morfeo 0.2.1 → 0.3.1

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': {
@@ -168,6 +182,7 @@ async function main() {
 				serie: 'series con personaje y capítulos: HUD (días, barras), cartas VS, "comenta", subtítulos en bloque',
 				infografia: 'infografía plana: medidores, barras, globos, pantalla dividida, rayos X',
 				'3d': 'escenas 3D con recorrido de cámara (tu .glb), una palabra grande a la vez',
+				maqueta: 'diorama 3D low-poly con corte de tierra: una palabra al centro, etiquetas con flecha, cortes rápidos (kit diorama)',
 				minimal: 'oscuro y limpio, para lo que sea',
 			};
 			for (const e of ESTILOS) console.log(`  ${e.padEnd(16)} ${desc[e] ?? ''}`);
@@ -221,7 +236,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.`);
@@ -233,6 +248,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

@@ -21,7 +21,7 @@ interface EscenaBase {
 	audio?: string;
 }
 
-export type Estilo = 'datos-curiosos' | 'explicativo' | 'documental' | 'ilustrado' | 'historia' | 'mesa' | 'serie' | 'infografia' | '3d' | 'minimal' | (string & {});
+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';
@@ -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>)[];
 }
@@ -84,8 +85,16 @@ export type Capa = CapaBase &
 		| {tipo: 'terminal'; lineas: (string | {texto: string; en?: Momento; salida?: boolean; color?: string})[]; titulo?: string; ancho?: number; tam?: number; fondo?: string; velocidad?: number}
 		| {tipo: 'nombre'; texto: string; sub?: string; tam?: number; fondo?: string; colorTexto?: string; borde?: string}
 		| {tipo: 'accion'; texto: string; tam?: number; color?: string; fondo?: string; colorTexto?: string}
+		/** Tarjetas de datos (estilo maqueta): se llenan o palomean solas desde `en`. */
+		| {tipo: 'reloj'; de?: number; a?: number; max?: number; segmentos?: [number, number, string][]; etiqueta?: string | false; tam?: number; color?: string; duracion?: number}
+		| {tipo: 'cronometro'; de?: number; a?: number; max?: number; unidad?: 'seg' | 'min'; tam?: number; color?: string; duracion?: number}
+		| {tipo: 'termometro'; valor: number; de?: number; min?: number; max?: number; unidad?: string; alto?: number; color?: string; decimales?: number; mostrar?: boolean}
+		| {tipo: 'recipientes'; n?: number; valor?: number; forma?: 'garrafon' | 'vaso'; total?: string; color?: string; tamPieza?: number; duracion?: number}
+		| {tipo: 'ficha'; titulo?: string; foto?: string; campos: [string, string][]; ancho?: number; color?: string; fondoFoto?: string}
+		| {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}
@@ -144,6 +153,9 @@ interface EscenaMotorBase extends EscenaBase {
 	rotulo?: string;
 	rotuloEn?: Momento;
 	rotuloTam?: number;
+	/** 'normal' | 'contorno' (blanco con contorno, clave en acento) | 'pastilla' (caja oscura inclinada: ¡CUIDADO!). Por defecto, el del estilo. */
+	rotuloEstilo?: 'normal' | 'contorno' | 'pastilla';
+	rotuloInclinar?: number;
 	/** Palabras clave de la escena para los subtítulos (la que lleva caja o color de acento en cada frase). */
 	claves?: string[];
 	/** Ajustes del tema solo para esta escena. */
@@ -171,7 +183,7 @@ export interface Tema {
 	colores: {texto: string; acento: string; acento2: string; suave: string; tarjeta: string; tarjetaTexto: string; borde: string};
 	fuentes: {titulo: string; texto: string; mono: string};
 	tituloMayusculas: boolean;
-	subtitulos: {tipo: 'karaoke' | 'seleccion' | 'pop' | 'bloque' | 'palabra' | 'caja' | 'ninguno'; y: number; tam: number; color: string; pendiente: string; resalte: string; maxPalabras: number; mayusculas?: boolean; contorno?: number; fondo?: string};
+	subtitulos: {tipo: 'karaoke' | 'seleccion' | 'pop' | 'bloque' | 'palabra' | 'caja' | 'ninguno'; y: number; tam: number; color: string; pendiente: string; resalte: string; maxPalabras: number; mayusculas?: boolean | 'inicial'; contorno?: number; fondo?: string};
 	transicion: Transicion;
 	/** Ritmo de las animaciones: duraciones (s) y curva de las entradas. */
 	movimiento?: {entrada?: number; salida?: number; transicion?: number; curva?: 'suave' | 'resorte' | 'seca'};
@@ -182,6 +194,8 @@ export interface Tema {
 		desenfoqueBordes?: number;
 		vinetaColor?: string;
 	};
+	/** Rótulo de cada escena: estilo 'normal' | 'contorno' | 'pastilla', inclinación, altura (px) y tamaño. */
+	rotulo?: {estilo?: 'normal' | 'contorno' | 'pastilla'; inclinar?: number; y?: number; tam?: number};
 	marca: 'esquina' | 'arriba' | 'ninguna';
 	zoomLento: number;
 }
@@ -233,6 +247,13 @@ 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...). */
 	tema?: Partial<Tema> & Record<string, unknown>;
 	/** Título para publicar. */
@@ -286,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

@@ -22,8 +22,8 @@ const parecidas = (nombre, lista, n = 3) => {
 export const TIPOS_CLASICOS = ['title', 'year', 'text', 'icon', 'compare', 'card', 'dialog', 'aliens', 'memory', 'morph', 'cta'];
 export const TIPOS_MOTOR = ['capas', 'titular', 'dato', 'lista', 'telefono', 'comparar', 'eleccion', 'cta'];
 export const TIPOS_ESCENA = [...new Set([...TIPOS_CLASICOS, ...TIPOS_MOTOR])];
-export const ESTILOS = ['datos-curiosos', 'explicativo', 'documental', 'ilustrado', 'historia', 'mesa', 'serie', 'infografia', '3d', 'minimal'];
-export const TIPOS_CAPA = ['imagen', 'video', 'texto', 'contador', 'chip', 'etiqueta', 'numero', 'tarjeta', 'telefono', 'forma', 'icono', 'emoji', 'marca', 'particulas', 'grupo', 'modelo', 'componente', 'barra', 'medidor', 'votacion', 'estado', 'noticia', 'chat', 'onda', 'globo', 'seguir', 'personaje', 'escena3d', 'ventana', 'escenario', 'recurso', 'dato', 'medida', 'trazo', 'contorno', 'fuente', 'seccion', 'insignia', 'sello', 'cursor', 'terminal', 'nombre', 'accion'];
+export const ESTILOS = ['datos-curiosos', 'explicativo', 'documental', 'ilustrado', 'historia', 'mesa', 'serie', 'infografia', '3d', 'maqueta', 'minimal'];
+export const TIPOS_CAPA = ['imagen', 'video', 'texto', 'contador', 'chip', 'etiqueta', 'numero', 'tarjeta', 'telefono', 'forma', 'icono', 'emoji', 'marca', 'particulas', 'grupo', 'modelo', 'componente', 'barra', 'medidor', 'votacion', 'estado', 'noticia', 'chat', 'onda', 'globo', 'seguir', 'personaje', 'escena3d', 'ventana', 'escenario', 'recurso', 'dato', 'medida', 'trazo', 'contorno', 'fuente', 'seccion', 'insignia', 'sello', 'cursor', 'terminal', 'nombre', 'accion', 'reloj', 'cronometro', 'termometro', 'recipientes', 'ficha', 'checklist', 'mapa'];
 export const ESCENARIOS = ['bosque', 'cuarto', 'departamento', 'tunel', 'pasillo'];
 export const FORMAS_3D = ['moneda', 'billete', 'lingote', 'cubo', 'esfera', 'corazon', 'estrella', 'rayo', 'diamante', 'trofeo', 'cohete', 'foco', 'reloj', 'planeta', 'arbol', 'nube', 'regalo', 'llave', 'candado', 'casa', 'libro', 'globo', 'medalla', 'escudo', 'pin', 'tuberia', 'muro', 'viga', 'columna', 'escalera', 'losa', 'tanque', 'suelo'];
 export const PROVEEDORES_VOZ = ['kokoro', 'elevenlabs', 'openai'];
@@ -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,7 +149,10 @@ 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)
@@ -198,19 +201,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 +309,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 +343,14 @@ 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.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

@@ -18,6 +18,12 @@
 //   - Series: una pastilla fija arriba ("TITO DESDE CERO · EP. 1", "GYM CON CIENCIA · PARTE 5") y contadores persistentes.
 //   - Cierre con una acción concreta, no solo "sígueme": elegir A o B en comentarios, "escribe PASO si entendiste",
 //     "mándaselo al que dice que...", cuenta regresiva para la próxima parte.
+//
+// Formato largo "explicador de maqueta" (2026-11, 4 videos de 102–132 s: castor, tinaco, buey, caseta de cobro):
+//   - Un solo diorama 3D low-poly con corte de tierra; 24–25 cortes por minuto (uno cada ~2,4 s) entre ángulos del
+//     mismo mundo. Una palabra a la vez al centro, rótulos con contorno, etiquetas con flecha pegadas a los objetos.
+//   - Gancho "Imagina que eres un castor…" o "¿Cómo se hace una caseta de cobro?"; cierre "¡Felicidades, eres…!" o un
+//     VS de "ya lo sabía / no lo sabía". Aquí 90–130 s está bien: el mundo y los cortes sostienen la atención.
 
 /** Las reglas, en el orden en que se le explican a la IA y a quien escribe un guion. */
 export const REGLAS = [
@@ -30,7 +36,7 @@ export const REGLAS = [
 	{id: 'escalada', regla: 'Que suba la apuesta', como: 'Cada escena más grave, más grande o más rara que la anterior; lo más fuerte cerca del final, no al principio.'},
 	{id: 'cierre', regla: 'Cierre con una acción concreta', como: 'Pide algo fácil y específico: elegir A o B en comentarios, escribir una palabra ("escribe PASO"), mandárselo a alguien ("mándaselo al que dice que…") o esperar la parte 2. "Sígueme" solo no basta.'},
 	{id: 'bucle', regla: 'Final que conecta con el inicio', como: 'La última frase puede regresar a la primera imagen o dejar una pregunta abierta, para que se vuelva a ver.'},
-	{id: 'duracion', regla: 'Entre 30 y 65 segundos', como: 'La mayoría de los de referencia dura ~1 minuto. Más de 75 s solo si es una serie o una historia que lo sostiene.'},
+	{id: 'duracion', regla: 'Entre 30 y 65 segundos (o 90–130 en maqueta)', como: 'La mayoría de los de referencia dura ~1 minuto. Más de 75 s solo si es una serie, una historia o un explicador de maqueta (estilo maqueta: 90–130 s con un corte de cámara cada 2–3 s dentro del mismo mundo).'},
 ];
 
 /** Las reglas como texto para el prompt de la IA. */
@@ -38,7 +44,7 @@ export const REGLAS_TEXTO = `Estructura (medida en videos virales; síguela):
 ${REGLAS.map((r, i) => `${i + 1}. ${r.regla}: ${r.como}`).join('\n')}`;
 
 const palabrasDe = (s) => String(s ?? '').trim().split(/\s+/).filter(Boolean);
-const GANCHOS = /^(¿|imagina|y si|si tu|si te|si un|qué pasaría|que pasaria|este es|esta es|esto es|nadie|nunca|todos|a \S+ |hay |tu |tú |te |tienes|cuando)/i;
+const GANCHOS = /^(¿|¡|imagina|y si|cómo|como se|si tu|si te|si un|qué pasaría|que pasaria|este es|esta es|esto es|nadie|nunca|todos|a \S+ |hay |tu |tú |te |tienes|cuando)/i;
 
 /**
  * Revisa la estructura de un video y devuelve consejos (no bloquea el render).
@@ -54,6 +60,8 @@ export function revisarEstructura(v, d) {
 	if (!cuerpo.length) return out;
 	const primera = cuerpo[0];
 	const clasico = (v.estilo ?? 'datos-curiosos') === 'datos-curiosos';
+	// formato largo: explicador de maqueta (o `formato: 'largo'` en el video)
+	const largo = v.estilo === 'maqueta' || v.formato === 'largo';
 
 	// 1) gancho
 	const dicho = String(primera.say ?? '').trim();
@@ -67,7 +75,9 @@ export function revisarEstructura(v, d) {
 	const es = d?.escenas?.filter((e) => e.tipo !== 'cta') ?? [];
 	if (es.length) {
 		const dur = d.duracion;
-		if (dur > 75) add('duracion', 'idea', `Dura ${Math.round(dur)} s: los de referencia rondan 60 s. Si no es una serie o una historia, recorta.`);
+		if (largo && dur > 140) add('duracion', 'idea', `Dura ${Math.round(dur)} s: los explicadores de maqueta de referencia van de 100 a 130 s.`);
+		else if (largo && dur < 60) add('duracion', 'idea', `Dura ${Math.round(dur)} s: en maqueta los de referencia duran 100–130 s; hay espacio para otra pregunta y su respuesta.`);
+		else if (!largo && dur > 75) add('duracion', 'idea', `Dura ${Math.round(dur)} s: los de referencia rondan 60 s. Si no es una serie o una historia, recorta (o usa estilo maqueta para un explicador largo).`);
 		if (dur < 20) add('duracion', 'idea', `Dura ${Math.round(dur)} s: un poco más de desarrollo (una pregunta y su respuesta) suele retener mejor.`);
 		const e0 = es[0];
 		if (e0 && e0.habla?.[0] > 0.5) add('gancho', 'aviso', `La voz tarda ${e0.habla[0].toFixed(1)} s en empezar: debe arrancar de inmediato.`);
@@ -77,7 +87,8 @@ export function revisarEstructura(v, d) {
 			// algo que cambie a media escena: capas con `en`, cámara con rango, toma con movimiento, o un mundo vivo
 			const capas = s.capas ?? [];
 			const cambia = capas.some((c) => c.en != null && c.en !== 0 && c.en !== 'inicio') || Array.isArray(s.camara?.zoom) || s.toma?.a || capas.some((c) => c.mover || c.cambios);
-			if (voz > 6 && !cambia && !v.mundo?.length) add('ritmo', 'aviso', `Escena ${i + 1}: ${voz.toFixed(1)} s de voz sin que nada cambie. Pártela en dos o haz que algo entre a media frase.`);
+			if (largo && voz > 4.5) add('ritmo', 'idea', `Escena ${i + 1}: ${voz.toFixed(1)} s en una sola toma; en maqueta la cámara corta cada 2–3 s. Pártela en dos tomas.`);
+			else if (voz > 6 && !cambia && !v.mundo?.length) add('ritmo', 'aviso', `Escena ${i + 1}: ${voz.toFixed(1)} s de voz sin que nada cambie. Pártela en dos o haz que algo entre a media frase.`);
 			else if (voz > 9) add('ritmo', 'idea', `Escena ${i + 1}: ${voz.toFixed(1)} s de voz en una sola escena; en los de referencia ninguna idea pasa de ~5 s.`);
 		});
 	}

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});