easycaptionkit 0.1.0 → 0.1.2

package/README.md

@@ -29,7 +29,7 @@ easycaptionkit-demo/
 ```
 
 - Three styles: `karaoke` shows each caption whole and lights the word being spoken, `line` shows each caption whole in one color, `word` shows one word at a time, lit.
-- With easyfontkit's `fonts.css`, the captions are drawn with the site's own font files, the ones in its folder, its heading font first. Chrome reports which font drew each letter, and CAPTIONS.md says so: a Japanese or Arabic caption over a Latin-only brand font is drawn partly in a system font, and the file tells you how much.
+- With easyfontkit's `fonts.css`, the captions are drawn with the site's own font files, the ones in its folder, its heading font first. Chrome reports which font drew each letter, and CAPTIONS.md says so: a Japanese or Arabic caption over a Latin-only brand font is drawn partly in a system font, and the file tells you how much. A letter Chrome finds no font for on the machine is drawn as a box, as Japanese is on a server with no Japanese font; on Linux, where fontconfig can tell, CAPTIONS.md names those letters and says to install a font that has them, such as Noto Sans CJK, or to give `--fonts` an easyfontkit folder whose font has them.
 - With an easybrandkit folder, the spoken word is lit in the brand's button, link or logo color. A color too dark to read as letters on the outline (a deep green, a navy) lights the word on a rounded patch of it instead. Without `--fonts` or `--font`, the brand's heading font is asked for by name, which this machine may not have; CAPTIONS.md says which font drew the letters wherever Chrome or fontconfig can tell.
 - Captions are cut at sentence ends, commas and pauses, into at most two lines of what fits the safe width, up to 42 characters, by default (`--lines` and `--max-chars` change both), and held a little longer when they would flash by. In Japanese no caption or line starts with a particle or a small kana, or splits a word, when another break fits.
 - The sound is copied as it is, so its loudness does not change. Sound that MP4 players do not take, like a camera's PCM in a MOV, becomes AAC at the same rate.
@@ -96,7 +96,7 @@ npx easycaptionkit@latest styles [--json]
 
 easycaptionkit reads files, not addresses: a video or words given as `https://...` is refused, so download it first. `--brand` and `--fonts` take what easybrandkit and easyfontkit make from a site, so a site's address there is refused with words that name the kit to make it with.
 
-`subtitles` writes captions.srt, captions.vtt and captions.ass from the words alone, with words.json, captions.json and CAPTIONS.md, and changes no video; `--video` gives it a video's size and length. captions.ass is laid out for that frame, its lines cut to what fits across it at the letter size, so it can have more captions than captions.srt and captions.vtt, whose lines take up to 42 characters unless `--max-chars` gives another number. `styles` lists the styles, the options and every place's margins with their sources.
+`subtitles` writes captions.srt, captions.vtt and captions.ass from the words alone, with words.json, captions.json and CAPTIONS.md, and changes no video; `--video` gives it a video's size and length, and without it a demo's captions end where its steps.json says the video does. captions.ass is laid out for that frame, its lines cut to what fits across it at the letter size, so it can have more captions than captions.srt and captions.vtt, whose lines take up to 42 characters unless `--max-chars` gives another number. `styles` lists the styles, the options and every place's margins with their sources.
 
 Without `--out`, a run goes to `easycaptionkit-<video name>`, or to `easycaptionkit-<video name>-2` and on when that folder holds the captions of another video by the same name, such as a second `demo.mp4`. A subtitles run goes to `easycaptionkit-subtitles-<video name>`, or `easycaptionkit-subtitles-<words name>` without `--video`, with `-2` and on in the same way. The name is the file's in lower case, its letters and digits in any script with a dash for anything else, and accents taken off Latin letters only; a name longer than 60 letters or 180 bytes is cut and ends in a short hash of the whole name. A run replaces the files an earlier run wrote in its folder, says so when that run was made from another file, and leaves anything else there alone. Each run's captions.json and words.json name the other files it wrote, with their sizes and SHA-256. A run stops before any work when the folder holds a file by one of the names it writes that they do not name, or that has changed since, such as another tool's words.json, a sheet.png of your own or a link, or one of the files the run reads, and says to pick another `--out`. A subtitles run also stops at a folder that holds the captioned video of an earlier run, which its new files would no longer match. The one file read and written over is a words.json from an earlier run, fixed by hand; if the edit breaks the JSON, the run says at which line and column. Once its words are fixed, a run that reads other words, such as the first command again, stops rather than replace them, and says how to keep them or start over. A file that comes in by one of the names while a run is going, or one there whose content changes, stays as it is: the run leaves the folder as it was and puts its own files in `easycaptionkit-new` inside it.
 
@@ -147,7 +147,7 @@ Only ads have published margins, and apps move their buttons. Each figure carrie
 4. The PNGs go into one animated PNG, each for exactly as long as its state lasts, to the millisecond. ffmpeg reads it as one stream and lays it over the video in a single encode, H.264 with x264 at CRF 18 where ffmpeg has x264, with every frame at its own time, or at a steady rate where the video has too few frames for the captions, as above. On an SDR video the caption colors are converted with the video's own color matrix, so a brand color lands on the same color. A picture stored as RGB, as PNG or QuickTime Animation in a MOV is, or coded in YCgCo, is converted to the matrix players take for its size first, and captioned.mp4 names the matrix it holds.
 5. Writes the subtitle files, takes frames of up to 24 captions from the result for sheet.png, draws safe-zones.png, and moves everything into the folder at once. A run that fails, or is stopped, leaves the folder as it was. A run killed outright (`kill -9`, or the system when memory runs out) cannot tidy up: its hidden `.easycaptionkit-work-` folder stays in the out folder, where an ffmpeg it started can go on writing captioned.mp4 to the end, and the Chrome profile it was drawing with stays in the temporary folder. The next run into that folder removes the work folder, and a later run of the same user that starts Chrome removes the profile once no process names it and it has not changed for a day, except on Windows, where it stays in the temporary folder until Windows or you clear it.
 
-With `--libass`, ffmpeg draws the captions itself from captions.ass with its ass filter, and where Chrome is missing or cannot start, ffmpeg makes plainer pictures too, and CAPTIONS.md says why. That needs an ffmpeg built with libass, which Homebrew's default ffmpeg is not. The kit gives the ass filter libass's complex shaping, which joins Arabic letters and forms the conjuncts of Devanagari and Bengali as Chrome does. ffmpeg's subtitles filter shapes them simply and draws Arabic in a font without its presentation forms, such as Noto Kufi Arabic, as boxes, so to burn captions.ass yourself, use `ass=captions.ass:shaping=complex`. When its font comes from fonts.css, give libass the folder of that file too, easyfontkit's `files`, as `ass=captions.ass:fontsdir=../easyfontkit-acme.com/files:shaping=complex` does from the captions' folder, or libass draws another font in its place; CAPTIONS.md gives the folder. captions.ass names the video's color matrix and range in its YCbCr Matrix line, as TV.709 for most HD videos, so players and ffmpeg 8's ass filter convert its colors as the video's own; for a video in BT.2020's matrix, as HDR video is, one stored as RGB, and one in YCgCo or another matrix ASS has no name for, it says None, with which they take the video's matrix. Older ass filters, such as 4.4's, convert every color as BT.601 does, so the kit gives them the colors that come out as the video's own, and a full range picture in the one form they draw full range colors on, so its white is white; a color BT.601 cannot reach that way, such as a pure green on an HD video, is drawn as the nearest one it can, and CAPTIONS.md says so. libass lays every line out from the left unless the style's Encoding is -1, so captions in Arabic, Hebrew or another script written from the right have -1 there, and libass, like Chrome, takes each line's direction from its first letter, so a line of Arabic has its full stop at the left. libass finds a font file in the kit's folder by the family name in the file, which fonts.css can give otherwise (easyfontkit calls InterVariable Inter), so captions.ass names it as the file does. libass draws a variable font at its default weight rather than the bold, and CAPTIONS.md says so; a highlight too dark for letters becomes a thick border of that color instead of a patch. libass draws no color emoji either, so the video shows a box for an emoji this machine has no black and white font for. CAPTIONS.md says which on Linux, where fontconfig can tell, and elsewhere names the emoji as ones that can show as boxes. libass makes a font as tall as its OS/2 heights rather than its em, so captions.ass gives the font the size whose em is the letter size CAPTIONS.md names. libass measures no letters either, so a line whose width, added up from the widths of its letters in the font, puts it past the safe space is drawn smaller, and captions.ass draws it smaller the same way, as capitals often need. The heights and widths come from the font file where the kit knows it: the one fonts.css names, or on Linux the one fontconfig gives for the name. libass draws a letter that font lacks, as a Latin font lacks Japanese, with another font, sized by that font's own heights, so on Linux captions.ass sets such letters in the font fontconfig gives for them, and an Arabic letter in the first Arabic family Chrome is given that this machine has, such as Noto Sans Arabic, at the size that makes them as big as the others. Elsewhere the numbers are Arial Bold's, and a letter the font does not have is guessed, so such a line can still reach past the safe space. Where Chrome drew the captions, captions.ass takes the size Chrome measured. Without `--libass`, a run with no Chrome, or with one that cannot start here (in a container without its sandbox, say), stops before the encode and says so.
+With `--libass`, ffmpeg draws the captions itself from captions.ass with its ass filter, and where Chrome is missing or cannot start, ffmpeg makes plainer pictures too, and CAPTIONS.md says why. That needs an ffmpeg built with libass, which Homebrew's default ffmpeg is not. The kit gives the ass filter libass's complex shaping, which joins Arabic letters and forms the conjuncts of Devanagari and Bengali as Chrome does. ffmpeg's subtitles filter shapes them simply and draws Arabic in a font without its presentation forms, such as Noto Kufi Arabic, as boxes, so to burn captions.ass yourself, use `ass=captions.ass:shaping=complex`. When its font comes from fonts.css, give libass the folder of that file too, easyfontkit's `files`, as `ass=captions.ass:fontsdir=../easyfontkit-acme.com/files:shaping=complex` does from the captions' folder, or libass draws another font in its place; CAPTIONS.md gives the folder. captions.ass names the video's color matrix and range in its YCbCr Matrix line, as TV.709 for most HD videos, so players and ffmpeg 8's ass filter convert its colors as the video's own; for a video in BT.2020's matrix, as HDR video is, one stored as RGB, and one in YCgCo or another matrix ASS has no name for, it says None, with which they take the video's matrix. Older ass filters, such as 4.4's, convert every color as BT.601 does, so the kit gives them the colors that come out as the video's own, and a full range picture in the one form they draw full range colors on, so its white is white; a color BT.601 cannot reach that way, such as a pure green on an HD video, is drawn as the nearest one it can, and CAPTIONS.md says so. libass lays every line out from the left unless the style's Encoding is -1, so captions in Arabic, Hebrew or another script written from the right have -1 there, and libass, like Chrome, takes each line's direction from its first letter, so a line of Arabic has its full stop at the left. libass finds a font file in the kit's folder by the family name in the file, which fonts.css can give otherwise (easyfontkit calls InterVariable Inter), so captions.ass names it as the file does. libass draws a variable font at its default weight rather than the bold, and CAPTIONS.md says so; a highlight too dark for letters becomes a thick border of that color instead of a patch. libass draws no color emoji either, so the video shows a box for an emoji this machine has no black and white font for, and for any letter no font on it has. CAPTIONS.md says which on Linux, where fontconfig can tell, with what to do, and elsewhere names the emoji as ones that can show as boxes. libass makes a font as tall as its OS/2 heights rather than its em, so captions.ass gives the font the size whose em is the letter size CAPTIONS.md names. libass measures no letters either, so a line whose width, added up from the widths of its letters in the font, puts it past the safe space is drawn smaller, and captions.ass draws it smaller the same way, as capitals often need. The heights and widths come from the font file where the kit knows it: the one fonts.css names, or on Linux the one fontconfig gives for the name. libass draws a letter that font lacks, as a Latin font lacks Japanese, with another font, sized by that font's own heights, so on Linux captions.ass sets such letters in the font fontconfig gives for them, and an Arabic letter in the first Arabic family Chrome is given that this machine has, such as Noto Sans Arabic, at the size that makes them as big as the others. Elsewhere the numbers are Arial Bold's, and a letter the font does not have is guessed, so such a line can still reach past the safe space. Where Chrome drew the captions, captions.ass takes the size Chrome measured. Without `--libass`, a run with no Chrome, or with one that cannot start here (in a container without its sandbox, say), stops before the encode and says so.
 
 ## Limits
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "easycaptionkit",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Burn captions into a video in the product's own fonts and colors, word by word or line by line, kept clear of each app's buttons, with the SRT, VTT and ASS files to go with it.",
   "license": "MIT",
   "author": "Emin Budak",

