paperlint 4.0.0 → 4.1.0

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

@@ -0,0 +1,80 @@
+/** The values a LaTeX source is read into: a run's text and the span of a range inside it. */
+import { describe, expect, it } from "vitest";
+import {
+  collapse,
+  documentClassLine,
+  missingOptions,
+  runText,
+  spanIn,
+  venueClass,
+  type TextRun,
+} from "./tex-document.ts";
+
+// "ab" at 10, then " " at 20 (one character standing for a longer whitespace), then "cd" at 30.
+const RUN: TextRun = {
+  segments: [
+    { text: "ab", at: 10 },
+    { text: " ", at: 20 },
+    { text: "cd", at: 30 },
+  ],
+};
+
+describe("a text run", () => {
+  it("its text is its segments' text, in order", () => {
+    expect(runText(RUN)).toBe("ab cd");
+  });
+
+  it("spanIn: from the first character's offset to past the last's, across segments", () => {
+    expect(spanIn(RUN, 0, 2)).toEqual({ start: 10, end: 12 });
+    expect(spanIn(RUN, 1, 4)).toEqual({ start: 11, end: 31 });
+    expect(spanIn(RUN, 3, 5)).toEqual({ start: 30, end: 32 });
+  });
+
+  it("🔴 spanIn: an empty range, or one reaching outside the run, has no span — never {0, 0}", () => {
+    expect(spanIn(RUN, 2, 2)).toBe(null);
+    expect(spanIn(RUN, -1, 2)).toBe(null);
+    expect(spanIn(RUN, 3, 9)).toBe(null);
+    expect(spanIn(RUN, 9, 10)).toBe(null);
+  });
+});
+
+describe("a document class", () => {
+  it("documentClassLine writes it back; with no options, no brackets", () => {
+    expect(
+      documentClassLine({
+        cls: "IEEEtran",
+        options: ["conference", "compsoc"],
+      }),
+    ).toBe("\\documentclass[conference,compsoc]{IEEEtran}");
+    expect(documentClassLine({ cls: "article", options: [] })).toBe(
+      "\\documentclass{article}",
+    );
+  });
+
+  it("missingOptions: every option of the wanted class the paper lacks, in the wanted order", () => {
+    expect(
+      missingOptions(
+        { cls: "x", options: ["b"] },
+        { cls: "x", options: ["a", "b", "c"] },
+      ),
+    ).toEqual(["a", "c"]);
+  });
+
+  it("venueClass: another class is replaced; the same class gains the missing options, or is kept", () => {
+    const want = { cls: "IEEEtran", options: ["conference", "compsoc"] };
+    expect(venueClass({ cls: "article", options: ["11pt"] }, want)).toEqual({
+      kind: "replace",
+      by: want,
+    });
+    expect(
+      venueClass({ cls: "IEEEtran", options: ["review", "conference"] }, want),
+    ).toEqual({ kind: "add", options: ["compsoc"] });
+    expect(
+      venueClass({ cls: "IEEEtran", options: ["compsoc", "conference"] }, want),
+    ).toEqual({ kind: "keep" });
+  });
+
+  it("collapse: every run of whitespace, newlines included, and trims", () => {
+    expect(collapse("  LLM   Usage\n Statement ")).toBe("LLM Usage Statement");
+  });
+});

package/src/domain/tex-document.ts

