@ignix-social/editor 0.1.3 → 0.1.5

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;
+}

package/src/analysis/sound.mjs

@@ -0,0 +1,99 @@
+// Sonido y ritmo con el ffmpeg del Editor:
+//  · cleanVoice: la voz de un clip, más limpia (medido en Creator, ADR-0022 O1): primero se
+//    MIDE (suelo de ruido = el 10 % más bajo de ventanas de 50 ms; voz = el 10 % más alto) y
+//    luego se limpia con esos números: sin graves de rumor, el ruido constante abajo a su nivel
+//    real, una puerta suave justo encima del suelo y UNA ganancia fija hasta el nivel de voz de
+//    redes, con limitador. Ni compresor ni loudness dinámico: suben las pausas y el ruido con
+//    ellas (medido: −6 a −11 dB de relación voz/ruido con ventilador, zumbido y siseo).
+//  · structure: el ritmo de un vídeo de REFERENCIA (dónde corta y cuánto suena cada medio
+//    segundo). Solo salen números: ni fotogramas ni palabras.
+//  · cuts: dónde cambia de plano un vídeo (detector de cambio de escena de ffmpeg).
+import { spawn, spawnSync } from 'node:child_process';
+import { levels, probe } from './media.mjs';
+
+export const MAX_VOICE_SEC = 3600;
+const SPEECH_TARGET_DB = -14;
+const CLEAN_ENOUGH_DB = 32;
+
+const percentile = (xs, p) => {
+  const s = [...xs].sort((a, b) => a - b);
+  return s[Math.min(s.length - 1, Math.max(0, Math.round((p / 100) * (s.length - 1))))];
+};
+
+export async function cleanVoice({ ffmpeg, ffprobe, path, out, start = null, end = null }) {
+  if (!/\.wav$/i.test(out)) throw new Error('out must be a .wav');
+  let span = null;
+  if (start !== null || end !== null) {
+    const a = Math.max(0, Number(start ?? 0));
+    const b = Number(end);
+    if (!(b > a) || b - a > MAX_VOICE_SEC) throw new Error('bad span');
+    span = [a, b];
+  }
+  const db = await levels(ffmpeg, path, { windowSec: 0.05, start: span?.[0] ?? 0, end: span?.[1] ?? null, maxSec: MAX_VOICE_SEC });
+  if (!db) throw new Error('no audio');
+  if (db.length < 10) throw new Error('too short');
+  const floor = percentile(db, 10);
+  const speech = percentile(db, 90);
+  const chain = ['highpass=f=80'];
+  const denoised = speech - floor < CLEAN_ENOUGH_DB;
+  if (denoised) {
+    chain.push(`afftdn=nr=15:nf=${Math.round(Math.max(-80, Math.min(-20, floor)))}:tn=1`);
+    const threshold = 10 ** ((floor + 8) / 20);
+    chain.push(`agate=mode=downward:range=0.2:threshold=${threshold.toFixed(5)}:ratio=3:attack=5:release=250:knee=4:detection=rms`);
+  }
+  const gain = Math.max(-12, Math.min(18, SPEECH_TARGET_DB - speech));
+  chain.push(`volume=${gain.toFixed(1)}dB`, 'alimiter=limit=0.84:level=false', 'aresample=48000');
+  const args = ['-nostdin', '-hide_banner', '-loglevel', 'error', '-y'];
+  if (span) args.push('-ss', span[0].toFixed(3));
+  args.push('-i', path);
+  if (span) args.push('-t', (span[1] - span[0]).toFixed(3));
+  args.push('-vn', '-af', chain.join(','), '-ac', '1', '-c:a', 'pcm_s16le', out);
+  const r = spawnSync(ffmpeg, args, { encoding: 'utf8' });
+  if (r.status !== 0) throw new Error(`clean_voice: ${(r.stderr || '').slice(-300)}`);
+  const d = probe(ffprobe, out).duration;
+  return {
+    durationSec: +d.toFixed(3),
+    floorDb: +floor.toFixed(1),
+    speechDb: +speech.toFixed(1),
+    denoised,
+    gainDb: +gain.toFixed(1),
+  };
+}
+
+/**
+ * Cambios de plano (segundos). Umbral del detector de ffmpeg (0–100, diferencia media entre
+ * fotogramas) y duración mínima de un plano.
+ */
+export function cuts(ffmpeg, path, { threshold = SCENE_THRESHOLD, minSec = 0.3, maxSec = 600 } = {}) {
+  return new Promise((resolve, reject) => {
+    const p = spawn(ffmpeg, ['-nostdin', '-hide_banner', '-loglevel', 'error', '-t', String(maxSec), '-i', path, '-an', '-vf', `scale=320:-2,scdet=threshold=${threshold}:sc_pass=1,metadata=print:file=-`, '-f', 'null', '-'], { stdio: ['ignore', 'pipe', 'pipe'] });
+    let out = '';
+    let err = '';
+    p.stdout.on('data', (d) => (out += d));
+    p.stderr.on('data', (d) => (err = (err + d).slice(-400)));
+    p.on('error', reject);
+    p.on('close', (code) => {
+      if (code !== 0) return reject(new Error(`scene detection: ${err.trim()}`));
+      const times = [...out.matchAll(/lavfi\.scd\.time=([\d.]+)/g)].map((m) => Number(m[1]));
+      const kept = [];
+      for (const t of times.sort((a, b) => a - b)) {
+        if (t < 0.05) continue;
+        if (!kept.length || t - kept[kept.length - 1] >= minSec) kept.push(+t.toFixed(2));
+      }
+      resolve(kept);
+    });
+  });
+}
+export const SCENE_THRESHOLD = 10;
+
+export const MAX_REFERENCE_SEC = 600;
+
+export async function structure({ ffmpeg, path }) {
+  const c = await cuts(ffmpeg, path, { minSec: 0.3, maxSec: MAX_REFERENCE_SEC });
+  // Cuánto suena cada medio segundo (dBFS del RMS), para la curva de energía.
+  const db = await levels(ffmpeg, path, { windowSec: 0.5, maxSec: MAX_REFERENCE_SEC + 1 }).catch((e) => {
+    if (/too long/.test(e.message)) throw e;
+    return null;
+  });
+  return { cuts: c.slice(0, 600), loudness: (db ?? []).map((v) => +v.toFixed(1)).slice(0, MAX_REFERENCE_SEC * 2) };
+}

