morfeo 0.2.1 → 0.3.1

package/lib/nuevo-video.mjs

@@ -0,0 +1,65 @@
+// `morfeo nuevo-video <id> --look 2d|3d`: crea guiones/<id>.mjs y escenas/Mundo<Id>.tsx desde una base que ya
+// renderiza (carpeta bases/ del paquete) y registra el componente en morfeo.config.mjs → componentes.
+import fs from 'node:fs';
+import path from 'node:path';
+import {ErrorMorfeo} from './config.mjs';
+import {PAQUETE} from './entorno.mjs';
+
+export const LOOKS = ['2d', '3d'];
+
+/** "mi-video_2" -> "MundoMiVideo2" */
+export const nombreComponente = (id) =>
+	'Mundo' +
+	String(id)
+		.normalize('NFD')
+		.replace(/[̀-ͯ]/g, '')
+		.split(/[^A-Za-z0-9]+/)
+		.filter(Boolean)
+		.map((p) => p[0].toUpperCase() + p.slice(1))
+		.join('');
+
+/**
+ * Agrega {Nombre: './escenas/Nombre.tsx'} a `componentes` del config (o crea la clave). Devuelve el texto nuevo,
+ * o null si ya estaba registrado.
+ */
+export function registrarEnConfig(texto, nombre, ruta) {
+	if (new RegExp(`\\b${nombre}\\s*:`).test(texto)) return null;
+	const entrada = `${nombre}: '${ruta}'`;
+	const m = texto.match(/componentes\s*:\s*\{/);
+	if (m) {
+		const i = m.index + m[0].length;
+		const vacio = /^\s*\}/.test(texto.slice(i));
+		return texto.slice(0, i) + (vacio ? entrada : `${entrada}, `) + texto.slice(i);
+	}
+	// sin `componentes`: se agrega antes del cierre de defineConfig({...}) / export default {...}
+	const fin = texto.lastIndexOf('}');
+	if (fin < 0) throw new ErrorMorfeo('No pude entender morfeo.config.mjs para registrar el componente; agrégalo a mano en `componentes`.');
+	const antes = texto.slice(0, fin).replace(/\s*$/, '');
+	const coma = antes.endsWith(',') || antes.endsWith('{') ? '' : ',';
+	return `${antes}${coma}\n\tcomponentes: {${entrada}},\n${texto.slice(fin)}`;
+}
+
+/**
+ * @param {{proyecto: string, id: string, look?: string, carpetaGuiones?: string}} o
+ * @returns {{guion: string, escena: string, componente: string}}
+ */
+export function nuevoVideo({proyecto, id, look = '2d', carpetaGuiones}) {
+	if (!id || !/^[a-z0-9][a-z0-9-_]*$/i.test(id)) throw new ErrorMorfeo('Dame un id corto sin espacios:  npx morfeo nuevo-video mi-video --look 2d');
+	if (!LOOKS.includes(look)) throw new ErrorMorfeo(`--look debe ser ${LOOKS.join(' o ')}`);
+	const config = ['morfeo.config.mjs', 'morfeo.config.js'].map((f) => path.join(proyecto, f)).find((f) => fs.existsSync(f));
+	if (!config) throw new ErrorMorfeo(`No encontré morfeo.config.mjs en ${proyecto}. Crea un proyecto con:  npx morfeo nuevo mi-canal`);
+	const componente = nombreComponente(id);
+	const dirGuiones = carpetaGuiones ?? path.join(proyecto, 'guiones');
+	const guion = path.join(dirGuiones, `${id}.mjs`);
+	const escena = path.join(proyecto, 'escenas', `${componente}.tsx`);
+	for (const f of [guion, escena]) if (fs.existsSync(f)) throw new ErrorMorfeo(`Ya existe ${path.relative(proyecto, f)}; elige otro id.`);
+	const base = path.join(PAQUETE, 'bases', look);
+	const poner = (s) => s.replaceAll('__ID__', id).replaceAll('__COMPONENTE__', componente);
+	fs.mkdirSync(dirGuiones, {recursive: true});
+	fs.mkdirSync(path.dirname(escena), {recursive: true});
+	fs.writeFileSync(guion, poner(fs.readFileSync(path.join(base, 'guion.mjs'), 'utf8')));
+	fs.writeFileSync(escena, poner(fs.readFileSync(path.join(base, 'Mundo.tsx'), 'utf8')));
+	const nuevo = registrarEnConfig(fs.readFileSync(config, 'utf8'), componente, `./escenas/${componente}.tsx`);
+	if (nuevo) fs.writeFileSync(config, nuevo);
+	return {guion, escena, componente};
+}

