paperlint 3.1.0 → 3.1.1

package/skills/verify-citations/scripts/__snapshots__/verify-cites.net.test.mjs.snap

@@ -0,0 +1,235 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`CVEs: found by count, found by list, not found, NVD down, and a malformed id 1`] = `
+{
+  "calls": [
+    "https://services.nvd.nist.gov/rest/json/cves/2.0?cveId=CVE-2024-0001",
+    "https://services.nvd.nist.gov/rest/json/cves/2.0?cveId=CVE-2024-0002",
+    "https://services.nvd.nist.gov/rest/json/cves/2.0?cveId=CVE-2024-0003",
+    "https://services.nvd.nist.gov/rest/json/cves/2.0?cveId=CVE-2024-0004",
+    "https://services.nvd.nist.gov/rest/json/cves/2.0?cveId=CVE-2024-0005",
+  ],
+  "results": [
+    {
+      "id": "cve-2024-0001",
+      "matched_db": "nvd",
+      "matched_title": "cve-2024-0001",
+      "reason": "confirmed by nvd — "cve-2024-0001"",
+      "verdict": "true",
+    },
+    {
+      "id": "CVE-2024-0002",
+      "matched_db": "nvd",
+      "matched_title": "CVE-2024-0002",
+      "reason": "confirmed by nvd — "CVE-2024-0002"",
+      "verdict": "true",
+    },
+    {
+      "id": "CVE-2024-0003",
+      "matched_db": null,
+      "reason": "RESOLVED_TO_NOTHING: the provided CVE CVE-2024-0003 resolves to no record (checked nvd) — fabrication evidence",
+      "verdict": "false",
+    },
+    {
+      "id": "CVE-2024-0004",
+      "matched_db": null,
+      "reason": "all databases unreachable (network/rate-limit) — degraded to unresolvable, never to false",
+      "verdict": "unresolvable",
+    },
+    {
+      "id": "CVE-2024-0005",
+      "matched_db": null,
+      "reason": "RESOLVED_TO_NOTHING: the provided CVE CVE-2024-0005 resolves to no record (checked nvd) — fabrication evidence",
+      "verdict": "false",
+    },
+    {
+      "id": "CVE-24-1",
+      "matched_db": null,
+      "reason": "RESOLVED_TO_NOTHING: the provided CVE CVE-24-1 resolves to no record (checked nvd) — fabrication evidence",
+      "verdict": "false",
+    },
+  ],
+}
+`;
+
+exports[`S2 and arXiv unreachable for an arXiv id 1`] = `
+{
+  "calls": [
+    "https://api.semanticscholar.org/graph/v1/paper/arXiv%3A1706.03762?fields=title,year",
+    "https://export.arxiv.org/api/query?id_list=1706.03762&max_results=1",
+  ],
+  "result": {
+    "id": "x",
+    "matched_db": null,
+    "reason": "all databases unreachable (network/rate-limit) — degraded to unresolvable, never to false",
+    "verdict": "unresolvable",
+  },
+}
+`;
+
+exports[`a DOI every registry resolves to the claimed paper, and the authority knows: true 1`] = `
+{
+  "calls": [
+    "https://api.crossref.org/works/10.1%2Fx",
+    "https://api.openalex.org/works/doi:10.1%2Fx",
+    "https://api.semanticscholar.org/graph/v1/paper/DOI%3A10.1%2Fx?fields=title,year",
+    "https://doi.org/api/handles/10.1/x",
+  ],
+  "result": {
+    "id": "v",
+    "matched_db": "crossref",
+    "matched_title": "Attention Is All You Need",
+    "reason": "confirmed by crossref — "Attention Is All You Need"",
+    "verdict": "true",
+  },
+}
+`;
+
+exports[`a DOI nobody knows, and the authority says it does not exist: false 1`] = `
+{
+  "calls": [
+    "https://api.crossref.org/works/10.1%2Fnope",
+    "https://api.openalex.org/works/doi:10.1%2Fnope",
+    "https://api.semanticscholar.org/graph/v1/paper/DOI%3A10.1%2Fnope?fields=title,year",
+    "https://doi.org/api/handles/10.1/nope",
+  ],
+  "result": {
+    "id": "f",
+    "matched_db": null,
+    "reason": "RESOLVED_TO_NOTHING: DOI 10.1/nope does not resolve at the DOI authority (doi.org handle responseCode 100 = not found) — fabrication evidence",
+    "verdict": "false",
+  },
+}
+`;
+
+exports[`a title only: every registry's search endpoint, hits and all 1`] = `
+{
+  "calls": [
+    "https://api.crossref.org/works?query.bibliographic=Attention%20Is%20All%20You%20Need&rows=5",
+    "https://api.openalex.org/works?search=Attention%20Is%20All%20You%20Need&per-page=5",
+    "https://api.semanticscholar.org/graph/v1/paper/search?query=Attention%20Is%20All%20You%20Need&fields=title,year&limit=5",
+    "https://export.arxiv.org/api/query?search_query=ti:%22Attention%20Is%20All%20You%20Need%22&max_results=5",
+  ],
+  "result": {
+    "id": "t",
+    "matched_db": "crossref",
+    "matched_title": "Attention Is All You Need",
+    "reason": "confirmed by crossref — "Attention Is All You Need"",
+    "verdict": "true",
+  },
+}
+`;
+
+exports[`a title search that cannot reach any registry is unresolvable 1`] = `
+{
+  "calls": [
+    "https://api.crossref.org/works?query.bibliographic=Attention%20Is%20All%20You%20Need&rows=5",
+    "https://api.openalex.org/works?search=Attention%20Is%20All%20You%20Need&per-page=5",
+    "https://api.semanticscholar.org/graph/v1/paper/search?query=Attention%20Is%20All%20You%20Need&fields=title,year&limit=5",
+    "https://export.arxiv.org/api/query?search_query=ti:%22Attention%20Is%20All%20You%20Need%22&max_results=5",
+  ],
+  "result": {
+    "id": "d",
+    "matched_db": null,
+    "reason": "all databases unreachable (network/rate-limit) — degraded to unresolvable, never to false",
+    "verdict": "unresolvable",
+  },
+}
+`;
+
+exports[`a title search whose answers are empty or shapeless is a miss, not a match 1`] = `
+{
+  "calls": [
+    "https://api.crossref.org/works?query.bibliographic=Attention%20Is%20All%20You%20Need&rows=5",
+    "https://api.openalex.org/works?search=Attention%20Is%20All%20You%20Need&per-page=5",
+    "https://api.semanticscholar.org/graph/v1/paper/search?query=Attention%20Is%20All%20You%20Need&fields=title,year&limit=5",
+    "https://export.arxiv.org/api/query?search_query=ti:%22Attention%20Is%20All%20You%20Need%22&max_results=5",
+  ],
+  "result": {
+    "id": "e",
+    "matched_db": null,
+    "reason": "not found by title in any database (no resolvable id to disprove) — could be a legit unindexed/regional/pre-digital work, NOT fabrication",
+    "verdict": "unresolvable",
+  },
+}
+`;
+
+exports[`an arXiv id nobody has: the arXiv API's empty feed and S2's 404 1`] = `
+{
+  "calls": [
+    "https://api.semanticscholar.org/graph/v1/paper/arXiv%3A9999.99999?fields=title,year",
+    "https://export.arxiv.org/api/query?id_list=9999.99999&max_results=1",
+  ],
+  "result": {
+    "id": "n",
+    "matched_db": null,
+    "reason": "RESOLVED_TO_NOTHING: arXiv id 9999.99999 returns a definitive not-found from the reachable arXiv API — fabrication evidence",
+    "verdict": "false",
+  },
+}
+`;
+
+exports[`an arXiv id: Semantic Scholar by arXiv id, the arXiv API by id_list 1`] = `
+{
+  "calls": [
+    "https://api.crossref.org/works?query.bibliographic=Attention%20Is%20All%20You%20Need&rows=5",
+    "https://api.openalex.org/works?search=Attention%20Is%20All%20You%20Need&per-page=5",
+    "https://api.semanticscholar.org/graph/v1/paper/arXiv%3A1706.03762?fields=title,year",
+    "https://export.arxiv.org/api/query?id_list=1706.03762&max_results=1",
+  ],
+  "result": {
+    "id": "a",
+    "matched_db": "semantic_scholar",
+    "matched_title": "Attention Is All You Need",
+    "reason": "confirmed by semantic_scholar — "Attention Is All You Need"",
+    "verdict": "true",
+  },
+}
+`;
+
+exports[`every registry down (429, 503, 403, a thrown error): unresolvable, never false 1`] = `
+{
+  "calls": [
+    "https://api.crossref.org/works/10.1%2Fx",
+    "https://api.openalex.org/works/doi:10.1%2Fx",
+    "https://api.semanticscholar.org/graph/v1/paper/DOI%3A10.1%2Fx?fields=title,year",
+    "https://doi.org/api/handles/10.1/x",
+  ],
+  "result": {
+    "id": "u",
+    "matched_db": null,
+    "reason": "all databases unreachable (network/rate-limit) — degraded to unresolvable, never to false",
+    "verdict": "unresolvable",
+  },
+}
+`;
+
+exports[`offline: no request at all, the verdict from the citation alone 1`] = `
+{
+  "calls": [],
+  "result": {
+    "id": "o",
+    "matched_db": null,
+    "reason": "all databases unreachable (network/rate-limit) — degraded to unresolvable, never to false",
+    "verdict": "unresolvable",
+  },
+}
+`;
+
+exports[`records with fields missing: no title, a subtitle, a year only in \`published\`, no id 1`] = `
+{
+  "calls": [
+    "https://api.crossref.org/works/10.1%2Fx",
+    "https://api.openalex.org/works/doi:10.1%2Fx",
+    "https://api.semanticscholar.org/graph/v1/paper/DOI%3A10.1%2Fx?fields=title,year",
+    "https://doi.org/api/handles/10.1/x",
+  ],
+  "result": {
+    "id": "m",
+    "matched_db": "crossref",
+    "matched_title": "",
+    "reason": "confirmed by crossref",
+    "verdict": "true",
+  },
+}
+`;

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

