paperlint 7.2.0 → 9.0.0

package/skills/verify-citations/scripts/bib-authors.mjs

@@ -43,200 +43,60 @@
  * Usage:  node bib-authors.mjs <paper-dir-or-.bib-or-.tex> [--json]
  * Exit:   0 = no author-set/order differences   1 = differences found   2 = usage/IO error
  */
-import { readFileSync, existsSync, readdirSync } from "node:fs";
-import { join, extname } from "node:path";
-import { headings as mdHeadings, requireMarkdown } from "#lib/markdown";
+import { resolve } from "node:path";
+import { latexReader } from "#src/adapters/latex/index";
+import { nodeFiles } from "#src/adapters/node/index";
+import { sourcesCodec } from "#src/adapters/sources-record/index";
+import { absolutePath } from "#src/domain/paths";
+import { bibReader } from "#src/adapters/bibtex/index";
+import { bibliographyAt, bibliographyUnreadWhy } from "#src/paper-sources";
 import { isMain } from "../../paper-pipeline/scripts/consumer.mjs";
 
 const DBLP = "https://dblp.org/search/publ/api";
 
-/* ---------- input: a .bib, a .tex with filecontents, or a paper dir ---------- */
+/* ---------- input: the bibliography TeX reads, or a .bib named ---------- */
+
+const DEPS = {
+  files: nodeFiles,
+  codec: sourcesCodec,
+  latex: latexReader,
+  bib: bibReader,
+};
 
 /**
- * Some papers carry no BibTeX at all. `compile-rules-2026` writes its 67 references as a
- * hand-numbered markdown list that `repro/md2acl.py` turns into ACL format at build time:
- *
- *   12. N. F. Liu, K. Lin, J. Hewitt. *Lost in the Middle: How Language Models Use Long
- *       Contexts.* TACL, 2024. arXiv:2307.03172.
- *
- * 🔴 Exempting such a paper would be the wrong call, and measurably so: a hand-written author
- * list has NO machine-checkable source, so it is the MORE exposed of the two formats, not the
- * less. The class this script hunts lives exactly where an entry names a published venue and an
- * arXiv id in the same breath — which is most of this list.
- *
- * Authors are taken only from the text BEFORE the first `*`, on purpose: entries here sometimes
- * append a second work ("— and the reanalysis: S. B. Hossain, ...") after the title, and folding
- * those names in would invent co-authors that the first work does not have.
+ * The texts to read: a `.bib` as named; for a paper directory or a `.tex`, the databases the last
+ * build's bibtex opened (`_build/sources.json`) — `bibliographyAt` (src/paper-sources.ts) answers, and
+ * refuses in its words, "run `npx paperlint build` first" among them.
  */
