morfeo 0.0.0-stage → 0.1.0

package/lib/navegador.mjs

@@ -0,0 +1,64 @@
+// Navegador de render compartido. Remotion descarga Chrome Headless Shell junto al package.json más
+// cercano al directorio actual (o sea, una copia de ~140 MB por proyecto). Morfeo lo descarga una sola
+// vez en ~/.morfeo/navegador y se lo pasa a cada render como browserExecutable.
+import fs from 'node:fs';
+import {createRequire} from 'node:module';
+import path from 'node:path';
+import {HOME} from './entorno.mjs';
+
+const require = createRequire(import.meta.url);
+const DIR = path.join(HOME, 'navegador');
+const MARCA = path.join(DIR, '.version-remotion');
+const versionRemotion = () => require('@remotion/renderer/package.json').version;
+
+function buscarEjecutable(dir, profundidad = 0) {
+	if (profundidad > 5 || !fs.existsSync(dir)) return null;
+	for (const e of fs.readdirSync(dir, {withFileTypes: true})) {
+		const p = path.join(dir, e.name);
+		if (e.isFile() && /^chrome-headless-shell(\.exe)?$/.test(e.name)) return p;
+		if (e.isDirectory()) {
+			const r = buscarEjecutable(p, profundidad + 1);
+			if (r) return r;
+		}
+	}
+	return null;
+}
+
+const ejecutable = () => buscarEjecutable(path.join(DIR, 'node_modules', '.remotion'));
+
+export const navegadorListo = () => {
+	try {
+		return !!ejecutable() && fs.readFileSync(MARCA, 'utf8') === versionRemotion();
+	} catch {
+		return false;
+	}
+};
+
+/** Devuelve la ruta del navegador compartido; lo descarga si falta o si cambió la versión de Remotion. */
+export async function asegurarNavegador(log = console.log) {
+	if (navegadorListo()) return ejecutable();
+	fs.mkdirSync(DIR, {recursive: true});
+	const pkg = path.join(DIR, 'package.json');
+	if (!fs.existsSync(pkg)) fs.writeFileSync(pkg, '{"private": true}\n');
+	log('Descargando el navegador de render (~100 MB, una sola vez para todos tus proyectos)...');
+	const {ensureBrowser} = await import('@remotion/renderer');
+	const antes = process.cwd();
+	process.chdir(DIR); // Remotion lo guarda junto al package.json del directorio actual
+	try {
+		await ensureBrowser({
+			onBrowserDownload: () => ({
+				version: null,
+				onProgress: ({percent}) => {
+					if (process.stdout.isTTY) process.stdout.write(`\r    navegador: ${Math.round(percent * 100)}%   `);
+				},
+			}),
+		});
+		if (process.stdout.isTTY) process.stdout.write('\n');
+	} finally {
+		process.chdir(antes);
+	}
+	const exe = ejecutable();
+	if (!exe) throw new Error(`No encontré el navegador después de descargarlo en ${DIR}`);
+	fs.writeFileSync(MARCA, versionRemotion());
+	return exe;
+}

package/lib/personajes.mjs

