paperlint 6.3.0 → 7.0.0

package/src/presets.test.ts

@@ -7,7 +7,7 @@
  * resolving shows here.
  */
 import { readdirSync, readFileSync } from "node:fs";
-import { join } from "node:path";
+import { join, relative } from "node:path";
 import { describe, expect, it } from "vitest";
 import { memoryFiles } from "./adapters/memory/index.ts";
 import { presetsDir } from "./package-dirs.ts";
@@ -35,6 +35,17 @@ const deps = (extra: Record<string, string> = {}) => ({
 });
 const resolve = (spec: string, extra: Record<string, string> = {}) =>
   resolvePreset(spec, PAPER_FILE, deps(extra));
+/** A venue preset of a project's own: the identity every venue declares, then `body`. */
+const venue = (body: Record<string, unknown>, name = "Our Workshop"): string =>
+  JSON.stringify({
+    type: "venue",
+    name,
+    url: "https://example.org/cfp",
+    ...body,
+  });
+/** A template family of a project's own. */
+const family = (body: Record<string, unknown>): string =>
+  JSON.stringify({ type: "family", ...body });
 
 describe("shipped presets", () => {
   it("paperlint:agenticdev → agenticdev over acm-sigconf: the family's format, the venue's kinds", () => {
@@ -54,7 +65,15 @@ describe("shipped presets", () => {
       file: join(VENUES, "acm-sigconf.jsonc"),
     });
     expect("acmart" in r.value.tex.packages).toBe(true);
-    expect(r.value.label).toBe("agenticdev");
+    // The label is the venue's own name, from its file's `name`; the id stays the file name — the
+    // stable key the facts file and the build plan carry.
+    expect(r.value.label).toBe("AgenticDev");
+    expect(r.value.id).toBe("agenticdev");
+    expect(r.value.identity).toEqual({
+      type: "venue",
+      name: "AgenticDev",
+      url: "https://conf.researchr.org/home/ase-2026/agenticdev-2026",
+    });
   });
 
   it("a paper may extend a family directly: format and fonts, and no kinds", () => {
@@ -78,19 +97,72 @@ 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,
-    };
+// 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 PARSED = shippedPresets(VENUES).map((name) => {
+  const file = join(VENUES, `${name}.jsonc`);
+  return {
+    name,
+    preset: parsePreset(readFileSync(file, "utf8"), file, VENUES),
+  };
+});
+const FAMILIES = PARSED.filter((p) =>
+  PARSED.some((q) => q.preset.extends === `${SHIPPED_PREFIX}${p.name}`),
+);
+
+describe("what each shipped preset declares itself to be", () => {
+  it("every shipped preset loads and declares what it is; a venue links its call", () => {
+    const declared = Object.fromEntries(
+      readdirSync(VENUES)
+        .filter((f) => f.endsWith(".jsonc"))
+        .map((f) => [
+          f,
+          parsePreset(readFileSync(join(VENUES, f), "utf8"), f, VENUES)
+            .identity,
+        ]),
+    );
+    expect(declared).toEqual({
+      "acm-sigconf.jsonc": { type: "family" },
+      "agenticdev.jsonc": {
+        type: "venue",
+        name: "AgenticDev",
+        url: "https://conf.researchr.org/home/ase-2026/agenticdev-2026",
+      },
+      "aidc.jsonc": {
+        type: "venue",
+        name: "AIDC",
+        url: "https://aidcworkshop.github.io/",
+      },
+      "aisec.jsonc": {
+        type: "venue",
+        name: "AISec",
+        url: "https://aisec.cc/",
+      },
+      "ieee-conference.jsonc": { type: "family" },
+      "realm.jsonc": {
+        type: "venue",
+        name: "REALM",
+        url: "https://realm-workshop.github.io/call_for_papers",
+      },
+      "tex-base.jsonc": { type: "base" },
+    });
   });
-  const families = presets.filter((p) =>
-    presets.some((q) => q.extends === `${SHIPPED_PREFIX}${p.name}`),
-  );
+
+  it("the families another preset extends are exactly the ones that declare `family`", () => {
+    expect(
+      PARSED.filter((p) => p.preset.identity.type === "family").map(
+        (p) => p.name,
+      ),
+    ).toEqual(FAMILIES.map((f) => f.name));
+  });
+});
+
+describe("the naming convention of shipped presets (docs/rules.md)", () => {
+  const families = FAMILIES;
+  const presets = PARSED.map((p) => ({
+    name: p.name,
+    extends: p.preset.extends,
+  }));
   const publishers = families.map((f) => f.name.slice(0, f.name.indexOf("-")));
 
   it("there are families to check (else the checks below see nothing)", () => {
@@ -118,16 +190,18 @@ describe("the naming convention of shipped presets (docs/rules.md)", () => {
 });
 
 describe("a project's own preset, by relative path", () => {
-  const usenix = JSON.stringify({
-    extends: "paperlint:acm-sigconf",
-    name: "USENIX Security",
-    format: {
-      columns: 1,
-      kinds: { full: { body_pages_max: 13, ref_pages_max: 0 } },
+  const usenix = venue(
+    {
+      extends: "paperlint:acm-sigconf",
+      format: {
+        columns: 1,
+        kinds: { full: { body_pages_max: 13, ref_pages_max: 0 } },
+      },
+      tex: { packages: { usenix: ["usenix.sty"] } },
+      rules: { "pdf/body-size": "off" },
     },
-    tex: { packages: { usenix: ["usenix.sty"] } },
-    rules: { "pdf/body-size": "off" },
-  });
+    "USENIX Security",
+  );
 
   it("./ is relative to the file that says it; merged per block, child wins", () => {
     const r = resolve("../../venues/usenix-sec.jsonc", {
@@ -147,18 +221,21 @@ describe("a project's own preset, by relative path", () => {
     expect(r.value.label).toBe("USENIX Security");
   });
 
-  it("without `name`, the label is the file name without its extension", () => {
+  it("a family names no venue: its label is the file name without its extension", () => {
     const r = resolve("./venues/usenix-sec.jsonc", {
-      "/work/papers/p/venues/usenix-sec.jsonc": JSON.stringify({
+      "/work/papers/p/venues/usenix-sec.jsonc": family({
         extends: "paperlint:acm-sigconf",
       }),
     });
     expect(r.ok && r.value.label).toBe("usenix-sec");
+    expect(r.ok && r.value.identity).toEqual({ type: "family" });
   });
+});
 
+describe("a project's own preset: what its children replace", () => {
   it("a child kind replaces that kind wholesale; other kinds are kept", () => {
     const r = resolve("./mine.jsonc", {
-      "/work/papers/p/mine.jsonc": JSON.stringify({
+      "/work/papers/p/mine.jsonc": venue({
         extends: "paperlint:agenticdev",
         format: { kinds: { short: { body_pages_max: 6 } } },
       }),
@@ -174,13 +251,40 @@ describe("a project's own preset, by relative path", () => {
 
   it("rules: the leaf wins over its parent, per rule id", () => {
     const r = resolve("./mine.jsonc", {
-      "/work/papers/p/mine.jsonc": JSON.stringify({
+      "/work/papers/p/mine.jsonc": venue({
         extends: "paperlint:agenticdev",
         rules: { "pdf/last-page-balance": "off" },
       }),
     });
     expect(r.ok && r.value.rules["pdf/last-page-balance"]).toBe("off");
   });
+
+  it("ruleOrigins: each rule's entry names the file of the chain that set it", () => {
+    const r = resolve("./mine.jsonc", {
+      "/work/papers/p/mine.jsonc": venue({
+        extends: "paperlint:agenticdev",
+        rules: { "pdf/body-size": "off" },
+      }),
+    });
+    // Guards: an own rule is the leaf's, an inherited one names the parent that set it.
+    expect(r.ok && r.value.ruleOrigins).toEqual({
+      "pdf/last-page-balance": join(VENUES, "agenticdev.jsonc"),
+      "tex/heading-case": join(VENUES, "agenticdev.jsonc"),
+      "pdf/body-size": "/work/papers/p/mine.jsonc",
+    });
+  });
+
+  it("ruleOrigins: a rule the leaf sets again is the leaf's, not its parent's", () => {
+    const r = resolve("./mine.jsonc", {
+      "/work/papers/p/mine.jsonc": venue({
+        extends: "paperlint:agenticdev",
+        rules: { "tex/heading-case": "off" },
+      }),
+    });
+    expect(r.ok && r.value.ruleOrigins["tex/heading-case"]).toBe(
+      "/work/papers/p/mine.jsonc",
+    );
+  });
 });
 
 describe("what does not resolve, and says why", () => {
@@ -217,8 +321,8 @@ describe("what does not resolve, and says why", () => {
 describe("chains that do not resolve", () => {
   it("a cycle is refused, naming the chain", () => {
     const r = resolve("./a.jsonc", {
-      "/work/papers/p/a.jsonc": JSON.stringify({ extends: "./b.jsonc" }),
-      "/work/papers/p/b.jsonc": JSON.stringify({ extends: "./a.jsonc" }),
+      "/work/papers/p/a.jsonc": family({ extends: "./b.jsonc" }),
+      "/work/papers/p/b.jsonc": family({ extends: "./a.jsonc" }),
     });
     expect(r.ok).toBe(false);
     if (r.ok) return;
@@ -231,7 +335,7 @@ describe("chains that do not resolve", () => {
   it(`a chain longer than ${String(MAX_PRESET_DEPTH)} is refused, printing it`, () => {
     const files: Record<string, string> = {};
     for (let i = 1; i <= 5; i++)
-      files[`/work/papers/p/p${String(i)}.jsonc`] = JSON.stringify({
+      files[`/work/papers/p/p${String(i)}.jsonc`] = venue({
         extends: i < 5 ? `./p${String(i + 1)}.jsonc` : "paperlint:acm-sigconf",
       });
     const r = resolve("./p1.jsonc", files);
@@ -243,17 +347,17 @@ describe("chains that do not resolve", () => {
 
   it("a chain of exactly the limit resolves", () => {
     const r = resolve("./p1.jsonc", {
-      "/work/papers/p/p1.jsonc": JSON.stringify({ extends: "./p2.jsonc" }),
-      "/work/papers/p/p2.jsonc": JSON.stringify({
-        extends: "paperlint:agenticdev",
-      }),
+      "/work/papers/p/p1.jsonc": venue({ extends: "./p2.jsonc" }),
+      "/work/papers/p/p2.jsonc": venue({ extends: "paperlint:agenticdev" }),
     });
     expect(r.ok && r.value.chain.length).toBe(MAX_PRESET_DEPTH);
   });
+});
 
+describe("chains that do not resolve: the files themselves", () => {
   it("a preset that fails the schema is named with its file", () => {
     const r = resolve("./bad.jsonc", {
-      "/work/papers/p/bad.jsonc": JSON.stringify({
+      "/work/papers/p/bad.jsonc": family({
         extends: "paperlint:acm-sigconf",
         colums: 2,
       }),
@@ -266,16 +370,51 @@ describe("chains that do not resolve", () => {
 
   it("a preset with no `extends` must carry `tex` (it is a root)", () => {
     const r = resolve("./root.jsonc", {
-      "/work/papers/p/root.jsonc": JSON.stringify({ format: { columns: 1 } }),
+      "/work/papers/p/root.jsonc": family({ format: { columns: 1 } }),
+    });
+    expect(r.ok).toBe(false);
+  });
+
+  it("a family that extends a venue is refused, naming both files", () => {
+    const r = resolve("./fam.jsonc", {
+      "/work/papers/p/fam.jsonc": family({ extends: "paperlint:aisec" }),
+    });
+    expect(r.ok).toBe(false);
+    if (r.ok) return;
+    expect(presetProblemText(r.error)).toBe(
+      `the preset /work/papers/p/fam.jsonc is a template family and extends ${join(VENUES, "aisec.jsonc")}, a venue — a family builds only on a family; a venue extends a family or another venue`,
+    );
+  });
+
+  it("nothing extends the TeX base set, even by a relative path", () => {
+    const r = resolve("./mine.jsonc", {
+      "/work/papers/p/mine.jsonc": venue({
+        extends: relative("/work/papers/p", join(VENUES, "tex-base.jsonc")),
+      }),
     });
     expect(r.ok).toBe(false);
+    if (r.ok) return;
+    expect(presetProblemText(r.error)).toBe(
+      `the preset /work/papers/p/mine.jsonc extends ${join(VENUES, "tex-base.jsonc")}, the TeX base set — every paper gets that set already, and no preset extends it`,
+    );
+  });
+
+  it("a venue may extend a venue, and the resolved identity is the leaf's", () => {
+    const r = resolve("./mine.jsonc", {
+      "/work/papers/p/mine.jsonc": venue({ extends: "paperlint:aisec" }),
+    });
+    expect(r.ok && r.value.identity).toEqual({
+      type: "venue",
+      name: "Our Workshop",
+      url: "https://example.org/cfp",
+    });
   });
 });
 
 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({
+      "/work/papers/p/own.jsonc": venue({
         extends: "paperlint:aidc",
         template: "\\documentclass[conference]{IEEEtran}",
       }),
@@ -302,8 +441,16 @@ describe("labelOf — display only, never used to resolve", () => {
 describe("shippedVenueNames — what each shipped venue is called", () => {
   it("every shipped preset, by its label and the names along its chain", () => {
     const names = shippedVenueNames(deps());
-    expect(names.map((n) => n.label)).toEqual(shippedPresets(VENUES));
-    expect(names.find((n) => n.label === "aisec")?.aliases).toEqual(
+    // A venue is labelled by its `name`, a family by its file name.
+    expect(names.map((n) => n.label)).toEqual([
+      "acm-sigconf",
+      "AgenticDev",
+      "AIDC",
+      "AISec",
+      "ieee-conference",
+      "REALM",
+    ]);
+    expect(names.find((n) => n.label === "AISec")?.aliases).toEqual(
       expect.arrayContaining(["AISec", "ACM CCS"]),
     );
   });
@@ -316,6 +463,12 @@ describe("shippedVenueNames — what each shipped venue is called", () => {
     );
     expect(
       shippedVenueNames({ files, venuesDir: VENUES }).map((n) => n.label),
-    ).toEqual(shippedPresets(VENUES).filter((n) => n !== "realm"));
+    ).toEqual([
+      "acm-sigconf",
+      "AgenticDev",
+      "AIDC",
+      "AISec",
+      "ieee-conference",
+    ]);
   });
 });

package/src/presets.ts

@@ -12,20 +12,27 @@
  * Anything else — an npm package name, a bare name — is refused by name. npm presets are not
  * supported yet; a bare name is almost always a shipped name missing its prefix, and the message says so.
  *
+ * ── WHAT EACH FILE IS ─────────────────────────────────────────────────────────────
+ * Every preset declares its `type` (`venue-profile.schema.json`): a `venue` names itself and links
+ * its call for papers, a template `family` names no venue, and the TeX `base` set is extended by
+ * nothing. A chain must read top-down as template → venue: a family extends only a family, and
+ * nothing extends the base set. A chain that does not is refused naming both files.
+ *
  * ── THE CHAIN ─────────────────────────────────────────────────────────────────────
  * At most `MAX_PRESET_DEPTH` files, root to leaf. A cycle (relative paths can form one) is refused
  * naming the chain. The chain is merged block by block:
  *
  *   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
+ *   rules      per rule id, the child wins; `ruleOrigins` keeps which file set each
  *   template   the child wins; so does `name`, and `required_sections`, `register`, `talk` and
  *              `portal` (each whole)
  *   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
- * preset's `name` when one sets it, else the spec's file name without its extension
+ * ── THE ID AND THE LABEL ──────────────────────────────────────────────────────────
+ * The facts file and the build plan carry the preset's `id`: the spec's file name without its
+ * extension, a stable key consumers match against preset ids. Messages say the `label`: the most
+ * derived venue's `name` when the chain has a venue, else the id
  * (`paperlint:agenticdev` → `agenticdev`, `./venues/usenix-sec.jsonc` → `usenix-sec`). Display
  * only: nothing is ever resolved by it.
  */
@@ -38,6 +45,7 @@ import {
   profileFileOf,
   venueNames,
   type PresetFile,
+  type PresetIdentity,
   type RequiredSection,
   type TexRequirements,
   type VenueFormat,
@@ -75,10 +83,17 @@ export interface PresetTemplate {
 
 /** A resolved chain, merged. */
 export interface Preset {
-  /** The word for this venue in messages. */
+  /**
+   * The preset's id: the spec's file name without its extension (`agenticdev`, `usenix-sec`). The
+   * stable key a machine reads — the facts file and the build plan carry it — whatever `name` says.
+   */
+  readonly id: string;
+  /** The word for this venue in messages: the venue's `name`, else the id. */
   readonly label: string;
   /** Every file of the chain, root first. */
   readonly chain: readonly string[];
+  /** What the spec names — the leaf file of the chain: a venue (with its call), or a family. */
+  readonly identity: PresetIdentity;
   /**
    * 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`,
@@ -93,6 +108,8 @@ export interface Preset {
   readonly tex: TexRequirements;
   readonly format: VenueFormat;
   readonly rules: Readonly<Record<string, unknown>>;
+  /** Rule id → the file of the chain that set its entry in `rules` (the last one to name it). */
+  readonly ruleOrigins: Readonly<Record<string, string>>;
   /** The accepted papers the register rules measure a body against; empty when no file names any. */
   readonly registerAnchors: readonly RegisterAnchor[];
   /** What the venue asks a presenter to send (`talk/*`); null when no file of the chain says. */
@@ -112,6 +129,14 @@ export type PresetProblem =
     }
   | { readonly kind: "cycle"; readonly chain: readonly string[] }
   | { readonly kind: "too-deep"; readonly chain: readonly string[] }
+  /** `file` extends `parent`, which a preset of its type may not extend. */
+  | {
+      readonly kind: "wrong-parent";
+      readonly file: string;
+      readonly parent: string;
+      /** A family extending a venue, or anything extending the base set. */
+      readonly parentType: "venue" | "base";
+    }
   | { readonly kind: "broken"; readonly file: string; readonly why: string };
 
 /** The display label of a spec: the file name without its extension. Pure. */
@@ -166,27 +191,47 @@ function readPreset(
   }
 }
 
-/** The chain's files, leaf first, each parsed. */
-function chainOf(
-  spec: string,
-  from: string,
+/** One file of a chain: where it is, and what it says. */
+interface Link {
+  readonly file: string;
+  readonly preset: PresetFile;
+}
+
+/**
+ * The chain from `child` up, leaf first: `below` is every file read so far, `child` the last of them.
+ * Each parent is refused when it closes a cycle, makes the chain too long, or is of a type `child`
+ * may not extend.
+ */
+function chainUp(
+  below: readonly Link[],
+  child: Link,
   deps: PresetDeps,
-): Result<{ file: string; preset: PresetFile }[], PresetProblem> {
-  const out: { file: string; preset: PresetFile }[] = [];
-  let next: { spec: string; from: string } | null = { spec, from };
-  while (next !== null) {
-    const r = readPreset(next.spec, next.from, deps);
-    if (!r.ok) return r;
-    const files = out.map((x) => x.file);
-    if (files.includes(r.value.file))
-      return err({ kind: "cycle", chain: [...files, r.value.file] });
-    if (out.length === MAX_PRESET_DEPTH)
-      return err({ kind: "too-deep", chain: [...files, r.value.file] });
-    out.push(r.value);
-    const up: string | null = r.value.preset.extends;
-    next = up === null ? null : { spec: up, from: r.value.file };
-  }
-  return ok(out);
+): Result<readonly Link[], PresetProblem> {
+  const up = child.preset.extends;
+  if (up === null) return ok(below);
+  const r = readPreset(up, child.file, deps);
+  if (!r.ok) return r;
+  const files = below.map((x) => x.file);
+  if (files.includes(r.value.file))
+    return err({ kind: "cycle", chain: [...files, r.value.file] });
+  if (below.length === MAX_PRESET_DEPTH)
+    return err({ kind: "too-deep", chain: [...files, r.value.file] });
+  const parentType = r.value.preset.identity.type;
+  if (parentType === "venue" && child.preset.identity.type === "family")
+    return err({
+      kind: "wrong-parent",
+      file: child.file,
+      parent: r.value.file,
+      parentType,
+    });
+  if (parentType === "base")
+    return err({
+      kind: "wrong-parent",
+      file: child.file,
+      parent: r.value.file,
+      parentType,
+    });
+  return chainUp([...below, r.value], r.value, deps);
 }
 
 /** A child's format over its parent's: per key the child wins, kinds by name. Pure. */
@@ -213,52 +258,68 @@ export function mergeFormat(
   };
 }
 
+/** A venue's name; a family and the base set have none. Pure. */
+const nameOf = (i: PresetIdentity): string | null =>
+  i.type === "venue" ? i.name : null;
+
+/** A venue's name as a list, empty for a family and the base set. Pure. */
+const namesOf = (i: PresetIdentity): readonly string[] =>
+  i.type === "venue" ? [i.name] : [];
+
+/** What the merge carries from file to file: the preset without what only the whole chain knows. */
+type Merging = Omit<Preset, "id" | "label" | "chain" | "identity"> & {
+  readonly name: string | null;
+};
+
+const NOTHING_MERGED: Merging = {
+  name: null,
+  template: null,
+  aliases: [],
+  blind: false,
+  requiredSections: [],
+  tex: NO_REQUIREMENTS,
+  format: NO_FORMAT,
+  rules: {},
+  ruleOrigins: {},
+  registerAnchors: [],
+  talk: null,
+  portal: null,
+};
+
+/** One file of the chain, `file`, merged over what its parents gave. Pure. */
+const mergeOne = (
+  acc: Merging,
+  { preset: p, file }: { readonly preset: PresetFile; readonly file: string },
+): Merging => ({
+  name: nameOf(p.identity) ?? acc.name,
+  template: p.template === null ? acc.template : { text: p.template, file },
+  aliases: [...new Set([...acc.aliases, ...namesOf(p.identity), ...p.aliases])],
+  blind: p.blind ?? acc.blind,
+  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 },
+  ruleOrigins: {
+    ...acc.ruleOrigins,
+    ...Object.fromEntries(Object.keys(p.rules).map((id) => [id, file])),
+  },
+  registerAnchors: p.registerAnchors ?? acc.registerAnchors,
+  talk: p.talk ?? acc.talk,
+  portal: p.portal ?? acc.portal,
+});
+
 /** The chain, root first, merged into one preset. Pure. */
 function merged(
   spec: string,
   rootFirst: readonly { readonly preset: PresetFile; readonly file: string }[],
+  leaf: { readonly preset: PresetFile },
 ): Preset {
-  const base: Omit<Preset, "label" | "chain"> & {
-    readonly name: string | null;
-  } = {
-    name: null,
-    template: null,
-    aliases: [],
-    blind: false,
-    requiredSections: [],
-    tex: NO_REQUIREMENTS,
-    format: NO_FORMAT,
-    rules: {},
-    registerAnchors: [],
-    talk: null,
-    portal: null,
-  };
-  const m = rootFirst.reduce(
-    (acc, { preset: p, file }) => ({
-      name: p.name ?? acc.name,
-      template: p.template === null ? acc.template : { text: p.template, file },
-      aliases: [
-        ...new Set([
-          ...acc.aliases,
-          ...(p.name === null ? [] : [p.name]),
-          ...p.aliases,
-        ]),
-      ],
-      blind: p.blind ?? acc.blind,
-      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 },
-      registerAnchors: p.registerAnchors ?? acc.registerAnchors,
-      talk: p.talk ?? acc.talk,
-      portal: p.portal ?? acc.portal,
-    }),
-    base,
-  );
-  const { name, ...rest } = m;
+  const { name, ...rest } = rootFirst.reduce(mergeOne, NOTHING_MERGED);
   return {
+    id: labelOf(spec),
     label: name ?? labelOf(spec),
     chain: rootFirst.map((x) => x.file),
+    identity: leaf.preset.identity,
     ...rest,
   };
 }
@@ -272,13 +333,17 @@ export function resolvePreset(
   fromFile: string,
   deps: PresetDeps,
 ): Result<Preset, PresetProblem> {
-  const chain = chainOf(spec, fromFile, deps);
-  if (!chain.ok)
-    return chain.error.kind === "not-found"
-      ? err({ ...chain.error, shipped: shippedPresets(deps.venuesDir) })
-      : chain;
-  const rootFirst = [...chain.value].reverse();
-  return ok(merged(spec, rootFirst));
+  const refused = (p: PresetProblem): Result<Preset, PresetProblem> =>
+    err(
+      p.kind === "not-found"
+        ? { ...p, shipped: shippedPresets(deps.venuesDir) }
+        : p,
+    );
+  const leaf = readPreset(spec, fromFile, deps);
+  if (!leaf.ok) return refused(leaf.error);
+  const chain = chainUp([leaf.value], leaf.value, deps);
+  if (!chain.ok) return refused(chain.error);
+  return ok(merged(spec, [...chain.value].reverse(), leaf.value));
 }
 
 /** The shipped presets' names (each is spelled `paperlint:<name>`). */
@@ -336,6 +401,10 @@ export function presetProblemText(p: PresetProblem): string {
       return `the preset chain is longer than ${String(MAX_PRESET_DEPTH)}: ${p.chain.join(" → ")}`;
     case "broken":
       return `the preset ${p.file} does not parse: ${p.why}`;
+    case "wrong-parent":
+      return p.parentType === "base"
+        ? `the preset ${p.file} extends ${p.parent}, the TeX base set — every paper gets that set already, and no preset extends it`
+        : `the preset ${p.file} is a template family and extends ${p.parent}, a venue — a family builds only on a family; a venue extends a family or another venue`;
   }
 }