package/lib/palabras.mjs

@@ -0,0 +1,79 @@
+// Momentos por palabra ("en: 'tubería'") que la voz nunca dice: en el video caen "a media frase" sin avisar.
+// Esto los busca con las mismas reglas que `cuando()` de remotion/motor/util.ts y avisa antes de renderizar.
+
+/** Igual que `norm` de remotion/motor/util.ts: sin acentos, minúsculas, solo letras y números. */
+export const normalizar = (s) =>
+	String(s)
+		.normalize('NFD')
+		.replace(/[̀-ͯ]/g, '')
+		.toLowerCase()
+		.replace(/[^a-z0-9]/g, '');
+
+/** "palabra+0.3" -> "palabra"; null si no es un momento por palabra (número, inicio, voz, fin). */
+export function palabraDe(en) {
+	if (typeof en !== 'string') return null;
+	const m = en.match(/^(.*?)([+-]\d+(?:\.\d+)?)?$/);
+	const base = (m?.[1] ?? en).trim();
+	if (!base || ['inicio', 'voz', 'fin'].includes(base)) return null;
+	return base;
+}
+
+/** ¿La voz dice una palabra que empiece así? (la misma regla que `cuando`: "orca" encuentra "orcas"). */
+export const laDice = (palabra, dichas) => {
+	const n = normalizar(palabra);
+	return !n || dichas.some((w) => normalizar(w).startsWith(n));
+};
+
+const CLAVES = ['en', 'hasta', 'check', 'clic', 'rotuloEn'];
+
+/** Recorre una capa (y lo que lleva dentro) juntando [ruta, palabra]. */
+function momentosDe(x, ruta, out) {
+	if (Array.isArray(x)) return x.forEach((v, i) => momentosDe(v, `${ruta}[${i}]`, out));
+	if (!x || typeof x !== 'object') return;
+	for (const k of CLAVES) {
+		const p = palabraDe(x[k]);
+		if (p) out.push([`${ruta}.${k}`, p]);
+	}
+	// lo que vive dentro de una capa: sus capas, su capa repetida, cambios, poses, items, líneas, movimientos
+	for (const k of ['capas', 'capa', 'cambios', 'poses', 'items', 'lineas', 'mover', 'escalar', 'opciones', 'capasPantalla'])
+		if (x[k] != null) momentosDe(x[k], `${ruta}.${k}`, out);
+}
+
+/**
+ * Avisos de momentos por palabra que no están en lo que dice la voz.
+ * @param {object} v  video validado (scenes, hud, mundo)
+ * @param {object} d  datos.json del video (palabras por escena)
+ * @returns {string[]}
+ */
+export function revisarPalabras(v, d) {
+	if (!d?.escenas) return [];
+	const avisos = [];
+	const todas = d.escenas.flatMap((e) => (e.palabras ?? []).map(([w]) => w));
+	(v.scenes ?? []).forEach((s, i) => {
+		const e = d.escenas[i];
+		if (!s || !e) return;
+		const dichas = (e.palabras ?? []).map(([w]) => w);
+		if (!dichas.length) return;
+		const momentos = [];
+		// los de la escena misma (rotuloEn, at/click de las clásicas) y los de sus capas
+		for (const k of ['rotuloEn', 'at', 'click']) {
+			const p = palabraDe(s[k]);
+			if (p) momentos.push([k, p]);
+		}
+		momentosDe(s.capas ?? [], 'capas', momentos);
+		momentosDe(s.items ?? [], 'items', momentos);
+		momentosDe(s.opciones ?? [], 'opciones', momentos);
+		// con `show`, los momentos se buscan en las palabras del subtítulo (las cifras quedan como "1.560.000")
+		const texto = String(s.show ?? s.say ?? '').slice(0, 60);
+		for (const [ruta, p] of momentos)
+			if (!laDice(p, dichas))
+				avisos.push(`escena ${i + 1}, ${ruta}: "${p}" no está en ${s.show ? 'el subtítulo (`show`)' : 'lo que dice la voz'} ("${texto}"); se usará la mitad de la frase`);
+	});
+	// hud y mundo usan las palabras de todo el video
+	for (const [k, lista] of [['hud', v.hud], ['mundo', v.mundo]]) {
+		const momentos = [];
+		momentosDe(lista ?? [], k, momentos);
+		for (const [ruta, p] of momentos) if (!laDice(p, todas)) avisos.push(`${ruta}: "${p}" no aparece en ninguna escena`);
+	}
+	return avisos;
+}

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.2.1",
+	"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)]