@ignix-social/editor 0.1.2 → 0.1.5

package/src/analysis/montage.mjs

@@ -0,0 +1,356 @@
+// El material del cliente como un ÍNDICE DE PLANOS, y el montaje que lo usa (ADR-0023 E1):
+//  · analyze: cada vídeo partido en sus planos reales (cambios de escena; una toma larga en
+//    trozos de ~4 s), cada plano con tres fotogramas, su movimiento, dónde está la acción o la
+//    cara, su tamaño de plano y su vector CLIP. Lo ya analizado no se repite.
+//  · edit: para cada momento del guion, el plano que ENSEÑA lo que se dice (CLIP imagen↔texto),
+//    sin repetir fuente seguida, variando el tamaño de plano, y el trozo del plano que mejor
+//    encaja; más planos alternativos para los subplanos.
+//  · review: la línea de tiempo terminada, juzgada (¿parece un pase de diapositivas?, ¿varía?).
+// Reglas propias de Ignix (no se copia código de OpenMontage).
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { dot, embedImage, embedTexts, pool } from './clip.mjs';
+import { faces as detectFaces } from './detect.mjs';
+import { frames, probe } from './media.mjs';
+import { cuts } from './sound.mjs';
+
+const DIM = 512;
+const SHOT_SIZES = ['close-up', 'medium', 'wide'];
+// Frases fijas con las que CLIP compara cada plano (tamaño de plano sin entrenar nada).
+const SIZE_PROMPTS = {
+  'close-up': 'an extreme close-up photo of a detail, a face or hands filling the frame',
+  medium: 'a medium shot photo of a person from the waist up',
+  wide: 'a wide shot photo of a whole room, place or scene',
+};
+const MAX_WINDOWS = 12;
+const TAG_WEIGHT = 0.25;
+const NEAR_DUPLICATE = 0.92;
+
+// ── el índice: index.json + un .f32 por plano con [conjunto, etiqueta, fotogramas…]
+function store(workdir) {
+  const dir = join(workdir, 'editor-corpus');
+  mkdirSync(dir, { recursive: true });
+  const indexPath = join(dir, 'index.json');
+  const index = existsSync(indexPath) ? JSON.parse(readFileSync(indexPath, 'utf8')) : { clips: {} };
+  const vecs = new Map();
+  const file = (id) => join(dir, `${id.replace(/[^\w.-]/g, '_')}.f32`);
+  return {
+    index,
+    save: () => writeFileSync(indexPath, JSON.stringify(index)),
+    put(id, meta, pooled, tag, frameVecs) {
+      const all = new Float32Array(DIM * (2 + frameVecs.length));
+      all.set(pooled, 0);
+      all.set(tag, DIM);
+      frameVecs.forEach((v, i) => all.set(v, DIM * (2 + i)));
+      writeFileSync(file(id), Buffer.from(all.buffer));
+      index.clips[id] = meta;
+      vecs.set(id, all);
+    },
+    vectors(id) {
+      if (!vecs.has(id)) {
+        const b = readFileSync(file(id));
+        vecs.set(id, new Float32Array(b.buffer, b.byteOffset, b.length / 4));
+      }
+      const all = vecs.get(id);
+      const n = all.length / DIM - 2;
+      return {
+        pooled: all.subarray(0, DIM),
+        tag: all.subarray(DIM, 2 * DIM),
+        frames: Array.from({ length: n }, (_, i) => all.subarray(DIM * (2 + i), DIM * (3 + i))),
+      };
+    },
+  };
+}
+
+/** Movimiento (diferencia media de grises, 0–255) entre dos fotogramas y dónde ocurre (0..1). */
+export function motionOf(a, b, w, h) {
+  if (!a || !b) return { motion: 0, focus: null };
+  const cols = new Float64Array(w);
+  let sum = 0;
+  for (let i = 0; i < w * h; i++) {
+    const ga = 0.299 * a[i * 3] + 0.587 * a[i * 3 + 1] + 0.114 * a[i * 3 + 2];
+    const gb = 0.299 * b[i * 3] + 0.587 * b[i * 3 + 1] + 0.114 * b[i * 3 + 2];
+    const d = Math.abs(ga - gb);
+    sum += d;
+    cols[i % w] += d;
+  }
+  const motion = sum / (w * h);
+  let focus = null;
+  if (motion > 2) {
+    let tot = 0;
+    let acc = 0;
+    for (let x = 0; x < w; x++) {
+      tot += cols[x];
+      acc += cols[x] * x;
+    }
+    if (tot > 0) focus = acc / tot / w;
+  }
+  return { motion, focus };
+}
+
+export async function analyze({ ffmpeg, ffprobe, workdir, media, log = () => {} }) {
+  const db = store(workdir);
+  const sizeVecs = await embedTexts(SHOT_SIZES.map((s) => SIZE_PROMPTS[s]), log);
+  const shots = [];
+  for (const m of media) {
+    const { id: asset, kind, path } = m;
+    const label = String(m.label ?? '').trim();
+    let windows = [];
+    let faceSamples = [];
+    let info = null;
+    try {
+      info = probe(ffprobe, path);
+    } catch (e) {
+      log(`analyze ${asset}: ${e.message}`);
+      continue;
+    }
+    if (kind === 'video') {
+      const duration = Number(m.duration) || info.duration;
+      // Dónde está la cara (la más grande) dos veces por segundo: encuadre y tamaño de plano.
+      await frames(ffmpeg, path, {
+        fps: 2,
+        max: 640,
+        width: info.width,
+        height: info.height,
+        onFrame: async (f) => {
+          const found = await detectFaces(f, log);
+          const big = found.sort((a, b) => b.w * b.h - a.w * a.h)[0];
+          if (big) faceSamples.push({ t: f.t, x: big.x + big.w / 2, area: big.w * big.h });
+        },
+      }).catch((e) => log(`faces ${asset}: ${e.message}`));
+      const found = await cuts(ffmpeg, path, { minSec: 0.8, maxSec: 24 * 3600 }).catch(() => []);
+      const bounds = [0, ...found, duration];
+      windows = [];
+      for (let i = 0; i + 1 < bounds.length; i++) if (bounds[i + 1] - bounds[i] >= 0.8) windows.push([bounds[i], bounds[i + 1]]);
+      if (!windows.length && duration > 0) windows = [[0, duration]];
+      // Una toma larga: trozos de ~4 s, para poder elegir cada uno.
+      const split = [];
+      for (const [a, b] of windows) {
+        const n = Math.max(1, Math.floor((b - a) / 4));
+        for (let k = 0; k < n; k++) split.push([a + (k * (b - a)) / n, a + ((k + 1) * (b - a)) / n]);
+      }
+      windows = split.slice(0, MAX_WINDOWS);
+    } else windows = [[0, 0]];
+
+    for (const [k, [a, b]] of windows.entries()) {
+      const clip = `${asset}~${k}`;
+      const known = db.index.clips[clip];
+      if (known) {
+        shots.push({ clip, asset, start: a, end: b, motion: known.motion, size: known.size, focus: known.focus });
+        continue;
+      }
+      const grabbed = [];
+      if (kind === 'video') {
+        await frames(ffmpeg, path, { fps: 3 / Math.max(0.1, b - a), max: 448, width: info.width, height: info.height, start: a, end: b, onFrame: (f) => void grabbed.push(f) }).catch(() => {});
+      } else {
+        await frames(ffmpeg, path, { still: true, max: 448, width: info.width, height: info.height, onFrame: (f) => void grabbed.push(f) }).catch(() => {});
+      }
+      if (!grabbed.length) continue;
+      const g = grabbed.slice(0, 3);
+      let { motion, focus } = kind === 'video' && g.length >= 2 ? motionOf(g[0].rgb, g[Math.floor(g.length / 2)].rgb, g[0].w, g[0].h) : { motion: 0, focus: null };
+      let faceSize = null;
+      const inside = faceSamples.filter((s) => s.t >= a && s.t <= b);
+      if (inside.length) {
+        // Una cara en el plano lo encuadra; si no, dónde está la acción.
+        const tot = inside.reduce((s, x) => s + x.area, 0);
+        focus = inside.reduce((s, x) => s + x.x * x.area, 0) / tot;
+        // El tamaño de la cara en el cuadro ES el tamaño de plano (gramática de montaje).
+        const side = Math.sqrt(Math.max(...inside.map((x) => x.area)));
+        faceSize = side > 0.3 ? 'close-up' : side < 0.1 ? 'wide' : 'medium';
+      } else if (kind !== 'video') {
+        const f = (await detectFaces(g[0], log)).sort((p, q) => q.w * q.h - p.w * p.h)[0];
+        if (f) focus = f.x + f.w / 2;
+      }
+      const frameVecs = [];
+      for (const f of g) frameVecs.push(await embedImage(f, log));
+      const pooled = pool(frameVecs);
+      const [tag] = await embedTexts([label || (kind === 'video' ? 'a video clip' : 'a photo')], log);
+      const size = faceSize ?? SHOT_SIZES[sizeVecs.map((v) => dot(pooled, v)).reduce((bi, v, i, arr) => (v > arr[bi] ? i : bi), 0)];
+      const fx = focus === null || focus === undefined ? null : +Math.min(1, Math.max(0, focus)).toFixed(3);
+      const times = g.map((f) => +f.t.toFixed(3));
+      db.put(clip, { asset, kind, label, start: a, end: b, duration: kind === 'video' ? +(b - a).toFixed(3) : 0, motion, size, focus: fx, times }, pooled, tag, frameVecs);
+      shots.push({ clip, asset, start: a, end: b, motion, size, focus: fx });
+    }
+    db.save();
+  }
+  db.save();
+  return { shots, corpus: Object.keys(db.index.clips).length };
+}
+
+/** El trozo del plano cuyos fotogramas se parecen más al momento. */
+function windowFor(shot, meta, frameVecs, seconds, q) {
+  const a = Number(shot.start);
+  const b = Number(shot.end);
+  if (b - a <= seconds + 0.2) return [a, b];
+  let bestT = (a + b) / 2;
+  if (meta?.times?.length && frameVecs.length) {
+    let best = -Infinity;
+    frameVecs.forEach((v, i) => {
+      const s = dot(v, q);
+      if (s > best) {
+        best = s;
+        bestT = meta.times[i];
+      }
+    });
+  }
+  const start = Math.min(Math.max(a + 0.1, bestT - seconds / 2), b - seconds - 0.05);
+  return [+start.toFixed(2), +(start + seconds).toFixed(2)];
+}
+
+export async function edit({ workdir, shots: given = [], beats, allowed = null, preferred = [], minScore = 0.3, minVisual = 0.24, log = () => {} }) {
+  const db = store(workdir);
+  const shotsById = new Map(given.map((s) => [s.clip, s]));
+  const allow = allowed ? new Set(allowed) : null;
+  const prefer = new Set(preferred);
+  const queries = beats.map((b) => String(b.query ?? '').trim().slice(0, 300) || 'a scene');
+  const qvecs = await embedTexts(queries, log);
+  const clips = Object.entries(db.index.clips).map(([id, meta]) => ({ id, ...meta }));
+  const visual = (id, i) => dot(db.vectors(id).pooled, qvecs[i]);
+
+  // Para cada momento: los planos ordenados por lo que ENSEÑAN (CLIP) y, menos, por su etiqueta.
+  const ranked = beats.map((beat, i) => {
+    const fixed = beat.asset;
+    const floor = Number(beat.min_visual ?? minVisual);
+    return clips
+      .filter((c) => (beat.kind === 'video' || beat.kind === 'image' ? c.kind === beat.kind : true))
+      .filter((c) => !allow || allow.has(c.asset))
+      .filter((c) => !fixed || c.asset === fixed)
+      .map((c) => {
+        const v = db.vectors(c.id);
+        const vis = dot(v.pooled, qvecs[i]);
+        return { score: (1 - TAG_WEIGHT) * vis + TAG_WEIGHT * dot(v.tag, qvecs[i]), visual: vis, clip: c };
+      })
+      .filter((x) => fixed || (x.score >= minScore && x.visual >= floor))
+      .sort((p, q) => q.score - p.score);
+  });
+
+  const used = new Set();
+  const picks = new Array(beats.length).fill(null);
+  const choose = (i, avoid) => {
+    const prev = i > 0 ? picks[i - 1]?.clip : null;
+    const next = i + 1 < picks.length ? picks[i + 1]?.clip : null;
+    const fixed = beats[i].asset;
+    let cands = ranked[i].filter((x) => !used.has(x.clip.id) && !avoid.has(x.clip.id) && (fixed || ((!prev || x.clip.asset !== prev.asset) && (!next || x.clip.asset !== next.asset))));
+    if (!cands.length) return null;
+    // Lo que adjuntaron para esta pieza antes que el resto de su biblioteca.
+    const mine = cands.filter((x) => prefer.has(x.clip.asset));
+    if (mine.length) cands = [...mine, ...cands.filter((x) => !prefer.has(x.clip.asset))];
+    let best = cands[0];
+    // Variar el tamaño de plano cuando hay otro casi igual de bueno.
+    if (prev?.size && best.clip.size === prev.size) {
+      const alt = cands.find((x) => x.score >= best.score - 0.02 && x.clip.size !== prev.size);
+      if (alt) best = alt;
+    }
+    return best;
+  };
+  for (let i = 0; i < beats.length; i++) {
+    picks[i] = choose(i, new Set());
+    if (picks[i]) used.add(picks[i].clip.id);
+  }
+  // Casi duplicados (dos planos que se ven iguales): el segundo se cambia por otro distinto.
+  let swapped = 0;
+  const kept = [];
+  for (let i = 0; i < picks.length; i++) {
+    const p = picks[i];
+    if (!p) continue;
+    const pv = db.vectors(p.clip.id).pooled;
+    const dup = kept.some((id) => dot(db.vectors(id).pooled, pv) > NEAR_DUPLICATE);
+    if (dup && !beats[i].asset) {
+      used.delete(p.clip.id);
+      const alt = choose(i, new Set([p.clip.id, ...kept]));
+      picks[i] = alt ?? p;
+      used.add(picks[i].clip.id);
+      if (alt) swapped += 1;
+    }
+    kept.push(picks[i].clip.id);
+  }
+
+  const cut = (i, x, seconds) => {
+    const c = x.clip;
+    const shot = shotsById.get(c.id) ?? { start: c.start ?? 0, end: c.end ?? c.duration ?? 0 };
+    const [a, b] = c.kind === 'video' ? windowFor(shot, c, db.vectors(c.id).frames, seconds, qvecs[i]) : [0, 0];
+    return {
+      beat: beats[i].beat,
+      asset: c.asset,
+      clip: c.id,
+      kind: c.kind,
+      in: a,
+      out: b,
+      score: +x.score.toFixed(4),
+      visual: +visual(c.id, i).toFixed(4),
+      size: c.size || null,
+      motion: +Number(c.motion || 0).toFixed(2),
+      focus: c.focus ?? null,
+    };
+  };
+  const cutsOut = [];
+  const unmatched = [];
+  picks.forEach((p, i) => (p ? cutsOut.push(cut(i, p, Number(beats[i].seconds))) : unmatched.push(beats[i].beat)));
+  // Planos alternativos (subplanos): fuentes distintas, planos sin usar.
+  const alternates = [];
+  beats.forEach((beat, i) => {
+    const want = Number(beat.alternates ?? 0);
+    if (want <= 0 || beat.asset) return;
+    const seen = new Set([picks[i]?.clip.asset]);
+    const part = Number(beat.seconds) / (want + 1);
+    for (const x of ranked[i]) {
+      if (alternates.filter((a) => a.beat === beat.beat).length >= want) break;
+      if (used.has(x.clip.id) || seen.has(x.clip.asset)) continue;
+      used.add(x.clip.id);
+      seen.add(x.clip.asset);
+      alternates.push(cut(i, x, Math.max(1.2, part)));
+    }
+  });
+  return { cuts: cutsOut, alternates, unmatched, swapped };
+}
+
+/**
+ * Juicio de la línea de tiempo terminada. Riesgo de «pase de diapositivas» (0..1, más alto =
+ * peor) por dimensiones, y variedad con sus fallos concretos.
+ */
+export function review({ scenes }) {
+  const n = scenes.length || 1;
+  const pairs = Math.max(1, scenes.length - 1);
+  const same = (f) => scenes.slice(1).filter((s, i) => f(s) && f(s) === f(scenes[i])).length / pairs;
+  const longestRun = (f) => {
+    let best = 0;
+    let run = 0;
+    scenes.forEach((s, i) => {
+      run = i && f(s) === f(scenes[i - 1]) ? run + 1 : 1;
+      best = Math.max(best, run);
+    });
+    return best;
+  };
+  const dimensions = {
+    still_share: scenes.filter((s) => (s.type === 'still' || s.type === 'text_card') && s.shot_language?.camera_movement === 'static').length / n,
+    text_cards: scenes.filter((s) => s.type === 'text_card').length / n,
+    camera_monotony: same((s) => s.shot_language?.camera_movement),
+    size_monotony: same((s) => (s.shot_language?.shot_size === 'none' ? null : s.shot_language?.shot_size)),
+    type_monotony: longestRun((s) => s.type) / n,
+  };
+  const values = Object.values(dimensions);
+  const average = +(values.reduce((a, b) => a + b, 0) / values.length).toFixed(3);
+  const violations = [];
+  const runs = (label, f, min) => {
+    let run = 1;
+    for (let i = 1; i <= scenes.length; i++) {
+      if (i < scenes.length && f(scenes[i]) && f(scenes[i]) === f(scenes[i - 1])) run += 1;
+      else {
+        if (run >= min) violations.push(`${run} consecutive scenes with the same ${label} (${f(scenes[i - 1])}), ending at ${scenes[i - 1].id}`);
+        run = 1;
+      }
+    }
+  };
+  runs('shot size', (s) => (s.shot_language?.shot_size === 'none' ? null : s.shot_language?.shot_size), 3);
+  runs('camera movement', (s) => s.shot_language?.camera_movement, 3);
+  runs('type', (s) => (s.type === 'text_card' ? 'text_card' : null), 3);
+  const score = +Math.max(0, 1 - violations.length / n).toFixed(3);
+  return {
+    slideshow_risk: {
+      average,
+      verdict: average < 0.35 ? 'low' : average < 0.6 ? 'medium' : 'high',
+      dimensions: Object.fromEntries(Object.entries(dimensions).map(([k, v]) => [k, +v.toFixed(3)])),
+    },
+    variation: { score, verdict: violations.length ? 'needs_variety' : 'varied', violations: violations.slice(0, 6), metadata_only: 0 },
+  };
+}

