@ignix-social/editor 0.1.18 → 0.1.20

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ignix-social/editor",
-  "version": "0.1.18",
+  "version": "0.1.20",
   "description": "Ignix Editor: render HTML video compositions (reels, edits, clips) on your own computer. Based on HyperFrames.",
   "license": "Apache-2.0",
   "type": "module",

package/src/cli.mjs

@@ -1,6 +1,7 @@
 // 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.
 // Los mensajes van en inglés, como el manual y la skill: los lee sobre todo el agente.
+import './win-fs-preload.mjs'; // Windows: fs.cpSync con rutas no ASCII (win-fs.mjs)
 import { spawnSync } from 'node:child_process';
 import { cpSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { createRequire } from 'node:module';
@@ -213,7 +214,7 @@ const commands = {
     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) });
+    let words = transcribe({ ffmpeg, whisper, model, input, language: opts.lang ?? 'es', threads: opts.threads });
     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);

package/src/creator/build.mjs

@@ -2,6 +2,7 @@
 // listo para renderizar: los medios en assets/ con sus tiempos escritos en el HTML (vídeos,
 // audios, imágenes), las fuentes, la tabla de anchos de carácter para ajustar textos y el
 // dibujante de las plantillas (runtime/creator.js). ADR-0023 E2.
+import '../win-fs-preload.mjs'; // Windows: fs.cpSync con rutas no ASCII (win-fs.mjs)
 import { spawnSync } from 'node:child_process';
 import { cpSync, existsSync, mkdirSync, writeFileSync } from 'node:fs';
 import { dirname, extname, join } from 'node:path';

package/src/engine.mjs

@@ -1,10 +1,11 @@
 // 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 './win-fs-preload.mjs'; // Windows: fs.cpSync con rutas no ASCII (win-fs.mjs)
 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 { fileURLToPath, pathToFileURL } 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';
@@ -22,6 +23,12 @@ export async function engineEnv(log = () => {}) {
     HYPERFRAMES_SKIP_SKILLS: '1',
     HYPERFRAMES_FONT_CACHE_DIR: join(HOME, 'cache', 'fonts'),
   };
+  // En Windows, el motor y todo proceso de Node que lance cargan antes el arreglo de
+  // fs.cpSync para rutas no ASCII (win-fs.mjs).
+  if (process.platform === 'win32') {
+    const preload = pathToFileURL(join(PKG_DIR, 'src', 'win-fs-preload.mjs')).href;
+    env.NODE_OPTIONS = `${env.NODE_OPTIONS ?? ''} --import="${preload}"`.trim();
+  }
   const ffmpeg = await ensureTool('ffmpeg', log);
   const ffprobe = await ensureTool('ffprobe', log);
   env.HYPERFRAMES_FFMPEG_PATH = ffmpeg;

package/src/giphy.mjs

@@ -72,7 +72,6 @@ export function giphyRenditions(kind) {
   return [['giphy.mp4', 'mp4'], ['giphy.gif', 'gif']];
 }
 
