@funpixel/tools 0.0.0-stage → 0.1.1

package/dist/relay/bots.js

@@ -0,0 +1,62 @@
+import { gameFrame, openPlayer } from "../verify/players.js";
+export const MAX_BOTS = 15;
+const NEVER = new Set(['Escape', 'KeyP', 'KeyM']);
+export function chooseAction(verbs, keys, rng = Math.random) {
+    const pick = (xs) => xs[Math.min(xs.length - 1, Math.floor(rng() * xs.length))];
+    if (verbs.length)
+        return { verb: pick(verbs) };
+    const usable = keys.filter((k) => !NEVER.has(k));
+    if (usable.length)
+        return { key: pick(usable), holdMs: 50 + Math.round(rng() * 250) };
+    return { tap: [0.25 + rng() * 0.5, 0.25 + rng() * 0.5] };
+}
+export function parseBots(raw) {
+    const n = Number(raw);
+    return Number.isInteger(n) && n >= 1 && n <= MAX_BOTS ? n : `--bots is a whole number from 1 to ${MAX_BOTS} (a room holds at most 16)`;
+}
+async function move(bot, rng) {
+    const game = gameFrame(bot.tab.page);
+    const verbs = (await game.evaluate('Object.keys(window.__FPX_VERBS__ ?? {})').catch(() => []));
+    const keys = (await game.evaluate('Object.keys(window.__FPX_KEYS__ ?? {})').catch(() => []));
+    const a = chooseAction(verbs, keys, rng);
+    if ('verb' in a)
+        await game.evaluate(`(() => { try { window.__FPX_VERBS__[${JSON.stringify(a.verb)}](); } catch {} })()`).catch(() => { });
+    else if ('key' in a) {
+        await bot.tab.page.keyboard.down(a.key).catch(() => { });
+        await new Promise((r) => setTimeout(r, a.holdMs));
+        await bot.tab.page.keyboard.up(a.key).catch(() => { });
+    }
+    else {
+        const vp = bot.tab.page.viewportSize() ?? { width: 1280, height: 720 };
+        await bot.tab.page.mouse.click(vp.width * a.tap[0], vp.height * a.tap[1]).catch(() => { });
+    }
+    bot.moves++;
+}
+export async function startBots(browser, playUrl, n, everyMs = 500, rng = Math.random) {
+    const bot = async (i) => ({ name: `bot${i}`, tab: await openPlayer(browser, playUrl, `bot${i}`), moves: 0 });
+    const bots = [await bot(1), ...(await Promise.all(Array.from({ length: n - 1 }, (_, i) => bot(i + 2))))];
+    let running = true;
+    const loops = bots.filter((b) => b.tab.room).map(async (b) => {
+        while (running) {
+            await new Promise((r) => setTimeout(r, everyMs * (0.5 + rng())));
+            if (running)
+                await move(b, rng).catch(() => { });
+        }
+    });
+    return {
+        bots,
+        stop: async () => {
+            running = false;
+            await Promise.all(loops);
+            for (const b of bots)
+                await b.tab.page.context().close().catch(() => { });
+        },
+    };
+}
+export function botLine(b) {
+    if (b.tab.room)
+        return ['pass', `room ${b.tab.room}${b.tab.host ? ', hosting' : ''}`];
+    if (b.tab.errors.length)
+        return ['fail', `the relay refused it: ${b.tab.errors[0]}`];
+    return ['not_observed', 'it opened no room — the game must join on load or in its play view (Room.autoJoin(getGameKey()))'];
+}

package/dist/relay/bridge.js

