primocode 10.0.9 → 10.1.0

package/lib/estudio/fluido.js

@@ -0,0 +1,283 @@
+/**
+ * fluido.js — o estilo FLUIDO: uma ideia por batida, muito respiro, e nada
+ * de corte. O elemento de uma batida VIRA o da próxima.
+ *
+ *   "Uma ideia por quadro, muito espaço vazio. Texto pequeno, caixa normal,
+ *    sans limpa. Movimento contínuo: um elemento se transforma no próximo."
+ *    — a referência de motion do Joel (05/10), os vídeos bons.
+ *
+ * Existe UMA forma que vive o vídeo inteiro (o "portador"): é o ponto da
+ * abertura, a pílula do título, o anel do número, a primeira pílula da lista,
+ * a linha que risca o "não", o cartão da citação e o primeiro círculo da
+ * marca no fim. Entre uma batida e outra ela muda de lugar, de tamanho, de
+ * raio e de preenchimento — o olho segue a forma, e o corte some.
+ *
+ * O texto entra palavra por palavra (stagger curto, ease-out forte, sem
+ * linear) e cada frase tem UM acento: uma palavra em serifa itálica na cor de
+ * acento. Fundo em gradiente grande e macio, de uma paleta curta (no máximo
+ * dois acentos e os neutros), clara ou escura.
+ *
+ * Proibido aqui, de propósito (é a lista do "cara de IA"): HUD, cantoneira,
+ * timecode, caixa na palavra-chave, neon, partícula e CAIXA ALTA.
+ *
+ * Puro: devolve a partitura (os testes olham) e o plano com UMA peça do kit
+ * (kit/fluido.jsx), que desenha a partitura quadro a quadro.
+ */
+
+'use strict';
+
+const { volumesDaTrilha } = require('./ritmo.js');
+
+const FPS = 30;
+const r2 = (n) => Math.round(n * 100) / 100;
+const POR_PALAVRA = 0.3, MINIMO = 0.8;   // o tempo de leitura: 0,3 s por palavra, nunca menos de 0,8 s
+const STAGGER = 0.07;                    // entre uma palavra e a próxima (a que a voz não diz)
+const ANTES = 0.12;                      // a batida troca isto antes da primeira palavra da frase
+
+/* As paletas: um fundo em três tons (o gradiente), a tinta, a tinta suave e
+   NO MÁXIMO dois acentos (o da palavra e o brilho difuso). */
+const PALETAS = {
+    noite: { escuro: true, fundo: ['#020615', '#061a5c', '#1240c9'], tinta: '#eef2ff', suave: '#9fb0d9', acentos: ['#8fb8ff', '#2f6bff'] },
+    breu: { escuro: true, fundo: ['#030304', '#0b0a12', '#2a2156'], tinta: '#f4f4f6', suave: '#8d8a9c', acentos: ['#b4a6ff', '#5b45ff'] },
+    lavanda: { escuro: false, fundo: ['#f5f4ff', '#e4e1ff', '#b9b2ff'], tinta: '#17153a', suave: '#6e6a92', acentos: ['#4a3ce0', '#8f86ff'] },
+    creme: { escuro: false, fundo: ['#fbf8f2', '#f2e8d8', '#e7c9a5'], tinta: '#1e1a15', suave: '#857a6c', acentos: ['#c2502a', '#f0a36b'] },
+};
+const ESCURAS = ['noite', 'breu'], CLARAS = ['lavanda', 'creme'];
+
+const hash = (s) => { let h = 2166136261; for (const c of String(s)) h = Math.imul(h ^ c.charCodeAt(0), 16777619); return h >>> 0; };
+
+/** A paleta: a pedida pelo nome; senão o tema (claro/escuro); senão a semente. */
+function paletaDe(roteiro, semente) {
+    const pedida = String(roteiro.paleta || '').toLowerCase();
+    const tema = String(roteiro.tema || '').toLowerCase();
+    const nome = PALETAS[pedida] ? pedida
+        : /claro|light/.test(tema) ? CLARAS[semente % 2]
+            : /escuro|dark/.test(tema) ? ESCURAS[semente % 2]
+                : Object.keys(PALETAS)[semente % 4];
+    const p = { nome, ...PALETAS[nome], acentos: [...PALETAS[nome].acentos] };
+    // A cor da marca vira o acento da palavra (e só ela: a paleta não cresce).
+    const dest = roteiro.marca && roteiro.marca.cores && roteiro.marca.cores.destaque;
+    if (/^#[0-9a-f]{6}$/i.test(dest || '')) p.acentos[0] = dest;
+    return p;
+}
+
+/* Caixa alta não entra: frase GRITADA vira caixa normal (sigla curta fica). */
+function caixaNormal(t) {
+    const s = String(t || '').trim();
+    const letras = s.replace(/[^A-Za-zÀ-ÿ]/g, '');
+    if (letras.length < 4 || letras !== letras.toUpperCase()) return s;
+    const m = s.toLowerCase();
+    return m.charAt(0).toUpperCase() + m.slice(1);
+}
+
+const VAZIAS = new Set('a o as os um uma de da do das dos e é em no na nos nas que com por para pra se seu sua você ao à mais muito isso este esta não sim'.split(' '));
+const limpa = (w) => w.toLowerCase().normalize('NFD').replace(/[̀-ͯ]/g, '').replace(/[^a-z0-9]/g, '');
+
+/** A frase em palavras, com UM acento: o destaque pedido, ou a palavra de mais peso. */
+function frase(texto, { destaque = '', semAcento = false } = {}) {
+    const ws = caixaNormal(texto).split(/\s+/).filter(Boolean);
+    let ac = -1;
+    if (!semAcento && ws.length > 1) {
+        const d = limpa(String(destaque).split(/\s+/)[0] || '');
+        if (d) ac = ws.findIndex((w) => limpa(w) === d);
+        if (ac < 0) {
+            // A palavra mais longa que não é vazia; no empate, a mais tarde (a frase termina nela).
+            let melhor = 0;
+            ws.forEach((w, i) => { const n = limpa(w).length; if (!VAZIAS.has(limpa(w)) && n >= 4 && n >= melhor) { melhor = n; ac = i; } });
+        }
+    }
+    return ws.map((t, i) => ({ t, acento: i === ac }));
+}
+
+const numeroDe = (v) => {
+    const m = String(v == null ? '' : v).match(/^(\D*)([\d.,]+)(.*)$/);
+    if (!m) return null;
+    const n = Number(m[2].replace(/\./g, '').replace(',', '.'));
+    return Number.isFinite(n) ? { antes: m[1], ate: n, depois: m[3], casas: /,\d/.test(m[2]) ? 1 : 0 } : null;
+};
+const itensDe = (p) => (p.itens || []).map((i) => (typeof i === 'string' ? i : i.texto || i.titulo || '')).filter(Boolean);
+const leitura = (n) => Math.max(MINIMO, POR_PALAVRA * n);
+
+/* A forma do portador em cada tipo de parte (kit/fluido.jsx dá o tamanho). */
+const FORMA = { abertura: 'ponto', titulo: 'pilula', numero: 'anel', lista: 'pilula', passos: 'ponto', contraste: 'linha', citacao: 'cartao', cta: 'marca' };
+const TIPO = { logo: 'abertura', imagem: 'titulo', produto: 'titulo', grafico: 'lista', cores: 'lista' };
+
+/**
+ * A partitura: as batidas, cada uma com as frases (e quando cada uma entra),
+ * a forma do portador e a transição. Sem áudio nem plano — é o que os testes olham.
+ */
+function partituraDe({ roteiro, largura = 1920, altura = 1080, tempos = [] }) {
+    const partes = (roteiro.partes || []).filter((p) => p && typeof p === 'object');
+    const semente = Number.isFinite(roteiro.semente) ? roteiro.semente : hash(JSON.stringify(partes.map((p) => [p.tipo, p.titulo, p.valor])));
+    const paleta = paletaDe(roteiro, semente);
+    const marca = roteiro.marca || {};
+    const temVoz = tempos.length === partes.length && tempos.every((t) => t && t.ate > t.de);
+    /* O comando do terminal: o link da cta, se for comando; senão o nome da marca. */
+    const link = (partes.find((p) => p.tipo === 'cta') || {}).link || '';
+    const cmd = /^(npm|npx|pnpm|yarn|pip|brew|curl|git|bun)\b/.test(link) ? link : String(marca.nome || 'app').toLowerCase().replace(/\s+/g, '-');
+    let comCartao = 0;
+
+    const batidas = partes.map((p, i) => {
+        const tipo = TIPO[p.tipo] || (FORMA[p.tipo] ? p.tipo : 'titulo');
+        const titulo = p.titulo || p.texto || '';
+        const fr = [];
+        const poe = (papel, texto, o = {}) => { if (String(texto || '').trim()) fr.push({ id: `${i}-${fr.length}`, papel, palavras: frase(texto, o) }); };
+        const b = { i, tipo, forma: FORMA[tipo], transicao: p.corte === true && i > 0 ? 'corte' : 'morfa', frases: fr, lado: 'centro' };
+        /* O CARTÃO DE PRODUTO que flutua ao lado (terminal, chat, painel), feito
+           de forma e texto — e o texto vai para o outro lado. `ui: false` tira. */
+        const ui = p.ui === false ? null : typeof p.ui === 'string' ? p.ui
+            : tipo === 'titulo' || tipo === 'abertura' ? ['terminal', 'chat'][comCartao % 2] : tipo === 'numero' ? 'painel' : null;
+        if (ui) {
+            b.lado = comCartao++ % 2 ? 'dir' : 'esq';
+            b.ui = ui === 'terminal' ? { tipo: ui, linhas: ['$ ' + cmd, '✓ ' + caixaNormal(p.sub || titulo)] }
+                : ui === 'chat' ? { tipo: ui, pergunta: caixaNormal(titulo) }
+                    : { tipo: 'painel', rotulo: caixaNormal(p.rotulo || titulo), barras: [0, 1, 2, 3, 4, 5, 6].map((k) => r2(0.35 + ((semente >>> (k * 3)) % 7) / 10)) };
+        }
+        switch (tipo) {
+            case 'numero': {
+                b.numero = numeroDe(p.valor);
+                poe('numero', p.valor, { semAcento: true });
+                poe('rotulo', p.rotulo || titulo, { destaque: p.destaque });
+                break;
+            }
+            case 'lista': case 'passos':
+                poe('principal', titulo, { destaque: p.destaque });
+                itensDe(p).slice(0, tipo === 'passos' ? 6 : 4).forEach((it) => poe('item', it, { semAcento: true }));
+                break;
+            case 'contraste':
+                poe('nao', p.nao, { semAcento: true });
+                poe('sim', p.sim || titulo, { destaque: p.destaque });
+                break;
+            case 'citacao':
+                poe('principal', titulo, { destaque: p.destaque });
+                poe('autor', p.autor ? `— ${p.autor}` : '', { semAcento: true });
+                break;
+            case 'cta':
+                b.marca = { nome: caixaNormal(marca.nome || titulo) };
+                poe('marca', b.marca.nome, { semAcento: true });
+                poe('principal', marca.nome ? titulo : '', { destaque: p.destaque });
+                poe('sub', p.link || p.sub, { semAcento: true });
+                break;
+            default:
+                poe('principal', titulo, { destaque: p.destaque });
+                poe('sub', p.sub, { semAcento: true });
+        }
+        return b;
+    });
+
+    /* ── o tempo: a VOZ manda. A batida troca na fronteira da frase (um
+       pouco antes da primeira palavra da parte) e cada palavra na tela
+       aparece no instante em que é dita (os tempos por palavra da narração).
+       A palavra que a voz não diz entra em cascata curta. Se o texto pede
+       mais leitura do que a frase deu, a batida estica e a próxima volta a
+       casar com a voz na primeira folga; o atraso medido vai na partitura. */
+    let atraso = 0, sincronia = 0;
+    batidas.forEach((b, i) => {
+        const tp = temVoz ? tempos[i] : null;
+        const deVoz = tp ? (i === 0 ? 0 : Math.max(0, tp.de - ANTES)) : null;
+        b.de = r2(i === 0 ? 0 : Math.max(batidas[i - 1].ate, deVoz == null ? 0 : deVoz));
+        if (deVoz != null) atraso = Math.max(atraso, r2(b.de - deVoz));
+        const ditas = ((tp && tp.palavras) || []).map((w) => ({ k: limpa(w.texto), de: w.de }));
+        let cursor = 0, livre = b.de + (b.tipo === 'cta' ? 0.55 : 0.12);
+        const fimVoz = tp ? (i < batidas.length - 1 ? tempos[i + 1].de - ANTES : tp.ate + 0.2) : 0;
+        for (const f of b.frases) {
+            /* Casa as palavras da tela com as faladas, na ordem. Tenta começar de
+               cada palavra (a frase da tela pode vir em outra ordem que a falada)
+               e fica com o casamento que acha mais palavras. */
+            const casa = (k, d) => d === k || (k.length >= 4 && d.length >= 4 && d.slice(0, 5) === k.slice(0, 5));
+            let ts = f.palavras.map(() => null), fim = cursor;
+            for (let ini = 0; ini < f.palavras.length; ini++) {
+                let c = cursor;
+                const tt = f.palavras.map((w, j) => {
+                    const k = limpa(w.t);
+                    if (j < ini || !k) return null;
+                    for (let q = c; q < Math.min(ditas.length, c + 12); q++) if (casa(k, ditas[q].k)) { c = q + 1; return ditas[q].de; }
+                    return null;
+                });
+                if (tt.filter((x) => x != null).length > ts.filter((x) => x != null).length) { ts = tt; fim = c; }
+            }
+            cursor = fim;
+            f.falada = ts.filter((x) => x != null).length >= f.palavras.length / 2;
+            const ach = ts.findIndex((x) => x != null);
+            /* O que a voz não diz entra cedo o bastante para ser lido antes de a
+               frase acabar (e nunca antes da batida). */
+            let t = ach >= 0 ? ts[ach] - ach * STAGGER
+                : tp ? Math.max(b.de + 0.25, Math.min(livre, fimVoz - leitura(f.palavras.length) - 0.05)) : livre;
+            f.palavras.forEach((w, j) => {
+                const falada = ts[j];
+                t = Math.max(b.de + 0.06, falada != null ? Math.max(t, falada - 0.05) : t);
+                w.em = r2(t);
+                if (falada != null) sincronia = Math.max(sincronia, r2(w.em - falada));
+                t += STAGGER;
+            });
+            f.de = f.palavras[0].em;
+            // O que não é dito (rótulo, item, link) entra logo depois do anterior.
+            livre = Math.max(livre, f.papel === 'item' && b.tipo === 'passos' ? f.de + leitura(f.palavras.length) * 0.8 : f.palavras[f.palavras.length - 1].em + 0.18);
+        }
+        /* O texto que a voz DIZ é lido junto com ela: fica até depois da última
+           palavra dita (e nunca menos de 0,8 s). O que a voz não diz pede 0,3 s por palavra. */
+        const precisa = Math.max(...b.frases.map((f) => f.de + (f.falada
+            ? Math.max(MINIMO, f.palavras[f.palavras.length - 1].em - f.de + 0.3) : leitura(f.palavras.length))), b.de + 0.9);
+        b.ate = r2(Math.max(precisa, fimVoz));
+    });
+    // A marca do fim segura um instante; o resto não espera.
+    const ult = batidas[batidas.length - 1];
+    ult.ate = r2(ult.ate + (ult.tipo === 'cta' ? 1.0 : 0.5));
+
+    return {
+        versao: 2, semente, fps: FPS, atraso, sincronia, largura, altura, duracao: ult.ate, paleta,
+        fontes: { texto: 'Inter', serifa: 'Instrument Serif', mono: 'JetBrains Mono' },
+        logo: marca.logo || null,
+        batidas,
+    };
+}
+
+/**
+ * @param {object} op
+ * @param {object} op.roteiro   { marca, paleta?: noite|breu|lavanda|creme, tema?: claro|escuro, partes }
+ * @param {Array}  op.tempos    [{de, ate, palavras}] por parte (da narração)
+ * @param {object} op.sons      os efeitos leves (sons-leves.js)
+ */
+function montarFluido({ roteiro, largura = 1920, altura = 1080, tempos = [], narracao = null, sons = {}, trilha = null }) {
+    const partes = ((roteiro && roteiro.partes) || []).filter((p) => p && typeof p === 'object');
+    if (!partes.length) return { ok: false, error: 'o roteiro veio sem partes.' };
+    const partitura = partituraDe({ roteiro: { ...roteiro, partes }, largura, altura, tempos });
+    const DUR = partitura.duracao;
+    /* O SOM segue o movimento (sons-leves.js, tudo sintetizado): whoosh em
+       cada transformação, pop quando pílula ou cartão assenta, clique na roda e
+       no terminal, um bolha discreto na palavra de acento, o riser que leva à
+       marca e o impacto quando ela trava. Baixo: a voz vem primeiro. */
+    const efeitos = [];
+    const som = (t, nome, volume) => { if (sons[nome]) efeitos.push({ t: r2(Math.max(0, t)), src: sons[nome], volume }); };
+    for (const b of partitura.batidas) {
+        if (b.i > 0 && b.tipo !== 'cta') som(b.de - 0.18, 'whoosh', 0.2);
+        if (b.ui) { som(b.de + 0.6, 'pop', 0.16); if (b.ui.tipo === 'terminal') b.ui.linhas.forEach((_, k) => som(b.de + 0.75 + k * 0.5, 'clique', 0.1)); }
+        for (const f of b.frases) {
+            if (f.papel === 'item') som(f.de - 0.06, b.tipo === 'passos' ? 'clique' : 'pop', 0.15);
+            const ac = f.palavras.find((w) => w.acento);
+            if (ac && f.papel !== 'item') som(ac.em, 'bolha', 0.09);
+        }
+        if (b.tipo === 'citacao') som(b.de + 0.3, 'pop', 0.14);
+        if (b.tipo === 'cta') { som(b.de - 0.75, 'riser', 0.2); som(b.de + 0.45, 'impacto', 0.26); som(b.de + 0.5, 'brilho', 0.16); }
+    }
+    const volumes = volumesDaTrilha(tempos.length === partes.length ? tempos : [], DUR, { alto: 0.55, baixo: 0.22 });
+    const P = partitura.paleta;
+    const plano = {
+        formato: { largura, altura, fps: FPS },
+        fundoGeral: P.fundo[0],
+        fontesVariaveis: { Inter: 'wght@300..700', 'Instrument Serif': 'ital@0;1', 'JetBrains Mono': 'wght@400;500' },
+        cenas: [{
+            duracao: DUR,
+            fundo: P.fundo[0],
+            elementos: [{ tipo: 'kit', peca: 'fluido', partitura, fonte: partitura.fontes.texto, fonteSerifa: partitura.fontes.serifa, fonteMono: partitura.fontes.mono }],
+        }],
+        audio: {
+            ...(narracao ? { narracao } : {}),
+            ...(trilha ? { trilha: { src: trilha, volumes, loop: true } } : {}),
+            efeitos,
+        },
+    };
+    return { ok: true, plano, partitura, resumo: { cenas: 1, batidas: partitura.batidas.length, segundos: DUR, fps: FPS, paleta: P.nome, atraso: partitura.atraso, sincronia: partitura.sincronia } };
+}
+
+module.exports = { montarFluido, partituraDe, caixaNormal, PALETAS, POR_PALAVRA, MINIMO };

package/lib/estudio/gerativo.js

@@ -827,6 +827,18 @@ function partituraDe({ roteiro, largura = 1920, altura = 1080, tempos = [] }) {
     };
     const registra = (b) => { usadas[b.comp] = (usadas[b.comp] || 0) + 1; recentes.push(b.comp); anterior = b.comp; batidas.push(b); };
 
+    /* PEDIU 3D, O 3D APARECE: o sorteio podia passar o vídeo inteiro sem a
+       batida do produto (3 partes, "pilha → contador → pilha", 05/10). Se
+       nenhuma escolher sozinha, a melhor parte ganha: a de produto, o cta ou
+       a primeira com título. */
+    const ultimaDe = (tipos) => { for (let i = brutas.length - 1; i >= 0; i--) if (tipos.includes(brutas[i].conteudo.tipo)) return i; return -1; };
+    let alvo3d = -1;
+    if (tem3d) {
+        alvo3d = ultimaDe(['produto']);
+        if (alvo3d < 0) alvo3d = ultimaDe(['cta']);
+        if (alvo3d < 0) alvo3d = brutas.findIndex((b) => ['titulo', 'marca'].includes(b.conteudo.tipo));
+    }
+
     brutas.forEach((br, bi) => {
         const c = br.conteudo;
         const tituloC = c.titulo || c.nome || c.texto || '';
@@ -836,6 +848,7 @@ function partituraDe({ roteiro, largura = 1920, altura = 1080, tempos = [] }) {
             pergunta: /\?/.test(tituloC), exclama: /!/.test(tituloC), numeroNoTitulo: /\d/.test(tituloC),
         };
         let nome = escolher(pesosDe(c, feat));
+        if (bi === alvo3d && !usadas.produto) nome = 'produto';
         const ctx = { s, W, H, M, deitado, base, larguraUtil, tamRotulo, fontes, P, palavras: br.palavras || c.palavras || [], parte: br.parte, marca, roteiro, memoria };
         if (nome === 'rajada' && br.ate - br.de < 1.6 * c.itens.length) nome = 'cascata';
         if (nome === 'rajada') {
@@ -1042,20 +1055,25 @@ function partituraDe({ roteiro, largura = 1920, altura = 1080, tempos = [] }) {
 
     // ── o produto em 3D: mora nas batidas que o hospedam ─────────────────
     const produtos = batidas.filter((b) => b.produto3d).map((b) => ({ ...b.produto3d, de: b.de, ate: b.ate, modelo: roteiro.modelo3d,
-        cor: roteiro.cor3d || '#1b1c20', corAcento: P.acento }));
+        cor: roteiro.cor3d || '#1b1c20', corAcento: P.acento, ...(roteiro.variacao3d || {}) }));
 
     // ── o fundo vivo ────────────────────────────────────────────────────
-    const fundo = { textura: s.um(['grade', 'pontos', 'linhas', 'grade']), passo: Math.round(s.um([72, 96, 120]) * base), grao: luz(P.fundo) < 0.5 ? 0.07 : 0.05,
+    /* SEM CARA DE IA (05/10): grade, pontinhos flutuando e o HUD só a pedido
+       (roteiro.hud, roteiro.particulas). O sorteio continua igual — a semente
+       dá o mesmo vídeo de antes, só sem o enfeite. */
+    const texturaSorteada = s.um(['grade', 'pontos', 'linhas', 'grade']);
+    const fundo = { textura: roteiro.hud === true ? texturaSorteada : null, passo: Math.round(s.um([72, 96, 120]) * base), grao: luz(P.fundo) < 0.5 ? 0.07 : 0.05,
         brilho: { x: s.entre(0.25, 0.75), y: s.entre(0.2, 0.5) },
         // Partículas em três profundidades: o espaço respira mesmo no repouso.
         particulas: Array.from({ length: 34 }, (_, i) => ({ x: r1(s.prox() * W), y: r1(s.prox() * H), z: [0.25, 0.5, 0.85][i % 3], r: r1((1.2 + s.prox() * 2.4) * base), v: r1(s.entre(6, 22) * base) })) };
+    if (roteiro.particulas !== true) fundo.particulas = [];
 
     return {
         versao: 1, semente, fps: FPS, humor,
         musica: { genero: s.um(H0.generos), generos: H0.generos }, largura: W, altura: H, duracao, regras: REGRAS,
         paleta: { ...P, fundo: campos[0], tinta: campos[2], acento: campos[1] }, campos, fontes, eixos: Object.fromEntries(Object.values(fontes).map((f) => [f, (VARIAVEIS[f] || {}).eixos || { wght: [400, 700] }])),
         margem: M, fundo, batidas, camera, produtos,
-        hud: { marca: String((marca.nome || roteiro.titulo || 'PrimoCode')).toUpperCase().slice(0, 24), ano: '2026' },
+        hud: roteiro.hud === true ? { marca: String((marca.nome || roteiro.titulo || 'PrimoCode')).toUpperCase().slice(0, 24), ano: '2026' } : null,
     };
 }
 

package/lib/estudio/hibrido.js

@@ -8,14 +8,14 @@
  *
  * O que cada lado traz:
  *   do cinema (cinema.js)  foto e vídeo REAIS ocupando a tela, escurecidos,
- *                          trocando por baixo do mesmo texto; letra grossa em
- *                          caixa alta com a palavra da tese no gradiente; o
+ *                          trocando por baixo do mesmo texto, escrito como a
+ *                          pessoa escreveu, com a palavra da tese na serifa; o
  *                          número que conta; a virada que bate no fundo; a
  *                          marca só no fim.
  *   do kit (kit/*.jsx)     a câmera que empurra e desliza em toda cena; a
- *                          etiqueta da fonte que se digita; partículas no
- *                          número e no fim; o HUD de motion designer; o
- *                          líquido entre blocos; grão e vinheta.
+ *                          líquido entre blocos; grão e vinheta. A etiqueta
+ *                          da fonte, o HUD e as partículas só a pedido
+ *                          (roteiro.hud, roteiro.particulas).
  *
  * Três passos, e nenhum repete o que o cinema já faz:
  *   traduzir(roteiro)      qualquer roteiro (vox, motion, composição) vira os
@@ -106,7 +106,10 @@ function camera(d, i, deitado, forte) {
 }
 
 /** O kit por cima do plano do cinema. Mexe no plano recebido e o devolve. */
-function enfeitar(plano, { extras = [], partes = [], marca = {}, largura, altura } = {}) {
+/* SEM CARA DE IA (05/10): o HUD (cantos, timecode, fps, rótulos nas bordas)
+   e as partículas eram exatamente a lista do "ruim" que o Joel juntou. Agora
+   só entram quando o roteiro pede: roteiro.hud === true, roteiro.particulas === true. */
+function enfeitar(plano, { extras = [], partes = [], marca = {}, largura, altura, hud = false, particulas = false } = {}) {
     if (!plano || !Array.isArray(plano.cenas)) return plano;
     const W = largura || (plano.formato && plano.formato.largura) || 1920;
     const H = altura || (plano.formato && plano.formato.altura) || 1080;
@@ -132,18 +135,18 @@ function enfeitar(plano, { extras = [], partes = [], marca = {}, largura, altura
         const forte = tipo === 'numero' || tipo === 'contraste' || tipo === 'abertura';
         if (!cena.camera) cena.camera = camera(d, c, deitado, forte);
 
-        // A FONTE que se digita, com a barra do acento: vira prova, não enfeite.
-        if (ex.fonte && d > 1.4) {
+        // A FONTE que se digita, com a barra do acento (é rótulo de borda: vem com o HUD).
+        if (hud && ex.fonte && d > 1.4) {
             els.push({ tipo: 'kit', peca: 'fonte', texto: String(ex.fonte).slice(0, 48), t: Math.min(0.9, d * 0.35),
                 x: M, y: Math.round(H - M * (deitado ? 1.1 : 2.6)), tamanho: Math.round(base * 0.016), cor: 'rgba(245,245,247,0.72)', corAcento: ACENTO });
         }
         // O NÚMERO estoura em partículas quando assenta.
-        if (tipo === 'numero' || tipo === 'grafico') {
+        if (particulas && (tipo === 'numero' || tipo === 'grafico')) {
             els.push({ tipo: 'kit', peca: 'particulas', t: 0.45, x: Math.round(W / 2), y: Math.round(H * 0.42), raio: Math.round(base * 0.34), n: 46,
                 tamanho: Math.max(5, Math.round(base * 0.007)), cores: ['#ffffff', ACENTO, grad[0]] });
         }
         // O FIM: a marca entra com um brilho de partículas.
-        if (tipo === 'cta' || tipo === 'logo' || tipo === 'fim') {
+        if (particulas && (tipo === 'cta' || tipo === 'logo' || tipo === 'fim')) {
             els.push({ tipo: 'kit', peca: 'particulas', t: 0.2, x: Math.round(W / 2), y: Math.round(H * 0.36), raio: Math.round(base * 0.45), n: 60,
                 tamanho: Math.max(4, Math.round(base * 0.006)), cores: ['#ffffff', ACENTO], forma: 'circulo' });
         }
@@ -154,8 +157,9 @@ function enfeitar(plano, { extras = [], partes = [], marca = {}, largura, altura
         }
     });
 
-    // O HUD de motion designer: cantos, timecode e a marca.
-    plano.hud = plano.hud || { marca: String(marca.nome || '').toUpperCase().slice(0, 24) || undefined };
+    // O HUD de motion designer (cantos, timecode e a marca): só a pedido.
+    if (hud) plano.hud = plano.hud || { marca: String(marca.nome || '').toUpperCase().slice(0, 24) || undefined };
+    else delete plano.hud;
     // O acabamento de filme um pouco mais presente que o do cinema.
     plano.acabamento = { ...(plano.acabamento || {}), grao: Math.max(0.06, (plano.acabamento || {}).grao || 0), vinheta: Math.max(0.55, (plano.acabamento || {}).vinheta || 0) };
     plano.estilo = 'hibrido';

package/lib/estudio/impacto.js

@@ -24,6 +24,7 @@
 
 const { caber, paleta } = require('./composicao.js');
 const { iconeDe, peso } = require('./edicao.js');
+const { minimoLeitura, sobra } = require('./legibilidade.js');
 
 const r2 = (n) => Math.round(n * 100) / 100;
 const limpa = (t) => String(t || '').replace(/^[^\p{L}\p{N}]+|[^\p{L}\p{N}%!?]+$/gu, '');
@@ -72,11 +73,12 @@ function montarImpacto({ roteiro, largura = 1080, altura = 1920, tempos = [], na
     const icOk = (ic) => ic && (!iconesOk || iconesOk.has(ic));
 
     // A palavra que bate: letra gigante, a palavra forte na cor de destaque.
-    const bater = (els, texto, { y = null, corTexto = cor.tinta, destaque = cor.destaque, max = (deitado ? H * 0.2 : W * 0.2), linhas = 3, glitch = false, girar = 0 } = {}) => {
-        const t = String(texto || '').toUpperCase();
-        /* Caixa alta em peso 900 é ~20% mais larga que a letra comum, e a
-           batida ainda cresce 5%: mede numa caixa mais estreita (medido em
-           25/09: "CONSTRUÇÃO" e "DEMONSTRAÇÃO" saíam pela borda). */
+    const bater = (els, texto, { y = null, corTexto = cor.tinta, destaque = cor.destaque, max = (deitado ? H * 0.2 : W * 0.2), linhas = 3, glitch = false, girar = 0, entra = 0.22 } = {}) => {
+        // Como a pessoa escreveu: caixa alta forçada era a "cara de IA" (05/10).
+        const t = String(texto || '');
+        /* Peso 900 é mais largo que a letra comum, e a batida ainda cresce 5%:
+           mede numa caixa mais estreita (medido em 25/09: "CONSTRUÇÃO" e
+           "DEMONSTRAÇÃO" saíam pela borda). */
         const fit = caber(t, { largura: W0 * 0.8, linhas, max, fonte: F.titulo });
         const h = fit.tamanho * 0.98 * fit.linhas;
         const ws = t.split(/\s+/);
@@ -85,12 +87,14 @@ function montarImpacto({ roteiro, largura = 1080, altura = 1920, tempos = [], na
         els.push({
             tipo: 'texto', texto: t, fonte: F.titulo, peso: 900, tamanho: fit.tamanho, cor: corTexto, entrelinha: 0.98,
             x: M, y: Math.round(y == null ? (H - h) / 2 : y), largura: W0, alinhamento: 'center', espacamento: -1,
-            ...(forte >= 0 && ws.length > 1 ? { revelar: ws.map(() => 0), destaques: [forte], corDestaque: destaque } : {}),
+            // A palavra forte é UM acento: a serifa em itálico, que chega um instante depois.
+            ...(forte >= 0 && ws.length > 1 ? { revelar: ws.map(() => 0), destaques: [forte], corDestaque: destaque, fonteDestaque: 'Instrument Serif' } : {}),
             ...(glitch ? { glitch: { forca: 14, dur: 0.3 } } : {}),
             anima: {
-                escala: [{ t: 0, v: 1.45 }, { t: 0.13, v: 0.97, e: 'saida' }, { t: 0.22, v: 1, e: 'suave' }, { t: 3, v: 1.05, e: 'linear' }],
-                opacidade: [{ t: 0, v: 0 }, { t: 0.05, v: 1 }],
-                rotacao: [{ t: 0, v: girar * 2 }, { t: 0.2, v: girar, e: 'saida' }],
+                // A entrada encolhe junto (entra < 0,22) quando a batida é curta: a leitura não.
+                escala: [{ t: 0, v: 1.45 }, { t: r2(entra * 0.6), v: 0.97, e: 'saida' }, { t: r2(entra), v: 1, e: 'suave' }, { t: 3, v: 1.05, e: 'linear' }],
+                opacidade: [{ t: 0, v: 0 }, { t: r2(entra * 0.23), v: 1 }],
+                rotacao: [{ t: 0, v: girar * 2 }, { t: r2(entra * 0.9), v: girar, e: 'saida' }],
             },
         });
         return h;
@@ -126,18 +130,51 @@ function montarImpacto({ roteiro, largura = 1080, altura = 1920, tempos = [], na
         let bs = batidas((tp.palavras || []).filter((w) => w && w.texto), fim);
         if (!bs.length) bs = [[{ de: ini, ate: fim, texto: p.titulo || p.sim || p.valor || '' }]];
         const itens = (p.itens || []).map((it) => (typeof it === 'string' ? it : it.texto));
+        const semNaoE = (t) => String(t || '').replace(/^\s*(n[aã]o\s+[ée]\s+|[ée]\s+)/i, '');
+        // Os textos que a batida k (de n) mostra — os mesmos que o desenho abaixo usa.
+        const textosDe = (b, k, n) => {
+            const falado = b.map((w) => limpa(w.texto)).join(' ');
+            if (p.tipo === 'numero' && k === 0) return [String(p.valor), p.rotulo || ''];
+            if ((p.tipo === 'lista' || p.tipo === 'passos') && itens.length) {
+                const it = itens[Math.min(k, itens.length - 1)];
+                return [p.tipo === 'passos' ? `${k + 1}. ${it}` : it, k === 0 ? p.titulo || '' : ''];
+            }
+            if (p.tipo === 'cta' && k === n - 1) return [p.titulo || falado, p.link || ''];
+            if (p.tipo === 'contraste') return [k < n / 2 ? `não é ${semNaoE(p.nao)}` : semNaoE(p.sim)];
+            // O título no fim só se der tempo de ler; senão, a fala dessa batida.
+            return [k === n - 1 && p.titulo && k > 0 && vao(k) >= minimoLeitura(p.titulo) + 0.08 ? p.titulo : falado];
+        };
+        /* A lei do /brag: cada batida fica no ar a entrada mínima mais
+           max(0,8 s; 0,3 s por palavra) — dentro do tempo da parte, sem esticar
+           o vídeo. Batida curta pega a folga da vizinha (o corte anda um pouco);
+           sem folga, gruda nela. */
+        const inis = bs.map((b, k) => (k === 0 ? ini : b[0].de - 0.04));
+        const vao = (k) => (k < bs.length - 1 ? inis[k + 1] : fim) - inis[k];
+        const precisa = (k) => Math.max(...textosDe(bs[k], k, bs.length).filter(Boolean).map(minimoLeitura))
+            + (p.tipo === 'cta' && k === bs.length - 1 && p.link ? 0.23 : 0) + 0.08;   // o link entra depois do título
+        for (let k = 0; bs.length > 1 && k < bs.length;) {
+            const falta = precisa(k) - vao(k);
+            if (falta <= 0) { k++; continue; }
+            if (k + 1 < bs.length && vao(k + 1) - falta >= precisa(k + 1)) { inis[k + 1] = r2(inis[k + 1] + falta); k++; continue; }
+            if (k > 0 && vao(k - 1) - falta >= precisa(k - 1)) { inis[k] = r2(inis[k] - falta); k++; continue; }
+            const a = k > 0 ? k - 1 : 0;
+            bs.splice(a, 2, [...bs[a], ...bs[a + 1]]);
+            inis.splice(a + 1, 1);
+            k = 0;
+        }
 
         // Impacto no começo de cada parte; o riser anuncia a chamada final.
         som(ini, 'impacto', i === 0 ? 0.9 : 0.6);
         if (p.tipo === 'cta') som(ini - 2, 'riser', 0.6);
 
         bs.forEach((b, k) => {
-            const de = k === 0 ? ini : b[0].de - 0.04;
-            const ate = k < bs.length - 1 ? bs[k + 1][0].de - 0.04 : fim;
+            const de = inis[k];
+            const ate = k < bs.length - 1 ? inis[k + 1] : fim;
             const falado = b.map((w) => limpa(w.texto)).join(' ');
             const els = [];
             const cena = { fundo: { tipo: 'cor', valor: cor.fundo }, elementos: els };
             const ultimo = k === bs.length - 1;
+            const entra = r2(sobra(vao(k), precisa(k) - 0.08, 0.08, 0.22));
             let tela;   // 'palavra' | 'foto' | 'marca'
 
             if (p.tipo === 'numero' && k === 0) {
@@ -148,8 +185,8 @@ function montarImpacto({ roteiro, largura = 1080, altura = 1920, tempos = [], na
                 const fit = caber(valor, { largura: W0, linhas: 1, max: H * (deitado ? 0.55 : 0.32), fonte: F.titulo });
                 els.push({ tipo: 'texto', texto: valor, fonte: F.titulo, peso: 900, tamanho: fit.tamanho, cor: '#FFFFFF', x: M, y: Math.round(H * 0.5 - fit.tamanho * 0.62), largura: W0, alinhamento: 'center',
                     ...(m ? { contar: { ate: Number(m[2].replace(/\./g, '').replace(',', '.')), dur: 0.7, antes: m[1], depois: m[3] } } : {}),
-                    anima: { escala: [{ t: 0, v: 1.6 }, { t: 0.18, v: 1, e: 'saida' }] } });
-                bater(els, p.rotulo || '', { y: H * 0.5 + fit.tamanho * 0.45, max: H * 0.07, linhas: 2, corTexto: '#FFFFFF', destaque: '#FFFFFF' });
+                    anima: { escala: [{ t: 0, v: 1.6 }, { t: r2(Math.min(0.18, entra)), v: 1, e: 'saida' }] } });
+                bater(els, p.rotulo || '', { y: H * 0.5 + fit.tamanho * 0.45, max: H * 0.07, linhas: 2, corTexto: '#FFFFFF', destaque: '#FFFFFF', entra });
                 cena.tremor = [{ de: 0, ate: 0.5, forca: 26 }];
                 tela = 'marca';
             } else if ((p.tipo === 'lista' || p.tipo === 'passos') && itens.length) {
@@ -159,9 +196,9 @@ function montarImpacto({ roteiro, largura = 1080, altura = 1920, tempos = [], na
                 const rot = p.tipo === 'passos' ? `${k + 1}. ${it}` : it;
                 const temE = emoji(els, it, { y: H * (deitado ? 0.28 : 0.3) });
                 // No gradiente, o destaque é o escuro da marca: laranja sobre azul some.
-                bater(els, rot, { y: temE ? H * (deitado ? 0.48 : 0.45) : null, max: deitado ? H * 0.11 : W * 0.12, linhas: 4, glitch: k === 0,
+                bater(els, rot, { y: temE ? H * (deitado ? 0.48 : 0.45) : null, max: deitado ? H * 0.11 : W * 0.12, linhas: 4, glitch: k === 0, entra,
                     ...(k % 2 === 1 ? { corTexto: '#FFFFFF', destaque: cor.fundo } : {}) });
-                if (k === 0 && p.titulo) els.push({ tipo: 'texto', texto: String(p.titulo).toUpperCase(), fonte: F.texto, peso: 800, tamanho: Math.round(Math.min(W, H) * 0.045), cor: cor.destaque, x: M, y: M * 2.2, largura: W0, alinhamento: 'center', espacamento: 3 });
+                if (k === 0 && p.titulo) els.push({ tipo: 'texto', texto: String(p.titulo), fonte: F.texto, peso: 700, tamanho: Math.round(Math.min(W, H) * 0.04), cor: cor.destaque, x: M, y: M * 2.2, largura: W0, alinhamento: 'center' });
                 tela = k % 2 ? 'marca' : 'palavra';
                 cena.socos = [{ t: 0, forca: 0.14 }];
                 som(de, 'estalo', 0.55);
@@ -173,7 +210,7 @@ function montarImpacto({ roteiro, largura = 1080, altura = 1920, tempos = [], na
                 els.push({ tipo: 'forma', forma: 'circulo', largura: R, altura: R, x: Math.round(W / 2 - R / 2), y: Math.round(H * 0.4 - R / 2), cor: grad[1], opacidade: 0.4,
                     anima: { desfoque: [{ t: 0, v: Math.round(R * 0.2) }], escala: [{ t: 0, v: 0.7 }, { t: 1, v: 1.1, e: 'suave' }] } });
                 const yT = H * 0.26;
-                const hT = bater(els, p.titulo || falado, { y: yT, max: deitado ? H * 0.14 : W * 0.14, linhas: 3, corTexto: '#FFFFFF', destaque: cor.destaque });
+                const hT = bater(els, p.titulo || falado, { y: yT, max: deitado ? H * 0.14 : W * 0.14, linhas: 3, corTexto: '#FFFFFF', destaque: cor.destaque, entra });
                 if (p.link) {
                     const fl = Math.round(Math.min(W, H) * 0.055);
                     const wP = Math.min(W0, String(p.link).length * fl * 0.62 + fl * 2.4);
@@ -193,39 +230,37 @@ function montarImpacto({ roteiro, largura = 1080, altura = 1920, tempos = [], na
                 // O rodízio das três telas, com a primeira batida sempre na palavra.
                 const ciclo = ['palavra', 'foto', 'marca', 'foto'];
                 tela = k === 0 ? (p.tipo === 'imagem' || i === 0 ? 'foto' : 'palavra') : ciclo[(nBatida + k) % ciclo.length];
-                const semNaoE = (t) => String(t || '').replace(/^\s*(n[aã]o\s+[ée]\s+|[ée]\s+)/i, '');
-                const texto = p.tipo === 'contraste' ? (k < bs.length / 2 ? `não é ${semNaoE(p.nao)}` : semNaoE(p.sim))
-                    : (ultimo && p.titulo && k > 0 ? p.titulo : falado);
+                const texto = textosDe(b, k, bs.length)[0];
                 if (tela === 'foto' && fotos.length) {
                     fotoCheia(els, proxFoto());
-                    bater(els, texto, { y: H * (deitado ? 0.56 : 0.6), max: deitado ? H * 0.12 : W * 0.13, linhas: 3 });
+                    bater(els, texto, { y: H * (deitado ? 0.56 : 0.6), max: deitado ? H * 0.12 : W * 0.13, linhas: 3, entra });
                     if (k % 2 === 0) cena.flashes = [0];
                 } else if (tela === 'marca') {
                     cena.fundo = { tipo: 'gradiente', cores: [grad[0], grad[1]], angulo: 135 };
                     const temE = emoji(els, texto, { y: H * (deitado ? 0.26 : 0.28) });
-                    bater(els, texto, { y: temE ? H * (deitado ? 0.46 : 0.44) : null, corTexto: '#FFFFFF', destaque: cor.fundo, max: deitado ? H * 0.16 : W * 0.16 });
+                    bater(els, texto, { y: temE ? H * (deitado ? 0.46 : 0.44) : null, corTexto: '#FFFFFF', destaque: cor.fundo, max: deitado ? H * 0.16 : W * 0.16, entra });
                 } else {
                     tela = 'palavra';
                     const temE = emoji(els, texto, { y: H * (deitado ? 0.25 : 0.27) });
                     bater(els, texto, { y: temE ? H * (deitado ? 0.45 : 0.43) : null, glitch: p.tipo === 'contraste' || k % 3 === 0,
-                        girar: k % 2 ? -2 : 2, corTexto: p.tipo === 'contraste' && k < bs.length / 2 ? 'rgba(255,255,255,0.55)' : cor.tinta });
+                        girar: k % 2 ? -2 : 2, entra, corTexto: p.tipo === 'contraste' && k < bs.length / 2 ? 'rgba(255,255,255,0.55)' : cor.tinta });
                     cena.socos = [{ t: 0, forca: 0.2 }];
                 }
                 if (k === 0) cena.tremor = [{ de: 0, ate: 0.35, forca: 18 }];
                 som(de, tela === 'foto' ? 'whoosh' : 'estalo', tela === 'foto' ? 0.5 : 0.5);
             }
             if (!(p.tipo === 'cta' && ultimo)) logoTopo(els);
-            /* A FAIXA: o subtítulo da parte (é onde moram a data e o local) em
-               letra pequena e espaçada no alto — o anúncio não pode esconder a data. */
+            /* A LINHA DE CIMA: o subtítulo da parte (é onde moram a data e o local)
+               em letra pequena no alto — o anúncio não pode esconder a data. Sem a
+               faixa de cor atrás (caixa de cor era a "cara de IA", 05/10): só o
+               texto, que sobe e aparece. */
             if (p.sub && p.tipo !== 'numero' && !(p.tipo === 'lista' || p.tipo === 'passos')) {
-                const fk = Math.round(Math.min(W, H) * 0.042);
-                els.push({ tipo: 'forma', forma: 'retangulo', x: M, y: Math.round(H * (deitado ? 0.14 : 0.1)), largura: W0, altura: Math.round(fk * 2), cor: cor.destaque, raio: Math.round(fk),
-                    anima: { escalaX: [{ t: 0.05, v: 0 }, { t: 0.3, v: 1, e: 'saida' }] }, origem: 'center' });
+                const fk = Math.round(Math.min(W, H) * 0.036);
                 // Com largura, e não pela âncora: sem largura o texto quebrava na metade da tela.
-                const tk = caber(String(p.sub).toUpperCase(), { largura: W0 * 0.78, linhas: 1, max: fk, fonte: F.texto }).tamanho;
-                els.push({ tipo: 'texto', texto: String(p.sub).toUpperCase(), fonte: F.texto, peso: 800, tamanho: tk, entrelinha: 1,
-                    cor: cor.sobreDestaque === '#FFFFFF' ? '#FFFFFF' : '#121218', x: M, largura: W0, alinhamento: 'center', y: Math.round(H * (deitado ? 0.14 : 0.1) + fk - tk * 0.5), espacamento: 2,
-                    anima: { opacidade: [{ t: 0.2, v: 0 }, { t: 0.35, v: 1 }] } });
+                const tk = caber(String(p.sub), { largura: W0 * 0.78, linhas: 1, max: fk, fonte: F.texto }).tamanho;
+                els.push({ tipo: 'texto', texto: String(p.sub), fonte: F.texto, peso: 600, tamanho: tk, entrelinha: 1,
+                    cor: tela === 'marca' ? '#FFFFFF' : cor.destaque, x: M, largura: W0, alinhamento: 'center', y: Math.round(H * (deitado ? 0.14 : 0.1)),
+                    anima: { opacidade: [{ t: 0.2, v: 0 }, { t: 0.5, v: 1 }], y: [{ t: 0.2, v: 12 }, { t: 0.6, v: 0, e: 'saida' }] } });
             }
 
             /* Uma transição curta a cada tanto; o resto é corte seco — é o