primocode 9.8.0-beta.9 → 9.8.0

package/lib/estudio/composicao.js

@@ -0,0 +1,470 @@
+/**
+ * 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');
+    let destaque = c.destaque || '#FF6A3D';
+    /* A cor da marca precisa aparecer no fundo: o azul #1e3fae da Paris Group
+       sumia no fundo escuro (medido em 25/09). Pouco contraste, e o destaque
+       clareia (no escuro) ou escurece (no claro) até aparecer. */
+    for (let k = 0; k < 6 && Math.abs(luz(destaque) - luz(fundo)) < 0.38; k++) {
+        destaque = misturar(destaque, escuro ? '#FFFFFF' : '#000000', 0.18);
+    }
+    return {
+        fundo, tinta, destaque, escuro, marca: c.destaque || destaque,
+        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. */
+// Com folga: medido em 25/09, 0,52 deixava "Fundadores" quebrar no meio no card.
+const LARGURA = { condensada: 0.46, display: 0.6, texto: 0.58, serifa: 0.54 };
+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 t of [`${p.titulo || ''} ${p.sub || ''}`, p.sim]) { const ic = iconeDoTexto(t); if (ic) nomes.add(ic); }
+        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, fundos = {} }) {
+    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;
+        // A cena fica no ar até a SEGUINTE terminar de entrar (o cruzamento é dela).
+        const cruzProx = vid && i + 1 < partes.length ? 0.35 : 0;
+        const dur = r2(base + cruzProx);
+        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); }
+        /* A FOTO DA MARCA DE FUNDO: a cena de texto ganha a sala de verdade
+           atrás, com um véu da cor do fundo para o texto continuar legível. */
+        const fotoFundo = fundos[i];
+        if (fotoFundo && p.tipo !== 'imagem') {
+            const ehV = fotoFundo.tipo === 'video';
+            els.push({ tipo: ehV ? 'video' : 'imagem', src: fotoFundo.src, ...(ehV ? { volume: 0 } : {}), x: 0, y: 0, largura: '100%', altura: '100%', ajuste: 'cover', foco: 'center 28%',
+                anima: { escala: [{ t: 0, v: variante ? 1.14 : 1.02 }, { t: dur, v: variante ? 1.02 : 1.14, e: 'suave' }] } });
+            els.push({ tipo: 'forma', forma: 'retangulo', x: 0, y: 0, largura: '100%', altura: '100%',
+                fundo: { tipo: 'gradiente', cores: [alfa(cor.fundo, 0.93), alfa(cor.fundo, 0.72), alfa(cor.fundo, 0.55)], angulo: 90 } });
+        } else 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]),
+                // O brilho alterna entre o destaque e a cor de apoio: as duas cores da marca aparecem.
+                cor: p.tipo === 'numero' ? cor.sobreDestaque : (variante && marca.cores && marca.cores.apoio ? cor.apoio : cor.destaque), opacidade: p.tipo === 'numero' ? 0.12 : (cor.escuro ? 0.26 : 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' }] },
+        });
+        /* O ÍCONE DA IDEIA: um emoji grande, que salta e depois flutua, do
+           lado livre da cena — o que dá vida a cena de texto sem virar enfeite. */
+        const iconeDaIdeia = (texto, x, y, tam, de = 0.35) => {
+            const ic = iconeDoTexto(texto);
+            if (!ic || (iconesOk && !iconesOk.has(ic))) return false;
+            const q = atraso(de);
+            const t2 = r2(Math.max(q + 0.6, dur * 0.55)), t3 = r2(Math.max(t2 + 0.3, dur));
+            els.push({ tipo: 'icone', nome: ic, tamanho: Math.round(tam), x: Math.round(x), y: Math.round(y), ancora: 'centro',
+                anima: {
+                    escala: [{ t: q, v: 0 }, { t: q + 0.25, v: 1.18, e: 'saida' }, { t: q + 0.42, v: 1, e: 'suave' }],
+                    rotacao: [{ t: q, v: -18 }, { t: q + 0.42, v: 0, e: 'saida' }, { t: t3, v: 6, e: 'suave' }],
+                    y: [{ t: q + 0.42, v: 0 }, { t: t2, v: -16, e: 'suave' }, { t: t3, v: 4, e: 'suave' }],
+                } });
+            if (vid && sons.pop) efeitos.push({ t: r2((tp.de || 0) + q), src: sons.pop, volume: 0.55 });
+            return true;
+        };
+        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 });
+                if (!centro && deitado) iconeDaIdeia(`${p.titulo || ''} ${p.sub || ''}`, W - M - W * 0.09, H * 0.5, H * 0.2, 0.5);
+                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 * (deitado ? 0.14 : 0.13);
+                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;
+                /* Um tamanho de letra para TODOS os itens: o do mais apertado. Cada
+                   item com o seu tamanho deixava um card com a letra maior que os
+                   outros, e esse texto saía do card (medido em 25/09). */
+                const padG = Math.round(Math.min(wCard, hCard) * 0.14);
+                const tamIG = Math.round(Math.min(hCard * (colunas > 1 ? 0.28 : 0.5), H * 0.09));
+                const lwG = colunas > 1 ? wCard - 2 * padG : wCard - (tamIG + 3 * padG);
+                // No vertical a linha é estreita: 3 linhas por item, para a letra caber grande.
+                const linhasG = colunas > 1 ? 4 : (deitado ? 2 : 3);
+                const hTexto = colunas > 1 ? hCard - (padG * 1.8 + tamIG + padG) : hCard - padG;
+                const maxItem = deitado ? Math.min(H * 0.05, hCard * 0.3) : Math.min(W * 0.062, hCard * 0.26);
+                const fits = itens.map((it) => caber(it.texto, { largura: lwG, linhas: linhasG, max: maxItem, fonte: F.texto }));
+                let tamItens = Math.min(...fits.map((f) => f.tamanho));
+                // Só na lista o texto mora DENTRO do card: ali a altura também manda.
+                if (p.tipo === 'lista') {
+                    const linhasReais = Math.max(...itens.map((it) => caber(it.texto, { largura: lwG, linhas: linhasG, max: tamItens, min: tamItens, fonte: F.texto }).linhas));
+                    tamItens = Math.min(tamItens, Math.floor(hTexto / (1.2 * linhasReais)));
+                }
+                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);
+                    // Entra de baixo e depois respira: nada fica parado como slide.
+                    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' }, { t: Math.max(quando + 0.5, dur), v: k % 2 ? -8 : 8, e: 'suave' }] };
+                    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 fit0 = caber(it.texto, { largura: lw, linhas: linhasG, max: tamItens, min: Math.min(18, tamItens), fonte: F.texto });
+                    const fit = { tamanho: Math.min(fit0.tamanho, tamItens), linhas: fit0.linhas };
+                    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 (deitado) iconeDaIdeia(p.sim || '', W - M - W * 0.06, H * 0.22, H * 0.14, meio + 0.3);
+                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 m = imagens[i] || p.src;
+                const src = m && typeof m === 'object' ? m.src : m;
+                if (src) {
+                    const ehVideo = m && typeof m === 'object' && m.tipo === 'video';
+                    // O enquadramento puxa para cima: é onde ficam os rostos.
+                    els.push({ tipo: ehVideo ? 'video' : 'imagem', src, ...(ehVideo ? { volume: 0 } : {}), x: 0, y: 0, largura: '100%', altura: '100%', ajuste: 'cover', foco: 'center 28%', 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 * (deitado ? 0.8 : 1);
+                const fit = caber(p.titulo || '', { largura: larg, linhas: 2, max: H * (deitado ? 0.1 : 0.06), fonte: F.titulo });
+                const hT = fit.tamanho * 1.04 * fit.linhas;
+                /* Vídeo da marca (depoimento, bastidor) costuma ter o nome da
+                   pessoa gravado embaixo: o título vai para o alto, com o véu
+                   de cima, para não escrever por cima dele. */
+                const noTopo = Boolean(m && typeof m === 'object' && m.tipo === 'video');
+                if (noTopo) els.push({ tipo: 'forma', forma: 'retangulo', x: 0, y: 0, largura: '100%', altura: '100%', fundo: { tipo: 'gradiente', cores: ['rgba(0,0,0,0.8)', 'rgba(0,0,0,0.2)', 'rgba(0,0,0,0)'], angulo: 180 } });
+                const yT = noTopo ? M * 1.2 : 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 };