primocode 10.0.9 → 10.2.0

package/lib/estudio/biblioteca.js

@@ -0,0 +1,214 @@
+/**
+ * biblioteca.js — o cardápio de fonte e cor dos estilos de corte (híbrido,
+ * cinema, impacto), com memória do que os últimos vídeos usaram.
+ *
+ *   "por falta de variedade a gente tá fazendo os vídeos todos iguais" (Joel, 02/10)
+ *
+ * Sem fonte e cor da marca, o cinema caía sempre no Inter e no gradiente
+ * azul e roxo (#2E81ED → #9567DB), e o híbrido é o padrão: todo vídeo saía
+ * com a mesma cara. Aqui a escolha segue esta ordem:
+ *   1. a marca (fontes e cores dela) — nunca é trocada;
+ *   2. o que a IA escolheu do cardápio (roteiro.visual);
+ *   3. um sorteio que pula o que os últimos vídeos já usaram.
+ *
+ * As 128 famílias foram conferidas no Google Fonts em 02/10, com o peso mais
+ * grosso de cada uma (o título do cinema é caixa alta em 800).
+ */
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+// ── as fontes: "Nome:peso máximo", por tipo ──────────────────────────────
+const TIPOS = {
+    condensada: 'Anton:400, Antonio:700, Archivo Narrow:700, Barlow Condensed:900, Bebas Neue:400, Big Shoulders Display:900, '
+        + 'Encode Sans Condensed:900, Fjalla One:400, Khand:700, League Gothic:400, Mohave:700, Oswald:700, Pathway Gothic One:400, '
+        + 'Saira Condensed:900, Six Caps:400, Smooch Sans:900, Sofia Sans Condensed:900, Staatliches:400, Teko:700',
+    display: 'Alfa Slab One:400, Anybody:900, Archivo Black:400, Archivo:900, Black Ops One:400, Bricolage Grotesque:800, '
+        + 'Chakra Petch:700, Chivo:900, Darker Grotesque:900, Epilogue:900, Exo 2:900, Familjen Grotesk:700, Funnel Display:800, '
+        + 'Gabarito:900, Lexend:900, Mona Sans:900, Passion One:900, Red Hat Display:900, Righteous:400, Rubik:900, Russo One:400, '
+        + 'Schibsted Grotesk:900, Shrikhand:400, Urbanist:900, Wix Madefor Display:800',
+    larga: 'Audiowide:400, Bagel Fat One:400, Bowlby One:400, Bungee Shade:400, Bungee:400, Dela Gothic One:400, Krona One:400, '
+        + 'Lexend Zetta:900, Michroma:400, Monoton:400, Orbitron:900, Press Start 2P:400, Rubik Mono One:400, Silkscreen:700, Syne:800, Ultra:400',
+    texto: 'Afacad:700, Albert Sans:900, Barlow:900, Be Vietnam Pro:900, Figtree:900, Funnel Sans:800, Golos Text:900, '
+        + 'Hanken Grotesk:900, Host Grotesk:800, Instrument Sans:700, Karla:800, Onest:900, Public Sans:900, Reddit Sans:900, '
+        + 'Rethink Sans:800, Sofia Sans:900, Work Sans:900',
+    serifa: 'Abril Fatface:400, Arvo:700, Bitter:900, Bodoni Moda:900, Caprasimo:400, Cormorant Garamond:700, Crimson Pro:900, '
+        + 'DM Serif Display:400, EB Garamond:800, Fraunces:900, Gloock:400, Instrument Serif:400, Libre Baskerville:700, '
+        + 'Libre Bodoni:700, Libre Caslon Display:400, Literata:900, Lora:700, Merriweather:900, Newsreader:800, Playfair Display:900, '
+        + 'Prata:400, Roboto Slab:900, Rozha One:400, Source Serif 4:900, Spectral:800, Yeseva One:400, Young Serif:400, Zilla Slab:700',
+    manuscrita: 'Caveat:700, Gloria Hallelujah:400, Kalam:700, Lobster:400, Marck Script:400, Nanum Pen Script:400, Pacifico:400, '
+        + 'Permanent Marker:400, Rock Salt:400, Satisfy:400, Shadows Into Light:400, Yellowtail:400',
+    mono: 'Azeret Mono:900, DM Mono:400, Fragment Mono:400, Geist Mono:900, IBM Plex Mono:700, JetBrains Mono:800, '
+        + 'Major Mono Display:400, Martian Mono:800, Red Hat Mono:700, Space Mono:700, VT323:400',
+};
+const FONTES = Object.entries(TIPOS).flatMap(([tipo, lista]) => lista.split(', ').map((x) => {
+    const [nome, peso] = x.split(':');
+    return { nome, tipo, peso: Number(peso) };
+}));
+
+/* A largura média do caractere, em "em", por tipo — o caber() de
+   composicao.js usa para escolher o tamanho. A larga é a que estoura a borda. */
+const LARGURA = { condensada: 0.46, display: 0.6, larga: 0.74, texto: 0.58, serifa: 0.55, manuscrita: 0.52, mono: 0.62 };
+const larguraDe = (fonte) => { const f = acharFonte(fonte); return f ? LARGURA[f.tipo] : null; };
+
+/* O título é caixa alta grossa: fonte de texto fina demais não serve. O
+   texto (etiquetas, nomes) é qualquer uma que se lê pequena. */
+const TITULO = FONTES.filter((f) => ['condensada', 'display', 'larga'].includes(f.tipo) || (f.tipo === 'serifa' && f.peso >= 800)
+    || (f.tipo === 'texto' && f.peso >= 900));
+const TEXTO = FONTES.filter((f) => ['texto', 'mono'].includes(f.tipo) || (f.tipo === 'serifa' && f.peso >= 700) || (f.tipo === 'display' && f.peso >= 800));
+
+// ── as paletas: fundo escuro e as duas cores do gradiente ────────────────
+/* O cinema é escuro (o texto é branco), então todo fundo é escuro. Nada do
+   violeta de SaaS nem do neon: é o que denuncia vídeo feito por IA. */
+const BASES = [
+    ['brasa', '#120B08', '#FF5A1F', '#FFB23F'], ['ferrugem', '#15100D', '#C8553D', '#F2A65A'], ['mata', '#0B1410', '#2BB673', '#D8F05A'],
+    ['oceano', '#071219', '#1E88E5', '#4FD1C5'], ['tijolo', '#170C0B', '#E2583E', '#F6D6AD'], ['limao', '#0E100A', '#C6F432', '#F4F1E8'],
+    ['cobre', '#120E0C', '#D9822B', '#F3C98B'], ['sangue', '#100607', '#E5383B', '#FF9F1C'], ['musgo', '#0F120C', '#8DB255', '#E9C46A'],
+    ['gelo', '#0A0F14', '#8EC5FF', '#F1F7FF'], ['sol-de-inverno', '#0D0D10', '#FFC93C', '#FF6B35'], ['cereja', '#14080B', '#FF4D6D', '#FFC2D1'],
+    ['jade', '#06120F', '#00A878', '#9BE564'], ['areia', '#13110D', '#E9C46A', '#F4A261'], ['safira', '#070B16', '#2F6BFF', '#7FB2FF'],
+    ['tangerina', '#110A06', '#FF7A00', '#FFD166'], ['pistache', '#0C110D', '#93C572', '#F0EAD6'], ['vinho', '#13070C', '#D1495B', '#FCB9B2'],
+    ['petroleo', '#061214', '#0F9D9A', '#F2C14E'], ['ouro-velho', '#0F0D08', '#C9A227', '#F5E6B3'], ['coral', '#120A0A', '#FF6F59', '#FFD6A5'],
+    ['asfalto', '#0E0F10', '#FF3B30', '#FFFFFF'], ['menta', '#08110E', '#3DDC97', '#E8FFF4'], ['lava', '#0F0705', '#FF3D00', '#FFB300'],
+    ['ceu', '#08101A', '#56C3E8', '#F7F7F7'], ['terracota', '#140D0A', '#CB6843', '#EBD4B4'], ['abacate', '#0D100A', '#A3B18A', '#DAD7CD'],
+    ['neve-e-fogo', '#0B0B0E', '#FFFFFF', '#FF4F00'], ['framboesa', '#12070D', '#E0245E', '#FFB3C6'], ['cacau', '#120D0A', '#A47148', '#F2D0A9'],
+    ['esmeralda', '#04110B', '#10B981', '#FDE68A'], ['aco', '#0C0E11', '#9DB4C0', '#E0E1DD'], ['acafrao', '#110D05', '#F4B400', '#FF6D00'],
+    ['lagoa', '#051214', '#48CAE4', '#CAF0F8'], ['papoula', '#110808', '#F94144', '#F9C74F'], ['oliva', '#0F0F09', '#B5A642', '#F1E9C9'],
+    ['ardosia', '#0D1014', '#FF8C42', '#E8EEF2'], ['tinta-e-rosa', '#0E0B0C', '#FF8FAB', '#FFE5EC'], ['hortela-e-ouro', '#08120F', '#52B788', '#F6C453'],
+    ['noite-azul', '#060A12', '#3A86FF', '#FFBE0B'], ['cinzas', '#101010', '#D9D9D9', '#FF5F1F'], ['pessego', '#120C0A', '#FFAD87', '#FFE3D3'],
+    ['floresta', '#07100A', '#40916C', '#B7E4C7'], ['rubi', '#10060A', '#EF233C', '#EDF2F4'], ['mostarda', '#100E06', '#E1AD01', '#F6F1D1'],
+    ['turquesa', '#061111', '#2EC4B6', '#FFBF69'], ['caramelo', '#120C07', '#DDA15E', '#FEFAE0'], ['grafite-limao', '#0F1011', '#D4FF3A', '#F2F2F2'],
+    ['alvorada', '#0D0A0C', '#FF9E00', '#FF4D6D'], ['tempestade', '#0A0D10', '#6C9BD2', '#F2E8CF'],
+];
+
+function rgb(hex) { const n = parseInt(String(hex).slice(1), 16); return [n >> 16 & 255, n >> 8 & 255, n & 255]; }
+const hex = (c) => '#' + c.map((v) => Math.max(0, Math.min(255, Math.round(v))).toString(16).padStart(2, '0')).join('').toUpperCase();
+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; };
+
+/* Cada base vira quatro: como veio, o gradiente invertido, o fundo tingido
+   da cor principal e a monocromática (a cor e ela mais clara). */
+const PALETAS = BASES.flatMap(([nome, fundo, a, b]) => [
+    { nome, base: nome, fundo, grad: [a, b] },
+    { nome: `${nome}-invertida`, base: nome, fundo, grad: [b, a] },
+    { nome: `${nome}-tingida`, base: nome, fundo: misturar(fundo, a, 0.1), grad: [a, b] },
+    { nome: `${nome}-mono`, base: nome, fundo, grad: [a, misturar(a, '#FFFFFF', 0.45)] },
+]);
+
+// ── a memória: o que os últimos vídeos já usaram ─────────────────────────
+const ARQ = path.join(os.homedir(), '.primocode', 'studio', 'biblioteca-usada.json');
+const LEMBRA = { titulo: 15, texto: 8, paleta: 20 };   // paleta conta pela base: "brasa-mono" depois de "brasa" é repetir
+
+function lerMemoria(arq = ARQ) {
+    try { const m = JSON.parse(fs.readFileSync(arq, 'utf8')); return { titulo: [], texto: [], paleta: [], ...m }; }
+    catch { return { titulo: [], texto: [], paleta: [] }; }
+}
+function gravarMemoria(m, arq = ARQ) {
+    try { fs.mkdirSync(path.dirname(arq), { recursive: true }); fs.writeFileSync(arq, JSON.stringify(m)); } catch { /* sem memória, só sorteio */ }
+}
+
+const norm = (s) => String(s || '').normalize('NFD').replace(/[̀-ͯ]/g, '').toLowerCase().trim();
+function acharFonte(nome) { const n = norm(nome); return FONTES.find((f) => norm(f.nome) === n) || null; }
+function acharPaleta(nome) { const n = norm(nome).replace(/\s+/g, '-'); return PALETAS.find((p) => p.nome === n) || null; }
+
+/* O CASAMENTO DA FONTE COM O ROTEIRO (07/10): "a IA deve escolher fontes e
+   combinações de acordo com assunto, tom, público e ritmo" (Joel). Antes eram
+   dois sorteios independentes. Agora:
+   - o CLIMA do roteiro (o mesmo que escolhe a trilha, variedade.climaDe) diz
+     quanto cada tipo de título serve (0 a 1);
+   - o tipo do título diz que tipo de texto faz par com ele (contraste, não
+     duas fontes que brigam);
+   - a memória penaliza o recente pela distância, não corta: o que serve ao
+     tom ganha do que só é novo (os pontos de variedade.js). */
+const TOM_DO_TITULO = {
+    tecnologia: { display: 1, larga: 0.9, condensada: 0.6, texto: 0.7, serifa: 0.2 },
+    energetico: { condensada: 1, display: 0.9, larga: 0.6, texto: 0.5, serifa: 0.2 },
+    epico: { condensada: 1, serifa: 0.8, display: 0.6, larga: 0.5, texto: 0.3 },
+    calmo: { serifa: 1, texto: 0.9, display: 0.5, condensada: 0.3, larga: 0.2 },
+    alegre: { display: 1, larga: 0.8, texto: 0.6, condensada: 0.4, serifa: 0.4 },
+    emocional: { serifa: 1, texto: 0.7, display: 0.5, condensada: 0.4, larga: 0.2 },
+    misterio: { condensada: 0.9, serifa: 0.9, larga: 0.6, display: 0.5, texto: 0.4 },
+};
+// O par do texto, pelo tipo do título: o contraste que funciona.
+const PAR_DO_TEXTO = {
+    condensada: { texto: 1, mono: 0.8, serifa: 0.6, display: 0.4 },
+    display: { texto: 1, serifa: 0.7, mono: 0.6, display: 0.2 },
+    larga: { mono: 1, texto: 0.9, serifa: 0.4, display: 0.2 },
+    serifa: { texto: 1, mono: 0.7, display: 0.5, serifa: 0.3 },
+    texto: { serifa: 1, mono: 0.9, texto: 0.3, display: 0.5 },
+};
+
+/** O tom do roteiro para a fonte: o clima (variedade.climaDe). Neutro serve tudo igual. */
+function tomDe(roteiro, estilo = '') { return require('./variedade.js').climaDe(roteiro || {}, estilo); }
+
+/* A escolha por pontos: 2 × adequação − recência (1 para o último usado,
+   metade a cada quarto da memória). Entre os quase empatados, sorteia. */
+function escolher(lista, recentes, chave, sorte, adequa = () => 1, lembra = 10) {
+    const meia = Math.max(1, lembra / 4);
+    const pts = lista.map((x) => {
+        const pos = recentes.indexOf(chave(x));
+        return { x, p: 2 * adequa(x) - (pos < 0 ? 0 : Math.pow(0.5, pos / meia)) };
+    });
+    const melhor = Math.max(...pts.map((q) => q.p));
+    const quase = pts.filter((q) => q.p >= melhor - 0.05).map((q) => q.x);
+    return quase[Math.floor(sorte() * quase.length) % quase.length];
+}
+
+/**
+ * Escolhe fonte e paleta para o roteiro e as põe em roteiro.marca, sem
+ * trocar nada que a marca já tem. Devolve o que escolheu e de onde veio.
+ * memoria: null não lê nem grava o disco (os testes); sorte: () => [0,1).
+ */
+function vestir(roteiro, { memoria = ARQ, sorte = Math.random, estilo = '' } = {}) {
+    if (!roteiro || typeof roteiro !== 'object') return { mudou: false };
+    const marca = roteiro.marca || {};
+    const cores = marca.cores || {};
+    const visual = roteiro.visual || {};
+    const mem = memoria ? lerMemoria(memoria) : { titulo: [], texto: [], paleta: [] };
+    const escolha = { mudou: false };
+
+    if (!(marca.fontes && marca.fontes.titulo)) {
+        // A IA escolheu pelo nome: vale qualquer família do Google Fonts, mesmo fora do cardápio.
+        const tom = TOM_DO_TITULO[tomDe(roteiro, estilo)] || null;
+        const titulo = visual.titulo ? String(visual.titulo)
+            : escolher(TITULO, mem.titulo, (f) => f.nome, sorte, (f) => (tom ? tom[f.tipo] ?? 0.3 : 1), LEMBRA.titulo).nome;
+        const tipoTitulo = (acharFonte(titulo) || {}).tipo;
+        const par = PAR_DO_TEXTO[tipoTitulo] || null;
+        const textoLista = TEXTO.filter((f) => f.nome !== titulo);
+        const texto = visual.texto ? String(visual.texto)
+            : escolher(textoLista, mem.texto, (f) => f.nome, sorte, (f) => (par ? par[f.tipo] ?? 0.2 : 1), LEMBRA.texto).nome;
+        marca.fontes = { ...(marca.fontes || {}), titulo, texto };
+        mem.titulo = [titulo, ...mem.titulo.filter((x) => x !== titulo)].slice(0, LEMBRA.titulo);
+        mem.texto = [texto, ...mem.texto.filter((x) => x !== texto)].slice(0, LEMBRA.texto);
+        Object.assign(escolha, { mudou: true, titulo, texto, fonteDaIA: !!visual.titulo, tom: tomDe(roteiro, estilo) });
+    }
+    // A cor da marca manda: com destaque ou gradiente declarado, a paleta não entra.
+    if (!(marca.gradiente && marca.gradiente.length >= 2) && !cores.destaque) {
+        const p = acharPaleta(visual.paleta) || escolher(PALETAS, mem.paleta, (x) => x.base, sorte, () => 1, LEMBRA.paleta);
+        marca.gradiente = [...p.grad];
+        marca.cores = { ...cores, fundo: cores.fundo || p.fundo, destaque: p.grad[1], apoio: p.grad[0] };
+        mem.paleta = [p.base, ...mem.paleta.filter((x) => x !== p.base)].slice(0, LEMBRA.paleta);
+        Object.assign(escolha, { mudou: true, paleta: p.nome, paletaDaIA: !!acharPaleta(visual.paleta) });
+    }
+    if (escolha.mudou) {
+        roteiro.marca = marca;
+        if (memoria) gravarMemoria(mem, memoria);
+    }
+    return escolha;
+}
+
+/** O cardápio para a IA: nomes por tipo, e as paletas pela base. */
+function cardapio() {
+    const porTipo = {};
+    for (const f of FONTES) (porTipo[f.tipo] = porTipo[f.tipo] || []).push(f.nome);
+    return {
+        fontes: porTipo,
+        paletas: BASES.map(([nome, fundo, a, b]) => `${nome} ${fundo} ${a} ${b}`),
+        variacoes: 'cada paleta também vem -invertida, -tingida e -mono (ex.: "brasa-mono")',
+        uso: 'roteiro.visual = {titulo, texto, paleta}. Sem visual, o PrimoCode sorteia e não repete os últimos vídeos.',
+    };
+}
+
+module.exports = { vestir, cardapio, tomDe, TOM_DO_TITULO, PAR_DO_TEXTO, larguraDe, acharFonte, acharPaleta, FONTES, PALETAS, BASES, TITULO, TEXTO, luz, ARQ };

