morfeo 0.0.0-stage → 0.1.1

package/lib/guion.mjs

@@ -0,0 +1,313 @@
+// Guiones: de un tema (la IA escribe todo) o de tu propio texto (la IA lo convierte en escenas,
+// o sin IA: una escena por frase). El resultado es un video listo para editar en videos/<id>.json.
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import {ErrorMorfeo, MUSICAS} from './config.mjs';
+
+export const MODELO_GUION = 'claude-opus-5-5';
+export const TIPOS_IA = ['title', 'year', 'text', 'icon', 'compare', 'card', 'dialog'];
+export const ICONOS = [
+	'question', 'warning', 'building', 'star', 'alien', 'cloud', 'joystick', 'eye', 'tblock', 'car', 'fist', 'book', 'computer', 'cards',
+	'coin', 'truck', 'skull', 'box', 'fog', 'pickaxe', 'zap', 'phone', 'camera', 'mustache', 'cap', 'people', 'sword', 'trophy',
+];
+const COLORES = {blanco: '#FFFFFF', amarillo: '#FFD400', rojo: '#FF4050', verde: '#5ADC6E', cian: '#50DCFF'};
+
+/** id corto para el archivo: sin acentos, en minúsculas, hasta ~38 letras y sin cortar palabras. */
+export const slug = (s) => {
+	const base = s
+		.normalize('NFD')
+		.replace(/[\u0300-\u036f]/g, '')
+		.toLowerCase()
+		.replace(/[^a-z0-9]+/g, '-')
+		.replace(/^-+|-+$/g, '');
+	if (base.length <= 38) return base || 'video';
+	const corto = base.slice(0, 39);
+	return corto.slice(0, Math.max(corto.lastIndexOf('-'), 12)).replace(/-+$/, '') || 'video';
+};
+
+const INSTRUCCIONES = `Eres guionista de videos cortos verticales (YouTube Shorts / TikTok / Reels) de 25 a 45 segundos.
+Escribes en el idioma que se te pida, con frases cortas, naturales y fáciles de decir en voz alta.
+
+Un video es una lista de escenas. Cada escena tiene "say": lo que dice la voz (una o dos frases cortas).
+Los números y años en "say" van ESCRITOS CON LETRAS ("mil novecientos ochenta") para que la voz los lea bien;
+en ese caso pon en "show" la misma frase con cifras ("1980") para el subtítulo. Si no hay números, "show" es null.
+
+Tipos de escena (elige el que mejor ilustre cada frase y varíalos):
+- title: el gancho, SIEMPRE la primera. "rows": 2-3 filas de texto grande; la última es el remate (color amarillo o rojo). "icon": un ícono.
+- year: una fecha clave. "pre": contexto corto (p. ej. "JAPÓN"), "year": el año como número, "sub": qué pasó (2-3 palabras).
+- text: 1-3 filas de texto grande con la idea clave.
+- icon: un ícono grande con "label" (2-3 palabras) y "color".
+- compare: antes/después o A vs B. "a" y "b": {text, color}. "at": UNA palabra de "say" en la que aparece "b".
+- card: tarjeta tipo código donde un valor cambia. "file" (p. ej. "datos.txt"), "label" (comentario corto),
+  "card_rows": 1-2 filas {etiqueta: "ventas = ", antes: "100", despues: "0"}, "at": palabra de "say" en la que cambia, "flash": exclamación corta.
+- dialog: ventana con pregunta. "q": dos líneas de pregunta, "click": palabra de "say" en la que se pulsa, "result": resultado corto.
+
+Reglas de texto en pantalla: MAYÚSCULAS, máximo 14 letras por fila, tamaños ("size") entre 110 y 260 (más corto = más grande).
+Colores disponibles: blanco, amarillo, rojo, verde, cian. Usa blanco para lo normal y un color para lo importante.
+"at" y "click" deben ser palabras que aparezcan tal cual en "say".
+No incluyas la escena final de "sígueme": morfeo la agrega sola.`;
+
+/** Esquema plano (todas las claves presentes, null cuando no aplican) para la salida estructurada. */
+export async function esquema() {
+	let z;
+	try {
+		({z} = await import('zod'));
+	} catch {
+		throw new ErrorMorfeo('Falta la dependencia zod (npm install zod)');
+	}
+	const color = z.enum(Object.keys(COLORES));
+	const fila = z.object({text: z.string(), color, size: z.number()});
+	const escena = z.object({
+		type: z.enum(TIPOS_IA),
+		say: z.string(),
+		show: z.string().nullable(),
+		rows: z.array(fila).nullable(),
+		icon: z.enum(ICONOS).nullable(),
+		label: z.string().nullable(),
+		color: color.nullable(),
+		pre: z.string().nullable(),
+		year: z.number().nullable(),
+		sub: z.string().nullable(),
+		a: z.object({text: z.string(), color}).nullable(),
+		b: z.object({text: z.string(), color}).nullable(),
+		at: z.string().nullable(),
+		file: z.string().nullable(),
+		card_rows: z.array(z.object({etiqueta: z.string(), antes: z.string(), despues: z.string()})).nullable(),
+		flash: z.string().nullable(),
+		q: z.array(z.string()).nullable(),
+		click: z.string().nullable(),
+		result: z.string().nullable(),
+	});
+	return z.object({
+		id: z.string(),
+		title: z.string(),
+		music: z.enum(MUSICAS),
+		scenes: z.array(escena),
+	});
+}
+
+const ESTILOS_MOTOR = ['explicativo', 'documental', 'ilustrado', 'historia', 'mesa', 'minimal'];
+
+const INSTRUCCIONES_MOTOR = `Eres guionista y director de arte de videos cortos verticales (YouTube Shorts / TikTok / Reels) de 25 a 60 segundos.
+Escribes en el idioma que se te pida, con frases cortas y naturales para decir en voz alta.
+Los subtítulos ya salen solos arriba: en pantalla pon solo lo que ILUSTRA la frase, no la repitas.
+
+Cada escena tiene "say" (lo que dice la voz). Números y años en "say" van CON LETRAS; en ese caso "show" lleva la frase con cifras.
+Tipos de escena:
+- titular: un titular corto en "texto" (marca la palabra clave con *asteriscos*), con "etiqueta" opcional tipo "// paso 1" y "numero" opcional.
+- dato: un número que cuenta hasta "valor" (con "prefijo"/"sufijo", p. ej. sufijo " m"), "texto" corto debajo. "curva": "exponencial" si crece muchísimo.
+- lista: tarjeta con "titulo" y 2-4 "items"; cada item se palomea cuando la voz dice su palabra "check".
+- comparar: "a" contra "b" (textos cortos); "at" es la palabra de "say" en la que aparece "b".
+- capas: una ilustración. Usa "emoji" (un emoji grande que represente la idea) o, si se pide arte, "imagen_ia" (descripción breve de UN objeto o personaje aislado),
+  más un "chip" opcional (dato corto como "×5" o "230 dB") que aparece en la palabra "en".
+- eleccion: final abierto para que el público comente: "pregunta" y 2 "opciones" ({texto, sub, emoji}). Úsala al final en series o historias.
+Varía los tipos. "at", "check" y "en" deben ser palabras que aparezcan tal cual en "say".
+No incluyas la escena final de "sígueme": morfeo la agrega sola.`;
+
+export async function esquemaMotor() {
+	const {z} = await import('zod');
+	const escena = z.object({
+		type: z.enum(['titular', 'dato', 'lista', 'comparar', 'capas', 'eleccion']),
+		say: z.string(),
+		show: z.string().nullable(),
+		texto: z.string().nullable(),
+		etiqueta: z.string().nullable(),
+		numero: z.number().nullable(),
+		valor: z.number().nullable(),
+		prefijo: z.string().nullable(),
+		sufijo: z.string().nullable(),
+		curva: z.enum(['suave', 'exponencial']).nullable(),
+		titulo: z.string().nullable(),
+		items: z.array(z.object({texto: z.string(), check: z.string()})).nullable(),
+		a: z.string().nullable(),
+		b: z.string().nullable(),
+		at: z.string().nullable(),
+		emoji: z.string().nullable(),
+		imagen_ia: z.string().nullable(),
+		chip: z.string().nullable(),
+		en: z.string().nullable(),
+		pregunta: z.string().nullable(),
+		opciones: z.array(z.object({texto: z.string(), sub: z.string(), emoji: z.string()})).nullable(),
+	});
+	return z.object({id: z.string(), title: z.string(), music: z.enum(MUSICAS), scenes: z.array(escena)});
+}
+
+/** De la salida de la IA (motor de capas) al formato de escenas de morfeo. */
+function aEscenaMotor(e, conImagenes) {
+	const out = {type: e.type, say: e.say};
+	if (e.show && e.show !== e.say) out.show = e.show;
+	const si = (k, v) => v != null && v !== '' && (out[k] = v);
+	switch (e.type) {
+		case 'titular':
+			si('texto', e.texto ?? '');
+			si('etiqueta', e.etiqueta);
+			si('numero', e.numero);
+			break;
+		case 'dato':
+			Object.assign(out, {valor: e.valor ?? 0});
+			si('prefijo', e.prefijo);
+			si('sufijo', e.sufijo);
+			si('texto', e.texto);
+			if (e.curva === 'exponencial') out.curva = 'exponencial';
+			break;
+		case 'lista':
+			si('titulo', e.titulo);
+			out.items = (e.items ?? []).map((it) => ({texto: it.texto, check: it.check}));
+			break;
+		case 'comparar':
+			Object.assign(out, {a: e.a ?? '', b: e.b ?? '', at: e.at ?? e.say.split(/\s+/).at(-1)});
+			break;
+		case 'eleccion':
+			si('pregunta', e.pregunta);
+			out.opciones = (e.opciones ?? []).slice(0, 3);
+			break;
+		case 'capas': {
+			const capas = [];
+			if (e.imagen_ia && conImagenes) capas.push({tipo: 'imagen', generar: e.imagen_ia, ancho: 640, x: 540, y: 1000, entrada: 'escala', flotar: true});
+			else capas.push({tipo: 'emoji', texto: e.emoji || '✨', tam: 420, x: 540, y: 1000, entrada: 'rebote', flotar: 16});
+			if (e.chip) capas.push({tipo: 'chip', texto: e.chip, x: 760, y: 1280, en: e.en ?? 'fin-0.5', entrada: 'rebote', sonido: 'pop'});
+			out.capas = capas;
+			break;
+		}
+	}
+	return out;
+}
+
+/** De la salida plana de la IA al formato de escenas de morfeo. */
+function aEscena(e) {
+	const c = (x) => COLORES[x] ?? x;
+	const out = {type: e.type, say: e.say};
+	if (e.show && e.show !== e.say) out.show = e.show;
+	switch (e.type) {
+		case 'title':
+		case 'text':
+			out.rows = (e.rows ?? []).map((r) => [r.text, c(r.color), Math.round(r.size)]);
+			if (e.type === 'title') out.icon = e.icon ?? 'question';
+			break;
+		case 'year':
+			Object.assign(out, {pre: e.pre ?? '', year: e.year ?? 2000, sub: e.sub ?? ''});
+			break;
+		case 'icon':
+			Object.assign(out, {icon: e.icon ?? 'star', label: e.label ?? '', color: c(e.color ?? 'amarillo')});
+			break;
+		case 'compare': {
+			const a = e.a ?? {text: '', color: 'blanco'};
+			const b = e.b ?? {text: '', color: 'amarillo'};
+			const tam = (t) => Math.max(110, Math.min(320, Math.round(1100 / Math.max(3, t.length))));
+			Object.assign(out, {a: [a.text, c(a.color)], b: [b.text, c(b.color)], at: e.at ?? e.say.split(/\s+/).at(-1), sizes: [tam(a.text), tam(b.text)]});
+			break;
+		}
+		case 'card':
+			Object.assign(out, {
+				file: e.file ?? 'datos.txt',
+				rows: [['// ' + (e.label ?? 'cambio'), null, null], ...(e.card_rows ?? []).map((r) => [r.etiqueta, r.antes, r.despues])],
+				at: e.at ?? e.say.split(/\s+/)[0],
+				flash: e.flash ?? '¡CAMBIO!',
+			});
+			break;
+		case 'dialog':
+			Object.assign(out, {q: (e.q ?? ['¿Seguro?', '']).slice(0, 2), click: e.click ?? e.say.split(/\s+/).at(-1), result: e.result ?? '¡LISTO!'});
+			break;
+	}
+	return out;
+}
+
+/**
+ * Pide a Claude un video completo.
+ * @param {{tema?: string, texto?: string, idioma?: string, duracion?: number, tono?: string, estilo?: string, imagenes?: boolean, voz?: any, modelo?: string}} o
+ *   estilo: 'datos-curiosos' (clásico) o uno del motor de capas · imagenes: true = pedir ilustraciones con IA
+ */
+export async function guionConIA(o) {
+	const perfil = fs.existsSync(path.join(os.homedir(), '.config', 'anthropic')) || process.env.ANTHROPIC_PROFILE;
+	if (!process.env.ANTHROPIC_API_KEY && !process.env.ANTHROPIC_AUTH_TOKEN && !perfil)
+		throw new ErrorMorfeo('Para generar guiones con IA pon tu clave en el .env del proyecto:  ANTHROPIC_API_KEY=...\n(Sin IA puedes convertir tu texto con:  npx morfeo guion --desde guion.txt --sin-ia)');
+	let Anthropic, zodOutputFormat;
+	try {
+		({default: Anthropic} = await import('@anthropic-ai/sdk'));
+		({zodOutputFormat} = await import('@anthropic-ai/sdk/helpers/zod'));
+	} catch {
+		throw new ErrorMorfeo('Falta la dependencia @anthropic-ai/sdk (npm install @anthropic-ai/sdk zod)');
+	}
+	const client = new Anthropic();
+	const idioma = o.idioma ?? 'español de México';
+	const pedido = o.texto
+		? `Convierte este guion en escenas. Respeta su contenido y su orden; puedes partir frases largas.\n\n<guion>\n${o.texto}\n</guion>`
+		: `Escribe un video sobre: ${o.tema}`;
+	const extra = [`Idioma: ${idioma}.`, `Duración aproximada: ${o.duracion ?? 35} segundos (unas ${Math.round((o.duracion ?? 35) / 4.5)} escenas).`];
+	if (o.tono) extra.push(`Tono: ${o.tono}.`);
+	const motor = o.estilo && o.estilo !== 'datos-curiosos';
+	if (motor) extra.push(`Estilo visual: ${o.estilo}.${o.imagenes ? ' Se pueden generar ilustraciones (usa imagen_ia en las escenas capas).' : ' No hay ilustraciones: usa emoji en las escenas capas.'}`);
+
+	let res;
+	try {
+		res = await client.messages.parse({
+			model: o.modelo ?? MODELO_GUION,
+			max_tokens: 16000,
+			system: motor ? INSTRUCCIONES_MOTOR : INSTRUCCIONES,
+			messages: [{role: 'user', content: `${pedido}\n\n${extra.join('\n')}\nEn "id" pon un identificador corto en minúsculas sin espacios. En "title" el título para publicar (con un emoji). En "music" el estilo de música que mejor le quede.`}],
+			output_config: {format: zodOutputFormat(motor ? await esquemaMotor() : await esquema())},
+		});
+	} catch (e) {
+		if (e instanceof Anthropic.AuthenticationError) throw new ErrorMorfeo('Tu ANTHROPIC_API_KEY no es válida.');
+		if (e instanceof Anthropic.RateLimitError) throw new ErrorMorfeo('Claude: límite de uso alcanzado, intenta en un momento.');
+		if (e instanceof Anthropic.APIError) throw new ErrorMorfeo(`Claude respondió ${e.status}: ${e.message}`);
+		throw e;
+	}
+	if (res.stop_reason === 'refusal') throw new ErrorMorfeo(`Claude no quiso escribir ese guion${res.stop_details?.explanation ? `: ${res.stop_details.explanation}` : ''}.`);
+	if (res.stop_reason === 'max_tokens') throw new ErrorMorfeo('El guion salió demasiado largo; pide una duración menor.');
+	const g = res.parsed_output;
+	if (!g) throw new ErrorMorfeo('Claude no devolvió un guion válido; intenta otra vez.');
+	if (motor) {
+		const scenes = g.scenes.map((e) => aEscenaMotor(e, !!o.imagenes));
+		return {id: slug(g.id || g.title), video: {estilo: o.estilo, title: g.title, voice: o.voz ?? 'em_alex', music: g.music, scenes: [...scenes, {type: 'cta'}]}};
+	}
+	const scenes = g.scenes.map(aEscena);
+	if (scenes[0]?.type !== 'title') scenes.unshift({type: 'title', say: scenes[0]?.say ?? g.title, rows: [[g.title.toUpperCase().slice(0, 14), '#FFD400', 200]], icon: 'question'});
+	return {id: slug(g.id || g.title), video: {title: g.title, voice: o.voz ?? 'em_alex', music: g.music, scenes: [...scenes, {type: 'cta'}]}};
+}
+
+/** Sin IA: una escena "text" por frase (o por línea), con la frase en pantalla partida en filas cortas. */
+export function guionSinIA(texto, o = {}) {
+	const frases = texto
+		.replace(/\r/g, '')
+		.split(/\n+|(?<=[.!?¿¡])\s+(?=[A-ZÁÉÍÓÚÑ¿¡])/)
+		.map((f) => f.trim())
+		.filter(Boolean);
+	if (!frases.length) throw new ErrorMorfeo('El guion está vacío.');
+	const filas = (f) => {
+		const palabras = f.replace(/[¿?¡!.,;:]/g, '').toUpperCase().split(/\s+/).filter(Boolean);
+		const out = [];
+		let cur = '';
+		for (const p of palabras) {
+			if (cur && (cur + ' ' + p).length > 12) {
+				out.push(cur);
+				cur = p;
+			} else cur = cur ? `${cur} ${p}` : p;
+		}
+		if (cur) out.push(cur);
+		const elegidas = out.slice(0, 3);
+		return elegidas.map((t, i) => [t, i === elegidas.length - 1 ? '#FFD400' : '#FFFFFF', Math.max(110, Math.min(220, Math.round(1500 / Math.max(6, t.length))))]);
+	};
+	const titulo = o.titulo ?? frases[0].slice(0, 60);
+	const motor = o.estilo && o.estilo !== 'datos-curiosos';
+	const scenes = motor
+		? frases.map((f) => {
+				// titular corto: las palabras más largas de la frase, la última resaltada
+				const palabras = f.replace(/[¿?¡!.,;:]/g, '').split(/\s+/).filter((w) => w.length > 3).slice(0, 3);
+				const txt = palabras.map((w, i) => (i === palabras.length - 1 ? `*${w}*` : w)).join(' ');
+				return {type: 'titular', say: f, texto: txt || f.slice(0, 24), y: 900};
+			})
+		: frases.map((f, i) => ({type: i === 0 ? 'title' : 'text', say: f, rows: filas(f), ...(i === 0 ? {icon: 'question'} : {})}));
+	return {id: slug(o.id ?? titulo), video: {...(motor ? {estilo: o.estilo} : {}), title: titulo, voice: o.voz ?? 'em_alex', music: o.musica ?? 'lofi', scenes: [...scenes, {type: 'cta'}]}};
+}
+
+/** Guarda el video en <carpeta>/<id>.json sin pisar uno existente (agrega -2, -3...). */
+export function guardarVideo(carpeta, id, video) {
+	fs.mkdirSync(carpeta, {recursive: true});
+	let final = id;
+	for (let n = 2; fs.existsSync(path.join(carpeta, `${final}.json`)); n++) final = `${id}-${n}`;
+	const archivo = path.join(carpeta, `${final}.json`);
+	fs.writeFileSync(archivo, JSON.stringify(video, null, '\t') + '\n');
+	return {id: final, archivo};
+}

