primocode 10.0.0 → 10.1.0

package/lib/estudio/referencias.js

@@ -0,0 +1,105 @@
+/**
+ * referencias.js — de onde o vídeo tira as referências, decidido pela
+ * PESSOA antes de começar.
+ *
+ *   "A IA deve pedir: pegar referências da web com escopo aberto, pegar
+ *    referências da web com escopo que você define (escopo fechado), ou sem
+ *    referências — só motion." (29/09)
+ *
+ * Três modos:
+ *   aberto   pesquisa, site da marca e b-roll de banco à vontade (o híbrido)
+ *   fechado  só o que a pessoa disse: os sites e termos do escopo, nada além
+ *   sem      nenhuma foto nem vídeo de fora: motion puro (o kit), sem b-roll
+ *
+ * A escolha vale para o pedido (o terminal pergunta a cada vídeo novo) e é
+ * lida em dois lugares: a instrução que vai para o agente e o Estúdio, que
+ * não baixa b-roll no "sem" e só busca o escopo no "fechado".
+ */
+
+'use strict';
+
+let ATUAL = { modo: null, escopo: '' };
+
+function definir(modo, escopo = '') {
+    ATUAL = { modo: ['aberto', 'fechado', 'sem'].includes(modo) ? modo : null, escopo: String(escopo || '').trim() };
+    return ATUAL;
+}
+function atual() { return ATUAL; }
+function limpar() { ATUAL = { modo: null, escopo: '' }; }
+
+/** Os termos do escopo fechado: "site:anthropic.com, claude ai, sonnet" → lista. */
+function termos(escopo = ATUAL.escopo) {
+    return String(escopo || '').split(/[,;\n]+/).map((x) => x.trim()).filter(Boolean).slice(0, 8);
+}
+
+/** A resposta da pergunta ("1", "2", "aberto", "só motion"…) → modo. */
+function entender(resposta) {
+    const r = String(resposta || '').toLowerCase().normalize('NFD').replace(/[̀-ͯ]/g, '').trim();
+    if (/^1\b|aberto|livre|qualquer/.test(r)) return 'aberto';
+    if (/^2\b|fechad|escopo|defino|so (d|n)(e|o)ss/.test(r)) return 'fechado';
+    if (/^3\b|sem ref|nenhum|so motion|motion|sem foto|sem imagem/.test(r)) return 'sem';
+    return null;
+}
+
+/* O MODO DEDUZIDO DO PEDIDO. Quem diz no pedido não é perguntado:
+     "só motion", "sem referência", "sem foto"          → sem
+     "só do site x.com", "usa apenas anthropic.com e …" → fechado (o escopo)
+     "web aberta", "escopo aberto", "pesquisa à vontade" → aberto
+   O resto volta com `explicito: false` e o terminal pergunta antes de
+   começar: "eu posso pedir um vídeo mas estar me referindo ao motion"
+   (Joel, 02/10) — chutar o aberto fazia vídeo com foto e b-roll quando a
+   pessoa queria só motion. */
+function inferir(texto) {
+    const t = String(texto || '').toLowerCase().normalize('NFD').replace(/[̀-ͯ]/g, '');
+    if (/so (o )?motion|motion puro|sem refer|sem (foto|imagem|imagens|video de banco|pesquisa)|nao (pesquis|busqu)|so anima/.test(t)) return { modo: 'sem', escopo: '', explicito: true };
+    const dominios = String(texto || '').match(/\b[a-z0-9-]+(\.[a-z0-9-]+)+\.?[a-z]{2,}(\/[^\s,]*)?/gi) || [];
+    if (/\b(so|apenas|somente|unicamente)\b[^.]{0,30}\b(site|sites|link|links|fonte|fontes|pagina|de|do|da|em)\b/.test(t) && dominios.length) {
+        return { modo: 'fechado', escopo: dominios.join(', '), explicito: true };
+    }
+    if (/escopo aberto|web aberta|pesquis\w* (a vontade|na web|na internet)|busc\w* (imagens|fotos|videos) na (web|internet)|com (imagens|fotos) da (web|internet)/.test(t)) {
+        return { modo: 'aberto', escopo: '', explicito: true };
+    }
+    return { modo: 'aberto', escopo: '', explicito: false };
+}
+
+/** A instrução para o agente, conforme o modo. */
+function instrucao({ modo, escopo } = ATUAL) {
+    if (modo === 'sem') {
+        return '[REFERÊNCIAS: NENHUMA] A pessoa quer SÓ MOTION: não pesquise (nada de pesquisar_referencia nem estudio_site), '
+            + 'não busque foto nem vídeo, não use estudio_midia de banco. Escreva o roteiro com o que o pedido já diz e deixe '
+            + 'o motion gerativo fazer o trabalho (roteiro.estilo "gerativo": a tipografia anima sozinha, sem template).';
+    }
+    if (modo === 'fechado') {
+        const t = termos(escopo);
+        return `[REFERÊNCIAS: ESCOPO FECHADO] Use SÓ estas fontes e termos: ${t.join(' · ') || escopo}. `
+            + 'Pesquise apenas dentro delas (em pesquisar_referencia, cite o site ou o termo no próprio texto da busca). '
+            + 'Nada de fato, foto ou vídeo de fora desse escopo; se faltar algo, diga no fim em uma linha. '
+            + `No roteiro, ponha roteiro.busca = ${JSON.stringify(t)} para o b-roll.`;
+    }
+    if (modo === 'aberto') {
+        return '[REFERÊNCIAS: ESCOPO ABERTO] Pesquise o assunto à vontade (pesquisar_referencia; estudio_site se for de uma marca) '
+            + 'e dê em cada parte do roteiro um "busca" em inglês com o que mostrar de fundo — gente, lugar, tela, objeto de verdade.';
+    }
+    return '';
+}
+
+/** Os domínios do escopo fechado: "só do site anthropic.com" → ['anthropic.com']. */
+function dominios(escopo = ATUAL.escopo) {
+    return termos(escopo).map((t) => t.replace(/^site:/, '').replace(/^https?:\/\//, '').replace(/^www\./, '').split('/')[0].toLowerCase())
+        .filter((t) => /^[a-z0-9-]+(\.[a-z0-9-]+)+$/.test(t));
+}
+
+/** O resultado da pesquisa sem o que está fora do escopo fechado (subdomínios valem: www-cdn.anthropic.com). */
+function filtrar(r, { modo, escopo } = ATUAL) {
+    if (modo !== 'fechado' || !r || !Array.isArray(r.referencias)) return r;
+    const ds = dominios(escopo);
+    if (!ds.length) return r;
+    const dentro = (u) => { try { const h = new URL(u).hostname.toLowerCase(); return ds.some((d) => h === d || h.endsWith('.' + d)); } catch { return false; } };
+    const refs = r.referencias.filter((x) => dentro(x.url));
+    const fora = r.referencias.length - refs.length;
+    if (!refs.length) return { ok: false, consulta: r.consulta, error: `nada desta busca é de ${ds.join(', ')} (escopo fechado)`,
+        comoCorrigir: `Abra o site direto: browser_open https://${ds[0]} e browser_read. Não use fonte de fora.` };
+    return { ...r, fontes: refs.length, referencias: refs, ...(fora ? { foraDoEscopo: fora } : {}) };
+}
+
+module.exports = { definir, atual, limpar, termos, entender, inferir, instrucao, dominios, filtrar };

package/lib/estudio/remotion.js

@@ -74,6 +74,10 @@ function pkgJson(nome) {
             remotion: VERSAO_REMOTION,
             react: '19.0.0',
             'react-dom': '19.0.0',
+            // O produto em 3D (kit/tres.jsx). Instalado uma vez na base compartilhada.
+            '@remotion/three': VERSAO_REMOTION,
+            three: '0.186.1',
+            '@react-three/fiber': '9.8.1',
         },
     }, null, 2) + '\n';
 }