package/skills/easycaptionkit/SKILL.md

@@ -32,7 +32,7 @@ node <skill>/scripts/easycaptionkit.js subtitles transcript.json --video video.m
 
 ## Use the result
 
-1. Read `CAPTIONS.md` first. It says which font drew the letters (and how many letters fell back to another font, as Japanese or Arabic text over a Latin brand font does), where the captions sit and why, and which captions go faster than people read.
+1. Read `CAPTIONS.md` first. It says which font drew the letters (and how many letters fell back to another font, as Japanese or Arabic text over a Latin brand font does, and which show as boxes because no font on the machine has them), where the captions sit and why, and which captions go faster than people read.
 2. Look at `sheet.png`: frames of `captioned.mp4` for up to 24 captions, spread over the video. Check that no caption covers text or a face in the picture; if one does, run again with `--position middle` or `top`. A video with more captions than the sheet shows has every caption's time in `captions.json`; take a frame at the times that matter.
 3. Show `safe-zones.png` to the user: a frame under each app's buttons, the margins tinted, the safe space outlined.
 4. Hand over `captioned.mp4`. It has every frame of the video at its own time, or, where the video holds a frame too long for the captions or has few frames a second (CAPTIONS.md says so), every frame at a steady rate, and its sound copied, or made AAC when MP4 players do not take it. Give `captions.srt` or `captions.vtt` to places that take a captions file.
@@ -42,7 +42,7 @@ node <skill>/scripts/easycaptionkit.js subtitles transcript.json --video video.m
 ## When it goes wrong
 
 - "reads files, not addresses": the video or the words were given as a link. Download it first and give the file. "--brand takes an easybrandkit folder" or "--fonts takes an easyfontkit folder": a site's address was given for the brand or the fonts. Make the folder from that site with easybrandkit or easyfontkit and give it.
-- "Every word starts after the video ends": the words belong to another video, or their times are in milliseconds in a shape the kit does not know. Convert them to seconds in a plain list of `{ "text", "start", "end" }`.
+- "Every word starts after the video ends": the words belong to another video, or their times are in milliseconds in a shape the kit does not know. Convert them to seconds in a plain list of `{ "text", "start", "end" }`. Where the message says the words file gives the video's length, as a demo's steps.json does on a subtitles run with no `--video`, the times in that file or that length are wrong; `--video` goes by the video's own length.
 - A caption is drawn smaller than the others: one of its lines was wider than the safe space (with `--libass`, by an estimate of its width). Lower `--max-chars` for long lines. A single long word, like a link, fits only at a lower `--size`; or shorten it in `words.json`.
 - "Pick another --out": the folder holds a file by one of the names the kit writes that it did not write itself (another tool's words.json, or a link, say) or that has changed since it wrote it, or one of the files the run reads, or, for a subtitles run, the captioned video of an earlier run, which new subtitle files would no longer match. Give a new folder with `--out`.
 - "holds words fixed by hand": the folder's words.json has fixes this run would lose, since it reads another words file. The message gives the command that keeps them, the one refused with `<out>/words.json` as its words; or move `<out>/words.json` away to start again from the words file. A subtitles run into the folder of a captioned video is refused whatever its words, and when they were fixed there, the message gives the command that makes subtitles of them in a folder of their own.
@@ -50,7 +50,8 @@ node <skill>/scripts/easycaptionkit.js subtitles transcript.json --video video.m
 - Without `--out`, a second video by the same name as an earlier one (every easyscreenshotkit demo is demo.mp4) goes to `easycaptionkit-demo-2`, and the summary says so. A subtitles run goes to `easycaptionkit-subtitles-<video name>`, or `easycaptionkit-subtitles-<words name>` without `--video`, in the same way. With `--out`, a run into the folder of another video's captions replaces them and says whose they were.
 - CAPTIONS.md says the brand font was asked for by name and this machine does not have it: give easyfontkit's folder with `--fonts`. When it says Chrome drew no letter with the file of a fonts.css font, that file lacks the letters of these words, as a cut for another script does.
 - The font license in CAPTIONS.md is commercial: tell the user before the video goes out. The file names the closest free font; `--font "<that font>"` uses it once it is installed. When CAPTIONS.md says no letter of the font is in the video, as with Japanese or Arabic words over a Latin font, its license does not reach the video: the fonts that drew the letters came with the machine.
-- With `--libass`, CAPTIONS.md can say the video shows boxes for some emoji: libass draws no color emoji. Run again without `--libass` to have Chrome draw them. A letter no font on the machine has shows as a box with Chrome too.
+- With `--libass`, CAPTIONS.md can say the video shows boxes for some emoji: libass draws no color emoji. Run again without `--libass` to have Chrome draw them.
+- CAPTIONS.md says Chrome found no font for some letters, or that no font libass can use has them: the video shows a box for each, as it does for Japanese on a server with no Japanese font. Install a font that has them, such as Noto Sans CJK (`fonts-noto-cjk` on Debian and Ubuntu), or give `--fonts` an easyfontkit folder whose font has them, and run again. Do not hand over a video with boxes in its captions.
 - No Chrome on the machine: the run stops. `--libass` draws the captions with ffmpeg's libass instead, which needs an ffmpeg built with libass (Homebrew's default ffmpeg is not).
 - "Chrome could not start its sandbox here", or another reason Chrome stopped as it started (in a container, or on a CI runner without user namespaces): the run stops before the encode. `--libass` draws the captions without Chrome, and ffmpeg makes plainer sheet.png and safe-zones.png, which CAPTIONS.md notes.
 - A run killed outright (`kill -9`, or the system when memory runs out) cannot tidy up: its hidden `.easycaptionkit-work-` folder stays in the out folder, where an ffmpeg it started can go on writing captioned.mp4, and its Chrome profile stays in the temporary folder. The captioned.mp4 in that folder is no result to hand over: run again. The next run into the folder removes the work folder, and a later run of the same user that starts Chrome removes the profile once no process names it and it has not changed for a day, except on Windows, where it stays in the temporary folder until Windows or the user clears it.

package/skills/easycaptionkit/scripts/easycaptionkit.js

@@ -4,7 +4,7 @@
 const path = require("node:path");
 const version = require("./lib/version");
 const { PLACES, PLACE_NAMES } = require("./lib/places");
