paperlint 7.2.0 → 9.0.0

package/src/domain/tex-run.test.ts

@@ -0,0 +1,228 @@
+/**
+ * Which files of the paper directory a build's TeX passes read, and which `.bib` files they wrote —
+ * decided from the `.fls` lines of each pass. The inputs are `.fls` files captured whole from real
+ * runs of the planted papers (test/fixtures/tex-output/README.md); the few shapes no planted paper
+ * has are written out, and say so.
+ */
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { describe, expect, it } from "vitest";
+import { texOutput } from "../adapters/tex-output/index.ts";
+import { filesOfRun } from "./tex-run.ts";
+
+const CAPTURES = join(
+  dirname(dirname(dirname(fileURLToPath(import.meta.url)))),
+  "test",
+  "fixtures",
+  "tex-output",
+);
+/** A planted paper's passes, as `.fls` text → lines, in the order they ran. */
+const passes = (paper: string) =>
+  ["first-pass.fls", "paper.fls"].map((f) =>
+    texOutput.fls(readFileSync(join(CAPTURES, paper, f), "utf8")),
+  );
+const BIBTEX_RAN = { jobname: "paper", generated: ["paper.bbl"] };
+
+describe("the files a build's TeX read", () => {
+  it("a paper of one file: the main file, a body", () => {
+    expect(filesOfRun(passes("v3-declared"), BIBTEX_RAN)).toEqual({
+      inputs: [{ path: "paper.tex", role: "body" }],
+      written: [],
+    });
+  });
+
+  it("an include read after \\begin{document} is body, a database TeX read before it is preamble — in first-read order", () => {
+    expect(filesOfRun(passes("p1"), BIBTEX_RAN)).toEqual({
+      inputs: [
+        { path: "paper.tex", role: "body" },
+        { path: "refs.bib", role: "preamble" },
+        { path: "sections/intro.tex", role: "body" },
+      ],
+      written: [],
+    });
+  });
+
+  it("a file read before \\begin{document} and never after is preamble", () => {
+    expect(filesOfRun(passes("v16-included-block"), BIBTEX_RAN)).toEqual({
+      inputs: [
+        { path: "paper.tex", role: "body" },
+        { path: "bibblock.tex", role: "preamble" },
+        { path: "refs.bib", role: "preamble" },
+      ],
+      written: [],
+    });
+  });
+});
+
+describe("the .bib files TeX wrote", () => {
+  it("a .bib TeX wrote (filecontents) is written, and is no input: its bytes are the block's", () => {
+    expect(filesOfRun(passes("v8-jobname"), BIBTEX_RAN)).toEqual({
+      inputs: [{ path: "paper.tex", role: "body" }],
+      written: ["paper.bib"],
+    });
+  });
+
+  it("🔴 a block writes its file on the first pass only (the later passes find it there and read it): the last pass alone would list it as an input and not as written", () => {
+    const [first, last] = passes("plain-block");
+    expect(last?.lines.filter((l) => l.path.endsWith(".bib"))).toEqual([
+      { op: "INPUT", path: "./refs.bib" },
+      { op: "INPUT", path: "refs.bib" },
+    ]);
+    expect(filesOfRun(passes("plain-block"), BIBTEX_RAN)).toEqual({
+      inputs: [{ path: "paper.tex", role: "body" }],
+      written: ["refs.bib"],
+    });
+    expect(first?.lines.filter((l) => l.path.endsWith(".bib"))).toEqual([
+      { op: "OUTPUT", path: "refs.bib" },
+    ]);
+  });
+});
+
+describe("a .tex TeX wrote and then read — the paper's text, generated", () => {
+  it("🔴 a block that writes a .tex the body \\input's: the file is written AND an input, a body file — its text is in the PDF", () => {
+    // v29-generated-input: pass 1 writes body.tex and reads it after \begin{document}; the later
+    // passes find it there, read it in the preamble (the block's check) and again in the body.
+    const [first, last] = passes("v29-generated-input");
+    expect(first?.lines.filter((l) => l.path.endsWith("body.tex"))[0]).toEqual({
+      op: "OUTPUT",
+      path: "body.tex",
+    });
+    expect(
+      last?.lines.some((l) => l.op === "OUTPUT" && l.path === "body.tex"),
+    ).toBe(false);
+    expect(filesOfRun(passes("v29-generated-input"), BIBTEX_RAN)).toEqual({
+      inputs: [
+        { path: "paper.tex", role: "body" },
+        { path: "body.tex", role: "body" },
+      ],
+      written: ["body.tex"],
+    });
+  });
+
+  it("with [overwrite] the last pass writes it again before reading it: still an input", () => {
+    const fls = texOutput.fls(
+      [
+        "PWD /work/paper",
+        "INPUT paper.tex",
+        "INPUT ./body.tex",
+        "OUTPUT body.tex",
+        "OUTPUT paper.aux",
+        "INPUT ./body.tex",
+      ].join("\n"),
+    );
+    expect(filesOfRun([fls], BIBTEX_RAN)).toEqual({
+      inputs: [
+        { path: "paper.tex", role: "body" },
+        { path: "body.tex", role: "body" },
+      ],
+      written: ["body.tex"],
+    });
+  });
+});
+
+describe("what is not the paper's: its TeX tree, a sibling directory, what TeX writes", () => {
+  it("the .bbl bibtex wrote is no input of the paper; with no bibtex run it is a file TeX read, and so is one", () => {
+    const last = passes("v3-declared");
+    expect(
+      filesOfRun(last, { jobname: "paper", generated: [] }).inputs,
+    ).toEqual([
+      { path: "paper.tex", role: "body" },
+      { path: "paper.bbl", role: "body" },
+    ]);
+  });
+
+  it("files the paper's TeX tree supplies are not the paper's: only the paper directory's files are listed", () => {
+    const fls = texOutput.fls(
+      [
+        "PWD /work/paper",
+        "INPUT /usr/share/texlive/texmf-dist/tex/latex/base/article.cls",
+        "INPUT paper.tex",
+        "INPUT /work/paper/inside.tex",
+        "INPUT ../shared/outside.tex",
+        "INPUT /elsewhere/other.tex",
+        "OUTPUT paper.aux",
+      ].join("\n"),
+    );
+    expect(
+      filesOfRun([fls], { jobname: "paper", generated: [] }).inputs,
+    ).toEqual([
+      { path: "paper.tex", role: "body" },
+      { path: "inside.tex", role: "preamble" },
+    ]);
+  });
+});
+
+describe("an .fls with no directory, and a name that merely starts with dots", () => {
+  it("an .fls that names no directory lists the files named relative to it and no absolute path", () => {
+    const fls = texOutput.fls(
+      "INPUT /usr/share/texlive/article.cls\nINPUT paper.tex\nINPUT ..x.tex\n",
+    );
+    expect(
+      filesOfRun([fls], { jobname: "paper", generated: [] }).inputs,
+    ).toEqual([
+      { path: "paper.tex", role: "body" },
+      { path: "..x.tex", role: "preamble" },
+    ]);
+  });
+});
+
+describe("roles on the edges: both places, no body, no passes", () => {
+  it("a file read in the preamble and again in the body is body: its first read alone would drop it from the prose", () => {
+    const fls = texOutput.fls(
+      [
+        "PWD /work/paper",
+        "INPUT paper.tex",
+        "INPUT ./macros.tex",
+        "OUTPUT paper.aux",
+        "INPUT ./macros.tex",
+        "INPUT ./intro.tex",
+      ].join("\n"),
+    );
+    expect(
+      filesOfRun([fls], { jobname: "paper", generated: [] }).inputs,
+    ).toEqual([
+      { path: "paper.tex", role: "body" },
+      { path: "macros.tex", role: "body" },
+      { path: "intro.tex", role: "body" },
+    ]);
+  });
+
+  it("a run that stopped before opening the .aux has no body: everything but the main file is preamble", () => {
+    const fls = texOutput.fls(
+      "PWD /work/paper\nINPUT paper.tex\nINPUT ./a.tex\nINPUT ./b.tex\n",
+    );
+    expect(
+      filesOfRun([fls], { jobname: "paper", generated: [] }).inputs,
+    ).toEqual([
+      { path: "paper.tex", role: "body" },
+      { path: "a.tex", role: "preamble" },
+      { path: "b.tex", role: "preamble" },
+    ]);
+  });
+
+  it("a file TeX wrote on any pass is not an input, even one it also reads on a later pass (.toc, .out)", () => {
+    const first = texOutput.fls(
+      "PWD /w\nINPUT paper.tex\nOUTPUT paper.aux\nOUTPUT paper.toc\n",
+    );
+    const second = texOutput.fls(
+      "PWD /w\nINPUT paper.tex\nINPUT ./paper.toc\nOUTPUT paper.aux\n",
+    );
+    expect(
+      filesOfRun([first, second], { jobname: "paper", generated: [] }).inputs,
+    ).toEqual([{ path: "paper.tex", role: "body" }]);
+  });
+
+  it("no passes, or passes that opened nothing of the paper, list nothing", () => {
+    expect(filesOfRun([], { jobname: "paper", generated: [] })).toEqual({
+      inputs: [],
+      written: [],
+    });
+    expect(
+      filesOfRun([texOutput.fls("PWD /w\nINPUT /usr/x.cls\n")], {
+        jobname: "paper",
+        generated: [],
+      }),
+    ).toEqual({ inputs: [], written: [] });
+  });
+});

