primocode 8.20.1 → 8.22.0

package/lib/studio.js

@@ -42,7 +42,7 @@ const BASE = `http://127.0.0.1:${PORTA}`;
 // voz.py é módulo do servidor, não enfeite: sem ele o server.py não importa
 // e o Studio inteiro deixa de subir. Todo arquivo .py do Studio precisa
 // entrar aqui.
-const COPIAVEIS = new Set(['server.py', 'voz.py', 'web', 'ferramentas', 'README.md', 'PRIMOCODE.md']);
+const COPIAVEIS = new Set(['server.py', 'voz.py', 'elevenlabs.py', 'edge.py', 'web', 'ferramentas', 'README.md', 'PRIMOCODE.md']);
 
 /**
  * Onde está o Python 3 desta máquina.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primocode",
-  "version": "8.20.1",
+  "version": "8.22.0",
   "description": "PrimoCode — agente de engenharia com IA e cursor próprio. Modelos grátis. Cria arquivos, roda comandos, controla navegador e desktop: abre apps, clica em botões e ícones pelo nome, digita e usa atalhos.",
   "main": "bin/primocode.js",
   "bin": {

package/studio/edge.py

@@ -0,0 +1,221 @@
+"""Narração neural grátis, via Edge TTS (vozes online da Microsoft).
+
+── POR QUE ESTE MOTOR EXISTE ─────────────────────────────────────────────
+A corrente de voz tinha um buraco entre o ElevenLabs (premium, com chave e
+cota) e o Google (uma voz só, robótica). No meio ficava o Piper — neural e
+offline, mas que baixa 90 MB e, em Mac ARM, vinha com binário x86 e travava.
+Quando o Piper não sobe, a narração caía direto no Google e o vídeo saía com
+voz de robô.
+
+O Edge TTS preenche esse buraco: são as MESMAS vozes neurais do serviço da
+Microsoft (Antonio, Francisca, Thalita em pt-BR), de graça, SEM chave e SEM
+conta. Precisa de internet — mas quem está gerando vídeo já está online. A
+qualidade fica logo abaixo do ElevenLabs e muito acima do Google.
+
+── COMO ENTRA NA CORRENTE ────────────────────────────────────────────────
+1. ELEVENLABS  premium, se houver chave com crédito.
+2. EDGE TTS    neural, grátis, sem chave.        ← ESTE
+3. PIPER       neural, offline, ilimitado.
+4. VOICEBOX    se o app estiver instalado.
+5. GOOGLE      última reserva; nunca fica mudo.
+
+── SÍNTESE ───────────────────────────────────────────────────────────────
+Rodamos o edge-tts por SUBPROCESSO (`python3 -m edge_tts`), não pela API
+async: o servidor do Studio é stdlib síncrono, e enfiar um event loop dentro
+de uma thread dele é fonte de travamento. O subprocesso é isolado, tem
+timeout de verdade, e devolve o MP3 pronto.
+
+A DURAÇÃO sai das legendas que o próprio edge-tts escreve (`--write-subtitles`):
+o último timestamp do VTT é o fim da fala, medido — não estimado. Com isso a
+cena sabe quanto dura de fato e a linha do tempo fica determinística.
+
+O pacote `edge-tts` não vem no PrimoCode (é pip, não stdlib). Se faltar, este
+motor se declara indisponível e a corrente segue para o Piper — nada trava.
+`instalar()` tenta trazê-lo em segundo plano, uma vez, sem bloquear ninguém.
+"""
+
+import os
+import re
+import subprocess
+import sys
+import tempfile
+import threading
+
+# Catálogo pt-BR do Edge. Só três vozes existem no serviço da Microsoft para
+# português do Brasil; não há por que inventar mais. A padrão é a Antonio,
+# masculina e de locução, que é o registro de abertura de vídeo — a mesma
+# lógica da voz grave padrão do Piper.
+CATALOGO = [
+    {"id": "antonio",   "voz": "pt-BR-AntonioNeural",           "nome": "Antonio",   "genero": "m", "padrao": True},
+    {"id": "francisca", "voz": "pt-BR-FranciscaNeural",         "nome": "Francisca", "genero": "f"},
+    {"id": "thalita",   "voz": "pt-BR-ThalitaMultilingualNeural","nome": "Thalita",  "genero": "f"},
+]
+POR_ID = {v["id"]: v for v in CATALOGO}
+PADRAO = next(v["voz"] for v in CATALOGO if v.get("padrao"))
+
+# Apelidos: as vozes do ElevenLabs que o usuário talvez peça no documento
+# mapeiam para o timbre mais próximo aqui, para o mesmo documento render
+# igual com qualquer motor ativo. Masculinas → Antonio; femininas → Francisca.
+APELIDOS = {
+    "brian": "pt-BR-AntonioNeural", "daniel": "pt-BR-AntonioNeural",
+    "adam": "pt-BR-AntonioNeural",  "bill": "pt-BR-AntonioNeural",
+    "liam": "pt-BR-AntonioNeural",  "jeff": "pt-BR-AntonioNeural",
+    "cadu": "pt-BR-AntonioNeural",  "edresson": "pt-BR-AntonioNeural",
+    "faber": "pt-BR-AntonioNeural",
+    "sarah": "pt-BR-FranciscaNeural", "alice": "pt-BR-FranciscaNeural",
+}
+
+_verificado = None          # cache do disponivel(): None = ainda não checou
+_instalando = False
+_tranca = threading.Lock()
+
+
+def _voz_de(voz_cfg):
+    """Resolve o id/nome pedido no documento para um nome de voz do Edge."""
+    pedido = ""
+    if isinstance(voz_cfg, dict):
+        pedido = str(voz_cfg.get("voz") or "").strip()
+    elif isinstance(voz_cfg, str):
+        pedido = voz_cfg.strip()
+    if not pedido:
+        return PADRAO
+    baixo = pedido.lower()
+    if baixo in POR_ID:
+        return POR_ID[baixo]["voz"]
+    if baixo in APELIDOS:
+        return APELIDOS[baixo]
+    # Nome cru do Edge ("pt-BR-...Neural") passa direto.
+    if re.match(r"^[a-z]{2}-[A-Z]{2}-\w+$", pedido):
+        return pedido
+    return PADRAO
+
+
+def _taxa(velocidade):
+    """velocidade do documento (1.0 = normal) vira o --rate do edge (+N%)."""
+    try:
+        v = float(velocidade)
+    except (TypeError, ValueError):
+        v = 1.0
+    v = max(0.5, min(2.0, v))
+    pct = int(round((v - 1.0) * 100))
+    return ("+%d%%" % pct) if pct >= 0 else ("%d%%" % pct)
+
+
+def disponivel():
+    """O edge-tts está utilizável nesta máquina? Resultado é cacheado: a
+    checagem roda o CLI e não vale repetir a cada narração."""
+    global _verificado
+    if _verificado is not None:
+        return _verificado
+    try:
+        r = subprocess.run(
+            [sys.executable, "-m", "edge_tts", "--help"],
+            stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, timeout=20)
+        _verificado = (r.returncode == 0)
+    except Exception:
+        _verificado = False
+    return _verificado
+
+
+def _rotina_instalar():
+    global _instalando, _verificado
+    try:
+        subprocess.run(
+            [sys.executable, "-m", "pip", "install", "--user", "--quiet", "edge-tts"],
+            stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, timeout=180)
+    except Exception as e:
+        sys.stderr.write("[edge] pip install falhou: %s\n" % e)
+    finally:
+        _verificado = None          # força nova checagem
+        with _tranca:
+            _instalando = False
+
+
+def instalar():
+    """Tenta trazer o pacote em segundo plano, uma vez. Não bloqueia: quem
+    pediu narração agora ouve o próximo motor da corrente, e a partir da
+    próxima vez o Edge já responde."""
+    global _instalando
+    if disponivel():
+        return
+    with _tranca:
+        if _instalando:
+            return
+        _instalando = True
+    threading.Thread(target=_rotina_instalar, daemon=True).start()
+
+
+def _dur_do_vtt(caminho):
+    """Último timestamp do VTT = fim da fala, em segundos. Medido, não
+    estimado. Formato do edge-tts: `HH:MM:SS,mmm --> HH:MM:SS,mmm`."""
+    try:
+        with open(caminho, "r", encoding="utf-8") as fh:
+            texto = fh.read()
+    except OSError:
+        return None
+    fins = re.findall(r"-->\s*(\d\d):(\d\d):(\d\d)[,.](\d\d\d)", texto)
+    if not fins:
+        return None
+    h, m, s, ms = fins[-1]
+    return int(h) * 3600 + int(m) * 60 + int(s) + int(ms) / 1000.0
+
+
+def sintetizar(texto, voz_cfg=None, timeout=90):
+    """O texto vira (mp3_bytes, duracao_em_s). Devolve (None, None) quando o
+    Edge não está disponível ou falha — e NUNCA levanta exceção, para a
+    corrente de voz cair no motor seguinte sem tratamento especial."""
+    if not disponivel():
+        instalar()
+        return None, None
+
+    # Uma fala por vez: quebras viram uma frase só, com respiro de pontuação.
+    limpo = re.sub(r"\s+", " ", str(texto or "")).strip()
+    if not limpo:
+        return None, None
+
+    grave = bool(isinstance(voz_cfg, dict) and voz_cfg.get("grave"))
+    velocidade = (voz_cfg.get("velocidade") if isinstance(voz_cfg, dict) else None) or 1.0
+    voz = _voz_de(voz_cfg)
+    taxa = _taxa(velocidade)
+
+    pasta = tempfile.mkdtemp(prefix="primo-edge-")
+    try:
+        mp3 = os.path.join(pasta, "voz.mp3")
+        vtt = os.path.join(pasta, "voz.vtt")
+        try:
+            r = subprocess.run(
+                [sys.executable, "-m", "edge_tts",
+                 "--voice", voz, "--rate", taxa, "--text", limpo,
+                 "--write-media", mp3, "--write-subtitles", vtt],
+                stdout=subprocess.DEVNULL, stderr=subprocess.PIPE, timeout=timeout)
+        except subprocess.TimeoutExpired:
+            sys.stderr.write("[edge] tempo esgotado (%ss)\n" % timeout)
+            return None, None
+        if r.returncode != 0 or not os.path.exists(mp3) or os.path.getsize(mp3) < 800:
+            msg = (r.stderr or b"").decode("utf-8", "replace")[-200:]
+            sys.stderr.write("[edge] síntese falhou: %s\n" % msg)
+            return None, None
+        with open(mp3, "rb") as fh:
+            dados = fh.read()
+        dur = _dur_do_vtt(vtt)
+        return dados, (round(dur, 2) if dur else None)
+    except Exception as e:
+        sys.stderr.write("[edge] erro inesperado: %s\n" % e)
+        return None, None
+    finally:
+        import shutil
+        shutil.rmtree(pasta, ignore_errors=True)
+
+
+def estado():
+    """O que a interface mostra sobre este motor."""
+    with _tranca:
+        inst = _instalando
+    return {
+        "motor": "edge",
+        "disponivel": disponivel(),
+        "instalando": inst,
+        "precisa_internet": True,
+        "vozes": [{"id": v["id"], "nome": v["nome"], "genero": v["genero"],
+                   "padrao": bool(v.get("padrao"))} for v in CATALOGO],
+    }

package/studio/elevenlabs.py

@@ -0,0 +1,142 @@
+"""Voz ElevenLabs — o topo da corrente de narração, quando há chave.
+
+── POR QUE ELA EXISTE ────────────────────────────────────────────────────
+O usuário ouviu a diferença: a narração que ele aprovou nos vídeos veio do
+ElevenLabs, e nenhum motor local chega perto. Este módulo coloca essa voz
+DENTRO do estúdio: com a chave configurada, toda narração — do player, do
+editor e do pré-render em arquivo — sai neural de verdade. Sem chave, nada
+muda: a corrente continua (Piper → Voicebox → Google) como sempre.
+
+── A CHAVE ───────────────────────────────────────────────────────────────
+Duas formas, nesta ordem:
+  1. variável de ambiente ELEVENLABS_API_KEY
+  2. arquivo ~/.primocode/elevenlabs.key (uma linha, só a chave)
+O endpoint POST /api/voz/elevenlabs grava o arquivo pela interface.
+
+── AS VOZES ──────────────────────────────────────────────────────────────
+Catálogo enxuto das vozes prontas da casa (IDs públicos e estáveis), com
+o timbre descrito honestamente. A padrão é a Brian — grave, de locução —
+porque abertura de vídeo pede peso. Todas falam português no modelo
+multilingual. `doc.voz.voz` escolhe pelo id daqui OU por um voice_id cru
+do ElevenLabs (quem tem voz clonada usa o ID dela direto).
+"""
+
+import json
+import os
+import urllib.request
+
+ARQUIVO_CHAVE = os.path.join(os.path.expanduser("~"), ".primocode", "elevenlabs.key")
+API = "https://api.elevenlabs.io/v1"
+MODELO = "eleven_multilingual_v2"
+# mp3_44100_128 é CBR: a duração sai do tamanho (bytes/16000), sem depender
+# de biblioteca de áudio para ler metadados.
+FORMATO = "mp3_44100_128"
+BYTES_POR_SEGUNDO = 16000.0
+
+CATALOGO = [
+    {"id": "brian",  "nome": "Brian",  "tom": "grave, de locução — é a padrão", "grave": True,
+     "voice_id": "nPczCjzI2devNBz1zQrb"},
+    {"id": "daniel", "nome": "Daniel", "tom": "grave, de noticiário", "grave": True,
+     "voice_id": "onwK4e9ZLuTAKqWW03F9"},
+    {"id": "bill",   "nome": "Bill",   "tom": "maduro, acolhedor",
+     "voice_id": "pqHfZKP75CvOlQylNhV4"},
+    {"id": "liam",   "nome": "Liam",   "tom": "jovem, energia de redes sociais",
+     "voice_id": "TX3LPaxmHKxFdv7VOQHJ"},
+    {"id": "adam",   "nome": "Adam",   "tom": "firme, dominante", "grave": True,
+     "voice_id": "pNInz6obpgDQGcFmaJgB"},
+    {"id": "sarah",  "nome": "Sarah",  "tom": "feminina, suave e profissional",
+     "voice_id": "EXAVITQu4vr4xnSDxMaL"},
+    {"id": "alice",  "nome": "Alice",  "tom": "feminina, clara e confiante",
+     "voice_id": "Xb7hH8MSUJpSbSDYk0k2"},
+]
+POR_ID = {v["id"]: v for v in CATALOGO}
+PADRAO = "brian"
+
+
+def chave():
+    k = (os.environ.get("ELEVENLABS_API_KEY") or "").strip()
+    if k:
+        return k
+    try:
+        with open(ARQUIVO_CHAVE, encoding="utf-8") as fh:
+            return fh.read().strip() or None
+    except OSError:
+        return None
+
+
+def configurado():
+    return bool(chave())
+
+
+def gravar_chave(k):
+    """Grava (ou apaga, com string vazia) a chave da interface."""
+    os.makedirs(os.path.dirname(ARQUIVO_CHAVE), exist_ok=True)
+    k = str(k or "").strip()
+    if not k:
+        try:
+            os.remove(ARQUIVO_CHAVE)
+        except OSError:
+            pass
+        return {"ok": True, "configurado": False}
+    with open(ARQUIVO_CHAVE, "w", encoding="utf-8") as fh:
+        fh.write(k)
+    try:
+        os.chmod(ARQUIVO_CHAVE, 0o600)      # a chave é segredo do usuário
+    except OSError:
+        pass
+    return {"ok": True, "configurado": True}
+
+
+def _voice_id(pedido):
+    """id do catálogo, voice_id cru do ElevenLabs, ou a padrão."""
+    p = str(pedido or "").strip()
+    if p.lower() in POR_ID:
+        return POR_ID[p.lower()]["voice_id"]
+    # voice_id cru: 20 caracteres alfanuméricos é a cara dos IDs deles —
+    # deixa passar qualquer coisa nesse formato (vozes clonadas do usuário).
+    if len(p) >= 16 and p.isalnum():
+        return p
+    return POR_ID[PADRAO]["voice_id"]
+
+
+def sintetizar(texto, voz_cfg=None, timeout=90):
+    """Texto → (bytes de MP3, duração em segundos) — ou (None, None).
+
+    None manda a corrente seguir para o próximo motor; nunca levanta para o
+    chamador, porque narração com um motor a menos ainda é narração.
+    """
+    k = chave()
+    limpo = " ".join(str(texto or "").split())
+    if not k or not limpo:
+        return None, None
+    voz_cfg = voz_cfg if isinstance(voz_cfg, dict) else {}
+    url = "%s/text-to-speech/%s?output_format=%s" % (
+        API, _voice_id(voz_cfg.get("voz")), FORMATO)
+    corpo = json.dumps({
+        "text": limpo[:4900],
+        "model_id": MODELO,
+        "voice_settings": {"stability": 0.5, "similarity_boost": 0.75},
+    }).encode("utf-8")
+    req = urllib.request.Request(url, data=corpo, headers={
+        "xi-api-key": k,
+        "Content-Type": "application/json",
+    })
+    try:
+        with urllib.request.urlopen(req, timeout=timeout) as r:
+            dados = r.read()
+        if not dados or len(dados) < 400:
+            return None, None
+        return dados, round(len(dados) / BYTES_POR_SEGUNDO, 2)
+    except Exception:
+        return None, None
+
+
+def estado():
+    return {
+        "ativo": configurado(),
+        "vozes": [{"id": v["id"], "nome": v["nome"], "tom": v["tom"],
+                   "grave": bool(v.get("grave"))} for v in CATALOGO],
+        "padrao": PADRAO,
+        "como_configurar": "POST /api/voz/elevenlabs {\"chave\":\"...\"} "
+                           "ou variável ELEVENLABS_API_KEY",
+    }

package/studio/ferramentas/corte.md

@@ -141,11 +141,33 @@ na hora de tocar — sem gravar nada, sem arquivo:
 Escolha da voz no **documento** (opcional):
 
 ```json
-"voz": { "voz": "jeff", "grave": true, "velocidade": 1 }
+"voz": { "voz": "brian", "grave": true, "velocidade": 1 }
 ```
 
-A síntese é neural e roda na máquina do usuário — offline, sem limite. As
-vozes pt-BR, com a frequência de cada uma medida (menor = mais grave):
+**Com o ElevenLabs configurado** (chave em `POST /api/voz/elevenlabs` ou na
+variável `ELEVENLABS_API_KEY`), a narração inteira sobe de nível e as vozes
+passam a ser: `brian` (grave, de locução — padrão) · `daniel` (grave, de
+noticiário) · `adam` (firme) · `bill` (maduro) · `liam` (jovem, redes
+sociais) · `sarah` e `alice` (femininas). Também aceita um voice_id cru do
+ElevenLabs — é assim que a voz clonada do próprio usuário entra. Consulte
+`GET /api/voz/status` para saber o que está ativo nesta máquina.
+
+**A corrente de voz, em ordem de qualidade** (cada motor cai no seguinte
+quando não responde — a narração nunca fica muda):
+
+1. **ElevenLabs** — premium, se houver chave com crédito.
+2. **Edge TTS** — vozes neurais da Microsoft, **grátis e sem chave**, só
+   pede internet. É a melhor voz gratuita: `antonio` (masculina, de locução
+   — **a padrão gratuita**), `francisca` e `thalita` (femininas). Instala-se
+   sozinho na primeira vez (`pip install edge-tts`, ~1 min) e, enquanto isso,
+   a narração sai por outro motor. Não há por que citar "voz de robô": com
+   internet, o padrão já é voz neural de gente.
+3. **Piper** — neural e **offline**, sem limite (detalhado abaixo).
+4. **Voicebox** — se o app estiver instalado (voz clonável).
+5. **Google** — última reserva, robótica, mas responde sempre.
+
+O **Piper** roda na máquina do usuário — offline, sem limite. As vozes
+pt-BR, com a frequência de cada uma medida (menor = mais grave):
 
 | id | timbre | Hz |
 |---|---|---|

package/studio/server.py

@@ -56,8 +56,61 @@ except Exception as _e:    # instalação parcial, ou voz.py de uma versão velh
         def apagar():
             return {"ok": True}
 
+        @staticmethod
+        def bloqueado():
+            return "módulo de voz indisponível"
+
     voz_lib = _SemVoz()
 
+try:
+    import elevenlabs as elevenlabs_lib  # noqa: E402
+except Exception as _e:
+    sys.stderr.write("[voz] elevenlabs indisponível (%s)\n" % _e)
+
+    class _SemEleven:
+        @staticmethod
+        def configurado():
+            return False
+
+        @staticmethod
+        def sintetizar(*a, **k):
+            return None, None
+
+        @staticmethod
+        def estado():
+            return {"ativo": False, "vozes": [], "erro": "módulo indisponível"}
+
+        @staticmethod
+        def gravar_chave(*a, **k):
+            return {"ok": False, "erro": "módulo indisponível"}
+
+    elevenlabs_lib = _SemEleven()
+
+try:
+    import edge as edge_lib  # noqa: E402
+except Exception as _e:
+    sys.stderr.write("[voz] edge indisponível (%s)\n" % _e)
+
+    class _SemEdge:
+        @staticmethod
+        def disponivel():
+            return False
+
+        @staticmethod
+        def sintetizar(*a, **k):
+            return None, None
+
+        @staticmethod
+        def instalar():
+            return None
+
+        @staticmethod
+        def estado():
+            return {"motor": "edge", "disponivel": False, "vozes": [],
+                    "erro": "módulo indisponível"}
+
+    edge_lib = _SemEdge()
+
 WEB = os.path.join(RAIZ, "web")
 ARQUIVOS = os.path.join(RAIZ, "arquivos")
 FERRAMENTAS = os.path.join(RAIZ, "ferramentas")
@@ -312,8 +365,12 @@ def preparar_voz(doc):
     aperta play seria tarde — ele ouviria a voz robótica do Google. Fazê-lo
     aqui, no instante em que o roteiro é gravado, dá ao download a mesma
     janela que o agente gasta escrevendo o resto: quando alguém toca o vídeo,
-    a voz boa já está na máquina. Se não der tempo, a corrente cobre."""
-    if _tem_narracao(doc) and not voz_lib.pronta():
+    a voz boa já está na máquina. Se não der tempo, a corrente cobre.
+
+    Com o ElevenLabs configurado, não há nada para baixar: a síntese é
+    imediata e os 90 MB do Piper ficam para o dia em que faltarem chave ou
+    internet."""
+    if _tem_narracao(doc) and not elevenlabs_lib.configurado() and not voz_lib.pronta():
         try:
             voz_lib.instalar()
         except Exception:
@@ -346,24 +403,50 @@ def _assinatura_voz(texto, voz):
     return hashlib.sha1(corpo.encode("utf-8")).hexdigest()[:10]
 
 
+def _google_tts(texto, idioma="pt-BR"):
+    """Google Translate TTS em MP3, no nível do módulo, para o pré-render
+    também ter o mesmo piso do endpoint: uma voz que responde sempre. Robótica,
+    mas garante que NENHUMA cena fique sem áudio. Devolve b"" se falhar."""
+    try:
+        pedacos = []
+        for t in _picar(texto, 190):
+            url = "https://translate.google.com/translate_tts?" + urlencode({
+                "ie": "UTF-8", "q": t, "tl": idioma, "client": "tw-ob", "total": 1, "idx": 0,
+            })
+            req = urllib.request.Request(url, headers={
+                "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) "
+                              "AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0 Safari/537.36",
+                "Referer": "https://translate.google.com/",
+            })
+            with urllib.request.urlopen(req, timeout=20) as r:
+                pedacos.append(r.read())
+        return b"".join(pedacos)
+    except Exception as e:
+        sys.stderr.write("[voz] Google TTS falhou: %s\n" % e)
+        return b""
+
+
 def _gravar_narracao(arq_id):
     """Sintetiza a narração de cada cena e guarda em midia/."""
     try:
-        # Esperar o motor: são minutos, mas ninguém está esperando na frente
-        # da tela — e o resultado é a diferença entre voz de gente e voz de
-        # robô no vídeo que a pessoa vai apresentar.
-        for _ in range(120):
-            if voz_lib.pronta():
-                break
-            # Máquina onde o Piper nunca vai rodar (binário de outra
-            # arquitetura): esperar 10 minutos aqui era esperar por nada.
-            if voz_lib.bloqueado():
-                sys.stderr.write("[voz] motor neural bloqueado: %s\n" % voz_lib.bloqueado())
-                return
-            voz_lib.instalar()
-            time.sleep(5)
-        if not voz_lib.pronta():
-            return
+        # Com ElevenLabs (chave) ou Edge (grátis, neural, sem download) já há
+        # voz de gente na hora — não se espera o Piper. Só quando NENHUM dos
+        # dois responde vale aguardar o Piper baixar, porque a alternativa é
+        # o Google, que soa a robô no vídeo que a pessoa vai apresentar.
+        if not elevenlabs_lib.configurado() and not edge_lib.disponivel():
+            edge_lib.instalar()          # tenta trazer o Edge em paralelo
+            for _ in range(120):
+                if voz_lib.pronta() or edge_lib.disponivel():
+                    break
+                # Máquina onde o Piper nunca vai rodar (binário de outra
+                # arquitetura): esperar 10 minutos aqui era esperar por nada.
+                if voz_lib.bloqueado():
+                    sys.stderr.write("[voz] Piper bloqueado: %s\n" % voz_lib.bloqueado())
+                    break
+                voz_lib.instalar()
+                time.sleep(5)
+            # Nem Piper nem Edge subiram: ainda assim seguimos — o Google, lá
+            # embaixo na síntese, garante que nenhuma cena fique sem áudio.
 
         a = ler(arq_id)
         if not a:
@@ -386,27 +469,58 @@ def _gravar_narracao(arq_id):
             # vale mais que qualquer síntese.
             if c.get("narracaoAudio") and not c.get("narracaoVoz"):
                 continue
-            try:
-                audio = voz_lib.sintetizar(
-                    texto, voz.get("voz"),
-                    grave=bool(voz.get("grave")),
-                    velocidade=float(voz.get("velocidade") or 1))
-            except Exception as e:
-                sys.stderr.write("[voz] cena %d falhou: %s\n" % (i + 1, e))
-                continue
+            audio, ext, dur = None, ".wav", None
+            # A CORRENTE, na ordem de qualidade. Cada motor cai no seguinte
+            # quando não devolve áudio — e o Google, no fim, garante que a
+            # cena nunca fique muda. É o que faz o pré-render nunca parar.
+
+            # 1) ElevenLabs: a voz que o usuário aprovou. MP3 CBR — a duração
+            #    do módulo já vem medida.
+            if elevenlabs_lib.configurado():
+                audio, dur = elevenlabs_lib.sintetizar(texto, voz)
+                if audio:
+                    ext = ".mp3"
+
+            # 2) Edge TTS: neural, grátis, sem chave. MP3, duração medida pelo
+            #    VTT que o próprio edge escreve.
+            if not audio and edge_lib.disponivel():
+                dados, edur = edge_lib.sintetizar(texto, voz)
+                if dados:
+                    audio, dur, ext = dados, edur, ".mp3"
+
+            # 3) Piper: neural e offline, quando baixado e compatível. WAV.
+            if not audio:
+                try:
+                    audio = voz_lib.sintetizar(
+                        texto, voz.get("voz"),
+                        grave=bool(voz.get("grave")),
+                        velocidade=float(voz.get("velocidade") or 1))
+                except Exception as e:
+                    sys.stderr.write("[voz] Piper cena %d falhou: %s\n" % (i + 1, e))
+                    audio = None
+                if audio:
+                    dur, ext = _duracao_wav(audio), ".wav"
+
+            # 4) Google: última reserva. Robótica, mas responde. MP3 — a
+            #    duração sai do tamanho (CBR de 24 kbps ≈ 3000 bytes/s).
+            if not audio:
+                dados = _google_tts(texto)
+                if dados:
+                    audio, ext = dados, ".mp3"
+                    dur = round(len(dados) / 3000.0, 2)
+
             if not audio:
                 continue
-            nome = "narr-%s-%d-%s.wav" % (arq_id[:28], i + 1, assinatura)
+            nome = "narr-%s-%d-%s%s" % (arq_id[:28], i + 1, assinatura, ext)
             with open(os.path.join(MIDIA, nome), "wb") as fh:
                 fh.write(audio)
             c["narracaoAudio"] = "/midia/" + nome
             c["narracaoVoz"] = assinatura
-            # A duração medida do WAV vai junto: com ela o player sabe quanto
-            # a cena REALMENTE dura (a fala inteira + respiro) e a linha do
-            # tempo vira determinística — sem ela, o relógio congela na
-            # beirada da cena esperando a voz, e a duração do vídeo muda a
-            # cada reprodução.
-            dur = _duracao_wav(audio)
+            # A duração medida vai junto: com ela o player sabe quanto a cena
+            # REALMENTE dura (a fala inteira + respiro) e a linha do tempo
+            # vira determinística — sem ela, o relógio congela na beirada da
+            # cena esperando a voz, e a duração do vídeo muda a cada
+            # reprodução.
             if dur:
                 c["narracaoDur"] = round(dur, 2)
             mudou = True
@@ -1002,10 +1116,33 @@ class Handler(SimpleHTTPRequestHandler):
         tipo = "audio/mpeg"
         audio = b""
 
-        # 1) Piper: o motor bom. Se ainda não baixou, começa a baixar agora e
-        #    segue para o próximo — quem pediu narração hoje ouve o Google, e
-        #    a partir da próxima já é voz de verdade.
-        if motor not in ("google", "voicebox"):
+        # 0) ElevenLabs: a voz que o usuário aprovou nos vídeos. Só entra na
+        #    corrente quando há chave configurada — e continua caindo para os
+        #    motores locais se falhar, porque narração nunca fica muda.
+        if motor in ("", "elevenlabs") and elevenlabs_lib.configurado():
+            dados, _ = elevenlabs_lib.sintetizar(texto, {"voz": voz_pedida})
+            if dados:
+                audio = dados
+                tipo = "audio/mpeg"
+            elif motor == "elevenlabs":
+                return self.js({"erro": "ElevenLabs não devolveu áudio — chave válida? cota?"}, 502)
+
+        # 0.5) Edge TTS: neural, grátis, sem chave. Entra logo depois do
+        #      ElevenLabs porque é a melhor voz gratuita da corrente — vozes
+        #      da Microsoft, muito acima do Google. Precisa de internet.
+        if not audio and motor in ("", "edge"):
+            dados, _ = edge_lib.sintetizar(texto, {"voz": voz_pedida,
+                                                   "grave": grave, "velocidade": velocidade})
+            if dados:
+                audio = dados
+                tipo = "audio/mpeg"
+            elif motor == "edge":
+                return self.js({"erro": "Edge TTS não devolveu áudio — sem internet ou pacote ausente?"}, 502)
+
+        # 1) Piper: o motor local. Se ainda não baixou, começa a baixar agora
+        #    e segue para o próximo — quem pediu narração hoje ouve o Google,
+        #    e a partir da próxima já é voz de verdade.
+        if not audio and motor not in ("google", "voicebox", "elevenlabs", "edge"):
             try:
                 if voz_lib.pronta(voz_pedida or None):
                     audio = voz_lib.sintetizar(texto, voz_pedida or None,
@@ -1069,6 +1206,8 @@ class Handler(SimpleHTTPRequestHandler):
             except Exception:
                 vozes = []
         return self.js({
+            "elevenlabs": elevenlabs_lib.estado(),
+            "edge": edge_lib.estado(),
             "piper": voz_lib.estado(),
             "voicebox": {"ativo": vivo, "vozes": vozes, "site": "https://voicebox.sh"},
             "google": {"ativo": True},
@@ -1219,6 +1358,11 @@ class Handler(SimpleHTTPRequestHandler):
             return self.js(voz_lib.instalar(pedido.get("voz"),
                                             esperar=min(60, int(pedido.get("esperar") or 0))))
 
+        if rota == "/api/voz/elevenlabs":
+            # Grava (ou apaga, com chave vazia) a chave do ElevenLabs. A chave
+            # nunca volta em resposta nenhuma — só o "configurado" volta.
+            return self.js(elevenlabs_lib.gravar_chave(self.corpo().get("chave")))
+
         if rota == "/api/sair":
             # Só o CLI chama, e só quando o código no disco mudou (update do
             # npm). Sem isto o processo antigo ficava no ar servindo o bug que

package/studio/web/core.css

@@ -852,3 +852,138 @@ body:has(.transporte) .aviso { bottom: 80px; }
   font: 500 12px/1 var(--sans); cursor: pointer;
 }
 .presets button:hover { background: var(--sup3); color: var(--texto); border-color: var(--primo); }
+
+/* ==========================================================================
+   Refresh 2026 — o estúdio deixa de parecer template.
+   Um bloco só, no fim, sobrepondo o essencial: profundidade no fundo,
+   gradiente na marca, cartões com vida e o transporte flutuando de vidro.
+   ========================================================================== */
+
+:root {
+  --primo2: #ffb03a;                          /* o par do laranja no gradiente */
+  --grad-primo: linear-gradient(120deg, #ff5a36 0%, #ff7a3c 55%, #ffb03a 100%);
+  --brilho-primo: 0 8px 32px rgba(255, 90, 54, .25);
+}
+
+body {
+  background:
+    radial-gradient(ellipse 1000px 640px at 18% -10%, rgba(255, 90, 54, .07), transparent 60%),
+    radial-gradient(ellipse 900px 600px at 92% 108%, rgba(124, 92, 246, .05), transparent 60%),
+    var(--fundo);
+}
+
+/* marca com gradiente e cubo aceso */
+.topo .marca .cubo {
+  background: var(--grad-primo);
+  box-shadow: var(--brilho-primo);
+}
+.topo .marca em {
+  background: var(--grad-primo);
+  -webkit-background-clip: text;
+  background-clip: text;
+  color: transparent;
+  font-style: normal;
+}
+
+/* hero maior, título com peso de capa */
+.home .hero h1 {
+  font-size: 42px;
+  letter-spacing: -.02em;
+  background: linear-gradient(120deg, #fff 30%, #ffd9cd 70%, var(--primo2) 100%);
+  -webkit-background-clip: text;
+  background-clip: text;
+  color: transparent;
+}
+
+/* cartões de ferramenta: vidro, glow no hover, levanta */
+.cartao-ferr {
+  border-radius: 16px;
+  background: linear-gradient(180deg, rgba(255, 255, 255, .035), rgba(255, 255, 255, .012));
+  transition: transform .18s ease, border-color .18s ease, box-shadow .18s ease;
+}
+.cartao-ferr:hover {
+  transform: translateY(-3px);
+  border-color: var(--linha2);
+  box-shadow: 0 14px 44px rgba(0, 0, 0, .45), 0 0 0 1px rgba(255, 90, 54, .12);
+}
+.cartao-ferr .icone {
+  border-radius: 12px;
+  box-shadow: inset 0 0 0 1px rgba(255, 255, 255, .06);
+}
+
+/* botão principal: gradiente da marca */
+.btn.primo,
+.transporte .tp-btn.texto.primo {
+  background: var(--grad-primo);
+  border: none;
+  color: #fff;
+  font-weight: 600;
+  box-shadow: var(--brilho-primo);
+}
+.btn.primo:hover,
+.transporte .tp-btn.texto.primo:hover {
+  filter: brightness(1.08);
+}
+
+/* itens da lista de arquivos: respiro e hover */
+.item-arq {
+  border-radius: 14px;
+  transition: background .15s ease, border-color .15s ease;
+}
+.item-arq:hover { background: var(--sup2); border-color: var(--linha2); }
+
+/* transporte do player: vidro flutuante */
+.transporte {
+  background: rgba(16, 16, 20, .78);
+  backdrop-filter: blur(14px);
+  -webkit-backdrop-filter: blur(14px);
+  border: 1px solid var(--linha);
+  border-radius: 16px;
+  margin: 0 14px 12px;
+  width: calc(100% - 28px);
+  box-shadow: 0 12px 40px rgba(0, 0, 0, .5);
+}
+.transporte .tp-cheio { background: var(--grad-primo); }
+
+/* menu do botão Baixar (vídeo / áudio) */
+.menu-baixar {
+  position: fixed;
+  right: 22px;
+  bottom: 84px;
+  z-index: 60;
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+  padding: 6px;
+  border-radius: 14px;
+  border: 1px solid var(--linha2);
+  background: rgba(18, 18, 23, .96);
+  backdrop-filter: blur(16px);
+  -webkit-backdrop-filter: blur(16px);
+  box-shadow: 0 18px 60px rgba(0, 0, 0, .6);
+  animation: menu-sobe .16s ease;
+}
+@keyframes menu-sobe {
+  from { opacity: 0; transform: translateY(8px); }
+  to   { opacity: 1; transform: none; }
+}
+.menu-baixar button {
+  display: flex;
+  flex-direction: column;
+  align-items: flex-start;
+  gap: 2px;
+  min-width: 250px;
+  padding: 11px 14px;
+  border: none;
+  border-radius: 10px;
+  background: transparent;
+  color: var(--texto);
+  font: 600 13.5px/1.2 var(--sans);
+  text-align: left;
+  cursor: pointer;
+}
+.menu-baixar button:hover { background: var(--primo-suave); }
+.menu-baixar button span {
+  font: 400 11.5px/1.2 var(--sans);
+  color: var(--fraco);
+}

package/studio/web/home.html

@@ -37,7 +37,8 @@
     <h1>O estúdio que a IA opera</h1>
     <p>Seis ferramentas nativas com um modelo de documento em comum. A IA escreve o
       documento, o estúdio desenha — apresentação, arte, texto, planilha, vídeo ou diagrama —
-      e você refina à mão no editor.</p>
+      e você refina à mão no editor. Vídeo sai com narração neural, trilha, efeitos
+      sonoros e download direto em MP4 ou áudio.</p>
   </section>
 
   <section class="grade-ferr" id="ferramentas"></section>

package/studio/web/js/player.js

@@ -219,6 +219,7 @@
     pintar();
     aviso("fim", 1200);
     if (gravador && gravador.state === "recording") setTimeout(pararGravacao, 600);
+    if (gravadorAudio && gravadorAudio.state === "recording") setTimeout(pararGravacao, 600);
   }
 
   /* A narração da cena ainda está no ar? */
@@ -388,12 +389,12 @@
       '<div class="tp-tempo" id="tp-total">00:00</div>' +
       '<button class="tp-btn pequeno" id="tp-som" title="Mudo (M)"></button>' +
       '<input class="tp-vol" id="tp-vol" type="range" min="0" max="100" value="70">' +
-      '<button class="tp-btn texto primo" id="tp-gravar" title="Baixar este vídeo como arquivo">Baixar MP4</button>';
+      '<button class="tp-btn texto primo" id="tp-gravar" title="Baixar vídeo ou áudio">Baixar ▾</button>';
     document.body.appendChild(transporte);
 
     document.getElementById("tp-tocar").onclick = function () { tocando ? pausar() : tocar(); };
     document.getElementById("tp-som").onclick = alternarMudo;
-    document.getElementById("tp-gravar").onclick = alternarGravacao;
+    document.getElementById("tp-gravar").onclick = menuBaixar;
     document.getElementById("tp-vol").oninput = function () {
       if (trilha) trilha.volume(this.value / 100);
     };
@@ -444,6 +445,81 @@
     iniciarGravacao();
   }
 
