paperlint 4.0.0 → 4.1.0

package/src/adapters/latex/nodes.ts

@@ -0,0 +1,141 @@
+/** What the three readers share about unified-latex nodes: places, text, and the walk. */
+import type * as Ast from "@unified-latex/unified-latex-types";
+import { CONTINUE, SKIP, visit } from "@unified-latex/unified-latex-util-visit";
+import type { Place, Span } from "../../domain/tex-document.ts";
+import { KEY_SIGNATURES } from "./parse.ts";
+
+export { collapse } from "../../domain/tex-document.ts";
+
+/** unified-latex's node types, read-only: nothing here writes to a tree. */
+export type Node = Readonly<Ast.Node>;
+export type Macro = Readonly<Ast.Macro>;
+export type Argument = Readonly<Ast.Argument>;
+
+/** Anything the parser may have given a position: offsets of its first and past its last character. */
+interface Positioned {
+  readonly position?: {
+    readonly start: { readonly offset: number };
+    readonly end: { readonly offset: number };
+  };
+}
+
+/** Where a node stands, or that it has no position. */
+export const placeOf = (n: Positioned): Place =>
+  n.position === undefined
+    ? { kind: "unplaced" }
+    : {
+        kind: "at",
+        span: { start: n.position.start.offset, end: n.position.end.offset },
+      };
+
+/** The first mandatory (`{…}`) and optional (`[…]`) arguments' contents, and the last mandatory one's. */
+export const mandatory = (m: Macro): readonly Argument[] =>
+  (m.args ?? []).filter((a) => a.openMark === "{");
+export const optional = (m: Macro): Argument | undefined =>
+  (m.args ?? []).find((a) => a.openMark === "[");
+
+/** What a string node reads as: itself, except a tie (`~`), which is a space the reader sees. */
+export const stringText = (content: string): string =>
+  content === "~" ? " " : content;
+
+/** Which of a macro's mandatory arguments it typesets: one of them, or none at all. */
+type Shown =
+  | { readonly kind: "argument"; readonly at: number }
+  | { readonly kind: "none" };
+
+const LAST: Shown = { kind: "argument", at: -1 };
+const NONE: Shown = { kind: "none" };
+
+/**
+ * Macros that do not typeset their last mandatory argument, as data. `\texorpdfstring{shown}{bookmark}`
+ * typesets the first; a declaration (`\color{red}`, `\fontsize{10}{12}`, `\vspace{1em}`,
+ * `\setlength{\x}{0pt}`) typesets none. Every other macro typesets its last (`\textcolor{red}{x}`,
+ * `\colorbox{yellow}{x}`, `\href{url}{x}`).
+ */
+const SHOWN_ARGUMENT: ReadonlyMap<string, Shown> = new Map<string, Shown>([
+  ["texorpdfstring", { kind: "argument", at: 0 }],
+  ...["color", "fontsize", "vspace", "hspace", "setlength", "addtolength"].map(
+    (m) => [m, NONE] as const,
+  ),
+]);
+
+/** The text a (non-key) macro typesets: see `SHOWN_ARGUMENT`. */
+function shownText(m: Macro): string {
+  const shown = SHOWN_ARGUMENT.get(m.content) ?? LAST;
+  return shown.kind === "none"
+    ? ""
+    : textOf(mandatory(m).at(shown.at)?.content);
+}
+
+/**
+ * The text of a node list with markup dropped: strings, spaces, what groups hold, and the argument a
+ * formatting macro typesets — its last mandatory one (`\textbf{Usage}`, `\textcolor{red}{Usage}`,
+ * `\href{url}{Usage}` → `Usage`) unless `SHOWN_ARGUMENT` says otherwise. A key macro's arguments
+ * (`\label{…}`, `\cite{…}`) are not text.
+ */
+export const textOf = (nodes: readonly Node[] | undefined): string =>
+  (nodes ?? [])
+    .map((n) => {
+      if (n.type === "string") return stringText(n.content);
+      if (n.type === "whitespace" || n.type === "parbreak") return " ";
+      if (n.type === "group") return textOf(n.content);
+      return n.type === "macro" && !(n.content in KEY_SIGNATURES)
+        ? shownText(n)
+        : "";
+    })
+    .join("");
+
+/**
+ * A macro's place with its arguments: from its name to past the closing mark of the last argument
+ * that holds text. unified-latex positions the name and the arguments' contents, never the
+ * arguments themselves, so an empty trailing argument is not covered.
+ */
+export function macroPlace(m: Macro): Place {
+  const name = placeOf(m);
+  if (name.kind === "unplaced") return name;
+  const end = (m.args ?? []).reduce((e, a) => {
+    const last = a.content.at(-1)?.position?.end.offset;
+    return last === undefined ? e : last + a.closeMark.length;
+  }, name.span.end);
+  const span: Span = { start: name.span.start, end };
+  return { kind: "at", span };
+}
+
+/** What visit reaches: a node, an argument, or a node list (a content array, an argument list). */
+export type Visited = Readonly<Ast.Ast> | readonly (Node | Argument)[];
+
+/**
+ * Everything visit reaches under `tree`, in document order, node lists included; `skip` prunes what
+ * it is given (a node or an argument, with the node that holds it) and everything under it. visit
+ * reports through a callback and returns nothing, so the one collection point of this adapter is here.
+ */
+export function visited(
+  // eslint-disable-next-line functional/prefer-immutable-types -- visit's own parameter type is mutable
+  tree: Ast.Ast,
+  skip: (v: Visited, parent: Visited | undefined) => boolean,
+): readonly Visited[] {
+  // eslint-disable-next-line functional/prefer-immutable-types -- the one accumulator, see above
+  const seen: Visited[] = [];
+  visit(
+    tree,
+    (node, info) => {
+      // eslint-disable-next-line functional/immutable-data -- visit is callback-only; see above
+      seen.push(node);
+      return skip(node, info.parents[0]) ? SKIP : CONTINUE;
+    },
+    { includeArrays: true },
+  );
+  return seen;
+}
+
+/** A node list visit reached. `Array.isArray` alone does not narrow a readonly array. */
+export const isList = (v: Visited): v is readonly (Node | Argument)[] =>
+  Array.isArray(v);
+
+/** A macro's argument, as visit reports it. */
+export const isArgument = (v: Visited): v is Argument =>
+  !isList(v) && v.type === "argument";
+
+/** A node, as opposed to a node list or an argument (which visit also reports). */
+export const isNode = (v: Visited): v is Node =>
+  !isList(v) && v.type !== "argument" && v.type !== "root";

