paperlint 6.2.2 → 6.3.0

package/src/adapters/hotcrp/response.ts

@@ -0,0 +1,181 @@
+/**
+ * HotCRP's answers, parsed at the boundary into paperlint's submission values. Pure.
+ *
+ * Only the fields the command uses are read; every other key HotCRP sends is dropped here. The field
+ * names are HotCRP's (`devel/openapi.json` and `devel/apidoc/submissions.md` in kohler/hotcrp):
+ * `GET /api/paper` answers `{ ok, paper, message_list? }`, `POST /api/paper` answers
+ * `{ ok, valid, change_list, message_list, dry_run?, pid }`. A document's `hash` is
+ * `sha2-<64 hex>` when HotCRP stored a sha256; timestamps are Unix seconds.
+ */
+import { z } from "zod";
+import { err, ok, type Result } from "../../domain/result.ts";
+import { parseSha256, type Sha256 } from "../../domain/sha256.ts";
+import type {
+  PortalDocument,
+  PortalFailure,
+  PortalMessage,
+  SubmissionView,
+  UpdateOutcome,
+} from "../../domain/submission.ts";
+
+const Message = z.object({
+  message: z.string().optional(),
+  field: z.string().optional(),
+  status: z.number().optional(),
+});
+const Messages = z.array(Message).optional();
+
+const Document = z.object({
+  hash: z.string().optional(),
+  size: z.number().optional(),
+  mimetype: z.string().optional(),
+  timestamp: z.number().optional(),
+});
+
+const Paper = z.object({
+  pid: z.number(),
+  status: z.string(),
+  title: z.string().optional(),
+  abstract: z.string().optional(),
+  paper_type: z.unknown().optional(),
+  topics: z.array(z.string()).optional(),
+  submission: Document.nullable().optional(),
+  submitted_at: z.number().optional(),
+  modified_at: z.number().optional(),
+});
+
+const ShowBody = z.object({
+  ok: z.literal(true),
+  paper: Paper,
+  message_list: Messages,
+});
+
+const UpdateBody = z.object({
+  valid: z.boolean(),
+  change_list: z.array(z.string()).optional(),
+  message_list: Messages,
+  dry_run: z.boolean().optional(),
+});
+
+const Envelope = z.object({ message_list: Messages });
+
+const SHA2 = /^sha2-([0-9a-f]{64})$/;
+
+/** HotCRP's `sha2-<hex>` → the sha256; null for any other hash it may name. */
+export function sha256OfHash(hash: string): Sha256 | null {
+  const hex = SHA2.exec(hash)?.[1];
+  return hex === undefined ? null : parseSha256(hex);
+}
+
+/** HotCRP prefixes a message with its format (`<0>` plain text, `<5>` HTML); the text is the rest. */
+const textOf = (message: string | undefined): string =>
+  (message ?? "").replace(/^<\d+>/, "").trim();
+
+/** The messages that say something: HotCRP also sends entries with no text, which print as blanks. */
+const messagesOf = (
+  list: Readonly<z.infer<typeof Messages>>,
+): readonly PortalMessage[] =>
+  (list ?? [])
+    .map((m) => ({
+      message: textOf(m.message),
+      field: m.field ?? null,
+      status: m.status ?? null,
+    }))
+    .filter((m) => m.message !== "");
+
+const documentOf = (
+  d: Readonly<z.infer<typeof Document>> | null | undefined,
+): PortalDocument | null =>
+  d?.hash === undefined
+    ? null
+    : {
+        sha256: sha256OfHash(d.hash),
+        hash: d.hash,
+        size: d.size ?? null,
+        mimetype: d.mimetype ?? null,
+        uploadedAt: d.timestamp ?? null,
+      };
+
+/** A paper type as text: HotCRP sends the option's name, or a value of another shape. */
+const typeText = (v: unknown): string | null =>
+  v === undefined || v === null
+    ? null
+    : typeof v === "string"
+      ? v
+      : JSON.stringify(v);
+
+function viewOf(b: Readonly<z.infer<typeof ShowBody>>): SubmissionView {
+  const p = b.paper;
+  return {
+    id: p.pid,
+    status: p.status,
+    title: p.title ?? null,
+    paperType: typeText(p.paper_type),
+    topics: p.topics ?? [],
+    abstract: p.abstract ?? null,
+    pdf: documentOf(p.submission),
+    submittedAt: p.submitted_at ?? null,
+    modifiedAt: p.modified_at ?? null,
+    messages: messagesOf(b.message_list),
+  };
+}
+
+const is2xx = (status: number): boolean => status >= 200 && status < 300;
+
+const StatusCode = z.object({ status_code: z.number() });
+
+/**
+ * The status HotCRP meant. Its error envelope repeats the status in the body (`status_code: 401`
+ * beside `ok: false`, recorded in `cassette/get-noauth.json`); when something between us and HotCRP
+ * turns the transport status into a 2xx, the body's code still decides.
+ */
+function statusOf(transport: number, body: unknown): number {
+  const c = StatusCode.safeParse(body);
+  return is2xx(transport) && c.success ? c.data.status_code : transport;
+}
+
+/** A body that is no answer of HotCRP's: the portal's messages when it sent any, else "malformed". */
+function refusal(
+  httpStatus: number,
+  body: unknown,
+  what: string,
+): PortalFailure {
+  const e = Envelope.safeParse(body);
+  const messages = e.success ? messagesOf(e.data.message_list) : [];
+  return messages.length > 0 || !is2xx(httpStatus)
+    ? { kind: "refused", httpStatus, messages }
+    : { kind: "malformed", httpStatus, detail: what };
+}
+
+/** `GET /api/paper` → the submission, or why there is none. */
+export function parseShow(
+  httpStatus: number,
+  body: unknown,
+): Result<SubmissionView, PortalFailure> {
+  const status = statusOf(httpStatus, body);
+  const b = ShowBody.safeParse(body);
+  return b.success && is2xx(status)
+    ? ok(viewOf(b.data))
+    : err(refusal(status, body, "the answer has no submission in `paper`"));
+}
+
+/**
+ * `POST /api/paper` → the outcome, valid or not. A body carrying `valid` is HotCRP's verdict on
+ * the change whatever the HTTP status; the caller decides the exit from both.
+ */
+export function parseUpdate(
+  httpStatus: number,
+  body: unknown,
+): Result<UpdateOutcome, PortalFailure> {
+  const status = statusOf(httpStatus, body);
+  const b = UpdateBody.safeParse(body);
+  if (!b.success)
+    return err(refusal(status, body, "the answer has no `valid`"));
+  return ok({
+    httpStatus: status,
+    valid: b.data.valid,
+    changes: b.data.change_list ?? [],
+    messages: messagesOf(b.data.message_list),
+    dryRun: b.data.dry_run ?? false,
+  });
+}

