primocode 10.5.0 → 10.7.0

package/lib/estudio/cenarios.js

@@ -0,0 +1,91 @@
+/**
+ * cenarios.js — os cenários que a IA criou e a pessoa deixou guardar.
+ *
+ *   "a IA vai criar os próprios cenários, além de ter os próprios cenários
+ *    prontos, e pede pro usuário se pode salvar pra usar na próxima vez."
+ *    (Joel, 12/10)
+ *
+ * Os lugares prontos moram no mundo.js (praia, cidade, cobertura…). A IA já
+ * podia mudar o céu, o chão, a luz e os elementos de UMA cena; o que se perdia
+ * era o resultado: o próximo vídeo começava do zero. Aqui o cenário inventado
+ * ganha nome e fica em ~/.primocode/cenarios.json — só com o "sim" da pessoa
+ * (a ferramenta recusa sem `autorizado: true`) — e vira um lugar como os
+ * outros: `lugar: "<nome>"` na cena o traz de volta.
+ *
+ * Só se guarda o que o mundo.js sabe desenhar: o lugar base, cores #rrggbb,
+ * a hora e até 7 elementos. Nada de caminho de arquivo nem código.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const arquivo = () => path.join(os.homedir(), '.primocode', 'cenarios.json');
+const ehCor = (c) => typeof c === 'string' && /^#[0-9a-f]{6}$/i.test(c);
+const TIPOS_DE_CHAO = ['areia', 'asfalto', 'grama', 'neve', 'lua', 'madeira', 'ladrilho'];
+const HORAS = ['noite', 'por_do_sol', 'amanhecer'];
+
+/** "Loja da Ana à noite" → "loja_da_ana_a_noite" (o mesmo jeito dos lugares do mundo.js). */
+function chave(nome) {
+    return String(nome || '').normalize('NFD').replace(/[̀-ͯ]/g, '').toLowerCase()
+        .replace(/[^a-z0-9]+/g, '_').replace(/^_|_$/g, '').slice(0, 40);
+}
+
+function lerTudo() {
+    try { const j = JSON.parse(fs.readFileSync(arquivo(), 'utf8')); return j && typeof j === 'object' ? j : {}; } catch { return {}; }
+}
+
+/** Só o que o mundo sabe desenhar; o resto cai fora em silêncio. */
+function limpar(c, bases) {
+    const o = c && typeof c === 'object' ? c : {};
+    const base = chave(o.base || o.lugar);
+    const out = { base: bases.includes(base) ? base : 'cobertura' };
+    if (typeof o.descricao === 'string') out.descricao = o.descricao.slice(0, 200);
+    if (Array.isArray(o.ceu) && o.ceu.length === 2 && o.ceu.every(ehCor)) out.ceu = o.ceu;
+    for (const k of ['parede', 'luz', 'acento']) if (ehCor(o[k])) out[k] = o[k];
+    if (o.chao && typeof o.chao === 'object') {
+        const ch = {};
+        if (TIPOS_DE_CHAO.includes(o.chao.tipo)) ch.tipo = o.chao.tipo;
+        if (ehCor(o.chao.cor)) ch.cor = o.chao.cor;
+        if (ehCor(o.chao.cor2)) ch.cor2 = o.chao.cor2;
+        if (Object.keys(ch).length) out.chao = ch;
+    } else if (ehCor(o.chao)) out.chao = { cor: o.chao, cor2: o.chao };
+    if (HORAS.includes(o.hora)) out.hora = o.hora.replace(/_/g, ' ');
+    if (Array.isArray(o.elementos)) {
+        const els = o.elementos.map((e) => (typeof e === 'string' ? e : e && e.nome) || '').map((s) => String(s).slice(0, 40)).filter(Boolean).slice(0, 7);
+        if (els.length) out.elementos = els;
+    }
+    return out;
+}
+
+/**
+ * Guarda o cenário. `autorizado` é a resposta da pessoa: sem ela, nada é escrito.
+ * @param {{nome:string, cenario:object, autorizado:boolean, bases:string[]}} op
+ */
+function salvar({ nome, cenario, autorizado, bases = [] } = {}) {
+    if (autorizado !== true) {
+        return { ok: false, error: 'falta o sim da pessoa.', comoResolver: 'pergunte "posso salvar este cenário pra usar na próxima vez?" e só chame de novo com autorizado:true se ela disser que sim.' };
+    }
+    const k = chave(nome);
+    if (!k) return { ok: false, error: 'dê um nome ao cenário (ex: "loja da Ana à noite").' };
+    if (bases.includes(k)) return { ok: false, error: `"${k}" já é um lugar pronto; escolha outro nome.` };
+    const tudo = lerTudo();
+    const novo = { ...limpar(cenario, bases), nome: String(nome).slice(0, 60), salvo: new Date().toISOString() };
+    tudo[k] = novo;
+    fs.mkdirSync(path.dirname(arquivo()), { recursive: true });
+    fs.writeFileSync(arquivo(), JSON.stringify(tudo, null, 2));
+    return { ok: true, chave: k, cenario: novo, comoUsar: `na próxima cena, lugar:"${k}" traz este cenário de volta.` };
+}
+
+function ler(nome) {
+    const k = chave(nome);
+    return k ? lerTudo()[k] || null : null;
+}
+
+function listar() {
+    return Object.entries(lerTudo()).map(([k, c]) => ({ chave: k, nome: c.nome, base: c.base, descricao: c.descricao || '' }));
+}
+
+module.exports = { salvar, ler, listar, limpar, chave, arquivo };

