primocode 10.0.9 → 10.2.0

package/lib/estudio/estilo.js

@@ -14,6 +14,8 @@
  *   hibrido     O PADRÃO do vídeo: o cinema com o kit por cima — foto e vídeo reais
  *               que não param, e o motion por cima (hibrido.js)
  *   composicao  a composição antiga, uma cena por parte (composicao.js)
+ *   fluido      minimalista: uma ideia por batida, a forma de uma vira a da próxima,
+ *               sem corte (fluido.js). É o que "fluido", "minimalista", "clean" e "apple" pedem.
  *
  * Quem manda, em ordem: o estilo que o AGENTE pediu; o do roteiro (a menos
  * que o pedido diga motion); o que o pedido descreve; e o motion.
@@ -21,15 +23,18 @@
 
 'use strict';
 
-const ESTILOS = ['hibrido', 'gerativo', 'motion', 'vox', 'marca', 'lancamento', 'impacto', 'cinema', 'composicao'];
+const variedade = require('./variedade.js');
+
+const ESTILOS = ['hibrido', 'gerativo', 'motion', 'vox', 'marca', 'lancamento', 'impacto', 'cinema', 'composicao', 'fluido'];
 // Nomes que o modelo usa para os mesmos estilos.
 /* "motion" agora é o GERATIVO ("não pode ter template", 29–30/09); o motion
    antigo segue pelo nome "classico" (e "limpo", o nome mais antigo dele). */
 const APELIDOS = { motion: 'gerativo', generativo: 'gerativo', kinetic: 'gerativo', cinetico: 'gerativo', 'cinético': 'gerativo',
     tipografico: 'gerativo', 'tipográfico': 'gerativo', animacao: 'gerativo', 'animação': 'gerativo',
     classico: 'motion', 'clássico': 'motion', 'motion-classico': 'motion', motion3d: 'motion',
-    absurdo: 'hibrido', misto: 'hibrido', mix: 'hibrido', 'híbrido': 'hibrido', limpo: 'motion', explainer: 'vox', editorial: 'vox', brand: 'marca', branding: 'marca', 'brand-reveal': 'marca', launch: 'lancamento', 'lançamento': 'lancamento', produto: 'lancamento' };
+    absurdo: 'hibrido', misto: 'hibrido', mix: 'hibrido', 'híbrido': 'hibrido', limpo: 'motion', explainer: 'vox', editorial: 'vox', brand: 'marca', branding: 'marca', 'brand-reveal': 'marca', minimalista: 'fluido', minimal: 'fluido', clean: 'fluido', apple: 'fluido', launch: 'lancamento', 'lançamento': 'lancamento', produto: 'lancamento' };
 
+const PEDE_FLUIDO = /\bfluid[oa]\b|minimalista|\bminimal\b|\bclean\b|\bapple\b/i;
 const PEDE_MOTION = /\bmotion\b|anima[çc][ãa]o|animad[oa]/i;
 const PEDE_VOX = /\bvox\b|explica|explainer|document[aá]rio|editorial|hist[oó]ria d[aoe]s?\b/i;
 const PEDE_MARCA = /\bbrand|identidade visual|revela[çc][ãa]o d[ae] marca|\blogo(tipo|marca)?\b|vinheta de marca/i;
@@ -43,24 +48,46 @@ const normal = (e) => {
     return ESTILOS.includes(n) ? n : null;
 };
 
