primocode 8.11.2 → 8.13.0

package/studio/web/js/ferramentas.js

@@ -2,7 +2,10 @@
    ferramentas.js — o que cada ferramenta oferece na interface.
    ========================================================================== */
 
-var TEMAS = ["meia-noite", "claro", "papel", "neon", "brasa", "floresta"];
+// Os dez que o render.css define. A lista tinha seis: quatro temas existiam
+// no CSS, a IA podia usá-los, e o editor não os oferecia a ninguém.
+var TEMAS = ["meia-noite", "claro", "papel", "neon", "brasa", "floresta",
+  "retro", "oceano", "doce", "mono"];
 
 var PALETA = ["#ff5a36", "#ffb03a", "#f4e04d", "#2fbf7f", "#1f8fe0", "#8b5cf6",
               "#f472b6", "#ffffff", "#9aa4b2", "#111318"];

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/render.js

@@ -70,13 +70,23 @@ function aplicarFundo(no, fundo) {
 /* --------------------------------------------------------------- gráficos */
 
 function svgGrafico(e, l, a) {
-  var dados = (e.dados || []).map(function (d) {
+  /* Os dados podem chegar como "dados" ou como "itens", e o tipo como
+     "grafico", "estilo" ou "tipo".
+
+     O nome certo é `dados` + `grafico`, e é o que a spec ensina. Mas quem
+     escreve um gráfico — a IA ou uma pessoa — chuta `itens`, porque é o
+     campo de TODOS os outros elementos da mesma spec (lista, cartoes,
+     numeros usam `itens`). Com o nome trocado esta função devolvia string
+     vazia: o gráfico simplesmente não existia na tela, sem erro nenhum.
+     Aceitar as duas grafias custa uma linha e evita a falha muda. */
+  var bruto = e.dados || e.itens || [];
+  var dados = bruto.map(function (d) {
     return Array.isArray(d) ? { r: d[0], v: +d[1] || 0 } : { r: d.rotulo, v: +d.valor || 0 };
   });
   if (!dados.length) return "";
   var cores = e.cores || ["var(--c-tom)", "var(--c-tom2)", "#7c9cff", "#2fbf7f", "#f472b6", "#facc15"];
   var max = Math.max.apply(null, dados.map(function (d) { return d.v; })) || 1;
-  var tipo = e.grafico || "barras";
+  var tipo = e.grafico || e.estilo || e.tipoGrafico || "barras";
   var pad = { e: 8, d: 8, t: 14, b: 42 };
   var iw = l - pad.e - pad.d, ih = a - pad.t - pad.b;
   var p = ['<svg viewBox="0 0 ' + l + " " + a + '" width="' + l + '" height="' + a + '">'];
@@ -140,9 +150,79 @@ function svgGrafico(e, l, a) {
 var TIPOS_CONHECIDOS = { texto: 1, lista: 1, cartoes: 1, numeros: 1, tabela: 1, codigo: 1,
   citacao: 1, forma: 1, imagem: 1, icone: 1, grafico: 1, no: 1, conector: 1 };
 
+/* ── chaves de animação ──────────────────────────────────────────────────
+   Transforma a lista de instantes de um elemento numa regra @keyframes de
+   verdade e prende ela no elemento.
+
+   Os nomes precisam ser únicos por página: o mesmo documento aparece várias
+   vezes ao mesmo tempo (palco, miniaturas do painel, clipes da tira), e
+   dois @keyframes de mesmo nome com conteúdo diferente se atropelariam —
+   a última regra injetada venceria em TODAS as cópias. */
+var _nChave = 0;
+
+function _numero(v, padrao) {
+  return typeof v === "number" && isFinite(v) ? v : padrao;
+}
+
+function aplicarChaves(no, e, ctx) {
+  var chaves = e.chaves.slice().sort(function (a, b) {
+    return _numero(a.t, 0) - _numero(b.t, 0);
+  });
+
+  var nome = "ch" + (++_nChave);
+  var passos = chaves.map(function (k) {
+    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);
+    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)");
+
+    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)");
+    }
+    return pct.toFixed(3) + "%{" + linhas.join(";") + "}";
+  }).join("");
+
+  // A regra vai na RAIZ da cena, não dentro do elemento.
+  //
+  // Presa no próprio elemento ela era apagada segundos depois: quem desenha
+  // o conteúdo (texto, lista, número) escreve o innerHTML e leva junto tudo
+  // que estivesse ali. O elemento continuava com `animation-name: ch1`
+  // apontando para uma regra que não existia mais — a animação simplesmente
+  // não acontecia, sem erro nenhum no console. A cena só recebe filhos, e
+  // por isso a regra sobrevive lá.
+  var folha = document.createElement("style");
+  folha.textContent = "@keyframes " + nome + "{" + passos + "}";
+  (ctx.raiz || no).appendChild(folha);
+
+  var dur = _numero(ctx.duracao, 4);
+  no.style.animationName = nome;
+  no.style.animationDuration = dur + "s";
+  no.style.animationTimingFunction = e.suavizar === false ? "linear" : "cubic-bezier(.4,0,.2,1)";
+  no.style.animationFillMode = "both";
+  no.style.animationIterationCount = e.repetir ? "infinite" : "1";
+}
+
 function renderElemento(e, ctx) {
   var no = document.createElement("div");
   var tipo = e.tipo || "texto";
+  /* Qual elemento do documento é este nó.
+
+     O editor precisava saber, e antes deduzia pela ordem dos nós na tela.
+     A dedução estava errada: os layouts de fluxo separam cabeçalho de corpo
+     e desenham o cabeçalho primeiro, então a ordem na tela NÃO é a ordem do
+     documento. O efeito era clicar num texto e o editor selecionar outro —
+     e mexer no elemento errado. O índice vem carimbado daqui. */
+  if (ctx && ctx.ordem && ctx.ordem.has(e)) no.dataset.i = ctx.ordem.get(e);
   /* Tipo inventado ("titulo", "subtitulo"...) caía num default sem estilo:
      texto de 16px num canvas de 1920 — invisível — ou div vazio quando o
      conteúdo estava noutro campo. O servidor novo recusa; documentos velhos
@@ -178,11 +258,27 @@ function renderElemento(e, ctx) {
 
   /* animação */
   var an = e.anim || ctx.animPadrao;
-  if (an && an !== "nenhuma") {
+  if (an && an !== "nenhuma" && !(e.chaves && e.chaves.length > 1)) {
     no.setAttribute("data-an", typeof an === "string" ? an : (an.entrada || "subir"));
     no.style.setProperty("--atraso", (typeof an === "object" && an.atraso != null ? an.atraso : ctx.i * 0.09 + 0.1));
   }
 
+  /* ── chaves de animação ────────────────────────────────────────────────
+     Antes um elemento só sabia ENTRAR: escolhia-se um efeito de entrada e
+     acabava ali. Não dava para fazer nada percorrer a cena, crescer devagar
+     ou sumir no fim — que é o que separa animação de slide com efeito.
+
+     Uma chave é um instante: `{t: 0.5, x: 200, escala: 1.2}` diz onde o
+     elemento está na metade da cena. Duas ou mais viram uma animação CSS de
+     verdade, gerada aqui, com a duração da cena. O navegador interpola;
+     nós só descrevemos os pontos.
+
+     Quem tem chaves não recebe animação de entrada: as duas brigariam pelo
+     mesmo transform, e a chave é a mais específica das duas. */
+  if (ctx.animar && e.chaves && e.chaves.length > 1) {
+    aplicarChaves(no, e, ctx);
+  }
+
   switch (tipo) {
     case "texto": {
       var papel = PAPEIS[e.papel] || PAPEIS.corpo;
@@ -560,7 +656,21 @@ function renderCena(cena, doc, op) {
   // tela vertical pede tipografia maior: os padrões são calibrados em 1920x1080
   var escalaTipo = H > W ? 1.35 : 1;
   no.style.setProperty("--esc", escalaTipo);
-  var ctx = { i: 0, escalaTipo: escalaTipo, animPadrao: op.animar ? (cena.anim || "subir") : null };
+  var ctx = {
+    i: 0, escalaTipo: escalaTipo,
+    animPadrao: op.animar ? (cena.anim || "subir") : null,
+    // as chaves precisam saber quanto dura a cena para virar segundos
+    animar: !!op.animar,
+    duracao: cena.duracao || 4,
+    raiz: no,
+    // objeto do elemento -> posição dele em cena.elementos, tirada ANTES de
+    // qualquer separação por layout
+    ordem: (function () {
+      var m = new Map();
+      (cena.elementos || []).forEach(function (e, i) { m.set(e, i); });
+      return m;
+    })(),
+  };
 
   if (layout === "livre") {
     fluxo.style.padding = "0";

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