@@ -0,0 +1,110 @@
+/**
+ * What a paper's LaTeX source says, in the paper's vocabulary — its document class, its sections,
+ * the text a reader sees — as values. No parser here: the LaTeX adapter (`src/adapters/latex/`)
+ * produces these, and the rules and `paperlint new` read them through the `LatexReader` port.
+ */
+
+/** A span of the source: `[start, end)` offsets. */
+export interface Span {
+  readonly start: number;
+  readonly end: number;
+}
+
+/** Where something stands in the source, or that the parser gave it no position. */
+export type Place =
+  { readonly kind: "at"; readonly span: Span } | { readonly kind: "unplaced" };
+
+/** Whitespace collapsed to single spaces and trimmed — how a title or a class name is compared. */
+export const collapse = (s: string): string =>
+  s.split(/\s+/u).filter(Boolean).join(" ");
+
+/** A LaTeX document class and the options it is loaded with, in source order. */
+export interface DocumentClass {
+  readonly cls: string;
+  readonly options: readonly string[];
+}
+
+/** A paper's `\documentclass`: none, one that names no class, or a class with its options. */
+export type ClassLine =
+  | { readonly kind: "missing" }
+  | { readonly kind: "empty"; readonly place: Place }
+  | ({ readonly kind: "class"; readonly place: Place } & DocumentClass);
+
+/** The options of `want` that `got` does not carry — every one, in `want`'s order. */
+export const missingOptions = (
+  got: DocumentClass,
+  want: DocumentClass,
+): readonly string[] => want.options.filter((o) => !got.options.includes(o));
+
+/** What a paper's class line needs to satisfy a venue: nothing, options added, or the venue's line. */
+export type ClassChange =
+  | { readonly kind: "keep" }
+  | { readonly kind: "add"; readonly options: readonly string[] }
+  | { readonly kind: "replace"; readonly by: DocumentClass };
+
+/**
+ * What a paper's class must change to satisfy a venue's `want`: another class is replaced by `want`;
+ * the same class keeps its options and gains the ones it lacks, in `want`'s order. This decides WHAT
+ * changes; writing it into a source is the LaTeX adapter's.
+ */
+export function venueClass(
+  have: DocumentClass,
+  want: DocumentClass,
+): ClassChange {
+  if (have.cls !== want.cls) return { kind: "replace", by: want };
+  const missing = missingOptions(have, want);
+  return missing.length === 0
+    ? { kind: "keep" }
+    : { kind: "add", options: missing };
+}
+
+/** A class as a `\documentclass` line, for a message and for the line `paperlint new` writes. */
+export const documentClassLine = (d: DocumentClass): string =>
+  `\\documentclass${d.options.length > 0 ? `[${d.options.join(",")}]` : ""}{${d.cls}}`;
+
+/** One `\section` or `\section*`, its title's text with whitespace collapsed. */
+export interface Heading {
+  readonly title: string;
+  readonly place: Place;
+}
+
+/** The document's sections in source order, where its back matter begins, and where it ends. */
+export interface Outline {
+  readonly sections: readonly Heading[];
+  /** The first `\appendix` or bibliography, or null: sections from here on are not body. */
+  readonly backMatter: number | null;
+  /** Where `\end{document}` stands, or null when there is no document environment. */
+  readonly end: number | null;
+}
+
+/** Text a reader sees, copied from one place: `text[i]` stands at source offset `at + i`. */
+export interface Segment {
+  readonly text: string;
+  readonly at: number;
+}
+
+/** A run of rendered text: contiguous segments, never empty. */
+export interface TextRun {
+  readonly segments: readonly [Segment, ...Segment[]];
+}
+
+/** The run's text. */
+export const runText = (run: TextRun): string =>
+  run.segments.map((s) => s.text).join("");
+
+/** The source offset of the `i`-th character of the text these segments make, or null outside it. */
+function offsetIn(segments: readonly Segment[], i: number): number | null {
+  const [s, ...rest] = segments;
+  if (s === undefined || i < 0) return null;
+  return i < s.text.length ? s.at + i : offsetIn(rest, i - s.text.length);
+}
+
+/**
+ * The source span of `runText(run).slice(from, to)`: from its first character to past its last.
+ * Null when the range is empty or reaches outside the run — never an invented position.
+ */
+export function spanIn(run: TextRun, from: number, to: number): Span | null {
+  const start = offsetIn(run.segments, from);
+  const last = to > from ? offsetIn(run.segments, to - 1) : null;
+  return start === null || last === null ? null : { start, end: last + 1 };
+}

package/src/engine.harness.mjs

