paperlint 3.0.0 → 3.1.1

package/scripts/check.mutations.mjs

@@ -1,110 +0,0 @@
-/**
- * Battery for `npm run check` — and the thing under test is NOT "does it run every gate".
- * That part is visible: you watch it happen. What is invisible, and therefore what this kills,
- * is whether the harness beside it can still tell when the gate list has fallen behind CI.
- *
- * 🔴 The failure mode this whole file exists against, measured 2026-09-19: a list of gates kept
- * by hand becomes a fossil the day after it is written. `check.harness.mjs` is the mechanism that
- * stops that — it reads job names out of the workflow rather than trusting a copy — and its
- * success state is silence. "It passed" and "it cannot fail" look identical from outside.
- *
- * Each case removes ONE property and names the assertion that must notice.
- */
-import { fileURLToPath } from "node:url";
-import { dirname, join, resolve } from "node:path";
-import { runMutations } from "../lib/mutation-driver.mjs";
-
-const HERE = dirname(fileURLToPath(import.meta.url));
-const ROOT = resolve(HERE, "..");
-const CHECK = join(HERE, "check.mjs");
-const HARNESS = join(HERE, "check.harness.mjs");
-
-process.exit(
-  runMutations({
-    root: ROOT,
-    runner: "node",
-    cases: [
-      {
-        name: "a CI job stops being accounted for — the tail goes quiet about its own boundary",
-        harness: HARNESS,
-        // No job name here: the harness reads every workflow in directory order, so which job
-        // fails first depends on file names, not on what this mutation proves.
-        expect:
-          "is either reproduced by a gate or named in NOT_COVERED with a reason",
-        disables:
-          "the reason this command is not just a shell alias. Emptying NOT_COVERED removes the " +
-          "one sentence that tells a reader what the green does NOT mean — and a check silent " +
-          "about its boundary reads as complete, which is the counter-that-counts-what-it-ignores " +
-          "class this repository keeps re-finding",
-        edits: [
-          [
-            CHECK,
-            "export const NOT_COVERED = {",
-            "export const NOT_COVERED = { }; const _unused = {",
-          ],
-        ],
-      },
-      {
-        name: "a gate names a CI job that does not exist — coverage on paper, none in fact",
-        harness: HARNESS,
-        expect: "names a job that really exists in a workflow",
-        disables:
-          "the link between the list and the workflow. A dead job name is WORSE than a missing " +
-          "one: it reads as coverage and delivers nothing, and nothing else in the repository " +
-          "would ever contradict it",
-        // 🔴 The anchor is a gate whose job is ALSO claimed by other gates (`gates`), and that
-        // is not incidental. Renaming a solely-claimed job — `build-e2e` — kills the FIRST
-        // assertion instead, because that job becomes uncovered before anyone asks whether the
-        // new name exists. Measured: the driver reported "RED but a DIFFERENT case". Two
-        // assertions overlapping is fine; a battery that cannot tell them apart is not.
-        edits: [
-          [
-            CHECK,
-            'job: "gates",\n    run: locked("vigiles", "lint"',
-            'job: "gates-renamed-in-ci",\n    run: locked("vigiles", "lint"',
-          ],
-        ],
-      },
-      {
-        name: "a gate points at an npm script nobody can run",
-        harness: HARNESS,
-        expect: "maps to a script that exists",
-        disables:
-          "the guarantee that every listed gate is runnable. A renamed script fails at the exact " +
-          "moment someone is trusting the list — which is the worst possible moment to find out",
-        edits: [[CHECK, 'script: "fmt:check"', 'script: "fmt:check-renamed"']],
-      },
-      {
-        name: "a gate runs a file that is not on disk",
-        harness: HARNESS,
-        expect: "runs files that exist",
-        disables:
-          "the same guarantee for gates that name their command directly instead of an npm " +
-          "script. A moved or renamed file would only show up when someone runs the whole list",
-        edits: [
-          [
-            CHECK,
-            '"scripts/rules-are-content-only.mjs"',
-            '"scripts/rules-are-content-only-renamed.mjs"',
-          ],
-        ],
-      },
-      {
-        name: "a gate drops out of CI silently, with no reason given",
-        harness: HARNESS,
-        expect: "carries a reason",
-        disables:
-          "the cost of removing something from CI. Without this, `job: null` is the quiet way to " +
-          "take a check out of the pipeline: the local run still shows it green and nothing says " +
-          "it stopped being enforced anywhere else",
-        edits: [
-          [
-            CHECK,
-            'reason:\n      "source-only property',
-            'reasonRemoved:\n      "source-only property',
-          ],
-        ],
-      },
-    ],
-  }),
-);

