@moood/render 0.1.4 → 0.1.5

package/index.js

@@ -1,89 +1,161 @@
 // A moood scene rendered here, with moood's own engine (engine/: the site's web/scene, its version in
 // engine/engine.json) in a Chromium already installed (playwright-core: nothing is downloaded) — no
 // network, no site. Time is a virtual clock, stepped from the scene's start: a frame at a moment is
-// the same every time, with the same state.
-//   render({spec, modules, device, at, state, set, bare, chromium, date}) → [{at, png, errors, tells}]
+// the same every time, with the same state. Only the frames taken are drawn: up to each moment the
+// scene goes on unseen (its scripts, its state, the memory its modules keep — all as when it plays;
+// the engine's stage.draw(false)), so a late moment costs little more than an early one.
+//   render({spec, modules, device, at, state, set, views, bare, debug, look, crop, chromium, date, engine, each})
+//       → [{at, view, png, errors, warnings, tells, look}]
 //     spec — the scene (readScene(folder) from a world's repository, or any spec);
 //     modules — the modules it lists, themselves: {name: {code, data}} (readModules(world, spec));
 //     device — the frame: 16:9 (1600×900), 4:3, 21:9 (the same height), tile (640×360), big (1920×1080);
 //     at — the moments, seconds from the scene's start (default [0]): a frame each;
 //     state — values over the spec's starting state ({"dawn": 1, "girl": "gone"});
 //     set — values set as the scene goes, as a game sets them: [[second, key, value, over?, ease?], …]
-//       (a film's beat at its second: [[4, "beat", "cover"]]);
+//       (a film's beat at its second: [[4, "beat", "cover"]]); a cut: [[4, "cut", {values}]] (scene.cut);
+//     views — other cameras on each moment: [{camera_target: "keeper", camera_shot: "close"}, {camera_x: 2},
+//       …] — a frame each (`view` 1, 2 …) of the very moment, the camera there at once; the film (its
+//       state, its clock, its own camera) goes on untouched;
 //     bare — without the title and the captions over it;
+//     debug — what is where, drawn over the frame (the scene's ?debug): ids, boxes, points, notes;
+//       true, or the ids of some elements ('keeper,boy'): only theirs;
+//     look — what is where, as numbers, with each frame (`look`): {t, camera, frame, elements, state}
+//       (the engine's stage.inspect(): each element's box in the frame's pixels, whether it is seen,
+//       its points, its notes, what its last painting cost);
+//     crop — an element's id: each frame only around it (its box, a margin round it);
+//     jpeg — frames as JPEG (`jpg` instead of `png`), quality 90: smaller, for a video;
 //     chromium — the browser's executable (else MOOOD_CHROMIUM, else Playwright's own);
-//     date — what the clock says at the start (default 2026-01-01T12:00:00Z).
+//     date — what the clock says at the start (default 2026-01-01T12:00:00Z);
+//     engine — another engine to render with: a folder like web/scene (another checkout's, an older
+//       package's engine/) — to compare engines;
+//     each — called with each frame as it is taken (async ok); then frames are not kept.
 //   Each frame: its errors, and what the scene's scripts told so far (scene.tell): [{at, text, about}].
 //   renderMotion({motion, at, views, kit, cell, chromium}) → {png, errors}
 //     a person's motion made by a model (moood's make_motion: list_motions(key, body=true) — its `body` is
 //     the motion, its `clip` the people module's entry) as frames on its body (engine/motion.html): a row
 //     per view (front, side, back, or {yaw, pitch, dist}), a column per moment (at, seconds; default eight
 //     across it); kit — the module's clip, its skeleton drawn over the body; cell — [w, h] of a frame.
