paperlint 3.1.3 → 3.2.0

package/eslint-rules/{paper-typography.mjs → paper-typography.ts}

@@ -59,51 +59,87 @@
  * 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 assert from "node:assert/strict";
 import { getParser } from "@unified-latex/unified-latex-util-parse";
+import type { Nodes } from "mdast";
+import type { TexArg, TexNode, TexRoot } from "./latex-language.ts";
+import type {
+  RuleContext,
+  RuleFixer,
+  RuleReport,
+  RuleSourceCode,
+} from "./rule-context.ts";
+
+/** Where a `.bib` embedded in a `filecontents` environment sits in the file. */
+export interface BibRange {
+  readonly start: number;
+  readonly end: number;
+  readonly bodyStart: number;
+  readonly body: string;
+}
+
+/** The `.tex` language's source code: the one that carries the unprojected file. */
+type TexSourceCode = RuleSourceCode & { readonly raw: string };
+
+/** A run of visible text, and for each of its characters the offset it came from (or null). */
+interface Run {
+  text: string;
+  offs: (number | null)[];
+}
 
 /** The inline bibliography — a `filecontents` block writing a `.bib` — with its offsets. */
-export function bibRange(text) {
+export function bibRange(text: string): BibRange | null {
   const m =
     /\\begin\{filecontents\*?\}(?:\[[^\]]*\])?\{[^}]*\.bib\}\r?\n([\s\S]*?)\\end\{filecontents\*?\}/d.exec(
       text,
     );
   if (!m) return null;
-  return {
-    start: m.index,
-    end: m.index + m[0].length,
-    bodyStart: m.indices[1][0],
-    body: m[1],
-  };
+  const [whole, body] = m;
+  const bodyStart = m.indices?.[1]?.[0];
+  // The `d` flag records every group's indices, and group 1 is not optional.
+  assert.ok(body !== undefined && bodyStart !== undefined, "no .bib body");
+  return { start: m.index, end: m.index + whole.length, bodyStart, body };
 }
 
 /**
  * The ranges a markup rule must not read: LaTeX comments (the language gives them as `html`
  * nodes, with positions) and the inline bibliography.
  */