package/src/domain/tex-run.ts

@@ -0,0 +1,139 @@
+/**
+ * WHICH FILES A BUILD'S TeX PASSES READ — decided from the lines of each pass's `.fls` (pdflatex
+ * `-recorder`), not from any TeX source (docs/design/paper-sources.md §1).
+ *
+ *   inputs   the files of the paper directory the LAST pass read, in the order it first read them,
+ *            each a `preamble` or `body` file: before or after TeX opened `<jobname>.aux` for writing,
+ *            which `\begin{document}` does (measured). The main file, read first, is `body`.
+ *   written  the `.bib` and `.tex` files ANY pass wrote — a `filecontents` block's.
+ *
+ * 🔴 WHY THE LAST PASS FOR INPUTS AND EVERY PASS FOR WHAT WAS WRITTEN. A block without `[overwrite]`
+ * writes its file on the first pass only; the later passes find it there and read it (measured on TeX
+ * Live 2026: pass 1 `OUTPUT refs.bib`, passes 2 and 3 `INPUT refs.bib`, no OUTPUT). The last pass alone
+ * would list TeX's own copy of a `.bib` as a file of the paper. And the first pass reads no `.aux`,
+ * `.toc` or `.out` yet, so only a later pass lists what the paper reads and the passes after it write.
+ *
+ * 🔴 A FILE TeX WROTE IS AN INPUT ONLY WHEN IT IS TeX SOURCE OF THE PAPER: a `.tex`. A block that
+ * writes `body.tex` the body `\input`s puts that text in the PDF (measured: pass 1 `OUTPUT body.tex`
+ * then `INPUT ./body.tex` after `\begin{document}`; the later passes read it again), so it is an
+ * input like any other: hashed, spliced where its include stands. Every other file a pass wrote is
+ * TeX's bookkeeping or a database — its `.aux`, `.out` and `.toc`, a block's `.bib` — and is no input.
+ * A file another program wrote from TeX's output (`generated`: the `.bbl`, when bibtex ran) is none
+ * either.
+ */
+import { isAbsolute, posix } from "node:path";
+import type { RecordedInput } from "./sources-record.ts";
+
+/** One line of an `.fls`: TeX opened a file to read it, or to write it. */
+export interface FlsLine {
+  readonly op: "INPUT" | "OUTPUT";
+  /** As TeX named the file: `./a.tex` and `a.tex` for one file, an absolute path for the TeX tree's. */
+  readonly path: string;
+}
+
+/** A pdflatex `-recorder` file: where it ran, and every file it opened, in order. */
+export interface Fls {
+  /** The directory pdflatex ran in, or null when the file names none. */
+  readonly pwd: string | null;
+  readonly lines: readonly FlsLine[];
+}
+
+export interface RunFiles {
+  readonly inputs: readonly RecordedInput[];
+  readonly written: readonly string[];
+}
+
+/**
+ * `path` as TeX named it → relative to the paper directory with forward slashes, or null when the file
+ * is not in it: the TeX tree's, a file of a sibling directory, an absolute path outside `pwd`.
+ */
+function inPaperDir(path: string, pwd: string | null): string | null {
+  const rel = isAbsolute(path)
+    ? pwd === null
+      ? null
+      : posix.relative(pwd, path)
+    : posix.normalize(path);
+  // `..` or `../x`: a file of a sibling directory. (`..x` is a file of this one.)
+  return rel === null || rel.split("/")[0] === ".." ? null : rel;
+}
+
+const distinct = <T>(xs: readonly T[]): readonly T[] => [...new Set(xs)];
+
+/** A file TeX writes that the record names: TeX source of the paper (`.tex`) or a database (`.bib`). */
+const isTexSource = (path: string): boolean => posix.extname(path) === ".tex";
+const isRecordedWrite = (path: string): boolean =>
+  isTexSource(path) || posix.extname(path) === ".bib";
+
+type Opened = FlsLine & { readonly rel: string };
+
+/** The files of the paper directory a pass opened, with the op, in order. */
+const opened = (pass: Fls): readonly Opened[] =>
+  pass.lines.flatMap((l) => {
+    const rel = inPaperDir(l.path, pass.pwd);
+    return rel === null ? [] : [{ ...l, rel }];
+  });
+
+export interface RunOptions {
+  /** The job name: `<jobname>.aux` is the file whose opening marks `\begin{document}`. */
+  readonly jobname: string;
+  /** Files other programs wrote from TeX's own output, relative to the paper directory (`paper.bbl`). */
+  readonly generated: readonly string[];
+}
+
+/** One read of a file of the paper, and whether it came after `\begin{document}`. */
+interface Read {
+  readonly path: string;
+  readonly afterBegin: boolean;
+}
+
+/**
+ * The reads of the last pass: INPUT lines of files nothing wrote, or that a pass wrote as TeX source,
+ * each with its place against the line that opens `<jobname>.aux` — `\begin{document}`. No such line
+ * (the run stopped first): none is after it.
+ */
+function readsOf(
+  last: readonly Opened[],
+  outputs: ReadonlySet<string>,
+  { jobname, generated }: RunOptions,
+): readonly Read[] {
+  const boundary = last.findIndex(
+    (l) => l.op === "OUTPUT" && l.rel === `${jobname}.aux`,
+  );
+  return last.flatMap((l, i) =>
+    l.op === "INPUT" &&
+    (!outputs.has(l.rel) || isTexSource(l.rel)) &&
+    !generated.includes(l.rel)
+      ? [{ path: l.rel, afterBegin: boundary >= 0 && i > boundary }]
+      : [],
+  );
+}
+
+export function filesOfRun(
+  passes: readonly Fls[],
+  options: RunOptions,
+): RunFiles {
+  const everyPass = passes.flatMap(opened);
+  const wrote = (l: Opened): boolean => l.op === "OUTPUT";
+  const outputs = new Set(everyPass.filter(wrote).map((l) => l.rel));
+  const last = passes.at(-1);
+  const reads = readsOf(
+    last === undefined ? [] : opened(last),
+    outputs,
+    options,
+  );
+  // The main file holds `\begin{document}` itself, so it is body wherever TeX opened it.
+  const body = (path: string): boolean =>
+    path === reads[0]?.path ||
+    reads.some((r) => r.path === path && r.afterBegin);
+  return {
+    inputs: distinct(reads.map((r) => r.path)).map((path): RecordedInput => ({
+      path,
+      role: body(path) ? "body" : "preamble",
+    })),
+    written: distinct(
+      everyPass
+        .filter((l) => wrote(l) && isRecordedWrite(l.rel))
+        .map((l) => l.rel),
+    ),
+  };
+}

