primocode 10.4.4 → 10.4.7

package/README.md

@@ -1,4 +1,4 @@
-# PrimoCode v10.4.4
+# PrimoCode v10.4.7
 
 Agente de engenharia brasileiro para o terminal, no estilo Claude Code.
 Cria arquivos de verdade, roda comandos, **controla o navegador e o desktop** —
@@ -9,7 +9,7 @@ OpenRouter, e cada apelido (`top`/`main`/`fast`) é uma **corrente**: se um mode
 está no limite de pedidos, o próximo atende. Você não vê o erro, e não paga nada.
 
 ```
- ▐▛███▜▌   Primo Code v10.4.4
+ ▐▛███▜▌   Primo Code v10.4.7
 ▝▜█████▛▘  Bem-vindo de volta, Joel
   ▘▘ ▝▝    ~/primocode  · /dir <pasta> muda
 ```

package/lib/catalogo.js

@@ -93,7 +93,7 @@ const GRUPOS = [
                 + 'contraste{nao,sim} citacao{texto,autor} imagem{busca,titulo,sub} grafico{titulo,barras:[{rotulo,valor}]} cta{titulo,link} '
                 + 'logo{titulo} cores{cores:[{nome,hex}]} produto{titulo,texto,destaque,selo,barras}. Em qualquer parte: destaque (a palavra-tese), fonte (a fonte citada). O texto da TELA sai da FALA: o título usa palavras que a fala diz, cedo na frase (a tela entra quando a voz diz; palavra que a voz não diz deixa a tela esperando). '
                 + 'visual:{titulo,texto,paleta} (hibrido, cinema, impacto): fonte e cor do cardápio (estudio_midia acao:fontes); sem visual, o PrimoCode sorteia sem repetir os últimos vídeos. '
-                + 'estilo (SEM IMAGEM é o padrão: escolha o motion que serve a ESTE roteiro, ou deixe vazio e ele gira entre gerativo, fluido e impacto): hibrido (SÓ quando a pessoa pediu imagem: foto e vídeo reais + o motion por cima; dê busca:"termo em inglês" só nas partes em que a imagem agrega) | gerativo (= motion: sem template — a tipografia anima nos eixos da fonte numa linha do tempo contínua, composição, fonte, cor e som sorteados do roteiro; modelo3d fone|celular|notebook|relogio|garrafa|lata|caixa: o objeto gira em 3D numa batida — ponha quando o vídeo é de um produto ou objeto físico; ideia abstrata, história ou explicação: deixe vazio; o vídeo tem UMA identidade (2 chãos, 1 acento, 2 fontes) e o fundo só troca na virada de seção — se o roteiro tem atos, dê secao:"nome curto" nas partes, senão o PrimoCode divide; moldura cantos|completa|false: o quadro fixo do reel (cantos, o assunto no alto, "01 · seção", o tempo) — ponha só se o vídeo pede cara de peça de design; vazio, o PrimoCode alterna com memória e às vezes não põe; heroi em cada parte: o desenho da batida além do texto, tirado do CONTEÚDO — um ícone do Iconify do objeto que a fala cita ("mdi:bread-slice", "mdi:qrcode"; procure com estudio_midia acao:icones), um 3D do kit (raio|relogio|check|balao|escudo|coracao|estrela|sol|play|engrenagem|cadeado|barras|fone|onda|celular|seta|bateria) ou "nenhum" quando a tipografia basta; forma abstrata (explosao|poligono|esfera|toro|truchet|aneis|grade|rastro) só em assunto abstrato ou de tecnologia — numa conversa de padaria, nunca; ambiente limpo|luz|bokeh e acento traco|viagem (o ponto que viaja entre as batidas): vazio, o PrimoCode escolhe com memória e o bokeh quase não sai fora de tecnologia) | classico (o motion 3D antigo) | vox (explainer editorial: tinta sobre papel, câmera que conta a frase) | '
+                + 'estilo (SEM IMAGEM é o padrão: escolha o motion que serve a ESTE roteiro, ou deixe vazio e ele gira entre gerativo, fluido e impacto): hibrido (SÓ quando a pessoa pediu imagem: foto e vídeo reais + o motion por cima; dê busca:"termo em inglês" só nas partes em que a imagem agrega) | gerativo (= motion: sem template — a tipografia anima nos eixos da fonte numa linha do tempo contínua, composição, fonte, cor e som sorteados do roteiro; modelo3d fone|celular|notebook|relogio|garrafa|lata|caixa: o objeto gira em 3D numa batida — ponha quando o vídeo é de um produto ou objeto físico; ideia abstrata, história ou explicação: deixe vazio; o vídeo tem UMA identidade (2 chãos, 1 acento, 2 fontes) e o fundo só troca na virada de seção — se o roteiro tem atos, dê secao:"nome curto" nas partes, senão o PrimoCode divide; moldura cantos|completa: o quadro fixo do reel (cantos, o assunto no alto, "01 · seção", o tempo) — SÓ quando a pessoa pedir; vazio = sem moldura (ela entrega que o vídeo foi gerado); heroi em cada parte: o desenho da batida além do texto, tirado do CONTEÚDO — um ícone do Iconify do objeto que a fala cita ("mdi:bread-slice", "mdi:qrcode"; procure com estudio_midia acao:icones), um 3D do kit (raio|relogio|check|balao|escudo|coracao|estrela|sol|play|engrenagem|cadeado|barras|fone|onda|celular|seta|bateria) ou "nenhum" quando a tipografia basta; forma abstrata (explosao|poligono|esfera|toro|truchet|aneis|grade|rastro) só em assunto abstrato ou de tecnologia — numa conversa de padaria, nunca; ambiente limpo|luz|bokeh e acento traco|viagem (o ponto que viaja entre as batidas): vazio, o PrimoCode escolhe com memória e o bokeh quase não sai fora de tecnologia) | classico (o motion 3D antigo) | vox (explainer editorial: tinta sobre papel, câmera que conta a frase) | '
                 + 'marca (brand reveal: brilho, letras em vetor, marca cromada, padrão) | lancamento (produto: cartões, painel, calendário) | fluido (minimalista: uma ideia por batida, a forma de uma vira a próxima, sem corte; paleta noite|breu|preto|cobalto (escuras) ou lavanda|creme|laranja|branco (claras) — escolha pelo assunto e NÃO repita a do vídeo anterior; vazio, o PrimoCode escolhe; fontesFluido aprovado|editorial|revista|carater|tecnico|classico, vazio gira) | impacto | cinema | personagem (o vídeo GRAVADO em 3D — cada parte é UMA fala {falante, texto, emocao?, destaque?}, sem tipo: personagens modelados — gente ou robô — conversando num set de podcast/estúdio/escritório, a boca segue a voz, gestos, e a câmera corta entre aberto, ombro e close; use quando o pedido fala em personagem, boneco, avatar, podcast, entrevista, ou alguém FALANDO em 3D. Com dois falantes (falante em cada parte) eles conversam; personagens:{"nome":{tipo:robo|pessoa, pele, cabelo:curto|cacheado|longo|topete|coque|careca, corCabelo, roupa, oculos, barba, rotulo}} — nome de IA vira robô sozinho; emocao feliz|serio|surpreso|pensativo|animado|curioso e destaque:"texto curto" (o cartão na tela) em cada parte; cenario podcast|estudio|escritorio|noite). '
                 + 'marca e lancamento aceitam visual:orbe|vetor|esfera|grade|site|padrao|cromo|cartoes|painel|cores numa parte. marca.nome dá o nome. '
                 + 'voz (thalita|antonio|francisca). DUAS VOZES (o pedido fala em dois narradores, diálogo, conversa, entrevista): roteiro.vozes {"nome":"antonio","outro":"thalita"} e falante:"nome" em cada parte — cada um sai na sua voz. Ajuste fino: plano: {formato:{largura,altura,fps}, cenas:[…], audio:{…}} — ou cenas direto. '

package/lib/estudio/batida.js

@@ -141,7 +141,16 @@ const CONFIANCA_MINIMA = 0.7;   // abaixo disso a batida é chute: a faixa entra
 
 const TRANSICOES_FORTES = new Set(['soco', 'flash', 'chicote', 'zoom', 'giro']);
 
-/** Os cortes do plano no tempo do vídeo: [{t, peso}]. Corte de impacto pesa 3; o maior impacto vira `impacto`. */
+/**
+ * Os cortes do plano no tempo do vídeo: [{t, peso}]. Corte de impacto pesa 3; o maior impacto vira `impacto`.
+ *
+ * O GERATIVO É UMA CENA SÓ: as batidas dele moram dentro da partitura do kit
+ * (cena.elementos[].partitura.batidas). Contando só as cenas, o vídeo dele
+ * tinha 0 cortes, e o log dizia "0 de 0 cortes caem na batida" (10/10). Cada
+ * batida (menos a primeira) é um corte; a troca de campo (fundo de cor) e a
+ * tese gigante pesam 3. O corte leva a referência da batida para ser
+ * ENCOSTADO na batida da música depois (melhorInicio).
+ */
 function cortesDoPlano(plano) {
     const cortes = [];
     let t = 0;
@@ -150,35 +159,111 @@ function cortesDoPlano(plano) {
             const tr = cena.transicao && (cena.transicao.tipo || cena.transicao);
             cortes.push({ t: r3(t), peso: cena.impacto || TRANSICOES_FORTES.has(tr) ? 3 : 1 });
         }
+        for (const el of cena.elementos || []) {
+            const bs = el && el.partitura && Array.isArray(el.partitura.batidas) ? el.partitura.batidas : null;
+            if (!bs) continue;
+            bs.forEach((b, j) => {
+                if (j === 0) return;
+                const forte = b.troca || b.comp === 'gigante' || b.campoCor;
+                // A palavra que a batida mostra: a entrada da primeira linha (sem linha, a batida mesmo).
+                const ts = (b.linhas || []).map((l) => l.t).filter((x) => typeof x === 'number');
+                const palavra = ts.length ? Math.min(...ts) : b.de;
+                cortes.push({ t: r3(t + b.de), peso: forte ? 3 : 1, ref: { bs, j, base: t, palavra } });
+            });
+        }
         t += Number(cena.duracao) || 0;
     }
-    return cortes;
+    return cortes.sort((a, b) => a.t - b.t);
+}
+
+/** A batida mais perto de `t` numa lista ordenada: {bt, d}. */
+function maisPerto(lista, t) {
+    let lo = 0, hi = lista.length - 1;
+    while (lo < hi) { const m = (lo + hi) >> 1; if (lista[m] < t) lo = m + 1; else hi = m; }
+    const a = lista[lo], b = lo > 0 ? lista[lo - 1] : Infinity;
+    return Math.abs(a - t) <= Math.abs(b - t) ? { bt: a, d: Math.abs(a - t) } : { bt: b, d: Math.abs(b - t) };
+}
+
+/* Quanto a troca de tela pode se afastar da PALAVRA que ela mostra: a fala
+   continua onde estava, e a troca adianta ou atrasa a palavra em no máximo
+   150 ms — abaixo do que o olho percebe como fora de sincronia. A janela é
+   medida da palavra, não do corte de antes (que já vinha ~120 ms adiantado). */
+const EMPURRAO = 0.15;
+/** A janela [de, até] em que o corte pode cair, no tempo do vídeo. */
+const janelaDo = (c) => (c.ref ? [c.ref.base + c.ref.palavra - EMPURRAO, c.ref.base + c.ref.palavra + EMPURRAO] : [c.t, c.t]);
+/** A batida da música (no tempo do vídeo) dentro da janela, a mais perto do corte; ou null. */
+function batidaNaJanela(bats, c, o) {
+    const [a, z] = janelaDo(c);
+    let lo = 0, hi = bats.length;
+    while (lo < hi) { const m = (lo + hi) >> 1; if (bats[m] - o < a) lo = m + 1; else hi = m; }
+    let melhor = null;
+    for (let i = lo; i < bats.length && bats[i] - o <= z; i++) {
+        const v = bats[i] - o;
+        if (!melhor || Math.abs(v - c.t) < Math.abs(melhor - c.t)) melhor = v;
+    }
+    return melhor;
 }
