morfeo 0.6.3 → 0.6.5

package/README.md

@@ -21,7 +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.
+- **Objetos 2D y 3D:** una biblioteca con diccionario temático en español (`{tipo: 'recurso', buscar: 'tubería', estilo: '3d'}`) que busca en Kenney, Quaternius, KayKit, 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/index.d.ts

@@ -27,7 +27,9 @@ interface EscenaBase {
 export type Estilo = 'datos-curiosos' | 'explicativo' | 'documental' | 'ilustrado' | 'historia' | 'mesa' | 'serie' | 'infografia' | '3d' | 'maqueta' | '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';
+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'
+	| 'valvula' | 'grifo' | 'tinaco' | 'calentador' | 'bomba' | 'alcantarilla' | 'codo' | 'interruptor' | 'enchufe' | 'tablero' | 'medidor' | 'transformador' | 'poste' | 'bateria' | 'turbina' | 'torre_electrica' | 'aire' | 'chip' | 'placa' | 'resistor' | 'capacitor' | 'led' | 'disco_duro' | 'tarjeta_grafica' | 'disipador' | 'ram' | 'router' | 'servidor' | 'fuente_poder' | 'engrane' | 'tornillo' | 'tuerca' | 'motor' | 'resorte' | 'piston'
+	| 'atomo' | 'molecula' | 'adn' | 'celula' | 'virus' | 'cerebro' | 'neurona' | 'pulmon' | 'ojo' | 'diente' | 'hueso' | 'jeringa' | 'matraz' | 'telescopio' | 'iman' | 'sol' | 'tierra' | 'volcan' | 'tornado' | 'iceberg' | 'agujero_negro' | 'disco' | 'usb' | 'tarjeta_sd' | 'cable_hdmi' | 'microfono' | 'visor_vr' | 'cargador' | 'dron' | 'tanque_gas' | 'calentador_solar' | 'termostato' | 'detector_humo' | 'camara_seguridad' | 'antena_celular' | 'presa' | 'torre_enfriamiento' | 'ascensor' | 'fusible' | 'fibra_optica' | 'buzon' | 'autobus' | 'helicoptero' | 'submarino' | 'bicicleta' | 'lapiz' | 'regla' | 'dado' | 'ancla' | 'paraguas';
 
 /** Momento: segundos desde que empieza la escena, una palabra de `say` ("orcas"), "voz", "fin", o "palabra+0.3". */
 export type Momento = number | string;

package/lib/config.mjs

@@ -30,7 +30,9 @@ export const ESTILOS = ['datos-curiosos', 'explicativo', 'documental', 'ilustrad
 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', 'taller', 'oficina', 'tienda', 'calle'];
 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 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',
+	'valvula', 'grifo', 'tinaco', 'calentador', 'bomba', 'alcantarilla', 'codo', 'interruptor', 'enchufe', 'tablero', 'medidor', 'transformador', 'poste', 'bateria', 'turbina', 'torre_electrica', 'aire', 'chip', 'placa', 'resistor', 'capacitor', 'led', 'disco_duro', 'tarjeta_grafica', 'disipador', 'ram', 'router', 'servidor', 'fuente_poder', 'engrane', 'tornillo', 'tuerca', 'motor', 'resorte', 'piston',
+	'atomo', 'molecula', 'adn', 'celula', 'virus', 'cerebro', 'neurona', 'pulmon', 'ojo', 'diente', 'hueso', 'jeringa', 'matraz', 'telescopio', 'iman', 'sol', 'tierra', 'volcan', 'tornado', 'iceberg', 'agujero_negro', 'disco', 'usb', 'tarjeta_sd', 'cable_hdmi', 'microfono', 'visor_vr', 'cargador', 'dron', 'tanque_gas', 'calentador_solar', 'termostato', 'detector_humo', 'camara_seguridad', 'antena_celular', 'presa', 'torre_enfriamiento', 'ascensor', 'fusible', 'fibra_optica', 'buzon', 'autobus', 'helicoptero', 'submarino', 'bicicleta', 'lapiz', 'regla', 'dado', 'ancla', 'paraguas'];
 export const PROVEEDORES_VOZ = ['kokoro', 'elevenlabs', 'openai'];
 export const MUSICAS = ['lofi', 'lofi2', 'chillpop', 'synth', 'house', 'ballad', 'trap'];
 

package/lib/diccionario.mjs

@@ -13,14 +13,14 @@ export const TEMAS = {
 		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'],
+		arco: ['bow'], flecha: ['arrow'], bote_basura: ['trashcan', 'dumpster', 'trash can'], bote_de_basura: ['trashcan', 'dumpster'], 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', 'monitor'], television: ['television', 'tv', 'monitor'], tele: ['television', 'tv', 'monitor'], tv: ['tv', 'television', 'monitor'], 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'],
+		alfombra: ['rug', 'carpet'], chimenea: ['fireplace'], ropero: ['wardrobe', 'closet'], buro: ['nightstand'], cajon: ['drawer', 'cabinet'], lavadora: ['washer', 'washing machine'], microondas: ['microwave'], licuadora: ['blender'], ventilador: ['fan'], ventilador_de_techo: ['ceiling fan'], generador: ['generator'], bocina: ['speaker'], boton: ['button'], satelite_antena: ['satellite dish'], 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'],
@@ -29,17 +29,19 @@ export const TEMAS = {
 		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'],
+		fabrica: ['factory machine', 'machine', 'factory'], maquina: ['machine'], banda_transportadora: ['conveyor'], brazo_robotico: ['robot arm'], palanca: ['lever'], tolva: ['hopper'], escaner: ['scanner'], pasarela: ['catwalk'],
+		chimenea_industrial: ['chimney'], canaleta: ['gutter'], contenedor: ['container', 'cargo container'], carguero: ['ship cargo'], boya: ['buoy'], via: ['railroad'], riel: ['railroad', 'rail'], vagon: ['train carriage', 'wagon'], locomotora: ['locomotive', 'train'],
 		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'],
+		farola: ['street light', 'lamp post'], banca: ['bench'], parada: ['bus stop'], hidrante: ['fire hydrant', 'hydrant'], basura: ['trashcan', 'dumpster', 'garbage'], camion_de_basura: ['garbage truck'],
 		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'],
+		barco: ['boat', 'ship'], velero: ['sail ship', 'boat'], crucero: ['cruise ship'], balsa: ['raft'], bote: ['boat'], 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'],
@@ -51,9 +53,11 @@ export const TEMAS = {
 		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'],
+		perro: ['husky', 'shiba', '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'],
+		serpiente: ['snake'], arana: ['spider'], abeja: ['bee'], mariposa: ['butterfly'], dinosaurio: ['trex', 'dinosaur'], zorro: ['fox'], lobo: ['wolf'], pinguino: ['penguin'],
+		rana: ['frog'], rata: ['rat', 'mouse'], avispa: ['wasp', 'bee'], venado: ['deer', 'stag'], burro: ['donkey'], toro: ['bull'], alpaca: ['alpaca'], llama: ['alpaca'],
+		tiranosaurio: ['trex'], triceratops: ['triceratops'], velociraptor: ['velociraptor'], pirana: ['piranha'], pez_payaso: ['clownfish'], pez_globo: ['puffer'], pez_espada: ['swordfish'], atun: ['tuna'],
 	},
 	comida: {
 		manzana: ['apple'], platano: ['banana'], pizza: ['pizza'], hamburguesa: ['burger', 'hamburger'], papas: ['fries', 'french fries'], pan: ['bread'],
@@ -67,7 +71,7 @@ export const TEMAS = {
 		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'],
+		computadora: ['computer', 'laptop'], laptop: ['laptop'], celular: ['phone', 'smartphone'], telefono: ['phone'], robot: ['robot', 'mech'], radio: ['radio'], chip: ['chip', 'microchip'],
 		bateria: ['battery'], enchufe: ['plug', 'socket'], foco: ['light bulb', 'bulb'], camara: ['camera'], audifonos: ['headphones'], microfono: ['microphone'],
 		control: ['gamepad', 'controller'], consola: ['game console', 'console', 'gamepad'], consola_portatil: ['handheld console', 'nintendo switch', 'tablet', 'gamepad'],
 		tablet: ['tablet'], monitor: ['monitor', 'screen'], pantalla: ['screen', 'monitor'], disco: ['disc', 'cd', 'compact disc'], cd: ['disc', 'cd', 'compact disc'], dvd: ['disc', 'dvd'], memoria_usb: ['usb', 'flash drive'], antena: ['antenna'], satelite: ['satellite'], dron: ['drone'], servidor: ['server'],
@@ -75,7 +79,7 @@ export const TEMAS = {
 	},
 	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'],
+		nave: ['spaceship', 'spacecraft'], base_espacial: ['base module', 'base'], panel_solar: ['solar panel'], modulo_lunar: ['lander'], domo: ['dome'], radar: ['radar'], 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'],
@@ -99,6 +103,9 @@ export const TEMAS = {
 		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'],
 		cartucho: ['game cartridge', 'cartridge', 'sd card', 'floppy disk'], joystick: ['joystick', 'gamepad'], arcade: ['arcade machine', 'arcade', 'gamepad'], jefe_final: ['monster', 'dragon', 'skull'],
+		caballero: ['knight'], esqueleto: ['skeleton'], mago: ['mage', 'wizard'], barbaro: ['barbarian'], enemigo: ['enemy', 'monster'], mecha: ['mech', 'robot'], torreta: ['turret'], pistola: ['pistol', 'gun'], escopeta: ['shotgun'],
+		armadura: ['armor'], daga: ['dagger'], baston_magico: ['staff', 'wand'], varita: ['wand'], ballesta: ['crossbow'], pergamino: ['parchment', 'scroll'], caliz: ['chalice'], collar: ['necklace'], lingote: ['gold ingots', 'ingot'],
+		catapulta: ['catapult'], taberna: ['tavern'], herreria: ['blacksmith'], estandarte: ['banner'], antorcha: ['torch'], botin: ['lootbox', 'chest'],
 		vida: ['heart', 'life'], nivel: ['level', 'block', 'platform'], bloque: ['block', 'cube', 'brick'], llave_juego: ['key'], hongo: ['mushroom'], estrella_juego: ['star'],
 	},
 	fiestas: {
@@ -128,5 +135,58 @@ export function traducir(termino) {
 	return {tema: null, termino: k, buscar: [String(termino).trim()]};
 }
 
+/**
+ * Piezas de ingeniería hechas en código (remotion/motor/objetos-ingenieria.tsx): forma → términos que la piden.
+ * No están en ninguna biblioteca libre, así que el buscador las revisa antes que a las bibliotecas.
+ */
+export const PIEZAS = {
+	valvula: ['valvula', 'llave_de_paso', 'valvula_de_agua'], grifo: ['grifo', 'llave_de_agua', 'llave_del_agua'], tinaco: ['tinaco', 'tanque_de_agua'],
+	calentador: ['calentador', 'boiler', 'caldera', 'calentador_de_agua'], bomba: ['bomba_de_agua', 'bomba_hidraulica'], alcantarilla: ['alcantarilla', 'coladera', 'tapa_de_drenaje'],
+	codo: ['codo', 'codo_de_tuberia'], interruptor: ['interruptor', 'apagador', 'switch'], enchufe: ['enchufe', 'contacto', 'tomacorriente'],
+	tablero: ['tablero_electrico', 'centro_de_carga', 'caja_de_fusibles', 'pastillas', 'breaker'], medidor: ['medidor', 'medidor_de_luz'], transformador: ['transformador'],
+	poste: ['poste_de_luz', 'poste'], bateria: ['bateria', 'pila', 'pila_aa'], turbina: ['turbina', 'aerogenerador', 'turbina_eolica'], torre_electrica: ['torre_electrica', 'torre_de_alta_tension'],
+	aire: ['aire_acondicionado', 'minisplit', 'clima'], chip: ['chip', 'microchip', 'procesador', 'cpu'], placa: ['placa_madre', 'tarjeta_madre', 'placa_base', 'motherboard', 'placa'],
+	resistor: ['resistor', 'resistencia'], capacitor: ['capacitor', 'condensador'], led: ['led'], disco_duro: ['disco_duro', 'hdd'],
+	tarjeta_grafica: ['tarjeta_grafica', 'tarjeta_de_video', 'gpu'], disipador: ['disipador', 'ventilador_de_pc', 'cooler'], ram: ['ram', 'memoria_ram'], router: ['router', 'modem'],
+	servidor: ['servidor', 'rack'], fuente_poder: ['fuente_de_poder', 'fuente_de_alimentacion'], engrane: ['engrane', 'engranaje'], tornillo: ['tornillo'], tuerca: ['tuerca'],
+	motor: ['motor', 'motor_electrico'], resorte: ['resorte'], piston: ['piston'],
+	// ciencia y cuerpo
+	atomo: ['atomo'], molecula: ['molecula', 'molecula_de_agua'], adn: ['adn', 'dna', 'genes'], celula: ['celula'], virus: ['virus', 'bacteria', 'microbio'], cerebro: ['cerebro'],
+	neurona: ['neurona'], pulmon: ['pulmon', 'pulmones'], ojo: ['ojo'], diente: ['diente', 'muela'], hueso: ['hueso'], jeringa: ['jeringa', 'vacuna', 'inyeccion'],
+	matraz: ['matraz', 'quimica', 'tubo_de_ensayo'], telescopio: ['telescopio'], iman: ['iman'], sol: ['sol'], tierra: ['tierra', 'globo_terraqueo', 'mundo', 'planeta_tierra'],
+	volcan: ['volcan'], tornado: ['tornado', 'huracan'], iceberg: ['iceberg'], agujero_negro: ['agujero_negro'],
+	// consola y tecnología
+	disco: ['disco', 'cd', 'dvd', 'disco_de_juego', 'blu_ray'], usb: ['usb', 'memoria_usb'], tarjeta_sd: ['tarjeta_sd', 'memoria_sd', 'tarjeta_de_memoria'], cable_hdmi: ['cable_hdmi', 'hdmi'],
+	microfono: ['microfono'], visor_vr: ['visor_vr', 'realidad_virtual', 'lentes_vr', 'vr'], cargador: ['cargador'], dron: ['dron'],
+	// casa y ciudad
+	tanque_gas: ['tanque_de_gas', 'gas', 'tanque_estacionario'], calentador_solar: ['calentador_solar'], termostato: ['termostato'], detector_humo: ['detector_de_humo', 'alarma_de_humo'],
+	camara_seguridad: ['camara_de_seguridad', 'camara_de_vigilancia'], antena_celular: ['antena_celular', 'antena_de_telefonia', 'torre_celular'], presa: ['presa', 'represa'],
+	torre_enfriamiento: ['planta_nuclear', 'torre_de_enfriamiento', 'central_nuclear'], ascensor: ['ascensor', 'elevador'], fusible: ['fusible'], fibra_optica: ['fibra_optica'], buzon: ['buzon'],
+	// transporte
+	autobus: ['autobus', 'camion_de_pasajeros'], helicoptero: ['helicoptero'], submarino: ['submarino'], bicicleta: ['bicicleta', 'bici'],
+	// escuela y objetos
+	lapiz: ['lapiz'], regla: ['regla'], dado: ['dado'], ancla: ['ancla'], paraguas: ['paraguas', 'sombrilla'],
+};
+const PIEZA_DE = new Map();
+for (const [forma, terminos] of Object.entries(PIEZAS)) for (const t of terminos) PIEZA_DE.set(t, forma);
+
+/** Formas básicas de Morfeo (objetos3d.tsx) por término: se usan solo si ninguna biblioteca tiene el objeto. */
+const BASICAS = {corazon: ['corazon'], estrella: ['estrella'], rayo: ['rayo', 'electricidad'], diamante: ['diamante', 'gema'], trofeo: ['trofeo', 'copa'], cohete: ['cohete'], foco: ['foco', 'bombilla', 'foco_led'], reloj: ['reloj'],
+	planeta: ['planeta', 'marte', 'saturno'], arbol: ['arbol'], nube: ['nube'], regalo: ['regalo'], llave: ['llave'], candado: ['candado'], casa: ['casa'], libro: ['libro'], globo: ['globo'], medalla: ['medalla'], escudo: ['escudo'], tanque: ['cisterna']};
+const BASICA_DE = new Map();
+for (const [forma, terminos] of Object.entries(BASICAS)) for (const t of terminos) BASICA_DE.set(t, forma);
+export function basicaDe(termino) {
+	const k = clave(termino);
+	for (const s of [k, k.replace(/es$/, ''), k.replace(/s$/, '')]) if (BASICA_DE.has(s)) return BASICA_DE.get(s);
+	return null;
+}
+
+/** Forma hecha en código que corresponde a un término ("llave de agua" → "grifo"), o null. */
+export function piezaDe(termino) {
+	const k = clave(termino);
+	for (const s of [k, k.replace(/es$/, ''), k.replace(/s$/, '')]) if (PIEZA_DE.has(s)) return PIEZA_DE.get(s);
+	return null;
+}
+
 /** 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)]));
+export const listaTemas = () => ({...Object.fromEntries(Object.entries(TEMAS).map(([t, v]) => [t, Object.keys(v)])), ingenieria: Object.values(PIEZAS).map((v) => v[0])});

package/lib/recursos.mjs

@@ -14,7 +14,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import {ErrorMorfeo} from './config.mjs';
 import {HOME} from './entorno.mjs';
-import {traducir} from './diccionario.mjs';
+import {traducir, piezaDe, basicaDe} from './diccionario.mjs';
 
 export const BIBLIOTECA = path.join(HOME, 'biblioteca');
 const UA = {'user-agent': 'morfeo (https://github.com/UreckChan/morfeo)'};
@@ -136,6 +136,82 @@ async function bajarKenney(r) {
 	return {archivos: [local], principal: local, credito: `${r.nombre} · Kenney (kenney.nl) · CC0`};
 }
 
+// ---------------------------------------------------------------- Quaternius y KayKit (3D low-poly, CC0)
+// Las dos viven en GitHub: el índice sale del árbol de cada repositorio y los archivos de raw.githubusercontent.
+// Quaternius no tiene repositorio propio: se usa un espejo que conserva los paquetes y sus licencias (todas CC0).
+const KAYKIT = ['Character-Pack-Adventures', 'Character-Pack-Skeletons', 'City-Builder-Bits', 'Dungeon-Remastered', 'Furniture-Bits', 'Halloween-Bits', 'Medieval-Hexagon-Pack', 'Prototype-Bits', 'Restaurant-Bits', 'Space-Base-Bits'];
+const REPOS = {
+	quaternius: [{repo: 'trebeljahr/quaternius-showcase', rama: 'main', filtro: /^public\/glb\/.+\.glb$/i, kit: (ruta) => ruta.split('/')[2].replace(/_/g, ' ')}],
+	kaykit: KAYKIT.map((n) => ({repo: `KayKit-Game-Assets/KayKit-${n}-1.0`, rama: 'main', filtro: /\/gltf\/.+\.(gltf|glb)$/i, kit: () => n.replace(/-/g, ' ')})),
+};
+// Kenney completo (49 kits): el espejo de arriba solo trae 12. De este se toman los kits que aquel no tiene
+// (fábrica, ciudad industrial, edificios, trenes, estación espacial, caminos…), para no duplicar resultados.
+const KENNEY_YA = ['car', 'fantasy-town', 'food', 'furniture', 'graveyard', 'hexagon', 'holiday', 'nature', 'platformer', 'racing', 'minigolf', 'tower-defense'];
+REPOS['kenney-mas'] = [{repo: 'shorepine/kenney', rama: 'main', filtro: new RegExp(`^3d/(?!(${KENNEY_YA.join('|')})/)[^/]+/[^/]+\\.glb$`, 'i'), kit: (ruta) => ruta.split('/')[1].replace(/-/g, ' ')}];
+const CREDITO_REPO = {'kenney-mas': 'Kenney (kenney.nl)', quaternius: 'Quaternius (quaternius.com)', kaykit: 'KayKit · Kay Lousberg (kaylousberg.com)'};
+
+const repoIndice = (fuente) =>
+	indice(fuente, async () => {
+		const out = [];
+		let fallos = 0;
+		for (const r of REPOS[fuente]) {
+			try {
+				const arbol = await pedirJSON(`https://api.github.com/repos/${r.repo}/git/trees/${r.rama}?recursive=1`);
+				for (const n of arbol.tree) if (r.filtro.test(n.path)) out.push({repo: r.repo, rama: r.rama, ruta: n.path, nombre: n.path.split('/').pop().replace(/(\.gltf)?\.(glb|gltf)$/i, '').replace(/-transformed$/, ''), kit: r.kit(n.path)});
+			} catch {
+				fallos++; // un repositorio que falla no tira a los demás
+			}
+		}
+		if (!out.length) throw new ErrorMorfeo(`No pude leer el índice de ${fuente}`);
+		void fallos;
+		return out;
+	});
+
+async function buscarRepo(fuente, consultas) {
+	const idx = await repoIndice(fuente);
+	const out = [];
+	for (const [i, q] of consultas.entries())
+		for (const m of idx) {
+			// "bed_double_A" / "Tree_03": la letra o el número de variante no es el sustantivo
+			const nombre = palabras(m.nombre).filter((w) => w.length > 1);
+			// el paquete también cuenta, con menos peso: "dinosaur" trae todo el paquete de dinosaurios aunque se llamen "Trex"
+			const p = Math.max(puntaje(nombre, q), puntaje([...nombre, ...palabras(m.kit).filter((w) => !['pack', 'kit', 'bits', 'ultimate', 'modular'].includes(w))], q) - 6);
+			if (p > 0) out.push({fuente, id: `${m.repo}/${m.ruta}`, repo: m.repo, rama: m.rama, ruta: m.ruta, nombre: m.nombre, coleccion: m.kit, licencia: 'CC0', puntaje: p - i * 3, tipo: 'modelo'});
+		}
+	return out;
+}
+
+/** El JSON de un .glb (primer bloque del archivo), o null si no se puede leer. */
+function jsonDeGlb(archivo) {
+	try {
+		const b = fs.readFileSync(archivo);
+		if (b.readUInt32LE(0) !== 0x46546c67 || b.readUInt32LE(16) !== 0x4e4f534a) return null;
+		return JSON.parse(b.subarray(20, 20 + b.readUInt32LE(12)).toString('utf8'));
+	} catch {
+		return null;
+	}
+}
+
+async function bajarRepo(r) {
+	const cruda = (ruta) => `https://raw.githubusercontent.com/${r.repo}/${r.rama}/${ruta.split('/').map(encodeURIComponent).join('/')}`;
+	const local = (ruta) => path.join(BIBLIOTECA, r.fuente, r.repo.split('/')[1], ruta.replace(/[^A-Za-z0-9._/-]/g, '_'));
+	const principal = await bajar(cruda(r.ruta), local(r.ruta));
+	const archivos = [principal];
+	// un .gltf trae su geometría (.bin) y sus texturas en archivos aparte, con rutas relativas; un .glb también
+	// puede apuntar a una textura de fuera (los de Kenney comparten "Textures/colormap.png" por kit)
+	const g = /\.gltf$/i.test(r.ruta) ? JSON.parse(fs.readFileSync(principal, 'utf8')) : jsonDeGlb(principal);
+	if (g) {
+		const dir = path.posix.dirname(r.ruta);
+		for (const x of [...(g.buffers ?? []), ...(g.images ?? [])]) {
+			if (!x.uri || x.uri.startsWith('data:')) continue;
+			const rel = path.posix.normalize(path.posix.join(dir, decodeURIComponent(x.uri)));
+			if (rel.startsWith('..')) continue;
+			archivos.push(await bajar(cruda(rel), local(rel)));
+		}
+	}
+	return {archivos, principal, credito: `${r.nombre} · ${r.coleccion} · ${CREDITO_REPO[r.fuente]} · CC0`};
+}
+
 // ---------------------------------------------------------------- Poly Haven (3D realista, CC0)
 const polyhavenIndice = () => indice('polyhaven', () => pedirJSON('https://api.polyhaven.com/assets?t=models'));
 
@@ -211,7 +287,7 @@ async function bajarPolypizza(r) {
 
 // ---------------------------------------------------------------- búsqueda y descarga
 /** Orden de fuentes por estilo. */
-const FUENTES = {'3d': ['kenney', 'polypizza', 'polyhaven'], realista: ['polyhaven', 'polypizza', 'kenney'], '2d': ['iconify']};
+const FUENTES = {'3d': ['kenney', 'kenney-mas', 'quaternius', 'kaykit', 'polypizza', 'polyhaven'], realista: ['polyhaven', 'polypizza', 'kenney', 'kenney-mas', 'quaternius', 'kaykit'], '2d': ['iconify']};
 
 /**
  * Busca un término en las bibliotecas.
@@ -221,15 +297,25 @@ export async function buscarRecursos(termino, {estilo = '3d', variante, fuente}
 	const {buscar} = traducir(termino);
 	const fuentes = fuente ? [fuente] : FUENTES[estilo] ?? FUENTES['3d'];
 	const todos = [];
+	// piezas de ingeniería hechas en código (válvula, interruptor, placa madre…): van primero porque ninguna
+	// biblioteca las tiene y lo que devuelven en su lugar no sirve ("tornillo" → unas pinzas)
+	const pieza = estilo !== '2d' && (!fuente || fuente === 'morfeo') ? piezaDe(termino) : null;
+	if (pieza) todos.push({fuente: 'morfeo', id: pieza, nombre: pieza, coleccion: 'piezas de ingeniería', licencia: 'incluida', puntaje: 1000, tipo: 'forma'});
+	if (fuente === 'morfeo') return todos;
 	for (const f of fuentes) {
 		try {
-			const r = f === 'kenney' ? await buscarKenney(buscar) : f === 'polyhaven' ? await buscarPolyhaven(buscar) : f === 'polypizza' ? await buscarPolypizza(buscar) : await buscarIconify(buscar, variante);
+			const r = f === 'kenney' ? await buscarKenney(buscar) : REPOS[f] ? await buscarRepo(f, buscar) : f === 'polyhaven' ? await buscarPolyhaven(buscar) : f === 'polypizza' ? await buscarPolypizza(buscar) : await buscarIconify(buscar, variante);
 			// el orden de las fuentes pesa: la primera fuente con resultados buenos gana
 			todos.push(...r.map((x) => ({...x, puntaje: x.puntaje - fuentes.indexOf(f) * 6})));
 		} catch (e) {
 			if (fuente) throw e; // con fuente explícita, el error importa; si no, se prueba la siguiente
 		}
 	}
+	// formas básicas de siempre (corazón, foco, planeta…): solo si ninguna biblioteca tuvo el objeto
+	// (en `3d`, un modelo realista de Poly Haven no cuenta: un foco de vidrio oscuro no combina con lo demás)
+	const hayLowPoly = todos.some((r) => estilo === 'realista' || r.fuente !== 'polyhaven');
+	const basica = estilo !== '2d' && !fuente && !hayLowPoly ? basicaDe(termino) : null;
+	if (basica) todos.push({fuente: 'morfeo', id: basica, nombre: basica, coleccion: 'formas básicas', licencia: 'incluida', puntaje: 500, tipo: 'forma'});
 	const vistos = new Set();
 	return todos
 		.sort((a, b) => b.puntaje - a.puntaje)
@@ -239,6 +325,7 @@ export async function buscarRecursos(termino, {estilo = '3d', variante, fuente}
 /** Descarga un resultado. Devuelve {principal, archivos, base?, credito}. */
 export async function bajarRecurso(r, {color} = {}) {
 	if (r.fuente === 'kenney') return bajarKenney(r);
+	if (REPOS[r.fuente]) return bajarRepo(r);
 	if (r.fuente === 'polyhaven') return bajarPolyhaven(r);
 	if (r.fuente === 'polypizza') return bajarPolypizza(r);
 	return bajarIconify(r, color);
@@ -279,6 +366,12 @@ export async function resolverRecursos(video, assetsPublico, log = console.log)
 			return null;
 		}
 		const r = res[Math.min(n, res.length - 1)];
+		if (r.tipo === 'forma') {
+			log(`    recurso "${buscar}" → ${r.nombre} (pieza de Morfeo)`);
+			// quietas y en tres cuartos: varias son planas (placa, chip, tapa) y girando quedaban de canto; las que
+			// tienen movimiento propio (engrane, ventiladores, turbina) se siguen moviendo
+			return {tipo: 'modelo', forma: r.id, ancho: 620, alto: 620, girar3d: [0, 0, 0], rotacion: [6, -28, 0], reflejos: 0.5, luzAmbiente: 0.42, ...resto};
+		}
 		const d = await bajarRecurso(r, {color});
 		creditos.add(d.credito);
 		// se copia a public/assets/biblioteca/<fuente>/... conservando la carpeta (los glTF de Poly Haven traen texturas aparte)

package/lib/render.mjs

@@ -80,6 +80,47 @@ const conHuella = (config) => ({
 	resolve: {...config.resolve, modules: [...(config.resolve?.modules ?? ['node_modules']), path.join(PAQUETE, 'node_modules')]},
 });
 
+const PREFIJO_BUNDLE = 'remotion-webpack-bundle-';
+const esBundleTemporal = (dir) => path.basename(dir).startsWith(PREFIJO_BUNDLE) && fs.realpathSync(path.dirname(dir)) === fs.realpathSync(os.tmpdir());
+
+/** Bundles que dejó un render interrumpido (o versiones anteriores de Morfeo, que no los borraban): fuera si tienen más de un día. */
+function limpiarBundlesViejos() {
+	try {
+		const limite = Date.now() - 24 * 3600 * 1000;
+		for (const n of fs.readdirSync(os.tmpdir())) {
+			if (!n.startsWith(PREFIJO_BUNDLE)) continue;
+			const dir = path.join(os.tmpdir(), n);
+			if (fs.statSync(dir).mtimeMs < limite) fs.rmSync(dir, {recursive: true, force: true});
+		}
+	} catch {}
+}
+
+/**
+ * Webpack guarda un caché (~300 MB) por cada huella del motor y de la configuración, y no borra los anteriores:
+ * tras varias actualizaciones eran varios GB. Se quedan los dos más recientes.
+ */
+function podarCacheWebpack(raiz) {
+	try {
+		let dir = raiz;
+		while (!fs.existsSync(path.join(dir, 'node_modules', '.cache', 'webpack'))) {
+			const arriba = path.dirname(dir);
+			if (arriba === dir) return;
+			dir = arriba;
+		}
+		const base = path.join(dir, 'node_modules', '.cache', 'webpack');
+		for (const grupo of fs.readdirSync(base)) {
+			if (!grupo.startsWith('remotion-')) continue;
+			const g = path.join(base, grupo);
+			const viejos = fs
+				.readdirSync(g)
+				.map((n) => ({d: path.join(g, n), m: fs.statSync(path.join(g, n)).mtimeMs}))
+				.sort((x, y) => y.m - x.m)
+				.slice(2);
+			for (const v of viejos) fs.rmSync(v.d, {recursive: true, force: true});
+		}
+	} catch {}
+}
+
 /**
  * Entrada de Remotion. Sin componentes propios es la del paquete; con ellos, Morfeo escribe
  * .morfeo/entrada.tsx que los importa y los registra antes de arrancar.
@@ -294,13 +335,17 @@ export async function render({proyecto = process.cwd(), ids, todos = false, camb
 	// cuadros pedazos de texto de cuadros anteriores (rótulos o subtítulos fantasma)
 	const hechos = [];
 	const soltar = await tomarCandado(log);
+	let serveUrl;
 	try {
 		log('Empaquetando la animación...');
 		const {bundle} = await import('@remotion/bundler');
 		const {renderMedia, renderStill, selectComposition} = await import('@remotion/renderer');
 		const entrada = entradaDe(p);
 		const tBundle = Date.now();
-		const serveUrl = await bundle({entryPoint: entrada, publicDir: publico, rootDir: entrada === ENTRADA_REMOTION ? path.dirname(ENTRADA_REMOTION) : p.proyecto, webpackOverride: conHuella});
+		limpiarBundlesViejos();
+		const raizBundle = entrada === ENTRADA_REMOTION ? path.dirname(ENTRADA_REMOTION) : p.proyecto;
+		serveUrl = await bundle({entryPoint: entrada, publicDir: publico, rootDir: raizBundle, webpackOverride: conHuella});
+		podarCacheWebpack(raizBundle);
 		const segBundle = (Date.now() - tBundle) / 1000;
 		fs.mkdirSync(p.salida, {recursive: true});
 		const chromiumOptions = {gl: p.render.gl};
@@ -414,6 +459,8 @@ export async function render({proyecto = process.cwd(), ids, todos = false, camb
 			}
 		}
 	} finally {
+		// el bundle es una copia de la animación y de public/ (cientos de MB) en la carpeta temporal: Remotion no la borra
+		if (serveUrl && esBundleTemporal(serveUrl)) fs.rmSync(serveUrl, {recursive: true, force: true});
 		soltar();
 	}
 	if (previa || parcial) return hechos;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "morfeo",
-	"version": "0.6.3",
+	"version": "0.6.5",
 	"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/remotion/motor/modelo3d.tsx

@@ -11,6 +11,7 @@ import React, {useEffect, useLayoutEffect, useMemo, useState} from 'react';
 import {continueRender, delayRender} from 'remotion';
 import * as THREE from 'three';
 import {GLTFLoader} from 'three/examples/jsm/loaders/GLTFLoader.js';
+import {clone as clonarConEsqueleto} from 'three/examples/jsm/utils/SkeletonUtils.js';
 import {RoomEnvironment} from 'three/examples/jsm/environments/RoomEnvironment.js';
 import {clamp, easeOut} from '../estilo';
 import {cuando, recurso, type CtxEscena} from './util';
@@ -30,7 +31,15 @@ const cargar = (url: string) => cargarGltf(url).then((g) => g.scene);
  * hilos sueltos (el cable de un control, la cuerda de un globo), encuadra esa zona y no la caja completa.
  */
 function cajaPrincipal(obj: THREE.Object3D): THREE.Box3 {
+	obj.updateMatrixWorld(true);
 	const completa = new THREE.Box3().setFromObject(obj);
+	// con esqueleto (animales, personajes), los vértices crudos están en la pose de reposo y a otra escala que la
+	// que se dibuja: la caja buena es la que calcula three con los huesos
+	let conHuesos = false;
+	obj.traverse((o) => {
+		if ((o as THREE.SkinnedMesh).isSkinnedMesh) conHuesos = true;
+	});
+	if (conHuesos) return completa;
 	const pts: number[] = [];
 	const v = new THREE.Vector3();
 	obj.updateMatrixWorld(true);
@@ -67,7 +76,9 @@ const Glb: React.FC<{src: string; levantar?: boolean}> = ({src, levantar}) => {
 		cargar(url)
 			.then((s) => {
 				// centrado y escalado a ~2 unidades para que cualquier modelo quepa en el lienzo
-				const copia = s.clone(true);
+				// clone() a secas deja la malla atada a los huesos del original: el modelo se dibujaba sin centrar ni escalar
+				const copia = clonarConEsqueleto(s) as THREE.Group;
+				copia.updateMatrixWorld(true);
 				const caja = levantar ? cajaPrincipal(copia) : new THREE.Box3().setFromObject(copia);
 				const tam = caja.getSize(new THREE.Vector3());
 				const centro = caja.getCenter(new THREE.Vector3());
@@ -244,7 +255,7 @@ const ModeloEscena: React.FC<{c: Record<string, any>; ctx: CtxEscena}> = ({c, ct
 	useEffect(() => {
 		cargarGltf(url)
 			.then((gl) => {
-				const scene = gl.scene.clone(true);
+				const scene = clonarConEsqueleto(gl.scene) as THREE.Group;
 				let mixer: THREE.AnimationMixer | null = null;
 				if (c.animacion && gl.animations.length) {
 					mixer = new THREE.AnimationMixer(scene);