paperlint 10.4.1 → 11.1.0

package/presets/msr.jsonc

@@ -38,26 +38,94 @@
   "portal": { "kind": "hotcrp", "url": "https://msr2027.hotcrp.com" },
 
   // Read from the portal's public deadlines page (no account) by the adapter in src/adapters/hotcrp/.
-  // «Submissions must be completed by this deadline» is the `submission`: on the CALL's abstract
-  // day, 04:00 UTC — four days before the call's paper day. «Completed submissions may be updated
-  // until this deadline» is the `resubmission`.
+  // «Submissions must be completed by this deadline» is the `submission`, «Completed submissions
+  // may be updated until this deadline» the `resubmission`. Read 2026-10-19 18:05 UTC: «Wednesday
+  // Oct 21, 2026, 7:59:59 AM EDT» (`"sub":1792583999`) and «Saturday Oct 24, 2026, 7:59:59 AM EDT»
+  // — the ends of the call's abstract and paper days AoE. The reading of 2026-10-05 was 04:00 UTC
+  // on the abstract and paper days themselves; the portal moved both later on or before 2026-10-19.
   "deadlines": [
     {
       "what": "submission",
-      "at": "2026-10-20T04:00:00Z",
+      "at": "2026-10-21T11:59:59Z",
       "source": "portal",
       "url": "https://msr2027.hotcrp.com/deadlines",
-      "read": "2026-10-05",
+      "read": "2026-10-19",
     },
     {
       "what": "resubmission",
-      "at": "2026-10-23T04:00:00Z",
+      "at": "2026-10-24T11:59:59Z",
       "source": "portal",
       "url": "https://msr2027.hotcrp.com/deadlines",
-      "read": "2026-10-05",
+      "read": "2026-10-19",
     },
   ],
 
+  // The fields msr2027's submission form asks beyond title, abstract, authors and the PDF, read
+  // 2026-10-20. The topics through the portal's API: `GET /api/searchcompletion` with an author's
+  // token lists 45 `topic:"…"` completions — these 41 and the 4 group names (DS/ML/AI Technique,
+  // Research Method, SE Topic, Software repository), which a submission cannot carry. Each of the 41
+  // was sent alone in a dry run of `POST /api/paper` and taken (`change_list` names `topics`); the
+  // bare subtopic «AI for software engineering» and the group «SE Topic» were dropped without an
+  // error. The form says «Select at least one topic». «ACM corresponding author» (`ACMCorAut`, listed
+  // by `/api/displayfields`) is a selector of the authors in the form; the API takes an author's
+  // email (a dry run with a name: «Format error»). `paperlint submission topics` re-reads the list.
+  "submission_fields": {
+    "source": "portal",
+    "url": "https://msr2027.hotcrp.com/api/searchcompletion",
+    "read": "2026-10-20",
+    "fields": {
+      "topics": {
+        "kind": "checkboxes",
+        "required": true,
+        "options": [
+          "DS/ML/AI Technique: Classical machine learning (e.g., regression, SVMs, nearest neighbour, decision trees, PCA, naive Bayes classifier, and k-means clustering)",
+          "DS/ML/AI Technique: Convolutional neural networks",
+          "DS/ML/AI Technique: LLM or other foundation models (e.g., large vision model)",
+          "DS/ML/AI Technique: Reinforcement learning",
+          "DS/ML/AI Technique: Transformers",
+          "Performance analysis and testing",
+          "Research Method: Controlled experiments with human subjects (e.g., A/B tests, lab studies)",
+          "Research Method: Qualitative analysis (e.g., thematic analysis, grounded theory)",
+          "Research Method: Statistical analysis and modelling",
+          "Research Method: Survey design and analysis",
+          "SE Topic: AI for software engineering",
+          "SE Topic: API design and evolution",
+          "SE Topic: App store analysis",
+          "SE Topic: Cloud-based and distributed systems",
+          "SE Topic: Debugging, fault localization, and fault prediction",
+          "SE Topic: DevOps and release engineering",
+          "SE Topic: Distributed and collaborative software engineering",
+          "SE Topic: Energy profiling",
+          "SE Topic: Ethical concerns (bias, fairness, explainability, etc.)",
+          "SE Topic: Human aspects",
+          "SE Topic: Legal aspects (licenses, copyright, etc.)",
+          "SE Topic: Privacy and security",
+          "SE Topic: Program comprehension",
+          "SE Topic: Recommender systems",
+          "SE Topic: Software development processes",
+          "SE Topic: Software ecosystems",
+          "SE Topic: Software engineering for AI",
+          "SE Topic: Software maintenance and evolution",
+          "SE Topic: Software measurement and analytics",
+          "SE Topic: Software quality assurance",
+          "SE Topic: Source / test code",
+          "SE Topic: Version control history logs",
+          "Software repository: App stores",
+          "Software repository: Archived communications (mailing lists, Gitter/Slack/Discord channels, etc.)",
+          "Software repository: Build / CI logs",
+          "Software repository: Code reviews",
+          "Software repository: Execution traces and logs",
+          "Software repository: Human interaction data",
+          "Software repository: Issue trackers / defect repositories",
+          "Software repository: Package registries / software releases",
+          "Software repository: Q&A websites",
+        ],
+      },
+      "pc_conflicts": { "kind": "pc_conflicts" },
+      "ACMCorAut": { "kind": "email", "label": "ACM corresponding author" },
+    },
+  },
+
   // What the venue is called in a paper's text (tex/venue-leftover) — and only beside a year
   // («MSR 2027», «MSR'27»): «MSR» is also Microsoft Research, and an acronym papers define for
   // themselves («Manual Speech Recognition (MSR)», in an accepted ACSAC paper of

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/presets/venue-profile.schema.json

