morfeo 0.1.3 → 0.2.1

package/bin/morfeo.mjs

@@ -20,6 +20,9 @@ Videos
   render [id...]        Genera los videos que faltan (o los que indiques)
       --todos             regenera todos
       --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
+  hoja <id>             Hoja de contacto (PNG con 15 cuadros) para revisar un video de un vistazo
+      --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
   recursos temas        Diccionario de objetos 2D/3D por temática
@@ -48,7 +51,7 @@ function opciones(argv) {
 			const [k, v] = a.slice(2).split('=');
 			const clave = k.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
 			const sig = argv[i + 1];
-			const conValor = ['proyecto', 'desde', 'id', 'voz', 'duracion', 'idioma', 'estilo', 'tono', 'variante', 'fuente', 'musica', 'titulo', 'modelo', 'puerto'];
+			const conValor = ['proyecto', 'desde', 'id', 'voz', 'duracion', 'idioma', 'estilo', 'tono', 'variante', 'fuente', 'musica', 'titulo', 'modelo', 'puerto', 'hasta', 'cols', 'filas'];
 			if (v != null) op[clave] = v;
 			else if (conValor.includes(clave) && sig != null && !sig.startsWith('--')) op[clave] = argv[++i];
 			else op[clave] = true;
@@ -95,6 +98,37 @@ async function main() {
 			await render({proyecto, ids: pos, todos: !!op.todos || pos[0] === 'todos'});
 			return;
 		}
+		case 'revisar': {
+			const {cargarProyecto} = await import('../lib/config.mjs');
+			const {revisarEstructura, consejosEnTexto, REGLAS} = await import('../lib/estructura.mjs');
+			const p = await cargarProyecto(proyecto);
+			const ids = pos.length ? pos : Object.keys(p.videos);
+			const fs = await import('node:fs');
+			let total = 0;
+			for (const id of ids) {
+				if (!p.videos[id]) throw new ErrorMorfeo(`No existe el video ${id}. Usa: npx morfeo lista`);
+				// tiempos reales si ya se preparó la voz (después de un render); si no, solo el texto
+				const f = path.join(p.trabajo, 'public', 'v', id, 'datos.json');
+				const d = fs.existsSync(f) ? JSON.parse(fs.readFileSync(f, 'utf8')) : null;
+				const c = revisarEstructura(p.videos[id], d);
+				total += c.length;
+				console.log(c.length ? `${id}${d ? '' : '  (sin tiempos: renderízalo para revisar el ritmo)'}\n${consejosEnTexto(c)}` : `${id}  ✔`);
+			}
+			if (total) console.log(`\nReglas completas: ${REGLAS.map((r) => r.regla.toLowerCase()).join(' · ')}`);
+			return;
+		}
+		case 'hoja': {
+			const {cargarProyecto} = await import('../lib/config.mjs');
+			const {hoja} = await import('../lib/hoja.mjs');
+			if (!pos.length) throw new ErrorMorfeo('¿De cuál video?  npx morfeo hoja <id>');
+			const p = await cargarProyecto(proyecto);
+			const num = (v) => (v == null || v === true ? undefined : Number(v));
+			for (const id of pos) {
+				const video = /\.(mp4|mov|webm)$/i.test(id) ? path.resolve(id) : path.join(p.salida, `${id}.mp4`);
+				console.log(hoja({video, cols: num(op.cols), filas: num(op.filas), desde: num(op.desde), hasta: num(op.hasta)}));
+			}
+			return;
+		}
 		case 'studio': {
 			const {studio} = await import('../lib/render.mjs');
 			return studio({proyecto, puerto: op.puerto});

package/index.d.ts

@@ -28,7 +28,7 @@ export type Objeto3D = 'corazon' | 'estrella' | 'rayo' | 'diamante' | 'trofeo' |
 
 /** Momento: segundos desde que empieza la escena, una palabra de `say` ("orcas"), "voz", "fin", o "palabra+0.3". */
 export type Momento = number | string;
-export type Entrada = 'escala' | 'rebote' | 'aparecer' | 'subir' | 'caer' | 'girar' | 'deslizar-izq' | 'deslizar-der' | 'deslizar-arriba' | 'deslizar-abajo' | 'ninguna';
+export type Entrada = 'escala' | 'rebote' | 'aparecer' | 'subir' | 'caer' | 'girar' | 'deslizar-izq' | 'deslizar-der' | 'deslizar-arriba' | 'deslizar-abajo' | 'ninguna' | 'enfocar';
 
 interface CapaBase {
 	/** Centro en el lienzo 1080×1920 (dentro de un grupo o teléfono: relativo a su centro). */
@@ -52,6 +52,14 @@ interface CapaBase {
 	latir?: boolean;
 	voltear?: boolean;
 	desenfoque?: number;
+	/** Curva de la entrada de esta capa (por defecto, la del estilo). */
+	curva?: 'suave' | 'resorte' | 'seca';
+	duracionEntrada?: number;
+	/** Sigue a otra capa: `x`, `y` pasan a ser la distancia al centro de la capa con ese `id`. */
+	sigue?: string;
+	id?: string;
+	/** En un video con `mundo`: la capa vive en el mundo (coordenadas del mundo) y la cámara la mueve con él. */
+	enMundo?: boolean;
 	sombra?: boolean | string;
 	z?: number;
 	/** Efecto de sonido al aparecer. */
@@ -64,6 +72,19 @@ export type Capa = CapaBase &
 	(
 		| {tipo: 'imagen'; src?: string; generar?: string; ancho?: number; alto?: number; redondo?: boolean; radio?: number; cambiarA?: {src: string; en?: Momento; efecto?: 'fundido' | 'barrido' | 'circulo'; duracion?: number}}
 		| {tipo: 'video'; src: string; ancho?: number; alto?: number; radio?: number}
+		/** Anotaciones: señalan y explican lo que hay en pantalla. `medida` y `trazo` usan coordenadas del lienzo. */
+		| {tipo: 'dato'; valor: number | string; unidad?: string; de?: number; duracion?: number; decimales?: number; tam?: number; color?: string; fondo?: string}
+		| {tipo: 'medida'; de: [number, number]; a: [number, number]; texto?: string; unidad?: string; tam?: number; color?: string; grosor?: number; tope?: number; separacion?: number; duracion?: number}
+		| {tipo: 'trazo'; puntos: [number, number][]; flecha?: boolean; punteado?: boolean | number; color?: string; grosor?: number; duracion?: number; velocidad?: number}
+		| {tipo: 'contorno'; forma?: 'rect' | 'circulo' | 'aro'; ancho?: number; alto?: number; radio?: number; color?: string; grosor?: number; punteado?: boolean; relleno?: string; velocidad?: number; duracion?: number}
+		| {tipo: 'fuente'; texto: string; etiqueta?: string; tam?: number; color?: string; colorTexto?: string}
+		| {tipo: 'seccion'; texto: string; tam?: number; color?: string}
+		| {tipo: 'insignia'; texto: string | number; tam?: number; fondo?: string; colorTexto?: string; inclinar?: number}
+		| {tipo: 'sello'; texto: string; tam?: number; color?: string; inclinar?: number}
+		| {tipo: 'terminal'; lineas: (string | {texto: string; en?: Momento; salida?: boolean; color?: string})[]; titulo?: string; ancho?: number; tam?: number; fondo?: string; velocidad?: number}
+		| {tipo: 'nombre'; texto: string; sub?: string; tam?: number; fondo?: string; colorTexto?: string; borde?: string}
+		| {tipo: 'accion'; texto: string; tam?: number; color?: string; fondo?: string; colorTexto?: string}
+		| {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'; alinear?: 'center' | 'left' | 'right'; interlineado?: number; escribir?: boolean | number; subrayado?: boolean}
 		| {tipo: 'contador'; de?: number; a: number; prefijo?: string; sufijo?: string; decimales?: number; miles?: string; decimal?: string; duracion?: number; curva?: 'suave' | 'lineal' | 'exponencial'; formato?: 'grande' | 'lcd' | 'chip'; tam?: number; color?: string; fondo?: string}
 		| {tipo: 'chip'; texto: string; unidad?: string; tam?: number; color?: string; fondo?: string; borde?: string}
@@ -105,12 +126,26 @@ export type FondoEscena =
 /** Escenarios ilustrados incluidos (animados). bosque: paneo, luna {cara, cantar, bajar, a}; cuarto: dia, parte; tunel: llegar; pasillo: golpe. */
 export type Escenario = 'bosque' | 'cuarto' | 'departamento' | 'tunel' | 'pasillo';
 
+export type Transicion = 'corte' | 'fundido' | 'deslizar' | 'zoom' | 'barrido' | 'empuje' | 'mascara' | 'destello';
+
 interface EscenaMotorBase extends EscenaBase {
 	capas?: Capa[];
 	fondo?: FondoEscena;
 	/** Cámara: número fijo o [inicio, fin] a lo largo de la escena. */
 	camara?: {zoom?: number | [number, number]; x?: number | [number, number]; y?: number | [number, number]; en?: number; duracion?: number; origen?: [number, number]; temblor?: {fuerza?: number; duracion?: number}};
-	transicion?: 'corte' | 'fundido' | 'deslizar' | 'zoom';
+	transicion?: Transicion;
+	/**
+	 * En un video con `mundo`: a dónde mira la cámara en esta escena. `x`, `y` = punto del mundo que queda al centro.
+	 * La cámara viaja desde donde terminó la escena anterior (`duracion` s; `corte: true` salta) y luego deriva
+	 * despacio (`deriva`: cuánto acerca, 0.05 por defecto) o se mueve hasta `a`. Sin `toma` conserva la anterior.
+	 */
+	toma?: {x?: number; y?: number; zoom?: number; giro?: number; duracion?: number; corte?: boolean; deriva?: number; a?: {x?: number; y?: number; zoom?: number; giro?: number}};
+	/** Rótulo grande y corto que resume el momento (segundo nivel de texto): '¿CUÁNTO *SUBIÓ*?'. `rotuloEn`: palabra o segundos. */
+	rotulo?: string;
+	rotuloEn?: Momento;
+	rotuloTam?: number;
+	/** Palabras clave de la escena para los subtítulos (la que lleva caja o color de acento en cada frase). */
+	claves?: string[];
 	/** Ajustes del tema solo para esta escena. */
 	tema?: Partial<Tema>;
 }
@@ -124,7 +159,7 @@ export type EscenaMotor =
 	| (EscenaMotorBase & {type: 'telefono'; src?: string; capasPantalla?: Capa[]; texto?: string; ancho?: number; y?: number})
 	| (EscenaMotorBase & {type: 'comparar'; a: string | {texto: string; imagen?: string; color?: string}; b: string | {texto: string; imagen?: string; color?: string}; at?: string})
 	| (EscenaMotorBase & {type: 'eleccion'; pregunta?: string; opciones: (string | {texto: string; sub?: string; objeto?: Objeto3D; emoji?: string; icono?: Icono; imagen?: string; color?: string; fondo?: string; en?: Momento})[]; formato?: 'cartas' | 'botones'; comenta?: string | false; enComenta?: Momento; y?: number})
-	| (Partial<EscenaMotorBase> & {type: 'cta'});
+	| (Partial<EscenaMotorBase> & {type: 'cta'; /** Pide una acción concreta en vez de solo seguir. */ pide?: 'comenta' | 'comparte'; /** comenta: la palabra a escribir. */ palabra?: string; /** comparte: a quién se lo mandan. */ a?: string; texto?: string; sub?: string});
 
 export interface Tema {
 	fondo: FondoEscena;
@@ -136,8 +171,17 @@ export interface Tema {
 	colores: {texto: string; acento: string; acento2: string; suave: string; tarjeta: string; tarjetaTexto: string; borde: string};
 	fuentes: {titulo: string; texto: string; mono: string};
 	tituloMayusculas: boolean;
-	subtitulos: {tipo: 'karaoke' | 'pop' | 'bloque' | 'palabra' | 'ninguno'; y: number; tam: number; color: string; pendiente: string; resalte: string; maxPalabras: number; mayusculas?: boolean; contorno?: number; fondo?: string};
-	transicion: 'corte' | 'fundido' | 'deslizar' | 'zoom';
+	subtitulos: {tipo: 'karaoke' | 'seleccion' | 'pop' | 'bloque' | 'palabra' | 'caja' | 'ninguno'; y: number; tam: number; color: string; pendiente: string; resalte: string; maxPalabras: number; mayusculas?: boolean; contorno?: number; fondo?: string};
+	transicion: Transicion;
+	/** Ritmo de las animaciones: duraciones (s) y curva de las entradas. */
+	movimiento?: {entrada?: number; salida?: number; transicion?: number; curva?: 'suave' | 'resorte' | 'seca'};
+	/** Acabado sobre todo el cuadro: tinte, cono de luz y desenfoque de bordes. */
+	post?: {
+		tinte?: {color: string; fuerza?: number; modo?: 'multiply' | 'screen' | 'overlay' | 'soft-light'};
+		luz?: {x?: number; y?: number; ancho?: number; largo?: number; color?: string; fuerza?: number; angulo?: number};
+		desenfoqueBordes?: number;
+		vinetaColor?: string;
+	};
 	marca: 'esquina' | 'arriba' | 'ninguna';
 	zoomLento: number;
 }
@@ -181,6 +225,14 @@ export interface Video {
 	estilo?: Estilo;
 	/** Capas fijas encima de todo el video (día, barras, hora...); se actualizan con `cambios`. */
 	hud?: Capa[];
+	/**
+	 * Mundo del video: capas (normalmente un `componente` tuyo más grande que el cuadro) que duran todo el video.
+	 * La cámara las recorre con la `toma` de cada escena, en lugar de cambiar de fondo en cada una.
+	 * El componente recibe además `escena` (1, 2, 3...), `tEscena`, `inicios` y `camara` (para paralaje).
+	 */
+	mundo?: Capa[];
+	/** Pastilla fija arriba para series: 'GYM CON CIENCIA · PARTE 5'. */
+	serie?: string;
 	/** Ajustes del estilo para este video (colores, fondo, subtítulos...). */
 	tema?: Partial<Tema> & Record<string, unknown>;
 	/** Título para publicar. */

package/lib/config.mjs

@@ -23,7 +23,7 @@ export const TIPOS_CLASICOS = ['title', 'year', 'text', 'icon', 'compare', 'card
 export const TIPOS_MOTOR = ['capas', 'titular', 'dato', 'lista', 'telefono', 'comparar', 'eleccion', 'cta'];
 export const TIPOS_ESCENA = [...new Set([...TIPOS_CLASICOS, ...TIPOS_MOTOR])];
 export const ESTILOS = ['datos-curiosos', 'explicativo', 'documental', 'ilustrado', 'historia', 'mesa', 'serie', 'infografia', '3d', 'minimal'];
-export const TIPOS_CAPA = ['imagen', 'video', 'texto', 'contador', 'chip', 'etiqueta', 'numero', 'tarjeta', 'telefono', 'forma', 'icono', 'emoji', 'marca', 'particulas', 'grupo', 'modelo', 'componente', 'barra', 'medidor', 'votacion', 'estado', 'noticia', 'chat', 'onda', 'globo', 'seguir', 'personaje', 'escena3d', 'ventana', 'escenario', 'recurso'];
+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'];
 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'];
@@ -32,11 +32,12 @@ export const MUSICAS = ['lofi', 'lofi2', 'chillpop', 'synth', 'house', 'ballad',
 export class ErrorMorfeo extends Error {}
 
 /**
- * WebGL por defecto: en Mac con Apple Silicon la tarjeta de video (angle) es estable y ~4 veces más rápida;
- * en lo demás, por software (swangle), que funciona en cualquier computadora. Si angle falla, el render
- * reintenta solo con swangle.
+ * WebGL por defecto: en Mac con Apple Silicon y en Windows la tarjeta de video (angle) es ~4 veces más rápida
+ * (Windows con RTX 3060: 23 s vs 91 s); en lo demás, por software (swangle), que funciona en cualquier
+ * computadora. Si angle falla, el render reintenta solo con swangle.
  */
-export const glPorDefecto = () => (process.platform === 'darwin' && process.arch === 'arm64' ? 'angle' : 'swangle');
+export const glPorDefecto = () =>
+	(process.platform === 'darwin' && process.arch === 'arm64') || process.platform === 'win32' ? 'angle' : 'swangle';
 
 /** Una carpeta de guiones: cada <id>.json o <id>.mjs es un video. */
 async function leerCarpeta(dir) {
@@ -151,8 +152,9 @@ export async function cargarProyecto(proyecto = process.cwd()) {
 			crf: r.crf ?? 18,
 			gl: process.env.MORFEO_GL || process.env.REMOTION_GL || r.gl || glPorDefecto(),
 			navegador: process.env.MORFEO_NAVEGADOR || r.navegador || null,
-			concurrencia: r.concurrencia ?? null, // null = Morfeo elige según la máquina y el modo (ver render.mjs)
+			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,
 		},
 	};
 }
@@ -311,9 +313,10 @@ function validarVideo(id, v, ctx) {
 	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);
+	if (v.mundo != null) validarCapas(v.mundo, 'mundo', err);
 	// archivos de assets/ que piden las escenas y el HUD: mejor avisar ahora que a mitad del render
-	revisarArchivos({scenes, hud: v.hud, tema: v.tema}, ctx.assetsDir, err);
-	revisarPersonajes({scenes, hud: v.hud}, ctx.personajes, err);
+	revisarArchivos({scenes, hud: v.hud, mundo: v.mundo, tema: v.tema}, ctx.assetsDir, err);
+	revisarPersonajes({scenes, hud: v.hud, mundo: v.mundo}, ctx.personajes, err);
 	revisarEscenarios({scenes, hud: v.hud, tema: v.tema}, err);
 	return {...v, estilo, voice, music: normalizarMusica(v.music, ctx, err), scenes};
 }

package/lib/estructura.mjs

@@ -0,0 +1,104 @@
+// Estructura base de un video corto que retiene: reglas medidas en 19 videos de referencia (virales y bien hechos),
+// una revisión automática de cada guion y el texto que se le da a la IA cuando escribe guiones.
+//
+// Mediciones (2026-11, 19 videos de 38 a 179 s, la mayoría ~55–65 s):
+//   - Todos arrancan DENTRO de la escena: el sujeto ya está en pantalla en el cuadro 1 y la voz empieza de inmediato.
+//     Ninguno abre con un título, un logo o una presentación.
+//   - Primeras palabras = gancho en segunda persona o con una cifra imposible: "Imagina que te despierta una alerta
+//     nuclear", "¿Y si tu nariz creciera cada vez que respiras?", "Si tu pareja te dice que ya no siente lo mismo",
+//     "A diez abuelitos de noventa los pusieron a levantar pesas", "Este es Alberto. Pero en el pueblo todos le...".
+//   - Ritmo: los de cortes rápidos cambian de plano cada 2,5–5 s (11–22 cortes por minuto; uno llega a 1,5 s).
+//     Los de mundo continuo casi no cortan (1–5 por minuto) pero la cámara nunca se queda quieta y entra algo nuevo
+//     (etiqueta, dato, personaje) cada 2–4 s.
+//   - Texto en dos niveles: subtítulo chico (lo que se dice) + un rótulo grande con la idea del momento
+//     ("¿CUÁNTO SUBIÓ?", "¡CASI EL TRIPLE!", "SALIR DE CASA", "DÍA 21").
+//   - Preguntas antes de cada revelación ("¿Para qué?", "¿Cuánto subió?", "¿...o músculo?") y la respuesta con un número
+//     que cuenta o un golpe visual.
+//   - Datos y nombres pegados a lo que señalan: "DOÑA ROSA · la mamá, 48 años", "▶ Te despiertas", "EL CABLE", "57 toneladas".
+//   - Series: una pastilla fija arriba ("TITO DESDE CERO · EP. 1", "GYM CON CIENCIA · PARTE 5") y contadores persistentes.
+//   - Cierre con una acción concreta, no solo "sígueme": elegir A o B en comentarios, "escribe PASO si entendiste",
+//     "mándaselo al que dice que...", cuenta regresiva para la próxima parte.
+
+/** Las reglas, en el orden en que se le explican a la IA y a quien escribe un guion. */
+export const REGLAS = [
+	{id: 'gancho', regla: 'Gancho en los primeros 2 segundos', como: 'La primera frase pone al espectador dentro ("Imagina que…", "¿Y si tu…?", "Si tu…") o suelta una cifra o situación imposible. El sujeto ya está en pantalla desde el cuadro 1. Nada de títulos, logos ni "hoy te voy a contar".'},
+	{id: 'tu', regla: 'Habla de tú', como: 'Segunda persona y presente: "te despiertas", "abres la puerta". Si es una historia, un nombre propio en la primera frase ("Este es Alberto").'},
+	{id: 'ritmo', regla: 'Algo nuevo cada 2–4 segundos', como: 'Escenas de 2 a 5 s de voz (una idea por escena). Si la escena dura más, que algo entre a media frase (un dato, una etiqueta, un movimiento de cámara).'},
+	{id: 'pregunta', regla: 'Pregunta antes de revelar', como: 'Antes de cada dato fuerte, la pregunta que el espectador se haría ("¿Cuánto subió?"); la respuesta llega en la escena siguiente con un número que cuenta o un golpe visual.'},
+	{id: 'rotulo', regla: 'Texto en dos niveles', como: 'El subtítulo dice lo que se oye; un rótulo grande y corto (2–4 palabras) resume el momento: "¿CUÁNTO SUBIÓ?", "SALIR DE CASA", "DÍA 21".'},
+	{id: 'etiquetas', regla: 'Datos pegados a las cosas', como: 'Nombres y cifras junto a lo que señalan (nombre de personaje con su rol, "▶ acción", "57 toneladas" junto a la ballena), no en un letrero aparte.'},
+	{id: 'escalada', regla: 'Que suba la apuesta', como: 'Cada escena más grave, más grande o más rara que la anterior; lo más fuerte cerca del final, no al principio.'},
+	{id: 'cierre', regla: 'Cierre con una acción concreta', como: 'Pide algo fácil y específico: elegir A o B en comentarios, escribir una palabra ("escribe PASO"), mandárselo a alguien ("mándaselo al que dice que…") o esperar la parte 2. "Sígueme" solo no basta.'},
+	{id: 'bucle', regla: 'Final que conecta con el inicio', como: 'La última frase puede regresar a la primera imagen o dejar una pregunta abierta, para que se vuelva a ver.'},
+	{id: 'duracion', regla: 'Entre 30 y 65 segundos', como: 'La mayoría de los de referencia dura ~1 minuto. Más de 75 s solo si es una serie o una historia que lo sostiene.'},
+];
+
+/** Las reglas como texto para el prompt de la IA. */
+export const REGLAS_TEXTO = `Estructura (medida en videos virales; síguela):
+${REGLAS.map((r, i) => `${i + 1}. ${r.regla}: ${r.como}`).join('\n')}`;
+
+const palabrasDe = (s) => String(s ?? '').trim().split(/\s+/).filter(Boolean);
+const GANCHOS = /^(¿|imagina|y si|si tu|si te|si un|qué pasaría|que pasaria|este es|esta es|esto es|nadie|nunca|todos|a \S+ |hay |tu |tú |te |tienes|cuando)/i;
+
+/**
+ * Revisa la estructura de un video y devuelve consejos (no bloquea el render).
+ * @param {object} v   el video ya validado (scenes, mundo, serie...)
+ * @param {object} [d] datos.json de ese video (tiempos reales de la voz); sin él solo se revisa el texto
+ * @returns {{id: string, nivel: 'aviso' | 'idea', texto: string}[]}
+ */
+export function revisarEstructura(v, d) {
+	const out = [];
+	const add = (id, nivel, texto) => out.push({id, nivel, texto});
+	const escenas = (v.scenes ?? []).filter(Boolean);
+	const cuerpo = escenas.filter((s) => s.type !== 'cta');
+	if (!cuerpo.length) return out;
+	const primera = cuerpo[0];
+	const clasico = (v.estilo ?? 'datos-curiosos') === 'datos-curiosos';
+
+	// 1) gancho
+	const dicho = String(primera.say ?? '').trim();
+	if (!GANCHOS.test(dicho) && !/\d/.test(primera.show ?? '') && !/\?/.test(dicho))
+		add('gancho', 'idea', `La primera frase ("${dicho.slice(0, 50)}${dicho.length > 50 ? '…' : ''}") no engancha de entrada: prueba "Imagina que…", "¿Y si tu…?" o una cifra imposible.`);
+	if (!clasico && !v.mundo?.length && ['titular', 'dato', 'lista'].includes(primera.type) && !(primera.capas ?? []).length)
+		add('gancho', 'aviso', 'El video abre con un letrero sin imagen. En los videos de referencia el sujeto ya está en pantalla desde el primer cuadro.');
+	if (/^(hola|hoy|bienvenid|en este video|te voy a)/i.test(dicho)) add('gancho', 'aviso', 'No abras presentando ("Hoy te voy a contar…"): entra directo a la situación.');
+
+	// 2) ritmo y duración (con los tiempos reales si ya hay voz)
+	const es = d?.escenas?.filter((e) => e.tipo !== 'cta') ?? [];
+	if (es.length) {
+		const dur = d.duracion;
+		if (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.`);
+		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];
+		if (e0 && e0.habla?.[0] > 0.5) add('gancho', 'aviso', `La voz tarda ${e0.habla[0].toFixed(1)} s en empezar: debe arrancar de inmediato.`);
+		es.forEach((e, i) => {
+			const s = cuerpo[i] ?? {};
+			const voz = (e.habla?.[1] ?? 0) - (e.habla?.[0] ?? 0);
+			// 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 (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.`);
+		});
+	}
+
+	// 3) preguntas y rótulos
+	const preguntas = cuerpo.slice(1).filter((s) => /\?/.test(s.say ?? '') || /\?/.test(s.rotulo ?? ''));
+	if (cuerpo.length >= 4 && !preguntas.length) add('pregunta', 'idea', 'Ninguna pregunta a media historia: antes del dato más fuerte pon la pregunta que se haría el espectador ("¿Cuánto subió?").');
+	if (!clasico && cuerpo.length >= 4 && !cuerpo.some((s) => s.rotulo || s.type === 'titular')) add('rotulo', 'idea', 'Sin rótulos: un `rotulo` corto en 2–3 escenas clave ("¿CUÁNTO SUBIÓ?") da el segundo nivel de texto que usan los de referencia.');
+
+	// 4) cierre
+	const fin = escenas.at(-1);
+	const pideAlgo = escenas.some((s) => s.type === 'eleccion') || (fin?.type === 'cta' && fin.pide) || /comenta|escribe|mándaselo|mandaselo|comparte|elige|parte 2|siguiente parte/i.test(cuerpo.at(-1)?.say ?? '');
+	if (!pideAlgo) add('cierre', 'idea', "El cierre solo pide seguir. Pide algo concreto: {type: 'cta', pide: 'comenta', palabra: 'PASO'}, pide: 'comparte' o una escena 'eleccion' (A o B).");
+
+	// 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|tienes|eres|puedes|sabes)\b/gi) ?? []).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.');
+	return out;
+}
+
+/** Consejos en texto para la terminal. */
+export const consejosEnTexto = (lista) => lista.map((c) => `    ${c.nivel === 'aviso' ? '!' : '·'} ${c.texto}`).join('\n');

package/lib/guion.mjs

@@ -5,6 +5,7 @@ import os from 'node:os';
 import path from 'node:path';
 import {ErrorMorfeo, MUSICAS} from './config.mjs';
 import {listaTemas} from './diccionario.mjs';
+import {REGLAS_TEXTO} from './estructura.mjs';
 
 export const MODELO_GUION = 'claude-opus-5-5';
 export const TIPOS_IA = ['title', 'year', 'text', 'icon', 'compare', 'card', 'dialog'];
@@ -27,7 +28,7 @@ export const slug = (s) => {
 	return corto.slice(0, Math.max(corto.lastIndexOf('-'), 12)).replace(/-+$/, '') || 'video';
 };
 
-const INSTRUCCIONES = `Eres guionista de videos cortos verticales (YouTube Shorts / TikTok / Reels) de 25 a 45 segundos.
+const INSTRUCCIONES = `Eres guionista de videos cortos verticales (YouTube Shorts / TikTok / Reels) de 30 a 60 segundos.
 Escribes en el idioma que se te pida, con frases cortas, naturales y fáciles de decir en voz alta.
 
 Un video es una lista de escenas. Cada escena tiene "say": lo que dice la voz (una o dos frases cortas).
@@ -35,7 +36,7 @@ Los números y años en "say" van ESCRITOS CON LETRAS ("mil novecientos ochenta"
 en ese caso pon en "show" la misma frase con cifras ("1980") para el subtítulo. Si no hay números, "show" es null.
 
 Tipos de escena (elige el que mejor ilustre cada frase y varíalos):
-- title: el gancho, SIEMPRE la primera. "rows": 2-3 filas de texto grande; la última es el remate (color amarillo o rojo). "icon": un ícono.
+- title: el gancho, SIEMPRE la primera. "say" es la frase gancho (ver Estructura); "rows": 2-3 filas con lo esencial del gancho; la última es el remate (color amarillo o rojo). "icon": un ícono.
 - year: una fecha clave. "pre": contexto corto (p. ej. "JAPÓN"), "year": el año como número, "sub": qué pasó (2-3 palabras).
 - text: 1-3 filas de texto grande con la idea clave.
 - icon: un ícono grande con "label" (2-3 palabras) y "color".
@@ -47,7 +48,9 @@ Tipos de escena (elige el que mejor ilustre cada frase y varíalos):
 Reglas de texto en pantalla: MAYÚSCULAS, máximo 14 letras por fila, tamaños ("size") entre 110 y 260 (más corto = más grande).
 Colores disponibles: blanco, amarillo, rojo, verde, cian. Usa blanco para lo normal y un color para lo importante.
 "at" y "click" deben ser palabras que aparezcan tal cual en "say".
-No incluyas la escena final de "sígueme": morfeo la agrega sola.`;
+No incluyas la escena final de "sígueme": morfeo la agrega sola; la última escena tuya pide algo concreto (comentar una palabra, elegir, mandárselo a alguien).
+
+${REGLAS_TEXTO}`;
 
 /** Esquema plano (todas las claves presentes, null cuando no aplican) para la salida estructurada. */
 export async function esquema() {
@@ -93,7 +96,7 @@ const OBJETOS = ['corazon', 'estrella', 'rayo', 'diamante', 'trofeo', 'cohete',
 
 const ESTILOS_MOTOR = ['explicativo', 'documental', 'ilustrado', 'historia', 'mesa', 'minimal'];
 
-const INSTRUCCIONES_MOTOR = `Eres guionista y director de arte de videos cortos verticales (YouTube Shorts / TikTok / Reels) de 25 a 60 segundos.
+const INSTRUCCIONES_MOTOR = `Eres guionista y director de arte de videos cortos verticales (YouTube Shorts / TikTok / Reels) de 30 a 60 segundos.
 Escribes en el idioma que se te pida, con frases cortas y naturales para decir en voz alta.
 Los subtítulos ya salen solos arriba: en pantalla pon solo lo que ILUSTRA la frase, no la repitas.
 
@@ -111,8 +114,13 @@ Tipos de escena:
   4. "emoji" SOLO si nada de lo anterior encaja (es el último recurso),
   más un "chip" opcional (dato corto como "×5" o "230 dB") que aparece en la palabra "en".
 - eleccion: final abierto para que el público comente: "pregunta" y 2 "opciones" ({texto, sub, objeto}; emoji solo si ningún objeto encaja). Úsala al final en series o historias.
+Además, en cualquier escena:
+- "rotulo": 2–4 palabras grandes que resumen el momento ("¿CUÁNTO *SUBIÓ*?", "SALIR DE CASA"), con la clave entre *asteriscos*. Úsalo en 2–4 escenas, sobre todo en preguntas y revelaciones; null en las demás.
+- "claves": 1–2 palabras de "say" que se resaltan en el subtítulo (la idea de la frase), o null.
 Varía los tipos. "at", "check" y "en" deben ser palabras que aparezcan tal cual en "say".
-No incluyas la escena final de "sígueme": morfeo la agrega sola.
+No escribas la escena de cierre: va en "cierre" (lo que pide al final: "comenta" una "palabra", "comparte" con "a" quién se lo mandan, o "sigue"), con su "say".
+
+${REGLAS_TEXTO}
 
 Diccionario de recursos por tema (usa estas palabras en "recurso"):
 ${Object.entries(listaTemas()).map(([t, v]) => `- ${t}: ${v.join(', ')}`).join('\n')}`;
@@ -144,8 +152,11 @@ export async function esquemaMotor() {
 		en: z.string().nullable(),
 		pregunta: z.string().nullable(),
 		opciones: z.array(z.object({texto: z.string(), sub: z.string(), objeto: z.enum(OBJETOS).nullable(), emoji: z.string().nullable()})).nullable(),
+		rotulo: z.string().nullable(),
+		claves: z.array(z.string()).nullable(),
 	});
-	return z.object({id: z.string(), title: z.string(), music: z.enum(MUSICAS), scenes: z.array(escena)});
+	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(), music: z.enum(MUSICAS), scenes: z.array(escena), cierre});
 }
 
 /** De la salida de la IA (motor de capas) al formato de escenas de morfeo. */
@@ -153,6 +164,8 @@ function aEscenaMotor(e, conImagenes) {
 	const out = {type: e.type, say: e.say};
 	if (e.show && e.show !== e.say) out.show = e.show;
 	const si = (k, v) => v != null && v !== '' && (out[k] = v);
+	si('rotulo', e.rotulo);
+	if (e.claves?.length) out.claves = e.claves;
 	switch (e.type) {
 		case 'titular':
 			si('texto', e.texto ?? '');
@@ -252,7 +265,9 @@ export async function guionConIA(o) {
 	const pedido = o.texto
 		? `Convierte este guion en escenas. Respeta su contenido y su orden; puedes partir frases largas.\n\n<guion>\n${o.texto}\n</guion>`
 		: `Escribe un video sobre: ${o.tema}`;
-	const extra = [`Idioma: ${idioma}.`, `Duración aproximada: ${o.duracion ?? 35} segundos (unas ${Math.round((o.duracion ?? 35) / 4.5)} escenas).`];
+	// ~45 s por defecto: los videos de referencia rondan el minuto y ninguna idea pasa de ~5 s (lib/estructura.mjs)
+	const dur = o.duracion ?? 45;
+	const extra = [`Idioma: ${idioma}.`, `Duración aproximada: ${dur} segundos (unas ${Math.round(dur / 4)} escenas de 3 a 5 segundos).`];
 	if (o.tono) extra.push(`Tono: ${o.tono}.`);
 	const motor = o.estilo && o.estilo !== 'datos-curiosos';
 	if (motor) extra.push(`Estilo visual: ${o.estilo}.${o.imagenes ? ' Se pueden generar ilustraciones (usa imagen_ia en las escenas capas).' : ' No hay ilustraciones: usa emoji en las escenas capas.'}`);
@@ -278,7 +293,9 @@ export async function guionConIA(o) {
 	if (!g) throw new ErrorMorfeo('Claude no devolvió un guion válido; intenta otra vez.');
 	if (motor) {
 		const scenes = g.scenes.map((e) => aEscenaMotor(e, !!o.imagenes));
-		return {id: slug(g.id || g.title), video: {estilo: o.estilo, title: g.title, voice: o.voz ?? 'em_alex', music: g.music, scenes: [...scenes, {type: 'cta'}]}};
+		const 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, title: g.title, 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

@@ -0,0 +1,98 @@
+// `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 {spawnSync} from 'node:child_process';
+import fs from 'node:fs';
+import {createRequire} from 'node:module';
+import path from 'node:path';
+import zlib from 'node:zlib';
+import {ErrorMorfeo} from './config.mjs';
+
+const require = createRequire(import.meta.url);
+
+/** Rutas de ffmpeg y ffprobe: las del paquete de Remotion de esta plataforma; si no, las del PATH. */
+function binarios() {
+	const exe = process.platform === 'win32' ? '.exe' : '';
+	const libc = process.platform === 'linux' ? (process.report?.getReport?.().header?.glibcVersionRuntime ? '-gnu' : '-musl') : '';
+	const sufijo = process.platform === 'win32' ? '-msvc' : libc;
+	try {
+		const dir = path.dirname(require.resolve(`@remotion/compositor-${process.platform}-${process.arch}${sufijo}/package.json`));
+		if (fs.existsSync(path.join(dir, `ffmpeg${exe}`))) return {ffmpeg: path.join(dir, `ffmpeg${exe}`), ffprobe: path.join(dir, `ffprobe${exe}`), cwd: dir};
+	} catch {}
+	return {ffmpeg: 'ffmpeg', ffprobe: 'ffprobe', cwd: undefined};
+}
+
+const CRC = (() => {
+	const t = new Uint32Array(256);
+	for (let n = 0; n < 256; n++) {
+		let c = n;
+		for (let k = 0; k < 8; k++) c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+		t[n] = c >>> 0;
+	}
+	return t;
+})();
+const crc32 = (b) => {
+	let c = 0xffffffff;
+	for (let i = 0; i < b.length; i++) c = CRC[(c ^ b[i]) & 255] ^ (c >>> 8);
+	return (c ^ 0xffffffff) >>> 0;
+};
+const trozo = (tipo, datos) => {
+	const cab = Buffer.alloc(8);
+	cab.writeUInt32BE(datos.length, 0);
+	cab.write(tipo, 4, 'latin1');
+	const fin = Buffer.alloc(4);
+	fin.writeUInt32BE(crc32(Buffer.concat([cab.subarray(4), datos])), 0);
+	return Buffer.concat([cab, datos, fin]);
+};
+
+/** PNG RGB de 8 bits sin predicción -> píxeles crudos (alto × ancho × 3). */
+function leerPng(b, w, h) {
+	const idat = [];
+	for (let p = 8; p + 8 <= b.length; ) {
+		const largo = b.readUInt32BE(p);
+		if (b.toString('latin1', p + 4, p + 8) === 'IDAT') idat.push(b.subarray(p + 8, p + 8 + largo));
+		p += 12 + largo;
+	}
+	const crudo = zlib.inflateSync(Buffer.concat(idat));
+	const fila = 1 + w * 3;
+	if (crudo.length !== fila * h) throw new Error('cuadro con tamaño inesperado');
+	const out = Buffer.alloc(w * h * 3);
+	for (let y = 0; y < h; y++) crudo.copy(out, y * w * 3, y * fila + 1, (y + 1) * fila);
+	return out;
+}
+
+/**
+ * @param {{video: string, salida?: string, cols?: number, filas?: number, desde?: number, hasta?: number, ancho?: number}} op
+ * @returns {string} ruta del PNG
+ */
+export function hoja({video, salida, cols = 5, filas = 3, desde = 0, hasta, ancho = 216}) {
+	if (!fs.existsSync(video)) throw new ErrorMorfeo(`No encuentro ${video}. Renderízalo primero:  npx morfeo render`);
+	const {ffmpeg, ffprobe, cwd} = binarios();
+	const sonda = spawnSync(ffprobe, ['-v', 'error', '-select_streams', 'v:0', '-show_entries', 'stream=width,height:format=duration', '-of', 'csv=p=0', video], {encoding: 'utf8', cwd});
+	if (sonda.status !== 0) throw new ErrorMorfeo(`No pude leer ${video} (¿falta ffprobe?)`);
+	const [dim, dur] = sonda.stdout.trim().split(/\r?\n/);
+	const [vw, vh] = dim.split(',').map(Number);
+	const fin = hasta ?? Number(dur);
+	const w = ancho - (ancho % 2);
+	const h = Math.round((w * vh) / vw / 2) * 2;
+	const n = cols * filas;
+	const W = cols * w;
+	const H = filas * h;
+	const lienzo = Buffer.alloc(H * (1 + W * 3)); // cada fila empieza con el byte de filtro 0
+	for (let i = 0; i < n; i++) {
+		const t = desde + ((fin - desde) * (i + 0.5)) / n;
+		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);
+		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);
+	}
+	const ihdr = Buffer.alloc(13);
+	ihdr.writeUInt32BE(W, 0);
+	ihdr.writeUInt32BE(H, 4);
+	ihdr.set([8, 2, 0, 0, 0], 8);
+	const destino = salida ?? video.replace(/\.[^.]+$/, '') + '-hoja.png';
+	fs.writeFileSync(destino, Buffer.concat([Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]), trozo('IHDR', ihdr), trozo('IDAT', zlib.deflateSync(lienzo, {level: 6})), trozo('IEND', Buffer.alloc(0))]));
+	return destino;
+}

package/lib/imagenes.mjs

@@ -62,6 +62,7 @@ export async function generarImagenes(video, cfgImagenes, cacheDir, assetsDir, l
 	};
 	const scenes = recorrer(video.scenes);
 	const hud = recorrer(video.hud ?? []);
+	const mundo = recorrer(video.mundo ?? []);
 	if (!pendientes.length) return video;
 	const cfg = cfgImagenes ?? {};
 	const proveedor = cfg.proveedor ?? 'openai';
@@ -95,5 +96,5 @@ export async function generarImagenes(video, cfgImagenes, cacheDir, assetsDir, l
 		if (x.__src) out.src = x.__src.ruta;
 		return out;
 	};
-	return {...video, scenes: fijar(scenes), hud: fijar(hud)};
+	return {...video, scenes: fijar(scenes), hud: fijar(hud), mundo: fijar(mundo)};
 }

package/lib/instalar.mjs

@@ -22,7 +22,7 @@ import {
 	venvListo,
 	versionPython,
 } from './entorno.mjs';
-import {whisperListo, instalarWhisper} from './whisper.mjs';
+import {faltaParaWhisper, whisperListo, instalarWhisper} from './whisper.mjs';
 
 const ok = (m) => console.log(`  ✔ ${m}`);
 const no = (m) => console.log(`  ✘ ${m}`);
@@ -154,7 +154,7 @@ export async function instalar(op = {}) {
 			if (process.platform === 'darwin' && spawnSync('xcode-select', ['-p'], {stdio: 'ignore'}).status !== 0) {
 				no('Whisper se compila y necesita las herramientas de Apple.');
 				info('Corre:  xcode-select --install   y cuando termine:  npx morfeo instalar --whisper');
-			} else {
+			} else if (await herramientasWhisper(op)) {
 				await instalarWhisper();
 				ok('Whisper listo');
 			}
@@ -164,6 +164,22 @@ export async function instalar(op = {}) {
 	console.log('\nTodo listo. Prueba:  npx morfeo nuevo mi-canal  &&  cd mi-canal  &&  npx morfeo render');
 }
 
+/** Revisa git, make y cmake antes de compilar whisper.cpp; en Mac con Homebrew ofrece instalar cmake. */
+async function herramientasWhisper(op) {
+	let falta = faltaParaWhisper();
+	if (falta.length === 1 && falta[0] === 'cmake' && process.platform === 'darwin' && tiene('brew')) {
+		if (await preguntar('Whisper necesita cmake para compilarse. ¿Lo instalo con Homebrew?', {...op, porDefecto: true})) {
+			correr('brew', ['install', 'cmake']);
+			falta = faltaParaWhisper();
+		}
+	}
+	if (!falta.length) return true;
+	no(`Whisper se compila y falta: ${falta.join(', ')}.`);
+	if (process.platform === 'darwin') info(`Corre:  brew install ${falta.join(' ')}   y cuando termine:  npx morfeo instalar --whisper`);
+	else info(`Instálalo con tu gestor de paquetes (por ejemplo:  sudo apt install ${falta.join(' ')} ) y luego:  npx morfeo instalar --whisper`);
+	return false;
+}
+
 /** Devuelve el estado de cada pieza; con imprimir=true lo muestra. */
 export async function doctor({imprimir = true} = {}) {
 	const estado = [];

package/lib/personajes.mjs

@@ -90,5 +90,5 @@ export function ponerPoses(video, mapa) {
 		}
 		return o;
 	};
-	return {...video, scenes: recorrer(video.scenes), hud: recorrer(video.hud ?? [])};
+	return {...video, scenes: recorrer(video.scenes), hud: recorrer(video.hud ?? []), mundo: recorrer(video.mundo ?? [])};
 }

package/lib/recursos.mjs

@@ -306,5 +306,6 @@ export async function resolverRecursos(video, assetsPublico, log = console.log)
 	};
 	const scenes = await recorrer(video.scenes);
 	const hud = await recorrer(video.hud ?? []);
-	return {video: {...video, scenes, hud}, creditos: [...creditos]};
+	const mundo = await recorrer(video.mundo ?? []);
+	return {video: {...video, scenes, hud, mundo}, creditos: [...creditos]};
 }