-export function parseMarkdownRefs(text) {
-  // 🔴 The heading comes FROM THE PARSER, not from a regex (the base's rule "parse markdown with a
-  // parser"). The previous `text.search(/^#+\s*References\s*$/m)` opened the bibliography on a
-  // `## References` line QUOTED inside a ``` fence — and the papers in this repo quote their own
-  // markup in chunks. Exactly this assert already stands at a neighbour
-  // (`paper-pipeline/scripts/extract-ref-facts.harness.mjs`: "a heading inside a ``` block is not a
-  // heading"), that is, the class was known and was being reproduced here again.
-  // `requireMarkdown()` — so that a missing markdown-it fails LOUDLY: with an empty parser
-  // `headings()` returns [], and the gate would report "no references" instead of refusing. That is
-  // the same trade of one silent failure for another that the rule was written against.
-  requireMarkdown();
-  const h = mdHeadings(text).find((x) => /^References\s*$/u.test(x.text));
-  if (!h) return [];
-  const body = text.slice(h.offset);
-  const out = [];
-  // 🔴 `$(?![\s\S])`, NOT `\Z`. JavaScript has no `\Z` anchor — outside a unicode-mode pattern it
-  // is an identity escape meaning the LETTER Z, so the first version of this lookahead ended entry
-  // 1 in the middle of "J. Zhou", at the Z. Measured: 48 of 67 references parsed, and the missing
-  // 19 looked like ordinary gaps rather than a bug. Same family as the `\b`-over-Cyrillic defect
-  // already recorded in this repo: an escape that means one thing in Perl/Python and another here.
-  const re = /^(\d+)\.[ \t]+([\s\S]*?)(?=^\d+\.[ \t]|^#|$(?![\s\S]))/gm;
-  let m;
-  while ((m = re.exec(body))) {
-    const entry = m[2].replace(/\s*\n\s*/g, " ").trim();
-    const t = entry.match(/\*([^*]+)\*/);
-    if (!t) {
-      // No italic title and no author list — in this corpus these are SOFTWARE references
-      // (npm packages, repos). Nothing for DBLP to disagree with. They are surfaced as
-      // not-applicable rather than dropped: an entry that silently vanishes between the file
-      // and the report is indistinguishable from an entry that passed.
-      out.push({
-        type: "mdref",
-        key: `ref${m[1]}`,
-        unparsed: true,
-        author: "",
-        title: "",
-        booktitle: "",
-        journal: "",
-      });
-      continue;
-    }
-    const authorPart = entry
-      .slice(0, entry.indexOf("*"))
-      .trim()
-      .replace(/[.,;]\s*$/, "");
-    const rest = entry.slice(entry.indexOf(t[0]) + t[0].length);
-    out.push({
-      type: "mdref",
-      key: `ref${m[1]}`,
-      author: authorPart
-        .split(/,\s*|\s+and\s+/)
-        .filter(Boolean)
-        .join(" and "),
-      title: t[1].replace(/\.$/, "").trim(),
-      booktitle: rest.trim(),
-      journal: "",
-    });
-  }
-  return out;
+function bibliographyFrom(target) {
+  const r = bibliographyAt(absolutePath(resolve(target)), DEPS);
+  if (!r.ok) die(bibliographyUnreadWhy(r.error));
+  const { texts } = r.value;
+  return { files: [...new Set(texts.map((x) => x.path))], texts };
 }
 
-function bibTextFrom(target) {
-  let file = target;
-  if (!existsSync(file)) die(`no such path: ${file}`);
-  if (!extname(file)) {
-    const names = readdirSync(file);
-    // 🔴 THE CANONICAL NAME FIRST, then the only candidate, and never "whichever
-    // turns up first" (review #189). It used to be `names.find(f => f.endsWith(".tex"))`,
-    // that is, the first in directory order. Measured: one of the papers in the corpus
-    // has FIVE drafts lying around (paper-CONSTRUCTIVE-…, paper-FOLDED-…, paper-SAFE-…),
-    // while PIPELINE-STATUS.md names `paper.tex` as the submitted source. The author
-    // check went off into a stale draft and printed a verdict about the WRONG
-    // bibliography — a gate that checks the wrong file is worse than a missing one,
-    // because it says "checked".
-    const pick = (ext) => {
-      const canon = names.find((f) => f === `paper${ext}`);
-      if (canon) return canon;
-      const all = names.filter((f) => f.endsWith(ext)).sort();
-      if (all.length === 1) return all[0];
-      if (all.length > 1) {
-        // We do not fail: a new check here would set up one more surface, and its
-        // home is decided by the ladder in the `CLAUDE.md` next to the papers, not by
-        // this script (the `frozen-checks` ratchet is what guards that). It is enough
-        // to SAY it out loud and to choose DETERMINISTICALLY — the header below prints
-        // which file was checked anyway, so the reader sees the choice.
-        console.error(
-          `⚠️ ${file} holds several ${ext} files and no canonical paper${ext}: ` +
-            `${all.join(", ")} — took ${all[0]}. If that is the wrong one, name the file explicitly.`,
-        );
-        return all[0];
-      }
-      return undefined;
-    };
-    const found =
-      pick(".bib") ||
-      pick(".tex") ||
-      names.find((f) => f === "paper.md" || f === "draft.md");
-    if (!found) die(`no .bib, .tex or paper.md in ${file}`);
-    file = join(file, found);
-  }
-  const text = readFileSync(file, "utf-8");
-  if (file.endsWith(".md")) return { text, file, markdown: true };
-  if (file.endsWith(".bib")) return { text, file };
-  // A .tex may carry the bibliography inline via filecontents — that is how our papers do it.
-  const m = text.match(
-    /\\begin\{filecontents\*?\}(?:\[[^\]]*\])?\{[^}]*\.bib\}\r?\n([\s\S]*?)\\end\{filecontents\*?\}/,
-  );
-  if (m) return { text: m[1], file };
-  const sibling = join(file, "..", "refs.bib");
-  if (existsSync(sibling))
-    return { text: readFileSync(sibling, "utf-8"), file: sibling };
-  die(
-    `no bibliography found in ${file} (no filecontents block, no refs.bib beside it)`,
-  );
-}
+/* ---------- entries: as the bibtex reader read them ---------- */
 
