paperlint 4.1.0 → 5.0.0

package/src/cli.harness.mjs

@@ -132,8 +132,8 @@ check(
     Array.isArray(cfg) && ruleBlocks(cfg).length === 4,
   );
   check(
-    "with a LaTeX language a fifth block is added",
-    ruleBlocks(buildConfig({}, {})).length === 5,
+    "with a LaTeX language two blocks are added: paper.tex, and the files it includes",
+    ruleBlocks(buildConfig({}, {})).length === 6,
   );
   check(
     "🔴 the project's paper TEMPLATE directory is ignored — flat config does not skip dot-directories",
@@ -181,7 +181,7 @@ check(
     writeFileSync(join(paper, "paper.md"), "# Intro\n\nRQ1: does it hold?\n");
     writeFileSync(
       join(paper, "PIPELINE-STATUS.md"),
-      `---\nstages:\n  - stage: submitted\n    date: 2026-07-22\n    pdf: versions/2026-07-22-submitted.pdf\n    bytes: 100\n    source: versions/s.tex\n    sourceBytes: 4\nresearchQuestion: "does it hold?"\n---\n# S\n\n| id | note |\n|---|---|\n| cites | bib-authors run |\n`,
+      `---\nstages:\n  - stage: submitted\n    date: 2026-07-22\n    pdf: versions/2026-07-22-submitted.pdf\n    bytes: 100\n    source: versions/s.tex\n    sourceBytes: 4\n---\n# S\n\n| id | note |\n|---|---|\n| cites | bib-authors run |\n`,
     );
     writeFileSync(
       join(root, "package.json"),
@@ -441,32 +441,14 @@ check(
         !existsSync(join(dir, WORKFLOW_PATH)),
       );
       check(
-        "and the CI step is still printed — it just gets pasted in by hand",
-        /uses: zernie\/paperlint@/.test(out.text()) &&
-          /paths: writing/.test(out.text()),
-      );
-    }
-    {
-      // Guards: the printed step carries the tag of the running release, not a placeholder.
-      const dir = project("ci-printed-pin", { papers: ["writing"] });
-      const out = say();
-      await init(dir, {
-        log: out.log,
-        err: out.log,
-        interactive: false,
-        run: haveAll,
-        version: "1.2.3",
-      });
-      check(
-        "🔴 a released version — the printed step is pinned to its tag, no <commit-sha>",
-        /uses: zernie\/paperlint@v1\.2\.3\b/.test(out.text()) &&
-          !/<commit-sha>/.test(out.text()),
+        "and the CI steps are still printed — they just get pasted in by hand",
+        out.text().includes("- uses: ./node_modules/paperlint"),
       );
     }
     {
       const dir = project("ci-yes", { papers: ["writing"] });
       const asked = [];
-      const wf = await offerWorkflow(dir, "writing", {
+      const wf = await offerWorkflow(dir, {
         interactive: true,
         ask: async (q) => {
           asked.push(q);
@@ -477,16 +459,22 @@ check(
         "saying yes WRITES the workflow",
         wf === "written" && existsSync(join(dir, WORKFLOW_PATH)),
       );
+      const steps =
+        yamlLoad(readFileSync(join(dir, WORKFLOW_PATH), "utf8"))?.jobs?.papers
+          ?.steps ?? [];
       check(
-        "and the workflow carries THE directory that was actually discussed",
-        /paths: writing/.test(readFileSync(join(dir, WORKFLOW_PATH), "utf8")),
+        "🔴 the workflow runs the action from the installed package — one revision, set by the lockfile",
+        steps.some((st) => st.uses === "./node_modules/paperlint") &&
+          !steps.some((st) =>
+            String(st.uses ?? "").startsWith("zernie/paperlint"),
+          ),
       );
       check(
-        "without a known release the action keeps the obvious placeholder, never a guessed tag",
-        /@<commit-sha>/.test(readFileSync(join(dir, WORKFLOW_PATH), "utf8")),
+        "and it repeats no papers directory — the action reads papersDir from paperlint.json",
+        steps.every((st) => st.with?.paths === undefined),
       );
       check("the question is asked exactly once", asked.length === 1);
-      const again = await offerWorkflow(dir, "writing", {
+      const again = await offerWorkflow(dir, {
         interactive: true,
         ask: async () => "y",
       });
@@ -495,29 +483,9 @@ check(
         again === "kept",
       );
     }
-    {
-      const dir = project("ci-pinned", { papers: ["writing"] });
-      const wf = await offerWorkflow(dir, "writing", {
-        interactive: true,
-        ask: async () => "y",
-        version: "1.2.3",
-      });
-      const yaml = existsSync(join(dir, WORKFLOW_PATH))
-        ? readFileSync(join(dir, WORKFLOW_PATH), "utf8")
-        : "";
-      const uses = (yamlLoad(yaml)?.jobs?.papers?.steps ?? []).map(
-        (s) => s.uses,
-      );
-      check(
-        "🔴 a released version — the written workflow is pinned to its tag, no <commit-sha> left",
-        wf === "written" &&
-          uses.includes("zernie/paperlint@v1.2.3") &&
-          !yaml.includes("<commit-sha>"),
-      );
-    }
     {
       const dir = project("ci-no", { papers: ["writing"] });
-      const no = await offerWorkflow(dir, "writing", {
+      const no = await offerWorkflow(dir, {
         interactive: true,
         ask: async () => "",
       });
@@ -532,7 +500,7 @@ check(
       // 🔴 THE `.catch` HERE IS LOAD-BEARING, NOT CAUTION. A leaked exception is a PROPERTY that
       // gets asserted; without it, the harness crashes instead of failing a named assertion,
       // i.e. the real defect would look like a hole in the test rather than a caught one.
-      const aborted = await offerWorkflow(dir, "writing", {
+      const aborted = await offerWorkflow(dir, {
         interactive: true,
         ask: async () => {
           throw new Error("Aborted with Ctrl+D");
@@ -733,7 +701,7 @@ check(
       "x".repeat(100),
     );
     const status = (bytes) =>
-      `---\nstages:\n  - stage: submitted\n    date: 2026-07-22\n    pdf: versions/2026-07-22-submitted.pdf\n    bytes: ${bytes}\n    source: versions/s.tex\n    sourceBytes: 4\nresearchQuestion: "does it hold?"\n---\n# S\n\n| id | note |\n|---|---|\n| cites | bib-authors run |\n`;
+      `---\nstages:\n  - stage: submitted\n    date: 2026-07-22\n    pdf: versions/2026-07-22-submitted.pdf\n    bytes: ${bytes}\n    source: versions/s.tex\n    sourceBytes: 4\n---\n# S\n\n| id | note |\n|---|---|\n| cites | bib-authors run |\n`;
     writeFileSync(join(paper, "versions", "s.tex"), "abcd");
     writeFileSync(join(paper, "paper.md"), "# Intro\n\nRQ1: does it hold?\n");
 
@@ -822,7 +790,7 @@ check(
     );
     writeFileSync(join(paper, "paper.md"), "# Intro\n\nRQ1: does it hold?\n");
     const status = (bytes) =>
-      `---\nstages:\n  - stage: submitted\n    date: 2026-07-22\n    pdf: versions/2026-07-22-submitted.pdf\n    bytes: ${bytes}\n    source: versions/s.tex\n    sourceBytes: 4\nresearchQuestion: "does it hold?"\n---\n# S\n\n| id | note |\n|---|---|\n| cites | bib-authors run |\n`;
+      `---\nstages:\n  - stage: submitted\n    date: 2026-07-22\n    pdf: versions/2026-07-22-submitted.pdf\n    bytes: ${bytes}\n    source: versions/s.tex\n    sourceBytes: 4\n---\n# S\n\n| id | note |\n|---|---|\n| cites | bib-authors run |\n`;
     writeFileSync(join(paper, "PIPELINE-STATUS.md"), status(100));
 
     // findProjectRoot — kept separate from the run so the failure is distinguishable
@@ -934,7 +902,7 @@ check(
     );
     writeFileSync(
       join(paper, "PIPELINE-STATUS.md"),
-      `---\nstages:\n  - stage: submitted\n    date: 2026-07-22\n    pdf: versions/2026-07-22-submitted.pdf\n    bytes: 100\n    source: versions/s.tex\n    sourceBytes: 4\nresearchQuestion: "does it hold?"\n---\n# S\n\n| id | note |\n|---|---|\n| cites | bib-authors run |\n`,
+      `---\nstages:\n  - stage: submitted\n    date: 2026-07-22\n    pdf: versions/2026-07-22-submitted.pdf\n    bytes: 100\n    source: versions/s.tex\n    sourceBytes: 4\n---\n# S\n\n| id | note |\n|---|---|\n| cites | bib-authors run |\n`,
     );
     writeFileSync(
       join(root, "paperlint.json"),

package/src/cli.test.ts

@@ -14,7 +14,6 @@ import type { runToolchain } from "./toolchain.ts";
 import {
   chooseVenue,
   initTexLive,
-  ownVersion,
   paperRuleBlocks,
   parseArgs,
   parseSettings,
@@ -259,7 +258,7 @@ test("build: a markdown-only paper is refused", async () => {
     code: 1,
     out: [
       "papers/md",
-      `  inputs: TEXINPUTS += ${venues}`,
+      `  inputs: TEXINPUTS += the paper's directory, then ${venues}`,
       "  compile: refused — no paper.tex; paperlint compiles LaTeX, and this paper has none",
       "  measure: skipped — nothing is compiled",
       "  references: skipped — nothing is compiled",
@@ -288,7 +287,7 @@ test("build: with no TeX Live a dry run says where a real run stops, and a real
         out: [
           `engine: none — a real run would stop here: paperlint build: no TeX Live with every package these papers need — run \`npx paperlint toolchain\` (${missing})`,
           "papers/tex",
-          `  inputs: TEXINPUTS += ${venues}`,
+          `  inputs: TEXINPUTS += the paper's directory, then ${venues}`,
           "  compile: paper.tex (\\documentclass{article})",
           "  measure: pdf.js → _build/paper.facts.json (facts for the lint rules; nothing is judged here)",
           "  references: online: citations exist, titles and authors match → _build/references.json (never fails the build)",
@@ -529,21 +528,6 @@ test("chooseVenue: a question that fails (the stream ended) takes the default, n
   assert.deepEqual(r, { ok: true, value: null });
 });
 
-test("ownVersion: the manifest's version; an unreadable manifest or a non-string version is undefined", () => {
-  assert.deepEqual(
-    [
-      ownVersion(() => '{"version": "1.2.3"}'),
-      ownVersion(() => "{ nope"),
-      ownVersion(() => '{"version": 3}'),
-      ownVersion(() => {
-        throw new Error("ENOENT");
-      }),
-      typeof ownVersion(),
-    ],
-    ["1.2.3", undefined, undefined, undefined, "string"],
-  );
-});
-
 test("init's TeX Live install runs the toolchain over the project's papers, never a check", () => {
   const dir = writeTree(join(root, "init-tex"), { "package.json": "{}" });
   const calls: Parameters<typeof runToolchain>[0][] = [];

package/src/cli.ts

@@ -9,8 +9,8 @@
  * but that is INTERNAL machinery, and you no longer need to know it in order to run them.
  *
  * Two entry points into the tool, and both are whole now:
- *     npx paperlint lint              ← here
- *     uses: zernie/paperlint@<sha>    ← action.yml
+ *     npx paperlint lint                ← here
+ *     uses: ./node_modules/paperlint    ← action.yml, after `npm ci`
  *
  * ⚠️ THE BOUNDARY THIS UTILITY HAS NO RIGHT TO ERASE: the consumer's data stays with the consumer.
  * Where the papers are and the project's own rule blocks — that is about ONE corpus, so it lives in
@@ -42,6 +42,7 @@ import {
   asEslintResults,
 } from "./structure.ts";
 import { buildPapers, papersIn, anyFailed, remedyFor, MAIN } from "./build.ts";
+import { 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";
@@ -50,6 +51,8 @@ import { latexReader } from "./adapters/latex/index.ts";
 import { hostDirs, nodeAdapters, nodeFiles } from "./adapters/node/index.ts";
 import { VENUE_RULE_LEVELS, venueRules } from "./venue-rules.ts";
 import { TEX_VENUE_RULE_LEVELS, texVenueRules } from "./tex-venue-rules.ts";
+import { claimProvenanceRule } from "./claim-provenance.ts";
+import { registerRule } from "./register.ts";
 import {
   paperRules,
   stringFields,
@@ -122,7 +125,6 @@ export { init };
 export { nextSteps } from "./init.ts";
 
 import paperStages from "#eslint-rules/paper-stages";
-import researchQuestion from "#eslint-rules/paper-research-question";
 import typography from "#eslint-rules/paper-typography";
 import texBuild from "#eslint-rules/tex-build";
 import bibReachable from "#eslint-rules/bib-reachable-entry";
@@ -225,7 +227,7 @@ export function buildConfig(
   opts: PaperlintConfig = {},
   texLanguage: unknown,
 ): ConfigBlock[] {
-  const paperRules = { ...researchQuestion.rules, ...typography.rules };
+  const paperRules = { ...typography.rules };
   // The reference rules judge `_build/references.json`, and only on `paper.tex`.
   const texPaperRules = {
     ...paperRules,
@@ -233,7 +235,6 @@ export function buildConfig(
   };
   // Each typography rule reports every occurrence where it is, and fixes it (`--fix`).
   const prose = {
-    "paper/research-question": "warn",
     "paper/section-word": "warn",
     "paper/leading-zero": "warn",
   };
@@ -312,6 +313,14 @@ export function buildConfig(
               venuesDir: presetsDir(),
               latex: latexReader,
             }),
+            "claim-provenance": claimProvenanceRule({
+              files: nodeFiles,
+              latex: latexReader,
+            }),
+            register: registerRule({
+              files: nodeFiles,
+              latex: latexReader,
+            }),
           },
         },
         paper: { rules: texPaperRules },
@@ -324,23 +333,64 @@ export function buildConfig(
         "paper/figure-ref-style": "warn",
         "bib/reachable-entry": "warn",
         "tex/future-promise": "warn",
+        // A number with no owner: a prose rule, on beside the others above.
+        "tex/claim-provenance": "warn",
+        // Sentence-initial conjunctions over the whole body: register, not vocabulary.
+        "tex/register": "warn",
         "tex/acm-frontmatter-override": "error",
         // Silent for a paper whose paperlint.json names no venue (src/venue-rules.ts).
         ...VENUE_RULE_LEVELS,
         ...TEX_VENUE_RULE_LEVELS,
       },
     });
+  // THE FILES A paper.tex INCLUDES FROM ITS BODY, each read on its own and reported at its own path
+  // (#144). The block claims every `.tex` but `paper.tex` — yet it is left out of the scope below, so
+  // it reaches only the files `paperlint lint` un-ignores by name for each paper (src/paper-includes.ts):
+  // a frozen version or a macro file is never enumerated. The rules are the ones that read a file as
+  // a fragment (no `document` environment: all of it is body); the whole-paper rules stay on
+  // `paper.tex`, which reads its includes itself (src/tex-paper.ts).
+  const fragments: readonly ConfigBlock[] = texLanguage
+    ? [
+        {
+          files: ["**/*.tex"],
+          ignores: ["**/paper.tex"],
+          plugins: {
+            tex: {
+              languages: { latex: texLanguage },
+              rules: { "future-promise": texBuild["future-promise"] },
+            },
+            paper: {
+              rules: {
+                "section-word": typography.rules["section-word"],
+                "leading-zero": typography.rules["leading-zero"],
+                "figure-ref-style": typography.rules["figure-ref-style"],
+              },
+            },
+          },
+          language: "tex/latex",
+          rules: {
+            "paper/section-word": "warn",
+            "paper/leading-zero": "warn",
+            "paper/figure-ref-style": "warn",
+            "tex/future-promise": "warn",
+          },
+        },
+      ]
+    : [];
   // 🔴 ONLY THE FILES THESE BLOCKS CLAIM ARE LINTED (src/paper-files.ts). Without this block ESLint's
   // built-in defaults lint every .js/.mjs/.cjs under the papers directory — a paper's vendored
   // `repro/` code failed the run with 74 parse errors and not one finding on a paper file. It goes
   // FIRST: the `.template/` ignore below must come after its directory un-ignore to win.
-  const owners = ruleOwners(cfg);
+  const owners = ruleOwners([...cfg, ...fragments]);
   cfg.unshift(scopeToOwned(ownedPatterns(cfg)));
   // The consumer's own blocks, LAST, so a later block wins — ESLint's rule. Parsed by
   // `readConfig`; each carries the settings file's directory as its `basePath`. Each is split so a
   // rule reaches only the files its plugin is registered for: `paper` is a different plugin beside
   // PIPELINE-STATUS.md than beside paper.tex, and ESLint throws on a rule its plugin lacks.
-  cfg.push(...(opts.rules ?? []).flatMap((b) => narrowToOwners(b, owners)));
+  cfg.push(
+    ...fragments,
+    ...(opts.rules ?? []).flatMap((b) => narrowToOwners(b, owners)),
+  );
   return cfg;
 }
 
@@ -481,6 +531,17 @@ export async function silentOptionalRules(
   return [...turnedOn].filter((id) => !reached.has(id));
 }
 
+/**
+ * The paper directories `paths` reach: each directory and the papers under it. A FILE named on the
+ * command line belongs to the paper it sits in.
+ */
+function paperDirs(paths: readonly string[]): readonly string[] {
+  const dirs = paths.map((p) =>
+    existsSync(p) && statSync(p).isFile() ? dirname(p) : p,
+  );
+  return [...new Set(dirs.flatMap((p) => [p, ...papersIn(p)]))];
+}
+
 /**
  * Every linted paper's rules, as ESLint blocks scoped to that paper, in two groups: what its venue
  * preset turns on, and what its own `paperlint.json` says. The caller puts the root's blocks between
@@ -490,11 +551,7 @@ export async function silentOptionalRules(
 export function paperRuleBlocks(
   paths: readonly string[],
 ): Parsed<{ preset: RuleBlock[]; own: RuleBlock[] }> {
-  // A FILE named on the command line belongs to the paper it sits in: that paper's settings apply.
-  const dirs = paths.map((p) =>
-    existsSync(p) && statSync(p).isFile() ? dirname(p) : p,
-  );
-  const papers = [...new Set(dirs.flatMap((p) => [p, ...papersIn(p)]))];
+  const papers = paperDirs(paths);
   const out: { preset: RuleBlock[]; own: RuleBlock[] } = {
     preset: [],
     own: [],
@@ -745,28 +802,6 @@ const VALUE_FLAGS: ReadonlySet<string> = new Set([
   "--max-warnings",
 ]);
 
-/**
- * This package's own version, from the `package.json` beside `src/` and `dist/` alike. `init` pins
- * the CI action to its release tag; an unreadable manifest yields `undefined`, and init then keeps
- * the placeholder instead of guessing.
- */
-export function ownVersion(
-  readManifest: () => string = () =>
-    readFileSync(new URL("../package.json", import.meta.url), "utf8"),
-): string | undefined {
-  try {
-    const manifest: unknown = JSON.parse(readManifest());
-    return typeof manifest === "object" &&
-      manifest !== null &&
-      "version" in manifest &&
-      typeof manifest.version === "string"
-      ? manifest.version
-      : undefined;
-  } catch {
-    return undefined;
-  }
-}
-
 /**
  * Reading the config, ONE reader for all commands. Pulled out of `run()` the moment a second
  * command needed the same config (`build`): two copies of this block would have drifted apart on
@@ -1401,7 +1436,6 @@ async function runInit(
     log,
     err,
     cwd,
-    version: ownVersion(),
     yes: a.yes,
     hooks: !a.noHooks,
     paper: a.paper,
@@ -1537,10 +1571,32 @@ export async function run(
     texLanguage = null;
   }
 
+  // Each paper's body files, resolved the way the build resolves 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,
+      })
+    : [];
+  // 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),
     overrideConfigFile: true,
-    overrideConfig: eslintConfig(buildConfig(withPapers, texLanguage)),
+    overrideConfig: eslintConfig([
+      ...buildConfig(withPapers, texLanguage),
+      ...includeBlocks(bodies),
+    ]),
     fix: a.fix,
   });
 

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

@@ -0,0 +1,156 @@
+/**
+ * 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.
+ * 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`).
+ */
+import { describe, expect, it } from "vitest";
+import {
+  assemblePaper,
+  originOf,
+  type AssembleDeps,
+  type Include,
+} from "./paper-source.ts";
+
+/** `\input{x}` / `\include{x}` / `\subfile{x}` in `src`, by a scan good enough for these inputs. */
+const includes = (src: string): readonly Include[] =>
+  [...src.matchAll(/\\(input|include|subfile)\{([^}]*)\}/gu)].map((m) => ({
+    macro:
+      m[1] === "subfile" ? "subfile" : m[1] === "include" ? "include" : "input",
+    target: m[2] ?? "",
+    span: { start: m.index, end: m.index + m[0].length },
+  }));
+
+const deps = (files: Record<string, string>): AssembleDeps => ({
+  includes,
+  documentBody: (src) => {
+    const a = src.indexOf("\\begin{document}");
+    const b = src.indexOf("\\end{document}");
+    return a < 0 || b < 0
+      ? null
+      : { start: a + "\\begin{document}".length, end: b };
+  },
+  read: (p) => files[p] ?? null,
+});
+
+describe("assemblePaper — the text TeX reads", () => {
+  it("splices each file where its include stands; `.tex` is tried first", () => {
+    const main = "A\\input{s/one}B\\include{two.tex}C";
+    const p = assemblePaper(
+      "paper.tex",
+      main,
+      deps({ "s/one.tex": "one", "two.tex": "two" }),
+    );
+    expect(p.text).toBe("AoneBtwoC");
+    expect(p.missing).toEqual([]);
+    expect([...new Set(p.segments.map((g) => g.file))]).toEqual([
+      "paper.tex",
+      "s/one.tex",
+      "two.tex",
+    ]);
+  });
+
+  it("nested includes resolve from the paper directory, and map back through the outermost include", () => {
+    const main = "x\\input{a}y";
+    const p = assemblePaper(
+      "paper.tex",
+      main,
+      deps({ "a.tex": "[\\input{s/b}]", "s/b.tex": "BB" }),
+    );
+    expect(p.text).toBe("x[BB]y");
+    expect(originOf(p, { start: 2, end: 4 })).toEqual({
+      file: "s/b.tex",
+      source: "BB",
+      span: { start: 0, end: 2 },
+      via: { start: 1, end: 10 },
+    });
+  });
+
+  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({}));
+    expect(p.text).toBe("ab");
+    expect(p.missing).toEqual([
+      {
+        file: "paper.tex",
+        target: "gone",
+        span: { start: 1, end: 13 },
+        via: { start: 1, end: 13 },
+      },
+    ]);
+  });
+});
+
+describe("assemblePaper — subfiles and a file that includes itself", () => {
+  it("a subfile contributes its document body, not its preamble", () => {
+    const sub =
+      "\\documentclass[paper]{subfiles}\\begin{document}BODY\\end{document}";
+    const p = assemblePaper(
+      "paper.tex",
+      "<\\subfile{s}>",
+      deps({ "s.tex": sub }),
+    );
+    expect(p.text).toBe("<BODY>");
+  });
+
+  it("a subfile with no document environment is read whole", () => {
+    const p = assemblePaper(
+      "paper.tex",
+      "<\\subfile{s}>",
+      deps({ "s.tex": "ALL" }),
+    );
+    expect(p.text).toBe("<ALL>");
+  });
+
+  it("a file that includes itself is entered once", () => {
+    const p = assemblePaper(
+      "paper.tex",
+      "m\\input{a}",
+      deps({ "a.tex": "a\\input{a}\\input{paper.tex}" }),
+    );
+    expect(p.text).toBe("ma");
+  });
+});
+
+describe("originOf — where a span of the assembled text comes from", () => {
+  const p = assemblePaper(
+    "paper.tex",
+    "ab\\input{x}cd",
+    deps({ "x.tex": "XYZ" }),
+  );
+
+  it("in the main file: its own offsets, via nothing", () => {
+    expect(originOf(p, { start: 0, end: 2 })).toEqual({
+      file: "paper.tex",
+      source: "ab\\input{x}cd",
+      span: { start: 0, end: 2 },
+      via: null,
+    });
+  });
+
+  it("after the include: offsets in the main file past the macro", () => {
+    expect(originOf(p, { start: 5, end: 7 })).toEqual({
+      file: "paper.tex",
+      source: "ab\\input{x}cd",
+      span: { start: 11, end: 13 },
+      via: null,
+    });
+  });
+
+  it("a span running out of an included file is cut at its end", () => {
+    expect(originOf(p, { start: 3, end: 7 })).toEqual({
+      file: "x.tex",
+      source: "XYZ",
+      span: { start: 1, end: 3 },
+      via: { start: 2, end: 11 },
+    });
+  });
+
+  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({
+      start: 13,
+      end: 13,
+    });
+    expect(originOf(p, { start: 9, end: 9 })).toBe(null);
+  });
+});