-function escolherEstilo({ pedido = '', agente = null, roteiro = null } = {}) {
+/* O RODÍZIO: quando ninguém escolheu ("vários estilos... que não sejam padrão
+   da IA", Joel 05/10), o padrão não é sempre o híbrido — gira entre os que
+   servem a qualquer roteiro, sem repetir os últimos (memória 'estilo'). */
+/* Com imagem pedida (08/10): o padrão é o FLUIDO MISTO — motion com a
+   imagem em poucos momentos, cada uma entrando de um jeito. O híbrido e o
+   cinema ("10 mil imagens de banco e a mesma animação") ficam pelo nome. */
+const RODIZIO = ['fluido'];
+/* Sem imagem (o padrão desde 07/10), o rodízio fica nos dois motions que
+   nasceram das referências boas (motions-exemplos/motion-god): o fluido e o
+   gerativo. O impacto (emoji 3D em cada batida, cara de anúncio) saiu do
+   rodízio em 08/10 — "horríveis, nada a ver com as referências" — e fica
+   para quem o pede pelo nome (o agente ou o roteiro). */
+const RODIZIO_SEM_IMAGEM = ['fluido', 'gerativo'];
+
+function estiloDaVez(aleatorio = Math.random, semImagem = false) {
+    const lista = semImagem ? RODIZIO_SEM_IMAGEM : RODIZIO;
+    return variedade.sortear(lista, 'estilo', { aleatorio }) || lista[0];
+}
+
+function escolherEstilo({ pedido = '', agente = null, roteiro = null, girar = false, semImagem = false, aleatorio } = {}) {
     const pedidoAgente = normal(agente);
     if (pedidoAgente) return pedidoAgente;
     const doRoteiro = normal(roteiro);
     /* Pedir MOTION (ou animação) é pedir o gerativo — antes do vox, da marca e
        do lançamento, que são leiaute fixo ("não pode ter template", 30/09). */
-    if (doRoteiro && !(doRoteiro !== 'gerativo' && PEDE_MOTION.test(pedido))) return doRoteiro;
+    if (doRoteiro && !(doRoteiro !== 'gerativo' && doRoteiro !== 'fluido' && PEDE_MOTION.test(pedido))) return doRoteiro;
+    // O fluido é um jeito de motion: "motion minimalista" é o fluido, não o gerativo.
+    if (PEDE_FLUIDO.test(pedido)) return 'fluido';
     if (PEDE_MOTION.test(pedido)) return 'gerativo';
     if (PEDE_VOX.test(pedido)) return 'vox';
     if (PEDE_MARCA.test(pedido)) return 'marca';
     if (PEDE_LANCAMENTO.test(pedido)) return 'lancamento';
     /* Anúncio, reels e o resto: o HÍBRIDO. "Um mix da versão antiga (o reels
        da imersão, no cinema) e da última (o kit) — absurdo, que nem parece
-       que foi IA" (29/09). O impacto segue existindo, se pedido pelo nome. */
-    return 'hibrido';
+       que foi IA" (29/09). Com `girar`, o padrão roda (RODIZIO). */
+    if (girar) return estiloDaVez(aleatorio, semImagem);
+    return semImagem ? 'gerativo' : 'hibrido';
 }
 
 /** Os estilos que usam os efeitos leves e a trilha do ende.app (os de motion, não os de corte). */
-const LEVES = new Set(['gerativo', 'motion', 'vox', 'marca', 'lancamento']);
+const LEVES = new Set(['gerativo', 'motion', 'vox', 'marca', 'lancamento', 'fluido']);
 
-module.exports = { escolherEstilo, ESTILOS, LEVES, PEDE_MOTION };
+module.exports = { escolherEstilo, estiloDaVez, ESTILOS, LEVES, PEDE_MOTION, PEDE_FLUIDO, RODIZIO, RODIZIO_SEM_IMAGEM };

package/lib/estudio/fluido.js

@@ -0,0 +1,352 @@
+/**
+ * fluido.js — o estilo FLUIDO: uma ideia por batida, muito respiro, e nada
+ * de corte. O elemento de uma batida VIRA o da próxima.
+ *
+ *   "Uma ideia por quadro, muito espaço vazio. Texto pequeno, caixa normal,
+ *    sans limpa. Movimento contínuo: um elemento se transforma no próximo."
+ *    — a referência de motion do Joel (05/10), os vídeos bons.
+ *
+ * Existe UMA forma que vive o vídeo inteiro (o "portador"): é o ponto da
+ * abertura, a pílula do título, o anel do número, a primeira pílula da lista,
+ * a linha que risca o "não", o cartão da citação e o primeiro círculo da
+ * marca no fim. Entre uma batida e outra ela muda de lugar, de tamanho, de
+ * raio e de preenchimento — o olho segue a forma, e o corte some.
+ *
+ * O texto entra palavra por palavra (stagger curto, ease-out forte, sem
+ * linear) e cada frase tem UM acento: uma palavra em serifa itálica na cor de
+ * acento. Fundo em gradiente grande e macio, de uma paleta curta (no máximo
+ * dois acentos e os neutros), clara ou escura.
+ *
+ * Proibido aqui, de propósito (é a lista do "cara de IA"): HUD, cantoneira,
+ * timecode, caixa na palavra-chave, neon, partícula e CAIXA ALTA.
+ *
+ * Puro: devolve a partitura (os testes olham) e o plano com UMA peça do kit
+ * (kit/fluido.jsx), que desenha a partitura quadro a quadro.
+ */
+
+'use strict';
+
+const { volumesDaTrilha } = require('./ritmo.js');
+
+const FPS = 30;
+const r2 = (n) => Math.round(n * 100) / 100;
+const POR_PALAVRA = 0.3, MINIMO = 0.8;   // o tempo de leitura: 0,3 s por palavra, nunca menos de 0,8 s
+const STAGGER = 0.07;                    // entre uma palavra e a próxima (a que a voz não diz)
+const ANTES = 0.12;                      // a batida troca isto antes da primeira palavra da frase
+
+/* As paletas: um fundo em três tons (o gradiente), a tinta, a tinta suave e
+   NO MÁXIMO dois acentos (o da palavra e o brilho difuso). */
+const PALETAS = {
+    noite: { escuro: true, fundo: ['#020615', '#061a5c', '#1240c9'], tinta: '#eef2ff', suave: '#9fb0d9', acentos: ['#8fb8ff', '#2f6bff'] },
+    /* As CHAPADAS das referências boas (08/10): fundo de uma cor só, sem o
+       gradiente — o laranja da "criatividade", o branco com azul, o preto puro
+       e o cobalto. O "sempre o mesmo azul" era vício. */
+    laranja: { escuro: false, fundo: ['#f2621f', '#f06a28', '#ec7a3c'], tinta: '#1a0d05', suave: '#5a2a10', acentos: ['#fff4ea', '#ffd2b0'] },
+    branco: { escuro: false, fundo: ['#ffffff', '#f6f7fa', '#eceff6'], tinta: '#0b0d12', suave: '#6b7180', acentos: ['#1f4bff', '#9fb3ff'] },
+    preto: { escuro: true, fundo: ['#000000', '#050505', '#121212'], tinta: '#f5f5f5', suave: '#8a8a8a', acentos: ['#ff7a3d', '#ff9a66'] },
+    cobalto: { escuro: true, fundo: ['#1238e6', '#1640f0', '#2350ff'], tinta: '#ffffff', suave: '#c8d4ff', acentos: ['#ffe14d', '#ffffff'] },
+    breu: { escuro: true, fundo: ['#030304', '#0b0a12', '#2a2156'], tinta: '#f4f4f6', suave: '#8d8a9c', acentos: ['#b4a6ff', '#5b45ff'] },
+    lavanda: { escuro: false, fundo: ['#f5f4ff', '#e4e1ff', '#b9b2ff'], tinta: '#17153a', suave: '#6e6a92', acentos: ['#4a3ce0', '#8f86ff'] },
+    creme: { escuro: false, fundo: ['#fbf8f2', '#f2e8d8', '#e7c9a5'], tinta: '#1e1a15', suave: '#857a6c', acentos: ['#c2502a', '#f0a36b'] },
+};
+const ESCURAS = ['noite', 'breu', 'preto', 'cobalto'], CLARAS = ['lavanda', 'creme', 'laranja', 'branco'];
+
+const hash = (s) => { let h = 2166136261; for (const c of String(s)) h = Math.imul(h ^ c.charCodeAt(0), 16777619); return h >>> 0; };
+
+/** A paleta: a pedida pelo nome; senão o tema (claro/escuro); senão a semente. */
+function paletaDe(roteiro, semente) {
+    const pedida = String(roteiro.paleta || '').toLowerCase();
+    const tema = String(roteiro.tema || '').toLowerCase();
+    const nome = PALETAS[pedida] ? pedida
+        : /claro|light/.test(tema) ? CLARAS[semente % CLARAS.length]
+            : /escuro|dark/.test(tema) ? ESCURAS[semente % ESCURAS.length]
+                : Object.keys(PALETAS)[semente % Object.keys(PALETAS).length];
+    const p = { nome, ...PALETAS[nome], acentos: [...PALETAS[nome].acentos] };
+    // A cor da marca vira o acento da palavra (e só ela: a paleta não cresce).
+    const dest = roteiro.marca && roteiro.marca.cores && roteiro.marca.cores.destaque;
+    if (/^#[0-9a-f]{6}$/i.test(dest || '')) p.acentos[0] = dest;
+    return p;
+}
+
+/* Caixa alta não entra: frase GRITADA vira caixa normal (sigla curta fica). */
+function caixaNormal(t) {
+    const s = String(t || '').trim();
+    const letras = s.replace(/[^A-Za-zÀ-ÿ]/g, '');
+    if (letras.length < 4 || letras !== letras.toUpperCase()) return s;
+    const m = s.toLowerCase();
+    return m.charAt(0).toUpperCase() + m.slice(1);
+}
+
+const VAZIAS = new Set('a o as os um uma de da do das dos e é em no na nos nas que com por para pra se seu sua você ao à mais muito isso este esta não sim'.split(' '));
+const limpa = (w) => w.toLowerCase().normalize('NFD').replace(/[̀-ͯ]/g, '').replace(/[^a-z0-9]/g, '');
+
+/** A frase em palavras, com UM acento: o destaque pedido, ou a palavra de mais peso. */
+function frase(texto, { destaque = '', semAcento = false } = {}) {
+    const ws = caixaNormal(texto).split(/\s+/).filter(Boolean);
+    let ac = -1;
+    if (!semAcento && ws.length > 1) {
+        const d = limpa(String(destaque).split(/\s+/)[0] || '');
+        if (d) ac = ws.findIndex((w) => limpa(w) === d);
+        if (ac < 0) {
+            // A palavra mais longa que não é vazia; no empate, a mais tarde (a frase termina nela).
+            let melhor = 0;
+            ws.forEach((w, i) => { const n = limpa(w).length; if (!VAZIAS.has(limpa(w)) && n >= 4 && n >= melhor) { melhor = n; ac = i; } });
+        }
+    }
+    return ws.map((t, i) => ({ t, acento: i === ac }));
+}
+
+const numeroDe = (v) => {
+    const m = String(v == null ? '' : v).match(/^(\D*)([\d.,]+)(.*)$/);
+    if (!m) return null;
+    const n = Number(m[2].replace(/\./g, '').replace(',', '.'));
+    return Number.isFinite(n) ? { antes: m[1], ate: n, depois: m[3], casas: /,\d/.test(m[2]) ? 1 : 0 } : null;
+};
+const itensDe = (p) => (p.itens || []).map((i) => (typeof i === 'string' ? i : i.texto || i.titulo || '')).filter(Boolean);
+const leitura = (n) => Math.max(MINIMO, POR_PALAVRA * n);
+
+/* A forma do portador em cada tipo de parte (kit/fluido.jsx dá o tamanho). */
+const FORMA = { abertura: 'ponto', titulo: 'pilula', numero: 'anel', lista: 'pilula', passos: 'ponto', contraste: 'linha', citacao: 'cartao', cta: 'marca' };
+const TIPO = { logo: 'abertura', imagem: 'titulo', produto: 'titulo', grafico: 'lista', cores: 'lista' };
+
+/**
+ * A partitura: as batidas, cada uma com as frases (e quando cada uma entra),
+ * a forma do portador e a transição. Sem áudio nem plano — é o que os testes olham.
+ */
+function partituraDe({ roteiro, largura = 1920, altura = 1080, tempos = [], imagens = {} }) {
+    const partes = (roteiro.partes || []).filter((p) => p && typeof p === 'object');
+    const semente = Number.isFinite(roteiro.semente) ? roteiro.semente : hash(JSON.stringify(partes.map((p) => [p.tipo, p.titulo, p.valor])));
+    const paleta = paletaDe(roteiro, semente);
+    const marca = roteiro.marca || {};
+    const temVoz = tempos.length === partes.length && tempos.every((t) => t && t.ate > t.de);
+    /* O comando do terminal: o link da cta, se for comando; senão o nome da marca. */
+    const link = (partes.find((p) => p.tipo === 'cta') || {}).link || '';
+    const cmd = /^(npm|npx|pnpm|yarn|pip|brew|curl|git|bun)\b/.test(link) ? link : String(marca.nome || 'app').toLowerCase().replace(/\s+/g, '-');
+    let comCartao = 0;
+    /* O cartão de produto só quando o vídeo É de produto: tem marca, um
+       comando de instalar ou um link. Um vídeo sobre sono saía com um
+       terminal "$ app" ao lado do título (teste de 08/10). `p.ui` explícito vale sempre. */
+    const deProduto = !!(marca.nome || link || /\b(app|software|plataforma|ferramenta|produto|sistema|saas|api|cli)\b/i.test(String(roteiro.pedido || '')));
+
+    const batidas = partes.map((p, i) => {
+        /* Fecho sem marca não monta a "marca de bolinhas" (vício, 08/10): vira
+           uma frase — e, curta, a gigante do fim. */
+        const tipo = p.tipo === 'cta' && !marca.nome ? 'titulo' : TIPO[p.tipo] || (FORMA[p.tipo] ? p.tipo : 'titulo');
+        const titulo = p.titulo || p.texto || '';
+        const fr = [];
+        const poe = (papel, texto, o = {}) => { if (String(texto || '').trim()) fr.push({ id: `${i}-${fr.length}`, papel, palavras: frase(texto, o) }); };
+        const b = { i, tipo, forma: FORMA[tipo], transicao: p.corte === true && i > 0 ? 'corte' : 'morfa', frases: fr, lado: 'centro' };
+        /* O CARTÃO DE PRODUTO que flutua ao lado (terminal, chat, painel), feito
+           de forma e texto — e o texto vai para o outro lado. `ui: false` tira. */
+        const ui = p.ui === false ? null : typeof p.ui === 'string' ? p.ui
+            : !deProduto ? null
+                : tipo === 'titulo' || tipo === 'abertura' ? ['terminal', 'chat'][comCartao % 2] : tipo === 'numero' ? 'painel' : null;
+        if (ui) {
+            b.lado = comCartao++ % 2 ? 'dir' : 'esq';
+            b.ui = ui === 'terminal' ? { tipo: ui, linhas: ['$ ' + cmd, '✓ ' + caixaNormal(p.sub || titulo)] }
+                : ui === 'chat' ? { tipo: ui, pergunta: caixaNormal(titulo) }
+                    : { tipo: 'painel', rotulo: caixaNormal(p.rotulo || titulo), barras: [0, 1, 2, 3, 4, 5, 6].map((k) => r2(0.35 + ((semente >>> (k * 3)) % 7) / 10)) };
+        }
+        switch (tipo) {
+            case 'numero': {
+                b.numero = numeroDe(p.valor);
+                poe('numero', p.valor, { semAcento: true });
+                poe('rotulo', p.rotulo || titulo, { destaque: p.destaque });
+                break;
+            }
+            case 'lista': case 'passos':
+                poe('principal', titulo, { destaque: p.destaque });
+                itensDe(p).slice(0, tipo === 'passos' ? 6 : 4).forEach((it) => poe('item', it, { semAcento: true }));
+                break;
+            case 'contraste':
+                poe('nao', p.nao, { semAcento: true });
+                poe('sim', p.sim || titulo, { destaque: p.destaque });
+                break;
+            case 'citacao':
+                poe('principal', titulo, { destaque: p.destaque });
+                poe('autor', p.autor ? `— ${p.autor}` : '', { semAcento: true });
+                break;
+            case 'cta':
+                b.marca = { nome: caixaNormal(marca.nome || titulo) };
+                poe('marca', b.marca.nome, { semAcento: true });
+                poe('principal', marca.nome ? titulo : '', { destaque: p.destaque });
+                poe('sub', p.link || p.sub, { semAcento: true });
+                break;
+            default:
+                poe('principal', titulo, { destaque: p.destaque });
+                poe('sub', p.sub, { semAcento: true });
+        }
+        return b;
+    });
+
+    /* ── A PALAVRA GIGANTE e a VIRADA (08/10): nas referências boas, o
+       momento forte é uma frase curta que ENCHE a tela, e o fundo vira
+       (o ponto cresce até cobrir tudo de cor). Sem isso o vídeo era a mesma
+       pílula pequena no mesmo azul por 36 s — "horríveis". Regras de editor:
+       só frase de até 4 palavras, abertura ou com destaque (a palavra-tese)
+       primeiro; gigante em até metade das batidas; a virada só nas que têm
+       destaque, 1 em 3 e nunca seguida. `p.gigante` explícito manda. */
+    const curta = (b) => { const f = b.frases.find((x) => x.papel === 'principal'); return f && f.palavras.length <= 4 && b.frases.length <= 2; };
+    const candidatas = batidas.map((b, i) => ({ b, i, p: partes[i] }))
+        .filter(({ b, p }) => p.gigante !== false && (b.tipo === 'titulo' || b.tipo === 'abertura') && !b.ui && !b.imagem && curta(b))
+        .sort((x, y) => (y.p.gigante === true) - (x.p.gigante === true) || !!y.p.destaque - !!x.p.destaque || (x.b.tipo === 'abertura' ? -1 : 0) || x.i - y.i);
+    /* ── AS IMAGENS, quando a pessoa pediu (08/10: "deve ser misto com imagens
+       e motion, e com variadas animações"; o híbrido era "10 mil imagens de
+       banco e a mesma animação"). A imagem é UM momento: só nas batidas que
+       têm imagem baixada, no máximo 1 em 3, nunca duas seguidas. E cada uma
+       entra de um JEITO diferente, sem repetir no vídeo:
+         janela   a foto abre da esquerda e cobre a tela, o texto por cima
+         circulo  o ponto cresce em círculo com a foto dentro
+         cartao   a foto num cartão que gira em 3D, o texto acima
+         faixa    uma faixa da foto abre na altura, o texto abaixo
+         vazado   o título gigante com a foto por DENTRO das letras        */
+    const JEITOS = ['janela', 'circulo', 'cartao', 'faixa', 'vazado'];
+    const ordemJeitos = JEITOS.map((j, k) => ({ j, o: hash(j + semente) })).sort((a, b) => a.o - b.o).map((x) => x.j);
+    const tetoImagem = Math.max(1, Math.floor(batidas.length / 3));
+    let nImagem = 0;
+    for (const b of batidas) {
+        const img = imagens[b.i];
+        if (!img || !img.src || b.tipo === 'cta' || nImagem >= tetoImagem) continue;
+        if (batidas[b.i - 1] && batidas[b.i - 1].imagem) continue;
+        const pr = b.frases.find((f) => f.papel === 'principal');
+        let jeito = ordemJeitos[nImagem % ordemJeitos.length];
+        if (jeito === 'vazado' && !(pr && pr.palavras.length <= 3)) jeito = ordemJeitos[(nImagem + 1) % ordemJeitos.length] === 'vazado' ? 'janela' : ordemJeitos[(nImagem + 1) % ordemJeitos.length];
+        b.imagem = { src: img.src, jeito };
+        b.ui = null; b.lado = 'centro';
+        nImagem++;
+    }
+
+    // A gigante pode seguir outra (as referências fazem isso); a VIRADA é o golpe: 1 em 3, nunca seguida.
+    const teto = Math.max(1, Math.ceil(batidas.length / 2)), tetoVirada = Math.max(1, Math.floor(batidas.length / 3));
+    for (const { b, i, p } of candidatas) {
+        if (batidas.filter((x) => x.gigante).length >= teto && p.gigante !== true) break;
+        b.gigante = true;
+        const viradas = batidas.filter((x) => x.virada).length;
+        const vizinha = (batidas[i - 1] && batidas[i - 1].virada) || (batidas[i + 1] && batidas[i + 1].virada);
+        if (i > 0 && viradas < tetoVirada && !vizinha && (p.destaque || p.gigante === true)) b.virada = true;
+    }
+
+    /* ── o tempo: a VOZ manda. A batida troca na fronteira da frase (um
+       pouco antes da primeira palavra da parte) e cada palavra na tela
+       aparece no instante em que é dita (os tempos por palavra da narração).
+       A palavra que a voz não diz entra em cascata curta. Se o texto pede
+       mais leitura do que a frase deu, a batida estica e a próxima volta a
+       casar com a voz na primeira folga; o atraso medido vai na partitura. */
+    let atraso = 0, sincronia = 0;
+    batidas.forEach((b, i) => {
+        const tp = temVoz ? tempos[i] : null;
+        const deVoz = tp ? (i === 0 ? 0 : Math.max(0, tp.de - ANTES)) : null;
+        b.de = r2(i === 0 ? 0 : Math.max(batidas[i - 1].ate, deVoz == null ? 0 : deVoz));
+        if (deVoz != null) atraso = Math.max(atraso, r2(b.de - deVoz));
+        const ditas = ((tp && tp.palavras) || []).map((w) => ({ k: limpa(w.texto), de: w.de }));
+        let cursor = 0, livre = b.de + (b.tipo === 'cta' ? 0.55 : 0.12);
+        const fimVoz = tp ? (i < batidas.length - 1 ? tempos[i + 1].de - ANTES : tp.ate + 0.2) : 0;
+        for (const f of b.frases) {
+            /* Casa as palavras da tela com as faladas, na ordem. Tenta começar de
+               cada palavra (a frase da tela pode vir em outra ordem que a falada)
+               e fica com o casamento que acha mais palavras. */
+            const casa = (k, d) => d === k || (k.length >= 4 && d.length >= 4 && d.slice(0, 5) === k.slice(0, 5));
+            /* Cada frase procura as suas palavras na fala INTEIRA da batida: com
+               um cursor só, o título que casava com o fim da fala deixava o
+               subtítulo sem achar as dele (entrava 0,45 s atrasado, 08/10). */
+            let ts = f.palavras.map(() => null), fim = cursor;
+            for (let ini = 0; ini < f.palavras.length; ini++) {
+                let c = 0;
+                const tt = f.palavras.map((w, j) => {
+                    const k = limpa(w.t);
+                    if (j < ini || !k) return null;
+                    for (let q = c; q < Math.min(ditas.length, c + 40); q++) if (casa(k, ditas[q].k)) { c = q + 1; return ditas[q].de; }
+                    return null;
+                });
+                if (tt.filter((x) => x != null).length > ts.filter((x) => x != null).length) { ts = tt; fim = c; }
+            }
+            cursor = fim;
+            f.falada = ts.filter((x) => x != null).length >= f.palavras.length / 2;
+            const ach = ts.findIndex((x) => x != null);
+            /* O que a voz não diz entra cedo o bastante para ser lido antes de a
+               frase acabar (e nunca antes da batida). */
+            /* O que a voz DIZ entra quando ela diz — nunca antes. Antes de 08/10
+               a frase entrava no começo da batida se a voz demorasse: "ontem à
+               noite" aparecia 2,8 s antes de ser dito, e o Joel viu "atrasos
+               entre a narração e o vídeo". */
+            let t = ach >= 0 && ts[ach] != null ? ts[ach] - ach * STAGGER
+                : tp ? Math.max(b.de + 0.25, Math.min(livre, fimVoz - leitura(f.palavras.length) - 0.05)) : livre;
+            f.palavras.forEach((w, j) => {
+                const falada = ts[j];
+                t = Math.max(b.de + 0.06, falada != null ? Math.max(t, falada - 0.05) : t);
+                w.em = r2(t);
+                if (falada != null) sincronia = Math.max(sincronia, r2(w.em - falada));
+                t += STAGGER;
+            });
+            f.de = f.palavras[0].em;
+            // O que não é dito (rótulo, item, link) entra logo depois do anterior.
+            livre = Math.max(livre, f.papel === 'item' && b.tipo === 'passos' ? f.de + leitura(f.palavras.length) * 0.8 : f.palavras[f.palavras.length - 1].em + 0.18);
+        }
+        /* O texto que a voz DIZ é lido junto com ela: fica até depois da última
+           palavra dita (e nunca menos de 0,8 s). O que a voz não diz pede 0,3 s por palavra. */
+        const precisa = Math.max(...b.frases.map((f) => f.de + (f.falada
+            ? Math.max(MINIMO, f.palavras[f.palavras.length - 1].em - f.de + 0.3) : leitura(f.palavras.length))), b.de + 0.9);
+        b.ate = r2(Math.max(precisa, fimVoz));
+    });
+    // A marca do fim segura um instante; o resto não espera.
+    const ult = batidas[batidas.length - 1];
+    ult.ate = r2(ult.ate + (ult.tipo === 'cta' ? 1.0 : 0.5));
+
+    return {
+        versao: 2, semente, fps: FPS, atraso, sincronia, largura, altura, duracao: ult.ate, paleta,
+        marcador: roteiro.marcador || ['brilho', 'numero', 'traco', 'ponto', 'nenhum'][hash('marcador' + semente) % 5],
+        fontes: { texto: 'Inter', serifa: 'Instrument Serif', mono: 'JetBrains Mono' },
+        logo: marca.logo || null,
+        batidas,
+    };
+}
+
+/**
+ * @param {object} op
+ * @param {object} op.roteiro   { marca, paleta?: noite|breu|lavanda|creme, tema?: claro|escuro, partes }
+ * @param {Array}  op.tempos    [{de, ate, palavras}] por parte (da narração)
+ * @param {object} op.sons      os efeitos leves (sons-leves.js)
+ */
+function montarFluido({ roteiro, largura = 1920, altura = 1080, tempos = [], narracao = null, sons = {}, trilha = null, imagens = {} }) {
+    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, imagens });
+    const DUR = partitura.duracao;
+    /* O SOM segue o movimento (sons-leves.js, tudo sintetizado): whoosh em
+       cada transformação, pop quando pílula ou cartão assenta, clique na roda e
+       no terminal, um bolha discreto na palavra de acento, o riser que leva à
+       marca e o impacto quando ela trava. Baixo: a voz vem primeiro. */
+    const efeitos = [];
+    const som = (t, nome, volume) => { if (sons[nome]) efeitos.push({ t: r2(Math.max(0, t)), src: sons[nome], volume }); };
+    for (const b of partitura.batidas) {
+        if (b.i > 0 && b.tipo !== 'cta') som(b.de - 0.18, 'whoosh', 0.2);
+        if (b.ui) { som(b.de + 0.6, 'pop', 0.16); if (b.ui.tipo === 'terminal') b.ui.linhas.forEach((_, k) => som(b.de + 0.75 + k * 0.5, 'clique', 0.1)); }
+        for (const f of b.frases) {
+            if (f.papel === 'item') som(f.de - 0.06, b.tipo === 'passos' ? 'clique' : 'pop', 0.15);
+            const ac = f.palavras.find((w) => w.acento);
+            if (ac && f.papel !== 'item') som(ac.em, 'bolha', 0.09);
+        }
+        if (b.tipo === 'citacao') som(b.de + 0.3, 'pop', 0.14);
+        if (b.tipo === 'cta') { som(b.de - 0.75, 'riser', 0.2); som(b.de + 0.45, 'impacto', 0.26); som(b.de + 0.5, 'brilho', 0.16); }
+    }
+    const volumes = volumesDaTrilha(tempos.length === partes.length ? tempos : [], DUR, { alto: 0.55, baixo: 0.22 });
+    const P = partitura.paleta;
+    const plano = {
+        formato: { largura, altura, fps: FPS },
+        fundoGeral: P.fundo[0],
+        fontesVariaveis: { Inter: 'wght@300..700', 'Instrument Serif': 'ital@0;1', 'JetBrains Mono': 'wght@400;500' },
+        cenas: [{
+            duracao: DUR,
+            fundo: P.fundo[0],
+            elementos: [{ tipo: 'kit', peca: 'fluido', partitura, fonte: partitura.fontes.texto, fonteSerifa: partitura.fontes.serifa, fonteMono: partitura.fontes.mono }],
+        }],
+        audio: {
+            ...(narracao ? { narracao } : {}),
+            ...(trilha ? { trilha: { src: trilha, volumes, loop: true } } : {}),
+            efeitos,
+        },
+    };
+    return { ok: true, plano, partitura, resumo: { cenas: 1, batidas: partitura.batidas.length, imagens: partitura.batidas.filter((b) => b.imagem).map((b) => b.imagem.jeito), segundos: DUR, fps: FPS, paleta: P.nome, atraso: partitura.atraso, sincronia: partitura.sincronia } };
+}
+
+module.exports = { montarFluido, partituraDe, caixaNormal, PALETAS, POR_PALAVRA, MINIMO };

package/lib/estudio/gerativo.js

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

package/lib/estudio/hibrido.js

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