morfeo 0.1.0 → 0.1.2

package/lib/recursos.mjs

@@ -0,0 +1,299 @@
+// Biblioteca de recursos 2D y 3D: busca un término (en español) en bibliotecas abiertas, lo descarga
+// una sola vez a ~/.morfeo/biblioteca y lo convierte en una capa de imagen o de modelo.
+//
+//   {tipo: 'recurso', buscar: 'tubería', estilo: '3d'}          3D low-poly (Kenney; Poly Pizza si hay clave)
+//   {tipo: 'recurso', buscar: 'silla', estilo: 'realista'}      3D realista con texturas (Poly Haven)
+//   {tipo: 'recurso', buscar: 'cohete', estilo: '2d', variante: 'clay'}   ilustración 2D (Iconify)
+//
+// Fuentes y licencias:
+//   Kenney (espejo github.com/ETdoFresh/kenney.nl)  CC0 · ~1.400 modelos .glb
+//   Poly Haven (polyhaven.com)                      CC0 · ~500 modelos glTF con texturas · "Powered by Poly Haven"
+//   Iconify (iconify.design)                        MIT / Apache / CC0 / CC BY según el set · 200 mil+ íconos
+//   Poly Pizza (poly.pizza, opcional)               CC0 / CC-BY · 10 mil+ modelos · necesita POLYPIZZA_API_KEY
+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';
+
+export const BIBLIOTECA = path.join(HOME, 'biblioteca');
+const UA = {'user-agent': 'morfeo (https://github.com/UreckChan/morfeo)'};
+const UNA_SEMANA = 7 * 24 * 3600 * 1000;
+
+// Variantes 2D: cada una es un set (o grupo de sets) de Iconify con la misma línea gráfica.
+export const VARIANTES_2D = {
+	color: ['fluent-color', 'glyphs-poly', 'icon-park', 'marketeq', 'withicons-suite'],
+	clay: ['withicons-clay'],
+	glass: ['withicons-glass'],
+	kawaii: ['withicons-kawaii'],
+	retro: ['withicons-retro'],
+	pastel: ['withicons-pastel'],
+	sticker: ['withicons-sticker'],
+	skeuo: ['withicons-skeuo'],
+	plush: ['withicons-plush'],
+	anime: ['withicons-anime'],
+	luxe: ['withicons-luxe'],
+	chrome: ['withicons-chrome'],
+	liquid: ['withicons-liquid'],
+	bauhaus: ['withicons-bauhaus'],
+	brutal: ['withicons-brutal'],
+	gothic: ['withicons-gothic'],
+	linea: ['ph', 'mdi', 'iconoir', 'tabler', 'lucide'],
+};
+
+async function pedirJSON(url, opciones = {}) {
+	let res;
+	try {
+		res = await fetch(url, {...opciones, headers: {...UA, ...(opciones.headers ?? {})}});
+	} catch (e) {
+		throw new ErrorMorfeo(`No pude conectar con ${new URL(url).host}: ${e.message}`);
+	}
+	if (!res.ok) throw new ErrorMorfeo(`${new URL(url).host} respondió ${res.status} para ${url}`);
+	return res.json();
+}
+
+async function bajar(url, destino) {
+	if (fs.existsSync(destino) && fs.statSync(destino).size > 0) return destino;
+	const res = await fetch(url, {headers: UA});
+	if (!res.ok) throw new ErrorMorfeo(`No pude descargar ${url} (${res.status})`);
+	fs.mkdirSync(path.dirname(destino), {recursive: true});
+	fs.writeFileSync(destino + '.part', Buffer.from(await res.arrayBuffer()));
+	fs.renameSync(destino + '.part', destino);
+	return destino;
+}
+
+/** Índice en caché (se renueva cada semana; si no hay internet, usa el que haya). */
+async function indice(nombre, obtener) {
+	const f = path.join(BIBLIOTECA, `${nombre}.json`);
+	if (fs.existsSync(f) && Date.now() - fs.statSync(f).mtimeMs < UNA_SEMANA) return JSON.parse(fs.readFileSync(f, 'utf8'));
+	try {
+		const datos = await obtener();
+		fs.mkdirSync(BIBLIOTECA, {recursive: true});
+		fs.writeFileSync(f, JSON.stringify(datos));
+		return datos;
+	} catch (e) {
+		if (fs.existsSync(f)) return JSON.parse(fs.readFileSync(f, 'utf8'));
+		throw e;
+	}
+}
+
+/** "bathroomSinkSquare" / "Barrel_01" → ["bathroom", "sink", "square", "barrel"] */
+const palabras = (s) =>
+	String(s)
+		.replace(/([a-z])([A-Z])/g, '$1 $2')
+		.toLowerCase()
+		.split(/[^a-z]+/)
+		.filter(Boolean);
+
+/** Singular aproximado en inglés: "pipes" → "pipe", "boxes" → "box", "glass" se queda. */
+const singular = (w) => (w.length > 4 && /(ches|shes|xes|sses)$/.test(w) ? w.slice(0, -2) : w.length > 3 && /[^s]s$/.test(w) ? w.slice(0, -1) : w);
+
+/**
+ * Puntaje de un nombre contra una búsqueda en inglés. Todas las palabras buscadas deben aparecer
+ * (plural = singular); gana el nombre corto cuyo sustantivo principal (la última palabra) es lo buscado.
+ */
+function puntaje(nombrePalabras, consulta) {
+	const q = palabras(consulta).map(singular);
+	const n = nombrePalabras.map(singular);
+	if (!q.length || !n.length) return 0;
+	let p = 0;
+	for (const w of q) {
+		if (n.includes(w)) p += 10;
+		else if (w.length >= 4 && n.some((x) => x.length >= 4 && (x.startsWith(w) || w.startsWith(x)))) p += 4;
+		else return 0;
+	}
+	if (n[n.length - 1] === q[q.length - 1]) p += 6; // "modular pipe" > "pipe wrench" al buscar "pipe"
+	return p - n.length * 0.6;
+}
+
+// ---------------------------------------------------------------- Kenney (3D low-poly, CC0)
+const KENNEY_REPO = 'ETdoFresh/kenney.nl';
+const kenneyIndice = () =>
+	indice('kenney', async () => {
+		const arbol = await pedirJSON(`https://api.github.com/repos/${KENNEY_REPO}/git/trees/master?recursive=1`);
+		return arbol.tree
+			.filter((n) => /\.glb$/i.test(n.path))
+			.map((n) => ({ruta: n.path, nombre: n.path.split('/').pop().replace(/\.glb$/i, ''), kit: n.path.split('/')[0]}));
+	});
+
+async function buscarKenney(consultas) {
+	const idx = await kenneyIndice();
+	const out = [];
+	for (const [i, q] of consultas.entries())
+		for (const m of idx) {
+			const p = puntaje(palabras(m.nombre), q);
+			if (p > 0) out.push({fuente: 'kenney', id: m.ruta, nombre: m.nombre, coleccion: m.kit, licencia: 'CC0', puntaje: p - i * 3, tipo: 'modelo'});
+		}
+	return out;
+}
+
+async function bajarKenney(r) {
+	const url = `https://raw.githubusercontent.com/${KENNEY_REPO}/master/${r.id.split('/').map(encodeURIComponent).join('/')}`;
+	const local = path.join(BIBLIOTECA, 'kenney', r.id.replace(/[^A-Za-z0-9._/-]/g, '_'));
+	await bajar(url, local);
+	return {archivos: [local], principal: local, credito: `${r.nombre} · Kenney (kenney.nl) · CC0`};
+}
+
+// ---------------------------------------------------------------- Poly Haven (3D realista, CC0)
+const polyhavenIndice = () => indice('polyhaven', () => pedirJSON('https://api.polyhaven.com/assets?t=models'));
+
+async function buscarPolyhaven(consultas) {
+	const idx = await polyhavenIndice();
+	const out = [];
+	for (const [i, q] of consultas.entries())
+		for (const [id, v] of Object.entries(idx)) {
+			const nombre = palabras(`${v.name} ${id}`);
+			const extra = palabras([...(v.tags ?? []), ...(v.categories ?? [])].join(' '));
+			const p = Math.max(puntaje(nombre, q), puntaje([...nombre, ...extra], q) - 6);
+			if (p > 0) out.push({fuente: 'polyhaven', id, nombre: v.name, coleccion: (v.categories ?? [])[0] ?? '', licencia: 'CC0', puntaje: p - i * 3, tipo: 'modelo'});
+		}
+	return out;
+}
+
+async function bajarPolyhaven(r, resolucion = '1k') {
+	const f = await pedirJSON(`https://api.polyhaven.com/files/${encodeURIComponent(r.id)}`);
+	const g = f.gltf?.[resolucion] ?? f.gltf?.['1k'] ?? Object.values(f.gltf ?? {})[0];
+	if (!g?.gltf) throw new ErrorMorfeo(`Poly Haven no tiene glTF para ${r.id}`);
+	const dir = path.join(BIBLIOTECA, 'polyhaven', r.id);
+	const principal = await bajar(g.gltf.url, path.join(dir, path.basename(new URL(g.gltf.url).pathname)));
+	const archivos = [principal];
+	for (const [rel, info] of Object.entries(g.gltf.include ?? {})) archivos.push(await bajar(info.url, path.join(dir, rel)));
+	return {archivos, principal, base: dir, credito: `${r.nombre} · Poly Haven (polyhaven.com) · CC0`};
+}
+
+// ---------------------------------------------------------------- Iconify (2D)
+async function buscarIconify(consultas, variante = 'color') {
+	const sets = VARIANTES_2D[variante] ?? VARIANTES_2D.color;
+	const out = [];
+	for (const [i, q] of consultas.entries()) {
+		const r = await pedirJSON(`https://api.iconify.design/search?query=${encodeURIComponent(q)}&limit=48&prefixes=${sets.join(',')}`);
+		for (const [j, icono] of (r.icons ?? []).entries()) {
+			const [prefijo, nombre] = icono.split(':');
+			const col = r.collections?.[prefijo] ?? {};
+			const p = puntaje(palabras(nombre), q);
+			out.push({fuente: 'iconify', id: icono, nombre, coleccion: col.name ?? prefijo, licencia: col.license?.title ?? '?', puntaje: (p || 1) - i * 3 - j * 0.05, tipo: 'imagen', mono: !col.palette});
+		}
+	}
+	return out;
+}
+
+async function bajarIconify(r, color) {
+	const [prefijo, nombre] = r.id.split(':');
+	const params = r.mono ? `?height=512&color=${encodeURIComponent(color ?? '#ffffff')}` : '?height=512';
+	const local = path.join(BIBLIOTECA, 'iconify', prefijo, `${nombre}${r.mono ? '-' + (color ?? '#ffffff').replace('#', '') : ''}.svg`);
+	await bajar(`https://api.iconify.design/${prefijo}/${nombre}.svg${params}`, local);
+	return {archivos: [local], principal: local, credito: `${nombre} · ${r.coleccion} (Iconify) · ${r.licencia}`};
+}
+
+// ---------------------------------------------------------------- Poly Pizza (3D, opcional con clave)
+async function buscarPolypizza(consultas) {
+	const clave = process.env.POLYPIZZA_API_KEY;
+	if (!clave) return [];
+	const out = [];
+	for (const [i, q] of consultas.entries()) {
+		const r = await pedirJSON(`https://api.poly.pizza/v1/search/${encodeURIComponent(q)}?limit=24`, {headers: {'X-Auth-Token': clave}});
+		const lista = Array.isArray(r) ? r : r.results ?? r.Results ?? [];
+		for (const [j, m] of lista.entries())
+			if (m.Download)
+				out.push({fuente: 'polypizza', id: m.ID, nombre: m.Title, coleccion: m.Creator?.Username ?? '', licencia: m.Licence ?? m.License ?? '?', puntaje: 8 - i * 3 - j * 0.1, tipo: 'modelo', url: m.Download, autor: m.Creator?.Username});
+	}
+	return out;
+}
+
+async function bajarPolypizza(r) {
+	const local = path.join(BIBLIOTECA, 'polypizza', `${String(r.id).replace(/[^A-Za-z0-9_-]/g, '_')}.glb`);
+	await bajar(r.url, local);
+	const cc0 = /cc0|public/i.test(r.licencia);
+	return {archivos: [local], principal: local, credito: cc0 ? `${r.nombre} · Poly Pizza · CC0` : `"${r.nombre}" by ${r.autor} (poly.pizza) ${r.licencia}`};
+}
+
+// ---------------------------------------------------------------- búsqueda y descarga
+/** Orden de fuentes por estilo. */
+const FUENTES = {'3d': ['kenney', 'polypizza', 'polyhaven'], realista: ['polyhaven', 'polypizza', 'kenney'], '2d': ['iconify']};
+
+/**
+ * Busca un término en las bibliotecas.
+ * @returns {Promise<Array<{fuente, id, nombre, coleccion, licencia, tipo}>>} ordenados del mejor al peor
+ */
+export async function buscarRecursos(termino, {estilo = '3d', variante, fuente} = {}) {
+	const {buscar} = traducir(termino);
+	const fuentes = fuente ? [fuente] : FUENTES[estilo] ?? FUENTES['3d'];
+	const 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);
+			// 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
+		}
+	}
+	const vistos = new Set();
+	return todos
+		.sort((a, b) => b.puntaje - a.puntaje)
+		.filter((r) => (vistos.has(r.fuente + r.id) ? false : vistos.add(r.fuente + r.id)));
+}
+
+/** Descarga un resultado. Devuelve {principal, archivos, base?, credito}. */
+export async function bajarRecurso(r, {color} = {}) {
+	if (r.fuente === 'kenney') return bajarKenney(r);
+	if (r.fuente === 'polyhaven') return bajarPolyhaven(r);
+	if (r.fuente === 'polypizza') return bajarPolypizza(r);
+	return bajarIconify(r, color);
+}
+
+/**
+ * Cambia cada {tipo: 'recurso'} del video por una capa de modelo o imagen ya descargada en public/assets/biblioteca.
+ * Devuelve {video, creditos}.
+ */
+export async function resolverRecursos(video, assetsPublico, log = console.log) {
+	const creditos = new Set();
+	const resolver = async (c) => {
+		const {tipo, buscar, estilo = '3d', variante, fuente, indice: n = 0, color, ...resto} = c;
+		if (!buscar) throw new ErrorMorfeo('Una capa {tipo: "recurso"} necesita `buscar` (por ejemplo, buscar: "tubería")');
+		let res = await buscarRecursos(buscar, {estilo, variante, fuente});
+		// sin resultados en ese estilo: se intenta en los otros antes de fallar (3d → realista → 2d)
+		if (!res.length && !fuente)
+			for (const otro of ['3d', 'realista', '2d'].filter((e) => e !== estilo)) {
+				res = await buscarRecursos(buscar, {estilo: otro, variante});
+				if (res.length) {
+					log(`    "${buscar}" no está en ${estilo}; uso ${otro}`);
+					break;
+				}
+			}
+		if (!res.length)
+			throw new ErrorMorfeo(
+				`No encontré "${buscar}" (${estilo}${variante ? ' ' + variante : ''}). Prueba un sinónimo, escríbelo en inglés (buscar: 'barrel'), otro estilo ('2d', '3d', 'realista'), o mira  npx morfeo recursos buscar "${buscar}"`,
+			);
+		const r = res[Math.min(n, res.length - 1)];
+		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)
+		const base = d.base ?? path.dirname(d.principal);
+		for (const a of d.archivos) {
+			const destino = path.join(assetsPublico, 'biblioteca', path.relative(BIBLIOTECA, a));
+			if (!fs.existsSync(destino)) {
+				fs.mkdirSync(path.dirname(destino), {recursive: true});
+				fs.copyFileSync(a, destino);
+			}
+		}
+		const src = path.relative(path.join(assetsPublico), path.join(assetsPublico, 'biblioteca', path.relative(BIBLIOTECA, d.principal))).split(path.sep).join('/');
+		log(`    recurso "${buscar}" → ${r.nombre} (${r.fuente})`);
+		return r.tipo === 'modelo'
+			? // modelos externos: cámara más cerca y menos luz ambiente para que no se vean chicos ni deslavados
+			  {tipo: 'modelo', src, ancho: 620, alto: 620, girar3d: [0, 30, 0], distancia: 4.3, camaraY: 0.9, luzAmbiente: 0.25, reflejos: 0.45, luz: 1.6, ...resto}
+			: {tipo: 'imagen', src, ancho: 460, sombra: true, ...resto};
+		void base;
+	};
+	const recorrer = async (x) => {
+		if (Array.isArray(x)) return Promise.all(x.map(recorrer));
+		if (!x || typeof x !== 'object') return x;
+		if (x.tipo === 'recurso') return resolver(x);
+		const out = {};
+		for (const [k, v] of Object.entries(x)) out[k] = await recorrer(v);
+		return out;
+	};
+	const scenes = await recorrer(video.scenes);
+	const hud = await recorrer(video.hud ?? []);
+	return {video: {...video, scenes, hud}, creditos: [...creditos]};
+}

