primocode 8.36.0 → 8.38.0

package/lib/fala.js

@@ -0,0 +1,146 @@
+/**
+ * fala.js — a voz do terminal: como cada coisa que vai e vem é desenhada.
+ *
+ *   "Melhore o layout das mensagens que vão e vem, deve ficar mais bonito.
+ *    Não deve aparecer erros [...]. Nunca mostrar limitações tipo limite do
+ *    minuto, tudo deve ocorrer ocultamente; deve mostrar um pensamento e
+ *    coisas com aquela sua personalidade tipo: 'vídeo está em formato
+ *    inválido, vou convertê-lo para mp4' / Bash (comando) / 'Feito,
+ *    continuando...'"
+ *
+ * ── UM LUGAR SÓ ─────────────────────────────────────────────────────────
+ * Antes cada arquivo desenhava do seu jeito: o act.js com `⎿` para cabeçalho
+ * E resultado (tudo no mesmo nível, sem hierarquia), o bin com `c.white`
+ * solto para a resposta do chat, e os avisos do encanamento ("limite do
+ * minuto", "conversa encolhida", "o modelo tropeçou") saindo na tela como se
+ * fossem parte do trabalho. Aqui mora a gramática inteira:
+ *
+ *   ❯ o que a pessoa pediu                        (o prompt, no bin)
+ *     ✦ o vídeo veio em .avi, vou converter        pensamento()
+ *     ● Bash  ffmpeg -y -i entrada.avi saida.mp4   acao()
+ *       ⎿ exit 0                                   resultado() + act.logResult
+ *     ✦ Feito, continuando.                        pensamento()
+ *
+ *   ● A resposta, alinhada ao ❯ de quem perguntou. resposta() / fluxo()
+ *
+ * O ❯ e o ● têm a mesma cor no mesmo nível: pergunta e resposta se espelham;
+ * o trabalho entre os dois fica recuado, como um parêntese que se lê depois.
+ *
+ * ── O QUE NÃO APARECE ───────────────────────────────────────────────────
+ * Limite do minuto, encolhimento da conversa, tropeço na chamada de função,
+ * resposta vazia, troca de modelo, chamada repetida: nada disso é do usuário.
+ * O que ele vê é o spinner de sempre girando um pouco mais. `problema()` é o
+ * único caminho de erro para a tela, e sai calmo — âmbar, uma linha, sem
+ * JSON: quem chega ali é o que a pessoa PRECISA fazer (crédito, chave,
+ * rede), nunca o que o encanamento passou para chegar até aqui.
+ */
+
+'use strict';
+
+const { c, actionHeader, friendlyError } = require('./ui');
+
+/* Até este tamanho, o texto que o modelo escreve antes de chamar uma tool é
+   guardado e sai de uma vez, como pensamento. Passou disso sem tool à vista,
+   é resposta — e volta a correr na tela conforme chega. Uma frase de
+   narração tem 60-150 caracteres; 320 dá folga para duas. */
+const LIMIAR_PENSAMENTO = 320;
+
+const ident = (n) => '  '.repeat(n || 0);
+
+function linhas(texto) {
+    return String(texto || '').replace(/\r/g, '').trim().split('\n').map((l) => l.trimEnd());
+}
+
+/** O que o Primo pensa antes de agir: recuado, cinza, com ✦. */
+function pensamento(texto, profundidade) {
+    const ls = linhas(texto);
+    if (!ls.length || !ls[0]) return '';
+    const p = ident(profundidade);
+    const saida = ls.map((l, i) => `${p}  ${i === 0 ? c.dim('✦') : ' '} ${c.muted(l)}`).join('\n');
+    console.log(saida);
+    return saida;
+}
+
+/** A ação (tool) que ele decidiu fazer. */
+function acao(name, args, profundidade) {
+    const saida = ident(profundidade) + actionHeader(name, args);
+    console.log(saida);
+    return saida;
+}
+
+/** O prefixo das linhas de resultado: embaixo da ação, um degrau para dentro. */
+function resultado(profundidade) {
+    return ident(profundidade) + c.muted('    ⎿ ');
+}
+
+function formatar(texto, marca) {
+    return linhas(texto).map((l, i) => (i === 0 ? `${marca} ${c.white(l)}` : `  ${c.white(l)}`)).join('\n');
+}
+
+/** A resposta final, pronta. Espelha o ❯ de quem perguntou. */
+function resposta(texto) {
+    if (!String(texto || '').trim()) return '';
+    const saida = '\n' + formatar(texto, c.brand('●'));
+    console.log(saida);
+    return saida;
+}
+
+/** O que precisa ser dito e não é resposta: parou, não concluiu, tem algo a
+ *  fazer. Âmbar, nunca vermelho — é aviso, não catástrofe. */
+function aviso(texto) {
+    if (!String(texto || '').trim()) return '';
+    const saida = '\n' + formatar(texto, c.warn('●'));
+    console.log(saida);
+    return saida;
+}
+
+/** Um erro que chegou até aqui. Passa pelo friendlyError e sai como aviso. */
+function problema(erro) {
+    return aviso(friendlyError(erro));
+}
+
+/** A frase humana de um erro, para quem precisa do texto e não da tela. */
+const frase = friendlyError;
+
+/**
+ * A resposta que chega em pedaços (o chat, e a resposta longa do agente).
+ * O `●` sai no primeiro pedaço; quebra de linha dentro do texto ganha o
+ * recuo, para o bloco continuar alinhado ao marcador.
+ */
+function fluxo() {
+    let escreveu = false;
+    return {
+        escrever(delta) {
+            const t = String(delta || '');
+            if (!t) return;
+            if (!escreveu) { process.stdout.write('\n' + c.brand('●') + ' '); escreveu = true; }
+            process.stdout.write(c.white(t.replace(/\n/g, '\n  ')));
+        },
+        fechar() { if (escreveu) process.stdout.write('\n'); },
+        escreveu: () => escreveu,
+    };
+}
+
+/** Vários agentes saindo juntos. */
+function paralelo(quantos, profundidade) {
+    const saida = `${ident(profundidade)}  ${c.brand('◆')} ${c.bold('Agentes')}  ${c.muted(`${quantos} em paralelo`)}`;
+    console.log(saida);
+    return saida;
+}
+
+/** Um agente delegado começando: "◆ Agente·frontend  a folha de estilo". */
+function agente(rotulo, descricao, profundidade) {
+    const saida = `${ident(profundidade)}  ${c.brand('◆')} ${c.bold(rotulo || 'Agente')}${descricao ? '  ' + c.muted(descricao) : ''}`;
+    console.log(saida);
+    return saida;
+}
+
+/** …e voltando, com o resumo dele embaixo, como um resultado. */
+function agenteVoltou(resumo, profundidade) {
+    const texto = String(resumo || 'sem resultado').replace(/\s+/g, ' ').trim();
+    const saida = resultado(profundidade) + c.muted(texto.length > 140 ? texto.slice(0, 139) + '…' : texto);
+    console.log(saida);
+    return saida;
+}
+
+module.exports = { LIMIAR_PENSAMENTO, pensamento, acao, resultado, resposta, aviso, problema, frase, fluxo, paralelo, agente, agenteVoltou };

