paperlint 3.1.3 → 4.0.0

package/src/paper-settings.ts

@@ -21,8 +21,8 @@ import {
   ROOT_ONLY_KEYS,
   SETTINGS_KEYS,
   findProjectRoot,
-} from "../lib/paper-config.mjs";
-import type { AbsolutePath } from "./domain/paths.ts";
+} from "#lib/paper-config";
+import { callerPath } from "./caller-path.ts";
 import { err, ok, type Result } from "./domain/result.ts";
 import type { Files } from "./ports/files.ts";
 import {
@@ -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;
@@ -111,19 +114,17 @@ export function parsePaperSettings(
   });
 }
 
-const at = (p: string): AbsolutePath => p as AbsolutePath;
-
 /** A JSON file through `files`: undefined when absent, the problem when it does not parse. */
 function readJson(
   files: Files,
   path: string,
 ): Result<unknown, SettingsProblem> {
-  const bytes = files.readBytes(at(path));
+  const bytes = files.readBytes(callerPath(path));
   if (bytes === null) return ok(undefined);
   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)})` });
   }
 }
 
@@ -136,7 +137,9 @@ function rootDefaults(
   files: Files,
   paperDir: string,
 ): Result<Defaults | null, SettingsProblem> {
-  const root = findProjectRoot(dirname(paperDir), (p) => files.isFile(at(p)));
+  const root = findProjectRoot(dirname(paperDir), (p) =>
+    files.isFile(callerPath(p)),
+  );
   const json = readJson(files, join(root, CONFIG_FILE));
   if (!json.ok) return json;
   if (!isObject(json.value)) return ok(null);
@@ -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),
@@ -39,11 +40,11 @@ function page(items: FakeItem[], fonts: Record<string, unknown>) {
     }),
   };
 }
-const doc = (pages: ReturnType<typeof page>[]) =>
-  ({
-    numPages: pages.length,
-    getPage: async (i: number) => 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[],
@@ -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", () => {
@@ -142,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

@@ -34,12 +34,68 @@ 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";
+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
@@ -94,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;
@@ -110,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 {
@@ -123,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;
 }
@@ -166,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 };
@@ -178,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,
@@ -199,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;
 }
 
@@ -210,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);
@@ -228,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)),
     ),
   };
 }
@@ -237,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 });
@@ -289,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,
   );
 }
@@ -303,7 +361,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;
@@ -158,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.
  *
@@ -294,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/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.ts

@@ -39,7 +39,7 @@ import {
   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 {
@@ -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:";
@@ -119,7 +120,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 {
@@ -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(" "),
     });
   }
 }
@@ -165,14 +166,22 @@ 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. */
@@ -181,12 +190,18 @@ function merged(
   rootFirst: readonly PresetFile[],
   files: readonly string[],
 ): Preset {
-  const base = {
-    name: null as string | null,
-    template: null as string | null,
+  const base: {
+    name: string | null;
+    template: string | null;
+    tex: TexRequirements;
+    format: VenueFormat;
+    rules: Readonly<Record<string, unknown>>;
+  } = {
+    name: null,
+    template: null,
     tex: NO_REQUIREMENTS,
     format: NO_FORMAT,
-    rules: {} as Readonly<Record<string, unknown>>,
+    rules: {},
   };
   const m = rootFirst.reduce(
     (acc, p) => ({