@@ -0,0 +1,54 @@
+import { mintDevTicket } from "./local.js";
+export const PLAY_PATH = '/__funpixel/play';
+export const TICKET_PATH = '/__funpixel/ticket';
+const LOOPBACK = new Set(['127.0.0.1', '::1', '::ffff:127.0.0.1']);
+export function shellHtml() {
+    return `<!doctype html><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1,viewport-fit=cover">
+<title>funtools · two players</title>
+<style>html,body{margin:0;height:100%;background:#000}iframe{border:0;width:100%;height:100%;display:block}</style>
+<iframe id="game" allow="autoplay; fullscreen; gamepad"></iframe>
+<script>
+const q = new URLSearchParams(location.search);
+let player = q.get('player') || sessionStorage.getItem('fpx-player');
+if (!player) { player = Math.random().toString(36).slice(2, 10); sessionStorage.setItem('fpx-player', player); }
+const game = document.getElementById('game');
+q.delete('player');
+game.src = '/' + (q.toString() ? '?' + q : '');
+addEventListener('message', async (e) => {
+  if (e.source !== game.contentWindow || e.data?.type !== 'FUNPIXEL_RELAY_TICKET_REQUEST') return;
+  try {
+    const r = await fetch('${TICKET_PATH}?player=' + encodeURIComponent(player));
+    if (!r.ok) throw new Error(await r.text());
+    game.contentWindow.postMessage({ type: 'FUNPIXEL_RELAY_TICKET', ticket: (await r.json()).ticket }, location.origin);
+  } catch (err) {
+    console.warn('[funtools] no relay ticket:', err);
+    game.contentWindow.postMessage({ type: 'FUNPIXEL_RELAY_TICKET_ERROR' }, location.origin);
+  }
+});
+</script>`;
+}
+export async function handleBridge(req, res, redisUrl, gameId) {
+    const url = new URL(req.url ?? '/', 'http://x');
+    if (url.pathname === PLAY_PATH) {
+        res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+        res.end(shellHtml());
+        return true;
+    }
+    if (url.pathname !== TICKET_PATH)
+        return false;
+    if (!LOOPBACK.has(req.socket.remoteAddress ?? '')) {
+        res.writeHead(403);
+        res.end('dev tickets are minted for this machine only');
+        return true;
+    }
+    try {
+        const ticket = await mintDevTicket(redisUrl, gameId, url.searchParams.get('player') ?? 'p1');
+        res.writeHead(200, { 'Content-Type': 'application/json', 'Cache-Control': 'no-store' });
+        res.end(JSON.stringify({ ticket }));
+    }
+    catch (e) {
+        res.writeHead(502);
+        res.end(e instanceof Error ? e.message : String(e));
+    }
+    return true;
+}

package/dist/relay/local.js

