paperlint 6.0.0 → 6.2.0

package/src/adapters/latex/prose.ts

@@ -14,10 +14,18 @@
  * own passage; one that cites or links leaves a citation mark in the sentence it hangs from.
  */
 import type * as Ast from "@unified-latex/unified-latex-types";
-import { hasAtLeast, sortBy } from "remeda";
-import type { Owner, Passage, ProsePiece } from "../../domain/tex-document.ts";
+import { hasAtLeast, mapWithFeedback, only, sortBy, zip } from "remeda";
+import type {
+  Emphasis,
+  EmphasisStyle,
+  Owner,
+  Passage,
+  Place,
+  ProsePiece,
+} from "../../domain/tex-document.ts";
 import {
   argumentsOf,
+  collapse,
   inPlace,
   macroPlace,
   mandatory,
@@ -28,12 +36,16 @@ import {
 } from "./nodes.ts";
 import { CITATION_MACROS, DEFINITION_MACROS, type ParsedTex } from "./parse.ts";
 
-/** What the walk yields: a piece, the end of a passage, the start of the back matter, a footnote. */
+/**
+ * What the walk yields: a piece, the end of a passage, the start of the back matter, a footnote, and
+ * an emphasised phrase — which stands beside the pieces it typesets, and makes no passage of its own.
+ */
 type Event =
   | { readonly kind: "piece"; readonly piece: ProsePiece }
   | { readonly kind: "break" }
   | { readonly kind: "end" }
-  | { readonly kind: "aside"; readonly events: readonly Event[] };
+  | { readonly kind: "aside"; readonly events: readonly Event[] }
+  | { readonly kind: "emphasis"; readonly emphasis: Emphasis };
 
 const BREAK: Event = { kind: "break" };
 const END: Event = { kind: "end" };
@@ -251,6 +263,75 @@ const OWN_EVENTS: ReadonlyMap<
   ],
 ]);
 
