@ignix-social/editor 0.1.2 → 0.1.5

package/skills/ignix-editor/SKILL.md

@@ -101,12 +101,11 @@ Decide the zones once per video (e.g. header y 270–440, stage y 460–1300, ca
 - Blurred background of the same footage: a second set of the same `<video>` elements behind, in a wrapper with `filter: blur(60px) brightness(.32)` and `transform: scale(1.25)`. (Heavy without a GPU: on a machine without one, prefer a pre-blurred copy made with ffmpeg.)
 - Long sources (lives, podcasts) are fine: the editor seeks straight to `data-media-start`.
 
-### The bundled ffmpeg (LGPL)
+### The bundled ffmpeg
 
-`ignix-editor ffmpeg` is a licence-clean build: everything you need for audio and simple video prep, but no GPL parts.
+`ignix-editor ffmpeg` is a full build for video prep (GPL, without libx264).
 - Encode H.264 with `-c:v h264_videotoolbox -b:v 10M -allow_sw 1` (there is no `libx264` and no `-crf`). AAC audio: `-c:a aac -b:a 192k`.
-- Present: `scale`, `crop`, `pad`, `overlay`, `trim`/`atrim`, `concat`, `gblur`, `avgblur`, `curves`, `lutyuv`, `colorbalance`, `colorchannelmixer`, `fade`, `afade`, `highpass`, `lowpass`, `acompressor`, `loudnorm`, `ebur128`, `silencedetect`, `amix`, `volume`.
-- Missing (GPL): `eq` (use `curves`/`lutyuv` for contrast and warmth), `boxblur` (use `gblur`), `delogo` (cover a burned-in label with a cropped, `gblur`red patch of the same frame placed by `overlay`, or with a card in the HTML).
+- Filters include `scale`, `crop`, `pad`, `overlay`, `trim`/`atrim`, `concat`, `eq` (contrast, brightness, saturation), `curves`, `lutyuv`, `colorbalance`, `boxblur`, `gblur`, `delogo` (hide a burned-in label: `delogo=x=..:y=..:w=..:h=..`), `hqdn3d` (denoise), `fade`, `afade`, `highpass`, `lowpass`, `acompressor`, `loudnorm`, `ebur128`, `silencedetect`, `amix`, `volume`.
 - Grading and blur are usually easier in the HTML anyway (CSS `filter: contrast() saturate() blur()`).
 
 ## 4. Audio and captions for reels from scratch

package/src/analysis/clip.mjs

@@ -0,0 +1,142 @@
+// CLIP ViT-B/32 (MIT; el mismo modelo que usaba Creator) en onnxruntime: imágenes y frases en
+// el mismo espacio, para elegir el plano que enseña lo que dice la voz. Coseno imagen↔texto:
+// ≈0,18 sin relación, ≈0,3 cuando la imagen lo muestra.
+import { readFileSync } from 'node:fs';
+import { resizeBicubic, toCHW } from './image.mjs';
+import { ensureModel, loadOrt, session } from './runtime.mjs';
+
+const MEAN = [0.48145466, 0.4578275, 0.40821073];
+const STD = [0.26862954, 0.26130258, 0.27577711];
+const SOT = 49406;
+const EOT = 49407;
+const MAX_TOKENS = 77;
+
+// ── Tokenizador BPE de CLIP (bytes → unicode, fusiones por rango, «</w>» al final de palabra)
+let tok = null;
+async function tokenizer(log) {
+  if (tok) return tok;
+  const vocab = JSON.parse(readFileSync(await ensureModel('clip_vocab', log), 'utf8'));
+  const lines = readFileSync(await ensureModel('clip_merges', log), 'utf8').split('\n');
+  const ranks = new Map();
+  lines.slice(1).forEach((l, i) => {
+    if (l.trim()) ranks.set(l.trim(), i);
+  });
+  const byteMap = bytesToUnicode();
+  const cache = new Map();
+  const bpe = (token) => {
+    if (cache.has(token)) return cache.get(token);
+    let word = [...token.slice(0, -1), token.slice(-1) + '</w>'];
+    if (token.length === 1) word = [token + '</w>'];
+    for (;;) {
+      let best = null;
+      let bestRank = Infinity;
+      for (let i = 0; i < word.length - 1; i++) {
+        const r = ranks.get(`${word[i]} ${word[i + 1]}`);
+        if (r !== undefined && r < bestRank) {
+          bestRank = r;
+          best = i;
+        }
+      }
+      if (best === null) break;
+      const a = word[best];
+      const b = word[best + 1];
+      const merged = [];
+      for (let i = 0; i < word.length; i++) {
+        if (i < word.length - 1 && word[i] === a && word[i + 1] === b) {
+          merged.push(a + b);
+          i++;
+        } else merged.push(word[i]);
+      }
+      word = merged;
+    }
+    cache.set(token, word);
+    return word;
+  };
+  const PAT = /<\|startoftext\|>|<\|endoftext\|>|'s|'t|'re|'ve|'m|'ll|'d|[\p{L}]+|[\p{N}]|[^\s\p{L}\p{N}]+/gu;
+  tok = (text) => {
+    const clean = text.normalize('NFC').replace(/\s+/g, ' ').trim().toLowerCase();
+    const ids = [SOT];
+    for (const m of clean.matchAll(PAT)) {
+      const mapped = [...Buffer.from(m[0], 'utf8')].map((b) => byteMap[b]).join('');
+      for (const piece of bpe(mapped)) {
+        const id = vocab[piece];
+        if (id !== undefined) ids.push(id);
+      }
+    }
+    return [...ids.slice(0, MAX_TOKENS - 1), EOT];
+  };
+  return tok;
+}
+
+function bytesToUnicode() {
+  const bs = [];
+  for (let b = 33; b <= 126; b++) bs.push(b);
+  for (let b = 161; b <= 172; b++) bs.push(b);
+  for (let b = 174; b <= 255; b++) bs.push(b);
+  const cs = [...bs];
+  let n = 0;
+  for (let b = 0; b < 256; b++) {
+    if (!bs.includes(b)) {
+      bs.push(b);
+      cs.push(256 + n);
+      n++;
+    }
+  }
+  const map = {};
+  bs.forEach((b, i) => (map[b] = String.fromCodePoint(cs[i])));
+  return map;
+}
+
+const unit = (v) => {
+  let s = 0;
+  for (const x of v) s += x * x;
+  const n = Math.sqrt(s) || 1;
+  return Float32Array.from(v, (x) => x / n);
+};
+
+/** Vectores unitarios (512) de cada frase. */
+export async function embedTexts(texts, log) {
+  const t = await tokenizer(log);
+  const s = await session('clip_text', log);
+  const { Tensor } = await loadOrt(log);
+  const out = [];
+  for (const text of texts) {
+    const ids = t(text);
+    const res = await s.run({ input_ids: new Tensor('int64', BigInt64Array.from(ids.map(BigInt)), [1, ids.length]) });
+    out.push(unit(res.text_embeds.data));
+  }
+  return out;
+}
+
+/** Vector unitario de una imagen (RGB intercalado w×h), preparada como CLIP. */
+export async function embedImage(frame, log) {
+  const s = await session('clip_vision', log);
+  const { Tensor } = await loadOrt(log);
+  // Lado corto a 224 (bicúbico, como PIL) y recorte central de 224×224.
+  const k = 224 / Math.min(frame.w, frame.h);
+  const W = Math.max(224, Math.round(frame.w * k));
+  const H = Math.max(224, Math.round(frame.h * k));
+  const big = resizeBicubic(frame.rgb, frame.w, frame.h, W, H);
+  const x0 = Math.floor((W - 224) / 2);
+  const y0 = Math.floor((H - 224) / 2);
+  const crop = new Uint8Array(224 * 224 * 3);
+  for (let y = 0; y < 224; y++) crop.set(big.subarray(((y0 + y) * W + x0) * 3, ((y0 + y) * W + x0 + 224) * 3), y * 224 * 3);
+  const input = new Tensor('float32', toCHW(crop, 224, 224, { scale: 1 / 255, mean: MEAN, std: STD }), [1, 3, 224, 224]);
+  const res = await s.run({ pixel_values: input });
+  return unit(res.image_embeds.data);
+}
+
+export const dot = (a, b) => {
+  let s = 0;
+  for (let i = 0; i < a.length; i++) s += a[i] * b[i];
+  return s;
+};
+
+/** Media de varios vectores, unitaria (un plano = sus fotogramas juntos). */
+export function pool(vecs) {
+  const out = new Float32Array(vecs[0].length);
+  for (const v of vecs) for (let i = 0; i < v.length; i++) out[i] += v[i];
+  return unit(out);
+}
+
+export { tokenizer as clipTokenizer };

package/src/analysis/detect.mjs

@@ -0,0 +1,185 @@
+// Detectores sobre onnxruntime, iguales en Mac y en Windows:
+//  · personas por el CUERPO (YOLOX-S, Apache-2.0): alguien que mira abajo o de espaldas sigue
+//    siendo alguien. El mismo detector que usa el trabajador del recast en la nube, para que los
+//    dos lados cuenten las mismas personas.
+//  · caras (YuNet, MIT) con sus cinco puntos (ojos, nariz, boca): sirven para encuadrar y para
+//    saber si una cara se ve de FRENTE (el parecido de un recast depende de eso).
+//  · texto quemado (detector de PP-OCRv3, Apache-2.0): letras sobre la persona salen
+//    garabateadas en un recast.
+// Todas las cajas salen normalizadas (0..1) respecto al fotograma.
+import { letterbox, nms, resize, toCHW } from './image.mjs';
+import { session } from './runtime.mjs';
+
+const S = 640;
+
+// ── YOLOX
+const ANCHORS = (() => {
+  const g = [];
+  for (const st of [8, 16, 32]) {
+    const n = S / st;
+    for (let y = 0; y < n; y++) for (let x = 0; x < n; x++) g.push([x, y, st]);
+  }
+  return g;
+})();
+export const PERSON_MIN_SCORE = 0.4;
+
+/** Salida cruda de YOLOX (8400 × 85) → cajas de persona en píxeles del fotograma. */
+export function decodeYolox(out, ratio, width, height, minScore = PERSON_MIN_SCORE) {
+  const found = [];
+  for (let i = 0; i < ANCHORS.length; i++) {
+    const o = i * 85;
+    const score = out[o + 4] * out[o + 5]; // un objeto, y ese objeto es una persona
+    if (score < minScore) continue;
+    const [gx, gy, st] = ANCHORS[i];
+    const cx = (out[o] + gx) * st;
+    const cy = (out[o + 1] + gy) * st;
+    const w = Math.exp(out[o + 2]) * st;
+    const h = Math.exp(out[o + 3]) * st;
+    const x0 = Math.max(0, (cx - w / 2) / ratio);
+    const y0 = Math.max(0, (cy - h / 2) / ratio);
+    const x1 = Math.min(width, (cx + w / 2) / ratio);
+    const y1 = Math.min(height, (cy + h / 2) / ratio);
+    if (x1 > x0 && y1 > y0) found.push({ x: x0, y: y0, w: x1 - x0, h: y1 - y0, score });
+  }
+  return nms(found, 0.5);
+}
+
+export async function people(frame, log) {
+  const s = await session('yolox', log);
+  const { rgb, r } = letterbox(frame.rgb, frame.w, frame.h, S, 114);
+  const input = new (await tensorClass(log))('float32', toCHW(rgb, S, S), [1, 3, S, S]);
+  const res = await s.run({ [s.inputNames[0]]: input });
+  const out = res[s.outputNames[0]].data;
+  return decodeYolox(out, r, frame.w, frame.h).map((b) => norm(b, frame));
+}
+
+// ── YuNet
+export const FACE_MIN_SCORE = 0.7;
+
+/** Salidas de YuNet → caras {x,y,w,h,score,kps:[[x,y]×5]} en píxeles del fotograma. */
+export function decodeYunet(out, ratio, width, height, minScore = FACE_MIN_SCORE) {
+  const found = [];
+  for (const st of [8, 16, 32]) {
+    const cls = out[`cls_${st}`];
+    const obj = out[`obj_${st}`];
+    const box = out[`bbox_${st}`];
+    const kps = out[`kps_${st}`];
+    const cols = S / st;
+    for (let i = 0; i < cls.length; i++) {
+      const score = Math.sqrt(Math.min(1, Math.max(0, cls[i])) * Math.min(1, Math.max(0, obj[i])));
+      if (score < minScore) continue;
+      const c = i % cols;
+      const r = Math.floor(i / cols);
+      const cx = (c + box[i * 4]) * st;
+      const cy = (r + box[i * 4 + 1]) * st;
+      const w = Math.exp(box[i * 4 + 2]) * st;
+      const h = Math.exp(box[i * 4 + 3]) * st;
+      const pts = [];
+      for (let k = 0; k < 5; k++) pts.push([((kps[i * 10 + 2 * k] + c) * st) / ratio, ((kps[i * 10 + 2 * k + 1] + r) * st) / ratio]);
+      const x0 = Math.max(0, (cx - w / 2) / ratio);
+      const y0 = Math.max(0, (cy - h / 2) / ratio);
+      const x1 = Math.min(width, (cx + w / 2) / ratio);
+      const y1 = Math.min(height, (cy + h / 2) / ratio);
+      if (x1 > x0 && y1 > y0) found.push({ x: x0, y: y0, w: x1 - x0, h: y1 - y0, score, kps: pts });
+    }
+  }
+  return nms(found, 0.3);
+}
+
+/**
+ * ¿Se ve la cara de frente? Con los cinco puntos de YuNet: la nariz cae entre los dos ojos y a
+ * la misma distancia de cada uno, y los ojos no están demasiado juntos para el tamaño de la cara
+ * (de perfil se juntan). Umbrales medidos con los clips del recast (ADR-0023 E1).
+ */
+export function isFrontal(face, { maxSkew = FRONTAL_MAX_SKEW, minEyes = FRONTAL_MIN_EYES } = {}) {
+  const [re, le, nose] = face.kps;
+  const eyes = Math.hypot(le[0] - re[0], le[1] - re[1]);
+  if (eyes < minEyes * face.w) return false;
+  const dl = Math.hypot(nose[0] - le[0], nose[1] - le[1]);
+  const dr = Math.hypot(nose[0] - re[0], nose[1] - re[1]);
+  return Math.abs(dl - dr) / (dl + dr) <= maxSkew;
+}
+// Medido (2026-10-06) con seis clips del recast: buenos 83–94 % de muestras de frente,
+// malos 14–37 %; con los umbrales de Creator (≥50 %, ≥110 px) separan igual que el Haar de antes.
+export const FRONTAL_MAX_SKEW = 0.2;
+export const FRONTAL_MIN_EYES = 0.3;
+
+export async function faces(frame, log) {
+  const s = await session('yunet', log);
+  // YuNet espera BGR en 0..255 (como lo prepara OpenCV), en un cuadrado de 640.
+  const { rgb, r } = letterbox(frame.rgb, frame.w, frame.h, S, 0);
+  const input = new (await tensorClass(log))('float32', toCHW(rgb, S, S, { bgr: true }), [1, 3, S, S]);
+  const res = await s.run({ [s.inputNames[0]]: input });
+  const out = Object.fromEntries(s.outputNames.map((n) => [n, res[n].data]));
+  return decodeYunet(out, r, frame.w, frame.h).map((f) => ({
+    ...norm(f, frame),
+    frontal: isFrontal(f),
+    kps: f.kps.map(([x, y]) => [x / frame.w, y / frame.h]),
+    // Tamaño de la cara en píxeles del ORIGINAL, no del fotograma de trabajo.
+    px: f.h * (frame.scale ?? 1),
+  }));
+}
+
+// ── PP-OCR (detector de texto DB)
+const OCR_MEAN = [123.675, 116.28, 103.53];
+const OCR_STD = [0.229, 0.224, 0.225];
+
+/** Mapa de probabilidad del detector DB → cajas de texto en coordenadas del mapa. */
+export function decodeDb(prob, W, H, { bin = 0.3, minScore = 0.5, unclip = 2.0, max = 200 } = {}) {
+  const seen = new Uint8Array(W * H);
+  const boxes = [];
+  const stack = [];
+  for (let start = 0; start < W * H && boxes.length < max; start++) {
+    if (seen[start] || prob[start] < bin) continue;
+    // Componente conexa (4 vecinos) de píxeles sobre el umbral.
+    let x0 = W, y0 = H, x1 = 0, y1 = 0, sum = 0, n = 0;
+    stack.push(start);
+    seen[start] = 1;
+    while (stack.length) {
+      const p = stack.pop();
+      const x = p % W;
+      const y = (p - x) / W;
+      sum += prob[p];
+      n += 1;
+      if (x < x0) x0 = x;
+      if (x > x1) x1 = x;
+      if (y < y0) y0 = y;
+      if (y > y1) y1 = y;
+      for (const q of [x > 0 ? p - 1 : -1, x < W - 1 ? p + 1 : -1, y > 0 ? p - W : -1, y < H - 1 ? p + W : -1]) {
+        if (q >= 0 && !seen[q] && prob[q] >= bin) {
+          seen[q] = 1;
+          stack.push(q);
+        }
+      }
+    }
+    const w = x1 - x0 + 1;
+    const h = y1 - y0 + 1;
+    if (Math.min(w, h) < 3 || sum / n < minScore) continue;
+    // El detector DB «encoge» el texto: se agranda la caja en área·ratio/perímetro.
+    const d = (w * h * unclip) / (2 * (w + h));
+    boxes.push({ x: Math.max(0, x0 - d), y: Math.max(0, y0 - d), w: Math.min(W, x1 + 1 + d) - Math.max(0, x0 - d), h: Math.min(H, y1 + 1 + d) - Math.max(0, y0 - d), score: sum / n });
+  }
+  return boxes;
+}
+
+export async function text(frame, log) {
+  const s = await session('ppocr', log);
+  const [W, H] = frame.h > frame.w ? [416, 736] : [736, 416];
+  const small = resize(frame.rgb, frame.w, frame.h, W, H);
+  // Como lo prepara OpenCV para este modelo: canales en orden BGR, medias y escalas por posición.
+  const input = new (await tensorClass(log))('float32', toCHW(small, W, H, { bgr: true, mean: OCR_MEAN, std: OCR_STD.map((v) => v * 255) }), [1, 3, H, W]);
+  const res = await s.run({ [s.inputNames[0]]: input });
+  const prob = res[s.outputNames[0]].data;
+  return decodeDb(prob, W, H)
+    .slice(0, 40)
+    .map((b) => ({ x: b.x / W, y: b.y / H, w: Math.min(1, b.w / W), h: Math.min(1, b.h / H) }));
+}
+
+// ── utilidades
+const norm = (b, frame) => ({ x: b.x / frame.w, y: b.y / frame.h, w: b.w / frame.w, h: b.h / frame.h, score: +b.score.toFixed(3) });
+
+let Tensor = null;
+async function tensorClass(log) {
+  if (!Tensor) Tensor = (await import('./runtime.mjs').then((m) => m.loadOrt(log))).Tensor;
+  return Tensor;
+}

package/src/analysis/image.mjs

@@ -0,0 +1,123 @@
+// Operaciones de imagen en RGB (uint8, intercalado) para preparar la entrada de los modelos.
+
+/** Reescalado bilineal de un RGB intercalado. */
+export function resize(rgb, w, h, W, H) {
+  const out = new Uint8Array(W * H * 3);
+  const sx = w / W;
+  const sy = h / H;
+  for (let y = 0; y < H; y++) {
+    const fy = Math.max(0, (y + 0.5) * sy - 0.5);
+    const y0 = Math.min(h - 1, Math.floor(fy));
+    const y1 = Math.min(h - 1, y0 + 1);
+    const dy = fy - y0;
+    for (let x = 0; x < W; x++) {
+      const fx = Math.max(0, (x + 0.5) * sx - 0.5);
+      const x0 = Math.min(w - 1, Math.floor(fx));
+      const x1 = Math.min(w - 1, x0 + 1);
+      const dx = fx - x0;
+      const o = (y * W + x) * 3;
+      for (let c = 0; c < 3; c++) {
+        const a = rgb[(y0 * w + x0) * 3 + c];
+        const b = rgb[(y0 * w + x1) * 3 + c];
+        const d = rgb[(y1 * w + x0) * 3 + c];
+        const e = rgb[(y1 * w + x1) * 3 + c];
+        out[o + c] = Math.round((a * (1 - dx) + b * dx) * (1 - dy) + (d * (1 - dx) + e * dx) * dy);
+      }
+    }
+  }
+  return out;
+}
+
+// Núcleo cúbico de Keys (a = -0.5), el del reescalado «bicúbico» de PIL que usa CLIP.
+const cubic = (x) => {
+  const a = -0.5;
+  x = Math.abs(x);
+  if (x <= 1) return ((a + 2) * x - (a + 3)) * x * x + 1;
+  if (x < 2) return (((x - 5) * x + 8) * x - 4) * a;
+  return 0;
+};
+
+/** Reescalado bicúbico separable con antialias al reducir (como PIL). */
+export function resizeBicubic(rgb, w, h, W, H) {
+  const pass = (src, sw, sh, dw, horizontal) => {
+    const len = horizontal ? sw : sh;
+    const out = new Float32Array(horizontal ? dw * sh * 3 : sw * dw * 3);
+    const scale = len / dw;
+    const support = 2 * Math.max(1, scale);
+    const fscale = Math.max(1, scale);
+    for (let i = 0; i < dw; i++) {
+      const center = (i + 0.5) * scale;
+      const lo = Math.max(0, Math.floor(center - support));
+      const hi = Math.min(len, Math.ceil(center + support));
+      const ws = [];
+      let sum = 0;
+      for (let j = lo; j < hi; j++) {
+        const wgt = cubic((j + 0.5 - center) / fscale);
+        ws.push(wgt);
+        sum += wgt;
+      }
+      for (let k = 0; k < ws.length; k++) ws[k] /= sum || 1;
+      const lines = horizontal ? sh : sw;
+      for (let l = 0; l < lines; l++) {
+        for (let c = 0; c < 3; c++) {
+          let acc = 0;
+          for (let j = lo, k = 0; j < hi; j++, k++) {
+            const idx = horizontal ? (l * sw + j) * 3 + c : (j * sw + l) * 3 + c;
+            acc += src[idx] * ws[k];
+          }
+          const o = horizontal ? (l * dw + i) * 3 + c : (i * sw + l) * 3 + c;
+          out[o] = acc;
+        }
+      }
+    }
+    return out;
+  };
+  const a = pass(rgb, w, h, W, true); // W × h
+  const b = pass(a, W, h, H, false); // W × H
+  const out = new Uint8Array(W * H * 3);
+  for (let i = 0; i < out.length; i++) out[i] = Math.max(0, Math.min(255, Math.round(b[i])));
+  return out;
+}
+
+/** Tensor CHW float32 con normalización por canal (`mean`, `std` en la escala dada). */
+export function toCHW(rgb, w, h, { scale = 1, mean = [0, 0, 0], std = [1, 1, 1], bgr = false } = {}) {
+  const out = new Float32Array(3 * w * h);
+  const plane = w * h;
+  for (let i = 0; i < plane; i++) {
+    for (let c = 0; c < 3; c++) {
+      const src = rgb[i * 3 + (bgr ? 2 - c : c)];
+      out[c * plane + i] = (src * scale - mean[c]) / std[c];
+    }
+  }
+  return out;
+}
+
+/** Pega la imagen arriba a la izquierda de un lienzo `S`×`S` relleno de `fill` (letterbox). */
+export function letterbox(rgb, w, h, S, fill = 114) {
+  const r = Math.min(S / w, S / h);
+  const nw = Math.max(1, Math.round(w * r));
+  const nh = Math.max(1, Math.round(h * r));
+  const small = resize(rgb, w, h, nw, nh);
+  const out = new Uint8Array(S * S * 3).fill(fill);
+  for (let y = 0; y < nh; y++) out.set(small.subarray(y * nw * 3, (y + 1) * nw * 3), y * S * 3);
+  return { rgb: out, r };
+}
+
+/** Supresión de no máximos sobre cajas {x,y,w,h,score}. */
+export function nms(boxes, iou = 0.5) {
+  const sorted = [...boxes].sort((a, b) => b.score - a.score);
+  const keep = [];
+  for (const b of sorted) {
+    if (keep.every((k) => overlap(k, b) <= iou)) keep.push(b);
+  }
+  return keep;
+}
+
+function overlap(a, b) {
+  const x0 = Math.max(a.x, b.x);
+  const y0 = Math.max(a.y, b.y);
+  const x1 = Math.min(a.x + a.w, b.x + b.w);
+  const y1 = Math.min(a.y + a.h, b.y + b.h);
+  const inter = Math.max(0, x1 - x0) * Math.max(0, y1 - y0);
+  return inter / (a.w * a.h + b.w * b.h - inter || 1);
+}

package/src/analysis/media.mjs

@@ -0,0 +1,152 @@
+// Leer vídeo, fotos y audio con el ffmpeg del Editor: datos del fichero, fotogramas
+// muestreados en RGB (para los modelos) y el sonido como muestras (para medirlo).
+import { spawn, spawnSync } from 'node:child_process';
+
+/** Duración, fotogramas por segundo, tamaño y si tiene audio. */
+export function probe(ffprobe, path) {
+  const r = spawnSync(ffprobe, ['-v', 'error', '-print_format', 'json', '-show_format', '-show_streams', path], { encoding: 'utf8', maxBuffer: 16 * 1024 * 1024 });
+  if (r.status !== 0) throw new Error(`Could not read ${path}: ${(r.stderr || '').slice(-200)}`);
+  const j = JSON.parse(r.stdout);
+  const v = (j.streams ?? []).find((s) => s.codec_type === 'video');
+  const rate = (s) => {
+    const [a, b] = String(s ?? '0/1').split('/').map(Number);
+    return b ? a / b : 0;
+  };
+  // Vídeo grabado con el móvil en vertical: el giro va en los metadatos.
+  const rot = Math.abs(Number(v?.tags?.rotate ?? (v?.side_data_list ?? []).find((d) => d.rotation !== undefined)?.rotation ?? 0)) % 180 === 90;
+  return {
+    duration: Number(j.format?.duration ?? v?.duration ?? 0) || 0,
+    fps: rate(v?.avg_frame_rate) || rate(v?.r_frame_rate) || 30,
+    width: rot ? v?.height ?? 0 : v?.width ?? 0,
+    height: rot ? v?.width ?? 0 : v?.height ?? 0,
+    hasVideo: !!v,
+    hasAudio: (j.streams ?? []).some((s) => s.codec_type === 'audio'),
+  };
+}
+
+/** Tamaño de trabajo que cabe en `max` px de lado manteniendo la proporción (par). */
+export function fitSize(w, h, max) {
+  const s = Math.min(1, max / Math.max(w, h));
+  return { w: Math.max(2, Math.round((w * s) / 2) * 2), h: Math.max(2, Math.round((h * s) / 2) * 2) };
+}
+
+/**
+ * Fotogramas del vídeo a `fps` por segundo (o uno, si es una foto), en RGB y a un tamaño de
+ * trabajo de como mucho `max` px. Llama a `onFrame({ t, w, h, rgb })` en orden; si devuelve
+ * `false`, para. `start`/`end` acotan un tramo (segundos).
+ */
+export function frames(ffmpeg, path, { fps = 2, max = 640, width, height, start = 0, end = null, still = false, onFrame }) {
+  const { w, h } = fitSize(width, height, max);
+  const args = ['-nostdin', '-hide_banner', '-loglevel', 'error'];
+  if (start > 0) args.push('-ss', start.toFixed(3));
+  args.push('-i', path);
+  if (end !== null) args.push('-t', Math.max(0.05, end - start).toFixed(3));
+  const vf = still ? `scale=${w}:${h}` : `fps=${fps},scale=${w}:${h}`;
+  args.push('-an', '-vf', vf, ...(still ? ['-frames:v', '1'] : []), '-f', 'rawvideo', '-pix_fmt', 'rgb24', 'pipe:1');
+  const size = w * h * 3;
+  return new Promise((resolve, reject) => {
+    const p = spawn(ffmpeg, args, { stdio: ['ignore', 'pipe', 'pipe'] });
+    let buf = Buffer.alloc(0);
+    let k = 0;
+    let stopped = false;
+    let err = '';
+    let chain = Promise.resolve();
+    p.stderr.on('data', (d) => (err = (err + d).slice(-400)));
+    p.stdout.on('data', (d) => {
+      if (stopped) return;
+      buf = buf.length ? Buffer.concat([buf, d]) : d;
+      while (buf.length >= size && !stopped) {
+        const rgb = buf.subarray(0, size);
+        buf = buf.subarray(size);
+        // El fps de ffmpeg toma el fotograma de cada tramo de 1/fps: su instante es el centro.
+        const t = still ? 0 : start + (k + 0.5) / fps;
+        k += 1;
+        const copy = Buffer.from(rgb);
+        chain = chain.then(async () => {
+          if (stopped) return;
+          if ((await onFrame({ t, w, h, rgb: copy })) === false) {
+            stopped = true;
+            p.kill();
+          }
+        });
+        // Con muchos fotogramas en cola, que ffmpeg espere (memoria acotada).
+        p.stdout.pause();
+        chain.then(() => p.stdout.resume(), () => p.stdout.resume());
+      }
+    });
+    p.on('error', reject);
+    p.on('close', (code) => {
+      chain.then(() => {
+        if (code !== 0 && !stopped && k === 0) reject(new Error(`Could not read the frames of ${path}: ${err.trim()}`));
+        else resolve({ count: k, w, h });
+      }, reject);
+    });
+  });
+}
+
+/**
+ * El sonido como muestras float32 mono a `rate` Hz, en bloques. `start`/`end` acotan un tramo.
+ * Devuelve false si el fichero no tiene audio.
+ */
+export function pcm(ffmpeg, path, { rate = 16000, start = 0, end = null, onSamples }) {
+  const args = ['-nostdin', '-hide_banner', '-loglevel', 'error'];
+  if (start > 0) args.push('-ss', start.toFixed(3));
+  args.push('-i', path);
+  if (end !== null) args.push('-t', Math.max(0.05, end - start).toFixed(3));
+  args.push('-vn', '-ac', '1', '-ar', String(rate), '-f', 'f32le', 'pipe:1');
+  return new Promise((resolve, reject) => {
+    const p = spawn(ffmpeg, args, { stdio: ['ignore', 'pipe', 'pipe'] });
+    let carry = Buffer.alloc(0);
+    let err = '';
+    let any = false;
+    p.stderr.on('data', (d) => (err = (err + d).slice(-400)));
+    p.stdout.on('data', (d) => {
+      any = true;
+      const all = carry.length ? Buffer.concat([carry, d]) : d;
+      const n = Math.floor(all.length / 4);
+      const copy = new Float32Array(n);
+      for (let i = 0; i < n; i++) copy[i] = all.readFloatLE(i * 4);
+      carry = all.subarray(n * 4);
+      try {
+        onSamples(copy);
+      } catch (e) {
+        p.kill();
+        reject(e);
+      }
+    });
+    p.on('error', reject);
+    p.on('close', (code) => {
+      if (!any && /does not contain any stream|Output file .* does not contain|matches no streams/i.test(err)) resolve(false);
+      else if (code !== 0 && !any) reject(new Error(`Could not read the audio of ${path}: ${err.trim()}`));
+      else resolve(true);
+    });
+  });
+}
+
+/** Niveles en dBFS de ventanas de `windowSec` (RMS). */
+export async function levels(ffmpeg, path, { windowSec = 0.05, start = 0, end = null, maxSec = 3600 } = {}) {
+  const rate = 16000;
+  const win = Math.round(rate * windowSec);
+  const out = [];
+  let acc = 0;
+  let n = 0;
+  let seen = 0;
+  const ok = await pcm(ffmpeg, path, {
+    rate,
+    start,
+    end,
+    onSamples: (x) => {
+      seen += x.length;
+      if (seen > maxSec * rate) throw new Error('too long');
+      for (let i = 0; i < x.length; i++) {
+        acc += x[i] * x[i];
+        if (++n === win) {
+          out.push(10 * Math.log10(acc / win + 1e-12));
+          acc = 0;
+          n = 0;
+        }
+      }
+    },
+  });
+  return ok ? out : null;
+}