primocode 9.10.0 → 10.0.9

package/lib/estudio/gerativo.js

@@ -0,0 +1,1453 @@
+/**
+ * gerativo.js — o motion GERATIVO: sem template, a tipografia é o filme.
+ *
+ *   "O motion que ele faz é tudo igual — só muda a informação num template
+ *    pronto. Não pode ter template. Motion é animação contínua, que
+ *    transforma as coisas, o texto: mexe a própria FONTE." — Joel (29–30/09)
+ *
+ * Os estilos de cena por parte (motion.js, vox.js, lancamento.js) ligam cada
+ * tipo de parte a um leiaute fixo: a lista é sempre a mesma lista. Aqui não.
+ * O roteiro e os tempos da voz viram uma PARTITURA: uma linha do tempo só,
+ * dividida em BATIDAS. Cada batida tem:
+ *
+ *   as palavras que a voz diz nela, cada uma com o seu instante (o áudio
+ *   comanda o quadro — regra 01 do guia VOX);
+ *   um papel por palavra (tese, apoio, função) — a tese é a mais forte;
+ *   uma COMPOSIÇÃO sorteada entre as que o CONTEÚDO permite (palavra
+ *   gigante, pilha à esquerda, divisão, contador, cascata, parede de texto,
+ *   citação marcada, marca que se constrói, palavras faladas, produto 3D) —
+ *   nunca a mesma duas batidas seguidas;
+ *   um COMPORTAMENTO por linha, do vocabulário que os eixos da fonte
+ *   permitem (carimbo, máscara, onda, decodificar, peso 100→900 no eixo
+ *   wght, largura no wdth, tracking, desfoque, split-flap, pontos, contorno);
+ *   a forma de ACENTO — um traço só que atravessa o vídeo inteiro e vira
+ *   sublinhado, anel, risco, barra, marcador, marca-texto, ponto final;
+ *   a SAÍDA, que transforma em vez de cortar: as letras viram pontos e voam
+ *   para o acento, a fonte afina e evapora, a câmera atravessa a palavra, o
+ *   acento cresce e vira o fundo da próxima.
+ *
+ * O sorteio é DETERMINÍSTICO: a semente é o hash do roteiro. O mesmo roteiro
+ * dá a mesma partitura; dois roteiros diferentes, filmes diferentes. As
+ * regras do guia são restrições do sorteio: hierarquia, 30–40% de respiro,
+ * um acento em no máximo 3 pontos, até 6 elementos, uma ação dominante por
+ * vez, stagger de 3–6 quadros, burst de 16–18, traço de 10–16, leitura de
+ * pelo menos 1 s, mola SNAPPY no elemento e bezier longa na câmera.
+ *
+ * Quem desenha é kit/gerativo.jsx: UM componente que lê a partitura quadro
+ * a quadro. Puro: tempos, narração, trilha e sons entram; o plano sai.
+ */
+
+'use strict';
+
+const { misturarCor, ehCor } = require('./morfar.js');
+const { volumesDaTrilha } = require('./ritmo.js');
+const { falaDe } = require('./composicao.js');
+
+const FPS = 30;
+const QUADRO = 1 / FPS;
+const r3 = (n) => Math.round(n * 1000) / 1000;
+const r1 = (n) => Math.round(n * 10) / 10;
+
+/* As regras do guia MOTION VOX STYLE, em números. Os testes leem daqui. */
+const REGRAS = {
+    SNAPPY: { damping: 26, stiffness: 240, mass: 0.65 },
+    stagger: [3, 6],          // quadros entre elementos
+    burst: [16, 18],          // quadros da entrada de um elemento
+    traco: [10, 16],          // quadros do traço de markup
+    leitura: 1.0,             // segundos parado antes de sair
+    elementos: 6,             // por quadro
+    acentos: 3,               // pontos de cor por batida
+    respiro: [0.3, 0.4],      // fração do quadro que é fundo puro
+};
+
+// ── o acaso com semente ─────────────────────────────────────────────────
+function hash(txt) {
+    let h = 0x811c9dc5;
+    const s = String(txt);
+    for (let i = 0; i < s.length; i++) { h ^= s.charCodeAt(i); h = Math.imul(h, 0x01000193) >>> 0; }
+    return h >>> 0;
+}
+/** mulberry32: o mesmo número de partida dá sempre a mesma sequência. */
+function sorteador(semente) {
+    let a = semente >>> 0;
+    const prox = () => {
+        a = (a + 0x6d2b79f5) >>> 0;
+        let t = a;
+        t = Math.imul(t ^ (t >>> 15), t | 1);
+        t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+    const s = {
+        prox,
+        entre: (a0, b0) => a0 + (b0 - a0) * prox(),
+        um: (lista) => lista[Math.floor(prox() * lista.length) % lista.length],
+        chance: (p) => prox() < p,
+        /** Sorteio com peso: {nome: peso}. Peso 0 não sai. */
+        pesado: (pesos) => {
+            const itens = Object.entries(pesos).filter(([, p]) => p > 0);
+            if (!itens.length) return null;
+            const total = itens.reduce((n, [, p]) => n + p, 0);
+            let x = prox() * total;
+            for (const [nome, p] of itens) { if ((x -= p) <= 0) return nome; }
+            return itens[itens.length - 1][0];
+        },
+    };
+    return s;
+}
+
+// ── as fontes variáveis (Google Fonts, eixos conferidos em 30/09) ─────────
+/* largura: o quanto a fonte é mais larga que uma grotesca comum (para a
+   estimativa; o componente mede de verdade e encolhe o que não couber). */
+const VARIAVEIS = {
+    'Roboto Flex': { eixos: { wght: [100, 1000], wdth: [25, 151], opsz: [8, 144], slnt: [-10, 0], GRAD: [-200, 150] }, largura: 0.98 },
+    'Fraunces': { eixos: { wght: [100, 900], opsz: [9, 144], SOFT: [0, 100], WONK: [0, 1] }, largura: 1.0, serifa: true },
+    'Inter Tight': { eixos: { wght: [100, 900] }, largura: 0.93 },
+    'Inter': { eixos: { wght: [100, 900], opsz: [14, 32] }, largura: 1.0 },
+    'Unbounded': { eixos: { wght: [200, 900] }, largura: 1.3 },
+    'Newsreader': { eixos: { wght: [200, 800], opsz: [6, 72] }, largura: 0.88, serifa: true },
+    'DM Sans': { eixos: { wght: [100, 1000], opsz: [9, 40] }, largura: 1.0 },
+    'Plus Jakarta Sans': { eixos: { wght: [200, 800] }, largura: 1.04 },
+    'Bricolage Grotesque': { eixos: { wght: [200, 800], wdth: [75, 100], opsz: [12, 96] }, largura: 0.98 },
+    'Anybody': { eixos: { wght: [100, 900], wdth: [50, 150] }, largura: 1.0 },
+    'Archivo': { eixos: { wght: [100, 900], wdth: [62, 125] }, largura: 1.0 },
+    'Mona Sans': { eixos: { wght: [200, 900], wdth: [75, 125] }, largura: 1.0 },
+    'IBM Plex Sans': { eixos: { wght: [100, 700], wdth: [85, 100] }, largura: 0.98 },
+    'Space Grotesk': { eixos: { wght: [300, 700] }, largura: 1.02 },
+    'Big Shoulders': { eixos: { wght: [100, 900], opsz: [10, 72] }, largura: 0.72 },
+    'Geist': { eixos: { wght: [100, 900] }, largura: 0.98 },
+    'Manrope': { eixos: { wght: [200, 800] }, largura: 1.02 },
+    'Sora': { eixos: { wght: [100, 800] }, largura: 1.06 },
+    'Outfit': { eixos: { wght: [100, 900] }, largura: 0.98 },
+    'Montserrat': { eixos: { wght: [100, 900] }, largura: 1.12 },
+    'JetBrains Mono': { eixos: { wght: [100, 800] }, largura: 1.1, mono: true },
+    // A biblioteca anti-genérica (30/09): faces com caráter, conferidas no Google Fonts.
+    'Bodoni Moda': { eixos: { wght: [400, 900], opsz: [6, 96] }, largura: 0.96, serifa: true },
+    'Playfair Display': { eixos: { wght: [400, 900] }, largura: 0.98, serifa: true },
+    'Familjen Grotesk': { eixos: { wght: [400, 700] }, largura: 0.96 },
+    'Schibsted Grotesk': { eixos: { wght: [400, 900] }, largura: 0.98 },
+    'Hanken Grotesk': { eixos: { wght: [100, 900] }, largura: 0.97 },
+    'Syne': { eixos: { wght: [400, 800] }, largura: 1.1 },
+    'Martian Mono': { eixos: { wdth: [75, 112.5], wght: [100, 800] }, largura: 1.15, mono: true },
+    // As estáticas: sem eixo para animar, servem de texto, citação e rótulo.
+    'Instrument Serif': { eixos: {}, css: 'ital@0;1', largura: 0.86, serifa: true },
+    'Space Mono': { eixos: {}, css: 'wght@400;700', largura: 1.1, mono: true },
+    'Fragment Mono': { eixos: {}, css: '', largura: 1.1, mono: true },
+};
+
+/* AS FONTES DE IA: o que todo vídeo feito por IA usa. Nunca são o padrão do
+   gerativo; se a marca manda uma delas como título, ela vira o texto e o
+   título ganha uma face com caráter. */
+const BANIDAS = ['Inter', 'Inter Tight', 'Roboto', 'Roboto Flex', 'Poppins', 'Montserrat', 'Open Sans', 'DM Sans', 'Plus Jakarta Sans',
+    'Unbounded', 'Lato', 'Arial', 'Helvetica', 'Nunito', 'Raleway', 'Space Grotesk', 'Manrope', 'Outfit', 'Geist', 'Sora'];
+/* AS CORES DE IA: o violeta de SaaS (#6366f1 e vizinhos) e o neon sobre preto. */
+function corGenerica(hex) {
+    const n = parseInt(String(hex).slice(1), 16), r = (n >> 16 & 255) / 255, g = (n >> 8 & 255) / 255, b = (n & 255) / 255;
+    const mx = Math.max(r, g, b), mn = Math.min(r, g, b), d = mx - mn;
+    if (!d) return false;
+    let h = mx === r ? ((g - b) / d) % 6 : mx === g ? (b - r) / d + 2 : (r - g) / d + 4;
+    h = (h * 60 + 360) % 360;
+    const sat = d / (1 - Math.abs(mx + mn - 1) || 1);
+    if (h >= 238 && h <= 300 && sat > 0.35) return true;                  // violeta, roxo, índigo de SaaS
+    if (sat > 0.85 && mx > 0.9 && ((h >= 170 && h <= 200) || (h >= 295 && h <= 330))) return true;   // ciano e magenta neon
+    return false;
+}
+
+/* OS HUMORES: do assunto do roteiro saem a dupla de fontes, a paleta, o
+   gênero da trilha e a família de sons. Cada humor tem várias opções; a
+   semente escolhe — dois vídeos do mesmo assunto não saem iguais. */
+const HUMORES = {
+    editorial: {
+        palavras: 'historia por que porque explica cancelamento atenas guerra livro politica cultura democracia voto lei grego roma imperio arte jornal',
+        displays: ['Fraunces', 'Bodoni Moda', 'Playfair Display'], textos: ['Schibsted Grotesk', 'Familjen Grotesk'], monos: ['Martian Mono', 'Space Mono'],
+        serifas: ['Instrument Serif', 'Fraunces'], cineticas: ['Anybody', 'Archivo'],
+        paletas: [['#EFE8DA', '#1A1714', '#7A1F1F'], ['#F3EEE3', '#14161F', '#1F3FBF'], ['#E9E3D3', '#211E1A', '#D9481C']],
+        generos: ['jazz', 'acoustic', 'classical'], som: 'papel',
+    },
+    tecnologia: {
+        palavras: 'ia ai app software codigo modelo modelos dados claude sonnet gpt algoritmo digital tecnologia plataforma api chip computador agente agentes agentic rapido barato versao lancamento',
+        displays: ['Bricolage Grotesque', 'Mona Sans', 'Schibsted Grotesk', 'Syne'], textos: ['Familjen Grotesk', 'Hanken Grotesk'], monos: ['Martian Mono', 'Fragment Mono'],
+        serifas: ['Instrument Serif', 'Fraunces'], cineticas: ['Mona Sans', 'Anybody', 'Archivo'],
+        paletas: [['#1B1D1A', '#E9E6DD', '#C6F432'], ['#10161F', '#F1ECE0', '#FF5F1F'], ['#2F3A26', '#EDE6D3', '#FF6F59'], ['#F0EDE6', '#141414', '#FF4A1C']],
+        generos: ['electronica', 'lofi-chill-beats', 'funk'], som: 'analogico',
+    },
+    energia: {
+        palavras: 'som audio fone fones headset musica bateria esporte treino velocidade energia jogo game festa barulho silencio ouca ouvir escute vento corrida',
+        displays: ['Anybody', 'Big Shoulders', 'Syne', 'Archivo'], textos: ['Hanken Grotesk', 'Familjen Grotesk'], monos: ['Space Mono', 'Martian Mono'],
+        serifas: ['Bodoni Moda', 'Instrument Serif'], cineticas: ['Anybody', 'Archivo'],
+        paletas: [['#121110', '#F2EEE6', '#FF4F00'], ['#1E1A16', '#F4EBDD', '#E8C547'], ['#0F1E3D', '#F3EDE1', '#FF7A4D']],
+        generos: ['funk', 'dance-club', 'electronica'], som: 'digital',
+    },
+    natureza: {
+        palavras: 'ceu azul sol luz natureza planta plantas agua mar terra fisica ciencia universo estrela estrelas clima ar cor cores olhos violeta vermelho por do',
+        displays: ['Fraunces', 'Bricolage Grotesque', 'Bodoni Moda'], textos: ['Hanken Grotesk', 'Schibsted Grotesk'], monos: ['Martian Mono', 'Space Mono'],
+        serifas: ['Instrument Serif', 'Fraunces'], cineticas: ['Anybody', 'Mona Sans'],
+        paletas: [['#F2EDE2', '#13233F', '#2546D9'], ['#0F2A2A', '#EDE7DA', '#F2A541'], ['#E7E2D2', '#22301F', '#C8553D']],
+        generos: ['ambient', 'acoustic', 'cinematic'], som: 'organico',
+    },
+    luxo: {
+        palavras: 'luxo moda perfume joia premium elegante vinho couro ouro atelier',
+        displays: ['Bodoni Moda', 'Playfair Display', 'Fraunces'], textos: ['Hanken Grotesk', 'Familjen Grotesk'], monos: ['Fragment Mono', 'Martian Mono'],
+        serifas: ['Bodoni Moda', 'Instrument Serif'], cineticas: ['Anybody', 'Mona Sans'],
+        paletas: [['#2A0E12', '#F0E6D6', '#C9A24A'], ['#F1EBE1', '#1B1A17', '#8C1C13']],
+        generos: ['jazz', 'soul-rnb', 'classical'], som: 'papel',
+    },
+};
+/* A cor que o próprio assunto diz ("por que o céu é AZUL") vira o acento. */
+const CORES_DITAS = { azul: '#2546D9', vermelho: '#C8291E', verde: '#2F7D4F', laranja: '#FF5F1F', amarelo: '#E8B92F', dourado: '#C9A24A', rosa: '#E86A8A', coral: '#FF6F59' };
+
+/* A palavra que pede ícone → o ícone 3D (kit/tres.jsx ICONES). */
+const ICONE_DE = {
+    bateria: 'bateria', carga: 'bateria', tomada: 'bateria', horas: 'relogio', hora: 'relogio', minutos: 'relogio', tempo: 'relogio', espera: 'relogio', dia: 'relogio',
+    rapido: 'raio', velocidade: 'raio', energia: 'raio', agil: 'raio', instantaneo: 'raio', conversa: 'balao', conversar: 'balao', chat: 'balao', pergunta: 'balao',
+    seguro: 'escudo', seguranca: 'escudo', protege: 'escudo', protecao: 'escudo', confianca: 'escudo', coracao: 'coracao', amor: 'coracao', saude: 'coracao', pessoas: 'coracao',
+    melhor: 'estrela', estrela: 'estrela', estrelas: 'estrela', qualidade: 'estrela', sol: 'sol', luz: 'sol', video: 'play', assista: 'play', experimente: 'play',
+    engrenagem: 'engrenagem', ajuste: 'engrenagem', agentes: 'engrenagem', agente: 'engrenagem', trabalho: 'engrenagem', senha: 'cadeado', privacidade: 'cadeado', bloqueio: 'cadeado',
+    grafico: 'barras', cresce: 'barras', crescimento: 'barras', dados: 'barras', barato: 'barras', conta: 'barras', fone: 'fone', headset: 'fone', almofadas: 'fone',
+    som: 'onda', audio: 'onda', microfone: 'onda', vento: 'onda', escute: 'onda', ouca: 'onda', barulho: 'onda', celular: 'celular', app: 'celular', aparelho: 'celular', aparelhos: 'celular',
+    notebook: 'celular', pronto: 'check', feito: 'check', certo: 'check', proximo: 'seta', passo: 'seta', adiante: 'seta', ricocheteia: 'seta',
+};
+
+/** O humor do roteiro: as palavras dele contra as de cada humor (empate: a semente). */
+function humorDe(roteiro, s) {
+    const txt = new Set(tokens((roteiro.partes || []).map((p) => [p.titulo, p.texto, p.fala, p.sub, ...(p.itens || [])].filter(Boolean).join(' ')).join(' ')
+        + ' ' + ((roteiro.marca && roteiro.marca.nome) || '') + ' ' + (roteiro.pedido || '')));
+    const nota = {};
+    for (const [h, d] of Object.entries(HUMORES)) nota[h] = d.palavras.split(' ').filter((w) => txt.has(w)).length + s.prox() * 0.5;
+    return Object.entries(nota).sort((a, b) => b[1] - a[1])[0][0];
+}
+/* As que têm largura (wdth): é nelas que a palavra estica. */
+const CINETICAS = ['Roboto Flex', 'Anybody', 'Archivo', 'Mona Sans'];
+
+/** A linha do css2 do Google para os eixos: minúsculos em ordem, depois os maiúsculos. */
+function especEixos(familia) {
+    const v = VARIAVEIS[familia];
+    if (!v) return null;
+    if (v.css != null) return v.css;
+    if (!Object.keys(v.eixos).length) return '';
+    const tags = Object.keys(v.eixos).sort((a, b) => {
+        const A = a === a.toUpperCase(), B = b === b.toUpperCase();
+        if (A !== B) return A ? 1 : -1;
+        return a < b ? -1 : 1;
+    });
+    return tags.join(',') + '@' + tags.map((t) => v.eixos[t].join('..')).join(',');
+}
+
+const eixoDe = (familia, tag) => (VARIAVEIS[familia] && VARIAVEIS[familia].eixos[tag]) || null;
+const prende = (v, [a, b]) => Math.max(a, Math.min(b, v));
+
+// ── o texto ─────────────────────────────────────────────────────────────
+const norm = (t) => String(t || '').normalize('NFD').replace(/[̀-ͯ]/g, '').toLowerCase();
+const tokens = (t) => norm(t).split(/[^a-z0-9%]+/).filter(Boolean);
+const FUNCAO = new Set(('o a os as um uma uns umas de do da dos das em no na nos nas por pra pro para com sem e ou que se '
+    + 'ao aos à às é ser seu sua seus suas te lhe me meu minha isso isto esse essa este esta ele ela eles elas voce nao mais '
+    + 'the a an of to in on for and or with is are it this that your you our by at as from be').split(' '));
+const funcao = (w) => FUNCAO.has(tokens(w)[0] || '');
+/* As que não podem terminar linha: artigo, preposição, conjunção. */
+const FRACAS = new Set('o a os as um uma de do da dos das em no na nos nas por pra pro para com sem e ou que se ao aos à às the an of to in on for and or with by at from'.split(' '));
+const fraca = (w) => FRACAS.has(tokens(w)[0] || '');
+
+/* A largura do texto em "em", pela forma de cada letra. É uma ESTIMATIVA:
+   serve para quebrar linha e escolher tamanho; quem garante que cabe é o
+   componente, que mede no navegador e encolhe. */
+function emDe(ch) {
+    if (ch === ' ') return 0.27;
+    if (/[iIl1.,:;'!|j·]/.test(ch)) return 0.3;
+    if (/[mwMW]/.test(ch)) return 0.86;
+    if (/[A-ZÀ-Ý]/.test(ch)) return 0.68;
+    if (/[0-9]/.test(ch)) return 0.58;
+    if (/[%&@#]/.test(ch)) return 0.8;
+    return 0.54;
+}
+function larguraEm(texto, { fonte = 'Roboto Flex', wght = 400, wdth = 100, tracking = 0, maiusc = false } = {}) {
+    const v = VARIAVEIS[fonte] || { largura: 1 };
+    const t = maiusc ? String(texto).toUpperCase() : String(texto);
+    let em = 0;
+    for (const ch of t) em += (v.mono ? 0.6 : emDe(ch)) + tracking;
+    const peso = 1 + ((wght - 400) / 500) * 0.1;
+    const larg = 0.3 + 0.7 * (wdth / 100);
+    return em * v.largura * peso * larg;
+}
+/** O maior tamanho (px) em que o texto cabe na largura, com teto. */
+function tamanhoQueCabe(texto, largura, max, op) {
+    const em = larguraEm(texto, op) || 1;
+    return Math.max(12, Math.min(max, Math.floor((largura * 0.94) / em)));
+}
+/* A QUEBRA DE LINHA de diretor de arte, não de editor de texto: todas as
+   partições da frase em até `n` linhas, e ganha a que tem linhas parelhas,
+   quebra depois da pontuação e NUNCA termina linha em "da", "o", "que" —
+   "Barulho da / rua" é o erro que denuncia máquina. */
+function particoes(ws, n) {
+    const out = [];
+    const rec = (i, acc) => {
+        if (i === ws.length) { out.push(acc); return; }
+        if (acc.length >= n) return;
+        for (let j = i + 1; j <= ws.length; j++) rec(j, [...acc, ws.slice(i, j).join(' ')]);
+    };
+    if (ws.length <= 14) rec(0, []);
+    return out;
+}
+function custoQuebra(linhas, larguras) {
+    let c = 0;
+    const max = Math.max(...larguras);
+    larguras.forEach((w, i) => { if (i < larguras.length - 1) c += Math.pow(1 - w / max, 2) * 2; });
+    linhas.forEach((l, i) => {
+        if (i === linhas.length - 1) { if (larguras[i] < max * 0.25 && linhas.length > 1) c += 1.2; return; }
+        const ult = l.split(' ').pop();
+        if (fraca(ult) || /^\d+$/.test(ult)) c += 6;
+        if (/[,.;:!?—–-]$/.test(ult)) c -= 0.8;
+    });
+    return c + (linhas.length - 1) * 0.35;
+}
+/** Quebra em linhas que caibam (a melhor partição; gulosa se a frase é longa). */
+function quebrar(texto, largura, tamanho, op, n = 99) {
+    const ws = String(texto).split(/\s+/).filter(Boolean);
+    const cabe = (l) => larguraEm(l, op) * tamanho <= largura * 0.94;
+    let melhor = null, custo = Infinity;
+    for (const ls of particoes(ws, n)) {
+        if (!ls.every(cabe)) continue;
+        const c = custoQuebra(ls, ls.map((l) => larguraEm(l, op)));
+        if (c < custo) { custo = c; melhor = ls; }
+    }
+    if (melhor) return melhor;
+    const linhas = [];
+    let atual = '';
+    for (const w of ws) {
+        const tenta = atual ? atual + ' ' + w : w;
+        if (!atual || cabe(tenta)) atual = tenta;
+        else { linhas.push(atual); atual = w; }
+    }
+    if (atual) linhas.push(atual);
+    return linhas;
+}
+/** O maior tamanho em que o texto cabe em até `n` linhas — sem quebra feia, se der. */
+function caberEmLinhas(texto, largura, n, max, op, min = 14) {
+    let reserva = null;
+    for (let t = Math.round(max); t >= min; t -= Math.max(1, Math.round(t * 0.04))) {
+        const ls = quebrar(texto, largura, t, op, n);
+        if (ls.length > n || !ls.every((l) => larguraEm(l, op) * t <= largura * 0.96)) continue;
+        const feia = ls.slice(0, -1).some((l) => fraca(l.split(' ').pop()));
+        if (!feia) return { tamanho: t, linhas: ls };
+        if (!reserva) reserva = { tamanho: t, linhas: ls };
+        if (t < max * 0.5) break;
+    }
+    return reserva || { tamanho: min, linhas: quebrar(texto, largura, min, op, n) };
+}
+
+const numeroDe = (v) => {
+    const m = String(v == null ? '' : v).match(/^(\D*?)(\d[\d.,]*)(.*)$/);
+    if (!m) return null;
+    const bruto = m[2];
+    const milhar = /\.\d{3}(\D|$)/.test(bruto) ? '.' : (/,\d{3}(\D|$)/.test(bruto) && !/\./.test(bruto) ? ',' : '');
+    const limpo = milhar === '.' ? bruto.replace(/\./g, '').replace(',', '.') : milhar === ',' ? bruto.replace(/,/g, '') : bruto.replace(',', '.');
+    const n = Number(limpo);
+    if (!Number.isFinite(n)) return null;
+    const casas = (/[.,](\d+)$/.exec(milhar ? '' : bruto) || [, ''])[1].length;
+    return { antes: m[1], n, depois: m[3], casas, milhar, virgula: /,/.test(bruto) && !milhar };
+};
+
+// ── o conteúdo de cada parte (o que aparece, não o leiaute) ────────────
+const itensDe = (p) => [...(p.itens || []), ...(p.barras || []).map((b) => `${b.rotulo || ''} ${b.valor != null ? b.valor : ''}`.trim()),
+    ...(p.cores || []).map((c) => (typeof c === 'string' ? c : `${c.nome || ''} ${c.hex || ''}`.trim()))]
+    .map((i) => (typeof i === 'string' ? i : i.texto || i.titulo || '')).filter(Boolean);
+
+function conteudoDe(p, marca = {}) {
+    const titulo = p.titulo || p.texto || '';
+    const itens = itensDe(p);
+    if (p.tipo === 'numero' && numeroDe(p.valor)) return { tipo: 'numero', valor: String(p.valor), rotulo: p.rotulo || titulo, sub: p.sub || '' };
+    if (itens.length >= 2) return { tipo: 'lista', titulo: p.tipo === 'cores' ? titulo : titulo, itens: itens.slice(0, 5), numerada: p.tipo === 'passos' };
+    if (p.tipo === 'contraste' && (p.nao || p.sim)) return { tipo: 'contraste', nao: p.nao || '', sim: p.sim || titulo };
+    if (p.tipo === 'citacao') return { tipo: 'citacao', texto: titulo, autor: p.autor || '' };
+    const nome = marca.nome || '';
+    if (p.tipo === 'logo' || (p.tipo === 'abertura' && titulo && norm(titulo).replace(/\s/g, '') === norm(nome).replace(/\s/g, '')))
+        return { tipo: 'marca', nome: titulo || nome, sub: p.sub || '' };
+    if (p.tipo === 'cta') return { tipo: 'cta', titulo, link: p.link || '' };
+    if (p.tipo === 'produto') return { tipo: 'produto', titulo, sub: p.texto && p.texto !== titulo ? p.texto : (p.sub || ''), selo: p.selo || '' };
+    return { tipo: 'titulo', titulo, sub: p.sub || '', selo: p.selo || '' };
+}
+const textoDoConteudo = (c) => [c.titulo, c.sub, c.valor, c.rotulo, c.nao, c.sim, c.texto, c.autor, c.nome, c.link, c.selo, ...(c.itens || [])].filter(Boolean).join(' ');
+
+// ── as composições e o que cada conteúdo aceita ─────────────────────────
+const COMPOSICOES = ['gigante', 'pilha', 'divisao', 'contador', 'cascata', 'parede', 'citacao', 'marca', 'palavras', 'produto'];
+const COMPORTAMENTOS = ['carimbo', 'mascara', 'onda', 'decodifica', 'peso', 'largura', 'tracking', 'desfoque', 'flap', 'pontos', 'contorno', 'monta'];
+const SAIDAS = ['pontos', 'evapora', 'atravessa', 'desliza', 'comprime', 'explode', 'chicote', 'inunda', 'corte'];
+const ACENTOS = ['ponto', 'sublinha', 'anel', 'risco', 'barra', 'bala', 'marca', 'moldura', 'seta'];
+
+function pesosDe(c, { curto, palavras, primeira, ultima, tem3d, pergunta, exclama, numeroNoTitulo }) {
+    switch (c.tipo) {
+        case 'numero': return { contador: 5, gigante: 2, pilha: 1.2 };
+        case 'lista': return { cascata: 4, pilha: c.itens.length <= 3 && c.itens.every((i) => i.length <= 26) ? 1.6 : 0, rajada: c.itens.length <= 4 ? 2.4 : 0 };
+        case 'contraste': return { divisao: 5, duelo: 2.6 };
+        case 'citacao': return { citacao: 5, pilha: 1 };
+        case 'marca': return { marca: primeira || ultima ? 4.5 : 3, gigante: 2.4, parede: curto ? 2 : 0 };
+        case 'cta': return { pilha: 3, gigante: curto ? 2.6 : 0.6, parede: c.titulo.length <= 16 ? 1.6 : 0, marca: 1, produto: tem3d ? 3.5 : 0 };
+        case 'produto': return tem3d ? { produto: 9, pilha: 0.5 } : { pilha: 3, gigante: curto ? 2.5 : 0.5, parede: c.titulo.length <= 12 ? 1.2 : 0 };
+        case 'falado': return { palavras: 4, gigante: palavras <= 3 ? 2.6 : 0, pilha: palavras <= 9 ? 1.2 : 0 };
+        default: return {
+            gigante: (curto ? 4.2 : 0.6) + (primeira ? 1 : 0) + (exclama ? 1 : 0) + (numeroNoTitulo ? 1 : 0),
+            pilha: 3 + (pergunta ? 1 : 0),
+            parede: c.titulo.length <= 14 ? 1.4 + (primeira ? 1 : 0) : 0,
+            palavras: 0,
+        };
+    }
+}
+
+// ── o tempo: casar o que aparece com o que a voz diz ────────────────────
+/** As palavras de cada parte, com tempo. Sem voz, 0,34 s por palavra. */
+function temposDasPartes(partes, tempos) {
+    const temVoz = tempos.length === partes.length && tempos.every((t) => t && t.ate > t.de);
+    if (temVoz) {
+        return tempos.map((t, i) => {
+            let ws = (t.palavras || []).filter((w) => w && w.texto != null && w.de != null).map((w) => ({ texto: String(w.texto), de: Number(w.de), ate: Number(w.ate != null ? w.ate : w.de + 0.25) }));
+            if (!ws.length) {
+                const falas = String(falaDe(partes[i])).split(/\s+/).filter(Boolean);
+                const passo = (t.ate - t.de) / Math.max(1, falas.length);
+                ws = falas.map((w, j) => ({ texto: w, de: t.de + j * passo, ate: t.de + (j + 0.8) * passo }));
+            }
+            return { de: t.de, ate: t.ate, palavras: ws };
+        });
+    }
+    let t = 0.35;
+    return partes.map((p) => {
+        const falas = String(falaDe(p) || '').split(/\s+/).filter(Boolean);
+        const ws = falas.map((w) => { const q = { texto: w, de: r3(t), ate: r3(t + 0.28) }; t += 0.34; return q; });
+        const de = ws.length ? ws[0].de : t;
+        const ate = ws.length ? ws[ws.length - 1].ate : t + 1.4;
+        t = ate + 0.45;
+        return { de, ate, palavras: ws };
+    });
+}
+
+/** Para cada texto (em ordem), o instante da voz em que ele é dito — ou null. */
+function casar(textos, palavras, { de = 0, cursor0 = 0 } = {}) {
+    const ws = palavras.map((w) => ({ ...w, k: tokens(w.texto)[0] || '' }));
+    let cursor = cursor0;
+    return textos.map((txt) => {
+        const tk = tokens(txt);
+        const alvo = tk.find((w) => w.length >= 3 && !FUNCAO.has(w)) || tk[0];
+        if (!alvo) return null;
+        for (let j = cursor; j < ws.length; j++) {
+            if (ws[j].de < de - 0.05) continue;
+            if (ws[j].k === alvo || (alvo.length >= 5 && ws[j].k.startsWith(alvo.slice(0, 5)))) { cursor = j + 1; return ws[j].de; }
+        }
+        return null;
+    });
+}
+
+/* As frases da fala: as palavras com tempo repartidas pelo ponto final. */
+function frasesDe(fala, palavras) {
+    const frases = String(fala || '').split(/(?<=[.!?…])\s+/).map((f) => f.trim()).filter(Boolean);
+    const out = [];
+    let j = 0;
+    for (const f of frases) {
+        const n = f.split(/\s+/).filter(Boolean).length;
+        const ws = palavras.slice(j, j + n);
+        j += n;
+        if (ws.length) out.push({ texto: f, palavras: ws.map((w, k) => ({ ...w, texto: f.split(/\s+/).filter(Boolean)[k] || w.texto })) });
+    }
+    return out;
+}
+
+// ── as cores ────────────────────────────────────────────────────────────
+const luz = (h) => { const n = parseInt(String(h).slice(1), 16); return ((n >> 16 & 255) * 0.299 + (n >> 8 & 255) * 0.587 + (n & 255) * 0.114) / 255; };
+const contraste = (a, b) => { const la = luz(a) + 0.05, lb = luz(b) + 0.05; return la > lb ? la / lb : lb / la; };
+const PALETAS = HUMORES.tecnologia.paletas;
+
+function paletaDe(marca, s, humor = null, roteiro = {}) {
+    const c = marca.cores || {};
+    const op = humor ? HUMORES[humor].paletas : PALETAS;
+    const [f0, t0, a0] = op[Math.floor(s.prox() * op.length) % op.length];
+    let base = { fundo: f0, tinta: t0, acento: a0 };
+    // A cor que o assunto diz manda no acento (se não sumir no fundo).
+    const ditas = tokens((roteiro.partes || []).map((p) => [p.titulo, p.destaque].join(' ')).join(' ')).filter((w) => CORES_DITAS[w]);
+    if (ditas.length && contraste(CORES_DITAS[ditas[0]], f0) >= 2.2) base = { ...base, acento: CORES_DITAS[ditas[0]] };
+    const fundo = ehCor(c.fundo) ? c.fundo : base.fundo;
+    let tinta = ehCor(c.tinta) ? c.tinta : (ehCor(c.fundo) ? (luz(fundo) < 0.5 ? '#F4F1EA' : '#121212') : base.tinta);
+    if (contraste(fundo, tinta) < 4) tinta = luz(fundo) < 0.5 ? '#F4F1EA' : '#121212';
+    const acento = ehCor(c.destaque) ? c.destaque : (marca.gradiente && ehCor(marca.gradiente[1]) && !corGenerica(marca.gradiente[1]) ? marca.gradiente[1] : base.acento);
+    return { fundo, tinta, acento };
+}
+/* OS CAMPOS DE COR (30/09, "olha a diferença"): o reel de referência troca o
+   fundo inteiro a cada batida — preto, laranja, creme, azul elétrico, lima —
+   cor chapada, saturada, contraste alto. Cada humor tem o seu sistema de 5
+   (0 = a tinta escura, 1 = a cor-assinatura, 2 = o papel, 3 e 4 = as ousadas);
+   a marca entra no lugar das dela. Nada de bege lavado o vídeo inteiro. */
+const CAMPOS = {
+    tecnologia: [['#0D0D0D', '#FF5B2E', '#EFEAE0', '#2B3BFF', '#DFFF3A'], ['#111111', '#C6F432', '#F1ECE0', '#FF4A1C', '#1F3CFF']],
+    editorial: [['#14110F', '#B3261E', '#F1EADB', '#1F4E3D', '#E9B44C'], ['#121417', '#1F3FBF', '#F3EEE3', '#D9481C', '#E8C547']],
+    energia: [['#0B0B0B', '#FF4F00', '#F2EEE6', '#1D3BD1', '#C9F23A'], ['#101010', '#E8C547', '#F4EBDD', '#E5322D', '#2A57FF']],
+    natureza: [['#0F2A2A', '#F2A541', '#F2EDE2', '#2546D9', '#E4573D'], ['#13233F', '#2546D9', '#F2EDE2', '#F2A541', '#C8553D']],
+    luxo: [['#120D0B', '#C9A24A', '#F0E6D6', '#5B1A1F', '#2F4F4F']],
+};
+function camposDe(marca, humor, s, dita = null) {
+    const c = marca.cores || {};
+    let k = [...s.um(CAMPOS[humor] || CAMPOS.tecnologia)];
+    // A cor que o assunto diz vira a assinatura (se não for a de outro papel).
+    if (dita && !ehCor(c.destaque)) { const j = k.indexOf(dita); if (j > 0) k[j] = k[1]; k[1] = dita; }
+    // A marca: o fundo dela, o destaque dela e a tinta dela tomam os lugares de mesmo papel.
+    const escuro = (x) => luz(x) < 0.35, claro = (x) => luz(x) > 0.7;
+    for (const cor of [c.fundo, c.destaque, c.tinta].filter(ehCor)) {
+        const lugar = escuro(cor) ? 0 : claro(cor) ? 2 : 1;
+        if (!k.includes(cor)) k[lugar] = cor;
+    }
+    if (ehCor(c.destaque) && k[1] !== c.destaque) k[1] = c.destaque;
+    return k;
+}
+/** As cores de uma batida pelo campo dela: texto no contraste máximo, acento noutra cor do sistema. */
+function coresDoCampo(campos, i, s) {
+    const fundo = campos[i];
+    const tintas = [campos[0], campos[2]].sort((a, b) => contraste(b, fundo) - contraste(a, fundo));
+    const texto = tintas[0];
+    const outras = campos.filter((c, j) => j !== i && c !== texto && contraste(c, fundo) >= 2.2);
+    const acento = outras.length ? (outras.includes(campos[1]) && i !== 1 ? campos[1] : s.um(outras)) : texto;
+    return { fundo, texto, fraco: misturarCor(texto, fundo, 0.45), acento, contorno: misturarCor(texto, fundo, 0.6) };
+}
+
+/** As cores de uma batida pelo fundo dela: base (a marca) ou acento (o fundo vira a cor). */
+function coresDaBatida(P, fundo) {
+    if (fundo === 'acento') {
+        const texto = contraste(P.acento, P.fundo) >= contraste(P.acento, P.tinta) ? P.fundo : P.tinta;
+        return { fundo: P.acento, texto, fraco: misturarCor(texto, P.acento, 0.45), acento: texto, contorno: misturarCor(texto, P.acento, 0.6) };
+    }
+    return { fundo: P.fundo, texto: P.tinta, fraco: misturarCor(P.tinta, P.fundo, 0.58), acento: P.acento, contorno: misturarCor(P.tinta, P.fundo, 0.72) };
+}
+
+// ── o som de cada vídeo: uma FAMÍLIA, não um pacote ─────────────────────
+/* "Os efeitos sonoros estão muito repetitivos" e "todo mundo usa os mesmos
+   sons" (30/09). Cada vídeo sintetiza a própria família no ffmpeg — 13
+   variações em 6 gestos (passagem, golpe, nasce, tique, revela, brilho) —
+   com afinação, duração, envelope e filtro sorteados da semente, no timbre
+   do humor: papel (foley de papel e madeira), analógico (pluck e fita),
+   digital (bitcrush), orgânico (madeira e sopro). Receita = argumentos do
+   ffmpeg; sons-leves.js gera os arquivos. */
+const NOTAS = [220, 246.94, 261.63, 293.66, 329.63, 349.23, 392, 440];
+function sonsDoVideo(roteiro = {}) {
+    const semente = hash('som:' + JSON.stringify((roteiro.partes || []).map((p) => [p.titulo, p.fala])) + ((roteiro.marca && roteiro.marca.nome) || ''));
+    const s = sorteador(semente);
+    const timbre = HUMORES[humorDe(roteiro, sorteador(hash('humor')))] ? HUMORES[humorDe(roteiro, s)].som : 'analogico';
+    const raiz = s.um(NOTAS);
+    const escala = [1, 1.189, 1.335, 1.498, 1.782, 2];               // pentatônica menor sobre a raiz
+    const nota = () => Math.round(raiz * s.um(escala) * (s.chance(0.3) ? 2 : 1));
+    const f = (x) => Math.round(x * 1000) / 1000;
+    const crush = timbre === 'digital' ? ',acrusher=bits=' + Math.round(s.entre(5, 9)) + ':mode=log:aa=1' : '';
+    const receitas = {};
+    const varre = (nome) => {
+        const d = f(s.entre(0.32, 0.7)), at = f(d * s.entre(0.45, 0.7)), fc = Math.round(s.entre(timbre === 'papel' ? 500 : 800, timbre === 'papel' ? 1600 : 2600));
+        const cor = timbre === 'papel' ? s.um(['brown', 'pink']) : timbre === 'digital' ? 'white' : 'pink';
+        receitas[nome] = ['-f', 'lavfi', '-i', `anoisesrc=d=${d}:c=${cor}:a=0.9:s=${Math.round(s.entre(1, 9999))}`, '-af',
+            `bandpass=f=${fc}:width_type=o:w=${f(s.entre(1.2, 2.6))},afade=t=in:st=0:d=${at}:curve=exp,afade=t=out:st=${at}:d=${f(d - at)}:curve=qsin,volume=${f(s.entre(1.6, 2.4))}${crush}`];
+    };
+    const fita = (nome) => {   // a fita que para: o tom cai até zero
+        const f0 = nota() * 2, d = f(s.entre(0.35, 0.6));
+        receitas[nome] = ['-f', 'lavfi', '-i', `aevalsrc='0.5*sin(2*PI*${f0}*(t-t*t/(2*${d})))*(1-t/${d})':s=44100:d=${d}`, '-af', `lowpass=f=${Math.round(s.entre(1800, 4000))}${crush}`];
+    };
+    const golpe = (nome) => {
+        const f0 = Math.round(s.entre(timbre === 'papel' ? 85 : 60, timbre === 'papel' ? 120 : 80)), f1 = Math.round(f0 * s.entre(0.4, 0.6)), d = f(s.entre(0.5, 1.0));
+        const ruido = f(timbre === 'papel' ? s.entre(0.4, 0.7) : s.entre(0.15, 0.4));
+        receitas[nome] = ['-f', 'lavfi', '-i', `aevalsrc='0.9*sin(2*PI*(${f0}*t-(${f0 - f1})*t*t/(2*${d})))*exp(-${f(s.entre(4, 8))}*t)+${ruido}*(random(0)*2-1)*exp(-${Math.round(s.entre(30, 60))}*t)':s=44100:d=${d}`,
+            '-af', `lowpass=f=${Math.round(s.entre(1400, 3200))},volume=1.4${crush}`];
+    };
+    const nasce = (nome) => {
+        if (timbre === 'papel' || timbre === 'organico') {   // madeira: tom curto e seco, com o estalo do toque
+            const fq = Math.round(s.entre(380, 900));
+            receitas[nome] = ['-f', 'lavfi', '-i', `aevalsrc='0.7*sin(2*PI*${fq}*t)*exp(-${Math.round(s.entre(45, 80))}*t)+0.25*(random(0)*2-1)*exp(-${Math.round(s.entre(120, 220))}*t)':s=44100:d=0.16`,
+                '-af', `bandpass=f=${fq}:width_type=o:w=2.5,volume=2.2`];
+        } else {               // pluck afinado na raiz do vídeo
+            const fq = nota(), k = Math.round(s.entre(14, 26));
+            receitas[nome] = ['-f', 'lavfi', '-i', `aevalsrc='0.55*exp(-${k}*t)*(sin(2*PI*${fq}*t)+0.45*sin(2*PI*${fq * 2}*t)*exp(-${k}*t)+0.2*sin(2*PI*${fq * 3}*t))':s=44100:d=0.32`,
+                '-af', `afade=t=out:st=0.26:d=0.06${crush}`];
+        }
+    };
+    const tique = (nome) => {
+        if (timbre === 'papel' || timbre === 'organico') {
+            const fc = Math.round(s.entre(2500, 6500));
+            receitas[nome] = ['-f', 'lavfi', '-i', `anoisesrc=d=0.035:c=white:a=0.8:s=${Math.round(s.entre(1, 9999))}`, '-af', `bandpass=f=${fc}:width_type=o:w=1.5,afade=t=out:st=0.005:d=0.03,volume=2.5`];
+        } else {
+            const fq = Math.round(s.entre(1800, 3600));
+            receitas[nome] = ['-f', 'lavfi', '-i', `aevalsrc='0.45*sin(2*PI*${fq}*t)*exp(-${Math.round(s.entre(70, 140))}*t)':s=44100:d=0.07`, ...(crush ? ['-af', crush.slice(1)] : [])];
+        }
+    };
+    const revela = (nome) => {
+        const f0 = nota() / 2, d = f(s.entre(0.9, 1.4));
+        receitas[nome] = ['-f', 'lavfi', '-i', `aevalsrc='(0.3*sin(2*PI*(${f0}+${Math.round(s.entre(300, 800))}*t*t)*t)+${timbre === 'papel' ? 0.32 : 0.18}*(random(0)*2-1))*pow(t/${d},2)':s=44100:d=${d}`,
+            '-af', `highpass=f=${Math.round(s.entre(180, 420))},afade=t=out:st=${f(d - 0.05)}:d=0.05,volume=1.3${crush}`];
+    };
+    const brilho = (nome) => {
+        const a = nota() * 2, b = Math.round(a * s.um([1.25, 1.335, 1.5]));
+        receitas[nome] = ['-f', 'lavfi', '-i', `aevalsrc='0.3*sin(2*PI*${a}*t)*exp(-${f(s.entre(2.5, 4))}*t)+0.22*sin(2*PI*${b}*t)*exp(-${f(s.entre(3, 5))}*t)':s=44100:d=1.3`,
+            ...(timbre === 'papel' ? ['-af', 'lowpass=f=2400'] : [])];
+    };
+    varre('passagem0'); varre('passagem1'); if (timbre === 'papel') varre('passagem2'); else fita('passagem2');
+    golpe('golpe0'); golpe('golpe1');
+    nasce('nasce0'); nasce('nasce1'); nasce('nasce2');
+    tique('tique0'); tique('tique1');
+    revela('revela0'); brilho('brilho0'); brilho('brilho1');
+    return { timbre, raiz, semente, receitas };
+}
+/** O gênero da trilha pelo humor do roteiro, e a semente para sortear a faixa. */
+function musicaDe(roteiro = {}) {
+    const semente = hash('musica:' + JSON.stringify((roteiro.partes || []).map((p) => [p.titulo, p.fala])));
+    const s = sorteador(semente);
+    const h = humorDe(roteiro, s);
+    return { humor: h, genero: s.um(HUMORES[h].generos), semente };
+}
+/* ── O SOM DESENHADO (30/09, terceira volta): "os efeitos repetem e são os
+   genéricos que toda IA usa". Então:
+     densidade  um evento por batida, no máximo (mais dois risers nas grandes
+                revelações); batida sem som também existe — a música carrega;
+     nunca repete  cada evento é um arquivo seu, com parâmetros sorteados
+                (altura, duração, envelope, filtro, pan, cauda de eco);
+     da própria trilha  o riser é um trecho da música AO CONTRÁRIO crescendo,
+                o golpe é a música parando como fita + um sub que cai, a
+                passagem é uma fatia filtrada dela, o chicote é um gaguejo de
+                um pedaço; o ar da câmera é ruído que atravessa o estéreo.
+   Sem trilha, os mesmos gestos saem sintetizados, também um por evento.
+   As receitas usam "{pasta}" no lugar da pasta do projeto (sons-leves.js). */
+function desenharSom(P, { trilha = null, sons = {} } = {}) {
+    const sh = sorteador((P.semente ^ 0x2c1b3c6d) >>> 0);
+    const DUR = P.duracao;
+    const f = (x) => Math.round(x * 1000) / 1000;
+    const musica = trilha ? '{pasta}/' + trilha : null;
+    const receitas = {}, efeitos = [];
+    const pan = () => { const x = sh.entre(-0.7, 0.7); return [f(Math.min(1, 1 - x)), f(Math.min(1, 1 + x))]; };
+    const panF = () => { const [l, r] = pan(); return `pan=stereo|c0=${l}*c0|c1=${r}*c1`; };
+    const eco = () => `aecho=0.8:${f(sh.entre(0.4, 0.75))}:${Math.round(sh.entre(30, 90))}|${Math.round(sh.entre(100, 220))}:${f(sh.entre(0.15, 0.35))}|${f(sh.entre(0.08, 0.2))}`;
+    const ss = () => f(sh.entre(4, Math.max(6, DUR + 20)));          // de onde da trilha sai o pedaço
+    const sint = sonsDoVideo({ partes: P.batidas.map((b) => ({ titulo: b.comp, fala: String(b.de) })) }).receitas;
+    const receita = (gesto) => {
+        if (!musica) {   // sem trilha: a síntese, um arquivo por evento (a semente muda a cada um)
+            const base = { revela: 'revela0', golpe: sh.um(['golpe0', 'golpe1']), fatia: sh.um(['nasce0', 'nasce1', 'nasce2']), gaguejo: sh.um(['passagem0', 'passagem1']), ar: sh.um(['passagem1', 'passagem2']) }[gesto];
+            const args = [...sint[base]];
+            const i = args.indexOf('-af');
+            const extra = `asetrate=44100*${f(sh.entre(0.8, 1.25))},aresample=44100,${eco()},${panF()}`;
+            if (i >= 0) args[i + 1] += ',' + extra; else args.push('-af', extra);
+            return args;
+        }
+        if (gesto === 'revela') {
+            const d = f(sh.entre(0.9, 1.5));
+            return ['-ss', String(ss()), '-t', String(d), '-i', musica, '-af',
+                `areverse,highpass=f=${Math.round(sh.entre(150, 500))},afade=t=in:st=0:d=${f(d * 0.92)}:curve=exp,${eco()},volume=${f(sh.entre(4, 6))},${panF()}`];
+        }
+        if (gesto === 'golpe') {
+            const d = f(sh.entre(0.55, 0.95)), f0 = Math.round(sh.entre(55, 80)), f1 = Math.round(f0 * sh.entre(0.35, 0.55));
+            return ['-ss', String(ss()), '-t', String(d), '-i', musica, '-f', 'lavfi', '-i',
+                `aevalsrc='0.9*sin(2*PI*(${f0}*t-${f((f0 - f1) / (2 * d))}*t*t))*exp(-${f(sh.entre(3.5, 6))}*t)':s=44100:d=${d}`,
+                '-filter_complex', `[0:a]aformat=channel_layouts=stereo,asetrate=44100*${f(sh.entre(0.45, 0.7))},aresample=44100,lowpass=f=${Math.round(sh.entre(900, 2400))},afade=t=out:st=0:d=${d}:curve=exp[m];`
+                    + `[1:a]aformat=channel_layouts=stereo[s];[m][s]amix=inputs=2:weights=${f(sh.entre(0.8, 1.3))} ${f(sh.entre(0.7, 1.1))}:normalize=0,volume=${f(sh.entre(1.4, 2))}`];
+        }
+        if (gesto === 'gaguejo') {
+            const g = f(sh.entre(0.06, 0.13)), n = Math.round(sh.entre(3, 6));
+            return ['-ss', String(ss()), '-t', String(g), '-i', musica, '-af',
+                `aloop=loop=${n}:size=${Math.round(g * 44100)},highpass=f=${Math.round(sh.entre(200, 700))},afade=t=out:st=${f(g * (n + 1) * 0.55)}:d=${f(g * (n + 1) * 0.45)},volume=${f(sh.entre(1.6, 2.4))},${panF()}`];
+        }
+        if (gesto === 'fatia') {
+            const d = f(sh.entre(0.16, 0.38)), fc = Math.round(sh.entre(300, 3200));
+            return ['-ss', String(ss()), '-t', String(d), '-i', musica, '-af',
+                `bandpass=f=${fc}:width_type=o:w=${f(sh.entre(0.8, 2))},afade=t=in:st=0:d=0.006,afade=t=out:st=${f(d * 0.35)}:d=${f(d * 0.65)},${eco()},volume=${f(sh.entre(5, 8))},${panF()}`];
+        }
+        // ar: o ruído que atravessa o estéreo, como a câmera passando
+        const d = f(sh.entre(0.45, 0.8)), ida = sh.chance(0.5);
+        return ['-f', 'lavfi', '-i', `anoisesrc=d=${d}:c=${sh.um(['pink', 'brown'])}:a=0.8:s=${Math.round(sh.entre(1, 99999))}`, '-af',
+            `bandpass=f=${Math.round(sh.entre(500, 1800))}:width_type=o:w=${f(sh.entre(1.4, 2.6))},afade=t=in:st=0:d=${f(d * 0.55)}:curve=exp,afade=t=out:st=${f(d * 0.55)}:d=${f(d * 0.45)},`
+            + `aformat=channel_layouts=stereo,aeval=exprs='val(0)*${ida ? '(1-t/' + d + ')' : '(t/' + d + ')'}|val(1)*${ida ? '(t/' + d + ')' : '(1-t/' + d + ')'}':channel_layout=stereo,volume=${f(sh.entre(4, 6))}`];
+    };
+    const evento = (t, gesto, volume) => {
+        if (t < 0 || t > DUR - 0.1) return;
+        if (efeitos.some((e) => Math.abs(e.t - t) < 0.25)) return;
+        const nome = 'e' + String(efeitos.length).padStart(2, '0') + '-' + gesto;
+        receitas[nome] = receita(gesto);
+        efeitos.push({ t: f(Math.max(0, t + (sh.prox() - 0.5) * 0.02)), nome, gesto, volume: f(volume * (0.85 + sh.prox() * 0.3)) });
+    };
+    const bs = P.batidas;
+    // Os dois risers: antes da primeira grande virada de fundo e antes do fecho.
+    const virada = bs.find((b, i) => i > 0 && b.entrada === 'inunda');
+    if (virada) evento(virada.de - 1.1, 'revela', 0.7);
+    if (bs.length > 2) evento(bs[bs.length - 1].de - 1.2, 'revela', 0.7);
+    // O golpe é raro (um a cada três batidas, nunca dois seguidos): golpe em toda tese vira bate-estaca.
+    let desdeGolpe = 9;
+    const tetoGolpes = Math.max(1, Math.round(bs.length / 3));
+    let golpes = 0;
+    bs.forEach((b, i) => {
+        const g = (b.golpes || [])[0];
+        const forte = g && g.forca >= 1 && desdeGolpe >= 2 && golpes < tetoGolpes;
+        desdeGolpe++;
+        if (forte) { desdeGolpe = 0; golpes++; }
+        if (i === 0) { if (forte) evento(g.t, 'golpe', 0.75); return; }
+        if (!forte && sh.chance(0.18)) return;                          // a batida que respira só com a música
+        if (forte) return evento(g.t, 'golpe', 0.8);
+        const tr = b.entrada;
+        if (tr === 'corte') return evento(b.de, 'golpe', 0.75);
+        if (tr === 'chicote' || tr === 'explode') return evento(b.de - 0.2, 'gaguejo', 0.7);
+        if (tr === 'atravessa' || tr === 'inunda') return evento(b.de - 0.4, 'ar', 0.75);
+        return evento(b.de - 0.08, 'fatia', 0.75);
+    });
+    efeitos.sort((a, b) => a.t - b.t);
+    // O src é o nome que sons-leves.prepararReceitas dá (semente + nome): um arquivo por evento.
+    const sufixo = (P.semente >>> 0).toString(36);
+    const fim = efeitos.map((e) => ({ t: e.t, src: (sons.__pasta || 'midia') + `/sfx-g${sufixo}-${e.nome}.mp3`, volume: e.volume }));
+    return { efeitos: fim, receitas: { semente: P.semente, receitas } };
+}
+
+/* Os nomes antigos (sons-leves.js) valem como reserva de cada gesto. */
+const LEGADO = { passagem: ['whoosh', 'sopro'], golpe: ['impacto', 'toque'], nasce: ['pop', 'bolha'], tique: ['clique'], revela: ['riser', 'subida'], brilho: ['brilho'] };
+
+// ── a montagem ──────────────────────────────────────────────────────────
+/**
+ * @param {object} op
+ * @param {object} op.roteiro   { marca, partes, modelo3d?, semente? }
+ * @param {Array}  op.tempos    [{de, ate, palavras:[{texto,de,ate}]}] por parte
+ * @returns {{ok, plano, partitura, resumo}}
+ */
+function montarGerativo({ 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: efeitos nas transformações, a música abaixa sob a voz ─────
+    /* O SOM (desenharSom): um evento por batida, no máximo — e cada um é um
+       arquivo PRÓPRIO, feito da trilha do vídeo (ou sintetizado, sem trilha). */
+    const somDesenhado = desenharSom(partitura, { trilha, sons });
+    const efeitos = somDesenhado.efeitos;
+    // A música vem cheia nos respiros e abaixa só sob a voz (a faixa chega normalizada a -18 LUFS).
+    const volumes = volumesDaTrilha(tempos.length === partes.length ? tempos : [], DUR, { alto: 0.95, baixo: 0.38 });
+
+    const P = partitura.paleta;
+    const fontesVariaveis = {};
+    for (const f of Object.values(partitura.fontes)) { const e = especEixos(f); if (e != null) fontesVariaveis[f] = e; }
+    const plano = {
+        formato: { largura, altura, fps: FPS },
+        fundoGeral: P.fundo,
+        fontesVariaveis,
+        cenas: [{
+            duracao: DUR,
+            fundo: P.fundo,
+            elementos: [{
+                tipo: 'kit', peca: 'gerativo', partitura,
+                // As chaves "fonte*" são o que o fontes.css procura (remotion.js).
+                fonte: partitura.fontes.display, fonteTexto: partitura.fontes.texto, fonteMono: partitura.fontes.mono,
+                fonteCinetica: partitura.fontes.cinetica, fonteSerifa: partitura.fontes.serifa,
+            }],
+        }],
+        audio: {
+            ...(narracao ? { narracao } : {}),
+            ...(trilha ? { trilha: { src: trilha, volumes, loop: true } } : {}),
+            efeitos,
+        },
+    };
+    return {
+        ok: true, plano, partitura, somReceitas: somDesenhado.receitas,
+        resumo: { cenas: 1, batidas: partitura.batidas.length, segundos: DUR, fps: FPS, composicoes: partitura.batidas.map((b) => b.comp), semente: partitura.semente },
+    };
+}
+
+/** A partitura, sem áudio nem plano — é o que os testes olham. */
+function partituraDe({ roteiro, largura = 1920, altura = 1080, tempos = [] }) {
+    const partes = roteiro.partes || [];
+    const marca = roteiro.marca || {};
+    const W = largura, H = altura, deitado = W >= H;
+    const semente = roteiro.semente != null ? hash('semente:' + roteiro.semente)
+        : hash(JSON.stringify([partes.map((p) => [p.tipo, p.titulo, p.texto, p.fala, p.valor, p.itens, p.nao, p.sim, p.destaque]), marca.nome || '']));
+    const s = sorteador(semente);
+    const humor = humorDe(roteiro, s);
+    const H0 = HUMORES[humor];
+    const P = paletaDe(marca, s, humor, roteiro);
+
+    /* ── as fontes: NADA de cara de IA. A da marca vale se tiver caráter (e
+       eixos para animar); a genérica da marca vira texto, e o título ganha
+       uma face da biblioteca do humor. ─────────────────────────────────── */
+    const pedida = (marca.fontes && marca.fontes.titulo) || '';
+    const pedidaTexto = (marca.fontes && marca.fontes.texto) || '';
+    const boa = (f) => f && VARIAVEIS[f] && !BANIDAS.includes(f) && VARIAVEIS[f].eixos.wght;
+    const display = boa(pedida) ? pedida : s.um(H0.displays);
+    const cinetica = eixoDe(display, 'wdth') && eixoDe(display, 'wdth')[0] <= 75 ? display : s.um(H0.cineticas);
+    const texto = pedidaTexto ? pedidaTexto : (pedida && BANIDAS.includes(pedida) ? pedida : s.um(H0.textos));
+    const serifa = VARIAVEIS[display].serifa ? display : s.um(H0.serifas);
+    const fontes = { display, cinetica, texto, mono: s.um(H0.monos), serifa };
+
+    // ── o quadro: margens e respiro ─────────────────────────────────────
+    // A margem conta com a câmera: ela empurra até ~8% e desliza, e nada pode sair do quadro.
+    const M = Math.round(W * (deitado ? 0.085 : 0.095));
+    const larguraUtil = W - 2 * M;
+    const base = Math.min(W, H) / 1080;
+    const tamRotulo = Math.round((deitado ? 24 : 30) * base);
+    const tem3d = !!roteiro.modelo3d;
+    const ws = temposDasPartes(partes, tempos);
+
+    // ── os limites de cada parte na linha do tempo ────────────────────────
+    const inicio = [];
+    partes.forEach((_, i) => inicio.push(i === 0 ? 0 : r3(Math.max(inicio[i - 1] + 1.4, ws[i].de - 0.12))));
+    const ultimaFala = ws[ws.length - 1];
+    const duracao = r1(Math.max(inicio[inicio.length - 1] + 2.0, (ultimaFala.ate || 0) + 1.15));
+    const fimParte = partes.map((_, i) => (i < partes.length - 1 ? inicio[i + 1] : duracao));
+
+    // ── as batidas: de cada parte, 1 a 3 ─────────────────────────────────
+    const brutas = [];
+    partes.forEach((p, i) => {
+        const c = conteudoDe(p, marca);
+        const palavrasP = ws[i].palavras;
+        const t0 = inicio[i], t1 = fimParte[i];
+        let de = t0;
+        /* A FALA que não é o que aparece ("Feche os olhos. Agora escute." antes
+           de "VÓRTEX H1") vira uma batida própria, palavra por palavra — quando
+           há tempo para as duas e a primeira frase não diz o conteúdo. */
+        const frases = frasesDe(falaDe(p), palavrasP);
+        const chave = tokens(textoDoConteudo(c)).filter((w) => w.length >= 3 && !FUNCAO.has(w));
+        if (frases.length >= 2 && t1 - t0 >= 2.6 && c.tipo !== 'lista') {
+            const f0 = frases[0];
+            const diz = tokens(f0.texto);
+            const cobre = chave.filter((w) => diz.some((d) => d === w || (w.length >= 5 && d.startsWith(w.slice(0, 5))))).length / Math.max(1, chave.length);
+            const ultimaW = f0.palavras[f0.palavras.length - 1];
+            const fimF = r3(Math.max(frases[1].palavras[0].de - 0.1, ultimaW.de + REGRAS.leitura + 0.1));
+            if (cobre < 0.5 && fimF - de >= 1.3 && t1 - fimF >= 1.9 && f0.palavras.length <= 9 && s.chance(0.9)) {
+                brutas.push({ parte: i, de, ate: fimF, conteudo: { tipo: 'falado', texto: f0.texto, palavras: f0.palavras, destaque: p.destaque || '' } });
+                de = fimF;
+            }
+        }
+        brutas.push({ parte: i, de, ate: t1, conteudo: { ...c, destaque: p.destaque || '' }, palavras: palavrasP });
+    });
+
+    // ── a composição de cada batida: sorteada entre as que cabem ─────────
+    const usadas = {};
+    const memoria = {};
+    const batidas = [];
+    let anterior = null;
+    const recentes = [];
+    const escolher = (pesos, { evita = [] } = {}) => {
+        const w = {};
+        for (const [nome, p] of Object.entries(pesos)) {
+            const comp = nome === 'rajada' ? 'gigante' : nome === 'duelo' ? 'pilha' : nome;
+            let q = p;
+            if (comp === anterior || evita.includes(comp)) q = 0;
+            if (recentes.slice(-3).includes(comp)) q *= 0.35;
+            q *= Math.pow(0.72, usadas[comp] || 0);
+            if (comp === 'parede' && (usadas.parede || 0) >= 1) q *= 0.25;
+            w[nome] = q;
+        }
+        return s.pesado(w) || s.pesado({ pilha: anterior === 'pilha' ? 0 : 1, gigante: anterior === 'gigante' ? 0 : 1, palavras: anterior === 'palavras' ? 0 : 1 });
+    };
+    const registra = (b) => { usadas[b.comp] = (usadas[b.comp] || 0) + 1; recentes.push(b.comp); anterior = b.comp; batidas.push(b); };
+
+    brutas.forEach((br, bi) => {
+        const c = br.conteudo;
+        const tituloC = c.titulo || c.nome || c.texto || '';
+        const feat = {
+            curto: tituloC.length <= 22 && tituloC.split(/\s+/).length <= 4,
+            palavras: (c.palavras || []).length, primeira: bi === 0, ultima: bi === brutas.length - 1, tem3d,
+            pergunta: /\?/.test(tituloC), exclama: /!/.test(tituloC), numeroNoTitulo: /\d/.test(tituloC),
+        };
+        let nome = escolher(pesosDe(c, feat));
+        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') {
+            // Cada item vira a sua batida; o título da lista fica como rótulo.
+            const n = c.itens.length;
+            const quandoItem = casar(c.itens, ctx.palavras, { de: br.de });
+            let de = br.de;
+            c.itens.forEach((it, j) => {
+                // Cada item fica no ar o bastante para ser lido: 1 s depois da última linha dele.
+                const MIN = 1.6;
+                const prox = j < n - 1 ? (quandoItem[j + 1] != null ? Math.max(de + MIN, quandoItem[j + 1] - 0.1) : de + (br.ate - de) / (n - j)) : br.ate;
+                const ate = j < n - 1 ? r3(Math.min(prox, br.ate - MIN * (n - j - 1))) : br.ate;
+                const comp = (anterior === 'gigante') ? 'pilha' : 'gigante';
+                const b = compor(comp, { parte: br.parte, de: r3(de), ate, conteudo: { tipo: 'titulo', titulo: (c.numerada ? String(j + 1).padStart(2, '0') + ' ' : '') + it, sub: '', selo: c.titulo, destaque: c.destaque } }, ctx);
+                registra(b);
+                de = ate;
+            });
+            return;
+        }
+        if (nome === 'duelo') {
+            const meio = casar([c.sim], ctx.palavras, { de: br.de + 1.2 })[0];
+            const corte = r3(Math.min(br.ate - 1.4, Math.max(br.de + 1.3, meio != null ? meio - 0.1 : (br.de + br.ate) / 2)));
+            const cNao = anterior !== 'pilha' ? 'pilha' : 'gigante';
+            registra(compor(cNao, { parte: br.parte, de: br.de, ate: corte, conteudo: { tipo: 'titulo', titulo: c.nao, sub: '', riscado: true, destaque: '' } }, ctx));
+            registra(compor(cNao === 'pilha' ? 'gigante' : 'pilha', { parte: br.parte, de: corte, ate: br.ate, conteudo: { tipo: 'titulo', titulo: c.sim, sub: '', destaque: c.destaque } }, ctx));
+            return;
+        }
+        registra(compor(nome, br, ctx));
+    });
+
+    /* ── os campos: o fundo inteiro troca de cor a cada batida (quase sempre),
+       nunca igual ao anterior nem ao de duas antes; a fala e o conteúdo da
+       mesma parte às vezes dividem o campo. O produto 3D pede o campo escuro. */
+    const ditaCor = tokens(partes.map((p) => [p.titulo, p.destaque].join(' ')).join(' ')).map((w) => CORES_DITAS[w]).find(Boolean) || null;
+    const campos = camposDe(marca, humor, s, ditaCor);
+    batidas.forEach((b, i) => {
+        if (i === 0) { b.campo = 0; return; }
+        const a = batidas[i - 1];
+        if (a.parte === b.parte && s.chance(0.4)) { b.campo = a.campo; return; }
+        if (b.produto3d) { b.campo = a.campo === 0 ? 3 : 0; return; }
+        const evita = [a.campo, i > 1 ? batidas[i - 2].campo : -1];
+        const op = campos.map((_, j) => j).filter((j) => !evita.includes(j));
+        b.campo = s.um(op);
+    });
+    for (const b of batidas) { b.fundo = 'campo' + b.campo; b.cores = coresDoCampo(campos, b.campo, s); }
+
+    /* ── os ÍCONES 3D: onde a parte pediria um ícone (lista, número,
+       recurso), um objeto de geometria no material do vídeo. A palavra
+       decide qual; nunca o mesmo duas vezes, e no máximo em ~45% das batidas
+       — ícone em toda batida vira papel de parede de IA. ───────────────── */
+    const material = s.um(['argila', 'verniz', 'metal']);
+    const iconesUsados = new Set();
+    const tetoIcones = Math.ceil(batidas.length * 0.45);
+    for (const b of batidas) {
+        if (iconesUsados.size >= tetoIcones) break;
+        if (b.produto3d || ['parede', 'marca', 'citacao', 'divisao'].includes(b.comp)) continue;
+        const ditas = tokens(b.linhas.map((l) => l.texto).join(' ') + ' ' + ((partes[b.parte] && partes[b.parte].fala) || ''));
+        const ic = ditas.map((w) => ICONE_DE[w]).find((x) => x && !iconesUsados.has(x));
+        if (!ic) continue;
+        iconesUsados.add(ic);
+        const prim = b.linhas[0];
+        b.icone3d = { icone: ic, lado: deitado ? 'direita' : 'acima', tamanho: Math.round(deitado ? 0.4 * H : 0.38 * W), material,
+            cor: b.cores.texto, cor2: b.cores.acento, luz: b.cores.acento, t: r3(Math.min(b.ate - 1, (prim ? prim.t : b.de) + 0.15)) };
+        b.acentos += 1;
+        if (b.acentos > REGRAS.acentos) { b.icone3d.cor2 = misturarCor(b.cores.texto, b.cores.fundo, 0.3); b.acentos -= 1; }
+    }
+
+    /* ── o HERÓI GRÁFICO: toda batida tem uma ideia visual grande além do
+       texto, como no reel de referência — a explosão radial que nasce de um
+       ponto, o polígono que vira estrela e quadrado com partículas em órbita,
+       o campo de truchet com uma onda de cor, a esfera e o toro de pontos em
+       3D, os anéis de órbita, a grade que deforma, os rastros de velocidade.
+       Procedurais, da semente, na paleta da batida; nunca o mesmo seguido. ── */
+    const OBJETOS = ['explosao', 'poligono', 'esfera', 'toro'], CAMPOS_H = ['truchet', 'aneis', 'grade', 'rastro'];
+    const usosH = {};
+    let ultimoH = null;
+    const recentesH = [];
+    batidas.forEach((b, i) => {
+        const ocupado = b.icone3d || b.produto3d;
+        let op = ocupado || ['gigante', 'parede', 'divisao'].includes(b.comp) ? CAMPOS_H : [...OBJETOS, ...CAMPOS_H];
+        if (b.comp === 'parede') op = ['aneis', 'rastro', 'grade'];
+        const w = {};
+        for (const h of op) {
+            let q = OBJETOS.includes(h) ? 2.2 : 1;
+            if (recentesH.slice(-3).includes(h)) q = 0;
+            if (h === 'truchet' && (usosH.truchet || 0) >= 1) q = 0;
+            if ((h === 'esfera' || h === 'toro') && (usosH[h] || 0) >= 1) q = 0;
+            q *= Math.pow(0.5, usosH[h] || 0);
+            w[h] = q;
+        }
+        // Tudo recente: o menos recente de todos os de campo.
+        const reserva = () => CAMPOS_H.filter((x) => !recentesH.slice(-3).includes(x))[0] || CAMPOS_H[0];
+        let h = i === 0 && b.comp === 'marca' ? 'explosao' : s.pesado(w) || reserva();
+        usosH[h] = (usosH[h] || 0) + 1;
+        ultimoH = h;
+        recentesH.push(h);
+        const comCor = b.acentos < REGRAS.acentos;
+        if (comCor) b.acentos += 1;
+        b.heroi = { tipo: h, modo: OBJETOS.includes(h) ? 'objeto' : 'campo', semente: hash(b.id + h) % 9973,
+            cor: comCor ? b.cores.acento : misturarCor(b.cores.texto, b.cores.fundo, 0.25), cor2: b.cores.texto };
+    });
+
+    // ── as passagens: como uma batida vira a outra ──────────────────────
+    let ultimaSaida = null, desdeCorte = 9;
+    const saidasRecentes = [];
+    batidas.forEach((b, i) => {
+        if (i === 0) { b.entrada = 'semente'; return; }
+        const a = batidas[i - 1];
+        let tr;
+        // O campo troca por corte seco, por cortina ou pela inundação do acento — independente do gesto do texto.
+        b.troca = a.campo === b.campo ? null : s.pesado({ corte: 5, cortina: 2.5, inunda: 1.5 });
+        if (b.troca === 'inunda' && s.chance(0.5)) tr = 'inunda';
+        else {
+            const tese = b.linhas.find((l) => l.papel === 'tese' || l.papel === 'numero');
+            /* As passagens EXTRAVAGANTES pesam mais ("motion é vida", 30/09): a
+               letra explode e remonta a próxima palavra, a câmera chicoteia,
+               atravessa a palavra. As calmas ficam de respiro. */
+            const w = { explode: 3, chicote: 2.8, atravessa: 2.4, pontos: 2.2, evapora: 0.8, desliza: 0.3, comprime: eixoDe(fontes.display, 'wdth') ? 1.2 : 0.7,
+                corte: desdeCorte >= 3 && tese && tese.comportamento === 'carimbo' ? 1.8 : 0 };
+            if (a.parte === b.parte) { w.atravessa *= 0.5; w.pontos *= 1.4; }
+            for (const x of saidasRecentes.slice(-3)) w[x] = 0;
+            tr = s.pesado(w);
+        }
+        desdeCorte = tr === 'corte' ? 0 : desdeCorte + 1;
+        ultimaSaida = tr;
+        saidasRecentes.push(tr);
+        b.entrada = tr;
+        a.saida = tr;
+        // O que explode REMONTA: as letras da próxima tese chegam dos estilhaços.
+        if (tr === 'explode') b.linhas.filter((l) => l.papel === 'tese' && !l.marca && !l.riscado).forEach((l) => { l.comportamento = 'monta'; });
+    });
+    batidas[batidas.length - 1].saida = 'fim';
+
+    /* O gesto da tese não volta antes de três batidas — conferido DEPOIS das
+       passagens (o "monta" que a explosão pede também conta): se repetir, a
+       batida ganha outro gesto; se o repetido é o monta, a passagem muda. */
+    const recG = [];
+    const gestoLivre = (fonte) => ['peso', 'carimbo', 'largura', 'contorno', 'onda', 'pontos', 'mascara', 'desfoque']
+        .filter((g) => !recG.slice(-3).includes(g) && (g !== 'largura' || eixoDe(fonte, 'wdth')) && (g !== 'peso' || eixoDe(fonte, 'wght')));
+    batidas.forEach((b, i) => {
+        const teses = b.linhas.filter((l) => (l.papel === 'tese' || l.papel === 'numero') && !l.marca);
+        if (!teses.length) return;
+        let g = teses[0].comportamento;
+        // O contador é sempre "peso" (o número engorda contando): quem vem antes dele cede o peso.
+        const contadorPerto = !b.contador && batidas.slice(i + 1, i + 4).some((x) => x.contador);
+        if (recG.slice(-3).includes(g) || (contadorPerto && g === 'peso')) {
+            if (contadorPerto) recG.push('peso');
+            if (g === 'monta' && i > 0) {
+                const alt = ['pontos', 'atravessa', 'evapora', 'comprime', 'desliza'].find((x) => !saidasRecentes.slice(Math.max(0, i - 4), i - 1).includes(x)) || 'pontos';
+                b.entrada = alt; batidas[i - 1].saida = alt;
+            }
+            const livres = gestoLivre(teses[0].fonte);
+            const novo = livres.length ? s.um(livres) : g;
+            teses.filter((l) => l.comportamento === g).forEach((l) => { l.comportamento = novo; });
+            if (b.contador) teses.forEach((l) => { if (l.id === b.contador.linha) l.comportamento = 'peso'; });
+            g = teses[0].comportamento;
+            if (contadorPerto) recG.pop();
+        }
+        recG.push(g);
+    });
+
+    // ── a vida no repouso: a fonte respira enquanto a gente lê ───────────
+    for (const b of batidas) {
+        const tese = b.linhas.find((l) => l.papel === 'tese' || l.papel === 'numero');
+        const f = tese ? tese.fonte : fontes.display;
+        const op = ['onda', 'deriva', ...(eixoDe(f, 'wght') ? ['respira', 'respira'] : []), ...(eixoDe(f, 'wdth') ? ['estica'] : [])];
+        b.vida = b.comp === 'contador' ? 'respira' : s.um(op);
+    }
+
+    /* ── os GOLPES: a tese bate — escala que soca, tela que treme, impacto
+       no som. Um por batida no máximo, onde a palavra mais forte assenta. */
+    for (const b of batidas) {
+        const t = b.linhas.find((l) => (l.papel === 'tese' || l.papel === 'numero') && !l.riscado);
+        b.golpes = [];
+        if (!t) continue;
+        const pt = t.palavras.find((p) => p.papel === 'tese') || t.palavras[0];
+        const quando = b.contador ? b.contador.t + b.contador.dur : (pt.t || t.t) + (t.comportamento === 'monta' ? 0.32 : t.comportamento === 'carimbo' ? 0.03 : 0.2);
+        if (quando < b.ate - 0.3) b.golpes.push({ t: r3(quando), linha: t.id, forca: b.comp === 'gigante' || b.comp === 'contador' || b.comp === 'parede' ? 1 : 0.6 });
+    }
+
+    // ── a câmera: nunca para; acelera na passagem ────────────────────────
+    const camera = [{ t: 0, x: 0, y: 0, zoom: 1.12, rot: 0, e: 'camera' }];
+    let lado = 1;
+    batidas.forEach((b, i) => {
+        // A câmera tem inércia: o sentido do movimento quase sempre continua (nada de virar a cada batida).
+        if (s.chance(0.2)) lado = -lado;
+        const z0 = r3(1 + s.entre(0, 0.02)), z1 = r3(z0 + s.entre(0.05, 0.09));
+        const x0 = r1(lado * s.entre(0.004, 0.014) * W), x1 = r1(-lado * s.entre(0.01, 0.022) * W);
+        const y0 = r1(s.entre(-0.006, 0.006) * H), y1 = r1(s.entre(-0.01, 0.01) * H);
+        const g0 = r3(s.entre(-0.6, 0.6)), g1 = r3(g0 + lado * s.entre(0.5, 1.1));
+        const assenta = Math.min(b.de + 0.55, (b.de + b.ate) / 2);
+        if (b.entrada === 'corte') camera.push({ t: r3(b.de), x: x0, y: y0, zoom: z0 + 0.04, rot: g0, e: 'degrau' });
+        camera.push({ t: r3(assenta), x: x0, y: y0, zoom: z0, rot: g0, e: i === 0 ? 'camera' : 'editorial' });
+        const fimCalmo = r3(Math.max(assenta + 0.1, b.ate - 0.32));
+        camera.push({ t: fimCalmo, x: x1, y: y1, zoom: z1, rot: g1, e: 'camera' });
+        if (i < batidas.length - 1) {
+            const prox = batidas[i + 1].entrada;
+            const empurra = prox === 'atravessa' ? 0.4 : prox === 'explode' ? 0.16 : prox === 'inunda' ? 0.14 : prox === 'corte' ? 0.03 : 0.1;
+            // O chicote: a câmera sai rasgando de lado, e a próxima chega do outro.
+            const xs = prox === 'chicote' ? -lado * 0.22 * W : x1 * 2.2;
+            camera.push({ t: r3(b.ate), x: r1(xs), y: r1(y1 * 2), zoom: r3(z1 + empurra), rot: r3(g1 + lado * (prox === 'corte' ? 0.3 : prox === 'chicote' ? 2.6 : 2)), e: 'acelera' });
+        } else camera.push({ t: r3(b.ate), x: 0, y: 0, zoom: r3(z1 + 0.03), rot: 0, e: 'camera' });
+    });
+
+    // ── 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 }));
+
+    // ── 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,
+        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) })) };
+
+    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' },
+    };
+}
+
+// ── as composições: de conteúdo + contexto, uma batida ─────────────────
+function compor(comp, br, ctx) {
+    const { s, W, H, M, deitado, base, larguraUtil, tamRotulo, fontes } = ctx;
+    const c = br.conteudo;
+    const palavras = ctx.palavras || [];
+    const b = { id: 'b' + Math.round(br.de * 1000), parte: br.parte, de: r3(br.de), ate: r3(br.ate), comp, origem: c.tipo === 'falado' ? 'falado' : 'conteudo', linhas: [], acento: [] };
+    const eixosDisplay = VARIAVEIS[fontes.display].eixos;
+    const wMax = eixosDisplay.wght[1];
+    const wTese = Math.min(wMax, s.um([800, 900, 900, 1000]));
+    const destaqueTk = tokens(c.destaque || '');
+    const ehTese = (w) => destaqueTk.length && tokens(w).some((k) => destaqueTk.includes(k));
+    let id = 0;
+    const linha = (texto, papel, o = {}) => {
+        const l = {
+            id: b.id + '-' + (id++), texto: String(texto), papel, fonte: o.fonte || fontes.display, tamanho: Math.round(o.tamanho),
+            eixos: o.eixos || { wght: papel === 'tese' || papel === 'numero' ? wTese : papel === 'rotulo' ? 500 : 420 },
+            cor: o.cor || (papel === 'rotulo' || papel === 'fraco' ? 'fraco' : 'texto'), tracking: o.tracking || 0, maiusc: !!o.maiusc,
+            comportamento: o.comportamento || null, riscado: !!o.riscado, envelhece: null,
+        };
+        l.palavras = l.texto.split(/\s+/).filter(Boolean).map((w) => ({ texto: w, papel: ehTese(w) ? 'tese' : funcao(w) ? 'funcao' : 'normal' }));
+        b.linhas.push(l);
+        return l;
+    };
+    // Os pesos DENTRO da frase: artigo leve, verbo regular, tese pesada e maior.
+    const misturarPesos = (l, { maiorTese = 1.12, corTese = true } = {}) => {
+        const [wmin, wmax] = (VARIAVEIS[l.fonte] && VARIAVEIS[l.fonte].eixos.wght) || [300, 800];
+        const temTese = l.palavras.some((p) => p.papel === 'tese');
+        for (const p of l.palavras) {
+            if (p.papel === 'tese') { p.wght = Math.min(wmax, wTese); p.escala = maiorTese; if (corTese) p.cor = 'acento'; }
+            else if (p.papel === 'funcao') p.wght = prende(temTese ? 300 : 380, [wmin, wmax]);
+            else p.wght = prende(temTese ? 520 : l.eixos.wght, [wmin, wmax]);
+        }
+    };
+    const vert = (opcoes) => s.um(opcoes);
+    const tese = (l) => { l.papel = 'tese'; return l; };
+
+    switch (comp) {
+        case 'gigante': {
+            const txt = c.titulo || c.nome || c.sim || c.valor || c.texto || '';
+            const maiusc = txt.length <= 16 && s.chance(0.65);
+            const fonte = s.chance(0.5) ? fontes.cinetica : fontes.display;
+            const eixos = { wght: Math.min(VARIAVEIS[fonte].eixos.wght[1], wTese) };
+            const op = { fonte, wght: eixos.wght, maiusc };
+            const nMax = deitado ? 2 : Math.min(4, txt.split(/\s+/).length);
+            const alvo = deitado ? larguraUtil * 0.96 : larguraUtil;
+            const fit = caberEmLinhas(txt, alvo, nMax, (deitado ? 0.3 : 0.2) * H, op);
+            const alinha = deitado && s.chance(0.35) ? 'esq' : 'centro';
+            b.bloco = { x: alinha === 'esq' ? M : W / 2, y: H * vert(deitado ? [0.5, 0.52, 0.47] : [0.47, 0.5, 0.55]), alinha, vert: 'meio', largura: alvo, gap: 0.04 };
+            if (c.selo) linha(c.selo, 'rotulo', { fonte: fontes.mono, tamanho: tamRotulo, tracking: 0.16, maiusc: true, eixos: { wght: 500 } });
+            for (const t of fit.linhas) {
+                const l = linha(t, 'tese', { fonte, tamanho: fit.tamanho, eixos, maiusc, riscado: c.riscado, cor: c.riscado ? 'fraco' : 'texto' });
+                if (!destaqueTk.length) l.palavras.forEach((p) => { p.papel = 'normal'; });
+            }
+            const ultima = b.linhas[b.linhas.length - 1];
+            if (c.riscado) b.acento.push({ forma: 'risco', alvo: { linha: ultima.id } });
+            else if (/[.!]$/.test(txt) || s.chance(0.4)) b.acento.push({ forma: 'ponto', alvo: { linha: ultima.id, fim: true } });
+            else {
+                const lt = b.linhas.find((l) => l.papel === 'tese' && l.palavras.some((p) => p.papel === 'tese')) || ultima;
+                const pi = Math.max(0, lt.palavras.findIndex((p) => p.papel === 'tese'));
+                b.acento.push({ forma: 'sublinha', alvo: { linha: lt.id, palavra: lt.palavras.some((p) => p.papel === 'tese') ? pi : null } });
+            }
+            if (s.chance(0.5)) b.linhas.filter((l) => l.papel === 'tese').forEach((l) => l.palavras.forEach((p) => { if (p.papel === 'tese') p.cor = 'acento'; }));
+            break;
+        }
+        case 'pilha': case 'produto': {
+            const noProduto = comp === 'produto';
+            const lg = noProduto ? (deitado ? W * 0.42 : larguraUtil) : (deitado ? W * s.entre(0.62, 0.74) : larguraUtil);
+            const principal = c.tipo === 'numero' ? c.valor : (c.titulo || c.nome || c.nao || c.sim || c.texto || '');
+            const nL = 3;
+            const op = { fonte: fontes.display, wght: wTese };
+            const fit = caberEmLinhas(principal, lg, nL, (deitado ? 0.15 : 0.085) * H * (noProduto ? 0.85 : 1), op);
+            const y = noProduto ? (deitado ? H * 0.52 : H * 0.72) : H * vert(deitado ? [0.42, 0.5, 0.58] : [0.44, 0.52, 0.6]);
+            b.bloco = { x: M, y, alinha: 'esq', vert: 'meio', largura: lg, gap: 0.16 };
+            const rot = c.selo || (c.tipo === 'cta' ? '' : '');
+            if (rot) linha(rot, 'rotulo', { fonte: fontes.mono, tamanho: tamRotulo, tracking: 0.16, maiusc: true, eixos: { wght: 500 }, cor: noProduto ? 'acento' : 'fraco' });
+            for (const t of fit.linhas) {
+                const l = linha(t, 'tese', { tamanho: fit.tamanho, riscado: c.riscado, cor: c.riscado ? 'fraco' : 'texto' });
+                if (!c.riscado) misturarPesos(l, { corTese: !noProduto });
+            }
+            if (c.tipo === 'numero') {
+                const t0 = b.linhas.find((l) => l.papel === 'tese');
+                t0.papel = 'numero';
+                b.contador = { linha: t0.id, ...numeroDe(c.valor), dur: 0.9 };
+                if (c.rotulo) linha(c.rotulo, 'apoio', { tamanho: Math.max(30 * base, fit.tamanho * 0.34), eixos: { wght: 600 } });
+            }
+            const apoio = c.sub || c.link || '';
+            if (apoio) {
+                const fa = caberEmLinhas(apoio, lg, 2, Math.max(26 * base, fit.tamanho * 0.36), { fonte: fontes.texto, wght: 400 });
+                fa.linhas.forEach((t) => linha(t, 'apoio', { fonte: fontes.texto, tamanho: fa.tamanho, eixos: { wght: 400 }, cor: c.link ? 'acento' : 'fraco' }));
+            }
+            const teses = b.linhas.filter((l) => l.papel === 'tese' || l.papel === 'numero');
+            if (c.riscado) b.acento.push({ forma: 'risco', alvo: { linha: teses[teses.length - 1].id } });
+            else {
+                const comTese = teses.find((l) => l.palavras.some((p) => p.papel === 'tese'));
+                const forma = s.pesado({ barra: 2, sublinha: comTese ? 2.5 : 0.6, anel: comTese && comTese.palavras.find((p) => p.papel === 'tese').texto.length <= 9 ? 1.6 : 0 });
+                if (forma === 'barra') b.acento.push({ forma: 'barra', alvo: { bloco: true } });
+                else {
+                    const lt = comTese || teses[teses.length - 1];
+                    b.acento.push({ forma, alvo: { linha: lt.id, palavra: comTese ? lt.palavras.findIndex((p) => p.papel === 'tese') : null } });
+                }
+            }
+            // O ThreeCanvas só aceita pixel inteiro; ele ocupa a altura toda, para o chão não cortar.
+            if (noProduto) b.produto3d = deitado ? { x: Math.round(W * 0.42), y: 0, largura: Math.round(W * 0.58), altura: H, escala: 0.95 } : { x: 0, y: -Math.round(H * 0.2), largura: W, altura: H, escala: 0.62 };
+            break;
+        }
+        case 'palavras': {
+            const txt = c.texto || c.titulo || '';
+            const alinha = s.chance(0.55) ? 'esq' : 'centro';
+            const lg = deitado ? W * 0.8 : larguraUtil;
+            const op = { fonte: fontes.display, wght: 600 };
+            const fit = caberEmLinhas(txt, lg, deitado ? 3 : 4, (deitado ? 0.12 : 0.075) * H, op);
+            b.bloco = { x: alinha === 'esq' ? M : W / 2, y: H * vert([0.48, 0.52]), alinha, vert: 'meio', largura: lg, gap: 0.1 };
+            // Sem destaque, a tese é a palavra mais longa que não é função.
+            if (!destaqueTk.length) {
+                const cand = txt.split(/\s+/).filter((w) => !funcao(w)).sort((a, b2) => tokens(b2).join('').length - tokens(a).join('').length)[0];
+                if (cand) destaqueTk.push(...tokens(cand));
+            }
+            for (const t of fit.linhas) { const l = linha(t, 'apoio', { tamanho: fit.tamanho, eixos: { wght: 560 } }); misturarPesos(l, { maiorTese: 1.14 }); }
+            const lt = b.linhas.find((l) => l.palavras.some((p) => p.papel === 'tese'));
+            if (lt) { tese(lt); b.acento.push({ forma: s.chance(0.6) ? 'sublinha' : 'anel', alvo: { linha: lt.id, palavra: lt.palavras.findIndex((p) => p.papel === 'tese') } }); }
+            else b.acento.push({ forma: 'ponto', alvo: { linha: b.linhas[b.linhas.length - 1].id, fim: true } });
+            break;
+        }
+        case 'contador': {
+            const n = numeroDe(c.valor);
+            const fonte = s.chance(0.6) ? fontes.cinetica : fontes.display;
+            const eixos = { wght: Math.min(VARIAVEIS[fonte].eixos.wght[1], wTese) };
+            const alinha = 'centro';
+            const lg = deitado ? W * 0.62 : larguraUtil;
+            const tam = tamanhoQueCabe(c.valor, lg * 0.82, (deitado ? 0.36 : 0.17) * H, { fonte, wght: eixos.wght });
+            b.bloco = { x: alinha === 'esq' ? M : W / 2, y: H * vert(deitado ? [0.48, 0.5] : [0.46, 0.5]), alinha, vert: 'meio', largura: lg, gap: 0.08 };
+            const l = linha(c.valor, 'numero', { fonte, tamanho: tam, eixos });
+            const tRot = Math.max(30 * base, Math.min(tam * 0.22, 64 * base));
+            if (c.rotulo) linha(c.rotulo, 'apoio', { tamanho: tRot, eixos: { wght: 600 }, fonte: fontes.display });
+            if (c.sub) linha(c.sub, 'rotulo', { fonte: fontes.mono, tamanho: tamRotulo, tracking: 0.08, eixos: { wght: 400 } });
+            b.contador = { linha: l.id, ...n, dur: 0.9 };
+            b.acento.push({ forma: c.valor.length <= 4 ? 'anel' : 'sublinha', alvo: { linha: l.id } });
+            break;
+        }
+        case 'cascata': {
+            const lg = deitado ? W * 0.72 : larguraUtil - 40 * base;
+            const itens = c.itens.slice(0, 5);
+            // Fonte larga (Unbounded) aperta a lista: os itens vão na fonte de texto.
+            const fonte = VARIAVEIS[fontes.display].largura > 1.1 ? fontes.texto : fontes.display;
+            const op = { fonte, wght: 560 };
+            const maxT = (deitado ? 0.09 : 0.042) * H;
+            const nL = itens.length <= 3 ? 2 : 1;
+            const tam = Math.min(...itens.map((it) => caberEmLinhas((c.numerada ? '00  ' : '') + it, lg, nL, maxT, op).tamanho));
+            b.bloco = { x: M + 30 * base, y: H * vert(deitado ? [0.5, 0.52] : [0.5, 0.54]), alinha: 'esq', vert: 'meio', largura: lg, gap: 0.42 };
+            if (c.titulo) linha(c.titulo, 'rotulo', { fonte: fontes.mono, tamanho: tamRotulo, tracking: 0.16, maiusc: true, eixos: { wght: 500 } });
+            itens.forEach((it, j) => {
+                const txt = (c.numerada ? String(j + 1).padStart(2, '0') + '  ' : '') + it;
+                quebrar(txt, lg, tam, op, nL).forEach((pedaco, q) => {
+                    const l = linha(pedaco, 'item', { tamanho: tam, fonte, eixos: { wght: 560 } });
+                    if (q > 0) l.continua = true;
+                    if (c.numerada && q === 0) l.palavras[0].papel = 'indice';
+                    l.palavras.forEach((p) => { if (p.papel === 'tese') p.papel = 'normal'; });
+                });
+            });
+            b.acento.push({ forma: 'bala', alvo: { linha: b.linhas.find((l) => l.papel === 'item').id }, segue: true });
+            break;
+        }
+        case 'divisao': {
+            const lado = deitado ? (larguraUtil - M * 0.6) / 2 : larguraUtil;
+            const op = { fonte: fontes.display, wght: wTese };
+            const fN = caberEmLinhas(c.nao, lado, deitado ? 3 : 2, (deitado ? 0.1 : 0.065) * H, { ...op, wght: 400 });
+            const fS = caberEmLinhas(c.sim, lado, deitado ? 3 : 3, (deitado ? 0.12 : 0.08) * H, op);
+            if (deitado) {
+                b.bloco = { x: M, y: H * 0.5, alinha: 'esq', vert: 'meio', largura: lado, gap: 0.1, colunas: [M, M + lado + M * 0.6] };
+            } else {
+                b.bloco = { x: M, y: H * 0.5, alinha: 'esq', vert: 'meio', largura: lado, gap: 0.12, blocos: 2 };
+            }
+            fN.linhas.forEach((t) => { const l = linha(t, 'fraco', { tamanho: fN.tamanho, eixos: { wght: 380 }, cor: 'fraco' }); l.coluna = 0; l.riscado = true; });
+            fS.linhas.forEach((t) => { const l = linha(t, 'tese', { tamanho: fS.tamanho }); l.coluna = 1; misturarPesos(l); });
+            const nao = b.linhas.filter((l) => l.coluna === 0), sim = b.linhas.filter((l) => l.coluna === 1);
+            b.acento.push({ forma: 'risco', alvo: { linha: nao[Math.floor((nao.length - 1) / 2)].id } });
+            const lt = sim.find((l) => l.palavras.some((p) => p.papel === 'tese')) || sim[sim.length - 1];
+            b.acento.push({ forma: 'sublinha', alvo: { linha: lt.id, palavra: lt.palavras.some((p) => p.papel === 'tese') ? lt.palavras.findIndex((p) => p.papel === 'tese') : null } });
+            break;
+        }
+        case 'citacao': {
+            const fonte = fontes.serifa;
+            const lg = deitado ? W * 0.78 : larguraUtil;
+            const q = String(c.texto || '').replace(/^["“]+|["”]+$/g, '');
+            const fit = caberEmLinhas(q, lg, deitado ? 4 : 5, (deitado ? 0.12 : 0.065) * H, { fonte, wght: 420 });
+            b.bloco = { x: M, y: H * vert([0.48, 0.52]), alinha: 'esq', vert: 'meio', largura: lg, gap: 0.16 };
+            linha('“', 'aspas', { fonte, tamanho: fit.tamanho * 1.6, eixos: { wght: 800 }, cor: 'acento' });
+            fit.linhas.forEach((t) => { const l = linha(t, 'apoio', { fonte, tamanho: fit.tamanho, eixos: { wght: 420, ...(VARIAVEIS[fonte].eixos.SOFT ? { SOFT: 100, WONK: 1 } : {}) } }); l.palavras.forEach((p) => { if (p.papel === 'tese') { p.wght = 700; } }); });
+            if (c.autor) linha('— ' + c.autor, 'rotulo', { fonte: fontes.mono, tamanho: tamRotulo, tracking: 0.06, eixos: { wght: 400 } });
+            const lt = b.linhas.find((l) => l.palavras.some((p) => p.papel === 'tese'));
+            if (lt) { tese(lt); b.acento.push({ forma: 'marca', alvo: { linha: lt.id, palavra: lt.palavras.findIndex((p) => p.papel === 'tese'), ate: lt.palavras.map((p) => p.papel).lastIndexOf('tese') } }); }
+            else b.acento.push({ forma: 'barra', alvo: { bloco: true } });
+            break;
+        }
+        case 'marca': {
+            const nome = c.nome || c.titulo || (ctx.marca.nome || '');
+            const fonte = fontes.display;
+            const lg = deitado ? W * 0.7 : larguraUtil * 0.9;
+            const tam = tamanhoQueCabe(nome, lg, (deitado ? 0.22 : 0.13) * H, { fonte, wght: 800 });
+            b.bloco = { x: W / 2 + tam * 0.3, y: H * 0.5, alinha: 'centro', vert: 'meio', largura: lg, gap: 0.2 };
+            linha(nome, 'tese', { fonte, tamanho: tam, eixos: { wght: Math.min(800, VARIAVEIS[fonte].eixos.wght[1]) }, comportamento: 'contorno' }).marca = true;
+            if (c.sub || c.link) linha(c.sub || c.link, 'rotulo', { fonte: fontes.mono, tamanho: tamRotulo, tracking: 0.2, maiusc: true, eixos: { wght: 400 } });
+            b.acento.push({ forma: 'ponto', alvo: { linha: b.linhas[0].id, antes: true } });
+            break;
+        }
+        case 'parede': {
+            const txt = c.titulo || c.nome || '';
+            const fonte = fontes.cinetica;
+            const maiusc = true;
+            const tam = tamanhoQueCabe(txt, larguraUtil, (deitado ? 0.2 : 0.1) * H, { fonte, wght: 900, maiusc });
+            b.bloco = { x: W / 2, y: H * 0.5, alinha: 'centro', vert: 'meio', largura: larguraUtil, gap: 0.1 };
+            linha(txt, 'tese', { fonte, tamanho: tam, eixos: { wght: Math.min(900, VARIAVEIS[fonte].eixos.wght[1]) }, maiusc });
+            b.textura = { texto: (maiusc ? txt.toUpperCase() : txt), tamanho: tam, fonte, linhas: Math.ceil(H / (tam * 1.02)) + 3, velocidade: Math.round(s.entre(40, 90) * base) };
+            b.acento.push({ forma: s.chance(0.5) ? 'moldura' : 'sublinha', alvo: { linha: b.linhas[0].id } });
+            break;
+        }
+        default: throw new Error('composição desconhecida: ' + comp);
+    }
+
+    // ── o comportamento de cada linha, do que os eixos permitem ─────────
+    /* Um GESTO por grupo: as linhas da mesma frase entram do mesmo jeito (a
+       frase é uma ação só); rótulo, apoio e itens têm o gesto deles. */
+    const gestos = {};
+    for (const l of b.linhas) {
+        if (l.comportamento) continue;
+        const grupo = l.papel === 'numero' ? 'tese' : l.papel;
+        if (gestos[grupo] && l.fonte === gestos[grupo].fonte) { l.comportamento = gestos[grupo].c; continue; }
+        const eixosF = VARIAVEIS[l.fonte] ? VARIAVEIS[l.fonte].eixos : {};
+        const temW = eixosF.wght && eixosF.wght[1] - eixosF.wght[0] >= 400;
+        const temL = !!eixosF.wdth && eixosF.wdth[0] <= 80;
+        let op;
+        /* Sem embaralhar e sem split-flap: leem como defeito ("natural, não
+           estranho", 30/09). Os gestos ficam físicos: peso, largura, máscara. */
+        if (l.papel === 'tese' || l.papel === 'numero') op = { carimbo: 2, peso: temW ? 2.6 : 0, largura: temL ? 2.4 : 0, contorno: 1.3, onda: 1.1, pontos: 1.2, mascara: 1.2, desfoque: 1 };
+        else if (l.papel === 'rotulo') op = { tracking: 1.5, mascara: 2, desfoque: 1.2 };
+        else if (l.papel === 'aspas') op = { carimbo: 1 };
+        else op = { mascara: 2, desfoque: 2.2, tracking: 1.2, onda: 1, peso: temW ? 1.2 : 0 };
+        l.comportamento = s.pesado(op);
+        gestos[grupo] = { c: l.comportamento, fonte: l.fonte };
+    }
+    // A MESMA tese não entra do mesmo jeito da batida anterior (não é template).
+    const tese0 = b.linhas.find((l) => l.papel === 'tese' || l.papel === 'numero');
+    // Nenhum gesto da tese volta antes de três batidas.
+    const mem = ctx.memoria || {};
+    mem.gestos = mem.gestos || [];
+    if (tese0 && !tese0.marca && mem.gestos.slice(-3).includes(tese0.comportamento)) {
+        const livres = ['peso', 'carimbo', 'largura', 'contorno', 'onda', 'pontos', 'mascara', 'desfoque'].filter((g) => !mem.gestos.slice(-3).includes(g)
+            && (g !== 'largura' || (VARIAVEIS[tese0.fonte] && VARIAVEIS[tese0.fonte].eixos.wdth)) && (g !== 'peso' || (VARIAVEIS[tese0.fonte] && VARIAVEIS[tese0.fonte].eixos.wght)));
+        const novo = livres.length ? s.um(livres) : tese0.comportamento;
+        const velho = tese0.comportamento;
+        b.linhas.filter((l) => (l.papel === 'tese' || l.papel === 'numero') && l.comportamento === velho && !l.marca).forEach((l) => { l.comportamento = novo; });
+    }
+    if (tese0) mem.gestos.push(tese0.comportamento);
+    if (b.contador) b.linhas.find((l) => l.id === b.contador.linha).comportamento = 'peso';
+
+    /* ENCHER: a estimativa de largura erra para fonte larga ou estreita; o
+       componente mede e cresce o grupo principal até a largura do bloco,
+       com o teto vertical daqui (o respiro de 30–40% continua garantido). */
+    // A palavra-herói de ponta a ponta (o CLAUDE do reel): teto alto, a largura manda.
+    const tetoV = { gigante: deitado ? 0.44 : 0.24, marca: deitado ? 0.3 : 0.16, parede: deitado ? 0.26 : 0.13, contador: deitado ? 0.52 : 0.22,
+        pilha: deitado ? 0.22 : 0.12, produto: deitado ? 0.14 : 0.08, palavras: deitado ? 0.12 : 0.08, cascata: deitado ? 0.1 : 0.05, divisao: deitado ? 0.13 : 0.085, citacao: deitado ? 0.12 : 0.07 }[b.comp] || 0.1;
+    // A SANGRIA (a palavra de ponta a ponta) é um momento, não o padrão: até duas por vídeo, só em palavra curta.
+    const memS = ctx.memoria || {};
+    if (['gigante', 'parede'].includes(b.comp) && (memS.cheios || 0) < 2 && b.linhas.filter((l) => l.papel === 'tese').length <= 2
+        && b.linhas.every((l) => l.texto.length <= 12) && s.chance(0.6)) { b.cheio = true; memS.cheios = (memS.cheios || 0) + 1; }
+    const enche = (l) => ['tese', 'numero', 'item'].includes(l.papel) || (b.comp === 'citacao' && l.papel === 'apoio') || (b.comp === 'palavras' && l.papel === 'apoio');
+    // O bloco inteiro cabe na área segura: o teto por linha divide a altura útil (~72%) pelo número de linhas que enchem.
+    const nEnche = Math.max(1, ...[0, 1].map((col) => b.linhas.filter((l) => enche(l) && (l.coluna == null || l.coluna === col)).length));
+    for (const l of b.linhas) {
+        if (!enche(l)) continue;
+        l.encher = l.papel === 'item' ? 'item' : 'principal';
+        // O respiro do guia: fora dos (no máximo dois) momentos de sangria, o bloco usa ~55% da altura e a tese não encosta em nada.
+        l.max = Math.round(b.cheio ? Math.min(tetoV * H, (H * 0.66) / (nEnche * 1.05)) : Math.min(tetoV * H * 0.72, (H * 0.5) / (nEnche * 1.05)));
+    }
+    // ── o tempo de cada linha e palavra: quando a voz diz ────────────────
+    tempoDaBatida(b, palavras, ctx);
+    // ── o acento: quando cada estado dele começa ─────────────────────────
+    acentoNoTempo(b, ctx);
+    // A linha que continua o item é o mesmo elemento (o item quebrou em duas).
+    b.elementos = b.linhas.filter((l) => !l.continua).length + (b.textura ? 1 : 0) + (b.produto3d ? 1 : 0);
+    b.acentos = contarAcentos(b);
+    return b;
+}
+
+function tempoDaBatida(b, palavras, ctx) {
+    const Q = QUADRO;
+    const fim = b.ate - REGRAS.leitura;          // a última entrada deixa 1 s de leitura
+    const ordem = b.linhas.filter((l) => l.papel !== 'aspas');
+    const quando = casar(ordem.map((l) => l.texto), palavras, { de: b.de - 0.05 });
+    // Lista: cada item no instante em que é dito; o resto, em cascata depois do anterior.
+    let t = b.de + 0.12;
+    /* O passo entre o que NÃO é dito: a cascata dá tempo de ler cada item
+       (até 0,7 s); o resto, o stagger do guia (3–6 quadros). */
+    const naoDitos = quando.filter((q) => q == null).length;
+    const janela = Math.max(0, fim - b.de - 0.3);
+    const passo = b.comp === 'cascata' && naoDitos > 1
+        ? Math.max(5 * Q, Math.min(0.7, janela / Math.max(1, ordem.length - 1)))
+        : ctx.s.um([3, 4, 5, 6]) * Q;
+    ordem.forEach((l, i) => {
+        if (l.continua && i) { l.t = r3(t + 2 * Q); t = l.t; return; }
+        const falado = quando[i];
+        l.t = r3(Math.max(i === 0 ? b.de + 0.1 : t + REGRAS.stagger[0] * Q, falado != null ? falado : (i === 0 ? b.de + 0.12 : t + passo)));
+        t = l.t;
+    });
+    /* Quadro morto não: a primeira coisa da batida entra em até 0,35 s, mesmo
+       que a voz ainda não a tenha dito (o resto segue a voz). */
+    if (ordem[0] && ordem[0].t > b.de + 0.35) ordem[0].t = r3(b.de + 0.35);
+    for (let i = 1; i < ordem.length; i++) if (ordem[i].t < ordem[i - 1].t + REGRAS.stagger[0] * Q) ordem[i].t = r3(ordem[i - 1].t + REGRAS.stagger[0] * Q);
+    // Nada entra tarde demais para ser lido: de trás para frente, com o stagger mínimo.
+    for (let i = ordem.length - 1; i >= 0; i--) {
+        const teto = i === ordem.length - 1 ? fim : ordem[i + 1].t - (ordem[i + 1].continua ? 2 : REGRAS.stagger[0]) * Q;
+        if (ordem[i].t > teto) ordem[i].t = r3(teto);
+    }
+    for (let i = 0; i < ordem.length; i++) {
+        const piso = i === 0 ? b.de + 0.03 : ordem[i - 1].t + (ordem[i].continua ? 2 : REGRAS.stagger[0]) * Q;
+        if (ordem[i].t < piso) ordem[i].t = r3(piso);
+    }
+    const aspas = b.linhas.find((l) => l.papel === 'aspas');
+    if (aspas) aspas.t = r3(Math.max(b.de + 0.03, ordem[0].t - 4 * Q));
+    /* A FALA, palavra por palavra: na batida falada, a k-ésima palavra na tela
+       é a k-ésima da frase — o tempo dela é o da voz, exato. */
+    if (b.origem === 'falado') {
+        let k = 0;
+        for (const l of b.linhas) {
+            for (const p of l.palavras) { const w = palavras[k++]; if (w) p.t = r3(Math.min(w.de, Math.max(b.de + 0.03, fim))); }
+            l.t = l.palavras[0].t;
+        }
+        for (let i = 1; i < ordem.length; i++) if (ordem[i].t < ordem[i - 1].t + REGRAS.stagger[0] * Q) ordem[i].t = r3(ordem[i - 1].t + REGRAS.stagger[0] * Q);
+        for (const l of b.linhas) l.palavras.forEach((p, j) => { if (j === 0 || p.t < l.t) p.t = Math.max(p.t, l.t); });
+    }
+    // As palavras: a fala faladas na hora; as outras seguem a linha.
+    for (const l of b.linhas) {
+        if (b.origem === 'falado') continue;
+        const qs = b.origem === 'falado' || b.comp === 'palavras' ? casar(l.palavras.map((p) => p.texto), palavras, { de: l.t - 0.05 }) : l.palavras.map(() => null);
+        let tw = l.t;
+        l.palavras.forEach((p, j) => {
+            const alvo = qs[j] != null ? qs[j] : (j === 0 ? l.t : tw + 2 * Q);
+            p.t = r3(Math.min(Math.max(j === 0 ? l.t : tw + 2 * Q, alvo), Math.max(l.t, fim)));
+            tw = p.t;
+        });
+    }
+    // A cascata envelhece: o item anterior perde a cor quando o próximo entra.
+    const itens = b.linhas.filter((l) => l.papel === 'item');
+    const cabecas = itens.filter((l) => !l.continua);
+    itens.forEach((l) => { const prox = cabecas.find((h) => h.t > l.t + 0.001 && itens.indexOf(h) > itens.indexOf(l)); if (prox) l.envelhece = prox.t; });
+    if (b.contador) b.contador.t = b.linhas.find((l) => l.id === b.contador.linha).t;
+}
+
+function acentoNoTempo(b, ctx) {
+    const Q = QUADRO;
+    const [ta, tb] = REGRAS.traco;
+    const dur = () => r3(ctx.s.um([ta, 12, 14, tb]) * Q);
+    const alvoT = (a) => {
+        const l = a.alvo && a.alvo.linha ? b.linhas.find((x) => x.id === a.alvo.linha) : b.linhas.find((x) => x.papel === 'tese') || b.linhas[0];
+        return l;
+    };
+    const fim = b.ate - 0.5;
+    if (b.acento[0] && b.acento[0].segue) {
+        // O marcador anda com a lista: um estado por item.
+        const itens = b.linhas.filter((l) => l.papel === 'item' && !l.continua);
+        const a0 = b.acento[0];
+        b.acento = itens.map((l) => ({ forma: 'bala', alvo: { linha: l.id }, t: r3(Math.max(b.de + 0.05, l.t - 2 * Q)), dur: r3(8 * Q) }));
+        void a0;
+        return;
+    }
+    let prev = b.de;
+    b.acento.forEach((a, i) => {
+        const l = alvoT(a);
+        const base = l ? l.t + (a.forma === 'ponto' && a.alvo.antes ? -0.05 : REGRAS.burst[0] * Q * 0.75) : b.de + 0.2;
+        a.t = r3(Math.min(fim, Math.max(prev + (i ? 0.25 : 0.05), base)));
+        a.dur = dur();
+        prev = a.t + a.dur;
+    });
+}
+
+function contarAcentos(b) {
+    const formas = b.acento.length ? 1 : 0;           // o traço é UM, que anda
+    const linhasAcento = b.linhas.filter((l) => l.cor === 'acento').length;
+    const palavrasAcento = b.linhas.reduce((n, l) => n + (l.cor === 'acento' ? 0 : l.palavras.filter((p) => p.cor === 'acento').length ? 1 : 0), 0);
+    let n = formas + linhasAcento + palavrasAcento;
+    // Passou de três: a cor sai primeiro das palavras, depois das linhas de apoio.
+    if (n > REGRAS.acentos) {
+        for (const l of b.linhas) { if (n <= REGRAS.acentos) break; if (l.cor !== 'acento' && l.palavras.some((p) => p.cor === 'acento')) { l.palavras.forEach((p) => { if (p.cor === 'acento') p.cor = null; }); n--; } }
+        for (const l of b.linhas) { if (n <= REGRAS.acentos) break; if (l.cor === 'acento' && l.papel !== 'aspas') { l.cor = 'fraco'; n--; } }
+    }
+    return n;
+}
+
+module.exports = {
+    montarGerativo, partituraDe, sonsDoVideo, musicaDe, desenharSom, humorDe, corGenerica, BANIDAS, HUMORES, REGRAS, VARIAVEIS, COMPOSICOES, COMPORTAMENTOS, SAIDAS, ACENTOS, FPS,
+    especEixos, sorteador, hash, larguraEm, conteudoDe, casar,
+};