primocode 10.4.4 → 10.5.0

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,8 +93,8 @@ 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) | '
-                + '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). '
+                + '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 3D RENDERIZADO da biblioteca ("fluent3d:hot beverage", "fluent3d:money bag"; procure com estudio_midia acao:icones3d — é o que mais parece 3D de verdade), uma animação pronta ("noto:1f525"; acao:animacoes), um ícone do Iconify do objeto que a fala cita ("mdi:bread-slice", "mdi:qrcode"; 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 (a ANIMAÇÃO 3D de verdade, o vídeo GRAVADO em 3D, no visual de blocos/voxel de render de cinema: bonecos de blocos e o mascote laranja (quem é IA) num set de ladrilhos com uma parede de telas, luz roxa de recorte, o fundo desfocado de lente e a legenda branca no meio — cada parte é UMA fala {falante, texto, emocao?, destaque?}, sem tipo; a boca segue a voz, gestos, e a câmera corta entre aberto, ombro e close de baixo; é a escolha para animação 3D, personagem, boneco, avatar, mascote, podcast, entrevista ou alguém FALANDO em 3D — um narrador só também serve (sem falante). As telas do fundo mostram o ASSUNTO: paineis:["título curto", …] (até 12) — vazio, saem dos destaques e das palavras fortes. 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 telas (o roxo da referência, padrão)|neon|oceano|terra; cor do mascote: personagens:{"claude":{cor:"#d97757"}}; visual:"liso" só se pedirem o boneco liso antigo). '
                 + '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. '
                 + 'cena (opcional): o número de UMA cena para trocar só ela, sem reescrever o resto. '
