@t09tanaka/test-gates 0.4.2 → 0.5.0

package/dist/cli.js

@@ -28,7 +28,7 @@ function parseShard(value) {
 }
 var OPTIONS_BY_COMMAND = {
   check: ["--dir"],
-  mutation: ["--dir", "--gate", "--affected"],
+  mutation: ["--dir", "--gate", "--shard", "--affected"],
   "mutation-result": ["--dir", "--report"],
   selfcheck: ["--dir", "--all", "--first", "--gate", "--shard", "--quick", "--jobs"],
   lcov: ["--dir", "--file"],
@@ -146,13 +146,18 @@ function parseArgs(argv) {
       "--affected and --gate cannot be combined: --gate runs the gates it names, --affected decides which gates run"
     );
   }
+  if (parsed.affected && parsed.shard !== null) {
+    throw new UsageError(
+      "--affected and --shard cannot be combined: --shard runs every mutant of its gates, --affected decides which gates run"
+    );
+  }
   const misplaced = parsed.rest.find((arg) => /^--(gate|shard|quick|jobs)(=|$)/.test(arg));
   if (parsed.command === "selfcheck" && misplaced !== void 0) {
     throw new UsageError(
       `${misplaced.split("=")[0]} after "--" would go to the gate command. Write it before "--"`
     );
   }
