vibeeditor-render 0.2.0 → 0.3.0

package/core/transcricao.js

@@ -0,0 +1,197 @@
+// Transcrição no computador da pessoa, para quem não tem placa de vídeo que o navegador use (o Whisper do site
+// precisa de WebGPU; no processador do navegador leva ~6× a duração do vídeo). Aqui roda o whisper.cpp nativo,
+// com todos os núcleos: na 1ª vez baixa o programa e o modelo large-v3-turbo (~1,6 GB) para a pasta de dados.
+//
+// O site manda o áudio já em WAV mono 16 kHz (PUT /v1/arquivos/<sha>) e recebe as palavras com tempo
+// [{ini, fim, txt, prob}]; o alinhamento ao envelope e as substituições continuam no site, como no navegador.
+const os = require("node:os");
+const path = require("node:path");
+const fs = require("node:fs");
+const crypto = require("node:crypto");
+const {spawn} = require("node:child_process");
+
+const VERSAO_WHISPER = "1.7.6"; // a 1.5.5 (a do Remotion) não tem --dtw para o turbo; Mac/Linux compilam esta
+const MODELO = "large-v3-turbo";
+const TEXTO_PROMPT = (glossario) => (glossario.length ? `Aula em português do Brasil. Termos: ${glossario.join(", ")}.` : "");
+
+/** junta os itens do whisper.cpp (--max-len 1 --split-on-word: ~1 palavra por item) em palavras do transcricao.json */
+function palavrasDoWhisper(json) {
+  const palavras = [];
+  for (const item of (json && json.transcription) || []) {
+    const bruto = String(item.text || "");
+    const txt = bruto.trim();
+    if (!txt || /^\[.*\]$/.test(txt)) continue; // [_BEG_], [Música]…
+    const toks = (item.tokens || []).filter((t) => !/^\[_/.test(String(t.text || "")));
+    const prob = toks.length ? toks.reduce((s, t) => s + (Number(t.p) || 0), 0) / toks.length : 1;
+    const ini = (item.offsets && item.offsets.from) / 1000, fim = (item.offsets && item.offsets.to) / 1000;
+    // pontuação solta ("," "." "?") vai para a palavra anterior, como no faster-whisper
+    if (palavras.length && (/^[^\p{L}\p{N}]+$/u.test(txt) || !/^\s/.test(bruto))) {
+      const ant = palavras[palavras.length - 1];
+      ant.txt += txt;
+      ant.fim = Math.max(ant.fim, fim);
+      continue;
+    }
+    palavras.push({ini: Math.round(ini * 1000) / 1000, fim: Math.round(fim * 1000) / 1000, txt, prob: Math.round(prob * 1000) / 1000});
+  }
+  return palavras;
+}
+
+function validarPedido(d, cache) {
+  const erro = (m, status = 400) => Object.assign(new Error(m), {status});
+  if (!d || typeof d !== "object") throw erro("corpo inválido");
+  if (typeof d.arquivo !== "string" || !/^[a-f0-9]{64}$/.test(d.arquivo)) throw erro("arquivo precisa ser o sha256 do WAV");
+  if (!cache.existe(d.arquivo)) throw erro("envie o WAV antes (PUT /v1/arquivos/<sha>)", 409);
+  const g = d.glossario == null ? [] : d.glossario;
+  if (!Array.isArray(g) || g.length > 200 || !g.every((x) => typeof x === "string" && x.length <= 80)) throw erro("glossario: até 200 termos de até 80 letras");
+  const idioma = d.idioma == null ? "pt" : d.idioma;
+  if (!/^[a-z]{2}$/.test(idioma)) throw erro("idioma: código de 2 letras");
+  return {arquivo: d.arquivo, glossario: g.map((x) => x.replace(/[\r\n"]/g, " ").trim()).filter(Boolean), idioma};
+}
+
+/** baixa um arquivo seguindo redirecionamentos (o GitHub manda para o CDN) */
+async function baixar(url, destino, signal) {
+  const r = await fetch(url, {redirect: "follow", signal});
+  if (!r.ok) throw new Error(`download falhou (${r.status}): ${url}`);
+  fs.writeFileSync(destino, Buffer.from(await r.arrayBuffer()));
+}
+
+function rodar(bin, args, {cwd, signal, aoLinha} = {}) {
+  return new Promise((ok, falha) => {
+    const p = spawn(bin, args, {cwd, signal, windowsHide: true});
+    let fim = "";
+    const ler = (d) => {
+      const t = d.toString("utf8");
+      if (aoLinha) t.split(/\r?\n/).forEach(aoLinha);
+      fim = (fim + t).slice(-4000);
+    };
+    p.stdout.on("data", ler);
+    p.stderr.on("data", ler);
+    p.on("error", falha);
+    p.on("close", (code) => (code === 0 ? ok() : falha(new Error(`${path.basename(bin)} saiu com código ${code}: ${fim.trim().split("\n").slice(-3).join(" | ")}`))));
+  });
+}
+
+/** o whisper.cpp de verdade (injetável nos testes): binário em whisper/bin-<versão>/, modelo em whisper/ */
+function whisperCpp({dirDados}) {
+  const W = require("@remotion/install-whisper-cpp");
+  const pasta = path.join(dirDados, "whisper");
+  const pastaBin = path.join(pasta, `bin-${VERSAO_WHISPER}`);
+  const exe = () => (process.platform === "win32" ? path.join(pastaBin, "whisper-cli.exe") : W.getWhisperExecutablePath(pastaBin, VERSAO_WHISPER));
+  const modelo = path.join(pasta, `ggml-${MODELO}.bin`);
+
+  // Windows: o binário pronto do GitHub (CPU, com AVX2), extraído com o tar que vem no Windows 10+
+  async function instalarNoWindows(signal) {
+    const zip = path.join(pasta, "whisper-bin-x64.zip");
+    const tmp = path.join(pasta, `extraindo-${process.pid}`);
+    await baixar(`https://github.com/ggml-org/whisper.cpp/releases/download/v${VERSAO_WHISPER}/whisper-bin-x64.zip`, zip, signal);
+    fs.rmSync(tmp, {recursive: true, force: true});
+    fs.mkdirSync(tmp, {recursive: true});
+    // o tar.exe do Windows pelo caminho completo: um "tar" do Git no PATH entende "C:" como computador remoto
+    await rodar(path.join(process.env.SystemRoot || "C:\\Windows", "System32", "tar.exe"), ["-xf", zip, "-C", tmp], {signal});
+    const release = fs.existsSync(path.join(tmp, "Release")) ? path.join(tmp, "Release") : tmp;
+    fs.rmSync(pastaBin, {recursive: true, force: true});
+    fs.renameSync(release, pastaBin);
+    fs.rmSync(tmp, {recursive: true, force: true});
+    fs.rmSync(zip, {force: true});
+  }
+
+  return {
+    async garantir({onProgresso, signal}) {
+      fs.mkdirSync(pasta, {recursive: true});
+      if (!fs.existsSync(exe())) {
+        if (process.platform === "win32") await instalarNoWindows(signal);
+        else await W.installWhisperCpp({version: VERSAO_WHISPER, to: pastaBin, printOutput: false, signal});
+      }
+      if (!fs.existsSync(modelo)) {
+        await W.downloadWhisperModel({model: MODELO, folder: pasta, printOutput: false, signal,
+          onProgress: (baixado, total) => onProgresso && total && onProgresso(baixado / total)});
+      }
+    },
+    async transcrever(wav, {glossario, idioma, onProgresso, signal}) {
+      const prompt = TEXTO_PROMPT(glossario);
+      const threads = String(Math.max(2, Math.min(16, Math.floor((os.cpus().length || 4) * 0.75))));
+      const saida = wav.replace(/\.wav$/i, "");
+      // -ml 1 -sow: um item por palavra; --dtw: tempo de cada palavra pelo alinhamento das cabeças de atenção
+      const args = ["-m", modelo, "-f", wav, "-l", idioma, "-t", threads, "-ojf", "-of", saida, "-ml", "1", "-sow", "-pp",
+        "--dtw", MODELO.replace(/-/g, "."), ...(prompt ? ["--prompt", prompt] : [])];
+      await rodar(exe(), args, {cwd: pasta, signal, aoLinha: (l) => {
+        const m = /progress\s*=\s*(\d+)%/.exec(l);
+        if (m && onProgresso) onProgresso(Number(m[1]) / 100);
+      }});
+      try {
+        return JSON.parse(fs.readFileSync(`${saida}.json`, "utf8"));
+      } finally {
+        fs.rmSync(`${saida}.json`, {force: true});
+      }
+    },
+  };
+}
+
+/**
+ * Fila de transcrições (uma por vez: o whisper.cpp já usa os núcleos). opc: {cache, dirDados, dirTmp, whisper?}
+ * O WAV vem do cache pelo sha; o whisper.cpp exige extensão .wav, então vai uma cópia para dirTmp.
+ */
+function criarTranscricoes(opc) {
+  const W = opc.whisper || whisperCpp({dirDados: opc.dirDados});
+  const itens = new Map();
+  const fila = [];
+  let rodando = null;
+
+  const visao = (t) => ({id: t.id, status: t.status, progresso: t.progresso, etapa: t.etapa, erro: t.erro, modelo: `whisper.cpp ${VERSAO_WHISPER} · ${MODELO}`,
+    tempoMs: t.tempoMs, ...(t.status === "pronto" ? {palavras: t.palavras} : {})});
+  const mudar = (t, patch) => Object.assign(t, patch);
+
+  async function proximo() {
+    if (rodando || !fila.length) return;
+    const t = fila.shift();
+    if (t.status === "cancelado") return proximo();
+    rodando = t;
+    const ab = new AbortController();
+    t.abortar = () => ab.abort();
+    const inicio = Date.now();
+    const wav = path.join(opc.dirTmp, `${t.id}.wav`);
+    try {
+      mudar(t, {status: "preparando", etapa: "Preparando o Whisper (na 1ª vez baixa ~1,6 GB)"});
+      await W.garantir({signal: ab.signal, onProgresso: (p) => mudar(t, {etapa: `Baixando o modelo de transcrição (uma vez só) ${Math.round(p * 100)}%`})});
+      fs.mkdirSync(opc.dirTmp, {recursive: true});
+      fs.copyFileSync(opc.cache.caminho(t.pedido.arquivo), wav);
+      mudar(t, {status: "transcrevendo", etapa: "Transcrevendo", progresso: 0});
+      const json = await W.transcrever(wav, {...t.pedido, signal: ab.signal, onProgresso: (p) => mudar(t, {progresso: Math.max(0, Math.min(1, p))})});
+      mudar(t, {status: "pronto", etapa: "Pronto", progresso: 1, palavras: palavrasDoWhisper(json), tempoMs: Date.now() - inicio});
+    } catch (e) {
+      if (t.status !== "cancelado") mudar(t, {status: "erro", erro: String((e && e.message) || e).slice(0, 500), etapa: "Erro"});
+    } finally {
+      fs.rmSync(wav, {force: true});
+      rodando = null;
+      proximo();
+    }
+  }
+
+  return {
+    criar(corpo) {
+      const pedido = validarPedido(corpo, opc.cache);
+      const t = {id: crypto.randomUUID(), pedido, status: "fila", progresso: 0, etapa: "Na fila", erro: null};
+      itens.set(t.id, t);
+      // guarda só as 20 mais novas
+      for (const id of [...itens.keys()].slice(0, Math.max(0, itens.size - 20))) if (itens.get(id) !== rodando) itens.delete(id);
+      fila.push(t);
+      proximo();
+      return visao(t);
+    },
+    obter: (id) => (itens.has(id) ? visao(itens.get(id)) : null),
+    cancelar(id) {
+      const t = itens.get(id);
+      if (!t) return null;
+      if (["fila", "preparando", "transcrevendo"].includes(t.status)) {
+        mudar(t, {status: "cancelado", etapa: "Cancelado"});
+        if (t.abortar) t.abortar();
+      }
+      return visao(t);
+    },
+    cancelarTodas() {
+      for (const id of itens.keys()) this.cancelar(id);
+    },
+  };
+}
+
+module.exports = {criarTranscricoes, palavrasDoWhisper, validarPedido, whisperCpp, VERSAO_WHISPER, MODELO};

package/core/voz.js

@@ -0,0 +1,227 @@
+// VoiceStudio (voz clonada → narração) pelo Vibe Render. O VoiceStudio é um app open source que roda no
+// computador da pessoa (github.com/debpalash/VoiceStudio, API local em http://127.0.0.1:3900). O site é https
+// e não consegue falar direto com ele (CORS e o bloqueio de rede local do Chrome), então estas rotas, já com a
+// sessão do site conferida pelo servidor, repassam os pedidos para a API dele:
+//   GET  /v1/voz/config              endereço em uso {url, origem, fixo}
+//   POST /v1/voz/config {url}        troca o endereço (só 127.0.0.1/localhost), guardado em voicestudio.json
+//   GET  /v1/voz/status              /health + /profiles + /personalities numa resposta só (online ou não)
+//   POST /v1/voz/perfis              multipart → POST /profiles (clonar: name, kind, ref_audio, ref_text, language)
+//   POST /v1/voz/perfis/<id>/excluir → DELETE /profiles/<id> (a voz que já não existe conta como excluída)
+//   POST /v1/voz/gerar               multipart → POST /generate (text, profile_id ou ref_audio… → WAV)
+// Nada de IA aqui: gerar voz é determinístico. O formato das respostas do VoiceStudio muda entre versões, então
+// o status vai cru e quem interpreta é o site.
+const fs = require("node:fs");
+const path = require("node:path");
+
+const URL_PADRAO = "http://127.0.0.1:3900";
+const HOSTS_LOCAIS = new Set(["127.0.0.1", "localhost", "[::1]"]);
+const LIMITE_CORPO = 64 * 1024 * 1024; // referência de voz ou texto + referência avulsa; um WAV de 19 s tem ~1 MB
+const LIMITE_RESPOSTA = 512 * 1024 * 1024; // o WAV de um bloco
+const ARQUIVO = "voicestudio.json";
+
+/** "http://127.0.0.1:3900/" → "http://127.0.0.1:3900"; null se não for um endereço local simples */
+function urlValida(bruta) {
+  let u;
+  try {
+    u = new URL(String(bruta || "").trim());
+  } catch {
+    return null;
+  }
+  if (!["http:", "https:"].includes(u.protocol)) return null;
+  if (!HOSTS_LOCAIS.has(u.hostname.toLowerCase())) return null;
+  if (u.username || u.password || u.search || u.hash || (u.pathname && u.pathname !== "/")) return null;
+  return `${u.protocol}//${u.host}`.toLowerCase();
+}
+
+const erro = (status, mensagem, extra = {}) => Object.assign(new Error(mensagem), {status, ...extra});
+
+/** lê o corpo inteiro até `max` bytes (413 acima disso) */
+function lerCorpo(req, max) {
+  return new Promise((ok, falha) => {
+    let n = 0;
+    const partes = [];
+    req.on("data", (c) => {
+      n += c.length;
+      if (n > max) {
+        falha(erro(413, "corpo grande demais")); req.destroy();
+      } else partes.push(c);
+    });
+    req.on("end", () => ok(Buffer.concat(partes)));
+    req.on("error", falha);
+  });
+}
+
+/** detalhe do erro do VoiceStudio (FastAPI manda {detail}) */
+async function detalhe(r) {
+  try {
+    const t = await r.text();
+    try {
+      const j = JSON.parse(t);
+      const d = j && (j.detail !== undefined ? j.detail : j.erro || j.error || j);
+      return typeof d === "string" ? d : JSON.stringify(d);
+    } catch {
+      return t;
+    }
+  } catch {
+    return "";
+  }
+}
+
+/**
+ * opc: {dirDados, env, urlInicial (do --voicestudio: grava como a do site), fetch (injetável nos testes), log}
+ */
+function criarVoz(opc) {
+  const env = opc.env || process.env;
+  const buscar = opc.fetch || fetch;
+  const log = opc.log || (() => {});
+  const arq = path.join(opc.dirDados, ARQUIVO);
+
+  const salva = () => {
+    try {
+      return urlValida(JSON.parse(fs.readFileSync(arq, "utf8")).url);
+    } catch {
+      return null;
+    }
+  };
+  /** a variável de ambiente manda (fixo); senão o endereço guardado; senão o padrão do VoiceStudio */
+  function config() {
+    const daEnv = urlValida(env.VIBE_RENDER_VOICESTUDIO);
+    if (daEnv) return {url: daEnv, origem: "env", fixo: true};
+    const s = salva();
+    return s ? {url: s, origem: "salvo", fixo: false} : {url: URL_PADRAO, origem: "padrao", fixo: false};
+  }
+  function definir(bruta) {
+    const url = urlValida(bruta);
+    if (!url) throw erro(400, "Endereço inválido: use o do VoiceStudio neste computador, como http://127.0.0.1:3900");
+    fs.mkdirSync(opc.dirDados, {recursive: true});
+    fs.writeFileSync(arq, JSON.stringify({url}, null, 2));
+    return config();
+  }
+  if (opc.urlInicial) definir(opc.urlInicial);
+
+  /** um pedido ao VoiceStudio; erro com status 503 (fechado), 504 (demorou) ou o status dele */
+  async function chamar(caminho, {metodo = "GET", corpo, tipo, timeout = 8000, sinal} = {}) {
+    const {url} = config();
+    const ctl = new AbortController();
+    const t = timeout ? setTimeout(() => ctl.abort(), timeout) : null;
+    const parar = () => ctl.abort();
+    if (sinal) sinal.addEventListener("abort", parar, {once: true});
+    try {
+      const r = await buscar(url + caminho, {method: metodo, body: corpo, headers: tipo ? {"Content-Type": tipo} : {}, signal: ctl.signal, redirect: "manual"});
+      if (!r.ok) {
+        const d = await detalhe(r);
+        throw erro(r.status, `VoiceStudio respondeu ${r.status}${d ? `: ${String(d).slice(0, 300)}` : ""}`, {doVoiceStudio: true});
+      }
+      return r;
+    } catch (e) {
+      if (e.doVoiceStudio) throw e;
+      if (sinal && sinal.aborted) throw erro(499, "parado");
+      if (e.name === "AbortError") throw erro(504, "o VoiceStudio demorou demais para responder");
+      throw erro(503, `não consegui falar com o VoiceStudio em ${url} (ele está aberto?)`, {offline: true});
+    } finally {
+      if (t) clearTimeout(t);
+      if (sinal) sinal.removeEventListener("abort", parar);
+    }
+  }
+  const jsonDe = async (r, padrao) => {
+    try {
+      return await r.json();
+    } catch {
+      return padrao;
+    }
+  };
+
+  async function status() {
+    const {url} = config();
+    try {
+      const saude = await jsonDe(await chamar("/health", {timeout: 2500}), {});
+      const perfis = await jsonDe(await chamar("/profiles", {timeout: 5000}), []);
+      let estilos = [];
+      try {
+        estilos = await jsonDe(await chamar("/personalities", {timeout: 3000}), []);
+      } catch { /* versão sem estilos prontos */ }
+      return {online: true, url, saude, perfis, estilos, erro: null};
+    } catch (e) {
+      return {online: false, url, saude: null, perfis: [], estilos: [], erro: e.message};
+    }
+  }
+
+  /** tipo multipart obrigatório nas rotas que repassam formulário */
+  function multipart(req) {
+    const t = String(req.headers["content-type"] || "");
+    if (!/^multipart\/form-data;\s*boundary=/i.test(t) || t.length > 300) throw erro(415, "envie multipart/form-data");
+    return t;
+  }
+
+  /** a resposta do VoiceStudio até o site; aborta o pedido a ele se o site desistir (botão Parar) */
+  async function repassar(req, res, cors, caminho, {timeout}) {
+    const tipo = multipart(req);
+    const corpo = await lerCorpo(req, LIMITE_CORPO);
+    const ctl = new AbortController();
+    res.on("close", () => {
+      if (!res.writableFinished) ctl.abort();
+    });
+    const r = await chamar(caminho, {metodo: "POST", corpo, tipo, timeout, sinal: ctl.signal});
+    const tam = Number(r.headers.get("content-length") || 0);
+    if (tam > LIMITE_RESPOSTA) throw erro(502, "a resposta do VoiceStudio é grande demais");
+    const bytes = Buffer.from(await r.arrayBuffer());
+    if (bytes.length > LIMITE_RESPOSTA) throw erro(502, "a resposta do VoiceStudio é grande demais");
+    res.writeHead(200, {...cors, "Content-Type": r.headers.get("content-type") || "application/octet-stream", "Content-Length": bytes.length, "Cache-Control": "no-store"});
+    res.end(bytes);
+  }
+
+  /**
+   * Rotas /v1/voz/... (o servidor já conferiu Host, Origin e a sessão). `resto` = partes depois de /v1/voz.
+   * Devolve true se tratou o pedido.
+   */
+  async function rota(req, res, resto, {json, cors}) {
+    const [a, b, c] = resto;
+    try {
+      if (a === "config" && !b && req.method === "GET") return json(200, config(), cors), true;
+      if (a === "config" && !b && req.method === "POST") {
+        let d;
+        try {
+          d = JSON.parse((await lerCorpo(req, 4096)).toString("utf8") || "{}");
+        } catch (e) {
+          throw e.status ? e : erro(400, "JSON inválido");
+        }
+        const atual = definir(d && d.url);
+        log("voz", `endereço do VoiceStudio: ${atual.url}`);
+        return json(200, atual, cors), true;
+      }
+      if (a === "status" && !b && req.method === "GET") return json(200, await status(), cors), true;
+      if (a === "perfis" && !b && req.method === "POST") {
+        await repassar(req, res, cors, "/profiles", {timeout: 180000});
+        return true;
+      }
+      if (a === "perfis" && b && c === "excluir" && resto.length === 3 && req.method === "POST") {
+        if (!/^[\w.:-]{1,128}$/.test(b)) throw erro(400, "voz inválida");
+        try {
+          await chamar(`/profiles/${encodeURIComponent(b)}`, {metodo: "DELETE", timeout: 20000});
+        } catch (e) {
+          if (e.status !== 404) throw e;
+          return json(200, {ok: true, jaNaoExistia: true}, cors), true;
+        }
+        return json(200, {ok: true}, cors), true;
+      }
+      if (a === "gerar" && !b && req.method === "POST") {
+        // sem prazo: um bloco grande no processador leva minutos; o Parar do site corta
+        await repassar(req, res, cors, "/generate", {timeout: 0});
+        return true;
+      }
+      return false;
+    } catch (e) {
+      if (res.headersSent) return res.destroy(), true;
+      if (e.status === 499) return res.destroy(), true;
+      // 401/403 do VoiceStudio não podem parecer sessão inválida do Vibe Render (o site renovaria a sessão)
+      const st = e.status === 401 || e.status === 403 ? 502 : e.status || 500;
+      json(st, {erro: e.status ? e.message : "erro interno", ...(e.offline ? {offline: true} : {}), ...(e.doVoiceStudio ? {voiceStudio: e.status} : {})}, cors);
+      if (!e.status) log("erro", e.message);
+      return true;
+    }
+  }
+
+  return {config, definir, status, chamar, rota};
+}
+
+module.exports = {criarVoz, urlValida, URL_PADRAO, LIMITE_CORPO};

package/host-dist/428.bundle.js

@@ -25941,7 +25941,7 @@ var registrationPromise3 = null;
 var doRegister3 = async () => {
   const nativeSupport = await (0,encode/* canEncodeAudio */.Tc)("mp3");
   if (!nativeSupport) {
-    const { registerMp3Encoder } = await __webpack_require__.e(/* import() */ 872).then(__webpack_require__.bind(__webpack_require__, 4872));
+    const { registerMp3Encoder } = await __webpack_require__.e(/* import() */ 872).then(__webpack_require__.bind(__webpack_require__, 2491));
     registerMp3Encoder();
   }
 };

package/host-dist/872.bundle.js

@@ -1,7 +1,7 @@
 "use strict";
 (self["webpackChunkvibeeditor_render"] = self["webpackChunkvibeeditor_render"] || []).push([[872],{
 
-/***/ 4872
+/***/ 2491
 (__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
 
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {