morfeo 0.0.0-stage → 0.1.1

package/index.d.ts

@@ -0,0 +1,250 @@
+// Tipos de Morfeo: dan autocompletado en morfeo.config.mjs y videos.mjs (también en JS).
+
+/** '#RRGGBB' o [r, g, b] */
+export type Color = string | [number, number, number];
+/** [texto, color, tamaño] — tamaño 110–260 aprox. */
+export type Fila = [string, Color, number];
+
+export type Icono =
+	| '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';
+
+export type EstiloMusica = 'lofi' | 'lofi2' | 'chillpop' | 'synth' | 'house' | 'ballad' | 'trap';
+
+interface EscenaBase {
+	/** Lo que dice la voz. Números con letras ("mil novecientos ochenta") para que se lean bien. */
+	say: string;
+	/** Subtítulo si es distinto de `say` (p. ej. con cifras: "1980"). */
+	show?: string;
+	/** Tu propia grabación para esta escena (wav, mp3, flac, ogg). `say` sigue sirviendo para los subtítulos. */
+	audio?: string;
+}
+
+export type Estilo = 'datos-curiosos' | 'explicativo' | 'documental' | 'ilustrado' | 'historia' | 'mesa' | 'serie' | 'infografia' | '3d' | 'minimal' | (string & {});
+
+/** Momento: segundos desde que empieza la escena, una palabra de `say` ("orcas"), "voz", "fin", o "palabra+0.3". */
+export type Momento = number | string;
+export type Entrada = 'escala' | 'rebote' | 'aparecer' | 'subir' | 'caer' | 'girar' | 'deslizar-izq' | 'deslizar-der' | 'deslizar-arriba' | 'deslizar-abajo' | 'ninguna';
+
+interface CapaBase {
+	/** Centro en el lienzo 1080×1920 (dentro de un grupo o teléfono: relativo a su centro). */
+	x?: number;
+	y?: number;
+	ancla?: 'centro' | 'izquierda' | 'derecha';
+	/** Cuándo aparece y cuándo se va. */
+	en?: Momento;
+	hasta?: Momento;
+	entrada?: Entrada;
+	salida?: 'aparecer' | 'escala' | 'subir' | 'deslizar-izq' | 'deslizar-der' | 'ninguna';
+	duracionEntrada?: number;
+	escala?: number;
+	rotar?: number;
+	opacidad?: number;
+	mover?: {a: [number, number]; en?: Momento; duracion?: number; curva?: 'suave' | 'lineal'};
+	escalar?: {a: number; en?: Momento; duracion?: number};
+	/** Grados por segundo. */
+	girar?: number;
+	flotar?: boolean | number;
+	latir?: boolean;
+	voltear?: boolean;
+	desenfoque?: number;
+	sombra?: boolean | string;
+	z?: number;
+	/** Efecto de sonido al aparecer. */
+	sonido?: 'pop' | 'whoosh' | 'tick' | 'glitch' | 'ding';
+	/** Cambios en el tiempo (ideal para el HUD): los números se animan desde el valor anterior. */
+	cambios?: ({en: Momento | {escena: number}} & Record<string, unknown>)[];
+}
+
+export type Capa = CapaBase &
+	(
+		| {tipo: 'imagen'; src?: string; generar?: string; ancho?: number; alto?: number; redondo?: boolean; radio?: number; cambiarA?: {src: string; en?: Momento; efecto?: 'fundido' | 'barrido' | 'circulo'; duracion?: number}}
+		| {tipo: 'video'; src: string; ancho?: number; alto?: number; radio?: number}
+		| {tipo: 'texto'; texto: string; tam?: number; color?: string; acento?: string; fuente?: 'titulo' | 'texto' | 'mono' | (string & {}); peso?: number; mayusculas?: boolean; contorno?: number; colorContorno?: string; fondo?: string; relleno?: string; radio?: number; maxAncho?: number | 'auto'; alinear?: 'center' | 'left' | 'right'; interlineado?: number; escribir?: boolean | number; subrayado?: boolean}
+		| {tipo: 'contador'; de?: number; a: number; prefijo?: string; sufijo?: string; decimales?: number; miles?: string; decimal?: string; duracion?: number; curva?: 'suave' | 'lineal' | 'exponencial'; formato?: 'grande' | 'lcd' | 'chip'; tam?: number; color?: string; fondo?: string}
+		| {tipo: 'chip'; texto: string; unidad?: string; tam?: number; color?: string; fondo?: string; borde?: string}
+		| {tipo: 'etiqueta'; texto: string; tam?: number; color?: string}
+		| {tipo: 'numero'; texto?: string; valor?: number; tam?: number; color?: string; fondo?: string; radio?: number}
+		| {tipo: 'tarjeta'; titulo?: string; cabecera?: string; texto?: string; items?: (string | {texto: string; check?: Momento | boolean; en?: Momento; color?: string})[]; ancho?: number; fondo?: string; borde?: string; checks?: boolean}
+		| {tipo: 'telefono'; src?: string; capas?: Capa[]; ancho?: number; pantalla?: string}
+		| {tipo: 'forma'; forma?: 'rect' | 'circulo' | 'linea' | 'flecha'; ancho?: number; alto?: number; color?: string; borde?: string; grosor?: number; punteado?: boolean; relleno?: boolean; radio?: number; brillo?: number; transparencia?: number}
+		| {tipo: 'icono'; nombre: Icono; tam?: number; color?: string}
+		| {tipo: 'emoji'; texto: string; tam?: number}
+		| {tipo: 'marca'; tam?: number}
+		| {tipo: 'particulas'; particulas?: 'burbujas' | 'polvo' | 'estrellas' | 'nieve' | 'confeti'; cantidad?: number; color?: string}
+		| {tipo: 'grupo'; capas?: Capa[]; capa?: Capa; repetir?: number; disposicion?: 'circulo' | 'fila' | 'columna' | 'cuadricula' | 'pila' | 'aleatorio'; radio?: number; espacio?: number; espacioV?: number; columnas?: number; orientar?: boolean | number; retraso?: number; area?: [number, number]; girarAzar?: number; desorden?: number}
+		| {tipo: 'modelo'; src?: string; forma?: 'moneda' | 'billete' | 'cubo' | 'esfera' | 'lingote'; color?: string; metal?: number; rugosidad?: number; ancho?: number; alto?: number; tamano?: number; rotacion?: [number, number, number]; girar3d?: [number, number, number]; cantidad?: number; crecer?: boolean; duracion?: number; distancia?: number; camaraY?: number; luz?: number; reflejos?: number}
+		| {tipo: 'componente'; nombre: string; props?: Record<string, unknown>}
+		| {tipo: 'personaje'; nombre: string; pose?: string; poses?: {en: Momento; pose: string}[]; hablar?: boolean; ancho?: number}
+		| {tipo: 'escena3d'; src: string; camara?: {en?: Momento; pos: [number, number, number]; mirar?: [number, number, number]; fov?: number}[]; animacion?: boolean | string | string[]; velocidad?: number; mostrar?: {nodo: string; en: Momento}[]; ocultar?: {nodo: string; en: Momento}[]; fondo?: string | null; niebla?: [number, number]; luz?: number; luzAmbiente?: number; sol?: [number, number, number]; reflejos?: number; sombras?: boolean; ancho?: number; alto?: number}
+		| {tipo: 'barra'; valor: number; max?: number; titulo?: string; unidad?: string; mostrar?: boolean; color?: string; ancho?: number; alto?: number; fondo?: string; decimales?: number}
+		| {tipo: 'medidor'; valor: number; min?: number; max?: number; unidad?: string; tam?: number; zonas?: [number, string][]; decimales?: number}
+		| {tipo: 'votacion'; titulo?: string; cabecera?: string; opciones: {texto: string; valor: number; sub?: string; color?: string}[]; ancho?: number}
+		| {tipo: 'estado'; hora?: string; dia?: string; bateria?: number; aviso?: string; contador?: number; color?: string; ancho?: number; tam?: number}
+		| {tipo: 'noticia'; titular: string; etiqueta?: string; cintillo?: string; vivo?: boolean; ancho?: number; velocidad?: number}
+		| {tipo: 'chat'; mensajes: {usuario: string; texto: string}[]; cada?: number; maximo?: number; ancho?: number; tam?: number}
+		| {tipo: 'onda'; barras?: number; ancho?: number; alto?: number; color?: string; siempre?: boolean}
+		| {tipo: 'globo'; texto: string; cola?: 'abajo' | 'arriba' | 'izq' | 'der' | 'ninguna'; fondo?: string; color?: string; borde?: string; tam?: number; maxAncho?: number}
+		| {tipo: 'seguir'; usuario?: string; texto?: string; pulsar?: number}
+		| {tipo: 'ventana'; diametro?: number; src?: string; capas?: Capa[]; borde?: 'metal' | 'ninguno' | (string & {}); grosor?: number; remaches?: number | false; zoom?: number | [number, number]; fondo?: string}
+	);
+
+export type FondoEscena =
+	| {tipo: 'color'; color: string}
+	| {tipo: 'degradado'; colores: string[]; angulo?: number}
+	| {tipo: 'imagen'; src?: string; generar?: string; oscurecer?: number; desenfoque?: number}
+	| {tipo: 'video'; src: string; oscurecer?: number};
+
+interface EscenaMotorBase extends EscenaBase {
+	capas?: Capa[];
+	fondo?: FondoEscena;
+	/** Cámara: número fijo o [inicio, fin] a lo largo de la escena. */
+	camara?: {zoom?: number | [number, number]; x?: number | [number, number]; y?: number | [number, number]; en?: number; duracion?: number; origen?: [number, number]; temblor?: {fuerza?: number; duracion?: number}};
+	transicion?: 'corte' | 'fundido' | 'deslizar' | 'zoom';
+	/** Ajustes del tema solo para esta escena. */
+	tema?: Partial<Tema>;
+}
+
+/** Escenas de los estilos del motor de capas (todos menos 'datos-curiosos', que también las acepta). */
+export type EscenaMotor =
+	| (EscenaMotorBase & {type?: 'capas'})
+	| (EscenaMotorBase & {type: 'titular'; texto: string; etiqueta?: string; numero?: number | string; sub?: string; y?: number; tam?: number})
+	| (EscenaMotorBase & {type: 'dato'; valor: number; de?: number; prefijo?: string; sufijo?: string; decimales?: number; curva?: 'suave' | 'lineal' | 'exponencial'; formato?: 'grande' | 'lcd' | 'chip'; texto?: string; imagen?: string | {generar: string}; tam?: number; y?: number; en?: Momento; duracion?: number})
+	| (EscenaMotorBase & {type: 'lista'; titulo?: string; cabecera?: string; items: (string | {texto: string; check?: Momento | boolean})[]; ancho?: number; y?: number})
+	| (EscenaMotorBase & {type: 'telefono'; src?: string; capasPantalla?: Capa[]; texto?: string; ancho?: number; y?: number})
+	| (EscenaMotorBase & {type: 'comparar'; a: string | {texto: string; imagen?: string; color?: string}; b: string | {texto: string; imagen?: string; color?: string}; at?: string})
+	| (EscenaMotorBase & {type: 'eleccion'; pregunta?: string; opciones: (string | {texto: string; sub?: string; emoji?: string; icono?: Icono; imagen?: string; color?: string; fondo?: string; en?: Momento})[]; formato?: 'cartas' | 'botones'; comenta?: string | false; enComenta?: Momento; y?: number})
+	| (Partial<EscenaMotorBase> & {type: 'cta'});
+
+export interface Tema {
+	fondo: FondoEscena;
+	rayos?: {color: string; fuerza?: number};
+	foco?: {color: string; x?: number; y?: number; radio?: number; fuerza?: number};
+	vineta?: number;
+	textura?: 'papel' | 'grano' | 'ninguna';
+	particulas?: {tipo: 'burbujas' | 'polvo' | 'estrellas' | 'nieve' | 'confeti' | 'ninguna'; cantidad?: number; color?: string};
+	colores: {texto: string; acento: string; acento2: string; suave: string; tarjeta: string; tarjetaTexto: string; borde: string};
+	fuentes: {titulo: string; texto: string; mono: string};
+	tituloMayusculas: boolean;
+	subtitulos: {tipo: 'karaoke' | 'pop' | 'bloque' | 'palabra' | 'ninguno'; y: number; tam: number; color: string; pendiente: string; resalte: string; maxPalabras: number; mayusculas?: boolean; contorno?: number; fondo?: string};
+	transicion: 'corte' | 'fundido' | 'deslizar' | 'zoom';
+	marca: 'esquina' | 'arriba' | 'ninguna';
+	zoomLento: number;
+}
+
+export type EscenaClasica =
+	| (EscenaBase & {type: 'title'; rows: Fila[]; icon?: Icono; tag?: string})
+	| (EscenaBase & {type: 'text'; rows: Fila[]; strike?: boolean})
+	| (EscenaBase & {type: 'year'; pre: string; year: number; sub: string})
+	| (EscenaBase & {type: 'icon'; icon: Icono; label: string; color?: Color})
+	| (EscenaBase & {type: 'compare'; a: [string, Color]; b: [string, Color]; at: string; sizes?: [number, number]})
+	| (EscenaBase & {type: 'card'; file: string; rows: [string, string | null, string | null][]; at: string; flash?: string})
+	| (EscenaBase & {type: 'dialog'; q: [string, string]; click: string; result: string})
+	| (EscenaBase & {type: 'aliens'; n: number; speed: number; label?: string})
+	| (EscenaBase & {type: 'memory'; label?: string})
+	| (EscenaBase & {type: 'morph'; at?: string})
+	| (Partial<EscenaBase> & {type: 'cta'});
+
+export type Escena = EscenaClasica | EscenaMotor;
+
+/** Mezcla de voces Kokoro: [nombre o ruta .npy, peso]. */
+export type MezclaVoz = [string, number][];
+
+export type VozExterna =
+	| {proveedor: 'elevenlabs'; voz: string; modelo?: string; idioma?: string; ajustes?: Record<string, number | boolean>}
+	| {proveedor: 'openai'; voz?: string; modelo?: string; instrucciones?: string; velocidad?: number}
+	| {proveedor: 'kokoro'; voz: string | MezclaVoz}
+	| {
+			/** Tu propio servicio: recibe el texto y devuelve una ruta de audio, un Buffer o {datos, ext}. */
+			proveedor: (texto: string, opciones: Record<string, unknown>) => Promise<string | Uint8Array | {datos: Uint8Array; ext: string}>;
+			[opcion: string]: unknown;
+	  };
+
+/** Nombre de voz Kokoro ("em_alex"), alias de `voces`, archivo .npy, mezcla, o servicio externo. */
+export type Voz = string | MezclaVoz | VozExterna;
+
+/** Estilo generado, alias de `musicas`, archivo ("./musica/x.mp3"), o false (sin música). */
+export type Musica = EstiloMusica | string | false | {archivo: string; volumen?: number; inicio?: number};
+
+export interface Video {
+	/** Estilo visual (por defecto, el de morfeo.config.mjs). */
+	estilo?: Estilo;
+	/** Capas fijas encima de todo el video (día, barras, hora...); se actualizan con `cambios`. */
+	hud?: Capa[];
+	/** Ajustes del estilo para este video (colores, fondo, subtítulos...). */
+	tema?: Partial<Tema> & Record<string, unknown>;
+	/** Título para publicar. */
+	title?: string;
+	voice?: Voz;
+	music?: Musica;
+	/** Velocidad de la voz Kokoro (por defecto 1.2). */
+	speed?: number;
+	/** Idioma de Kokoro: "es", "en-us", "en-gb", "fr-fr", "it", "pt-br", "ja", "cmn", "hi". */
+	lang?: string;
+	scenes: Escena[];
+	/** Segundo del video para la miniatura (por defecto, cuando la primera escena ya está completa). Sale sin subtítulos. */
+	miniaturaEn?: number;
+	/** Datos libres que se copian a salida/resumen.json. */
+	meta?: Record<string, unknown>;
+}
+
+export interface Config {
+	/** Estilo visual por defecto: npx morfeo estilos. */
+	estilo?: Estilo;
+	/** Tus estilos: {'mi-estilo': {base: 'minimal', colores: {...}}}. */
+	estilos?: Record<string, Partial<Tema> & {base?: Estilo}>;
+	/** Componentes React propios para {tipo: 'componente'}: {Mapa: './escenas/Mapa.tsx'}. */
+	componentes?: Record<string, string>;
+	/** Personajes con poses: archivos propios o generadas con IA desde `referencia`. */
+	personajes?: Record<string, {referencia?: string; poses: Record<string, string>}>;
+	/** Fuentes propias: {'Poppins': './fuentes/Poppins.ttf'}. */
+	fuentes?: Record<string, string>;
+	/** Carpeta de imágenes/videos/modelos para las capas (por defecto ./assets). */
+	assets?: string;
+	/** Imágenes con IA para {generar: '...'}. */
+	imagenes?: {proveedor?: 'openai' | ((prompt: string, opciones: Record<string, unknown>) => Promise<string | Uint8Array>); estilo?: string; modelo?: string; calidad?: 'low' | 'medium' | 'high'; tamano?: string};
+	marca?: {
+		nombre?: string;
+		/** Imagen cuadrada (png/jpg). Sin logo se usa la inicial del nombre. */
+		logo?: string | null;
+		redes?: string;
+		/** Lo que dice la voz en {type: 'cta'} cuando no trae `say`. */
+		cta?: string;
+		seguir?: string;
+		siguiendo?: string;
+		/** Pastilla del gancho (escena title). */
+		etiqueta?: string;
+	};
+	/** Archivo con {id: video}, o carpeta con <id>.json / <id>.mjs. Por defecto ./videos.mjs + ./guiones/. */
+	videos?: string | Record<string, Video> | (() => Record<string, Video> | Promise<Record<string, Video>>);
+	/** Carpeta donde `morfeo guion` guarda los videos generados (por defecto ./guiones). */
+	guiones?: string;
+	voces?: Record<string, Voz>;
+	musicas?: Record<string, Musica>;
+	/** Carpeta de los .mp4 (por defecto ./salida). */
+	salida?: string;
+	/** gl: por defecto 'angle' (GPU) en Mac con Apple Silicon y 'swangle' (CPU) en lo demás; si la GPU falla, reintenta con CPU. */
+	render?: {crf?: number; gl?: 'swangle' | 'angle' | 'egl' | 'swiftshader' | 'vulkan'; navegador?: string | null; concurrencia?: number | null; miniatura?: boolean};
+}
+
+export declare function defineConfig(config: Config): Config;
+export declare function defineVideo(video: Video): Video;
+export declare function defineVideos(videos: Record<string, Video>): Record<string, Video>;
+
+export interface Hecho {id: string; mp4: string; jpg: string | null; segundos: number}
+type Log = (mensaje: string) => void;
+
+export declare function render(o?: {proyecto?: string; ids?: string[]; todos?: boolean; log?: Log; alProgreso?: (id: string, progreso: number) => void}): Promise<Hecho[]>;
+export declare function preparar(o?: {proyecto?: string; ids?: string[]; log?: Log}): Promise<{publico: string; datos: Record<string, unknown>}>;
+export declare function lista(o?: {proyecto?: string}): Promise<{id: string; titulo: string; hecho: boolean}[]>;
+export declare function studio(o?: {proyecto?: string; puerto?: number}): Promise<void>;
+export declare function instalar(o?: {si?: boolean; whisper?: boolean | null; saltarNavegador?: boolean}): Promise<void>;
+export declare function doctor(o?: {imprimir?: boolean}): Promise<{nombre: string; bien: boolean; detalle: string; arreglo: string}[]>;
+export declare function guionConIA(o: {tema?: string; texto?: string; idioma?: string; duracion?: number; tono?: string; estilo?: Estilo; imagenes?: boolean; voz?: Voz; modelo?: string}): Promise<{id: string; video: Video}>;
+export declare function guionSinIA(texto: string, o?: {id?: string; voz?: Voz; musica?: Musica; titulo?: string; estilo?: Estilo}): {id: string; video: Video};
+export declare function guardarVideo(carpeta: string, id: string, video: Video): {id: string; archivo: string};
+export declare function cargarEnv(proyecto: string): void;
+export declare class ErrorMorfeo extends Error {}
+export declare const VERSION: string;
+export declare const HOME: string;