-import { readFileSync } from 'node:fs';
+// browser(chromium) — the Chromium it renders in, launched (compose.js lays frames out in it too).
+import { existsSync, readFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { chromium as browserType } from 'playwright-core';
 
 export { readModules, readScene } from './scene.js';
 
-const PAGE = pathToFileURL(fileURLToPath(new URL('./engine/render.html', import.meta.url))).href;
-const MOTION = pathToFileURL(fileURLToPath(new URL('./engine/motion.html', import.meta.url))).href;
-export const ENGINE = JSON.parse(readFileSync(new URL('./engine/engine.json', import.meta.url), 'utf8')).engine;
+const OWN = fileURLToPath(new URL('./engine/', import.meta.url));
+export const ENGINE = JSON.parse(readFileSync(join(OWN, 'engine.json'), 'utf8')).engine;
 export const DEVICES = { '16:9': [1600, 900], '4:3': [1200, 900], '21:9': [2100, 900], tile: [640, 360], big: [1920, 1080] };
 const STEP = 100;  // ms: timers fire as they come due, not all at the end of one jump
-// WebGL on SwiftShader; 2D canvases on the CPU's Skia (SwiftShader takes minutes for many blended fills)
-const ARGS = ['--use-angle=swiftshader', '--enable-unsafe-swiftshader', '--ignore-gpu-blocklist', '--disable-accelerated-2d-canvas',
-              '--allow-file-access-from-files'];
+const FRAME = 17;  // ms: one frame drawn
+// ms before a frame taken that the scene is painted as when drawn (unseen still): what keeps a memory
+// of its own and depends on how big it is painted (a module's detail drawn only up close) comes to
+// the frame exactly as when the film plays; before that, coarsely
+const SETTLE = 2000;
+const PATIENCE = 10 * 60_000; // ms: how long anything on the page is waited for
 
-export async function render({ spec, modules = {}, device = '16:9', at = [0], state = {}, set = [], bare = false, chromium, date } = {}) {
+export const browser = chromium => browserType.launch({
+  executablePath: chromium || process.env.MOOOD_CHROMIUM || undefined,
+  // WebGL on SwiftShader; 2D canvases on the CPU's Skia (SwiftShader takes minutes for many blended fills)
+  args: ['--use-angle=swiftshader', '--enable-unsafe-swiftshader', '--ignore-gpu-blocklist', '--disable-accelerated-2d-canvas',
+         '--allow-file-access-from-files'],
+});
+
+export async function render({ spec, modules = {}, device = '16:9', at = [0], state = {}, set = [], views = [], bare = false, debug = false,
+                               look = false, crop = null, jpeg = false, chromium, date, engine, each } = {}) {
   const size = DEVICES[device];
   if (!size) throw new Error(`device: one of ${Object.keys(DEVICES).join(', ')}`);
   if (!spec || typeof spec !== 'object') throw new Error('spec: a scene expected');
+  const dir = engine ? resolve(engine) : OWN;
+  if (!existsSync(join(dir, 'render.html'))) throw new Error(`engine: ${dir} is not an engine (no render.html in it: a folder like moood/web/scene)`);
   const shown = { ...spec, state: { ...(spec.state && typeof spec.state === 'object' ? spec.state : {}), ...state } };
-  const browser = await browserType.launch({
-    executablePath: chromium || process.env.MOOOD_CHROMIUM || undefined, args: ARGS,
-  });
+  const b = await browser(chromium);
   try {
-    const page = await (await browser.newContext({ viewport: { width: size[0], height: size[1] } })).newPage();
+    const page = await (await b.newContext({ viewport: { width: size[0], height: size[1] } })).newPage();
+    // a machine under load draws slowly: what waits on the page waits long (Playwright's own: 30 s)
+    page.setDefaultTimeout(PATIENCE);
     const errors = [];
     page.on('pageerror', e => errors.push(String(e.message)));
-    // the clock stands still: only the frames' moments move it (install alone lets it run as time does)
+    // the real clock, before the page's own is stopped: what painting costs is timed by it
+    await page.addInitScript(() => { const now = performance.now.bind(performance); window.__mooodClock = () => now(); });
+    // the clock stands still: only the frames' moments move it (install alone lets it run as time
+    // does — from a minute before, so that however slowly a loaded machine gets to stopping it, it
+    // is stopped ahead of where it is, not behind: "Cannot fast-forward to the past")
     const start = new Date(date || '2026-01-01T12:00:00Z').getTime();
-    await page.clock.install({ time: start });
-    await page.clock.pauseAt(start + 1);
+    await page.clock.install({ time: start - 60_000 });
+    await page.clock.pauseAt(start);
     await page.addInitScript(([s, m]) => {
       window.__mooodSpec = s; window.__mooodModules = m;
       // chance, the same every time (the engine's grain, rain, sparks): the same moment, the same frame
       let seed = 1;
       Math.random = () => { seed = (seed + 0x6d2b79f5) | 0; let t = Math.imul(seed ^ (seed >>> 15), 1 | seed); t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t; return ((t ^ (t >>> 14)) >>> 0) / 4294967296; };
     }, [shown, modules]);
-    await page.goto(bare ? `${PAGE}?bare` : PAGE);
+    const query = [bare && 'bare', debug && (debug === true ? 'debug' : `debug=${encodeURIComponent(debug)}`)].filter(Boolean).join('&');
+    await page.goto(`${pathToFileURL(join(dir, 'render.html')).href}${query ? `?${query}` : ''}`);
     // what loads by itself (fonts, the scene's modules) has loaded before the clock moves at all
     await page.evaluate(() => document.fonts.ready);
     await page.waitForTimeout(1000);
+    // values put in its starting state that nothing in the scene uses (a mistyped key): said
+    const extra = Object.keys(state).filter(k => !(spec.state && typeof spec.state === 'object' && k in spec.state));
+    if (extra.length) await page.evaluate(k => typeof MooodState !== 'undefined' && MooodState.check?.(k, '--state'), extra);
+    // an engine that can go on unseen (older ones draw every frame up to the moment)
+    const [unseeing, inspecting, stills] = await page.evaluate(() => ['draw', 'inspect', 'still'].map(f => typeof window.__mooodStage?.[f] === 'function'));
+    if ((look || crop) && !inspecting) throw new Error('this engine does not tell what is where (look, crop): it is older than them');
     const frames = [], sets = [...set].map(([s, ...rest]) => [Number(s) * 1000, ...rest]).sort((a, b) => a[0] - b[0]);
     let now = 0;
     // the values due by now, set (the clock stops at each one's second: it is set on time)
     const due = async () => {
       while (sets.length && sets[0][0] <= now) {
         const [, key, value, over, ease] = sets.shift();
-        await page.evaluate(([k, v, o, e]) => MooodState.set(k, v, o, e), [key, value, over, ease]);
+        await page.evaluate(([k, v, o, e]) => (k === 'cut' ? MooodState.cut(v, { who: '--set' }) : MooodState.set(k, v, o, e, { who: '--set' })), [key, value, over, ease]);
+      }
+    };
+    const run = async ms => { await page.clock.runFor(ms); now += ms; await due(); };
+    // on to `ms`, the clock stopping at each value's second (what is due by then is set)
+    const until = async ms => { while (now < ms) await run(Math.min(STEP, ms - now, sets.length ? sets[0][0] - now : STEP)); };
+    const draw = how => unseeing && page.evaluate(v => window.__mooodStage.draw(v), how);
+    // (keys set from outside that nothing in the scene has read — a mistyped one — said with the last
+    // moment's frame: by then whatever reads a key late has read it)
+    const last = Math.max(...at.map(Number));
+    const shot = async (t, view) => {
+      const [said, warned, tells, seen] = await page.evaluate(([l, end]) => [window.__mooodErrors || [], [...(window.__mooodWarnings || []), ...(end ? MooodState.unknown?.() || [] : [])], window.__mooodTells || [],
+        l ? { ...window.__mooodStage.inspect(), state: MooodState.all() } : null], [look || !!crop, t === last]);
+      let clip;
+      if (crop) {
+        const el = seen.elements[crop];
+        if (!el) throw new Error(`crop: there is no element "${crop}" (its id): ${Object.keys(seen.elements).join(', ')}`);
+        if (el.seen && el.box) {
+          const [x, y, w, h] = el.box, m = 0.1 * Math.max(w, h), x0 = Math.max(0, x - m), y0 = Math.max(0, y - m);
+          clip = { x: x0, y: y0, width: Math.min(size[0], x + w + m) - x0, height: Math.min(size[1], y + h + m) - y0 };
+          if (!(clip.width >= 8 && clip.height >= 8)) clip = undefined;
+        }
+        if (!clip) errors.push(`crop: "${crop}" is not in the frame at ${t}s — the whole frame instead`);
       }
+      const image = await page.screenshot(jpeg ? { type: 'jpeg', quality: 90, clip } : { type: 'png', clip });
+      const frame = { at: t, view, [jpeg ? 'jpg' : 'png']: image, errors: [...new Set([...errors, ...said])].slice(0, 100), warnings: [...new Set(warned)].slice(0, 100), tells, ...(look ? { look: seen } : {}) };
+      if (each) await each(frame); else frames.push(frame);
     };
     await due();
     for (const t of [...at].map(Number).sort((a, b) => a - b)) {
-      while (now < t * 1000) {
-        const step = Math.min(STEP, t * 1000 - now, sets.length ? sets[0][0] - now : STEP); // (what is due by now is set)
-        await page.clock.runFor(step);
-        now += step;
-        await due();
+      // unseen up to a frame before the moment (its last seconds painted as when drawn); that frame drawn
+      if (now < t * 1000 - FRAME) {
+        if (now < t * 1000 - SETTLE) { await draw(false); await until(t * 1000 - SETTLE); }
+        await draw('painted'); await until(t * 1000 - FRAME); await draw(true);
       }
+      // (the scene's first frame is drawn at the first display refresh: a moment before it is that frame)
+      await until(Math.max(t * 1000, FRAME));
       await page.clock.runFor(0);
-      const [said, tells] = await page.evaluate(() => [window.__mooodErrors || [], window.__mooodTells || []]);
-      frames.push({ at: t, png: await page.screenshot({ type: 'png' }), errors: [...new Set([...errors, ...said])].slice(0, 100), tells });
+      await shot(t);
+      if (!views.length) continue;
+      if (!stills) throw new Error('views: this engine cannot draw a moment from another camera (stage.still): it is older than that');
+      for (const [i, view] of views.entries()) {
+        await page.evaluate(v => window.__mooodStage.still(v), view);
+        await shot(t, i + 1);
+      }
     }
     return frames;
   } finally {
-    await browser.close();
+    await b.close();
   }
 }
 
@@ -91,17 +163,17 @@ export async function renderMotion({ motion, at, views = ['front', 'side'], kit
   if (!motion || !Array.isArray(motion.names)) throw new Error('motion: the body of a made motion expected (list_motions(key, body=true).body)');
   const length = (motion.n - 1) / motion.fps;
   const moments = at && at.length ? at.map(s => Math.min(Math.max(0, Number(s)), length)) : Array.from({ length: 8 }, (_, i) => +(length * i / 7).toFixed(2));
-  const browser = await browserType.launch({ executablePath: chromium || process.env.MOOOD_CHROMIUM || undefined, args: ARGS });
+  const b = await browser(chromium);
   try {
-    const page = await (await browser.newContext({ viewport: { width: cell[0] * moments.length, height: cell[1] * views.length } })).newPage();
+    const page = await (await b.newContext({ viewport: { width: cell[0] * moments.length, height: cell[1] * views.length } })).newPage();
     const errors = [];
     page.on('pageerror', e => errors.push(String(e.message)));
     await page.addInitScript(([m, s]) => { window.__mooodMotion = m; window.__mooodMotionShow = s; }, [motion, { at: moments, views, kit, cell }]);
-    await page.goto(MOTION);
+    await page.goto(pathToFileURL(join(OWN, 'motion.html')).href);
     await page.waitForFunction(() => document.title === 'ready', null, { timeout: 120_000 });
     errors.push(...await page.evaluate(() => window.__mooodRenderErrors || []));
     return { png: await page.screenshot({ type: 'png' }), errors: [...new Set(errors)] };
   } finally {
-    await browser.close();
+    await b.close();
   }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@moood/render",
-  "version": "0.1.4",
-  "description": "A moood scene rendered locally — the site's own engine, in a browser already installed — at a moment, with a state: a PNG and the errors its code threw; and a person's motion made by a model, as frames on its body.",
+  "version": "0.1.5",
+  "description": "A moood scene rendered locally — the site's own engine, in a browser already installed — at any moment of it, with a state: frames, a sheet, a video, what is where as numbers, two versions compared; and the errors its code threw. And a person's motion made by a model, as frames on its body.",
   "license": "UNLICENSED",
   "type": "module",
   "main": "index.js",
@@ -12,6 +12,8 @@
     "index.js",
     "cli.js",
     "scene.js",
+    "compose.js",
+    "video.js",
     "engine/",
     "README.md"
   ],

package/scene.js

@@ -1,19 +1,34 @@
 // A scene as it lies in its world's repository, put together as moood does it (the scenes service's
 // layout.py): scenes/<folder>/scene.json and its code beside it — elements/<id>.js (objects[].code),
-// elements/<id>.script.js (objects[].script), script.js, lib.js, notes.md, widgets/<id>.html — and
-// the modules it lists (modules/<name>.js, .data.json, in the world's repository).
+// elements/<id>.script.js (objects[].script), script.js, lib.js, relief.js, notes.md, widgets/<id>.html — and
+// the modules it lists (modules/<name>.js, .data.json, in the world's repository). As it is on disk,
+// or as a commit of the repository has it (`ref`: a branch, a tag, a commit — the world's main, say).
+import { execFileSync } from 'node:child_process';
 import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
 import { join, relative, sep } from 'node:path';
 
-const TOP = { script: 'script.js', lib: 'lib.js', notes: 'notes.md' };
+const TOP = { script: 'script.js', lib: 'lib.js', relief: 'relief.js', notes: 'notes.md' };
 const IN = { objects: { code: 'elements/{id}.js', script: 'elements/{id}.script.js' }, widgets: { html: 'widgets/{id}.html' } };
 
 const walk = dir => readdirSync(dir).flatMap(f => (statSync(join(dir, f)).isDirectory() ? walk(join(dir, f)) : [join(dir, f)]));
+const git = (world, ...args) => execFileSync('git', ['-C', world, ...args], { encoding: 'utf8', maxBuffer: 1 << 28, stdio: ['ignore', 'pipe', 'pipe'] });
+// a file at a commit (null: there is none) — its path from the world's folder, which may lie deeper in
+// its repository (./: from there)
+const shown = (world, ref, path) => { try { return git(world, 'show', `${ref}:./${path}`); } catch { return null; } };
 
-// the spec a scene's folder makes (an error says what is wrong with it)
-export function readScene(folder) {
-  const files = Object.fromEntries(walk(folder).map(p => [relative(folder, p).split(sep).join('/'), readFileSync(p, 'utf8')]));
-  if (!('scene.json' in files)) throw new Error(`${folder}: no scene.json`);
+// the spec a scene's folder makes (an error says what is wrong with it); `ref` — as that commit of the
+// world's repository (`world`) has it
+export function readScene(folder, { world, ref } = {}) {
+  let files;
+  if (ref) {
+    const at = relative(world, folder).split(sep).join('/');
+    try { git(world, 'rev-parse', '--verify', '--quiet', `${ref}^{commit}`); } catch { throw new Error(`${ref}: no such branch or commit in ${world}`); }
+    // (-z: the names as they are — any letters — not quoted; from the world's folder)
+    const names = git(world, 'ls-tree', '-r', '-z', '--name-only', ref, '--', `${at}/`).split('\0').filter(Boolean);
+    if (!names.length) throw new Error(`${ref}: there is no ${at} in it`);
+    files = Object.fromEntries(names.map(p => [p.slice(at.length + 1), shown(world, ref, p)]));
+  } else files = Object.fromEntries(walk(folder).map(p => [relative(folder, p).split(sep).join('/'), readFileSync(p, 'utf8')]));
+  if (!('scene.json' in files)) throw new Error(`${folder}${ref ? ` (${ref})` : ''}: no scene.json`);
   const spec = JSON.parse(files['scene.json']);
   const used = new Set(['scene.json']);
   for (const [key, name] of Object.entries(TOP)) if (name in files) { spec[key] = files[name].replace(/\n+$/, ''); used.add(name); }
@@ -31,13 +46,14 @@ export function readScene(folder) {
   return spec;
 }
 
-// the modules a scene lists, from its world's repository: {name: {code, data}}
-export function readModules(world, spec) {
+// the modules a scene lists, from its world's repository: {name: {code, data}} (`ref`: at that commit)
+export function readModules(world, spec, { ref } = {}) {
+  const read = path => (ref ? shown(world, ref, path) : existsSync(join(world, path)) ? readFileSync(join(world, path), 'utf8') : null);
   const out = {};
   for (const name of [...new Set((spec.modules || []).filter(n => typeof n === 'string'))].sort()) {
-    const code = join(world, 'modules', `${name}.js`), data = join(world, 'modules', `${name}.data.json`);
-    if (!existsSync(code)) throw new Error(`the scene lists modules/${name}.js, and there is none`);
-    out[name] = { code: readFileSync(code, 'utf8'), data: existsSync(data) ? JSON.parse(readFileSync(data, 'utf8')) : null };
+    const code = read(`modules/${name}.js`), data = read(`modules/${name}.data.json`);
+    if (code == null) throw new Error(`the scene lists modules/${name}.js, and there is none${ref ? ` at ${ref}` : ''}`);
+    out[name] = { code, data: data == null ? null : JSON.parse(data) };
   }
   return out;
 }

package/video.js

@@ -0,0 +1,66 @@
+// Frames into a video — by an ffmpeg already on this machine (nothing is downloaded): MOOOD_FFMPEG,
+// else the one on the PATH, else the one Playwright installs beside its browsers (that one writes
+// .webm only). The frames come in as JPEGs.
+import { spawn, spawnSync } from 'node:child_process';
+import { existsSync, readdirSync } from 'node:fs';
+import { dirname, extname, join } from 'node:path';
+import { homedir } from 'node:os';
+
+// what each kind of file is written with: the encoder it needs, and how
+const KINDS = {
+  '.mp4': ['libx264', ['-c:v', 'libx264', '-pix_fmt', 'yuv420p', '-crf', '20', '-preset', 'veryfast', '-movflags', '+faststart']],
+  '.webm': ['libvpx', ['-c:v', 'libvpx', '-b:v', '4M', '-crf', '8', '-auto-alt-ref', '0']],
+  '.gif': ['gif', ['-vf', 'split[a][b];[a]palettegen[p];[b][p]paletteuse']],
+};
+export const VIDEOS = Object.keys(KINDS);
+
+// the ffmpegs here: the one asked for, the PATH's, Playwright's (beside its browsers: where it keeps
+// them on Linux, macOS or Windows, or up from the browser given)
+function ffmpegs(chromium) {
+  const found = [process.env.MOOOD_FFMPEG, 'ffmpeg'];
+  const homes = [process.env.PLAYWRIGHT_BROWSERS_PATH, join(homedir(), '.cache', 'ms-playwright'), join(homedir(), 'Library', 'Caches', 'ms-playwright'),
+    process.env.LOCALAPPDATA && join(process.env.LOCALAPPDATA, 'ms-playwright')];
+  for (let d = chromium && dirname(chromium); d && dirname(d) !== d; d = dirname(d)) homes.push(d);
+  for (const home of homes.filter(h => h && existsSync(h))) {
+    for (const f of readdirSync(home).filter(f => f.startsWith('ffmpeg-')).sort().reverse()) {
+      for (const exe of ['ffmpeg-linux', 'ffmpeg-mac', 'ffmpeg-win64.exe']) if (existsSync(join(home, f, exe))) found.push(join(home, f, exe));
+    }
+  }
+  return [...new Set(found.filter(Boolean))];
+}
+const encoders = exe => { const r = spawnSync(exe, ['-hide_banner', '-encoders'], { encoding: 'utf8' }); return r.status === 0 ? r.stdout : null; };
+
+// a video being written to `out` at `fps` frames a second: write(jpeg) each frame, then done()
+export function video(out, fps, { chromium } = {}) {
+  const kind = KINDS[extname(out).toLowerCase()];
+  if (!kind) throw new Error(`--video: ${out} — a .mp4, .webm or .gif`);
+  const [need, how] = kind, tried = [];
+  let exe = null;
+  for (const f of ffmpegs(chromium || process.env.MOOOD_CHROMIUM)) {
+    const list = encoders(f);
+    if (list == null) continue;
+    tried.push(f);
+    if (new RegExp(`^\\s*V\\S*\\s+${need}\\s`, 'm').test(list)) { exe = f; break; }
+  }
+  if (!exe) {
+    throw new Error(tried.length
+      ? `--video: ${extname(out)} needs an ffmpeg with ${need}, and ${tried.join(', ')} ${tried.length > 1 ? 'have' : 'has'} none — write .webm, or install ffmpeg, or point MOOOD_FFMPEG at one`
+      : '--video: no ffmpeg here — install it (or point MOOOD_FFMPEG at one); Playwright\'s own (npx playwright install ffmpeg) writes .webm');
+  }
+  const p = spawn(exe, ['-hide_banner', '-loglevel', 'error', '-y', '-f', 'image2pipe', '-c:v', 'mjpeg', '-framerate', String(fps), '-i', '-', ...how, out], { stdio: ['pipe', 'ignore', 'pipe'] });
+  let said = '';
+  p.stderr.on('data', d => { said += d; });
+  // (ffmpeg gone — it could not start, or it stopped: what it said is the error, the frames' pipe
+  // closing with it is not)
+  const ended = new Promise((ok, no) => {
+    p.on('error', e => no(new Error(`--video: ffmpeg (${exe}) could not run: ${e.message}`)));
+    p.on('close', code => (code === 0 ? ok() : no(new Error(`--video: ffmpeg (${exe}) failed: ${said.trim() || `exit ${code}`}`))));
+  });
+  ended.catch(() => {});
+  p.stdin.on('error', () => {});
+  return {
+    ffmpeg: exe,
+    write: jpeg => new Promise((ok, no) => p.stdin.write(jpeg, e => (e ? ended.then(() => no(e), no) : ok()))),
+    done: async () => { p.stdin.end(); await ended; },
+  };
+}