paperlint 3.2.0 → 4.1.0

package/src/pdf-facts.test.ts

@@ -40,11 +40,11 @@ function page(items: FakeItem[], fonts: Record<string, unknown>) {
     }),
   };
 }
-const doc = (pages: ReturnType<typeof page>[]) =>
-  ({
-    numPages: pages.length,
-    getPage: (i: number) => Promise.resolve(pages[i - 1]),
-  }) as never;
+const doc = (pages: ReturnType<typeof page>[]) => ({
+  numPages: pages.length,
+  getPage: (i: number) =>
+    Promise.resolve(present(pages[i - 1], `page ${String(i)}`)),
+});
 const item = (
   fontName: string,
   transform: number[],
@@ -141,3 +141,14 @@ test("a failure that is not an Error is named `Error` with its text", () => {
     detail: "Error: boom",
   });
 });
+
+test("🔴 a rejection with no value at all is a failure too, not a TypeError out of `readPdf`", () => {
+  // Guards: `readPdf` ends in `.catch(failureOf)`, and reading `.name` off `null` threw from inside it.
+  assert.deepEqual(
+    [failureOf(null), failureOf(undefined)],
+    [
+      { ok: false, reason: "unreadable", detail: "Error: null" },
+      { ok: false, reason: "unreadable", detail: "Error: undefined" },
+    ],
+  );
+});

package/src/pdf-facts.ts

@@ -35,12 +35,67 @@ import type { PageLayout, TextBox } from "./domain/page-layout.ts";
 // eslint-disable-next-line boundaries/dependencies -- legacy layer, moves behind a port in #76
 import { fillsFor, isUpright } from "./adapters/pdfjs/fill.ts";
 import { messageOf } from "./domain/text.ts";
+import { fieldOf, isRecord, numbersOf } from "./domain/record.ts";
 
 type PdfJs = Awaited<ReturnType<typeof import("unpdf").getResolvedPDFJS>>;
