paperlint 7.0.0 → 7.2.0

package/src/presets.ts

@@ -25,8 +25,8 @@
  *   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
- *              `portal` (each whole)
+ *   template   the child wins, with its `template_forbids`; so does `name`, and `required_sections`, `register`, `talk`,
+ *              `portal` and `deadlines` (each whole)
  *   aliases    union, with every `name` — what the venue is called along the chain
  *
  * ── THE ID AND THE LABEL ──────────────────────────────────────────────────────────
@@ -63,6 +63,7 @@ import { messageOf } from "./domain/text.ts";
 import type { RegisterAnchor } from "./domain/register.ts";
 import type { VenueTalk } from "./domain/talk.ts";
 import type { VenuePortal } from "./domain/submission.ts";
+import type { Reading } from "./domain/deadline.ts";
 
 /** The prefix of a shipped preset's spec. */
 export const SHIPPED_PREFIX = "paperlint:";
@@ -75,10 +76,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 +107,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;
@@ -116,6 +124,11 @@ export interface Preset {
   readonly talk: VenueTalk | null;
   /** Where the venue takes submissions (`paperlint submission`); null when no file of the chain says. */
   readonly portal: VenuePortal | null;
+  /**
+   * The edition's deadlines as they were read (the portal's, refreshed by paperlint's scheduled
+   * workflow); empty when no file of the chain names any. A paper's current cycle derives them.
+   */
+  readonly deadlines: readonly Reading[];
 }
 
 /** Why a spec does not resolve. */
