easycaptionkit 0.1.1 → 0.1.3

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

@@ -12,49 +12,86 @@ const fs = require("node:fs");
 const os = require("node:os");
 const path = require("node:path");
 const { spawn, spawnSync } = require("node:child_process");
-const { onPath, given, namedNothing } = require("./ffmpeg");
+const programs = require("./programs");
 const { track, trackFolder, untrackFolder, kill, sleep } = require("./running");
 
-// A Chrome named in the environment is found as FFMPEG_PATH is: a bare
-// name on PATH, a path from the folder the run starts in.
-function findChrome() {
-  const named = process.env.CHROME_PATH;
-  if (named) return given(named);
-  const mac = [
-    "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
-    "/Applications/Chromium.app/Contents/MacOS/Chromium",
-    "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge",
-    "/Applications/Brave Browser.app/Contents/MacOS/Brave Browser",
-    path.join(os.homedir(), "Applications/Google Chrome.app/Contents/MacOS/Google Chrome"),
-  ];
-  const win = [
-    path.join(process.env.PROGRAMFILES || "C:\\Program Files", "Google\\Chrome\\Application\\chrome.exe"),
-    path.join(process.env["PROGRAMFILES(X86)"] || "C:\\Program Files (x86)", "Google\\Chrome\\Application\\chrome.exe"),
-    path.join(process.env.LOCALAPPDATA || "", "Google\\Chrome\\Application\\chrome.exe"),
-    path.join(process.env["PROGRAMFILES(X86)"] || "C:\\Program Files (x86)", "Microsoft\\Edge\\Application\\msedge.exe"),
-  ];
-  const listed = process.platform === "darwin" ? mac : process.platform === "win32" ? win : [];
-  for (const file of listed) if (file && fs.existsSync(file)) return file;
-  for (const name of ["google-chrome", "google-chrome-stable", "chromium", "chromium-browser", "chrome", "microsoft-edge", "brave-browser"]) {
-    const found = onPath(name);
-    if (found) return found;
-  }
-  return "";
-}
+const LIBASS = "--libass has ffmpeg draw the captions without Chrome.";
 
-const MISSING = "No Chrome was found to draw the captions with. Install Google Chrome or Chromium, set CHROME_PATH to it, or pass --libass to have ffmpeg draw them.";
+// Chrome as a run looks for it and asks it its version (see
+// programs.find()): the path CHROME_PATH gives, or a name on PATH, as
+// FFMPEG_PATH is read; else where macOS and Windows install it, and on
+// PATH by each of its names. It answers with a version number, as "Google
+// Chrome 155.0.8059.84". On Windows, where Chrome prints no version, it is
+// not asked, and taken once nothing keeps it from running.
+const CHROME = {
+  name: "Chrome",
+  variable: "CHROME_PATH",
+  args: ["--version"],
+  answers: (stdout) => /\d+\.\d+/.test(stdout),
+  names: ["google-chrome", "google-chrome-stable", "chromium", "chromium-browser", "chrome", "microsoft-edge", "brave-browser"],
+  first: () => {
+    const mac = [
+      "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+      "/Applications/Chromium.app/Contents/MacOS/Chromium",
+      "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge",
+      "/Applications/Brave Browser.app/Contents/MacOS/Brave Browser",
+      path.join(os.homedir(), "Applications/Google Chrome.app/Contents/MacOS/Google Chrome"),
+    ];
+    const win = [
+      path.join(process.env.PROGRAMFILES || "C:\\Program Files", "Google\\Chrome\\Application\\chrome.exe"),
+      path.join(process.env["PROGRAMFILES(X86)"] || "C:\\Program Files (x86)", "Google\\Chrome\\Application\\chrome.exe"),
+      path.join(process.env.LOCALAPPDATA || "", "Google\\Chrome\\Application\\chrome.exe"),
+      path.join(process.env["PROGRAMFILES(X86)"] || "C:\\Program Files (x86)", "Microsoft\\Edge\\Application\\msedge.exe"),
+    ];
+    const listed = process.platform === "darwin" ? mac : process.platform === "win32" ? win : [];
+    return listed.filter(Boolean).map((file) => ({ file, name: "Chrome", where: "installed on this machine" }));
+  },
+  ask: process.platform !== "win32",
+  none: `easycaptionkit needs Chrome to draw the captions, and none was found. Install Google Chrome or Chromium, or set CHROME_PATH to one. ${LIBASS}`,
+  advice: {
+    variable: `Set CHROME_PATH to a Chrome that runs, or unset it and install Google Chrome or Chromium. ${LIBASS}`,
+    found: `Install Google Chrome or Chromium, or set CHROME_PATH to a Chrome that runs. ${LIBASS}`,
+    late: `Run easycaptionkit again. ${LIBASS}`,
+  },
+};
 
