morfeo 0.3.4 → 0.4.0

package/bin/morfeo.mjs

@@ -13,7 +13,7 @@ Primeros pasos
   instalar              Prepara tu computadora: Python, voces, navegador y (opcional) Whisper
       --si                responde "sí" a todo        --whisper / --sin-whisper
   nuevo <carpeta>       Crea un proyecto de ejemplo listo para renderizar
-  nuevo-video <id>      Crea un video desde una base que ya renderiza (guion + mundo):  --look 2d | 3d
+  nuevo-video <id>      Crea un video desde una base que ya renderiza:  --look 2d | 3d | serie | biografia | escalada | mito | construiste
   doctor                Revisa qué está instalado y qué falta
 
 Videos
@@ -33,6 +33,8 @@ Videos
 Guiones
   guion "tema"          La IA (Claude) escribe un video completo sobre el tema
   guion --desde f.txt   Convierte tu guion en escenas (con IA; --sin-ia: una escena por frase)
+      --formula <id>      una fórmula de historia (construiste, serie, mito, misterio…)
+  formulas              Las fórmulas de historia medidas en videos de referencia
       --estilo documental   estilo visual (por defecto, el del proyecto)
       --imagenes            pide ilustraciones con IA (necesita OPENAI_API_KEY)
       --id nombre  --voz em_alex  --duracion 40  --idioma "inglés"  --tono "humor"