@@ -0,0 +1,94 @@
+// Personajes recurrentes (series): cada uno con sus poses, en archivos propios o generadas con IA
+// a partir de una imagen de referencia (así siempre es el mismo personaje).
+//
+//   personajes: {
+//     neto: {
+//       referencia: './personajes/neto.png',                 // opcional: base para generar poses con IA
+//       poses: {
+//         normal: './personajes/neto.png',                    // archivo propio
+//         feliz: 'con ojos de corazón, sonriendo',             // sin archivo: se genera con IA desde la referencia
+//         triste: './personajes/neto-triste.png',
+//       },
+//     },
+//   }
+//
+// En una escena: {tipo: 'personaje', nombre: 'neto', pose: 'normal', poses: [{en: 'enamorado', pose: 'feliz'}], hablar: true}
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import {ErrorMorfeo} from './config.mjs';
+
+const huella = (x) => crypto.createHash('sha1').update(JSON.stringify(x)).digest('hex').slice(0, 20);
+const esArchivo = (proyecto, v) => typeof v === 'string' && /\.(png|webp|jpe?g|svg|gif)$/i.test(v) && fs.existsSync(path.resolve(proyecto, v));
+
+/** Genera una pose nueva editando la imagen de referencia (OpenAI gpt-image-1, endpoint de ediciones). */
+async function poseOpenAI(referencia, descripcion, o) {
+	const clave = o.apiKey ?? process.env.OPENAI_API_KEY;
+	if (!clave) throw new ErrorMorfeo('Para generar poses con IA pon OPENAI_API_KEY en el .env (o usa tus propios PNG para cada pose).');
+	const form = new FormData();
+	form.append('model', o.modelo ?? 'gpt-image-1');
+	form.append('prompt', `El mismo personaje de la imagen, mismo estilo de dibujo, misma ropa y proporciones, cuerpo completo, ${descripcion}. Fondo transparente, sin texto.`);
+	form.append('background', 'transparent');
+	form.append('size', '1024x1536');
+	form.append('image[]', new Blob([fs.readFileSync(referencia)], {type: 'image/png'}), path.basename(referencia));
+	const res = await fetch('https://api.openai.com/v1/images/edits', {method: 'POST', headers: {authorization: `Bearer ${clave}`}, body: form});
+	if (!res.ok) throw new ErrorMorfeo(`OpenAI (poses) respondió ${res.status}: ${(await res.text()).slice(0, 300)}`);
+	const b64 = (await res.json()).data?.[0]?.b64_json;
+	if (!b64) throw new ErrorMorfeo('OpenAI no devolvió la pose.');
+	return Buffer.from(b64, 'base64');
+}
+
+/**
+ * Copia (o genera) las poses de cada personaje a public/assets/personajes/<nombre>/ y devuelve
+ * {nombre: {pose: 'personajes/nombre/pose.png'}} para que Remotion las encuentre.
+ */
+export async function prepararPersonajes(p, assetsPublico, log = console.log) {
+	const out = {};
+	for (const [nombre, def] of Object.entries(p.personajes ?? {})) {
+		const poses = def.poses ?? {};
+		const ref = def.referencia ? path.resolve(p.proyecto, def.referencia) : null;
+		if (ref && !fs.existsSync(ref)) throw new ErrorMorfeo(`Personaje ${nombre}: no existe la referencia ${def.referencia}`);
+		out[nombre] = {};
+		const dir = path.join(assetsPublico, 'personajes', nombre);
+		fs.mkdirSync(dir, {recursive: true});
+		for (const [pose, v] of Object.entries(poses)) {
+			let origen;
+			if (esArchivo(p.proyecto, v)) origen = path.resolve(p.proyecto, v);
+			else {
+				if (!ref) throw new ErrorMorfeo(`Personaje ${nombre}, pose "${pose}": "${v}" no es un archivo. Para generarla con IA agrega  referencia: './personaje.png'`);
+				const cache = path.join(p.trabajo, 'cache', 'personajes');
+				fs.mkdirSync(cache, {recursive: true});
+				origen = path.join(cache, `${huella([nombre, fs.statSync(ref).size, fs.statSync(ref).mtimeMs, v])}.png`);
+				if (!fs.existsSync(origen)) {
+					log(`    personaje ${nombre}: generando pose "${pose}"...`);
+					const fn = typeof p.imagenes?.proveedorPoses === 'function' ? p.imagenes.proveedorPoses : poseOpenAI;
+					const r = await fn(ref, String(v), p.imagenes ?? {});
+					if (typeof r === 'string') fs.copyFileSync(r, origen);
+					else fs.writeFileSync(origen, Buffer.from(r));
+				}
+			}
+			const ext = path.extname(origen).toLowerCase() || '.png';
+			fs.copyFileSync(origen, path.join(dir, `${pose}${ext}`));
+			out[nombre][pose] = `personajes/${nombre}/${pose}${ext}`;
+		}
+		if (!Object.keys(out[nombre]).length) throw new ErrorMorfeo(`Personaje ${nombre}: no tiene poses.`);
+	}
+	return out;
+}
+
+/** Pone en cada capa {tipo: 'personaje'} el mapa de sus poses (escenas y HUD). */
+export function ponerPoses(video, mapa) {
+	const recorrer = (x) => {
+		if (Array.isArray(x)) return x.map(recorrer);
+		if (!x || typeof x !== 'object') return x;
+		const o = {};
+		for (const [k, v] of Object.entries(x)) o[k] = recorrer(v);
+		if (o.tipo === 'personaje') {
+			const poses = mapa[o.nombre];
+			if (!poses) throw new ErrorMorfeo(`No existe el personaje "${o.nombre}". Defínelo en morfeo.config.mjs → personajes. Hay: ${Object.keys(mapa).join(', ') || 'ninguno'}`);
+			o.__poses = poses;
+		}
+		return o;
+	};
+	return {...video, scenes: recorrer(video.scenes), hud: recorrer(video.hud ?? [])};
+}

