paperlint 7.0.0 → 7.1.0

package/src/preset-card-rule.test.ts

@@ -91,6 +91,7 @@ describe("the shipped cards", () => {
       "aidc.md",
       "aisec.md",
       "ieee-conference.md",
+      "msr.md",
       "realm.md",
       "tex-base.md",
     ]);

package/src/presets.test.ts

@@ -63,6 +63,7 @@ describe("shipped presets", () => {
     expect(r.value.template).toEqual({
       text: "\\documentclass[sigconf]{acmart}",
       file: join(VENUES, "acm-sigconf.jsonc"),
+      forbids: [],
     });
     expect("acmart" in r.value.tex.packages).toBe(true);
     // The label is the venue's own name, from its file's `name`; the id stays the file name — the
@@ -75,7 +76,40 @@ describe("shipped presets", () => {
       url: "https://conf.researchr.org/home/ase-2026/agenticdev-2026",
     });
   });
+});
+
+describe("shipped presets: paperlint:msr", () => {
+  it("paperlint:msr → msr over ieee-conference: one kind, appendices counted as body, compsoc forbidden", () => {
+    const r = resolve("paperlint:msr");
+    expect(r.ok).toBe(true);
+    if (!r.ok) return;
+    expect(r.value.chain.map((f) => f.split("/").pop())).toEqual([
+      "ieee-conference.jsonc",
+      "msr.jsonc",
+    ]);
+    expect([...r.value.format.kinds]).toEqual([
+      ["technical", { bodyPagesMax: 10, refPagesMax: 2 }],
+    ]);
+    expect(r.value.format.bodyEndsAt).toBe("references");
+    expect(r.value.format.appendixInBody).toBe(true);
+    expect(r.value.format.pageWidthIn).toBe(8.5);
+    expect(r.value.template).toEqual({
+      text: "\\documentclass[10pt,conference]{IEEEtran}",
+      file: join(VENUES, "msr.jsonc"),
+      forbids: ["compsoc", "compsocconf"],
+    });
+    expect(r.value.blind).toBe(true);
+    expect(r.value.portal).toEqual({
+      kind: "hotcrp",
+      url: "https://msr2027.hotcrp.com",
+    });
+    // No rule turned on: the IEEE capitalization rule has not been read and quoted.
+    expect(r.value.rules).toEqual({});
+    expect(r.value.registerAnchors).toEqual([]);
+  });
+});
 
