@ignix-social/editor 0.1.5 → 0.1.7

package/src/engine.mjs

@@ -0,0 +1,98 @@
+// El motor (HyperFrames, en vendor/) con nuestro entorno: sin telemetría, sin actualizaciones
+// solas, con nuestros binarios; y el render completo de un proyecto (copia de trabajo, motor,
+// volumen a −14 LUFS). Lo usan el CLI y el servicio para Creator.
+import { spawn, spawnSync } from 'node:child_process';
+import { cpSync, existsSync, mkdirSync, rmSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { HOME, PLATFORM, TOOLS, ensureTool, findTool } from './binaries.mjs';
+import { linkMedia, prepare } from './prepare.mjs';
+import { hasAudio, loudness, normalizeLoudness } from './audio.mjs';
+
+const PKG_DIR = join(dirname(fileURLToPath(import.meta.url)), '..');
+export const ENGINE = join(PKG_DIR, 'vendor', 'hyperframes', 'bin', 'hyperframes.mjs');
+
+export async function engineEnv(log = () => {}) {
+  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. Uno por proceso (Creator puede renderizar y analizar a la vez), borrado al salir.
+  const shim = join(HOME, 'shim', `${PLATFORM}-${process.pid}`);
+  rmSync(shim, { recursive: true, force: true });
+  mkdirSync(shim, { recursive: true });
+  process.once('exit', () => rmSync(shim, { recursive: true, force: true }));
+  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 };
+}
+
+/** Lanza el motor. `quiet`: su salida va a stderr (el servicio reserva stdout al protocolo). */
+export function runEngine(args, env, cwd, { quiet = false } = {}) {
+  const r = spawnSync(process.execPath, [ENGINE, ...args], { stdio: quiet ? ['ignore', 2, 2] : 'inherit', env, cwd });
+  return r.status ?? 1;
+}
+
+/**
+ * Lanza el motor sin bloquear: su salida va a stderr y cada línea pasa por `onLine` (para leer
+ * el avance). `signal` lo para (SIGTERM; el motor cierra su navegador).
+ */
+export function runEngineAsync(args, env, cwd, { onLine = () => {}, signal } = {}) {
+  return new Promise((resolve) => {
+    const p = spawn(process.execPath, [ENGINE, ...args], { stdio: ['ignore', 'pipe', 'pipe'], env, cwd });
+    const relay = (d) => {
+      process.stderr.write(d);
+      for (const line of String(d).split(/[\r\n]+/)) if (line.trim()) onLine(line);
+    };
+    p.stdout.on('data', relay);
+    p.stderr.on('data', relay);
+    const stop = () => p.kill('SIGTERM');
+    signal?.addEventListener('abort', stop, { once: true });
+    p.on('close', (code) => {
+      signal?.removeEventListener('abort', stop);
+      resolve(code ?? 1);
+    });
+    p.on('error', () => resolve(1));
+  });
+}
+
+/**
+ * Renderiza el proyecto `dir` en `output`: copia de trabajo con los tiempos ajustados, el motor
+ * y, si hay sonido, la mezcla a `lufs` (−14 por defecto; `normalize: false` lo deja tal cual).
+ */
+export async function renderProject(dir, output, { lufs = -14, normalize = true, engineArgs = [], quiet = false, onProgress, signal, browser, log = () => {} } = {}) {
+  const { build, snapped } = prepare(dir);
+  const { env, ffmpeg, ffprobe } = await engineEnv(log);
+  if (browser) env.HYPERFRAMES_BROWSER_PATH = browser;
+  mkdirSync(dirname(output), { recursive: true });
+  const raw = join(build, 'raw.mp4');
+  const args = ['render', build, '-o', raw, ...engineArgs];
+  // Avance: «Capturing frame N/M» del motor; luego codifica y monta.
+  const onLine = (line) => {
+    const m = line.match(/Capturing frame (\d+)\/(\d+)/);
+    if (m) onProgress?.({ stage: 'rendering', fraction: Math.min(0.99, Number(m[1]) / Math.max(1, Number(m[2]))) });
+    else if (/Encoding video|Assembling final video/.test(line)) onProgress?.({ stage: 'encoding', fraction: 0.95 });
+  };
+  const code = onProgress || signal ? await runEngineAsync(args, env, dir, { onLine, signal }) : runEngine(args, env, dir, { quiet });
+  if (signal?.aborted) throw Object.assign(new Error('cancelled'), { code: 'cancelled' });
+  if (code !== 0 || !existsSync(raw)) throw new Error('The render failed (see the messages above).');
+  let level = null;
+  if (normalize !== false && hasAudio(ffprobe, raw)) {
+    const r = normalizeLoudness(ffmpeg, raw, output, { lufs: Number(lufs ?? -14) });
+    level = { before: r.before, after: loudness(ffmpeg, output) };
+  } else cpSync(raw, output);
+  return { output, snapped, loudness: level };
+}