-function skippedRanges(sourceCode, raw) {
-  const out = [];
+function skippedRanges(
+  sourceCode: RuleSourceCode,
+  raw: string,
+): [number, number][] {
+  const out: [number, number][] = [];
   for (const n of sourceCode.ast?.children ?? [])
-    if (n.type === "html" && n.position)
-      out.push([n.position.start.offset, n.position.end.offset]);
+    if (n.type === "html" && n.position) {
+      // An offset-less point compares as NaN: inside no range, as `undefined` always did.
+      const {
+        start: { offset: s = Number.NaN },
+        end: { offset: e = Number.NaN },
+      } = n.position;
+      out.push([s, e]);
+    }
   const bib = bibRange(raw);
   if (bib) out.push([bib.start, bib.end]);
   return out;
 }
-const inside = (ranges, i) => ranges.some(([s, e]) => i >= s && i < e);
+const inside = (ranges: readonly [number, number][], i: number) =>
+  ranges.some(([s, e]) => i >= s && i < e);
 
 /** Every match of `re` in `raw` outside the skipped ranges. */
-function markupMatches(sourceCode, re) {
+function markupMatches(sourceCode: TexSourceCode, re: RegExp) {
   const raw = sourceCode.raw;
   const skip = skippedRanges(sourceCode, raw);
   return [...raw.matchAll(re)].filter((m) => !inside(skip, m.index));
 }
 
-const isTex = (sourceCode) => typeof sourceCode.raw === "string";
+const isTex = (sourceCode: RuleSourceCode): sourceCode is TexSourceCode =>
+  typeof sourceCode.raw === "string";
 
 // ── the text a READER sees, with the source offset of every character ─────────────────────
 
 /** A run of visible text; `offs[i]` is the source offset of `text[i]`, or null when unknown. */
-const run = () => ({ text: "", offs: [] });
+const run = (): Run => ({ text: "", offs: [] });
 
 // Environments whose body is not typeset as text: code, drawings, the inline bibliography.
 const TEX_HIDDEN_ENV =
@@ -117,7 +153,7 @@ const TEX_LAST_ARG = /^(multicolumn|multirow|textcolor|href)$/;
 const TEX_MATH_HIDDEN =
   /^(label|ref|eqref|autoref|cite|hspace|vspace|hskip|vskip|kern|mkern|mskip|rule|phantom|hphantom|vphantom|color|raisebox|includegraphics)$/;
 
-const mandatory = (macro) =>
+const mandatory = (macro: { readonly args?: readonly TexArg[] }) =>
   (macro.args || []).filter((a) => a.openMark === "{");
 
 /**
@@ -125,15 +161,15 @@ const mandatory = (macro) =>
  * arguments come back as the NEXT SIBLINGS: an optional `[…]` as bare strings, then groups.
  * They are parameters, not prose. Returns the index of the last sibling to skip after `i`.
  */
-function unparsedArgsEnd(nodes, i) {
+/** Whether `n` is a string node whose text passes `test`. */
+const isString = (n: TexNode | undefined, test: (s: string) => boolean) =>
+  n?.type === "string" && test(n.content);
+
+function unparsedArgsEnd(nodes: readonly TexNode[], i: number): number {
   let j = i + 1;
-  if (nodes[j]?.type === "string" && nodes[j].content.startsWith("[")) {
+  if (isString(nodes[j], (c) => c.startsWith("["))) {
     let k = j;
-    while (
-      k < nodes.length &&
-      !(nodes[k].type === "string" && nodes[k].content.endsWith("]"))
-    )
-      k++;
+    while (k < nodes.length && !isString(nodes[k], (c) => c.endsWith("]"))) k++;
     if (k < nodes.length) j = k + 1;
   }
   while (nodes[j]?.type === "group") j++;
@@ -141,13 +177,22 @@ function unparsedArgsEnd(nodes, i) {
 }
 
 /** Append a string node to the current run, keeping each character's offset. */
-function appendString(cur, n, src) {
+function appendString(
+  cur: Run,
+  n: {
+    readonly content: string;
+    readonly position?: { readonly start?: { readonly offset: number } };
+  },
+  src: string,
+) {
   const start = n.position?.start?.offset;
   const exact =
     typeof start === "number" &&
-    src.slice(start, start + n.content.length) === n.content;
+    src.slice(start, start + n.content.length) === n.content
+      ? start
+      : null;
   for (let i = 0; i < n.content.length; i++)
-    cur.offs.push(exact ? start + i : null);
+    cur.offs.push(exact === null ? null : exact + i);
   cur.text += n.content;
 }
 
@@ -156,14 +201,23 @@ function appendString(cur, n, src) {
  * `string` nodes with nothing between them: math splits `.05` into `.`, `0`, `5`, and prose
  * keeps `2310.05736` whole — both come back as one word. Anything else ends the run.
  */
-function texRuns(nodes, math, src, out) {
+/** What stands in for an index past the end: a node every branch below passes over. */
+const NOTHING: TexNode = { type: "whitespace" };
+
+function texRuns(
+  nodes: readonly TexNode[] | undefined,
+  math: boolean,
+  src: string,
+  out: Run[],
+): Run[] {
   let cur = run();
   const flush = () => {
     if (cur.text) out.push(cur);
     cur = run();
   };
-  for (let i = 0; i < (nodes || []).length; i++) {
-    const n = nodes[i];
+  const list = nodes || [];
+  for (let i = 0; i < list.length; i++) {
+    const { [i]: n = NOTHING } = list;
     if (n.type === "string") {
       appendString(cur, n, src);
       continue;
@@ -192,9 +246,9 @@ function texRuns(nodes, math, src, out) {
       } else if (TEX_PROSE_ARG.test(n.content)) {
         for (const a of args) texRuns(a.content, false, src, out);
       } else if (TEX_LAST_ARG.test(n.content) && args.length) {
-        texRuns(args[args.length - 1].content, false, src, out);
+        texRuns(args.at(-1)?.content, false, src, out);
       }
-      if (!math && !(n.args || []).length) i = unparsedArgsEnd(nodes, i);
+      if (!math && !(n.args || []).length) i = unparsedArgsEnd(list, i);
     }
   }
   flush();
@@ -206,13 +260,16 @@ function texRuns(nodes, math, src, out) {
  * with the fields the walk tolerates being absent.
  */
 export function texVisibleRuns(
-  raw,
-  { parse = (s) => getParser().parse(s) } = {},
-) {
+  raw: string,
+  {
+    parse = (s: string): TexRoot => getParser().parse(s),
+  }: { parse?: (s: string) => TexRoot } = {},
+): Run[] {
   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",
+    (n): n is Extract<TexNode, { type: "environment" | "mathenv" }> =>
+      n.type === "environment" && n.env === "document",
   );
   return texRuns(document ? document.content : root, false, raw, []);
 }
@@ -232,8 +289,8 @@ const MD_HIDDEN = new Set([
  * markdown's escapes (`\*`) and character references (`&lt;`) resolved, so the two are walked
  * side by side; a character whose source cannot be followed gets null (reported, not fixed).
  */
-function mdOffsets(value, src, start) {
-  const offs = [];
+function mdOffsets(value: string, src: string, start: number) {
+  const offs: (number | null)[] = [];
   let j = start;
   for (const ch of value) {
     if (src[j] === ch) offs.push(j++);
@@ -251,29 +308,39 @@ function mdOffsets(value, src, start) {
   return offs;
 }
 
-function mdVisibleRuns(node, src, out = []) {
+function mdVisibleRuns(
+  node: Nodes | undefined,
+  src: string,
+  out: Run[] = [],
+): Run[] {
   if (!node || MD_HIDDEN.has(node.type)) return out;
   if (node.type === "text") {
-    const start = node.position?.start?.offset;
+    const start = node.position?.start.offset;
     out.push({
       text: node.value,
       offs:
         typeof start === "number"
           ? mdOffsets(node.value, src, start)
-          : [...node.value].map(() => null),
+          : Array.from(node.value, () => null),
     });
   }
-  for (const c of node.children || []) mdVisibleRuns(c, src, out);
+  for (const c of "children" in node ? node.children : [])
+    mdVisibleRuns(c, src, out);
   return out;
 }
 
-const visibleRuns = (sourceCode) =>
+const visibleRuns = (sourceCode: RuleSourceCode): Run[] =>
   isTex(sourceCode)
     ? texVisibleRuns(sourceCode.raw)
     : mdVisibleRuns(sourceCode.ast, sourceCode.text);
 
 /** A report at `[from, to)` of the file. */
-const at = (context, from, to, rest) => {
+const at = (
+  context: RuleContext,
+  from: number,
+  to: number,
+  rest: Omit<RuleReport, "loc" | "node">,
+) => {
   const sc = context.sourceCode;
   context.report({
     loc: { start: sc.getLocFromIndex(from), end: sc.getLocFromIndex(to) },
@@ -288,14 +355,14 @@ const at = (context, from, to, rest) => {
 const SECTION_TEX = /(§|\\S(?![A-Za-z]))(~|[ \t]*)(?=(\\(?:auto)?ref\b)|(\d))/g;
 const SECTION_GLYPH = /§/g;
 
-function sectionWord(context) {
+function sectionWord(context: RuleContext) {
   const sc = context.sourceCode;
   if (isTex(sc)) {
     const seen = new Set();
     for (const m of markupMatches(sc, SECTION_TEX)) {
       seen.add(m.index);
       const word = m[3] ? "Section~" : "Section ";
-      const range = [m.index, m.index + m[0].length];
+      const range: [number, number] = [m.index, m.index + m[0].length];
       at(context, range[0], range[1], {
         messageId: "sign",
         fix: (f) => f.replaceTextRange(range, word),
@@ -313,7 +380,8 @@ function sectionWord(context) {
       const from = r.offs[m.index];
       if (from === null || from === undefined) continue;
       // The sign and the space after it; the number stays.
-      const range = [from, from + 1 + m[1].length];
+      const [, gap = ""] = m;
+      const range: [number, number] = [from, from + 1 + gap.length];
       at(context, range[0], range[1], {
         messageId: "sign",
         ...(m[2] ? { fix: (f) => f.replaceTextRange(range, "Section ") } : {}),
@@ -334,13 +402,13 @@ 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 paragraphBefore = (src: string, i: number) => {
   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) {
+function leadingZero(context: RuleContext) {
   const sc = context.sourceCode;
   const src = isTex(sc) ? sc.raw : sc.text;
   for (const r of visibleRuns(sc))
@@ -349,7 +417,7 @@ function leadingZero(context) {
       if (dot === null || dot === undefined) continue;
       const before = paragraphBefore(src, dot);
       if (DESIGNATOR_BEFORE.test(before)) continue;
-      const zero = (f) => f.insertTextBeforeRange([dot, dot], "0");
+      const zero = (f: RuleFixer) => f.insertTextBeforeRange([dot, dot], "0");
       at(
         context,
         dot,
@@ -371,7 +439,7 @@ function leadingZero(context) {
 
 const FIG_REF = /\b(Fig\.|Figure)(?=~?\\(?:ref|autoref)\b)/g;
 
-function figureRefStyle(context) {
+function figureRefStyle(context: RuleContext) {
   const sc = context.sourceCode;
   if (!isTex(sc)) return;
   const all = markupMatches(sc, FIG_REF);
@@ -382,16 +450,22 @@ function figureRefStyle(context) {
   const [minority, word] =
     short.length > long.length ? [long, "Fig."] : [short, "Figure"];
   for (const m of minority) {
-    const range = [m.index, m.index + m[1].length];
+    const [, form = ""] = m;
+    const range: [number, number] = [m.index, m.index + form.length];
     at(context, range[0], range[1], {
       messageId: "mixed",
-      data: { form: m[1], word, n: String(all.length - minority.length) },
+      data: { form, word, n: String(all.length - minority.length) },
       fix: (f) => f.replaceTextRange(range, word),
     });
   }
 }
 
-const rule = (description, messages, check, meta = {}) => ({
+const rule = (
+  description: string,
+  messages: Readonly<Record<string, string>>,
+  check: (context: RuleContext) => void,
+  meta: { readonly hasSuggestions?: boolean } = {},
+) => ({
   meta: {
     type: "suggestion",
     fixable: "code",
@@ -400,7 +474,11 @@ const rule = (description, messages, check, meta = {}) => ({
     messages,
     ...meta,
   },
-  create: (context) => ({ "root:exit": () => check(context) }),
+  create: (context: RuleContext) => ({
+    "root:exit": () => {
+      check(context);
+    },
+  }),
 });
 
 export default {

package/eslint-rules/papers.harness.mjs

@@ -17,7 +17,7 @@
  * not throw" as success; an exported `tests` object is run by nothing.
  */
 import assert from "node:assert/strict";
-import { PAPERS_DIR_FIELD } from "../lib/paper-config.mjs";
+import { PAPERS_DIR_FIELD } from "../lib/paper-config.ts";
 import {
   mkdirSync,
   mkdtempSync,
@@ -31,7 +31,7 @@ import { tmpdir } from "node:os";
 import { dirname, isAbsolute, join } from "node:path";
 import { fileURLToPath } from "node:url";
 
-import { DEFAULT_PAPERS_ROOT, paperFiles, papersRoot } from "./papers.mjs";
+import { DEFAULT_PAPERS_ROOT, paperFiles, papersRoot } from "./papers.ts";
 
 const HERE = dirname(fileURLToPath(import.meta.url));
 const ROOT = join(HERE, "..");

package/eslint-rules/{papers.mjs → papers.ts}

@@ -82,7 +82,7 @@ import {
   DEFAULT_PAPERS_ROOT,
   PAPERS_DIR_FIELD,
   CONFIG_FILE,
-} from "../lib/paper-config.mjs";
+} from "../lib/paper-config.ts";
 export { DEFAULT_PAPERS_ROOT };
 
 /**
@@ -98,7 +98,10 @@ export { DEFAULT_PAPERS_ROOT };
  *          globs, which ESLint interprets relative to the config, and an absolute path there
  *          would change their meaning.
  */
-export function papersRoot(settings, baseDir = process.cwd()) {
+export function papersRoot(
+  settings: Readonly<Record<string, unknown>> | null | undefined,
+  baseDir: string = process.cwd(),
+): string {
   const declared = settings?.[PAPERS_DIR_FIELD];
   // 🔴 `declared === undefined`, NOT `declared ?? DEFAULT`. The two differ on exactly one
   // input — `"papersDir": null` — and the difference is the whole point: `??` reads an explicit
@@ -118,7 +121,7 @@ export function papersRoot(settings, baseDir = process.cwd()) {
           ? `Nothing was declared, so the default "${DEFAULT_PAPERS_ROOT}" was used. Declare the ` +
             `real location in ${CONFIG_FILE}:\n` +
             `  { "${PAPERS_DIR_FIELD}": "path/to/papers" }`
-          : `It is declared in ${CONFIG_FILE} as "${declared}". Fix it there, or create the ` +
+          : `It is declared in ${CONFIG_FILE} as "${root}". Fix it there, or create the ` +
             `directory.`) +
         `\nThis is thrown rather than ignored on purpose: a papers root that matches nothing ` +
         `makes every rule lint zero files, and a run with zero findings is indistinguishable ` +
@@ -136,7 +139,7 @@ export function papersRoot(settings, baseDir = process.cwd()) {
  * with the rule, in the same package, rather than as a line every consumer has to add by hand
  * to keep up. A hand-maintained list of paths is the thing that rots, and rots silently.
  */
-export function paperFiles(root) {
+export function paperFiles(root: string) {
   return {
     /** Markdown drafts — the two names a paper's prose is allowed to have. */
     md: [`${root}/*/paper.md`, `${root}/*/draft.md`],

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

@@ -23,12 +23,12 @@ import { tmpdir } from "node:os";
 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";
+import { texLanguage } from "./latex-language.ts";
+import { createChecker } from "../lib/check.ts";
 
 const HERE = dirname(fileURLToPath(import.meta.url));
 const { parseFacts, judgeColumns, DEFAULT_TOLERANCE_PT } = await import(
-  join(HERE, "pdf-last-page-balance.mjs")
+  join(HERE, "pdf-last-page-balance.ts")
 );
 const { buildConfig } = await import(join(HERE, "..", "src", "cli.ts"));
 

package/eslint-rules/{pdf-last-page-balance.mjs → pdf-last-page-balance.ts}

@@ -35,7 +35,58 @@
 import { createHash } from "node:crypto";
 import { existsSync, readFileSync } from "node:fs";
 import { basename, dirname, isAbsolute, join } from "node:path";
-import { CONFIG_FILE } from "../lib/paper-config.mjs";
+import assert from "node:assert/strict";
+import { z } from "zod";
+import { CONFIG_FILE } from "../lib/paper-config.ts";
+import type { RuleContext } from "./rule-context.ts";
+
+/** A reason to report, in ESLint's terms. */
+export interface Finding {
+  readonly messageId: string;
+  readonly data: Readonly<Record<string, string>>;
+}
+
+/** The `last_page` field, as far as this rule can judge it. */
+export type LastPage =
+  | { readonly kind: "stub" | "review" }
+  | {
+      readonly kind: "measured";
+      readonly left: number;
+      readonly right: number;
+    };
+
+/** What `parseFacts` reads out of `paper.facts.json`, or why it cannot. */
+export type ParsedFacts =
+  | {
+      readonly ok: true;
+      readonly pdf: string;
+      /** Whatever the file holds there; it matched the digest pattern, and is compared as-is. */
+      readonly sha: unknown;
+      readonly last: LastPage;
+    }
+  | ({ readonly ok: false } & Finding);
+
+// The fields read, each as it is written; anything that is not a mapping has none of them.
+const FactsFields = z
+  .looseObject({
+    schema: z.unknown().optional(),
+    pdf: z.unknown().optional(),
+    pdf_sha256: z.unknown().optional(),
+    last_page: z.unknown().optional(),
+  })
+  .catch({});
+const LastPageFields = z
+  .looseObject({
+    kind: z.unknown().optional(),
+    columns_pt: z.unknown().optional(),
+  })
+  .catch({});
+/** Two column heights: finite numbers, exactly two of them. */
+const Columns = z.tuple([z.number(), z.number()]);
+const Settings = z.looseObject({ extends: z.unknown().optional() }).catch({});
+const RuleOptions = z
+  .object({ tolerancePt: z.number().optional() })
+  .default({});
 
 /** The difference, in points, that two columns may end apart. See the harness for why 120. */
 export const DEFAULT_TOLERANCE_PT = 120;
@@ -43,44 +94,40 @@ export const DEFAULT_TOLERANCE_PT = 120;
 export const FACTS_SCHEMA = 2;
 export const FACTS_REL = join("_build", "paper.facts.json");
 
-const isHeight = (x) => typeof x === "number" && Number.isFinite(x);
-
 /** The `last_page` field, parsed. */
-function lastPageOf(v) {
-  if (v?.kind === "stub" || v?.kind === "review") return { kind: v.kind };
-  const c = v?.columns_pt;
-  if (
-    v?.kind === "measured" &&
-    Array.isArray(c) &&
-    c.length === 2 &&
-    c.every(isHeight)
-  )
-    return { kind: "measured", left: c[0], right: c[1] };
+function lastPageOf(v: unknown): LastPage | null {
+  const { kind, columns_pt } = LastPageFields.parse(v);
+  if (kind === "stub" || kind === "review") return { kind };
+  const c = Columns.safeParse(columns_pt);
+  if (kind === "measured" && c.success)
+    return { kind: "measured", left: c.data[0], right: c.data[1] };
   return null;
 }
 
 /**
  * The facts file's text → what this rule needs, or the reason it cannot be judged. Pure.
- *
- * @returns {{ ok: true, pdf: string, sha: string, last: object } | { ok: false, messageId: string, data: object }}
  */
-export function parseFacts(text) {
-  let d;
+export function parseFacts(text: string): ParsedFacts {
+  let raw: unknown;
   try {
-    d = JSON.parse(text);
+    raw = JSON.parse(text);
   } catch (e) {
+    // `JSON.parse` throws a `SyntaxError` and nothing else.
+    assert.ok(e instanceof Error);
     return { ok: false, messageId: "factsBroken", data: { why: e.message } };
   }
-  if (d?.schema !== FACTS_SCHEMA)
+  const d = FactsFields.parse(raw);
+  if (d.schema !== FACTS_SCHEMA)
     return {
       ok: false,
       messageId: "schema",
-      data: { got: JSON.stringify(d?.schema ?? null) },
+      data: { got: JSON.stringify(d.schema ?? null) },
     };
   const last = lastPageOf(d.last_page);
   if (
     typeof d.pdf !== "string" ||
-    !/^[0-9a-f]{64}$/.test(d.pdf_sha256 ?? "") ||
+    typeof d.pdf_sha256 !== "string" ||
+    !/^[0-9a-f]{64}$/.test(d.pdf_sha256) ||
     !last
   )
     return {
@@ -94,9 +141,12 @@ export function parseFacts(text) {
 }
 
 /** Whether the facts describe the PDF on disk: null when they do, else the reason. */
-function staleness(paperDir, facts) {
+function staleness(
+  paperDir: string,
+  facts: { readonly pdf: string; readonly sha: unknown },
+): Finding | null {
   const pdf = isAbsolute(facts.pdf) ? facts.pdf : join(paperDir, facts.pdf);
-  let got;
+  let got: string;
   try {
     got = createHash("sha256").update(readFileSync(pdf)).digest("hex");
   } catch {
@@ -108,7 +158,10 @@ function staleness(paperDir, facts) {
 }
 
 /** The finding for a measured page, or null when it is balanced. Pure. */
-export function judgeColumns(last, tolerancePt) {
+export function judgeColumns(
+  last: LastPage,
+  tolerancePt: number,
+): Finding | null {
   if (last.kind !== "measured") return null;
   const diff = Math.abs(last.left - last.right);
   if (diff <= tolerancePt) return null;
@@ -124,7 +177,7 @@ export function judgeColumns(last, tolerancePt) {
 }
 
 /** Where a finding goes: the `\documentclass` line, where the class options that fix it live. */
-function reportLine(file) {
+function reportLine(file: string): number {
   try {
     const lines = readFileSync(file, "utf8").split("\n");
     const i = lines.findIndex((l) => /^\s*\\documentclass\b/.test(l));
@@ -140,17 +193,19 @@ function reportLine(file) {
  * repeating it as an error would fail a lint-only CI for every paper of a venue whose preset turns
  * this rule on.
  */
-function extendsPreset(paperDir) {
+function extendsPreset(paperDir: string): boolean {
   try {
-    const s = JSON.parse(readFileSync(join(paperDir, CONFIG_FILE), "utf8"));
-    return typeof s?.extends === "string" && s.extends !== "";
+    const s = Settings.parse(
+      JSON.parse(readFileSync(join(paperDir, CONFIG_FILE), "utf8")),
+    );
+    return typeof s.extends === "string" && s.extends !== "";
   } catch {
     return false;
   }
 }
 
 /** Everything the rule decides for one paper, as a finding or null. */
-function verdict(paperDir, tolerancePt) {
+function verdict(paperDir: string, tolerancePt: number): Finding | null {
   const factsFile = join(paperDir, FACTS_REL);
   if (!existsSync(factsFile))
     return extendsPreset(paperDir)
@@ -204,10 +259,12 @@ const rule = {
         "differs), so judging it would judge an earlier build — rebuild the paper",
     },
   },
-  create(context) {
+  create(context: RuleContext) {
     // Judged once per paper, on its paper.tex: the paper directory is the file's directory.
     if (basename(context.filename) !== "paper.tex") return {};
-    const tolerancePt = context.options[0]?.tolerancePt ?? DEFAULT_TOLERANCE_PT;
+    const { tolerancePt = DEFAULT_TOLERANCE_PT } = RuleOptions.parse(
+      context.options[0],
+    );
     return {
       root() {
         const v = verdict(dirname(context.filename), tolerancePt);

package/eslint-rules/review-frontmatter.test.mjs

@@ -5,8 +5,8 @@
 import { describe, expect, it } from "vitest";
 import { ESLint } from "eslint";
 import markdown from "@eslint/markdown";
-import review, { errorsOf } from "./review-frontmatter.mjs";
-import sibling from "./sibling-frontmatter.mjs";
+import review, { errorsOf } from "./review-frontmatter.ts";
+import sibling from "./sibling-frontmatter.ts";
 
 async function lint(text) {
   const eslint = new ESLint({