paperlint 6.1.0 → 6.2.0

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

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 });
+  });
+});