package/src/binaries.json

@@ -3,14 +3,150 @@
   "baseUrl": "https://media.ignix.social/editor/bin",
   "platforms": {
     "darwin-x64": {
-      "ffmpeg": { "file": "ffmpeg", "size": 25454144, "sha256": "593bf505c3f4e67c3b24c8b24008577f217178e6b96ffa452f0d63d55f557d41", "build": "ffmpeg 7.1.2 GPL (sin libx264 ni non-free) + VideoToolbox, scripts/build-ffmpeg-macos.sh en Mac Intel" },
-      "ffprobe": { "file": "ffprobe", "size": 25367080, "sha256": "97dae7a58f71a3fa54d11be06c810896504fb70f062396cd466c37f66fe16b1e", "build": "ffmpeg 7.1.2 GPL, scripts/build-ffmpeg-macos.sh en Mac Intel" },
-      "whisper": { "file": "whisper-cli", "size": 2912480, "sha256": "73fc58436c1e1a9d2cc3ea08bddf18bf78270d8c6940c5fd89a3c9cb31535efe", "build": "whisper.cpp v1.7.6, scripts/build-whisper-macos.sh" }
+      "ffmpeg": {
+        "file": "ffmpeg",
+        "size": 25454144,
+        "sha256": "593bf505c3f4e67c3b24c8b24008577f217178e6b96ffa452f0d63d55f557d41",
+        "build": "ffmpeg 7.1.2 GPL (sin libx264 ni non-free) + VideoToolbox, scripts/build-ffmpeg-macos.sh en Mac Intel"
+      },
+      "ffprobe": {
+        "file": "ffprobe",
+        "size": 25367080,
+        "sha256": "97dae7a58f71a3fa54d11be06c810896504fb70f062396cd466c37f66fe16b1e",
+        "build": "ffmpeg 7.1.2 GPL, scripts/build-ffmpeg-macos.sh en Mac Intel"
+      },
+      "whisper": {
+        "file": "whisper-cli",
+        "size": 2912480,
+        "sha256": "73fc58436c1e1a9d2cc3ea08bddf18bf78270d8c6940c5fd89a3c9cb31535efe",
+        "build": "whisper.cpp v1.7.6, scripts/build-whisper-macos.sh"
+      }
     },
     "darwin-arm64": {
-      "ffmpeg": { "file": "ffmpeg", "size": 21133592, "sha256": "47430a1ac61ff5e461c0fd70db9c5feb74557018ede93773bdf98b09297dcd49", "build": "ffmpeg 7.1.2 GPL (sin libx264 ni non-free) + VideoToolbox, CI binaries.yml (macos-15, run 37375441240)" },
-      "ffprobe": { "file": "ffprobe", "size": 21074760, "sha256": "10c338cd1c804222a6c90c24c7c07f73bb07ee0f2d506eff565ca8f5e9fa9a40", "build": "ffmpeg 7.1.2 GPL, CI binaries.yml (macos-15, run 37375441240)" },
-      "whisper": { "file": "whisper-cli", "size": 2573144, "sha256": "215d93a2edc77f8929311f127f368727859e13833e925652315ca5ea774595ee", "build": "whisper.cpp v1.7.6, CI binaries.yml (macos-15, run 37375441240)" }
+      "ffmpeg": {
+        "file": "ffmpeg",
+        "size": 21133592,
+        "sha256": "47430a1ac61ff5e461c0fd70db9c5feb74557018ede93773bdf98b09297dcd49",
+        "build": "ffmpeg 7.1.2 GPL (sin libx264 ni non-free) + VideoToolbox, CI binaries.yml (macos-15, run 37375441240)"
+      },
+      "ffprobe": {
+        "file": "ffprobe",
+        "size": 21074760,
+        "sha256": "10c338cd1c804222a6c90c24c7c07f73bb07ee0f2d506eff565ca8f5e9fa9a40",
+        "build": "ffmpeg 7.1.2 GPL, CI binaries.yml (macos-15, run 37375441240)"
+      },
+      "whisper": {
+        "file": "whisper-cli",
+        "size": 2573144,
+        "sha256": "215d93a2edc77f8929311f127f368727859e13833e925652315ca5ea774595ee",
+        "build": "whisper.cpp v1.7.6, CI binaries.yml (macos-15, run 37375441240)"
+      }
+    },
+    "win32-x64": {
+      "ffmpeg": {
+        "file": "ffmpeg.exe",
+        "size": 23648768,
+        "sha256": "44afa6a014429b21ae647a09f31cb13f66af628e9f5dd66942f61a88a7f1ebfc",
+        "build": "ffmpeg 7.1.2 GPL (sin libx264 ni non-free) + Media Foundation, cruzado con MinGW, CI windows.yml (run 37392626795)"
+      },
+      "ffprobe": {
+        "file": "ffprobe.exe",
+        "size": 23516160,
+        "sha256": "86ddaff3fac842fa833102cdae338cda5f9862b71c1a54682ddc4fd336f3964f",
+        "build": "ffmpeg 7.1.2 GPL, cruzado con MinGW, CI windows.yml (run 37392626795)"
+      },
+      "whisper": {
+        "file": "whisper-cli.exe",
+        "size": 1990144,
+        "sha256": "26cef7a9b82544e4076a4977c93635bb1b324bd5ab3b4301d6d06e8224e580ea",
+        "build": "whisper.cpp v1.7.6, MSVC estático sin OpenMP, CI windows.yml (run 37392626795)"
+      }
+    }
+  },
+  "analysis": {
+    "version": "1",
+    "baseUrl": "https://media.ignix.social/editor/analysis",
+    "runtimeVersion": "1.23.2",
+    "runtime": {
+      "darwin-x64": {
+        "file": "onnxruntime-1.23.2-darwin-x64.zip",
+        "size": 11733354,
+        "sha256": "ff1d13c08e73f238f385205c265fb2d9bc49cab928b2f93263e3699d392742e9",
+        "build": "onnxruntime-node 1.23.2 (npm, MIT), scripts/build-analysis-runtime.mjs"
+      },
+      "darwin-arm64": {
+        "file": "onnxruntime-1.23.2-darwin-arm64.zip",
+        "size": 10537536,
+        "sha256": "dec3b9fddb103048c35a8dbc075a6c9d0c7f94c2ae188e1bb555d9128aee2f22",
+        "build": "onnxruntime-node 1.23.2 (npm, MIT), scripts/build-analysis-runtime.mjs"
+      },
+      "win32-x64": {
+        "file": "onnxruntime-1.23.2-win32-x64.zip",
+        "size": 27455571,
+        "sha256": "1666158dab17be85ce480b0f397c68c0f11c9ae82e40366344b03900b6e70e96",
+        "build": "onnxruntime-node 1.23.2 (npm, MIT), scripts/build-analysis-runtime.mjs"
+      }
+    },
+    "models": {
+      "yolox": {
+        "file": "yolox_s.onnx",
+        "size": 35858002,
+        "sha256": "c5c2d13e59ae883e6af3b45daea64af4833a4951c92d116ec270d9ddbe998063",
+        "label": "the person detector",
+        "source": "opencv/object_detection_yolox@78c368f (Apache-2.0)"
+      },
+      "yunet": {
+        "file": "face_detection_yunet_2023mar.onnx",
+        "size": 232589,
+        "sha256": "8f2383e4dd3cfbb4553ea8718107fc0423210dc964f9f4280604804ed2552fa4",
+        "label": "the face detector",
+        "source": "opencv/face_detection_yunet@3cc26e7 (MIT)"
+      },
+      "ppocr": {
+        "file": "ppocr_det.onnx",
+        "size": 2423490,
+        "sha256": "03f550c6b406fda8bf54bd8327815f6c7e2edd98cea02348c93d879254366587",
+        "label": "the text detector",
+        "source": "opencv/text_detection_ppocr@c299e81 (Apache-2.0)"
+      },
+      "clip_vision": {
+        "file": "clip-vit-b32-vision.onnx",
+        "size": 351685709,
+        "sha256": "fd6e1402a588279d1723c7534d4bcba5bc0b14b47dfab0e46f8c47b8270d7d40",
+        "label": "the image matcher",
+        "source": "Xenova/clip-vit-base-patch32@d15189d onnx/vision_model.onnx (MIT, openai/clip-vit-base-patch32)",
+        "parts": [
+          {
+            "file": "clip-vit-b32-vision.onnx.partaa",
+            "size": 200000000,
+            "sha256": "d34cb7664dd8897e6acb806703f937b307ce20aa5bbff9209b8911028318e2ea"
+          },
+          {
+            "file": "clip-vit-b32-vision.onnx.partab",
+            "size": 151685709,
+            "sha256": "f046802f8bb8fd4e50584a0295809cb386167cb56dfb76cb163911540f0e2e62"
+          }
+        ]
+      },
+      "clip_text": {
+        "file": "clip-vit-b32-text.onnx",
+        "size": 254058553,
+        "sha256": "3f6571f5bad13a97c469c1622e1cfc4d9aef78b79fdbfcff804ca357bfada8cc",
+        "label": "the text matcher",
+        "source": "Xenova/clip-vit-base-patch32@d15189d onnx/text_model.onnx (MIT)"
+      },
+      "clip_vocab": {
+        "file": "clip-vocab.json",
+        "size": 862328,
+        "sha256": "5047b556ce86ccaf6aa22b3ffccfc52d391ea4accdab9c2f2407da5b742d4363",
+        "source": "Xenova/clip-vit-base-patch32@d15189d (MIT)"
+      },
+      "clip_merges": {
+        "file": "clip-merges.txt",
+        "size": 524619,
+        "sha256": "9fd691f7c8039210e0fced15865466c65820d09b63988b0174bfe25de299051a",
+        "source": "Xenova/clip-vit-base-patch32@d15189d (MIT)"
+      }
     }
   }
 }