@@ -0,0 +1,274 @@
+/**
+ * bib-authors.mjs's comparison (`checkAuthors`) and its reading of DBLP's answer (`dblpHits`).
+ *
+ * `checkAuthors` takes its lookup and its pause as parameters for exactly this: the buckets it
+ * sorts entries into — finding, matched, not applicable, NOT CHECKED — are our logic, and each is
+ * driven here with a lookup that answers on purpose. `dblpHits` is our parser of DBLP's search
+ * JSON; it is fed that documented shape (`result.hits.hit[].info`), which pins how WE read it,
+ * not how DBLP behaves — the colocated bib-authors.test.mjs keeps the live service out of tests.
+ */
+import assert from "node:assert/strict";
+import { afterEach, test, vi } from "vitest";
+import {
+  checkAuthors,
+  claimsPublished,
+  dblpHits,
+  parseBib,
+  surnames,
+} from "./bib-authors.mjs";
+
+afterEach(() => vi.unstubAllGlobals());
+
+const entry = (key, author, title, booktitle = "Proc. X") => ({
+  type: "inproceedings",
+  key,
+  author,
+  title,
+  booktitle,
+  journal: "",
+});
+const hit = (
+  title,
+  authors,
+  venue = "X",
+  type = "Conference and Workshop Papers",
+) => ({
+  title,
+  authors,
+  venue,
+  year: "2024",
+  type,
+});
+
+test("checkAuthors sorts every kind of entry into its bucket", async () => {
+  const parsed = [
+    entry("same", "Ada Lovelace and Alan Turing", "Same Paper"),
+    entry("dropped", "Ada Lovelace", "Dropped Author"),
+    entry("order", "Alan Turing and Ada Lovelace", "Order Swapped"),
+    entry("pre", "Ada Lovelace", "A Preprint", "arXiv preprint"),
+    entry("etal", "Ada Lovelace and others", "Truncated"),
+    entry("nomatch", "Ada Lovelace", "Nobody Has This"),
+    entry("onlycorr", "Ada Lovelace", "Only On CoRR"),
+    entry("down", "Ada Lovelace", "Service Down"),
+    {
+      type: "mdref",
+      key: "sw",
+      unparsed: true,
+      author: "",
+      title: "",
+      booktitle: "",
+      journal: "",
+    },
+  ];
+  const answers = {
+    "Same Paper": [hit("Same Paper.", ["Ada Lovelace", "Alan Turing"])],
+    "Dropped Author": [hit("Dropped Author", ["Ada Lovelace", "Alan Turing"])],
+    "Order Swapped": [hit("Order Swapped", ["Ada Lovelace", "Alan Turing"])],
+    "Nobody Has This": [hit("Something Else", ["X"])],
+    "Only On CoRR": [
+      hit("Only On CoRR", ["Ada Lovelace"], "CoRR", "Informal Publications"),
+    ],
+  };
+  const pauses = [];
+  const result = await checkAuthors(parsed, {
+    lookup: async (title) => {
+      if (title === "Service Down") throw new Error("DBLP 500");
+      return answers[title];
+    },
+    pause: (ms) => pauses.push(ms),
+  });
+  assert.deepEqual(
+    { ...result, pauses },
+    {
+      findings: [
+        {
+          key: "dropped",
+          venue: "X 2024",
+          ours: ["lovelace"],
+          theirs: ["lovelace", "turing"],
+          missing: ["turing"],
+          extra: [],
+          orderDiffers: false,
+        },
+        {
+          key: "order",
+          venue: "X 2024",
+          ours: ["turing", "lovelace"],
+          theirs: ["lovelace", "turing"],
+          missing: [],
+          extra: [],
+          orderDiffers: true,
+        },
+      ],
+      skipped: [
+        {
+          key: "sw",
+          why: "no author/title — a reference to software or a dataset, DBLP does not apply",
+        },
+        {
+          key: "etal",
+          why: "author list ends in `and others` — completeness not checkable",
+        },
+        { key: "nomatch", why: "no DBLP title match" },
+        { key: "onlycorr", why: "only a preprint record on DBLP" },
+      ],
+      unchecked: [{ key: "down", why: "DBLP lookup failed: DBLP 500" }],
+      matched: ["same"],
+      // 900 ms after each compared entry; 1500 and 3000 between the three failed attempts.
+      pauses: [900, 900, 900, 1500, 3000],
+    },
+  );
+});
+
+test("a lookup that fails once and then answers is retried, not reported", async () => {
+  let calls = 0;
+  const result = await checkAuthors([entry("k", "Ada Lovelace", "Flaky")], {
+    lookup: async () => {
+      if (calls++ === 0)
+        throw Object.assign(new Error("DBLP 429"), { retryable: true });
+      return [hit("Flaky", ["Ada Lovelace"])];
+    },
+    pause: () => {},
+  });
+  assert.deepEqual(result, {
+    findings: [],
+    skipped: [],
+    unchecked: [],
+    matched: ["k"],
+  });
+});
+
+test("the default pause really waits", async () => {
+  vi.useFakeTimers();
+  try {
+    const done = checkAuthors([entry("k", "Ada Lovelace", "T")], {
+      lookup: async () => [hit("T", ["Ada Lovelace"])],
+    });
+    await vi.advanceTimersByTimeAsync(900);
+    assert.deepEqual((await done).matched, ["k"]);
+  } finally {
+    vi.useRealTimers();
+  }
+});
+
+/** A stubbed fetch that answers every request with `status` and `body`, recording the URLs. */
+function fakeDblp(status, body) {
+  const urls = [];
+  vi.stubGlobal("fetch", async (url) => {
+    urls.push(url);
+    return new Response(body === undefined ? null : JSON.stringify(body), {
+      status,
+    });
+  });
+  return urls;
+}
+
+test("dblpHits reads DBLP's hit list: one author or several, the disambiguation number dropped", async () => {
+  const urls = fakeDblp(200, {
+    result: {
+      hits: {
+        hit: [
+          {
+            info: {
+              title: "One",
+              venue: "ICSE",
+              year: "2024",
+              type: "Conference and Workshop Papers",
+              authors: { author: { text: "Ada Lovelace 0001" } },
+            },
+          },
+          {
+            info: {
+              title: "Two",
+              authors: { author: [{ text: "A B" }, { text: "C D" }] },
+            },
+          },
+          { info: {} },
+          {},
+        ],
+      },
+    },
+  });
+  assert.deepEqual(
+    { hits: await dblpHits("a title"), urls },
+    {
+      hits: [
+        {
+          venue: "ICSE",
+          year: "2024",
+          type: "Conference and Workshop Papers",
+          title: "One",
+          authors: ["Ada Lovelace"],
+        },
+        {
+          venue: "",
+          year: "",
+          type: "",
+          title: "Two",
+          authors: ["A B", "C D"],
+        },
+        { venue: "", year: "", type: "", title: "", authors: [] },
+        { venue: "", year: "", type: "", title: "", authors: [] },
+      ],
+      urls: ["https://dblp.org/search/publ/api/?q=a%20title&format=json&h=6"],
+    },
+  );
+});
+
+test("dblpHits: no hits is an empty list; 429 is retryable; other errors are not", async () => {
+  fakeDblp(200, {});
+  const none = await dblpHits("x");
+  fakeDblp(429);
+  const limited = await dblpHits("x").catch((e) => [e.message, e.retryable]);
+  fakeDblp(500);
+  const down = await dblpHits("x").catch((e) => [e.message, e.retryable]);
+  assert.deepEqual(
+    [none, limited, down],
+    [[], ["DBLP 429", true], ["DBLP 500", undefined]],
+  );
+});
+
+test("parseBib reads quoted and bare field values, and a field that is absent", () => {
+  assert.deepEqual(
+    parseBib(
+      '@article{k, author = "Ada Lovelace", title = {T}, journal = J, }',
+    ),
+    [
+      {
+        type: "article",
+        key: "k",
+        author: "Ada Lovelace",
+        title: "T",
+        booktitle: "",
+        journal: "J",
+      },
+    ],
+  );
+});
+
+test("parseBib: braces nested inside a value, and a bare last value with no comma after it", () => {
+  assert.deepEqual(
+    parseBib("@article{k, title = {The {BERT} Model}, journal = J}"),
+    [
+      {
+        type: "article",
+        key: "k",
+        author: "",
+        title: "The {BERT} Model",
+        booktitle: "",
+        journal: "J",
+      },
+    ],
+  );
+});
+
+test("surnames of nothing is nothing; a name with an empty family part contributes nothing", () => {
+  assert.deepEqual(
+    [surnames(""), surnames(", Ada and Lovelace")],
+    [[], ["lovelace"]],
+  );
+});
+
+test("an entry naming no venue at all does not claim to be published", () => {
+  assert.equal(claimsPublished({ booktitle: "", journal: "" }), false);
+});

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