@@ -275,14 +279,20 @@ function Elemento({ el, t, dados }) {
       if (Array.isArray(el.revelar) && typeof el.texto === 'string') {
         const palavras = el.texto.split(' ');
         conteudo = palavras.map((w, i) => {
-          const t0 = el.revelar[Math.min(i, el.revelar.length - 1)] ?? 0;
-          const k = Math.min(1, Math.max(0, (tLocal - t0) / 0.28));
+          const marcada = !!(el.destaques && el.destaques.includes(i));
+          /* A PALAVRA DE DESTAQUE: com "fonteDestaque", o acento é a serifa em
+             itálico (na cor do texto), que chega um instante depois das outras.
+             Um acento só — nada de caixa de cor atrás (a "cara de IA", 05/10). */
+          const serifa = marcada && el.fonteDestaque;
+          const t0 = (el.revelar[Math.min(i, el.revelar.length - 1)] ?? 0) + (serifa ? 0.12 : 0);
+          const k = Math.min(1, Math.max(0, (tLocal - t0) / (serifa ? 0.45 : 0.28)));
           const e = CURVAS.saida(k);
           // O espaço fica FORA do span: é ali que a linha pode quebrar.
           return (
             <React.Fragment key={i}>
               <span style={{ display: 'inline-block', opacity: e, transform: 'translateY(' + (1 - e) * 0.35 + 'em)',
-                color: el.destaques && el.destaques.includes(i) ? (el.corDestaque || el.cor) : undefined }}>{w}</span>
+                color: marcada && !serifa ? (el.corDestaque || el.cor) : undefined,
+                ...(serifa ? { fontFamily: '"' + el.fonteDestaque + '", Georgia, serif', fontStyle: 'italic', fontWeight: 400, fontSize: '1.1em', letterSpacing: 0 } : {}) }}>{w}</span>
               {i < palavras.length - 1 ? ' ' : null}
             </React.Fragment>
           );
@@ -461,12 +471,14 @@ function Elemento({ el, t, dados }) {
                   display: 'inline-block',
                   // A palavra forte é MAIOR na fonte, não na escala: escala não
                   // abre espaço, e ela cresceria por cima da vizinha.
-                  fontSize: p.forte ? '1.22em' : undefined,
+                  fontSize: p.forte ? (e.fonteForte ? '1.1em' : '1.22em') : undefined,
+                  // Com "fonteForte", a palavra forte é a serifa em itálico, não o letreiro maior.
+                  ...(p.forte && e.fonteForte ? { fontFamily: '"' + e.fonteForte + '", Georgia, serif', fontStyle: 'italic', fontWeight: 400, textTransform: 'none' } : {}),
                   transform: 'scale(' + salto + ') translateY(' + (1 - entra) * 18 + 'px)',
                   opacity: entra,
                   color: cor,
                   textShadow: e.sombra || '0 6px 22px rgba(0,0,0,.6), 0 2px 0 rgba(0,0,0,.35)',
-                  WebkitTextStroke: e.contorno || '2px rgba(0,0,0,.55)',
+                  WebkitTextStroke: p.forte && e.fonteForte ? undefined : (e.contorno || '2px rgba(0,0,0,.55)'),
                   paintOrder: 'stroke fill',
                   background: falando && e.fundoAtivo ? e.fundoAtivo : undefined,
                   borderRadius: '0.18em', padding: falando && e.fundoAtivo ? '0 0.12em' : undefined,
@@ -877,9 +889,15 @@ function fontesCSS(plano) {
     for (const cena of plano.cenas || []) andar(cena.elementos || []);
     andar(plano.hud);
     if (!usadas.size) return '/* nenhuma fonte externa neste vídeo */\n';
+    /* A FONTE VARIÁVEL: o motion gerativo anima os eixos (wght, wdth, GRAD…)
+       e precisa do arquivo variável inteiro, pedido pela faixa de cada eixo
+       ("Roboto+Flex:opsz,slnt,wdth,wght,GRAD@8..144,…"). As outras seguem
+       com os pesos fixos. */
+    const variaveis = plano.fontesVariaveis || {};
     const familias = [...usadas]
         // O Google devolve o que a família tem e ignora o resto: pedir todos os pesos e o itálico não quebra.
-        .map((f) => 'family=' + encodeURIComponent(f).replace(/%20/g, '+') + ':ital,wght@0,300;0,400;0,500;0,600;0,700;0,800;0,900;1,400;1,600')
+        .map((f) => 'family=' + encodeURIComponent(f).replace(/%20/g, '+')
+            + (variaveis[f] ? ':' + variaveis[f] : ':ital,wght@0,300;0,400;0,500;0,600;0,700;0,800;0,900;1,400;1,600'))
         .join('&');
     return `@import url('https://fonts.googleapis.com/css2?${familias}&display=block');\n`;
 }
@@ -904,15 +922,47 @@ function citarWin(a) {
     return '"' + t.replace(/"/g, '""') + '"';
 }
 
+/* O REMOTION COMPARTILHADO. Cada projeto rodava o próprio `npm install`
+   (minutos, e ~300 MB por vídeo) — e um 404 passageiro do registro no meio
+   dele derrubava o vídeo inteiro (medido em 30/09: source-map-js 1.2.2).
+   Agora a instalação mora UMA vez em ~/.primocode/studio/remotion-base, com
+   as mesmas dependências, e o projeto aponta para ela. Dependência diferente
+   (versão nova do Remotion) reinstala a base. */
+const os = require('os');
+function baseCompartilhada(raiz) {
+    const base = path.join(os.homedir(), '.primocode', 'studio', 'remotion-base');
+    let deps = '';
+    try { const pj = JSON.parse(fs.readFileSync(path.join(raiz, 'package.json'), 'utf8')); deps = JSON.stringify({ d: pj.dependencies || {}, v: pj.devDependencies || {} }); } catch { return null; }
+    return { base, deps, pronta: (() => {
+        try { return fs.existsSync(path.join(base, 'node_modules', '.bin')) && fs.readFileSync(path.join(base, 'deps.json'), 'utf8') === deps; } catch { return false; }
+    })() };
+}
+
 function renderizar({ raiz, saida, minutos = 30, aoFalar = () => {} }) {
     return new Promise((resolve) => {
-        const temNodeModules = fs.existsSync(path.join(raiz, 'node_modules'));
-        const passos = temNodeModules ? [] : [['npm', ['install', '--no-audit', '--no-fund']]];
-        passos.push(['npx', ['remotion', 'render', 'Video', saida, '--log=warn']]);
-
-        const correr = (i) => {
+        let temNodeModules = fs.existsSync(path.join(raiz, 'node_modules'));
+        const comp = temNodeModules || process.platform === 'win32' ? null : baseCompartilhada(raiz);
+        if (comp && comp.pronta) {
+            try { fs.symlinkSync(path.join(comp.base, 'node_modules'), path.join(raiz, 'node_modules'), 'dir'); temNodeModules = true; } catch { /* instala aqui mesmo */ }
+        }
+        const passos = [];
+        if (!temNodeModules && comp) {
+            // Instala na base (com uma segunda tentativa: o registro às vezes devolve 404 por instantes) e liga.
+            try { fs.mkdirSync(comp.base, { recursive: true }); fs.copyFileSync(path.join(raiz, 'package.json'), path.join(comp.base, 'package.json')); } catch { /* segue */ }
+            passos.push(['npm', ['install', '--no-audit', '--no-fund'], { cwd: comp.base, tentativas: 2, depois: () => {
+                fs.writeFileSync(path.join(comp.base, 'deps.json'), comp.deps);
+                try { fs.symlinkSync(path.join(comp.base, 'node_modules'), path.join(raiz, 'node_modules'), 'dir'); } catch { /* já existe */ }
+            } }]);
+        } else if (!temNodeModules) passos.push(['npm', ['install', '--no-audit', '--no-fund'], { tentativas: 2 }]);
+        // Vídeo de b-roll pesado (Pexels HD) levava mais de 30 s para o primeiro quadro.
+        /* VÁRIOS TRABALHADORES no render: o Remotion usa metade dos núcleos por
+           padrão; aqui vão quase todos (um fica para o terminal respirar). */
+        const nucleos = Math.max(2, (require('os').cpus() || []).length - 1);
+        passos.push(['npx', ['remotion', 'render', 'Video', saida, '--log=warn', '--timeout=120000', `--concurrency=${nucleos}`]]);
+
+        const correr = (i, tentativa = 1) => {
             if (i >= passos.length) return resolve({ ok: true, arquivo: saida });
-            const [cmd, args] = passos[i];
+            const [cmd, args, op = {}] = passos[i];
             aoFalar(i === 0 && !temNodeModules
                 ? 'instalando o Remotion nesta pasta (uma vez só, alguns minutos)'
                 : 'renderizando quadro a quadro');
@@ -926,7 +976,7 @@ function renderizar({ raiz, saida, minutos = 30, aoFalar = () => {} }) {
                CVE-2024-27980 o Node recusa spawnar npm.cmd/npx.cmd sem shell.
                Então as aspas entram na mão, só onde o shell existe. */
             const citados = process.platform === 'win32' ? args.map(citarWin) : args;
-            const p = spawn(cmd, citados, { cwd: raiz, shell: process.platform === 'win32' });
+            const p = spawn(cmd, citados, { cwd: op.cwd || raiz, shell: process.platform === 'win32' });
             let erro = '';
             p.stderr.on('data', (d) => { erro += d.toString().slice(0, 2000); });
             p.stdout.on('data', (d) => {
@@ -937,8 +987,10 @@ function renderizar({ raiz, saida, minutos = 30, aoFalar = () => {} }) {
             p.on('close', (code) => {
                 clearTimeout(relogio);
                 if (code !== 0) {
+                    if (tentativa < (op.tentativas || 1)) { aoFalar('o npm tropeçou — tentando de novo'); return setTimeout(() => correr(i, tentativa + 1), 3000); }
                     return resolve({ ok: false, error: `${cmd} saiu com ${code}: ${erro.slice(-600).trim()}` });
                 }
+                try { if (op.depois) op.depois(); } catch { /* segue */ }
                 correr(i + 1);
             });
             p.on('error', (e) => {
@@ -961,4 +1013,41 @@ function renderizar({ raiz, saida, minutos = 30, aoFalar = () => {} }) {
     });
 }
 
-module.exports = { montar, renderizar, fontesCSS, VERSAO_REMOTION, CENA_JSX };
+/* ── ABRIR PARA EDITAR ────────────────────────────────────────────────
+   "Quando eu falar pra editar, edita no editor de vídeo open source." O
+   projeto já é Remotion: editar é abrir o Remotion Studio na pasta dele. Ele
+   sobe solto (o PrimoCode não espera) e abre o navegador sozinho. */
+function comandoStudio(raiz) {
+    return { cmd: 'npx', args: ['remotion', 'studio'], cwd: raiz };
+}
+
+function abrirStudio({ raiz, spawnar = spawn } = {}) {
+    if (!raiz || !fs.existsSync(path.join(raiz, 'package.json'))) {
+        return { ok: false, error: 'não achei o projeto Remotion nesta pasta.' };
+    }
+    // O Studio precisa do Remotion instalado. A base compartilhada já vem do primeiro render.
+    if (!fs.existsSync(path.join(raiz, 'node_modules'))) {
+        const comp = process.platform === 'win32' ? null : baseCompartilhada(raiz);
+        if (comp && comp.pronta) {
+            try { fs.symlinkSync(path.join(comp.base, 'node_modules'), path.join(raiz, 'node_modules'), 'dir'); } catch { /* segue */ }
+        }
+        if (!fs.existsSync(path.join(raiz, 'node_modules'))) {
+            return { ok: false, error: 'o Remotion ainda não está instalado para este projeto.',
+                comoResolver: 'renderize uma vez com estudio_render (instala o Remotion), depois abra o editor.' };
+        }
+    }
+    const c = comandoStudio(raiz);
+    const win = process.platform === 'win32';
+    try {
+        const p = spawnar(c.cmd, win ? c.args.map(citarWin) : c.args,
+            { cwd: c.cwd, detached: true, stdio: 'ignore', shell: win });
+        if (p && p.on) p.on('error', () => { /* sem npx: o caminho vai na resposta */ });
+        if (p && p.unref) p.unref();
+    } catch (e) {
+        return { ok: false, error: e.message };
+    }
+    return { ok: true, raiz, comando: `cd "${raiz}" && npx remotion studio` };
+}
+
+module.exports = { montar, renderizar, fontesCSS, VERSAO_REMOTION, CENA_JSX, pkgJson, baseCompartilhada, TSCONFIG,
+    comandoStudio, abrirStudio };

package/lib/estudio/ritmo.js

@@ -25,7 +25,7 @@ const r2 = (n) => Math.round(n * 100) / 100;
  *
  * @returns {{ini:number[], dur:number[], total:number, temVoz:boolean}}
  */
-function tempoDasPartes(partes, tempos = [], { semVoz = () => 2.6, antes = 0.12, cauda = 1.1, minimo = 1.1 } = {}) {
+function tempoDasPartes(partes, tempos = [], { semVoz = () => 2.0, antes = 0.08, cauda = 0.6, minimo = 0.9 } = {}) {
     const temVoz = tempos.length === partes.length && tempos.every((t) => t && t.ate > t.de);
     const ini = [];
     if (temVoz) partes.forEach((_, i) => ini.push(i === 0 ? 0 : r2(Math.max(ini[i - 1] + minimo, tempos[i].de - antes))));
@@ -60,7 +60,7 @@ function palavrasNaCena(tempo, inicio) {
 }
 
 /** O volume da trilha no tempo: cheia no respiro, baixa quando a voz fala, some no fim. */
-function volumesDaTrilha(tempos, total, { alto = 0.22, baixo = 0.11 } = {}) {
+function volumesDaTrilha(tempos, total, { alto = 0.4, baixo = 0.2 } = {}) {
     const k = (t, v) => ({ t: r2(t), v });
     const vs = [k(0, 0.05), k(0.4, alto)];
     // Um quadro-chave de cada vez, sempre depois do anterior: fala colada na outra não volta no tempo.

package/lib/estudio/sons-leves.js

@@ -32,6 +32,14 @@ const EFEITOS = {
     subida: ['-f', 'lavfi', '-i', "aevalsrc='0.28*sin(2*PI*(180+260*t*t)*t)*(t/1.4)':s=44100:d=1.4", '-af', 'afade=t=out:st=1.2:d=0.2'],
     // Toque grave e macio: o que chega e assenta.
     toque: ['-f', 'lavfi', '-i', "aevalsrc='0.7*sin(2*PI*(110-50*t)*t)*exp(-7*t)':s=44100:d=0.6", '-af', 'lowpass=f=900'],
+    /* Os CHEIOS do motion gerativo ("motion é vida: efeito sonoro NA ação",
+       30/09): o whoosh da passagem, o impacto da tese, o riser antes da
+       revelação e o pop da letra que nasce. Ainda sintetizados, ainda limpos. */
+    whoosh: ['-f', 'lavfi', '-i', 'anoisesrc=d=0.75:c=pink:a=0.9', '-af',
+        'bandpass=f=1100:width_type=o:w=2.2,afade=t=in:st=0:d=0.42:curve=exp,afade=t=out:st=0.42:d=0.33:curve=qsin,volume=2.2'],
+    impacto: ['-f', 'lavfi', '-i', "aevalsrc='0.95*sin(2*PI*(62-26*t)*t)*exp(-4.5*t)+0.45*(random(0)*2-1)*exp(-38*t)':s=44100:d=1.1", '-af', 'lowpass=f=2600,volume=1.4'],
+    riser: ['-f', 'lavfi', '-i', "aevalsrc='(0.32*sin(2*PI*(170+620*t*t)*t)+0.22*(random(0)*2-1))*pow(t/1.1,2)':s=44100:d=1.1", '-af', 'highpass=f=260,afade=t=out:st=1.04:d=0.06,volume=1.3'],
+    pop: ['-f', 'lavfi', '-i', "aevalsrc='0.8*sin(2*PI*(980-640*t)*t)*exp(-28*t)*(1-exp(-700*t))':s=44100:d=0.18"],
 };
 
 /**
@@ -59,4 +67,33 @@ function preparar(pasta, { rodar = null } = {}) {
     return sons;
 }
 
-module.exports = { EFEITOS, preparar };
+/**
+ * A família de sons de UM vídeo (gerativo.js sonsDoVideo): cada receita vira
+ * midia/sfx-g<semente>-<nome>.mp3. O que já existe não é refeito.
+ */
+function prepararReceitas(pasta, { receitas = {}, semente = 0 } = {}, { rodar = null } = {}) {
+    const exec = rodar || ((args) => {
+        try { require('child_process').execFileSync('ffmpeg', args, { stdio: 'ignore', timeout: 30000 }); return true; }
+        catch { return false; }
+    });
+    const sons = {};
+    const sufixo = (semente >>> 0).toString(36);
+    for (const [nome, args] of Object.entries(receitas)) {
+        const rel = `midia/sfx-g${sufixo}-${nome}.mp3`;
+        const cheio = path.join(pasta, rel);
+        if (!fs.existsSync(cheio)) {
+            fs.mkdirSync(path.dirname(cheio), { recursive: true });
+            // O limitador no fim: o golpe sintetizado passava de 0 dB e estalava.
+            // "{pasta}" é a pasta do projeto: o som feito da própria trilha lê o arquivo dela.
+            const a = args.map((x) => String(x).split('{pasta}').join(pasta));
+            const fc = a.indexOf('-filter_complex'), i = a.indexOf('-af');
+            if (fc >= 0) a[fc + 1] += ',alimiter=limit=0.8:level=false';
+            else if (i >= 0) a[i + 1] += ',alimiter=limit=0.8:level=false'; else a.push('-af', 'alimiter=limit=0.8:level=false');
+            if (!exec(['-y', '-loglevel', 'error', ...a, '-q:a', '3', cheio])) continue;
+        }
+        sons[nome] = rel;
+    }
+    return sons;
+}
+
+module.exports = { EFEITOS, preparar, prepararReceitas };

package/lib/estudio/variacao3d.js

@@ -0,0 +1,46 @@
+/**
+ * variacao3d.js — o produto em 3D (kit/tres.jsx) diferente a cada vídeo.
+ *
+ *   "várias opções de elementos 3D... vários estilos... que não sejam padrão
+ *    da IA" (Joel, 05/10)
+ *
+ * Antes, todo fone saía igual: o mesmo material, a mesma câmera, a mesma luz
+ * e o mesmo giro. Agora cada vídeo sorteia o acabamento, o enquadramento, a
+ * luz e o ritmo — sem repetir os últimos (memória '3d' do variedade.js). Os
+ * nomes daqui são as chaves que o tres.jsx desenha.
+ */
+
+'use strict';
+
+const variedade = require('./variedade.js');
+
+const VARIACOES = {
+    acabamento: ['verniz', 'metal', 'fosco', 'perola', 'acetinado'],
+    camera: ['frente', 'alto', 'baixo', 'perfil', 'perto'],
+    luz: ['estudio', 'recorte', 'suave', 'lateral'],
+    ritmo: ['lento', 'medio', 'rapido', 'pendulo'],
+};
+
+/** Um 3D por vídeo: cada faceta sorteada sem repetir as últimas. */
+function escolherVariacao3d(aleatorio = Math.random) {
+    const v = {};
+    for (const [faceta, opcoes] of Object.entries(VARIACOES)) v[faceta] = variedade.sortear(opcoes, '3d', { prefixo: faceta + ':', aleatorio });
+    return v;
+}
+
+/** Qual modelo o pedido descreve. Sem pista, a caixa — um produto genérico que ainda gira. */
+const MODELOS3D = [
+    ['fone', /fone|headset|headphone|auricular/i],
+    ['celular', /celular|smartphone|iphone|phone|telefone/i],
+    ['notebook', /notebook|laptop|computador|macbook/i],
+    ['relogio', /rel[oó]gio|smartwatch|\bwatch\b/i],
+    ['garrafa', /garrafa|squeeze|bottle|garrafinha|vinho|perfume/i],
+    ['lata', /lata|bebida|refri|cerveja|energ[eé]tico/i],
+];
+
+function modeloDoPedido(texto) {
+    const achado = MODELOS3D.find(([, re]) => re.test(String(texto || '')));
+    return achado ? achado[0] : 'caixa';
+}
+
+module.exports = { VARIACOES, MODELOS3D, escolherVariacao3d, modeloDoPedido };

package/lib/estudio/variedade.js

@@ -0,0 +1,183 @@
+/**
+ * variedade.js — a trilha e os efeitos dos vídeos de corte (híbrido, cinema,
+ * impacto) sem repetir de um vídeo para o outro.
+ *
+ *   "todos os vídeos é sempre as mesmas músicas, os mesmos efeitos sonoros,
+ *    sempre o mesmo padrão de vídeo" (Joel, 02/10)
+ *
+ * A causa era a mesma nos dois: um termo fixo na busca ("inspiring
+ * corporate", "cinematic whoosh") e o PRIMEIRO resultado baixado. A busca
+ * devolve a mesma lista na mesma ordem, então todo vídeo saía com a mesma
+ * faixa e o mesmo whoosh. Aqui:
+ *   1. o termo sai de um cardápio pelo clima do roteiro, em ordem sorteada;
+ *   2. dos resultados, sorteia — e pula o que os últimos vídeos já usaram;
+ *   3. o que foi usado entra na memória (~/.primocode/studio/<tipo>-usadas.json).
+ */
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const PASTA = path.join(os.homedir(), '.primocode', 'studio');
+const MEMORIA = { trilha: 16, sfx: 40, broll: 80, icones: 4, estilo: 8, '3d': 24 };
+
+function arquivo(tipo) { return path.join(PASTA, `${tipo}-usadas.json`); }
+
+function usadas(tipo) {
+    try { const l = JSON.parse(fs.readFileSync(arquivo(tipo), 'utf8')); return Array.isArray(l) ? l : []; } catch { return []; }
+}
+
+function marcar(tipo, id) {
+    if (!id) return;
+    try {
+        fs.mkdirSync(PASTA, { recursive: true });
+        const l = [id, ...usadas(tipo).filter((x) => x !== id)].slice(0, MEMORIA[tipo] || 20);
+        fs.writeFileSync(arquivo(tipo), JSON.stringify(l));
+    } catch { /* sem memória: só perde a garantia de não repetir */ }
+}
+
+function embaralhar(lista, aleatorio = Math.random) {
+    const a = [...lista];
+    for (let i = a.length - 1; i > 0; i--) {
+        const j = Math.floor(aleatorio() * (i + 1));
+        [a[i], a[j]] = [a[j], a[i]];
+    }
+    return a;
+}
+
+/** Os itens da busca na ordem de tentar: os nunca usados primeiro (sorteados), os usados no fim. */
+function ordenar(itens, tipo, aleatorio = Math.random) {
+    const ja = new Set(usadas(tipo));
+    const validos = (itens || []).filter((x) => x && x.url);
+    return [...embaralhar(validos.filter((x) => !ja.has(x.url)), aleatorio), ...validos.filter((x) => ja.has(x.url))];
+}
+
+/**
+ * Uma das opções, sem repetir as últimas: as nunca usadas primeiro (sorteadas),
+ * depois a usada há mais tempo. Marca a escolhida na memória do tipo. Com
+ * `prefixo`, várias listas dividem o mesmo arquivo ('acabamento:fosco').
+ */
+function sortear(opcoes, tipo, { prefixo = '', aleatorio = Math.random } = {}) {
+    if (!opcoes || !opcoes.length) return null;
+    const ja = usadas(tipo);
+    const idade = (o) => ja.indexOf(prefixo + o);   // 0 = a última usada
+    const novas = embaralhar(opcoes.filter((o) => idade(o) < 0), aleatorio);
+    const velhas = opcoes.filter((o) => idade(o) >= 0).sort((a, b) => idade(b) - idade(a));
+    const escolha = [...novas, ...velhas][0];
+    marcar(tipo, prefixo + escolha);
+    return escolha;
+}
+
+// ── a trilha: termos por clima ──────────────────────────────────────────
+const CLIMAS = {
+    tecnologia: ['electronic instrumental', 'synthwave instrumental', 'future bass instrumental', 'downtempo electronic', 'minimal techno instrumental', 'chillwave instrumental'],
+    energetico: ['funk instrumental', 'rock instrumental', 'drum and bass instrumental', 'breakbeat instrumental', 'upbeat indie instrumental', 'house instrumental'],
+    epico: ['epic orchestral', 'trailer instrumental', 'cinematic drums', 'epic hybrid instrumental', 'dramatic strings'],
+    calmo: ['lofi hip hop instrumental', 'ambient instrumental', 'acoustic guitar instrumental', 'piano instrumental', 'jazz instrumental'],
+    alegre: ['ukulele instrumental', 'indie pop instrumental', 'happy acoustic instrumental', 'latin instrumental', 'disco instrumental'],
+    emocional: ['piano emotional instrumental', 'post rock instrumental', 'cinematic strings', 'neo classical instrumental'],
+    misterio: ['dark ambient instrumental', 'trip hop instrumental', 'suspense instrumental', 'noir jazz instrumental'],
+    neutro: ['indie instrumental', 'soul instrumental', 'jazz hop instrumental', 'world instrumental', 'electronic instrumental', 'acoustic instrumental'],
+};
+const SINONIMOS = {
+    tecnologia: /tec|tech|ia\b|ai\b|software|app|digital|futur/, energetico: /energ|agit|rapid|forte|esport|academ/,
+    epico: /epic|epico|grandi|trailer|impact/, calmo: /calm|tranq|suave|relax|chill/, alegre: /aleg|feliz|divert|leve/,
+    emocional: /emoc|emoti|inspir|sentim|historia/, misterio: /mist|sombr|dark|suspen|tens/,
+};
+
+function climaDe(roteiro = {}, estilo = '') {
+    const t = String([roteiro.clima, roteiro.genero, roteiro.tom].filter(Boolean).join(' ')).toLowerCase()
+        .normalize('NFD').replace(/[̀-ͯ]/g, '');
+    for (const [clima, re] of Object.entries(SINONIMOS)) if (re.test(t)) return clima;
+    return estilo === 'impacto' ? 'energetico' : 'neutro';
+}
+
+/**
+ * Os termos para buscar a trilha, em ordem de tentar. O pedido explícito
+ * (roteiro.musica) vem primeiro; depois o clima, sorteado; e por último um
+ * clima vizinho, para nunca sair sem música.
+ */
+function termosTrilha(roteiro = {}, estilo = '', aleatorio = Math.random) {
+    const clima = climaDe(roteiro, estilo);
+    const reserva = clima === 'neutro' ? 'calmo' : 'neutro';
+    return [...new Set([roteiro.musica, ...embaralhar(CLIMAS[clima], aleatorio).slice(0, 3),
+        ...embaralhar(CLIMAS[reserva], aleatorio).slice(0, 2)].filter(Boolean))];
+}
+
+// ── os efeitos: várias formas de pedir o mesmo som ───────────────────────
+const SFX = {
+    teclado: ['keyboard typing', 'typing keyboard', 'mechanical keyboard', 'laptop typing', 'typewriter keys'],
+    whoosh: ['cinematic whoosh', 'swoosh transition', 'air whoosh', 'fast swipe', 'woosh pass by', 'riser whoosh'],
+    impacto: ['cinematic boom impact', 'deep cinematic impact', 'trailer hit', 'bass drop hit', 'punch hit', 'sub boom'],
+    sala: ['crowd murmur indoor', 'office ambience', 'people talking background', 'cafe ambience', 'room tone people'],
+};
+
+function termosSfx(nome, aleatorio = Math.random) {
+    return embaralhar(SFX[nome] || [nome], aleatorio).slice(0, 3);
+}
+
+// ── o b-roll: o mesmo pedido, de jeitos diferentes ───────────────────────
+/* "não ficar só nas mesmas fontes, mesmos estilos" (Joel, 05/10): o mesmo
+   roteiro renderizado duas vezes trocou fonte, cor e música, mas o b-roll
+   veio IDÊNTICO — as mesmas mãos no teclado. O termo era o mesmo e o
+   primeiro resultado do Pexels também. Agora o termo ganha um jeito de
+   filmar sorteado, e o clipe já usado vai para o fim da fila. */
+const JEITOS = ['cinematic', 'slow motion', 'close up', 'natural light', 'detail shot', 'wide shot', 'handheld'];
+
+function termosBroll(termo, aleatorio = Math.random) {
+    const t = String(termo || '').replace(/\s+/g, ' ').trim();
+    if (!t) return [];
+    const jeitos = embaralhar(JEITOS.filter((j) => !t.toLowerCase().includes(j)), aleatorio).slice(0, 2);
+    return embaralhar([t, ...jeitos.map((j) => `${t} ${j}`)], aleatorio);
+}
+
+/**
+ * Busca com as variações do termo e devolve os itens na ordem de tentar:
+ * para no primeiro termo que trouxer algo nunca usado. `buscar(termo)`
+ * devolve a lista de itens ({url, …}) — é a busca de verdade, ou um stub.
+ */
+async function buscarSemRepetir(buscar, termo, tipo = 'broll', aleatorio = Math.random) {
+    const ja = new Set(usadas(tipo));
+    let reserva = [];
+    for (const t of termosBroll(termo, aleatorio)) {
+        let itens = [];
+        try { itens = ordenar(await buscar(t), tipo, aleatorio); } catch { continue; }
+        if (itens.length && !ja.has(itens[0].url)) return itens;
+        if (!reserva.length) reserva = itens;
+    }
+    return reserva;
+}
+
+// ── os ícones: a coleção muda de um vídeo para o outro ──────────────────
+/* O ícone automático (edicao.iconeDe) é sempre "fluent-3d:<emoji>". Estas
+   coleções do Iconify usam os mesmos nomes de emoji, então dá para trocar a
+   coleção inteira do vídeo; o que não existir na coleção nova fica no 3D. */
+const FAMILIAS_ICONE = ['fluent-3d', 'fluent-emoji-flat', 'fluent-emoji', 'noto', 'twemoji', 'openmoji'];
+
+function colecaoIcones(aleatorio = Math.random) {
+    return ordenar(FAMILIAS_ICONE.map((url) => ({ url })), 'icones', aleatorio)[0].url;
+}
+
+function cadaIcone(plano, fn) {
+    for (const cena of (plano && plano.cenas) || []) for (const el of cena.elementos || []) if (el && el.tipo === 'icone' && el.nome) fn(el);
+}
+
+/** Os ícones automáticos do plano — os que o roteiro pediu pelo nome ficam como estão. */
+function iconesTrocaveis(plano, explicitos = []) {
+    const fixos = new Set(explicitos);
+    const nomes = new Set();
+    cadaIcone(plano, (el) => { if (/^fluent-3d:/.test(el.nome) && !fixos.has(el.nome)) nomes.add(el.nome); });
+    return [...nomes];
+}
+
+/** Troca no plano cada nome que estiver em `troca` ({velho: novo}). Devolve quantos trocou. */
+function trocarIcones(plano, troca = {}) {
+    let n = 0;
+    cadaIcone(plano, (el) => { if (troca[el.nome]) { el.nome = troca[el.nome]; n++; } });
+    return n;
+}
+
+module.exports = { usadas, marcar, embaralhar, ordenar, sortear, climaDe, termosTrilha, termosSfx, termosBroll, buscarSemRepetir,
+    colecaoIcones, iconesTrocaveis, trocarIcones, CLIMAS, SFX, JEITOS, FAMILIAS_ICONE };