RingBRP/tools/check-packs.mjs

/**
 * EXPOSURE's tables, held against the harness that produced them.
 *
 *   node tools/check-packs.mjs           hold the claim
 *   node tools/check-packs.mjs --list    print what it found
 *   node tools/pack-tables.mjs --update  re-record after a deliberate change
 *
 * check-cited holds the PROSE against the baseline. This holds the BASELINE against the
 * game, and without it the pair is a loop: re-record, and the prose can be corrected to
 * match a figure nobody has checked came from anywhere.
 *
 * THE HARD CLAIMS READ `now` AND NEVER `base`, so --update cannot silence them — R-270's
 * arrangement in check-fight-tail, which is the only part of that guard that cannot be
 * argued with. Chief among them is the ceiling: these tables were published for versions at
 * runFight's default 40 rounds, which truncated 578 of 2000 runs in the worst config and
 * understated its wipe rate by fourteen points. A guard that could be talked out of that
 * check would be worth nothing.
 */
import { readFileSync, existsSync } from "node:fs";
import path from "node:path";
import { measureAll, censoredIn, CONFIGS, BASELINE, CAP, RUNS } from "./pack-tables.mjs";
import { castAndCut } from "./declared-cast.mjs";

const ROOT = path.resolve(path.dirname(new URL(import.meta.url).pathname.replace(/^\/([A-Za-z]:)/, "$1")), "..");
const LIST = process.argv.slice(2).includes("--list");
const MIN_CONFIGS = 14;
const FIELDS = ["hurt", "down", "wiped", "deaths", "median"];

if (!existsSync(BASELINE)) {
  console.error(`check-packs: FAILED — no baseline at ${path.relative(ROOT, BASELINE)}. `
    + `Record one with: node tools/pack-tables.mjs --update`);
  process.exit(1);
}
const base = JSON.parse(readFileSync(BASELINE, "utf8"));
const now = measureAll();
const problems = [];
const notes = [];

/* ── HARD CLAIMS ───────────────────────────────────────────────────────────────────── */

const censored = censoredIn(now);
if (censored.length) {
  problems.push(`  ${censored.length} config(s) hit the ${CAP}-round ceiling: ${censored.join(", ")}. `
    + `A truncated fight is scored by whoever is standing when the loop stops, so the wipe rate `
    + `is understated and nothing says so. This is the defect that produced the 58.7% these `
    + `tables carried for three versions when the real figure was 74.9%. Raise CAP, re-record.`);
} else {
  notes.push(`nothing truncated at ${CAP} rounds (longest ${Math.max(...CONFIGS.map(c => now[c.party][c.id].longest))})`);
}

if (CONFIGS.length < MIN_CONFIGS) {
  problems.push(`  only ${CONFIGS.length} configs, and EXPOSURE prints at least ${MIN_CONFIGS} rows. `
    + `A shrunken config list would let this guard report full agreement over a table it is no `
    + `longer measuring.`);
}

const { line, cut } = castAndCut("check-packs");
for (const [which, want] of [["line", line], ["cut", cut]]) {
  const got = now.party[which];
  if (got.join(",") !== want.join(",")) {
    problems.push(`  the ${which} party measured here is ${got.join(", ")}, and the scenario declares `
      + `${want.join(", ")}. These figures would be a real measurement of a fight this case does not cast.`);
  }
}
if (!problems.length) notes.push(`measured against the declared cast: ${line.join(", ")}`);

/* More of the same creature must not make the party safer. Not a style rule — EXPOSURE's
   "the curve between six and ten is almost vertical" is an argument about this ordering,
   and a violation means the harness has broken rather than that the document is wrong. */
for (const [which, ids] of [["line", ["hollow1", "hollow3", "hollow6"]], ["line", ["column3", "column6", "column10", "column15"]],
                            ["cut", ["hollow3", "hollow6"]], ["cut", ["column3", "column6"]]]) {
  for (let i = 1; i < ids.length; i++) {
    const a = now[which][ids[i - 1]], b = now[which][ids[i]];
    if (b.wiped < a.wiped) {
      problems.push(`  ${which}.${ids[i]} (${b.n} of them) wipes ${b.wiped}% and ${which}.${ids[i - 1]} `
        + `(${a.n}) wipes ${a.wiped}%. More of the same creature made the party safer, which is the `
        + `harness misbehaving, not a finding.`);
    }
  }
}

/* ── AGREEMENT WITH THE RECORD — deterministic, so exact ───────────────────────────── */

let drift = 0;
for (const c of CONFIGS) {
  const b = base[c.party]?.[c.id], n = now[c.party][c.id];
  if (!b) { problems.push(`  ${c.party}.${c.id} is measured here and absent from the baseline. Re-record.`); continue; }
  for (const f of FIELDS) {
    if (b[f] !== n[f]) {
      drift++;
      problems.push(`  ${c.party}.${c.id}.${f}: the game now says ${n[f]}, the baseline holds ${b[f]}. `
        + `These runs are deterministic at seed ${now.seed}, so this is a real change in the harness `
        + `or the cast, not noise. Re-record with --update once you know which, and fix EXPOSURE's `
        + `prose in the same commit — check-cited will not let you forget.`);
    }
  }
}
/* The mirror of the check above, and the one a config-list edit needs. Dropping a config
   leaves the loop above iterating over what remains and agreeing with itself; coverage
   falls and every figure still matches. MIN_CONFIGS is a floor, not a ratchet, so it
   cannot see a single row going missing. */
const dropped = [];
for (const which of ["line", "cut"])
  for (const id of Object.keys(base[which] ?? {}))
    if (!CONFIGS.some(c => c.party === which && c.id === id)) dropped.push(`${which}.${id}`);
if (dropped.length) {
  problems.push(`  ${dropped.length} config(s) in the record are no longer measured: ${dropped.join(", ")}. `
    + `Coverage fell and every remaining figure still agreed, which is how this guard would go on `
    + `reporting success over a smaller table than the one EXPOSURE prints. Re-record deliberately `
    + `if a row was really retired.`);
}
if (!drift && !dropped.length) notes.push(`${CONFIGS.length} configs x ${FIELDS.length} figures agree exactly with the record`);

if (LIST) {
  for (const c of CONFIGS) {
    const r = now[c.party][c.id];
    console.log(`  ${(c.party + "." + c.id).padEnd(20)} ${c.label.padEnd(38)} hurt ${r.hurt} down ${r.down} wiped ${r.wiped}% deaths ${r.deaths} median ${r.median}`);
  }
  notes.forEach(n => console.log(`  ${n}`));
  problems.forEach(p => console.log(p));
  process.exit(0);
}
if (problems.length) {
  console.error("check-packs: FAILED — EXPOSURE's tables no longer describe the fight the game runs");
  problems.forEach(p => console.error(p));
  process.exit(1);
}
console.log(`check-packs: OK — ${CONFIGS.length} pack fights, ${RUNS} runs each at seed ${now.seed}, `
  + `nothing truncated at ${CAP} rounds, every figure matching the record`);