package/lib/estudio/colecao.js

@@ -55,6 +55,27 @@ const PT_EN = {
     surpreso: 'surprised', cerebro: 'brain', 'cérebro': 'brain', olho: 'eye', mao: 'hand', 'mão': 'hand', joinha: 'thumbs up',
     palmas: 'clapping', aplauso: 'clapping', calendario: 'calendar', 'calendário': 'calendar', saco: 'money bag', banco: 'bank',
     cartao: 'credit card', 'cartão': 'credit card', loja: 'shopping', compras: 'shopping cart', voto: 'ballot box', ferramenta: 'hammer',
+    // Comida, objeto e veículo: o que vira personagem ou peça da cena 3D (mundo.js).
+    hamburguer: 'hamburger', 'hambúrguer': 'hamburger', batata: 'potato', 'batata frita': 'french fries', sorvete: 'ice cream', bolo: 'birthday cake',
+    chocolate: 'chocolate bar', maca: 'red apple', 'maçã': 'red apple', uva: 'grapes', morango: 'strawberry', abacaxi: 'pineapple', melancia: 'watermelon',
+    cenoura: 'carrot', ovo: 'egg', queijo: 'cheese wedge', leite: 'glass of milk', cerveja: 'beer mug', vinho: 'wine glass', suco: 'beverage box',
+    refrigerante: 'cup with straw', sanduiche: 'sandwich', 'sanduíche': 'sandwich', sushi: 'sushi', 'cachorro-quente': 'hot dog', pipoca: 'popcorn',
+    rosquinha: 'doughnut', donut: 'doughnut', biscoito: 'cookie', abacate: 'avocado', coco: 'coconut', taco: 'taco', croissant: 'croissant',
+    barraca: 'tent', fogueira: 'fire', palmeira: 'palm tree', violao: 'guitar', 'violão': 'guitar', guitarra: 'guitar', bola: 'soccer ball',
+    bicicleta: 'bicycle', moto: 'motorcycle', aviao: 'airplane', 'avião': 'airplane', trem: 'locomotive', onibus: 'bus', 'ônibus': 'bus',
+    navio: 'ship', helicoptero: 'helicopter', 'helicóptero': 'helicopter', lapis: 'pencil', 'lápis': 'pencil', caneta: 'pen', mochila: 'backpack',
+    chapeu: 'top hat', 'chapéu': 'top hat', oculos: 'glasses', 'óculos': 'glasses', televisao: 'television', 'televisão': 'television', tv: 'television',
+    microfone: 'microphone', fone: 'headphone', 'guarda-chuva': 'umbrella', cogumelo: 'mushroom', semaforo: 'vertical traffic light',
+    'semáforo': 'vertical traffic light', ampulheta: 'hourglass', lua: 'crescent moon', nuvem: 'cloud', arco_iris: 'rainbow', 'arco-íris': 'rainbow',
+    flor: 'blossom', rosa: 'rose', girassol: 'sunflower', 'cacto': 'cactus', vulcao: 'volcano', 'vulcão': 'volcano', castelo: 'castle',
+    fantasma: 'ghost', alien: 'alien', 'alienígena': 'alien', et: 'alien', unicornio: 'unicorn', 'unicórnio': 'unicorn', dragao: 'dragon', 'dragão': 'dragon',
+    // Bichos que o kit/mundo.jsx não monta de blocos: vêm do ícone 3D (a lula fica de fora: é o presidente).
+    polvo: 'octopus', baleia: 'whale', caranguejo: 'crab', borboleta: 'butterfly', abelha: 'honeybee', cobra: 'snake', jacare: 'crocodile',
+    'jacaré': 'crocodile', crocodilo: 'crocodile', formiga: 'ant', aranha: 'spider', camelo: 'camel', zebra: 'zebra', hipopotamo: 'hippopotamus',
+    'hipopótamo': 'hippopotamus', rinoceronte: 'rhinoceros', canguru: 'kangaroo', coala: 'koala', preguica: 'sloth', 'preguiça': 'sloth',
+    joaninha: 'lady beetle', caracol: 'snail', minhoca: 'worm', morcego: 'bat', esquilo: 'chipmunk', rato: 'mouse', hamster: 'hamster',
+    lagosta: 'lobster', camarao: 'shrimp', 'camarão': 'shrimp', flamingo: 'flamingo', pavao: 'peacock', 'pavão': 'peacock', cisne: 'swan',
+    aguia: 'eagle', 'águia': 'eagle', peru: 'turkey', lhama: 'llama', gorila: 'gorilla', orangotango: 'orangutan', bufalo: 'water buffalo',
     engrenagem: 'gear', ciencia: 'test tube', 'ciência': 'test tube', saude: 'hospital', 'saúde': 'hospital', remedio: 'pill', 'remédio': 'pill',
 };
 