package/scripts/exclusive.mjs

@@ -1,138 +0,0 @@
-#!/usr/bin/env node
-/**
- * MUTUAL EXCLUSION FOR RUNS THAT TOUCH THE SAME FILES.
- *
- * ── WHY ──────────────────────────────────────────────────────────────────────────────────────
- * The mutation batteries (`scripts/run-mutations.mjs`) edit the sources IN PLACE — a deliberate strategy, explained in the header of
- * `lib/mutation-driver.mjs`: nine cases rewrite the real file, and copying the whole repository
- * per mutation would mean minutes instead of seconds.
- *
- * The strategy has one cost: while the battery runs, ANY parallel `npm test` reads a file in its
- * mutilated state and fails — with a message about an assertion, not about a mutation. The
- * failure is FALSE, NON-DETERMINISTIC (it depends on which second you caught) and reads as "the
- * tests are flaky", i.e. it leads in exactly the direction where there is nothing to fix. This
- * has already cost an investigation: two runs in a row gave DIFFERENT error messages, and the
- * conclusion "I broke round-diff" was wrong.
- *
- * ── WHY A LOCK AND NOT AN INSTRUCTION "DON'T RUN THEM AT THE SAME TIME" ───────────────────────
- * The instruction already existed — as prose, in the consumer's CLAUDE.md. Prose does not
- * execute, so it is not checked and does not apply to anyone who has not read it: the person in
- * the other terminal, the agent, the editor with tests on save. A lock refuses LOUDLY and names
- * the reason at the moment it matters.
- *
- * ── HOW ─────────────────────────────────────────────────────────────────────────────────────
- * `mkdirSync` is atomic: either we created the directory or it already existed — there is no
- * race, unlike "check existsSync, then write". Inside it lie the holder's pid and command; if the
- * process with that pid is dead, the lock is taken over with an explicit message, otherwise an
- * interrupted run would block the repository forever, and the first cure would be "delete the
- * lock by hand", i.e. switching the mechanism off.
- *
- * The lock is released in `finally` AND on signals — for exactly the same reason the mutation
- * driver restores the sources on SIGINT/SIGTERM.
- */
-import {
-  mkdirSync,
-  writeFileSync,
-  readFileSync,
-  rmSync,
-  existsSync,
-} from "node:fs";
-import { spawnSync } from "node:child_process";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-
-const ROOT = dirname(dirname(fileURLToPath(import.meta.url)));
-const LOCK = join(ROOT, ".vigiles", "exclusive.lock");
-const INFO = join(LOCK, "holder.json");
-
-const argv = process.argv.slice(2);
-if (argv.length === 0) {
-  console.error("usage: node scripts/exclusive.mjs <command> [args…]");
-  process.exit(2);
-}
-
-// The PARENT is created recursively; only the lock itself must be a non-recursive mkdir, because
-// that is the atomic step. Nothing else guarantees `.vigiles/` exists: once
-// `.vigiles/coverage.json` stopped being tracked, a fresh checkout has no such directory, and the
-// lock's mkdir failed with ENOENT before any gate ran (CI on e389916).
-mkdirSync(dirname(LOCK), { recursive: true });
-
-/** Is the process alive. `kill(pid, 0)` sends nothing — it only checks existence and rights. */
-function alive(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (e) {
-    return e.code === "EPERM"; // exists but belongs to someone else — counted as alive
-  }
-}
-
-function readHolder() {
-  try {
-    return JSON.parse(readFileSync(INFO, "utf8"));
-  } catch {
-    return null; // the lock exists, its description is unreadable — resolved below as "dead"
-  }
-}
-
-function acquire() {
-  try {
-    mkdirSync(LOCK, { recursive: false });
-  } catch (e) {
-    if (e.code !== "EEXIST") throw e;
-    const holder = readHolder();
-    if (holder && alive(holder.pid)) {
-      console.error(
-        `🔴 refused: this repository is busy with a run that EDITS FILES IN PLACE.\n` +
-          `   held by: pid ${holder.pid}, "${holder.cmd}", since ${holder.at}\n` +
-          `   A parallel run would produce FALSE failures — a test would read the source in its\n` +
-          `   mutilated state and complain about an assertion, not a mutation. Wait for it to finish.`,
-      );
-      process.exit(3);
-    }
-    console.error(
-      `⚠️  the lock was left behind by a run that no longer exists` +
-        (holder
-          ? ` (pid ${holder.pid}, "${holder.cmd}")`
-          : " (description unreadable)") +
-        ` — taking it over.`,
-    );
-    rmSync(LOCK, { recursive: true, force: true });
-    mkdirSync(LOCK, { recursive: false });
-  }
-  writeFileSync(
-    INFO,
-    JSON.stringify(
-      { pid: process.pid, cmd: argv.join(" "), at: new Date().toISOString() },
-      null,
-      2,
-    ),
-  );
-}
-
-const release = () => {
-  if (existsSync(LOCK)) rmSync(LOCK, { recursive: true, force: true });
-};
-
-acquire();
-for (const sig of ["SIGINT", "SIGTERM", "SIGHUP"]) {
-  process.on(sig, () => {
-    release();
-    process.exit(sig === "SIGINT" ? 130 : 143);
-  });
-}
-
-// 🔴 `process.on("exit")`, NOT `finally`, AND THIS IS NOT STYLE. The first edition released the
-// lock in `finally` — and it STAYED ON DISK: `process.exit()` terminates the process immediately,
-// the stack is not unwound, `finally` does not run. Caught by a run (the lock outlived a
-// successful launch), not by reading. The cost of the defect would have been exactly the inverse
-// of the intent: every run would leave the repository "busy", and the first cure would be "delete
-// the lock by hand", i.e. switching the mechanism off.
-process.on("exit", release);
-
-const r = spawnSync(argv[0], argv.slice(1), { stdio: "inherit", shell: false });
-if (r.error) {
-  console.error(`🔴 failed to launch "${argv.join(" ")}": ${r.error.message}`);
-  process.exit(127);
-}
-process.exit(r.status ?? 1);