package/src/folder-venue-rule.test.ts

@@ -160,7 +160,7 @@ describe("paper/folder-venue-leftover — silent", () => {
   });
 
   it("judged once per paper, on PIPELINE-STATUS.md only", () => {
-    expect(lint("aisec-2026", AIDC, { file: "paper.md" })).toEqual([]);
+    expect(lint("aisec-2026", AIDC, { file: "paper.tex" })).toEqual([]);
   });
 
   it("a paper on a bare template family declares no venue: a venue in its folder may be its own", () => {

package/src/heading-case.test.ts

@@ -12,6 +12,7 @@ import { run } from "./cli.ts";
 import { headingCaseRule } from "./heading-case.ts";
 import { latexReader } from "./adapters/latex/index.ts";
 import { useTempDir, writeTree } from "../test/support.ts";
+import { recordedTree } from "../test/recorded-fixture.ts";
 
 const Results = z.array(
   z.looseObject({
@@ -369,10 +370,15 @@ describe("tex/heading-case refuses, when ESLint loads it, a configuration that a
 });
 
 describe("tex/heading-case in the files a paper includes", () => {
-  const tree = paper(
-    doc("\\section{Introduction}\n\\input{sections/results}"),
-    PRESET,
-    { "papers/p/sections/results.tex": "\\section{Results and discussion}\n" },
+  const tree = recordedTree(
+    paper(doc("\\section{Introduction}\n\\input{sections/results}"), PRESET, {
+      "papers/p/sections/results.tex": "\\section{Results and discussion}\n",
+    }),
+    "papers/p",
+    [
+      { path: "paper.tex", role: "body" },
+      { path: "sections/results.tex", role: "body" },
+    ],
   );
 
   it("reports a heading at its own file and line, and --fix edits that file", async () => {
@@ -391,12 +397,20 @@ describe("tex/heading-case in the files a paper includes", () => {
   });
 
   it("🔴 reads a \\title kept in a file the body includes, where it stands", async () => {
-    const withTitle = paper(
-      `${ACM}\n\\begin{document}\n\\input{front}\n\\maketitle\n\\end{document}\n`,
-      PRESET,
-      {
-        "papers/p/front.tex": "% the front matter\n\\title{Measuring things}\n",
-      },
+    const withTitle = recordedTree(
+      paper(
+        `${ACM}\n\\begin{document}\n\\input{front}\n\\maketitle\n\\end{document}\n`,
+        PRESET,
+        {
+          "papers/p/front.tex":
+            "% the front matter\n\\title{Measuring things}\n",
+        },
+      ),
+      "papers/p",
+      [
+        { path: "paper.tex", role: "body" },
+        { path: "front.tex", role: "body" },
+      ],
     );
     const { found } = await lint(withTitle);
     expect(found).toEqual([

package/src/init.test.ts

@@ -55,8 +55,8 @@ function project(): string {
     "paperlint.json": JSON.stringify({ papersDir: "papers" }),
     "papers/a/PIPELINE-STATUS.md": "---\nstages: []\n---\n",
     "eslint-rules/fixtures/x/PIPELINE-STATUS.md": "---\nstages: []\n---\n",
-    "eslint-rules/fixtures/y/paper.md": "# y\n",
-    "drafts/z/paper.md": "# z\n",
+    "eslint-rules/fixtures/y/paper.tex": "% y\n",
+    "drafts/z/paper.tex": "% z\n",
   };
   for (const [p, text] of Object.entries(files)) {
     mkdirSync(join(root, p, ".."), { recursive: true });
@@ -291,7 +291,7 @@ describe("paperlint init — a paperlint.json it cannot use stops it before anyt
     for (const json of ["null\n", "[1]\n"]) {
       const root = tree({
         "paperlint.json": json,
-        "drafts/a/paper.md": "# a\n",
+        "drafts/a/paper.tex": "% a\n",
       });
       const decl = await declarePapers(root, () =>
         choosePapers(root, { interactive: false }),
@@ -308,7 +308,7 @@ describe("paperlint init — a paperlint.json it cannot use stops it before anyt
   it("a file without a trailing newline keeps having none", async () => {
     const root = tree({
       "paperlint.json": '{"x":1}',
-      "drafts/a/paper.md": "# a\n",
+      "drafts/a/paper.tex": "% a\n",
     });
     const decl = await declarePapers(root, () =>
       choosePapers(root, { interactive: false }),
@@ -322,7 +322,7 @@ describe("paperlint init — a paperlint.json it cannot use stops it before anyt
 
 describe("paperlint init — how several candidate directories were decided, said", () => {
   const several = () =>
-    tree({ "drafts/a/paper.md": "# a\n", "writing/b/paper.md": "# b\n" });
+    tree({ "drafts/a/paper.tex": "% a\n", "writing/b/paper.tex": "% b\n" });
   const section = (out: string[]) =>
     out.slice(out.indexOf("papers directory") + 1, out.indexOf("settings") - 1);
 
@@ -530,7 +530,6 @@ describe("paperlint init — a first paper named after a venue", () => {
       createPaper: (_root, name) => Promise.resolve((made.push(name), 0)),
     });
     expect(made).toEqual([]);
-    expect(asked.filter((q) => /format/.test(q))).toEqual([]);
     expect(r.out[r.out.indexOf("first paper") + 1]).toBe(
       '  ✗ no paper created — `aisec-2026` — the paper folder names a venue ("AISec"); venues change on resubmission, so name it after the work\n    if the venue really belongs in the name, rerun `paperlint new` with --allow-venue-name',
     );
@@ -539,7 +538,7 @@ describe("paperlint init — a first paper named after a venue", () => {
 
 describe("paperlint init — paths are shown relative to where it was run", () => {
   it("a path that IS the working directory is shown whole, not as an empty string", async () => {
-    const root = tree({ "papers/a/paper.md": "# a\n" });
+    const root = tree({ "papers/a/paper.tex": "% a\n" });
     const home = join(root, ".claude", "skills");
     mkdirSync(home, { recursive: true });
     const r = await initRun(root, {

package/src/init.ts

@@ -63,12 +63,7 @@ import {
   type Merge,
   type WireResult,
 } from "./hooks-settings.ts";
-import {
-  DEFAULT_FORMAT,
-  isFormat,
-  nameProblem,
-  type PaperFormat,
-} from "./new-paper.ts";
+import { nameProblem } from "./new-paper.ts";
 // The one source for the consumer's config key lives in lib/ (the ESLint rules and the skill scripts
 // import it too). It is imported compiled, from dist/, the one path that resolves the same from src/
 // and from dist/ — see CONTRIBUTING.md.
@@ -572,17 +567,11 @@ export interface InitOptions {
   merge?: Merge | undefined;
   /** `--paper <name>`: create this paper, even without a terminal. */
   paper?: string | null;
-  /** `--format tex|md` for that paper. */
-  format?: PaperFormat | null;
   /**
    * Creates one paper and lints it — `paperlint new`'s own routine, passed in by the CLI so `init` and
    * `new` cannot drift into two implementations.
    */
-  createPaper?: (
-    papersRoot: string,
-    name: string,
-    format: PaperFormat,
-  ) => Promise<number>;
+  createPaper?: (papersRoot: string, name: string) => Promise<number>;
   /**
    * The venues a paper name may not name (`shippedVenueNames`), so `--paper aisec-2026` is refused
    * before anything is asked. `createPaper` refuses it again whatever this holds.
@@ -717,7 +706,6 @@ export async function init(
     hooks = true,
     merge,
     paper = null,
-    format = null,
     createPaper,
     venues = [],
     run = spawnSync,
@@ -824,18 +812,11 @@ export async function init(
   }
   if (wanted !== null && createPaper) {
     const problem = nameProblem(wanted, venues);
-    let fmt: PaperFormat = format ?? DEFAULT_FORMAT;
-    if (!problem && format === null && interactive) {
-      const f = (
-        await askOrDefault(ask, `  format: tex / md [${DEFAULT_FORMAT}] `)
-      )?.trim();
-      if (isFormat(f)) fmt = f;
-    }
     if (problem) {
       log(`  ✗ no paper created — ${problem}`);
       paperCode = 2;
     } else {
-      const code = await createPaper(papersAbs, wanted, fmt);
+      const code = await createPaper(papersAbs, wanted);
       if (code !== 0) {
         log(`  ⚠ the new paper's lint exited ${String(code)} — see above`);
         paperCode = code;

package/src/latex-log.ts

@@ -146,6 +146,26 @@ export function bibtexExcerpt(stdout: string): string[] {
     .slice(0, MAX_EXCERPT);
 }
 
+/** What a bibtex run read: the databases its `.blg` names, the entries its `.bbl` holds. */
+export interface BibtexRead {
+  readonly databases: readonly string[];
+  readonly bibitems: readonly string[];
+}
+
+/** `\bibitem{key}`, `\bibitem[label]{key}` — a label may hold one level of braces (natbib's `[{A}(2020)]`). */
+const BIBITEM = /\\bibitem\s*(?:\[(?:[^[\]{}]|\{[^{}]*\})*\])?\s*\{([^}]+)\}/g;
+
+/**
+ * What a bibtex run read, from the files it left: `Database file #n: name` in its `.blg` (the name
+ * as the `.aux` gave it, relative to where bibtex ran), and every key its `.bbl` typesets.
+ */
+export const bibtexRead = (blg: string, bbl: string): BibtexRead => ({
+  databases: [...blg.matchAll(/^Database file #\d+: (.+)$/gm)].flatMap((m) =>
+    m.slice(1, 2),
+  ),
+  bibitems: [...bbl.matchAll(BIBITEM)].flatMap((m) => m.slice(1, 2)),
+});
+
 /** What the `.aux` tells bibtex: the cited keys, the databases and the style. */
 export interface AuxBib {
   /** Sorted, unique. `*` (`\nocite{*}`) is a key like any other. */

package/src/latex-loop.harness.ts

@@ -51,6 +51,7 @@ const latex = (o: Partial<LatexPass> = {}): LatexPass => ({
   markers: [],
   bib: NO_BIB,
   errorLines: [],
+  fls: null,
   ...o,
 });
 const bibtex = (o: Partial<BibtexPass> = {}): BibtexPass => ({

package/src/latex-loop.ts

@@ -86,6 +86,8 @@ export type Observation =
       readonly bib: BibInput;
       /** The first error and its source context, from the log. Empty on success. */
       readonly errorLines: readonly string[];
+      /** What `-recorder` wrote after this pass (`paper.fls`), or null when pdflatex wrote none. */
+      readonly fls: string | null;
     }
   | {
       readonly step: "bibtex";

package/src/lint-fix.test.ts

@@ -20,6 +20,10 @@ afterEach(() => {
   for (const d of dirs.splice(0)) rmSync(d, { recursive: true, force: true });
 });
 
+/** A paper.tex whose whole body is `body`. */
+const PAPER = (body: string): string =>
+  `\\documentclass{article}\n\\begin{document}\n${body}\n\\end{document}\n`;
+
 function project(
   settings: Record<string, unknown>,
   files: Record<string, string> = {},
@@ -30,7 +34,7 @@ function project(
     "package.json": JSON.stringify({ name: "c", private: true }),
     "paperlint.json": JSON.stringify({ papersDir: "papers", ...settings }),
     "papers/a/PIPELINE-STATUS.md": "---\nstages: []\n---\n",
-    "papers/a/paper.md": "# Intro\n\nSee §5, §6 and §7; p < .05.\n",
+    "papers/a/paper.tex": PAPER("See §5, §6 and §7; $p < .05$."),
     ...files,
   };
   for (const [p, text] of Object.entries(all)) {
@@ -64,15 +68,17 @@ describe("paperlint lint --fix", () => {
     const fixed = await lint(root, ["--fix"]);
     expect(ruleIds(fixed.out)).not.toContain("paper/section-word");
     expect(ruleIds(fixed.out)).not.toContain("paper/leading-zero");
-    expect(readFileSync(join(root, "papers/a/paper.md"), "utf8")).toBe(
-      "# Intro\n\nSee Section 5, Section 6 and Section 7; p < 0.05.\n",
+    expect(readFileSync(join(root, "papers/a/paper.tex"), "utf8")).toBe(
+      PAPER("See Section 5, Section 6 and Section 7; $p < 0.05$."),
     );
   });
 
   it("without --fix nothing is written", async () => {
     const root = project({});
     await lint(root);
-    expect(readFileSync(join(root, "papers/a/paper.md"), "utf8")).toMatch(/§5/);
+    expect(readFileSync(join(root, "papers/a/paper.tex"), "utf8")).toMatch(
+      /§5/,
+    );
   });
 });
 

package/src/linted-set.test.ts

@@ -20,6 +20,7 @@ import { join, relative } from "node:path";
 import { afterEach, describe, expect, it } from "vitest";
 import { run } from "./cli.ts";
 import { lintReport } from "../test/lint-report.ts";
+import { recordedTree } from "../test/recorded-fixture.ts";
 
 const dirs: string[] = [];
 afterEach(() => {
@@ -87,7 +88,14 @@ function project(): string {
     "papers/a/sections/intro.tex": "Intro.\n",
     ...NEIGHBOURS,
   };
-  for (const [p, text] of Object.entries(all)) {
+  // As a build left it: TeX read paper.tex, the macro file in the preamble and the section in the body
+  // (`paper-guards` is paperlint's own input, outside the paper's directory, so the record has none).
+  const built = recordedTree(all, "papers/a", [
+    { path: "paper.tex", role: "body" },
+    { path: "macros.tex", role: "preamble" },
+    { path: "sections/intro.tex", role: "body" },
+  ]);
+  for (const [p, text] of Object.entries(built)) {
     mkdirSync(join(root, p, ".."), { recursive: true });
     writeFileSync(join(root, p), text);
   }