@@ -5,7 +5,7 @@
  *   1. `resolveEngine` over `EngineFacts` — one row per branch of the order;
  *   2. the fact readers: `missingPackages` over kpsewhich output, `missingTools`, `whichOnPath`,
  *      `probeTree` through a fake runner.
- * All pure or port-driven: no TeX needed. The real-TeX half is `test/e2e/build.ts`.
+ * All pure or port-driven: no TeX needed. The real-TeX half is `test/e2e/tex/build.e2e.ts`.
  */
 import {
   chmodSync,

package/src/facts-file.test.ts

@@ -5,12 +5,12 @@
  * in-memory files with a FAKE pdf.js reader and a FAKE measurer, so each outcome — read failed, not
  * measured, measured — is chosen rather than hoped for. Reading real PDFs is
  * `pdf-facts.harness.ts`'s job; banal as the measurer is `adapters/banal/index.test.ts`, and the
- * real banal is `test/e2e/banal.ts`.
+ * real banal is `test/e2e/tex/banal.e2e.ts`.
  */
 import assert from "node:assert/strict";
 import { readdirSync, readFileSync } from "node:fs";
 import { join } from "node:path";
-import { packageVenuesDir } from "../skills/paper-pipeline/scripts/consumer.mjs";
+import { presetsDir } from "./package-dirs.ts";
 import { test } from "vitest";
 import { memoryFiles } from "./adapters/memory/index.ts";
 import {
@@ -154,12 +154,9 @@ const good: PdfReader = () =>
   });
 /** The shipped presets at their real paths: `extends` resolves through the same Files port. */
 const SHIPPED_PRESETS = Object.fromEntries(
-  readdirSync(packageVenuesDir())
+  readdirSync(presetsDir())
     .filter((f) => /\.jsonc?$/.test(f))
-    .map((f) => [
-      join(packageVenuesDir(), f),
-      readFileSync(join(packageVenuesDir(), f)),
-    ]),
+    .map((f) => [join(presetsDir(), f), readFileSync(join(presetsDir(), f))]),
 );
 
 /** Options over in-memory files: the PDF and paperlint.json on "disk", a measurer answering `geometry`. */

package/src/facts-file.ts

@@ -49,7 +49,7 @@ import { callerPath } from "./caller-path.ts";
 import type { Files } from "./ports/files.ts";
 import { err, ok, type Result } from "./domain/result.ts";
 import { paperPreset, paperPresetProblem } from "./presets.ts";
-import { packageVenuesDir } from "../skills/paper-pipeline/scripts/consumer.mjs";
+import { presetsDir } from "./package-dirs.ts";
 import { messageOf } from "./domain/text.ts";
 
 export const FACTS_SCHEMA = 2;