+const MIN_BATIDA = 0.6;   // nenhuma batida fica mais curta que isto depois do empurrão
 
 /**
  * De onde a faixa começa (em s) para o máximo de cortes cair numa batida.
  * Procura em passos de 10 ms, de 0 a `maximo`; empate fica com o início mais
  * cedo. O corte mais pesado ganha bônus se cair num acento.
+ *
+ * Os cortes do gerativo (com `ref`) contam como "na batida" até EMPURRAO de
+ * distância, porque depois da escolha eles são ENCOSTADOS nela: a batida do
+ * vídeo anda (b.de e o ate da anterior), e o golpe da tese também. O plano é
+ * mudado no lugar — é ele que vai para o render.
  */
 function melhorInicio(cortes, analise, { maximo = 0, tolerancia = 0.05 } = {}) {
     const bats = (analise && analise.batidas) || [];
     if (!cortes.length || bats.length < 4 || (analise.confianca != null && analise.confianca < CONFIANCA_MINIMA)) return { inicio: 0, alinhados: 0, total: cortes.length };
-    const perto = (lista, t) => {
-        let lo = 0, hi = lista.length - 1;
-        while (lo < hi) { const m = (lo + hi) >> 1; if (lista[m] < t) lo = m + 1; else hi = m; }
-        return Math.min(Math.abs(lista[lo] - t), lo > 0 ? Math.abs(lista[lo - 1] - t) : Infinity);
-    };
+    const perto = (lista, t) => maisPerto(lista, t).d;
     const maior = cortes.reduce((a, b) => (b.peso > a.peso ? b : a), cortes[0]);
     const acentos = (analise.acentos || []);
     let melhor = { inicio: 0, pontos: -1 };
     for (let o = 0; o <= Math.max(0, maximo) + 1e-9; o += 0.01) {
         let pontos = 0;
-        for (const c of cortes) pontos += c.peso * Math.exp(-0.5 * Math.pow(perto(bats, c.t + o) / tolerancia, 2));
+        for (const c of cortes) {
+            if (c.ref) {
+                const v = batidaNaJanela(bats, c, o);
+                if (v != null) pontos += c.peso * (1 - 0.3 * Math.min(1, Math.abs(v - c.t) / (2 * EMPURRAO)));
+            } else pontos += c.peso * Math.exp(-0.5 * Math.pow(perto(bats, c.t + o) / tolerancia, 2));
+        }
         if (maior.peso > 1 && acentos.length && perto(acentos, maior.t + o) < 0.1) pontos += 2;
         if (pontos > melhor.pontos + 1e-6) melhor = { inicio: r3(o), pontos };
     }
-    const alinhados = cortes.filter((c) => perto(bats, c.t + melhor.inicio) <= tolerancia).length;
-    return { inicio: melhor.inicio, alinhados, total: cortes.length };
+    const o = melhor.inicio;
+    // O empurrão: cada corte do gerativo vai para a batida mais perto, se couber.
+    let empurrados = 0;
+    for (const c of cortes) {
+        if (!c.ref) continue;
+        const { bs, j, base } = c.ref;
+        const v = batidaNaJanela(bats, c, o);
+        if (v == null || Math.abs(v - c.t) <= 1e-3) continue;
+        const delta = v - c.t;
+        const b = bs[j], a = bs[j - 1];
+        const novo = b.de + delta;
+        if (novo - a.de < MIN_BATIDA || b.ate - novo < MIN_BATIDA) continue;
+        const colado = Math.abs(a.ate - b.de) < 0.02;
+        b.de = r3(novo);
+        if (colado) a.ate = b.de;
+        c.t = r3(base + b.de);
+        empurrados++;
+    }
+    // O golpe (a tese que bate) também cai na batida, sem sair da batida dele.
+    const vistos = new Set();
+    for (const c of cortes) {
+        if (!c.ref || vistos.has(c.ref.bs)) continue;
+        vistos.add(c.ref.bs);
+        for (const b of c.ref.bs) for (const g of b.golpes || []) {
+            const { bt, d } = maisPerto(bats, c.ref.base + g.t + o);
+            const alvo = bt - o - c.ref.base;
+            if (d <= EMPURRAO && alvo > b.de + 0.05 && alvo < b.ate - 0.1) g.t = r3(alvo);
+        }
+    }
+    const alinhados = cortes.filter((c) => perto(bats, c.t + o) <= tolerancia).length;
+    return { inicio: o, alinhados, total: cortes.length, empurrados };
 }
 
 module.exports = { analisarPCM, analisar, cortesDoPlano, melhorInicio, TAXA, CONFIANCA_MINIMA };

package/lib/estudio/gerativo.js

