morfeo 0.3.0 → 0.3.3

package/lib/render.mjs

@@ -6,7 +6,7 @@ import fs from 'node:fs';
 import {createRequire} from 'node:module';
 import path from 'node:path';
 import {cargarProyecto, ErrorMorfeo} from './config.mjs';
-import {ENTRADA_REMOTION, FUENTES, MODELOS, PY_DIR, modelosListos, pythonVenv, venvListo} from './entorno.mjs';
+import {ENTRADA_REMOTION, FUENTES, MODELOS, PAQUETE, PY_DIR, modelosListos, pythonVenv, venvListo} from './entorno.mjs';
 import {asegurarNavegador} from './navegador.mjs';
 import {generarImagenes} from './imagenes.mjs';
 import {ponerPoses, prepararPersonajes} from './personajes.mjs';
@@ -14,6 +14,8 @@ 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';
+import {ordenarSalida, salidaDe} from './salida.mjs';
 
 const require = createRequire(import.meta.url);
 
@@ -70,7 +72,13 @@ function huellaMotor() {
 }
 
 // Remotion calcula la clave del caché a partir de la configuración: meter la huella ahí la invalida
-const conHuella = (config) => ({...config, name: `morfeo-${huellaMotor()}`});
+// También: los componentes del proyecto pueden importar 'three', 'react' o '@react-three/fiber' aunque no estén instalados
+// en el proyecto (llegan como dependencias de morfeo; con `npm i ../morfeo` o pnpm no quedan en su node_modules).
+const conHuella = (config) => ({
+	...config,
+	name: `morfeo-${huellaMotor()}`,
+	resolve: {...config.resolve, modules: [...(config.resolve?.modules ?? ['node_modules']), path.join(PAQUETE, 'node_modules')]},
+});
 
 /**
  * Entrada de Remotion. Sin componentes propios es la del paquete; con ellos, Morfeo escribe
@@ -127,13 +135,13 @@ export const datosDe = (publico, id) => {
 	return fs.existsSync(f) ? JSON.parse(fs.readFileSync(f, 'utf8')) : null;
 };
 
-const salidaDe = (p, id) => path.join(p.salida, `${id}.mp4`);
 
 /** [{id, titulo, hecho}] en el orden del proyecto. */
 export async function lista({proyecto = process.cwd()} = {}) {
 	cargarEnv(proyecto);
 	const p = await cargarProyecto(proyecto);
-	return Object.entries(p.videos).map(([id, v]) => ({id, titulo: v.title ?? id, hecho: fs.existsSync(salidaDe(p, id))}));
+	ordenarSalida(p);
+	return Object.entries(p.videos).map(([id, v]) => ({id, titulo: v.title ?? id, archivo: path.basename(salidaDe(p, id)), hecho: fs.existsSync(salidaDe(p, id))}));
 }
 
 /** Corre python/preparar.py con el trabajo indicado; su salida va directo a la terminal. */
