primocode 10.1.0 → 10.2.0

package/lib/estudio/edicao.js

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

package/lib/estudio/estilo.js

@@ -51,13 +51,23 @@ const normal = (e) => {
 /* 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'). */
-const RODIZIO = ['hibrido', 'cinema', 'gerativo', 'impacto', 'fluido'];
+/* 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) {
-    return variedade.sortear(RODIZIO, 'estilo', { aleatorio }) || 'hibrido';
+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, aleatorio } = {}) {
+function escolherEstilo({ pedido = '', agente = null, roteiro = null, girar = false, semImagem = false, aleatorio } = {}) {
     const pedidoAgente = normal(agente);
     if (pedidoAgente) return pedidoAgente;
     const doRoteiro = normal(roteiro);
@@ -73,10 +83,11 @@ function escolherEstilo({ pedido = '', agente = null, roteiro = null, girar = fa
     /* 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). Com `girar`, o padrão roda (RODIZIO). */
-    return girar ? estiloDaVez(aleatorio) : 'hibrido';
+    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', 'fluido']);
 
-module.exports = { escolherEstilo, estiloDaVez, ESTILOS, LEVES, PEDE_MOTION, PEDE_FLUIDO, RODIZIO };
+module.exports = { escolherEstilo, estiloDaVez, ESTILOS, LEVES, PEDE_MOTION, PEDE_FLUIDO, RODIZIO, RODIZIO_SEM_IMAGEM };

package/lib/estudio/fluido.js

@@ -38,11 +38,18 @@ const ANTES = 0.12;                      // a batida troca isto antes da primeir
    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'], CLARAS = ['lavanda', 'creme'];
+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; };
 
@@ -51,9 +58,9 @@ function paletaDe(roteiro, semente) {
     const pedida = String(roteiro.paleta || '').toLowerCase();
     const tema = String(roteiro.tema || '').toLowerCase();
     const nome = PALETAS[pedida] ? pedida
-        : /claro|light/.test(tema) ? CLARAS[semente % 2]
-            : /escuro|dark/.test(tema) ? ESCURAS[semente % 2]
-                : Object.keys(PALETAS)[semente % 4];
+        : /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;
@@ -106,7 +113,7 @@ const TIPO = { logo: 'abertura', imagem: 'titulo', produto: 'titulo', grafico: '
  * 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 = [] }) {
+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);
@@ -116,9 +123,15 @@ function partituraDe({ roteiro, largura = 1920, altura = 1080, tempos = [] }) {
     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) => {
-        const tipo = TIPO[p.tipo] || (FORMA[p.tipo] ? p.tipo : 'titulo');
+        /* 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) }); };
@@ -126,7 +139,8 @@ function partituraDe({ roteiro, largura = 1920, altura = 1080, tempos = [] }) {
         /* O CARTÃO DE PRODUTO que flutua ao lado (terminal, chat, painel), feito
            de forma e texto — e o texto vai para o outro lado. `ui: false` tira. */
         const ui = p.ui === false ? null : typeof p.ui === 'string' ? p.ui
-            : tipo === 'titulo' || tipo === 'abertura' ? ['terminal', 'chat'][comCartao % 2] : tipo === 'numero' ? 'painel' : null;
+            : !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)] }
@@ -165,6 +179,53 @@ function partituraDe({ roteiro, largura = 1920, altura = 1080, tempos = [] }) {
         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).
