morfeo 0.5.0 → 0.6.0

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

@@ -21,9 +21,12 @@ Videos
   render [id...]        Genera los videos que faltan (o los que indiques)
       --todos             regenera todos
       --solo-fallidos     reintenta solo los que fallaron en el último lote
+      --escenas 5-7       solo esas escenas (para corregir una toma sin rehacer todo) + su hoja
       --gpu               usa la tarjeta de video (más rápido; si falla, quítalo)
   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
+  animatica <id>        Todo el video a 1/3 de tamaño (~3× más rápido) + su hoja: para aprobar tomas y ritmo
+  revisar [id...]       Revisa la estructura (gancho, ritmo, preguntas, cierre), que la voz diga el guion, la zona segura,
+                        el riesgo de "diapositiva" y, si ya está el MP4, cuadros negros, tapados, planos o quietos
   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
@@ -59,7 +62,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', 'formula'];
+			const conValor = ['proyecto', 'desde', 'id', 'voz', 'duracion', 'idioma', 'estilo', 'tono', 'variante', 'fuente', 'musica', 'titulo', 'modelo', 'puerto', 'hasta', 'cols', 'filas', 'look', 'formula', 'escenas'];
 			if (v != null) op[clave] = v;
 			else if (conValor.includes(clave) && sig != null && !sig.startsWith('--')) op[clave] = argv[++i];
 			else op[clave] = true;
