paperlint 11.1.0 → 11.1.1

package/.github/workflows/dependabot-automerge.yml

@@ -31,19 +31,29 @@ on:
     workflows: ["ci"]
     types: [completed]
 
-# Merge and delete branch — nothing else this workflow needs.
+# Merge and delete branch, then start release.yml — nothing else this workflow needs.
 permissions:
   contents: write
   pull-requests: write
+  actions: write
 
 jobs:
   merge:
-    # Three conditions, each blocking a case: the run was for a PR (not a push to main) ·
-    # the run is GREEN · the author is a bot, not a person. Remove any one and meaning changes.
+    # Three conditions, each blocking a case: the run is GREEN · it was for one of two bots' pull
+    # requests, never a person's · and that pull request is the bot's own. Remove any one and
+    # meaning changes. The two bots:
+    #   - Dependabot: its PR's `ci` is an ordinary `pull_request` run.
+    #   - the deadline refresh (deadlines.yml): a PR opened with GITHUB_TOKEN starts no workflow, so
+    #     deadlines.yml dispatches `ci` on its branch; that run is `workflow_dispatch` by
+    #     github-actions[bot] on `bot/preset-deadlines`, and GitHub still lists the PR in
+    #     `pull_requests` (measured on run 39489222900, PR #248).
     if: >
-      github.event.workflow_run.event == 'pull_request' &&
-      github.event.workflow_run.conclusion == 'success' &&
-      github.event.workflow_run.actor.login == 'dependabot[bot]'
+      github.event.workflow_run.conclusion == 'success' && (
+        (github.event.workflow_run.event == 'pull_request' &&
+         github.event.workflow_run.actor.login == 'dependabot[bot]') ||
+        (github.event.workflow_run.event == 'workflow_dispatch' &&
+         github.event.workflow_run.actor.login == 'github-actions[bot]' &&
+         github.event.workflow_run.head_branch == 'bot/preset-deadlines'))
     runs-on: ubuntu-latest
     timeout-minutes: 5
     steps:
@@ -68,3 +78,7 @@ jobs:
           fi
           gh pr merge "${PR}" --repo "${REPO}" --squash --delete-branch --match-head-commit "${HEAD_SHA}"
           echo "merged PR #${PR} on green ci run ${RUN_ID}"
+          # A merge made with GITHUB_TOKEN pushes to main without starting release.yml (GitHub's rule
+          # against loops), so a `fix(presets):` would never be released. Start it by hand; a
+          # `deps:` merge releases nothing either way, so the dispatch is harmless there.
+          gh workflow run release.yml --repo "${REPO}" --ref main

package/.github/workflows/release.yml

@@ -10,6 +10,16 @@ name: Release
 on:
   push:
     branches: [main]
+  # dependabot-automerge.yml merges with GITHUB_TOKEN, and such a push starts no workflow: it
+  # dispatches this one instead.
+  workflow_dispatch:
+
+# One release at a time: two runs started close together (a push and a dispatch, or two bot merges)
+# would both read the same last tag, and the one that loses the tag race leaves its merge
+# unreleased. A queued run reads every commit since the tag, so the last one in still releases all.
+concurrency:
+  group: release
+  cancel-in-progress: false
 
 permissions:
   contents: write

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "paperlint",
-  "version": "11.1.0",
+  "version": "11.1.1",
   "description": "A linter for scientific papers written in LaTeX: catches mistakes before you submit to a conference or journal.",
   "type": "module",
   "license": "MIT",

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

