paperlint 6.2.3 → 6.3.0

package/src/presets.ts

@@ -19,7 +19,8 @@
  *   tex        union — a child never removes a package its parent needs
  *   format     per key, the child wins; `kinds` by kind name, a child's kind replaces that kind
  *   rules      per rule id, the child wins
- *   template   the child wins; so does `name`, and `required_sections`, `register` and `talk` (each whole)
+ *   template   the child wins; so does `name`, and `required_sections`, `register`, `talk` and
+ *              `portal` (each whole)
  *   aliases    union, with every `name` — what the venue is called along the chain
  *
  * ── THE LABEL ─────────────────────────────────────────────────────────────────────
@@ -42,7 +43,7 @@ import {
   type VenueFormat,
 } from "./tex-requirements.ts";
 import { callerPath } from "./caller-path.ts";
-import { err, ok, type Result } from "./domain/result.ts";
+import { err, isOk, ok, type Result } from "./domain/result.ts";
 import type { Files } from "./ports/files.ts";
 import {
   readPaperSettings,
@@ -53,6 +54,7 @@ import { CONFIG_FILE } from "#lib/paper-config";
 import { messageOf } from "./domain/text.ts";
 import type { RegisterAnchor } from "./domain/register.ts";
 import type { VenueTalk } from "./domain/talk.ts";
+import type { VenuePortal } from "./domain/submission.ts";
 
 /** The prefix of a shipped preset's spec. */
 export const SHIPPED_PREFIX = "paperlint:";
@@ -95,6 +97,8 @@ export interface Preset {
   readonly registerAnchors: readonly RegisterAnchor[];
   /** What the venue asks a presenter to send (`talk/*`); null when no file of the chain says. */
   readonly talk: VenueTalk | null;
+  /** Where the venue takes submissions (`paperlint submission`); null when no file of the chain says. */
+  readonly portal: VenuePortal | null;
 }
 
 /** Why a spec does not resolve. */
@@ -227,6 +231,7 @@ function merged(
     rules: {},
     registerAnchors: [],
     talk: null,
+    portal: null,
   };
   const m = rootFirst.reduce(
     (acc, { preset: p, file }) => ({
@@ -246,6 +251,7 @@ function merged(
       rules: { ...acc.rules, ...p.rules },
       registerAnchors: p.registerAnchors ?? acc.registerAnchors,
       talk: p.talk ?? acc.talk,
+      portal: p.portal ?? acc.portal,
     }),
     base,
   );
@@ -280,11 +286,48 @@ export function shippedPresets(venuesDir: string): string[] {
   return venueNames(venuesDir);
 }
 
+/** The spec a paper writes in `extends` for the shipped preset `name`: `paperlint:<name>`. */
+export const shippedSpec = (name: string): string => `${SHIPPED_PREFIX}${name}`;
+
+/**
+ * Every shipped preset that resolves, each read the way a paper extending it would read it. The one
+ * piece that reads the presets directory. One that does not resolve is left out: `pdf/profile`
+ * owns that.
+ */
+export function resolveShipped(deps: PresetDeps): readonly Preset[] {
+  const from = join(deps.venuesDir, CONFIG_FILE);
+  return shippedPresets(deps.venuesDir)
+    .map((name) => resolvePreset(shippedSpec(name), from, deps))
+    .filter(isOk)
+    .map((r) => r.value);
+}
+
+/** A shipped venue as a name knows it, and the files of its chain: what tells it from a paper's own. */
+export type ShippedVenue = Pick<Preset, "label" | "aliases" | "chain">;
+
+/**
+ * A resolved preset as a name knows it: its label, its aliases, its chain. Pure. (Not Remeda's
+ * `pick`: the app layer may not import it — `boundaries/dependencies`, `APP_EXTERNALS`.)
+ */
+export const venueOf = ({ label, aliases, chain }: Preset): ShippedVenue => ({
+  label,
+  aliases,
+  chain,
+});
+
+/**
+ * THE ONE SOURCE OF VENUE NAMES: every shipped venue's label and `aliases` (with each `name` along
+ * its chain). Read by `paperlint new`, which refuses a folder name naming one, and through
+ * `otherVenues` by `tex/venue-leftover` and `paper/folder-venue-leftover`.
+ */
+export const shippedVenueNames = (deps: PresetDeps): readonly ShippedVenue[] =>
+  resolveShipped(deps).map(venueOf);
+
 /** One line for a problem, naming what to change. Pure. */
 export function presetProblemText(p: PresetProblem): string {
   switch (p.kind) {
     case "unsupported":
-      return `"extends": "${p.spec}" — a preset is \`paperlint:<name>\` (shipped) or a path starting with ./ or ../ (your own); npm presets: not yet supported. Did you mean "${SHIPPED_PREFIX}${p.spec}"?`;
+      return `"extends": "${p.spec}" — a preset is \`paperlint:<name>\` (shipped) or a path starting with ./ or ../ (your own); npm presets: not yet supported. Did you mean "${shippedSpec(p.spec)}"?`;
     case "not-found":
       return `"extends": "${p.spec}" names no preset (${p.file}); shipped presets (${SHIPPED_PREFIX}<name>): ${p.shipped.join(", ")}`;
     case "cycle":

package/src/rule-cases.test.ts

@@ -389,6 +389,25 @@ const CASES: Readonly<Record<string, RuleCases>> = {
     },
     silent: aidc("Text."),
   },
+  "paper/folder-venue-leftover": {
+    reports: {
+      // An AIDC paper still in the folder it had when it targeted AISec.
+      tree: {
+        "papers/aisec-2026/PIPELINE-STATUS.md": STATUS,
+        "papers/aisec-2026/paper.tex": tex("x"),
+        "papers/aisec-2026/paperlint.json": AIDC[`${P}/paperlint.json`],
+      },
+      file: "papers/aisec-2026/PIPELINE-STATUS.md",
+      severity: 1,
+      line: 1,
+    },
+    // The folder names the paper's own venue.
+    silent: {
+      "papers/aidc-2026/PIPELINE-STATUS.md": STATUS,
+      "papers/aidc-2026/paper.tex": tex("x"),
+      "papers/aidc-2026/paperlint.json": AIDC[`${P}/paperlint.json`],
+    },
+  },
   "tex/venue-leftover": {
     reports: {
       tree: aidc("First written for AISec."),

package/src/rules-config.ts

@@ -6,7 +6,7 @@
  * A consumer turns an optional rule on, or changes a built-in rule's severity, by writing what they
  * would write in an ESLint flat config — a list of `{ files, ignores, rules }` blocks:
  *
- *   "rules": [ { "files": ["papers/agenticdev-2026/**"],
+ *   "rules": [ { "files": ["papers/rule-drift/**"],
  *                "rules": { "pdf/last-page-balance": ["error", { "tolerancePt": 120 }] } } ]
  *
  * The blocks are appended AFTER paperlint's built-in config, so a later block wins, exactly as in ESLint.

package/src/submission.test.ts

@@ -0,0 +1,496 @@
+/**
+ * `paperlint submission` over in-memory files and a recording portal: where the portal and the
+ * submission id come from, the refusals that name the file and key to set, the token rule, and what
+ * `show` and `update` print and exit with. The HotCRP wire format is tested in the adapter.
+ */
+import assert from "node:assert/strict";
+import { test } from "vitest";
+import { memoryFiles } from "./adapters/memory/index.ts";
+import { nodeFiles } from "./adapters/node/index.ts";
+import type { Files } from "./ports/files.ts";
+import { ok, err, type Result } from "./domain/result.ts";
+import { sha256Hex } from "./domain/sha256.ts";
+import type {
+  PortalFailure,
+  SubmissionChange,
+  SubmissionView,
+  SupportedPortal,
+  UpdateOutcome,
+} from "./domain/submission.ts";
+import { presetsDir } from "./package-dirs.ts";
+import type { SubmissionPortal } from "./ports/submission-portal.ts";
+import {
+  failureText,
+  runSubmission,
+  submissionTarget,
+  tokenFor,
+  usageProblem,
+  type SubmissionArgs,
+} from "./submission.ts";
+
+const PAPER = "/w/papers/p";
+const SITE = "http://127.0.0.1:9";
+const PDF = new TextEncoder().encode("%PDF fake");
+const HEX = sha256Hex(PDF);
+
+/** The test's files, over the disk for what they do not hold: the shipped presets and their schema. */
+const withPresets = (fs: Files): Files => ({
+  ...fs,
+  isFile: (p) => fs.isFile(p) || nodeFiles.isFile(p),
+  readBytes: (p) => fs.readBytes(p) ?? nodeFiles.readBytes(p),
+});
+
+const venue = (portal: unknown): string =>
+  JSON.stringify({ extends: "paperlint:aidc", portal });
+const files = (o: {
+  readonly portal?: unknown;
+  readonly paper?: Readonly<Record<string, unknown>>;
+  readonly extra?: Readonly<Record<string, string | Uint8Array>>;
+}) =>
+  memoryFiles({
+    "/w/package.json": "{}",
+    "/w/venue.jsonc": venue(o.portal ?? { kind: "hotcrp", url: `${SITE}/` }),
+    [`${PAPER}/paperlint.json`]: JSON.stringify(
+      o.paper ?? { extends: "../../venue.jsonc", submission: { id: 7 } },
+    ),
+    [`${PAPER}/paper.pdf`]: PDF,
+    ...o.extra,
+  });
+
+const VIEW: SubmissionView = {
+  id: 7,
+  status: "submitted",
+  title: "A Fake Title",
+  paperType: "Regular",
+  topics: ["A", "B"],
+  abstract: "one two  three\nfour",
+  pdf: {
+    sha256: HEX,
+    hash: `sha2-${HEX}`,
+    size: PDF.length,
+    mimetype: "application/pdf",
+    uploadedAt: 0,
+  },
+  submittedAt: 60,
+  modifiedAt: 120,
+  messages: [],
+};
+
+interface Recorded {
+  readonly portal: SupportedPortal;
+  readonly token: string;
+  readonly calls: unknown[];
+}
+
+const fakePortal = (answers: {
+  readonly show?: Result<SubmissionView, PortalFailure>;
+  readonly update?: Result<UpdateOutcome, PortalFailure>;
+}) => {
+  const seen: Recorded[] = [];
+  const portalFor = (
+    portal: SupportedPortal,
+    token: string,
+  ): SubmissionPortal => {
+    const r: Recorded = { portal, token, calls: [] };
+    seen.push(r);
+    return {
+      show: (id) => {
+        r.calls.push(["show", id]);
+        return Promise.resolve(answers.show ?? ok(VIEW));
+      },
+      update: (id, change: SubmissionChange, o) => {
+        r.calls.push(["update", id, change, o]);
+        return Promise.resolve(
+          answers.update ??
+            ok({
+              httpStatus: 200,
+              valid: true,
+              changes: ["submission"],
+              messages: [],
+              dryRun: !o.save,
+            }),
+        );
+      },
+    };
+  };
+  return { seen, portalFor };
+};
+
+const ARGS: SubmissionArgs = {
+  sub: "show",
+  paperDir: "papers/p",
+  extra: [],
+  pdf: null,
+  abstract: null,
+  submit: false,
+  save: false,
+};
+
+async function run(
+  a: Partial<SubmissionArgs>,
+  o: {
+    readonly files?: Files;
+    readonly env?: Readonly<Record<string, string>>;
+    readonly portal?: ReturnType<typeof fakePortal>;
+  } = {},
+) {
+  const out: string[] = [];
+  const errs: string[] = [];
+  const portal = o.portal ?? fakePortal({});
+  const fs = withPresets(o.files ?? files({}));
+  const code = await runSubmission(
+    { ...ARGS, ...a },
+    {
+      files: fs,
+      presets: { files: fs, venuesDir: presetsDir() },
+      cwd: "/w",
+      env: (n) => (o.env ?? { HOTCRP_TOKEN: "hct_secret" })[n],
+      portalFor: portal.portalFor,
+      log: (l) => out.push(l),
+      err: (l) => errs.push(l),
+    },
+  );
+  return { code, out, errs, seen: portal.seen };
+}
+
+test("show: the portal from the preset, the id from the paper, the token from HOTCRP_TOKEN", async () => {
+  const r = await run({});
+  assert.equal(r.code, 0);
+  assert.deepEqual(r.errs, []);
+  assert.deepEqual(r.seen, [
+    {
+      portal: { kind: "hotcrp", url: SITE },
+      token: "hct_secret",
+      calls: [["show", 7]],
+    },
+  ]);
+  assert.deepEqual(r.out, [
+    `submission 7 on ${SITE} (hotcrp)`,
+    "status        submitted, submitted 1970-01-01T00:01:00.000Z",
+    "title         A Fake Title",
+    "paper type    Regular",
+    "topics        A; B",
+    "abstract      4 words",
+    `portal PDF    sha2-${HEX}, ${String(PDF.length)} bytes, uploaded 1970-01-01T00:00:00.000Z`,
+    `local PDF     papers/p/paper.pdf sha2-${HEX}`,
+    "match         yes — the portal holds this build",
+  ]);
+  // Guards: the token is an input to the adapter and nothing printed carries it.
+  assert.doesNotMatch([...r.out, ...r.errs].join("\n"), /hct_secret/);
+});
+
+test("show: a different PDF on the portal is reported as NO, and still exits 0", async () => {
+  const other = {
+    ...VIEW,
+    pdf: VIEW.pdf && { ...VIEW.pdf, sha256: sha256Hex(new Uint8Array([1])) },
+  };
+  const r = await run({}, { portal: fakePortal({ show: ok(other) }) });
+  assert.equal(r.code, 0);
+  assert.equal(
+    r.out.at(-1),
+    "match         NO — the portal holds a different PDF than the local one",
+  );
+});
+
+test("show: no PDF on the portal, a hash that is not sha256, no local PDF, portal messages", async () => {
+  const bare: SubmissionView = {
+    ...VIEW,
+    title: null,
+    paperType: null,
+    topics: [],
+    abstract: null,
+    pdf: null,
+    submittedAt: null,
+    messages: [
+      { message: "Not yet submitted", field: "status", status: 1 },
+      { message: "Draft", field: null, status: null },
+    ],
+  };
+  const r1 = await run({}, { portal: fakePortal({ show: ok(bare) }) });
+  assert.deepEqual(r1.out.slice(1), [
+    "status        submitted",
+    "title         —",
+    "paper type    —",
+    "topics        —",
+    "abstract      —",
+    "portal PDF    none",
+    `local PDF     papers/p/paper.pdf sha2-${HEX}`,
+    "match         NO — the portal holds no PDF",
+    "  portal says: status: Not yet submitted",
+    "  portal says: Draft",
+  ]);
+  const sha1 = {
+    ...VIEW,
+    pdf: {
+      hash: "sha1-abc",
+      sha256: null,
+      size: null,
+      mimetype: null,
+      uploadedAt: null,
+    },
+  };
+  const r2 = await run({}, { portal: fakePortal({ show: ok(sha1) }) });
+  assert.equal(r2.out[6], "portal PDF    sha1-abc, ? bytes, uploaded —");
+  assert.equal(
+    r2.out[8],
+    "match         unknown — the portal names a sha1 hash, not a sha256",
+  );
+  const r4 = await run({ pdf: "/elsewhere/x.pdf" });
+  assert.equal(r4.out[7], "local PDF     /elsewhere/x.pdf (missing)");
+  const r3 = await run({ pdf: "missing.pdf" });
+  assert.equal(r3.out[7], "local PDF     missing.pdf (missing)");
+  assert.equal(r3.out[8], "match         unknown — no local PDF to compare");
+});
+
+test("🔴 the portal's refusal is printed with its own message, exit 1", async () => {
+  const refused = err<PortalFailure>({
+    kind: "refused",
+    httpStatus: 401,
+    messages: [{ message: "Missing credentials", field: null, status: 2 }],
+  });
+  const r = await run({}, { portal: fakePortal({ show: refused }) });
+  assert.equal(r.code, 1);
+  assert.deepEqual(r.errs, [
+    "the portal refused (HTTP 401): Missing credentials",
+  ]);
+});
+
+test("failureText: each failure in words", () => {
+  assert.equal(
+    failureText({ kind: "refused", httpStatus: 500, messages: [] }),
+    "the portal refused (HTTP 500)",
+  );
+  assert.equal(
+    failureText({ kind: "unreachable", detail: "fetch failed" }),
+    "the portal cannot be reached: fetch failed",
+  );
+  assert.equal(
+    failureText({
+      kind: "malformed",
+      httpStatus: 200,
+      detail: "the answer is not JSON (text/html)",
+    }),
+    "the portal answered HTTP 200, but not as its API does: the answer is not JSON (text/html)",
+  );
+});
+
+test("update: a dry run by default — the paper's PDF sent, nothing saved, exit 0", async () => {
+  const r = await run({ sub: "update" });
+  assert.equal(r.code, 0);
+  assert.deepEqual(r.seen[0]?.calls, [
+    [
+      "update",
+      7,
+      { pdf: { name: "paper.pdf", bytes: PDF }, abstract: null, submit: false },
+      { save: false },
+    ],
+  ]);
+  assert.deepEqual(r.out, [
+    "dry run — the portal checked the change and kept nothing; --save sends it for real",
+    "HTTP          200",
+    "valid         yes",
+    "changes       submission",
+    `local PDF     papers/p/paper.pdf sha2-${HEX}`,
+  ]);
+});
+
+test("update --save --submit --abstract --pdf: all of it sent, and said to be saved", async () => {
+  const fs = files({
+    extra: { "/w/abs.txt": "  The abstract.\n", "/w/other.pdf": PDF },
+  });
+  const r = await run(
+    {
+      sub: "update",
+      save: true,
+      submit: true,
+      abstract: "abs.txt",
+      pdf: "other.pdf",
+    },
+    { files: fs },
+  );
+  assert.equal(r.code, 0);
+  assert.deepEqual(r.seen[0]?.calls, [
+    [
+      "update",
+      7,
+      {
+        pdf: { name: "other.pdf", bytes: PDF },
+        abstract: "The abstract.",
+        submit: true,
+      },
+      { save: true },
+    ],
+  ]);
+  assert.equal(r.out[0], "saved");
+});
+
+test("update: valid:false, or a non-2xx status, exits 1 with the portal's messages", async () => {
+  const invalid = ok<UpdateOutcome>({
+    httpStatus: 200,
+    valid: false,
+    changes: [],
+    messages: [{ message: "Bad PDF", field: "submission", status: 2 }],
+    dryRun: true,
+  });
+  const r1 = await run(
+    { sub: "update" },
+    { portal: fakePortal({ update: invalid }) },
+  );
+  assert.equal(r1.code, 1);
+  assert.deepEqual(r1.out.slice(2), [
+    "valid         NO",
+    "changes       —",
+    `local PDF     papers/p/paper.pdf sha2-${HEX}`,
+    "  portal says: submission: Bad PDF",
+  ]);
+  const status = ok<UpdateOutcome>({
+    httpStatus: 400,
+    valid: true,
+    changes: [],
+    messages: [],
+    dryRun: false,
+  });
+  assert.equal(
+    (await run({ sub: "update" }, { portal: fakePortal({ update: status }) }))
+      .code,
+    1,
+  );
+  const unreachable = err<PortalFailure>({
+    kind: "unreachable",
+    detail: "down",
+  });
+  const r3 = await run(
+    { sub: "update" },
+    { portal: fakePortal({ update: unreachable }) },
+  );
+  assert.equal(r3.code, 1);
+  assert.deepEqual(r3.errs, ["the portal cannot be reached: down"]);
+});
+
+test("update --save that the portal withheld says so", async () => {
+  const withheld = ok<UpdateOutcome>({
+    httpStatus: 200,
+    valid: true,
+    changes: [],
+    messages: [],
+    dryRun: true,
+  });
+  const r = await run(
+    { sub: "update", save: true },
+    { portal: fakePortal({ update: withheld }) },
+  );
+  assert.equal(r.out[0], "SAVE WITHHELD by the portal — nothing changed");
+});
+
+test("update: no PDF to send, or no abstract file, is refused before the portal is asked", async () => {
+  const r1 = await run({ sub: "update", pdf: "nope.pdf" });
+  assert.equal(r1.code, 2);
+  assert.deepEqual(r1.errs, [
+    "no PDF at nope.pdf — build the paper, or name one with --pdf",
+  ]);
+  assert.deepEqual(r1.seen[0]?.calls, []);
+  const r2 = await run({ sub: "update", abstract: "nope.txt" });
+  assert.equal(r2.code, 2);
+  assert.deepEqual(r2.errs, ["--abstract: no file at nope.txt"]);
+});
+
+test("🔴 no token: the variable is named, with where to make one — and nothing is called", async () => {
+  const r = await run({}, { env: {} });
+  assert.equal(r.code, 2);
+  assert.deepEqual(r.seen, []);
+  assert.match(
+    r.errs[0] ?? "",
+    /^HOTCRP_TOKEN is not set — .*Account settings → Developer/,
+  );
+  assert.deepEqual(
+    tokenFor({ kind: "hotcrp", url: SITE }, () => "  "),
+    {
+      ok: false,
+      error: r.errs[0],
+    },
+  );
+});
+
+test("🔴 the file and key to set: no portal in the preset, no submission in the paper, no preset", () => {
+  const deps = (fs: Files) => ({
+    files: withPresets(fs),
+    venuesDir: presetsDir(),
+  });
+  const noPortal = memoryFiles({
+    "/w/package.json": "{}",
+    [`${PAPER}/paperlint.json`]: JSON.stringify({
+      extends: "paperlint:ieee-conference",
+      submission: { id: 7 },
+    }),
+  });
+  const t1 = submissionTarget(PAPER, deps(noPortal));
+  assert.match(
+    !t1.ok ? t1.error : "",
+    /^the venue preset declares no "portal" \(read: .*ieee-conference\.jsonc\) — add "portal": \{ "kind": "hotcrp"/,
+  );
+  const noId = files({ paper: { extends: "../../venue.jsonc" } });
+  assert.deepEqual(submissionTarget(PAPER, deps(noId)), {
+    ok: false,
+    error: `${PAPER}/paperlint.json: no "submission" — add "submission": { "id": <the submission number on ${SITE}/> }`,
+  });
+  const noExtends = files({ paper: { submission: { id: 7 } } });
+  const t3 = submissionTarget(PAPER, deps(noExtends));
+  assert.match(!t3.ok ? t3.error : "", /paperlint\.json: no "extends"/);
+  const broken = files({
+    paper: { extends: "../../venue.jsonc", submission: { id: "7" } },
+  });
+  const t4 = submissionTarget(PAPER, deps(broken));
+  assert.match(!t4.ok ? t4.error : "", /"submission" must be \{ "id"/);
+});
+
+test("🔴 an unknown portal kind is refused: upload by hand", async () => {
+  const r = await run(
+    {},
+    { files: files({ portal: { kind: "easychair", url: "https://x.test" } }) },
+  );
+  assert.equal(r.code, 2);
+  assert.deepEqual(r.errs, [
+    `portal kind "easychair" is not supported; upload by hand`,
+  ]);
+  assert.deepEqual(r.seen, []);
+});
+
+test("the shipped aidc preset declares its HotCRP portal", () => {
+  const fs = memoryFiles({
+    "/w/package.json": "{}",
+    [`${PAPER}/paperlint.json`]: JSON.stringify({
+      extends: "paperlint:aidc",
+      submission: { id: 7 },
+    }),
+  });
+  const t = submissionTarget(PAPER, {
+    files: withPresets(fs),
+    venuesDir: presetsDir(),
+  });
+  assert.equal(t.ok && t.value.portal.kind, "hotcrp");
+  assert.match(t.ok ? t.value.portal.url : "", /^https:\/\//);
+});
+
+test("usage: refused before anything is read, exit 2", async () => {
+  const r = await run({ sub: "upload" });
+  assert.equal(r.code, 2);
+  assert.deepEqual(r.seen, []);
+  assert.match(r.errs[0] ?? "", /got `upload`/);
+});
+
+test("usage: a subcommand is required, one paper folder, update-only flags refused on show", () => {
+  assert.match(
+    usageProblem({ ...ARGS, sub: undefined }) ?? "",
+    /needs a subcommand: show or update — got ``/,
+  );
+  assert.match(usageProblem({ ...ARGS, sub: "upload" }) ?? "", /got `upload`/);
+  assert.equal(
+    usageProblem({ ...ARGS, extra: ["x"] }),
+    "`submission show` takes one paper folder — got also `x`",
+  );
+  assert.equal(
+    usageProblem({ ...ARGS, save: true, submit: true, abstract: "a" }),
+    "--abstract, --submit, --save: only `submission update` changes anything; `show` reads",
+  );
+  assert.equal(usageProblem({ ...ARGS, sub: "update", save: true }), null);
+});