vibeeditor-render 0.2.0 → 0.3.0

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

@@ -6,7 +6,8 @@
 //   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 --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" na área de trabalho
 "use strict";
 const fs = require("node:fs");
@@ -35,6 +36,7 @@ ${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
 
@@ -44,13 +46,15 @@ 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};
   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 === "--versao" || v === "-v" || v === "--version") a.comando = "versao";
     else if (v === "--ajuda" || v === "-h" || v === "--help") a.comando = "ajuda";
@@ -229,6 +233,9 @@ async function principal() {
   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")}.`));
@@ -252,7 +259,7 @@ 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,
   });
 
   // atalho na área de trabalho, uma vez (quem abriu pelo atalho passa --sem-atalho)
@@ -266,6 +273,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

package/core/ffmpeg.js

@@ -0,0 +1,149 @@
+// ffmpeg completo para o tratamento do áudio (passa-alta, afftdn, alimiter, loudnorm, ebur128). O ffmpeg que vem
+// com o @remotion/renderer é mínimo e não tem esses filtros.
+//
+// Decisão (docs/M2-MOTOR-ETAPA1.md): baixar na primeira vez para a pasta de dados, como o navegador de render —
+// o binário estático do projeto ffmpeg-static (github.com/eugeneware/ffmpeg-static, release b6.1.1), com URL e
+// sha256 fixos aqui. Não vai dentro do pacote npm (o pacote continua pequeno e MIT), não roda script de instalação
+// no `npx` e sobrevive às atualizações (fica em <dados>/ffmpeg/6.1.1/). Esses binários são GPL-3.0 (builds com
+// x264/x265): o Vibe Render só os executa como programa separado, sem ligar código, e a licença vem junto
+// (ffmpeg.LICENSE). Ordem de busca: VIBE_FFMPEG → baixado → (sem download) o do PATH, se tiver os filtros.
+"use strict";
+const fs = require("node:fs");
+const path = require("node:path");
+const crypto = require("node:crypto");
+const zlib = require("node:zlib");
+const {spawn} = require("node:child_process");
+
+const VERSAO = "6.1.1";
+const BASE = "https://github.com/eugeneware/ffmpeg-static/releases/download/b6.1.1/";
+const LICENCA_GPL = "8ceb4b9ee5adedde47b31e975c1d90c73ad27b6b165a1dcd80c7c545eb65b903";
+// sha256 do .gz baixado e do executável descompactado (digests publicados pelo GitHub na release b6.1.1)
+const BINARIOS = {
+  "win32-x64": {gz: "8883a3dffbd0a16cf4ef95206ea05283f78908dbfb118f73c83f4951dcc06d77", exe: "04e1307997530f9cf2fe35cba2ca7e8875ca91da02f89d6c7243df819c94ad00", bytes: 29581307, licenca: LICENCA_GPL},
+  "darwin-x64": {gz: "929b375c1182d956c51f7ac25e0b2b0411fb01f6f407aa15c9758efeb4242106", exe: "ebdddc936f61e14049a2d4b549a412b8a40deeff6540e58a9f2a2da9e6b18894", bytes: 25296431, licenca: "2e1d16c72fd74e12063776371da757322f8b77589386532f4fd8634bde7de1af"},
+  "darwin-arm64": {gz: "8923876afa8db5585022d7860ec7e589af192f441c56793971276d450ed3bbfa", exe: "a90e3db6a3fd35f6074b013f948b1aa45b31c6375489d39e572bea3f18336584", bytes: 19246198, licenca: "cb48bf09a11f5fb576cddb0431c8f5ed0a60157a9ec942adffc13907cbe083f2"},
+  "linux-x64": {gz: "bfe8a8fc511530457b528c48d77b5737527b504a3797a9bc4866aeca69c2dffa", exe: "e7e7fb30477f717e6f55f9180a70386c62677ef8a4d4d1a5d948f4098aa3eb99", bytes: 29354986, licenca: LICENCA_GPL},
+  "linux-arm64": {gz: "754a678672298bc68156adff58aa7385a592c2b30b1d0ae8750c45c915c4bac0", exe: "6bb182d0d75d23028db82e9e4f723ca69b853d055698486e6984ddb2c06fb8ce", bytes: 25568691, licenca: LICENCA_GPL},
+};
+const FILTROS = ["highpass", "afftdn", "alimiter", "loudnorm", "ebur128", "atrim", "afade", "asplit", "concat", "volume", "aresample"];
+
+const chave = (plataforma = process.platform, arq = process.arch) => `${plataforma}-${arq}`;
+const nomeExe = (plataforma = process.platform) => (plataforma === "win32" ? "ffmpeg.exe" : "ffmpeg");
+const caminhoBaixado = (dirDados, plataforma = process.platform) => path.join(dirDados, "ffmpeg", VERSAO, nomeExe(plataforma));
+
+/** saída de um comando curto, sem travar o servidor (a 1ª execução de um .exe novo pode demorar no antivírus) */
+function saidaDe(exe, args) {
+  return new Promise((ok) => {
+    let out = "";
+    let p;
+    try {
+      p = spawn(exe, args, {windowsHide: true});
+    } catch {
+      return ok({status: -1, out: ""});
+    }
+    p.stdout.on("data", (d) => (out += d));
+    p.on("error", () => ok({status: -1, out}));
+    p.on("close", (status) => ok({status, out}));
+  });
+}
+
+const filtrosOk = new Map();
+/** o ffmpeg tem os filtros da cadeia de áudio? (resultado guardado por caminho) */
+async function temFiltros(ffmpeg) {
+  if (!filtrosOk.has(ffmpeg)) {
+    const r = await saidaDe(ffmpeg, ["-hide_banner", "-filters"]);
+    filtrosOk.set(ffmpeg, r.status === 0 && FILTROS.every((f) => new RegExp(`\\s${f}\\s`).test(r.out)));
+  }
+  return filtrosOk.get(ffmpeg);
+}
+
+/** versão principal (6, 7, 9…) do ffmpeg: o grafo em arquivo usa "-/filter_complex" a partir da 7 */
+async function versaoPrincipal(ffmpeg) {
+  const r = await saidaDe(ffmpeg, ["-hide_banner", "-version"]);
+  const m = /ffmpeg version n?(\d+)/.exec(r.out || "");
+  return m ? Number(m[1]) : 0;
+}
+
+/** sem baixar nada: VIBE_FFMPEG, o já baixado, ou null */
+function acharFfmpegCompleto({dirDados, env = process.env} = {}) {
+  if (env.VIBE_FFMPEG && fs.existsSync(env.VIBE_FFMPEG)) return {caminho: env.VIBE_FFMPEG, origem: "VIBE_FFMPEG"};
+  if (dirDados && fs.existsSync(caminhoBaixado(dirDados))) return {caminho: caminhoBaixado(dirDados), origem: "baixado"};
+  return null;
+}
+
+async function obter(url, {fetchImpl = fetch, sinal} = {}) {
+  const r = await fetchImpl(url, {redirect: "follow", signal: sinal});
+  if (!r.ok) throw new Error(`download do ffmpeg falhou (${r.status}) em ${url}`);
+  return r;
+}
+
+/**
+ * Baixa o ffmpeg desta plataforma para <dirDados>/ffmpeg/6.1.1/ (uma vez), conferindo o sha256 do .gz e do
+ * executável. onProgresso(fração). Devolve o caminho.
+ */
+async function baixarFfmpeg({dirDados, onProgresso, fetchImpl = fetch, sinal} = {}) {
+  const b = BINARIOS[chave()];
+  if (!b) throw new Error(`não há ffmpeg pronto para ${chave()}: instale um ffmpeg completo e defina VIBE_FFMPEG`);
+  const destino = caminhoBaixado(dirDados);
+  if (fs.existsSync(destino)) return destino;
+  const dir = path.dirname(destino);
+  fs.mkdirSync(dir, {recursive: true});
+  const tmp = `${destino}.${crypto.randomBytes(4).toString("hex")}.parte`;
+  try {
+    const r = await obter(`${BASE}ffmpeg-${chave()}.gz`, {fetchImpl, sinal});
+    const total = Number(r.headers.get("content-length")) || b.bytes;
+    const hGz = crypto.createHash("sha256"), hExe = crypto.createHash("sha256");
+    const gunzip = zlib.createGunzip();
+    const saida = fs.createWriteStream(tmp, {mode: 0o755});
+    const fim = new Promise((ok, falha) => {
+      saida.on("finish", ok); saida.on("error", falha); gunzip.on("error", falha);
+    });
+    gunzip.on("data", (c) => hExe.update(c));
+    gunzip.pipe(saida);
+    let lidos = 0;
+    for await (const pedaco of r.body) {
+      lidos += pedaco.length;
+      hGz.update(pedaco);
+      if (!gunzip.write(pedaco)) await new Promise((ok) => gunzip.once("drain", ok));
+      if (onProgresso) onProgresso(Math.min(1, lidos / total));
+    }
+    gunzip.end();
+    await fim;
+    if (hGz.digest("hex") !== b.gz || hExe.digest("hex") !== b.exe) throw new Error("o ffmpeg baixado não confere com o sha256 esperado");
+    // a licença (GPL-3.0) vai junto do binário
+    const l = await obter(`${BASE}${chave()}.LICENSE`, {fetchImpl, sinal});
+    const texto = Buffer.from(await l.arrayBuffer());
+    if (crypto.createHash("sha256").update(texto).digest("hex") !== b.licenca) throw new Error("a licença do ffmpeg não confere com o sha256 esperado");
+    fs.writeFileSync(path.join(dir, "ffmpeg.LICENSE"), texto);
+    fs.chmodSync(tmp, 0o755);
+    fs.renameSync(tmp, destino);
+    return destino;
+  } finally {
+    fs.rmSync(tmp, {force: true});
+  }
+}
+
+let emAndamento = null;
+/**
+ * O ffmpeg completo, baixando se precisar (um download por vez; quem chega junto espera o mesmo).
+ * opc: {dirDados, env, baixar (padrão true), onProgresso, fetchImpl}. Devolve {caminho, origem, versao}.
+ */
+async function garantirFfmpeg(opc = {}) {
+  const achado = acharFfmpegCompleto(opc);
+  if (achado) return {...achado, versao: await versaoPrincipal(achado.caminho)};
+  const doPath = nomeExe();
+  if (opc.baixar !== false && opc.dirDados) {
+    try {
+      if (!emAndamento) emAndamento = baixarFfmpeg(opc).finally(() => { emAndamento = null; });
+      const caminho = await emAndamento;
+      return {caminho, origem: "baixado", versao: await versaoPrincipal(caminho)};
+    } catch (e) {
+      if (await temFiltros(doPath)) return {caminho: doPath, origem: "PATH", versao: await versaoPrincipal(doPath)};
+      throw e;
+    }
+  }
+  if (await temFiltros(doPath)) return {caminho: doPath, origem: "PATH", versao: await versaoPrincipal(doPath)};
+  throw new Error("sem ffmpeg completo para tratar o áudio (defina VIBE_FFMPEG ou deixe o Vibe Render baixar)");
+}
+
+module.exports = {garantirFfmpeg, baixarFfmpeg, acharFfmpegCompleto, temFiltros, versaoPrincipal, caminhoBaixado, BINARIOS, VERSAO, FILTROS};