paperlint 6.1.0 → 6.2.1

package/presets/venue-profile.schema.json

@@ -186,6 +186,138 @@
           }
         }
       }
+    },
+    "talk": {
+      "description": "What the venue asks a presenter to send, judged by the talk/* rules on the finished files (src/talk-rules.ts). Read only for a paper whose paperlint.json declares `talk`. A child preset's block replaces its parent's whole. Durations in seconds.",
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "modes": {
+          "description": "The presentation modes the venue allows.",
+          "type": "array",
+          "items": {
+            "type": "string",
+            "enum": ["in-person", "remote-video", "remote-live"]
+          },
+          "uniqueItems": true,
+          "minItems": 1
+        },
+        "artifacts": {
+          "description": "What each mode owes: the files required, and those that may be sent.",
+          "type": "object",
+          "propertyNames": {
+            "type": "string",
+            "enum": ["in-person", "remote-video", "remote-live"]
+          },
+          "additionalProperties": {
+            "type": "object",
+            "additionalProperties": false,
+            "required": ["required"],
+            "properties": {
+              "required": {
+                "type": "array",
+                "items": {
+                  "type": "string",
+                  "enum": [
+                    "video",
+                    "one-slide",
+                    "captions",
+                    "slides-pdf",
+                    "poster"
+                  ]
+                },
+                "uniqueItems": true
+              },
+              "optional": {
+                "type": "array",
+                "items": {
+                  "type": "string",
+                  "enum": [
+                    "video",
+                    "one-slide",
+                    "captions",
+                    "slides-pdf",
+                    "poster"
+                  ]
+                },
+                "uniqueItems": true
+              }
+            }
+          }
+        },
+        "kinds": {
+          "description": "The talk slot per paper kind (the names of format.kinds; the paper's `kind` selects one).",
+          "type": "object",
+          "additionalProperties": {
+            "type": "object",
+            "additionalProperties": false,
+            "required": ["slot_s", "talk_s_max"],
+            "properties": {
+              "slot_s": {
+                "description": "The whole slot, talk and questions. Informational.",
+                "type": "number",
+                "exclusiveMinimum": 0
+              },
+              "talk_s_min": {
+                "description": "The shortest talk the venue asks for (talk/duration-floor).",
+                "type": "number",
+                "minimum": 0
+              },
+              "talk_s_max": {
+                "description": "The longest talk (talk/duration).",
+                "type": "number",
+                "exclusiveMinimum": 0
+              },
+              "qa_s": {
+                "description": "The questions' share. Informational.",
+                "type": "number",
+                "minimum": 0
+              }
+            }
+          }
+        },
+        "video": {
+          "description": "The venue's limits on the video file (talk/video-format).",
+          "type": "object",
+          "additionalProperties": false,
+          "properties": {
+            "container": {
+              "type": "string",
+              "enum": ["mp4"]
+            },
+            "min_height_px": {
+              "description": "The lowest vertical resolution; HD is 720.",
+              "type": "integer",
+              "minimum": 1
+            },
+            "max_bytes": {
+              "type": "integer",
+              "minimum": 1
+            },
+            "captions": {
+              "description": "`required`: a captions file is owed with the video (talk/required-files).",
+              "type": "string",
+              "enum": ["required", "optional"]
+            }
+          }
+        },
+        "one_slide": {
+          "description": "The one-slide image's size in pixels (talk/one-slide-size), when the venue states one.",
+          "type": "object",
+          "additionalProperties": false,
+          "required": ["width_px", "height_px"],
+          "properties": {
+            "width_px": {
+              "type": "integer",
+              "minimum": 1
+            },
+            "height_px": {
+              "type": "integer",
+              "minimum": 1
+            }
+          }
+        }
+      }
     }
   },
   "allOf": [

package/skills/submit-paper/references/venues/agenticdev.md

@@ -116,17 +116,44 @@ the preamble, the copyright block, CCS, source files). Here — only what's spec
 - **Title changes are allowed** — the portal explicitly asks for it "exactly as it should appear
   in the ACM DL." But decide before eRights (see the publisher card).
 
