paperlint 6.2.2 → 6.3.0

package/src/paper-settings.ts

@@ -4,7 +4,7 @@
  * One file name at two levels, one schema (lib/paper-config.mjs → SETTINGS_KEYS):
  *
  *   paperlint.json                 the project (optional): papersDir, rules, defaults
- *   <paper>/paperlint.json         this paper: { extends, kind, pdf, rules }
+ *   <paper>/paperlint.json         this paper: { extends, kind, pdf, rules, identity, talk, submission }
  *   a venue preset                 `paperlint:<name>` (shipped) or `./x.jsonc` (src/presets.ts)
  *
  * The paper's `extends`, `kind` and `pdf` win over the root's; with no own value, the root's is
@@ -32,6 +32,10 @@ import {
 } from "./rules-config.ts";
 import { messageOf } from "./domain/text.ts";
 import { parsePaperTalk, type PaperTalk } from "./domain/talk.ts";
+import {
+  parsePaperSubmission,
+  type PaperSubmission,
+} from "./domain/submission.ts";
 
 /** What one paper declares. Every absent field is null. */
 export interface PaperSettings {
@@ -54,6 +58,8 @@ export interface PaperSettings {
   readonly identity: readonly string[] | null;
   /** How this paper is presented (`talk/*`); null when it declares no talk. Never the root's. */
   readonly talk: PaperTalk | null;
+  /** Which submission on the venue's portal is this paper's; null when it says none. Never the root's. */
+  readonly submission: PaperSubmission | null;
 }
 
 /** Why a paper's settings cannot be read. */
@@ -112,17 +118,25 @@ export function identityField(
       );
 }
 
-/** `rules` (checked for shape only) and `talk`, each null when absent. */
+/** `rules` (checked for shape only), `talk` and `submission`, each null when absent. */
 function rulesAndTalk(
   json: Readonly<Record<string, unknown>>,
-): Result<Pick<PaperSettings, "rules" | "talk">, string> {
+): Result<Pick<PaperSettings, "rules" | "talk" | "submission">, string> {
   const rules = json["rules"];
   if (rules !== undefined && !isObject(rules) && !Array.isArray(rules))
     return err(
       `"rules" must be an object of rule id → severity, or a list of ESLint blocks`,
     );
   const talk = parsePaperTalk(json["talk"]);
-  return talk.ok ? ok({ rules: rules ?? null, talk: talk.value }) : talk;
+  if (!talk.ok) return talk;
+  const submission = parsePaperSubmission(json["submission"]);
+  return submission.ok
+    ? ok({
+        rules: rules ?? null,
+        talk: talk.value,
+        submission: submission.value,
+      })
+    : submission;
 }
 
 /** The parsed JSON of `paperlint.json` → the settings, or one line saying what is wrong. Pure. */
@@ -232,7 +246,12 @@ function merge(
   paper: PaperSettings | null,
 ): PaperSettings | null {
   const r = root ?? NO_DEFAULTS;
-  const p = paper ?? { ...NO_DEFAULTS, rules: null, talk: null };
+  const p = paper ?? {
+    ...NO_DEFAULTS,
+    rules: null,
+    talk: null,
+    submission: null,
+  };
   const merged: PaperSettings = {
     extends: p.extends ?? r.extends,
     kind: p.kind ?? r.kind,
@@ -240,6 +259,7 @@ function merge(
     rules: p.rules,
     identity: joined(r.identity, p.identity),
     talk: p.talk,
+    submission: p.submission,
   };
   return paper === null && Object.values(merged).every((v) => v === null)
     ? null

package/src/parse-args.test.ts

@@ -35,6 +35,25 @@ describe("parseArgs — `--flag=value` is the same as `--flag value`", () => {
   });
 });
 
+describe("parseArgs — the switches, each turning one field on", () => {
+  it.each([
+    ["--json", "json"],
+    ["--fix", "fix"],
+    ["--all", "all"],
+    ["--dry-run", "dryRun"],
+    ["--check", "check"],
+    ["--yes", "yes"],
+    ["-y", "yes"],
+    ["--no-hooks", "noHooks"],
+    ["--allow-venue-name", "allowVenueName"],
+  ] as const)("%s → %s", (flag, key) => {
+    const off = parseArgs(["new", "x"]);
+    const on = parseArgs(["new", "x", flag]);
+    expect(off[key]).toBe(false);
+    expect(on).toEqual({ ...off, [key]: true });
+  });
+});
+
 describe("an unknown flag is refused, not read as a path", () => {
   it("exits 2 and names the flag", async () => {
     const err: string[] = [];

package/src/ports/submission-portal.ts

@@ -0,0 +1,26 @@
+/**
+ * A conference portal holding a paper's submission — the port `paperlint submission` talks through.
+ * Shaped by what the command needs (read one submission, send one change), not by any portal's API;
+ * one adapter per portal kind (`src/adapters/hotcrp/`).
+ */
+import type { Result } from "../domain/result.ts";
+import type {
+  PortalFailure,
+  SubmissionChange,
+  SubmissionView,
+  UpdateOutcome,
+} from "../domain/submission.ts";
+
+export interface SubmissionPortal {
+  /** The submission as the portal holds it now. */
+  show(id: number): Promise<Result<SubmissionView, PortalFailure>>;
+  /**
+   * Send a change. Without `save` the portal only checks it (a dry run) and keeps nothing; an
+   * answer the portal gave — valid or not — is an outcome, not a failure.
+   */
+  update(
+    id: number,
+    change: SubmissionChange,
+    o: { readonly save: boolean },
+  ): Promise<Result<UpdateOutcome, PortalFailure>>;
+}

package/src/presets.test.ts

@@ -16,6 +16,7 @@ import {
   MAX_PRESET_DEPTH,
   SHIPPED_PREFIX,
   shippedPresets,
+  shippedVenueNames,
   labelOf,
   presetProblemText,
   resolvePreset,
@@ -297,3 +298,24 @@ describe("labelOf — display only, never used to resolve", () => {
     expect(labelOf(spec)).toBe(label);
   });
 });
+
+describe("shippedVenueNames — what each shipped venue is called", () => {
+  it("every shipped preset, by its label and the names along its chain", () => {
+    const names = shippedVenueNames(deps());
+    expect(names.map((n) => n.label)).toEqual(shippedPresets(VENUES));
+    expect(names.find((n) => n.label === "aisec")?.aliases).toEqual(
+      expect.arrayContaining(["AISec", "ACM CCS"]),
+    );
+  });
+
+  it("a preset that does not resolve is left out", () => {
+    const files = memoryFiles(
+      Object.fromEntries(
+        Object.entries(shipped).filter(([f]) => !f.endsWith("realm.jsonc")),
+      ),
+    );
+    expect(
+      shippedVenueNames({ files, venuesDir: VENUES }).map((n) => n.label),
+    ).toEqual(shippedPresets(VENUES).filter((n) => n !== "realm"));
+  });
+});

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.