paperlint 4.2.0 → 5.0.0

package/src/paper-includes.test.ts

@@ -0,0 +1,161 @@
+/**
+ * `paperlint lint` over a paper whose body is in other files: the rules over ESLint's LaTeX text read
+ * every file `paper.tex` includes from its document body, report at that file's own path and line,
+ * and fix that file. What a rule decides for the whole paper — the majority reference form and
+ * whether the build is in review mode — it decides over all of the paper's files, not over the one
+ * it is reporting in.
+ */
+import {
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  realpathSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+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";
+
+const dirs: string[] = [];
+afterEach(() => {
+  for (const d of dirs.splice(0)) rmSync(d, { recursive: true, force: true });
+});
+
+const doc = (cls: string, preamble: string, body: string): string =>
+  `\\documentclass${cls}\n${preamble}\n\\begin{document}\n${body}\n\\end{document}\n`;
+
+const INTRO = "See §3 and p < .05.\nAs Fig.~\\ref{f3} shows.\n";
+
+function project(files: Record<string, string>): string {
+  const root = realpathSync(mkdtempSync(join(tmpdir(), "paperlint-inc-")));
+  dirs.push(root);
+  const all: Record<string, string> = {
+    "package.json": JSON.stringify({ name: "c", private: true }),
+    "papers/a/PIPELINE-STATUS.md": "---\nstages: []\n---\n",
+    "papers/a/paper.tex": doc(
+      "{article}",
+      "\\input{macros}",
+      "Figure~\\ref{f1} and Figure~\\ref{f2}.\n\\input{sections/intro}",
+    ),
+    // Prose in a preamble include is not the body: were it linted, `§2` would be reported.
+    "papers/a/macros.tex": "% See §2.\n\\newcommand{\\half}{0.5}\nSee §2.\n",
+    "papers/a/sections/intro.tex": INTRO,
+    // A frozen version beside the paper is not the paper.
+    "papers/a/versions/2026-01-01-submitted.tex": doc(
+      "{article}",
+      "",
+      "See §9.",
+    ),
+    ...files,
+  };
+  for (const [p, text] of Object.entries(all)) {
+    mkdirSync(join(root, p, ".."), { recursive: true });
+    writeFileSync(join(root, p), text);
+  }
+  return root;
+}
+
+/** `paperlint lint --json` → rule ids per linted file (relative to the project), and stderr. */
+async function lint(
+  root: string,
+  args: string[] = [],
+): Promise<{ byFile: Record<string, string[]>; err: string }> {
+  const out: string[] = [];
+  const err: string[] = [];
+  await run(["lint", "--json", ...args], {
+    cwd: root,
+    log: (s: string) => out.push(s),
+    err: (s: string) => err.push(s),
+  });
+  const byFile = Object.fromEntries(
+    lintReport(out.join("\n")).map((r) => [
+      relative(root, r.filePath),
+      r.messages.map((m) => m.ruleId ?? "(fatal)").sort(),
+    ]),
+  );
+  return { byFile, err: err.join("\n") };
+}
+
+describe("lint reads the files paper.tex includes from its body", () => {
+  it("🔴 findings in an included file land at that file; the majority form is the paper's", async () => {
+    const { byFile } = await lint(project({}));
+    expect(byFile["papers/a/sections/intro.tex"]).toEqual([
+      "paper/figure-ref-style",
+      "paper/leading-zero",
+      "paper/section-word",
+    ]);
+    // Two `Figure` in paper.tex against one `Fig.` in the section: the section holds the minority.
+    expect(byFile["papers/a/paper.tex"]).not.toContain(
+      "paper/figure-ref-style",
+    );
+  });
+
+  it("a preamble include and a frozen version beside the paper are not linted", async () => {
+    const { byFile } = await lint(project({}));
+    expect(Object.keys(byFile).sort()).toEqual([
+      "papers/a/PIPELINE-STATUS.md",
+      "papers/a/paper.tex",
+      "papers/a/sections/intro.tex",
+    ]);
+  });
+
+  it("--fix rewrites the included file, to the paper's majority form", async () => {
+    const root = project({});
+    const before = readFileSync(join(root, "papers/a/paper.tex"), "utf8");
+    const { byFile } = await lint(root, ["--fix"]);
+    expect(byFile["papers/a/sections/intro.tex"]).toEqual([]);
+    expect(
+      readFileSync(join(root, "papers/a/sections/intro.tex"), "utf8"),
+    ).toBe("See Section 3 and p < 0.05.\nAs Figure~\\ref{f3} shows.\n");
+    expect(readFileSync(join(root, "papers/a/paper.tex"), "utf8")).toBe(before);
+  });
+});
+
+describe("what lint decides for the whole paper, it decides over every file of it", () => {
+  it("tex/future-promise in an included file follows the build mode paper.tex declares", async () => {
+    const promise = {
+      "papers/a/sections/intro.tex":
+        "The harness will be released at camera-ready.\n",
+    };
+    const final = await lint(project(promise));
+    expect(final.byFile["papers/a/sections/intro.tex"]).toEqual([
+      "tex/future-promise",
+    ]);
+    const review = await lint(
+      project({
+        ...promise,
+        "papers/a/paper.tex": doc(
+          "[review]{article}",
+          "",
+          "Text.\n\\input{sections/intro}",
+        ),
+      }),
+    );
+    expect(review.byFile["papers/a/sections/intro.tex"]).toEqual([]);
+  });
+
+  it("an include that resolves nowhere is named as a file lint did not read", async () => {
+    const { err } = await lint(
+      project({
+        "papers/a/paper.tex": doc("{article}", "", "\\input{sections/gone}"),
+      }),
+    );
+    expect(err).toMatch(
+      /papers\/a\/paper\.tex: lint did not read `sections\/gone`/,
+    );
+  });
+
+  it("the note is about the papers this run lints, not another paper of the project", async () => {
+    const root = project({
+      "papers/b/PIPELINE-STATUS.md": "---\nstages: []\n---\n",
+      "papers/b/paper.tex": doc("{article}", "", "\\input{gone}"),
+    });
+    expect((await lint(root, ["papers/a"])).err).not.toMatch(/did not read/);
+    expect((await lint(root)).err).toMatch(
+      /papers\/b\/paper\.tex: lint did not read `gone`/,
+    );
+  });
+});

package/src/paper-includes.ts

@@ -0,0 +1,77 @@
+/**
+ * THE FILES OF A PAPER'S BODY, handed to ESLint — so the rules over ESLint's LaTeX text read a paper
+ * whose body is in `sections/*.tex`, and report each finding at its own file and line (#144).
+ *
+ * The set is what TeX reads, resolved by the reader the parse-tree rules use (`bodyFiles`,
+ * src/tex-paper.ts): `paper.tex` and every file an include in its document body brings in, found in
+ * the paper's directory. Not a glob over every `.tex`: a frozen version under `versions/`, a macro
+ * file the preamble includes and a scratch file nothing includes are not the paper.
+ *
+ * Two blocks per paper, both relative to the paper's directory (`basePath`):
+ *
+ * 1. a global un-ignore of each body file by name. paperlint's scope ignores every file it does not
+ *    claim (src/paper-files.ts); the fragment block (`buildConfig`) claims every `.tex` but
+ *    `paper.tex`, so only the files named here are ever enumerated;
+ * 2. `settings.paperlint.paper` for `paper.tex` and its body files: the main file and the whole set,
+ *    for the rules whose verdict is the paper's (eslint-rules/paper-context.ts).
+ */
+import { join, relative } from "node:path";
+import { PAPERLINT_SETTINGS } from "#eslint-rules/paper-context";
+import { callerPath } from "./caller-path.ts";
+import type { AbsolutePath } from "./domain/paths.ts";
+import type { ConfigBlock } from "./rules-config.ts";
+import { bodyFiles, type PaperDeps, type Unread } from "./tex-paper.ts";
+
+/** One paper's main file and body files, and the includes that resolved nowhere. */
+export interface PaperBody {
+  readonly dir: string;
+  readonly main: AbsolutePath;
+  readonly files: readonly AbsolutePath[];
+  readonly missing: readonly Unread[];
+}
+
+/** The body of each paper directory in `dirs` that has a `paper.tex`. */
+export function paperBodies(
+  dirs: readonly string[],
+  deps: PaperDeps,
+): readonly PaperBody[] {
+  return dirs.flatMap((dir) => {
+    const main = callerPath(join(dir, "paper.tex"));
+    const bytes = deps.files.readBytes(main);
+    if (bytes === null) return [];
+    const body = bodyFiles(main, new TextDecoder().decode(bytes), deps);
+    return [{ dir, main, files: body.files, missing: body.missing }];
+  });
+}
+
+/** The config blocks that hand ESLint each paper's body files, and the paper to every one of them. */
+export const includeBlocks = (
+  bodies: readonly PaperBody[],
+): readonly ConfigBlock[] =>
+  bodies.flatMap((b) => {
+    const rel = b.files.map((f) => relative(b.dir, f));
+    const paper = { main: b.main, files: [b.main, ...b.files] };
+    return [
+      ...(rel.length > 0
+        ? [{ basePath: b.dir, ignores: rel.map((r) => `!${r}`) }]
+        : []),
+      {
+        basePath: b.dir,
+        files: ["paper.tex", ...rel],
+        settings: { [PAPERLINT_SETTINGS]: { paper } },
+      },
+    ];
+  });
+
+/** One line per include that resolved nowhere: which text lint did not read, and why. */
+export const unreadLines = (
+  bodies: readonly PaperBody[],
+  shown: (path: string) => string,
+): readonly string[] =>
+  bodies.flatMap((b) =>
+    b.missing.map(
+      (m) =>
+        `${shown(b.main)}: lint did not read \`${m.target}\` (included by ${m.file}): ` +
+        "no such file in the paper's directory or paperlint's inputs",
+    ),
+  );

package/src/rule-cases.test.ts

@@ -186,25 +186,6 @@ const CASES: Readonly<Record<string, RuleCases>> = {
     },
     silent: paper(tex("x")),
   },