package/src/adapters/latex/outline.ts

@@ -0,0 +1,64 @@
+/** The document's sections, where its back matter starts, and where it ends. */
+import type * as Ast from "@unified-latex/unified-latex-types";
+import { isDefined } from "remeda";
+import type { Heading, Outline } from "../../domain/tex-document.ts";
+import {
+  collapse,
+  isNode,
+  macroPlace,
+  mandatory,
+  textOf,
+  visited,
+  type Macro,
+  type Node,
+} from "./nodes.ts";
+import { isDefinition, isUnrendered } from "./hidden.ts";
+import type { ParsedTex } from "./parse.ts";
+
+/** Macros and the environment that start the back matter: the appendix and the bibliography. */
+const BACK_MATTER_MACROS: ReadonlySet<string> = new Set([
+  "appendix",
+  "bibliography",
+  "printbibliography",
+]);
+
+const isBackMatter = (n: Node): boolean =>
+  (n.type === "macro" && BACK_MATTER_MACROS.has(n.content)) ||
+  (n.type === "environment" && n.env === "thebibliography");
+
+const isSection = (n: Node): n is Macro =>
+  n.type === "macro" && n.content === "section";
+
+const isDocument = (n: Node): n is Readonly<Ast.Environment> =>
+  n.type === "environment" && n.env === "document";
+
+/** One `\section`/`\section*`: the last mandatory argument is its title. */
+const headingOf = (m: Macro): Heading => ({
+  title: collapse(textOf(mandatory(m).at(-1)?.content)),
+  place: macroPlace(m),
+});
+
+/**
+ * The body's `\section`s (starred or not) in document order, the first back-matter node, and the
+ * end of the document. A source with no `document` environment is read whole, as a fragment. What
+ * the PDF never shows is pruned (`isUnrendered`), and so is a macro definition's body
+ * (`isDefinition`): a heading in a comment environment or in a definition is not a section.
+ */
+export function outlineOf(t: ParsedTex): Outline {
+  const doc = t.root.content.find(isDocument);
+  const nodes = visited(
+    doc?.content ?? t.root.content,
+    (v, parent) => isUnrendered(v, parent) || isDefinition(v),
+  ).filter(isNode);
+  const backMatter =
+    nodes
+      .filter(isBackMatter)
+      .map((n) => n.position?.start.offset)
+      .filter(isDefined)[0] ?? null;
+  const docEnd = doc?.position?.end.offset;
+  return {
+    sections: nodes.filter(isSection).map(headingOf),
+    backMatter,
+    end: docEnd === undefined ? null : docEnd - 1,
+  };
+}

