morfeo 0.4.0 → 0.5.0

package/bin/morfeo.mjs

@@ -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
@@ -34,7 +36,9 @@ 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"
@@ -113,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');
@@ -142,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;
 		}
@@ -192,6 +204,13 @@ 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');
@@ -233,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, 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});
+		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');
@@ -261,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,7 +64,7 @@ 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>)[];
 }
@@ -104,7 +104,8 @@ export type Capa = CapaBase &
 		| {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}
+		| {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}
@@ -295,6 +296,12 @@ 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.

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,5 +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';
@@ -26,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', 'bloqueo', 'llamada', 'recuento', 'capitulo', 'vigilancia', 'cintillo', 'fecha', 'calendario', 'dividida', 'tierra'];
+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'];
@@ -80,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()
@@ -103,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.'),
 	};
@@ -112,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 ?? {})) {
@@ -161,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',
 		},
@@ -230,6 +241,7 @@ function validarCapas(capas, donde, err, comps) {
 			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)`);
@@ -303,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;
@@ -356,6 +370,9 @@ 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);
@@ -372,6 +389,9 @@ function validarVideo(id, v, ctx) {
 	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, lugares: v.lugares, tema: v.tema}, ctx.assetsDir, err);

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);
+		});
+	});
+}

package/lib/estilo-propio.mjs

@@ -0,0 +1,70 @@
+// Estilo propio del canal (estilo.json en la carpeta del proyecto, lo escribe `morfeo estilo`): nombre, siglas,
+// colores, letra, voz, ritmo y frase de cierre. Se aplica al cargar el proyecto, encima de morfeo.config.mjs:
+// todos los videos salen así salvo que uno diga otra cosa (su `estilo`, `voice` o `speed`).
+import fs from 'node:fs';
+import path from 'node:path';
+
+export const ARCHIVO_ESTILO = 'estilo.json';
+
+/** Letras para títulos (OFL/Apache, del repositorio de Google Fonts). Las dos primeras ya vienen en el paquete. */
+export const LETRAS = {
+	Anton: null,
+	Montserrat: null,
+	'Archivo Black': 'ofl/archivoblack/ArchivoBlack-Regular.ttf',
+	'Bebas Neue': 'ofl/bebasneue/BebasNeue-Regular.ttf',
+	'Luckiest Guy': 'apache/luckiestguy/LuckiestGuy-Regular.ttf',
+	Bangers: 'ofl/bangers/Bangers-Regular.ttf',
+	'Lilita One': 'ofl/lilitaone/LilitaOne-Regular.ttf',
+	'Russo One': 'ofl/russoone/RussoOne-Regular.ttf',
+	'Titan One': 'ofl/titanone/TitanOne-Regular.ttf',
+	'Black Ops One': 'ofl/blackopsone/BlackOpsOne-Regular.ttf',
+	'Rubik Mono One': 'ofl/rubikmonoone/RubikMonoOne-Regular.ttf',
+	'Passion One': 'ofl/passionone/PassionOne-Black.ttf',
+};
+
+/** Ritmo → velocidad de la voz y duración de entradas/transiciones. */
+export const RITMOS = {
+	pausado: {velocidad: 1.05, movimiento: {entrada: 0.6, salida: 0.45, transicion: 0.45, curva: 'suave'}},
+	natural: {velocidad: 1.2, movimiento: {entrada: 0.45, salida: 0.35, transicion: 0.35, curva: 'suave'}},
+	agil: {velocidad: 1.32, movimiento: {entrada: 0.3, salida: 0.25, transicion: 0.25, curva: 'seca'}},
+};
+
+export function leerEstiloPropio(proyecto) {
+	const f = path.join(proyecto, ARCHIVO_ESTILO);
+	if (!fs.existsSync(f)) return null;
+	try {
+		return JSON.parse(fs.readFileSync(f, 'utf8'));
+	} catch (e) {
+		throw new Error(`${ARCHIVO_ESTILO} no es un JSON válido: ${e.message}`);
+	}
+}
+
+/**
+ * Mezcla el estilo propio en la configuración (devuelve una copia). El estilo queda como `mi-estilo`, heredando de
+ * `base`, y es el estilo por defecto del proyecto.
+ */
+export function aplicarEstiloPropio(cfg, e, proyecto) {
+	if (!e) return cfg;
+	const out = {...cfg, marca: {...(cfg.marca ?? {})}, voces: {...(cfg.voces ?? {})}, estilos: {...(cfg.estilos ?? {})}, fuentes: {...(cfg.fuentes ?? {})}};
+	if (e.nombre) out.marca.nombre = e.nombre;
+	if (e.siglas) out.marca.siglas = e.siglas;
+	if (e.colores?.acento) out.marca.color = e.colores.acento;
+	if (e.cierre) out.marca.cta = e.cierre;
+	if (e.letra) out.marca.letra = e.letra;
+	if (e.redes) out.marca.redes = e.redes;
+	const ritmo = RITMOS[e.ritmo] ?? RITMOS.natural;
+	const tema = {base: e.base ?? cfg.estilo ?? 'documental', movimiento: ritmo.movimiento};
+	if (e.colores?.acento) tema.colores = {acento: e.colores.acento, ...(e.colores.acento2 ? {acento2: e.colores.acento2} : {})};
+	if (e.colores?.subtitulo) tema.subtitulos = {resalte: e.colores.subtitulo};
+	if (e.letra && e.letra !== 'Montserrat') {
+		tema.fuentes = {titulo: e.letra};
+		// las letras descargadas viven en fuentes/ del proyecto (Anton viene en el paquete)
+		const archivo = path.join(proyecto, 'fuentes', `${e.letra.replace(/\s+/g, '')}.ttf`);
+		if (LETRAS[e.letra] && fs.existsSync(archivo)) out.fuentes[e.letra] = archivo;
+	}
+	out.estilos['mi-estilo'] = tema;
+	out.estilo = 'mi-estilo';
+	if (e.voz) out.voces['mi-voz'] = e.voz;
+	out.__estiloPropio = {voz: e.voz ? 'mi-voz' : null, velocidad: ritmo.velocidad, estiloAnterior: cfg.estilo ?? 'datos-curiosos'};
+	return out;
+}

package/lib/estructura.mjs

@@ -43,6 +43,7 @@ export const REGLAS = [
 export const REGLAS_TEXTO = `Estructura (medida en videos virales; síguela):
 ${REGLAS.map((r, i) => `${i + 1}. ${r.regla}: ${r.como}`).join('\n')}`;
 
+import {revisarVoz, revisarZona} from './calidad.mjs';
 import {formulaDe, revisarFormula} from './formulas.mjs';
 
 const palabrasDe = (s) => String(s ?? '').trim().split(/\s+/).filter(Boolean);
@@ -113,6 +114,8 @@ export function revisarEstructura(v, d) {
 	if (n > 40 && tu === 0) add('tu', 'idea', 'No le habla al espectador ni una vez: una frase en segunda persona ("imagina que tú…") lo mete en la historia.');
 	// 6) lo propio de la fórmula del video (lib/formulas.mjs)
 	for (const t of revisarFormula(v)) add('formula', 'idea', t);
+	// 7) lo que no se ve a simple vista: la voz dijo lo del guion y nada queda bajo los botones de las apps
+	out.push(...revisarZona(v), ...revisarVoz(v, d));
 	// "envíaselo a…" también es un cierre que pide algo
 	return out;
 }

package/lib/guion.mjs

@@ -170,7 +170,7 @@ export async function esquemaMotor() {
 		claves: z.array(z.string()).nullable(),
 	});
 	const cierre = z.object({pide: z.enum(['comenta', 'comparte', 'sigue']), say: z.string(), palabra: z.string().nullable(), a: z.string().nullable()});
-	return z.object({id: z.string(), title: z.string(), formula: z.enum(IDS_FORMULA), music: z.enum(MUSICAS), scenes: z.array(escena), cierre});
+	return z.object({id: z.string(), title: z.string(), formula: z.enum(IDS_FORMULA), music: z.enum(MUSICAS), descripcion: z.string(), tags: z.array(z.string()), hooks: z.array(z.string()), scenes: z.array(escena), cierre});
 }
 
 /** De la salida de la IA (motor de capas) al formato de escenas de morfeo. */
@@ -266,6 +266,51 @@ export function aEscena(e) {
 	return out;
 }
 
+/**
+ * Investiga el tema en la web antes de escribir (búsqueda del servidor de Claude): devuelve notas con cada dato y su
+ * fuente, y la lista de fuentes que de verdad se consultaron (las URLs de los resultados de búsqueda citados).
+ * @returns {Promise<{notas: string, fuentes: {texto: string, url: string}[]}>}
+ */
+export async function investigar(client, Anthropic, tema, {idioma = 'español de México', modelo = MODELO_GUION, log = () => {}} = {}) {
+	const messages = [
+		{
+			role: 'user',
+			content: `Investiga para un video corto vertical sobre: ${tema}
+
+Busca en la web y junta 8 a 12 datos concretos, sorprendentes y verificables (cifras, fechas, nombres, lugares), cada uno
+con la fuente donde lo leíste (nombre del medio o institución y URL). Prefiere fuentes primarias u oficiales. Si dos
+fuentes no coinciden, dilo. No inventes nada que no esté en una fuente.
+Responde en ${idioma} con una lista: "- dato · fuente (URL)".`,
+		},
+	];
+	const vistas = new Map();
+	let texto = '';
+	// la búsqueda corre en el servidor; si el turno se pausa (pause_turn), se reenvía para que continúe
+	for (let vuelta = 0; vuelta < 6; vuelta++) {
+		const res = await client.messages.create({
+			model: modelo,
+			max_tokens: 16000,
+			tools: [{type: 'web_search_20260209', name: 'web_search', max_uses: 8}],
+			messages,
+		});
+		for (const b of res.content) {
+			if (b.type === 'web_search_tool_result' && Array.isArray(b.content)) for (const r of b.content) if (r.url) vistas.set(r.url, r.title ?? r.url);
+			if (b.type === 'text') {
+				texto += b.text;
+				for (const c of b.citations ?? []) if (c.url) vistas.set(c.url, c.title ?? vistas.get(c.url) ?? c.url);
+			}
+		}
+		if (res.stop_reason === 'refusal') throw new ErrorMorfeo('Claude no quiso investigar ese tema.');
+		if (res.stop_reason !== 'pause_turn') break;
+		log('    (sigue buscando…)');
+		messages.push({role: 'assistant', content: res.content});
+	}
+	if (!texto.trim()) throw new ErrorMorfeo('La investigación no devolvió datos; intenta otra vez o sin --investigar.');
+	// solo las fuentes que aparecen en las notas (las que de verdad respaldan un dato)
+	const fuentes = [...vistas].filter(([url]) => texto.includes(url) || texto.includes(new URL(url).hostname)).map(([url, titulo]) => ({texto: titulo, url}));
+	return {notas: texto.trim(), fuentes: fuentes.length ? fuentes : [...vistas].slice(0, 8).map(([url, titulo]) => ({texto: titulo, url}))};
+}
+
 /**
  * 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
@@ -283,10 +328,25 @@ export async function guionConIA(o) {
 		throw new ErrorMorfeo('Falta la dependencia @anthropic-ai/sdk (npm install @anthropic-ai/sdk zod)');
 	}
 	const client = new Anthropic();
+	// --investigar: primero los datos con su fuente (búsqueda web), luego el guion se escribe solo con esos datos
+	let investigacion = null;
+	if (o.investigar && !o.texto) {
+		(o.log ?? console.log)('Investigando el tema en la web (cada dato con su fuente)...');
+		try {
+			investigacion = await investigar(client, Anthropic, o.tema, {idioma: o.idioma ?? 'español de México', modelo: o.modelo ?? MODELO_GUION, log: o.log ?? console.log});
+		} catch (e) {
+			if (e instanceof ErrorMorfeo) throw e;
+			if (e instanceof Anthropic.APIError) throw new ErrorMorfeo(`La búsqueda web falló (${e.status}): ${e.message}. Intenta sin --investigar.`);
+			throw e;
+		}
+	}
 	const idioma = o.idioma ?? 'español de México';
-	const pedido = o.texto
+	const pedidoBase = 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 pedido = investigacion
+		? `${pedidoBase}\n\nUsa SOLO estos datos investigados (no agregues cifras que no estén aquí):\n<investigacion>\n${investigacion.notas}\n</investigacion>`
+		: pedidoBase;
 	// ~45 s por defecto: los videos de referencia rondan el minuto y ninguna idea pasa de ~5 s (lib/estructura.mjs)
 	const forzada = o.formula ? formulaDe(o.formula) : null;
 	if (o.formula && !forzada) throw new ErrorMorfeo(`La fórmula "${o.formula}" no existe. Opciones: ${IDS_FORMULA.join(', ')}`);
@@ -304,7 +364,7 @@ export async function guionConIA(o) {
 			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.`}],
