paperlint 7.2.0 → 9.0.0

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

@@ -697,3 +697,76 @@ describe("bodyEmphasis — each style, and edge cases", () => {
     expect(e && src.slice(e.span.start, e.span.end)).toBe("\\textbf{see it}");
   });
 });
+
+describe("latexReader.filecontents — the blocks that write a file, where they stand", () => {
+  const SRC =
+    "\\documentclass{x}\n" +
+    "\\begin{filecontents*}[overwrite]{refs.bib}\n@misc{a, title={A}}\n\\end{filecontents*}\n" +
+    "\\begin{document}\n" +
+    "\\begin{filecontents}{\\jobname.bib}\n@misc{b, title={B}}\n\\end{filecontents}\n" +
+    "\\end{document}\n" +
+    "\\begin{filecontents}{late.bib}\n@misc{c}\n\\end{filecontents}\n";
+
+  it("each live block, in order: the file it writes (\\jobname expanded), [overwrite], its span and body", () => {
+    const blocks = latexReader.filecontents(SRC, "paper");
+    expect(
+      blocks.map((b) => [
+        b.writes,
+        b.overwrite,
+        SRC.slice(b.body.start, b.body.end),
+      ]),
+    ).toEqual([
+      ["refs.bib", true, "@misc{a, title={A}}\n"],
+      ["paper.bib", false, "@misc{b, title={B}}\n"],
+    ]);
+    expect(SRC.slice(blocks[0]?.span.start, blocks[0]?.span.end)).toMatch(
+      /^\\begin\{filecontents\*\}.*\\end\{filecontents\*\}$/s,
+    );
+  });
+
+  it("a block inside a comment, or after \\end{document}, is not one TeX runs", () => {
+    expect(
+      latexReader.filecontents(
+        "% \\begin{filecontents}{x.bib}\n% @misc{z}\n% \\end{filecontents}\n\\begin{document}\n\\end{document}\n",
+        "paper",
+      ),
+    ).toEqual([]);
+  });
+
+  it("a block that names no file writes none: a group after its body's first text is no name, and a body may hold none", () => {
+    expect(
+      [
+        "\\begin{filecontents}\n@misc{z}\n\\end{filecontents}\n",
+        "\\begin{filecontents}\nplain text\n\\end{filecontents}\n",
+      ].flatMap((block) =>
+        latexReader.filecontents(
+          `${block}\\begin{document}\n\\end{document}\n`,
+          "paper",
+        ),
+      ),
+    ).toEqual([]);
+  });
+});
+
+describe("latexReader.filecontents — a file name on a line of its own", () => {
+  it("🔴 a name on the line after \\begin, the option before it or not: TeX takes it, and the body starts on the line after the name", () => {
+    // Measured with pdflatex: `\\begin{filecontents*}` then `{refs.bib}` on the next line writes
+    // refs.bib from the lines after the name (fixtures/paper-sources/v30-name-next-line).
+    const src =
+      "\\begin{filecontents*}\n{refs.bib}\n@misc{a, title={A}}\n\\end{filecontents*}\n" +
+      "\\begin{filecontents}[overwrite]\n  {two.bib}\n@misc{b}\n\\end{filecontents}\n" +
+      "\\begin{document}\n\\end{document}\n";
+    expect(
+      latexReader
+        .filecontents(src, "paper")
+        .map((b) => [
+          b.writes,
+          b.overwrite,
+          src.slice(b.body.start, b.body.end),
+        ]),
+    ).toEqual([
+      ["refs.bib", false, "@misc{a, title={A}}\n"],
+      ["two.bib", true, "@misc{b}\n"],
+    ]);
+  });
+});

package/src/adapters/latex/index.ts

@@ -33,6 +33,7 @@ import { parseLatex } from "./parse.ts";
 import { bodyEmphasis, bodyProse } from "./prose.ts";
 import { renderedRuns } from "./rendered.ts";
 import { layoutOverridesOf } from "./layout.ts";
