primocode 8.11.1 → 8.12.0

package/studio/voz.py

@@ -0,0 +1,307 @@
+"""Narração de verdade, gerada aqui em Python.
+
+── O PROBLEMA ────────────────────────────────────────────────────────────
+A narração era feita no NAVEGADOR. Havia três caminhos lá: a voz neural do
+Edge por WebSocket, o TTS do Google por este servidor, e o speechSynthesis
+da própria máquina. O primeiro morreu — a Microsoft passou a responder 403
+na síntese (a lista de vozes ainda responde; a síntese, não), e isso é uma
+trava que eles impõem de propósito, não um bug para contornar. O terceiro é
+o TTS do sistema: existe em todo computador e soa a computador. Resultado
+prático: o usuário pedia vídeo institucional e ouvia voz de robô.
+
+── A SAÍDA ───────────────────────────────────────────────────────────────
+Trazer a síntese para cá, para o Python, onde ela não depende de navegador
+nem de serviço de ninguém. O motor é o Piper (MIT, do projeto Rhasspy):
+rede neural que roda na máquina, offline, sem chave, sem cota e sem limite.
+Ele não vem no pacote — são ~90 MB entre programa e modelo — então é
+baixado uma vez, sob demanda, e daí em diante a narração é instantânea e
+funciona sem internet.
+
+── AS VOZES ──────────────────────────────────────────────────────────────
+As quatro vozes pt-BR do Piper foram sintetizadas e MEDIDAS: a frequência
+fundamental de cada uma está na tabela abaixo, apurada por autocorrelação
+sobre os quadros com tom. Não é adjetivo de catálogo, é medida. Por isso a
+padrão é a Jeff, de 139 Hz — a mais grave, que é o que sustenta abertura de
+vídeo. E por isso não há voz feminina listada: o Piper não tem nenhuma em
+pt-BR, e inventar rótulo seria pior que admitir a falta.
+
+── A CORRENTE ────────────────────────────────────────────────────────────
+1. PIPER    neural, offline, ilimitado, com escolha de voz. O bom.
+2. VOICEBOX se o usuário tiver o app instalado — voz clonável.
+3. GOOGLE   uma voz só, robótica, mas responde na hora e sem instalar nada.
+
+Cada um cai no seguinte quando falha. A narração nunca fica muda por falta
+de motor: enquanto o Piper baixa, o Google cobre.
+"""
+
+import json
+import os
+import platform
+import re
+import shutil
+import subprocess
+import sys
+import tarfile
+import tempfile
+import threading
+import urllib.parse
+import urllib.request
+import wave
+import zipfile
+
+CASA = os.path.join(os.path.expanduser("~"), ".primocode", "vozes")
+
+RELEASE = "https://github.com/rhasspy/piper/releases/download/2023.11.14-2/"
+VOZES_URL = "https://huggingface.co/rhasspy/piper-voices/resolve/main/"
+
+# O pacote do Piper para cada sistema. Os cinco nomes foram conferidos no ar.
+PACOTES = {
+    ("Linux", "x86_64"): "piper_linux_x86_64.tar.gz",
+    ("Linux", "aarch64"): "piper_linux_aarch64.tar.gz",
+    ("Linux", "arm64"): "piper_linux_aarch64.tar.gz",
+    ("Darwin", "x86_64"): "piper_macos_x64.tar.gz",
+    ("Darwin", "arm64"): "piper_macos_aarch64.tar.gz",
+    ("Windows", "AMD64"): "piper_windows_amd64.zip",
+    ("Windows", "x86_64"): "piper_windows_amd64.zip",
+}
+
+# hz: fundamental medida, em Hz. Quanto menor, mais grave.
+CATALOGO = [
+    {"id": "jeff", "nome": "Jeff", "hz": 139, "grave": True, "padrao": True,
+     "tom": "grave, de locução", "caminho": "pt/pt_BR/jeff/medium/pt_BR-jeff-medium", "mb": 60},
+    {"id": "cadu", "nome": "Cadu", "hz": 140, "grave": True,
+     "tom": "grave, mais solta", "caminho": "pt/pt_BR/cadu/medium/pt_BR-cadu-medium", "mb": 60},
+    {"id": "faber", "nome": "Faber", "hz": 167,
+     "tom": "clara, de leitura", "caminho": "pt/pt_BR/faber/medium/pt_BR-faber-medium", "mb": 60},
+    {"id": "edresson", "nome": "Edresson", "hz": 151,
+     "tom": "média, mais leve de baixar", "caminho": "pt/pt_BR/edresson/low/pt_BR-edresson-low", "mb": 21},
+    {"id": "tugao", "nome": "Tugão", "hz": 0,
+     "tom": "português de Portugal", "caminho": "pt/pt_PT/tugão/medium/pt_PT-tugão-medium", "mb": 60},
+]
+
+POR_ID = {v["id"]: v for v in CATALOGO}
+PADRAO = next(v["id"] for v in CATALOGO if v.get("padrao"))
+
+# Estado do download, para a interface poder mostrar em vez de fingir que
+# está tudo pronto. Um dicionário simples, protegido por tranca porque quem
+# escreve é a thread do download e quem lê são as requisições.
+_tranca = threading.Lock()
+_baixando = {"ativo": False, "voz": None, "pct": 0, "etapa": "", "erro": None}
+_thread = None
+
+
+def _versao_pacote():
+    return PACOTES.get((platform.system(), platform.machine()))
+
+
+def pasta_piper():
+    return os.path.join(CASA, "piper")
+
+
+def binario():
+    """O executável do Piper, se já foi baixado."""
+    nome = "piper.exe" if platform.system() == "Windows" else "piper"
+    p = os.path.join(pasta_piper(), nome)
+    return p if os.path.exists(p) else None
+
+
+def modelo(voz_id):
+    v = POR_ID.get(voz_id or PADRAO)
+    if not v:
+        return None
+    base = os.path.join(CASA, os.path.basename(v["caminho"]))
+    return base if os.path.exists(base + ".onnx") and os.path.exists(base + ".onnx.json") else None
+
+
+def instaladas():
+    return [v["id"] for v in CATALOGO if modelo(v["id"])]
+
+
+def pronta(voz_id=None):
+    return bool(binario() and modelo(voz_id or PADRAO))
+
+
+# ------------------------------------------------------------------ baixar --
+
+def _baixar(url, destino, fatia=(0, 100)):
+    """Baixa mostrando progresso dentro da fatia que lhe cabe do total."""
+    ini, fim = fatia
+    with urllib.request.urlopen(url, timeout=60) as r:
+        total = int(r.headers.get("Content-Length") or 0)
+        feito = 0
+        tmp = destino + ".parcial"
+        with open(tmp, "wb") as fh:
+            while True:
+                p = r.read(262144)
+                if not p:
+                    break
+                fh.write(p)
+                feito += len(p)
+                if total:
+                    with _tranca:
+                        _baixando["pct"] = int(ini + (fim - ini) * feito / total)
+        # Só vira o arquivo de verdade quando terminou inteiro: assim uma
+        # queda de rede não deixa um modelo pela metade que "existe".
+        os.replace(tmp, destino)
+
+
+def _instalar_piper():
+    pacote = _versao_pacote()
+    if not pacote:
+        raise RuntimeError("não há Piper para %s/%s" % (platform.system(), platform.machine()))
+    os.makedirs(CASA, exist_ok=True)
+    with _tranca:
+        _baixando["etapa"] = "baixando o motor de voz"
+    alvo = os.path.join(CASA, pacote)
+    _baixar(RELEASE + pacote, alvo, (0, 35))
+
+    with _tranca:
+        _baixando["etapa"] = "instalando o motor"
+    if pacote.endswith(".zip"):
+        with zipfile.ZipFile(alvo) as z:
+            z.extractall(CASA)
+    else:
+        with tarfile.open(alvo) as t:
+            t.extractall(CASA)
+    os.remove(alvo)
+
+    exe = binario()
+    if not exe:
+        raise RuntimeError("o pacote do Piper não trouxe o executável")
+    if platform.system() != "Windows":
+        os.chmod(exe, 0o755)
+
+
+def _instalar_voz(voz_id):
+    v = POR_ID[voz_id]
+    os.makedirs(CASA, exist_ok=True)
+    base = os.path.join(CASA, os.path.basename(v["caminho"]))
+    with _tranca:
+        _baixando["etapa"] = "baixando a voz %s" % v["nome"]
+    # O nome tem "ã" no caso do tugão: a URL precisa disso escapado.
+    url = VOZES_URL + urllib.parse.quote(v["caminho"])
+    _baixar(url + ".onnx.json", base + ".onnx.json", (35, 40))
+    _baixar(url + ".onnx", base + ".onnx", (40, 100))
+
+
+def _rotina(voz_id):
+    global _thread
+    try:
+        if not binario():
+            _instalar_piper()
+        if not modelo(voz_id):
+            _instalar_voz(voz_id)
+        with _tranca:
+            _baixando.update(ativo=False, pct=100, etapa="pronta", erro=None)
+    except Exception as e:
+        sys.stderr.write("[voz] instalação falhou: %s\n" % e)
+        with _tranca:
+            _baixando.update(ativo=False, etapa="", erro=str(e))
+    finally:
+        _thread = None
+
+
+def instalar(voz_id=None, esperar=0):
+    """Começa (ou acompanha) a instalação. Não bloqueia, por padrão.
+
+    Quem chama é a interface e o próprio servidor quando vê um documento com
+    narração: preparar a voz enquanto o agente ainda escreve o roteiro é o
+    que faz ela estar pronta na hora de tocar."""
+    global _thread
+    voz_id = voz_id if voz_id in POR_ID else PADRAO
+    with _tranca:
+        if _thread is None and not pronta(voz_id):
+            _baixando.update(ativo=True, voz=voz_id, pct=0, etapa="começando", erro=None)
+            _thread = threading.Thread(target=_rotina, args=(voz_id,), daemon=True)
+            _thread.start()
+        t = _thread
+    if t and esperar:
+        t.join(esperar)
+    return estado()
+
+
+def estado():
+    with _tranca:
+        b = dict(_baixando)
+    return {
+        "motor": "piper",
+        "pronta": pronta(),
+        "instaladas": instaladas(),
+        "suportado": bool(_versao_pacote()),
+        "baixando": b,
+        "vozes": [{
+            "id": v["id"], "nome": v["nome"], "tom": v["tom"], "hz": v["hz"], "mb": v["mb"],
+            "instalada": bool(modelo(v["id"])),
+            "grave": bool(v.get("grave")),
+            "padrao": bool(v.get("padrao")),
+        } for v in CATALOGO],
+    }
+
+
+# --------------------------------------------------------------- sintetizar --
+
+def _mais_grave(bruto, razao):
+    """Abaixa o tom reescrevendo a taxa declarada do WAV.
+
+    Não há reamostragem: os mesmos quadros, lidos mais devagar, soam mais
+    graves na mesma proporção. Como isso também alonga o áudio, a síntese já
+    foi feita acelerada pelo mesmo fator, e a duração volta ao lugar.
+    Medido: a voz Jeff sai de 139 Hz para 125 Hz com razão 0.9."""
+    with wave.open(bruto, "rb") as w:
+        p = w.getparams()
+        quadros = w.readframes(p.nframes)
+    saida = bruto + ".grave.wav"
+    with wave.open(saida, "wb") as s:
+        s.setnchannels(p.nchannels)
+        s.setsampwidth(p.sampwidth)
+        s.setframerate(max(8000, int(p.framerate * razao)))
+        s.writeframes(quadros)
+    return saida
+
+
+def sintetizar(texto, voz_id=None, grave=False, velocidade=1.0, timeout=120):
+    """O texto vira WAV. None quando o Piper não está pronto — aí quem chamou
+    cai para o próximo motor da corrente."""
+    exe = binario()
+    voz_id = voz_id if voz_id in POR_ID else PADRAO
+    mod = modelo(voz_id)
+    if not exe or not mod:
+        return None
+
+    # Sem isto, um texto com quebra de linha vira várias falas e o Piper
+    # devolve só a última.
+    limpo = re.sub(r"\s+", " ", str(texto or "")).strip()
+    if not limpo:
+        return None
+
+    razao = 0.9 if grave else 1.0
+    # length_scale > 1 é mais devagar. A razão do grave entra aqui para a
+    # duração não crescer quando a taxa for reescrita lá embaixo.
+    escala = (1.0 / max(0.5, min(2.0, velocidade))) * razao
+
+    pasta = tempfile.mkdtemp(prefix="primo-voz-")
+    try:
+        saida = os.path.join(pasta, "voz.wav")
+        r = subprocess.run(
+            [exe, "--model", mod + ".onnx", "--config", mod + ".onnx.json",
+             "--length_scale", "%.3f" % escala, "--sentence_silence", "0.25",
+             "--output_file", saida],
+            input=limpo.encode("utf-8"),
+            stdout=subprocess.DEVNULL, stderr=subprocess.PIPE, timeout=timeout,
+        )
+        if r.returncode != 0 or not os.path.exists(saida):
+            raise RuntimeError((r.stderr or b"").decode("utf-8", "replace")[-300:] or "piper falhou")
+        if grave:
+            saida = _mais_grave(saida, razao)
+        with open(saida, "rb") as fh:
+            return fh.read()
+    finally:
+        shutil.rmtree(pasta, ignore_errors=True)
+
+
+def apagar():
+    """Some com tudo que foi baixado. Existe para o usuário poder desfazer:
+    são 90 MB na máquina dele, e ele tem direito de recuperá-los."""
+    if os.path.isdir(CASA):
+        shutil.rmtree(CASA, ignore_errors=True)
+    return {"ok": True}

