@ignix-social/editor 0.1.0

package/src/audio.mjs

@@ -0,0 +1,31 @@
+// Volumen final a −14 LUFS (lo que reproduce Instagram), en dos pasadas de loudnorm.
+// El mezclador del motor no normaliza: en la cata 2 la edición salió a −16,1 y el reel a −15,0.
+import { spawnSync } from 'node:child_process';
+
+function ffmpegRun(ffmpeg, args) {
+  const r = spawnSync(ffmpeg, ['-nostdin', '-hide_banner', ...args], { encoding: 'utf8', maxBuffer: 64 * 1024 * 1024 });
+  if (r.status !== 0) throw new Error(`ffmpeg falló: ${(r.stderr || r.error?.message || '').slice(-400)}`);
+  return r.stderr; // ffmpeg informa por stderr
+}
+
+export function hasAudio(ffprobe, input) {
+  const r = spawnSync(ffprobe, ['-v', 'error', '-select_streams', 'a', '-show_entries', 'stream=index', '-of', 'csv=p=0', input], { encoding: 'utf8' });
+  return r.status === 0 && r.stdout.trim().length > 0;
+}
+
+/** Sonoridad integrada (LUFS) de un fichero. */
+export function loudness(ffmpeg, input) {
+  const text = ffmpegRun(ffmpeg, ['-i', input, '-af', 'ebur128', '-f', 'null', '-']);
+  const m = text.slice(text.lastIndexOf('Summary:')).match(/I:\s+(-?[\d.]+) LUFS/);
+  return m ? Number(m[1]) : null;
+}
+
+/** Copia `input` en `output` con el audio normalizado; el vídeo no se recodifica. */
+export function normalizeLoudness(ffmpeg, input, output, { lufs = -14, tp = -1, lra = 11 } = {}) {
+  const base = `loudnorm=I=${lufs}:TP=${tp}:LRA=${lra}`;
+  const report = ffmpegRun(ffmpeg, ['-i', input, '-af', `${base}:print_format=json`, '-f', 'null', '-']);
+  const s = JSON.parse(report.slice(report.lastIndexOf('{'), report.lastIndexOf('}') + 1));
+  const filter = `${base}:measured_I=${s.input_i}:measured_TP=${s.input_tp}:measured_LRA=${s.input_lra}:measured_thresh=${s.input_thresh}:offset=${s.target_offset}:linear=true`;
+  ffmpegRun(ffmpeg, ['-y', '-i', input, '-c:v', 'copy', '-af', filter, '-ar', '48000', '-c:a', 'aac', '-b:a', '192k', '-movflags', '+faststart', output]);
+  return { before: Number(s.input_i), after: lufs };
+}

package/src/binaries.json

@@ -0,0 +1,46 @@
+{
+  "version": "1",
+  "baseUrl": "https://media.ignix.social/editor/bin",
+  "platforms": {
+    "darwin-x64": {
+      "ffmpeg": {
+        "file": "ffmpeg",
+        "size": 25060568,
+        "sha256": "d4d01b1c196a4c6e3000be608f906991fe41914840a1ce0dcdf66256c3ee4c40",
+        "build": "ffmpeg 7.1.2 LGPL + VideoToolbox, scripts/build-ffmpeg-macos.sh"
+      },
+      "ffprobe": {
+        "file": "ffprobe",
+        "size": 24973512,
+        "sha256": "dd9f843f01a934c8358c9a235d8e44349fe50692418dd79ba328be7f4fecbd85",
+        "build": "ffmpeg 7.1.2 LGPL, scripts/build-ffmpeg-macos.sh"
+      },
+      "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": 20858536,
+        "sha256": "ba5d9f9e59dd9588b88c97a526d971d07ccc60d1f101f47e2f9fac3c03ff2846",
+        "build": "ffmpeg 7.1.2 LGPL + VideoToolbox, CI binaries.yml (macos-15, run 37322341901)"
+      },
+      "ffprobe": {
+        "file": "ffprobe",
+        "size": 20799752,
+        "sha256": "5c7c6da2f0a7c14ac7aaf934afdfd6e0efa232955226a287b986fcb37e5992b9",
+        "build": "ffmpeg 7.1.2 LGPL, CI binaries.yml (macos-15, run 37322341901)"
+      },
+      "whisper": {
+        "file": "whisper-cli",
+        "size": 2573144,
+        "sha256": "215d93a2edc77f8929311f127f368727859e13833e925652315ca5ea774595ee",
+        "build": "whisper.cpp v1.7.6, CI binaries.yml (macos-15, run 37322341901)"
+      }
+    }
+  }
+}

package/src/binaries.mjs

