paperlint 10.4.0 → 11.0.0

package/presets/msr.md

@@ -23,16 +23,20 @@ whereas last year it was ACM format.»), and limits and dates change between edi
   2027-01-08; camera-ready 2027-01-26. The call's prose names the weekdays «Mon, 20 Oct 2026» and
   «Thurs, 23 Oct 2026», its date table «Tue 20 Oct 2026» and «Fri 23 Oct 2026»; the calendar sides
   with the table (2026-10-20 is a Tuesday).
-- 🔴 **The portal closes earlier than the call says.** Read 2026-10-05 on
-  `https://msr2027.hotcrp.com/deadlines`: «Submission deadline: Tuesday Oct 20, 2026, 12 AM EDT»
-  (`"sub":1792468800`, 2026-10-20 04:00 UTC) and «Resubmission deadline: Friday Oct 23, 2026, 12 AM
-  EDT» («Completed submissions may be updated until this deadline»). Midnight EDT at the start of
-  each day is about a day and a half before the end of that day AoE. The portal is what refuses the
-  upload: plan for its times. The preset carries them as `deadlines` (`source: "portal"`, with the
-  day read), refreshed by paperlint's scheduled workflow when the portal changes them; a paper whose
-  current cycle names `paperlint:msr` derives them. Recording the call's days in the paper's own
-  cycle maps «abstract» to `registration` and «paper» to `submission` — and the portal's earlier
-  `submission` is then the one in force.
+- 🔴 **The portal's submission deadline is the call's ABSTRACT day, not its paper day.** Read
+  2026-10-19 18:05 UTC on `https://msr2027.hotcrp.com/deadlines`: «Submission deadline: Wednesday
+  Oct 21, 2026, 7:59:59 AM EDT — Submissions must be completed by this deadline to be reviewed»
+  (`"sub":1792583999`, 2026-10-21 11:59:59 UTC, the end of 2026-10-20 AoE) and «Resubmission
+  deadline: Saturday Oct 24, 2026, 7:59:59 AM EDT — Completed submissions may be updated until this
+  deadline» (2026-10-24 11:59:59 UTC, the end of 2026-10-23 AoE). So a submission must be complete
+  by the abstract day, and the paper day is the last day to update it. The reading of 2026-10-05
+  was earlier on both («Tuesday Oct 20, 2026, 12 AM EDT», `"sub":1792468800`, and «Friday Oct 23,
+  2026, 12 AM EDT»): the portal moved them. The portal is what refuses the upload: plan for its
+  times. The preset carries them as `deadlines` (`source: "portal"`, with the day read), refreshed
+  by paperlint's scheduled workflow when the portal changes them; a paper whose current cycle names
+  `paperlint:msr` derives them. Recording the call's days in the paper's own cycle maps «abstract»
+  to `registration` and «paper» to `submission` — and the portal's `submission`, at the end of the
+  abstract day, is then the one in force.
 - **Format**, verbatim from the call: «LaTeX users must use \documentclass[10pt,conference]{IEEEtran}
   without including the compsoc or compsocconf options», «title in 24pt font and full text in 10pt
   type», and «Alterations of spacing, font size, and other changes that deviate from the

package/scripts/check.ts