package/lib/render.mjs

@@ -0,0 +1,278 @@
+// Render: audio (Python) -> datos -> video (Remotion). También lista y Studio.
+import {spawn, spawnSync} from 'node:child_process';
+import crypto from 'node:crypto';
+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 {asegurarNavegador} from './navegador.mjs';
+import {generarImagenes} from './imagenes.mjs';
+import {ponerPoses, prepararPersonajes} from './personajes.mjs';
+import {sintetizarVoces} from './voces.mjs';
+import {transcribir, whisperListo} from './whisper.mjs';
+
+const require = createRequire(import.meta.url);
+
+/** Carga variables de <proyecto>/.env (sin pisar las que ya existen). */
+export function cargarEnv(proyecto) {
+	const f = path.join(proyecto, '.env');
+	if (!fs.existsSync(f)) return;
+	if (typeof process.loadEnvFile === 'function') {
+		const antes = {...process.env};
+		process.loadEnvFile(f);
+		for (const [k, v] of Object.entries(antes)) process.env[k] = v;
+		return;
+	}
+	for (const linea of fs.readFileSync(f, 'utf8').split(/\r?\n/)) {
+		const m = linea.match(/^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)\s*$/);
+		if (m && process.env[m[1]] == null) process.env[m[1]] = m[2].replace(/^(['"])(.*)\1$/, '$2');
+	}
+}
+
+const copiarCarpeta = (de, a) => {
+	for (const e of fs.readdirSync(de, {withFileTypes: true})) {
+		if (e.name.startsWith('.')) continue;
+		const o = path.join(de, e.name);
+		const d = path.join(a, e.name);
+		if (e.isDirectory()) copiarCarpeta(o, d);
+		else copiarSiCambia(o, d);
+	}
+};
+
+const copiarSiCambia = (de, a) => {
+	if (fs.existsSync(a) && fs.statSync(a).size === fs.statSync(de).size && fs.statSync(a).mtimeMs >= fs.statSync(de).mtimeMs) return;
+	fs.mkdirSync(path.dirname(a), {recursive: true});
+	fs.copyFileSync(de, a);
+};
+
+/**
+ * Huella del código de animación (tamaño y fecha de cada archivo de remotion/). Webpack trata
+ * node_modules como inmutable por versión: sin esto, un Morfeo actualizado podía usar un bundle viejo.
+ */
+function huellaMotor() {
+	const partes = [];
+	const recorrer = (dir) => {
+		for (const e of fs.readdirSync(dir, {withFileTypes: true}).sort((a, b) => a.name.localeCompare(b.name))) {
+			const p = path.join(dir, e.name);
+			if (e.isDirectory()) recorrer(p);
+			else {
+				const st = fs.statSync(p);
+				partes.push(`${e.name}:${st.size}:${Math.round(st.mtimeMs)}`);
+			}
+		}
+	};
+	recorrer(path.dirname(ENTRADA_REMOTION));
+	return crypto.createHash('sha1').update(partes.join('|')).digest('hex').slice(0, 16);
+}
+
+// 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()}`});
+
+/**
+ * Entrada de Remotion. Sin componentes propios es la del paquete; con ellos, Morfeo escribe
+ * .morfeo/entrada.tsx que los importa y los registra antes de arrancar.
+ */
+function entradaDe(p) {
+	const nombres = Object.keys(p.componentes);
+	if (!nombres.length) return ENTRADA_REMOTION;
+	const archivo = path.join(p.trabajo, 'entrada.tsx');
+	const rel = (abs) => {
+		const r = path.relative(p.trabajo, abs).split(path.sep).join('/');
+		return r.startsWith('.') ? r : `./${r}`;
+	};
+	const motor = (f) => rel(path.join(path.dirname(ENTRADA_REMOTION), f)).replace(/\.tsx?$/, '');
+	const codigo = [
+		'// Generado por morfeo: registra tus componentes y arranca la composición. No lo edites.',
+		"import {registerRoot} from 'remotion';",
+		`import {Root} from '${motor('Root.tsx')}';`,
+		`import {registrarComponentes} from '${motor('motor/registro.ts')}';`,
+		...nombres.map((n, i) => `import C${i} from '${rel(p.componentes[n]).replace(/\.tsx?$/, '')}';`),
+		`registrarComponentes({${nombres.map((n, i) => `${n}: C${i}`).join(', ')}});`,
+		'registerRoot(Root);',
+		'',
+	].join('\n');
+	fs.mkdirSync(p.trabajo, {recursive: true});
+	if (!fs.existsSync(archivo) || fs.readFileSync(archivo, 'utf8') !== codigo) fs.writeFileSync(archivo, codigo);
+	return archivo;
+}
+
+/** Arma la carpeta public que ve Remotion: fuentes del paquete + logo de la marca + audios generados. */
+function prepararPublico(p) {
+	const publico = path.join(p.trabajo, 'public');
+	for (const f of fs.readdirSync(FUENTES)) copiarSiCambia(path.join(FUENTES, f), path.join(publico, 'fuentes', f));
+	let logo = null;
+	if (p.marca.logo) {
+		logo = `marca/logo${path.extname(p.marca.logo).toLowerCase()}`;
+		copiarSiCambia(p.marca.logo, path.join(publico, logo));
+	}
+	// assets/ del proyecto (imágenes, videos, modelos) -> public/assets
+	if (fs.existsSync(p.assets)) copiarCarpeta(p.assets, path.join(publico, 'assets'));
+	// fuentes propias -> public/fuentes-proyecto
+	const fuentes = p.fuentes.map(({familia, archivo}) => {
+		const url = `fuentes-proyecto/${path.basename(archivo)}`;
+		copiarSiCambia(archivo, path.join(publico, url));
+		return {familia, url};
+	});
+	const ignorar = path.join(p.trabajo, '.gitignore');
+	if (!fs.existsSync(ignorar)) fs.writeFileSync(ignorar, '*\n');
+	return {publico, marca: {...p.marca, logo, cta: undefined}, extras: {fuentes, estilos: p.estilos}};
+}
+
+const datosDe = (publico, id) => {
+	const f = path.join(publico, 'v', id, 'datos.json');
+	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))}));
+}
+
+/** Corre python/preparar.py con el trabajo indicado; su salida va directo a la terminal. */
+function python(trabajo) {
+	const r = spawnSync(pythonVenv(), [path.join(PY_DIR, 'preparar.py'), trabajo], {
+		stdio: 'inherit',
+		env: {...process.env, PYTHONUTF8: '1', PYTHONIOENCODING: 'utf-8'},
+	});
+	if (r.status !== 0) throw new ErrorMorfeo(`Falló la preparación del audio (código ${r.status}). Revisa el mensaje de arriba.`);
+}
+
+/**
+ * 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} = {}) {
+	cargarEnv(proyecto);
+	const p = _p ?? (await cargarProyecto(proyecto));
+	if (!venvListo() || !modelosListos()) throw new ErrorMorfeo('Falta preparar tu computadora. Corre una vez:  npx morfeo instalar');
+	const {publico, marca, extras} = prepararPublico(p);
+	const todos = Object.keys(p.videos);
+	const conWhisper = whisperListo();
+	const datos = {};
+	const poses = await prepararPersonajes(p, path.join(publico, 'assets'), log);
+	const trabajos = path.join(p.trabajo, 'trabajos');
+	fs.mkdirSync(trabajos, {recursive: true});
+	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...`);
+		const conImagenes = await generarImagenes(ponerPoses(original, poses), p.imagenes, path.join(p.trabajo, 'cache', 'imagenes'), path.join(publico, 'assets'), 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'))) {
+			log('    whisper...');
+			await transcribir(path.join(publico, 'v', id), (video.lang ?? 'es').slice(0, 2));
+		}
+		fs.writeFileSync(job, JSON.stringify(base));
+		python(job);
+		datos[id] = datosDe(publico, id);
+	}
+	return {p, publico, marca, extras, datos};
+}
+
+/**
+ * Genera los videos. Sin ids: los que aún no existen en la carpeta de salida.
+ * @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} = {}) {
+	cargarEnv(proyecto);
+	const p = await cargarProyecto(proyecto);
+	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`);
+	if (!lista.length) {
+		log('No hay videos pendientes. Para regenerar: npx morfeo render --todos  (o npx morfeo render <id>)');
+		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});
+
+	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));
+	const hechos = [];
+	for (const [i, id] of lista.entries()) {
+		const t = Date.now();
+		const inputProps = {videos: {[id]: datos[id]}, marca, ...extras};
+		const composition = await selectComposition({serveUrl, id, inputProps, browserExecutable, chromiumOptions});
+		let ultimo = -1;
+		const mp4 = salidaDe(p, id);
+		await renderMedia({
+			serveUrl,
+			composition,
+			inputProps,
+			browserExecutable,
+			chromiumOptions,
+			codec: 'h264',
+			crf: p.render.crf,
+			audioBitrate: '192k',
+			imageFormat: 'jpeg',
+			jpegQuality: 92,
+			concurrency: p.render.concurrencia,
+			outputLocation: mp4,
+			onProgress: ({progress}) => {
+				alProgreso?.(id, progress);
+				const n = Math.floor(progress * 10);
+				if (n !== ultimo && process.stdout.isTTY) process.stdout.write(`\r[${i + 1}/${lista.length}] ${id}: video ${n * 10}%   `);
+				ultimo = n;
+			},
+		});
+		let jpg = null;
+		if (p.render.miniatura) {
+			// miniatura: el gancho ya completo
+			jpg = path.join(p.salida, `${id}.jpg`);
+			await renderStill({serveUrl, composition, inputProps, browserExecutable, chromiumOptions, frame: Math.min(36, composition.durationInFrames - 1), 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}/${lista.length}] ${id}: listo en ${segundos} s  →  ${path.relative(p.proyecto, mp4)}      `);
+		hechos.push({id, mp4, jpg, segundos});
+	}
+	escribirResumen(p);
+	return hechos;
+}
+
+/** <salida>/resumen.json: título, archivo y duración de cada video hecho (útil para publicar). */
+function escribirResumen(p) {
+	const publico = path.join(p.trabajo, 'public');
+	const filas = Object.entries(p.videos)
+		.filter(([id]) => fs.existsSync(salidaDe(p, id)))
+		.map(([id, v]) => ({id, titulo: v.title ?? id, archivo: `${id}.mp4`, duracion: datosDe(publico, id)?.duracion ?? null, ...(v.meta ? {meta: v.meta} : {})}));
+	fs.writeFileSync(path.join(p.salida, 'resumen.json'), JSON.stringify(filas, null, '\t') + '\n');
+}
+
+/** Abre Remotion Studio con los videos ya preparados (para verlos y ajustar en vivo). */
+export async function studio({proyecto = process.cwd(), puerto} = {}) {
+	cargarEnv(proyecto);
+	const p = await cargarProyecto(proyecto);
+	const {publico, marca, extras} = prepararPublico(p);
+	const videos = {};
+	for (const id of Object.keys(p.videos)) {
+		const d = datosDe(publico, id);
+		if (d) videos[id] = d;
+	}
+	if (!Object.keys(videos).length) console.log('Todavía no hay videos preparados. Corre primero:  npx morfeo render');
+	const props = path.join(p.trabajo, 'studio-props.json');
+	fs.writeFileSync(props, JSON.stringify({videos, marca, ...extras}));
+	const cli = path.join(path.dirname(require.resolve('@remotion/cli/package.json')), 'remotion-cli.js');
+	const navegador = p.render.navegador ?? (await asegurarNavegador());
+	const args = [cli, 'studio', entradaDe(p), `--public-dir=${publico}`, `--props=${props}`, `--gl=${p.render.gl}`, `--browser-executable=${navegador}`];
+	if (puerto) args.push(`--port=${puerto}`);
+	const hijo = spawn(process.execPath, args, {stdio: 'inherit', cwd: p.proyecto});
+	await new Promise((r) => hijo.on('exit', r));
+}
+

