paperlint 8.0.0 → 9.0.1

package/src/cli.harness.mjs

@@ -46,6 +46,15 @@ const check = createChecker();
 const tex = (body) =>
   `\\documentclass{article}\n\\begin{document}\n${body}\n\\end{document}\n`;
 
+/**
+ * A run that linted a paper nobody built clean: exit 0, and the one finding is the warning that no
+ * build recorded what TeX read (`paper/sources-fresh`) — what "no findings" meant before that rule.
+ */
+const cleanButUnbuilt = (r) =>
+  r.code === 0 &&
+  /paper\/sources-fresh/.test(r.out) &&
+  /1 problem \(0 errors, 1 warning\)/.test(r.out);
+
 /** Runs the utility with output captured — quieter and faster than spawning a process. */
 async function cli(args, cwd) {
   // 🔴 THE STREAMS ARE SPLIT, AND THAT IS LOAD-BEARING. As long as the harness dumped log and
@@ -196,7 +205,7 @@ check(
     const bare = await cli(["lint"], root);
     check(
       "🔴 NO paperlint.json IS A VALID PROJECT — the default papers directory is linted",
-      bare.code === 0 && /no findings/.test(bare.out),
+      cleanButUnbuilt(bare),
     );
     check(
       "and no config line is printed when there is no file to name",
@@ -208,7 +217,7 @@ check(
     const empty = await cli(["lint"], root);
     check(
       `an empty paperlint.json — no \`${PAPERS_DIR_FIELD}\`, so the default`,
-      empty.code === 0 && /no findings/.test(empty.out),
+      cleanButUnbuilt(empty),
     );
 
     // 🔴 THE DECLARED DIRECTORY IS NOT THE DEFAULT: with `papers` declared, a CLI that ignored
@@ -221,7 +230,7 @@ check(
     const r = await cli(["lint"], root);
     check(
       "🔴 THE UTILITY READS THE DECLARATION FROM paperlint.json — the file `paperlint init` writes and the hooks read",
-      r.code === 0 && /no findings/.test(r.out),
+      cleanButUnbuilt(r),
     );
     check(
       "and NAMES the carrier out loud — swapping settings is never silent",
@@ -713,7 +722,7 @@ check(
     const clean = await cli(["lint", "papers"], root);
     check(
       "on a clean corpus — zero and a legible report",
-      clean.code === 0 && /no findings/.test(clean.out),
+      cleanButUnbuilt(clean),
     );
 
     writeFileSync(join(paper, "PIPELINE-STATUS.md"), status(999));
@@ -822,7 +831,7 @@ check(
     const found = await cli(["lint"], root);
     check(
       "the config is FOUND on its own: `lint` with no argument at all runs",
-      found.code === 0 && /no findings/.test(found.out),
+      cleanButUnbuilt(found),
     );
     check(
       "and the found file is NAMED out loud — swapping settings silently is not acceptable",
@@ -836,7 +845,7 @@ check(
     const fromSub = await cli(["lint"], paper);
     check(
       "the path from the config resolves relative to the CONFIG'S DIRECTORY, not the current one",
-      fromSub.code === 0 && /no findings/.test(fromSub.out),
+      cleanButUnbuilt(fromSub),
     );
 
     // Consumer data from the found config actually reaches the rules, not just gets read.
@@ -865,7 +874,7 @@ check(
     const noPapers = await cli(["lint"], root);
     check(
       "a config WITHOUT the papers-directory field lints the default `papers/`",
-      noPapers.code === 0 && /no findings/.test(noPapers.out),
+      cleanButUnbuilt(noPapers),
     );
     check(
       'an empty string as the papers directory is refused, not read as the directory ""',
@@ -925,7 +934,7 @@ check(
     );
     check(
       'and the failure names the NUMBER and the THRESHOLD, not just "too many"',
-      /3 warning\(s\) exceed the --max-warnings limit of 0/.test(strict.out),
+      /4 warning\(s\) exceed the --max-warnings limit of 0/.test(strict.out),
     );
     const generous = await cli(["lint", "--max-warnings", "5"], root);
     check(
@@ -1597,13 +1606,14 @@ console.log(
     );
     const r = await cli(["new", "demo"], root);
     check(
-      "🔴 `paperlint new demo` creates writing/demo/ and its lint is the verdict — exit 0, and only the warning that no venue is chosen yet",
+      "🔴 `paperlint new demo` creates writing/demo/ and its lint is the verdict — exit 0, and only two warnings: no venue is chosen yet, the paper is not built",
       r.code === 0 &&
         existsSync(join(root, "writing", "demo", "PIPELINE-STATUS.md")) &&
         existsSync(join(root, "writing", "demo", "paper.tex")) &&
         existsSync(join(root, "writing", "demo", "paperlint.json")) &&
         /names no venue preset yet/.test(r.out) &&
-        /\(0 errors, 1 warning\)/.test(r.out),
+        /paper\/sources-fresh/.test(r.out) &&
+        /\(0 errors, 2 warnings\)/.test(r.out),
     );
     const again = await cli(["new", "demo"], root);
     check(

package/src/cli.test.ts

@@ -33,13 +33,18 @@ import { texInputsDir } from "./package-dirs.ts";
 const root = useTempDir("cli-test-");
 
 /** `run(argv)` from `cwd`, the output as one string per stream. */
-async function cli(argv: string[], cwd: string) {
+async function cli(
+  argv: string[],
+  cwd: string,
+  deps: Pick<NonNullable<Parameters<typeof run>[1]>, "loadTexLanguage"> = {},
+) {
   const out: string[] = [];
   const err: string[] = [];
   const code = await run(argv, {
     log: (...a: unknown[]) => out.push(a.join(" ")),
     err: (...a: unknown[]) => err.push(a.join(" ")),
     cwd,
+    ...deps,
   });
   return { code, out: out.join("\n"), err: err.join("\n") };
 }
@@ -617,21 +622,20 @@ test("init's TeX Live install runs the toolchain over the project's papers, neve
   assert.equal(typeof here.installed(), "boolean");
 });
 
-test("lint with its LaTeX language missing from the install still lints the scorecards", () => {
+test("lint with its LaTeX language missing from the install still lints the scorecards", async () => {
   const dir = writeTree(join(root, "lint-no-tex-language"), {
     "papers/p/PIPELINE-STATUS.md": "---\nstages: []\n---\n# S\n",
-    "no-latex.mjs":
-      "import { register } from 'node:module';\n" +
-      "register('data:text/javascript,' + encodeURIComponent(\"export async function resolve(s, c, next) { if (s === '#eslint-rules/latex-language') throw Object.assign(new Error('gone'), { code: 'ERR_MODULE_NOT_FOUND' }); return next(s, c); }\"));\n",
   });
-  const without = runNode(BIN, ["lint", "papers"], {
-    cwd: dir,
-    nodeArgs: ["--import", join(dir, "no-latex.mjs")],
+  const gone = Object.assign(new Error("gone"), {
+    code: "ERR_MODULE_NOT_FOUND",
   });
-  const whole = runNode(BIN, ["lint", "papers"], { cwd: dir });
+  const without = await cli(["lint", "papers"], dir, {
+    loadTexLanguage: () => Promise.reject(gone),
+  });
+  const whole = await cli(["lint", "papers"], dir);
   // A scorecard needs no LaTeX language: the same report, the same code.
   assert.deepEqual(without, whole);
-  assert.match(whole.stdout, /missing all of `paper\.tex`/);
+  assert.match(whole.out, /missing all of `paper\.tex`/);
 });
 
 test("`paperlint hook` with no name: exit 2, and the usage names an example", async () => {

package/src/cli.ts

@@ -46,11 +46,11 @@ import {
   FRAGMENT_FILES,
   includeBlocks,
   paperBodies,
-  unreadLines,
 } from "./paper-includes.ts";
 import { prepareEngine } from "./build-engine.ts";
 import { cacheRoot, cachedTree, runToolchain } from "./toolchain.ts";
 import { banalInstaller, parseBanalSettings } from "./adapters/banal/index.ts";
+import { bibReader } from "./adapters/bibtex/index.ts";
 import { curlDownload } from "./adapters/curl/index.ts";
 import { latexReader } from "./adapters/latex/index.ts";
 import {
@@ -93,6 +93,12 @@ import {
   type PaperSettings,
 } from "./paper-settings.ts";
 import { referenceRules, REFERENCE_RULE_LEVELS } from "./reference-rules.ts";
+import { SOURCES_RULE_LEVELS, sourcesRules } from "./sources-rules.ts";
+import { sourcesRecorder } from "./sources-record.ts";
+import { sourcesCodec } from "./adapters/sources-record/index.ts";
+import { texOutput } from "./adapters/tex-output/index.ts";
+import { BIB_RULE_LEVELS, bibRules } from "./bib-rules.ts";
+import { bibliographyReader } from "./references.ts";
 import { onlineReferences } from "./adapters/references/index.ts";
 import { hotcrpPortal } from "./adapters/hotcrp/index.ts";
 import { runSubmission } from "./submission.ts";
@@ -166,7 +172,6 @@ import {
 } from "./folder-venue-rule.ts";
 import typography from "#eslint-rules/paper-typography";
 import texBuild from "#eslint-rules/tex-build";
-import bibReachable from "#eslint-rules/bib-reachable-entry";
 import reviewFrontmatter from "#eslint-rules/review-frontmatter";
 import siblingFrontmatter from "#eslint-rules/sibling-frontmatter";
 import pdfRules from "#eslint-rules/pdf-last-page-balance";
@@ -302,11 +307,17 @@ settings — paperlint.json, at two levels, one schema. Both are optional.
   unknown key, in either file, is an error.
 `;
 
-/** What the rules over a paper.tex read with: the disk, the shipped presets, the LaTeX reader. */
+/** What reads the build's record of a paper: the disk, and the schema its text is parsed with. */
+const RECORD_DEPS = { files: nodeFiles, codec: sourcesCodec };
+
+/** What reads the bibliography the last build recorded: the record, and the readers of its databases and blocks. */
+const RECORDED_DEPS = { ...RECORD_DEPS, latex: latexReader, bib: bibReader };
+
+/** What the rules over a paper.tex read with: the paper's disk and LaTeX reader, the build's record, and the shipped presets. */
 const TEX_RULE_DEPS = {
-  files: nodeFiles,
-  venuesDir: presetsDir(),
+  ...RECORD_DEPS,
   latex: latexReader,
+  venuesDir: presetsDir(),
 };
 
 /** The register band rules and `tex/heading-case`: the rules of the `tex` plugin that read a paper's words. */
@@ -354,7 +365,8 @@ export function buildConfig(
   // The reference rules judge `_build/references.json`, and only on `paper.tex`.
   const texPaperRules = {
     ...paperRules,
-    ...referenceRules({ files: nodeFiles }),
+    ...referenceRules(RECORDED_DEPS),
+    ...sourcesRules(RECORD_DEPS),
   };
   // Each typography rule reports every occurrence where it is, and fixes it (`--fix`).
   const prose = {
@@ -445,7 +457,7 @@ export function buildConfig(
           },
         },
         paper: { rules: texPaperRules },
-        bib: bibReachable,
+        bib: { rules: bibRules(RECORDED_DEPS) },
         talk: { rules: talkRules(TALK_RULE_DEPS) },
         format: {
           rules: {
@@ -459,8 +471,9 @@ export function buildConfig(
       rules: {
         ...prose,
         ...REFERENCE_RULE_LEVELS,
+        ...SOURCES_RULE_LEVELS,
         "paper/figure-ref-style": "warn",
-        "bib/reachable-entry": "warn",
+        ...BIB_RULE_LEVELS,
         "tex/future-promise": "warn",
         // A number with no owner: a prose rule, on beside the others above.
         "tex/claim-provenance": "warn",
@@ -1443,6 +1456,12 @@ async function runBuild(
     dryRun: a.dryRun,
     log,
     checkReferences,
+    readBibliography: bibliographyReader(RECORDED_DEPS),
+    recordSources: sourcesRecorder({
+      files: nodeFiles,
+      listDir: nodeListDir,
+      texOutput,
+    }),
     engine: () => engineEnv(targets, a, { log, err }),
   });
   if (out.kind === "no-engine") return 1;
@@ -1656,10 +1675,17 @@ export async function run(
     err = console.error,
     cwd = process.cwd(),
     checkReferences = onlineReferences,
+    loadTexLanguage = async () =>
+      (await import("#eslint-rules/latex-language")).texLanguage,
   }: {
     log?: typeof console.log;
     err?: typeof console.error;
     cwd?: string;
+    /**
+     * `lint`'s LaTeX language, loaded lazily because only `lint` needs it. A test hands one that
+     * fails, as a broken install would.
+     */
+    loadTexLanguage?: () => Promise<unknown>;
     /**
      * `build`'s online reference check — the real services by default. The e2e build passes a
      * fake: no test depends on Crossref, Semantic Scholar or DBLP answering.
@@ -1765,31 +1791,14 @@ export async function run(
   // Loaded lazily because only `lint` needs it. If the module cannot be loaded (a broken install:
   // the file missing from the package), lint still runs over the scorecards and the review notes
   // rather than failing outright — the LaTeX rules simply have no language to run in.
-  let texLanguage: unknown = null;
-  try {
-    ({ texLanguage } = await import("#eslint-rules/latex-language"));
-  } catch {
-    texLanguage = null;
-  }
+  const texLanguage: unknown = await loadTexLanguage().catch(() => null);
 
-  // Each paper's body files, resolved the way the build resolves them — only when the LaTeX language
+  // Each paper's body files, as the last build recorded TeX reading them — only when the LaTeX language
   // loaded, since only its rules read them. The project's papers too: `paperlint lint .` reaches
   // papers two levels down, which a directory's immediate papers do not.
   const bodies = texLanguage
-    ? paperBodies(paperDirs([...paths, ...papersRoots(cfg)]), {
-        files: nodeFiles,
-        latex: latexReader,
-      })
+    ? paperBodies(paperDirs([...paths, ...papersRoots(cfg)]), RECORD_DEPS)
     : [];
-  // Named only for the papers this run lints: a paper elsewhere in the project is not this run's.
-  const inScope = (dir: string) =>
-    paths.some((p) => dir === p || dir.startsWith(`${p}${sep}`));
-  unreadLines(
-    bodies.filter((b) => inScope(b.dir)),
-    (p) => shown(cwd, p),
-  ).forEach((l) => {
-    err(l);
-  });
 
   const eslint = new ESLint({
     cwd: lintRoot(root, paths),

package/src/domain/paper-source.test.ts

@@ -1,6 +1,6 @@
 /**
  * The paper as one text: includes spliced where they stand, every character mapped back to its
- * file, a missing file reported, a subfile's body only, and a file that includes itself entered once.
+ * file, a file with nothing behind it left out, a subfile's body only, and a file that includes itself entered once.
  * The reader is a stand-in that finds `\input{…}` by position, so these tests are about assembling,
  * not about parsing LaTeX (the LaTeX adapter's own tests cover `includes`).
  */
@@ -41,8 +41,7 @@ describe("assemblePaper — the text TeX reads", () => {
       main,
       deps({ "s/one.tex": "one", "two.tex": "two" }),
     );
-    expect(p.text).toBe("AoneBtwoC");
-    expect(p.missing).toEqual([]);
+    expect(p.text).toBe("Aone\nBtwo\nC");
     expect([...new Set(p.segments.map((g) => g.file))]).toEqual([
       "paper.tex",
       "s/one.tex",
@@ -57,7 +56,7 @@ describe("assemblePaper — the text TeX reads", () => {
       main,
       deps({ "a.tex": "[\\input{s/b}]", "s/b.tex": "BB" }),
     );
-    expect(p.text).toBe("x[BB]y");
+    expect(p.text).toBe("x[BB\n]\ny");
     expect(originOf(p, { start: 2, end: 4 })).toEqual({
       file: "s/b.tex",
       source: "BB",
@@ -66,18 +65,10 @@ describe("assemblePaper — the text TeX reads", () => {
     });
   });
 
-  it("🔴 a missing file is reported where it stands, and left out", () => {
-    const main = "a\\input{gone}b";
-    const p = assemblePaper("paper.tex", main, deps({}));
+  it("a file the reader has none of contributes nothing", () => {
+    const p = assemblePaper("paper.tex", "a\\input{gone}b", deps({}));
     expect(p.text).toBe("ab");
-    expect(p.missing).toEqual([
-      {
-        file: "paper.tex",
-        target: "gone",
-        span: { start: 1, end: 13 },
-        via: { start: 1, end: 13 },
-      },
-    ]);
+    expect(p.segments.map((g) => g.file)).toEqual(["paper.tex", "paper.tex"]);
   });
 });
 
@@ -99,7 +90,7 @@ describe("assemblePaper — subfiles and a file that includes itself", () => {
       "<\\subfile{s}>",
       deps({ "s.tex": "ALL" }),
     );
-    expect(p.text).toBe("<ALL>");
+    expect(p.text).toBe("<ALL\n>");
   });
 
   it("a file that includes itself is entered once", () => {
@@ -108,7 +99,54 @@ describe("assemblePaper — subfiles and a file that includes itself", () => {
       "m\\input{a}",
       deps({ "a.tex": "a\\input{a}\\input{paper.tex}" }),
     );
-    expect(p.text).toBe("ma");
+    expect(p.text).toBe("ma\n");
+  });
+});
+
+describe("assemblePaper — TeX's end of line after the last line of an included file", () => {
+  // Measured with TeX Live 2026: `a\input f b` with f = `foo`, no final newline, typesets «afoo b» —
+  // the file's last line is ended like any other; `f` = `bar` plus a newline typesets the same; an
+  // empty file reads no line and adds nothing.
+  it("a file whose last line has no newline is ended, so what follows it is a new word", () => {
+    const p = assemblePaper(
+      "paper.tex",
+      "a\\input{f}b",
+      deps({ "f.tex": "foo" }),
+    );
+    expect(p.text).toBe("afoo\nb");
+  });
+
+  it("a file that ends with a newline gets no second one", () => {
+    const p = assemblePaper(
+      "paper.tex",
+      "a\\input{f}b",
+      deps({ "f.tex": "foo\n" }),
+    );
+    expect(p.text).toBe("afoo\nb");
+  });
+
+  it("an empty file reads no line: it adds nothing", () => {
+    const p = assemblePaper("paper.tex", "a\\input{f}b", deps({ "f.tex": "" }));
+    expect(p.text).toBe("ab");
+  });
+
+  it("the main file is not ended: its text is the caller's, as given", () => {
+    const p = assemblePaper("paper.tex", "no newline", deps({}));
+    expect(p.text).toBe("no newline");
+  });
+
+  it("the end of line belongs to the file it ends, at the end of that file", () => {
+    const p = assemblePaper(
+      "paper.tex",
+      "a\\input{f}b",
+      deps({ "f.tex": "foo" }),
+    );
+    expect(originOf(p, { start: 4, end: 5 })).toEqual({
+      file: "f.tex",
+      source: "foo",
+      span: { start: 3, end: 4 },
+      via: { start: 1, end: 10 },
+    });
   });
 });
 
@@ -129,7 +167,7 @@ describe("originOf — where a span of the assembled text comes from", () => {
   });
 
   it("after the include: offsets in the main file past the macro", () => {
-    expect(originOf(p, { start: 5, end: 7 })).toEqual({
+    expect(originOf(p, { start: 6, end: 8 })).toEqual({
       file: "paper.tex",
       source: "ab\\input{x}cd",
       span: { start: 11, end: 13 },
@@ -147,10 +185,10 @@ describe("originOf — where a span of the assembled text comes from", () => {
   });
 
   it("an empty span at the very end belongs to the last stretch; outside the text there is none", () => {
-    expect(originOf(p, { start: 7, end: 7 })?.span).toEqual({
+    expect(originOf(p, { start: 8, end: 8 })?.span).toEqual({
       start: 13,
       end: 13,
     });
-    expect(originOf(p, { start: 9, end: 9 })).toBe(null);
+    expect(originOf(p, { start: 10, end: 10 })).toBe(null);
   });
 });

package/src/domain/paper-source.ts

@@ -9,12 +9,19 @@
  * answers about one file (the class, the outline, the rendered text, the body's passages) is
  * answered about the paper, unchanged. A subfile is a document of its own; only its body is spliced.
  *
+ * ── THE END OF AN INCLUDED FILE'S LAST LINE ─────────────────────────────────────
+ * TeX ends every line it reads with its end-of-line character, the last line of a file included:
+ * `a\input{f}b` with `f` holding `foo` and no final newline typesets "afoo b" (measured, TeX Live
+ * 2026), not "afoob". The splice does the same: an included file whose text does not end in a newline
+ * gets one, mapped to the end of that file; an empty file read no line and gets nothing. The main file
+ * is the caller's text and is left as given.
+ *
  * ── WHAT IS NOT DONE ─────────────────────────────────────────────────────────────
  * No macro is expanded, so a path built from a macro (`\input{\dir/intro}`) is read as written. A
- * file that cannot be found is left out and named in `missing`; a file that includes itself,
- * directly or through others, is spliced once.
+ * file the caller's `read` has none of contributes nothing; a file that includes itself, directly or
+ * through others, is spliced once.
  */
-import { extname, normalize } from "node:path";
+import { posix } from "node:path";
 import type { Span } from "./tex-document.ts";
 
 /** One `\input`, `\include` or `\subfile` in a source: the path as written and where the macro stands. */
@@ -46,27 +53,17 @@ export interface Segment {
   readonly via: Span | null;
 }
 
-/** An include whose file was not found, where it stands. */
-export interface MissingInclude {
-  readonly file: string;
-  readonly target: string;
-  readonly span: Span;
-  /** Where it stands in the main file (the include itself, or the one that brought its file in). */
-  readonly via: Span;
-}
-
-/** The paper as one text, the map back to its files, and the includes that were not found. */
+/** The paper as one text, and the map back to its files. */
 export interface PaperSource {
   readonly main: string;
   readonly text: string;
   readonly segments: readonly Segment[];
-  readonly missing: readonly MissingInclude[];
 }
 
 /** The paths TeX tries for a target: `name.tex`, then `name` — or the name alone if it has one. */
 const candidates = (target: string): readonly string[] => {
-  const t = normalize(target.trim());
-  return extname(t) === "" ? [`${t}.tex`, t] : [t];
+  const t = posix.normalize(target.trim());
+  return posix.extname(t) === "" ? [`${t}.tex`, t] : [t];
 };
 
 /** The first candidate path that exists, with its text. */
@@ -81,11 +78,10 @@ function found(
   return hits[0] ?? null;
 }
 
-/** An assembled piece of text: the text, its segments from 0, and the includes not found. */
+/** An assembled piece of text: the text and its segments from 0. */
 interface Piece {
   readonly text: string;
   readonly segments: readonly Segment[];
-  readonly missing: readonly MissingInclude[];
 }
 
 /** `segments` moved by `by` characters. */
@@ -111,11 +107,10 @@ const copied = ({ file, text, from, to, via }: Stretch): Piece => ({
     to > from
       ? [{ start: 0, end: to - from, file, source: text, from, via }]
       : [],
-  missing: [],
 });
 
 /** Nothing: an include left out. */
-const NOTHING: Piece = { text: "", segments: [], missing: [] };
+const NOTHING: Piece = { text: "", segments: [] };
 
 /** Pieces joined in order. */
 const joined = (pieces: readonly Piece[]): Piece =>
@@ -123,7 +118,6 @@ const joined = (pieces: readonly Piece[]): Piece =>
     (acc, p) => ({
       text: acc.text + p.text,
       segments: [...acc.segments, ...shifted(p.segments, acc.text.length)],
-      missing: [...acc.missing, ...p.missing],
     }),
     NOTHING,
   );
@@ -153,7 +147,7 @@ function spliced(file: string, text: string, range: Span, ctx: Context): Piece {
       pieces: [
         ...acc.pieces,
         at(acc.cursor, inc.span.start),
-        included(file, inc, ctx),
+        included(inc, ctx),
       ],
       cursor: inc.span.end,
     }),
@@ -162,23 +156,30 @@ function spliced(file: string, text: string, range: Span, ctx: Context): Piece {
   return joined([...pieces, at(cursor, range.end)]);
 }
 
-/** One include: the file it names, spliced, or — when not found — nothing, and a report. */
-function included(file: string, inc: Include, ctx: Context): Piece {
+/** TeX's end of line after the last line of `file`, standing where its text ends: one newline. */
+const endOfLine = (file: string, text: string, via: Span | null): Piece => ({
+  text: "\n",
+  segments: [{ start: 0, end: 1, file, source: text, from: text.length, via }],
+});
+
+/** One include: the file it names, spliced, or — when the reader has none of it — nothing. */
+function included(inc: Include, ctx: Context): Piece {
   const via = ctx.via ?? inc.span;
   const hit = found(inc.target, ctx.deps.read);
-  if (hit === null)
-    return {
-      ...NOTHING,
-      missing: [{ file, target: inc.target, span: inc.span, via }],
-    };
-  if (ctx.stack.includes(hit.path)) return NOTHING;
+  if (hit === null || ctx.stack.includes(hit.path)) return NOTHING;
   const body = inc.macro === "subfile" ? ctx.deps.documentBody(hit.text) : null;
-  return spliced(
-    hit.path,
-    hit.text,
-    body ?? { start: 0, end: hit.text.length },
-    { deps: ctx.deps, stack: [...ctx.stack, hit.path], via },
-  );
+  const range = body ?? { start: 0, end: hit.text.length };
+  const piece = spliced(hit.path, hit.text, range, {
+    deps: ctx.deps,
+    stack: [...ctx.stack, hit.path],
+    via,
+  });
+  // The last line of the file is read to its end; a subfile's body ends inside its last line.
+  const endsLine =
+    range.end === hit.text.length &&
+    hit.text !== "" &&
+    !hit.text.endsWith("\n");
+  return endsLine ? joined([piece, endOfLine(hit.path, hit.text, via)]) : piece;
 }
 
 /** The paper whose main file is `main` (a path relative to the paper directory) with `text`. */
@@ -193,12 +194,7 @@ export function assemblePaper(
     { start: 0, end: text.length },
     { deps, stack: [main], via: null },
   );
-  return {
-    main,
-    text: p.text,
-    segments: p.segments,
-    missing: p.missing,
-  };
+  return { main, text: p.text, segments: p.segments };
 }
 
 /** Where a span of the assembled text stands: in which file, at which offsets, and via which include. */