@@ -213,7 +213,7 @@ export const NOT_COVERED: Readonly<Record<string, string>> = {
   refresh:
     "deadlines.yml reads the venue presets' portals over the network once a day and opens a pull " +
     "request when a deadline moved; npm test replays the recorded portal pages through " +
-    "scripts/refresh-deadlines.test.ts, and nothing local should read the live portals on every check.",
+    "scripts/refresh-deadlines/main.test.ts, and nothing local should read the live portals on every check.",
 };
 
 /**

package/scripts/refresh-deadlines/compare.test.ts

@@ -0,0 +1,75 @@
+/** A preset's portal readings against the page: kept, rewritten, added, noted — a call's never touched. */
+import { describe, expect, test } from "vitest";
+import { refreshReadings } from "./compare.ts";
+
+const reading = (
+  what: "submission" | "resubmission" | "camera-ready",
+  at: string,
+  source: "portal" | "call" = "portal",
+) => ({
+  what,
+  at,
+  source,
+  url: "https://x.example/deadlines",
+  read: "2026-10-01",
+});
+const page = (
+  deadlines: readonly {
+    what: "submission" | "camera-ready" | null;
+    at: string;
+  }[],
+) => ({
+  now: 1,
+  open: true,
+  blind: true,
+  deadlines: deadlines.map((d) => ({ ...d, label: String(d.what) })),
+});
+
+describe("refreshReadings — what the page says, over what the preset said", () => {
+  test("a reading the portal no longer lists is kept and noted; a call's reading is never touched", () => {
+    const r = refreshReadings(
+      [
+        reading("submission", "2026-10-21T11:59:59Z"),
+        reading("submission", "2026-10-21T11:59:59Z", "call"),
+        reading("camera-ready", "2026-12-01T00:00:00Z"),
+      ],
+      page([{ what: "submission", at: "2026-10-21T11:59:59Z" }]),
+      "https://x.example/deadlines",
+      "2026-10-06",
+    );
+    expect(r.changes).toEqual([]);
+    expect(r.notes).toEqual([
+      "camera-ready: no longer on the page — kept as read 2026-10-01",
+    ]);
+    expect(r.readings).toEqual([
+      reading("submission", "2026-10-21T11:59:59Z"),
+      reading("submission", "2026-10-21T11:59:59Z", "call"),
+      reading("camera-ready", "2026-12-01T00:00:00Z"),
+    ]);
+  });
+
+  test("a kind the page lists twice binds at the earlier instant; a label paperlint names no kind for is left out", () => {
+    const r = refreshReadings(
+      [],
+      page([
+        { what: "submission", at: "2026-10-22T04:00:00Z" },
+        { what: "submission", at: "2026-10-21T11:59:59Z" },
+        { what: null, at: "2026-09-01T00:00:00Z" },
+      ]),
+      "https://x.example/deadlines",
+      "2026-10-06",
+    );
+    expect(r.readings).toEqual([
+      {
+        what: "submission",
+        at: "2026-10-21T11:59:59Z",
+        source: "portal",
+        url: "https://x.example/deadlines",
+        read: "2026-10-06",
+      },
+    ]);
+    expect(r.notes).toEqual([
+      "submission: the page lists 2026-10-21T11:59:59Z, 2026-10-22T04:00:00Z — the earliest is recorded",
+    ]);
+  });
+});

package/scripts/refresh-deadlines/compare.ts

@@ -0,0 +1,101 @@
+/**
+ * A PRESET'S PORTAL READINGS AGAINST WHAT THE PORTAL'S PAGE SAYS NOW — the comparison the scheduled
+ * refresh of the shipped presets makes (`main.ts` beside this file). Pure.
+ *
+ *   a kind the page lists at the instant the preset holds   kept as it is, its `read` day too
+ *   a kind the page lists at another instant                rewritten, `read` = today
+ *   a kind the page lists that the preset does not hold     added, `read` = today
+ *   a kind the preset holds that the page no longer lists   KEPT and noted — a portal may drop a
+ *                                                           passed deadline; the reading stays true
+ *   a reading from the call                                 never touched: it is not the portal's
+ */
+import {
+  DEADLINE_WHATS,
+  type DeadlineWhat,
+  type IsoDate,
+  type PortalDeadlines,
+  type Reading,
+} from "#src/domain/deadline";
+
+/** The preset's readings after the page's answer, what changed, and what is worth a note. */
+export interface Refreshed {
+  readonly readings: readonly Reading[];
+  readonly changes: readonly string[];
+  readonly notes: readonly string[];
+}
+
+/** The page's instants for one kind, earliest first. */
+const pageAts = (
+  page: PortalDeadlines,
+  what: DeadlineWhat,
+): readonly string[] =>
+  page.deadlines
+    .filter((d) => d.what === what)
+    .map((d) => d.at)
+    .toSorted();
+
+/** A kind the page does not list: the preset's reading, if it holds one, is kept and noted. */
+const offThePage = (
+  what: DeadlineWhat,
+  held: Reading | undefined,
+): Refreshed =>
+  held === undefined
+    ? { readings: [], changes: [], notes: [] }
+    : {
+        readings: [held],
+        changes: [],
+        notes: [`${what}: no longer on the page — kept as read ${held.read}`],
+      };
+
+/** One kind: the preset's portal reading against the page's. */
+function oneKind(
+  what: DeadlineWhat,
+  held: Reading | undefined,
+  ats: readonly string[],
+  o: { readonly url: string; readonly today: IsoDate },
+): Refreshed {
+  const notes =
+    ats.length > 1
+      ? [`${what}: the page lists ${ats.join(", ")} — the earliest is recorded`]
+      : [];
+  const at = ats[0];
+  if (at === undefined) return offThePage(what, held);
+  if (held?.at === at) return { readings: [held], changes: [], notes };
+  const fresh: Reading = {
+    what,
+    at,
+    source: "portal",
+    url: o.url,
+    read: o.today,
+  };
+  const change =
+    held === undefined ? `${what}: added ${at}` : `${what}: ${held.at} → ${at}`;
+  return { readings: [fresh], changes: [change], notes };
+}
+
+/**
+ * The preset's readings after the portal answered `page` at `url` on `today`. The call's readings
+ * are kept as they are; the portal's are kept, rewritten or added kind by kind. Pure.
+ */
+export function refreshReadings(
+  current: readonly Reading[],
+  page: PortalDeadlines,
+  url: string,
+  today: IsoDate,
+): Refreshed {
+  const perKind = DEADLINE_WHATS.map((what) => {
+    const portal = oneKind(
+      what,
+      current.find((r) => r.what === what && r.source === "portal"),
+      pageAts(page, what),
+      { url, today },
+    );
+    const call = current.filter((r) => r.what === what && r.source === "call");
+    return { ...portal, readings: [...portal.readings, ...call] };
+  });
+  return {
+    readings: perKind.flatMap((k) => k.readings),
+    changes: perKind.flatMap((k) => k.changes),
+    notes: perKind.flatMap((k) => k.notes),
+  };
+}