@@ -114,7 +117,22 @@ Pruébalo:  npx morfeo render ${pos[0]}   y revísalo:  npx morfeo hoja ${pos[0]
 		case 'render': {
 			if (op.gpu) process.env.MORFEO_GL = 'angle';
 			const {render} = await import('../lib/render.mjs');
-			await render({proyecto, ids: pos, todos: !!op.todos || pos[0] === 'todos', soloFallidos: !!op.soloFallidos});
+			const escenas = op.escenas != null && op.escenas !== true ? String(op.escenas).split(/[-,]/).map(Number) : null;
+			if (escenas && (escenas.some((x) => !Number.isInteger(x) || x < 1) || pos.length !== 1)) throw new ErrorMorfeo('Uso:  npx morfeo render mi-video --escenas 5   (o 5-7)');
+			const hechos = await render({proyecto, ids: pos, todos: !!op.todos || pos[0] === 'todos', soloFallidos: !!op.soloFallidos, escenas: escenas ? [escenas[0], escenas[escenas.length - 1]] : null});
+			if (escenas) {
+				const {hoja} = await import('../lib/hoja.mjs');
+				for (const h of hechos ?? []) console.log(hoja({video: h.mp4, cols: 5, filas: 2}));
+			}
+			return;
+		}
+		case 'animatica': {
+			if (op.gpu) process.env.MORFEO_GL = 'angle';
+			const {render} = await import('../lib/render.mjs');
+			const {hoja} = await import('../lib/hoja.mjs');
+			const hechos = await render({proyecto, ids: pos, animatica: true});
+			for (const h of hechos ?? []) console.log(hoja({video: h.mp4, cols: 6, filas: 3, ancho: 180}));
+			console.log('Si las tomas y el ritmo te gustan:  npx morfeo render ' + pos.join(' '));
 			return;
 		}
 		case 'previa': {
@@ -138,6 +156,12 @@ Pruébalo:  npx morfeo render ${pos[0]}   y revísalo:  npx morfeo hoja ${pos[0]
 				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);
+				// con el MP4 ya hecho: cuadros negros, tapados, planos o quietos (--sin-cuadros lo salta)
+				if (!op.sinCuadros) {
+					const {salidaDe} = await import('../lib/salida.mjs');
+					const {revisarCuadros} = await import('../lib/calidad.mjs');
+					c.push(...(await revisarCuadros(salidaDe(p, id), d)));
+				}
 				total += c.length;
 				console.log(c.length ? `${id}${d ? '' : '  (sin tiempos: renderízalo para revisar el ritmo)'}\n${consejosEnTexto(c)}` : `${id}  ✔`);
 			}

package/index.d.ts

@@ -1,6 +1,9 @@
 // Tipos de Morfeo: dan autocompletado en morfeo.config.mjs y videos.mjs (también en JS).
 
 /** '#RRGGBB' o [r, g, b] */
+export type Ambiente = 'cuarto-gamer' | 'sala' | 'arcade';
+/** Postproceso 3D: 'cine' (foco + brillo + viñeta), 'miniatura' (tilt-shift), 'suave', false o ajustes propios. */
+export type Post3D = 'cine' | 'miniatura' | 'suave' | false | {foco?: boolean | number; brillo?: number; vinieta?: number; miniatura?: number};
 export type Color = string | [number, number, number];
 /** [texto, color, tamaño] — tamaño 110–260 aprox. */
 export type Fila = [string, Color, number];
@@ -123,6 +126,8 @@ export type Capa = CapaBase &
 		| {tipo: 'grupo'; capas?: Capa[]; capa?: Capa; repetir?: number; disposicion?: 'circulo' | 'fila' | 'columna' | 'cuadricula' | 'pila' | 'aleatorio'; radio?: number; espacio?: number; espacioV?: number; columnas?: number; orientar?: boolean | number; retraso?: number; area?: [number, number]; girarAzar?: number; desorden?: number}
 		| {tipo: 'modelo'; src?: string; forma?: 'moneda' | 'billete' | 'cubo' | 'esfera' | 'lingote' | Objeto3D; color?: string; metal?: number; rugosidad?: number; ancho?: number; alto?: number; tamano?: number; rotacion?: [number, number, number]; girar3d?: [number, number, number]; cantidad?: number; crecer?: boolean; duracion?: number; distancia?: number; camaraY?: number; luz?: number; reflejos?: number; /** levanta hacia la cámara los modelos planos acostados (por defecto en recursos) */ levantar?: boolean; /** tuberia */ puntos?: [number, number, number][]; radio?: number; material?: 'pvc' | 'cobre' | 'acero' | 'vidrio'; agua?: boolean; velocidad?: number; colorAgua?: string; gotas?: number; /** muro */ columnas?: number; filas?: number; colorLadrillo?: string; colorMezcla?: string; /** viga */ largo?: number; vertical?: boolean; /** escalera */ escalones?: number; /** suelo */ capas?: [string, number][]}
 		| {tipo: 'componente'; nombre: string; props?: Record<string, unknown>}
+		/** Ambiente 3D completo (set con utilería, luz y vida de fondo). Como `mundo`, cada escena elige su `plano`. */
+		| {tipo: 'ambiente'; nombre: Ambiente; plano?: string; planos?: (string | null)[]; persona?: boolean | {ropa?: string; pelo?: string; piel?: string; semilla?: number}; reaccionar?: boolean; reacciones?: {en: number; expresion?: string; pose?: string}[]; post?: Post3D; etiquetas?: {ancla?: string; pos?: [number, number, number]; texto: string; escena?: number | number[]; en?: number; hasta?: number; color?: string; lado?: 'arriba' | 'abajo' | 'izq' | 'der'}[]}
 		| {tipo: 'personaje'; nombre: string; pose?: string; poses?: {en: Momento; pose: string}[]; hablar?: boolean; ancho?: number}
 		| {tipo: 'escena3d'; src: string; camara?: {en?: Momento; pos: [number, number, number]; mirar?: [number, number, number]; fov?: number}[]; animacion?: boolean | string | string[]; velocidad?: number; mostrar?: {nodo: string; en: Momento}[]; ocultar?: {nodo: string; en: Momento}[]; fondo?: string | null; niebla?: [number, number]; luz?: number; luzAmbiente?: number; sol?: [number, number, number]; reflejos?: number; sombras?: boolean; ancho?: number; alto?: number}
 		| {tipo: 'barra'; valor: number; max?: number; titulo?: string; unidad?: string; mostrar?: boolean; color?: string; ancho?: number; alto?: number; fondo?: string; decimales?: number}
@@ -192,6 +197,15 @@ interface EscenaMotorBase extends EscenaBase {
 	modoHasta?: Momento;
 	/** Lugar (de `lugares` del video) donde pasa esta escena. */
 	lugar?: string;
+	/** Con `ambiente`: plano de cámara de esta escena ('general', 'persona', 'tele'…). Sin él, cada escena toma otro ángulo. */
+	plano?: string;
+	/**
+	 * Cortes de cámara dentro de la escena (con `ambiente`): segundos desde que empieza. Sin decirlo, corta solo en la
+	 * primera palabra clave si la escena dura más de 3,5 s (o a la mitad si pasa de 7 s). `false` los apaga.
+	 */
+	cortes?: number[] | false;
+	/** Golpe de cámara (zoom con sacudida) cuando cae el rótulo. Por defecto sí con rotuloEstilo 'sello' y 'pixel'. */
+	golpe?: boolean;
 	/** 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). */
@@ -224,7 +238,7 @@ export interface Tema {
 	subtitulos: {tipo: 'karaoke' | 'seleccion' | 'pop' | 'bloque' | 'palabra' | 'caja' | 'ninguno'; y: number; tam: number; color: string; pendiente: string; resalte: string; maxPalabras: number; mayusculas?: boolean | 'inicial'; contorno?: number; fondo?: string; /** Colores que rotan entre las palabras clave (palabra, pop). */ coloresClave?: 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'};
+	movimiento?: {entrada?: number; salida?: number; transicion?: number; curva?: 'suave' | 'resorte' | 'seca'; /** false quita los golpes de cámara de los rótulos sello/pixel. */ golpes?: boolean};
 	/** 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'};
@@ -282,6 +296,11 @@ export interface 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).
 	 */
+	/**
+	 * Ambiente 3D listo como mundo del video: 'cuarto-gamer' | 'sala' | 'arcade' (o {nombre, persona, post}).
+	 * Sirve en cualquier estilo del motor de capas; cada escena elige su `plano` o toma otro ángulo sola.
+	 */
+	ambiente?: Ambiente | {nombre: Ambiente; persona?: boolean | {ropa?: string; pelo?: string; piel?: string}; reaccionar?: boolean; post?: Post3D};
 	mundo?: Capa[];
 	/**
 	 * Varios mundos en un video (biografías, historias que cambian de sitio): `{cocina: [...], boda: [...]}`. Cada escena

package/lib/calidad.mjs

@@ -72,3 +72,130 @@ export function revisarVoz(v, d) {
 	});
 	return out;
 }
+
+/**
+ * Mira el video terminado (cuadros cada 0,5 s a 54×96) y avisa lo que en la hoja se ve "a ojo":
+ *   negro     cuadro casi negro y liso (escena sin nada)
+ *   tapado    un solo color cubre más del 58 % del cuadro (cámara pegada a un objeto, pantalla o pared)
+ *   plano     fondo liso sin variación (solo subtítulo sobre un color)
+ *   quieto    más de 3 s sin que nada se mueva
+ * `d` (datos.json) sirve para decir en qué escena pasa. Necesita el MP4: corre después del render.
+ * @returns {{id: string, nivel: 'aviso' | 'idea', texto: string}[]}
+ */
+export async function revisarCuadros(mp4, d) {
+	const {binarios, leerPng} = await import('./hoja.mjs');
+	const {spawnSync} = await import('node:child_process');
+	const fs = await import('node:fs');
+	if (!fs.existsSync(mp4)) return [];
+	const {ffmpeg, ffprobe, cwd} = binarios();
+	const sonda = spawnSync(ffprobe, ['-v', 'error', '-show_entries', 'format=duration', '-of', 'csv=p=0', mp4], {encoding: 'utf8', cwd});
+	const dur = Number(sonda.stdout?.trim());
+	if (!dur) return [];
+	const W = 54;
+	const H = 96;
+	// todos los cuadros en una pasada: -r 2 en la salida toma 2 por segundo (el ffmpeg de Remotion no trae el filtro fps)
+	// (ni rawvideo: los cuadros salen como PNG seguidos por la tubería y se separan en cada IEND)
+	const r = spawnSync(ffmpeg, ['-v', 'error', '-i', mp4, '-r', '2', '-vf', `scale=${W}:${H}`, '-f', 'image2pipe', '-c:v', 'png', '-pred', 'none', '-pix_fmt', 'rgb24', '-'], {maxBuffer: 512 * 1024 * 1024, cwd});
+	if (r.status !== 0 || !r.stdout?.length) return [];
+	const pngs = [];
+	for (let p = 0, ini = 0; p + 8 <= r.stdout.length; ) {
+		if (p === ini) p += 8; // firma PNG
+		const largo = r.stdout.readUInt32BE(p);
+		const tipo = r.stdout.toString('latin1', p + 4, p + 8);
+		p += 12 + largo;
+		if (tipo === 'IEND') pngs.push(r.stdout.subarray(ini, p)), (ini = p);
+	}
+	const tam = W * H * 3;
+	const n = pngs.length;
+	const muestras = [];
+	let prev = null;
+	for (let i = 0; i < n; i++) {
+		let px;
+		try {
+			px = leerPng(pngs[i], W, H);
+		} catch {
+			continue;
+		}
+		const cubetas = new Map();
+		let suma = 0;
+		let suma2 = 0;
+		let dif = 0;
+		for (let k = 0; k < tam; k += 3) {
+			const l = 0.299 * px[k] + 0.587 * px[k + 1] + 0.114 * px[k + 2];
+			suma += l;
+			suma2 += l * l;
+			const c = ((px[k] >> 5) << 6) | ((px[k + 1] >> 5) << 3) | (px[k + 2] >> 5);
+			cubetas.set(c, (cubetas.get(c) ?? 0) + 1);
+			if (prev) dif += Math.abs(px[k] - prev[k]) + Math.abs(px[k + 1] - prev[k + 1]) + Math.abs(px[k + 2] - prev[k + 2]);
+		}
+		const m = W * H;
+		const media = suma / m;
+		const desv = Math.sqrt(Math.max(0, suma2 / m - media * media));
+		let dom = 0;
+		let domC = 0;
+		for (const [c, v] of cubetas) if (v > dom) (dom = v), (domC = c);
+		// brillo de la cubeta dominante (0–255): un fondo nocturno oscuro no cuenta como "tapado"
+		const luzDom = 0.299 * ((domC >> 6) * 32 + 16) + 0.587 * (((domC >> 3) & 7) * 32 + 16) + 0.114 * ((domC & 7) * 32 + 16);
+		muestras.push({t: i / 2, media, desv, dom: dom / m, luzDom, dif: prev ? dif / (m * 3) : null});
+		if (process.env.MORFEO_DEBUG_CUADROS) console.log(JSON.stringify(muestras.at(-1), (k, v) => (typeof v === 'number' ? Math.round(v * 100) / 100 : v)));
+		prev = px;
+	}
+	const escenaDe = (t) => {
+		const es = d?.escenas ?? [];
+		for (let i = es.length - 1; i >= 0; i--) if (t >= es[i].t0) return {n: i + 1, cta: es[i].tipo === 'cta'};
+		return null;
+	};
+	const tipos = {
+		// medido: escenas sin nada sobre fondo oscuro → media 13–15 y la cubeta más oscura con 97 % del cuadro;
+		// tele o pared pegadas a la cámara → desviación 12–16 con media > 130; los videos buenos del canal: desviación ≥ 27
+		negro: (s) => (s.media < 16 && s.desv < 9) || (s.media < 25 && s.dom > 0.9),
+		tapado: (s) => (s.dom > 0.58 && s.luzDom > 45) || (s.desv < 18 && s.media > 60),
+		plano: (s) => s.desv < 14 && s.media >= 25 && s.media <= 60,
+	};
+	const TEXTO = {
+		negro: 'cuadro casi negro (¿escena sin nada en pantalla?)',
+		tapado: 'un solo color cubre casi todo el cuadro (¿cámara pegada a un objeto, a una pantalla o a una pared?)',
+		plano: 'fondo liso, sin nada detrás del texto (prueba un `ambiente` o un `mundo`)',
+	};
+	const out = [];
+	const fmt = (a, b) => (b - a < 0.6 ? `${a.toFixed(1)} s` : `${a.toFixed(1)}–${b.toFixed(1)} s`);
+	const donde = (a) => {
+		const e = escenaDe(a);
+		return e ? `Escena ${e.n}` : 'Video';
+	};
+	for (const [tipo, es] of Object.entries(tipos)) {
+		let ini = null;
+		for (let i = 0; i <= muestras.length; i++) {
+			const s = muestras[i];
+			const si = s && es(s) && !escenaDe(s.t)?.cta;
+			// un aviso por escena: si cambia de escena a media racha, se corta ahí
+			const otra = si && ini != null && escenaDe(s.t)?.n !== escenaDe(ini)?.n;
+			if (otra) {
+				const fin = muestras[i - 1].t;
+				if (fin - ini >= 1) out.push({id: 'cuadros', nivel: 'aviso', texto: `${donde(ini)} · ${fmt(ini, fin)}: ${TEXTO[tipo]}`});
+				ini = s.t;
+				continue;
+			}
+			if (si && ini == null) ini = s.t;
+			if (!si && ini != null) {
+				const fin = muestras[i - 1].t;
+				// un cuadro suelto (un destello, un corte) no cuenta: al menos 1 s seguido
+				if (fin - ini >= 1) out.push({id: 'cuadros', nivel: 'aviso', texto: `${donde(ini)} · ${fmt(ini, fin)}: ${TEXTO[tipo]}`});
+				ini = null;
+			}
+		}
+	}
+	// quieto: diferencia media entre cuadros (0.5 s) casi cero durante más de 3 s
+	let ini = null;
+	for (let i = 1; i <= muestras.length; i++) {
+		const s = muestras[i];
+		const quieto = s && s.dif != null && s.dif < 0.7 && !escenaDe(s.t)?.cta;
+		if (quieto && ini == null) ini = muestras[i - 1].t;
+		if (!quieto && ini != null) {
+			const fin = muestras[i - 1].t;
+			if (fin - ini >= 3) out.push({id: 'cuadros', nivel: 'aviso', texto: `${donde(ini)} · ${fmt(ini, fin)}: nada se mueve (agrega movimiento de cámara, un \`ambiente\` o algo que entre a media frase)`});
+			ini = null;
+		}
+	}
+	return out;
+}

package/lib/config.mjs

@@ -27,7 +27,8 @@ 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', 'linea'];
+export const TIPOS_CAPA = ['imagen', 'video', 'texto', 'contador', 'chip', 'etiqueta', 'numero', 'tarjeta', 'telefono', 'forma', 'icono', 'emoji', 'marca', 'particulas', 'grupo', 'modelo', 'componente', 'ambiente', '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 AMBIENTES = ['cuarto-gamer', 'sala', 'arcade'];
 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'];
@@ -230,6 +231,7 @@ function validarCapas(capas, donde, err, comps) {
 			else if (comps && !comps.includes(c.nombre))
 				err(`${d}: el componente "${c.nombre}" no está en morfeo.config.mjs → componentes${comps.length ? ` (hay: ${comps.join(', ')})` : ''}`);
 		}
+		if (c.tipo === 'ambiente' && !AMBIENTES.includes(c.nombre)) err(`${d}: ambiente "${c.nombre}" no existe. Opciones: ${AMBIENTES.join(', ')}`);
 		if (c.tipo === 'medida' && (!Array.isArray(c.de) || !Array.isArray(c.a))) err(`${d}: \`medida\` necesita \`de: [x, y]\` y \`a: [x, y]\``);
 		if (c.tipo === 'trazo' && (!Array.isArray(c.puntos) || c.puntos.length < 2)) err(`${d}: \`trazo\` necesita \`puntos\` con al menos 2 [x, y]`);
 		if (c.tipo === 'terminal' && !Array.isArray(c.lineas)) err(`${d}: \`terminal\` necesita \`lineas\` (lista de textos)`);
@@ -320,6 +322,12 @@ function validarVideo(id, v, ctx) {
 	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(', ')}`);
+	// `ambiente: 'cuarto-gamer'` (o {nombre, persona, post}) = un mundo listo con ese set
+	if (v.ambiente != null) {
+		if (v.mundo || v.lugares) err('usa `ambiente` o `mundo`/`lugares`, no los dos');
+		else if (clasico) err('`ambiente` es del motor de capas: usa un estilo como 3d, historia o minimal (no "datos-curiosos")');
+		else v = {...v, mundo: [{tipo: 'ambiente', x: 540, y: 960, entrada: 'ninguna', ...(typeof v.ambiente === 'string' ? {nombre: v.ambiente} : v.ambiente)}]};
+	}
 	const permitidos = clasico ? TIPOS_ESCENA : TIPOS_MOTOR;
 	const scenes = v.scenes.map((s0, i) => {
 		const n = `escena ${i + 1}`;
@@ -340,6 +348,7 @@ function validarVideo(id, v, ctx) {
 		if (s.modo != null) {
 			if (!MODOS.includes(s.modo)) err(`${n}: modo "${s.modo}" no existe. Opciones: ${MODOS.join(', ')}`);
 		} else if (s.modoEn != null || s.modoHasta != null) err(`${n}: \`modoEn\`/\`modoHasta\` necesitan \`modo\` ('rayosx', 'plano' u 'holograma')`);
+		if (s.plano != null && typeof s.plano !== 'string' && typeof s.plano !== 'object') err(`${n}: \`plano\` es el nombre de un plano del ambiente ('tele', 'persona'…) o una toma 3D`);
 		if (s.claves != null && (!Array.isArray(s.claves) || s.claves.some((k) => typeof k !== 'string'))) err(`${n}: \`claves\` debe ser una lista de palabras (['cerebro'])`);
 		if (s.toma != null) {
 			const tm = s.toma;

package/lib/estructura.mjs

@@ -66,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();
@@ -79,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];
@@ -91,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.`);
 		});
@@ -110,8 +113,35 @@ 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.');
+	// 5b) escenas vacías y riesgo de "diapositiva" (texto sobre fondo plano, sin mundo y siempre lo mismo)
+	if (!clasico) {
+		// fondo de pantalla completa en la escena (escenario, componente propio, 3D, vigilancia…) también cuenta como mundo
+		const FONDOS = new Set(['escenario', 'componente', 'ambiente', 'escena3d', 'vigilancia', 'dividida', 'imagen', 'video', 'tierra', 'personaje']);
+		const conFondo = cuerpo.filter((s) => (s.capas ?? []).some((c) => c && FONDOS.has(c.tipo))).length;
+		const conMundo = !!(v.mundo?.length || v.lugares || v.ambiente) || conFondo / Math.max(1, cuerpo.length) >= 0.6;
+		const SOLO_TEXTO = new Set(['texto', 'chip', 'numero', 'etiqueta', 'tarjeta', 'titular', 'contador', 'checklist']);
+		let vacias = 0;
+		let soloTexto = 0;
+		const tipos = new Map();
+		cuerpo.forEach((s, i) => {
+			const capas = (s.capas ?? []).filter(Boolean);
+			if (!conMundo && (s.type ?? 'capas') === 'capas' && !capas.length && !s.rotulo) {
+				vacias++;
+				add('vacia', 'aviso', `Escena ${i + 1}: solo el subtítulo sobre el fondo. Agrega una capa o dale al video un \`ambiente: 'cuarto-gamer'\` (o 'sala', 'arcade').`);
+			}
+			if (capas.length && capas.every((c) => SOLO_TEXTO.has(c.tipo))) soloTexto++;
+			for (const c of capas) tipos.set(c.tipo, (tipos.get(c.tipo) ?? 0) + 1);
+		});
+		const m = Math.max(1, cuerpo.length);
+		const repetido = Math.max(0, ...tipos.values()) / m;
+		const riesgo = Math.round((conMundo ? 0 : 35) + (vacias / m) * 30 + (soloTexto / m) * 25 + (repetido > 0.5 ? 10 : 0));
+		if (riesgo >= 45) {
+			const por = [!conMundo && 'sin mundo ni ambiente', vacias && `${vacias} escena(s) vacías`, soloTexto && `${soloTexto} escena(s) de puro texto`, repetido > 0.5 && 'la misma capa en casi todas'].filter(Boolean).join(', ');
+			add('diapositiva', 'aviso', `Riesgo de "diapositiva" ${riesgo}/100 (${por}): se verá como texto sobre un fondo. Un \`ambiente\` o un \`mundo\` da fondo vivo y otro ángulo en cada escena.`);
+		}
+	}
 	// 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

