paperlint 3.1.0 → 3.1.2

package/eslint-rules/paper-research-question.harness.mjs

@@ -13,10 +13,19 @@
  */
 import assert from "node:assert/strict";
 import { join, dirname } from "node:path";
-import { readFileSync } from "node:fs";
+import {
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  realpathSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
 import { fileURLToPath } from "node:url";
 import { Linter } from "eslint";
 import markdown from "@eslint/markdown";
+import { createChecker } from "../lib/check.mjs";
 
 const HERE = dirname(fileURLToPath(import.meta.url));
 const FIX = join(HERE, "..", "fixtures", "paper-research-question");
@@ -24,11 +33,7 @@ const FIX = join(HERE, "..", "fixtures", "paper-research-question");
 const { texLanguage } = await import(join(HERE, "latex-language.mjs"));
 const rq = (await import(join(HERE, "paper-research-question.mjs"))).default;
 
-let n = 0;
-const check = (label, cond) => {
-  assert.ok(cond, label);
-  n++;
-};
+const check = createChecker();
 
 const linter = new Linter();
 
@@ -141,6 +146,67 @@ check(
     .length === 1,
 );
 
+// ── a scorecard that cannot be read is no scorecard: silence, never a crash ────────────
+// A directory where the file should be (EISDIR), and front matter that is not YAML — which
+// `paper/stages` reports on the scorecard itself, so this rule does not report it twice.
+{
+  const work = realpathSync(mkdtempSync(join(tmpdir(), "paperlint-rq-")));
+  try {
+    const paperIn = (name, status) => {
+      const dir = join(work, name);
+      mkdirSync(dir);
+      status(join(dir, "PIPELINE-STATUS.md"));
+      const path = join(dir, "paper.md");
+      writeFileSync(path, "# A paper\n");
+      // A linter rooted at the scratch directory: files outside `cwd` match no config.
+      return new Linter({ cwd: work }).verify(
+        "# A paper\n",
+        [
+          {
+            files: ["**/*.md"],
+            plugins: { markdown, paper: rq },
+            language: "markdown/gfm",
+            rules: { "paper/research-question": "error" },
+          },
+        ],
+        path,
+      );
+    };
+    check(
+      "a scorecard path that is a directory: no finding, no crash",
+      JSON.stringify(paperIn("dir", (p) => mkdirSync(p))) === "[]",
+      () => paperIn("dir2", (p) => mkdirSync(p)),
+    );
+    check(
+      "a scorecard whose front matter is not YAML: no finding, no crash",
+      JSON.stringify(
+        paperIn("yaml", (p) =>
+          writeFileSync(p, "---\nstages: [submitted\n---\n"),
+        ),
+      ) === "[]",
+    );
+  } finally {
+    rmSync(work, { recursive: true, force: true });
+  }
+}
+
+// ── a language whose source code carries no text at all: nothing to compare, silence ───
+{
+  const reports = [];
+  rq.rules["research-question"]
+    .create({
+      options: [],
+      filename: join(FIX, "shipped-no-rq", "paper.tex"),
+      sourceCode: {},
+      report: (r) => reports.push(r),
+    })
+    ["root:exit"]({});
+  check(
+    "a source code with neither `raw` nor `text` is skipped, even for a shipped paper",
+    reports.length === 0,
+  );
+}
+
 console.log(
-  `✓ ${String(n)} assertions passed — paper/research-question, the debt of a shipped paper`,
+  `✓ ${String(check.count)} assertions passed — paper/research-question, the debt of a shipped paper`,
 );

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

@@ -201,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",

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));
@@ -293,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", () => {
@@ -335,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 § 5 and .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.test.mjs

@@ -5,7 +5,7 @@
 import { describe, expect, it } from "vitest";
 import { ESLint } from "eslint";
 import markdown from "@eslint/markdown";
-import review from "./review-frontmatter.mjs";
+import review, { errorsOf } from "./review-frontmatter.mjs";
 import sibling from "./sibling-frontmatter.mjs";
 
 async function lint(text) {
@@ -81,6 +81,42 @@ describe("review/frontmatter — the findings record", () => {
   });
 });
 
+describe("review/frontmatter — what the parser and the validator may hand back", () => {
+  /** The rule's visitors over a fake context; the reports it makes. */
+  const visit = (value) => {
+    const reports = [];
+    const v = review.rules.frontmatter.create({
+      report: (r) => reports.push(r),
+    });
+    v.yaml({ value });
+    v["root:exit"]({});
+    return reports.map(
+      (r) => r.messageId + (r.data?.why ? `: ${r.data.why}` : ""),
+    );
+  };
+
+  it("an empty frontmatter block is validated as `{}` — silent", async () => {
+    expect(await lint("---\n---\n# Review\n")).toEqual([]);
+    expect(visit(undefined)).toEqual([]);
+  });
+
+  it("a parser failure without a YAML reason is reported by its message, or as unparseable", () => {
+    const throwing = (thrown) => ({
+      toString() {
+        throw thrown;
+      },
+    });
+    expect(visit(throwing(new Error("boom")))).toEqual(["malformed: boom"]);
+    expect(visit(throwing("not an Error"))).toEqual(["malformed: unparseable"]);
+  });
+
+  it("a failed validation with no errors attached names nothing", () => {
+    const validate = () => false;
+    validate.errors = null;
+    expect(errorsOf(validate, {})).toEqual([]);
+  });
+});
+
 describe("sibling/frontmatter — the same mechanism, the package's own sibling-card schema", () => {
   async function card(text) {
     const eslint = new ESLint({