paperlint 10.4.1 → 11.0.0

package/docs/submission.md

@@ -1,73 +1,72 @@
 # The submission on the venue's portal
 
-`paperlint submission` reads and updates a paper's submission on the venue's submission portal,
-through the portal's API. Only [HotCRP](https://github.com/kohler/hotcrp) is supported.
+`paperlint submission` creates, reads and updates a paper's submission on the venue's submission
+portal. Only [HotCRP](https://github.com/kohler/hotcrp) is supported; any other portal is refused
+with `portal kind "<kind>" is not supported; upload by hand`.
 
 ```sh
+npx paperlint submission new papers/my-paper              # a dry run: the portal checks it and keeps nothing
+npx paperlint submission new papers/my-paper --save       # creates the real submission
 npx paperlint submission show papers/my-paper
-npx paperlint submission update papers/my-paper                 # a dry run: nothing is saved
-npx paperlint submission update papers/my-paper --save          # changes the real submission
+npx paperlint submission update papers/my-paper           # a dry run
+npx paperlint submission update papers/my-paper --save    # changes the real submission
 ```
 
 ## What it needs
 
-Two keys, each in the file that owns the fact, and a token:
+| where                        | key                                                  | what it says                                                          |
+| ---------------------------- | ---------------------------------------------------- | --------------------------------------------------------------------- |
+| the venue preset             | `"portal": { "kind": "hotcrp", "url": "https://…" }` | where the venue takes submissions (`paperlint:aidc`, `paperlint:msr`) |
+| the paper's `paperlint.json` | `"authors": [{ "name", "email", "affiliation"? }]`   | for `new`: every author, in the paper's order — never guessed         |
+| the paper's `paperlint.json` | `"submission": { "id": 7 }`                          | which submission is this paper's — `new --save` writes it             |
+| the environment              | `HOTCRP_TOKEN_<SITE>`, e.g. `HOTCRP_TOKEN_MSR2027`   | your API token for that site                                          |
 
-| where                        | key                                                  | what it says                                    |
-| ---------------------------- | ---------------------------------------------------- | ----------------------------------------------- |
-| the venue preset             | `"portal": { "kind": "hotcrp", "url": "https://…" }` | where the venue takes submissions               |
-| the paper's `paperlint.json` | `"submission": { "id": 7 }`                          | which submission on that portal is this paper's |
-| the environment              | `HOTCRP_TOKEN`                                       | an API token for your HotCRP account            |
+**The token** works on the site it was made on only, so each site has its own variable:
+`HOTCRP_TOKEN_MSR2027` for `msr2027.hotcrp.com`; for a site not on hotcrp.com, its whole host
+(with a port other than the default) and path, every other character becoming `_`, so two paths
+on one host that differ only in punctuation (`/conf-a`, `/conf/a`) share one variable. A plain
+`HOTCRP_TOKEN` is not read. When the token is missing, misnamed or refused, the command prints
+where on that site to make one, which permissions to tick, and the exact variable to set. Set it
+in your environment — never paste it into a chat; paperlint never prints it.
 
-`paperlint:aidc` and `paperlint:msr` declare their portals. For another venue, add `portal` to your own preset (see
-[`rules.md`](rules.md)) — or upload by hand: a kind paperlint has no adapter for is refused with
-`portal kind "<kind>" is not supported; upload by hand`.
+A missing key or token stops the command with exit 2 and a line naming what to set.
 
-```jsonc
-// papers/my-paper/paperlint.json
-{ "extends": "paperlint:aidc", "kind": "regular", "submission": { "id": 7 } }
-```
+## `new`
 
-**The token** is read only from `HOTCRP_TOKEN`. Create it on the HotCRP site under **Account
-settings → Developer**; `show` needs the scopes `submeta:read` and `document:read`, `update` also
-`submeta:write` and `document:write`. paperlint sends it as `Authorization: bearer <token>` and
-never prints it or writes it anywhere.
+Creates the submission and sends four things, printing them first — the abstract in full:
 
-A missing key or token stops the command with exit 2 and a line naming the file and key, or the
-variable, to set.
+- **the title** — the paper's `\title`; when it holds a command of your own, the PDF's title;
+- **the abstract** — `\begin{abstract}…\end{abstract}` as plain text: your argument-less macros
+  expanded, dashes and quotes as TeX sets them, citations and comments dropped. Anything it cannot
+  read without guessing stops the command with the macro and its line; then pass
+  `--abstract <file>`, plain text;
+- **the authors** — from `"authors"`; without it, `new` stops and names the key;
+- **the PDF** — the paper's own, or `--pdf <file>`.
 
-## `show`
+Without `--save` it is a dry run. With `--save` the new id is written into `paperlint.json` (the
+open cycle, with `cycles`), and the next command is `show`. Every run prints what is left to do on
+the site (conflicts, topics, the venue's own fields). `new` is refused when the paper already has a
+submission id.
 
-Prints the submission's status (and when it was submitted), its id, title, paper type, topics, the
-abstract's length in words, and the PDF the portal holds — its hash, size and upload time — then
-whether that PDF is the local one: HotCRP stores a PDF's sha256 as `sha2-<hex>`, and paperlint
-compares it with the sha256 of the paper's `paper.pdf` (or its `pdf` setting, or `--pdf <file>`).
-`match yes` means the portal holds exactly the file you built. Exit 0 whenever the portal answered.
+## `show`
 
-Then one `deadline` line per deadline in force for the current attempt — the venue preset's portal
-readings with the paper's own call readings and overrides over them ([Deadlines](configuration.md#deadlines)):
-the instant that binds, what set it (a reading and the day it was read, or an override with its
-reason and evidence), and the other readings of it. Instants only; how long is left is not printed.
+Prints the submission's status, title, type, topics, abstract length and the PDF the portal holds,
+then `match`: `yes` means the portal holds exactly the PDF you built (compared by sha256). Then the
+deadlines in force for the current attempt, each with when and where it was read
+([Deadlines](configuration.md#deadlines)). Exit 0 whenever the portal answered.
 
 ## `update`
 
-Sends the PDF — the paper's own unless `--pdf <file>` names another — and, when asked, a new
-abstract (`--abstract <file>`, plain text) and the status "submitted" (`--submit`).
-
-**Without `--save` it is a dry run**: HotCRP's `dry_run=1` checks the change and keeps nothing. With
-`--save` the real submission changes. Either way it prints HotCRP's verdict — `valid`, the fields the
-change touched (`change_list`), HotCRP's messages — and the local file's sha256. Exit 1 when the
-change is not valid or the HTTP status is not 2xx.
-
-Before it sends anything, dry run or not, it prints one line asking you to open that exact PDF and
-check it against the venue's call for papers — named by the preset's `url` when the preset is a
-venue: what paperlint checks is an aid, and the venue's reading of the PDF is what counts.
+Sends the PDF and, when asked, a new abstract (`--abstract <file>`) and "submitted" (`--submit`).
+Without `--save` it is a dry run. It prints the portal's verdict and its messages; exit 1 when the
+portal would not take the change. Before sending, it asks you to open that exact PDF and check it
+against the venue's call for papers.
 
-The safe order: `show`, `update` (dry run), read what it says, `update --save`, then `show` again and
-check `match yes`.
+The safe order: `new`, `new --save` once; then `show`, `update`, `update --save`, and `show` again
+until it says `match yes`. Every `--save` comes after the author has read the dry run and said yes.
 
 ## What it does not do
 
-- It does not create a submission, edit authors, topics or other form fields, or upload
-  supplementary files.
+- It does not set conflicts, topics or the venue's other fields, change the authors after `new`, or
+  upload supplementary files.
 - It does not check the PDF against the venue; that is `paperlint lint`.

package/eslint.config.mjs

@@ -225,7 +225,10 @@ export const TOOL_PACKAGES = [
   "@eslint/plugin-kit",
   "@retorquere/bibtex-parser", // BibTeX
   "@unified-latex/unified-latex-types", // LaTeX
+  "@unified-latex/unified-latex-util-ligatures",
+  "@unified-latex/unified-latex-util-macros",
   "@unified-latex/unified-latex-util-parse",
+  "@unified-latex/unified-latex-util-replace",
   "@unified-latex/unified-latex-util-visit",
   "ajv", // JSON Schema
   "eslint",

package/lib/paper-config.ts

@@ -138,11 +138,13 @@ export const SETTINGS_KEYS: Readonly<Record<string, string>> = Object.freeze({
   pdf: "where the built PDF is, relative to the paper, when it is not paper.pdf — the facts",
   identity:
     "what identifies the authors — names, handles, emails, affiliations, own project names; a blind venue's PDF must not say any of them — anonymity/identity. The root's list and a paper's are joined",
-  talk: 'how this paper is presented: { "mode": "remote-video", "dir"?, "files"?, "one_slide"? } — the talk/ rules. A paper\'s own; refused in the root file',
+  talk: 'how this paper is presented: { "mode": "remote-video", "dir"?, "files"?, "one_slide"? } — the talk/ rules. Set only in a paper\'s own paperlint.json; in the root paperlint.json it is an error',
   submission:
-    "which submission on the venue's portal is this paper's: { \"id\": <number> } — paperlint submission, with the preset's \"portal\". A paper's own; refused in the root file",
+    "which submission on the venue's portal is this paper's: { \"id\": <number> } — paperlint submission, with the preset's \"portal\". Set only in a paper's own paperlint.json; in the root paperlint.json it is an error",
+  authors:
+    'the authors as the venue\'s portal should record them, in order: [{ "name", "email", "affiliation"? }] — paperlint submission new. Set only in a paper\'s own paperlint.json; in the root paperlint.json it is an error',
   cycles:
-    "the paper's attempts at venues, oldest first: [{ id, venue, kind, opened, phase?, deadlines, submission?, outcome }] — extends, kind and submission are then the current attempt's, and the cycle/ rules judge the record. A paper's own; refused in the root file",
+    "the paper's attempts at venues, oldest first: [{ id, venue, kind, opened, phase?, deadlines, submission?, outcome }] — extends, kind and submission are then the current attempt's, and the cycle/ rules judge the record. Set only in a paper's own paperlint.json; in the root paperlint.json it is an error",
   scripts: "how skill prose names the scripts — consumer.mjs",
   timezone: "the zone deadline anchors are written in — consumer.mjs",
   contactEmail: "the polite-pool address for citation lookups — consumer.mjs",
@@ -151,10 +153,11 @@ export const SETTINGS_KEYS: Readonly<Record<string, string>> = Object.freeze({
   $comment: "a note for humans (JSON Schema's own comment keyword); ignored",
 });
 
-/** The keys that only mean something for one paper: refused in the root `paperlint.json`. */
+/** The keys that only mean something for one paper: an error in the root `paperlint.json`. */
 export const PAPER_ONLY_KEYS: readonly string[] = Object.freeze([
   "talk",
   "submission",
+  "authors",
   "cycles",
 ]);
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "paperlint",
-  "version": "10.4.1",
+  "version": "11.0.0",
   "description": "A linter for scientific papers written in LaTeX: catches mistakes before you submit to a conference or journal.",
   "type": "module",
   "license": "MIT",
@@ -15,6 +15,7 @@
     "coverage": "NODE_OPTIONS=\"--import=./test/coverage-src.ts $NODE_OPTIONS\" c8 --check-coverage npm test --",
     "lint": "eslint .",
     "check": "node scripts/check.ts",
+    "refresh-deadlines": "node --conditions=paperlint-source scripts/refresh-deadlines/main.ts",
     "fmt": "prettier --write .",
     "fmt:check": "prettier --check ."
   },
@@ -23,7 +24,10 @@
     "@eslint/plugin-kit": "^0.7.2",
     "@retorquere/bibtex-parser": "^10.0.1",
     "@unified-latex/unified-latex-types": "^1.8.4",
+    "@unified-latex/unified-latex-util-ligatures": "^1.8.4",
+    "@unified-latex/unified-latex-util-macros": "^1.8.4",
     "@unified-latex/unified-latex-util-parse": "^1.8.4",
+    "@unified-latex/unified-latex-util-replace": "^1.8.4",
     "@unified-latex/unified-latex-util-visit": "^1.8.4",
     "ajv": "^6.12.6",
     "eslint": "^10.9.1",
@@ -52,6 +56,7 @@
     "eslint-plugin-n": "^18.3.0",
     "eslint-plugin-project-structure": "^3.14.5",
     "eslint-plugin-sonarjs": "^4.2.1",
+    "jsonc-parser": "^3.3.1",
     "prettier": "^3.8.1",
     "semantic-release": "25.0.9",
     "typescript-eslint": "^8.70.1",

package/presets/msr.jsonc

@@ -38,23 +38,25 @@
   "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",
     },
   ],
 

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