package/lib/config.mjs

@@ -0,0 +1,284 @@
+// Carga y valida morfeo.config.mjs del proyecto del usuario.
+import fs from 'node:fs';
+import path from 'node:path';
+import {pathToFileURL} from 'node:url';
+
+export const NOMBRES_CONFIG = ['morfeo.config.mjs', 'morfeo.config.js'];
+
+// Voces de Kokoro v1.0 (archivo voices-v1.0.bin)
+export const VOCES_KOKORO = 'af_alloy af_aoede af_bella af_heart af_jessica af_kore af_nicole af_nova af_river af_sarah af_sky am_adam am_echo am_eric am_fenrir am_liam am_michael am_onyx am_puck am_santa bf_alice bf_emma bf_isabella bf_lily bm_daniel bm_fable bm_george bm_lewis ef_dora em_alex em_santa ff_siwis hf_alpha hf_beta hm_omega hm_psi if_sara im_nicola jf_alpha jf_gongitsune jf_nezumi jf_tebukuro jm_kumo pf_dora pm_alex pm_santa zf_xiaobei zf_xiaoni zf_xiaoxiao zf_xiaoyi zm_yunjian zm_yunxi zm_yunxia zm_yunyang'.split(' ');
+
+/** Las voces más parecidas a un nombre mal escrito (para sugerir). */
+const parecidas = (nombre, lista, n = 3) => {
+	const d = (a, b) => {
+		const m = Array.from({length: a.length + 1}, (_, i) => [i, ...Array(b.length).fill(0)]);
+		for (let j = 1; j <= b.length; j++) m[0][j] = j;
+		for (let i = 1; i <= a.length; i++) for (let j = 1; j <= b.length; j++) m[i][j] = Math.min(m[i - 1][j] + 1, m[i][j - 1] + 1, m[i - 1][j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
+		return m[a.length][b.length];
+	};
+	return [...lista].sort((a, b) => d(nombre, a) - d(nombre, b)).slice(0, n);
+};
+
+export const TIPOS_CLASICOS = ['title', 'year', 'text', 'icon', 'compare', 'card', 'dialog', 'aliens', 'memory', 'morph', 'cta'];
+export const TIPOS_MOTOR = ['capas', 'titular', 'dato', 'lista', 'telefono', 'comparar', 'eleccion', 'cta'];
+export const TIPOS_ESCENA = [...new Set([...TIPOS_CLASICOS, ...TIPOS_MOTOR])];
+export const ESTILOS = ['datos-curiosos', 'explicativo', 'documental', 'ilustrado', 'historia', 'mesa', 'serie', 'infografia', '3d', 'minimal'];
+export const TIPOS_CAPA = ['imagen', 'video', 'texto', 'contador', 'chip', 'etiqueta', 'numero', 'tarjeta', 'telefono', 'forma', 'icono', 'emoji', 'marca', 'particulas', 'grupo', 'modelo', 'componente', 'barra', 'medidor', 'votacion', 'estado', 'noticia', 'chat', 'onda', 'globo', 'seguir', 'personaje', 'escena3d', 'ventana'];
+export const PROVEEDORES_VOZ = ['kokoro', 'elevenlabs', 'openai'];
+export const MUSICAS = ['lofi', 'lofi2', 'chillpop', 'synth', 'house', 'ballad', 'trap'];
+
+export class ErrorMorfeo extends Error {}
+
+/**
+ * WebGL por defecto: en Mac con Apple Silicon la tarjeta de video (angle) es estable y ~4 veces más rápida;
+ * en lo demás, por software (swangle), que funciona en cualquier computadora. Si angle falla, el render
+ * reintenta solo con swangle.
+ */
+export const glPorDefecto = () => (process.platform === 'darwin' && process.arch === 'arm64' ? 'angle' : 'swangle');
+
+/** Una carpeta de guiones: cada <id>.json o <id>.mjs es un video. */
+async function leerCarpeta(dir) {
+	const out = {};
+	for (const f of fs.readdirSync(dir).sort()) {
+		const m = f.match(/^(.+)\.(json|mjs|js)$/);
+		if (!m || f.startsWith('.')) continue;
+		const p = path.join(dir, f);
+		try {
+			out[m[1]] = m[2] === 'json' ? JSON.parse(fs.readFileSync(p, 'utf8')) : await importar(p);
+		} catch (e) {
+			throw new ErrorMorfeo(`No pude leer ${path.relative(process.cwd(), p)}: ${e.message}`);
+		}
+	}
+	return out;
+}
+
+export function buscarConfig(proyecto) {
+	for (const n of NOMBRES_CONFIG) {
+		const p = path.join(proyecto, n);
+		if (fs.existsSync(p)) return p;
+	}
+	return null;
+}
+
+const importar = async (archivo) => {
+	// ?v= evita la caché de import() si se carga dos veces en el mismo proceso (studio, pruebas)
+	const mod = await import(`${pathToFileURL(archivo).href}?v=${fs.statSync(archivo).mtimeMs}`);
+	return mod.default ?? mod;
+};
+
+/** Carga la config y los videos del proyecto. Devuelve un objeto normalizado con rutas absolutas. */
+export async function cargarProyecto(proyecto = process.cwd()) {
+	proyecto = path.resolve(proyecto);
+	const archivo = buscarConfig(proyecto);
+	if (!archivo) throw new ErrorMorfeo(`No encontré morfeo.config.mjs en ${proyecto}.\nCrea un proyecto con:  npx morfeo nuevo mi-canal`);
+	let cfg = await importar(archivo);
+	if (typeof cfg === 'function') cfg = await cfg();
+	if (!cfg || typeof cfg !== 'object') throw new ErrorMorfeo(`${path.basename(archivo)} debe exportar un objeto (export default defineConfig({...}))`);
+
+	let videos = cfg.videos ?? (fs.existsSync(path.join(proyecto, 'videos.mjs')) ? './videos.mjs' : './guiones');
+	const carpetaGuiones = typeof videos === 'string' && fs.existsSync(path.resolve(proyecto, videos)) && fs.statSync(path.resolve(proyecto, videos)).isDirectory()
+		? path.resolve(proyecto, videos)
+		: path.resolve(proyecto, cfg.guiones ?? 'guiones');
+	if (typeof videos === 'string') {
+		const p = path.resolve(proyecto, videos);
+		if (!fs.existsSync(p)) throw new ErrorMorfeo(`No existe ${videos}. Crea videos.mjs o la carpeta guiones/ (npx morfeo guion "tema")`);
+		videos = fs.statSync(p).isDirectory() ? await leerCarpeta(p) : await importar(p);
+	}
+	if (typeof videos === 'function') videos = await videos();
+	// los guiones generados con `morfeo guion` (guiones/*.json) se suman a los de videos.mjs
+	if (carpetaGuiones && fs.existsSync(carpetaGuiones) && videos && typeof videos === 'object')
+		videos = {...(await leerCarpeta(carpetaGuiones)), ...videos};
+	if (!videos || typeof videos !== 'object' || Array.isArray(videos)) throw new ErrorMorfeo('`videos` debe ser un objeto {id: video}.');
+
+	const m = cfg.marca ?? {};
+	const marca = {
+		nombre: m.nombre ?? '',
+		logo: m.logo ? path.resolve(proyecto, m.logo) : null,
+		redes: m.redes ?? '',
+		seguir: m.seguir ?? '+ SEGUIR',
+		siguiendo: m.siguiendo ?? 'SIGUIENDO',
+		etiqueta: m.etiqueta ?? 'DATO CURIOSO',
+		cta: m.cta ?? (m.nombre ? `Sígueme en ${m.nombre} para más.` : 'Sígueme para más.'),
+	};
+	if (marca.logo && !fs.existsSync(marca.logo)) throw new ErrorMorfeo(`No existe el logo: ${m.logo}`);
+
+	const errores = [];
+	const estilosPropios = cfg.estilos ?? {};
+	const estilo = cfg.estilo ?? 'datos-curiosos';
+	const assetsDir = path.resolve(proyecto, cfg.assets ?? 'assets');
+	const ctx = {proyecto, marca, voces: cfg.voces ?? {}, musicas: cfg.musicas ?? {}, errores, estilo, estilosPropios, assetsDir};
+	if (!ESTILOS.includes(estilo) && !estilosPropios[estilo]) errores.push(`estilo "${estilo}" no existe. Opciones: ${[...ESTILOS, ...Object.keys(estilosPropios)].join(', ')}`);
+	const componentes = {};
+	for (const [nombre, ruta] of Object.entries(cfg.componentes ?? {})) {
+		const abs = path.resolve(proyecto, ruta);
+		if (!/^[A-Z][A-Za-z0-9_]*$/.test(nombre)) errores.push(`componente "${nombre}": el nombre debe empezar con mayúscula (como un componente de React)`);
+		if (!fs.existsSync(abs)) errores.push(`componente ${nombre}: no existe ${ruta}`);
+		componentes[nombre] = abs;
+	}
+	const fuentes = [];
+	for (const [familia, ruta] of Object.entries(cfg.fuentes ?? {})) {
+		const abs = path.resolve(proyecto, ruta);
+		if (!fs.existsSync(abs)) errores.push(`fuente ${familia}: no existe ${ruta}`);
+		else fuentes.push({familia, archivo: abs});
+	}
+	const normalizados = {};
+	for (const [id, v] of Object.entries(videos)) {
+		if (!/^[a-z0-9][a-z0-9_-]*$/i.test(id)) errores.push(`"${id}": el id solo puede tener letras, números, - y _`);
+		const e = validarVideo(id, v, ctx);
+		if (e) normalizados[id] = e;
+	}
+	if (errores.length) throw new ErrorMorfeo(`Hay errores en tus videos:\n  - ${errores.join('\n  - ')}`);
+
+	const r = cfg.render ?? {};
+	return {
+		proyecto,
+		archivo,
+		marca,
+		videos: normalizados,
+		salida: path.resolve(proyecto, cfg.salida ?? 'salida'),
+		guiones: carpetaGuiones,
+		trabajo: path.resolve(proyecto, '.morfeo'),
+		assets: path.resolve(proyecto, cfg.assets ?? 'assets'),
+		estilo,
+		estilos: estilosPropios,
+		fuentes,
+		imagenes: cfg.imagenes ?? {},
+		personajes: cfg.personajes ?? {},
+		componentes,
+		render: {
+			crf: r.crf ?? 18,
+			gl: process.env.MORFEO_GL || process.env.REMOTION_GL || r.gl || glPorDefecto(),
+			navegador: process.env.MORFEO_NAVEGADOR || r.navegador || null,
+			concurrencia: r.concurrencia ?? null, // null = Morfeo elige según la máquina y el modo (ver render.mjs)
+			miniatura: r.miniatura ?? true,
+		},
+	};
+}
+
+const CAMPOS_ARCHIVO = new Set(['src', 'imagen']);
+/** Busca `src`/`imagen` que apunten a assets/ y avisa de los que no existen. */
+function revisarArchivos(x, assetsDir, err, ruta = '') {
+	if (Array.isArray(x)) return x.forEach((v, i) => revisarArchivos(v, assetsDir, err, `${ruta}[${i}]`));
+	if (!x || typeof x !== 'object') return;
+	for (const [k, v] of Object.entries(x)) {
+		if (CAMPOS_ARCHIVO.has(k) && typeof v === 'string' && !/^(https?:|data:)/.test(v)) {
+			const rel = v.replace(/^\.?\/?(assets\/)?/, '');
+			if (!fs.existsSync(path.join(assetsDir, rel))) err(`no existe assets/${rel} (lo pide ${ruta.replace(/^\./, '') || 'una capa'}.${k}). Ponlo en la carpeta assets/ o usa  generar: 'descripción'  para la IA`);
+		} else if (v && typeof v === 'object') revisarArchivos(v, assetsDir, err, `${ruta}.${k}`);
+	}
+}
+
+function validarCapas(capas, donde, err) {
+	if (!Array.isArray(capas)) return err(`${donde}: \`capas\` debe ser una lista`);
+	capas.forEach((c, i) => {
+		const d = `${donde}, capa ${i + 1}`;
+		if (!c || typeof c !== 'object') return err(`${d} debe ser un objeto`);
+		if (!TIPOS_CAPA.includes(c.tipo)) return err(`${d}: tipo "${c.tipo}" no existe. Opciones: ${TIPOS_CAPA.join(', ')}`);
+		if ((c.tipo === 'imagen' || c.tipo === 'video') && !c.src && !c.generar) err(`${d}: falta \`src\` (archivo en assets/) o \`generar\` (descripción para la IA)`);
+		if (c.capas) validarCapas(c.capas, d, err);
+		if (c.capa) validarCapas([c.capa], d, err);
+	});
+}
+
+const EXT_AUDIO = /\.(mp3|wav|flac|ogg|oga|aiff?|m4a|aac)$/i;
+const pareceRuta = (x) => typeof x === 'string' && (x.includes('/') || x.includes('\\') || /\.[a-z0-9]{2,4}$/i.test(x));
+
+/** Voz -> lista [[ref, peso]] donde ref es un nombre de voz Kokoro o la ruta absoluta de un .npy. */
+function normalizarVoz(voz, ctx, err, profundidad = 0) {
+	if (typeof voz === 'string' && ctx.voces[voz] != null && profundidad < 5) return normalizarVoz(ctx.voces[voz], ctx, err, profundidad + 1);
+	if (voz && typeof voz === 'object' && !Array.isArray(voz)) {
+		// voz por servicio externo: {proveedor: 'elevenlabs' | 'openai' | función, ...opciones}
+		if (voz.proveedor ?? voz.provider) {
+			const proveedor = voz.proveedor ?? voz.provider;
+			if (proveedor === 'kokoro') return normalizarVoz(voz.voz ?? voz.voice ?? 'em_alex', ctx, err, profundidad + 1);
+			if (typeof proveedor !== 'function' && !PROVEEDORES_VOZ.includes(proveedor))
+				err(`proveedor de voz "${proveedor}" no existe. Opciones: ${PROVEEDORES_VOZ.join(', ')} o una función async (texto, opciones) => ruta o Buffer`);
+			return {...voz, proveedor};
+		}
+		voz = voz.archivo ?? voz.file;
+	}
+	if (typeof voz === 'string') voz = [[voz, 1]];
+	if (!Array.isArray(voz) || !voz.length) return err('`voice` debe ser un nombre de voz ("em_alex"), una mezcla [["em_alex", 0.6], ["am_michael", 0.4]] o un archivo .npy'), null;
+	const out = [];
+	for (const par of voz) {
+		const [ref, peso = 1] = Array.isArray(par) ? par : [par, 1];
+		if (typeof ref !== 'string' || typeof peso !== 'number') {
+			err(`voz inválida: ${JSON.stringify(par)}`);
+			continue;
+		}
+		if (ctx.voces[ref] != null && profundidad < 5) {
+			for (const [r, w] of normalizarVoz(ctx.voces[ref], ctx, err, profundidad + 1) ?? []) out.push([r, w * peso]);
+		} else if (pareceRuta(ref)) {
+			const abs = path.resolve(ctx.proyecto, ref);
+			if (!/\.npy$/i.test(abs)) err(`la voz ${ref} debe ser un archivo .npy (estilo de voz Kokoro, forma 510×1×256)`);
+			else if (!fs.existsSync(abs)) err(`no existe el archivo de voz ${ref}`);
+			out.push([abs, peso]);
+		} else {
+			if (!VOCES_KOKORO.includes(ref)) {
+				const alias = Object.keys(ctx.voces);
+				err(`la voz "${ref}" no existe. ¿Quisiste decir ${parecidas(ref, [...alias, ...VOCES_KOKORO]).map((x) => `"${x}"`).join(', ')}? En español: em_alex, ef_dora, em_santa`);
+			}
+			out.push([ref, peso]);
+		}
+	}
+	return out;
+}
+
+/** Música -> null | {estilo} | {archivo, volumen, inicio}. */
+function normalizarMusica(m, ctx, err, profundidad = 0) {
+	if (m == null || m === false) return null;
+	if (typeof m === 'string' && ctx.musicas[m] != null && profundidad < 5) return normalizarMusica(ctx.musicas[m], ctx, err, profundidad + 1);
+	if (typeof m === 'string' && MUSICAS.includes(m)) return {estilo: m};
+	if (typeof m === 'string' && pareceRuta(m)) m = {archivo: m};
+	if (m && typeof m === 'object' && (m.archivo || m.file)) {
+		const abs = path.resolve(ctx.proyecto, m.archivo ?? m.file);
+		if (!fs.existsSync(abs)) err(`no existe el archivo de música ${m.archivo ?? m.file}`);
+		else if (!EXT_AUDIO.test(abs)) err(`formato de música no soportado: ${path.basename(abs)} (usa mp3, wav, flac u ogg)`);
+		return {archivo: abs, volumen: m.volumen ?? m.volume ?? 1, inicio: m.inicio ?? m.start ?? 0};
+	}
+	if (m && typeof m === 'object' && m.estilo) return normalizarMusica(m.estilo, ctx, err, profundidad + 1);
+	err(`music "${typeof m === 'string' ? m : JSON.stringify(m)}" no existe. Usa un estilo (${MUSICAS.join(', ')}), un archivo ("./musica/cancion.mp3"), un alias de \`musicas\` o false`);
+	return null;
+}
+
+function validarVideo(id, v, ctx) {
+	const err = (m) => ctx.errores.push(`${id}: ${m}`);
+	if (!v || typeof v !== 'object') return err('debe ser un objeto'), null;
+	if (!Array.isArray(v.scenes) || !v.scenes.length) return err('falta `scenes` (lista de escenas)'), null;
+	const estilo = v.estilo ?? ctx.estilo;
+	const clasico = estilo === 'datos-curiosos';
+	if (!ESTILOS.includes(estilo) && !ctx.estilosPropios[estilo]) err(`estilo "${estilo}" no existe. Opciones: ${[...ESTILOS, ...Object.keys(ctx.estilosPropios)].join(', ')}`);
+	const permitidos = clasico ? TIPOS_ESCENA : TIPOS_MOTOR;
+	const scenes = v.scenes.map((s0, i) => {
+		const n = `escena ${i + 1}`;
+		if (!s0 || typeof s0 !== 'object') return err(`${n} debe ser un objeto`), s0;
+		const s = {...s0, type: s0.type ?? (s0.capas ? 'capas' : undefined)};
+		if (!permitidos.includes(s.type))
+			err(
+				TIPOS_CLASICOS.includes(s.type)
+					? `${n}: type "${s.type}" es del estilo "datos-curiosos"; en "${estilo}" usa: ${TIPOS_MOTOR.join(', ')}`
+					: `${n}: type "${s.type}" no existe. Opciones: ${permitidos.join(', ')}`,
+			);
+		if (s.capas != null) validarCapas(s.capas, `${n}`, err);
+		const say = s.say ?? (s.type === 'cta' ? ctx.marca.cta : null);
+		if (!say || typeof say !== 'string') err(`${n}: falta \`say\` (lo que dice la voz${s.audio ? '; con `audio` sirve para los subtítulos' : ''})`);
+		for (const k of ['at', 'click']) if (s[k] != null && typeof s[k] !== 'string') err(`${n}: \`${k}\` debe ser una palabra del texto`);
+		const e = {...s, say};
+		if (s.audio != null) {
+			const abs = path.resolve(ctx.proyecto, s.audio);
+			if (!fs.existsSync(abs)) err(`${n}: no existe el audio ${s.audio}`);
+			else if (!EXT_AUDIO.test(abs)) err(`${n}: formato de audio no soportado: ${path.basename(abs)} (usa wav, mp3, flac u ogg)`);
+			e.audio = abs;
+		}
+		return e;
+	});
+	// la voz sintética solo hace falta si alguna escena no trae su propia grabación
+	const necesitaVoz = scenes.some((s) => s && !s.audio);
+	let voice = null;
+	if (v.voice != null) voice = normalizarVoz(v.voice, ctx, err);
+	else if (necesitaVoz) err('falta `voice` (p. ej. "em_alex", una mezcla [["em_alex", 0.6], ["am_michael", 0.4]], un .npy, o `audio` en cada escena)');
+	if (v.hud != null) validarCapas(v.hud, 'hud', err);
+	// archivos de assets/ que piden las escenas y el HUD: mejor avisar ahora que a mitad del render
+	revisarArchivos({scenes, hud: v.hud, tema: v.tema}, ctx.assetsDir, err);
+	return {...v, estilo, voice, music: normalizarMusica(v.music, ctx, err), scenes};
+}

package/lib/entorno.mjs

@@ -0,0 +1,93 @@
+// Rutas compartidas y detección de Python.
+//   ~/.morfeo (o MORFEO_HOME) guarda lo pesado, una sola vez para todos tus proyectos:
+//     python/   entorno virtual con kokoro-onnx, numpy, scipy...
+//     modelos/  voces Kokoro (~340 MB)
+//     whisper/  whisper.cpp + modelo (opcional, ~470 MB)
+import {execFileSync} from 'node:child_process';
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+
+export const PAQUETE = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+export const VERSION = JSON.parse(fs.readFileSync(path.join(PAQUETE, 'package.json'), 'utf8')).version;
+export const ES_WIN = process.platform === 'win32';
+
+export const HOME = process.env.MORFEO_HOME || path.join(os.homedir(), '.morfeo');
+export const VENV = path.join(HOME, 'python');
+export const MODELOS = path.join(HOME, 'modelos');
+export const WHISPER = path.join(HOME, 'whisper');
+
+export const PY_DIR = path.join(PAQUETE, 'python');
+export const REQUISITOS = path.join(PY_DIR, 'requirements.txt');
+export const ENTRADA_REMOTION = path.join(PAQUETE, 'remotion', 'index.ts');
+export const FUENTES = path.join(PAQUETE, 'assets', 'fuentes');
+
+export const ARCHIVOS_MODELO = ['kokoro-v1.0.onnx', 'voices-v1.0.bin'];
+export const URL_MODELOS = 'https://github.com/thewh1teagle/kokoro-onnx/releases/download/model-files-v1.0/';
+
+// kokoro-onnx 0.6.1 pide Python >=3.10,<3.14
+export const PY_MIN = [3, 10];
+export const PY_MAX = [3, 13];
+
+export const pythonVenv = () => (ES_WIN ? path.join(VENV, 'Scripts', 'python.exe') : path.join(VENV, 'bin', 'python'));
+
+const huellaRequisitos = () => crypto.createHash('sha1').update(fs.readFileSync(REQUISITOS)).digest('hex').slice(0, 12);
+const MARCA_VENV = () => path.join(VENV, '.morfeo-listo');
+export const venvListo = () => {
+	try {
+		return fs.existsSync(pythonVenv()) && fs.readFileSync(MARCA_VENV(), 'utf8') === huellaRequisitos();
+	} catch {
+		return false;
+	}
+};
+export const marcarVenvListo = () => fs.writeFileSync(MARCA_VENV(), huellaRequisitos());
+
+export const modelosListos = () => ARCHIVOS_MODELO.every((f) => fs.existsSync(path.join(MODELOS, f)));
+
+/** Versión [mayor, menor] de un ejecutable de Python, o null si no existe. */
+export function versionPython(cmd, args = []) {
+	try {
+		const out = execFileSync(cmd, [...args, '-c', 'import sys;print(sys.version_info[0], sys.version_info[1])'], {
+			encoding: 'utf8',
+			stdio: ['ignore', 'pipe', 'ignore'],
+			timeout: 15000,
+		});
+		const [a, b] = out.trim().split(/\s+/).map(Number);
+		return Number.isFinite(a) && Number.isFinite(b) ? [a, b] : null;
+	} catch {
+		return null;
+	}
+}
+
+const compatible = (v) => v && (v[0] > PY_MIN[0] || (v[0] === PY_MIN[0] && v[1] >= PY_MIN[1])) && (v[0] < PY_MAX[0] || (v[0] === PY_MAX[0] && v[1] <= PY_MAX[1]));
+
+/** Busca un Python compatible (3.10–3.13). Devuelve {cmd, args, version} o null. Respeta MORFEO_PYTHON. */
+export function buscarPython() {
+	const candidatos = [];
+	if (process.env.MORFEO_PYTHON) candidatos.push([process.env.MORFEO_PYTHON, []]);
+	const menores = [];
+	for (let m = PY_MAX[1]; m >= PY_MIN[1]; m--) menores.push(m);
+	if (ES_WIN) {
+		for (const m of menores) candidatos.push(['py', [`-3.${m}`]]);
+		candidatos.push(['python', []], ['python3', []]);
+	} else {
+		for (const m of menores) {
+			candidatos.push([`python3.${m}`, []]);
+			for (const pre of ['/opt/homebrew/bin', '/usr/local/bin', `/Library/Frameworks/Python.framework/Versions/3.${m}/bin`])
+				candidatos.push([`${pre}/python3.${m}`, []]);
+		}
+		candidatos.push(['python3', []], ['python', []]);
+	}
+	const vistos = [];
+	for (const [cmd, args] of candidatos) {
+		const v = versionPython(cmd, args);
+		if (!v) continue;
+		vistos.push(`${[cmd, ...args].join(' ')} → ${v.join('.')}`);
+		if (compatible(v)) return {cmd, args, version: v, vistos};
+	}
+	return {cmd: null, args: [], version: null, vistos};
+}
+
+export const formatoBytes = (n) => (n > 1e9 ? `${(n / 1e9).toFixed(1)} GB` : n > 1e6 ? `${Math.round(n / 1e6)} MB` : `${Math.round(n / 1e3)} KB`);