package/src/adapters/latex/parse.ts

@@ -0,0 +1,136 @@
+/**
+ * A LaTeX source → its unified-latex tree, as one `ParsedTex` that keeps the two together.
+ *
+ * ── CITATION KEYS ARE ARGUMENTS, NOT TEXT ────────────────────────────────────────
+ * unified-latex attaches arguments only to macros it has a signature for. natbib's and biblatex's
+ * citation commands have none, so `\citep{aisec2025}` came back with its key as a separate group —
+ * readable as prose. `KEY_SIGNATURES` declares them, and the other macros whose arguments name a
+ * file, a label or a URL rather than say something, so their arguments are attached and the
+ * rendered text skips them structurally. `\href` says something in one argument and names a URL in
+ * the other, so it is signed too, and `KEY_ARGUMENT` says which of its arguments is not text.
+ */
+import type * as Ast from "@unified-latex/unified-latex-types";
+import { getParser } from "@unified-latex/unified-latex-util-parse";
+import { once } from "remeda";
+
+const signed = (
+  names: readonly string[],
+  signature: string,
+): readonly (readonly [string, { readonly signature: string }])[] =>
+  names.map((m) => [m, { signature }] as const);
+
+/** Citation commands: their `{…}` argument is a key, their `[…]` ones are notes the reader sees. */
+export const CITATION_MACROS: ReadonlySet<string> = new Set([
+  "cite",
+  "citep",
+  "citet",
+  "citealp",
+  "citealt",
+  "citeauthor",
+  "citeyear",
+  "citeyearpar",
+  "Citep",
+  "Citet",
+  "nocite",
+  "parencite",
+  "textcite",
+  "autocite",
+  "footcite",
+]);
+
+/** Macros whose arguments are keys, labels, files or URLs — never text a reader sees. */
+export const KEY_SIGNATURES: Readonly<
+  Record<string, { readonly signature: string }>
+> = Object.fromEntries([
+  ...signed([...CITATION_MACROS], "o o m"),
+  ...signed(
+    [
+      "label",
+      "ref",
+      "eqref",
+      "pageref",
+      "autoref",
+      "cref",
+      "Cref",
+      "url",
+      "input",
+      "include",
+      "bibliography",
+      "bibliographystyle",
+      "addbibresource",
+    ],
+    "m",
+  ),
+  ...signed(["includegraphics"], "s o o m"),
+  ...signed(["usepackage", "RequirePackage", "documentclass"], "o m o"),
+]);
+
+/**
+ * Macros that print some arguments and not others: the index of the one argument that is a key or
+ * a URL. A citation (`o o m`) prints its `[…]` notes, not its `{…}` key; `\href` (`m m`) prints its
+ * link text, not its URL.
+ */
+export const KEY_ARGUMENT: ReadonlyMap<string, number> = new Map([
+  ...[...CITATION_MACROS].map((m) => [m, 2] as const),
+  ["href", 0],
+]);
+
+const LINK_SIGNATURES = Object.fromEntries(signed(["href"], "m m"));
+
+/**
+ * Declarations unified-latex has no signature for: signed so their arguments (sizes, not text)
+ * attach to them instead of standing beside them as groups a reader would seem to see.
+ */
+const DECLARATION_SIGNATURES = Object.fromEntries(signed(["fontsize"], "m m"));
+
+/**
+ * Macros that define other macros or environments. A heading in a body is no section where it is
+ * written, so the outline skips these; the rendered text reads a body as written, since nothing here
+ * expands macros. `\def` and its kin get a signature so the name and the body attach to them; a
+ * parameter text (`\def\x#1{…}`) is not modelled.
+ */
+export const DEFINITION_MACROS: ReadonlySet<string> = new Set([
+  "newcommand",
+  "renewcommand",
+  "providecommand",
+  "DeclareRobustCommand",
+  "newenvironment",
+  "renewenvironment",
+  "def",
+  "gdef",
+  "edef",
+  "xdef",
+]);
+
+const DEF_SIGNATURES = Object.fromEntries(
+  signed(["def", "gdef", "edef", "xdef"], "m m"),
+);
+
+// Not exported: a `ParsedTex` carries this property, and the one way to write it is `parseLatex`.
+const PARSED = Symbol("ParsedTex");
+
+/** A source and ITS tree: only `parseLatex` makes one, so a tree cannot be paired with another source. */
+export interface ParsedTex {
+  readonly src: string;
+  readonly root: Ast.Root;
+  readonly [PARSED]: true;
+}
+
+/** One parser for the process, made on first use: building one compiles its grammar. */
+const parser = once(() =>
+  getParser({
+    macros: {
+      ...KEY_SIGNATURES,
+      ...LINK_SIGNATURES,
+      ...DECLARATION_SIGNATURES,
+      ...DEF_SIGNATURES,
+    },
+  }),
+);
+
+/** A LaTeX source → its tree. */
+export const parseLatex = (src: string): ParsedTex => ({
+  src,
+  root: parser().parse(src),
+  [PARSED]: true,
+});

