demobites 1.33.0 → 1.35.0

package/launcher/index.mjs

@@ -714,10 +714,24 @@ if (arg === "listen") {
     await event(job.id, "ready", { forgot: site, machine: name });
     noteState({ busy: false, job: null, last_error: null });
   };
+  // THE SESSION MOVES (2026-10-18, their consent in the app): this machine exports the sign-in its profile holds
+  // at the job's site and hands it to the vault with its own key. Counts come back; nothing else is said.
+  const runVault = async (job) => {
+    noteState({ busy: true, job: job.id });
+    await event(job.id, "started", { machine: name });
+    const env = { ...process.env, RECORDER_BASE: base, ...profileFor(job) };
+    const r = spawnSync(process.execPath, [path.join(dest, "scripts", "export-session.mjs"), env.RECORDER_PROFILE || path.join(process.cwd(), ".recorder", "profile"), job.url], { cwd: process.cwd(), encoding: "utf8", env });
+    const line = (r.stdout || "").trim().split("\n").filter((l) => l.startsWith("RESULT ")).pop();
+    let out = null; try { out = JSON.parse(line.slice(7)); } catch { /* none */ }
+    if (r.status === 0 && out) { console.log(`  ○ Your sign-in at ${new URL(job.url).host} is in the vault for the cloud (${out.cookies} cookies).`); await event(job.id, "ready", { ...out, machine: name }); }
+    else { const why = (r.stderr || r.stdout || "").trim().split("\n").pop() || `exit ${r.status}`; console.log(`  ! The sign-in could not be moved: ${why}`); await event(job.id, "failed", { message: r.status === 3 ? "No sign-in at that site on this machine yet" : `The sign-in could not be moved (${why.slice(0, 120)})` }); }
+    noteState({ busy: false, job: null, last_error: null });
+  };
   const runJob = async (job) => {
     waitOff();
     if (job.kind === "off") return runOff(job);
     if (job.kind === "forget") return runForget(job);
+    if (job.kind === "vault") return runVault(job);
     if (job.kind === "look" || job.kind === "signin" || job.kind === "signout") return runLookOrSignin(job);
     const model = typeof job.model === "string" && job.model ? job.model : JOB_MODEL;
     // Alive while filming (1.13.1): a heartbeat every 5 s so the rail never shows this machine
@@ -796,6 +810,13 @@ if (arg === "listen") {
   }
 }
 