-/* ---------- a deliberately small bib reader ----------
- * Only three fields are needed (type, key, author, title, booktitle/journal), and a full
- * BibTeX grammar would be a second thing to maintain. Brace-depth counting is enough and
- * is exercised by the colocated test. */
-export function parseBib(text) {
-  const out = [];
-  const re = /@(\w+)\s*\{\s*([^,\s]+)\s*,/g;
-  let m;
-  while ((m = re.exec(text))) {
-    const [, type, key] = m;
-    let i = re.lastIndex,
-      depth = 1;
-    while (i < text.length && depth > 0) {
-      if (text[i] === "{") depth++;
-      else if (text[i] === "}") depth--;
-      i++;
-    }
-    const body = text.slice(re.lastIndex, i - 1);
-    out.push({ type: type.toLowerCase(), key, ...fields(body) });
-  }
-  return out;
-}
+/** A name of a name list as BibTeX writes it, family part first: `von Last, First`, or the literal. */
+const writtenName = (n) =>
+  n.name ??
+  [[n.prefix, n.lastName].filter(Boolean).join(" "), n.firstName]
+    .filter(Boolean)
+    .join(", ");
 
-function fields(body) {
-  const get = (name) => {
-    const r = new RegExp(`(?:^|[,\\s])${name}\\s*=\\s*`, "i");
-    const at = body.search(r);
-    if (at === -1) return "";
-    let i = body.indexOf("=", at) + 1;
-    while (/\s/.test(body[i])) i++;
-    if (body[i] === "{") {
-      let depth = 1,
-        j = i + 1;
-      while (j < body.length && depth > 0) {
-        if (body[j] === "{") depth++;
-        else if (body[j] === "}") depth--;
-        j++;
-      }
-      return body.slice(i + 1, j - 1);
-    }
-    if (body[i] === '"') {
-      const j = body.indexOf('"', i + 1);
-      return body.slice(i + 1, j);
-    }
-    const j = body.indexOf(",", i);
-    return body.slice(i, j === -1 ? undefined : j);
-  };
-  return {
-    author: get("author"),
-    title: get("title"),
-    booktitle: get("booktitle"),
-    journal: get("journal"),
-  };
+/**
+ * The entries this check reads, from the bibtex reader's (src/ports/bib-reader.ts): type, key, the
+ * author list written out (`and others` kept), title, booktitle and journal; "" for a field it lacks.
+ */
+export function authorEntries(entries) {
+  return entries.map((e) => ({
+    type: e.type,
+    key: e.key,
+    author: (e.names.author ?? []).map(writtenName).join(" and "),
+    title: e.fields.title ?? "",
+    booktitle: e.fields.booktitle ?? "",
+    journal: e.fields.journal ?? "",
+  }));
 }
 
 /* ---------- normalisation: surnames only, in order ---------- */
@@ -358,13 +218,6 @@ export async function checkAuthors(
   const matched = []; // compared against the published record, and equal
   const entries = parsed.filter((e) => e.title && e.author);
 
-  for (const e of parsed.filter((x) => x.unparsed)) {
-    skipped.push({
-      key: e.key,
-      why: "no author/title — a reference to software or a dataset, DBLP does not apply",
-    });
-  }
-
   for (const e of entries) {
     if (!claimsPublished(e)) continue; // a preprint entry is allowed to carry preprint metadata
     if (truncated(e.author)) {
@@ -438,14 +291,22 @@ async function main() {
   if (!args[0])
     die("usage: bib-authors.mjs <paper-dir|file.bib|file.tex> [--json]");
 
-  const { text, file, markdown } = bibTextFrom(args[0]);
-  const parsed = markdown ? parseMarkdownRefs(text) : parseBib(text);
+  const { files, texts } = bibliographyFrom(args[0]);
+  const file = files.join(", ");
+  const parsed = texts.flatMap((t) => authorEntries(t.entries));
   const entries = parsed.filter((e) => e.title && e.author);
   const { findings, skipped, unchecked } = await checkAuthors(parsed);
   if (asJson) {
     console.log(
       JSON.stringify(
-        { file, entries: entries.length, findings, skipped, unchecked },
+        {
+          file: files[0],
+          files,
+          entries: entries.length,
+          findings,
+          skipped,
+          unchecked,
+        },
         null,
         2,
       ),

package/skills/verify-citations/scripts/bib-authors.test.mjs

@@ -14,12 +14,7 @@
  */
 import assert from "node:assert/strict";
 import { test } from "vitest";
-import {
-  surnames,
-  compare,
-  claimsPublished,
-  parseMarkdownRefs,
-} from "./bib-authors.mjs";
+import { surnames, compare, claimsPublished } from "./bib-authors.mjs";
 
 const t = test;
 
@@ -135,41 +130,3 @@ t("a proceedings entry IS in scope", () => {
     true,
   );
 });
-
-console.log("bib-authors — where the bibliography begins");
-
-// Both halves. "Silent on a fence" without "finds the real one" is indistinguishable from a broken parse.
-t("a real ## References is parsed", () => {
-  const md = [
-    "# Paper",
-    "text",
-    "",
-    "## References",
-    "",
-    "1. A. Author. *A title*. In NeurIPS, 2023.",
-  ].join("\n");
-  const refs = parseMarkdownRefs(md);
-  assert.equal(refs.length, 1);
-  assert.match(refs[0].title, /A title/);
-});
-
-t("a ## References inside a ``` fence does NOT open the bibliography", () => {
-  const md = [
-    "# Paper",
-    "",
-    "The section is written like this:",
-    "",
-    "```markdown",
-    "## References",
-    "",
-    "1. Z. Ghost. *Not a reference, but a markup example*. In Nowhere, 2020.",
-    "```",
-    "",
-    "The end.",
-  ].join("\n");
-  assert.deepEqual(
-    parseMarkdownRefs(md),
-    [],
-    "quoted markup is not a bibliography — the ^#+ regex counted it as a heading",
-  );
-});

package/skills/verify-citations/scripts/verify-cites.cli.test.ts

@@ -10,6 +10,8 @@ import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { test } from "vitest";
 import { z } from "zod";
+import { absolutePath } from "#src/domain/paths";
+import { bibliographyUnreadWhy } from "#src/paper-sources";
 import {
   runNode,
   useTempDir,
@@ -92,6 +94,20 @@ test("an input that cannot be read: exit 2, named", () => {
   );
 });
 
+test("a .bib that is not there: exit 2, in bibliographyAt's words", () => {
+  // The path → bibliography vocabulary is tested once, beside bibliographyAt (src/paper-sources.ts).
+  const gone = join(root, "gone.bib");
+  const r = offline([gone]);
+  assert.deepEqual(
+    { status: r.status, stdout: r.stdout, stderr: r.stderr },
+    {
+      status: 2,
+      stdout: "",
+      stderr: `error: could not read input — ${bibliographyUnreadWhy({ kind: "missing", path: absolutePath(gone) })}\n`,
+    },
+  );
+});
+
 test("offline over a JSON list: a citation with no id is unresolvable by name, a short SHA is flagged", () => {
   const r = parsed(offline([join(root, "cites.json")]));
   assert.deepEqual(

package/skills/verify-citations/scripts/verify-cites.d.mts

@@ -5,14 +5,30 @@
 // Only what `src/` imports is declared. The `.mjs` is not typechecked, so a declaration nobody
 // compiles against would drift without anyone noticing.
 
-/** One entry as `parseBib` returns it: the BibTeX key as `id`, plus the fields it recognised. */
+/** One citation as `citationsOf` returns it: the BibTeX key as `id`, plus the fields it recognised. */
 export interface Citation {
   readonly id: string;
   readonly [field: string]: unknown;
 }
 
-/** Every entry of a BibTeX text, `@comment`/`@string`/`@preamble` skipped. */
-export declare function parseBib(text: string): Citation[];
+/** A name of a name list, in its parts (`BibName`). */
+export interface ReadName {
+  readonly lastName?: string;
+  readonly firstName?: string;
+  readonly prefix?: string;
+  readonly suffix?: string;
+  readonly name?: string;
+}
+
+/** An entry as the bibtex reader reads it (`BibEntry`, src/domain/paper-sources.ts), as far as citations use it. */
+export interface ReadEntry {
+  readonly key: string;
+  readonly fields: Readonly<Record<string, string>>;
+  readonly names: Readonly<Record<string, readonly ReadName[]>>;
+}
+
+/** The citations of a bibliography's entries, as the bibtex reader read them. */
+export declare function citationsOf(entries: readonly ReadEntry[]): Citation[];
 
 /** The title reduced to what identifies it: case, braces and punctuation removed. */
 export declare function titleIdentity(title: string): string;

package/skills/verify-citations/scripts/verify-cites.mjs

@@ -47,7 +47,13 @@
 
 import { mkdirSync, readFileSync, writeFileSync, existsSync } from "node:fs";
 import { homedir } from "node:os";
-import { dirname, join, extname } from "node:path";
+import { dirname, join, extname, resolve } from "node:path";
+import { bibReader } from "#src/adapters/bibtex/index";
+import { latexReader } from "#src/adapters/latex/index";
+import { nodeFiles } from "#src/adapters/node/index";
+import { sourcesCodec } from "#src/adapters/sources-record/index";
+import { absolutePath } from "#src/domain/paths";
+import { bibliographyAt, bibliographyUnreadWhy } from "#src/paper-sources";
 import { createHash } from "node:crypto";
 import {
   consumerContactEmail,
@@ -588,116 +594,32 @@ export function reduceVerdict(citation, evidence, commitFlags = []) {
 }
 
 // ─────────────────────────────────────────────────────────────────────────────
-// .bib PARSER — small, best-effort. Extracts @article/@inproceedings/... entries
-// and (loosely) \bibitem blocks. Not a full BibTeX grammar; enough to seed cites.
+// CITATIONS — from the entries the bibtex reader read (src/ports/bib-reader.ts).
 // ─────────────────────────────────────────────────────────────────────────────
 
+/** A name of a name list, written out: `First von Last, Jr.`, or the literal it was. */
+const writtenName = (n) =>
+  n.name ??
+  [n.firstName, n.prefix, n.lastName, n.suffix].filter(Boolean).join(" ");
+
 /**
- * field(body, name) — extract a BibTeX field value from an entry body.
- *  (a) anchors `name` so `title` does NOT also match `booktitle` (S4a);
- *  (b) reads BRACE-delimited values with balanced-brace scanning, so a protected
- *      acronym `{Evaluating {LLM}-based ...}` is captured whole, not truncated at
- *      the inner `}` (S4b);
- *  also handles "quoted" and bare (numeric) values.
+ * The citations of a bibliography's entries, as the bibtex reader read them: the key as `id`, and
+ * the doi, title, year, authors and arXiv eprint each entry has.
  */
-function bibField(body, name) {
-  const re = new RegExp(`(?<![a-zA-Z])${name}\\s*=\\s*`, "i");
-  const fm = re.exec(body);
-  if (!fm) return undefined;
-  let i = fm.index + fm[0].length;
-  const ch = body[i];
-  if (ch === "{") {
-    let depth = 0;
-    let j = i;
-    for (; j < body.length; j++) {
-      if (body[j] === "{") depth++;
-      else if (body[j] === "}") {
-        depth--;
-        if (depth === 0) break;
-      }
-    }
-    return body
-      .slice(i + 1, j)
-      .replace(/\s+/g, " ")
-      .trim();
-  }
-  if (ch === '"') {
-    let j = i + 1;
-    while (j < body.length && body[j] !== '"') j++;
-    return body
-      .slice(i + 1, j)
-      .replace(/\s+/g, " ")
-      .trim();
-  }
-  // bare value (e.g. year = 2017,) — up to the next comma / newline / close brace
-  let j = i;
-  while (j < body.length && !/[,\n}]/.test(body[j])) j++;
-  const v = body.slice(i, j).replace(/\s+/g, " ").trim();
-  return v || undefined;
-}
-
-export function parseBib(text) {
-  const cites = [];
-  // @type{key,  — then read the entry body with BALANCED-BRACE scanning so that
-  // one-line entries and indented / same-line closing braces (`\n  }` or `...}`)
-  // are captured, not dropped by a `\n}`-at-column-0 requirement (S4c).
-  const headRe = /@(\w+)\s*\{\s*([^,\s}]+)\s*,/g;
-  let m;
-  while ((m = headRe.exec(text)) !== null) {
-    const type = m[1].toLowerCase();
-    if (type === "comment" || type === "string" || type === "preamble")
-      continue;
-    const key = m[2].trim();
-    // Balanced scan from just after the key's comma to the entry's closing brace.
-    let depth = 1; // the entry's opening `{` was already consumed by headRe
-    let j = headRe.lastIndex;
-    for (; j < text.length && depth > 0; j++) {
-      if (text[j] === "{") depth++;
-      else if (text[j] === "}") depth--;
-    }
-    const body = text.slice(headRe.lastIndex, j - 1);
-    headRe.lastIndex = j; // resume scanning AFTER this entry
-
-    const c = { id: key };
-    const doi = bibField(body, "doi");
-    const title = bibField(body, "title");
-    const year = bibField(body, "year");
-    const author = bibField(body, "author");
-    const eprint = bibField(body, "eprint");
-    const archive =
-      bibField(body, "archiveprefix") || bibField(body, "eprinttype");
-    if (doi) c.doi = normalizeDoi(doi);
-    if (title) c.title = title.replace(/[{}]/g, "");
-    if (year) c.year = year;
-    if (author) c.authors = author;
-    if (eprint && (!archive || /arxiv/i.test(archive)))
-      c.arxiv = normalizeArxiv(eprint);
-    cites.push(c);
-  }
-  if (cites.length > 0) return cites;
-
-  // Fallback: \bibitem — grab arXiv ids / DOIs out of each block, best-effort.
-  const itemRe =
-    /\\bibitem(?:\[[^\]]*\])?\{([^}]+)\}([\s\S]*?)(?=\\bibitem|\\end\{thebibliography\}|$)/g;
-  while ((m = itemRe.exec(text)) !== null) {
-    const key = m[1].trim();
-    const block = m[2];
-    const c = { id: key };
-    const doiM = block.match(/10\.\d{4,9}\/[-._;()/:A-Z0-9]+/i);
-    const arxivM = block.match(/arXiv:\s*(\d{4}\.\d{4,5})/i);
-    const yearM = block.match(/\b(19|20)\d{2}\b/);
-    if (doiM) c.doi = normalizeDoi(doiM[0]);
-    if (arxivM) c.arxiv = normalizeArxiv(arxivM[1]);
-    if (yearM) c.year = yearM[0];
-    // crude title: longest quoted or {\em ...} run
-    const titleM =
-      block.match(/``([^']{6,}?)''/) ||
-      block.match(/\\emph\{([^}]{6,}?)\}/) ||
-      block.match(/\{\\em\s+([^}]{6,}?)\}/);
-    if (titleM) c.title = titleM[1].replace(/\s+/g, " ").trim();
-    cites.push(c);
-  }
-  return cites;
+export function citationsOf(entries) {
+  return entries.map((e) => {
+    const f = e.fields;
+    const c = { id: e.key };
+    if (f.doi) c.doi = normalizeDoi(f.doi);
+    if (f.title) c.title = f.title.replace(/\s+/g, " ").trim();
+    if (f.year) c.year = f.year;
+    const authors = (e.names.author ?? []).map(writtenName).join(" and ");
+    if (authors) c.authors = authors;
+    const archive = f.archiveprefix || f.eprinttype;
+    if (f.eprint && (!archive || /arxiv/i.test(archive)))
+      c.arxiv = normalizeArxiv(f.eprint);
+    return c;
+  });
 }
 
 // ─────────────────────────────────────────────────────────────────────────────
@@ -1212,11 +1134,23 @@ export async function verifyCitationLive(
 // CLI
 // ─────────────────────────────────────────────────────────────────────────────
 
+/** What `bibliographyAt` needs to read a `.bib` (src/paper-sources.ts, the one answer for a path). */
+const DEPS = {
+  files: nodeFiles,
+  codec: sourcesCodec,
+  latex: latexReader,
+  bib: bibReader,
+};
+
 function loadInput(argv) {
   const path = argv.find((a) => !a.startsWith("-"));
+  if (path && extname(path).toLowerCase() === ".bib") {
+    const r = bibliographyAt(absolutePath(resolve(path)), DEPS);
+    if (!r.ok) throw new Error(bibliographyUnreadWhy(r.error));
+    return citationsOf(r.value.texts.flatMap((t) => t.entries));
+  }
   const raw =
     path && path !== "-" ? readFileSync(path, "utf8") : readFileSync(0, "utf8"); // stdin
-  if (path && extname(path).toLowerCase() === ".bib") return parseBib(raw);
   const parsed = JSON.parse(raw);
   return Array.isArray(parsed) ? parsed : [parsed];
 }