easycaptionkit 0.1.1 → 0.1.3

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.
@@ -37,6 +37,17 @@ easycaptionkit-demo/
 - The captions run as long as the video's sound where the sound runs on past its picture, in the subtitle files too, and as long as its frames where it states no length, as a WebM a browser recorded does. A file whose frames and sound all end well before the length it states, as an interrupted download leaves it, is captioned as far as its frames go, and CAPTIONS.md says so.
 - CAPTIONS.md carries the license facts easyfontkit read for the font that was burned in, and the closest free font when it is not open. Whether to use it is your call. When the font has none of the letters, as a Latin font has no Japanese, CAPTIONS.md says that no letter of it is in the video and names the fonts of the machine that drew them.
 
+## Requirements
+
+- Node.js 22 or newer.
+- ffmpeg and ffprobe 4.4 or newer, Ubuntu 22.04's 4.4.2 included. To burn the captions, ffmpeg needs an H.264 encoder: libx264, the one every test has used, or VideoToolbox, OpenH264 or Media Foundation, which no test has run with. `--libass` needs it built with libass as well, which Homebrew's default ffmpeg is not; `subtitles` needs neither, and with `--video` it uses ffprobe alone. Apart from libass's ass filter, the filters it uses are ffmpeg's own, and so is the AAC encoder. `brew install ffmpeg` and `winget install ffmpeg` give a new enough one, and so does `sudo apt install ffmpeg` on Ubuntu 22.04, Debian 12 or newer. Set `FFMPEG_PATH` to use another build, as a path or a name on your PATH, and `FFPROBE_PATH` for an ffprobe that is not next to ffmpeg or on your PATH. Before any work, a run checks that ffmpeg and ffprobe start and answer as ffmpeg and ffprobe, ffprobe alone in `subtitles --video`; one that does not stops the run with what the system or the program said, and how to get one. When the system is short of open files, processes or memory to start one, the run says so and what to do. Then, before it draws anything, a run that burns captions checks ffmpeg's version number, its H.264 encoder and, for `--libass`, libass, and says what is missing; an ffmpeg that fails or is stopped when asked for its encoders or its filters stops the run with how it ended. An ffmpeg or ffprobe that gives no answer in two minutes when asked, as on a machine short of memory, stops the run too, and the message says to run it again. It checks no version number of ffprobe's.
+- Google Chrome or Chromium, which draws the captions; `subtitles` starts none. Chrome runs in its sandbox unless easycaptionkit runs as root, where the sandbox does not start: on Linux, Google Chrome's own package sets the sandbox up, and a container has to let it start, as Docker does with `--security-opt seccomp=unconfined`. It has been tested with Google Chrome only: 155 on Ubuntu 26.04, 157 on Ubuntu 22.04 and the ones GitHub's ubuntu-22.04, ubuntu-24.04 and ubuntu-latest runners come with. No test has run with Chromium, or with Edge or Brave, which easycaptionkit also takes. It looks for all four on your PATH and where macOS installs them; on Windows it looks only where Chrome and Edge install themselves. Set `CHROME_PATH` to use another build, as a path or a name on your PATH. Before any work, a run that draws with Chrome checks that it starts and gives a version number when asked with `--version`, except on Windows, where Chrome prints none, and one that does not stops the run in the same way. With `--libass` ffmpeg draws the captions instead, and a run with no browser, or with one that does not start or gives no version number, makes plainer sheet.png and safe-zones.png.
+- A font that has the letters of your captions, on the machine or in `--fonts`. A letter no font has is drawn as a box, as Japanese is on a server with no Japanese font; `fonts-noto-cjk` gives Debian and Ubuntu one.
+- Linux, where it is tested: on Ubuntu 22.04 with its ffmpeg 4.4.2, on Ubuntu 24.04 with its ffmpeg 6.1 and on GitHub's ubuntu-latest runner, on every push and before every release. This release has also run on Ubuntu 26.04 with ffmpeg 8.0. It is written for macOS and Windows as well, but it has not been run on either.
+- Room on the disk for the files of a run and those of the run before it, as the earlier files stay until the new ones are in place. captioned.mp4 is a new encode of the whole video and can come out larger than the video given. Until a run ends, it also keeps the pictures Chrome drew of the captions, a PNG of each state and an animated PNG of them all, in its hidden folder in the out folder. In the karaoke style, at the default letter size and two lines, they take about 75 KB a word on a 1080x1920 video, 150 KB on a 1920x1080 one and 360 KB on a 3840x2160 one, some 1.5 GB for an hour of speech at 1920x1080. With the largest letters and the most lines the options allow, `--size 20` and `--lines 3`, they take about twice as much, and in the line and word styles and with `--box` less. Each Chrome that easycaptionkit starts keeps a profile of 3 to 7 MB in the temp folder.
+- Memory for ffmpeg's encode, more for a video of more pixels, more again for an HDR one, which stays in 10 bits, and on a machine with more cores. For a 1920x1080 or 1080x1920 video, ffmpeg took about 0.6 GB on 2 cores and 1.5 GB on 24, as much for ten minutes of video as for 30 seconds, and 1 GB and 2.4 GB for one in HDR. For a 3840x2160 video it took about 2 GB on 2 cores and 5 GB on 24, and 3.6 GB and 8.6 GB for one in HDR. The cores are the ones ffmpeg may run on, and a CPU quota does not lower their count: in a systemd scope held to 2 CPUs by CPUQuota=200% on a 24 core machine, where `nproc` said 2, the encode of a 1920x1080 video took as much as on all 24 cores, and 0.6 GB once `taskset` held it to 2 cores. A container held to 2 CPUs by `docker run --cpus=2` or by a Kubernetes CPU limit is held by such a quota, while `docker run --cpuset-cpus` holds it to cores, as taskset does. Chrome takes about 0.3 GB while it draws, before the encode and after it, and Node.js about 0.1 GB.
+- A run needs no network access and no API key: easycaptionkit reads files on your disk, the browser runs offline with the font files there, and nothing leaves your machine. Installing it needs the network, and `npx easycaptionkit@latest` asks npm for the newest version each time it runs. There are no npm dependencies, and `subtitles` without `--video` needs Node.js alone.
+
 ## Use it with your agent
 
 easycaptionkit ships as an [Agent Skill](https://agentskills.io). Install it once and your agent runs it by itself when a video needs captions:
@@ -96,7 +107,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.
 
@@ -111,8 +122,6 @@ npx easycaptionkit@latest subtitles transcript.json --video film.mp4
 
 Installed globally (`npm install -g easycaptionkit`), the command is `easycaptionkit`. npx keeps the copy an earlier run fetched, so `npx easycaptionkit@latest` is how you get a newer version.
 
-It needs Node 22 or newer, ffmpeg 4.4 or newer and Chrome, Chromium, Edge or Brave. `brew install ffmpeg` and `winget install ffmpeg` give a new enough ffmpeg, and so does `sudo apt install ffmpeg` on Ubuntu 22.04, Debian 12 or newer; the tests run on Ubuntu 22.04's ffmpeg 4.4 and on the latest Ubuntu's, before every release too. Set `FFMPEG_PATH` and `CHROME_PATH` to pick them, as a path or a name on your PATH, and `FFPROBE_PATH` for an ffprobe that is not next to ffmpeg or on your PATH. There are no npm dependencies, and nothing leaves your machine: the browser runs offline with the font files on your disk.
-
 ## Where the words come from
 
 `--words` takes the words with their times from any of these, told apart by what is in the file, saved as UTF-8 or UTF-16:
@@ -147,7 +156,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.1",
+  "version": "0.1.3",
   "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,8 +50,13 @@ 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).
+- "easycaptionkit needs ffmpeg", "easycaptionkit needs ffprobe" or "easycaptionkit needs Chrome": the run stopped before any work, as it found none, or the one it found or the variable names could not be started, did not answer as one when asked its version or, for ffmpeg, failed when asked its encoders or its filters. The message names that file, by `FFMPEG_PATH`, `FFPROBE_PATH`, `CHROME_PATH` or PATH, and gives what is at its path, as a folder, or what the system said, or the first line the program printed and how it ended: tell the user, and ask them to install the program or to point the variable at one that runs, and never guess a path. Where it is Chrome, `--libass` draws the captions without it.
+- "easycaptionkit could not start ffmpeg:", or ffprobe or Chrome, and what the system is short of: the system could not start a program then, as when too many files are open, and the message says what to do, such as raising the limit on open files or running it again once fewer processes run. The program is not at fault, so do not ask the user to install another.
+- "easycaptionkit could not start ffmpeg, <its path>, again", or ffprobe or Chrome: the program answered when the run began, and the system could not start it later in the run, as when it was taken away or changed in the meantime. Tell the user what the system said, and run again: a program that is still wrong then stops the run before any work, with what is wrong with it.
+- "easycaptionkit could not check ffmpeg", or ffprobe or Chrome: the program gave no answer in two minutes when asked its version or, for ffmpeg, its encoders or its filters, as on a machine short of memory. Run again, and if it gives no answer again, tell the user, with the path the message names.
 - "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.
 - The safe zones are the apps' ad guides or estimates, each with its source and date. Tell the user to check one post on a phone.

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,15 +12,16 @@ 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");
 const ffmpeg = require("./ffmpeg");
-const { findChrome, missingChrome, chromeNamedNothing, tempProblem } = require("./chrome");
+const { chromeReady, chromeProblem, 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 "".
@@ -945,15 +945,22 @@ async function captionVideo(videoFile, options) {
   writable(dir);
   const notes = recover(path.resolve(dir), dir);
   const view = guard(dir, { video: videoFile, timeline: timelineOf(videoFile), words: options.words, brand: options.brand, fonts: options.fonts });
-  const bins = ffmpeg.tools();
   const useLibass = Boolean(options.libass);
-  if (!useLibass && !findChrome()) throw new Error(missingChrome());
   // Chrome keeps its profile in the temporary folder.
   const temp = useLibass ? "" : tempProblem();
   if (temp) throw new Error(`${temp}. Set it to a folder, or unset it`);
-  const [video, caps] = await Promise.all([ffmpeg.readVideo(videoFile, bins), ffmpeg.capabilities(bins)]);
+  // Each program the run uses is asked its version before the video is
+  // read, Chrome while ffmpeg is: one that cannot be started or does not
+  // answer as itself stops the run with what the system or the program
+  // said, ffmpeg's first.
+  const chrome = useLibass ? null : chromeReady();
+  if (chrome) chrome.catch(() => {});
+  const tools = await ffmpeg.ready();
+  if (chrome) await chrome;
+  const bins = { ffmpeg: tools.ffmpeg, ffprobe: tools.ffprobe, places: tools.places };
+  const [video, caps] = await Promise.all([ffmpeg.readVideo(videoFile, bins), ffmpeg.capabilities(bins, tools.version)]);
   notStill(video, videoFile);
-  if (!caps.encoder) throw new Error("This ffmpeg has no H.264 encoder (libx264, VideoToolbox or OpenH264), so it cannot write the captioned MP4");
+  if (!caps.encoder) throw new Error("This ffmpeg has no H.264 encoder (libx264, VideoToolbox, OpenH264 or Media Foundation), so it cannot write the captioned MP4");
   if (useLibass && !caps.libass) throw new Error("This ffmpeg has no libass (its ass filter), so --libass cannot draw the captions. Leave out --libass to draw them with Chrome, or install an ffmpeg built with libass");
   if (!useLibass && !caps.overlay) throw new Error("This ffmpeg has no overlay filter, so it cannot lay the captions over the video");
   const read = await loadWords(options.words);
@@ -967,7 +974,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 +1028,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,14 +1079,16 @@ 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
         // Chrome the system stopped as memory ran out can draw with fewer
-        // jobs at once, or a smaller video.
-        if (err.chrome && err.signal === "SIGKILL") err.message += ". Run again with fewer jobs at once or with a smaller video, or pass --libass to have ffmpeg draw the captions without Chrome";
-        else if (err.chrome && err.start) err.message += ". Pass --libass to have ffmpeg draw the captions without Chrome";
+        // jobs at once, or a smaller video. A message that ends with a full
+        // stop, as one of what to do does, keeps only that one.
+        const said = err.message.replace(/\.$/, "");
+        if (err.chrome && err.signal === "SIGKILL") err.message = `${said}. Run again with fewer jobs at once or with a smaller video, or pass --libass to have ffmpeg draw the captions without Chrome`;
+        else if (err.chrome && err.start) err.message = `${said}. Pass --libass to have ffmpeg draw the captions without Chrome`;
         throw err;
       }
       fs.writeFileSync(path.join(run.work, "captions.ass"), assFile(drawn.scales));
@@ -1082,6 +1097,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.`);
     }
@@ -1118,8 +1135,10 @@ async function captionVideo(videoFile, options) {
     const sheetFile = path.join(run.work, "sheet.png");
     // Chrome lays the pictures out. Where there is none, or it cannot start
     // or stops, ffmpeg makes plainer ones: the captions are in the video
-    // by now, and the pictures only show them.
-    let plain = findChrome() ? tempProblem() : chromeNamedNothing() || "no Chrome was found";
+    // by now, and the pictures only show them. A run that drew them with
+    // libass asks Chrome its version here, which a run that drew them with
+    // Chrome did before any work, with the temporary folder.
+    let plain = useLibass ? (await chromeProblem()) || tempProblem() : "";
     if (!plain) {
       try {
         await safeZonesPng({ bins, video, output: out, zones: place.zones, cue: widest, times, file: zonesFile, dir: run.work, frameTags });
@@ -1152,6 +1171,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 +1192,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 +1286,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,
@@ -1307,6 +1332,9 @@ async function makeSubtitles(wordsFile, options) {
   writable(dir);
   const notes = recover(path.resolve(dir), dir);
   const view = guard(dir, { words: wordsFile, video: options.video, brand: options.brand, fonts: options.fonts }, { subtitles: true, options });
+  // The video is read with ffprobe alone, which is asked its version first;
+  // no ffmpeg is started, so nothing at ffmpeg's path stops the run.
+  const bins = options.video ? await ffmpeg.readyProbe() : null;
   const read = await loadWords(wordsFile);
   const first = firstFormat(read, origin);
   const look = chooseLook({ ...options, ...scriptsOf(read.words) });
@@ -1314,7 +1342,7 @@ async function makeSubtitles(wordsFile, options) {
   notes.push(...read.notes, ...look.notes);
   let video = null;
   if (options.video) {
-    video = await ffmpeg.readVideo(options.video, ffmpeg.tools());
+    video = await ffmpeg.readVideo(options.video, bins);
     notStill(video, options.video);
     notes.push(...video.notes);
   }
@@ -1323,11 +1351,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 +1412,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 +1423,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 };