@@ -177,9 +198,22 @@ function cardapio() {
         personagens3d: 'o estilo personagem (voxel): bonecos de blocos e o mascote, com a câmera de cinema — estudio_roteiro estilo:"personagem"',
         efeitosSonoros: { sintetizados: sons, internet: 'acao:efeito termo:"whoosh" (Openverse, licença aberta, até 6 s)' },
         musicas: { internet: 'acao:trilha termo:"lofi" (Openverse, 30 s ou mais)', automatica: 'sem trilha pedida, o PrimoCode escolhe uma sem repetir as últimas' },
+        movimentos: { quantos: Object.keys(require('./movimentos.js').CATALOGO).length, acao: 'movimentos', exemplo: 'termo:"quique" → movimento:"quicar-de-baixo"' },
         fontes: { quantas: fontes || 128, acao: 'fontes', nota: 'Google Fonts, por tipo (condensada, display, serifada, manuscrita…)' },
         imagens: 'acao:imagem termo:"…" (Openverse e Wikimedia; Google com chave) — só quando a pessoa pediu imagem',
     };
 }
 
-module.exports = { procurarIcones3d, procurarAnimacoes, baixar, cardapio, termos, PT_EN };
+/** O ícone 3D que É a coisa (nota de palavra inteira), ou null: "pizza" acha, "joel" não. */
+function melhorIcone3d(termo, piso = 80) {
+    const ts = termos(termo);
+    if (!ts.length) return null;
+    let melhor = null;
+    for (const [nome, , kw = ''] of fluent()) {
+        const n = Math.max(nota(nome, ts), nota(kw, ts) * 0.8);
+        if (n >= piso && (!melhor || n > melhor.n || (n === melhor.n && nome.length < melhor.nome.length))) melhor = { nome, n };
+    }
+    return melhor ? 'fluent3d:' + melhor.nome : null;
+}
+
+module.exports = { melhorIcone3d, procurarIcones3d, procurarAnimacoes, baixar, cardapio, termos, PT_EN };

package/lib/estudio/diretor.js

@@ -288,6 +288,7 @@ REGRAS QUE SEPARAM UM VÍDEO BOM DE UM GENÉRICO:
 5. RITMO VARIADO. Cenas de durações diferentes e transições diferentes. Tudo em fade parece slide.
 5b. NADA DE GAVETA. Não existe tema pronto, layout pronto nem fundo pronto: é você que decide a cor, a tipografia e a composição DESTE vídeo. Dois vídeos seus sobre assuntos diferentes não podem sair parecidos.
 6. MÍDIA COM PROPÓSITO. Só peça imagem ou logo quando ela PROVA algo. Diga o termo de busca de verdade ("painel solar em telhado residencial", não "imagem legal").
+6b. CADA FRASE PEDE UMA ROTA DE IMAGEM, nesta ordem: número ou citação → nenhuma (a tipografia é a imagem); fala do produto → a tela ou a logo dele; coisa concreta → o vídeo DELA, com a busca no substantivo ("espresso cup", não a frase inteira); ideia abstrata → textura que se move. A imagem entra logo DEPOIS da palavra que a nomeia, nunca antes.
 7. MOVIMENTO. Em cada cena diga em "chaves" o movimento principal — é ele que tira a cara de apresentação parada.
 8. CÂMERA COM PARCIMÔNIA. Movimento de quadro em UMA cena a cada duas ou três ("camera": "nenhuma" nas outras): o que dá ritmo é alternar cena parada e cena que se move. Em cena com foto de fundo, prefira "aproximar" ou "empurrar".
 9. UMA VOZ OU DUAS. Se o pedido fala em dois narradores, duas vozes, diálogo, conversa ou entrevista, escreva como DIÁLOGO: dê nome a cada um em "vozes" (com vozes diferentes) e diga em cada cena quem fala ("falante"). Com uma voz só, deixe "vozes" e "falante" de fora.

