paperlint 7.0.0 → 7.2.0

package/src/paper-settings.test.ts

@@ -33,6 +33,7 @@ describe("parsePaperSettings", () => {
         identity: null,
         talk: null,
         submission: null,
+        cycles: null,
       },
     });
     expect(parsePaperSettings({})).toEqual({
@@ -45,6 +46,7 @@ describe("parsePaperSettings", () => {
         identity: null,
         talk: null,
         submission: null,
+        cycles: null,
       },
     });
   });
@@ -60,6 +62,7 @@ describe("parsePaperSettings", () => {
         identity: null,
         talk: null,
         submission: null,
+        cycles: null,
       },
     });
   });
@@ -164,6 +167,7 @@ const UNSET = {
   identity: null,
   talk: null,
   submission: null,
+  cycles: null,
 };
 
 describe("readPaperSettings — the root paperlint.json's defaults, the paper's file over them", () => {
@@ -220,8 +224,14 @@ describe("readPaperSettings — the root paperlint.json's defaults, the paper's
       identity: null,
       talk: null,
       submission: null,
+      cycles: null,
     });
   });
+});
+
+describe("readPaperSettings — a project key in a paper's file", () => {
+  const withFiles = (f: Record<string, string>) =>
+    memoryFiles({ "/work/package.json": "{}", ...f });
 
   it("papersDir in a paper's file: broken, naming the root file as its place", () => {
     const r = readPaperSettings(
@@ -264,6 +274,7 @@ describe("paperRules — `rules` in paperlint.json", () => {
     identity: null,
     talk: null,
     submission: null,
+    cycles: null,
   });
 
   it("no rules: none", () => {
@@ -352,3 +363,159 @@ describe("talk in a paper's paperlint.json", () => {
     expect(r.ok ? "" : r.error).toMatch(/"talk.mode"/);
   });
 });
+
+describe("parsePaperSettings — `cycles`: the current attempt supplies extends, kind and submission", () => {
+  const closed = {
+    id: "alpha-2026",
+    venue: { kind: "preset", extends: "paperlint:acm-sigconf" },
+    kind: "short",
+    opened: "2026-07-01",
+    outcome: {
+      kind: "rejected",
+      date: "2026-09-08",
+      desk: true,
+      evidence: "reviews/alpha.md",
+    },
+  };
+  const open = {
+    id: "beta-2027",
+    venue: { kind: "preset", extends: "paperlint:ieee-conference" },
+    kind: "technical",
+    opened: "2026-09-09",
+    submission: { id: 52 },
+    outcome: { kind: "open" },
+  };
+  const settingsOf = (json: unknown) => {
+    const r = parsePaperSettings(json);
+    if (!r.ok) throw new Error(r.error);
+    return r.value;
+  };
+
+  it("an open cycle: its venue, kind and submission are the paper's", () => {
+    const s = settingsOf({ cycles: [closed, open] });
+    expect(s.extends).toBe("paperlint:ieee-conference");
+    expect(s.kind).toBe("technical");
+    expect(s.submission).toEqual({ id: 52 });
+    expect(s.cycles?.current.kind).toBe("cycle");
+    expect(s.cycles?.list.map((c) => c.id)).toEqual([
+      "alpha-2026",
+      "beta-2027",
+    ]);
+  });
+
+  it("parked (the last cycle closed) and none (`cycles: []`): no venue, as `extends: null` reads", () => {
+    const parked = settingsOf({ cycles: [closed] });
+    expect([parked.extends, parked.kind, parked.submission]).toEqual([
+      null,
+      null,
+      null,
+    ]);
+    expect(parked.cycles?.current.kind).toBe("parked");
+    expect(settingsOf({ cycles: [] }).cycles?.current).toEqual({
+      kind: "none",
+    });
+  });
+});
+
+describe("parsePaperSettings — `cycles`, closed and named", () => {
+  const closed = {
+    id: "alpha-2026",
+    venue: { kind: "preset", extends: "paperlint:acm-sigconf" },
+    kind: "short",
+    opened: "2026-07-01",
+    outcome: { kind: "withdrawn", date: "2026-09-08", evidence: "n.md" },
+  };
+  const open = {
+    id: "beta-2027",
+    venue: { kind: "preset", extends: "paperlint:ieee-conference" },
+    kind: "technical",
+    opened: "2026-09-09",
+  };
+  const settingsOf = (json: unknown) => {
+    const r = parsePaperSettings(json);
+    if (!r.ok) throw new Error(r.error);
+    return r.value;
+  };
+
+  it("an accepted last cycle keeps its venue and kind: camera-ready and talk are judged against it", () => {
+    const accepted = { kind: "accepted", date: "2026-08-21", evidence: "r.md" };
+    const s = settingsOf({ cycles: [{ ...closed, outcome: accepted }] });
+    expect([s.extends, s.kind, s.cycles?.current.kind]).toEqual([
+      "paperlint:acm-sigconf",
+      "short",
+      "accepted",
+    ]);
+  });
+
+  it("a named venue (no preset yet) resolves no preset: extends is null, the record stays", () => {
+    const venue = {
+      kind: "named",
+      name: "X '27",
+      url: "https://example.org/c",
+    };
+    const s = settingsOf({ cycles: [{ ...open, venue }] });
+    expect([s.extends, s.kind]).toEqual([null, "technical"]);
+  });
+});
+
+describe("parsePaperSettings — `cycles` refused", () => {
+  const open = {
+    id: "beta-2027",
+    venue: { kind: "preset", extends: "paperlint:ieee-conference" },
+    opened: "2026-09-09",
+  };
+  const alsoOpen = {
+    id: "alpha-2026",
+    venue: { kind: "preset", extends: "paperlint:acm-sigconf" },
+    opened: "2026-07-01",
+  };
+
+  it("one derived key beside `cycles` is refused in the singular", () => {
+    const error: unknown = expect.stringMatching(
+      /^"kind" beside "cycles": with cycles, it is the current attempt's/,
+    );
+    expect(parsePaperSettings({ kind: "short", cycles: [open] })).toEqual({
+      ok: false,
+      error,
+    });
+  });
+
+  it("a derived key written beside `cycles` is refused, naming it — two sources for one fact", () => {
+    const error: unknown = expect.stringMatching(
+      /^"extends", "kind" beside "cycles": with cycles, they are the current attempt's/,
+    );
+    expect(
+      parsePaperSettings({
+        extends: "paperlint:acm-sigconf",
+        kind: "short",
+        cycles: [open],
+      }),
+    ).toEqual({ ok: false, error });
+  });
+
+  it("two open cycles is refused as the file's problem: dual submission has no current venue", () => {
+    const error: unknown = expect.stringMatching(
+      /are both open — a paper is on one attempt/,
+    );
+    expect(parsePaperSettings({ cycles: [alsoOpen, open] })).toEqual({
+      ok: false,
+      error,
+    });
+  });
+
+  it("a malformed cycle is refused with the entry and key, through readPaperSettings as `broken`", () => {
+    const files = memoryFiles({
+      "/work/package.json": "{}",
+      [`${PAPER}/paperlint.json`]: JSON.stringify({
+        cycles: [{ ...open, opened: "soon" }],
+      }),
+    });
+    const why: unknown = expect.stringMatching(
+      /^cycles\[0\]: "opened" must be a date/,
+    );
+    expect(readPaperSettings(files, PAPER)).toEqual({
+      ok: false,
+      error: { kind: "broken", why },
+    });
+  });
+});

package/src/paper-settings.ts

@@ -4,7 +4,9 @@
  * One file name at two levels, one schema (lib/paper-config.mjs → SETTINGS_KEYS):
  *
  *   paperlint.json                 the project (optional): papersDir, rules, defaults
- *   <paper>/paperlint.json         this paper: { extends, kind, pdf, rules, identity, talk, submission }
+ *   <paper>/paperlint.json         this paper: { extends, kind, pdf, rules, identity, talk, submission } —
+ *                                  or `cycles`, from whose current attempt extends, kind and submission
+ *                                  are DERIVED (src/domain/cycle.ts); the two forms do not mix
  *   a venue preset                 `paperlint:<name>` (shipped) or `./x.jsonc` (src/presets.ts)
  *
  * The paper's `extends`, `kind` and `pdf` win over the root's; with no own value, the root's is
@@ -36,6 +38,13 @@ import {
   parsePaperSubmission,
   type PaperSubmission,
 } from "./domain/submission.ts";
+import {
+  cycleProblemText,
+  cyclesOf,
+  parseCycles,
+  venueCycleOf,
+  type Cycles,
+} from "./domain/cycle.ts";
 
 /** What one paper declares. Every absent field is null. */
 export interface PaperSettings {
@@ -60,6 +69,12 @@ export interface PaperSettings {
   readonly talk: PaperTalk | null;
   /** Which submission on the venue's portal is this paper's; null when it says none. Never the root's. */
   readonly submission: PaperSubmission | null;
+  /**
+   * The paper's attempts at venues and the current one, when the file declares `cycles`; null for a
+   * file in the flat form. With cycles, `extends`, `kind` and `submission` above are the current
+   * attempt's — derived, never written beside it. Never the root's.
+   */
+  readonly cycles: Cycles | null;
 }
 
 /** Why a paper's settings cannot be read. */
@@ -139,28 +154,85 @@ function rulesAndTalk(
     : submission;
 }
 
-/** The parsed JSON of `paperlint.json` → the settings, or one line saying what is wrong. Pure. */
-export function parsePaperSettings(
-  json: unknown,
-): Result<PaperSettings, string> {
-  if (!isObject(json)) return err("must be a JSON object");
+/** The keys the current cycle supplies: writing one beside `cycles` is a second source for it. */
+const DERIVED_FROM_CYCLE = ["extends", "kind", "submission"] as const;
+
+/**
+ * `cycles`, parsed with its current attempt, or null when the file is in the flat form. A file that
+ * has both `cycles` and a derived key is refused: two sources for one fact drift apart.
+ */
+function cyclesField(
+  json: Readonly<Record<string, unknown>>,
+): Result<Cycles | null, string> {
+  const list = parseCycles(json["cycles"]);
+  if (!list.ok) return list;
+  if (list.value === null) return ok(null);
+  const beside = DERIVED_FROM_CYCLE.filter((k) => k in json);
+  if (beside.length > 0)
+    return err(
+      `"${beside.join('", "')}" beside "cycles": with cycles, ${beside.length === 1 ? "it is" : "they are"} the current attempt's and cannot be set here — move the value into the open cycle`,
+    );
+  const cycles = cyclesOf(list.value);
+  return cycles.ok ? cycles : err(cycleProblemText(cycles.error));
+}
+
+/**
+ * The current attempt's venue, kind and submission, as the flat keys every reader takes. An accepted
+ * attempt keeps them: the camera-ready and the talk are judged against the venue that accepted.
+ */
+function derived(
+  cycles: Cycles,
+): Pick<PaperSettings, (typeof DERIVED_FROM_CYCLE)[number]> {
+  const c = venueCycleOf(cycles.current);
+  if (c === null) return { extends: null, kind: null, submission: null };
+  return {
+    extends: c.venue.kind === "preset" ? c.venue.extends : null,
+    kind: c.kind,
+    submission: c.submission,
+  };
+}
+
+/** The keys that may not be in a paper's file: unknown ones, and the project's. */
+function refusedKeys(
+  json: Readonly<Record<string, unknown>>,
+): Result<Readonly<Record<string, unknown>>, string> {
   const unknown = Object.keys(json).filter((k) => !KNOWN.includes(k));
   if (unknown.length > 0)
     return err(
       `unknown key "${String(unknown[0])}" — known keys: ${KNOWN.join(", ")}`,
     );
   const project = Object.keys(json).filter((k) => ROOT_ONLY_KEYS.includes(k));
-  if (project.length > 0)
-    return err(
-      `"${String(project[0])}" is a project setting — set it in the root ${CONFIG_FILE}, not in a paper's`,
-    );
+  return project.length > 0
+    ? err(
+        `"${String(project[0])}" is a project setting — set it in the root ${CONFIG_FILE}, not in a paper's`,
+      )
+    : ok(json);
+}
+
+/** The parsed JSON of `paperlint.json` → the settings, or one line saying what is wrong. Pure. */
+export function parsePaperSettings(
+  json: unknown,
+): Result<PaperSettings, string> {
+  if (!isObject(json)) return err("must be a JSON object");
+  const keys = refusedKeys(json);
+  if (!keys.ok) return keys;
   const fields = stringFields(json);
   if (!fields.ok) return fields;
   const identity = identityField(json);
   if (!identity.ok) return identity;
   const rest = rulesAndTalk(json);
   if (!rest.ok) return rest;
-  return ok({ ...fields.value, ...rest.value, identity: identity.value });
+  const cycles = cyclesField(json);
+  if (!cycles.ok) return cycles;
+  const flat = {
+    ...fields.value,
+    ...rest.value,
+    identity: identity.value,
+    cycles: cycles.value,
+  };
+  return ok(
+    cycles.value === null ? flat : { ...flat, ...derived(cycles.value) },
+  );
 }
 
 /** A JSON file through `files`: undefined when absent, the problem when it does not parse. */
@@ -251,6 +323,7 @@ function merge(
     rules: null,
     talk: null,
     submission: null,
+    cycles: null,
   };
   const merged: PaperSettings = {
     extends: p.extends ?? r.extends,
@@ -260,6 +333,7 @@ function merge(
     identity: joined(r.identity, p.identity),
     talk: p.talk,
     submission: p.submission,
+    cycles: p.cycles,
   };
   return paper === null && Object.values(merged).every((v) => v === null)
     ? null

package/src/ports/venue-deadlines.ts

@@ -0,0 +1,14 @@
+/**
+ * A venue's deadlines as its portal publishes them — the port the scheduled refresh of the shipped
+ * presets reads through (`scripts/refresh-deadlines.ts`). Shaped by what the refresh needs (the
+ * portal's deadlines, once), not by any portal's page; one adapter per portal kind
+ * (`src/adapters/hotcrp/`).
+ */
+import type { Result } from "../domain/result.ts";
+import type { PortalDeadlines } from "../domain/deadline.ts";
+import type { PortalFailure } from "../domain/submission.ts";
+
+export interface VenueDeadlines {
+  /** The deadlines the portal publishes now. Needs no account: the page is public. */
+  read(): Promise<Result<PortalDeadlines, PortalFailure>>;
+}

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,57 @@ 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",
+    });
+    // The portal's deadlines, read 2026-10-05 off cassette/deadlines-msr2027.html's page.
+    expect(r.value.deadlines).toEqual([
+      {
+        what: "submission",
+        at: "2026-10-20T04:00:00Z",
+        source: "portal",
+        url: "https://msr2027.hotcrp.com/deadlines",
+        read: "2026-10-05",
+      },
+      {
+        what: "resubmission",
+        at: "2026-10-23T04:00:00Z",
+        source: "portal",
+        url: "https://msr2027.hotcrp.com/deadlines",
+        read: "2026-10-05",
+      },
+    ]);
+    // 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 +190,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",
@@ -287,6 +343,94 @@ describe("a project's own preset: what its children replace", () => {
   });
 });
 
+describe("a project's own preset: its deadlines", () => {
+  const reading = (what: string, at: string, source = "portal") => ({
+    what,
+    at,
+    source,
+    url: "https://example.org/deadlines",
+    read: "2026-10-05",
+  });
+
+  it("a child's deadlines replace its parent's whole; none named keeps the parent's", () => {
+    const own = resolve("./mine.jsonc", {
+      "/work/papers/p/mine.jsonc": venue({
+        extends: "paperlint:msr",
+        deadlines: [reading("submission", "2026-10-21T04:00:00Z")],
+      }),
+    });
+    expect(own.ok && own.value.deadlines).toEqual([
+      reading("submission", "2026-10-21T04:00:00Z"),
+    ]);
+    const inherited = resolve("./mine.jsonc", {
+      "/work/papers/p/mine.jsonc": venue({ extends: "paperlint:msr" }),
+    });
+    expect(inherited.ok && inherited.value.deadlines.length).toBe(2);
+    const none = resolve("./mine.jsonc", {
+      "/work/papers/p/mine.jsonc": venue({ extends: "paperlint:aisec" }),
+    });
+    expect(none.ok && none.value.deadlines).toEqual([]);
+  });
+
+  it("the portal's and the call's reading of one kind may stand side by side", () => {
+    const r = resolve("./mine.jsonc", {
+      "/work/papers/p/mine.jsonc": venue({
+        extends: "paperlint:aisec",
+        deadlines: [
+          reading("submission", "2026-10-20T04:00:00Z"),
+          reading("submission", "2026-10-21T11:59:59Z", "call"),
+        ],
+      }),
+    });
+    expect(r.ok && r.value.deadlines.map((d) => d.source)).toEqual([
+      "portal",
+      "call",
+    ]);
+  });
+});
+
+describe("a project's own preset: deadlines it refuses", () => {
+  const reading = (what: string, at: string, source = "portal") => ({
+    what,
+    at,
+    source,
+    url: "https://example.org/deadlines",
+    read: "2026-10-05",
+  });
+
+  it.each([
+    [
+      "two readings of one kind from one source",
+      [
+        reading("submission", "2026-10-20T04:00:00Z"),
+        reading("submission", "2026-10-21T04:00:00Z"),
+      ],
+      /"deadlines" holds two "portal" readings of "submission" — keep one, the latest/,
+    ],
+    [
+      "an instant that is not UTC as a portal publishes it",
+      [reading("submission", "2026-10-20 AoE")],
+      /deadlines/,
+    ],
+    [
+      "a reading without the day it was read",
+      [{ ...reading("submission", "2026-10-20T04:00:00Z"), read: undefined }],
+      /deadlines/,
+    ],
+  ])("refuses %s, naming the file", (_what, deadlines, re) => {
+    const r = resolve("./mine.jsonc", {
+      "/work/papers/p/mine.jsonc": venue({
+        extends: "paperlint:aisec",
+        deadlines,
+      }),
+    });
+    expect(r.ok).toBe(false);
+    if (r.ok) return;
+    expect(presetProblemText(r.error)).toMatch(/mine\.jsonc/);
+    expect(presetProblemText(r.error)).toMatch(re);
+  });
+});
+
 describe("what does not resolve, and says why", () => {
   it.each([
     [
@@ -300,7 +444,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 +566,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 +616,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 +638,7 @@ describe("shippedVenueNames — what each shipped venue is called", () => {
       "AIDC",
       "AISec",
       "ieee-conference",
+      "MSR",
     ]);
   });
 });