package/scripts/mutation-batteries-frozen.harness.mjs

@@ -1,204 +0,0 @@
-/**
- * Colocated test for `scripts/mutation-batteries-frozen.mjs` — the shrink-only guard (#52).
- * Run: `npx vigiles test scripts/mutation-batteries-frozen.harness.mjs`
- *
- * Both halves:
- *   I.  QUIET on this repository — every battery on disk is listed, every listed one exists,
- *       and every count matches. Plus a non-vacuity row: the walk found batteries at all.
- *   II. RED on a planted tree — a new battery, a grown one, a shrunk one, a stale list entry
- *       and an uncountable table are each named; an unchanged battery beside them is not.
- *   III. The case counter on each table shape the repository actually uses.
- *
- * ⚠️ Assertions at the TOP LEVEL: `vigiles test` imports the file and counts "did not throw"
- * as a pass.
- */
-import assert from "node:assert/strict";
-import {
-  mkdirSync,
-  mkdtempSync,
-  realpathSync,
-  rmSync,
-  symlinkSync,
-  writeFileSync,
-} from "node:fs";
-import { tmpdir } from "node:os";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-
-const HERE = dirname(fileURLToPath(import.meta.url));
-const ROOT = dirname(HERE);
-const { checkFrozen, countCases, findBatteries, FROZEN_FILE } = await import(
-  join(HERE, "mutation-batteries-frozen.mjs")
-);
-
-let n = 0;
-const check = (label, cond, detail = "") => {
-  n++;
-  assert.ok(cond, detail ? `${label}\n${detail}` : label);
-};
-
-// ── I. quiet on this repository ─────────────────────────────────────────────────────────
-{
-  const { problems, found, frozen } = checkFrozen(ROOT);
-  check(
-    "the walk finds batteries in this repository — otherwise the quiet below proves nothing",
-    found.length > 0,
-  );
-  check(
-    "this repository passes: nothing new, nothing grown, nothing stale",
-    problems.length === 0,
-    problems.join("\n"),
-  );
-  check(
-    "the frozen list names exactly the batteries on disk",
-    JSON.stringify(Object.keys(frozen).sort()) === JSON.stringify(found),
-  );
-}
-
-// ── II. red on a planted tree ───────────────────────────────────────────────────────────
-const driverBattery = (k) =>
-  `import { runMutations } from "./lib/mutation-driver.mjs";\n` +
-  `process.exit(runMutations({ root: ".", cases: [${Array.from({ length: k }, (_, i) => `{ name: "c${String(i)}" }`).join(", ")}] }));\n`;
-
-const TMP = realpathSync(mkdtempSync(join(tmpdir(), "paperlint-frozen-h-")));
-process.on("exit", () => rmSync(TMP, { recursive: true, force: true }));
-mkdirSync(join(TMP, "scripts"), { recursive: true });
-mkdirSync(join(TMP, "src"), { recursive: true });
-mkdirSync(join(TMP, "node_modules", "dep"), { recursive: true });
-writeFileSync(join(TMP, "src", "same.mutations.mjs"), driverBattery(3));
-writeFileSync(join(TMP, "src", "grown.mutations.mjs"), driverBattery(4));
-writeFileSync(join(TMP, "src", "shrunk.mutations.mjs"), driverBattery(1));
-writeFileSync(join(TMP, "src", "planted.mutations.mjs"), driverBattery(1));
-writeFileSync(
-  join(TMP, "src", "opaque.mutations.mjs"),
-  `const ALL = [{}, {}];\nrunMutations({ cases: ALL.filter(Boolean) });\n`,
-);
-// Not the repository's own files: a dependency, and a symlinked view of `src/`.
-writeFileSync(
-  join(TMP, "node_modules", "dep", "theirs.mutations.mjs"),
-  driverBattery(9),
-);
-symlinkSync(join(TMP, "src"), join(TMP, "view"), "dir");
-writeFileSync(
-  join(TMP, FROZEN_FILE),
-  JSON.stringify({
-    batteries: {
-      "src/same.mutations.mjs": { cases: 3 },
-      "src/grown.mutations.mjs": { cases: 2 },
-      "src/shrunk.mutations.mjs": { cases: 2 },
-      "src/opaque.mutations.mjs": { cases: 2 },
-      "src/gone.mutations.mjs": { cases: 5 },
-    },
-  }),
-);
-{
-  const { problems, found } = checkFrozen(TMP);
-  const about = (file) => problems.filter((p) => p.startsWith(`${file}:`));
-  const all = problems.join("\n");
-  check(
-    "the walk skips node_modules and does not follow symlinks — each battery once",
-    JSON.stringify(found) ===
-      JSON.stringify([
-        "src/grown.mutations.mjs",
-        "src/opaque.mutations.mjs",
-        "src/planted.mutations.mjs",
-        "src/same.mutations.mjs",
-        "src/shrunk.mutations.mjs",
-      ]),
-    JSON.stringify(found),
-  );
-  check(
-    "🔴 a NEW battery fails, pointing at #52",
-    about("src/planted.mutations.mjs").some((p) =>
-      p.includes(
-        "new hand-written mutation batteries are not accepted, see #52",
-      ),
-    ),
-    all,
-  );
-  check(
-    "🔴 a battery that GREW fails, naming both counts",
-    about("src/grown.mutations.mjs").some(
-      (p) => p.includes("4 cases, frozen at 2") && p.includes("#52"),
-    ),
-    all,
-  );
-  check(
-    "🔴 a listed file that no longer exists fails: remove it from the frozen list",
-    about("src/gone.mutations.mjs").some(
-      (p) =>
-        p.includes("remove it from") &&
-        p.includes("the list must shrink with the code"),
-    ),
-    all,
-  );
-  check(
-    "a battery that SHRANK fails until its recorded count is lowered to the new one",
-    about("src/shrunk.mutations.mjs").some((p) =>
-      p.includes('lower "cases" to 1'),
-    ),
-    all,
-  );
-  check(
-    "a table the counter cannot read is a failure, never a guessed number",
-    about("src/opaque.mutations.mjs").some((p) =>
-      p.includes("cannot be counted"),
-    ),
-    all,
-  );
-  check(
-    "control: an unchanged battery beside them is not reported",
-    about("src/same.mutations.mjs").length === 0,
-    all,
-  );
-  check(
-    "exactly the five planted defects, nothing else",
-    problems.length === 5,
-    all,
-  );
-}
-
-// ── III. the counter, on each table shape in use ────────────────────────────────────────
-const cases = (src) => countCases(src, "x.mutations.mjs");
-check("inline `cases: [...]` literal", cases(driverBattery(3)).count === 3);
-check(
-  "`cases: TABLE.map(...)` counts TABLE",
-  cases(
-    `const T = [[1], [2], [3], [4]];\nrunMutations({ cases: T.map(([a]) => ({ a })) });`,
-  ).count === 4,
-);
-check(
-  "`const CASES = A.map(...)` then `cases: CASES`, and the shorthand `{ cases }`",
-  cases(
-    `const A = [1, 2];\nconst CASES = A.map((x) => x);\nrunMutations({ cases: CASES });`,
-  ).count === 2 &&
-    cases(`const cases = [1, 2, 3];\nrunMutations({ root, cases });`).count ===
-      3,
-);
-check(
-  "a spread of another const table adds its length",
-  cases(`const A = [1, 2];\nrunMutations({ cases: [...A, 3] });`).count === 3,
-);
-check(
-  "a self-contained battery: the loop over M counts, the results loop over `rows = []` does not",
-  cases(
-    `const M = [["a"], ["b"], ["c"]];\nconst rows = [];\nfor (const [x] of M) rows.push(x);\nfor (const r of rows) console.log(r);`,
-  ).count === 3,
-);
-check(
-  "a file with no table is an error, not zero",
-  "error" in cases(`console.log("hi");`),
-);
-check(
-  "two driver calls are ambiguous, not summed",
-  "error" in
-    cases(`runMutations({ cases: [1] });\nrunMutations({ cases: [2] });`),
-);
-check(
-  "findBatteries on this repository matches only `*.mutations.mjs` names",
-  findBatteries(ROOT).every((f) => f.endsWith(".mutations.mjs")),
-);
-
-console.log(
-  `✓ ${String(n)} assertions passed — mutation-batteries-frozen: quiet here, red on a new, grown, shrunk, stale or uncountable battery`,
-);

