paperlint 3.1.3 → 3.2.0

package/src/paper-settings.ts

@@ -21,7 +21,7 @@ import {
   ROOT_ONLY_KEYS,
   SETTINGS_KEYS,
   findProjectRoot,
-} from "../lib/paper-config.mjs";
+} from "#lib/paper-config";
 import type { AbsolutePath } from "./domain/paths.ts";
 import { err, ok, type Result } from "./domain/result.ts";
 import type { Files } from "./ports/files.ts";
@@ -30,6 +30,7 @@ import {
   type Parsed,
   type RuleEntry,
 } from "./rules-config.ts";
+import { messageOf } from "./domain/text.ts";
 
 /** What one paper declares. Every absent field is null. */
 export interface PaperSettings {
@@ -92,11 +93,13 @@ export function parsePaperSettings(
   if (!isObject(json)) return err("must be a JSON object");
   const unknown = Object.keys(json).filter((k) => !KNOWN.includes(k));
   if (unknown.length > 0)
-    return err(`unknown key "${unknown[0]}" — known keys: ${KNOWN.join(", ")}`);
+    return err(
+      `unknown key "${String(unknown[0])}" — known keys: ${KNOWN.join(", ")}`,
+    );
   const project = Object.keys(json).filter((k) => ROOT_ONLY_KEYS.includes(k));
   if (project.length > 0)
     return err(
-      `"${project[0]}" is a project setting — set it in the root ${CONFIG_FILE}, not in a paper's`,
+      `"${String(project[0])}" is a project setting — set it in the root ${CONFIG_FILE}, not in a paper's`,
     );
   const fields = stringFields(json);
   if (!fields.ok) return fields;
@@ -123,7 +126,7 @@ function readJson(
   try {
     return ok(JSON.parse(new TextDecoder().decode(bytes)));
   } catch (e) {
-    return err({ kind: "broken", why: `not JSON (${(e as Error).message})` });
+    return err({ kind: "broken", why: `not JSON (${messageOf(e)})` });
   }
 }
 
@@ -200,9 +203,5 @@ export function paperRules(
   if (settings.rules === null || Array.isArray(settings.rules))
     return { ok: true, value: null };
   const where = `${join(paperDir, CONFIG_FILE)} → "rules"`;
-  return parseRuleEntries(
-    settings.rules as Readonly<Record<string, unknown>>,
-    where,
-    shipped,
-  );
+  return parseRuleEntries(settings.rules, where, shipped);
 }

package/src/{pdf-facts.harness.mjs → pdf-facts.harness.ts}

@@ -1,7 +1,7 @@
 /**
  * `pdf-facts.ts` — pdf.js reading REAL PDFs, committed under `fixtures/pdf-facts/`.
  *
- * The pure decisions are tested in `pdf-geometry.harness.mjs` with hand-written words. This file is
+ * The pure decisions are tested in `pdf-geometry.harness.ts` with hand-written words. This file is
  * the other half: that the shell asks pdf.js the right questions, with the right options, and maps
  * what comes back. The expected numbers are the ones poppler reported for the same files in the
  * 2026-09-24 measurement (issue #61), so a pass here is agreement with the tool this replaced.
@@ -11,23 +11,24 @@ import { writeFileSync, mkdtempSync, realpathSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { createChecker } from "../lib/check.mjs";
+import { createChecker } from "../lib/check.ts";
+import type { PdfFacts } from "./pdf-facts.ts";
 
 const HERE = dirname(fileURLToPath(import.meta.url));
 const FIX = resolve(HERE, "..", "fixtures", "pdf-facts");
-const { readPdf } = await import(join(HERE, "pdf-facts.ts"));
-const { classifyLastPage } = await import(join(HERE, "pdf-geometry.ts"));
+const { readPdf } = await import("./pdf-facts.ts");
+const { classifyLastPage } = await import("./pdf-geometry.ts");
 
 const check = createChecker();
 
-const read = async (name) => {
+const read = async (name: string): Promise<PdfFacts> => {
   const r = await readPdf(join(FIX, name));
   assert.ok(r.ok, `${name} must read: ${JSON.stringify(r)}`);
   return r.facts;
 };
-const kinds = (facts) =>
+const kinds = (facts: PdfFacts): string[] =>
   facts.fonts.kind === "drawn" ? facts.fonts.list.map((f) => f.kind) : [];
-const named = (facts, name) =>
+const named = (facts: PdfFacts, name: string) =>
   facts.fonts.kind === "drawn"
     ? facts.fonts.list.find((f) => f.name === name)
     : undefined;
@@ -139,7 +140,7 @@ try {
   const boxes = f.layout.flatMap((p, i) =>
     p.boxes.map((b) => ({ ...b, page: i + 1 })),
   );
-  const chars = (pred) =>
+  const chars = (pred: (b: (typeof boxes)[number]) => boolean) =>
     boxes.filter(pred).reduce((sum, b) => sum + b.text.length, 0);
   check(
     "hidden-text: one layout per page, each US letter",

package/src/pdf-facts.test.ts

@@ -8,6 +8,7 @@ import assert from "node:assert/strict";
 import { getResolvedPDFJS } from "unpdf";
 import { test } from "vitest";
 import { factsOf, failureOf, rawFontOf } from "./pdf-facts.ts";
+import { present } from "../test/support.ts";
 
 const lib = await getResolvedPDFJS();
 const H = 792;
@@ -23,8 +24,8 @@ interface FakeItem {
 function page(items: FakeItem[], fonts: Record<string, unknown>) {
   const objs = new Map(Object.entries(fonts));
   return {
-    getOperatorList: async () => ({ fnArray: [], argsArray: [] }),
-    getTextContent: async () => ({ items }),
+    getOperatorList: () => Promise.resolve({ fnArray: [], argsArray: [] }),
+    getTextContent: () => Promise.resolve({ items }),
     // Iterable like pdf.js's `commonObjs`, with its `has`/`get`.
     commonObjs: {
       has: (id: string) => objs.has(id),
@@ -42,7 +43,7 @@ function page(items: FakeItem[], fonts: Record<string, unknown>) {
 const doc = (pages: ReturnType<typeof page>[]) =>
   ({
     numPages: pages.length,
-    getPage: async (i: number) => pages[i - 1],
+    getPage: (i: number) => Promise.resolve(pages[i - 1]),
   }) as never;
 const item = (
   fontName: string,
@@ -89,7 +90,7 @@ test("a document with no pages is `empty`; text drawn with no font is refused",
     lib,
   );
   assert.equal(r.ok, false);
-  assert.equal(!r.ok && r.reason, "zero-fonts-on-text");
+  assert.equal(r.reason, "zero-fonts-on-text");
 });
 
 test("metrics, sizes and names fall back when pdf.js gives none", async () => {
@@ -117,7 +118,7 @@ test("metrics, sizes and names fall back when pdf.js gives none", async () => {
     lib,
   );
   assert.equal(r.ok, true);
-  const boxes = r.ok ? r.facts.layout[0]!.boxes : [];
+  const boxes = present(r.facts.layout[0], "a first page").boxes;
   assert.deepEqual(
     boxes.map((b) => [b.font, b.size, b.fill]),
     [
@@ -127,12 +128,10 @@ test("metrics, sizes and names fall back when pdf.js gives none", async () => {
       ["gone", 10, { kind: "unknown" }],
     ],
   );
-  assert.deepEqual(r.ok ? r.facts.last.words.map((w) => w.text) : [], [
-    "word",
-    "word",
-    "word",
-    "word",
-  ]);
+  assert.deepEqual(
+    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", () => {

package/src/pdf-facts.ts

@@ -34,6 +34,7 @@ import {
 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";
 
 type PdfJs = Awaited<ReturnType<typeof import("unpdf").getResolvedPDFJS>>;
 type Doc = Awaited<ReturnType<PdfJs["getDocument"]>["promise"]>;
@@ -303,7 +304,7 @@ export const readPdf: PdfReader = async (path) => {
   try {
     data = new Uint8Array(readFileSync(path));
   } catch (e) {
-    return fail("unreadable", (e as Error).message);
+    return fail("unreadable", messageOf(e));
   }
   const lib = await loadPdfJs();
   const task = lib.getDocument({ data, ...PDFJS_OPTIONS });

package/src/{pdf-geometry.harness.mjs → pdf-geometry.harness.ts}

@@ -6,11 +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 { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-import { createChecker } from "../lib/check.mjs";
+import { createChecker } from "../lib/check.ts";
+import type { RawFont } from "./pdf-geometry.ts";
 
-const HERE = dirname(fileURLToPath(import.meta.url));
 const {
   classifyLastPage,
   wordsOf,
@@ -19,14 +17,23 @@ const {
   programOf,
   popplerType,
   STUB_WORDS,
-} = await import(join(HERE, "pdf-geometry.ts"));
+} = await import("./pdf-geometry.ts");
 
 const check = createChecker();
 
+/** A row of stacked words: `n` of them from `top` downwards, `step` apart. */
+interface Row {
+  x: number;
+  top: number;
+  n?: number;
+  step?: number;
+  text?: string;
+}
+
 const W = 612; // US letter, points
 
 /** Words from rows `{x, top, n, step, text}`: `n` words stacked downwards, each 10 pt tall. */
-const words = (rows) =>
+const words = (rows: readonly Row[]) =>
   rows.flatMap(({ x, top, n: count = 1, step = 10, text = "word" }) =>
     Array.from({ length: count }, (_, i) => ({
       x0: x,
@@ -36,7 +43,7 @@ const words = (rows) =>
       text,
     })),
   );
-const page = (rows, widthPt = W) => ({
+const page = (rows: readonly Row[], widthPt = W) => ({
   widthPt,
   heightPt: 792,
   words: words(rows),
@@ -164,19 +171,19 @@ check(
   check(
     "a run splits at whitespace into words with proportional x",
     ws.length === 2 &&
-      ws[0].text === "ab" &&
+      ws[0]?.text === "ab" &&
       ws[0].x0 === 100 &&
       ws[0].x1 === 120 &&
-      ws[1].x0 === 140,
+      ws[1]?.x0 === 140,
   );
   check(
     "a word spans ascent above the baseline to descent below it",
-    ws[0].y0 === 192 && ws[0].y1 === 202,
+    ws[0]?.y0 === 192 && ws[0].y1 === 202,
   );
 }
 
 // ── fonts ───────────────────────────────────────────────────────────────────────────────
-const font = (over) => ({
+const font = (over: Partial<RawFont>): RawFont => ({
   id: "f1",
   name: "ABCDEF+LinLibertineT",
   type: "Type1",
@@ -227,7 +234,7 @@ check(
   ]);
   check(
     "fonts: each font once, in the order pages first drew them",
-    r.kind === "drawn" && r.list.length === 2 && r.list[1].name === "B",
+    r.kind === "drawn" && r.list.length === 2 && r.list[1]?.name === "B",
   );
 }
 {

package/src/pdf-geometry.ts

@@ -89,7 +89,9 @@ function isLineNumber(w: Word, widthPt: number): boolean {
  */
 export function classifyLastPage(p: PageText): LastPage {
   if (!(p.widthPt > 0))
-    throw new RangeError(`page width must be positive, got ${p.widthPt}`);
+    throw new RangeError(
+      `page width must be positive, got ${String(p.widthPt)}`,
+    );
   if (p.words.length < STUB_WORDS)
     return { kind: "stub", words: p.words.length };
   const lineNumbers = p.words.filter((w) => isLineNumber(w, p.widthPt)).length;

package/src/presets.ts

@@ -47,7 +47,8 @@ import {
   type PaperSettings,
   type SettingsProblem,
 } from "./paper-settings.ts";
-import { CONFIG_FILE } from "../lib/paper-config.mjs";
+import { CONFIG_FILE } from "#lib/paper-config";
+import { messageOf } from "./domain/text.ts";
 
 /** The prefix of a shipped preset's spec. */
 export const SHIPPED_PREFIX = "paperlint:";
@@ -132,7 +133,7 @@ function readPreset(
     return err({
       kind: "broken",
       file: where.value,
-      why: (e as Error).message.split("\n").join(" "),
+      why: messageOf(e).split("\n").join(" "),
     });
   }
 }

package/src/references.test.ts

@@ -32,8 +32,8 @@ import {
   type LookupCache,
 } from "./domain/lookup-cache.ts";
 import { referenceRules, REFERENCE_RULE_LEVELS } from "./reference-rules.ts";
-// @ts-expect-error — an ESLint language in .mjs, it has no types
-import { texLanguage } from "../eslint-rules/latex-language.mjs";
+import { texLanguage } from "../eslint-rules/latex-language.ts";
+import { present } from "../test/support.ts";
 
 const PAPER = "/work/papers/p";
 const TEX = (entries: string) =>
@@ -63,14 +63,16 @@ const verdict = (
 
 const checker =
   (entries: readonly EntryVerdict[]): CheckReferences =>
-  async (_bib, cache) => ({ check: { kind: "checked", entries }, cache });
-const offline: CheckReferences = async (_bib, cache) => ({
-  check: {
-    kind: "not-checked",
-    why: "the citation services cannot be reached (fetch failed)",
-  },
-  cache,
-});
+  (_bib, cache) =>
+    Promise.resolve({ check: { kind: "checked", entries }, cache });
+const offline: CheckReferences = (_bib, cache) =>
+  Promise.resolve({
+    check: {
+      kind: "not-checked",
+      why: "the citation services cannot be reached (fetch failed)",
+    },
+    cache,
+  });
 
 /** The step's context over `files`, with every port it does not use stubbed. */
 const ctx = (files: ReturnType<typeof memoryFiles>) => ({
@@ -122,7 +124,7 @@ async function lint(files: ReturnType<typeof memoryFiles>, tex: string) {
   const [res] = await eslint.lintText(tex, {
     filePath: join(PAPER, "paper.tex"),
   });
-  return res!.messages;
+  return present(res, "one lint result").messages;
 }
 
 describe("the references build step", () => {
@@ -135,7 +137,9 @@ describe("the references build step", () => {
     expect(out.ok).toBe(true);
     const doc = readReferences(files, PAPER);
     expect(doc?.status).toBe("checked");
-    expect(doc?.bib.sha256).toBe(bibHash(bibliographyOf(files, PAPER)!));
+    expect(doc?.bib.sha256).toBe(
+      bibHash(present(bibliographyOf(files, PAPER), "the bibliography")),
+    );
     expect(await lint(files, tex)).toEqual([]);
   });
 
@@ -148,13 +152,13 @@ describe("the references build step", () => {
     expect(msgs.map((m) => [m.ruleId, m.severity])).toEqual([
       ["paper/refs-checked", 1],
     ]);
-    expect(msgs[0]!.message).toMatch(/cannot be reached/);
+    expect(msgs[0]?.message).toMatch(/cannot be reached/);
   });
 
   it("a checker that throws is recorded as not checked, not as a failed build", async () => {
-    const { files, out } = await build(TEX(ENTRIES), async () => {
-      throw new Error("DBLP exploded");
-    });
+    const { files, out } = await build(TEX(ENTRIES), () =>
+      Promise.reject(new Error("DBLP exploded")),
+    );
     expect(out.ok).toBe(true);
     expect(readReferences(files, PAPER)?.why).toMatch(/DBLP exploded/);
   });
@@ -167,9 +171,9 @@ const ANSWER: CachedResponse = {
 /** A checker that fetches `key` unless the cache has it, recording the cache it was handed. */
 function fetching(key: string) {
   const seen: LookupCache[] = [];
-  const check: CheckReferences = async (_bib, cache) => {
+  const check: CheckReferences = (_bib, cache) => {
     seen.push(cache);
-    return {
+    return Promise.resolve({
       check: { kind: "checked", entries: [verdict("schick2023")] },
       cache: cache.citations.has(key)
         ? cache
@@ -177,7 +181,7 @@ function fetching(key: string) {
             citations: new Map([...cache.citations, [key, ANSWER]]),
             dblp: cache.dblp,
           },
-    };
+    });
   };
   return { check, seen };
 }
@@ -210,23 +214,26 @@ describe("the lookup cache — <paper>/repro/references-cache.json", () => {
       note: "references: 1 checked, 0 failing → _build/references.json; nothing fetched",
     });
     // The second build was handed exactly what the first one wrote.
-    expect(parseLookupCache(written!)).toEqual(ok(f.seen[1]));
+    expect(parseLookupCache(present(written, "the written cache"))).toEqual(
+      ok(f.seen[1]),
+    );
     expect(cacheText(files)).toBe(written);
   });
 });
 
 describe("the lookup cache — counting and refusing", () => {
   it("two new answers are counted as two", async () => {
-    const two: CheckReferences = async (_bib, cache) => ({
-      check: { kind: "checked", entries: [verdict("schick2023")] },
-      cache: {
-        citations: new Map([
-          ["a", ANSWER],
-          ["b", ANSWER],
-        ]),
-        dblp: cache.dblp,
-      },
-    });
+    const two: CheckReferences = (_bib, cache) =>
+      Promise.resolve({
+        check: { kind: "checked", entries: [verdict("schick2023")] },
+        cache: {
+          citations: new Map([
+            ["a", ANSWER],
+            ["b", ANSWER],
+          ]),
+          dblp: cache.dblp,
+        },
+      });
     const { out } = await build(TEX(ENTRIES), two);
     expect(out).toEqual({
       ok: true,
@@ -271,8 +278,8 @@ describe("the reference rules", () => {
     );
     const msgs = await lint(files, tex);
     expect(msgs.map((m) => m.ruleId)).toEqual(["paper/author-list"]);
-    expect(msgs[0]!.line).toBe(3);
-    expect(msgs[0]!.message).toMatch(/`schick2023`.*missing hambro/);
+    expect(msgs[0]?.line).toBe(3);
+    expect(msgs[0]?.message).toMatch(/`schick2023`.*missing hambro/);
   });
 
   it("an identifier that provably fails → paper/cite-exists on that entry", async () => {
@@ -311,7 +318,7 @@ describe("the reference rules", () => {
     const files = memoryFiles({});
     const msgs = await lint(files, TEX(ENTRIES));
     expect(msgs.map((m) => m.ruleId)).toEqual(["paper/refs-checked"]);
-    expect(msgs[0]!.message).toMatch(/npx paperlint build/);
+    expect(msgs[0]?.message).toMatch(/npx paperlint build/);
   });
 
   it("a paper with no bibliography gets nothing", async () => {
@@ -354,7 +361,7 @@ const record = (
   files: ReturnType<typeof memoryFiles>,
   body: Record<string, unknown>,
 ) => {
-  const bib = bibliographyOf(files, PAPER)!;
+  const bib = present(bibliographyOf(files, PAPER), "the bibliography");
   files.writeAtomic(
     referencesPath(PAPER) as AbsolutePath,
     new TextEncoder().encode(
@@ -374,7 +381,7 @@ describe("the reference rules over a record written by hand", () => {
     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/);
+    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 () => {
@@ -410,7 +417,7 @@ describe("the reference rules over refs.bib, and on other files", () => {
     expect(msgs.map((m) => [m.ruleId, m.line])).toEqual([
       ["paper/author-list", 1],
     ]);
-    expect(msgs[0]!.message).toMatch(/schick2023/);
+    expect(msgs[0]?.message).toMatch(/schick2023/);
   });
 
   it("only paper.tex is judged", () => {
@@ -430,13 +437,14 @@ describe("the lookup cache — refreshed answers", () => {
     const OLD: CachedResponse = { ...ANSWER, fetched: "2026-08-01" };
     const put =
       (answer: CachedResponse): CheckReferences =>
-      async (_bib, cache) => ({
-        check: { kind: "checked", entries: [verdict("schick2023")] },
-        cache: {
-          citations: new Map([...cache.citations, ["a", answer]]),
-          dblp: cache.dblp,
-        },
-      });
+      (_bib, cache) =>
+        Promise.resolve({
+          check: { kind: "checked", entries: [verdict("schick2023")] },
+          cache: {
+            citations: new Map([...cache.citations, ["a", answer]]),
+            dblp: cache.dblp,
+          },
+        });
     const { files } = await build(TEX(ENTRIES), put(OLD));
     const again = await referencesStep.run({
       ...ctx(files),

package/src/references.ts

@@ -44,8 +44,8 @@ import type {
   ReferencesCheck,
   ReferencesRun,
 } from "./ports/check-references.ts";
-// @ts-expect-error — an ESLint rule module in .mjs, it has no types
-import { bibRange } from "../eslint-rules/paper-typography.mjs";
+import { bibRange } from "#eslint-rules/paper-typography";
+import { messageOf } from "./domain/text.ts";
 
 export const REFERENCES_SCHEMA = 1;
 export const REFERENCES_FILE = "references.json";
@@ -109,6 +109,15 @@ export const documentOf = (
     : { status: "not-checked" as const, why: check.why, entries: [] }),
 });
 
+/** A parsed `references.json` of this schema, its entries a list. */
+const isReferencesDocument = (d: unknown): d is ReferencesDocument =>
+  typeof d === "object" &&
+  d !== null &&
+  "schema" in d &&
+  d.schema === REFERENCES_SCHEMA &&
+  "entries" in d &&
+  Array.isArray(d.entries);
+
 /** The recorded verdicts, or null when there are none or they do not parse. */
 export function readReferences(
   files: Files,
@@ -117,10 +126,8 @@ export function readReferences(
   const raw = text(files, referencesPath(paperDir));
   if (raw === null) return null;
   try {
-    const d = JSON.parse(raw) as ReferencesDocument;
-    return d?.schema === REFERENCES_SCHEMA && Array.isArray(d.entries)
-      ? d
-      : null;
+    const d: unknown = JSON.parse(raw);
+    return isReferencesDocument(d) ? d : null;
   } catch {
     return null;
   }
@@ -159,7 +166,7 @@ async function run(
   try {
     return await check(bib, cache);
   } catch (e) {
-    return { check: { kind: "not-checked", why: (e as Error).message }, cache };
+    return { check: { kind: "not-checked", why: messageOf(e) }, cache };
   }
 }
 

package/src/{rules-config.harness.mjs → rules-config.harness.ts}

@@ -3,24 +3,18 @@
  * 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 { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-import { createChecker } from "../lib/check.mjs";
+import { createChecker } from "../lib/check.ts";
 
-const HERE = dirname(fileURLToPath(import.meta.url));
-const { parseRuleBlocks, shippedRuleIds, unknownKeys } = await import(
-  join(HERE, "rules-config.ts")
-);
+const { parseRuleBlocks, shippedRuleIds, unknownKeys } =
+  await import("./rules-config.ts");
 
 const check = createChecker();
 
 const SHIPPED = new Set(["pdf/last-page-balance", "paper/typography"]);
-const parse = (raw) => parseRuleBlocks(raw, "S", SHIPPED, "/consumer");
+const parse = (raw: unknown) => parseRuleBlocks(raw, "S", SHIPPED, "/consumer");
 
-check(
-  "no `rules` key: no blocks",
-  parse(undefined).ok && parse(undefined).value.length === 0,
-);
+const none = parse(undefined);
+check("no `rules` key: no blocks", none.ok && none.value.length === 0);
 {
   const r = parse([
     {
@@ -62,7 +56,7 @@ check(
   parse([{ rules: { "paper/typography": 0, "pdf/last-page-balance": "warn" } }])
     .ok,
 );
-const refusals = [
+const refusals: [unknown, string][] = [
   ["pdf/last-page-balance", 'S → "rules" must be { "<rule>": "<severity>" }'],
   [{ a: 1 }, '"a" is not a rule paperlint ships'],
   [[42], "S → rules[0] must be an object"],

package/src/rules-config.ts

@@ -25,7 +25,7 @@
  * would need that plugin, which JSON cannot carry. Which rules paperlint ships is read off its own
  * config (`buildConfig`), not listed a second time.
  */
-import { SETTINGS_KEYS } from "../lib/paper-config.mjs";
+import { SETTINGS_KEYS } from "#lib/paper-config";
 
 /** ESLint's severities, in both of its spellings. */
 export type Severity = "off" | "warn" | "error" | 0 | 1 | 2;
@@ -61,7 +61,7 @@ const isStringList = (v: unknown): v is string[] =>
 
 /** A severity, or `[severity, ...options]`. */
 function parseEntry(v: unknown): RuleEntry | null {
-  const sev = Array.isArray(v) ? v[0] : v;
+  const sev: unknown = Array.isArray(v) ? v[0] : v;
   if (!SEVERITIES.includes(sev)) return null;
   return v as RuleEntry;
 }
@@ -126,7 +126,7 @@ function parseBlock(
   const extra = Object.keys(o).filter((k) => !BLOCK_KEYS.has(k));
   if (extra.length)
     return bad(
-      `${at}: unknown key "${extra[0]}" — a block takes "files", "ignores" and "rules"`,
+      `${at}: unknown key "${String(extra[0])}" — a block takes "files", "ignores" and "rules"`,
     );
   const globs = badGlobs(o, at);
   if (globs) return bad(globs);
@@ -167,7 +167,10 @@ export function parseRuleBlocks(
     );
   const out: RuleBlock[] = [];
   for (const [i, v] of raw.entries()) {
-    const b = parseBlock(v, `${where} → rules[${i}]`, { shipped, baseDir });
+    const b = parseBlock(v, `${where} → rules[${String(i)}]`, {
+      shipped,
+      baseDir,
+    });
     if (!b.ok) return b;
     out.push(b.value);
   }

package/src/rules-off.test.ts

@@ -9,9 +9,9 @@
  */
 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 { texLanguage } from "../eslint-rules/latex-language.ts";
 import { rulePlugins, rulesOff, SHIPPED_RULES } from "./cli.ts";
+import { present } from "../test/support.ts";
 
 const PAPER = [
   "\\documentclass{article}",
@@ -45,7 +45,7 @@ async function lintAsConsumer(
   const [res] = await eslint.lintText(PAPER, {
     filePath: "papers/a/paper.tex",
   });
-  return res!.messages;
+  return present(res, "one lint result").messages;
 }
 
 describe("rulesOff — paperlint's rules, registered and off, for a consumer's own ESLint run", () => {
@@ -100,7 +100,9 @@ describe("rulesOff — paperlint's rules, registered and off, for a consumer's o
       "// 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([
+    expect(
+      present(res, "one lint result").messages.map((m) => m.message),
+    ).toEqual([
       "Unused eslint-disable directive (no problems were reported from 'paper/leading-zero').",
     ]);
   });