@@ -142,14 +150,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 +171,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 +184,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 +213,20 @@ 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 [];
+		}
+	}
+	// archivos ya hechos con el id o con un título viejo → su nombre actual (sin volver a renderizar)
+	ordenarSalida(p, (m) => log(m));
 	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,94 +235,175 @@ 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)}`);
 		}
 
-	log('Empaquetando la animación...');
-	const {bundle} = await import('@remotion/bundler');
-	const {renderMedia, renderStill, selectComposition} = await import('@remotion/renderer');
-	const entrada = entradaDe(p);
-	const serveUrl = await bundle({entryPoint: entrada, publicDir: publico, rootDir: entrada === ENTRADA_REMOTION ? path.dirname(ENTRADA_REMOTION) : p.proyecto, webpackOverride: conHuella});
-	fs.mkdirSync(p.salida, {recursive: true});
-	const chromiumOptions = {gl: p.render.gl};
-	const browserExecutable = p.render.navegador ?? (await asegurarNavegador(log));
+	if (!listos.length) return terminarLote(p, loteArchivo, [], fallidos, log);
+	// un solo render a la vez en esta computadora: dos Chrome usando la GPU al mismo tiempo dejaban en algunos
+	// cuadros pedazos de texto de cuadros anteriores (rótulos o subtítulos fantasma)
 	const hechos = [];
-	// cuadros en paralelo: con GPU aguanta más; por software cada pestaña come mucha CPU y memoria
-	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()) {
-		const t = Date.now();
-		const inputProps = {videos: {[id]: datos[id]}, marca, ...extras};
-		const mp4 = salidaDe(p, id);
-		let gl = p.render.gl;
-		let concurrencia = concurrenciaBase;
-		let composition;
-		// hasta 3 intentos: si el navegador truena, se baja la concurrencia y, con GPU, se pasa a software
-		for (let intento = 1; ; intento++) {
-			const chromium = {gl};
-			let ultimo = -1;
+	const soltar = await tomarCandado(log);
+	try {
+		log('Empaquetando la animación...');
+		const {bundle} = await import('@remotion/bundler');
+		const {renderMedia, renderStill, selectComposition} = await import('@remotion/renderer');
+		const entrada = entradaDe(p);
+		const serveUrl = await bundle({entryPoint: entrada, publicDir: publico, rootDir: entrada === ENTRADA_REMOTION ? path.dirname(ENTRADA_REMOTION) : p.proyecto, webpackOverride: conHuella});
+		fs.mkdirSync(p.salida, {recursive: true});
+		const chromiumOptions = {gl: p.render.gl};
+		const browserExecutable = p.render.navegador ?? (await asegurarNavegador(log));
+		// cuadros en paralelo: con GPU aguanta más; por software cada pestaña come mucha CPU y memoria
+		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 listos.entries()) {
+			const t = Date.now();
 			try {
-				composition = await selectComposition({serveUrl, id, inputProps, browserExecutable, chromiumOptions: chromium});
-				await renderMedia({
-					serveUrl,
-					composition,
-					inputProps,
-					browserExecutable,
-					chromiumOptions: chromium,
-					codec: 'h264',
-					crf: p.render.crf,
-					audioBitrate: '192k',
-					imageFormat: 'jpeg',
-					jpegQuality: 92,
-					concurrency: concurrencia,
-					outputLocation: mp4,
-					onProgress: ({progress}) => {
-						alProgreso?.(id, progress);
-						// con terminal: cada 10 % en la misma línea; sin terminal (logs, CI): cada 25 %
-						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}%   `);
-						}
-						ultimo = n;
-					},
-				});
-				chromiumOptions.gl = gl;
-				break;
+			const inputProps = {videos: {[id]: datos[id]}, marca, ...extras};
+			const mp4 = salidaDe(p, id);
+			let gl = p.render.gl;
+			let concurrencia = concurrenciaBase;
+			let composition;
+			// hasta 3 intentos: si el navegador truena, se baja la concurrencia y, con GPU, se pasa a software
+			for (let intento = 1; ; intento++) {
+				const chromium = {gl};
+				let ultimo = -1;
+				try {
+					composition = await selectComposition({serveUrl, id, inputProps, browserExecutable, chromiumOptions: chromium});
+					await renderMedia({
+						serveUrl,
+						composition,
+						inputProps,
+						browserExecutable,
+						chromiumOptions: chromium,
+						codec: 'h264',
+						crf: crfDe(p, id),
+						audioBitrate: '192k',
+						imageFormat: 'jpeg',
+						jpegQuality: 92,
+						concurrency: concurrencia,
+						outputLocation: mp4,
+						onProgress: ({progress}) => {
+							alProgreso?.(id, progress);
+							// con terminal: cada 10 % en la misma línea; sin terminal (logs, CI): cada 25 %
+							const paso = sinTTY ? 4 : 10;
+							const n = Math.floor(progress * paso);
+							if (n !== ultimo) {
+								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;
+						},
+					});
+					chromiumOptions.gl = gl;
+					break;
+				} catch (e) {
+					const msg = String(e?.message ?? e);
+					const truena = /crash|Session closed|Target closed|Protocol error|WebGL|context lost|browser has disconnected|Navigation failed/i.test(msg);
+					if (!truena || intento >= 3) throw e;
+					if (gl === 'angle' && /WebGL|context/i.test(msg)) gl = 'swangle';
+					else if (concurrencia > 1) concurrencia = Math.max(1, Math.floor(concurrencia / 2));
+					else if (gl === 'angle') gl = 'swangle';
+					log(`\n    el navegador falló; reintento con ${gl === 'angle' ? 'GPU' : 'CPU'} y ${concurrencia} cuadro(s) a la vez...`);
+				}
+			}
+			let jpg = null;
+			if (p.render.miniatura) {
+				// miniatura: cuando la primera escena ya está completa (o en `miniaturaEn`), sin subtítulos
+				jpg = salidaDe(p, id, 'jpg');
+				const d = datos[id];
+				const e0 = d.escenas[0];
+				const seg = p.videos[id].miniaturaEn ?? Math.min(e0.dur - 0.15, Math.max(1.4, e0.habla[1] * 0.85));
+				const frame = Math.max(0, Math.min(composition.durationInFrames - 1, Math.round(seg * composition.fps)));
+				const props = {...inputProps, miniatura: true};
+				await renderStill({serveUrl, composition: {...composition, props: {...composition.props, miniatura: true}}, inputProps: props, browserExecutable, chromiumOptions: {gl}, frame, imageFormat: 'jpeg', jpegQuality: 92, output: jpg});
+			}
+			const segundos = Math.round((Date.now() - t) / 1000);
+			if (process.stdout.isTTY) process.stdout.write('\r');
+			log(`[${i + 1}/${listos.length}] ${id}: listo en ${segundos} s  →  ${path.relative(p.proyecto, mp4)}      `);
+			hechos.push({id, mp4, jpg, segundos});
 			} catch (e) {
-				const msg = String(e?.message ?? e);
-				const truena = /crash|Session closed|Target closed|Protocol error|WebGL|context lost|browser has disconnected|Navigation failed/i.test(msg);
-				if (!truena || intento >= 3) throw e;
-				if (gl === 'angle' && /WebGL|context/i.test(msg)) gl = 'swangle';
-				else if (concurrencia > 1) concurrencia = Math.max(1, Math.floor(concurrencia / 2));
-				else if (gl === 'angle') gl = 'swangle';
-				log(`\n    el navegador falló; reintento con ${gl === 'angle' ? 'GPU' : 'CPU'} y ${concurrencia} cuadro(s) a la vez...`);
+				if (process.stdout.isTTY) process.stdout.write('\n');
+				fallidos.push({id, error: mensajeDe(e)});
+				log(`[${i + 1}/${listos.length}] ${id}: ✘ ${mensajeDe(e)}`);
 			}
 		}