package/lib/imagenes.mjs

@@ -0,0 +1,99 @@
+// Imágenes generadas con IA para las capas. Cualquier capa o fondo de imagen puede pedir
+//   {tipo: 'imagen', generar: 'un oso pardo de frente, ilustración plana'}
+// y Morfeo la genera una sola vez (caché en .morfeo/cache/imagenes) y la pone en assets/ia/.
+// Configuración (morfeo.config.mjs):
+//   imagenes: {proveedor: 'openai' | async (prompt, opciones) => ruta | Buffer, estilo: 'ilustración plana, colores cálidos', modelo}
+// `estilo` se agrega a cada pedido para que todas las imágenes del canal se vean iguales.
+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);
+
+async function openai(prompt, o) {
+	const clave = o.apiKey ?? process.env.OPENAI_API_KEY;
+	if (!clave) throw new ErrorMorfeo('Para generar imágenes pon OPENAI_API_KEY en el .env de tu proyecto (o usa tus propias imágenes en assets/).');
+	let res;
+	try {
+		res = await fetch('https://api.openai.com/v1/images/generations', {
+			method: 'POST',
+			headers: {authorization: `Bearer ${clave}`, 'content-type': 'application/json'},
+			body: JSON.stringify({
+				model: o.modelo ?? 'gpt-image-1',
+				prompt,
+				size: o.fondo ? '1024x1536' : o.tamano ?? '1024x1024',
+				background: o.fondo ? 'opaque' : 'transparent',
+				output_format: 'png',
+				quality: o.calidad ?? 'medium',
+			}),
+		});
+	} catch (e) {
+		throw new ErrorMorfeo(`No pude conectar con OpenAI: ${e.message}`);
+	}
+	if (!res.ok) throw new ErrorMorfeo(`OpenAI (imágenes) respondió ${res.status}: ${(await res.text()).slice(0, 300)}`);
+	const j = await res.json();
+	const b64 = j.data?.[0]?.b64_json;
+	if (!b64) throw new ErrorMorfeo('OpenAI no devolvió la imagen.');
+	return Buffer.from(b64, 'base64');
+}
+
+/** Recorre la escena y cambia cada {generar: '...'} por la ruta de la imagen generada. */
+export async function generarImagenes(video, cfgImagenes, cacheDir, assetsDir, log = console.log) {
+	const pendientes = [];
+	const recorrer = (x, esFondo = false) => {
+		if (Array.isArray(x)) return x.map((v) => recorrer(v));
+		if (!x || typeof x !== 'object') return x;
+		const out = {};
+		for (const [k, v] of Object.entries(x)) out[k] = recorrer(v, k === 'fondo');
+		if (typeof out.generar === 'string') {
+			const pedido = {prompt: out.generar, fondo: esFondo || out.fondo === true};
+			const marca = {};
+			pendientes.push([pedido, marca]);
+			delete out.generar;
+			if (out.tipo) {
+				out.__src = marca;
+				return out;
+			}
+			// {generar: '...'} donde se esperaba una ruta (p. ej. imagen: {generar: '...'} en la escena "dato")
+			return marca;
+		}
+		return out;
+	};
+	const scenes = recorrer(video.scenes);
+	const hud = recorrer(video.hud ?? []);
+	if (!pendientes.length) return video;
+	const cfg = cfgImagenes ?? {};
+	const proveedor = cfg.proveedor ?? 'openai';
+	const fn = typeof proveedor === 'function' ? proveedor : proveedor === 'openai' ? openai : null;
+	if (!fn) throw new ErrorMorfeo(`Proveedor de imágenes "${proveedor}" no existe. Usa 'openai' o una función async (prompt, opciones) => ruta | Buffer`);
+	fs.mkdirSync(cacheDir, {recursive: true});
+	fs.mkdirSync(path.join(assetsDir, 'ia'), {recursive: true});
+	let nuevas = 0;
+	for (const [pedido, marca] of pendientes) {
+		const prompt = [pedido.prompt, cfg.estilo, pedido.fondo ? 'formato vertical, escena completa de fondo, sin texto' : 'objeto aislado, fondo transparente, sin texto'].filter(Boolean).join('. ');
+		const h = huella([typeof proveedor === 'function' ? proveedor.name : proveedor, cfg.modelo, prompt]);
+		const archivo = path.join(cacheDir, `${h}.png`);
+		if (!fs.existsSync(archivo)) {
+			log(`    imagen: ${pedido.prompt.slice(0, 60)}...`);
+			const r = await fn(prompt, {...cfg, fondo: pedido.fondo});
+			if (typeof r === 'string') fs.copyFileSync(r, archivo);
+			else fs.writeFileSync(archivo, Buffer.from(r));
+			nuevas++;
+		}
+		fs.copyFileSync(archivo, path.join(assetsDir, 'ia', `${h}.png`));
+		marca.ruta = `ia/${h}.png`;
+	}
+	if (nuevas) log(`    ${nuevas} imagen(es) nuevas`);
+	// segunda pasada: pone las rutas en su lugar
+	const fijar = (x) => {
+		if (Array.isArray(x)) return x.map(fijar);
+		if (!x || typeof x !== 'object') return x;
+		if ('ruta' in x && Object.keys(x).length === 1) return x.ruta;
+		const out = {};
+		for (const [k, v] of Object.entries(x)) if (k !== '__src') out[k] = fijar(v);
+		if (x.__src) out.src = x.__src.ruta;
+		return out;
+	};
+	return {...video, scenes: fijar(scenes), hud: fijar(hud)};
+}

