paperlint 3.0.0 → 3.1.1

package/eslint-rules/paper-stages.harness.mjs

@@ -16,6 +16,7 @@ import { fileURLToPath } from "node:url";
 import { Linter } from "eslint";
 import markdown from "@eslint/markdown";
 import stages from "./paper-stages.mjs";
+import { createChecker } from "../lib/check.mjs";
 
 const FIX = join(
   dirname(fileURLToPath(import.meta.url)),
@@ -25,11 +26,7 @@ const FIX = join(
 );
 const linter = new Linter();
 
-let n = 0;
-const check = (label, cond) => {
-  assert.ok(cond, label);
-  n++;
-};
+const check = createChecker();
 
 // 🔴 The `n` counter is RUNNING TOTAL across the whole file, so printing it under one rule's
 // heading would credit that rule with someone else's asserts. That's exactly what happened: the
@@ -38,8 +35,8 @@ const check = (label, cond) => {
 // stands next to it again.
 let mark = 0;
 const since = () => {
-  const d = n - mark;
-  mark = n;
+  const d = check.count - mark;
+  mark = check.count;
   return d;
 };
 
@@ -141,12 +138,10 @@ console.log(
   const { mkdtempSync, writeFileSync, mkdirSync, rmSync } =
     await import("node:fs");
   const root = mkdtempSync(join(FIX, "..", ".tmp-stages-src-"));
-  // 🔴 try/finally, NOT cleanup at the end of the block. Observed 09-16: under every mutation
-  // the assert throws — that is, precisely when the harness is doing its job — and cleanup on
-  // the happy path never runs. One run of the battery left EIGHT `.tmp-stages-src-*` directories
-  // in the repository, one for each mutation deliberately killed. The litter here is not
-  // cosmetic: the mutation driver refuses to run on a dirty tree, so the harness would break
-  // the next run.
+  // 🔴 try/finally, NOT cleanup at the end of the block. Any `check()` above can throw on
+  // failure — that is precisely when the harness is doing its job — so cleanup written after
+  // the checks would never run on that path and would leave a `.tmp-stages-src-*` directory
+  // behind in the repository.
   try {
     const paper = join(root, "one");
     mkdirSync(join(paper, "versions"), { recursive: true });
@@ -237,4 +232,4 @@ console.log(
   `✓ ${String(since())} assertions passed — paper/source, frozen bytes instead of a sha`,
 );
 
-console.log(`✓ ${String(n)} assertions passed in total`);
+console.log(`✓ ${String(check.count)} assertions passed in total`);

package/eslint-rules/paper-stages.test.mjs

@@ -0,0 +1,135 @@
+/**
+ * `paper/stages` and `paper/source` on the malformed declarations the fixture papers do not carry:
+ * YAML that does not parse, `stages` that is not a list, an unknown or missing stage, a missing
+ * field, a date that is not a date — and, in `versions/`, the files the rule must NOT count.
+ */
+import assert from "node:assert/strict";
+import { join } from "node:path";
+import markdown from "@eslint/markdown";
+import { Linter } from "eslint";
+import { test } from "vitest";
+import { useTempDir, writeTree } from "../test/support.mjs";
+import stages from "./paper-stages.mjs";
+
+const root = useTempDir("paper-stages-");
+// Flat config matches `files` against paths under the linter's cwd; the temp papers live outside
+// the repository, so the cwd is the temp root (otherwise: "No matching configuration found").
+const linter = new Linter({ cwd: root });
+
+/** The messages of `rule` on a PIPELINE-STATUS.md with `frontmatter`, in a paper holding `files`. */
+function lint(name, frontmatter, { rule = "stages", files = {} } = {}) {
+  const dir = writeTree(join(root, name), files);
+  const file = join(dir, "PIPELINE-STATUS.md");
+  const msgs = linter.verify(
+    `---\n${frontmatter}\n---\n\n# Status\n`,
+    [
+      {
+        files: ["**/*.md"],
+        plugins: { markdown, paper: stages },
+        language: "markdown/gfm",
+        languageOptions: { frontmatter: "yaml" },
+        rules: { [`paper/${rule}`]: "error" },
+      },
+    ],
+    file,
+  );
+  assert.deepEqual(
+    msgs.filter((m) => m.fatal),
+    [],
+    `${name}: the rule threw`,
+  );
+  return msgs.map((m) => m.message);
+}
+
+test("YAML that does not parse is named; paper/source leaves it to paper/stages", () => {
+  const [msg] = lint("bad-yaml", "stages: [");
+  assert.match(msg, /^the frontmatter does not parse as YAML: /);
+  assert.deepEqual(lint("bad-yaml-src", "stages: [", { rule: "source" }), []);
+});
+
+test("`stages` must be a list: empty and a scalar are each named", () => {
+  assert.deepEqual(lint("empty", "stages:"), [
+    "`stages` must be a LIST of entries, not empty — a paper can reach the same stage twice",
+  ]);
+  assert.deepEqual(lint("scalar", "stages: submitted"), [
+    "`stages` must be a LIST of entries, not string — a paper can reach the same stage twice",
+  ]);
+});
+
+test("each entry: an unknown or missing stage, missing fields, a date that is not a date", () => {
+  assert.deepEqual(
+    lint(
+      "entries",
+      [
+        "stages:",
+        "  - stage: reviewed",
+        "  - date: 2026-08-01",
+        "  - stage: submitted",
+        "    date: 2026-08-01",
+        "  - stage: arxiv",
+        "    date: soon",
+        "    pdf: versions/x.pdf",
+        "    bytes: 1",
+        "  - stage: camera-ready",
+        "    date: 20260801",
+        "    pdf: versions/x.pdf",
+        "    bytes: 1",
+        "  - stage: arxiv",
+        '    date: "2026-08-03"',
+        "    pdf: versions/x.pdf",
+        "    bytes: 1",
+      ].join("\n"),
+    ),
+    [
+      "unknown stage «reviewed» — the vocabulary is: submitted · camera-ready · arxiv",
+      "unknown stage «» — the vocabulary is: submitted · camera-ready · arxiv",
+      "the «submitted» entry has no `pdf` field",
+      "the «submitted» entry has no `bytes` field",
+      "the date «soon» in the «arxiv» entry is not YYYY-MM-DD",
+      "the date «20260801» in the «camera-ready» entry is not YYYY-MM-DD",
+      // A quoted date stays a string and is read the same as an unquoted one.
+      "stage «arxiv» (2026-08-03) is declared, but `versions/x.pdf` is not on disk",
+    ],
+  );
+});
+
+test("paper/source skips a `stages` that is not a list, and entries whose stage is unknown or missing", () => {
+  assert.deepEqual(
+    lint("src-scalar", "stages: submitted", { rule: "source" }),
+    [],
+  );
+  assert.deepEqual(
+    lint("src-skip", "stages:\n  - stage: reviewed\n  - date: 2026-08-01", {
+      rule: "source",
+    }),
+    [],
+  );
+});
+
+test("versions/: only dated stage pdfs count — not other files, STALE ones, odd names or other stages", () => {
+  assert.deepEqual(
+    lint("versions", "title: x", {
+      files: {
+        "versions/README.md": "x",
+        "versions/2026-08-01-submitted.STALE-wrong.pdf": "x",
+        "versions/draft.pdf": "x",
+        "versions/2026-08-01-review.pdf": "x",
+        "versions/2026-08-02-arxiv.pdf": "x",
+      },
+    }),
+    [
+      "`versions/2026-08-02-arxiv.pdf` is frozen, but no «arxiv» stage on 2026-08-02 is declared in `stages` — the artefact ran ahead of the declaration",
+    ],
+  );
+});
+
+test("a frontmatter node without a value (another markdown language) reads as empty YAML", () => {
+  const reports = [];
+  const context = {
+    filename: join(root, "valueless", "PIPELINE-STATUS.md"),
+    report: (r) => reports.push(r),
+  };
+  for (const rule of ["stages", "source"])
+    stages.rules[rule].create(context).yaml({ type: "yaml" });
+  assert.deepEqual(reports, []);
+});

package/eslint-rules/paper-typography.mjs

@@ -50,6 +50,14 @@
  * inserts the zero there. The arXiv lookbehind stays: in `2310.05736` the dot follows a digit.
  * A text macro outside the known set (`\hl{.05}`) is read as a parameter and NOT reported — a
  * miss costs less than a finding on markup.
+ *
+ * 🔴 A NUMBER AFTER `¶` OR `§` IS A DESIGNATOR, NOT A DECIMAL (#102). An auditing standard is cited
+ * by paragraph as `¶¶.42`, and `--fix` rewrote it to `¶¶0.42` — a fix that changed a reference.
+ * So a lexeme right after the sign (`¶`, `§`, `\P`, `\S`, spaces or `~` between) is silent. The
+ * same sentence then goes on `and .44`: a paragraph number continuing the list, or a decimal —
+ * the text does not say which. In a paragraph that already cites `¶.nn` this way, a bare decimal
+ * is REPORTED WITHOUT A FIX and the zero is offered as a suggestion: an autofix must never be the
+ * one to decide what a number means. A real `.05` in any other paragraph is fixed as before.
  */
 import { getParser } from "@unified-latex/unified-latex-util-parse";
 
@@ -193,8 +201,15 @@ function texRuns(nodes, math, src, out) {
   return out;
 }
 
-function texVisibleRuns(raw) {
-  const root = getParser().parse(raw).content;
+/**
+ * The visible runs of a LaTeX source. `parse` is unified-latex's parser; a test hands in a tree
+ * with the fields the walk tolerates being absent.
+ */
+export function texVisibleRuns(
+  raw,
+  { parse = (s) => getParser().parse(s) } = {},
+) {
+  const root = parse(raw).content;
   // Only the document body is typeset. A fragment with no `document` environment is all body.
   const document = root.find(
     (n) => n.type === "environment" && n.env === "document",
@@ -312,16 +327,43 @@ function sectionWord(context) {
 // (2310.05736) out: there the dot follows a digit.
 const BARE_DECIMAL = /(?<![\d.\w])\.\d{2,}\b/g;
 
+// A paragraph or section sign — the glyph, or `\P`/`\S` not followed by a letter — and what may
+// sit between it and the number. Both read the SOURCE, because in LaTeX `\P\P.42` reaches the
+// visible runs as `.42` alone: the macros end the run.
+const DESIGNATOR_BEFORE = /(?:[¶§]|\\[PS](?![A-Za-z]))[ \t~]*$/;
+const DESIGNATED = /(?:[¶§]|\\[PS](?![A-Za-z]))[ \t~]*\.\d/;
+
+/** The source of the paragraph holding `i`, up to `i`: from the last blank line before it. */
+const paragraphBefore = (src, i) => {
+  const head = src.slice(0, i);
+  const blank = [...head.matchAll(/\n[ \t]*\n/g)].at(-1);
+  return head.slice(blank ? blank.index + blank[0].length : 0);
+};
+
 function leadingZero(context) {
-  for (const r of visibleRuns(context.sourceCode))
+  const sc = context.sourceCode;
+  const src = isTex(sc) ? sc.raw : sc.text;
+  for (const r of visibleRuns(sc))
     for (const m of r.text.matchAll(BARE_DECIMAL)) {
       const dot = r.offs[m.index];
       if (dot === null || dot === undefined) continue;
-      at(context, dot, dot + 1, {
-        messageId: "bare",
-        data: { n: m[0] },
-        fix: (f) => f.insertTextBeforeRange([dot, dot], "0"),
-      });
+      const before = paragraphBefore(src, dot);
+      if (DESIGNATOR_BEFORE.test(before)) continue;
+      const zero = (f) => f.insertTextBeforeRange([dot, dot], "0");
+      at(
+        context,
+        dot,
+        dot + 1,
+        DESIGNATED.test(before)
+          ? {
+              messageId: "ambiguous",
+              data: { n: m[0] },
+              suggest: [
+                { messageId: "insertZero", data: { n: m[0] }, fix: zero },
+              ],
+            }
+          : { messageId: "bare", data: { n: m[0] }, fix: zero },
+      );
     }
 }
 
@@ -349,13 +391,14 @@ function figureRefStyle(context) {
   }
 }
 
-const rule = (description, messages, check) => ({
+const rule = (description, messages, check, meta = {}) => ({
   meta: {
     type: "suggestion",
     fixable: "code",
     docs: { description },
     schema: [],
     messages,
+    ...meta,
   },
   create: (context) => ({ "root:exit": () => check(context) }),
 });
@@ -373,8 +416,12 @@ export default {
       "a decimal below 1 written without its leading zero (IEEE / ISO 80000-1); fixable",
       {
         bare: "`{{n}}` has no leading zero — write `0{{n}}` (IEEE / ISO 80000-1); `paperlint lint --fix` inserts it",
+        ambiguous:
+          "`{{n}}` in a paragraph that cites `¶`/`§` numbers: a decimal without its leading zero, or another paragraph number? Not fixed automatically — write `0{{n}}` for a decimal, or put the sign before a paragraph number",
+        insertZero: "It is a decimal: write `0{{n}}`",
       },
       leadingZero,
+      { hasSuggestions: true },
     ),
     "figure-ref-style": rule(
       "`Fig.~\\ref` and `Figure~\\ref` mixed in one document; fixable to the majority form",

package/eslint-rules/paper-typography.test.mjs

@@ -16,7 +16,7 @@ import { readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { texLanguage } from "./latex-language.mjs";
-import typography from "./paper-typography.mjs";
+import typography, { texVisibleRuns } from "./paper-typography.mjs";
 import bib from "./bib-reachable-entry.mjs";
 
 const HERE = dirname(fileURLToPath(import.meta.url));
@@ -203,6 +203,46 @@ describe("paper/leading-zero", () => {
   });
 });
 
+describe("paper/leading-zero — a number after ¶ or § is not a decimal (#102)", () => {
+  // From a consumer's bibliography: `--fix` rewrote the paragraph number `¶¶.42` to `¶¶0.42`.
+  const CITE =
+    "PCAOB. \\emph{Audit of Financial Statements}, ¶¶.42 (design\neffectiveness) and .44 (operating effectiveness).";
+
+  it.each([
+    ["¶¶.42", "Standard 5, ¶¶.42 applies."],
+    ["¶ .42", "Standard 5, ¶ .42 applies."],
+    ["\\P\\P.42", "Standard 5, \\P\\P.42 applies."],
+    ["§.12", "Rule 10b-5, §.12 applies."],
+  ])("SILENT: %s is a designator", async (_, body) => {
+    // Guards: the defect — the lexeme after a paragraph/section sign was read as a decimal.
+    expect(ids(await lint(doc(body)), "paper/leading-zero")).toEqual([]);
+    expect(await fixed(doc(body))).toBe(doc(body));
+  });
+
+  it("🔴 the list continuation `and .44` is reported WITHOUT a fix, with the zero as a suggestion", async () => {
+    const res = await lint(doc(CITE));
+    const found = ids(res, "paper/leading-zero");
+    expect(found.map((m) => [m.line, m.message.slice(0, 5)])).toEqual([
+      [4, "`.44`"],
+    ]);
+    expect(found[0].fix).toBeUndefined();
+    expect(found[0].suggestions).toHaveLength(1);
+    // Guards: --fix changes nothing in an ambiguous paragraph — neither number.
+    expect(await fixed(doc(CITE))).toBe(doc(CITE));
+  });
+
+  it("…while a real decimal still fixes, in markdown too, even beside a cited paragraph", async () => {
+    const body = `${CITE}\n\nWe use a threshold of .05 throughout.`;
+    expect(await fixed(doc(body))).toBe(
+      doc(`${CITE}\n\nWe use a threshold of 0.05 throughout.`),
+    );
+    const md = "See ¶¶.42 and .44.\n\nSignificant at p<.05.\n";
+    expect(await fixed(md, "paper.md")).toBe(
+      "See ¶¶.42 and .44.\n\nSignificant at p<0.05.\n",
+    );
+  });
+});
+
 describe("paper/figure-ref-style", () => {
   it("the minority form is reported and rewritten to the majority", async () => {
     const src = doc("Figure~\\ref{a}, Figure~\\ref{b} and Fig.~\\ref{c}.");
@@ -253,6 +293,32 @@ describe("bib/reachable-entry", () => {
     expect(m.column).toBe(1);
     expect(m.message).toMatch(/`lost`/);
   });
+
+  it("an entry with no key is reported as `?`, not skipped", async () => {
+    const [m] = ids(
+      await lint(bibDoc("@article{\n  title = {x}}")),
+      "bib/reachable-entry",
+    );
+    expect(m.message).toMatch(/`\?`/);
+  });
+
+  it("a source code with only `text`, or with neither text nor raw", () => {
+    const run = (sourceCode) => {
+      const out = [];
+      bib.rules["reachable-entry"]
+        .create({
+          sourceCode: {
+            getLocFromIndex: (i) => ({ line: 1, column: i }),
+            ...sourceCode,
+          },
+          report: (r) => out.push(r.data.key),
+        })
+        ["root:exit"]();
+      return out;
+    };
+    expect(run({ text: bibDoc("@article{t, title = {x}}") })).toEqual(["t"]);
+    expect(run({})).toEqual([]);
+  });
 });
 
 describe("the escape hatch — a disable directive in a `%` comment", () => {
@@ -295,3 +361,122 @@ describe("the escape hatch — a disable directive in a `%` comment", () => {
     ).toHaveLength(1);
   });
 });
+
+describe("where visible text comes from — the walk's other paths", () => {
+  it("a decimal in a braced group, in a typeset math argument, in a table's last argument", async () => {
+    const src = doc(
+      "In a group {.05}.\n\n\\multicolumn{2}{c}{.35}\n\n$x_{.75}$",
+    );
+    expect(
+      ids(await lint(src), "paper/leading-zero").map((m) =>
+        m.message.slice(0, 5),
+      ),
+    ).toEqual(["`.05`", "`.35`", "`.75`"]);
+  });
+
+  it("🔴 inside `\\frac{}{}` unified-latex gives offsets relative to the argument: the decimal is NOT reported", async () => {
+    // Guards: a character whose file offset is unknown gets no report and, above all, no fix at
+    // a guessed place. Known false negative, recorded rather than hidden.
+    const src = doc("$\\frac{1}{.25}$");
+    expect(texVisibleRuns(src).map((r) => [r.text, r.offs])).toContainEqual([
+      ".25",
+      [null, null, null],
+    ]);
+    expect(ids(await lint(src), "paper/leading-zero")).toEqual([]);
+  });
+
+  it("a last-argument macro written without its argument ends the run and reports nothing", async () => {
+    expect(ids(await lint(doc("See \\href")), "paper/leading-zero")).toEqual(
+      [],
+    );
+  });
+
+  it("a tree with no content, no args and a non-string environment name is walked, not thrown on", () => {
+    const tree = {
+      content: [
+        { type: "string", content: "a" },
+        { type: "group" },
+        { type: "environment", env: { weird: true } },
+        { type: "inlinemath" },
+        { type: "string", content: "b" },
+      ],
+    };
+    expect(texVisibleRuns("ab", { parse: () => tree })).toEqual([
+      { text: "a", offs: [null] },
+      { text: "b", offs: [null] },
+    ]);
+  });
+});
+
+describe("markdown: offsets that cannot be followed, and rules that are LaTeX-only", () => {
+  const mdLint = async (text, rules) => {
+    const [res] = await new ESLint({
+      cwd: FIX,
+      overrideConfigFile: true,
+      overrideConfig: [
+        {
+          files: ["**/*.md"],
+          plugins: { markdown, paper: typography },
+          language: "markdown/gfm",
+          rules,
+        },
+      ],
+    }).lintText(text, { filePath: join(FIX, "inline", "paper.md") });
+    expect(res.messages.filter((m) => m.fatal)).toEqual([]);
+    return res;
+  };
+
+  it("`§` before prose is reported without a fix", async () => {
+    const src = "As § above.\n";
+    const res = await mdLint(src, { "paper/section-word": "warn" });
+    expect(res.messages.map((m) => [m.ruleId, m.column, m.fix])).toEqual([
+      ["paper/section-word", 4, undefined],
+    ]);
+  });
+
+  it("a sign or a dot written as a character reference has no source offset: nothing is reported", async () => {
+    const res = await mdLint("See &#167; 5 and &#46;25.\n", {
+      "paper/section-word": "warn",
+      "paper/leading-zero": "warn",
+    });
+    expect(res.messages).toEqual([]);
+  });
+
+  it("figure-ref-style is LaTeX-only: silent on markdown", async () => {
+    const res = await mdLint("Figure~\\ref{a} and Fig.~\\ref{b}.\n", {
+      "paper/figure-ref-style": "warn",
+    });
+    expect(res.messages).toEqual([]);
+  });
+});
+
+describe("a source code the rules did not expect — the defaults hold", () => {
+  const reports = (ruleId, sourceCode) => {
+    const out = [];
+    const context = {
+      sourceCode: {
+        getLocFromIndex: (i) => ({ line: 1, column: i }),
+        ...sourceCode,
+      },
+      report: (r) => out.push(r),
+    };
+    typography.rules[ruleId].create(context)["root:exit"]();
+    return out;
+  };
+
+  it("LaTeX source without an AST: no comment ranges, the sign is still found", () => {
+    const found = reports("section-word", { raw: "See §5." });
+    expect(found.map((r) => [r.messageId, r.loc.start.column])).toEqual([
+      ["sign", 4],
+    ]);
+  });
+
+  it("markdown text nodes without positions: seen, never reported at a guessed place", () => {
+    const ast = {
+      type: "root",
+      children: [{ type: "text", value: "§5 and .25" }],
+    };
+    expect(reports("section-word", { text: "§5 and .25", ast })).toEqual([]);
+    expect(reports("leading-zero", { text: "§5 and .25", ast })).toEqual([]);
+  });
+});

package/eslint-rules/pdf-last-page-balance.harness.mjs

@@ -11,7 +11,6 @@
  * foreign schema, facts about another PDF), and it is QUIET on a balanced page, a stub, a review
  * build, a file that is not paper.tex — and when nobody turned it on.
  */
-import assert from "node:assert/strict";
 import { createHash } from "node:crypto";
 import {
   mkdirSync,
@@ -25,6 +24,7 @@ import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { ESLint } from "eslint";
 import { texLanguage } from "./latex-language.mjs";
+import { createChecker } from "../lib/check.mjs";
 
 const HERE = dirname(fileURLToPath(import.meta.url));
 const { parseFacts, judgeColumns, DEFAULT_TOLERANCE_PT } = await import(
@@ -32,11 +32,7 @@ const { parseFacts, judgeColumns, DEFAULT_TOLERANCE_PT } = await import(
 );
 const { buildConfig } = await import(join(HERE, "..", "src", "cli.ts"));
 
-let n = 0;
-const check = (label, cond, detail = "") => {
-  assert.ok(cond, detail ? `${label} — ${detail}` : label);
-  n++;
-};
+const check = createChecker();
 
 const TEX =
   "% a paper\n\\documentclass[sigconf]{acmart}\n\\begin{document}x\\end{document}\n";
@@ -179,6 +175,66 @@ try {
     only(await lint([join(old, "paper.tex")]))[0]?.messageId === "schema",
   );
 
+  // ── the facts' optional spellings, and a paper.tex the rule cannot place the finding in ──
+  check(
+    "parseFacts: no schema at all, or JSON null, is schema `null` — named, not crashed on",
+    parseFacts("{}").data?.got === "null" &&
+      parseFacts("null").data?.got === "null",
+  );
+  check(
+    "parseFacts: facts without a pdf_sha256 are `factsBroken`",
+    parseFacts(JSON.stringify(facts(MEASURED(1, 1), { pdf_sha256: undefined })))
+      .messageId === "factsBroken",
+  );
+  const abs = paper("absolute-pdf", null);
+  writeFileSync(
+    join(abs, "_build", "paper.facts.json"),
+    JSON.stringify(
+      facts(MEASURED(621.5, 264.8), { pdf: join(abs, "paper.pdf") }),
+    ),
+  );
+  const absMsgs = only(await lint([join(abs, "paper.tex")]));
+  check(
+    "facts naming the PDF by an absolute path are read from there, and judged",
+    absMsgs.length === 1 && absMsgs[0].messageId === "unbalanced",
+    JSON.stringify(absMsgs),
+  );
+  const noClass = paper("no-documentclass", facts(MEASURED(621.5, 264.8)));
+  writeFileSync(
+    join(noClass, "paper.tex"),
+    "\\begin{document}x\\end{document}\n",
+  );
+  check(
+    "a paper.tex with no \\documentclass line: the finding goes on line 1",
+    only(await lint([join(noClass, "paper.tex")]))[0]?.line === 1,
+  );
+  // The text is linted from memory and paper.tex is not on disk: the rule cannot read it back
+  // to find the class line, and still reports — on line 1.
+  const unsaved = paper("unsaved", facts(MEASURED(621.5, 264.8)));
+  rmSync(join(unsaved, "paper.tex"));
+  const [fromMemory] = await new ESLint({
+    cwd: root,
+    overrideConfigFile: true,
+    overrideConfig: buildConfig(
+      {
+        rules: [
+          {
+            basePath: root,
+            files: ["papers/**"],
+            rules: { "pdf/last-page-balance": "error" },
+          },
+        ],
+      },
+      texLanguage,
+    ),
+  }).lintText(TEX, { filePath: join(unsaved, "paper.tex") });
+  const mem = only(fromMemory.messages);
+  check(
+    "a paper.tex linted from memory, not on disk: reported on line 1, not crashed on",
+    mem.length === 1 && mem[0].line === 1 && mem[0].messageId === "unbalanced",
+    JSON.stringify(fromMemory.messages),
+  );
+
   // ── quiet ───────────────────────────────────────────────────────────────────────────
   const bal = paper("balanced", facts(MEASURED(464.2, 461.5)));
   const stub = paper("stub", facts({ kind: "stub", words: 12 }));
@@ -204,5 +260,5 @@ try {
 }
 
 console.log(
-  `✓ ${String(n)} assertions passed — pdf/last-page-balance: fires on unbalanced and unjudgeable, quiet on balanced/stub/review/off`,
+  `✓ ${String(check.count)} assertions passed — pdf/last-page-balance: fires on unbalanced and unjudgeable, quiet on balanced/stub/review/off`,
 );

package/eslint-rules/review-frontmatter.mjs

@@ -53,7 +53,8 @@ function describe(e) {
   return `${where} ${e.message}`;
 }
 
-const errorsOf = (validate, data) =>
+/** The schema's verdict on `data` as messages. Ajv types `errors` as possibly null; that is tolerated. */
+export const errorsOf = (validate, data) =>
   validate(data)
     ? []
     : (validate.errors ?? []).filter((e) => e.keyword !== "if").map(describe);

package/eslint-rules/review-frontmatter.schema.json

@@ -2,7 +2,7 @@
   "$schema": "http://json-schema.org/draft-07/schema#",
   "$id": "urn:paperlint:review-frontmatter",
   "title": "paperlint review frontmatter",
-  "description": "The YAML frontmatter of a review report under reviews/. A review with no `findings` key is not a findings record and is not checked for findings. A project adds its own required fields with the `reviewSchema` setting; its schema is applied together with this one.",
+  "description": "The YAML frontmatter of a review report under reviews/. A review with no `findings` key is not a findings record and is not checked for findings.",
   "type": "object",
   "properties": {
     "findings": {