morfeo 0.3.4 → 0.5.0

package/bin/morfeo.mjs

@@ -13,7 +13,7 @@ Primeros pasos
   instalar              Prepara tu computadora: Python, voces, navegador y (opcional) Whisper
       --si                responde "sí" a todo        --whisper / --sin-whisper
   nuevo <carpeta>       Crea un proyecto de ejemplo listo para renderizar
-  nuevo-video <id>      Crea un video desde una base que ya renderiza (guion + mundo):  --look 2d | 3d
+  nuevo-video <id>      Crea un video desde una base que ya renderiza:  --look 2d | 3d | serie | biografia | escalada | mito | construiste
   doctor                Revisa qué está instalado y qué falta
 
 Videos
@@ -22,8 +22,10 @@ Videos
       --todos             regenera todos
       --solo-fallidos     reintenta solo los que fallaron en el último lote
       --gpu               usa la tarjeta de video (más rápido; si falla, quítalo)
-  revisar [id...]       Revisa la estructura (gancho, ritmo, preguntas, cierre) con reglas de videos virales
+  previa <id>           Solo el gancho (~8 s) para aprobarlo antes del render completo:  --hasta 6
+  revisar [id...]       Revisa la estructura (gancho, ritmo, preguntas, cierre), que la voz diga el guion y la zona segura
   hoja <id>             Hoja de contacto (PNG con 15 cuadros) para revisar un video de un vistazo
+      --zona              pinta en rojo lo que tapan los botones de TikTok, Reels y Shorts
       --desde 8 --hasta 11  solo ese tramo (segundos)   --cols 5 --filas 3
   studio                Abre el editor en el navegador para ver y ajustar en vivo
   estilos               Lista los estilos visuales disponibles
@@ -33,6 +35,10 @@ Videos
 Guiones
   guion "tema"          La IA (Claude) escribe un video completo sobre el tema
   guion --desde f.txt   Convierte tu guion en escenas (con IA; --sin-ia: una escena por frase)
+      --formula <id>      una fórmula de historia (construiste, serie, mito, misterio…)
+      --investigar        busca cada dato en la web con su fuente antes de escribir (van al texto del post)
+  formulas              Las fórmulas de historia medidas en videos de referencia
+  estilo                Abre una página para crear tu estilo: nombre, siglas, colores, letra, voz, ritmo y cierre
       --estilo documental   estilo visual (por defecto, el del proyecto)
       --imagenes            pide ilustraciones con IA (necesita OPENAI_API_KEY)
       --id nombre  --voz em_alex  --duracion 40  --idioma "inglés"  --tono "humor"