@@ -254,6 +267,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 +290,7 @@ const NOTHING_MERGED: Merging = {
   template: null,
   aliases: [],
   blind: false,
+  mentions: "any",
   requiredSections: [],
   tex: NO_REQUIREMENTS,
   format: NO_FORMAT,
@@ -284,18 +299,37 @@ const NOTHING_MERGED: Merging = {
   registerAnchors: [],
   talk: null,
   portal: null,
+  deadlines: [],
 };
 
+/** The blocks a child replaces whole: the child's when it names one, else its parents'. Pure. */
+const wholeBlocks = (
+  acc: Merging,
+  p: PresetFile,
+): Pick<
+  Merging,
+  "requiredSections" | "registerAnchors" | "talk" | "portal" | "deadlines"
+> => ({
+  requiredSections: p.requiredSections ?? acc.requiredSections,
+  registerAnchors: p.registerAnchors ?? acc.registerAnchors,
+  talk: p.talk ?? acc.talk,
+  portal: p.portal ?? acc.portal,
+  deadlines: p.deadlines ?? acc.deadlines,
+});
+
 /** One file of the chain, `file`, merged over what its parents gave. Pure. */
 const mergeOne = (
   acc: Merging,
   { preset: p, file }: { readonly preset: PresetFile; readonly file: string },
 ): Merging => ({
   name: nameOf(p.identity) ?? acc.name,
-  template: p.template === null ? acc.template : { text: p.template, file },
+  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,
-  requiredSections: p.requiredSections ?? acc.requiredSections,
+  mentions: p.mentions ?? acc.mentions,
   tex: p.tex ? mergeRequirements(acc.tex, p.tex) : acc.tex,
   format: mergeFormat(acc.format, p.format),
   rules: { ...acc.rules, ...p.rules },
@@ -303,9 +337,7 @@ const mergeOne = (
     ...acc.ruleOrigins,
     ...Object.fromEntries(Object.keys(p.rules).map((id) => [id, file])),
   },
-  registerAnchors: p.registerAnchors ?? acc.registerAnchors,
-  talk: p.talk ?? acc.talk,
-  portal: p.portal ?? acc.portal,
+  ...wholeBlocks(acc, p),
 });
 
 /** The chain, root first, merged into one preset. Pure. */
@@ -368,17 +400,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
@@ -440,15 +476,29 @@ export function paperPreset(paperDir: string, deps: PresetDeps): PaperPreset {
     : { kind: "preset-problem", settings, problem: r.error };
 }
 
+/** A paper's settings or preset that cannot be used. */
+export type UnusablePreset = Extract<
+  PaperPreset,
+  { readonly kind: "settings-problem" | "preset-problem" }
+>;
+
+/** The one-line reason a paper's settings or preset cannot be used. */
+export const unusablePresetLine = (
+  paperDir: string,
+  p: UnusablePreset,
+): string =>
+  p.kind === "preset-problem"
+    ? `${join(paperDir, CONFIG_FILE)}: ${presetProblemText(p.problem)}`
+    : settingsProblemLine(paperDir, p.problem);
+
 /** The one-line reason a paper's settings or preset cannot be used, or null when they can. */
 export function paperPresetProblem(
   paperDir: string,
   p: PaperPreset,
 ): string | null {
-  if (p.kind === "preset-problem")
-    return `${join(paperDir, CONFIG_FILE)}: ${presetProblemText(p.problem)}`;
-  if (p.kind !== "settings-problem") return null;
-  return settingsProblemLine(paperDir, p.problem);
+  return p.kind === "preset-problem" || p.kind === "settings-problem"
+    ? unusablePresetLine(paperDir, p)
+    : null;
 }
 
 /** The one line naming a paper's `paperlint.json` that does not parse, and why. */

package/src/rule-cases.test.ts

@@ -316,6 +316,88 @@ const onPdf = (tree: Record<string, string>, line = 1) => ({
   line,
 });
 
+/** One open cycle on the ACM family: what a flat `{ "extends": "paperlint:acm-sigconf" }` says, as a record. */
+const OPEN_CYCLE = JSON.stringify({
+  cycles: [
+    {
+      id: "open-2027",
+      venue: { kind: "preset", extends: "paperlint:acm-sigconf" },
+      opened: "2026-09-09",
+    },
+  ],
+});
+/**
+ * One open cycle whose registration deadline is after its submission deadline: a date typed wrong.
+ * The record's STRUCTURAL problems — two open cycles, a bare date, an unknown key — never reach a
+ * rule: `paperRuleBlocks` refuses the settings file before lint runs (measured 2026-10-05: one line
+ * naming the file and both ids, exit 2), as it refuses any unreadable `paperlint.json`. The order of
+ * the deadlines is what the record parses with and the rule still judges.
+ */
+const DISORDERED = JSON.stringify({
+  cycles: [
+    {
+      id: "open-2027",
+      venue: { kind: "preset", extends: "paperlint:acm-sigconf" },
+      opened: "2026-09-09",
+      // The call's own abstract day after its paper day: a date typed wrong. (The portal's and the
+      // call's readings disagreeing is not a finding: the earlier binds.)
+      deadlines: [
+        {
+          what: "registration",
+          observed: [
+            {
+              at: "2026-10-25 AoE",
+              source: "call",
+              url: "https://conf.example/cfp",
+              read: "2026-09-09",
+            },
+          ],
+        },
+        {
+          what: "submission",
+          observed: [
+            {
+              at: "2026-10-20T04:00:00Z",
+              source: "portal",
+              url: "https://conf.example/deadlines",
+              read: "2026-09-09",
+            },
+            {
+              at: "2026-10-23 AoE",
+              source: "call",
+              url: "https://conf.example/cfp",
+              read: "2026-09-09",
+            },
+          ],
+        },
+      ],
+    },
+  ],
+});
+/** One closed cycle whose evidence is `reviews/decision.md`. */
+const CLOSED_CYCLE = JSON.stringify({
+  cycles: [
+    {
+      id: "first-2026",
+      venue: { kind: "preset", extends: "paperlint:acm-sigconf" },
+      opened: "2026-07-01",
+      outcome: {
+        kind: "rejected",
+        date: "2026-09-08",
+        evidence: "reviews/decision.md",
+      },
+    },
+  ],
+});
+/** A BlindConf cycle still declared porting — on a paper whose class line is already BlindConf's. */
+const BLIND_PORTING = {
+  id: "blindconf-2027",
+  venue: { kind: "preset", extends: "./blindconf.jsonc" },
+  opened: "2026-09-09",
+  phase: "porting",
+  // What `blind()` declares flat; with cycles it moves into the record's siblings, not the cycle.
+};
+
 const CASES: Readonly<Record<string, RuleCases>> = {
   "paper/stages": {
     reports: {
@@ -326,6 +408,68 @@ const CASES: Readonly<Record<string, RuleCases>> = {
     },
     silent: paper(tex("x")),
   },
+  // ── the cycle rules: the paper's attempts in paperlint.json, judged on PIPELINE-STATUS.md ──────
+  "cycle/record": {
+    reports: {
+      tree: { ...paper(tex("x")), [`${P}/paperlint.json`]: DISORDERED },
+      file: STATUS_FILE,
+      severity: 2,
+      line: 1,
+    },
+    silent: paper(tex("x")),
+  },
+  "cycle/evidence": {
+    reports: {
+      tree: { ...paper(tex("x")), [`${P}/paperlint.json`]: CLOSED_CYCLE },
+      file: STATUS_FILE,
+      severity: 2,
+      line: 1,
+    },
+    silent: {
+      ...paper(tex("x")),
+      [`${P}/paperlint.json`]: CLOSED_CYCLE,
+      [`${P}/reviews/decision.md`]: "# decision\n",
+    },
+  },
+  "cycle/stage": {
+    reports: {
+      tree: {
+        ...paper(tex("x")),
+        [STATUS_FILE]: SHIPPED_STATUS,
+        [`${P}/paperlint.json`]: OPEN_CYCLE,
+        [`${P}/versions/a.pdf`]: "x",
+      },
+      file: STATUS_FILE,
+      severity: 2,
+      line: 1,
+    },
+    silent: {
+      ...paper(tex("x")),
+      [STATUS_FILE]: SHIPPED_STATUS.replace(
+        "date: 2026-07-22",
+        "cycle: open-2027\n    date: 2026-07-22",
+      ),
+      [`${P}/paperlint.json`]: OPEN_CYCLE,
+      [`${P}/versions/a.pdf`]: "x",
+    },
+  },
+  "cycle/port-done": {
+    reports: {
+      tree: {
+        ...blind("Text."),
+        [`${P}/paperlint.json`]: JSON.stringify({ cycles: [BLIND_PORTING] }),
+      },
+      file: TEX_FILE,
+      severity: 2,
+      line: 1,
+    },
+    silent: {
+      ...blind("Text."),
+      [`${P}/paperlint.json`]: JSON.stringify({
+        cycles: [{ ...BLIND_PORTING, phase: "prepared" }],
+      }),
+    },
+  },
   "paper/source": {
     reports: {
       tree: { ...paper(tex("x")), [STATUS_FILE]: SHIPPED_STATUS },

package/src/submission.test.ts

@@ -22,6 +22,7 @@ import type { SubmissionPortal } from "./ports/submission-portal.ts";
 import {
   failureText,
   runSubmission,
+  deadlineLine,
   submissionTarget,
   tokenFor,
   usageProblem,
@@ -41,8 +42,11 @@ const withPresets = (fs: Files): Files => ({
   readBytes: (p) => fs.readBytes(p) ?? nodeFiles.readBytes(p),
 });
 
+/** A venue over aidc's format with a portal of its own — so none of aidc's deadline readings. */
 const venue = (portal: unknown): string =>
-  JSON.stringify(venuePreset("venue", { extends: "paperlint:aidc", portal }));
+  JSON.stringify(
+    venuePreset("venue", { extends: "paperlint:aidc", portal, deadlines: [] }),
+  );
 const files = (o: {
   readonly portal?: unknown;
   readonly paper?: Readonly<Record<string, unknown>>;
@@ -117,6 +121,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 +295,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 +331,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 +381,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 +423,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 () => {
@@ -437,6 +480,28 @@ test("🔴 the file and key to set: no portal in the preset, no submission in th
   const noExtends = files({ paper: { submission: { id: 7 } } });
   const t3 = submissionTarget(PAPER, deps(noExtends));
   assert.match(!t3.ok ? t3.error : "", /paperlint\.json: no "extends"/);
+  // With cycles, `extends` beside them is refused: the message names the cycle, not the key.
+  const named = files({
+    paper: {
+      cycles: [
+        {
+          id: "secdev-2027",
+          venue: {
+            kind: "named",
+            name: "SecDev 2027",
+            url: "https://x.example",
+          },
+          opened: "2027-01-10",
+          submission: { id: 3 },
+        },
+      ],
+    },
+  });
+  const t5 = submissionTarget(PAPER, deps(named));
+  assert.equal(
+    !t5.ok ? t5.error : "",
+    `${PAPER}/paperlint.json: 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`,
+  );
   const broken = files({
     paper: { extends: "../../venue.jsonc", submission: { id: "7" } },
   });
@@ -495,3 +560,81 @@ test("usage: a subcommand is required, one paper folder, update-only flags refus
   );
   assert.equal(usageProblem({ ...ARGS, sub: "update", save: true }), null);
 });
+
+test("show prints the current attempt's deadlines in force: the preset's portal readings, the paper's call readings and override over them", () => {
+  const fs = memoryFiles({
+    "/w/package.json": "{}",
+    [`${PAPER}/paperlint.json`]: JSON.stringify({
+      cycles: [
+        {
+          id: "msr-2027",
+          venue: { kind: "preset", extends: "paperlint:msr" },
+          kind: "technical",
+          opened: "2026-10-05",
+          submission: { id: 7 },
+          deadlines: [
+            {
+              what: "registration",
+              observed: [
+                {
+                  at: "2026-10-20 AoE",
+                  source: "call",
+                  url: "https://2027.msrconf.org/cfp",
+                  read: "2026-10-05",
+                },
+              ],
+            },
+            {
+              what: "submission",
+              observed: [
+                {
+                  at: "2026-10-23 AoE",
+                  source: "call",
+                  url: "https://2027.msrconf.org/cfp",
+                  read: "2026-10-05",
+                },
+              ],
+            },
+            {
+              what: "resubmission",
+              override: {
+                at: "2026-10-27T04:00:00Z",
+                reason: "the chairs extended updates by mail",
+                evidence: "mail/extension.eml",
+              },
+            },
+          ],
+        },
+      ],
+    }),
+  });
+  const t = submissionTarget(PAPER, {
+    files: withPresets(fs),
+    venuesDir: presetsDir(),
+  });
+  assert.ok(t.ok, JSON.stringify(t));
+  assert.deepEqual(t.value.deadlines.map(deadlineLine), [
+    "deadline      registration 2026-10-21T11:59:59Z — call, read 2026-10-05",
+    "deadline      submission 2026-10-20T04:00:00Z — portal, read 2026-10-05; also call 2026-10-24T11:59:59Z, read 2026-10-05",
+    "deadline      resubmission 2026-10-27T04:00:00Z — override: the chairs extended updates by mail (mail/extension.eml); also portal 2026-10-23T04:00:00Z, read 2026-10-05",
+  ]);
+});
+
+test("show, in the flat form: the deadlines in force are the preset's readings alone", () => {
+  const flat = memoryFiles({
+    "/w/package.json": "{}",
+    [`${PAPER}/paperlint.json`]: JSON.stringify({
+      extends: "paperlint:msr",
+      kind: "technical",
+      submission: { id: 7 },
+    }),
+  });
+  const f = submissionTarget(PAPER, {
+    files: withPresets(flat),
+    venuesDir: presetsDir(),
+  });
+  assert.deepEqual(f.ok ? f.value.deadlines.map((d) => [d.what, d.at]) : f, [
+    ["submission", "2026-10-20T04:00:00Z"],
+    ["resubmission", "2026-10-23T04:00:00Z"],
+  ]);
+});