@ignix-social/editor 0.1.3 → 0.1.6

package/src/analysis/runtime.mjs

@@ -0,0 +1,128 @@
+// 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;
+
+/** Lo que falta del análisis en este ordenador, con su tamaño de descarga (sin descargar nada). */
+export function analysisMissing() {
+  const out = [];
+  const rt = manifest.runtime[PLATFORM];
+  const rtDir = join(HOME, 'runtime', `onnxruntime-${manifest.runtimeVersion}`, PLATFORM);
+  if (!process.env.IGNIX_EDITOR_ORT && rt && !existsSync(join(rtDir, 'onnxruntime-node', 'package.json'))) out.push({ item: 'runtime', size: rt.size });
+  for (const [name, entry] of Object.entries(manifest.models)) {
+    if (process.env.IGNIX_EDITOR_MODELS) continue;
+    if (!existsSync(join(HOME, 'models', 'analysis', manifest.version, entry.file))) out.push({ item: name, size: entry.size });
+  }
+  return out;
+}

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/binaries.mjs

@@ -3,7 +3,7 @@
 // descarga desde media.ignix.social con su sha256 comprobado. Chrome lo gestiona el motor
 // (descarga oficial de Google la primera vez).
 import { createHash } from 'node:crypto';
-import { chmodSync, createWriteStream, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { chmodSync, createReadStream, createWriteStream, existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
 import { Readable } from 'node:stream';
 import { pipeline } from 'node:stream/promises';
 import { homedir } from 'node:os';
@@ -62,9 +62,9 @@ export async function ensureTool(name, log = () => {}) {
 
 /** Modelos de whisper (ggml, MIT), en ~/.ignix-editor/models. */
 export const WHISPER_MODELS = {
-  medium: { file: 'ggml-medium.bin', size: 1533763059 },
-  small: { file: 'ggml-small.bin', size: 487601967 },
-  base: { file: 'ggml-base.bin', size: 147951465 },
+  medium: { file: 'ggml-medium.bin', size: 1533763059, sha256: '6c14d5adee5f86394037b4e4e8b59f1673b6cee10e3cf0b11bbdbee79c156208' },
+  small: { file: 'ggml-small.bin', size: 487601967, sha256: '1be3a9b2063867b937e64e2ec7483364a79917e157fa98c5d94b5c1fffea987b' },
+  base: { file: 'ggml-base.bin', size: 147951465, sha256: '60ed5bc3dd14eea856493d334349b405782ddcaf0028d4b5df4088345fba2efe' },
 };
 
 export async function ensureWhisperModel(model = 'medium', log = () => {}) {
@@ -78,6 +78,19 @@ export async function ensureWhisperModel(model = 'medium', log = () => {}) {
   const res = await fetch(`https://huggingface.co/ggerganov/whisper.cpp/resolve/main/${m.file}`);
   if (!res.ok) throw new Error(`Could not download the ${model} model: ${res.status}`);
   await pipeline(Readable.fromWeb(res.body), createWriteStream(`${dest}.part`));
+  // El sha256 es el que publica Hugging Face para ese fichero (su oid de LFS).
+  const h = createHash('sha256');
+  await pipeline(createReadStream(`${dest}.part`), h);
+  if (h.digest('hex') !== m.sha256) {
+    rmSync(`${dest}.part`, { force: true });
+    throw new Error(`The downloaded ${model} model does not match its SHA-256. Not using it.`);
+  }
   renameSync(`${dest}.part`, dest);
   return dest;
 }
+
+/** Ruta del modelo de whisper si ya está descargado (sin descargar nada). */
+export const whisperModelPath = (model) => (WHISPER_MODELS[model] ? join(HOME, 'models', WHISPER_MODELS[model].file) : null);
+
+/** Tamaño de descarga de un binario en esta plataforma (0 si no hay descarga). */
+export const toolSize = (name) => manifest.platforms[PLATFORM]?.[name]?.size ?? 0;