@@ -109,7 +109,11 @@ const GRUPOS = [
                 + 'o render empurra para dentro, encolhe o texto largo e afasta o colado; enfeite de fundo marque decorativo: true.' },
 
             { tool: 'estudio_midia', escreve: true, faz: 'procura e baixa ícone, imagem, música e efeito sonoro da internet, e lista as fontes',
-              args: 'acao: imagem | icones | som | trilha | efeito | fontes | print | elementos | elemento | recortar. termo. id (para baixar). '
+              args: 'acao: biblioteca | imagem | icones | icones3d | animacoes | som | trilha | efeito | fontes | print | elementos | elemento | recortar. termo. id (para baixar). '
+                + 'biblioteca: o cardápio INTEIRO do que existe (ícone 2D, ícone 3D, animação pronta, efeito sonoro, música, fonte, personagem 3D) — olhe antes de escolher. '
+                + 'icones3d termo:"coffee": os 1.500+ ícones 3D renderizados do Fluent Emoji (MIT); com item:"fluent3d:<nome>" e o id do projeto, baixa e devolve o elemento {tipo:"imagem"} pronto. '
+                + 'animacoes termo:"fire": as 881 animações prontas do Noto (Lottie, vetor; CC BY 4.0, ponha o crédito); com item:"noto:<código>", baixa e devolve o elemento {tipo:"kit", peca:"animacao", src, loop} pronto. '
+                + 'O termo vai em inglês (as palavras comuns em português também casam). Escolha pelo que a fala DIZ: numa conversa sobre café, a xícara; nunca enfeite sem relação. '
                 + 'print: url — tira o print REAL do site e devolve o src e um elemento {tipo:"kit", peca:"printsite"} pronto '
                 + '(o site de verdade numa janela 3D que rola a página; celular: true para a tela do celular; inteira: false só a primeira dobra). '
                 + 'Use SE o pedido trouxer um site e o vídeo for SOBRE ele (lançamento, tour, case); vídeo que só cita a marca não precisa. '

package/lib/conta.js

@@ -54,6 +54,12 @@ const FIREBASE_AUTH = process.env.PRIMOCODE_FIREBASE_AUTH_URL || 'https://identi
 // (`PLANOS_COM_PRO`), e quem decide de verdade é ele: isto aqui só evita uma
 // ida à rede para mostrar o selo na abertura.
 const PLANOS_PRO = ['premium', 'super'];
+/* ASSINANTE É QUEM NÃO ESTÁ NO GRÁTIS (11/10). A conta do Joel veio do Conecta
+   como "empresarial" — um plano pago que esta lista não conhecia — e ele caiu
+   no limite de quem não paga, com a mensagem "assine o Premium". O Conecta cria
+   plano novo sem avisar o PrimoCode; o que não muda é o nome do grátis. */
+const PLANOS_GRATIS = ['free', 'gratis', 'grátis', 'gratuito', 'basico', 'básico', ''];
+const ehPago = (plano) => !PLANOS_GRATIS.includes(String(plano == null ? '' : plano).trim().toLowerCase());
 
 function pedir(rota, corpo, timeout = 30000, { token, base = CONECTA } = {}) {
     return new Promise((resolve, reject) => {
@@ -116,7 +122,7 @@ function atual() {
     const c = ler();
     if (!c || !c.token) return null;
     return { uid: c.uid, plano: c.plano || 'free', email: c.email || null,
-        pro: PLANOS_PRO.includes(c.plano), desde: c.desde };
+        pro: ehPago(c.plano), desde: c.desde };
 }
 
 // ── entrar ───────────────────────────────────────────────────────────────
@@ -189,7 +195,7 @@ async function entrar({ email, senha } = {}) {
             token: r.token, uid: r.uid, plano: r.plano || 'free', email,
             desde: new Date().toISOString(), servidor: CONECTA,
         });
-        return { ok: true, uid: r.uid, plano: r.plano, pro: PLANOS_PRO.includes(r.plano) };
+        return { ok: true, uid: r.uid, plano: r.plano, pro: ehPago(r.plano) };
     } catch (e) {
         return { ok: false, error: `não consegui concluir o login: ${e.message}` };
     }
@@ -234,4 +240,4 @@ function versao() {
     try { return require('../package.json').version; } catch { return '?'; }
 }
 
-module.exports = { entrar, sair, atual, sessao, dispositivos, erroDoFirebase, ARQUIVO, CONECTA, PLANOS_PRO };
+module.exports = { entrar, sair, atual, sessao, dispositivos, erroDoFirebase, ARQUIVO, CONECTA, PLANOS_PRO, PLANOS_GRATIS, ehPago };

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/colecao.js

@@ -0,0 +1,185 @@
+/**
+ * colecao.js — a biblioteca completa do Estúdio: o que existe para pôr num vídeo.
+ *
+ *   "tem que ter uma biblioteca completa de ícones, pra ele poder pegar os
+ *    ícones 3D, 2D, animações, também efeitos sonoros e músicas, também
+ *    fontes de texto" (Joel, 11/10)
+ *
+ * O 2D (Iconify), a imagem e o som (Openverse), a trilha e as fontes já
+ * existiam (assets.js, biblioteca.js, sons-leves.js). Faltavam duas coisas, e
+ * as duas entram aqui:
+ *
+ *   · ÍCONE 3D — o Fluent Emoji 3D da Microsoft (licença MIT): mais de 1.500 objetos
+ *     renderizados em 3D, de "coffee" a "rocket". O índice mora no pacote
+ *     (dados/fluent-3d.json), então PROCURAR não usa rede; só o PNG escolhido
+ *     desce, do CDN do jsDelivr.
+ *   · ANIMAÇÃO PRONTA — o Noto Emoji animado do Google (CC BY 4.0): 881
+ *     animações em Lottie (vetor, nítido em qualquer tamanho), tocadas quadro
+ *     a quadro pela peça kit/animacao.jsx. Índice também no pacote.
+ *
+ * E `cardapio()` junta TUDO numa resposta só, para a IA saber o que existe
+ * antes de escolher — a escolha é dela (nada entra no vídeo sozinho).
+ *
+ * A licença anda junto: cada download grava o .json ao lado (fonte, licença,
+ * crédito), como no acervo.js.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const DADOS = path.join(__dirname, 'dados');
+const CDN_FLUENT = 'https://cdn.jsdelivr.net/gh/microsoft/fluentui-emoji@main/assets/';
+const LOTTIE_NOTO = (cp) => `https://fonts.gstatic.com/s/e/notoemoji/latest/${cp}/lottie.json`;
+const GIF_NOTO = (cp) => `https://fonts.gstatic.com/s/e/notoemoji/latest/${cp}/512.gif`;
+
+let _fluent = null, _noto = null;
+const fluent = () => (_fluent = _fluent || JSON.parse(fs.readFileSync(path.join(DADOS, 'fluent-3d.json'), 'utf8')));
+const noto = () => (_noto = _noto || JSON.parse(fs.readFileSync(path.join(DADOS, 'noto-animado.json'), 'utf8')));
+
+/* As duas bibliotecas são em inglês. A IA costuma mandar o termo em inglês,
+   mas a pessoa fala português: as palavras mais comuns de vídeo têm par. */
+const PT_EN = {
+    cafe: 'coffee', 'café': 'coffee', pao: 'bread', 'pão': 'bread', padaria: 'bread', dinheiro: 'money', grana: 'money', moeda: 'coin',
+    foguete: 'rocket', coracao: 'heart', 'coração': 'heart', fogo: 'fire', ideia: 'light bulb', lampada: 'light bulb', 'lâmpada': 'light bulb',
+    estrela: 'star', relogio: 'clock', 'relógio': 'clock', tempo: 'hourglass', celular: 'mobile phone', telefone: 'telephone',
+    computador: 'laptop', notebook: 'laptop', robo: 'robot', 'robô': 'robot', livro: 'books', escola: 'school', carro: 'car',
+    casa: 'house', comida: 'food', pizza: 'pizza', musica: 'musical note', 'música': 'musical note', foto: 'camera', camera: 'camera',
+    'câmera': 'camera', mundo: 'globe', terra: 'globe', chave: 'key', cadeado: 'locked', seguranca: 'shield', 'segurança': 'shield',
+    escudo: 'shield', grafico: 'chart', 'gráfico': 'chart', alvo: 'direct hit', trofeu: 'trophy', 'troféu': 'trophy', medalha: 'medal',
+    presente: 'gift', festa: 'party', sol: 'sun', chuva: 'rain', raio: 'high voltage', energia: 'high voltage', bateria: 'battery',
+    email: 'envelope', mensagem: 'speech balloon', conversa: 'speech balloon', pergunta: 'question', ok: 'check mark', certo: 'check mark',
+    errado: 'cross mark', aviso: 'warning', dinossauro: 'dinosaur', gato: 'cat', cachorro: 'dog', planta: 'seedling', arvore: 'tree',
+    'árvore': 'tree', sorriso: 'smile', feliz: 'smile', triste: 'sad', bravo: 'angry', amor: 'heart', rindo: 'joy', pensando: 'thinking',
+    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',
+    engrenagem: 'gear', ciencia: 'test tube', 'ciência': 'test tube', saude: 'hospital', 'saúde': 'hospital', remedio: 'pill', 'remédio': 'pill',
+};
+
+const norm = (t) => String(t || '').toLowerCase().normalize('NFD').replace(/[̀-ͯ]/g, '').replace(/[^a-z0-9 ]+/g, ' ').trim();
+
+function termos(termo) {
+    const cru = String(termo || '').toLowerCase().trim();
+    const out = new Set([norm(cru)]);
+    for (const w of cru.split(/\s+/)) if (PT_EN[w]) out.add(PT_EN[w]);
+    if (PT_EN[cru]) out.add(PT_EN[cru]);
+    return [...out].filter(Boolean);
+}
+
+// A nota de um nome contra a busca: palavra inteira vale mais que pedaço.
+function nota(nome, ts) {
+    const n = ' ' + norm(nome) + ' ';
+    let melhor = 0;
+    for (const t of ts) {
+        if (n.trim() === t) melhor = Math.max(melhor, 100);
+        else if (n.includes(' ' + t + ' ')) melhor = Math.max(melhor, 60 - n.length * 0.1);
+        else {
+            const ws = t.split(' ').filter((w) => w.length > 2);
+            const achou = ws.filter((w) => n.includes(' ' + w)).length;
+            if (achou) melhor = Math.max(melhor, (achou / ws.length) * 40 - n.length * 0.1);
+        }
+    }
+    return melhor;
+}
+
+/** Os ícones 3D (Fluent) que casam com o termo. */
+function procurarIcones3d(termo, { quantas = 10 } = {}) {
+    const ts = termos(termo);
+    if (!ts.length) return { ok: false, error: 'diga o que procurar (termo), de preferência em inglês: "coffee", "rocket".' };
+    // O nome manda; as palavras-chave do metadata (coffee em "hot beverage") e o grupo ajudam.
+    const achados = fluent().map(([nome, p, kw = '', grupo = '']) => ({ nome, p, grupo, n: Math.max(nota(nome, ts), nota(kw, ts) * 0.8, nota(grupo, ts) * 0.3) })).filter((x) => x.n > 0)
+        .sort((a, b) => b.n - a.n).slice(0, quantas);
+    return {
+        ok: true, termo, total: achados.length,
+        icones: achados.map((x) => ({ id: 'fluent3d:' + x.nome, nome: x.nome, grupo: x.grupo, url: CDN_FLUENT + encodeURI(x.p), licenca: 'MIT', fonte: 'Microsoft Fluent Emoji 3D' })),
+        comoUsar: 'baixe com acao:icones3d id:"fluent3d:<nome>" (precisa do id do projeto) — volta um elemento {tipo:"imagem"} pronto, PNG transparente de 256 px em 3D.',
+    };
+}
+
+/** As animações prontas (Noto animado, Lottie) que casam com o termo. */
+function procurarAnimacoes(termo, { quantas = 10 } = {}) {
+    const ts = termos(termo);
+    if (!ts.length) return { ok: false, error: 'diga o que procurar (termo): "fire", "party", "thinking"…' };
+    const achados = noto().map(([cp, tags, cat]) => ({ cp, tags, cat, n: Math.max(nota(tags, ts), nota(cat, ts) * 0.5) }))
+        .filter((x) => x.n > 0).sort((a, b) => b.n - a.n).slice(0, quantas);
+    return {
+        ok: true, termo, total: achados.length,
+        animacoes: achados.map((x) => ({ id: 'noto:' + x.cp, nome: x.tags, categoria: x.cat, lottie: LOTTIE_NOTO(x.cp), gif: GIF_NOTO(x.cp),
+            licenca: 'CC BY 4.0', creditos: 'Noto Emoji Animation, Google (CC BY 4.0)' })),
+        comoUsar: 'baixe com acao:animacoes id:"noto:<código>" (precisa do id do projeto) — volta um elemento {tipo:"kit", peca:"animacao"} pronto, que toca quadro a quadro.',
+    };
+}
+
+async function baixarUrl(url, destino) {
+    const r = await fetch(url, { headers: { 'user-agent': 'primocode-estudio' } });
+    if (!r.ok) return { ok: false, error: `${r.status} ao baixar ${url}` };
+    const buf = Buffer.from(await r.arrayBuffer());
+    fs.mkdirSync(path.dirname(destino), { recursive: true });
+    fs.writeFileSync(destino, buf);
+    return { ok: true, bytes: buf.length };
+}
+
+/**
+ * Baixa um item da biblioteca para a pasta do projeto e devolve o elemento pronto.
+ * @param {string} id  "fluent3d:<nome>" ou "noto:<código>"
+ */
+async function baixar(id, { pasta, largura = 1920, altura = 1080 } = {}) {
+    if (!pasta) return { ok: false, error: 'para baixar é preciso dizer em qual projeto (id).' };
+    const [tipo, chave0] = String(id || '').split(/:(.+)/);
+    const chave = String(chave0 || '').trim().toLowerCase();
+    const lado = Math.round(Math.min(largura, altura) * 0.32);
+    if (tipo === 'fluent3d') {
+        const item = fluent().find(([nome]) => nome === chave);
+        if (!item) return { ok: false, error: `não há o ícone 3D "${chave}" — procure com acao:icones3d termo:"…".` };
+        const arquivo = chave.replace(/[^a-z0-9]+/g, '-') + '.png';
+        const destino = path.join(pasta, 'midia', 'icones3d', arquivo);
+        if (!fs.existsSync(destino)) {
+            const r = await baixarUrl(CDN_FLUENT + encodeURI(item[1]), destino);
+            if (!r.ok) return r;
+            fs.writeFileSync(destino.replace(/\.png$/, '.json'), JSON.stringify({ fonte: 'Microsoft Fluent Emoji 3D', licenca: 'MIT', url: CDN_FLUENT + encodeURI(item[1]) }, null, 2));
+        }
+        const src = path.relative(pasta, destino).replace(/\\/g, '/');
+        return { ok: true, src, licenca: 'MIT',
+            elemento: { tipo: 'imagem', src, x: Math.round((largura - lado) / 2), y: Math.round((altura - lado) / 2), largura: lado, altura: lado, ajuste: 'contain' } };
+    }
+    if (tipo === 'noto') {
+        const item = noto().find(([cp]) => cp === chave);
+        if (!item) return { ok: false, error: `não há a animação "${chave}" — procure com acao:animacoes termo:"…".` };
+        const destino = path.join(pasta, 'midia', 'animacoes', chave + '.json');
+        if (!fs.existsSync(destino)) {
+            const r = await baixarUrl(LOTTIE_NOTO(chave), destino);
+            if (!r.ok) return r;
+            fs.writeFileSync(destino.replace(/\.json$/, '.licenca.json'), JSON.stringify({ fonte: 'Noto Emoji Animation (Google)', licenca: 'CC BY 4.0', url: LOTTIE_NOTO(chave) }, null, 2));
+        }
+        const src = path.relative(pasta, destino).replace(/\\/g, '/');
+        return { ok: true, src, licenca: 'CC BY 4.0', creditos: 'Noto Emoji Animation, Google (CC BY 4.0)',
+            elemento: { tipo: 'kit', peca: 'animacao', src, loop: true, x: Math.round((largura - lado) / 2), y: Math.round((altura - lado) / 2), largura: lado, altura: lado } };
+    }
+    return { ok: false, error: 'id da biblioteca é "fluent3d:<nome>" ou "noto:<código>".' };
+}
+
+/**
+ * O CARDÁPIO: tudo o que a biblioteca tem, numa resposta. A IA lê isto e
+ * escolhe pelo assunto do vídeo — a regra da casa é que todo elemento tenha a
+ * ver com o que a fala diz.
+ */
+function cardapio() {
+    let fontes = 0, sons = [];
+    try { fontes = Object.keys(require('./biblioteca.js').FONTES || {}).length; } catch { /* sem a lista */ }
+    try { sons = Object.keys(require('./sons-leves.js').EFEITOS || {}); } catch { /* sem a lista */ }
+    return {
+        ok: true,
+        icones2d: { quantos: '200 mil+ (Iconify: Material, Lucide, Phosphor, marcas…)', acao: 'icones', exemplo: 'termo:"bread"' },
+        icones3d: { quantos: fluent().length, fonte: 'Microsoft Fluent Emoji 3D (MIT)', acao: 'icones3d', exemplo: 'termo:"coffee" → id:"fluent3d:hot beverage"' },
+        animacoes: { quantas: noto().length, fonte: 'Noto Emoji animado do Google, Lottie (CC BY 4.0)', acao: 'animacoes', exemplo: 'termo:"fire" → id:"noto:1f525"' },
+        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' },
+        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 };