package/lib/render.mjs

@@ -1,6 +1,7 @@
 // Render: audio (Python) -> datos -> video (Remotion). También lista y Studio.
 import {spawn, spawnSync} from 'node:child_process';
 import crypto from 'node:crypto';
+import os from 'node:os';
 import fs from 'node:fs';
 import {createRequire} from 'node:module';
 import path from 'node:path';
@@ -9,6 +10,7 @@ import {ENTRADA_REMOTION, FUENTES, MODELOS, PY_DIR, modelosListos, pythonVenv, v
 import {asegurarNavegador} from './navegador.mjs';
 import {generarImagenes} from './imagenes.mjs';
 import {ponerPoses, prepararPersonajes} from './personajes.mjs';
+import {resolverRecursos} from './recursos.mjs';
 import {sintetizarVoces} from './voces.mjs';
 import {transcribir, whisperListo} from './whisper.mjs';
 
@@ -156,12 +158,16 @@ export async function preparar({proyecto = process.cwd(), ids, log = console.log
 	const datos = {};
 	const poses = await prepararPersonajes(p, path.join(publico, 'assets'), log);
 	const trabajos = path.join(p.trabajo, 'trabajos');
+	const creditos = {};
 	fs.mkdirSync(trabajos, {recursive: true});
 	for (const [i, id] of (ids ?? todos).entries()) {
 		const original = p.videos[id];
 		if (!original) throw new ErrorMorfeo(`No existe el video "${id}". Usa: npx morfeo lista`);
 		log(`[${i + 1}/${(ids ?? todos).length}] ${id}: audio...`);
-		const conImagenes = await generarImagenes(ponerPoses(original, poses), p.imagenes, path.join(p.trabajo, 'cache', 'imagenes'), path.join(publico, 'assets'), log);
+		const conRecursos = await resolverRecursos(ponerPoses(original, poses), path.join(publico, 'assets'), log);
+		creditos[id] = conRecursos.creditos;
+		guardarCreditos(p, id, conRecursos.creditos);
+		const conImagenes = await generarImagenes(conRecursos.video, p.imagenes, path.join(p.trabajo, 'cache', 'imagenes'), path.join(publico, 'assets'), log);
 		const video = await sintetizarVoces(id, conImagenes, path.join(p.trabajo, 'cache', 'voces'), log);
 		const job = path.join(trabajos, `${id}.json`);
 		const base = {id, video, indice: todos.indexOf(id), publico, modelos: MODELOS};
@@ -175,7 +181,7 @@ export async function preparar({proyecto = process.cwd(), ids, log = console.log
 		python(job);
 		datos[id] = datosDe(publico, id);
 	}
-	return {p, publico, marca, extras, datos};
+	return {p, publico, marca, extras, datos, creditos};
 }
 
 /**
@@ -205,37 +211,70 @@ export async function render({proyecto = process.cwd(), ids, todos = false, log
 	const chromiumOptions = {gl: p.render.gl};
 	const browserExecutable = p.render.navegador ?? (await asegurarNavegador(log));
 	const hechos = [];
+	// cuadros en paralelo: con GPU aguanta más; por software cada pestaña come mucha CPU y memoria
+	const nucleos = os.cpus().length;
+	const concurrenciaBase = p.render.concurrencia ?? (p.render.gl === 'angle' ? Math.max(2, Math.min(6, Math.floor(nucleos / 2))) : Math.max(1, Math.min(3, Math.floor(nucleos / 4))));
+	const sinTTY = !process.stdout.isTTY;
 	for (const [i, id] of lista.entries()) {
 		const t = Date.now();
 		const inputProps = {videos: {[id]: datos[id]}, marca, ...extras};
-		const composition = await selectComposition({serveUrl, id, inputProps, browserExecutable, chromiumOptions});
-		let ultimo = -1;
 		const mp4 = salidaDe(p, id);
-		await renderMedia({
-			serveUrl,
-			composition,
-			inputProps,
-			browserExecutable,
-			chromiumOptions,
-			codec: 'h264',
-			crf: p.render.crf,
-			audioBitrate: '192k',
-			imageFormat: 'jpeg',
-			jpegQuality: 92,
-			concurrency: p.render.concurrencia,
-			outputLocation: mp4,
-			onProgress: ({progress}) => {
-				alProgreso?.(id, progress);
-				const n = Math.floor(progress * 10);
-				if (n !== ultimo && process.stdout.isTTY) process.stdout.write(`\r[${i + 1}/${lista.length}] ${id}: video ${n * 10}%   `);
-				ultimo = n;
-			},
-		});
+		let gl = p.render.gl;
+		let concurrencia = 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++) {
+			const chromium = {gl};
+			let ultimo = -1;
+			try {
+				composition = await selectComposition({serveUrl, id, inputProps, browserExecutable, chromiumOptions: chromium});
+				await renderMedia({
+					serveUrl,
+					composition,
+					inputProps,
+					browserExecutable,
+					chromiumOptions: chromium,
+					codec: 'h264',
+					crf: p.render.crf,
+					audioBitrate: '192k',
+					imageFormat: 'jpeg',
+					jpegQuality: 92,
+					concurrency: concurrencia,
+					outputLocation: mp4,
+					onProgress: ({progress}) => {
+						alProgreso?.(id, progress);
+						// con terminal: cada 10 % en la misma línea; sin terminal (logs, CI): cada 25 %
+						const paso = sinTTY ? 4 : 10;
+						const n = Math.floor(progress * paso);
+						if (n !== ultimo) {
+							if (sinTTY) log(`[${i + 1}/${lista.length}] ${id}: video ${Math.round((n / paso) * 100)}%`);
+							else process.stdout.write(`\r[${i + 1}/${lista.length}] ${id}: video ${n * 10}%   `);
+						}
+						ultimo = n;
+					},
+				});
+				chromiumOptions.gl = gl;
+				break;
+			} catch (e) {
+				const msg = String(e?.message ?? e);
+				const truena = /crash|Session closed|Target closed|Protocol error|WebGL|context lost|browser has disconnected|Navigation failed/i.test(msg);
+				if (!truena || intento >= 3) throw e;
+				if (gl === 'angle' && /WebGL|context/i.test(msg)) gl = 'swangle';
+				else if (concurrencia > 1) concurrencia = Math.max(1, Math.floor(concurrencia / 2));
+				else if (gl === 'angle') gl = 'swangle';
+				log(`\n    el navegador falló; reintento con ${gl === 'angle' ? 'GPU' : 'CPU'} y ${concurrencia} cuadro(s) a la vez...`);
+			}
+		}
 		let jpg = null;
 		if (p.render.miniatura) {
-			// miniatura: el gancho ya completo
+			// miniatura: cuando la primera escena ya está completa (o en `miniaturaEn`), sin subtítulos
 			jpg = path.join(p.salida, `${id}.jpg`);
-			await renderStill({serveUrl, composition, inputProps, browserExecutable, chromiumOptions, frame: Math.min(36, composition.durationInFrames - 1), imageFormat: 'jpeg', jpegQuality: 92, output: jpg});
+			const d = datos[id];
+			const e0 = d.escenas[0];
+			const seg = p.videos[id].miniaturaEn ?? Math.min(e0.dur - 0.15, Math.max(1.4, e0.habla[1] * 0.85));
+			const frame = Math.max(0, Math.min(composition.durationInFrames - 1, Math.round(seg * composition.fps)));
+			const props = {...inputProps, miniatura: true};
+			await renderStill({serveUrl, composition: {...composition, props: {...composition.props, miniatura: true}}, inputProps: props, browserExecutable, chromiumOptions: {gl}, frame, imageFormat: 'jpeg', jpegQuality: 92, output: jpg});
 		}
 		const segundos = Math.round((Date.now() - t) / 1000);
 		if (process.stdout.isTTY) process.stdout.write('\r');
@@ -247,12 +286,33 @@ export async function render({proyecto = process.cwd(), ids, todos = false, log
 }
 
 /** <salida>/resumen.json: título, archivo y duración de cada video hecho (útil para publicar). */
+/** Créditos de los recursos de cada video (.morfeo/creditos/<id>.json), para el resumen y el archivo de créditos. */
+function guardarCreditos(p, id, lista) {
+	const dir = path.join(p.trabajo, 'creditos');
+	fs.mkdirSync(dir, {recursive: true});
+	fs.writeFileSync(path.join(dir, `${id}.json`), JSON.stringify(lista ?? []));
+}
+const creditosDe = (p, id) => {
+	try {
+		return JSON.parse(fs.readFileSync(path.join(p.trabajo, 'creditos', `${id}.json`), 'utf8'));
+	} catch {
+		return [];
+	}
+};
+
 function escribirResumen(p) {
 	const publico = path.join(p.trabajo, 'public');
 	const filas = Object.entries(p.videos)
 		.filter(([id]) => fs.existsSync(salidaDe(p, id)))
-		.map(([id, v]) => ({id, titulo: v.title ?? id, archivo: `${id}.mp4`, duracion: datosDe(publico, id)?.duracion ?? null, ...(v.meta ? {meta: v.meta} : {})}));
+		.map(([id, v]) => {
+			const c = creditosDe(p, id);
+			return {id, titulo: v.title ?? id, archivo: `${id}.mp4`, duracion: datosDe(publico, id)?.duracion ?? null, ...(c.length ? {creditos: c} : {}), ...(v.meta ? {meta: v.meta} : {})};
+		});
 	fs.writeFileSync(path.join(p.salida, 'resumen.json'), JSON.stringify(filas, null, '\t') + '\n');
+	// créditos para la descripción del video (las licencias CC BY piden mencionar al autor)
+	const conCreditos = filas.filter((f) => f.creditos?.length);
+	if (conCreditos.length)
+		fs.writeFileSync(path.join(p.salida, 'creditos.md'), ['# Créditos de recursos', '', ...conCreditos.flatMap((f) => [`## ${f.titulo}`, ...f.creditos.map((c) => `- ${c}`), ''])].join('\n'));
 }
 
 /** Abre Remotion Studio con los videos ya preparados (para verlos y ajustar en vivo). */

package/package.json

@@ -1,11 +1,11 @@
 {
 	"name": "morfeo",
-	"version": "0.1.0",
+	"version": "0.1.2",
 	"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://github.com/UreckChan/morfeo#readme",
+	"homepage": "https://ureckchan.github.io/morfeo/",
 	"repository": {
 		"type": "git",
 		"url": "git+https://github.com/UreckChan/morfeo.git"

package/plantilla/videos.mjs

@@ -10,6 +10,7 @@ const C = '#50DCFF'; // cian
 
 export default defineVideos({
 	cielo: {
+		estilo: 'datos-curiosos', // sus escenas (title, text, icon...) son del estilo clásico
 		title: '¿Por qué el cielo es azul? 🌤️ | Dato curioso',
 		voice: 'narrador', // alias de morfeo.config.mjs (o directo: 'em_alex')
 		music: 'lofi', // lofi, lofi2, chillpop, synth, house, ballad, trap, un archivo './musica/x.mp3' o false

package/remotion/Short.tsx

@@ -30,7 +30,7 @@ import {temaDe} from './motor/tema';
 import {VideoConAudio} from './motor/Video';
 import {loadFont} from '@remotion/fonts';
 
-export type PropsShort = {id: string; videos?: Record<string, Datos>; marca?: TipoMarca; guias?: boolean; fuentes?: {familia: string; url: string}[]; estilos?: Record<string, any>};
+export type PropsShort = {id: string; videos?: Record<string, Datos>; marca?: TipoMarca; guias?: boolean; miniatura?: boolean; fuentes?: {familia: string; url: string}[]; estilos?: Record<string, any>};
 
 const ADELANTO_GANCHO = 0.4; // el gancho arranca ya animado: el fotograma 0 nunca está vacío
 const CIERRE_BUCLE = 0.5; // al final se funde con el fotograma 0 para que el video se repita sin corte
@@ -220,7 +220,7 @@ const Guias: React.FC = () => (
 	</AbsoluteFill>
 );
 
-export const Fotograma: React.FC<{d: Datos; T: number; guias?: boolean}> = ({d, T, guias}) => {
+export const Fotograma: React.FC<{d: Datos; T: number; guias?: boolean; miniatura?: boolean}> = ({d, T, guias, miniatura}) => {
 	const n = d.escenas.length;
 	let si = n - 1;
 	for (let i = 0; i < n; i++) if (T < d.escenas[i].t0 + d.escenas[i].dur) {
@@ -238,7 +238,7 @@ export const Fotograma: React.FC<{d: Datos; T: number; guias?: boolean}> = ({d,
 				<Fondo T={T} d={d} e={e} t={t} salida={si === n - 1 ? 0 : clamp((t - (e.dur - 0.12)) / 0.12)} />
 				<CapaEscena e={e} si={si} t={t} d={d} ultima={si === n - 1} />
 				{remate && <Destello t={t} semilla={d.indice} />}
-				<Subtitulos T={T} d={d} />
+				{miniatura ? null : <Subtitulos T={T} d={d} />}
 			</AbsoluteFill>
 			{e.tipo !== 'cta' && <Marca />}
 			{guias && <Guias />}
@@ -246,7 +246,7 @@ export const Fotograma: React.FC<{d: Datos; T: number; guias?: boolean}> = ({d,
 	);
 };
 
-export const Short: React.FC<PropsShort> = ({id, videos, marca, guias, fuentes, estilos}) => {
+export const Short: React.FC<PropsShort> = ({id, videos, marca, guias, miniatura, fuentes, estilos}) => {
 	const frame = useCurrentFrame();
 	const [listo, setListo] = useState(false);
 	const [handle] = useState(() => delayRender('Cargando fuentes'));
@@ -259,13 +259,13 @@ export const Short: React.FC<PropsShort> = ({id, videos, marca, guias, fuentes,
 	const d = videos?.[id];
 	if (!d) throw new Error(`El video "${id}" no está preparado. Corre: npx morfeo render ${id}`);
 	if (!listo) return null;
-	if (d.estilo && d.estilo !== 'datos-curiosos') return <VideoConAudio d={d} frame={frame} marca={{...MARCA_VACIA, ...marca}} estilos={estilos} />;
+	if (d.estilo && d.estilo !== 'datos-curiosos') return <VideoConAudio d={d} frame={frame} marca={{...MARCA_VACIA, ...marca}} estilos={estilos} miniatura={miniatura} />;
 	const T = frame / FPS;
 	const kb = clamp((T - (d.duracion - CIERRE_BUCLE)) / CIERRE_BUCLE);
 	return (
 		<MarcaContexto.Provider value={{...MARCA_VACIA, ...marca}}>
 		<AbsoluteFill>
-			<Fotograma d={d} T={T} guias={guias} />
+			<Fotograma d={d} T={T} guias={guias} miniatura={miniatura} />
 			{kb > 0 && (
 				<AbsoluteFill style={{opacity: backOut(kb, 0)}}>
 					<Fotograma d={d} T={0} />

package/remotion/motor/Video.tsx

@@ -5,7 +5,7 @@ import {Avatar, MarcaContexto, useMarca} from '../piezas';
 import {FPS, W, clamp, easeIO, easeOut, lerp} from '../estilo';
 import type {Datos, Escena} from '../tipos';
 import {Capas} from './capas';
-import {FondoTema, Vineta} from './fondo';
+import {FondoTema, Textura, Vineta} from './fondo';
 import {capasDe} from './plantillas';
 import {Subtitulos} from './subtitulos';
 import {mezclar, temaDe, type Tema} from './tema';
@@ -30,7 +30,7 @@ const EscenaVista: React.FC<{e: Escena; t: number; tema: Tema; semilla: string}>
 	return (
 		<AbsoluteFill>
 			<AbsoluteFill style={{transform: `scale(${1 + (zoom - 1) * 0.5}) translate(${-cx * 0.3}px, ${-cy * 0.3}px)`}}>
-				<FondoTema tema={temaEsc} fondo={p.fondo} t={t + e.t0} semilla={semilla} />
+				<FondoTema tema={temaEsc} fondo={p.fondo} t={t + e.t0} semilla={semilla} ctx={ctx} />
 			</AbsoluteFill>
 			<AbsoluteFill style={{transform: `scale(${zoom}) translate(${-cx + temblor}px, ${-cy}px)`, transformOrigin: `${540 + (cam.origen?.[0] ?? 0)}px ${960 + (cam.origen?.[1] ?? 0)}px`}}>
 				<Capas capas={capasDe(e.tipo, p, temaEsc, marca)} ctx={ctx} />
@@ -66,7 +66,7 @@ const MarcaEsquina: React.FC<{tema: Tema}> = ({tema}) => {
 	);
 };
 
-export const VideoMotor: React.FC<{d: Datos; T: number; estilos?: Record<string, any>}> = ({d, T, estilos}) => {
+export const VideoMotor: React.FC<{d: Datos; T: number; estilos?: Record<string, any>; miniatura?: boolean}> = ({d, T, estilos, miniatura}) => {
 	const tema = temaDe(d.estilo, d.tema, estilos);
 	const n = d.escenas.length;
 	let si = d.escenas.findIndex((e) => T < e.t0 + e.dur);
@@ -100,19 +100,21 @@ export const VideoMotor: React.FC<{d: Datos; T: number; estilos?: Record<string,
 			<AbsoluteFill style={estiloActual}>
 				<EscenaVista e={e} t={t} tema={tema} semilla={semilla} />
 			</AbsoluteFill>
+			{/* la textura va quieta, fuera de la cámara: si se moviera con el zoom, cada cuadro sería distinto y el video pesaría 10 veces más */}
+			{tema.textura && tema.textura !== 'ninguna' ? <Textura tipo={tema.textura} /> : null}
 			<Vineta fuerza={tema.vineta ?? 0} />
 			{d.hud?.length ? <Hud d={d} T={T} tema={tema} /> : null}
-			{e.tipo !== 'cta' ? <Subtitulos tema={e.p.tema ? mezclar(tema, e.p.tema) : tema} palabras={e.palabras ?? []} t={t} dur={e.dur} /> : null}
+			{e.tipo !== 'cta' && !miniatura ? <Subtitulos tema={e.p.tema ? mezclar(tema, e.p.tema) : tema} palabras={e.palabras ?? []} t={t} dur={e.dur} /> : null}
 			{e.tipo !== 'cta' ? <MarcaEsquina tema={tema} /> : null}
 		</AbsoluteFill>
 	);
 };
 
 /** Componente raíz de un video del motor de capas (con su audio). */
-export const VideoConAudio: React.FC<{d: Datos; frame: number; marca: any; estilos?: Record<string, any>}> = ({d, frame, marca, estilos}) => (
+export const VideoConAudio: React.FC<{d: Datos; frame: number; marca: any; estilos?: Record<string, any>; miniatura?: boolean}> = ({d, frame, marca, estilos, miniatura}) => (
 	<MarcaContexto.Provider value={marca}>
 		<AbsoluteFill>
-			<VideoMotor d={d} T={frame / FPS} estilos={estilos} />
+			<VideoMotor d={d} T={frame / FPS} estilos={estilos} miniatura={miniatura} />
 			<Audio src={staticFile(d.audio)} />
 		</AbsoluteFill>
 	</MarcaContexto.Provider>