paperlint 6.3.0 → 7.1.0

package/src/tex-requirements.test.ts

@@ -1,6 +1,11 @@
 import assert from "node:assert/strict";
 import { test } from "vitest";
-import { loadTypescript } from "./tex-requirements.ts";
+import {
+  identityHint,
+  identityHints,
+  loadTypescript,
+  parsePreset,
+} from "./tex-requirements.ts";
 
 test("loadTypescript refuses a module without the two functions a profile is read with", () => {
   assert.throws(
@@ -19,3 +24,124 @@ test("loadTypescript hands back what `require` loaded when it has them", () => {
     ts,
   );
 });
+
+// ── what a preset is: the identity its `type` declares ─────────────────────────────────────
+
+/** What `parsePreset` throws for `preset`, as text; "" when it parses. */
+function refusalOf(name: string, preset: object): string {
+  try {
+    parsePreset(JSON.stringify(preset), name);
+    return "";
+  } catch (e) {
+    return e instanceof Error ? e.message : String(e);
+  }
+}
+
+test("a venue without the link to its call for papers is refused at load, saying what to add", () => {
+  // Guards: the wrong state the identity exists to make unrepresentable — a venue nobody can check.
+  assert.equal(
+    refusalOf("v.jsonc", {
+      type: "venue",
+      name: "X",
+      extends: "paperlint:acm-sigconf",
+    }),
+    [
+      "v.jsonc does not match venue-profile.schema.json:",
+      '  a venue preset names its venue and links its call for papers: "name": "<the venue, as its call spells it>", "url": "https://<the call for papers>"',
+      "  v.jsonc: (top level) should have required property 'url'",
+      '  v.jsonc: (top level) should match "then" schema',
+    ].join("\n"),
+  );
+});
+
+test("a template family with a venue's name and url is refused, naming each key", () => {
+  assert.equal(
+    refusalOf("f.jsonc", {
+      type: "family",
+      name: "ACM",
+      url: "https://acm.org/",
+      extends: "paperlint:acm-sigconf",
+    }),
+    [
+      "f.jsonc does not match venue-profile.schema.json:",
+      '  a template family names no venue: drop "name" — "name" and "url" belong to the venue presets that extend it',
+      '  a template family names no venue: drop "url" — "name" and "url" belong to the venue presets that extend it',
+      "  f.jsonc: .name boolean schema is false",
+      "  f.jsonc: .url boolean schema is false",
+      '  f.jsonc: (top level) should match "then" schema',
+    ].join("\n"),
+  );
+});
+
+test("a preset that does not say what it is is refused, with the three answers", () => {
+  assert.equal(
+    refusalOf("n.jsonc", { extends: "paperlint:acm-sigconf" }),
+    [
+      "n.jsonc does not match venue-profile.schema.json:",
+      '  say what this preset is: "type": "venue" (one venue\'s call for papers), "family" (a publisher\'s template that venues extend) or "base" (the TeX base set)',
+      "  n.jsonc: (top level) should have required property 'type'",
+    ].join("\n"),
+  );
+});
+
+test("the TeX base set holds its packages and nothing else", () => {
+  assert.equal(
+    refusalOf("b.jsonc", {
+      type: "base",
+      tex: { packages: { a: ["a.sty"] } },
+      format: { columns: 2 },
+    }),
+    [
+      "b.jsonc does not match venue-profile.schema.json:",
+      '  the TeX base set holds "type" and "tex" only — a venue\'s or a family\'s settings go in its own preset',
+      "  b.jsonc: (top level) should NOT have more than 2 properties",
+      '  b.jsonc: (top level) should match "then" schema',
+    ].join("\n"),
+  );
+});
+
+test("a venue is parsed into its identity; a family and the base set carry none of a venue's fields", () => {
+  const read = (p: object) =>
+    parsePreset(JSON.stringify(p), "p.jsonc").identity;
+  assert.deepEqual(
+    [
+      read({
+        type: "venue",
+        name: "X",
+        url: "https://x.org/cfp",
+        extends: "paperlint:acm-sigconf",
+      }),
+      read({ type: "family", extends: "paperlint:acm-sigconf" }),
+      read({ type: "base", tex: { packages: { a: ["a.sty"] } } }),
+    ],
+    [
+      { type: "venue", name: "X", url: "https://x.org/cfp" },
+      { type: "family" },
+      { type: "base" },
+    ],
+  );
+});
+
+test("identityHint has nothing to add to a violation that is not about the identity", () => {
+  assert.equal(
+    identityHint({
+      keyword: "additionalProperties",
+      dataPath: "",
+      params: { additionalProperty: "colums" },
+    }),
+    null,
+  );
+});
+
+test("identityHints: Ajv's null errors give none; a hint two violations share is given once", () => {
+  assert.deepEqual(identityHints({ errors: null }), []);
+  const missing = {
+    keyword: "required",
+    dataPath: "",
+    schemaPath: "#/required",
+    params: { missingProperty: "type" },
+  };
+  const hints = identityHints({ errors: [missing, missing] });
+  assert.equal(hints.length, 1);
+  assert.deepEqual(hints, [identityHint(missing)]);
+});

package/src/tex-requirements.ts

@@ -140,6 +140,11 @@ export interface VenueFormat {
   readonly fontsTitle: string | null;
   /** How the body is counted: null is banal's count; `references`, the pages before the references. */
   readonly bodyEndsAt: "references" | null;
+  /**
+   * With `bodyEndsAt`: appendices count as body wherever they sit, and the reference pages are the
+   * ones holding only references. Null: the appendix ends the body, as `references` alone counts it.
+   */
+  readonly appendixInBody: boolean | null;
   readonly kinds: ReadonlyMap<string, KindLimits>;
 }
 
@@ -155,6 +160,7 @@ export const NO_FORMAT: VenueFormat = {
   fontsText: null,
   fontsTitle: null,
   bodyEndsAt: null,
+  appendixInBody: null,
   kinds: new Map(),
 };
 
@@ -165,21 +171,38 @@ export interface RequiredSection {
   readonly position: "last" | null;
 }
 
+/**
+ * What a preset file IS, as its `type` declares it. A venue names itself and its call for papers; a
+ * template family and the base set name no venue, so they cannot carry either — the union has no
+ * field to put them in, the way the schema refuses them.
+ */
+export type PresetIdentity =
+  | { readonly type: "venue"; readonly name: string; readonly url: string }
+  | { readonly type: "family" }
+  | { readonly type: "base" };
+
+/** A preset's kind of file: `venue`, `family` or `base`. */
+export type PresetType = PresetIdentity["type"];
+
 /**
  * One preset FILE, parsed — before its `extends` chain is resolved (`src/presets.ts` does that).
- * A preset is a venue or a template family: `{ extends?, name?, template?, format?, tex?, rules? }`.
+ * A preset is a venue, a template family, or the TeX base set (`identity`).
  */
 export interface PresetFile {
+  /** What the file is, and for a venue, its name and call for papers. */
+  readonly identity: PresetIdentity;
   /** The preset this one builds on: `paperlint:<name>` or a relative path. */
   readonly extends: string | null;
-  /** A display name for messages; the file name otherwise. */
-  readonly name: string | null;
   /** The `\\documentclass` the venue's template uses, as the file spells it; null when it names none. */
   readonly template: string | null;
+  /** Class options the venue forbids, read with `template`; empty when the file names none. */
+  readonly templateForbids: readonly string[];
   /** Other names the venue goes by in a paper's text; empty when the file names none. */
   readonly aliases: readonly string[];
   /** Whether the venue reviews double-blind; null when the file does not say. */
   readonly blind: boolean | null;
+  /** When the venue's names count as a mention in a paper's text; null when the file does not say. */
+  readonly mentions: "with-year" | null;
   /** Sections the venue requires; null when the file names none (a child's list replaces its parent's). */
   readonly requiredSections: readonly RequiredSection[] | null;
   /** Null when the file declares no `tex` block (allowed only with `extends`). */
@@ -214,16 +237,28 @@ interface FormatJson {
   readonly fonts_text?: string;
   readonly fonts_title?: string;
   readonly body_ends_at?: "references";
+  readonly appendix_in_body?: boolean;
   readonly kinds?: KindsJson;
 }
 
-/** The preset's JSON after the schema accepted it — the shape `venue-profile.schema.json` allows. */
-interface PresetJson {
+/**
+ * The preset's JSON after the schema accepted it — the shape `venue-profile.schema.json` allows,
+ * the identity included: a venue has its `name` and `url`, a family and the base set have neither.
+ */
+type PresetJson = PresetBodyJson &
+  (
+    | { readonly type: "venue"; readonly name: string; readonly url: string }
+    | { readonly type: "family" | "base" }
+  );
+
+/** Every key of a preset but its identity. */
+interface PresetBodyJson {
   readonly extends?: string;
-  readonly name?: string;
   readonly template?: string;
+  readonly template_forbids?: readonly string[];
   readonly aliases?: readonly string[];
   readonly blind?: boolean;
+  readonly mentions?: "with-year";
   readonly required_sections?: readonly {
     readonly title: string;
     readonly position?: "last";
@@ -270,6 +305,7 @@ function formatOf(j: FormatJson = {}): VenueFormat {
     fontsText: orNull(j.fonts_text),
     fontsTitle: orNull(j.fonts_title),
     bodyEndsAt: orNull(j.body_ends_at),
+    appendixInBody: orNull(j.appendix_in_body),
     kinds: kindsOf(j.kinds),
   };
 }
@@ -282,6 +318,46 @@ const sectionsOf = (
     ? null
     : r.map((x) => ({ title: x.title, position: orNull(x.position) }));
 
+/** The identity a preset's `type` declares. Pure. */
+const identityOf = (j: PresetJson): PresetIdentity =>
+  j.type === "venue"
+    ? { type: "venue", name: j.name, url: j.url }
+    : { type: j.type };
+
+/** One ajv error, as far as the hints read it. */
+interface SchemaError {
+  readonly keyword: string;
+  readonly dataPath: string;
+  readonly params: object;
+}
+
+/**
+ * What to write instead, for the violations of a preset's identity — ajv's own words for them
+ * ("should have required property 'url'", "boolean schema is false") name the key but not why.
+ * Read off the error's keyword and parameters, never its message text. Pure.
+ */
+export function identityHint(e: SchemaError): string | null {
+  const missing = fieldOf(e.params, "missingProperty");
+  if (e.keyword === "required" && missing === "type")
+    return 'say what this preset is: "type": "venue" (one venue\'s call for papers), "family" (a publisher\'s template that venues extend) or "base" (the TeX base set)';
+  if (e.keyword === "required" && (missing === "name" || missing === "url"))
+    return 'a venue preset names its venue and links its call for papers: "name": "<the venue, as its call spells it>", "url": "https://<the call for papers>"';
+  if (e.keyword === "false schema")
+    return `a template family names no venue: drop "${e.dataPath.slice(1)}" — "name" and "url" belong to the venue presets that extend it`;
+  if (e.keyword === "maxProperties")
+    return 'the TeX base set holds "type" and "tex" only — a venue\'s or a family\'s settings go in its own preset';
+  return null;
+}
+
+/** The hints for every violation that has one, each once. Ajv's null `errors` has none. */
+export const identityHints = (
+  v: Readonly<Pick<Validate, "errors">>,
+): readonly string[] => [
+  ...new Set(
+    (v.errors ?? []).map(identityHint).filter((h): h is string => h !== null),
+  ),
+];
+
 /** A preset's JSONC text → its value, or an Error naming the syntax problem. */
 function jsoncOf(text: string, file: string): unknown {
   const parsed = typescript().parseConfigFileTextToJson(file, text);
@@ -314,6 +390,10 @@ const anchorsOf = (
         },
       }));
 
+/** A preset's `portal`, or null when it names none. */
+const portalOf = (p: PresetJson["portal"]): Readonly<VenuePortal> | null =>
+  p === undefined ? null : { kind: p.kind, url: p.url };
+
 /**
  * The text of one preset file → the typed file, or an Error naming every problem. The ONE parser
  * of a preset: the toolchain reads its `tex`, the venue rules its `format`, the config its `rules`.
@@ -331,25 +411,24 @@ export function parsePreset(
   const validate = validatorFor(dir);
   if (!matchesSchema(config, validate))
     throw new Error(
-      `${file} does not match ${SCHEMA_FILE}:\n  ${violations(file, validate).join("\n  ")}`,
+      `${file} does not match ${SCHEMA_FILE}:\n  ${[...identityHints(validate), ...violations(file, validate)].join("\n  ")}`,
     );
   const j = config;
   return {
+    identity: identityOf(j),
     extends: orNull(j.extends),
-    name: orNull(j.name),
     template: orNull(j.template),
+    templateForbids: j.template_forbids ?? [],
     aliases: j.aliases ?? [],
     blind: orNull(j.blind),
+    mentions: orNull(j.mentions),
     requiredSections: sectionsOf(j.required_sections),
     tex: texOf(j.tex),
     format: formatOf(j.format),
     rules: j.rules ?? {},
     registerAnchors: anchorsOf(j.register),
     talk: j.talk === undefined ? null : venueTalkOf(j.talk),
-    portal:
-      j.portal === undefined
-        ? null
-        : { kind: j.portal.kind, url: j.portal.url },
+    portal: portalOf(j.portal),
   };
 }
 

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

@@ -20,6 +20,7 @@ import {
 } from "./tex-venue-rules.ts";
 import { resolvePreset } from "./presets.ts";
 import { buildConfig, SHIPPED_RULES } from "./cli.ts";
+import { venuePreset } from "../test/support.ts";
 
 const VENUES = presetsDir();
 const PAPER = "/work/papers/p";
@@ -136,13 +137,13 @@ describe("tex/template — the class and every option the preset names", () => {
       "[conference]{IEEEtran} — compsoc missing",
       "\\documentclass[conference]{IEEEtran}",
       ["tex/template:missingOption"],
-      /the class option `compsoc` is missing: aidc requires `\\documentclass\[conference,compsoc\]\{IEEEtran\}`/,
+      /the class option `compsoc` is missing: AIDC requires `\\documentclass\[conference,compsoc\]\{IEEEtran\}`/,
     ],
     [
       "{acmart} under an IEEE preset",
       "\\documentclass[sigconf]{acmart}",
       ["tex/template:wrongClass"],
-      /the class is `acmart`, and aidc requires/,
+      /the class is `acmart`, and AIDC requires/,
     ],
     [
       "[journal,compsoc]{IEEEtran} — conference missing",
@@ -183,7 +184,7 @@ describe("tex/template — the class line's states: missing, empty, commented ou
     expect(ids(fs)).toEqual(["tex/template:emptyClass"]);
     expect(fs[0]?.line).toBe(2);
     expect(fs[0]?.message).toBe(
-      "the \\documentclass names no class; aidc requires `\\documentclass[conference,compsoc]{IEEEtran}`",
+      "the \\documentclass names no class; AIDC requires `\\documentclass[conference,compsoc]{IEEEtran}`",
     );
   });
 
@@ -258,7 +259,7 @@ describe("tex/template — several \\documentclass lines behind a TeX switch", (
     // Line 4: the first candidate, after the comment, `\\def` and `\\if` lines.
     expect(fs[0]?.line).toBe(4);
     expect(fs[0]?.message).toBe(
-      "none of the 2 \\documentclass lines is `\\documentclass[conference,compsoc]{IEEEtran}`, which aidc requires: `\\documentclass{article}`, `\\documentclass[conference]{IEEEtran}`. The source picks one behind a TeX switch, which is not evaluated; make one of them the venue's",
+      "none of the 2 \\documentclass lines is `\\documentclass[conference,compsoc]{IEEEtran}`, which AIDC requires: `\\documentclass{article}`, `\\documentclass[conference]{IEEEtran}`. The source picks one behind a TeX switch, which is not evaluated; make one of them the venue's",
     );
   });
 
@@ -309,13 +310,131 @@ describe("tex/template — a project's own preset, and nothing to judge", () =>
         paper("\\documentclass{whatever}"),
         { extends: "./own.jsonc" },
         {
-          extra: { [own]: JSON.stringify({ tex: { packages: { x: ["x"] } } }) },
+          extra: {
+            [own]: JSON.stringify({
+              type: "family",
+              tex: { packages: { x: ["x"] } },
+            }),
+          },
         },
       ),
     ).toEqual([]);
   });
 });
 
+/** A project's own venue on IEEEtran's conference class that forbids the two compsoc options. */
+const forbidding = (body: Record<string, unknown> = {}) => ({
+  [`${PAPER}/own.jsonc`]: JSON.stringify(
+    venuePreset("Own", {
+      extends: "paperlint:ieee-conference",
+      template: "\\documentclass[10pt,conference]{IEEEtran}",
+      template_forbids: ["compsoc", "compsocconf"],
+      ...body,
+    }),
+  ),
+});
+
+describe("tex/template — class options the preset forbids (`template_forbids`)", () => {
+  const judge = (cls: string, extra = forbidding()) =>
+    lint(paper(cls, "Text."), { extends: "./own.jsonc" }, { extra });
+
+  it("the template's own line passes, and so does an extra option the preset does not forbid", () => {
+    expect(judge("\\documentclass[10pt,conference]{IEEEtran}")).toEqual([]);
+    expect(
+      judge("\\documentclass[10pt,conference,letterpaper]{IEEEtran}"),
+    ).toEqual([]);
+  });
+
+  it("🔴 a forbidden option is reported at the class line, naming it and the venue's line", () => {
+    const fs = judge("\\documentclass[10pt,conference,compsoc]{IEEEtran}");
+    expect(ids(fs)).toEqual(["tex/template:forbiddenOption"]);
+    expect(fs[0]?.message).toBe(
+      "the class option `compsoc` is forbidden: Own requires `\\documentclass[10pt,conference]{IEEEtran}` without `compsoc`, `compsocconf`",
+    );
+    expect(fs[0]?.line).toBe(2);
+  });
+
+  it("each forbidden option is one finding, beside a missing one", () => {
+    expect(
+      ids(judge("\\documentclass[compsoc,compsocconf,conference]{IEEEtran}")),
+    ).toEqual([
+      "tex/template:forbiddenOption",
+      "tex/template:forbiddenOption",
+      "tex/template:missingOption",
+    ]);
+  });
+});
+
+describe("tex/template under paperlint:msr — `[10pt,conference]`, without compsoc or compsocconf", () => {
+  const MSR = { extends: "paperlint:msr", kind: "technical" };
+
+  it("the class line MSR's call names passes", () => {
+    expect(
+      lint(paper("\\documentclass[10pt,conference]{IEEEtran}", "Text."), MSR),
+    ).toEqual([]);
+  });
+
+  it.each([["compsoc"], ["compsocconf"]])(
+    "🔴 `%s` in the class options fails tex/template",
+    (option) => {
+      const fs = lint(
+        paper(`\\documentclass[10pt,conference,${option}]{IEEEtran}`, "Text."),
+        MSR,
+      );
+      expect(ids(fs)).toEqual(["tex/template:forbiddenOption"]);
+      expect(fs[0]?.message).toMatch(
+        `the class option \`${option}\` is forbidden: MSR requires`,
+      );
+    },
+  );
+
+  it("AIDC's class line fails MSR on both counts: compsoc forbidden, 10pt missing", () => {
+    expect(ids(lint(OFFICIAL, MSR))).toEqual([
+      "tex/template:forbiddenOption",
+      "tex/template:missingOption",
+    ]);
+  });
+});
+
+describe("tex/template — forbidden options behind a switch, and down a chain", () => {
+  it("behind a TeX switch, a candidate with a forbidden option is not the venue's class", () => {
+    const two = (a: string, b: string) =>
+      `\\def\\v{1}\n\\if\\v1 ${a} \\fi\n\\if\\v2 ${b} \\fi\n\\begin{document}\nText.\n\\end{document}\n`;
+    const compsoc = "\\documentclass[10pt,conference,compsoc]{IEEEtran}";
+    const opts = { extra: forbidding() };
+    expect(
+      ids(lint(two(compsoc, compsoc), { extends: "./own.jsonc" }, opts)),
+    ).toEqual(["tex/template:noCandidate"]);
+    expect(
+      lint(
+        two(compsoc, "\\documentclass[10pt,conference]{IEEEtran}"),
+        { extends: "./own.jsonc" },
+        opts,
+      ),
+    ).toEqual([]);
+  });
+
+  it("a child's template replaces its parent's, the forbidden options with it", () => {
+    const child = `${PAPER}/child.jsonc`;
+    const extra = {
+      ...forbidding(),
+      [child]: JSON.stringify(
+        venuePreset("Child", {
+          extends: "./own.jsonc",
+          template: "\\documentclass[conference]{IEEEtran}",
+        }),
+      ),
+    };
+    expect(
+      lint(
+        paper("\\documentclass[conference,compsoc]{IEEEtran}", "Text."),
+        { extends: "./child.jsonc" },
+        { extra },
+      ),
+    ).toEqual([]);
+  });
+});
+
 describe("tex/template — a template the reader cannot read, a bare class name, nothing to judge", () => {
   it("a template the reader cannot read is said once, naming its file — the class is not judged", () => {
     const own = `${PAPER}/own.jsonc`;
@@ -325,6 +444,7 @@ describe("tex/template — a template the reader cannot read, a bare class name,
       {
         extra: {
           [own]: JSON.stringify({
+            type: "family",
             template: "\\documentclass[a]{}",
             tex: { packages: { x: ["x"] } },
           }),
@@ -341,6 +461,7 @@ describe("tex/template — a template the reader cannot read, a bare class name,
     const own = `${PAPER}/own.jsonc`;
     const extra = {
       [own]: JSON.stringify({
+        type: "family",
         template: "article",
         tex: { packages: { x: ["x"] } },
       }),
@@ -353,7 +474,9 @@ describe("tex/template — a template the reader cannot read, a bare class name,
       ids(lint(paper("\\documentclass{report}"), settings, { extra })),
     ).toEqual(["tex/template:wrongClass"]);
   });
+});
 
+describe("tex/template — nothing to judge", () => {
   it.each<[string, object | undefined, string]>([
     ["no paperlint.json", undefined, `${PAPER}/paper.tex`],
     [
@@ -428,7 +551,7 @@ describe("tex/required-section — what fails", () => {
     const fs = required(lint(tex, AIDC));
     expect(ids(fs)).toEqual(["tex/required-section:missing"]);
     expect(fs[0]?.message).toBe(
-      "aidc requires a section titled «LLM Usage Statement» and there is none — add `\\section*{LLM Usage Statement}` (the title exactly; a bold paragraph does not count)",
+      "AIDC requires a section titled «LLM Usage Statement» and there is none — add `\\section*{LLM Usage Statement}` (the title exactly; a bold paragraph does not count)",
     );
     // At `\end{document}`, where the section would go.
     expect(fs[0]?.line).toBe(tex.split("\n").indexOf("\\end{document}") + 1);
@@ -503,10 +626,12 @@ describe("tex/required-section — the edges", () => {
   it("a position other than last (none): anywhere will do; a child's list replaces its parent's", () => {
     const own = `${PAPER}/own.jsonc`;
     const extra = {
-      [own]: JSON.stringify({
-        extends: "paperlint:aidc",
-        required_sections: [{ title: "Ethics" }],
-      }),
+      [own]: JSON.stringify(
+        venuePreset("own", {
+          extends: "paperlint:aidc",
+          required_sections: [{ title: "Ethics" }],
+        }),
+      ),
     };
     const settings = { extends: "./own.jsonc", kind: "regular" };
     expect(
@@ -528,8 +653,8 @@ describe("tex/venue-leftover — another venue named in the text", () => {
     const tex = aidcPaper(`${INSTITUTION}\n${BODY}${STATEMENT}`);
     const fs = leftovers(lint(tex, AIDC));
     expect(fs.map((f) => f.message)).toEqual([
-      "«AISec» names aisec, and this paper extends aidc — a leftover from an earlier submission? A reviewer reads it before the abstract. Comments and citation keys are not reported; a sentence that names the other venue on purpose can keep it with a disable directive",
-      expect.stringContaining("«ACM CCS» names aisec"),
+      "«AISec» names AISec, and this paper extends AIDC — a leftover from an earlier submission? A reviewer reads it before the abstract. Comments and citation keys are not reported; a sentence that names the other venue on purpose can keep it with a disable directive",
+      expect.stringContaining("«ACM CCS» names AISec"),
     ]);
     const line = tex.split("\n").indexOf(INSTITUTION) + 1;
     expect(fs.map((f) => f.line)).toEqual([line, line]);
@@ -568,6 +693,53 @@ describe("tex/venue-leftover — another venue named in the text", () => {
   });
 });
 
+describe("tex/venue-leftover — MSR, a name that is also an acronym, counts only with a year (`mentions`)", () => {
+  const under = (text: string) =>
+    leftovers(lint(aidcPaper(`${text}\n${BODY}${STATEMENT}`), AIDC));
+
+  it.each([
+    [
+      "an acronym the paper defines",
+      "We score it by Manual Speech Recognition (MSR), and MSR scores rise.",
+    ],
+    [
+      "Microsoft Research",
+      "Researchers at Microsoft Research (MSR) built it, and MSR released it.",
+    ],
+    [
+      "a citation of an MSR paper: the key, and the entry in the bibliography",
+      "As shown~\\cite{msr2024}.\n\\begin{thebibliography}{1}\\bibitem{msr2024} A. Author, ``Mining,'' in \\emph{Proc. MSR 2024}, 2024.\\end{thebibliography}",
+    ],
+    ["a year that is not beside the name", "MSR, in 2027, scored best."],
+  ])("silent: %s", (_, text) => {
+    expect(under(text)).toEqual([]);
+  });
+
+  it.each([
+    ["First written for MSR 2027.", "MSR"],
+    ["A version appeared as MSR'27 work.", "MSR"],
+    ["Submitted to MSR~2027.", "MSR"],
+  ])("🔴 reported: «%s»", (text, name) => {
+    const fs = under(text);
+    expect(fs.map((f) => f.message)).toEqual([
+      expect.stringMatching(
+        new RegExp(`^«${name}» names MSR, and this paper extends AIDC`),
+      ),
+    ]);
+    expect(fs[0]?.line).toBe(4);
+  });
+
+  it("under msr itself, its own name with a year is never a leftover", () => {
+    const tex = paper(
+      "\\documentclass[10pt,conference]{IEEEtran}",
+      "First written for MSR 2027.",
+    );
+    expect(
+      leftovers(lint(tex, { extends: "paperlint:msr", kind: "technical" })),
+    ).toEqual([]);
+  });
+});
+
 describe("tex/venue-leftover — a URL is not text, a definition body is", () => {
   it("\\href: a name in the URL is not reported, a name in the link text is", () => {
     const inUrl = aidcPaper(
@@ -591,7 +763,7 @@ describe("tex/venue-leftover — a URL is not text, a definition body is", () =>
       );
       const fs = leftovers(lint(tex, AIDC));
       expect(fs.map((f) => [f.line, f.message.slice(0, 16)])).toEqual([
-        [4, "«AISec» names ai"],
+        [4, "«AISec» names AI"],
       ]);
     },
   );
@@ -622,11 +794,12 @@ describe("tex/venue-leftover — where names are found, and whose they are", ()
   it("a name a venue shares with this paper's own chain is not a leftover", () => {
     const own = `${PAPER}/own.jsonc`;
     const extra = {
-      [own]: JSON.stringify({
-        extends: "paperlint:aidc",
-        name: "AIDC 2027",
-        aliases: ["ACM CCS"],
-      }),
+      [own]: JSON.stringify(
+        venuePreset("AIDC 2027", {
+          extends: "paperlint:aidc",
+          aliases: ["ACM CCS"],
+        }),
+      ),
     };
     const tex = aidcPaper(`ACM CCS and AIDC 2027.\n${BODY}${STATEMENT}`);
     expect(
@@ -721,8 +894,9 @@ describe("otherVenues", () => {
     if (!aidc.ok) return;
     expect(otherVenues(aidc.value, deps).map((o) => o.label)).toEqual([
       "acm-sigconf",
-      "agenticdev",
-      "aisec",
+      "AgenticDev",
+      "AISec",
+      "MSR",
     ]);
   });
 });
@@ -790,7 +964,7 @@ describe("format/layout-override reports", () => {
       [13, "\\newgeometry"],
     ]);
     expect(overrides(tex)[0]?.message).toBe(
-      "`\\usepackage{geometry}` changes the page layout aidc's template sets (`\\documentclass[conference,compsoc]{IEEEtran}`) — a desk-reject reason at venues that check the format. Remove it; if the venue allows it, disable this line with a comment saying so",
+      "`\\usepackage{geometry}` changes the page layout AIDC's template sets (`\\documentclass[conference,compsoc]{IEEEtran}`) — a desk-reject reason at venues that check the format. Remove it; if the venue allows it, disable this line with a comment saying so",
     );
   });
   it("a definition's body counts: the length it sets is set wherever it is used", () => {
@@ -834,6 +1008,7 @@ describe("format/layout-override stays silent", () => {
     expect(overrides(tex, { extends: null })).toEqual([]);
     const house = {
       [`${PAPER}/house.jsonc`]: JSON.stringify({
+        type: "family",
         tex: { packages: { ieeetran: ["IEEEtran.cls"] } },
       }),
     };