@blzsky/variant 0.3.0-canary.0 → 0.3.0-canary.1

package/dist/check-AKYABBIV.js

@@ -0,0 +1,1459 @@
+import {
+  defaultIsTestFile
+} from "./chunk-BNACT47L.js";
+import {
+  assertBaseRef,
+  createClassifier
+} from "./chunk-JEJRXPCU.js";
+import "./chunk-TRUK3TJF.js";
+import {
+  mapLimit
+} from "./chunk-GDSZFIHM.js";
+import "./chunk-MKUYZIXF.js";
+import {
+  plural
+} from "./chunk-CXNXZLDG.js";
+import "./chunk-3E5LBU3O.js";
+import {
+  errorLines,
+  lines
+} from "./chunk-6J4XDG44.js";
+import {
+  getColors
+} from "./chunk-YYGCSKIQ.js";
+import {
+  getPrinter
+} from "./chunk-EISTWXDW.js";
+import {
+  changeBaseDeps,
+  resolveChangeBase
+} from "./chunk-O6FCFZDF.js";
+import {
+  EXCLUDED_MUTATORS
+} from "./chunk-WTXWEEI2.js";
+import "./chunk-X3VVGTEV.js";
+import {
+  hasLocalChanges,
+  listChangedFiles,
+  listUntrackedFiles,
+  readFileAtRef,
+  readZeroContextDiff
+} from "./chunk-OON6O4S5.js";
+import "./chunk-XXMD4NC5.js";
+import "./chunk-WULBOSG5.js";
+import {
+  BaselineFailedError,
+  CheckBackendError,
+  CheckRunnerError,
+  CheckWorkspaceRootError,
+  CliUsageError,
+  GitRefError,
+  NoChangeBaseError
+} from "./chunk-C3NZIFW6.js";
+
+// src/adapters/mutation/stryker.ts
+import { fork, spawnSync } from "child_process";
+import { existsSync, realpathSync } from "fs";
+import { mkdir, readdir, readFile, rm, writeFile } from "fs/promises";
+import path from "path";
+import { fileURLToPath } from "url";
+var EXCLUDED = new Set(EXCLUDED_MUTATORS);
+var OUTPUT_LINES = 200;
+var KILL_WAIT_MS = 5e3;
+var OUTPUT_SETTLE_MS = 250;
+var CHECK_TMP = path.join(".variant", "check-tmp");
+function toPosix(file) {
+  return file.replace(/\\/g, "/");
+}
+function projectRoots(cwd) {
+  try {
+    const real = realpathSync(cwd);
+    return real === cwd ? [cwd] : [cwd, real];
+  } catch {
+    return [cwd];
+  }
+}
+function relativeFile(roots, fileName) {
+  for (const root of roots) {
+    const relative = path.relative(root, fileName);
+    if (!relative.startsWith("..") && !path.isAbsolute(relative)) {
+      return toPosix(relative);
+    }
+  }
+  return toPosix(path.relative(roots[0] ?? "", fileName));
+}
+function toPlannedMutant(roots, raw) {
+  return {
+    id: raw.id,
+    file: relativeFile(roots, raw.fileName),
+    mutator: raw.mutatorName,
+    replacement: raw.replacement,
+    start: {
+      line: raw.location.start.line + 1,
+      column: raw.location.start.column + 1
+    },
+    end: {
+      line: raw.location.end.line + 1,
+      column: raw.location.end.column + 1
+    },
+    // No coverage information at all means Stryker runs every test
+    // against it: it counts toward the limit like any covered mutant.
+    covered: raw.coveredBy === void 0 || raw.coveredBy.length > 0,
+    static: raw.static === true
+  };
+}
+var STATUSES = /* @__PURE__ */ new Set([
+  "Killed",
+  "Survived",
+  "NoCoverage",
+  "Timeout",
+  "RuntimeError",
+  "CompileError",
+  "Ignored",
+  "Pending"
+]);
+function toTestedMutant(raw) {
+  const status = STATUSES.has(raw.status) ? raw.status : "RuntimeError";
+  return {
+    id: raw.id,
+    status,
+    ...raw.statusReason !== void 0 && { statusReason: raw.statusReason },
+    killedBy: raw.killedBy ?? [],
+    ...raw.testsCompleted !== void 0 && {
+      testsCompleted: raw.testsCompleted
+    }
+  };
+}
+function toBaselineTest(roots, raw) {
+  return {
+    id: raw.id,
+    name: raw.name,
+    file: raw.fileName === void 0 ? raw.id.split("#")[0] ?? "" : relativeFile(roots, raw.fileName),
+    skipped: raw.skipped === true
+  };
+}
+var ANSI = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, "g");
+var SANDBOX_PREFIX = /(?:[A-Za-z]:)?[^\s'"`]*?[\\/]\.variant[\\/]check-tmp[\\/][^\\/\s]+[\\/]sandbox-[^\\/\s]+[\\/]/g;
+function withoutSandbox(text) {
+  return text.replace(SANDBOX_PREFIX, "");
+}
+function parseFailingTests(output) {
+  const lines2 = withoutSandbox(output.replace(ANSI, "")).split(/\r?\n/);
+  const start = lines2.findIndex(
+    (line) => /tests failed in the initial test run:\s*$/i.test(line)
+  );
+  if (start === -1) return [];
+  const tests = [];
+  for (const line of lines2.slice(start + 1)) {
+    if (/^\t\t/.test(line)) {
+      const last = tests[tests.length - 1];
+      if (last !== void 0) {
+        last.message = last.message === "" ? line.trim() : `${last.message} ${line.trim()}`;
+      }
+    } else if (/^\t\S/.test(line)) {
+      tests.push({ name: line.trim(), message: "" });
+    } else {
+      break;
+    }
+  }
+  return tests;
+}
+function hostEnvironment(env, ceiling) {
+  const out = {};
+  for (const [key, value] of Object.entries(env)) {
+    if (value === void 0) continue;
+    if (/^GIT_(DIR|INDEX_FILE|WORK_TREE|COMMON_DIR|OBJECT_DIRECTORY|PREFIX)$/.test(
+      key
+    )) {
+      continue;
+    }
+    if (/^GITHUB_(STEP_SUMMARY|OUTPUT|ENV|PATH)$/.test(key)) continue;
+    if (key.startsWith("VITEST_")) continue;
+    out[key] = value;
+  }
+  out["GIT_CEILING_DIRECTORIES"] = ceiling;
+  out["VARIANT_SHADOW"] = "0";
+  return out;
+}
+function isAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+async function removeInside(root, target) {
+  const resolved = path.resolve(target);
+  if (!resolved.startsWith(path.resolve(root) + path.sep)) return;
+  await rm(resolved, { recursive: true, force: true, maxRetries: 5 });
+}
+async function sweep(root) {
+  const names = await readdir(root).catch(() => []);
+  await Promise.all(
+    names.filter((name) => name.endsWith(".owner")).map(async (name) => {
+      const pid = Number(
+        (await readFile(path.join(root, name), "utf8").catch(() => "")).trim()
+      );
+      if (Number.isInteger(pid) && pid > 0 && isAlive(pid)) return;
+      const runId = name.slice(0, -".owner".length);
+      await Promise.all([
+        removeInside(root, path.join(root, runId)),
+        removeInside(root, path.join(root, `${runId}.json`)),
+        removeInside(root, path.join(root, name))
+      ]);
+    })
+  );
+}
+var Channel = class {
+  queue = [];
+  waiting;
+  closed = false;
+  push(value) {
+    if (this.closed) return;
+    const waiting = this.waiting;
+    if (waiting !== void 0) {
+      this.waiting = void 0;
+      waiting({ value, done: false });
+    } else {
+      this.queue.push(value);
+    }
+  }
+  close() {
+    this.closed = true;
+    const waiting = this.waiting;
+    this.waiting = void 0;
+    waiting?.({ value: void 0, done: true });
+  }
+  [Symbol.asyncIterator]() {
+    return {
+      next: () => {
+        const value = this.queue.shift();
+        if (value !== void 0) return Promise.resolve({ value, done: false });
+        if (this.closed)
+          return Promise.resolve({ value: void 0, done: true });
+        return new Promise((resolve) => {
+          this.waiting = resolve;
+        });
+      }
+    };
+  }
+};
+function killTree(child) {
+  const pid = child.pid;
+  if (pid === void 0 || child.exitCode !== null || child.signalCode !== null) {
+    return;
+  }
+  if (process.platform === "win32") {
+    spawnSync("taskkill", ["/PID", String(pid), "/T", "/F"], {});
+    return;
+  }
+  try {
+    process.kill(-pid, "SIGKILL");
+  } catch {
+    child.kill("SIGKILL");
+  }
+}
+function exited(child) {
+  if (child.exitCode !== null || child.signalCode !== null)
+    return Promise.resolve();
+  return new Promise((resolve) => {
+    const timer = setTimeout(resolve, KILL_WAIT_MS);
+    child.once("close", () => {
+      clearTimeout(timer);
+      resolve();
+    });
+  });
+}
+function builtSibling(name) {
+  return fileURLToPath(new URL(`./${name}`, import.meta.url));
+}
+function createStrykerBackend(options = {}) {
+  return {
+    start: (request) => startRun(request, options)
+  };
+}
+function startRun(request, options) {
+  const channel = new Channel();
+  const output = [];
+  const remember = (chunk) => {
+    output.push(...new TextDecoder().decode(chunk).split(/\r?\n/));
+    if (output.length > OUTPUT_LINES)
+      output.splice(0, output.length - OUTPUT_LINES);
+  };
+  const root = path.join(request.cwd, CHECK_TMP);
+  const roots = projectRoots(request.cwd);
+  const variantDir = path.join(request.cwd, ".variant");
+  const createdVariantDir = !existsSync(variantDir);
+  const runId = `${Date.now().toString(36)}-${process.pid}`;
+  let child;
+  let stopping = false;
+  let stopped2;
+  const cleanup = async () => {
+    await Promise.all([
+      removeInside(root, path.join(root, runId)),
+      removeInside(root, path.join(root, `${runId}.json`)),
+      removeInside(root, path.join(root, `${runId}.owner`))
+    ]);
+    const left = await readdir(root).catch(() => []);
+    if (left.every((name) => name === ".gitignore")) {
+      await rm(root, { recursive: true, force: true });
+    }
+    if (createdVariantDir) {
+      const rest = await readdir(variantDir).catch(() => []);
+      if (rest.length === 0)
+        await rm(variantDir, { recursive: true, force: true });
+    }
+  };
+  const prepared = (async () => {
+    try {
+      await mkdir(root, { recursive: true });
+      await writeFile(path.join(root, ".gitignore"), "*\n");
+      await sweep(root);
+      await writeFile(path.join(root, `${runId}.owner`), String(process.pid));
+      await writeFile(path.join(root, `${runId}.json`), "{}\n");
+      return true;
+    } catch (error) {
+      channel.push({
+        kind: "error",
+        message: `Could not prepare ${CHECK_TMP}: ${error instanceof Error ? error.message : String(error)}`,
+        output: ""
+      });
+      return false;
+    }
+  })();
+  const stop = () => {
+    stopped2 ??= (async () => {
+      stopping = true;
+      await prepared;
+      if (child !== void 0) {
+        killTree(child);
+        await exited(child);
+      }
+      await cleanup();
+      channel.close();
+    })();
+    return stopped2;
+  };
+  void (async () => {
+    if (!await prepared) {
+      channel.close();
+      return;
+    }
+    if (stopping) return;
+    const host = {
+      mutate: request.mutate,
+      ...request.vitestConfig !== void 0 && {
+        vitestConfig: request.vitestConfig
+      },
+      baselineTimeoutMinutes: request.baselineTimeoutMinutes,
+      tempDirName: toPosix(path.join(CHECK_TMP, runId)),
+      configFile: toPosix(path.join(CHECK_TMP, `${runId}.json`)),
+      plugins: options.pluginsPath ?? builtSibling("stryker-plugins.js")
+    };
+    const spawned = fork(
+      options.hostPath ?? builtSibling("stryker-host.js"),
+      [],
+      {
+        cwd: request.cwd,
+        env: { ...hostEnvironment(process.env, root), ...options.env },
+        execArgv: options.execArgv ?? [],
+        stdio: ["ignore", "pipe", "pipe", "ipc"],
+        // A process group of its own on POSIX, so one signal ends Stryker's
+        // workers too. On Windows a detached process opens a console of its
+        // own, and taskkill follows the process tree without one.
+        detached: process.platform !== "win32"
+      }
+    );
+    child = spawned;
+    spawned.stdout?.on("data", remember);
+    spawned.stderr?.on("data", remember);
+    const dropped = /* @__PURE__ */ new Set();
+    let terminal;
+    spawned.on("message", (message) => {
+      if (message.kind === "baseline") {
+        channel.push({
+          kind: "baseline",
+          tests: message.tests.map((test) => toBaselineTest(roots, test))
+        });
+      } else if (message.kind === "plan") {
+        const kept = message.mutants.filter((mutant) => {
+          if (!EXCLUDED.has(mutant.mutatorName)) return true;
+          dropped.add(mutant.id);
+          return false;
+        });
+        channel.push({
+          kind: "plan",
+          mutants: kept.map((mutant) => toPlannedMutant(roots, mutant)),
+          coverageMeasured: kept.length === 0 || kept.some((mutant) => mutant.coveredBy !== void 0)
+        });
+      } else if (message.kind === "tested") {
+        if (dropped.has(message.mutant.id)) return;
+        channel.push({
+          kind: "tested",
+          mutant: toTestedMutant(message.mutant)
+        });
+      } else if (message.kind === "note") {
+        channel.push({ kind: "note", text: message.text });
+      } else {
+        terminal = message;
+        if (message.kind === "finished") channel.push({ kind: "finished" });
+        else setTimeout(report, OUTPUT_SETTLE_MS);
+      }
+    });
+    spawned.on("error", (error) => {
+      if (stopping) return;
+      channel.push({
+        kind: "error",
+        message: error.message,
+        output: output.join("\n")
+      });
+      channel.close();
+    });
+    let reported = false;
+    let exit = "";
+    function report() {
+      if (reported || stopping) return;
+      reported = true;
+      const text = withoutSandbox(output.join("\n").trim());
+      if (terminal?.kind === "baseline-failed") {
+        channel.push({
+          kind: "baseline-failed",
+          failingTests: parseFailingTests(text),
+          output: text
+        });
+      } else if (terminal?.kind === "error") {
+        channel.push({
+          kind: "error",
+          message: terminal.message,
+          output: text
+        });
+      } else if (terminal === void 0) {
+        channel.push({
+          kind: "error",
+          message: `The mutation-testing engine exited (${exit}) before it finished`,
+          output: text
+        });
+      }
+      channel.close();
+    }
+    spawned.on("close", (code2, signal) => {
+      exit = signal ?? `code ${code2}`;
+      report();
+    });
+    spawned.send(host);
+  })();
+  return { events: channel, stop };
+}
+
+// src/core/check/run.ts
+import { createHash } from "crypto";
+import { readdir as readdir2, readFile as readFile2 } from "fs/promises";
+import path2 from "path";
+
+// src/core/semantic/equivalence.ts
+function shape(node, tsm, out) {
+  const { SyntaxKind, ts } = tsm;
+  if (node.getKind() === SyntaxKind.SingleLineCommentTrivia || node.getKind() === SyntaxKind.MultiLineCommentTrivia || tsm.Node.isJSDoc(node)) {
+    return;
+  }
+  if (tsm.Node.isParenthesizedExpression(node) && !(tsm.Node.isExpressionStatement(node.getParent()) && tsm.Node.isStringLiteral(node.getExpression()))) {
+    shape(node.getExpression(), tsm, out);
+    return;
+  }
+  const children = node.getChildren();
+  if (children.length === 0) {
+    if (node.getKind() !== SyntaxKind.EndOfFileToken) out.push(node.getText());
+    return;
+  }
+  const chain = (node.compilerNode.flags & ts.NodeFlags.OptionalChain) !== 0;
+  out.push(`(${node.getKindName()}${chain ? "?" : ""}`);
+  children.forEach((child, index) => {
+    const isLastComma = child.getKind() === SyntaxKind.CommaToken && index === children.length - 1 && node.getKind() === SyntaxKind.SyntaxList;
+    if (!isLastComma) shape(child, tsm, out);
+  });
+  out.push(")");
+}
+function createProgramComparer() {
+  let project;
+  let id = 0;
+  return async (filePath, before, after) => {
+    const tsm = await import("ts-morph");
+    project ??= new tsm.Project({ useInMemoryFileSystem: true });
+    const extension = /\.[cm]?tsx?$/.exec(filePath)?.[0] ?? ".ts";
+    const n = id++;
+    const a = project.createSourceFile(`/__a_${n}${extension}`, before);
+    const b = project.createSourceFile(`/__b_${n}${extension}`, after);
+    try {
+      const left = [];
+      const right = [];
+      shape(a, tsm, left);
+      shape(b, tsm, right);
+      return left.join(" ") === right.join(" ");
+    } finally {
+      project.removeSourceFile(a);
+      project.removeSourceFile(b);
+    }
+  };
+}
+
+// src/core/check/base.ts
+var NAMED = /* @__PURE__ */ new Set(["flag", "environment", "pull-request", "push"]);
+async function resolveCheckBase(explicit, deps) {
+  const detected = await resolveChangeBase(explicit, deps);
+  if (NAMED.has(detected.source)) {
+    return { ref: detected.ref, label: detected.label };
+  }
+  if (await deps.hasLocalChanges() === true) {
+    return { ref: "HEAD", label: "HEAD: your uncommitted changes" };
+  }
+  if (detected.source === "default-branch") {
+    return { ref: detected.ref, label: detected.label };
+  }
+  throw new NoChangeBaseError(
+    "Nothing to compare against: the working tree is clean and this branch has not left the default branch"
+  );
+}
+
+// src/core/check/hunks.ts
+var HUNK_HEADER = /^@@ -\d+(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/;
+function parseZeroContextDiff(diff) {
+  const added = [];
+  let deletedLines = 0;
+  for (const line of diff.split("\n")) {
+    const match = HUNK_HEADER.exec(line);
+    if (match === null) continue;
+    const oldCount = match[1] === void 0 ? 1 : Number(match[1]);
+    const start = Number(match[2]);
+    const newCount = match[3] === void 0 ? 1 : Number(match[3]);
+    if (newCount === 0) {
+      deletedLines += oldCount;
+      continue;
+    }
+    added.push({ start, end: start + newCount - 1 });
+  }
+  return { added, deletedLines };
+}
+function countLines(ranges) {
+  return ranges.reduce((sum, range) => sum + range.end - range.start + 1, 0);
+}
+
+// src/core/check/explain.ts
+var BOUNDARY = {
+  ">=": ">",
+  ">": ">=",
+  "<=": "<",
+  "<": "<="
+};
+var MAX_OPERAND = 40;
+function operatorChange(original, replacement) {
+  const a = original.replace(/\s+/g, "");
+  const b = replacement.replace(/\s+/g, "");
+  let prefix = 0;
+  while (prefix < a.length && prefix < b.length && a[prefix] === b[prefix]) {
+    prefix++;
+  }
+  let suffix = 0;
+  while (suffix < a.length - prefix && suffix < b.length - prefix && a[a.length - 1 - suffix] === b[b.length - 1 - suffix]) {
+    suffix++;
+  }
+  while (prefix > 0 && /[<>=!&|?]/.test(a[prefix - 1] ?? "")) prefix--;
+  while (suffix > 0 && /[<>=!&|?]/.test(a[a.length - suffix] ?? "")) suffix--;
+  const from = a.slice(prefix, a.length - suffix);
+  const to = b.slice(prefix, b.length - suffix);
+  if (!/^[<>=!&|?+\-*/%]+$/.test(from) || !/^[<>=!&|?+\-*/%]+$/.test(to)) {
+    return null;
+  }
+  let seen = 0;
+  let index = 0;
+  while (index < original.length && seen < prefix) {
+    if (!/\s/.test(original[index] ?? "")) seen++;
+    index++;
+  }
+  const left = original.slice(0, index).trim();
+  const rest = original.slice(index).trimStart();
+  const right = rest.slice(from.length).trim();
+  return { left, from, to, right };
+}
+function code(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+function explainSurvivor(mutation) {
+  const { mutator, original, replacement } = mutation;
+  const change = operatorChange(original, replacement);
+  if (mutator === "EqualityOperator" && change !== null) {
+    const head = `Changing ${change.from} to ${change.to} went undetected.`;
+    if (BOUNDARY[change.from] === change.to) {
+      return change.left.length <= MAX_OPERAND && change.right.length <= MAX_OPERAND ? `${head} Review the behavior at ${code(change.left)} = ${code(change.right)}.` : `${head} Review the behavior where both sides are equal.`;
+    }
+    return `${head} The tests that ran passed with the comparison inverted: review a case on each side of ${code(original)}.`;
+  }
+  if (mutator === "ConditionalExpression" && /^(true|false)$/.test(replacement)) {
+    const other = replacement === "true" ? "false" : "true";
+    return `Replacing the condition ${code(original)} with ${replacement} went undetected. The tests that ran passed as if it were always ${replacement}: review a case where it is ${other}.`;
+  }
+  if (mutator === "LogicalOperator" && change !== null) {
+    return `Changing ${change.from} to ${change.to} went undetected. Review a case where only one side of ${code(original)} holds.`;
+  }
+  if (mutator === "BooleanLiteral") {
+    if (/^!/.test(original.trim()) && !/^!/.test(replacement.trim())) {
+      return `Removing the ! from ${code(original)} went undetected.`;
+    }
+    return `Changing ${code(original)} to ${code(replacement)} went undetected.`;
+  }
+  if (mutator === "ArithmeticOperator" && change !== null) {
+    return `Changing ${change.from} to ${change.to} went undetected. The tests that ran did not tell ${code(original)} from ${code(replacement)}.`;
+  }
+  return `Replacing ${code(original)} with ${code(replacement)} went undetected.`;
+}
+
+// src/core/check/result.ts
+var STATUS_OUTCOME = {
+  Killed: "detected",
+  Survived: "undetected",
+  NoCoverage: "no-coverage",
+  Timeout: "timeout",
+  RuntimeError: "runtime-error",
+  CompileError: "compile-error",
+  Ignored: "ignored",
+  Pending: "not-run"
+};
+function sliceSource(content, start, end) {
+  const lines2 = content.split("\n");
+  const offset = (position) => {
+    let total = 0;
+    for (let line = 1; line < position.line; line++) {
+      total += (lines2[line - 1]?.length ?? 0) + 1;
+    }
+    return total + position.column - 1;
+  };
+  return content.slice(offset(start), offset(end));
+}
+function outcomeOf(mutant, input) {
+  const counted = input.selection === void 0 || input.selection.selected.has(mutant.id) || input.selection.free.has(mutant.id);
+  const tested = input.tested.get(mutant.id);
+  if (!counted || tested === void 0) {
+    return {
+      outcome: "not-run",
+      reason: !counted ? "past --max-mutants" : input.stopReason === "budget" ? "the --budget ran out" : input.stopReason === "interrupted" ? "interrupted" : "not reported"
+    };
+  }
+  const outcome = STATUS_OUTCOME[tested.status];
+  return {
+    outcome,
+    ...outcome !== "detected" && outcome !== "undetected" && tested.statusReason !== void 0 && {
+      reason: tested.statusReason.split("\n")[0] ?? ""
+    },
+    ...tested.killedBy[0] !== void 0 && { killedBy: tested.killedBy[0] },
+    ...tested.testsCompleted !== void 0 && {
+      testsRun: tested.testsCompleted
+    }
+  };
+}
+function assembleCheckResult(input) {
+  const mutants = (input.plan ?? []).map((mutant) => {
+    const original = sliceSource(
+      input.snapshot.get(mutant.file) ?? "",
+      mutant.start,
+      mutant.end
+    );
+    const result = outcomeOf(mutant, input);
+    const symbol = input.symbols?.get(mutant.file)?.(mutant.start.line);
+    return {
+      id: mutant.id,
+      file: mutant.file,
+      start: mutant.start,
+      end: mutant.end,
+      mutator: mutant.mutator,
+      original,
+      replacement: mutant.replacement,
+      ...result,
+      ...result.outcome === "undetected" && {
+        explanation: explainSurvivor({
+          mutator: mutant.mutator,
+          original,
+          replacement: mutant.replacement
+        })
+      },
+      ...symbol !== void 0 && { symbol },
+      ...mutant.static && { static: true }
+    };
+  });
+  mutants.sort(
+    (a, b) => a.file.localeCompare(b.file) || a.start.line - b.start.line || a.start.column - b.start.column || a.id.localeCompare(b.id, void 0, { numeric: true })
+  );
+  const counts = {
+    detected: 0,
+    undetected: 0,
+    "no-coverage": 0,
+    timeout: 0,
+    "runtime-error": 0,
+    "compile-error": 0,
+    ignored: 0,
+    "not-run": 0,
+    attempted: 0
+  };
+  for (const mutant of mutants) {
+    counts[mutant.outcome]++;
+    if (mutant.outcome !== "not-run" && mutant.outcome !== "ignored") {
+      counts.attempted++;
+    }
+  }
+  const files = input.targets.map((target) => {
+    const lookup = input.symbols?.get(target.file);
+    const symbols = /* @__PURE__ */ new Set();
+    if (lookup !== void 0) {
+      for (const range of target.ranges) {
+        for (let line = range.start; line <= range.end; line++) {
+          const symbol = lookup(line);
+          if (symbol !== void 0) symbols.add(symbol);
+        }
+      }
+    }
+    return {
+      file: target.file,
+      ranges: target.ranges,
+      untracked: target.untracked,
+      changedLines: countLines(target.ranges),
+      mutants: mutants.filter((mutant) => mutant.file === target.file).length,
+      symbols: [...symbols]
+    };
+  });
+  const baselineFinished = input.baselineTests !== void 0;
+  const status = input.targets.length === 0 ? "nothing-to-mutate" : input.plan === void 0 || input.stopReason !== void 0 || counts["not-run"] > 0 ? "incomplete" : "complete";
+  return {
+    base: input.base,
+    status,
+    ...input.stopReason !== void 0 && { stopReason: input.stopReason },
+    baselineFinished,
+    files,
+    excluded: [...input.excluded],
+    deletedLines: input.deletedLines,
+    ...input.baselineTests !== void 0 && {
+      baseline: {
+        tests: input.baselineTests.length,
+        files: new Set(input.baselineTests.map((test) => test.file)).size,
+        skipped: input.baselineTests.filter((test) => test.skipped).length
+      }
+    },
+    ...input.vitestConfig !== void 0 && {
+      vitestConfig: input.vitestConfig
+    },
+    coverageMeasured: input.coverageMeasured ?? true,
+    mutants,
+    counts,
+    notes: [...input.notes ?? []],
+    durationMs: input.durationMs
+  };
+}
+function allDetected(result) {
+  const { counts } = result;
+  return result.status === "complete" && counts.attempted > 0 && counts.detected === counts.attempted;
+}
+
+// src/core/check/runner.ts
+function parse(manifest) {
+  if (manifest === null) return null;
+  try {
+    return JSON.parse(manifest);
+  } catch {
+    return null;
+  }
+}
+function detectRunner(manifestText, fileNames) {
+  const manifest = parse(manifestText);
+  const declares = (name) => name in (manifest?.devDependencies ?? {}) || name in (manifest?.dependencies ?? {});
+  const scripts = Object.entries(manifest?.scripts ?? {});
+  const scriptRunning = (tool) => scripts.find(
+    ([, command]) => typeof command === "string" && tool.test(command)
+  )?.[0];
+  if (declares("vitest") || scriptRunning(/\bvitest\b/) !== void 0 || fileNames.some((name) => /^vitest\.(config|workspace)\./.test(name))) {
+    return { kind: "vitest" };
+  }
+  const jestConfig = fileNames.find((name) => /^jest\.config\./.test(name));
+  if (jestConfig !== void 0) return { kind: "jest", evidence: jestConfig };
+  const jestScript = scriptRunning(/\bjest\b/);
+  if (jestScript !== void 0) {
+    return { kind: "jest", evidence: `the \`${jestScript}\` script` };
+  }
+  if (manifest?.jest !== void 0) {
+    return { kind: "jest", evidence: "the `jest` key in package.json" };
+  }
+  if (declares("jest"))
+    return { kind: "jest", evidence: "a `jest` dependency" };
+  return { kind: "none" };
+}
+
+// src/core/check/selection.ts
+function selectMutants(plan, maxMutants) {
+  const selected = /* @__PURE__ */ new Set();
+  const free = /* @__PURE__ */ new Set();
+  const overLimit = [];
+  for (const mutant of plan) {
+    if (!mutant.covered && !mutant.static) {
+      free.add(mutant.id);
+    } else if (selected.size < maxMutants) {
+      selected.add(mutant.id);
+    } else {
+      overLimit.push(mutant.id);
+    }
+  }
+  return { selected, free, overLimit };
+}
+
+// src/core/check/symbols.ts
+function createSymbolReader() {
+  let project;
+  return async (file, content) => {
+    const tsm = await import("ts-morph");
+    project ??= new tsm.Project({ useInMemoryFileSystem: true });
+    const source = project.createSourceFile(`/${file}`, content, {
+      overwrite: true
+    });
+    const spans = [];
+    const add = (name, node) => {
+      if (name === void 0 || name === "") return;
+      spans.push({
+        name,
+        start: node.getStartLineNumber(),
+        end: node.getEndLineNumber()
+      });
+    };
+    source.forEachDescendant((node) => {
+      if (tsm.Node.isFunctionDeclaration(node) || tsm.Node.isClassDeclaration(node)) {
+        add(node.getName(), node);
+      } else if (tsm.Node.isMethodDeclaration(node) || tsm.Node.isGetAccessorDeclaration(node) || tsm.Node.isSetAccessorDeclaration(node)) {
+        const owner = node.getParent();
+        const ownerName = tsm.Node.isClassDeclaration(owner) ? owner.getName() : void 0;
+        add(
+          ownerName === void 0 ? node.getName() : `${ownerName}.${node.getName()}`,
+          node
+        );
+      } else if (tsm.Node.isConstructorDeclaration(node)) {
+        const owner = node.getParent();
+        add(
+          tsm.Node.isClassDeclaration(owner) ? `${owner.getName() ?? "class"}.constructor` : void 0,
+          node
+        );
+      } else if (tsm.Node.isVariableDeclaration(node)) {
+        const initializer = node.getInitializer();
+        if (tsm.Node.isArrowFunction(initializer) || tsm.Node.isFunctionExpression(initializer)) {
+          add(node.getName(), node);
+        }
+      }
+    });
+    project.removeSourceFile(source);
+    return (line) => {
+      let best;
+      for (const span of spans) {
+        if (line < span.start || line > span.end) continue;
+        if (best === void 0 || span.end - span.start < best.end - best.start) {
+          best = span;
+        }
+      }
+      return best?.name;
+    };
+  };
+}
+
+// src/core/check/targets.ts
+var TYPESCRIPT = /\.(?:ts|tsx|mts|cts)$/;
+var DECLARATION = /\.d\.(?:ts|mts|cts)$/;
+var INSTALLED = /(^|\/)node_modules\//;
+function exclusionBeforeDiff(file, isTestFile) {
+  if (file.startsWith("../")) return "outside";
+  if (!TYPESCRIPT.test(file)) return "not-typescript";
+  if (DECLARATION.test(file)) return "declaration";
+  if (isTestFile(file)) return "test";
+  return null;
+}
+function isNewSource(file) {
+  return TYPESCRIPT.test(file) && !DECLARATION.test(file) && !INSTALLED.test(file);
+}
+function selectTargets(input) {
+  const targets = [];
+  const excluded = [];
+  let deletedLines = 0;
+  const consider = (file, untracked) => {
+    const reason = exclusionBeforeDiff(file, input.isTestFile);
+    if (reason !== null) {
+      excluded.push({ file, reason });
+      return;
+    }
+    const hunks = input.hunks.get(file);
+    if (hunks === void 0 || hunks.added.length === 0) {
+      excluded.push({ file, reason: "deleted-lines-only" });
+      return;
+    }
+    if (input.formattingOnly.has(file)) {
+      excluded.push({ file, reason: "formatting-only" });
+      return;
+    }
+    deletedLines += hunks.deletedLines;
+    targets.push({ file, ranges: hunks.added, untracked });
+  };
+  for (const file of [...input.changed].sort()) consider(file, false);
+  for (const file of [...input.untracked].sort()) {
+    if (isNewSource(file)) consider(file, true);
+  }
+  return { targets, excluded, deletedLines };
+}
+function mutateEntries(targets) {
+  return targets.flatMap(
+    (target) => target.ranges.map((range) => `${target.file}:${range.start}-${range.end}`)
+  );
+}
+
+// src/core/check/run.ts
+var DEFAULT_MAX_MUTANTS = 50;
+var DEFAULT_BUDGET_MS = 5 * 6e4;
+async function readText(file) {
+  try {
+    return await readFile2(file, "utf8");
+  } catch {
+    return null;
+  }
+}
+function declaresWorkspaces(pnpmWorkspace, manifest) {
+  if (pnpmWorkspace !== null && /^packages\s*:/m.test(pnpmWorkspace)) {
+    return true;
+  }
+  if (manifest === null) return false;
+  try {
+    const parsed = JSON.parse(manifest);
+    return parsed.workspaces !== void 0;
+  } catch {
+    return false;
+  }
+}
+async function isWorkspaceRoot(cwd) {
+  const [pnpmWorkspace, manifest] = await Promise.all([
+    readText(path2.join(cwd, "pnpm-workspace.yaml")),
+    readText(path2.join(cwd, "package.json"))
+  ]);
+  return declaresWorkspaces(pnpmWorkspace, manifest);
+}
+function formattingOnly(classify, sameProgram) {
+  return async (filePath, before, after) => (await classify({ filePath, before, after })).classification === "non-impacting" || await sameProgram(filePath, before, after);
+}
+function checkDeps(cwd, backend) {
+  return {
+    backend,
+    now: () => Date.now(),
+    resolveBase: (explicit) => resolveCheckBase(explicit, {
+      ...changeBaseDeps(cwd),
+      hasLocalChanges: () => hasLocalChanges(cwd)
+    }),
+    assertBase: (ref) => assertBaseRef(cwd, ref),
+    listChangedFiles: (ref) => listChangedFiles(cwd, ref),
+    listUntrackedFiles: () => listUntrackedFiles(cwd),
+    readDiff: (ref, file) => readZeroContextDiff(cwd, ref, file),
+    readFile: (file) => readText(path2.join(cwd, file)),
+    readFileAtBase: (ref, file) => readFileAtRef(cwd, ref, file),
+    isFormattingOnly: formattingOnly(
+      createClassifier(),
+      createProgramComparer()
+    ),
+    isWorkspaceRoot: () => isWorkspaceRoot(cwd),
+    detectRunner: async () => detectRunner(
+      await readText(path2.join(cwd, "package.json")),
+      await readdir2(cwd).catch(() => [])
+    ),
+    symbols: createSymbolReader()
+  };
+}
+function digest(text) {
+  return createHash("sha256").update(text ?? "\0missing").digest("hex");
+}
+function nextOrStop(iterator, msLeft, signal) {
+  if (signal?.aborted === true) return Promise.resolve("interrupted");
+  if (msLeft <= 0) return Promise.resolve("budget");
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => finish("budget"), msLeft);
+    const onAbort = () => finish("interrupted");
+    signal?.addEventListener("abort", onAbort, { once: true });
+    function finish(value) {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", onAbort);
+      resolve(value);
+    }
+    iterator.next().then(finish, (error) => {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", onAbort);
+      reject(error);
+    });
+  });
+}
+async function runCheck(cwd, options, deps) {
+  const startedAt = deps.now();
+  const base = await deps.resolveBase(options.base);
+  await deps.assertBase(base.ref);
+  if (await deps.isWorkspaceRoot()) throw new CheckWorkspaceRootError();
+  if (options.vitestConfig === void 0) {
+    const runner = await deps.detectRunner();
+    if (runner.kind !== "vitest") throw new CheckRunnerError(runner);
+  }
+  const [changed, untracked] = await Promise.all([
+    deps.listChangedFiles(base.ref),
+    deps.listUntrackedFiles()
+  ]);
+  if (changed === null || untracked === null) {
+    throw new GitRefError(
+      `Could not compare the working tree with ${base.ref}`
+    );
+  }
+  const mutable = (file) => exclusionBeforeDiff(file, defaultIsTestFile) === null;
+  const hunks = /* @__PURE__ */ new Map();
+  const formatting = /* @__PURE__ */ new Set();
+  const contents = /* @__PURE__ */ new Map();
+  await mapLimit(changed.filter(mutable), 8, async (file) => {
+    const diff = await deps.readDiff(base.ref, file);
+    if (diff === null) return;
+    const fileHunks = parseZeroContextDiff(diff);
+    hunks.set(file, fileHunks);
+    if (fileHunks.added.length === 0) return;
+    const [before, after] = await Promise.all([
+      deps.readFileAtBase(base.ref, file),
+      deps.readFile(file)
+    ]);
+    if (after !== null) contents.set(file, after);
+    if (before !== null && after !== null && await deps.isFormattingOnly(file, before, after).catch(() => false)) {
+      formatting.add(file);
+    }
+  });
+  const newFiles = untracked.filter(
+    (file) => isNewSource(file) && mutable(file)
+  );
+  await mapLimit(newFiles, 8, async (file) => {
+    const content = await deps.readFile(file);
+    if (content === null) return;
+    contents.set(file, content);
+    const lines2 = content.split("\n").length - (content.endsWith("\n") ? 1 : 0);
+    if (lines2 > 0) {
+      hunks.set(file, { added: [{ start: 1, end: lines2 }], deletedLines: 0 });
+    }
+  });
+  const { targets, excluded, deletedLines } = selectTargets({
+    changed,
+    untracked,
+    hunks,
+    formattingOnly: formatting,
+    isTestFile: defaultIsTestFile
+  });
+  const assembleBase = {
+    base,
+    targets,
+    excluded,
+    deletedLines,
+    ...options.vitestConfig !== void 0 && {
+      vitestConfig: options.vitestConfig
+    }
+  };
+  if (targets.length === 0) {
+    return assembleCheckResult({
+      ...assembleBase,
+      tested: /* @__PURE__ */ new Map(),
+      snapshot: /* @__PURE__ */ new Map(),
+      durationMs: deps.now() - startedAt
+    });
+  }
+  const snapshot = /* @__PURE__ */ new Map();
+  await Promise.all(
+    targets.map(async (target) => {
+      snapshot.set(
+        target.file,
+        contents.get(target.file) ?? await deps.readFile(target.file) ?? ""
+      );
+    })
+  );
+  const symbols = /* @__PURE__ */ new Map();
+  if (deps.symbols !== void 0) {
+    for (const [file, content] of snapshot) {
+      const lookup = await deps.symbols(file, content).catch(() => void 0);
+      if (lookup !== void 0) symbols.set(file, lookup);
+    }
+  }
+  const deadline = startedAt + options.budgetMs;
+  const run = deps.backend.start({
+    cwd,
+    mutate: mutateEntries(targets),
+    ...options.vitestConfig !== void 0 && {
+      vitestConfig: options.vitestConfig
+    },
+    // The engine's own limit on the baseline, kept inside the budget so
+    // that the budget is what stops a slow one, with a reason.
+    baselineTimeoutMinutes: Math.max(1, Math.ceil(options.budgetMs / 6e4))
+  });
+  let baselineTests;
+  let plan;
+  let coverageMeasured = true;
+  let selection;
+  const tested = /* @__PURE__ */ new Map();
+  let stopReason;
+  let failure;
+  const engineNotes = [];
+  const countedDone = () => selection !== void 0 && [...selection.selected, ...selection.free].every((id) => tested.has(id));
+  const iterator = run.events[Symbol.asyncIterator]();
+  try {
+    for (; ; ) {
+      const next = await nextOrStop(
+        iterator,
+        deadline - deps.now(),
+        options.signal
+      );
+      if (next === "budget" || next === "interrupted") {
+        stopReason = next;
+        break;
+      }
+      if (next.done === true) break;
+      const event = next.value;
+      if (event.kind === "baseline") baselineTests = event.tests;
+      else if (event.kind === "plan") {
+        plan = event.mutants;
+        coverageMeasured = event.coverageMeasured;
+        selection = selectMutants(plan, options.maxMutants);
+      } else if (event.kind === "tested")
+        tested.set(event.mutant.id, event.mutant);
+      else if (event.kind === "note") engineNotes.push(event.text);
+      else if (event.kind === "finished") break;
+      else {
+        failure = event;
+        break;
+      }
+      if (countedDone() && selection !== void 0) {
+        if (selection.overLimit.length > 0) stopReason = "limit";
+        break;
+      }
+    }
+  } finally {
+    await run.stop();
+  }
+  if (options.signal?.aborted === true) stopReason = "interrupted";
+  else if (failure?.kind === "baseline-failed") {
+    throw new BaselineFailedError(failure.failingTests, failure.output);
+  } else if (failure?.kind === "error") {
+    throw new CheckBackendError(failure.message, failure.output);
+  } else if (stopReason === void 0 && plan === void 0) {
+    throw new CheckBackendError(
+      "The mutation-testing engine stopped without a result",
+      ""
+    );
+  }
+  const notes = [...engineNotes];
+  await Promise.all(
+    targets.map(async (target) => {
+      const now = await deps.readFile(target.file);
+      if (digest(now) !== digest(snapshot.get(target.file) ?? null)) {
+        notes.push(
+          `${target.file} changed while variant check ran; the report quotes it as it was when the run started.`
+        );
+      }
+    })
+  );
+  return assembleCheckResult({
+    ...assembleBase,
+    ...baselineTests !== void 0 && { baselineTests },
+    ...plan !== void 0 && { plan },
+    ...selection !== void 0 && { selection },
+    tested,
+    coverageMeasured,
+    ...stopReason !== void 0 && { stopReason },
+    snapshot,
+    symbols,
+    notes: notes.sort(),
+    durationMs: deps.now() - startedAt
+  });
+}
+
+// src/cli/render/check.ts
+var EXCLUSION = {
+  test: "a test file",
+  declaration: "a declaration file",
+  "not-typescript": "not TypeScript",
+  outside: "outside this directory",
+  "deleted-lines-only": "only lines removed, which cannot be mutated",
+  "formatting-only": "only formatting or comments changed"
+};
+var MAX_EXCLUDED = 10;
+function exclusionRank(reason) {
+  if (reason === "outside") return 2;
+  if (reason === "not-typescript") return 1;
+  return 0;
+}
+var INCONCLUSIVE = {
+  timeout: "timed out",
+  "runtime-error": "the tests errored",
+  "compile-error": "did not compile"
+};
+function shortRef(ref) {
+  return /^[0-9a-f]{40}$/.test(ref) ? ref.slice(0, 12) : ref;
+}
+function seconds(ms) {
+  return `${(ms / 1e3).toFixed(1)} s`;
+}
+function where(mutant) {
+  const at = `${mutant.file}:${mutant.start.line}:${mutant.start.column}`;
+  return mutant.symbol === void 0 ? at : `${at}  in ${mutant.symbol}`;
+}
+function oneLine(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+function ranAgainstTests(result) {
+  return result.counts.attempted - result.counts["no-coverage"];
+}
+function stopped(result) {
+  const tried = ranAgainstTests(result);
+  const planned = result.mutants.filter(
+    (mutant) => mutant.outcome !== "no-coverage"
+  ).length;
+  switch (result.stopReason) {
+    case "limit":
+      return `stopped at --max-mutants after ${plural(tried, "mutation")}; ${result.counts["not-run"].toLocaleString("en-US")} more were not run`;
+    case "budget":
+      return result.baselineFinished ? `the --budget ran out after ${tried} of ${plural(planned, "mutation")}` : "the --budget ran out before the tests finished their first, unmutated run";
+    case "interrupted":
+      return `interrupted after ${tried} of ${plural(planned, "mutation")}`;
+    default:
+      return `${result.counts["not-run"].toLocaleString("en-US")} of ${plural(planned, "mutation")} were not run`;
+  }
+}
+function renderCheck(result, printer = getPrinter()) {
+  const colors = getColors();
+  const base = result.base.label === result.base.ref ? shortRef(result.base.ref) : `${shortRef(result.base.ref)} (${result.base.label.replace(/^HEAD: /, "")})`;
+  lines(printer, "", `Compared with ${base}.`);
+  if (result.files.length > 0) {
+    lines(printer, "", "Mutated:");
+    for (const file of result.files) {
+      const symbols = file.symbols.length > 0 ? `  (${file.symbols.join(", ")})` : "";
+      const lineCount = file.untracked ? `new, untracked: ${plural(file.changedLines, "line")}` : plural(file.changedLines, "changed line");
+      lines(
+        printer,
+        `  ${file.file}  ${lineCount}, ${plural(file.mutants, "mutation")}${symbols}`
+      );
+    }
+  }
+  if (result.excluded.length > 0) {
+    lines(printer, "", "Not mutated:");
+    const ordered = [...result.excluded].sort(
+      (a, b) => exclusionRank(a.reason) - exclusionRank(b.reason)
+    );
+    for (const exclusion of ordered.slice(0, MAX_EXCLUDED)) {
+      lines(printer, `  ${exclusion.file}  ${EXCLUSION[exclusion.reason]}`);
+    }
+    const more = result.excluded.length - MAX_EXCLUDED;
+    if (more > 0) {
+      lines(
+        printer,
+        `  \u2026 and ${more.toLocaleString("en-US")} more (all of them in --json)`
+      );
+    }
+  }
+  if (result.status === "nothing-to-mutate") {
+    lines(
+      printer,
+      "",
+      result.excluded.some(
+        (exclusion) => exclusion.reason === "formatting-only"
+      ) ? "Nothing to check: the TypeScript here changed only in formatting or comments." : "Nothing to check: no TypeScript source line changed here, so there is nothing to mutate."
+    );
+    renderFooter(result, printer);
+    return;
+  }
+  const undetected = result.mutants.filter((m) => m.outcome === "undetected");
+  if (undetected.length > 0) {
+    lines(
+      printer,
+      "",
+      colors.bold(colors.yellow(`Undetected: ${undetected.length}`))
+    );
+    for (const mutant of undetected) {
+      lines(
+        printer,
+        `  ${where(mutant)}`,
+        `    ${colors.red(`- ${oneLine(mutant.original)}`)}`,
+        `    ${colors.green(`+ ${oneLine(mutant.replacement)}`)}`,
+        `    ${mutant.explanation ?? ""}`,
+        ...mutant.static === true ? [
+          "    This runs when its module loads, so every test ran against it."
+        ] : []
+      );
+    }
+  }
+  const unreached = result.mutants.filter((m) => m.outcome === "no-coverage");
+  if (unreached.length > 0) {
+    lines(
+      printer,
+      "",
+      colors.bold(colors.yellow(`No test reached: ${unreached.length}`)),
+      "  No test executed this code in the test process, so none could notice a change to it.",
+      ...(result.baseline?.skipped ?? 0) > 0 ? [
+        `  ${plural(result.baseline?.skipped ?? 0, "test")} were skipped; code only they would reach reads as reached by no test.`
+      ] : []
+    );
+    for (const mutant of unreached) {
+      lines(
+        printer,
+        `  ${where(mutant)}  ${oneLine(mutant.original)} \u2192 ${oneLine(mutant.replacement)}`
+      );
+    }
+  }
+  const inconclusive = result.mutants.filter(
+    (m) => INCONCLUSIVE[m.outcome] !== void 0
+  );
+  if (inconclusive.length > 0) {
+    lines(
+      printer,
+      "",
+      `Inconclusive: ${inconclusive.length}  (neither detected nor undetected)`
+    );
+    for (const mutant of inconclusive) {
+      const reason = mutant.reason === void 0 ? "" : `: ${oneLine(mutant.reason)}`;
+      lines(
+        printer,
+        `  ${where(mutant)}  ${oneLine(mutant.original)} \u2192 ${oneLine(mutant.replacement)}  ${INCONCLUSIVE[mutant.outcome]}${reason}`
+      );
+    }
+  }
+  lines(printer, "");
+  const { counts } = result;
+  if (result.status === "incomplete") {
+    lines(
+      printer,
+      colors.bold(`Incomplete: ${stopped(result)}.`),
+      "Nothing here says how the rest of the change would fare."
+    );
+  }
+  if (counts.attempted === 0 && result.status === "complete") {
+    lines(
+      printer,
+      "The changed lines hold no comparison, condition or arithmetic to mutate."
+    );
+  } else if (allDetected(result)) {
+    lines(
+      printer,
+      colors.green(
+        counts.attempted === 1 ? "The one mutation tried was detected by the tests that ran." : `All ${plural(counts.attempted, "mutation")} were detected by the tests that ran.`
+      ),
+      "That is evidence these tests check these lines, not proof the change is correct."
+    );
+  } else if (counts.attempted > 0) {
+    const ran = ranAgainstTests(result);
+    const unreachedCount = counts["no-coverage"];
+    const outcomes = [
+      `${counts.detected.toLocaleString("en-US")} detected`,
+      `${counts.undetected.toLocaleString("en-US")} undetected`,
+      ...inconclusive.length > 0 ? [`${inconclusive.length.toLocaleString("en-US")} inconclusive`] : []
+    ].join(", ");
+    const one = unreachedCount === 1;
+    const unreachedPart = `not run because no test executes ${one ? "its" : "their"} code (${one ? "it does" : "they do"} not count toward --max-mutants)`;
+    if (unreachedCount === 0) {
+      lines(
+        printer,
+        `${plural(ran, "mutation")} run against the tests: ${outcomes}.`
+      );
+    } else if (ran === 0) {
+      lines(
+        printer,
+        `${plural(unreachedCount, "mutation")}, none run: no test executes ${one ? "its" : "their"} code (${one ? "it does" : "they do"} not count toward --max-mutants).`
+      );
+    } else {
+      lines(
+        printer,
+        `${plural(counts.attempted, "mutation")}: ${ran.toLocaleString("en-US")} run against the tests (${outcomes}), ${unreachedCount.toLocaleString("en-US")} ${unreachedPart}.`
+      );
+    }
+  }
+  renderFooter(result, printer);
+}
+function renderFooter(result, printer) {
+  const scope = [];
+  if (result.baseline !== void 0) {
+    const config = result.vitestConfig === void 0 ? "the Vitest config here" : result.vitestConfig;
+    scope.push(
+      `the tests passed unmutated first (${plural(result.baseline.tests, "test")} in ${plural(result.baseline.files, "file")}${result.baseline.skipped > 0 ? `, ${plural(result.baseline.skipped, "test")} skipped` : ""}, from ${config}); ${result.coverageMeasured ? "each mutation then ran against the tests that executed its code" : "which test executes what could not be measured, so each mutation ran against every test and none could be found unreached"}`
+    );
+  }
+  if (result.status !== "nothing-to-mutate") {
+    scope.push(
+      "only comparisons, boolean conditions and arithmetic were mutated, and mutations are not type-checked"
+    );
+  }
+  if (result.deletedLines > 0) {
+    scope.push(
+      `${plural(result.deletedLines, "deleted line")} could not be mutated`
+    );
+  }
+  if (scope.length > 0) lines(printer, "", `Scope: ${scope.join("; ")}.`);
+  for (const note of result.notes) lines(printer, `Note: ${note}`);
+  lines(printer, `Time: ${seconds(result.durationMs)}`);
+}
+function renderCheckJson(result, printer = getPrinter()) {
+  lines(
+    printer,
+    JSON.stringify({ ...result, allDetected: allDetected(result) }, null, 2)
+  );
+}
+
+// src/cli/commands/check.ts
+function parseMaxMutants(value) {
+  if (value === void 0) return DEFAULT_MAX_MUTANTS;
+  if (!/^\d+$/.test(value) || Number(value) < 1) {
+    throw new CliUsageError(
+      `--max-mutants takes a whole number of at least 1, not "${value}"`
+    );
+  }
+  return Number(value);
+}
+function parseBudget(value) {
+  if (value === void 0) return DEFAULT_BUDGET_MS;
+  const match = /^(\d+)(s|m)?$/.exec(value.trim());
+  if (match === null || Number(match[1]) < 1) {
+    throw new CliUsageError(
+      `--budget takes seconds (300, 90s) or minutes (5m), not "${value}"`
+    );
+  }
+  return Number(match[1]) * (match[2] === "m" ? 6e4 : 1e3);
+}
+function hasFindings(result) {
+  return result.status === "incomplete" || result.counts.undetected > 0 || result.counts["no-coverage"] > 0;
+}
+async function registerCheckAction(opts = {}, backend = createStrykerBackend()) {
+  const maxMutants = parseMaxMutants(opts.maxMutants);
+  const budgetMs = parseBudget(opts.budget);
+  const controller = new AbortController();
+  const onInterrupt = () => {
+    if (controller.signal.aborted) process.exit(130);
+    errorLines(getPrinter(), "variant check: stopping\u2026");
+    controller.abort();
+  };
+  process.on("SIGINT", onInterrupt);
+  let result;
+  try {
+    result = await runCheck(
+      process.cwd(),
+      {
+        maxMutants,
+        budgetMs,
+        signal: controller.signal,
+        ...opts.base !== void 0 && { base: opts.base },
+        ...opts.vitestConfig !== void 0 && {
+          vitestConfig: opts.vitestConfig
+        }
+      },
+      checkDeps(process.cwd(), backend)
+    );
+  } finally {
+    process.off("SIGINT", onInterrupt);
+  }
+  if (opts.json === true) renderCheckJson(result);
+  else renderCheck(result);
+  if (opts.failOnSurvivors === true && hasFindings(result)) {
+    process.exitCode = 1;
+  }
+}
+export {
+  hasFindings,
+  parseBudget,
+  parseMaxMutants,
+  registerCheckAction
+};