@@ -76,7 +76,7 @@ export interface VenueDecl {
 export function declaredVenue(
   files: Files,
   paperDir: string,
-  venuesDir: string = packageVenuesDir(),
+  venuesDir: string = presetsDir(),
 ): VenueDecl | null {
   const p = paperPreset(paperDir, { files, venuesDir });
   const problem = paperPresetProblem(paperDir, p);

package/src/latex-loop.harness.ts

@@ -6,7 +6,7 @@
  * A defect in `nextStep` fails in table 1, one in `summarize` in table 2, before table 3 runs.
  *
  * The decision is pure, so none of this needs TeX. The real-pdflatex half lives in
- * `test/e2e/build.ts`.
+ * `test/e2e/tex/build.e2e.ts`.
  */
 import { createChecker } from "../lib/check.ts";
 import type {

package/src/new-paper.test.ts

@@ -19,7 +19,7 @@ import { newPaper, OVERRIDE_DIR, reportNewPaper } from "./new-paper.ts";
 import { parsePaperSettings } from "./paper-settings.ts";
 import { chooseVenue, run } from "./cli.ts";
 import { shippedPresets } from "./presets.ts";
-import { packageVenuesDir } from "../skills/paper-pipeline/scripts/consumer.mjs";
+import { presetsDir } from "./package-dirs.ts";
 import { lintReport } from "../test/lint-report.ts";
 import { z } from "zod";
 
@@ -177,6 +177,31 @@ describe("paperlint new --venue / --kind", () => {
     expect(r.code).toBe(0);
   });
 
+  it("🔴 the new paper.tex is set in the venue's class, so tex/template passes on what new wrote; the required section is named", async () => {
+    const r = await newIn(["--venue", "aidc", "--kind", "regular"]);
+    const tex = readFileSync(join(r.dir, "paper.tex"), "utf8");
+    expect(tex).toContain("\\documentclass[conference,compsoc]{IEEEtran}\n");
+    expect(tex).not.toContain("{article}");
+    expect(r.out).not.toMatch(/tex\/template/);
+    // What the stub still lacks is what AIDC requires of the text, and lint says so right away.
+    expect(r.out).toMatch(/tex\/required-section/);
+    expect(r.code).toBe(1);
+  });
+
+  it("a preset that names no template, or one no reader can read, leaves the template's class as it is", async () => {
+    for (const template of [undefined, "\\documentclass[a]{}"]) {
+      const r = await newIn(["--venue", "./venues/bare.jsonc"], {
+        "venues/bare.jsonc": JSON.stringify({
+          ...(template === undefined ? {} : { template }),
+          tex: { packages: { x: ["x.sty"] } },
+        }),
+      });
+      expect(readFileSync(join(r.dir, "paper.tex"), "utf8")).toContain(
+        "\\documentclass{article}",
+      );
+    }
+  });
+
   it("🔴 a path is relative to where you run it, and written relative to the paper's file", async () => {
     const r = await newIn(
       ["--venue", "./venues/my-workshop.jsonc", "--kind", "short"],
@@ -197,7 +222,7 @@ describe("paperlint new --venue / --kind", () => {
     const r = await newIn(["--venue", "icse"]);
     expect(r.code).toBe(2);
     // Guards: the list is read from the shipped presets, the same list lint prints.
-    expect(r.err).toContain(shippedPresets(packageVenuesDir()).join(", "));
+    expect(r.err).toContain(shippedPresets(presetsDir()).join(", "));
     expect(r.err).toMatch(/--venue icse: no such venue preset/);
     expect(existsSync(r.dir)).toBe(false);
   });
@@ -277,7 +302,7 @@ describe("chooseVenue — on a terminal", () => {
       value: { extends: "paperlint:agenticdev", kind: "full" },
     });
     expect(t.asked[0]).toContain(
-      [...shippedPresets(packageVenuesDir()), "none"].join(" / "),
+      [...shippedPresets(presetsDir()), "none"].join(" / "),
     );
     expect(t.asked[1]).toMatch(/kind: short \/ full \/ demo \/ later/);
   });

package/src/new-paper.ts

@@ -104,6 +104,11 @@ export interface VenueSetting {
   /** `paperlint:<name>`, or a path relative to the paper's `paperlint.json`. */
   readonly extends: string;
   readonly kind: string | null;
+  /**
+   * The new `paper.tex` set in the class the preset's template names, so `tex/template` passes on
+   * the paper `new` just wrote. Absent or null: the template's class is kept.
+   */
+  readonly setClass?: ((paperTex: string) => string) | null;
 }
 
 /**
@@ -164,6 +169,9 @@ function fromTemplate(
   if (!existsSync(src))
     return { ok: false, reason: `no template for ${file}: ${src} is missing` };
   const text = readFileSync(src, "utf8").split("{{name}}").join(name);
+  const setClass = venue?.setClass ?? null;
+  if (file === SOURCE_FILE.tex && setClass !== null)
+    return { ok: true, value: { file, text: setClass(text), from } };
   if (file !== CONFIG_FILE || venue === null)
     return { ok: true, value: { file, text, from } };
   const edited = withVenue(text, src, venue);

package/src/package-dirs.ts

@@ -0,0 +1,17 @@
+/**
+ * Where the package's own data lives, wherever the package is installed (its checkout,
+ * `node_modules`, a plugin cache). This file sits one level below the package root both as a source
+ * (`src/`) and as a build (`dist/`), so `..` is the root in either.
+ *
+ *   presets/       the venue presets (`paperlint:<name>`) and their JSON Schema
+ *   presets/tex/   the LaTeX inputs `paperlint build` puts on TEXINPUTS
+ */
+import { fileURLToPath } from "node:url";
+
+/** The shipped venue presets and `venue-profile.schema.json`. */
+export const presetsDir = (): string =>
+  fileURLToPath(new URL("../presets", import.meta.url));
+
+/** The LaTeX inputs a paper `\input`s by name (`paper-guards`, a venue's numbers). */
+export const texInputsDir = (): string =>
+  fileURLToPath(new URL("../presets/tex", import.meta.url));

package/src/paper-settings-commands.test.ts

@@ -232,6 +232,9 @@ describe("paperlint lint — the venue preset's rules", () => {
         extends: "paperlint:agenticdev",
         kind: "short",
       }),
+      // In agenticdev's class, or tex/template would be the finding.
+      "papers/a/paper.tex":
+        "\\documentclass[sigconf]{acmart}\n\\begin{document}x\\end{document}\n",
     });
     const r = await lint(root);
     expect(r.code).toBe(0);
@@ -282,7 +285,9 @@ describe("paperlint lint — the paper over its preset, and the project's own pr
     });
     const r = await lint(root);
     expect(r.code).toBe(1);
-    expect(r.out).toMatch(/acm-sigconf, agenticdev, aisec, realm/);
+    expect(r.out).toMatch(
+      /acm-sigconf, agenticdev, aidc, aisec, ieee-conference, realm/,
+    );
   });
 });
 