@@ -185,13 +246,16 @@ function partituraDe({ roteiro, largura = 1920, altura = 1080, tempos = [] }) {
                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 = cursor;
+                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 + 12); q++) if (casa(k, ditas[q].k)) { c = q + 1; return ditas[q].de; }
+                    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; }
@@ -201,7 +265,11 @@ function partituraDe({ roteiro, largura = 1920, altura = 1080, tempos = [] }) {
             const ach = ts.findIndex((x) => x != null);
             /* O que a voz não diz entra cedo o bastante para ser lido antes de a
                frase acabar (e nunca antes da batida). */
-            let t = ach >= 0 ? ts[ach] - ach * STAGGER
+            /* 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];
@@ -226,6 +294,7 @@ function partituraDe({ roteiro, largura = 1920, altura = 1080, tempos = [] }) {
 
     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,
@@ -238,10 +307,10 @@ function partituraDe({ roteiro, largura = 1920, altura = 1080, tempos = [] }) {
  * @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 }) {
+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 });
+    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
@@ -277,7 +346,7 @@ function montarFluido({ roteiro, largura = 1920, altura = 1080, tempos = [], nar
             efeitos,
         },
     };
-    return { ok: true, plano, partitura, resumo: { cenas: 1, batidas: partitura.batidas.length, segundos: DUR, fps: FPS, paleta: P.nome, atraso: partitura.atraso, sincronia: partitura.sincronia } };
+    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/index.js

@@ -43,6 +43,8 @@ const plano = require('./plano.js');
 const remotion = require('./remotion.js');
 const assets = require('./assets.js');
 const video = require('./video.js');
+const batida = require('./batida.js');
+const revisor = require('./revisor.js');
 const identidade = require('./identidade.js');
 const slides = require('./slides.js');
 const edicao = require('./edicao.js');
@@ -666,7 +668,7 @@ async function ferramentaVideo(args, ctx = {}) {
         if ((args.estilo || 'viral') === 'viral' && args.recorte !== false) {
             const recortes = {};
             for (const [i, info] of montado.infos.entries()) {
-                if (!edicao.temRecorte(i) || !info.forte || info.forte.peso < 9 || Object.keys(recortes).length >= 3) continue;
+                if (!info.recorte || !info.forte || info.forte.peso < 9 || Object.keys(recortes).length >= 3) continue;
                 const de = Math.max(0, info.forte.de - 0.15);
                 const ate = Math.min(info.dur, de + 2.2);
                 if (ate - de < 1) continue;
@@ -715,6 +717,18 @@ async function ferramentaVideo(args, ctx = {}) {
    senão uma foto. Devolve {src, tipo} ou null. O clipe sai sorteado entre
    os que os últimos vídeos não usaram (variedade.js), não o primeiro da
    busca — "o b-roll veio igual nos dois vídeos" (Joel, 05/10). */
+/** A foto editorial (Wikimedia, museu) que os últimos vídeos não usaram; o crédito fica no caderno. */
+async function baixarEditorial(p, termo) {
+    try {
+        const b = await assets.procurarEditorial(termo, { quantas: 8 });
+        for (const item of variedade.ordenar(b.imagens, 'broll').slice(0, 4)) {
+            const d = await assets.baixar(item, { pasta: p.pasta, nome: 'foto-' + termo });
+            if (d.ok) { variedade.marcar('broll', item.url); projeto.anotar(p.id, 'creditos', item.creditos); return { src: d.relativo, tipo: 'imagem' }; }
+        }
+    } catch { /* sem foto */ }
+    return null;
+}
+
 async function baixarApoio(p, termo, { orientacao = null, video: querVideo = false } = {}) {
     if (querVideo) {
         try {
@@ -749,11 +763,26 @@ async function variarIcones(plano, roteiro) {
     const explicitos = [];
     try { JSON.stringify(roteiro || {}, (k, v) => { if (k === 'icone' && typeof v === 'string') explicitos.push(v); return v; }); } catch { /* sem */ }
     const troca = {};
-    if (colecao !== 'fluent-3d') {
-        for (const nome of variedade.iconesTrocaveis(plano, explicitos)) {
-            const novo = colecao + ':' + nome.split(':')[1];
-            try { const r = await assets.icone(novo); if (r && r.ok) troca[nome] = novo; } catch { /* fica o 3D */ }
+    for (const nome of variedade.iconesTrocaveis(plano, explicitos)) {
+        /* Primeiro O ÍCONE: o conceito escolhe entre as formas dele
+           (edicao.ALTERNATIVAS) pelos pontos da variedade — o que os últimos
+           vídeos menos usaram. Depois A COLEÇÃO. */
+        const base = nome.split(':')[1];
+        let escolhido = base;
+        const alts = edicao.ALTERNATIVAS[base];
+        if (alts) {
+            const ordem = variedade.ordenar([base, ...alts].map((url) => ({ url })), 'icone-nome').map((x) => x.url);
+            for (const n of ordem) {
+                if (n === base) { escolhido = base; break; }
+                try { const r = await assets.icone('fluent-3d:' + n); if (r && r.ok) { escolhido = n; break; } } catch { /* tenta o próximo */ }
+            }
+            variedade.marcar('icone-nome', escolhido);
         }
+        let novo = 'fluent-3d:' + escolhido;
+        if (colecao !== 'fluent-3d') {
+            try { const r = await assets.icone(colecao + ':' + escolhido); if (r && r.ok) novo = colecao + ':' + escolhido; } catch { /* fica o 3D */ }
+        }
+        if (novo !== nome) troca[nome] = novo;
     }
     const n = variedade.trocarIcones(plano, troca);
     if (n || colecao === 'fluent-3d') variedade.marcar('icones', colecao);
@@ -1008,16 +1037,13 @@ async function prepararRoteiro(p, args) {
        IMPACTO. O que o agente pediu vale mais que tudo. */
     const pedidoTxt = `${p.pedido || ''} ${args.pedido || ''}`;
     const ref = referencias.atual();
-    /* Ninguém escolheu? O padrão gira (estilo.js, RODIZIO) — menos no "sem
-       referências", que só tem o motion e segue a regra de baixo. */
-    let estilo = escolherEstilo({ pedido: pedidoTxt, agente: args.estilo, roteiro: roteiro.estilo, girar: ref.modo !== 'sem' });
-    /* "Sem referências, só motion": o híbrido vive de b-roll de fora, então
-       cai para o motion — sem nada baixado. */
-    const produtoNoPedido = /produto|an[uú]nci|lan[çc]a|headset|fone|celular|t[eê]nis|rel[oó]gio|garrafa|lata|app\b/i.test(pedidoTxt);
-    /* E o motion de agora é o GERATIVO: sem template, produto ou não (o
-       produto em 3D entra numa batida dele, logo abaixo). */
-    if (ref.modo === 'sem' && estilo === 'hibrido') estilo = 'gerativo';
-    void produtoNoPedido;
+    /* Sem imagem é o padrão (07/10): sem o pedido dizer, nada de foto nem
+       vídeo de fora. Ninguém escolheu o estilo? Ele gira (estilo.js) — sem
+       imagem, só entre os que não vivem de foto. O híbrido e o cinema, pedidos
+       pelo nome sem imagem, caem para o gerativo (sem nada baixado). */
+    const semImagem = referencias.semImagem(ref);
+    let estilo = escolherEstilo({ pedido: pedidoTxt, agente: args.estilo, roteiro: roteiro.estilo, girar: true, semImagem });
+    if (semImagem && (estilo === 'hibrido' || estilo === 'cinema')) estilo = 'gerativo';
     /* "O vídeo deve ter um 3D do fone" (30/09): pedido de 3D vira o gerativo
        com o produto modelado girando numa batida (kit/tres.jsx) — a menos que
        o agente tenha escolhido outro estilo pelo nome. */
@@ -1046,8 +1072,8 @@ async function prepararRoteiro(p, args) {
        todos iguais" (02/10). A marca manda; depois o roteiro.visual da IA;
        sem nada, o sorteio que pula o que os últimos vídeos usaram. */
     if (['hibrido', 'cinema', 'impacto'].includes(estilo)) {
-        const v = biblioteca.vestir(roteiro);
-        if (v.mudou) projeto.anotar(p.id, 'visual', [v.titulo && `fonte ${v.titulo} + ${v.texto}`, v.paleta && `paleta ${v.paleta}`].filter(Boolean).join(', '));
+        const v = biblioteca.vestir(roteiro, { estilo });
+        if (v.mudou) projeto.anotar(p.id, 'visual', [v.titulo && `fonte ${v.titulo} + ${v.texto} (tom ${v.tom})`, v.paleta && `paleta ${v.paleta}`].filter(Boolean).join(', '));
     }
     // Os estilos de motion usam os efeitos leves e a trilha do ende.app; os de corte, os cheios.
     const ehMotion = LEVES.has(estilo);
@@ -1079,13 +1105,13 @@ async function prepararRoteiro(p, args) {
     const videosMarca = [...(acervo.videos || [])];
     const imagens = {}, fundos = {};
     for (const [i, parte] of partes.entries()) {
-        if (parte.tipo !== 'imagem' || parte.src) continue;
+        if (semImagem || parte.tipo !== 'imagem' || parte.src) continue;
         const texto = `${parte.titulo || ''} ${parte.sub || ''} ${parte.fala || ''} ${parte.busca || ''}`;
         if (modo === 'video' && videosMarca.length && i % 2 === 1) { imagens[i] = { src: videosMarca.shift().src, tipo: 'video' }; continue; }
         const m = melhorFoto(texto) || (parte.busca ? await baixarApoio(p, parte.busca, { orientacao: largura >= altura ? 'landscape' : 'portrait', video: modo === 'video' }) : null);
         if (m) imagens[i] = m;
     }
-    if (acervo.fotos.length) {
+    if (acervo.fotos.length && !semImagem) {
         const comFundo = ['abertura', 'titulo', 'contraste', 'citacao', 'cta', 'passos'];
         let alterna = 0;
         for (const [i, parte] of partes.entries()) {
@@ -1408,9 +1434,8 @@ async function prepararRoteiro(p, args) {
                    funk para o fone, eletrônica para IA…), sorteia a faixa e não
                    repete as últimas usadas — nada de "inspiring corporate". */
                 let m = null;
-                const usadasArq = path.join(os.homedir(), '.primocode', 'studio', 'trilhas-usadas.json');
-                let usadas = [];
-                try { usadas = JSON.parse(fs.readFileSync(usadasArq, 'utf8')); } catch { usadas = []; }
+                // A memória da trilha é a da variedade ('trilha'): antes era um arquivo à parte (trilhas-usadas.json).
+                const usadas = variedade.usadas('trilha');
                 const mus = estilo === 'gerativo' ? gerativo.musicaDe(roteiro) : null;
                 /* A trilha do gerativo vem do Jamendo (Openverse), pelo GÊNERO do
                    assunto, instrumental, sorteada e sem repetir as últimas — a
@@ -1421,9 +1446,10 @@ async function prepararRoteiro(p, args) {
                         classical: 'piano classical instrumental', 'soul-rnb': 'soul instrumental' };
                     try {
                         const b = await assets.procurarMusica(BUSCA[roteiro.genero || mus.genero] || ((roteiro.genero || mus.genero) + ' instrumental'), { quantas: 8, duracaoMin: Math.max(45, segundos + 10) });
-                        const opcoes = (b.ok ? b.sons : []).filter((x) => x.url && !usadas.includes(x.url) && !/vocal|voice|feat|ft\.|remix/i.test(x.titulo || ''));
+                        // Pelos pontos da variedade: a recente e a muito usada vão para o fim, não somem.
+                        const opcoes = variedade.ordenar((b.ok ? b.sons : []).filter((x) => !/vocal|voice|feat|ft\.|remix/i.test(x.titulo || '')), 'trilha');
                         for (let k = 0; k < opcoes.length && !m; k++) {
-                            const item = opcoes[(mus.semente + k) % opcoes.length];
+                            const item = opcoes[k];
                             const d = await assets.baixar(item, { pasta: p.pasta, nome: 'trilha-' + (roteiro.genero || mus.genero) });
                             if (!d.ok) continue;
                             if (await temLetra(path.join(p.pasta, d.relativo))) { projeto.anotar(p.id, 'midia', `trilha com voz descartada: ${item.titulo}`); continue; }
@@ -1432,12 +1458,12 @@ async function prepararRoteiro(p, args) {
                     } catch { /* cai na ende.app */ }
                 }
                 if (mus && m) {
-                    try { fs.writeFileSync(usadasArq, JSON.stringify([m.id, ...usadas.filter((x) => x !== m.id)].slice(0, 16))); } catch { /* sem memória */ }
+                    variedade.marcar('trilha', m.id);
                     projeto.anotar(p.id, 'trilha', `gênero ${roteiro.genero || mus.genero} (Jamendo)`);
                 } else if (mus) {
                     m = await ende.provedor({ pasta: path.join(p.pasta, 'midia') }).gerar({ clima: roteiro.clima || 'energetico', segundos, genero: roteiro.genero || mus.genero, semente: mus.semente, evitar: usadas });
                     const id = m && Number((/ende-(\d+)\.mp3$/.exec(m.src) || [])[1]);
-                    if (id) try { fs.writeFileSync(usadasArq, JSON.stringify([id, ...usadas.filter((x) => x !== id)].slice(0, 16))); } catch { /* sem memória */ }
+                    if (id) variedade.marcar('trilha', id);
                     if (m) projeto.anotar(p.id, 'trilha', `gênero ${roteiro.genero || mus.genero}`);
                 } else m = await ende.provedor({ pasta: path.join(p.pasta, 'midia') }).gerar({ clima: roteiro.clima || 'tecnologia', segundos });
                 if (m) { trilha = path.relative(p.pasta, m.src).replace(/\\/g, '/'); projeto.anotar(p.id, 'trilha', m.credito); }
@@ -1512,8 +1538,48 @@ async function prepararRoteiro(p, args) {
         return r;
     }
     if (estilo === 'fluido' && modo === 'video') {
-        const r = fluido.montarFluido({ roteiro, largura, altura, tempos, narracao, sons, trilha });
-        if (r.ok) projeto.anotar(p.id, 'plano', `estilo fluido: ${r.resumo.batidas} batidas, paleta ${r.resumo.paleta}, ${r.resumo.segundos}s, batida atrasada no máximo ${r.resumo.atraso}s, palavra atrás da voz no máximo ${r.resumo.sincronia}s`);
+        /* A CARA de cada vídeo do fluido, por PROJETO (ajustar uma frase não
+           troca): a semente (marcador, jeito das imagens) e a paleta, que a
+           memória de variedade não repete do vídeo anterior (08/10: "sempre o
+           mesmo azul"). A paleta ou o tema pedidos mandam. */
+        if (roteiro.semente == null) {
+            roteiro.semente = p.semente != null ? p.semente : Math.floor(Math.random() * 1e9);
+            if (p.semente == null) projeto.salvar(p.id, { semente: roteiro.semente });
+        }
+        /* O modelo também vicia: pedia "noite" em todo vídeo (era a primeira da
+           lista). A paleta dele vale, menos quando é uma das 2 últimas usadas —
+           aí vem a menos usada do mesmo tema (escura ou clara). */
+        if (!p.paletaFluido) {
+            const P = fluido.PALETAS, nomes = Object.keys(P);
+            const pedida = P[String(roteiro.paleta || '').toLowerCase()] ? String(roteiro.paleta).toLowerCase() : null;
+            const recentes = variedade.usadas('paleta-fluido').slice(0, 2);
+            const escuro = pedida ? P[pedida].escuro : /escuro|dark/i.test(roteiro.tema || '') ? true : /claro|light/i.test(roteiro.tema || '') ? false : null;
+            let escolha = pedida && !recentes.includes(pedida) ? pedida : null;
+            if (!escolha) escolha = variedade.sortear(nomes.filter((n) => escuro == null || P[n].escuro === escuro), 'paleta-fluido');
+            else variedade.marcar('paleta-fluido', escolha);
+            if (pedida && escolha !== pedida) projeto.anotar(p.id, 'visual', `paleta ${pedida} pedida, mas foi a de um dos últimos vídeos: ${escolha}`);
+            projeto.salvar(p.id, { paletaFluido: escolha });
+            p.paletaFluido = escolha;
+        }
+        roteiro.paleta = p.paletaFluido;
+        /* As IMAGENS do fluido misto, só com imagem pedida: as partes com
+           "busca", no máximo 1 em 3 e espalhadas (fluido.js decide o jeito). */
+        const fotosFluido = {};
+        if (!semImagem) {
+            const comBusca = partes.map((pt, k) => (pt.busca || pt.src ? k : -1)).filter((k) => k >= 0 && (partes[k].tipo !== 'cta'));
+            const teto = Math.max(1, Math.floor(partes.length / 3));
+            const escolhidas = [];
+            for (const k of comBusca) if (escolhidas.length < teto && !escolhidas.some((j) => Math.abs(j - k) < 2)) escolhidas.push(k);
+            for (const k of escolhidas) {
+                const pt = partes[k];
+                // O acervo EDITORIAL (assets.procurarEditorial), não o banco de stock: sem foto que sirva, a parte fica sem imagem.
+                const m = pt.src ? { src: pt.src } : await baixarEditorial(p, pt.busca);
+                if (m && m.src) fotosFluido[k] = { src: m.src };
+            }
+            if (Object.keys(fotosFluido).length) projeto.anotar(p.id, 'midia', `fluido misto: imagem nas partes ${Object.keys(fotosFluido).map((k) => Number(k) + 1).join(', ')}`);
+        }
+        const r = fluido.montarFluido({ imagens: fotosFluido, roteiro: { ...roteiro, pedido: roteiro.pedido || pedidoTxt }, largura, altura, tempos, narracao, sons, trilha });
+        if (r.ok) projeto.anotar(p.id, 'plano', `estilo fluido: ${r.resumo.batidas} batidas${r.resumo.imagens.length ? ` (imagens: ${r.resumo.imagens.join(', ')})` : ''}, paleta ${r.resumo.paleta}, ${r.resumo.segundos}s, batida atrasada no máximo ${r.resumo.atraso}s, palavra atrás da voz no máximo ${r.resumo.sincronia}s`);
         return r;
     }
     if (estilo === 'motion' && modo === 'video') {
@@ -1600,10 +1666,34 @@ async function ferramentaRender(args, ctx = {}) {
             problemas: conferida.problemas.slice(0, 12) };
     }
 
+    /* A REVISÃO (revisor.js): o plano roda; agora, ele está bom? Conserta a
+       receita (transição repetida, câmera sem respiro, som duplicado) e
+       devolve o resto como aviso para quem fez o plano. */
+    const revisao = revisor.revisar(pl, { semImagem: referencias.semImagem() });
+    if (revisao.consertos.length) projeto.anotar(args.id, 'revisao', revisao.consertos.join('; '));
+    if (revisao.avisos.length) projeto.anotar(args.id, 'revisao', 'avisos: ' + revisao.avisos.join('; '));
+
     // Os ícones vêm ANTES do render: um render que busca ícone na internet
     // falha no meio, depois de vinte minutos.
     const { mapa, faltaram } = await assets.iconesDoPlano(pl, p.pasta);
 
+    /* A MÚSICA NO CORTE (batida.js): a faixa começa no ponto em que as
+       batidas caem nos cortes do plano, e o corte de impacto num acento. Só
+       quando ninguém disse o início (audio.trilha.inicio). */
+    const tr = pl.audio && pl.audio.trilha;
+    if (tr && !(typeof tr === 'object' && tr.inicio != null) && !(p.formato === 'slides' || p.formato === 'arte' || args.paginas)) {
+        try {
+            const src = path.join(p.pasta, tr.src || tr);
+            const analise = await batida.analisar(src, { ffmpeg: video.ffmpeg() || 'ffmpeg' });
+            if (analise && analise.batidas.length) {
+                const duracao = (pl.cenas || []).reduce((n, c) => n + (Number(c.duracao) || 0), 0);
+                const r = batida.melhorInicio(batida.cortesDoPlano(pl), analise, { maximo: Math.min(20, analise.segundos - duracao - 0.5) });
+                pl.audio.trilha = { ...(typeof tr === 'object' ? tr : { src: tr }), inicio: r.inicio };
+                projeto.anotar(args.id, 'trilha', `${analise.bpm} BPM; a faixa entra em ${r.inicio}s e ${r.alinhados} de ${r.total} cortes caem na batida`);
+            }
+        } catch { /* sem análise, a faixa entra do começo */ }
+    }
+
     const montado = remotion.montar({ pasta: p.pasta, titulo: p.titulo, plano: pl, icones: mapa });
 
     if (args.somenteProjeto) {
@@ -1669,7 +1759,9 @@ async function ferramentaRender(args, ctx = {}) {
     return {
         ok: true, arquivo: saida, bytes, segundos: conferida.duracao,
         faltaram: faltaram.length ? faltaram : undefined,
-        aviso: 'ABERTO para o usuário assistir. Chame finish dizendo o que foi feito.',
+        revisao: revisao.consertos.length || revisao.avisos.length ? { consertado: revisao.consertos, avisos: revisao.avisos } : undefined,
+        aviso: 'ABERTO para o usuário assistir. Chame finish dizendo o que foi feito'
+            + (revisao.avisos.length ? ' — e cite os avisos da revisão que valem um novo plano.' : '.'),
     };
 }
 
@@ -1803,7 +1895,7 @@ async function ferramentaSite(args) {
     return r;
 }
 
-module.exports = {
+module.exports = { variarIcones,
     ferramentaProjeto, ferramentaPlano, ferramentaMidia, ferramentaNarrar,
     ferramentaVideo, ferramentaRender, ferramentaSite,
     projeto, plano, remotion, assets, video, identidade, slides, python, rodarPython, alinharPartes, prepararRoteiro,