paperlint 3.0.0 → 3.1.1

package/src/pdf-facts.test.ts

@@ -0,0 +1,144 @@
+/**
+ * pdf-facts.ts on document shapes real test PDFs do not carry, through a fake pdf.js document
+ * (the real pdf.js library for its transforms and operator codes): a font object that is not one,
+ * a font without a name or metrics, an item whose font never resolved, zero-scale transforms, a
+ * document with no pages, text with no font, and a failure that is not an Error.
+ */
+import assert from "node:assert/strict";
+import { getResolvedPDFJS } from "unpdf";
+import { test } from "vitest";
+import { factsOf, failureOf, rawFontOf } from "./pdf-facts.ts";
+
+const lib = await getResolvedPDFJS();
+const H = 792;
+
+interface FakeItem {
+  str: string;
+  fontName: string;
+  transform: number[];
+  width: number;
+  height: number;
+}
+/** A page whose text items and loaded fonts are given; its viewport flips y like pdf.js's. */
+function page(items: FakeItem[], fonts: Record<string, unknown>) {
+  const objs = new Map(Object.entries(fonts));
+  return {
+    getOperatorList: async () => ({ fnArray: [], argsArray: [] }),
+    getTextContent: async () => ({ items }),
+    // Iterable like pdf.js's `commonObjs`, with its `has`/`get`.
+    commonObjs: {
+      has: (id: string) => objs.has(id),
+      get: (id: string) => objs.get(id),
+      [Symbol.iterator]: () => objs[Symbol.iterator](),
+    },
+    getViewport: () => ({
+      width: 612,
+      height: H,
+      transform: [1, 0, 0, -1, 0, H],
+      convertToViewportPoint: (x: number, y: number) => [x, H - y],
+    }),
+  };
+}
+const doc = (pages: ReturnType<typeof page>[]) =>
+  ({
+    numPages: pages.length,
+    getPage: async (i: number) => pages[i - 1],
+  }) as never;
+const item = (
+  fontName: string,
+  transform: number[],
+  height = 10,
+): FakeItem => ({
+  str: "word",
+  fontName,
+  transform,
+  width: 20,
+  height,
+});
+
+test("rawFontOf: not an object, not a font, and a font without a name", () => {
+  assert.deepEqual(
+    [
+      rawFontOf("a", null),
+      rawFontOf("b", { x: 1 }),
+      rawFontOf("c", { loadedName: "L" }),
+    ],
+    [
+      null,
+      null,
+      {
+        id: "c",
+        name: "",
+        type: undefined,
+        subtype: undefined,
+        isType3Font: false,
+        missingFile: false,
+      },
+    ],
+  );
+});
+
+test("a document with no pages is `empty`; text drawn with no font is refused", async () => {
+  assert.deepEqual(await factsOf(doc([]), lib), {
+    ok: false,
+    reason: "empty",
+    detail: "the PDF has no pages",
+  });
+  const r = await factsOf(
+    doc([page([item("f0", [10, 0, 0, 10, 50, 700])], {})]),
+    lib,
+  );
+  assert.equal(r.ok, false);
+  assert.equal(!r.ok && r.reason, "zero-fonts-on-text");
+});
+
+test("metrics, sizes and names fall back when pdf.js gives none", async () => {
+  const fonts = {
+    // a font with a name and an ascent but no descent
+    f1: { loadedName: "f1", name: "Named", ascent: 0.8 },
+    // a font with no name and no metrics at all
+    f2: { loadedName: "f2" },
+  };
+  const r = await factsOf(
+    doc([
+      page(
+        [
+          item("f1", [10, 0, 0, 10, 50, 700]),
+          // zero horizontal scale: the size comes from the item's height…
+          item("f2", [0, 0, 0, 0, 100, 700], 12),
+          // …or, with no height either, from the vertical scale
+          item("f2", [0, 0, 0, 9, 150, 700], 0),
+          // an item whose font pdf.js never resolved
+          item("gone", [10, 0, 0, 10, 200, 700]),
+        ],
+        fonts,
+      ),
+    ]),
+    lib,
+  );
+  assert.equal(r.ok, true);
+  const boxes = r.ok ? r.facts.layout[0]!.boxes : [];
+  assert.deepEqual(
+    boxes.map((b) => [b.font, b.size, b.fill]),
+    [
+      ["Named", 10, { kind: "unknown" }],
+      ["f2", 12, { kind: "unknown" }],
+      ["f2", 9, { kind: "unknown" }],
+      ["gone", 10, { kind: "unknown" }],
+    ],
+  );
+  assert.deepEqual(r.ok ? r.facts.last.words.map((w) => w.text) : [], [
+    "word",
+    "word",
+    "word",
+    "word",
+  ]);
+});
+
+test("a failure that is not an Error is named `Error` with its text", () => {
+  assert.deepEqual(failureOf("boom"), {
+    ok: false,
+    reason: "unreadable",
+    detail: "Error: boom",
+  });
+});

