morfeo 0.3.0 → 0.3.3

package/README.md

@@ -1,6 +1,6 @@
 # Morfeo
 
-> **Documentación: [ureckchan.github.io/morfeo](https://ureckchan.github.io/morfeo/)** · Ejemplos: [github.com/UreckChan/morfeo](https://github.com/UreckChan/morfeo)
+> **Documentación: [morfeo-docs-two.vercel.app](https://morfeo-docs-two.vercel.app/)** · Ejemplos: [github.com/UreckChan/morfeo](https://github.com/UreckChan/morfeo) · Versiones: [historial](https://morfeo-docs-two.vercel.app/historial)
 
 Genera videos verticales animados (Shorts, TikTok, Reels) desde código: escribes las escenas y Morfeo agrega
 la voz, la música, los efectos de sonido, los subtítulos, las animaciones y la miniatura.

package/bases/2d/Mundo.tsx

@@ -0,0 +1,43 @@
+// Mundo 2D de __ID__ (2160×1920): un escenario del kit + personajes que reaccionan a la historia.
+// Recibe t (segundos del video), cuando('palabra'), escena (1, 2, 3...), tEscena, inicios y camara (para paralaje).
+// Piezas: Persona2D, Multitud, Globo · CiudadNoche, Cuarto, Campo, Calle, Oficina, Mar · Filtros, ConoLuz, Paralaje.
+import React from 'react';
+import {CiudadNoche, ConoLuz, Filtros, Globo, Persona2D, type Camara} from 'morfeo/kit';
+
+type Props = {t: number; cuando: (en: unknown) => number; escena?: number; tEscena?: number; inicios?: number[]; camara?: Camara};
+
+const ANCHO = 2160;
+const SUELO = 1500;
+
+export default function __COMPONENTE__({t, cuando, escena = 1, inicios = [0], camara}: Props) {
+	const ini = (n: number) => inicios[n - 1] ?? 1e9;
+	// la vecina entra corriendo en la escena 2 y se detiene junto al protagonista
+	const k = Math.max(0, Math.min(1, (t - ini(2)) / 1.6));
+	const vecinaX = 2050 - 520 * (1 - (1 - k) ** 2);
+	return (
+		<svg width={ANCHO} height={1920} viewBox={`0 0 ${ANCHO} 1920`} style={{overflow: 'visible', display: 'block'}}>
+			<Filtros />
+			<CiudadNoche t={t} camara={camara} ancho={ANCHO} suelo={SUELO} />
+			{/* protagonista: despierta asustado y señala cuando aparece la vecina */}
+			<Persona2D
+				x={900}
+				y={SUELO + 40}
+				alto={560}
+				t={t}
+				ropa="#2F6FE0"
+				peinado="corto"
+				expresion="sorpresa"
+				estados={[{en: ini(2), expresion: 'miedo', pose: 'señalar'}, {en: ini(4), expresion: 'triste', pose: 'parado'}]}
+				semilla={1}
+			/>
+			{/* la vecina con su linterna */}
+			{escena >= 2 ? (
+				<g>
+					<ConoLuz id="linterna" x={vecinaX - 150} y={SUELO - 300} ancho={420} largo={900} angulo={-70} fuerza={0.5} />
+					<Persona2D x={vecinaX} y={SUELO + 50} alto={520} t={t} ropa="#E86AA6" piel="#C98E66" pelo="#4A2C17" peinado="largo" pose={k < 1 ? 'caminar' : 'parado'} expresion="miedo" voltear semilla={2} />
+					<Globo x={vecinaX - 60} y={SUELO - 520} texto="¡No hay luz en ningún lado!" t={t} en={cuando('linterna')} hasta={ini(3)} lado="izq" ancho={420} />
+				</g>
+			) : null}
+		</svg>
+	);
+}

package/bases/2d/guion.mjs

@@ -0,0 +1,32 @@
+// __ID__ · base 2D (creada con `npx morfeo nuevo-video __ID__ --look 2d`). Ya renderiza: cámbiale el texto, el mundo
+// (escenas/__COMPONENTE__.tsx) y las tomas. Estructura (npx morfeo revisar __ID__): gancho → contexto → pregunta →
+// revelación → cierre que pide algo. `toma` = punto del mundo (2160×1920) que queda al centro y cuánto acerca.
+export default {
+	estilo: 'historia',
+	voice: 'narrador',
+	music: 'lofi',
+	title: 'Título para publicar 🌙',
+	descripcion: 'Una línea que resuma el video.',
+	tags: ['curiosidades', 'historias'],
+	tema: {fondo: {tipo: 'color', color: '#070A1F'}, particulas: {tipo: 'ninguna'}},
+	mundo: [{tipo: 'componente', nombre: '__COMPONENTE__', x: 0, y: 960, ancla: 'izquierda', entrada: 'ninguna'}],
+	scenes: [
+		// 1 · gancho: segunda persona, el sujeto ya en pantalla
+		{say: 'Imagina que te despiertas y toda tu ciudad está a oscuras.', claves: ['oscuras'], rotulo: '¿TODO *APAGADO*?', rotuloEn: 'ciudad',
+			toma: {x: 1080, y: 900, zoom: 1, a: {x: 900, y: 1150, zoom: 1.25}},
+			capas: [{tipo: 'accion', texto: 'Te despiertas', x: 540, y: 1480, en: 'despiertas'}]},
+		// 2 · contexto con nombre pegado al personaje
+		{say: 'Tu vecina Rosa sale corriendo con una linterna.', claves: ['linterna'],
+			toma: {x: 1460, y: 1150, zoom: 1.4},
+			capas: [{tipo: 'nombre', texto: 'Rosa', sub: 'tu vecina · 48 años', x: 540, y: 620, en: 'Rosa'}]},
+		// 3 · pregunta antes de revelar
+		{say: '¿Sabes cuánto aguanta una ciudad sin luz?', rotulo: '¿CUÁNTO *AGUANTA*?',
+			toma: {x: 1080, y: 760, zoom: 0.95, duracion: 0.9}},
+		// 4 · revelación con un número que cuenta
+		{say: 'Unas setenta y dos horas, antes de quedarse sin agua.', show: 'Unas 72 horas, antes de quedarse sin agua.', claves: ['agua'],
+			toma: {x: 900, y: 1120, zoom: 1.6},
+			capas: [{tipo: 'dato', valor: 72, de: 0, unidad: 'horas', x: 540, y: 600, en: '72', duracion: 1.4, tam: 96}]},
+		// 5 · cierre que pide una acción concreta
+		{type: 'cta', pide: 'comenta', palabra: 'LUZ', sub: 'si te ha pasado', say: 'Escribe luz si alguna vez te pasó.', toma: {x: 1080, y: 760, zoom: 1}},
+	],
+};

package/bases/3d/Mundo.tsx

@@ -0,0 +1,45 @@
+// Mundo 3D de __ID__: un solo Lienzo3D para todo el video (Chrome aguanta pocos contextos WebGL).
+// TOMAS = una toma de cámara por escena: pos (dónde está), mirar (a dónde mira) y `a` (a dónde se mueve en la escena).
+// En vertical el cuadro es angosto: para un plano general pon la cámara en diagonal, no de frente.
+// Piezas: Lienzo3D, Persona3D, Ciudad, Camino, Coche, Cuarto3D, Terreno, Tubo, Arbol, Casa, Mesa, Pila, Bloque, Objeto3D.
+import React from 'react';
+import {Arbol, Camino, Ciudad, Coche, Lienzo3D, Persona3D, type Toma3D} from 'morfeo/kit';
+
+type Props = {t: number; cuando: (en: unknown) => number; escena?: number; tEscena?: number; inicios?: number[]};
+
+const TOMAS: Toma3D[] = [
+	// 1 · gancho: la calle con el coche, la cámara baja hacia la gente
+	{pos: [-7, 5, 12], mirar: [0, 1, 0], a: {pos: [-5, 3.4, 9]}},
+	// 2 · a nivel de calle, la gente caminando
+	{pos: [3.5, 1.9, 7], mirar: [0, 1.2, 1.5], a: {pos: [2.5, 1.8, 6]}},
+	// 3 · la pregunta: primer plano del protagonista
+	{pos: [0.6, 1.9, 4.6], mirar: [0, 1.65, 2], fov: 32, a: {pos: [0.5, 1.85, 4]}},
+	// 4 · se abre: toda la calle desde arriba
+	{pos: [-9, 9, 13], mirar: [0, 0.5, -2], a: {pos: [-7, 8, 11]}},
+	// 5 · cierre
+	{pos: [0, 12, 16], mirar: [0, 4, -4]},
+];
+
+export default function __COMPONENTE__({t, escena = 1, tEscena = 0, inicios = [0]}: Props) {
+	const ini = (n: number) => inicios[n - 1] ?? 1e9;
+	// el coche cruza en la escena 1 y desaparece (se encoge) al final de esa escena
+	const kCoche = Math.max(0, Math.min(1, (t - ini(1)) / Math.max(0.5, ini(2) - ini(1))));
+	const escalaCoche = escena === 1 ? 1 - Math.max(0, kCoche - 0.75) * 4 : 0;
+	const caminan = escena >= 2;
+	return (
+		<Lienzo3D tomas={TOMAS} escena={escena} tEscena={tEscena} inicios={inicios} luz="dia" fondo="#BFE6FF" niebla={[30, 80]}>
+			<Ciudad t={t} pos={[0, 0, -3]} filas={4} columnas={6} />
+			<Camino largo={50} ancho={5} />
+			{escalaCoche > 0.01 ? <Coche pos={[-6 + kCoche * 10, 0, 1.4]} escala={escalaCoche} t={t} /> : null}
+			<Persona3D pos={[0, 0, 2]} t={t} expresion={escena === 3 ? 'pensativo' : escena >= 4 ? 'sorpresa' : 'neutral'} pose={caminan && escena !== 3 ? 'caminar' : 'parado'} ropa="#F07A3A" semilla={1} />
+			{caminan
+				? [-1.6, 1.4, -0.6, 2.2].map((x, i) => (
+						<Persona3D key={i} pos={[x, 0, -1 - i * 1.6 + ((t * 0.8) % 3)]} t={t} pose="caminar" ropa={['#2F6FE0', '#2FA36B', '#8B5BD6', '#E04A4A'][i]} pelo={['#2B1B12', '#E6C36B', '#4A2C17', '#1A1A1A'][i]} semilla={i + 2} />
+					))
+				: null}
+			{[-4.2, 4.2].map((x, i) => (
+				<Arbol key={i} pos={[x, 0, 2]} semilla={i} />
+			))}
+		</Lienzo3D>
+	);
+}

package/bases/3d/guion.mjs

@@ -0,0 +1,26 @@
+// __ID__ · base 3D (creada con `npx morfeo nuevo-video __ID__ --look 3d`). Ya renderiza: cámbiale el texto y el mundo
+// (escenas/__COMPONENTE__.tsx, donde están las tomas de cámara 3D, una por escena). Estructura (npx morfeo revisar __ID__):
+// gancho → contexto → pregunta → revelación → cierre que pide algo.
+export default {
+	estilo: '3d',
+	voice: 'narradora',
+	music: 'chillpop',
+	title: 'Título para publicar 🏙️',
+	descripcion: 'Una línea que resuma el video.',
+	tags: ['quepasariasi', 'curiosidades'],
+	mundo: [{tipo: 'componente', nombre: '__COMPONENTE__', x: 540, y: 960, entrada: 'ninguna'}],
+	scenes: [
+		// 1 · gancho: "¿y si...?" con el sujeto en pantalla
+		{say: '¿Y si todos los coches de tu ciudad desaparecieran mañana?', claves: ['coches'], rotulo: '¿SIN *COCHES*?', rotuloEn: 'desaparecieran'},
+		// 2 · contexto
+		{say: 'Las calles se llenarían de gente caminando.', claves: ['caminando'],
+			capas: [{tipo: 'accion', texto: 'Sales a caminar', x: 540, y: 560, en: 'gente'}]},
+		// 3 · pregunta antes de revelar
+		{say: '¿Cuánto tardarías en llegar al trabajo?', rotulo: '¿CUÁNTO *TARDAS*?'},
+		// 4 · revelación con un número que cuenta
+		{say: 'En promedio, tres veces más que hoy.', claves: ['tres'],
+			capas: [{tipo: 'dato', valor: 3, de: 1, unidad: 'veces más', x: 540, y: 560, en: 'tres', duracion: 1.2, tam: 96}]},
+		// 5 · cierre que pide una acción concreta
+		{type: 'cta', pide: 'comparte', a: 'el que va a todos lados en coche', say: 'Mándaselo al que va a todos lados en coche.'},
+	],
+};

package/bin/morfeo.mjs

@@ -13,12 +13,14 @@ Primeros pasos
   instalar              Prepara tu computadora: Python, voces, navegador y (opcional) Whisper
       --si                responde "sí" a todo        --whisper / --sin-whisper
   nuevo <carpeta>       Crea un proyecto de ejemplo listo para renderizar
+  nuevo-video <id>      Crea un video desde una base que ya renderiza (guion + mundo):  --look 2d | 3d
   doctor                Revisa qué está instalado y qué falta
 
 Videos
   lista                 Muestra los videos del proyecto y cuáles ya están hechos
   render [id...]        Genera los videos que faltan (o los que indiques)
       --todos             regenera todos
+      --solo-fallidos     reintenta solo los que fallaron en el último lote
       --gpu               usa la tarjeta de video (más rápido; si falla, quítalo)
   revisar [id...]       Revisa la estructura (gancho, ritmo, preguntas, cierre) con reglas de videos virales
   hoja <id>             Hoja de contacto (PNG con 15 cuadros) para revisar un video de un vistazo
@@ -51,7 +53,7 @@ function opciones(argv) {
 			const [k, v] = a.slice(2).split('=');
 			const clave = k.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
 			const sig = argv[i + 1];
-			const conValor = ['proyecto', 'desde', 'id', 'voz', 'duracion', 'idioma', 'estilo', 'tono', 'variante', 'fuente', 'musica', 'titulo', 'modelo', 'puerto', 'hasta', 'cols', 'filas'];
+			const conValor = ['proyecto', 'desde', 'id', 'voz', 'duracion', 'idioma', 'estilo', 'tono', 'variante', 'fuente', 'musica', 'titulo', 'modelo', 'puerto', 'hasta', 'cols', 'filas', 'look'];
 			if (v != null) op[clave] = v;
 			else if (conValor.includes(clave) && sig != null && !sig.startsWith('--')) op[clave] = argv[++i];
 			else op[clave] = true;
@@ -83,6 +85,18 @@ async function main() {
 		case 'nuevo':
 		case 'new':
 			return nuevo(pos[0], op);
+		case 'nuevo-video': {
+			const {nuevoVideo} = await import('../lib/nuevo-video.mjs');
+			const look = op.look === true || op.look == null ? '2d' : String(op.look).toLowerCase();
+			const r = nuevoVideo({proyecto, id: pos[0], look});
+			const rel = (f) => path.relative(process.cwd(), f);
+			console.log(`Listo (${look}):
+  ${rel(r.guion)}   el guion: texto, tomas, rótulos y capas
+  ${rel(r.escena)}   el mundo (${r.componente}, ya registrado en morfeo.config.mjs)
+
+Pruébalo:  npx morfeo render ${pos[0]}   y revísalo:  npx morfeo hoja ${pos[0]}`);
+			return;
+		}
 		case 'lista':
 		case 'ls': {
 			const {lista} = await import('../lib/render.mjs');
@@ -95,7 +109,7 @@ async function main() {
 		case 'render': {
 			if (op.gpu) process.env.MORFEO_GL = 'angle';
 			const {render} = await import('../lib/render.mjs');
-			await render({proyecto, ids: pos, todos: !!op.todos || pos[0] === 'todos'});
+			await render({proyecto, ids: pos, todos: !!op.todos || pos[0] === 'todos', soloFallidos: !!op.soloFallidos});
 			return;
 		}
 		case 'revisar': {
@@ -124,7 +138,9 @@ async function main() {
 			const p = await cargarProyecto(proyecto);
 			const num = (v) => (v == null || v === true ? undefined : Number(v));
 			for (const id of pos) {
-				const video = /\.(mp4|mov|webm)$/i.test(id) ? path.resolve(id) : path.join(p.salida, `${id}.mp4`);
+				const {salidaDe, ordenarSalida} = await import('../lib/salida.mjs');
+				ordenarSalida(p);
+				const video = /\.(mp4|mov|webm)$/i.test(id) ? path.resolve(id) : salidaDe(p, id);
 				console.log(hoja({video, cols: num(op.cols), filas: num(op.filas), desde: num(op.desde), hasta: num(op.hasta)}));
 			}
 			return;
@@ -222,7 +238,7 @@ async function guion(pos, op, proyecto) {
 	console.log(`Revísalo y edítalo si quieres; luego:  npx morfeo render ${id}`);
 }
 
-function nuevo(carpeta, op) {
+async function nuevo(carpeta, op) {
 	if (!carpeta) throw new ErrorMorfeo('Dime el nombre de la carpeta:  npx morfeo nuevo mi-canal');
 	const destino = path.resolve(carpeta);
 	if (fs.existsSync(destino) && fs.readdirSync(destino).length) throw new ErrorMorfeo(`La carpeta ${carpeta} ya existe y no está vacía.`);
@@ -234,6 +250,9 @@ function nuevo(carpeta, op) {
 	const nombre = path.basename(destino).toLowerCase().replace(/[^a-z0-9-_]/g, '-');
 	const pkg = path.join(destino, 'package.json');
 	fs.writeFileSync(pkg, fs.readFileSync(pkg, 'utf8').replace('__NOMBRE__', nombre).replace('__VERSION__', `^${VERSION}`));
+	// dos videos de ejemplo con mundo y la estructura completa (los mismos que `morfeo nuevo-video`)
+	const {nuevoVideo} = await import('../lib/nuevo-video.mjs');
+	for (const look of ['2d', '3d']) nuevoVideo({proyecto: destino, id: `ejemplo-${look}`, look});
 	console.log(`Proyecto creado en ${carpeta}/\n\nSiguientes pasos:\n  cd ${carpeta}\n  npm install\n  npx morfeo instalar     (solo la primera vez en esta computadora)\n  npx morfeo render`);
 }
 

package/index.d.ts

@@ -63,7 +63,8 @@ interface CapaBase {
 	sombra?: boolean | string;
 	z?: number;
 	/** Efecto de sonido al aparecer. */
-	sonido?: 'pop' | 'whoosh' | 'tick' | 'glitch' | 'ding';
+	/** Efecto al aparecer. Sin decirlo, suena según cómo entra (rebote, caer, deslizar) o qué es (sello, dato, chip…); `false` lo apaga. */
+	sonido?: 'pop' | 'whoosh' | 'tick' | 'glitch' | 'ding' | 'golpe' | false;
 	/** Cambios en el tiempo (ideal para el HUD): los números se animan desde el valor anterior. */
 	cambios?: ({en: Momento | {escena: number}} & Record<string, unknown>)[];
 }
@@ -93,7 +94,7 @@ export type Capa = CapaBase &
 		| {tipo: 'checklist'; items: (string | {texto: string; en?: Momento; pendiente?: boolean})[]; titulo?: string; tam?: number; color?: string; cada?: number}
 		| {tipo: 'mapa'; ruta?: [number, number][]; distancia?: string; ancho?: number; color?: string; fondo?: string; inclinar?: number; duracion?: number}
 		| {tipo: 'cursor'; a: [number, number]; clic?: Momento; duracion?: number; tam?: number; color?: string}
-		| {tipo: 'texto'; texto: string; tam?: number; color?: string; acento?: string; fuente?: 'titulo' | 'texto' | 'mono' | (string & {}); peso?: number; mayusculas?: boolean; contorno?: number; colorContorno?: string; fondo?: string; relleno?: string; radio?: number; maxAncho?: number | 'auto'; alinear?: 'center' | 'left' | 'right'; interlineado?: number; escribir?: boolean | number; subrayado?: boolean}
+		| {tipo: 'texto'; texto: string; tam?: number; color?: string; acento?: string; fuente?: 'titulo' | 'texto' | 'mono' | (string & {}); peso?: number; mayusculas?: boolean; contorno?: number; colorContorno?: string; fondo?: string; relleno?: string; radio?: number; maxAncho?: number | 'auto'; /** Achica la letra si no cabe (palabra más larga o más de `maxLineas` renglones). Por defecto sí. */ ajustar?: boolean; maxLineas?: number; alinear?: 'center' | 'left' | 'right'; interlineado?: number; escribir?: boolean | number; subrayado?: boolean}
 		| {tipo: 'contador'; de?: number; a: number; prefijo?: string; sufijo?: string; decimales?: number; miles?: string; decimal?: string; duracion?: number; curva?: 'suave' | 'lineal' | 'exponencial'; formato?: 'grande' | 'lcd' | 'chip'; tam?: number; color?: string; fondo?: string}
 		| {tipo: 'chip'; texto: string; unidad?: string; tam?: number; color?: string; fondo?: string; borde?: string}
 		| {tipo: 'etiqueta'; texto: string; tam?: number; color?: string}
@@ -246,6 +247,11 @@ export interface Video {
 	mundo?: Capa[];
 	/** Pastilla fija arriba para series: 'GYM CON CIENCIA · PARTE 5'. */
 	serie?: string;
+	/** Calidad de este video (ver `render.calidad`). */
+	calidad?: 'alta' | 'media' | 'ligera';
+	/** Para publicar: descripción y etiquetas (van a salida/<id>.txt junto con el título). */
+	descripcion?: string;
+	tags?: string[];
 	/** 'largo' = explicador de 90–130 s (lo asume el estilo maqueta): cambia las reglas de `morfeo revisar`. */
 	formato?: 'corto' | 'largo';
 	/** Ajustes del estilo para este video (colores, fondo, subtítulos...). */
@@ -301,7 +307,8 @@ export interface Config {
 	/** 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};
+	/** `calidad` alta = CRF 18, media = 21, ligera = 24 (sin decirlo: media con `mundo`, alta sin él). `crf` la fuerza. `consejos: false` apaga la revisión de estructura. */
+	render?: {crf?: number; calidad?: 'alta' | 'media' | 'ligera'; consejos?: boolean; gl?: 'swangle' | 'angle' | 'egl' | 'swiftshader' | 'vulkan'; navegador?: string | null; concurrencia?: number | null; miniatura?: boolean};
 }
 
 export declare function defineConfig(config: Config): Config;

package/lib/config.mjs

@@ -109,7 +109,7 @@ export async function cargarProyecto(proyecto = process.cwd()) {
 	const estilosPropios = cfg.estilos ?? {};
 	const estilo = cfg.estilo ?? 'datos-curiosos';
 	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 ?? {}};
+	const ctx = {proyecto, marca, voces: cfg.voces ?? {}, musicas: cfg.musicas ?? {}, errores, estilo, estilosPropios, assetsDir, personajes: cfg.personajes ?? {}, componentes: Object.keys(cfg.componentes ?? {})};
 	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 ?? {})) {
@@ -149,12 +149,17 @@ export async function cargarProyecto(proyecto = process.cwd()) {
 		personajes: cfg.personajes ?? {},
 		componentes,
 		render: {
-			crf: r.crf ?? 18,
+			crf: r.crf ?? null, // null = según `calidad`
+			// alta = CRF 18, media = 21, ligera = 24. Sin decirlo: media en videos con `mundo` (la cámara siempre se mueve
+			// y a CRF 18 pesan ~6 Mbps), alta en los demás. Cada video puede pedir la suya con `calidad`.
+			calidad: r.calidad ?? null,
 			gl: process.env.MORFEO_GL || process.env.REMOTION_GL || r.gl || glPorDefecto(),
 			navegador: process.env.MORFEO_NAVEGADOR || r.navegador || null,
 			concurrencia: Number(process.env.MORFEO_CONCURRENCIA) || r.concurrencia || null, // null = Morfeo elige según la máquina y el modo (ver render.mjs)
 			miniatura: r.miniatura ?? true,
 			consejos: r.consejos ?? true,
+			// 'titulo' (por defecto): salida/<Título del video>.mp4, listo para subir · 'id': salida/<id>.mp4
+			nombreArchivo: r.nombreArchivo ?? 'titulo',
 		},
 	};
 }
@@ -198,19 +203,31 @@ function revisarArchivos(x, assetsDir, err, ruta = '') {
 	}
 }
 
-function validarCapas(capas, donde, err) {
+const esNum = (x) => typeof x === 'number' && Number.isFinite(x);
+
+function validarCapas(capas, donde, err, comps) {
 	if (!Array.isArray(capas)) return err(`${donde}: \`capas\` debe ser una lista`);
 	capas.forEach((c, i) => {
 		const d = `${donde}, capa ${i + 1}`;
 		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 === 'componente') {
+			if (!c.nombre) err(`${d}: falta \`nombre\` (el componente registrado en morfeo.config.mjs → componentes)`);
+			else if (comps && !comps.includes(c.nombre))
+				err(`${d}: el componente "${c.nombre}" no está en morfeo.config.mjs → componentes${comps.length ? ` (hay: ${comps.join(', ')})` : ''}`);
+		}
+		if (c.tipo === 'medida' && (!Array.isArray(c.de) || !Array.isArray(c.a))) err(`${d}: \`medida\` necesita \`de: [x, y]\` y \`a: [x, y]\``);
+		if (c.tipo === 'trazo' && (!Array.isArray(c.puntos) || c.puntos.length < 2)) err(`${d}: \`trazo\` necesita \`puntos\` con al menos 2 [x, y]`);
+		if (c.tipo === 'terminal' && !Array.isArray(c.lineas)) err(`${d}: \`terminal\` necesita \`lineas\` (lista de textos)`);
+		if (['nombre', 'accion', 'sello', 'fuente', 'seccion'].includes(c.tipo) && (c.texto == null || c.texto === '')) err(`${d}: falta \`texto\``);
+		if (c.tipo === 'dato' && c.valor == null) err(`${d}: falta \`valor\``);
 		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);
+		if (c.capas) validarCapas(c.capas, d, err, comps);
+		if (c.capa) validarCapas([c.capa], d, err, comps);
 	});
 }
 
@@ -294,7 +311,23 @@ function validarVideo(id, v, ctx) {
 					? `${n}: type "${s.type}" es del estilo "datos-curiosos"; en "${estilo}" usa: ${TIPOS_MOTOR.join(', ')}`
 					: `${n}: type "${s.type}" no existe. Opciones: ${permitidos.join(', ')}`,
 			);
-		if (s.capas != null) validarCapas(s.capas, `${n}`, err);
+		if (s.capas != null) validarCapas(s.capas, `${n}`, err, ctx.componentes);
+		if (s.rotulo != null && typeof s.rotulo !== 'string') err(`${n}: \`rotulo\` debe ser un texto corto ('¿CUÁNTO *SUBIÓ*?')`);
+		if (s.claves != null && (!Array.isArray(s.claves) || s.claves.some((k) => typeof k !== 'string'))) err(`${n}: \`claves\` debe ser una lista de palabras (['cerebro'])`);
+		if (s.toma != null) {
+			const tm = s.toma;
+			if (typeof tm !== 'object' || Array.isArray(tm)) err(`${n}: \`toma\` debe ser un objeto {x, y, zoom}`);
+			else {
+				for (const k of ['x', 'y', 'zoom', 'giro', 'duracion', 'deriva']) if (tm[k] != null && !esNum(tm[k])) err(`${n}: \`toma.${k}\` debe ser un número`);
+				if (tm.zoom != null && tm.zoom <= 0) err(`${n}: \`toma.zoom\` debe ser mayor que 0`);
+				if (tm.a != null) for (const k of ['x', 'y', 'zoom', 'giro']) if (tm.a[k] != null && !esNum(tm.a[k])) err(`${n}: \`toma.a.${k}\` debe ser un número`);
+			}
+			if (!v.mundo?.length) err(`${n}: \`toma\` mueve la cámara del \`mundo\`, pero el video no tiene \`mundo\``);
+		}
+		if (s.type === 'cta' && s.pide != null) {
+			if (!['comenta', 'comparte'].includes(s.pide)) err(`${n}: \`pide\` debe ser 'comenta' o 'comparte'`);
+			if (s.pide === 'comenta' && s.palabra != null && typeof s.palabra !== 'string') err(`${n}: \`palabra\` debe ser un texto ('PASO')`);
+		}
 		const say = s.say ?? (s.type === 'cta' ? ctx.marca.cta : null);
 		if (!say || typeof say !== 'string') err(`${n}: falta \`say\` (lo que dice la voz${s.audio ? '; con `audio` sirve para los subtítulos' : ''})`);
 		for (const k of ['at', 'click']) if (s[k] != null && typeof s[k] !== 'string') err(`${n}: \`${k}\` debe ser una palabra del texto`);
@@ -312,8 +345,15 @@ function validarVideo(id, v, ctx) {
 	let voice = null;
 	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);
-	if (v.mundo != null) validarCapas(v.mundo, 'mundo', err);
+	if (v.hud != null) validarCapas(v.hud, 'hud', err, ctx.componentes);
+	if (v.mundo != null) {
+		validarCapas(v.mundo, 'mundo', err, ctx.componentes);
+		if (clasico) err('`mundo` es del motor de capas: usa un estilo como ilustrado, 3d o mesa (no "datos-curiosos")');
+	}
+	if (v.serie != null && typeof v.serie !== 'string') err("`serie` debe ser un texto ('GYM CON CIENCIA · PARTE 5')");
+	if (v.title != null && typeof v.title !== 'string') err('`title` debe ser un texto (también es el nombre del archivo del video)');
+	if (v.calidad != null && !['alta', 'media', 'ligera'].includes(v.calidad)) err("`calidad` debe ser 'alta', 'media' o 'ligera'");
+	if (v.tags != null && (!Array.isArray(v.tags) || v.tags.some((x) => typeof x !== 'string'))) err("`tags` debe ser una lista de textos (['curiosidades', 'ciencia'])");
 	// archivos de assets/ que piden las escenas y el HUD: mejor avisar ahora que a mitad del render
 	revisarArchivos({scenes, hud: v.hud, mundo: v.mundo, tema: v.tema}, ctx.assetsDir, err);
 	revisarPersonajes({scenes, hud: v.hud, mundo: v.mundo}, ctx.personajes, err);

package/lib/entorno.mjs

@@ -33,11 +33,31 @@ export const PY_MAX = [3, 13];
 
 export const pythonVenv = () => (ES_WIN ? path.join(VENV, 'Scripts', 'python.exe') : path.join(VENV, 'bin', 'python'));
 
-const huellaRequisitos = () => crypto.createHash('sha1').update(fs.readFileSync(REQUISITOS)).digest('hex').slice(0, 12);
+const sha = (s) => crypto.createHash('sha1').update(s).digest('hex').slice(0, 12);
+// la huella ignora saltos de línea y espacios: el mismo requirements.txt llega con CRLF (git en Windows) o LF (npm),
+// y antes eso hacía creer que faltaba `npx morfeo instalar` al cambiar entre una copia del repo y el paquete
+const huellaRequisitos = () =>
+	sha(
+		fs
+			.readFileSync(REQUISITOS, 'utf8')
+			.split(/\r?\n/)
+			.map((l) => l.trim())
+			.filter((l) => l && !l.startsWith('#'))
+			.join('\n'),
+	);
+const huellaVieja = () => [sha(fs.readFileSync(REQUISITOS)), sha(fs.readFileSync(REQUISITOS, 'utf8').replace(/\r\n/g, '\n')), sha(fs.readFileSync(REQUISITOS, 'utf8').replace(/\n/g, '\r\n'))];
 const MARCA_VENV = () => path.join(VENV, '.morfeo-listo');
 export const venvListo = () => {
 	try {
-		return fs.existsSync(pythonVenv()) && fs.readFileSync(MARCA_VENV(), 'utf8') === huellaRequisitos();
+		if (!fs.existsSync(pythonVenv())) return false;
+		const marca = fs.readFileSync(MARCA_VENV(), 'utf8').trim();
+		if (marca === huellaRequisitos()) return true;
+		// marcas de versiones anteriores (huella del archivo tal cual, con LF o CRLF): se aceptan y se actualizan
+		if (huellaVieja().includes(marca)) {
+			marcarVenvListo();
+			return true;
+		}
+		return false;
 	} catch {
 		return false;
 	}

package/lib/estructura.mjs

@@ -106,7 +106,7 @@ export function revisarEstructura(v, d) {
 	// 5) habla de tú
 	const todo = cuerpo.map((s) => s.say ?? '').join(' ');
 	const n = palabrasDe(todo).length;
-	const tu = (todo.match(/\b(tú|tu|tus|te|ti|contigo|imagina|tienes|eres|puedes|sabes)\b/gi) ?? []).length;
+	const tu = (todo.match(/\b(tú|tu|tus|te|ti|contigo|imagina|imaginas|tienes|eres|puedes|sabes|sabías|crees|conoces|harías|pagarías)\b/gi) ?? []).length;
 	if (n > 40 && tu === 0) add('tu', 'idea', 'No le habla al espectador ni una vez: una frase en segunda persona ("imagina que tú…") lo mete en la historia.');
 	return out;
 }

package/lib/guion.mjs

@@ -160,7 +160,7 @@ export async function esquemaMotor() {
 }
 
 /** De la salida de la IA (motor de capas) al formato de escenas de morfeo. */
-function aEscenaMotor(e, conImagenes) {
+export function aEscenaMotor(e, conImagenes) {
 	const out = {type: e.type, say: e.say};
 	if (e.show && e.show !== e.say) out.show = e.show;
 	const si = (k, v) => v != null && v !== '' && (out[k] = v);
@@ -206,7 +206,7 @@ function aEscenaMotor(e, conImagenes) {
 }
 
 /** De la salida plana de la IA al formato de escenas de morfeo. */
-function aEscena(e) {
+export function aEscena(e) {
 	const c = (x) => COLORES[x] ?? x;
 	const out = {type: e.type, say: e.say};
 	if (e.show && e.show !== e.say) out.show = e.show;

package/lib/hoja.mjs

@@ -66,6 +66,9 @@ function leerPng(b, w, h) {
  * @returns {string} ruta del PNG
  */
 export function hoja({video, salida, cols = 5, filas = 3, desde = 0, hasta, ancho = 216}) {
+	// rutas absolutas: ffmpeg corre desde la carpeta de sus DLL, así que una ruta relativa no se encontraría
+	video = path.resolve(video);
+	if (salida) salida = path.resolve(salida);
 	if (!fs.existsSync(video)) throw new ErrorMorfeo(`No encuentro ${video}. Renderízalo primero:  npx morfeo render`);
 	const {ffmpeg, ffprobe, cwd} = binarios();
 	const sonda = spawnSync(ffprobe, ['-v', 'error', '-select_streams', 'v:0', '-show_entries', 'stream=width,height:format=duration', '-of', 'csv=p=0', video], {encoding: 'utf8', cwd});

package/lib/nuevo-video.mjs

@@ -0,0 +1,65 @@
+// `morfeo nuevo-video <id> --look 2d|3d`: crea guiones/<id>.mjs y escenas/Mundo<Id>.tsx desde una base que ya
+// renderiza (carpeta bases/ del paquete) y registra el componente en morfeo.config.mjs → componentes.
+import fs from 'node:fs';
+import path from 'node:path';
+import {ErrorMorfeo} from './config.mjs';
+import {PAQUETE} from './entorno.mjs';
+
+export const LOOKS = ['2d', '3d'];
+
+/** "mi-video_2" -> "MundoMiVideo2" */
+export const nombreComponente = (id) =>
+	'Mundo' +
+	String(id)
+		.normalize('NFD')
+		.replace(/[̀-ͯ]/g, '')
+		.split(/[^A-Za-z0-9]+/)
+		.filter(Boolean)
+		.map((p) => p[0].toUpperCase() + p.slice(1))
+		.join('');
+
+/**
+ * Agrega {Nombre: './escenas/Nombre.tsx'} a `componentes` del config (o crea la clave). Devuelve el texto nuevo,
+ * o null si ya estaba registrado.
+ */
+export function registrarEnConfig(texto, nombre, ruta) {
+	if (new RegExp(`\\b${nombre}\\s*:`).test(texto)) return null;
+	const entrada = `${nombre}: '${ruta}'`;
+	const m = texto.match(/componentes\s*:\s*\{/);
+	if (m) {
+		const i = m.index + m[0].length;
+		const vacio = /^\s*\}/.test(texto.slice(i));
+		return texto.slice(0, i) + (vacio ? entrada : `${entrada}, `) + texto.slice(i);
+	}
+	// sin `componentes`: se agrega antes del cierre de defineConfig({...}) / export default {...}
+	const fin = texto.lastIndexOf('}');
+	if (fin < 0) throw new ErrorMorfeo('No pude entender morfeo.config.mjs para registrar el componente; agrégalo a mano en `componentes`.');
+	const antes = texto.slice(0, fin).replace(/\s*$/, '');
+	const coma = antes.endsWith(',') || antes.endsWith('{') ? '' : ',';
+	return `${antes}${coma}\n\tcomponentes: {${entrada}},\n${texto.slice(fin)}`;
+}
+
+/**
+ * @param {{proyecto: string, id: string, look?: string, carpetaGuiones?: string}} o
+ * @returns {{guion: string, escena: string, componente: string}}
+ */
+export function nuevoVideo({proyecto, id, look = '2d', carpetaGuiones}) {
+	if (!id || !/^[a-z0-9][a-z0-9-_]*$/i.test(id)) throw new ErrorMorfeo('Dame un id corto sin espacios:  npx morfeo nuevo-video mi-video --look 2d');
+	if (!LOOKS.includes(look)) throw new ErrorMorfeo(`--look debe ser ${LOOKS.join(' o ')}`);
+	const config = ['morfeo.config.mjs', 'morfeo.config.js'].map((f) => path.join(proyecto, f)).find((f) => fs.existsSync(f));
+	if (!config) throw new ErrorMorfeo(`No encontré morfeo.config.mjs en ${proyecto}. Crea un proyecto con:  npx morfeo nuevo mi-canal`);
+	const componente = nombreComponente(id);
+	const dirGuiones = carpetaGuiones ?? path.join(proyecto, 'guiones');
+	const guion = path.join(dirGuiones, `${id}.mjs`);
+	const escena = path.join(proyecto, 'escenas', `${componente}.tsx`);
+	for (const f of [guion, escena]) if (fs.existsSync(f)) throw new ErrorMorfeo(`Ya existe ${path.relative(proyecto, f)}; elige otro id.`);
+	const base = path.join(PAQUETE, 'bases', look);
+	const poner = (s) => s.replaceAll('__ID__', id).replaceAll('__COMPONENTE__', componente);
+	fs.mkdirSync(dirGuiones, {recursive: true});
+	fs.mkdirSync(path.dirname(escena), {recursive: true});
+	fs.writeFileSync(guion, poner(fs.readFileSync(path.join(base, 'guion.mjs'), 'utf8')));
+	fs.writeFileSync(escena, poner(fs.readFileSync(path.join(base, 'Mundo.tsx'), 'utf8')));
+	const nuevo = registrarEnConfig(fs.readFileSync(config, 'utf8'), componente, `./escenas/${componente}.tsx`);
+	if (nuevo) fs.writeFileSync(config, nuevo);
+	return {guion, escena, componente};
+}

package/lib/palabras.mjs

@@ -0,0 +1,79 @@
+// Momentos por palabra ("en: 'tubería'") que la voz nunca dice: en el video caen "a media frase" sin avisar.
+// Esto los busca con las mismas reglas que `cuando()` de remotion/motor/util.ts y avisa antes de renderizar.
+
+/** Igual que `norm` de remotion/motor/util.ts: sin acentos, minúsculas, solo letras y números. */
+export const normalizar = (s) =>
+	String(s)
+		.normalize('NFD')
+		.replace(/[̀-ͯ]/g, '')
+		.toLowerCase()
+		.replace(/[^a-z0-9]/g, '');
+
+/** "palabra+0.3" -> "palabra"; null si no es un momento por palabra (número, inicio, voz, fin). */
+export function palabraDe(en) {
+	if (typeof en !== 'string') return null;
+	const m = en.match(/^(.*?)([+-]\d+(?:\.\d+)?)?$/);
+	const base = (m?.[1] ?? en).trim();
+	if (!base || ['inicio', 'voz', 'fin'].includes(base)) return null;
+	return base;
+}
+
+/** ¿La voz dice una palabra que empiece así? (la misma regla que `cuando`: "orca" encuentra "orcas"). */
+export const laDice = (palabra, dichas) => {
+	const n = normalizar(palabra);
+	return !n || dichas.some((w) => normalizar(w).startsWith(n));
+};
+
+const CLAVES = ['en', 'hasta', 'check', 'clic', 'rotuloEn'];
+
+/** Recorre una capa (y lo que lleva dentro) juntando [ruta, palabra]. */
+function momentosDe(x, ruta, out) {
+	if (Array.isArray(x)) return x.forEach((v, i) => momentosDe(v, `${ruta}[${i}]`, out));
+	if (!x || typeof x !== 'object') return;
+	for (const k of CLAVES) {
+		const p = palabraDe(x[k]);
+		if (p) out.push([`${ruta}.${k}`, p]);
+	}
+	// lo que vive dentro de una capa: sus capas, su capa repetida, cambios, poses, items, líneas, movimientos
+	for (const k of ['capas', 'capa', 'cambios', 'poses', 'items', 'lineas', 'mover', 'escalar', 'opciones', 'capasPantalla'])
+		if (x[k] != null) momentosDe(x[k], `${ruta}.${k}`, out);
+}
+
+/**
+ * Avisos de momentos por palabra que no están en lo que dice la voz.
+ * @param {object} v  video validado (scenes, hud, mundo)
+ * @param {object} d  datos.json del video (palabras por escena)
+ * @returns {string[]}
+ */
+export function revisarPalabras(v, d) {
+	if (!d?.escenas) return [];
+	const avisos = [];
+	const todas = d.escenas.flatMap((e) => (e.palabras ?? []).map(([w]) => w));
+	(v.scenes ?? []).forEach((s, i) => {
+		const e = d.escenas[i];
+		if (!s || !e) return;
+		const dichas = (e.palabras ?? []).map(([w]) => w);
+		if (!dichas.length) return;
+		const momentos = [];
+		// los de la escena misma (rotuloEn, at/click de las clásicas) y los de sus capas
+		for (const k of ['rotuloEn', 'at', 'click']) {
+			const p = palabraDe(s[k]);
+			if (p) momentos.push([k, p]);
+		}
+		momentosDe(s.capas ?? [], 'capas', momentos);
+		momentosDe(s.items ?? [], 'items', momentos);
+		momentosDe(s.opciones ?? [], 'opciones', momentos);
+		// con `show`, los momentos se buscan en las palabras del subtítulo (las cifras quedan como "1.560.000")
+		const texto = String(s.show ?? s.say ?? '').slice(0, 60);
+		for (const [ruta, p] of momentos)
+			if (!laDice(p, dichas))
+				avisos.push(`escena ${i + 1}, ${ruta}: "${p}" no está en ${s.show ? 'el subtítulo (`show`)' : 'lo que dice la voz'} ("${texto}"); se usará la mitad de la frase`);
+	});
+	// hud y mundo usan las palabras de todo el video
+	for (const [k, lista] of [['hud', v.hud], ['mundo', v.mundo]]) {
+		const momentos = [];
+		momentosDe(lista ?? [], k, momentos);
+		for (const [ruta, p] of momentos) if (!laDice(p, todas)) avisos.push(`${ruta}: "${p}" no aparece en ninguna escena`);
+	}
+	return avisos;
+}