-/** Trae el elegido a `<project>/assets/` y apunta su origen en `work/media-sources.json`. */
 /**
  * Un GIF con transparencia → una tira PNG (cols × rows fotogramas) + sus medidas.
  * `ffmpeg`/`ffprobe` son los del Editor.
@@ -92,10 +91,30 @@ export function gifToSheet({ ffmpeg, ffprobe, gif, out }) {
   return { sheet: out, frames, cols, rows, fps, durationSec: Math.round(durationSec * 100) / 100, frameWidth: Number(st.width), frameHeight: Number(st.height) };
 }
 
+/**
+ * El tipo cuando el enlace no lo dice (el del ARCHIVO, …/giphy.gif): con él un clip se traía
+ * como GIF, sin audio. Solo los clips tienen giphy480p.mp4, y la página dice si es sticker.
+ */
+export async function resolveGiphyKind(id, fromLink) {
+  if (fromLink) return fromLink;
+  if (!ID.test(id)) return 'gif';
+  const clip = await fetch(`https://media.giphy.com/media/${id}/giphy480p.mp4`, { method: 'HEAD', signal: AbortSignal.timeout(8000) })
+    .then((r) => r.ok)
+    .catch(() => false);
+  if (clip) return 'clip';
+  const page = await fetch(`https://giphy.com/gifs/${id}`, { headers: { 'user-agent': 'Mozilla/5.0 (compatible; IgnixEditor)' }, signal: AbortSignal.timeout(8000) })
+    .then((r) => (r.ok ? r.text() : ''))
+    .catch(() => '');
+  const html = page.replace(/\\"/g, '"');
+  const at = html.indexOf(`"id":"${id}"`);
+  return at >= 0 && /"is_sticker":true/.test(html.slice(at, at + 8000)) ? 'sticker' : 'gif';
+}
+
+/** Trae el elegido a `<project>/assets/` y apunta su origen en `work/media-sources.json`. */
 export async function importGiphy({ link, project, kind: forced, ffmpeg, ffprobe }) {
   const parsed = parseGiphyLink(link);
   if (!parsed) throw new Error('That is not a GIPHY link. Copy the link of the GIF, sticker or clip from giphy.com.');
-  const kind = forced ?? parsed.kind ?? 'gif';
+  const kind = forced ?? (await resolveGiphyKind(parsed.id, parsed.kind));
   const assets = join(project, 'assets');
   mkdirSync(assets, { recursive: true });
   let lastErr = null;

package/src/prepare.mjs

@@ -3,6 +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 './win-fs-preload.mjs'; // Windows: fs.cpSync con rutas no ASCII (win-fs.mjs)
 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';

package/src/transcribe.mjs

@@ -4,26 +4,77 @@
 // y a veces se come el final de una frase.
 import { spawnSync } from 'node:child_process';
 import { mkdtempSync, readFileSync, rmSync, statSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
+import { availableParallelism, tmpdir } from 'node:os';
+import { basename, dirname, join, relative } from 'node:path';
+
+/**
+ * Dónde trabaja whisper. En Windows, whisper.cpp NO abre rutas con caracteres fuera del ASCII
+ * (pasó con «C:\Users\José María»: el modelo, el audio y la salida cuelgan todos de esa
+ * carpeta, %TEMP% incluido). Así que se le ejecuta DESDE la carpeta del modelo y se le pasan
+ * solo rutas relativas, que son ASCII: el modelo por su nombre y el audio y la salida en una
+ * subcarpeta temporal de ahí. ffmpeg y el arranque del proceso sí entienden Unicode.
+ */
+function whisperWorkspace(model) {
+  if (process.platform === 'win32') {
+    try {
+      const cwd = dirname(model);
+      const tmp = mkdtempSync(join(cwd, 'asr-'));
+      return { tmp, cwd, modelArg: basename(model), arg: (p) => relative(cwd, p) };
+    } catch {
+      /* carpeta del modelo sin permiso de escritura: como en el resto de sistemas */
+    }
+  }
+  return { tmp: mkdtempSync(join(tmpdir(), 'ignix-editor-asr-')), cwd: undefined, modelArg: model, arg: (p) => p };
+}
+
+/**
+ * Hilos para whisper: nunca más que núcleos. Con más hilos que núcleos (p. ej. -t 8 en un
+ * portátil de 2 o 4) el whisper.cpp que publicamos (sin OpenMP) se queda bloqueado PARA
+ * SIEMPRE, sin error (Windows en CI y en una VM, 2026-10-08).
+ */
+export function whisperThreads(requested) {
+  const cores = Math.max(1, availableParallelism());
+  const n = Number(requested);
+  return Math.max(1, Math.min(Number.isFinite(n) && n > 0 ? n : 8, cores));
+}
+
+/** Tiempo máximo de whisper: generoso (un PC lento va a ~1× tiempo real), pero nunca infinito. */
+function whisperTimeoutMs(wavPath) {
+  let seconds = 0;
+  try {
+    seconds = Math.max(0, (statSync(wavPath).size - 44) / 32000);
+  } catch {
+    /* sin tamaño: el mínimo */
+  }
+  return Math.max(10 * 60_000, seconds * 6 * 1000);
+}
+
+function whisperFailure(w, timeoutMs) {
+  if (w.error?.code === 'ETIMEDOUT') {
+    return new Error(`whisper did not finish in ${Math.round(timeoutMs / 60_000)} min and was stopped. Close other heavy programs and run the command again, or use a smaller model (--model small).`);
+  }
+  return new Error(`whisper failed: ${(w.stderr || '').slice(-400)}`);
+}
 
 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-'));
+export function transcribe({ ffmpeg, whisper, model, input, language = 'es', threads }) {
+  const ws = whisperWorkspace(model);
+  const tmp = ws.tmp;
   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 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 });
+    const args = ['-m', ws.modelArg, '-l', language, '-ml', '1', '-sow', '-oj', '-of', ws.arg(out), '-t', String(whisperThreads(threads)), '-f', ws.arg(wav)];
+    const timeout = whisperTimeoutMs(wav);
+    const run = (extra) => spawnSync(whisper, [...extra, ...args], { encoding: 'utf8', maxBuffer: 64 * 1024 * 1024, cwd: ws.cwd, timeout });
     // 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 failed: ${(w.stderr || '').slice(-400)}`);
+    if (w.status !== 0 && !intelMac && w.error?.code !== 'ETIMEDOUT') w = run(['-ng']);
+    if (w.status !== 0) throw whisperFailure(w, timeout);
     const j = JSON.parse(readFileSync(`${out}.json`, 'utf8'));
     const words = [];
     for (const seg of j.transcription ?? []) {
@@ -74,24 +125,26 @@ export function alignToScript(script, tokens, end) {
  * 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-'));
+export function transcribeDetailed({ ffmpeg, whisper, model, input, language = null, threads, maxWords = 6000, maxSegments = 800 }) {
+  const ws = whisperWorkspace(model);
+  const tmp = ws.tmp;
   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 args = ['-m', ws.modelArg, '-l', language || 'auto', '-ml', '1', '-sow', '-ojf', '-of', ws.arg(out), '-t', String(whisperThreads(threads)), '-f', ws.arg(wav)];
+    const timeout = whisperTimeoutMs(wav);
+    const run = (extra) => spawnSync(whisper, [...extra, ...args], { encoding: 'utf8', maxBuffer: 64 * 1024 * 1024, cwd: ws.cwd, timeout });
     const intelMac = process.platform === 'darwin' && process.arch === 'x64';
     let w = run(intelMac ? ['-ng'] : []);
     let device = intelMac ? 'cpu' : 'gpu';
-    if (w.status !== 0 && !intelMac) {
+    if (w.status !== 0 && !intelMac && w.error?.code !== 'ETIMEDOUT') {
       w = run(['-ng']);
       device = 'cpu';
     }
-    if (w.status !== 0) throw new Error(`whisper failed: ${(w.stderr || '').slice(-400)}`);
+    if (w.status !== 0) throw whisperFailure(w, timeout);
     const j = JSON.parse(readFileSync(`${out}.json`, 'utf8'));
     const words = [];
     let aside = false; // dentro de una acotación: [MÚSICA], (upbeat music)…

package/src/win-fs-preload.mjs

@@ -0,0 +1,4 @@
+// Se carga con `node --import` en el proceso del motor (ver win-fs.mjs).
+import { installWindowsFsPatch } from './win-fs.mjs';
+
+installWindowsFsPatch();

package/src/win-fs.mjs

@@ -0,0 +1,40 @@
+// fs.cpSync de Node 22 en Windows (su versión nativa en C++) rompe con rutas fuera del
+// ASCII: con «C:\Users\José María» el proceso muere en seco (0xC0000409) o «copia» a una
+// ruta mal convertida y el fichero no aparece. Le pasa a `init`, a `skill` y al motor al
+// compilar el proyecto para renderizar. En Windows se cambia por una copia en JavaScript
+// (fichero a fichero, que sí respeta Unicode) para el Editor y, vía --import, para el motor.
+import fs from 'node:fs';
+import { syncBuiltinESMExports } from 'node:module';
+import { dirname, join } from 'node:path';
+
+/** cpSync en JavaScript: recursive, dereference, filter(src, dest) y force (por defecto sí). */
+export function safeCpSync(src, dest, opts = {}) {
+  const { recursive = false, dereference = false, filter, force = true } = opts;
+  if (filter && !filter(String(src), String(dest))) return;
+  const st = dereference ? fs.statSync(src) : fs.lstatSync(src);
+  if (st.isDirectory()) {
+    if (!recursive) throw Object.assign(new Error(`Recursive option is required to copy a directory: ${src}`), { code: 'ERR_FS_EISDIR' });
+    fs.mkdirSync(dest, { recursive: true });
+    for (const name of fs.readdirSync(src)) safeCpSync(join(String(src), name), join(String(dest), name), opts);
+    return;
+  }
+  if (st.isSymbolicLink()) {
+    if (!force && fs.existsSync(dest)) return;
+    fs.rmSync(dest, { force: true });
+    fs.mkdirSync(dirname(String(dest)), { recursive: true });
+    fs.symlinkSync(fs.readlinkSync(src), dest);
+    return;
+  }
+  if (!force && fs.existsSync(dest)) return;
+  fs.mkdirSync(dirname(String(dest)), { recursive: true });
+  fs.copyFileSync(src, dest);
+}
+
+let installed = false;
+/** En Windows, cambia fs.cpSync por safeCpSync también para quien lo importó por nombre. */
+export function installWindowsFsPatch() {
+  if (installed || process.platform !== 'win32') return;
+  installed = true;
+  fs.cpSync = safeCpSync;
+  syncBuiltinESMExports();
+}