@@ -265,7 +265,7 @@ function escolherVisual(roteiro = {}, { aleatorio = Math.random } = {}) {
        roteiro É do assunto (uma palavra só não basta). UMA forma por vídeo —
        é identidade, não sorteio por batida — ou 'nenhum', que a memória também gira. */
     const forca = (ABSTRATO_DO_HUMOR[humor] || 0) * Math.min(1, n[humor] / 3);
-    const h1 = forca > 0 ? variedade.sortear([...HEROIS_OBJETO, ...HEROIS_CAMPO, 'nenhum'], 'heroi-gerativo', { aleatorio, adequacao: (h) => (h === 'nenhum' ? 1 - forca : forca * fitH(h)) }) : 'nenhum';
+    const h1 = forca > 0 ? variedade.sortear([...HEROIS_3D, ...HEROIS_OBJETO, ...HEROIS_CAMPO, 'nenhum'], 'heroi-gerativo', { aleatorio, adequacao: (h) => (h === 'nenhum' ? 1 - forca : HEROIS_3D.includes(h) ? forca * 1.3 : forca * fitH(h)) }) : 'nenhum';
     out.herois = { favoritos: h1 === 'nenhum' ? [] : [h1] };
     // 'produto' e 'marca' quem decide é o conteúdo (o 3D pedido, a marca), não o gosto do projeto.
     const favC = [];
@@ -274,7 +274,10 @@ function escolherVisual(roteiro = {}, { aleatorio = Math.random } = {}) {
     /* A MOLDURA (09/10): o quadro fixo do reel de referência — cantos, o assunto
        no alto, a seção, o tempo embaixo — é identidade, mas em todo vídeo vira
        vício. Sai do cardápio com memória: 'sem' pesa um pouco mais. */
-    out.moldura = variedade.sortear(MOLDURAS, 'moldura-gerativo', { aleatorio, adequacao: { sem: 1, cantos: 0.95, completa: 0.95 } });
+    /* (10/10) "Essa borda entrega que foi IA que fez" (Joel): os cantos, o
+       "01 · seção" e o tempo embaixo são a assinatura de vídeo gerado. Saiu
+       do sorteio: só entra quando o roteiro PEDE (moldura: cantos|completa). */
+    out.moldura = 'sem';
     // O bokeh combina com luz de tela (tecnologia, energia, natureza); numa padaria, quase nunca.
     const bokeh = ['tecnologia', 'energia', 'natureza'].includes(humor) ? 0.6 : 0.2;
     out.ambiente = variedade.sortear(AMBIENTES, 'ambiente-gerativo', { aleatorio, adequacao: { limpo: 1, luz: 0.85, bokeh } });
@@ -298,6 +301,18 @@ function escolherVisual(roteiro = {}, { aleatorio = Math.random } = {}) {
    O assunto decide quanto 3D: tecnologia e energia puxam os objetos (esfera,
    toro, polígono, explosão); editorial e luxo, os campos. */
 const HEROIS_OBJETO = ['explosao', 'poligono', 'esfera', 'toro'], HEROIS_CAMPO = ['truchet', 'aneis', 'grade', 'rastro'];
+/* O 3D DE VERDADE (10/10, "quero um 3d bem presente", com o reel de
+   referência): three.js, perspectiva, luz — grande na tela, não um enfeite.
+   globo3d: a esfera de pontos e malha girando em profundidade; fita3d: o nó
+   que se torce, com material e luz de recorte; colunas3d: o campo de colunas
+   que a câmera sobrevoa, atrás do texto. (kit/tres.jsx, Heroi3D) */
+const HEROIS_3D = ['globo3d', 'fita3d', 'colunas3d'];
+const CAMPOS_3D = ['colunas3d'];
+/* A FAMÍLIA de cada herói: dois heróis da mesma família seguidos são o
+   "mesmo desenho" para quem assiste (o anel de pontos com a forma no meio
+   saiu em 4 batidas seguidas no vídeo do Joel, 10/10). */
+const FAMILIA_HEROI = { explosao: 'raio', poligono: 'orbita', aneis: 'orbita', esfera: 'malha', toro: 'malha', globo3d: 'malha',
+    fita3d: 'fita', colunas3d: 'campo3d', truchet: 'azulejo', grade: 'grade', rastro: 'rastro' };
 const OBJETO3D_DO_HUMOR = { tecnologia: 1, energia: 1, natureza: 0.8, luxo: 0.6, editorial: 0.4 };
 /* Quanto o assunto aceita forma abstrata (o resto: a tipografia e o ícone do conteúdo). */
 const ABSTRATO_DO_HUMOR = { tecnologia: 1, energia: 0.7, natureza: 0.5, luxo: 0, editorial: 0 };
@@ -327,7 +342,7 @@ function escolhasValidas(e) {
         texto: todas('textos').includes(e.texto) ? e.texto : null,
         mono: todas('monos').includes(e.mono) ? e.mono : null,
         genero: todas('generos').includes(e.genero) ? e.genero : null,
-        herois: (e.herois && Array.isArray(e.herois.favoritos) ? e.herois.favoritos : []).filter((h) => HEROIS_OBJETO.includes(h) || HEROIS_CAMPO.includes(h)),
+        herois: (e.herois && Array.isArray(e.herois.favoritos) ? e.herois.favoritos : []).filter((h) => HEROIS_OBJETO.includes(h) || HEROIS_CAMPO.includes(h) || HEROIS_3D.includes(h)),
         composicoes: (e.composicoes && Array.isArray(e.composicoes.favoritas) ? e.composicoes.favoritas : []).filter((c) => COMPOSICOES.includes(c)),
         icones: e.icones && ARRANJOS_ICONE.includes(e.icones.arranjo) ? {
             arranjo: e.icones.arranjo,
@@ -570,6 +585,9 @@ function frasesDe(fala, palavras) {
 
 // ── 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; };
+/** A luminância relativa do WCAG (com o gama) e o contraste por ela. */
+const lumWcag = (h) => { const n = parseInt(String(h).slice(1), 16); const c = [n >> 16 & 255, n >> 8 & 255, n & 255].map((v) => { v /= 255; return v <= 0.03928 ? v / 12.92 : Math.pow((v + 0.055) / 1.055, 2.4); }); return 0.2126 * c[0] + 0.7152 * c[1] + 0.0722 * c[2]; };
+const contrasteWcag = (a, b) => { const la = lumWcag(a) + 0.05, lb = lumWcag(b) + 0.05; return la > lb ? la / lb : lb / la; };
 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;
 
@@ -999,6 +1017,8 @@ function partituraDe({ roteiro, largura = 1920, altura = 1080, tempos = [], icon
             const comp = nome === 'rajada' ? 'gigante' : nome === 'duelo' ? 'pilha' : nome;
             let q = p;
             if (comp === anterior || evita.includes(comp)) q = 0;
+            // No máximo 2 vezes no vídeo (10/10: "cascata" saiu 3 vezes no vídeo do Joel).
+            if ((usadas[comp] || 0) >= 2) 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;
@@ -1033,6 +1053,8 @@ function partituraDe({ roteiro, largura = 1920, altura = 1080, tempos = [], icon
         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';
+        // A cascata que veio da rajada também respeita o teto de 2 (e nunca segue outra cascata).
+        if (nome === 'cascata' && ((usadas.cascata || 0) >= 2 || anterior === 'cascata')) nome = anterior === 'pilha' ? 'palavras' : 'pilha';
         if (nome === 'rajada') {
             // Cada item vira a sua batida; o título da lista fica como rótulo.
             const n = c.itens.length;
@@ -1075,6 +1097,45 @@ function partituraDe({ roteiro, largura = 1920, altura = 1080, tempos = [], icon
     batidas.forEach((b) => { b.secao = secoes.idx[b.parte] || 0; b.campo = b.secao % 2 === 0 ? comeca : 2 - comeca; });
     for (const b of batidas) { b.fundo = 'campo' + b.campo; b.cores = coresDoCampo(campos, b.campo, s, ident); }
 
+    /* ── OS CAMPOS DE COR CHAPADA (10/10) ────────────────────────────────
+       "O vídeo fica bege e grafite do começo ao fim" — o reel de referência
+       troca o quadro INTEIRO para laranja, azul elétrico, lima. Os campos 3 e
+       4 tinham saído em 09/10 porque entravam a esmo ("cores nada a ver uma
+       com a outra"); voltam com regra: só DUAS cores fortes — o acento do
+       vídeo e a ousada do mesmo sistema (campos[3]) —, em ~1 de cada 3,5
+       batidas (pelo menos 2 num vídeo de 6+), nunca duas seguidas, nunca a
+       primeira nem a marca. Tinta de contraste alto; o corte é seco (o fundo
+       troca no quadro da batida, que o batida.js encosta na música). */
+    // A segunda cor é a ousada do sistema MAIS LONGE no matiz do acento: duas laranjas lado a lado
+    // (o terracota e o #FF4A1C, render real de 10/10) não fazem o contraste do reel (laranja × azul).
+    const matiz = (h) => { const n = parseInt(String(h).slice(1), 16); const r = (n >> 16 & 255) / 255, g = (n >> 8 & 255) / 255, bb = (n & 255) / 255;
+        const mx = Math.max(r, g, bb), mn = Math.min(r, g, bb), d = mx - mn; if (!d) return 0;
+        const hh = mx === r ? ((g - bb) / d) % 6 : mx === g ? (bb - r) / d + 2 : (r - g) / d + 4; return (hh * 60 + 360) % 360; };
+    const longe = (x) => { const d = Math.abs(matiz(x) - matiz(ident.acento)); return Math.min(d, 360 - d); };
+    const ousada = [campos[3], campos[4]].filter(ehCor).sort((x, y) => longe(y) - longe(x))[0];
+    const fortes = [ident.acento, ousada].filter((x, i, a) => ehCor(x) && a.indexOf(x) === i);
+    const nCor = batidas.length >= 6 ? Math.max(2, Math.round(batidas.length / 3.5)) : batidas.length >= 4 ? 1 : 0;
+    const candCor = batidas.map((b, i) => i).filter((i) => i > 0 && !['marca', 'produto'].includes(batidas[i].comp));
+    const pesoCor = { gigante: 3, palavras: 2.5, contador: 2.5, pilha: 2, parede: 1.5, divisao: 1, cascata: 0.8, citacao: 0.8 };
+    const comCor = [];
+    for (const i of candCor.sort((x, y) => (pesoCor[batidas[y].comp] || 1) - (pesoCor[batidas[x].comp] || 1) || x - y)) {
+        if (comCor.length >= nCor || !fortes.length) break;
+        if (comCor.some((j) => Math.abs(j - i) < 2)) continue;
+        comCor.push(i);
+    }
+    comCor.sort((x, y) => x - y).forEach((i, k) => {
+        const b = batidas[i];
+        const fundo = fortes[k % fortes.length], outra = fortes[(k + 1) % fortes.length];
+        /* A tinta pelo contraste WCAG (luminância relativa, com o gama): a `luz`
+           daqui acha o azul elétrico "médio" e punha texto PRETO nele — o olho
+           lê muito melhor o branco. */
+        const tinta = [...ident.chaos, '#0B0B0B', '#FAFAF7'].sort((x, y) => contrasteWcag(y, fundo) - contrasteWcag(x, fundo))[0];
+        const acento = outra && outra !== fundo && contrasteWcag(outra, fundo) >= 2.6 ? outra : tinta;
+        b.cores = { fundo, texto: tinta, fraco: misturarCor(tinta, fundo, 0.32), acento, contorno: misturarCor(tinta, fundo, 0.5) };
+        b.campoCor = true;
+        b.fundo = 'cor';
+    });
+
     /* ── O HERÓI DE CADA BATIDA VEM DO CONTEÚDO (09/10): "é uma conversa sobre
        pão e ele vai naquela bolinha" (Joel). Quem diz é o roteiro: parte.heroi
        (ou parte.icone) — um ícone do Iconify ("mdi:bread-slice", o desenho
@@ -1084,7 +1145,7 @@ function partituraDe({ roteiro, largura = 1920, altura = 1080, tempos = [], icon
        e a forma abstrata só no assunto abstrato, a escolhida do projeto, em
        até 1 de cada 3 batidas. Nada serve: a tipografia carrega a batida. ── */
     const pedidoDe = partes.map((p) => { const h = p.heroi != null ? p.heroi : p.icone; return typeof h === 'string' && h.trim() ? h.trim() : null; });
-    const ABSTRATOS = [...HEROIS_OBJETO, ...HEROIS_CAMPO];
+    const ABSTRATOS = [...HEROIS_OBJETO, ...HEROIS_CAMPO, ...HEROIS_3D];
     const ICONES3D = new Set(Object.values(ICONE_DE));
     const materialSorteado = s.um(['argila', 'verniz', 'metal']);
     // O arranjo do projeto (escolherVisual); sem ele, o de antes: um lado só, ícones seguidos.
@@ -1135,24 +1196,100 @@ function partituraDe({ roteiro, largura = 1920, altura = 1080, tempos = [], icon
         ultimoIcone = bi;
     }
 
-    // A forma abstrata: a que o modelo pediu, ou a do projeto no assunto que aceita.
+    /* ── A FORMA ABSTRATA, BATIDA A BATIDA (10/10) ───────────────────────
+       Era UMA forma por vídeo, repetida a cada duas batidas: o anel com a
+       forma no meio saiu em 4 batidas seguidas e "as animações são muito
+       iguais" (Joel). Agora cada batida que recebe forma tira a sua de um
+       cardápio, com três regras:
+         1. nunca a mesma FAMÍLIA (FAMILIA_HEROI) em duas batidas seguidas;
+         2. cada forma no máximo 2 vezes no vídeo (uma repetição);
+         3. no assunto que aceita (tecnologia, energia, natureza), pelo menos
+            1 de cada 3 batidas é 3D DE VERDADE (HEROIS_3D) — grande, com
+            perspectiva e luz, não o enfeite pequeno de antes.
+       A forma pedida pelo roteiro (parte.heroi) continua valendo onde pediu. */
     const OBJETOS = HEROIS_OBJETO;
-    const favorito = (ABSTRATO_DO_HUMOR[humor] || 0) > 0 ? E.herois[0] : null;
-    const tetoH = Math.ceil(batidas.length / 3);
-    let nH = 0, ultimoH = -9;
+    /* O assunto aceita forma abstrata quando o humor é de tecnologia, energia
+       ou natureza E o roteiro É do assunto (3 palavras do humor, como na
+       escolha do projeto) — a padaria que fala de Pix não vira reel de tech. */
+    const acertos = acertosDeHumor(roteiro)[humor] || 0;
+    // E o projeto escolheu ter forma (escolherVisual, E.herois): sem essa escolha, o herói vem só do conteúdo.
+    const aceita = (E.herois || []).length > 0 && (ABSTRATO_DO_HUMOR[humor] || 0) >= 0.5 && acertos >= 3;
+    const nB = batidas.length;
+    const usoH = {}, usoFam = {};
+    let famAnterior = null, ultimoH = -9;
+    // A parede de texto e a marca já cobrem o quadro: forma ali é ruído.
+    const livreParaHeroi = (b) => !b.icone3d && !b.produto3d && !pedidoDe[b.parte] && b.comp !== 'marca' && b.comp !== 'parede';
+    const elegiveis = aceita ? batidas.map((b, i) => (livreParaHeroi(b) ? i : -1)).filter((i) => i >= 0) : [];
+    // Quantas batidas ganham forma: metade do vídeo (as outras ficam com a tipografia e o ícone).
+    const quantas = Math.min(elegiveis.length, Math.ceil(nB / 2));
+    const escolhidas = new Set();
+    for (let k = 0; k < quantas; k++) escolhidas.add(elegiveis[Math.floor((k * elegiveis.length) / quantas)]);
+    const meta3d = aceita ? Math.min(quantas, Math.ceil(nB / 3)) : 0;
+    let n3d = 0, feitas = 0;
+    const favoritos = new Set(E.herois || []);
+    const sortearHeroi = (b, i, so3d) => {
+        const lista = so3d ? HEROIS_3D : [...HEROIS_3D, ...HEROIS_OBJETO, 'truchet', 'aneis', 'rastro'];
+        const w = {};
+        const pode = (h) => w[h] > 0;
+        for (const h of lista.concat([...favoritos].filter((f) => !lista.includes(f) && (!so3d || HEROIS_3D.includes(f))))) {
+            if ((usoH[h] || 0) >= 2) continue;
+            const fam = FAMILIA_HEROI[h];
+            if (fam === famAnterior && i - ultimoH <= 2) continue;
+            // Cada família uma vez no vídeo: a esfera plana depois do globo 3D lia como repetição.
+            if ((usoFam[fam] || 0) >= 1) continue;
+            // As formas planas que pedem o vazio ao lado não cabem na batida sem vazio.
+            if (OBJETOS.includes(h) && ['gigante', 'parede', 'divisao'].includes(b.comp)) continue;
+            // O campo 3D e a parede de texto brigam: as duas cobrem o quadro.
+            if ((CAMPOS_3D.includes(h) || HEROIS_CAMPO.includes(h)) && b.comp === 'parede') continue;
+            // O 3D que mora AO LADO do texto (globo, fita) precisa de um lado livre: a tese gigante,
+            // o contraste e a citação ocupam a largura — ali ele não teria onde ficar sem cruzar a letra.
+            if (HEROIS_3D.includes(h) && !CAMPOS_3D.includes(h) && ['gigante', 'divisao', 'citacao', 'contador'].includes(b.comp)) continue;
+            let p = HEROIS_3D.includes(h) ? 1.6 : 1;
+            if (favoritos.has(h)) p *= 2;
+            p *= Math.pow(0.4, usoH[h] || 0);
+            w[h] = p;
+        }
+        // A forma que o projeto escolheu é a identidade: entra na primeira batida em que cabe.
+        const fav = [...favoritos].find((f) => !usoH[f] && pode(f));
+        if (fav) return fav;
+        // A batida pede 3D e a escolhida é plana: vem a versão 3D da mesma família (o toro vira o globo).
+        if (so3d) {
+            const irma = [...favoritos].map((f) => HEROIS_3D.find((h) => FAMILIA_HEROI[h] === FAMILIA_HEROI[f])).find((h) => h && pode(h));
+            if (irma) return irma;
+        }
+        return s.pesado(w);
+    };
     batidas.forEach((b, i) => {
         let h = b.heroiPedido || null;
-        if (!h && favorito && !b.icone3d && !b.produto3d && !pedidoDe[b.parte] && nH < tetoH && i - ultimoH >= 2
-            && !(OBJETOS.includes(favorito) && ['gigante', 'parede', 'divisao'].includes(b.comp))) h = favorito;
         delete b.heroiPedido;
+        if (!h && escolhidas.has(i)) {
+            const faltam3d = meta3d - n3d, restam = quantas - feitas;
+            h = sortearHeroi(b, i, faltam3d > 0 && faltam3d >= restam) || sortearHeroi(b, i, false);
+            feitas++;
+        }
         if (!h) return;
-        nH++; ultimoH = i;
+        usoH[h] = (usoH[h] || 0) + 1;
+        usoFam[FAMILIA_HEROI[h] || h] = (usoFam[FAMILIA_HEROI[h] || h] || 0) + 1;
+        famAnterior = FAMILIA_HEROI[h] || h; ultimoH = i;
+        const tres = HEROIS_3D.includes(h);
+        if (tres) n3d++;
         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 };
+        b.heroi = { tipo: h, modo: CAMPOS_3D.includes(h) ? 'campo' : tres ? 'objeto3d' : OBJETOS.includes(h) ? 'objeto' : 'campo',
+            tres, semente: hash(b.id + h) % 9973,
+            cor: comCor ? b.cores.acento : misturarCor(b.cores.texto, b.cores.fundo, 0.25), cor2: b.cores.texto, fundo: b.cores.fundo };
     });
 
+    /* O 3D COMO ASSUNTO (10/10, "uma coisa gigante por tela"): na batida com
+       globo ou fita, o texto vai para a metade esquerda (no 9:16, para o alto)
+       e a outra metade fica inteira para o 3D — que o kit faz do tamanho do
+       vão (até ~60% da altura), sem nunca cruzar a letra. */
+    for (const b of batidas) {
+        if (!b.heroi || b.heroi.modo !== 'objeto3d' || !b.bloco || b.bloco.colunas || b.bloco.blocos) continue;
+        if (deitado) b.bloco = { ...b.bloco, x: M, alinha: 'esq', largura: Math.min(b.bloco.largura, W * 0.46) };
+        else b.bloco = { ...b.bloco, y: H * 0.3, largura: Math.min(b.bloco.largura, larguraUtil) };
+    }
+
     // ── as passagens: como uma batida vira a outra ──────────────────────
     let ultimaSaida = null, desdeCorte = 9;
     const saidasRecentes = [];
@@ -1361,9 +1498,12 @@ function compor(comp, br, ctx) {
             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);
+            // A frase de 3+ palavras pode ir em 3 linhas no 16:9: cresce na altura em vez de encolher na largura.
+            const nMax = deitado ? Math.min(3, Math.max(2, txt.split(/\s+/).length)) : 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);
+            /* UMA COISA GIGANTE POR TELA (10/10, comparado ao reel de referência: "o
+               texto pequeno no meio do bege"). A tese gigante enche a largura. */
+            const fit = caberEmLinhas(txt, alvo, nMax, (deitado ? 0.42 : 0.26) * 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 } });
@@ -1384,11 +1524,11 @@ function compor(comp, br, ctx) {
         }
         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 lg = noProduto ? (deitado ? W * 0.42 : larguraUtil) : (deitado ? W * s.entre(0.74, 0.84) : 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 fit = caberEmLinhas(principal, lg, nL, (deitado ? 0.23 : 0.115) * 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' ? '' : '');
@@ -1426,9 +1566,9 @@ function compor(comp, br, ctx) {
         case 'palavras': {
             const txt = c.texto || c.titulo || '';
             const alinha = s.chance(0.55) ? 'esq' : 'centro';
-            const lg = deitado ? W * 0.8 : larguraUtil;
+            const lg = deitado ? W * 0.86 : larguraUtil;
             const op = { fonte: fontes.display, wght: 600 };
-            const fit = caberEmLinhas(txt, lg, deitado ? 3 : 4, (deitado ? 0.12 : 0.075) * H, op);
+            const fit = caberEmLinhas(txt, lg, deitado ? 3 : 4, (deitado ? 0.18 : 0.1) * 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) {
@@ -1463,7 +1603,7 @@ function compor(comp, br, ctx) {
             // 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 maxT = (deitado ? 0.12 : 0.056) * 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 };
@@ -1483,8 +1623,8 @@ function compor(comp, br, ctx) {
         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);
+            const fN = caberEmLinhas(c.nao, lado, deitado ? 3 : 2, (deitado ? 0.13 : 0.08) * H, { ...op, wght: 400 });
+            const fS = caberEmLinhas(c.sim, lado, deitado ? 3 : 3, (deitado ? 0.17 : 0.1) * 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 {
@@ -1502,7 +1642,7 @@ function compor(comp, br, ctx) {
             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 });
+            const fit = caberEmLinhas(q, lg, deitado ? 4 : 5, (deitado ? 0.15 : 0.08) * 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; } }); });
@@ -1516,7 +1656,7 @@ function compor(comp, br, ctx) {
             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 });
+            const tam = tamanhoQueCabe(nome, lg, (deitado ? 0.3 : 0.16) * 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 } });
@@ -1527,7 +1667,7 @@ function compor(comp, br, ctx) {
             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 });
+            const tam = tamanhoQueCabe(txt, larguraUtil, (deitado ? 0.26 : 0.13) * 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) };
@@ -1578,8 +1718,12 @@ function compor(comp, br, ctx) {
        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;
+    /* (10/10) "Uma coisa gigante por tela": os tetos subiram — a frase curta
+       chega a ~14–18% da altura em altura de maiúscula, a lista a ~9%. Era o
+       teto daqui (0,12 × 0,72 da altura) que deixava "Entregue a próxima
+       tarefa" pequena no meio do bege, não o tamanho que a composição pedia. */
+    const tetoV = { gigante: deitado ? 0.5 : 0.28, marca: deitado ? 0.34 : 0.18, parede: deitado ? 0.3 : 0.15, contador: deitado ? 0.55 : 0.25,
+        pilha: deitado ? 0.3 : 0.15, produto: deitado ? 0.16 : 0.09, palavras: deitado ? 0.22 : 0.12, cascata: deitado ? 0.14 : 0.07, divisao: deitado ? 0.18 : 0.1, citacao: deitado ? 0.16 : 0.09 }[b.comp] || 0.12;
     // 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
@@ -1591,7 +1735,7 @@ function compor(comp, br, ctx) {
         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)));
+        l.max = Math.round(b.cheio ? Math.min(tetoV * H, (H * 0.7) / (nEnche * 1.05)) : Math.min(tetoV * H * 0.9, (H * 0.62) / (nEnche * 1.05)));
     }
     // ── o tempo de cada linha e palavra: quando a voz diz ────────────────
     tempoDaBatida(b, palavras, ctx);
@@ -1709,5 +1853,5 @@ function contarAcentos(b) {
 
 module.exports = {
     montarGerativo, partituraDe, sonsDoVideo, musicaDe, desenharSom, humorDe, escolherVisual, MOLDURAS, AMBIENTES, ACENTOS_JEITO, ARRANJOS_ICONE, RITMOS_ICONE, MATERIAIS_ICONE, corGenerica, BANIDAS, HUMORES, REGRAS, VARIAVEIS, COMPOSICOES, COMPORTAMENTOS, SAIDAS, ACENTOS, FPS,
-    especEixos, sorteador, hash, larguraEm, conteudoDe, casar, HEROIS_OBJETO, HEROIS_CAMPO,
+    especEixos, sorteador, hash, larguraEm, conteudoDe, casar, HEROIS_OBJETO, HEROIS_CAMPO, HEROIS_3D, FAMILIA_HEROI,
 };

package/lib/estudio/index.js

@@ -896,6 +896,32 @@ function alinharPartes(lista, palavras, total) {
     });
 }
 
+/**
+ * Onde o roteiro COMEÇA na fala transcrita, em segundos — 0 se começa logo.
+ *
+ * Dois jeitos de o Gemini vazar a direção, os dois vistos no vídeo do Joel
+ * (10/10): falar "Rápido e contínuo." ANTES do roteiro, e falar NO LUGAR da
+ * primeira frase ("Rápido e contínuo. Você pergunta…", sem o "IA é pra tirar
+ * dúvida"). Então: acha o primeiro par de palavras seguidas que existe no
+ * roteiro (não só o par do começo), e corta o que veio antes — mas só se o que
+ * veio antes for, na maior parte, palavra da DIREÇÃO. Fala do roteiro que o
+ * transcritor errou não é vazamento e não sai.
+ */
+function vazamentoNoComeco(lista, palavras, direcao = '') {
+    const norm = (t) => String(t || '').toLowerCase().normalize('NFD').replace(/[\u0300-\u036f]/g, '').replace(/[^a-z0-9]+/g, ' ').trim();
+    const roteiro = norm(lista.slice(0, 2).map((x) => x.texto).join(' ')).split(' ').filter(Boolean);
+    if (roteiro.length < 2 || !palavras.length) return 0;
+    const pares = new Set(roteiro.slice(0, -1).map((w, i) => w + ' ' + roteiro[i + 1]));
+    const ditas = palavras.slice(0, 14).map((w) => norm(w.texto));
+    let i = 0;
+    while (i < ditas.length - 1 && !pares.has(ditas[i] + ' ' + ditas[i + 1])) i++;
+    if (i === 0 || i >= ditas.length - 1) return 0;
+    const daDirecao = new Set(norm(direcao).split(' ').filter(Boolean));
+    const antes = ditas.slice(0, i).join(' ').split(' ').filter(Boolean);
+    const vazou = !direcao || antes.filter((w) => daDirecao.has(w)).length / antes.length >= 0.6;
+    return vazou ? Math.max(0, palavras[i].de - 0.08) : 0;
+}
+
 async function narrarComGemini(lista, mp3, { voz, direcao } = {}) {
     try {
         const cfg = require('../config').loadConfig();
@@ -931,9 +957,25 @@ async function narrarComGemini(lista, mp3, { voz, direcao } = {}) {
         const chars = lista.reduce((n, x) => n + x.texto.length, 0);
         if (med.segundos < chars / 22) return { ok: false, error: `a voz veio cortada (${med.segundos.toFixed(1)} s para ${chars} caracteres)` };
         const tr = await api.requestTranscricao(cfg.server, { token: cfg.token, audio: fs.readFileSync(mp3).toString('base64'), nome: 'voz.mp3', idioma: 'pt' });
-        const palavras = (tr && tr.palavras) || [];
+        let palavras = (tr && tr.palavras) || [];
         if (!palavras.length) return { ok: false, error: 'sem a transcrição da voz para achar as partes' };
-        return { ok: true, voz: `gemini ${r.voz}`, segundos: med.segundos, partes: alinharPartes(lista, palavras, med.segundos) };
+        let segundos = med.segundos;
+        /* A DIREÇÃO LIDA EM VOZ ALTA. O servidor manda a direção ("leia RÁPIDO e
+           contínuo…") e o texto no mesmo pedido, e o Gemini às vezes fala o
+           começo dela: o vídeo do Joel abria com "Rápido e contínuo." antes do
+           roteiro (10/10). Se o roteiro só começa depois de algumas palavras,
+           o que vem antes é vazamento — e sai do áudio. */
+        const corte = vazamentoNoComeco(lista, palavras, direcao);
+        if (corte > 0.15) {
+            const cortado = mp3.replace(/\.mp3$/, '-c.mp3');
+            const k = await video.rodar(video.ffmpeg(), ['-y', '-ss', corte.toFixed(3), '-i', mp3, '-c:a', 'libmp3lame', '-q:a', '3', cortado], { timeout: 120000 });
+            if (k.ok && fs.existsSync(cortado)) {
+                fs.renameSync(cortado, mp3);
+                palavras = palavras.filter((w) => w.de >= corte - 0.02).map((w) => ({ ...w, de: Math.max(0, w.de - corte), ate: Math.max(0, w.ate - corte) }));
+                segundos = Math.max(0, segundos - corte);
+            }
+        }
+        return { ok: true, voz: `gemini ${r.voz}`, segundos, partes: alinharPartes(lista, palavras, segundos), ...(corte > 0.15 ? { cortouDirecao: corte } : {}) };
     } catch (e) {
         return { ok: false, error: e.message };
     }
@@ -1011,7 +1053,10 @@ async function prepararDepoimento(p, c) {
 
 /* A narração com cache (a mesma fala, na mesma direção, não é gerada duas vezes). */
 async function narrarComCache(lista, mp3, { voz, direcao } = {}) {
-    const chave = require('crypto').createHash('sha1').update(JSON.stringify([lista.map((x) => x.texto), voz || '', direcao || ''])).digest('hex').slice(0, 16);
+    /* 'v2' (10/10): as narrações guardadas antes do corte da direção lida em
+       voz alta ("Rápido e contínuo.") ficam para trás — reaproveitar uma delas
+       trazia o vazamento de volta mesmo com o conserto. */
+    const chave = require('crypto').createHash('sha1').update(JSON.stringify(['v2', lista.map((x) => x.texto), voz || '', direcao || ''])).digest('hex').slice(0, 16);
     const dir = path.join(os.homedir(), '.primocode', 'studio', 'cache-voz');
     const cm = path.join(dir, chave + '.mp3'), cj = path.join(dir, chave + '.json');
     if (fs.existsSync(cm) && fs.existsSync(cj)) { fs.copyFileSync(cm, mp3); return { ok: true, ...JSON.parse(fs.readFileSync(cj, 'utf8')) }; }
@@ -1497,7 +1542,9 @@ async function prepararRoteiro(p, args) {
                 /* O gerativo pede voz com CORPO ("narração encorpada, extravagante",
                    30/09): cheia, quente, perto do microfone — e o ritmo segue 1,12×. */
                 /* (A primeira versão pedia "trailer" e "ênfase sustentada": a voz saiu 25% mais lenta, medido em 30/09.) */
-                ? 'Leia em português do Brasil como locutor de reels de tecnologia: RÁPIDO e contínuo, com voz cheia, quente e encorpada, '
+                /* Sem a ênfase em caixa alta logo no começo ("rápido" gritado): era
+                   exatamente o trecho que o Gemini lia em voz alta (10/10). */
+                ? 'Leia em português do Brasil como locutor de reels de tecnologia, num ritmo rápido e sem pausas, com voz cheia, quente e encorpada, '
                     + 'bem perto do microfone, muita energia e sorriso na voz. Ataque firme e ênfase curta e forte nas palavras de impacto; '
                     + 'quase sem pausa entre as frases. Nunca arraste, nunca leia devagar nem solene.'
                 // O fluido é o vídeo de produto: voz limpa e segura, e rápida ("mais rápido", 06/10).
@@ -2042,7 +2089,8 @@ async function ferramentaSite(args) {
     return r;
 }
 
-module.exports = { variarIcones,
+module.exports = {
+    vazamentoNoComeco, variarIcones,
     ferramentaProjeto, ferramentaPlano, ferramentaMidia, ferramentaNarrar,
     ferramentaVideo, ferramentaRender, ferramentaSite,
     projeto, plano, remotion, assets, video, identidade, slides, python, rodarPython, alinharPartes, prepararRoteiro, roteiroValido, juntarVozes,

package/lib/estudio/kit/gerativo.jsx

@@ -14,7 +14,7 @@
 import React, { useState, useEffect, useMemo } from 'react';
 import { delayRender, continueRender } from 'remotion';
 import { SNAPPY, CURVAS_KIT, acaso, suave, alfa, mistura } from './base';
-import { Produto3D, Icone3D } from './tres';
+import { Produto3D, Icone3D, Heroi3D } from './tres';
 
 const ed = CURVAS_KIT.editorial, curvaCam = CURVAS_KIT.camera, arrasto = CURVAS_KIT.arrasto, acelera = CURVAS_KIT.acelera;
 const c01 = (x) => (x < 0 ? 0 : x > 1 ? 1 : x);
@@ -193,7 +193,9 @@ function leiaute(P, med) {
       if (!l.encher || !med[l.id]) continue;
       const k = l.encher + (l.coluna != null ? l.coluna : '');
       // O grid manda: a tese ocupa até ~74% da largura do bloco; só a sangria vai a 97%.
-      const s = Math.min(l.max || l.tamanho, (bl.largura * (b.cheio ? 0.97 : 0.74)) / med[l.id].w);
+      /* (10/10) A tese gigante, a parede e a marca ENCHEM o bloco (97%): com fonte
+         larga, os 74% de antes paravam "CLAUDE CODE" em 9% da altura. O resto, 80%. */
+      const s = Math.min(l.max || l.tamanho, (bl.largura * (b.cheio || ['gigante', 'parede', 'marca'].includes(b.comp) ? 0.97 : 0.8)) / med[l.id].w);
       grupo[k] = grupo[k] == null ? s : Math.min(grupo[k], s);
     }
     const tam = (l) => {
@@ -950,9 +952,24 @@ export function Gerativo({ el, t, fps }) {
             e do texto — e calmo: desenhado por cima, brigava com os dois (05/10). */}
         {noAr.filter((x) => x.heroi && x.heroi.modo === 'campo' && L[x.id]).map((x) => {
           const bl = L[x.id].bloco, some = 1 - c01((t - x.ate) / 0.14);
+          let campo3d = null;
+          if (x.heroi.tres) {
+            /* As colunas NUNCA encostam no texto: só existem numa faixa abaixo
+               (ou acima, de ponta-cabeça) do bloco MEDIDO, com folga. O campo mora
+               mais fundo que o texto (translateZ -200), então na tela ele encolhe
+               para o centro mais que o texto: a folga medida aqui só cresce lá. */
+            const folga = Math.max(x.vao || 0, 0.07 * H);
+            const ds = DUR_SAIDA[x.saida] || 0;
+            const saiDe = x.ate - ds - 0.15;
+            if (H - (bl.y1 + folga) >= 0.34 * H) campo3d = { op: 0.7, faixa: { y0: bl.y1 + folga, y1: H }, saiDe };
+            else if (bl.y - folga >= 0.34 * H) campo3d = { op: 0.7, faixa: { y0: 0, y1: bl.y - folga }, teto: true, saiDe };
+            if (!campo3d) return null;   // sem faixa livre: sem colunas
+          }
           return (
             <div key={'campo' + x.id} style={{ position: 'absolute', left: 0, top: 0, width: W, height: H, transform: 'translateZ(-200px)', opacity: some }}>
-              <Heroi b={x} t={t} P={P} slot={{ cx: (bl.x + bl.x1) / 2, cy: (bl.y + bl.y1) / 2, R: Math.min(W, H) * 0.32, op: 0.18 }} />
+              {x.heroi.tres
+                ? <Heroi3D h={x.heroi} t={t} de={x.de} ate={x.ate} W={W} H={H} slot={campo3d} />
+                : <Heroi b={x} t={t} P={P} slot={{ cx: (bl.x + bl.x1) / 2, cy: (bl.y + bl.y1) / 2, R: Math.min(W, H) * 0.32, op: 0.18 }} />}
             </div>
           );
         })}
@@ -998,10 +1015,31 @@ export function Gerativo({ el, t, fps }) {
                 // O lugar do herói: o vazio do bloco (como o ícone); sem vazio, atrás do texto e mais fraco.
                 const bl = lay.bloco, M = P.margem;
                 if (x.heroi.modo === 'campo') return null;   // desenhado atrás, antes do produto
-                const R = Math.min(W, H) * (W >= H ? 0.2 : 0.17);
+                const tres = x.heroi.modo === 'objeto3d';
+                // O 3D é GRANDE ("um 3d bem presente"): o raio pede o vazio inteiro.
+                const R = Math.min(W, H) * (tres ? (W >= H ? 0.26 : 0.22) : (W >= H ? 0.2 : 0.17));
                 let slot = null;
                 // A área segura (margem.js), com o vão do bloco; partitura antiga: a margem do mundo.
                 const S = x.seguro || { x0: M, y0: M * 1.4, x1: W - M, y1: H - M * 1.4 }, V = x.vao || 0;
+                if (tres) {
+                  /* O 3D NUNCA cruza o texto: mora no maior retângulo livre ao lado do
+                     bloco MEDIDO (com o vão e uma folga), dentro da área segura; o raio
+                     é o círculo que cabe nele, e o Heroi3D garante que a projeção inteira
+                     (anel, tubo, dolly, perspectiva) fica dentro desse raio. Sem
+                     retângulo grande o bastante: sem 3D nesta batida. */
+                  const folga = Math.max(V, 0.035 * Math.min(W, H));
+                  const livres = [
+                    { x0: bl.x1 + folga, y0: S.y0, x1: S.x1, y1: S.y1 },
+                    { x0: S.x0, y0: S.y0, x1: bl.x - folga, y1: S.y1 },
+                    { x0: S.x0, y0: S.y0, x1: S.x1, y1: bl.y - folga },
+                    { x0: S.x0, y0: bl.y1 + folga, x1: S.x1, y1: S.y1 },
+                  ].map((q) => ({ ...q, r: Math.min(q.x1 - q.x0, q.y1 - q.y0) / 2 })).sort((a, c) => c.r - a.r);
+                  const q = livres[0];
+                  if (!q || q.r < Math.min(W, H) * 0.12) return null;
+                  const ds = DUR_SAIDA[x.saida] || 0;
+                  slot = { cx: (q.x0 + q.x1) / 2, cy: (q.y0 + q.y1) / 2, R: Math.min(q.r, Math.min(W, H) * 0.3), saiDe: x.ate - ds - 0.12 };
+                  return <Heroi3D h={x.heroi} t={t} de={x.de} ate={x.ate} W={W} H={H} slot={slot} />;
+                }
                 if (S.x1 - bl.x1 - V >= R * 2.3) slot = { cx: bl.x1 + V + (S.x1 - bl.x1 - V) / 2, cy: (bl.y + bl.y1) / 2, R };
                 else if (bl.y - V - S.y0 >= R * 2.2) slot = { cx: W / 2, cy: S.y0 + (bl.y - V - S.y0) / 2, R };
                 else if (S.y1 - bl.y1 - V >= R * 2.2) slot = { cx: W / 2, cy: bl.y1 + V + (S.y1 - bl.y1 - V) / 2, R };

package/lib/estudio/kit/tres.jsx

@@ -375,4 +375,160 @@ export function Icone3D({ el, t }) {
   );
 }
 
+
+/* ── OS HERÓIS EM 3D DE VERDADE (10/10) ───────────────────────────────────
+ * "As animações são muito iguais, quero um 3d bem presente" (Joel, com um
+ * reel de motion de referência). O herói abstrato era SVG — pontos girando
+ * num plano. Estes três são three.js: perspectiva, profundidade, luz e
+ * câmera que anda. Grandes: o raio vem do vazio do bloco (gerativo.jsx).
+ *
+ *   globo3d    a esfera de pontos e malha, girando inclinada, com um anel
+ *              de órbita; os pontos de perto maiores (perspectiva real);
+ *   fita3d     o nó que se torce, em material com verniz e a luz de
+ *              recorte na cor de acento;
+ *   colunas3d  o campo de colunas que sobe em onda, sobrevoado pela câmera
+ *              e sumindo na névoa da cor do fundo — fica ATRÁS do texto.
+ *
+ * Canvas do quadro inteiro, transparente: o objeto é posto no lugar do
+ * vazio convertendo pixel → mundo (câmera fixa, fov 30, a 12 unidades).
+ */
+const FOV3D = 30, DIST3D = 12;
+const VIS3D = 2 * DIST3D * Math.tan((FOV3D / 2) * Math.PI / 180);
+const mola3d = (x) => { const k = Math.max(0, Math.min(1, x)); return 1 - Math.pow(1 - k, 3) * Math.cos(k * 4.2); };
+
+function CameraFixa({ pos, alvo, teto }) {
+  const { camera } = useThree();
+  // De ponta-cabeça: o campo pende do alto (o texto mora embaixo).
+  camera.up.set(0, teto ? -1 : 1, 0);
+  camera.position.set(pos[0], pos[1], pos[2]);
+  camera.near = 0.1; camera.far = 80;
+  camera.lookAt(alvo[0], alvo[1], alvo[2]);
+  camera.updateProjectionMatrix();
+  return null;
+}
+
+function Globo({ r, cor, cor2, sem, tl }) {
+  const geo = useMemo(() => {
+    const N = 1100, pos = new Float32Array(N * 3), col = new Float32Array(N * 3);
+    const c1 = new THREE.Color(cor2), c2 = new THREE.Color(cor);
+    const ouro = Math.PI * (3 - Math.sqrt(5));
+    for (let i = 0; i < N; i++) {
+      const y = 1 - (i / (N - 1)) * 2, rr = Math.sqrt(1 - y * y), a = i * ouro;
+      pos.set([Math.cos(a) * rr * r, y * r, Math.sin(a) * rr * r], i * 3);
+      const c = (i * 7 + sem) % 6 === 0 ? c2 : c1;
+      col.set([c.r, c.g, c.b], i * 3);
+    }
+    const g = new THREE.BufferGeometry();
+    g.setAttribute('position', new THREE.BufferAttribute(pos, 3));
+    g.setAttribute('color', new THREE.BufferAttribute(col, 3));
+    return g;
+  }, [r, cor, cor2, sem]);
+  return (
+    <group rotation={[0.38 + Math.sin(tl * 0.5) * 0.08, tl * 0.55 + sem * 0.01, 0.12]}>
+      <points geometry={geo}><pointsMaterial size={r * 0.06} vertexColors sizeAttenuation /></points>
+      <mesh><sphereGeometry args={[r * 0.99, 32, 20]} /><meshBasicMaterial color={cor2} wireframe transparent opacity={0.22} /></mesh>
+      <mesh rotation={[1.2, 0.3, tl * 0.4]}><torusGeometry args={[r * 1.14, r * 0.008, 8, 160]} /><meshBasicMaterial color={cor} transparent opacity={0.85} /></mesh>
+      <mesh position={[Math.cos(tl * 1.3) * r * 1.14, 0, Math.sin(tl * 1.3) * r * 1.14]} rotation={[1.2, 0.3, 0]}>
+        <sphereGeometry args={[r * 0.05, 16, 12]} /><meshBasicMaterial color={cor} />
+      </mesh>
+    </group>
+  );
+}
+
+function Fita({ r, cor, cor2, sem, tl }) {
+  return (
+    <group rotation={[0.5 + tl * 0.35, tl * 0.6 + sem * 0.02, 0.2]}>
+      <mesh>
+        <torusKnotGeometry args={[r * 0.52, r * 0.13, 280, 32, 2 + (sem % 2), 3]} />
+        <meshPhysicalMaterial color={cor2} roughness={0.28} metalness={0.35} clearcoat={0.9} clearcoatRoughness={0.2} />
+      </mesh>
+      <mesh scale={[1.02, 1.02, 1.02]}>
+        <torusKnotGeometry args={[r * 0.52, r * 0.13, 140, 12, 2 + (sem % 2), 3]} />
+        <meshBasicMaterial color={cor} wireframe transparent opacity={0.22} />
+      </mesh>
+    </group>
+  );
+}
+
+function Colunas({ cor, cor2, fundo, sem, tl }) {
+  const n = 15, passo = 0.9;
+  const base = new THREE.Color(fundo).lerp(new THREE.Color(cor2), 0.22).getStyle();
+  const acesa = new THREE.Color(cor).getStyle();
+  const els = [];
+  for (let i = 0; i < n; i++) for (let j = 0; j < n; j++) {
+    const x = (i - (n - 1) / 2) * passo, z = (j - (n - 1) / 2) * passo - tl * 1.1;
+    const d = Math.hypot(i - n / 2, j - n / 2);
+    const onda = 0.5 + 0.5 * Math.sin(d * 0.85 - tl * 2.6 + (sem % 7));
+    const h = 0.25 + 2.2 * onda * onda;
+    const crista = onda > 0.93;
+    els.push(
+      <mesh key={i + '-' + j} position={[x, h / 2 - 1.6, z]} scale={[passo * 0.78, h, passo * 0.78]}>
+        <boxGeometry args={[1, 1, 1]} />
+        <meshStandardMaterial color={crista ? acesa : base} roughness={0.55} metalness={0.15}
+          {...(crista ? { emissive: acesa, emissiveIntensity: 0.6 } : {})} />
+      </mesh>,
+    );
+  }
+  return <group>{els}</group>;
+}
+
+/* O quanto cada forma passa do raio r, no pior quadro: o anel e a lua do
+   globo (1,14 r + a lua), o nó (o tubo vai a 1,5 × 0,52 r + 0,13 r). */
+const ALCANCE3D = { globo3d: 1.2, fita3d: 0.92 };
+
+export function Heroi3D({ h, t, de, ate, W, H, slot }) {
+  const tl = Math.max(0, t - de), dur = Math.max(0.8, ate - de);
+  const k = Math.min(1.02, mola3d(tl / 0.8));
+  // Some ANTES de o texto sair (a saída dele voa pela tela): o herói nunca cruza a letra.
+  const saiDe = slot.saiDe != null ? slot.saiDe : ate - 0.25;
+  const sai = Math.max(0, Math.min(1, (t - saiDe) / 0.2));
+  const sem = h.semente || 0;
+  const cor = h.cor || '#ff5a1f', cor2 = h.cor2 || '#eeeeee', fundo = h.fundo || '#111111';
+  if (h.tipo === 'colunas3d') {
+    // O sobrevoo: a câmera alta, olhando para a frente e para baixo, andando sobre o campo.
+    const avanca = tl * 0.25;
+    return (
+      <div style={{ position: 'absolute', left: 0, top: 0, width: W, height: H, opacity: (slot.op != null ? slot.op : 0.85) * Math.min(1, tl / 0.5) * (1 - sai),
+        /* A FAIXA: as colunas só existem fora do texto (clip), com a borda esfumada. */
+        ...(slot.faixa ? { clipPath: `inset(${slot.faixa.y0}px 0 ${H - slot.faixa.y1}px 0)`,
+          WebkitMaskImage: slot.teto ? `linear-gradient(to top, transparent ${H - slot.faixa.y1}px, #000 ${H - slot.faixa.y1 + 0.06 * H}px)` : `linear-gradient(to bottom, transparent ${slot.faixa.y0}px, #000 ${slot.faixa.y0 + 0.06 * H}px)` } : {}) }}>
+        <ThreeCanvas width={W} height={H} camera={{ position: [0, 4, 9], fov: 38 }} gl={{ antialias: true, preserveDrawingBuffer: true, alpha: true }}>
+          {/* Câmera baixa olhando quase reto: o campo ocupa a metade de baixo e some na névoa — o meio fica para o texto. */}
+          <CameraFixa teto={slot.teto} pos={[Math.sin(tl * 0.3) * 1.2, 2.3, 8 - avanca]} alvo={[0, 0.9, -4 - avanca]} />
+          <fog attach="fog" args={[fundo, 6, 19]} />
+          <ambientLight intensity={0.45} />
+          <directionalLight position={[4, 8, 5]} intensity={2.2} />
+          <directionalLight position={[-6, 2, -4]} intensity={2.6} color={cor} />
+          <Colunas cor={cor} cor2={cor2} fundo={fundo} sem={sem} tl={tl} />
+        </ThreeCanvas>
+      </div>
+    );
+  }
+  const { cx, cy, R } = slot;
+  const wx = ((cx - W / 2) / H) * VIS3D, wy = (-(cy - H / 2) / H) * VIS3D;
+  /* R é o TETO do que aparece na tela (o vão livre ao lado do texto). O raio
+     no mundo sai dele de trás para a frente: o alcance da forma, a escala
+     máxima e a perspectiva do ponto mais perto da lente no fim do dolly. */
+  const F = ALCANCE3D[h.tipo] || 1.2, zMax = 0.45;
+  let r = (R / H) * VIS3D / (F * 1.02);
+  for (let i = 0; i < 3; i++) r = ((R / H) * VIS3D / (F * 1.02)) * ((DIST3D - zMax - F * r) / DIST3D);
+  // O dolly: o objeto chega do fundo e vem devagar para a lente durante a batida.
+  const z = -3.5 * (1 - Math.min(1, k)) + zMax * Math.min(1, tl / dur);
+  const esc = 0.55 + 0.45 * k;
+  return (
+    <div style={{ position: 'absolute', left: 0, top: 0, width: W, height: H, opacity: (slot.op != null ? slot.op : 1) * Math.min(1, tl / 0.3) * (1 - sai) }}>
+      <ThreeCanvas width={W} height={H} camera={{ position: [0, 0, DIST3D], fov: FOV3D }} gl={{ antialias: true, preserveDrawingBuffer: true, alpha: true }}>
+        <Ambiente forca={0.9} />
+        <ambientLight intensity={0.3} />
+        <directionalLight position={[3, 4, 6]} intensity={2.6} />
+        <directionalLight position={[-5, -1, -3]} intensity={3.2} color={cor} />
+        <pointLight position={[0, 0, 5]} intensity={0.6} />
+        <group position={[wx, wy, z]} scale={[esc, esc, esc]}>
+          {h.tipo === 'fita3d' ? <Fita r={r} cor={cor} cor2={cor2} sem={sem} tl={tl} /> : <Globo r={r} cor={cor} cor2={cor2} sem={sem} tl={tl} />}
+        </group>
+      </ThreeCanvas>
+    </div>
+  );
+}
+
 export const TRES = { produto3d: Produto3D, icone3d: Icone3D };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primocode",
-  "version": "10.4.4",
+  "version": "10.4.7",
   "description": "PrimoCode — agente de engenharia com IA e cursor próprio. Requer conta Conecta Primo AI (Premium ou Super). Cria arquivos, roda comandos, controla navegador e desktop: abre apps, clica em botões e ícones pelo nome, digita e usa atalhos.",
   "main": "bin/primocode.js",
   "bin": {
@@ -8,7 +8,7 @@
   },
   "scripts": {
     "start": "node bin/primocode.js",
-    "test": "node test/tools.test.js && node test/ui.test.js && node test/entrada.test.js && node test/transparencia.test.js && node test/permissao.test.js && node test/compatibilidade.test.js && node test/skills.test.js && node test/skills-de-fora.test.js && node test/skills-novas.test.js && node test/comandos.test.js && node test/estudio.test.js && node test/voz.test.js && node test/modo.test.js && node test/pasta.test.js && node test/projeto.test.js && node test/nome-projeto.test.js && node test/api-propria.test.js && node test/claude-engine.test.js && node test/codex.test.js && node test/conferir.test.js && node test/catalogo.test.js && node test/desktop.test.js && node test/seta.test.js && node test/effort.test.js && node test/regressao.test.js && node test/memoria-conversa.test.js && node test/repeticao.test.js && node test/casar.test.js && node test/recado.test.js && node test/releitura.test.js && node test/snapshot.test.js && node test/video.test.js && node test/limpeza.test.js && node test/autonomia.test.js && node test/desfazer.test.js && node test/desfazer-git.test.js && node test/referencia.test.js && node test/parar.test.js && node test/continuar.test.js && node test/pipeline.test.js && node test/conta.test.mjs && node test/nuvem.test.js && node test/prazo.test.js && node test/primeira-vez.test.js && node test/fala.test.js && node test/especialistas.test.js && node test/empurrao.test.js && node test/terminal-novo.test.js && node test/markdown.test.js && node test/coerencia.test.js && node test/contexto.test.js && node test/perigo.test.js && node test/rapidez.test.js && node test/mascotes.test.js && node test/comandos-extra.test.js && node test/offline.test.js && node test/edicao.test.js && node test/composicao.test.js && node test/acervo-site.test.js && node test/impacto.test.js && node test/cinema.test.js && node test/producao.test.js && node test/ende.test.js && node test/capa.test.js && node test/broll.test.js && node test/morfar.test.js && node test/motion.test.js && node test/motion-roteiro.test.js && node test/kit-motion.test.js && node test/gerativo.test.js && node test/gerativo-identidade.test.js && node test/gerativo-moldura.test.js && node test/gerativo-heroi.test.js && node test/gerativo-ambiente.test.js && node test/hibrido.test.js && node test/batida.test.js && node test/estudio-acervo.test.js && node test/estudio-diretor.test.js && node test/estudio-marca.test.js && node test/estudio-novo-projeto.test.js && node test/estudio-plano.test.js && node test/estudio-slides.test.js && node test/estudio-video.test.js && node test/revisor.test.js && node test/assinatura.test.js && node test/biblioteca.test.js && node test/mcp.test.js && node test/personas.test.js && node test/efeitos.test.js && node test/auto.test.js && node test/colar.test.js && node test/orquestra.test.js && node test/shell-limpo.test.js && node test/editar-remotion.test.js && node test/variacao3d.test.js && node test/portao-skill.test.js && node test/clones.test.js && node test/kokoro.test.js && node test/fluido.test.js && node test/zoom.test.js && node test/personagem.test.js && node test/tela.test.js && node test/margem.test.js"
+    "test": "node test/tools.test.js && node test/ui.test.js && node test/entrada.test.js && node test/transparencia.test.js && node test/permissao.test.js && node test/compatibilidade.test.js && node test/skills.test.js && node test/skills-de-fora.test.js && node test/skills-novas.test.js && node test/comandos.test.js && node test/estudio.test.js && node test/voz.test.js && node test/modo.test.js && node test/pasta.test.js && node test/projeto.test.js && node test/nome-projeto.test.js && node test/api-propria.test.js && node test/claude-engine.test.js && node test/codex.test.js && node test/conferir.test.js && node test/catalogo.test.js && node test/desktop.test.js && node test/seta.test.js && node test/effort.test.js && node test/regressao.test.js && node test/memoria-conversa.test.js && node test/repeticao.test.js && node test/casar.test.js && node test/recado.test.js && node test/releitura.test.js && node test/snapshot.test.js && node test/video.test.js && node test/limpeza.test.js && node test/autonomia.test.js && node test/desfazer.test.js && node test/desfazer-git.test.js && node test/referencia.test.js && node test/parar.test.js && node test/continuar.test.js && node test/pipeline.test.js && node test/conta.test.mjs && node test/nuvem.test.js && node test/prazo.test.js && node test/primeira-vez.test.js && node test/fala.test.js && node test/especialistas.test.js && node test/empurrao.test.js && node test/terminal-novo.test.js && node test/markdown.test.js && node test/coerencia.test.js && node test/contexto.test.js && node test/perigo.test.js && node test/rapidez.test.js && node test/mascotes.test.js && node test/comandos-extra.test.js && node test/offline.test.js && node test/edicao.test.js && node test/composicao.test.js && node test/acervo-site.test.js && node test/impacto.test.js && node test/cinema.test.js && node test/producao.test.js && node test/ende.test.js && node test/capa.test.js && node test/broll.test.js && node test/morfar.test.js && node test/motion.test.js && node test/motion-roteiro.test.js && node test/kit-motion.test.js && node test/gerativo.test.js && node test/gerativo-identidade.test.js && node test/gerativo-moldura.test.js && node test/gerativo-heroi.test.js && node test/gerativo-ambiente.test.js && node test/gerativo-variedade.test.js && node test/hibrido.test.js && node test/batida.test.js && node test/estudio-acervo.test.js && node test/estudio-diretor.test.js && node test/estudio-marca.test.js && node test/estudio-novo-projeto.test.js && node test/estudio-plano.test.js && node test/estudio-slides.test.js && node test/estudio-video.test.js && node test/revisor.test.js && node test/assinatura.test.js && node test/biblioteca.test.js && node test/mcp.test.js && node test/personas.test.js && node test/efeitos.test.js && node test/auto.test.js && node test/colar.test.js && node test/orquestra.test.js && node test/shell-limpo.test.js && node test/editar-remotion.test.js && node test/variacao3d.test.js && node test/portao-skill.test.js && node test/clones.test.js && node test/kokoro.test.js && node test/fluido.test.js && node test/zoom.test.js && node test/personagem.test.js && node test/tela.test.js && node test/margem.test.js && node test/vazamento.test.js"
   },
   "engines": {
     "node": ">=18.17.0"