+import { filecontentsOf } from "./filecontents.ts";
 
 export {
   documentClassOf,
@@ -69,4 +70,5 @@ export const latexReader: LatexReader = {
   template: parseTemplate,
   withDocumentClass: (src, want) => replaceDocumentClass(parseLatex(src), want),
   layoutOverrides: (src) => layoutOverridesOf(parseLatex(src)),
+  filecontents: (src, jobname) => filecontentsOf(parseLatex(src), jobname),
 };

package/src/adapters/latex/nodes.ts

@@ -156,3 +156,67 @@ export const isArgument = (v: Visited): v is Argument =>
 /** A node, as opposed to a node list or an argument (which visit also reports). */
 export const isNode = (v: Visited): v is Node =>
   !isList(v) && v.type !== "argument" && v.type !== "root";
+
+/** A piece of an argument as TeX reads it: text, or a macro this reader leaves as written (`\x`). */
+export interface ArgumentPiece {
+  readonly text: string;
+  readonly macro: boolean;
+}
+
+/**
+ * An argument's nodes as TeX reads them, off the tree: a comment is no part of it, a group's braces
+ * are none, and white space is one space. `\jobname` is the main file's name when `jobname` is given;
+ * every other macro — `\jobnamebib` included, a control sequence of its own — is a piece of its own,
+ * written as it stands, and so is anything else (math, verbatim) a name cannot hold.
+ */
+export function argumentPieces(
+  nodes: readonly Node[],
+  jobname: string | null,
+): readonly ArgumentPiece[] {
+  return nodes.flatMap((n) => pieceOf(n, jobname));
+}
+
+/** The nodes a name cannot hold as text: an environment, math, verbatim. */
+type Nameless = Extract<
+  Node,
+  {
+    readonly type:
+      | "root"
+      | "environment"
+      | "mathenv"
+      | "inlinemath"
+      | "displaymath"
+      | "verb"
+      | "verbatim";
+  }
+>;
+const NAMELESS: ReadonlySet<string> = new Set([
+  "root",
+  "environment",
+  "mathenv",
+  "inlinemath",
+  "displaymath",
+  "verb",
+  "verbatim",
+]);
+const isNameless = (n: Node): n is Nameless => NAMELESS.has(n.type);
+
+/** One node of an argument as `argumentPieces` reads it. */
+function pieceOf(n: Node, jobname: string | null): readonly ArgumentPiece[] {
+  if (isNameless(n)) return [{ text: `\\${n.type}`, macro: true }];
+  switch (n.type) {
+    case "comment":
+      return [];
+    case "string":
+      return [{ text: n.content, macro: false }];
+    case "whitespace":
+    case "parbreak":
+      return [{ text: " ", macro: false }];
+    case "group":
+      return argumentPieces(n.content, jobname);
+    case "macro":
+      return n.content === "jobname" && jobname !== null
+        ? [{ text: jobname, macro: false }]
+        : [{ text: `\\${n.content}`, macro: true }];
+  }
+}

package/src/adapters/latex/parse.test.ts

@@ -0,0 +1,38 @@
+/**
+ * `parseLatex` keeps the trees of a bounded amount of source text: an editor session must not hold a
+ * tree for every version of the paper it has seen.
+ */
+import { describe, expect, it } from "vitest";
+import { parseLatex } from "./index.ts";
+
+describe("parseLatex's memo", () => {
+  /** A distinct source of `kib` KiB that parses quickly: one long comment. */
+  const source = (tag: string, kib: number) =>
+    `${tag}\n%${"x".repeat(kib * 1024)}`;
+
+  it("returns the same tree for the same text while it is kept", () => {
+    const s = source("same", 1);
+    expect(parseLatex(s)).toBe(parseLatex(s));
+  });
+
+  it("keeps up to 512 KiB of source: a paper's ten files stay, read in a cycle", () => {
+    const files = Array.from({ length: 11 }, (_, i) =>
+      source(`f${String(i)}`, 30),
+    );
+    const first = files.map((f) => parseLatex(f));
+    expect(files.map((f) => parseLatex(f))).toEqual(first);
+    expect(files.every((f, i) => parseLatex(f) === first[i])).toBe(true);
+  });
+
+  it("past 512 KiB the text used least recently goes first, a recently used one stays", () => {
+    const big = Array.from({ length: 6 }, (_, i) =>
+      source(`b${String(i)}`, 100),
+    );
+    const trees = big.slice(0, 5).map((f) => parseLatex(f));
+    // Touch the oldest: it becomes the most recent, so the second is the one evicted.
+    expect(parseLatex(big[0] ?? "")).toBe(trees[0]);
+    parseLatex(big[5] ?? "");
+    expect(parseLatex(big[0] ?? "")).toBe(trees[0]);
+    expect(parseLatex(big[1] ?? "")).not.toBe(trees[1]);
+  });
+});

package/src/adapters/latex/parse.ts

@@ -59,10 +59,13 @@ export const KEY_SIGNATURES: Readonly<
       "subfile",
       "bibliography",
       "bibliographystyle",
-      "addbibresource",
     ],
     "m",
   ),