-  const forStryker = parsed.rest.find((arg) => /^--(gate|affected)(=|$)/.test(arg));
+  const forStryker = parsed.rest.find((arg) => /^--(gate|shard|affected)(=|$)/.test(arg));
   if (forStryker !== void 0) {
     throw new UsageError(
       `${forStryker.split("=")[0]} after "--" would go to Stryker. Write it before "--"`
@@ -1034,13 +1039,13 @@ function judgeSelfcheck(input) {
 function selectControls(input) {
   const { gates, mode, only, shard } = input;
   if (only.length > 0) {
-    const unknown = only.filter((path13) => !gates.includes(path13));
+    const unknown = only.filter((path15) => !gates.includes(path15));
     if (unknown.length > 0) {
       return {
         error: `--gate ${unknown.join(", ")}: not a gate of test-gates.json (write the path as it is written there)`
       };
     }
-    return { selected: gates.filter((path13) => only.includes(path13)) };
+    return { selected: gates.filter((path15) => only.includes(path15)) };
   }
   if (shard !== null) {
     if (shard.total > gates.length) {
@@ -1083,6 +1088,12 @@ function gateRunRefused(env) {
 function affectedRefused(env) {
   return inCi(env) ? "CI is set, and there every mutant is run (the final check)" : null;
 }
+function shardRunCaveat(shard, judged, all) {
+  if (shard.total === 1) {
+    return `. All ${all} gate(s) were run and judged (--shard 1/1 is the only part)`;
+  }
+  return `. Only part ${shard.index}/${shard.total} (${judged} of ${all} gate(s)) was run and judged (--shard): every part has to pass for the final check`;
+}
 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`;
 }
@@ -1193,8 +1204,8 @@ function planControls(input) {
   if (silent !== void 0) {
     return everyoneAlone(`the gate run left no note for the spec of ${silent.path}`);
   }
-  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");
+  const partsOf3 = (gate) => notes.flatMap((note) => gate.file in note.files ? [note.files[gate.file]] : []);
+  const short = all.find((gate) => accountedFor(totals[gate.file], partsOf3(gate)) === "no");
   if (short !== void 0) {
     return everyoneAlone(
       `the notes of the specs do not add up to what the runner counted for ${short.path}`
@@ -1208,7 +1219,7 @@ function planControls(input) {
     if (all.some((other) => other.path !== gate.path && other.path.includes(gate.path))) {
       return false;
     }
-    if (accountedFor(totals[gate.file], partsOf2(gate)) !== "yes") {
+    if (accountedFor(totals[gate.file], partsOf3(gate)) !== "yes") {
       return false;
     }
     const touching = notes.filter((note) => {
@@ -1419,9 +1430,9 @@ function runCheck(dir, io2) {
 }
 
 // src/commands/doctor.ts
-import { spawnSync as spawnSync3 } from "child_process";
-import fs9 from "fs";
-import path9 from "path";
+import { spawnSync as spawnSync5 } from "child_process";
+import fs11 from "fs";
+import path11 from "path";
 
 // src/core/mutation-result.ts
 var DETECTED = /* @__PURE__ */ new Set(["Killed", "Timeout"]);
@@ -1688,6 +1699,80 @@ function judgeMutationReport(input) {
   }
   return { violations, survivors, unexpectedTimeouts, summary };
 }
+var UNKNOWN_TEST = "not-in-the-first-run:";
+function sameMutant(a, b) {
+  return a.mutatorName === b.mutatorName && (a.replacement ?? "") === (b.replacement ?? "") && a.location.start.line === b.location.start.line && a.location.start.column === b.location.start.column && a.location.end.line === b.location.end.line && a.location.end.column === b.location.end.column;
+}
+function mergeRetry(first, retry, gates) {
+  const outcome = { retried: 0, statuses: {}, missing: 0 };
+  const firstId = translator(first, retry);
+  const files = { ...first.files };
+  const again = retry.files ?? {};
+  for (const named of gates) {
+    const gate = named.path.split("/").filter((part) => part !== ".").join("/");
+    const result = Object.hasOwn(files, gate) ? files[gate] : void 0;
+    if (result?.mutants === void 0) {
+      continue;
+    }
+    const expected = expectedTimeoutMutants(named, result.source, result.mutants);
+    const rerun = Object.hasOwn(again, gate) ? again[gate]?.mutants : void 0;
+    files[gate] = {
+      ...result,
+      mutants: result.mutants.map((mutant) => {
+        if (mutant.status !== "Timeout" || expected.has(mutant)) {
+          return mutant;
+        }
+        outcome.retried += 1;
+        const found = rerun?.find((other) => sameMutant(other, mutant));
+        if (found === void 0) {
+          outcome.missing += 1;
+          return mutant;
+        }
+        outcome.statuses[found.status] = (outcome.statuses[found.status] ?? 0) + 1;
+        return {
+          ...found,
+          ...found.coveredBy === void 0 ? {} : { coveredBy: found.coveredBy.map(firstId) },
+          ...found.killedBy === void 0 ? {} : { killedBy: found.killedBy.map(firstId) }
+        };
+      })
+    };
+  }
+  return { report: { ...first, files }, outcome };
+}
+function testKey(file, test) {
+  const start = test.location?.start;
+  return JSON.stringify([file, test.name ?? "", start?.line, start?.column]);
+}
+function* keyedTests(report) {
+  for (const [file, entry] of Object.entries(report.testFiles ?? {})) {
+    if (entry.tests !== void 0) {
+      for (const test of entry.tests) {
+        yield { id: test.id, key: testKey(file, test) };
+      }
+    }
+  }
+}
+function translator(first, retry) {
+  const firstIds = /* @__PURE__ */ new Map();
+  for (const { id, key } of keyedTests(first)) {
+    firstIds.set(key, firstIds.has(key) ? null : id);
+  }
+  const ids = /* @__PURE__ */ new Map();
+  for (const { id, key } of keyedTests(retry)) {
+    ids.set(id, firstIds.get(key));
+  }
+  return (id) => {
+    const found = ids.get(id);
+    return typeof found === "string" ? found : `${UNKNOWN_TEST}${id}`;
+  };
+}
+function formatRetry(outcome) {
+  const statuses = Object.entries(outcome.statuses).sort(([a], [b]) => a.localeCompare(b)).map(([status, count]) => `${count} ${status}`);
+  if (outcome.missing > 0) {
+    statuses.push(`${outcome.missing} not in the report (still Timeout)`);
+  }
+  return `test-gates mutation: ${outcome.retried} mutant(s) that timed out were run again one at a time (--concurrency 1): ${statuses.join(", ")}`;
+}
 function formatSurvivor(survivor) {
   const occurrence = survivor.sameKeyCount > 1 ? ` / occurrence ${survivor.occurrence} of ${survivor.sameKeyCount}` : "";
   return `${survivor.file}:${survivor.line}:${survivor.column} / ${survivor.mutator} / ${survivor.original} \u2192 ${survivor.replacement}${occurrence} (${survivor.status})`;
@@ -1697,7 +1782,7 @@ function formatSummary(summary) {
 }
 
 // src/core/reuse-guard.ts
-var RECORD_FORMAT = 2;
+var RECORD_FORMAT = 3;
 function isStringRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) && Object.values(value).every((entry) => typeof entry === "string");
 }
@@ -1709,11 +1794,14 @@ function parseAffected(value) {
   }
   const parsed = /* @__PURE__ */ Object.create(null);
   for (const [gate, entry] of Object.entries(gates)) {
-    const { specs, files } = entry ?? {};
+    const { specs, files, blind } = entry ?? {};
     if (!isStringList(specs) || !isStringList(files)) {
       return null;
     }
-    parsed[gate] = { specs, files };
+    if (blind !== void 0 && typeof blind !== "string") {
+      return null;
+    }
+    parsed[gate] = { specs, files, ...blind === void 0 ? {} : { blind } };
   }
   return { tests, gates: parsed };
 }
@@ -1876,7 +1964,8 @@ var CONFIG_NAMES = [
   /\.d\.[cm]?ts$/
 ];
 var ROOT_MOCKS = "__mocks__";
-var DOCUMENT = /\.(?:md|markdown|txt|rst|adoc)$/i;
+var DOCUMENT = /\.(?:md|markdown|txt|rst|adoc|html?)$/i;
+var ENTRY_PAGE = /^index\.html?$/i;
 var PASSIVE = /\.(?:[cm]?[jt]sx?|json|snap|css|scss|sass|less|svg|png|jpe?g|gif|webp|avif|ico)$/i;
 function kindOf(key, subproject) {
   const segments = localSegments(key, subproject);
@@ -1887,7 +1976,7 @@ function kindOf(key, subproject) {
   if (isNestedMock(key, subproject)) {
     return "other";
   }
-  if (DOCUMENT.test(name)) {
+  if (DOCUMENT.test(name) && !ENTRY_PAGE.test(name)) {
     return "document";
   }
   const inside = subproject === "" || key.startsWith(`${subproject}/`);
@@ -1904,6 +1993,7 @@ function isNestedMock(key, subproject) {
 }
 function gateDependencies(input) {
   const closureOf = (key) => Object.hasOwn(input.closures, key) ? input.closures[key] : [key];
+  const blind = input.blind ?? {};
   const result = /* @__PURE__ */ Object.create(null);
   for (const gate of input.gates) {
     const covering = Object.hasOwn(input.covering, gate.key) ? input.covering[gate.key] : [];
@@ -1917,7 +2007,13 @@ function gateDependencies(input) {
     for (const spec of specs) {
       closureOf(spec).forEach((file) => files.add(file));
     }
-    result[gate.key] = { specs: [...specs].sort(), files: [...files].sort() };
+    const sorted2 = [...files].sort();
+    const reason = sorted2.find((file) => Object.hasOwn(blind, file));
+    result[gate.key] = {
+      specs: [...specs].sort(),
+      files: sorted2,
+      ...reason === void 0 ? {} : { blind: blind[reason] }
+    };
   }
   return result;
 }
@@ -1948,6 +2044,15 @@ function planAffected(input) {
       rerun.push({ gate: gate.path, changed: [] });
       continue;
     }
+    const blind = gate.blind ?? last.blind;
+    if (blind !== void 0) {
+      if (changed.length > 0 || input.seeded === true) {
+        rerun.push({ gate: gate.path, changed, blind });
+      } else {
+        reused.push(gate.path);
+      }
+      continue;
+    }
     const files = [.../* @__PURE__ */ new Set([...last.files, ...gate.files])];
     const differing = files.filter((file) => input.before.files[file] !== input.now[file]).sort();
     if (differing.length > 0) {
@@ -1999,13 +2104,23 @@ function describePlan(plan, shown = 5, timeouts = 0, expected = 0) {
   const lines = [
     `test-gates mutation --affected: ${plan.reused.length} of ${total} gate(s) reused, ${plan.rerun.length} run again`
   ];
-  for (const { gate, changed } of plan.rerun.slice(0, shown)) {
+  const told = plan.rerun.filter((entry) => entry.blind === void 0);
+  for (const { gate, changed } of told.slice(0, shown)) {
     lines.push(
       changed.length === 0 ? `  ${gate}: the last run left no result of it that can be reused` : `  ${gate}: changed ${listed(changed)}`
     );
   }
-  if (plan.rerun.length > shown) {
-    lines.push(`  and ${plan.rerun.length - shown} more`);
+  if (told.length > shown) {
+    lines.push(`  and ${told.length - shown} more`);
+  }
+  const reasons = [
+    ...new Set(plan.rerun.flatMap((entry) => entry.blind === void 0 ? [] : [entry.blind]))
+  ];
+  if (reasons.length > 0) {
+    const more = reasons.length > 1 ? ` (and ${reasons.length - 1} more reason(s))` : "";
+    lines.push(
+      `  ${plan.rerun.length - told.length} gate(s) run again for any change, as what they depend on cannot be told: ${reasons[0]}${more}`
+    );
   }
   if (timeouts > 0) {
     lines.push(`  and ${timeouts} mutant(s) of reused gates that timed out in the last run`);
@@ -2052,12 +2167,22 @@ function diagnose(facts) {
       fix: "write such a path from the directory of its file (path.resolve(__dirname, \u2026)) so that it can be followed, or keep it out of the files the run loads"
     });
   }
+  const everyBlind = facts.blindGates.length >= facts.gates;
   if (facts.blind !== null) {
     findings.push({
       level: facts.hooks.some((hook) => hook.affected) ? "problem" : "note",
       text: `with --affected, a change of any file runs every mutant: what a gate depends on cannot be told (${facts.blind})`,
       fix: "keep what reads files or loads modules by a computed name out of what the gates and their specs import, or run without --affected"
     });
+  } else if (facts.blindGates.length > 0) {
+    const gates = facts.blindGates.map((one) => one.gate);
+    const reasons = [...new Set(facts.blindGates.map((one) => one.reason))];
+    const more = reasons.length > 1 ? ` (and ${reasons.length - 1} more reason(s))` : "";
+    findings.push({
+      level: everyBlind && facts.hooks.some((hook) => hook.affected) ? "problem" : "note",
+      text: `with --affected, a change of any file runs ${gates.length} of ${facts.gates} gate(s) again (${listed(gates)}): what they depend on cannot be told (${reasons[0]}${more})`,
+      fix: "keep what reads files by a path no import names out of what those gates and their specs import"
+    });
   }
   if (facts.scope !== null && "every" in facts.scope) {
     findings.push({
@@ -2066,6 +2191,21 @@ function diagnose(facts) {
       fix: facts.scope.every.startsWith(NOT_THE_HELPER) ? "make the runner config with createJestGatesConfig or createVitestGatesConfig" : null
     });
   }
+  if (facts.sandboxes !== null) {
+    const { tempDir, count, kept, running } = facts.sandboxes;
+    findings.push(
+      running === null ? {
+        level: "note",
+        text: `${count} sandbox(es) an interrupted Stryker run left in ${tempDir}: a tool that walks the subproject (a test runner, a script) finds a copy of every file in them`,
+        fix: kept === null ? "the next test-gates mutation removes them" : `remove them by hand; the next test-gates mutation keeps them, because ${kept}`
+      } : {
+        // The sandboxes may be those of that run: removing them would break it.
+        level: "note",
+        text: `another test-gates mutation is running in this subproject (pid ${running}): the ${count} sandbox(es) in ${tempDir} are in use`,
+        fix: "leave them; the first test-gates mutation after that run ends removes what is left"
+      }
+    );
+  }
   if (facts.hooks.length === 0) {
     findings.push({
       level: "note",
@@ -2073,7 +2213,8 @@ function diagnose(facts) {
       fix: null
     });
   }
-  for (const hook of facts.hooks.filter((one) => !one.affected && facts.blind === null)) {
+  const toldApart = facts.blind === null && !everyBlind;
+  for (const hook of facts.hooks.filter((one) => !one.affected && toldApart)) {
     findings.push({
       level: "problem",
       text: `${hook.file} runs test-gates mutation without --affected: a change of any file of the subproject runs every mutant`,
@@ -2099,39 +2240,322 @@ function formatFindings(findings) {
 var RUNS_MUTATION = /(?<![\w-])test-gates(?:\.js)?\s+mutation(?![\w-])|(?<![\w:-])test:gates:mutation(?![\w:-])/;
 var TARGET = /(?:--dir|--prefix|--workspace|-w)(?:=|\s+)(['"]?)([^\s'";&|)]+)\1/;
 var CD = /\bcd\s+(['"]?)([^\s'";&|)]+)\1/;
+var NONE = [];
+var COMMAND = String.raw`(?<=(?:^|[\n;&|(){]|\b(?:then|else|do))\s*)`;
+var TOKEN = new RegExp(
+  String.raw`\n|;;&?|;&|${COMMAND}(?:case\s+(\S+)\s+in|for\s+(\w+)(?:\s+in\s+([^;\n]*))?|(esac|do|done))(?![\w-])`,
+  "g"
+);
+var PATTERN = /\s*(?:esac(?![\w-])|\(?([^()\n;]*)\))/y;
+var VARIABLE = /^("?)\$(?:(\w+)|\{(\w+)\})\1$/;
+var REFERENCE = /\$(?:(\w+)|\{(\w+)\})/g;
+function namesOf(words) {
+  const names = words.map((word) => word.trim().replace(/^(["'])(.*)\1$/, "$2"));
+  return names.some((name) => name === "" || /[$*?[{}~\\`"']/.test(name)) ? null : names;
+}
+function partsOf(text) {
+  const parts = [];
+  let scopes = NONE;
+  let start = 0;
+  let loop = null;
+  const enter = (scope) => {
+    scopes = [...scopes, scope];
+  };
+  const leave = (kind) => {
+    const left = scopes.at(-1)?.kind === kind;
+    scopes = scopes.slice(0, -1);
+    return left;
+  };
+  TOKEN.lastIndex = 0;
+  for (; ; ) {
+    const token = TOKEN.exec(text);
+    parts.push({ text: text.slice(start, token?.index), scopes });
+    if (token === null) {
+      return scopes.length === 0 ? parts : null;
+    }
+    const [word, subject, variable, list, keyword] = token;
+    let awaiting = false;
+    if (subject !== void 0) {
+      const named = VARIABLE.exec(subject);
+      enter({
+        kind: "case",
+        id: /* @__PURE__ */ Symbol(),
+        variable: named?.[2] ?? named?.[3] ?? null,
+        names: null
+      });
+      awaiting = true;
+    } else if (variable !== void 0) {
+      loop = {
+        kind: "loop",
+        id: /* @__PURE__ */ Symbol(),
+        variable,
+        names: list === void 0 ? null : namesOf(list.trim().split(/\s+/))
+      };
+    } else if (keyword === "do") {
+      enter(loop ?? { kind: "loop", id: /* @__PURE__ */ Symbol(), variable: null, names: null });
+      loop = null;
+    } else if (keyword === "done" || keyword === "esac") {
+      if (!leave(keyword === "done" ? "loop" : "case")) {
+        return null;
+      }
+    } else if (word === ";&") {
+      return null;
+    } else if (word !== "\n") {
+      if (scopes.at(-1)?.kind !== "case") {
+        return null;
+      }
+      awaiting = true;
+    }
+    start = TOKEN.lastIndex;
+    if (awaiting) {
+      PATTERN.lastIndex = start;
+      const pattern = PATTERN.exec(text);
+      if (pattern === null) {
+        return null;
+      }
+      start = PATTERN.lastIndex;
+      TOKEN.lastIndex = start;
+      const top = scopes.at(-1);
+      scopes = scopes.slice(0, -1);
+      if (pattern[1] !== void 0) {
+        enter({ ...top, names: namesOf(pattern[1].split("|")) });
+      }
+    }
+  }
+}
+function sibling(of, scopes) {
+  const apart = of.findIndex((scope, at) => scope !== scopes[at]);
+  return apart !== -1 && of[apart].id === scopes[apart]?.id;
+}
+function expansions(target, scopes) {
+  return [...target.matchAll(REFERENCE)].reduce(
+    (words, [reference, plain2, braced]) => {
+      const names = [...scopes].reverse().find((scope) => scope.variable === (plain2 ?? braced))?.names ?? [reference];
+      return words.flatMap((word) => names.map((name) => word.replace(reference, name)));
+    },
+    [target]
+  );
+}
 function hookUses(input) {
   const lines = input.text.split("\n").map((line) => line.replace(/(?:^|\s)#.*/, ""));
+  const parts = partsOf(lines.join("\n")) ?? lines.map((text) => ({ text, scopes: NONE }));
   const uses = [];
-  lines.forEach((line, index) => {
-    if (!RUNS_MUTATION.test(line)) {
+  const cds = parts.map((part) => ({ cd: CD.exec(part.text)?.[2], scopes: part.scopes }));
+  parts.forEach((part, index) => {
+    if (!RUNS_MUTATION.test(part.text)) {
       return;
     }
-    const named = TARGET.exec(line) ?? CD.exec(line);
-    const target = named?.[2] ?? lines.slice(0, index).reverse().map((before) => CD.exec(before)?.[2]).find((found) => found !== void 0);
-    const normalized = target?.split("/").filter((part) => part !== "." && part !== "").join("/");
-    const ours = normalized === void 0 || normalized.includes("$") || normalized.includes("..") || normalized === input.subproject;
+    const named = TARGET.exec(part.text) ?? CD.exec(part.text);
+    const before = cds.slice(0, index).reverse().find((one) => one.cd !== void 0 && !sibling(one.scopes, part.scopes));
+    const target = named?.[2] ?? before?.cd;
+    const scopes = named !== null || before?.scopes === part.scopes ? part.scopes : NONE;
+    const ours = target === void 0 || expansions(target, scopes).some((word) => {
+      const normalized = word.split("/").filter((one) => one !== "." && one !== "").join("/");
+      return normalized.includes("$") || normalized.includes("..") || normalized === input.subproject;
+    });
     if (ours) {
       uses.push({
         file: input.file,
-        affected: /--affected\b/.test(line) || /test:gates:mutation\b/.test(line) && input.script.includes("--affected")
+        affected: /--affected\b/.test(part.text) || /test:gates:mutation\b/.test(part.text) && input.script.includes("--affected")
       });
     }
   });
   return uses;
 }
 
-// src/snapshot.ts
+// src/sandboxes.ts
 import { spawnSync } from "child_process";
+import fs4 from "fs";
+import path4 from "path";
+
+// src/core/sandboxes.ts
+var SANDBOX = /^sandbox-[A-Za-z0-9]{6}$/;
+var MARKER = /^test-gates-run-([1-9][0-9]*)$/;
+function markerName(pid) {
+  return `test-gates-run-${pid}`;
+}
+function markerText(pid, started) {
+  return `${pid}
+${started ?? ""}
+`;
+}
+function markerAlive(input) {
+  const recorded = input.text?.split("\n")[1]?.trim() || null;
+  return input.there && (recorded === null || input.started === null || sameStart(recorded, input.started));
+}
+var START_SLACK_SECONDS = 5;
+function sameStart(a, b) {
+  const difference = Math.abs(Date.parse(a) - Date.parse(b));
+  return Number.isNaN(difference) ? a === b : difference <= START_SLACK_SECONDS * 1e3;
+}
+function insideSubproject(tempDir) {
+  const parts = tempDir.split("/");
+  return !/^[A-Za-z]:/.test(tempDir) && parts.every((part) => part !== "" && part !== "." && part !== "..");
+}
+function planSandboxes(facts) {
+  const sandboxes = facts.entries.filter((entry) => entry.directory && SANDBOX.test(entry.name)).map((entry) => entry.name).sort();
+  if (facts.tempDir === null) {
+    return {
+      kept: sandboxes,
+      why: "the Stryker config could not be loaded to see where they are",
+      running: null
+    };
+  }
+  if (!insideSubproject(facts.tempDir)) {
+    return {
+      kept: sandboxes,
+      why: `tempDirName (${facts.tempDir}) is not a directory inside the subproject`,
+      running: null
+    };
+  }
+  if (facts.keeps) {
+    return { kept: sandboxes, why: "the Stryker config sets cleanTempDir: false", running: null };
+  }
+  const markers = [];
+  for (const entry of facts.entries) {
+    const pid = MARKER.exec(entry.name)?.[1];
+    if (pid === void 0 || entry.directory) {
+      continue;
+    }
+    if (facts.alive(Number(pid), entry.name)) {
+      return {
+        kept: sandboxes,
+        why: `another test-gates mutation is running in this subproject (pid ${pid})`,
+        running: Number(pid)
+      };
+    }
+    markers.push(entry.name);
+  }
+  return { remove: sandboxes, markers };
+}
+
+// src/sandboxes.ts
+function there(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+function startedAt(pid) {
+  const result = spawnSync("ps", ["-o", "lstart=", "-p", String(pid)], {
+    encoding: "utf8",
+    env: { ...process.env, LC_ALL: "C" },
+    timeout: 5e3
+  });
+  const started = result.status === 0 ? result.stdout.trim() : "";
+  return started === "" ? null : started;
+}
+function alive(dir) {
+  return (pid, marker) => {
+    if (!there(pid)) {
+      return false;
+    }
+    let text = null;
+    try {
+      text = fs4.readFileSync(path4.join(dir, marker), "utf8");
+    } catch {
+    }
+    return markerAlive({ there: true, text, started: startedAt(pid) });
+  };
+}
+function relativeTempDir(subproject, dir) {
+  let real = dir;
+  try {
+    real = fs4.realpathSync(dir);
+  } catch {
+  }
+  return path4.relative(fs4.realpathSync(subproject), real).split(path4.sep).join("/");
+}
+function sandboxPlan(subproject, setting) {
+  const tempDir = setting.dir === null ? null : relativeTempDir(subproject, setting.dir);
+  let entries = [];
+  if (setting.dir !== null) {
+    try {
+      entries = fs4.readdirSync(setting.dir, { withFileTypes: true });
+    } catch {
+    }
+  }
+  const plan = planSandboxes({
+    tempDir,
+    entries: entries.map((entry) => ({ name: entry.name, directory: entry.isDirectory() })),
+    keeps: setting.keeps,
+    alive: alive(setting.dir ?? subproject)
+  });
+  return { plan, shown: tempDir ?? ".stryker-tmp" };
+}
+function removeStaleSandboxes(subproject, setting) {
+  const { plan, shown } = sandboxPlan(subproject, setting);
+  if ("kept" in plan) {
+    if (plan.kept.length === 0) {
+      return [];
+    }
+    return plan.running === null ? [
+      `test-gates mutation: ${plan.kept.length} sandbox(es) left in ${shown} by an earlier Stryker run are kept: ${plan.why}`
+    ] : [
+      `test-gates mutation: ${plan.why}, so the ${plan.kept.length} sandbox(es) in ${shown} are kept: they are in use`
+    ];
+  }
+  const dir = setting.dir;
+  for (const marker of plan.markers) {
+    try {
+      fs4.rmSync(path4.join(dir, marker), { force: true });
+    } catch {
+    }
+  }
+  const failed = [];
+  for (const sandbox of plan.remove) {
+    try {
+      fs4.rmSync(path4.join(dir, sandbox), { recursive: true, force: true });
+    } catch (error) {
+      failed.push(`${sandbox} (${error.message})`);
+    }
+  }
+  const removed = plan.remove.length - failed.length;
+  return [
+    ...removed > 0 ? [
+      `test-gates mutation: removed ${removed} sandbox(es) an earlier Stryker run left in ${shown}`
+    ] : [],
+    ...failed.length > 0 ? [`test-gates mutation: could not remove from ${shown}: ${failed.join(", ")}`] : []
+  ];
+}
+function markRun(subproject, setting) {
+  const dir = setting.dir;
+  if (dir === null || !insideSubproject(relativeTempDir(subproject, dir))) {
+    return () => void 0;
+  }
+  const marker = path4.join(dir, markerName(process.pid));
+  try {
+    fs4.mkdirSync(dir, { recursive: true });
+    if (!insideSubproject(relativeTempDir(subproject, dir))) {
+      return () => void 0;
+    }
+    fs4.writeFileSync(marker, markerText(process.pid, startedAt(process.pid)));
+  } catch {
+    return () => void 0;
+  }
+  return () => {
+    try {
+      fs4.rmSync(marker, { force: true });
+      fs4.rmdirSync(dir);
+    } catch {
+    }
+  };
+}
+
+// src/snapshot.ts
+import { spawnSync as spawnSync2 } from "child_process";
 import { createHash } from "crypto";
-import fs5 from "fs";
+import fs6 from "fs";
 import { createRequire } from "module";
 import os from "os";
-import path5 from "path";
+import path6 from "path";
 
 // src/commands/loaded-files.ts
-import fs4 from "fs";
+import fs5 from "fs";
 import { builtinModules } from "module";
-import path4 from "path";
+import path5 from "path";
 var SCRIPT = /\.[cm]?[jt]sx?$/;
 var COMPONENT = /\.(?:vue|svelte|astro|mdx)$/;
 var EXTENSIONS = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"];
@@ -2139,7 +2563,7 @@ var QUOTED = /(['"`])([^'"`\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, { throwIfNoEntry: false })?.isFile() === true;
+    return fs5.statSync(file, { throwIfNoEntry: false })?.isFile() === true;
   } catch {
     return false;
   }
@@ -2172,9 +2596,9 @@ function filesOf(base, directory, declarations) {
     ...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}`)) : []
+    ...directory ? extensions.map((extension) => path5.join(base, `index${extension}`)) : []
   ];
-  const data = [`${base}.json`, ...directory ? [path4.join(base, "index.json")] : []];
+  const data = [`${base}.json`, ...directory ? [path5.join(base, "index.json")] : []];
   const scripts = [.../* @__PURE__ */ new Set([base, ...candidates(EXTENSIONS), ...data])].filter(isFile);
   return scripts.length > 0 || !declarations ? scripts : [...new Set(candidates(DECLARATIONS))].filter(isFile);
 }
@@ -2183,11 +2607,11 @@ function resolveFile(base, directory = true, declarations = true) {
 }
 function installed(specifier, from) {
   const name = specifier.split("/").slice(0, specifier.startsWith("@") ? 2 : 1).join("/");
-  for (let current = path4.dirname(from); ; current = path4.dirname(current)) {
-    if (fs4.existsSync(path4.join(current, "node_modules", name))) {
+  for (let current = path5.dirname(from); ; current = path5.dirname(current)) {
+    if (fs5.existsSync(path5.join(current, "node_modules", name))) {
       return true;
     }
-    if (current === path4.dirname(current)) {
+    if (current === path5.dirname(current)) {
       return false;
     }
   }
@@ -2197,18 +2621,18 @@ function loadedFiles(manifest, configFile) {
 }
 function loadedFilesNow(manifest, configFile) {
   const aliases = manifest.settings.importAliases;
-  const relative = (file) => path4.relative(manifest.dir, file).split(path4.sep).join("/");
+  const relative = (file) => path5.relative(manifest.dir, file).split(path5.sep).join("/");
   const target = (specifier, from) => {
     if (specifier.startsWith(".")) {
-      return resolveFiles(path4.resolve(path4.dirname(from), specifier));
+      return resolveFiles(path5.resolve(path5.dirname(from), specifier));
     }
     const alias = aliases.find((candidate) => specifier.startsWith(candidate.prefix));
     return alias === void 0 ? [] : resolveFiles(
-      path4.resolve(manifest.dir, alias.target + specifier.slice(alias.prefix.length))
+      path5.resolve(manifest.dir, alias.target + specifier.slice(alias.prefix.length))
     );
   };
   const read2 = (file) => {
-    const source = fs4.readFileSync(file, "utf8");
+    const source = fs5.readFileSync(file, "utf8");
     const imports = parseImports(source).filter((ref) => !ref.typeOnly);
     const specifiers = [
       .../* @__PURE__ */ new Set([
@@ -2220,7 +2644,7 @@ function loadedFilesNow(manifest, configFile) {
     return { source, specifiers, strings };
   };
   const named = /* @__PURE__ */ new Set();
-  const configs = configFile === null ? [] : [path4.resolve(manifest.dir, configFile)];
+  const configs = configFile === null ? [] : [path5.resolve(manifest.dir, configFile)];
   const seenConfigs = new Set(configs);
   const entry = configs[0];
   for (let file = configs.shift(); file !== void 0; file = configs.shift()) {
@@ -2228,8 +2652,8 @@ function loadedFilesNow(manifest, configFile) {
     const paths = strings.filter((text) => file === entry || /^(?:\.|<rootDir>\/)/.test(text));
     for (const text of paths) {
       const stripped = text.replace(/^<rootDir>\//, "");
-      const here = resolveFiles(path4.resolve(path4.dirname(file), stripped), false);
-      const found = here.length > 0 ? here : resolveFiles(path4.resolve(manifest.dir, stripped), false);
+      const here = resolveFiles(path5.resolve(path5.dirname(file), stripped), false);
+      const found = here.length > 0 ? here : resolveFiles(path5.resolve(manifest.dir, stripped), false);
       for (const one of found.filter((candidate) => SCRIPT.test(candidate))) {
         named.add(one);
       }
@@ -2270,7 +2694,7 @@ function loadedFilesNow(manifest, configFile) {
       }
     }
     for (const text of strings.filter((one) => one.startsWith("."))) {
-      next.push(...resolveFiles(path4.resolve(path4.dirname(file), text)));
+      next.push(...resolveFiles(path5.resolve(path5.dirname(file), text)));
     }
     const visited = {
       file: { path: relative(file), source, imports },
@@ -2300,7 +2724,7 @@ function loadedFilesNow(manifest, configFile) {
   const specs = [...new Set(manifest.gates.flatMap((gate) => gate.existingSpecs))];
   const roots = [
     closure(null, [...named]),
-    ...specs.map((spec) => closure(spec, [path4.join(manifest.dir, spec)]))
+    ...specs.map((spec) => closure(spec, [path5.join(manifest.dir, spec)]))
   ];
   return { files: [...known.values()].map((visited) => visited.file), roots };
 }
@@ -2352,17 +2776,17 @@ function hashOf(content) {
 }
 function hashFile(file) {
   try {
-    return hashOf(fs5.readFileSync(file));
+    return hashOf(fs6.readFileSync(file));
   } catch {
     return null;
   }
 }
 function isInside(parent, child) {
-  const relative = path5.relative(parent, child);
-  return relative === "" || !relative.startsWith("..") && !path5.isAbsolute(relative);
+  const relative = path6.relative(parent, child);
+  return relative === "" || !relative.startsWith("..") && !path6.isAbsolute(relative);
 }
 function toPosix(file) {
-  return file.split(path5.sep).join("/");
+  return file.split(path6.sep).join("/");
 }
 function gitEnvironment(env) {
   if (env.GIT_DIR === void 0 || env.GIT_WORK_TREE !== void 0) {
@@ -2373,7 +2797,7 @@ function gitEnvironment(env) {
   return rest;
 }
 function git(cwd, args) {
-  const result = spawnSync("git", args, {
+  const result = spawnSync2("git", args, {
     cwd,
     env: gitEnvironment(process.env),
     encoding: "utf8",
@@ -2386,7 +2810,7 @@ function globLiteral(relative) {
 }
 function gitLister(root) {
   return (directory, recursive) => {
-    const relative = globLiteral(toPosix(path5.relative(root, directory)));
+    const relative = globLiteral(toPosix(path6.relative(root, directory)));
     const pattern = recursive ? `${relative === "" ? "" : `${relative}/`}**` : `${relative === "" ? "" : `${relative}/`}*`;
     const listed2 = git(root, [
       "ls-files",
@@ -2405,8 +2829,8 @@ function gitLister(root) {
 }
 function walkLister(root) {
   const walk = (directory, recursive, found) => {
-    for (const entry of fs5.readdirSync(directory, { withFileTypes: true })) {
-      const file = path5.join(directory, entry.name);
+    for (const entry of fs6.readdirSync(directory, { withFileTypes: true })) {
+      const file = path6.join(directory, entry.name);
       if (NEVER.includes(entry.name)) {
         continue;
       }
@@ -2415,7 +2839,7 @@ function walkLister(root) {
           walk(file, true, found);
         }
       } else {
-        found.push(toPosix(path5.relative(root, file)));
+        found.push(toPosix(path6.relative(root, file)));
       }
     }
     return found;
@@ -2425,16 +2849,16 @@ function walkLister(root) {
 function upTo(from, to) {
   const directories = [from];
   while (directories[directories.length - 1] !== to) {
-    directories.push(path5.dirname(directories[directories.length - 1]));
+    directories.push(path6.dirname(directories[directories.length - 1]));
   }
   return directories;
 }
 function declaresWorkspaces(directory) {
-  if (fs5.existsSync(path5.join(directory, "pnpm-workspace.yaml"))) {
+  if (fs6.existsSync(path6.join(directory, "pnpm-workspace.yaml"))) {
     return true;
   }
   try {
-    const manifest = JSON.parse(fs5.readFileSync(path5.join(directory, "package.json"), "utf8"));
+    const manifest = JSON.parse(fs6.readFileSync(path6.join(directory, "package.json"), "utf8"));
     return manifest.workspaces !== void 0;
   } catch {
     return false;
@@ -2442,7 +2866,7 @@ function declaresWorkspaces(directory) {
 }
 function walkRoot(dir) {
   const candidates = withinBounds(dir);
-  const repository = candidates.find((directory) => fs5.existsSync(path5.join(directory, ".git")));
+  const repository = candidates.find((directory) => fs6.existsSync(path6.join(directory, ".git")));
   if (repository !== void 0) {
     return repository;
   }
@@ -2451,11 +2875,11 @@ function walkRoot(dir) {
 function withinBounds(dir) {
   let home = null;
   try {
-    home = fs5.realpathSync(os.homedir());
+    home = fs6.realpathSync(os.homedir());
   } catch {
   }
-  return upTo(dir, path5.parse(dir).root).filter(
-    (directory) => directory !== path5.parse(dir).root && (home === null || !isInside(directory, home))
+  return upTo(dir, path6.parse(dir).root).filter(
+    (directory) => directory !== path6.parse(dir).root && (home === null || !isInside(directory, home))
   );
 }
 function linkedPackages(nodeModules, root) {
@@ -2463,20 +2887,20 @@ function linkedPackages(nodeModules, root) {
   const visit = (directory, depth) => {
     let entries;
     try {
-      entries = fs5.readdirSync(directory, { withFileTypes: true });
+      entries = fs6.readdirSync(directory, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
-      const file = path5.join(directory, entry.name);
+      const file = path6.join(directory, entry.name);
       if (entry.isSymbolicLink()) {
         let target;
         try {
-          target = fs5.realpathSync(file);
+          target = fs6.realpathSync(file);
         } catch {
           continue;
         }
-        if (target.split(path5.sep).includes("node_modules") || !fs5.statSync(target).isDirectory()) {
+        if (target.split(path6.sep).includes("node_modules") || !fs6.statSync(target).isDirectory()) {
           continue;
         }
         if (!isInside(root, target)) {
@@ -2498,11 +2922,11 @@ function installedVersion(start, name) {
   for (; ; ) {
     try {
       const manifest = JSON.parse(
-        fs5.readFileSync(path5.join(current, "node_modules", name, "package.json"), "utf8")
+        fs6.readFileSync(path6.join(current, "node_modules", name, "package.json"), "utf8")
       );
       return typeof manifest.version === "string" ? manifest.version : "unknown";
     } catch {
-      const parent = path5.dirname(current);
+      const parent = path6.dirname(current);
       if (parent === current) {
         return null;
       }
@@ -2511,7 +2935,7 @@ function installedVersion(start, name) {
   }
 }
 function nodeOnPath(cwd) {
-  const result = spawnSync("node", ["--version"], {
+  const result = spawnSync2("node", ["--version"], {
     cwd,
     encoding: "utf8",
     shell: process.platform === "win32",
@@ -2528,12 +2952,12 @@ function snapshotOf(input) {
   return resolving(() => snapshotNow(input));
 }
 function snapshotNow(input) {
-  const dir = fs5.realpathSync(input.dir);
+  const dir = fs6.realpathSync(input.dir);
   const top = git(dir, ["rev-parse", "--show-toplevel"]);
-  let root = top === null ? dir : fs5.realpathSync(top.trim());
+  let root = top === null ? dir : fs6.realpathSync(top.trim());
   let lister = gitLister(root);
   let mode = "git";
-  const manifest = toPosix(path5.relative(root, path5.join(dir, "test-gates.json")));
+  const manifest = toPosix(path6.relative(root, path6.join(dir, "test-gates.json")));
   if (top === null || !lister(dir, false).includes(manifest)) {
     mode = "walk";
     root = walkRoot(dir);
@@ -2541,17 +2965,17 @@ function snapshotNow(input) {
   }
   const listRoot = root;
   const list = lister;
-  const followed = input.scope === void 0 ? null : input.scope(list(dir, true).map((file) => path5.join(listRoot, file)));
+  const followed = input.scope === void 0 ? null : input.scope(list(dir, true).map((file) => path6.join(listRoot, file)));
   const walk = walkLister(listRoot);
   const written = input.written.map((file) => {
-    const target = path5.resolve(dir, file);
+    const target = path6.resolve(dir, file);
     try {
-      return fs5.realpathSync(target);
+      return fs6.realpathSync(target);
     } catch {
       return target;
     }
   });
-  const swallowing = written.find((target) => isInside(target, path5.join(dir, "test-gates.json")));
+  const swallowing = written.find((target) => isInside(target, path6.join(dir, "test-gates.json")));
   if (swallowing !== void 0) {
     throw new SnapshotError(`the run writes to ${swallowing}, which holds test-gates.json`);
   }
@@ -2568,12 +2992,12 @@ function snapshotNow(input) {
     if (!isInside(listRoot, directory)) {
       const written2 = reference === void 0 ? "" : ` with ${JSON.stringify(reference)}`;
       throw new SnapshotError(
-        `${toPosix(path5.relative(dir, from))} points outside of what can be listed${written2} (${directory})`
+        `${toPosix(path6.relative(dir, from))} points outside of what can be listed${written2} (${directory})`
       );
     }
     if (directory === listRoot && listRoot !== dir && widened.length < WIDENED_SHOWN) {
       const written2 = reference === void 0 ? "" : ` ${JSON.stringify(reference)}`;
-      widened.push(`${toPosix(path5.relative(listRoot, from))}${written2}`);
+      widened.push(`${toPosix(path6.relative(listRoot, from))}${written2}`);
     }
     if (![...queued].some((region) => isInside(region, directory))) {
       queued.add(directory);
@@ -2582,10 +3006,10 @@ function snapshotNow(input) {
   };
   const follow = (fixed, open, anchored, file, reference) => {
     const from = (start) => {
-      const target = path5.resolve(start, fixed);
+      const target = path6.resolve(start, fixed);
       let isDirectory2 = false;
       try {
-        isDirectory2 = fs5.statSync(target).isDirectory();
+        isDirectory2 = fs6.statSync(target).isDirectory();
       } catch {
       }
       return {
@@ -2594,9 +3018,9 @@ function snapshotNow(input) {
         found: isDirectory2 || resolveFile(target, true, false) !== null
       };
     };
-    const fromFile = from(path5.dirname(file));
+    const fromFile = from(path6.dirname(file));
     const targets = [fromFile];
-    if (!anchored && path5.dirname(file) !== dir) {
+    if (!anchored && path6.dirname(file) !== dir) {
       const fromRun = from(dir);
       if (fromRun.found && !fromFile.found) {
         targets[0] = fromRun;
@@ -2615,24 +3039,24 @@ function snapshotNow(input) {
         continue;
       }
       if (!isDirectory2 && !isInside(listRoot, target) && resolveFile(target, true, false) === null) {
-        files[toPosix(path5.relative(listRoot, target))] = "missing";
+        files[toPosix(path6.relative(listRoot, target))] = "missing";
         continue;
       }
-      const directory = isDirectory2 ? target : path5.dirname(target);
-      if (fs5.existsSync(directory)) {
+      const directory = isDirectory2 ? target : path6.dirname(target);
+      if (fs6.existsSync(directory)) {
         enqueue(directory, file, reference, anchored && !open);
       }
     }
   };
   const reached = /* @__PURE__ */ new Set();
   const reach = (file) => {
-    if (reached.has(file) || DOCUMENTS.includes(path5.extname(file).toLowerCase())) {
+    if (reached.has(file) || DOCUMENTS.includes(path6.extname(file).toLowerCase())) {
       return;
     }
     reached.add(file);
     let text;
     try {
-      const content = fs5.readFileSync(file);
+      const content = fs6.readFileSync(file);
       if (content.length > SCAN_LIMIT || content.subarray(0, 8e3).includes(0)) {
         return;
       }
@@ -2664,7 +3088,7 @@ function snapshotNow(input) {
       const end = (match.index ?? 0) + match[0].length;
       const open = match[3] === void 0 || /^\s*[,+.}[]/.test(text.slice(end, end + 200));
       const reference = match[0].slice(0, match[0].length - (match[3]?.length ?? 0));
-      follow(path5.posix.join(...segments), open, true, file, reference);
+      follow(path6.posix.join(...segments), open, true, file, reference);
     }
     for (const match of text.matchAll(UPWARD)) {
       const at = match.index ?? 0;
@@ -2684,35 +3108,35 @@ function snapshotNow(input) {
     }
   };
   const add = (relative) => {
-    const file = path5.join(listRoot, relative);
+    const file = path6.join(listRoot, relative);
     if (relative in files || written.some((target) => isInside(target, file))) {
       return;
     }
     let stat;
     try {
-      stat = fs5.lstatSync(file);
+      stat = fs6.lstatSync(file);
     } catch {
       files[relative] = "missing";
       return;
     }
     if (stat.isSymbolicLink()) {
-      files[relative] = `link ${fs5.readlinkSync(file)}`;
+      files[relative] = `link ${fs6.readlinkSync(file)}`;
       let target;
       try {
-        target = fs5.realpathSync(file);
+        target = fs6.realpathSync(file);
       } catch {
         return;
       }
-      enqueue(fs5.statSync(target).isDirectory() ? target : path5.dirname(target), file);
+      enqueue(fs6.statSync(target).isDirectory() ? target : path6.dirname(target), file);
     } else if (stat.isDirectory()) {
       files[relative] = "directory";
       walk(file, true).forEach(add);
     } else if (!stat.isFile()) {
       files[relative] = "special";
     } else {
-      const content = fs5.readFileSync(file);
+      const content = fs6.readFileSync(file);
       files[relative] = hashOf(content);
-      const document = DOCUMENTS.includes(path5.extname(file).toLowerCase());
+      const document = DOCUMENTS.includes(path6.extname(file).toLowerCase());
       const loaded = followed === null || !isInside(dir, file) || followed.has(file);
       if (loaded && !document && content.length <= SCAN_LIMIT && !content.subarray(0, 8e3).includes(0)) {
         scan(content.toString("utf8").replace(/\\[\\/]/g, "/"), file);
@@ -2723,32 +3147,32 @@ function snapshotNow(input) {
   const besideAncestors = /* @__PURE__ */ new Set();
   const ancestorFiles = ancestors.flatMap((directory) => list(directory, false));
   for (const relative of ancestorFiles) {
-    besideAncestors.add(path5.join(listRoot, relative));
+    besideAncestors.add(path6.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()) {
+    const patches = path6.join(directory, "patches");
+    if (fs6.existsSync(patches) && fs6.statSync(patches).isDirectory()) {
       enqueue(patches, directory);
     }
   }
   for (const directory of [dir, ...ancestors]) {
-    for (const linked of linkedPackages(path5.join(directory, "node_modules"), listRoot)) {
+    for (const linked of linkedPackages(path6.join(directory, "node_modules"), listRoot)) {
       if (!isInside(linked, dir)) {
-        enqueue(linked, path5.join(directory, "node_modules"));
+        enqueue(linked, path6.join(directory, "node_modules"));
       }
     }
   }
   const above = withinBounds(listRoot).slice(1);
   for (const directory of [dir, ...ancestors, ...above]) {
     const candidates = [
-      ...INSTALL_MARKERS.map((marker) => path5.join(directory, "node_modules", marker)),
-      ...above.includes(directory) ? LOCK_FILES.map((name) => path5.join(directory, name)) : []
+      ...INSTALL_MARKERS.map((marker) => path6.join(directory, "node_modules", marker)),
+      ...above.includes(directory) ? LOCK_FILES.map((name) => path6.join(directory, name)) : []
     ];
     for (const file of candidates) {
       const hash = hashFile(file);
       if (hash !== null) {
-        files[toPosix(path5.relative(listRoot, file))] = hash;
+        files[toPosix(path6.relative(listRoot, file))] = hash;
       }
     }
   }
@@ -2760,9 +3184,9 @@ function snapshotNow(input) {
   };
   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)));
+    const parts = path6.relative(listRoot, file).split(path6.sep);
+    if (isInside(listRoot, file) && !parts.some((part) => NEVER.includes(part)) && fs6.statSync(file, { throwIfNoEntry: false })?.isFile() === true) {
+      add(toPosix(path6.relative(listRoot, file)));
     }
   }
   drain();
@@ -2782,14 +3206,18 @@ function snapshotNow(input) {
 }
 
 // src/affected-files.ts
-import fs6 from "fs";
+import fs7 from "fs";
 import { builtinModules as builtinModules2 } from "module";
-import path6 from "path";
+import path7 from "path";
 var AffectedError = class extends Error {
 };
-var RUNTIME_PATHS = /\b(?:require\.(?:context|resolve)|process\.cwd|createRequire|toMatchFileSnapshot|readFileSync|readdirSync)\b|\bimport\.meta\.(?:glob|resolve)\b/;
+var RUNTIME_PATHS = /\b(?:require\.(?:context|resolve)|process\.cwd|createRequire|toMatchFileSnapshot|readFileSync|readFile|readdirSync|fromFile|fromURL)\b|\bimport\.meta\.(?:glob|resolve)\b/;
+var PATH_FROM_TOP = /^[^\s./?#*:][^\s?#*:]*\.(?:html?|md|json)$/i;
+var withoutQuery = (specifier) => specifier.replace(/\?[^/]*$/, "");
+var RUNTIME_LOADS = /\b(?:require\.(?:context|resolve)|process\.cwd|createRequire)\b|\bimport\.meta\.(?:glob|resolve)\b/;
 var LOCATION = /\b(?:__dirname|__filename)\b|\bimport\.meta\.(?:url|dirname|filename)\b/;
 var LOCATION_READS = /\b(?:readFile|readdir|readlink|existsSync|stat|statSync|lstat|lstatSync|access|accessSync|realpath|realpathSync|open|openSync|opendir|opendirSync|createReadStream|watch|watchFile|glob|globSync|promises)\b|\b(?:requireActual|requireMock|importActual|importMock|mock|doMock|unstable_mockModule|setMock|createMockFromModule)\(\s*(?![\s'"`)])|\bWorker\(/;
+var LOCATION_LOADS = /\b(?:requireActual|requireMock|importActual|importMock|mock|doMock|unstable_mockModule|setMock|createMockFromModule)\(\s*(?![\s'"`)])|\bWorker\(/;
 var LOCATION_SAFE = /* @__PURE__ */ new Set([
   "path",
   "path/posix",
@@ -2810,30 +3238,31 @@ var FILE_MODULES = /* @__PURE__ */ new Set([
   "fast-glob",
   "globby"
 ]);
+var LOADING_MODULES = /* @__PURE__ */ new Set(["child_process", "module", "worker_threads"]);
 var bare = (specifier) => specifier.replace(/^node:/, "");
 function linkedPackage(specifier, from) {
   const name = specifier.split("/").slice(0, specifier.startsWith("@") ? 2 : 1).join("/");
-  for (let current = path6.dirname(from); ; current = path6.dirname(current)) {
-    const candidate = path6.join(current, "node_modules", name);
-    if (fs6.existsSync(candidate)) {
+  for (let current = path7.dirname(from); ; current = path7.dirname(current)) {
+    const candidate = path7.join(current, "node_modules", name);
+    if (fs7.existsSync(candidate)) {
       const target = realpath(candidate);
-      return target.split(path6.sep).includes("node_modules") ? null : target;
+      return target.split(path7.sep).includes("node_modules") ? null : target;
     }
-    if (current === path6.dirname(current)) {
+    if (current === path7.dirname(current)) {
       return null;
     }
   }
 }
-var toPosix2 = (file) => file.split(path6.sep).join("/");
+var toPosix2 = (file) => file.split(path7.sep).join("/");
 function realpath(file) {
   try {
-    return fs6.realpathSync.native(file);
+    return fs7.realpathSync.native(file);
   } catch {
     return file;
   }
 }
 function runnerConfigs(dir, stryker, options) {
-  const files = [path6.resolve(dir, stryker)];
+  const files = [path7.resolve(dir, stryker)];
   const named = options.testRunner === "vitest" ? options.vitestConfig : options.jestConfig;
   if (options.testRunner !== "vitest" && options.testRunner !== "jest") {
     throw new AffectedError(
@@ -2841,20 +3270,20 @@ function runnerConfigs(dir, stryker, options) {
     );
   }
   if (typeof named === "string") {
-    files.push(path6.resolve(dir, named));
+    files.push(path7.resolve(dir, named));
   } else {
     const names = options.testRunner === "vitest" ? ["vitest.config", "vite.config"] : ["jest.config"];
     for (const name of names) {
       for (const extension of [".ts", ".mts", ".cts", ".js", ".mjs", ".cjs", ".json"]) {
-        const file = path6.join(dir, name + extension);
-        if (fs6.existsSync(file)) {
+        const file = path7.join(dir, name + extension);
+        if (fs7.existsSync(file)) {
           files.push(file);
         }
       }
     }
   }
   return {
-    files: files.filter((file) => fs6.existsSync(file)).map(realpath),
+    files: files.filter((file) => fs7.existsSync(file)).map(realpath),
     runner: options.testRunner,
     checkers: Array.isArray(options.checkers) && options.checkers.length > 0
   };
@@ -2875,24 +3304,24 @@ function typesErased(configs, texts, compiler) {
       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));
+  const inline = erased && !KEEPS_IMPORTS.test(all) && compiler.some(({ file }) => /^tsconfig/.test(path7.basename(file))) && compiler.every(({ text }) => text !== null && !KEEPS_IMPORTS.test(text));
   return { erased, inline };
 }
 function compilerConfigs(dir, root, keys) {
   const above = /* @__PURE__ */ new Set();
-  for (let current = path6.dirname(dir); ; current = path6.dirname(current)) {
-    const relative = path6.relative(root, current);
-    if (relative.startsWith("..") || path6.isAbsolute(relative)) {
+  for (let current = path7.dirname(dir); ; current = path7.dirname(current)) {
+    const relative = path7.relative(root, current);
+    if (relative.startsWith("..") || path7.isAbsolute(relative)) {
       break;
     }
     above.add(current);
-    if (current === path6.dirname(current)) {
+    if (current === path7.dirname(current)) {
       break;
     }
   }
-  const compared = new Set(keys.map((key) => path6.join(root, key)));
+  const compared = new Set(keys.map((key) => path7.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)))
+    (file) => (COMPILER_CONFIG.test(path7.basename(file)) || path7.basename(file) === "package.json") && (file.startsWith(`${dir}${path7.sep}`) || above.has(path7.dirname(file)))
   );
   const found = [];
   const seen = /* @__PURE__ */ new Set();
@@ -2903,9 +3332,9 @@ function compilerConfigs(dir, root, keys) {
     }
     seen.add(file);
     let text = null;
-    if (compared.has(file) || file.split(path6.sep).includes("node_modules")) {
+    if (compared.has(file) || file.split(path7.sep).includes("node_modules")) {
       try {
-        text = fs6.readFileSync(file, "utf8");
+        text = fs7.readFileSync(file, "utf8");
       } catch {
         text = null;
       }
@@ -2921,24 +3350,24 @@ function extended(base, from) {
   const candidates = (start) => [
     start,
     `${start}.json`,
-    path6.join(start, "tsconfig.json")
+    path7.join(start, "tsconfig.json")
   ];
-  if (base.startsWith(".") || path6.isAbsolute(base)) {
-    return candidates(path6.resolve(path6.dirname(from), base)).find(isFile2) ?? null;
+  if (base.startsWith(".") || path7.isAbsolute(base)) {
+    return candidates(path7.resolve(path7.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);
+  for (let current = path7.dirname(from); ; current = path7.dirname(current)) {
+    const file = candidates(path7.join(current, "node_modules", base)).find(isFile2);
     if (file !== void 0) {
       return file;
     }
-    if (current === path6.dirname(current)) {
+    if (current === path7.dirname(current)) {
       return null;
     }
   }
 }
 function isFile2(file) {
   try {
-    return fs6.statSync(file).isFile();
+    return fs7.statSync(file).isFile();
   } catch {
     return false;
   }
@@ -2949,29 +3378,33 @@ function fileEdges(file, context) {
   if (known !== void 0) {
     return known;
   }
-  const shown = (one) => toPosix2(path6.relative(dir, one));
+  const shown = (one) => toPosix2(path7.relative(dir, one));
   const target = (specifier, from) => {
     if (specifier.startsWith(".")) {
-      return resolveFiles(path6.resolve(path6.dirname(from), specifier));
+      return resolveFiles(path7.resolve(path7.dirname(from), specifier));
     }
     const alias = aliases.find((candidate) => specifier.startsWith(candidate.prefix));
-    return alias === void 0 ? [] : resolveFiles(path6.resolve(dir, alias.target + specifier.slice(alias.prefix.length)));
+    return alias === void 0 ? [] : resolveFiles(path7.resolve(dir, alias.target + specifier.slice(alias.prefix.length)));
+  };
+  const found = { loads: [], unknown: null, loading: null, computed: false, unnamed: [] };
+  const loading = (reason) => {
+    found.unknown ??= reason;
+    found.loading ??= reason;
   };
-  const found = { loads: [], unknown: null, computed: false, unnamed: [] };
   cache.set(file, found);
-  const snapshotFile = path6.join(
-    path6.dirname(file),
+  const snapshotFile = path7.join(
+    path7.dirname(file),
     "__snapshots__",
-    `${path6.basename(file)}.snap`
+    `${path7.basename(file)}.snap`
   );
-  if (fs6.existsSync(snapshotFile)) {
+  if (fs7.existsSync(snapshotFile)) {
     found.loads.push(realpath(snapshotFile));
   }
-  const mocks = path6.join(path6.dirname(file), "__mocks__");
-  const name = path6.basename(file);
+  const mocks = path7.join(path7.dirname(file), "__mocks__");
+  const name = path7.basename(file);
   const candidates = isDirectory(mocks) ? [
-    path6.join(mocks, name),
-    ...resolveFiles(path6.join(mocks, name.replace(/\.[^.]+$/, "")), false, false)
+    path7.join(mocks, name),
+    ...resolveFiles(path7.join(mocks, name.replace(/\.[^.]+$/, "")), false, false)
   ] : [];
   for (const mock of new Set(candidates)) {
     if (isFile2(mock)) {
@@ -2981,18 +3414,23 @@ function fileEdges(file, context) {
   if (!SCRIPT.test(file) && !COMPONENT.test(file)) {
     return found;
   }
-  const source = fs6.readFileSync(file, "utf8");
+  const source = fs7.readFileSync(file, "utf8");
   const code = withoutComments(source);
   if (COMPONENT.test(file)) {
-    found.unknown = `${shown(file)} is a component, which can use others that it does not import`;
+    loading(`${shown(file)} is a component, which can use others that it does not import`);
   }
   const uncheckable = findUncheckableImports(code)[0];
   const runtime = RUNTIME_PATHS.exec(code);
+  const runtimeLoads = RUNTIME_LOADS.exec(code);
   if (uncheckable !== void 0) {
     found.unknown = `${shown(file)}:${uncheckable} imports a module whose path is not written out`;
+    found.loading = found.unknown;
     found.computed = true;
   } else if (runtime !== null) {
     found.unknown = `${shown(file)} uses ${runtime[0]}, which can reach files that no import names`;
+    if (runtimeLoads !== null) {
+      found.loading ??= `${shown(file)} uses ${runtimeLoads[0]}, which can reach files that no import names`;
+    }
   }
   const location = LOCATION.exec(code);
   const refs = parseImports(code);
@@ -3007,30 +3445,39 @@ function fileEdges(file, context) {
     typeLines.set(key, (typeLines.get(key) ?? 0) + 1);
   }
   for (const specifier of specifiers) {
-    if (path6.isAbsolute(specifier) || specifier.startsWith("file:")) {
+    if (path7.isAbsolute(specifier) || specifier.startsWith("file:")) {
       const resolved2 = resolveFiles(
-        specifier.startsWith("file:") ? new URL(specifier).pathname : specifier
+        withoutQuery(specifier.startsWith("file:") ? new URL(specifier).pathname : specifier)
       );
       if (resolved2.length === 0) {
-        found.unknown ??= `${shown(file)} imports ${specifier}, which leads to no file`;
+        loading(`${shown(file)} imports ${specifier}, which leads to no file`);
       } else {
         found.loads.push(...resolved2.map(realpath));
       }
     } else if (isProjectImport(specifier, aliases)) {
-      const resolved2 = target(specifier, file);
+      const resolved2 = target(withoutQuery(specifier), file);
       if (resolved2.length === 0) {
-        found.unknown ??= `${shown(file)} imports ${specifier}, which leads to no file`;
+        loading(`${shown(file)} imports ${specifier}, which leads to no file`);
       } else {
         found.loads.push(...resolved2.map(realpath));
       }
     } else if (FILE_MODULES.has(bare(specifier))) {
-      found.unknown ??= `${shown(file)} imports ${specifier}, which can reach files that no import names`;
+      const reason = `${shown(file)} imports ${specifier}, which can reach files that no import names`;
+      if (LOADING_MODULES.has(bare(specifier))) {
+        loading(reason);
+      } else {
+        found.unknown ??= reason;
+      }
     } else if (!specifier.startsWith("node:") && !builtinModules2.includes(specifier)) {
       if (!installed(specifier, file)) {
-        found.unknown ??= `${shown(file)} imports ${specifier}, which is neither a file nor an installed package (name an alias in settings.importAliases)`;
+        loading(
+          `${shown(file)} imports ${specifier}, which is neither a file nor an installed package (name an alias in settings.importAliases)`
+        );
         found.unnamed.push(specifier);
       } else if (linkedPackage(specifier, file) !== null) {
-        found.unknown ??= `${shown(file)} imports ${specifier}, a package of the repository linked into node_modules`;
+        loading(
+          `${shown(file)} imports ${specifier}, a package of the repository linked into node_modules`
+        );
         found.computed = true;
       }
     }
@@ -3038,10 +3485,14 @@ 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))
+      (specifier) => !specifier.startsWith(".") && !path7.isAbsolute(specifier) && !specifier.startsWith("file:") && !isProjectImport(specifier, aliases) && !LOCATION_SAFE.has(bare(specifier))
     );
     if (reads !== null) {
       found.unknown ??= `${shown(file)} uses ${location[0]} and ${reads[0].replace(/\(\s*$/, "")}, which can reach files that no import names`;
+      const loads = LOCATION_LOADS.exec(code);
+      if (loads !== null) {
+        found.loading ??= `${shown(file)} uses ${location[0]} and ${loads[0].replace(/\(\s*$/, "")}, which can reach files that no import names`;
+      }
     } else if (reader !== void 0) {
       found.unknown ??= `${shown(file)} uses ${location[0]} and imports ${reader}, which can read files by it that no import names`;
     }
@@ -3060,7 +3511,9 @@ function fileEdges(file, context) {
     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));
+      found.loads.push(...resolveFiles(path7.resolve(path7.dirname(file), text)).map(realpath));
+    } else if (PATH_FROM_TOP.test(text) && isFile2(path7.resolve(dir, text))) {
+      found.loads.push(realpath(path7.resolve(dir, text)));
     }
   }
   return found;
@@ -3072,25 +3525,25 @@ function inputsOf(manifest, input) {
   const dir = realpath(manifest.dir);
   const aliases = manifest.settings.importAliases;
   const placed = [...input.tests, ...Object.values(input.covering).flat()];
-  const absolute = placed.find((file) => path6.isAbsolute(file) || file.startsWith(".."));
+  const absolute = placed.find((file) => path7.isAbsolute(file) || file.startsWith(".."));
   if (absolute !== void 0) {
     throw new AffectedError(`the report names a spec file outside of the subproject: ${absolute}`);
   }
   const keyOf2 = (file) => {
-    const relative = path6.relative(input.root, realpath(file));
-    if (relative.startsWith("..") || path6.isAbsolute(relative)) {
+    const relative = path7.relative(input.root, realpath(file));
+    if (relative.startsWith("..") || path7.isAbsolute(relative)) {
       throw new AffectedError(`${file} is outside of the files that are compared`);
     }
     return toPosix2(relative);
   };
-  const shown = (file) => toPosix2(path6.relative(dir, file));
+  const shown = (file) => toPosix2(path7.relative(dir, file));
   const plain2 = /* @__PURE__ */ new Map();
   const configTexts = [];
   const runnerSources = [];
   const reached = new Set(input.configs.files);
   const pending = [...input.configs.files];
   for (let file = pending.shift(); file !== void 0; file = pending.shift()) {
-    const text = fs6.readFileSync(file, "utf8");
+    const text = fs7.readFileSync(file, "utf8");
     configTexts.push(text);
     runnerSources.push({ file, text });
     for (const next of fileEdges(file, { dir, aliases, cache: plain2 }).loads) {
@@ -3108,7 +3561,7 @@ function inputsOf(manifest, input) {
     // 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));
+        const relative = path7.relative(input.root, realpath(file));
         return !relative.startsWith("..") && toPosix2(relative) in input.files;
       }),
       ...jestInPackage(dir, input.configs)
@@ -3121,14 +3574,21 @@ function inputsOf(manifest, input) {
   }
   const edges = /* @__PURE__ */ new Map();
   const edgesOf = (file) => fileEdges(file, { dir, aliases, cache: edges, types });
+  const blind = /* @__PURE__ */ Object.create(null);
   const closure = (start, strict) => {
     const seen = /* @__PURE__ */ new Set([start]);
     const queue = [start];
     for (let file = queue.shift(); file !== void 0; file = queue.shift()) {
       const found = edgesOf(file);
-      if (strict && found.unknown !== null) {
+      if (strict === "every" && found.unknown !== null) {
         throw new AffectedError(found.unknown);
       }
+      if (strict === "gate" && found.unknown !== null) {
+        if (found.loading !== null) {
+          throw new AffectedError(found.loading);
+        }
+        blind[keyOf2(file)] = found.unknown;
+      }
       for (const next of found.loads) {
         if (!seen.has(next)) {
           seen.add(next);
@@ -3139,8 +3599,8 @@ function inputsOf(manifest, input) {
     return [...seen];
   };
   const isCompared = (file) => {
-    const relative = path6.relative(input.root, realpath(file));
-    return !relative.startsWith("..") && !path6.isAbsolute(relative) && toPosix2(relative) in input.files;
+    const relative = path7.relative(input.root, realpath(file));
+    return !relative.startsWith("..") && !path7.isAbsolute(relative) && toPosix2(relative) in input.files;
   };
   const keysOf = (files) => files.map((file) => {
     const key = keyOf2(file);
@@ -3159,10 +3619,10 @@ function inputsOf(manifest, input) {
       if (!SCRIPT.test(loaded)) {
         continue;
       }
-      for (const match of fs6.readFileSync(loaded, "utf8").matchAll(QUOTED)) {
+      for (const match of fs7.readFileSync(loaded, "utf8").matchAll(QUOTED)) {
         const text = match[2].replace(/^<rootDir>\//, "");
-        const here = resolveFiles(path6.resolve(path6.dirname(loaded), text), false, false);
-        const candidates = here.length > 0 ? here : resolveFiles(path6.resolve(dir, text), false, false);
+        const here = resolveFiles(path7.resolve(path7.dirname(loaded), text), false, false);
+        const candidates = here.length > 0 ? here : resolveFiles(path7.resolve(dir, text), false, false);
         for (const found of candidates) {
           if (text.includes("*") || !isCompared(found)) {
             continue;
@@ -3177,7 +3637,7 @@ function inputsOf(manifest, input) {
     }
   }
   const gatePaths = new Map(
-    manifest.gates.map((gate) => [realpath(path6.join(dir, gate.path)), gate.path])
+    manifest.gates.map((gate) => [realpath(path7.join(dir, gate.path)), gate.path])
   );
   const tests = [
     .../* @__PURE__ */ new Set([
@@ -3188,13 +3648,13 @@ function inputsOf(manifest, input) {
   ];
   const runAsSuch = new Set(
     [...tests, ...manifest.gates.map((gate) => gate.path)].map(
-      (file) => realpath(path6.join(dir, file))
+      (file) => realpath(path7.join(dir, file))
     )
   );
-  const subprojectKey = toPosix2(path6.relative(input.root, dir));
+  const subprojectKey = toPosix2(path7.relative(input.root, dir));
   const isConfig = (file) => input.configs.files.includes(file) || kindOf(keyOf2(file), subprojectKey) === "config";
   for (const file of named.filter((one) => !isConfig(one) && !runAsSuch.has(one))) {
-    for (const loaded of closure(file, true)) {
+    for (const loaded of closure(file, "every")) {
       const gate = gatePaths.get(loaded);
       if (gate !== void 0) {
         throw new AffectedError(
@@ -3204,16 +3664,16 @@ function inputsOf(manifest, input) {
       config.add(loaded);
     }
   }
-  const fromSubproject = (file) => path6.join(dir, file);
+  const fromSubproject = (file) => path7.join(dir, file);
   const closures = /* @__PURE__ */ Object.create(null);
   for (const file of [...manifest.gates.map((gate) => gate.path), ...tests]) {
     const absolute2 = fromSubproject(file);
-    if (!fs6.existsSync(absolute2)) {
+    if (!fs7.existsSync(absolute2)) {
       continue;
     }
-    closures[keysOf([absolute2])[0]] = keysOf(closure(realpath(absolute2), true));
+    closures[keysOf([absolute2])[0]] = keysOf(closure(realpath(absolute2), "gate"));
   }
-  const keyed = (files) => files.map((file) => toPosix2(path6.relative(input.root, path6.join(dir, file))));
+  const keyed = (files) => files.map((file) => toPosix2(path7.relative(input.root, path7.join(dir, file))));
   const dependencies = gateDependencies({
     gates: manifest.gates.map((gate) => ({
       key: keyed([gate.path])[0],
@@ -3223,9 +3683,10 @@ function inputsOf(manifest, input) {
     covering: Object.fromEntries(
       Object.entries(input.covering).map(([gate, specs]) => [keyed([gate])[0], keyed(specs)])
     ),
-    closures
+    closures,
+    blind
   });
-  const subproject = toPosix2(path6.relative(input.root, dir));
+  const subproject = toPosix2(path7.relative(input.root, dir));
   const prefix = subproject === "" ? "" : `${subproject}/`;
   const gates = /* @__PURE__ */ Object.create(null);
   for (const gate of manifest.gates) {
@@ -3236,12 +3697,13 @@ function inputsOf(manifest, input) {
       specs: found.specs.map(
         (spec) => spec.startsWith(prefix) ? spec.slice(prefix.length) : spec
       ),
-      files: found.files
+      files: found.files,
+      ...found.blind === void 0 ? {} : { blind: found.blind }
     };
   }
   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))
+      (name) => builtinModules2.includes(name) || installed(name, path7.join(input.root, key))
     )
   );
   return {
@@ -3297,7 +3759,7 @@ function scopeOf(manifest, configs, listed2) {
   const cache = /* @__PURE__ */ new Map();
   const context = { dir, aliases: manifest.settings.importAliases, cache };
   const runner = configs.files.slice(1);
-  const texts = runner.map((file) => withoutComments(fs6.readFileSync(file, "utf8")));
+  const texts = runner.map((file) => withoutComments(fs7.readFileSync(file, "utf8")));
   if (runner.length === 0 || !texts.every((text) => OWN.test(text))) {
     return { every: NOT_THE_HELPER2 };
   }
@@ -3312,21 +3774,21 @@ function scopeOf(manifest, configs, listed2) {
       fileEdges(file, context).loads.forEach((loaded) => parts.add(loaded));
     }
   }
-  if ([...parts].some((file) => PROJECTS.test(withoutComments(fs6.readFileSync(file, "utf8"))))) {
+  if ([...parts].some((file) => PROJECTS.test(withoutComments(fs7.readFileSync(file, "utf8"))))) {
     return {
       every: "the runner config, or a file it is put together from, names projects or a workspace"
     };
   }
-  const named = fs6.readdirSync(dir).filter((name) => READ_BY_NAME.some((pattern) => pattern.test(name))).map((name) => path6.join(dir, name));
-  const mocks = path6.join(dir, "__mocks__");
+  const named = fs7.readdirSync(dir).filter((name) => READ_BY_NAME.some((pattern) => pattern.test(name))).map((name) => path7.join(dir, name));
+  const mocks = path7.join(dir, "__mocks__");
   const seeds = [
     ...configs.files,
     ...named,
-    ...manifest.gates.flatMap((gate) => [gate.path, ...gate.existingSpecs]).map((file) => path6.join(dir, file)),
-    ...listed2.filter((file) => file.startsWith(`${mocks}${path6.sep}`))
-  ].filter((file) => fs6.existsSync(file)).map(realpath);
+    ...manifest.gates.flatMap((gate) => [gate.path, ...gate.existingSpecs]).map((file) => path7.join(dir, file)),
+    ...listed2.filter((file) => file.startsWith(`${mocks}${path7.sep}`))
+  ].filter((file) => fs7.existsSync(file)).map(realpath);
   const naming = new Set(
-    [...configs.files, ...named].filter((file) => fs6.existsSync(file)).map(realpath)
+    [...configs.files, ...named].filter((file) => fs7.existsSync(file)).map(realpath)
   );
   const seen = new Set(seeds);
   const queue = [...seeds];
@@ -3338,7 +3800,7 @@ function scopeOf(manifest, configs, listed2) {
     }
   };
   for (let file = queue.shift(); file !== void 0; file = queue.shift()) {
-    if (fs6.statSync(file).isDirectory()) {
+    if (fs7.statSync(file).isDirectory()) {
       continue;
     }
     const edges = fileEdges(file, context);
@@ -3349,11 +3811,11 @@ function scopeOf(manifest, configs, listed2) {
     for (const specifier of edges.unnamed) {
       endingAs(specifier, listed2).forEach(add);
     }
-    if (naming.has(file) || SCRIPT.test(file) && path6.dirname(file) === dir) {
+    if (naming.has(file) || SCRIPT.test(file) && path7.dirname(file) === dir) {
       for (const named2 of namedIn(file)) {
         const text = named2.replace(/^<rootDir>\//, "");
-        const here = resolveFiles(path6.resolve(path6.dirname(file), text), false);
-        const found = here.length > 0 ? here : resolveFiles(path6.resolve(dir, text), false);
+        const here = resolveFiles(path7.resolve(path7.dirname(file), text), false);
+        const found = here.length > 0 ? here : resolveFiles(path7.resolve(dir, text), false);
         for (const one of text.includes("*") ? [] : found) {
           if (!SCRIPT.test(one)) {
             naming.add(realpath(one));
@@ -3377,7 +3839,7 @@ function endingAs(specifier, files) {
   });
 }
 function namedIn(file) {
-  const text = fs6.readFileSync(file, "utf8");
+  const text = fs7.readFileSync(file, "utf8");
   if (SCRIPT.test(file)) {
     return [...text.matchAll(QUOTED)].map((match) => match[2]);
   }
@@ -3531,15 +3993,15 @@ function mayStartPattern(before) {
   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 }] : [];
+  const file = path7.join(dir, "package.json");
+  return configs.runner === "jest" && configs.files.length === 1 && fs7.existsSync(file) ? [{ file, text: fs7.readFileSync(file, "utf8"), mapperOnly: true }] : [];
 }
 var STRING_LITERAL = String.raw`'(?:[^'\\\n]|\\.)*'|"(?:[^"\\\n]|\\.)*"`;
 function stringValue(text) {
   const match = new RegExp(`^\\s*(${STRING_LITERAL})\\s*$`).exec(text);
   return match === null ? null : match[1].slice(1, -1).replace(/\\(.)/g, "$1");
 }
-function partsOf(text, at) {
+function partsOf2(text, at) {
   const parts = [];
   let depth = 0;
   let start = at + 1;
@@ -3576,7 +4038,7 @@ function property(part) {
 }
 function aliasPath(expression, file, text, depth = 0) {
   const value = expression.trim();
-  const here = path6.dirname(file);
+  const here = path7.dirname(file);
   if (value === "__dirname" || value === "import.meta.dirname" || /^(?:path\.)?dirname\(\s*(?:url\.)?fileURLToPath\(\s*import\.meta\.url\s*\)\s*\)$/.test(value)) {
     return here;
   }
@@ -3584,18 +4046,18 @@ function aliasPath(expression, file, text, depth = 0) {
     `^(?:(?: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]));
+    return path7.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);
+    const found = partsOf2(value, call[0].length - 1);
     if (found === null || value.slice(found.end + 1).trim() !== "" || found.parts.length === 0) {
       return null;
     }
     const [first, ...rest] = found.parts;
     const base = aliasPath(first, file, text, depth + 1);
     const parts = rest.map(stringValue);
-    return base === null || parts.some((part) => part === null) ? null : path6.resolve(base, ...parts);
+    return base === null || parts.some((part) => part === null) ? null : path7.resolve(base, ...parts);
   }
   if (/^[A-Za-z_$][\w$]*$/.test(value) && depth < 4) {
     const declarations = text.match(
@@ -3611,7 +4073,7 @@ function aliasPath(expression, file, text, depth = 0) {
 var PACKAGE_NAME = /^(?:@[\w-][\w.-]*\/)?[\w-][\w.-]*$/;
 function isDirectory(file) {
   try {
-    return fs6.statSync(file).isDirectory();
+    return fs7.statSync(file).isDirectory();
   } catch {
     return false;
   }
@@ -3637,8 +4099,8 @@ 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 shown = (file) => toPosix2(path7.relative(dir, file));
+  const under = (base, rest) => rest === "" ? `${base}/` : path7.join(base, rest);
   const named = (prefix, target) => {
     const alias = aliases.find((candidate) => prefix.startsWith(candidate.prefix));
     if (alias === void 0) {
@@ -3646,10 +4108,10 @@ function unexplainedMaps(input) {
     }
     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("/");
+    return path7.resolve(dir, full) === path7.resolve(target) && slash === target.endsWith("/");
   };
   const advice = (prefix, target) => {
-    const relative = toPosix2(path6.relative(dir, target));
+    const relative = toPosix2(path7.relative(dir, target));
     const shownTarget = relative === "" ? "./" : `${relative}/`;
     const shorter = aliases.find((alias) => prefix.startsWith(alias.prefix));
     const before = shorter === void 0 ? "" : shorter.prefix === prefix ? `, in place of the alias of ${prefix}` : `, before the alias of ${shorter.prefix}`;
@@ -3662,7 +4124,7 @@ function unexplainedMaps(input) {
       let prefix = null;
       let to = null;
       if (list) {
-        const object = /^\s*\{/.test(part) ? partsOf(part, part.indexOf("{")) : null;
+        const object = /^\s*\{/.test(part) ? partsOf2(part, part.indexOf("{")) : null;
         const fields = Object.fromEntries(
           (object?.parts ?? []).map(property).map((one) => [one?.key ?? "", one?.value ?? ""])
         );
@@ -3714,7 +4176,7 @@ function unexplainedMaps(input) {
       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 found = at === -1 ? null : partsOf2(text, at);
       const unreadable = `${shown(file)} names ${word} in a way that cannot be read as a list of aliases`;
       if (found === null || text[at] !== "{" && !(word === "alias" && text[at] === "[")) {
         reasons.push(unreadable);
@@ -3744,7 +4206,7 @@ function unexplainedMaps(input) {
         }
         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]);
+        const to = target === null ? null : under(path7.dirname(file), target[1]);
         if (prefix === null || to === null) {
           reasons.push(missing(file, entry.key, word));
         } else if (!named(prefix, to)) {
@@ -3755,19 +4217,19 @@ function unexplainedMaps(input) {
       }
     }
   }
-  const tsconfigs = input.compiler.filter(({ file }) => /^[jt]sconfig/.test(path6.basename(file)));
+  const tsconfigs = input.compiler.filter(({ file }) => /^[jt]sconfig/.test(path7.basename(file)));
   const withBase = tsconfigs.filter(({ text }) => text !== null && /"baseUrl"\s*:/.test(text));
   for (const { file, text } of input.compiler) {
     if (text === null) {
       continue;
     }
     const plain2 = withoutComments(text);
-    const name = path6.basename(file);
+    const name = path7.basename(file);
     const swc = name === ".swcrc";
     if (!/^[jt]sconfig/.test(name) && !swc) {
       const babel = /"babel"\s*:\s*/.exec(plain2);
       const own2 = name !== "package.json" ? plain2 : babel === null ? "" : (() => {
-        const found2 = partsOf(plain2, babel.index + babel[0].length);
+        const found2 = partsOf2(plain2, babel.index + babel[0].length);
         return found2 === null ? plain2 : found2.parts.join(",");
       })();
       const maps = /module-resolver|\balias\b/.exec(own2);
@@ -3781,7 +4243,7 @@ function unexplainedMaps(input) {
       continue;
     }
     const at = paths.index + paths[0].length;
-    const found = plain2[at] === "{" ? partsOf(plain2, at) : null;
+    const found = plain2[at] === "{" ? partsOf2(plain2, at) : null;
     if (found === null) {
       reasons.push(`${shown(file)} names paths in a way that cannot be read as a list of aliases`);
       continue;
@@ -3791,7 +4253,7 @@ function unexplainedMaps(input) {
       reasons.push(`${shown(file)} names paths, and baseUrl is set in another file`);
       continue;
     }
-    const base = path6.resolve(path6.dirname(file), own?.[1] ?? ".");
+    const base = path7.resolve(path7.dirname(file), own?.[1] ?? ".");
     for (const part of found.parts) {
       const entry = property(part);
       if (entry === null) {
@@ -3800,10 +4262,10 @@ function unexplainedMaps(input) {
         );
         continue;
       }
-      const list = entry.value.startsWith("[") ? partsOf(entry.value, 0) : null;
+      const list = entry.value.startsWith("[") ? partsOf2(entry.value, 0) : null;
       const target = list?.parts.length === 1 ? stringValue(list.parts[0]) : null;
       const prefix = entry.key.endsWith("*") ? entry.key.slice(0, -1) : null;
-      if (prefix === null && target !== null && !target.includes("*") && path6.resolve(base, target).split(path6.sep).includes("node_modules")) {
+      if (prefix === null && target !== null && !target.includes("*") && path7.resolve(base, target).split(path7.sep).includes("node_modules")) {
         continue;
       }
       const directory = target?.endsWith("*") ? target.slice(0, -1) : null;
@@ -3821,26 +4283,69 @@ function unexplainedMaps(input) {
 }
 
 // src/commands/mutation.ts
-import { spawnSync as spawnSync2 } from "child_process";
+import { spawnSync as spawnSync4 } from "child_process";
+import fs10 from "fs";
+import path10 from "path";
+import { pathToFileURL } from "url";
+
+// src/main-worktree.ts
+import { spawnSync as spawnSync3 } from "child_process";
 import fs8 from "fs";
 import path8 from "path";
-import { pathToFileURL } from "url";
+function git2(dir, args) {
+  const result = spawnSync3("git", args, {
+    cwd: dir,
+    env: gitEnvironment(process.env),
+    encoding: "utf8"
+  });
+  return result.error || result.status !== 0 ? null : result.stdout.trim().split("\n");
+}
+function linkedWorktreeOf(dir) {
+  const found = git2(dir, [
+    "rev-parse",
+    "--path-format=absolute",
+    "--show-toplevel",
+    "--git-dir",
+    "--git-common-dir"
+  ]);
+  if (found === null || found.length !== 3) {
+    return null;
+  }
+  const [top, gitDir, common] = found;
+  if (gitDir === common || path8.basename(common) !== ".git") {
+    return null;
+  }
+  try {
+    const main2 = fs8.realpathSync(path8.dirname(common));
+    const real = fs8.realpathSync(top);
+    return main2 === real ? null : { top: real, main: main2 };
+  } catch {
+    return null;
+  }
+}
+function inMainWorktree(linked, file) {
+  const relative = path8.relative(linked.top, file);
+  if (relative === "" || relative.startsWith("..") || path8.isAbsolute(relative)) {
+    return null;
+  }
+  return path8.join(linked.main, relative);
+}
 
 // src/commands/mutation-result.ts
-import fs7 from "fs";
-import path7 from "path";
+import fs9 from "fs";
+import path9 from "path";
 function reportPathOf(manifest, override) {
-  return path7.resolve(manifest.dir, override ?? manifest.settings.strykerReportFile);
+  return path9.resolve(manifest.dir, override ?? manifest.settings.strykerReportFile);
 }
-function runMutationResult(dir, reportOverride, io2, only = [], seen = () => void 0) {
+function runMutationResult(dir, reportOverride, io2, only = [], seen = () => void 0, retried = null, shard = null) {
   const manifest = readManifest(dir);
   const gates = only.length === 0 ? manifest.gates : manifest.gates.filter((gate) => only.includes(gate.path));
-  const caveat = only.length === 0 ? "" : gateRunCaveat(gates.length, manifest.gates.length);
+  const caveat = only.length === 0 ? "" : shard === null ? gateRunCaveat(gates.length, manifest.gates.length) : shardRunCaveat(shard, gates.length, manifest.gates.length);
   const reportPath = reportPathOf(manifest, reportOverride);
-  const shown = path7.relative(manifest.dir, reportPath) || reportPath;
+  const shown = path9.relative(manifest.dir, reportPath) || reportPath;
   let report;
   try {
-    report = JSON.parse(fs7.readFileSync(reportPath, "utf8"));
+    report = JSON.parse(fs9.readFileSync(reportPath, "utf8"));
   } catch (error) {
     io2.err(
       `test-gates mutation: cannot read the Stryker JSON report ${shown} (${error.message}). Did Stryker finish, with the "json" reporter writing to this path?`
@@ -3857,7 +4362,7 @@ function runMutationResult(dir, reportOverride, io2, only = [], seen = () => voi
     maxTimeouts: manifest.settings.maxTimeouts,
     readSource: (gatePath) => {
       try {
-        return fs7.readFileSync(path7.join(manifest.dir, gatePath), "utf8");
+        return fs9.readFileSync(path9.join(manifest.dir, gatePath), "utf8");
       } catch {
         return void 0;
       }
@@ -3905,8 +4410,34 @@ function runMutationResult(dir, reportOverride, io2, only = [], seen = () => voi
       io2.err(`  - ${formatSurvivor(mutant)}`);
     }
     io2.err("");
-    io2.err("A timeout counts as detected, but on a loaded machine a mutant that would survive");
-    io2.err("can time out instead. Run again with less load (-- --concurrency 1). Only for a");
+    if (retried === null || retried === "failed") {
+      io2.err("A timeout counts as detected, but on a loaded machine a mutant that would survive");
+      if (retried === null) {
+        io2.err(
+          "can time out instead. `test-gates mutation` runs such timeouts again one at a time"
+        );
+        io2.err("(--concurrency 1) before it fails; these were not run again. Only for a");
+      } else {
+        io2.err(
+          "can time out instead. They were run again one at a time (--concurrency 1), but that"
+        );
+        io2.err("run gave no result (see above), so these are those of the first run. Only for a");
+      }
+    } else if (retried.missing === 0) {
+      io2.err("They timed out again when they were run one at a time (--concurrency 1), so they");
+      io2.err("most likely never finish. Look at each mutant first. Only for a");
+    } else {
+      const again = retried.statuses["Timeout"] ?? 0;
+      if (again > 0) {
+        io2.err(
+          `${again} of them timed out again when they were run one at a time (--concurrency 1).`
+        );
+      }
+      io2.err(
+        `${retried.missing} of them were not in the report of the run again (--concurrency 1),`
+      );
+      io2.err("so they keep the timeout of the first run. Look at each mutant first. Only for a");
+    }
     io2.err("mutant that can never finish (a loop that no longer ends), add it to");
     io2.err('"expectedTimeouts" of the gate in test-gates.json and fill in "reason"');
     io2.err("(settings.mutation.maxTimeouts raises the limit for the whole project):");
@@ -3925,16 +4456,16 @@ function runMutationResult(dir, reportOverride, io2, only = [], seen = () => voi
 // src/commands/mutation.ts
 var CONFIG_MARK = "\0test-gates-stryker-config\0";
 function loadStrykerConfig(manifest, config) {
-  const file = path8.resolve(manifest.dir, config);
+  const file = path10.resolve(manifest.dir, config);
   if (file.endsWith(".json")) {
     try {
-      return JSON.parse(fs8.readFileSync(file, "utf8"));
+      return JSON.parse(fs10.readFileSync(file, "utf8"));
     } catch {
       return void 0;
     }
   }
-  const script = `const loaded = await import(${JSON.stringify(pathToFileURL(file).href)});const config = loaded.default?.default ?? loaded.default ?? loaded;process.stdout.write(${JSON.stringify(CONFIG_MARK)} + JSON.stringify({incremental: config.incremental, force: config.force,incrementalFile: config.incrementalFile, tempDirName: config.tempDirName,testRunner: config.testRunner, vitestConfig: config.vitest?.configFile,jestConfig: config.jest?.configFile, 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], {
+  const script = `const loaded = await import(${JSON.stringify(pathToFileURL(file).href)});const config = loaded.default?.default ?? loaded.default ?? loaded;process.stdout.write(${JSON.stringify(CONFIG_MARK)} + JSON.stringify({incremental: config.incremental, force: config.force,incrementalFile: config.incrementalFile, tempDirName: config.tempDirName,testRunner: config.testRunner, vitestConfig: config.vitest?.configFile,jestConfig: config.jest?.configFile, checkers: config.checkers,htmlReporter: config.htmlReporter, jsonReporter: config.jsonReporter,ignorePatterns: config.ignorePatterns, cleanTempDir: config.cleanTempDir,}) + ${JSON.stringify(CONFIG_MARK)});`;
+  const result = spawnSync4(process.execPath, ["--input-type=module", "--eval", script], {
     cwd: manifest.dir,
     encoding: "utf8",
     timeout: 6e4
@@ -3947,7 +4478,7 @@ function loadStrykerConfig(manifest, config) {
 }
 function modifiedAt(file) {
   try {
-    const stat = fs8.statSync(file, { bigint: true });
+    const stat = fs10.statSync(file, { bigint: true });
     return `${stat.mtimeNs} ${stat.ino}`;
   } catch {
     return null;
@@ -3956,6 +4487,7 @@ function modifiedAt(file) {
 function guardRecordPath(incrementalFile) {
   return `${incrementalFile}.test-gates.json`;
 }
+var forcedLine = (reason) => `test-gates mutation: running every mutant again (--force), the results of the last run are not reused: ${reason}`;
 function coveringSpecs(report, gates) {
   const fileOf = /* @__PURE__ */ new Map();
   for (const [file, entry] of Object.entries(report.testFiles ?? {})) {
@@ -3982,10 +4514,20 @@ function coveringSpecs(report, gates) {
   }
   return covering;
 }
-function decideReuse(manifest, config, strykerArgs, part, affected) {
+function readSeed(incrementalFile, recordFile) {
+  try {
+    const incremental = fs10.readFileSync(incrementalFile);
+    const record = JSON.parse(fs10.readFileSync(recordFile, "utf8"));
+    const named = record?.incremental;
+    return named === hashOf(incremental) ? { incremental, record } : null;
+  } catch {
+    return null;
+  }
+}
+function decideReuse(manifest, config, strykerArgs, part, affected, found = () => void 0) {
   const loaded = loadStrykerConfig(manifest, config);
   const options = incrementalOptions(loaded, strykerArgs);
-  const base = fs8.realpathSync(manifest.dir);
+  const base = fs10.realpathSync(manifest.dir);
   const checkersArg = strykerArgs.some(
     (arg) => arg === "--checkers" || arg.startsWith("--checkers=")
   );
@@ -4009,35 +4551,42 @@ function decideReuse(manifest, config, strykerArgs, part, affected) {
     last: void 0,
     ci: affected ? affectedRefused(process.env) : null,
     unchanged: null,
-    configs
+    configs,
+    temp: {
+      dir: loaded === void 0 ? null : path10.resolve(base, options.tempDirName),
+      keeps: loaded?.cleanTempDir === false
+    },
+    mainWorktree: null,
+    seed: null
   };
+  found(decision.temp);
   if (loaded !== void 0 && !options.incremental) {
     return decision;
   }
   decision.incremental = true;
-  const incrementalFile = path8.resolve(base, options.incrementalFile);
+  const incrementalFile = path10.resolve(base, options.incrementalFile);
   const recordFile = guardRecordPath(incrementalFile);
   decision.incrementalFile = incrementalFile;
   decision.recordFile = recordFile;
   let snapshot = null;
   let root = base;
   let failure = "the Stryker config could not be loaded to see where the incremental file is";
-  const reports = reportFiles(loaded).map((file) => path8.resolve(base, file));
+  const reports = reportFiles(loaded).map((file) => path10.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("/")));
+    const relative = path10.relative(base, file);
+    const inside = !relative.startsWith("..") && !path10.isAbsolute(relative);
+    return !reports.includes(file) && !(inside && ignores(relative.split(path10.sep).join("/")));
   };
   if (loaded !== void 0) {
     const scope = (listed2) => {
       try {
-        const found = loadedScope(manifest, configs(), listed2);
-        if (!("files" in found)) {
-          decision.scope = found;
+        const found2 = loadedScope(manifest, configs(), listed2);
+        if (!("files" in found2)) {
+          decision.scope = found2;
           return null;
         }
-        const files = new Set([...found.files].filter(read2));
+        const files = new Set([...found2.files].filter(read2));
         decision.scope = { files: files.size };
         return files;
       } catch (error) {
@@ -4053,8 +4602,8 @@ function decideReuse(manifest, config, strykerArgs, part, affected) {
         written: [
           incrementalFile,
           recordFile,
-          path8.resolve(base, options.tempDirName),
-          path8.resolve(base, manifest.settings.strykerReportFile),
+          path10.resolve(base, options.tempDirName),
+          path10.resolve(base, manifest.settings.strykerReportFile),
           ...reports
         ],
         args: comparableArgs(strykerArgs)
@@ -4067,17 +4616,32 @@ function decideReuse(manifest, config, strykerArgs, part, affected) {
   decision.snapshot = snapshot;
   decision.failure = snapshot === null ? failure : null;
   decision.root = root;
-  const incremental = hashFile(incrementalFile);
+  const tempDir = path10.basename(options.tempDirName);
+  if (!part && !options.force && snapshot?.mode === "git" && !path10.relative(root, base).split(path10.sep).includes(tempDir) && !fs10.existsSync(incrementalFile) && !fs10.existsSync(recordFile)) {
+    const linked = linkedWorktreeOf(base);
+    const mainIncremental = linked === null ? null : inMainWorktree(linked, incrementalFile);
+    const mainRecord = linked === null ? null : inMainWorktree(linked, recordFile);
+    if (linked !== null && mainIncremental !== null && mainRecord !== null) {
+      decision.mainWorktree = linked.main;
+      const seed = readSeed(mainIncremental, mainRecord);
+      if (seed !== null) {
+        decision.seed = seed;
+      }
+    }
+  }
+  const incremental = decision.seed === null ? hashFile(incrementalFile) : hashOf(decision.seed.incremental);
   decision.incrementalHash = incremental;
   if (part) {
     decision.force = incremental !== null && !options.force ? "with --gate nothing is taken over from an earlier run" : null;
     return decision;
   }
-  let stored;
-  try {
-    stored = JSON.parse(fs8.readFileSync(recordFile, "utf8"));
-  } catch {
-    stored = void 0;
+  let stored = decision.seed?.record;
+  if (decision.seed === null) {
+    try {
+      stored = JSON.parse(fs10.readFileSync(recordFile, "utf8"));
+    } catch {
+      stored = void 0;
+    }
   }
   const ci = decision.ci;
   let force = null;
@@ -4091,6 +4655,9 @@ function decideReuse(manifest, config, strykerArgs, part, affected) {
       if (force === null) {
         const read3 = readRecord({ record: stored, incremental, snapshot });
         last = "record" in read3 ? read3.record.affected : void 0;
+        if (decision.seed !== null) {
+          force = blindInMainRecord(manifest, { root, snapshot, configs, last });
+        }
       }
     } else if (ci !== null) {
       force = ci;
@@ -4117,8 +4684,10 @@ function decideReuse(manifest, config, strykerArgs, part, affected) {
             config: inputs.config,
             gates: manifest.gates.map((gate) => ({
               path: gate.path,
-              files: inputs.gates[gate.path]?.files ?? []
-            }))
+              files: inputs.gates[gate.path]?.files ?? [],
+              blind: inputs.gates[gate.path]?.blind
+            })),
+            seeded: decision.seed !== null
           });
         } catch (error) {
           if (!(error instanceof AffectedError)) {
@@ -4127,7 +4696,7 @@ function decideReuse(manifest, config, strykerArgs, part, affected) {
           plan = { full: `what a gate depends on cannot be told: ${error.message}` };
         }
         if ("full" in plan) {
-          if (refuseReuse({ record: stored, incremental, snapshot }) === null) {
+          if (decision.seed === null && refuseReuse({ record: stored, incremental, snapshot }) === null) {
             decision.unchanged = plan.full;
             plan = null;
           } else {
@@ -4144,9 +4713,45 @@ function decideReuse(manifest, config, strykerArgs, part, affected) {
   decision.last = last;
   return decision;
 }
-function guardIncremental(manifest, config, strykerArgs, part, affected) {
-  const nothing = { force: null, mutate: null, said: [], record: () => void 0 };
-  const decision = decideReuse(manifest, config, strykerArgs, part, affected);
+function blindInMainRecord(manifest, input) {
+  const { last } = input;
+  const unknown = last === void 0 ? "each gate" : manifest.gates.find((gate) => !Object.hasOwn(last.gates, gate.path))?.path;
+  if (last === void 0 || unknown !== void 0) {
+    return `the record of the main worktree does not say what ${unknown} depends on, so it may read files git does not list, which differ between worktrees`;
+  }
+  try {
+    const inputs = affectedInputs(manifest, {
+      root: input.root,
+      files: input.snapshot.files,
+      configs: input.configs(),
+      tests: last.tests,
+      covering: Object.fromEntries(
+        Object.entries(last.gates).map(([gate, entry]) => [gate, entry.specs])
+      )
+    });
+    for (const gate of manifest.gates) {
+      const blind = inputs.gates[gate.path]?.blind ?? last.gates[gate.path]?.blind;
+      if (blind !== void 0) {
+        return `${gate.path} may read files git does not list, which differ between worktrees (${blind})`;
+      }
+    }
+    return null;
+  } catch (error) {
+    if (!(error instanceof AffectedError)) {
+      throw error;
+    }
+    return `what a gate depends on cannot be told, so it may read files git does not list, which differ between worktrees: ${error.message}`;
+  }
+}
+function guardIncremental(manifest, config, strykerArgs, part, affected, found) {
+  const decision = decideReuse(manifest, config, strykerArgs, part, affected, found);
+  const nothing = {
+    force: null,
+    mutate: null,
+    said: [],
+    temp: decision.temp,
+    record: () => void 0
+  };
   if (!decision.incremental) {
     return affected ? {
       ...nothing,
@@ -4161,10 +4766,14 @@ function guardIncremental(manifest, config, strykerArgs, part, affected) {
   const incremental = decision.incrementalHash;
   const options = { force: decision.forced };
   if (part) {
-    fs8.rmSync(recordFile, { force: true });
+    fs10.rmSync(recordFile, { force: true });
     return { ...nothing, force };
   }
-  fs8.rmSync(recordFile, { force: true });
+  if (decision.seed !== null) {
+    fs10.mkdirSync(path10.dirname(incrementalFile), { recursive: true });
+    fs10.writeFileSync(incrementalFile, decision.seed.incremental);
+  }
+  fs10.rmSync(recordFile, { force: true });
   const before = modifiedAt(incrementalFile);
   const rerun = plan !== null && "rerun" in plan ? plan.rerun.map((entry) => entry.gate) : null;
   const everyGate = force ?? (rerun !== null && rerun.length > 0 && rerun.length === manifest.gates.length ? "every gate is affected" : null);
@@ -4179,7 +4788,7 @@ function guardIncremental(manifest, config, strykerArgs, part, affected) {
         rerun: timedOut,
         expected
       } = timeoutRanges(
-        JSON.parse(fs8.readFileSync(incrementalFile, "utf8")),
+        JSON.parse(fs10.readFileSync(incrementalFile, "utf8")),
         kept
       ));
     } catch {
@@ -4210,11 +4819,20 @@ function guardIncremental(manifest, config, strykerArgs, part, affected) {
       said.push(`test-gates mutation: ${describeExpected(expected)}`);
     }
   }
+  if (decision.seed !== null) {
+    if (said.length === 0 && everyGate !== null) {
+      said.push(forcedLine(everyGate));
+    }
+    said.unshift(
+      `test-gates mutation: this worktree has no record of its own, so it starts from the one of the main worktree (${decision.mainWorktree})`
+    );
+  }
   return {
     // Every gate is run again: the same as a run of every mutant.
     force: everyGate,
     mutate: subset.length + ranges.length > 0 ? [...subset, ...ranges] : null,
     said,
+    temp: decision.temp,
     record: (judged) => {
       const written = hashFile(incrementalFile);
       if (snapshot === null || written === null || modifiedAt(incrementalFile) === before) {
@@ -4225,7 +4843,7 @@ function guardIncremental(manifest, config, strykerArgs, part, affected) {
         record.affected = affectedRecord(judged, ran, last);
       }
       try {
-        fs8.writeFileSync(recordFile, `${JSON.stringify(record)}
+        fs10.writeFileSync(recordFile, `${JSON.stringify(record)}
 `);
       } catch {
       }
@@ -4256,7 +4874,11 @@ function guardIncremental(manifest, config, strykerArgs, part, affected) {
       for (const gate of Object.keys(covering)) {
         const entry = inputs.gates[gate];
         if (entry !== void 0) {
-          recorded[gate] = { specs: entry.specs, files: entry.files };
+          recorded[gate] = {
+            specs: entry.specs,
+            files: entry.files,
+            ...entry.blind === void 0 ? {} : { blind: entry.blind }
+          };
         }
       }
       return { tests: Object.keys(judged.report.testFiles ?? {}).sort(), gates: recorded };
@@ -4268,11 +4890,11 @@ function guardIncremental(manifest, config, strykerArgs, part, affected) {
     }
   }
 }
-function runMutation(dir, strykerArgs, io2, only = [], affected = false) {
+function runMutation(dir, strykerArgs, io2, only = [], affected = false, shard = null) {
   const part = only.length > 0;
-  if (affected && strykerArgs.some((arg) => /^(?:--mutate|-m)(?:=|$)/.test(arg))) {
+  if ((affected || shard !== null) && strykerArgs.some((arg) => /^(?:--mutate|-m)(?:=|$)/.test(arg))) {
     throw new UsageError(
-      "--affected and --mutate cannot be combined: --affected sets --mutate itself"
+      `${affected ? "--affected" : "--shard"} and --mutate cannot be combined: ${affected ? "--affected" : "--shard"} sets --mutate itself`
     );
   }
   if (part) {
@@ -4289,11 +4911,12 @@ function runMutation(dir, strykerArgs, io2, only = [], affected = false) {
     gates: manifest.gates.map((gate) => gate.path),
     mode: "all",
     only,
-    shard: null
+    shard
   });
   if ("error" in chosen) {
     throw new UsageError(chosen.error);
   }
+  const shardGates = shard === null ? null : chosen.selected;
   const config = findStrykerConfig(manifest);
   if (config === null) {
     throw new ManifestError(
@@ -4307,53 +4930,122 @@ function runMutation(dir, strykerArgs, io2, only = [], affected = false) {
     );
   }
   const reportFile = reportPathOf(manifest, null);
-  fs8.rmSync(reportFile, { force: true });
-  const guard = guardIncremental(manifest, config, strykerArgs, part, affected);
+  fs10.rmSync(reportFile, { force: true });
+  let removed = [];
+  const guard = guardIncremental(manifest, config, strykerArgs, part, affected, (temp) => {
+    removed = removeStaleSandboxes(manifest.dir, temp);
+  });
   if (guard.said.length > 0) {
     guard.said.forEach((line) => io2.out(line));
   } else if (guard.force !== null) {
-    io2.out(
-      `test-gates mutation: running every mutant again (--force), the results of the last run are not reused: ${guard.force}`
-    );
+    io2.out(forcedLine(guard.force));
   }
+  removed.forEach((line) => io2.out(line));
   const guardArgs = guard.force === null && guard.mutate === null ? [] : ["--force"];
-  const partArgs = part ? ["--mutate", chosen.selected.join(",")] : guard.mutate !== null ? ["--mutate", guard.mutate.join(",")] : [];
-  const result = spawnSync2(stryker, ["run", config, ...strykerArgs, ...partArgs, ...guardArgs], {
-    cwd: manifest.dir,
-    stdio: "inherit",
-    shell: process.platform === "win32"
-  });
-  if (result.error) {
-    io2.err(`test-gates mutation: cannot start Stryker (${result.error.message})`);
-    return 1;
-  }
-  if (result.status !== 0) {
-    io2.err(
-      `test-gates mutation: Stryker failed (${result.signal ? `signal ${result.signal}` : `exit ${result.status}`}). The result was not judged`
+  const partArgs = part || shardGates !== null ? ["--mutate", (shardGates ?? chosen.selected).join(",")] : guard.mutate !== null ? ["--mutate", guard.mutate.join(",")] : [];
+  const judged = part ? chosen.selected : shardGates ?? [];
+  const unmark = markRun(manifest.dir, guard.temp);
+  let retried;
+  try {
+    const result = spawnSync4(stryker, ["run", config, ...strykerArgs, ...partArgs, ...guardArgs], {
+      cwd: manifest.dir,
+      stdio: "inherit",
+      shell: process.platform === "win32"
+    });
+    if (result.error) {
+      io2.err(`test-gates mutation: cannot start Stryker (${result.error.message})`);
+      return 1;
+    }
+    if (result.status !== 0) {
+      io2.err(
+        `test-gates mutation: Stryker failed (${result.signal ? `signal ${result.signal}` : `exit ${result.status}`}). The result was not judged`
+      );
+      return 1;
+    }
+    retried = retryTimeouts(
+      stryker,
+      [config, ...strykerArgs],
+      manifest,
+      reportFile,
+      judged.length > 0 ? manifest.gates.filter((gate) => judged.includes(gate.path)) : manifest.gates,
+      io2
     );
-    return 1;
+  } finally {
+    unmark();
   }
-  let judged = null;
-  const status = runMutationResult(dir, null, io2, part ? chosen.selected : [], (seen) => {
-    judged = seen;
-  });
-  guard.record(judged);
+  let lastSeen = null;
+  const status = runMutationResult(
+    dir,
+    null,
+    io2,
+    judged,
+    (seen) => {
+      lastSeen = seen;
+    },
+    retried,
+    shard
+  );
+  guard.record(lastSeen);
   if (part) {
-    fs8.rmSync(reportFile, { force: true });
+    fs10.rmSync(reportFile, { force: true });
   }
   return status;
 }
+function retryTimeouts(stryker, args, manifest, reportFile, gates, io2) {
+  let first;
+  try {
+    first = JSON.parse(fs10.readFileSync(reportFile, "utf8"));
+  } catch {
+    return null;
+  }
+  if (typeof first !== "object" || first === null) {
+    return null;
+  }
+  const { ranges, rerun } = timeoutRanges(first, gates);
+  if (ranges.length === 0 || rerun <= manifest.settings.maxTimeouts) {
+    return null;
+  }
+  io2.out(
+    `test-gates mutation: ${rerun} mutant(s) timed out outside expectedTimeouts, running them again one at a time (--concurrency 1)`
+  );
+  fs10.rmSync(reportFile, { force: true });
+  const result = spawnSync4(
+    stryker,
+    ["run", ...args, "--mutate", ranges.join(","), "--concurrency", "1", "--force"],
+    { cwd: manifest.dir, stdio: "inherit", shell: process.platform === "win32" }
+  );
+  let retry = null;
+  if (!result.error && result.status === 0) {
+    try {
+      retry = JSON.parse(fs10.readFileSync(reportFile, "utf8"));
+    } catch {
+      retry = null;
+    }
+  }
+  if (retry === null || typeof retry !== "object") {
+    const why = result.error ? result.error.message : result.signal ? `signal ${result.signal}` : result.status === 0 ? "no report" : `exit ${result.status}`;
+    io2.err(
+      `test-gates mutation: running the timed-out mutants again failed (${why}). The first run is judged`
+    );
+    fs10.writeFileSync(reportFile, JSON.stringify(first));
+    return "failed";
+  }
+  const merged = mergeRetry(first, retry, gates);
+  fs10.writeFileSync(reportFile, JSON.stringify(merged.report));
+  io2.out(formatRetry(merged.outcome));
+  return merged.outcome;
+}
 
 // src/commands/doctor.ts
 function read(file) {
   try {
-    return fs9.readFileSync(file, "utf8");
+    return fs11.readFileSync(file, "utf8");
   } catch {
     return null;
   }
 }
-function git2(dir, args) {
-  const result = spawnSync3("git", args, {
+function git3(dir, args) {
+  const result = spawnSync5("git", args, {
     cwd: dir,
     env: gitEnvironment(process.env),
     encoding: "utf8"
@@ -4361,20 +5053,20 @@ function git2(dir, args) {
   return result.status === 0 ? result.stdout.trim() : null;
 }
 function hooksOf(dir) {
-  const root = git2(dir, ["rev-parse", "--show-toplevel"]) ?? dir;
-  const hooksDir = git2(dir, ["rev-parse", "--path-format=absolute", "--git-path", "hooks"]);
+  const root = git3(dir, ["rev-parse", "--show-toplevel"]) ?? dir;
+  const hooksDir = git3(dir, ["rev-parse", "--path-format=absolute", "--git-path", "hooks"]);
   const candidates = [
-    ...["pre-push", "pre-commit"].map((name) => path9.join(root, ".husky", name)),
-    ...hooksDir === null ? [] : ["pre-push", "pre-commit"].map((name) => path9.join(hooksDir, name)),
-    ...["lefthook.yml", ".lefthook.yml"].map((name) => path9.join(root, name))
+    ...["pre-push", "pre-commit"].map((name) => path11.join(root, ".husky", name)),
+    ...hooksDir === null ? [] : ["pre-push", "pre-commit"].map((name) => path11.join(hooksDir, name)),
+    ...["lefthook.yml", ".lefthook.yml"].map((name) => path11.join(root, name))
   ];
   let script = "";
   try {
-    const manifest = JSON.parse(read(path9.join(dir, "package.json")) ?? "{}");
+    const manifest = JSON.parse(read(path11.join(dir, "package.json")) ?? "{}");
     script = manifest.scripts?.["test:gates:mutation"] ?? "";
   } catch {
   }
-  const subproject = path9.relative(fs9.realpathSync(root), dir).split(path9.sep).join("/");
+  const subproject = path11.relative(fs11.realpathSync(root), dir).split(path11.sep).join("/");
   const seen = /* @__PURE__ */ new Set();
   const uses = [];
   for (const file of candidates) {
@@ -4382,12 +5074,12 @@ function hooksOf(dir) {
     if (text === null) {
       continue;
     }
-    const real = fs9.realpathSync(file);
+    const real = fs11.realpathSync(file);
     if (seen.has(real)) {
       continue;
     }
     seen.add(real);
-    const shown = path9.relative(root, file).split(path9.sep).join("/");
+    const shown = path11.relative(root, file).split(path11.sep).join("/");
     uses.push(...hookUses({ file: shown, text, subproject, script }));
   }
   return uses;
@@ -4404,8 +5096,8 @@ function runDoctor(dir, io2) {
   const affected = decideReuse(manifest, config, [], false, true);
   io2.out(`test-gates doctor: ${manifest.dir} (${config})`);
   if (plain2.snapshot !== null) {
-    const subproject = path9.relative(plain2.root, fs9.realpathSync(manifest.dir));
-    const prefix = subproject === "" ? "" : `${subproject.split(path9.sep).join("/")}/`;
+    const subproject = path11.relative(plain2.root, fs11.realpathSync(manifest.dir));
+    const prefix = subproject === "" ? "" : `${subproject.split(path11.sep).join("/")}/`;
     const keys = Object.keys(plain2.snapshot.files);
     const outside = keys.filter((key) => !key.startsWith(prefix)).length;
     const followed = plain2.scope === null ? "" : "files" in plain2.scope ? `, paths followed in the ${plain2.scope.files} files the run loads` : ", paths followed in every file";
@@ -4416,6 +5108,15 @@ function runDoctor(dir, io2) {
     io2.out(
       reuse === null ? "  next run: reuses the results of the last run" : `  next run: every mutant, ${reuse}`
     );
+    if (plain2.seed !== null) {
+      io2.out(
+        `  this worktree has no record of its own: the next run starts from the one of the main worktree (${plain2.mainWorktree})`
+      );
+    } else if (plain2.mainWorktree !== null) {
+      io2.out(
+        `  this worktree has no record of its own, and the main worktree (${plain2.mainWorktree}) has none this worktree can start from`
+      );
+    }
     if (affected.ci !== null) {
       io2.out(`  next run with --affected: every mutant, ${affected.ci}`);
     } else if (affected.plan !== null && "rerun" in affected.plan) {
@@ -4432,15 +5133,20 @@ function runDoctor(dir, io2) {
     }
   }
   let blind = null;
+  let blindGates = [];
   if (plain2.snapshot !== null) {
     try {
-      affectedInputs(manifest, {
+      const inputs = affectedInputs(manifest, {
         root: plain2.root,
         files: plain2.snapshot.files,
         configs: plain2.configs(),
         tests: [],
         covering: {}
       });
+      blindGates = manifest.gates.flatMap((gate) => {
+        const reason = inputs.gates[gate.path]?.blind;
+        return reason === void 0 ? [] : [{ gate: gate.path, reason }];
+      });
     } catch (error) {
       if (!(error instanceof AffectedError)) {
         throw error;
@@ -4448,6 +5154,8 @@ function runDoctor(dir, io2) {
       blind = error.message;
     }
   }
+  const left = sandboxPlan(manifest.dir, plain2.temp);
+  const count = "kept" in left.plan ? left.plan.kept.length : left.plan.remove.length;
   const { lines, status } = formatFindings(
     diagnose({
       incremental: plain2.incremental,
@@ -4455,8 +5163,16 @@ function runDoctor(dir, io2) {
       failure: plain2.failure,
       widened: plain2.widened,
       scope: plain2.scope,
-      hooks: hooksOf(fs9.realpathSync(manifest.dir)),
-      blind
+      hooks: hooksOf(fs11.realpathSync(manifest.dir)),
+      blind,
+      blindGates,
+      gates: manifest.gates.length,
+      sandboxes: count === 0 ? null : {
+        tempDir: left.shown,
+        count,
+        kept: "kept" in left.plan ? left.plan.why : null,
+        running: "kept" in left.plan ? left.plan.running : null
+      }
     })
   );
   lines.forEach((line) => io2.out(line));
@@ -4464,8 +5180,8 @@ function runDoctor(dir, io2) {
 }
 
 // src/commands/lcov.ts
-import fs10 from "fs";
-import path10 from "path";
+import fs12 from "fs";
+import path12 from "path";
 
 // src/core/lcov.ts
 function normalizePath2(file, rootDir) {
@@ -4492,9 +5208,9 @@ function parseLcov(text, rootDir) {
     const line = rawLine.trim();
     if (line.startsWith("SF:")) {
       closeRecord();
-      const path13 = normalizePath2(line.slice(3), rootDir);
-      const file = files.get(path13) ?? { lines: /* @__PURE__ */ new Map(), found: 0, hit: 0 };
-      files.set(path13, file);
+      const path15 = normalizePath2(line.slice(3), rootDir);
+      const file = files.get(path15) ?? { lines: /* @__PURE__ */ new Map(), found: 0, hit: 0 };
+      files.set(path15, file);
       record = { file, hasDa: false, found: 0, hit: 0 };
     } else if (line === "end_of_record") {
       closeRecord();
@@ -4578,10 +5294,10 @@ function runLcov(dir, fileOption, io2) {
       "no lcov file given. Pass --file <lcov.info> or set settings.lcov.file"
     );
   }
-  const lcovPath = path10.resolve(manifest.dir, file);
+  const lcovPath = path12.resolve(manifest.dir, file);
   let text;
   try {
-    text = fs10.readFileSync(lcovPath, "utf8");
+    text = fs12.readFileSync(lcovPath, "utf8");
   } catch (error) {
     io2.err(
       `test-gates lcov: cannot read ${file} (${error.message}). Run the tests with coverage first`
@@ -4624,10 +5340,10 @@ function runLcov(dir, fileOption, io2) {
 }
 
 // src/commands/selfcheck.ts
-import { spawn, spawnSync as spawnSync4 } from "child_process";
-import fs12 from "fs";
+import { spawn, spawnSync as spawnSync6 } from "child_process";
+import fs14 from "fs";
 import os2 from "os";
-import path12 from "path";
+import path14 from "path";
 
 // src/core/jobs.ts
 var SWITCHES = {
@@ -4667,6 +5383,34 @@ function knownCommand(program, args) {
 function jobFlags(runner, dir) {
   return runner === "jest" ? [`--coverageDirectory=${dir}/coverage`, `--cacheDirectory=${dir}/cache`] : [`--coverage.reportsDirectory=${dir}/coverage`, "--no-cache"];
 }
+var LIMITS = {
+  jest: ["--runInBand", "-i", "--maxWorkers", "-w"],
+  vitest: ["--no-file-parallelism", "--fileParallelism", "--maxWorkers", "--minWorkers"]
+};
+var CONFIG_LIMITS = [
+  "maxWorkers",
+  "minWorkers",
+  "maxThreads",
+  "minThreads",
+  "maxForks",
+  "minForks",
+  "fileParallelism",
+  "singleThread",
+  "singleFork"
+];
+function workerFlags(input) {
+  if (input.lines <= 1) {
+    return [];
+  }
+  const given = input.args.some(
+    (arg) => LIMITS[input.runner].includes(arg.split("=")[0])
+  );
+  const configured = CONFIG_LIMITS.some((word) => input.configSource?.includes(word) === true);
+  if (given || configured) {
+    return [];
+  }
+  return [`--maxWorkers=${Math.max(1, Math.floor(input.cores / input.lines))}`];
+}
 var REACHES = [
   "process.",
   "process?.",
@@ -4690,6 +5434,11 @@ var REACHES = [
   "WebSocket",
   "XMLHttpRequest",
   "navigator",
+  // What crypto keeps as a setting of its module, for every spec file of a worker after it.
+  "setFips",
+  "setEngine",
+  "setDefaultEncoding",
+  "DEFAULT_ENCODING",
   "Atomics",
   "WeakRef",
   "FinalizationRegistry",
@@ -4698,10 +5447,35 @@ var REACHES = [
 ];
 var COMPUTED_LOAD = /(?:require|import)\((?!['"])|\brequire(?!\(|\.resolve\b|[\w$])|\bimport\.meta\.glob\b/;
 var COMPUTED = "loads a module whose name is computed";
+var STRING = /(^|[:,([={?+&|;])(\s*)(['"])((?:\\.|(?!\3)[^\\\n])*)\3(?=\s*(?:[,}\]);:+?&|]|$))/gm;
+function withoutStrings(source) {
+  return source.replace(
+    STRING,
+    (all, before, space, quote, inside) => (
+      // In a template (`{"home": "${home()}"}`) the quotes are text, and what is
+      // between them may be code.
+      inside.includes("${") ? all : `${before}${space}${quote}${" ".repeat(inside.length)}${quote}`
+    )
+  );
+}
+var PURE_BUILTINS = [
+  "assert",
+  "assert/strict",
+  "crypto",
+  "path",
+  "path/posix",
+  "path/win32",
+  "punycode",
+  "querystring",
+  "string_decoder",
+  "url",
+  "util/types"
+];
 var RUNNER_PACKAGES = ["vitest", "@jest/globals"];
 function reachesOutside(file, trusted) {
   const dense = file.source.replace(/\s/g, "");
-  const mark = REACHES.find((text) => dense.includes(text));
+  const code = withoutStrings(file.source).replace(/\s/g, "");
+  const mark = REACHES.find((text) => code.includes(text));
   if (mark !== void 0) {
     return `uses ${mark.replace(/[.?[(:]+$/, "")}`;
   }
@@ -4710,7 +5484,9 @@ function reachesOutside(file, trusted) {
   }
   for (const { specifier, builtin } of file.imports) {
     if (builtin) {
-      return `imports ${specifier}`;
+      if (!PURE_BUILTINS.includes(specifier.replace(/^node:/, ""))) {
+        return `imports ${specifier}`;
+      }
     } else if (![...RUNNER_PACKAGES, ...trusted].some(
       (name) => specifier === name || specifier.startsWith(`${name}/`)
     )) {
@@ -4844,8 +5620,8 @@ function cleanHold(input) {
 
 // src/touch.ts
 import { createHash as createHash2 } from "crypto";
-import fs11 from "fs";
-import path11 from "path";
+import fs13 from "fs";
+import path13 from "path";
 import { fileURLToPath } from "url";
 var TOUCH_ENV = "TEST_GATES_TOUCH_DIR";
 function isObject(value) {
@@ -4879,7 +5655,7 @@ function isCounters(value) {
 function readNotes(directory) {
   const read2 = (file) => {
     try {
-      return JSON.parse(fs11.readFileSync(path11.join(directory, file), "utf8"));
+      return JSON.parse(fs13.readFileSync(path13.join(directory, file), "utf8"));
     } catch {
       return null;
     }
@@ -4887,8 +5663,8 @@ function readNotes(directory) {
   const run = read2("run.json");
   let notes = [];
   try {
-    for (const name of fs11.readdirSync(path11.join(directory, "specs"))) {
-      const note = read2(path11.join("specs", name));
+    for (const name of fs13.readdirSync(path13.join(directory, "specs"))) {
+      const note = read2(path13.join("specs", name));
       if (!isObject(note) || typeof note.spec !== "string" || !isObject(note.files) || !Object.values(note.files).every(isCounters)) {
         throw new Error("not a note");
       }
@@ -4900,7 +5676,7 @@ function readNotes(directory) {
   return {
     run: isObject(run) && typeof run.runner === "string" && typeof run.version === "string" && typeof run.provider === "string" && typeof run.pool === "string" && typeof run.isolate === "boolean" && typeof run.projects === "number" && (run.problem === null || typeof run.problem === "string") ? run : null,
     notes,
-    totals: countersOfAll(read2(path11.join("coverage", "coverage-final.json")))
+    totals: countersOfAll(read2(path13.join("coverage", "coverage-final.json")))
   };
 }
 
@@ -4915,7 +5691,7 @@ function resolveGateCommand(manifest) {
   if (manifest.settings.gateCommand !== null) {
     return manifest.settings.gateCommand;
   }
-  const exists = (name) => fs12.existsSync(path12.join(manifest.dir, name));
+  const exists = (name) => fs14.existsSync(path14.join(manifest.dir, name));
   const jest = JEST_CONFIGS.find(exists);
   const vitest = VITEST_CONFIGS.find(exists);
   if (jest && vitest) {
@@ -4936,7 +5712,7 @@ function resolveGateCommand(manifest) {
 var TOUCH_PREFIX = ".test-gates-touch-";
 function realPath(file) {
   try {
-    return fs12.realpathSync(file);
+    return fs14.realpathSync(file);
   } catch {
     return file;
   }
@@ -4944,13 +5720,16 @@ function realPath(file) {
 function shareOneRun(manifest, targets, runGate) {
   let touchDir;
   try {
-    for (const name of fs12.readdirSync(manifest.dir)) {
-      const left = path12.join(manifest.dir, name);
-      if (name.startsWith(TOUCH_PREFIX) && Date.now() - fs12.statSync(left).mtimeMs > 36e5) {
-        fs12.rmSync(left, { recursive: true, force: true });
+    for (const name of fs14.readdirSync(manifest.dir)) {
+      const left = path14.join(manifest.dir, name);
+      try {
+        if (name.startsWith(TOUCH_PREFIX) && Date.now() - fs14.statSync(left).mtimeMs > 36e5) {
+          fs14.rmSync(left, { recursive: true, force: true });
+        }
+      } catch {
       }
     }
-    touchDir = fs12.mkdtempSync(path12.join(manifest.dir, TOUCH_PREFIX));
+    touchDir = fs14.mkdtempSync(path14.join(manifest.dir, TOUCH_PREFIX));
   } catch {
     return { reason: "the subproject cannot be written to" };
   }
@@ -4961,14 +5740,14 @@ function shareOneRun(manifest, targets, runGate) {
       return { reason: "the gate run with every spec does not pass" };
     }
     const base = realPath(manifest.dir);
-    const absolute = (file) => realPath(path12.resolve(base, file));
+    const absolute = (file) => realPath(path14.resolve(base, file));
     const rekeyed = (files) => Object.fromEntries(Object.entries(files).map(([file, value]) => [absolute(file), value]));
     const left = readNotes(touchDir);
     plan = planControls({
       all: manifest.gates.map((gate) => ({
         path: gate.path,
-        file: path12.join(base, gate.path),
-        specFile: path12.join(base, gate.spec ?? "")
+        file: path14.join(base, gate.path),
+        specFile: path14.join(base, gate.spec ?? "")
       })),
       targets: targets.map((gate) => gate.path),
       run: left.run,
@@ -4977,7 +5756,7 @@ function shareOneRun(manifest, targets, runGate) {
       failurePattern: manifest.settings.selfcheckFailurePattern
     });
   } finally {
-    fs12.rmSync(touchDir, { recursive: true, force: true });
+    fs14.rmSync(touchDir, { recursive: true, force: true });
   }
   if (plan.reason !== null) {
     return { reason: plan.reason };
@@ -4987,15 +5766,15 @@ function shareOneRun(manifest, targets, runGate) {
   return { gates, result: runGate({ excludeAll: gates.map((gate) => gate.spec) }) };
 }
 function installedVersion2(start, name) {
-  let current = path12.resolve(start);
+  let current = path14.resolve(start);
   for (; ; ) {
     try {
       const manifest = JSON.parse(
-        fs12.readFileSync(path12.join(current, "node_modules", name, "package.json"), "utf8")
+        fs14.readFileSync(path14.join(current, "node_modules", name, "package.json"), "utf8")
       );
       return typeof manifest.version === "string" ? manifest.version : null;
     } catch {
-      const parent = path12.dirname(current);
+      const parent = path14.dirname(current);
       if (parent === current) {
         return null;
       }
@@ -5024,24 +5803,39 @@ async function runAtOnce(manifest, gates, jobs, runner, executable, args) {
   const results = /* @__PURE__ */ new Map();
   let root;
   try {
-    for (const name of fs12.readdirSync(os2.tmpdir())) {
-      const left = path12.join(os2.tmpdir(), name);
-      if (name.startsWith(JOBS_PREFIX) && Date.now() - fs12.statSync(left).mtimeMs > 36e5) {
-        fs12.rmSync(left, { recursive: true, force: true });
+    root = fs14.realpathSync(fs14.mkdtempSync(path14.join(os2.tmpdir(), JOBS_PREFIX)));
+  } catch {
+    return results;
+  }
+  try {
+    for (const name of fs14.readdirSync(os2.tmpdir())) {
+      const left = path14.join(os2.tmpdir(), name);
+      try {
+        if (name.startsWith(JOBS_PREFIX) && Date.now() - fs14.statSync(left).mtimeMs > 36e5) {
+          fs14.rmSync(left, { recursive: true, force: true });
+        }
+      } catch {
       }
     }
-    root = fs12.realpathSync(fs12.mkdtempSync(path12.join(os2.tmpdir(), JOBS_PREFIX)));
   } catch {
-    return results;
   }
   const queue = [...gates];
+  const lines = Math.min(jobs, gates.length);
+  const workers = workerFlags({
+    runner,
+    args,
+    configSource: gateConfigSource(manifest, args),
+    lines,
+    // (os.availableParallelism is in Node 18.14 and later.)
+    cores: os2.availableParallelism?.() ?? os2.cpus().length
+  });
   const line = async (dir) => {
     for (let gate = queue.shift(); gate !== void 0; gate = queue.shift()) {
       const spec = gate.spec;
       results.set(
         gate,
         await new Promise((resolve) => {
-          const child = spawn(executable, [...args, ...jobFlags(runner, dir)], {
+          const child = spawn(executable, [...args, ...jobFlags(runner, dir), ...workers], {
             cwd: manifest.dir,
             env: { ...process.env, [EXCLUDE_ENV]: spec, [EXCLUDE_ALL_ENV]: "", [TOUCH_ENV]: "" },
             shell: process.platform === "win32"
@@ -5060,13 +5854,10 @@ async function runAtOnce(manifest, gates, jobs, runner, executable, args) {
   };
   try {
     await Promise.all(
-      Array.from(
-        { length: Math.min(jobs, gates.length) },
-        (_unused, index) => line(path12.join(root, `line-${index}`))
-      )
+      Array.from({ length: lines }, (_unused, index) => line(path14.join(root, `line-${index}`)))
     );
   } finally {
-    fs12.rmSync(root, { recursive: true, force: true });
+    fs14.rmSync(root, { recursive: true, force: true });
   }
   return results;
 }
@@ -5095,7 +5886,7 @@ async function runSelfcheck(dir, selection, commandOverride, io2) {
   const command = commandOverride.length > 0 ? commandOverride : resolveGateCommand(manifest);
   const [program, ...args] = command;
   const executable = findLocalBin(manifest.dir, program) ?? program;
-  const runGate = (env) => spawnSync4(executable, args, {
+  const runGate = (env) => spawnSync6(executable, args, {
     cwd: manifest.dir,
     env: {
       ...process.env,
@@ -5173,6 +5964,11 @@ async function runSelfcheck(dir, selection, commandOverride, io2) {
           ...manifest.gates.flatMap((gate) => [gate.path, gate.spec])
         ].sort((left, right) => right.length - left.length);
         const results = await runAtOnce(manifest, atOnce, jobs, known.runner, executable, args);
+        if (results.size === 0) {
+          io2.out(
+            `test-gates selfcheck: one negative control at a time (no directory for the runs next to others could be made in ${os2.tmpdir()})`
+          );
+        }
         for (const [gate, result] of results) {
           const output = `${result.stdout}${result.stderr}`;
           const clean = cleanHold({
@@ -5190,7 +5986,7 @@ async function runSelfcheck(dir, selection, commandOverride, io2) {
           }
         }
         const again = atOnce.length - heldAtOnce.size;
-        if (again > 0) {
+        if (again > 0 && results.size > 0) {
           io2.out(
             `test-gates selfcheck: ${again} of ${atOnce.length} negative control(s) did not hold cleanly next to others and run again on their own`
           );
@@ -5278,7 +6074,9 @@ Options:
   --affected                  mutation: run again only the gates that a change since the last
                               run can affect, and reuse the results of the others. Every
                               mutant is run when CI is set
-  --shard <index>/<total>     selfcheck: one of <total> parts of the gates, for parallel CI jobs
+  --shard <index>/<total>     selfcheck, mutation: one of <total> parts of the gates, for parallel CI
+                              jobs. For mutation the gates are sorted and dealt out in turn; every
+                              part has to run. Accepted when CI is set
   --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.
@@ -5313,7 +6111,7 @@ function main(argv) {
     case "doctor":
       return runDoctor(args.dir, io);
     case "mutation":
-      return runMutation(args.dir, args.rest, io, args.gates, args.affected);
+      return runMutation(args.dir, args.rest, io, args.gates, args.affected, args.shard);
     case "mutation-result":
       return runMutationResult(args.dir, args.report, io);
     case "selfcheck":