paperlint 8.0.0 → 9.0.0

package/src/references.ts

@@ -8,14 +8,16 @@
  * "bib-authors" in a scorecard table, or a command the project configured. Now the build runs
  * them and records the result as data, beside the facts it already writes about the PDF:
  *
- *   { "schema": 1,
- *     "bib": { "source": "paper.tex", "sha256": "…" },       the bibliography that was checked
+ *   { "schema": 3,
+ *     "bib": { "sources": ["refs.bib"], "sha256": "…" },     the databases that were checked, as
+ *                                                            bibtex names them, and a hash of their text
  *     "status": "checked" | "not-checked", "why": "…",       not-checked: nothing could be asked
  *     "entries": [ { "key", "exists", "authors", "why" } ] }
+ *                                                            one per entry checked, in its order
  *
  * A sibling file, not a new field of `paper.facts.json`: those facts are about ONE PDF and are
- * stale when it changes (`pdf_sha256`); these are about the bibliography and are stale when IT
- * changes (`bib.sha256`). One staleness key per file, the way `pdf/fresh` already works.
+ * stale when it changes (`pdf_sha256`); these are about the databases and are stale when THEY
+ * change (`bib.sha256`). One staleness key per file, the way `pdf/fresh` already works.
  *
  * 🔴 WHAT THE CHECKERS ANSWERED IS KEPT, COMMITTED, IN `<paper>/repro/references-cache.json`
  * (`domain/lookup-cache.ts`). Loaded before the check and saved after it — only when something new
@@ -23,6 +25,18 @@
  * MAX_AGE_DAYS, not once per build (#107: 217 s for 27 references, every build). The verdicts above are NOT cached: they are derived from the cached
  * answers on every build, so a fix to the checkers reaches every paper at once.
  *
+ * ── WHICH DATABASES, AND WHAT BIBTEX TYPESET ───────────────────────────────────────────
+ * The databases checked are the ones the build's bibtex OPENED (`_build/sources.json`, written by
+ * `sources-record.ts` from TeX's own files; docs/design/paper-sources.md §1) — nothing here reads
+ * TeX source to decide which. Their entries are read by the one bibtex reader. bibtex reads
+ * differently from it in one place: it has no comment syntax, so an entry behind `%` or inside
+ * `@comment{…}` is one it typesets and the reader does not see. The record holds the keys bibtex
+ * typeset, so `paper/refs-checked` names the ones no entry of those databases has (`unseenKeys`).
+ * A malformed `.bib` never gets here: bibtex fails on it, and the build fails with bibtex's own lines.
+ *
+ * Without a record of the build, or with one the paper has changed since, there is no answer to
+ * "which databases": the step checks nothing, and the rules are silent — `paper/sources-fresh` speaks.
+ *
  * 🔴 THE STEP NEVER FAILS THE BUILD. A build without network still builds the PDF; the reference
  * step records `not-checked` and the lint rule says so, as a warning. Recording "not checked" as
  * a pass would be the counter that counts what it never looked at.
@@ -44,10 +58,22 @@ import type {
   ReferencesCheck,
   ReferencesRun,
 } from "./ports/check-references.ts";
-import { bibRange } from "#eslint-rules/paper-typography";
 import { messageOf } from "./domain/text.ts";
+import {
+  describeChanges,
+  type SourcesRecord,
+} from "./domain/sources-record.ts";
+import type { PaperRecord } from "./paper-record.ts";
+import {
+  entriesOfDatabases,
+  recordedBibliography,
+  type ReadDatabase,
+  type RecordedEntry,
+  type RecordedReadDeps,
+} from "./recorded-bibliography.ts";
 
-export const REFERENCES_SCHEMA = 1;
+/** 3: the record of what bibtex read lives in `_build/sources.json`; an older one reads as none. */
+export const REFERENCES_SCHEMA = 3;
 export const REFERENCES_FILE = "references.json";
 
 /** The lookup cache's place in a paper: committed, beside the paper's other reproduction files. */
@@ -65,44 +91,127 @@ const text = (files: Files, p: string): string | null => {
   return b === null ? null : new TextDecoder().decode(b);
 };
 
-/** The bibliography a paper carries: inside `paper.tex` (`filecontents`), else `refs.bib`. */
-export interface Bibliography {
-  readonly source: "paper.tex" | "refs.bib";
-  readonly text: string;
-  /** Where `text` starts in the source file — so a finding can point at an entry. */
-  readonly offset: number;
+/** `xs` without the elements whose `key` an earlier one has, in order. */
+const distinctBy = <T>(xs: readonly T[], key: (x: T) => string): readonly T[] =>
+  xs.filter((x, i) => xs.findIndex((o) => key(o) === key(x)) === i);
+
+/**
+ * The bibliography the build checks: the databases bibtex opened, in the order it opened them, and
+ * their entries as the bibtex reader read them. The verdicts are recorded one per entry, in this
+ * order: a verdict is about an entry, not about its key.
+ */
+export interface CheckedBibliography {
+  /** The build's record these databases were read from. */
+  readonly record: SourcesRecord;
+  readonly databases: readonly [ReadDatabase, ...ReadDatabase[]];
+  readonly entries: readonly RecordedEntry[];
+  /** The keys bibtex typeset, in the order it did: the `.bbl`'s `\bibitem`s. */
+  readonly typeset: readonly string[];
 }
 
-export function bibliographyOf(
-  files: Files,
-  paperDir: string,
-): Bibliography | null {
-  const tex = text(files, join(paperDir, "paper.tex"));
-  const inline = tex === null ? null : bibRange(tex);
-  if (inline)
-    return { source: "paper.tex", text: inline.body, offset: inline.bodyStart };
-  const bib = text(files, join(paperDir, "refs.bib"));
-  return bib === null ? null : { source: "refs.bib", text: bib, offset: 0 };
+/** What reading the bibliography takes: the record's readers, and the bibtex reader. */
+export type BibliographyDeps = RecordedReadDeps;
+
+/** What a paper's record comes to for the references. */
+export type BibliographyRead =
+  | { readonly kind: "read"; readonly bibliography: CheckedBibliography }
+  /** No record of the build, an unreadable one, or one the paper has changed since. */
+  | {
+      readonly kind: "no-record";
+      readonly record: Exclude<PaperRecord, { readonly kind: "fresh" }>;
+    }
+  /** bibtex opened no database: the build ran none, or the paper names none. */
+  | { readonly kind: "nothing" }
+  /** Databases bibtex opened that are not in the paper directory: it found them on its search path. */
+  | { readonly kind: "unread"; readonly databases: readonly string[] }
+  /** The build was not given a reader. */
+  | { readonly kind: "not-wired" };
+
+/**
+ * The bibliography the build recorded for the paper in `dir`: the databases bibtex opened, read by
+ * the bibtex reader. Only a fresh record answers (`paperRecord`).
+ */
+export function readBibliography(
+  dir: string,
+  deps: BibliographyDeps,
+): BibliographyRead {
+  const rec = recordedBibliography(dir, deps);
+  if (rec.kind === "unrecorded")
+    return { kind: "no-record", record: rec.record };
+  if (rec.unread.length > 0) return { kind: "unread", databases: rec.unread };
+  const [first, ...rest] = rec.databases;
+  const bibtex = rec.record.bibtex;
+  if (first === undefined || !bibtex.ran) return { kind: "nothing" };
+  return {
+    kind: "read",
+    bibliography: {
+      record: rec.record,
+      databases: [first, ...rest],
+      entries: entriesOfDatabases(rec.databases),
+      typeset: bibtex.keys,
+    },
+  };
+}
+
+/** A paper's bibliography by its directory — what the build's steps are handed by the composition root. */
+export type ReadBibliography = (dir: string) => BibliographyRead;
+
+/** `readBibliography` over `deps`, as a `ReadBibliography`. */
+export const bibliographyReader =
+  (deps: BibliographyDeps): ReadBibliography =>
+  (dir) =>
+    readBibliography(dir, deps);
+
+/** No reader: the build was not given one. Never "no bibliography" — it says so. */
+export const notWiredBibliography: ReadBibliography = () => ({
+  kind: "not-wired",
+});
+
+/**
+ * The keys bibtex typeset that no entry the reader read has — an entry behind `%` or inside
+ * `@comment{…}`, which bibtex reads and the reader does not. In the order bibtex typeset them, each
+ * once. bibtex's keys are case-insensitive (`\cite{SMITH}` typesets `\bibitem{SMITH}` from an entry
+ * `smith`, measured), so they are compared so.
+ */
+export function unseenKeys(b: CheckedBibliography): readonly string[] {
+  const read = new Set(b.entries.map((e) => e.entry.key.toLowerCase()));
+  return distinctBy(
+    b.typeset.filter((k) => !read.has(k.toLowerCase())),
+    (k) => k.toLowerCase(),
+  );
 }
 
-export const bibHash = (b: Bibliography): string =>
-  sha256Hex(new TextEncoder().encode(b.text));
+/** The bytes of the databases checked, in order: what a later lint compares to see the verdicts are current. */
+export const bibHash = (b: CheckedBibliography): string =>
+  sha256Hex(
+    new TextEncoder().encode(
+      b.databases
+        .map((d) => d.bib.text.slice(d.bib.body.start, d.bib.body.end))
+        .join("\n"),
+    ),
+  );
 
 /** What `_build/references.json` holds. */
 export interface ReferencesDocument {
   readonly schema: number;
-  readonly bib: { readonly source: string; readonly sha256: string };
+  readonly bib: {
+    readonly sources: readonly string[];
+    readonly sha256: string;
+  };
   readonly status: "checked" | "not-checked";
   readonly why?: string;
   readonly entries: readonly EntryVerdict[];
 }
 
 export const documentOf = (
-  bib: Bibliography,
+  bib: CheckedBibliography,
   check: ReferencesCheck,
 ): ReferencesDocument => ({
   schema: REFERENCES_SCHEMA,
-  bib: { source: bib.source, sha256: bibHash(bib) },
+  bib: {
+    sources: bib.databases.map((d) => d.name),
+    sha256: bibHash(bib),
+  },
   ...(check.kind === "checked"
     ? { status: "checked" as const, entries: check.entries }
     : { status: "not-checked" as const, why: check.why, entries: [] }),
@@ -156,32 +265,66 @@ const newAnswers = (before: LookupCache, after: LookupCache): number => {
   );
 };
 
-/** Run the checker; a throw is `not-checked`, with the cache as it was. */
+/** Run the checker over the bibliography's entries; a throw is `not-checked`, with the cache as it was. */
 async function run(
   check: CheckReferences,
-  bib: string,
+  bib: CheckedBibliography,
   cache: LookupCache,
 ): Promise<ReferencesRun> {
   try {
-    return await check(bib, cache);
+    return await check(
+      bib.entries.map((f) => f.entry),
+      cache,
+    );
   } catch (e) {
     return { check: { kind: "not-checked", why: messageOf(e) }, cache };
   }
 }
 
+/** Why the build's record cannot say which databases were read, in the words a note carries. */
+function noRecord(
+  r: Extract<BibliographyRead, { readonly kind: "no-record" }>["record"],
+): string {
+  switch (r.kind) {
+    case "none":
+      return r.unreadable === null
+        ? "the build recorded no sources (_build/sources.json was not written)"
+        : `_build/sources.json cannot be used (${r.unreadable})`;
+    case "stale":
+      return `the paper changed since the build recorded it (${describeChanges(r.changed)})`;
+  }
+}
+
+/** The note for a paper whose bibliography was not read. */
+function unreadNote(
+  read: Exclude<BibliographyRead, { readonly kind: "read" }>,
+): string {
+  switch (read.kind) {
+    case "no-record":
+      return `references NOT checked — ${noRecord(read.record)}; lint will say so`;
+    case "nothing":
+      return "no bibliography database — bibtex opened none, nothing to check";
+    case "unread":
+      return `references NOT checked — ${read.databases.join(", ")}, which bibtex opened, is not in the paper directory; lint will say so`;
+    case "not-wired":
+      return "references NOT checked — no bibliography reader was wired into this build; lint will say so";
+  }
+}
+
 /**
- * The build step's work: check the bibliography, serving what it can from the paper's lookup
- * cache, and record the verdicts. Returns the one-line note the build prints. A checker that
- * throws, or a cache that does not parse, is recorded as `not-checked` — the step reports, it
- * never refuses. A cache that does not parse is left as it is, and named.
+ * The build step's work: check the bibliography the build recorded, serving what it can from the
+ * paper's lookup cache, and record the verdicts. Returns the one-line note the build prints. A
+ * checker that throws, or a cache that does not parse, is recorded as `not-checked` — the step
+ * reports, it never refuses. A cache that does not parse is left as it is, and named.
  */
 export async function recordReferences(
   files: Files,
   paperDir: string,
+  read: BibliographyRead,
   check: CheckReferences,
 ): Promise<string> {
-  const bib = bibliographyOf(files, paperDir);
-  if (bib === null) return "no bibliography — nothing to check";
+  if (read.kind !== "read") return unreadNote(read);
+  const bib = read.bibliography;
   const record = (c: ReferencesCheck): ReferencesDocument => {
     const doc = documentOf(bib, c);
     files.writeAtomic(
@@ -199,7 +342,7 @@ export async function recordReferences(
     return notChecked(
       `${LOOKUP_CACHE_FILE} cannot be read (${cache.error}) — fix it, or delete it to ask every question again`,
     );
-  const result = await run(check, bib.text, cache.value);
+  const result = await run(check, bib, cache.value);
   if (result.check.kind === "not-checked") return notChecked(result.check.why);
   const doc = record(result.check);
   const fetched = newAnswers(cache.value, result.cache);
@@ -208,6 +351,11 @@ export async function recordReferences(
       callerPath(lookupCachePath(paperDir)),
       new TextEncoder().encode(serializeLookupCache(result.cache)),
     );
+  return summary(doc, fetched);
+}
+
+/** The note a checked run prints: how many entries, how many failing, what was fetched. */
+function summary(doc: ReferencesDocument, fetched: number): string {
   const bad = doc.entries.filter(
     (e) => e.exists === "false" || e.authors === "mismatch",
   ).length;

package/src/register-bands.test.ts

@@ -17,6 +17,7 @@ import { fileURLToPath } from "node:url";
 import { describe, expect, it } from "vitest";
 import { latexReader } from "./adapters/latex/index.ts";
 import { nodeFiles } from "./adapters/node/index.ts";
+import { sourcesCodec } from "./adapters/sources-record/index.ts";
 import {
   bandOf,
   rateOf,
@@ -36,6 +37,7 @@ import {
   standingOf,
 } from "./register-bands.ts";
 import { readPaper } from "./tex-paper.ts";
+import { withRecord } from "../test/recorded-fixture.ts";
 import { useTempDir, writeTree } from "../test/support.ts";
 
 const ROOT = dirname(dirname(fileURLToPath(import.meta.url)));
@@ -56,8 +58,9 @@ const aidc = (() => {
 const sourceOf = (paper: string): string => {
   const file = join(CORPUS, paper, "paper.tex");
   return readPaper(file, readFileSync(file, "utf8"), {
-    files: nodeFiles,
+    files: withRecord(nodeFiles, join(CORPUS, paper)),
     latex: latexReader,
+    codec: sourcesCodec,
   }).text;
 };
 
@@ -286,6 +289,7 @@ describe("the rules, as ESLint calls them", () => {
       files: nodeFiles,
       venuesDir: presetsDir(),
       latex: latexReader,
+      codec: sourcesCodec,
     };
     registerBandRules(deps)
       [rule].create({

package/src/register-bands.ts

@@ -40,7 +40,7 @@ import type { Emphasis, Passage, Span } from "./domain/tex-document.ts";
 import type { LatexReader } from "./ports/latex.ts";
 import { paperPreset } from "./presets.ts";
 import { MIN_WORDS, startOf } from "./register.ts";
-import { readPaper, reportInPaper } from "./tex-paper.ts";
+import { readPaper, reportInPaper, type ProseDeps } from "./tex-paper.ts";
 import {
   ruleDocsUrl,
   type Located,
@@ -49,10 +49,8 @@ import {
 } from "./tex-venue-rules.ts";
 import type { VenueRuleDeps } from "./venue-rules.ts";
 
-/** What the three rules read: the preset store, and the LaTeX reader. */
-export interface RegisterBandDeps extends VenueRuleDeps {
-  readonly latex: LatexReader;
-}
+/** What the three rules read: the preset store, the LaTeX reader, and the paper's files as the build recorded them. */
+export interface RegisterBandDeps extends VenueRuleDeps, ProseDeps {}
 
 export type RegisterBandRuleName =
   "contrast-frames" | "claim-emphasis" | "relation-markers";

package/src/register.test.ts

@@ -7,6 +7,7 @@
 import { describe, expect, it } from "vitest";
 import { latexReader } from "./adapters/latex/index.ts";
 import { memoryFiles } from "./adapters/memory/index.ts";
+import { sourcesCodec } from "./adapters/sources-record/index.ts";
 import {
   judgeRegister,
   measureRegister,
@@ -125,7 +126,11 @@ describe("the rule — reported at the start of the body, the option read from t
   }
   const run = (src: string, options?: readonly unknown[]): Seen[] => {
     const seen: Seen[] = [];
-    registerRule({ files: memoryFiles({}), latex: latexReader })
+    registerRule({
+      files: memoryFiles({}),
+      latex: latexReader,
+      codec: sourcesCodec,
+    })
       .create({
         filename: "/p/paper.tex",
         ...(options === undefined ? {} : { options }),

package/src/register.ts

@@ -17,7 +17,7 @@
  */
 import type { Passage, Span } from "./domain/tex-document.ts";
 import { bodySentences, wordsOf } from "./domain/register.ts";
-import { readPaper, reportInPaper, type PaperDeps } from "./tex-paper.ts";
+import { readPaper, reportInPaper, type ProseDeps } from "./tex-paper.ts";
 import {
   ruleDocsUrl,
   type Located,
@@ -125,7 +125,7 @@ const META: TexRuleModule["meta"] = {
 };
 
 /** The rule, over the body's prose of the whole paper, its includes spliced (`readPaper`). */
-export const registerRule = (deps: PaperDeps): TexRuleModule => ({
+export const registerRule = (deps: ProseDeps): TexRuleModule => ({
   meta: META,
   create(context) {
     return {

package/src/rule-cases.test.ts

@@ -17,7 +17,7 @@ import { describe, expect, it } from "vitest";
 import { z } from "zod";
 import { run, rulePlugins } from "./cli.ts";
 import { sha256Hex } from "./domain/sha256.ts";
-import { bibHash } from "./references.ts";
+import { recordText } from "../test/recorded-fixture.ts";
 import { useTempDir, venuePreset, writeTree } from "../test/support.ts";
 
 const ROOT = dirname(dirname(fileURLToPath(import.meta.url)));
@@ -172,32 +172,84 @@ const built = (
 
 const BIB =
   "@article{a,\n  title = {A},\n  author = {Doe, J.},\n  year = {2026},\n  doi = {10.1/x}\n}\n";
-const sha = bibHash({ source: "refs.bib", text: BIB, offset: 0 });
-/** A paper citing refs.bib, with its references record (`status`, `entries`) or none. */
+/** The hash the build records for a bibliography that is BIB alone (`bibHash` over its one text). */
+const sha: string = sha256Hex(new TextEncoder().encode(BIB));
+/** The paper `cited` builds: it cites refs.bib. */
+const CITING = tex("See~\\cite{a}.\n\\bibliography{refs}");
+const digest = (text: string): string =>
+  sha256Hex(new TextEncoder().encode(text));
+/**
+ * A paper citing refs.bib that was built — TeX read paper.tex, bibtex opened refs.bib and typeset `a`
+ * — with its references record (`status`, `entries`) or none.
+ */
 const cited = (
   body: Record<string, unknown> | null,
   bibSha = sha,
 ): Record<string, string> =>
-  paper(tex("See~\\cite{a}.\n\\bibliography{refs}"), {
+  paper(CITING, {
     [`${P}/refs.bib`]: BIB,
+    [`${P}/_build/sources.json`]: JSON.stringify({
+      schema: 1,
+      inputs: [{ path: "paper.tex", role: "body" }],
+      written: [],
+      bibdata: ["refs"],
+      bibtex: {
+        ran: true,
+        databases: ["refs.bib"],
+        keys: ["a"],
+        exit: 0,
+        errors: [],
+      },
+      sha256: { "paper.tex": digest(CITING), "refs.bib": digest(BIB) },
+    }),
     ...(body === null
       ? {}
       : {
           [`${P}/_build/references.json`]: JSON.stringify({
-            schema: 1,
-            bib: { source: "refs.bib", sha256: bibSha },
+            schema: 3,
+            bib: { sources: ["refs.bib"], sha256: bibSha },
             ...body,
           }),
         }),
   });
-/** A paper whose bibliography is written inline, by `filecontents*`, as `bib/reachable-entry` reads it. */
+/** A paper whose bibliography is written inline, by `filecontents*[overwrite]`. */
 const inlineBib = (entry: string): string =>
-  `\\documentclass{article}\n\\begin{filecontents*}{refs.bib}\n${entry}\n\\end{filecontents*}\n\\begin{document}\nSee~\\cite{a}.\n\\bibliography{refs}\n\\end{document}\n`;
+  `\\documentclass{article}\n\\begin{filecontents*}[overwrite]{refs.bib}\n${entry}\n\\end{filecontents*}\n\\begin{document}\nSee~\\cite{a}.\n\\bibliography{refs}\n\\end{document}\n`;
+/** That paper as a build leaves it: the `.bib` TeX wrote from the block, and the record of the build. */
+const inlineBuilt = (entry: string): Record<string, string> => {
+  const paperTex = inlineBib(entry);
+  return paper(paperTex, {
+    [`${P}/refs.bib`]: `${entry}\n`,
+    [`${P}/_build/sources.json`]: recordText(
+      { "paper.tex": paperTex, "refs.bib": `${entry}\n` },
+      {
+        inputs: [["paper.tex", "body"]],
+        written: ["refs.bib"],
+        databases: ["refs.bib"],
+      },
+    ),
+  });
+};
 const checked = (exists: string, authors: string) => ({
   status: "checked",
   entries: [{ key: "a", exists, authors }],
 });
 
+// ── the build's record of the sources: what `paperlint build` would write after TeX read paper.tex ───
+
+/** A paper that was built: the record of its one file, hashed as it stands. */
+const sourced = (paperTex: string): Record<string, string> =>
+  paper(paperTex, {
+    [`${P}/_build/sources.json`]: JSON.stringify({
+      schema: 1,
+      inputs: [{ path: "paper.tex", role: "body" }],
+      written: [],
+      bibdata: [],
+      bibtex: { ran: false },
+      sha256: { "paper.tex": sha256Hex(new TextEncoder().encode(paperTex)) },
+    }),
+  });
+
 // ── a BlindConf paper, for the LaTeX venue rules ──────────────────────────────────────────────
 
 const BLIND_PAPER = onBlindConf(P);
@@ -517,7 +569,7 @@ const CASES: Readonly<Record<string, RuleCases>> = {
       tree: cited(checked("true", "mismatch")),
       file: TEX_FILE,
       severity: 2,
-      line: 1,
+      line: 1, // refs.bib is a file the author keeps: the top of paper.tex, naming it
     },
     silent: cited(checked("true", "match")),
   },
@@ -526,7 +578,7 @@ const CASES: Readonly<Record<string, RuleCases>> = {
       tree: cited(checked("false", "match")),
       file: TEX_FILE,
       severity: 2,
-      line: 1,
+      line: 1, // refs.bib is a file the author keeps: the top of paper.tex, naming it
     },
     silent: cited(checked("true", "match")),
   },
@@ -543,6 +595,10 @@ const CASES: Readonly<Record<string, RuleCases>> = {
     },
     silent: cited(checked("true", "match")),
   },
+  "paper/sources-fresh": {
+    reports: { tree: paper(tex("x")), file: TEX_FILE, severity: 1, line: 1 },
+    silent: sourced(tex("x")),
+  },
   "review/frontmatter": {
     reports: {
       tree: paper(tex("x"), {
@@ -697,12 +753,12 @@ const CASES: Readonly<Record<string, RuleCases>> = {
   },
   "bib/reachable-entry": {
     reports: {
-      tree: paper(inlineBib("@book{a,\n  title = {A},\n  year = {2026}\n}")),
+      tree: inlineBuilt("@book{a,\n  title = {A},\n  year = {2026}\n}"),
       file: TEX_FILE,
       severity: 1,
       line: 3,
     },
-    silent: paper(inlineBib(BIB)),
+    silent: inlineBuilt(BIB.trimEnd()),
   },
   "pdf/fresh": {
     reports: onPdf(built({ pdf_sha256: "0".repeat(64) })),

package/src/rule-docs.test.ts

@@ -19,7 +19,6 @@ const PAGES = "https://github.com/zernie/paperlint/blob/main/";
 
 /** Rules shipped before per-rule pages, each waiting for its page in #131. Only ever shrinks. */
 const AWAITING_PAGE: ReadonlySet<string> = new Set([
-  "bib/reachable-entry",
   "paper/author-list",
   "paper/cite-exists",
   "paper/figure-ref-style",