package/src/fetch.mjs

@@ -0,0 +1,30 @@
+// `ignix-editor fetch`: descarga de una vez lo que el Editor necesita (ffmpeg, ffprobe, whisper y
+// su modelo, el motor de análisis y sus modelos), cada cosa con su sha256. Ignix Creator lo lanza
+// al instalar el motor de vídeo para que ningún render ni análisis tenga que esperar a una
+// descarga. Con --json informa por stdout con líneas JSON: progress {item, fraction, received,
+// total} (bytes), done, error {code}.
+import { ensureTool, ensureWhisperModel, findTool, toolSize, whisperModelPath, WHISPER_MODELS } from './binaries.mjs';
+import { existsSync } from 'node:fs';
+import { analysisMissing, ensureModel, loadOrt } from './analysis/runtime.mjs';
+
+export async function fetchAll({ whisper = 'small', analysis = true, json = false, log = () => {} } = {}) {
+  const emit = (e) => json && process.stdout.write(`${JSON.stringify(e)}\n`);
+  if (!WHISPER_MODELS[whisper]) throw Object.assign(new Error(`Unknown model: ${whisper}`), { code: 'invalid_args' });
+  const todo = [];
+  for (const name of ['ffmpeg', 'ffprobe', 'whisper']) {
+    if (!findTool(name).path) todo.push({ item: name, size: toolSize(name), run: () => ensureTool(name, log) });
+  }
+  if (!existsSync(whisperModelPath(whisper))) todo.push({ item: `whisper-${whisper}`, size: WHISPER_MODELS[whisper].size, run: () => ensureWhisperModel(whisper, log) });
+  if (analysis) {
+    for (const m of analysisMissing()) todo.push({ ...m, run: () => (m.item === 'runtime' ? loadOrt(log) : ensureModel(m.item, log)) });
+  }
+  const total = todo.reduce((n, t) => n + t.size, 0);
+  let done = 0;
+  for (const t of todo) {
+    emit({ t: 'progress', item: t.item, fraction: +(done / (total || 1)).toFixed(4), received: done, total });
+    await t.run();
+    done += t.size;
+  }
+  emit({ t: 'progress', item: 'done', fraction: 1, received: total, total });
+  return { downloaded: todo.map((t) => t.item), bytes: todo.reduce((n, t) => n + t.size, 0) };
+}

package/vendor/hyperframes/UPSTREAM.json

@@ -8,6 +8,7 @@
     "no-telemetry",
     "no-auto-update",
     "mf-encoder",
-    "no-desktop-promo"
+    "no-desktop-promo",
+    "chrome-first-launch"
   ]
 }

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

@@ -211,7 +211,7 @@ async function chromeLaunchOutcome(executablePath, found, signal) {
   try {
     const { stdout } = await runCancellableProcess(executablePath, ["--version"], {
       signal,
-      timeoutMs: 5e3,
+      timeoutMs: 6e4, // ignix-editor: primera apertura de una copia nueva
       maxBufferBytes: 64 * 1024
     });
     return { ...found, versionMajor: extractMajorVersion(stdout) };