-		let jpg = null;
-		if (p.render.miniatura) {
-			// miniatura: cuando la primera escena ya está completa (o en `miniaturaEn`), sin subtítulos
-			jpg = path.join(p.salida, `${id}.jpg`);
-			const d = datos[id];
-			const e0 = d.escenas[0];
-			const seg = p.videos[id].miniaturaEn ?? Math.min(e0.dur - 0.15, Math.max(1.4, e0.habla[1] * 0.85));
-			const frame = Math.max(0, Math.min(composition.durationInFrames - 1, Math.round(seg * composition.fps)));
-			const props = {...inputProps, miniatura: true};
-			await renderStill({serveUrl, composition: {...composition, props: {...composition.props, miniatura: true}}, inputProps: props, browserExecutable, chromiumOptions: {gl}, frame, imageFormat: 'jpeg', jpegQuality: 92, output: jpg});
+	} finally {
+		soltar();
+	}
+	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;
+}
+
+/**
+ * Candado de render por computadora (~/.morfeo/render.lock con el pid). Si otro render de Morfeo está corriendo,
+ * espera a que termine; si el proceso del candado ya no existe, lo toma. Devuelve la función que lo suelta.
+ */
+async function tomarCandado(log) {
+	const {HOME} = await import('./entorno.mjs');
+	const archivo = path.join(HOME, 'render.lock');
+	fs.mkdirSync(HOME, {recursive: true});
+	const vivo = (pid) => {
+		try {
+			process.kill(pid, 0);
+			return true;
+		} catch (e) {
+			return e.code === 'EPERM';
+		}
+	};
+	let avisado = false;
+	for (;;) {
+		try {
+			fs.writeFileSync(archivo, String(process.pid), {flag: 'wx'});
+			break;
+		} catch (e) {
+			if (e.code !== 'EEXIST') throw e;
+			const pid = Number(fs.readFileSync(archivo, 'utf8')) || 0;
+			if (!pid || pid === process.pid || !vivo(pid)) {
+				fs.rmSync(archivo, {force: true});
+				continue;
+			}
+			if (!avisado) log(`Otro render de Morfeo está usando la tarjeta de video (proceso ${pid}); espero a que termine...`);
+			avisado = true;
+			await new Promise((r) => setTimeout(r, 2000));
 		}
-		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)}      `);
-		hechos.push({id, mp4, jpg, segundos});
 	}
+	const soltar = () => {
+		try {
+			if (Number(fs.readFileSync(archivo, 'utf8')) === process.pid) fs.rmSync(archivo, {force: true});
+		} catch {}
+	};
+	process.once('exit', soltar);
+	return soltar;
+}
+
+/** 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;
 }
 
@@ -313,11 +428,19 @@ function escribirResumen(p) {
 		.filter(([id]) => fs.existsSync(salidaDe(p, id)))
 		.map(([id, v]) => {
 			const c = creditosDe(p, id);
-			return {id, titulo: v.title ?? id, archivo: `${id}.mp4`, duracion: datosDe(publico, id)?.duracion ?? null, ...(c.length ? {creditos: c} : {}), ...(v.meta ? {meta: v.meta} : {})};
+			return {id, titulo: v.title ?? id, archivo: path.basename(salidaDe(p, id)), duracion: datosDe(publico, id)?.duracion ?? null, ...(c.length ? {creditos: c} : {}), ...(v.meta ? {meta: v.meta} : {})};
 		});
 	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);
+	// <título>.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(salidaDe(p, 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/salida.mjs

@@ -0,0 +1,84 @@
+// Nombres de los archivos terminados. Por defecto, el título del video: YouTube, TikTok e Instagram toman el nombre
+// del archivo como título al subirlo, así que no hay que escribirlo otra vez. `render.nombreArchivo: 'id'` vuelve a
+// usar el id. Los videos hechos con el id (versiones anteriores) se renombran solos, sin volver a renderizar.
+import fs from 'node:fs';
+import path from 'node:path';
+
+const EXTENSIONES = ['mp4', 'jpg', 'txt'];
+// nombres que Windows no permite como archivo
+const RESERVADOS = /^(con|prn|aux|nul|com\d|lpt\d)$/i;
+
+/** Título → nombre de archivo válido en Windows, Mac y Linux (conserva acentos y emojis). */
+export function nombreSeguro(titulo, respaldo = 'video') {
+	let s = String(titulo ?? '')
+		.normalize('NFC')
+		.replace(/[<>:"/\\|?*\u0000-\u001F]/g, ' ') // prohibidos en Windows
+		.replace(/\s+/g, ' ')
+		.trim()
+		.replace(/[. ]+$/g, ''); // Windows no acepta punto ni espacio al final
+	// largo máximo prudente (cuenta caracteres, no bytes; los emojis cuentan como uno)
+	const chars = [...s];
+	if (chars.length > 90) s = chars.slice(0, 90).join('').replace(/[. ]+$/g, '');
+	if (!s || RESERVADOS.test(s)) s = respaldo;
+	return s;
+}
+
+/**
+ * {id: nombre base} para todos los videos del proyecto. Dos videos con el mismo título se distinguen con " (2)",
+ * en el orden del proyecto, así que el nombre de cada uno no cambia entre renders.
+ */
+export function nombresDe(p) {
+	const porId = {};
+	const usados = new Set();
+	for (const [id, v] of Object.entries(p.videos)) {
+		const base = p.render?.nombreArchivo === 'id' ? id : nombreSeguro(v?.title, id);
+		let nombre = base;
+		for (let n = 2; usados.has(nombre.toLowerCase()); n++) nombre = `${base} (${n})`;
+		usados.add(nombre.toLowerCase());
+		porId[id] = nombre;
+	}
+	return porId;
+}
+
+/** Ruta de un archivo terminado: salidaDe(p, 'mi-video') → salida/<Título>.mp4 */
+export const salidaDe = (p, id, ext = 'mp4') => path.join(p.salida, `${nombresDe(p)[id] ?? id}.${ext}`);
+
+/**
+ * Pone los archivos ya hechos bajo su nombre actual: los que tenían el id (versiones anteriores) o un título viejo
+ * (registrado en .morfeo/archivos.json). Así cambiar el título renombra el video sin volver a renderizarlo.
+ */
+export function ordenarSalida(p, log = () => {}) {
+	const registro = path.join(p.trabajo, 'archivos.json');
+	let antes = {};
+	try {
+		antes = JSON.parse(fs.readFileSync(registro, 'utf8'));
+	} catch {}
+	const ahora = nombresDe(p);
+	if (fs.existsSync(p.salida)) {
+		for (const [id, nombre] of Object.entries(ahora)) {
+			for (const viejo of [antes[id], id]) {
+				if (!viejo || viejo === nombre) continue;
+				const de = path.join(p.salida, `${viejo}.mp4`);
+				const a = path.join(p.salida, `${nombre}.mp4`);
+				if (!fs.existsSync(de) || fs.existsSync(a)) continue;
+				for (const ext of EXTENSIONES) {
+					const d = path.join(p.salida, `${viejo}.${ext}`);
+					if (fs.existsSync(d)) fs.renameSync(d, path.join(p.salida, `${nombre}.${ext}`));
+				}
+				// la hoja de contacto también sigue al video
+				const hoja = path.join(p.salida, `${viejo}-hoja.png`);
+				if (fs.existsSync(hoja)) fs.renameSync(hoja, path.join(p.salida, `${nombre}-hoja.png`));
+				log(`  ${viejo}.mp4 → ${nombre}.mp4`);
+				break;
+			}
+		}
+	}
+	// resumen.json apunta a los archivos: que siga a los nombres nuevos
+	const resumen = path.join(p.salida, 'resumen.json');
+	try {
+		const filas = JSON.parse(fs.readFileSync(resumen, 'utf8'));
+		if (Array.isArray(filas)) fs.writeFileSync(resumen, JSON.stringify(filas.map((f) => (ahora[f.id] ? {...f, archivo: `${ahora[f.id]}.mp4`} : f)), null, '\t') + '\n');
+	} catch {}
+	fs.mkdirSync(p.trabajo, {recursive: true});
+	fs.writeFileSync(registro, JSON.stringify(ahora, null, '\t'));
+}

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,11 +1,11 @@
 {
 	"name": "morfeo",
-	"version": "0.3.0",
+	"version": "0.3.3",
 	"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",
 	"author": "Uriel Gómez",
-	"homepage": "https://ureckchan.github.io/morfeo/",
+	"homepage": "https://morfeo-docs-two.vercel.app/",
 	"repository": {
 		"type": "git",
 		"url": "git+https://github.com/UreckChan/morfeo.git"
@@ -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
 	},