vibeeditor-render 0.2.0 → 0.3.1

package/README.md

@@ -12,7 +12,8 @@ Precisa do [Node.js](https://nodejs.org) 20 ou mais novo.
 npx vibeeditor-render@latest
 ```
 
-Na primeira vez ele baixa o navegador de render (uns 100 MB) e cria o atalho **Vibe Render** na área de
+Na primeira vez ele baixa o navegador de render (uns 100 MB) e, em segundo plano, o ffmpeg do tratamento de áudio
+(uns 30 MB; ver Licença) e cria o atalho **Vibe Render** na área de
 trabalho (Windows e Mac). Depois:
 
 1. Abra [plat.vibeeditor.com.br/editor/render](https://plat.vibeeditor.com.br/editor/render) e clique em **Conectar**.
@@ -27,10 +28,20 @@ ele instala o Node.js, se faltar, e cria o atalho.
 | `npx vibeeditor-render@latest` | abre o Vibe Render |
 | `… --codigo ABCD-2345` | pareia sem perguntar |
 | `… --pasta "C:\Videos"` | muda a pasta dos vídeos (fica guardada) |
+| `… --voicestudio http://127.0.0.1:3900` | endereço do VoiceStudio deste computador (fica guardado) |
 | `… desparear` | desliga este computador da conta |
 | `… atalho` | (re)cria o atalho na área de trabalho e sai |
 | `… --ajuda` | mostra os comandos |
 
+### Voz clonada (VoiceStudio)
+
+A página VoiceStudio do site gera a narração com a sua voz clonada pelo [VoiceStudio](https://github.com/debpalash/VoiceStudio),
+um app open source que também roda no seu computador (API em `http://127.0.0.1:3900`). O navegador não alcança
+esse app sozinho, então o Vibe Render repassa os pedidos (`/v1/voz/...`) para ele, só em endereço local
+(`127.0.0.1`, `localhost` ou `[::1]`). O endereço muda pelo site, por `--voicestudio` ou pela variável
+`VIBE_RENDER_VOICESTUDIO` (esta manda) e fica em `voicestudio.json` na pasta de dados. Os pesos do modelo padrão
+do VoiceStudio (OmniVoice) são CC-BY-NC: uso pessoal, não comercial.
+
 ## Segurança
 
 - O servidor escuta só em `127.0.0.1` (portas 47817 a 47820) e confere o cabeçalho `Host` (barra DNS rebinding).
@@ -51,11 +62,12 @@ npm install
 npm test               # núcleo, segurança, CLI
 npm start              # gera host-dist/ se faltar e abre o Vibe Render
 npm run benchmark      # renderiza scripts/amostra.tsx pelo servidor local, nos 2 presets
+node scripts/paridade-etapa1.mjs --hv <hiveverse-editor>   # Edição Simples × editor local (docs/M2-MOTOR-ETAPA1.md)
 npm pack               # o pacote como vai para o npm (prepack gera o host-dist)
 ```
 
 - `core/`: Node puro. Servidor local (`servidor.js`), fila (`jobs.js`), cache por sha256 (`cache.js`),
-  pareamento (`pareamento.js`), segurança (`seguranca.js`).
+  pareamento (`pareamento.js`), segurança (`seguranca.js`), transcrição (`transcricao.js`), VoiceStudio (`voz.js`).
 - `host/`: projeto Remotion com a composição `VibeHost`, que avalia o código gerado dentro do Chromium.
   Vira `host-dist/` no build.
 - `cli/`: o comando `vibeeditor-render`.
@@ -67,3 +79,8 @@ npm pack               # o pacote como vai para o npm (prepack gera o host-dist)
 O código deste pacote é MIT (veja `LICENSE`). Ele usa o [Remotion](https://www.remotion.dev/license), que tem
 licença própria: grátis para pessoas, organizações sem fins lucrativos e empresas de até 3 pessoas; acima
 disso, a empresa precisa de uma licença do Remotion.
+
+O tratamento de áudio usa o ffmpeg 6.1.1 estático do projeto [ffmpeg-static](https://github.com/eugeneware/ffmpeg-static)
+(release `b6.1.1`), baixado na primeira vez para `<pasta de dados>/ffmpeg/6.1.1/` com sha256 conferido. Esse binário é
+**GPL-3.0** (a licença fica ao lado, em `ffmpeg.LICENSE`) e roda como programa separado; ele não faz parte deste pacote.
+Para usar outro ffmpeg completo: `VIBE_FFMPEG=<caminho do executável>`.

package/cli/sistema.js

@@ -0,0 +1,158 @@
+// Integração com o sistema, para ninguém precisar abrir o Vibe Render na mão a cada vez que liga o computador:
+//  · início automático: sobe junto com o login (Windows: pasta Inicializar; Mac: LaunchAgent; Linux: autostart),
+//    minimizado e sem perguntar nada — o pareamento já fica salvo na pasta de dados;
+//  · link vibe-render://abrir: o botão "Abrir o Vibe Render" do site chama este link e o navegador pergunta
+//    "Abrir Vibe Render?" (Windows: registro do usuário; Linux: x-scheme-handler; Mac: um app pequeno em
+//    ~/Applications feito com o osacompile).
+// Tudo fica na conta do usuário (nada de administrador) e cada passo que falhar só é pulado.
+"use strict";
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+const {spawnSync} = require("node:child_process");
+
+const PROTOCOLO = "vibe-render";
+const COMANDO = "npx -y vibeeditor-render@latest --sem-atalho --segundo-plano";
+
+const rodar = (cmd, args) => spawnSync(cmd, args, {encoding: "utf8", windowsHide: true});
+
+/** pasta especial do Windows (Startup, Desktop…), já com OneDrive e nome traduzido */
+function pastaWindows(qual) {
+  const r = rodar("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", `[Environment]::GetFolderPath('${qual}')`]);
+  const p = String(r.stdout || "").trim();
+  return r.status === 0 && p ? p : null;
+}
+
+/** onde fica o arquivo do início automático em cada sistema */
+function arquivoInicio(plataforma = process.platform, casa = os.homedir(), env = process.env) {
+  if (plataforma === "win32") {
+    const startup = pastaWindows("Startup") || path.join(env.APPDATA || path.join(casa, "AppData", "Roaming"), "Microsoft", "Windows", "Start Menu", "Programs", "Startup");
+    return path.join(startup, "Vibe Render.cmd");
+  }
+  if (plataforma === "darwin") return path.join(casa, "Library", "LaunchAgents", "br.com.vibeeditor.render.plist");
+  return path.join(env.XDG_CONFIG_HOME || path.join(casa, ".config"), "autostart", "vibeeditor-render.desktop");
+}
+
+/** conteúdo do arquivo do início automático (minimizado, sem pausa no fim) */
+function conteudoInicio(plataforma = process.platform, dirDados = "") {
+  if (plataforma === "win32") return `@echo off\r\nstart "Vibe Render" /min cmd /c "${COMANDO}"\r\n`;
+  if (plataforma === "darwin") {
+    const log = path.join(dirDados, "inicio.log");
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key><string>br.com.vibeeditor.render</string>
+  <key>ProgramArguments</key>
+  <array><string>/bin/bash</string><string>-lc</string><string>${COMANDO}</string></array>
+  <key>RunAtLoad</key><true/>
+  <key>StandardOutPath</key><string>${log}</string>
+  <key>StandardErrorPath</key><string>${log}</string>
+</dict>
+</plist>
+`;
+  }
+  return `[Desktop Entry]
+Type=Application
+Name=Vibe Render
+Comment=Exporta os vídeos do Editor IA neste computador
+Exec=bash -lc "${COMANDO}"
+Terminal=false
+X-GNOME-Autostart-enabled=true
+`;
+}
+
+function ligarInicio({dirDados}) {
+  const arq = arquivoInicio();
+  fs.mkdirSync(path.dirname(arq), {recursive: true});
+  fs.writeFileSync(arq, conteudoInicio(process.platform, dirDados), {mode: 0o644});
+  return arq;
+}
+
+function desligarInicio() {
+  const arq = arquivoInicio();
+  const tinha = fs.existsSync(arq);
+  fs.rmSync(arq, {force: true});
+  return tinha;
+}
+
+const inicioLigado = () => fs.existsSync(arquivoInicio());
+
+/** o link vibe-render://abrir chama este iniciador (Windows/Linux); abre visível, mas sem segurar a janela */
+function registrarProtocolo({dirDados}) {
+  if (process.platform === "win32") {
+    const iniciador = path.join(dirDados, "abrir.cmd");
+    fs.writeFileSync(iniciador, `@echo off\r\nstart "Vibe Render" cmd /c "npx -y vibeeditor-render@latest --sem-atalho"\r\n`);
+    const chave = `HKCU\\Software\\Classes\\${PROTOCOLO}`;
+    const passos = [
+      ["add", chave, "/ve", "/d", "URL:Vibe Render", "/f"],
+      ["add", chave, "/v", "URL Protocol", "/d", "", "/f"],
+      ["add", `${chave}\\shell\\open\\command`, "/ve", "/d", `"${iniciador}" "%1"`, "/f"],
+    ];
+    for (const p of passos) {
+      const r = rodar("reg.exe", p);
+      if (r.status !== 0) throw new Error(`não consegui registrar o link (${String(r.stderr || r.stdout).trim()})`);
+    }
+    return `${PROTOCOLO}:// → ${iniciador}`;
+  }
+  if (process.platform === "darwin") {
+    // app de AppleScript que recebe o link e sobe o Vibe Render em segundo plano
+    const app = path.join(os.homedir(), "Applications", "Vibe Render.app");
+    fs.mkdirSync(path.dirname(app), {recursive: true});
+    const log = path.join(dirDados, "abrir.log");
+    const script = [
+      "on open location u",
+      `  do shell script "/bin/bash -lc 'nohup ${COMANDO.replace("--segundo-plano", "")} > \\"${log}\\" 2>&1 &'"`,
+      "end open location",
+      "on run",
+      `  do shell script "/bin/bash -lc 'nohup ${COMANDO.replace("--segundo-plano", "")} > \\"${log}\\" 2>&1 &'"`,
+      "end run",
+    ];
+    fs.rmSync(app, {recursive: true, force: true});
+    const r = rodar("osacompile", ["-o", app, ...script.flatMap((l) => ["-e", l])]);
+    if (r.status !== 0) throw new Error(`osacompile falhou (${String(r.stderr).trim()})`);
+    const plist = path.join(app, "Contents", "Info.plist");
+    for (const a of [
+      "Add :CFBundleIdentifier string br.com.vibeeditor.render.link",
+      "Add :CFBundleURLTypes array", "Add :CFBundleURLTypes:0 dict",
+      "Add :CFBundleURLTypes:0:CFBundleURLName string Vibe Render",
+      "Add :CFBundleURLTypes:0:CFBundleURLSchemes array",
+      `Add :CFBundleURLTypes:0:CFBundleURLSchemes:0 string ${PROTOCOLO}`,
+    ]) rodar("/usr/libexec/PlistBuddy", ["-c", a, plist]);
+    rodar("/System/Library/Frameworks/CoreServices.framework/Frameworks/LaunchServices.framework/Support/lsregister", ["-f", app]);
+    return `${PROTOCOLO}:// → ${app}`;
+  }
+  const apps = path.join(process.env.XDG_DATA_HOME || path.join(os.homedir(), ".local", "share"), "applications");
+  fs.mkdirSync(apps, {recursive: true});
+  const desk = path.join(apps, "vibeeditor-render-link.desktop");
+  fs.writeFileSync(desk, `[Desktop Entry]
+Type=Application
+Name=Vibe Render
+Exec=bash -lc "npx -y vibeeditor-render@latest --sem-atalho" %u
+Terminal=true
+NoDisplay=true
+MimeType=x-scheme-handler/${PROTOCOLO};
+`);
+  rodar("xdg-mime", ["default", "vibeeditor-render-link.desktop", `x-scheme-handler/${PROTOCOLO}`]);
+  return `${PROTOCOLO}:// → ${desk}`;
+}
+
+/** liga tudo de uma vez; devolve o que deu certo e o que foi pulado (com o motivo) */
+function integrar({dirDados, inicio = true}) {
+  const feito = [], pulado = [];
+  try {
+    feito.push(`link ${registrarProtocolo({dirDados})}`);
+  } catch (e) {
+    pulado.push(`link vibe-render:// (${e.message})`);
+  }
+  if (inicio) {
+    try {
+      feito.push(`início automático em ${ligarInicio({dirDados})}`);
+    } catch (e) {
+      pulado.push(`início automático (${e.message})`);
+    }
+  }
+  return {feito, pulado};
+}
+
+module.exports = {integrar, ligarInicio, desligarInicio, inicioLigado, registrarProtocolo, arquivoInicio, conteudoInicio, PROTOCOLO, COMANDO};

