paperlint 7.1.0 → 7.2.0

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/presets.test.ts

@@ -103,6 +103,23 @@ describe("shipped presets: paperlint:msr", () => {
       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([]);
@@ -326,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([
     [

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, with its `template_forbids`; 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:";
@@ -123,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. */
@@ -293,8 +299,24 @@ 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,
@@ -308,7 +330,6 @@ const mergeOne = (
   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),
   rules: { ...acc.rules, ...p.rules },
@@ -316,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. */
@@ -457,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>>;
@@ -476,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" } },
   });
@@ -534,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"],
+  ]);
+});