package/src/ports/latex.ts

@@ -0,0 +1,29 @@
+/**
+ * What paperlint needs from a LaTeX source, shaped by its rules and `paperlint new` — not by the
+ * parser. The one implementation is `src/adapters/latex/` (unified-latex); `src/cli.ts` wires it.
+ */
+import type {
+  ClassLine,
+  DocumentClass,
+  Outline,
+  TextRun,
+} from "../domain/tex-document.ts";
+
+export interface LatexReader {
+  /** The source's `\documentclass`, as one of its states. */
+  readonly documentClass: (src: string) => ClassLine;
+  /** Its sections, where the back matter begins, and where the document ends. */
+  readonly outline: (src: string) => Outline;
+  /** The text a reader sees: prose, the author block, footnotes — not comments, keys, math, code. */
+  readonly renderedRuns: (src: string) => readonly TextRun[];
+  /**
+   * A preset's `template` → the class it names: a whole `\documentclass[…]{…}` line, or a bare
+   * class name (no option). Null for anything else.
+   */
+  readonly template: (text: string) => DocumentClass | null;
+  /**
+   * `src` with its `\documentclass` set to `want` — unless it already is `want`'s class with every
+   * option `want` names (the author's own options stay), or it has none.
+   */
+  readonly withDocumentClass: (src: string, want: DocumentClass) => string;
+}

package/src/presets.test.ts

@@ -10,15 +10,18 @@ import { readdirSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { describe, expect, it } from "vitest";
 import { memoryFiles } from "./adapters/memory/index.ts";
-import { packageVenuesDir } from "../skills/paper-pipeline/scripts/consumer.mjs";
+import { presetsDir } from "./package-dirs.ts";
+import { parsePreset } from "./tex-requirements.ts";
 import {
   MAX_PRESET_DEPTH,
+  SHIPPED_PREFIX,
+  shippedPresets,
   labelOf,
   presetProblemText,
   resolvePreset,
 } from "./presets.ts";
 
-const VENUES = packageVenuesDir();
+const VENUES = presetsDir();
 const shipped = Object.fromEntries(
   readdirSync(VENUES)
     .filter((f) => f.endsWith(".jsonc") || f.endsWith(".json"))
@@ -44,7 +47,11 @@ describe("shipped presets", () => {
     expect(r.value.format.columns).toBe(2);
     expect(r.value.format.fontsText).toBe("LinLibertine");
     expect([...r.value.format.kinds.keys()]).toEqual(["short", "full", "demo"]);
-    expect(r.value.template).toBe("acmart");
+    // The family's template, as its file spells it: the child names none.
+    expect(r.value.template).toEqual({
+      text: "\\documentclass[sigconf]{acmart}",
+      file: join(VENUES, "acm-sigconf.jsonc"),
+    });
     expect("acmart" in r.value.tex.packages).toBe(true);
     expect(r.value.label).toBe("agenticdev");
   });
@@ -70,6 +77,45 @@ describe("shipped presets", () => {
   });
 });
 
