Agregar pestaña Libros analizados

app.py

@@ -1,425 +1,1121 @@
-# -*- coding: utf-8 -*-
-"""
-Centralita Torá — HuggingFace Space (Gradio)
-Leer hebreo + español · escuchar (Canto Gregoriano-Hebraico con Voz Divina Especial)
-"""
-import os, glob, json, tempfile, html, asyncio, subprocess, shutil, re
-import urllib.request
-import gradio as gr
-import edge_tts
+import os, time, json, glob, random, asyncio, base64
+from fastapi import FastAPI, Request, UploadFile, File
+from fastapi.responses import HTMLResponse, JSONResponse, FileResponse
+from groq import Groq
+import edge_tts, requests
+
+# Servicio Veo independiente (con cascada a Leonardo.ai)
 try:
-    from gtts import gTTS
+    from veo_service import generar_clips_escenas as generar_runway
 except Exception:
-    gTTS = None
-
-from gradio_theme_fenix import fenix_theme, FENIX_CSS
-
-# --- CONFIGURACIÓN DE VOZ Y CANTO ---
-CANTO_GREGORIANO_HEBRAICO = True
-
-VOZ_DIVINA = "es-ES-AlvaroNeural"
-VOZ_NARRADOR = "es-ES-AlvaroNeural"  # Usamos Álvaro con procesamiento acústico sagrado especial
-
-VOZ_HE = "he-IL-AvriNeural"
-
-# Perillas de entonación para Narrador
-VOZ_RATE = "-10%"
-VOZ_PITCH = "+5Hz"
-
-# Fondo musical
-FONDO = "fondo.mp3"
-FONDO_VOL = 0.18
-
-# IA de Estudio (Groq)
-MODELO_ESTUDIA = "openai/gpt-oss-120b"
-CARPETA = "libros"
-GROQ_URL = "https://api.groq.com/openai/v1/chat/completions"
-GROQ_KEY = os.environ.get("GROQ_API_KEY")
-
-
-# --- MOTOR FONÉTICO GREGORIANO-HEBRAICO ---
-def transformar_a_canto_gregoriano_hebraico(texto_sagrado: str) -> str:
-    if not texto_sagrado:
-        return ""
-
-    texto = texto_sagrado
-
-    # Melismas gregorianos en vocales tónicas
-    melismas = {
-        'á': 'a-a-a-a', 'é': 'e-e-e-e', 'í': 'i-i-i-i',
-        'ó': 'o-o-o-o', 'ú': 'u-u-u-u',
-        'Á': 'A-a-a-a', 'É': 'E-e-e-e', 'Í': 'I-i-i-i',
-        'Ó': 'O-o-o-o', 'Ú': 'U-u-u-u',
-    }
-    for vocal_con_tilde, melisma in melismas.items():
-        texto = texto.replace(vocal_con_tilde, melisma)
-
-    # Cierres litúrgicos
-    def cierre_liturgico(match):
-        vocal = match.group(1)
-        puntuacion = match.group(2)
-        return f"{vocal}-{vocal}-{vocal}{puntuacion} ... "
-
-    texto = re.sub(r'([aeiouAEIOU])([,.:;])', cierre_liturgico, texto)
-
-    # Énfasis místico
-    texto = re.sub(r'\bDios\b', 'Di-o-o-os', texto, flags=re.IGNORECASE)
-    texto = re.sub(r'\bSeñor\b', 'Se-ñoo-or', texto, flags=re.IGNORECASE)
-    texto = re.sub(r'\bIsrael\b', 'Is-ra-e-el', texto, flags=re.IGNORECASE)
-
-    return texto
-
-
-# --- PROCESAMIENTO ACÚSTICO FFMEPG ---
-def procesar_audio_narrador(ruta):
-    """Efecto catedral estándar para el narrador."""
-    if not shutil.which("ffmpeg"):
-        return ruta
-
-    filtros = [
-        "atempo=0.22",
-        "bass=g=8:f=133",
-        "treble=g=-22",
-        "vibrato=f=3.5:d=0.55",
-        "aecho=0.75:0.70:120|240:0.4|0.25"
-    ]
-    salida = ruta[:-4] + "_narrador.mp3"
-    cmd = ["ffmpeg", "-y", "-i", ruta, "-af", ", ".join(filtros), "-ac", "2", salida]
+    def generar_runway(escenas): return None
+try:
+    from leonardo_service import generar_clips_escenas as generar_leonardo
+except Exception:
+    def generar_leonardo(escenas): return None
+try:
+    from ltx_service import generar_clips_escenas as generar_ltx
+except Exception:
+    def generar_ltx(escenas): return None
+def generar_clips_escenas(escenas, nicho="espiritualidad", motor="auto"):
+    import copy
+    if motor == "ltx":
+        res = generar_ltx(copy.deepcopy(escenas), nicho=nicho)
+        if res and any(str(e.get("material", "")).startswith("ltx_") for e in res): return res
+        print("[Cerebro] LTX elegido pero fallo.", flush=True); return escenas
+    if motor == "veo":
+        res = generar_runway(copy.deepcopy(escenas))
+        if res and any(str(e.get("material", "")).startswith("veo_") for e in res): return res
+        print("[Cerebro] Veo elegido pero fallo.", flush=True); return escenas
+    if motor == "leonardo":
+        res_leo = generar_leonardo(copy.deepcopy(escenas))
+        return res_leo if res_leo else escenas
+    res = generar_ltx(copy.deepcopy(escenas), nicho=nicho)
+    if res and any(str(e.get("material", "")).startswith("ltx_") for e in res): return res
+    print("[Cerebro] LTX no disponible. Saltando a Runway...", flush=True)
+    res = generar_runway(copy.deepcopy(escenas))
+    if res and any(str(e.get("material", "")).startswith("veo_") for e in res): return res
+    print("[Cerebro] Saltando a Leonardo.ai...", flush=True)
+    res_leo = generar_leonardo(copy.deepcopy(escenas))
+    return res_leo if res_leo else escenas
+
+app = FastAPI()
+
+GROQ_KEYS = [k for k in [os.environ.get("GROQ_KEY",""), os.environ.get("GROQ_KEY_2",""), os.environ.get("GROQ_KEY_3","")] if k]
+
+CLAVE_ACCESO = os.environ.get("CLAVE_ACCESO", "demo2026")
+
+def verificar_clave(clave):
+    return clave == CLAVE_ACCESO
+
+PEXELS_KEY = os.environ.get("PEXELS_KEY","")
+
+# Estado de la sesion (guarda guion editado y material entre pasos)
+ESTADO = {
+    "guion": "",
+    "archivos": [],
+    "voz_lista": False,
+    "video_listo": False,
+}
+
+ESTILOS = {
+    "narrativo": "narrativo y emocional, como contando una historia",
+    "educativo": "educativo y claro, explicando con autoridad",
+    "motivador": "motivador e inspirador, que mueva a la accion",
+    "publicitario": "publicitario y persuasivo, vendiendo sin parecer venta",
+    "misterio": "intrigante y de misterio, con ganchos de curiosidad",
+}
+
+VOCES = {
+    "es": {
+        "masculina": ["es-ES-AlvaroNeural","es-MX-JorgeNeural","es-AR-TomasNeural","es-CO-GonzaloNeural"],
+        "femenina": ["es-ES-ElviraNeural","es-MX-DaliaNeural","es-AR-ElenaNeural","es-CO-SalomeNeural"],
+    },
+    "en": {"masculina":["en-US-GuyNeural","en-GB-RyanNeural"],"femenina":["en-US-JennyNeural","en-GB-SoniaNeural"]},
+}
+
+def log(m): print(m, flush=True)
+
+# Detecta la marca "Veo" en la esquina abajo-derecha y la tapa con el logo de Teshua.
+# Si falla, devuelve el clip original (nunca rompe el montaje).
+def quitar_marca_meta(path, _cache={}):
+    exts_v = (".mp4",".mov",".webm",".avi",".mkv")
+    exts_i = (".jpg",".jpeg",".png",".webp")
+    low = str(path).lower()
+    if not low.endswith(exts_v + exts_i):
+        return path
+    if path in _cache:
+        return _cache[path]
     try:
