paperlint 7.0.0 → 7.2.0

package/src/submission.ts

@@ -30,7 +30,19 @@ import {
 } from "./domain/submission.ts";
 import type { Files } from "./ports/files.ts";
 import type { SubmissionPortal } from "./ports/submission-portal.ts";
-import { paperPreset, paperPresetProblem, type PresetDeps } from "./presets.ts";
+import {
+  paperPreset,
+  unusablePresetLine,
+  type PaperPreset,
+  type PresetDeps,
+} from "./presets.ts";
+import type { PaperSettings } from "./paper-settings.ts";
+import { currentDeadlines } from "./domain/cycle.ts";
+import {
+  deadlinesInForce,
+  type InForce,
+  type Observation,
+} from "./domain/deadline.ts";
 import { CONFIG_FILE } from "#lib/paper-config";
 
 /** The environment variable each portal kind's token is read from. */
@@ -80,22 +92,31 @@ 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;
+  /**
+   * The deadlines in force for the current attempt: the paper's own entries (with `cycles`) over the
+   * venue preset's readings. Instants and where each came from — never how long is left.
+   */
+  readonly deadlines: readonly InForce[];
 }
 
 const configOf = (dir: string): string => join(dir, CONFIG_FILE);
 
-/** The paper directory → its portal and submission, or the line naming the file and key to set. */
-export function submissionTarget(
+/** Why a paper without a venue preset has no portal: the key to set, or — with cycles — where. */
+const noPresetLine = (
   paperDir: string,
-  deps: PresetDeps,
+  settings: PaperSettings | null,
+): string =>
+  settings === null || settings.cycles === null
+    ? `${configOf(paperDir)}: no "extends" — the venue preset it names declares the portal ("portal": { "kind": …, "url": … })`
+    : `${configOf(paperDir)}: the current cycle names no venue preset, and the preset is what declares the portal — set the venue in the current cycle ("venue": { "kind": "preset", "extends": "paperlint:…" }), or upload by hand`;
+
+/** A resolved paper → its portal and submission, or the line naming the file and key to set. */
+function targetOf(
+  paperDir: string,
+  p: Extract<PaperPreset, { readonly kind: "resolved" }>,
 ): Result<SubmissionTarget, string> {
-  const p = paperPreset(paperDir, deps);
-  const problem = paperPresetProblem(paperDir, p);
-  if (problem !== null) return err(problem);
-  if (p.kind !== "resolved")
-    return err(
-      `${configOf(paperDir)}: no "extends" — the venue preset it names declares the portal ("portal": { "kind": …, "url": … })`,
-    );
   const declared = p.preset.portal;
   if (declared === null)
     return err(
@@ -109,7 +130,31 @@ 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;
+  const own =
+    p.settings.cycles === null
+      ? []
+      : currentDeadlines(p.settings.cycles.current);
+  const deadlines = deadlinesInForce(own, p.preset.deadlines);
+  return ok({ portal: portal.value, id: sub.id, pdf, call, deadlines });
+}
+
+/** The paper directory → its portal and submission, or the line naming the file and key to set. */
+export function submissionTarget(
+  paperDir: string,
+  deps: PresetDeps,
+): Result<SubmissionTarget, string> {
+  const p = paperPreset(paperDir, deps);
+  switch (p.kind) {
+    case "none":
+      return err(noPresetLine(paperDir, p.settings));
+    case "settings-problem":
+    case "preset-problem":
+      return err(unusablePresetLine(paperDir, p));
+    case "resolved":
+      return targetOf(paperDir, p);
+  }
 }
 
 /** The token from the environment, or the line naming the variable and where to get one. */
@@ -162,6 +207,25 @@ const pdfLine = (view: SubmissionView): string =>
     ? "portal PDF    none"
     : `portal PDF    ${view.pdf.hash}, ${view.pdf.size === null ? "?" : String(view.pdf.size)} bytes, uploaded ${iso(view.pdf.uploadedAt)}`;
 
+const readingText = (o: Observation): string =>
+  `${o.source} ${o.at}, read ${o.read}`;
+
+/** One deadline in force, what set it, and the other readings of it. Pure. */
+export function deadlineLine(d: InForce): string {
+  const by = d.by;
+  const why =
+    by.kind === "override"
+      ? `override: ${by.override.reason} (${by.override.evidence})`
+      : `${by.reading.source}, read ${by.reading.read}`;
+  const others = d.readings.filter(
+    (r) => by.kind === "override" || r !== by.reading,
+  );
+  const also = others.length
+    ? `; also ${others.map(readingText).join("; ")}`
+    : "";
+  return `deadline      ${d.what} ${d.at} — ${why}${also}`;
+}
+
 /** `show`'s report. Pure. */
 export function showLines(
   t: SubmissionTarget,
@@ -178,10 +242,19 @@ export function showLines(
     pdfLine(view),
     `local PDF     ${local.shown} ${local.sha256 === null ? "(missing)" : `sha2-${local.sha256}`}`,
     matchLine(view, local.sha256),
+    ...t.deadlines.map(deadlineLine),
     ...view.messages.map(messageLine),
   ];
 }
 
+/**
+ * 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 +316,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 +343,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

@@ -35,6 +35,7 @@ import {
   type VenueTalkJson,
 } from "./domain/talk.ts";
 import type { VenuePortal } from "./domain/submission.ts";
+import type { Reading } from "./domain/deadline.ts";
 
 /** CTAN package name → the names that prove it is installed. */
 export type PackageProofs = Readonly<Record<string, readonly string[]>>;
@@ -140,6 +141,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 +161,7 @@ export const NO_FORMAT: VenueFormat = {
   fontsText: null,
   fontsTitle: null,
   bodyEndsAt: null,
+  appendixInBody: null,
   kinds: new Map(),
 };
 
@@ -189,10 +196,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`). */
@@ -209,6 +220,8 @@ export interface PresetFile {
   readonly talk: VenueTalk | null;
   /** Where the venue takes submissions (`paperlint submission`); null when the file does not say. */
   readonly portal: VenuePortal | null;
+  /** The edition's deadlines as they were read; null when the file names none (a child's list replaces its parent's). */
+  readonly deadlines: readonly Reading[] | null;
 }
 
 type KindsJson = Readonly<
@@ -227,6 +240,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 +258,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";
@@ -263,6 +279,7 @@ interface PresetBodyJson {
   };
   readonly talk?: VenueTalkJson;
   readonly portal?: VenuePortal;
+  readonly deadlines?: readonly Reading[];
 }
 
 /** An optional field as the typed preset holds it: absent is null. */
@@ -292,6 +309,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 +394,36 @@ 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 };
+
+/**
+ * A preset's `deadlines`, or null when it names none. Two readings of one kind from one source are
+ * refused: the schema cannot say it, and a paper could not tell which binds.
+ */
+function deadlinesOf(
+  d: PresetJson["deadlines"],
+  file: string,
+): readonly Reading[] | null {
+  if (d === undefined) return null;
+  const twice = d.find(
+    (r, i) =>
+      d.findIndex((x) => x.what === r.what && x.source === r.source) !== i,
+  );
+  if (twice !== undefined)
+    throw new Error(
+      `${file}: "deadlines" holds two "${twice.source}" readings of "${twice.what}" — keep one, the latest`,
+    );
+  return d.map(({ what, at, source, url, read }) => ({
+    what,
+    at,
+    source,
+    url,
+    read,
+  }));
+}
+
 /**
  * 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 +448,18 @@ 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),
+    deadlines: deadlinesOf(j.deadlines, file),
   };
 }
 

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

@@ -10,6 +10,7 @@ import { memoryFiles } from "./adapters/memory/index.ts";
 import { presetsDir } from "./package-dirs.ts";
 import { latexReader } from "./adapters/latex/index.ts";
 import {
+  cyclePortRules,
   judgeRequiredSections,
   judgeTemplate,
   otherVenues,
@@ -77,6 +78,9 @@ function lint(
     ...Object.entries(formatRules(deps)).map(
       ([n, r]) => [`format/${n}`, r] as const,
     ),
+    ...Object.entries(cyclePortRules(deps)).map(
+      ([n, r]) => [`cycle/${n}`, r] as const,
+    ),
   ]) {
     const visitor = rule.create({
       filename,
@@ -302,6 +306,78 @@ describe("tex/template — the shipped ACM and ACL templates", () => {
   });
 });
 
+const PORTING = {
+  id: "aidc-2026",
+  venue: { kind: "preset", extends: "paperlint:aidc" },
+  kind: "regular",
+  opened: "2026-09-26",
+  phase: "porting",
+};
+
+describe("tex/template — a cycle in `porting`", () => {
+  it("the class line is the previous venue's by declaration: silent, where the flat form reports", () => {
+    const src = paper("\\documentclass[sigconf]{acmart}");
+    expect(lint(src, AIDC).map((f) => f.messageId)).toEqual(["wrongClass"]);
+    expect(lint(src, { cycles: [PORTING] })).toEqual([]);
+    expect(
+      lint(src, { cycles: [{ ...PORTING, phase: "prepared" }] }).map(
+        (f) => f.messageId,
+      ),
+    ).toEqual(["wrongClass"]);
+  });
+});
+
+describe("cycle/port-done — the declared port is finished", () => {
+  it("porting declared and the class line already the venue's: the one finding, naming the cycle", () => {
+    const fs = lint(OFFICIAL, { cycles: [PORTING] });
+    expect(fs.map((f) => `${f.rule}:${f.messageId}`)).toEqual([
+      "cycle/port-done:done",
+    ]);
+    expect(fs[0]?.message).toMatch(
+      /already `\\documentclass\[conference,compsoc\]\{IEEEtran\}`, which AIDC requires, and the cycle «aidc-2026» still declares "phase": "porting"/,
+    );
+  });
+
+  it("silent while the class line is still the old venue's, once the phase is dropped, and on the flat form", () => {
+    const old = paper("\\documentclass[sigconf]{acmart}");
+    expect(lint(old, { cycles: [PORTING] })).toEqual([]);
+    expect(
+      lint(OFFICIAL, { cycles: [{ ...PORTING, phase: "prepared" }] }),
+    ).toEqual([]);
+    expect(lint(OFFICIAL, AIDC)).toEqual([]);
+  });
+
+  it("judges the text when the source carries no `raw`", () => {
+    expect(
+      lint(OFFICIAL, { cycles: [PORTING] }, { raw: false }).map(
+        (f) => `${f.rule}:${f.messageId}`,
+      ),
+    ).toContain("cycle/port-done:done");
+  });
+
+  it("silent when the venue names no template, and when the preset does not resolve", () => {
+    const own = `${PAPER}/own.jsonc`;
+    const porting = (ext: string) => ({
+      cycles: [{ ...PORTING, venue: { kind: "preset", extends: ext } }],
+    });
+    expect(
+      lint(OFFICIAL, porting("./own.jsonc"), {
+        extra: {
+          [own]: JSON.stringify({
+            type: "family",
+            tex: { packages: { x: ["x"] } },
+          }),
+        },
+      }).filter((f) => f.rule === "cycle/port-done"),
+    ).toEqual([]);
+    expect(
+      lint(OFFICIAL, porting("./missing.jsonc")).filter(
+        (f) => f.rule === "cycle/port-done",
+      ),
+    ).toEqual([]);
+  });
+});
+
 describe("tex/template — a project's own preset, and nothing to judge", () => {
   it("a preset with no template: nothing to compare, no finding", () => {
     const own = `${PAPER}/own.jsonc`;
@@ -322,6 +398,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 +769,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 +972,7 @@ describe("otherVenues", () => {
       "acm-sigconf",
       "AgenticDev",
       "AISec",
+      "MSR",
     ]);
   });
 });