+  /* Menu do botão Baixar: vídeo completo ou só o áudio.
+
+     O áudio sai DIRETO do grafo (trilha + narração + SFX, já mixados com
+     ducking) — sem pedir permissão de tela nenhuma, porque não há tela:
+     é o MediaRecorder pendurado no fluxo da Web Audio. */
+  function menuBaixar() {
+    if ((gravador && gravador.state === "recording") ||
+        (gravadorAudio && gravadorAudio.state === "recording")) {
+      return pararGravacao();
+    }
+    var velho = document.getElementById("menu-baixar");
+    if (velho) { velho.remove(); return; }
+    var m = document.createElement("div");
+    m.id = "menu-baixar";
+    m.className = "menu-baixar";
+    m.innerHTML =
+      '<button data-acao="mp4">🎬 Vídeo completo <span>' + (gravaMp4() ? "MP4" : "WebM") + " · imagem + som</span></button>" +
+      '<button data-acao="audio">🎧 Só o áudio <span>narração + trilha + efeitos</span></button>';
+    document.body.appendChild(m);
+    m.onclick = function (ev) {
+      var b = ev.target.closest("button");
+      if (!b) return;
+      m.remove();
+      if (b.dataset.acao === "mp4") iniciarGravacao();
+      else iniciarGravacaoAudio();
+    };
+    setTimeout(function () {
+      document.addEventListener("click", function fecha(e) {
+        if (!m.contains(e.target)) { m.remove(); document.removeEventListener("click", fecha); }
+      });
+    }, 0);
+  }
+
+  /* ------------------------------------------------ gravação só de áudio -- */
+
+  var gravadorAudio = null, pedacosAudio = [];
+
+  var FORMATOS_AUDIO = [
+    "audio/mp4",                    // AAC → .m4a: toca em tudo, importa em tudo
+    "audio/webm;codecs=opus",
+    "audio/webm",
+  ];
+
+  function iniciarGravacaoAudio() {
+    if (!trilha || !trilha.fluxo) return aviso("áudio indisponível neste navegador", 2500);
+    var tipo = "";
+    for (var i = 0; i < FORMATOS_AUDIO.length; i++) {
+      if (MediaRecorder.isTypeSupported(FORMATOS_AUDIO[i])) { tipo = FORMATOS_AUDIO[i]; break; }
+    }
+    pedacosAudio = [];
+    gravadorAudio = new MediaRecorder(trilha.fluxo, tipo ? { mimeType: tipo, audioBitsPerSecond: 192000 } : undefined);
+    gravadorAudio.ondataavailable = function (ev) { if (ev.data.size) pedacosAudio.push(ev.data); };
+    gravadorAudio.onstop = baixarAudio;
+    gravadorAudio.start();
+    var b = document.getElementById("tp-gravar");
+    if (b) { b.classList.add("gravando"); b.textContent = "Parar"; }
+    buscar(0);
+    tocar();
+    aviso("gravando o áudio — para sozinho no fim", 2600);
+  }
+
+  function baixarAudio() {
+    var mime = (gravadorAudio && gravadorAudio.mimeType) || "audio/webm";
+    var ext = /mp4/.test(mime) ? ".m4a" : ".weba";
+    var blob = new Blob(pedacosAudio, { type: mime.split(";")[0] });
+    var url = URL.createObjectURL(blob);
+    var a = document.createElement("a");
+    a.href = url;
+    a.download = (arq.titulo || "audio").replace(/[^\w\-]+/g, "-").toLowerCase() + ext;
+    a.click();
+    setTimeout(function () { URL.revokeObjectURL(url); }, 4000);
+    aviso("áudio salvo em " + ext, 2600);
+    gravadorAudio = null;
+  }
+
 /* O melhor formato que este navegador sabe gravar.
  *
  * A ordem importa: H.264 com AAC é o MP4 que toca em qualquer lugar —
@@ -518,9 +594,10 @@ function gravaMp4() { return /mp4/.test(escolherFormato()); }
 
   function pararGravacao() {
     if (gravador && gravador.state === "recording") gravador.stop();
+    if (gravadorAudio && gravadorAudio.state === "recording") gravadorAudio.stop();
     if (fluxoTela) fluxoTela.getTracks().forEach(function (f) { f.stop(); });
     var b = document.getElementById("tp-gravar");
-    if (b) { b.classList.remove("gravando"); b.textContent = "Gravar"; }
+    if (b) { b.classList.remove("gravando"); b.textContent = "Baixar ▾"; }
   }
 
   function baixarGravacao() {

package/studio/web/js/render.js

@@ -178,25 +178,43 @@ function aplicarChaves(no, e, ctx) {
     return _numero(a.t, 0) - _numero(b.t, 0);
   });
 
+  // Um campo OMITIDO numa chave herda o valor da chave anterior — não pula
+  // para um padrão fixo. Sem isto, uma chave que só mexe em `opacidade`
+  // zerava a `escala` implícita: o elemento nascia com scale(0) e sumia da
+  // tela, e a animação parecia "bugada e atrasada". Herdar é o que a pessoa
+  // espera: "o que eu não toquei, fica como estava". O primeiro valor de
+  // cada campo, quando nem a primeira chave o declara, é o neutro (escala e
+  // opacidade em 1, deslocamento e giro em 0) — nunca zero para escala.
+  var NEUTRO = { x: 0, y: 0, escala: 1, giro: 0, opacidade: 1, desfoque: 0 };
+  var CAMPOS = ["x", "y", "escala", "giro", "opacidade", "desfoque"];
+  var herdado = {};
+  CAMPOS.forEach(function (c) {
+    // semente: primeiro valor declarado em qualquer chave, senão o neutro.
+    for (var i = 0; i < chaves.length; i++) {
+      if (typeof chaves[i][c] === "number" && isFinite(chaves[i][c])) { herdado[c] = chaves[i][c]; return; }
+    }
+    herdado[c] = NEUTRO[c];
+  });
+
   var nome = "ch" + (++_nChave);
   var passos = chaves.map(function (k) {
+    CAMPOS.forEach(function (c) {
+      if (typeof k[c] === "number" && isFinite(k[c])) herdado[c] = k[c];
+    });
     var pct = Math.max(0, Math.min(1, _numero(k.t, 0))) * 100;
     var mov = [];
     // x e y de uma chave são DESLOCAMENTO a partir de onde o elemento está.
     // Assim a chave continua valendo se a pessoa arrastar o elemento no
     // palco depois — o contrário obrigaria a refazer todas as chaves.
-    var dx = _numero(k.x, 0), dy = _numero(k.y, 0);
+    var dx = herdado.x, dy = herdado.y;
     if (dx || dy) mov.push("translate(" + dx + "px," + dy + "px)");
-    var esc = _numero(k.escala, 1);
-    if (esc !== 1) mov.push("scale(" + esc + ")");
-    var giro = _numero(k.giro, 0);
-    if (giro) mov.push("rotate(" + giro + "deg)");
+    if (herdado.escala !== 1) mov.push("scale(" + herdado.escala + ")");
+    if (herdado.giro) mov.push("rotate(" + herdado.giro + "deg)");
 
     var linhas = ["transform:" + (mov.length ? mov.join(" ") : "none")];
-    var op = _numero(k.opacidade, 1);
-    linhas.push("opacity:" + op);
-    if (typeof k.desfoque === "number" && k.desfoque > 0) {
-      linhas.push("filter:blur(" + k.desfoque + "px)");
+    linhas.push("opacity:" + herdado.opacidade);
+    if (herdado.desfoque > 0) {
+      linhas.push("filter:blur(" + herdado.desfoque + "px)");
     }
     return pct.toFixed(3) + "%{" + linhas.join(";") + "}";
   }).join("");