package/lib/voces.mjs

@@ -0,0 +1,122 @@
+// Voces por servicio externo (ElevenLabs, OpenAI o una función tuya).
+// Cada frase se sintetiza una sola vez: el audio queda en .morfeo/cache/voces/<huella>.<ext>
+// y si el texto, la voz y las opciones no cambian, no se vuelve a pedir (ni a cobrar).
+// Las claves se leen del entorno (.env del proyecto), nunca del código.
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import {ErrorMorfeo} from './config.mjs';
+
+const huella = (obj) => crypto.createHash('sha1').update(JSON.stringify(obj)).digest('hex').slice(0, 20);
+
+const clave = (nombre, opciones) => {
+	const v = opciones.apiKey ?? process.env[nombre];
+	if (!v) throw new ErrorMorfeo(`Falta ${nombre}. Ponla en el archivo .env de tu proyecto:  ${nombre}=...`);
+	return v;
+};
+
+async function pedir(url, init, servicio) {
+	let res;
+	try {
+		res = await fetch(url, init);
+	} catch (e) {
+		throw new ErrorMorfeo(`No pude conectar con ${servicio}: ${e.message}`);
+	}
+	if (!res.ok) {
+		let detalle = '';
+		try {
+			detalle = (await res.text()).slice(0, 300);
+		} catch {}
+		const pista = res.status === 401 ? ' (revisa tu clave)' : res.status === 429 ? ' (límite o saldo agotado)' : '';
+		throw new ErrorMorfeo(`${servicio} respondió ${res.status}${pista}: ${detalle}`);
+	}
+	return Buffer.from(await res.arrayBuffer());
+}
+
+const PROVEEDORES = {
+	// https://elevenlabs.io/docs/api-reference/text-to-speech/convert
+	async elevenlabs(texto, o) {
+		const voz = o.voz ?? o.voice ?? o.voiceId;
+		if (!voz) throw new ErrorMorfeo('ElevenLabs: falta `voz` (el voice_id de tu voz en ElevenLabs)');
+		const datos = await pedir(
+			`https://api.elevenlabs.io/v1/text-to-speech/${encodeURIComponent(voz)}?output_format=mp3_44100_128`,
+			{
+				method: 'POST',
+				headers: {'xi-api-key': clave('ELEVENLABS_API_KEY', o), 'content-type': 'application/json', accept: 'audio/mpeg'},
+				body: JSON.stringify({
+					text: texto,
+					model_id: o.modelo ?? o.model ?? 'eleven_multilingual_v2',
+					...(o.idioma ? {language_code: o.idioma} : {}),
+					...(o.ajustes ? {voice_settings: o.ajustes} : {}),
+				}),
+			},
+			'ElevenLabs',
+		);
+		return {datos, ext: 'mp3'};
+	},
+	// https://platform.openai.com/docs/api-reference/audio/createSpeech
+	async openai(texto, o) {
+		const datos = await pedir(
+			'https://api.openai.com/v1/audio/speech',
+			{
+				method: 'POST',
+				headers: {authorization: `Bearer ${clave('OPENAI_API_KEY', o)}`, 'content-type': 'application/json'},
+				body: JSON.stringify({
+					model: o.modelo ?? o.model ?? 'gpt-4o-mini-tts',
+					voice: o.voz ?? o.voice ?? 'alloy',
+					input: texto,
+					response_format: 'wav',
+					...(o.instrucciones ? {instructions: o.instrucciones} : {}),
+					...(o.velocidad ? {speed: o.velocidad} : {}),
+				}),
+			},
+			'OpenAI',
+		);
+		return {datos, ext: 'wav'};
+	},
+};
+
+/** Normaliza lo que devuelve una función de voz propia: ruta de archivo, Buffer, o {datos, ext}. */
+function resultadoPropio(r) {
+	if (typeof r === 'string') {
+		if (!fs.existsSync(r)) throw new ErrorMorfeo(`Tu función de voz devolvió una ruta que no existe: ${r}`);
+		return {datos: fs.readFileSync(r), ext: path.extname(r).slice(1) || 'wav'};
+	}
+	if (Buffer.isBuffer(r) || r instanceof Uint8Array) return {datos: Buffer.from(r), ext: 'wav'};
+	if (r && (Buffer.isBuffer(r.datos) || r.datos instanceof Uint8Array)) return {datos: Buffer.from(r.datos), ext: r.ext ?? 'wav'};
+	throw new ErrorMorfeo('Tu función de voz debe devolver una ruta de archivo, un Buffer, o {datos: Buffer, ext: "mp3"}');
+}
+
+/**
+ * Si el video usa un proveedor externo, sintetiza cada escena sin `audio` y le pone su grabación.
+ * Devuelve una copia del video lista para preparar.py (voice: null cuando ya todo trae audio).
+ */
+export async function sintetizarVoces(id, video, cacheDir, log = console.log) {
+	const voz = video.voice;
+	if (!voz || Array.isArray(voz)) return video;
+	const {proveedor, ...opciones} = voz;
+	const fn = typeof proveedor === 'function' ? async (t, o) => resultadoPropio(await proveedor(t, o)) : PROVEEDORES[proveedor];
+	fs.mkdirSync(cacheDir, {recursive: true});
+	const nombre = typeof proveedor === 'function' ? proveedor.name || 'propia' : proveedor;
+	const {apiKey, ...publicas} = opciones; // la clave no entra en la huella del caché
+	let nuevas = 0;
+	const scenes = [];
+	for (const sc of video.scenes) {
+		if (sc.audio) {
+			scenes.push(sc);
+			continue;
+		}
+		const h = huella([nombre, publicas, sc.say]);
+		const previo = fs.readdirSync(cacheDir).find((f) => f.startsWith(h + '.'));
+		let archivo = previo && path.join(cacheDir, previo);
+		if (!archivo) {
+			const {datos, ext} = await fn(sc.say, publicas.apiKey ? opciones : {...publicas, apiKey});
+			archivo = path.join(cacheDir, `${h}.${ext}`);
+			fs.writeFileSync(archivo, datos);
+			nuevas++;
+		}
+		scenes.push({...sc, audio: archivo});
+	}
+	if (nuevas) log(`    voz ${nombre}: ${nuevas} frase(s) nuevas`);
+	return {...video, voice: null, scenes};
+}

