paperlint 12.0.0 → 13.0.0

package/src/submission-new.test.ts

@@ -1,7 +1,7 @@
 /** `paperlint submission new`: what it reads and sends, the dry run, the save that records the id, the refusals. */
 import { map } from "remeda";
 import { expect, test } from "vitest";
-import { builtPaper } from "../test/recorded-fixture.ts";
+import { builtPaper, recordText } from "../test/recorded-fixture.ts";
 import { latexReader } from "./adapters/latex/index.ts";
 import { absolutePath } from "./domain/paths.ts";
 import { err, ok } from "./domain/result.ts";
@@ -104,6 +104,16 @@ test("new --save in the cycles form: the id goes into the open attempt, the last
   const fs = newFiles({
     paper: { authors: AUTHORS, cycles: [closed, cycle("second", null)] },
   });
+  // Built: a save in the cycles form freezes the PDF with the source the build read.
+  fs.writeAtomic(
+    absolutePath(`${PAPER}/_build/sources.json`),
+    new TextEncoder().encode(
+      recordText(
+        { "paper.tex": DEFAULT_TEX },
+        { inputs: [["paper.tex", "body"]] },
+      ),
+    ),
+  );
   const r = await run({ sub: "new", save: true }, { files: fs });
   expect(r.code, r.errs.join("\n")).toBe(0);
   const written: unknown = JSON.parse(

package/src/submission.ts

@@ -82,6 +82,13 @@ import { originOf, type PaperSource } from "./domain/paper-source.ts";
 import type { SourcesCodec } from "./ports/sources-codec.ts";
 import { MAIN } from "./build.ts";
 import { assessSent, venueMessages, type VenueMessage } from "./venue-rules.ts";
+import {
+  freezePlan,
+  freezeSent,
+  NOT_FROZEN,
+  versionLines,
+  type FreezePlan,
+} from "./versions.ts";
 
 /** How to make and set the site's token: the page, the scopes, the variable. Pure. */
 export function tokenSteps(
@@ -168,6 +175,8 @@ export interface SubmissionDeps {
     file: string,
     messages: readonly VenueMessage[],
   ) => Promise<string>;
+  /** The instant a frozen version's lock entry records (`versions/lock.json`), ISO 8601. */
+  readonly now: () => string;
   readonly log: (line: string) => void;
   readonly err: (line: string) => void;
 }
@@ -468,7 +477,12 @@ async function runShow(
     shown: shownPath(deps.cwd, pdfPath),
     sha256: bytes === null ? null : sha256Hex(bytes),
   };
-  showLines(t, view.value, local).forEach((l) => {
+  // With `cycles`, the frozen versions beside the portal's copy: which is under review, which is history.
+  const versions = versionLines(t.paperDir, deps);
+  [
+    ...showLines(t, view.value, local),
+    ...(versions.ok ? ["", "versions", ...versions.value] : []),
+  ].forEach((l) => {
     deps.log(l);
   });
   return 0;
@@ -567,15 +581,71 @@ async function runUpdate(
   const refused = await venueCheck(t, bytes, a.save, deps);
   logAll(fieldLines(t.fields), deps);
   if (refused) return 2;
+  const plan = planFor(t, a.save, deps);
+  if (!plan.ok) return (deps.err(plan.error), 2);
   const change = changeOf(a, bytes, abstract.value, t.fields);
   const r = await portal.update(t.id, change, { save: a.save });
   if (!r.ok) return failed(r.error, deps);
-  const local = { shown, sha256: sha256Hex(bytes) };
-  const dropped = droppedLines(t.fields, t.venueFields, r.value);
-  logAll([...updateLines(r.value, local, a.save), ...dropped], deps);
-  const fine =
-    r.value.valid && r.value.httpStatus >= 200 && r.value.httpStatus < 300;
-  return fine && dropped.length === 0 ? 0 : 1;
+  const sent = { shown, bytes, save: a.save, plan: plan.value };
+  return afterUpdate(t, r.value, sent, deps);
+}
+
+/** The portal's answer to `update` printed, and what it kept frozen: the exit code. */
+function afterUpdate(
+  t: SubmissionTarget,
+  o: UpdateOutcome,
+  sent: {
+    readonly shown: string;
+    readonly bytes: Uint8Array;
+    readonly save: boolean;
+    readonly plan: FreezePlan | null;
+  },
+  deps: RunDeps,
+): number {
+  const local = { shown: sent.shown, sha256: sha256Hex(sent.bytes) };
+  const dropped = droppedLines(t.fields, t.venueFields, o);
+  logAll([...updateLines(o, local, sent.save), ...dropped], deps);
+  const fine = took(o);
+  const kept = fine && !o.dryRun ? sent.plan : null;
+  const frozen = freezeKept(t, kept, sent.bytes, deps);
+  return fine && dropped.length === 0 ? frozen : 1;
+}
+
+/** The portal answered valid, with a 2xx. */
+const took = (o: {
+  readonly valid: boolean;
+  readonly httpStatus: number;
+}): boolean => o.valid && o.httpStatus >= 200 && o.httpStatus < 300;
+
+/** What a `--save` will freeze, decided before anything is sent; null for a dry run. */
+const planFor = (
+  t: SubmissionTarget,
+  save: boolean,
+  deps: SubmissionDeps,
+): Result<FreezePlan | null, string> =>
+  save ? freezePlan(t.paperDir, t.resolved.settings.cycles, deps) : ok(null);
+
+/** The PDF a save sent, frozen with its source when there is a plan: 0, or 1 when the lock did not take it. */
+function freezeKept(
+  t: SubmissionTarget,
+  plan: FreezePlan | null,
+  pdf: Uint8Array,
+  deps: RunDeps,
+): number {
+  if (plan === null) return 0;
+  if (plan.kind === "flat") return (deps.log(NOT_FROZEN), 0);
+  const r = freezeSent(
+    {
+      paperDir: t.paperDir,
+      plan,
+      pdf,
+      shownPaper: shownPath(deps.cwd, t.paperDir),
+    },
+    deps,
+  );
+  if (!r.ok) return (deps.err(r.error), 1);
+  deps.log(r.value);
+  return 0;
 }
 
 // ── new ──────────────────────────────────────────────────────────────────────────────
@@ -900,15 +970,16 @@ async function runNew(
   const refused = await venueCheck(t, paper.pdf.bytes, a.save, deps);
   logAll(newLines(paper), deps);
   if (refused) return 2;
+  const plan = planFor(t, a.save, deps);
+  if (!plan.ok) return (deps.err(plan.error), 2);
   const r = await portal.create(paper, { save: a.save });
   if (!r.ok) return failed(r.error, deps);
   const dropped = droppedLines(t.fields, t.venueFields, r.value);
   logAll([...createLines(r.value, a.save), ...dropped], deps);
-  const fine =
-    r.value.valid && r.value.httpStatus >= 200 && r.value.httpStatus < 300;
-  if (!fine || (a.save && r.value.id === null)) return 1;
+  if (!took(r.value) || (a.save && r.value.id === null)) return 1;
+  const frozen = freezeKept(t, plan.value, paper.pdf.bytes, deps);
   const recorded = afterCreated(t, r.value.id, a, deps);
-  return dropped.length === 0 ? recorded : 1;
+  return dropped.length === 0 ? Math.max(recorded, frozen) : 1;
 }
 
 /** The subcommands that run before the paper has a submission id: `new` creates it, `topics` needs none. */

package/src/tex-venue-rules.test.ts

@@ -998,9 +998,12 @@ describe("otherVenues", () => {
     if (!aidc.ok) return;
     expect(otherVenues(aidc.value, deps).map((o) => o.label)).toEqual([
       "acm-sigconf",
+      "AGENT 2027",
       "AgenticDev",
+      "AGENTVERIFY",
       "AISec",
       "MSR",
+      "NLBSE",
     ]);
   });
 });

package/src/venue-rules.test.ts

@@ -270,13 +270,13 @@ describe("pdf/profile — the declaration must resolve, or nothing is judged", (
       "an unknown venue (a typo would silently disable every check)",
       { extends: "paperlint:agentic-dev", kind: "short" },
       "preset",
-      /agenticdev, aidc, aisec, ieee-conference, msr, realm/,
+      /agent, agenticdev, agentverify, aidc, aisec, ieee-conference, msr, nlbse, realm/,
     ],
     [
       "the base TeX set is not a venue",
       { extends: "paperlint:tex-base" },
       "preset",
-      /agenticdev, aidc, aisec, ieee-conference, msr, realm/,
+      /agent, agenticdev, agentverify, aidc, aisec, ieee-conference, msr, nlbse, realm/,
     ],
     [
       "paperlint.json that is not JSON",

package/src/version-rules.test.ts

@@ -0,0 +1,222 @@
+/**
+ * The rules over a paper's frozen versions, each module called directly over in-memory files: the
+ * finding on a planted defect, silence on a clean folder, on another file, and on a paper without
+ * cycles. (`rule-cases.test.ts` runs each through real ESLint.)
+ */
+import { describe, expect, it } from "vitest";
+import { latexReader } from "./adapters/latex/index.ts";
+import { memoryFiles, memoryListDir } from "./adapters/memory/index.ts";
+import { sourcesCodec } from "./adapters/sources-record/index.ts";
+import { sha256Hex } from "./domain/sha256.ts";
+import { lockText, type Lock } from "./domain/versions.ts";
+import {
+  draftRules,
+  submittedFrozenRules,
+  versionLayoutRules,
+} from "./version-rules.ts";
+
+const DIR = "/w/papers/p";
+const enc = (t: string) => new TextEncoder().encode(t);
+const locked = (t: string) => ({
+  kind: "file" as const,
+  bytes: enc(t).length,
+  sha256: sha256Hex(enc(t)),
+  frozen: "2026-10-23T16:58:01.000Z",
+});
+
+const OPEN = {
+  id: "beta-2027",
+  venue: { kind: "named", name: "Beta 2027", url: "https://beta.example" },
+  opened: "2026-09-09",
+  submission: { id: 7 },
+};
+const ACCEPTED = {
+  ...OPEN,
+  outcome: { kind: "accepted", date: "2026-12-01", evidence: "m.eml" },
+};
+const SOURCE =
+  "\\documentclass{article}\n\\begin{document}\nA.\n\\end{document}\n";
+const DRIFTED = SOURCE.replace("A.", "A, then B.\nC.");
+
+/** A paper folder: its settings, paper.tex, and `submitted.*` of beta-2027 frozen and locked. */
+function tree(
+  o: {
+    readonly cycles?: readonly object[] | null;
+    readonly draft?: string;
+    readonly extra?: Readonly<Record<string, string>>;
+    readonly lock?: Lock;
+  } = {},
+): Record<string, string> {
+  const pdf = "%PDF sent";
+  return {
+    [`${DIR}/paperlint.json`]: JSON.stringify(
+      o.cycles === null ? { extends: null } : { cycles: o.cycles ?? [OPEN] },
+    ),
+    [`${DIR}/paper.tex`]: o.draft ?? SOURCE,
+    [`${DIR}/versions/beta-2027/submitted.pdf`]: pdf,
+    [`${DIR}/versions/beta-2027/submitted.tex`]: SOURCE,
+    [`${DIR}/versions/lock.json`]: lockText(
+      o.lock ?? {
+        "beta-2027/submitted.pdf": locked(pdf),
+        "beta-2027/submitted.tex": locked(SOURCE),
+      },
+    ),
+    ...o.extra,
+  };
+}
+
+interface Seen {
+  readonly messageId: string;
+  readonly data: Readonly<Record<string, string | number>>;
+}
+
+/** Every finding of the scorecard rules on `file` of the tree. */
+function status(
+  t: Record<string, string>,
+  file = "PIPELINE-STATUS.md",
+): Seen[] {
+  const files = memoryFiles(t);
+  const deps = { files, listDir: memoryListDir(files) };
+  const rules = { ...versionLayoutRules(deps), ...submittedFrozenRules(deps) };
+  const out: Seen[] = [];
+  Object.values(rules).forEach((rule) => {
+    rule
+      .create({
+        filename: `${DIR}/${file}`,
+        sourceCode: { getLocFromIndex: () => ({ line: 1, column: 0 }) },
+        report: (d) => out.push({ messageId: d.messageId, data: d.data }),
+      })
+      .root?.();
+  });
+  return out;
+}
+
+/** Every finding of the draft rules on `file` (paper.tex by default), its text read off the tree. */
+function draft(t: Record<string, string>, file = "paper.tex"): Seen[] {
+  const files = memoryFiles(t);
+  const rules = draftRules({ files, latex: latexReader, codec: sourcesCodec });
+  const out: Seen[] = [];
+  Object.values(rules).forEach((rule) => {
+    rule
+      .create({
+        filename: `${DIR}/${file}`,
+        sourceCode: {
+          text: t[`${DIR}/${file}`] ?? "",
+          getLocFromIndex: () => ({ line: 1, column: 0 }),
+        },
+        report: (d) => {
+          if ("messageId" in d)
+            out.push({ messageId: d.messageId, data: d.data ?? {} });
+        },
+      })
+      .root?.();
+  });
+  return out;
+}
+
+describe("versions/layout and cycle/submitted-frozen", () => {
+  it("a submission frozen, every file locked as it stands: silent", () => {
+    expect(status(tree())).toStrictEqual([]);
+  });
+
+  it("report on the scorecard only, and say nothing for a paper without cycles", () => {
+    const stray = { [`${DIR}/versions/notes.md`]: "x" };
+    expect(status(tree({ extra: stray }), "paper.tex")).toStrictEqual([]);
+    expect(status(tree({ cycles: null, extra: stray }))).toStrictEqual([]);
+  });
+
+  it("a stray file and a submission not frozen, each said by its rule", () => {
+    const t = tree({
+      cycles: [
+        {
+          ...OPEN,
+          outcome: { kind: "rejected", date: "2026-10-01", evidence: "m.eml" },
+        },
+        { ...OPEN, id: "gamma-2027", submission: { id: 9 } },
+      ],
+      extra: { [`${DIR}/versions/notes.md`]: "x" },
+    });
+    expect(status(t).map((f) => f.messageId)).toStrictEqual([
+      "stray",
+      "unfrozen",
+    ]);
+  });
+});
+
+describe("cycle/draft-drift and cycle/camera-ready-source", () => {
+  it("the draft as frozen: silent; paper.tex only", () => {
+    expect(draft(tree())).toStrictEqual([]);
+    expect(draft(tree({ draft: DRIFTED }), "notes.tex")).toStrictEqual([]);
+  });
+
+  it("an open cycle and a drifted draft: the drift, with the lines", () => {
+    expect(draft(tree({ draft: DRIFTED }))).toStrictEqual([
+      {
+        messageId: "drift",
+        data: {
+          key: "beta-2027/submitted.tex",
+          venue: "Beta 2027",
+          drift: "2 lines added, 1 removed",
+        },
+      },
+    ]);
+  });
+
+  it("no cycles, a cycle parked between venues, or no frozen source: nothing to measure", () => {
+    expect(draft(tree({ cycles: null, draft: DRIFTED }))).toStrictEqual([]);
+    const rejected = {
+      ...OPEN,
+      outcome: { kind: "rejected", date: "2026-12-01", evidence: "m.eml" },
+    };
+    expect(draft(tree({ cycles: [rejected], draft: DRIFTED }))).toStrictEqual(
+      [],
+    );
+    const t = Object.fromEntries(
+      Object.entries(tree({ draft: DRIFTED })).filter(
+        ([k]) => !k.endsWith("/submitted.tex"),
+      ),
+    );
+    expect(draft(t)).toStrictEqual([]);
+  });
+});
+
+describe("cycle/camera-ready-source", () => {
+  it("an accepted cycle: silent while the camera-ready is edited, however far the draft moved", () => {
+    expect(draft(tree({ cycles: [ACCEPTED], draft: DRIFTED }))).toStrictEqual(
+      [],
+    );
+    // A PDF frozen without its source: nothing to compare (versions/layout names the missing source).
+    const pdfOnly = {
+      [`${DIR}/versions/beta-2027/camera-ready.pdf`]: "%PDF final",
+    };
+    expect(
+      draft(tree({ cycles: [ACCEPTED], draft: DRIFTED, extra: pdfOnly })),
+    ).toStrictEqual([]);
+  });
+
+  it("an accepted cycle with its camera-ready frozen: judged against what was accepted, the draft no more", () => {
+    const camera = (source: string) => ({
+      [`${DIR}/versions/beta-2027/camera-ready.pdf`]: "%PDF final",
+      [`${DIR}/versions/beta-2027/camera-ready.tex`]: source,
+    });
+    // The accepted source plus a change: it derives, and the draft moving on after it is free.
+    expect(
+      draft(
+        tree({ cycles: [ACCEPTED], draft: "Next.", extra: camera(DRIFTED) }),
+      ),
+    ).toStrictEqual([]);
+    expect(
+      draft(
+        tree({
+          cycles: [ACCEPTED],
+          extra: camera("\\documentclass{book}\nAnother paper.\n"),
+        }),
+      ),
+    ).toStrictEqual([
+      {
+        messageId: "base",
+        data: { id: "beta-2027", kept: "0", total: "4" },
+      },
+    ]);
+  });
+});