-// The variable that names this run's Chrome, when it names no program:
-// what it names, as a sentence without its end. Empty otherwise.
-function chromeNamedNothing() {
-  return namedNothing("CHROME_PATH");
+// The Chrome a run would take, by what is at its place alone, not run, or
+// "" where there is none.
+const findChrome = () => programs.locate(CHROME);
+
+// The Chrome that answered, for the CHROME_PATH, the PATH and the folder
+// the run works with now: a run asks it once, and every Chrome it starts
+// to draw is that one. A failure is not kept, so a later call asks again.
+let checked = null;
+
+// The Chrome a run draws with, found and asked its version before any work,
+// so one that cannot be started or does not answer as Chrome stops the run
+// with what the system or the program said, not once it begins to draw.
+async function chromeReady(limit = programs.LIMIT) {
+  let here = "";
+  try {
+    here = process.cwd();
+  } catch {
+    // A folder taken away since: only PATH's relative entries read from it.
+  }
+  const key = JSON.stringify([process.env.CHROME_PATH, process.env.PATH, here]);
+  if (checked && checked.key === key) return checked.file;
+  const { file } = await programs.find(CHROME, limit);
+  checked = { key, file };
+  return file;
 }
 
-// Why there is no Chrome: what the variable names, or that none is on the
-// machine.
-function missingChrome() {
-  const nothing = chromeNamedNothing();
-  return nothing ? `${nothing}. Set it to the path of Chrome or Chromium, or pass --libass to have ffmpeg draw the captions.` : MISSING;
+// For a run that draws without Chrome and uses it for its pictures alone:
+// why there is no Chrome to use, as words that follow "since", or "" when
+// it answers.
+async function chromeProblem() {
+  try {
+    await chromeReady();
+    return "";
+  } catch (err) {
+    if (!err.unusable) throw err;
+    return err.why;
+  }
 }
 
 // An error of Chrome's own, not of a file or of ffmpeg: `start` when Chrome
@@ -225,9 +262,17 @@ function whyStopped(stderr, temp) {
   return text;
 }
 
+// Starts the Chrome a run checked before any work (see chromeReady()),
+// asking it first where it was not. A start the system refuses says what
+// the system said, never its code alone.
 async function launch({ width = 1920, height = 1080 } = {}) {
-  const chrome = findChrome();
-  if (!chrome) throw failed(missingChrome(), { start: true });
+  let chrome;
+  try {
+    chrome = await chromeReady();
+  } catch (err) {
+    throw failed(err.message, { start: true });
+  }
+  const refused = (err) => failed(programs.startFailure(chrome, err, "Chrome").message, { start: true });
   const temp = chromeTemp();
   clearOldProfiles();
   // A profile Chrome cannot have is a Chrome that cannot start.
@@ -271,13 +316,20 @@ async function launch({ width = 1920, height = 1080 } = {}) {
     child = track(spawn(chrome, args, { stdio: ["ignore", "ignore", "pipe", "pipe", "pipe"], env: { ...process.env, TMPDIR: temp, CHROME_CONFIG_HOME: path.join(profile, "config") } }), stop);
   } catch (err) {
     drop();
-    throw failed(`Chrome could not start: ${err.message}`, { start: true });
+    throw refused(err);
   }
   // Settles when Chrome is gone, whether it exited or never started.
   const gone = new Promise((resolve) => {
     child.once("exit", resolve);
     child.once("error", resolve);
   });
+  // With no file descriptor left for them Node makes no pipes, and says
+  // why a moment later.
+  if (!child.stdio || !child.stderr || !child.stdio[3] || !child.stdio[4]) {
+    const err = await new Promise((resolve) => child.once("error", resolve));
+    drop();
+    throw refused(err);
+  }
   let stderr = "";
   child.stderr.on("data", (d) => (stderr = (stderr + d).slice(-8000)));
   const told = new Promise((resolve) => child.stderr.once("close", resolve));
@@ -312,7 +364,7 @@ async function launch({ width = 1920, height = 1080 } = {}) {
     fall(dead);
   });
   child.on("error", (err) => {
-    dead = failed(`Chrome could not start: ${err.message}`, { start: true });
+    dead = refused(err);
     for (const waiting of pending.values()) waiting.reject(dead);
     pending.clear();
     fall(dead);
@@ -421,4 +473,4 @@ async function openPage(browser, file, { width, height, transparent = false }) {
   return page;
 }
 
-module.exports = { findChrome, missingChrome, chromeNamedNothing, tempProblem, launch, evaluate, openPage, whyStopped, chromeTemp, clearOldProfiles, MISSING };
+module.exports = { CHROME, findChrome, chromeReady, chromeProblem, tempProblem, launch, evaluate, openPage, whyStopped, chromeTemp, clearOldProfiles };

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

@@ -8,82 +8,69 @@ const fs = require("node:fs");
 const path = require("node:path");
 const { spawn } = require("node:child_process");
 const { track } = require("./running");
+const programs = require("./programs");
+
+const { exe } = programs;
 
 // Where package managers put it, for an agent or app whose PATH is short.
 const KNOWN = ["/opt/homebrew/bin", "/usr/local/bin", "/usr/bin", "/snap/bin"];
 
-// The first program by a name on PATH, in a folder `skip` does not pass
-// over.
-function onPath(name, { skip = () => false } = {}) {
-  for (const dir of String(process.env.PATH || "").split(path.delimiter)) {
-    if (!dir || skip(dir)) continue;
-    const file = path.join(dir, name);
-    try {
-      fs.accessSync(file, fs.constants.X_OK);
-      if (fs.statSync(file).isFile()) return file;
-    } catch {
-      // Not here.
-    }
-  }
-  return "";
-}
-
-const exe = (name) => (process.platform === "win32" ? `${name}.exe` : name);
+const INSTALL = "brew install ffmpeg, sudo apt install ffmpeg or winget install ffmpeg";
 
-const bare = (value) => !(value.includes("/") || (process.platform === "win32" && value.includes("\\")));
-const isFile = (file) => {
-  try {
-    return fs.statSync(file).isFile();
-  } catch {
-    return false;
-  }
+// ffmpeg as a run looks for it and asks it its version (see programs.find()).
+const FFMPEG = {
+  name: "ffmpeg",
+  variable: "FFMPEG_PATH",
+  args: ["-version"],
+  answers: (stdout) => /^ffmpeg version\b/m.test(stdout),
+  names: [exe("ffmpeg")],
+  known: KNOWN,
+  none: `easycaptionkit needs ffmpeg, and none was found. Install it (${INSTALL}) or set FFMPEG_PATH to one.`,
+  advice: {
+    variable: `Set FFMPEG_PATH to an ffmpeg that runs, or unset it and install one (${INSTALL}).`,
+    found: `Install ffmpeg (${INSTALL}) or set FFMPEG_PATH to an ffmpeg that runs.`,
+    late: "Run easycaptionkit again.",
+  },
 };
 
-// A program named in the environment, as a whole path: a path is taken
-// from the folder the run started in, so a program run in another folder
-// (the encode runs in its work folder) still finds it, and a bare name is
-// looked up on PATH, as a shell would. Empty when it is not there.
-function given(value) {
-  if (bare(value)) return onPath(value) || onPath(exe(value));
-  const file = path.resolve(value);
-  return isFile(file) ? file : "";
-}
-
-// What an environment variable that names a program names, when that is
-// no program: "FFMPEG_PATH is /opt/ffmpeg, and there is no file there".
-// Empty when it is not set or names one.
-function namedNothing(variable) {
-  const value = process.env[variable];
-  if (!value || given(value)) return "";
-  const what = bare(value) ? "and no program by that name is on PATH" : fs.existsSync(path.resolve(value)) ? "a folder, not a program" : "and there is no file there";
-  return `${variable} is ${value}, ${what}`;
-}
-
-function findFfmpeg() {
-  if (process.env.FFMPEG_PATH) return given(process.env.FFMPEG_PATH);
-  return onPath(exe("ffmpeg")) || (process.platform === "win32" ? "" : KNOWN.map((d) => path.join(d, "ffmpeg")).find((f) => fs.existsSync(f)) || "");
-}
+// ffprobe, which sits next to ffmpeg in every package: the one next to the
+// ffmpeg at `ffmpeg`, when that is not ffmpeg's own file, else as ffmpeg is
+// looked for.
+const FFPROBE = (ffmpeg) => ({
+  name: "ffprobe",
+  variable: "FFPROBE_PATH",
+  args: ["-version"],
+  answers: (stdout) => /^ffprobe version\b/m.test(stdout),
+  names: [exe("ffprobe")],
+  known: KNOWN,
+  first: () => (ffmpeg ? [{ file: path.join(path.dirname(ffmpeg), exe("ffprobe")), name: "ffprobe", where: `next to ${ffmpeg}`, next: true }].filter((place) => place.file !== ffmpeg) : []),
+  none: `easycaptionkit needs ffprobe, and none was found${ffmpeg ? ` next to ${ffmpeg} or` : ""} on PATH. Install ffmpeg, which comes with ffprobe (${INSTALL}), or set FFPROBE_PATH to one.`,
+  advice: {
+    variable: `Set FFPROBE_PATH to an ffprobe that runs, or unset it and install ffmpeg, which comes with ffprobe (${INSTALL}).`,
+    next: "Set FFPROBE_PATH to an ffprobe that runs.",
+    found: `Install ffmpeg, which comes with ffprobe (${INSTALL}), or set FFPROBE_PATH to an ffprobe that runs.`,
+    late: "Run easycaptionkit again.",
+  },
+});
 
-// ffprobe sits next to ffmpeg in every package.
-function findFfprobe(ffmpeg) {
-  if (process.env.FFPROBE_PATH) return given(process.env.FFPROBE_PATH);
-  const next = ffmpeg ? path.join(path.dirname(ffmpeg), exe("ffprobe")) : "";
-  if (next && fs.existsSync(next)) return next;
-  return onPath(exe("ffprobe")) || (process.platform === "win32" ? "" : KNOWN.map((d) => path.join(d, "ffprobe")).find((f) => fs.existsSync(f)) || "");
+// ffmpeg and ffprobe, each found and asked its version before any work,
+// as { ffmpeg, ffprobe, version, places }: their files, what ffmpeg said,
+// which capabilities() reads, and where each was found, for the words of
+// a later failure. ffprobe is looked for next to the ffmpeg that answered.
+// A program that cannot be started or does not answer as itself stops the
+// run there, as programs.find() says, ffmpeg's first.
+async function ready(limit = programs.LIMIT) {
+  const ffmpeg = await programs.find(FFMPEG, limit);
+  const ffprobe = await programs.find(FFPROBE(ffmpeg.file), limit);
+  return { ffmpeg: ffmpeg.file, ffprobe: ffprobe.file, version: ffmpeg.stdout, places: { ffmpeg: ffmpeg.place, ffprobe: ffprobe.place } };
 }
 
-const MISSING = "ffmpeg and ffprobe were not found. Install them (brew install ffmpeg, sudo apt install ffmpeg or winget install ffmpeg) or set FFMPEG_PATH and FFPROBE_PATH to them.";
-
-function tools() {
-  for (const [variable, name] of [["FFMPEG_PATH", "ffmpeg"], ["FFPROBE_PATH", "ffprobe"]]) {
-    const nothing = namedNothing(variable);
-    if (nothing) throw new Error(`${nothing}. Set it to the path of ${name}, or unset it to use the one on PATH.`);
-  }
-  const ffmpeg = findFfmpeg();
-  const ffprobe = findFfprobe(ffmpeg);
-  if (!ffmpeg) throw new Error(MISSING);
-  if (!ffprobe) throw new Error(`ffprobe was not found next to ${ffmpeg} or on PATH. It comes with ffmpeg: install it, or set FFPROBE_PATH to it.`);
-  return { ffmpeg, ffprobe };
+// ffprobe alone, for a run that reads a video and starts no ffmpeg: found
+// and asked as ready() does, next to the ffmpeg the run would take, which
+// is not run, so nothing at ffmpeg's path stops it.
+async function readyProbe(limit = programs.LIMIT) {
+  const ffprobe = await programs.find(FFPROBE(programs.locate(FFMPEG)), limit);
+  return { ffprobe: ffprobe.file, places: { ffprobe: ffprobe.place } };
 }
 
 // What ffmpeg prints once it has given up, after the lines that say why:
@@ -92,7 +79,9 @@ function tools() {
 // ffmpeg 7 and newer with the others, and ffmpeg 8 says last that its
 // encoder never opened and that it wrote nothing, after a filter that
 // could not start, or that filtering failed, after the scaler said which
-// frame it could not convert.
+// frame it could not convert. ffmpeg 6.1 says it could not start a simple
+// filtergraph, the one -vf gives, after the line that names the option
+// its filter refused.
 const CLOSING = [
   /^Could not open encoder before EOF/,
   /^Error while filtering\b/,
@@ -104,6 +93,7 @@ const CLOSING = [
   /^Error initializing complex filters\.?$/,
   /^Error opening filters!?$/,
   /^Exiting normally/,
+  /^Error initializing a simple filtergraph$/,
   /^(?:Invalid argument|Operation not permitted|Cannot allocate memory|Invalid data found when processing input|Unknown error occurred)$/,
   /^Error opening (?:input|output) files?\b/,
   /^Error selecting an encoder$/,
@@ -149,20 +139,42 @@ function whyFailed({ code, signal, stderr }, who = "it") {
 // error, not a hang, unless what `busy` gives, as the size and the time of
 // the file it writes, changed in that time: ffmpeg prints nothing while it
 // writes a whole MP4 again to move its index to the front. With `binary`,
-// stdout is the bytes it wrote, not text.
+// stdout is the bytes it wrote, not text. The programs are the ones a run
+// checked before any work, so one that cannot be started now says what
+// the system said, or that the folder it was to run in is gone, never the
+// system's code alone: Node throws some of those errors at once and gives
+// the others a moment later.
 function run(binary, args, { quiet = 120_000, onStdout = null, cwd = undefined, busy = null, binary: bytes = false } = {}) {
   return new Promise((resolve, reject) => {
+    const failed = (err) => {
+      if (!/^spawn\b/.test(err.syscall || "")) return err;
+      // A start that fails for want of the folder it runs in is no fault of
+      // the program's.
+      if (cwd && !programs.enterable(cwd)) return new Error(`${path.basename(binary)} could not be started in ${cwd}, a folder that is not there any more or may not be entered`);
+      return programs.startFailure(binary, err);
+    };
     let child;
     try {
       child = track(spawn(binary, args, { stdio: ["ignore", "pipe", "pipe"], cwd }));
     } catch (err) {
-      reject(err);
+      reject(failed(err));
       return;
     }
     let stdout = "";
     const chunks = [];
     let stderr = "";
     let timer = null;
+    child.on("error", (err) => {
+      clearTimeout(timer);
+      reject(failed(err));
+    });
+    child.on("close", (code, signal) => {
+      clearTimeout(timer);
+      resolve({ code, signal, stdout: bytes ? Buffer.concat(chunks) : stdout, stderr });
+    });
+    // With no file descriptor left for them Node makes no pipes, and says
+    // why a moment later.
+    if (!child.stdout || !child.stderr) return;
     const arm = () => {
       clearTimeout(timer);
       const before = busy ? busy() : null;
@@ -184,14 +196,6 @@ function run(binary, args, { quiet = 120_000, onStdout = null, cwd = undefined,
       arm();
       stderr = (stderr + d).slice(-40_000);
     });
-    child.on("error", (err) => {
-      clearTimeout(timer);
-      reject(err.code === "ENOENT" ? new Error(MISSING) : err);
-    });
-    child.on("close", (code, signal) => {
-      clearTimeout(timer);
-      resolve({ code, signal, stdout: bytes ? Buffer.concat(chunks) : stdout, stderr });
-    });
   });
 }
 
@@ -564,15 +568,21 @@ const round3 = (value) => Math.round(value * 1000) / 1000;
 
 // ─── what this ffmpeg can do ──────────────────────────────────────────────
 
-async function capabilities(bins) {
-  const [about, filters, encoders] = await Promise.all([run(bins.ffmpeg, ["-hide_banner", "-version"], { quiet: 20_000 }), run(bins.ffmpeg, ["-hide_banner", "-filters"], { quiet: 20_000 }), run(bins.ffmpeg, ["-hide_banner", "-encoders"], { quiet: 20_000 })]);
+// What this ffmpeg can do: its version number, from what it said when
+// ready() asked it, and its filters and encoders, each asked of it and
+// read only once it ended well (see programs.probe()), so an ffmpeg that
+// fails or is stopped when asked is said to, not taken for one with no
+// H.264 encoder, no overlay filter or no libass.
+async function capabilities(bins, version) {
+  const asked = (args, what) => programs.probe(FFMPEG, bins.places.ffmpeg, ["-hide_banner", ...args], what);
+  const [filters, encoders] = await Promise.all([asked(["-filters"], "its filters"), asked(["-encoders"], "its encoders")]);
   // 4.4 is the oldest ffmpeg the kit is tried on: Ubuntu 22.04's. A build
   // from git says no number and is newer.
-  const v = /ffmpeg version n?(\d+)\.(\d+)/.exec(about.stdout);
+  const v = /ffmpeg version n?(\d+)\.(\d+)/.exec(version);
   const atLeast = (major, minor) => !v || Number(v[1]) > major || (Number(v[1]) === major && Number(v[2]) >= minor);
   if (!atLeast(4, 4)) throw new Error(`ffmpeg 4.4 or newer is needed, and this one is ${v[1]}.${v[2]}. Install a newer one (brew install ffmpeg, or a static build) or set FFMPEG_PATH to it.`);
-  const hasFilter = (name) => new RegExp(`^\\s*\\S+\\s+${name}\\s`, "m").test(filters.stdout);
-  const hasEncoder = (name) => new RegExp(`^\\s*V\\S*\\s+${name}\\s`, "m").test(encoders.stdout);
+  const hasFilter = (name) => new RegExp(`^\\s*\\S+\\s+${name}\\s`, "m").test(filters);
+  const hasEncoder = (name) => new RegExp(`^\\s*V\\S*\\s+${name}\\s`, "m").test(encoders);
   let encoder = null;
   // No B-frames: with them the file starts behind an edit list, and a tool
   // that reads frames without it is two frames off the captions' times.
@@ -581,11 +591,7 @@ async function capabilities(bins) {
   else if (hasEncoder("libopenh264")) encoder = { name: "libopenh264", args: ["-c:v", "libopenh264", "-b:v", "12M"] };
   else if (hasEncoder("h264_mf")) encoder = { name: "h264_mf", args: ["-c:v", "h264_mf", "-b:v", "12M"] };
   // Whether x264 here writes 10 bits, which an HDR video needs to stay HDR.
-  let tenBit = false;
-  if (encoder && encoder.name === "libx264") {
-    const help = await run(bins.ffmpeg, ["-hide_banner", "-h", "encoder=libx264"], { quiet: 20_000 });
-    tenBit = /yuv420p10le/.test(help.stdout);
-  }
+  const tenBit = Boolean(encoder && encoder.name === "libx264" && /yuv420p10le/.test(await asked(["-h", "encoder=libx264"], "about its libx264")));
   const setparams = hasFilter("setparams");
   return {
     // -fps_mode came in 5.1, in the place of -vsync.
@@ -594,10 +600,10 @@ async function capabilities(bins) {
     libass: hasFilter("ass"),
     setparams,
     // The names setparams takes for each of its options.
-    colorNames: setparams ? optionNames((await run(bins.ffmpeg, ["-hide_banner", "-h", "filter=setparams"], { quiet: 20_000 })).stdout) : {},
+    colorNames: setparams ? optionNames(await asked(["-h", "filter=setparams"], "about its setparams filter")) : {},
     encoder,
     tenBit,
-    aac: /^\s*A\S*\s+aac\s/m.test(encoders.stdout),
+    aac: /^\s*A\S*\s+aac\s/m.test(encoders),
   };
 }
 
@@ -925,7 +931,7 @@ const rateBase = (rate) => {
 // The captions show on the video's own frames. Where it has too few for
 // them, as fillFor says, `fill` gives it frames at a steady rate first.
 async function burn({ bins, caps, video: v, output, overlay = null, ass = null, assMatrix = "", assFull = false, fontsDir = "", fill = null, onProgress = null, quiet = 180_000 }) {
-  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");
   const color = colorOf(v, caps.colorNames);
   // An HDR video stays HDR where x264 writes 10 bits.
   const deep = v.hdr && caps.tenBit;
@@ -1029,4 +1035,4 @@ async function frameAt(bins, file, t, output, { width = 0, retag = "", untag = "
   return output;
 }
 
-module.exports = { tools, findFfmpeg, findFfprobe, given, namedNothing, probe, readVideo, packetsOf, frameTimes, rateOf, steadyRate, fillFor, capabilities, burn, frameAt, run, whyFailed, optionNames, onPath, MISSING, colorOf, prepareChain, filterPath, libassFilter, hdrLevel, fineBase, matrixLine, as601, libassFollows, assColors, pixelFormat };
+module.exports = { FFMPEG, FFPROBE, ready, readyProbe, onPath: programs.onPath, probe, readVideo, packetsOf, frameTimes, rateOf, steadyRate, fillFor, capabilities, burn, frameAt, run, whyFailed, optionNames, colorOf, prepareChain, filterPath, libassFilter, hdrLevel, fineBase, matrixLine, as601, libassFollows, assColors, pixelFormat };

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