package/scripts/refresh-deadlines/main.test.ts

@@ -0,0 +1,140 @@
+/**
+ * The entry of the scheduled refresh: the npm script the workflow runs, end to end, and the
+ * command line and files main.ts hands the logic.
+ */
+import { execFile } from "node:child_process";
+import {
+  mkdtempSync,
+  readFileSync,
+  realpathSync,
+  writeFileSync,
+} from "node:fs";
+import {
+  createServer,
+  type IncomingMessage,
+  type ServerResponse,
+} from "node:http";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { promisify } from "node:util";
+import { afterAll, beforeAll, describe, expect, test } from "vitest";
+import { parsePreset } from "#src/tex-requirements";
+import { argsOf, presetsIn, summaryTo } from "./main.ts";
+
+const ROOT = dirname(dirname(dirname(fileURLToPath(import.meta.url))));
+const PRESETS = join(ROOT, "presets");
+const CASSETTE = join(ROOT, "src", "adapters", "hotcrp", "cassette");
+const MSR = join(PRESETS, "msr.jsonc");
+const msrText = readFileSync(MSR, "utf8");
+const readings = (text: string) => parsePreset(text, MSR).deadlines ?? [];
+/** MSR with its submission deadline two days before the portal's. */
+const earlier = msrText.replace(
+  '"at": "2026-10-21T11:59:59Z"',
+  '"at": "2026-10-19T04:00:00Z"',
+);
+const tempDir = (prefix: string) =>
+  realpathSync(mkdtempSync(join(tmpdir(), prefix)));
+
+const MSR_HTML = readFileSync(join(CASSETTE, "deadlines-msr2027.html"), "utf8");
+const server = createServer((req: IncomingMessage, res: ServerResponse) => {
+  const ok = req.url === "/msr/deadlines";
+  res.writeHead(ok ? 200 : 404, { "content-type": "text/html" });
+  res.end(ok ? MSR_HTML : '<h1 id="h-title">No such conference</h1>');
+});
+const base = { url: "" };
+beforeAll(async () => {
+  await new Promise<void>((r) => server.listen(0, "127.0.0.1", r));
+  const a = server.address();
+  base.url = `http://127.0.0.1:${String(typeof a === "object" && a !== null ? a.port : 0)}`;
+});
+afterAll(
+  () =>
+    new Promise<void>((r) =>
+      server.close(() => {
+        r();
+      }),
+    ),
+);
+
+// The one end-to-end test: main.ts's isMain block wires the real HotCRP adapter, run against the cassette.
+describe("`npm run refresh-deadlines`, the command the workflow runs — with no dist/", () => {
+  // A real `node` process: Node strips the types of the script and everything it imports cold —
+  // about a second alone, several on a loaded machine, past vitest's 5 s.
+  test(
+    "rewrites the moved deadline, reports the site it could not read, writes the summary — and exits 0",
+    { timeout: 60_000 },
+    async () => {
+      const dir = tempDir("deadlines-");
+      const atServer = (text: string, path: string) =>
+        text.split("https://msr2027.hotcrp.com").join(`${base.url}/${path}`);
+      writeFileSync(join(dir, "msr.jsonc"), atServer(earlier, "msr"));
+      writeFileSync(join(dir, "gone.jsonc"), atServer(msrText, "gone"));
+      writeFileSync(join(dir, "notes.md"), "not a preset\n");
+      const summary = join(dir, "summary.md");
+      // Asynchronously: the local server answers from THIS process, which a synchronous spawn blocks.
+      // The inherited NODE_OPTIONS are replaced by test/no-dist.ts, which refuses any module in
+      // `dist/` — the job installs with --ignore-scripts.
+      const r = await promisify(execFile)(
+        "npm",
+        [
+          "run",
+          "-s",
+          "refresh-deadlines",
+          "--",
+          "--presets",
+          dir,
+          "--summary",
+          summary,
+        ],
+        {
+          env: {
+            ...process.env,
+            NODE_OPTIONS: `--import ${join(ROOT, "test", "no-dist.ts")}`,
+          },
+          cwd: ROOT,
+        },
+      ); // rejects on a non-zero exit, with the output
+      expect(
+        readings(readFileSync(join(dir, "msr.jsonc"), "utf8"))[0]?.at,
+      ).toBe("2026-10-21T11:59:59Z");
+      expect(r.stdout).toMatch(
+        /^::warning title=deadlines::gone\.jsonc: could not read http:\/\/127\.0\.0\.1:\d+\/gone\/deadlines — the portal refused \(HTTP 404\): No such conference$/m,
+      );
+      expect(readFileSync(summary, "utf8")).toMatch(
+        /^- ⚠️ `gone\.jsonc`: could not read /m,
+      );
+    },
+  );
+});
+
+test("argsOf: the repository's presets and no summary by default; a flag without a value is no value", () => {
+  expect(argsOf([])).toEqual({ presets: PRESETS, summary: null });
+  expect(argsOf(["--presets", "/p", "--summary"])).toEqual({
+    presets: "/p",
+    summary: null,
+  });
+});
+
+test("presetsIn: the *.jsonc files of a directory, sorted, read and written there; summaryTo: a file, or nowhere", () => {
+  const dir = tempDir("presets-");
+  writeFileSync(join(dir, "b.jsonc"), "B");
+  writeFileSync(join(dir, "a.jsonc"), "A");
+  writeFileSync(join(dir, "notes.md"), "not a preset");
+  const p = presetsIn(dir);
+  p.write("a.jsonc", "A2");
+  summaryTo(join(dir, "s.md"))?.("body\n");
+  expect([
+    p.names,
+    p.read("a.jsonc"),
+    p.path("b.jsonc"),
+    readFileSync(join(dir, "s.md"), "utf8"),
+    summaryTo(null),
+  ]).toStrictEqual([
+    ["a.jsonc", "b.jsonc"],
+    "A2",
+    join(dir, "b.jsonc"),
+    "body\n",
+    null,
+  ]);
+});