package/src/adapters/latex/rendered.ts

@@ -0,0 +1,59 @@
+/** The text a reader sees, each character with the source offset it came from. */
+import { hasAtLeast, sortBy } from "remeda";
+import type { Segment, TextRun } from "../../domain/tex-document.ts";
+import { isUnrendered } from "./hidden.ts";
+import {
+  isList,
+  stringText,
+  visited,
+  type Argument,
+  type Node,
+} from "./nodes.ts";
+import type { ParsedTex } from "./parse.ts";
+
+/** A node's rendered text and where it starts, or null when it is not text (it ends a run). */
+function segmentOf(n: Node | Argument): Segment | null {
+  const at = n.position?.start.offset;
+  if (at === undefined) return null;
+  if (n.type === "whitespace" || n.type === "parbreak")
+    return { text: " ", at };
+  if (n.type !== "string") return null;
+  return { text: stringText(n.content), at };
+}
+
+/** One node list → its runs: stretches of sibling text, split wherever anything else stands. */
+function runsOf(list: readonly (Node | Argument)[]): readonly TextRun[] {
+  const { done, current } = list.reduce<{
+    readonly done: readonly (readonly Segment[])[];
+    readonly current: readonly Segment[];
+  }>(
+    (acc, n) => {
+      const seg = segmentOf(n);
+      return seg === null
+        ? { done: [...acc.done, acc.current], current: [] }
+        : { done: acc.done, current: [...acc.current, seg] };
+    },
+    { done: [], current: [] },
+  );
+  return [...done, current].flatMap((g) =>
+    hasAtLeast(g, 1) &&
+    g
+      .map((x) => x.text)
+      .join("")
+      .trim() !== ""
+      ? [{ segments: g }]
+      : [],
+  );
+}
+
+/**
+ * Runs of rendered text, in document order: stretches of sibling strings and spaces. Everything
+ * else ends a run and is entered — a group's text, a macro's arguments — except what a reader never
+ * sees (`isUnrendered`): comments, math, code, the bibliography, keys and URLs. A macro definition's
+ * body is read where it is written.
+ */
+export const renderedRuns = (t: ParsedTex): readonly TextRun[] =>
+  sortBy(
+    visited(t.root, isUnrendered).filter(isList).flatMap(runsOf),
+    (r) => r.segments[0].at,
+  );