@@ -0,0 +1,83 @@
+// Binarios nativos que Ignix Editor necesita (ffmpeg, ffprobe, whisper-cli) por sistema.
+// Orden de búsqueda: variable de entorno → caché (~/.ignix-editor/bin/<plataforma>) →
+// 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 { Readable } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+export const HOME = process.env.IGNIX_EDITOR_HOME || join(homedir(), '.ignix-editor');
+export const PLATFORM = `${process.platform}-${process.arch}`; // darwin-x64, darwin-arm64, win32-x64…
+const EXE = process.platform === 'win32' ? '.exe' : '';
+
+const manifest = JSON.parse(readFileSync(join(dirname(fileURLToPath(import.meta.url)), 'binaries.json'), 'utf8'));
+
+export const TOOLS = {
+  ffmpeg: { env: 'IGNIX_EDITOR_FFMPEG', file: `ffmpeg${EXE}` },
+  ffprobe: { env: 'IGNIX_EDITOR_FFPROBE', file: `ffprobe${EXE}` },
+  whisper: { env: 'IGNIX_EDITOR_WHISPER', file: `whisper-cli${EXE}` },
+};
+
+const binDir = () => join(HOME, 'bin', PLATFORM, manifest.version);
+
+/** Ruta del binario si ya está disponible, sin descargar nada. */
+export function findTool(name) {
+  const t = TOOLS[name];
+  const fromEnv = process.env[t.env];
+  if (fromEnv) return existsSync(fromEnv) ? { path: fromEnv, source: 'env' } : { path: null, source: 'env', error: `${t.env} apunta a ${fromEnv}, que no existe` };
+  const cached = join(binDir(), t.file);
+  if (existsSync(cached)) return { path: cached, source: 'cache' };
+  const entry = manifest.platforms[PLATFORM]?.[name];
+  return { path: null, source: entry ? 'download' : 'unavailable' };
+}
+
+/** Ruta del binario, descargándolo la primera vez. */
+export async function ensureTool(name, log = () => {}) {
+  const found = findTool(name);
+  if (found.path) return found.path;
+  if (found.error) throw new Error(found.error);
+  const entry = manifest.platforms[PLATFORM]?.[name];
+  if (!entry) {
+    throw new Error(`${name} todavía no está publicado para ${PLATFORM}. Mientras tanto, apunta ${TOOLS[name].env} a un ${TOOLS[name].file} local.`);
+  }
+  const url = `${manifest.baseUrl}/${manifest.version}/${PLATFORM}/${entry.file}`;
+  log(`Descargando ${name} (${(entry.size / 1e6).toFixed(0)} MB)…`);
+  const res = await fetch(url);
+  if (!res.ok) throw new Error(`No se pudo descargar ${name}: ${res.status} ${url}`);
+  const buf = Buffer.from(await res.arrayBuffer());
+  const sha = createHash('sha256').update(buf).digest('hex');
+  if (sha !== entry.sha256) throw new Error(`El ${name} descargado no coincide con su huella (sha256). No se usa.`);
+  const dir = binDir();
+  mkdirSync(dir, { recursive: true });
+  const dest = join(dir, TOOLS[name].file);
+  writeFileSync(`${dest}.part`, buf);
+  chmodSync(`${dest}.part`, 0o755);
+  renameSync(`${dest}.part`, dest);
+  return dest;
+}
+
+/** 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 },
+};
+
+export async function ensureWhisperModel(model = 'medium', log = () => {}) {
+  const m = WHISPER_MODELS[model];
+  if (!m) throw new Error(`Modelo desconocido: ${model}. Opciones: ${Object.keys(WHISPER_MODELS).join(', ')}`);
+  const dir = join(HOME, 'models');
+  const dest = join(dir, m.file);
+  if (existsSync(dest)) return dest;
+  mkdirSync(dir, { recursive: true });
+  log(`Descargando el modelo de transcripción ${model} (${(m.size / 1e9).toFixed(1)} GB, solo la primera vez)…`);
+  const res = await fetch(`https://huggingface.co/ggerganov/whisper.cpp/resolve/main/${m.file}`);
+  if (!res.ok) throw new Error(`No se pudo descargar el modelo ${model}: ${res.status}`);
+  await pipeline(Readable.fromWeb(res.body), createWriteStream(`${dest}.part`));
+  renameSync(`${dest}.part`, dest);
+  return dest;
+}

package/src/cli.mjs

@@ -0,0 +1,254 @@
+// ignix-editor — CLI de Ignix Editor. El motor (HyperFrames, en vendor/) corre siempre por
+// debajo con nuestro entorno: sin telemetría, sin actualizaciones solas, con nuestros binarios.
+import { spawnSync } from 'node:child_process';
+import { cpSync, existsSync, mkdirSync, readFileSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
+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 { validateHtml } from './validate.mjs';
+import { loudness, hasAudio, normalizeLoudness } from './audio.mjs';
+import { alignToScript, transcribe } from './transcribe.mjs';
+
+const PKG_DIR = join(dirname(fileURLToPath(import.meta.url)), '..');
+const PKG = JSON.parse(readFileSync(join(PKG_DIR, 'package.json'), 'utf8'));
+const ENGINE = join(PKG_DIR, 'vendor', 'hyperframes', 'bin', 'hyperframes.mjs');
+const UPSTREAM = JSON.parse(readFileSync(join(PKG_DIR, 'vendor', 'hyperframes', 'UPSTREAM.json'), 'utf8'));
+export const VIDEOS_DIR = join(homedir(), 'ignix-videos');
+
+const log = (...a) => console.error(...a);
+const fail = (msg) => {
+  log(`✗ ${msg}`);
+  process.exit(1);
+};
+
+// ── argumentos: posicionales, nuestras opciones y el resto pasa al motor tal cual
+function parseArgs(argv, ours) {
+  const pos = [];
+  const opts = {};
+  const rest = [];
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    const m = a.match(/^--([^=]+)(?:=(.*))?$/);
+    const key = m?.[1] ?? (a === '-o' ? 'output' : null);
+    if (key && key in ours) {
+      if (ours[key] === 'bool') opts[key] = m?.[2] !== 'false';
+      else opts[key] = m?.[2] ?? argv[++i];
+    } else if (key && key.startsWith('no-') && key.slice(3) in ours && ours[key.slice(3)] === 'bool') opts[key.slice(3)] = false;
+    else if (a.startsWith('-')) rest.push(a);
+    else if (rest.length && rest[rest.length - 1].startsWith('-') && !rest[rest.length - 1].includes('=') && pos.length >= 1) rest.push(a);
+    else pos.push(a);
+  }
+  return { pos, opts, rest };
+}
+
+// ── el motor
+async function engineEnv() {
+  const env = {
+    ...process.env,
+    HYPERFRAMES_NO_TELEMETRY: '1',
+    DO_NOT_TRACK: '1',
+    HYPERFRAMES_NO_UPDATE_CHECK: '1',
+    HYPERFRAMES_NO_AUTO_INSTALL: '1',
+    HYPERFRAMES_SKIP_SKILLS: '1',
+    HYPERFRAMES_FONT_CACHE_DIR: join(HOME, 'cache', 'fonts'),
+  };
+  const ffmpeg = await ensureTool('ffmpeg', log);
+  const ffprobe = await ensureTool('ffprobe', log);
+  env.HYPERFRAMES_FFMPEG_PATH = ffmpeg;
+  env.HYPERFRAMES_FFPROBE_PATH = ffprobe;
+  const whisper = findTool('whisper');
+  if (whisper.path) env.HYPERFRAMES_WHISPER_PATH = whisper.path;
+  // Por si alguna parte del motor llama a «ffmpeg» por su nombre: los nuestros van primero en el PATH.
+  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));
+  env.PATH = `${shim}${process.platform === 'win32' ? ';' : ':'}${env.PATH ?? ''}`;
+  return { env, ffmpeg, ffprobe };
+}
+
+function runEngine(args, env, cwd) {
+  const r = spawnSync(process.execPath, [ENGINE, ...args], { stdio: 'inherit', env, cwd });
+  return r.status ?? 1;
+}
+
+// ── comprobaciones propias
+function validateProject(dir) {
+  const issues = projectHtml(dir).flatMap(validateHtml);
+  for (const i of issues) log(`${i.level === 'error' ? '✗' : '⚠'} ${i.rule} ${i.file.replace(dir + '/', '')}:${i.line} — ${i.msg}`);
+  const errors = issues.filter((i) => i.level === 'error').length;
+  log(errors ? `✗ ${errors} error(es) de Ignix Editor` : `✓ Ignix Editor: HTML y recursos correctos${issues.length ? ` (${issues.length} aviso(s))` : ''}`);
+  return errors;
+}
+
+const projectDir = (p) => {
+  const dir = resolve(p ?? '.');
+  if (!existsSync(join(dir, 'index.html'))) fail(`No hay index.html en ${dir}. ¿Es la carpeta del proyecto? (créala con: ignix-editor init <nombre>)`);
+  return dir;
+};
+
+// ── comandos
+const commands = {
+  async doctor() {
+    const major = Number(process.versions.node.split('.')[0]);
+    log(`${major >= 22 ? '✓' : '✗'} Node ${process.versions.node}${major >= 22 ? '' : ' — hace falta Node 22 o superior'}`);
+    log(`✓ Ignix Editor ${PKG.version} · motor HyperFrames ${UPSTREAM.version} (parches: ${UPSTREAM.patches.join(', ')})`);
+    log(`  Plataforma ${PLATFORM} · datos en ${HOME}`);
+    let ok = major >= 22;
+    for (const name of Object.keys(TOOLS)) {
+      const f = findTool(name);
+      const line = f.path ? `✓ ${name}: ${f.path}${f.source === 'env' ? ' (variable de entorno)' : ''}` : f.error ? `✗ ${name}: ${f.error}` : f.source === 'download' ? `• ${name}: se descargará la primera vez` : `✗ ${name}: aún no publicado para ${PLATFORM} (apunta ${TOOLS[name].env} a uno local)`;
+      log(line);
+      if (!f.path && f.source !== 'download' && name !== 'whisper') ok = false;
+    }
+    if (findTool('ffmpeg').path) {
+      const enc = spawnSync(findTool('ffmpeg').path, ['-hide_banner', '-encoders'], { encoding: 'utf8' }).stdout ?? '';
+      const h264 = /\blibx264\b/.test(enc) ? 'libx264' : /\bh264_videotoolbox\b/.test(enc) ? 'VideoToolbox' : null;
+      log(`${h264 ? '✓' : '✗'} codificador H.264: ${h264 ?? 'ninguno (hace falta libx264 o VideoToolbox)'}`);
+      if (!h264) ok = false;
+    }
+    process.exit(ok ? 0 : 1);
+  },
+
+  async init(argv) {
+    const { pos, opts } = parseArgs(argv, { dir: 'str' });
+    const name = pos[0];
+    if (!name || !/^[\w.-]+$/.test(name)) fail('Uso: ignix-editor init <nombre> [--dir carpeta]  (nombre sin espacios)');
+    const dir = resolve(opts.dir ?? join(VIDEOS_DIR, name));
+    if (existsSync(dir)) fail(`${dir} ya existe. Elige otro nombre o trabaja dentro de ese proyecto.`);
+    cpSync(join(PKG_DIR, 'templates', 'blank'), dir, { recursive: true });
+    mkdirSync(join(dir, 'assets', 'fonts'), { recursive: true });
+    cpSync(join(PKG_DIR, 'node_modules', 'gsap', 'dist', 'gsap.min.js'), join(dir, 'assets', 'gsap.min.js'));
+    for (const w of [700, 800, 900]) {
+      for (const sub of ['latin', 'latin-ext']) {
+        const f = `montserrat-${sub}-${w}-normal.woff2`;
+        cpSync(join(PKG_DIR, 'node_modules', '@fontsource', 'montserrat', 'files', f), join(dir, 'assets', 'fonts', f));
+      }
+    }
+    cpSync(join(PKG_DIR, 'src', 'runtime', 'ignix-frame.js'), join(dir, 'ignix-frame.js'));
+    const html = readFileSync(join(dir, 'index.html'), 'utf8').replaceAll('__ID__', name.toLowerCase().replace(/[^a-z0-9]+/g, '-'));
+    writeFileSync(join(dir, 'index.html'), html);
+    console.log(dir);
+  },
+
+  async check(argv) {
+    const { pos, rest } = parseArgs(argv, {});
+    const dir = projectDir(pos[0]);
+    const errors = validateProject(dir);
+    const { build, snapped } = prepare(dir);
+    if (snapped) log(`• ${snapped} tiempo(s) ajustado(s) al fotograma`);
+    const { env } = await engineEnv();
+    const code = runEngine(['check', build, ...rest], env, dir);
+    process.exit(errors ? 1 : code);
+  },
+
+  async snapshot(argv) {
+    const { pos, rest } = parseArgs(argv, { output: 'str' });
+    const dir = projectDir(pos[0]);
+    const { build } = prepare(dir);
+    const { env } = await engineEnv();
+    const out = resolve(dir, 'snapshots');
+    rmSync(out, { recursive: true, force: true });
+    process.exit(runEngine(['snapshot', build, '-o', out, '--describe', 'false', ...rest], env, dir));
+  },
+
+  async render(argv) {
+    const { pos, opts, rest } = parseArgs(argv, { output: 'str', lufs: 'str', normalize: 'bool', force: 'bool' });
+    const dir = projectDir(pos[0]);
+    if (validateProject(dir) && !opts.force) fail('Arregla los errores de arriba antes de renderizar (o --force si sabes lo que haces).');
+    const { build, snapped } = prepare(dir);
+    if (snapped) log(`• ${snapped} tiempo(s) ajustado(s) al fotograma`);
+    const { env, ffmpeg, ffprobe } = await engineEnv();
+    const output = resolve(opts.output ?? join(dir, 'renders', `${basename(dir)}.mp4`));
+    mkdirSync(dirname(output), { recursive: true });
+    const raw = join(build, 'raw.mp4');
+    const code = runEngine(['render', build, '-o', raw, ...rest], env, dir);
+    if (code !== 0 || !existsSync(raw)) fail('El render falló (mira los mensajes de arriba).');
+    if (opts.normalize !== false && hasAudio(ffprobe, raw)) {
+      const lufs = Number(opts.lufs ?? -14);
+      const r = normalizeLoudness(ffmpeg, raw, output, { lufs });
+      log(`✓ Volumen: ${r.before.toFixed(1)} → ${loudness(ffmpeg, output)?.toFixed(1)} LUFS`);
+    } else cpSync(raw, output);
+    console.log(output);
+  },
+
+  async preview(argv) {
+    const { pos, rest } = parseArgs(argv, {});
+    const dir = projectDir(pos[0]);
+    const { build } = prepare(dir);
+    const { env } = await engineEnv();
+    log('Vista previa de la copia de trabajo: si cambias el proyecto, vuelve a lanzar este comando.');
+    process.exit(runEngine(['preview', build, ...rest], env, dir));
+  },
+
+  async transcribe(argv) {
+    const { pos, opts } = parseArgs(argv, { lang: 'str', model: 'str', script: 'str', output: 'str', threads: 'str' });
+    const input = pos[0] && resolve(pos[0]);
+    if (!input || !existsSync(input)) fail('Uso: ignix-editor transcribe <audio|vídeo> [--lang es] [--model medium] [--script "texto dicho"] [-o palabras.json]');
+    const ffmpeg = await ensureTool('ffmpeg', log);
+    const ffprobe = await ensureTool('ffprobe', log);
+    const whisper = await ensureTool('whisper', log);
+    const model = await ensureWhisperModel(opts.model ?? 'medium', log);
+    let words = transcribe({ ffmpeg, whisper, model, input, language: opts.lang ?? 'es', threads: Number(opts.threads ?? 8) });
+    if (opts.script) {
+      const dur = Number(spawnSync(ffprobe, ['-v', 'error', '-show_entries', 'format=duration', '-of', 'csv=p=0', input], { encoding: 'utf8' }).stdout.trim());
+      words = alignToScript(opts.script, words, dur);
+    }
+    const json = JSON.stringify({ language: opts.lang ?? 'es', words }, null, 1);
+    if (opts.output) writeFileSync(resolve(opts.output), json);
+    else console.log(json);
+  },
+
+  async ffmpeg(argv) {
+    const r = spawnSync(await ensureTool('ffmpeg', log), argv, { stdio: 'inherit' });
+    process.exit(r.status ?? 1);
+  },
+
+  async ffprobe(argv) {
+    const r = spawnSync(await ensureTool('ffprobe', log), argv, { stdio: 'inherit' });
+    process.exit(r.status ?? 1);
+  },
+
+  async skills(argv) {
+    const { pos, opts } = parseArgs(argv, { dir: 'str' });
+    if (pos[0] !== 'add') fail('Uso: ignix-editor skills add [--dir ~/.claude/skills]');
+    const target = resolve(opts.dir ?? join(homedir(), '.claude', 'skills'), 'ignix-editor');
+    rmSync(target, { recursive: true, force: true });
+    cpSync(join(PKG_DIR, 'skills', 'ignix-editor'), target, { recursive: true });
+    log(`✓ Skill instalada en ${target}`);
+  },
+
+  async version() {
+    console.log(`ignix-editor ${PKG.version} (motor HyperFrames ${UPSTREAM.version})`);
+  },
+
+  async help() {
+    console.log(`Ignix Editor ${PKG.version} — vídeo con HTML, renderizado en tu ordenador.
+
+  ignix-editor doctor                      comprueba Node, ffmpeg, whisper y el codificador
+  ignix-editor init <nombre>               crea ~/ignix-videos/<nombre> listo para trabajar
+  ignix-editor check [carpeta]             HTML, recursos, maqueta, movimiento y contraste
+  ignix-editor snapshot [carpeta] --at 0,2.5,5   fotogramas sueltos para revisar
+  ignix-editor render [carpeta] [-o salida.mp4] [--lufs -14] [--no-normalize]
+  ignix-editor preview [carpeta]           vista previa en el navegador
+  ignix-editor transcribe <fichero> [--lang es] [--script "texto"] [-o palabras.json]
+  ignix-editor ffmpeg|ffprobe <args>       el ffmpeg de Ignix Editor
+  ignix-editor skills add                  instala la skill para Claude
+
+Basado en HyperFrames (Apache-2.0) de HeyGen, Inc. Ver NOTICE.`);
+  },
+};
+
+export async function main(argv) {
+  const [cmd = 'help', ...rest] = argv;
+  const fn = commands[cmd === '--version' || cmd === '-v' ? 'version' : cmd === '--help' || cmd === '-h' ? 'help' : cmd];
+  if (!fn) fail(`Comando desconocido: ${cmd}. Usa: ignix-editor help`);
+  try {
+    await fn(rest);
+  } catch (e) {
+    fail(e.message);
+  }
+}

package/src/prepare.mjs

@@ -0,0 +1,74 @@
+// Copia de trabajo del proyecto para el motor (.ignix-build/), con los arreglos de las catas:
+//  · tiempos de los clips ajustados al fotograma más cercano (el motor TRUNCA data-media-start × fps:
+//    con 4 decimales, 97/30 = 3.2333 daba el fotograma 96 en vez del 97);
+//  · ignix-frame.js de esta versión del editor, siempre al día.
+// El proyecto del usuario no se toca.
+import { copyFileSync, cpSync, existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, rmSync, statSync, symlinkSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const RUNTIME = join(dirname(fileURLToPath(import.meta.url)), 'runtime', 'ignix-frame.js');
+const SKIP = new Set(['.ignix-build', 'renders', 'snapshots', 'node_modules', '.git', '.DS_Store']);
+// Vídeo y audio no se copian (pueden pesar gigas): enlace a la ruta absoluta del original.
+const MEDIA = /\.(mp4|mov|m4v|webm|mkv|avi|wav|mp3|m4a|aac|ogg|flac)$/i;
+
+function mirror(src, dest) {
+  mkdirSync(dest, { recursive: true });
+  for (const name of readdirSync(src)) {
+    if (SKIP.has(name)) continue;
+    const from = join(src, name);
+    const to = join(dest, name);
+    const st = statSync(from);
+    if (st.isDirectory()) mirror(from, to);
+    else if (MEDIA.test(name)) symlinkSync(realpathSync(from), to);
+    else copyFileSync(from, to);
+  }
+}
+
+function htmlFiles(dir) {
+  const out = [];
+  for (const name of readdirSync(dir)) {
+    if (SKIP.has(name)) continue;
+    const p = join(dir, name);
+    if (statSync(p).isDirectory()) out.push(...htmlFiles(p));
+    else if (name.endsWith('.html')) out.push(p);
+  }
+  return out;
+}
+
+export function projectHtml(dir) {
+  return htmlFiles(dir);
+}
+
+/** Ajusta data-start / data-duration / data-media-start al fotograma más cercano. */
+export function snapTimes(html, fps) {
+  let changes = 0;
+  const out = html.replace(/\b(data-(?:start|duration|media-start))="(-?\d+(?:\.\d+)?)"/g, (m, attr, raw) => {
+    const n = Math.round(Number(raw) * fps);
+    // media-start: el motor hace floor(t × fps); un pelo por encima del fotograma lo deja exacto.
+    const v = attr === 'data-media-start' ? (n + 1e-4) / fps : n / fps;
+    const s = Number(v.toFixed(9)).toString();
+    if (s !== raw) changes++;
+    return `${attr}="${s}"`;
+  });
+  return { html: out, changes };
+}
+
+export function prepare(projectDir) {
+  const build = join(projectDir, '.ignix-build');
+  rmSync(build, { recursive: true, force: true });
+  mirror(projectDir, build);
+
+  const root = join(build, 'index.html');
+  if (!existsSync(root)) throw new Error(`No hay index.html en ${projectDir}`);
+  const fps = Number(readFileSync(root, 'utf8').match(/data-fps="(\d+(?:\.\d+)?)"/)?.[1] ?? 30);
+
+  let snapped = 0;
+  for (const f of htmlFiles(build)) {
+    const { html, changes } = snapTimes(readFileSync(f, 'utf8'), fps);
+    if (changes) writeFileSync(f, html);
+    snapped += changes;
+  }
+  cpSync(RUNTIME, join(build, 'ignix-frame.js'));
+  return { build, fps, snapped };
+}