package/scripts/refresh-deadlines/main.ts

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+/**
+ * `npm run refresh-deadlines [-- --presets <dir>] [-- --summary <file.md>]`, which
+ * .github/workflows/deadlines.yml runs from source (no `dist/`). The composition root: the command
+ * line, the files, the clock, and HotCRP's adapter plugged into the port `refresh.ts` reads.
+ */
+import { readdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { hotcrpDeadlines } from "#src/adapters/hotcrp/index";
+import { presetsDir } from "#src/package-dirs";
+import { isMain } from "../../skills/paper-pipeline/scripts/consumer.mjs";
+import { runRefresh, type PresetFiles } from "./refresh.ts";
+
+/** `--presets <dir>` and `--summary <file>`; a flag without a value is no value. */
+export function argsOf(argv: readonly string[]) {
+  const value = (flag: string): string | null =>
+    argv.includes(flag) ? (argv[argv.indexOf(flag) + 1] ?? null) : null;
+  return {
+    presets: value("--presets") ?? presetsDir(),
+    summary: value("--summary"),
+  };
+}
+
+/** The `*.jsonc` presets in `dir`, on disk. */
+export const presetsIn = (dir: string): PresetFiles => ({
+  names: readdirSync(dir)
+    .filter((f) => f.endsWith(".jsonc"))
+    .toSorted(),
+  read: (name) => readFileSync(join(dir, name), "utf8"),
+  write: (name, text) => {
+    writeFileSync(join(dir, name), text);
+  },
+  path: (name) => join(dir, name),
+});
+
+/** Where the pull request's body is written: the `--summary` file, or nowhere. */
+export const summaryTo = (path: string | null) =>
+  path === null
+    ? null
+    : (text: string) => {
+        writeFileSync(path, text);
+      };
+
+// `isMain`, not a comparison with `file://${argv[1]}`: that is false through a symlink (consumer.mjs).
+if (isMain(import.meta.url)) {
+  const args = argsOf(process.argv.slice(2));
+  process.exit(
+    await runRefresh({
+      presets: presetsIn(args.presets),
+      portal: (site) => hotcrpDeadlines({ url: site }),
+      today: new Date().toISOString().slice(0, 10), // the clock, read at the edge
+      log: console.log,
+      summary: summaryTo(args.summary),
+    }),
+  );
+}