package/studio/web/js/narracao.js

@@ -191,12 +191,28 @@ var Narracao = (function () {
     });
   }
 
-  /* Mede quanto tempo a fala leva, sem ninguém ouvir. */
+  /* Mede quanto tempo a fala leva, sem ninguém ouvir.
+
+     Com a voz neural o áudio vem pronto, em arquivo, e a duração está nos
+     metadados dele: perguntar é exato e é silencioso. Só o caminho do
+     speechSynthesis ainda precisa falar para cronometrar — e lá o volume
+     zero é obedecido de verdade. */
   function medir(texto, cfg) {
+    cfg = cfg || {};
+    if (cfg.motor !== "sistema" && typeof VozNeural !== "undefined") {
+      return VozNeural.duracaoDe(texto, cfg).then(function (s) {
+        return s || medirPelaSintese(texto, cfg);
+      }).catch(function () { return medirPelaSintese(texto, cfg); });
+    }
+    return medirPelaSintese(texto, cfg);
+  }
+
+  function medirPelaSintese(texto, cfg) {
     var c = {};
     for (var k in (cfg || {})) c[k] = cfg[k];
     c.volume = 0;
-    return falar(texto, c);
+    c.motor = "sistema";
+    return pelaSintese(texto, c);
   }
 
   function parar() {

package/studio/web/js/voz-neural.js

@@ -1,204 +1,112 @@
 /* ==========================================================================
    voz-neural.js — locução com voz de verdade.
 
-   ── O PROBLEMA ──────────────────────────────────────────────────────────
-   A narração usava speechSynthesis, o TTS da própria máquina. Ele existe em
-   todo computador, e é justamente esse o problema: soa a computador. Para
-   vídeo institucional não serve — e o dono pediu voz densa, cinematográfica,
-   com possibilidade de ESCOLHER.
-
-   ── OS TRÊS CAMINHOS, DO MELHOR PARA O PIOR ─────────────────────────────
-   1. NEURAL (Edge)   vozes neurais da Microsoft. Grátis, sem chave, sem
-                      limite prático, e as pt-BR são boas de verdade:
-                      Antonio (masculina, grave — a de vídeo), Francisca
-                      (feminina) e Thalita (multilíngue).
-                      Fala por WebSocket, que não passa por CORS.
-   2. GOOGLE (proxy)  uma voz só, sem escolha, mas responde sempre. Vai pelo
-                      servidor do Studio porque o Google não manda cabeçalho
-                      de CORS — do navegador direto seria bloqueado.
-   3. SISTEMA         o speechSynthesis de antes. Rascunho, e nada mais.
-
-   Cada caminho cai no seguinte quando falha. Narração é acabamento: se a voz
-   não vier, o vídeo continua existindo, mudo.
-
-   ── NOTA HONESTA ────────────────────────────────────────────────────────
-   O caminho 1 foi escrito a partir do protocolo do edge-tts e a lista de
-   vozes foi confirmada no ar, mas a SÍNTESE não pôde ser testada de onde
-   este código foi escrito (o proxy de lá não passa WebSocket). O caminho 2
-   foi testado de ponta a ponta e devolveu MP3 real. Por isso a corrente
-   existe: se o 1 não subir na sua máquina, o 2 assume sem você notar.
+   ── O QUE MUDOU, E POR QUÊ ──────────────────────────────────────────────
+   Este arquivo já tentou sintetizar no próprio navegador, falando por
+   WebSocket com o serviço de leitura em voz alta do Edge. Não funciona
+   mais: a Microsoft passou a responder 403 na síntese. A lista de vozes
+   ainda responde, o que enganava — parecia vivo e não estava.
+
+   Com o caminho neural morto, toda narração caía no speechSynthesis, o TTS
+   da própria máquina. Ele existe em todo computador, e é justamente por
+   isso que soa a computador. Era o que se ouvia em TODO vídeo.
+
+   Agora a síntese acontece no servidor do Studio, em Python (studio/voz.py),
+   com o Piper: rede neural que roda na máquina do usuário, offline, sem
+   chave, sem cota e sem limite — e com vozes graves de verdade, escolhidas
+   por frequência MEDIDA, não por adjetivo. Este arquivo virou o que devia
+   ter sido desde o começo: um cliente magro de /api/voz.
+
+   A vantagem não é só timbre. O servidor devolve um Blob, e Blob serve
+   tanto para tocar quanto para ir junto no vídeo exportado — coisa que o
+   speechSynthesis nunca permitiu, porque ele fala e some.
    ========================================================================== */
 
 var VozNeural = (function () {
   "use strict";
 
-  /* Constantes do serviço de leitura em voz alta do Edge. */
-  var TOKEN = "6A5AA1D4EAFF4E9FB37E23D68491D6F4";
-  var HOST = "speech.platform.bing.com/consumer/speech/synthesize/readaloud";
-  var VERSAO_GEC = "1-130.0.2849.68";
-  /* 1601-01-01 → 1970-01-01 em segundos: o relógio do Windows começa antes. */
-  var EPOCA_WIN = 11644473600;
-
-  /* As vozes que valem para narrar em português. `grave` é o que o dono
-     chamou de densa: a que sustenta abertura de vídeo. */
-  var VOZES = [
-    { id: "pt-BR-AntonioNeural", nome: "Antônio", tom: "masculina, grave", grave: true, padrao: true },
-    { id: "pt-BR-FranciscaNeural", nome: "Francisca", tom: "feminina, calorosa" },
-    { id: "pt-BR-ThalitaMultilingualNeural", nome: "Thalita", tom: "feminina, moderna" },
-    { id: "pt-PT-DuarteNeural", nome: "Duarte", tom: "masculina de Portugal", grave: true },
-    { id: "pt-PT-RaquelNeural", nome: "Raquel", tom: "feminina de Portugal" }
-  ];
+  /* Preenchido por /api/voz/status na primeira consulta. Começa com a voz
+     padrão do servidor para a interface ter o que mostrar antes da resposta. */
+  var VOZES = [];
+  var estado = null;
+
+  function status(forcar) {
+    if (estado && !forcar) return Promise.resolve(estado);
+    return fetch("/api/voz/status")
+      .then(function (r) { return r.json(); })
+      .then(function (s) {
+        estado = s;
+        VOZES = (s.piper && s.piper.vozes) || [];
+        return s;
+      })
+      .catch(function () { return { piper: { pronta: false, vozes: [] } }; });
+  }
 
   function vozes() { return VOZES.slice(); }
-  function vozPadrao() { return VOZES[0].id; }
   function graves() { return VOZES.filter(function (v) { return v.grave; }); }
-
-  /* ---------------------------------------------------------------- DRM --- */
-
-  /* O serviço exige um token derivado do relógio, arredondado para baixo de
-     5 em 5 minutos, concatenado com a chave pública do cliente e passado por
-     SHA-256. Sem ele o servidor recusa a conexão. */
-  function selo() {
-    var ticks = Math.floor(Date.now() / 1000) + EPOCA_WIN;
-    ticks -= ticks % 300;
-    /* de segundos para intervalos de 100 nanossegundos */
-    var texto = String(ticks * 1e7) + TOKEN;
-    var bytes = new TextEncoder().encode(texto);
-    return crypto.subtle.digest("SHA-256", bytes).then(function (buf) {
-      return Array.prototype.map
-        .call(new Uint8Array(buf), function (b) { return ("0" + b.toString(16)).slice(-2); })
-        .join("")
-        .toUpperCase();
-    });
-  }
-
-  function agoraISO() {
-    return new Date().toUTCString().replace("GMT", "GMT+0000 (Coordinated Universal Time)");
+  function vozPadrao() {
+    var p = VOZES.filter(function (v) { return v.padrao; })[0];
+    return p ? p.id : "";
   }
 
-  function escapar(t) {
-    return String(t || "")
-      .replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;")
-      .replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+  /* Manda baixar o motor e a voz. A interface chama isto quando o usuário
+     escolhe uma voz que ainda não está na máquina. */
+  function instalar(voz, esperar) {
+    return fetch("/api/voz/instalar", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ voz: voz || "", esperar: esperar || 0 }),
+    }).then(function (r) { return r.json(); });
   }
 
-  /* -------------------------------------------------------------- neural -- */
+  /* --------------------------------------------------------------- fala --- */
 
-  /* Uma frase → um Blob de MP3. Abre a conexão, manda a configuração e o
-     SSML, junta os pedaços binários até o "turn.end". */
-  function pelaNeural(texto, cfg) {
+  /* O texto vira áudio pelo melhor motor que o servidor tiver pronto. O
+     navegador não decide nada: só pede e toca. */
+  function audioDe(texto, cfg) {
     cfg = cfg || {};
-    var voz = cfg.voz || vozPadrao();
-    /* Voz de narração pede um passo mais lento e um tom um pouco abaixo — é
-       o que separa locução de leitura de robô. */
-    var vel = cfg.velocidade != null ? cfg.velocidade : -8;
-    var tom = cfg.tom != null ? cfg.tom : -4;
-
-    return selo().then(function (gec) {
-      return new Promise(function (ok, erro) {
-        var url = "wss://" + HOST + "/edge/v1?TrustedClientToken=" + TOKEN
-          + "&Sec-MS-GEC=" + gec + "&Sec-MS-GEC-Version=" + VERSAO_GEC;
-        var ws;
-        try { ws = new WebSocket(url); } catch (e) { return erro(e); }
-        ws.binaryType = "arraybuffer";
-
-        var pedacos = [];
-        var fechou = false;
-        var relogio = setTimeout(function () {
-          if (!fechou) { fechou = true; try { ws.close(); } catch (e) {} erro(new Error("voz neural nao respondeu")); }
-        }, 6000);
-
-        function desistir(e) {
-          if (fechou) return;
-          fechou = true;
-          clearTimeout(relogio);
-          try { ws.close(); } catch (x) {}
-          erro(e instanceof Error ? e : new Error("voz neural falhou"));
-        }
-
-        ws.onerror = desistir;
-        ws.onclose = function () {
-          if (fechou) return;
-          fechou = true;
-          clearTimeout(relogio);
-          if (pedacos.length) ok(new Blob(pedacos, { type: "audio/mpeg" }));
-          else erro(new Error("voz neural fechou sem audio"));
-        };
-
-        ws.onopen = function () {
-          ws.send(
-            "X-Timestamp:" + agoraISO() + "\r\n"
-            + "Content-Type:application/json; charset=utf-8\r\n"
-            + "Path:speech.config\r\n\r\n"
-            + '{"context":{"synthesis":{"audio":{"metadataoptions":'
-            + '{"sentenceBoundaryEnabled":"false","wordBoundaryEnabled":"false"},'
-            + '"outputFormat":"audio-24khz-48kbitrate-mono-mp3"}}}}'
-          );
-          var ssml = '<speak version="1.0" xmlns="http://www.w3.org/2001/10/synthesis" xml:lang="pt-BR">'
-            + '<voice name="' + voz + '">'
-            + '<prosody pitch="' + tom + 'Hz" rate="' + vel + '%" volume="+0%">'
-            + escapar(texto)
-            + "</prosody></voice></speak>";
-          ws.send(
-            "X-RequestId:" + pedido() + "\r\n"
-            + "Content-Type:application/ssml+xml\r\n"
-            + "X-Timestamp:" + agoraISO() + "Z\r\n"
-            + "Path:ssml\r\n\r\n" + ssml
-          );
-        };
-
-        ws.onmessage = function (ev) {
-          if (typeof ev.data === "string") {
-            if (ev.data.indexOf("Path:turn.end") !== -1) {
-              fechou = true;
-              clearTimeout(relogio);
-              try { ws.close(); } catch (x) {}
-              if (pedacos.length) ok(new Blob(pedacos, { type: "audio/mpeg" }));
-              else erro(new Error("voz neural nao mandou audio"));
-            }
-            return;
-          }
-          /* Binário: 2 bytes de tamanho do cabeçalho, o cabeçalho, e o áudio. */
-          var b = new Uint8Array(ev.data);
-          if (b.length < 2) return;
-          var tamCabecalho = (b[0] << 8) | b[1];
-          if (b.length > 2 + tamCabecalho) pedacos.push(b.slice(2 + tamCabecalho));
-        };
-      });
-    });
-  }
-
-  function pedido() {
-    var s = "";
-    for (var i = 0; i < 32; i++) s += "0123456789abcdef"[Math.floor(Math.random() * 16)];
-    return s;
-  }
+    var t = String(texto || "").trim();
+    if (!t) return Promise.reject(new Error("sem texto"));
 
-  /* -------------------------------------------------------------- google -- */
+    var q = "texto=" + encodeURIComponent(t);
+    if (cfg.voz) q += "&voz=" + encodeURIComponent(cfg.voz);
+    if (cfg.motor) q += "&motor=" + encodeURIComponent(cfg.motor);
+    if (cfg.grave) q += "&grave=1";
+    if (cfg.velocidade) q += "&velocidade=" + encodeURIComponent(cfg.velocidade);
 
-  /* Pelo servidor do Studio: o Google não manda cabeçalho de CORS, então do
-     navegador direto o pedido morre. Uma voz só, sem escolha — mas responde. */
-  function pelaGoogle(texto) {
-    return fetch("/api/voz?texto=" + encodeURIComponent(texto)).then(function (r) {
+    return fetch("/api/voz?" + q).then(function (r) {
       if (!r.ok) throw new Error("voz do servidor falhou (" + r.status + ")");
       return r.blob();
     });
   }
 
-  /* --------------------------------------------------------------- fala --- */
-
-  /* O texto vira áudio pelo melhor caminho que responder. Devolve um Blob de
-     MP3, que serve tanto para tocar quanto para ir junto no vídeo exportado —
-     coisa que o speechSynthesis nunca permitiu, porque ele fala e some. */
-  function audioDe(texto, cfg) {
-    cfg = cfg || {};
-    var t = String(texto || "").trim();
-    if (!t) return Promise.reject(new Error("sem texto"));
+  /* Quanto tempo a narração vai levar, SEM tocar nada.
 
-    if (cfg.motor === "google") return pelaGoogle(t);
-    return pelaNeural(t, cfg).catch(function (e) {
-      if (window.console) console.warn("[voz] neural falhou, indo de Google:", e.message);
-      return pelaGoogle(t);
+     O editor precisa disso para ajustar a duração da cena ao texto. Antes
+     ele media falando com volume zero — funcionava porque o speechSynthesis
+     obedece volume. Agora o áudio vem em Blob, e "tocar mudo" seria tocar
+     alto. Os metadados do arquivo já trazem a duração exata: é só perguntar,
+     e é mais preciso do que cronometrar a fala. */
+  function duracaoDe(texto, cfg) {
+    return audioDe(texto, cfg).then(function (blob) {
+      return new Promise(function (ok) {
+        var a = new Audio();
+        var url = URL.createObjectURL(blob);
+        var respondeu = false;
+        function fim(s) {
+          if (respondeu) return;
+          respondeu = true;
+          URL.revokeObjectURL(url);
+          ok(s);
+        }
+        a.onloadedmetadata = function () {
+          fim(isFinite(a.duration) && a.duration > 0 ? a.duration : 0);
+        };
+        a.onerror = function () { fim(0); };
+        setTimeout(function () { fim(0); }, 8000);
+        a.preload = "metadata";
+        a.src = url;
+      });
     });
   }
 
@@ -232,10 +140,12 @@ var VozNeural = (function () {
       .catch(function (e) { return { ok: false, error: e.message }; });
   }
 
+  status();
+
   return {
-    vozes: vozes, vozPadrao: vozPadrao, graves: graves,
+    vozes: vozes, vozPadrao: vozPadrao, graves: graves, status: status,
+    instalar: instalar, duracaoDe: duracaoDe,
     audioDe: audioDe, falar: falar, parar: parar, falando: falando, testar: testar,
-    _selo: selo
   };
 })();