@@ -21,12 +21,15 @@ 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";
+import { FROZEN_DIR, frozenText } from "../../test/frozen-presets.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");
+// Frozen at the portal's reading of 2026-10-19 (test/frozen-presets.ts): the shipped file's dates
+// are the refresh's own output.
+const MSR = join(FROZEN_DIR, "msr.jsonc");
+const msrText = frozenText("msr.jsonc");
 const readings = (text: string) => parsePreset(text, MSR).deadlines ?? [];
 /** MSR with its submission deadline two days before the portal's. */
 const earlier = msrText.replace(

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

@@ -3,15 +3,15 @@
  * fake VenueDeadlines port that answers plain domain values (how HotCRP's page is parsed is
  * src/adapters/hotcrp/deadlines.test.ts's) and presets held in memory.
  */
-import { readdirSync, readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
+import { readdirSync } from "node:fs";
+import { join } from "node:path";
 import { describe, expect, test } from "vitest";
 import type { PortalDeadlines } from "#src/domain/deadline";
 import { err, ok, type Result } from "#src/domain/result";
 import type { PortalFailure } from "#src/domain/submission";
 import type { VenueDeadlines } from "#src/ports/venue-deadlines";
 import { parsePreset } from "#src/tex-requirements";
+import { FROZEN_DIR, frozenText } from "../../test/frozen-presets.ts";
 import {
   refreshPreset,
   runRefresh,
@@ -20,10 +20,11 @@ import {
   type PresetFiles,
 } from "./refresh.ts";
 
-const ROOT = dirname(dirname(dirname(fileURLToPath(import.meta.url))));
-const PRESETS = join(ROOT, "presets");
-const MSR = join(PRESETS, "msr.jsonc");
-const msrText = readFileSync(MSR, "utf8");
+// The logic is tested over presets FROZEN at the portal's reading of 2026-10-19 (test/frozen-presets.ts):
+// the shipped files' dates are the refresh's own output, and a test of the refresh that read them
+// would turn red on the refresh's own pull request.
+const MSR = join(FROZEN_DIR, "msr.jsonc");
+const msrText = frozenText("msr.jsonc");
 const readings = (text: string) => parsePreset(text, MSR).deadlines ?? [];
 /** MSR with its submission deadline two days before the portal's. */
 const earlier = msrText.replace(
@@ -39,12 +40,12 @@ function inMemory(files: Readonly<Record<string, string>>) {
     write: (name, text) => {
       written[name] = text;
     },
-    path: (name) => join(PRESETS, name),
+    path: (name) => join(FROZEN_DIR, name),
   };
   return { presets, written };
 }
 
-/** What MSR 2027's portal lists — the readings presets/msr.jsonc holds. */
+/** What MSR 2027's portal lists — the readings the frozen msr.jsonc holds. */
 const MSR_PAGE: PortalDeadlines = {
   now: 1792434476,
   open: true,
@@ -164,12 +165,12 @@ describe("refreshPreset on MSR 2027's page", () => {
 
 describe("refreshPreset — what it skips, and a portal it cannot read", () => {
   test("a preset without a portal, or with one paperlint has no adapter for, is skipped", async () => {
-    const aisec = join(PRESETS, "aisec.jsonc");
+    const aisec = join(FROZEN_DIR, "aisec.jsonc");
     const skipped = { kind: "skipped" };
     expect(
       await refreshPreset({
         file: aisec,
-        text: readFileSync(aisec, "utf8"),
+        text: frozenText("aisec.jsonc"),
         portal: answering(ok(MSR_PAGE)),
         today: "2026-10-05",
       }),
@@ -226,9 +227,9 @@ describe("runRefresh — what it prints, writes and returns", () => {
   test("nothing changed: one line, no preset written, exit 0", async () => {
     const { presets, written } = inMemory(
       Object.fromEntries(
-        readdirSync(PRESETS)
+        readdirSync(FROZEN_DIR)
           .filter((f) => f.endsWith(".jsonc"))
-          .map((f) => [f, readFileSync(join(PRESETS, f), "utf8")]),
+          .map((f) => [f, frozenText(f)]),
       ),
     );
     const lines: string[] = [];
@@ -241,7 +242,7 @@ describe("runRefresh — what it prints, writes and returns", () => {
     });
     expect([code, written]).toStrictEqual([0, {}]);
     expect(lines.at(-1)).toMatch(
-      /^✓ no deadline changed: 2 preset\(s\) with a portal read, \d+ skipped$/,
+      /^✓ no deadline changed: 2 preset\(s\) with a portal read, 1 skipped$/,
     );
   });
 

package/src/cycle-rules.test.ts

@@ -8,15 +8,23 @@ import { describe, expect, it } from "vitest";
 import { memoryFiles } from "./adapters/memory/index.ts";
 import { presetsDir } from "./package-dirs.ts";
 import { cycleRules } from "./cycle-rules.ts";
+import { frozenText } from "../test/frozen-presets.ts";
 
 const VENUES = presetsDir();
 const DIR = "/work/papers/p";
-/** The shipped presets, so a cycle naming `paperlint:msr` resolves through the memory files. */
-const SHIPPED = Object.fromEntries(
-  readdirSync(VENUES)
-    .filter((f) => f.endsWith(".jsonc"))
-    .map((f) => [join(VENUES, f), readFileSync(join(VENUES, f), "utf8")]),
-);
+/**
+ * The shipped presets, so a cycle naming `paperlint:msr` resolves through the memory files — msr
+ * FROZEN (test/frozen-presets.ts): its deadlines are rewritten by the scheduled refresh, and the
+ * tests below assert the readings they sit beside.
+ */
+const SHIPPED = {
+  ...Object.fromEntries(
+    readdirSync(VENUES)
+      .filter((f) => f.endsWith(".jsonc"))
+      .map((f) => [join(VENUES, f), readFileSync(join(VENUES, f), "utf8")]),
+  ),
+  [join(VENUES, "msr.jsonc")]: frozenText("msr.jsonc"),
+};
 
 interface Reported {
   readonly rule: string;

package/src/presets.test.ts

@@ -10,6 +10,7 @@ import { readdirSync, readFileSync } from "node:fs";
 import { join, relative } from "node:path";
 import { describe, expect, it } from "vitest";
 import { memoryFiles } from "./adapters/memory/index.ts";
+import { frozenText } from "../test/frozen-presets.ts";
 import { presetsDir } from "./package-dirs.ts";
 import { parsePreset } from "./tex-requirements.ts";
 import {
@@ -23,18 +24,27 @@ import {
 } from "./presets.ts";
 
 const VENUES = presetsDir();
-const shipped = Object.fromEntries(
+const live = Object.fromEntries(
   readdirSync(VENUES)
     .filter((f) => f.endsWith(".jsonc") || f.endsWith(".json"))
     .map((f) => [join(VENUES, f), readFileSync(join(VENUES, f))]),
 );
+// The shipped msr.jsonc's deadlines are rewritten by the scheduled refresh, so the tests of LOGIC
+// read it FROZEN (test/frozen-presets.ts); only the shape test below reads the shipped file.
+const shipped = {
+  ...live,
+  [join(VENUES, "msr.jsonc")]: frozenText("msr.jsonc"),
+};
 const PAPER_FILE = "/work/papers/p/paperlint.json";
-const deps = (extra: Record<string, string> = {}) => ({
-  files: memoryFiles({ ...shipped, ...extra }),
+const deps = (extra: Record<string, string> = {}, base = shipped) => ({
+  files: memoryFiles({ ...base, ...extra }),
   venuesDir: VENUES,
 });
-const resolve = (spec: string, extra: Record<string, string> = {}) =>
-  resolvePreset(spec, PAPER_FILE, deps(extra));
+const resolve = (
+  spec: string,
+  extra: Record<string, string> = {},
+  base = shipped,
+) => resolvePreset(spec, PAPER_FILE, deps(extra, base));
 /** A venue preset of a project's own: the identity every venue declares, then `body`. */
 const venue = (body: Record<string, unknown>, name = "Our Workshop"): string =>
   JSON.stringify({
@@ -80,7 +90,7 @@ describe("shipped presets", () => {
 
 describe("shipped presets: paperlint:msr", () => {
   it("paperlint:msr → msr over ieee-conference: one kind, appendices counted as body, compsoc forbidden", () => {
-    const r = resolve("paperlint:msr");
+    const r = resolve("paperlint:msr", {}, live);
     expect(r.ok).toBe(true);
     if (!r.ok) return;
     expect(r.value.chain.map((f) => f.split("/").pop())).toEqual([
@@ -103,26 +113,26 @@ describe("shipped presets: paperlint:msr", () => {
       kind: "hotcrp",
       url: "https://msr2027.hotcrp.com",
     });
-    // The portal's deadlines, read 2026-10-19 18:05 UTC off https://msr2027.hotcrp.com/deadlines:
-    // «Wednesday Oct 21, 2026, 7:59:59 AM EDT» (`"sub":1792583999`) and «Saturday Oct 24, 2026,
-    // 7:59:59 AM EDT» (#235).
-    expect(r.value.deadlines).toEqual([
-      {
-        what: "submission",
-        at: "2026-10-21T11:59:59Z",
-        source: "portal",
-        url: "https://msr2027.hotcrp.com/deadlines",
-        read: "2026-10-19",
-      },
-      {
-        what: "resubmission",
-        at: "2026-10-24T11:59:59Z",
+    // The deadlines' SHAPE, never their dates: the scheduled refresh rewrites those whenever the
+    // portal moves them (deadlines.yml), and a date asserted here turns its pull request red.
+    // Guards: the shipped preset keeps a submission deadline, every reading is the portal's own
+    // from the venue's deadlines page, with a read day and an instant that carries its zone.
+    expect(r.value.deadlines.map((d) => d.what)).toContain("submission");
+    expect(
+      r.value.deadlines.map((d) => ({
+        source: d.source,
+        url: d.url,
+        read: /^\d{4}-\d{2}-\d{2}$/.test(d.read),
+        at: /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$/.test(d.at),
+      })),
+    ).toEqual(
+      r.value.deadlines.map(() => ({
         source: "portal",
         url: "https://msr2027.hotcrp.com/deadlines",
-        read: "2026-10-19",
-      },
-    ]);
-    expect(Date.parse("2026-10-21T11:59:59Z") / 1000).toBe(1792583999);
+        read: true,
+        at: true,
+      })),
+    );
     // No rule turned on: the IEEE capitalization rule has not been read and quoted.
     expect(r.value.rules).toEqual({});
     expect(r.value.registerAnchors).toEqual([]);

package/src/submission-show.test.ts

@@ -1,4 +1,5 @@
 /** `paperlint submission show`: what the portal holds, whether it is the local build, the deadlines in force. */
+import { join } from "node:path";
 import { expect, test } from "vitest";
 import { memoryFiles } from "./adapters/memory/index.ts";
 import { err, ok } from "./domain/result.ts";
@@ -20,6 +21,12 @@ import {
   run,
   STEPS,
 } from "../test/submission-fixtures.ts";
+import { frozenText } from "../test/frozen-presets.ts";
+
+/** msr FROZEN (test/frozen-presets.ts): the shipped file's deadlines are the scheduled refresh's output. */
+const frozenMsr = {
+  [join(presetsDir(), "msr.jsonc")]: frozenText("msr.jsonc"),
+};
 
 test("show: the portal from the preset, the id from the paper, the token from the site's variable", async () => {
   const r = await run({});
@@ -130,6 +137,7 @@ test("show sends nothing, so it asks for no check", async () => {
 
 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({
+    ...frozenMsr,
     "/w/package.json": "{}",
     [`${PAPER}/paperlint.json`]: JSON.stringify({
       cycles: [
@@ -188,6 +196,7 @@ test("show prints the current attempt's deadlines in force: the preset's portal
 
 test("show, in the flat form: the deadlines in force are the preset's readings alone", () => {
   const flat = memoryFiles({
+    ...frozenMsr,
     "/w/package.json": "{}",
     [`${PAPER}/paperlint.json`]: JSON.stringify({
       extends: "paperlint:msr",