primocode 9.10.0 → 10.0.0

package/lib/estudio/vox.js

@@ -0,0 +1,385 @@
+/**
+ * vox.js — o estilo VOX: explainer editorial, narração ilustrada.
+ *
+ *   "O vídeo é uma narração ilustrada. Cada elemento existe porque uma
+ *    palavra pediu — e entra no instante exato em que ela é dita."
+ *    — guia MOTION VOX STYLE com Remotion
+ *
+ * Uma cena por parte, com CORTE SECO no beat. Cada cena é composta como
+ * revista, não como slide:
+ *
+ *   · 30 a 40% do quadro é fundo puro, e a banda de cima nunca é invadida;
+ *   · uma âncora grande (30 a 40% da largura), o resto três vezes menor;
+ *   · UM acento, em no máximo três pontos; o resto é tinta sobre papel;
+ *   · tudo imprime no papel: sombra de contato, tinta, grão e vinheta;
+ *   · a câmera conta a frase: dolly do perto para o longe na abertura,
+ *     empurrão no clímax, e acelera antes do corte;
+ *   · parallax como consequência da câmera: quatro planos (0,12 · 0,40 ·
+ *     0,55 · 1,25), com o desfoque da lente em cada um.
+ *
+ * Cada tipo de parte vira um dos oito dispositivos tipográficos do kit
+ * (kit/vox.jsx):
+ *
+ *   abertura  cartão-espécime (termo curto) ou highlight na letra, no escuro
+ *   titulo    highlight na letra + source tag
+ *   numero    palavra ancorada gigante (o número) + o rótulo carimbando
+ *   lista     lista com travessão (o anterior apaga para cinza)
+ *   passos    idem, numerada 01 — 02 — 03
+ *   contraste o "não" riscado à caneta, o "sim" carimba no acento
+ *   citacao   o documento lido em cascata, marca-texto e círculo
+ *   imagem    a foto na mesa, a pill branca e a linha-guia
+ *   grafico   as barras em tinta, a maior circulada
+ *   cta       texto-textura de fundo, a chamada carimbada e a pill
+ *   logo      a marca e o nome em espécime
+ *   cores     os cartões de cor sobre o papel
+ *   produto   o cartão do produto sobre a mesa
+ *
+ * Puro: roteiro, tempos da voz e arquivos entram; o plano sai.
+ */
+
+'use strict';
+
+const { caber } = require('./composicao.js');
+const { misturarCor, ehCor } = require('./morfar.js');
+const { tempoDasPartes, gatilhos, palavrasNaCena, volumesDaTrilha, r2 } = require('./ritmo.js');
+
+const FPS = 30;
+const k = (t, v, e) => (e ? { t: r2(t), v, e } : { t: r2(t), v });
+const luz = (hex) => {
+    const h = String(hex || '').replace('#', '');
+    const n = h.length === 3 ? h.split('').map((c) => c + c).join('') : h.slice(0, 6);
+    const [r, g, b] = [0, 2, 4].map((i) => parseInt(n.slice(i, i + 2), 16) || 0);
+    return (0.299 * r + 0.587 * g + 0.114 * b) / 255;
+};
+const itensDe = (p) => (p.itens || []).map((i) => (typeof i === 'string' ? i : i.texto || i.titulo || '')).filter(Boolean);
+const semAcento = (w) => String(w || '').normalize('NFD').replace(/[̀-ͯ]/g, '').toLowerCase().replace(/[^a-z0-9]/g, '');
+const PEQUENAS = new Set(['a', 'o', 'as', 'os', 'um', 'uma', 'de', 'do', 'da', 'dos', 'das', 'e', 'em', 'no', 'na', 'nos', 'nas', 'que', 'se', 'por', 'pra', 'para', 'com', 'ao', 'the', 'of', 'to', 'and']);
+
+/** A palavra-tese de uma frase: a pedida, ou a mais longa das últimas. */
+function tese(frase, pedida) {
+    const ws = String(frase || '').split(/\s+/).filter(Boolean);
+    if (pedida && ws.some((w) => semAcento(w) === semAcento(pedida))) return pedida;
+    let melhor = '';
+    ws.forEach((w, i) => { const c = semAcento(w); if (!PEQUENAS.has(c) && c.length + i * 0.6 >= semAcento(melhor).length) melhor = w; });
+    return melhor.replace(/[.,;:!?]+$/, '');
+}
+
+/** Quebra um texto em linhas de até `n` caracteres, palavra por palavra. */
+function quebrar(texto, n) {
+    const linhas = [];
+    let atual = '';
+    for (const w of String(texto || '').split(/\s+/).filter(Boolean)) {
+        if (atual && (atual + ' ' + w).length > n) { linhas.push(atual); atual = w; } else atual = atual ? atual + ' ' + w : w;
+    }
+    if (atual) linhas.push(atual);
+    return linhas;
+}
+
+/** "Termo — definição" (ou "termo: definição") vira {termo, def}. */
+function termoDef(t) {
+    const m = String(t).match(/^(.{1,40}?)\s*(?:—|–|-|:)\s+(.+)$/);
+    return m ? { termo: m[1], def: m[2] } : { termo: String(t) };
+}
+
+/**
+ * @param {object} op
+ * @param {object} op.roteiro   { marca, partes: [{tipo, titulo, sub, itens, valor, rotulo, sim, nao, autor, destaque, fonte, barras, link, src}] }
+ * @param {Array}  op.tempos    [{de, ate, palavras}] por parte (da narração)
+ * @param {object} op.imagens   { indiceDaParte: {src, tipo} }
+ */
+function montarVox({ roteiro, largura = 1920, altura = 1080, tempos = [], narracao = null, sons = {}, trilha = null, imagens = {} }) {
+    const partes = (roteiro && roteiro.partes) || [];
+    if (!partes.length) return { ok: false, error: 'o roteiro veio sem partes.' };
+    const W = largura, H = altura, deitado = W >= H;
+    const b = Math.min(W, H) / 1080;
+    const M = Math.round(Math.min(W, H) * 0.075);
+    const TOPO = Math.round(H * (deitado ? 0.17 : 0.2));          // a banda intocada
+
+    // ── a paleta: papel, tinta e UM acento ─────────────────────────────
+    const marca = roteiro.marca || {};
+    const cores = marca.cores || {};
+    const PAPEL = ehCor(cores.fundo) && luz(cores.fundo) > 0.78 ? cores.fundo : '#ece8df';
+    const TINTA = ehCor(cores.tinta) && luz(cores.tinta) < 0.3 ? cores.tinta : '#171614';
+    let ACENTO = ehCor(cores.destaque) ? cores.destaque : '#d23a2a';
+    for (let i = 0; i < 5 && luz(ACENTO) > 0.62; i++) ACENTO = misturarCor(ACENTO, '#000000', 0.2);
+    const CINZA = misturarCor(PAPEL, TINTA, 0.3);
+    const ESCURO = '#121110';
+    const F = {
+        titulo: (marca.fontes && marca.fontes.titulo) || 'Inter Tight',
+        texto: (marca.fontes && marca.fontes.texto) || 'Inter Tight',
+        mono: 'JetBrains Mono', serifa: 'Newsreader',
+    };
+    const base = { fonte: F.titulo, fonteMono: F.mono, cor: TINTA, corAcento: ACENTO };
+
+    // ── o tempo ────────────────────────────────────────────────────────
+    const leitura = (p) => 1.6 + 0.3 * String([p.titulo, p.sub, p.valor, p.rotulo, p.nao, p.sim, ...itensDe(p)].filter(Boolean).join(' ')).split(/\s+/).length;
+    const { ini, dur, total, temVoz } = tempoDasPartes(partes, tempos, { semVoz: leitura });
+    const efeitos = [];
+    const som = (t, nome, volume) => { if (sons[nome]) efeitos.push({ t: r2(Math.max(0, t)), src: sons[nome], volume }); };
+
+    // ── as quatro profundidades, e o que mora em cada uma ──────────────
+    const CAMADAS = [{ p: 0.12, desfoque: 2.2 }, { p: 0.4, desfoque: 0.9 }, { p: 0.55, desfoque: 0, sujeito: true }, { p: 1.25, desfoque: 3.4 }];
+    const papel = (escuro) => (escuro
+        ? { tipo: 'forma', forma: 'retangulo', x: '-8%', y: '-8%', largura: '116%', altura: '116%', camada: 0,
+            fundo: { tipo: 'gradiente', radial: true, centro: '38% 45%', cores: ['#2a2723', ESCURO] } }
+        : { tipo: 'kit', peca: 'papel', cor: PAPEL, sobra: 1.16, camada: 0 });
+    /* A câmera conta a frase. Dolly do perto para o longe na abertura (3,4 →
+       1,0), empurrão no clímax, e nos outros um avanço lento; nos últimos
+       quadros ela ACELERA — é o que vende o corte. Bezier longa, nunca mola. */
+    const camera = (d, modo, i) => {
+        const lado = i % 2 ? 1 : -1;
+        const fimLento = Math.max(0.4, d - 0.3);
+        if (modo === 'abertura') {
+            return { zoom: [k(0, 3.4), k(Math.min(1.8, d * 0.55), 1.0, 'camera'), k(fimLento, 1.03, 'camera'), k(d, 1.06, 'acelera')],
+                x: [k(0, 0), k(d, lado * 10 * b, 'camera')] };
+        }
+        const z1 = modo === 'climax' ? 1.14 : 1.045;
+        return { zoom: [k(0, 1.0), k(fimLento, z1, 'camera'), k(d, z1 + 0.035, 'acelera')],
+            x: [k(0, -lado * 14 * b), k(d, lado * 14 * b, 'camera')],
+            rotacao: [k(0, -lado * 0.3), k(d, lado * 0.3, 'camera')] };
+    };
+
+    /* O CORTE NO BEAT dentro da parte longa: passou de 5 s, a câmera pula de
+       enquadramento numa palavra do meio (dois quadros-chave a 1 quadro). */
+    const corteInterno = (cam, d, tempo, inicio) => {
+        if (d <= 5.2) return cam;
+        const ws = palavrasNaCena(tempo, inicio).filter((w) => w.t > d * 0.4 && w.t < d * 0.7);
+        const tc = ws.length ? ws[0].t : r2(d * 0.5);
+        const z = (cam.zoom || []).filter((q) => q.t < tc);
+        const zAntes = z.length ? z[z.length - 1].v : 1;
+        const zFim = cam.zoom[cam.zoom.length - 1].v;
+        cam.zoom = [...z, k(tc - 1 / FPS, zAntes), k(tc, zAntes + 0.09), k(d, zFim + 0.09, 'camera')];
+        return cam;
+    };
+
+    // ── as partes ──────────────────────────────────────────────────────
+    /* Em pé a âncora ocupa a largura toda, então ela mede um pouco menos: o
+       empurrão da câmera (até 8%) não pode levar a última letra para fora. */
+    const larguraAncora = deitado ? W * 0.64 : (W - 2 * M) * 0.9;
+    const cenas = partes.map((p, i) => {
+        const d = dur[i];
+        const t0 = ini[i];
+        const tp = tempos[i];
+        const g = (textos, op) => gatilhos(textos, tp, t0, d, op);
+        const esquerda = i % 2 === 0 || !deitado;
+        const xA = esquerda ? M : W - M - larguraAncora;   // a âncora de um lado, o vazio do outro
+        const els = [];
+        let modo = 'normal', escuro = false, origem = null;
+        const titulo = p.titulo || p.texto || '';
+        const semMidia = p.tipo === 'imagem' && !(imagens[i] || p.src);
+        const tipo = semMidia ? 'titulo' : p.tipo;
+        const fonteTag = (texto, y, t, extra = {}) => els.push({ tipo: 'kit', peca: 'fonte', texto, x: xA, y: r2(y), t, tamanho: r2(24 * b), ...base, cor: misturarCor(TINTA, PAPEL, 0.35), ...extra });
+
+        switch (tipo) {
+            case 'abertura': {
+                escuro = true; modo = 'abertura';
+                const curto = titulo.replace(/\s+/g, '').length <= 12 && titulo.split(/\s+/).length <= 2;
+                if (curto) {
+                    const n = titulo.length;
+                    const tam = Math.min(170 * b, (W - 2 * M) / (n * 1.06));
+                    const [tt] = g([titulo]);
+                    els.push({ tipo: 'kit', peca: 'especime', termo: titulo, sub: p.sub || '', x: W / 2, y: H / 2, t: Math.min(0.35, tt), tamanho: r2(tam),
+                        ...base, cor: '#f2eee6', corSub: '#9d968a' });
+                    origem = [W / 2 - (n * tam * 1.02) / 2 + tam * 0.4, H / 2 - (p.sub ? tam * 0.34 : 0)];
+                } else {
+                    const fit = caber(titulo, { largura: W - 2 * M, linhas: 3, max: 150 * b, min: 44 * b, fonte: F.titulo });
+                    const alt = fit.linhas * fit.tamanho * 1.04;
+                    els.push({ tipo: 'kit', peca: 'letra', texto: titulo, destaque: tese(titulo, p.destaque), x: M, y: r2(H * 0.55 - alt / 2), largura: W - 2 * M,
+                        tamanho: fit.tamanho, t: 0.3, tDestaque: g([tese(titulo, p.destaque)])[0], ...base, cor: '#f2eee6' });
+                    if (p.sub) fonteTag(p.sub, H * 0.55 + alt / 2 + 40 * b, 1.0, { cor: '#9d968a' });
+                    origem = [M + 40 * b, H * 0.55];
+                }
+                som(t0 + 0.3, 'toque', 0.3);
+                break;
+            }
+            case 'numero': {
+                modo = 'climax';
+                const v = String(p.valor || titulo);
+                const tamN = caber(v, { largura: larguraAncora * 0.9, linhas: 1, max: 400 * b, min: 110 * b, fonte: F.titulo }).tamanho;
+                const rot = p.rotulo || (p.valor ? titulo : '');
+                const [tv, tr] = g([v, rot || v]);
+                const yN = H * 0.62 - tamN;
+                els.push({ tipo: 'kit', peca: 'palavra', palavras: [{ texto: v, t: tv, acento: true, peso: 800 }], x: xA, y: r2(yN), tamanho: tamN, ...base, sublinhar: false });
+                let yFim = yN + tamN * 1.02;
+                if (rot) {
+                    const fr = caber(rot, { largura: larguraAncora, linhas: 2, max: 76 * b, min: 34 * b, fonte: F.texto });
+                    const tamR = fr.tamanho;
+                    yFim += fr.linhas * tamR * 1.08;
+                    els.push({ tipo: 'kit', peca: 'palavra', x: xA, y: r2(yN + tamN * 1.02), largura: larguraAncora, tamanho: tamR, ...base, sublinhar: false,
+                        palavras: rot.split(/\s+/).map((w, j) => ({ texto: w, t: r2(tr + j * 4 / FPS), peso: PEQUENAS.has(semAcento(w)) ? 300 : 500 })) });
+                }
+                // A fonte vem DEPOIS do rótulo, na altura que ele de fato ocupa (em pé ele quebra em duas linhas).
+                if (p.sub || p.fonte) fonteTag(p.fonte || p.sub, yFim + 36 * b, Math.min(d - 0.8, tr + 0.6));
+                origem = [xA + tamN, yN + tamN / 2];
+                som(t0 + tv, 'toque', 0.35);
+                break;
+            }
+            case 'lista': case 'passos': case 'contraste': {
+                let itens;
+                if (tipo === 'contraste') itens = [{ termo: p.nao || '—', riscar: true }, { termo: p.sim || titulo }];
+                else itens = itensDe(p).slice(0, 5).map((x, j) => (tipo === 'passos' ? { termo: String(j + 1).padStart(2, '0'), def: x } : termoDef(x)));
+                const maior = itens.reduce((a, x) => ((x.termo + (x.def ? ' — ' + x.def : '')).length > a.length ? x.termo + (x.def ? ' — ' + x.def : '') : a), '');
+                // Uma linha por item quando cabe grande; senão, duas.
+                const umaLinha = caber(maior, { largura: larguraAncora * (deitado ? 1.05 : 1), linhas: 1, max: (tipo === 'contraste' ? 170 : itens.length > 3 ? 80 : 96) * b, min: 30 * b, fonte: F.titulo });
+                const tam = umaLinha.tamanho >= 58 * b || tipo === 'contraste' ? umaLinha.tamanho
+                    : caber(maior, { largura: larguraAncora * (deitado ? 1.05 : 1), linhas: 2, max: 80 * b, min: 30 * b, fonte: F.titulo }).tamanho;
+                const ts = g(itens.map((x) => (tipo === 'passos' ? x.def : x.termo)), { t0: titulo && tipo !== 'contraste' ? 0.6 : 0.3 });
+                itens.forEach((x, j) => { x.t = ts[j]; });
+                const linhasEst = itens.reduce((n, x) => n + Math.ceil(((x.termo + (x.def ? ' — ' + x.def : '')).length * tam * 0.56) / larguraAncora), 0);
+                const alt = linhasEst * tam * 1.08 + itens.length * tam * 0.34;
+                const y = Math.max(TOPO + 60 * b, H * 0.58 - alt / 2);
+                if (titulo && tipo !== 'contraste') fonteTag(titulo, y - 70 * b, 0.15);
+                els.push({ tipo: 'kit', peca: 'lista', itens, x: xA, y: r2(y), largura: larguraAncora, tamanho: tam, ...base, corVelha: CINZA });
+                origem = [xA + 60 * b, y + alt / 2];
+                itens.forEach((x) => som(t0 + x.t, 'toque', 0.22));
+                if (tipo === 'contraste') som(t0 + itens[0].t + 0.35, 'sopro', 0.18);
+                break;
+            }
+            case 'citacao': {
+                const frase = `“${titulo}”`;
+                const porLinha = deitado ? 30 : 22;
+                const linhas = quebrar(frase, porLinha).slice(0, 6);
+                const alvo = semAcento(tese(titulo, p.destaque));
+                const marca = Math.max(0, linhas.findIndex((l) => l.split(/\s+/).some((w) => semAcento(w) === alvo)));
+                const docW = deitado ? W * 0.56 : W - 2 * M;
+                const tam = Math.min(64 * b, docW / (porLinha * 0.5 + 2.4));
+                const docH = linhas.length * tam * 1.36 + tam * 3.4;
+                const x = esquerda ? M + 20 * b : W - M - docW - 20 * b;
+                const y = Math.max(TOPO, H * 0.52 - docH / 2);
+                const [tm] = g([linhas[marca]]);
+                els.push({ tipo: 'kit', peca: 'marcatexto', linhas, marca, tMarca: Math.max(0.9, tm), x: r2(x), y: r2(y), largura: r2(docW), tamanho: r2(tam), t: 0.25,
+                    titulo: p.fonte || 'citação', fonte: F.serifa, fonteMono: F.mono, corAcento: ACENTO, fundo: misturarCor(PAPEL, '#ffffff', 0.55), rotacao: esquerda ? -0.7 : 0.6 });
+                if (p.autor) els.push({ tipo: 'kit', peca: 'fonte', texto: '— ' + p.autor, x: r2(esquerda ? x + docW + 50 * b : x - 50 * b), y: r2(y + docH - 40 * b),
+                    alinhamento: esquerda ? 'left' : 'right', t: Math.min(d - 0.8, Math.max(1.4, tm + 0.8)), tamanho: r2(26 * b), ...base, cor: misturarCor(TINTA, PAPEL, 0.3) });
+                origem = [x + docW / 2, y + (marca + 2) * tam * 1.36];
+                som(t0 + Math.max(0.9, tm), 'sopro', 0.15);
+                break;
+            }
+            case 'imagem': {
+                const m = imagens[i] || { src: p.src, tipo: 'imagem' };
+                const iw = deitado ? W * 0.5 : W - 2 * M, ih = iw * (deitado ? 0.62 : 0.75);
+                const ix = deitado ? (esquerda ? W - M - iw : M) : M, iy = deitado ? Math.max(TOPO, H * 0.52 - ih / 2) : TOPO + 40 * b;
+                els.push({ tipo: m.tipo === 'video' ? 'video' : 'imagem', src: m.src, ...(m.tipo === 'video' ? { volume: 0 } : {}), x: r2(ix), y: r2(iy), largura: r2(iw), altura: r2(ih),
+                    ajuste: 'cover', raio: 4, sombra: '0 1px 1px rgba(20,16,10,0.25), 0 20px 40px -14px rgba(20,16,10,0.45)',
+                    anima: { rotacao: [k(0, esquerda ? 0.8 : -0.8)], escala: [k(0, 1.0), k(d, 1.025, 'camera')] } });
+                if (titulo) {
+                    const tamP = Math.min(50 * b, (deitado ? W * 0.36 : W - 2 * M) / (titulo.length * 0.72));
+                    const px = deitado ? (esquerda ? ix - 40 * b - titulo.length * tamP * 0.36 : ix + iw + 40 * b + titulo.length * tamP * 0.36) : W / 2;
+                    const py = deitado ? iy + ih * 0.78 : iy + ih + 150 * b;
+                    const pxOk = Math.min(W - M - titulo.length * tamP * 0.4, Math.max(M + titulo.length * tamP * 0.4, px));
+                    els.push({ tipo: 'kit', peca: 'pilula', texto: titulo, sub: p.sub || '', x: r2(pxOk), y: r2(py), alvo: { x: r2(ix + iw * (esquerda ? 0.3 : 0.7)), y: r2(iy + ih * 0.42) },
+                        t: g([titulo])[0], tamanho: r2(tamP), ...base, cor: '#ffffff', corTexto: TINTA, corLinha: TINTA });
+                }
+                if (p.fonte) els.push({ tipo: 'kit', peca: 'fonte', texto: p.fonte, x: r2(ix), y: r2(iy + ih + 24 * b), t: 0.8, tamanho: r2(18 * b), ...base, cor: misturarCor(TINTA, PAPEL, 0.35) });
+                origem = [ix + iw / 2, iy + ih / 2];
+                break;
+            }
+            case 'grafico': {
+                const barras = (p.barras || itensDe(p).map((x, j) => ({ rotulo: x, valor: itensDe(p).length - j }))).slice(0, 6);
+                const gw = deitado ? W * 0.6 : W - 2 * M;
+                const tamB = Math.min(44 * b, (H * 0.46) / (barras.length * 2.2));
+                const altB = barras.length * tamB * 1.5 * 1.45;
+                const y = Math.max(TOPO + 130 * b, H * 0.6 - altB / 2);
+                if (titulo) {
+                    const tt = caber(titulo, { largura: gw, linhas: 2, max: 96 * b, min: 34 * b, fonte: F.titulo }).tamanho;
+                    els.push({ tipo: 'kit', peca: 'letra', texto: titulo, destaque: tese(titulo, p.destaque), x: xA, y: r2(y - tt * 1.1 * Math.min(2, Math.ceil(titulo.length * tt * 0.56 / gw)) - 40 * b),
+                        largura: r2(gw), tamanho: tt, t: 0.2, ...base });
+                }
+                els.push({ tipo: 'kit', peca: 'barras', barras, x: xA, y: r2(y), largura: r2(gw), tamanho: r2(tamB), t: g([String(barras[0].rotulo)])[0] + 0.1, ...base });
+                if (p.fonte) fonteTag(p.fonte, y + altB + 20 * b, 1.6);
+                origem = [xA + gw / 2, y + altB / 2];
+                break;
+            }
+            case 'cta': {
+                modo = 'climax';
+                const fundo = p.link || marca.nome || titulo;
+                els.push({ tipo: 'kit', peca: 'textura', texto: fundo, largura: W * 1.16, altura: H * 1.16, x: -W * 0.08, y: -H * 0.08, tamanho: r2((deitado ? 96 : 84) * b),
+                    fonte: F.titulo, cor: TINTA, t: 0.05, camada: 1, velocidade: 30 });
+                const fit = caber(titulo, { largura: W - 2 * M, linhas: 2, max: 150 * b, min: 44 * b, fonte: F.titulo });
+                const alt = fit.linhas * fit.tamanho * 1.02;
+                const ts = g(titulo.split(/\s+/).slice(0, 1));
+                const alvo = semAcento(tese(titulo, p.destaque));
+                els.push({ tipo: 'forma', forma: 'retangulo', x: 0, y: r2(H / 2 - alt / 2 - 50 * b), largura: '100%', altura: r2(alt + 100 * b), cor: PAPEL, opacidade: 0.94, camada: 1 });
+                els.push({ tipo: 'kit', peca: 'palavra', x: W / 2, y: r2(H / 2 - alt / 2), largura: W - 2 * M, tamanho: fit.tamanho, alinhamento: 'center', ...base,
+                    palavras: titulo.split(/\s+/).map((w, j) => ({ texto: w, t: r2(ts[0] + j * 5 / FPS), acento: semAcento(w) === alvo, peso: PEQUENAS.has(semAcento(w)) ? 400 : 700 })) });
+                if (p.link) els.push({ tipo: 'kit', peca: 'pilula', texto: p.link, x: W / 2, y: r2(H / 2 + alt / 2 + 110 * b), alvo: { x: W / 2, y: r2(H / 2 + alt / 2 + 20 * b) },
+                    t: Math.min(d - 0.9, ts[0] + 0.7), tamanho: r2(34 * b), ...base, cor: '#ffffff', corTexto: TINTA, corLinha: TINTA });
+                origem = [W / 2, H / 2];
+                som(t0 + ts[0], 'toque', 0.35);
+                break;
+            }
+            case 'logo': {
+                escuro = true; modo = 'abertura';
+                const nome = p.titulo || marca.nome || '';
+                const tam = Math.min(130 * b, (W - 2 * M) / (Math.max(4, nome.length) * 1.06));
+                if (marca.logo) els.push({ tipo: 'imagem', src: marca.logo, x: W / 2, y: r2(H / 2 - tam * 1.5), largura: r2(tam * 1.4), altura: r2(tam * 1.4), ancora: 'centro', ajuste: 'contain', de: 0.1 });
+                els.push({ tipo: 'kit', peca: 'especime', termo: nome, sub: p.sub || '', x: W / 2, y: r2(H / 2 + (marca.logo ? tam * 0.4 : 0)), t: 0.4, tamanho: r2(tam), ...base, cor: '#f2eee6', corSub: '#9d968a' });
+                origem = [W / 2, H / 2];
+                break;
+            }
+            case 'cores': {
+                const lista = (p.cores || [cores.fundo, cores.destaque, cores.tinta, cores.apoio].filter(ehCor).map((hex, j) => ({ nome: ['Fundo', 'Destaque', 'Tinta', 'Apoio'][j], hex })))
+                    .slice(0, 5).map((c) => (typeof c === 'string' ? { nome: c, hex: c } : c));
+                if (titulo) fonteTag(titulo, TOPO, 0.2);
+                els.push({ tipo: 'kit', peca: 'cores', cores: lista.length ? lista : [{ nome: 'Tinta', hex: TINTA }, { nome: 'Papel', hex: PAPEL }, { nome: 'Acento', hex: ACENTO }],
+                    x: W / 2, y: r2(H * 0.56), largura: r2((deitado ? 300 : 280) * b), raioX: r2(deitado ? W * 0.3 : W * 0.28), raioY: r2(deitado ? H * 0.2 : H * 0.18), t: 0.3, ...base });
+                origem = [W / 2, H * 0.56];
+                break;
+            }
+            case 'produto': {
+                const pw = deitado ? W * 0.62 : W - 2 * M;
+                if (titulo) fonteTag(titulo, TOPO - 20 * b, 0.1, { x: r2((W - pw) / 2) });
+                els.push({ tipo: 'kit', peca: 'painel', titulo: marca.nome || titulo, texto: p.texto || p.sub || titulo, destaque: p.destaque || tese(p.texto || p.sub || titulo), selo: p.selo,
+                    barras: p.barras, x: r2((W - pw) / 2), y: r2(Math.max(TOPO, H * 0.5 - pw * 0.22)), largura: r2(pw), t: 0.2, ...base, fonte: F.texto });
+                origem = [W / 2, H / 2];
+                break;
+            }
+            default: {   // titulo e o que mais vier
+                const fit = caber(titulo, { largura: larguraAncora, linhas: 3, max: 160 * b, min: 44 * b, fonte: F.titulo });
+                const alt = fit.linhas * fit.tamanho * 1.04;
+                const y = Math.max(TOPO + 20 * b, H * 0.7 - alt);
+                const alvo = tese(titulo, p.destaque);
+                const [tA] = g([alvo]);
+                /* Do lado direito o texto encosta na margem direita: alinhado à
+                   esquerda numa caixa larga, ele flutuaria no meio e a câmera o
+                   empurraria para fora do quadro. */
+                const dir = !esquerda;
+                els.push({ tipo: 'kit', peca: 'letra', texto: titulo, destaque: alvo, x: r2(dir ? W - M : xA), y: r2(y), largura: r2(larguraAncora), tamanho: fit.tamanho, t: 0.12,
+                    tDestaque: Math.max(0.5, tA), alinhamento: dir ? 'right' : 'left', ...base });
+                if (p.sub) fonteTag(p.sub, y + alt + 36 * b, Math.min(d - 0.8, Math.max(0.9, tA + 0.5)), dir ? { x: r2(W - M), alinhamento: 'right' } : {});
+                // A câmera ancora na margem do texto: o empurrão cresce para dentro, nunca para fora do quadro.
+                origem = [dir ? W - M : xA, y + alt / 2];
+                som(t0 + Math.max(0.5, tA), 'sopro', 0.14);
+            }
+        }
+
+        const cam = corteInterno(camera(d, modo, i), d, tp, t0);
+        return {
+            duracao: d,
+            fundo: escuro ? ESCURO : PAPEL,
+            escuro,
+            secao: String(i + 1).padStart(2, '0') + ' — ' + (p.tipo || 'parte'),
+            camadas: CAMADAS,
+            camera: cam,
+            cameraOrigem: origem ? `${r2(origem[0])}px ${r2(origem[1])}px` : 'center center',
+            transicao: 'corte',
+            elementos: [papel(escuro), ...els],
+        };
+    });
+
+    const plano = {
+        formato: { largura: W, altura: H, fps: FPS },
+        fundoGeral: PAPEL,
+        estilo: 'vox',
+        acabamento: { grao: 0.06, vinheta: 0.22, corVinheta: '40,30,18' },
+        cenas,
+        audio: {
+            ...(narracao ? { narracao } : {}),
+            ...(trilha ? { trilha: { src: trilha, volumes: volumesDaTrilha(temVoz ? tempos : [], total), loop: true } } : {}),
+            efeitos,
+        },
+    };
+    return { ok: true, plano, resumo: { cenas: cenas.length, segundos: total, partes: partes.length, fps: FPS, estilo: 'vox' } };
+}
+
+module.exports = { montarVox, tese, quebrar, termoDef };

