morfeo 0.0.0-stage → 0.1.1

package/package.json

@@ -1,6 +1,85 @@
 {
-  "name": "morfeo",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+	"name": "morfeo",
+	"version": "0.1.1",
+	"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://ureckchan.github.io/morfeo/",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/UreckChan/morfeo.git"
+	},
+	"bugs": {
+		"url": "https://github.com/UreckChan/morfeo/issues"
+	},
+	"keywords": [
+		"video",
+		"shorts",
+		"remotion",
+		"threejs",
+		"tts",
+		"kokoro",
+		"elevenlabs",
+		"subtitulos",
+		"animacion"
+	],
+	"bin": {
+		"morfeo": "bin/morfeo.mjs"
+	},
+	"exports": {
+		".": {
+			"types": "./index.d.ts",
+			"default": "./lib/index.mjs"
+		},
+		"./package.json": "./package.json",
+		"./remotion/*": "./remotion/*"
+	},
+	"types": "./index.d.ts",
+	"files": [
+		"bin",
+		"lib",
+		"remotion",
+		"python/*.py",
+		"python/requirements.txt",
+		"assets",
+		"plantilla",
+		"index.d.ts",
+		"LICENSE",
+		"README.md"
+	],
+	"engines": {
+		"node": ">=18.17"
+	},
+	"scripts": {
+		"postinstall": "node bin/postinstall.mjs",
+		"typecheck": "tsc --noEmit",
+		"test": "node --test test/",
+		"prepublishOnly": "tsc --noEmit && node bin/morfeo.mjs -v"
+	},
+	"dependencies": {
+		"@anthropic-ai/sdk": "^1.6.0",
+		"@react-three/fiber": "^9.3.0",
+		"@remotion/bundler": "4.0.541",
+		"@remotion/cli": "4.0.541",
+		"@remotion/fonts": "4.0.541",
+		"@remotion/install-whisper-cpp": "4.0.541",
+		"@remotion/layout-utils": "4.0.541",
+		"@remotion/noise": "4.0.541",
+		"@remotion/renderer": "4.0.541",
+		"@remotion/three": "4.0.541",
+		"react": "^19.2.0",
+		"react-dom": "^19.2.0",
+		"remotion": "4.0.541",
+		"three": "^0.178.0",
+		"zod": "^4.1.0"
+	},
+	"devDependencies": {
+		"@types/react": "^19.2.2",
+		"@types/three": "^0.178.1",
+		"typescript": "^5.9.3"
+	},
+	"publishConfig": {
+		"access": "public"
+	}
+}

package/plantilla/env.example

@@ -0,0 +1,7 @@
+# Copia este archivo como .env y llena solo lo que vayas a usar. Nunca lo subas a git.
+# Guiones con IA (npx morfeo guion "tema"):
+ANTHROPIC_API_KEY=
+# Voces de ElevenLabs ({proveedor: 'elevenlabs', voz: '<voice_id>'}):
+ELEVENLABS_API_KEY=
+# Voces de OpenAI ({proveedor: 'openai', voz: 'nova'}):
+OPENAI_API_KEY=

package/plantilla/escenas/Barras.tsx

@@ -0,0 +1,15 @@
+// Un componente propio en React: úsalo con {tipo: 'componente', nombre: 'Barras', props: {valores: [2, 5, 13]}}.
+// Recibe t (segundos desde que aparece), dur, palabras, tema y cuando('palabra') -> segundos.
+import React from 'react';
+
+export default function Barras({t, valores = [3, 7, 12], tema}: {t: number; valores?: number[]; tema: any}) {
+	const max = Math.max(...valores);
+	return (
+		<div style={{display: 'flex', alignItems: 'flex-end', gap: 40, height: 520}}>
+			{valores.map((v, i) => {
+				const k = Math.min(1, Math.max(0, (t - i * 0.25) / 0.6));
+				return <div key={i} style={{width: 150, height: (v / max) * 500 * k, background: i === valores.length - 1 ? tema.colores.acento : tema.colores.suave, borderRadius: 16}} />;
+			})}
+		</div>
+	);
+}

package/plantilla/gitignore

@@ -0,0 +1,4 @@
+node_modules/
+.morfeo/
+salida/
+.env

package/plantilla/guiones/cachalote.mjs