package/lib/formulas.mjs

@@ -94,7 +94,8 @@ export const FORMULAS = [
 		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".'] : []),
+		// solo si el guion habla de lo de adentro: un demuéstralo de reflejos o de vista no tiene interior que mostrar
+		revisar: (v) => (!(v.scenes ?? []).some((s) => s.modo) && /dentro|adentro|interior|por dentro/i.test((v.scenes ?? []).map((s) => s.say ?? '').join(' ')) ? ['Fórmula "demuéstralo": la explicación luce con `modo: \'rayosx\'` en la palabra donde se ve "por dentro".'] : []),
 	},
 	{
 		id: 'mito',

package/lib/hoja.mjs

@@ -12,7 +12,7 @@ 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() {
+export 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;
@@ -47,7 +47,7 @@ const trozo = (tipo, datos) => {
 };
 
 /** PNG RGB de 8 bits sin predicción -> píxeles crudos (alto × ancho × 3). */
-function leerPng(b, w, h) {
+export function leerPng(b, w, h) {
 	const idat = [];
 	for (let p = 8; p + 8 <= b.length; ) {
 		const largo = b.readUInt32BE(p);

package/lib/recursos.mjs

@@ -260,11 +260,15 @@ export async function resolverRecursos(video, assetsPublico, log = console.log)
 			const intentos =
 				estilo === '2d'
 					? [...Object.keys(VARIANTES_2D).filter((v) => v !== (variante ?? 'color') && v !== 'linea').map((v) => ['2d', v]), ['3d'], ['realista']]
-					: [...['3d', 'realista'].filter((e) => e !== estilo).map((e) => [e]), ['2d', variante]];
+					: // un 3D low-poly que no existe cae a 2D antes que a realista: un gato de piedra fotorrealista no
+						// combina con un video de figuras planas (pasó con 'gato' en un video del canal)
+						estilo === 'realista'
+						? [['3d'], ['2d', variante]]
+						: [['2d', variante], ['realista']];
 			for (const [otro, otraVariante] of intentos) {
 				res = await buscarRecursos(buscar, {estilo: otro, variante: otraVariante});
 				if (res.length) {
-					log(`    "${buscar}" no está en ${estilo}${variante ? ' ' + variante : ''}; uso ${otro}${otraVariante && otro === '2d' ? ' ' + otraVariante : ''}`);
+					log(`    ${otro === 'realista' ? '⚠ ' : ''}"${buscar}" no está en ${estilo}${variante ? ' ' + variante : ''}; uso ${otro}${otraVariante && otro === '2d' ? ' ' + otraVariante : ''}${otro === 'realista' ? ' (puede no combinar con el resto: prueba un sinónimo o estilo: \'2d\')' : ''}`);
 					break;
 				}
 			}

package/lib/render.mjs

@@ -208,12 +208,33 @@ export async function preparar({proyecto = process.cwd(), ids, log = console.log
 	return {p, publico, marca, extras, datos, creditos, fallidos};
 }
 
+// ¿El video dibuja con WebGL? Capas 3D del motor o componentes del proyecto que usan Three.js / Lienzo3D.
+export function usaWebGL(p, id) {
+	const v = p.videos[id];
+	if (!v) return false;
+	const texto = JSON.stringify(v);
+	if (/"tipo":"(modelo|escena3d|ambiente)"/.test(texto) || v.ambiente) return true;
+	for (const [nombre, ruta] of Object.entries(p.componentes ?? {})) {
+		if (!texto.includes(`"nombre":"${nombre}"`)) continue;
+		try {
+			if (/Lienzo3D|ThreeCanvas|@react-three|from ['"]three['"]/.test(fs.readFileSync(ruta, 'utf8'))) return true;
+		} catch {
+			return true;
+		}
+	}
+	return false;
+}
+
 /**
  * Genera los videos. Sin ids: los que aún no existen en la carpeta de salida.
  * @param {{proyecto?: string, ids?: string[], todos?: boolean, log?: (m: string) => void, alProgreso?: (id: string, p: number) => void}} o
  * @returns {Promise<{id: string, mp4: string, jpg: string | null, segundos: number}[]>}
  */
-export async function render({proyecto = process.cwd(), ids, todos = false, soloFallidos = false, previa = null, log = console.log, alProgreso} = {}) {
+export async function render({proyecto = process.cwd(), ids, todos = false, soloFallidos = false, previa = null, animatica = false, escenas = null, log = console.log, alProgreso} = {}) {
+	// animática: todo el video a 1/3 de tamaño y menor calidad (para aprobar tomas y ritmo en segundos)
+	// escenas: [a, b] (1 = la primera) solo ese tramo, en tamaño completo
+	const parcial = !!(animatica || escenas);
+	if (parcial && !ids?.length) throw new ErrorMorfeo('Dime qué video:  npx morfeo ' + (animatica ? 'animatica' : 'render') + ' mi-video');
 	// previa: solo el gancho (las primeras escenas, hasta `previa` segundos o ~8 s) en "<título> (previa).mp4", sin miniatura
 	if (previa && !ids?.length) throw new ErrorMorfeo('Dime qué video:  npx morfeo previa mi-video');
 	cargarEnv(proyecto);
@@ -268,12 +289,16 @@ export async function render({proyecto = process.cwd(), ids, todos = false, solo
 			const t = Date.now();
 			try {
 			const inputProps = {videos: {[id]: datos[id]}, marca, ...extras};
-			const mp4 = previa ? salidaDe(p, id).replace(/\.mp4$/, ' (previa).mp4') : salidaDe(p, id);
+			const sufijo = previa ? ' (previa)' : animatica ? ' (animatica)' : escenas ? ` (escenas ${escenas[0]}${escenas[1] !== escenas[0] ? '-' + escenas[1] : ''})` : '';
+			const mp4 = sufijo ? salidaDe(p, id).replace(/\.mp4$/, `${sufijo}.mp4`) : salidaDe(p, id);
 			// tramo de la previa: hasta el final de la 2.ª escena (gancho + la que sigue), entre 4 y 8 s, o lo que se pida
 			const d0 = datos[id];
 			const finPrevia = typeof previa === 'number' ? previa : Math.min(8, Math.max(4, (d0.escenas[1] ?? d0.escenas[0]).t0 + (d0.escenas[1] ?? d0.escenas[0]).dur));
 			let gl = p.render.gl;
-			let concurrencia = concurrenciaBase;
+			// WebGL con GPU y muchas pestañas: alguna se queda "pegada" y sus cuadros salen con rótulos o subtítulos de
+			// cuadros anteriores (medido en Windows + RTX 3060: 9 pestañas → 0–54 cuadros malos de 270; 4 → 41–81; 2–3 → 0
+			// en 24 pruebas, casi igual de rápido). Solo se limita si el video usa 3D y nadie fijó la concurrencia.
+			let concurrencia = gl === 'angle' && p.render.concurrencia == null && usaWebGL(p, id) ? Math.min(concurrenciaBase, 3) : concurrenciaBase;
 			let composition;
 			// hasta 3 intentos: si el navegador truena, se baja la concurrencia y, con GPU, se pasa a software
 			for (let intento = 1; ; intento++) {
@@ -295,6 +320,8 @@ export async function render({proyecto = process.cwd(), ids, todos = false, solo
 						concurrency: concurrencia,
 						outputLocation: mp4,
 						...(previa ? {frameRange: [0, Math.min(composition.durationInFrames - 1, Math.round(finPrevia * composition.fps))]} : {}),
+						...(escenas ? {frameRange: tramoEscenas(d0, escenas, composition)} : {}),
+						...(animatica ? {scale: 1 / 3, crf: 30, jpegQuality: 70} : {}),
 						onProgress: ({progress}) => {
 							alProgreso?.(id, progress);
 							// con terminal: cada 10 % en la misma línea; sin terminal (logs, CI): cada 25 %
@@ -320,7 +347,7 @@ export async function render({proyecto = process.cwd(), ids, todos = false, solo
 				}
 			}
 			let jpg = null;
-			if (p.render.miniatura && !previa) {
+			if (p.render.miniatura && !previa && !parcial) {
 				// miniatura: cuando la primera escena ya está completa (o en `miniaturaEn`), sin subtítulos
 				jpg = salidaDe(p, id, 'jpg');
 				const d = datos[id];
@@ -332,7 +359,7 @@ export async function render({proyecto = process.cwd(), ids, todos = false, solo
 			}
 			// portada: el mismo cuadro con el título grande y la marca (`portada: 'texto'` o el título sin emojis; false = sin portada)
 			const vid = p.videos[id];
-			if (!previa && p.render.portada !== false && vid.portada !== false && jpg) {
+			if (!previa && !parcial && p.render.portada !== false && vid.portada !== false && jpg) {
 				const textoPortada = typeof vid.portada === 'string' ? vid.portada : String(vid.title ?? id).replace(/[\p{Extended_Pictographic}\uFE0F\u200D]/gu, '').replace(/\s*[|·].*$/, '').trim();
 				const d = datos[id];
 				const e0 = d.escenas[0];
@@ -354,11 +381,20 @@ export async function render({proyecto = process.cwd(), ids, todos = false, solo
 	} finally {
 		soltar();
 	}
-	if (previa) return hechos;
+	if (previa || parcial) return hechos;
 	return terminarLote(p, loteArchivo, hechos, fallidos, log);
 }
 
 const CRF = {alta: 18, media: 21, ligera: 24};
+/** Cuadros [inicio, fin] de las escenas a..b (1 = la primera). */
+function tramoEscenas(d, [a, b], composition) {
+	const n = d.escenas.length;
+	const ea = d.escenas[Math.max(0, Math.min(n - 1, a - 1))];
+	const eb = d.escenas[Math.max(0, Math.min(n - 1, b - 1))];
+	const fps = composition.fps;
+	return [Math.round(ea.t0 * fps), Math.min(composition.durationInFrames - 1, Math.round((eb.t0 + eb.dur) * fps) - 1)];
+}
+
 /** CRF del video: `crf` explícito > `calidad` del video > `render.calidad` > media con mundo, alta sin él. */
 export function crfDe(p, id) {
 	if (p.render.crf != null) return p.render.crf;

package/package.json

@@ -1,11 +1,11 @@
 {
 	"name": "morfeo",
-	"version": "0.5.0",
+	"version": "0.6.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",
 	"author": "Uriel Gómez",
-	"homepage": "https://morfeo-docs-two.vercel.app/",
+	"homepage": "https://morfeo.ureck.dev/",
 	"repository": {
 		"type": "git",
 		"url": "git+https://github.com/UreckChan/morfeo.git"
@@ -62,6 +62,7 @@
 	"dependencies": {
 		"@anthropic-ai/sdk": "^1.6.0",
 		"@react-three/fiber": "^9.3.0",
+		"@react-three/postprocessing": "3.2.0",
 		"@remotion/bundler": "4.0.541",
 		"@remotion/cli": "4.0.541",
 		"@remotion/fonts": "4.0.541",
@@ -70,6 +71,7 @@
 		"@remotion/noise": "4.0.541",
 		"@remotion/renderer": "4.0.541",
 		"@remotion/three": "4.0.541",
+		"postprocessing": "6.39.5",
 		"react": "^19.2.0",
 		"react-dom": "^19.2.0",
 		"remotion": "4.0.541",

package/plantilla/AGENTS.md

@@ -6,9 +6,12 @@ técnica. Nunca publiques nada por ella: le entregas los archivos y ella decide
 
 Comandos de referencia: `npx morfeo ayuda`. Tipos de todo lo que existe: `node_modules/morfeo/index.d.ts`.
 
+**Antes de cada video lee `gustos.md`**: son las reglas de estilo de este canal y mandan sobre lo de abajo. Cuando
+la persona te corrija algo que deba valer para los siguientes videos, ofrécele agregarlo a `gustos.md`.
+
 ## Cuando diga «Configúrame» (o es la primera vez)
 
-1. Revisa que haya Node 20+ (`node -v`). Si falta, dile cómo instalarlo y espera.
+1. Revisa que haya Node 18.17+ (`node -v`). Si falta, dile cómo instalarlo y espera.
 2. `npm install` en esta carpeta.
 3. `npx morfeo instalar --si` (Python, voces gratis, navegador; tarda unos minutos la primera vez). Si algo falla,
    lee el mensaje, arréglalo y vuelve a correrlo. `npx morfeo doctor` dice qué falta.
@@ -38,12 +41,15 @@ Comandos de referencia: `npx morfeo ayuda`. Tipos de todo lo que existe: `node_m
 4. **Enséñale el guion** (texto de cada escena, en limpio) y espera su visto bueno o sus cambios.
 5. **Enséñale el gancho:** `npx morfeo previa <id>` renderiza solo los primeros segundos. Si no le convence, cámbialo
    (tiene 3 ganchos de reserva en `hooks`).
-6. **Renderiza:** `npx morfeo render <id>`.
-7. **Revisa antes de entregar:**
-   - `npx morfeo revisar <id>`: estructura, que la voz haya dicho el guion y que nada quede bajo los botones de la app.
+6. **Aprueba tomas y ritmo barato:** `npx morfeo animatica <id>` (todo el video a 1/3 de tamaño + su hoja). Si una
+   toma está mal, arréglala y vuelve a pedir solo esas escenas: `npx morfeo render <id> --escenas 5-6`.
+7. **Renderiza:** `npx morfeo render <id>`.
+8. **Revisa antes de entregar:**
+   - `npx morfeo revisar <id>`: estructura, que la voz haya dicho el guion, que nada quede bajo los botones de la app,
+     el riesgo de "diapositiva" y, en el MP4, cuadros negros, tapados (cámara pegada a algo), lisos o quietos.
    - `npx morfeo hoja <id> --zona`: mira la hoja de contacto (es una imagen); lo pintado en rojo es lo que tapan las apps.
    - Si algo se ve mal (texto encimado, objeto cortado, cuadro vacío), arréglalo y vuelve a renderizar.
-8. **Entrega:** en `salida/` quedan `<título>.mp4`, `<título>.jpg` (miniatura), `<título> (portada).jpg` y
+9. **Entrega:** en `salida/` quedan `<título>.mp4`, `<título>.jpg` (miniatura), `<título> (portada).jpg` y
    `<título>.txt` (texto del post, etiquetas, fuentes y ganchos de reserva). Dile eso y nada más.
 
 ## Reglas

package/plantilla/gustos.md

@@ -0,0 +1,19 @@
+# Gustos del canal
+
+Reglas de estilo que el agente (Claude Code, Codex…) sigue en **todos** los videos de este proyecto. Escríbelas a tu
+manera: una por línea. Cuando le corrijas algo a un video y quieras que no se repita, agrégalo aquí.
+
+## Lo que sí
+
+- Siempre un fondo vivo: un `ambiente` ('cuarto-gamer', 'sala', 'arcade') o un `mundo` propio. Nada de texto sobre un color liso.
+- Objetos 2D/3D (`recurso`) antes que emojis.
+- Gancho en segunda persona en los primeros 2 segundos.
+
+## Lo que no
+
+- Emojis en pantalla (solo en el título, si acaso).
+- Escenas de más de 5 segundos con la misma toma.
+
+## Mi tono
+
+- (Ejemplo) Cercano, con humor, sin groserías.