package/src/adapters/pdfjs/fill.test.ts

@@ -1,7 +1,7 @@
 /**
  * `fill.ts` — what is recovered from pdf.js's exports for each text item: whether it is upright, and
  * the fill it was drawn in (the operator-list walk). Operator lists here are written by hand; the
- * real-PDF half runs in `pdf-facts.harness.ts` and `test/e2e/banal.ts`.
+ * real-PDF half runs in `pdf-facts.harness.ts` and `test/e2e/tex/banal.e2e.ts`.
  */
 import assert from "node:assert/strict";
 import { test } from "vitest";

package/src/adapters/pdfjs/fill.ts

@@ -154,14 +154,22 @@ export function fillsFor<T>(
   textOf: (item: T) => string,
 ): { readonly item: T; readonly fill: Fill }[] {
   const drawn = drawnCharacters(ops, list);
-  let at = 0;
-  const fillOf = (text: string): Fill => {
-    const want = Array.from(squeeze(text));
-    if (want.length === 0) return { kind: "unknown" };
-    const hit = findRun(drawn, want, at);
-    if (hit === null) return { kind: "unknown" };
-    at = hit.at + want.length;
-    return hit.fill;
-  };
-  return items.map((item) => ({ item, fill: fillOf(textOf(item)) }));
+  // Each item is searched for after the previous one's match: the offset threads through.
+  const { out } = items.reduce<{
+    readonly at: number;
+    readonly out: readonly { readonly item: T; readonly fill: Fill }[];
+  }>(
+    (acc, item) => {
+      const want = Array.from(squeeze(textOf(item)));
+      const hit = want.length === 0 ? null : findRun(drawn, want, acc.at);
+      return hit === null
+        ? { at: acc.at, out: [...acc.out, { item, fill: { kind: "unknown" } }] }
+        : {
+            at: hit.at + want.length,
+            out: [...acc.out, { item, fill: hit.fill }],
+          };
+    },
+    { at: 0, out: [] },
+  );
+  return [...out];
 }

package/src/build.harness.mjs

@@ -4,7 +4,7 @@
  * The process runner is replaced by a fake that writes what pdflatex and bibtex would write, so
  * these assertions check the SHELL's decisions: what is run, with which environment, in which
  * order, and what is left on disk. Whether a real pdflatex produces a real PDF is the other half,