+/** Formatting macros that set their argument apart from the running text, and how. */
+const EMPHASIS_MACROS: ReadonlyMap<string, EmphasisStyle> = new Map([
+  ["textbf", "bold"],
+  ["emph", "italic"],
+  ["textit", "italic"],
+  ["textsl", "italic"],
+  ["underline", "underline"],
+  ["uline", "underline"],
+]);
+
+/**
+ * Declarations that set the rest of their group apart — `{\bfseries …}`, `{\em …}` — and how. The
+ * group is the phrase.
+ */
+const EMPHASIS_DECLARATIONS: ReadonlyMap<string, EmphasisStyle> = new Map([
+  ["bfseries", "bold"],
+  ["bf", "bold"],
+  ["em", "italic"],
+  ["itshape", "italic"],
+  ["it", "italic"],
+  ["slshape", "italic"],
+]);
+
+/** An emphasised phrase over `place`, typesetting what `inner` typesets; nothing when it has no place or no text. */
+const emphasisOf = (
+  style: EmphasisStyle,
+  place: Place,
+  inner: readonly Event[],
+): readonly Event[] =>
+  inPlace(place, (span) => {
+    const text = collapse(typeset(inner));
+    return text === ""
+      ? []
+      : [
+          {
+            kind: "emphasis",
+            emphasis: { style, place: "inline", text, span },
+          },
+        ];
+  });
+
+/** A formatting macro's events: what it typesets, and — for an emphasising one — the phrase. */
+function formattingEvents(t: ParsedTex, m: Macro): readonly Event[] {
+  const inner = walkList(t, lastArgument(m));
+  const style = EMPHASIS_MACROS.get(m.content);
+  return style === undefined
+    ? inner
+    : [...emphasisOf(style, macroPlace(m), inner), ...inner];
+}
+
+/** The style a group's opening declaration sets, when it opens with one (`{\bfseries …}`). */
+function declaredStyle(list: readonly Node[]): EmphasisStyle | undefined {
+  const first = list.find(
+    (n) => n.type !== "whitespace" && n.type !== "comment",
+  );
+  return first?.type === "macro"
+    ? EMPHASIS_DECLARATIONS.get(first.content)
+    : undefined;
+}
+
+/** A group's events: what it typesets, and — when it opens with an emphasis declaration — the phrase. */
+function groupEvents(t: ParsedTex, g: NodeOf<"group">): readonly Event[] {
+  const inner = walkList(t, g.content);
+  const style = declaredStyle(g.content);
+  return style === undefined
+    ? inner
+    : [...emphasisOf(style, placeOf(g), inner), ...inner];
+}
+
 function macroEvents(t: ParsedTex, m: Macro): readonly Event[] {
   const name = m.content;
   if (DEFINITION_MACROS.has(name)) return [];
@@ -260,7 +341,7 @@ function macroEvents(t: ParsedTex, m: Macro): readonly Event[] {
   const own = OWN_EVENTS.get(name);
   if (own !== undefined) return own(t, m);
   if (BREAK_MACROS.has(name)) return [BREAK];
-  if (INLINE_MACROS.has(name)) return walkList(t, lastArgument(m));
+  if (INLINE_MACROS.has(name)) return formattingEvents(t, m);
   const ch = CHARACTER_MACROS.get(name);
   return ch === undefined ? [] : characterAt(m, ch);
 }
@@ -298,7 +379,7 @@ function nodeEvents(t: ParsedTex, n: Node): readonly Event[] {
     case "whitespace":
       return textAt(n, " ");
     case "group":
-      return walkList(t, n.content);
+      return groupEvents(t, n);
     case "environment":
     case "mathenv":
       return environmentEvents(t, n);
@@ -346,20 +427,12 @@ function step(
  * macro the parser gave no signature — `\institution{…}`, `\ccsdesc[500]{…}`, `\tool{}`,
  * `\if\conference1` — which are its arguments, not text. A formatting macro's group (`\enquote{…}` without csquotes' signature) stays prose.
  */
-const proseNodes = (list: readonly Node[]): readonly Node[] =>
-  list.reduce<{
-    readonly kept: readonly Node[];
-    readonly state: ArgumentState;
-  }>(
-    (acc, n) => {
-      const next = step(acc.state, n);
-      return {
-        kept: next.skip ? acc.kept : [...acc.kept, n],
-        state: next.state,
-      };
-    },
-    { kept: [], state: "prose" },
-  ).kept;
+const proseNodes = (list: readonly Node[]): readonly Node[] => {
+  // Each node's step, fed the state the one before left: a scan, linear in the list.
+  const start: ReturnType<typeof step> = { skip: false, state: "prose" };
+  const steps = mapWithFeedback(list, (prev, n) => step(prev.state, n), start);
+  return zip(list, steps).flatMap(([n, st]) => (st.skip ? [] : [n]));
+};
 
 /** Formatting macros a run-in heading is set in: `\textbf{Correctness gate.} Each task…`. */
 const RUN_IN_MACROS: ReadonlySet<string> = new Set([
@@ -378,11 +451,33 @@ const typeset = (events: readonly Event[]): string =>
     )
     .join("");
 
-/** A formatting macro whose phrase ends in `.` or `:` — a run-in heading, when it opens a paragraph. */
-const isRunInHeading = (t: ParsedTex, n: Node): boolean =>
-  n.type === "macro" &&
-  RUN_IN_MACROS.has(n.content) &&
-  /[.:]$/u.test(typeset(walkList(t, lastArgument(n))).trim());
+/** The one node a group holds besides spaces and comments — `{\textbf{…}}` → the `\textbf` — or null. */
+const soleChild = (n: Node): Node | null => {
+  if (n.type !== "group") return null;
+  const kept = n.content.filter(
+    (c) => c.type !== "whitespace" && c.type !== "comment",
+  );
+  return only(kept) ?? null;
+};
+
+/** A node with the groups around it taken off: `{{\textbf{…}}}` → the `\textbf`. */
+const unwrapped = (n: Node): Node => {
+  const inner = soleChild(n);
+  return inner === null ? n : unwrapped(inner);
+};
+
+/**
+ * A formatting macro whose phrase ends in `.` or `:` — a run-in heading, when it opens a paragraph.
+ * Braces around it change nothing on the page, so `{\textbf{Threats:}}` is one too.
+ */
+const isRunInHeading = (t: ParsedTex, node: Node): boolean => {
+  const n = unwrapped(node);
+  return (
+    n.type === "macro" &&
+    RUN_IN_MACROS.has(n.content) &&
+    /[.:]$/u.test(typeset(walkList(t, lastArgument(n))).trim())
+  );
+};
 
 /** Macros that typeset no text, and so leave a paragraph's opening where it was. */
 const SILENT_AT_OPENING: ReadonlySet<string> = new Set([
@@ -405,28 +500,47 @@ const keepsOpening = (n: Node): boolean =>
 const opensAfter = (n: Node): boolean =>
   n.type === "parbreak" || (n.type === "macro" && BREAK_MACROS.has(n.content));
 
+/**
+ * An emphasising node's events when it opens a paragraph: its own phrase — the first event — is a
+ * label, not inline; braces around it change nothing on the page (`{\textbf{…}}.`). Any other node
+ * (an environment, a footnote) is left as it is: what it holds opens nothing here.
+ */
+const asOpening = (node: Node, events: readonly Event[]): readonly Event[] => {
+  const [own, ...rest] = events;
+  const n = unwrapped(node);
+  const emphasises =
+    (n.type === "macro" && EMPHASIS_MACROS.has(n.content)) ||
+    (n.type === "group" && declaredStyle(n.content) !== undefined);
+  return emphasises && own?.kind === "emphasis"
+    ? [
+        { kind: "emphasis", emphasis: { ...own.emphasis, place: "opening" } },
+        ...rest,
+      ]
+    : events;
+};
+
 /**
  * A list's events. `opens` says the list starts a paragraph (the body, an environment's content);
- * a run-in heading that opens a paragraph ends the passage before it and is left out, like a heading.
+ * a run-in heading that opens a paragraph ends the passage before it and is left out, like a heading,
+ * and a phrase emphasised there is a label (`opening`).
  */
 function walkList(
   t: ParsedTex,
   list: readonly Node[],
   opens = false,
 ): readonly Event[] {
-  return proseNodes(list).reduce<{
-    readonly events: readonly Event[];
-    readonly opening: boolean;
-  }>(
-    (acc, n) => ({
-      events: [
-        ...acc.events,
-        ...(acc.opening && isRunInHeading(t, n) ? [BREAK] : nodeEvents(t, n)),
-      ],
-      opening: opensAfter(n) || (acc.opening && keepsOpening(n)),
-    }),
-    { events: [], opening: opens },
-  ).events;
+  const nodes = proseNodes(list);
+  // Whether a paragraph is open AFTER each node: a scan, so the walk stays linear in the list.
+  const after = mapWithFeedback(
+    nodes,
+    (opening, n) => opensAfter(n) || (opening && keepsOpening(n)),
+    opens,
+  );
+  return nodes.flatMap((n, i) => {
+    const opening = i === 0 ? opens : after[i - 1] === true;
+    if (!opening) return nodeEvents(t, n);
+    return isRunInHeading(t, n) ? [BREAK] : asOpening(n, nodeEvents(t, n));
+  });
 }
 
 /** The events before the back matter starts. */
@@ -437,27 +551,35 @@ const untilEnd = (events: readonly Event[]): readonly Event[] => {
 
 /** Events → passages: pieces between breaks, each footnote a passage of its own. */
 function passagesOf(events: readonly Event[]): readonly Passage[] {
-  const { done, current } = events.reduce<{
-    readonly done: readonly (readonly ProsePiece[])[];
-    readonly current: readonly ProsePiece[];
-  }>(
-    (acc, e) =>
-      e.kind === "piece"
-        ? { done: acc.done, current: [...acc.current, e.piece] }
-        : e.kind === "break"
-          ? { done: [...acc.done, acc.current], current: [] }
-          : acc,
-    { done: [], current: [] },
+  // Where each passage starts and ends: between breaks. Slicing between them keeps this linear in
+  // the events — a paragraph of thousands of words is one slice, not a copy per word.
+  const breaks = events.flatMap((e, i) => (e.kind === "break" ? [i] : []));
+  const bounds = zip(
+    [0, ...breaks.map((b) => b + 1)],
+    [...breaks, events.length],
   );
+  const own = bounds.flatMap(([from, to]) => {
+    const pieces = events
+      .slice(from, to)
+      .flatMap((e) => (e.kind === "piece" ? [e.piece] : []));
+    return hasAtLeast(pieces, 1) ? [{ pieces }] : [];
+  });
   const asides = events.flatMap((e) =>
     e.kind === "aside" ? passagesOf(untilEnd(e.events)) : [],
   );
-  const own = [...done, current].flatMap((pieces) =>
-    hasAtLeast(pieces, 1) ? [{ pieces }] : [],
-  );
   return [...own, ...asides];
 }
 
+/** Every emphasised phrase among events, a footnote's included, up to the back matter. */
+const emphasesOf = (events: readonly Event[]): readonly Emphasis[] =>
+  untilEnd(events).flatMap((e) =>
+    e.kind === "emphasis"
+      ? [e.emphasis]
+      : e.kind === "aside"
+        ? emphasesOf(e.events)
+        : [],
+  );
+
 const isDocument = (n: Node): n is Readonly<Ast.Environment> =>
   n.type === "environment" && n.env === "document";
 
@@ -476,9 +598,17 @@ const startOf = (p: Passage): number => {
  * source when there is none), up to the first back-matter node.
  */
 export function bodyProse(t: ParsedTex): readonly Passage[] {
-  const body = t.root.content.find(isDocument)?.content ?? t.root.content;
-  return sortBy(
-    passagesOf(untilEnd(walkList(t, body, true))).filter(hasProse),
-    startOf,
-  );
+  return sortBy(passagesOf(untilEnd(bodyEvents(t))).filter(hasProse), startOf);
+}
+
+/** The walk of the body: the content of the `document` environment, or the whole source when there is none. */
+const bodyEvents = (t: ParsedTex): readonly Event[] =>
+  walkList(t, t.root.content.find(isDocument)?.content ?? t.root.content, true);
+
+/**
+ * The phrases set in bold, italics or underline inside the body's prose, in document order: what
+ * `bodyProse` reads, so never a heading, a run-in heading, a caption, a float or a table.
+ */
+export function bodyEmphasis(t: ParsedTex): readonly Emphasis[] {
+  return sortBy(emphasesOf(bodyEvents(t)), (e) => e.span.start);
 }

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");