package/lib/whisper.mjs

@@ -0,0 +1,45 @@
+// Whisper (opcional): tiempos reales de cada palabra para los subtítulos.
+import {downloadWhisperModel, installWhisperCpp, toCaptions, transcribe} from '@remotion/install-whisper-cpp';
+import {execFileSync} from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+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'));
+
+export async function instalarWhisper() {
+	await installWhisperCpp({to: WHISPER, version: VERSION_CPP, printOutput: true});
+	await downloadWhisperModel({model: MODELO_WHISPER, folder: WHISPER, printOutput: true});
+	fs.writeFileSync(path.join(WHISPER, '.listo'), VERSION_CPP);
+}
+
+/** Transcribe <dir>/voz.wav y escribe <dir>/whisper.json (palabras con tiempos). */
+export async function transcribir(dir, idioma = 'es') {
+	const wav16 = path.join(dir, 'voz16k.wav');
+	// whisper.cpp pide WAV 16 kHz mono 16 bits: lo convierte el Python del entorno (ya trae scipy y soundfile)
+	execFileSync(
+		pythonVenv(),
+		[
+			'-c',
+			'import sys,soundfile as sf;from scipy.signal import resample_poly;x,sr=sf.read(sys.argv[1]);x=x.mean(1) if x.ndim>1 else x;sf.write(sys.argv[2],resample_poly(x,16000,sr),16000,subtype="PCM_16")',
+			path.join(dir, 'voz.wav'),
+			wav16,
+		],
+		{stdio: 'inherit'},
+	);
+	const res = await transcribe({
+		inputPath: wav16,
+		whisperPath: WHISPER,
+		whisperCppVersion: VERSION_CPP,
+		model: MODELO_WHISPER,
+		language: idioma,
+		tokenLevelTimestamps: true,
+		printOutput: false,
+	});
+	const {captions} = toCaptions({whisperCppOutput: res});
+	fs.writeFileSync(path.join(dir, 'whisper.json'), JSON.stringify(captions.map(({text, startMs, endMs}) => ({text, startMs, endMs}))));
+	fs.rmSync(wav16, {force: true});
+}