package/lib/index.mjs

@@ -0,0 +1,15 @@
+// API de Morfeo para usar desde código:
+//   import {render, defineConfig, defineVideo} from 'morfeo';
+export {cargarProyecto, ErrorMorfeo, MUSICAS, PROVEEDORES_VOZ, TIPOS_ESCENA} from './config.mjs';
+export {HOME, VERSION} from './entorno.mjs';
+export {guardarVideo, guionConIA, guionSinIA, ICONOS, MODELO_GUION} from './guion.mjs';
+export {doctor, instalar, listoParaRender} from './instalar.mjs';
+export {cargarEnv, lista, preparar, render, studio} from './render.mjs';
+export {sintetizarVoces} from './voces.mjs';
+
+/** Ayuda de autocompletado para morfeo.config.mjs (devuelve lo mismo que recibe). */
+export const defineConfig = (config) => config;
+/** Ayuda de autocompletado para un video (devuelve lo mismo que recibe). */
+export const defineVideo = (video) => video;
+/** Ayuda de autocompletado para videos.mjs: {id: video}. */
+export const defineVideos = (videos) => videos;

package/lib/instalar.mjs

@@ -0,0 +1,193 @@
+// `morfeo instalar`: deja todo listo, paso a paso, preguntando antes de instalar cosas del sistema.
+// `morfeo doctor`: dice qué falta sin tocar nada.
+import {spawnSync} from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import readline from 'node:readline/promises';
+import {
+	ARCHIVOS_MODELO,
+	ES_WIN,
+	HOME,
+	MODELOS,
+	PY_MAX,
+	PY_MIN,
+	REQUISITOS,
+	URL_MODELOS,
+	VENV,
+	buscarPython,
+	formatoBytes,
+	marcarVenvListo,
+	modelosListos,
+	pythonVenv,
+	venvListo,
+	versionPython,
+} from './entorno.mjs';
+import {whisperListo, instalarWhisper} from './whisper.mjs';
+
+const ok = (m) => console.log(`  ✔ ${m}`);
+const no = (m) => console.log(`  ✘ ${m}`);
+const info = (m) => console.log(`    ${m}`);
+const titulo = (m) => console.log(`\n▸ ${m}`);
+const tiene = (cmd) => spawnSync(ES_WIN ? 'where' : 'which', [cmd], {stdio: 'ignore'}).status === 0;
+const correr = (cmd, args, opts = {}) => {
+	const r = spawnSync(cmd, args, {stdio: 'inherit', ...opts});
+	if (r.status !== 0) throw new Error(`Falló: ${[cmd, ...args].join(' ')}`);
+};
+
+async function preguntar(texto, {si = false, porDefecto = true} = {}) {
+	if (si) return true;
+	if (!process.stdin.isTTY) return porDefecto;
+	const rl = readline.createInterface({input: process.stdin, output: process.stdout});
+	const r = (await rl.question(`  ? ${texto} ${porDefecto ? '[S/n]' : '[s/N]'} `)).trim().toLowerCase();
+	rl.close();
+	return r ? r.startsWith('s') || r.startsWith('y') : porDefecto;
+}
+
+const rango = `${PY_MIN.join('.')}–${PY_MAX.join('.')}`;
+
+/** Intenta instalar Python 3.12 con el gestor del sistema, preguntando antes. */
+async function instalarPython(op) {
+	if (process.platform === 'darwin' && tiene('brew')) {
+		if (!(await preguntar('¿Instalo Python 3.12 con Homebrew (brew install python@3.12)?', op))) return false;
+		correr('brew', ['install', 'python@3.12']);
+		return true;
+	}
+	if (ES_WIN && tiene('winget')) {
+		if (!(await preguntar('¿Instalo Python 3.12 con winget?', op))) return false;
+		correr('winget', ['install', '-e', '--id', 'Python.Python.3.12', '--accept-package-agreements', '--accept-source-agreements']);
+		info('Si el siguiente paso no encuentra Python, cierra esta terminal, abre otra y vuelve a correr: npx morfeo instalar');
+		return true;
+	}
+	if (process.platform === 'darwin') info('Instala Homebrew (https://brew.sh) y luego: brew install python@3.12');
+	else if (ES_WIN) info('Descarga Python 3.12 de https://www.python.org/downloads/ y marca "Add python.exe to PATH".');
+	else info('Instálalo con tu gestor de paquetes, por ejemplo:  sudo apt install python3.12 python3.12-venv');
+	return false;
+}
+
+async function descargar(url, destino) {
+	const res = await fetch(url);
+	if (!res.ok || !res.body) throw new Error(`No pude descargar ${url} (${res.status})`);
+	const total = Number(res.headers.get('content-length')) || 0;
+	const tmp = `${destino}.part`;
+	const f = fs.createWriteStream(tmp);
+	let n = 0;
+	let ultimo = 0;
+	for await (const trozo of res.body) {
+		f.write(trozo);
+		n += trozo.length;
+		if (process.stdout.isTTY && Date.now() - ultimo > 250) {
+			ultimo = Date.now();
+			process.stdout.write(`\r    ${path.basename(destino)}: ${formatoBytes(n)}${total ? ` de ${formatoBytes(total)}` : ''}   `);
+		}
+	}
+	await new Promise((r, j) => f.end((e) => (e ? j(e) : r())));
+	if (process.stdout.isTTY) process.stdout.write('\n');
+	fs.renameSync(tmp, destino);
+}
+
+/**
+ * @param {{si?: boolean, whisper?: boolean|null, saltarNavegador?: boolean}} op
+ *   si: responde "sí" a todo · whisper: true/false fuerza instalarlo o no (null = preguntar)
+ */
+export async function instalar(op = {}) {
+	console.log(`Morfeo: preparando tu computadora (todo queda en ${HOME})`);
+	fs.mkdirSync(HOME, {recursive: true});
+
+	// 1) Node
+	titulo('Node.js');
+	const mayor = Number(process.versions.node.split('.')[0]);
+	if (mayor < 18) throw new Error(`Necesitas Node.js 18 o más nuevo (tienes ${process.versions.node}). Descárgalo de https://nodejs.org`);
+	ok(`Node ${process.versions.node}`);
+
+	// 2) Python + entorno
+	titulo(`Python ${rango} (voces Kokoro y mezcla de audio)`);
+	if (venvListo()) ok(`entorno listo en ${VENV}`);
+	else {
+		let py = buscarPython();
+		if (!py.cmd) {
+			no(`no encontré Python ${rango}${py.vistos.length ? ` (vi: ${py.vistos.join(', ')})` : ''}`);
+			if (await instalarPython(op)) py = buscarPython();
+			if (!py.cmd) throw new Error(`Instala Python ${rango} y vuelve a correr: npx morfeo instalar\n  (o indica cuál usar con MORFEO_PYTHON=/ruta/a/python3.12)`);
+		}
+		ok(`uso ${[py.cmd, ...py.args].join(' ')} (${py.version.join('.')})`);
+		const vpy = versionPython(pythonVenv());
+		if (fs.existsSync(VENV) && (!vpy || vpy[1] !== py.version[1])) fs.rmSync(VENV, {recursive: true, force: true});
+		if (!fs.existsSync(pythonVenv())) {
+			info('creando entorno virtual...');
+			correr(py.cmd, [...py.args, '-m', 'venv', VENV]);
+		}
+		info('instalando paquetes (kokoro-onnx, numpy, scipy...). La primera vez tarda un par de minutos.');
+		correr(pythonVenv(), ['-m', 'pip', 'install', '--disable-pip-version-check', '-q', '--upgrade', 'pip']);
+		correr(pythonVenv(), ['-m', 'pip', 'install', '--disable-pip-version-check', '-q', '-r', REQUISITOS]);
+		marcarVenvListo();
+		ok('entorno de Python listo');
+	}
+
+	// 3) Modelos de voz
+	titulo('Voces Kokoro (~340 MB, una sola vez)');
+	fs.mkdirSync(MODELOS, {recursive: true});
+	for (const f of ARCHIVOS_MODELO) {
+		const p = path.join(MODELOS, f);
+		if (fs.existsSync(p)) ok(f);
+		else {
+			await descargar(URL_MODELOS + f, p);
+			ok(f);
+		}
+	}
+
+	// 4) Navegador de Remotion (Chrome Headless Shell)
+	titulo('Navegador para renderizar (~100 MB)');
+	if (op.saltarNavegador) info('omitido');
+	else {
+		const {asegurarNavegador} = await import('./navegador.mjs');
+		ok(await asegurarNavegador(info));
+	}
+
+	// 5) Whisper (opcional)
+	titulo('Whisper: subtítulos sincronizados palabra por palabra (opcional, ~470 MB)');
+	if (whisperListo()) ok('instalado');
+	else {
+		let quiere = op.whisper;
+		if (quiere == null) quiere = await preguntar('¿Instalo Whisper? Sin él los subtítulos se reparten por frase', {...op, porDefecto: true});
+		if (!quiere) info('omitido. Puedes instalarlo después con: npx morfeo instalar --whisper');
+		else {
+			if (process.platform === 'darwin' && spawnSync('xcode-select', ['-p'], {stdio: 'ignore'}).status !== 0) {
+				no('Whisper se compila y necesita las herramientas de Apple.');
+				info('Corre:  xcode-select --install   y cuando termine:  npx morfeo instalar --whisper');
+			} else {
+				await instalarWhisper();
+				ok('Whisper listo');
+			}
+		}
+	}
+
+	console.log('\nTodo listo. Prueba:  npx morfeo nuevo mi-canal  &&  cd mi-canal  &&  npx morfeo render');
+}
+
+/** Devuelve el estado de cada pieza; con imprimir=true lo muestra. */
+export async function doctor({imprimir = true} = {}) {
+	const estado = [];
+	const add = (nombre, bien, detalle, arreglo) => estado.push({nombre, bien, detalle, arreglo});
+	const mayor = Number(process.versions.node.split('.')[0]);
+	add('Node.js', mayor >= 18, process.versions.node, 'instala Node 18+ de https://nodejs.org');
+	const py = venvListo() ? {cmd: pythonVenv(), version: versionPython(pythonVenv())} : buscarPython();
+	add(`Python ${rango}`, !!py.cmd, py.cmd ? `${py.version?.join('.')} (${py.cmd})` : 'no encontrado', 'npx morfeo instalar');
+	add('Entorno de Python', venvListo(), VENV, 'npx morfeo instalar');
+	add('Voces Kokoro', modelosListos(), MODELOS, 'npx morfeo instalar');
+	const {navegadorListo} = await import('./navegador.mjs');
+	add('Navegador de render', navegadorListo(), navegadorListo() ? 'listo' : 'falta (se descarga solo en el primer render)', 'npx morfeo instalar');
+	add('Whisper (opcional)', whisperListo(), whisperListo() ? 'instalado' : 'no instalado', 'npx morfeo instalar --whisper', true);
+	add('ffmpeg (opcional)', tiene('ffmpeg'), tiene('ffmpeg') ? 'en el PATH' : 'no está (solo hace falta para m4a/aac)', 'brew install ffmpeg', true);
+	for (const k of ['ANTHROPIC_API_KEY', 'ELEVENLABS_API_KEY', 'OPENAI_API_KEY'])
+		add(`${k} (opcional)`, !!process.env[k], process.env[k] ? 'configurada' : 'no configurada', `ponla en tu .env si la vas a usar`, true);
+	if (imprimir) {
+		console.log(`Morfeo · carpeta compartida: ${HOME}\n`);
+		for (const e of estado) {
+			const marca = e.bien ? '✔' : e.nombre.includes('opcional') ? '·' : '✘';
+			console.log(`  ${marca} ${e.nombre.padEnd(30)} ${e.detalle}${e.bien ? '' : `   → ${e.arreglo}`}`);
+		}
+	}
+	return estado;
+}
+
+export const listoParaRender = () => venvListo() && modelosListos();