package/src/runtime/ignix-frame.js

@@ -0,0 +1,92 @@
+/*
+ * ignix-frame.js — animación como función pura del tiempo (Ignix Editor).
+ *
+ * El render pide cada fotograma por separado y en cualquier orden. Si lo que se ve en el
+ * segundo t depende SOLO de t (nada de estado acumulado, nada medido en la página mientras
+ * corre), lo que se escribe es lo que sale. Uso:
+ *
+ *   IgnixFrame.run({ id: 'reel', duration: 18.9, fps: 30 }, (t, f) => {
+ *     el.style.opacity = IgnixFrame.lerp(t, [0, 0.4], [0, 1], IgnixFrame.ease.out);
+ *   });
+ *
+ * `id` es el data-composition-id del nodo raíz. Necesita GSAP cargado antes.
+ */
+(function () {
+  const clamp01 = (x) => Math.min(1, Math.max(0, x));
+
+  // Curva cúbica de Bézier como en CSS (x1, y1, x2, y2).
+  function bezier(x1, y1, x2, y2) {
+    return (t) => {
+      let u = t;
+      for (let i = 0; i < 8; i++) {
+        const x = 3 * (1 - u) ** 2 * u * x1 + 3 * (1 - u) * u * u * x2 + u ** 3 - t;
+        const dx = 3 * (1 - u) ** 2 * x1 + 6 * (1 - u) * u * (x2 - x1) + 3 * u * u * (1 - x2);
+        if (Math.abs(dx) < 1e-6) break;
+        u = clamp01(u - x / dx);
+      }
+      return 3 * (1 - u) ** 2 * u * y1 + 3 * (1 - u) * u * u * y2 + u ** 3;
+    };
+  }
+
+  const ease = {
+    linear: (t) => t,
+    out: bezier(0.22, 1, 0.36, 1), // entrada rápida que se posa (por defecto)
+    inOut: bezier(0.65, 0, 0.35, 1), // movimientos de cámara
+    in: (t) => t * t * t,
+    outCubic: (t) => 1 - (1 - t) ** 3, // = Easing.out(Easing.cubic) de Remotion = power2.out de GSAP
+    inOutSine: (t) => -(Math.cos(Math.PI * t) - 1) / 2,
+  };
+
+  // Valor entre dos puntos en el tiempo: lerp(t, [t0, t1], [v0, v1], ease). Fuera del tramo, se queda en el extremo.
+  function lerp(t, range, values, e = ease.linear) {
+    const [a, b] = range;
+    const [y0, y1] = values;
+    return y0 + (y1 - y0) * e(clamp01((t - a) / (b - a)));
+  }
+
+  // Muelle amortiguado en forma cerrada (masa 1): de 0 a 1 empezando en t=0 (segundos).
+  // stiffness/damping como en Remotion. Sin estado: se puede pedir cualquier t.
+  function spring(t, { stiffness = 220, damping = 14 } = {}) {
+    if (t <= 0) return 0;
+    const w0 = Math.sqrt(stiffness);
+    const z = damping / (2 * w0);
+    if (z < 1) {
+      const wd = w0 * Math.sqrt(1 - z * z);
+      return 1 - Math.exp(-z * w0 * t) * (Math.cos(wd * t) + ((z * w0) / wd) * Math.sin(wd * t));
+    }
+    return 1 - Math.exp(-w0 * t) * (1 + w0 * t);
+  }
+
+  // Valor por tramos: keys = [[t, valor], ...]; en cada t pasa al nuevo valor en `dur` segundos.
+  // El valor puede ser un número o una lista de números (posiciones, rectángulos).
+  function keyed(t, keys, dur = 0.5, e = ease.out) {
+    let v = keys[0][1];
+    for (let i = 1; i < keys.length; i++) {
+      const [tk, val] = keys[i];
+      if (t < tk) break;
+      const p = e(clamp01((t - tk) / dur));
+      v = Array.isArray(val) ? val.map((x, j) => v[j] + (x - v[j]) * p) : v + (val - v) * p;
+    }
+    return v;
+  }
+
+  // Registra la línea de tiempo: un único reloj que llama a render(t, fotograma).
+  function run({ id, duration, fps = 30 }, render) {
+    if (!window.gsap) throw new Error('ignix-frame: carga GSAP antes que este fichero');
+    if (!id) throw new Error('ignix-frame: falta id (el data-composition-id del nodo raíz)');
+    const last = Math.max(0, Math.round(duration * fps) - 1);
+    const draw = (sec) => {
+      const f = Math.min(last, Math.max(0, Math.round(sec * fps)));
+      render(f / fps, f);
+    };
+    const clock = { t: 0 };
+    const tl = window.gsap.timeline({ paused: true });
+    tl.to(clock, { t: duration, duration, ease: 'none', onUpdate: () => draw(clock.t) }, 0);
+    draw(0);
+    window.__timelines = window.__timelines || {};
+    window.__timelines[id] = tl;
+    return tl;
+  }
+
+  window.IgnixFrame = { run, lerp, spring, keyed, bezier, ease, clamp01 };
+})();