+// ── 2c. THE POOL (2026-10-18): a box of ours, many workspaces, no key of its own ──────────────
+//   demobite pool --base <url> --secret <pool secret> [--slots N] [--name <box>]
+if (arg === "pool") {
+  const r = spawnSync(process.execPath, [path.join(dest, "scripts", "pool.mjs"), ...process.argv.slice(3)], { stdio: "inherit", cwd: process.cwd(), env: process.env });
+  process.exit(r.status ?? 0);
+}
+
 // ── 3. Subcommands ─────────────────────────────────────────────────────────
 if (arg === "login" || arg === "logout") {
   // `login <base>` forwards the base (dev, a preview) to login.mjs, which

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "demobites",
-  "version": "1.33.0",
+  "version": "1.35.0",
   "description": "The DemoBites agentic recorder — you prompt, it films a real browser, and DemoBites turns the take into an editable demo bite.",
   "bin": {
     "demobites": "launcher/index.mjs"

package/scripts/calibrate.mjs

@@ -90,7 +90,7 @@ function bboxCrossing(step) {
   return cross;
 }
 
-function roiChanges(bb) {
+function roiChanges(bb, around) {
   // ONSETS of visible change inside the padded bbox crop, in video time.
   // Not threshold crossings: hover styles animate (LinkedIn fades its row
   // background over ~150ms), and a threshold detector fires mid-fade —
@@ -101,14 +101,19 @@ function roiChanges(bb) {
   const pad = 6;
   const x0 = Math.max(0, bb.x - pad), y0 = Math.max(0, bb.y - pad);
   const w = Math.min(FRAME.w - x0, bb.w + 2 * pad), h = Math.min(FRAME.h - y0, bb.h + 2 * pad);
+  // ONLY THE WINDOW THAT MATTERS (2026-10-18: six anchors decoded the whole take six times, 48 s on the founder's
+  // Air). The caller keeps changes within [pred - 3.2, pred + 1.2]; the decode starts 3.6 s before the prediction and
+  // runs 5.2 s. Seeking the mp4 before the input is frame-accurate (decode from the keyframe, drop until the mark),
+  // and the reported pts restart at 0, so the window's start is added back.
+  const from = around == null ? 0 : Math.max(0, around - 3.6);
   const res = spawnSync(FFMPEG(), [
-    "-loglevel", "info", "-i", clean,
+    "-loglevel", "info", ...(around == null ? [] : ["-ss", String(from), "-t", "5.2"]), "-i", clean,
     "-vf", `crop=${w}:${h}:${x0}:${y0},select='gte(scene,0)',metadata=print`, "-f", "null", "-",
   ], { encoding: "utf8", maxBuffer: 256 * 1024 * 1024 });
   const err = `${res.stderr ?? ""}`;
   const rows = [];
   const re = /pts_time:([0-9.]+)[\s\S]*?lavfi\.scene_score=([0-9.]+)/g;
-  for (let m; (m = re.exec(err)); ) rows.push({ t: parseFloat(m[1]), s: parseFloat(m[2]) });
+  for (let m; (m = re.exec(err)); ) rows.push({ t: parseFloat(m[1]) + from, s: parseFloat(m[2]) });
   const onsets = [];
   for (let i = 1; i < rows.length; i++) {
     if (rows[i].s < 0.004) continue;               // not a peak-worthy change
@@ -126,7 +131,7 @@ for (const s of man.steps ?? []) {
   const wallCross = bboxCrossing(s);
   if (wallCross == null) continue;
   const pred = tb.a * wallCross + tb.b;
-  const changes = roiChanges(s.target.bbox).filter((c) => c >= pred - 3.2 && c <= pred + 1.2);
+  const changes = roiChanges(s.target.bbox, pred).filter((c) => c >= pred - 3.2 && c <= pred + 1.2);
   if (changes.length === 0) continue;
   anchors.push({ label: s.label ?? s.action, pred, changes, weight: 1 / Math.sqrt(changes.length) });
 }

package/scripts/export-session.mjs

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+// THE SESSION MOVES, NEVER THE CREDENTIALS (founder 2026-10-18, with the person's consent in the app): read the
+// cookies and local storage the app set in the recorder's OWN Chrome profile — ours to drive; never the keychain,
+// never a password — for the one site asked, and hand them to the vault with this machine's key. The vault answers
+// with counts; nothing of the session is printed here.
+// usage: node export-session.mjs <profileDir> <url>      (base and key from <cwd>/.recorder/config.json)
+import fs from "node:fs";
+import path from "node:path";
+const [profileDir, url] = process.argv.slice(2);
+if (!profileDir || !url) { console.error("usage: export-session.mjs <profileDir> <url>"); process.exit(2); }
+const cfg = JSON.parse(fs.readFileSync(path.resolve(process.cwd(), ".recorder", "config.json"), "utf8"));
+const base = (process.env.RECORDER_BASE || cfg.base || "https://app.demobites.com").replace(/\/+$/, "");
+const { chromium } = await import("playwright");
+const origin = new URL(url).origin;
+const host = new URL(url).hostname;
+const site = host.split(".").slice(-2).join(".");
+const ctx = await chromium.launchPersistentContext(path.resolve(profileDir), { channel: "chrome", headless: true, viewport: { width: 1280, height: 800 } });
+let state;
+try {
+  const page = await ctx.newPage();
+  await page.goto(origin, { waitUntil: "domcontentloaded", timeout: 30000 }).catch(() => {});
+  const cookies = (await ctx.cookies()).filter((c) => c.domain.replace(/^\./, "").endsWith(site));
+  const localStorage = await page.evaluate(() => Object.entries(window.localStorage).map(([name, value]) => ({ name, value }))).catch(() => []);
+  state = { cookies, origins: [{ origin, localStorage }] };
+} finally { await ctx.close(); }
+if (!state.cookies.length && !state.origins[0].localStorage.length) { console.error(`no session at ${origin} in this profile`); process.exit(3); }
+const res = await fetch(`${base}/api/recorder/session`, { method: "PUT", headers: { "Content-Type": "application/json", Authorization: `Bearer ${cfg.api_key}` }, body: JSON.stringify({ url: origin, state, label: "From my machine" }) });
+const d = await res.json().catch(() => ({}));
+if (!res.ok) { console.error(`the vault refused: ${d.error ?? res.status}`); process.exit(1); }
+console.log(`RESULT ${JSON.stringify({ cookies: d.cookies ?? state.cookies.length, origins: d.origins ?? 1, profile_id: d.profile_id ?? null })}`);

package/scripts/pool.mjs

@@ -0,0 +1,114 @@
+#!/usr/bin/env node
+// THE POOL (founder 2026-10-18: "every user will install the inner one on his machine; the second one is a unique
+// key he never sees… a pool that you're managing behind the scenes"). A box of OURS: it checks in with the pool
+// secret, claims any workspace's cloud job, receives that job's cloud key and the person's session for the length
+// of the take, runs the same chain the laptop runs (plan → record → trim → measure → pack → upload) in a folder of
+// its own, and shreds the folder when the take is up. Ten identities on one box, none written where a neighbour
+// could read them. A reclaim or a drain order stops new claims; running takes finish.
+//
+//   node pool.mjs --base https://dev.demobites.com --secret <pool secret> [--slots 5] [--name <box name>]
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+const argv = process.argv.slice(2);
+const flag = (f, d = "") => (argv.includes(f) ? argv[argv.indexOf(f) + 1] ?? d : d);
+const base = (flag("--base", process.env.RECORDER_BASE || "https://app.demobites.com")).replace(/\/+$/, "");
+const secret = flag("--secret", process.env.POOL_SECRET || "");
+if (!secret) { console.error("pool: --secret (or POOL_SECRET) is required"); process.exit(2); }
+const HOME = process.env.DEMOBITE_POOL_HOME || path.join(os.homedir(), ".demobite", "pool");
+fs.mkdirSync(HOME, { recursive: true });
+const stamp = () => new Date().toISOString();
+let version = "?"; try { version = JSON.parse(fs.readFileSync(path.join(HERE, "..", "package.json"), "utf8")).version; } catch { try { version = JSON.parse(fs.readFileSync(path.join(HERE, "package.json"), "utf8")).version; } catch { /* unknown */ } }
+
+// WHO AM I: the instance's own id and type from the metadata service (IMDSv2), the hostname otherwise.
+const imds = async (p) => {
+  try {
+    const t = await fetch("http://169.254.169.254/latest/api/token", { method: "PUT", headers: { "X-aws-ec2-metadata-token-ttl-seconds": "60" }, signal: AbortSignal.timeout(1500) });
+    if (!t.ok) return null;
+    const r = await fetch(`http://169.254.169.254/latest/meta-data/${p}`, { headers: { "X-aws-ec2-metadata-token": await t.text() }, signal: AbortSignal.timeout(1500) });
+    return r.ok ? (await r.text()).trim() : null;
+  } catch { return null; }
+};
+const instanceId = (await imds("instance-id")) || `local-${os.hostname()}`;
+const instanceType = (await imds("instance-type")) || "local";
+const name = flag("--name", instanceId);
+// CAPACITY (the matrix, measured 2026-10-18 on c7i.2xlarge: 10 clean, 5 within ~90 s end to end): comfort slots by type.
+const COMFORT = { "2xlarge": 5, "4xlarge": 10, "8xlarge": 20, "xlarge": 2, "large": 1 };
+const sizeOf = (t) => Object.keys(COMFORT).find((k) => t.endsWith(`.${k}`));
+const slots = Number(flag("--slots", "")) || COMFORT[sizeOf(instanceType) ?? ""] || Math.max(1, Math.floor(os.cpus().length * 0.6));
+
+const api = async (body) => {
+  try {
+    const res = await fetch(`${base}/api/recorder/pool`, { method: "PUT", headers: { "Content-Type": "application/json", Authorization: `Bearer ${secret}` }, body: JSON.stringify({ instance_id: instanceId, instance_type: instanceType, name, slots, version, ...body }), signal: AbortSignal.timeout(20000) });
+    if (res.status === 401) { console.error(`  ${stamp()} the pool secret was refused; stopping`); process.exit(1); }
+    return res.ok ? await res.json() : null;
+  } catch (e) { console.error(`  ${stamp()} pool: ${String(e?.message ?? e).split("\n")[0]}`); return null; }
+};
+
+const running = new Map(); // job id → child
+let draining = false;
+const shred = (dir) => { try { fs.rmSync(dir, { recursive: true, force: true }); } catch { /* best effort */ } };
+
+const runJob = async (claim) => {
+  const job = claim.job;
+  // The take's own door, with the job's cloud key (what a laptop's listener does with its own key).
+  const jobApi = async (body) => { try { const r = await fetch(`${base}/api/recorder/listen`, { method: "PUT", headers: { "Content-Type": "application/json", Authorization: `Bearer ${claim.key}` }, body: JSON.stringify({ job_id: job.id, ...body }), signal: AbortSignal.timeout(20000) }); return r.ok ? await r.json() : null; } catch { return null; } };
+  const dir = path.join(HOME, job.id);
+  const rec = path.join(dir, ".recorder");
+  const profile = path.join(dir, "profile");
+  const ledger = path.join(dir, "ledger.json");
+  const takeDir = path.join(rec, "takes", job.id);
+  const t0 = Date.now();
+  try {
+    fs.mkdirSync(takeDir, { recursive: true });
+    // The job's cloud key: the person's authority to put the take in their workspace, for this folder only.
+    fs.writeFileSync(path.join(rec, "config.json"), JSON.stringify({ base, api_key: claim.key, workspace: claim.workspace ?? null, pool: true }), { mode: 0o600 });
+    fs.writeFileSync(path.join(takeDir, "job.json"), JSON.stringify({ id: job.id, brief: job.brief, url: job.url ?? null, model: job.model ?? null, review_storyboard: job.review_storyboard !== false, code_repo: job.code_repo ?? null, retake_of: job.retake_of ?? null, retake_note: job.retake_note ?? null, storyboard: job.storyboard ?? null, cloud: true }, null, 2));
+    // The person's session → a profile of this take's own; the ledger says the site is signed in so no window opens.
+    const origins = {};
+    for (const o of claim.session?.origins ?? []) if (o?.origin) origins[o.origin] = new Date().toISOString();
+    try { if (job.url) origins[new URL(job.url).origin] = origins[new URL(job.url).origin] ?? new Date().toISOString(); } catch { /* no url */ }
+    fs.writeFileSync(ledger, JSON.stringify({ origins, who: {} }, null, 2));
+    const sessionFile = path.join(dir, "session.json");
+    fs.writeFileSync(sessionFile, JSON.stringify(claim.session ?? { cookies: [], origins: [] }), { mode: 0o600 });
+    console.log(`\n  ▶ ${stamp()} job ${job.id} (${claim.workspace?.name ?? "workspace"}): ${String(job.brief).slice(0, 90)}…`);
+    await new Promise((resolve) => { const s = spawn(process.execPath, [path.join(HERE, "seed-profile.mjs"), profile, sessionFile], { stdio: "inherit", cwd: dir }); s.on("close", resolve); });
+    shred(sessionFile);
+    const child = spawn(process.execPath, [path.join(HERE, "plan.mjs"), takeDir], {
+      cwd: dir, stdio: "inherit",
+      env: { ...process.env, RECORDER_JOB: job.id, RECORDER_BASE: base, RECORDER_LISTEN: "1", RECORDER_PROFILE: profile, RECORDER_LEDGER: ledger, DEMOBITES_NO_CODE: "1", RECORDER_POOL: instanceId },
+      detached: process.platform !== "win32",
+    });
+    running.set(job.id, child);
+    const code = await new Promise((resolve) => child.on("close", resolve));
+    const st = await jobApi({ action: "poll" });
+    if (st && st.status && !["ready", "failed", "cancelled"].includes(st.status)) await jobApi({ action: "event", kind: "failed", payload: { message: code === 0 ? "The demo did not come through — try again" : `The take stopped (exit ${code})` } });
+    console.log(`  ■ ${stamp()} job ${job.id} ${st?.status ?? "ended"} in ${Math.round((Date.now() - t0) / 1000)} s\n`);
+  } catch (e) {
+    console.error(`  ! ${stamp()} job ${job.id}: ${String(e?.message ?? e).split("\n")[0]}`);
+    await jobApi({ action: "event", kind: "failed", payload: { message: `The cloud recorder could not run the take (${String(e?.message ?? e).slice(0, 120)})` } });
+  } finally {
+    running.delete(job.id);
+    shred(dir); // the key, the session, the profile, the take: gone with the folder
+    await api({ action: "checkin", busy: [...running.keys()], draining });
+  }
+};
+
+const bye = () => { draining = true; for (const c of running.values()) { try { process.kill(process.platform === "win32" ? c.pid : -c.pid, "SIGTERM"); } catch { /* gone */ } } setTimeout(() => process.exit(0), 1500); };
+process.on("SIGTERM", bye); process.on("SIGINT", bye);
+
+console.log(`demobite pool ${version} — ${name} (${instanceType}), ${slots} cameras, ${base}`);
+for (;;) {
+  const r = await api({ action: "checkin", busy: [...running.keys()], draining });
+  if (r?.drain && !draining) { draining = true; console.log(`  ${stamp()} drain: no new takes; ${running.size} still running`); }
+  if (r?.stop && running.size === 0) { console.log(`  ${stamp()} stop: the pool says goodbye`); process.exit(0); }
+  if (!draining && running.size < slots) {
+    const c = await api({ action: "claim" });
+    if (c?.job && c?.key) { void runJob(c); await new Promise((s) => setTimeout(s, 1500)); continue; }
+  }
+  await new Promise((s) => setTimeout(s, 5000));
+}

package/scripts/seed-profile.mjs

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+// SEED A PROFILE FROM A SESSION (the cloud pool, 2026-10-18): the person's session (a Playwright storageState:
+// cookies and local storage, exported from their own machine with their consent) becomes a fresh Chrome profile
+// the planner's look, probe and the camera all drive. Nothing else goes in; the folder is shredded after the take.
+// usage: node seed-profile.mjs <profileDir> <session.json>
+import fs from "node:fs";
+import path from "node:path";
+const [profileDir, sessionFile] = process.argv.slice(2);
+if (!profileDir || !sessionFile) { console.error("usage: seed-profile.mjs <profileDir> <session.json>"); process.exit(2); }
+const state = JSON.parse(fs.readFileSync(sessionFile, "utf8"));
+const { chromium } = await import("playwright");
+fs.mkdirSync(profileDir, { recursive: true });
+const ctx = await chromium.launchPersistentContext(path.resolve(profileDir), { channel: "chrome", headless: true, viewport: { width: 1280, height: 800 } });
+try {
+  const cookies = (state.cookies ?? []).map((c) => ({ ...c, sameSite: ["Strict", "Lax", "None"].includes(c.sameSite) ? c.sameSite : "Lax" }));
+  if (cookies.length) await ctx.addCookies(cookies);
+  const page = await ctx.newPage();
+  for (const o of state.origins ?? []) {
+    if (!o?.origin || !o.localStorage?.length) continue;
+    try {
+      await page.goto(o.origin, { waitUntil: "domcontentloaded", timeout: 20000 });
+      await page.evaluate((items) => { for (const { name, value } of items) window.localStorage.setItem(name, value); }, o.localStorage);
+    } catch (e) { console.log(`seed: local storage for ${o.origin} skipped (${String(e?.message ?? e).split("\n")[0]})`); }
+  }
+  console.log(`seeded ${cookies.length} cookies and ${(state.origins ?? []).reduce((n, o) => n + (o.localStorage?.length ?? 0), 0)} local-storage keys`);
+} finally { await ctx.close(); }

package/scripts/trim.mjs

@@ -40,7 +40,7 @@ const clean = path.join(dir, "clean.mp4");
 // tail into a fake 1.027x, and a scene-change fit anchored on a modal that
 // took 0.49s to load tilted 0.897x. Both produced ramps of error that read as
 // a broken cursor.
-const r0 = man.record_from ?? 0;
+let r0 = man.record_from ?? 0;
 
 // Head-beacon phase 0: the identity law above fixes the RATE; the beacon
 // fixes the ANCHOR. record.mjs flashed the blank page full-frame at stamped
@@ -105,7 +105,36 @@ if ((man.beacon?.flips?.length ?? 0) >= 3) {
   }
 }
 
-const cutAt = Math.max(0, r0 - beaconDelta);
+let cutAt = Math.max(0, r0 - beaconDelta);
+
+// THE FIRST FRAME IS A LOADED PAGE (founder 2026-10-18, bite 1236: "you started without the In-app Pulse loaded…
+// after 3 seconds everything is loaded… use the trim at the start"). The camera's still-picture gate waits for the
+// outer page; an inner panel can keep loading after it. So the head of the clean take is scanned for visible change
+// in its first seconds, and when the picture kept changing, the cut moves to the last change plus a breath, and
+// record_from moves with it (the timebase stays video = wall - record_from). Bounded at 3.5 s; a still head is
+// untouched.
+const HEAD_SCAN_S = 4.0;
+const HEAD_MAX_SHIFT_S = 3.5;
+try {
+  const res = spawnSync(FFMPEG(), ["-hide_banner", "-loglevel", "info", "-i", raw, "-vf", `trim=start=${cutAt}:end=${cutAt + HEAD_SCAN_S},setpts=PTS-STARTPTS,scale=480:-2,select='gt(scene,0.02)',showinfo`, "-f", "null", "-"], { encoding: "utf8", maxBuffer: 64 * 1024 * 1024 });
+  const changes = [];
+  for (const m of `${res.stderr ?? ""}`.matchAll(/pts_time:([0-9.]+)/g)) changes.push(parseFloat(m[1]));
+  const late = changes.filter((t) => t > 0.3 && t < HEAD_SCAN_S - 0.3);
+  if (late.length) {
+    const shift = Math.min(HEAD_MAX_SHIFT_S, Math.round((late[late.length - 1] + 0.25) * 100) / 100);
+    console.log(`first frame: the picture kept changing for ${late[late.length - 1].toFixed(2)}s after the cut (${late.length} change${late.length === 1 ? "" : "s"}) — cutting ${shift.toFixed(2)}s later, to a loaded page`);
+    void postEvent("finishing", { text: "Cutting to the first loaded frame…" });
+    cutAt += shift;
+    r0 += shift;
+    man.record_from = r0;
+    man.first_frame_shift_s = shift;
+    // Nothing in the story happens before its first frame.
+    for (const st of man.steps ?? []) { if (Number(st.t_start) < r0) st.t_start = r0; if (Number(st.t_end) < r0) st.t_end = r0; }
+    for (const sh of man.shots ?? []) { if (Number(sh.t_start) < r0) sh.t_start = r0; }
+  } else console.log(`first frame: still (${changes.length} change${changes.length === 1 ? "" : "s"} in the first ${HEAD_SCAN_S}s, none after 0.3s)`);
+} catch (e) {
+  console.log(`first frame: scan skipped (${String(e?.message ?? e).split("\n")[0]})`);
+}
 
 // TAIL law (vanilla-Linux smoke 2026-09-09): raw.webm keeps receiving frames
 // while the browser context tears down — on a headless shell that was a
@@ -166,12 +195,23 @@ man.timebase = {
 fs.writeFileSync(manPath, JSON.stringify(man, null, 2));
 console.log(`timebase: video = (wall - ${r0.toFixed(3)})${speed === 1 ? "" : ` / ${speed}`}${beaconMethod ? ` (cut at raw ${cutAt.toFixed(3)}s)` : ""}`);
 
+// THE MACHINE'S OWN ENCODER (founder 2026-10-18: "saving the take… this should be 5 seconds"; the trim took 39.6 s on
+// his Air, most of it libx264 at preset medium). Apple's VideoToolbox encodes the same h264 several times faster;
+// elsewhere libx264 at a faster preset. The ingest wants h264 at 30 fps in an mp4, which both give.
+const ENCODER = (() => {
+  try {
+    const enc = execFileSync(FFMPEG(), ["-hide_banner", "-encoders"], { stdio: ["ignore", "pipe", "ignore"] }).toString();
+    if (process.platform === "darwin" && /\bh264_videotoolbox\b/.test(enc)) return ["-c:v", "h264_videotoolbox", "-b:v", "3M", "-maxrate", "4M", "-bufsize", "8M", "-profile:v", "high", "-allow_sw", "1", "-g", "60"];
+  } catch { /* libx264 */ }
+  return ["-c:v", "libx264", "-preset", "veryfast", "-crf", "19", "-g", "60"];
+})();
+console.log(`encoder: ${ENCODER[1]}`);
 execFileSync(FFMPEG(), [
   "-y", "-loglevel", "error",
   "-i", raw,
   "-filter_complex", `[0:v]trim=${tailCut ? `start=${cutAt}:end=${tailCut}` : `start=${cutAt}`},setpts=(PTS-STARTPTS)/${speed},fps=30,format=yuv420p[out]`,
   "-map", "[out]",
-  "-c:v", "libx264", "-preset", "medium", "-crf", "19",
+  ...ENCODER,
   "-movflags", "+faststart",
   clean,
 ], { stdio: "inherit" });
@@ -184,7 +224,7 @@ execFileSync(FFMPEG(), [
 try {
   const filters = execFileSync(FFMPEG(), ["-hide_banner", "-filters"], { stdio: ["ignore", "pipe", "ignore"] }).toString();
   if (/\bfreezeframes\b/.test(filters) && /\bsignalstats\b/.test(filters)) {
-    const stats = spawnSync(FFMPEG(), ["-hide_banner", "-loglevel", "error", "-i", clean, "-vf", "crop=iw/2:ih/2:iw/2:ih/2,signalstats,metadata=print:file=-", "-f", "null", "-"], { encoding: "utf8", maxBuffer: 64 * 1024 * 1024 });
+    const stats = spawnSync(FFMPEG(), ["-hide_banner", "-loglevel", "error", "-i", clean, "-vf", "crop=iw/2:ih/2:iw/2:ih/2,scale=240:-2,signalstats,metadata=print:file=-", "-f", "null", "-"], { encoding: "utf8", maxBuffer: 64 * 1024 * 1024 });
     const bad = [];
     let frame = -1, yavg = null, ymin = null, ymax = null;
     const flush = () => { if (frame >= 0 && yavg !== null && yavg >= 118 && yavg <= 138 && ymin !== null && ymax !== null && ymax - ymin <= 24) bad.push(frame); };
@@ -208,7 +248,7 @@ try {
       graph += `[a${chain.length}]format=yuv420p[out]`;
       const fixed = path.join(dir, "clean-fixed.mp4");
       void postEvent("finishing", { text: `Replacing ${bad.length} glitch frame${bad.length === 1 ? "" : "s"}…` });
-      execFileSync(FFMPEG(), ["-y", "-loglevel", "error", "-i", clean, "-filter_complex", graph, "-map", "[out]", "-c:v", "libx264", "-preset", "medium", "-crf", "19", "-movflags", "+faststart", fixed], { stdio: "inherit" });
+      execFileSync(FFMPEG(), ["-y", "-loglevel", "error", "-i", clean, "-filter_complex", graph, "-map", "[out]", ...ENCODER, "-movflags", "+faststart", fixed], { stdio: "inherit" });
       fs.renameSync(fixed, clean);
       man.glitch = { frames: bad.length, windows: chain.map((r) => ({ first: r.first, last: r.last })) };
       fs.writeFileSync(manPath, JSON.stringify(man, null, 2));