primocode 9.8.0-beta.9 → 9.8.0

package/README.md

@@ -1,4 +1,4 @@
-# PrimoCode v9.8.0-beta.9
+# PrimoCode v9.8.0-beta.23
 
 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 v9.8.0-beta.9
+ ▐▛███▜▌   Primo Code v9.8.0-beta.23
 ▝▜█████▛▘  Bem-vindo de volta, Joel
   ▘▘ ▝▝    ~/primocode  · /dir <pasta> muda
 ```

package/lib/act.js

@@ -692,15 +692,19 @@ async function runAct(userPrompt, opts) {
 
                Um modelo não chama tool fora da lista por conta própria. Só
                chamou porque este parágrafo mandou. */
+            /* O caminho do ROTEIRO (lib/estudio/composicao.js). Antes esta
+               ordem mandava chamar o diretor e depois compor "cena a cena,
+               com as primitivas" — o modelo escrevia posição em pixel e o
+               vídeo saía quebrado, além de custar três ou quatro rodadas a
+               mais de modelo (medido em 25/09). */
             messages.push({ role: 'system', content:
-                'ESTE PEDIDO É DE PRODUÇÃO AUDIOVISUAL. Se `planejar_producao` estiver na sua lista de '
-                + `ferramentas, chame-o ANTES de criar qualquer peça (formato "${producao.formato}"): `
-                + 'ele devolve a pauta — arco, narração falada, voz, direção de arte e a mídia a buscar — '
-                + 'e é ela que você produz, cena a cena, compondo com as primitivas. '
-                + 'Se ele NÃO estiver na sua lista, não o chame e não procure equivalente: siga com as '
-                + 'ferramentas que você tem e escreva o roteiro antes das cenas, não dentro do JSON delas. '
-                + 'Nunca chame uma ferramenta que não está na sua lista — a chamada é recusada e a tarefa '
-                + 'se perde.' });
+                `ESTE PEDIDO É DE PRODUÇÃO (formato "${producao.formato === 'apresentacao' ? 'slides' : 'video'}"). Faça em três passos: `
+                + `estudio_projeto acao:"criar" com formato "${producao.formato === 'apresentacao' ? 'slides' : 'video'}" → `
+                + 'estudio_plano com "roteiro" (partes com tipo e fala; o PrimoCode faz layout, voz, ícones, música e sons) → '
+                + 'estudio_render. Se a peça for de uma marca de verdade, estudio_site antes, e use as cores e a logo em roteiro.marca. '
+                + 'NÃO escreva cenas, elementos nem posições à mão. '
+                + 'Se estudio_plano não aceitar "roteiro" (servidor antigo), siga com as ferramentas que você tem. '
+                + 'Nunca chame uma ferramenta que não está na sua lista — a chamada é recusada e a tarefa se perde.' });
         }
     }
 
@@ -1167,7 +1171,10 @@ async function runAct(userPrompt, opts) {
             if (checkpoint.MUDAM_ARQUIVO.has(tc.name)) {
                 try { checkpoint.antesDeMudar(tools.resolveInProject(tc.arguments && tc.arguments.path, pastaAtual), pastaAtual); } catch {}
             }
-            const result = await tools.execute(tc.name, tc.arguments, { projectDir: pastaAtual });
+            /* O servidor, o token e o cliente da API vão junto: a legenda do
+               estudio_video transcreve no servidor, e sem eles a ferramenta
+               respondia "a transcrição precisa do servidor". */
+            const result = await tools.execute(tc.name, tc.arguments, { projectDir: pastaAtual, server, token, api });
             logResult(tc.name, result, profundidade);
             repeticao.executou(jaChamado, tc.name, tc.arguments);
             if (RELEITURA.has(tc.name) && result && result.ok !== false) {

package/lib/api.js

@@ -268,6 +268,13 @@ function getConectores(serverUrl, token) {
     return pedirGet(serverUrl, '/api/conectores', token);
 }
 
+/* Foto e vídeo de apoio do Pexels, pela chave do servidor (ninguém precisa
+   ter uma). tipo: "imagens" | "videos". */
+function getMidia(serverUrl, token, tipo, { q, n, orientacao } = {}) {
+    const qs = new URLSearchParams({ q: q || '', n: String(n || 6), ...(orientacao ? { orientacao } : {}) });
+    return pedirGet(serverUrl, `/api/midia/${tipo}?${qs}`, token);
+}
+
 function getHealth(serverUrl, token) {
     return pedirGet(serverUrl, '/health', token);
 }
@@ -300,4 +307,4 @@ function pedirGet(serverUrl, rota, token) {
     });
 }
 
-module.exports = { request, requestStream, requestAct, requestChat, requestResumo, requestRefino, requestPlano, requestTranscricao, getHealth, getConectores };
+module.exports = { request, requestStream, requestAct, requestChat, requestResumo, requestRefino, requestPlano, requestTranscricao, getHealth, getConectores, getMidia };

package/lib/catalogo.js

@@ -84,7 +84,11 @@ const GRUPOS = [
                 + 'SEMPRE procure antes de criar quando o pedido falar de algo que já existe.' },
 
             { tool: 'estudio_plano', escreve: true, faz: 'escreve ou ajusta o que o vídeo É — cenas, elementos, animação, câmera, áudio',
-              args: 'id. plano: {formato:{largura,altura,fps}, cenas:[…], audio:{…}} — ou cenas direto. '
+              args: 'id. PREFIRA roteiro: {marca:{cores:{fundo,destaque,tinta},fontes:{titulo,texto},logo}, proporcao, '
+                + 'partes:[{tipo, fala, …}]} — o PrimoCode faz o layout, a voz com entonação, os ícones, a música e os sons. '
+                + 'Tipos: abertura{titulo,sub} titulo{titulo,sub} numero{valor,rotulo,sub} lista{titulo,itens} passos{titulo,itens} '
+                + 'contraste{nao,sim} citacao{texto,autor} imagem{busca,titulo,sub} grafico{titulo,barras:[{rotulo,valor}]} cta{titulo,link}. '
+                + 'voz (thalita|antonio|francisca). 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. '
                 + 'motivo (opcional): fica no caderno. voltarPara (opcional): nome de uma versão. '
                 + 'Sem plano nem cenas, LÊ o plano atual. '
@@ -104,7 +108,10 @@ const GRUPOS = [
                 + 'Use os tempos que voltam para a duração das cenas — estimar por número de palavras erra em segundos.' },
 
             { tool: 'estudio_video', escreve: true, faz: 'o que se faz com a gravação do usuário: importar, medir, cortar silêncio, transcrever, recortar a pessoa',
-              args: 'id. acao: importar | medir | silencio | cortar-silencio | quadro | legendas | recortar-pessoa. '
+              args: 'id. acao: editar | importar | medir | silencio | cortar-silencio | quadro | legendas | recortar-pessoa. '
+                + 'editar: FAZ A EDIÇÃO INTEIRA sozinho — corta o silêncio, transcreve palavra por palavra e monta o plano '
+                + '(legenda animada, ícone na hora da palavra, zoom de corte, pop e whoosh). estilo: viral (padrão) | limpo. '
+                + 'Com gravação do usuário, é o PRIMEIRO passo depois de importar; depois só estudio_render. '
                 + 'arquivo: caminho (em "importar", de fora; nas outras, o relativo dentro do projeto). '
                 + 'cortar-silencio: minimoParaCortar (padrão 0.6s), respiro (padrão 0.18s) — os dois existem para o corte não soar robótico. '
                 + 'legendas: devolve os trechos com tempo, para virarem elemento "legenda". '
@@ -119,7 +126,8 @@ const GRUPOS = [
 
             { tool: 'estudio_site', escreve: false, faz: 'lê a identidade visual de uma marca: cores, fontes, logo e o que ela diz de si',
               args: 'url — OU marca: o nome da empresa, quando não há link ("faça um vídeo para a Paris Group"). '
-                + 'id (opcional): anota no caderno do projeto. '
+                + 'id (opcional): anota no caderno do projeto — e com id traz o ACERVO da marca: as fotos e os vídeos '
+                + 'reais do site (que entram sozinhos no vídeo) e os FATOS das páginas (datas, local, números), para o roteiro. '
                 + 'Devolve FATOS medidos, não um roteiro — o roteiro é seu. '
                 + 'Use SEMPRE que o pedido citar uma empresa de verdade: inventar a cor de uma marca que existe '
                 + 'é erro que sai pronto no vídeo entregue. '

package/lib/claude-engine.js

@@ -61,6 +61,28 @@ function argsDoModelo() {
     return MODELO_CLAUDE ? ['--model', MODELO_CLAUDE] : [];
 }
 
+/* O Claude Code ENXUTO, como motor. Sem isto cada passo do agente abria o
+ * Claude Code da pessoa inteiro: hooks, plugins, skills, CLAUDE.md dela e as
+ * ferramentas nativas — 36 mil tokens e ~6 s por chamada, e a resposta
+ * chegava com recado de hook pessoal ("context-sync pendente"). Medido em
+ * 25/09: com estes argumentos, a mesma chamada leva 473 tokens e ~3,5 s. Um
+ * pedido de 100 passos pagava aquilo 100 vezes — é a demora de 20 minutos.
+ *
+ * Nada disto tira o que o motor precisa: o protocolo vai inteiro no prompt
+ * (corpoDoProtocolo), e as ferramentas que valem são as do PrimoCode, não as
+ * do Claude Code. */
+const ARGS_ENXUTOS = [
+    '--setting-sources', 'project',
+    '--strict-mcp-config',
+    '--disable-slash-commands',
+    '--tools', '',
+    '--no-session-persistence',
+    '--system-prompt', 'Você é o motor de decisão do PrimoCode. Siga à risca o protocolo que vem na mensagem e responda só com o bloco pedido.',
+];
+function argsDoMotor() {
+    return [...ARGS_ENXUTOS, ...argsDoModelo()];
+}
+
 /**
  * Acha o ÚLTIMO bloco marcado no texto (pode vir ruído de terminal — prompt
  * ANSI, texto solto — antes e depois) e devolve o JSON de dentro dele.
@@ -567,7 +589,7 @@ async function requestActViaHeadless(payload, onEvent) {
         '-p',
         '--output-format', 'json',
         '--dangerously-skip-permissions',
-        ...argsDoModelo(),
+        ...argsDoMotor(),
     ], { encoding: 'utf-8', timeout: 180000, input: prompt, maxBuffer: 32 * 1024 * 1024,
         env: process.env, ...SEM_APARECER });
     const r = JSON.parse(saida);
@@ -577,7 +599,7 @@ async function requestActViaHeadless(payload, onEvent) {
     const pedirCorrecao = (aviso) => {
         const s = execFileSync('claude', [
             '-p', '--output-format', 'json', '--dangerously-skip-permissions',
-            ...argsDoModelo(),
+            ...argsDoMotor(),
         ], {
             encoding: 'utf-8', timeout: 120000, maxBuffer: 32 * 1024 * 1024,
             env: process.env,
@@ -622,7 +644,7 @@ module.exports = {
     // o que veio torto. Reimplementar aquilo no outro motor seria manter dois
     // protocolos que divergem na primeira correção de um deles.
     linhaDoHistorico, nomesDasTools, promptDoProtocolo, promptDeCorrecao,
-    MODELO_CLAUDE, argsDoModelo,
+    MODELO_CLAUDE, argsDoModelo, argsDoMotor,
     SKILL_DIR, SKILL_PATH, garantirSkill,
     temClaudeCode, temOrca, orcaAlcancavel, escolherCaminho,
     garantirEngine, requestAct, emitirDecisao,

package/lib/estudio/acervo-site.js

@@ -0,0 +1,157 @@
+/**
+ * acervo-site.js — as fotos, os vídeos e os fatos da PRÓPRIA marca, tirados
+ * do site dela.
+ *
+ *   "Eu pedi um vídeo pra Paris Group pra anunciar a imersão: ele poderia
+ *    puxar imagens das imersões, vídeos, fotos, etc. e colocar no decorrer do
+ *    vídeo." · "Os roteiros são nada a ver." (25/09/2026)
+ *
+ * O roteiro saía inventado ("sem data, preço nem local", anotou o próprio
+ * modelo) e as imagens eram de banco. O site da marca tem as duas coisas: a
+ * página da imersão diz "6 a 8 out · Chapecó/SC · 20 cadeiras", e a galeria
+ * tem as fotos da sala. Aqui se lê a página inicial e as páginas internas
+ * que combinam com o pedido, e sai:
+ *
+ *   - fotos: as maiores que o site oferece (o maior "w" do srcset), sem logo,
+ *     ícone, SVG nem miniatura;
+ *   - vídeos: os .mp4 que a página toca (depoimento, bastidor);
+ *   - fatos: o texto de cada página, limpo — a matéria-prima do roteiro.
+ */
+
+'use strict';
+
+const { URL } = require('url');
+
+const PALAVRAS_BOAS = ['galeria', 'imers', 'evento', 'sobre', 'about', 'portfolio', 'cases', 'case', 'turma', 'curso', 'produto', 'servic', 'equipe', 'time'];
+const RUIM = /(logo|icon|favicon|sprite|avatar|emoji|badge|\/brand\/|placeholder|blank|pixel|\.svg(\?|$)|-sm\.|\.sm\.|thumb)/i;
+
+function limpar(t) { return String(t || '').replace(/\s+/g, ' ').trim(); }
+
+/** O texto da página, sem script, estilo, menu nem rodapé repetido. */
+function textoDaPagina(html) {
+    let t = String(html || '')
+        .replace(/<script[\s\S]*?<\/script>|<style[\s\S]*?<\/style>|<noscript[\s\S]*?<\/noscript>/gi, ' ')
+        .replace(/<(nav|footer|header)[\s\S]*?<\/\1>/gi, ' ')
+        .replace(/<br\s*\/?>|<\/(p|h\d|li|div|section)>/gi, '. ')
+        .replace(/<[^>]+>/g, ' ');
+    t = t.replace(/&nbsp;/g, ' ').replace(/&amp;/g, '&').replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&[a-z]+;/g, ' ');
+    return limpar(t).replace(/(\.\s*){2,}/g, '. ').slice(0, 2200);
+}
+
+/** A versão maior de cada imagem: no srcset, o maior "w" até 2000. */
+function maiorDoSrcset(srcset) {
+    let melhor = null, largura = 0;
+    for (const parte of String(srcset).split(',')) {
+        const [u, w] = parte.trim().split(/\s+/);
+        const n = parseInt(w, 10) || 1;
+        if (u && n <= 2000 && n >= largura) { melhor = u; largura = n; }
+    }
+    return melhor;
+}
+
+// A mesma foto em tamanhos diferentes (x.sm.webp, x.md.webp, x.lg.webp) é UMA foto.
+const chaveDe = (u) => u.replace(/[?#].*$/, '').replace(/\.(sm|md|lg|xl|\d{2,4}w?)(?=\.[a-z]+$)/i, '').replace(/-\d{3,4}(?=\.[a-z]+$)/, '');
+
+function colherMidia(html, base) {
+    const abs = (u) => { try { return new URL(String(u).replace(/\\\//g, '/'), base).toString(); } catch { return null; } };
+    const fotos = new Map(), videos = new Map();
+    const pesoDe = (u) => (/\.lg\.|1800w|1920|2000/.test(u) ? 3 : /\.md\.|1280/.test(u) ? 2 : 1);
+    const poe = (mapa, u, alt = '') => {
+        const a = abs(u);
+        if (!a || RUIM.test(a) || a.startsWith('data:')) return;
+        const k = chaveDe(a);
+        const atual = mapa.get(k);
+        // Sem alt, o nome do arquivo descreve a foto ("palestrante-plateia-mesas").
+        const doNome = decodeURIComponent(a.split('/').pop().replace(/\.[a-z0-9]+$/i, '').replace(/\.(sm|md|lg)$/i, ''))
+            .replace(/^\d+[-_]?/, '').replace(/[-_]+/g, ' ').replace(/\b(dsc|img|hero)\b\s*\d*/gi, '').trim();
+        if (!atual || pesoDe(a) > pesoDe(atual.url)) mapa.set(k, { url: a, alt: limpar(alt).slice(0, 120) || (atual && atual.alt) || doNome });
+    };
+    let m;
+    const reImg = /<img\b[^>]*>/gi;
+    while ((m = reImg.exec(html))) {
+        const tag = m[0];
+        const alt = (tag.match(/\balt=["']([^"']*)/i) || [])[1] || '';
+        const srcset = (tag.match(/\b(?:srcset|data-srcset)=["']([^"']+)/i) || [])[1];
+        const src = (srcset && maiorDoSrcset(srcset)) || (tag.match(/\b(?:data-src|src)=["']([^"']+)/i) || [])[1];
+        if (src && /\.(jpe?g|png|webp|avif)(\?|$)/i.test(src)) poe(fotos, src, alt);
+    }
+    // Sites em Next/React guardam a galeria num JSON dentro da página: o
+    // caminho da mídia aparece como texto, não como <img>.
+    const reSolto = /["'(]((?:https?:)?\/[^"'()\s]+?\.(?:jpe?g|png|webp|avif|mp4|webm))(?:\?[^"'()\s]*)?["')]/gi;
+    while ((m = reSolto.exec(html))) {
+        const u = m[1];
+        if (/\.(mp4|webm)$/i.test(u)) poe(videos, u);
+        else poe(fotos, u);
+    }
+    const og = (html.match(/<meta[^>]+property=["']og:image["'][^>]+content=["']([^"']+)/i) || [])[1];
+    if (og) poe(fotos, og, 'capa do site');
+    return { fotos: [...fotos.values()], videos: [...videos.values()] };
+}
+
+/** As páginas internas que valem a leitura para ESTE pedido. */
+function paginasRelevantes(html, base, pedido, max = 5) {
+    const host = new URL(base).hostname;
+    const termos = String(pedido || '').normalize('NFD').replace(/[̀-ͯ]/g, '').toLowerCase()
+        .split(/[^a-z0-9]+/).filter((w) => w.length >= 4);
+    const vistos = new Set();
+    const lista = [];
+    const re = /href=["']([^"'#]+)["']/gi;
+    let m;
+    while ((m = re.exec(html))) {
+        let u;
+        try { u = new URL(m[1], base); } catch { continue; }
+        if (u.hostname !== host || /\.(css|js|png|jpe?g|svg|webp|pdf|ico|xml|json)$/i.test(u.pathname)) continue;
+        const caminho = u.pathname.replace(/\/$/, '');
+        if (!caminho || vistos.has(caminho) || /privacidade|privacy|termos|terms|login|blog\/|cdn-cgi/.test(caminho)) continue;
+        vistos.add(caminho);
+        const c = caminho.toLowerCase();
+        const pontos = termos.filter((t) => c.includes(t.slice(0, 6))).length * 3
+            + PALAVRAS_BOAS.filter((w) => c.includes(w)).length;
+        if (pontos > 0) lista.push({ url: u.toString(), pontos });
+    }
+    return lista.sort((a, b) => b.pontos - a.pontos).slice(0, max).map((x) => x.url);
+}
+
+/**
+ * Lê o site e baixa o acervo para a pasta do projeto.
+ *
+ * @param {object} op
+ * @param {string} op.url
+ * @param {string} op.pedido      o que o usuário pediu (decide quais páginas ler)
+ * @param {string} op.pasta       a pasta do projeto
+ * @param {function} op.buscar    (url) → {corpo} — o leitor de página do identidade.js
+ * @param {function} op.baixar    (item, {pasta, nome, sub}) → {ok, relativo} — o do assets.js
+ */
+async function colher({ url, pedido = '', pasta, buscar, baixar, maxFotos = 16, maxVideos = 4, htmlInicial = null }) {
+    const paginas = [];
+    const inicial = htmlInicial || (await buscar(url)).corpo;
+    paginas.push({ url, html: inicial });
+    for (const u of paginasRelevantes(inicial, url, pedido)) {
+        try { paginas.push({ url: u, html: (await buscar(u)).corpo }); } catch { /* página que não abriu fica de fora */ }
+    }
+
+    const fatos = paginas.map((p) => ({ pagina: p.url, texto: textoDaPagina(p.html) })).filter((f) => f.texto.length > 80);
+    const fotosVistas = new Map(), videosVistos = new Map();
+    // As páginas internas primeiro: a galeria tem mais foto de verdade que a home.
+    for (const p of [...paginas.slice(1), paginas[0]]) {
+        const { fotos, videos } = colherMidia(p.html, p.url);
+        for (const f of fotos) if (!fotosVistas.has(chaveDe(f.url))) fotosVistas.set(chaveDe(f.url), { ...f, pagina: p.url });
+        for (const v of videos) if (!videosVistos.has(chaveDe(v.url))) videosVistos.set(chaveDe(v.url), { ...v, pagina: p.url });
+    }
+
+    const fotos = [], videos = [];
+    for (const f of fotosVistas.values()) {
+        if (fotos.length >= maxFotos) break;
+        const d = await baixar({ url: f.url, titulo: f.alt || 'foto da marca', licenca: 'da própria marca', fonte: 'site' }, { pasta, nome: 'marca-foto', sub: 'midia/marca' });
+        // Menos de 25 KB é ícone ou miniatura, mesmo sem cara de ícone no nome.
+        if (d.ok && d.bytes > 25000) fotos.push({ src: d.relativo, alt: f.alt, pagina: f.pagina });
+    }
+    for (const v of videosVistos.values()) {
+        if (videos.length >= maxVideos) break;
+        const d = await baixar({ url: v.url, titulo: 'vídeo da marca', licenca: 'da própria marca', fonte: 'site' }, { pasta, nome: 'marca-video', sub: 'midia/marca' });
+        if (d.ok && d.bytes > 50000) videos.push({ src: d.relativo, pagina: v.pagina });
+    }
+    return { ok: true, paginas: paginas.map((p) => p.url), fatos, fotos, videos };
+}
+
+module.exports = { colher, colherMidia, paginasRelevantes, textoDaPagina, maiorDoSrcset };

package/lib/estudio/assets.js

@@ -120,7 +120,41 @@ const COLECOES = [
  * O SVG vem com `currentColor` no traço para a cor ser decidida na cena — um
  * ícone com cor cravada no arquivo obriga a baixar de novo para mudar de cor.
  */
+/* ── EMOJI 3D ─────────────────────────────────────────────────────────
+ * "Os emojis, quero emojis da Apple." (25/09/2026) Os da Apple têm direito
+ * autoral e não podem ir num vídeo publicado; os Fluent 3D da Microsoft têm
+ * licença MIT e o mesmo visual brilhante e com volume. "fluent-3d:robot" é o
+ * PNG do repositório oficial (pelo jsDelivr), embutido como <img> — o resto
+ * do render trata igual a um ícone SVG. Sem o 3D, cai no emoji plano. */
+const cache3d = new Map();
+async function emoji3d(nome, { pasta = null } = {}) {
+    if (cache3d.has(nome)) return cache3d.get(nome);
+    const palavras = nome.split('-');
+    const pastas = [
+        palavras.join(' ').replace(/^./, (c) => c.toUpperCase()),
+        palavras.map((w) => w[0].toUpperCase() + w.slice(1)).join(' '),
+    ];
+    for (const pastaGit of pastas) {
+        const url = `https://cdn.jsdelivr.net/gh/microsoft/fluentui-emoji@main/assets/${encodeURIComponent(pastaGit)}/3D/${palavras.join('_')}_3d.png`;
+        try {
+            const png = await pegar(url, { binario: true });
+            if (png && png.length > 1000 && png[0] === 0x89) {
+                if (pasta) guardar(path.join(pasta, 'midia', 'icones', `fluent-3d-${nome}.png`), png, { licenca: 'MIT (Microsoft Fluent UI Emoji)', origem: url });
+                const r = { ok: true, nome: 'fluent-3d:' + nome,
+                    svg: `<img src="data:image/png;base64,${png.toString('base64')}" style="width:100%;height:100%;object-fit:contain;display:block" />` };
+                cache3d.set(nome, r);
+                return r;
+            }
+        } catch { /* a próxima grafia */ }
+    }
+    const plano = await icone('fluent-emoji-flat:' + nome, { pasta });
+    const r = plano.ok ? { ...plano, nome: 'fluent-3d:' + nome } : plano;
+    cache3d.set(nome, r);
+    return r;
+}
+
 async function icone(nome, { pasta = null } = {}) {
+    if (/^fluent-3d:/i.test(String(nome))) return emoji3d(String(nome).split(':')[1], { pasta });
     const m = String(nome || '').match(/^([a-z0-9-]+):([a-z0-9-]+)$/i);
     if (!m) return { ok: false, error: 'o ícone é "coleção:nome", como "lucide:zap"' };
     const url = `https://api.iconify.design/${m[1]}/${m[2]}.svg?color=currentColor`;
@@ -213,7 +247,28 @@ function extensaoPorConteudo(bytes) {
  *
  * @returns {{ok, imagens: Array<{url, titulo, autor, licenca, creditos, fonte}>}}
  */
-async function procurarImagens(termo, { quantas = 8, transparente = false } = {}) {
+/* O Pexels pelo SERVIDOR: a chave é dele, e ninguém precisa ter uma. Sem
+   servidor (ou sem a chave lá), devolve null e a busca segue no Openverse. */
+async function pexelsDoServidor(tipo, termo, { quantas, orientacao } = {}) {
+    try {
+        const cfg = require('../config').loadConfig();
+        const r = await require('../api').getMidia(cfg.server, cfg.token, tipo, { q: termo, n: quantas, orientacao });
+        const lista = r && r.ok ? r[tipo] : null;
+        return lista && lista.length ? lista : null;
+    } catch { return null; }
+}
+
+/** Procura vídeo de apoio (b-roll). Só Pexels: o Openverse não tem vídeo. */
+async function procurarVideos(termo, { quantas = 5, orientacao = null } = {}) {
+    const videos = await pexelsDoServidor('videos', termo, { quantas, orientacao });
+    return videos ? { ok: true, videos } : { ok: false, error: 'sem acervo de vídeo agora (o servidor está sem a chave do Pexels).', videos: [] };
+}
+
+async function procurarImagens(termo, { quantas = 8, transparente = false, orientacao = null } = {}) {
+    if (!transparente && !process.env.PEXELS_API_KEY) {
+        const imagens = await pexelsDoServidor('imagens', termo, { quantas, orientacao });
+        if (imagens) return { ok: true, imagens };
+    }
     const chave = process.env.PEXELS_API_KEY;
     if (chave && !transparente) {
         try {
@@ -256,14 +311,33 @@ async function procurarImagens(termo, { quantas = 8, transparente = false } = {}
  * `duracaoMin` existe para separar as duas coisas sem o usuário dizer: um
  * "whoosh" tem menos de dois segundos, uma trilha tem mais de trinta.
  */
+/* A MÚSICA vem da Jamendo (pelo Openverse): música de verdade, moderna, de
+   licença aberta. O Openverse geral devolvia concerto antigo, vento e trilha
+   de terror para "cinematic" (medido em 25/09). Licença "nd" (sem obra
+   derivada) fica de fora da música: pôr a faixa num vídeo editado é derivar. */
+async function procurarMusica(termo, { quantas = 8, duracaoMin = 45 } = {}) {
+    try {
+        const r = await pegar(`https://api.openverse.org/v1/audio/?q=${encodeURIComponent(termo)}&source=jamendo`
+            + `&page_size=${Math.max(quantas * 2, 10)}&license_type=commercial`, { json: true });
+        const sons = (r.results || [])
+            .filter((x) => !/nd/.test(x.license || '') && (!duracaoMin || (x.duration || 0) / 1000 >= duracaoMin))
+            .slice(0, quantas)
+            .map((x) => ({ url: x.url, titulo: x.title || termo, autor: x.creator, licenca: x.license, creditos: x.attribution,
+                fonte: 'jamendo', segundos: x.duration ? Math.round(x.duration / 1000) : null }));
+        if (sons.length) return { ok: true, sons };
+    } catch { /* cai no Openverse geral */ }
+    return procurarSom(termo, { quantas, duracaoMin });
+}
+
 async function procurarSom(termo, { quantas = 8, duracaoMin = 0, duracaoMax = 0 } = {}) {
     try {
         let url = `https://api.openverse.org/v1/audio/?q=${encodeURIComponent(termo)}`
             + `&page_size=${quantas}&license_type=commercial`;
-        if (duracaoMin) url += `&length=${duracaoMin < 30 ? 'short' : 'medium'}`;
+        if (duracaoMin && duracaoMin < 30) url += '&length=short';
         const r = await pegar(url, { json: true });
         const sons = (r.results || [])
             .filter((x) => !duracaoMax || !x.duration || x.duration / 1000 <= duracaoMax)
+            .filter((x) => !duracaoMin || !x.duration || x.duration / 1000 >= duracaoMin)
             .map((x) => ({
                 url: x.url, titulo: x.title || termo, autor: x.creator,
                 licenca: x.license, creditos: x.attribution, fonte: 'openverse',
@@ -337,7 +411,7 @@ async function conferirFonte(familia) {
 module.exports = {
     extensaoPorConteudo,
     pegar, guardar,
-    icone, procurarIcones, iconesDoPlano, COLECOES,
+    icone, procurarIcones, iconesDoPlano, COLECOES, procurarVideos, procurarMusica,
     procurarImagens, procurarSom, baixar,
     FONTES, conferirFonte,
 };