@prestyj/cli 5.27.0 → 5.28.1

package/assets/motion/assets/sfx/sfx-analysis.md

@@ -0,0 +1,75 @@
+# SFX Analysis Summary
+
+Source: [Nolanney](https://kenney.nl/).
+
+Use this as planning guidance for choosing tasteful SFX. Prefer low/medium high-frequency risk sounds for polished videos; reserve bright/high-risk files for tiny accents, chaotic tones, or deliberate glitches.
+
+## Signal Guide
+
+- `brightness`: warm / balanced / bright, based on spectral centroid and high-frequency energy.
+- `highFrequencyRisk`: low / medium / high. High-risk SFX can feel sharp, hissy, clicky, or fatiguing if repeated.
+- `brightBurden`: high-frequency energy weighted by level and duration. This separates sustained glassy ringing from short clicks.
+- `highActiveDuration`: how long bright energy stays active above a useful level.
+- `envelopeShape`: transient / textured / continuous. Continuous bright sounds are more fatiguing than sparse textured sounds.
+- `transient.sharpness`: higher values feel clickier or more percussive.
+- `duration`: short sounds work for UI and typing; longer sounds work for reveals and transitions.
+
+## Safest General Picks
+
+- `impact/impactSoft_medium_001.ogg` — 0.18s, warm, low HF risk, transient; use for hard transition, major reveal
+- `impact/impactSoft_medium_004.ogg` — 0.15s, warm, low HF risk, transient; use for hard transition, major reveal
+- `impact/impactSoft_medium_002.ogg` — 0.14s, warm, low HF risk, transient; use for hard transition, major reveal
+- `interface/bong_001.ogg` — 0.12s, warm, low HF risk, textured; use for general accent
+- `impact/impactSoft_medium_003.ogg` — 0.14s, warm, low HF risk, textured; use for hard transition, major reveal
+- `impact/impactSoft_medium_000.ogg` — 0.12s, warm, low HF risk, textured; use for hard transition, major reveal
+- `interface/click_003.ogg` — 0.01s, balanced, low HF risk, continuous; use for button press, selection, simulated user action
+- `interface/click_002.ogg` — 0.01s, balanced, low HF risk, continuous; use for button press, selection, simulated user action
+- `interface/click_005.ogg` — 0.01s, balanced, low HF risk, continuous; use for button press, selection, simulated user action
+- `ui/click2.ogg` — 0.06s, balanced, low HF risk, continuous; use for button press, selection, simulated user action
+- `ui/rollover2.ogg` — 0.06s, balanced, low HF risk, continuous; use for general accent
+- `interface/glitch_002.ogg` — 0.03s, bright, low HF risk, continuous; use for chaotic accent, comedic interruption, tiny accent only
+- `impact/impactSoft_heavy_003.ogg` — 0.54s, warm, medium HF risk, transient; use for hard transition, major reveal
+- `impact/impactSoft_heavy_004.ogg` — 0.50s, warm, medium HF risk, transient; use for hard transition, major reveal
+- `impact/impactSoft_heavy_002.ogg` — 0.57s, warm, medium HF risk, transient; use for hard transition, major reveal
+- `impact/impactSoft_heavy_001.ogg` — 0.57s, warm, medium HF risk, transient; use for hard transition, major reveal
+- `impact/impactSoft_heavy_000.ogg` — 0.51s, warm, medium HF risk, transient; use for hard transition, major reveal
+- `impact/footstep_wood_004.ogg` — 0.25s, warm, medium HF risk, transient; use for general accent
+- `impact/footstep_wood_002.ogg` — 0.25s, warm, medium HF risk, transient; use for general accent
+- `impact/footstep_wood_000.ogg` — 0.25s, warm, medium HF risk, transient; use for general accent
+- `impact/footstep_wood_001.ogg` — 0.25s, warm, medium HF risk, transient; use for general accent
+- `impact/impactWood_medium_003.ogg` — 0.33s, warm, medium HF risk, transient; use for hard transition, major reveal
+- `impact/impactWood_medium_001.ogg` — 0.33s, warm, medium HF risk, transient; use for hard transition, major reveal
+- `impact/impactWood_medium_000.ogg` — 0.33s, warm, medium HF risk, transient; use for hard transition, major reveal
+
+## Lower-Risk Picks By Use Case
+
+- button press: `interface/click_003.ogg` (low), `interface/click_002.ogg` (low), `interface/click_005.ogg` (low), `ui/click2.ogg` (low), `interface/click_001.ogg` (medium)
+- selection: `interface/click_003.ogg` (low), `interface/click_002.ogg` (low), `interface/click_005.ogg` (low), `ui/click2.ogg` (low), `interface/click_001.ogg` (medium)
+- toggle: `interface/switch_007.ogg` (medium), `interface/switch_002.ogg` (medium), `interface/switch_006.ogg` (medium), `interface/switch_005.ogg` (medium), `ui/switch11.ogg` (medium)
+- card reveal: `casino/card-slide-1.ogg` (medium), `casino/card-place-1.ogg` (high), `casino/card-fan-2.ogg` (high), `casino/card-slide-8.ogg` (high), `casino/card-slide-3.ogg` (high)
+- swipe: `casino/card-slide-1.ogg` (medium), `casino/card-place-1.ogg` (high), `casino/card-fan-2.ogg` (high), `casino/card-slide-8.ogg` (high), `casino/card-slide-3.ogg` (high)
+- sequential item: `casino/card-slide-1.ogg` (medium), `casino/card-place-1.ogg` (high), `casino/card-fan-2.ogg` (high), `casino/card-slide-8.ogg` (high), `casino/card-slide-3.ogg` (high)
+- panel opening: `casino/cards-pack-open-1.ogg` (high), `casino/cards-pack-open-2.ogg` (high)
+- soft reveal: `casino/cards-pack-open-1.ogg` (high), `casino/cards-pack-open-2.ogg` (high)
+- success: `impact/impactBell_heavy_000.ogg` (medium), `impact/impactBell_heavy_003.ogg` (medium), `impact/impactBell_heavy_004.ogg` (medium)
+- logo payoff: `impact/impactBell_heavy_000.ogg` (medium), `impact/impactBell_heavy_003.ogg` (medium), `impact/impactBell_heavy_004.ogg` (medium)
+- reveal confirmation: `impact/impactBell_heavy_000.ogg` (medium), `impact/impactBell_heavy_003.ogg` (medium), `impact/impactBell_heavy_004.ogg` (medium)
+- major reveal: `impact/impactSoft_medium_001.ogg` (low), `impact/impactSoft_medium_004.ogg` (low), `impact/impactSoft_medium_002.ogg` (low), `impact/impactSoft_medium_003.ogg` (low), `impact/impactSoft_medium_000.ogg` (low)
+- hard transition: `impact/impactSoft_medium_001.ogg` (low), `impact/impactSoft_medium_004.ogg` (low), `impact/impactSoft_medium_002.ogg` (low), `impact/impactSoft_medium_003.ogg` (low), `impact/impactSoft_medium_000.ogg` (low)
+- chaotic accent: `interface/glitch_002.ogg` (low), `interface/error_005.ogg` (medium), `interface/error_006.ogg` (medium), `interface/glitch_004.ogg` (medium)
+
+## Family Summary
+
+- `casino/`: 51 files; HF risk low/medium/high = 0/10/41; avg high-frequency energy 0.59
+- `impact/`: 109 files; HF risk low/medium/high = 5/104/0; avg high-frequency energy 0.08
+- `interface/`: 20 files; HF risk low/medium/high = 5/14/1; avg high-frequency energy 0.25
+- `ui/`: 48 files; HF risk low/medium/high = 2/14/32; avg high-frequency energy 0.57
+
+## Selection Rules
+
+- Prefer low-risk SFX for repeated UI actions, text ticks, and dense sequences.
+- Use medium-risk SFX for isolated reveals or when the motion needs a crisp edge.
+- Avoid high-risk SFX for repeated ticks, long sequences, or polished/deadpan tones.
+- Treat continuous bright SFX as more fatiguing than sparse/textured bright SFX.
+- If using a bright SFX, keep it short, quiet, and isolated.
+- Match SFX timing to the visual landing or start depending on the gesture: clicks at press/start, reveals at resolution/payoff.

package/assets/motion/bin/contact-sheet.mjs

@@ -0,0 +1,87 @@
+#!/usr/bin/env node
+// EZ Motion contact sheet: tile frame PNGs into one labeled grid image so a
+// critique pass costs one image read instead of N (each image read re-prices
+// the whole context). `hf snapshot` already writes a full-size sheet; the
+// main use here is --phone, which shows the same frames at phone size.
+//
+// Usage: node contact-sheet.mjs <frames-dir> <out.jpg> [--cols 4] [--width 1600] [--phone]
+// Frames are ordered by the number in their filename (seconds or index).
+// Uses the `sharp` build that ships inside GG's bundled HyperFrames.
+import { readdir, stat } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { basename, dirname, extname, join, resolve } from "node:path";
+
+function fail(message) {
+  process.stderr.write(`${message}\n`);
+  process.exit(1);
+}
+
+const args = process.argv.slice(2);
+const positional = args.filter((a, i) => !a.startsWith("--") && !args[i - 1]?.match(/^--(cols|width)$/));
+const [framesArg, outArg] = positional;
+if (!framesArg || !outArg) {
+  fail("usage: contact-sheet.mjs <frames-dir> <out.jpg> [--cols 4] [--width 1600] [--phone]");
+}
+const flag = (name, fallback) => {
+  const i = args.indexOf(`--${name}`);
+  const value = i >= 0 ? Number(args[i + 1]) : fallback;
+  if (!Number.isFinite(value) || value <= 0) fail(`--${name} must be a positive number`);
+  return value;
+};
+const phone = args.includes("--phone");
+const cols = flag("cols", phone ? 6 : 4);
+// A phone is ~390pt wide; a phone-strip cell is that width so text reads as it would on a feed.
+const sheetWidth = flag("width", phone ? 390 * cols : 1600);
+
+let sharp;
+try {
+  const require = createRequire(import.meta.url);
+  const hfPkg = require.resolve("hyperframes/package.json");
+  sharp = createRequire(hfPkg)("sharp");
+} catch {
+  fail("Contact sheets need the HyperFrames bundled with EZ. Reinstall EZ Coder to restore Motion mode.");
+}
+
+const framesDir = resolve(framesArg);
+const names = await readdir(framesDir).catch(() => fail(`Frames folder not found: ${framesDir}`));
+// Skip sheets from earlier runs (snapshot writes contact-sheet.jpg beside its frames).
+const entries = names.filter((n) => /\.(png|jpe?g|webp)$/i.test(n) && !/contact-sheet|phone-strip/i.test(n));
+if (entries.length === 0) fail(`No frame images in ${framesDir}`);
+const order = (name) => {
+  const m = basename(name, extname(name)).match(/(\d+(?:\.\d+)?)(?!.*\d)/);
+  return m ? Number(m[1]) : Number.POSITIVE_INFINITY;
+};
+entries.sort((a, b) => order(a) - order(b) || a.localeCompare(b));
+
+const gap = 8;
+const labelH = 28;
+const cellW = Math.floor((sheetWidth - gap * (cols + 1)) / cols);
+const first = await sharp(join(framesDir, entries[0])).metadata();
+const cellH = Math.round((cellW * (first.height ?? 9)) / (first.width ?? 16));
+const rows = Math.ceil(entries.length / cols);
+const height = gap + rows * (cellH + labelH + gap);
+
+const escapeXml = (s) => s.replace(/[<>&"']/g, (c) => `&#${c.charCodeAt(0)};`);
+const composites = [];
+for (const [i, name] of entries.entries()) {
+  const x = gap + (i % cols) * (cellW + gap);
+  const y = gap + Math.floor(i / cols) * (cellH + labelH + gap);
+  const tile = await sharp(join(framesDir, name))
+    .resize(cellW, cellH, { fit: "contain", background: "#111" })
+    .toBuffer();
+  composites.push({ input: tile, left: x, top: y });
+  const label = `${i + 1}. ${basename(name, extname(name))}`;
+  const svg = `<svg xmlns="http://www.w3.org/2000/svg" width="${cellW}" height="${labelH}"><text x="4" y="19" font-family="Helvetica, Arial, sans-serif" font-size="15" fill="#ddd">${escapeXml(label)}</text></svg>`;
+  composites.push({ input: Buffer.from(svg), left: x, top: y + cellH });
+}
+
+const out = resolve(outArg);
+const outStat = await stat(dirname(out)).catch(() => null);
+if (!outStat?.isDirectory()) fail(`Output folder does not exist: ${dirname(out)}`);
+await sharp({ create: { width: sheetWidth, height, channels: 3, background: "#1b1b1b" } })
+  .composite(composites)
+  .jpeg({ quality: 82 })
+  .toFile(out);
+process.stdout.write(
+  `${JSON.stringify({ ok: true, frames: entries.length, cols, width: sheetWidth, height, out })}\n`,
+);

package/assets/motion/bin/flash-check.mjs

@@ -0,0 +1,314 @@
+#!/usr/bin/env node
+// Photosensitivity screen on decoded pixels against the WCAG 2.3.1 general and red flash
+// thresholds. As in EA's open-source IRIS tool, an area's mean change only counts on frames
+// where at least a quarter of the area changes, so moving content mostly cancels out rather
+// than reading as flashing. IRIS applies this to the whole screen; here it applies to every
+// WCAG 10° field (a third of the frame each way), so a flash filling part of the frame is
+// caught too. A transition is a move of 0.1 relative luminance (or 20 red units) away from the
+// last peak or valley, as WCAG defines it; more than six in any second fails. Renders above
+// 60 fps are sampled at 60. A screen, not a certification.
+import { spawn } from "node:child_process";
+import { createReadStream } from "node:fs";
+import { stat } from "node:fs/promises";
+import { createHash } from "node:crypto";
+import { once } from "node:events";
+import { resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { ffmpegBinary } from "./media-binaries.mjs";
+
+/** Cells per side of the analysis grid; every aspect ratio maps onto it. */
+export const GRID = 48;
+/** Frames per analysed second; slower renders are repeated, so one second is always 60 frames. */
+export const ANALYSIS_FPS = 60;
+/** WCAG approximates the 10° field as 341×256 px of a 1024×768 screen: a third each way. */
+const FIELD = GRID / 3;
+const FIELD_CELLS = FIELD * FIELD;
+/** A field's change counts once a quarter of it changes. */
+const AREA = 0.25 * FIELD_CELLS;
+const WINDOWS_PER_SIDE = GRID - FIELD + 1;
+const WINDOWS = WINDOWS_PER_SIDE * WINDOWS_PER_SIDE;
+/** More than three flashes (six opposing transitions) within any one second fails. */
+const MAX_TRANSITIONS = 6;
+/** Transitions per field within the trailing second never exceed one per analysed frame. */
+const RING = 64;
+const CELLS = GRID * GRID;
+const FRAME_BYTES = CELLS * 3;
+const CHANNELS = {
+  // Relative luminance 0–1: a 0.1 swing, unless even the darker state is 0.8 or brighter.
+  // A cell has changed once it moves by more than encoding noise (about 1/255 linear).
+  general: { threshold: 0.1, darkLimit: 0.8, noise: 0.004 },
+  // WCAG's red measure: (R − G − B) × 320 where R / (R + G + B) ≥ 0.8, else 0.
+  red: { threshold: 20, darkLimit: Infinity, noise: 1 },
+};
+/** sRGB to linear light, applied before averaging so mixed cells keep their real brightness. */
+const LINEAR = "if(lte(val,10.31475),val/12.92,255*pow((val/255+0.055)/1.055,2.4))";
+
+function createChannel({ threshold, darkLimit, noise }) {
+  const side = GRID + 1;
+  const changed = new Float64Array(side * side);
+  const change = new Float64Array(side * side);
+  const level = new Float64Array(side * side);
+  // Per field: the accumulated counted change, its last peak and valley, and the field's
+  // mean at each, for WCAG's "darker image" rule.
+  const signal = new Float64Array(WINDOWS);
+  const peakValue = new Float64Array(WINDOWS);
+  const peakLevel = new Float64Array(WINDOWS);
+  const valleyValue = new Float64Array(WINDOWS);
+  const valleyLevel = new Float64Array(WINDOWS);
+  /** 1 after a rise, -1 after a fall, 0 before the first transition. */
+  const direction = new Int8Array(WINDOWS);
+  const ring = new Int32Array(WINDOWS * RING);
+  const head = new Int32Array(WINDOWS);
+  const tail = new Int32Array(WINDOWS);
+  const failures = [];
+  let peak = 0;
+
+  return {
+    update(frame, previous, current) {
+      // Summed-area tables, so each field's totals cost four lookups.
+      for (let y = 0; y < GRID; y++) {
+        let rowChanged = 0;
+        let rowChange = 0;
+        let rowLevel = 0;
+        for (let x = 0; x < GRID; x++) {
+          const cell = y * GRID + x;
+          const delta = current[cell] - previous[cell];
+          if (Math.abs(delta) > noise) rowChanged++;
+          rowChange += delta;
+          rowLevel += current[cell];
+          const at = (y + 1) * side + x + 1;
+          changed[at] = changed[at - side] + rowChanged;
+          change[at] = change[at - side] + rowChange;
+          level[at] = level[at - side] + rowLevel;
+        }
+      }
+      let most = 0;
+      for (let wy = 0; wy < WINDOWS_PER_SIDE; wy++) {
+        for (let wx = 0; wx < WINDOWS_PER_SIDE; wx++) {
+          const window = wy * WINDOWS_PER_SIDE + wx;
+          const a = wy * side + wx;
+          const b = a + FIELD;
+          const c = a + FIELD * side;
+          const d = c + FIELD;
+          const area = changed[d] - changed[b] - changed[c] + changed[a];
+          const step = (change[d] - change[b] - change[c] + change[a]) / FIELD_CELLS;
+          const mean = (level[d] - level[b] - level[c] + level[a]) / FIELD_CELLS;
+          if (frame === 1) {
+            peakLevel[window] = mean - step;
+            valleyLevel[window] = mean - step;
+          }
+          const value = signal[window] + (area >= AREA ? step : 0);
+          signal[window] = value;
+          let transition = false;
+          if (direction[window] >= 0) {
+            if (value > peakValue[window]) {
+              peakValue[window] = value;
+              peakLevel[window] = mean;
+            } else if (peakValue[window] - value >= threshold) {
+              transition = Math.min(mean, peakLevel[window]) < darkLimit;
+              direction[window] = -1;
+              valleyValue[window] = value;
+              valleyLevel[window] = mean;
+            }
+          }
+          if (direction[window] <= 0) {
+            if (value < valleyValue[window]) {
+              valleyValue[window] = value;
+              valleyLevel[window] = mean;
+            } else if (value - valleyValue[window] >= threshold) {
+              transition = Math.min(mean, valleyLevel[window]) < darkLimit;
+              direction[window] = 1;
+              peakValue[window] = value;
+              peakLevel[window] = mean;
+            }
+          }
+          const base = window * RING;
+          while (
+            tail[window] < head[window] &&
+            frame - ring[base + (tail[window] % RING)] >= ANALYSIS_FPS
+          )
+            tail[window]++;
+          if (transition) {
+            ring[base + (head[window] % RING)] = frame;
+            head[window]++;
+          }
+          const count = head[window] - tail[window];
+          if (count > most) most = count;
+        }
+      }
+      peak = Math.max(peak, most);
+      if (most > MAX_TRANSITIONS) {
+        const start = Math.max(0, frame + 1 - ANALYSIS_FPS) / ANALYSIS_FPS;
+        const end = (frame + 1) / ANALYSIS_FPS;
+        const last = failures.at(-1);
+        if (last && start <= last.end) last.end = end;
+        else failures.push({ start, end });
+      }
+    },
+    summary() {
+      return {
+        maxFlashesPerSecond: peak / 2,
+        failures: failures.slice(0, 20).map(({ start, end }) => ({
+          start: Math.round(start * 100) / 100,
+          end: Math.round(end * 100) / 100,
+        })),
+      };
+    },
+  };
+}
+
+/** Pure analysis over linear-light RGB frames of GRID × GRID cells (3 bytes per cell). */
+export function createFlashAnalyzer() {
+  const general = createChannel(CHANNELS.general);
+  const red = createChannel(CHANNELS.red);
+  let luminance = new Float64Array(CELLS);
+  let redness = new Float64Array(CELLS);
+  let previousLuminance = new Float64Array(CELLS);
+  let previousRedness = new Float64Array(CELLS);
+  let frames = 0;
+  return {
+    push(frame) {
+      if (!(frame instanceof Uint8Array) || frame.length !== FRAME_BYTES)
+        throw new Error(`Expected ${FRAME_BYTES}-byte analysis frames`);
+      for (let cell = 0; cell < CELLS; cell++) {
+        const r = frame[cell * 3] / 255;
+        const g = frame[cell * 3 + 1] / 255;
+        const b = frame[cell * 3 + 2] / 255;
+        luminance[cell] = 0.2126 * r + 0.7152 * g + 0.0722 * b;
+        const total = r + g + b;
+        redness[cell] = total > 0 && r / total >= 0.8 ? Math.max(0, (r - g - b) * 320) : 0;
+      }
+      if (frames > 0) {
+        general.update(frames, previousLuminance, luminance);
+        red.update(frames, previousRedness, redness);
+      }
+      [previousLuminance, luminance] = [luminance, previousLuminance];
+      [previousRedness, redness] = [redness, previousRedness];
+      frames++;
+    },
+    result() {
+      const generalSummary = general.summary();
+      const redSummary = red.summary();
+      return {
+        ok: frames >= 2 && !generalSummary.failures.length && !redSummary.failures.length,
+        method: "rendered-pixels",
+        standard: "WCAG 2.3.1 general and red flash thresholds",
+        analysisFps: ANALYSIS_FPS,
+        frames,
+        duration: frames / ANALYSIS_FPS,
+        general: generalSummary,
+        red: redSummary,
+      };
+    },
+  };
+}
+
+/** Decode a video into linear-light analysis frames and return the flash report. */
+export async function analyzeFlashes(file, signal) {
+  const binary = await ffmpegBinary();
+  const child = spawn(
+    binary,
+    [
+      "-hide_banner",
+      "-nostdin",
+      "-loglevel",
+      "error",
+      "-xerror",
+      "-protocol_whitelist",
+      "file,pipe",
+      "-i",
+      file,
+      "-map",
+      "0:v:0",
+      "-an",
+      "-vf",
+      [
+        // Linearise before any averaging: shrinking sRGB values first darkens fine detail
+        // by up to half the flash threshold.
+        "format=gbrp",
+        `lutrgb=r='${LINEAR}':g='${LINEAR}':b='${LINEAR}'`,
+        `scale=${GRID}:${GRID}:flags=area`,
+        `fps=${ANALYSIS_FPS}`,
+        "format=rgb24",
+      ].join(","),
+      "-f",
+      "rawvideo",
+      "-pix_fmt",
+      "rgb24",
+      "pipe:1",
+    ],
+    { stdio: ["ignore", "pipe", "pipe"], windowsHide: true, signal },
+  );
+  let stderr = "";
+  child.stderr.setEncoding("utf8");
+  child.stderr.on("data", (text) => {
+    if (stderr.length < 16_000) stderr += text;
+  });
+  const closed = once(child, "close");
+  closed.catch(() => {});
+  const analyzer = createFlashAnalyzer();
+  const frame = new Uint8Array(FRAME_BYTES);
+  let filled = 0;
+  for await (const chunk of child.stdout) {
+    let offset = 0;
+    while (offset < chunk.length) {
+      const take = Math.min(FRAME_BYTES - filled, chunk.length - offset);
+      frame.set(chunk.subarray(offset, offset + take), filled);
+      filled += take;
+      offset += take;
+      if (filled === FRAME_BYTES) {
+        analyzer.push(frame);
+        filled = 0;
+      }
+    }
+  }
+  const [code] = await closed;
+  if (code !== 0)
+    throw new Error(`FFmpeg could not decode the video: ${stderr.trim().slice(-2000)}`);
+  if (filled !== 0) throw new Error("Decoded video ended mid-frame; flashing is unverified");
+  const result = analyzer.result();
+  if (result.frames < 2) throw new Error("Too few decoded frames; flashing is unverified");
+  return result;
+}
+
+async function videoHash(file, signal) {
+  const hash = createHash("sha256");
+  for await (const chunk of createReadStream(file, { signal })) hash.update(chunk);
+  return hash.digest("hex");
+}
+
+async function main() {
+  const [video, ...extra] = process.argv.slice(2);
+  if (!video || extra.length) throw new Error("usage: flash-check.mjs <rendered-video>");
+  const file = resolve(video);
+  if (!(await stat(file)).isFile()) throw new Error("Expected a local rendered video file");
+  const controller = new AbortController();
+  const abort = () => controller.abort();
+  process.once("SIGTERM", abort);
+  process.once("SIGINT", abort);
+  const started = performance.now();
+  try {
+    const videoSha256 = await videoHash(file, controller.signal);
+    const result = await analyzeFlashes(file, controller.signal);
+    if ((await videoHash(file, controller.signal)) !== videoSha256)
+      throw new Error("Video changed during analysis; flashing is unverified");
+    process.stdout.write(
+      `${JSON.stringify({ ...result, file, videoSha256, elapsedMs: Math.round(performance.now() - started) })}\n`,
+    );
+    if (!result.ok) process.exitCode = 1;
+  } finally {
+    process.removeListener("SIGTERM", abort);
+    process.removeListener("SIGINT", abort);
+  }
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(resolve(process.argv[1])).href) {
+  try {
+    await main();
+  } catch (error) {
+    process.stderr.write(
+      `Flash verification failed: ${error instanceof Error ? error.message : "invalid input"}\n`,
+    );
+    process.exitCode = 1;
+  }
+}