+describe("shipped presets: a family, and a venue that stands alone", () => {
   it("a paper may extend a family directly: format and fonts, and no kinds", () => {
     const r = resolve("paperlint:acm-sigconf");
     expect(r.ok && r.value.format.kinds.size).toBe(0);
@@ -139,6 +173,11 @@ describe("what each shipped preset declares itself to be", () => {
         url: "https://aisec.cc/",
       },
       "ieee-conference.jsonc": { type: "family" },
+      "msr.jsonc": {
+        type: "venue",
+        name: "MSR",
+        url: "https://2027.msrconf.org/track/msr-2027-technical-papers",
+      },
       "realm.jsonc": {
         type: "venue",
         name: "REALM",
@@ -300,7 +339,7 @@ describe("what does not resolve, and says why", () => {
       "a shipped name with a typo",
       "paperlint:agenticdve",
       "not-found",
-      /acm-sigconf, agenticdev, aidc, aisec, ieee-conference, realm/,
+      /acm-sigconf, agenticdev, aidc, aisec, ieee-conference, msr, realm/,
     ],
     ["the base TeX set", "paperlint:tex-base", "not-found", /agenticdev/],
     [
@@ -422,8 +461,32 @@ describe("a preset's template: kept as its file spells it, with that file", () =
     expect(r.ok && r.value.template).toEqual({
       text: "\\documentclass[conference]{IEEEtran}",
       file: "/work/papers/p/own.jsonc",
+      forbids: [],
     });
   });
+
+  it("the options a file forbids travel with its template", () => {
+    const r = resolve("./own.jsonc", {
+      "/work/papers/p/own.jsonc": venue({
+        extends: "paperlint:ieee-conference",
+        template: "\\documentclass[conference]{IEEEtran}",
+        template_forbids: ["compsoc"],
+      }),
+    });
+    expect(r.ok && r.value.template?.forbids).toEqual(["compsoc"]);
+  });
+
+  it("forbidden options without a template of the same file are refused by the schema", () => {
+    const r = resolve("./own.jsonc", {
+      "/work/papers/p/own.jsonc": venue({
+        extends: "paperlint:aidc",
+        template_forbids: ["compsoc"],
+      }),
+    });
+    expect(r.ok).toBe(false);
+    if (r.ok) return;
+    expect(presetProblemText(r.error)).toMatch(/template_forbids/);
+  });
 });
 
 describe("labelOf — display only, never used to resolve", () => {
@@ -448,6 +511,7 @@ describe("shippedVenueNames — what each shipped venue is called", () => {
       "AIDC",
       "AISec",
       "ieee-conference",
+      "MSR",
       "REALM",
     ]);
     expect(names.find((n) => n.label === "AISec")?.aliases).toEqual(
@@ -469,6 +533,7 @@ describe("shippedVenueNames — what each shipped venue is called", () => {
       "AIDC",
       "AISec",
       "ieee-conference",
+      "MSR",
     ]);
   });
 });

package/src/presets.ts

@@ -25,7 +25,7 @@
  *   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; `ruleOrigins` keeps which file set each
- *   template   the child wins; so does `name`, and `required_sections`, `register`, `talk` and
+ *   template   the child wins, with its `template_forbids`; 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
  *
@@ -75,10 +75,12 @@ export interface PresetDeps {
   readonly venuesDir: string;
 }
 
-/** A preset's `template`, as its file spells it. */
+/** A preset's `template`, as its file spells it, and the class options that file forbids. */
 export interface PresetTemplate {
   readonly text: string;
   readonly file: string;
+  /** `template_forbids` of the same file: options the paper's class line must not carry. */
+  readonly forbids: readonly string[];
 }
 
 /** A resolved chain, merged. */
@@ -104,6 +106,11 @@ export interface Preset {
   readonly aliases: readonly string[];
   /** Whether the venue reviews double-blind (`anonymity/identity`); false when no file of the chain says. */
   readonly blind: boolean;
+  /**
+   * When the venue's names count as a mention in a paper's text (`tex/venue-leftover`): `any`
+   * whole-word use, or `with-year` beside it; `any` when no file of the chain says.
+   */
+  readonly mentions: "any" | "with-year";
   readonly requiredSections: readonly RequiredSection[];
   readonly tex: TexRequirements;
   readonly format: VenueFormat;
@@ -254,6 +261,7 @@ export function mergeFormat(
     fontsText: pick("fontsText"),
     fontsTitle: pick("fontsTitle"),
     bodyEndsAt: pick("bodyEndsAt"),
+    appendixInBody: pick("appendixInBody"),
     kinds: new Map([...parent.kinds, ...child.kinds]),
   };
 }
@@ -276,6 +284,7 @@ const NOTHING_MERGED: Merging = {
   template: null,
   aliases: [],
   blind: false,
+  mentions: "any",
   requiredSections: [],
   tex: NO_REQUIREMENTS,
   format: NO_FORMAT,
@@ -292,9 +301,13 @@ const mergeOne = (
   { 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 },
+  template:
+    p.template === null
+      ? acc.template
+      : { text: p.template, file, forbids: p.templateForbids },
   aliases: [...new Set([...acc.aliases, ...namesOf(p.identity), ...p.aliases])],
   blind: p.blind ?? acc.blind,
+  mentions: p.mentions ?? acc.mentions,
   requiredSections: p.requiredSections ?? acc.requiredSections,
   tex: p.tex ? mergeRequirements(acc.tex, p.tex) : acc.tex,
   format: mergeFormat(acc.format, p.format),
@@ -368,17 +381,21 @@ export function resolveShipped(deps: PresetDeps): readonly Preset[] {
 }
 
 /** A shipped venue as a name knows it, and the files of its chain: what tells it from a paper's own. */
-export type ShippedVenue = Pick<Preset, "label" | "aliases" | "chain">;
+export type ShippedVenue = Pick<
+  Preset,
+  "label" | "aliases" | "chain" | "mentions"
+>;
 
 /**
  * A resolved preset as a name knows it: its label, its aliases, its chain. Pure. (Not Remeda's
  * `pick`: the app layer may not import it — `boundaries/dependencies`, `APP_EXTERNALS`.)
  */
-export const venueOf = ({ label, aliases, chain }: Preset): ShippedVenue => ({
+export const venueOf = ({
   label,
   aliases,
   chain,
-});
+  mentions,
+}: Preset): ShippedVenue => ({ label, aliases, chain, mentions });
 
 /**
  * THE ONE SOURCE OF VENUE NAMES: every shipped venue's label and `aliases` (with each `name` along

package/src/submission.test.ts

@@ -117,6 +117,10 @@ const fakePortal = (answers: {
   return { seen, portalFor };
 };
 
+/** The line `update` prints before it sends `pdf`, naming `call`. */
+const CHECK = (pdf: string, call: string): string =>
+  `before you rely on it, open ${pdf} yourself and check it against ${call}: the page count and what counts toward the limit, the template and its class options, anonymity, and that every figure, table and reference renders — paperlint passing is not the venue accepting the format`;
+
 const ARGS: SubmissionArgs = {
   sub: "show",
   paperDir: "papers/p",
@@ -287,6 +291,7 @@ test("update: a dry run by default — the paper's PDF sent, nothing saved, exit
     ],
   ]);
   assert.deepEqual(r.out, [
+    CHECK("papers/p/paper.pdf", "the call for papers, https://example.org/cfp"),
     "dry run — the portal checked the change and kept nothing; --save sends it for real",
     "HTTP          200",
     "valid         yes",
@@ -322,7 +327,41 @@ test("update --save --submit --abstract --pdf: all of it sent, and said to be sa
       { save: true },
     ],
   ]);
-  assert.equal(r.out[0], "saved");
+  // Guards: the PDF that is sent is the one named, and --save is told to check it too.
+  assert.deepEqual(r.out.slice(0, 2), [
+    CHECK("other.pdf", "the call for papers, https://example.org/cfp"),
+    "saved",
+  ]);
+});
+
+test("🔴 update: the check line names the venue's call from the preset's `url`; a preset that names no venue gets the generic line", async () => {
+  const family = memoryFiles({
+    "/w/package.json": "{}",
+    "/w/house.jsonc": JSON.stringify({
+      type: "family",
+      extends: "paperlint:ieee-conference",
+      portal: { kind: "hotcrp", url: `${SITE}/` },
+    }),
+    [`${PAPER}/paperlint.json`]: JSON.stringify({
+      extends: "../../house.jsonc",
+      submission: { id: 7 },
+    }),
+    [`${PAPER}/paper.pdf`]: PDF,
+  });
+  const r = await run({ sub: "update" }, { files: family });
+  assert.equal(r.code, 0);
+  assert.equal(
+    r.out[0],
+    CHECK("papers/p/paper.pdf", "the venue's call for papers"),
+  );
+});
+
+test("show sends nothing, so it asks for no check", async () => {
+  const r = await run({});
+  assert.equal(
+    r.out.some((l) => l.includes("call for papers")),
+    false,
+  );
 });
 
 test("update: valid:false, or a non-2xx status, exits 1 with the portal's messages", async () => {
@@ -338,7 +377,7 @@ test("update: valid:false, or a non-2xx status, exits 1 with the portal's messag
     { portal: fakePortal({ update: invalid }) },
   );
   assert.equal(r1.code, 1);
-  assert.deepEqual(r1.out.slice(2), [
+  assert.deepEqual(r1.out.slice(3), [
     "valid         NO",
     "changes       —",
     `local PDF     papers/p/paper.pdf sha2-${HEX}`,
@@ -380,7 +419,7 @@ test("update --save that the portal withheld says so", async () => {
     { sub: "update", save: true },
     { portal: fakePortal({ update: withheld }) },
   );
-  assert.equal(r.out[0], "SAVE WITHHELD by the portal — nothing changed");
+  assert.equal(r.out[1], "SAVE WITHHELD by the portal — nothing changed");
 });
 
 test("update: no PDF to send, or no abstract file, is refused before the portal is asked", async () => {

package/src/submission.ts

@@ -80,6 +80,8 @@ export interface SubmissionTarget {
   readonly id: number;
   /** The paper's built PDF, absolute. */
   readonly pdf: string;
+  /** The venue's call for papers (the preset's `url`); null when the preset names no venue. */
+  readonly call: string | null;
 }
 
 const configOf = (dir: string): string => join(dir, CONFIG_FILE);
@@ -109,7 +111,9 @@ export function submissionTarget(
   const portal = supportedPortal(declared);
   if (!portal.ok) return portal;
   const pdf = join(paperDir, p.settings.pdf ?? "paper.pdf");
-  return ok({ portal: portal.value, id: sub.id, pdf });
+  const identity = p.preset.identity;
+  const call = identity.type === "venue" ? identity.url : null;
+  return ok({ portal: portal.value, id: sub.id, pdf, call });
 }
 
 /** The token from the environment, or the line naming the variable and where to get one. */
@@ -182,6 +186,14 @@ export function showLines(
   ];
 }
 
+/**
+ * What `update` says before it sends a PDF, dry run or not: the author opens that file and checks it
+ * against the venue's call. paperlint's checks are an aid; the venue's reading of the PDF is what
+ * counts. Pure.
+ */
+export const checkPdfLine = (shown: string, call: string | null): string =>
+  `before you rely on it, open ${shown} yourself and check it against ${call === null ? "the venue's call for papers" : `the call for papers, ${call}`}: the page count and what counts toward the limit, the template and its class options, anonymity, and that every figure, table and reference renders — paperlint passing is not the venue accepting the format`;
+
 /** `update`'s report. Pure. */
 export function updateLines(
   o: UpdateOutcome,
@@ -243,6 +255,17 @@ function abstractOf(
     : ok(new TextDecoder().decode(bytes).trim());
 }
 
+/** What `update` sends: the PDF's bytes, the abstract's text, and whether to mark it submitted. */
+const changeOf = (
+  a: SubmissionArgs & { readonly pdfPath: string },
+  bytes: Uint8Array,
+  abstract: string | null,
+) => ({
+  pdf: { name: basename(a.pdfPath), bytes },
+  abstract,
+  submit: a.submit,
+});
+
 /** `update`: send the PDF (and the abstract, and "submitted" when asked); a dry run unless saving. */
 async function runUpdate(
   t: SubmissionTarget,
@@ -259,12 +282,10 @@ async function runUpdate(
     );
   const abstract = abstractOf(a, deps);
   if (!abstract.ok) return (deps.err(abstract.error), 2);
-  const change = {
-    pdf: { name: basename(a.pdfPath), bytes },
-    abstract: abstract.value,
-    submit: a.submit,
-  };
-  const r = await portal.update(t.id, change, { save: a.save });
+  deps.log(checkPdfLine(shown, t.call));
+  const r = await portal.update(t.id, changeOf(a, bytes, abstract.value), {
+    save: a.save,
+  });
   if (!r.ok) return (deps.err(failureText(r.error)), 1);
   const local = { shown, sha256: sha256Hex(bytes) };
   updateLines(r.value, local, a.save).forEach((l) => {

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(),
 };
 
@@ -189,10 +195,14 @@ export interface PresetFile {
   readonly extends: 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`). */
@@ -227,6 +237,7 @@ interface FormatJson {
   readonly fonts_text?: string;
   readonly fonts_title?: string;
   readonly body_ends_at?: "references";
+  readonly appendix_in_body?: boolean;
   readonly kinds?: KindsJson;
 }
 
@@ -244,8 +255,10 @@ type PresetJson = PresetBodyJson &
 interface PresetBodyJson {
   readonly extends?: 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";
@@ -292,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),
   };
 }
@@ -376,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`.
@@ -400,18 +418,17 @@ export function parsePreset(
     identity: identityOf(j),
     extends: orNull(j.extends),
     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

@@ -322,6 +322,119 @@ describe("tex/template — a project's own preset, and nothing to judge", () =>
   });
 });
 
+/** 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`;
@@ -580,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(
@@ -736,6 +896,7 @@ describe("otherVenues", () => {
       "acm-sigconf",
       "AgenticDev",
       "AISec",
+      "MSR",
     ]);
   });
 });