morfeo 0.4.0 → 0.5.1

package/README.md

@@ -1,6 +1,6 @@
 # Morfeo
 
-> **Documentación: [morfeo-docs-two.vercel.app](https://morfeo-docs-two.vercel.app/)** · Ejemplos: [github.com/UreckChan/morfeo](https://github.com/UreckChan/morfeo) · Versiones: [historial](https://morfeo-docs-two.vercel.app/historial)
+> **Documentación: [morfeo.ureck.dev](https://morfeo.ureck.dev/)** · Ejemplos: [github.com/UreckChan/morfeo](https://github.com/UreckChan/morfeo) · Versiones: [historial](https://morfeo.ureck.dev/historial)
 
 Genera videos verticales animados (Shorts, TikTok, Reels) desde código: escribes las escenas y Morfeo agrega
 la voz, la música, los efectos de sonido, los subtítulos, las animaciones y la miniatura.

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);
@@ -65,6 +66,9 @@ export function revisarEstructura(v, d) {
 	// formato largo: explicador de maqueta (o `formato: 'largo'` en el video)
 	const formula = formulaDe(v.formula);
 	const largo = v.estilo === 'maqueta' || v.formato === 'largo' || (formula?.duracion[1] ?? 0) > 90;
+	// a qué se compara: los explicadores de maqueta (100–130 s) o la duración de la fórmula (biografía 90–180 s…)
+	const enLargo = v.estilo === 'maqueta' || !formula ? 'en maqueta' : `en la fórmula "${formula.id}"`;
+	const rangoLargo = v.estilo === 'maqueta' || !formula ? [100, 130] : formula.duracion;
 
 	// 1) gancho
 	const dicho = String(primera.say ?? '').trim();
@@ -78,8 +82,8 @@ export function revisarEstructura(v, d) {
 	const es = d?.escenas?.filter((e) => e.tipo !== 'cta') ?? [];
 	if (es.length) {
 		const dur = d.duracion;
-		if (largo && dur > 140) add('duracion', 'idea', `Dura ${Math.round(dur)} s: los explicadores de maqueta de referencia van de 100 a 130 s.`);
-		else if (largo && dur < 60) add('duracion', 'idea', `Dura ${Math.round(dur)} s: en maqueta los de referencia duran 100–130 s; hay espacio para otra pregunta y su respuesta.`);
+		if (largo && dur > rangoLargo[1] + 10) add('duracion', 'idea', `Dura ${Math.round(dur)} s: ${enLargo} los de referencia van de ${rangoLargo[0]} a ${rangoLargo[1]} s.`);
+		else if (largo && dur < 60) add('duracion', 'idea', `Dura ${Math.round(dur)} s: ${enLargo} los de referencia duran ${rangoLargo[0]}–${rangoLargo[1]} s; hay espacio para otra pregunta y su respuesta.`);
 		else if (!largo && dur > 75) add('duracion', 'idea', `Dura ${Math.round(dur)} s: los de referencia rondan 60 s. Si no es una serie o una historia, recorta (o usa estilo maqueta para un explicador largo).`);
 		if (dur < 20) add('duracion', 'idea', `Dura ${Math.round(dur)} s: un poco más de desarrollo (una pregunta y su respuesta) suele retener mejor.`);
 		const e0 = es[0];
@@ -90,7 +94,7 @@ export function revisarEstructura(v, d) {
 			// algo que cambie a media escena: capas con `en`, cámara con rango, toma con movimiento, o un mundo vivo
 			const capas = s.capas ?? [];
 			const cambia = capas.some((c) => c.en != null && c.en !== 0 && c.en !== 'inicio') || Array.isArray(s.camara?.zoom) || s.toma?.a || capas.some((c) => c.mover || c.cambios);
-			if (largo && voz > 4.5) add('ritmo', 'idea', `Escena ${i + 1}: ${voz.toFixed(1)} s en una sola toma; en maqueta la cámara corta cada 2–3 s. Pártela en dos tomas.`);
+			if (largo && voz > 4.5) add('ritmo', 'idea', `Escena ${i + 1}: ${voz.toFixed(1)} s en una sola toma; ${enLargo} la cámara corta cada 2–3 s. Pártela en dos tomas.`);
 			else if (voz > 6 && !cambia && !v.mundo?.length) add('ritmo', 'aviso', `Escena ${i + 1}: ${voz.toFixed(1)} s de voz sin que nada cambie. Pártela en dos o haz que algo entre a media frase.`);
 			else if (voz > 9) add('ritmo', 'idea', `Escena ${i + 1}: ${voz.toFixed(1)} s de voz en una sola escena; en los de referencia ninguna idea pasa de ~5 s.`);
 		});
@@ -109,10 +113,12 @@ export function revisarEstructura(v, d) {
 	// 5) habla de tú
 	const todo = cuerpo.map((s) => s.say ?? '').join(' ');
 	const n = palabrasDe(todo).length;
-	const tu = (todo.match(/\b(tú|tu|tus|te|ti|contigo|imagina|imaginas|tienes|eres|puedes|sabes|sabías|crees|conoces|harías|pagarías)\b/gi) ?? []).length;
+	const tu = (todo.match(/(?<!\p{L})(tú|tu|tus|te|ti|contigo|imagina|imaginas|tienes|eres|puedes|sabes|sabías|crees|conoces|harías|pagarías|jugabas|tuviste|tuyo|tuya)(?!\p{L})/giu) ?? []).length;
 	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;
 }