@@ -0,0 +1,24 @@
+// Ejemplo del motor de capas, estilo "documental". Cada escena es una lista de capas animadas.
+// Las palabras en `en` hacen que la capa aparezca justo cuando la voz las dice.
+export default {
+	estilo: 'documental',
+	title: 'El cachalote, el gigante del océano 🐋',
+	voice: 'narrador',
+	music: 'ballad',
+	scenes: [
+		{say: '¿Sabías que las orcas le tienen miedo a un solo animal?', capas: [
+			// en tu canal real usa tus ilustraciones: {tipo: 'imagen', src: 'cachalote.png'} (carpeta assets/)
+			// o pídela a la IA: {tipo: 'imagen', generar: 'un cachalote, ilustración plana'}
+			{tipo: 'emoji', texto: '🐋', tam: 520, x: 540, y: 1000, entrada: 'deslizar-der', mover: {a: [480, 980]}, flotar: 18},
+			{tipo: 'chip', texto: '×5', x: 760, y: 1260, en: 'animal', entrada: 'rebote', sonido: 'pop'}]},
+		{type: 'dato', say: 'El cachalote puede bajar a más de dos mil metros.', show: 'El cachalote puede bajar a más de 2.000 metros.',
+			valor: 2000, sufijo: ' m', formato: 'chip', tam: 110, camara: {zoom: [1.15, 1]},
+			capas: [{tipo: 'emoji', texto: '🐋', tam: 300, x: 540, y: 620, rotar: 70, mover: {a: [540, 1500]}}]},
+		{say: 'Y forman un círculo para proteger a sus crías.', capas: [
+			{tipo: 'grupo', x: 540, y: 1000, repetir: 8, disposicion: 'circulo', radio: 300, orientar: 90, retraso: 0.08, girar: 6, capa: {tipo: 'emoji', texto: '🐋', tam: 150}},
+			{tipo: 'emoji', texto: '🐳', tam: 140, x: 540, y: 1000, en: 'crías', entrada: 'rebote'}]},
+		{say: 'Su sonido llega a doscientos treinta decibeles.', show: 'Su sonido llega a 230 decibeles.', capas: [
+			{tipo: 'contador', de: 0, a: 230, sufijo: ' dB', formato: 'lcd', x: 540, y: 980, en: 'sonido', tam: 120}]},
+		{type: 'cta'},
+	],
+};

package/plantilla/guiones/tutorial.mjs

@@ -0,0 +1,16 @@
+// Ejemplo del estilo "explicativo": titulares, tarjetas que se palomean, comparación y un contador.
+export default {
+	estilo: 'explicativo',
+	title: 'Haz videos con código 🎬',
+	voice: 'narrador',
+	music: 'chillpop',
+	scenes: [
+		{type: 'titular', say: 'Paso uno: instala Morfeo en tu computadora.', etiqueta: '// paso 1 · instala', texto: 'INSTALA *MORFEO*', numero: 1,
+			capas: [{tipo: 'tarjeta', cabecera: '// terminal', titulo: 'npx morfeo instalar', x: 540, y: 1080, ancho: 820, en: 'morfeo', sonido: 'pop'}]},
+		{type: 'lista', say: 'Morfeo pone la voz, la música y los subtítulos por ti.', titulo: 'Lo hace *solo*', cabecera: '// paso 2',
+			items: [{texto: 'Voz', check: 'voz'}, {texto: 'Música', check: 'música'}, {texto: 'Subtítulos', check: 'subtítulos'}]},
+		{type: 'comparar', say: 'Tu guion pasa de aburrido a viral.', a: 'ABURRIDO', b: '¡VIRAL!', at: 'viral'},
+		{type: 'dato', say: 'Un video al día puede llegar a más de un millón de visitas.', de: 100, valor: 1284930, curva: 'exponencial', texto: 'visitas', tam: 170},
+		{type: 'cta'},
+	],
+};

package/plantilla/morfeo.config.mjs