package/lib/estudio/cinema.js

@@ -27,6 +27,7 @@
 'use strict';
 
 const { caber } = require('./composicao.js');
+const { minimoLeitura, sobra } = require('./legibilidade.js');
 
 const r2 = (n) => Math.round(n * 100) / 100;
 const tokens = (t) => String(t || '').normalize('NFD').replace(/[̀-ͯ]/g, '').toLowerCase().split(/[^a-z0-9]+/).filter(Boolean);
@@ -34,6 +35,7 @@ const tokens = (t) => String(t || '').normalize('NFD').replace(/[̀-ͯ]/g, '').t
 /** Quanto tempo um texto precisa ficar na tela para ser lido. Nunca menos que
     0,3 s por palavra: a regra de legibilidade do /brag (Arthur, 28/09). */
 const nPalavras = (t) => String(t || '').split(/\s+/).filter(Boolean).length;
+const SAIDA_MIN = 0.1, ENTRA_NUM = 0.4;   // a saída mais curta; o número contando antes de ser lido
 const leituraCheia = (t) => Math.max(0.55 + 0.22 * nPalavras(t), 0.3 * nPalavras(t));
 
 /** A fala desta parte (o que a voz diz): a "fala", ou os textos da tela. */
@@ -113,7 +115,7 @@ function montarCinema({ roteiro, largura = 1920, altura = 1080, tempos = [], nar
     const PRETO = fundoMarca && luz(fundoMarca) < 0.25 ? fundoMarca : '#07070A';
     const BRANCO = '#F5F5F7';
     const DEST = grad[1];
-    const F = { titulo: (marca.fontes && marca.fontes.titulo) || 'Inter', texto: (marca.fontes && marca.fontes.texto) || 'Inter' };
+    const F = { titulo: (marca.fontes && marca.fontes.titulo) || 'Inter', texto: (marca.fontes && marca.fontes.texto) || 'Inter', destaque: 'Instrument Serif' };
     const W = largura, H = altura, deitado = W >= H;
     const M = Math.round(Math.min(W, H) * 0.08), W0 = W - 2 * M;
     const base = Math.min(W, H);
@@ -180,26 +182,36 @@ function montarCinema({ roteiro, largura = 1920, altura = 1080, tempos = [], nar
             fundo: { tipo: 'gradiente', cores: [`rgba(7,7,10,${veu * 0.7})`, `rgba(7,7,10,${veu})`, `rgba(7,7,10,${Math.min(0.95, veu + 0.25)})`], angulo: 180 } });
     };
     // O texto: entra palavra por palavra no tempo da voz e fica; as palavras marcadas no gradiente.
-    const pTexto = (els, texto, de, ate, { y = null, max = deitado ? H * 0.11 : W * 0.13, linhas = 3, peso = 700, caixa = true, marcar = [], cor = BRANCO, pal = [], alinhar = 'center', x = M, larg = W0, bater = false } = {}) => {
+    /* SEM CARA DE IA (05/10): o texto sai como a pessoa escreveu (nada de caixa
+       alta forçada), um pouco menor e com mais respiro — e a palavra marcada é
+       UM acento, na serifa em itálico. Caixa alta só com "caixa: true". */
+    const pTexto = (els, texto, de, ate, { y = null, max = deitado ? H * 0.11 : W * 0.13, linhas = 3, peso = 700, caixa = false, marcar = [], cor = BRANCO, pal = [], alinhar = 'center', x = M, larg = W0, bater = false } = {}) => {
+        max *= 0.85; peso = Math.min(peso, 700);
         // Frase longa (a narração na tela) vai em letra normal: em caixa alta ela encolhe e cansa.
-        if (caixa && String(texto).split(/\s+/).length > 7) { caixa = false; peso = Math.min(peso, 700); }
+        if (caixa && String(texto).split(/\s+/).length > 7) caixa = false;
         // Frase longa ganha linhas (no vertical, até 5), para a letra não encolher.
         if (String(texto).split(/\s+/).length > 7) linhas = Math.max(linhas, deitado ? 4 : 5);
         const txt = caixa ? String(texto).toUpperCase() : String(texto);
-        const fit = caber(txt, { largura: larg * 0.86, linhas, max, fonte: F.titulo });
-        const h = fit.tamanho * 1.08 * fit.linhas;
+        const fit = caber(txt, { largura: larg * 0.78, linhas, max, fonte: F.titulo });
+        const h = fit.tamanho * 1.14 * fit.linhas;
         const ws = txt.split(/\s+/);
         /* Centralizado, a linha entra inteira: palavra por palavra, as que ainda
            não foram ditas ocupam espaço invisível e o começo da frase aparece
            torto, puxado para a esquerda. Alinhado à esquerda, palavra por palavra. */
         const rev = ws.map((_, k) => (alinhar === 'center' ? 0 : r2(Math.max(0, (pal[k] != null ? pal[k] : de + 0.08 * k) - de))));
-        const idx = ws.map((w, k) => (marcar.some((m) => tokens(w)[0] && tokens(m).includes(tokens(w)[0])) ? k : -1)).filter((k) => k >= 0);
-        els.push({ tipo: 'texto', texto: txt, fonte: F.titulo, peso, tamanho: fit.tamanho, cor, entrelinha: 1.08, espacamento: caixa ? 1 : 0,
+        // Uma palavra só, e só em frase de mais de uma palavra (a palavra sozinha não tem com quem contrastar).
+        const idx = ws.length < 2 ? [] : ws.map((w, k) => (marcar.some((m) => tokens(w)[0] && tokens(m).includes(tokens(w)[0])) ? k : -1)).filter((k) => k >= 0).slice(0, 1);
+        /* Entra rápido, FICA parado o tempo de ler, e só então sai (a lei do
+           /brag). Cena curta encolhe a entrada e a saída, nunca a leitura. */
+        const vida = ate - de, ler = minimoLeitura(txt);
+        const ent = bater ? sobra(vida - SAIDA_MIN, ler, 0.08, 0.22) : 0, fe = ent / 0.22;
+        const saida = r2(sobra(vida - ent, ler, SAIDA_MIN, 0.25));
+        els.push({ tipo: 'texto', texto: txt, fonte: F.titulo, peso, tamanho: fit.tamanho, cor, entrelinha: 1.14, espacamento: caixa ? 1 : -0.5,
             x: Math.round(x), y: Math.round(y == null ? (H - h) / 2 : y), largura: Math.round(larg), alinhamento: alinhar, de: r2(de), ate: r2(ate),
-            revelar: rev, ...(idx.length ? { destaques: idx, corDestaque: DEST } : {}),
-            anima: { opacidade: [{ t: 0, v: 1 }, { t: Math.max(0.01, ate - de - 0.25), v: 1 }, { t: ate - de, v: 0 }], y: [{ t: 0, v: 10 }, { t: ate - de, v: -6, e: 'linear' }],
+            revelar: rev, ...(idx.length ? { destaques: idx, corDestaque: DEST, fonteDestaque: F.destaque } : {}),
+            anima: { opacidade: [{ t: 0, v: 1 }, { t: r2(Math.max(0.01, vida - saida)), v: 1 }, { t: r2(vida), v: 0 }], y: [{ t: 0, v: 10 }, { t: ate - de, v: -6, e: 'linear' }],
                 // O texto que BATE no fundo: entra grande e assenta de uma vez.
-                ...(bater ? { escala: [{ t: 0, v: 1.35 }, { t: 0.12, v: 0.97, e: 'saida' }, { t: 0.22, v: 1 }] } : {}) } });
+                ...(bater ? { escala: [{ t: 0, v: 1.35 }, { t: r2(0.12 * fe), v: 0.97, e: 'saida' }, { t: r2(ent), v: 1 }] } : {}) } });
         return h;
     };
     const linhaFina = (els, y, de, larg = W * 0.18) => els.push({ tipo: 'forma', forma: 'retangulo', x: Math.round((W - larg) / 2), y: Math.round(y), largura: Math.round(larg), altura: 2,
@@ -242,9 +254,14 @@ function montarCinema({ roteiro, largura = 1920, altura = 1080, tempos = [], nar
            com a voz é bom, ler é obrigatório. Se a leitura pede mais que a fala,
            a cena cresce (medido: "EDIÇÕES" ficava meio segundo na tela). */
         // Texto curto (um número, "3 DIAS.") se lê de relance: não espera a leitura cheia e não atrasa a voz.
-        const minimo = (x) => Math.max(0.3 * nPalavras(x), Math.min(leitura(x), nPalavras(x) <= 3 ? 0.75 : 1.6));
-        for (let k = 1; k < inicios.length; k++) inicios[k] = r2(Math.max(inicios[k], inicios[k - 1] + minimo(textosDaParte[k - 1])));
-        if (inicios.length) dur = r2(Math.max(dur, inicios[inicios.length - 1] + leitura(textosDaParte[inicios.length - 1]) + 0.3));
+        /* E nunca menos que a lei do /brag (0,8 s parado) mais a saída mínima; o
+           número ainda conta antes de ser lido (ENTRA_NUM). */
+        const minimo = (x) => Math.max(minimoLeitura(x) + SAIDA_MIN, Math.min(leitura(x), nPalavras(x) <= 3 ? 0.75 : 1.6)) + (p.tipo === 'numeros' ? ENTRA_NUM : 0);
+        const espacar = (passo = 0) => {
+            for (let k = 1; k < inicios.length; k++) inicios[k] = r2(Math.max(inicios[k], inicios[k - 1] + Math.max(passo, minimo(textosDaParte[k - 1]))));
+            if (inicios.length) dur = r2(Math.max(dur, inicios[inicios.length - 1] + Math.max(leitura(textosDaParte[inicios.length - 1]), minimo(textosDaParte[inicios.length - 1])) + 0.3));
+        };
+        espacar();
         const fimDe = (k) => (k < inicios.length - 1 ? inicios[k + 1] : dur);
         const palDo = (txt) => { const ws = String(txt).split(/\s+/); const a = pals.findIndex((w) => tokens(w.texto)[0] === tokens(ws[0])[0]); return a < 0 ? [] : ws.map((_, k) => (pals[a + k] ? rel(pals[a + k].de) : null)); };
 
@@ -256,11 +273,13 @@ function montarCinema({ roteiro, largura = 1920, altura = 1080, tempos = [], nar
             const rap = p.tipo === 'climax' ? 0.38 : (p.ritmo || 0.75);
             let fimFotos = p.tipo === 'climax' && textosDaParte.length ? Math.max(1.8, inicios[0] - 0.4) : dur;
             const fz = p.tipo === 'climax' ? fortes[i] : null;
+            // A virada começa quando as fotos acabam: o texto não perde a leitura para a montagem.
+            if (p.tipo === 'climax' && !fz && inicios.length) { inicios[0] = r2(Math.max(inicios[0], fimFotos)); espacar(1.2); }
             if (fz) {
                 /* A voz forte entra DEPOIS da montagem, junto com o texto que bate. */
                 fimFotos = 1.4;
                 const ini2 = quando(textosDaParte, (fz.palavras || []).map((w) => ({ ...w, de: w.de + fimFotos })), fz.segundos, fimFotos);
-                ini2.forEach((v0, k) => { inicios[k] = k === 0 ? fimFotos : Math.max(v0, inicios[k - 1] + 1.2); });
+                ini2.forEach((v0, k) => { inicios[k] = k === 0 ? fimFotos : Math.max(v0, inicios[k - 1] + Math.max(1.2, minimo(textosDaParte[k - 1]))); });
                 dur = r2(Math.max(fimFotos + fz.segundos + 0.5, inicios[inicios.length - 1] + 1.6));
                 const tr = trechos[trechos.length - 1];
                 if (tr && tr.src === fz.src) tr.t = r2(t + fimFotos - 0.05);
@@ -301,9 +320,10 @@ function montarCinema({ roteiro, largura = 1920, altura = 1080, tempos = [], nar
                 const larguraNum = String(mv[1] + m[1] + mv[3]).length * 0.8;   // serifa larga: 0,62 ainda quebrava
                 const tam = Math.round(Math.min(deitado ? H * 0.24 : W * 0.3, (W0 * 0.96) / Math.max(1, larguraNum)));
                 const casas = /[.,]/.test(m[1]) ? 1 : 0;
+                const entN = r2(sobra(fimDe(k) - inicios[k], minimoLeitura(m[1]), 0.3, 0.6));
                 els.push({ tipo: 'texto', texto: mv[1] + m[1] + mv[3], fonte: F.titulo, peso: 800, tamanho: tam, cor: BRANCO, x: M, y: Math.round(H * 0.5 - tam * 0.75), largura: W0, alinhamento: 'center',
-                    de: inicios[k], ate: fimDe(k), contar: { ate: Number(m[1].replace(',', '.')), dur: 0.6, casas, antes: mv[1].toUpperCase(), depois: mv[3] }, gradienteTexto: undefined,
-                    anima: { opacidade: [{ t: 0, v: 0 }, { t: 0.25, v: 1 }], escala: [{ t: 0, v: 0.92 }, { t: 0.6, v: 1, e: 'saida' }] } });
+                    de: inicios[k], ate: fimDe(k), contar: { ate: Number(m[1].replace(',', '.')), dur: entN, casas, antes: mv[1].toUpperCase(), depois: mv[3] }, gradienteTexto: undefined,
+                    anima: { opacidade: [{ t: 0, v: 0 }, { t: Math.min(0.25, entN), v: 1 }], escala: [{ t: 0, v: 0.92 }, { t: entN, v: 1, e: 'saida' }] } });
                 pTexto(els, m[2], inicios[k] + 0.1, fimDe(k), { y: H * 0.5 + tam * 0.3, max: base * 0.085, peso: 700, cor: DEST });
             });
         } else if (p.tipo === 'escada') {
@@ -330,7 +350,7 @@ function montarCinema({ roteiro, largura = 1920, altura = 1080, tempos = [], nar
             pFoto(els, foto(), 0, dur, { veu: 0.66, entrada: 'suave' });
             som(t, 'whoosh', 0.3);
             const tamN = Math.round(deitado ? H * 0.34 : W * 0.42);
-            els.push({ tipo: 'texto', texto: String(p.num), fonte: F.titulo, peso: 800, tamanho: tamN, cor: 'rgba(149,103,219,0.12)', contorno: `${Math.max(3, Math.round(base * 0.004))}px ${DEST}`,
+            els.push({ tipo: 'texto', texto: String(p.num), fonte: F.titulo, peso: 800, tamanho: tamN, cor: `${DEST}1F`, contorno: `${Math.max(3, Math.round(base * 0.004))}px ${DEST}`,
                 x: M, y: Math.round(deitado ? H * 0.12 : H * 0.14), largura: W0, alinhamento: deitado ? 'left' : 'center',
                 anima: { opacidade: [{ t: 0, v: 0 }, { t: 0.6, v: 1 }], x: [{ t: 0, v: -20 }, { t: dur, v: 20, e: 'linear' }] } });
             const yT = deitado ? H * 0.5 : H * 0.42;

package/lib/estudio/composicao.js

@@ -71,7 +71,8 @@ const FAMILIA_TIPO = (f) => (/condensed|narrow|anton|oswald|bebas|teko|league go
         : /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)];
+    // A fonte da biblioteca sabe a própria largura; a de fora, pelo nome.
+    const cw = require('./biblioteca.js').larguraDe(fonte) || 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á.

package/lib/estudio/decisao.js

@@ -0,0 +1,106 @@
+/**
+ * decisao.js — o que cada frase da edição pede: movimento, recorte, som — ou
+ * nada, e a cena respira.
+ *
+ *   "Não quero simplesmente adicionar efeitos. Quero melhorar a decisão de
+ *    edição. Nem todo momento precisa de movimento, transição ou efeito. Às
+ *    vezes a melhor decisão é deixar a cena respirar." (Joel, 07/10)
+ *
+ * Antes a edição era um rodízio: zoom por `i % 3`, a pessoa recortada em
+ * `i % 4 === 2`, whoosh em `i % 3 === 1`. A frase mais forte do vídeo podia
+ * cair num "parado", e uma frase de ligação ganhava o soco. Aqui:
+ *   1. INTENSIDADE (0 a 1) de cada frase: a palavra mais forte, número,
+ *      exclamação e pergunta, frase curta de efeito, a pausa antes dela (o
+ *      silêncio prepara o golpe), o gancho do começo e o fecho;
+ *   2. MOVIMENTO pela intensidade, com três regras de editor: o golpe é raro
+ *      (no máximo ~1 em 3 frases), depois do golpe vem um respiro, e o mesmo
+ *      movimento não se repete em seguida;
+ *   3. o RECORTE (a pessoa na frente da palavra gigante) vai para as frases
+ *      mais fortes, longe uma da outra; o WHOOSH só anuncia o soco.
+ * Puro: frases entram, decisões saem. `aleatorio` decide os empates.
+ */
+
+'use strict';
+
+const r2 = (n) => Math.round(n * 100) / 100;
+const limpa = (t) => String(t || '').toLowerCase().normalize('NFD').replace(/[̀-ͯ]/g, '').replace(/[^a-z0-9%]/g, '');
+
+/* Os movimentos de câmera (zoom em quadros-chave, no tempo da cena):
+     parado      nada — a cena respira
+     empurra     aproxima devagar (tensão que cresce)
+     soco        entra já fechado e segura (o golpe)
+     recua       abre devagar (alívio, conclusão)
+     reenquadra  fecha num ponto fora do centro (mudança de assunto)  */
+const MOVIMENTOS = {
+    parado: () => ({ zoom: [{ t: 0, v: 1.0 }, { t: 1, v: 1.0 }] }),
+    empurra: (d, k) => ({ zoom: [{ t: 0, v: 1.0 }, { t: d, v: r2(1.04 + 0.06 * k), e: 'linear' }] }),
+    soco: (d, k) => ({ zoom: [{ t: 0, v: r2(1.14 + 0.08 * k) }, { t: d, v: r2(1.17 + 0.08 * k), e: 'linear' }] }),
+    recua: (d, k) => ({ zoom: [{ t: 0, v: r2(1.1 + 0.05 * k) }, { t: d, v: 1.02, e: 'suave' }] }),
+    // O x é em px: 3,5% do lado menor cabe na sobra de um zoom de 1,12.
+    reenquadra: (d, k, lado, base = 1080) => ({ zoom: [{ t: 0, v: r2(1.12 + 0.04 * k) }, { t: d, v: r2(1.15 + 0.04 * k), e: 'suave' }],
+        x: [{ t: 0, v: Math.round((lado ? 1 : -1) * base * 0.03) }, { t: d, v: Math.round((lado ? 1 : -1) * base * 0.035), e: 'suave' }] }),
+};
+
+/** A intensidade de cada frase (lista de palavras {de, ate, texto}), de 0 a 1. */
+function intensidades(grupos, peso = (w) => limpa(w).length) {
+    const n = grupos.length;
+    const brutos = grupos.map((g, i) => {
+        const texto = g.map((p) => p.texto).join(' ');
+        const forte = Math.max(0, ...g.map((p) => peso(p.texto)));
+        let s = Math.min(1, forte / 14) * 0.45;
+        if (/\d/.test(texto)) s += 0.2;
+        if (/!/.test(texto)) s += 0.2;
+        if (/\?/.test(texto)) s += 0.1;
+        if (g.length <= 4) s += 0.15;                                    // frase curta é frase de efeito
+        const pausa = i > 0 ? g[0].de - grupos[i - 1][grupos[i - 1].length - 1].ate : 0;
+        if (pausa > 0.45) s += Math.min(0.2, pausa * 0.25);              // o silêncio prepara o golpe
+        if (i === 0) s += 0.15;                                          // o gancho
+        if (i === n - 1) s += 0.1;                                       // o fecho
+        return s;
+    });
+    const max = Math.max(...brutos, 1e-9), min = Math.min(...brutos);
+    return brutos.map((s) => r2(max - min < 1e-6 ? 0.5 : (s - min) / (max - min)));
+}
+
+/**
+ * As decisões da edição: uma por frase.
+ * @returns {Array<{intensidade:number, movimento:string, recorte:boolean, whoosh:boolean}>}
+ */
+function decidir(grupos, { peso, aleatorio = Math.random, maxRecortes = 3 } = {}) {
+    const ints = intensidades(grupos, peso);
+    const n = ints.length;
+    // O golpe é raro: só as frases do terço de cima (pelo menos 1, no máximo n/3).
+    const ordem = [...ints.keys()].sort((a, b) => ints[b] - ints[a]);
+    const golpes = new Set(ordem.slice(0, Math.max(1, Math.floor(n / 3))).filter((i) => ints[i] >= 0.6 || i === ordem[0]));
+    const out = [];
+    for (let i = 0; i < n; i++) {
+        const ant = out[i - 1];
+        let mov;
+        if (golpes.has(i) && !(ant && ant.movimento === 'soco')) mov = 'soco';
+        else if (ant && ant.movimento === 'soco') mov = 'parado';     // depois do golpe, respira
+        else if (i === n - 1) mov = ints[i] > 0.4 ? 'recua' : 'parado';
+        else {
+            // O resto pelo que a frase pede, sem repetir o anterior.
+            const pede = ints[i] > 0.45 ? ['reenquadra', 'empurra'] : ints[i] > 0.2 ? ['empurra', 'parado', 'reenquadra'] : ['parado', 'empurra'];
+            const opcoes = pede.filter((m) => !ant || m !== ant.movimento);
+            mov = opcoes[Math.floor(aleatorio() * Math.min(2, opcoes.length)) % opcoes.length];
+        }
+        out.push({ intensidade: ints[i], movimento: mov, recorte: false, whoosh: mov === 'soco' && i > 0 });
+    }
+    // O recorte: as frases mais fortes, com pelo menos 3 frases entre um e outro.
+    const escolhidos = [];
+    for (const i of ordem) {
+        if (escolhidos.length >= maxRecortes || ints[i] < 0.5) break;
+        if (i === 0 || escolhidos.some((j) => Math.abs(j - i) < 3)) continue;
+        escolhidos.push(i);
+        out[i].recorte = true;
+    }
+    return out;
+}
+
+/** A câmera da cena para o movimento decidido. `lado` alterna o reenquadramento. */
+function camera(movimento, dur, intensidade = 0.5, lado = 0, base = 1080) {
+    return (MOVIMENTOS[movimento] || MOVIMENTOS.parado)(dur, Math.max(0, Math.min(1, intensidade)), lado, base);
+}
+
+module.exports = { intensidades, decidir, camera, MOVIMENTOS };

package/lib/estudio/edicao.js

@@ -26,6 +26,8 @@
 
 'use strict';
 
+const decisao = require('./decisao.js');
+
 // ── as palavras que não carregam ideia ───────────────────────────────────
 const VAZIAS = new Set((
     'a o as os um uma uns umas de do da dos das no na nos nas em por para pra pro com sem que se e '
@@ -88,6 +90,25 @@ const ICONES = [
     [['surpre', 'chocad', 'absurd'], 'exploding-head'],
 ];
 
+/* AS OUTRAS FORMAS DE DIZER O MESMO (07/10): "não quero que o sistema fique
+   repetindo os mesmos ícones". Cada conceito tinha UM emoji — todo vídeo de
+   dinheiro saía com o mesmo saco de dinheiro. O ícone automático continua
+   saindo daqui pelo primeiro nome (o de ICONES); a passada de variedade do
+   vídeo (index.js, variarIcones) troca pelo que os últimos vídeos menos
+   usaram, o mesmo conceito com o mesmo ícone dentro do vídeo. Nomes
+   conferidos no fluent-emoji-flat do Iconify em 07/10. */
+const ALTERNATIVAS = {
+    robot: ['mechanical-arm', 'desktop-computer'], brain: ['thought-balloon', 'light-bulb'], 'light-bulb': ['sparkles', 'glowing-star', 'gem-stone'],
+    'money-bag': ['dollar-banknote', 'coin', 'money-with-wings', 'credit-card'], stopwatch: ['hourglass-not-done', 'alarm-clock', 'mantelpiece-clock', 'watch'],
+    'chart-increasing': ['seedling', 'mountain', 'chequered-flag'], 'bar-chart': ['clipboard', 'hundred-points'], rocket: ['high-voltage', 'airplane'],
+    fire: ['collision', 'high-voltage', 'dizzy'], 'check-mark-button': ['check-mark', 'thumbs-up', 'hundred-points'], 'cross-mark': ['stop-sign', 'no-entry'],
+    laptop: ['desktop-computer', 'keyboard'], 'globe-showing-americas': ['globe-with-meridians', 'satellite-antenna'], 'speaker-high-volume': ['microphone', 'headphone', 'megaphone'],
+    memo: ['pencil', 'open-book', 'clipboard'], books: ['open-book', 'pencil'], 'speech-balloon': ['speaking-head', 'thought-balloon', 'megaphone'],
+    gear: ['hammer-and-wrench', 'toolbox', 'link'], calendar: ['spiral-calendar'], trophy: ['sports-medal', 'crown', 'glowing-star'],
+    'flexed-biceps': ['high-voltage'], handshake: ['people-hugging', 'link'], locked: ['shield', 'key'], briefcase: ['bank', 'classical-building'],
+    'party-popper': ['confetti-ball', 'sparkles'], 'red-heart': ['sparkling-heart'], 'shopping-cart': ['receipt', 'credit-card'], 'clapper-board': ['video-camera', 'camera'],
+};
+
 /* O termo de busca da IMAGEM DE APOIO, pelo emoji que a palavra ganhou. Em
    inglês de propósito: os acervos abertos respondem muito melhor assim. */
 const FOTO = {
@@ -225,14 +246,6 @@ function blocos(palavras, maximo) {
     return out;
 }
 
-// O zoom de cada cena, em rodízio: parado, punch-in, empurrando devagar.
-function camera(i, dur) {
-    const tipo = i % 3;
-    if (tipo === 0) return { zoom: [{ t: 0, v: 1 }, { t: dur, v: 1.04, e: 'linear' }] };
-    if (tipo === 1) return { zoom: [{ t: 0, v: 1.18 }, { t: dur, v: 1.21, e: 'linear' }] };
-    return { zoom: [{ t: 0, v: 1.07 }, { t: dur, v: 1.13, e: 'suave' }] };
-}
-
 const ESTILOS = {
     viral: { icones: true, letreiro: true, sons: true, barra: true, apoio: true, recorte: true, fundoRecorte: ['#1B1F3B', '#3A1C71'], destaque: '#FFD400', forte: '#00E0A4' },
     limpo: { icones: false, letreiro: false, sons: false, barra: false, apoio: true, recorte: false, fundoRecorte: ['#111111', '#333333'], destaque: '#FFFFFF', forte: '#FFD400' },
@@ -251,8 +264,6 @@ const ESTILOS = {
  * @param {object} op.sons        { pop, whoosh } — caminhos na pasta do projeto, opcionais
  * @param {Set}    op.iconesOk    os nomes de ícone que existem de verdade (sem isso, todos valem)
  */
-// Em quais cenas a pessoa é recortada, com a palavra gigante atrás dela.
-const temRecorte = (i) => i % 4 === 2;
 
 function montarEdicao({ src, duracao, palavras, largura = 1080, altura = 1920, estilo = 'viral', sons = {}, iconesOk = null, imagens = {}, trilha = null, recortes = {}, marca = null }) {
     const e = ESTILOS[estilo] || ESTILOS.viral;
@@ -263,6 +274,10 @@ function montarEdicao({ src, duracao, palavras, largura = 1080, altura = 1920, e
     const base = Math.min(largura, altura);
     const grupos = frases(lista);
     const total = duracao || lista[lista.length - 1].ate + 0.3;
+    /* O QUE CADA FRASE PEDE (decisao.js): movimento, recorte e whoosh pela
+       intensidade dela, não pelo rodízio i % 3 — e depois do golpe, respiro. */
+    const decisoes = decisao.decidir(grupos, { peso });
+    let ladoQuadro = 0;
     const cenas = [];
     const efeitos = [];
     const infos = [];   // onde cada cena começa e a palavra forte dela — para o recorte
@@ -283,12 +298,13 @@ function montarEdicao({ src, duracao, palavras, largura = 1080, altura = 1920, e
             deOrigem: r2(ini), ateOrigem: r2(ini + dur), volume: 1,
         }];
 
-        infos.push({ ini: r2(ini), dur, forte: forte ? { de: local(forte.de), texto: forte.texto, peso: peso(forte.texto) } : null });
+        infos.push({ ini: r2(ini), dur, forte: forte ? { de: local(forte.de), texto: forte.texto, peso: peso(forte.texto) } : null,
+            recorte: decisoes[i].recorte, intensidade: decisoes[i].intensidade });
 
         /* A PALAVRA ATRÁS DA PESSOA: o fundo do quarto some, entra a cor da
            marca, a palavra forte aparece enorme e a pessoa, recortada, fica
            na frente dela. É o efeito que mais denuncia edição de videomaker. */
-        const rec = e.recorte && temRecorte(i) ? recortes[i] : null;
+        const rec = e.recorte && decisoes[i].recorte ? recortes[i] : null;
         if (rec && forte) {
             const vida = r2(rec.ate - rec.de);
             const some = [{ t: 0, v: 0 }, { t: 0.1, v: 1 }, { t: vida - 0.12, v: 1 }, { t: vida, v: 0 }];
@@ -389,7 +405,8 @@ function montarEdicao({ src, duracao, palavras, largura = 1080, altura = 1920, e
             tipo: 'legenda', x: '50%', y: deitado ? '76%' : '68%', ancora: 'centro', fala,
             estilo: {
                 fonte: 'Montserrat', peso: 900, tamanho: Math.round(base * (deitado ? 0.078 : 0.072)),
-                destaque: e.destaque, corForte: e.forte, caixa: 'uppercase', largura: '92%',
+                // Caixa normal (o que a pessoa disse, como disse) e a palavra forte na serifa em itálico.
+                destaque: e.destaque, corForte: e.forte, fonteForte: 'Instrument Serif', largura: '92%',
             },
         });
 
@@ -402,10 +419,12 @@ function montarEdicao({ src, duracao, palavras, largura = 1080, altura = 1920, e
             });
         }
 
-        // O whoosh entra no punch-in: é o corte que ele anuncia.
-        if (e.sons && sons.whoosh && i > 0 && i % 3 === 1) efeitos.push({ t: r2(Math.max(0, ini - 0.12)), src: sons.whoosh, volume: 0.6 });
+        // O whoosh entra no soco: é o corte que ele anuncia (e só nele).
+        if (e.sons && sons.whoosh && decisoes[i].whoosh) efeitos.push({ t: r2(Math.max(0, ini - 0.12)), src: sons.whoosh, volume: 0.6 });
 
-        cenas.push({ duracao: dur, camera: camera(i, dur), elementos, transicao: { tipo: 'corte' } });
+        const d = decisoes[i];
+        if (d.movimento === 'reenquadra') ladoQuadro = 1 - ladoQuadro;
+        cenas.push({ duracao: dur, camera: decisao.camera(d.movimento, dur, d.intensidade, ladoQuadro, base), elementos, transicao: { tipo: 'corte' }, impacto: d.movimento === 'soco' || undefined });
     });
 
     return {
@@ -472,4 +491,4 @@ async function prepararSons(pasta, video) {
     return sons;
 }
 
-module.exports = { montarEdicao, temRecorte, prepararSons, iconeDe, peso, frases, blocos, termosDeApoio, termoDeApoio, rotaDeApoio, DEPOIS_DA_PALAVRA, ESTILOS, ICONES, FOTO };
+module.exports = { montarEdicao, ALTERNATIVAS, prepararSons, iconeDe, peso, frases, blocos, termosDeApoio, termoDeApoio, rotaDeApoio, DEPOIS_DA_PALAVRA, ESTILOS, ICONES, FOTO };