morfeo 0.1.0 → 0.1.2

package/README.md

@@ -1,6 +1,6 @@
 # Morfeo
 
-> Galería de estilos y ejemplos: [github.com/UreckChan/morfeo](https://github.com/UreckChan/morfeo).
+> **Documentación: [ureckchan.github.io/morfeo](https://ureckchan.github.io/morfeo/)** · Ejemplos: [github.com/UreckChan/morfeo](https://github.com/UreckChan/morfeo)
 
 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.
@@ -21,6 +21,7 @@ la voz, la música, los efectos de sonido, los subtítulos, las animaciones y la
 
 - **Voces:** Kokoro (gratis, en tu computadora, más de 50 voces y mezclas), ElevenLabs, OpenAI, tu propia
   grabación por escena o cualquier servicio que conectes con una función.
+- **Objetos 2D y 3D:** una biblioteca con diccionario temático en español (`{tipo: 'recurso', buscar: 'tubería', estilo: '3d'}`) que busca en Kenney, Poly Haven e Iconify (miles de modelos e ilustraciones libres), más objetos 3D y piezas de construcción hechos en código (tuberías con agua, muros, vigas…) y escenarios ilustrados animados. Los emojis quedan como último recurso.
 - **Música:** 7 estilos generados sin derechos de autor, o tu propia pista (mp3, wav, flac, ogg). Baja sola cuando habla la voz.
 - **Guiones:** los escribes tú, o Claude escribe el video completo a partir de un tema o de tu texto.
 - **Subtítulos:** palabra por palabra; con Whisper quedan sincronizados con la voz real.

package/bin/morfeo.mjs

@@ -22,6 +22,8 @@ Videos
       --gpu               usa la tarjeta de video (más rápido; si falla, quítalo)
   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
+  recursos buscar "x"   Busca un objeto (--3d, --realista, --2d --variante clay)
 
 Guiones
   guion "tema"          La IA (Claude) escribe un video completo sobre el tema
@@ -46,7 +48,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', 'musica', 'titulo', 'modelo', 'puerto'];
+			const conValor = ['proyecto', 'desde', 'id', 'voz', 'duracion', 'idioma', 'estilo', 'tono', 'variante', 'fuente', 'musica', 'titulo', 'modelo', 'puerto'];
 			if (v != null) op[clave] = v;
 			else if (conValor.includes(clave) && sig != null && !sig.startsWith('--')) op[clave] = argv[++i];
 			else op[clave] = true;
@@ -97,6 +99,29 @@ async function main() {
 			const {studio} = await import('../lib/render.mjs');
 			return studio({proyecto, puerto: op.puerto});
 		}
+		case 'recursos':
+		case 'recurso': {
+			const [sub, ...resto] = pos;
+			const {buscarRecursos, VARIANTES_2D} = await import('../lib/recursos.mjs');
+			const {listaTemas, traducir} = await import('../lib/diccionario.mjs');
+			if (sub === 'temas' || !sub) {
+				for (const [t, terminos] of Object.entries(listaTemas())) console.log(`  ${t.padEnd(14)} ${terminos.map((x) => x.replace(/_/g, ' ')).join(', ')}`);
+				console.log(`\nEstilos: 2d (variantes: ${Object.keys(VARIANTES_2D).join(', ')}), 3d, realista`);
+				console.log('Busca con:  npx morfeo recursos buscar "tubería" --3d   (o --2d --variante clay, o --realista)');
+				return;
+			}
+			if (sub !== 'buscar') throw new ErrorMorfeo('Uso:  npx morfeo recursos temas   |   npx morfeo recursos buscar "término" [--2d|--3d|--realista] [--variante clay]');
+			const termino = resto.join(' ').trim();
+			if (!termino) throw new ErrorMorfeo('¿Qué busco?  npx morfeo recursos buscar "tubería"');
+			const estilo = op['2d'] ? '2d' : op.realista ? 'realista' : '3d';
+			const t = traducir(termino);
+			console.log(`Buscando "${termino}" (${estilo}${op.variante ? ' ' + op.variante : ''}) → ${t.buscar.join(', ')}${t.tema ? ` · tema ${t.tema}` : ''}\n`);
+			const r = await buscarRecursos(termino, {estilo, variante: op.variante, fuente: op.fuente});
+			if (!r.length) return console.log('Sin resultados. Prueba otra palabra u otro estilo.');
+			r.slice(0, 15).forEach((x, i) => console.log(`  ${String(i).padStart(2)}  ${x.nombre.padEnd(30).slice(0, 30)} ${x.fuente.padEnd(10)} ${String(x.coleccion).padEnd(26).slice(0, 26)} ${x.licencia}`));
+			console.log(`\nÚsalo:  {tipo: 'recurso', buscar: '${termino}', estilo: '${estilo}'${op.variante ? `, variante: '${op.variante}'` : ''}}   (indice: n para elegir otro)`);
+			return;
+		}
 		case 'estilos': {
 			const {ESTILOS} = await import('../lib/config.mjs');
 			const desc = {

package/index.d.ts

@@ -23,6 +23,9 @@ interface EscenaBase {
 
 export type Estilo = 'datos-curiosos' | 'explicativo' | 'documental' | 'ilustrado' | 'historia' | 'mesa' | 'serie' | 'infografia' | '3d' | 'minimal' | (string & {});
 
+/** Objetos 3D incluidos para capas {tipo: 'modelo', forma}: mejor opción que un emoji. */
+export type Objeto3D = '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';
+
 /** 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';
@@ -74,7 +77,7 @@ export type Capa = CapaBase &
 		| {tipo: 'marca'; tam?: number}
 		| {tipo: 'particulas'; particulas?: 'burbujas' | 'polvo' | 'estrellas' | 'nieve' | 'confeti'; cantidad?: number; color?: string}
 		| {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'; 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}
+		| {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; /** 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>}
 		| {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}
@@ -87,13 +90,20 @@ export type Capa = CapaBase &
 		| {tipo: 'onda'; barras?: number; ancho?: number; alto?: number; color?: string; siempre?: boolean}
 		| {tipo: 'globo'; texto: string; cola?: 'abajo' | 'arriba' | 'izq' | 'der' | 'ninguna'; fondo?: string; color?: string; borde?: string; tam?: number; maxAncho?: number}
 		| {tipo: 'seguir'; usuario?: string; texto?: string; pulsar?: number}
+		| {tipo: 'recurso'; buscar: string; estilo?: '2d' | '3d' | 'realista'; variante?: 'color' | 'clay' | 'glass' | 'kawaii' | 'retro' | 'pastel' | 'sticker' | 'skeuo' | 'plush' | 'anime' | 'luxe' | 'chrome' | 'liquid' | 'bauhaus' | 'brutal' | 'gothic' | 'linea'; fuente?: 'kenney' | 'polyhaven' | 'iconify' | 'polypizza'; indice?: number; color?: string; ancho?: number; alto?: number; girar3d?: [number, number, number]; rotacion?: [number, number, number]}
+		| {tipo: 'escenario'; nombre: Escenario; parte?: 'fondo' | 'frente'; [opcion: string]: unknown}
+		| {tipo: 'ventana'; diametro?: number; src?: string; capas?: Capa[]; borde?: 'metal' | 'ninguno' | (string & {}); grosor?: number; remaches?: number | false; zoom?: number | [number, number]; fondo?: string}
 	);
 
 export type FondoEscena =
 	| {tipo: 'color'; color: string}
 	| {tipo: 'degradado'; colores: string[]; angulo?: number}
 	| {tipo: 'imagen'; src?: string; generar?: string; oscurecer?: number; desenfoque?: number}
-	| {tipo: 'video'; src: string; oscurecer?: number};
+	| {tipo: 'video'; src: string; oscurecer?: number}
+	| {tipo: 'escenario'; nombre: Escenario; oscurecer?: number; [opcion: string]: unknown};
+
+/** 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';
 
 interface EscenaMotorBase extends EscenaBase {
 	capas?: Capa[];
@@ -109,11 +119,11 @@ interface EscenaMotorBase extends EscenaBase {
 export type EscenaMotor =
 	| (EscenaMotorBase & {type?: 'capas'})
 	| (EscenaMotorBase & {type: 'titular'; texto: string; etiqueta?: string; numero?: number | string; sub?: string; y?: number; tam?: number})
-	| (EscenaMotorBase & {type: 'dato'; valor: number; de?: number; prefijo?: string; sufijo?: string; decimales?: number; curva?: 'suave' | 'lineal' | 'exponencial'; formato?: 'grande' | 'lcd' | 'chip'; texto?: string; imagen?: string | {generar: string}; tam?: number; y?: number; en?: Momento; duracion?: number})
+	| (EscenaMotorBase & {type: 'dato'; valor: number; de?: number; prefijo?: string; sufijo?: string; decimales?: number; curva?: 'suave' | 'lineal' | 'exponencial'; formato?: 'grande' | 'lcd' | 'chip'; texto?: string; objeto?: Objeto3D; imagen?: string | {generar: string}; tam?: number; y?: number; en?: Momento; duracion?: number})
 	| (EscenaMotorBase & {type: 'lista'; titulo?: string; cabecera?: string; items: (string | {texto: string; check?: Momento | boolean})[]; ancho?: number; y?: number})
 	| (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; emoji?: string; icono?: Icono; imagen?: string; color?: string; fondo?: string; en?: Momento})[]; formato?: 'cartas' | 'botones'; comenta?: string | false; enComenta?: Momento; y?: number})
+	| (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'});
 
 export interface Tema {
@@ -182,6 +192,8 @@ export interface Video {
 	/** Idioma de Kokoro: "es", "en-us", "en-gb", "fr-fr", "it", "pt-br", "ja", "cmn", "hi". */
 	lang?: string;
 	scenes: Escena[];
+	/** Segundo del video para la miniatura (por defecto, cuando la primera escena ya está completa). Sale sin subtítulos. */
+	miniaturaEn?: number;
 	/** Datos libres que se copian a salida/resumen.json. */
 	meta?: Record<string, unknown>;
 }
@@ -221,6 +233,7 @@ export interface Config {
 	musicas?: Record<string, Musica>;
 	/** Carpeta de los .mp4 (por defecto ./salida). */
 	salida?: string;
+	/** gl: por defecto 'angle' (GPU) en Mac con Apple Silicon y 'swangle' (CPU) en lo demás; si la GPU falla, reintenta con CPU. */
 	render?: {crf?: number; gl?: 'swangle' | 'angle' | 'egl' | 'swiftshader' | 'vulkan'; navegador?: string | null; concurrencia?: number | null; miniatura?: boolean};
 }
 

package/lib/config.mjs

@@ -5,16 +5,39 @@ import {pathToFileURL} from 'node:url';
 
 export const NOMBRES_CONFIG = ['morfeo.config.mjs', 'morfeo.config.js'];
 
+// Voces de Kokoro v1.0 (archivo voices-v1.0.bin)
+export const VOCES_KOKORO = 'af_alloy af_aoede af_bella af_heart af_jessica af_kore af_nicole af_nova af_river af_sarah af_sky am_adam am_echo am_eric am_fenrir am_liam am_michael am_onyx am_puck am_santa bf_alice bf_emma bf_isabella bf_lily bm_daniel bm_fable bm_george bm_lewis ef_dora em_alex em_santa ff_siwis hf_alpha hf_beta hm_omega hm_psi if_sara im_nicola jf_alpha jf_gongitsune jf_nezumi jf_tebukuro jm_kumo pf_dora pm_alex pm_santa zf_xiaobei zf_xiaoni zf_xiaoxiao zf_xiaoyi zm_yunjian zm_yunxi zm_yunxia zm_yunyang'.split(' ');
+
+/** Las voces más parecidas a un nombre mal escrito (para sugerir). */
+const parecidas = (nombre, lista, n = 3) => {
+	const d = (a, b) => {
+		const m = Array.from({length: a.length + 1}, (_, i) => [i, ...Array(b.length).fill(0)]);
+		for (let j = 1; j <= b.length; j++) m[0][j] = j;
+		for (let i = 1; i <= a.length; i++) for (let j = 1; j <= b.length; j++) m[i][j] = Math.min(m[i - 1][j] + 1, m[i][j - 1] + 1, m[i - 1][j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
+		return m[a.length][b.length];
+	};
+	return [...lista].sort((a, b) => d(nombre, a) - d(nombre, b)).slice(0, n);
+};
+
 export const TIPOS_CLASICOS = ['title', 'year', 'text', 'icon', 'compare', 'card', 'dialog', 'aliens', 'memory', 'morph', 'cta'];
 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'];
+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 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'];
 export const MUSICAS = ['lofi', 'lofi2', 'chillpop', 'synth', 'house', 'ballad', 'trap'];
 
 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.
+ */
+export const glPorDefecto = () => (process.platform === 'darwin' && process.arch === 'arm64' ? 'angle' : 'swangle');
+
 /** Una carpeta de guiones: cada <id>.json o <id>.mjs es un video. */
 async function leerCarpeta(dir) {
 	const out = {};
@@ -84,7 +107,8 @@ export async function cargarProyecto(proyecto = process.cwd()) {
 	const errores = [];
 	const estilosPropios = cfg.estilos ?? {};
 	const estilo = cfg.estilo ?? 'datos-curiosos';
-	const ctx = {proyecto, marca, voces: cfg.voces ?? {}, musicas: cfg.musicas ?? {}, errores, estilo, estilosPropios};
+	const assetsDir = path.resolve(proyecto, cfg.assets ?? 'assets');
+	const ctx = {proyecto, marca, voces: cfg.voces ?? {}, musicas: cfg.musicas ?? {}, errores, estilo, estilosPropios, assetsDir, personajes: cfg.personajes ?? {}};
 	if (!ESTILOS.includes(estilo) && !estilosPropios[estilo]) errores.push(`estilo "${estilo}" no existe. Opciones: ${[...ESTILOS, ...Object.keys(estilosPropios)].join(', ')}`);
 	const componentes = {};
 	for (const [nombre, ruta] of Object.entries(cfg.componentes ?? {})) {
@@ -125,14 +149,53 @@ export async function cargarProyecto(proyecto = process.cwd()) {
 		componentes,
 		render: {
 			crf: r.crf ?? 18,
-			gl: process.env.MORFEO_GL || process.env.REMOTION_GL || r.gl || 'swangle',
+			gl: process.env.MORFEO_GL || process.env.REMOTION_GL || r.gl || glPorDefecto(),
 			navegador: process.env.MORFEO_NAVEGADOR || r.navegador || null,
-			concurrencia: r.concurrencia ?? null,
+			concurrencia: r.concurrencia ?? null, // null = Morfeo elige según la máquina y el modo (ver render.mjs)
 			miniatura: r.miniatura ?? true,
 		},
 	};
 }
 
+/** Capas {tipo: 'personaje'} que piden un personaje (o una pose) que no está en el config. */
+function revisarPersonajes(x, personajes, err) {
+	if (Array.isArray(x)) return x.forEach((v) => revisarPersonajes(v, personajes, err));
+	if (!x || typeof x !== 'object') return;
+	if (x.tipo === 'personaje') {
+		const def = personajes[x.nombre];
+		if (!def) err(`el personaje "${x.nombre}" no existe. Defínelo en morfeo.config.mjs → personajes. Hay: ${Object.keys(personajes).join(', ') || 'ninguno'}`);
+		else {
+			const poses = Object.keys(def.poses ?? {});
+			for (const p of [x.pose, ...(x.poses ?? []).map((k) => k?.pose)].filter(Boolean))
+				if (!poses.includes(p)) err(`el personaje "${x.nombre}" no tiene la pose "${p}". Tiene: ${poses.join(', ')}`);
+		}
+	}
+	for (const v of Object.values(x)) if (v && typeof v === 'object') revisarPersonajes(v, personajes, err);
+}
+
+/** Fondos y capas {tipo: 'escenario'} con un nombre que no existe. */
+function revisarEscenarios(x, err) {
+	if (Array.isArray(x)) return x.forEach((v) => revisarEscenarios(v, err));
+	if (!x || typeof x !== 'object') return;
+	if (x.tipo === 'escenario' && !ESCENARIOS.includes(x.nombre)) err(`el escenario "${x.nombre}" no existe. Hay: ${ESCENARIOS.join(', ')}`);
+	if (x.tipo === 'modelo' && x.forma && !x.src && !FORMAS_3D.includes(x.forma)) err(`la forma 3D "${x.forma}" no existe. Hay: ${FORMAS_3D.join(', ')}`);
+	if (x.objeto && typeof x.objeto === 'string' && !FORMAS_3D.includes(x.objeto)) err(`el objeto 3D "${x.objeto}" no existe. Hay: ${FORMAS_3D.join(', ')}`);
+	for (const v of Object.values(x)) if (v && typeof v === 'object') revisarEscenarios(v, err);
+}
+
+const CAMPOS_ARCHIVO = new Set(['src', 'imagen']);
+/** Busca `src`/`imagen` que apunten a assets/ y avisa de los que no existen. */
+function revisarArchivos(x, assetsDir, err, ruta = '') {
+	if (Array.isArray(x)) return x.forEach((v, i) => revisarArchivos(v, assetsDir, err, `${ruta}[${i}]`));
+	if (!x || typeof x !== 'object') return;
+	for (const [k, v] of Object.entries(x)) {
+		if (CAMPOS_ARCHIVO.has(k) && typeof v === 'string' && !/^(https?:|data:)/.test(v)) {
+			const rel = v.replace(/^\.?\/?(assets\/)?/, '');
+			if (!fs.existsSync(path.join(assetsDir, rel))) err(`no existe assets/${rel} (lo pide ${ruta.replace(/^\./, '') || 'una capa'}.${k}). Ponlo en la carpeta assets/ o usa  generar: 'descripción'  para la IA`);
+		} else if (v && typeof v === 'object') revisarArchivos(v, assetsDir, err, `${ruta}.${k}`);
+	}
+}
+
 function validarCapas(capas, donde, err) {
 	if (!Array.isArray(capas)) return err(`${donde}: \`capas\` debe ser una lista`);
 	capas.forEach((c, i) => {
@@ -140,6 +203,10 @@ function validarCapas(capas, donde, err) {
 		if (!c || typeof c !== 'object') return err(`${d} debe ser un objeto`);
 		if (!TIPOS_CAPA.includes(c.tipo)) return err(`${d}: tipo "${c.tipo}" no existe. Opciones: ${TIPOS_CAPA.join(', ')}`);
 		if ((c.tipo === 'imagen' || c.tipo === 'video') && !c.src && !c.generar) err(`${d}: falta \`src\` (archivo en assets/) o \`generar\` (descripción para la IA)`);
+		if (c.tipo === 'recurso') {
+			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.capas) validarCapas(c.capas, d, err);
 		if (c.capa) validarCapas([c.capa], d, err);
 	});
@@ -178,7 +245,13 @@ function normalizarVoz(voz, ctx, err, profundidad = 0) {
 			if (!/\.npy$/i.test(abs)) err(`la voz ${ref} debe ser un archivo .npy (estilo de voz Kokoro, forma 510×1×256)`);
 			else if (!fs.existsSync(abs)) err(`no existe el archivo de voz ${ref}`);
 			out.push([abs, peso]);
-		} else out.push([ref, peso]);
+		} else {
+			if (!VOCES_KOKORO.includes(ref)) {
+				const alias = Object.keys(ctx.voces);
+				err(`la voz "${ref}" no existe. ¿Quisiste decir ${parecidas(ref, [...alias, ...VOCES_KOKORO]).map((x) => `"${x}"`).join(', ')}? En español: em_alex, ef_dora, em_santa`);
+			}
+			out.push([ref, peso]);
+		}
 	}
 	return out;
 }
@@ -211,7 +284,8 @@ function validarVideo(id, v, ctx) {
 	const scenes = v.scenes.map((s0, i) => {
 		const n = `escena ${i + 1}`;
 		if (!s0 || typeof s0 !== 'object') return err(`${n} debe ser un objeto`), s0;
-		const s = {...s0, type: s0.type ?? (s0.capas ? 'capas' : undefined)};
+		// sin `type`: escena de capas (con o sin capas: el fondo y los subtítulos mientras habla)
+		const s = {...s0, type: s0.type ?? 'capas'};
 		if (!permitidos.includes(s.type))
 			err(
 				TIPOS_CLASICOS.includes(s.type)
@@ -237,5 +311,9 @@ 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);
+	// 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);
+	revisarEscenarios({scenes, hud: v.hud, tema: v.tema}, err);
 	return {...v, estilo, voice, music: normalizarMusica(v.music, ctx, err), scenes};
 }

package/lib/diccionario.mjs

@@ -0,0 +1,129 @@
+// Diccionario temático: términos en español → búsquedas en inglés para las bibliotecas de recursos.
+// Sirve para {tipo: 'recurso', buscar: 'tubería'} y para que la IA elija ilustraciones según la temática.
+// Cada término puede tener varias búsquedas (de la más específica a la más general).
+// Si un término no está, se busca tal cual (y en inglés si viene en inglés).
+
+export const TEMAS = {
+	objetos: {
+		barril: ['barrel'], caja: ['box', 'crate'], bolsa: ['bag'], maleta: ['suitcase'], paraguas: ['umbrella'], sombrero: ['hat'], gorra: ['cap'],
+		lentes: ['glasses'], zapato: ['shoe'], camisa: ['shirt'], reloj_de_pulsera: ['watch'], anillo: ['ring'], bolso: ['handbag', 'bag'], cubeta: ['bucket'],
+		escoba: ['broom'], tijeras: ['scissors'], cuerda: ['rope'], cadena: ['chain'], iman: ['magnet'], brujula: ['compass'], mapa: ['map'], sobre: ['envelope'],
+		carta_correo: ['letter', 'envelope'], paquete: ['package', 'parcel', 'box'], etiqueta: ['tag', 'label'], campana: ['bell'], trompeta: ['trumpet'],
+		guitarra: ['guitar'], piano: ['piano'], tambor: ['drum'], pincel: ['paintbrush', 'brush'], pintura: ['paint'], cuadro: ['painting', 'picture frame'],
+		vela_aromatica: ['candle'], jarron: ['vase'], maceta: ['pot', 'plant pot'], tetera: ['teapot'], olla: ['pot', 'cooking pot'], sarten: ['pan', 'frying pan'],
+		cuchara: ['spoon'], tenedor: ['fork'], frasco: ['jar'], lata: ['can'], extintor: ['fire extinguisher'], botiquin: ['first aid kit'], escalera_mano: ['ladder'],
+		silla_ruedas: ['wheelchair'], muleta: ['crutch'], carrito: ['cart', 'shopping cart'], tienda_campana: ['tent'], fogata: ['campfire'], hacha: ['axe'],
+		arco: ['bow'], flecha: ['arrow'], bote_basura: ['trash can', 'bin'], periodico: ['newspaper'], revista: ['magazine'], boleto: ['ticket'], pasaporte: ['passport'],
+	},
+	hogar: {
+		casa: ['house', 'home'], cuarto: ['bedroom', 'room'], cama: ['bed'], sillon: ['sofa', 'couch', 'armchair'], sofa: ['sofa', 'couch'],
+		silla: ['chair'], mesa: ['table'], escritorio: ['desk'], lampara: ['lamp'], librero: ['bookcase', 'shelf'], refrigerador: ['fridge', 'refrigerator'],
+		estufa: ['stove', 'oven'], horno: ['oven'], lavabo: ['sink', 'bathroom sink'], fregadero: ['kitchen sink', 'sink'], inodoro: ['toilet'], banera: ['bathtub'],
+		regadera: ['shower'], espejo: ['mirror'], puerta: ['door'], ventana: ['window'], televisor: ['television', 'tv'], planta: ['plant', 'potted plant'],
+		alfombra: ['rug'], ropero: ['wardrobe', 'closet'], buro: ['nightstand'], cajon: ['drawer', 'cabinet'], lavadora: ['washer', 'washing machine'], microondas: ['microwave'], licuadora: ['blender'], ventilador: ['fan'], almohada: ['pillow'], cortina: ['curtain'], reloj: ['clock'], llave: ['key'], candado: ['padlock', 'lock'], cocina: ['kitchen'], bano: ['bathroom'],
+	},
+	construccion: {
+		tuberia: ['pipe', 'pipes'], tubo: ['pipe'], valvula: ['valve'], llave_de_agua: ['faucet', 'tap'], drenaje: ['drain', 'sewer'], manguera: ['hose'],
+		ladrillo: ['brick'], muro: ['wall', 'brick wall'], pared: ['wall'], viga: ['beam', 'girder'], columna: ['column', 'pillar'], escalera: ['ladder', 'stairs'],
+		andamio: ['scaffold'], cemento: ['cement', 'concrete'], concreto: ['concrete'], grua: ['crane'], excavadora: ['excavator', 'digger'], casco: ['helmet', 'hard hat'],
+		martillo: ['hammer'], taladro: ['drill'], llave_inglesa: ['wrench'], desarmador: ['screwdriver'], sierra: ['saw'], pala: ['shovel'], carretilla: ['wheelbarrow'],
+		cono: ['traffic cone', 'cone'], barrera: ['barrier'], tunel: ['tunnel'], puente: ['bridge'], tanque: ['tank'], cable: ['cable', 'wire'], tornillo: ['screw', 'bolt'],
+		molino: ['windmill', 'building mill', 'mill'], granja: ['farm', 'barn'], granero: ['barn'], pozo: ['well'], muelle: ['dock', 'pier'], mina: ['mine'], castillo_piedra: ['castle'],
+		herramienta: ['tool', 'toolbox'], caja_de_herramientas: ['toolbox'], valla: ['fence'], cerca: ['fence'],
+	},
+	ciudad: {
+		edificio: ['building', 'skyscraper'], rascacielos: ['skyscraper'], tienda: ['shop', 'store'], calle: ['road', 'street'], semaforo: ['traffic light'],
+		farola: ['street light', 'lamp post'], banca: ['bench'], parada: ['bus stop'], hidrante: ['fire hydrant', 'hydrant'], basura: ['trash can', 'garbage'],
+		buzon: ['mailbox'], hospital_edificio: ['hospital'], escuela_edificio: ['school'], iglesia: ['church'], mercado: ['market'], torre: ['tower'], fuente: ['fountain'], letrero: ['sign', 'billboard'], estacion: ['station'], metro: ['subway', 'train'],
+	},
+	transporte: {
+		auto: ['car'], carro: ['car'], coche: ['car'], camion: ['truck'], autobus: ['bus'], ambulancia: ['ambulance'], patrulla: ['police car', 'police'],
+		bomberos: ['firetruck', 'fire truck'], taxi: ['taxi'], moto: ['motorcycle', 'motorbike'], bicicleta: ['bicycle', 'bike'], tren: ['train'], avion: ['airplane', 'plane'],
+		barco: ['boat', 'ship'], cohete: ['rocket'], helicoptero: ['helicopter'], submarino: ['submarine'],
+	},
+	naturaleza: {
+		arbol: ['tree'], pino: ['pine tree', 'pine'], flor: ['flower'], pasto: ['grass'], roca: ['rock', 'stone'], piedra: ['stone', 'rock'], montana: ['mountain'],
+		hongo: ['mushroom'], hoja: ['leaf'], tronco: ['log', 'tree trunk'], arbusto: ['bush', 'shrub'], cactus: ['cactus'], nube: ['cloud'], sol: ['sun'], luna: ['moon'],
+		lluvia: ['rain'], rayo: ['lightning', 'thunder'], fuego: ['fire', 'campfire'], agua: ['water'], rio: ['river'], lago: ['lake'], isla: ['island'], volcan: ['volcano'],
+	},
+	oceano: {
+		ballena: ['whale'], tiburon: ['shark'], pez: ['fish'], pulpo: ['octopus'], medusa: ['jellyfish'], delfin: ['dolphin'], tortuga: ['turtle'], cangrejo: ['crab'],
+		concha: ['shell', 'seashell'], coral: ['coral'], ancla: ['anchor'], faro: ['lighthouse'], burbuja: ['bubble'],
+	},
+	animales: {
+		perro: ['dog'], gato: ['cat'], oso: ['bear'], leon: ['lion'], tigre: ['tiger'], elefante: ['elephant'], caballo: ['horse'], vaca: ['cow'], cerdo: ['pig'],
+		oveja: ['sheep'], gallina: ['chicken'], pato: ['duck'], conejo: ['rabbit', 'bunny'], raton: ['mouse'], mono: ['monkey'], pajaro: ['bird'], buho: ['owl'],
+		serpiente: ['snake'], arana: ['spider'], abeja: ['bee'], mariposa: ['butterfly'], dinosaurio: ['dinosaur'], zorro: ['fox'], lobo: ['wolf'], pinguino: ['penguin'],
+	},
+	comida: {
+		manzana: ['apple'], platano: ['banana'], pizza: ['pizza'], hamburguesa: ['burger', 'hamburger'], papas: ['fries', 'french fries'], pan: ['bread'],
+		queso: ['cheese'], huevo: ['egg'], pastel: ['cake'], galleta: ['cookie'], helado: ['ice cream'], cafe: ['coffee', 'coffee cup'], taza: ['cup', 'mug'],
+		dona: ['donut', 'doughnut'], tacos: ['taco'], sandia: ['watermelon'], uva: ['grapes'], fresa: ['strawberry'], zanahoria: ['carrot'], tomate: ['tomato'],
+		carne: ['meat', 'steak'], pollo: ['chicken leg', 'chicken'], pescado: ['fish'], sopa: ['soup', 'bowl'], ramen: ['ramen', 'noodles'], refresco: ['soda', 'can'],
+		botella: ['bottle'], vaso: ['glass'], plato: ['plate'], cubiertos: ['cutlery', 'fork'],
+	},
+	dinero: {
+		dinero: ['money', 'cash'], moneda: ['coin'], billete: ['banknote', 'money'], cartera: ['wallet'], banco: ['bank'], tarjeta: ['credit card'], alcancia: ['piggy bank'],
+		oro: ['gold', 'gold bar'], diamante: ['diamond', 'gem'], grafica: ['chart', 'graph'], cofre: ['chest', 'treasure chest'], tesoro: ['treasure'], caja_fuerte: ['safe'],
+	},
+	tecnologia: {
+		computadora: ['computer', 'laptop'], laptop: ['laptop'], celular: ['phone', 'smartphone'], telefono: ['phone'], robot: ['robot'], chip: ['chip', 'microchip'],
+		bateria: ['battery'], enchufe: ['plug', 'socket'], foco: ['light bulb', 'bulb'], camara: ['camera'], audifonos: ['headphones'], microfono: ['microphone'],
+		control: ['gamepad', 'controller'], consola: ['console', 'game console'], antena: ['antenna'], satelite: ['satellite'], dron: ['drone'], servidor: ['server'],
+		wifi: ['wifi'], nube_de_datos: ['cloud computing', 'cloud'], codigo: ['code'], teclado: ['keyboard'], raton_pc: ['computer mouse'],
+	},
+	espacio: {
+		planeta: ['planet'], estrella: ['star'], astronauta: ['astronaut'], ovni: ['ufo'], galaxia: ['galaxy'], meteorito: ['meteor', 'asteroid'], telescopio: ['telescope'],
+		nave: ['spaceship', 'spacecraft'], tierra: ['earth', 'globe'], marte: ['mars'], cometa: ['comet'],
+	},
+	cuerpo: {
+		corazon: ['heart'], cerebro: ['brain'], pulmon: ['lungs'], hueso: ['bone'], craneo: ['skull'], diente: ['tooth'], ojo: ['eye'], mano: ['hand'], musculo: ['muscle'],
+		sangre: ['blood', 'blood drop'], adn: ['dna'], virus: ['virus'], bacteria: ['bacteria'], pastilla: ['pill', 'medicine'], jeringa: ['syringe'], hospital: ['hospital'],
+		doctor: ['doctor'], termometro: ['thermometer'], estetoscopio: ['stethoscope'], cama_de_hospital: ['hospital bed'],
+	},
+	escuela: {
+		libro: ['book'], cuaderno: ['notebook'], lapiz: ['pencil'], pluma: ['pen'], mochila: ['backpack'], pizarron: ['blackboard', 'chalkboard'], regla: ['ruler'],
+		calculadora: ['calculator'], globo_terraqueo: ['globe'], microscopio: ['microscope'], matraz: ['flask', 'lab flask'], diploma: ['diploma'], birrete: ['graduation cap'],
+	},
+	deporte: {
+		balon: ['ball', 'football'], futbol: ['soccer ball', 'football'], basquetbol: ['basketball'], beisbol: ['baseball'], tenis: ['tennis'], trofeo: ['trophy'],
+		medalla: ['medal'], pesa: ['dumbbell'], bicicleta_estatica: ['exercise bike'], caminadora: ['treadmill'], silbato: ['whistle'], cronometro: ['stopwatch'],
+		golf: ['golf'], patineta: ['skateboard'], carrera: ['race', 'racing'],
+	},
+	misterio: {
+		fantasma: ['ghost'], calavera: ['skull'], tumba: ['grave', 'tombstone'], ataud: ['coffin'], vela: ['candle'], linterna: ['lantern', 'flashlight'], lupa: ['magnifying glass'],
+		huella: ['footprint', 'fingerprint'], cuchillo: ['knife'], arana_red: ['spider web'], murcielago: ['bat'], calabaza: ['pumpkin'], castillo: ['castle'], llave_antigua: ['old key', 'key'],
+	},
+	juegos: {
+		videojuego: ['video game', 'gamepad'], dado: ['dice'], carta: ['playing card', 'card'], ajedrez: ['chess'], moneda_juego: ['coin'], corona: ['crown'], espada: ['sword'],
+		escudo: ['shield'], cofre_juego: ['chest'], gema: ['gem', 'crystal'], pocion: ['potion'], bandera: ['flag'], meta: ['finish line', 'flag'],
+	},
+	fiestas: {
+		regalo: ['gift', 'present'], globo: ['balloon'], pastel_cumpleanos: ['birthday cake', 'cake'], arbol_navidad: ['christmas tree'], nieve: ['snow', 'snowman'],
+		munneco_nieve: ['snowman'], fuegos_artificiales: ['fireworks'], confeti: ['confetti'], mascara: ['mask'],
+	},
+};
+
+/** Quita acentos, ñ → n, minúsculas y espacios → _ (las claves del diccionario están así). */
+export const clave = (s) =>
+	String(s)
+		.normalize('NFD')
+		.replace(/[̀-ͯ]/g, '')
+		.toLowerCase()
+		.trim()
+		.replace(/\s+/g, '_');
+
+const INDICE = new Map();
+for (const [tema, terminos] of Object.entries(TEMAS)) for (const [t, q] of Object.entries(terminos)) if (!INDICE.has(t)) INDICE.set(t, {tema, termino: t, buscar: q});
+
+/** Búsquedas en inglés para un término en español (o el término tal cual si no está). */
+export function traducir(termino) {
+	const k = clave(termino);
+	if (INDICE.has(k)) return INDICE.get(k);
+	// plural simple: "tuberías" → "tuberia", "árboles" → "arbol"
+	for (const s of [k.replace(/es$/, ''), k.replace(/s$/, '')]) if (INDICE.has(s)) return INDICE.get(s);
+	return {tema: null, termino: k, buscar: [String(termino).trim()]};
+}
+
+/** Lista de temas con sus términos (para `morfeo recursos temas` y para la IA). */
+export const listaTemas = () => Object.fromEntries(Object.entries(TEMAS).map(([t, v]) => [t, Object.keys(v)]));

package/lib/guion.mjs

@@ -4,6 +4,7 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import {ErrorMorfeo, MUSICAS} from './config.mjs';
+import {listaTemas} from './diccionario.mjs';
 
 export const MODELO_GUION = 'claude-opus-5-5';
 export const TIPOS_IA = ['title', 'year', 'text', 'icon', 'compare', 'card', 'dialog'];
@@ -13,14 +14,18 @@ export const ICONOS = [
 ];
 const COLORES = {blanco: '#FFFFFF', amarillo: '#FFD400', rojo: '#FF4050', verde: '#5ADC6E', cian: '#50DCFF'};
 
-export const slug = (s) =>
-	s
+/** id corto para el archivo: sin acentos, en minúsculas, hasta ~38 letras y sin cortar palabras. */
+export const slug = (s) => {
+	const base = s
 		.normalize('NFD')
-		.replace(/[̀-ͯ]/g, '')
+		.replace(/[\u0300-\u036f]/g, '')
 		.toLowerCase()
 		.replace(/[^a-z0-9]+/g, '-')
-		.replace(/^-+|-+$/g, '')
-		.slice(0, 40) || 'video';
+		.replace(/^-+|-+$/g, '');
+	if (base.length <= 38) return base || 'video';
+	const corto = base.slice(0, 39);
+	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.
 Escribes en el idioma que se te pida, con frases cortas, naturales y fáciles de decir en voz alta.
@@ -83,6 +88,9 @@ export async function esquema() {
 	});
 }
 
+// objetos 3D del catálogo de Morfeo (remotion/motor/objetos3d.tsx)
+const OBJETOS = ['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'];
+
 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.
@@ -95,11 +103,19 @@ Tipos de escena:
 - dato: un número que cuenta hasta "valor" (con "prefijo"/"sufijo", p. ej. sufijo " m"), "texto" corto debajo. "curva": "exponencial" si crece muchísimo.
 - lista: tarjeta con "titulo" y 2-4 "items"; cada item se palomea cuando la voz dice su palabra "check".
 - comparar: "a" contra "b" (textos cortos); "at" es la palabra de "say" en la que aparece "b".
-- capas: una ilustración. Usa "emoji" (un emoji grande que represente la idea) o, si se pide arte, "imagen_ia" (descripción breve de UN objeto o personaje aislado),
+- capas: una ilustración, en este orden de preferencia:
+  1. "recurso": un objeto concreto de la biblioteca (palabra del diccionario de abajo, según la temática del video), con "recurso_estilo"
+     ("3d" low-poly, "realista" o "2d"); usa el mismo estilo en todo el video.
+  2. "objeto": un objeto 3D simbólico del catálogo (corazón, trofeo, cohete...).
+  3. "imagen_ia" si se pide arte (descripción breve de UN objeto o personaje aislado).
+  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, emoji}). Úsala al final en series o historias.
+- 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.
 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 incluyas la escena final de "sígueme": morfeo la agrega sola.
+
+Diccionario de recursos por tema (usa estas palabras en "recurso"):
+${Object.entries(listaTemas()).map(([t, v]) => `- ${t}: ${v.join(', ')}`).join('\n')}`;
 
 export async function esquemaMotor() {
 	const {z} = await import('zod');
@@ -119,12 +135,15 @@ export async function esquemaMotor() {
 		a: z.string().nullable(),
 		b: z.string().nullable(),
 		at: z.string().nullable(),
+		recurso: z.string().nullable(),
+		recurso_estilo: z.enum(['3d', 'realista', '2d']).nullable(),
+		objeto: z.enum(OBJETOS).nullable(),
 		emoji: z.string().nullable(),
 		imagen_ia: z.string().nullable(),
 		chip: z.string().nullable(),
 		en: z.string().nullable(),
 		pregunta: z.string().nullable(),
-		opciones: z.array(z.object({texto: z.string(), sub: z.string(), emoji: z.string()})).nullable(),
+		opciones: z.array(z.object({texto: z.string(), sub: z.string(), objeto: z.enum(OBJETOS).nullable(), emoji: z.string().nullable()})).nullable(),
 	});
 	return z.object({id: z.string(), title: z.string(), music: z.enum(MUSICAS), scenes: z.array(escena)});
 }
@@ -156,12 +175,15 @@ function aEscenaMotor(e, conImagenes) {
 			break;
 		case 'eleccion':
 			si('pregunta', e.pregunta);
-			out.opciones = (e.opciones ?? []).slice(0, 3);
+			out.opciones = (e.opciones ?? []).slice(0, 3).map(({texto, sub, objeto, emoji}) => ({texto, sub, ...(objeto ? {objeto} : emoji ? {emoji} : {})}));
 			break;
 		case 'capas': {
 			const capas = [];
-			if (e.imagen_ia && conImagenes) capas.push({tipo: 'imagen', generar: e.imagen_ia, ancho: 640, x: 540, y: 1000, entrada: 'escala', flotar: true});
-			else capas.push({tipo: 'emoji', texto: e.emoji || '✨', tam: 420, x: 540, y: 1000, entrada: 'rebote', flotar: 16});
+			// recurso de la biblioteca > objeto 3D > imagen con IA > emoji (último recurso)
+			if (e.recurso) capas.push({tipo: 'recurso', buscar: e.recurso, estilo: e.recurso_estilo ?? '3d', x: 540, y: 1000, entrada: 'rebote', flotar: 10});
+			else if (e.objeto) capas.push({tipo: 'modelo', forma: e.objeto, ancho: 680, alto: 680, x: 540, y: 1000, girar3d: [0, 40, 0], entrada: 'rebote', flotar: 12});
+			else if (e.imagen_ia && conImagenes) capas.push({tipo: 'imagen', generar: e.imagen_ia, ancho: 640, x: 540, y: 1000, entrada: 'escala', flotar: true});
+			else capas.push({tipo: 'modelo', forma: 'estrella', ancho: 600, alto: 600, x: 540, y: 1000, girar3d: [0, 40, 0], entrada: 'rebote'});
 			if (e.chip) capas.push({tipo: 'chip', texto: e.chip, x: 760, y: 1280, en: e.en ?? 'fin-0.5', entrada: 'rebote', sonido: 'pop'});
 			out.capas = capas;
 			break;