primocode 8.42.1 → 9.0.0

package/lib/studio.js

@@ -1,960 +0,0 @@
-/**
- * studio.js — o PrimoCode Studio, ligado ao agente.
- *
- * O Studio é a suíte de criação que vem junto com o PrimoCode (pasta studio/):
- * Prisma (apresentações), Tela (design), Prosa (documentos), Grade (planilhas),
- * Corte (vídeo) e Traço (diagramas). É um servidor Python de biblioteca padrão,
- * sem nada para instalar.
- *
- * ── POR QUE ESTE MÓDULO EXISTE ───────────────────────────────────────────
- * Medido em uso real: o agente sabia do Studio, tentou falar com ele em
- * localhost:7777, tomou "conexão recusada" e DESISTIU — respondeu ao usuário
- * que "o estúdio não está rodando na sua máquina". O usuário não tem que ligar
- * ferramenta nenhuma: ele pediu um vídeo, quer o vídeo.
- *
- * Então aqui o Studio sobe SOZINHO, na primeira vez que o agente precisa dele.
- * `garantirNoAr()` é chamado antes de toda tool studio_*, e o modelo nem sabe
- * que houve um passo a mais.
- *
- * ── POR QUE ELE RODA DE ~/.primocode/studio, E NÃO DE DENTRO DO PACOTE ────
- * O Studio grava o que cria (arquivos/ e midia/) ao lado do server.py. Com o
- * pacote instalado global (`npm i -g`), essa pasta costuma ser de sistema e a
- * escrita falharia — e, pior, um `npm update` apagaria o trabalho do usuário.
- * Então o código é copiado para ~/.primocode/studio na primeira vez, e as
- * criações ficam lá, a salvo de atualização do pacote.
- */
-
-'use strict';
-
-const http = require('http');
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-const { spawn, execSync } = require('child_process');
-
-const ORIGEM = path.join(__dirname, '..', 'studio');
-const CASA = path.join(os.homedir(), '.primocode', 'studio');
-const PORTA = Number(process.env.PRIMOCODE_STUDIO_PORT) || 7777;
-const BASE = `http://127.0.0.1:${PORTA}`;
-
-// Só o código do Studio é atualizado; `arquivos/` e `midia/` (o que o usuário
-// criou) nunca são tocados.
-// voz.py é módulo do servidor, não enfeite: sem ele o server.py não importa
-// e o Studio inteiro deixa de subir. Todo arquivo .py do Studio precisa
-// entrar aqui.
-const COPIAVEIS = new Set(['server.py', 'voz.py', 'elevenlabs.py', 'edge.py', 'web', 'ferramentas', 'README.md', 'PRIMOCODE.md']);
-
-/**
- * Onde está o Python 3 desta máquina.
- *
- * Procurar só por `python3` no PATH não basta, e isso custou uma tarefa
- * inteira num Mac: o comando existe mas é o atalho da Apple, que sem as
- * Ferramentas de Linha de Comando instaladas sai com erro em vez de versão —
- * e o usuário lia "Python 3 não está instalado" com o Python instalado pelo
- * Homebrew ali do lado, fora do PATH daquele terminal.
- *
- * Então: nomes comuns, versões numeradas, e os caminhos absolutos onde o
- * Python realmente mora em cada sistema.
- */
-function pythonCmd() {
-    const numeradas = ['python3.13', 'python3.12', 'python3.11', 'python3.10', 'python3.9'];
-    let candidatos;
-    if (os.platform() === 'win32') {
-        candidatos = ['python', 'py', 'python3', ...numeradas];
-    } else {
-        candidatos = [
-            'python3', 'python', ...numeradas,
-            // Homebrew (Apple Silicon e Intel) e o do sistema — o PATH de um
-            // terminal aberto por atalho às vezes não tem nenhum dos dois.
-            '/opt/homebrew/bin/python3', '/usr/local/bin/python3', '/usr/bin/python3',
-        ];
-    }
-    for (const c of candidatos) {
-        try {
-            const v = execSync(`${c} --version`, { stdio: ['ignore', 'pipe', 'pipe'], timeout: 5000 }).toString();
-            if (/Python 3/.test(v)) return c;
-        } catch {}
-    }
-    return null;
-}
-
-// Cópia recursiva que só reescreve o que mudou — assim `npm update` traz o
-// Studio novo sem custo, e o que o usuário criou continua onde está.
-function copiar(de, para) {
-    const st = fs.statSync(de);
-    if (st.isDirectory()) {
-        fs.mkdirSync(para, { recursive: true });
-        for (const item of fs.readdirSync(de)) copiar(path.join(de, item), path.join(para, item));
-        return;
-    }
-    // Copia SEMPRE. A comparação esperta (tamanho + data) deixava passar
-    // arquivo alterado de mesmo tamanho: o npm instala com data antiga
-    // (1985, de propósito, por reprodutibilidade) e o teste de mtime nunca
-    // disparava. O que o usuário criou não corre risco — arquivos/ e midia/
-    // não estão em COPIAVEIS.
-    fs.copyFileSync(de, para);
-}
-
-function prepararCasa() {
-    if (!fs.existsSync(ORIGEM)) return { ok: false, error: 'A pasta studio/ não veio no pacote.' };
-    fs.mkdirSync(CASA, { recursive: true });
-    for (const item of COPIAVEIS) {
-        const de = path.join(ORIGEM, item);
-        if (fs.existsSync(de)) copiar(de, path.join(CASA, item));
-    }
-    return { ok: true, casa: CASA };
-}
-
-// ── HTTP ─────────────────────────────────────────────────────────────────
-function pedir(metodo, rota, corpo, timeout = 30000) {
-    return new Promise((resolve, reject) => {
-        const dados = corpo == null ? null : Buffer.from(JSON.stringify(corpo), 'utf8');
-        const req = http.request({
-            hostname: '127.0.0.1',
-            port: PORTA,
-            path: rota,
-            method: metodo,
-            timeout,
-            // Este cabeçalho diz ao Studio que quem fala é a IA, não o editor
-            // do navegador. O servidor valida o documento com rigor só neste
-            // caso: erro de formato tem de voltar para o agente como lição, e
-            // não pode fazer o salvamento de uma pessoa que está digitando
-            // falhar no meio da edição.
-            headers: Object.assign({ 'X-Primo-Agente': '1' },
-                dados ? { 'Content-Type': 'application/json', 'Content-Length': dados.length } : {}),
-        }, (res) => {
-            let texto = '';
-            res.setEncoding('utf8');
-            res.on('data', (c) => { texto += c; });
-            res.on('end', () => {
-                if (res.statusCode >= 400) {
-                    // A mensagem do servidor é escrita PARA o agente ("tema X
-                    // não existe, os temas são..."). Envolver em "HTTP 400:
-                    // {json}" só afasta a lição do olho dele.
-                    let motivo = texto.slice(0, 400);
-                    let corpoErro = null;
-                    try {
-                        corpoErro = JSON.parse(texto);
-                        motivo = corpoErro.erro || motivo;
-                    } catch { /* texto cru serve */ }
-                    const erro = new Error(motivo);
-                    erro.corpo = corpoErro;
-                    // O código vem no objeto, e não mais embutido no texto:
-                    // quem trata 404 (comIdReal) precisa saber que é 404 sem
-                    // depender de a mensagem começar com "HTTP 404".
-                    erro.status = res.statusCode;
-                    return reject(erro);
-                }
-                try { resolve(JSON.parse(texto)); }
-                catch { resolve({ texto }); }
-            });
-        });
-        req.on('timeout', () => { req.destroy(new Error('tempo esgotado falando com o Studio')); });
-        req.on('error', reject);
-        if (dados) req.write(dados);
-        req.end();
-    });
-}
-
-async function estaNoAr() {
-    try { await pedir('GET', '/api/ferramentas', null, 1500); return true; }
-    catch { return false; }
-}
-
-// ── Subir ────────────────────────────────────────────────────────────────
-// Uma subida por vez: sem esta trava, duas tools chamadas no mesmo turno
-// disparariam dois servidores na mesma porta e o segundo morreria com
-// "address in use" — barulho por nada.
-/** A assinatura do server.py que está NO DISCO — a versão que deveria rodar. */
-function assinaturaDoDisco() {
-    try {
-        const corpo = fs.readFileSync(path.join(CASA, 'server.py'));
-        return require('crypto').createHash('sha1').update(corpo).digest('hex').slice(0, 12);
-    } catch { return null; }
-}
-
-/** A assinatura do processo que está NO AR — a versão que roda de fato. */
-async function assinaturaNoAr() {
-    try { return (await pedir('GET', '/api/versao', null, 1500)).assinatura || null; }
-    catch { return null; }   // servidor antigo não tem a rota — também é "desatualizado"
-}
-
-/**
- * Derruba o Studio que está no ar. Primeiro pelo caminho limpo (/api/sair);
- * se for um servidor antigo, que não tem a rota, pelo sistema.
- */
-async function derrubar() {
-    try { await pedir('POST', '/api/sair', {}, 1500); } catch {}
-    for (let i = 0; i < 10; i++) {
-        await new Promise((r) => setTimeout(r, 300));
-        if (!(await estaNoAr())) return true;
-    }
-    // Servidor antigo: sem /api/sair. Mata pelo padrão da linha de comando.
-    try {
-        const { execSync } = require('child_process');
-        if (os.platform() === 'win32') {
-            execSync('powershell -NoProfile -Command "Get-CimInstance Win32_Process | ' +
-                "Where-Object {$_.CommandLine -like '*primocode*studio*server.py*'} | " +
-                'ForEach-Object { Stop-Process -Id $_.ProcessId -Force }"', { stdio: 'ignore' });
-        } else {
-            execSync("pkill -f '[.]primocode/studio/server.py'", { stdio: 'ignore' });
-        }
-    } catch {}
-    for (let i = 0; i < 10; i++) {
-        await new Promise((r) => setTimeout(r, 300));
-        if (!(await estaNoAr())) return true;
-    }
-    return !(await estaNoAr());
-}
-
-let subindo = null;
-
-async function garantirNoAr() {
-    if (await estaNoAr()) {
-        // O npm pode ter trocado o código no disco DEPOIS de este processo
-        // subir — e aí o Studio no ar é o antigo, servindo o bug que o
-        // update corrigiu. Atualiza o disco e compara as assinaturas; se
-        // divergirem, reinicia. Na véspera de uma apresentação, "atualizei
-        // mas continua igual" é o pior modo de falha que existe.
-        prepararCasa();
-        const doDisco = assinaturaDoDisco();
-        const noAr = await assinaturaNoAr();
-        if (!doDisco || (noAr && noAr === doDisco)) return { ok: true, url: BASE, jaEstava: true };
-        await derrubar();
-        // cai para o caminho de subida normal, já com o código novo
-    }
-    if (subindo) return subindo;
-
-    subindo = (async () => {
-        const casa = prepararCasa();
-        if (!casa.ok) return casa;
-
-        const py = pythonCmd();
-        if (!py) {
-            return {
-                ok: false,
-                error: 'O Studio precisa do Python 3, e não achei nenhum nesta máquina.',
-                comoResolver: os.platform() === 'darwin'
-                    ? 'No Mac, o mais rápido é: xcode-select --install (traz o Python 3 da Apple). '
-                      + 'Ou, se você usa Homebrew: brew install python. Depois é só pedir de novo.'
-                    : os.platform() === 'win32'
-                        ? 'Instale em python.org/downloads (marque "Add python.exe to PATH" no instalador).'
-                        : 'Instale o Python 3 pelo gerenciador da sua distribuição (ex: sudo apt install python3).',
-                // Sem isto o agente responde "não consegui" e para. O trabalho
-                // pedido quase sempre tem um caminho que não depende do Studio.
-                enquantoIsso: 'Não desista da tarefa: dá para entregar em HTML com write_file e abrir com open_in_browser.',
-            };
-        }
-
-        // Solto do processo do CLI: o Studio continua de pé quando a sessão
-        // fecha, que é o que o usuário espera de um app aberto.
-        const filho = spawn(py, ['server.py', String(PORTA)], {
-            cwd: CASA,
-            detached: true,
-            stdio: 'ignore',
-        });
-        filho.unref();
-
-        // Espera ficar de pé (~8s no pior caso). Máquina lenta continua sendo
-        // atendida; máquina rápida sai na primeira volta.
-        for (let i = 0; i < 40; i++) {
-            await new Promise((r) => setTimeout(r, 200));
-            if (await estaNoAr()) return { ok: true, url: BASE, subiuAgora: true };
-        }
-        return { ok: false, error: `O Studio não respondeu em ${BASE} depois de subir. Veja se a porta ${PORTA} está livre.` };
-    })();
-
-    try { return await subindo; }
-    finally { subindo = null; }
-}
-
-// ── O que o agente usa ───────────────────────────────────────────────────
-// Toda função garante o Studio no ar ANTES de falar com ele. É isto que faz o
-// "abre o Canva e faz um post" virar um post pronto, sem o usuário ligar nada.
-
-async function comStudio(fn) {
-    const no = await garantirNoAr();
-    if (!no.ok) return no;
-    return fn();
-}
-
-const manual = () => comStudio(async () => ({ ok: true, ...(await pedir('GET', '/api/manual')) }));
-const ferramentas = () => comStudio(async () => ({ ok: true, ferramentas: await pedir('GET', '/api/ferramentas') }));
-const spec = (slug) => comStudio(async () => ({ ok: true, spec: await pedir('GET', `/api/ferramentas/${encodeURIComponent(slug)}`) }));
-const listar = () => comStudio(async () => ({ ok: true, arquivos: await pedir('GET', '/api/arquivos') }));
-// 404 de id é quase sempre id INVENTADO: num pedido real o agente criou o
-// arquivo, recebeu "corte-founders-ea74b" de volta, e chamou studio_ler com
-// "imersao-foulders-ai" — um id que ele imaginou. O erro seco ("não
-// encontrado") não dizia isso, e ele insistia. O erro que ensina, diz.
-async function comIdReal(id, fn) {
-    try {
-        return await fn();
-    } catch (e) {
-        if (!(e && e.status === 404)) throw e;
-        let existem = [];
-        try { existem = (await pedir('GET', '/api/arquivos')).map((a) => a.id).slice(0, 8); } catch {}
-        return {
-            ok: false,
-            error: `O id "${id}" não existe. NÃO invente id: use EXATAMENTE o campo "id" que studio_criar devolveu.`
-                + (existem.length ? ` Os que existem agora: ${existem.join(', ')}.` : ''),
-        };
-    }
-}
-
-const ler = (id) => comStudio(() => comIdReal(id, async () => ({ ok: true, arquivo: await pedir('GET', `/api/arquivos/${encodeURIComponent(id)}`) })));
-
-// Quando o documento tem narração, o servidor começa a baixar a voz neural
-// sozinho. São ~90 MB, e o usuário merece saber por que o primeiro vídeo sai
-// com uma voz e o próximo com outra — melhor ele ouvir isso do agente do que
-// achar que o programa está inconstante.
-async function avisoDaVoz(doc) {
-    const temNarracao = !!(doc && (doc.narracao
-        || (doc.cenas || []).some((c) => c && typeof c.narracao === 'string' && c.narracao.trim())));
-    if (!temNarracao) return null;
-    try {
-        const s = await pedir('GET', '/api/voz/status', null, 3000);
-        if (!s) return null;
-        // Voz de gente garantida: ElevenLabs com chave, ou o Edge (Python,
-        // neural, grátis) já instalado. Nada a avisar.
-        if (s.elevenlabs && (s.elevenlabs.configurado || s.elevenlabs.ativo)) return null;
-        if (s.edge && s.edge.disponivel) return null;
-        if (s.piper && s.piper.pronta) return null;
-        // "A narração tá pegando do Google, tem que ser do Python" — o dono
-        // ouviu a reserva sem saber que era reserva. Quando o Edge ainda não
-        // está na máquina, o agente fica sabendo e conta: o pip está rodando
-        // (as cenas esperam por ele), ou falhou, e aí a pessoa pode instalar
-        // à mão em vez de achar que a voz do produto é aquela.
-        if (s.edge && s.edge.instalando) {
-            return 'A voz neural (edge-tts, Python) está sendo instalada agora — leva segundos, uma vez só; '
-                + 'a narração das cenas espera por ela. Se o vídeo tocar antes, a primeira reprodução pode sair '
-                + 'com a voz de reserva. Diga isso ao usuário em uma frase.';
-        }
-        if (s.edge && s.edge.erro) {
-            return `A voz neural (edge-tts) não instalou sozinha (${String(s.edge.erro).slice(0, 120)}). `
-                + 'Até instalar, a narração sai pela voz de reserva do Google. AVISE o usuário e dê o comando: '
-                + 'python3 -m pip install --user edge-tts (ou com --break-system-packages).';
-        }
-        if (s.piper && !s.piper.pronta && s.piper.suportado) {
-            return 'A voz neural (offline, ilimitada) está sendo baixada agora — ~90 MB, uma vez só. '
-                + 'Até terminar a narração sai por uma voz de reserva, mais simples. Diga isso ao usuário.';
-        }
-    } catch { /* status é enfeite; não pode atrapalhar a criação */ }
-    return null;
-}
-
-const criar = ({ ferramenta, titulo, doc }) => comStudio(async () => {
-    if (!ferramenta) return { ok: false, error: 'Diga a ferramenta: prisma, tela, prosa, grade, corte ou traco.' };
-    if (!doc) return { ok: false, error: 'Falta o doc. Leia a spec com studio_spec antes de criar.' };
-    const r = await pedir('POST', '/api/arquivos', { ferramenta, titulo: titulo || 'Sem título', doc });
-    const saida = { ok: true, ...r };
-    const voz = await avisoDaVoz(doc);
-    if (voz) saida.voz = voz;
-    return saida;
-});
-
-// O que o agente recebe de volta depois de mexer num arquivo. Devolver o
-// documento inteiro era caro e inútil: um vídeo de oito cenas volta como
-// milhares de tokens que ele acabou de escrever. O que ele precisa saber é
-// que gravou, quantas peças ficaram e como voltar atrás.
-const resumoDoArquivo = (r) => {
-    const doc = r.doc || {};
-    const pecas = (doc.cenas || doc.blocos || doc.abas || []).length;
-    return {
-        id: r.id, titulo: r.titulo, ferramenta: r.ferramenta,
-        pecas, tema: doc.tema,
-        temNarracao: !!(doc.narracao || (doc.cenas || []).some((c) => c && c.narracao)),
-        temTrilha: !!doc.trilha,
-        // O mesmo link de sempre: ajustar não cria peça nova, e é isso que o
-        // agente precisa dizer ao usuário no finish.
-        // localhost, e não 127.0.0.1, para bater com o link que studio_criar
-        // já deu ao usuário — dois endereços para a mesma peça confundem.
-        ver: `http://localhost:${PORTA}/v/${r.id}`,
-    };
-};
-
-const atualizar = ({ id, titulo, doc }) => comStudio(() => comIdReal(id, async () => {
-    if (!id) return { ok: false, error: 'Falta o id do arquivo.' };
-    const corpo = {};
-    if (titulo != null) corpo.titulo = titulo;
-    if (doc != null) corpo.doc = doc;
-    const r = await pedir('PUT', `/api/arquivos/${encodeURIComponent(id)}`, corpo);
-    const saida = { ok: true, ...resumoDoArquivo(r) };
-    // A mescla é a razão de isto não ter destruído nada: as chaves que você
-    // não mandou continuam lá. Dizer isso evita a rodada seguinte em que o
-    // agente "reconstrói" o que nunca se perdeu.
-    saida.nota = 'Só as chaves que você mandou mudaram; o resto do documento continua como estava.';
-    if (r.versao_anterior) saida.desfazer = `studio_versoes com id "${r.id}" e restaurar "${r.versao_anterior}" volta ao estado anterior.`;
-    return saida;
-}));
-
-// ── Histórico ────────────────────────────────────────────────────────────
-// Existe porque uma vez não existiu: um ajuste apagou oito cenas de trabalho
-// e não havia de onde tirar de volta.
-const versoesDe = ({ id, restaurar }) => comStudio(() => comIdReal(id, async () => {
-    if (!id) return { ok: false, error: 'Falta o id do arquivo.' };
-    if (restaurar) {
-        const alvo = restaurar === true || restaurar === 'anterior' ? null : String(restaurar);
-        try {
-            const r = await pedir('POST', `/api/arquivos/${encodeURIComponent(id)}/restaurar`,
-                alvo ? { versao: alvo } : {});
-            return { ok: true, ...r };
-        } catch (e) {
-            // 404 aqui pode ser o arquivo OU a versão. Quando o servidor manda
-            // a lista junto, o arquivo existe e quem não existe é a versão —
-            // deixar comIdReal dizer "o id não existe" mandaria o agente
-            // caçar um problema que não é o dele.
-            if (e && e.status === 404 && e.corpo && Array.isArray(e.corpo.versoes)) {
-                return {
-                    ok: false,
-                    error: `A versão "${alvo}" não existe.`,
-                    versoes: e.corpo.versoes,
-                    comoCorrigir: 'Use um "versao" desta lista, copiado LITERALMENTE, ou "anterior" para desfazer a última mudança.',
-                };
-            }
-            throw e;
-        }
-    }
-    const r = await pedir('GET', `/api/arquivos/${encodeURIComponent(id)}/versoes`);
-    return {
-        ok: true,
-        versoes: r.versoes || [],
-        comoVoltar: 'Para voltar, chame de novo com restaurar: "<versao>" — ou restaurar: "anterior" para desfazer a última mudança.',
-    };
-}));
-
-// ── Mídia: a imagem de fundo e a música do usuário ───────────────────────
-// Sem isto o agente não tinha como pôr foto de fundo nem trilha própria: a
-// API pede base64, e ele não ia montar data URI na mão dentro de um curl.
-const TIPOS_MIDIA = {
-    '.png': 1, '.jpg': 1, '.jpeg': 1, '.gif': 1, '.webp': 1, '.svg': 1, '.avif': 1,
-    '.mp3': 1, '.m4a': 1, '.wav': 1, '.ogg': 1, '.aac': 1, '.flac': 1, '.opus': 1, '.weba': 1,
-    '.mp4': 1, '.webm': 1, '.mov': 1,
-};
-
-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.
- *
- * "Eu quero que eu consiga arrastar os meus vídeos pra dentro do terminal."
- * Arrastar, num terminal, cola o caminho — e cola do jeito do sistema: o
- * macOS escapa espaço com barra invertida, o Windows põe aspas em volta, e
- * alguns colam file:// na frente. `path.resolve` de qualquer um desses dá um
- * caminho que não existe, e a resposta era "arquivo não existe" para um
- * arquivo que está bem ali.
- */
-function limparCaminho(bruto) {
-    let s = String(bruto || '').trim();
-    if ((s.startsWith('"') && s.endsWith('"')) || (s.startsWith("'") && s.endsWith("'"))) {
-        s = s.slice(1, -1);
-    }
-    if (/^file:\/\//i.test(s)) {
-        try { s = decodeURIComponent(s.replace(/^file:\/\//i, '')); } catch { /* fica como está */ }
-    }
-    // Só desescapa o que o shell escapa; um "\" de caminho do Windows fica.
-    s = s.replace(/\\([ ()'"&!$`\\])/g, '$1');
-    if (s.startsWith('~/') || s === '~') s = path.join(os.homedir(), s.slice(1));
-    return s.trim();
-}
-
-const midiaEnviar = ({ arquivo, nome }) => comStudio(async () => {
-    if (!arquivo) return { ok: false, error: 'Diga o caminho do arquivo (arquivo: "foto.jpg").' };
-    const caminho = path.resolve(limparCaminho(arquivo));
-    if (!fs.existsSync(caminho)) {
-        return {
-            ok: false,
-            error: `Arquivo não existe: ${arquivo}. NÃO invente arquivo de mídia — num pedido real o agente `
-                + 'tentou fundo.jpg, trilha.mp3 e logo.png que nunca existiram. Sem arquivo do usuário, siga sem mídia: '
-                + 'fundo pode ser "aurora"/"raios"/"brilho" (gerados), e trilha pode ser gerada — '
-                + '"trilha":{"tipo":"gerada","estilo":"epico"}. O vídeo fica pronto do mesmo jeito.',
-        };
-    }
-
-    const ext = path.extname(caminho).toLowerCase();
-    if (!TIPOS_MIDIA[ext]) {
-        // 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';
-    const teto = ehVideo ? 2 * 1024 * 1024 * 1024 : 60 * 1024 * 1024;
-    if (bytes > teto) {
-        return { ok: false, error: `Arquivo tem ${(bytes / 1048576).toFixed(1)} MB; `
-            + `o limite é ${Math.round(teto / 1048576)} MB.` };
-    }
-
-    // O corpo vai em pedaços, direto do disco para o socket. Em base64 um
-    // vídeo de celular precisaria caber inteiro na memória três vezes — e o
-    // Node estourava antes de o estúdio ver um byte.
-    const r = await enviarArquivo(caminho, nome || path.basename(caminho));
-    const comoUsar = ehVideo
-        ? `Use "${r.url}" no "src" de um elemento {"tipo":"clipe"}. Para cortar as pausas, `
-          + 'escreva VÁRIOS clipes do mesmo src, cada um com "de" e "ate" em segundos.'
-        : `Use "${r.url}" em fundo.imagem, em src de uma imagem, ou em trilha.src.`;
-    return { ok: true, ...r, comoUsar };
-});
-
-/* PUT /api/midia/<nome> com o arquivo cru no corpo. */
-function enviarArquivo(caminho, nome) {
-    return new Promise((resolve, reject) => {
-        const bytes = fs.statSync(caminho).size;
-        const req = http.request({
-            hostname: '127.0.0.1', port: PORTA, method: 'PUT',
-            path: '/api/midia/' + encodeURIComponent(nome),
-            // Vídeo grande copiando para o disco leva tempo; meia hora é
-            // folga para um arquivo de duas horas, e continua sendo um teto.
-            timeout: 30 * 60 * 1000,
-            headers: { 'X-Primo-Agente': '1', 'Content-Type': 'application/octet-stream',
-                'Content-Length': bytes },
-        }, (res) => {
-            let texto = '';
-            res.setEncoding('utf8');
-            res.on('data', (c) => { texto += c; });
-            res.on('end', () => {
-                let corpo = null;
-                try { corpo = JSON.parse(texto); } catch { /* texto cru serve */ }
-                if (res.statusCode >= 400) {
-                    return reject(new Error((corpo && corpo.erro) || texto.slice(0, 300)));
-                }
-                resolve(corpo || {});
-            });
-        });
-        req.on('timeout', () => { req.destroy(new Error('o envio demorou demais')); });
-        req.on('error', reject);
-        const leitura = fs.createReadStream(caminho);
-        leitura.on('error', (e) => { req.destroy(e); reject(e); });
-        leitura.pipe(req);
-    });
-}
-
-/* ── Ouvir o vídeo para achar as pausas ──────────────────────────────────
- *
- * "Ele vai cortar as pausas demoradas no vídeo."
- *
- * Cortar pausa exige saber onde a fala para, e nada aqui lê o áudio de um
- * .mp4: o PrimoCode não tem dependência, e o Python da máquina lê WAV e mais
- * nada. ffmpeg resolveria e seria mais uma instalação de 80 MB para quem só
- * quer editar um vídeo.
- *
- * Quem decodifica MP4, MOV e webm já está aberto na mesa. A conta roda numa
- * aba que abre, trabalha e se fecha; aqui a gente espera a resposta.
- *
- * `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, escondido }) => comStudio(async () => {
-    if (!arquivo) return { ok: false, error: 'Diga qual mídia analisar (arquivo: "/midia/x.mp4").' };
-    // 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.
-    const prazo = Date.now() + 180000;
-    while (Date.now() < prazo) {
-        await new Promise((ok) => setTimeout(ok, 700));
-        const estado = await pedir('GET', `/api/analise/${tarefa.id}`, null, 8000).catch(() => null);
-        if (!estado) continue;
-        if (estado.estado === 'erro') {
-            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 || {};
-            const repetidos = r.repetidos || [];
-            /* O QUE FOI TIRADO É DITO, e não só cortado. O vídeo sai menor e a
-               diferença é fala da pessoa: um resultado que só entrega os
-               trechos deixa o agente montar o vídeo sem ter como contar que
-               dois segundos dela sumiram — e vídeo que encurta sem explicação é
-               indistinguível de vídeo quebrado. */
-            const aviso = repetidos.length
-                ? ` ${repetidos.length} trecho(s) saíram por terem sido ditos duas vezes `
-                  + `(${repetidos.map((x) => `${x.de}s–${x.ate}s, ${x.motivo}`).join('; ')}). `
-                  + 'DIGA isso ao usuário na sua resposta, com os tempos. Se ele quiser tudo de volta, '
-                  + 'chame de novo com repetida:false.'
-                : '';
-            return {
-                ok: true,
-                duracao: r.duracao,
-                cortado: r.cortado,
-                pausas: r.pausas,
-                trechos: r.trechos,
-                repetidos,
-                comoUsar: `${(r.trechos || []).length} trecho(s) sem pausa. Escreva UMA CENA por trecho, `
-                    + `cada uma com {"tipo":"clipe","src":"${arquivo}","de":<início>,"ate":<fim>}. `
-                    + 'NÃO escreva "duracao" nessas cenas: a cena já dura o trecho.' + aviso,
-            };
-        }
-    }
-    return {
-        ok: false,
-        error: 'A aba de análise não respondeu em 3 minutos. Ela precisa do navegador aberto. '
-            + '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, remotion }) => 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á.
-    let 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.' };
-
-    /* A MESCLA COM O REMOTION. O Studio acabou de gravar a peça em tempo real:
-       o ÁUDIO dele é completo (narração, trilha gerada, efeitos sintetizados),
-       mas o vídeo gravado depende do relógio — máquina ocupada perde quadro.
-       O Remotion desenha a MESMA cena quadro a quadro, determinístico, com o
-       motion inteiro (Filme.jsx leva as animações ao instante certo pela Web
-       Animations API). Então o vídeo vem do Remotion, o áudio do Studio, e o
-       ffmpeg junta. Pedido do dono: "deve usar o Remotion e o Studio, deve
-       mesclar os 2". Sem ffmpeg ou com o Remotion indisponível, fica o
-       arquivo do Studio — e o aviso diz por quê. */
-    let motor = 'studio';
-    if (remotion && temFfmpeg()) {
-        const rem = require('./remotion.js');
-        const c = require('./ui').c;
-        const avisar = (t) => console.log(c.dim('    ' + t));
-        // O doc que o Remotion desenha é o MESMO que o navegador escondido
-        // desenhou: com as cópias compatíveis dos clipes, se houve.
-        const docRemotion = JSON.parse(JSON.stringify(doc));
-        const trocar = (o) => {
-            if (!o || typeof o !== 'object') return;
-            if (Array.isArray(o)) return o.forEach(trocar);
-            for (const k of Object.keys(o)) {
-                if (typeof o[k] === 'string' && mapa[o[k]]) o[k] = mapa[o[k]]; else trocar(o[k]);
-            }
-        };
-        trocar(docRemotion);
-        const rr = await rem.renderizarPeca({
-            doc: docRemotion, titulo: a.titulo, fps: Number(fps) > 0 ? Number(fps) : 30,
-            midiaDir: MIDIA_DIR, semAudio: true, avisar,
-        });
-        if (rr.ok) {
-            // Vídeo do Remotion + áudio do Studio. `-shortest` porque as duas
-            // durações podem diferir por um quadro.
-            const mesclado = origem.replace(/\.[^.]+$/, '') + '.remotion.mp4';
-            try {
-                await ffmpeg(['-i', rr.arquivo, '-i', origem, '-map', '0:v:0', '-map', '1:a:0?',
-                    '-c:v', 'copy', '-c:a', 'aac', '-b:a', '160k', '-shortest', '-movflags', '+faststart', mesclado]);
-                if (fs.existsSync(mesclado) && fs.statSync(mesclado).size > 10000) {
-                    try { fs.unlinkSync(origem); } catch { /* fica */ }
-                    origem = mesclado;
-                    motor = 'remotion+studio';
-                    r.valor.tipo = 'video/mp4; codecs="avc1"';
-                    r.valor.formato = '.mp4';
-                }
-            } catch (e) {
-                avisos.push(`O Remotion renderizou mas a mistura com o áudio falhou (${String(e.message || e).slice(0, 120)}); ficou o arquivo do Studio.`);
-            }
-        } else {
-            avisos.push(`O Remotion não renderizou desta vez (${String(rr.error || '').slice(0, 160)}); ficou o arquivo do Studio, gravado em tempo real.`);
-        }
-    }
-    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),
-        motor,
-        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, MIDIA_DIR,
-    garantirNoAr, estaNoAr, prepararCasa, pythonCmd, derrubar,
-    manual, ferramentas, spec, listar, ler, criar, atualizar, versoesDe,
-    midiaListar, midiaEnviar, analisarAudio, exportarVideo,
-    temFfmpeg, compativel, capacidadesDoNavegador, srcsDeMidia, duracaoEstimada,
-};