@ignix-social/editor 0.1.2 → 0.1.5

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

@@ -1,19 +1,19 @@
 {
-  "version": "1",
+  "version": "2",
   "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"
+        "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": 24973512,
-        "sha256": "dd9f843f01a934c8358c9a235d8e44349fe50692418dd79ba328be7f4fecbd85",
-        "build": "ffmpeg 7.1.2 LGPL, scripts/build-ffmpeg-macos.sh"
+        "size": 25367080,
+        "sha256": "97dae7a58f71a3fa54d11be06c810896504fb70f062396cd466c37f66fe16b1e",
+        "build": "ffmpeg 7.1.2 GPL, scripts/build-ffmpeg-macos.sh en Mac Intel"
       },
       "whisper": {
         "file": "whisper-cli",
@@ -25,21 +25,127 @@
     "darwin-arm64": {
       "ffmpeg": {
         "file": "ffmpeg",
-        "size": 20858536,
-        "sha256": "ba5d9f9e59dd9588b88c97a526d971d07ccc60d1f101f47e2f9fac3c03ff2846",
-        "build": "ffmpeg 7.1.2 LGPL + VideoToolbox, CI binaries.yml (macos-15, run 37322341901)"
+        "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": 20799752,
-        "sha256": "5c7c6da2f0a7c14ac7aaf934afdfd6e0efa232955226a287b986fcb37e5992b9",
-        "build": "ffmpeg 7.1.2 LGPL, CI binaries.yml (macos-15, run 37322341901)"
+        "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 37322341901)"
+        "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.`);
   },

package/src/prepare.mjs

@@ -3,7 +3,7 @@
 //    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 { copyFileSync, cpSync, existsSync, linkSync, mkdirSync, readFileSync, readdirSync, realpathSync, rmSync, statSync, symlinkSync, writeFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
@@ -12,6 +12,17 @@ const SKIP = new Set(['.ignix-build', 'renders', 'snapshots', 'node_modules', '.
 // 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;
 
+// macOS/Linux: enlace simbólico. Windows: los simbólicos piden permisos de administrador o el
+// modo desarrollador, así que enlace duro (mismo disco) y, si no se puede, una copia.
+export function linkMedia(target, to) {
+  if (process.platform !== 'win32') return symlinkSync(target, to);
+  try {
+    linkSync(target, to);
+  } catch {
+    copyFileSync(target, to);
+  }
+}
+
 function mirror(src, dest) {
   mkdirSync(dest, { recursive: true });
   for (const name of readdirSync(src)) {
@@ -20,7 +31,7 @@ function mirror(src, dest) {
     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 if (MEDIA.test(name)) linkMedia(realpathSync(from), to);
     else copyFileSync(from, to);
   }
 }

package/src/transcribe.mjs

@@ -3,7 +3,7 @@
 // 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 { mkdtempSync, readFileSync, rmSync, statSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 
@@ -69,3 +69,67 @@ export function alignToScript(script, tokens, end) {
   }
   return out.map((w) => ({ t: w.t, s: +w.s.toFixed(3), e: +w.e.toFixed(3) }));
 }
+
+/**
+ * Transcripción completa para Creator: idioma detectado (si no se da), cada palabra con su
+ * confianza (media de sus tokens) y las frases (cortadas en un punto o en una pausa).
+ */
+export function transcribeDetailed({ ffmpeg, whisper, model, input, language = null, threads = 8, maxWords = 6000, maxSegments = 800 }) {
+  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(`Could not read the audio of ${input}: ${a.stderr.slice(-300)}`);
+    const duration = statSync(wav).size > 44 ? (statSync(wav).size - 44) / 32000 : 0;
+    const out = join(tmp, 'out');
+    const args = ['-m', model, '-l', language || 'auto', '-ml', '1', '-sow', '-ojf', '-of', out, '-t', String(threads), '-f', wav];
+    const run = (extra) => spawnSync(whisper, [...extra, ...args], { encoding: 'utf8', maxBuffer: 64 * 1024 * 1024 });
+    const intelMac = process.platform === 'darwin' && process.arch === 'x64';
+    let w = run(intelMac ? ['-ng'] : []);
+    let device = intelMac ? 'cpu' : 'gpu';
+    if (w.status !== 0 && !intelMac) {
+      w = run(['-ng']);
+      device = 'cpu';
+    }
+    if (w.status !== 0) throw new Error(`whisper failed: ${(w.stderr || '').slice(-400)}`);
+    const j = JSON.parse(readFileSync(`${out}.json`, 'utf8'));
+    const words = [];
+    let aside = false; // dentro de una acotación: [MÚSICA], (upbeat music)…
+    for (const seg of j.transcription ?? []) {
+      const text = seg.text.trim();
+      if (!text) continue;
+      if (aside || /^[[(]/.test(text)) {
+        aside = !/[\])]$/.test(text);
+        continue;
+      }
+      const toks = (seg.tokens ?? []).filter((t) => !/^\[_|^<\|/.test(t.text) && t.text.trim());
+      const p = toks.length ? toks.reduce((s, t) => s + (t.p ?? 0), 0) / toks.length : 0;
+      words.push({ text: text.slice(0, 60), start: seg.offsets.from / 1000, end: seg.offsets.to / 1000, p: +Math.min(1, Math.max(0, p)).toFixed(3) });
+      if (words.length >= maxWords) break;
+    }
+    // Frases: hasta un punto final o una pausa de más de 0,7 s.
+    const segments = [];
+    let cur = null;
+    for (const wd of words) {
+      if (cur && wd.start - cur.end > 0.7) {
+        segments.push(cur);
+        cur = null;
+      }
+      cur = cur ? { start: cur.start, end: wd.end, text: `${cur.text} ${wd.text}` } : { start: wd.start, end: wd.end, text: wd.text };
+      if (/[.!?…。]$/.test(wd.text)) {
+        segments.push(cur);
+        cur = null;
+      }
+    }
+    if (cur) segments.push(cur);
+    return {
+      language: j.result?.language ?? language ?? null,
+      duration: +duration.toFixed(3),
+      device,
+      words,
+      segments: segments.slice(0, maxSegments).map((s) => ({ ...s, text: s.text.slice(0, 500) })),
+    };
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+}

package/vendor/hyperframes/UPSTREAM.json

@@ -7,6 +7,7 @@
   "patches": [
     "no-telemetry",
     "no-auto-update",
+    "mf-encoder",
     "no-desktop-promo"
   ]
 }

package/vendor/hyperframes/dist/chunk-K2FTXJYH.js

@@ -7405,14 +7405,16 @@ var GPU_ENCODER_CANDIDATES = [
   "videotoolbox",
   "vaapi",
   "qsv",
-  "amf"
+  "amf",
+  "mf" // ignix-editor: Media Foundation (Windows)
 ];
 var H264_ENCODER_BY_GPU = {
   nvenc: "h264_nvenc",
   videotoolbox: "h264_videotoolbox",
   vaapi: "h264_vaapi",
   qsv: "h264_qsv",
-  amf: "h264_amf"
+  amf: "h264_amf",
+  mf: "h264_mf"
 };
 var GPU_PROBE_TIMEOUT_MS = 2e3;
 var GPU_PROBE_KILL_GRACE_MS = 1e3;
@@ -7476,6 +7478,8 @@ function getGpuEncoderName(encoder, codec) {
       return codec === "h264" ? "h264_qsv" : "hevc_qsv";
     case "amf":
       return codec === "h264" ? "h264_amf" : "hevc_amf";
+    case "mf":
+      return codec === "h264" ? "h264_mf" : "hevc_mf";
     default:
       return codec === "h264" ? "libx264" : "libx265";
   }
@@ -8595,6 +8599,11 @@ function buildEncoderArgs(options, inputArgs, outputPath, gpuEncoder = null) {
           if (bitrate) args.push("-b:v", bitrate);
           else args.push("-rc", "cqp", "-qp_i", String(quality), "-qp_p", String(quality));
           break;
+        case "mf": {
+          const vt = buildVideoToolboxRateControlArgs({ bitrate, width: options.width, height: options.height, fps: fpsToNumber(fps), quality });
+          args.push("-b:v", vt[1], "-rate_control", "u_vbr");
+          break;
+        }
       }
       if (codec === "h264" && (gpuEncoder === "nvenc" || gpuEncoder === "qsv" || gpuEncoder === "vaapi" || gpuEncoder === "amf")) {
         args.push("-bf", "0");
@@ -9248,6 +9257,11 @@ function buildStreamingArgs(options, outputPath, gpuEncoder = null) {
           if (bitrate) args.push("-b:v", bitrate);
           else args.push("-rc", "cqp", "-qp_i", String(quality), "-qp_p", String(quality));
           break;
+        case "mf": {
+          const vt = buildVideoToolboxRateControlArgs({ bitrate, width: options.width, height: options.height, fps: fpsToNumber(fps), quality });
+          args.push("-b:v", vt[1], "-rate_control", "u_vbr");
+          break;
+        }
       }
       if (codec === "h264" && (gpuEncoder === "nvenc" || gpuEncoder === "qsv" || gpuEncoder === "vaapi" || gpuEncoder === "amf")) {
         args.push("-bf", "0");

package/vendor/hyperframes/dist/chunk-TVCRUG2S.js

@@ -195,7 +195,7 @@ var H264EncoderUnavailableError = class extends Error {
 function resolveH264EncoderMode(ffmpegEncodersOutput, gpuRequested) {
   if (gpuRequested) return "gpu";
   if (/\blibx264\b/.test(ffmpegEncodersOutput)) return "software";
-  if (/\bh264_videotoolbox\b/.test(ffmpegEncodersOutput)) return "gpu";
+  if (/\bh264_(videotoolbox|mf)\b/.test(ffmpegEncodersOutput)) return "gpu";
   throw new H264EncoderUnavailableError();
 }
 function detectH264EncoderMode(ffmpegPath, gpuRequested) {

package/vendor/hyperframes/dist/render-LNO62LEL.js

@@ -1770,7 +1770,7 @@ async function executeLocalRender(projectDir, outputPath, options, cancellation)
     }
     if (encoderMode === "gpu") {
       console.warn(
-        c.warn("  FFmpeg does not include libx264; falling back to VideoToolbox H.264 encoding.")
+        c.warn("  FFmpeg does not include libx264; using the system's hardware H.264 encoder (VideoToolbox on macOS, Media Foundation on Windows).")
       );
       options = { ...options, gpu: true };
     }

package/src/native/faces.swift

@@ -1,60 +0,0 @@
-// faces — dónde está la cara en cada momento de un vídeo (Apple Vision, macOS 13+).
-// Uso: faces <vídeo> <cada_segundos>  → JSON por stdout:
-//   { "duration": s, "width": px, "height": px, "samples": [ { "t": s, "x":…, "y":…, "w":…, "h":… } | { "t": s } ] }
-// x, y, w, h normalizados 0–1 con origen ARRIBA a la izquierda (como CSS). Sin cara → solo "t".
-import AVFoundation
-import Foundation
-import Vision
-
-@main
-struct Faces {
-  static func main() async {
-    let args = CommandLine.arguments
-    guard args.count >= 2 else {
-      FileHandle.standardError.write("usage: faces <video> [every_seconds]\n".data(using: .utf8)!)
-      exit(2)
-    }
-    let url = URL(fileURLWithPath: args[1])
-    let every = args.count >= 3 ? (Double(args[2]) ?? 0.2) : 0.2
-    let asset = AVURLAsset(url: url)
-    do {
-      let duration = try await asset.load(.duration).seconds
-      guard let track = try await asset.loadTracks(withMediaType: .video).first else {
-        FileHandle.standardError.write("no video track\n".data(using: .utf8)!)
-        exit(1)
-      }
-      let size = try await track.load(.naturalSize).applying(try await track.load(.preferredTransform))
-      let gen = AVAssetImageGenerator(asset: asset)
-      gen.appliesPreferredTrackTransform = true
-      gen.requestedTimeToleranceBefore = CMTime(value: 1, timescale: 30)
-      gen.requestedTimeToleranceAfter = CMTime(value: 1, timescale: 30)
-      gen.maximumSize = CGSize(width: 960, height: 960)
-
-      var samples: [[String: Double]] = []
-      var t = 0.0
-      while t < duration {
-        var sample: [String: Double] = ["t": (t * 1000).rounded() / 1000]
-        if let (image, _) = try? await gen.image(at: CMTime(seconds: t, preferredTimescale: 600)) {
-          let req = VNDetectFaceRectanglesRequest()
-          try? VNImageRequestHandler(cgImage: image, options: [:]).perform([req])
-          // La cara más grande: la de quien habla a cámara.
-          if let f = (req.results ?? []).max(by: { $0.boundingBox.width * $0.boundingBox.height < $1.boundingBox.width * $1.boundingBox.height }) {
-            let b = f.boundingBox // Vision: origen ABAJO a la izquierda
-            sample["x"] = b.minX
-            sample["y"] = 1 - b.maxY
-            sample["w"] = b.width
-            sample["h"] = b.height
-          }
-        }
-        samples.append(sample)
-        t += every
-      }
-      let out: [String: Any] = ["duration": duration, "width": abs(size.width), "height": abs(size.height), "samples": samples]
-      let data = try JSONSerialization.data(withJSONObject: out)
-      FileHandle.standardOutput.write(data)
-    } catch {
-      FileHandle.standardError.write("faces failed: \(error)\n".data(using: .utf8)!)
-      exit(1)
-    }
-  }
-}