package/src/analysis/runtime.mjs

@@ -0,0 +1,115 @@
+// Lo que el análisis necesita aparte de ffmpeg: onnxruntime (MIT, 1.23.2: la última con
+// binario para Mac Intel) y los modelos (YOLOX, YuNet, PP-OCR, CLIP). Se descargan la primera
+// vez que hacen falta, por separado de la instalación con npx: quien solo renderiza vídeos con
+// Claude nunca los baja. Mismo patrón que los binarios: media.ignix.social + sha256.
+//
+// Orden de búsqueda: variable de entorno (desarrollo) → caché en ~/.ignix-editor → descarga.
+import { createHash } from 'node:crypto';
+import { createReadStream, createWriteStream, existsSync, mkdirSync, readFileSync, renameSync, rmSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { dirname, join } from 'node:path';
+import { Readable } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+import { fileURLToPath } from 'node:url';
+import AdmZip from 'adm-zip';
+import { HOME, PLATFORM } from '../binaries.mjs';
+
+const manifest = JSON.parse(readFileSync(join(dirname(fileURLToPath(import.meta.url)), '..', 'binaries.json'), 'utf8')).analysis;
+
+async function sha256Of(path) {
+  const h = createHash('sha256');
+  await pipeline(createReadStream(path), h);
+  return h.digest('hex');
+}
+
+/** Descarga `url` a `dest` comprobando tamaño y sha256 (sin dejar nada a medias). */
+async function fetchChecked(url, dest, entry, log) {
+  mkdirSync(dirname(dest), { recursive: true });
+  log(`Downloading ${entry.label ?? entry.file} (${(entry.size / 1e6).toFixed(0)} MB, first time only)…`);
+  const res = await fetch(url);
+  if (!res.ok || !res.body) throw new Error(`Could not download ${entry.file}: ${res.status} ${url}`);
+  const part = `${dest}.part`;
+  await pipeline(Readable.fromWeb(res.body), createWriteStream(part));
+  if ((await sha256Of(part)) !== entry.sha256) {
+    rmSync(part, { force: true });
+    throw new Error(`The downloaded ${entry.file} does not match its SHA-256. Not using it.`);
+  }
+  renameSync(part, dest);
+}
+
+let ort = null;
+
+/** onnxruntime-node para esta plataforma (cargado una vez por proceso). */
+export async function loadOrt(log = () => {}) {
+  if (ort) return ort;
+  let dir = process.env.IGNIX_EDITOR_ORT;
+  if (!dir) {
+    const entry = manifest.runtime[PLATFORM];
+    if (!entry) throw new Error(`The analysis runtime is not available for ${PLATFORM} yet.`);
+    dir = join(HOME, 'runtime', `onnxruntime-${manifest.runtimeVersion}`, PLATFORM);
+    if (!existsSync(join(dir, 'onnxruntime-node', 'package.json'))) {
+      const zip = join(HOME, 'runtime', `${entry.file}`);
+      await fetchChecked(`${manifest.baseUrl}/${manifest.version}/runtime/${PLATFORM}/${entry.file}`, zip, { ...entry, label: 'the analysis runtime' }, log);
+      rmSync(dir, { recursive: true, force: true });
+      new AdmZip(zip).extractAllTo(dir, true);
+      rmSync(zip, { force: true });
+    }
+  }
+  ort = createRequire(join(dir, 'onnxruntime-node', 'package.json'))('./');
+  return ort;
+}
+
+/** Ruta local de un modelo de análisis, descargándolo la primera vez. */
+export async function ensureModel(name, log = () => {}) {
+  const entry = manifest.models[name];
+  if (!entry) throw new Error(`Unknown analysis model: ${name}`);
+  const local = process.env.IGNIX_EDITOR_MODELS;
+  if (local) {
+    const p = join(local, entry.file);
+    if (!existsSync(p)) throw new Error(`IGNIX_EDITOR_MODELS has no ${entry.file}`);
+    return p;
+  }
+  const dest = join(HOME, 'models', 'analysis', manifest.version, entry.file);
+  if (existsSync(dest)) return dest;
+  const base = `${manifest.baseUrl}/${manifest.version}/models`;
+  if (!entry.parts) {
+    await fetchChecked(`${base}/${entry.file}`, dest, entry, log);
+    return dest;
+  }
+  // Un modelo de más de 300 MB va en partes (límite de subida a R2): cada una con su sha256 y,
+  // juntas, el sha256 del modelo entero.
+  const pieces = [];
+  for (const [i, part] of entry.parts.entries()) {
+    const p = `${dest}.${i}`;
+    await fetchChecked(`${base}/${part.file}`, p, { ...part, label: `${entry.label ?? entry.file} (${i + 1}/${entry.parts.length})` }, log);
+    pieces.push(p);
+  }
+  const whole = `${dest}.part`;
+  const w = createWriteStream(whole);
+  for (const p of pieces) await pipeline(createReadStream(p), w, { end: false });
+  await new Promise((resolve, reject) => w.end((e) => (e ? reject(e) : resolve())));
+  for (const p of pieces) rmSync(p, { force: true });
+  if ((await sha256Of(whole)) !== entry.sha256) {
+    rmSync(whole, { force: true });
+    throw new Error(`The downloaded ${entry.file} does not match its SHA-256. Not using it.`);
+  }
+  renameSync(whole, dest);
+  return dest;
+}
+
+const sessions = new Map();
+
+/** Sesión de onnxruntime para un modelo (una por proceso y modelo). */
+export async function session(name, log = () => {}) {
+  if (!sessions.has(name)) {
+    const p = (async () => {
+      const o = await loadOrt(log);
+      return o.InferenceSession.create(await ensureModel(name, log), { graphOptimizationLevel: 'all' });
+    })();
+    sessions.set(name, p);
+    p.catch(() => sessions.delete(name));
+  }
+  return sessions.get(name);
+}
+
+export const RUNTIME_VERSION = manifest.runtimeVersion;

package/src/analysis/serve.mjs

@@ -0,0 +1,149 @@
+// `ignix-editor serve`: el Editor como servicio local para Ignix Creator (ADR-0023). Habla
+// líneas JSON por stdin/stdout, una petición y una respuesta por línea:
+//
+//   -> {"id": 1, "op": "hello"}
+//   <- {"id": 1, "ok": true, "result": {...}}
+//
+// Las operaciones y sus respuestas son las que Creator ya usaba con su caja de OpenMontage, así
+// que cambiar de motor no toca su lógica. Todo ocurre en el ordenador: nada sale a la red salvo
+// la primera descarga de lo que falte (binarios, motor de análisis y modelos, con su sha256).
+// Las peticiones se atienden de una en una (el análisis ya usa todos los núcleos).
+import { createInterface } from 'node:readline';
+import { ensureTool, ensureWhisperModel } from '../binaries.mjs';
+import { transcribeDetailed } from '../transcribe.mjs';
+import { faces as detectFaces, people as detectPeople, text as detectText } from './detect.mjs';
+import { frames, probe } from './media.mjs';
+import { analyze, edit, review } from './montage.mjs';
+import { RUNTIME_VERSION, loadOrt } from './runtime.mjs';
+import { cleanVoice, structure } from './sound.mjs';
+
+const MAX_SAMPLES = 2400;
+const log = (...a) => console.error(...a);
+
+async function tools() {
+  return { ffmpeg: await ensureTool('ffmpeg', log), ffprobe: await ensureTool('ffprobe', log) };
+}
+
+export function createOps({ version, engine }) {
+  return {
+    async hello() {
+      const { ffmpeg, ffprobe } = await tools();
+      const ort = await loadOrt(log);
+      return { runner: 'ignix-editor', version, engine, onnxruntime: ort.env?.versions?.common ?? RUNTIME_VERSION, platform: `${process.platform}-${process.arch}`, ffmpeg: !!ffmpeg, ffprobe: !!ffprobe };
+    },
+
+    async transcribe(req) {
+      const { ffmpeg } = await tools();
+      const whisper = await ensureTool('whisper', log);
+      const model = await ensureWhisperModel(req.model ?? 'small', log);
+      return transcribeDetailed({ ffmpeg, whisper, model, input: req.path, language: req.language ?? null });
+    },
+
+    // Dónde está la persona a lo largo del clip (la cara más grande de cada muestra).
+    async faces(req) {
+      const { ffmpeg, ffprobe } = await tools();
+      const info = probe(ffprobe, req.path);
+      const found = [];
+      let sampled = 0;
+      await frames(ffmpeg, req.path, {
+        fps: Number(req.fps ?? 3),
+        max: 640,
+        width: info.width,
+        height: info.height,
+        onFrame: async (f) => {
+          sampled += 1;
+          const all = await detectFaces(f, log);
+          const big = all.sort((a, b) => b.w * b.h - a.w * a.h)[0];
+          if (big) found.push({ t: +f.t.toFixed(3), x: big.x, y: big.y, w: big.w, h: big.h });
+          return found.length < MAX_SAMPLES;
+        },
+      });
+      return { faces: found, sampled };
+    },
+
+    // Cada persona (su cuerpo), las caras vistas DE FRENTE y el texto quemado (una vez por segundo).
+    async people(req) {
+      const { ffmpeg, ffprobe } = await tools();
+      const info = probe(ffprobe, req.path);
+      const fps = Number(req.fps ?? 3);
+      const every = Math.max(1, Math.round(fps));
+      const people = [];
+      const frontal = [];
+      const text = [];
+      let sampled = 0;
+      await frames(ffmpeg, req.path, {
+        fps,
+        max: 960,
+        width: info.width,
+        height: info.height,
+        onFrame: async (f) => {
+          const t = +f.t.toFixed(3);
+          const scale = info.height / f.h;
+          for (const b of await detectPeople(f, log)) people.push({ t, x: b.x, y: b.y, w: b.w, h: b.h });
+          for (const c of (await detectFaces({ ...f, scale }, log)).slice(0, 12)) if (c.frontal) frontal.push({ t, x: c.x, y: c.y, w: c.w, h: c.h });
+          if (sampled % every === 0) for (const b of await detectText(f, log)) text.push({ t, ...b });
+          sampled += 1;
+          return people.length < MAX_SAMPLES;
+        },
+      });
+      return { people: people.slice(0, MAX_SAMPLES), faces: frontal.slice(0, MAX_SAMPLES), text: text.slice(0, MAX_SAMPLES), textChecked: true, sampled };
+    },
+
+    async clean_voice(req) {
+      const { ffmpeg, ffprobe } = await tools();
+      return cleanVoice({ ffmpeg, ffprobe, path: req.path, out: req.out, start: req.start ?? null, end: req.end ?? null });
+    },
+
+    async structure(req) {
+      const { ffmpeg } = await tools();
+      return structure({ ffmpeg, path: req.path });
+    },
+
+    async analyze(req) {
+      const { ffmpeg, ffprobe } = await tools();
+      return analyze({ ffmpeg, ffprobe, workdir: req.workdir, media: req.media ?? [], log });
+    },
+
+    async edit(req) {
+      return edit({
+        workdir: req.workdir,
+        shots: req.shots ?? [],
+        beats: req.beats ?? [],
+        allowed: req.allowed ?? null,
+        preferred: req.preferred ?? [],
+        minScore: Number(req.min_score ?? 0.3),
+        minVisual: Number(req.min_visual ?? 0.24),
+        log,
+      });
+    },
+
+    async review(req) {
+      return review({ scenes: req.scenes ?? [] });
+    },
+  };
+}
+
+export async function serve({ version, engine }) {
+  const ops = createOps({ version, engine });
+  const send = (msg) => process.stdout.write(`${JSON.stringify(msg)}\n`);
+  const lines = createInterface({ input: process.stdin, crlfDelay: Infinity });
+  let queue = Promise.resolve();
+  lines.on('line', (line) => {
+    if (!line.trim()) return;
+    queue = queue.then(async () => {
+      let id = null;
+      try {
+        const msg = JSON.parse(line);
+        id = msg.id ?? null;
+        const op = ops[msg.op];
+        if (!op) throw new Error('unknown op');
+        send({ id, ok: true, result: await op(msg) });
+      } catch (e) {
+        log(e?.stack ?? String(e));
+        send({ id, ok: false, error: `${e?.name ?? 'Error'}: ${String(e?.message ?? e).slice(0, 400)}` });
+      }
+    });
+  });
+  await new Promise((resolve) => lines.on('close', resolve));
+  await queue;
+}