package/lib/fala.js

@@ -41,91 +41,6 @@ const { EventEmitter } = require('events');
 const { c, actionHeader, friendlyError } = require('./ui');
 const markdown = require('./markdown.js');
 
-/* ── O CANAL ESTRUTURADO ─────────────────────────────────────────────────
- * A janela do app (lib/app.js) mostra a conversa como CHAT: a fala do Primo
- * em texto e cada ação dele numa linha cinza ("Leu index.html", "Rodou npm
- * test ✓"). Adivinhar isso relendo a saída colorida do terminal seria frágil
- * — um rótulo que muda aqui quebraria a janela calado. Então a MESMA função
- * que desenha no terminal também avisa, por este canal, o que desenhou.
- *
- * Sem ouvinte (terminal puro), `avisar` não faz nada: nenhum custo para quem
- * não abriu a janela. */
-const eventos = new EventEmitter();
-eventos.setMaxListeners(20);
-function avisar(tipo, dados) {
-    if (!eventos.listenerCount('evento')) return;
-    try { eventos.emit('evento', Object.assign({ tipo }, dados || {})); } catch { /* a janela nunca derruba o agente */ }
-}
-
-/* O que a linha de ação da janela diz, por ferramenta. Verbo no passado
-   porque a linha fica na conversa depois que a ação acabou — "Lendo" viraria
-   mentira um segundo depois. O ícone é uma família, não um desenho por tool:
-   a página tem dez ícones, não setenta. */
-const VERBOS = {
-    read_file: ['Leu', 'ler'], write_file: ['Escreveu', 'escrever'], edit_file: ['Editou', 'editar'],
-    multi_edit: ['Editou', 'editar'], list_dir: ['Listou', 'buscar'], glob: ['Procurou', 'buscar'],
-    grep: ['Buscou', 'buscar'], run_shell: ['Rodou', 'rodar'], run_in_new_terminal: ['Abriu um terminal com', 'rodar'],
-    open_in_browser: ['Abriu', 'web'], spawn_agent: ['Chamou um agente', 'agente'], write_todos: ['Planejou', 'plano'],
-    finish: ['Concluiu', 'plano'], pesquisar_referencia: ['Pesquisou', 'web'], remember_general: ['Guardou na memória', 'plano'],
-    planejar_producao: ['Planejou a produção', 'agente'], construir_app: ['Construiu', 'agente'],
-};
-
-/** Verbo, alvo e ícone de uma ação — só o que cabe numa linha, nunca o
- *  conteúdo inteiro de um write_file. */
-function resumoDaAcao(name, args) {
-    const a = args || {};
-    let [verbo, icone] = VERBOS[name] || [];
-    if (!verbo) {
-        if (/^browser_/.test(name)) { verbo = 'Navegador · ' + name.slice(8); icone = 'web'; }
-        else if (/^desktop_/.test(name)) { verbo = 'Computador · ' + name.slice(8).replace(/_/g, ' '); icone = 'computador'; }
-        else if (/^estudio_/.test(name)) { verbo = 'Estúdio · ' + name.slice(8); icone = 'agente'; }
-        else { verbo = name; icone = 'outro'; }
-    }
-    let alvo = a.path || a.command || a.pattern || a.consulta || a.url || a.target || a.app || a.selector
-        || a.titulo || a.description || a.arquivo || (a.todos ? `${a.todos.length} tarefas` : '') || '';
-    if (typeof alvo !== 'string') alvo = '';
-    alvo = alvo.replace(/\s+/g, ' ').trim();
-    if (alvo.length > 120) alvo = alvo.slice(0, 119) + '…';
-    return { nome: name, verbo, alvo, icone };
-}
-
-/** O resultado de uma ação, resumido para a linha da janela: ok ou não, o
- *  "+12 −3" das edições e até 40 linhas de detalhe para quem expandir. */
-function resumoDoResultado(name, r) {
-    if (!r || typeof r !== 'object') return { nome: name, ok: true };
-    if (r.ok === false) {
-        return { nome: name, ok: false, resumo: String(r.error || `exit ${r.code ?? 'erro'}`).replace(/\s+/g, ' ').trim().slice(0, 300) };
-    }
-    const fora = { nome: name, ok: true };
-    if (typeof r._antes === 'string' && typeof r._depois === 'string') {
-        try {
-            const diff = require('./diff.js');
-            const n = r._antes.split('\n').length + r._depois.split('\n').length;
-            if (n <= diff.MAX_LINHAS_ARQUIVO * 2) {
-                const ops = diff.operacoes(r._antes, r._depois);
-                Object.assign(fora, diff.contar(ops));
-                fora.detalhe = ops.filter((o) => o.tipo !== ' ').slice(0, 40).map((o) => o.tipo + ' ' + o.texto).join('\n');
-            }
-        } catch { /* sem diff: a linha sai sem os números */ }
-    }
-    if (name === 'write_file') fora.criado = !!r.created;
-    if (name === 'run_shell' || name === 'run_in_new_terminal') {
-        const saida = String(r.stdout || '').trim() + (r.stderr ? '\n' + String(r.stderr).trim() : '');
-        fora.detalhe = saida.split('\n').slice(-40).join('\n').trim();
-        fora.codigo = r.code ?? 0;
-    }
-    const plural = (n, um, varios) => `${n} ${n === 1 ? um : varios}`;
-    if (name === 'read_file') fora.resumo = plural(r.linhas || 0, 'linha', 'linhas');
-    if (name === 'grep') fora.resumo = plural(r.total || 0, 'ocorrência', 'ocorrências');
-    if (name === 'glob') fora.resumo = plural(r.total || 0, 'arquivo', 'arquivos');
-    if (name === 'list_dir' && r.tree) fora.detalhe = String(r.tree).split('\n').slice(0, 40).join('\n');
-    if (name === 'write_todos' && Array.isArray(r.todos)) {
-        fora.detalhe = r.todos.map((t) => (t.status === 'completed' ? '✓ ' : '○ ') + t.content).join('\n');
-        fora.resumo = `${r.feitos}/${r.total}`;
-    }
-    return fora;
-}
-
 /* Até este tamanho, o texto que o modelo escreve antes de chamar uma tool é
    guardado e sai de uma vez, como pensamento. Passou disso sem tool à vista,
    é resposta — e volta a correr na tela conforme chega. Uma frase de
@@ -144,7 +59,6 @@ function pensamento(texto, profundidade) {
     if (!ls.length || !ls[0]) return '';
     const p = ident(profundidade);
     const saida = ls.map((l, i) => `${p}  ${i === 0 ? c.dim('✦') : ' '} ${c.muted(l)}`).join('\n');
-    avisar('pensamento', { texto: ls.join('\n'), prof: profundidade || 0 });
     console.log(saida);
     return saida;
 }
@@ -152,7 +66,6 @@ function pensamento(texto, profundidade) {
 /** A ação (tool) que ele decidiu fazer. */
 function acao(name, args, profundidade) {
     const saida = ident(profundidade) + actionHeader(name, args);
-    avisar('acao', Object.assign(resumoDaAcao(name, args), { prof: profundidade || 0 }));
     console.log(saida);
     return saida;
 }