package/src/cli.test.ts

@@ -7,6 +7,7 @@
 import assert from "node:assert/strict";
 import { spawn } from "node:child_process";
 import { existsSync } from "node:fs";
+import { createServer } from "node:http";
 import { dirname, join } from "node:path";
 import { test } from "vitest";
 import { runNode, useTempDir, writeTree } from "../test/support.ts";
@@ -82,6 +83,14 @@ test("parseSettings refuses `talk` in the root file: it is one paper's setting",
   );
 });
 
+test("parseSettings refuses `submission` in the root file: a submission is one paper's", () => {
+  const r = parseSettings({ submission: { id: 7 } }, "paperlint.json", "/r");
+  assert.equal(
+    r.ok ? null : r.error,
+    "paperlint.json: \"submission\" is a paper's setting — set it in that paper's paperlint.json",
+  );
+});
+
 test("parseSettings refuses a non-object, names one unknown key or several, and a mistyped default", () => {
   const error = (json: unknown) => {
     const r = parseSettings(json, "paperlint.json", "/r");
@@ -603,3 +612,103 @@ test("parseSettings refuses a root `identity` that is not a list of words, and t
     true,
   );
 });
+
+test("parseArgs: submission's flags — two values and two switches", () => {
+  assert.deepEqual(
+    parseArgs([
+      "submission",
+      "update",
+      "papers/p",
+      "--pdf=build/p.pdf",
+      "--abstract",
+      "abs.txt",
+      "--submit",
+      "--save",
+    ]),
+    {
+      ...parseArgs([]),
+      cmd: "submission",
+      paths: ["update", "papers/p"],
+      pdf: "build/p.pdf",
+      abstract: "abs.txt",
+      submit: true,
+      save: true,
+    },
+  );
+  assert.equal(
+    parseArgs(["submission", "update", "--pdf"]).missingValue,
+    "--pdf",
+  );
+});
+
+/** A paper whose venue's HotCRP portal is `site`, submission 7, with a paper.pdf. */
+const submissionPaper = (dir: string, site: string): void => {
+  writeTree(dir, {
+    "package.json": "{}",
+    "venue.jsonc": JSON.stringify({
+      extends: "paperlint:aidc",
+      portal: { kind: "hotcrp", url: site },
+    }),
+    "papers/p/paperlint.json": JSON.stringify({
+      extends: "../../venue.jsonc",
+      submission: { id: 7 },
+    }),
+    "papers/p/paper.pdf": "%PDF fake",
+  });
+};
+
+test("🔴 submission: without HOTCRP_TOKEN it names the variable and asks the portal nothing", async () => {
+  const dir = join(root, "submission-no-token");
+  submissionPaper(dir, "http://127.0.0.1:9");
+  const saved = process.env["HOTCRP_TOKEN"];
+  delete process.env["HOTCRP_TOKEN"];
+  try {
+    const r = await cli(["submission", "show", "papers/p"], dir);
+    assert.equal(r.code, 2);
+    assert.match(r.err, /^HOTCRP_TOKEN is not set — /);
+  } finally {
+    if (saved !== undefined) process.env["HOTCRP_TOKEN"] = saved;
+  }
+});
+
+test("submission show: through the HotCRP adapter to a local portal, the token in the header only", async () => {
+  const seen: { url: string; auth: string }[] = [];
+  const server = createServer((req, res) => {
+    seen.push({ url: req.url ?? "", auth: req.headers.authorization ?? "" });
+    res.writeHead(200, { "content-type": "application/json" });
+    res.end(
+      JSON.stringify({
+        ok: true,
+        paper: { object: "paper", pid: 7, status: "submitted", title: "T" },
+      }),
+    );
+  });
+  await new Promise<void>((r) => server.listen(0, "127.0.0.1", r));
+  const address = server.address();
+  assert.ok(address !== null && typeof address === "object");
+  const dir = join(root, "submission-show");
+  submissionPaper(dir, `http://127.0.0.1:${String(address.port)}`);
+  const saved = process.env["HOTCRP_TOKEN"];
+  process.env["HOTCRP_TOKEN"] = "hct_cli_test";
+  try {
+    const r = await cli(["submission", "show"], join(dir, "papers/p"));
+    assert.equal(r.code, 0, r.err);
+    assert.deepEqual(seen, [
+      { url: "/api/paper?p=7&word_limit=hard", auth: "bearer hct_cli_test" },
+    ]);
+    assert.match(
+      r.out,
+      /^submission 7 on http:\/\/127\.0\.0\.1:\d+ \(hotcrp\)$/m,
+    );
+    assert.match(r.out, /^match {9}NO — the portal holds no PDF$/m);
+    assert.doesNotMatch(r.out + r.err, /hct_cli_test/);
+  } finally {
+    if (saved === undefined) delete process.env["HOTCRP_TOKEN"];
+    else process.env["HOTCRP_TOKEN"] = saved;
+    await new Promise<void>((r) => {
+      server.close(() => {
+        r();
+      });
+    });
+  }
+});

package/src/cli.ts

@@ -86,6 +86,10 @@ import {
 } from "./paper-settings.ts";
 import { referenceRules, REFERENCE_RULE_LEVELS } from "./reference-rules.ts";
 import { onlineReferences } from "./adapters/references/index.ts";
+import { hotcrpPortal } from "./adapters/hotcrp/index.ts";
+import { runSubmission } from "./submission.ts";
+import type { PortalKind, SupportedPortal } from "./domain/submission.ts";
+import type { SubmissionPortal } from "./ports/submission-portal.ts";
 import type { CheckReferences } from "./ports/check-references.ts";
 import {
   narrowToOwners,
@@ -99,6 +103,8 @@ import {
   presetProblemText,
   resolvePreset,
   shippedPresets,
+  shippedSpec,
+  shippedVenueNames,
   SHIPPED_PREFIX,
   type PaperPreset,
   type PresetTemplate,
@@ -152,6 +158,10 @@ export { init };
 export { nextSteps } from "./init.ts";
 
 import paperStages from "#eslint-rules/paper-stages";
+import {
+  FOLDER_VENUE_RULE_LEVELS,
+  folderVenueRules,
+} from "./folder-venue-rule.ts";
 import typography from "#eslint-rules/paper-typography";
 import texBuild from "#eslint-rules/tex-build";
 import bibReachable from "#eslint-rules/bib-reachable-entry";
@@ -171,7 +181,9 @@ const USAGE = `paperlint — machine-checkable gates for a paper kept in git
                                       .claude/settings.json, offer the CI step, report what is missing
   npx paperlint new <name> [--venue <preset>] [--kind <kind>] [--format tex|md]
                                       create <papers>/<name>/ from the template; never overwrites,
-                                      on an existing folder adds only the missing files, then lints it
+                                      on an existing folder adds only the missing files, then lints it.
+                                      A <name> that names a venue (aisec-2026) is refused: name the
+                                      paper after the work
   npx paperlint lint [paths…]         run every rule over your papers
   npx paperlint build <paper> | --all
                                       compile paper.tex to paper.pdf: pdflatex and bibtex, rerun until
@@ -187,6 +199,14 @@ const USAGE = `paperlint — machine-checkable gates for a paper kept in git
                                       into ~/.cache/paperlint/texlive (PAPERLINT_TEXLIVE_DIR overrides); a second
                                       run does nothing. --check: report what is missing, change nothing
   npx paperlint doctor                say what is actually wired — and what only LOOKS wired
+  npx paperlint submission show [paper]
+                                      the paper's submission on the venue's portal: status, title,
+                                      type, topics, abstract length, the PDF the portal holds, and
+                                      whether it is the local paper.pdf (sha256)
+  npx paperlint submission update [paper] [--pdf <file>] [--abstract <file>] [--submit] [--save]
+                                      send the PDF (default: the paper's own), an abstract, or
+                                      "submitted". A DRY RUN unless --save: the portal checks the
+                                      change and keeps nothing
   npx paperlint hook <name>           run an editor hook (.claude/settings.json calls this)
   npx paperlint --help
 
@@ -205,6 +225,19 @@ new:
   --kind <kind>       the paper's kind at that venue (its page limit), e.g. short — one of the
                       preset's kinds; needs --venue
   --format tex|md     the paper's source format; default tex
+  --allow-venue-name  create the folder even though its name names a venue (a whole word such as
+                      "realm" can be the work's own). Without it such a name is refused: a rejected
+                      paper moves to another venue and keeps its folder
+
+submission:
+  The venue preset declares the portal — "portal": { "kind": "hotcrp", "url": "<site>" } — and the
+  paper's paperlint.json its submission there — "submission": { "id": <number> }. The token comes
+  only from the environment: HOTCRP_TOKEN (HotCRP: Account settings → Developer).
+  [paper]             the paper's folder; default the current directory
+  --pdf <file>        the PDF to compare (show) or send (update) instead of the paper's own
+  --abstract <file>   update: a plain-text file whose text replaces the abstract
+  --submit            update: mark the submission submitted
+  --save              update: really change the submission. Without it, nothing is saved
 
 lint:
   npx paperlint lint [paths…] [--fix] [--config <file.json>] [--json]
@@ -313,11 +346,22 @@ export function buildConfig(
     },
     {
       files: ["**/PIPELINE-STATUS.md"],
-      plugins: { markdown, paper: paperStages },
+      // Every paper folder has one, whatever its source format: the rules about the folder itself
+      // (its stages, its frozen sources, its name) are judged here, once per paper.
+      plugins: {
+        markdown,
+        paper: {
+          rules: {
+            ...paperStages.rules,
+            ...folderVenueRules({ files: nodeFiles, venuesDir: presetsDir() }),
+          },
+        },
+      },
       ...md,
       rules: {
         "paper/stages": "error",
         "paper/source": "error",
+        ...FOLDER_VENUE_RULE_LEVELS,
       },
     },
     {
@@ -781,10 +825,15 @@ export function parseArgs(argv: readonly string[]): Args {
     check: false,
     yes: false,
     noHooks: false,
+    allowVenueName: false,
     paper: null,
     format: null,
     venue: null,
     kind: null,
+    pdf: null,
+    abstract: null,
+    submit: false,
+    save: false,
     hooksMode: null,
     // -1 = warnings NEVER fail the run. In this set most findings are advisory by design, and a
     // gate that fails on advice gets muted entirely.
@@ -824,19 +873,14 @@ export function parseArgs(argv: readonly string[]): Args {
       if (inline === "") out.missingValue = a;
       return inline === "" ? undefined : inline;
     };
-    if (a === "--json") out.json = true;
-    else if (a === "--fix") out.fix = true;
-    else if (a === "--all") out.all = true;
-    else if (a === "--dry-run") out.dryRun = true;
-    else if (a === "--check") out.check = true;
-    else if (a === "--yes" || a === "-y") out.yes = true;
-    else if (a === "--no-hooks") out.noHooks = true;
+    const on = SWITCHES.get(a);
+    if (on !== undefined) out[on] = true;
     else if (a.startsWith("--hooks="))
       out.hooksMode = a.slice("--hooks=".length);
-    else if (a === "--paper") out.paper = take() ?? null;
-    else if (a === "--format") out.format = take() ?? null;
-    else if (a === "--venue") out.venue = take() ?? null;
-    else if (a === "--kind") out.kind = take() ?? null;
+    else if (STRING_FLAGS.has(a)) {
+      const field = STRING_FLAGS.get(a);
+      if (field !== undefined) out[field] = take() ?? null;
+    }
     // `--options` was the first spelling and is kept working. It named the wrong thing — every
     // other tool in the stack calls this file its config — but a flag in someone's CI is not
     // ours to break.
@@ -852,12 +896,49 @@ export function parseArgs(argv: readonly string[]): Args {
   return out;
 }
 
+/** The flags that take no value: each turns one field of `Args` on. */
+const SWITCHES: ReadonlyMap<
+  string,
+  | "json"
+  | "fix"
+  | "all"
+  | "dryRun"
+  | "check"
+  | "yes"
+  | "noHooks"
+  | "allowVenueName"
+  | "submit"
+  | "save"
+> = new Map([
+  ["--json", "json"],
+  ["--fix", "fix"],
+  ["--all", "all"],
+  ["--dry-run", "dryRun"],
+  ["--check", "check"],
+  ["--yes", "yes"],
+  ["-y", "yes"],
+  ["--no-hooks", "noHooks"],
+  ["--allow-venue-name", "allowVenueName"],
+  ["--submit", "submit"],
+  ["--save", "save"],
+]);
+
+/** The flags whose value is one string field of `Args`. */
+const STRING_FLAGS: ReadonlyMap<
+  string,
+  "paper" | "format" | "venue" | "kind" | "pdf" | "abstract"
+> = new Map([
+  ["--paper", "paper"],
+  ["--format", "format"],
+  ["--venue", "venue"],
+  ["--kind", "kind"],
+  ["--pdf", "pdf"],
+  ["--abstract", "abstract"],
+]);
+
 /** The flags that take a value, in either spelling: `--flag value` or `--flag=value`. */
 const VALUE_FLAGS: ReadonlySet<string> = new Set([
-  "--paper",
-  "--format",
-  "--venue",
-  "--kind",
+  ...STRING_FLAGS.keys(),
   "--config",
   "--options",
   "--max-warnings",
@@ -1048,15 +1129,21 @@ export async function createPaperAt(
     err,
     cwd,
     venue = null,
+    allowVenueName = false,
   }: {
     log: typeof console.log;
     err: typeof console.error;
     cwd: string;
     /** What `--venue` chose; null writes the template's `paperlint.json` as it is. */
     venue?: VenueChoice | null;
+    /** `--allow-venue-name`: a name that names a venue is created, not refused. */
+    allowVenueName?: boolean;
   },
 ): Promise<number> {
-  const result = newPaper(papersRoot, name, format, { venue });
+  const result = newPaper(papersRoot, name, format, {
+    venue,
+    venues: allowVenueName ? [] : shippedVenueNames(PRESET_DEPS),
+  });
   const here = (p: string): string => shown(cwd, p);
   for (const line of reportNewPaper(result, here)) log(line);
   if (!result.ok) return 2;
@@ -1194,7 +1281,7 @@ function venueSpec(
     return bad(
       `--venue ${venue}: no such venue preset. Shipped: ${shipped.join(", ")} — or a path to your own preset, starting with ./ or ../`,
     );
-  return { ok: true, value: `${SHIPPED_PREFIX}${name}` };
+  return { ok: true, value: shippedSpec(name) };
 }
 
 /**
@@ -1274,6 +1361,7 @@ async function runNew(
     err,
     cwd,
     venue: venue.value,
+    allowVenueName: a.allowVenueName,
   });
 }
 
@@ -1420,7 +1508,37 @@ const SIMPLE: Readonly<
       banal: hostBanalInstaller(),
       tex: toolchainTex(cwd),
     }),
+  submission: (a, { log, err, cwd }) =>
+    runSubmission(
+      {
+        sub: a.paths[0],
+        paperDir: a.paths[1] ?? ".",
+        extra: a.paths.slice(2),
+        pdf: a.pdf,
+        abstract: a.abstract,
+        submit: a.submit,
+        save: a.save,
+      },
+      {
+        files: nodeFiles,
+        presets: PRESET_DEPS,
+        cwd,
+        env: (name) => process.env[name],
+        portalFor,
+        log,
+        err,
+      },
+    ),
+};
+
+/** The adapter of each portal kind — one per kind, chosen here at the root. */
+const PORTALS: Readonly<
+  Record<PortalKind, (url: string, token: string) => SubmissionPortal>
+> = {
+  hotcrp: (url, token) => hotcrpPortal({ url, token }),
 };
+const portalFor = (p: SupportedPortal, token: string): SubmissionPortal =>
+  PORTALS[p.kind](p.url, token);
 
 /** banal's installer, wired from this process's environment: the composition root's work. */
 function hostBanalInstaller(): ToolInstaller {
@@ -1503,6 +1621,7 @@ async function runInit(
     format: isFormat(a.format) ? a.format : null,
     createPaper: (papersRoot, name, format) =>
       createPaperAt(papersRoot, name, format, { log, err, cwd }),
+    venues: shippedVenueNames(PRESET_DEPS),
     tex: initTexLive(a, { log, err, cwd }),
     resolveCliPapers: (root: string): string | null =>
       cliPapers({ ...a, config: null }, root),
@@ -1584,8 +1703,8 @@ export async function run(
   // editing a file.
   //
   // 🔴 A path FROM THE CONFIG is resolved relative to the PROJECT ROOT, not the current directory.
-  // Otherwise walking up is pointless: from `papers/aisec-2026` the root would be found, but
-  // `"papersDir": "papers"` would point at `papers/aisec-2026/papers`. A command-line argument stays
+  // Otherwise walking up is pointless: from `papers/rule-drift` the root would be found, but
+  // `"papersDir": "papers"` would point at `papers/rule-drift/papers`. A command-line argument stays
   // relative to the current directory: it was typed here and now.
   //
   // Both kinds end up ABSOLUTE: ESLint below runs from `lintRoot`, not from here, and would resolve a

package/src/domain/result.test.ts

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict";
 import { test } from "vitest";
-import { andThen, err, map, match, ok, type Result } from "./result.ts";
+import { andThen, err, isOk, map, match, ok, type Result } from "./result.ts";
 
 const half = (n: number): Result<number, string> =>
   n % 2 === 0 ? ok(n / 2) : err(`${String(n)} is odd`);
@@ -28,3 +28,11 @@ test("match picks the branch by `ok`", () => {
   assert.equal(say(half(4)), "got 2");
   assert.equal(say(half(5)), "no: 5 is odd");
 });
+
+test("isOk: filter keeps the successes, and their values are read without a cast", () => {
+  const rs = [2, 3, 4].map(half);
+  assert.deepEqual(
+    rs.filter(isOk).map((r) => r.value),
+    [1, 2],
+  );
+});

package/src/domain/result.ts

@@ -10,6 +10,11 @@ export type Result<T, E> =
 export const ok = <T>(value: T): Result<T, never> => ({ ok: true, value });
 export const err = <E>(error: E): Result<never, E> => ({ ok: false, error });
 
+/** Whether `r` succeeded — a type guard, so `filter(isOk)` keeps the successes as successes. */
+export const isOk = <T, E>(
+  r: Result<T, E>,
+): r is Extract<Result<T, E>, { readonly ok: true }> => r.ok;
+
 export const map = <T, U, E>(r: Result<T, E>, f: (t: T) => U): Result<U, E> =>
   r.ok ? ok(f(r.value)) : r;
 

package/src/domain/submission.test.ts

@@ -0,0 +1,45 @@
+/** The submission values: a paper's `submission` key, the portal kinds an adapter exists for, words. */
+import assert from "node:assert/strict";
+import { test } from "vitest";
+import {
+  parsePaperSubmission,
+  supportedPortal,
+  wordCount,
+} from "./submission.ts";
+
+test("parsePaperSubmission: absent is null; { id } with a positive integer is the value", () => {
+  assert.deepEqual(parsePaperSubmission(undefined), { ok: true, value: null });
+  assert.deepEqual(parsePaperSubmission({ id: 7 }), {
+    ok: true,
+    value: { id: 7 },
+  });
+});
+
+test("🔴 parsePaperSubmission: a string id, zero, a fraction, a list, an unknown key — each refused", () => {
+  const shape = `"submission" must be { "id": <the submission number on the venue's portal> }`;
+  for (const bad of [{ id: "7" }, { id: 0 }, { id: 1.5 }, [7], 7, null, {}])
+    assert.deepEqual(parsePaperSubmission(bad), { ok: false, error: shape });
+  assert.deepEqual(parsePaperSubmission({ id: 7, pid: 7 }), {
+    ok: false,
+    error: `"submission" has an unknown key "pid" — known: id`,
+  });
+});
+
+test("supportedPortal: hotcrp is, with the trailing slash dropped; any other kind is refused by name", () => {
+  assert.deepEqual(
+    supportedPortal({ kind: "hotcrp", url: "https://example.test//" }),
+    { ok: true, value: { kind: "hotcrp", url: "https://example.test" } },
+  );
+  assert.deepEqual(
+    supportedPortal({ kind: "openreview", url: "https://example.test" }),
+    {
+      ok: false,
+      error: `portal kind "openreview" is not supported; upload by hand`,
+    },
+  );
+});
+
+test("wordCount: runs of non-space, any whitespace between", () => {
+  assert.equal(wordCount(""), 0);
+  assert.equal(wordCount("  one\ttwo\n\nthree  "), 3);
+});