@@ -53,7 +59,7 @@ function opciones(argv) {
 			const [k, v] = a.slice(2).split('=');
 			const clave = k.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
 			const sig = argv[i + 1];
-			const conValor = ['proyecto', 'desde', 'id', 'voz', 'duracion', 'idioma', 'estilo', 'tono', 'variante', 'fuente', 'musica', 'titulo', 'modelo', 'puerto', 'hasta', 'cols', 'filas', 'look'];
+			const conValor = ['proyecto', 'desde', 'id', 'voz', 'duracion', 'idioma', 'estilo', 'tono', 'variante', 'fuente', 'musica', 'titulo', 'modelo', 'puerto', 'hasta', 'cols', 'filas', 'look', 'formula'];
 			if (v != null) op[clave] = v;
 			else if (conValor.includes(clave) && sig != null && !sig.startsWith('--')) op[clave] = argv[++i];
 			else op[clave] = true;
@@ -87,12 +93,11 @@ async function main() {
 			return nuevo(pos[0], op);
 		case 'nuevo-video': {
 			const {nuevoVideo} = await import('../lib/nuevo-video.mjs');
-			const look = op.look === true || op.look == null ? '2d' : String(op.look).toLowerCase();
+			const look = typeof op.formula === 'string' ? op.formula.toLowerCase() : op.look === true || op.look == null ? '2d' : String(op.look).toLowerCase();
 			const r = nuevoVideo({proyecto, id: pos[0], look});
 			const rel = (f) => path.relative(process.cwd(), f);
 			console.log(`Listo (${look}):
-  ${rel(r.guion)}   el guion: texto, tomas, rótulos y capas
-  ${rel(r.escena)}   el mundo (${r.componente}, ya registrado en morfeo.config.mjs)
+  ${rel(r.guion)}   el guion: texto, tomas, rótulos y capas${r.escena ? `\n  ${rel(r.escena)}   el mundo (${r.componente}, ya registrado en morfeo.config.mjs)` : ''}
 
 Pruébalo:  npx morfeo render ${pos[0]}   y revísalo:  npx morfeo hoja ${pos[0]}`);
 			return;
@@ -112,6 +117,14 @@ Pruébalo:  npx morfeo render ${pos[0]}   y revísalo:  npx morfeo hoja ${pos[0]
 			await render({proyecto, ids: pos, todos: !!op.todos || pos[0] === 'todos', soloFallidos: !!op.soloFallidos});
 			return;
 		}
+		case 'previa': {
+			if (op.gpu) process.env.MORFEO_GL = 'angle';
+			const {render} = await import('../lib/render.mjs');
+			const seg = op.hasta != null && op.hasta !== true ? Number(op.hasta) : true;
+			await render({proyecto, ids: pos, previa: seg});
+			console.log('Si el gancho te gusta:  npx morfeo render ' + pos.join(' '));
+			return;
+		}
 		case 'revisar': {
 			const {cargarProyecto} = await import('../lib/config.mjs');
 			const {revisarEstructura, consejosEnTexto, REGLAS} = await import('../lib/estructura.mjs');
@@ -141,7 +154,7 @@ Pruébalo:  npx morfeo render ${pos[0]}   y revísalo:  npx morfeo hoja ${pos[0]
 				const {salidaDe, ordenarSalida} = await import('../lib/salida.mjs');
 				ordenarSalida(p);
 				const video = /\.(mp4|mov|webm)$/i.test(id) ? path.resolve(id) : salidaDe(p, id);
-				console.log(hoja({video, cols: num(op.cols), filas: num(op.filas), desde: num(op.desde), hasta: num(op.hasta)}));
+				console.log(hoja({video, cols: num(op.cols), filas: num(op.filas), desde: num(op.desde), hasta: num(op.hasta), zona: !!op.zona}));
 			}
 			return;
 		}
@@ -191,6 +204,20 @@ Pruébalo:  npx morfeo render ${pos[0]}   y revísalo:  npx morfeo hoja ${pos[0]
 			console.log('\nÚsalo con  estilo: "documental"  en el video o en morfeo.config.mjs. Crea los tuyos con  estilos: {...}  en el config.');
 			return;
 		}
+		case 'estilo': {
+			const {abrirEditorDeEstilo} = await import('../lib/estilo-pagina.mjs');
+			const {buscarConfig} = await import('../lib/config.mjs');
+			if (!buscarConfig(proyecto)) throw new ErrorMorfeo('Corre esto dentro de un proyecto de Morfeo (npx morfeo nuevo mi-canal).');
+			await abrirEditorDeEstilo({proyecto, puerto: op.puerto ? Number(op.puerto) : 4321, abrir: !op.sinAbrir});
+			return;
+		}
+		case 'formulas':
+		case 'formula': {
+			const {FORMULAS} = await import('../lib/formulas.mjs');
+			for (const f of FORMULAS) console.log(`${f.id.padEnd(14)} ${f.nombre}  (${f.duracion[0]}–${f.duracion[1]} s · ${f.estilos.join(', ')})\n${' '.repeat(15)}${f.para}\n${' '.repeat(15)}Gancho: ${f.gancho}\n`);
+			console.log('Úsala:  npx morfeo guion "tu tema" --formula construiste   (o formula: \'construiste\' en el guion para que `revisar` la revise)');
+			return;
+		}
 		case 'guion':
 		case 'script':
 			return guion(pos, op, proyecto);
@@ -225,7 +252,7 @@ async function guion(pos, op, proyecto) {
 	if (texto && op.sinIa) r = guionSinIA(texto, {id: op.id, voz: op.voz, musica: op.musica, titulo: op.titulo, estilo});
 	else {
 		console.log(texto ? 'Claude está convirtiendo tu guion en escenas...' : `Claude está escribiendo un video sobre: ${tema}...`);
-		r = await guionConIA({tema, texto, idioma: op.idioma, duracion: op.duracion ? Number(op.duracion) : undefined, tono: op.tono, estilo, imagenes: !!op.imagenes, voz: op.voz, modelo: op.modelo});
+		r = await guionConIA({tema, texto, investigar: !!op.investigar, formula: op.formula, idioma: op.idioma, duracion: op.duracion ? Number(op.duracion) : undefined, tono: op.tono, estilo, imagenes: !!op.imagenes, voz: op.voz, modelo: op.modelo});
 	}
 	if (op.id) r.id = op.id;
 	const {cargarProyecto} = await import('../lib/config.mjs');
@@ -253,7 +280,7 @@ async function nuevo(carpeta, op) {
 	// dos videos de ejemplo con mundo y la estructura completa (los mismos que `morfeo nuevo-video`)
 	const {nuevoVideo} = await import('../lib/nuevo-video.mjs');
 	for (const look of ['2d', '3d']) nuevoVideo({proyecto: destino, id: `ejemplo-${look}`, look});
-	console.log(`Proyecto creado en ${carpeta}/\n\nSiguientes pasos:\n  cd ${carpeta}\n  npm install\n  npx morfeo instalar     (solo la primera vez en esta computadora)\n  npx morfeo render`);
+	console.log(`Proyecto creado en ${carpeta}/\n\nCon tu IA: abre la carpeta en Claude Code o Codex y escribe «Configúrame»; luego «Hazme un video sobre…».\n\nA mano:\n  cd ${carpeta}\n  npm install\n  npx morfeo instalar     (solo la primera vez en esta computadora)\n  npx morfeo estilo       (tu nombre, colores, letra y voz)\n  npx morfeo render`);
 }
 
 main().catch((e) => {

package/index.d.ts

@@ -64,11 +64,14 @@ interface CapaBase {
 	z?: number;
 	/** Efecto de sonido al aparecer. */
 	/** Efecto al aparecer. Sin decirlo, suena según cómo entra (rebote, caer, deslizar) o qué es (sello, dato, chip…); `false` lo apaga. */
-	sonido?: 'pop' | 'whoosh' | 'tick' | 'glitch' | 'ding' | 'golpe' | false;
+	sonido?: 'pop' | 'whoosh' | 'tick' | 'glitch' | 'ding' | 'golpe' | 'teclas' | 'radio' | 'obturador' | 'notificacion' | 'latido' | 'alarma' | 'reloj' | 'caja' | false;
 	/** 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>)[];
 }
 
+/** Mitad de una pantalla dividida: sus capas usan coordenadas de 1080×1920 recortadas a su mitad. */
+export interface Mitad {etiqueta?: string; color?: string; fondo?: string; capas?: Capa[]}
+
 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}}
@@ -92,6 +95,17 @@ export type Capa = CapaBase &
 		| {tipo: 'recipientes'; n?: number; valor?: number; forma?: 'garrafon' | 'vaso'; total?: string; color?: string; tamPieza?: number; duracion?: number}
 		| {tipo: 'ficha'; titulo?: string; foto?: string; campos: [string, string][]; ancho?: number; color?: string; fondoFoto?: string}
 		| {tipo: 'checklist'; items: (string | {texto: string; en?: Momento; pendiente?: boolean})[]; titulo?: string; tam?: number; color?: string; cada?: number}
+		| {tipo: 'bloqueo'; hora?: string; fecha?: string; /** Año abajo de la hora; [2026, 2031] salta de uno a otro en `anioEn`. */ anio?: number | string | (number | string)[]; anioEn?: Momento; notificaciones?: {app?: string; titulo?: string; texto?: string; en?: Momento}[]; fondo?: string; ancho?: number}
+		| {tipo: 'llamada'; estado?: 'entrante' | 'curso' | 'terminada'; nombre?: string; numero?: string; aviso?: string | false; /** Segundos con los que arranca el contador (curso) o duración final (terminada). */ desde?: number; duracion?: number; fondo?: string; ancho?: number}
+		| {tipo: 'recuento'; cabecera?: string; titulo?: string; opciones: {texto: string; valor: number; sub?: string}[]; color?: string; ancho?: number}
+		| {tipo: 'capitulo'; serie?: string; capitulo?: string; pregunta?: string; opciones?: {texto: string; sub?: string}[]; pie?: string; siguiente?: string; horario?: string; color?: string; ancho?: number}
+		| {tipo: 'vigilancia'; hora?: string; fecha?: string; etiqueta?: string; zoom?: number; mira?: boolean; miraX?: number; miraY?: number; color?: string}
+		| {tipo: 'cintillo'; nombre: string; cargo?: string; color?: string; tam?: number}
+		| {tipo: 'fecha'; anio?: number; de?: number; texto?: string; pie?: string; color?: string; tam?: number}
+		| {tipo: 'calendario'; titulo?: string; de?: number; a?: number; color?: string; tam?: number; duracion?: number}
+		| {tipo: 'dividida'; izq?: Mitad; der?: Mitad; arriba?: Mitad; abajo?: Mitad; vertical?: boolean; fondo?: string; linea?: string}
+		| {tipo: 'tierra'; lat: number; lon: number; etiqueta?: string; tam?: number; color?: string; girar?: boolean; /** Después del pin, vuela hacia el sitio: el globo crece × este valor. */ acercar?: number; duracionVuelo?: number}
+		| {tipo: 'linea'; hitos: {anio?: number | string; titulo?: string; texto?: string; en?: Momento}[]; color?: string; ancho?: number; paso?: number}
 		| {tipo: 'mapa'; ruta?: [number, number][]; distancia?: string; ancho?: number; color?: string; fondo?: string; inclinar?: number; duracion?: number}
 		| {tipo: 'cursor'; a: [number, number]; clic?: Momento; duracion?: number; tam?: number; color?: string}
 		| {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'; /** Achica la letra si no cabe (palabra más larga o más de `maxLineas` renglones). Por defecto sí. */ ajustar?: boolean; maxLineas?: number; alinear?: 'center' | 'left' | 'right'; interlineado?: number; escribir?: boolean | number; subrayado?: boolean}
@@ -176,6 +190,8 @@ interface EscenaMotorBase extends EscenaBase {
 	modoEn?: Momento;
 	/** Palabra o segundos en que vuelve a la imagen normal. */
 	modoHasta?: Momento;
+	/** Lugar (de `lugares` del video) donde pasa esta escena. */
+	lugar?: string;
 	/** Invertir la imagen en el modo (fondo claro → oscuro). Por defecto sí en looks claros (3d, maqueta, explicativo, infografia, minimal). */
 	modoInvertir?: boolean;
 	/** Palabras clave de la escena para los subtítulos (la que lleva caja o color de acento en cada frase). */
@@ -267,6 +283,12 @@ export interface Video {
 	 * El componente recibe además `escena` (1, 2, 3...), `tEscena`, `inicios` y `camara` (para paralaje).
 	 */
 	mundo?: Capa[];
+	/**
+	 * Varios mundos en un video (biografías, historias que cambian de sitio): `{cocina: [...], boda: [...]}`. Cada escena
+	 * elige uno con `lugar: 'boda'` (o sigue en el anterior). Cada lugar tiene su propia cámara; al cambiar, corta o usa
+	 * la `transicion` de la escena.
+	 */
+	lugares?: Record<string, Capa[]>;
 	/** Pastilla fija arriba para series: 'GYM CON CIENCIA · PARTE 5'. */
 	serie?: string;
 	/** Calidad de este video (ver `render.calidad`). */
@@ -274,6 +296,17 @@ export interface Video {
 	/** Para publicar: descripción y etiquetas (van a salida/<id>.txt junto con el título). */
 	descripcion?: string;
 	tags?: string[];
+	/** Texto grande de la portada (salida/<título> (portada).jpg); por defecto el título sin emojis. `*palabra*` en color. false = sin portada. */
+	portada?: string | false;
+	/** Ganchos de reserva: otras primeras frases para probar otra versión (van al final de salida/<título>.txt). */
+	hooks?: string[];
+	/** Fuentes de los datos del video (van en salida/<título>.txt): 'INEGI 2024' o {texto, url}. */
+	fuentes?: (string | {texto?: string; url?: string})[];
+	/**
+	 * Fórmula de historia (ver `npx morfeo formulas`): 'construiste' | 'recomendable' | 'escalada' | 'supervivencia' |
+	 * 'experimento' | 'misterio' | 'demuestralo' | 'mito' | 'roast' | 'serie' | 'biografia'. `revisar` da consejos propios.
+	 */
+	formula?: 'construiste' | 'recomendable' | 'escalada' | 'supervivencia' | 'experimento' | 'misterio' | 'demuestralo' | 'mito' | 'roast' | 'serie' | 'biografia';
 	/** 'largo' = explicador de 90–130 s (lo asume el estilo maqueta): cambia las reglas de `morfeo revisar`. */
 	formato?: 'corto' | 'largo';
 	/** Ajustes del estilo para este video (colores, fondo, subtítulos...). */

package/lib/calidad.mjs

@@ -0,0 +1,74 @@
+// Revisión automática de lo que no se ve a simple vista:
+//   - voz = guion: con Whisper, compara lo que la voz dijo de verdad con el `say` de cada escena (la voz sintética a
+//     veces se come palabras, lee mal cifras o siglas).
+//   - zona segura: lo que queda debajo de los botones y textos de TikTok, Reels y Shorts (columna derecha, pie con
+//     el nombre y la descripción, barra de arriba). Coordenadas en 1080×1920.
+import {normalizar} from './palabras.mjs';
+
+const NUMEROS = /^(uno|una|dos|tres|cuatro|cinco|seis|siete|ocho|nueve|diez|once|doce|trece|catorce|quince|dieci\w*|veint\w*|treinta|cuarenta|cincuenta|sesenta|setenta|ochenta|noventa|cien|ciento|\w*cientos|mil|millon\w*|porciento|ciento)$/;
+
+/** Zonas que tapan las apps (unión aproximada de TikTok, Instagram Reels y YouTube Shorts). */
+export const ZONAS = [
+	{id: 'derecha', nombre: 'botones de la derecha (me gusta, comentar, compartir)', x0: 930, y0: 760, x1: 1080, y1: 1660},
+	{id: 'pie', nombre: 'nombre de la cuenta y descripción', x0: 0, y0: 1640, x1: 1080, y1: 1920},
+	{id: 'arriba', nombre: 'barra de arriba (Siguiendo / Para ti)', x0: 0, y0: 0, x1: 1080, y1: 150},
+];
+
+/** Medida aproximada de una capa: su caja centrada en (x, y). */
+function caja(c) {
+	const ancho = Number(c.ancho ?? c.tam ?? 300);
+	const alto = Number(c.alto ?? c.tam ?? ancho * 0.4);
+	const x = Number(c.x ?? 540);
+	const y = Number(c.y ?? 960);
+	return {x0: x - ancho / 2, y0: y - alto / 2, x1: x + ancho / 2, y1: y + alto / 2, x, y};
+}
+const pisa = (b, z, margen = 0.25) => {
+	const ix = Math.max(0, Math.min(b.x1, z.x1) - Math.max(b.x0, z.x0));
+	const iy = Math.max(0, Math.min(b.y1, z.y1) - Math.max(b.y0, z.y0));
+	const area = Math.max(1, (b.x1 - b.x0) * (b.y1 - b.y0));
+	return (ix * iy) / area > margen;
+};
+
+// capas que llenan la pantalla o viven en el mundo: no se revisan
+const LLENAS = new Set(['particulas', 'escenario', 'vigilancia', 'dividida', 'componente', 'grupo', 'escena3d']);
+
+/**
+ * Capas cuyo texto o dato queda debajo de la interfaz de las apps.
+ * @returns {{id: string, nivel: 'aviso' | 'idea', texto: string}[]}
+ */
+export function revisarZona(v) {
+	const out = [];
+	(v.scenes ?? []).forEach((s, i) => {
+		for (const c of s.capas ?? []) {
+			if (!c || LLENAS.has(c.tipo) || c.enMundo || c.x == null || c.y == null) continue;
+			const b = caja(c);
+			for (const z of ZONAS) if (pisa(b, z)) out.push({id: 'zona', nivel: 'aviso', texto: `Escena ${i + 1}: la capa ${c.tipo}${c.texto ? ` "${String(c.texto).slice(0, 24)}"` : ''} (x ${c.x}, y ${c.y}) queda bajo ${z.nombre}. Muévela al centro.`});
+		}
+		if (s.rotuloY != null && (s.rotuloY > 1600 || s.rotuloY < 160)) out.push({id: 'zona', nivel: 'aviso', texto: `Escena ${i + 1}: el rótulo (y ${s.rotuloY}) queda bajo la interfaz de la app.`});
+	});
+	const sy = v.tema?.subtitulos?.y;
+	if (sy != null && (sy > 1600 || sy < 160)) out.push({id: 'zona', nivel: 'aviso', texto: `Los subtítulos (y ${sy}) quedan bajo la interfaz de la app: entre 200 y 1550 se leen en todas.`});
+	return out;
+}
+
+/**
+ * Compara lo que la voz dijo (palabras de Whisper en datos.json) con el `say` de cada escena. Solo con tiempos reales.
+ * @returns {{id: string, nivel: 'aviso' | 'idea', texto: string}[]}
+ */
+export function revisarVoz(v, d) {
+	if (!d?.escenas || !d.whisper) return [];
+	const out = [];
+	(v.scenes ?? []).forEach((s, i) => {
+		const e = d.escenas[i];
+		if (!e?.palabras?.length || s.audio || !s.say) return;
+		const esperadas = String(s.say).split(/\s+/).map(normalizar).filter((w) => w.length > 2);
+		if (esperadas.length < 3) return;
+		const dichas = e.palabras.map(([w]) => normalizar(w));
+		// Whisper escribe las cifras con números ("33"): las palabras de número cuentan como dichas si hay cifras
+		const hayCifras = dichas.some((x) => /\d/.test(x));
+		const faltan = esperadas.filter((w) => !(hayCifras && NUMEROS.test(w)) && !dichas.some((x) => x.startsWith(w.slice(0, 5)) || w.startsWith(x.slice(0, 5))));
+		if (faltan.length / esperadas.length > 0.25)
+			out.push({id: 'voz', nivel: 'aviso', texto: `Escena ${i + 1}: la voz no dijo bien ${faltan.length} de ${esperadas.length} palabras (${faltan.slice(0, 4).join(', ')}). Escucha esa escena; escribe las cifras y siglas con letras en \`say\`.`});
+	});
+	return out;
+}

package/lib/config.mjs

@@ -1,4 +1,6 @@
 // Carga y valida morfeo.config.mjs del proyecto del usuario.
+import {IDS_FORMULA} from './formulas.mjs';
+import {aplicarEstiloPropio, leerEstiloPropio} from './estilo-propio.mjs';
 import fs from 'node:fs';
 import path from 'node:path';
 import {pathToFileURL} from 'node:url';
@@ -25,7 +27,7 @@ export const TIPOS_ESCENA = [...new Set([...TIPOS_CLASICOS, ...TIPOS_MOTOR])];
 export const ROTULOS = ['normal', 'contorno', 'pastilla', 'sello', 'paso', 'pixel'];
 export const MODOS = ['rayosx', 'plano', 'holograma'];
 export const ESTILOS = ['datos-curiosos', 'explicativo', 'documental', 'ilustrado', 'historia', 'mesa', 'serie', 'infografia', '3d', 'maqueta', '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', 'escenario', 'recurso', 'dato', 'medida', 'trazo', 'contorno', 'fuente', 'seccion', 'insignia', 'sello', 'cursor', 'terminal', 'nombre', 'accion', 'reloj', 'cronometro', 'termometro', 'recipientes', 'ficha', 'checklist', 'mapa'];
+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', 'escenario', 'recurso', 'dato', 'medida', 'trazo', 'contorno', 'fuente', 'seccion', 'insignia', 'sello', 'cursor', 'terminal', 'nombre', 'accion', 'reloj', 'cronometro', 'termometro', 'recipientes', 'ficha', 'checklist', 'mapa', 'bloqueo', 'llamada', 'recuento', 'capitulo', 'vigilancia', 'cintillo', 'fecha', 'calendario', 'dividida', 'tierra', 'linea'];
 export const ESCENARIOS = ['bosque', 'cuarto', 'departamento', 'tunel', 'pasillo'];
 export const FORMAS_3D = ['moneda', 'billete', 'lingote', 'cubo', 'esfera', 'corazon', 'estrella', 'rayo', 'diamante', 'trofeo', 'cohete', 'foco', 'reloj', 'planeta', 'arbol', 'nube', 'regalo', 'llave', 'candado', 'casa', 'libro', 'globo', 'medalla', 'escudo', 'pin', 'tuberia', 'muro', 'viga', 'columna', 'escalera', 'losa', 'tanque', 'suelo'];
 export const PROVEEDORES_VOZ = ['kokoro', 'elevenlabs', 'openai'];
@@ -79,6 +81,12 @@ export async function cargarProyecto(proyecto = process.cwd()) {
 	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({...}))`);
+	// estilo.json (de `morfeo estilo`): nombre, siglas, colores, letra, voz, ritmo y cierre encima del config
+	try {
+		cfg = aplicarEstiloPropio(cfg, leerEstiloPropio(proyecto), proyecto);
+	} catch (e) {
+		throw new ErrorMorfeo(e.message);
+	}
 
 	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()
@@ -102,6 +110,9 @@ export async function cargarProyecto(proyecto = process.cwd()) {
 		redes: m.redes ?? '',
 		seguir: m.seguir ?? '+ SEGUIR',
 		siguiendo: m.siguiendo ?? 'SIGUIENDO',
+		...(m.siglas ? {siglas: String(m.siglas)} : {}),
+		...(m.color ? {color: String(m.color)} : {}),
+		...(m.letra ? {letra: String(m.letra)} : {}),
 		etiqueta: m.etiqueta ?? 'DATO CURIOSO',
 		cta: m.cta ?? (m.nombre ? `Sígueme en ${m.nombre} para más.` : 'Sígueme para más.'),
 	};
@@ -111,7 +122,7 @@ export async function cargarProyecto(proyecto = process.cwd()) {
 	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, personajes: cfg.personajes ?? {}, componentes: Object.keys(cfg.componentes ?? {})};
+	const ctx = {proyecto, marca, propio: cfg.__estiloPropio ?? null, voces: cfg.voces ?? {}, musicas: cfg.musicas ?? {}, errores, estilo, estilosPropios, assetsDir, personajes: cfg.personajes ?? {}, componentes: Object.keys(cfg.componentes ?? {})};
 	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 ?? {})) {
@@ -160,6 +171,7 @@ export async function cargarProyecto(proyecto = process.cwd()) {
 			concurrencia: Number(process.env.MORFEO_CONCURRENCIA) || r.concurrencia || null, // null = Morfeo elige según la máquina y el modo (ver render.mjs)
 			miniatura: r.miniatura ?? true,
 			consejos: r.consejos ?? true,
+			portada: r.portada ?? true,
 			// 'titulo' (por defecto): salida/<Título del video>.mp4, listo para subir · 'id': salida/<id>.mp4
 			nombreArchivo: r.nombreArchivo ?? 'titulo',
 		},
@@ -228,6 +240,11 @@ function validarCapas(capas, donde, err, comps) {
 			if (!c.buscar) err(`${d}: falta \`buscar\` (qué objeto: 'tubería', 'casa', 'pizza'...)`);
 			if (c.estilo && !['2d', '3d', 'realista'].includes(c.estilo)) err(`${d}: estilo "${c.estilo}" no existe. Usa '2d', '3d' o 'realista'`);
 		}
+		if (c.tipo === 'dividida') for (const lado of ['izq', 'der', 'arriba', 'abajo']) if (c[lado]?.capas) validarCapas(c[lado].capas, `${d}, ${lado}`, err, comps);
+		if (c.tipo === 'linea' && (!Array.isArray(c.hitos) || !c.hitos.length)) err(`${d}: \`linea\` necesita \`hitos\`: [{anio: 1963, texto: '…', en: 'palabra'}]`);
+		if (c.tipo === 'cintillo' && !c.nombre) err(`${d}: \`cintillo\` necesita \`nombre\``);
+		if (c.tipo === 'llamada' && c.estado != null && !['entrante', 'curso', 'terminada'].includes(c.estado)) err(`${d}: estado "${c.estado}" no existe (entrante, curso o terminada)`);
+		if (c.tipo === 'tierra' && (!esNum(c.lat) || !esNum(c.lon))) err(`${d}: \`tierra\` necesita \`lat\` y \`lon\` (números)`);
 		if (c.capas) validarCapas(c.capas, d, err, comps);
 		if (c.capa) validarCapas([c.capa], d, err, comps);
 	});
@@ -298,7 +315,9 @@ 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;
+	// con estilo.json, un video viejo de escenas clásicas (title, text, card…) sin `estilo` sigue en su estilo de antes
+	const deClasicas = v.scenes.some((s) => s && TIPOS_CLASICOS.includes(s.type) && s.type !== 'cta' && !TIPOS_MOTOR.includes(s.type));
+	const estilo = v.estilo ?? (ctx.propio && deClasicas ? ctx.propio.estiloAnterior ?? 'datos-curiosos' : 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;
@@ -315,6 +334,7 @@ function validarVideo(id, v, ctx) {
 			);
 		if (s.capas != null) validarCapas(s.capas, `${n}`, err, ctx.componentes);
 		if (s.rotulo != null && typeof s.rotulo !== 'string') err(`${n}: \`rotulo\` debe ser un texto corto ('¿CUÁNTO *SUBIÓ*?')`);
+		if (s.lugar != null && !(v.lugares && typeof v.lugares === 'object' && v.lugares[s.lugar])) err(`${n}: el lugar "${s.lugar}" no está en \`lugares\`${v.lugares && typeof v.lugares === 'object' ? ` (hay: ${Object.keys(v.lugares).join(', ')})` : ''}`);
 		if (s.rotuloEstilo != null && !ROTULOS.includes(s.rotuloEstilo)) err(`${n}: rotuloEstilo "${s.rotuloEstilo}" no existe. Opciones: ${ROTULOS.join(', ')}`);
 		if (s.rotuloPaso != null && s.rotuloEstilo !== 'paso') err(`${n}: \`rotuloPaso\` es para rotuloEstilo: 'paso'`);
 		if (s.modo != null) {
@@ -329,7 +349,7 @@ function validarVideo(id, v, ctx) {
 				if (tm.zoom != null && tm.zoom <= 0) err(`${n}: \`toma.zoom\` debe ser mayor que 0`);
 				if (tm.a != null) for (const k of ['x', 'y', 'zoom', 'giro']) if (tm.a[k] != null && !esNum(tm.a[k])) err(`${n}: \`toma.a.${k}\` debe ser un número`);
 			}
-			if (!v.mundo?.length) err(`${n}: \`toma\` mueve la cámara del \`mundo\`, pero el video no tiene \`mundo\``);
+			if (!v.mundo?.length && !v.lugares) err(`${n}: \`toma\` mueve la cámara del \`mundo\`, pero el video no tiene \`mundo\` ni \`lugares\``);
 		}
 		if (s.type === 'cta' && s.pide != null) {
 			if (!['comenta', 'comparte'].includes(s.pide)) err(`${n}: \`pide\` debe ser 'comenta' o 'comparte'`);
@@ -350,20 +370,32 @@ function validarVideo(id, v, ctx) {
 	// 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;
+	// sin `voice`, la del estilo propio (estilo.json)
+	if (v.voice == null && ctx.propio?.voz) v = {...v, voice: ctx.propio.voz};
+	if (v.speed == null && ctx.propio?.velocidad) v = {...v, speed: ctx.propio.velocidad};
 	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, ctx.componentes);
+	if (v.lugares != null) {
+		if (typeof v.lugares !== 'object' || Array.isArray(v.lugares) || !Object.keys(v.lugares).length) err("`lugares` debe ser un objeto con un mundo por nombre: {cocina: [...], boda: [...]}");
+		else for (const [nombre, capas] of Object.entries(v.lugares)) validarCapas(capas, `lugares.${nombre}`, err, ctx.componentes);
+		if (clasico) err('`lugares` es del motor de capas: usa un estilo como ilustrado, 3d o mesa (no "datos-curiosos")');
+	}
 	if (v.mundo != null) {
 		validarCapas(v.mundo, 'mundo', err, ctx.componentes);
 		if (clasico) err('`mundo` es del motor de capas: usa un estilo como ilustrado, 3d o mesa (no "datos-curiosos")');
 	}
+	if (v.formula != null && !IDS_FORMULA.includes(v.formula)) err(`\`formula\` "${v.formula}" no existe. Opciones: ${IDS_FORMULA.join(', ')} (npx morfeo formulas)`);
 	if (v.serie != null && typeof v.serie !== 'string') err("`serie` debe ser un texto ('GYM CON CIENCIA · PARTE 5')");
 	if (v.title != null && typeof v.title !== 'string') err('`title` debe ser un texto (también es el nombre del archivo del video)');
 	if (v.calidad != null && !['alta', 'media', 'ligera'].includes(v.calidad)) err("`calidad` debe ser 'alta', 'media' o 'ligera'");
+	if (v.portada != null && v.portada !== false && typeof v.portada !== 'string') err('`portada` debe ser un texto (el título grande de la portada) o false');
+	if (v.hooks != null && (!Array.isArray(v.hooks) || v.hooks.some((x) => typeof x !== 'string'))) err("`hooks` debe ser una lista de textos (ganchos de reserva)");
+	if (v.fuentes != null && (!Array.isArray(v.fuentes) || v.fuentes.some((x) => typeof x !== 'string' && !(x && typeof x === 'object' && (x.texto || x.url))))) err("`fuentes` debe ser una lista: ['INEGI 2024'] o [{texto: 'INEGI', url: 'https://…'}]");
 	if (v.tags != null && (!Array.isArray(v.tags) || v.tags.some((x) => typeof x !== 'string'))) err("`tags` debe ser una lista de textos (['curiosidades', 'ciencia'])");
 	// archivos de assets/ que piden las escenas y el HUD: mejor avisar ahora que a mitad del render
-	revisarArchivos({scenes, hud: v.hud, mundo: v.mundo, tema: v.tema}, ctx.assetsDir, err);
-	revisarPersonajes({scenes, hud: v.hud, mundo: v.mundo}, ctx.personajes, err);
+	revisarArchivos({scenes, hud: v.hud, mundo: v.mundo, lugares: v.lugares, tema: v.tema}, ctx.assetsDir, err);
+	revisarPersonajes({scenes, hud: v.hud, mundo: v.mundo, lugares: v.lugares}, ctx.personajes, err);
 	revisarEscenarios({scenes, hud: v.hud, tema: v.tema}, err);
 	return {...v, estilo, voice, music: normalizarMusica(v.music, ctx, err), scenes};
 }

package/lib/estilo-pagina.mjs

@@ -0,0 +1,174 @@
+// `morfeo estilo`: abre una página en tu computadora para crear el estilo del canal (nombre, siglas, colores, letra,
+// voz, ritmo y cierre) con una vista previa en vivo. Al guardar escribe estilo.json en el proyecto y baja la letra
+// elegida a fuentes/. No sale nada de tu computadora salvo la descarga de la letra (Google Fonts, licencia libre).
+import fs from 'node:fs';
+import http from 'node:http';
+import path from 'node:path';
+import {spawn} from 'node:child_process';
+import {ARCHIVO_ESTILO, LETRAS, RITMOS, leerEstiloPropio} from './estilo-propio.mjs';
+import {ESTILOS} from './config.mjs';
+
+const VOCES_KOKORO = {
+	'Narrador (mezcla)': [['em_alex', 0.6], ['am_michael', 0.4]],
+	'Narradora (mezcla)': [['ef_dora', 0.6], ['af_heart', 0.4]],
+	'Alex (hombre, español)': 'em_alex',
+	'Santa (hombre, español)': 'em_santa',
+	'Dora (mujer, español)': 'ef_dora',
+};
+
+const esc = (s) => String(s ?? '').replace(/[&<>"]/g, (c) => ({'&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;'})[c]);
+
+function pagina(actual) {
+	const a = actual ?? {};
+	const vozActual = typeof a.voz === 'object' && a.voz?.proveedor === 'elevenlabs' ? 'eleven' : JSON.stringify(a.voz ?? VOCES_KOKORO['Narrador (mezcla)']);
+	const familias = Object.keys(LETRAS).filter((f) => f !== 'Montserrat').map((f) => f.replace(/ /g, '+')).join('&family=');
+	return `<!doctype html><html lang="es"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
+<title>Tu estilo · Morfeo</title>
+<link rel="stylesheet" href="https://fonts.googleapis.com/css2?family=${familias}&family=Montserrat:wght@500;700;900&display=swap">
+<style>
+:root{--fondo:#0f0d15;--panel:#17151f;--linea:rgba(241,236,228,.12);--tinta:#f1ece4;--tenue:#a49dae;--acento:${esc(a.colores?.acento ?? '#FFD400')}}
+*{box-sizing:border-box}body{margin:0;background:var(--fondo);color:var(--tinta);font-family:Montserrat,system-ui,sans-serif}
+main{max-width:1100px;margin:0 auto;padding:40px 24px 80px;display:grid;grid-template-columns:1fr 360px;gap:48px}
+h1{font-weight:900;font-size:34px;margin:0 0 6px;letter-spacing:-.02em}p.sub{color:var(--tenue);margin:0 0 30px}
+fieldset{border:1px solid var(--linea);border-radius:16px;padding:18px 20px 20px;margin:0 0 18px}
+legend{font-size:12px;letter-spacing:.14em;text-transform:uppercase;color:var(--tenue);padding:0 8px}
+label{display:block;font-size:14px;font-weight:700;margin:12px 0 6px}
+input[type=text],select{width:100%;background:var(--panel);border:1px solid var(--linea);color:var(--tinta);border-radius:10px;padding:11px 12px;font:inherit}
+.fila{display:grid;grid-template-columns:1fr 1fr;gap:14px}.colores{display:flex;gap:12px;align-items:center}
+input[type=color]{width:52px;height:40px;border:none;background:none;padding:0;cursor:pointer}
+.ritmos{display:flex;gap:8px}.ritmos label{flex:1;margin:0;text-align:center;border:1px solid var(--linea);border-radius:10px;padding:10px;cursor:pointer;font-weight:600}
+.ritmos input{display:none}.ritmos input:checked+span{color:var(--acento)}.ritmos label:has(input:checked){border-color:var(--acento)}
+button{margin-top:10px;background:var(--acento);color:#111;border:none;border-radius:12px;padding:14px 26px;font:900 16px Montserrat;cursor:pointer}
+.nota{font-size:13px;color:var(--tenue);margin-top:6px}
+.tel{position:sticky;top:30px;width:360px;aspect-ratio:9/16;border-radius:34px;padding:9px;background:#0b0a10;box-shadow:0 30px 60px rgba(0,0,0,.5),inset 0 0 0 2px #2a2733}
+.pantalla{position:relative;width:100%;height:100%;border-radius:27px;overflow:hidden;background:radial-gradient(ellipse at 50% 30%,#2b2f55,#0c0d1a)}
+.marca{position:absolute;left:16px;top:44px;display:flex;align-items:center;gap:8px;font-weight:800;font-size:14px}
+.av{width:34px;height:34px;border-radius:50%;border:2px solid #fff;display:grid;place-items:center;font-weight:900;font-size:13px;background:linear-gradient(var(--acento),#111);color:#fff}
+.rotulo{position:absolute;left:18px;right:18px;top:38%;text-align:center;font-size:42px;line-height:1;text-transform:uppercase;color:#fff;-webkit-text-stroke:2px #000;paint-order:stroke fill}
+.rotulo b{color:var(--acento);font-weight:inherit}
+.subs{position:absolute;left:0;right:0;top:62%;text-align:center;font-weight:800;font-size:17px;color:#fff}.subs span{background:var(--sub,#4C8DFF);padding:1px 6px;border-radius:4px}
+.cierre{position:absolute;left:18px;right:18px;bottom:40px;text-align:center;font-size:13px;color:var(--tenue)}
+.ok{display:none;margin-top:14px;padding:12px 14px;border-radius:10px;background:rgba(48,164,108,.15);color:#7ee0a8;font-weight:700}
+@media (max-width:860px){main{grid-template-columns:1fr}.tel{position:relative;top:0;margin:0 auto}}
+</style></head><body><main>
+<form id="f">
+<h1>Tu estilo</h1><p class="sub">Así se verán y sonarán todos tus videos. Puedes cambiarlo cuando quieras.</p>
+<fieldset><legend>Canal</legend>
+<div class="fila"><div><label>Nombre</label><input type="text" name="nombre" value="${esc(a.nombre ?? '')}" placeholder="Datos Rápidos"></div>
+<div><label>Siglas (sin logo)</label><input type="text" name="siglas" maxlength="3" value="${esc(a.siglas ?? '')}" placeholder="DR"></div></div>
+<label>Redes (salen en el cierre)</label><input type="text" name="redes" value="${esc(a.redes ?? '')}" placeholder="TikTok @datosrapidos · YT @datosrapidos">
+</fieldset>
+<fieldset><legend>Cómo se ve</legend>
+<label>Estilo base</label><select name="base">${ESTILOS.filter((e) => e !== 'datos-curiosos').map((e) => `<option ${e === (a.base ?? 'documental') ? 'selected' : ''}>${e}</option>`).join('')}</select>
+<label>Colores</label><div class="colores"><input type="color" name="acento" value="${esc(a.colores?.acento ?? '#FFD400')}"><span class="nota">acento (cifras, palabra clave, siglas)</span>
+<input type="color" name="subtitulo" value="${esc(a.colores?.subtitulo ?? '#4C8DFF')}"><span class="nota">caja del subtítulo</span></div>
+<label>Letra de títulos</label><select name="letra">${Object.keys(LETRAS).map((f) => `<option ${f === (a.letra ?? 'Anton') ? 'selected' : ''}>${f}</option>`).join('')}</select>
+</fieldset>
+<fieldset><legend>Cómo suena</legend>
+<label>Voz</label><select name="voz">${Object.entries(VOCES_KOKORO).map(([n, v]) => `<option value='${esc(JSON.stringify(v))}' ${JSON.stringify(v) === vozActual ? 'selected' : ''}>${n} · gratis</option>`).join('')}<option value="eleven" ${vozActual === 'eleven' ? 'selected' : ''}>Mi voz de ElevenLabs</option></select>
+<div id="eleven" style="display:${vozActual === 'eleven' ? 'block' : 'none'}"><label>ID de la voz en ElevenLabs</label><input type="text" name="elevenId" value="${esc(a.voz?.voz ?? '')}" placeholder="21m00Tcm4TlvDq8ikWAM"><p class="nota">La clave va en el .env del proyecto: ELEVENLABS_API_KEY=…</p></div>
+<label>Ritmo</label><div class="ritmos">${Object.keys(RITMOS).map((r) => `<label><input type="radio" name="ritmo" value="${r}" ${r === (a.ritmo ?? 'natural') ? 'checked' : ''}><span>${r === 'agil' ? 'Ágil' : r[0].toUpperCase() + r.slice(1)}</span></label>`).join('')}</div>
+<label>Frase de cierre</label><input type="text" name="cierre" value="${esc(a.cierre ?? '')}" placeholder="Guárdalo para cuando te pregunten.">
+</fieldset>
+<button type="submit">Guardar estilo</button><div class="ok" id="ok"></div>
+</form>
+<div><div class="tel"><div class="pantalla"><div class="marca"><div class="av" id="pav">M</div><span id="pnom">Mi Canal</span></div>
+<div class="rotulo" id="prot">MIL <b>TRESCIENTOS</b> METROS</div><div class="subs">a casi <span>mil trescientos</span> metros</div><div class="cierre" id="pcie"></div></div></div></div>
+</main>
+<script>
+const f=document.getElementById('f');
+function vista(){const d=new FormData(f);document.documentElement.style.setProperty('--acento',d.get('acento'));document.querySelector('.subs').style.setProperty('--sub',d.get('subtitulo'));
+document.getElementById('pnom').textContent=d.get('nombre')||'Mi Canal';document.getElementById('pav').textContent=(d.get('siglas')||(d.get('nombre')||'M')[0]).toUpperCase();
+document.getElementById('prot').style.fontFamily='"'+d.get('letra')+'"';document.getElementById('pcie').textContent=d.get('cierre')||'';
+document.getElementById('eleven').style.display=d.get('voz')==='eleven'?'block':'none';}
+f.addEventListener('input',vista);vista();
+f.addEventListener('submit',async(e)=>{e.preventDefault();const d=Object.fromEntries(new FormData(f));const r=await fetch('/guardar',{method:'POST',headers:{'content-type':'application/json'},body:JSON.stringify(d)});
+const t=await r.text();const ok=document.getElementById('ok');ok.style.display='block';ok.textContent=t;});
+</script></body></html>`;
+}
+
+/** Arma estilo.json desde el formulario. */
+export function estiloDesdeFormulario(d) {
+	let voz;
+	if (d.voz === 'eleven') voz = {proveedor: 'elevenlabs', voz: String(d.elevenId ?? '').trim()};
+	else {
+		try {
+			voz = JSON.parse(d.voz);
+		} catch {
+			voz = 'em_alex';
+		}
+	}
+	return {
+		nombre: String(d.nombre ?? '').trim(),
+		siglas: String(d.siglas ?? '').trim().toUpperCase().slice(0, 3),
+		redes: String(d.redes ?? '').trim(),
+		base: ESTILOS.includes(d.base) ? d.base : 'documental',
+		colores: {acento: d.acento || '#FFD400', subtitulo: d.subtitulo || '#4C8DFF'},
+		letra: LETRAS[d.letra] !== undefined ? d.letra : 'Anton',
+		voz,
+		ritmo: RITMOS[d.ritmo] ? d.ritmo : 'natural',
+		cierre: String(d.cierre ?? '').trim(),
+	};
+}
+
+/** Baja la letra a fuentes/ del proyecto (si no viene ya en el paquete o ya está). */
+export async function bajarLetra(proyecto, letra) {
+	const ruta = LETRAS[letra];
+	if (!ruta) return null;
+	const destino = path.join(proyecto, 'fuentes', `${letra.replace(/\s+/g, '')}.ttf`);
+	if (fs.existsSync(destino)) return destino;
+	const r = await fetch(`https://raw.githubusercontent.com/google/fonts/main/${ruta}`);
+	if (!r.ok) throw new Error(`no pude bajar la letra ${letra} (${r.status})`);
+	fs.mkdirSync(path.dirname(destino), {recursive: true});
+	fs.writeFileSync(destino, Buffer.from(await r.arrayBuffer()));
+	return destino;
+}
+
+export function abrirNavegador(url) {
+	const cmd = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'cmd' : 'xdg-open';
+	const args = process.platform === 'win32' ? ['/c', 'start', '', url] : [url];
+	try {
+		spawn(cmd, args, {stdio: 'ignore', detached: true}).unref();
+	} catch {}
+}
+
+/** Levanta la página en localhost y espera a que se guarde (o a Ctrl+C). */
+export function abrirEditorDeEstilo({proyecto, puerto = 4321, log = console.log, abrir = true}) {
+	return new Promise((resolve, reject) => {
+		const srv = http.createServer(async (req, res) => {
+			try {
+				if (req.method === 'GET' && (req.url === '/' || req.url?.startsWith('/?'))) {
+					res.writeHead(200, {'content-type': 'text/html; charset=utf-8'});
+					return res.end(pagina(leerEstiloPropio(proyecto)));
+				}
+				if (req.method === 'POST' && req.url === '/guardar') {
+					let cuerpo = '';
+					for await (const trozo of req) cuerpo += trozo;
+					const e = estiloDesdeFormulario(JSON.parse(cuerpo));
+					let aviso = '';
+					try {
+						await bajarLetra(proyecto, e.letra);
+					} catch (err) {
+						aviso = ` (la letra no se pudo bajar: ${err.message}; se usará Anton)`;
+						e.letra = 'Anton';
+					}
+					fs.writeFileSync(path.join(proyecto, ARCHIVO_ESTILO), JSON.stringify(e, null, '\t') + '\n');
+					log(`Guardado ${ARCHIVO_ESTILO}${aviso}. Ya puedes cerrar la página.`);
+					res.writeHead(200, {'content-type': 'text/plain; charset=utf-8'});
+					res.end(`Listo: tus videos ya salen con este estilo${aviso}. Vuelve a la terminal o a tu IA y pide un video.`);
+					setTimeout(() => srv.close(() => resolve(e)), 300);
+					return;
+				}
+				res.writeHead(404).end();
+			} catch (err) {
+				res.writeHead(500, {'content-type': 'text/plain; charset=utf-8'}).end(String(err.message));
+			}
+		});
+		srv.on('error', reject);
+		srv.listen(puerto, '127.0.0.1', () => {
+			const url = `http://localhost:${puerto}/`;
+			log(`Abre ${url} para crear tu estilo (Ctrl+C para salir).`);
+			if (abrir) abrirNavegador(url);
+		});
+	});
+}