@@ -190,7 +103,6 @@ function resposta(texto) {
     const largura = Math.max(40, (process.stdout.columns || 80) - 4);
     const linhasMd = markdown.renderizar(texto, largura);
     const saida = '\n' + linhasMd.map((l, i) => (i === 0 ? `${c.brand('●')} ${l}` : `  ${l}`)).join('\n');
-    avisar('resposta', { texto: String(texto) });
     console.log(saida);
     return saida;
 }
@@ -200,7 +112,6 @@ function resposta(texto) {
 function aviso(texto) {
     if (!String(texto || '').trim()) return '';
     const saida = '\n' + formatar(texto, c.warn('●'));
-    avisar('aviso', { texto: String(texto) });
     console.log(saida);
     return saida;
 }
@@ -244,11 +155,9 @@ function fluxo() {
         escrever(delta) {
             const t = String(delta || '');
             if (!t) return;
-            avisar('pedaco', { texto: t });
             sair(desenho.pedaco(t));
         },
         fechar() {
-            avisar('fim', {});
             sair(desenho.fim());
             if (escreveu) process.stdout.write('\n');
         },
@@ -266,7 +175,6 @@ function paralelo(quantos, profundidade) {
 /** Um agente delegado começando: "◆ Agente·frontend  a folha de estilo". */
 function agente(rotulo, descricao, profundidade) {
     const saida = `${ident(profundidade)}  ${c.brand('◆')} ${c.bold(rotulo || 'Agente')}${descricao ? '  ' + c.muted(descricao) : ''}`;
-    avisar('acao', { nome: 'agente', verbo: rotulo || 'Agente', alvo: String(descricao || '').slice(0, 120), icone: 'agente', prof: profundidade || 0 });
     console.log(saida);
     return saida;
 }
@@ -275,9 +183,8 @@ function agente(rotulo, descricao, profundidade) {
 function agenteVoltou(resumo, profundidade) {
     const texto = String(resumo || 'sem resultado').replace(/\s+/g, ' ').trim();
     const saida = resultado(profundidade) + c.muted(texto.length > 140 ? texto.slice(0, 139) + '…' : texto);
-    avisar('resultado', { nome: 'agente', ok: true, detalhe: texto.slice(0, 2000) });
     console.log(saida);
     return saida;
 }
 
-module.exports = { eventos, avisar, resumoDaAcao, resumoDoResultado, LIMIAR_PENSAMENTO, pensamento, acao, resultado, recuo, resposta, aviso, problema, frase, fluxo, paralelo, agente, agenteVoltou };
+module.exports = { LIMIAR_PENSAMENTO, pensamento, acao, resultado, recuo, resposta, aviso, problema, frase, fluxo, paralelo, agente, agenteVoltou };