morfeo 0.3.0 → 0.3.1

package/lib/render.mjs

@@ -14,6 +14,7 @@ import {resolverRecursos} from './recursos.mjs';
 import {sintetizarVoces} from './voces.mjs';
 import {transcribir, whisperListo} from './whisper.mjs';
 import {consejosEnTexto, revisarEstructura} from './estructura.mjs';
+import {revisarPalabras} from './palabras.mjs';
 
 const require = createRequire(import.meta.url);
 
@@ -142,14 +143,16 @@ function python(trabajo) {
 		stdio: 'inherit',
 		env: {...process.env, PYTHONUTF8: '1', PYTHONIOENCODING: 'utf-8'},
 	});
+	if (r.status === 10) return 'falta-whisper';
 	if (r.status !== 0) throw new ErrorMorfeo(`Falló la preparación del audio (código ${r.status}). Revisa el mensaje de arriba.`);
+	return 'listo';
 }
 
 /**
  * Prepara (audio + tiempos) los videos indicados. Devuelve {publico, marca, datos: {id: datos}}.
  * @param {{proyecto?: string, ids?: string[], log?: (m: string) => void}} o
  */
-export async function preparar({proyecto = process.cwd(), ids, log = console.log, _p} = {}) {
+export async function preparar({proyecto = process.cwd(), ids, log = console.log, _p, continuar = false} = {}) {
 	cargarEnv(proyecto);
 	const p = _p ?? (await cargarProyecto(proyecto));
 	if (!venvListo() || !modelosListos()) throw new ErrorMorfeo('Falta preparar tu computadora. Corre una vez:  npx morfeo instalar');
@@ -161,10 +164,12 @@ export async function preparar({proyecto = process.cwd(), ids, log = console.log
 	const trabajos = path.join(p.trabajo, 'trabajos');
 	const creditos = {};
 	fs.mkdirSync(trabajos, {recursive: true});
+	const fallidos = [];
 	for (const [i, id] of (ids ?? todos).entries()) {
 		const original = p.videos[id];
 		if (!original) throw new ErrorMorfeo(`No existe el video "${id}". Usa: npx morfeo lista`);
 		log(`[${i + 1}/${(ids ?? todos).length}] ${id}: audio...`);
+		try {
 		const conRecursos = await resolverRecursos(ponerPoses(original, poses), path.join(publico, 'assets'), log);
 		creditos[id] = conRecursos.creditos;
 		guardarCreditos(p, id, conRecursos.creditos);
@@ -172,17 +177,28 @@ export async function preparar({proyecto = process.cwd(), ids, log = console.log
 		const video = await sintetizarVoces(id, conImagenes, path.join(p.trabajo, 'cache', 'voces'), log);
 		const job = path.join(trabajos, `${id}.json`);
 		const base = {id, video, indice: todos.indexOf(id), publico, modelos: MODELOS};
-		fs.writeFileSync(job, JSON.stringify({...base, soloVoz: true}));
-		python(job);
-		if (conWhisper && !fs.existsSync(path.join(publico, 'v', id, 'whisper.json'))) {
+		// una sola pasada de Python cuando la voz y su transcripción ya están en caché (lo normal al volver a renderizar);
+		// si la voz es nueva, Python sale con 10, se transcribe con Whisper y se vuelve a llamar
+		fs.writeFileSync(job, JSON.stringify({...base, conWhisper}));
+		if (python(job) === 'falta-whisper') {
 			log('    whisper...');
-			await transcribir(path.join(publico, 'v', id), (video.lang ?? 'es').slice(0, 2));
+			try {
+				await transcribir(path.join(publico, 'v', id), (video.lang ?? 'es').slice(0, 2));
+			} catch (e) {
+				log(`    (Whisper falló: ${mensajeDe(e)}; subtítulos repartidos por frase)`);
+			}
+			fs.writeFileSync(job, JSON.stringify(base));
+			python(job);
 		}
-		fs.writeFileSync(job, JSON.stringify(base));
-		python(job);
 		datos[id] = datosDe(publico, id);
+		for (const a of revisarPalabras(original, datos[id])) log(`    ! ${a}`);
+		} catch (e) {
+			if (!continuar) throw e;
+			fallidos.push({id, error: mensajeDe(e)});
+			log(`    ✘ ${id}: ${mensajeDe(e)}`);
+		}
 	}
-	return {p, publico, marca, extras, datos, creditos};
+	return {p, publico, marca, extras, datos, creditos, fallidos};
 }
 
 /**
@@ -190,9 +206,18 @@ export async function preparar({proyecto = process.cwd(), ids, log = console.log
  * @param {{proyecto?: string, ids?: string[], todos?: boolean, log?: (m: string) => void, alProgreso?: (id: string, p: number) => void}} o
  * @returns {Promise<{id: string, mp4: string, jpg: string | null, segundos: number}[]>}
  */
-export async function render({proyecto = process.cwd(), ids, todos = false, log = console.log, alProgreso} = {}) {
+export async function render({proyecto = process.cwd(), ids, todos = false, soloFallidos = false, log = console.log, alProgreso} = {}) {
 	cargarEnv(proyecto);
 	const p = await cargarProyecto(proyecto);
+	const loteArchivo = path.join(p.trabajo, 'ultimo-lote.json');
+	if (soloFallidos) {
+		const previo = fs.existsSync(loteArchivo) ? JSON.parse(fs.readFileSync(loteArchivo, 'utf8')) : {fallidos: []};
+		ids = previo.fallidos.map((f) => f.id).filter((id) => p.videos[id]);
+		if (!ids.length) {
+			log('El último lote no tuvo videos fallidos.');
+			return [];
+		}
+	}
 	let lista = ids?.length ? ids : todos ? Object.keys(p.videos) : Object.keys(p.videos).filter((id) => !fs.existsSync(salidaDe(p, id)));
 	const malos = lista.filter((id) => !p.videos[id]);
 	if (malos.length) throw new ErrorMorfeo(`No existen: ${malos.join(', ')}. Usa: npx morfeo lista`);
@@ -201,14 +226,16 @@ export async function render({proyecto = process.cwd(), ids, todos = false, log
 		return [];
 	}
 	if (!whisperListo()) log('(Whisper no está instalado: subtítulos repartidos por frase. Para tiempos exactos: npx morfeo instalar --whisper)');
-	const {publico, marca, extras, datos} = await preparar({proyecto, ids: lista, log, _p: p});
+	const {publico, marca, extras, datos, fallidos} = await preparar({proyecto, ids: lista, log, _p: p, continuar: true});
+	const listos = lista.filter((id) => datos[id]);
 	// estructura: consejos medidos en videos virales (no detienen el render; se apagan con render.consejos: false)
 	if (p.render.consejos !== false)
-		for (const id of lista) {
+		for (const id of listos) {
 			const c = revisarEstructura(p.videos[id], datos[id]);
 			if (c.length) log(`  ${id}: ${c.length} consejo(s) de estructura\n${consejosEnTexto(c)}`);
 		}
 
+	if (!listos.length) return terminarLote(p, loteArchivo, [], fallidos, log);
 	log('Empaquetando la animación...');
 	const {bundle} = await import('@remotion/bundler');
 	const {renderMedia, renderStill, selectComposition} = await import('@remotion/renderer');
@@ -222,8 +249,9 @@ export async function render({proyecto = process.cwd(), ids, todos = false, log
 	const nucleos = os.cpus().length;
 	const concurrenciaBase = p.render.concurrencia ?? (p.render.gl === 'angle' ? Math.max(2, Math.min(10, Math.floor(nucleos * 0.75))) : Math.max(1, Math.min(3, Math.floor(nucleos / 4))));
 	const sinTTY = !process.stdout.isTTY;
-	for (const [i, id] of lista.entries()) {
+	for (const [i, id] of listos.entries()) {
 		const t = Date.now();
+		try {
 		const inputProps = {videos: {[id]: datos[id]}, marca, ...extras};
 		const mp4 = salidaDe(p, id);
 		let gl = p.render.gl;
@@ -242,7 +270,7 @@ export async function render({proyecto = process.cwd(), ids, todos = false, log
 					browserExecutable,
 					chromiumOptions: chromium,
 					codec: 'h264',
-					crf: p.render.crf,
+					crf: crfDe(p, id),
 					audioBitrate: '192k',
 					imageFormat: 'jpeg',
 					jpegQuality: 92,
@@ -254,8 +282,8 @@ export async function render({proyecto = process.cwd(), ids, todos = false, log
 						const paso = sinTTY ? 4 : 10;
 						const n = Math.floor(progress * paso);
 						if (n !== ultimo) {
-							if (sinTTY) log(`[${i + 1}/${lista.length}] ${id}: video ${Math.round((n / paso) * 100)}%`);
-							else process.stdout.write(`\r[${i + 1}/${lista.length}] ${id}: video ${n * 10}%   `);
+							if (sinTTY) log(`[${i + 1}/${listos.length}] ${id}: video ${Math.round((n / paso) * 100)}%`);
+							else process.stdout.write(`\r[${i + 1}/${listos.length}] ${id}: video ${n * 10}%   `);
 						}
 						ultimo = n;
 					},
@@ -285,10 +313,39 @@ export async function render({proyecto = process.cwd(), ids, todos = false, log
 		}
 		const segundos = Math.round((Date.now() - t) / 1000);
 		if (process.stdout.isTTY) process.stdout.write('\r');
-		log(`[${i + 1}/${lista.length}] ${id}: listo en ${segundos} s  →  ${path.relative(p.proyecto, mp4)}      `);
+		log(`[${i + 1}/${listos.length}] ${id}: listo en ${segundos} s  →  ${path.relative(p.proyecto, mp4)}      `);
 		hechos.push({id, mp4, jpg, segundos});
+		} catch (e) {
+			if (process.stdout.isTTY) process.stdout.write('\n');
+			fallidos.push({id, error: mensajeDe(e)});
+			log(`[${i + 1}/${listos.length}] ${id}: ✘ ${mensajeDe(e)}`);
+		}
 	}
+	return terminarLote(p, loteArchivo, hechos, fallidos, log);
+}
+
+const CRF = {alta: 18, media: 21, ligera: 24};
+/** CRF del video: `crf` explícito > `calidad` del video > `render.calidad` > media con mundo, alta sin él. */
+export function crfDe(p, id) {
+	if (p.render.crf != null) return p.render.crf;
+	const v = p.videos[id] ?? {};
+	return CRF[v.calidad ?? p.render.calidad ?? (v.mundo?.length ? 'media' : 'alta')] ?? 18;
+}
+
+/** Primera línea útil de un error (sin la pila de Remotion o de Python). */
+const mensajeDe = (e) => String(e?.message ?? e).split('\n').find((l) => l.trim()) ?? 'error desconocido';
+
+/** Resumen del lote: lo guarda (para --solo-fallidos), lo imprime y marca la salida con error si algo falló. */
+function terminarLote(p, archivo, hechos, fallidos, log) {
 	escribirResumen(p);
+	fs.mkdirSync(path.dirname(archivo), {recursive: true});
+	fs.writeFileSync(archivo, JSON.stringify({fecha: new Date().toISOString(), hechos: hechos.map((h) => h.id), fallidos}, null, '\t'));
+	if (fallidos.length) {
+		log(`\n${hechos.length} hecho(s), ${fallidos.length} con error:`);
+		for (const f of fallidos) log(`  ✘ ${f.id}: ${f.error}`);
+		log('Corrígelos y vuelve a intentar solo esos con:  npx morfeo render --solo-fallidos');
+		process.exitCode = 1;
+	}
 	return hechos;
 }
 
@@ -318,6 +375,14 @@ function escribirResumen(p) {
 	fs.writeFileSync(path.join(p.salida, 'resumen.json'), JSON.stringify(filas, null, '\t') + '\n');
 	// créditos para la descripción del video (las licencias CC BY piden mencionar al autor)
 	const conCreditos = filas.filter((f) => f.creditos?.length);
+	// <id>.txt: lo que se copia al publicar (título, descripción, etiquetas y créditos)
+	for (const f of filas) {
+		const v = p.videos[f.id];
+		const tags = (v.tags ?? []).map((x) => `#${String(x).replace(/^#/, '').replace(/\s+/g, '')}`).join(' ');
+		const creditos = f.creditos?.length ? ['', 'Créditos:', ...f.creditos.map((c) => `- ${c}`)] : [];
+		const lineas = [v.title ?? f.id, '', ...(v.descripcion ? [v.descripcion, ''] : []), ...(tags ? [tags] : []), ...creditos];
+		fs.writeFileSync(path.join(p.salida, `${f.id}.txt`), lineas.join('\n').trim() + '\n');
+	}
 	if (conCreditos.length)
 		fs.writeFileSync(path.join(p.salida, 'creditos.md'), ['# Créditos de recursos', '', ...conCreditos.flatMap((f) => [`## ${f.titulo}`, ...f.creditos.map((c) => `- ${c}`), ''])].join('\n'));
 }

package/lib/whisper.mjs

@@ -8,7 +8,30 @@ import {WHISPER, pythonVenv} from './entorno.mjs';
 const VERSION_CPP = '1.7.6';
 export const MODELO_WHISPER = 'small';
 
-export const whisperListo = () => fs.existsSync(path.join(WHISPER, `ggml-${MODELO_WHISPER}.bin`)) && fs.existsSync(path.join(WHISPER, '.listo'));
+/** Ruta del ejecutable donde @remotion/install-whisper-cpp lo va a buscar (whisper-cli desde 1.7.4). */
+const ejecutable = () => path.join(WHISPER, 'build', 'bin', process.platform === 'win32' ? 'whisper-cli.exe' : 'whisper-cli');
+
+/**
+ * En Windows, @remotion/install-whisper-cpp 4.0.541 descomprime los binarios en `Release/` pero luego busca
+ * `build/bin/whisper-cli.exe`: sin esto `transcribe` revienta con ENOENT (y tumba el proceso, porque el error sale
+ * de un evento sin manejar). Se copian los .exe y .dll a donde los busca.
+ */
+function acomodarWindows() {
+	if (process.platform !== 'win32' || fs.existsSync(ejecutable())) return;
+	const release = path.join(WHISPER, 'Release');
+	if (!fs.existsSync(path.join(release, 'whisper-cli.exe'))) return;
+	const destino = path.dirname(ejecutable());
+	fs.mkdirSync(destino, {recursive: true});
+	for (const f of fs.readdirSync(release)) if (/\.(exe|dll)$/i.test(f)) fs.copyFileSync(path.join(release, f), path.join(destino, f));
+}
+
+export const whisperListo = () => {
+	if (!fs.existsSync(path.join(WHISPER, `ggml-${MODELO_WHISPER}.bin`)) || !fs.existsSync(path.join(WHISPER, '.listo'))) return false;
+	try {
+		acomodarWindows();
+	} catch {}
+	return fs.existsSync(ejecutable());
+};
 
 /** Herramientas que whisper.cpp necesita para compilarse (en Windows se descarga ya compilado). */
 export function faltaParaWhisper() {
@@ -20,15 +43,36 @@ export function faltaParaWhisper() {
 const compilado = () => fs.existsSync(path.join(WHISPER, 'build', 'bin', process.platform === 'win32' ? 'whisper-cli.exe' : 'whisper-cli'));
 
 export async function instalarWhisper() {
+	// en Windows los binarios vienen en Release/: se acomodan antes de decidir si la carpeta quedó a medias
+	try {
+		acomodarWindows();
+	} catch {}
 	// Un intento anterior que falló a medias deja la carpeta sin el ejecutable, y Remotion se niega a seguir: se limpia.
 	if (fs.existsSync(WHISPER) && !compilado()) fs.rmSync(WHISPER, {recursive: true, force: true});
 	try {
-		await installWhisperCpp({to: WHISPER, version: VERSION_CPP, printOutput: true});
+		// en Mac/Linux compila (su salida sirve si falla); en Windows solo descarga
+		await installWhisperCpp({to: WHISPER, version: VERSION_CPP, printOutput: process.platform !== 'win32'});
+		acomodarWindows();
 	} catch (e) {
 		if (!compilado()) fs.rmSync(WHISPER, {recursive: true, force: true});
 		throw e;
 	}
-	await downloadWhisperModel({model: MODELO_WHISPER, folder: WHISPER, printOutput: true});
+	// progreso en una sola línea con terminal; sin terminal (logs), cada 25 %: antes imprimía cientos de líneas
+	let ultimo = -1;
+	await downloadWhisperModel({
+		model: MODELO_WHISPER,
+		folder: WHISPER,
+		printOutput: false,
+		onProgress: (bajado, total) => {
+			const pct = total ? Math.floor((bajado / total) * 100) : 0;
+			if (process.stdout.isTTY) process.stdout.write(`\r    modelo de Whisper: ${pct}%   `);
+			else if (Math.floor(pct / 25) !== ultimo) console.log(`    modelo de Whisper: ${pct}%`);
+			ultimo = Math.floor(pct / 25);
+		},
+	});
+	if (process.stdout.isTTY) process.stdout.write('\n');
+	acomodarWindows();
+	if (!fs.existsSync(ejecutable())) throw new Error(`Whisper se descargó pero no encuentro ${ejecutable()}. Borra ${WHISPER} y vuelve a correr: npx morfeo instalar --whisper`);
 	fs.writeFileSync(path.join(WHISPER, '.listo'), VERSION_CPP);
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "morfeo",
-	"version": "0.3.0",
+	"version": "0.3.1",
 	"description": "Genera videos verticales animados (Remotion + Three.js) con voz, música y subtítulos, desde un guion en código o escrito por IA.",
 	"type": "module",
 	"license": "SEE LICENSE IN LICENSE",
@@ -45,6 +45,7 @@
 		"python/requirements.txt",
 		"assets",
 		"plantilla",
+		"bases",
 		"index.d.ts",
 		"LICENSE",
 		"README.md"
@@ -55,8 +56,8 @@
 	"scripts": {
 		"postinstall": "node bin/postinstall.mjs",
 		"typecheck": "tsc --noEmit",
-		"test": "node --test test/",
-		"prepublishOnly": "tsc --noEmit && node bin/morfeo.mjs -v"
+		"test": "node --test \"test/*.test.mjs\"",
+		"prepublishOnly": "tsc --noEmit && npm test && node bin/morfeo.mjs -v"
 	},
 	"dependencies": {
 		"@anthropic-ai/sdk": "^1.6.0",

package/plantilla/morfeo.config.mjs

@@ -3,7 +3,8 @@ import {defineConfig} from 'morfeo';
 
 export default defineConfig({
 	// Estilo visual por defecto (cada video puede cambiarlo con  estilo: '...'):
-	//   datos-curiosos, explicativo, documental, ilustrado, historia, mesa, serie, infografia, 3d, minimal   (npx morfeo estilos)
+	//   datos-curiosos, explicativo, documental, ilustrado, historia, mesa, serie, infografia, 3d, maqueta, minimal   (npx morfeo estilos)
+	// Para empezar un video con mundo 2D o 3D:  npx morfeo nuevo-video mi-video --look 2d
 	estilo: 'datos-curiosos',
 
 	marca: {
@@ -17,6 +18,7 @@ export default defineConfig({
 	// Alias para no repetir: úsalos como voice: 'narrador' o music: 'mi-cancion'
 	voces: {
 		narrador: [['em_alex', 0.6], ['am_michael', 0.4]], // mezcla de voces Kokoro (gratis, en tu computadora)
+		narradora: [['ef_dora', 0.6], ['af_heart', 0.4]],
 		// eleven: {proveedor: 'elevenlabs', voz: 'TU_VOICE_ID'}, // necesita ELEVENLABS_API_KEY en .env
 		// openai: {proveedor: 'openai', voz: 'nova'},            // necesita OPENAI_API_KEY en .env
 	},

package/python/musica.py

@@ -175,20 +175,50 @@ def efecto(nombre, rng):
     if nombre == "tick": return 0.4 * tick()
     if nombre == "glitch": return 0.3 * glitch(rng)
     if nombre == "ding": return 0.2 * bell(nf(88), 0.8)
+    if nombre == "golpe":
+        x = 0.22 * pop(180, 90, 0.16)
+        add(x, 0.1 * lp(rng.standard_normal(int(0.06 * SR)), 1200), 0)
+        return x
     return 0.14 * pop()
 
 
+# sonido por defecto según cómo entra o qué es la capa (sonido: false lo apaga; sonido: "x" lo cambia)
+SONIDO_TIPO = {"sello": "golpe", "dato": "tick", "contador": "tick", "nombre": "pop", "accion": "pop", "chip": "pop", "insignia": "pop"}
+SONIDO_ENTRADA = {"rebote": "pop", "caer": "golpe", "deslizar-izq": "whoosh", "deslizar-der": "whoosh", "deslizar-arriba": "whoosh", "deslizar-abajo": "whoosh", "girar": "whoosh"}
+
+
+def sonido_de(c):
+    s = c.get("sonido")
+    if s is False or s == "ninguno": return None
+    if s: return s
+    return SONIDO_TIPO.get(c.get("tipo")) or SONIDO_ENTRADA.get(c.get("entrada"))
+
+
 def capas_con_sonido(sp):
-    """Capas de la escena (y de sus grupos) que piden un efecto de sonido."""
+    """[(capa, efecto, explícito)] de la escena y de sus grupos; las de enMundo y las del HUD no suenan solas."""
     out, pila = [], list(sp.get("capas") or [])
     while pila:
         c = pila.pop(0)
         if not isinstance(c, dict): continue
-        if c.get("sonido"): out.append(c)
+        ef = sonido_de(c)
+        if ef: out.append((c, ef, bool(c.get("sonido"))))
         pila.extend(c.get("capas") or [])
     return out
 
 
+def momento(en, ev, si, m):
+    """Segundos (relativos a la escena) de `en`: número, palabra, "palabra+0.3", "inicio", "voz" o "fin" (como cuando() del motor)."""
+    if en is None: return 0.3
+    if isinstance(en, (int, float)): return float(en)
+    import re
+    g = re.match(r"^(.*?)([+-]\d+(?:\.\d+)?)?$", str(en))
+    base, ajuste = (g.group(1) or "").strip(), float(g.group(2) or 0)
+    if base in ("", "inicio"): return ajuste
+    if base == "voz": return m["start"] - m["t0"] + ajuste
+    if base == "fin": return m["start"] - m["t0"] + m["speech"] + ajuste
+    return ev(si, base) + ajuste
+
+
 def mix(vid, style, outdir, TIM, SPEC, durs, ev):
     """Mezcla voz + música (con ducking) + efectos y escribe mix.wav. style=None: sin música."""
     dur = sum(durs); N = int(dur * SR); rng = np.random.default_rng(11)
@@ -206,11 +236,14 @@ def mix(vid, style, outdir, TIM, SPEC, durs, ev):
         if ty == "text" and sp.get("strike"):
             for i in range(len(sp["rows"])): add(sfx, 0.2 * whoosh(rng, 0.15), t0 + m["speech"] * 0.55 + i * 0.12)
         if ty == "cta": add(sfx, 0.4 * tick(), t0 + 1.6)
-        # motor de capas: cada capa (o grupo) con "sonido" suena cuando entra
-        for capa in capas_con_sonido(sp):
-            cuando = capa.get("en", 0.3)
-            tc = t0 + (ev(si, cuando) if isinstance(cuando, str) else float(cuando))
-            add(sfx, efecto(capa["sonido"], rng), tc)
+        # motor de capas: cada capa suena cuando entra (las explícitas siempre; las automáticas, más bajas y sin amontonarse)
+        if sp.get("rotulo"): add(sfx, 0.5 * efecto("whoosh", rng), t0 + momento(sp.get("rotuloEn", 0.12), ev, si, m) - 0.05)
+        usados = []
+        for capa, ef, explicito in sorted(capas_con_sonido(sp), key=lambda x: momento(x[0].get("en"), ev, si, m)):
+            tc = t0 + momento(capa.get("en"), ev, si, m)
+            if not explicito and any(abs(tc - u) < 0.25 for u in usados): continue
+            usados.append(tc)
+            add(sfx, (1.0 if explicito else 0.6) * efecto(ef, rng), tc)
     voice, _ = sf.read(os.path.join(outdir, "voz.wav"))
     voice = resample_poly(voice, 147, 80)
     v = np.zeros(N); v[: min(N, len(voice))] = voice[:N]

package/python/preparar.py

@@ -228,16 +228,25 @@ def preparar(job):
     if not voz_vigente(v, outdir):
         print("    voz...", flush=True); hacer_voz(v, outdir, job["modelos"])
     if job.get("soloVoz"): return
+    # pidió Whisper y la transcripción no existe (voz nueva): se sale con 10 para que morfeo transcriba y vuelva a llamar
+    if job.get("conWhisper") and not os.path.exists(os.path.join(outdir, "whisper.json")): sys.exit(10)
     TIM = json.load(open(os.path.join(outdir, "tiempos.json"), encoding="utf-8"))["escenas"]
     wj = os.path.join(outdir, "whisper.json"); ww = palabras_whisper(wj) if os.path.exists(wj) else None
     WORDS, reales = [], 0
     for seg in TIM:
         w, ok = tiempos_palabras(seg, ww); WORDS.append(w); reales += ok
 
+    def norm(x):
+        # igual que norm() de remotion/motor/util.ts: sin acentos, minúsculas, solo letras y números
+        import unicodedata
+        x = unicodedata.normalize("NFD", str(x))
+        return "".join(ch for ch in x if not unicodedata.combining(ch)).lower().translate({ord(c): None for c in "¿?.,:;¡!\"'«»()"}).replace(" ", "")
+
     def ev(si, prefix):
         seg = TIM[si]
+        p = norm(prefix)
         for w, a, b in WORDS[si]:
-            if w.lower().strip("¿?.,:¡!").startswith(prefix.lower()): return a - seg["t0"]
+            if norm(w).startswith(p): return a - seg["t0"]
         return seg["speech"] * 0.5
 
     durs = [seg["dur"] + (0.6 if i == len(TIM) - 1 else 0) for i, seg in enumerate(TIM)]

package/remotion/kit/datos.tsx

@@ -0,0 +1,180 @@
+// Gráficas 2D que se dibujan solas (van DENTRO de un <svg>): barras, línea, comparación y lupa.
+// `t` es el tiempo y `en` el momento en que empiezan (segundos); todo se anima con el tiempo.
+//
+//   <GraficaBarras x={140} y={700} ancho={800} alto={500} t={t} en={1} datos={[['0 m', 100], ['1 m', 50], ['2 m', 25]]} />
+//   <GraficaLinea x={140} y={700} ancho={800} alto={420} t={t} puntos={[100, 50, 25, 12]} etiquetas={['0', '1', '2', '3']} />
+//   <Comparacion x={540} y={1300} t={t} a={['ANTES', 10]} b={['DESPUÉS', 27.4]} unidad="kg" />
+//   <Lupa x={540} y={900} radio={220} t={t}> ...lo que se ve aumentado... </Lupa>
+import React from 'react';
+
+const k = (t: number, en: number, dur: number) => {
+	const x = Math.max(0, Math.min(1, (t - en) / dur));
+	return 1 - (1 - x) ** 3;
+};
+const fmt = (v: number, dec = 0) => v.toLocaleString('es-MX', {minimumFractionDigits: dec, maximumFractionDigits: dec});
+
+type Comun = {x: number; y: number; t: number; en?: number; color?: string; texto?: string; fuente?: string};
+
+/** Barras horizontales: [etiqueta, valor]. La más grande ocupa todo el ancho; el valor cuenta mientras crece. */
+export const GraficaBarras: React.FC<Comun & {ancho?: number; alto?: number; datos: [string, number][]; unidad?: string; colores?: string[]; decimales?: number; maximo?: number}> = ({
+	x,
+	y,
+	t,
+	en = 0,
+	ancho = 820,
+	alto = 480,
+	datos,
+	unidad = '',
+	color = '#F2B632',
+	colores,
+	texto = '#FFFFFF',
+	fuente = 'JetBrains Mono, monospace',
+	decimales = 0,
+	maximo,
+}) => {
+	const max = maximo ?? Math.max(...datos.map(([, v]) => v), 1);
+	const fila = alto / datos.length;
+	const etiqueta = 150;
+	return (
+		<g transform={`translate(${x} ${y})`}>
+			{datos.map(([e, v], i) => {
+				const p = k(t, en + i * 0.18, 0.9);
+				const w = (ancho - etiqueta - 150) * (v / max) * p;
+				return (
+					<g key={i} transform={`translate(0 ${i * fila})`} opacity={Math.min(1, p * 4)}>
+						<text x={etiqueta - 20} y={fila * 0.42} textAnchor="end" dominantBaseline="middle" fontFamily={fuente} fontSize={fila * 0.32} fill={texto} opacity={0.75}>
+							{e}
+						</text>
+						<rect x={etiqueta} y={fila * 0.18} width={Math.max(4, w)} height={fila * 0.48} rx={fila * 0.1} fill={colores?.[i] ?? color} />
+						<text x={etiqueta + w + 16} y={fila * 0.42} dominantBaseline="middle" fontFamily={fuente} fontWeight={700} fontSize={fila * 0.32} fill={texto}>
+							{fmt(v * p, decimales)}
+							{unidad}
+						</text>
+					</g>
+				);
+			})}
+		</g>
+	);
+};
+
+/** Línea que se dibuja de izquierda a derecha, con puntos y etiquetas en el eje. */
+export const GraficaLinea: React.FC<Comun & {ancho?: number; alto?: number; puntos: number[]; etiquetas?: string[]; minimo?: number; maximo?: number; relleno?: boolean; dur?: number}> = ({
+	x,
+	y,
+	t,
+	en = 0,
+	ancho = 820,
+	alto = 420,
+	puntos,
+	etiquetas = [],
+	color = '#F07A3A',
+	texto = '#FFFFFF',
+	fuente = 'JetBrains Mono, monospace',
+	minimo,
+	maximo,
+	relleno = true,
+	dur = 1.4,
+}) => {
+	const mn = minimo ?? Math.min(0, ...puntos);
+	const mx = maximo ?? Math.max(...puntos);
+	const px = (i: number) => (i / Math.max(1, puntos.length - 1)) * ancho;
+	const py = (v: number) => alto - ((v - mn) / Math.max(1e-6, mx - mn)) * alto;
+	const p = k(t, en, dur);
+	const d = puntos.map((v, i) => `${i ? 'L' : 'M'} ${px(i)} ${py(v)}`).join(' ');
+	const largo = puntos.slice(1).reduce((s, v, i) => s + Math.hypot(px(i + 1) - px(i), py(v) - py(puntos[i])), 0);
+	const id = `linea-${Math.round(x)}-${Math.round(y)}`;
+	return (
+		<g transform={`translate(${x} ${y})`}>
+			<line x1={0} y1={alto} x2={ancho} y2={alto} stroke={texto} strokeOpacity={0.35} strokeWidth={3} />
+			<line x1={0} y1={0} x2={0} y2={alto} stroke={texto} strokeOpacity={0.35} strokeWidth={3} />
+			{relleno ? (
+				<>
+					<defs>
+						<linearGradient id={id} x1="0" y1="0" x2="0" y2="1">
+							<stop offset="0" stopColor={color} stopOpacity={0.35} />
+							<stop offset="1" stopColor={color} stopOpacity={0} />
+						</linearGradient>
+						<clipPath id={`${id}-c`}>
+							<rect x={0} y={-50} width={ancho * p} height={alto + 100} />
+						</clipPath>
+					</defs>
+					<path d={`${d} L ${ancho} ${alto} L 0 ${alto} Z`} fill={`url(#${id})`} clipPath={`url(#${id}-c)`} />
+				</>
+			) : null}
+			<path d={d} fill="none" stroke={color} strokeWidth={7} strokeLinecap="round" strokeLinejoin="round" strokeDasharray={largo} strokeDashoffset={largo * (1 - p)} />
+			{puntos.map((v, i) =>
+				px(i) <= ancho * p + 1 ? <circle key={i} cx={px(i)} cy={py(v)} r={11} fill={color} stroke="#fff" strokeWidth={4} /> : null,
+			)}
+			{etiquetas.map((e, i) => (
+				<text key={i} x={px(i)} y={alto + 44} textAnchor="middle" fontFamily={fuente} fontSize={28} fill={texto} opacity={0.7}>
+					{e}
+				</text>
+			))}
+		</g>
+	);
+};
+
+/** Dos columnas que crecen hasta su valor (antes / después, A contra B), con el número contando encima. */
+export const Comparacion: React.FC<Comun & {a: [string, number]; b: [string, number]; unidad?: string; alto?: number; colorA?: string; colorB?: string; decimales?: number}> = ({
+	x,
+	y,
+	t,
+	en = 0,
+	a,
+	b,
+	unidad = '',
+	alto = 520,
+	colorA = '#8A8F9C',
+	colorB = '#2FD08A',
+	texto = '#FFFFFF',
+	fuente = 'Montserrat, sans-serif',
+	decimales = 0,
+}) => {
+	const max = Math.max(a[1], b[1], 1e-6);
+	const col = (lbl: string, v: number, c: string, dx: number, retraso: number) => {
+		const p = k(t, en + retraso, 1.1);
+		const h = (alto * v * p) / max;
+		return (
+			<g transform={`translate(${dx} 0)`}>
+				<rect x={-90} y={-h} width={180} height={Math.max(2, h)} rx={18} fill={c} />
+				<text x={0} y={-h - 28} textAnchor="middle" fontFamily={fuente} fontWeight={900} fontSize={64} fill={texto}>
+					{fmt(v * p, decimales)}
+					<tspan fontSize={34}>{unidad}</tspan>
+				</text>
+				<text x={0} y={56} textAnchor="middle" fontFamily={fuente} fontWeight={800} fontSize={36} fill={texto} opacity={0.8}>
+					{lbl}
+				</text>
+			</g>
+		);
+	};
+	return (
+		<g transform={`translate(${x} ${y})`}>
+			<line x1={-280} y1={0} x2={280} y2={0} stroke={texto} strokeOpacity={0.4} strokeWidth={4} />
+			{col(a[0], a[1], colorA, -150, 0)}
+			{col(b[0], b[1], colorB, 150, 0.5)}
+		</g>
+	);
+};
+
+/** Lupa: aro con mango; dentro se ve `children` (lo que dibujes, normalmente más grande). Entra con un pequeño rebote. */
+export const Lupa: React.FC<{x: number; y: number; radio?: number; t: number; en?: number; fondo?: string; children?: React.ReactNode}> = ({x, y, radio = 220, t, en = 0, fondo = '#F4E6D8', children}) => {
+	const p = k(t, en, 0.5);
+	const s = 0.6 + 0.4 * p + Math.sin(Math.min(1, (t - en) / 0.5) * Math.PI) * 0.05;
+	const id = `lupa-${Math.round(x)}-${Math.round(y)}`;
+	if (p <= 0) return null;
+	return (
+		<g transform={`translate(${x} ${y}) scale(${s})`} opacity={Math.min(1, p * 3)}>
+			<defs>
+				<clipPath id={id}>
+					<circle r={radio} />
+				</clipPath>
+			</defs>
+			<rect x={radio * 0.62} y={radio * 0.62} width={radio * 0.3} height={radio * 0.95} rx={radio * 0.12} transform={`rotate(-45 ${radio * 0.77} ${radio * 0.62})`} fill="#5A3A28" />
+			<circle r={radio} fill={fondo} />
+			<g clipPath={`url(#${id})`}>{children}</g>
+			<circle r={radio} fill="none" stroke="#E9EDF2" strokeWidth={radio * 0.11} />
+			<circle r={radio * 1.05} fill="none" stroke="rgba(0,0,0,0.25)" strokeWidth={4} />
+			<path d={`M ${-radio * 0.55} ${-radio * 0.35} A ${radio * 0.7} ${radio * 0.7} 0 0 1 ${-radio * 0.2} ${-radio * 0.62}`} stroke="rgba(255,255,255,0.7)" strokeWidth={10} fill="none" strokeLinecap="round" />
+		</g>
+	);
+};