package/lib/estudio/falantes.js

@@ -35,22 +35,46 @@ function normalizar(roteiro) {
     return r;
 }
 
+/* A VOZ PELO GÊNERO (11/10, "os personagens falam com vozes diferentes em
+   cada cena"): o par antigo dava a primeira voz livre a quem falasse
+   primeiro — a Ana saía com a voz do Antonio. Agora o NOME decide o gênero e
+   cada falante ganha uma voz do Gemini só dele, do começo ao fim do vídeo.
+   O que a IA disse (roteiro.vozes, personagens.x.genero) manda. */
+const MASCULINAS = ['Charon', 'Puck', 'Orus', 'Fenrir'];
+const FEMININAS = ['Kore', 'Aoede', 'Leda', 'Zephyr'];
+const ROBO = /\b(ia|ai|assistente|robo|robô|bot|claude|gpt|chatgpt|gemini|primo|primocode|copilot|agente|mascote)\b/i;
+const NOMES_FEMININOS = /^(beatriz|raquel|isabel|carmen|ester|ines|inês|alice|ruth|nicole|lis|luz|rose|ingrid|kelly|jennifer|michelle|rachel|karen|manu|gabi|bel|mel|vitoria|vitória|yasmin|jasmin|carol|isis|ísis|iris|íris|liz|mirian|miriam|ellen|helen|lourdes|mercedes|dolores|socorro|aline|daiane|tais|taís|thais|thaís|lilian|vivian|suellen|jaqueline|simone|rosangela|rosângela|irene|lucimar|nair|jussara|joice|joyce|cris|dani|fer|ju|lu|bia|mãe|mae|vó|vo|avó|avo|tia|dona|senhora|professora|menina|garota|mulher|rainha|princesa|moça|moca)$/;
+const NOMES_MASCULINOS_EM_A = /^(luca|lucca|joshua|nicola|andrea|elias|matias|tobias|jonas|lucas|thomas|tomas|tomás|bruna?x|zuma)$/;
+function generoDe(nome, pedido = {}) {
+    const g = String((pedido && pedido.genero) || '').toLowerCase();
+    if (/^(f|fem|feminin|mulher)/.test(g)) return 'f';
+    if (/^(m|masc|homem)/.test(g)) return 'm';
+    const n = String(nome || '').trim().toLowerCase().split(/\s+/)[0];
+    if (ROBO.test(n)) return 'robo';
+    if (NOMES_FEMININOS.test(n)) return 'f';
+    if (NOMES_MASCULINOS_EM_A.test(n)) return 'm';
+    return /a$/.test(n) ? 'f' : 'm';
+}
+
 /**
  * A voz de cada parte, na ordem. Com falante e voz no mapa, a do mapa; com
- * falante FORA do mapa (o modelo deu nome e esqueceu a voz), a próxima do par
- * que ainda não fala — dois falantes nunca saem com a mesma voz por esquecimento;
- * sem falante, a `padrao` (roteiro.voz).
+ * falante FORA do mapa, uma voz do Gemini do gênero do nome que ainda não
+ * fala neste vídeo; sem falante, a `padrao` (roteiro.voz).
  */
 function vozesDasPartes(partes, roteiro = {}, padrao = '') {
     const mapa = { ...((roteiro && roteiro.vozes) || {}) };
     const ocupadas = new Set(Object.values(mapa).map((v) => String(v).toLowerCase()));
     if (padrao) ocupadas.add(String(padrao).toLowerCase());
+    const pedidos = (roteiro && roteiro.personagens) || {};
+    const livre = (lista, k) => lista.find((v) => !ocupadas.has(v.toLowerCase())) || lista[k % lista.length];
     return (partes || []).map((pt) => {
         const f = nomeFalante(pt && pt.falante);
         if (!f) return padrao || '';
         if (!mapa[f]) {
-            mapa[f] = PAR.find((v) => !ocupadas.has(v)) || PAR[Object.keys(mapa).length % PAR.length];
-            ocupadas.add(mapa[f]);
+            const g = generoDe(f, pedidos[f] || pedidos[Object.keys(pedidos).find((k) => k.toLowerCase() === f)] || {});
+            // O mascote tem a voz mais leve das masculinas (Puck), se estiver livre.
+            mapa[f] = g === 'f' ? livre(FEMININAS, Object.keys(mapa).length) : g === 'robo' && !ocupadas.has('puck') ? 'Puck' : livre(MASCULINAS, Object.keys(mapa).length);
+            ocupadas.add(mapa[f].toLowerCase());
         }
         return mapa[f];
     });
@@ -94,4 +118,4 @@ async function narrarPorFalante(lista, mp3, { narrarUm, juntar }) {
     return { ok: true, voz: [...new Set(feitos.map((x) => x.v.voz).filter(Boolean))].join(' + '), segundos: Math.round(antes * 1000) / 1000, partes, falantes: grupos.length };
 }
 
-module.exports = { normalizar, vozesDasPartes, narrarPorFalante, PAR };
+module.exports = { generoDe, MASCULINAS, FEMININAS, normalizar, vozesDasPartes, narrarPorFalante, PAR };

package/lib/estudio/hibrido.js

@@ -21,6 +21,8 @@
  *   traduzir(roteiro)      qualquer roteiro (vox, motion, composição) vira os
  *                          tipos do cinema; o que o cinema não usa (a fonte, o
  *                          destaque) fica guardado por parte.
+ *   rotaDaParte(parte, …)  qual imagem a frase pede (4 rotas) e em que palavra
+ *                          o corte se ancora (b-roll-finder, Arthur 17/09).
  *   termosDeBusca(roteiro) o que procurar de b-roll para cada parte.
  *   enfeitar(plano, …)     o kit por cima do plano que o cinema montou.
  */
@@ -36,6 +38,65 @@ const limpo = (x) => String(x || '').replace(/\s+/g, ' ').trim();
 const BUSCA_PADRAO = ['technology abstract light', 'people working on laptop', 'hands typing keyboard close up',
     'data center servers', 'city night timelapse', 'team meeting office', 'developer code screen', 'futuristic digital network'];
 
+/* AS 4 ROTAS DO B-ROLL (do b-roll-finder): a frase diz qual imagem pede, e
+   a primeira regra que casa decide. O roteiro manda: `rota` e `busca` na parte.
+     tipografia  número, gráfico, citação      → sem imagem: o texto é a imagem
+     produto     a frase fala da marca/produto → a tela/foto da marca
+     literal     uma coisa concreta ("café")   → o vídeo de banco DELA
+     abstrato    ideia que teria de ser desenhada → textura que se move
+   O termo sai da PALAVRA-ÂNCORA, não da frase inteira; e o clipe troca 0,2 s
+   DEPOIS dela — "atrasado parece intenção, adiantado parece erro". */
+const ROTAS = ['tipografia', 'produto', 'literal', 'abstrato'];
+const ATRASO_ANCORA = require('./edicao.js').DEPOIS_DA_PALAVRA;
+const PRODUTO = /^(app|aplicativ|ferrament|painel|dashboard|plataform|site|terminal|cli|sistema|interface|software|agente)/;
+/* As COISAS que se filmam: substantivo concreto → o termo do banco, em inglês.
+   O ícone da edição (edicao.iconeDe) casa verbo também ("começa" → foguete),
+   bom para emoji, ruim para b-roll literal; aqui só entra o que tem cara. */
+const COISAS = [
+    [['cafe'], 'coffee cup morning'], [['cachorro', 'cao'], 'dog'], [['gato'], 'cat'], [['casa', 'lar'], 'modern house'],
+    [['carro'], 'car driving road'], [['cidade', 'rua'], 'city street people'], [['mar', 'praia', 'oceano'], 'ocean waves'],
+    [['escritorio', 'reuniao'], 'team meeting office'], [['mao', 'maos'], 'hands close up'], [['teclado', 'digit'], 'hands typing keyboard close up'],
+    [['computador', 'notebook', 'laptop'], 'laptop on desk'], [['codigo', 'programa'], 'developer code screen'], [['celular', 'telefone'], 'smartphone in hand'],
+    [['livro', 'aula', 'escola'], 'library books'], [['musica'], 'music concert'], [['pessoa', 'equipe', 'cliente', 'gente'], 'people working together'],
+    [['servidor', 'nuvem'], 'data center servers'], [['dinheiro'], 'money cash'], [['relogio'], 'clock ticking'],
+];
+const coisaDe = (limpo) => { for (const [raizes, termo] of COISAS) if (raizes.some((r) => (r.length <= 3 ? limpo === r : limpo.startsWith(r)))) return termo; return null; };
+const ABSTRATO = ['abstract light texture', 'ink in water slow motion', 'bokeh lights dark background', 'smoke texture dark'];
+
+/** A rota e a âncora de uma parte. `palavras`: [{texto, de, ate}] da voz (ou só o texto). */
+function rotaDaParte(parte, palavras, { marca = null, i = 0 } = {}) {
+    const p = parte || {};
+    const ed = require('./edicao.js');
+    const ws = (palavras && palavras.length ? palavras : String(p.fala || p.texto || p.titulo || '').split(/\s+/).filter(Boolean).map((texto) => ({ texto })));
+    const limpa = (x) => String(x || '').normalize('NFD').replace(/[\u0300-\u036f]/g, '').toLowerCase().replace(/[^a-z0-9]/g, '');
+    const achar = (alvo) => { const a = limpa(String(alvo || '').split(/\s+/)[0]); return a ? ws.find((w) => limpa(w.texto) === a) || null : null; };
+    // A palavra que carrega a frase: a mais longa que não é vazia ("confiança", não "um").
+    const forte = () => ws.reduce((f, w) => (ed.peso(w.texto) && limpa(w.texto).length > (f ? limpa(f.texto).length : 0) ? w : f), null);
+    const tipo = p.tipoOriginal || p.tipo || '';
+    let r;
+    if (ROTAS.includes(p.rota)) r = { rota: p.rota, palavra: null };
+    else if (['numero', 'grafico', 'citacao', 'numeros'].includes(tipo)) r = { rota: 'tipografia', palavra: null };
+    else {
+        const e = ed.rotaDeApoio(ws, { marca });
+        const prod = ws.find((w) => ed.peso(w.texto) && PRODUTO.test(limpa(w.texto)));
+        const coisa = ws.find((w) => ed.peso(w.texto) && coisaDe(limpa(w.texto)));
+        if (e.rota === 'marca' || prod) r = { rota: 'produto', palavra: e.rota === 'marca' ? e.palavra : prod, termo: 'software interface on laptop screen' };
+        else if (e.rota === 'numero') r = { rota: 'tipografia', palavra: e.palavra };
+        else if (coisa) r = { rota: 'literal', palavra: coisa, termo: coisaDe(limpa(coisa.texto)) };
+        else r = { rota: p.busca ? 'literal' : 'abstrato', palavra: forte(), termo: ABSTRATO[i % ABSTRATO.length] };
+    }
+    // A âncora: a do roteiro, a palavra-tese, ou a que a regra achou.
+    r.palavra = achar(p.ancora) || r.palavra || achar(p.destaque) || forte();
+    if (r.rota === 'tipografia') r.termo = null;
+    else if (p.busca) r.termo = String(p.busca);
+    return r;
+}
+
+/** Quando o clipe troca, no tempo da voz: 0,2 s depois da âncora. null sem tempo. */
+function tempoDaAncora(palavra) {
+    return palavra && Number.isFinite(palavra.de) ? r2(palavra.de + ATRASO_ANCORA) : null;
+}
+
 /** O roteiro de qualquer estilo → o roteiro do cinema. Devolve {roteiro, extras}. */
 function traduzir(roteiro) {
     const partes = (roteiro && roteiro.partes) || [];
@@ -71,12 +132,16 @@ function traduzir(roteiro) {
         else if (tipo === 'cta' || tipo === 'logo' || tipo === 'fim') q = { tipo: 'final', linhas: [p.titulo || p.texto, p.link].filter(Boolean).map(limpo), ...base };
         else q = { tipo: 'montagem', linhas: [p.titulo || p.texto || p.fala].filter(Boolean).map(limpo), ...base };
         saida.push(q);
-        extras.push({ tipoOriginal: tipo, fonte: tipo === 'abertura' && p.sub ? p.sub : (p.fonte || (tipo === 'citacao' ? p.autor : '')), autor: p.autor || '', busca: p.busca || '' });
+        extras.push({ tipoOriginal: tipo, fonte: tipo === 'abertura' && p.sub ? p.sub : (p.fonte || (tipo === 'citacao' ? p.autor : '')), autor: p.autor || '', busca: p.busca || '',
+            ...(p.rota ? { rota: p.rota } : {}), ...(p.ancora ? { ancora: p.ancora } : {}) });
     });
     return { roteiro: { ...roteiro, partes: saida, estilo: 'hibrido' }, extras };
 }
 