@@ -0,0 +1,43 @@
+// Configuración de tu canal. Los videos están en videos.mjs y en la carpeta guiones/.
+import {defineConfig} from 'morfeo';
+
+export default defineConfig({
+	// Estilo visual por defecto (cada video puede cambiarlo con  estilo: '...'):
+	//   datos-curiosos, explicativo, documental, ilustrado, historia, mesa, serie, infografia, 3d, minimal   (npx morfeo estilos)
+	estilo: 'datos-curiosos',
+
+	marca: {
+		nombre: 'Mi Canal', // sale arriba en cada video y en el cierre
+		logo: null, // './logo.png' (cuadrado). Sin logo se usa la inicial del nombre
+		redes: 'YT @micanal  ·  TikTok @micanal',
+		cta: 'Sígueme para más datos curiosos.', // lo que dice la voz en la escena final ({type: 'cta'})
+		etiqueta: 'DATO CURIOSO', // la pastilla roja del gancho
+	},
+
+	// Alias para no repetir: úsalos como voice: 'narrador' o music: 'mi-cancion'
+	voces: {
+		narrador: [['em_alex', 0.6], ['am_michael', 0.4]], // mezcla de voces Kokoro (gratis, en tu computadora)
+		// eleven: {proveedor: 'elevenlabs', voz: 'TU_VOICE_ID'}, // necesita ELEVENLABS_API_KEY en .env
+		// openai: {proveedor: 'openai', voz: 'nova'},            // necesita OPENAI_API_KEY en .env
+	},
+	musicas: {
+		// 'mi-cancion': {archivo: './musica/cancion.mp3', volumen: 0.8},
+	},
+
+	// Tus propios estilos, heredando de uno existente:
+	// estilos: {'mi-marca': {base: 'minimal', colores: {acento: '#00E0A0'}, subtitulos: {resalte: '#00E0A0'}}},
+
+	// Imágenes con IA para capas {tipo: 'imagen', generar: '...'} (necesita OPENAI_API_KEY en .env):
+	// imagenes: {proveedor: 'openai', estilo: 'ilustración plana, colores cálidos, sin texto'},
+
+	// Componentes propios en React para capas {tipo: 'componente', nombre: 'Barras'}:
+	componentes: {Barras: './escenas/Barras.tsx'},
+
+	// Personajes con poses (series): {tipo: 'personaje', nombre: 'neto', pose: 'feliz'}
+	// personajes: {neto: {referencia: './personajes/neto.png', poses: {normal: './personajes/neto.png', triste: 'llorando, con lágrimas'}}},
+
+	// Fuentes propias: {'Poppins': './fuentes/Poppins-Bold.ttf'} y úsalas en tema: {fuentes: {titulo: 'Poppins'}}
+	// fuentes: {},
+
+	salida: './salida', // aquí quedan los .mp4 y .jpg
+});

package/plantilla/package.json

@@ -0,0 +1,13 @@
+{
+	"name": "__NOMBRE__",
+	"private": true,
+	"type": "module",
+	"scripts": {
+		"render": "morfeo render",
+		"lista": "morfeo lista",
+		"studio": "morfeo studio"
+	},
+	"dependencies": {
+		"morfeo": "__VERSION__"
+	}
+}

package/plantilla/videos.mjs

@@ -0,0 +1,25 @@
+// Tus videos: {id: video}. Cada escena dice algo ("say") y lo ilustra en pantalla.
+// Tipos: title, year, text, icon, compare, card, dialog, cta (y aliens, memory, morph).
+// Colores: '#RRGGBB' o [r, g, b]. Íconos: question, warning, star, zap, eye, book, trophy...
+import {defineVideos} from 'morfeo';
+
+const B = '#FFFFFF'; // blanco
+const A = '#FFD400'; // amarillo
+const R = '#FF4050'; // rojo
+const C = '#50DCFF'; // cian
+
+export default defineVideos({
+	cielo: {
+		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
+		scenes: [
+			{type: 'title', say: '¿Sabías por qué el cielo es azul?', rows: [['¿POR QUÉ', B, 150], ['EL CIELO ES', B, 130], ['AZUL?', C, 250]], icon: 'question'},
+			{type: 'text', say: 'La luz del sol trae todos los colores mezclados.', rows: [['LA LUZ TRAE', B, 140], ['TODOS LOS', B, 140], ['COLORES', A, 210]]},
+			{type: 'icon', say: 'Pero al chocar con el aire, el azul rebota mucho más que el rojo.', icon: 'zap', label: 'EL AZUL REBOTA', color: C},
+			{type: 'compare', say: 'Por eso de día vemos azul, y al atardecer, naranja.', a: ['DE DÍA', C], b: ['ATARDECER', R], at: 'atardecer', sizes: [220, 180]},
+			{type: 'year', say: 'Lord Rayleigh lo explicó en mil ochocientos setenta y uno.', show: 'Lord Rayleigh lo explicó en 1871.', pre: 'RAYLEIGH', year: 1871, sub: 'DISPERSIÓN'},
+			{type: 'cta'}, // dice marca.cta
+		],
+	},
+});