-## Attendance / registration
+## Attendance and the talk (2026 edition)
 
-The CFP is silent on remote participation, and **that does not mean "you don't have to show
-up"**: ACM has no blanket no-show policy, IEEE does have one and allows a "qualified proxy" plus
-exceptions for circumstances outside the author's control. Which one applies to the ASE workshop
-**cannot be derived from public sources** — only by writing to the chairs.
+**Remote is allowed, but there is no live slot.** On 2026-08-27 the chairs told accepted authors
+who cannot travel (by email) that the workshop adopts ASE 2026's
+[Not-in-Person Presentations](https://conf.researchr.org/track/ase-2026/ase-2026-not-in-person-presentations)
+policy. That page, verbatim:
 
-- Workshop-day registration (non-member): **€350** through 08-31, €410 through 09-20, €460
-  on-site. This is a **publication gate**, not a travel expense.
-- If entry requires a visa, the timeline for it is real → ask the chairs right after acceptance,
-  don't delay.
+> ASE 2026 does not provide presentation slots for papers that are not presented in-person by one
+> of the authors.
+
+Instead the author sends:
+
+| artifact  | what the page says                                                                                                                | deadline                                                                    |
+| --------- | --------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------- |
+| video     | "made available via a dedicated page on the conference website (recommendation: 10 min duration, mp4 file format, HD resolution)" | ASE page: 2026-10-08; the workshop chairs asked by email for **2026-10-01** |
+| one-slide | "shown during one of the conference sessions"; no size or format stated                                                           | same as the video                                                           |
+| poster    | optional for the workshop; ASE prints it                                                                                          | ASE page: 2026-09-21                                                        |
+
+**Where to upload.** The page says: "find the submission link on the submission page for your paper
+(see author-kit e-mail from Conference Publishing Consulting)". That is the same personal page used
+for the camera-ready. On it, the block "Optional Archive/Appendix/Video/Picture Submissions … Submit
+Material to ACM" uploads straight into the ACM system, once per file. "All submitted material will be
+published in the ACM DL if the publishing-rights agreement gives permission for this", so tick
+permission for auxiliary material when filling in eRights. The chairs never named a channel in
+email; sending the files to them as attachments as well covers both readings.
+
+**The slot.** Per the chairs' email to all authors (2026-09-29), a short paper gets 10 minutes in
+total: approximately 6–7 for the presentation and 3–4 for questions. It is stated as approximate,
+with no minimum.
+
+**Q&A for a remote author.** No source requires live attendance or a live answer; none confirms
+email Q&A either. Put a contact address on the video's last slide and on the one-slide.
+
+**Registration is still required** and still a **publication gate**, not a travel expense:
+workshop-day registration (non-member) €350 through 08-31, €410 through 09-20, €460 on-site.
+If entry requires a visa, ask the chairs right after acceptance.
+
+The `talk` rules check the finished files against these numbers: `docs/talk.md`.
 
 ## 🤖 Machine-readable format profile
 

package/src/adapters/mp4box/index.test.ts

@@ -0,0 +1,63 @@
+/** `probeVideo` on the committed synthetic media (`fixtures/talk/`): 3 s, 1280×720, no voice. */
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { describe, expect, it } from "vitest";
+import { probeVideo } from "./index.ts";
+
+const FIXTURES = join(
+  dirname(fileURLToPath(import.meta.url)),
+  "../../../fixtures/talk",
+);
+const bytes = (name: string): Uint8Array =>
+  new Uint8Array(readFileSync(join(FIXTURES, name)));
+
+describe("probeVideo", () => {
+  it("reads the movie header's duration, the audio track's, the size and the brands", () => {
+    expect(probeVideo(bytes("talk.mp4"))).toEqual({
+      durationS: 3,
+      audioS: 3.064,
+      heightPx: 720,
+      widthPx: 1280,
+      brands: ["isom", "iso2", "avc1", "mp41"],
+    });
+  });
+
+  it("reads an audio track that stops before the video", () => {
+    expect(probeVideo(bytes("short-audio.mp4"))?.audioS).toBe(1.064);
+  });
+
+  it("reads a QuickTime file, with its `qt  ` brand and no audio track", () => {
+    expect(probeVideo(bytes("talk.mov"))).toMatchObject({
+      durationS: 3,
+      audioS: null,
+      brands: ["qt  "],
+    });
+  });
+
+  it("is null for bytes that do not open with an ftyp box", () => {
+    expect(probeVideo(bytes("one-slide.png"))).toBeNull();
+    expect(probeVideo(new Uint8Array(3))).toBeNull();
+  });
+
+  it("reads a Node Buffer that is a view into a larger buffer, as readFileSync returns for small files", () => {
+    const mov = bytes("talk.mov");
+    const big = new Uint8Array(mov.length + 100);
+    big.set(mov, 50);
+    expect(probeVideo(Buffer.from(big.buffer, 50, mov.length))?.brands).toEqual(
+      ["qt  "],
+    );
+  });
+
+  it("is null for an ftyp box with no moov after it", () => {
+    const ftyp = bytes("talk.mp4").slice(0, 32);
+    expect(probeVideo(ftyp)).toBeNull();
+  });
+
+  it("has no size for a file without a video track", () => {
+    expect(probeVideo(bytes("audio-only.mp4"))).toMatchObject({
+      heightPx: null,
+      widthPx: null,
+    });
+  });
+});

package/src/adapters/mp4box/index.ts

@@ -0,0 +1,50 @@
+/**
+ * MP4Box.js (GPAC's ISO-BMFF parser, pure JavaScript, no dependencies) as the video half of the
+ * `TalkMedia` port: the movie header's duration, the first audio and video tracks, the brands.
+ * No ffmpeg: the boxes that hold these numbers (`ftyp`, `moov/mvhd`, `trak/tkhd`, `mdhd`) are read
+ * directly, in milliseconds even for a ten-megabyte file.
+ */
+import { createFile, MP4BoxBuffer, type Movie, type Track } from "mp4box";
+import type { VideoProbe } from "../../domain/talk.ts";
+
+/**
+ * Whether the bytes open with an `ftyp` box, as every MP4 and QuickTime file written by a current
+ * tool does. Anything else is refused here, before MP4Box.js — which would log its parse errors to
+ * the console, in the middle of the lint output.
+ */
+const opensWithFtyp = (bytes: Uint8Array): boolean =>
+  bytes.length >= 8 &&
+  new TextDecoder("latin1").decode(bytes.subarray(4, 8)) === "ftyp";
+
+/** A track's duration in seconds, from its own media timescale. */
+const seconds = (t: Readonly<Pick<Track, "duration" | "timescale">>): number =>
+  t.duration / t.timescale;
+
+/** The movie's info, or null when the bytes hold no complete `moov` box. */
+function movieOf(bytes: Uint8Array): Readonly<Movie> | null {
+  const file = createFile();
+  // A copy into a buffer of its own: a Node Buffer's `.buffer` is a shared pool for small files,
+  // and `Buffer#slice` does not copy, so `bytes.slice().buffer` would hand MP4Box.js the whole pool.
+  const copy = new Uint8Array(bytes).buffer;
+  file.appendBuffer(MP4BoxBuffer.fromArrayBuffer(copy, 0));
+  file.flush();
+  // `moov` is typed as always present and is undefined until the box has been parsed.
+  const parsed: unknown = file.moov;
+  return parsed === undefined ? null : file.getInfo();
+}
+
+/** The bytes of a video file → its durations, size and brands; null when not an ISO media file. */
+export function probeVideo(bytes: Uint8Array): VideoProbe | null {
+  if (!opensWithFtyp(bytes)) return null;
+  const movie = movieOf(bytes);
+  if (movie === null) return null;
+  const audio = movie.audioTracks[0];
+  const video = movie.videoTracks[0];
+  return {
+    durationS: movie.duration / movie.timescale,
+    audioS: audio === undefined ? null : seconds(audio),
+    heightPx: video?.video?.height ?? null,
+    widthPx: video?.video?.width ?? null,
+    brands: [...new Set(movie.brands)],
+  };
+}

package/src/adapters/node/index.ts

@@ -34,3 +34,4 @@ export function nodeAdapters(o: NodeAdapterOptions): NodePorts {
 export { nodeFiles } from "./files.io.ts";
 export { spawnProcess, type SpawnSync } from "./process.io.ts";
 export { hostDirs } from "./host.io.ts";
+export { nodeListDir } from "./list-dir.io.ts";

package/src/adapters/node/list-dir.io.ts

@@ -0,0 +1,15 @@
+/** `ListDir` over `node:fs`: the names in a directory, or none when it does not exist. */
+import { readdirSync } from "node:fs";
+import type { AbsolutePath } from "../../domain/paths.ts";
+import type { ListDir } from "../../ports/talk-media.ts";
+import { codeOf } from "../../domain/text.ts";
+
+export const nodeListDir: ListDir = (dir: AbsolutePath): readonly string[] => {
+  try {
+    return readdirSync(dir);
+  } catch (e) {
+    const code = codeOf(e);
+    if (code === "ENOENT" || code === "ENOTDIR") return [];
+    throw e;
+  }
+};

package/src/adapters/node/list-dir.test.ts

@@ -0,0 +1,30 @@
+/** `nodeListDir`: a directory's names; none for a missing directory or a file; other errors thrown. */
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+import { absolutePath } from "../../domain/paths.ts";
+import { useTempDir } from "../../../test/support.ts";
+import { nodeListDir } from "./list-dir.io.ts";
+
+const root = useTempDir("paperlint-list-dir-");
+
+describe("nodeListDir", () => {
+  it("lists a directory's names", () => {
+    mkdirSync(join(root, "talk"));
+    writeFileSync(join(root, "talk", "a.mp4"), "");
+    expect(nodeListDir(absolutePath(join(root, "talk")))).toEqual(["a.mp4"]);
+  });
+
+  it("is empty for a directory that does not exist", () => {
+    expect(nodeListDir(absolutePath(join(root, "none")))).toEqual([]);
+  });
+
+  it("is empty for a path that is a file", () => {
+    writeFileSync(join(root, "f"), "");
+    expect(nodeListDir(absolutePath(join(root, "f")))).toEqual([]);
+  });
+
+  it("throws any other error", () => {
+    expect(() => nodeListDir(absolutePath(`${root}/a\0b`))).toThrow();
+  });
+});

package/src/adapters/png/index.test.ts

@@ -0,0 +1,43 @@
+/** `imageSize`: the PNG header's width and height, or null for anything that is not a PNG. */
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { describe, expect, it } from "vitest";
+import { imageSize } from "./index.ts";
+
+const png = new Uint8Array(
+  readFileSync(
+    join(
+      dirname(fileURLToPath(import.meta.url)),
+      "../../../fixtures/talk/one-slide.png",
+    ),
+  ),
+);
+
+describe("imageSize", () => {
+  it("reads the IHDR width and height", () => {
+    expect(imageSize(png)).toEqual({ width: 16, height: 9 });
+  });
+
+  it("reads a size above 65 535 (four bytes, big-endian)", () => {
+    const big = png.slice();
+    big.set([0, 1, 0, 0], 16);
+    expect(imageSize(big)).toEqual({ width: 65_536, height: 9 });
+  });
+
+  it("is null for bytes too short to hold the header", () => {
+    expect(imageSize(png.slice(0, 20))).toBeNull();
+  });
+
+  it("is null without the PNG signature", () => {
+    const jpeg = png.slice();
+    jpeg.set([0xff, 0xd8], 0);
+    expect(imageSize(jpeg)).toBeNull();
+  });
+
+  it("is null when the first chunk is not IHDR", () => {
+    const odd = png.slice();
+    odd.set(new TextEncoder().encode("IDAT"), 12);
+    expect(imageSize(odd)).toBeNull();
+  });
+});

package/src/adapters/png/index.ts

@@ -0,0 +1,29 @@
+/**
+ * The PNG format as the image half of the `TalkMedia` port: an image's size, from its header.
+ *
+ * A PNG opens with an eight-byte signature and then the `IHDR` chunk, whose first eight data bytes
+ * are the width and the height as big-endian unsigned integers (PNG specification, 11.2.2). That is
+ * the whole of what is read; the pixels are never decoded.
+ */
+import type { PixelSize } from "../../domain/talk.ts";
+
+const SIGNATURE = [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a];
+/** Where the `IHDR` chunk's type and its width and height sit: after the signature and the length. */
+const IHDR_TYPE_AT = 12;
+const WIDTH_AT = 16;
+const HEIGHT_AT = 20;
+
+/** The bytes of an image → its size; null when they are not a PNG. */
+export function imageSize(bytes: Uint8Array): PixelSize | null {
+  if (bytes.length < HEIGHT_AT + 4) return null;
+  if (!SIGNATURE.every((b, i) => bytes[i] === b)) return null;
+  const type = new TextDecoder("latin1").decode(
+    bytes.subarray(IHDR_TYPE_AT, IHDR_TYPE_AT + 4),
+  );
+  if (type !== "IHDR") return null;
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  return {
+    width: view.getUint32(WIDTH_AT),
+    height: view.getUint32(HEIGHT_AT),
+  };
+}

package/src/adapters/srt/index.test.ts

@@ -0,0 +1,24 @@
+/** `captions`: the cues of an `.srt` file, their times in seconds. */
+import { describe, expect, it } from "vitest";
+import { captions } from "./index.ts";
+
+describe("captions", () => {
+  it("reads every cue's start and end", () => {
+    const srt =
+      "1\n00:00:00,000 --> 00:00:01,200\nA line.\n\n2\n00:01:01,400 --> 00:01:02,900\nAnother.\n";
+    expect(captions(srt)).toEqual([
+      { startS: 0, endS: 1.2 },
+      { startS: 61.4, endS: 62.9 },
+    ]);
+  });
+
+  it("reads Windows line endings", () => {
+    expect(captions("1\r\n00:00:03,000 --> 00:00:04,000\r\nx\r\n")).toEqual([
+      { startS: 3, endS: 4 },
+    ]);
+  });
+
+  it("is empty for text that holds no cue", () => {
+    expect(captions("not captions")).toEqual([]);
+  });
+});

package/src/adapters/srt/index.ts

@@ -0,0 +1,13 @@
+/**
+ * SubRip (`.srt`) captions as the captions half of the `TalkMedia` port, through `srt-parser-2`
+ * (MIT, no dependencies). Only the timing of each cue is kept: the rules judge coverage, not words.
+ */
+import Parser from "srt-parser-2";
+import type { Cue } from "../../domain/talk.ts";
+
+/** The text of an `.srt` file → its cues in file order; empty when it holds none. */
+export function captions(text: string): readonly Cue[] {
+  return new Parser()
+    .fromSrt(text)
+    .map((line) => ({ startS: line.startSeconds, endS: line.endSeconds }));
+}

package/src/cli.test.ts

@@ -70,6 +70,18 @@ test("🔴 parseSettings refuses a mistyped `structure` instead of letting `lint
   assert.equal(off.ok && off.value.structure, false);
 });
 
+test("parseSettings refuses `talk` in the root file: it is one paper's setting", () => {
+  const r = parseSettings(
+    { talk: { mode: "remote-video" } },
+    "paperlint.json",
+    "/r",
+  );
+  assert.equal(
+    r.ok ? null : r.error,
+    "paperlint.json: \"talk\" 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");

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,
@@ -125,6 +134,7 @@ import {
   CONFIG_FILE,
   DEFAULT_PAPERS_ROOT,
   PAPERS_DIR_FIELD,
+  PAPER_ONLY_KEYS,
   SETTINGS_KEYS,
   findProjectRoot,
 } from "#lib/paper-config";
@@ -236,8 +246,9 @@ 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. */
@@ -247,6 +258,14 @@ const TEX_RULE_DEPS = {
   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 = {},
@@ -344,6 +363,7 @@ export function buildConfig(
         },
         paper: { rules: texPaperRules },
         bib: bibReachable,
+        talk: { rules: talkRules(TALK_RULE_DEPS) },
         format: {
           rules: {
             ...formatRules(TEX_RULE_DEPS),
@@ -372,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
@@ -696,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);