package/lib/studio.js

@@ -410,7 +410,13 @@ const TIPOS_MIDIA = {
     '.mp4': 1, '.webm': 1, '.mov': 1,
 };
 
-const midiaListar = () => comStudio(async () => ({ ok: true, midia: await pedir('GET', '/api/midia') }));
+const midiaListar = () => comStudio(async () => {
+    const lista = await pedir('GET', '/api/midia');
+    // As cópias `.compat.webm` são encanamento da exportação escondida (ver
+    // `compativel`), não mídia do usuário: listá-las faria o agente usá-las.
+    const midia = Array.isArray(lista) ? lista.filter((m) => !/\.compat\.webm$/i.test(String((m && (m.nome || m.url)) || ''))) : lista;
+    return { ok: true, midia };
+});
 
 /* O caminho como ele chega quando a pessoa ARRASTA o arquivo para o terminal.
  *
@@ -450,7 +456,25 @@ const midiaEnviar = ({ arquivo, nome }) => comStudio(async () => {
 
     const ext = path.extname(caminho).toLowerCase();
     if (!TIPOS_MIDIA[ext]) {
-        return { ok: false, error: `Formato não aceito: ${ext}`, aceitos: Object.keys(TIPOS_MIDIA).join(' ') };
+        // O erro traz o CONSERTO: o comando pronto. É o que faz "o vídeo veio
+        // em .avi, vou converter para mp4 / Bash / feito, continuando" ser o
+        // que acontece, em vez de "formato não aceito" e a tarefa morrendo —
+        // o modelo copia o comando, roda e manda o arquivo certo.
+        const base = caminho.replace(/\.[^.]+$/, '');
+        const pareceAudio = /^\.(wma|aiff?|amr|mid|midi|ra|au|ape|mka)$/.test(ext);
+        const pareceImagem = /^\.(heic|heif|bmp|tiff?|ico|psd|raw|cr2|nef)$/.test(ext);
+        const comando = pareceAudio
+            ? `ffmpeg -y -i "${caminho}" -vn -c:a libmp3lame -q:a 2 "${base}.mp3"`
+            : pareceImagem
+                ? `ffmpeg -y -i "${caminho}" "${base}.png"`
+                : `ffmpeg -y -i "${caminho}" -c:v libx264 -pix_fmt yuv420p -c:a aac -movflags +faststart "${base}.mp4"`;
+        return {
+            ok: false,
+            error: `Formato não aceito: ${ext}. Converta com run_shell e mande o arquivo convertido: ${comando}`,
+            aceitos: Object.keys(TIPOS_MIDIA).join(' '),
+            comando,
+            semFfmpeg: 'brew install ffmpeg · sudo apt-get install -y ffmpeg · winget install Gyan.FFmpeg',
+        };
     }
     const bytes = fs.statSync(caminho).size;
     const ehVideo = ext === '.mp4' || ext === '.webm' || ext === '.mov';
@@ -519,11 +543,38 @@ function enviarArquivo(caminho, nome) {
  * `abrir` é injetado (é a função de abrir navegador do tools.js) para esta
  * camada não passar a conhecer o sistema operacional.
  */
