paperlint 3.1.3 → 4.0.0

package/src/adapters/node/workspace.test.ts

@@ -20,7 +20,9 @@ import { afterAll as after, test } from "vitest";
 import { tmpWorkspace } from "./workspace.io.ts";
 
 const root = realpathSync(mkdtempSync(join(tmpdir(), "paperlint-ws-test-")));
-after(() => rmSync(root, { recursive: true, force: true }));
+after(() => {
+  rmSync(root, { recursive: true, force: true });
+});
 
 test("the directory exists inside the scope and is gone after it", () => {
   const ws = tmpWorkspace(root);

package/src/adapters/pdfjs/fill.test.ts

@@ -1,7 +1,7 @@
 /**
  * `fill.ts` — what is recovered from pdf.js's exports for each text item: whether it is upright, and
  * the fill it was drawn in (the operator-list walk). Operator lists here are written by hand; the
- * real-PDF half runs in `pdf-facts.harness.mjs` and `test/e2e/banal.mjs`.
+ * real-PDF half runs in `pdf-facts.harness.ts` and `test/e2e/banal.ts`.
  */
 import assert from "node:assert/strict";
 import { test } from "vitest";
@@ -34,7 +34,7 @@ const OPS = {
   showText: 5,
   showSpacedText: 6,
 };
-const glyphs = (s: string) => [[...s].map((unicode) => ({ unicode }))];
+const glyphs = (s: string) => [Array.from(s, (unicode) => ({ unicode }))];
 const ops = (...pairs: [number, unknown?][]): OperatorList => ({
   fnArray: pairs.map((p) => p[0]),
   argsArray: pairs.map((p) => p[1] ?? null),

package/src/adapters/pdfjs/fill.ts

@@ -33,9 +33,12 @@ export interface OperatorList {
 /** Text as the walk compares it: normalised, with no whitespace (items and glyphs split spaces differently). */
 const squeeze = (s: string): string => s.normalize("NFKC").replace(/\s+/g, "");
 
+/** An operator's argument list; pdf.js types it `any`, and a malformed one reads as empty. */
+const listOf = (v: unknown): readonly unknown[] => (Array.isArray(v) ? v : []);
+
 /** `setFillRGBColor`'s argument: a `#rrggbb` string in current pdf.js, three 0-255 numbers in older ones. */
 export function hexOf(args: unknown): string {
-  const a = Array.isArray(args) ? (args as unknown[]) : [];
+  const a = listOf(args);
   if (typeof a[0] === "string") return a[0].toLowerCase();
   const byte = (v: unknown): string =>
     Math.round(typeof v === "number" ? v : 0)
@@ -46,12 +49,13 @@ export function hexOf(args: unknown): string {
 
 /** The characters a show-text operator draws, from its glyph objects. */
 function glyphText(args: unknown): string {
-  const a = Array.isArray(args) ? (args as unknown[]) : [];
-  const glyphs = Array.isArray(a[0]) ? (a[0] as unknown[]) : [];
+  const glyphs = listOf(listOf(args)[0]);
   return glyphs
     .map((g) =>
       typeof g === "object" && g !== null && "unicode" in g
-        ? String((g as { unicode: unknown }).unicode ?? "")
+        ? typeof g.unicode === "string"
+          ? g.unicode
+          : ""
         : "",
     )
     .join("");
@@ -76,7 +80,7 @@ function applyState(
   else if (fn === ops.setFillRGBColor)
     s.cur.fill = { kind: "rgb", hex: hexOf(args) };
   else if (fn === ops.setTextRenderingMode)
-    s.cur.mode = Number((args as unknown[] | undefined)?.[0] ?? 0);
+    s.cur.mode = Number(listOf(args)[0] ?? 0);
   else return false;
   return true;
 }
@@ -89,7 +93,10 @@ interface Drawn {
 
 /** Every drawn character, in content order, with the fill it was drawn in. */
 export function drawnCharacters(ops: ColourOps, list: OperatorList): Drawn[] {
-  const s = { cur: { fill: { kind: "unknown" } as Fill, mode: 0 }, stack: [] };
+  const s: { cur: State; stack: State[] } = {
+    cur: { fill: { kind: "unknown" }, mode: 0 },
+    stack: [],
+  };
   const drawn: Drawn[] = [];
   list.fnArray.forEach((fn, i) => {
     const args = list.argsArray[i];
@@ -149,7 +156,7 @@ export function fillsFor<T>(
   const drawn = drawnCharacters(ops, list);
   let at = 0;
   const fillOf = (text: string): Fill => {
-    const want = [...squeeze(text)];
+    const want = Array.from(squeeze(text));
     if (want.length === 0) return { kind: "unknown" };
     const hit = findRun(drawn, want, at);
     if (hit === null) return { kind: "unknown" };

package/src/adapters/references/index.test.ts

@@ -10,7 +10,6 @@ import {
   EMPTY_LOOKUP_CACHE,
   type LookupCache,
 } from "../../domain/lookup-cache.ts";
-// @ts-expect-error — a skill script in .mjs, it has no types
 import * as cites from "../../../skills/verify-citations/scripts/verify-cites.mjs";
 
 /** The verdicts of a cold run — an empty cache, the adapter the CLI wires. */
@@ -46,29 +45,29 @@ const dblp = (title: string, authors: string[]) =>
 /** Route by URL prefix; the longest prefix wins. */
 function fakeFetch(routes: Record<string, () => Response>): string[] {
   const calls: string[] = [];
-  vi.stubGlobal("fetch", async (url: string) => {
+  vi.stubGlobal("fetch", (url: string) => {
     calls.push(url);
-    const hit = Object.keys(routes)
-      .filter((p) => url.startsWith(p))
-      .sort((a, b) => b.length - a.length)[0];
-    if (hit === undefined) return json(404);
-    return routes[hit]!();
+    const hit = Object.entries(routes)
+      .filter(([p]) => url.startsWith(p))
+      .sort(([a], [b]) => b.length - a.length)[0];
+    return Promise.resolve(hit === undefined ? json(404) : hit[1]());
   });
   return calls;
 }
 
 /** Await `p` while fake time runs, so DBLP's pauses between requests elapse at once. */
 async function settle<T>(p: Promise<T>): Promise<T> {
-  let done = false;
-  const out = p.finally(() => (done = true));
-  while (!done) await vi.advanceTimersByTimeAsync(1000);
+  // A field, not a `let`: the flag is set in a callback, which flow analysis cannot see.
+  const state = { done: false };
+  const out = p.finally(() => (state.done = true));
+  while (!state.done) await vi.advanceTimersByTimeAsync(1000);
   return out;
 }
 
 test("no service answers: not-checked, with the reason", async () => {
-  vi.stubGlobal("fetch", async () => {
-    throw new Error("getaddrinfo ENOTFOUND api.crossref.org");
-  });
+  vi.stubGlobal("fetch", () =>
+    Promise.reject(new Error("getaddrinfo ENOTFOUND api.crossref.org")),
+  );
   assert.deepEqual(await checkOnly("@misc{k, title={T}}"), {
     kind: "not-checked",
     why: "the citation services cannot be reached (getaddrinfo ENOTFOUND api.crossref.org)",
@@ -104,19 +103,19 @@ test("each entry gets its existence and its authors: confirmed, fabricated, mism
   const r = await settle(checkOnly(bib));
   assert.equal(r.kind, "checked");
   const byKey = Object.fromEntries(
-    (r.kind === "checked" ? r.entries : []).map((e) => [
-      e.key,
-      [e.exists, e.authors, e.why ?? ""],
-    ]),
+    r.entries.map((e) => [e.key, [e.exists, e.authors, e.why ?? ""]]),
   );
   assert.deepEqual(
     {
-      good: byKey["good"]!.slice(0, 2),
-      fake: byKey["fake"]!.slice(0, 2),
-      drift: byKey["drift"]!.slice(0, 2),
-      driftWhy: String(byKey["drift"]![2]).split("; ").pop(),
-      flaky: [byKey["flaky"]![1], String(byKey["flaky"]![2]).split("; ").pop()],
-      pre: byKey["pre"]!.slice(0, 2),
+      good: byKey["good"]?.slice(0, 2),
+      fake: byKey["fake"]?.slice(0, 2),
+      drift: byKey["drift"]?.slice(0, 2),
+      driftWhy: String(byKey["drift"]?.[2]).split("; ").pop(),
+      flaky: [
+        byKey["flaky"]?.[1],
+        String(byKey["flaky"]?.[2]).split("; ").pop(),
+      ],
+      pre: byKey["pre"]?.slice(0, 2),
     },
     {
       good: ["true", "match"],
@@ -209,20 +208,14 @@ test(
     slowFetch(40);
     const bib = manyBib(20);
     const serial: string[] = [];
-    for (const c of cites.parseBib(bib) as { id: string }[])
-      serial.push(
-        (
-          (await cites.verifyCitationLive(c, { cache: {} })) as {
-            verdict: string;
-          }
-        ).verdict,
-      );
+    for (const c of cites.parseBib(bib))
+      serial.push((await cites.verifyCitationLive(c, { cache: {} })).verdict);
     const t0 = Date.now();
     const r = await checkOnly(bib);
     const ms = Date.now() - t0;
     assert.equal(r.kind, "checked");
     assert.deepEqual(
-      r.kind === "checked" ? r.entries.map((e) => e.exists) : [],
+      r.entries.map((e) => e.exists),
       serial,
     );
     assert.ok(ms < (20 * 200) / 2, `${String(ms)} ms for 20 lookups`);
@@ -249,7 +242,7 @@ const PAPERS = [
   "@inproceedings{good, author={Ada Lovelace}, title={Good Paper}, booktitle={ICSE}, doi={10.1/good}}",
   "@inproceedings{other, author={Ada Lovelace}, title={Other Paper}, booktitle={ICSE}}",
   "@misc{pre, author={Ada Lovelace}, title={A Preprint}, journal={arXiv preprint}}",
-];
+] as const;
 /** Every service answers; DBLP knows "Good Paper" and nothing else. */
 const answering = () =>
   fakeFetch({
@@ -414,7 +407,7 @@ test("a failed lookup is not cached: the next run asks it again", async () => {
     "https://api.crossref.org/": () => json(200, { message: { items: [] } }),
     "https://dblp.org/": () => json(500),
   });
-  const bib = PAPERS[1]!;
+  const bib = PAPERS[1];
   const r = await settle(cached(bib, EMPTY_LOOKUP_CACHE));
   const failed: LookupCache = r.cache;
   assert.deepEqual(
@@ -427,10 +420,10 @@ test("a failed lookup is not cached: the next run asks it again", async () => {
 });
 
 test("offline with an incomplete cache: not-checked, and the cache comes back unchanged", async () => {
-  vi.stubGlobal("fetch", async () => {
-    throw new Error("getaddrinfo ENOTFOUND api.crossref.org");
-  });
-  const r = await cached(PAPERS[0]!, EMPTY_LOOKUP_CACHE);
+  vi.stubGlobal("fetch", () =>
+    Promise.reject(new Error("getaddrinfo ENOTFOUND api.crossref.org")),
+  );
+  const r = await cached(PAPERS[0], EMPTY_LOOKUP_CACHE);
   assert.deepEqual(r, {
     check: {
       kind: "not-checked",

package/src/adapters/references/index.ts

@@ -35,29 +35,16 @@ import { sleep, todayUtc } from "./clock.io.ts";
 
 /** Citations looked up at once (#107). */
 const LOOKUPS_IN_FLIGHT = 6;
-// @ts-expect-error — a skill script in .mjs, it has no types
 import * as cites from "../../../skills/verify-citations/scripts/verify-cites.mjs";
-// @ts-expect-error — a skill script in .mjs, it has no types
+import type { CiteVerdict } from "../../../skills/verify-citations/scripts/verify-cites.mjs";
 import * as authors from "../../../skills/verify-citations/scripts/bib-authors.mjs";
-
-interface CiteResult {
-  readonly id: string;
-  readonly verdict: "true" | "false" | "unresolvable";
-  readonly reason?: string;
-  /** "<service>: <reason>" for each question a refusing service did not answer (#120). */
-  readonly refused?: readonly string[];
-}
-interface AuthorFinding {
-  readonly key: string;
-  readonly venue: string;
-  readonly missing: readonly string[];
-  readonly extra: readonly string[];
-  readonly orderDiffers: boolean;
-}
-interface KeyWhy {
-  readonly key: string;
-  readonly why: string;
-}
+import type {
+  AuthorBuckets,
+  AuthorFinding,
+  BibEntry,
+} from "../../../skills/verify-citations/scripts/bib-authors.mjs";
+import { messageOf } from "../../domain/text.ts";
+import { isRecord } from "../../domain/record.ts";
 
 const describeAuthors = (f: AuthorFinding): string =>
   [
@@ -68,13 +55,6 @@ const describeAuthors = (f: AuthorFinding): string =>
     .filter(Boolean)
     .join("; ") + ` (DBLP: ${f.venue})`;
 
-interface AuthorBuckets {
-  readonly findings: readonly AuthorFinding[];
-  readonly skipped: readonly KeyWhy[];
-  readonly unchecked: readonly KeyWhy[];
-  readonly matched: readonly string[];
-}
-
 const authorsOf = (key: string, a: AuthorBuckets): EntryVerdict["authors"] =>
   a.findings.some((f) => f.key === key)
     ? "mismatch"
@@ -90,7 +70,7 @@ const authorsOf = (key: string, a: AuthorBuckets): EntryVerdict["authors"] =>
  * confirmed work: a refusal after a confirmation changed nothing.
  */
 const unconfirmed = (
-  c: CiteResult | undefined,
+  c: CiteVerdict | undefined,
 ): readonly (string | undefined)[] =>
   c && c.verdict !== "true"
     ? [c.reason, ...(c.refused ?? []).map((r) => `not asked: ${r}`)]
@@ -99,7 +79,7 @@ const unconfirmed = (
 /** One entry's verdict from the two checkers' answers. */
 function entryVerdict(
   key: string,
-  found: readonly CiteResult[],
+  found: readonly CiteVerdict[],
   a: AuthorBuckets,
 ): EntryVerdict {
   const c = found.find((x) => x.id === key);
@@ -119,27 +99,21 @@ function entryVerdict(
   };
 }
 
-interface BibAuthorsEntry {
-  readonly key: string;
-  readonly title: string;
-  readonly author: string;
-}
-
 /** Whether bib-authors will ask DBLP about this entry — the filter its `checkAuthors` applies. */
-const asksDblp = (e: BibAuthorsEntry): boolean =>
+const asksDblp = (e: BibEntry): boolean =>
   Boolean(e.title && e.author) &&
-  (authors.claimsPublished(e) as boolean) &&
-  !(authors.truncated(e.author) as boolean);
+  authors.claimsPublished(e) &&
+  !authors.truncated(e.author);
 
 /** Is every question this bibliography would ask already answered in `cache`? */
 async function fullyCached(
-  citations: readonly object[],
-  entries: readonly BibAuthorsEntry[],
+  citations: readonly cites.Citation[],
+  entries: readonly BibEntry[],
   cache: LookupCache,
   store: Readonly<Record<string, unknown>>,
 ): Promise<boolean> {
   const asks = await Promise.all(
-    citations.map((c) => cites.wouldAsk(c, store) as Promise<boolean>),
+    citations.map((c) => cites.wouldAsk(c, store)),
   );
   return (
     !asks.includes(true) &&
@@ -185,11 +159,11 @@ function cachedDblp(cache: LookupCache, today: () => string) {
       if (refused !== null)
         throw new Error(`DBLP refused earlier in this run (${refused})`);
       try {
-        const hits = (await authors.dblpHits(title)) as DblpHit[];
+        const hits = await authors.dblpHits(title);
         dblp.set(dblpTitleKey(title), { fetched: today(), title, hits });
         return hits;
       } catch (e) {
-        refused = (e as Error).message;
+        refused = messageOf(e);
         throw new Error(`DBLP refused earlier in this run (${refused})`);
       }
     },
@@ -215,12 +189,16 @@ function grown(
 ): LookupCache {
   const { cache, usable } = loaded;
   const { store, dblp } = run;
-  const fresh = Object.entries(store).filter(([k]) => !usable.citations.has(k));
+  // verify-cites stores each answer as an object; only such a value is a response the cache can hold.
+  const fresh = Object.entries(store).filter(
+    (e): e is [string, Readonly<Record<string, unknown>>] =>
+      !usable.citations.has(e[0]) && isRecord(e[1]),
+  );
   const freshDblp = [...dblp].filter(([k]) => !usable.dblp.has(k));
   if (fresh.length === 0 && freshDblp.length === 0) return cache;
   const dated = fresh.map(([k, response]): [string, CachedResponse] => [
     k,
-    { fetched: today(), response: response as CachedResponse["response"] },
+    { fetched: today(), response },
   ]);
   return {
     citations: new Map([...cache.citations, ...dated]),
@@ -234,10 +212,8 @@ export const referencesChecker =
   async (bib, cache) => {
     // Answers past MAX_AGE_DAYS are left out, so the run asks them again (and `grown` re-dates them).
     const usable = freshPart(cache, today());
-    const citations = (cites.parseBib(bib) as { id?: string }[]).filter(
-      (c) => c.id,
-    );
-    const parsed = authors.parseBib(bib) as BibAuthorsEntry[];
+    const citations = cites.parseBib(bib);
+    const parsed = authors.parseBib(bib);
     const store: Record<string, unknown> = Object.fromEntries(
       [...usable.citations].map(([k, v]) => [k, v.response]),
     );
@@ -252,22 +228,19 @@ export const referencesChecker =
     // answer.
     // One breaker for the run: a service that refuses is not asked again, not once per citation
     // (#120). Requests already in flight when it starts refusing still land — at most six.
-    const breaker = cites.createBreaker() as unknown;
+    const breaker = cites.createBreaker();
     const d = cachedDblp(usable, today);
     const [found, a] = await Promise.all([
-      mapLimit(
-        citations,
-        LOOKUPS_IN_FLIGHT,
-        (c) =>
-          cites.verifyCitationLive(c, {
-            cache: store,
-            breaker,
-          }) as Promise<CiteResult>,
+      mapLimit(citations, LOOKUPS_IN_FLIGHT, (c) =>
+        cites.verifyCitationLive(c, {
+          cache: store,
+          breaker,
+        }),
       ),
       authors.checkAuthors(parsed, {
         lookup: d.lookup,
         pause: d.pause,
-      }) as Promise<AuthorBuckets>,
+      }),
     ]);
     const keys = new Set([
       ...found.map((c) => c.id),

package/src/adapters/references/pool.ts

@@ -10,12 +10,10 @@ export async function mapLimit<T, R>(
   fn: (item: T) => Promise<R>,
 ): Promise<R[]> {
   const out: R[] = new Array<R>(items.length);
-  let next = 0;
+  // ONE iterator shared by every worker: each `next()` hands out the next index exactly once.
+  const queue = items.entries();
   const worker = async (): Promise<void> => {
-    while (next < items.length) {
-      const i = next++;
-      out[i] = await fn(items[i] as T);
-    }
+    for (const [i, item] of queue) out[i] = await fn(item);
   };
   await Promise.all(
     Array.from({ length: Math.min(limit, items.length) }, worker),

package/src/adapters/references/reach.io.ts

@@ -1,3 +1,4 @@
+import { messageOf } from "../../domain/text.ts";
 /** Whether the citation services answer at all — the one request that decides "not checked". */
 export async function unreachable(): Promise<string | null> {
   try {
@@ -7,6 +8,6 @@ export async function unreachable(): Promise<string | null> {
     });
     return null;
   } catch (e) {
-    return `the citation services cannot be reached (${(e as Error).message})`;
+    return `the citation services cannot be reached (${messageOf(e)})`;
   }
 }

package/src/build-engine.harness.mjs

@@ -19,7 +19,7 @@ import {
 import { tmpdir } from "node:os";
 import { basename, delimiter, 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 E = await import(join(HERE, "build-engine.ts"));

package/src/build-engine.test.ts

@@ -7,8 +7,9 @@ import assert from "node:assert/strict";
 import { chmodSync, mkdirSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { test } from "vitest";
-import { useTempDir } from "../test/support.mjs";
+import { useTempDir } from "../test/support.ts";
 import { prepareEngine, refusal } from "./build-engine.ts";
+import type { Runner } from "./engine.ts";
 
 const work = useTempDir("paperlint-build-engine-test-");
 const TEX = { packages: { acmart: ["acmart.cls"] }, tools: {} };
@@ -20,11 +21,12 @@ const texAt = (dir: string): string => {
   return dir;
 };
 /** kpsewhich answers per bin directory. */
-const fakeRun = (found: Record<string, string>) =>
-  ((cmd: string) => ({
+const fakeRun =
+  (found: Record<string, string>): Runner =>
+  (cmd) => ({
     stdout: found[dirname(cmd)] ?? "",
     status: 0,
-  })) as never;
+  });
 
 async function go(o: Parameters<typeof prepareEngine>[0]) {
   const out: string[] = [];
@@ -34,7 +36,7 @@ async function go(o: Parameters<typeof prepareEngine>[0]) {
     err: (l) => err.push(l),
     platform: "linux",
     interactive: true,
-    ask: async () => "y",
+    ask: () => Promise.resolve("y"),
     ...o,
   });
   return { r, out, err };
@@ -101,7 +103,10 @@ test("a complete cache is used from an environment with no PATH at all", async (
 
 test("the refusal line for a decision to use a tree names nothing missing", () => {
   assert.equal(
-    refusal({ kind: "use-cache" } as never, { system: null } as never),
+    refusal(
+      { kind: "use-cache", tree: { label: "cache", bin: "/b", missing: [] } },
+      { system: null },
+    ),
     "✗ paperlint build: no TeX Live with every package these papers need — run `npx paperlint toolchain` (missing: 0 package(s): )",
   );
 });
@@ -122,14 +127,14 @@ test("without an ask or an install given: Enter is yes, and the default install
       PAPERLINT_CTAN_MIRROR: "https://mirror.invalid/tlnet",
       PATH: join(work, "nothing"),
     },
-    run: ((cmd: string) => {
+    run: (cmd) => {
       calls.push(cmd.split("/").pop() ?? cmd);
       return {
         status: 22,
         stdout: "",
         stderr: "curl: (6) could not resolve\n",
       };
-    }) as never,
+    },
   });
   assert.deepEqual(r, { ok: false, code: 1 });
   assert.ok(calls.includes("curl"), calls.join(","));

package/src/build-engine.ts

@@ -62,16 +62,18 @@ type Resolved = Required<Omit<EngineOptions, "install">> & {
 };
 
 /** The options a caller actually set — `undefined` must still get its default, so no plain spread. */
-const defined = <T extends object>(o: T): Partial<T> =>
-  Object.fromEntries(
-    Object.entries(o).filter(([, v]) => v !== undefined),
-  ) as Partial<T>;
+function defined<T extends object>(o: T): Partial<T> {
+  const out: Partial<T> = {};
+  // `for…in` hands out `o`'s keys typed as its keys; an options literal has no inherited ones.
+  for (const k in o) if (o[k] !== undefined) out[k] = o[k];
+  return out;
+}
 
 function withDefaults(o: EngineOptions): Resolved {
   const r = {
     dryRun: false,
     interactive: false,
-    ask: async () => "",
+    ask: () => Promise.resolve(""),
     log: console.log,
     err: console.error,
     // eslint-disable-next-line no-restricted-globals -- legacy I/O, moves behind a port in #76
@@ -130,10 +132,13 @@ export function gatherFacts(o: Resolved): EngineFacts {
 }
 
 const names = (missing: readonly string[]): string =>
-  `${missing.length} package(s): ${missing.join(", ")}`;
+  `${String(missing.length)} package(s): ${missing.join(", ")}`;
 
 /** The one line a run without a human gets. It names the command and what is missing. */
-export function refusal(d: EngineDecision, facts: EngineFacts): string {
+export function refusal(
+  d: EngineDecision,
+  facts: Pick<EngineFacts, "system">,
+): string {
   const missing = d.kind === "refuse" || d.kind === "ask" ? d.missing : [];
   const sys =
     facts.system && facts.system.missing.length

package/src/build.harness.mjs

@@ -4,7 +4,7 @@
  * The process runner is replaced by a fake that writes what pdflatex and bibtex would write, so
  * these assertions check the SHELL's decisions: what is run, with which environment, in which
  * order, and what is left on disk. Whether a real pdflatex produces a real PDF is the other half,
- * `test/e2e/build.mjs`.
+ * `test/e2e/build.ts`.
  *
  * 🔴 THE TWO THINGS PINNED DOWN HERE THAT A RETURNED OBJECT CANNOT SHOW: a paper-supplied
  * `build.sh` is never executed (checked by the trace it would leave on disk and by the list of
@@ -22,7 +22,7 @@ import {
 import { tmpdir } from "node:os";
 import { join, dirname, delimiter } 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 {

package/src/build.test.ts

@@ -8,7 +8,7 @@ import assert from "node:assert/strict";
 import { existsSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { test } from "vitest";
-import { useTempDir, writeTree } from "../test/support.mjs";
+import { present, useTempDir, writeTree } from "../test/support.ts";
 import {
   bibInput,
   buildPaper,
@@ -62,18 +62,18 @@ function bibtexRun(f: Fake, cwd: string) {
     ? { status: f.bibtex }
     : { status: f.bibtex, stdout: f.bibtexOut };
 }
-function fakeRun(f: Fake): BuildOptions["run"] {
+function fakeRun(f: Fake): NonNullable<BuildOptions["run"]> {
   let pass = 0;
-  return ((bin: string, _args: string[], opts: { cwd: string }) => {
+  return (bin, _args, opts) => {
     if (bin === f.missing)
       return {
         error: Object.assign(new Error("spawn ENOENT"), { code: "ENOENT" }),
         status: null,
       };
-    return bin === "pdflatex"
-      ? latexPass(f, opts.cwd, ++pass)
-      : bibtexRun(f, opts.cwd);
-  }) as never;
+    // The build always runs a pass in the paper's directory.
+    const cwd = present(opts.cwd, "the pass's cwd");
+    return bin === "pdflatex" ? latexPass(f, cwd, ++pass) : bibtexRun(f, cwd);
+  };
 }
 
 const NO_GEOMETRY: Geometry = {
@@ -103,18 +103,19 @@ const page = (words: number, numbered = 0) => ({
 });
 const reader =
   (last = page(80)): PdfReader =>
-  async () => ({
-    ok: true,
-    facts: {
-      pages: 1,
-      fonts: {
-        kind: "drawn",
-        list: [{ kind: "embedded", name: "CMR10", program: "Type1" }],
+  () =>
+    Promise.resolve({
+      ok: true,
+      facts: {
+        pages: 1,
+        fonts: {
+          kind: "drawn",
+          list: [{ kind: "embedded", name: "CMR10", program: "Type1" }],
+        },
+        last,
+        layout: [],
       },
-      last,
-      layout: [],
-    },
-  });
+    });
 const quiet = () => {};
 /** buildPaper with fakes; the verdict line is what the command would print for it. */
 async function build(dir: string, f: Fake = {}, over: BuildOptions = {}) {
@@ -145,11 +146,10 @@ test("documentclass: an empty name is no class; a macro inside the name contribu
   // `\documentclass` came back bare has no name to read, and is no class.
   assert.equal(
     parseDocumentclass("\\documentclass", {
-      parse: () =>
-        ({
-          type: "root",
-          content: [{ type: "macro", content: "documentclass" }],
-        }) as never,
+      parse: () => ({
+        type: "root",
+        content: [{ type: "macro", content: "documentclass" }],
+      }),
     }),
     null,
   );
@@ -332,7 +332,7 @@ test("paths: a paper that IS the working directory is named by its full path", a
   const run = await buildPapers([dir], {
     cwd: dir,
     log: (l) => lines.push(l),
-    engine: async () => null,
+    engine: () => Promise.resolve(null),
   });
   assert.deepEqual(
     [run, lines],