-/** O que procurar de b-roll para cada parte: a busca dela, a do roteiro, ou o padrão. */
+/* A parte com o que o roteiro original disse dela (o tipo, a busca, a rota). */
+const comExtras = (p, ex) => ({ ...p, ...(ex ? { tipoOriginal: ex.tipoOriginal, busca: ex.busca || p.busca, rota: ex.rota || p.rota, ancora: ex.ancora || p.ancora } : {}) });
+
+/** O que procurar de b-roll para cada parte: o termo da rota dela, a busca do roteiro, ou o padrão. */
 function termosDeBusca(roteiro, extras = []) {
     const global = [].concat(roteiro.busca || []).filter(Boolean);
     // Escopo fechado: só os termos da pessoa, nunca o padrão genérico.
@@ -84,11 +149,20 @@ function termosDeBusca(roteiro, extras = []) {
     const lista = global.length ? global : fechado ? [] : BUSCA_PADRAO;
     const termos = new Set();
     (roteiro.partes || []).forEach((p, i) => {
-        const b = (extras[i] && extras[i].busca) || p.busca;
-        if (b) termos.add(String(b));
+        const q = comExtras(p, extras[i]);
+        const r = rotaDaParte(q, null, { marca: roteiro.marca && roteiro.marca.nome, i });
+        /* Escopo fechado: só a busca que o roteiro deu à parte. O termo da rota sai
+           do dicionário (textura, tela de app, e o literal: "cachorro" → "dog") e
+           furava o escopo da pessoa (revisão do #99). */
+        if (r.termo && (!fechado || q.busca)) termos.add(r.termo);
     });
-    for (const t of lista) termos.add(t);
-    return [...termos].slice(0, 8);
+    /* O corte em 8 guarda lugar para a busca global do roteiro (no fechado, é o
+       escopo da pessoa): as frases vinham antes e a empurravam para fora
+       (revisão do #99). O padrão genérico é só enchimento, esse pode cair. */
+    const fixos = global.slice(0, 8);
+    const frases = [...termos].filter((t) => !fixos.includes(t)).slice(0, 8 - fixos.length);
+    const resto = global.length ? [] : lista.filter((t) => !termos.has(t));
+    return [...frases, ...fixos, ...resto].slice(0, 8);
 }
 
 /* A câmera de cada cena do cinema: empurra e desliza, alternando o lado. A
@@ -109,7 +183,7 @@ function camera(d, i, deitado, forte) {
 /* SEM CARA DE IA (05/10): o HUD (cantos, timecode, fps, rótulos nas bordas)
    e as partículas eram exatamente a lista do "ruim" que o Joel juntou. Agora
    só entram quando o roteiro pede: roteiro.hud === true, roteiro.particulas === true. */
-function enfeitar(plano, { extras = [], partes = [], marca = {}, largura, altura, hud = false, particulas = false } = {}) {
+function enfeitar(plano, { extras = [], partes = [], marca = {}, largura, altura, hud = false, particulas = false, tempos = null, fortes = {}, fotos = [] } = {}) {
     if (!plano || !Array.isArray(plano.cenas)) return plano;
     const W = largura || (plano.formato && plano.formato.largura) || 1920;
     const H = altura || (plano.formato && plano.formato.altura) || 1080;
@@ -126,6 +200,7 @@ function enfeitar(plano, { extras = [], partes = [], marca = {}, largura, altura
         const n = p.tipo === 'depoimento' ? Math.max(1, (p.clipes || []).length) : 1;
         for (let q = 0; q < n; q++) parteDaCena.push(i);
     });
+    if (tempos) ancorar(plano, { extras, partes, marca, tempos, fortes, fotos, parteDaCena });
     plano.cenas.forEach((cena, c) => {
         const iParte = parteDaCena[c] != null ? parteDaCena[c] : c;
         const ex = extras[iParte] || {};
@@ -166,4 +241,65 @@ function enfeitar(plano, { extras = [], partes = [], marca = {}, largura, altura
     return plano;
 }
 
-module.exports = { traduzir, termosDeBusca, enfeitar, BUSCA_PADRAO };
+/* O B-ROLL NA PALAVRA: a cena de montagem (ou de frase) troca para o clipe da
+   rota dela 0,2 s depois da âncora — antes, segue a montagem do cinema. Rota
+   tipografia tira as fotos: o número já é a imagem. O tempo da cena é o do
+   cinema: a voz entra 0,2 s depois do corte (off). */
+function ancorar(plano, { extras, partes, marca, tempos, fortes, fotos, parteDaCena }) {
+    const cinema = require('./cinema.js');
+    const off = 0.2;
+    let narrI = 0;
+    const tempoDe = partes.map((p, i) => (p.tipo !== 'depoimento' && cinema.falaDe(p) !== '' && !(p.falaForte && fortes[i]) ? tempos[narrI++] || null : null));
+    const ehFoto = (e) => (e.tipo === 'imagem' || e.tipo === 'video' || (e.tipo === 'forma' && e.fundo && e.fundo.tipo === 'gradiente')) && e.largura === '100%';
+    const plan = [], vez = [];
+    plano.cenas.forEach((cena, c) => {
+        const i = parteDaCena[c] != null ? parteDaCena[c] : c;
+        const p = partes[i], tp = tempoDe[i];
+        if (!p || !['montagem', 'frase', 'numeros'].includes(p.tipo) || (parteDaCena.indexOf(i) !== c)) return;
+        const r = rotaDaParte(comExtras(p, extras[i]), tp && tp.palavras, { marca: marca.nome, i });
+        plan.push({ parte: i, rota: r.rota, ancora: r.palavra ? r.palavra.texto : null, termo: r.termo || null });
+        /* Produto: a tela DA MARCA (o print do acervo) antes do vídeo de banco. Antes
+           a regra perguntava se o alt não era termo de busca, mas o conjunto tinha o
+           alt de todas as fotos: nunca casava, e o painel ficava de fora (revisão do #99). */
+        const f = r.rota === 'tipografia' ? null : r.rota === 'produto' ? fotos.find((x) => x.cat === 'tela' && !x.banco) || fotos.find((x) => x.alt === r.termo)
+            : fotos.find((x) => x.alt === r.termo && x.tipo === 'video') || fotos.find((x) => x.alt === r.termo);
+        const ta = tp ? tempoDaAncora(r.palavra) : null;
+        const de = ta == null ? null : r2(off + ta - tp.de);
+        vez.push({ cena, r, f: f && de != null && (cena.duracao || 2) - de >= 0.8 ? f : null, de });   // sem 0,8 s para ver, fica a montagem
+    });
+    /* O clipe de uma frase não aparece ANTES da palavra dela (nem na montagem
+       de outra cena): quem vê o café antes de ouvir "café" sente o erro. */
+    const reservado = new Set(vez.filter((x) => x.f).map((x) => x.f.src));
+    const livres = fotos.filter((x) => !reservado.has(x.src));
+    let n = 0;
+    for (const { cena, r, f, de } of vez) {
+        let els = cena.elementos || [];
+        if (r.rota === 'tipografia') { cena.elementos = els.filter((e) => !ehFoto(e)); continue; }
+        for (const e of els) if ((e.tipo === 'imagem' || e.tipo === 'video') && reservado.has(e.src) && livres.length) {
+            const g = livres[n++ % livres.length];
+            Object.assign(e, { tipo: g.tipo === 'video' ? 'video' : 'imagem', src: g.src, ...(g.tipo === 'video' ? { volume: 0 } : {}) });
+        }
+        if (!f) continue;
+        const d = cena.duracao || 2;
+        els = els.filter((e) => !(ehFoto(e) && e.de >= de));
+        for (const e of els) if (ehFoto(e) && (e.ate == null || e.ate > de)) e.ate = de;
+        // Um resto de foto de um instante vira um piscar: a foto de antes cobre o buraco.
+        for (const e of els.filter((x) => ehFoto(x) && x.ate - (x.de || 0) < 0.25)) {
+            for (const x of els) if (x !== e && ehFoto(x) && x.ate === e.de && x.tipo === e.tipo) x.ate = e.ate;
+            els = els.filter((x) => x !== e);
+        }
+        const v = f.tipo === 'video';
+        const vida = r2(d - de);
+        const novo = [{ tipo: v ? 'video' : 'imagem', src: f.src, ...(v ? { volume: 0 } : {}), x: 0, y: 0, largura: '100%', altura: '100%', ajuste: 'cover', de, ate: r2(d), broll: r.rota,
+            anima: { escala: [{ t: 0, v: 1.12 }, { t: vida, v: 1.02, e: 'linear' }] } },
+        { tipo: 'forma', forma: 'retangulo', x: 0, y: 0, largura: '100%', altura: '100%', de, ate: r2(d),
+            fundo: { tipo: 'gradiente', cores: ['rgba(7,7,10,0.35)', 'rgba(7,7,10,0.5)', 'rgba(7,7,10,0.75)'], angulo: 180 } }];
+        const k = els.findIndex((e) => e.tipo === 'texto' || e.tipo === 'kit');
+        els.splice(k < 0 ? els.length : k, 0, ...novo);
+        cena.elementos = els;
+    }
+    plano.broll = plan;
+    return plan;
+}
+
+module.exports = { traduzir, termosDeBusca, enfeitar, rotaDaParte, tempoDaAncora, ancorar, ROTAS, ATRASO_ANCORA, BUSCA_PADRAO };