package/src/pdf-facts.ts

@@ -33,7 +33,7 @@ import {
 } from "./pdf-geometry.ts";
 import type { PageLayout, TextBox } from "./domain/page-layout.ts";
 // eslint-disable-next-line boundaries/dependencies -- legacy layer, moves behind a port in #76
-import { fillsOf, isUpright } from "./adapters/pdfjs/fill.ts";
+import { fillsFor, isUpright } from "./adapters/pdfjs/fill.ts";
 
 type PdfJs = Awaited<ReturnType<typeof import("unpdf").getResolvedPDFJS>>;
 type Doc = Awaited<ReturnType<PdfJs["getDocument"]>["promise"]>;
@@ -241,20 +241,18 @@ function layoutOf(
   lib: PdfJs,
 ): PageLayout {
   const vp = page.getViewport({ scale: 1 });
-  const fills = fillsOf(
-    lib.OPS,
-    ops,
-    items.map((it) => it.str),
+  const boxes = fillsFor(lib.OPS, ops, items, (it) => it.str).map(
+    ({ item, fill }): TextBox => ({ ...boxOf(page, vp, item, lib), fill }),
   );
-  const boxes = items.map((it, k): TextBox => ({
-    ...boxOf(page, vp, it, lib),
-    fill: fills[k] ?? { kind: "unknown" },
-  }));
   return { widthPt: vp.width, heightPt: vp.height, boxes };
 }
 
-/** Every page's fonts, and the last page's words. */
-async function factsOf(doc: Doc, lib: PdfJs): Promise<PdfRead> {
+/**
+ * Every page's fonts, and the last page's words. Exported with `failureOf` so a test can hand it a
+ * document whose objects pdf.js shapes only in rare files (a font without metrics, a zero-scale
+ * transform, no pages) — `readPdf` below is the one production caller.
+ */
+export async function factsOf(doc: Doc, lib: PdfJs): Promise<PdfRead> {
   const read: {
     page: Page;
     raw: RawPage;
@@ -290,7 +288,7 @@ async function factsOf(doc: Doc, lib: PdfJs): Promise<PdfRead> {
 }
 
 /** pdf.js's own exception names for the two conditions a caller can act on. */
-function failureOf(e: unknown): PdfRead {
+export function failureOf(e: unknown): PdfRead {
   const err = e as { name?: string; message?: string };
   const detail = `${err.name ?? "Error"}: ${err.message ?? String(e)}`;
   return fail(
@@ -309,13 +307,13 @@ export const readPdf: PdfReader = async (path) => {
   }
   const lib = await loadPdfJs();
   const task = lib.getDocument({ data, ...PDFJS_OPTIONS });
-  try {
-    return await factsOf(await task.promise, lib);
-  } catch (e) {
-    return failureOf(e);
-  } finally {
-    await task.destroy();
-  }
+  // A promise chain rather than try/catch/finally: every path returns a value here, and the code
+  // after such a statement is a block that can never run — which coverage reports as unrun.
+  const read = await task.promise
+    .then((doc) => factsOf(doc, lib))
+    .catch(failureOf);
+  await task.destroy();
+  return read;
 };
 
 /** The one wording of a failed read, as a build step or a CLI prints it. */

package/src/pdf-geometry.harness.mjs

@@ -6,9 +6,9 @@
  * on 2026-08-29 (the midpoint cut, the review build, years mistaken for line numbers), ported from
  * the harness of the function this replaces.
  */
-import assert from "node:assert/strict";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
+import { createChecker } from "../lib/check.mjs";
 
 const HERE = dirname(fileURLToPath(import.meta.url));
 const {
@@ -21,11 +21,7 @@ const {
   STUB_WORDS,
 } = await import(join(HERE, "pdf-geometry.ts"));
 
-let n = 0;
-const check = (label, cond) => {
-  assert.ok(cond, label);
-  n++;
-};
+const check = createChecker();
 
 const W = 612; // US letter, points
 
@@ -250,5 +246,5 @@ check(
 );
 
 console.log(
-  `✓ ${String(n)} assertions passed — pdf-geometry: columns, stub/review, words from runs, fonts`,
+  `✓ ${String(check.count)} assertions passed — pdf-geometry: columns, stub/review, words from runs, fonts`,
 );

package/src/pdf-geometry.ts

@@ -136,7 +136,7 @@ export function wordsOf(run: TextRun): Word[] {
   const y0 = run.baseline - run.ascent * run.size;
   const y1 = run.baseline - run.descent * run.size;
   return [...run.text.matchAll(/\S+/g)].map((m) => {
-    const x0 = run.x + (m.index ?? 0) * perChar;
+    const x0 = run.x + m.index * perChar;
     return { x0, y0, x1: x0 + m[0].length * perChar, y1, text: m[0] };
   });
 }

package/src/presets.test.ts

@@ -230,6 +230,8 @@ describe("labelOf — display only, never used to resolve", () => {
     ["paperlint:agenticdev", "agenticdev"],
     ["./venues/usenix-sec.jsonc", "usenix-sec"],
     ["../shared/acl.json", "acl"],
+    ["./.hidden", ".hidden"],
+    ["paperlint:", ""],
   ])("%s → %s", (spec, label) => {
     expect(labelOf(spec)).toBe(label);
   });

package/src/presets.ts

@@ -293,5 +293,11 @@ export function paperPresetProblem(
   if (p.kind === "preset-problem")
     return `${join(paperDir, CONFIG_FILE)}: ${presetProblemText(p.problem)}`;
   if (p.kind !== "settings-problem") return null;
-  return `${join(paperDir, CONFIG_FILE)}: ${p.problem.why}`;
+  return settingsProblemLine(paperDir, p.problem);
 }
+
+/** The one line naming a paper's `paperlint.json` that does not parse, and why. */
+export const settingsProblemLine = (
+  paperDir: string,
+  problem: SettingsProblem,
+): string => `${join(paperDir, CONFIG_FILE)}: ${problem.why}`;

package/src/references.test.ts

@@ -207,3 +207,100 @@ describe("the reference rules", () => {
     expect(referencesPath(PAPER)).toBe(`${PAPER}/_build/references.json`);
   });
 });
+
+describe("reading what is on disk", () => {
+  it("no paper.tex: the bibliography is refs.bib, from its first byte", () => {
+    const files = memoryFiles({ [`${PAPER}/refs.bib`]: ENTRIES });
+    expect(bibliographyOf(files, PAPER)).toEqual({
+      source: "refs.bib",
+      text: ENTRIES,
+      offset: 0,
+    });
+  });
+
+  it("a references.json of another schema, without entries, or not JSON reads as none", () => {
+    for (const body of [
+      JSON.stringify({ schema: 999, entries: [] }),
+      JSON.stringify({ schema: 1 }),
+      "null",
+      "{",
+    ]) {
+      const files = memoryFiles({ [referencesPath(PAPER)]: body });
+      expect(readReferences(files, PAPER)).toBeNull();
+    }
+  });
+});
+
+/** A record for `bib`, as the build would write it, with `patch` applied to the document. */
+const record = (
+  files: ReturnType<typeof memoryFiles>,
+  body: Record<string, unknown>,
+) => {
+  const bib = bibliographyOf(files, PAPER)!;
+  files.writeAtomic(
+    referencesPath(PAPER) as AbsolutePath,
+    new TextEncoder().encode(
+      JSON.stringify({
+        schema: 1,
+        bib: { source: bib.source, sha256: bibHash(bib) },
+        ...body,
+      }),
+    ),
+  );
+};
+
+describe("the reference rules over a record written by hand", () => {
+  it("not-checked with no reason recorded says so", async () => {
+    const tex = TEX(ENTRIES);
+    const files = memoryFiles({ [`${PAPER}/paper.tex`]: tex });
+    record(files, { status: "not-checked", entries: [] });
+    const msgs = await lint(files, tex);
+    expect(msgs.map((m) => m.ruleId)).toEqual(["paper/refs-checked"]);
+    expect(msgs[0]!.message).toMatch(/no reason recorded/);
+  });
+
+  it("a verdict without a reason, and one for a key the bibliography lacks, still report", async () => {
+    const tex = TEX(ENTRIES);
+    const files = memoryFiles({ [`${PAPER}/paper.tex`]: tex });
+    record(files, {
+      status: "checked",
+      entries: [
+        { key: "schick2023", exists: "true", authors: "mismatch" },
+        { key: "ghost", exists: "false", authors: "match" },
+      ],
+    });
+    const msgs = await lint(files, tex);
+    expect(msgs.map((m) => [m.ruleId, m.line])).toEqual([
+      ["paper/cite-exists", 1],
+      ["paper/author-list", 3],
+    ]);
+  });
+});
+
+describe("the reference rules over refs.bib, and on other files", () => {
+  it("an external refs.bib: findings sit at the start of paper.tex, naming the key", async () => {
+    const tex = "\\documentclass{acmart}\n\\begin{document}x\\end{document}\n";
+    const files = memoryFiles({
+      [`${PAPER}/paper.tex`]: tex,
+      [`${PAPER}/refs.bib`]: ENTRIES,
+    });
+    record(files, {
+      status: "checked",
+      entries: [verdict("schick2023", "mismatch")],
+    });
+    const msgs = await lint(files, tex);
+    expect(msgs.map((m) => [m.ruleId, m.line])).toEqual([
+      ["paper/author-list", 1],
+    ]);
+    expect(msgs[0]!.message).toMatch(/schick2023/);
+  });
+
+  it("only paper.tex is judged", () => {
+    const files = memoryFiles({});
+    const rules = referenceRules({ files });
+    for (const rule of Object.values(rules))
+      expect(rule.create({ filename: `${PAPER}/notes.tex` } as never)).toEqual(
+        {},
+      );
+  });
+});

package/src/references.ts

@@ -129,8 +129,8 @@ export async function recordReferences(
     at(referencesPath(paperDir)),
     new TextEncoder().encode(`${JSON.stringify(doc, null, 2)}\n`),
   );
-  if (doc.status === "not-checked")
-    return `references NOT checked — ${doc.why ?? "no reason given"}; lint will say so`;
+  if (result.kind === "not-checked")
+    return `references NOT checked — ${result.why}; lint will say so`;
   const bad = doc.entries.filter(
     (e) => e.exists === "false" || e.authors === "mismatch",
   ).length;

package/src/rules-config.harness.mjs

@@ -3,20 +3,16 @@
  * paperlint ships. The end-to-end path (a project's paperlint.json → `paperlint lint`) is in `cli.harness.mjs`;
  * this pins the parser's output shape and each refusal.
  */
-import assert from "node:assert/strict";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
+import { createChecker } from "../lib/check.mjs";
 
 const HERE = dirname(fileURLToPath(import.meta.url));
 const { parseRuleBlocks, shippedRuleIds, unknownKeys } = await import(
   join(HERE, "rules-config.ts")
 );
 
-let n = 0;
-const check = (label, cond, detail = "") => {
-  assert.ok(cond, detail ? `${label} — ${detail}` : label);
-  n++;
-};
+const check = createChecker();
 
 const SHIPPED = new Set(["pdf/last-page-balance", "paper/typography"]);
 const parse = (raw) => parseRuleBlocks(raw, "S", SHIPPED, "/consumer");
@@ -112,7 +108,13 @@ check(
           markdown: foreign,
         },
       },
-      { plugins: { paper: { rules: { typography: {} } } } },
+      // A plugin that carries only a language (the `tex` plugin does) has no rules to ship.
+      {
+        plugins: {
+          paper: { rules: { typography: {} } },
+          tex: { languages: {} },
+        },
+      },
       { files: ["x"] },
     ],
     [foreign],
@@ -126,5 +128,5 @@ check(
 }
 
 console.log(
-  `✓ ${String(n)} assertions passed — rules-config: blocks parsed with basePath, every refusal names its key`,
+  `✓ ${String(check.count)} assertions passed — rules-config: blocks parsed with basePath, every refusal names its key`,
 );

package/src/rules-off.test.ts

@@ -0,0 +1,111 @@
+/**
+ * A consumer that ALSO lints paper files with its own ESLint config (#104).
+ *
+ * 3.0.0 made `% eslint-disable-next-line <rule> -- <why>` the way to keep a deliberate exception.
+ * A project that runs its own `eslint` over the same `paper.tex` — for its own rules, with
+ * paperlint's LaTeX language — did not register paperlint's rule plugins, so that run failed on the
+ * directive: "Definition for rule 'paper/leading-zero' was not found". `rulesOff` is the fragment
+ * such a config spreads in: every rule paperlint ships, registered and turned off.
+ */
+import { ESLint, type Linter } from "eslint";
+import { describe, expect, it } from "vitest";
+// @ts-expect-error — the module is .mjs and has no types.
+import { texLanguage } from "../eslint-rules/latex-language.mjs";
+import { rulePlugins, rulesOff, SHIPPED_RULES } from "./cli.ts";
+
+const PAPER = [
+  "\\documentclass{article}",
+  "\\begin{document}",
+  "% eslint-disable-next-line paper/leading-zero -- quoted from the reviewer",
+  "We use a threshold of .05 throughout.",
+  "% eslint-disable-next-line bib/reachable-entry -- kept for the artifact",
+  "Nothing else.",
+  "\\end{document}",
+  "",
+].join("\n");
+
+/** The consumer's own config: its LaTeX files, with paperlint's language, and its own rules. */
+async function lintAsConsumer(
+  fragment: Linter.Config[],
+): Promise<Linter.LintMessage[]> {
+  const eslint = new ESLint({
+    overrideConfigFile: true,
+    overrideConfig: [
+      ...fragment,
+      {
+        files: ["**/*.tex"],
+        plugins:
+          fragment.length > 0
+            ? {}
+            : { tex: { languages: { latex: texLanguage } } },
+        language: "tex/latex",
+      },
+    ],
+  });
+  const [res] = await eslint.lintText(PAPER, {
+    filePath: "papers/a/paper.tex",
+  });
+  return res!.messages;
+}
+
+describe("rulesOff — paperlint's rules, registered and off, for a consumer's own ESLint run", () => {
+  it("without it, the documented escape hatch breaks the consumer's run (the defect)", async () => {
+    const messages = await lintAsConsumer([]);
+    expect(messages.map((m) => m.message)).toContain(
+      "Definition for rule 'paper/leading-zero' was not found.",
+    );
+  });
+
+  it("🔴 spreading it: no 'Definition … not found', and no paperlint finding runs", async () => {
+    const messages = await lintAsConsumer(rulesOff(texLanguage));
+    // Guards: the defect — every directive names a rule ESLint now knows.
+    expect(messages.map((m) => m.message).join("\n")).not.toMatch(
+      /Definition for rule/,
+    );
+    // Guards: off means off — paperlint's own run judges these files, not the consumer's.
+    expect(messages.filter((m) => m.ruleId?.startsWith("paper/"))).toEqual([]);
+    // Guards: a directive naming an OFF rule suppresses nothing, and ESLint would call it unused
+    // ("Unused eslint-disable directive (no problems were reported from 'paper/leading-zero')").
+    expect(messages).toEqual([]);
+  });
+
+  it("registers every rule paperlint ships, each off, and carries the LaTeX language", () => {
+    const [cfg] = rulesOff(texLanguage);
+    expect(new Set(Object.keys(cfg?.rules ?? {}))).toEqual(SHIPPED_RULES);
+    expect(Object.values(cfg?.rules ?? {}).every((e) => e === "off")).toBe(
+      true,
+    );
+    const plugins = rulePlugins(texLanguage);
+    const defined = new Set<string>();
+    for (const [name, p] of Object.entries(plugins))
+      for (const r of Object.keys(p.rules ?? {})) defined.add(`${name}/${r}`);
+    expect(defined).toEqual(SHIPPED_RULES);
+    expect(plugins["tex"]?.languages?.["latex"]).toBe(texLanguage);
+    // `@eslint/markdown` is a dependency's plugin: the consumer registers its own.
+    expect(plugins["markdown"]).toBeUndefined();
+  });
+
+  it("the unused-directive report is off on paper files only, not on the consumer's code", async () => {
+    const eslint = new ESLint({
+      overrideConfigFile: true,
+      overrideConfig: [
+        ...rulesOff(texLanguage),
+        {
+          files: ["**/*.js"],
+          linterOptions: { reportUnusedDisableDirectives: "warn" },
+        },
+      ],
+    });
+    const [res] = await eslint.lintText(
+      "// eslint-disable-next-line paper/leading-zero -- nothing to silence\nconst x = 1;\n",
+      { filePath: "src/x.js" },
+    );
+    expect(res!.messages.map((m) => m.message)).toEqual([
+      "Unused eslint-disable directive (no problems were reported from 'paper/leading-zero').",
+    ]);
+  });
+
+  it("without a LaTeX language, the `tex` plugin carries rules only", () => {
+    expect(rulePlugins()["tex"]?.languages).toBeUndefined();
+  });
+});

package/src/structure.harness.mjs

@@ -6,7 +6,6 @@
  * So every "found" here has a paired "not found on the neighboring directory", and the defaults
  * are separately checked against the shape of the live corpus.
  */
-import assert from "node:assert/strict";
 import {
   mkdtempSync,
   mkdirSync,
@@ -17,16 +16,13 @@ import {
 import { tmpdir } from "node:os";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
+import { createChecker } from "../lib/check.mjs";
 
 const HERE = dirname(fileURLToPath(import.meta.url));
 const { checkStructure, formatStructure, asEslintResults, STRUCTURE_DEFAULTS } =
   await import(join(HERE, "structure.ts"));
 
-let n = 0;
-const check = (label, cond) => {
-  assert.ok(cond, label);
-  n++;
-};
+const check = createChecker();
 
 const root = realpathSync(mkdtempSync(join(tmpdir(), "paperlint-struct-")));
 const papers = join(root, "papers");
@@ -71,8 +67,8 @@ try {
   );
   check(
     "and the message names the CONSEQUENCE, not a restatement of the condition",
-    /is checked/.test(at("no-scorecard")[0].message) &&
-      /stages, sources or research question/.test(
+    /are skipped/.test(at("no-scorecard")[0].message) &&
+      /stage, source and research-question checks/.test(
         at("no-scorecard")[0].message,
       ),
   );
@@ -177,5 +173,5 @@ try {
 }
 
 console.log(
-  `✓ ${String(n)} assertions passed — structure: a missing file cannot complain for itself`,
+  `✓ ${String(check.count)} assertions passed — structure: a missing file cannot complain for itself`,
 );

package/src/structure.ts

@@ -122,7 +122,7 @@ export function checkStructure(
  */
 function whyMissingMatters(file: string, dirName: string): string {
   if (file === "PIPELINE-STATUS.md")
-    return `\`paper/stages\`, \`paper/source\` and \`paper/research-question\` read this file, so nothing \`${dirName}\` declares about its stages, sources or research question is checked`;
+    return `the stage, source and research-question checks are skipped for \`${dirName}\``;
   return `declared as required by your \`structure\` configuration`;
 }
 

package/src/tex-requirements.harness.mjs

@@ -7,7 +7,6 @@
  *   2. the schema REJECTS what it must — each bad profile names the offending path;
  *   3. what a paper gets: its venue plus the base set, or the base set with the reason said.
  */
-import assert from "node:assert/strict";
 import {
   copyFileSync,
   mkdtempSync,
@@ -19,6 +18,7 @@ import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import ts from "typescript";
+import { createChecker } from "../lib/check.mjs";
 
 const HERE = dirname(fileURLToPath(import.meta.url));
 const VENUES = join(
@@ -31,11 +31,7 @@ const VENUES = join(
 );
 const R = await import(join(HERE, "tex-requirements.ts"));
 
-let n = 0;
-const check = (label, cond, detail = "") => {
-  assert.ok(cond, `${label}${detail ? ` — ${detail}` : ""}`);
-  n++;
-};
+const check = createChecker();
 const throws = (fn) => {
   try {
     fn();
@@ -229,4 +225,35 @@ rmSync(tmp, { recursive: true, force: true });
   );
 }
 
-console.log(`tex-requirements: ${n} checks passed`);
+// ── 5. the parser's tolerances: an optional block left out, and Ajv's optional fields ───
+{
+  const bare = R.parsePreset(
+    '{ "extends": "paperlint:aisec" }',
+    "bare.jsonc",
+    VENUES,
+  );
+  check(
+    "a preset that only extends another: no tex block, `rules` an empty object",
+    JSON.stringify([bare.extends, bare.tex, bare.rules]) ===
+      '["paperlint:aisec",null,{}]',
+    bare,
+  );
+  // Guards: `packages` is read without a fallback because the schema refuses a tex block
+  // without it — this is the refusal the type relies on.
+  check(
+    "a tex block without `packages` is refused by the schema, before anything reads it",
+    /tex\.jsonc: \.tex should have required property 'packages'/.test(
+      throws(() => R.parsePreset('{ "tex": {} }', "tex.jsonc", VENUES)),
+    ),
+    throws(() => R.parsePreset('{ "tex": {} }', "tex.jsonc", VENUES)),
+  );
+  check(
+    "violations: Ajv's null `errors` is no violation; a message Ajv left out is an empty one",
+    R.violations("f.jsonc", { errors: null }).length === 0 &&
+      R.violations("f.jsonc", {
+        errors: [{ dataPath: "", message: undefined }],
+      })[0] === "f.jsonc: (top level) ",
+  );
+}
+
+console.log(`tex-requirements: ${check.count} checks passed`);