@@ -53,7 +55,7 @@ function opciones(argv) {
 			const [k, v] = a.slice(2).split('=');
 			const clave = k.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
 			const sig = argv[i + 1];
-			const conValor = ['proyecto', 'desde', 'id', 'voz', 'duracion', 'idioma', 'estilo', 'tono', 'variante', 'fuente', 'musica', 'titulo', 'modelo', 'puerto', 'hasta', 'cols', 'filas', 'look'];
+			const conValor = ['proyecto', 'desde', 'id', 'voz', 'duracion', 'idioma', 'estilo', 'tono', 'variante', 'fuente', 'musica', 'titulo', 'modelo', 'puerto', 'hasta', 'cols', 'filas', 'look', 'formula'];
 			if (v != null) op[clave] = v;
 			else if (conValor.includes(clave) && sig != null && !sig.startsWith('--')) op[clave] = argv[++i];
 			else op[clave] = true;
@@ -87,12 +89,11 @@ async function main() {
 			return nuevo(pos[0], op);
 		case 'nuevo-video': {
 			const {nuevoVideo} = await import('../lib/nuevo-video.mjs');
-			const look = op.look === true || op.look == null ? '2d' : String(op.look).toLowerCase();
+			const look = typeof op.formula === 'string' ? op.formula.toLowerCase() : op.look === true || op.look == null ? '2d' : String(op.look).toLowerCase();
 			const r = nuevoVideo({proyecto, id: pos[0], look});
 			const rel = (f) => path.relative(process.cwd(), f);
 			console.log(`Listo (${look}):
-  ${rel(r.guion)}   el guion: texto, tomas, rótulos y capas
-  ${rel(r.escena)}   el mundo (${r.componente}, ya registrado en morfeo.config.mjs)
+  ${rel(r.guion)}   el guion: texto, tomas, rótulos y capas${r.escena ? `\n  ${rel(r.escena)}   el mundo (${r.componente}, ya registrado en morfeo.config.mjs)` : ''}
 
 Pruébalo:  npx morfeo render ${pos[0]}   y revísalo:  npx morfeo hoja ${pos[0]}`);
 			return;
@@ -191,6 +192,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 'formulas':
+		case 'formula': {
+			const {FORMULAS} = await import('../lib/formulas.mjs');
+			for (const f of FORMULAS) console.log(`${f.id.padEnd(14)} ${f.nombre}  (${f.duracion[0]}–${f.duracion[1]} s · ${f.estilos.join(', ')})\n${' '.repeat(15)}${f.para}\n${' '.repeat(15)}Gancho: ${f.gancho}\n`);
+			console.log('Úsala:  npx morfeo guion "tu tema" --formula construiste   (o formula: \'construiste\' en el guion para que `revisar` la revise)');
+			return;
+		}
 		case 'guion':
 		case 'script':
 			return guion(pos, op, proyecto);
@@ -225,7 +233,7 @@ async function guion(pos, op, proyecto) {
 	if (texto && op.sinIa) r = guionSinIA(texto, {id: op.id, voz: op.voz, musica: op.musica, titulo: op.titulo, estilo});
 	else {
 		console.log(texto ? 'Claude está convirtiendo tu guion en escenas...' : `Claude está escribiendo un video sobre: ${tema}...`);
-		r = await guionConIA({tema, texto, idioma: op.idioma, duracion: op.duracion ? Number(op.duracion) : undefined, tono: op.tono, estilo, imagenes: !!op.imagenes, voz: op.voz, modelo: op.modelo});
+		r = await guionConIA({tema, texto, 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');

package/index.d.ts

@@ -69,6 +69,9 @@ interface CapaBase {
 	cambios?: ({en: Momento | {escena: number}} & Record<string, unknown>)[];
 }
 
+/** Mitad de una pantalla dividida: sus capas usan coordenadas de 1080×1920 recortadas a su mitad. */
+export interface Mitad {etiqueta?: string; color?: string; fondo?: string; capas?: Capa[]}
+
 export type Capa = CapaBase &
 	(
 		| {tipo: 'imagen'; src?: string; generar?: string; ancho?: number; alto?: number; redondo?: boolean; radio?: number; cambiarA?: {src: string; en?: Momento; efecto?: 'fundido' | 'barrido' | 'circulo'; duracion?: number}}
@@ -92,6 +95,16 @@ export type Capa = CapaBase &
 		| {tipo: 'recipientes'; n?: number; valor?: number; forma?: 'garrafon' | 'vaso'; total?: string; color?: string; tamPieza?: number; duracion?: number}
 		| {tipo: 'ficha'; titulo?: string; foto?: string; campos: [string, string][]; ancho?: number; color?: string; fondoFoto?: string}
 		| {tipo: 'checklist'; items: (string | {texto: string; en?: Momento; pendiente?: boolean})[]; titulo?: string; tam?: number; color?: string; cada?: number}
+		| {tipo: 'bloqueo'; hora?: string; fecha?: string; /** Año abajo de la hora; [2026, 2031] salta de uno a otro en `anioEn`. */ anio?: number | string | (number | string)[]; anioEn?: Momento; notificaciones?: {app?: string; titulo?: string; texto?: string; en?: Momento}[]; fondo?: string; ancho?: number}
+		| {tipo: 'llamada'; estado?: 'entrante' | 'curso' | 'terminada'; nombre?: string; numero?: string; aviso?: string | false; /** Segundos con los que arranca el contador (curso) o duración final (terminada). */ desde?: number; duracion?: number; fondo?: string; ancho?: number}
+		| {tipo: 'recuento'; cabecera?: string; titulo?: string; opciones: {texto: string; valor: number; sub?: string}[]; color?: string; ancho?: number}
+		| {tipo: 'capitulo'; serie?: string; capitulo?: string; pregunta?: string; opciones?: {texto: string; sub?: string}[]; pie?: string; siguiente?: string; horario?: string; color?: string; ancho?: number}
+		| {tipo: 'vigilancia'; hora?: string; fecha?: string; etiqueta?: string; zoom?: number; mira?: boolean; miraX?: number; miraY?: number; color?: string}
+		| {tipo: 'cintillo'; nombre: string; cargo?: string; color?: string; tam?: number}
+		| {tipo: 'fecha'; anio?: number; de?: number; texto?: string; pie?: string; color?: string; tam?: number}
+		| {tipo: 'calendario'; titulo?: string; de?: number; a?: number; color?: string; tam?: number; duracion?: number}
+		| {tipo: 'dividida'; izq?: Mitad; der?: Mitad; arriba?: Mitad; abajo?: Mitad; vertical?: boolean; fondo?: string; linea?: string}
+		| {tipo: 'tierra'; lat: number; lon: number; etiqueta?: string; tam?: number; color?: string; girar?: boolean}
 		| {tipo: 'mapa'; ruta?: [number, number][]; distancia?: string; ancho?: number; color?: string; fondo?: string; inclinar?: number; duracion?: number}
 		| {tipo: 'cursor'; a: [number, number]; clic?: Momento; duracion?: number; tam?: number; color?: string}
 		| {tipo: 'texto'; texto: string; tam?: number; color?: string; acento?: string; fuente?: 'titulo' | 'texto' | 'mono' | (string & {}); peso?: number; mayusculas?: boolean; contorno?: number; colorContorno?: string; fondo?: string; relleno?: string; radio?: number; maxAncho?: number | 'auto'; /** Achica la letra si no cabe (palabra más larga o más de `maxLineas` renglones). Por defecto sí. */ ajustar?: boolean; maxLineas?: number; alinear?: 'center' | 'left' | 'right'; interlineado?: number; escribir?: boolean | number; subrayado?: boolean}
@@ -176,6 +189,8 @@ interface EscenaMotorBase extends EscenaBase {
 	modoEn?: Momento;
 	/** Palabra o segundos en que vuelve a la imagen normal. */
 	modoHasta?: Momento;
+	/** Lugar (de `lugares` del video) donde pasa esta escena. */
+	lugar?: string;
 	/** Invertir la imagen en el modo (fondo claro → oscuro). Por defecto sí en looks claros (3d, maqueta, explicativo, infografia, minimal). */
 	modoInvertir?: boolean;
 	/** Palabras clave de la escena para los subtítulos (la que lleva caja o color de acento en cada frase). */
@@ -267,6 +282,12 @@ export interface Video {
 	 * El componente recibe además `escena` (1, 2, 3...), `tEscena`, `inicios` y `camara` (para paralaje).
 	 */
 	mundo?: Capa[];
+	/**
+	 * Varios mundos en un video (biografías, historias que cambian de sitio): `{cocina: [...], boda: [...]}`. Cada escena
+	 * elige uno con `lugar: 'boda'` (o sigue en el anterior). Cada lugar tiene su propia cámara; al cambiar, corta o usa
+	 * la `transicion` de la escena.
+	 */
+	lugares?: Record<string, Capa[]>;
 	/** Pastilla fija arriba para series: 'GYM CON CIENCIA · PARTE 5'. */
 	serie?: string;
 	/** Calidad de este video (ver `render.calidad`). */
@@ -274,6 +295,11 @@ export interface Video {
 	/** Para publicar: descripción y etiquetas (van a salida/<id>.txt junto con el título). */
 	descripcion?: string;
 	tags?: string[];
+	/**
+	 * Fórmula de historia (ver `npx morfeo formulas`): 'construiste' | 'recomendable' | 'escalada' | 'supervivencia' |
+	 * 'experimento' | 'misterio' | 'demuestralo' | 'mito' | 'roast' | 'serie' | 'biografia'. `revisar` da consejos propios.
+	 */
+	formula?: 'construiste' | 'recomendable' | 'escalada' | 'supervivencia' | 'experimento' | 'misterio' | 'demuestralo' | 'mito' | 'roast' | 'serie' | 'biografia';
 	/** 'largo' = explicador de 90–130 s (lo asume el estilo maqueta): cambia las reglas de `morfeo revisar`. */
 	formato?: 'corto' | 'largo';
 	/** Ajustes del estilo para este video (colores, fondo, subtítulos...). */

package/lib/config.mjs

@@ -1,4 +1,5 @@
 // Carga y valida morfeo.config.mjs del proyecto del usuario.
+import {IDS_FORMULA} from './formulas.mjs';
 import fs from 'node:fs';
 import path from 'node:path';
 import {pathToFileURL} from 'node:url';
@@ -25,7 +26,7 @@ export const TIPOS_ESCENA = [...new Set([...TIPOS_CLASICOS, ...TIPOS_MOTOR])];
 export const ROTULOS = ['normal', 'contorno', 'pastilla', 'sello', 'paso', 'pixel'];
 export const MODOS = ['rayosx', 'plano', 'holograma'];
 export const ESTILOS = ['datos-curiosos', 'explicativo', 'documental', 'ilustrado', 'historia', 'mesa', 'serie', 'infografia', '3d', 'maqueta', 'minimal'];
-export const TIPOS_CAPA = ['imagen', 'video', 'texto', 'contador', 'chip', 'etiqueta', 'numero', 'tarjeta', 'telefono', 'forma', 'icono', 'emoji', 'marca', 'particulas', 'grupo', 'modelo', 'componente', 'barra', 'medidor', 'votacion', 'estado', 'noticia', 'chat', 'onda', 'globo', 'seguir', 'personaje', 'escena3d', 'ventana', 'escenario', 'recurso', 'dato', 'medida', 'trazo', 'contorno', 'fuente', 'seccion', 'insignia', 'sello', 'cursor', 'terminal', 'nombre', 'accion', 'reloj', 'cronometro', 'termometro', 'recipientes', 'ficha', 'checklist', 'mapa'];
+export const TIPOS_CAPA = ['imagen', 'video', 'texto', 'contador', 'chip', 'etiqueta', 'numero', 'tarjeta', 'telefono', 'forma', 'icono', 'emoji', 'marca', 'particulas', 'grupo', 'modelo', 'componente', 'barra', 'medidor', 'votacion', 'estado', 'noticia', 'chat', 'onda', 'globo', 'seguir', 'personaje', 'escena3d', 'ventana', 'escenario', 'recurso', 'dato', 'medida', 'trazo', 'contorno', 'fuente', 'seccion', 'insignia', 'sello', 'cursor', 'terminal', 'nombre', 'accion', 'reloj', 'cronometro', 'termometro', 'recipientes', 'ficha', 'checklist', 'mapa', 'bloqueo', 'llamada', 'recuento', 'capitulo', 'vigilancia', 'cintillo', 'fecha', 'calendario', 'dividida', 'tierra'];
 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'];
@@ -228,6 +229,10 @@ function validarCapas(capas, donde, err, comps) {
 			if (!c.buscar) err(`${d}: falta \`buscar\` (qué objeto: 'tubería', 'casa', 'pizza'...)`);
 			if (c.estilo && !['2d', '3d', 'realista'].includes(c.estilo)) err(`${d}: estilo "${c.estilo}" no existe. Usa '2d', '3d' o 'realista'`);
 		}
+		if (c.tipo === 'dividida') for (const lado of ['izq', 'der', 'arriba', 'abajo']) if (c[lado]?.capas) validarCapas(c[lado].capas, `${d}, ${lado}`, err, comps);
+		if (c.tipo === 'cintillo' && !c.nombre) err(`${d}: \`cintillo\` necesita \`nombre\``);
+		if (c.tipo === 'llamada' && c.estado != null && !['entrante', 'curso', 'terminada'].includes(c.estado)) err(`${d}: estado "${c.estado}" no existe (entrante, curso o terminada)`);
+		if (c.tipo === 'tierra' && (!esNum(c.lat) || !esNum(c.lon))) err(`${d}: \`tierra\` necesita \`lat\` y \`lon\` (números)`);
 		if (c.capas) validarCapas(c.capas, d, err, comps);
 		if (c.capa) validarCapas([c.capa], d, err, comps);
 	});
@@ -315,6 +320,7 @@ function validarVideo(id, v, ctx) {
 			);
 		if (s.capas != null) validarCapas(s.capas, `${n}`, err, ctx.componentes);
 		if (s.rotulo != null && typeof s.rotulo !== 'string') err(`${n}: \`rotulo\` debe ser un texto corto ('¿CUÁNTO *SUBIÓ*?')`);
+		if (s.lugar != null && !(v.lugares && typeof v.lugares === 'object' && v.lugares[s.lugar])) err(`${n}: el lugar "${s.lugar}" no está en \`lugares\`${v.lugares && typeof v.lugares === 'object' ? ` (hay: ${Object.keys(v.lugares).join(', ')})` : ''}`);
 		if (s.rotuloEstilo != null && !ROTULOS.includes(s.rotuloEstilo)) err(`${n}: rotuloEstilo "${s.rotuloEstilo}" no existe. Opciones: ${ROTULOS.join(', ')}`);
 		if (s.rotuloPaso != null && s.rotuloEstilo !== 'paso') err(`${n}: \`rotuloPaso\` es para rotuloEstilo: 'paso'`);
 		if (s.modo != null) {
@@ -329,7 +335,7 @@ function validarVideo(id, v, ctx) {
 				if (tm.zoom != null && tm.zoom <= 0) err(`${n}: \`toma.zoom\` debe ser mayor que 0`);
 				if (tm.a != null) for (const k of ['x', 'y', 'zoom', 'giro']) if (tm.a[k] != null && !esNum(tm.a[k])) err(`${n}: \`toma.a.${k}\` debe ser un número`);
 			}
-			if (!v.mundo?.length) err(`${n}: \`toma\` mueve la cámara del \`mundo\`, pero el video no tiene \`mundo\``);
+			if (!v.mundo?.length && !v.lugares) err(`${n}: \`toma\` mueve la cámara del \`mundo\`, pero el video no tiene \`mundo\` ni \`lugares\``);
 		}
 		if (s.type === 'cta' && s.pide != null) {
 			if (!['comenta', 'comparte'].includes(s.pide)) err(`${n}: \`pide\` debe ser 'comenta' o 'comparte'`);
@@ -353,17 +359,23 @@ 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, ctx.componentes);
+	if (v.lugares != null) {
+		if (typeof v.lugares !== 'object' || Array.isArray(v.lugares) || !Object.keys(v.lugares).length) err("`lugares` debe ser un objeto con un mundo por nombre: {cocina: [...], boda: [...]}");
+		else for (const [nombre, capas] of Object.entries(v.lugares)) validarCapas(capas, `lugares.${nombre}`, err, ctx.componentes);
+		if (clasico) err('`lugares` es del motor de capas: usa un estilo como ilustrado, 3d o mesa (no "datos-curiosos")');
+	}
 	if (v.mundo != null) {
 		validarCapas(v.mundo, 'mundo', err, ctx.componentes);
 		if (clasico) err('`mundo` es del motor de capas: usa un estilo como ilustrado, 3d o mesa (no "datos-curiosos")');
 	}
+	if (v.formula != null && !IDS_FORMULA.includes(v.formula)) err(`\`formula\` "${v.formula}" no existe. Opciones: ${IDS_FORMULA.join(', ')} (npx morfeo formulas)`);
 	if (v.serie != null && typeof v.serie !== 'string') err("`serie` debe ser un texto ('GYM CON CIENCIA · PARTE 5')");
 	if (v.title != null && typeof v.title !== 'string') err('`title` debe ser un texto (también es el nombre del archivo del video)');
 	if (v.calidad != null && !['alta', 'media', 'ligera'].includes(v.calidad)) err("`calidad` debe ser 'alta', 'media' o 'ligera'");
 	if (v.tags != null && (!Array.isArray(v.tags) || v.tags.some((x) => typeof x !== 'string'))) err("`tags` debe ser una lista de textos (['curiosidades', 'ciencia'])");
 	// archivos de assets/ que piden las escenas y el HUD: mejor avisar ahora que a mitad del render
-	revisarArchivos({scenes, hud: v.hud, mundo: v.mundo, tema: v.tema}, ctx.assetsDir, err);
-	revisarPersonajes({scenes, hud: v.hud, mundo: v.mundo}, ctx.personajes, err);
+	revisarArchivos({scenes, hud: v.hud, mundo: v.mundo, lugares: v.lugares, tema: v.tema}, ctx.assetsDir, err);
+	revisarPersonajes({scenes, hud: v.hud, mundo: v.mundo, lugares: v.lugares}, ctx.personajes, err);
 	revisarEscenarios({scenes, hud: v.hud, tema: v.tema}, err);
 	return {...v, estilo, voice, music: normalizarMusica(v.music, ctx, err), scenes};
 }

package/lib/estructura.mjs

@@ -43,8 +43,10 @@ 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 {formulaDe, revisarFormula} from './formulas.mjs';
+
 const palabrasDe = (s) => String(s ?? '').trim().split(/\s+/).filter(Boolean);
-const GANCHOS = /^(¿|¡|imagina|y si|cómo|como se|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;
+const GANCHOS = /^(¿|¡|imagina|la mayoría|la mayoria|y si|cómo|como se|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).
@@ -61,7 +63,8 @@ export function revisarEstructura(v, d) {
 	const primera = cuerpo[0];
 	const clasico = (v.estilo ?? 'datos-curiosos') === 'datos-curiosos';
 	// formato largo: explicador de maqueta (o `formato: 'largo'` en el video)
-	const largo = v.estilo === 'maqueta' || v.formato === 'largo';
+	const formula = formulaDe(v.formula);
+	const largo = v.estilo === 'maqueta' || v.formato === 'largo' || (formula?.duracion[1] ?? 0) > 90;
 
 	// 1) gancho
 	const dicho = String(primera.say ?? '').trim();
@@ -100,7 +103,7 @@ export function revisarEstructura(v, d) {
 
 	// 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 ?? '');
+	const pideAlgo = escenas.some((s) => s.type === 'eleccion') || (fin?.type === 'cta' && fin.pide) || /comenta|escribe|mándaselo|mandaselo|envíaselo|enviaselo|comparte|elige|parte 2|siguiente parte|capítulo/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ú
@@ -108,6 +111,9 @@ export function revisarEstructura(v, d) {
 	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;
 	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);
+	// "envíaselo a…" también es un cierre que pide algo
 	return out;
 }
 

package/lib/formulas.mjs

@@ -0,0 +1,179 @@
+// Fórmulas de historia medidas en los videos de referencia (referencias/videos-ejemplo.md). Una sola fuente para:
+// el prompt de `morfeo guion` (la IA elige una o se le pide con --formula), `morfeo revisar` (consejos propios de cada
+// fórmula) y `morfeo formulas` (la lista). Cada una dice cómo arranca, cómo avanza, cómo cierra y qué piezas le quedan.
+
+/** @typedef {{id: string, nombre: string, para: string, esqueleto: string[], gancho: string, cierre: string, duracion: [number, number], estilos: string[], piezas: string, revisar?: (v: any, texto: string) => string[]}} Formula */
+
+const dice = (texto, re) => re.test(texto);
+
+/** @type {Formula[]} */
+export const FORMULAS = [
+	{
+		id: 'construiste',
+		nombre: 'Construiste un X',
+		para: 'explicar cómo funciona una obra, máquina o instalación (túnel, inodoro, portón eléctrico, semáforo)',
+		esqueleto: ['Arranca por lo obvio: "Si haces un hoyo en la montaña, tienes un túnel…"', 'Falla por algo concreto ("pero el techo plano se derrumba")', 'Lo arreglas con la pieza real ("le das forma de arco")', 'Repite falla → arreglo 4 a 7 veces; cada arreglo es una pieza nueva en pantalla', 'Remate: "¡Felicidades, construiste un túnel!"'],
+		gancho: '"Si a tu portón le pones un motor, ya no te bajas a abrir… pero no sabe cuándo parar."',
+		cierre: '"¡Felicidades, construiste X!" y "comenta qué construimos en el próximo".',
+		duracion: [90, 120],
+		estilos: ['maqueta', '3d'],
+		piezas: 'un solo mundo (Maqueta con corte de tierra), Aparece por pieza en su palabra, etiquetas 3D, rótulo paso con número, modo plano para ver por dentro',
+		revisar: (v, texto) => {
+			const out = [];
+			if (!dice(texto, /felicidades|construiste|inventaste|has (?:construido|inventado)/i)) out.push('Fórmula "construiste": cierra con "¡Felicidades, construiste X!" (es el remate que esperan).');
+			const pero = (texto.match(/\bpero\b/gi) ?? []).length;
+			if (pero < 3) out.push(`Fórmula "construiste": solo ${pero} "pero". La cadena falla → arreglo necesita 4–7 rondas ("…pero se derrumba, así que…").`);
+			return out;
+		},
+	},
+	{
+		id: 'recomendable',
+		nombre: 'Lo recomendable es X, y no [absurdo]',
+		para: 'humor con datos: consejos cotidianos contra la exageración más absurda (prensa de 500 t para un zancudo)',
+		esqueleto: ['"¿Sabías que para X lo recomendable es Y…"', '"…y no [la exageración con cifra]: [consecuencia absurda]"', 'Tres rondas iguales con objetos distintos (cifra en tarjeta cada vez)', 'Remate corto que vuelve al principio'],
+		gancho: '"¿Sabías que si quieres matar un zancudo, lo recomendable es usar la mano y no una prensa de 500 toneladas?"',
+		cierre: 'Remate de una línea ("La próxima, con cuchara") o "síguenos si quieres más así".',
+		duracion: [45, 60],
+		estilos: ['3d', 'datos-curiosos'],
+		piezas: 'subtítulo palabra con coloresClave, dato/chip con la cifra exagerada, sello para la consecuencia',
+		revisar: (v, texto) => ((texto.match(/\by no\b/gi) ?? []).length < 2 ? ['Fórmula "recomendable": repite "lo recomendable es… y no…" al menos 3 veces; la gracia está en el patrón.'] : []),
+	},
+	{
+		id: 'escalada',
+		nombre: 'Escalada absurda',
+		para: 'un objeto cotidiano que crece pieza por pieza porque cada solución causa otro problema (la mochila que termina con reactor)',
+		esqueleto: ['Problema cotidiano y su arreglo simple ("le pones dos ruedas")', '"Pero [alguien/algo] causa otro problema, así que le metes…"', 'Cada escena suma una pieza visible y más grande', 'Remate: "Felicidades, has inventado una mochila básica"'],
+		gancho: '"Tu mochila pesa más que tu abuela, así que le pones dos ruedas."',
+		cierre: '"Felicidades, has inventado [algo que ya existe]" y "envíaselo a tu amigo que…".',
+		duracion: [40, 55],
+		estilos: ['3d'],
+		piezas: 'Aparece (cae y rebota) por cada pieza en su palabra, Persona3D reaccionando, sello por golpe cómico',
+		revisar: (v, texto) => (!dice(texto, /así que|entonces/i) ? ['Fórmula "escalada": encadena con "así que…" / "entonces le…": cada arreglo provoca el siguiente.'] : []),
+	},
+	{
+		id: 'supervivencia',
+		nombre: 'Regla de supervivencia',
+		para: 'qué hacer ante un peligro con dos variantes que se confunden (oso negro / grizzly, medusa, rayo)',
+		esqueleto: ['"Si te pasa X: con uno haz A y con el otro nunca. Si te equivocas…"', 'Presenta el primero con cifras (peso, velocidad) y qué hacer', 'Presenta el segundo y por qué es al revés', 'Cómo distinguirlos (una sola seña visual)', 'Cierre en suspenso o pregunta'],
+		gancho: '"Si te ataca un oso, con uno tienes que hacerte el muerto, y con el otro, nunca."',
+		cierre: 'Suspenso ("porque cuando el próximo oso cargue contra ti…") o "comenta cuál sabías".',
+		duracion: [45, 60],
+		estilos: ['ilustrado', 'documental'],
+		piezas: 'chips de cifra pegados al animal, comparar/dividida A | B, contorno sobre la seña que los distingue',
+	},
+	{
+		id: 'experimento',
+		nombre: 'Experimento mental con contador',
+		para: 'dilemas y "¿qué pasa si…?" que se resuelven contando (un céntimo que se duplica, 10 años de un hábito)',
+		esqueleto: ['Dilema o pregunta con cifra ("¿Un millón ahora o un céntimo que se duplica 30 días?")', 'Casi todos eligen mal', 'Contador por días/años con saltos (Día 1, 7, 20…)', 'Giro en los últimos días', 'Resultado con número grande'],
+		gancho: '"Un millón de euros ahora mismo, o un céntimo que se duplica cada día durante 30 días."',
+		cierre: '"Así que ya sabes qué decir cuando alguien te pregunte" o pregunta A/B.',
+		duracion: [45, 60],
+		estilos: ['mesa', 'infografia', '3d'],
+		piezas: 'contador lcd, Pila que crece, calendario que avanza, rótulo pixel para el resultado',
+		revisar: (v, texto) => (!dice(texto, /\bd[ií]a\b|\baños?\b|\bmes(es)?\b/i) ? ['Fórmula "experimento": marca el tiempo en voz ("día siete…", "diez años después") y con un contador o calendario.'] : []),
+	},
+	{
+		id: 'misterio',
+		nombre: 'Misterio con giro',
+		para: 'historias reales o inventadas con un hecho raro que escala y se explica al final',
+		esqueleto: ['Hecho raro en una frase ("Un hombre se colaba cada noche y movía todo 2,5 cm")', 'Escala por días ("DÍA 8", "DÍA 12") con la tensión de quien lo vive', 'Consecuencia (venden la casa, llaman a la policía)', 'Giro final que reordena todo (el comprador era él)'],
+		gancho: '"Un hombre se colaba cada noche en una casa y movía cada objeto dos centímetros a la izquierda."',
+		cierre: 'El giro es el cierre; nada de "sígueme" largo.',
+		duracion: [50, 65],
+		estilos: ['historia', 'ilustrado'],
+		piezas: 'siluetas, calendario o tarjeta "DÍA 8", vigilancia, medida para los centímetros',
+	},
+	{
+		id: 'demuestralo',
+		nombre: 'Te lo demuestro',
+		para: 'algo que el espectador puede probar con su cuerpo o su casa en ese momento',
+		esqueleto: ['"Hay algo que tu cuerpo no puede hacer y te lo voy a demostrar"', 'Instrucciones paso a paso al espectador (pon, dobla, levanta)', 'Lo que pasa ("¿No sube?")', 'Explicación con rayos X / plano', '"Tu cuerpo viene así de fábrica"'],
+		gancho: '"Hay un dedo de tu mano que no puedes levantar, y te lo voy a demostrar."',
+		cierre: '"Envíaselo a un amigo y que lo intente."',
+		duracion: [30, 45],
+		estilos: ['ilustrado', 'explicativo'],
+		piezas: 'modo rayosx en la explicación, trazo/contorno sobre la parte, cierre comparte',
+		revisar: (v) => (!(v.scenes ?? []).some((s) => s.modo) ? ['Fórmula "demuéstralo": la explicación luce con `modo: \'rayosx\'` en la palabra donde se ve "por dentro".'] : []),
+	},
+	{
+		id: 'mito',
+		nombre: 'Mito desmentido con comparación',
+		para: 'creencias comunes que tienen truco (la cinta de correr "miente", el microondas, la sal)',
+		esqueleto: ['Afirmación tajante ("La cinta te miente")', 'Por qué (la física o la biología en una frase)', 'La prueba (estudio o medida)', 'Comparación lado a lado', 'Matiz honesto', 'CTA a quien cree el mito'],
+		gancho: '"Diez kilómetros en la cinta y diez en la calle: mismo reloj, y no hiciste lo mismo."',
+		cierre: '"Envíaselo a ese amigo que dice que…"',
+		duracion: [50, 65],
+		estilos: ['infografia', 'explicativo'],
+		piezas: 'dividida A | B, medidor, barras, sellos "TE MIENTE" / "PILLADO", modo plano',
+	},
+	{
+		id: 'roast',
+		nombre: 'Roast con analogía animal',
+		para: 'conductas de la gente explicadas con la biología de un animal (el amigo tacaño y el pavo real)',
+		esqueleto: ['Pregunta provocadora sobre un conocido ("¿Por qué tu amigo el rata…?")', '"Es lo mismo que le pasa a un [animal]"', 'Explicación biológica con imágenes del animal', 'Vuelta al amigo con la analogía', 'CTA para mandárselo a ese amigo'],
+		gancho: '"¿Por qué tu amigo el rata no te invita ni un café, pero a su novia le paga las vacaciones?"',
+		cierre: '"Envíaselo a tu amigo el rata y que esta vez el café lo pague él."',
+		duracion: [45, 60],
+		estilos: ['ilustrado', 'mesa'],
+		piezas: 'mismos objetos que vuelven (cartera, café), lugares distintos por tramo, cierre comparte',
+		revisar: (v) => {
+			const cta = (v.scenes ?? []).find((s) => s.type === 'cta');
+			return cta && cta.pide !== 'comparte' ? ['Fórmula "roast": cierra con `pide: \'comparte\'` y un destinatario concreto ("tu amigo el rata").'] : [];
+		},
+	},
+	{
+		id: 'serie',
+		nombre: 'Serie interactiva (elige tú)',
+		para: 'historias por capítulos donde el público decide qué pasa (llamadas del futuro, vuelos perdidos)',
+		esqueleto: ['Recuento de lo que votaron ("La mayoría de ustedes votó…") si no es el capítulo 1', 'El capítulo en tiempo real: hora en pantalla, teléfono, noticias', 'Escalada hasta una decisión', 'Cliffhanger con dos opciones A/B', '"Comenta tu opción; la más votada gana. Capítulo 3 mañana 15:30"'],
+		gancho: '"Anoche te llamó tu propio número y te dijo que no tomaras el metro."',
+		cierre: 'Capa `capitulo` con las dos opciones y el horario, o escena `eleccion`.',
+		duracion: [70, 115],
+		estilos: ['historia', 'serie'],
+		piezas: 'serie (pastilla fija), recuento, bloqueo, llamada, noticia, vigilancia, capitulo',
+		revisar: (v) => {
+			const ultima = (v.scenes ?? []).at(-1);
+			const tieneFinal = (v.scenes ?? []).some((s) => s.type === 'eleccion' || (s.capas ?? []).some((c) => c.tipo === 'capitulo'));
+			const out = [];
+			if (!tieneFinal) out.push('Fórmula "serie": termina con una decisión A/B (capa `capitulo` o escena `eleccion`): es lo que trae comentarios.');
+			if (!v.serie) out.push("Fórmula \"serie\": pon `serie: 'MI SERIE · CAP. 2'` para la pastilla fija arriba.");
+			if (ultima && ultima.type === 'cta' && !ultima.pide) out.push('Fórmula "serie": el cierre debe pedir que comenten su opción, no solo "sígueme".');
+			return out;
+		},
+	},
+	{
+		id: 'biografia',
+		nombre: 'Biografía con secreto',
+		para: 'la vida de una persona o empresa contada año por año, con un escándalo o secreto como gancho',
+		esqueleto: ['Gancho de escándalo ("Al jefe no lo descubrió su esposa: lo descubrieron los espías")', 'Origen: lugar y año (globo con pin)', 'Ascenso año por año (tarjetas de año, cintillos con nombres)', 'El secreto con pruebas (documentos, vigilancia)', 'Final abierto'],
+		gancho: '"Al jefe de [empresa] no lo descubrió su esposa: lo descubrieron los espías."',
+		cierre: 'Final abierto ("Le dijeron que no.") o "sígueme para la parte 2".',
+		duracion: [90, 180],
+		estilos: ['documental', '3d'],
+		piezas: 'lugares (un set por época), tierra con pin, fecha, cintillo, calendario, vigilancia, ficha',
+		revisar: (v) => (!v.lugares ? ['Fórmula "biografía": usa `lugares` (un set por época o sitio) y `lugar` por escena: un solo fondo se siente pobre en 2–3 minutos.'] : []),
+	},
+];
+
+export const IDS_FORMULA = FORMULAS.map((f) => f.id);
+export const formulaDe = (id) => FORMULAS.find((f) => f.id === id) ?? null;
+
+/** Texto de las fórmulas para el prompt de la IA. */
+export function formulasParaIA(id) {
+	const lista = id ? [formulaDe(id)].filter(Boolean) : FORMULAS;
+	return lista
+		.map(
+			(f) =>
+				`### ${f.id}: ${f.nombre}\nPara: ${f.para}.\nEsqueleto:\n${f.esqueleto.map((p, i) => `  ${i + 1}. ${p}`).join('\n')}\nGancho de ejemplo: ${f.gancho}\nCierre: ${f.cierre}\nDuración: ${f.duracion[0]}–${f.duracion[1]} s.`,
+		)
+		.join('\n\n');
+}
+
+/** Consejos propios de la fórmula del video (`formula: 'construiste'`). */
+export function revisarFormula(v) {
+	const f = formulaDe(v?.formula);
+	if (!f?.revisar) return [];
+	const texto = (v.scenes ?? []).map((s) => s.say ?? '').join(' ');
+	return f.revisar(v, texto);
+}

package/lib/guion.mjs

@@ -1,5 +1,6 @@
 // Guiones: de un tema (la IA escribe todo) o de tu propio texto (la IA lo convierte en escenas,
 // o sin IA: una escena por frase). El resultado es un video listo para editar en videos/<id>.json.
+import {FORMULAS, IDS_FORMULA, formulaDe, formulasParaIA} from './formulas.mjs';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
@@ -120,8 +121,17 @@ Además, en cualquier escena:
 Varía los tipos. "at", "check" y "en" deben ser palabras que aparezcan tal cual en "say".
 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".
 
+- "rotulo_estilo": cómo se ve el rótulo: "sello" (sello de goma inclinado para un golpe: "¡SIN LUZ!", "¡TE MIENTE!"),
+  "paso" (titular de paso con número en "rotulo_paso", para explicar en orden), "pixel" (caja de videojuego para
+  resultados: "RESULTADO", "-20% RIESGO"), "pastilla" (aviso: "¡CUIDADO!") o null (el del estilo).
+- "modo": "rayosx" (ver por dentro: cuerpo, máquina), "plano" (cómo está hecho) u "holograma" (datos, cerebro) en la
+  escena que lo explica, con "modo_en" = la palabra donde cambia; null en las demás. Úsalo en 1–3 escenas como máximo.
+
 ${REGLAS_TEXTO}
 
+Fórmulas de historia (elige la que mejor le quede al tema y escribe en "formula" su id; síguela de principio a fin):
+${formulasParaIA()}
+
 Diccionario de recursos por tema (usa estas palabras en "recurso"):
 ${Object.entries(listaTemas()).map(([t, v]) => `- ${t}: ${v.join(', ')}`).join('\n')}`;
 
@@ -153,10 +163,14 @@ export async function esquemaMotor() {
 		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(),
+		rotulo_estilo: z.enum(['sello', 'paso', 'pixel', 'pastilla']).nullable(),
+		rotulo_paso: z.number().nullable(),
+		modo: z.enum(['rayosx', 'plano', 'holograma']).nullable(),
+		modo_en: z.string().nullable(),
 		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(), 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), scenes: z.array(escena), cierre});
 }
 
 /** De la salida de la IA (motor de capas) al formato de escenas de morfeo. */
@@ -165,6 +179,14 @@ export function aEscenaMotor(e, conImagenes) {
 	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.rotulo && e.rotulo_estilo) {
+		out.rotuloEstilo = e.rotulo_estilo;
+		if (e.rotulo_estilo === 'paso' && e.rotulo_paso != null) out.rotuloPaso = e.rotulo_paso;
+	}
+	if (e.modo) {
+		out.modo = e.modo;
+		si('modoEn', e.modo_en);
+	}
 	if (e.claves?.length) out.claves = e.claves;
 	switch (e.type) {
 		case 'titular':
@@ -266,9 +288,13 @@ export async function guionConIA(o) {
 		? `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}`;
 	// ~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 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(', ')}`);
+	// con fórmula, la duración es la de sus videos de referencia (el punto medio de su rango)
+	const dur = o.duracion ?? (forzada ? Math.round((forzada.duracion[0] + forzada.duracion[1]) / 2) : 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}.`);
+	if (forzada) extra.push(`Fórmula: usa "${forzada.id}" (${forzada.nombre}) y su esqueleto tal cual.`);
 	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.'}`);
 
@@ -295,7 +321,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, 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, 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/nuevo-video.mjs

@@ -5,7 +5,14 @@ import path from 'node:path';
 import {ErrorMorfeo} from './config.mjs';
 import {PAQUETE} from './entorno.mjs';
 
-export const LOOKS = ['2d', '3d'];
+/** Bases disponibles: cada carpeta de bases/ con un guion.mjs (y un Mundo.tsx si lleva mundo propio). */
+export const LOOKS = (() => {
+	try {
+		return fs.readdirSync(path.join(PAQUETE, 'bases')).filter((d) => fs.existsSync(path.join(PAQUETE, 'bases', d, 'guion.mjs'))).sort();
+	} catch {
+		return ['2d', '3d'];
+	}
+})();
 
 /** "mi-video_2" -> "MundoMiVideo2" */
 export const nombreComponente = (id) =>
@@ -41,7 +48,7 @@ export function registrarEnConfig(texto, nombre, ruta) {
 
 /**
  * @param {{proyecto: string, id: string, look?: string, carpetaGuiones?: string}} o
- * @returns {{guion: string, escena: string, componente: string}}
+ * @returns {{guion: string, escena: string | null, componente: string | null}}
  */
 export function nuevoVideo({proyecto, id, look = '2d', carpetaGuiones}) {
 	if (!id || !/^[a-z0-9][a-z0-9-_]*$/i.test(id)) throw new ErrorMorfeo('Dame un id corto sin espacios:  npx morfeo nuevo-video mi-video --look 2d');
@@ -52,12 +59,14 @@ export function nuevoVideo({proyecto, id, look = '2d', carpetaGuiones}) {
 	const dirGuiones = carpetaGuiones ?? path.join(proyecto, 'guiones');
 	const guion = path.join(dirGuiones, `${id}.mjs`);
 	const escena = path.join(proyecto, 'escenas', `${componente}.tsx`);
-	for (const f of [guion, escena]) if (fs.existsSync(f)) throw new ErrorMorfeo(`Ya existe ${path.relative(proyecto, f)}; elige otro id.`);
+	for (const f of [guion, escena]) if (f && fs.existsSync(f)) throw new ErrorMorfeo(`Ya existe ${path.relative(proyecto, f)}; elige otro id.`);
 	const base = path.join(PAQUETE, 'bases', look);
 	const poner = (s) => s.replaceAll('__ID__', id).replaceAll('__COMPONENTE__', componente);
 	fs.mkdirSync(dirGuiones, {recursive: true});
 	fs.mkdirSync(path.dirname(escena), {recursive: true});
 	fs.writeFileSync(guion, poner(fs.readFileSync(path.join(base, 'guion.mjs'), 'utf8')));
+	// bases sin mundo propio (solo capas): no hay componente que copiar ni registrar
+	if (!fs.existsSync(path.join(base, 'Mundo.tsx'))) return {guion, escena: null, componente: null};
 	fs.writeFileSync(escena, poner(fs.readFileSync(path.join(base, 'Mundo.tsx'), 'utf8')));
 	const nuevo = registrarEnConfig(fs.readFileSync(config, 'utf8'), componente, `./escenas/${componente}.tsx`);
 	if (nuevo) fs.writeFileSync(config, nuevo);

package/lib/palabras.mjs

@@ -70,7 +70,7 @@ export function revisarPalabras(v, d) {
 				avisos.push(`escena ${i + 1}, ${ruta}: "${p}" no está en ${s.show ? 'el subtítulo (`show`)' : 'lo que dice la voz'} ("${texto}"); se usará la mitad de la frase`);
 	});
 	// hud y mundo usan las palabras de todo el video
-	for (const [k, lista] of [['hud', v.hud], ['mundo', v.mundo]]) {
+	for (const [k, lista] of [['hud', v.hud], ['mundo', v.mundo], ...Object.entries(v.lugares ?? {}).map(([n, l]) => [`lugares.${n}`, l])]) {
 		const momentos = [];
 		momentosDe(lista ?? [], k, momentos);
 		for (const [ruta, p] of momentos) if (!laDice(p, todas)) avisos.push(`${ruta}: "${p}" no aparece en ninguna escena`);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "morfeo",
-	"version": "0.3.4",
+	"version": "0.4.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/python/preparar.py

@@ -264,7 +264,7 @@ def preparar(job):
     subs = [dict(a=round(c[0][1], 3), b=round(c[-1][2], 3), w=[[x[0].upper(), round(x[1], 3), round(x[2], 3)] for x in c])
             for ws in WORDS for c in trozos(ws)]
     datos = dict(id=vid, titulo=v.get("title", vid), indice=job.get("indice", 0), duracion=round(sum(durs), 3),
-                 estilo=v.get("estilo", "datos-curiosos"), tema=v.get("tema") or {}, hud=v.get("hud") or [], mundo=v.get("mundo") or [], serie=v.get("serie"),
+                 estilo=v.get("estilo", "datos-curiosos"), tema=v.get("tema") or {}, hud=v.get("hud") or [], mundo=v.get("mundo") or [], lugares=v.get("lugares") or {}, serie=v.get("serie"),
                  audio=f"v/{vid}/mix.wav", whisper=reales, escenas=escenas, subtitulos=subs)
     json.dump(datos, open(os.path.join(outdir, "datos.json"), "w", encoding="utf-8"), ensure_ascii=False, indent=1)
     print(f"    tiempos por palabra: {'Whisper' if reales else 'reparto por frase'} ({reales}/{len(TIM)} escenas)", flush=True)