-const analisarAudio = ({ arquivo, pausa, manter, repetida, abrir }) => comStudio(async () => {
+const analisarAudio = ({ arquivo, pausa, manter, repetida, abrir, escondido }) => comStudio(async () => {
     if (!arquivo) return { ok: false, error: 'Diga qual mídia analisar (arquivo: "/midia/x.mp4").' };
-    const tarefa = await pedir('POST', '/api/analise', { arquivo, pausa, manter, repetida });
-    if (abrir) { try { abrir(`${BASE}${tarefa.pagina}`); } catch { /* segue e expira */ } }
+    // No navegador escondido a conta roda sobre a cópia que ele decodifica
+    // (ver `compativel`); o resultado vale para o original, que é o que o
+    // agente escreve nas cenas — a linha do tempo é a mesma.
+    let alvo = arquivo;
+    if (escondido) {
+        // Vídeo SEM faixa de áudio: não há pausa para achar, e a página só
+        // saberia dizer "não consegui decodificar" — que manda o agente caçar
+        // um formato errado que não existe. Quem tem ffprobe pergunta antes.
+        if (!temAudio(noDisco(arquivo))) {
+            return { ok: false, semAudio: true,
+                error: 'Este vídeo não tem faixa de áudio: não há pausa nem fala para cortar. Use-o inteiro num '
+                    + 'clipe só (sem "de"/"ate") e, se quiser voz, escreva "narracao" na cena — ela entra por cima.' };
+        }
+        const c = await compativel(arquivo, escondido);
+        if (c.aviso) return { ok: false, error: c.aviso };
+        alvo = c.url;
+    }
+    const tarefa = await pedir('POST', '/api/analise', { arquivo: alvo, pausa, manter, repetida });
+    // `abrir` pode devolver a aba escondida (com `fechar`) ou nada (o
+    // navegador da pessoa). A aba fica de pé até a análise voltar.
+    let aba = null;
+    if (abrir) { try { aba = await abrir(`${BASE}${tarefa.pagina}`); } catch { /* segue e expira */ } }
+    try {
+        return await esperarAnalise(tarefa, arquivo);
+    } finally {
+        if (aba && typeof aba.fechar === 'function') { try { await aba.fechar(); } catch { /* já fechou */ } }
+    }
+});
 
+async function esperarAnalise(tarefa, arquivo) {
     // Um vídeo de meia hora leva alguns segundos para decodificar; três
     // minutos é folga com sobra, e continua sendo um teto — sem ele um
     // navegador que nunca abriu deixaria a tarefa pendurada para sempre.
@@ -533,7 +584,16 @@ const analisarAudio = ({ arquivo, pausa, manter, repetida, abrir }) => comStudio
         const estado = await pedir('GET', `/api/analise/${tarefa.id}`, null, 8000).catch(() => null);
         if (!estado) continue;
         if (estado.estado === 'erro') {
-            return { ok: false, error: (estado.resultado && estado.resultado.erro) || 'a análise falhou' };
+            const erro = String((estado.resultado && estado.resultado.erro) || 'a análise falhou');
+            // O erro do navegador é genérico; o que o agente precisa é do
+            // caminho a seguir, e ele é o mesmo nos dois casos que produzem
+            // essa frase (sem faixa de áudio; formato que o navegador não lê).
+            if (/decode audio|decodeAudioData|EncodingError/i.test(erro)) {
+                return { ok: false, error: 'Não consegui ler o áudio deste arquivo — ele pode não ter faixa de áudio, '
+                    + 'ou estar num formato que o navegador não decodifica. Siga sem o corte automático: use o vídeo '
+                    + 'inteiro num clipe só (sem "de"/"ate"), ou converta com ffmpeg para mp4 (H.264/AAC) e mande de novo.' };
+            }
+            return { ok: false, error: erro };
         }
         if (estado.estado === 'pronto') {
             const r = estado.resultado || {};
@@ -568,11 +628,260 @@ const analisarAudio = ({ arquivo, pausa, manter, repetida, abrir }) => comStudio
             + 'Siga sem o corte automático: escreva os trechos que o usuário pedir, ou use o vídeo inteiro '
             + 'num clipe só (sem "de"/"ate").',
     };
-});
+}
+
+/* ── Exportar o vídeo sem ninguém clicar ────────────────────────────────
+ *
+ *   "Ele libera, você volta ao terminal... faz testes pedindo vídeo e pra ele
+ *    editar vídeos."
+ *
+ * O botão "Baixar" do player já monta o arquivo certo (cena a cena, com a
+ * narração, a trilha e os clipes mixados). O que faltava era ALGUÉM clicar:
+ * o agente entregava um link e dizia "clique em baixar". Aqui a mesma página
+ * roda num navegador escondido, gera pelo MESMO caminho do botão
+ * (Player.exportar) e devolve o arquivo ao estúdio; daqui ele vai para a
+ * pasta do projeto, em .mp4 quando há ffmpeg.
+ *
+ * ── O NAVEGADOR ESCONDIDO NÃO LÊ H.264 ─────────────────────────────────
+ * O Chromium do Playwright (o que existe em CI e em máquina sem Chrome) não
+ * traz H.264 nem AAC — são patentes. Um .mp4 do usuário abre lá em PRETO e
+ * MUDO, sem erro nenhum, e o export sairia "perfeito" com um buraco no meio.
+ * `capacidadesDoNavegador` pergunta uma vez; `compativel` converte o que ele
+ * não lê para uma cópia .webm (VP8/Opus), feita uma vez e guardada ao lado. O
+ * mp4 original continua sendo o que a pessoa vê e edita.
+ */
+
+const MIDIA_DIR = path.join(CASA, 'midia');
+
+let ffmpegConhecido = null;
+function temFfmpeg() {
+    if (ffmpegConhecido !== null) return ffmpegConhecido;
+    try { execSync('ffmpeg -version', { stdio: 'ignore', timeout: 5000 }); ffmpegConhecido = true; }
+    catch { ffmpegConhecido = false; }
+    return ffmpegConhecido;
+}
+
+function ffmpeg(args, timeoutMs) {
+    const { execFile } = require('child_process');
+    return new Promise((ok, falha) => {
+        execFile('ffmpeg', ['-y', '-hide_banner', '-loglevel', 'error', ...args],
+            { timeout: timeoutMs || 30 * 60 * 1000, maxBuffer: 8 * 1024 * 1024 }, (erro, so, se) => {
+                if (erro) return falha(new Error('ffmpeg: ' + String(se || erro.message).trim().split('\n').pop()));
+                ok();
+            });
+    });
+}
+
+let capacidades = null;
+async function capacidadesDoNavegador(escondido) {
+    if (capacidades) return capacidades;
+    try {
+        const r = await escondido(`${BASE}/`, {
+            prazo: 15000,
+            script: `(function(){ var v = document.createElement('video');
+                window.__primo = { h264: !!v.canPlayType('video/mp4; codecs="avc1.42E01E"'),
+                                   aac: !!v.canPlayType('audio/mp4; codecs="mp4a.40.2"'),
+                                   mp4Grava: !!(window.MediaRecorder && MediaRecorder.isTypeSupported('video/mp4')) }; })()`,
+        });
+        capacidades = (r && r.valor) || { h264: false, aac: false, mp4Grava: false };
+    } catch {
+        // Sem navegador escondido nesta máquina: quem vai tocar é o da pessoa,
+        // e o dela (Chrome, Edge, Safari) lê tudo.
+        capacidades = { h264: true, aac: true, mp4Grava: false, semEscondido: true };
+    }
+    return capacidades;
+}
+
+/* O arquivo tem faixa de áudio? Sem ffprobe, "não sei" — e "não sei" é sim:
+   a página ainda vai tentar, e o erro dela é traduzido em esperarAnalise. */
+function temAudio(caminho) {
+    if (!caminho || !fs.existsSync(caminho) || !temFfmpeg()) return true;
+    try {
+        const saida = execSync(`ffprobe -v error -select_streams a -show_entries stream=codec_type -of csv=p=0 "${caminho}"`,
+            { encoding: 'utf8', timeout: 20000, stdio: ['ignore', 'pipe', 'ignore'] });
+        return /audio/.test(saida);
+    } catch { return true; }
+}
+
+/* A URL "/midia/x.mp4" → o arquivo no disco. */
+function noDisco(url) {
+    const nome = path.basename(decodeURIComponent(String(url || '').replace(/^\/midia\//, '')));
+    return nome && !nome.includes('..') ? path.join(MIDIA_DIR, nome) : null;
+}
+
+/* Devolve uma URL que o navegador escondido consegue tocar. */
+async function compativel(url, escondido) {
+    const ext = path.extname(String(url || '')).toLowerCase();
+    if (!['.mp4', '.mov', '.m4a', '.aac'].includes(ext)) return { url };
+    const cap = await capacidadesDoNavegador(escondido);
+    const ehAudio = ext === '.m4a' || ext === '.aac';
+    if (ehAudio ? cap.aac : (cap.h264 && cap.aac)) return { url };
+    const origem = noDisco(url);
+    if (!origem || !fs.existsSync(origem)) return { url };
+    if (!temFfmpeg()) {
+        return { url, aviso: 'O navegador escondido não decodifica H.264/AAC e não há ffmpeg para converter: '
+            + 'o clipe sairia preto e mudo. Instale o ffmpeg (brew install ffmpeg · sudo apt-get install -y ffmpeg · '
+            + 'winget install Gyan.FFmpeg) e chame de novo.' };
+    }
+    const destino = origem.replace(/\.[^.]+$/, '') + '.compat.webm';
+    if (!fs.existsSync(destino) || fs.statSync(destino).mtimeMs < fs.statSync(origem).mtimeMs) {
+        // VP8 em tempo real, não VP9: um vídeo de cinco minutos em VP9 leva
+        // minutos para converter, e isto acontece no meio do pedido da pessoa.
+        const args = ehAudio
+            ? ['-i', origem, '-vn', '-c:a', 'libopus', '-b:a', '128k', destino]
+            : ['-i', origem, '-c:v', 'libvpx', '-deadline', 'realtime', '-cpu-used', '8', '-b:v', '2500k',
+                '-c:a', 'libopus', '-b:a', '128k', destino];
+        await ffmpeg(args);
+    }
+    return { url: '/midia/' + path.basename(destino), convertido: true };
+}
+
+/* Toda URL de mídia do estúdio dentro do documento, sem repetição. */
+function srcsDeMidia(doc) {
+    const achados = new Set();
+    const andar = (o) => {
+        if (!o) return;
+        if (typeof o === 'string') { if (o.startsWith('/midia/')) achados.add(o); return; }
+        if (Array.isArray(o)) return o.forEach(andar);
+        if (typeof o === 'object') Object.values(o).forEach(andar);
+    };
+    andar(doc);
+    return [...achados];
+}
+
+/* Quanto o vídeo dura, para o prazo da exportação — a mesma conta do player,
+   por alto: a cena dura o que o autor pediu, o clipe dura o trecho, e a
+   narração estica quando é maior. */
+function duracaoEstimada(doc) {
+    return (doc.cenas || []).reduce((t, c) => {
+        let d = Number(c && c.duracao);
+        if (!(d > 0)) {
+            const clipe = c && c.tipo === 'clipe' ? c : ((c && c.elementos) || []).find((e) => e && e.tipo === 'clipe');
+            d = clipe && clipe.ate > clipe.de ? clipe.ate - clipe.de : 4;
+        }
+        const n = Number(c && c.narracaoDur);
+        if (n > 0) d = Math.max(d, Math.min(90, n + 0.4));
+        return t + d;
+    }, 0);
+}
+
+function errosDoNavegador(r) {
+    const erros = (r && r.erros) || [];
+    return erros.length ? ' O navegador reclamou: ' + erros.slice(0, 3).map((e) => e.texto).join(' · ') : '';
+}
+
+const exportarVideo = ({ id, destino, fps, escondido, pasta }) => comStudio(() => comIdReal(id, async () => {
+    if (!id) return { ok: false, error: 'Falta o id do vídeo.' };
+    if (typeof escondido !== 'function') return { ok: false, error: 'Sem navegador escondido para gerar o vídeo.' };
+    const a = await pedir('GET', `/api/arquivos/${encodeURIComponent(id)}`);
+    if (a.ferramenta !== 'corte') {
+        return { ok: false, error: `"${a.titulo}" é ${a.ferramenta}, não vídeo. Só o corte vira .mp4 — para as `
+            + 'outras ferramentas o link "ver" já é a peça pronta.' };
+    }
+    const doc = a.doc || {};
+    if (!(doc.cenas || []).length) return { ok: false, error: 'Este vídeo não tem cenas.' };
+
+    // 1. Os clipes do usuário, no formato que o navegador escondido toca.
+    const mapa = {};
+    const avisos = [];
+    for (const src of srcsDeMidia(doc)) {
+        const r = await compativel(src, escondido);
+        if (r.aviso) avisos.push(r.aviso);
+        if (r.url !== src) mapa[src] = r.url;
+    }
+
+    // 2. A página do player faz o trabalho do botão e devolve o arquivo ao estúdio.
+    const segundos = duracaoEstimada(doc);
+    const script = `(async () => {
+      function trocarSrc(o, m) {
+        if (!o || typeof o !== 'object') return;
+        if (Array.isArray(o)) return o.forEach(function (x) { trocarSrc(x, m); });
+        Object.keys(o).forEach(function (k) {
+          if (typeof o[k] === 'string' && m[o[k]]) o[k] = m[o[k]]; else trocarSrc(o[k], m);
+        });
+      }
+      try {
+        const a = await Player.carregado;
+        const mapa = ${JSON.stringify(mapa)};
+        if (Object.keys(mapa).length) {
+          const copia = JSON.parse(JSON.stringify(a));
+          trocarSrc(copia.doc, mapa);
+          Player.remontar(copia);
+        }
+        const r = await Player.exportar({ fps: ${Number(fps) > 0 ? Number(fps) : 30} });
+        const nome = ${JSON.stringify('export-' + id)} + r.formato;
+        const resp = await fetch('/api/midia/' + encodeURIComponent(nome), {
+          method: 'PUT', body: r.blob,
+          headers: { 'Content-Type': r.blob.type || 'application/octet-stream' },
+        });
+        const j = await resp.json();
+        if (!resp.ok) throw new Error(j.erro || ('HTTP ' + resp.status));
+        window.__primo = { ok: true, url: j.url, formato: r.formato, tipo: r.tipo, bytes: r.bytes, segundos: r.segundos, mp4: r.mp4 };
+      } catch (e) {
+        window.__primo = { ok: false, erro: String((e && e.message) || e) };
+      }
+    })()`;
+    const prazo = Math.round(segundos + 90);
+    const r = await escondido(`${BASE}/v/${encodeURIComponent(id)}`, {
+        script, gesto: true, prazo: prazo * 1000, passo: 700, assentar: 1500,
+    });
+    if (!r || !r.valor) return { ok: false, error: `A exportação não terminou em ${prazo}s.` + errosDoNavegador(r) };
+    if (!r.valor.ok) return { ok: false, error: `O navegador não conseguiu gerar o vídeo: ${r.valor.erro}.` + errosDoNavegador(r) };
+
+    // 3. Do estúdio para a pasta do projeto, em mp4 quando dá.
+    const origem = noDisco(r.valor.url);
+    if (!origem || !fs.existsSync(origem)) return { ok: false, error: 'O navegador gerou o vídeo mas o estúdio não o guardou.' };
+    const base = pasta || process.cwd();
+    const slug = String(a.titulo || 'video').normalize('NFD').replace(/[̀-ͯ]/g, '')
+        .replace(/[^\w-]+/g, '-').replace(/^-+|-+$/g, '').toLowerCase() || 'video';
+    let saida = destino ? path.resolve(base, destino) : path.join(base, `${slug}.mp4`);
+    if (!path.extname(saida)) saida += '.mp4';
+    fs.mkdirSync(path.dirname(saida), { recursive: true });
+    let formato = String(r.valor.formato || '.webm');
+    // "mp4" do gravador do navegador pode ser VP9 dentro de um .mp4 — o
+    // Chromium sem H.264 grava assim, e o arquivo não abre no iPhone nem no
+    // QuickTime. O que decide é o CODEC (avc1), não a extensão: sem avc1 e
+    // com ffmpeg na máquina, o arquivo é recodificado em H.264/AAC.
+    const jaH264 = /avc1|avc3|h264/i.test(String(r.valor.tipo || ''));
+    if ((formato === '.webm' || !jaH264) && /\.mp4$/i.test(saida)) {
+        if (temFfmpeg()) {
+            await ffmpeg(['-i', origem, '-c:v', 'libx264', '-preset', 'veryfast', '-crf', '20', '-pix_fmt', 'yuv420p',
+                '-c:a', 'aac', '-b:a', '160k', '-movflags', '+faststart', saida]);
+            formato = '.mp4';
+        } else if (formato === '.webm') {
+            saida = saida.replace(/\.mp4$/i, '.webm');
+            fs.copyFileSync(origem, saida);
+            avisos.push('Sem ffmpeg nesta máquina o arquivo ficou em .webm (toca em qualquer navegador e no VLC); '
+                + 'instale o ffmpeg para sair em .mp4.');
+        } else {
+            fs.copyFileSync(origem, saida);
+            avisos.push('O .mp4 saiu em VP9 (este navegador não grava H.264) — abre no Chrome, no Android e no VLC, '
+                + 'mas não no iPhone nem no QuickTime. Com o ffmpeg instalado ele sai em H.264.');
+        }
+    } else {
+        if (path.extname(saida).toLowerCase() !== formato) saida = saida.replace(/\.[^.]+$/, '') + formato;
+        fs.copyFileSync(origem, saida);
+    }
+    // O rascunho no estúdio já cumpriu o papel: ficar lá seria um vídeo
+    // inteiro duplicado na galeria a cada exportação.
+    try { fs.unlinkSync(origem); } catch { /* fica */ }
+    const bytes = fs.statSync(saida).size;
+    return {
+        ok: true,
+        arquivo: saida,
+        formato: formato.slice(1),
+        bytes,
+        segundos: r.valor.segundos,
+        avisos: avisos.length ? avisos : undefined,
+        comoUsar: `O vídeo está em ${saida} (${(bytes / 1048576).toFixed(1)} MB, ${Math.round(r.valor.segundos || segundos)}s). `
+            + 'Diga ao usuário o caminho, em uma linha.' + (avisos.length ? ' Avisos: ' + avisos.join(' ') : ''),
+    };
+}));
 
 module.exports = {
-    BASE, PORTA, CASA,
-    garantirNoAr, estaNoAr, prepararCasa, pythonCmd,
+    BASE, PORTA, CASA, MIDIA_DIR,
+    garantirNoAr, estaNoAr, prepararCasa, pythonCmd, derrubar,
     manual, ferramentas, spec, listar, ler, criar, atualizar, versoesDe,
-    midiaListar, midiaEnviar, analisarAudio,
+    midiaListar, midiaEnviar, analisarAudio, exportarVideo,
+    temFfmpeg, compativel, capacidadesDoNavegador, srcsDeMidia, duracaoEstimada,
 };

package/lib/tools.js

@@ -570,14 +570,28 @@ async function despachar(name, args, ctx) {
                 return args.arquivo
                     ? studio.midiaEnviar({ arquivo: resolveInProject(args.arquivo, projectDir), nome: args.nome })
                     : studio.midiaListar();
-            case 'studio_analisar':
-                // Ouvir o vídeo para achar as pausas. A conta acontece no
+            case 'studio_analisar': {
+                // Ouvir o vídeo para achar as pausas. A conta acontece num
                 // navegador (é quem sabe decodificar MP4 sem instalar nada) —
-                // por isso passa a função de abrir, e por isso demora alguns
-                // segundos em vez de responder na hora.
+                // e ESCONDIDO: a conta não é da pessoa, e uma aba piscando no
+                // navegador dela é encanamento aparecendo. Sem Chrome nem
+                // Chromium nesta máquina, cai no navegador dela, como antes.
+                const visivel = process.env.PRIMOCODE_ANALISE_VISIVEL === '1';
+                const abrir = visivel ? openInBrowser : async (url) => {
+                    try { return await browser.abrirEscondido(url); }
+                    catch { openInBrowser(url); return null; }
+                };
                 return studio.analisarAudio({
                     arquivo: args.arquivo, pausa: args.pausa, manter: args.manter,
-                    repetida: args.repetida, abrir: openInBrowser,
+                    repetida: args.repetida, abrir, escondido: visivel ? null : browser.rodarEscondido,
+                });
+            }
+            case 'studio_exportar':
+                // O mp4 sem clique: a página do player roda escondida e gera
+                // pelo mesmo caminho do botão. Ver lib/studio.js.
+                return studio.exportarVideo({
+                    id: args.id, destino: args.destino, fps: args.fps,
+                    escondido: browser.rodarEscondido, pasta: projectDir || process.cwd(),
                 });
 
             /* A MESMA peça, virando projeto Remotion.