package/src/transcribe.mjs

@@ -0,0 +1,71 @@
+// Transcripción en el ordenador del usuario con whisper.cpp: cada palabra con su inicio y fin
+// en segundos. Con `script` (el texto que se sabe que se dijo, p. ej. una voz generada) manda
+// el guion en las palabras y whisper en los tiempos: whisper confunde palabras («ADM», «tiene»)
+// y a veces se come el final de una frase.
+import { spawnSync } from 'node:child_process';
+import { mkdtempSync, readFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+const norm = (s) => s.toLowerCase().normalize('NFD').replace(/[̀-ͯ]/g, '').replace(/[^\p{L}\p{N}]/gu, '');
+
+export function transcribe({ ffmpeg, whisper, model, input, language = 'es', threads = 8 }) {
+  const tmp = mkdtempSync(join(tmpdir(), 'ignix-editor-asr-'));
+  try {
+    const wav = join(tmp, 'audio.wav');
+    const a = spawnSync(ffmpeg, ['-nostdin', '-hide_banner', '-loglevel', 'error', '-y', '-i', input, '-vn', '-ar', '16000', '-ac', '1', '-c:a', 'pcm_s16le', wav], { encoding: 'utf8' });
+    if (a.status !== 0) throw new Error(`No se pudo leer el audio de ${input}: ${a.stderr.slice(-300)}`);
+    const out = join(tmp, 'out');
+    const args = ['-m', model, '-l', language, '-ml', '1', '-sow', '-oj', '-of', out, '-t', String(threads), '-f', wav];
+    const run = (extra) => spawnSync(whisper, [...extra, ...args], { encoding: 'utf8', maxBuffer: 64 * 1024 * 1024 });
+    // En Mac Intel la GPU (Metal) se cuelga con whisper: CPU directamente. En el resto, GPU y,
+    // si falla, otra vez por CPU.
+    const intelMac = process.platform === 'darwin' && process.arch === 'x64';
+    let w = run(intelMac ? ['-ng'] : []);
+    if (w.status !== 0 && !intelMac) w = run(['-ng']);
+    if (w.status !== 0) throw new Error(`whisper falló: ${(w.stderr || '').slice(-400)}`);
+    const j = JSON.parse(readFileSync(`${out}.json`, 'utf8'));
+    const words = [];
+    for (const seg of j.transcription ?? []) {
+      const t = seg.text.trim();
+      if (!t || /^\[.*\]$/.test(t)) continue; // [MÚSICA], [MUSIC]…
+      words.push({ t, s: seg.offsets.from / 1000, e: seg.offsets.to / 1000 });
+    }
+    return words;
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+}
+
+/** Palabras del guion con los tiempos de whisper. `end` = duración del audio. */
+export function alignToScript(script, tokens, end) {
+  const sw = script.split(/\s+/).filter(Boolean);
+  const out = [];
+  let i = 0;
+  for (let j = 0; j < tokens.length && i < sw.length; j++) {
+    const tk = tokens[j];
+    const tEnd = j + 1 < tokens.length ? tokens[j + 1].s : Math.max(tk.e, end);
+    // whisper juntó dos palabras en una («a DM» → «ADM»)
+    if (i + 1 < sw.length && norm(sw[i] + sw[i + 1]) === norm(tk.t) && norm(sw[i]) !== norm(tk.t)) {
+      const mid = tk.s + (tEnd - tk.s) * (sw[i].length / (sw[i].length + sw[i + 1].length));
+      out.push({ t: sw[i], s: tk.s, e: mid }, { t: sw[i + 1], s: mid, e: tEnd });
+      i += 2;
+    } else {
+      out.push({ t: sw[i], s: tk.s, e: tEnd });
+      i += 1;
+    }
+  }
+  // Palabras que whisper no devolvió: reparte el último tramo entre la última palabra y las que faltan.
+  if (i < sw.length && out.length) {
+    const last = out.pop();
+    const rest = [last.t, ...sw.slice(i)];
+    const total = rest.reduce((n, w) => n + w.length, 0);
+    let s = last.s;
+    for (const w of rest) {
+      const e = s + (end - last.s) * (w.length / total);
+      out.push({ t: w, s, e });
+      s = e;
+    }
+  }
+  return out.map((w) => ({ t: w.t, s: +w.s.toFixed(3), e: +w.e.toFixed(3) }));
+}