@@ -0,0 +1,178 @@
+/**
+ * bib-authors.mjs as a process: which file it picks from a paper directory, the three
+ * bibliography sources it reads (.bib, a .tex's filecontents or its sibling refs.bib, a markdown
+ * reference list), and the report and exit code for each outcome. DBLP is a preload that answers
+ * by title from a table (the documented `result.hits.hit[].info` shape) — no network.
+ */
+import assert from "node:assert/strict";
+import { join } from "node:path";
+import { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { test } from "vitest";
+import { runNode, useTempDir, writeTree } from "../../../test/support.mjs";
+
+const SCRIPT = join(dirname(fileURLToPath(import.meta.url)), "bib-authors.mjs");
+const root = useTempDir("bib-authors-cli-");
+
+const DBLP_ANSWERS = {
+  "Dropped Author": [["Ada Lovelace", "Alan Turing"]],
+  "Swapped Order": [["Ada Lovelace", "Alan Turing"]],
+  "All Good": [["Ada Lovelace"]],
+};
+const bib = (key, author, title, venue = "booktitle = {Proc. X}") =>
+  `@inproceedings{${key}, author = {${author}}, title = {${title}}, ${venue}}\n`;
+
+writeTree(root, {
+  // The retry backoff (1.5 s, then 3 s) and the 900 ms courtesy pause are real sleeps in the
+  // script. Under CPU load they made "DBLP down" take 11.7 s once and time out. The preload
+  // stands in for the clock too: every timer fires at once, so no test here depends on time.
+  "dblp.mjs":
+    "const realSetTimeout = globalThis.setTimeout;\n" +
+    "globalThis.setTimeout = (fn, _ms, ...args) => realSetTimeout(fn, 0, ...args);\n" +
+    `const answers = ${JSON.stringify(DBLP_ANSWERS)};\n` +
+    "globalThis.fetch = async (url) => {\n" +
+    "  const q = new URL(url).searchParams.get('q');\n" +
+    "  if (q === 'Service Down') return new Response(null, { status: 500 });\n" +
+    "  const hit = (answers[q] ?? []).map((authors) => ({ info: { title: q, venue: 'X', year: '2024',\n" +
+    "    type: 'Conference and Workshop Papers', authors: { author: authors.map((text) => ({ text })) } } }));\n" +
+    "  return new Response(JSON.stringify({ result: { hits: { hit } } }), { status: 200 });\n};\n",
+  "findings/paper.bib":
+    bib("dropped", "Ada Lovelace and Grace Hopper", "Dropped Author") +
+    bib("order", "Alan Turing and Ada Lovelace", "Swapped Order"),
+  "findings/other.bib": bib("never", "X", "Never Read"),
+  "twotex/b.tex": "\\documentclass{article}\n",
+  "twotex/a.tex":
+    "\\begin{filecontents*}{refs.bib}\n" +
+    bib("pre", "Ada Lovelace", "A Preprint", "journal = {arXiv preprint}") +
+    "\\end{filecontents*}\n",
+  "sibling/paper.tex": "\\documentclass{article}\n",
+  "sibling/refs.bib": bib("good", "Ada Lovelace", "All Good"),
+  "nobib/paper.tex": "\\documentclass{article}\n",
+  "md/paper.md":
+    "# P\n\n## References\n\n1. A. Lovelace. *All Good.* Proc. X, 2024.\n2. some-npm-package, https://npm.example\n",
+  "down/refs.bib": bib("down", "Ada Lovelace", "Service Down"),
+  "empty/.keep": "",
+});
+
+const run = (...args) => {
+  const r = runNode(SCRIPT, args, {
+    nodeArgs: ["--import", join(root, "dblp.mjs")],
+  });
+  return {
+    ...r,
+    stdout: r.stdout.replaceAll(root, "<root>"),
+    stderr: r.stderr.replaceAll(root, "<root>"),
+  };
+};
+
+test("refusals: no argument, no such path, a directory with nothing to read, a .tex with no bibliography", () => {
+  assert.deepEqual(
+    [
+      run(),
+      run(join(root, "nope")),
+      run(join(root, "empty")),
+      run(join(root, "nobib", "paper.tex")),
+    ].map(({ status, stdout, stderr }) => ({ status, stdout, stderr })),
+    [
+      {
+        status: 2,
+        stdout: "",
+        stderr:
+          "bib-authors: usage: bib-authors.mjs <paper-dir|file.bib|file.tex> [--json]\n",
+      },
+      {
+        status: 2,
+        stdout: "",
+        stderr: "bib-authors: no such path: <root>/nope\n",
+      },
+      {
+        status: 2,
+        stdout: "",
+        stderr: "bib-authors: no .bib, .tex or paper.md in <root>/empty\n",
+      },
+      {
+        status: 2,
+        stdout: "",
+        stderr:
+          "bib-authors: no bibliography found in <root>/nobib/paper.tex (no filecontents block, no refs.bib beside it)\n",
+      },
+    ],
+  );
+});
+
+test("a paper directory: the canonical paper.bib is read, and each difference is printed — FAIL, exit 1", () => {
+  assert.deepEqual(run(join(root, "findings")), {
+    status: 1,
+    stderr: "",
+    stdout: [
+      "== bib-authors: <root>/findings/paper.bib ==",
+      "",
+      "  🔴 dropped  (DBLP: X 2024)",
+      "     MISSING from ours : turing",
+      "     EXTRA in ours     : hopper",
+      "",
+      "  🔴 order  (DBLP: X 2024)",
+      "     ORDER differs",
+      "       ours : turing > lovelace",
+      "       DBLP : lovelace > turing",
+      "",
+      "-- 2 entries · 2 difference(s) · 0 not applicable · 0 NOT CHECKED",
+      "FAIL: our author list disagrees with the version we claim to cite.",
+      "",
+    ].join("\n"),
+  });
+});
+
+test("two .tex files and no paper.tex: the first by name, said out loud; its filecontents is read", () => {
+  const r = run(join(root, "twotex"), "--json");
+  assert.deepEqual(
+    { status: r.status, stderr: r.stderr, report: JSON.parse(r.stdout) },
+    {
+      status: 0,
+      stderr:
+        "⚠️ <root>/twotex holds several .tex files and no canonical paper.tex: a.tex, b.tex — took a.tex. If that is the wrong one, name the file explicitly.\n",
+      report: {
+        file: "<root>/twotex/a.tex",
+        entries: 1,
+        findings: [],
+        skipped: [],
+        unchecked: [],
+      },
+    },
+  );
+});
+
+test("a .tex with no filecontents reads the refs.bib beside it — PASS, exit 0", () => {
+  const r = run(join(root, "sibling", "paper.tex"));
+  assert.deepEqual(r, {
+    status: 0,
+    stderr: "",
+    stdout:
+      "== bib-authors: <root>/sibling/refs.bib ==\n\n-- 1 entries · 0 difference(s) · 0 not applicable · 0 NOT CHECKED\nPASS: no author-list disagreement.\n",
+  });
+});
+
+test("a markdown reference list: a software entry is not applicable, not dropped", () => {
+  const r = run(join(root, "md"));
+  assert.deepEqual(r, {
+    status: 0,
+    stderr: "",
+    stdout:
+      "== bib-authors: <root>/md/paper.md ==\n" +
+      "  · n/a ref2 — no author/title — a reference to software or a dataset, DBLP does not apply\n\n" +
+      "-- 1 entries · 0 difference(s) · 1 not applicable · 0 NOT CHECKED\nPASS: no author-list disagreement.\n",
+  });
+});
+
+test("DBLP down: NOT CHECKED, PARTIAL, exit 2 — never a pass", () => {
+  const r = run(join(root, "down"));
+  assert.deepEqual(r, {
+    status: 2,
+    stderr: "",
+    stdout:
+      "== bib-authors: <root>/down/refs.bib ==\n" +
+      "  ⚠️ NOT CHECKED down — DBLP lookup failed: DBLP 500\n\n" +
+      "-- 1 entries · 0 difference(s) · 0 not applicable · 1 NOT CHECKED\n" +
+      "PARTIAL: no disagreement among the entries reached, but 1 could not be checked — this is NOT a pass.\n",
+  });
+});