-type Doc = Awaited<ReturnType<PdfJs["getDocument"]>["promise"]>;
-type Page = Awaited<ReturnType<Doc["getPage"]>>;
-type Item = Awaited<ReturnType<Page["getTextContent"]>>["items"][number];
-type TextItem = Extract<Item, { str: string }>;
+
+/** A text item as this module reads it; pdf.js's `TextItem` is one. */
+interface TextItem {
+  readonly str: string;
+  readonly fontName: string;
+  /** pdf.js types it `any[]`; `numbersOf` reads it. */
+  readonly transform: readonly unknown[];
+  readonly width: number;
+  readonly height: number;
+}
+/** What else pdf.js lists among a page's items: a marked-content boundary, with no text. */
+interface MarkedContent {
+  readonly type: string;
+  readonly str?: undefined;
+}
+type Item = TextItem | MarkedContent;
+
+/** A page's operators, as `fillsFor` walks them; pdf.js's operator list is one. */
+interface OperatorList {
+  readonly fnArray: readonly number[];
+  readonly argsArray: readonly unknown[];
+}
+
+/** A viewport as this module reads it; pdf.js's `PageViewport` is one. */
+interface Viewport {
+  readonly width: number;
+  readonly height: number;
+  readonly transform: readonly number[];
+  convertToViewportPoint(x: number, y: number): readonly unknown[];
+}
+
+/**
+ * A page as this module reads it. pdf.js's `PDFPageProxy` is one, and so is a test's fake page: the
+ * module depends on these five members, not on the rest of pdf.js's page.
+ */
+interface Page {
+  getOperatorList(): Promise<OperatorList>;
+  getTextContent(): Promise<{ readonly items: readonly Item[] }>;
+  /** pdf.js's `commonObjs`: loaded objects by id, iterable as `[id, object]` pairs. */
+  readonly commonObjs: {
+    has(id: string): boolean;
+    get(id: string): unknown;
+    [Symbol.iterator](): Iterator<readonly unknown[]>;
+  };
+  getViewport(params: { scale: number }): Viewport;
+}
+
+/** A document as this module reads it; pdf.js's `PDFDocumentProxy` is one. */
+interface Doc {
+  readonly numPages: number;
+  getPage(pageNumber: number): Promise<Page>;
+}
+
+/** A viewport point, which pdf.js types as `any[]`: the two numbers it holds. */
+const pointOf = (xy: readonly unknown[]): [number, number] => [
+  Number(xy[0]),
+  Number(xy[1]),
+];
 
 /**
  * What `readPdf` measured. `last` is the last page's words; `classifyLastPage` reads it. `layout` is
@@ -95,8 +150,8 @@ const fail = (reason: PdfReadFailure, detail: string): PdfRead => ({
 
 /** A font object pdf.js left in `commonObjs`, read into a `RawFont`, or null when it is not one. */
 export function rawFontOf(id: string, obj: unknown): RawFont | null {
-  if (typeof obj !== "object" || obj === null) return null;
-  const o = obj as Record<string, unknown>;
+  if (!isRecord(obj)) return null;
+  const o = obj;
   if (!("loadedName" in o) && !("isType3Font" in o)) return null;
   const str = (v: unknown): string | undefined =>
     typeof v === "string" ? v : undefined;
@@ -111,7 +166,7 @@ export function rawFontOf(id: string, obj: unknown): RawFont | null {
 }
 
 const isText = (it: Item): it is TextItem =>
-  "str" in it && it.str.trim() !== "";
+  typeof it.str === "string" && it.str.trim() !== "";
 
 /** The font pdf.js resolved for `id`, if it did. `get` throws on an unresolved id; `has` does not. */
 function resolved(page: Page, id: string): unknown {
@@ -124,9 +179,10 @@ function resolved(page: Page, id: string): unknown {
  */
 function loadedFonts(page: Page): Map<string, RawFont> {
   const out = new Map<string, RawFont>();
-  for (const [id, obj] of page.commonObjs as Iterable<[string, unknown]>) {
-    const f = rawFontOf(id, obj);
-    if (f) out.set(id, f);
+  // pdf.js yields `[id, object]` pairs, typed `any[]`.
+  for (const entry of page.commonObjs) {
+    const f = rawFontOf(String(entry[0]), entry[1]);
+    if (f) out.set(f.id, f);
   }
   return out;
 }
@@ -167,7 +223,7 @@ async function readPage(
  * Both are far below any balance tolerance, so the simpler rule stays.
  */
 function metricsOf(font: unknown): { ascent: number; descent: number } {
-  const f = (font ?? {}) as Record<string, unknown>;
+  const f = isRecord(font) ? font : {};
   const ascent = f["ascent"];
   if (typeof ascent !== "number" || !(ascent > 0))
     return { ascent: DEFAULT_ASCENT, descent: DEFAULT_DESCENT };
@@ -179,8 +235,8 @@ function metricsOf(font: unknown): { ascent: number; descent: number } {
 function pageText(page: Page, items: readonly TextItem[]): PageText {
   const vp = page.getViewport({ scale: 1 });
   const runs: TextRun[] = items.map((it) => {
-    const [a = 0, b = 0, , d = 0, e = 0, f = 0] = it.transform as number[];
-    const [x, baseline] = vp.convertToViewportPoint(e, f) as [number, number];
+    const [a = 0, b = 0, , d = 0, e = 0, f = 0] = numbersOf(it.transform);
+    const [x, baseline] = pointOf(vp.convertToViewportPoint(e, f));
     const size = Math.hypot(a, b) || it.height || Math.abs(d);
     return {
       text: it.str,
@@ -200,7 +256,7 @@ function pageText(page: Page, items: readonly TextItem[]): PageText {
 
 /** The font name pdf.js resolved for an item, else its internal id. */
 function fontNameOf(font: unknown, id: string): string {
-  const name = (font as { name?: unknown } | null)?.name;
+  const name = fieldOf(font, "name");
   return typeof name === "string" && name ? name : id;
 }
 
@@ -211,12 +267,12 @@ function fontNameOf(font: unknown, id: string): string {
  */
 function boxOf(
   page: Page,
-  vp: ReturnType<Page["getViewport"]>,
+  vp: Viewport,
   it: TextItem,
   lib: PdfJs,
 ): Omit<TextBox, "fill"> {
-  const [a = 0, b = 0, c = 0, d = 0, e = 0, f = 0] = it.transform as number[];
-  const [x, baseline] = vp.convertToViewportPoint(e, f) as [number, number];
+  const [a = 0, b = 0, c = 0, d = 0, e = 0, f = 0] = numbersOf(it.transform);
+  const [x, baseline] = pointOf(vp.convertToViewportPoint(e, f));
   const size = Math.hypot(c, d) || Math.hypot(a, b) || it.height;
   const font = resolved(page, it.fontName);
   const m = metricsOf(font);
@@ -229,7 +285,7 @@ function boxOf(
     font: fontNameOf(font, it.fontName),
     text: it.str,
     upright: isUpright(
-      lib.Util.transform(vp.transform, it.transform) as number[],
+      numbersOf(lib.Util.transform(vp.transform, it.transform)),
     ),
   };
 }
@@ -238,7 +294,7 @@ function boxOf(
 function layoutOf(
   page: Page,
   items: readonly TextItem[],
-  ops: Awaited<ReturnType<Page["getOperatorList"]>>,
+  ops: OperatorList,
   lib: PdfJs,
 ): PageLayout {
   const vp = page.getViewport({ scale: 1 });
@@ -290,10 +346,11 @@ export async function factsOf(doc: Doc, lib: PdfJs): Promise<PdfRead> {
 
 /** pdf.js's own exception names for the two conditions a caller can act on. */
 export function failureOf(e: unknown): PdfRead {
-  const err = e as { name?: string; message?: string };
-  const detail = `${err.name ?? "Error"}: ${err.message ?? String(e)}`;
+  const name = fieldOf(e, "name");
+  const message = fieldOf(e, "message");
+  const detail = `${typeof name === "string" ? name : "Error"}: ${typeof message === "string" ? message : String(e)}`;
   return fail(
-    err.name === "PasswordException" ? "encrypted" : "unreadable",
+    name === "PasswordException" ? "encrypted" : "unreadable",
     detail,
   );
 }

package/src/pdf-geometry.ts

@@ -160,6 +160,10 @@ export type FontProgram =
 /** A program pdf.js named but this module does not know — kept verbatim, never guessed. */
 export type UnknownProgram = `unknown:${string}`;
 
+const isUnknownProgram = (
+  p: FontProgram | UnknownProgram,
+): p is UnknownProgram => p.startsWith("unknown:");
+
 /**
  * One font the PDF draws text with.
  *
@@ -296,7 +300,5 @@ export const POPPLER_TYPE: Readonly<Record<FontProgram, string>> = {
 /** The type column for any fact, the unknown ones verbatim. */
 export function popplerType(f: FontFact): string {
   if (f.kind === "type3") return POPPLER_TYPE.Type3;
-  return f.program.startsWith("unknown:")
-    ? f.program
-    : POPPLER_TYPE[f.program as FontProgram];
+  return isUnknownProgram(f.program) ? f.program : POPPLER_TYPE[f.program];
 }

package/src/ports/latex.ts

@@ -0,0 +1,29 @@
+/**
+ * What paperlint needs from a LaTeX source, shaped by its rules and `paperlint new` — not by the
+ * parser. The one implementation is `src/adapters/latex/` (unified-latex); `src/cli.ts` wires it.
+ */
+import type {
+  ClassLine,
+  DocumentClass,
+  Outline,
+  TextRun,
+} from "../domain/tex-document.ts";
+
+export interface LatexReader {
+  /** The source's `\documentclass`, as one of its states. */
+  readonly documentClass: (src: string) => ClassLine;
+  /** Its sections, where the back matter begins, and where the document ends. */
+  readonly outline: (src: string) => Outline;
+  /** The text a reader sees: prose, the author block, footnotes — not comments, keys, math, code. */
+  readonly renderedRuns: (src: string) => readonly TextRun[];
+  /**
+   * A preset's `template` → the class it names: a whole `\documentclass[…]{…}` line, or a bare
+   * class name (no option). Null for anything else.
+   */
+  readonly template: (text: string) => DocumentClass | null;
+  /**
+   * `src` with its `\documentclass` set to `want` — unless it already is `want`'s class with every
+   * option `want` names (the author's own options stay), or it has none.
+   */
+  readonly withDocumentClass: (src: string, want: DocumentClass) => string;
+}

package/src/ports/tool-installer.ts

@@ -2,26 +2,11 @@
  * The port `paperlint toolchain` installs and checks an external program through. One port, many
  * programs: banal implements it now, TeX Live in #76.
  */
-import type { Opaque } from "ts-essentials";
 import type { Result } from "../domain/result.ts";
 import type { Lines } from "../domain/text.ts";
+import type { Ready } from "../domain/ready.ts";
 
-/**
- * Present, verified, running. BRANDED: a literal `{ where, fresh, verified }` is not a `Ready`, so
- * only an installer's adapter — one minting function each (banal's is `ready` in
- * `adapters/banal/index.ts`) — can make one, and a ready line cannot be printed without it.
- */
-export type Ready = Opaque<
-  {
-    /** Where it is: the program's path or its bin directory. */
-    readonly where: string;
-    /** This run installed it. */
-    readonly fresh: boolean;
-    /** What was checked before calling it ready, as a person reads it. */
-    readonly verified: string;
-  },
-  "Ready"
->;
+export type { Ready };
 
 export interface ToolInstaller {
   /** The program as a person reads it: `banal 1.2 (HotCRP f3e4352)`. */

package/src/presets.test.ts

@@ -10,15 +10,18 @@ import { readdirSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { describe, expect, it } from "vitest";
 import { memoryFiles } from "./adapters/memory/index.ts";
-import { packageVenuesDir } from "../skills/paper-pipeline/scripts/consumer.mjs";
+import { presetsDir } from "./package-dirs.ts";
+import { parsePreset } from "./tex-requirements.ts";
 import {
   MAX_PRESET_DEPTH,
+  SHIPPED_PREFIX,
+  shippedPresets,
   labelOf,
   presetProblemText,
   resolvePreset,
 } from "./presets.ts";
 
-const VENUES = packageVenuesDir();
+const VENUES = presetsDir();
 const shipped = Object.fromEntries(
   readdirSync(VENUES)
     .filter((f) => f.endsWith(".jsonc") || f.endsWith(".json"))
@@ -44,7 +47,11 @@ describe("shipped presets", () => {
     expect(r.value.format.columns).toBe(2);
     expect(r.value.format.fontsText).toBe("LinLibertine");
     expect([...r.value.format.kinds.keys()]).toEqual(["short", "full", "demo"]);
-    expect(r.value.template).toBe("acmart");
+    // The family's template, as its file spells it: the child names none.
+    expect(r.value.template).toEqual({
+      text: "\\documentclass[sigconf]{acmart}",
+      file: join(VENUES, "acm-sigconf.jsonc"),
+    });
     expect("acmart" in r.value.tex.packages).toBe(true);
     expect(r.value.label).toBe("agenticdev");
   });
@@ -70,6 +77,45 @@ describe("shipped presets", () => {
   });
 });
 
+describe("the naming convention of shipped presets (docs/rules.md)", () => {
+  // Each shipped preset, parsed: its file name and what it extends. The families are DERIVED — a
+  // shipped preset another shipped preset extends — so a new family is checked the day it ships.
+  const presets = shippedPresets(VENUES).map((name) => {
+    const file = join(VENUES, `${name}.jsonc`);
+    return {
+      name,
+      extends: parsePreset(readFileSync(file, "utf8"), file, VENUES).extends,
+    };
+  });
+  const families = presets.filter((p) =>
+    presets.some((q) => q.extends === `${SHIPPED_PREFIX}${p.name}`),
+  );
+  const publishers = families.map((f) => f.name.slice(0, f.name.indexOf("-")));
+
+  it("there are families to check (else the checks below see nothing)", () => {
+    expect(families.map((f) => f.name).sort()).toEqual([
+      "acm-sigconf",
+      "ieee-conference",
+    ]);
+  });
+
+  it.each(families.map((f) => [f.name]))(
+    "the family %s is <publisher>-<template variant>",
+    (name) => {
+      expect(name).toMatch(/^[a-z0-9]+-[a-z0-9-]+$/);
+    },
+  );
+
+  it.each(presets.filter((p) => p.extends !== null).map((p) => [p.name]))(
+    "the venue %s carries no publisher prefix — its template is said by `extends`",
+    (name) => {
+      expect(publishers.filter((pub) => name.startsWith(`${pub}-`))).toEqual(
+        [],
+      );
+    },
+  );
+});
+
 describe("a project's own preset, by relative path", () => {
   const usenix = JSON.stringify({
     extends: "paperlint:acm-sigconf",
@@ -149,7 +195,7 @@ describe("what does not resolve, and says why", () => {
       "a shipped name with a typo",
       "paperlint:agenticdve",
       "not-found",
-      /acm-sigconf, agenticdev, aisec, realm/,
+      /acm-sigconf, agenticdev, aidc, aisec, ieee-conference, realm/,
     ],
     ["the base TeX set", "paperlint:tex-base", "not-found", /agenticdev/],
     [
@@ -225,6 +271,21 @@ describe("chains that do not resolve", () => {
   });
 });
 
+describe("a preset's template: kept as its file spells it, with that file", () => {
+  it("a child's template replaces its parent's, and names its own file", () => {
+    const r = resolve("./own.jsonc", {
+      "/work/papers/p/own.jsonc": JSON.stringify({
+        extends: "paperlint:aidc",
+        template: "\\documentclass[conference]{IEEEtran}",
+      }),
+    });
+    expect(r.ok && r.value.template).toEqual({
+      text: "\\documentclass[conference]{IEEEtran}",
+      file: "/work/papers/p/own.jsonc",
+    });
+  });
+});
+
 describe("labelOf — display only, never used to resolve", () => {
   it.each([
     ["paperlint:agenticdev", "agenticdev"],

package/src/presets.ts

@@ -19,7 +19,8 @@
  *   tex        union — a child never removes a package its parent needs
  *   format     per key, the child wins; `kinds` by kind name, a child's kind replaces that kind
  *   rules      per rule id, the child wins
- *   template   the child wins; so does `name`
+ *   template   the child wins; so does `name`, and `required_sections` (the whole list)
+ *   aliases    union, with every `name` — what the venue is called along the chain
  *
  * ── THE LABEL ─────────────────────────────────────────────────────────────────────
  * Messages, the facts file and the build plan need a word for the venue. It is the most derived
@@ -36,10 +37,11 @@ import {
   profileFileOf,
   venueNames,
   type PresetFile,
+  type RequiredSection,
   type TexRequirements,
   type VenueFormat,
 } from "./tex-requirements.ts";
-import type { AbsolutePath } from "./domain/paths.ts";
+import { callerPath } from "./caller-path.ts";
 import { err, ok, type Result } from "./domain/result.ts";
 import type { Files } from "./ports/files.ts";
 import {
@@ -61,13 +63,27 @@ export interface PresetDeps {
   readonly venuesDir: string;
 }
 
+/** A preset's `template`, as its file spells it. */
+export interface PresetTemplate {
+  readonly text: string;
+  readonly file: string;
+}
+
 /** A resolved chain, merged. */
 export interface Preset {
   /** The word for this venue in messages. */
   readonly label: string;
   /** Every file of the chain, root first. */
   readonly chain: readonly string[];
-  readonly template: string | null;
+  /**
+   * The `\\documentclass` the venue's template uses, as the preset spells it, and the file that
+   * spells it; null when no file of the chain names one. Read by the rules and `paperlint new`,
+   * through the LaTeX reader.
+   */
+  readonly template: PresetTemplate | null;
+  /** Every `name` and `aliases` along the chain: what this venue is called in a paper's text. */
+  readonly aliases: readonly string[];
+  readonly requiredSections: readonly RequiredSection[];
   readonly tex: TexRequirements;
   readonly format: VenueFormat;
   readonly rules: Readonly<Record<string, unknown>>;
@@ -120,7 +136,7 @@ function readPreset(
 ): Result<{ file: string; preset: PresetFile }, PresetProblem> {
   const where = fileOf(spec, from, deps.venuesDir);
   if (!where.ok) return where;
-  const bytes = deps.files.readBytes(where.value as AbsolutePath);
+  const bytes = deps.files.readBytes(callerPath(where.value));
   if (bytes === null)
     return err({ kind: "not-found", spec, file: where.value, shipped: [] });
   try {
@@ -166,33 +182,58 @@ export function mergeFormat(
   parent: VenueFormat,
   child: VenueFormat,
 ): VenueFormat {
-  const keys = Object.keys(NO_FORMAT).filter((k) => k !== "kinds") as Exclude<
-    keyof VenueFormat,
-    "kinds"
-  >[];
-  const scalars = Object.fromEntries(
-    keys.map((k) => [k, child[k] ?? parent[k]]),
-  ) as Omit<VenueFormat, "kinds">;
-  return { ...scalars, kinds: new Map([...parent.kinds, ...child.kinds]) };
+  // Every field listed: a VenueFormat literal missing one is a compile error.
+  const pick = <K extends Exclude<keyof VenueFormat, "kinds">>(
+    k: K,
+  ): VenueFormat[K] => child[k] ?? parent[k];
+  return {
+    pageWidthIn: pick("pageWidthIn"),
+    pageHeightIn: pick("pageHeightIn"),
+    columns: pick("columns"),
+    bodyPt: pick("bodyPt"),
+    bodyPtTol: pick("bodyPtTol"),
+    refPtMin: pick("refPtMin"),
+    refPtMax: pick("refPtMax"),
+    fontsText: pick("fontsText"),
+    fontsTitle: pick("fontsTitle"),
+    kinds: new Map([...parent.kinds, ...child.kinds]),
+  };
 }
 
 /** The chain, root first, merged into one preset. Pure. */
 function merged(
   spec: string,
-  rootFirst: readonly PresetFile[],
-  files: readonly string[],
+  rootFirst: readonly { readonly preset: PresetFile; readonly file: string }[],
 ): Preset {
-  const base = {
-    name: null as string | null,
-    template: null as string | null,
+  const base: {
+    name: string | null;
+    template: PresetTemplate | null;
+    aliases: readonly string[];
+    requiredSections: readonly RequiredSection[];
+    tex: TexRequirements;
+    format: VenueFormat;
+    rules: Readonly<Record<string, unknown>>;
+  } = {
+    name: null,
+    template: null,
+    aliases: [],
+    requiredSections: [],
     tex: NO_REQUIREMENTS,
     format: NO_FORMAT,
-    rules: {} as Readonly<Record<string, unknown>>,
+    rules: {},
   };
   const m = rootFirst.reduce(
-    (acc, p) => ({
+    (acc, { preset: p, file }) => ({
       name: p.name ?? acc.name,
-      template: p.template ?? acc.template,
+      template: p.template === null ? acc.template : { text: p.template, file },
+      aliases: [
+        ...new Set([
+          ...acc.aliases,
+          ...(p.name === null ? [] : [p.name]),
+          ...p.aliases,
+        ]),
+      ],
+      requiredSections: p.requiredSections ?? acc.requiredSections,
       tex: p.tex ? mergeRequirements(acc.tex, p.tex) : acc.tex,
       format: mergeFormat(acc.format, p.format),
       rules: { ...acc.rules, ...p.rules },
@@ -201,8 +242,10 @@ function merged(
   );
   return {
     label: m.name ?? labelOf(spec),
-    chain: files,
+    chain: rootFirst.map((x) => x.file),
     template: m.template,
+    aliases: m.aliases,
+    requiredSections: m.requiredSections,
     tex: m.tex,
     format: m.format,
     rules: m.rules,
@@ -224,13 +267,7 @@ export function resolvePreset(
       ? err({ ...chain.error, shipped: shippedPresets(deps.venuesDir) })
       : chain;
   const rootFirst = [...chain.value].reverse();
-  return ok(
-    merged(
-      spec,
-      rootFirst.map((x) => x.preset),
-      rootFirst.map((x) => x.file),
-    ),
-  );
+  return ok(merged(spec, rootFirst));
 }
 
 /** The shipped presets' names (each is spelled `paperlint:<name>`). */

package/src/references.test.ts

@@ -9,10 +9,11 @@
  */
 import { describe, expect, it } from "vitest";
 import { ESLint } from "eslint";
+import { eslintConfig } from "./cli.ts";
 import { join } from "node:path";
 import { memoryFiles } from "./adapters/memory/index.ts";
 import { ok } from "./domain/result.ts";
-import type { AbsolutePath } from "./domain/paths.ts";
+import { absolutePath } from "./domain/paths.ts";
 import type {
   CheckReferences,
   EntryVerdict,
@@ -78,9 +79,13 @@ const offline: CheckReferences = (_bib, cache) =>
 const ctx = (files: ReturnType<typeof memoryFiles>) => ({
   paperDir: PAPER,
   env: {},
-  run: (() => ({})) as never,
-  readPdf: (() => null) as never,
-  measure: (() => null) as never,
+  run: () => ({ status: 0 }),
+  readPdf: () => Promise.reject(new Error("the references step reads no PDF")),
+  measure: {
+    measure: () => {
+      throw new Error("the references step measures nothing");
+    },
+  },
   files,
 });
 
@@ -94,32 +99,26 @@ async function build(tex: string, check: CheckReferences) {
   return { files, out };
 }
 
-/**
- * The rules as an ESLint plugin. Their context type is the narrow one they read (a custom
- * language's SourceCode), which ESLint's JS-centred plugin type does not describe.
- */
-const asPlugin = (rules: object): ESLint.Plugin => ({ rules }) as ESLint.Plugin;
-
 /** Lint `tex` as the paper's paper.tex against what `files` recorded. */
 async function lint(files: ReturnType<typeof memoryFiles>, tex: string) {
   files.writeAtomic(
-    `${PAPER}/paper.tex` as AbsolutePath,
+    absolutePath(`${PAPER}/paper.tex`),
     new TextEncoder().encode(tex),
   );
   const eslint = new ESLint({
     cwd: "/work",
     overrideConfigFile: true,
-    overrideConfig: [
+    overrideConfig: eslintConfig([
       {
         files: ["**/paper.tex"],
         plugins: {
           tex: { languages: { latex: texLanguage } },
-          paper: asPlugin(referenceRules({ files })),
+          paper: { rules: referenceRules({ files }) },
         },
         language: "tex/latex",
         rules: REFERENCE_RULE_LEVELS,
       },
-    ],
+    ]),
   });
   const [res] = await eslint.lintText(tex, {
     filePath: join(PAPER, "paper.tex"),
@@ -186,7 +185,7 @@ function fetching(key: string) {
   return { check, seen };
 }
 const cacheText = (files: ReturnType<typeof memoryFiles>): string | null => {
-  const b = files.readBytes(lookupCachePath(PAPER) as AbsolutePath);
+  const b = files.readBytes(absolutePath(lookupCachePath(PAPER)));
   return b === null ? null : new TextDecoder().decode(b);
 };
 
@@ -363,7 +362,7 @@ const record = (
 ) => {
   const bib = present(bibliographyOf(files, PAPER), "the bibliography");
   files.writeAtomic(
-    referencesPath(PAPER) as AbsolutePath,
+    absolutePath(referencesPath(PAPER)),
     new TextEncoder().encode(
       JSON.stringify({
         schema: 1,
@@ -424,9 +423,16 @@ describe("the reference rules over refs.bib, and on other files", () => {
     const files = memoryFiles({});
     const rules = referenceRules({ files });
     for (const rule of Object.values(rules))
-      expect(rule.create({ filename: `${PAPER}/notes.tex` } as never)).toEqual(
-        {},
-      );
+      expect(
+        rule.create({
+          filename: `${PAPER}/notes.tex`,
+          cwd: "/work",
+          sourceCode: { getLocFromIndex: () => ({ line: 1, column: 0 }) },
+          report: () => {
+            throw new Error("a file that is not paper.tex is never reported");
+          },
+        }),
+      ).toEqual({});
   });
 });