@@ -0,0 +1,82 @@
+import { spawn } from 'node:child_process';
+import { randomBytes } from 'node:crypto';
+import { existsSync, readFileSync } from 'node:fs';
+import { delimiter, join, resolve } from 'node:path';
+import { DEFAULT_REDIS_URL, redis } from "./redis.js";
+export const RELAY_PORT = 7370;
+const RELAY = `http://127.0.0.1:${RELAY_PORT}`;
+const EXE = process.platform === 'win32' ? 'funpixel-relay.exe' : 'funpixel-relay';
+const MONOREPO_BIN = resolve(import.meta.dirname, '..', '..', '..', '..', 'target', 'debug', EXE);
+export const HOW_TO_GET_A_RELAY = `build it once in the Funpixel repo (cargo build -p funpixel-relay, in funpixel-mono) and set FUNPIXEL_RELAY_BIN to it, or put ${EXE} on PATH; ` +
+    'it needs a Redis (REDIS_URL, default redis://127.0.0.1:6379 — `docker run -p 6379:6379 redis`)';
+export function findRelayBin(env = process.env) {
+    if (env.FUNPIXEL_RELAY_BIN)
+        return env.FUNPIXEL_RELAY_BIN;
+    for (const dir of (env.PATH ?? '').split(delimiter))
+        if (dir && existsSync(join(dir, EXE)))
+            return join(dir, EXE);
+    return existsSync(MONOREPO_BIN) ? MONOREPO_BIN : null;
+}
+async function ready() {
+    try {
+        return (await fetch(`${RELAY}/readyz`, { signal: AbortSignal.timeout(1000) })).ok;
+    }
+    catch {
+        return false;
+    }
+}
+async function listening() {
+    try {
+        await fetch(`${RELAY}/health`, { signal: AbortSignal.timeout(1000) });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function startRelay(env = process.env) {
+    const redisUrl = env.REDIS_URL || DEFAULT_REDIS_URL;
+    await redis(redisUrl, ['PING']).catch((e) => { throw new Error(`${e.message} — the local relay keeps its tickets in Redis: ${HOW_TO_GET_A_RELAY}`); });
+    if (await ready())
+        return { reused: true, redisUrl, stop: async () => { } };
+    if (await listening())
+        throw new Error(`something on :${RELAY_PORT} is not a ready relay — stop it, or start the relay with Redis at ${redisUrl}`);
+    const bin = findRelayBin(env);
+    if (!bin)
+        throw new Error(`no funpixel-relay binary — ${HOW_TO_GET_A_RELAY}`);
+    const child = spawn(bin, [], {
+        env: { ...env, PORT: String(RELAY_PORT), REDIS_URL: redisUrl, RUST_LOG: env.RUST_LOG ?? 'warn' },
+        stdio: ['ignore', 'ignore', 'pipe'],
+    });
+    let log = '';
+    child.stderr?.on('data', (d) => { log = (log + d).slice(-2000); });
+    for (let i = 0; i < 100 && child.exitCode === null; i++) {
+        if (await ready()) {
+            return {
+                reused: false, redisUrl,
+                stop: () => new Promise((done) => { if (child.exitCode !== null)
+                    return done(); child.once('exit', () => done()); child.kill(); }),
+            };
+        }
+        await new Promise((r) => setTimeout(r, 100));
+    }
+    child.kill();
+    throw new Error(`the relay did not become ready on :${RELAY_PORT}: ${log.trim().split('\n').pop() ?? 'no output'}`);
+}
+export function devGameId(dir) {
+    try {
+        const id = JSON.parse(readFileSync(join(dir, 'funpixel.json'), 'utf8')).game_id;
+        if (typeof id === 'string' && /^[a-z0-9]{1,64}$/.test(id))
+            return id;
+    }
+    catch { }
+    return 'local';
+}
+export async function mintDevTicket(redisUrl, gameId, player) {
+    if (!/^[A-Za-z0-9]{1,16}$/.test(player))
+        throw new Error('player is 1–16 letters or digits');
+    const ticket = `relay_${randomBytes(24).toString('hex')}`;
+    const claims = { user_id: `dev-${player}`, username: `Player ${player}`, game_id: gameId, dev: true };
+    await redis(redisUrl, ['SET', `relay_ticket:${ticket}`, JSON.stringify(claims), 'EX', '60']);
+    return ticket;
+}

package/dist/relay/redis.js

@@ -0,0 +1,40 @@
+import { connect } from 'node:net';
+export const DEFAULT_REDIS_URL = 'redis://127.0.0.1:6379';
+const encode = (args) => `*${args.length}\r\n${args.map((a) => `$${Buffer.byteLength(a)}\r\n${a}\r\n`).join('')}`;
+export function redis(url, command, timeoutMs = 3000) {
+    const u = new URL(url);
+    const pre = [];
+    if (u.password)
+        pre.push(u.username ? ['AUTH', decodeURIComponent(u.username), decodeURIComponent(u.password)] : ['AUTH', decodeURIComponent(u.password)]);
+    const db = u.pathname.replace(/^\//, '');
+    if (db)
+        pre.push(['SELECT', db]);
+    const all = [...pre, command];
+    return new Promise((resolve, reject) => {
+        const sock = connect({ host: u.hostname, port: Number(u.port || 6379) });
+        const timer = setTimeout(() => { sock.destroy(); reject(new Error(`redis at ${u.host} did not answer`)); }, timeoutMs);
+        let buf = '';
+        let replies = 0;
+        sock.setEncoding('utf8');
+        sock.on('connect', () => sock.write(all.map(encode).join('')));
+        sock.on('data', (d) => {
+            buf += d;
+            let nl;
+            while ((nl = buf.indexOf('\r\n')) >= 0) {
+                const line = buf.slice(0, nl);
+                buf = buf.slice(nl + 2);
+                if (line.startsWith('-')) {
+                    clearTimeout(timer);
+                    sock.destroy();
+                    return reject(new Error(`redis: ${line.slice(1)}`));
+                }
+                if (++replies === all.length) {
+                    clearTimeout(timer);
+                    sock.end();
+                    return resolve(line);
+                }
+            }
+        });
+        sock.on('error', (e) => { clearTimeout(timer); reject(new Error(`no redis at ${u.host} (${e.message})`)); });
+    });
+}

package/dist/review/audio.js

@@ -0,0 +1,72 @@
+import { spawnSync } from 'node:child_process';
+import { classOf, decodeMono, loopsAsPlayed, measure, PEAK_CEILING, SILENT, TARGETS, TOLERANCE, WRAP_MAX_S, WRAP_MIN_S, wrapSeam } from "../sound/loudness.js";
+import { decodeErrors, found, named, round2, together, unseen } from "./media.js";
+export const DROPOUT_S = 2;
+export const DROPOUT_DB = -60;
+export const DELIVERY_LUFS = { music: -14, speech: -16 };
+export function parseDropouts(stderr, duration) {
+    const out = [];
+    let open = null;
+    for (const m of stderr.matchAll(/silence_(start|end):\s*(-?[\d.]+)/g)) {
+        if (m[1] === 'start')
+            open = Math.max(0, Number(m[2]));
+        else if (open !== null) {
+            out.push({ start: open, end: Number(m[2]) });
+            open = null;
+        }
+    }
+    if (open !== null)
+        out.push({ start: open, end: duration });
+    return out.filter((s) => s.start > 0.05 && s.end < duration - 0.05);
+}
+export function reviewAudio(file, rel, o = {}) {
+    const r = { file: rel, trade: 'audio', errors: unseen('not measured'), overlaps: unseen('audio has nothing to overlap'), seams: unseen('not measured'), notes: [] };
+    const decode = decodeErrors(file, ['-vn']);
+    if (decode.length && /Invalid data|could not find|Error opening|does not contain any stream|no such file/i.test(decode.join(' '))) {
+        r.errors = found([`does not decode: ${decode[0]}`]);
+        r.seams = unseen('does not decode');
+        return r;
+    }
+    const m = measure(file);
+    const seconds = m.seconds ?? 0;
+    const problems = decode.length ? [`does not decode cleanly: ${decode[0]}${decode.length > 1 ? ` (+${decode.length - 1} more)` : ''}`] : [];
+    const silent = m.max !== null && m.max < SILENT;
+    if (silent)
+        problems.push(`silent: a dud take (sample peak ${m.max} dB)`);
+    else {
+        const peak = m.peak ?? m.max;
+        if (peak !== null && peak > PEAK_CEILING)
+            problems.push(`clips: true peak ${peak} dBTP, over the ${PEAK_CEILING} ceiling`);
+        if (seconds >= 2 * DROPOUT_S) {
+            const sd = spawnSync('ffmpeg', ['-hide_banner', '-nostats', '-i', file, '-vn', '-af', `silencedetect=noise=${DROPOUT_DB}dB:d=${DROPOUT_S}`, '-f', 'null', '-'], { encoding: 'utf8', timeout: 120_000 });
+            for (const s of parseDropouts(sd.stderr ?? '', seconds))
+                problems.push(`drops out: silence ${round2(s.start)}–${round2(s.end)} s (${round2(s.end - s.start)} s) inside it`);
+        }
+    }
+    r.errors = m.seconds === null && m.max === null ? together(found(problems), unseen('ffmpeg measured nothing')) : found(problems);
+    const cls = classOf(rel, m.seconds);
+    const loops = o.loop || named(rel, 'loop|loops|looping|bed|beds|amb|ambience|ambient') || (o.game === true && loopsAsPlayed(cls));
+    if (!loops)
+        r.seams = unseen('not a loop (name it loop or bed, or --loop)');
+    else if (silent)
+        r.seams = unseen('silent: no join to judge');
+    else if (seconds < WRAP_MIN_S || seconds > WRAP_MAX_S)
+        r.seams = unseen(`${round2(seconds)} s: a join is judged on ${WRAP_MIN_S}–${WRAP_MAX_S} s`);
+    else {
+        const pcm = decodeMono(file);
+        const w = pcm ? wrapSeam(pcm) : null;
+        r.seams = !w ? unseen('the samples did not decode for the join')
+            : found(w.seam === 'gap' ? [`as a loop it gaps: ${w.gap_ms} ms of silence at the ends, heard on every repeat`]
+                : w.seam === 'click' ? [`as a loop it clicks: the last sample jumps ${w.ratio}× the ordinary step into the first`] : []);
+    }
+    if (!silent && m.lufs !== null && m.lufs > -69) {
+        const speech = named(rel, 'podcast|episode|ep|voice|vo|interview|talk|speech|narration');
+        const [target, kind] = o.lufs !== undefined ? [o.lufs, '--lufs'] : o.game ? [TARGETS[cls], `a game's ${cls}`] : speech ? [DELIVERY_LUFS.speech, 'speech'] : [DELIVERY_LUFS.music, 'music'];
+        const off = Math.abs(m.lufs - target) > TOLERANCE;
+        r.notes.push(`loudness ${m.lufs} LUFS, true peak ${m.peak ?? '–'} dBTP (target ${target} ±${TOLERANCE} for ${kind}${off ? `: ${m.lufs < target ? 'quiet' : 'loud'} for it` : ''})`);
+    }
+    else if (!silent)
+        r.notes.push(`loudness: too short for integrated loudness (${round2(seconds)} s; sample peak ${m.max ?? '–'} dB)`);
+    r.notes.unshift(`${round2(seconds)} s, ${cls}`);
+    return r;
+}

package/dist/review/ledger.js

@@ -0,0 +1,60 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { MEASURED, TRADES } from "./media.js";
+export const LEDGER = join('.funtools', 'review.json');
+export const BY = 'review';
+export function readLedger(root) {
+    try {
+        const j = JSON.parse(readFileSync(join(root, LEDGER), 'utf8'));
+        if (j && typeof j.files === 'object' && j.files)
+            return { version: 1, files: j.files };
+    }
+    catch { }
+    return { version: 1, files: {} };
+}
+export function writeLedger(root, l) {
+    const p = join(root, LEDGER);
+    mkdirSync(dirname(p), { recursive: true });
+    const tmp = `${p}.${process.pid}.tmp`;
+    writeFileSync(tmp, JSON.stringify(l, null, 2) + '\n');
+    renameSync(tmp, p);
+}
+export function mergeLedger(l, reviews, at, root) {
+    const files = {};
+    for (const [k, e] of Object.entries(l.files))
+        if (existsSync(join(root, k)))
+            files[k] = e;
+    for (const r of reviews)
+        files[r.file] = { ...r, at };
+    return { version: 1, files: Object.fromEntries(Object.entries(files).sort(([a], [b]) => a.localeCompare(b))) };
+}
+export function tradeTotals(entries) {
+    const out = {};
+    for (const t of TRADES) {
+        out[t] = { errors: null, overlaps: null, seams: null };
+        for (const c of MEASURED) {
+            const seen = entries.filter((e) => e.trade === t && e[c].value !== null);
+            if (seen.length)
+                out[t][c] = seen.reduce((s, e) => s + (e[c].value ?? 0), 0);
+        }
+    }
+    return out;
+}
+export function ledgerPatch(l, board) {
+    const entries = Object.values(l.files);
+    const patch = {};
+    for (const c of MEASURED) {
+        for (const t of TRADES) {
+            const seen = entries.filter((e) => e.trade === t && e[c].value !== null);
+            if (seen.length) {
+                const value = seen.reduce((s, e) => s + (e[c].value ?? 0), 0);
+                const detail = seen.filter((e) => e[c].value).flatMap((e) => e[c].detail.map((d) => `${e.file}: ${d}`));
+                const newest = seen.map((e) => e.at).sort().at(-1);
+                (patch[c] ??= {})[t] = { value, by: BY, detail, ...(newest ? { at: newest } : {}) };
+            }
+            else if (board.counters[c].parts[t]?.by === BY)
+                (patch[c] ??= {})[t] = null;
+        }
+    }
+    return patch;
+}

package/dist/review/media.js

@@ -0,0 +1,114 @@
+import { spawnSync } from 'node:child_process';
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import { basename, dirname, extname, join, resolve } from 'node:path';
+import { homedir } from 'node:os';
+export const TRADES = ['video', 'audio', 'model', 'picture'];
+export const MEASURED = ['errors', 'overlaps', 'seams'];
+export const found = (problems) => ({ value: problems.length, detail: problems });
+export const unseen = (why) => ({ value: null, detail: [], why });
+export function together(...cs) {
+    const seen = cs.filter((c) => c.value !== null);
+    if (!seen.length)
+        return unseen(cs.map((c) => c.why).filter(Boolean).join('; ') || 'not measured');
+    return { value: seen.reduce((s, c) => s + (c.value ?? 0), 0), detail: seen.flatMap((c) => c.detail) };
+}
+export const EXT = {
+    video: /\.(mp4|mov|m4v|webm)$/i,
+    audio: /\.(wav|mp3|m4a|aac|flac|ogg|opus)$/i,
+    model: /\.(glb|gltf)$/i,
+    picture: /\.(png|jpe?g|webp)$/i,
+};
+export function tradeOfFile(path) {
+    for (const t of TRADES)
+        if (EXT[t].test(path))
+            return t;
+    return null;
+}
+export const SKIP_DIRS = new Set(['node_modules', 'dist', 'build', 'raw', 'test-results', 'coverage']);
+export const MAX_FILES = 500;
+export const MAX_DEPTH = 8;
+export function mediaFiles(paths) {
+    const out = [];
+    let capped = false;
+    const walk = (p, depth) => {
+        if (out.length >= MAX_FILES) {
+            capped = true;
+            return;
+        }
+        let st;
+        try {
+            st = statSync(p);
+        }
+        catch {
+            return;
+        }
+        if (st.isFile()) {
+            if (tradeOfFile(p) && !out.includes(p))
+                out.push(p);
+            return;
+        }
+        if (!st.isDirectory() || depth > MAX_DEPTH)
+            return;
+        for (const f of readdirSync(p).sort()) {
+            if (f.startsWith('.') || SKIP_DIRS.has(f))
+                continue;
+            walk(join(p, f), depth + 1);
+        }
+    };
+    for (const p of paths)
+        walk(resolve(p), 0);
+    return { files: out, capped };
+}
+export function projectRoot(path) {
+    const abs = resolve(path);
+    let dir = existsSync(abs) && statSync(abs).isFile() ? dirname(abs) : abs;
+    const start = dir;
+    const home = homedir();
+    for (let i = 0; i < 12; i++) {
+        if (existsSync(join(dir, 'funpixel.json')) || existsSync(join(dir, 'design', 'status.json')) || (existsSync(join(dir, 'design')) && statSync(join(dir, 'design')).isDirectory()))
+            return dir;
+        const up = dirname(dir);
+        if (up === dir || dir === home)
+            break;
+        dir = up;
+    }
+    return start;
+}
+export const named = (file, words) => new RegExp(`(^|[/_. -])(${words})([/_. -]|\\d|$)`, 'i').test(file.replace(/\\/g, '/').replace(extname(file), ''));
+export const stem = (file) => basename(file, extname(file));
+let ffmpegKnown = null;
+export function hasFfmpeg() {
+    if (ffmpegKnown === null) {
+        const ok = (cmd) => { try {
+            return spawnSync(cmd, ['-version'], { stdio: 'ignore', timeout: 10_000 }).status === 0;
+        }
+        catch {
+            return false;
+        } };
+        ffmpegKnown = ok('ffmpeg') && ok('ffprobe');
+    }
+    return ffmpegKnown;
+}
+export function probe(file) {
+    const r = spawnSync('ffprobe', ['-v', 'error', '-show_entries', 'stream=index,codec_type,codec_name,pix_fmt,width,height,r_frame_rate,duration:stream_side_data=rotation:format=duration', '-of', 'json', file], { encoding: 'utf8', timeout: 30_000 });
+    if (r.status !== 0)
+        return { error: firstLine(r.stderr) || `ffprobe exit ${r.status}` };
+    try {
+        const j = JSON.parse(r.stdout);
+        const d = Number(j.format?.duration);
+        return { streams: Array.isArray(j.streams) ? j.streams : [], duration: Number.isFinite(d) ? d : null };
+    }
+    catch {
+        return { error: 'ffprobe printed no JSON' };
+    }
+}
+export const firstLine = (s) => (s ?? '').split('\n').map((l) => l.replace(/^\[[^\]]*@ 0x[0-9a-f]+\]\s*/i, '').trim()).find(Boolean)?.slice(0, 160) ?? '';
+export function decodeErrors(file, args = ['-map', '0']) {
+    const r = spawnSync('ffmpeg', ['-hide_banner', '-nostats', '-v', 'error', '-i', file, ...args, '-f', 'null', '-'], { encoding: 'utf8', timeout: 300_000 });
+    const lines = (r.stderr ?? '').split('\n').map((l) => l.replace(/^\[[^\]]*@ 0x[0-9a-f]+\]\s*/i, '').trim()).filter(Boolean);
+    if (r.status !== 0 && !lines.length)
+        lines.push(`ffmpeg exit ${r.status ?? 'killed'}`);
+    return [...new Set(lines)];
+}
+export const round1 = (n) => Math.round(n * 10) / 10;
+export const round2 = (n) => Math.round(n * 100) / 100;