paperlint 6.0.0 → 6.2.0

package/src/cli.ts

@@ -48,7 +48,16 @@ import { cacheRoot, cachedTree, runToolchain } from "./toolchain.ts";
 import { banalInstaller, parseBanalSettings } from "./adapters/banal/index.ts";
 import { curlDownload } from "./adapters/curl/index.ts";
 import { latexReader } from "./adapters/latex/index.ts";
-import { hostDirs, nodeAdapters, nodeFiles } from "./adapters/node/index.ts";
+import {
+  hostDirs,
+  nodeAdapters,
+  nodeFiles,
+  nodeListDir,
+} from "./adapters/node/index.ts";
+import { probeVideo } from "./adapters/mp4box/index.ts";
+import { imageSize } from "./adapters/png/index.ts";
+import { captions } from "./adapters/srt/index.ts";
+import { TALK_RULE_LEVELS, talkRules } from "./talk-rules.ts";
 import {
   ANONYMITY_RULE_LEVELS,
   anonymityRules,
@@ -65,6 +74,10 @@ import {
 } from "./tex-venue-rules.ts";
 import { claimProvenanceRule } from "./claim-provenance.ts";
 import { registerRule } from "./register.ts";
+import {
+  REGISTER_BAND_RULE_LEVELS,
+  registerBandRules,
+} from "./register-bands.ts";
 import {
   paperRules,
   identityField,
@@ -121,6 +134,7 @@ import {
   CONFIG_FILE,
   DEFAULT_PAPERS_ROOT,
   PAPERS_DIR_FIELD,
+  PAPER_ONLY_KEYS,
   SETTINGS_KEYS,
   findProjectRoot,
 } from "#lib/paper-config";
@@ -232,10 +246,26 @@ settings — paperlint.json, at two levels, one schema. Both are optional.
   own, the venue preset's, the root file's, the paper's. Optional rules (off unless turned on):
   pdf/last-page-balance. The venue rules (pdf/fresh, pdf/profile, pdf/fonts, pdf/geometry,
   pdf/body-size, pdf/measured, format/page-limit, format/layout-override, anonymity/identity) are
-  on for every paper with a venue preset; set one to "off" to skip it. An unknown key, in either
-  file, is an error.
+  on for every paper with a venue preset; set one to "off" to skip it. The talk rules (talk/*) judge
+  the finished talk files of a paper whose paperlint.json declares "talk" (docs/talk.md). An
+  unknown key, in either file, is an error.
 `;
 
+/** What the rules over a paper.tex read with: the disk, the shipped presets, the LaTeX reader. */
+const TEX_RULE_DEPS = {
+  files: nodeFiles,
+  venuesDir: presetsDir(),
+  latex: latexReader,
+};
+
+/** What the talk rules read with: the disk, the shipped presets, and the three media readers. */
+const TALK_RULE_DEPS = {
+  files: nodeFiles,
+  venuesDir: presetsDir(),
+  media: { probeVideo, imageSize, captions },
+  listDir: nodeListDir,
+};
+
 /** The config the user would otherwise write by hand. The data comes from `opts`, the mechanism is here. */
 export function buildConfig(
   opts: PaperlintConfig = {},
@@ -325,30 +355,18 @@ export function buildConfig(
           languages: { latex: texLanguage },
           rules: {
             ...texBuild,
-            ...texVenueRules({
-              files: nodeFiles,
-              venuesDir: presetsDir(),
-              latex: latexReader,
-            }),
-            "claim-provenance": claimProvenanceRule({
-              files: nodeFiles,
-              latex: latexReader,
-            }),
-            register: registerRule({
-              files: nodeFiles,
-              latex: latexReader,
-            }),
+            ...texVenueRules(TEX_RULE_DEPS),
+            "claim-provenance": claimProvenanceRule(TEX_RULE_DEPS),
+            register: registerRule(TEX_RULE_DEPS),
+            ...registerBandRules(TEX_RULE_DEPS),
           },
         },
         paper: { rules: texPaperRules },
         bib: bibReachable,
+        talk: { rules: talkRules(TALK_RULE_DEPS) },
         format: {
           rules: {
-            ...formatRules({
-              files: nodeFiles,
-              venuesDir: presetsDir(),
-              latex: latexReader,
-            }),
+            ...formatRules(TEX_RULE_DEPS),
             ...pageLimitRules({ files: nodeFiles, venuesDir: presetsDir() }),
           },
         },
@@ -364,6 +382,9 @@ export function buildConfig(
         "tex/claim-provenance": "warn",
         // Sentence-initial conjunctions over the whole body: register, not vocabulary.
         "tex/register": "warn",
+        // Contrast frames, claims in bold, relation markers: each against the band the venue
+        // preset's anchors set, silent for a preset without anchors (src/register-bands.ts).
+        ...REGISTER_BAND_RULE_LEVELS,
         "tex/acm-frontmatter-override": "error",
         // Silent for a paper whose paperlint.json names no venue (src/venue-rules.ts).
         ...VENUE_RULE_LEVELS,
@@ -371,6 +392,8 @@ export function buildConfig(
         ...TEX_VENUE_RULE_LEVELS,
         ...FORMAT_RULE_LEVELS,
         ...PAGE_LIMIT_RULE_LEVELS,
+        // Silent for a paper that declares no `talk` (src/talk-rules.ts), but talk/undeclared.
+        ...TALK_RULE_LEVELS,
       },
     });
   // THE FILES A paper.tex INCLUDES FROM ITS BODY, each read on its own and reported at its own path
@@ -695,6 +718,12 @@ export function parseSettings(
         `${where}: unknown key${unknown.length > 1 ? "s" : ""} ${unknown.map((k) => `"${k}"`).join(", ")} — ` +
         `a typo would otherwise read as "not set". Known keys: ${Object.keys(SETTINGS_KEYS).join(", ")}`,
     };
+  const paperOnly = PAPER_ONLY_KEYS.find((k) => k in raw);
+  if (paperOnly !== undefined)
+    return {
+      ok: false,
+      error: `${where}: "${paperOnly}" is a paper's setting — set it in that paper's ${CONFIG_FILE}`,
+    };
   const defaults = stringFields(raw);
   if (!defaults.ok) return { ok: false, error: `${where}: ${defaults.error}` };
   const identity = identityField(raw);

package/src/domain/register.test.ts

@@ -0,0 +1,153 @@
+/**
+ * The register measures on real parses: what counts as a contrast frame, a relation marker and a
+ * claim in bold, and what does not; the band the anchors set; the excerpt a finding quotes.
+ * Every "does not count" case below is a sentence shape found in an accepted ACSAC paper.
+ */
+import { describe, expect, it } from "vitest";
+import { latexReader } from "../adapters/latex/index.ts";
+import {
+  bandOf,
+  bodySentences,
+  claimEmphasis,
+  contrastFrames,
+  excerpt,
+  rateOf,
+  relationMarkers,
+  type RegisterAnchor,
+} from "./register.ts";
+
+const doc = (body: string): string =>
+  `\\documentclass{article}\n\\begin{document}\n${body}\n\\end{document}\n`;
+const sentencesOf = (body: string) =>
+  bodySentences(latexReader.bodyProse(doc(body)));
+const frames = (body: string): number =>
+  contrastFrames(sentencesOf(body)).length;
+const markers = (body: string): number =>
+  relationMarkers(sentencesOf(body)).length;
+const claims = (body: string): readonly string[] =>
+  claimEmphasis(latexReader.bodyEmphasis(doc(body))).map((o) => o.match);
+
+describe("contrastFrames — a claim set against a rejected alternative", () => {
+  it.each([
+    [
+      "X, not Y",
+      "They react to the dangerous word, not the dangerous operation.",
+    ],
+    ["X --- not Y", "It guarantees encryption --- not authenticity."],
+    ["X; not Y", "We score the operation; not the attacker."],
+    ["X, and not Y", "It reads the field, and not the raw input."],
+    ["not X but Y", "Over-blocking is not a side metric but a precondition."],
+    ["rather than", "It fires on the mention rather than the act."],
+    ["instead of", "It reads the whole event instead of the command."],
+    ["as opposed to", "It matches words as opposed to operations."],
+  ])("🔴 %s is one frame", (_form, sentence) => {
+    expect(frames(sentence)).toBe(1);
+  });
+
+  it.each([
+    ["not only … but also", "It is not only fast but also exact."],
+    [
+      "a negated clause",
+      "The nature of the audit is not reported, but it did not assess quality.",
+    ],
+    ["«, not yet»", "The fix is merged, not yet released."],
+    [
+      "«, not already in the corpus»",
+      "We kept every guard published since, not already in the corpus.",
+    ],
+    ["«without»", "The attack works without any access to the device."],
+    ["«unlike»", "Unlike prior work, we measure the installed guards."],
+    ["a bare negation", "The guard does not block it."],
+  ])("%s is no frame", (_form, sentence) => {
+    expect(frames(sentence)).toBe(0);
+  });
+
+  it("two frames in one sentence are two; one phrase matching two forms is one", () => {
+    expect(
+      frames("It reads the word, not the act, rather than the operation."),
+    ).toBe(2);
+    expect(frames("It is not a word but rather than a verb.")).toBe(2);
+  });
+
+  it("a frame in a table, a caption or a heading is not prose, so not counted", () => {
+    expect(
+      frames(
+        "\\section{Words, not operations}\n\\begin{table}\\caption{Words, not operations.}\\begin{tabular}{l}a, not b\\end{tabular}\\end{table}\nPlain text here.",
+      ),
+    ).toBe(0);
+  });
+});
+
+describe("relationMarkers — words that name how a sentence relates to the one before", () => {
+  it("🔴 each marker counts where it stands, sentence-initial or not", () => {
+    expect(
+      markers(
+        "However, the rate is low. It fails because the rule matches words. For example, echo is blocked. It is therefore unsafe.",
+      ),
+    ).toBe(4);
+  });
+
+  it("a marker inside a longer word is not one: «thusly» is no «thus», «sincere» no «since»", () => {
+    expect(
+      markers("The sincere author wrote thusly. Eventually it held."),
+    ).toBe(0);
+  });
+});
+
+describe("claimEmphasis — a claim set in bold inside a sentence", () => {
+  it("🔴 a bold phrase of six words or more, or holding a number, inside a sentence", () => {
+    expect(
+      claims(
+        "We find that \\textbf{they react to the dangerous word}. The \\textbf{median coverage is 2.5/10} here.",
+      ),
+    ).toEqual([
+      "they react to the dangerous word",
+      "median coverage is 2.5/10",
+    ]);
+  });
+
+  it("a term in bold, a label opening a paragraph or item, italics, and a run-in heading are not claims", () => {
+    expect(
+      claims(
+        "BaroVox offers a \\textbf{Pressure-Acoustic Transformation (PAT)} here.\n\n\\textbf{Varying the orientation of the sound source from the device}. We vary it.\n\\begin{itemize}\n\\item \\textbf{A corpus of user security questions with sources}: we release it.\n\\end{itemize}\nWe \\emph{find that the guards react to the word}.\n\n\\textbf{Threats to validity of the 46 guards.} None.",
+      ),
+    ).toEqual([]);
+  });
+});
+
+describe("bandOf — the anchors' range, widened by two Poisson standard deviations", () => {
+  const anchor = (words: number, contrast_frames: number): RegisterAnchor => ({
+    paper: "p",
+    words,
+    counts: { contrast_frames, claim_emphasis: 0, relation_markers: 0 },
+  });
+
+  it("🔴 the edges stand two standard deviations of the edge anchor's count beyond it", () => {
+    // 4 in 10,000 words: rate 4, sd 2 → max 8. 1 in 10,000: rate 1, sd 1 → min 1 - 2 < 0 → 0.
+    expect(
+      bandOf([anchor(10_000, 4), anchor(10_000, 1)], "contrast_frames"),
+    ).toEqual({ min: 0, max: 8, anchorMin: 1, anchorMax: 4, anchors: 2 });
+  });
+
+  it("an anchor with no occurrence is widened as if it had one; a floor above zero stays", () => {
+    expect(bandOf([anchor(10_000, 0)], "contrast_frames")?.max).toBe(2);
+    expect(bandOf([anchor(10_000, 100)], "contrast_frames")?.min).toBe(80);
+  });
+
+  it("no anchors, no band; a body of no words has a rate of zero", () => {
+    expect(bandOf([], "contrast_frames")).toBeNull();
+    expect(rateOf(3, 0)).toBe(0);
+  });
+});
+
+describe("excerpt — the words around an occurrence, as a finding quotes them", () => {
+  it("the match with its neighbours, cut at a word, an ellipsis where the sentence goes on", () => {
+    const s =
+      "We score 46 gates and find that they react to the dangerous word, not the dangerous operation, in every one of the ten cases we built.";
+    const at = s.indexOf(", not");
+    expect(excerpt(s, at, at + 6)).toBe(
+      "…that they react to the dangerous word, not the dangerous operation, in every one…",
+    );
+    expect(excerpt("a, not b", 1, 7)).toBe("a, not b");
+  });
+});

package/src/domain/register.ts

@@ -0,0 +1,261 @@
+/**
+ * THE REGISTER OF A PAPER'S BODY, COUNTED — the measures the register rules judge, and the band a
+ * venue's accepted papers set for each. Pure: passages and emphasised phrases in, counts out.
+ *
+ * Three measures, each per 10,000 words of the body, each read off the same passages and cut into
+ * the same sentences as every other rule over the body (`sentences.ts`):
+ *
+ *   contrast_frames    a claim set against a rejected alternative: «X, not Y», «not X but Y»,
+ *                      «X rather than Y», «instead of Y», «as opposed to Y»
+ *   claim_emphasis     a phrase in bold INSIDE a sentence that states something: six words or more,
+ *                      or holding a number — not a label opening a paragraph or an item, and not a
+ *                      term of a few words
+ *   relation_markers   a word that names how a sentence relates to the one before: because,
+ *                      therefore, however, in contrast, for example, that is …
+ *
+ * ── THE BAND IS THE ANCHORS', NOT A CONSTANT ────────────────────────────────────
+ * A venue preset records its anchors — accepted papers of the venue (or its parent conference),
+ * each with its word count and its count of every measure, as these counters give them. The band
+ * of a measure is the anchors' range, widened at each end by two Poisson standard deviations of
+ * the anchor standing there: a paper of that anchor's length and register would fall outside it
+ * about one time in forty. An anchor with no occurrence is widened as if it had one. Below zero is
+ * zero. So every number a message names comes from the preset's anchors, and changing an anchor
+ * changes the band.
+ */
+import type { Emphasis, Passage, Span, TextRun } from "./tex-document.ts";
+import { runText, spanIn } from "./tex-document.ts";
+import { CITATION, MATH, REFERENCE, runOf, sentences } from "./sentences.ts";
+
+/** The measures a venue's anchors set a band for. */
+export type RegisterMeasureName =
+  "contrast_frames" | "claim_emphasis" | "relation_markers";
+
+export const REGISTER_MEASURES: readonly RegisterMeasureName[] = [
+  "contrast_frames",
+  "claim_emphasis",
+  "relation_markers",
+];
+
+/** One accepted paper of the venue, as the counters measured it. */
+export interface RegisterAnchor {
+  /** What the preset calls it: a directory under `fixtures/accepted-papers/`, or a citation. */
+  readonly paper: string;
+  readonly words: number;
+  readonly counts: Readonly<Record<RegisterMeasureName, number>>;
+}
+
+/** How far the band reaches past the anchors: this many Poisson standard deviations. */
+export const NOISE_SDS = 2;
+
+/** The words a rate is taken over. */
+export const PER = 10_000;
+
+/** A rate per `PER` words; 0 for a body with no words. */
+export const rateOf = (count: number, words: number): number =>
+  words === 0 ? 0 : (PER * count) / words;
+
+/** A measure's band, and the anchors' own range it was widened from. */
+export interface Band {
+  readonly min: number;
+  readonly max: number;
+  readonly anchorMin: number;
+  readonly anchorMax: number;
+  readonly anchors: number;
+}
+
+/** One anchor's rate of a measure, and how far one standard deviation of its count reaches. */
+const anchorRate = (a: RegisterAnchor, m: RegisterMeasureName) => {
+  const count = a.counts[m];
+  return {
+    rate: rateOf(count, a.words),
+    sd: rateOf(Math.sqrt(Math.max(count, 1)), a.words),
+  };
+};
+
+/** The band the anchors set for a measure; null when there are no anchors. */
+export function bandOf(
+  anchors: readonly RegisterAnchor[],
+  m: RegisterMeasureName,
+): Band | null {
+  const rates = anchors.map((a) => anchorRate(a, m));
+  const low = rates.reduce<(typeof rates)[number] | null>(
+    (lo, r) => (lo === null || r.rate < lo.rate ? r : lo),
+    null,
+  );
+  const high = rates.reduce<(typeof rates)[number] | null>(
+    (hi, r) => (hi === null || r.rate > hi.rate ? r : hi),
+    null,
+  );
+  if (low === null || high === null) return null;
+  return {
+    min: Math.max(0, low.rate - NOISE_SDS * low.sd),
+    max: high.rate + NOISE_SDS * high.sd,
+    anchorMin: low.rate,
+    anchorMax: high.rate,
+    anchors: anchors.length,
+  };
+}
+
+// ── sentences, as every register measure reads them ───────────────────────────────
+
+/** The characters a mark or math stands as in a sentence's text. */
+const MARK = new RegExp(`[${CITATION}${REFERENCE}${MATH}]`, "gu");
+
+const WORDS = new Intl.Segmenter("en", { granularity: "word" });
+
+/** A sentence of the body: its text as the reader sees it, its words, its first word, where it stands. */
+export interface BodySentence {
+  /** The text with marks and math left out and spaces collapsed, for a message. */
+  readonly text: string;
+  /** The text with each mark and math as one character, for matching. */
+  readonly raw: string;
+  /** Its word-like words, and one for each mark or math, as it reads on the page. */
+  readonly words: number;
+  readonly first: string;
+  /** The run it was cut from, and where in that run's text it starts. */
+  readonly run: TextRun;
+  readonly from: number;
+}
+
+/** The body's sentences that hold a word, in order. */
+export function bodySentences(
+  passages: readonly Passage[],
+): readonly BodySentence[] {
+  return passages.flatMap((p) => {
+    const run = runOf(p);
+    const text = runText(run);
+    return sentences(text).flatMap(([from, to]) => {
+      const raw = text.slice(from, to);
+      const words = [...WORDS.segment(raw)].filter((w) => w.isWordLike);
+      const [first] = words;
+      if (first === undefined) return [];
+      return [
+        {
+          text: raw.replace(MARK, "").replace(/\s+/gu, " ").trim(),
+          raw,
+          words: words.length + (raw.match(MARK)?.length ?? 0),
+          first: first.segment,
+          run,
+          from,
+        },
+      ];
+    });
+  });
+}
+
+/** The body's words. */
+export const wordsOf = (ss: readonly BodySentence[]): number =>
+  ss.reduce((n, s) => n + s.words, 0);
+
+// ── the measures ──────────────────────────────────────────────────────────────────
+
+/**
+ * One occurrence of a measure: the words around it as the reader sees them, the sentence it stands
+ * in, and where it is.
+ */
+export interface Occurrence {
+  readonly match: string;
+  readonly sentence: string;
+  readonly at: Span | null;
+}
+
+/** The forms as one pattern: matched left to right, so one phrase is never two occurrences. */
+const anyOf = (forms: readonly RegExp[]): Readonly<RegExp> =>
+  new RegExp(forms.map((r) => `(?:${r.source})`).join("|"), "giu");
+
+/**
+ * «not» after a comma, a dash (`---` as the source spells it) or a semicolon — «the word, not the
+ * operation», «--- not authenticity» —
+ * unless it opens a phrase that rejects nothing («not only», «not yet», «not already in the corpus»).
+ */
+const COMMA_NOT =
+  /(?:[,;—–]|--)\s*(?:and\s+|but\s+)?not\s+(?!(?:only|least|yet|always|necessarily|all|even|just|merely|surprisingly|already|to)\b)/giu;
+
+/** «not X but Y» inside one clause — no comma, colon or semicolon between — but not «not only … but also». */
+const NOT_BUT = /\bnot\b(?!\s+only\b)[^.;:,]{1,60}?\bbut\b(?!\s+also\b)/giu;
+
+/** Every form of a contrast frame, as one pattern over one sentence. */
+const CONTRAST_FRAME = anyOf([
+  COMMA_NOT,
+  NOT_BUT,
+  /\brather\s+than\b/u,
+  /\binstead\s+of\b/u,
+  /\bas\s+opposed\s+to\b/u,
+]);
+
+/**
+ * Words that name the relation between a sentence and the one before it: cause, consequence,
+ * contrast, concession, example, restatement. The list is the one the register diagnosis measured
+ * (every marker whose meaning does not depend on context), not tuned to this corpus.
+ */
+const RELATION_MARKERS =
+  /(?<![\p{L}])(?:therefore|thus|hence|consequently|as a result|because|since|this means|this implies|which explains|in turn|that is,|i\.e\.|in contrast|by contrast|however|nevertheless|nonetheless|whereas|in other words|for this reason|it follows|accordingly|specifically,|in particular,|for example|for instance|e\.g\.)(?![\p{L}])/giu;
+
+/** How many characters of context an excerpt keeps on each side of a match. */
+const CONTEXT = 40;
+
+/**
+ * The words around `[from, to)` of a sentence as the reader sees them: the match with up to
+ * `CONTEXT` characters on each side, cut at a word, marks and math left out.
+ */
+export function excerpt(raw: string, from: number, to: number): string {
+  const start = Math.max(0, from - CONTEXT);
+  const end = Math.min(raw.length, to + CONTEXT);
+  const words = raw
+    .slice(start, end)
+    .replace(MARK, "")
+    .split(/\s+/u)
+    .filter((w) => w !== "");
+  const inner = words.slice(
+    start > 0 ? 1 : 0,
+    end < raw.length ? -1 : words.length,
+  );
+  return `${start > 0 ? "…" : ""}${inner.join(" ")}${end < raw.length ? "…" : ""}`;
+}
+
+/** Every match of `pattern` in every sentence, in order, with where it stands. */
+function occurrences(
+  ss: readonly BodySentence[],
+  pattern: Readonly<RegExp>,
+): readonly Occurrence[] {
+  return ss.flatMap((s) =>
+    [...s.raw.matchAll(pattern)].map((m) => ({
+      match: excerpt(s.raw, m.index, m.index + m[0].length),
+      sentence: s.text,
+      at: spanIn(s.run, s.from + m.index, s.from + m.index + m[0].length),
+    })),
+  );
+}
+
+/** The contrast frames of the body's sentences. */
+export const contrastFrames = (
+  ss: readonly BodySentence[],
+): readonly Occurrence[] => occurrences(ss, CONTRAST_FRAME);
+
+/** The relation markers of the body's sentences. */
+export const relationMarkers = (
+  ss: readonly BodySentence[],
+): readonly Occurrence[] => occurrences(ss, RELATION_MARKERS);
+
+/** A phrase this long or longer states something rather than names it. */
+export const CLAIM_WORDS = 6;
+
+const wordCount = (s: string): number =>
+  [...WORDS.segment(s)].filter((w) => w.isWordLike).length;
+
+/**
+ * Whether an emphasised phrase is a claim set in bold: bold, inside its sentence (not a label that
+ * opens a paragraph or an item), and either `CLAIM_WORDS` words long or holding a number.
+ */
+export const isClaimEmphasis = (e: Emphasis): boolean =>
+  e.style === "bold" &&
+  e.place === "inline" &&
+  (wordCount(e.text) >= CLAIM_WORDS || /\p{N}/u.test(e.text));
+
+/** The claims the body sets in bold. */
+export const claimEmphasis = (es: readonly Emphasis[]): readonly Occurrence[] =>
+  es.filter(isClaimEmphasis).map((e) => ({
+    match: e.text,
+    sentence: e.text,
+    at: e.span,
+  }));

package/src/domain/talk.test.ts

@@ -0,0 +1,125 @@
+/** A paper's `talk` key and a preset's `talk` block, parsed. */
+import { describe, expect, it } from "vitest";
+import { DEFAULT_TALK_FILES, parsePaperTalk, venueTalkOf } from "./talk.ts";
+
+describe("parsePaperTalk", () => {
+  it("is null when the paper declares no talk", () => {
+    expect(parsePaperTalk(undefined)).toEqual({ ok: true, value: null });
+  });
+
+  it("defaults the folder and the file names", () => {
+    expect(parsePaperTalk({ mode: "remote-video" })).toEqual({
+      ok: true,
+      value: {
+        mode: "remote-video",
+        dir: "talk",
+        files: DEFAULT_TALK_FILES,
+        oneSlide: null,
+      },
+    });
+  });
+
+  it("takes a folder, file names and a one-slide size", () => {
+    const r = parsePaperTalk({
+      mode: "in-person",
+      dir: "video",
+      files: { video: "my-talk.mp4" },
+      one_slide: { width_px: 1920, height_px: 1080 },
+    });
+    expect(r).toEqual({
+      ok: true,
+      value: {
+        mode: "in-person",
+        dir: "video",
+        files: { ...DEFAULT_TALK_FILES, video: "my-talk.mp4" },
+        oneSlide: { width: 1920, height: 1080 },
+      },
+    });
+  });
+});
+
+describe("parsePaperTalk refuses", () => {
+  it.each([
+    ["not an object", "remote-video", '"talk" must be an object'],
+    [
+      "an unknown key",
+      { mode: "remote-video", lenght: 1 },
+      'unknown key "lenght"',
+    ],
+    ["an unknown mode", { mode: "zoom" }, '"talk.mode" must be one of'],
+    ["an empty folder", { mode: "remote-video", dir: "" }, '"talk.dir"'],
+    [
+      "files not an object",
+      { mode: "remote-video", files: [] },
+      '"talk.files" must be an object',
+    ],
+    [
+      "an unknown artifact",
+      { mode: "remote-video", files: { slides: "s.pdf" } },
+      '"talk.files": "slides"',
+    ],
+    [
+      "a path for a name",
+      { mode: "remote-video", files: { video: "a/b.mp4" } },
+      '"talk.files": "video"',
+    ],
+    [
+      "a size that is not integers",
+      { mode: "remote-video", one_slide: { width_px: 1.5, height_px: 2 } },
+      '"talk.one_slide"',
+    ],
+  ])("%s", (_, v, msg) => {
+    const r = parsePaperTalk(v);
+    expect(r.ok).toBe(false);
+    expect(r.ok ? "" : r.error).toContain(msg);
+  });
+});
+
+describe("venueTalkOf", () => {
+  it("types every field, absent ones as null or empty", () => {
+    expect(venueTalkOf({})).toEqual({
+      modes: [],
+      artifacts: new Map(),
+      kinds: new Map(),
+      video: {
+        container: null,
+        minHeightPx: null,
+        maxBytes: null,
+        captions: null,
+      },
+      oneSlide: null,
+    });
+  });
+
+  it("reads modes, artifacts per mode, slots per kind, video limits and the one-slide size", () => {
+    const t = venueTalkOf({
+      modes: ["remote-video"],
+      artifacts: { "remote-video": { required: ["video"] } },
+      kinds: { short: { slot_s: 600, talk_s_max: 420 } },
+      video: {
+        container: "mp4",
+        min_height_px: 720,
+        max_bytes: 9,
+        captions: "required",
+      },
+      one_slide: { width_px: 1920, height_px: 1080 },
+    });
+    expect(t.artifacts.get("remote-video")).toEqual({
+      required: ["video"],
+      optional: [],
+    });
+    expect(t.kinds.get("short")).toEqual({
+      slotS: 600,
+      talkSMin: null,
+      talkSMax: 420,
+      qaS: null,
+    });
+    expect(t.video).toEqual({
+      container: "mp4",
+      minHeightPx: 720,
+      maxBytes: 9,
+      captions: "required",
+    });
+    expect(t.oneSlide).toEqual({ width: 1920, height: 1080 });
+  });
+});