primocode 9.8.0-beta.11 → 9.8.0-beta.13

package/README.md

@@ -1,4 +1,4 @@
-# PrimoCode v9.8.0-beta.11
+# PrimoCode v9.8.0-beta.13
 
 Agente de engenharia brasileiro para o terminal, no estilo Claude Code.
 Cria arquivos de verdade, roda comandos, **controla o navegador e o desktop** —
@@ -9,7 +9,7 @@ OpenRouter, e cada apelido (`top`/`main`/`fast`) é uma **corrente**: se um mode
 está no limite de pedidos, o próximo atende. Você não vê o erro, e não paga nada.
 
 ```
- ▐▛███▜▌   Primo Code v9.8.0-beta.11
+ ▐▛███▜▌   Primo Code v9.8.0-beta.13
 ▝▜█████▛▘  Bem-vindo de volta, Joel
   ▘▘ ▝▝    ~/primocode  · /dir <pasta> muda
 ```

package/lib/act.js

@@ -692,15 +692,19 @@ async function runAct(userPrompt, opts) {
 
                Um modelo não chama tool fora da lista por conta própria. Só
                chamou porque este parágrafo mandou. */
+            /* O caminho do ROTEIRO (lib/estudio/composicao.js). Antes esta
+               ordem mandava chamar o diretor e depois compor "cena a cena,
+               com as primitivas" — o modelo escrevia posição em pixel e o
+               vídeo saía quebrado, além de custar três ou quatro rodadas a
+               mais de modelo (medido em 25/09). */
             messages.push({ role: 'system', content:
-                'ESTE PEDIDO É DE PRODUÇÃO AUDIOVISUAL. Se `planejar_producao` estiver na sua lista de '
-                + `ferramentas, chame-o ANTES de criar qualquer peça (formato "${producao.formato}"): `
-                + 'ele devolve a pauta — arco, narração falada, voz, direção de arte e a mídia a buscar — '
-                + 'e é ela que você produz, cena a cena, compondo com as primitivas. '
-                + 'Se ele NÃO estiver na sua lista, não o chame e não procure equivalente: siga com as '
-                + 'ferramentas que você tem e escreva o roteiro antes das cenas, não dentro do JSON delas. '
-                + 'Nunca chame uma ferramenta que não está na sua lista — a chamada é recusada e a tarefa '
-                + 'se perde.' });
+                `ESTE PEDIDO É DE PRODUÇÃO (formato "${producao.formato === 'apresentacao' ? 'slides' : 'video'}"). Faça em três passos: `
+                + `estudio_projeto acao:"criar" com formato "${producao.formato === 'apresentacao' ? 'slides' : 'video'}" → `
+                + 'estudio_plano com "roteiro" (partes com tipo e fala; o PrimoCode faz layout, voz, ícones, música e sons) → '
+                + 'estudio_render. Se a peça for de uma marca de verdade, estudio_site antes, e use as cores e a logo em roteiro.marca. '
+                + 'NÃO escreva cenas, elementos nem posições à mão. '
+                + 'Se estudio_plano não aceitar "roteiro" (servidor antigo), siga com as ferramentas que você tem. '
+                + 'Nunca chame uma ferramenta que não está na sua lista — a chamada é recusada e a tarefa se perde.' });
         }
     }
 

package/lib/catalogo.js