package/cli/vibeeditor-render.js

@@ -6,8 +6,11 @@
 //   vibeeditor-render                 abre (na primeira vez baixa o navegador de render e pede o código)
 //   vibeeditor-render --codigo X      pareia com o código do site sem perguntar
 //   vibeeditor-render --pasta <dir>   muda a pasta onde os vídeos são salvos (fica guardada)
-//   vibeeditor-render desparear       desliga este computador da conta
-//   vibeeditor-render atalho          (re)cria o atalho "Vibe Render" na área de trabalho
+//   vibeeditor-render --voicestudio <url>   endereço do VoiceStudio deste computador (fica guardado)
+//   vibeeditor-render desparear      desliga este computador da conta
+//   vibeeditor-render atalho          (re)cria o atalho "Vibe Render", o link vibe-render:// e o início automático
+//   vibeeditor-render sem-inicio-automatico   não abre mais junto com o computador
+//   vibeeditor-render --segundo-plano  como o início automático chama: minimizado, sem perguntar nada
 "use strict";
 const fs = require("node:fs");
 const os = require("node:os");
@@ -19,6 +22,8 @@ const PACOTE = require("../package.json");
 const VERSAO = PACOTE.version;
 const RAIZ = path.join(__dirname, "..");
 const SITE = "https://plat.vibeeditor.com.br/editor/render";