+			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. En "descripcion" el texto del post (1–2 frases). En "tags" 3–5 etiquetas sin #. En "hooks" 3 primeras frases alternativas al gancho, distintas entre sí, para probar otra versión.`}],
 			output_config: {format: zodOutputFormat(motor ? await esquemaMotor() : await esquema())},
 		});
 	} catch (e) {
@@ -321,7 +381,7 @@ export async function guionConIA(o) {
 		const scenes = g.scenes.map((e) => aEscenaMotor(e, !!o.imagenes));
 		const c = g.cierre;
 		const cta = !c || c.pide === 'sigue' ? {type: 'cta', ...(c?.say ? {say: c.say} : {})} : {type: 'cta', pide: c.pide, say: c.say, ...(c.palabra ? {palabra: c.palabra} : {}), ...(c.a ? {a: c.a} : {})};
-		return {id: slug(g.id || g.title), video: {estilo: o.estilo, formula: forzada?.id ?? g.formula, title: g.title, voice: o.voz ?? 'em_alex', music: g.music, scenes: [...scenes, cta]}};
+		return {id: slug(g.id || g.title), video: {estilo: o.estilo, formula: forzada?.id ?? g.formula, title: g.title, descripcion: g.descripcion, tags: g.tags, hooks: g.hooks, ...(investigacion?.fuentes.length ? {fuentes: investigacion.fuentes} : {}), voice: o.voz ?? 'em_alex', music: g.music, scenes: [...scenes, 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'});

package/lib/hoja.mjs

@@ -1,6 +1,7 @@
 // `morfeo hoja <id>`: hoja de contacto (PNG con cuadros repartidos en el tiempo) para revisar un video de un vistazo.
 // El ffmpeg que trae Remotion viene recortado (sin los filtros `tile` ni `fps`), así que cada cuadro se pide como
 // PNG sin predicción por una tubería y la hoja se arma aquí con zlib.
+import {ZONAS} from './calidad.mjs';
 import {spawnSync} from 'node:child_process';
 import fs from 'node:fs';
 import {createRequire} from 'node:module';
@@ -62,10 +63,11 @@ function leerPng(b, w, h) {
 }
 
 /**
- * @param {{video: string, salida?: string, cols?: number, filas?: number, desde?: number, hasta?: number, ancho?: number}} op
+ * @param {{video: string, salida?: string, cols?: number, filas?: number, desde?: number, hasta?: number, ancho?: number, zona?: boolean}} op
+ *   zona: pinta en rojo lo que tapan los botones de TikTok/Reels/Shorts
  * @returns {string} ruta del PNG
  */
-export function hoja({video, salida, cols = 5, filas = 3, desde = 0, hasta, ancho = 216}) {
+export function hoja({video, salida, cols = 5, filas = 3, desde = 0, hasta, ancho = 216, zona = false}) {
 	// rutas absolutas: ffmpeg corre desde la carpeta de sus DLL, así que una ruta relativa no se encontraría
 	video = path.resolve(video);
 	if (salida) salida = path.resolve(salida);
@@ -87,6 +89,19 @@ export function hoja({video, salida, cols = 5, filas = 3, desde = 0, hasta, anch
 		const r = spawnSync(ffmpeg, ['-v', 'error', '-ss', t.toFixed(3), '-i', video, '-frames:v', '1', '-vf', `scale=${w}:${h}`, '-f', 'image2pipe', '-c:v', 'png', '-pred', 'none', '-pix_fmt', 'rgb24', '-'], {maxBuffer: 64 * 1024 * 1024, cwd});
 		if (r.status !== 0 || !r.stdout?.length) continue;
 		const px = leerPng(r.stdout, w, h);
+		if (zona) {
+			// tinte rojo en las zonas que tapan las apps (escala de 1080×1920 al tamaño del cuadro)
+			const ex = w / 1080;
+			const ey = h / 1920;
+			for (const z of ZONAS)
+				for (let y = Math.floor(z.y0 * ey); y < Math.min(h, Math.ceil(z.y1 * ey)); y++)
+					for (let x = Math.floor(z.x0 * ex); x < Math.min(w, Math.ceil(z.x1 * ex)); x++) {
+						const k = (y * w + x) * 3;
+						px[k] = Math.round(px[k] * 0.55 + 255 * 0.45);
+						px[k + 1] = Math.round(px[k + 1] * 0.55);
+						px[k + 2] = Math.round(px[k + 2] * 0.55);
+					}
+		}
 		const x0 = (i % cols) * w;
 		const y0 = Math.floor(i / cols) * h;
 		for (let y = 0; y < h; y++) px.copy(lienzo, (y0 + y) * (1 + W * 3) + 1 + x0 * 3, y * w * 3, (y + 1) * w * 3);

package/lib/palabras.mjs

@@ -35,7 +35,7 @@ function momentosDe(x, ruta, out) {
 		if (p) out.push([`${ruta}.${k}`, p]);
 	}
 	// lo que vive dentro de una capa: sus capas, su capa repetida, cambios, poses, items, líneas, movimientos
-	for (const k of ['capas', 'capa', 'cambios', 'poses', 'items', 'lineas', 'mover', 'escalar', 'opciones', 'capasPantalla'])
+	for (const k of ['capas', 'capa', 'cambios', 'poses', 'items', 'lineas', 'mover', 'escalar', 'opciones', 'capasPantalla', 'hitos', 'notificaciones'])
 		if (x[k] != null) momentosDe(x[k], `${ruta}.${k}`, out);
 }
 

package/lib/render.mjs

@@ -213,7 +213,9 @@ export async function preparar({proyecto = process.cwd(), ids, log = console.log
  * @param {{proyecto?: string, ids?: string[], todos?: boolean, log?: (m: string) => void, alProgreso?: (id: string, p: number) => void}} o
  * @returns {Promise<{id: string, mp4: string, jpg: string | null, segundos: number}[]>}
  */
-export async function render({proyecto = process.cwd(), ids, todos = false, soloFallidos = false, log = console.log, alProgreso} = {}) {
+export async function render({proyecto = process.cwd(), ids, todos = false, soloFallidos = false, previa = null, log = console.log, alProgreso} = {}) {
+	// previa: solo el gancho (las primeras escenas, hasta `previa` segundos o ~8 s) en "<título> (previa).mp4", sin miniatura
+	if (previa && !ids?.length) throw new ErrorMorfeo('Dime qué video:  npx morfeo previa mi-video');
 	cargarEnv(proyecto);
 	const p = await cargarProyecto(proyecto);
 	const loteArchivo = path.join(p.trabajo, 'ultimo-lote.json');
@@ -266,7 +268,10 @@ export async function render({proyecto = process.cwd(), ids, todos = false, solo
 			const t = Date.now();
 			try {
 			const inputProps = {videos: {[id]: datos[id]}, marca, ...extras};
-			const mp4 = salidaDe(p, id);
+			const mp4 = previa ? salidaDe(p, id).replace(/\.mp4$/, ' (previa).mp4') : salidaDe(p, id);
+			// tramo de la previa: hasta el final de la 2.ª escena (gancho + la que sigue), entre 4 y 8 s, o lo que se pida
+			const d0 = datos[id];
+			const finPrevia = typeof previa === 'number' ? previa : Math.min(8, Math.max(4, (d0.escenas[1] ?? d0.escenas[0]).t0 + (d0.escenas[1] ?? d0.escenas[0]).dur));
 			let gl = p.render.gl;
 			let concurrencia = concurrenciaBase;
 			let composition;
@@ -289,6 +294,7 @@ export async function render({proyecto = process.cwd(), ids, todos = false, solo
 						jpegQuality: 92,
 						concurrency: concurrencia,
 						outputLocation: mp4,
+						...(previa ? {frameRange: [0, Math.min(composition.durationInFrames - 1, Math.round(finPrevia * composition.fps))]} : {}),
 						onProgress: ({progress}) => {
 							alProgreso?.(id, progress);
 							// con terminal: cada 10 % en la misma línea; sin terminal (logs, CI): cada 25 %
@@ -314,7 +320,7 @@ export async function render({proyecto = process.cwd(), ids, todos = false, solo
 				}
 			}
 			let jpg = null;
-			if (p.render.miniatura) {
+			if (p.render.miniatura && !previa) {
 				// miniatura: cuando la primera escena ya está completa (o en `miniaturaEn`), sin subtítulos
 				jpg = salidaDe(p, id, 'jpg');
 				const d = datos[id];
@@ -324,6 +330,17 @@ export async function render({proyecto = process.cwd(), ids, todos = false, solo
 				const props = {...inputProps, miniatura: true};
 				await renderStill({serveUrl, composition: {...composition, props: {...composition.props, miniatura: true}}, inputProps: props, browserExecutable, chromiumOptions: {gl}, frame, imageFormat: 'jpeg', jpegQuality: 92, output: jpg});
 			}
+			// portada: el mismo cuadro con el título grande y la marca (`portada: 'texto'` o el título sin emojis; false = sin portada)
+			const vid = p.videos[id];
+			if (!previa && p.render.portada !== false && vid.portada !== false && jpg) {
+				const textoPortada = typeof vid.portada === 'string' ? vid.portada : String(vid.title ?? id).replace(/[\p{Extended_Pictographic}\uFE0F\u200D]/gu, '').replace(/\s*[|·].*$/, '').trim();
+				const d = datos[id];
+				const e0 = d.escenas[0];
+				const seg = vid.miniaturaEn ?? Math.min(e0.dur - 0.15, Math.max(1.4, e0.habla[1] * 0.85));
+				const frame = Math.max(0, Math.min(composition.durationInFrames - 1, Math.round(seg * composition.fps)));
+				const props = {...inputProps, portada: textoPortada};
+				await renderStill({serveUrl, composition: {...composition, props: {...composition.props, portada: textoPortada}}, inputProps: props, browserExecutable, chromiumOptions: {gl}, frame, imageFormat: 'jpeg', jpegQuality: 92, output: salidaDe(p, id, 'jpg').replace(/\.jpg$/, ' (portada).jpg')});
+			}
 			const segundos = Math.round((Date.now() - t) / 1000);
 			if (process.stdout.isTTY) process.stdout.write('\r');
 			log(`[${i + 1}/${listos.length}] ${id}: listo en ${segundos} s  →  ${path.relative(p.proyecto, mp4)}      `);
@@ -337,6 +354,7 @@ export async function render({proyecto = process.cwd(), ids, todos = false, solo
 	} finally {
 		soltar();
 	}
+	if (previa) return hechos;
 	return terminarLote(p, loteArchivo, hechos, fallidos, log);
 }
 
@@ -438,7 +456,18 @@ function escribirResumen(p) {
 		const v = p.videos[f.id];
 		const tags = (v.tags ?? []).map((x) => `#${String(x).replace(/^#/, '').replace(/\s+/g, '')}`).join(' ');
 		const creditos = f.creditos?.length ? ['', 'Créditos:', ...f.creditos.map((c) => `- ${c}`)] : [];
-		const lineas = [v.title ?? f.id, '', ...(v.descripcion ? [v.descripcion, ''] : []), ...(tags ? [tags] : []), ...creditos];
+		const fuentes = (v.fuentes ?? []).map((x) => (typeof x === 'string' ? `- ${x}` : `- ${x.texto ?? ''}${x.url ? ` · ${x.url}` : ''}`));
+		const ganchos = (v.hooks ?? []).map((h, i) => `${i + 1}. ${h}`);
+		const lineas = [
+			v.title ?? f.id,
+			'',
+			...(v.descripcion ? [v.descripcion, ''] : []),
+			...(tags ? [tags] : []),
+			...(fuentes.length ? ['', 'Fuentes:', ...fuentes] : []),
+			...creditos,
+			// lo de abajo no va en el post: ganchos para probar otra versión del inicio
+			...(ganchos.length ? ['', '———', 'Ganchos de reserva (para otra versión):', ...ganchos] : []),
+		];
 		fs.writeFileSync(salidaDe(p, f.id, 'txt'), lineas.join('\n').trim() + '\n');
 	}
 	if (conCreditos.length)

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "morfeo",
-	"version": "0.4.0",
+	"version": "0.5.0",
 	"description": "Genera videos verticales animados (Remotion + Three.js) con voz, música y subtítulos, desde un guion en código o escrito por IA.",
 	"type": "module",
 	"license": "SEE LICENSE IN LICENSE",

package/plantilla/AGENTS.md

@@ -0,0 +1,54 @@
+# Instrucciones para la IA (Claude Code, Codex u otra)
+
+Este es un proyecto de **Morfeo**: videos verticales animados (Shorts, TikTok, Reels) desde código. Tú eres quien
+los hace: la persona te pide un tema y tú le devuelves el video terminado. Habla con ella en su idioma, sin jerga
+técnica. Nunca publiques nada por ella: le entregas los archivos y ella decide dónde subirlos.
+
+Comandos de referencia: `npx morfeo ayuda`. Tipos de todo lo que existe: `node_modules/morfeo/index.d.ts`.
+
+## Cuando diga «Configúrame» (o es la primera vez)
+
+1. Revisa que haya Node 20+ (`node -v`). Si falta, dile cómo instalarlo y espera.
+2. `npm install` en esta carpeta.
+3. `npx morfeo instalar --si` (Python, voces gratis, navegador; tarda unos minutos la primera vez). Si algo falla,
+   lee el mensaje, arréglalo y vuelve a correrlo. `npx morfeo doctor` dice qué falta.
+4. `npx morfeo estilo`: abre una página para que elija nombre, siglas, colores, letra, voz, ritmo y frase de cierre.
+   Espera a que diga que guardó (crea `estilo.json`).
+5. Si quiere su voz de ElevenLabs: que pegue su clave en `.env` como `ELEVENLABS_API_KEY=…` (cópialo de `.env.example`;
+   nunca escribas tú la clave ni la pongas en el chat). Para investigar con Claude desde la terminal, `ANTHROPIC_API_KEY`.
+6. Haz un video de prueba (`npx morfeo render ejemplo-2d`) y dile dónde quedó.
+
+## Cuando diga «Hazme un video sobre…»
+
+1. **Investiga.** Busca los datos en la web y quédate solo con lo que puedas respaldar con una fuente (medio,
+   institución, URL). Si no puedes buscar, usa `npx morfeo guion "tema" --investigar` (necesita `ANTHROPIC_API_KEY`).
+   Si dudas de una cifra, dila en general o quítala.
+2. **Elige la fórmula** que mejor le queda al tema: `npx morfeo formulas` (construiste, mito, misterio, serie,
+   biografía, experimento, demuéstralo, roast…). Si hay una base para esa fórmula, empieza de ahí:
+   `npx morfeo nuevo-video <id> --formula <fórmula>` (bases: serie, mito, escalada, biografia, construiste; o
+   `--look 2d` / `--look 3d`). Si no, `npx morfeo guion "tema" --formula <fórmula>` o escribe el guion a mano en
+   `guiones/<id>.mjs` (mira los ejemplos de `guiones/`).
+3. **Escribe el guion** siguiendo la fórmula y estas reglas:
+   - Gancho en los primeros 2 s, en segunda persona o con una cifra imposible. Nada de "hoy te voy a contar".
+   - Una idea por escena (2–5 s de voz). Pregunta antes de revelar. Sube la apuesta hacia el final.
+   - `say` es lo que dice la voz (cifras con letra); `show` el subtítulo con cifras.
+   - Rótulos cortos en 2–4 escenas (`rotulo`, con `rotuloEstilo` sello/paso/pixel si va), `claves` en cada escena.
+   - Cierre que pide algo: `{type: 'cta', pide: 'comenta', palabra: 'X'}` o `pide: 'comparte', a: 'tu amigo que…'`.
+   - `title`, `descripcion`, `tags`, `hooks` (3 ganchos de reserva) y `fuentes` (cada dato con su fuente).
+4. **Enséñale el guion** (texto de cada escena, en limpio) y espera su visto bueno o sus cambios.
+5. **Enséñale el gancho:** `npx morfeo previa <id>` renderiza solo los primeros segundos. Si no le convence, cámbialo
+   (tiene 3 ganchos de reserva en `hooks`).
+6. **Renderiza:** `npx morfeo render <id>`.
+7. **Revisa antes de entregar:**
+   - `npx morfeo revisar <id>`: estructura, que la voz haya dicho el guion y que nada quede bajo los botones de la app.
+   - `npx morfeo hoja <id> --zona`: mira la hoja de contacto (es una imagen); lo pintado en rojo es lo que tapan las apps.
+   - Si algo se ve mal (texto encimado, objeto cortado, cuadro vacío), arréglalo y vuelve a renderizar.
+8. **Entrega:** en `salida/` quedan `<título>.mp4`, `<título>.jpg` (miniatura), `<título> (portada).jpg` y
+   `<título>.txt` (texto del post, etiquetas, fuentes y ganchos de reserva). Dile eso y nada más.
+
+## Reglas
+
+- No inventes datos. No copies videos de otros: se toma la forma, no el contenido.
+- Emojis solo como último recurso; mejor objetos 2D/3D (`{tipo: 'recurso', buscar: 'volcán', estilo: '3d'}`).
+- Un render a la vez. Si un render falla, lee el error (Morfeo explica qué falta) y corrígelo.
+- No toques `node_modules/`. Lo de la persona vive en `guiones/`, `escenas/`, `assets/`, `estilo.json` y `morfeo.config.mjs`.

package/plantilla/CLAUDE.md

@@ -0,0 +1,5 @@
+# Instrucciones para Claude Code
+
+Las instrucciones de este proyecto están en AGENTS.md (las mismas para cualquier IA):
+
+@AGENTS.md

package/python/musica.py

@@ -179,11 +179,97 @@ def efecto(nombre, rng):
         x = 0.22 * pop(180, 90, 0.16)
         add(x, 0.1 * lp(rng.standard_normal(int(0.06 * SR)), 1200), 0)
         return x
+    if nombre in EFECTOS_EXTRA: return EFECTOS_EXTRA[nombre](rng)
     return 0.14 * pop()
 
 
+def _env(n, ataque=0.004, cola=6.0):
+    t = np.arange(n) / SR
+    return np.minimum(1, t / ataque) * np.exp(-t * cola)
+
+
+def _tono(f, d, cola=8.0, armonicos=(1,)):
+    n = int(d * SR); t = np.arange(n) / SR
+    x = sum(np.sin(2 * np.pi * f * h * t) / (i + 1) for i, h in enumerate(armonicos))
+    return x * _env(n, 0.003, cola)
+
+
+def _teclas(rng):
+    """Ráfaga de teclas de máquina: 7 clics secos con espaciado irregular."""
+    x = np.zeros(int(0.9 * SR)); t = 0.0
+    for _ in range(7):
+        c = hp(rng.standard_normal(int(0.012 * SR)), 2500) * _env(int(0.012 * SR), 0.0005, 300)
+        add(x, 0.14 * c, t); t += 0.07 + rng.random() * 0.07
+    return x
+
+
+def _radio(rng):
+    """Estática de radio con un pitido de sintonía."""
+    n = int(0.7 * SR)
+    ruido = hp(lp(rng.standard_normal(n), 3500), 400) * 0.25 * np.minimum(1, np.arange(n) / (0.03 * SR)) * np.linspace(1, 0.2, n)
+    add(ruido, 0.08 * _tono(1200, 0.25, 4), 0.2)
+    return ruido
+
+
+def _obturador(rng):
+    """Obturador de cámara: dos clics mecánicos."""
+    x = np.zeros(int(0.25 * SR))
+    for t, f in ((0.0, 1800), (0.07, 1300)):
+        c = lp(hp(rng.standard_normal(int(0.02 * SR)), 900), f * 3) * _env(int(0.02 * SR), 0.0004, 220)
+        add(x, 0.5 * c, t)
+    return x
+
+
+def _notificacion(rng):
+    """Notificación del teléfono: dos notas que suben."""
+    x = np.zeros(int(0.5 * SR))
+    add(x, 0.18 * _tono(nf(84), 0.25, 14, (1, 2)), 0)
+    add(x, 0.18 * _tono(nf(91), 0.35, 10, (1, 2)), 0.11)
+    return x
+
+
+def _latido(rng):
+    """Latido: dos golpes graves (lub-dub)."""
+    x = np.zeros(int(0.7 * SR))
+    add(x, 0.5 * _tono(55, 0.18, 22), 0)
+    add(x, 0.35 * _tono(48, 0.16, 24), 0.2)
+    return lp(x, 300)
+
+
+def _alarma(rng):
+    """Alarma: tres pitidos cuadrados."""
+    x = np.zeros(int(0.9 * SR))
+    for i in range(3):
+        n = int(0.16 * SR); t = np.arange(n) / SR
+        b = np.sign(np.sin(2 * np.pi * 1600 * t)) * 0.09 * np.minimum(1, (n - np.arange(n)) / (0.01 * SR))
+        add(x, lp(b, 5000), i * 0.27)
+    return x
+
+
+def _reloj(rng):
+    """Tic-tac de reloj: tic agudo y tac grave."""
+    x = np.zeros(int(1.0 * SR))
+    for i in range(2):
+        add(x, 0.45 * tick(0.02), i * 0.5)
+        add(x, 0.3 * lp(tick(0.025), 1500), i * 0.5 + 0.25)
+    return x
+
+
+def _caja(rng):
+    """Caja registradora: campanita y cajón que se abre."""
+    x = np.zeros(int(0.9 * SR))
+    add(x, 0.25 * bell(nf(96), 0.7), 0.0)
+    cajon = lp(rng.standard_normal(int(0.25 * SR)), 900) * _env(int(0.25 * SR), 0.01, 10) * 0.25
+    add(x, cajon, 0.12)
+    return x
+
+
+EFECTOS_EXTRA = {"teclas": _teclas, "radio": _radio, "obturador": _obturador, "notificacion": _notificacion, "latido": _latido, "alarma": _alarma, "reloj": _reloj, "caja": _caja}
+
+
 # sonido por defecto según cómo entra o qué es la capa (sonido: false lo apaga; sonido: "x" lo cambia)
-SONIDO_TIPO = {"sello": "golpe", "dato": "tick", "contador": "tick", "nombre": "pop", "accion": "pop", "chip": "pop", "insignia": "pop"}
+SONIDO_TIPO = {"sello": "golpe", "dato": "tick", "contador": "tick", "nombre": "pop", "accion": "pop", "chip": "pop", "insignia": "pop",
+               "bloqueo": "notificacion", "llamada": "notificacion", "vigilancia": "radio", "terminal": "teclas", "calendario": "reloj", "fecha": "golpe", "noticia": "radio", "recuento": "tick", "cronometro": "reloj"}
 SONIDO_ENTRADA = {"rebote": "pop", "caer": "golpe", "deslizar-izq": "whoosh", "deslizar-der": "whoosh", "deslizar-arriba": "whoosh", "deslizar-abajo": "whoosh", "girar": "whoosh"}
 
 

package/remotion/Short.tsx

@@ -27,10 +27,11 @@ import {MARCA_VACIA, type Datos, type Escena, type Marca as TipoMarca} from './t
 import {Capas} from './motor/capas';
 import {capasDe} from './motor/plantillas';
 import {temaDe} from './motor/tema';
+import {Portada} from './motor/portada';
 import {VideoConAudio} from './motor/Video';
 import {loadFont} from '@remotion/fonts';
 
-export type PropsShort = {id: string; videos?: Record<string, Datos>; marca?: TipoMarca; guias?: boolean; miniatura?: boolean; fuentes?: {familia: string; url: string}[]; estilos?: Record<string, any>};
+export type PropsShort = {id: string; videos?: Record<string, Datos>; marca?: TipoMarca; guias?: boolean; miniatura?: boolean; portada?: string; fuentes?: {familia: string; url: string}[]; estilos?: Record<string, any>};
 
 const ADELANTO_GANCHO = 0.4; // el gancho arranca ya animado: el fotograma 0 nunca está vacío
 const CIERRE_BUCLE = 0.5; // al final se funde con el fotograma 0 para que el video se repita sin corte
@@ -246,7 +247,7 @@ export const Fotograma: React.FC<{d: Datos; T: number; guias?: boolean; miniatur
 	);
 };
 
-export const Short: React.FC<PropsShort> = ({id, videos, marca, guias, miniatura, fuentes, estilos}) => {
+export const Short: React.FC<PropsShort> = ({id, videos, marca, guias, miniatura, portada, fuentes, estilos}) => {
 	const frame = useCurrentFrame();
 	const [listo, setListo] = useState(false);
 	const [handle] = useState(() => delayRender('Cargando fuentes'));
@@ -259,6 +260,13 @@ export const Short: React.FC<PropsShort> = ({id, videos, marca, guias, miniatura
 	const d = videos?.[id];
 	if (!d) throw new Error(`El video "${id}" no está preparado. Corre: npx morfeo render ${id}`);
 	if (!listo) return null;
+	if (portada)
+		return (
+			<AbsoluteFill>
+				{d.estilo && d.estilo !== 'datos-curiosos' ? <VideoConAudio d={d} frame={frame} marca={{...MARCA_VACIA, ...marca}} estilos={estilos} miniatura sinMarca /> : <Fotograma d={d} T={frame / FPS} miniatura />}
+				<Portada texto={portada} marca={{...MARCA_VACIA, ...marca}} />
+			</AbsoluteFill>
+		);
 	if (d.estilo && d.estilo !== 'datos-curiosos') return <VideoConAudio d={d} frame={frame} marca={{...MARCA_VACIA, ...marca}} estilos={estilos} miniatura={miniatura} />;
 	const T = frame / FPS;
 	const kb = clamp((T - (d.duracion - CIERRE_BUCLE)) / CIERRE_BUCLE);

package/remotion/motor/Video.tsx

@@ -383,7 +383,7 @@ const MarcaEsquina: React.FC<{tema: Tema}> = ({tema}) => {
 	);
 };
 
-export const VideoMotor: React.FC<{d: Datos; T: number; estilos?: Record<string, any>; miniatura?: boolean}> = ({d, T, estilos, miniatura}) => {
+export const VideoMotor: React.FC<{d: Datos; T: number; estilos?: Record<string, any>; miniatura?: boolean; sinMarca?: boolean}> = ({d, T, estilos, miniatura, sinMarca}) => {
 	const tema = temaDe(d.estilo, d.tema, estilos);
 	const n = d.escenas.length;
 	let si = d.escenas.findIndex((e) => T < e.t0 + e.dur);
@@ -459,18 +459,18 @@ export const VideoMotor: React.FC<{d: Datos; T: number; estilos?: Record<string,
 			<Vineta fuerza={tema.vineta ?? 0} color={tema.post?.vinetaColor} />
 			{d.hud?.length ? <Hud d={d} T={T} tema={tema} /> : null}
 			{d.serie && e.tipo !== 'cta' ? <Serie texto={d.serie} tema={tema} /> : null}
-			{e.tipo !== 'cta' ? <Rotulo e={e} t={t} tema={e.p.tema ? mezclar(tema, e.p.tema) : tema} /> : null}
+			{e.tipo !== 'cta' && !sinMarca ? <Rotulo e={e} t={t} tema={e.p.tema ? mezclar(tema, e.p.tema) : tema} /> : null}
 			{e.tipo !== 'cta' && !miniatura ? <Subtitulos tema={e.p.tema ? mezclar(tema, e.p.tema) : tema} palabras={e.palabras ?? []} t={t} dur={e.dur} claves={e.p.claves} /> : null}
-			{e.tipo !== 'cta' ? <MarcaEsquina tema={tema} /> : null}
+			{e.tipo !== 'cta' && !sinMarca ? <MarcaEsquina tema={tema} /> : null}
 		</AbsoluteFill>
 	);
 };
 
 /** Componente raíz de un video del motor de capas (con su audio). */
-export const VideoConAudio: React.FC<{d: Datos; frame: number; marca: any; estilos?: Record<string, any>; miniatura?: boolean}> = ({d, frame, marca, estilos, miniatura}) => (
+export const VideoConAudio: React.FC<{d: Datos; frame: number; marca: any; estilos?: Record<string, any>; miniatura?: boolean; sinMarca?: boolean}> = ({d, frame, marca, estilos, miniatura, sinMarca}) => (
 	<MarcaContexto.Provider value={marca}>
 		<AbsoluteFill>
-			<VideoMotor d={d} T={frame / FPS} estilos={estilos} miniatura={miniatura} />
+			<VideoMotor d={d} T={frame / FPS} estilos={estilos} miniatura={miniatura} sinMarca={sinMarca} />
 			<Audio src={staticFile(d.audio)} />
 		</AbsoluteFill>
 	</MarcaContexto.Provider>

package/remotion/motor/historias.tsx

@@ -367,9 +367,13 @@ export const Tierra: React.FC<{c: C; ctx: CtxEscena}> = ({c, ctx}) => {
 	const pin = clamp((t - (c.girar === false ? 0.2 : (c.duracion ?? 1.8) * 0.85)) / 0.35);
 	const X = cx + px * R;
 	const Y = cx - py * R;
+	// `acercar: 4`: después del pin, la cámara vuela hacia el sitio (el globo crece alrededor del pin)
+	const tPin = c.girar === false ? 0.2 : (c.duracion ?? 1.8) * 0.85;
+	const vuelo = c.acercar ? easeIO(clamp((t - tPin - 0.6) / (c.duracionVuelo ?? 1.2))) : 0;
+	const zoom = 1 + ((c.acercar ?? 1) - 1) * vuelo;
 	const color = c.color ?? '#E5484D';
 	return (
-		<div style={{position: 'relative', width: tam, height: tam}}>
+		<div style={{position: 'relative', width: tam, height: tam, transform: `scale(${zoom})`, transformOrigin: `${X}px ${Y}px`}}>
 			<svg width={tam} height={tam} style={{overflow: 'visible'}}>
 				<defs>
 					<radialGradient id="tierra-mar" cx="38%" cy="32%" r="75%">
@@ -390,7 +394,7 @@ export const Tierra: React.FC<{c: C; ctx: CtxEscena}> = ({c, ctx}) => {
 				<circle cx={cx} cy={cx} r={R} fill="url(#tierra-mar)" />
 				<g clipPath="url(#tierra-disco)">
 					{caminos.map((d, i) => (
-						<path key={i} d={d} fill="#6FBF73" stroke="#4E9A55" strokeWidth={1.2} strokeLinejoin="round" />
+						<path key={i} d={d} fill="#6FBF73" stroke="#4E9A55" strokeWidth={1.2} strokeLinejoin="round" vectorEffect="non-scaling-stroke" />
 					))}
 				</g>
 				<circle cx={cx} cy={cx} r={R} fill="url(#tierra-luz)" />
@@ -411,9 +415,48 @@ export const Tierra: React.FC<{c: C; ctx: CtxEscena}> = ({c, ctx}) => {
 	);
 };
 
-export const HISTORIAS = ['tierra', 'bloqueo', 'llamada', 'recuento', 'capitulo', 'vigilancia', 'cintillo', 'fecha', 'calendario', 'dividida'];
+/**
+ * Línea de tiempo vertical: la línea se dibuja hacia abajo y cada hito entra en su palabra (`en`), con el año en
+ * grande y su texto. `hitos: [{anio: 1963, texto: 'Nace en Taiwán', en: 'nació'}]`, `color`, `ancho`. El último que
+ * ya entró queda resaltado.
+ */
+export const Linea: React.FC<{c: C; ctx: CtxEscena}> = ({c, ctx}) => {
+	const hitos: C[] = c.hitos ?? [];
+	const color = c.color ?? ctx.tema.colores.acento;
+	const paso = c.paso ?? 190;
+	const tiempos = hitos.map((h, i) => cuando(h.en, ctx, 0.3 + i * 0.8));
+	const visibles = tiempos.filter((t0) => ctx.t >= t0).length;
+	const ultimo = visibles - 1;
+	// la línea llega hasta el último hito que ya entró (y avanza mientras entra)
+	const kUlt = ultimo >= 0 ? easeOut(clamp((ctx.t - tiempos[ultimo]) / 0.4)) : 0;
+	const largo = ultimo >= 0 ? (ultimo - 1 + kUlt) * paso + paso * 0.15 : 0;
+	return (
+		<div style={{position: 'relative', width: c.ancho ?? 820, height: hitos.length * paso, fontFamily: 'Montserrat, sans-serif'}}>
+			<div style={{position: 'absolute', left: 38, top: 30, width: 8, height: (hitos.length - 1) * paso, borderRadius: 4, background: 'rgba(255,255,255,0.18)'}} />
+			<div style={{position: 'absolute', left: 38, top: 30, width: 8, height: Math.max(0, largo + paso * 0.85), borderRadius: 4, background: color}} />
+			{hitos.map((h, i) => {
+				const k = easeOut(clamp((ctx.t - tiempos[i]) / 0.4));
+				if (k <= 0) return null;
+				const actual = i === ultimo;
+				return (
+					<div key={i} style={{position: 'absolute', left: 0, top: i * paso, display: 'flex', alignItems: 'flex-start', gap: 34, opacity: k, transform: `translateX(${(1 - k) * 40}px)`}}>
+						<div style={{width: 84, height: 84, borderRadius: '50%', background: actual ? color : '#1B1B1F', border: `6px solid ${color}`, boxShadow: actual ? `0 0 24px ${color}` : undefined, transform: `scale(${resorte(k, 0.3)})`, flex: 'none'}} />
+						<div style={{paddingTop: 2}}>
+							<div style={{color: actual ? color : '#FFFFFF', fontWeight: 900, fontSize: 64, lineHeight: 1}}>{h.anio ?? h.titulo}</div>
+							{h.texto ? <div style={{color: '#FFFFFF', fontWeight: 700, fontSize: 36, marginTop: 6, maxWidth: (c.ancho ?? 820) - 140, textShadow: '0 2px 10px rgba(0,0,0,0.5)'}}>{h.texto}</div> : null}
+						</div>
+					</div>
+				);
+			})}
+		</div>
+	);
+};
+
+export const HISTORIAS = ['linea', 'tierra', 'bloqueo', 'llamada', 'recuento', 'capitulo', 'vigilancia', 'cintillo', 'fecha', 'calendario', 'dividida'];
 export const Historias: React.FC<{c: C; ctx: CtxEscena}> = ({c, ctx}) => {
 	switch (c.tipo) {
+		case 'linea':
+			return <Linea c={c} ctx={ctx} />;
 		case 'tierra':
 			return <Tierra c={c} ctx={ctx} />;
 		case 'bloqueo':

package/remotion/motor/portada.tsx

@@ -0,0 +1,44 @@
+// Portada del video (salida/<título> (portada).jpg): el cuadro de la miniatura con el título grande abajo, la palabra
+// clave en color y la marca arriba. Distinta de la miniatura (que es el cuadro limpio): la portada es la que se ve en
+// el perfil y en la cuadrícula del canal, así que el título tiene que leerse en chiquito.
+import React from 'react';
+import {AbsoluteFill} from 'remotion';
+import {ANTON, ancho} from '../estilo';
+import {Avatar, MarcaContexto} from '../piezas';
+import type {Marca} from '../tipos';
+import {partesResaltadas} from './util';
+
+export const Portada: React.FC<{texto: string; marca: Marca; acento?: string}> = ({texto, marca, acento = marca.color ?? '#FFD400'}) => {
+	const letra = marca.letra ?? ANTON;
+	const limpio = texto.replace(/\*/g, '').toUpperCase();
+	// sin *palabra*, se resalta la última palabra larga
+	const marcado = texto.includes('*') ? texto : texto.replace(/([^\s]{5,})(?![\s\S]*\s[^\s]{5,})/, '*$1*');
+	let tam = 150;
+	try {
+		// en 2–3 renglones de 940 px
+		const w = ancho(limpio, letra, tam, 400);
+		if (w > 940 * 2.6) tam = Math.max(84, Math.floor((tam * 940 * 2.6) / w));
+	} catch {}
+	return (
+		<MarcaContexto.Provider value={marca}>
+			<AbsoluteFill>
+				<AbsoluteFill style={{background: 'linear-gradient(180deg, rgba(0,0,0,0.35) 0%, rgba(0,0,0,0) 22%, rgba(0,0,0,0) 45%, rgba(0,0,0,0.82) 78%, rgba(0,0,0,0.92) 100%)'}} />
+				{marca.nombre || marca.logo ? (
+					<div style={{position: 'absolute', left: 56, top: 110, display: 'flex', alignItems: 'center', gap: 18}}>
+						<div style={{position: 'relative', width: 96, height: 96}}>
+							<Avatar x={0} y={0} size={88} aro={5} />
+						</div>
+						{marca.nombre ? <div style={{fontFamily: 'Montserrat, sans-serif', fontWeight: 900, fontSize: 44, color: '#FFFFFF', textShadow: '0 3px 12px rgba(0,0,0,0.6)'}}>{marca.nombre}</div> : null}
+					</div>
+				) : null}
+				<div style={{position: 'absolute', left: 60, right: 60, bottom: 230, fontFamily: letra, fontSize: tam, lineHeight: 1.02, color: '#FFFFFF', textTransform: 'uppercase', textShadow: '0 8px 30px rgba(0,0,0,0.6)', WebkitTextStroke: `${Math.round(tam * 0.04)}px #000`, paintOrder: 'stroke fill'}}>
+					{partesResaltadas(marcado).map(([p, r], i) => (
+						<span key={i} style={r ? {color: acento} : undefined}>
+							{p}
+						</span>
+					))}
+				</div>
+			</AbsoluteFill>
+		</MarcaContexto.Provider>
+	);
+};

package/remotion/piezas.tsx

@@ -164,16 +164,16 @@ export const Avatar: React.FC<{x: number; y: number; size: number; aro: number}>
 						width: size,
 						height: size,
 						borderRadius: '50%',
-						background: 'linear-gradient(#5A3CAA, #2A1650)',
+						background: marca.color ? `linear-gradient(${marca.color}, #111)` : 'linear-gradient(#5A3CAA, #2A1650)',
 						color: '#fff',
 						fontFamily: ANTON,
-						fontSize: size * 0.55,
+						fontSize: size * (marca.siglas && marca.siglas.length > 1 ? 0.42 : 0.55),
 						display: 'flex',
 						alignItems: 'center',
 						justifyContent: 'center',
 					}}
 				>
-					{(marca.nombre.trim()[0] || 'M').toUpperCase()}
+					{(marca.siglas || marca.nombre.trim()[0] || 'M').toUpperCase().slice(0, 3)}
 				</div>
 			)}
 		</div>

package/remotion/tipos.ts

@@ -34,6 +34,9 @@ export type Datos = {
 export type Marca = {
 	nombre: string; // "" = sin etiqueta
 	logo: string | null; // ruta dentro de la carpeta public (la copia morfeo), o null = inicial del nombre
+	siglas?: string; // sin logo: estas siglas (2–3 letras) en vez de la inicial
+	color?: string; // color del círculo de las siglas y acento de la portada
+	letra?: string; // letra de títulos del estilo propio (portada)
 	redes: string; // línea pequeña bajo el botón de la escena "cta" ("" = nada)
 	seguir: string; // texto del botón de la escena "cta"
 	siguiendo: string; // texto del botón ya pulsado