paperlint 3.2.0 → 4.0.0

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/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 {
@@ -120,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 {
@@ -166,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. */
@@ -182,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) => ({

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({});
   });
 });
 

package/src/references.ts

@@ -28,7 +28,7 @@
  * a pass would be the counter that counts what it never looked at.
  */
 import { join } from "node:path";
-import type { AbsolutePath } from "./domain/paths.ts";
+import { callerPath } from "./caller-path.ts";
 import { sha256Hex } from "./domain/sha256.ts";
 import type { Files } from "./ports/files.ts";
 import {
@@ -60,9 +60,8 @@ export const lookupCachePath = (paperDir: string): string =>
 export const referencesPath = (paperDir: string): string =>
   join(paperDir, "_build", REFERENCES_FILE);
 
-const at = (p: string): AbsolutePath => p as AbsolutePath;
 const text = (files: Files, p: string): string | null => {
-  const b = files.readBytes(at(p));
+  const b = files.readBytes(callerPath(p));
   return b === null ? null : new TextDecoder().decode(b);
 };
 
@@ -186,7 +185,7 @@ export async function recordReferences(
   const record = (c: ReferencesCheck): ReferencesDocument => {
     const doc = documentOf(bib, c);
     files.writeAtomic(
-      at(referencesPath(paperDir)),
+      callerPath(referencesPath(paperDir)),
       new TextEncoder().encode(`${JSON.stringify(doc, null, 2)}\n`),
     );
     return doc;
@@ -206,7 +205,7 @@ export async function recordReferences(
   const fetched = newAnswers(cache.value, result.cache);
   if (fetched > 0)
     files.writeAtomic(
-      at(lookupCachePath(paperDir)),
+      callerPath(lookupCachePath(paperDir)),
       new TextEncoder().encode(serializeLookupCache(result.cache)),
     );
   const bad = doc.entries.filter(

package/src/rules-config.ts

@@ -39,11 +39,40 @@ export interface RuleBlock {
   readonly rules: Readonly<Record<string, RuleEntry>>;
 }
 
+/**
+ * A plugin as a config block registers it, typed to what paperlint reads of it: its rules, and the
+ * languages it brings (`tex` brings LaTeX).
+ */
+export interface ConfigPlugin {
+  readonly rules?: Readonly<Record<string, unknown>>;
+  readonly languages?: Readonly<Record<string, unknown>>;
+}
+
+/**
+ * An ESLint config block as paperlint builds and reads one. Not `Linter.Config`: ESLint types a
+ * plugin's rule as one that runs on ANY language, and paperlint's rules are written for the language
+ * they read (LaTeX, markdown), so none of them is assignable to it. ESLint checks a block when it
+ * loads it; `eslintConfig` in cli.ts is the one place these blocks become `Linter.Config`.
+ */
+export interface ConfigBlock {
+  readonly name?: string;
+  readonly basePath?: string;
+  readonly files?: readonly (string | readonly string[])[];
+  readonly ignores?: readonly string[];
+  readonly plugins?: Readonly<Record<string, ConfigPlugin>>;
+  readonly language?: string;
+  readonly languageOptions?: Readonly<Record<string, unknown>>;
+  readonly linterOptions?: Readonly<Record<string, unknown>>;
+  readonly rules?: Readonly<Record<string, unknown>>;
+}
+
 export type Parsed<T> =
   | { readonly ok: true; readonly value: T }
   | { readonly ok: false; readonly error: string };
 
-const SEVERITIES: readonly unknown[] = ["off", "warn", "error", 0, 1, 2];
+const SEVERITIES: readonly Severity[] = ["off", "warn", "error", 0, 1, 2];
+const isSeverity = (v: unknown): v is Severity =>
+  SEVERITIES.some((s) => s === v);
 
 const BLOCK_KEYS = new Set(["files", "ignores", "rules"]);
 
@@ -61,9 +90,10 @@ const isStringList = (v: unknown): v is string[] =>
 
 /** A severity, or `[severity, ...options]`. */
 function parseEntry(v: unknown): RuleEntry | null {
-  const sev: unknown = Array.isArray(v) ? v[0] : v;
-  if (!SEVERITIES.includes(sev)) return null;
-  return v as RuleEntry;
+  const entry: readonly unknown[] = Array.isArray(v) ? v : [v];
+  const [sev, ...options] = entry;
+  if (!isSeverity(sev)) return null;
+  return Array.isArray(v) ? [sev, ...options] : sev;
 }
 
 /**
@@ -105,8 +135,8 @@ function badGlobs(o: Record<string, unknown>, at: string): string | null {
 
 /** The block's `files`/`ignores`, present only when given. */
 const globsOf = (o: Record<string, unknown>) => ({
-  ...(o["files"] ? { files: o["files"] as string[] } : {}),
-  ...(o["ignores"] ? { ignores: o["ignores"] as string[] } : {}),
+  ...(isStringList(o["files"]) ? { files: o["files"] } : {}),
+  ...(isStringList(o["ignores"]) ? { ignores: o["ignores"] } : {}),
 });
 
 const isRecord = (v: unknown): v is Record<string, unknown> =>
@@ -182,16 +212,15 @@ export function parseRuleBlocks(
  * `foreign` (a dependency's plugin, such as `@eslint/markdown`) are not paperlint's and are skipped.
  */
 export function shippedRuleIds(
-  config: readonly unknown[],
+  config: readonly ConfigBlock[],
   foreign: readonly unknown[],
 ): Set<string> {
   const ids = new Set<string>();
   for (const block of config) {
-    const plugins = (block as { plugins?: Record<string, unknown> }).plugins;
-    for (const [name, plugin] of Object.entries(plugins ?? {})) {
+    for (const [name, plugin] of Object.entries(block.plugins ?? {})) {
       if (foreign.includes(plugin)) continue;
-      const rules = (plugin as { rules?: Record<string, unknown> }).rules;
-      for (const rule of Object.keys(rules ?? {})) ids.add(`${name}/${rule}`);
+      for (const rule of Object.keys(plugin.rules ?? {}))
+        ids.add(`${name}/${rule}`);
     }
   }
   return ids;

package/src/tex-requirements.test.ts

@@ -0,0 +1,21 @@
+import assert from "node:assert/strict";
+import { test } from "vitest";
+import { loadTypescript } from "./tex-requirements.ts";
+
+test("loadTypescript refuses a module without the two functions a profile is read with", () => {
+  assert.throws(
+    () => loadTypescript(() => ({})),
+    /loaded without parseConfigFileTextToJson/,
+  );
+});
+
+test("loadTypescript hands back what `require` loaded when it has them", () => {
+  const ts = {
+    parseConfigFileTextToJson: () => ({ config: {} }),
+    flattenDiagnosticMessageText: () => "",
+  };
+  assert.equal(
+    loadTypescript(() => ts),
+    ts,
+  );
+});

package/src/tex-requirements.ts

@@ -27,6 +27,7 @@ import { join } from "node:path";
 import Ajv from "ajv";
 import { packageVenuesDir } from "../skills/paper-pipeline/scripts/consumer.mjs";
 import { CONFIG_FILE } from "#lib/paper-config";
+import { fieldOf } from "./domain/record.ts";
 
 /** CTAN package name → the names that prove it is installed. */
 export type PackageProofs = Readonly<Record<string, readonly string[]>>;
@@ -51,15 +52,37 @@ const PROFILE_EXT = ".jsonc";
 
 export const NO_REQUIREMENTS: TexRequirements = { packages: {}, tools: {} };
 
-type Ts = typeof import("typescript");
-let ts: Ts | null = null;
+/** The two functions of `typescript` a profile is read with. */
+type TsJsonc = Pick<
+  typeof import("typescript"),
+  "parseConfigFileTextToJson" | "flattenDiagnosticMessageText"
+>;
+
+const isTsJsonc = (m: unknown): m is TsJsonc =>
+  typeof fieldOf(m, "parseConfigFileTextToJson") === "function" &&
+  typeof fieldOf(m, "flattenDiagnosticMessageText") === "function";
+
+/** `typescript` as `load` returns it — `require` answers `any` — checked for the two functions used. */
+export function loadTypescript(load: (id: string) => unknown): TsJsonc {
+  const m = load("typescript");
+  if (!isTsJsonc(m))
+    throw new Error(
+      "`typescript` loaded without parseConfigFileTextToJson — reinstall this package",
+    );
+  return m;
+}
+
+let ts: TsJsonc | null = null;
 /** TypeScript is loaded only when a profile is read: `paperlint lint` never pays for it. */
-function typescript(): Ts {
-  ts ??= createRequire(import.meta.url)("typescript") as Ts;
+function typescript(): TsJsonc {
+  ts ??= loadTypescript(createRequire(import.meta.url));
   return ts;
 }
 
 type Validate = ReturnType<Ajv.Ajv["compile"]>;
+/** `PresetJson` is the TypeScript side of the profile schema: a document the schema accepts is one. */
+const matchesSchema = (v: unknown, validate: Validate): v is PresetJson =>
+  validate(v) === true;
 const validators = new Map<string, Validate>();
 function validatorFor(dir: string): Validate {
   const known = validators.get(dir);
@@ -223,11 +246,11 @@ export function parsePreset(
       `${file}: not valid JSONC — ${typescript().flattenDiagnosticMessageText(error.messageText, " ")}`,
     );
   const validate = validatorFor(dir);
-  if (!validate(config))
+  if (!matchesSchema(config, validate))
     throw new Error(
       `${file} does not match ${SCHEMA_FILE}:\n  ${violations(file, validate).join("\n  ")}`,
     );
-  const j = config as PresetJson;
+  const j = config;
   return {
     extends: orNull(j.extends),
     name: orNull(j.name),

package/src/toolchain.test.ts

@@ -34,19 +34,19 @@ type Answer = {
 };
 /** A runner answering by program name (the last path segment); `onRun` may write files first. */
 function io(
-  answers: Record<string, (args: string[]) => Answer>,
+  answers: Record<string, (args: readonly string[]) => Answer>,
 ): ToolchainIO & { lines: string[] } {
   const lines: string[] = [];
   return {
     lines,
     log: (l) => lines.push(l),
     env: {},
-    run: ((cmd: string, args: string[]) => {
+    run: (cmd, args) => {
       const name = cmd.split("/").pop() ?? cmd;
       const answer = answers[`${name} ${args[0] ?? ""}`] ?? answers[name];
       if (!answer) throw new Error(`unexpected ${name} ${args.join(" ")}`);
       return answer(args);
-    }) as never,
+    },
   };
 }
 const ok = (stdout = ""): Answer => ({ status: 0, stdout, stderr: "" });
@@ -194,7 +194,7 @@ function cacheWith(name: string, year: string): string {
 const ACMART = { packages: { acmart: ["acmart.cls"] }, tools: {} };
 function ensure(
   cache: string,
-  answers: Record<string, (args: string[]) => Answer>,
+  answers: Record<string, (args: readonly string[]) => Answer>,
 ) {
   const t = io(answers);
   const errs: string[] = [];
@@ -272,7 +272,11 @@ test("runToolchain with only its installer: the console is the default output",
   const saved = console.error;
   console.error = (...a: unknown[]) => void seen.push(a.join(" "));
   try {
-    assert.equal(runToolchain({ platform: "win32", banal: {} as never }), 1);
+    const unused = (): never => {
+      throw new Error("an unsupported platform installs nothing");
+    };
+    const banal = { label: "banal", ensure: unused, check: unused };
+    assert.equal(runToolchain({ platform: "win32", banal }), 1);
   } finally {
     console.error = saved;
   }