@@ -117,6 +117,47 @@
         }
       }
     },
+    "submission_fields": {
+      "description": "The fields the edition's submission form asks beyond the title, the abstract, the authors and the PDF, as READ — where (`source`: `portal`, through the portal's API; `form`, copied from the form), from which page and on which day. Read by `paperlint submission`: a paper answers them in its paperlint.json `fields`, checked against these before anything is sent, so an option the form does not offer is refused here instead of dropped by the portal without a word. `fields` maps the portal API's key to its kind: `checkboxes` (a list of `options`, HotCRP's topics spelled \"Group: Topic\"), `text`, `email`, `pc_conflicts` (PC member's email → conflict type). `required`: the form does not complete without it. A child's value replaces its parent's.",
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["source", "url", "read", "fields"],
+      "properties": {
+        "source": { "type": "string", "enum": ["portal", "form"] },
+        "url": { "type": "string", "pattern": "^https?://[^\\s/]+[^\\s]*$" },
+        "read": {
+          "description": "The day the fields were read, YYYY-MM-DD.",
+          "type": "string",
+          "pattern": "^\\d{4}-\\d{2}-\\d{2}$"
+        },
+        "fields": {
+          "type": "object",
+          "minProperties": 1,
+          "additionalProperties": {
+            "type": "object",
+            "additionalProperties": false,
+            "required": ["kind"],
+            "properties": {
+              "kind": {
+                "type": "string",
+                "enum": ["checkboxes", "text", "email", "pc_conflicts"]
+              },
+              "required": { "type": "boolean" },
+              "label": { "type": "string", "minLength": 1 },
+              "options": {
+                "type": "array",
+                "minItems": 1,
+                "uniqueItems": true,
+                "items": { "type": "string", "minLength": 1 }
+              }
+            },
+            "if": { "properties": { "kind": { "const": "checkboxes" } } },
+            "then": { "required": ["options"] },
+            "else": { "not": { "required": ["options"] } }
+          }
+        }
+      }
+    },
     "required_sections": {
       "description": "Sections the venue requires, read by `tex/required-section`. Each is a `\\section` or `\\section*` whose title equals `title` once whitespace is collapsed. `position: \"last\"`: after every section of the body (the ones before the appendix and the bibliography); it may stand after the bibliography. A child preset's list replaces its parent's.",
       "type": "array",

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),
+    }),
+  );
+}