-        subprocess.run(cmd, check=True, capture_output=True, timeout=60)
-        if os.path.getsize(salida) > 0:
-            return salida
-    except Exception:
-        pass
-    return ruta
-
-
-def procesar_audio_divino(ruta):
-    """
-    Efecto ACÚSTICO SAGRADO Y PROFUNDO para la Voz de Dios.
-    Tono más grave, resonancia sub-bass, eco más amplio y pureza vocal.
-    """
-    if not shutil.which("ffmpeg"):
-        return ruta
-
-    filtros = [
-        "atempo=0.80",                         # Más pausado y solemne
-        "asetrate=44100*0.45",                  # Bajar tono (más grave y imponente)
-        "aresample=144000",                      # Reajustar sample rate
-        "bass=g=15:f=200",                     # Graves profundos sub-bass
-        "treble=g=-10",                        # Sonido cálido, sin aristas agudas
-         
-    ]
-    salida = ruta[:-4] + "_divino.mp3"
-    cmd = ["ffmpeg", "-y", "-i", ruta, "-af", ", ".join(filtros), "-ac", "2", salida]
+        import subprocess
+        dims = subprocess.run(
+            ["ffprobe","-v","error","-select_streams","v:0",
+             "-show_entries","stream=width,height","-of","csv=p=0:s=x", path],
+            capture_output=True, text=True).stdout.strip()
+        W, H = [int(v) for v in dims.split("x")[:2]]
+        # Tapar marca "Veo" (banda negra abajo-derecha) con "Teshua" dorado
+        es_video = low.endswith(exts_v)
+        salida = path + ("_clean.mp4" if es_video else "_clean.png")
+        fs = max(22, int(H * 0.030))
+        pad = int(fs * 0.5)
+        # Caja: 22% ancho, 6% alto, pegada abajo-derecha con margen de 1%
+        bx = W - int(W * 0.23)
+        by = H - int(H * 0.065)
+        bw = int(W * 0.22)
+        bh = int(H * 0.060)
+        # Texto centrado dentro de la caja (coordenadas fijas, no variables ffmpeg)
+        tx = bx + int(bw * 0.08)
+        ty = by + int(bh * 0.20)
+        # 1) Caja negra que tapa "Veo" completamente
+        # 2) Borde dorado alrededor
+        # 3) Texto "Teshua" dorado encima, bien posicionado dentro de la caja
+        vf = (
+            f"drawbox=x={bx}:y={by}:w={bw}:h={bh}:color=black@1:t=fill,"
+            f"drawbox=x={bx}:y={by}:w={bw}:h={bh}:color=0xFFD700@1:t=2,"
+            f"drawtext=text='Teshua':fontsize={fs}:fontcolor=0xFFD700:x={tx}:y={ty}:font=serif:borderw=2:bordercolor=black"
+        )
+        cmd = ["ffmpeg","-y","-v","error","-i",path,"-vf",vf]
+        cmd += (["-c:a","copy",salida] if es_video else [salida])
+        result = subprocess.run(cmd, capture_output=True, text=True)
+        if result.returncode != 0:
+            log(f"marca ffmpeg error: {result.stderr[:300]}")
+        if os.path.exists(salida) and os.path.getsize(salida) > 0:
+            log(f"marca: {os.path.basename(path)} -> {os.path.basename(salida)} (logo={'si' if os.path.exists('logo.png') else 'no'})")
+            _cache[path] = salida; return salida
+    except Exception as e:
+        log(f"marca error: {e}")
+    _cache[path] = path
+    return path
+
+# ========== GUION ==========
+def generar_guion(texto_base, estilo, duracion=60):
+    estilo_desc = ESTILOS.get(estilo, ESTILOS["narrativo"])
+    palabras = int(duracion * 2.4)
+    last_err = None
+    MODELOS = ["llama-3.3-70b-versatile", "llama-3.1-8b-instant", "openai/gpt-oss-120b", "openai/gpt-oss-20b"]
+    prompt = f"Basandote en este contenido:\n\n{texto_base}\n\nEscribe SOLO el texto a narrar en un video de {duracion} segundos (aproximadamente {palabras} palabras, IMPORTANTE: debe ser largo si la duracion es alta). Estilo: {estilo_desc}. Usa psicologia de retencion: gancho fuerte en los primeros 3 segundos, desarrollo con curiosidad, cierre con llamada a la accion. NO incluyas indicaciones tipo narrador, voz en off, intro, outro. Solo el texto a leer, sin simbolos, sin hashtags, sin emojis."
+    # Probar cada modelo con cada key hasta que uno funcione
+    for modelo in MODELOS:
+        for k in GROQ_KEYS:
+            try:
+                client = Groq(api_key=k)
+                res = client.chat.completions.create(
+                    messages=[{"role":"user","content":prompt}],
+                    model=modelo, temperature=0.85
+                )
+                return res.choices[0].message.content.strip()
+            except Exception as e:
+                last_err = e
+                if "rate_limit" in str(e).lower() or "429" in str(e): continue
+                if "model" in str(e).lower() or "decommission" in str(e).lower(): break
+                continue
+    raise last_err if last_err else Exception("Sin keys Groq")
+
+
+def prompt_visual_auto(texto_escena):
+    if not texto_escena or not texto_escena.strip():
+        texto_escena = "cinematic atmospheric scene"
+    instruccion = (
+        "Eres un director de fotografia escribiendo el prompt para un modelo de video por IA (LTX). "
+        "Crea UN solo prompt en INGLES, fotorrealista y cinematografico, que ilustre la frase de abajo. "
+        "Escribelo como UNA descripcion fluida y en orden cronologico: "
+        "primero el plano y el encuadre, luego el sujeto y el entorno con detalle concreto, "
+        "luego la luz, el color y la atmosfera, y por ultimo UN movimiento de camara LENTO y SUAVE "
+        "(un push-in lento, una deriva suave, un tilt ascendente) mas algun movimiento de la escena "
+        "tambien lento y simple (la luz que cambia, particulas que flotan, niebla que se desplaza). "
+        "REGLA CLAVE para que el video no se deforme: el movimiento debe ser lento, continuo y simple; "
+        "NADA de movimiento rapido, accion compleja, ni personas con gestos detallados de manos o cara. "
+        "REGLA DE LUZ: la escena SIEMPRE claramente iluminada, con una fuente de luz visible "
+        "(luz de luna, horizonte que brilla, rayos de sol, estrellas, una vela); "
+        "NUNCA negro total ni infraexpuesto, el cuadro debe verse con claridad. "
+        "Entre 60 y 110 palabras, concreto, sin contradicciones, sin listas, sin numeros, sin comillas. "
+        "Solo el prompt en ingles. Frase: " + texto_escena)
+    for modelo in ["llama-3.1-8b-instant", "llama-3.3-70b-versatile"]:
+        for k in GROQ_KEYS:
+            try:
+                client = Groq(api_key=k)
+                res = client.chat.completions.create(
+                    messages=[{"role":"user","content":instruccion}], model=modelo, temperature=0.8)
+                return res.choices[0].message.content.strip().strip('"')
+            except Exception as e:
+                if "rate_limit" in str(e).lower() or "429" in str(e): continue
+                if "model" in str(e).lower() or "decommission" in str(e).lower(): break
+                continue
+    return texto_escena
+
+# ========== VOZ ==========
+async def generar_voz(guion, idioma="es", genero="masculina", pais=""):
+    voces = VOCES.get(idioma, VOCES["es"]).get(genero, ["es-ES-AlvaroNeural"])
+    if pais:
+        cods = {"españa":"ES","mexico":"MX","argentina":"AR","colombia":"CO","usa":"US","uk":"GB","australia":"AU"}
+        cod = cods.get(pais.lower(),"")
+        if cod:
+            filt = [v for v in voces if f"-{cod}-" in v]
+            if filt: voces = filt
+    voz_sel = random.choice(voces)
+    await edge_tts.Communicate(guion, voz_sel).save("voz.mp3")
+    return voz_sel
+
+# ========== VIDEO ==========
+def montar_video(guion, archivos, subs=None, efecto="ninguno", material_escenas=None, escenas_data=None):
+    subs = subs or {}
+    material_escenas = material_escenas or []
+    escenas_data = escenas_data or []
+    from moviepy.editor import AudioFileClip as AC, VideoFileClip as VC, ImageClip as IC, TextClip, CompositeVideoClip, concatenate_videoclips
+    from PIL import Image as PILImage, ImageFilter as PIF, ImageFile
+    ImageFile.LOAD_TRUNCATED_IMAGES = True
+
+    voz = AC("voz.mp3")
+    # Si el usuario asigno material por escena, usar ESE orden; si no, los archivos normales
+    if material_escenas:
+        fondos = [m + "_clean.mp4" if os.path.exists(m + "_clean.mp4") else m for m in material_escenas if os.path.exists(m) or os.path.exists(m + "_clean.mp4")]
+    else:
+        fondos = []
+    # Respaldo: si no hay fondos de escenas validos, usar el material general
+    if not fondos:
+        fondos = archivos[:8] if archivos else []
+
+    # Si no hay material propio, fondo de Pexels
+        raise Exception("[Fenix Error] Leonardo AI fallo o no tiene saldo, y Pexels esta desactivado.")
+
+    # === QUITAR MARCA "Meta AI" de cada clip de video antes de montar ===
+    fondos = [quitar_marca_meta(f) for f in fondos]
+    if material_escenas:
+        material_escenas = [quitar_marca_meta(m) if not str(m).endswith("_norm.mp4") else m for m in material_escenas]
+    if escenas_data:
+        escenas_data = [(quitar_marca_meta(m) if m and not str(m).endswith("_norm.mp4") else m, s) for m, s in escenas_data]
+
+    # Duracion: si hay escenas con segundos definidos, usar la SUMA; si no, la voz
+    if escenas_data:
+        suma_seg = sum(s for m,s in escenas_data)
+        dur_total = min(suma_seg, 1200) if suma_seg > 0 else min(voz.duration, 1200)
+    else:
+        dur_total = min(voz.duration, 1200)
+
+    # Si el material son SOLO videos, usar el video entero de fondo (no trocear)
+    solo_videos = fondos and all(str(f).lower().endswith((".mp4",".mov",".webm",".avi",".mkv")) for f in fondos)
+    if solo_videos:
+        from moviepy.editor import concatenate_videoclips as _ccv
+        vclips = []
+        for fp in fondos:
+            try:
+                vc = VC(fp).without_audio()
+                vc = vc.resize(height=1920) if vc.w/vc.h > 1080/1920 else vc.resize(width=1080)
+                vc = vc.crop(x_center=vc.w/2, y_center=vc.h/2, width=1080, height=1920)
+                vclips.append(vc)
+            except Exception as e:
+                log(f"Error video {fp}: {e}")
+        if vclips:
+            base = _ccv(vclips, method="compose") if len(vclips) > 1 else vclips[0]
+            # Repetir el video en bucle hasta cubrir toda la duracion (sin negro)
+            if base.duration < dur_total:
+                from moviepy.editor import concatenate_videoclips as _ccloop
+                repes = []
+                acumulado = 0
+                while acumulado < dur_total:
+                    repes.append(base)
+                    acumulado += base.duration
+                base = _ccloop(repes, method="compose").subclip(0, dur_total)
+            else:
+                base = base.subclip(0, dur_total)
+            clip = base
+            voz = voz.subclip(0, min(dur_total, voz.duration))
+            _USAR_VIDEO_ENTERO = True
+        else:
+            _USAR_VIDEO_ENTERO = False
+    else:
+        _USAR_VIDEO_ENTERO = False
+
+    num_planos = max(int(dur_total / 4) + 1, len(fondos))
+    fondos_loop = (fondos * ((num_planos // max(len(fondos),1)) + 1))[:num_planos]
+    dur_clip = dur_total / num_planos
+    # Si hay escenas con segundos, cada clip dura SUS segundos
+    # Solo usar segundos por escena si hay material asignado en las escenas
+    material_en_escenas = [(m,s) for m,s in escenas_data if m and os.path.exists(m)]
+    usar_seg_escena = bool(material_en_escenas) and not _USAR_VIDEO_ENTERO
+    if usar_seg_escena:
+        fondos_loop = [m for m,s in material_en_escenas]
+        segundos_loop = [s for m,s in material_en_escenas]
+    clips = []
+    idx_clip = -1
+    # EFECTO RAFAGA: las imagenes pasan rapido (0.6s) y se repiten en bucle hasta llenar la voz
+    _es_rafaga = (efecto == "rafaga") and not _USAR_VIDEO_ENTERO
+    if _es_rafaga and fondos_loop:
+        dur_rafaga = 0.2
+        n_necesarias = int(dur_total / dur_rafaga) + 1
+        fondos_loop = [fondos_loop[k % len(fondos_loop)] for k in range(n_necesarias)]
+        segundos_loop = [dur_rafaga for _ in fondos_loop]
+        usar_seg_escena = True
+    for fp in (fondos_loop if not _USAR_VIDEO_ENTERO else []):
+        idx_clip += 1
+        d_este = segundos_loop[idx_clip] if usar_seg_escena and idx_clip < len(segundos_loop) else dur_clip
+        try:
+            if fp.lower().endswith((".jpg",".jpeg",".png",".webp")):
+                img = PILImage.open(fp).convert("RGB")
+                w, h = img.size
+                bg = img.resize((1080,1920), PILImage.LANCZOS).filter(PIF.GaussianBlur(40))
+                ratio = min(1080/w, 1920/h)
+                fg = img.resize((int(w*ratio), int(h*ratio)), PILImage.LANCZOS)
+                bg.paste(fg, ((1080-fg.width)//2, (1920-fg.height)//2))
+                bg.save(fp+"_r.jpg","JPEG",quality=90)
+                ic = IC(fp+"_r.jpg").set_duration(d_este)
+                if efecto in ("zoom","zoom_fundido"):
+                    ic = ic.resize(lambda t: 1 + 0.015*t).set_duration(d_este)
+                ic = ic.set_duration(d_este)
+                clips.append(ic)
+            else:
+                vclip = VC(fp).without_audio()
+                vclip = vclip.resize(height=1920) if vclip.w/vclip.h > 1080/1920 else vclip.resize(width=1080)
+                vclip = vclip.crop(x_center=vclip.w/2, y_center=vclip.h/2, width=1080, height=1920)
+                vclip = vclip.loop(duration=d_este).set_duration(d_este)
+                clips.append(vclip)
+        except Exception as e:
+            log(f"Error clip {fp}: {e}")
+
+    if not _USAR_VIDEO_ENTERO:
+        hay_video = any(str(f).lower().endswith((".mp4",".mov",".webm",".avi")) for f in fondos_loop)
+        if efecto in ("fundido","zoom_fundido") and len(clips) > 1 and not hay_video:
+            from moviepy.editor import concatenate_videoclips as _cc
+            clips_fx = [clips[0]] + [c2.crossfadein(0.5) for c2 in clips[1:]]
+            clip = _cc(clips_fx, method="compose", padding=-0.5)
+        else:
+            clip = concatenate_videoclips(clips, method="compose")
+        # MANUAL (material asignado a escenas): forzar duracion = suma de segundos exacta
+        _es_manual = bool([m for m,s in escenas_data if m and os.path.exists(m)]) if escenas_data else False
+        if _es_manual:
+            suma = sum(s for m,s in escenas_data if m and os.path.exists(m))
+            if clip.duration < suma:
+                # Congelar el ultimo fotograma hasta llegar a la duracion (NO dejar negro)
+                from moviepy.editor import ImageClip as _ICf
+                ultimo = clip.to_ImageClip(t=clip.duration-0.1, duration=suma-clip.duration)
+                from moviepy.editor import concatenate_videoclips as _ccf
+                clip = _ccf([clip, ultimo.set_pos("center")], method="compose")
+            else:
+                clip = clip.subclip(0, suma)
+            dur_total = suma
+        else:
+            # AUTOMATICO: dura lo que suman los clips (va de lujo, no tocar)
+            dur_total = clip.duration
+        voz = voz.subclip(0, min(dur_total, voz.duration))
+
+    import re as _re
+    sub_color = subs.get("color","#FFFFFF")
+    sub_size = {"pequeno":48,"mediano":64,"grande":80}.get(subs.get("tamano","mediano"),64)
+    sub_pos = {"arriba":0.15,"centro":0.5,"abajo":0.78}.get(subs.get("posicion","abajo"),0.78)
+    sub_activo = subs.get("activo",True)
+
+    # --- SUBTITULOS SINCRONIZADOS POR FRASE ---
+    # 1) Cortar respetando frases reales: puntuacion (. ! ? :) y saltos de linea
+    crudo = [s.strip() for s in _re.split(r'(?<=[\.\!\?\:])\s+|\n+', guion) if s.strip()]
+    # 2) Trocear solo las frases largas (max ~7 palabras) SIN mezclar frases distintas
+    segmentos = []
+    for fr in crudo:
+        pal = fr.split()
+        if len(pal) <= 8:
+            segmentos.append(fr)
+        else:
+            for i in range(0, len(pal), 7):
+                segmentos.append(" ".join(pal[i:i+7]))
+    if not segmentos:
+        segmentos = [guion]
+    # 3) Repartir el tiempo PROPORCIONAL a las palabras de cada frase (mejor sincronia)
+    total_pal = sum(max(len(s.split()), 1) for s in segmentos)
+    dur_voz = voz.duration
+    txts = []
+    if sub_activo:
+        t_cursor = 0.0
+        for s in segmentos:
+            d = dur_voz * (max(len(s.split()), 1) / total_pal)
+            txts.append(
+                TextClip(s.upper(), fontsize=sub_size, color=sub_color,
+                    font="/usr/share/fonts/truetype/liberation/LiberationSans-Bold.ttf",
+                    stroke_color="black", stroke_width=2, method="caption", size=(int(clip.w*0.8),None)
+                ).set_start(t_cursor).set_duration(d).set_pos(("center", sub_pos), relative=True)
+            )
+            t_cursor += d
+
+    # Mezclar musica de fondo si el cliente la subio
+    import os as _os
+    audio_final = voz
+    if _os.path.exists("musica.mp3"):
+        try:
+            from moviepy.editor import CompositeAudioClip, AudioFileClip as _AC
+            musica = _AC("musica.mp3").volumex(0.18)
+            dur = voz.duration
+            if musica.duration > dur:
+                musica = musica.subclip(0, dur)
+            elif musica.duration < dur:
+                import math
+                reps = math.ceil(dur / musica.duration)
+                from moviepy.editor import concatenate_audioclips
+                musica = concatenate_audioclips([_AC("musica.mp3").volumex(0.18) for _ in range(reps)]).subclip(0, dur)
+            audio_final = CompositeAudioClip([voz.volumex(1.0), musica])
+        except Exception as _em:
+            log(f"Error mezcla musica: {_em}")
+            audio_final = voz
+    _vid = CompositeVideoClip([clip]+txts)
+    try:
+        _vd = getattr(_vid, "duration", None)
+        _ad = getattr(audio_final, "duration", None)
+        if _vd and _ad:
+            if _ad > _vd + 0.05:
+                # audio mas largo que el video -> recortar
+                audio_final = audio_final.subclip(0, _vd)
+                log(f"[Video] audio recortado a {_vd:.1f}s (era {_ad:.1f}s)")
+            elif _vd > _ad:
+                # video mas largo que el audio -> rellenar con silencio hasta el final
+                from moviepy.editor import CompositeAudioClip as _CAC
+                audio_final = _CAC([audio_final]).set_duration(_vd)
+                log(f"[Video] audio rellenado con silencio a {_vd:.1f}s (era {_ad:.1f}s)")
+            # alinear exacto para que ffmpeg nunca lea fuera de rango
+            audio_final = audio_final.set_duration(_vd)
+    except Exception as _ea:
+        log(f"[Video] ajuste audio: {_ea}")
+    final = _vid.set_audio(audio_final)
     try:
-        subprocess.run(cmd, check=True, capture_output=True, timeout=60)
-        if os.path.getsize(salida) > 0:
-            return salida
+        if getattr(_vid, "duration", None):
+            final = final.set_duration(_vid.duration)
     except Exception:
         pass
-    return ruta
-
-
-def concatenar_audios(lista_rutas):
-    """Concatena varios archivos MP3 en uno solo en orden estricto."""
-    if not lista_rutas:
-        return None
-    if len(lista_rutas) == 1:
-        return lista_rutas[0]
-
-    salida_final = tempfile.NamedTemporaryFile(suffix=".mp3", delete=False).name
-    list_file = tempfile.NamedTemporaryFile(suffix=".txt", mode="w", delete=False, encoding="utf-8")
-    
-    for r in lista_rutas:
-        list_file.write(f"file '{os.path.abspath(r)}'\n")
-    list_file.close()
-
-    cmd = ["ffmpeg", "-y", "-f", "concat", "-safe", "0", "-i", list_file.name, "-c", "copy", salida_final]
+    import os as _os2
+    for _f in ("preview.mp4", "preview_tmp.mp4"):
+        if _os2.path.exists(_f):
+            _os2.remove(_f)
     try:
-        subprocess.run(cmd, check=True, capture_output=True, timeout=120)
-        os.remove(list_file.name)
-        return salida_final
-    except Exception:
-        if os.path.exists(list_file.name):
-            os.remove(list_file.name)
-        return lista_rutas[0]
-
-
-def mezclar_fondo(voz_path):
-    if not (os.path.exists(FONDO) and shutil.which("ffmpeg")):
-        return voz_path
-    salida = voz_path[:-4] + "_mix.mp3"
-    filtro = (f"[1:a]volume={FONDO_VOL}[m];"
-              f"[0:a][m]amix=inputs=2:duration=first:normalize=0[a]")
-    cmd = ["ffmpeg", "-y", "-i", voz_path, "-stream_loop", "-1", "-i", FONDO,
-           "-filter_complex", filtro, "-map", "[a]", salida]
+        final.write_videofile("preview_tmp.mp4", fps=24, codec="libx264", preset="fast", logger=None, threads=4, audio_codec="aac", ffmpeg_params=["-pix_fmt", "yuv420p", "-movflags", "+faststart"])
+    except Exception as _ew:
+        log(f"[Video] write_videofile FALLO: {_ew}")
+        raise
+    if not _os2.path.exists("preview_tmp.mp4"):
+        raise RuntimeError("write_videofile no genero preview_tmp.mp4 (revisa audio/duracion)")
+    _os2.rename("preview_tmp.mp4", "preview.mp4")
+    return "preview.mp4"
+
+# ========== ENDPOINTS ==========
+@app.post("/login")
+async def ep_login(request: Request):
+    d = await request.json()
+    clave = d.get("clave","").strip()
+    if verificar_clave(clave):
+        return {"ok": True}
+    return JSONResponse({"error":"Clave incorrecta"}, status_code=401)
+
+@app.post("/generar-guion")
+async def ep_guion(request: Request):
+    d = await request.json()
+    texto = d.get("texto","").strip()
+    estilo = d.get("estilo","narrativo")
+    duracion = int(d.get("duracion", 60) or 60)
+    parte = d.get("parte","auto")
+    # Si hay PDF completo cargado y el usuario no edito el texto a mano, usar el trozo elegido
+    completo = ESTADO.get("texto_completo","")
+    if completo and len(completo) > 6000:
+        if parte == "principio":
+            texto = completo[:6000]
+        elif parte == "mitad":
+            m = len(completo)//2
+            texto = completo[m-3000:m+3000]
+        elif parte == "final":
+            texto = completo[-6000:]
+        else:  # auto = trozo al azar
+            import random as _r
+            ini = _r.randint(0, max(0, len(completo)-6000))
+            texto = completo[ini:ini+6000]
+    if not texto:
+        return JSONResponse({"error":"Pega tu contenido base primero"}, status_code=400)
     try:
-        subprocess.run(cmd, check=True, capture_output=True, timeout=120)
-        if os.path.getsize(salida) > 0:
-            return salida
-    except Exception:
-        pass
-    return voz_path
-
-
-# --- SEPARACIÓN DE BLOQUES (NARRADOR vs DIOS) ---
-def segmentar_texto_divino(texto):
-    """
-    Detecta patrones como 'Y dijo Dios: ...' o 'Dijo Dios ...'
-    y divide el texto en partes ('narrador' o 'dios').
-    """
-    patron = r'((?:Y\s+dijo\s+Dios|dijo\s+Dios|Y\s+llamó\s+Dios|Y\s+bendijo\s+Dios)[^:,.–—]*[:,.–—]?\s*)([^.\n]+)'
-    bloques = []
-    ultimo_idx = 0
-
-    for match in re.finditer(patron, texto, flags=re.IGNORECASE):
-        start, end = match.span()
-        if start > ultimo_idx:
-            bloques.append(("narrador", texto[ultimo_idx:start]))
-        
-        intro_dios = match.group(1) # Ej: "Y dijo Dios: "
-        palabras_dios = match.group(2) # Ej: "Sea la luz"
-
-        bloques.append(("narrador", intro_dios))
-        bloques.append(("dios", palabras_dios))
-        ultimo_idx = end
-
-    if ultimo_idx < len(texto):
-        bloques.append(("narrador", texto[ultimo_idx:]))
-
-    return bloques if bloques else [("narrador", texto)]
-
-
-# --- GENERACIÓN DE AUDIO DINÁMICA ---
-async def generar_bloque_audio(texto, es_divino):
-    texto_tts = transformar_a_canto_gregoriano_hebraico(texto) if CANTO_GREGORIANO_HEBRAICO else texto
-    ruta = tempfile.NamedTemporaryFile(suffix=".mp3", delete=False).name
-    
-    voz = VOZ_DIVINA if es_divino else VOZ_NARRADOR
-    pitch = "-5Hz" if es_divino else VOZ_PITCH
-    rate = "-9%" if es_divino else VOZ_RATE
+        guion = generar_guion(texto, estilo, duracion)
+        ESTADO["guion"] = guion
+        return {"guion": guion}
+    except Exception as e:
+        return JSONResponse({"error": str(e)[:100]}, status_code=500)
 
+@app.post("/subir-material")
+async def ep_material(file: UploadFile = File(...)):
     try:
-        com = edge_tts.Communicate(texto_tts[:4000], voz, rate=rate, pitch=pitch)
-        await com.save(ruta)
-    except Exception:
-        return None
-
-    if es_divino:
-        return procesar_audio_divino(ruta)
-    else:
-        return procesar_audio_narrador(ruta)
-
-
-async def a_voz(texto, idioma):
-    if not texto or not texto.strip():
-        return None
-
-    if idioma == "he":
-        ruta = tempfile.NamedTemporaryFile(suffix=".mp3", delete=False).name
-        try:
-            com = edge_tts.Communicate(texto[:4000], VOZ_HE, rate=VOZ_RATE, pitch=VOZ_PITCH)
-            await com.save(ruta)
-            return mezclar_fondo(ruta)
-        except Exception:
-            return None
-
-    # Procesamiento para Español con Voz Divina Diferenciada
-    bloques = segmentar_texto_divino(texto)
-    audios_segmentos = []
-
-    for tipo, contenido in bloques:
-        if contenido.strip():
-            es_divino = (tipo == "dios")
-            audio_seg = await generar_bloque_audio(contenido, es_divino)
-            if audio_seg:
-                audios_segmentos.append(audio_seg)
-
-    audio_final = concatenar_audios(audios_segmentos)
-    if audio_final:
-        audio_final = mezclar_fondo(audio_final)
-    
-    return audio_final
-
-
-async def leer_es(t):
-    return await a_voz(t, "es")
-
-
-async def leer_he(t):
-    return await a_voz(t, "he")
-
-
-# --- CARGA Y MANEJO DE LIBROS ---
-def cargar_libros():
-    libros = {}
-    for ruta in sorted(glob.glob(os.path.join(CARPETA, "*.json"))):
-        try:
-            with open(ruta, encoding="utf-8") as f:
-                d = json.load(f)
-            lid = d.get("id") or os.path.splitext(os.path.basename(ruta))[0]
-            libros[lid] = d
-        except Exception as e:
-            print("No pude leer", ruta, e)
-    return libros
-
-
-LIBROS = cargar_libros()
-ORDEN = ["Genesis", "Exodus", "Leviticus", "Numbers", "Deuteronomy"]
-IDS = [i for i in ORDEN if i in LIBROS] + [i for i in LIBROS if i not in ORDEN]
-NOMBRES = [LIBROS[i].get("es", i) for i in IDS] or ["(sube tus libros)"]
-
+        import subprocess as _sp, os as _os
+        ext = file.filename.split(".")[-1].lower()
+        idx = len(ESTADO['archivos'])
+        if ext in ("mp4","mov","webm","avi","mkv","m4v"):
+            crudo = f"crudo_{idx}.{ext}"
+            with open(crudo,"wb") as f:
+                f.write(await file.read())
+            nombre = f"media_{idx}.mp4"
+            # Re-encodear a h264 estandar y fps fijo (arregla grabaciones de pantalla y formatos raros)
+            r = _sp.run(["ffmpeg","-y","-i",crudo,"-r","30","-c:v","libx264","-preset","ultrafast","-pix_fmt","yuv420p","-an",nombre], capture_output=True)
+            if _os.path.exists(nombre) and _os.path.getsize(nombre) > 1000:
+                try: _os.remove(crudo)
+                except: pass
+            else:
+                nombre = crudo
+        else:
+            nombre = f"media_{idx}.{ext}"
+            with open(nombre,"wb") as f:
+                f.write(await file.read())
+        ESTADO["archivos"].append(nombre)
+        return {"ok": True, "total": len(ESTADO["archivos"]), "nombre": nombre}
+    except Exception as e:
+        return JSONResponse({"error": str(e)[:100]}, status_code=500)
+
+@app.post("/generar-voz")
+async def ep_voz(request: Request):
+    d = await request.json()
+    guion = d.get("guion","").strip()
+    if not guion:
+        return JSONResponse({"error":"No hay guion"}, status_code=400)
+    ESTADO["guion"] = guion
+    try:
+        await generar_voz(guion, d.get("idioma","es"), d.get("genero","masculina"), d.get("pais",""))
+        ESTADO["voz_lista"] = True
+        return {"ok": True}
+    except Exception as e:
+        return JSONResponse({"error": str(e)[:100]}, status_code=500)
 
-def id_por_nombre(nombre):
-    for i in IDS:
-        if LIBROS[i].get("es", i) == nombre:
-            return i
-    return IDS[0] if IDS else None
 
+@app.post("/subir-voz-grabada")
+async def ep_voz_grabada(file: UploadFile = File(...)):
+    try:
+        import subprocess
+        contenido = await file.read()
+        with open("voz_grabada_raw","wb") as f:
+            f.write(contenido)
+        # Convertir a mp3 con ffmpeg (el navegador graba en webm/ogg)
+        subprocess.run(["ffmpeg","-y","-i","voz_grabada_raw","-acodec","libmp3lame","voz.mp3"], capture_output=True)
+        import os as _os
+        if _os.path.exists("voz.mp3") and _os.path.getsize("voz.mp3") > 1000:
+            ESTADO["voz_lista"] = True
+            return {"ok": True}
+        return JSONResponse({"error":"No se pudo procesar el audio"}, status_code=500)
+    except Exception as e:
+        return JSONResponse({"error": str(e)[:120]}, status_code=500)
 
-def versiculos(lid, cap):
-    return LIBROS.get(lid, {}).get("capitulos", {}).get(str(cap), [])
 
+@app.post("/subir-musica")
+async def ep_musica(file: UploadFile = File(...)):
+    try:
+        import subprocess, os as _os
+        contenido = await file.read()
+        with open("musica_raw","wb") as f:
+            f.write(contenido)
+        subprocess.run(["ffmpeg","-y","-i","musica_raw","-acodec","libmp3lame","musica.mp3"], capture_output=True)
+        if _os.path.exists("musica.mp3") and _os.path.getsize("musica.mp3") > 1000:
+            ESTADO["musica"] = True
+            return {"ok": True}
+        return JSONResponse({"error":"No se pudo procesar la musica"}, status_code=500)
+    except Exception as e:
+        return JSONResponse({"error": str(e)[:120]}, status_code=500)
 
-def render(nombre, cap):
-    lid = id_por_nombre(nombre)
-    if not lid:
-        return "<div class='pasaje'><p>Aún no has subido libros a la carpeta <b>libros/</b>.</p></div>", "", ""
+@app.post("/generar-musica-ia")
+async def ep_musica_ia(request: Request):
     try:
-        cap = max(1, int(float(cap or 1)))
-    except Exception:
-        cap = 1
-    d = LIBROS[lid]
-    vs = versiculos(lid, cap)
-    if not vs:
-        return f"<div class='pasaje'><p>No hay texto para {html.escape(d.get('es',''))} {cap}.</p></div>", "", ""
-    filas = [f"<div class='cab'><span class='h'>{html.escape(d.get('heb',''))}</span><br>"
-             f"{html.escape(d.get('es',''))} {cap}</div>"]
-    plano_es, plano_he = [], []
-    for v in vs:
-        he = html.escape(v.get("he", "")); es = html.escape(v.get("es", ""))
-        fila = f"<div class='verso'><span class='num'>{v.get('n','')}</span>"
-        if he:
-            fila += f"<span class='he'>{he}</span>"; plano_he.append(v.get("he", ""))
-        if es:
-            fila += f"<span class='es'>{es}</span>"; plano_es.append(v.get("es", ""))
-        fila += "</div>"
-        filas.append(fila)
-    return f"<div class='pasaje'>{''.join(filas)}</div>", " ".join(plano_es), " ".join(plano_he)
-
-
-def estudiar(mensaje, historial, contexto):
-    if not GROQ_KEY:
-        return "Para el estudio, añade el Secret GROQ_API_KEY en el Space."
-    sistema = (
-        "Eres un compañero de estudio de la Torá que responde en español, cálido y honesto. "
-        "Ofreces el sentido literal (peshat), contexto histórico y lingüístico, capas de la "
-        "tradición (midrash, Rashi cuando venga al caso) y reflexión espiritual. Vas al grano.\n\n" + contexto
-    )
-    mensajes = [{"role": "system", "content": sistema}]
-    for m in (historial or []):
-        if isinstance(m, dict) and m.get("role") in ("user", "assistant"):
-            mensajes.append({"role": m["role"], "content": m["content"]})
-    mensajes.append({"role": "user", "content": mensaje})
-    cuerpo = {"model": MODELO_ESTUDIA, "temperature": 0.4, "max_tokens": 1200, "messages": mensajes}
+        d = await request.json()
+        nicho = d.get("nicho", "espiritual")
+        duracion = int(d.get("duracion", 20))
+        url_fabrica = os.environ.get("URL_FABRICA_MUSICA", "").rstrip("/")
+        if not url_fabrica:
+            return JSONResponse({"error": "Secret URL_FABRICA_MUSICA no configurado"}, status_code=500)
+        PROMPTS = {
+            "espiritual": "mystical ambient music, spiritual journey, ethereal choir, no lyrics",
+            "numerologia": "meditative orchestral music, sacred geometry, soft piano and strings",
+            "motivacional": "epic cinematic music, uplifting, orchestral, no vocals",
+            "terror": "dark atmospheric tension, horror underscore, eerie strings",
+            "naturaleza": "peaceful nature sounds, light acoustic guitar, calm",
+            "default": "cinematic background music, neutral mood, no vocals",
+        }
+        prompt = next((v for k, v in PROMPTS.items() if k in nicho.lower()), PROMPTS["default"])
+        from gradio_client import Client
+        client = Client(url_fabrica)
+        ruta = client.predict(prompt, duracion, api_name="/generar_musica")
+        if isinstance(ruta, (list, tuple)) and ruta:
+            ruta = ruta[0]
+        if isinstance(ruta, dict):
+            ruta = ruta.get("path") or ruta.get("name") or ""
+        if not ruta or not os.path.exists(ruta):
+            log(f"[Musica] sin fichero valido: {ruta}")
+            return JSONResponse({"error": "La Fabrica no devolvio audio"}, status_code=500)
+        with open(ruta, "rb") as fi, open("musica.mp3", "wb") as fo:
+            fo.write(fi.read())
+        ESTADO["musica"] = True
+        log(f"[Musica] OK -> {ruta}")
+        return {"ok": True}
+    except Exception as e:
+        log(f"[Musica] ERROR: {e}")
+        return JSONResponse({"error": str(e)[:200]}, status_code=500)
+
+@app.get("/musica-lista")
+def ep_musica_lista():
+    if os.path.exists("musica.mp3"):
+        return {"listo": True, "mtime": os.path.getmtime("musica.mp3")}
+    return {"listo": False, "mtime": 0}
+
+
+@app.get("/audio")
+def ep_audio():
+    if os.path.exists("voz.mp3"):
+        return FileResponse("voz.mp3", media_type="audio/mpeg")
+    return JSONResponse({"error":"sin audio"}, status_code=404)
+
+@app.post("/generar-video")
+async def ep_video(request: Request):
+    d = await request.json()
+    guion = d.get("guion","").strip() or ESTADO["guion"]
+    if not os.path.exists("voz.mp3"):
+        return JSONResponse({"error":"Genera la voz primero"}, status_code=400)
+    subs = {
+        "color": d.get("sub_color","#FFFFFF"),
+        "tamano": d.get("sub_tamano","mediano"),
+        "posicion": d.get("sub_posicion","abajo"),
+        "activo": d.get("sub_activo", True),
+    }
+    efecto = d.get("efecto","ninguno")
+    escenas = d.get("escenas", [])
+    # Modo híbrido: rellenar escenas vacías con clips de Veo
+    if ESTADO["archivos"]:
+        # Si hay archivos subidos, los asignamos a las escenas automáticas
+        for idx, e in enumerate(escenas):
+            mat = str(e.get("material", "")).strip()
+            if not mat or mat == "automático" or mat == "automatico":
+                # Usamos tus archivos de forma circular si hay menos que escenas
+                e["material"] = ESTADO["archivos"][idx % len(ESTADO["archivos"])]
+    if not ESTADO["archivos"]:
+        from nichos import detectar_nicho
+        nicho_detectado = detectar_nicho(guion)
+        print(f"[Fenix] Nicho detectado: {nicho_detectado}", flush=True)
+        for e in escenas:
+            if not e.get("prompt","").strip():
+                e["prompt"] = prompt_visual_auto(e.get("texto","") or e.get("narracion",""))
+                print("[Fenix] Prompt auto generado", flush=True)
+        for e in escenas:
+            if e.get("prompt","").strip() and not e.get("prompt_manual","").strip():
+                e["prompt_manual"] = e["prompt"].strip()
+        motor = d.get("motor","auto")
+        escenas = generar_clips_escenas(escenas, nicho=nicho_detectado, motor=motor)
+    # Lista de (material, segundos) de cada escena, en orden
+    # Pasar el prompt visual del usuario a cada escena para que los servicios lo usen
+    for e in escenas:
+        if e.get("prompt","").strip() and not e.get("prompt_manual","").strip():
+            e["prompt_manual"] = e["prompt"].strip()
+    escenas_data = [(e.get("material",""), int(e.get("segundos",5) or 5)) for e in escenas]
+    material_escenas = [m for m,s in escenas_data if m]
     try:
-        data = json.dumps(cuerpo).encode("utf-8")
-        req = urllib.request.Request(GROQ_URL, data=data, method="POST")
-        req.add_header("Content-Type", "application/json")
-        req.add_header("Authorization", f"Bearer {GROQ_KEY}")
-        with urllib.request.urlopen(req, timeout=90) as r:
-            d = json.load(r)
-        return (d["choices"][0]["message"]["content"] or "").strip()
+        loop = asyncio.get_event_loop()
+        await loop.run_in_executor(None, montar_video, guion, ESTADO["archivos"], subs, efecto, material_escenas, escenas_data)
+        ESTADO["video_listo"] = True
+        return {"ok": True}
     except Exception as e:
-        return f"No pude consultar a la IA ahora mismo ({e})."
-
-
-# ============================ INTERFAZ GRADIO ============================
-with gr.Blocks(theme=fenix_theme(), css=FENIX_CSS, title="Centralita Torá") as demo:
-    st_es = gr.State("")
-    st_he = gr.State("")
-    st_nombre = gr.State(NOMBRES[0])
-    st_cap = gr.State(1)
-
-    gr.HTML("<div id='cabecera'><div class='estrella'>✡</div>"
-            "<h1>Centralita Torá</h1><p>hebreo y español · canto Trope con voz celectial diferenciada</p></div>")
-
-    with gr.Tab("Leer"):
-        with gr.Row():
-            dd = gr.Dropdown(NOMBRES, value=NOMBRES[0], label="Libro")
-            ncap = gr.Number(value=1, precision=0, label="Capítulo", minimum=1)
-        ver_btn = gr.Button("Ver capítulo", variant="primary")
-        salida = gr.HTML()
-        with gr.Row():
-            b_es = gr.Button("🔊 Canto Trope + Voz celectial", variant="secondary")
-            b_he = gr.Button("🔊 עברית (Hebreo)", variant="secondary")
-        audio = gr.Audio(label="Audio Litúrgico", autoplay=True)
-
-        def ver(nombre, cap):
-            md, es, he = render(nombre, cap)
-            return md, es, he, nombre, cap
-
-        ver_btn.click(ver, [dd, ncap], [salida, st_es, st_he, st_nombre, st_cap])
-        b_es.click(leer_es, st_es, audio)
-        b_he.click(leer_he, st_he, audio)
-
-    with gr.Tab("Buscar"):
-        q = gr.Textbox(label="Palabra o frase (hebreo o español)", placeholder="ej. luz  /  אור")
-        q_btn = gr.Button("Buscar", variant="primary")
-        q_out = gr.HTML()
-
-        def buscar(texto):
-            t = (texto or "").strip().lower()
-            if not t:
-                return "<p>Escribe algo para buscar.</p>"
-            filas = []
-            for lid in IDS:
-                d = LIBROS[lid]
-                for c, vs in d.get("capitulos", {}).items():
-                    for v in vs:
-                        campos = " ".join(filter(None, [v.get("es"), v.get("he")])).lower()
-                        if t in campos:
-                            ref = f"{d.get('es', lid)} {c}:{v.get('n')}"
-                            txt = html.escape(v.get("es") or v.get("he") or "")
-                            filas.append(f"<div class='resultado'><span class='ref'>{ref}</span> — {txt}</div>")
-                            if len(filas) >= 120:
-                                return "".join(filas)
-            return "".join(filas) if filas else "<p>Sin resultados en los libros cargados.</p>"
-
-        q_btn.click(buscar, q, q_out)
-
-    with gr.Tab("Estudiar"):
-        gr.Markdown("La IA usa el capítulo abierto en **Leer** como contexto.")
-        chat = gr.Chatbot(type="messages", height=360)
-        pin = gr.Textbox(placeholder="Pregunta sobre el pasaje…", label="")
-        with gr.Row():
-            enviar = gr.Button("Preguntar", variant="primary")
-            comentar = gr.Button("Comentar este capítulo", variant="secondary")
-
-        def responder(mensaje, historial, es, he, nombre, cap):
-            mensaje = (mensaje or "").strip()
-            if not mensaje:
-                return historial, ""
-            contexto = f"Pasaje en pantalla — {nombre} {cap}:\nHebreo: {he}\nEspañol: {es}"
-            r = estudiar(mensaje, historial, contexto)
-            historial = (historial or []) + [
-                {"role": "user", "content": mensaje},
-                {"role": "assistant", "content": r},
-            ]
-            return historial, ""
-
-        enviar.click(responder, [pin, chat, st_es, st_he, st_nombre, st_cap], [chat, pin])
-        comentar.click(
-            lambda h, es, he, n, c: responder("Comenta y ayúdame a estudiar este capítulo.", h, es, he, n, c),
-            [chat, st_es, st_he, st_nombre, st_cap], [chat, pin],
-        )
-
-    with gr.Tab("Cómo subir"):
-        gr.Markdown(
-            "Sube un JSON por libro a la carpeta `libros/`. Para el estudio, añade el Secret `GROQ_API_KEY`."
-        )
-
-if __name__ == "__main__":
-    demo.launch(ssr_mode=False)
-    
+        import traceback
+        tb = traceback.format_exc()
+        print("ERROR VIDEO:", tb, flush=True)
+        return JSONResponse({"error": str(e)[:300]}, status_code=500)
+
+
+@app.get("/video-listo")
+def ep_video_listo():
+    import os as _os
+    if _os.path.exists("preview.mp4") and _os.path.getsize("preview.mp4") > 5000:
+        return {"listo": True, "mtime": _os.path.getmtime("preview.mp4")}
+    return {"listo": False}
+
+@app.get("/video")
+def ep_video_file():
+    if os.path.exists("preview.mp4"):
+        return FileResponse("preview.mp4", media_type="video/mp4")
+    return JSONResponse({"error":"sin video"}, status_code=404)
+
+@app.post("/reset")
+def ep_reset():
+    for f in glob.glob("media_*")+glob.glob("fondo*")+glob.glob("leonardo_*")+["voz.mp3","preview.mp4","musica.mp3","musica_raw"]:
+        try: os.remove(f)
+        except: pass
+    ESTADO["guion"]=""; ESTADO["archivos"]=[]; ESTADO["voz_lista"]=False; ESTADO["video_listo"]=False
+    return {"ok": True}
+
+@app.post("/subir-pdf")
+async def ep_pdf(file: UploadFile = File(...)):
+    try:
+        contenido = await file.read()
+        with open("temp.pdf","wb") as f:
+            f.write(contenido)
+        from pypdf import PdfReader
+        reader = PdfReader("temp.pdf")
+        texto = ""
+        for pagina in reader.pages:
+            texto += (pagina.extract_text() or "") + "\n"
+        texto = texto.strip()
+        if not texto:
+            return JSONResponse({"error":"El PDF no tiene texto extraible (puede ser escaneado)"}, status_code=400)
+        ESTADO["texto_completo"] = texto
+        # Mostrar preview de los primeros 6000 al usuario
+        return {"ok": True, "texto": texto[:6000], "caracteres": len(texto)}
+    except Exception as e:
+        return JSONResponse({"error": str(e)[:120]}, status_code=500)
+
+# ========== INTERFAZ ==========
+@app.get("/", response_class=HTMLResponse)
+def home():
+    return """<!DOCTYPE html>
+<html lang="es"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
+<title>Fenix Hybrid Engine</title>
+<style>
+*{box-sizing:border-box;margin:0;padding:0}
+body{background:#0a0a0a;color:#fff;font-family:system-ui,sans-serif;padding:20px;max-width:780px;margin:0 auto;line-height:1.5}
+h1{font-size:1.8rem;background:linear-gradient(90deg,#ff6b00,#ffb700);-webkit-background-clip:text;-webkit-text-fill-color:transparent;margin-bottom:4px}
+.sub{color:#888;margin-bottom:24px;font-size:.95rem}
+.fase{background:#111;border:1px solid #222;border-radius:14px;padding:20px;margin-bottom:16px}
+.fase-t{font-size:.8rem;color:#ff8c00;font-weight:700;text-transform:uppercase;letter-spacing:1px;margin-bottom:12px}
+textarea,select,input{width:100%;background:#0a0a0a;color:#fff;border:1px solid #333;border-radius:8px;padding:12px;font-size:.95rem;font-family:inherit;margin-bottom:10px}
+textarea{min-height:90px;resize:vertical}
+button{background:linear-gradient(90deg,#ff6b00,#ffb700);color:#000;border:none;padding:14px 20px;border-radius:8px;font-weight:800;font-size:1rem;cursor:pointer;width:100%;margin-top:6px}
+button:disabled{opacity:.4}
+.btn2{background:#222;color:#fff;border:1px solid #444}
+.msg{font-size:.85rem;margin-top:8px;min-height:18px}
+audio,video{width:100%;margin-top:10px;border-radius:8px}
+.lbl{font-size:.85rem;color:#aaa;margin-bottom:6px;display:block}
+.row{display:flex;gap:8px}.row>*{flex:1}
+.tag{display:inline-block;background:#1a1a1a;color:#ff8c00;padding:2px 10px;border-radius:20px;font-size:.75rem;margin-left:6px}
+
+.spinner{display:inline-block;width:24px;height:24px;border:3px solid #333;border-top:3px solid #ffb700;border-radius:50%;animation:spin 1s linear infinite;vertical-align:middle;margin-right:8px}
+@keyframes spin{0%{transform:rotate(0)}100%{transform:rotate(360deg)}}
+.tick{display:inline-block;width:24px;height:24px;background:#00c853;border-radius:50%;color:#fff;text-align:center;line-height:24px;font-weight:900;margin-right:8px;vertical-align:middle}
+</style></head><body>
+<div id="loginOverlay" style="position:fixed;inset:0;background:#0a0a0a;z-index:9999;display:flex;flex-direction:column;align-items:center;justify-content:center;padding:20px">
+  <div style="font-size:2rem;font-weight:800;background:linear-gradient(90deg,#ff6b00,#ffb700);-webkit-background-clip:text;-webkit-text-fill-color:transparent;margin-bottom:8px">Fenix Hybrid Engine</div>
+  <p style="color:#888;margin-bottom:24px;font-size:.95rem">Introduce tu clave de acceso</p>
+  <input type="password" id="claveInput" placeholder="Clave de acceso" style="width:100%;max-width:300px;background:#111;color:#fff;border:1px solid #333;border-radius:10px;padding:14px;font-size:1rem;margin-bottom:12px" onkeydown="if(event.key==='Enter')hacerLogin()">
+  <button onclick="hacerLogin()" style="width:100%;max-width:300px;background:linear-gradient(135deg,#ff6b00,#ff3d00);color:#fff;border:none;padding:14px;border-radius:10px;font-weight:800;font-size:1rem;cursor:pointer">Entrar</button>
+  <div id="loginMsg" style="color:#ff5252;margin-top:12px;font-size:.9rem;min-height:18px"></div>
+</div>
+<script>
+async function hacerLogin(){
+  var clave=document.getElementById("claveInput").value;
+  var msg=document.getElementById("loginMsg");
+  msg.textContent="Comprobando...";msg.style.color="#ffb700";
+  try{
+    var r=await fetch("/login",{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({clave:clave})});
+    var d=await r.json();
+    if(d.ok){document.getElementById("loginOverlay").style.display="none";}
+    else{msg.textContent="Clave incorrecta";msg.style.color="#ff5252";}
+  }catch(e){msg.textContent="Error";msg.style.color="#ff5252";}
+}
+</script>
+
+<h1>Fenix Hybrid Engine</h1>
+<div class="sub">Motor de produccion asistida. La IA acelera, tu tienes el control.</div>
+<button onclick="var p=document.getElementById('panelAyuda');p.style.display=(p.style.display=='none'||!p.style.display)?'block':'none';" style="background:#ff6b00;color:#fff;border:none;padding:10px 18px;border-radius:8px;font-weight:700;cursor:pointer;margin:10px 0">Como usar (pulsa aqui)</button>
+<div id="panelAyuda" style="display:none;background:#1a1a1a;border:1px solid #ff6b00;border-radius:10px;padding:16px;margin:10px 0;line-height:1.6">
+<b>COMO HACER TU VIDEO (paso a paso):</b><br><br>
+<b>1.</b> Sube un PDF o pega tu texto.<br>
+<b>2.</b> Elige la duracion (15s, 30s, 45s, 1 o 2 min) y el estilo. Pulsa Generar Guion.<br>
+<b>3.</b> Si quieres, edita el guion a tu gusto.<br>
+<b>4.</b> Pulsa Dividir en escenas.<br>
+<b>5.</b> Sube tus imagenes o videos.<br>
+<b>6.</b> Genera la voz. Los segundos de cada escena se ponen SOLOS segun la voz, y abajo veras el total.<br>
+<b>7.</b> Elige color de subtitulos y efecto si quieres.<br>
+<b>8.</b> Pulsa Generar Video y descargalo. Sale perfecto, sin pantalla negra.<br><br>
+<b>DOS MODOS DE MONTAR:</b><br>
+- <b>AUTOMATICO (facil):</b> deja el material en automatico. El sistema reparte las imagenes solo. Ideal para ir rapido.<br>
+- <b>MANUAL (control total):</b> asigna una imagen a cada escena. Tu decides que imagen va en cada parte.<br><br>
+<b>CONSEJO IMPORTANTE:</b> los segundos salen solos al generar la voz, no tienes que calcular nada. Si quieres que una escena dure mas o menos, NO toques los segundos: edita su TEXTO (hazlo mas largo o mas corto) y vuelve a generar la voz. Los segundos se ajustan solos. Asi es mas facil y siempre cuadra.<br>
+</div>
+
+<div class="fase">
+  <div class="fase-t">1. Ingesta de conocimiento</div>
+  <span class="lbl">Sube un PDF (extrae el texto solo) o pega tu contenido:</span>
+  <input type="file" id="pdf" accept=".pdf" onchange="subirPdf()">
+  <div class="msg" id="msgPdf"></div>
+  <textarea id="texto" placeholder="Pega aqui tu base de conocimiento, o sube un PDF arriba..."></textarea>
+  <span class="lbl">Duracion del video:</span>
+  <select id="duracion">
+    <option value="15">15 segundos</option>
+    <option value="30">30 segundos</option>
+    <option value="45">45 segundos</option>
+    <option value="60">1 minuto</option>
+    <option value="120">2 minutos</option>
+  </select>
+  <span class="lbl">Estilo de narrativa:</span>
+  <select id="estilo">
+  <label style="display:block;margin:10px 0 4px">Motor de video:</label>
+    <option value="narrativo">Narrativo y emocional</option>
+    <option value="educativo">Educativo y claro</option>
+    <option value="motivador">Motivador e inspirador</option>
+    <option value="publicitario">Publicitario y persuasivo</option>
+    <option value="misterio">Misterio e intriga</option>
+  </select>
+  <span class="lbl">Motor de video:</span>
+  <select id="motorVideo">
+    <option value="auto">Automatico (LTX - Veo - Leonardo)</option>
+    <option value="ltx">Solo LTX (gratis, mi GPU)</option>
+    <option value="veo">Solo Veo (Google, calidad alta)</option>
+    <option value="leonardo">Solo Leonardo</option>
+  </select>
+  
+  <span class="lbl">Que parte del documento usar (si subiste PDF largo):</span>
+  <select id="parte">
+    <option value="auto">Automatico (trozos al azar, mas variedad)</option>
+    <option value="principio">Principio del documento</option>
+    <option value="mitad">Mitad del documento</option>
+    <option value="final">Final del documento</option>
+  </select>
+  <button onclick="genGuion()">Generar Propuesta de Guion</button>
+  <div class="msg" id="msgGuion"></div>
+</div>
+
+<div class="fase">
+  <div class="fase-t">2. Edicion del guion <span class="tag">control humano</span></div>
+  <span class="lbl">Edita el guion a tu gusto antes de continuar:</span>
+  <textarea id="guion" placeholder="Aqui aparecera el guion generado, editable..."></textarea>
+  <button onclick="dividirEscenas()" style="background:#1565c0;color:#fff;border:none;padding:10px;border-radius:8px;margin-top:8px;width:100%;font-weight:600">Dividir en escenas</button>
+  <div id="escenas" style="margin-top:12px"></div>
+</div>
+
+<div class="fase">
+  <div class="fase-t">3. Tu material</div>
+  <span class="lbl">Sube tus imagenes o videos (uno a uno):</span>
+  <input type="file" id="material" accept="image/*,video/*" multiple onchange="subirMaterial()">
+  <div class="msg" id="msgMaterial">Sin material aun (usara fondos automaticos)</div>
+</div>
+
+<div class="fase">
+  <div class="fase-t">4. Voz</div>
+  <select id="tipoVoz" onchange="cambioVoz()">
+    <option value="ia">Voz IA (automatica)</option>
+    <option value="grabada">Mi voz grabada (con microfono)</option>
+  </select>
+  <div id="vozIA">
+    <div class="row">
+      <select id="genero"><option value="masculina">Voz masculina</option><option value="femenina">Voz femenina</option></select>
+      <select id="pais"><option value="">Acento neutro</option><option value="españa">Espana</option><option value="mexico">Mexico</option><option value="argentina">Argentina</option><option value="colombia">Colombia</option></select>
+    </div>
+    <button class="btn2" onclick="genVoz()">Generar y Pre-escuchar Voz</button>
+  </div>
+  <div id="vozGrabada" style="display:none">
+    <p style="color:#aaa;font-size:.85rem;margin-bottom:8px">Lee el guion de arriba en voz alta y grabate:</p>
+    <button class="btn2" id="btnRec" onclick="toggleRec()">Empezar a grabar</button>
+  </div>
+  <div class="msg" id="msgVoz"></div>
+  <audio id="player" controls style="display:none"></audio>
+  <div style="margin-top:14px;padding-top:14px;border-top:1px solid #222">
+    <span class="lbl">Musica de fondo:</span>
+    <div style="display:flex;gap:10px;margin-bottom:10px;flex-wrap:wrap">
+      <label style="display:flex;align-items:center;gap:6px;cursor:pointer;padding:10px 14px;background:#1a1a1a;border-radius:8px;border:2px solid #333;flex:1" onclick="setModoMusica(\'no\')">
+        <input type="radio" name="modoMusica" value="no" checked style="width:auto;margin:0"> <span>Sin musica</span>
+      </label>
+      <label style="display:flex;align-items:center;gap:6px;cursor:pointer;padding:10px 14px;background:#1a1a1a;border-radius:8px;border:2px solid #333;flex:1" onclick="setModoMusica(\'ia\')">
+        <input type="radio" name="modoMusica" value="ia" style="width:auto;margin:0"> <span>🎵 Musica IA</span>
+      </label>
+      <label style="display:flex;align-items:center;gap:6px;cursor:pointer;padding:10px 14px;background:#1a1a1a;border-radius:8px;border:2px solid #333;flex:1" onclick="setModoMusica(\'subir\')">
+        <input type="radio" name="modoMusica" value="subir" style="width:auto;margin:0"> <span>📁 Subir mi musica</span>
+      </label>
+    </div>
+    <div id="panelMusicaIA" style="display:none">
+      <select id="nichoMusica" style="margin-bottom:8px">
+        <option value="espiritual">Espiritual / Meditacion</option>
+        <option value="motivacional">Motivacional / Epico</option>
+        <option value="numerologia">Numerologia / Mistico</option>
+        <option value="terror">Tension / Terror</option>
+        <option value="naturaleza">Naturaleza / Calma</option>
+      </select>
+      <button class="btn2" onclick="generarMusicaIA()">🎼 Generar Musica con IA</button>
+    </div>
+    <div id="panelMusicaSubir" style="display:none">
+      <input type="file" id="musica" accept="audio/*" onchange="subirMusica()">
+    </div>
+    <div class="msg" id="msgMusica"></div>
+  </div>
+</div>
+
+<div class="fase">
+  <div class="fase-t">5. Subtitulos y Montaje</div>
+  <div class="row">
+    <select id="subActivo"><option value="si">Con subtitulos</option><option value="no">Sin subtitulos</option></select>
+    <select id="subTamano"><option value="pequeno">Pequenos</option><option value="mediano" selected>Medianos</option><option value="grande">Grandes</option></select>
+  </div>
+  <div class="row">
+    <select id="subPosicion"><option value="arriba">Arriba</option><option value="centro">Centro</option><option value="abajo" selected>Abajo</option></select>
+    <select id="subColor"><option value="#FFFFFF">Blanco</option><option value="#C0C0C0">Plata</option><option value="#000000">Negro</option><option value="#FFD700">Dorado</option><option value="#FFFF00">Amarillo</option><option value="#FFA500">Naranja</option><option value="#FF0000">Rojo</option><option value="#FF4081">Rosa</option><option value="#FF00FF">Magenta</option><option value="#00E5FF">Cian</option><option value="#00BFFF">Azul cielo</option><option value="#1565C0">Azul</option><option value="#76FF03">Verde lima</option><option value="#00C853">Verde</option><option value="#9C27B0">Morado</option><option value="#FF6B00">Naranja fuego</option></select>
+  </div>
+  <span class="lbl">Efecto de video:</span>
+  <select id="efecto">
+    <option value="ninguno">Sin efecto (estatico)</option>
+    <option value="zoom">Zoom lento (Ken Burns)</option>
+    <option value="fundido">Fundido suave entre planos</option>
+    <option value="zoom_fundido">Zoom + Fundido (cinematografico)</option>
+    <option value="rafaga">Rafaga rapida (videoclip)</option>
+  </select>
+  <button onclick="genVideo()">Generar Vista Previa del Video</button>
+  <button class="btn2" onclick="cargarVideo()" style="margin-top:8px">Cargar Video (cuando termine)</button>
+  <div class="msg" id="msgVideo"></div>
+  <video id="vid" controls playsinline webkit-playsinline preload="metadata" style="display:none"></video>
+</div>
+
+<div class="fase">
+  <div class="fase-t">6. Publicacion</div>
+  <button onclick="descargar()" style="background:linear-gradient(90deg,#00c853,#64dd17)">Descargar Video</button>
+  <button onclick="nuevoVideo()" style="background:#222;color:#fff;border:1px solid #444;margin-top:8px">Nuevo Video (limpiar todo)</button>
+  <button class="btn2" onclick="subirYt()" style="margin-top:8px">Conectar YouTube y Subir</button>
+  <div class="msg" id="msgPub"></div>
+</div>
+
+<script>
+var ARCHIVOS_SUBIDOS=[];
+async function subirPdf(){
+  var f=document.getElementById("pdf").files[0]; if(!f)return;
+  var m=document.getElementById("msgPdf"); m.textContent="Extrayendo texto...";m.style.color="#ffb700";
+  var fd=new FormData(); fd.append("file",f);
+  var r=await fetch("/subir-pdf",{method:"POST",body:fd}); var d=await r.json();
+  if(d.ok){document.getElementById("texto").value=d.texto;m.textContent="PDF leido: "+d.caracteres+" caracteres";m.style.color="#00c853";}
+  else{m.textContent=d.error;m.style.color="#ff5252";}
+}
+async function genGuion(){
+  var m=document.getElementById("msgGuion");m.textContent="Generando...";m.style.color="#ffb700";
+  var r=await fetch("/generar-guion",{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({texto:document.getElementById("texto").value,estilo:document.getElementById("estilo").value,parte:document.getElementById("parte").value,duracion:document.getElementById("duracion").value})});
+  var d=await r.json();
+  if(d.guion){document.getElementById("guion").value=d.guion;m.textContent="Guion listo. Editalo abajo si quieres.";m.style.color="#00c853";}
+  else{m.textContent=d.error;m.style.color="#ff5252";}
+}
+async function subirMaterial(){
+  var files=document.getElementById("material").files; if(!files.length)return;
+  var m=document.getElementById("msgMaterial");
+  var total=0;
+  for(var i=0;i<files.length;i++){
+    m.textContent="Subiendo "+(i+1)+" de "+files.length+"...";m.style.color="#ffb700";
+    var fd=new FormData(); fd.append("file",files[i]);
+    var r=await fetch("/subir-material",{method:"POST",body:fd}); var d=await r.json();
+    if(d.ok){total=d.total; if(d.nombre){ARCHIVOS_SUBIDOS.push(d.nombre);}}
+  }
+  m.textContent=total+" archivo(s) subido(s) en total";m.style.color="#00c853";
+}
+async function genVoz(){
+  var m=document.getElementById("msgVoz");m.textContent="Generando voz...";m.style.color="#ffb700";
+  var guionFinal=document.getElementById("guion").value;
+  var esc=recolectarEscenas();
+  if(esc.length>0){
+    var textos=[];
+    for(var k=0;k<esc.length;k++){ if(esc[k].texto){textos.push(esc[k].texto);} }
+    if(textos.length>0){guionFinal=textos.join(". ");}
+  }
+  var r=await fetch("/generar-voz",{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({guion:guionFinal,genero:document.getElementById("genero").value,pais:document.getElementById("pais").value})});
+  var d=await r.json();
+  if(d.ok){var p=document.getElementById("player");p.src="/audio?t="+Date.now();p.style.display="block";m.textContent="Voz lista, escuchala:";m.style.color="#00c853";
+    p.onloadedmetadata=function(){ sugerirSegundos(p.duration); };
+  }
+  else{m.textContent=d.error;m.style.color="#ff5252";}
+}
+function sugerirSegundos(durVoz){
+  if(!durVoz||durVoz<1){return;}
+  var items=document.getElementsByClassName("escenaItem");
+  if(items.length==0){return;}
+  // Contar palabras de cada escena y el total
+  var palabrasEsc=[]; var total=0;
+  for(var i=0;i<items.length;i++){
+    var t=items[i].getElementsByClassName("txtEscena")[0];
+    var np=t?t.value.trim().split(" ").filter(function(x){return x.length>0;}).length:1;
+    palabrasEsc.push(np); total+=np;
+  }
+  // Repartir la duracion de la voz segun palabras y rellenar
+  var sumaSeg=0;
+  for(var i=0;i<items.length;i++){
+    var seg=Math.max(1, Math.round(durVoz*(palabrasEsc[i]/total)));
+
+    sumaSeg+=seg;
+    var campo=items[i].getElementsByClassName("segEscena")[0];
+    if(campo){campo.value=seg;}
+  }
+  // Mostrar total abajo
+  var tot=document.getElementById("totalSeg");
+  if(!tot){
+    tot=document.createElement("div");
+    tot.id="totalSeg";
+    tot.style.cssText="background:#1565c0;color:#fff;padding:10px;border-radius:8px;margin-top:10px;font-weight:700;text-align:center";
+    var cont=document.getElementById("escenas");
+    if(cont){cont.appendChild(tot);}
+  }
+  tot.textContent="Total del video: "+sumaSeg+" segundos (voz: "+Math.round(durVoz)+"s). Ajusta si quieres.";
+}
+var pollTimer=null;
+function recolectarEscenas(){
+  var items=document.getElementsByClassName("escenaItem");
+  var lista=[];
+  for(var i=0;i<items.length;i++){
+    var sel=items[i].getElementsByClassName("selMaterial")[0];
+    var mat=sel?sel.value:"";
+    var seg=items[i].getElementsByClassName("segEscena")[0];
+    var segs=seg?parseInt(seg.value):5;
+    if(!segs||segs<1){segs=5;}
+    var txt=items[i].getElementsByClassName("txtEscena")[0];
+    var texto=txt?txt.value:"";
+    var prEl=items[i].getElementsByClassName("promptEscena")[0];
+    var prompt_escena=prEl?prEl.value:"";
+    lista.push({material:mat,segundos:segs,texto:texto,prompt:prompt_escena});
+  }
+  return lista;
+}
+async function genVideo(){
+  var m=document.getElementById("msgVideo");
+  m.innerHTML="<span class=\'spinner\'></span> Montando video...";m.style.color="#ffb700";
+  // Ocultar y vaciar el reproductor viejo: evita dar a play sobre un preview ya borrado
+  var _vold=document.getElementById("vid"); if(_vold){ _vold.pause(); _vold.removeAttribute("src"); _vold.load(); _vold.style.display="none"; }
+  // Lanzar el render sin esperar la respuesta (evita timeout)
+  fetch("/generar-video",{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({
+    guion:document.getElementById("guion").value,
+    sub_activo:document.getElementById("subActivo").value==="si",
+    sub_tamano:document.getElementById("subTamano").value,
+    sub_posicion:document.getElementById("subPosicion").value,
+    sub_color:document.getElementById("subColor").value,
+    efecto:document.getElementById("efecto").value,
+    motor:document.getElementById("motorVideo").value,
+    escenas:recolectarEscenas()
+  })}).catch(e=>{});
+  // Comprobar cada 4 segundos si el video esta listo
+  var inicio=Date.now();
+  if(pollTimer)clearInterval(pollTimer);
+  pollTimer=setInterval(async()=>{
+    try{
+      var r=await fetch("/video-listo?t="+Date.now());var d=await r.json();
+      if(d.listo && d.mtime*1000 > inicio){
+        clearInterval(pollTimer);
+        var u="/video?t="+Date.now();
+        var v=document.getElementById("vid");v.src=u;v.style.display="block";v.load();
+        m.innerHTML="<span class=\'tick\'>✓</span> Video listo! <a href=\'"+u+"\' target=\'_blank\' style=\'display:inline-block;background:#00E5FF;color:#000;padding:10px 18px;border-radius:8px;text-decoration:none;font-weight:800;margin-top:8px\'>▶ VER VIDEO</a>";
+        m.style.color="#00c853";
+      }
+    }catch(e){}
+  },4000);
+}
+async function subirMusica(){
+  var f=document.getElementById("musica").files[0]; if(!f)return;
+  var m=document.getElementById("msgMusica");m.textContent="Subiendo musica...";m.style.color="#ffb700";
+  var fd=new FormData(); fd.append("file",f);
+  var r=await fetch("/subir-musica",{method:"POST",body:fd}); var d=await r.json();
+  if(d.ok){m.textContent="✅ Musica anadida, sonara de fondo";m.style.color="#00c853";}
+  else{m.textContent="❌ "+(d.error||"Error");m.style.color="#ff5252";}
+}
+function cargarVideo(){
+  var u="/video?t="+Date.now();
+  var v=document.getElementById("vid");v.src=u;v.style.display="block";v.load();
+  var m=document.getElementById("msgVideo");
+  m.innerHTML="▶ <a href=\'"+u+"\' target=\'_blank\' style=\'color:#00E5FF;font-weight:800\'>VER VIDEO EN PANTALLA COMPLETA</a>";
+  m.style.color="#00c853";
+}
+async function nuevoVideo(){
+  if(!confirm("Esto borra el material, la voz y el video actual para empezar de cero. Continuar?"))return;
+  try{
+    await fetch("/reset",{method:"POST"});
+    location.reload();
+  }catch(e){alert("Error al limpiar");}
+}
+function setModoMusica(modo){
+  document.getElementById("panelMusicaIA").style.display=modo==="ia"?"block":"none";
+  document.getElementById("panelMusicaSubir").style.display=modo==="subir"?"block":"none";
+}
+async function generarMusicaIA(){
+  var m=document.getElementById("msgMusica");
+  m.innerHTML="<span class='spinner'></span> Generando musica con IA (puede tardar 1-2 min)...";m.style.color="#ffb700";
+  var nicho=document.getElementById("nichoMusica").value;
+  var dur=parseInt(document.getElementById("duracion").value||"20")+5;
+  var inicioMus=Date.now();
+  fetch("/generar-musica-ia",{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({nicho:nicho,duracion:dur})}).catch(function(e){});
+  if(window.musicaTimer)clearInterval(window.musicaTimer);
+  window.musicaTimer=setInterval(async()=>{
+    try{
+      var r=await fetch("/musica-lista?t="+Date.now());var d=await r.json();
+      if(d.listo && d.mtime*1000 > inicioMus){
+        clearInterval(window.musicaTimer);
+        m.textContent="✅ Musica IA lista, sonara de fondo";m.style.color="#00c853";
+      }
+    }catch(e){}
+  },4000);
+}
+function descargar(){var a=document.createElement("a");a.href="/video?t="+Date.now();a.download="video_fenix.mp4";a.click();}
+function dividirEscenas(){
+  var t=document.getElementById("guion").value;
+  var sep=String.fromCharCode(10)+String.fromCharCode(10);
+  var bloques=t.split(sep);
+  var cont=document.getElementById("escenas");
+  var html="";
+  var n=0;
+  for(var i=0;i<bloques.length;i++){
+    var b=bloques[i].trim();
+    if(b==""){continue;}
+    n++;
+    var opciones="<option value=>-- material automatico --</option>";
+    for(var j=0;j<ARCHIVOS_SUBIDOS.length;j++){ opciones+="<option value="+ARCHIVOS_SUBIDOS[j]+">"+ARCHIVOS_SUBIDOS[j]+"</option>"; }
+    html+="<div class=escenaItem style='background:#111;border:1px solid #222;border-radius:10px;padding:12px;margin-bottom:10px'><b>Escena "+n+"</b><br><textarea class=txtEscena style='width:100%;min-height:50px;background:#0a0a0a;color:#fff;border:1px solid #333;border-radius:6px;padding:6px;margin-bottom:6px'>"+b+"</textarea><select class=selMaterial style='width:100%;margin-bottom:6px'>"+opciones+"</select><div style='display:flex;align-items:center;gap:8px;margin-bottom:6px'><input type=number class=segEscena min=1 value=5 style='width:70px;background:#0a0a0a;color:#fff;border:1px solid #333;border-radius:6px;padding:6px'> <span style='color:#aaa;font-size:.85rem'>seg</span></div><textarea class=promptEscena placeholder='Prompt visual para esta escena (opcional)...' style='width:100%;min-height:40px;background:#0a0a0a;color:#fff;border:1px solid #ff6b00;border-radius:6px;padding:6px;font-size:.85rem'></textarea></div>";
+  }
+  if(n==0){html="<div style=color:#888>Separa los parrafos con una linea en blanco</div>";}
+  cont.innerHTML=html;
+}
+async function subirYt(){var m=document.getElementById("msgPub");m.textContent="Conecta tu canal de YouTube para activar la subida automatica";m.style.color="#ffb700";}
+
+function cambioVoz(){
+  var t=document.getElementById("tipoVoz").value;
+  document.getElementById("vozIA").style.display=t==="ia"?"block":"none";
+  document.getElementById("vozGrabada").style.display=t==="grabada"?"block":"none";
+}
+var mediaRec=null, chunks=[], grabando=false;
+async function toggleRec(){
+  var btn=document.getElementById("btnRec"); var m=document.getElementById("msgVoz");
+  if(!grabando){
+    try{
+      var stream=await navigator.mediaDevices.getUserMedia({audio:true});
+      mediaRec=new MediaRecorder(stream); chunks=[];
+      mediaRec.ondataavailable=e=>chunks.push(e.data);
+      mediaRec.onstop=async()=>{
+        var blob=new Blob(chunks,{type:"audio/webm"});
+        m.textContent="Subiendo tu voz...";m.style.color="#ffb700";
+        var fd=new FormData(); fd.append("file",blob,"voz.webm");
+        var r=await fetch("/subir-voz-grabada",{method:"POST",body:fd}); var d=await r.json();
+        if(d.ok){var p=document.getElementById("player");p.src="/audio?t="+Date.now();p.style.display="block";m.textContent="✅ Tu voz lista, escuchala:";m.style.color="#00c853";}
+        else{m.textContent="❌ "+(d.error||"Error");m.style.color="#ff5252";}
+      };
+      mediaRec.start(); grabando=true;
+      btn.textContent="⏹ Detener grabacion"; btn.style.background="#ff4444";
+      m.textContent="Grabando... lee el guion";m.style.color="#ff4444";
+    }catch(e){m.textContent="❌ No se pudo acceder al microfono";m.style.color="#ff5252";}
+  }else{
+    mediaRec.stop(); grabando=false;
+    btn.textContent="Empezar a grabar"; btn.style.background="";
+  }
+}
+</script>
+</body></html>"""