+  // biblatex's resources take options (`[location=remote]`) before the name.
+  ...signed(["addbibresource", "addglobalbib", "addsectionbib"], "o m"),
+  // bibentry's: writes `\bibdata` as `\bibliography` does, and typesets nothing.
+  ...signed(["nobibliography"], "m"),
   ...signed(["includegraphics"], "s o o m"),
   ...signed(["usepackage", "RequirePackage", "documentclass"], "o m o"),
 ]);
@@ -134,9 +137,67 @@ const parser = once(() =>
   }),
 );
 
+/**
+ * The trees parsed last, by their source: a tree is a pure function of its text, and one lint of a
+ * paper asks for the same texts many times — every rule that reads the paper (`readPaper`)
+ * parses `paper.tex`, its includes and the assembled whole again. Measured 2026-10-06 on the
+ * accepted ACM paper of the corpus: 0.9 s per reading of the paper's sources, seven of them per lint,
+ * 50–76 ms with the memo.
+ *
+ * Bounded by the SOURCE TEXT it holds (UTF-16 units, about bytes for TeX), least recently used out.
+ * A count bound is wrong both ways: 64 trees held 64 versions of one file in an editor (186 MiB for a
+ * 48 KiB paper), and 8 trees thrashed on a paper with ten includes — the rules read them in a cycle,
+ * so every read missed and the corpus lint timed out. `MEMO_BYTES` holds the largest paper of the corpus
+ * (150 KB of sources, and the assembled whole) and about ten versions of a 48 KiB file.
+ */
+const MEMO_BYTES = 512 * 1024;
+const memo = new Map<string, ParsedTex>();
+
+/** The texts to evict, least recent first, so that `adding` more fits under `MEMO_BYTES`. */
+const evicted = (adding: number): readonly string[] => {
+  const keys = [...memo.keys()];
+  const total = keys.reduce((n, k) => n + k.length, adding);
+  const { out } = keys.reduce<{
+    readonly left: number;
+    readonly out: readonly string[];
+  }>(
+    (acc, k) =>
+      acc.left > MEMO_BYTES
+        ? { left: acc.left - k.length, out: [...acc.out, k] }
+        : acc,
+    { left: total, out: [] },
+  );
+  return out;
+};
+
 /** A LaTeX source → its tree, without the branches `\iffalse … \fi` hides (`conditionals.ts`). */
-export const parseLatex = (src: string): ParsedTex => ({
-  src,
-  root: withoutFalseBranches(src, parser().parse(src)),
-  [PARSED]: true,
-});
+export function parseLatex(src: string): ParsedTex {
+  const hit = memo.get(src);
+  const parsed: ParsedTex = hit ?? {
+    src,
+    root: withoutFalseBranches(src, parser().parse(src)),
+    [PARSED]: true,
+  };
+  // Most recent last: a hit moves to the end, and the first keys are the ones used least recently.
+  // eslint-disable-next-line functional/immutable-data -- the bounded memo, see above
+  memo.delete(src);
+  // eslint-disable-next-line functional/immutable-data -- the bounded memo, see above
+  evicted(src.length).forEach((k) => memo.delete(k));
+  // eslint-disable-next-line functional/immutable-data -- the bounded memo, see above
+  memo.set(src, parsed);
+  return parsed;
+}
+
+/**
+ * The part of a source's tree TeX reads: everything up to and with the `document` environment.
+ * TeX stops at `\end{document}`, so a `\bibliography`, a `thebibliography`, a block or an `\input`
+ * parked after it is never read. A source with no `document` environment is read whole.
+ */
+export function liveRoot(t: ParsedTex): Readonly<Ast.Root> {
+  const end = t.root.content.findIndex(
+    (n) => n.type === "environment" && n.env === "document",
+  );
+  return end < 0
+    ? t.root
+    : { ...t.root, content: t.root.content.slice(0, end + 1) };
+}