+const sistema = require("./sistema");
+const VERSAO_INTEGRACAO = 1; // sobe quando o que sistema.integrar() faz mudar
 
 // ------------------------------------------------------------------ terminal
 
@@ -35,8 +40,10 @@ ${negrito("Vibe Render")} ${cinza(`v${VERSAO}`)} · exporta os vídeos do Editor
   ${azul("npx vibeeditor-render@latest")}              abre o Vibe Render
   ${azul("npx vibeeditor-render@latest --codigo ABCD-2345")}   pareia sem perguntar
   ${azul("npx vibeeditor-render@latest --pasta \"C:\\Videos\"")}   muda a pasta dos vídeos
+  ${azul("npx vibeeditor-render@latest --voicestudio http://127.0.0.1:3900")}   endereço do VoiceStudio (voz clonada)
   ${azul("npx vibeeditor-render@latest desparear")}    desliga este computador da sua conta
-  ${azul("npx vibeeditor-render@latest atalho")}       cria o atalho na área de trabalho
+  ${azul("npx vibeeditor-render@latest atalho")}       atalho, botão "Abrir" do site e início junto com o computador
+  ${azul("npx vibeeditor-render@latest sem-inicio-automatico")}   não abre mais junto com o computador
 
 Deixe a janela aberta enquanto exporta. Para fechar: Ctrl+C.
 Ajuda: ${SITE}
