paperlint 11.0.0 → 11.1.0

package/src/submission-update.test.ts

@@ -21,7 +21,12 @@ test("update: a dry run by default — the paper's PDF sent, nothing saved, exit
     [
       "update",
       7,
-      { pdf: { name: "paper.pdf", bytes: PDF }, abstract: null, submit: false },
+      {
+        pdf: { name: "paper.pdf", bytes: PDF },
+        abstract: null,
+        submit: false,
+        fields: {},
+      },
       { save: false },
     ],
   ]);
@@ -58,6 +63,7 @@ test("update --save --submit --abstract --pdf: all of it sent, and said to be sa
         pdf: { name: "other.pdf", bytes: PDF },
         abstract: "The abstract.",
         submit: true,
+        fields: {},
       },
       { save: true },
     ],

package/src/submission.test.ts

@@ -239,7 +239,7 @@ test("usage: refused before anything is read, exit 2", async () => {
 
 test("usage: a subcommand is required, one paper folder, update-only flags refused on show", () => {
   expect(usageProblem({ ...ARGS, sub: undefined }) ?? "").toMatch(
-    /needs a subcommand: new or show or update — got ``/,
+    /needs a subcommand: new or show or update or topics — got ``/,
   );
   expect(usageProblem({ ...ARGS, sub: "upload" }) ?? "").toMatch(
     /got `upload`/,

package/src/submission.ts

@@ -1,6 +1,6 @@
 /**
- * `paperlint submission show|update [paper-dir]` — read and change a paper's submission on the
- * venue's portal, through the portal's API.
+ * `paperlint submission new|show|update|topics [paper-dir]` — create, read and change a paper's
+ * submission on the venue's portal, through the portal's API.
  *
  * The command is named by the job, not by the portal: WHERE the submission lives is data. The venue
  * preset declares the portal (`"portal": { "kind": "hotcrp", "url": … }`), the paper's
@@ -11,6 +11,12 @@
  *            whether it is the local `paper.pdf`, by sha256
  *   update   send the PDF (and, if asked, an abstract, or "submitted"). A DRY RUN unless `--save`:
  *            the portal checks the change and keeps nothing
+ *   topics   the topics the portal offers, against the ones the venue preset records
+ *
+ * `new` and `update` also send the paper's `fields` — its answers to the venue's own form fields
+ * (topics, PC conflicts, …), checked against the preset's `submission_fields` before anything is
+ * sent (`src/domain/submission-fields.ts`). A checkbox field the portal did not take is said, and
+ * fails the command: HotCRP keeps an option it does not know as nothing, without an error.
  *
  * 🔴 THE TOKEN IS AN INPUT, AND ONLY AN INPUT. It comes from the environment (the root reads it), is
  * handed to the adapter, and never appears in anything printed here.
@@ -33,6 +39,12 @@ import {
   type SupportedPortal,
   type UpdateOutcome,
 } from "./domain/submission.ts";
+import {
+  droppedFields,
+  parsePaperFields,
+  type FieldValues,
+  type VenueFields,
+} from "./domain/submission-fields.ts";
 import type { Files } from "./ports/files.ts";
 import type {
   PortalSite,
@@ -111,7 +123,7 @@ export function tokenRefusedLines(
   return [why, ...tokenSteps(portal, site, variable)];
 }
 
-export const SUBCOMMANDS = ["new", "show", "update"] as const;
+export const SUBCOMMANDS = ["new", "show", "update", "topics"] as const;
 export type Subcommand = (typeof SUBCOMMANDS)[number];
 const isSubcommand = (s: string | undefined): s is Subcommand =>
   SUBCOMMANDS.some((x) => x === s);
@@ -158,6 +170,15 @@ export interface SubmissionTarget {
   readonly config: string;
   /** The authors the paper declares for the portal; null when it declares none. */
   readonly authors: readonly Author[] | null;
+  /**
+   * The paper's answers to the venue's own form fields, checked against `venueFields`: only `new`
+   * and `update` send them, so only they stop on a problem — `show` and `topics` read past it.
+   */
+  readonly answers: Result<FieldValues, string>;
+  /** The answers to send: `answers`' value once a sending subcommand checked it; empty otherwise. */
+  readonly fields: FieldValues;
+  /** The venue's own form fields, as its preset records them; null when it records none. */
+  readonly venueFields: VenueFields | null;
   /** The cycle attempt is accepted: a new submission belongs to a new cycle. */
   readonly accepted: boolean;
   /** The paper's built PDF, absolute. */
@@ -182,35 +203,55 @@ const noPresetLine = (
     ? `${configOf(paperDir)}: no "extends" — the venue preset it names declares the portal ("portal": { "kind": …, "url": … })`
     : `${configOf(paperDir)}: the current cycle names no venue preset, and the preset is what declares the portal — set the venue in the current cycle ("venue": { "kind": "preset", "extends": "paperlint:…" }), or upload by hand`;
 
+/** The paper's `fields`, checked against its venue preset's form, or the line naming what is wrong. */
+function fieldsOf(
+  paperDir: string,
+  p: Extract<PaperPreset, { readonly kind: "resolved" }>,
+): Result<FieldValues, string> {
+  const fields = parsePaperFields(
+    p.settings.fields,
+    p.preset.submissionFields,
+    p.preset.chain.join(", "),
+  );
+  return fields.ok ? fields : err(`${configOf(paperDir)}: ${fields.error}`);
+}
+
+/** The venue preset's portal, if it declares one that paperlint can talk to; else the line to act on. */
+function portalOfPreset(
+  p: Extract<PaperPreset, { readonly kind: "resolved" }>,
+): Result<SupportedPortal, string> {
+  const declared = p.preset.portal;
+  return declared === null
+    ? err(
+        `the venue preset declares no "portal" (read: ${p.preset.chain.join(", ")}) — add "portal": { "kind": "hotcrp", "url": "<the site>" } to the venue's preset, or upload by hand`,
+      )
+    : supportedPortal(declared);
+}
+
 /** A resolved paper → its portal and submission, or the line naming the file and key to set. */
 function targetOf(
   paperDir: string,
   p: Extract<PaperPreset, { readonly kind: "resolved" }>,
 ): Result<SubmissionTarget, string> {
-  const declared = p.preset.portal;
-  if (declared === null)
-    return err(
-      `the venue preset declares no "portal" (read: ${p.preset.chain.join(", ")}) — add "portal": { "kind": "hotcrp", "url": "<the site>" } to the venue's preset, or upload by hand`,
-    );
-  const portal = supportedPortal(declared);
+  const portal = portalOfPreset(p);
   if (!portal.ok) return portal;
-  const pdf = join(paperDir, p.settings.pdf ?? "paper.pdf");
   const identity = p.preset.identity;
-  const call = identity.type === "venue" ? identity.url : null;
   const own =
     p.settings.cycles === null
       ? []
       : currentDeadlines(p.settings.cycles.current);
-  const deadlines = deadlinesInForce(own, p.preset.deadlines);
   return ok({
     portal: portal.value,
     id: p.settings.submission?.id ?? null,
     config: configOf(paperDir),
     authors: p.settings.authors,
+    answers: fieldsOf(paperDir, p),
+    fields: {},
+    venueFields: p.preset.submissionFields,
     accepted: p.settings.cycles?.current.kind === "accepted",
-    pdf,
-    call,
-    deadlines,
+    pdf: join(paperDir, p.settings.pdf ?? "paper.pdf"),
+    call: identity.type === "venue" ? identity.url : null,
+    deadlines: deadlinesInForce(own, p.preset.deadlines),
   });
 }
 
@@ -312,6 +353,28 @@ export function showLines(
 export const checkPdfLine = (shown: string, call: string | null): string =>
   `before you rely on it, open ${shown} yourself and check it against ${call === null ? "the venue's call for papers" : `the call for papers, ${call}`}: the page count and what counts toward the limit, the template and its class options, anonymity, and that every figure, table and reference renders — paperlint passing is not the venue accepting the format`;
 
+/** The fields the paper sent, one line each, as the portal will get them. Pure. */
+export const fieldLines = (fields: FieldValues): readonly string[] =>
+  Object.entries(fields).map(
+    ([key, value]) => `field         ${key}: ${JSON.stringify(value)}`,
+  );
+
+/** The checkbox fields the portal did not take, said; none when it took them all. Pure. */
+export function droppedLines(
+  fields: FieldValues,
+  venue: VenueFields | null,
+  o: UpdateOutcome,
+): readonly string[] {
+  const dropped = droppedFields(fields, venue, {
+    changes: o.changes,
+    messageFields: o.messages.map((m) => m.field),
+  });
+  return dropped.map(
+    (key) =>
+      `NOT TAKEN     ${key}: the portal kept none of ${JSON.stringify(fields[key])} — an option it does not know is dropped without an error; \`paperlint submission topics\` lists what it offers`,
+  );
+}
+
 /** `update`'s report. Pure. */
 export function updateLines(
   o: UpdateOutcome,
@@ -346,6 +409,12 @@ type RunDeps = SubmissionDeps & {
   readonly refused: (f: PortalFailure) => readonly string[];
 };
 
+const logAll = (lines: readonly string[], deps: RunDeps): void => {
+  lines.forEach((l) => {
+    deps.log(l);
+  });
+};
+
 /** A failure printed — the portal's words, then what to do about the token if it was the token — exit 1. */
 function failed(f: PortalFailure, deps: RunDeps): number {
   [failureText(f), ...deps.refused(f)].forEach((l) => {
@@ -395,15 +464,17 @@ function abstractOf(
     : ok(new TextDecoder().decode(bytes).trim());
 }
 
-/** What `update` sends: the PDF's bytes, the abstract's text, and whether to mark it submitted. */
+/** What `update` sends: the PDF's bytes, the abstract's text, whether to mark it submitted, the fields. */
 const changeOf = (
   a: SubmissionArgs & { readonly pdfPath: string },
   bytes: Uint8Array,
   abstract: string | null,
+  fields: FieldValues,
 ) => ({
   pdf: { name: basename(a.pdfPath), bytes },
   abstract,
   submit: a.submit,
+  fields,
 });
 
 /** `update`: send the PDF (and the abstract, and "submitted" when asked); a dry run unless saving. */
@@ -422,18 +493,16 @@ async function runUpdate(
     );
   const abstract = abstractOf(a, deps);
   if (!abstract.ok) return (deps.err(abstract.error), 2);
-  deps.log(checkPdfLine(shown, t.call));
-  const r = await portal.update(t.id, changeOf(a, bytes, abstract.value), {
-    save: a.save,
-  });
+  logAll([checkPdfLine(shown, t.call), ...fieldLines(t.fields)], deps);
+  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) };
-  updateLines(r.value, local, a.save).forEach((l) => {
-    deps.log(l);
-  });
+  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 ? 0 : 1;
+  return fine && dropped.length === 0 ? 0 : 1;
 }
 
 // ── new ──────────────────────────────────────────────────────────────────────────────
@@ -541,31 +610,37 @@ const noReadableTitle = (text: string): string =>
     : `the \\title in ${MAIN} uses a command paperlint does not read («${text.replaceAll(OPAQUE, "…")}»), and the PDF names no Title — set \\hypersetup{pdftitle={<the title as plain text>}} and rebuild`;
 
 /** What `new` will send, as the author reads it before saying yes. Pure. */
-export function newLines(
-  title: string,
-  abstract: string,
-  authors: readonly Author[],
-): readonly string[] {
+export function newLines(p: NewSubmission): readonly string[] {
   return [
-    `title         ${title}`,
-    ...authors.map(
+    `title         ${p.title}`,
+    ...p.authors.map(
       (a, i) =>
         `author ${String(i + 1).padEnd(6)} ${a.name} <${a.email}>${a.affiliation === null ? "" : `, ${a.affiliation}`}`,
     ),
-    `abstract      ${String(wordCount(abstract))} words:`,
-    `  ${abstract}`,
+    `abstract      ${String(wordCount(p.abstract))} words:`,
+    `  ${p.abstract}`,
+    ...fieldLines(p.fields),
   ];
 }
 
-/** What the author does on the site after `new`: what paperlint does not send. Pure. */
+/** What is left after `new`: the venue's fields the paper did not answer, what only the site takes, the submit. Pure. */
 export function onTheSiteLines(
   site: PortalSite,
+  t: Pick<SubmissionTarget, "fields" | "venueFields">,
   id: number | null,
   paperArg: string,
 ): readonly string[] {
+  const sent = Object.keys(t.fields);
+  const unanswered = Object.keys(t.venueFields?.fields ?? {}).filter(
+    (k) => !sent.includes(k),
+  );
   return [
-    `do on the site, ${site.submissionPage(id)} — paperlint sends only the title, the abstract, the authors and the PDF:`,
-    ...site.siteOnly.map((f) => `  - ${f}`),
+    `still to do for ${site.submissionPage(id)} — paperlint sent the title, the abstract, the authors and the PDF${sent.length ? `, and ${sent.join(", ")}` : ""}:`,
+    ...unanswered.map(
+      (k) =>
+        `  - answer ${k} in the paper's paperlint.json "fields" (the venue preset records it), then: npx paperlint submission update ${paperArg} (a dry run; --save after your yes)`,
+    ),
+    ...site.siteOnly.map((f) => `  - on the site: ${f}`),
     `  - then mark it submitted: npx paperlint submission update ${paperArg} --submit (a dry run; --save after your yes)`,
   ];
 }
@@ -695,6 +770,7 @@ function newSubmissionOf(
     ...text.value,
     authors: authors.value,
     pdf: { name: basename(a.pdfPath), bytes: pdf },
+    fields: t.fields,
   };
   return ok({ paper, shown });
 }
@@ -721,11 +797,18 @@ function recordCreated(
   return 0;
 }
 
-const logAll = (lines: readonly string[], deps: RunDeps): void => {
-  lines.forEach((l) => {
-    deps.log(l);
-  });
-};
+/** After a creation the portal took: what is still to do, and the id recorded when it saved one. */
+function afterCreated(
+  t: SubmissionTarget,
+  id: number | null,
+  a: SubmissionArgs & { readonly paperDir: string },
+  deps: RunDeps,
+): number {
+  const paperArg =
+    a.paperDir === deps.cwd ? "." : shownPath(deps.cwd, a.paperDir);
+  logAll(onTheSiteLines(deps.portalSite, t, id, paperArg), deps);
+  return id === null ? 0 : recordCreated(t, id, paperArg, deps);
+}
 
 /**
  * `new`: create the paper's submission — title and abstract from the build, the authors the paper
@@ -741,17 +824,85 @@ async function runNew(
   if (!n.ok) return (deps.err(n.error), 2);
   const { paper, shown } = n.value;
   deps.log(checkPdfLine(shown, t.call));
-  logAll(newLines(paper.title, paper.abstract, paper.authors), deps);
+  logAll(newLines(paper), deps);
   const r = await portal.create(paper, { save: a.save });
   if (!r.ok) return failed(r.error, deps);
-  logAll(createLines(r.value, a.save), 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;
-  const paperArg =
-    a.paperDir === deps.cwd ? "." : shownPath(deps.cwd, a.paperDir);
-  logAll(onTheSiteLines(deps.portalSite, r.value.id, paperArg), deps);
-  return r.value.id === null ? 0 : recordCreated(t, r.value.id, paperArg, deps);
+  const recorded = afterCreated(t, r.value.id, a, deps);
+  return dropped.length === 0 ? recorded : 1;
+}
+
+/** The subcommands that run before the paper has a submission id: `new` creates it, `topics` needs none. */
+const NEEDS_NO_ID: readonly string[] = ["new", "topics"];
+/** The subcommands that send the paper's answers to the venue's fields. */
+const SENDS_FIELDS: readonly string[] = ["new", "update"];
+
+/**
+ * What the subcommand needs before a token is looked up: the submission id (`show`, `update`) and
+ * the paper's checked answers (`new`, `update`) — or the line naming what to fix.
+ */
+function readyFor(
+  sub: string | undefined,
+  t: SubmissionTarget,
+): Result<
+  { readonly id: number | null; readonly fields: FieldValues },
+  string
+> {
+  const id = NEEDS_NO_ID.some((s) => s === sub) ? ok(null) : idOf(t);
+  if (!id.ok) return id;
+  const fields = SENDS_FIELDS.some((s) => s === sub) ? t.answers : ok({});
+  return fields.ok ? ok({ id: id.value, fields: fields.value }) : fields;
+}
+
+/** The checkbox field the preset records the portal's topics under: the one named `topics`. */
+const TOPICS = "topics";
+
+/** `topics`' report: each topic the portal offers against the preset's options, and whether they agree. Pure. */
+export function topicsReport(
+  t: Pick<SubmissionTarget, "portal" | "venueFields">,
+  offered: readonly string[],
+): { readonly lines: readonly string[]; readonly agrees: boolean } {
+  const declared = t.venueFields?.fields[TOPICS];
+  const head = `topics on ${t.portal.url}: ${String(offered.length)}`;
+  if (t.venueFields === null || declared?.kind !== "checkboxes")
+    return {
+      lines: [
+        head,
+        ...offered.map((n) => `  ${n}`),
+        `the venue preset records no "submission_fields" with "topics" — record these, spelled as listed, before a paper can send any`,
+      ],
+      agrees: false,
+    };
+  const recorded = declared.options;
+  const extra = offered.filter((n) => !recorded.includes(n));
+  const missing = recorded.filter((n) => !offered.includes(n));
+  return {
+    lines: [
+      `${head}; the preset records ${String(recorded.length)} (read ${t.venueFields.read})`,
+      ...offered.map(
+        (n) => `  ${recorded.includes(n) ? "✓" : "+ not in the preset:"} ${n}`,
+      ),
+      ...missing.map((n) => `  − in the preset, not offered: ${n}`),
+    ],
+    agrees: extra.length === 0 && missing.length === 0,
+  };
+}
+
+/** `topics`: what the portal offers, and whether the preset records the same — exit 1 when not. */
+async function runTopics(
+  t: SubmissionTarget,
+  portal: SubmissionPortal,
+  deps: RunDeps,
+): Promise<number> {
+  const r = await portal.options();
+  if (!r.ok) return failed(r.error, deps);
+  const report = topicsReport(t, r.value.topics);
+  logAll(report.lines, deps);
+  return report.agrees ? 0 : 1;
 }
 
 //** The flags that change something, as given. */
@@ -769,8 +920,8 @@ export function usageProblem(a: SubmissionArgs): string | null {
   if (a.extra.length > 0)
     return `\`submission ${a.sub}\` takes one paper folder — got also \`${a.extra.join(" ")}\``;
   const writing = writingFlags(a);
-  if (a.sub === "show" && writing.length > 0)
-    return `${writing.join(", ")}: only \`submission new\` and \`submission update\` change anything; \`show\` reads`;
+  if ((a.sub === "show" || a.sub === "topics") && writing.length > 0)
+    return `${writing.join(", ")}: only \`submission new\` and \`submission update\` change anything; \`${a.sub}\` reads`;
   return a.sub === "new" && a.submit
     ? "--submit: `submission new` creates the submission; mark it submitted with `submission update --submit` once `show` says the portal holds this build"
     : null;
@@ -805,8 +956,8 @@ export async function runSubmission(
   const paperDir = resolve(deps.cwd, a.paperDir);
   const t = submissionTarget(paperDir, deps.presets);
   if (!t.ok) return (deps.err(t.error), 2);
-  const id = a.sub === "new" ? ok(null) : idOf(t.value);
-  if (!id.ok) return (deps.err(id.error), 2);
+  const ready = readyFor(a.sub, t.value);
+  if (!ready.ok) return (deps.err(ready.error), 2);
   const site = deps.site(t.value.portal);
   const found = lookUpToken(tokenNames(site), deps.env);
   if (!found.ok) return tokenMissing(t.value.portal, site, found.error, deps);
@@ -817,9 +968,11 @@ export async function runSubmission(
     portalSite: site,
     refused: (f) => tokenRefusedLines(t.value.portal, site, f),
   };
-  if (id.value === null)
-    return runNew(t.value, portal, { ...a, pdfPath, paperDir }, withToken);
-  const target = { ...t.value, id: id.value };
+  const sending = { ...t.value, fields: ready.value.fields };
+  if (a.sub === "topics") return runTopics(sending, portal, withToken);
+  if (ready.value.id === null)
+    return runNew(sending, portal, { ...a, pdfPath, paperDir }, withToken);
+  const target = { ...sending, id: ready.value.id };
   return a.sub === "show"
     ? runShow(target, portal, pdfPath, withToken)
     : runUpdate(target, portal, { ...a, pdfPath }, withToken);

package/src/tex-requirements.test.ts

@@ -54,6 +54,27 @@ test("a venue without the link to its call for papers is refused at load, saying
   );
 });
 
+test("🔴 submission_fields naming a key the submission object carries itself is refused, naming it", () => {
+  // Guards: a field `submission` spread over the PDF's `content_file` would drop the upload.
+  const preset = (key: string) => ({
+    type: "venue",
+    name: "X",
+    url: "https://example.org/cfp",
+    extends: "paperlint:acm-sigconf",
+    submission_fields: {
+      source: "form",
+      url: "https://example.org/paper/new",
+      read: "2026-10-20",
+      fields: { [key]: { kind: "text" } },
+    },
+  });
+  assert.equal(
+    refusalOf("v.jsonc", preset("submission")),
+    'v.jsonc: "submission_fields" names "submission", which paperlint sends itself (object, pid, title, abstract, authors, submission, status) — a field of that name would overwrite it',
+  );
+  assert.equal(refusalOf("v.jsonc", preset("topics")), "");
+});
+
 test("a template family with a venue's name and url is refused, naming each key", () => {
   assert.equal(
     refusalOf("f.jsonc", {

package/src/tex-requirements.ts

@@ -36,6 +36,12 @@ import {
 } from "./domain/talk.ts";
 import type { VenuePortal } from "./domain/submission.ts";
 import type { Reading } from "./domain/deadline.ts";
+import {
+  RESERVED_FIELD_KEYS,
+  reservedKey,
+  type FieldKind,
+  type VenueFields,
+} from "./domain/submission-fields.ts";
 
 /** CTAN package name → the names that prove it is installed. */
 export type PackageProofs = Readonly<Record<string, readonly string[]>>;
@@ -222,6 +228,8 @@ export interface PresetFile {
   readonly portal: VenuePortal | null;
   /** The edition's deadlines as they were read; null when the file names none (a child's list replaces its parent's). */
   readonly deadlines: readonly Reading[] | null;
+  /** The fields the edition's submission form asks, as read; null when the file records none. */
+  readonly submissionFields: VenueFields | null;
 }
 
 type KindsJson = Readonly<
@@ -280,6 +288,54 @@ interface PresetBodyJson {
   readonly talk?: VenueTalkJson;
   readonly portal?: VenuePortal;
   readonly deadlines?: readonly Reading[];
+  readonly submission_fields?: SubmissionFieldsJson;
+}
+
+/** A preset's `submission_fields` after the schema accepted it. */
+interface SubmissionFieldsJson {
+  readonly source: VenueFields["source"];
+  readonly url: string;
+  readonly read: string;
+  readonly fields: Readonly<
+    Record<
+      string,
+      {
+        readonly kind: FieldKind;
+        readonly required?: boolean;
+        readonly label?: string;
+        readonly options?: readonly string[];
+      }
+    >
+  >;
+}
+
+/** A preset's `submission_fields`, or null when it records none; a reserved field name is refused. */
+function submissionFieldsOf(
+  j: SubmissionFieldsJson | undefined,
+  file: string,
+): VenueFields | null {
+  if (j === undefined) return null;
+  const reserved = reservedKey(Object.keys(j.fields));
+  if (reserved !== null)
+    throw new Error(
+      `${file}: "submission_fields" names "${reserved}", which paperlint sends itself (${RESERVED_FIELD_KEYS.join(", ")}) — a field of that name would overwrite it`,
+    );
+  return {
+    source: j.source,
+    url: j.url,
+    read: j.read,
+    fields: Object.fromEntries(
+      Object.entries(j.fields).map(([key, f]) => [
+        key,
+        {
+          kind: f.kind,
+          required: f.required ?? false,
+          label: f.label ?? null,
+          options: f.options ?? [],
+        },
+      ]),
+    ),
+  };
 }
 
 /** An optional field as the typed preset holds it: absent is null. */
@@ -424,6 +480,16 @@ function deadlinesOf(
   }));
 }
 
+/** A preset's blocks about its portal: where, the deadlines read there, the form's own fields. */
+const portalBlocks = (
+  j: PresetJson,
+  file: string,
+): Pick<PresetFile, "portal" | "deadlines" | "submissionFields"> => ({
+  portal: portalOf(j.portal),
+  deadlines: deadlinesOf(j.deadlines, file),
+  submissionFields: submissionFieldsOf(j.submission_fields, file),
+});
+
 /**
  * The text of one preset file → the typed file, or an Error naming every problem. The ONE parser
  * of a preset: the toolchain reads its `tex`, the venue rules its `format`, the config its `rules`.
@@ -458,8 +524,7 @@ export function parsePreset(
     rules: j.rules ?? {},
     registerAnchors: anchorsOf(j.register),
     talk: j.talk === undefined ? null : venueTalkOf(j.talk),
-    portal: portalOf(j.portal),
-    deadlines: deadlinesOf(j.deadlines, file),
+    ...portalBlocks(j, file),
   };
 }