-  "paper/research-question": {
-    reports: {
-      tree: {
-        [STATUS_FILE]: fixture(
-          "paper-research-question/shipped-no-rq/PIPELINE-STATUS.md",
-        ),
-        [TEX_FILE]: fixture("paper-research-question/shipped-no-rq/paper.tex"),
-      },
-      file: TEX_FILE,
-      severity: 1,
-      line: 1,
-    },
-    silent: {
-      [STATUS_FILE]: fixture(
-        "paper-research-question/shipped-with-rq/PIPELINE-STATUS.md",
-      ),
-      [TEX_FILE]: fixture("paper-research-question/shipped-with-rq/paper.tex"),
-    },
-  },
   "paper/section-word": {
     reports: {
       tree: paper(tex("As in §2.")),
@@ -365,17 +346,6 @@ const CASES: Readonly<Record<string, RuleCases>> = {
     },
     silent: paper(tex(FORMAL)),
   },
-  "tex/missing-input": {
-    reports: {
-      tree: paper(tex("Text.\n\\input{sections/gone}")),
-      file: TEX_FILE,
-      severity: 1,
-      line: 4,
-    },
-    silent: paper(tex("Text.\n\\input{sections/here}"), {
-      [`${P}/sections/here.tex`]: "More text.\n",
-    }),
-  },
   "bib/reachable-entry": {
     reports: {
       tree: paper(inlineBib("@book{a,\n  title = {A},\n  year = {2026}\n}")),

package/src/rule-docs.test.ts

@@ -26,7 +26,6 @@ const AWAITING_PAGE: ReadonlySet<string> = new Set([
   "paper/leading-zero",
   "paper/refs-checked",
   "paper/refs-fresh",
-  "paper/research-question",
   "paper/section-word",
   "paper/source",
   "paper/stages",

package/src/rules-config.ts

@@ -64,6 +64,7 @@ export interface ConfigBlock {
   readonly languageOptions?: Readonly<Record<string, unknown>>;
   readonly linterOptions?: Readonly<Record<string, unknown>>;
   readonly rules?: Readonly<Record<string, unknown>>;
+  readonly settings?: Readonly<Record<string, unknown>>;
 }
 
 export type Parsed<T> =

package/src/structure.harness.ts

@@ -79,9 +79,7 @@ try {
   check(
     "and the message names the CONSEQUENCE, not a restatement of the condition",
     /are skipped/.test(at("no-scorecard")[0]?.message ?? "") &&
-      /stage, source and research-question checks/.test(
-        at("no-scorecard")[0]?.message ?? "",
-      ),
+      /stage and source checks/.test(at("no-scorecard")[0]?.message ?? ""),
   );
   check(
     "and the consequence names THIS directory by name",

package/src/structure.ts

@@ -122,7 +122,7 @@ export function checkStructure(
  */
 function whyMissingMatters(file: string, dirName: string): string {
   if (file === "PIPELINE-STATUS.md")
-    return `the stage, source and research-question checks are skipped for \`${dirName}\``;
+    return `the stage and source checks are skipped for \`${dirName}\``;
   return `declared as required by your \`structure\` configuration`;
 }
 

package/src/tex-paper.test.ts

@@ -1,81 +1,98 @@
 /**
- * `tex/missing-input` and the reading every parse-tree rule shares (`readPaper`): an include that
- * names no file is reported where it stands in `paper.tex`, once, whether `paper.tex` wrote it or a
- * file it includes did; an include that resolves says nothing.
+ * The reading every parse-tree rule shares (`readPaper`), the files of the paper's body that lint
+ * reads on their own (`bodyFiles`), and where a finding of the assembled text is reported
+ * (`reportInPaper`).
  */
 import { describe, expect, it } from "vitest";
 import { latexReader } from "./adapters/latex/index.ts";
 import { memoryFiles } from "./adapters/memory/index.ts";
-import { missingInputRule, readPaper, reportInPaper } from "./tex-paper.ts";
+import { join } from "node:path";
+import { texInputsDir } from "./package-dirs.ts";
+import { bodyFiles, readPaper, reportInPaper } from "./tex-paper.ts";
 
-const doc = (body: string): string =>
-  `\\documentclass{article}\n\\begin{document}\n${body}\n\\end{document}\n`;
+describe("readPaper — the paper as the rules read it", () => {
+  it("reads includes from the paper's own directory", () => {
+    const p = readPaper("/p/paper.tex", "x\\input{s/a}y", {
+      files: memoryFiles({ "/p/s/a.tex": "AAA" }),
+      latex: latexReader,
+    });
+    expect(p.text).toBe("xAAAy");
+    expect(p.main).toBe("paper.tex");
+  });
 
-/** What the rule reports over `/p/paper.tex` holding `src`, with `files` on disk. */
-function run(src: string, files: Record<string, string> = {}) {
-  const out: { line: number; messageId: string; data: unknown }[] = [];
-  const rule = missingInputRule({
-    files: memoryFiles(files),
-    latex: latexReader,
+  it("an include the paper's directory lacks is found in paperlint's own inputs, as the build finds it", () => {
+    const p = readPaper("/p/paper.tex", "x\\input{guards}y", {
+      files: memoryFiles({ [join(texInputsDir(), "guards.tex")]: "G" }),
+      latex: latexReader,
+    });
+    expect({ text: p.text, missing: p.missing }).toEqual({
+      text: "xGy",
+      missing: [],
+    });
   });
-  rule
-    .create({
-      filename: "/p/paper.tex",
-      sourceCode: {
-        text: src,
-        getLocFromIndex: (i) => ({
-          line: src.slice(0, i).split("\n").length,
-          column: 0,
-        }),
-      },
-      report: (d) => {
-        if ("messageId" in d)
-          out.push({
-            line: d.loc.start.line,
-            messageId: d.messageId,
-            data: d.data,
-          });
-      },
-    })
-    .root?.();
-  return out;
-}
 
-describe("tex/missing-input", () => {
-  it("an \\input naming no file is reported at its line, naming the target", () => {
-    expect(run(doc("Text.\n\\input{sections/gone}"))).toEqual([
-      {
-        line: 4,
-        messageId: "missing",
-        data: { target: "sections/gone", file: "paper.tex" },
-      },
-    ]);
+  it("the paper's directory comes first: its file wins over paperlint's of the same name", () => {
+    const p = readPaper("/p/paper.tex", "\\input{guards}", {
+      files: memoryFiles({
+        "/p/guards.tex": "mine",
+        [join(texInputsDir(), "guards.tex")]: "package",
+      }),
+      latex: latexReader,
+    });
+    expect(p.text).toBe("mine");
   });
+});
 
-  it("one missing in an included file is reported at the include that brought that file in", () => {
-    expect(run(doc("\\input{a}"), { "/p/a.tex": "A\n\\input{b}\n" })).toEqual([
-      { line: 3, messageId: "missingIn", data: { target: "b", file: "a.tex" } },
-    ]);
+describe("bodyFiles — the files of the body lint reads on their own", () => {
+  const doc = (preamble: string, body: string): string =>
+    `\\documentclass{article}\n${preamble}\n\\begin{document}\n${body}\n\\end{document}\n`;
+  const files = (extra: Record<string, string> = {}) =>
+    memoryFiles({
+      "/p/macros.tex": "\\newcommand{\\x}{y}",
+      "/p/sections/a.tex": "A\n\\input{sections/b}\n",
+      "/p/sections/b.tex": "B",
+      [join(texInputsDir(), "guards.tex")]: "G",
+      ...extra,
+    });
+
+  it("every file an include in the document body brings in, nested ones too, by absolute path", () => {
+    expect(
+      bodyFiles("/p/paper.tex", doc("", "\\input{sections/a}"), {
+        files: files(),
+        latex: latexReader,
+      }),
+    ).toEqual({
+      files: ["/p/sections/a.tex", "/p/sections/b.tex"],
+      missing: [],
+    });
   });
 
-  it("silent when every include resolves, with `.tex` added or not", () => {
+  it("not a preamble include (macros), and not a file found only in paperlint's inputs", () => {
     expect(
-      run(doc("\\input{a}\\include{b.tex}"), {
-        "/p/a.tex": "A",
-        "/p/b.tex": "B",
+      bodyFiles(
+        "/p/paper.tex",
+        doc("\\input{macros}", "\\input{guards}\nText."),
+        { files: files(), latex: latexReader },
+      ),
+    ).toEqual({ files: [], missing: [] });
+  });
+
+  it("an include that resolves nowhere is named, with the file that wrote it", () => {
+    expect(
+      bodyFiles("/p/paper.tex", doc("", "\\input{gone}"), {
+        files: files(),
+        latex: latexReader,
       }),
-    ).toEqual([]);
+    ).toEqual({ files: [], missing: [{ file: "paper.tex", target: "gone" }] });
   });
-});
 
-describe("readPaper — the paper as the rules read it", () => {
-  it("reads includes from the paper's own directory", () => {
-    const p = readPaper("/p/paper.tex", "x\\input{s/a}y", {
-      files: memoryFiles({ "/p/s/a.tex": "AAA" }),
-      latex: latexReader,
-    });
-    expect(p.text).toBe("xAAAy");
-    expect(p.main).toBe("paper.tex");
+  it("a main file with no document environment: every include is the body", () => {
+    expect(
+      bodyFiles("/p/paper.tex", "\\input{sections/b}", {
+        files: files(),
+        latex: latexReader,
+      }),
+    ).toEqual({ files: ["/p/sections/b.tex"], missing: [] });
   });
 });
 

package/src/tex-paper.ts

@@ -7,11 +7,9 @@
  * file at the include in `paper.tex` that brought it in — the one place ESLint can point to in this
  * file — with the included file, line and column at the front of the message.
  *
- *   tex/missing-input  warn  an `\input`, `\include` or `\subfile` names a file that is not there
- *
- * A missing file is a finding, not a silent skip: the rules would otherwise report a clean body for
- * text they never read, and TeX stops on it too. Warn, not error: a file a build step writes (a
- * table of generated numbers) is legitimately absent before that step has run.
+ * An include is looked for where the build tells TeX to look (`texSearchPath`): the paper's own
+ * directory, then paperlint's inputs. `bodyFiles` names the files of the paper's BODY the author
+ * wrote — what the rules over ESLint's own LaTeX text read one by one, each at its own path.
  */
 import { basename, dirname, join } from "node:path";
 import {
@@ -23,11 +21,9 @@ import type { Span } from "./domain/tex-document.ts";
 import type { LatexReader } from "./ports/latex.ts";
 import type { Files } from "./ports/files.ts";
 import { callerPath } from "./caller-path.ts";
-import type {
-  Located,
-  TexRuleContext,
-  TexRuleModule,
-} from "./tex-venue-rules.ts";
+import type { AbsolutePath } from "./domain/paths.ts";
+import { texSearchPath } from "./package-dirs.ts";
+import type { Located, TexRuleContext } from "./tex-venue-rules.ts";
 
 /** What reading a paper needs: the disk, and the LaTeX reader. */
 export interface PaperDeps {
@@ -46,12 +42,62 @@ export function readPaper(
     includes: deps.latex.includes,
     documentBody: deps.latex.documentBody,
     read: (rel) => {
-      const b = deps.files.readBytes(callerPath(join(dir, rel)));
+      const at = located(dir, rel, deps.files);
+      const b = at === null ? null : deps.files.readBytes(at);
       return b === null ? null : new TextDecoder().decode(b);
     },
   });
 }
 
+/** `rel` in the first directory of the paper's TeX search path that holds it, or null. */
+const located = (dir: string, rel: string, files: Files): AbsolutePath | null =>
+  texSearchPath(dir)
+    .map((d) => callerPath(join(d, rel)))
+    .find((p) => files.isFile(p)) ?? null;
+
+/** An include that resolved nowhere: the file that wrote it, and the path as written. */
+export interface Unread {
+  readonly file: string;
+  readonly target: string;
+}
+
+/**
+ * The files of the body of the paper whose main file is `filename`: every file an include inside its
+ * `document` environment brings in, nested ones too, found in the paper's own directory. Not a
+ * preamble include (macros are not the body), and not a file found only in paperlint's inputs (not
+ * the author's text). `missing` is every include, anywhere, that resolved nowhere.
+ */
+export function bodyFiles(
+  filename: string,
+  src: string,
+  deps: PaperDeps,
+): {
+  readonly files: readonly AbsolutePath[];
+  readonly missing: readonly Unread[];
+} {
+  const dir = dirname(filename);
+  const paper = readPaper(filename, src, deps);
+  const body = deps.latex.documentBody(src);
+  const inBody = (via: Span | null): boolean =>
+    via !== null &&
+    (body === null || (via.start >= body.start && via.end <= body.end));
+  const own = (rel: string): AbsolutePath | null => {
+    const at = located(dir, rel, deps.files);
+    return at === callerPath(join(dir, rel)) ? at : null;
+  };
+  return {
+    files: [
+      ...new Set(
+        paper.segments
+          .filter((s) => s.file !== paper.main && inBody(s.via))
+          .map((s) => own(s.file))
+          .filter((f): f is AbsolutePath => f !== null),
+      ),
+    ],
+    missing: paper.missing.map(({ file, target }) => ({ file, target })),
+  };
+}
+
 /** Line and column (1-based) of an offset in a text. */
 function lineColumn(text: string, at: number): string {
   const line = text.slice(0, at).split("\n").length;
@@ -113,40 +159,3 @@ export function reportInPaper(
       });
   });
 }
-
-const MISSING_META: TexRuleModule["meta"] = {
-  type: "problem",
-  docs: {
-    description:
-      "an \\input, \\include or \\subfile names a file that is not there, so no rule read its text",
-    url: "https://github.com/zernie/paperlint/blob/main/docs/rules/tex/missing-input.md",
-  },
-  schema: [],
-  messages: {
-    missing:
-      "`{{target}}` is not there (tried `{{target}}.tex` and `{{target}}`, from the paper's directory): TeX stops on it, and no rule read what it should hold",
-    missingIn:
-      "`{{target}}`, which {{file}} includes, is not there (tried `{{target}}.tex` and `{{target}}`, from the paper's directory): TeX stops on it, and no rule read what it should hold",
-  },
-};
-
-/** The includes that name no file, each reported where it stands in the main file. */
-export const missingInputRule = (deps: PaperDeps): TexRuleModule => ({
-  meta: MISSING_META,
-  create(context) {
-    return {
-      root() {
-        const sc = context.sourceCode;
-        const paper = readPaper(context.filename, sc.raw ?? sc.text, deps);
-        const loc = (i: number) => sc.getLocFromIndex(i);
-        paper.missing.forEach((m) => {
-          context.report({
-            loc: { start: loc(m.via.start), end: loc(m.via.end) },
-            messageId: m.file === paper.main ? "missing" : "missingIn",
-            data: { target: m.target, file: m.file },
-          });
-        });
-      },
-    };
-  },
-});

package/src/tex-venue-rules.test.ts

@@ -199,7 +199,7 @@ describe("the venue rules read the whole paper: the files it \\inputs, spliced w
         "\\section*{LLM Usage Statement}\nNone.\n",
     };
     expect(lint(tex, AIDC, { extra })).toEqual([]);
-    // Without the file, the section is missing — and tex/missing-input (not a venue rule) says why.
+    // Without the file, the section is missing.
     expect(ids(lint(tex, AIDC))).toEqual(["tex/required-section:missing"]);
   });
 

package/templates/paper/PIPELINE-STATUS.md

@@ -1,10 +1,6 @@
 ---
 # Created by `paperlint new` — from <papers>/.template/ when the project keeps one, else from the package.
 #
-# researchQuestion — the paper's question, one sentence, written the way it appears in the paper.
-# `paper/research-question` reads it once the paper has shipped a stage. Empty until you have it.
-researchQuestion: ""
-#
 # There is no `stages` field yet, on purpose: a new paper has shipped nothing and owes nothing.
 # When it reaches a stage, add the record — its shape is in docs/rules.md of the package.
 ---

package/dist/action-ref.d.ts

@@ -1,12 +0,0 @@
-/**
- * The ref `paperlint init` pins the GitHub Action to, decided from the version of the package that is
- * running. semantic-release tags every release `v<version>` on the commit it publishes, so the
- * action at that tag is the same code as the installed package.
- *
- * Only a plain `X.Y.Z` has such a tag. A git checkout or `npm link` carries the unreleased
- * placeholder `0.0.0-semantically-released`, a version that could not be read is `undefined`, and
- * anything else is not known to be tagged: those return `null` ("no pin known"), and the caller
- * keeps the placeholder. A wrong tag written confidently is worse than an obvious placeholder.
- */
-export declare function actionRef(version: string | undefined): string | null;
-//# sourceMappingURL=action-ref.d.ts.map

package/dist/action-ref.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"action-ref.d.ts","sourceRoot":"","sources":["../src/action-ref.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,IAAI,CAIpE"}