package/src/cli.mjs

@@ -2,17 +2,19 @@
 // debajo con nuestro entorno: sin telemetría, sin actualizaciones solas, con nuestros binarios.
 // Los mensajes van en inglés, como el manual y la skill: los lee sobre todo el agente.
 import { spawnSync } from 'node:child_process';
-import { createHash } from 'node:crypto';
-import { cpSync, existsSync, mkdirSync, readFileSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
+import { cpSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { createRequire } from 'node:module';
 import { homedir } from 'node:os';
 import { basename, dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { HOME, PLATFORM, TOOLS, ensureTool, ensureWhisperModel, findTool } from './binaries.mjs';
-import { prepare, projectHtml } from './prepare.mjs';
+import { linkMedia, prepare, projectHtml } from './prepare.mjs';
 import { validateHtml } from './validate.mjs';
 import { loudness, hasAudio, normalizeLoudness } from './audio.mjs';
 import { alignToScript, transcribe } from './transcribe.mjs';
+import { faces as detectFaces } from './analysis/detect.mjs';
+import { frames, probe } from './analysis/media.mjs';
+import { serve } from './analysis/serve.mjs';
 
 const PKG_DIR = join(dirname(fileURLToPath(import.meta.url)), '..');
 const PKG = JSON.parse(readFileSync(join(PKG_DIR, 'package.json'), 'utf8'));
@@ -77,8 +79,8 @@ async function engineEnv() {
   const shim = join(HOME, 'shim', PLATFORM);
   rmSync(shim, { recursive: true, force: true });
   mkdirSync(shim, { recursive: true });
-  symlinkSync(ffmpeg, join(shim, TOOLS.ffmpeg.file));
-  symlinkSync(ffprobe, join(shim, TOOLS.ffprobe.file));
+  linkMedia(ffmpeg, join(shim, TOOLS.ffmpeg.file));
+  linkMedia(ffprobe, join(shim, TOOLS.ffprobe.file));
   env.PATH = `${shim}${process.platform === 'win32' ? ';' : ':'}${env.PATH ?? ''}`;
   return { env, ffmpeg, ffprobe };
 }
@@ -129,8 +131,10 @@ const commands = {
     const ff = findTool('ffmpeg').path;
     if (ff) {
       const enc = spawnSync(ff, ['-hide_banner', '-encoders'], { encoding: 'utf8' }).stdout ?? '';
-      const h264 = /\blibx264\b/.test(enc) ? 'libx264' : /\bh264_videotoolbox\b/.test(enc) ? 'VideoToolbox' : null;
-      log(`${h264 ? '✓' : '✗'} H.264 encoder: ${h264 ?? 'none (needs libx264 or VideoToolbox)'}`);
+      // Lo mismo que acepta el motor (con el parche mf-encoder): libx264, VideoToolbox (Mac) o
+      // Media Foundation (Windows); NVIDIA/Intel/AMD si el ffmpeg los trae.
+      const h264 = /\blibx264\b/.test(enc) ? 'libx264' : /\bh264_videotoolbox\b/.test(enc) ? 'VideoToolbox' : /\bh264_mf\b/.test(enc) ? 'Media Foundation' : /\bh264_(nvenc|qsv|amf)\b/.test(enc) ? 'GPU' : null;
+      log(`${h264 ? '✓' : '✗'} H.264 encoder: ${h264 ?? 'none (needs libx264, VideoToolbox or Media Foundation)'}`);
       if (!h264) ok = false;
     }
     log(ok ? '✓ Ready.' : '✗ Not ready: see the lines above.');
@@ -232,27 +236,28 @@ const commands = {
     } else console.log(json);
   },
 
-  // Dónde está la cara a lo largo del vídeo, para encuadrar en vertical siguiéndola.
-  // macOS: Apple Vision desde un Swift propio (src/native/faces.swift), compilado una vez.
+  // Dónde está la cara a lo largo del vídeo, para encuadrar en vertical siguiéndola. YuNet sobre
+  // onnxruntime (igual en Mac y en Windows); el motor y el modelo se descargan la primera vez.
   async faces(argv) {
     const { pos, opts } = parseArgs(argv, { every: 'str', output: 'str', smooth: 'str' });
     const input = pos[0] && resolve(pos[0]);
     if (!input || !existsSync(input)) fail('Usage: ignix-editor faces <video> [--every 0.2] [--smooth 1] [-o work/faces.json]');
-    if (process.platform !== 'darwin') fail('faces needs macOS for now. Elsewhere, frame the person by hand from stills (snapshot) or keep a centred crop.');
-    const src = join(PKG_DIR, 'src', 'native', 'faces.swift');
-    const hash = createHash('sha256').update(readFileSync(src)).digest('hex').slice(0, 12);
-    const bin = join(HOME, 'bin', PLATFORM, `faces-${hash}`);
-    if (!existsSync(bin)) {
-      mkdirSync(dirname(bin), { recursive: true });
-      log('Compiling the face tracker (first time only)…');
-      const c = spawnSync('xcrun', ['swiftc', '-O', '-parse-as-library', src, '-o', bin], { encoding: 'utf8' });
-      if (c.status !== 0) fail(`Could not compile the face tracker. It needs Apple's Command Line Tools (xcode-select --install).\n${(c.stderr || c.error?.message || '').slice(-400)}`);
-    }
+    const ffmpeg = await ensureTool('ffmpeg', log);
+    const ffprobe = await ensureTool('ffprobe', log);
     const every = Math.max(0.05, Number(opts.every ?? 0.2));
-    const r = spawnSync(bin, [input, String(every)], { encoding: 'utf8', maxBuffer: 256 * 1024 * 1024 });
-    if (r.status !== 0) fail(`Face tracking failed: ${(r.stderr || '').slice(-400)}`);
-    const raw = JSON.parse(r.stdout);
-    const S = raw.samples;
+    const info = probe(ffprobe, input);
+    const S = [];
+    await frames(ffmpeg, input, {
+      fps: 1 / every,
+      max: 640,
+      width: info.width,
+      height: info.height,
+      onFrame: async (f) => {
+        const big = (await detectFaces(f, log)).sort((a, b) => b.w * b.h - a.w * a.h)[0];
+        S.push(big ? { t: +f.t.toFixed(3), x: big.x, y: big.y, w: big.w, h: big.h } : { t: +f.t.toFixed(3), x: 0, y: 0, w: 0, h: 0 });
+      },
+    });
+    const raw = { width: info.width, height: info.height, duration: info.duration };
     // Huecos sin cara: la posición conocida más cercana; si no hay ninguna, el centro.
     const known = S.map((x, i) => (x.w ? i : -1)).filter((i) => i >= 0);
     const filled = S.map((x, i) => {
@@ -279,6 +284,11 @@ const commands = {
     } else console.log(json);
   },
 
+  // Servicio local para Ignix Creator: líneas JSON por stdin/stdout (ADR-0023).
+  async serve() {
+    await serve({ version: PKG.version, engine: UPSTREAM.version });
+  },
+
   async ffmpeg(argv) {
     const r = spawnSync(await ensureTool('ffmpeg', log), argv, { stdio: 'inherit' });
     process.exit(r.status ?? 1);
@@ -312,9 +322,10 @@ const commands = {
   ignix-editor render [folder] [-o out.mp4] [--lufs -14] [--no-normalize]
   ignix-editor preview [folder]                live preview in the browser
   ignix-editor transcribe <file> [--lang es] [--script "text"] [-o words.json]
-  ignix-editor faces <video> [--every 0.2] [-o faces.json]   where the face is, smoothed (macOS)
+  ignix-editor faces <video> [--every 0.2] [-o faces.json]   where the face is, smoothed
   ignix-editor ffmpeg|ffprobe <args>           Ignix Editor's own ffmpeg
   ignix-editor skills add                      installs the skill for Claude
+  ignix-editor serve                           local service for Ignix Creator (JSON lines on stdin/stdout)
 
 The folder defaults to the current one. Based on HyperFrames (Apache-2.0) by HeyGen, Inc. See NOTICE.`);
   },