paperlint 7.0.0 → 7.2.0

package/src/tex-venue-rules.ts

@@ -3,6 +3,7 @@
  * requires of the LaTeX itself, before any build:
  *
  *   tex/template          error  the `\documentclass` is the preset's class, with every option it names
+ *                                and none it forbids (`template_forbids`)
  *   tex/required-section  error  each section the preset requires is there, titled exactly, and
  *                                where the preset says (`last`: after every section of the body)
  *   tex/venue-leftover    warn   the text a reader sees names ANOTHER shipped venue — its `name`
@@ -51,6 +52,7 @@ import type { PaperSource } from "./domain/paper-source.ts";
 import { readPaper, reportInPaper } from "./tex-paper.ts";
 import type { RequiredSection } from "./tex-requirements.ts";
 import type { Finding, VenueRuleDeps } from "./venue-rules.ts";
+import { isPorting } from "./domain/cycle.ts";
 
 /** A finding and where it points; null points at the top of the file. */
 export interface Located extends Finding {
@@ -107,20 +109,38 @@ type TemplateData = {
   readonly template: string;
 };
 
-/** A class line that names a class, against the template's: the same class, with every option. */
+/** What the template requires of a class line: its class and options, and the options it forbids. */
+interface Wanted {
+  readonly cls: DocumentClass;
+  readonly forbids: readonly string[];
+}
+
+/**
+ * A class line that names a class, against the template's: the same class, with every option, and
+ * none of the options the preset forbids.
+ */
 function judgeClass(
   line: Extract<ClassLine, { readonly kind: "class" }>,
-  want: DocumentClass,
+  want: Wanted,
   data: TemplateData,
 ): readonly Located[] {
   const at = spanOf(line.place);
-  if (line.cls !== want.cls)
+  if (line.cls !== want.cls.cls)
     return [{ messageId: "wrongClass", data: { ...data, got: line.cls }, at }];
-  return missingOptions(line, want).map((option) => ({
-    messageId: "missingOption",
-    data: { ...data, option },
-    at,
-  }));
+  const forbidden = want.forbids.filter((o) => line.options.includes(o));
+  const without = want.forbids.map((o) => `\`${o}\``).join(", ");
+  return [
+    ...forbidden.map((option) => ({
+      messageId: "forbiddenOption",
+      data: { ...data, option, without },
+      at,
+    })),
+    ...missingOptions(line, want.cls).map((option) => ({
+      messageId: "missingOption",
+      data: { ...data, option },
+      at,
+    })),
+  ];
 }
 
 /** A candidate as the message names it: its line, or an empty `\documentclass{}`. */
@@ -133,7 +153,7 @@ const candidateLine = (c: ClassCandidate): string =>
  */
 function judgeCandidates(
   candidates: readonly [ClassCandidate, ...ClassCandidate[]],
-  want: DocumentClass,
+  want: Wanted,
   data: TemplateData,
 ): readonly Located[] {
   const matches = candidates.some(
@@ -150,7 +170,7 @@ function judgeCandidates(
 /** The paper's class line against a template that was read: present, naming a class, that class. */
 function judgeClassLine(
   line: ClassLine,
-  want: DocumentClass,
+  want: Wanted,
   data: TemplateData,
 ): readonly Located[] {
   switch (line.kind) {
@@ -183,7 +203,7 @@ export function judgeTemplate(
     return [{ messageId: "badTemplate", data, at: null }];
   }
   const data = { venue: preset.label, template: documentClassLine(want) };
-  return judgeClassLine(line, want, data);
+  return judgeClassLine(line, { cls: want, forbids: t.forbids }, data);
 }
 
 /** Where a heading starts, or null when the parser gave it no place. */
@@ -248,8 +268,17 @@ export function judgeRequiredSections(
   );
 }
 
-/** Another shipped venue: the word for it, and what it is called in a paper's text. */
-export type OtherVenue = NamedVenue;
+/**
+ * Another shipped venue: the word for it, what it is called in a paper's text, and when a name
+ * counts as naming it (`mentions`).
+ */
+export type OtherVenue = NamedVenue & Pick<Preset, "mentions">;
+
+/**
+ * What must follow a name for it to name a `with-year` venue: a year beside it — `2027`, `'27` or
+ * `’27`, after spaces or none (`~` renders as a space). A lookahead, so the finding is the name.
+ */
+const YEAR_BESIDE = "(?=[\\s\\u00a0]*(?:\\d{4}|['’]\\d{2})(?![\\p{L}\\p{N}]))";
 
 /** `s` as a pattern that matches it literally. */
 const literal = (s: string): string =>
@@ -271,7 +300,7 @@ export function judgeLeftover(
       .map((alias) => ({
         other: o.label,
         re: new RegExp(
-          `(?<![\\p{L}\\p{N}])${literal(alias)}(?![\\p{L}\\p{N}])`,
+          `(?<![\\p{L}\\p{N}])${literal(alias)}(?![\\p{L}\\p{N}])${o.mentions === "with-year" ? YEAR_BESIDE : ""}`,
           "gu",
         ),
       })),
@@ -357,6 +386,8 @@ const RULES: Readonly<
           "the class is `{{got}}`, and {{venue}} requires `{{template}}` — the page size, fonts and layout the venue checks come from the class",
         missingOption:
           "the class option `{{option}}` is missing: {{venue}} requires `{{template}}`",
+        forbiddenOption:
+          "the class option `{{option}}` is forbidden: {{venue}} requires `{{template}}` without {{without}}",
         noCandidate:
           "none of the {{count}} \\documentclass lines is `{{template}}`, which {{venue}} requires: {{candidates}}. The source picks one behind a TeX switch, which is not evaluated; make one of them the venue's",
       },
@@ -442,7 +473,7 @@ export function otherVenues(
 ): readonly OtherVenue[] {
   return shippedVenueNames(deps)
     .filter((v) => !v.chain.every((f) => preset.chain.includes(f)))
-    .map(({ label, aliases }) => ({ label, aliases }));
+    .map(({ label, aliases, mentions }) => ({ label, aliases, mentions }));
 }
 
 /** What the venue-conformance rules are built with: the preset store, and the LaTeX reader. */
@@ -463,6 +494,10 @@ function readingOf(
   const dir = dirname(filename);
   const p = paperPreset(dir, deps);
   if (p.kind !== "resolved") return null;
+  // The port to this venue's template is declared open work: the class line is the previous
+  // venue's by declaration, and `cycle/port-done` watches that declaration.
+  if (p.settings.cycles !== null && isPorting(p.settings.cycles.current))
+    return null;
   const preset = p.preset;
   const others = () => otherVenues(preset, deps);
   const paper = readPaper(filename, src, deps);
@@ -508,3 +543,83 @@ export function formatRules(
 ): Readonly<Record<"layout-override", TexRuleModule>> {
   return { "layout-override": rule("layout-override", deps) };
 }
+
+// ── cycle/port-done: the declared port is finished ───────────────────────────────────────
+
+/**
+ * `cycle/port-done` (error): the current cycle declares `"phase": "porting"`, and the paper's
+ * `\documentclass` is already the venue's template. The declaration silences every venue rule
+ * (`src/venue-rules.ts`, `readingOf` above); once the class line is the venue's, the port is done
+ * and the declaration is stale — this is the other half that keeps `porting` from being a mute
+ * button. Silent when the preset names no template: there is nothing to compare, as for `tex/template`.
+ */
+export function judgePortDone(
+  r: Pick<Reading, "src" | "latex" | "preset">,
+  cycleId: string,
+): readonly Located[] {
+  if (r.preset.template === null) return [];
+  const mismatch = judgeTemplate(
+    r.latex.documentClass(r.src),
+    r.preset,
+    r.latex,
+  );
+  return mismatch.length > 0
+    ? []
+    : [
+        {
+          messageId: "done",
+          data: {
+            venue: r.preset.label,
+            template: r.preset.template.text,
+            id: cycleId,
+          },
+          at: null,
+        },
+      ];
+}
+
+const PORT_DONE_META: TexRuleModule["meta"] = {
+  type: "problem",
+  docs: {
+    description:
+      "the current cycle still says `porting` while the \\documentclass is already the venue's template — the port is done, drop the phase",
+    url: "https://github.com/zernie/paperlint/blob/main/docs/rules/cycle/port-done.md",
+  },
+  schema: [],
+  messages: {
+    done: 'the \\documentclass is already `{{template}}`, which {{venue}} requires, and the cycle «{{id}}» still declares "phase": "porting" — the port is done: remove the phase, so the venue\'s format rules judge this paper again',
+  },
+};
+
+/** The `cycle` plugin's rule over the source, for every `paper.tex`. */
+export function cyclePortRules(
+  deps: TexVenueRuleDeps,
+): Readonly<Record<"port-done", TexRuleModule>> {
+  return {
+    "port-done": {
+      meta: PORT_DONE_META,
+      create(context) {
+        if (basename(context.filename) !== "paper.tex") return {};
+        return {
+          root() {
+            const p = paperPreset(dirname(context.filename), deps);
+            if (p.kind !== "resolved") return;
+            const current = p.settings.cycles?.current;
+            if (current?.kind !== "cycle" || !isPorting(current)) return;
+            const sc = context.sourceCode;
+            const paper = readPaper(context.filename, sc.raw ?? sc.text, deps);
+            const found = judgePortDone(
+              { src: paper.text, latex: deps.latex, preset: p.preset },
+              current.cycle.id,
+            );
+            reportInPaper(context, PORT_DONE_META.messages, paper, found);
+          },
+        };
+      },
+    },
+  };
+}
+
+export const CYCLE_PORT_RULE_LEVELS: Readonly<
+  Record<"cycle/port-done", "error">
+> = { "cycle/port-done": "error" };

package/src/venue-rules.test.ts

@@ -231,6 +231,36 @@ describe("a paper that names no venue", () => {
       lint({ venue: DECL, facts: null }, `${PAPER}/PIPELINE-STATUS.md`),
     ).toEqual([]);
   });
+
+  it.each([
+    [
+      "a named venue",
+      {
+        id: "secdev-2027",
+        venue: { kind: "named", name: "SecDev 2027", url: "https://x.example" },
+        opened: "2027-01-10",
+      },
+    ],
+    [
+      "the last cycle closed, none open",
+      {
+        id: "first-2026",
+        venue: { kind: "preset", extends: "paperlint:aisec" },
+        opened: "2026-07-01",
+        outcome: { kind: "withdrawn", date: "2026-07-18", evidence: "n.md" },
+      },
+    ],
+  ])(
+    "with `cycles` and %s: the warning says to set the venue IN THE CYCLE — `extends` beside `cycles` is refused",
+    (_, cycle) => {
+      const fs = lint({ venue: { cycles: [cycle] }, facts: null, pdf: null });
+      expect(ids(fs)).toEqual(["pdf/measured:noPresetCycle"]);
+      expect(fs[0]?.message).toMatch(
+        /^this paper's current cycle names no venue preset, so its page limit, fonts and format are not checked — set the venue in the current cycle in .*paperlint\.json \("venue": \{ "kind": "preset", "extends": "paperlint:…" \}\), or open a new cycle when the last one has ended$/,
+      );
+      expect(fs[0]?.message).not.toMatch(/set "extends"/);
+    },
+  );
 });
 
 describe("pdf/profile — the declaration must resolve, or nothing is judged", () => {
@@ -239,13 +269,13 @@ describe("pdf/profile — the declaration must resolve, or nothing is judged", (
       "an unknown venue (a typo would silently disable every check)",
       { extends: "paperlint:agentic-dev", kind: "short" },
       "preset",
-      /agenticdev, aidc, aisec, ieee-conference, realm/,
+      /agenticdev, aidc, aisec, ieee-conference, msr, realm/,
     ],
     [
       "the base TeX set is not a venue",
       { extends: "paperlint:tex-base" },
       "preset",
-      /agenticdev, aidc, aisec, ieee-conference, realm/,
+      /agenticdev, aidc, aisec, ieee-conference, msr, realm/,
     ],
     [
       "paperlint.json that is not JSON",
@@ -863,6 +893,177 @@ describe("format/page-limit on AIDC: the two signals of where the references sta
   });
 });
 
+/**
+ * A project's own venue that counts its appendices in the body (`appendix_in_body`): a body of ten
+ * pages, appendices included, and two pages holding only references — MSR's rule.
+ */
+const OWN_APPENDIX_IN_BODY = {
+  [`${PAPER}/own.jsonc`]: JSON.stringify({
+    type: "venue",
+    name: "Own",
+    url: "https://example.org/cfp",
+    extends: "paperlint:ieee-conference",
+    format: {
+      body_ends_at: "references",
+      appendix_in_body: true,
+      kinds: {
+        technical: { body_pages_max: 10, ref_pages_max: 2 },
+        open: {},
+        refs: { ref_pages_max: 2 },
+      },
+    },
+  }),
+};
+
+/** `own.jsonc` papers of the kind named, over IEEE facts with `pages` and the two anchors. */
+const ownSplit = (
+  pages: readonly string[],
+  bib: number | null,
+  appendix: number | null,
+  kind = "technical",
+) =>
+  lint({
+    venue: { extends: "./own.jsonc", kind },
+    extra: OWN_APPENDIX_IN_BODY,
+    facts: ieeeFacts((f) => {
+      f.pages_text = [...pages];
+      f.bib_anchor_page = bib;
+      f.appendix_anchor_page = appendix;
+      // banal's counts, which this counting replaces: neither is judged.
+      f.body_pages = 99;
+      f.ref_pages = 99;
+    }),
+  });
+
+describe("format/page-limit with `appendix_in_body`: the appendix is body, the reference pages hold only references", () => {
+  const REFS = ["the end\nReferences\n[1] A.\n", "[2] B.\n", "[3] C.\n"];
+
+  it("ten pages of body and two of references pass; banal's counts are not judged", () => {
+    expect(ownSplit([...bodyPages(9), ...REFS], 10, null)).toEqual([]);
+  });
+
+  it("🔴 an appendix after the references that brings the body to eleven fails, naming where it starts", () => {
+    const fs = ownSplit(
+      [...bodyPages(9), ...REFS.slice(0, 2), "Appendix A.\nDetails\n"],
+      10,
+      12,
+    );
+    expect(fs.map((f) => f.message)).toEqual([
+      "body pages (up to the references on page 10, and the appendix from page 12): 11, over the limit 10 for Own/technical — a desk reject; cut the text",
+    ]);
+  });
+
+  it("🔴 three pages holding only references fail", () => {
+    const fs = ownSplit([...bodyPages(9), ...REFS, "[4] D.\n"], 10, null);
+    expect(fs.map((f) => f.message)).toEqual([
+      "pages holding only references: 3, over the limit 2 for Own/technical — a desk reject; cut the text",
+    ]);
+  });
+
+  it("an eleventh page of body before the references fails, appendices included", () => {
+    expect(ids(ownSplit([...bodyPages(10), ...REFS], 11, null))).toEqual([
+      "format/page-limit:pages",
+    ]);
+  });
+
+  it.each<
+    [string, readonly string[], readonly [number | null, number | null], string]
+  >([
+    [
+      "no references heading",
+      bodyPages(3),
+      [null, null],
+      "format/page-limit:noReferences",
+    ],
+    [
+      "an appendix anchor on a page with no «Appendix» line",
+      [...bodyPages(3), ...REFS],
+      [4, 6],
+      "format/page-limit:unclear",
+    ],
+  ])("%s: said, not counted", (_, pages, [bib, appendix], want) => {
+    expect(ids(ownSplit(pages, bib, appendix))).toEqual([want]);
+  });
+
+  it("a kind with no limits judges nothing; one with a reference limit only judges that", () => {
+    expect(ownSplit(bodyPages(3), null, null, "open")).toEqual([]);
+    expect(
+      ids(ownSplit([...bodyPages(12), ...REFS, "[4] D.\n"], 13, null, "refs")),
+    ).toEqual(["format/page-limit:pages"]);
+  });
+});
+
+/** An MSR technical paper that declares who wrote it. */
+const MSR = {
+  extends: "paperlint:msr",
+  kind: "technical",
+  identity: ["Ada Example"],
+};
+
+/** MSR facts: `pages` as the PDF's text, the two anchors where hyperref put them. */
+const msrFacts = (
+  pages: readonly string[],
+  bib: number,
+  appendix: number | null = null,
+) =>
+  ieeeFacts((f) => {
+    f.pages_text = [...pages];
+    f.bib_anchor_page = bib;
+    f.appendix_anchor_page = appendix;
+  });
+
+/** References that start below the last body text on their page, then `more` pages of them. */
+const refsFrom = (more: number): string[] => [
+  "the last lines of the conclusion\nR EFERENCES\n[1] D. E. Knuth.\n",
+  ...Array.from({ length: more }, (_, i) => `[${String(i + 2)}] More.\n`),
+];
+
+describe("format/page-limit on MSR: ten pages of main text, appendices included, and two of only references", () => {
+  it("🔴 ten pages of body, the references starting on the tenth, and two pages of only references pass", () => {
+    expect(
+      lint({
+        venue: MSR,
+        facts: msrFacts([...bodyPages(9), ...refsFrom(2)], 10),
+      }),
+    ).toEqual([]);
+  });
+
+  it("🔴 eleven pages of body fail", () => {
+    const fs = lint({
+      venue: MSR,
+      facts: msrFacts([...bodyPages(10), ...refsFrom(2)], 11),
+    });
+    expect(fs.map((f) => f.message)).toEqual([
+      "body pages (up to the references on page 11, appendices included): 11, over the limit 10 for MSR/technical — a desk reject; cut the text",
+    ]);
+  });
+
+  it("🔴 an appendix before the references that brings the body to eleven fails", () => {
+    const pages = [...bodyPages(9), "Appendix A.\nDetails\n", ...refsFrom(2)];
+    expect(ids(lint({ venue: MSR, facts: msrFacts(pages, 11, 10) }))).toEqual([
+      "format/page-limit:pages",
+    ]);
+  });
+
+  it("🔴 an appendix after the references that brings the body to eleven fails", () => {
+    const pages = [...bodyPages(9), ...refsFrom(1), "Appendix A.\nDetails\n"];
+    const fs = lint({ venue: MSR, facts: msrFacts(pages, 10, 12) });
+    expect(fs[0]?.message).toMatch(
+      /^body pages \(up to the references on page 10, and the appendix from page 12\): 11, over the limit 10/,
+    );
+  });
+
+  it("🔴 three pages of only references fail", () => {
+    const fs = lint({
+      venue: MSR,
+      facts: msrFacts([...bodyPages(9), ...refsFrom(3)], 10),
+    });
+    expect(fs.map((f) => f.message)).toEqual([
+      "pages holding only references: 3, over the limit 2 for MSR/technical — a desk reject; cut the text",
+    ]);
+  });
+});
+
 /** An AIDC paper that declares who wrote it. */
 const BLIND = {
   extends: "paperlint:aidc",
@@ -1022,3 +1223,55 @@ describe("judgeBodyEnd, on a venue it does not apply to", () => {
     expect(judgeBodyEnd(NO_TEXT, venue(null))).toEqual([]);
   });
 });
+
+/** A paper on AIDC through `cycles`: one attempt, open unless `outcome` says otherwise. */
+const onCycle = (cycle: Record<string, unknown>) => ({
+  identity: ["Ada Example"],
+  cycles: [
+    {
+      id: "aidc-2026",
+      venue: { kind: "preset", extends: "paperlint:aidc" },
+      kind: "regular",
+      opened: "2026-09-26",
+      ...cycle,
+    },
+  ],
+});
+
+describe("the cycle decides what applies", () => {
+  it("an open cycle reads as the flat form: the same findings on the same facts", () => {
+    const facts = said((f) => (f.columns = 1));
+    expect(ids(lint({ venue: onCycle({}), facts }))).toEqual(
+      ids(lint({ venue: BLIND, facts })),
+    );
+    expect(ids(lint({ venue: onCycle({}), facts }))).toContain(
+      "pdf/geometry:columns",
+    );
+  });
+
+  it("`phase: porting` — the source is in the previous venue's template by declaration: every venue rule is silent", () => {
+    const facts = said(
+      (f) => ((f.columns = 1), (f.pages_text = ["Ada Example\n"])),
+    );
+    expect(lint({ venue: onCycle({ phase: "porting" }), facts })).toEqual([]);
+    expect(lint({ venue: onCycle({ phase: "porting" }), facts: null })).toEqual(
+      [],
+    );
+  });
+
+  it("an ACCEPTED cycle at a blind venue: the camera-ready carries the authors, anonymity/identity is silent", () => {
+    const facts = said(
+      (f) =>
+        (f.pages_text = ["Ada Example\n", ...bodyPages(11), "References\n"]),
+    );
+    const accepted = {
+      kind: "accepted",
+      date: "2026-10-16",
+      evidence: "reviews/decision.md",
+    };
+    expect(ids(lint({ venue: onCycle({}), facts }))).toContain(
+      "anonymity/identity:leak",
+    );
+    expect(lint({ venue: onCycle({ outcome: accepted }), facts })).toEqual([]);
+  });
+});