package/src/adapters/memory/index.ts

@@ -5,6 +5,7 @@
 import { absolutePath } from "../../domain/paths.ts";
 import type { Download } from "../../ports/download.ts";
 import type { Files } from "../../ports/files.ts";
+import type { ListDir } from "../../ports/talk-media.ts";
 import type { Command, ProcessExit, RunProcess } from "../../ports/process.ts";
 import type { NotAPromise, Scratch, Workspace } from "../../ports/workspace.ts";
 import { err, ok } from "../../domain/result.ts";
@@ -55,6 +56,22 @@ export function memoryFiles(
   };
 }
 
+/** `ListDir` over `memoryFiles`: the names directly under a directory, none when it holds no file. */
+export const memoryListDir =
+  (files: MemoryFiles): ListDir =>
+  (dir) => [
+    ...new Set(
+      [...files.map.keys()]
+        .filter((k) => k.startsWith(`${dir}/`))
+        .map((k) =>
+          k
+            .slice(dir.length + 1)
+            .split("/", 1)
+            .join(""),
+        ),
+    ),
+  ];
+
 export interface MemoryWorkspace extends Workspace {
   /** Every file written into a scratch directory, in order. */
   readonly written: {

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

@@ -11,10 +11,16 @@ import {
   type LookupCache,
 } from "../../domain/lookup-cache.ts";
 import * as cites from "../../../skills/verify-citations/scripts/verify-cites.mjs";
+import { absolutePath } from "../../domain/paths.ts";
+import { bibReader } from "../bibtex/index.ts";
+
+/** A BibTeX text's entries, as the bibtex reader reads them. */
+const read = (bib: string) =>
+  bibReader.readFile(absolutePath("/p/refs.bib"), bib).entries;
 
 /** The verdicts of a cold run — an empty cache, the adapter the CLI wires. */
 const checkOnly = async (bib: string) =>
-  (await onlineReferences(bib, EMPTY_LOOKUP_CACHE)).check;
+  (await onlineReferences(read(bib), EMPTY_LOOKUP_CACHE)).check;
 
 afterEach(() => {
   vi.unstubAllGlobals();
@@ -131,23 +137,75 @@ test("each entry gets its existence and its authors: confirmed, fabricated, mism
   );
 });
 
-test("an author finding names what is extra and what is out of order; an entry only the author check read is unresolvable", async () => {
+test("one key in two databases bibtex opened: each entry gets its own verdict, in the order given", async () => {
+  vi.useFakeTimers();
+  fakeFetch({
+    "https://api.crossref.org/works/10.1%2Fgood": () =>
+      json(200, {
+        message: { title: ["Good Paper"], issued: { "date-parts": [[2024]] } },
+      }),
+    "https://doi.org/api/handles/10.1/good": () =>
+      json(200, { responseCode: 1 }),
+    "https://doi.org/api/handles/10.1/fake": () => json(404),
+    // Crossref knows nothing of the fake: a 404, not a refusal that would stop the run asking it.
+    "https://api.crossref.org/works/10.1%2Ffake": () => json(404),
+    "https://dblp.org/search/publ/api/?q=Good%20Paper": () =>
+      dblp("Good Paper", ["Ada Lovelace"]),
+    "https://api.crossref.org/": () => json(200),
+    "https://dblp.org/": () => json(200, {}),
+  });
+  // Two databases of one `\bibliography`: both define `k` (bibtex takes the first), and only one
+  // copy fails — its existence, or its authors. The failing verdict is the failing copy's own.
+  const good =
+    "@inproceedings{k, author={Ada Lovelace}, title={Good Paper}, booktitle={ICSE}, doi={10.1/good}}";
+  const fake =
+    "@inproceedings{k, author={Ada Lovelace}, title={Fake Paper}, booktitle={ICSE}, doi={10.1/fake}}";
+  const drift =
+    "@inproceedings{k, author={Ada Lovelace and Alan Turing}, title={Good Paper}, booktitle={ICSE}, doi={10.1/good}}";
+  const verdicts = async (bib: string) => {
+    const r = await settle(checkOnly(bib));
+    return (r.kind === "checked" ? r.entries : []).map((e) => [
+      e.key,
+      e.exists,
+      e.authors,
+    ]);
+  };
+  assert.deepEqual(
+    [
+      await verdicts(`${good}\n${fake}`),
+      await verdicts(`${fake}\n${good}`),
+      await verdicts(`${good}\n${drift}`),
+    ],
+    [
+      [
+        ["k", "true", "match"],
+        ["k", "false", "skipped"],
+      ],
+      [
+        ["k", "false", "skipped"],
+        ["k", "true", "match"],
+      ],
+      [
+        ["k", "true", "match"],
+        ["k", "true", "mismatch"],
+      ],
+    ],
+  );
+});
+
+test("an author finding names what is extra and what is out of order", async () => {
   vi.useFakeTimers();
   fakeFetch({
     "https://dblp.org/search/publ/api/?q=Extra%20Paper": () =>
       dblp("Extra Paper", ["Ada Lovelace"]),
     "https://dblp.org/search/publ/api/?q=Swapped%20Paper": () =>
       dblp("Swapped Paper", ["Ada Lovelace", "Alan Turing"]),
-    "https://dblp.org/search/publ/api/?q=Comment%20Paper": () =>
-      dblp("Comment Paper", ["Grace Hopper"]),
     "https://dblp.org/": () => json(200, {}),
     "https://api.crossref.org/": () => json(200, { message: { items: [] } }),
   });
   const bib = [
     "@inproceedings{extra, author={Ada Lovelace and Grace Hopper}, title={Extra Paper}, booktitle={ICSE}}",
     "@inproceedings{swapped, author={Alan Turing and Ada Lovelace}, title={Swapped Paper}, booktitle={ICSE}}",
-    // verify-cites skips @comment blocks; bib-authors reads them — so only one checker sees this key.
-    "@comment{commented, author={Ada Lovelace}, title={Comment Paper}, booktitle={ICSE}}",
   ].join("\n");
   const r = await settle(checkOnly(bib));
   const why = Object.fromEntries(
@@ -165,10 +223,6 @@ test("an author finding names what is extra and what is out of order; an entry o
       "unresolvable",
       "not found by title in any database (no resolvable id to disprove) — could be a legit unindexed/regional/pre-digital work, NOT fabrication; order differs (DBLP: ICSE 2024)",
     ],
-    commented: [
-      "unresolvable",
-      "missing hopper; extra lovelace (DBLP: ICSE 2024)",
-    ],
   });
 });
 
@@ -208,7 +262,7 @@ test(
     slowFetch(40);
     const bib = manyBib(20);
     const serial: string[] = [];
-    for (const c of cites.parseBib(bib))
+    for (const c of cites.citationsOf(read(bib)))
       serial.push((await cites.verifyCitationLive(c, { cache: {} })).verdict);
     const t0 = Date.now();
     const r = await checkOnly(bib);
@@ -265,7 +319,7 @@ const answering = () =>
 async function cold(bib: string) {
   vi.useFakeTimers();
   answering();
-  return settle(cached(bib, EMPTY_LOOKUP_CACHE));
+  return settle(cached(read(bib), EMPTY_LOOKUP_CACHE));
 }
 
 test("cold: every answer is stored with the day it was fetched — responses, never verdicts", async () => {
@@ -324,7 +378,7 @@ test("🔴 warm: a fully cached bibliography asks NOTHING — no lookup, no reac
   // Fake timers with NO advancing: a single DBLP pause would never resolve and time the test out.
   vi.useFakeTimers();
   const calls = fakeFetch({});
-  const second = await cached(bib, first.cache);
+  const second = await cached(read(bib), first.cache);
   assert.deepEqual(
     // Nothing fetched, so the cache comes back as the very object passed in — nothing to write.
     { calls, check: second.check, sameCache: second.cache === first.cache },
@@ -338,7 +392,7 @@ test("🔴 one entry edited: only that entry is asked again, and the old answers
   vi.useFakeTimers();
   const calls = answering();
   const edited = PAPERS.join("\n").replace("Other Paper", "Renamed Paper");
-  const second = await settle(cached(edited, first.cache));
+  const second = await settle(cached(read(edited), first.cache));
   assert.deepEqual(
     {
       // The lookups run concurrently, so the order of requests is not the subject.
@@ -373,14 +427,14 @@ test("an answer older than 30 days is asked again and re-dated; at 30 days it is
   vi.useFakeTimers();
   const quiet = fakeFetch({});
   const at30 = await referencesChecker({ today: () => "2026-10-27" })(
-    bib,
+    read(bib),
     first.cache,
   );
   vi.useRealTimers();
   vi.useFakeTimers();
   const calls = answering();
   const at31 = await settle(
-    referencesChecker({ today: () => "2026-10-28" })(bib, first.cache),
+    referencesChecker({ today: () => "2026-10-28" })(read(bib), first.cache),
   );
   assert.deepEqual(
     {
@@ -408,7 +462,7 @@ test("a failed lookup is not cached: the next run asks it again", async () => {
     "https://dblp.org/": () => json(500),
   });
   const bib = PAPERS[1];
-  const r = await settle(cached(bib, EMPTY_LOOKUP_CACHE));
+  const r = await settle(cached(read(bib), EMPTY_LOOKUP_CACHE));
   const failed: LookupCache = r.cache;
   assert.deepEqual(
     {
@@ -423,7 +477,7 @@ test("offline with an incomplete cache: not-checked, and the cache comes back un
   vi.stubGlobal("fetch", () =>
     Promise.reject(new Error("getaddrinfo ENOTFOUND api.crossref.org")),
   );
-  const r = await cached(PAPERS[0], EMPTY_LOOKUP_CACHE);
+  const r = await cached(read(PAPERS[0]), EMPTY_LOOKUP_CACHE);
   assert.deepEqual(r, {
     check: {
       kind: "not-checked",
@@ -461,7 +515,7 @@ test("🔴 #120: DBLP answering HTML is asked ONCE — no retries, no pause —
     () => new Response("<!doctype html><title>429</title>"),
     () => json(429),
   );
-  const { check } = await cached(PUBLISHED, EMPTY_LOOKUP_CACHE);
+  const { check } = await cached(read(PUBLISHED), EMPTY_LOOKUP_CACHE);
   const entries = check.kind === "checked" ? check.entries : [];
   assert.deepEqual(
     {
@@ -507,14 +561,14 @@ test("#120: a DBLP 429 trips it as well; DBLP answering keeps its 900 ms pace be
     () => json(429),
     () => json(200, { data: [] }),
   );
-  await cached(PUBLISHED, EMPTY_LOOKUP_CACHE);
+  await cached(read(PUBLISHED), EMPTY_LOOKUP_CACHE);
   vi.useRealTimers();
   vi.useFakeTimers();
   const answering = refusing(
     () => dblp("First Paper", ["Ada Lovelace"]),
     () => json(200, { data: [] }),
   );
-  const pending = cached(PUBLISHED, EMPTY_LOOKUP_CACHE);
+  const pending = cached(read(PUBLISHED), EMPTY_LOOKUP_CACHE);
   // One compared entry, then the pause: without advancing time, the run cannot finish.
   let done = false;
   void pending.finally(() => (done = true));

package/src/adapters/references/index.ts

@@ -43,6 +43,7 @@ import type {
   AuthorFinding,
   BibEntry,
 } from "../../../skills/verify-citations/scripts/bib-authors.mjs";
+import { zip } from "remeda";
 import { messageOf } from "../../domain/text.ts";
 import { isRecord } from "../../domain/record.ts";
 
@@ -55,12 +56,13 @@ const describeAuthors = (f: AuthorFinding): string =>
     .filter(Boolean)
     .join("; ") + ` (DBLP: ${f.venue})`;
 
-const authorsOf = (key: string, a: AuthorBuckets): EntryVerdict["authors"] =>
-  a.findings.some((f) => f.key === key)
+/** bib-authors' answer for one entry, from its buckets for that entry alone. */
+const authorsOf = (a: AuthorBuckets): EntryVerdict["authors"] =>
+  a.findings.length > 0
     ? "mismatch"
-    : a.unchecked.some((u) => u.key === key)
+    : a.unchecked.length > 0
       ? "unchecked"
-      : a.matched.includes(key)
+      : a.matched.length > 0
         ? "match"
         : "skipped";
 
@@ -69,36 +71,45 @@ const authorsOf = (key: string, a: AuthorBuckets): EntryVerdict["authors"] =>
  * one, so "unresolvable" is not read as "every registry looked and found nothing". Nothing for a
  * confirmed work: a refusal after a confirmation changed nothing.
  */
-const unconfirmed = (
-  c: CiteVerdict | undefined,
-): readonly (string | undefined)[] =>
-  c && c.verdict !== "true"
+const unconfirmed = (c: CiteVerdict): readonly (string | undefined)[] =>
+  c.verdict !== "true"
     ? [c.reason, ...(c.refused ?? []).map((r) => `not asked: ${r}`)]
     : [];
 
-/** One entry's verdict from the two checkers' answers. */
-function entryVerdict(
-  key: string,
-  found: readonly CiteVerdict[],
-  a: AuthorBuckets,
-): EntryVerdict {
-  const c = found.find((x) => x.id === key);
-  const mismatch = a.findings.find((f) => f.key === key);
+/** One entry's verdict: verify-cites' answer for it, and bib-authors' buckets for it alone. */
+function entryVerdict(c: CiteVerdict, a: AuthorBuckets): EntryVerdict {
   const why = [
     ...unconfirmed(c),
-    mismatch ? describeAuthors(mismatch) : undefined,
-    a.unchecked.find((u) => u.key === key)?.why,
+    ...a.findings.map(describeAuthors),
+    ...a.unchecked.map((u) => u.why),
   ]
     .filter(Boolean)
     .join("; ");
   return {
-    key,
-    exists: c?.verdict ?? "unresolvable",
-    authors: authorsOf(key, a),
+    key: c.id,
+    exists: c.verdict,
+    authors: authorsOf(a),
     ...(why ? { why } : {}),
   };
 }
 
+/**
+ * bib-authors over each entry on its own, one after another as it would run them: its buckets name
+ * an entry by key, and two entries of a bibliography may share a key (two databases bibtex
+ * opened may each define it, with other metadata).
+ */
+const authorsOfEach = (
+  parsed: readonly BibEntry[],
+  d: Pick<ReturnType<typeof cachedDblp>, "lookup" | "pause">,
+): Promise<readonly AuthorBuckets[]> =>
+  parsed.reduce<Promise<readonly AuthorBuckets[]>>(
+    async (done, e) => [
+      ...(await done),
+      await authors.checkAuthors([e], { lookup: d.lookup, pause: d.pause }),
+    ],
+    Promise.resolve([]),
+  );
+
 /** Whether bib-authors will ask DBLP about this entry — the filter its `checkAuthors` applies. */
 const asksDblp = (e: BibEntry): boolean =>
   Boolean(e.title && e.author) &&
@@ -212,8 +223,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);
-    const parsed = authors.parseBib(bib);
+    const citations = cites.citationsOf(bib);
+    const parsed = authors.authorEntries(bib);
     const store: Record<string, unknown> = Object.fromEntries(
       [...usable.citations].map(([k, v]) => [k, v.response]),
     );
@@ -237,16 +248,10 @@ export const referencesChecker =
           breaker,
         }),
       ),
-      authors.checkAuthors(parsed, {
-        lookup: d.lookup,
-        pause: d.pause,
-      }),
-    ]);
-    const keys = new Set([
-      ...found.map((c) => c.id),
-      ...a.findings.map((f) => f.key),
+      authorsOfEach(parsed, d),
     ]);
-    const entries = [...keys].map((key) => entryVerdict(key, found, a));
+    // Both lists are one per entry, in its order: so is the verdict list.
+    const entries = zip(found, a).map(([c, b]) => entryVerdict(c, b));
     return {
       check: { kind: "checked", entries },
       cache: grown({ cache, usable }, { store, dblp: d.dblp }, today),