package/scripts/mutation-batteries-frozen.mjs

@@ -1,238 +0,0 @@
-#!/usr/bin/env node
-/**
- * mutation-batteries-frozen.mjs — the hand-written mutation batteries may only SHRINK.
- *
- * Issue #52 retires the `*.mutations.mjs` pattern: string replacements of source lines, run
- * through `lib/mutation-driver.mjs`. The idea behind it stays (a test must be seen going red
- * when the code breaks); the vehicle is being replaced by a real mutation-testing tool, or by
- * nothing — that is decided in #52, not here. Until the last battery is gone, this check holds
- * the line so the pattern cannot grow back while it is being removed:
- *
- *   1. a `*.mutations.mjs` on disk that is not in the frozen list fails — a NEW battery;
- *   2. a listed file that no longer exists fails — the list must shrink with the code;
- *   3. a listed battery whose case table grew fails — no new cases in an old battery;
- *   4. a listed battery whose case table shrank fails until the recorded count is lowered —
- *      otherwise a removed case leaves room for a different one to be added later.
- *
- * The frozen list and the counts live in `mutation-batteries.frozen.json`, next to this file.
- *
- * ── HOW CASES ARE COUNTED, AND WHY NOT BY IMPORTING ───────────────────────────────────────
- * A battery runs on import and ends with `process.exit`, so it cannot be imported to read its
- * table. The file is PARSED instead (TypeScript's parser, already a dependency) and the case
- * table is found structurally:
- *
- *   - batteries on the shared driver pass `cases` to `runMutations({ ... })`;
- *   - the older self-contained batteries loop `for (const [...] of M)` over a top-level table.
- *
- * The table expression is then resolved to an array literal: an identifier goes to its
- * top-level `const` initializer, `X.map(...)` goes to `X` (map keeps the length), and a spread
- * `...X` inside a literal adds X's count. Anything else — `.filter`, a function call, a table
- * built in a loop — is NOT guessed at: the battery is reported as uncountable, which fails the
- * check. A count that silently stood for something else would be the green zero this repo
- * keeps guarding against.
- *
- * Run: `node scripts/mutation-batteries-frozen.mjs` (also part of `npm run check`)
- */
-import { readFileSync, readdirSync, existsSync } from "node:fs";
-import { dirname, join, relative, sep } from "node:path";
-import { fileURLToPath } from "node:url";
-import ts from "typescript";
-
-const ROOT = join(dirname(fileURLToPath(import.meta.url)), "..");
-export const FROZEN_FILE = join("scripts", "mutation-batteries.frozen.json");
-
-// Build output and dependencies are not the repository's own files. Symlinks are not followed:
-// `.claude/skills/<name>` points back into `skills/`, and following it would list every skill
-// battery twice under two spellings.
-const SKIP = new Set(["node_modules", ".git", "dist", "_build"]);
-
-/** Every `*.mutations.mjs` under `root`, as sorted POSIX-style repo-relative paths. */
-export function findBatteries(root) {
-  const found = [];
-  const walk = (dir) => {
-    for (const e of readdirSync(dir, { withFileTypes: true })) {
-      if (e.isSymbolicLink() || SKIP.has(e.name)) continue;
-      const p = join(dir, e.name);
-      if (e.isDirectory()) walk(p);
-      else if (e.isFile() && e.name.endsWith(".mutations.mjs"))
-        found.push(relative(root, p).split(sep).join("/"));
-    }
-  };
-  walk(root);
-  return found.sort();
-}
-
-/**
- * The number of cases in a battery's table, read from its source without running it.
- * Returns `{ count }` or `{ error }` — never a guess.
- */
-export function countCases(source, fileName = "battery.mjs") {
-  const sf = ts.createSourceFile(
-    fileName,
-    source,
-    ts.ScriptTarget.Latest,
-    true,
-    ts.ScriptKind.JS,
-  );
-
-  // Top-level `const NAME = <init>` — the only bindings a table name is resolved through.
-  const consts = new Map();
-  for (const st of sf.statements) {
-    if (!ts.isVariableStatement(st)) continue;
-    if (!(st.declarationList.flags & ts.NodeFlags.Const)) continue;
-    for (const d of st.declarationList.declarations)
-      if (ts.isIdentifier(d.name) && d.initializer)
-        consts.set(d.name.text, d.initializer);
-  }
-
-  const tables = [];
-  const visit = (node) => {
-    if (
-      ts.isCallExpression(node) &&
-      ts.isIdentifier(node.expression) &&
-      node.expression.text === "runMutations"
-    ) {
-      const arg = node.arguments[0];
-      const prop =
-        arg && ts.isObjectLiteralExpression(arg)
-          ? arg.properties.find((p) => p.name?.getText(sf) === "cases")
-          : undefined;
-      if (prop && ts.isPropertyAssignment(prop)) tables.push(prop.initializer);
-      else if (prop && ts.isShorthandPropertyAssignment(prop))
-        tables.push(prop.name);
-      else tables.push(null);
-    }
-    ts.forEachChild(node, visit);
-  };
-  visit(sf);
-
-  const size = (expr, seen = new Set()) => {
-    if (!expr) return null;
-    while (
-      ts.isParenthesizedExpression(expr) ||
-      ts.isAsExpression?.(expr) ||
-      ts.isSatisfiesExpression?.(expr)
-    )
-      expr = expr.expression;
-    if (ts.isArrayLiteralExpression(expr)) {
-      let n = 0;
-      for (const el of expr.elements) {
-        if (ts.isSpreadElement(el)) {
-          const inner = size(el.expression, seen);
-          if (inner === null) return null;
-          n += inner;
-        } else if (ts.isOmittedExpression(el)) return null;
-        else n += 1;
-      }
-      return n;
-    }
-    if (ts.isIdentifier(expr)) {
-      if (seen.has(expr.text) || !consts.has(expr.text)) return null;
-      seen.add(expr.text);
-      return size(consts.get(expr.text), seen);
-    }
-    if (
-      ts.isCallExpression(expr) &&
-      ts.isPropertyAccessExpression(expr.expression) &&
-      expr.expression.name.text === "map"
-    )
-      return size(expr.expression.expression, seen);
-    return null;
-  };
-
-  // The self-contained batteries: a top-level `for (... of TABLE)`. They also loop over a
-  // results accumulator (`const rows = []; for (const r of rows) ...`), which is empty in the
-  // source — so a candidate counts only when its table is non-empty.
-  if (tables.length === 0)
-    for (const st of sf.statements)
-      if (ts.isForOfStatement(st) && (size(st.expression) ?? 0) > 0)
-        tables.push(st.expression);
-
-  if (tables.length !== 1)
-    return {
-      error:
-        tables.length === 0
-          ? "no case table found (neither `runMutations({ cases })` nor a top-level `for ... of` over a non-empty table)"
-          : `${String(tables.length)} candidate case tables — which one counts is ambiguous`,
-    };
-
-  const count = size(tables[0]);
-  return count === null
-    ? {
-        error: `the case table (${tables[0]?.getText(sf).slice(0, 60) ?? "?"}) is not an array literal this check can count`,
-      }
-    : { count };
-}
-
-/**
- * Compare what is on disk with the frozen list. Pure: every input is passed in.
- * `found` — paths from findBatteries; `frozen` — `{ path: { cases } }`;
- * `counted` — `{ path: { count } | { error } }` for the paths that exist.
- */
-export function judge({ found, frozen, counted }) {
-  const problems = [];
-  const listed = new Set(Object.keys(frozen));
-  for (const f of found)
-    if (!listed.has(f))
-      problems.push(
-        `${f}: new hand-written mutation batteries are not accepted, see #52. ` +
-          `Record what a test guards as a comment above its assertion instead.`,
-      );
-  const onDisk = new Set(found);
-  for (const f of listed)
-    if (!onDisk.has(f))
-      problems.push(
-        `${f}: no longer exists — remove it from ${FROZEN_FILE} (the list must shrink with the code).`,
-      );
-  for (const f of found) {
-    if (!listed.has(f)) continue;
-    const want = frozen[f].cases;
-    const got = counted[f];
-    if (!got || "error" in got) {
-      problems.push(
-        `${f}: cases cannot be counted — ${got?.error ?? "not read"}. ` +
-          `The table must stay an array literal (optionally through a const or .map) so it can only shrink.`,
-      );
-      continue;
-    }
-    if (got.count > want)
-      problems.push(
-        `${f}: ${String(got.count)} cases, frozen at ${String(want)} — ` +
-          `no new cases in existing batteries, see #52.`,
-      );
-    else if (got.count < want)
-      problems.push(
-        `${f}: ${String(got.count)} cases, frozen at ${String(want)} — ` +
-          `lower "cases" to ${String(got.count)} in ${FROZEN_FILE} (the list must shrink with the code).`,
-      );
-  }
-  return problems;
-}
-
-/** Run the whole check against `root`. Returns the problems found. */
-export function checkFrozen(root = ROOT) {
-  const data = JSON.parse(readFileSync(join(root, FROZEN_FILE), "utf8"));
-  const frozen = data.batteries ?? {};
-  const found = findBatteries(root);
-  const counted = {};
-  for (const f of found) {
-    const p = join(root, f);
-    if (existsSync(p)) counted[f] = countCases(readFileSync(p, "utf8"), f);
-  }
-  return { problems: judge({ found, frozen, counted }), found, frozen };
-}
-
-if (import.meta.url === `file://${process.argv[1]}`) {
-  const { problems, found, frozen } = checkFrozen(ROOT);
-  if (problems.length) {
-    console.error(
-      `🔴 mutation batteries are frozen and may only shrink (#52) — ${String(problems.length)} problem(s):`,
-    );
-    for (const p of problems) console.error(`   ${p}`);
-    process.exit(1);
-  }
-  const cases = Object.values(frozen).reduce((s, v) => s + v.cases, 0);
-  console.log(
-    `✓ ${String(found.length)} frozen mutation batteries, ${String(cases)} cases, none new, none grown (#52)`,
-  );
-}