package/python/musica.py

@@ -0,0 +1,221 @@
+import os, numpy as np, soundfile as sf
+from scipy.signal import butter, sosfilt, resample_poly
+
+SR = 44100
+def nf(m): return 440 * 2 ** ((m - 69) / 12)
+def lp(x, fc, o=2): return sosfilt(butter(o, fc, "low", fs=SR, output="sos"), x)
+def hp(x, fc, o=2): return sosfilt(butter(o, fc, "high", fs=SR, output="sos"), x)
+def add(buf, x, t):
+    i = int(t * SR)
+    if i < 0 or i >= len(buf): return
+    x = x[: len(buf) - i]; buf[i:i + len(x)] += x
+def dec(n, r, a=0.004):
+    e = np.exp(-np.arange(n) / (r * SR)); na = max(1, int(a * SR)); e[:na] *= np.linspace(0, 1, na); return e
+
+# ---- instruments ----
+def epiano(f, d):
+    n = int(d * SR); t = np.arange(n) / SR
+    mod = 1.6 * np.exp(-t * 6) * np.sin(2 * np.pi * f * t)
+    x = np.sin(2 * np.pi * f * t + mod) + 0.25 * np.sin(2 * np.pi * 2 * f * t) * np.exp(-t * 4)
+    return x * dec(n, 0.9, 0.006) * (1 + 0.08 * np.sin(2 * np.pi * 4.5 * t))
+def pluck(f, d):
+    n = int(d * SR); t = np.arange(n) / SR
+    x = sum(np.sin(2 * np.pi * f * k * t) * np.exp(-t * (5 + 4 * k)) / k for k in range(1, 6))
+    return x * dec(n, 0.5, 0.002)
+def bell(f, d):
+    n = int(d * SR); t = np.arange(n) / SR
+    x = np.sin(2 * np.pi * f * t + 2.2 * np.exp(-t * 3) * np.sin(2 * np.pi * f * 3.5 * t))
+    return x * dec(n, 0.6, 0.002)
+def pad(freqs, d):
+    n = int(d * SR); t = np.arange(n) / SR; x = np.zeros(n)
+    for f in freqs:
+        for det in (-0.08, 0, 0.08):
+            ph = (t * f * 2 ** (det / 12)) % 1; x += 2 * ph - 1
+    x = lp(x, 1400) / (len(freqs) * 3)
+    e = np.minimum(1, t / 0.4) * np.minimum(1, (d - t) / 0.3); return x * np.clip(e, 0, 1)
+def sub(f, d, glide=None):
+    n = int(d * SR); t = np.arange(n) / SR
+    ff = f if glide is None else f * (glide / f) ** np.clip(t / 0.08, 0, 1)
+    return np.sin(2 * np.pi * np.cumsum(np.ones(n) * ff) / SR) * dec(n, d * 0.6, 0.005)
+def kick(g=1.0, d=0.35):
+    n = int(d * SR); t = np.arange(n) / SR
+    return g * np.sin(2 * np.pi * (48 + 70 * np.exp(-t * 28)) * t) * np.exp(-t * 9)
+def snare(rng, d=0.2, tone=180):
+    n = int(d * SR); t = np.arange(n) / SR
+    return (lp(rng.standard_normal(n), 5000) * 0.6 + 0.4 * np.sin(2 * np.pi * tone * t)) * np.exp(-t * 18)
+def clap(rng):
+    n = int(0.18 * SR); x = hp(rng.standard_normal(n), 900) * np.exp(-np.arange(n) / (0.05 * SR))
+    for o in (0.008, 0.016): x[int(o * SR):] += 0.6 * x[: n - int(o * SR)]
+    return x * 0.5
+def hat(rng, d=0.05):
+    n = int(d * SR); return hp(rng.standard_normal(n), 7000) * dec(n, d / 3, 0.001)
+
+STYLES = {
+    "lofi":     dict(bpm=84, prog=[(53, [65, 69, 72, 76]), (52, [64, 67, 71, 74]), (50, [62, 65, 69, 72]), (48, [60, 64, 67, 71])], drum="lofi", lead="epiano", vinyl=True),
+    "lofi2":    dict(bpm=78, prog=[(51, [63, 67, 70, 74]), (50, [62, 65, 69, 72]), (48, [60, 63, 67, 70]), (46, [58, 62, 65, 69])], drum="lofi", lead="pluckmel", vinyl=True),
+    "chillpop": dict(bpm=102, prog=[(48, [60, 64, 67]), (43, [62, 67, 71]), (45, [60, 64, 69]), (41, [60, 65, 69])], drum="pop", lead="arp8"),
+    "synth":    dict(bpm=108, prog=[(45, [57, 60, 64]), (41, [57, 60, 65]), (48, [55, 60, 64]), (43, [55, 59, 62])], drum="four", lead="arp16", padon=True),
+    "house":    dict(bpm=118, prog=[(50, [62, 65, 69, 72]), (46, [58, 62, 65, 69]), (53, [60, 65, 69, 72]), (48, [60, 64, 67, 71])], drum="house", lead="offchord", padon=True),
+    "ballad":   dict(bpm=74, prog=[(48, [60, 64, 67, 71]), (45, [60, 64, 69, 72]), (41, [60, 65, 69, 72]), (43, [59, 62, 67, 71])], drum="soft", lead="pianoarp"),
+    "trap":     dict(bpm=140, prog=[(48, [60, 63, 67]), (44, [60, 63, 68]), (51, [58, 63, 67]), (46, [58, 62, 65])], drum="trap", lead="bellmel"),
+}
+
+def make_music(style, dur, seed):
+    S = dict(STYLES[style]); rng = np.random.default_rng(seed); N = int((dur + 2) * SR)
+    tr = (seed % 7) - 3
+    S["prog"] = [(r + tr, [c + tr for c in ch]) for r, ch in S["prog"]]
+    if seed % 2: S["prog"] = S["prog"][2:] + S["prog"][:2]
+    m = np.zeros(N); beat = 60 / (S["bpm"] * (0.94 + (seed % 5) * 0.03)); bar = beat * 4
+    nbars = int(dur / bar) + 2
+    scale = [0, 3, 5, 7, 10, 12, 15]
+    motif = [rng.choice(scale) for _ in range(8)]
+    for b in range(nbars):
+        t0 = b * bar; root, ch = S["prog"][b % 4]
+        # harmony
+        if S["lead"] == "pianoarp":
+            for s in range(8): add(m, 0.09 * epiano(nf(ch[s % len(ch)] + (12 if s >= 4 else 0)), beat * 1.2), t0 + s * beat / 2)
+        if S["lead"] == "offchord":
+            for q in range(4):
+                for nn in ch: add(m, 0.035 * pluck(nf(nn), beat * 0.35), t0 + q * beat + beat / 2)
+        if S["lead"] in ("epiano", "pluckmel"):
+            for i, nn in enumerate(ch): add(m, 0.12 * epiano(nf(nn), bar * 0.95), t0 + i * 0.012)
+            if b % 2 == 1: add(m, 0.07 * epiano(nf(ch[1]), beat * 1.5), t0 + beat * 2.5)
+        if S.get("padon") or S["lead"] in ("bellmel", "arp8"):
+            add(m, 0.10 * pad([nf(x) for x in ch], bar), t0)
+        # bass
+        if S["drum"] == "trap":
+            add(m, 0.38 * sub(nf(root - 12), beat * 1.8), t0); add(m, 0.3 * sub(nf(root - 12), beat * 1.2, glide=nf(root - 7)), t0 + beat * 2.5)
+        else:
+            add(m, 0.32 * sub(nf(root - 12), beat * 1.9), t0); add(m, 0.25 * sub(nf(root - 12), beat * 1.4), t0 + beat * 2)
+        # leads
+        if S["lead"] == "arp8":
+            for s in range(8): add(m, 0.07 * pluck(nf(ch[s % len(ch)] + 12), beat * 0.6), t0 + s * beat / 2)
+        elif S["lead"] == "arp16":
+            for s in range(16): add(m, 0.045 * pluck(nf(ch[(s * 2) % len(ch)] + 12), beat * 0.3), t0 + s * beat / 4)
+        elif S["lead"] in ("bellmel", "pluckmel") and b % 4 >= 1:
+            inst = bell if S["lead"] == "bellmel" else pluck
+            for s, iv in enumerate(motif[:4] if b % 2 else motif[4:]):
+                add(m, 0.07 * inst(nf(root + 24 + iv), beat * 0.9), t0 + s * beat)
+        # drums
+        for q in range(4):
+            tb = t0 + q * beat
+            if S["drum"] == "lofi":
+                sw = beat * 0.08
+                if q in (0,): add(m, 0.55 * kick(), tb)
+                if q == 2: add(m, 0.4 * kick(), tb + beat / 2)
+                if q in (1, 3): add(m, 0.16 * lp(snare(rng), 3000), tb)
+                add(m, 0.05 * hat(rng), tb); add(m, 0.035 * hat(rng), tb + beat / 2 + sw)
+            elif S["drum"] == "pop":
+                if q in (0, 2): add(m, 0.55 * kick(), tb)
+                if q == 2: add(m, 0.35 * kick(), tb + beat * 0.75)
+                if q in (1, 3): add(m, 0.3 * clap(rng), tb)
+                add(m, 0.04 * hat(rng), tb + beat / 2)
+            elif S["drum"] == "four":
+                add(m, 0.5 * kick(), tb); add(m, 0.05 * hat(rng, 0.08), tb + beat / 2)
+                if q in (1, 3): add(m, 0.12 * snare(rng), tb)
+            elif S["drum"] == "house":
+                add(m, 0.5 * kick(), tb); add(m, 0.07 * hat(rng, 0.09), tb + beat / 2)
+                if q in (1, 3): add(m, 0.22 * clap(rng), tb)
+            elif S["drum"] == "soft":
+                if q == 0: add(m, 0.35 * kick(), tb)
+                if q == 2: add(m, 0.08 * lp(snare(rng, 0.3), 2000), tb)
+                add(m, 0.02 * hat(rng, 0.08), tb + beat / 2)
+            elif S["drum"] == "trap":
+                if q == 0: add(m, 0.5 * kick(), tb)
+                if q == 2: add(m, 0.3 * clap(rng), tb)
+                rolls = 6 if (q == 3 and b % 2) else 2
+                for h in range(rolls): add(m, 0.04 * hat(rng, 0.03), tb + h * beat / rolls)
+    if S.get("vinyl"):
+        crack = (rng.random(N) > 0.9993) * rng.standard_normal(N) * 0.3
+        m += lp(crack + 0.004 * rng.standard_normal(N), 4000)
+    m = m[: int(dur * SR)]
+    t = np.arange(len(m)) / SR
+    m *= np.clip(t / 0.6, 0, 1) * np.clip((dur - 0.2 - t) / 1.2, 0, 1)
+    return m / (np.abs(m).max() + 1e-9)
+
+# ---- sfx ----
+def whoosh(rng, d=0.35):
+    n = int(d * SR); x = rng.standard_normal(n)
+    a = lp(x, 900); b = lp(x, 3500); k = np.linspace(0, 1, n)
+    return (a * (1 - k) + b * k) * np.sin(np.linspace(0, np.pi, n)) ** 2
+def pop(f0=500, f1=1100, d=0.12):
+    n = int(d * SR); f = np.linspace(f0, f1, n)
+    return np.sin(2 * np.pi * np.cumsum(f) / SR) * dec(n, d / 3, 0.002)
+def tick(d=0.03):
+    n = int(d * SR); t = np.arange(n) / SR; return np.sin(2 * np.pi * 2200 * t) * np.exp(-t * 120)
+def glitch(rng):
+    x = np.zeros(int(0.25 * SR))
+    for i in range(6):
+        add(x, 0.6 * pop(rng.uniform(300, 1600), rng.uniform(200, 900), 0.03), i * 0.035)
+    return x
+
+def musica_de(vid, m, dur, N):
+    """m = None (sin música) | {"estilo": "lofi"} (generada) | {"archivo", "volumen", "inicio"} (la tuya)."""
+    if not m: return np.zeros(N)
+    if m.get("estilo"):
+        if m["estilo"] not in STYLES: raise SystemExit(f"Música desconocida: {m['estilo']!r}. Opciones: {', '.join(STYLES)}")
+        return make_music(m["estilo"], dur, seed=sum(map(ord, vid)))
+    from preparar import leer_audio
+    import pyloudnorm as pyln
+    x = leer_audio(m["archivo"], SR)[int(float(m.get("inicio", 0)) * SR):]
+    if not len(x): raise SystemExit(f"La música {m['archivo']} está vacía (¿inicio mayor que su duración?)")
+    try:
+        lufs = pyln.Meter(SR).integrated_loudness(x)
+        if np.isfinite(lufs): x = x * 10 ** ((-23 - lufs) / 20)  # nivel de fondo parejo, se ajusta con `volumen`
+    except ValueError: pass  # pista muy corta para medir: se usa tal cual
+    x = np.tile(x, int(np.ceil(N / len(x))))[:N] * float(m.get("volumen", 1))
+    fi, fo = int(0.3 * SR), int(1.2 * SR)
+    x[:fi] *= np.linspace(0, 1, fi); x[-fo:] *= np.linspace(1, 0, fo)
+    return x / 0.22  # mix() la multiplica por 0.22 como a la generada
+
+
+def efecto(nombre, rng):
+    """Efectos para el motor de capas: pop, whoosh, tick, glitch, ding."""
+    if nombre == "whoosh": return 0.18 * whoosh(rng)
+    if nombre == "tick": return 0.4 * tick()
+    if nombre == "glitch": return 0.3 * glitch(rng)
+    if nombre == "ding": return 0.2 * bell(nf(88), 0.8)
+    return 0.14 * pop()
+
+
+def capas_con_sonido(sp):
+    """Capas de la escena (y de sus grupos) que piden un efecto de sonido."""
+    out, pila = [], list(sp.get("capas") or [])
+    while pila:
+        c = pila.pop(0)
+        if not isinstance(c, dict): continue
+        if c.get("sonido"): out.append(c)
+        pila.extend(c.get("capas") or [])
+    return out
+
+
+def mix(vid, style, outdir, TIM, SPEC, durs, ev):
+    """Mezcla voz + música (con ducking) + efectos y escribe mix.wav. style=None: sin música."""
+    dur = sum(durs); N = int(dur * SR); rng = np.random.default_rng(11)
+    music = musica_de(vid, style, dur, N)
+    sfx = np.zeros(N)
+    for si, (m, sp) in enumerate(zip(TIM, SPEC)):
+        t0 = m["t0"]; ty = sp["type"]
+        if si and sp.get("transicion", "auto") != "corte": add(sfx, 0.18 * whoosh(rng), t0 - 0.12)
+        if ty in ("title", "text", "icon", "year", "aliens", "memory"): add(sfx, 0.13 * pop(), t0 + 0.3)
+        if ty == "compare": add(sfx, 0.16 * pop(600, 1500, 0.2), t0 + ev(si, sp["at"]) - 0.2)
+        if ty == "card": add(sfx, 0.35 * glitch(rng), t0 + ev(si, sp["at"]))
+        if ty == "dialog":
+            tc = t0 + ev(si, sp["click"]) - 0.15; add(sfx, 0.4 * tick(), tc); add(sfx, 0.13 * pop(700, 1400), tc + 0.1)
+        if ty == "morph": add(sfx, 0.12 * pop(300, 900, 0.8), t0 + ev(si, sp["at"]) - 0.1)
+        if ty == "text" and sp.get("strike"):
+            for i in range(len(sp["rows"])): add(sfx, 0.2 * whoosh(rng, 0.15), t0 + m["speech"] * 0.55 + i * 0.12)
+        if ty == "cta": add(sfx, 0.4 * tick(), t0 + 1.6)
+        # motor de capas: cada capa (o grupo) con "sonido" suena cuando entra
+        for capa in capas_con_sonido(sp):
+            cuando = capa.get("en", 0.3)
+            tc = t0 + (ev(si, cuando) if isinstance(cuando, str) else float(cuando))
+            add(sfx, efecto(capa["sonido"], rng), tc)
+    voice, _ = sf.read(os.path.join(outdir, "voz.wav"))
+    voice = resample_poly(voice, 147, 80)
+    v = np.zeros(N); v[: min(N, len(voice))] = voice[:N]
+    w = int(0.15 * SR); envv = np.convolve(np.abs(v), np.ones(w) / w, mode="same")
+    music *= 1 - 0.6 * np.clip(envv / 0.05, 0, 1)
+    out = 1.3 * v + 0.22 * music + 0.6 * sfx
+    out = np.tanh(out * 1.1) * 0.89
+    sf.write(os.path.join(outdir, "mix.wav"), np.stack([out, out], 1).astype(np.float32), SR)