@@ -44,14 +51,17 @@ Ajuda: ${SITE}
 }
 
 function lerArgs(argv) {
-  const a = {comando: null, codigo: null, pasta: null, semAtalho: false};
+  const a = {comando: null, codigo: null, pasta: null, voicestudio: null, semAtalho: false, segundoPlano: false};
   for (let i = 0; i < argv.length; i++) {
     const v = argv[i];
     if (v === "--codigo" || v === "-c") a.codigo = argv[++i] || "";
     else if (v.startsWith("--codigo=")) a.codigo = v.slice(9);
     else if (v === "--pasta") a.pasta = argv[++i] || "";
     else if (v.startsWith("--pasta=")) a.pasta = v.slice(8);
+    else if (v === "--voicestudio") a.voicestudio = argv[++i] || "";
+    else if (v.startsWith("--voicestudio=")) a.voicestudio = v.slice(14);
     else if (v === "--sem-atalho") a.semAtalho = true;
+    else if (v === "--segundo-plano") a.segundoPlano = true;
     else if (v === "--versao" || v === "-v" || v === "--version") a.comando = "versao";
     else if (v === "--ajuda" || v === "-h" || v === "--help") a.comando = "ajuda";
     else if (!v.startsWith("-") && !a.comando) a.comando = v;
@@ -200,7 +210,7 @@ async function principal() {
   const args = lerArgs(process.argv.slice(2));
   if (args.comando === "versao") return dizer(VERSAO);
   if (args.comando === "ajuda") return ajuda();
-  if (args.comando && !["desparear", "atalho"].includes(args.comando)) throw new Error(`não conheço o comando "${args.comando}". Veja: npx vibeeditor-render --ajuda`);
+  if (args.comando && !["desparear", "atalho", "sem-inicio-automatico"].includes(args.comando)) throw new Error(`não conheço o comando "${args.comando}". Veja: npx vibeeditor-render --ajuda`);
 
   const [maior] = process.versions.node.split(".").map(Number);
   if (maior < 20) throw new Error(`o Vibe Render precisa do Node.js 20 ou mais novo (este computador tem ${process.version}). Atualize em https://nodejs.org`);
@@ -224,11 +234,25 @@ async function principal() {
   }
   if (args.comando === "atalho") {
     const a = criarAtalho();
-    return dizer(a ? `${verde("✓")} Atalho criado: ${a}` : "Atalho só no Windows e no Mac. Aqui, rode: npx vibeeditor-render@latest");
+    dizer(a ? `${verde("✓")} Atalho criado: ${a}` : "Atalho na área de trabalho só no Windows e no Mac.");
+    config = {...config, semInicio: false};
+    const r = sistema.integrar({dirDados: dados});
+    for (const f of r.feito) dizer(`${verde("✓")} ${f}`);
+    for (const p of r.pulado) dizer(`${ambar("!")} Pulei: ${p}`);
+    config = {...config, atalhoCriado: true, integrado: VERSAO_INTEGRACAO}; gravarConfig();
+    return;
+  }
+  if (args.comando === "sem-inicio-automatico") {
+    const tinha = sistema.desligarInicio();
+    config = {...config, semInicio: true, integrado: VERSAO_INTEGRACAO}; gravarConfig();
+    return dizer(tinha ? `${verde("✓")} O Vibe Render não abre mais junto com o computador. Para voltar: npx vibeeditor-render@latest atalho` : "O início automático já estava desligado.");
   }
   if (args.pasta) {
     config = {...config, dirSaida: path.resolve(args.pasta)}; gravarConfig();
   }
+  if (args.voicestudio !== null && !require("../core/voz").urlValida(args.voicestudio)) {
+    throw new Error(`--voicestudio precisa ser o endereço do VoiceStudio neste computador, como http://127.0.0.1:3900 (veio "${args.voicestudio}")`);
+  }
 
   dizer(`\n${negrito(azul("▶ Vibe Render"))} ${cinza(`v${VERSAO}`)}  ${cinza("· exporta os vídeos do Editor IA neste computador")}\n`);
   versaoNova().then((v) => v && dizer(`${ambar("!")} Saiu a versão ${v}. Feche e abra de novo com ${azul("npx vibeeditor-render@latest")}.`));
@@ -236,7 +260,7 @@ async function principal() {
   const {PORTAS} = require("../core/config");
   const outra = await jaAberto(PORTAS);
   if (outra) {
-    dizer(`${ambar("!")} O Vibe Render já está aberto em outra janela (porta ${outra}). Use aquela.`);
+    if (!args.segundoPlano) dizer(`${ambar("!")} O Vibe Render já está aberto em outra janela (porta ${outra}). Use aquela.`);
     return;
   }
 
@@ -252,9 +276,18 @@ async function principal() {
   const nucleo = await criarNucleo({
     versao: VERSAO, dirDados: dados, dirSaida: () => config.dirSaida, hostDir, navegador: null, binarios: null,
     armazenamento, nomeAparelho: os.hostname(), licenseKey: config.licenseKey || process.env.REMOTION_LICENSE_KEY || null,
-    mostrarArquivo, log,
+    mostrarArquivo, log, voiceStudio: args.voicestudio || null,
   });
 
+  // link vibe-render:// (botão "Abrir" do site) e início junto com o computador: uma vez por versão da
+  // integração, também para quem já abria pelo atalho antigo (que passa --sem-atalho)
+  if (config.integrado !== VERSAO_INTEGRACAO) {
+    const r = sistema.integrar({dirDados: dados, inicio: !config.semInicio});
+    if (r.feito.length) dizer(`${verde("✓")} Daqui para a frente o Vibe Render abre sozinho junto com o computador, e o site consegue abri-lo pelo botão. ${cinza("(para desligar: npx vibeeditor-render@latest sem-inicio-automatico)")}`);
+    for (const p of r.pulado) log("integração pulada:", p);
+    config = {...config, integrado: VERSAO_INTEGRACAO}; gravarConfig();
+  }
+
   // atalho na área de trabalho, uma vez (quem abriu pelo atalho passa --sem-atalho)
   if (!args.semAtalho && !config.atalhoCriado) {
     try {
@@ -266,6 +299,15 @@ async function principal() {
 
   dizer(`${verde("✓")} Pronto e escutando só neste computador ${cinza(`(127.0.0.1:${nucleo.porta})`)}.`);
   dizer(`  Vídeos vão para: ${config.dirSaida}`);
+  if (args.voicestudio) dizer(`  VoiceStudio: ${require("../core/voz").urlValida(args.voicestudio)}`);
+
+  // ffmpeg completo do tratamento de áudio: baixa já em segundo plano (a 1ª exportação não espera por ele)
+  const ffmpeg = require("../core/ffmpeg");
+  if (!ffmpeg.acharFfmpegCompleto({dirDados: dados})) {
+    ffmpeg.garantirFfmpeg({dirDados: dados})
+      .then((f) => f.origem === "baixado" && dizer(`${verde("✓")} Tratamento de áudio pronto ${cinza(`(ffmpeg ${ffmpeg.VERSAO})`)}.`))
+      .catch((e) => dizer(`${ambar("!")} Não consegui baixar o ffmpeg do tratamento de áudio (${e.message}). Tento de novo na exportação.`));
+  }
 
   // pareamento
   let rl = null;

package/core/audio.js

@@ -1,20 +1,30 @@
-// Tratamento do áudio da fala com ffmpeg, a mesma cadeia do editor local (hv/montar.py + render.limitar_pico):
-// passa-alta → redução de ruído (afftdn, opcional) → loudnorm em 2 passadas (−14 LUFS, linear) →
-// limitador de pico com 4× de reamostragem (≤ −1,5 dBTP).
+// Tratamento do áudio da fala com ffmpeg, a mesma cadeia do editor local.
 //
-// O ffmpeg que vem com o @remotion/renderer é mínimo: não tem afftdn, alimiter nem highpass. Por isso este
-// módulo usa um ffmpeg próprio: VIBE_FFMPEG, a pasta `recursos` (se quem chama passar) ou o do PATH.
-// Para distribuir, usar um build LGPL (ex.: BtbN "win64-lgpl"): os filtros de áudio são LGPL e não precisamos do x264 nele.
+// tratarFala   — a cadeia do hv/montar.py para a linha do tempo editada: corta os trechos mantidos (fade de 8 ms
+//                nas emendas), iguala o nível de voz por trecho, passa-alta, (afftdn), limitador de folga e loudnorm
+//                em 2 passadas (linear; se o ganho estourasse o pico: ganho fixo + limitador). WAV 48 kHz.
+// limitarPico  — o último passo de todo render (hv/render.limitar_pico): pico real ≤ máximo no ARQUIVO FINAL.
+// tratarAudio  — cadeia genérica (arquivo inteiro, sem cortes), para áudio avulso.
+//
+// O ffmpeg que vem com o @remotion/renderer é mínimo (sem highpass/afftdn/alimiter/ebur128): o ffmpeg completo vem
+// de core/ffmpeg.js (VIBE_FFMPEG, baixado na pasta de dados, ou o do PATH em desenvolvimento).
 const {spawn} = require("node:child_process");
 const fs = require("node:fs");
+const os = require("node:os");
 const path = require("node:path");
+const crypto = require("node:crypto");
+const {acharFfmpegCompleto, versaoPrincipal} = require("./ffmpeg");
 
 const ALVO = {lufs: -14, tp: -1.5, lra: 11};
+const FPS = 30;
 
-function acharFfmpeg({recursos, env = process.env} = {}) {
+/** ffmpeg sem baixar nada: VIBE_FFMPEG, `recursos/ffmpeg-audio`, o baixado na pasta de dados, ou o do PATH */
+function acharFfmpeg({recursos, dirDados, env = process.env} = {}) {
   const exe = process.platform === "win32" ? "ffmpeg.exe" : "ffmpeg";
-  const candidatos = [env.VIBE_FFMPEG, recursos && path.join(recursos, "ffmpeg-audio", exe)].filter(Boolean);
-  for (const c of candidatos) if (fs.existsSync(c)) return c;
+  const achado = acharFfmpegCompleto({dirDados, env});
+  if (achado) return achado.caminho;
+  const r = recursos && path.join(recursos, "ffmpeg-audio", exe);
+  if (r && fs.existsSync(r)) return r;
   return exe; // PATH (desenvolvimento)
 }
 
@@ -48,11 +58,11 @@ async function medir(ffmpeg, entrada, opc) {
 }
 
 /**
- * Trata o áudio de `entrada` (vídeo ou áudio) e grava WAV 48 kHz em `saida`.
- * opc: {ruido: bool (afftdn), recursos, sinal: AbortSignal}
+ * Trata o áudio de `entrada` (vídeo ou áudio) inteiro e grava WAV 48 kHz em `saida`.
+ * opc: {ruido: bool (afftdn), ffmpeg, recursos, dirDados, sinal: AbortSignal}
  */
 async function tratarAudio(entrada, saida, opc = {}) {
-  const ffmpeg = acharFfmpeg(opc);
+  const ffmpeg = opc.ffmpeg || acharFfmpeg(opc);
   const m = await medir(ffmpeg, entrada, opc);
   const loud = `loudnorm=I=${ALVO.lufs}:TP=${ALVO.tp}:LRA=${ALVO.lra}:measured_I=${m.input_i}:measured_TP=${m.input_tp}:measured_LRA=${m.input_lra}:measured_thresh=${m.input_thresh}:offset=${m.target_offset}:linear=true`;
   const limite = Math.pow(10, ALVO.tp / 20).toFixed(4); // −1,5 dB → 0,8414
@@ -61,13 +71,125 @@ async function tratarAudio(entrada, saida, opc = {}) {
   return {medicaoAntes: m, ffmpeg};
 }
 
-/** mede loudness integrada e true peak de um arquivo (para conferir o resultado) */
+// ---------------------------------------------------------------- fala da linha do tempo editada (montar.py)
+
+// voz gerada (VoiceStudio): chiado de 1,5–8 kHz que engrossa ao longo da geração; afftdn com rastreio do ruído
+const REDUCAO_VOZ_GERADA = "afftdn=nr=40:nf=-70:tn=1:gs=8";
+
+/** número como o Python escreve num f-string sem formato (3.0 → "3.0"; o ffmpeg lê igual a "3") */
+const py = (v) => (Number.isInteger(v) ? `${v}.0` : String(v));
+
+/** grafo de áudio do montar._grafo_audio: trechos [[a, b]] já deslocados pelo -ss da leitura */
+function grafoFala(trechos, spec, final, ganhos) {
+  const n = trechos.length;
+  const partes = n > 1 ? [`[0:a]asplit=${n}` + trechos.map((_, i) => `[s${i}]`).join("")] : [];
+  trechos.forEach(([a, b], i) => {
+    const src = n > 1 ? `[s${i}]` : "[0:a]";
+    const d = b - a;
+    const fade = Math.min(0.008, d / 4);
+    // ganho do trecho antes do limitador e do loudnorm (eles agem na mistura já nivelada)
+    const ganho = ganhos && ganhos[i] ? `,volume=${py(ganhos[i])}dB` : "";
+    partes.push(`${src}atrim=${a.toFixed(4)}:${b.toFixed(4)},asetpts=PTS-STARTPTS,`
+      + `afade=t=in:d=${fade.toFixed(3)},afade=t=out:st=${(d - fade).toFixed(4)}:d=${fade.toFixed(3)}${ganho}[a${i}]`);
+  });
+  const entradas = trechos.map((_, i) => `[a${i}]`).join("");
+  let cadeia = `highpass=f=${spec.passa_alta_hz}`;
+  if (spec.voz_gerada) cadeia += "," + REDUCAO_VOZ_GERADA;
+  else if (spec.reducao_ruido_db) cadeia += `,afftdn=nr=${spec.reducao_ruido_db}:nf=-40`;
+  // limitador antes do loudnorm: sem folga de pico o modo linear vira dinâmico
+  cadeia += ",alimiter=limit=0.79:level=disabled";
+  partes.push(`${entradas}concat=n=${n}:v=0:a=1,${cadeia}${final}`);
+  return partes.join(";");
+}
+
+/** roda um grafo grande pelo arquivo (o Windows limita a linha de comando) */
+async function rodarGrafo(ffmpeg, versao, leitura, grafo, resto, opc) {
+  const arq = path.join(opc.dirTmp || os.tmpdir(), `vibe-grafo-${crypto.randomBytes(5).toString("hex")}.txt`);
+  fs.writeFileSync(arq, grafo, "utf8");
+  try {
+    const flag = versao >= 7 ? ["-/filter_complex", arq] : ["-filter_complex_script", arq];
+    return await rodar(ffmpeg, ["-nostats", ...leitura, ...flag, ...resto], opc);
+  } finally {
+    fs.rmSync(arq, {force: true});
+  }
+}
+
+/**
+ * A fala da linha do tempo editada, tratada como no montar.py. spec (vem do job, já validado):
+ *   trechos [[ini, fim]] no tempo do original, ganhos_db [] (um por trecho), lufs_alvo, pico_dbtp (alvo do loudnorm,
+ *   já com a folga), passa_alta_hz, reducao_ruido_db, voz_gerada.
+ * opc: {ffmpeg, versao, sinal, dirTmp}. Grava WAV 48 kHz 16 bits em `saida`; devolve a medição e o modo usado.
+ */
+async function tratarFala(entrada, saida, spec, opc = {}) {
+  const ffmpeg = opc.ffmpeg || acharFfmpeg(opc);
+  const versao = opc.versao || (await versaoPrincipal(ffmpeg));
+  const alvo = spec.lufs_alvo, tp = spec.pico_dbtp;
+  // lê só o pedaço do original que interessa (amostra não decodifica o vídeo todo)
+  const t0 = spec.trechos[0][0], tN = spec.trechos[spec.trechos.length - 1][1];
+  const ofs = Math.max(0, Math.trunc((t0 - 1.0) * FPS) / FPS);
+  const leitura = ["-ss", ofs.toFixed(4), "-to", (tN + 0.5).toFixed(4), "-i", entrada];
+  const trechos = spec.trechos.map(([a, b]) => [a - ofs, b - ofs]);
+
+  const g1 = grafoFala(trechos, spec, `,loudnorm=I=${py(alvo)}:TP=${py(tp)}:LRA=11:print_format=json[aout]`, spec.ganhos_db);
+  const log = await rodarGrafo(ffmpeg, versao, leitura, g1, ["-map", "[aout]", "-f", "null", "-"], opc);
+  const achados = log.match(/\{[^{}]*"input_i"[^{}]*\}/g);
+  if (!achados) throw new Error("loudnorm não devolveu a medição");
+  const m = JSON.parse(achados[achados.length - 1]);
+
+  // loudnorm só é linear se o ganho não estourar o pico; senão vira compressor dinâmico (puxa pausas e chiado
+  // para cima). Nesse caso: ganho fixo + limitador.
+  const ganho = alvo - Number(m.input_i);
+  const linear = Number(m.input_tp) + ganho <= tp;
+  const ln = linear
+    ? `,loudnorm=I=${py(alvo)}:TP=${py(tp)}:LRA=11:measured_I=${m.input_i}:measured_TP=${m.input_tp}:measured_LRA=${m.input_lra}`
+      + `:measured_thresh=${m.input_thresh}:offset=${m.target_offset}:linear=true,aresample=48000[aout]`
+    : `,volume=${ganho.toFixed(2)}dB,alimiter=limit=${Math.pow(10, tp / 20).toFixed(4)}:attack=1:release=60:level=disabled,aresample=48000[aout]`;
+  const g2 = grafoFala(trechos, spec, ln, spec.ganhos_db);
+  fs.mkdirSync(path.dirname(saida), {recursive: true});
+  await rodarGrafo(ffmpeg, versao, leitura, g2, ["-y", "-v", "error", "-map", "[aout]", "-c:a", "pcm_s16le", saida], opc);
+  return {loudnorm_medido: m, normalizacao: linear ? "loudnorm linear" : `ganho ${ganho >= 0 ? "+" : ""}${ganho.toFixed(1)} dB + limitador`, ffmpeg};
+}
+
+// ---------------------------------------------------------------- pico real no arquivo final (render.limitar_pico)
+
+/** mede loudness integrada, LRA e true peak de um arquivo */
 async function medirLoudness(arquivo, opc = {}) {
-  const log = await rodar(acharFfmpeg(opc), ["-i", arquivo, "-vn", "-af", "ebur128=peak=true", "-f", "null", "-"], opc);
+  const log = await rodar(opc.ffmpeg || acharFfmpeg(opc), ["-nostats", "-i", arquivo, "-vn", "-af", "ebur128=peak=true", "-f", "null", "-"], opc);
   const resumo = log.slice(log.lastIndexOf("Summary:"));
-  const lufs = Number((resumo.match(/I:\s+(-?[\d.]+) LUFS/) || [])[1]);
-  const tp = Number((resumo.match(/Peak:\s+(-?[\d.]+) dBFS/) || [])[1]);
-  return {lufs, tp};
+  const num = (re) => {
+    const v = (resumo.match(re) || [])[1];
+    return v === undefined ? NaN : v === "-inf" ? -99 : Number(v);
+  };
+  return {lufs: num(/I:\s+(-?[\d.]+|-inf) LUFS/), lra: num(/LRA:\s+(-?[\d.]+|-inf) LU/), tp: num(/Peak:\s+(-?[\d.]+|-inf) dBFS/)};
+}
+
+/**
+ * Último passo de todo render: o limitador da montagem age antes das compressões AAC, e cada compressão cria
+ * picos novos. Aqui o áudio passa por um limitador com 4× de superamostragem, é recodificado (AAC 256k) e medido
+ * de novo — se ainda passar, aperta o limite e repete. O vídeo é copiado. Troca `video` no lugar.
+ */
+async function limitarPico(video, picoMaxDbtp, opc = {}) {
+  const ffmpeg = opc.ffmpeg || acharFfmpeg(opc);
+  // a medição do arquivo final também vai para a conferência da amostra (LUFS/LRA/pico, como o conferir.py)
+  const m0 = await medirLoudness(video, {...opc, ffmpeg});
+  const antes = m0.tp;
+  if (antes <= picoMaxDbtp - 0.2) return {pico_dbtp: antes, limitado: false, lufs: m0.lufs, lra: m0.lra};
+  const tmp = video.replace(/(\.\w+)$/, "_pico$1");
+  let limiteDb = picoMaxDbtp - 0.5, m = m0;
+  try {
+    for (let i = 0; i < 4; i++) {
+      await rodar(ffmpeg, ["-y", "-v", "error", "-i", video, "-map", "0", "-c:v", "copy",
+        "-af", `aresample=192000,alimiter=limit=${Math.pow(10, limiteDb / 20).toFixed(4)}:attack=1:release=60:level=disabled,aresample=48000`,
+        "-c:a", "aac", "-b:a", "256k", "-movflags", "+faststart", tmp], opc);
+      m = await medirLoudness(tmp, {...opc, ffmpeg});
+      if (m.tp <= picoMaxDbtp) break;
+      limiteDb -= (m.tp - picoMaxDbtp) + 0.3;
+    }
+    fs.renameSync(tmp, video);
+  } finally {
+    fs.rmSync(tmp, {force: true});
+  }
+  return {pico_dbtp: m.tp, limitado: true, antes_dbtp: antes, lufs: m.lufs, lra: m.lra};
 }
 
-module.exports = {tratarAudio, medirLoudness, acharFfmpeg, ALVO};
+module.exports = {tratarAudio, tratarFala, grafoFala, limitarPico, medirLoudness, acharFfmpeg, ALVO, REDUCAO_VOZ_GERADA};

package/core/cache.js

@@ -45,6 +45,26 @@ function criarCache(dir, {limiteBytes}) {
     }
   }
 
+  /** põe no cache um arquivo gerado aqui (ex.: o áudio tratado), endereçado pelo sha256 dele; devolve o sha */
+  async function adotar(arquivo) {
+    const hash = crypto.createHash("sha256");
+    await pipeline(fs.createReadStream(arquivo), new Transform({transform(c, _e, cb) {
+      hash.update(c); cb();
+    }}));
+    const sha = hash.digest("hex");
+    const destino = caminho(sha);
+    if (fs.existsSync(destino)) fs.rmSync(arquivo, {force: true});
+    else {
+      try {
+        fs.renameSync(arquivo, destino);
+      } catch {
+        fs.copyFileSync(arquivo, destino); fs.rmSync(arquivo, {force: true});
+      }
+    }
+    tocar(sha);
+    return sha;
+  }
+
   /** marca uso (o limpador tira primeiro o que está há mais tempo sem uso) */
   function tocar(sha) {
     const t = new Date();
@@ -68,7 +88,7 @@ function criarCache(dir, {limiteBytes}) {
     return total;
   }
 
-  return {dir, caminho, existe, guardar, tocar, limpar};
+  return {dir, caminho, existe, guardar, adotar, tocar, limpar};
 }
 
 module.exports = {criarCache};

package/core/config.js

@@ -25,6 +25,11 @@ const PRESETS = {
   rascunho: {ladoCurto: 720, crf: 23, x264Preset: "veryfast", jpegQuality: 80},
   // lado curto em 1080, qualidade de entrega
   final: {ladoCurto: 1080, crf: 18, x264Preset: "medium", jpegQuality: 92},
+  // 2K e 4K: a composição continua no tamanho do layout (1080 de lado curto) e o Chromium renderiza com escala
+  // maior, como o --scale do editor local: texto, legenda e motions saem nítidos e o vídeo do apresentador vem
+  // do original (4K do iPhone fica 4K de verdade). Por isso estes dois podem AUMENTAR a escala.
+  "2k": {ladoCurto: 1440, crf: 18, x264Preset: "medium", jpegQuality: 92, aumenta: true},
+  "4k": {ladoCurto: 2160, crf: 18, x264Preset: "medium", jpegQuality: 92, aumenta: true},
 };
 
 const STATUS_INTERVALO = 10 * 60000; // reconferir o pareamento com o servidor