-const { drewWith, setsAny, setsNone, machineHas, shown, soundText } = require("./lib/report");
+const { drewWith, setsAny, setsNone, boxedIn, machineHas, shown, soundText } = require("./lib/report");
 const { variableFace, sameName } = require("./lib/look");
 
 const USAGE = `Usage: easycaptionkit <video> --words <file> [options]
@@ -297,7 +297,12 @@ function summary({ dir, facts: f }) {
     // sets them in, which can be all of them, as Japanese over a Latin font.
     const fallbacks = libass ? f.assFallbacks || [] : [];
     const none = libass && setsNone(f);
-    if (!f.look.family) font = libass ? `Arial, asked for by name${m && !sameName(m.family, "Arial") ? ` (fontconfig gives ${m.family})` : ""}` : f.fontFirst ? (drawn.length && !firstDrew ? `${f.fontFirst}, which has none of these letters: ${list(drawn.map((x) => x.family))} drew them` : f.fontFirst) : drawn.length ? `a common sans (${list(drawn.map((x) => x.family))} drew it)` : "a common sans";
+    // Where letters show as boxes, which a note names, the fonts named
+    // drew the others, and the font lacks more letters than they drew.
+    const boxed = boxedIn(f);
+    const them = boxed ? "all but the boxes" : "them";
+    const the = boxed ? "" : "the ";
+    if (!f.look.family) font = libass ? `Arial, asked for by name${m && !sameName(m.family, "Arial") ? ` (fontconfig gives ${m.family})` : ""}` : f.fontFirst ? (drawn.length && !firstDrew ? `${f.fontFirst}, which has none of these letters: ${list(drawn.map((x) => x.family))} drew ${them}` : f.fontFirst) : drawn.length ? `a common sans (${list(drawn.map((x) => x.family))} drew it)` : "a common sans";
     else if (libass && variableFace(f.look) && setsAny(f)) font = `${f.look.family} from fonts.css, which libass draws at its variable file's default weight, not at ${f.look.weight}`;
     else if (libass && f.look.from === "machine") font = `${f.look.family} ${f.look.weight}, asked for by name${!m ? "; libass draws whatever this machine gives for that name" : sameName(m.family, f.look.family) ? "" : ` (not on this machine: fontconfig gives ${m.family})`}`;
     else font = `${f.look.family} ${f.look.weight}${f.look.from === "fonts.css" ? " from fonts.css" : ""}`;
@@ -307,7 +312,7 @@ function summary({ dir, facts: f }) {
     const families = list(fallbacks.map((x) => x.family));
     const set = fallbacks.reduce((a, b) => a + b.letters, 0);
     if (none) font += `, ${renamed ? "and which" : "which"} has none of these letters: captions.ass sets them in ${families}`;
-    else if (fallbacks.length) font += `; captions.ass sets the ${set} ${set === 1 ? "letter" : "letters"} it lacks in ${families}`;
+    else if (fallbacks.length) font += `; captions.ass sets ${the}${set} ${set === 1 ? "letter" : "letters"} it lacks in ${families}`;
     const missing = drawn.length && f.look.family && !drawn.some((x) => drewWith(x, f.look));
     const why = f.look.from !== "machine" ? "its file drew nothing" : machineHas(f) ? "it has none of these letters" : "not on this machine";
     // With Chrome, the fonts that drew the letters the font lacks, where
@@ -315,8 +320,10 @@ function summary({ dir, facts: f }) {
     const own = libass ? [] : drawn.filter((x) => (f.look.family ? drewWith(x, f.look) : x.family === f.fontFirst));
     const others = own.length ? drawn.filter((x) => !own.includes(x)) : [];
     const rest = others.reduce((a, b) => a + b.glyphs, 0);
-    const filled = others.length ? `; Chrome drew the ${rest} ${rest === 1 ? "letter" : "letters"} it lacks with ${list(others.map((x) => (others.length > 1 ? `${x.family} (${x.glyphs})` : x.family)))}` : "";
-    lines.push(`  Font      ${font}${missing ? ` (${why}: ${list(drawn.map((x) => x.family))} drew them)` : filled}`);
+    const filled = others.length ? `; Chrome drew ${the}${rest} ${rest === 1 ? "letter" : "letters"} it lacks with ${list(others.map((x) => (others.length > 1 ? `${x.family} (${x.glyphs})` : x.family)))}` : "";
+    // Every letter a box: the font asked for by name drew none of them either.
+    const gone = !libass && boxed && !drawn.length && f.look.family && f.look.from === "machine" && !machineHas(f);
+    lines.push(`  Font      ${font}${missing ? ` (${why}: ${list(drawn.map((x) => x.family))} drew ${them})` : gone ? " (not on this machine)" : filled}`);
     if (f.style !== "line") lines.push(`  Lit word  ${f.look.highlightMode !== "patch" ? f.look.highlight : libass ? `in a thick border of ${f.look.highlight}` : `on a patch of ${f.look.highlight}`}`);
     lines.push(`  Video     captioned.mp4, ${o.width}x${o.height}, ${o.fps} fps, ${sec(o.duration)}, ${soundText(o.audio)}`);
   }

package/skills/easycaptionkit/scripts/lib/boxes.js

@@ -0,0 +1,139 @@
+"use strict";
+
+// The letters a video shows as boxes. Chrome draws a letter it finds no
+// font for with the missing glyph of the first font of the list, a box,
+// and names that font as the one that drew it: on an Ubuntu with no
+// Japanese font, Liberation Sans for every letter of a Japanese caption.
+// So each font Chrome names is asked whether it has each letter, a font
+// of fonts.css through its own files and any other through the letters
+// fontconfig lists for it, and a letter none of them has is a box. libass
+// looks through fontconfig for a font for each letter its own font lacks,
+// and draws a box where no font on the machine has one. Without
+// fontconfig, as on macOS and Windows, nothing here can say, and nothing
+// is said.
+
+const { spawnSync } = require("node:child_process");
+const { clusters } = require("./text");
+const { fcName } = require("./look");
+
+// What fc-list prints for a pattern in a format, or "" where there is no
+// fc-list or it fails. The letters of every font of a machine with many
+// fonts take some megabytes.
+function fcList(pattern, format) {
+  let r;
+  try {
+    r = spawnSync("fc-list", ["-f", format, ...(pattern ? [pattern] : [])], { encoding: "utf8", timeout: 20_000, maxBuffer: 256 * 1024 * 1024 });
+  } catch {
+    return "";
+  }
+  return r.error || r.status !== 0 ? "" : r.stdout || "";
+}
+
+// The code points of fontconfig's charsets, as it prints them ("20-7e
+// a0-17f 192"), all of them together, as a lookup: has(code). The ranges
+// are put in order and joined, and a code point is found by halves.
+function letterSet(charsets) {
+  const ranges = [];
+  for (const charset of charsets) {
+    for (const part of charset.split(/\s+/)) {
+      const m = /^([0-9a-f]{1,6})(?:-([0-9a-f]{1,6}))?$/i.exec(part);
+      if (m) ranges.push([parseInt(m[1], 16), parseInt(m[2] || m[1], 16)]);
+    }
+  }
+  ranges.sort((a, b) => a[0] - b[0]);
+  const starts = [];
+  const ends = [];
+  for (const [from, to] of ranges) {
+    const last = ends.length - 1;
+    if (last >= 0 && from <= ends[last] + 1) ends[last] = Math.max(ends[last], to);
+    else {
+      starts.push(from);
+      ends.push(to);
+    }
+  }
+  return (code) => {
+    let lo = 0;
+    let hi = starts.length - 1;
+    let found = -1;
+    while (lo <= hi) {
+      const mid = (lo + hi) >> 1;
+      if (starts[mid] <= code) {
+        found = mid;
+        lo = mid + 1;
+      } else hi = mid - 1;
+    }
+    return found >= 0 && code <= ends[found];
+  };
+}
+
+// The letters a font Chrome names has, as fontconfig lists them for its
+// PostScript name, else for its family: has(code), or null where
+// fontconfig gives nothing for it or cannot be asked. `list` stands in
+// for fc-list in the tests.
+function fontLetters({ family = "", postScriptName = "" }, { platform = process.platform, list = fcList } = {}) {
+  if (platform !== "linux") return null;
+  const charsets = (pattern) => list(pattern, "%{charset}\\n").split("\n").filter((line) => line.trim());
+  let found = postScriptName ? charsets(`:postscriptname=${fcName(postScriptName)}`) : [];
+  if (!found.length && family) found = charsets(`:family=${fcName(family)}`);
+  return found.length ? letterSet(found) : null;
+}
+
+// The letters of every font on this machine, as fontconfig lists them:
+// has(code), or null where fontconfig cannot be asked. libass finds a
+// font through fontconfig for a letter its own font lacks, among all of
+// them, so a letter none of them has is a box.
+function machineLetters({ platform = process.platform, list = fcList } = {}) {
+  if (platform !== "linux") return null;
+  const text = list("", "%{charset}\\n");
+  return text.trim() ? letterSet(text.split("\n")) : null;
+}
+
+// A letter as a reader sees it, one or more code points, is in a font
+// when the font has each of them but those that draw nothing (a joiner, a
+// variation selector, the object mark U+FFFC), as they are, composed or
+// decomposed: HarfBuzz draws é from e and its accent in a font that has
+// only those, and a no-break hyphen with the plain one of a font that has
+// only that, as Liberation Sans is from version 2.1.
+const DRAWS_NOTHING = /^[\p{Default_Ignorable_Code_Point}\ufffc]$/u;
+function hasLetter(has, letter) {
+  for (const form of new Set([letter, letter.normalize("NFC"), letter.normalize("NFD"), letter.replace(/\u2011/g, "\u2010")])) {
+    if (Array.from(form).every((p) => DRAWS_NOTHING.test(p) || has(p))) return true;
+  }
+  return false;
+}
+
+// The letters of `letters` Chrome drew as boxes: those no font it names
+// for them has, of [{ family, postScriptName, custom, glyphs }]. A font of
+// fonts.css, which Chrome names as custom, is asked through `kit(c)`,
+// kitLetters' answer for a code point. Where a font named cannot be asked,
+// as without fontconfig, or Chrome names none, nothing can say: none.
+// `lookUp` stands in for fontLetters in the tests.
+function chromeBoxes(letters, fonts, { kit = null, lookUp = fontLetters } = {}) {
+  const drew = fonts.filter((font) => font.glyphs > 0);
+  if (!drew.length) return [];
+  const asks = [];
+  for (const font of drew) {
+    if (font.custom) {
+      if (!kit) return [];
+      asks.push(kit);
+      continue;
+    }
+    const has = lookUp(font);
+    if (!has) return [];
+    asks.push((p) => has(p.codePointAt(0)));
+  }
+  return letters.filter((letter) => !/^\s+$/.test(letter) && !asks.some((has) => hasLetter(has, letter)));
+}
+
+// Each letter of the captions that is one of `boxed`, with the number of
+// its caption: [{ letter, cue }], as assLetters gives the ones libass has
+// no font for.
+function boxesIn(cues, boxed) {
+  const set = new Set(boxed);
+  if (!set.size) return [];
+  const out = [];
+  for (const cue of cues) for (const line of cue.lines) for (const c of clusters(line)) if (set.has(c)) out.push({ letter: c, cue: cue.n });
+  return out;
+}
+
+module.exports = { fcList, letterSet, fontLetters, machineLetters, hasLetter, chromeBoxes, boxesIn };

package/skills/easycaptionkit/scripts/lib/caption.js

@@ -12,7 +12,8 @@ const crypto = require("node:crypto");
 const { loadWords, handFixed, wordsSha256, FORMATS, MOST_OPENED, DEEPEST } = require("./words");
 const { cjkLanguage, arabicIn, scriptsIn } = require("./text");
 const { buildCues, states: makeStates, readingSpeed } = require("./cues");
-const { srt, vtt, ass, assFont, estimatedScales, shrunkOf, assLetters, SRT_SPECIAL } = require("./subtitles");
+const { srt, vtt, ass, assFont, kitLetters, estimatedScales, shrunkOf, assLetters, SRT_SPECIAL } = require("./subtitles");
+const { machineLetters, chromeBoxes, boxesIn } = require("./boxes");
 const { captionLayout, charsThatFit, defaultPlaces, shapeOf } = require("./places");
 const { chooseLook, variableFace, machineFont, fallbackFont } = require("./look");
 const { fontLike } = require("./fontfile");
@@ -20,7 +21,7 @@ const ffmpeg = require("./ffmpeg");
 const { findChrome, missingChrome, chromeNamedNothing, tempProblem } = require("./chrome");
 const { renderStates } = require("./render");
 const { safeZonesPng, sheetPng, plainPictures, shotOf } = require("./draw");
-const { captionsMarkdown, captionsJson, subtitlesMarkdown, arg, subtitlesCommand, shown } = require("./report");
+const { captionsMarkdown, captionsJson, subtitlesMarkdown, arg, subtitlesCommand, shown, captionsOf, lettersOf, boxesText, installText } = require("./report");
 const { jsonShape, jsonProblem, decodeText } = require("./files");
 const { stopAll } = require("./running");
 const version = require("./version");
@@ -823,15 +824,18 @@ function notStill(video, name) {
 
 // The words, cut to the video: words after its end are left out, a word
 // that runs past it is cut there.
-function fitWords(read, duration) {
+function fitWords(read, duration, givenBy = "") {
   const notes = [];
   if (!Number.isFinite(duration)) return { words: read.words, notes };
   const words = read.words.filter((w) => w.start < duration - 0.05).map((w) => ({ ...w, end: Math.min(w.end, duration) }));
   const dropped = read.words.length - words.length;
-  if (dropped) notes.push(`${dropped} ${dropped === 1 ? "word starts" : "words start"} after the video ends (${duration.toFixed(2)} s) and ${dropped === 1 ? "was" : "were"} left out. Check that the words belong to this video.`);
-  if (!words.length) throw new Error(`Every word starts after the video ends (${duration.toFixed(2)} s). The words file belongs to another video, or its times are in another unit`);
+  // `givenBy`: the file that gives the length where no video was given,
+  // which says nothing of whether its own words belong to its video.
+  const end = `${duration.toFixed(2)} s${givenBy ? `, as ${givenBy} gives its length` : ""}`;
+  if (dropped) notes.push(`${dropped} ${dropped === 1 ? "word starts" : "words start"} after the video ends (${end}) and ${dropped === 1 ? "was" : "were"} left out.${givenBy ? "" : " Check that the words belong to this video."}`);
+  if (!words.length) throw new Error(`Every word starts after the video ends (${end}). ${givenBy ? "The times in that file or the length it gives are wrong" : "The words file belongs to another video, or its times are in another unit"}`);
   const last = words[words.length - 1].end;
-  if (last < duration * 0.5 && duration > 20) notes.push(`The words end at ${last.toFixed(1)} s, before half of the video (${duration.toFixed(1)} s). Check that they belong to this video.`);
+  if (!givenBy && last < duration * 0.5 && duration > 20) notes.push(`The words end at ${last.toFixed(1)} s, before half of the video (${duration.toFixed(1)} s). Check that they belong to this video.`);
   return { words, notes };
 }
 
@@ -859,29 +863,25 @@ function specialNote(cues) {
 
 // The letters libass drew boxes for, since this machine has no font it
 // can draw them with, as notes: emoji, which libass draws in no color
-// font, and any other letters. `missing` and `unsure` are assLetters':
-// where nothing says which font an emoji goes in, as on macOS and Windows,
-// the note says it can be a box.
+// font, and any other letters, with what to do. `missing` and `unsure`
+// are assLetters': where nothing says which font an emoji goes in, as on
+// macOS and Windows, the note says it can be a box.
 const EMOJI = /[\p{Extended_Pictographic}\p{Regional_Indicator}]/u;
 function missingNotes(missing, unsure = []) {
-  const where = (items) => {
-    const cues = [...new Set(items.map((m) => m.cue))];
-    return `${cues.length === 1 ? "caption" : "captions"} ${cues.length > 6 ? `${cues.slice(0, 6).join(", ")} and ${cues.length - 6} more` : list(cues.map(String))}`;
-  };
-  const which = (items) => {
-    const letters = [...new Set(items.map((m) => m.letter))];
-    return letters.length > 8 ? `${letters.slice(0, 8).join(" ")} and ${letters.length - 8} more` : letters.join(" ");
-  };
   const boxes = (n) => (n === 1 ? "a box for it" : "boxes for them");
   const emoji = missing.filter((m) => EMOJI.test(m.letter));
   const other = missing.filter((m) => !EMOJI.test(m.letter));
   const notes = [];
-  if (emoji.length) notes.push(`libass draws no color emoji, and this machine has no other font that draws ${emoji.length === 1 ? "the emoji" : `the ${emoji.length} emoji`} in ${where(emoji)} (${which(emoji)}) whole, so the video shows ${boxes(emoji.length)}. Leave out --libass to have Chrome draw ${emoji.length === 1 ? "it" : "them"}.`);
-  if (other.length) notes.push(`No font on this machine that libass can use has ${count(other.length, "letter", "letters")} of ${where(other)} (${which(other)}), so the video shows ${boxes(other.length)}.`);
-  if (unsure.length) notes.push(`libass draws no color emoji, so ${unsure.length === 1 ? "the emoji" : `the ${unsure.length} emoji`} in ${where(unsure)} (${which(unsure)}) can show as ${unsure.length === 1 ? "a box" : "boxes"}: nothing on this machine says which font libass draws ${unsure.length === 1 ? "it" : "them"} with. Leave out --libass to have Chrome draw ${unsure.length === 1 ? "it" : "them"}.`);
+  if (emoji.length) notes.push(`libass draws no color emoji, and this machine has no other font that draws ${emoji.length === 1 ? "the emoji" : `the ${emoji.length} emoji`} in ${captionsOf(emoji)} (${lettersOf(emoji)}) whole, so the video shows ${boxes(emoji.length)}. Leave out --libass to have Chrome draw ${emoji.length === 1 ? "it" : "them"}.`);
+  if (other.length) notes.push(`${boxesText(other, "libass")} ${installText(other)}`);
+  if (unsure.length) notes.push(`libass draws no color emoji, so ${unsure.length === 1 ? "the emoji" : `the ${unsure.length} emoji`} in ${captionsOf(unsure)} (${lettersOf(unsure)}) can show as ${unsure.length === 1 ? "a box" : "boxes"}: nothing on this machine says which font libass draws ${unsure.length === 1 ? "it" : "them"} with. Leave out --libass to have Chrome draw ${unsure.length === 1 ? "it" : "them"}.`);
   return notes;
 }
 
+// The letters Chrome drew as boxes, [{ letter, cue }], as a note: which,
+// and what to do.
+const boxesNotes = (boxes) => (boxes.length ? [`${boxesText(boxes, "chrome")} ${installText(boxes)}`] : []);
+
 // The folder of a fonts.css font's files, which ffmpeg's ass filter finds
 // the font of captions.ass in when it is its fontsdir, from the output
 // folder `dir`, where captions.ass is; else "".
@@ -967,7 +967,7 @@ async function captionVideo(videoFile, options) {
   notes.push(...place.notes);
   const fitted = fitWords(read, video.duration);
   notes.push(...fitted.notes);
-  if (read.video && Math.abs(read.video.duration - video.duration) > 0.5) notes.push(`steps.json is for a video ${read.video.duration.toFixed(1)} s long, and this one is ${video.duration.toFixed(1)} s. The captions follow the steps' times.`);
+  if (read.format === "steps" && read.video && Math.abs(read.video.duration - video.duration) > 0.5) notes.push(`steps.json is for a video ${read.video.duration.toFixed(1)} s long, and this one is ${video.duration.toFixed(1)} s. The captions follow the steps' times.`);
   const words = fitted.words;
   log(`Read ${count(words.length, "word", "words")} from ${shown(path.basename(options.words))} (${read.about})`);
   const cues = buildCues(words, { lines, maxChars, hard: read.hard, duration: video.duration });
@@ -1021,8 +1021,14 @@ async function captionVideo(videoFile, options) {
     // The font captions.ass names, as libass and players that read ASS
     // make it: a font asked for by name is what this machine gives for it.
     const libassFont = look.from === "fonts.css" ? null : machineFont(look.family || "Arial", look.weight);
-    const font = assFont(look, libassFont, { fallback: givenFor(look) });
+    // libass finds a font through fontconfig for each letter its own font
+    // lacks: one no font on this machine has, as fontconfig lists them, is
+    // a box, which needs no asking.
+    const every = useLibass ? machineLetters() : null;
+    const font = assFont(look, libassFont, { fallback: givenFor(look), lacks: every ? (code) => !every(code) : null });
     const letters = assLetters(cues, font);
+    // The letters the video shows as boxes, [{ letter, cue }].
+    let boxes = useLibass ? letters.missing : [];
     // captions.ass names the video's own matrix and range for players; the
     // file libass burns can name others, and give other colors (assColors).
     const assFile = (scales, { level = 1, matrix = color.header, tint = null } = {}) => ass(cues, words, { states, style: options.style, look: { ...look, tool: TOOL }, place, title: titled, level, scales, font, matrix, tint });
@@ -1066,7 +1072,7 @@ async function captionVideo(videoFile, options) {
     } else {
       log(`Drawing ${count(states.length, "caption state", "caption states")} in Chrome`);
       try {
-        drawn = await renderStates({ cues, words, states, style: options.style, look, place, duration: video.duration, dir: run.work, log });
+        drawn = await renderStates({ cues, words, states, style: options.style, look, place, duration: video.duration, dir: run.work, log, boxed: (all, fonts) => chromeBoxes(all, fonts, { kit: kitLetters(look) }) });
       } catch (err) {
         // A Chrome that cannot start here (no usable sandbox, as in a
         // container) stops the run before the encode; libass needs none. A
@@ -1082,6 +1088,8 @@ async function captionVideo(videoFile, options) {
       notes.push(...made.notes);
       sound = made.tracks;
       frameTags = made.frameTags;
+      boxes = boxesIn(cues, drawn.boxes);
+      notes.push(...boxesNotes(boxes));
       if (drawn.failedFonts.length) notes.push(`Chrome could not load the font ${[...new Set(drawn.failedFonts)].join(", ")}; the next font in the list drew the captions.`);
       if (drawn.shrunk) notes.push(`${drawn.shrunk} ${drawn.shrunk === 1 ? `${unit[0]} was` : `${unit[1]} were`} wider than the safe space and drawn smaller to fit, ${drawn.shrunk === 1 ? "at" : "the smallest at"} ${percentOf(drawn.smallest)}% of the size.`);
     }
@@ -1152,6 +1160,7 @@ async function captionVideo(videoFile, options) {
       states: drawn ? drawn.states : states.length,
       fontsDrawn: drawn ? drawn.fonts : [],
       fontFirst: drawn ? drawn.first : "",
+      boxes,
       libassFont: useLibass ? libassFont : null,
       // The name captions.ass gives the font, from its file for fonts.css,
       // and the fonts it sets the letters in that the font lacks.
@@ -1172,7 +1181,7 @@ async function captionVideo(videoFile, options) {
     fs.writeFileSync(path.join(run.work, "CAPTIONS.md"), captionsMarkdown(facts));
     names.push("CAPTIONS.md");
     const files = writtenFiles(run.work, names);
-    fs.writeFileSync(path.join(run.work, "words.json"), JSON.stringify(wordsJson(words, read, files, first), null, 2) + "\n");
+    fs.writeFileSync(path.join(run.work, "words.json"), JSON.stringify(wordsJson(words, read, files, first, video.duration), null, 2) + "\n");
     const json = captionsJson({ ...facts, files: { ...files, ...writtenFiles(run.work, ["words.json"]) } });
     fs.writeFileSync(path.join(run.work, "captions.json"), JSON.stringify(json, null, 2) + "\n");
     names.push("words.json", "captions.json");
@@ -1266,12 +1275,17 @@ function describe(v, rate = null, frames = 0) {
 // firstFormat's), which a run that reads the file again keeps. A word
 // without a time of its own says how it got one: spread over its line by
 // length, or placed between its neighbors, as the file gave it none.
-function wordsJson(words, read, files, first = read.format) {
+// Words of a demo's steps keep `end`, where this run ended the captions:
+// the video's length, or the one steps.json gives without a video. That
+// is `demo`, where a later subtitles run with no video ends them too.
+function wordsJson(words, read, files, first, end) {
   const items = words.map((w) => ({ text: w.text, start: round(w.start), end: round(w.end), ...(w.seg >= 0 ? { seg: w.seg } : {}), ...(w.timed ? {} : w.placed ? { placed: true } : { spread: true }) }));
+  const demo = read.video && Number.isFinite(end) ? end : 0;
   return {
     tool: TOOL,
     from: FORMATS[first] || read.about,
     hard: read.hard,
+    ...(demo > 0 ? { demo: { duration: round(demo) } } : {}),
     // The other files the run wrote, so a folder whose captions.json went
     // is still known as the run's.
     files,
@@ -1323,11 +1337,14 @@ async function makeSubtitles(wordsFile, options) {
   const maxChars = options.maxChars || 42;
   const { place, lines } = cueLayout({ ...options, maxChars }, width, height, places);
   notes.push(...place.notes);
-  const fitted = video ? fitWords(read, video.duration) : { words: read.words, notes: [] };
+  // No caption runs past the video's end: the video's, or with no video
+  // the one steps.json gives the demo's video, as words.json keeps it.
+  const end = video ? video.duration : read.video ? read.video.duration : Infinity;
+  const fitted = fitWords(read, end, video ? "" : shown(path.basename(wordsFile)));
   notes.push(...fitted.notes);
   const words = fitted.words;
   log(`Read ${count(words.length, "word", "words")} from ${shown(path.basename(wordsFile))} (${read.about})`);
-  const shape = { lines: options.style === "word" ? 1 : lines, hard: read.hard, duration: video ? video.duration : Infinity };
+  const shape = { lines: options.style === "word" ? 1 : lines, hard: read.hard, duration: end };
   const cues = buildCues(words, { ...shape, maxChars });
   // Words said after the picture ends, while the sound runs on, are heard.
   if (video && video.soundPast && cues.some((cue) => cue.end > video.picture.end + 0.05)) notes.push(`The video's picture ends at ${video.picture.end.toFixed(2)} s, and its sound runs on to ${video.duration.toFixed(2)} s. The captions go on to the end of the sound, over the last frame, which players hold.`);
@@ -1381,7 +1398,7 @@ async function makeSubtitles(wordsFile, options) {
     };
     fs.writeFileSync(path.join(run.work, "CAPTIONS.md"), subtitlesMarkdown(facts));
     const files = writtenFiles(run.work, ["captions.srt", "captions.vtt", "captions.ass", "CAPTIONS.md"]);
-    fs.writeFileSync(path.join(run.work, "words.json"), JSON.stringify(wordsJson(words, read, files, first), null, 2) + "\n");
+    fs.writeFileSync(path.join(run.work, "words.json"), JSON.stringify(wordsJson(words, read, files, first, end), null, 2) + "\n");
     const json = captionsJson({ ...facts, files: { ...files, ...writtenFiles(run.work, ["words.json"]) } });
     fs.writeFileSync(path.join(run.work, "captions.json"), JSON.stringify(json, null, 2) + "\n");
     await heard();
@@ -1392,4 +1409,4 @@ async function makeSubtitles(wordsFile, options) {
   }
 }
 
-module.exports = { captionVideo, makeSubtitles, slug, notAddresses, writable, guard, recover, begin, finish, abandon, frameFor, encodingLine, percentOf, missingNotes, signalsOf, stopOnSignals, stopped, began, OUTPUTS, TOOL, shown, named };
+module.exports = { captionVideo, makeSubtitles, slug, notAddresses, writable, guard, recover, begin, finish, abandon, frameFor, encodingLine, percentOf, missingNotes, boxesNotes, signalsOf, stopOnSignals, stopped, began, OUTPUTS, TOOL, shown, named };

package/skills/easycaptionkit/scripts/lib/look.js

@@ -568,4 +568,4 @@ function chooseLook(options = {}) {
   };
 }
 
-module.exports = { chooseLook, readBrand, readFontsCss, parseColor, contrast, luminance, highlightMode, brandHighlight, variableFace, machineFont, fallbackFont, sameName, DEFAULT_HIGHLIGHT };
+module.exports = { chooseLook, readBrand, readFontsCss, parseColor, contrast, luminance, highlightMode, brandHighlight, variableFace, machineFont, fallbackFont, fcName, sameName, DEFAULT_HIGHLIGHT };

package/skills/easycaptionkit/scripts/lib/render.js

@@ -13,6 +13,7 @@ const { launch, openPage, evaluate } = require("./chrome");
 const { cueLines } = require("./cues");
 const { inkOf } = require("./places");
 const { writeApng } = require("./apng");
+const { clusters } = require("./text");
 
 // The cue's lines as words, each with whether a space goes before it.
 const lineWords = cueLines;
@@ -198,11 +199,14 @@ function pageHtml(look, place, style, data) {
 
 // Draws every state of the timeline to PNGs in `dir` and puts them in one
 // animated PNG. Returns { file, y, height, reach, states, fonts, first,
-// failedFonts, shrunk, scales }: the band the PNGs cover, the rows the
-// captions reach in it, how many states there are, which fonts drew the
-// letters and which of them is the first of the list this machine has,
-// and how many captions had to be drawn smaller to fit.
-async function renderStates({ cues, words, states, style, look, place, duration, dir, log = () => {} }) {
+// failedFonts, shrunk, scales, boxes }: the band the PNGs cover, the rows
+// the captions reach in it, how many states there are, which fonts drew
+// the letters and which of them is the first of the list this machine
+// has, how many captions had to be drawn smaller to fit, and the letters
+// Chrome drew as boxes. `boxed(letters, fonts)` gives those, of the
+// letters of the captions and the fonts Chrome names for them
+// (chromeBoxes); without it, none are.
+async function renderStates({ cues, words, states, style, look, place, duration, dir, log = () => {}, boxed = null }) {
   const W = place.frame.width;
   const H = place.frame.height;
   const ink = place.ink || inkOf(place.fontPx, { style, box: look.box });
@@ -248,7 +252,13 @@ async function renderStates({ cues, words, states, style, look, place, duration,
       })()`,
       60_000,
     );
-    const fonts = await fontsOf(page, probeText);
+    const named = await fontsOf(page, probeText);
+    // A letter no font Chrome found has is a box, which Chrome says the
+    // first font of the list drew. Those letters are left out when it is
+    // asked again, so the fonts it names drew the letters that show.
+    const boxes = boxed ? boxed([...new Set(probeText.split("\n").flatMap((word) => clusters(word)))], named) : [];
+    const rest = boxes.length ? withoutLetters(probeText, new Set(boxes)) : probeText;
+    const fonts = !boxes.length ? named : rest ? await fontsOf(page, rest) : [];
     // The first font of the list this machine has: the one that draws
     // plain Latin letters. The others draw only what it lacks.
     const latin = await fontsOf(page, "Hamburgefonstiv");
@@ -305,12 +315,21 @@ async function renderStates({ cues, words, states, style, look, place, duration,
     const shrunk = all.filter((s) => s < 1).length;
     // The rows every state stays in, its outline and shadow included.
     const reach = Number.isFinite(fit.top) ? { top: Math.max(0, Math.floor(fit.top)), bottom: Math.min(H, Math.ceil(fit.bottom)) } : null;
-    return { file: animation, y, height, reach, states: made.size + 1, fonts, first: latin.length ? latin[0].family : "", failedFonts: loaded || [], shrunk, smallest: all.reduce((a, b) => Math.min(a, b), 1), scales: fit.scales };
+    return { file: animation, y, height, reach, states: made.size + 1, fonts, first: latin.length ? latin[0].family : "", failedFonts: loaded || [], shrunk, smallest: all.reduce((a, b) => Math.min(a, b), 1), scales: fit.scales, boxes };
   } finally {
     await browser.close();
   }
 }
 
+// The words of the probe, one a line, without the letters of `left`: a
+// word of those letters alone goes.
+const withoutLetters = (text, left) =>
+  text
+    .split("\n")
+    .map((word) => clusters(word).filter((c) => !left.has(c)).join(""))
+    .filter(Boolean)
+    .join("\n");
+
 // Which fonts Chrome draws a text with, and how many letters each. Chrome
 // says so only of text it has laid out, and a text just set is laid out at
 // the next frame: the probe is laid out in the same step its text is set

package/skills/easycaptionkit/scripts/lib/report.js

@@ -19,6 +19,41 @@ const clock = (t) => {
 };
 const list = (items) => (items.length <= 1 ? items.join("") : `${items.slice(0, -1).join(", ")} and ${items[items.length - 1]}`);
 const plural = (n, one, many) => `${n} ${n === 1 ? one : many}`;
+
+// The captions letters are in, of [{ letter, cue }], as a note says them:
+// "caption 3", "captions 1, 2 and 5", or the first six and how many more.
+function captionsOf(items) {
+  const cues = [...new Set(items.map((m) => m.cue))];
+  return `${cues.length === 1 ? "caption" : "captions"} ${cues.length > 6 ? `${cues.slice(0, 6).join(", ")} and ${cues.length - 6} more` : list(cues.map(String))}`;
+}
+
+// The letters themselves, each once: all of them, or the first eight and
+// how many more.
+function lettersOf(items) {
+  const letters = [...new Set(items.map((m) => m.letter))];
+  return letters.length > 8 ? `${letters.slice(0, 8).join(" ")} and ${letters.length - 8} more` : letters.join(" ");
+}
+
+// The letters the video shows as boxes, [{ letter, cue }], as a sentence:
+// Chrome found no font for them, or no font libass can use has them.
+function boxesText(boxes, drawnWith) {
+  const n = boxes.length;
+  if (drawnWith === "libass") return `No font on this machine that libass can use has ${plural(n, "letter", "letters")} of ${captionsOf(boxes)} (${lettersOf(boxes)}), so the video shows ${n === 1 ? "a box for it" : "boxes for them"}.`;
+  return `Chrome found no font on this machine for ${plural(n, "letter", "letters")} of ${captionsOf(boxes)} (${lettersOf(boxes)}), so it drew a box for ${n === 1 ? "it" : "each of them"}.`;
+}
+
+// What to do about letters no font here has: install one that has them,
+// named where one font covers them all, as Noto Sans CJK covers Chinese,
+// Japanese and Korean, or give a font kit whose font has them.
+const CJK = /[\p{Script_Extensions=Han}\p{Script_Extensions=Hiragana}\p{Script_Extensions=Katakana}\p{Script_Extensions=Hangul}\p{Script_Extensions=Bopomofo}　-〿＀-￯]/u;
+const PICTURE = /[\p{Extended_Pictographic}\p{Regional_Indicator}\u20e3]/u;
+function installText(items) {
+  const letters = items.map((m) => m.letter);
+  const them = letters.length === 1 ? "it" : "them";
+  if (letters.every((c) => PICTURE.test(c))) return "Install a color emoji font, such as Noto Color Emoji (fonts-noto-color-emoji on Debian and Ubuntu), and run again.";
+  const font = letters.every((c) => CJK.test(c)) ? "Noto Sans CJK (fonts-noto-cjk on Debian and Ubuntu)" : `a Noto font for ${letters.length === 1 ? "its" : "their"} script`;
+  return `Install a font that has ${them}, such as ${font}, or give --fonts an easyfontkit folder whose font has ${them}, and run again.`;
+}
 // A name on one line of Markdown or of the terminal: its control
 // characters become a space, as a line break in it would end a heading or
 // a list item, or start a line of its own in a message, and an escape
@@ -197,17 +232,24 @@ function fallbackLine(f) {
   const n = fb.reduce((a, b) => a + b.letters, 0);
   const where = `in ${list(fb.map((x) => x.family))}, which fontconfig gives for ${n === 1 ? "it" : "them"}, at the size that makes ${n === 1 ? "it a" : "them"} ${f.layout.fontPx} px ${n === 1 ? "letter" : "letters"} too.`;
   if (setsNone(f)) return `The font has none of the ${plural(n, "letter", "letters")}: captions.ass sets ${n === 1 ? "it" : "them"} ${where}`;
-  return `captions.ass sets the ${plural(n, "letter", "letters")} the font lacks ${where}`;
+  // Where the video shows boxes too, the font lacks more letters than these.
+  return `captions.ass sets ${boxedIn(f) ? "" : "the "}${plural(n, "letter", "letters")} the font lacks ${where}`;
 }
 
 // Whether the font captions.ass names sets any letter of the captions,
-// and whether it sets none and other fonts set them.
+// and whether it sets none and other fonts set them all, with no letter
+// libass showed as a box.
 const setsAny = (f) => !f.assLetters || f.assLetters.own > 0;
-const setsNone = (f) => !setsAny(f) && (f.assFallbacks || []).length > 0;
+const setsNone = (f) => !setsAny(f) && (f.assFallbacks || []).length > 0 && !boxedIn(f);
+
+// Whether the video shows letters as boxes.
+const boxedIn = (f) => (f.boxes || []).length > 0;
 
 // The font the captions were drawn with: none named, the first of the
 // common sans fonts this machine has, which Chrome found for Latin
-// letters, and the fonts that drew the letters it lacks.
+// letters, and the fonts that drew the letters it lacks. The letters the
+// video shows as boxes, which no font drew, are said after the font, and
+// the letters counted after them are the others.
 function fontLines(f) {
   const lines = [];
   const look = f.look;
@@ -217,25 +259,36 @@ function fontLines(f) {
   const m = libass ? f.libassFont || null : null;
   const fill = (fonts) => list(fonts.map((x) => (fonts.length > 1 ? `${x.family} (${x.glyphs})` : x.family)));
   const filled = libass && fallbackLine(f) ? [`  ${fallbackLine(f)}`] : [];
+  const boxed = boxedIn(f) ? [`  ${boxesText(f.boxes, f.drawnWith)}`] : [];
+  const other = boxed.length ? "other " : "";
+  const ofAll = boxed.length ? `of the other ${total}` : `of ${total}`;
+  // The letters the fonts drew as a sentence names them, where one is left
+  // beside the boxes, or is all there is: "the other letter", which "it"
+  // stands for, and never "the other 1 letters".
+  const one = total === 1;
+  const it = one ? "it" : "them";
+  const letters = `the ${other}${one ? "letter" : "letters"}`;
+  const counted = one ? letters : `the ${other}${total} letters`;
+  const lacksThem = (fonts) => `It ${one ? "does not have" : "has none of"} ${counted}, so Chrome drew ${it} with ${fill(fonts)}.`;
   if (!look.family) {
     if (libass) {
-      lines.push(`- Font: Arial ${look.weight}, as captions.ass asks for it by name. ${m && sameName(m.family, "Arial") ? "This machine has it." : givenFor(m)}`, ...filled);
+      lines.push(`- Font: Arial ${look.weight}, as captions.ass asks for it by name. ${m && sameName(m.family, "Arial") ? "This machine has it." : givenFor(m)}`, ...boxed, ...filled);
       return lines;
     }
     // Chrome did not say which font is the first of the list: the fonts
     // that drew, and none named as that one.
     const first = f.fontFirst || "";
     if (!first) {
-      lines.push(`- Font: a common sans ${look.weight}, the first of the common sans fonts easycaptionkit asks for that this machine has.`);
-      if (drawn.length) lines.push(`  Chrome drew the ${total} letters with ${fill(drawn)}.`);
+      lines.push(`- Font: a common sans ${look.weight}, the first of the common sans fonts easycaptionkit asks for that this machine has.`, ...boxed);
+      if (drawn.length) lines.push(`  Chrome drew ${counted} with ${fill(drawn)}.`);
       return lines;
     }
-    lines.push(`- Font: ${first} ${look.weight}, the first of the common sans fonts easycaptionkit asks for that this machine has.`);
+    lines.push(`- Font: ${first} ${look.weight}, the first of the common sans fonts easycaptionkit asks for that this machine has.`, ...boxed);
     const own = drawn.find((x) => x.family === first);
     const others = drawn.filter((x) => x.family !== first);
     if (others.length) {
       const rest = total - (own ? own.glyphs : 0);
-      lines.push(own ? `  Chrome drew ${own.glyphs} of ${total} letters with it, and the ${rest} it lacks with ${fill(others)}.` : `  It has none of the ${total} letters, so Chrome drew them with ${fill(others)}.`);
+      lines.push(own ? `  Chrome drew ${own.glyphs} ${ofAll} letters with it, and the ${rest} it lacks with ${fill(others)}.` : `  ${lacksThem(others)}`);
     }
     lines.push(...lighterLines(look, others));
     return lines;
@@ -246,12 +299,20 @@ function fontLines(f) {
       if (m && sameName(m.family, look.family)) lines.push(`- Font: ${look.family} ${look.weight}, as installed on this machine.`);
       else if (m) lines.push(`- Font: ${look.family} ${look.weight} was asked for by name, and this machine does not have it: ${givenFor(m)} Give easyfontkit's folder with --fonts to burn the real font.`);
       else lines.push(`- Font: ${look.family} ${look.weight}, asked for by name. ${givenFor(m)}`);
-      lines.push(...filled);
+      lines.push(...boxed, ...filled);
+      return lines;
+    }
+    // Not on this machine: Chrome drew the letters with other fonts, or
+    // drew every letter as a box, and its first font is another.
+    const absent = !machineHas(f) && (drawn.length ? !drawn.some((x) => drewWith(x, look)) : boxed.length > 0);
+    if (absent) {
+      if (boxed.length) lines.push(`- Font: ${look.family} ${look.weight} was asked for by name, and this machine does not have it. Give easyfontkit's folder with --fonts to burn the real font.`, ...boxed, ...(drawn.length ? [`  Chrome drew ${letters} with ${fill(drawn)}.`] : []));
+      else lines.push(`- Font: ${look.family} ${look.weight} was asked for by name, and this machine does not have it, so Chrome drew ${letters} with ${fill(drawn)}. Give easyfontkit's folder with --fonts to burn the real font.`);
       return lines;
     }
     if (drawn.length && !drawn.some((x) => drewWith(x, look))) {
-      if (machineHas(f)) lines.push(`- Font: ${look.family} ${look.weight}, as installed on this machine. It has none of the ${total} letters, so Chrome drew them with ${fill(drawn)}.`, ...lighterLines(look, drawn));
-      else lines.push(`- Font: ${look.family} ${look.weight} was asked for by name, and this machine does not have it, so Chrome drew the letters with ${fill(drawn)}. Give easyfontkit's folder with --fonts to burn the real font.`);
+      if (boxed.length) lines.push(`- Font: ${look.family} ${look.weight}, as installed on this machine.`, ...boxed, `  ${lacksThem(drawn)}`, ...lighterLines(look, drawn));
+      else lines.push(`- Font: ${look.family} ${look.weight}, as installed on this machine. ${lacksThem(drawn)}`, ...lighterLines(look, drawn));
       return lines;
     }
     lines.push(`- Font: ${look.family} ${look.weight}, as installed on this machine.`);
@@ -260,18 +321,19 @@ function fontLines(f) {
     lines.push(`- Font: ${look.family}, from ${files}. That file holds the weights ${face.weight[0]} to ${face.weight[1]}, and libass draws such a file at its default weight, not at ${look.weight}, so the letters are thinner than Chrome draws them.`);
   } else lines.push(`- Font: ${look.family} ${look.weight}, from ${files}.`);
   if (f.assFamily && !sameName(f.assFamily, look.family)) lines.push(`  captions.ass names it ${f.assFamily}, the family name in its file, which libass and the players that read ASS find a font by.`);
-  if (libass) lines.push("  libass drew the letters and does not say which font drew each.", ...filled);
+  if (libass) lines.push("  libass drew the letters and does not say which font drew each.", ...boxed, ...filled);
+  else lines.push(...boxed);
   if (!drawn.length) return lines;
   // A font file of fonts.css is the only web font on the page, and Chrome
   // names it by the family in the file, which fonts.css can call
   // otherwise.
   const own = drawn.filter((x) => drewWith(x, look));
   const others = drawn.filter((x) => !drewWith(x, look));
-  if (!own.length) lines.push(`  Chrome drew no letter with the file of ${look.family}: ${drawn[0].family} drew them.`);
-  else if (!others.length) lines.push("  Chrome drew every letter with it.");
+  if (!own.length) lines.push(`  Chrome ${!boxed.length ? "drew no letter" : one ? "did not draw the other letter" : "drew none of the other letters"} with the file of ${look.family}: ${drawn[0].family} drew ${it}.`);
+  else if (!others.length) lines.push(boxed.length ? `  Chrome drew ${one ? "the other letter" : "all the other letters"} with it.` : "  Chrome drew every letter with it.");
   else {
     const mine = own.reduce((a, b) => a + b.glyphs, 0);
-    lines.push(`  Chrome drew ${mine} of ${total} letters with it, and the ${total - mine} it lacks with ${fill(others)}.`);
+    lines.push(`  Chrome drew ${mine} ${ofAll} letters with it, and the ${total - mine} it lacks with ${fill(others)}.`);
   }
   lines.push(...lighterLines(look, others));
   return lines;
@@ -298,10 +360,11 @@ function lighterLines(look, drawn) {
 // The fonts that drew every letter of the captions where the font asked
 // for, by name or from fonts.css, drew none of them, as a Latin font draws
 // no Japanese: the fonts Chrome drew them with, or with libass the fonts
-// captions.ass sets them in. Their names, or [] when the font drew any
-// letter, no font was asked for, or nothing says.
+// captions.ass sets them in. Letters that show as boxes, which no font
+// drew, do not count. Their names, or [] when the font drew any letter, no
+// font was asked for, or nothing says.
 function drewNone(f) {
-  if (f.drawnWith === "libass") return f.look.family && setsNone(f) ? f.assFallbacks.map((x) => x.family) : [];
+  if (f.drawnWith === "libass") return f.look.family && !setsAny(f) && (f.assFallbacks || []).length ? f.assFallbacks.map((x) => x.family) : [];
   const drawn = (f.fontsDrawn || []).filter((x) => x.glyphs > 0);
   if (!f.look.family || !drawn.length || drawn.some((x) => drewWith(x, f.look))) return [];
   return drawn.map((x) => x.family);
@@ -341,7 +404,8 @@ function licenseSection(f) {
   // ones that drew them are, whatever its license.
   const instead = drewNone(f);
   if (instead.length) {
-    const drew = libass ? "captions.ass sets them all in" : "Chrome drew them all with";
+    const which = boxedIn(f) ? "all but the boxes" : "them all";
+    const drew = libass ? `captions.ass sets ${which} in` : `Chrome drew ${which} with`;
     // A font asked for by name that this machine has, or one from fonts.css, lacks the letters.
     const lacks = look.from === "fonts.css" || (libass ? f.libassFont && sameName(f.libassFont.family, look.family) : machineHas(f));
     const lead = read ? `${read}, but no letter of it is in the video` : `No letter of ${look.family} is in the video`;
@@ -601,4 +665,4 @@ function captionsJson(f) {
   };
 }
 
-module.exports = { captionsMarkdown, subtitlesMarkdown, captionsJson, marginsText, drewWith, setsAny, setsNone, machineHas, arg, quote, code, clock, subtitlesCommand, programOf, shown, soundText };
+module.exports = { captionsMarkdown, subtitlesMarkdown, captionsJson, marginsText, drewWith, setsAny, setsNone, boxedIn, machineHas, captionsOf, lettersOf, boxesText, installText, arg, quote, code, clock, subtitlesCommand, programOf, shown, soundText };

package/skills/easycaptionkit/scripts/lib/subtitles.js

@@ -121,12 +121,10 @@ const styleName = (name) => Boolean(name) && !/[\u0000-\u001f\u007f,]/.test(name
 // with. libass sizes each font by its own heights, so captions.ass sets
 // those letters in that font at a size of its own: the font then has
 // `fallback(c)`, the font a letter is set in, { family, scale, advance },
-// or null.
-function assFont(look, machine = null, { fallback = null, budget = BUDGET } = {}) {
-  const upright = (look.faces || []).filter((f) => !f.italic);
-  const faces = upright.length ? upright : look.faces || [];
-  const nearest = faces.length ? Math.min(...faces.map((f) => distance(f, look.weight))) : 0;
-  const files = faces.filter((f) => distance(f, look.weight) === nearest);
+// or null. `lacks(codePoint)` says no font on this machine has a letter,
+// which then needs no asking (boxes.js).
+function assFont(look, machine = null, { fallback = null, budget = BUDGET, lacks = null } = {}) {
+  const files = facesAt(look);
   const kit = files.length ? familyOf(files, budget) : null;
   const first = kit ? kit.first : machine ? readFont(machine.file, machine.index) : null;
   const scale = first ? assScale(first) : 0;
@@ -135,10 +133,31 @@ function assFont(look, machine = null, { fallback = null, budget = BUDGET } = {}
   const has = kit ? kit.has : (c) => Number.isFinite(first.advance(c));
   const own = kit ? kit.family : "";
   const font = { scale, advance, has, from: files.length ? files[0].name || files[0].file : machine.file, family: styleName(own) ? own : "" };
-  if (fallback) font.fallback = fallbacksOf(fallback);
+  if (fallback) font.fallback = fallbacksOf(fallback, lacks);
   return font;
 }
 
+// The faces of a fonts.css family the captions are drawn with, by Chrome
+// and by libass: the upright ones nearest the weight.
+function facesAt(look) {
+  const upright = (look.faces || []).filter((f) => !f.italic);
+  const faces = upright.length ? upright : look.faces || [];
+  const nearest = faces.length ? Math.min(...faces.map((f) => distance(f, look.weight))) : 0;
+  return faces.filter((f) => distance(f, look.weight) === nearest);
+}
+
+// Whether the files of a fonts.css family the captions are drawn with
+// have a letter, one code point: has(c), or null for a look with no
+// files. A letter is taken to be there when a file that could hold it
+// was not read, as one past what is read of a family: only a letter
+// they are known to lack is not.
+function kitLetters(look, budget = BUDGET) {
+  const files = facesAt(look);
+  if (!files.length) return null;
+  const kit = familyOf(files, budget);
+  return (c) => kit.has(c) || kit.unread(c);
+}
+
 // What is read of a fonts.css family's files in all, at most, counting
 // what WOFF and WOFF2 files unpack to: a site splits a CJK family into a
 // hundred files and more, each small, and a file of a few hundred bytes
@@ -159,10 +178,11 @@ function rangesOf(text) {
 // The files of a fonts.css family at one weight, each read once a letter
 // in its unicode-range is asked for, as Chrome loads them, and no more than
 // `budget` bytes of them in all, files and what they unpack to. { first,
-// family, advance, has }: the first file that reads, which gives the size,
-// and the family name in it or in the next file that has one. A letter in
-// the range of a file that was not read, or is no font this kit reads, is
-// the family's still: libass finds that file by its name.
+// family, advance, has, unread }: the first file that reads, which gives
+// the size, and the family name in it or in the next file that has one.
+// A letter in the range of a file that was not read, or is no font this
+// kit reads, is the family's still: libass finds that file by its name.
+// unread(c) says a file that could hold the letter was not read.
 function familyOf(faces, budget) {
   const list = faces.map((face) => ({ face, ranges: rangesOf(face.unicodeRange), font: undefined }));
   let left = budget;
@@ -179,16 +199,17 @@ function familyOf(faces, budget) {
   const lookUp = (c) => {
     const code = c.codePointAt(0);
     if (known.has(code)) return known.get(code);
-    let found = { advance: NaN, has: false };
+    let found = { advance: NaN, has: false, unread: false };
     for (const item of list) {
       if (!inRange(item, code)) continue;
       const font = fontOf(item);
       const w = font ? font.advance(c) : NaN;
       if (Number.isFinite(w)) {
-        found = { advance: w, has: true };
+        found = { advance: w, has: true, unread: false };
         break;
       }
       if (!font && item.ranges) found.has = true;
+      if (!font) found.unread = true;
     }
     known.set(code, found);
     return found;
@@ -201,7 +222,7 @@ function familyOf(faces, budget) {
     if (font && font.family) family = font.family;
     if (first && family) break;
   }
-  return { first, family, advance: (c) => lookUp(c).advance, has: (c) => lookUp(c).has };
+  return { first, family, advance: (c) => lookUp(c).advance, has: (c) => lookUp(c).has, unread: (c) => lookUp(c).unread };
 }
 
 // A name an override tag can carry: it ends at a backslash or a brace.
@@ -222,13 +243,17 @@ const NONE = Object.freeze({ none: true });
 // that has them all. libass draws no font of pictures alone, as a color
 // emoji font is, and fontconfig gives a font that lacks a letter only
 // when no font has it: `none(c)` says fontconfig gives no font libass can
-// draw the letter with, so libass draws a box for it.
-function fallbacksOf(give) {
+// draw the letter with, so libass draws a box for it. A letter `lacks`
+// says no font on this machine has is one too, without asking, and asks
+// none of the 64: so every such letter is counted, however many there
+// are, as in Japanese on a machine with no Japanese font.
+function fallbacksOf(give, lacks = null) {
   const found = [];
   const asked = new Map();
   const fontFor = (first, arabic) => {
     const code = first.codePointAt(0);
     if (asked.has(code)) return asked.get(code);
+    if (lacks && lacks(code)) return NONE;
     if (asked.size >= 64) return null;
     const given = give(code);
     let got = null;
@@ -450,6 +475,10 @@ function ass(cues, words, { states, style, look, place, title = "", level = 1, s
 // default, one asked for so, or a flag. A © or a ™ is a letter.
 const SHOWN_AS_EMOJI = /\p{Emoji_Presentation}|\ufe0f|\p{Regional_Indicator}/u;
 
+// A no-break hyphen no font here has is no box where the font has the
+// plain hyphen: HarfBuzz, which libass shapes with, draws that for it.
+const hyphenFor = (c, font) => c === "\u2011" && font.has("\u2010");
+
 // How captions.ass sets the letters of the captions, the spaces left out:
 // { total, own, fallbacks, missing, unsure }. own is how many are in the
 // font it names, or where nothing says otherwise; fallbacks the fonts it
@@ -471,7 +500,7 @@ function assLetters(cues, font) {
         const lacks = !font.has(Array.from(c)[0]);
         const other = setIn(c, font, null);
         if (other) counts.set(other.family, (counts.get(other.family) || 0) + 1);
-        else if (font.fallback && lacks && font.fallback.none(c)) missing.push({ letter: c, cue: cue.n });
+        else if (font.fallback && lacks && font.fallback.none(c) && !hyphenFor(c, font)) missing.push({ letter: c, cue: cue.n });
         else {
           own++;
           if (lacks && SHOWN_AS_EMOJI.test(c)) unsure.push({ letter: c, cue: cue.n });
@@ -486,4 +515,4 @@ function assLetters(cues, font) {
 // names, by that font: [{ family, letters }].
 const fallbackLetters = (cues, font) => assLetters(cues, font).fallbacks;
 
-module.exports = { srt, vtt, ass, assFont, estimatedScales, shrunkOf, assLetters, fallbackLetters, clock, assClock, assColor, assTag, dimmed, escapeSrt, SRT_SPECIAL, ARIAL };
+module.exports = { srt, vtt, ass, assFont, kitLetters, estimatedScales, shrunkOf, assLetters, fallbackLetters, clock, assClock, assColor, assTag, dimmed, escapeSrt, SRT_SPECIAL, ARIAL };

package/skills/easycaptionkit/scripts/lib/version.js

@@ -2,4 +2,4 @@
 
 // Kept here, not read from package.json: a skill install copies this folder
 // alone.
-module.exports = "0.1.0";
+module.exports = "0.1.2";

package/skills/easycaptionkit/scripts/lib/words.js

@@ -645,7 +645,12 @@ function detectJson(data) {
       // `from`: a demo's steps stay steps when their words.json is read
       // again, in its own folder or in another.
       const first = Object.keys(FORMATS).find((key) => key !== "easycaptionkit" && FORMATS[key] === data.from);
-      return shape({ format: "easycaptionkit", words, hard: Boolean(data.hard), fixed: handFixed(data), ...(first ? { first } : {}) }, data.words);
+      // The length steps.json gave the demo's video, which words.json
+      // keeps, so a subtitles run with no video ends the captions there
+      // again, as the run from steps.json did.
+      const length = entry(data.demo) ? numberOf(data.demo.duration) : NaN;
+      const demo = Number.isFinite(length) && length > 0 ? { duration: length, file: "" } : null;
+      return shape({ format: "easycaptionkit", words, hard: Boolean(data.hard), fixed: handFixed(data), ...(first ? { first } : {}), ...(demo ? { video: demo } : {}) }, data.words);
     }
     if (data.kind === "demo" && Array.isArray(data.steps)) return shape({ format: "steps", ...readSteps(data, listed(data.steps, read)) }, data.steps);
     if (Array.isArray(data.transcription)) return shape({ format: "whispercpp", words: readWhisperCpp(listed(data.transcription, read), read) }, data.transcription);
@@ -1083,6 +1088,8 @@ function readWords(file, given = null) {
     // words.json a run writes from them keeps saying.
     fixed: Boolean(found.fixed),
     notes,
+    // The demo's video as steps.json gives it, { duration, file }, also
+    // from a words.json made of steps, which keeps its length.
     video: found.video || null,
   };
 }