- * `test/e2e/build.ts`.
+ * `test/e2e/tex/build.e2e.ts`.
  *
  * 🔴 THE TWO THINGS PINNED DOWN HERE THAT A RETURNED OBJECT CANNOT SHOW: a paper-supplied
  * `build.sh` is never executed (checked by the trace it would leave on disk and by the list of
@@ -40,9 +40,7 @@ const {
   STEPS,
   IGNORED_SCRIPTS,
 } = await import(join(HERE, "build.ts"));
-const { packageVenuesDir } = await import(
-  join(HERE, "..", "skills", "paper-pipeline", "scripts", "consumer.mjs")
-);
+const { texInputsDir } = await import(join(HERE, "package-dirs.ts"));
 
 const check = createChecker();
 
@@ -137,12 +135,12 @@ const fakeRead = async (pdf) => {
 const CLEAN_TEX = "\\documentclass{article}\\begin{document}x\\end{document}";
 
 try {
-  // ── inputs: paperlint's own venues directory, no configuration ───────────────────────────────
+  // ── inputs: paperlint's own TeX inputs directory, no configuration ────────────────────────────
   // First: the facts below resolve a paper's venue preset in this same directory, so a wrong one
   // must be named HERE, not as a missing venue label two checks later.
-  const venues = packageVenuesDir();
+  const venues = texInputsDir();
   check(
-    "the venues directory is paperlint's own and holds paper-guards.tex",
+    "the TeX inputs directory is paperlint's own and holds paper-guards.tex",
     existsSync(join(venues, "paper-guards.tex")),
   );
   check(

package/src/build.ts

@@ -34,7 +34,7 @@
  * The decision of the LaTeX loop is `latex-loop.ts`, reading the log is `latex-log.ts`; both are
  * pure. This file is the shell: it runs processes through the injected `run` (the existing port —
  * `spawnSync` by default) and reads the files a pass left behind. Where paperlint's own files live is
- * answered by `consumer.mjs`, the one module allowed to know it (rule 10).
+ * answered by `package-dirs.ts`, the one module allowed to know it (rule 10).
  */
 // eslint-disable-next-line boundaries/dependencies -- legacy I/O, moves behind a port in #76
 import { existsSync, readdirSync, readFileSync, rmSync } from "node:fs";
@@ -44,7 +44,7 @@ import { createHash } from "node:crypto";
 import { delimiter, join, relative } from "node:path";
 // eslint-disable-next-line boundaries/dependencies -- legacy layer, moves behind a port in #76
 import { getParser } from "@unified-latex/unified-latex-util-parse";
-import { packageVenuesDir } from "../skills/paper-pipeline/scripts/consumer.mjs";
+import { texInputsDir } from "./package-dirs.ts";
 import { CONFIG_FILE } from "#lib/paper-config";
 import {
   declaredVenue,
@@ -268,11 +268,11 @@ export const inputsStep: BuildStep = {
   required: false,
   applies: () => ({
     yes: true,
-    why: `TEXINPUTS += ${packageVenuesDir()}`,
+    why: `TEXINPUTS += ${texInputsDir()}`,
   }),
   run: (ctx) => ({
     ok: true,
-    env: withTexInputs(ctx.env, [packageVenuesDir()]),
+    env: withTexInputs(ctx.env, [texInputsDir()]),
   }),
 };
 

package/src/cli.harness.mjs

@@ -1148,7 +1148,7 @@ check(
 //     pnpm: node_modules/vigiles/dist/cli.js  DOES NOT
 // The old wiring addressed the runtime from the project root and did not resolve under pnpm,
 // and `|| exit 2` on PreToolUse(Bash) turned that into a block on ANY command. The end-to-end
-// half (both installs, real processes) lives in `test/e2e/install.ts`; here — the verdicts.
+// half (both installs, real processes) lives in `test/e2e/install/install.e2e.ts`; here — the verdicts.
 {
   const calls = [];
   const fake = (code) => (bin, args, opts) => {

package/src/cli.test.ts

@@ -23,6 +23,7 @@ import {
   silentOptionalRules,
   toolchainTex,
 } from "./cli.ts";
+import { texInputsDir } from "./package-dirs.ts";
 
 const root = useTempDir("cli-test-");
 
@@ -248,14 +249,7 @@ writeTree(noTexDir, {
   "papers/tex/paper.tex":
     "\\documentclass{article}\\begin{document}x\\end{document}\n",
 });
-const venues = join(
-  import.meta.dirname,
-  "..",
-  "skills",
-  "submit-paper",
-  "references",
-  "venues",
-);
+const venues = texInputsDir();
 
 test("build: a markdown-only paper is refused", async () => {
   const md = await withoutTex(noTexDir, () =>

package/src/cli.ts

@@ -32,10 +32,8 @@ import { join, dirname, resolve, relative, basename, sep } from "node:path";
 import markdown from "@eslint/markdown";
 import { z } from "zod";
 // Types come from consumer.d.mts beside it.
-import {
-  isMain,
-  packageVenuesDir,
-} from "../skills/paper-pipeline/scripts/consumer.mjs";
+import { isMain } from "../skills/paper-pipeline/scripts/consumer.mjs";
+import { presetsDir } from "./package-dirs.ts";
 export { isMain };
 import type { Args, PaperlintConfig, ConfigRead } from "./types.ts";
 import {
@@ -48,8 +46,10 @@ import { prepareEngine } from "./build-engine.ts";
 import { cacheRoot, cachedTree, runToolchain } from "./toolchain.ts";
 import { banalInstaller, parseBanalSettings } from "./adapters/banal/index.ts";
 import { curlDownload } from "./adapters/curl/index.ts";
+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 {
   paperRules,
   stringFields,
@@ -72,6 +72,7 @@ import {
   shippedPresets,
   SHIPPED_PREFIX,
   type PaperPreset,
+  type PresetTemplate,
 } from "./presets.ts";
 import type { ToolInstaller } from "./ports/tool-installer.ts";
 import {
@@ -132,7 +133,7 @@ import { messageOf } from "./domain/text.ts";
 import { isRecord } from "./domain/record.ts";
 
 /** The shipped venue presets, read from the package's venues directory — the one list. */
-const SHIPPED_VENUES = (): string[] => shippedPresets(packageVenuesDir());
+const SHIPPED_VENUES = (): string[] => shippedPresets(presetsDir());
 
 const USAGE = `paperlint — machine-checkable gates for a paper kept in git
 
@@ -257,7 +258,7 @@ export function buildConfig(
         pdf: {
           rules: {
             ...pdfRules.rules,
-            ...venueRules({ files: nodeFiles, venuesDir: packageVenuesDir() }),
+            ...venueRules({ files: nodeFiles, venuesDir: presetsDir() }),
           },
         },
       },
@@ -302,7 +303,17 @@ export function buildConfig(
     cfg.push({
       files: ["**/paper.tex"],
       plugins: {
-        tex: { languages: { latex: texLanguage }, rules: texBuild },
+        tex: {
+          languages: { latex: texLanguage },
+          rules: {
+            ...texBuild,
+            ...texVenueRules({
+              files: nodeFiles,
+              venuesDir: presetsDir(),
+              latex: latexReader,
+            }),
+          },
+        },
         paper: { rules: texPaperRules },
         bib: bibReachable,
       },
@@ -316,6 +327,7 @@ export function buildConfig(
         "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,
       },
     });
   // 🔴 ONLY THE FILES THESE BLOCKS CLAIM ARE LINTED (src/paper-files.ts). Without this block ESLint's
@@ -1037,12 +1049,25 @@ export async function chooseVenue(
     value: {
       extends: spec.value,
       kind: kind !== null && kinds.includes(kind) ? kind : null,
+      setClass: classSetter(r.value.template),
       label,
       kinds,
     },
   };
 }
 
+/**
+ * What `paperlint new` does to the template's paper.tex for a venue: set it in the class the
+ * preset's template names. Null when the preset names no template, or one the reader cannot read
+ * (then `tex/template` says so on the new paper).
+ */
+function classSetter(
+  t: PresetTemplate | null,
+): ((paperTex: string) => string) | null {
+  const cls = t === null ? null : latexReader.template(t.text);
+  return cls === null ? null : (src) => latexReader.withDocumentClass(src, cls);
+}
+
 const bad = (error: string): { ok: false; error: string } => ({
   ok: false,
   error,
@@ -1217,7 +1242,7 @@ async function runBuild(
 }
 
 /** The presets' deps, wired to the disk and the package's own venues directory. */
-const PRESET_DEPS = { files: nodeFiles, venuesDir: packageVenuesDir() };
+const PRESET_DEPS = { files: nodeFiles, venuesDir: presetsDir() };
 
 /**
  * What one paper needs from TeX Live: the base set plus its preset chain's `tex`. A paper whose