easycaptionkit 0.1.1 → 0.1.3

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.1";
+module.exports = "0.1.3";

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,
   };
 }