@@ -84,7 +84,11 @@ const GRUPOS = [
                 + 'SEMPRE procure antes de criar quando o pedido falar de algo que já existe.' },
 
             { tool: 'estudio_plano', escreve: true, faz: 'escreve ou ajusta o que o vídeo É — cenas, elementos, animação, câmera, áudio',
-              args: 'id. plano: {formato:{largura,altura,fps}, cenas:[…], audio:{…}} — ou cenas direto. '
+              args: 'id. PREFIRA roteiro: {marca:{cores:{fundo,destaque,tinta},fontes:{titulo,texto},logo}, proporcao, '
+                + 'partes:[{tipo, fala, …}]} — o PrimoCode faz o layout, a voz com entonação, os ícones, a música e os sons. '
+                + 'Tipos: abertura{titulo,sub} titulo{titulo,sub} numero{valor,rotulo,sub} lista{titulo,itens} passos{titulo,itens} '
+                + 'contraste{nao,sim} citacao{texto,autor} imagem{busca,titulo,sub} grafico{titulo,barras:[{rotulo,valor}]} cta{titulo,link}. '
+                + 'voz (thalita|antonio|francisca). Ajuste fino: plano: {formato:{largura,altura,fps}, cenas:[…], audio:{…}} — ou cenas direto. '
                 + 'cena (opcional): o número de UMA cena para trocar só ela, sem reescrever o resto. '
                 + 'motivo (opcional): fica no caderno. voltarPara (opcional): nome de uma versão. '
                 + 'Sem plano nem cenas, LÊ o plano atual. '

package/lib/claude-engine.js

@@ -61,6 +61,28 @@ function argsDoModelo() {
     return MODELO_CLAUDE ? ['--model', MODELO_CLAUDE] : [];
 }
 
+/* O Claude Code ENXUTO, como motor. Sem isto cada passo do agente abria o
+ * Claude Code da pessoa inteiro: hooks, plugins, skills, CLAUDE.md dela e as
+ * ferramentas nativas — 36 mil tokens e ~6 s por chamada, e a resposta
+ * chegava com recado de hook pessoal ("context-sync pendente"). Medido em
+ * 25/09: com estes argumentos, a mesma chamada leva 473 tokens e ~3,5 s. Um
+ * pedido de 100 passos pagava aquilo 100 vezes — é a demora de 20 minutos.
+ *
+ * Nada disto tira o que o motor precisa: o protocolo vai inteiro no prompt
+ * (corpoDoProtocolo), e as ferramentas que valem são as do PrimoCode, não as
+ * do Claude Code. */
+const ARGS_ENXUTOS = [
+    '--setting-sources', 'project',
+    '--strict-mcp-config',
+    '--disable-slash-commands',
+    '--tools', '',
+    '--no-session-persistence',
+    '--system-prompt', 'Você é o motor de decisão do PrimoCode. Siga à risca o protocolo que vem na mensagem e responda só com o bloco pedido.',
+];
+function argsDoMotor() {
+    return [...ARGS_ENXUTOS, ...argsDoModelo()];
+}
+
 /**
  * Acha o ÚLTIMO bloco marcado no texto (pode vir ruído de terminal — prompt
  * ANSI, texto solto — antes e depois) e devolve o JSON de dentro dele.
@@ -567,7 +589,7 @@ async function requestActViaHeadless(payload, onEvent) {
         '-p',
         '--output-format', 'json',
         '--dangerously-skip-permissions',
-        ...argsDoModelo(),
+        ...argsDoMotor(),
     ], { encoding: 'utf-8', timeout: 180000, input: prompt, maxBuffer: 32 * 1024 * 1024,
         env: process.env, ...SEM_APARECER });
     const r = JSON.parse(saida);
@@ -577,7 +599,7 @@ async function requestActViaHeadless(payload, onEvent) {
     const pedirCorrecao = (aviso) => {
         const s = execFileSync('claude', [
             '-p', '--output-format', 'json', '--dangerously-skip-permissions',
-            ...argsDoModelo(),
+            ...argsDoMotor(),
         ], {
             encoding: 'utf-8', timeout: 120000, maxBuffer: 32 * 1024 * 1024,
             env: process.env,
@@ -622,7 +644,7 @@ module.exports = {
     // o que veio torto. Reimplementar aquilo no outro motor seria manter dois
     // protocolos que divergem na primeira correção de um deles.
     linhaDoHistorico, nomesDasTools, promptDoProtocolo, promptDeCorrecao,
-    MODELO_CLAUDE, argsDoModelo,
+    MODELO_CLAUDE, argsDoModelo, argsDoMotor,
     SKILL_DIR, SKILL_PATH, garantirSkill,
     temClaudeCode, temOrca, orcaAlcancavel, escolherCaminho,
     garantirEngine, requestAct, emitirDecisao,

package/lib/estudio/composicao.js

@@ -0,0 +1,404 @@
+/**
+ * composicao.js — o roteiro vira cena, e quem faz o layout é o CÓDIGO.
+ *
+ *   "Os motion estão bem quebrados, a voz está sem entonação, não tem música,
+ *    efeitos sonoros, ícones… ele sobrepõe as coisas." · "Os slides entregou
+ *    uma merda." (25/09/2026)
+ *
+ * O modelo escrevia a posição de cada texto em pixel, à mão, e errava: texto
+ * cortado na borda, letra minúscula, meia tela vazia, nada de som. Aqui o
+ * modelo escreve só o ROTEIRO — o que cada parte diz e de que tipo ela é — e
+ * o código monta a cena:
+ *
+ *   - a letra é MEDIDA para caber na caixa (nunca sai da tela, nunca some de
+ *     tão pequena), e tudo respeita a margem de segurança;
+ *   - cada tipo de parte tem a composição dele (abertura, número que conta,
+ *     lista com ícones, contraste, citação, imagem, gráfico, passos, chamada),
+ *     e a variação vem da marca e da posição no roteiro;
+ *   - no vídeo, cada parte dura o que a voz dela dura, e o som (whoosh na
+ *     transição, pop no item, música de cama) entra sozinho;
+ *   - no slide, é a MESMA cena, parada.
+ *
+ * Função pura: roteiro + tempos da voz entram, plano sai.
+ */
+
+'use strict';
+
+const { iconeDe } = require('./edicao.js');
+
+const TIPOS = ['abertura', 'titulo', 'numero', 'lista', 'contraste', 'citacao', 'imagem', 'grafico', 'passos', 'cta'];
+
+// ── cor ──────────────────────────────────────────────────────────────────
+function rgb(hex) {
+    const h = String(hex || '').replace('#', '');
+    const n = h.length === 3 ? h.split('').map((c) => c + c).join('') : h.padEnd(6, '0').slice(0, 6);
+    return [0, 2, 4].map((i) => parseInt(n.slice(i, i + 2), 16) || 0);
+}
+const hex = (c) => '#' + c.map((v) => Math.max(0, Math.min(255, Math.round(v))).toString(16).padStart(2, '0')).join('');
+const misturar = (a, b, k) => hex(rgb(a).map((v, i) => v + (rgb(b)[i] - v) * k));
+const luz = (c) => { const [r, g, b] = rgb(c); return (0.299 * r + 0.587 * g + 0.114 * b) / 255; };
+const alfa = (c, a) => c + Math.round(a * 255).toString(16).padStart(2, '0');
+
+function paleta(marca = {}) {
+    const c = marca.cores || {};
+    const fundo = c.fundo || '#0E0F14';
+    const escuro = luz(fundo) < 0.5;
+    const tinta = c.tinta || (escuro ? '#F4F2EC' : '#15161A');
+    const destaque = c.destaque || '#FF6A3D';
+    return {
+        fundo, tinta, destaque, escuro,
+        fundo2: misturar(fundo, tinta, escuro ? 0.07 : 0.05),
+        apoio: c.apoio || misturar(destaque, tinta, 0.35),
+        suave: alfa(tinta, 0.68),
+        // Sobre o destaque, a tinta que dá contraste.
+        sobreDestaque: luz(destaque) > 0.6 ? '#15161A' : '#FFFFFF',
+    };
+}
+
+/* ── a letra que cabe ─────────────────────────────────────────────────────
+ * Largura média do caractere em "em" por família. Não é exata — é o
+ * bastante para escolher o maior tamanho que cabe em N linhas, com folga. */
+const LARGURA = { condensada: 0.43, display: 0.56, texto: 0.52, serifa: 0.5 };
+const FAMILIA_TIPO = (f) => (/condensed|narrow|anton|oswald|bebas|teko|league gothic/i.test(f) ? 'condensada'
+    : /serif|fraunces|playfair|garamond|lora|newsreader|spectral|baskerville|dm serif/i.test(f) ? 'serifa'
+        : /black|bricolage|archivo|sora|grotesk|syne|unbounded/i.test(f) ? 'display' : 'texto');
+
+function caber(texto, { largura, linhas = 2, max = 200, min = 18, fonte = 'Inter' }) {
+    const cw = LARGURA[FAMILIA_TIPO(fonte)];
+    const palavras = String(texto || '').split(/\s+/).filter(Boolean);
+    for (let t = Math.round(max); t >= min; t -= 2) {
+        // Quebra de verdade, palavra por palavra: é o que o navegador fará.
+        let n = 1, linha = 0;
+        let cabe = true;
+        for (const w of palavras) {
+            const lw = (w.length + 1) * cw * t;
+            if (lw > largura * 1.02) { cabe = false; break; } // uma palavra sozinha não cabe
+            if (linha + lw > largura) { n++; linha = lw; } else linha += lw;
+        }
+        if (cabe && n <= linhas) return { tamanho: t, linhas: n };
+    }
+    return { tamanho: min, linhas };
+}
+
+// ── as partes do roteiro ─────────────────────────────────────────────────
+const r2 = (n) => Math.round(n * 100) / 100;
+const TRANSICOES = ['deslizar', 'zoom', 'mascara', 'esmaecer', 'morph'];
+
+function textoDe(p) {
+    return [p.titulo, p.texto, p.valor, p.rotulo, p.sub, p.nao, p.sim, ...(p.itens || []).map((i) => (typeof i === 'string' ? i : i.texto))]
+        .filter(Boolean).join(' ');
+}
+
+/** O que a voz diz nesta parte. Sem "fala", a voz lê o que está na tela. */
+function falaDe(p) {
+    if (p.fala) return String(p.fala);
+    if (p.tipo === 'numero') return `${p.valor} ${p.rotulo || ''}.`;
+    return textoDe(p);
+}
+
+/** O registro da voz para esta parte (ver REGISTRO em studio/narrar.py). */
+function registroDe(p, i, n) {
+    if (i === 0) return 'gancho';
+    if (p.tipo === 'cta' || i === n - 1) return 'cta';
+    return { numero: 'numero', contraste: 'contraste', lista: 'lista', citacao: 'citacao', passos: 'lista' }[p.tipo] || 'normal';
+}
+
+function iconesDoRoteiro(roteiro) {
+    const nomes = new Set();
+    for (const p of roteiro.partes || []) {
+        for (const it of p.itens || []) {
+            const t = typeof it === 'string' ? it : it.texto;
+            const ic = (typeof it === 'object' && it.icone) || iconeDoTexto(t);
+            if (ic) nomes.add(ic);
+        }
+    }
+    return [...nomes];
+}
+
+function iconeDoTexto(t) {
+    for (const w of String(t || '').split(/\s+/)) { const ic = iconeDe(w); if (ic) return ic; }
+    return null;
+}
+
+/**
+ * O plano.
+ *
+ * @param {object} op
+ * @param {object} op.roteiro   { partes: [{tipo, …}], marca: {cores, fontes, logo} }
+ * @param {string} op.modo      'video' | 'slides'
+ * @param {Array}  op.tempos    no vídeo: [{de, ate, palavras}] da voz de cada parte
+ * @param {string} op.narracao  o mp3 da voz (vídeo)
+ * @param {object} op.sons      { pop, whoosh }
+ * @param {string} op.trilha    a música de cama (vídeo)
+ * @param {object} op.imagens   { indiceDaParte: src }
+ * @param {Set}    op.iconesOk  os ícones que existem
+ */
+function comporRoteiro({ roteiro, modo = 'video', largura = 1920, altura = 1080, tempos = [], narracao = null,
+    sons = {}, trilha = null, imagens = {}, iconesOk = null }) {
+    const partes = (roteiro && roteiro.partes) || [];
+    if (!partes.length) return { ok: false, error: 'o roteiro veio sem partes.' };
+    const ruins = partes.map((p, i) => (TIPOS.includes(p.tipo) ? null : `parte ${i + 1}: tipo "${p.tipo}" não existe (use ${TIPOS.join(', ')})`)).filter(Boolean);
+    if (ruins.length) return { ok: false, error: 'o roteiro tem partes de tipo desconhecido.', problemas: ruins };
+
+    const marca = roteiro.marca || {};
+    const cor = paleta(marca);
+    const F = {
+        titulo: (marca.fontes && marca.fontes.titulo) || 'Bricolage Grotesque',
+        texto: (marca.fontes && marca.fontes.texto) || 'Inter',
+        serifa: (marca.fontes && marca.fontes.serifa) || 'Fraunces',
+    };
+    const W = largura, H = altura;
+    const M = Math.round(Math.min(W, H) * 0.08);          // a margem de segurança
+    const vid = modo === 'video';
+    const deitado = W >= H;
+    const cenas = [];
+    const efeitos = [];
+
+    // No slide tudo já entrou quando o quadro do meio é tirado (1,5 s).
+    const atraso = (t) => (vid ? t : Math.min(t, 0.9) * 0.6);
+
+    partes.forEach((p, i) => {
+        const tp = tempos[i] || {};
+        const proxDe = tempos[i + 1] ? tempos[i + 1].de : null;
+        const base = vid ? Math.max(1.6, (proxDe != null ? proxDe : (tp.ate || 0) + 0.9) - (tp.de || 0)) : 3;
+        const trans = !vid || i === 0 ? 'corte' : TRANSICOES[i % TRANSICOES.length];
+        const cruz = trans === 'corte' ? 0 : 0.35;
+        const dur = r2(base + cruz);
+        const els = [];
+        const variante = i % 2;
+
+        // ── o fundo: cor, profundidade e movimento, nunca chapado e morto ──
+        let fundo = { tipo: 'cor', valor: variante ? cor.fundo2 : cor.fundo };
+        let tinta = cor.tinta, destaque = cor.destaque, suave = cor.suave;
+        if (p.tipo === 'numero') { fundo = { tipo: 'cor', valor: cor.destaque }; tinta = cor.sobreDestaque; destaque = cor.sobreDestaque; suave = alfa(cor.sobreDestaque, 0.75); }
+        if (p.tipo !== 'imagem') {
+            const R = Math.round(Math.max(W, H) * 0.62);
+            const canto = [[W - R * 0.55, -R * 0.45], [-R * 0.45, H - R * 0.5], [W - R * 0.4, H - R * 0.55], [-R * 0.5, -R * 0.4]][i % 4];
+            els.push({
+                tipo: 'forma', forma: 'circulo', largura: R, altura: R, x: Math.round(canto[0]), y: Math.round(canto[1]),
+                cor: p.tipo === 'numero' ? cor.sobreDestaque : cor.destaque, opacidade: p.tipo === 'numero' ? 0.12 : (cor.escuro ? 0.22 : 0.16),
+                anima: {
+                    desfoque: [{ t: 0, v: Math.round(R * 0.22) }],
+                    x: [{ t: 0, v: 0 }, { t: dur, v: variante ? 60 : -60, e: 'suave' }],
+                    y: [{ t: 0, v: 0 }, { t: dur, v: variante ? -40 : 40, e: 'suave' }],
+                },
+            });
+        }
+
+        const W0 = W - 2 * M;
+        const titulo = (texto, { y, larg = W0, linhas = 2, max = H * 0.12, x = M, alinhar = 'left', de = 0.15, cor: c = tinta, destaqueUltima = true }) => {
+            const fit = caber(texto, { largura: larg, linhas, max, fonte: F.titulo });
+            const ws = String(texto).split(/\s+/);
+            els.push({
+                tipo: 'texto', texto, fonte: F.titulo, peso: 800, tamanho: fit.tamanho, cor: c, entrelinha: 1.04,
+                x, y: Math.round(y), largura: Math.round(larg), alinhamento: alinhar,
+                revelar: ws.map((_, k) => r2(atraso(de + k * 0.07))),
+                ...(destaqueUltima && ws.length > 2 ? { destaques: [ws.length - 1], corDestaque: destaque } : {}),
+            });
+            return fit.tamanho * 1.04 * fit.linhas;
+        };
+        const linhaFina = (texto, { y, larg = W0, x = M, max = H * 0.04, de = 0.5, alinhar = 'left', c = suave, linhas = 2 }) => {
+            const fit = caber(texto, { largura: larg, linhas, max, fonte: F.texto });
+            els.push({
+                tipo: 'texto', texto, fonte: F.texto, peso: 500, tamanho: fit.tamanho, cor: c, entrelinha: 1.3,
+                x, y: Math.round(y), largura: Math.round(larg), alinhamento: alinhar,
+                anima: { opacidade: [{ t: atraso(de), v: 0 }, { t: atraso(de) + 0.4, v: 1 }], y: [{ t: atraso(de), v: 18 }, { t: atraso(de) + 0.5, v: 0, e: 'saida' }] },
+            });
+            return fit.tamanho * 1.3 * fit.linhas;
+        };
+        const traco = (x, y, c = destaque, de = 0.05) => els.push({
+            tipo: 'forma', forma: 'retangulo', x, y: Math.round(y), largura: Math.round(W * 0.06), altura: Math.max(6, Math.round(H * 0.008)),
+            cor: c, origem: 'left', anima: { escalaX: [{ t: atraso(de), v: 0 }, { t: atraso(de) + 0.5, v: 1, e: 'saida' }] },
+        });
+        const logo = (x, y, alt) => { if (marca.logo) els.push({ tipo: 'imagem', src: marca.logo, x, y, altura: alt, largura: Math.round(alt * 4), ajuste: 'contain', foco: 'left center', anima: { opacidade: [{ t: atraso(0.3), v: 0 }, { t: atraso(0.3) + 0.4, v: 1 }] } }); };
+
+        switch (p.tipo) {
+            case 'abertura':
+            case 'titulo': {
+                const centro = p.tipo === 'titulo' && variante === 1;
+                const larg = centro ? W0 * 0.86 : W0 * (deitado ? 0.78 : 1);
+                const fit = caber(p.titulo || '', { largura: larg, linhas: 3, max: H * (p.tipo === 'abertura' ? 0.15 : 0.12), fonte: F.titulo });
+                const hT = fit.tamanho * 1.04 * fit.linhas;
+                const hS = p.sub ? H * 0.09 : 0;
+                let y = (H - hT - hS) / 2;
+                const x = centro ? (W - larg) / 2 : M;
+                if (p.tipo === 'abertura') logo(M, M, Math.round(H * 0.05));
+                if (!centro) traco(M, y - H * 0.05);
+                titulo(p.titulo || '', { y, larg, linhas: 3, max: fit.tamanho, x, alinhar: centro ? 'center' : 'left' });
+                if (p.sub) linhaFina(p.sub, { y: y + hT + H * 0.03, larg, x, alinhar: centro ? 'center' : 'left', de: 0.6 });
+                break;
+            }
+            case 'numero': {
+                const valor = String(p.valor == null ? '' : p.valor);
+                const m = valor.match(/^([^\d-]*)(-?[\d.,]+)(.*)$/);
+                const larg = deitado ? W0 * 0.5 : W0;
+                const fit = caber(valor, { largura: larg, linhas: 1, max: H * (deitado ? 0.5 : 0.3), fonte: F.titulo });
+                const yN = deitado ? (H - fit.tamanho) / 2 - H * 0.03 : H * 0.22;
+                const num = Number(m ? m[2].replace(/\./g, '').replace(',', '.') : NaN);
+                els.push({
+                    tipo: 'texto', texto: valor, fonte: F.titulo, peso: 800, tamanho: fit.tamanho, cor: tinta, entrelinha: 1,
+                    x: M, y: Math.round(yN), largura: Math.round(larg + M),
+                    ...(m && !Number.isNaN(num) ? { contar: { ate: num, dur: vid ? 1.3 : 0.6, antes: m[1], depois: m[3], casas: (m[2].split(',')[1] || '').length } } : {}),
+                    anima: { escala: [{ t: 0, v: 0.86 }, { t: atraso(0.5), v: 1, e: 'saida' }], opacidade: [{ t: 0, v: 0 }, { t: 0.15, v: 1 }] },
+                });
+                const xR = deitado ? M + larg + W * 0.04 : M;
+                const lR = deitado ? W - xR - M : W0;
+                const yR = deitado ? H * 0.38 : yN + fit.tamanho + H * 0.04;
+                const hR = titulo(p.rotulo || '', { y: yR, larg: lR, linhas: 3, max: H * 0.075, x: xR, de: 0.4, destaqueUltima: false });
+                if (p.sub) linhaFina(p.sub, { y: yR + hR + H * 0.03, larg: lR, x: xR, de: 0.8 });
+                break;
+            }
+            case 'lista':
+            case 'passos': {
+                const itens = (p.itens || []).slice(0, 5).map((it) => (typeof it === 'string' ? { texto: it } : it));
+                const n = itens.length || 1;
+                const colunas = deitado && n <= 4 ? n : 1;
+                const gap = W * 0.025;
+                const wCard = colunas > 1 ? (W0 - gap * (colunas - 1)) / colunas : W0;
+                /* O bloco inteiro (título + itens) fica no meio da altura: com
+                   o título no topo e os itens logo abaixo, sobrava meia tela
+                   vazia embaixo. */
+                const fT = p.titulo ? caber(p.titulo, { largura: W0, linhas: 2, max: H * 0.1, fonte: F.titulo }) : { tamanho: 0, linhas: 0 };
+                const hTit = fT.tamanho * 1.04 * fT.linhas;
+                const hCard0 = colunas > 1 ? (p.tipo === 'passos' ? H * 0.26 : H * 0.44) : H * 0.14;
+                const hItens = colunas > 1 ? hCard0 : n * hCard0 + (n - 1) * gap;
+                const bloco = hTit + (hTit ? H * 0.07 : 0) + hItens;
+                const yTit = Math.max(M, (H - bloco) / 2);
+                if (p.titulo) titulo(p.titulo, { y: yTit, linhas: 2, max: fT.tamanho });
+                const topo = yTit + hTit + (hTit ? H * 0.07 : 0);
+                const hCard = Math.min(hCard0, colunas > 1 ? H - topo - M : (H - topo - M - gap * (n - 1)) / n);
+                const dur0 = vid ? Math.max(1, (tp.ate || dur) - (tp.de || 0)) : 1;
+                itens.forEach((it, k) => {
+                    const cx = colunas > 1 ? M + k * (wCard + gap) : M;
+                    const cy = colunas > 1 ? topo : topo + k * (hCard + gap);
+                    // O item entra quando a voz chega nele (ou em cascata, no slide).
+                    const quando = atraso(vid ? 0.5 + (dur0 * 0.85 - 0.5) * (k / n) : 0.3 + k * 0.12);
+                    const entra = { opacidade: [{ t: quando, v: 0 }, { t: quando + 0.3, v: 1 }], y: [{ t: quando, v: 40 }, { t: quando + 0.45, v: 0, e: 'saida' }] };
+                    if (p.tipo === 'lista') {
+                        els.push({ tipo: 'forma', forma: 'retangulo', x: Math.round(cx), y: Math.round(cy), largura: Math.round(wCard), altura: Math.round(hCard), cor: alfa(tinta, cor.escuro ? 0.07 : 0.06), raio: Math.round(H * 0.025), anima: entra });
+                    } else if (k < n - 1 && colunas > 1) {
+                        els.push({ tipo: 'forma', forma: 'retangulo', x: Math.round(cx + H * 0.05), y: Math.round(cy + H * 0.05), largura: Math.round(wCard + gap), altura: 4, cor: alfa(destaque, 0.5), origem: 'left', anima: { escalaX: [{ t: quando, v: 0 }, { t: quando + 0.6, v: 1, e: 'suave' }] } });
+                    }
+                    const tamI = Math.round(Math.min(hCard * (colunas > 1 ? 0.28 : 0.5), H * 0.09));
+                    const ic = it.icone || iconeDoTexto(it.texto);
+                    const pad = Math.round(Math.min(wCard, hCard) * 0.14);
+                    if (p.tipo === 'passos') {
+                        els.push({ tipo: 'forma', forma: 'circulo', x: Math.round(cx + pad * 0.3), y: Math.round(cy + pad * 0.3), largura: tamI, altura: tamI, cor: destaque, anima: { ...entra, escala: [{ t: quando, v: 0 }, { t: quando + 0.35, v: 1, e: 'elastico' }] } });
+                        els.push({ tipo: 'texto', texto: String(k + 1), fonte: F.titulo, peso: 800, tamanho: Math.round(tamI * 0.5), cor: cor.sobreDestaque, x: Math.round(cx + pad * 0.3 + tamI / 2), y: Math.round(cy + pad * 0.3 + tamI / 2), ancora: 'centro', anima: entra });
+                    } else if (ic && (!iconesOk || iconesOk.has(ic))) {
+                        els.push({ tipo: 'icone', nome: ic, tamanho: tamI, x: Math.round(cx + pad), y: Math.round(cy + (colunas > 1 ? pad : (hCard - tamI) / 2)), anima: { ...entra, escala: [{ t: quando, v: 0 }, { t: quando + 0.3, v: 1.12, e: 'saida' }, { t: quando + 0.45, v: 1 }] } });
+                    }
+                    if (vid && sons.pop) efeitos.push({ t: r2((tp.de || 0) + quando), src: sons.pop, volume: 0.5 });
+                    const tx = colunas > 1 ? cx + pad : cx + pad + tamI + pad;
+                    const ty = colunas > 1 ? cy + pad + tamI + pad * 0.8 : cy + hCard / 2;
+                    const lw = colunas > 1 ? wCard - 2 * pad : wCard - (tamI + 3 * pad);
+                    const fit = caber(it.texto, { largura: lw, linhas: colunas > 1 ? 4 : 2, max: Math.min(H * 0.05, hCard * 0.3), fonte: F.texto });
+                    els.push({
+                        tipo: 'texto', texto: it.texto, fonte: F.texto, peso: 650, tamanho: fit.tamanho, cor: tinta, entrelinha: 1.2,
+                        x: Math.round(tx), y: Math.round(colunas > 1 ? ty : ty - fit.tamanho * 1.2 * fit.linhas / 2), largura: Math.round(lw), anima: entra,
+                    });
+                });
+                break;
+            }
+            case 'contraste': {
+                const larg = W0 * 0.9;
+                const f1 = caber(p.nao || '', { largura: larg, linhas: 2, max: H * 0.07, fonte: F.texto });
+                const f2 = caber(p.sim || '', { largura: larg, linhas: 3, max: H * 0.13, fonte: F.titulo });
+                const hTot = f1.tamanho * 1.2 * f1.linhas + H * 0.05 + f2.tamanho * 1.04 * f2.linhas;
+                const y1 = (H - hTot) / 2;
+                const meio = vid ? Math.max(0.8, ((tp.ate || dur) - (tp.de || 0)) * 0.45) : 0.5;
+                els.push({ tipo: 'texto', texto: p.nao || '', fonte: F.texto, peso: 600, tamanho: f1.tamanho, cor: alfa(tinta, 0.5), x: M, y: Math.round(y1), largura: Math.round(larg), entrelinha: 1.2, anima: { opacidade: [{ t: 0.1, v: 0 }, { t: 0.4, v: 1 }] } });
+                els.push({ tipo: 'forma', forma: 'retangulo', x: M, y: Math.round(y1 + f1.tamanho * 0.62), largura: Math.round(Math.min(larg, (p.nao || '').length * f1.tamanho * 0.52)), altura: Math.max(5, Math.round(f1.tamanho * 0.09)), cor: destaque, origem: 'left', anima: { escalaX: [{ t: atraso(meio - 0.3), v: 0 }, { t: atraso(meio), v: 1, e: 'saida' }] } });
+                titulo(p.sim || '', { y: y1 + f1.tamanho * 1.2 * f1.linhas + H * 0.05, larg, linhas: 3, max: f2.tamanho, de: atraso(meio) });
+                if (vid && sons.pop) efeitos.push({ t: r2((tp.de || 0) + meio), src: sons.pop, volume: 0.5 });
+                break;
+            }
+            case 'citacao': {
+                const larg = W0 * 0.84;
+                const fit = caber(p.texto || '', { largura: larg, linhas: 4, max: H * 0.085, fonte: F.serifa });
+                const hT = fit.tamanho * 1.18 * fit.linhas;
+                const y = (H - hT) / 2 + H * 0.04;
+                els.push({ tipo: 'texto', texto: '“', fonte: F.serifa, peso: 700, tamanho: Math.round(H * 0.3), cor: destaque, x: M, y: Math.round(y - H * 0.24), anima: { opacidade: [{ t: 0, v: 0 }, { t: 0.3, v: 1 }], escala: [{ t: 0, v: 0.7 }, { t: 0.5, v: 1, e: 'saida' }] } });
+                const ws = String(p.texto || '').split(/\s+/);
+                els.push({ tipo: 'texto', texto: p.texto || '', fonte: F.serifa, peso: 500, italico: true, tamanho: fit.tamanho, cor: tinta, entrelinha: 1.18, x: Math.round(M + W * 0.04), y: Math.round(y), largura: Math.round(larg), revelar: ws.map((_, k) => r2(atraso(0.2 + k * 0.09))) });
+                if (p.autor) linhaFina('— ' + p.autor, { y: y + hT + H * 0.04, x: Math.round(M + W * 0.04), larg, de: 0.9, c: destaque });
+                break;
+            }
+            case 'imagem': {
+                const src = imagens[i] || p.src;
+                if (src) {
+                    els.push({ tipo: 'imagem', src, x: 0, y: 0, largura: '100%', altura: '100%', ajuste: 'cover', anima: { escala: [{ t: 0, v: 1.12 }, { t: dur, v: 1, e: 'suave' }] } });
+                    els.push({ tipo: 'forma', forma: 'retangulo', x: 0, y: 0, largura: '100%', altura: '100%', fundo: { tipo: 'gradiente', cores: ['rgba(0,0,0,0)', 'rgba(0,0,0,0.25)', 'rgba(0,0,0,0.85)'], angulo: 180 } });
+                }
+                const larg = W0 * 0.8;
+                const fit = caber(p.titulo || '', { largura: larg, linhas: 2, max: H * 0.1, fonte: F.titulo });
+                const hT = fit.tamanho * 1.04 * fit.linhas;
+                const yT = H - M - hT - (p.sub ? H * 0.08 : 0);
+                if (p.titulo) titulo(p.titulo, { y: yT, larg, max: fit.tamanho, cor: '#FFFFFF', de: 0.3 });
+                if (p.sub) linhaFina(p.sub, { y: yT + hT + H * 0.02, larg, c: 'rgba(255,255,255,0.8)', de: 0.7 });
+                break;
+            }
+            case 'grafico': {
+                const barras = (p.barras || []).slice(0, 7);
+                const hT = p.titulo ? titulo(p.titulo, { y: M * 1.1, linhas: 2, max: H * 0.08 }) : 0;
+                const topo = M * 1.1 + hT + H * 0.12;
+                const baseY = H - M - H * 0.08;
+                const hMax = baseY - topo;
+                const maior = Math.max(1, ...barras.map((b) => Number(b.valor) || 0));
+                const gap = W0 * 0.03;
+                const wB = (W0 - gap * (barras.length - 1)) / Math.max(1, barras.length);
+                barras.forEach((b, k) => {
+                    const h = Math.max(6, hMax * (Number(b.valor) || 0) / maior);
+                    const x = M + k * (wB + gap);
+                    const q = atraso(0.4 + k * 0.12);
+                    els.push({ tipo: 'forma', forma: 'retangulo', x: Math.round(x), y: Math.round(baseY - h), largura: Math.round(wB), altura: Math.round(h), cor: k === barras.length - 1 ? destaque : alfa(tinta, 0.25), raio: Math.round(wB * 0.08), origem: 'bottom', anima: { escalaY: [{ t: q, v: 0 }, { t: q + 0.6, v: 1, e: 'saida' }] } });
+                    const fv = Math.round(Math.min(H * 0.05, wB * 0.35));
+                    els.push({ tipo: 'texto', texto: String(b.valor), fonte: F.titulo, peso: 800, tamanho: fv, cor: tinta, x: Math.round(x + wB / 2), y: Math.round(baseY - h - fv * 1.4), ancora: 'centro-x', contar: { ate: Number(b.valor) || 0, dur: 0.8 }, anima: { opacidade: [{ t: q, v: 0 }, { t: q + 0.3, v: 1 }] } });
+                    const fr = caber(b.rotulo || '', { largura: wB, linhas: 2, max: H * 0.03, fonte: F.texto });
+                    els.push({ tipo: 'texto', texto: b.rotulo || '', fonte: F.texto, peso: 500, tamanho: fr.tamanho, cor: suave, x: Math.round(x), y: Math.round(baseY + H * 0.02), largura: Math.round(wB), alinhamento: 'center' });
+                });
+                break;
+            }
+            case 'cta': {
+                const larg = W0 * 0.84;
+                const fit = caber(p.titulo || '', { largura: larg, linhas: 3, max: H * 0.12, fonte: F.titulo });
+                const hT = fit.tamanho * 1.04 * fit.linhas;
+                const temLink = Boolean(p.link || p.sub);
+                const y = (H - hT - (temLink ? H * 0.16 : 0)) / 2;
+                titulo(p.titulo || '', { y, larg, max: fit.tamanho, x: (W - larg) / 2, alinhar: 'center' });
+                if (temLink) {
+                    const txt = p.link || p.sub;
+                    const fl = caber(txt, { largura: larg * 0.7, linhas: 1, max: H * 0.045, fonte: F.texto });
+                    const wP = Math.min(larg, txt.length * fl.tamanho * 0.55 + fl.tamanho * 2.4);
+                    const hP = fl.tamanho * 2.2;
+                    const yP = y + hT + H * 0.06;
+                    const q = atraso(0.8);
+                    const entra = { opacidade: [{ t: q, v: 0 }, { t: q + 0.3, v: 1 }], escala: [{ t: q, v: 0.8 }, { t: q + 0.4, v: 1, e: 'elastico' }] };
+                    els.push({ tipo: 'forma', forma: 'retangulo', x: Math.round((W - wP) / 2), y: Math.round(yP), largura: Math.round(wP), altura: Math.round(hP), cor: destaque, raio: Math.round(hP / 2), anima: entra });
+                    els.push({ tipo: 'texto', texto: txt, fonte: F.texto, peso: 700, tamanho: fl.tamanho, cor: cor.sobreDestaque, x: Math.round(W / 2), y: Math.round(yP + hP / 2), ancora: 'centro', anima: entra });
+                    if (vid && sons.pop) efeitos.push({ t: r2((tp.de || 0) + q), src: sons.pop, volume: 0.55 });
+                }
+                logo(Math.round(W / 2 - H * 0.1), Math.round(H - M - H * 0.05), Math.round(H * 0.05));
+                break;
+            }
+            default: break;
+        }
+
+        const cena = { duracao: dur, fundo, elementos: els, transicao: { tipo: trans, duracao: cruz } };
+        if (vid) cena.camera = { zoom: variante ? [{ t: 0, v: 1.04 }, { t: dur, v: 1, e: 'suave' }] : [{ t: 0, v: 1 }, { t: dur, v: 1.04, e: 'suave' }] };
+        cenas.push(cena);
+        if (vid && i > 0 && sons.whoosh) efeitos.push({ t: r2(Math.max(0, (tp.de || 0) - 0.15)), src: sons.whoosh, volume: 0.4 });
+    });
+
+    const audio = {};
+    if (vid && narracao) audio.narracao = narracao;
+    if (vid && trilha) audio.trilha = { src: trilha, volume: 0.12, loop: true };
+    if (vid && efeitos.length) audio.efeitos = efeitos;
+    return {
+        ok: true,
+        plano: { formato: { largura: W, altura: H, fps: 30 }, fundoGeral: cor.fundo, cenas, ...(Object.keys(audio).length ? { audio } : {}) },
+        resumo: { cenas: cenas.length, efeitos: efeitos.length, musica: Boolean(audio.trilha), voz: Boolean(audio.narracao) },
+    };
+}
+
+module.exports = { comporRoteiro, caber, paleta, falaDe, registroDe, iconesDoRoteiro, TIPOS };