+describe("the naming convention of shipped presets (docs/rules.md)", () => {
+  // Each shipped preset, parsed: its file name and what it extends. The families are DERIVED — a
+  // shipped preset another shipped preset extends — so a new family is checked the day it ships.
+  const presets = shippedPresets(VENUES).map((name) => {
+    const file = join(VENUES, `${name}.jsonc`);
+    return {
+      name,
+      extends: parsePreset(readFileSync(file, "utf8"), file, VENUES).extends,
+    };
+  });
+  const families = presets.filter((p) =>
+    presets.some((q) => q.extends === `${SHIPPED_PREFIX}${p.name}`),
+  );
+  const publishers = families.map((f) => f.name.slice(0, f.name.indexOf("-")));
+
+  it("there are families to check (else the checks below see nothing)", () => {
+    expect(families.map((f) => f.name).sort()).toEqual([
+      "acm-sigconf",
+      "ieee-conference",
+    ]);
+  });
+
+  it.each(families.map((f) => [f.name]))(
+    "the family %s is <publisher>-<template variant>",
+    (name) => {
+      expect(name).toMatch(/^[a-z0-9]+-[a-z0-9-]+$/);
+    },
+  );
+
+  it.each(presets.filter((p) => p.extends !== null).map((p) => [p.name]))(
+    "the venue %s carries no publisher prefix — its template is said by `extends`",
+    (name) => {
+      expect(publishers.filter((pub) => name.startsWith(`${pub}-`))).toEqual(
+        [],
+      );
+    },
+  );
+});
+
 describe("a project's own preset, by relative path", () => {
   const usenix = JSON.stringify({
     extends: "paperlint:acm-sigconf",
@@ -149,7 +195,7 @@ describe("what does not resolve, and says why", () => {
       "a shipped name with a typo",
       "paperlint:agenticdve",
       "not-found",
-      /acm-sigconf, agenticdev, aisec, realm/,
+      /acm-sigconf, agenticdev, aidc, aisec, ieee-conference, realm/,
     ],
     ["the base TeX set", "paperlint:tex-base", "not-found", /agenticdev/],
     [
@@ -225,6 +271,21 @@ describe("chains that do not resolve", () => {
   });
 });
 
+describe("a preset's template: kept as its file spells it, with that file", () => {
+  it("a child's template replaces its parent's, and names its own file", () => {
+    const r = resolve("./own.jsonc", {
+      "/work/papers/p/own.jsonc": JSON.stringify({
+        extends: "paperlint:aidc",
+        template: "\\documentclass[conference]{IEEEtran}",
+      }),
+    });
+    expect(r.ok && r.value.template).toEqual({
+      text: "\\documentclass[conference]{IEEEtran}",
+      file: "/work/papers/p/own.jsonc",
+    });
+  });
+});
+
 describe("labelOf — display only, never used to resolve", () => {
   it.each([
     ["paperlint:agenticdev", "agenticdev"],

package/src/presets.ts

@@ -19,7 +19,8 @@
  *   tex        union — a child never removes a package its parent needs
  *   format     per key, the child wins; `kinds` by kind name, a child's kind replaces that kind
  *   rules      per rule id, the child wins
- *   template   the child wins; so does `name`
+ *   template   the child wins; so does `name`, and `required_sections` (the whole list)
+ *   aliases    union, with every `name` — what the venue is called along the chain
  *
  * ── THE LABEL ─────────────────────────────────────────────────────────────────────
  * Messages, the facts file and the build plan need a word for the venue. It is the most derived
@@ -36,6 +37,7 @@ import {
   profileFileOf,
   venueNames,
   type PresetFile,
+  type RequiredSection,
   type TexRequirements,
   type VenueFormat,
 } from "./tex-requirements.ts";
@@ -61,13 +63,27 @@ export interface PresetDeps {
   readonly venuesDir: string;
 }
 
+/** A preset's `template`, as its file spells it. */
+export interface PresetTemplate {
+  readonly text: string;
+  readonly file: string;
+}
+
 /** A resolved chain, merged. */
 export interface Preset {
   /** The word for this venue in messages. */
   readonly label: string;
   /** Every file of the chain, root first. */
   readonly chain: readonly string[];
-  readonly template: string | null;
+  /**
+   * The `\\documentclass` the venue's template uses, as the preset spells it, and the file that
+   * spells it; null when no file of the chain names one. Read by the rules and `paperlint new`,
+   * through the LaTeX reader.
+   */
+  readonly template: PresetTemplate | null;
+  /** Every `name` and `aliases` along the chain: what this venue is called in a paper's text. */
+  readonly aliases: readonly string[];
+  readonly requiredSections: readonly RequiredSection[];
   readonly tex: TexRequirements;
   readonly format: VenueFormat;
   readonly rules: Readonly<Record<string, unknown>>;
@@ -187,26 +203,37 @@ export function mergeFormat(
 /** The chain, root first, merged into one preset. Pure. */
 function merged(
   spec: string,
-  rootFirst: readonly PresetFile[],
-  files: readonly string[],
+  rootFirst: readonly { readonly preset: PresetFile; readonly file: string }[],
 ): Preset {
   const base: {
     name: string | null;
-    template: string | null;
+    template: PresetTemplate | null;
+    aliases: readonly string[];
+    requiredSections: readonly RequiredSection[];
     tex: TexRequirements;
     format: VenueFormat;
     rules: Readonly<Record<string, unknown>>;
   } = {
     name: null,
     template: null,
+    aliases: [],
+    requiredSections: [],
     tex: NO_REQUIREMENTS,
     format: NO_FORMAT,
     rules: {},
   };
   const m = rootFirst.reduce(
-    (acc, p) => ({
+    (acc, { preset: p, file }) => ({
       name: p.name ?? acc.name,
-      template: p.template ?? acc.template,
+      template: p.template === null ? acc.template : { text: p.template, file },
+      aliases: [
+        ...new Set([
+          ...acc.aliases,
+          ...(p.name === null ? [] : [p.name]),
+          ...p.aliases,
+        ]),
+      ],
+      requiredSections: p.requiredSections ?? acc.requiredSections,
       tex: p.tex ? mergeRequirements(acc.tex, p.tex) : acc.tex,
       format: mergeFormat(acc.format, p.format),
       rules: { ...acc.rules, ...p.rules },
@@ -215,8 +242,10 @@ function merged(
   );
   return {
     label: m.name ?? labelOf(spec),
-    chain: files,
+    chain: rootFirst.map((x) => x.file),
     template: m.template,
+    aliases: m.aliases,
+    requiredSections: m.requiredSections,
     tex: m.tex,
     format: m.format,
     rules: m.rules,
@@ -238,13 +267,7 @@ export function resolvePreset(
       ? err({ ...chain.error, shipped: shippedPresets(deps.venuesDir) })
       : chain;
   const rootFirst = [...chain.value].reverse();
-  return ok(
-    merged(
-      spec,
-      rootFirst.map((x) => x.preset),
-      rootFirst.map((x) => x.file),
-    ),
-  );
+  return ok(merged(spec, rootFirst));
 }
 
 /** The shipped presets' names (each is spelled `paperlint:<name>`). */