primocode 10.19.0 → 11.1.0

package/lib/plugin/estudio/assets.js

@@ -0,0 +1,497 @@
+/**
+ * assets.js — de onde vêm os ícones, as imagens, o som e as fontes.
+ *
+ *   "Ícones: trocar a fonte de ícones atual, que está genérica demais.
+ *    Integrar uma biblioteca de ícones boa e autêntica. Imagens: buscar
+ *    imagens e PNGs na internet, remover fundo quando necessário. Trilha e
+ *    efeitos sonoros buscados na internet, não apenas os que já existem."
+ *
+ * ── O QUE HAVIA ──────────────────────────────────────────────────────────
+ * Um `icones.js` de 120 linhas com uns poucos desenhos feitos à mão, e nada
+ * mais: sem imagem, sem som, sem fonte além das seis embutidas no pacote. O
+ * resultado é o que foi descrito — genérico, porque o repertório inteiro
+ * cabia num arquivo de 120 linhas.
+ *
+ * ── POR QUE ESTAS FONTES, E NÃO PEXELS/FREESOUND ─────────────────────────
+ * As três usadas aqui funcionam SEM CHAVE NENHUMA, e isso não é detalhe: o
+ * produto promete que a pessoa instala e usa. Um estúdio que só busca imagem
+ * depois de a pessoa criar conta em dois serviços é um estúdio que não busca
+ * imagem.
+ *
+ *   · Iconify — mais de 200 mil ícones de 150 coleções (Lucide, Phosphor,
+ *     Material, Simple Icons com as marcas). Um SVG por requisição, sem
+ *     cadastro. É o fim do pacote genérico.
+ *   · Openverse — imagem e áudio com licença aberta, de Flickr, Wikimedia,
+ *     Freesound e outros, com a atribuição junto. Sem cadastro.
+ *   · Google Fonts — o leque de fontes, sem cadastro.
+ *
+ * Pexels e Freesound entram por cima QUANDO houver chave (PEXELS_API_KEY,
+ * FREESOUND_API_KEY): a qualidade de foto do Pexels é melhor. Sem a chave, o
+ * Openverse atende — em vez de o estúdio não atender.
+ *
+ * ── A LICENÇA VAI JUNTO, SEMPRE ──────────────────────────────────────────
+ * Toda mídia baixada guarda um `.licenca.json` ao lado, com autor, licença e
+ * de onde veio. Não é burocracia: material aberto quase sempre exige crédito,
+ * e descobrir isso depois de publicar o vídeo é tarde. Com o arquivo ao lado,
+ * o agente consegue montar os créditos sem adivinhar.
+ *
+ * ── NADA DISSO ENTRA NO RENDER PELA REDE ─────────────────────────────────
+ * Tudo é BAIXADO para a pasta do projeto antes. Render que busca imagem na
+ * internet falha no meio, depois de vinte minutos de trabalho — e falha de
+ * novo amanhã, quando o link morrer.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+const { URL } = require('url');
+
+const PRAZO = 20000;
+
+function pegar(url, { json = false, binario = false, cabecalhos = {} } = {}) {
+    return new Promise((resolve, reject) => {
+        const u = new URL(url);
+        const req = https.get({
+            hostname: u.hostname,
+            path: u.pathname + u.search,
+            headers: {
+                // O Openverse recusa quem não se identifica, e com razão.
+                'User-Agent': 'PrimoCode-Studio/1.0 (+https://www.npmjs.com/package/primocode)',
+                Accept: json ? 'application/json' : '*/*',
+                ...cabecalhos,
+            },
+        }, (res) => {
+            if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+                res.resume();
+                return resolve(pegar(new URL(res.headers.location, url).toString(), { json, binario, cabecalhos }));
+            }
+            if (res.statusCode >= 400) {
+                res.resume();
+                return reject(new Error(`HTTP ${res.statusCode} em ${u.hostname}`));
+            }
+            const pedacos = [];
+            res.on('data', (d) => pedacos.push(d));
+            res.on('end', () => {
+                const corpo = Buffer.concat(pedacos);
+                if (binario) return resolve(corpo);
+                const texto = corpo.toString('utf8');
+                if (!json) return resolve(texto);
+                try { resolve(JSON.parse(texto)); }
+                catch { reject(new Error('resposta não era JSON')); }
+            });
+        });
+        const relogio = setTimeout(() => req.destroy(new Error('a busca demorou demais')), PRAZO);
+        if (relogio.unref) relogio.unref();
+        req.on('close', () => clearTimeout(relogio));
+        req.on('error', reject);
+    });
+}
+
+function guardar(arquivo, dados, licenca) {
+    fs.mkdirSync(path.dirname(arquivo), { recursive: true });
+    fs.writeFileSync(arquivo, dados);
+    if (licenca) {
+        fs.writeFileSync(arquivo + '.licenca.json', JSON.stringify(licenca, null, 2), 'utf8');
+    }
+    return arquivo;
+}
+
+// ── ícones ───────────────────────────────────────────────────────────────
+
+/* As coleções que valem a pena, na ordem em que costumam servir. Não é uma
+   lista fechada: qualquer coleção do Iconify funciona, isto é só o que o
+   agente vê quando não sabe o que pedir. */
+const COLECOES = [
+    ['lucide', 'traço limpo e moderno, o padrão para interface'],
+    ['phosphor', 'traço com peso ajustável, boa para destaque'],
+    ['solar', 'cheios e arredondados, bons em tamanho grande'],
+    ['tabler', 'traço fino e técnico'],
+    ['material-symbols', 'os do Google, para produto Android/web'],
+    ['simple-icons', 'as MARCAS — pix, whatsapp, spotify, github'],
+    ['fluent-emoji-flat', 'emoji desenhado, quando o assunto pede leveza'],
+    ['game-icons', 'ilustrativos, para assunto fora do corporativo'],
+];
+
+/**
+ * Baixa um ícone e devolve o SVG.
+ *
+ * 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`;
+    try {
+        const svg = await pegar(url);
+        if (!/^<svg/i.test(svg.trim())) {
+            return { ok: false, error: `"${nome}" não existe. Procure com estudio_icones.` };
+        }
+        if (pasta) guardar(path.join(pasta, 'midia', 'icones', `${m[1]}-${m[2]}.svg`), svg);
+        return { ok: true, nome, svg };
+    } catch (e) {
+        return { ok: false, error: `não deu para baixar o ícone: ${e.message}` };
+    }
+}
+
+/** Procura ícones por palavra, em todas as coleções. */
+async function procurarIcones(termo, { limite = 24 } = {}) {
+    try {
+        const r = await pegar(
+            `https://api.iconify.design/search?query=${encodeURIComponent(termo)}&limit=${limite}`,
+            { json: true });
+        return { ok: true, icones: r.icons || [], colecoes: COLECOES };
+    } catch (e) {
+        return { ok: false, error: e.message, colecoes: COLECOES };
+    }
+}
+
+/** Baixa todos os ícones que o plano usa, de uma vez. */
+async function iconesDoPlano(plano, pasta) {
+    const nomes = new Set();
+    for (const cena of plano.cenas || []) {
+        for (const el of cena.elementos || []) if (el.tipo === 'icone' && el.nome) nomes.add(el.nome);
+    }
+    const mapa = {};
+    const faltaram = [];
+    for (const nome of nomes) {
+        const r = await icone(nome, { pasta });
+        if (r.ok) mapa[nome] = r.svg;
+        else faltaram.push({ nome, motivo: r.error });
+    }
+    return { mapa, faltaram };
+}
+
+// ── imagens ──────────────────────────────────────────────────────────────
+
+function extensaoDe(url, padrao) {
+    const m = String(url).split('?')[0].match(/\.([a-z0-9]{2,5})$/i);
+    return m ? '.' + m[1].toLowerCase() : padrao;
+}
+
+/**
+ * A extensão pelos PRIMEIROS BYTES, não pela URL.
+ *
+ * O Jamendo entrega mp3 numa URL sem extensão nenhuma ("?trackid=…&
+ * format=mp32"), e o Openverse repassa essa URL como está. Pela URL o arquivo
+ * era salvo como `.jpg` — e um `.jpg` que na verdade é um mp3 entra no plano,
+ * passa pelo validador (o arquivo existe!) e só quebra lá na frente, dentro
+ * do Remotion, com um erro que não fala de download nenhum.
+ *
+ * Os bytes não mentem. A URL é o palpite de reserva, para o formato que não
+ * tiver assinatura conhecida aqui.
+ */
+function extensaoPorConteudo(bytes) {
+    if (!bytes || bytes.length < 12) return null;
+    const c = bytes.subarray(0, 12);
+    const quatro = c.subarray(0, 4).toString('latin1');
+    if (c.subarray(0, 3).toString('latin1') === 'ID3' || (c[0] === 0xff && (c[1] & 0xe0) === 0xe0)) return '.mp3';
+    if (quatro === 'OggS') return '.ogg';
+    if (quatro === 'fLaC') return '.flac';
+    // RIFF é container: WAVE é som, WEBP é imagem — os bytes 8..11 dizem qual.
+    if (quatro === 'RIFF') {
+        const tipo = c.subarray(8, 12).toString('latin1');
+        return tipo === 'WEBP' ? '.webp' : tipo === 'WAVE' ? '.wav' : null;
+    }
+    if (c[0] === 0x89 && quatro.slice(1) === 'PNG') return '.png';
+    if (c[0] === 0xff && c[1] === 0xd8) return '.jpg';
+    if (c.subarray(0, 3).toString('latin1') === 'GIF') return '.gif';
+    if (c[0] === 0x00 && c[1] === 0x00 && c[2] === 0x01 && c[3] === 0x00) return '.ico';
+    // ftyp no offset 4: MP4 e M4A dividem o container; o `brand` separa.
+    if (c.subarray(4, 8).toString('latin1') === 'ftyp') {
+        return /^(M4A|mp42|isom|iso2|mp41)/.test(c.subarray(8, 12).toString('latin1')) ? '.mp4' : '.mp4';
+    }
+    const inicio = bytes.subarray(0, 400).toString('utf8').trimStart();
+    if (/^<(\?xml|svg)/i.test(inicio)) return '.svg';
+    return null;
+}
+
+/**
+ * Procura imagem. Pexels na frente quando há chave; Openverse sempre.
+ *
+ * @returns {{ok, imagens: Array<{url, titulo, autor, licenca, creditos, fonte}>}}
+ */
+/* 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/config').loadConfig();
+        const r = await require('../../provider/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; }
+}
+
+/* ── O ACERVO EDITORIAL (08/10): "as imagens de banco são horríveis… desde
+   que não seja genérica, tipo pessoa sorrindo olhando pro nada" (Joel). Foto
+   de verdade, de arquivo e de museu, em vez de banco de stock:
+     1. Wikimedia Commons — documental (o despertador antigo, a ressonância de
+        1982, a cidade à noite). Só CC0, domínio público e CC BY (sem SA: o
+        SA obrigaria o vídeo a ter a mesma licença), e só foto grande;
+     2. Art Institute of Chicago — o acervo em domínio público (pintura,
+        gravura, fotografia antiga), pela imagem IIIF.
+   O que tem cara de stock ou de assunto pesado sai pelo título. Sem nada
+   que sirva, volta vazio: imagem genérica é pior que nenhuma. */
+const GENERICA = /smil|happy|laugh|business ?(wo)?man|teamwork|handshake|thumbs|stock photo|isolated on white|portrait of (a|an) (young|happy)|selfie|model pos/i;
+const PESADA = /homeless|corpse|dead body|cad[aá]ver|war victim|wounded|blood|nude|naked|execution|lynch|torture|mendig/i;
+const LIVRE = (lic) => /^(cc0|public domain|pd|cc by \d|cc by$|cc-by-\d|attribution)/i.test(String(lic || '').trim()) && !/sa|nc|nd/i.test(String(lic || '').replace(/^public domain/i, ''));
+
+function limparHtml(t) { return String(t || '').replace(/<[^>]+>/g, '').replace(/\s*(title|label)\s+QS:.*$/i, '').replace(/\s+/g, ' ').trim(); }
+
+async function procurarWikimedia(termo, { quantas = 8, minimo = 1200 } = {}) {
+    const url = 'https://commons.wikimedia.org/w/api.php?action=query&format=json&generator=search&gsrnamespace=6'
+        + `&gsrsearch=${encodeURIComponent(termo + ' filetype:bitmap')}&gsrlimit=30&prop=imageinfo`
+        + '&iiprop=url|size|extmetadata&iiurlwidth=1600&iiextmetadatafilter=LicenseShortName|Artist|ImageDescription|ObjectName';
+    const r = await pegar(url, { json: true });
+    const paginas = Object.values((r.query && r.query.pages) || {}).sort((a, b) => (a.index || 0) - (b.index || 0));
+    const out = [];
+    for (const pg of paginas) {
+        const ii = (pg.imageinfo || [])[0];
+        if (!ii || ii.width < minimo || ii.height < minimo * 0.5) continue;
+        const md = ii.extmetadata || {};
+        const lic = (md.LicenseShortName || {}).value || '';
+        const titulo = limparHtml((md.ObjectName || {}).value || pg.title.replace(/^File:/, '').replace(/\.[a-z]+$/i, ''));
+        const desc = limparHtml((md.ImageDescription || {}).value || '');
+        if (!LIVRE(lic) || GENERICA.test(titulo + ' ' + desc) || PESADA.test(titulo + ' ' + desc)) continue;
+        const autor = (limparHtml((md.Artist || {}).value || '').split(/\s+(Author info|Reusing images|Own work)\b/i)[0].slice(0, 80)) || 'Wikimedia Commons';
+        out.push({ url: ii.thumburl || ii.url, titulo, autor, licenca: lic, fonte: 'wikimedia', largura: ii.thumbwidth || ii.width, altura: ii.thumbheight || ii.height,
+            creditos: `${titulo} — ${autor} (${lic}, Wikimedia Commons)`, pagina: ii.descriptionurl });
+        if (out.length >= quantas) break;
+    }
+    return out;
+}
+
+async function procurarArtic(termo, { quantas = 6 } = {}) {
+    const url = `https://api.artic.edu/api/v1/artworks/search?q=${encodeURIComponent(termo)}`
+        + '&query%5Bterm%5D%5Bis_public_domain%5D=true&limit=20&fields=id,title,image_id,artist_title,date_display,thumbnail';
+    const r = await pegar(url, { json: true });
+    return (r.data || []).filter((a) => a.image_id && !PESADA.test(a.title || '')).slice(0, quantas).map((a) => ({
+        url: `https://www.artic.edu/iiif/2/${a.image_id}/full/1686,/0/default.jpg`, titulo: a.title, autor: a.artist_title || 'Art Institute of Chicago',
+        licenca: 'CC0 (domínio público)', fonte: 'artic', largura: (a.thumbnail || {}).width, altura: (a.thumbnail || {}).height,
+        creditos: `${a.title}${a.date_display ? ', ' + a.date_display : ''} — ${a.artist_title || 'autor desconhecido'} (Art Institute of Chicago, CC0)`,
+    }));
+}
+
+/* A BUSCA DE ARQUIVO é curta: o roteiro escreve busca de banco de stock
+   ("tired person at office desk"), e um arquivo de verdade não acha nada
+   com isso. Tenta a busca inteira, depois só as palavras de conteúdo, depois
+   os pares delas do fim para o começo ("alarm clock on nightstand" → "alarm
+   clock"). Pessoa genérica sai da busca: o arquivo responde com a coisa. */
+const VAZIAS_BUSCA = new Set('a an the of on in at with and or to for from by into over under near during while person people man woman someone guy girl young old tired happy sad soft light glowing macro close up closeup shot view cinematic photo image background beautiful modern'.split(' '));
+function buscasMenores(termo) {
+    const ws = String(termo || '').toLowerCase().replace(/[^a-z0-9\s-]/g, ' ').split(/\s+/).filter(Boolean);
+    const conteudo = ws.filter((w) => !VAZIAS_BUSCA.has(w));
+    const pares = [];
+    for (let k = conteudo.length - 2; k >= 0; k--) pares.push(conteudo.slice(k, k + 2).join(' '));
+    return [...new Set([ws.join(' '), conteudo.join(' '), ...pares, ...conteudo.slice().reverse()].filter((x) => x && x.length > 2))];
+}
+
+/** A foto editorial (Wikimedia), da busca inteira à mais curta. Nunca o banco de stock. */
+async function procurarEditorial(termo, { quantas = 8 } = {}) {
+    for (const q of buscasMenores(termo)) {
+        let imagens = [];
+        try { imagens = await procurarWikimedia(q, { quantas }); } catch { continue; }
+        if (imagens.length >= 2) return { ok: true, imagens, busca: q };
+    }
+    return { ok: false, imagens: [] };
+}
+
+/** 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 {
+            const r = await pegar(
+                `https://api.pexels.com/v1/search?query=${encodeURIComponent(termo)}&per_page=${quantas}`,
+                { json: true, cabecalhos: { Authorization: chave } });
+            const imagens = (r.photos || []).map((p) => ({
+                url: p.src.original, titulo: p.alt || termo, autor: p.photographer,
+                licenca: 'Pexels', creditos: `Foto de ${p.photographer} (Pexels)`, fonte: 'pexels',
+                largura: p.width, altura: p.height,
+            }));
+            if (imagens.length) return { ok: true, imagens };
+        } catch { /* cai para o Openverse */ }
+    }
+
+    try {
+        // `license_type=commercial` corta o que não pode ser usado em peça de
+        // marca — que é o caso de quase todo vídeo feito aqui.
+        const r = await pegar(
+            `https://api.openverse.org/v1/images/?q=${encodeURIComponent(termo)}`
+            + `&page_size=${quantas}&license_type=commercial`
+            + (transparente ? '&extension=png' : ''),
+            { json: true });
+        const imagens = (r.results || []).map((x) => ({
+            url: x.url, titulo: x.title || termo, autor: x.creator,
+            licenca: x.license, creditos: x.attribution, fonte: 'openverse',
+            largura: x.width, altura: x.height,
+        }));
+        return { ok: true, imagens };
+    } catch (e) {
+        return { ok: false, error: `não deu para procurar imagem: ${e.message}`, imagens: [] };
+    }
+}
+
+// ── som ──────────────────────────────────────────────────────────────────
+
+/**
+ * Procura música ou efeito sonoro.
+ *
+ * `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 });
+}
+
+/* `livre`: só domínio público (CC0 e PDM). O efeito sonoro entra no vídeo sem
+   crédito, então não pode ser CC-BY, que o "commercial" deixa passar. */
+function urlSom(termo, { quantas = 8, duracaoMin = 0, livre = false } = {}) {
+    let url = `https://api.openverse.org/v1/audio/?q=${encodeURIComponent(termo)}`
+        + `&page_size=${quantas}` + (livre ? '&license=cc0,pdm' : '&license_type=commercial');
+    if (duracaoMin && duracaoMin < 30) url += '&length=short';
+    return url;
+}
+
+async function procurarSom(termo, { quantas = 8, duracaoMin = 0, duracaoMax = 0, livre = false } = {}) {
+    try {
+        const r = await pegar(urlSom(termo, { quantas, duracaoMin, livre }), { 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',
+                segundos: x.duration ? Math.round(x.duration / 1000) : null,
+            }));
+        return { ok: true, sons };
+    } catch (e) {
+        return { ok: false, error: `não deu para procurar som: ${e.message}`, sons: [] };
+    }
+}
+
+// ── baixar ───────────────────────────────────────────────────────────────
+
+/**
+ * Traz a mídia para a pasta do projeto.
+ *
+ * O `relativo` que volta é o que entra no plano — sempre relativo à pasta do
+ * projeto, nunca absoluto: caminho absoluto quebra quando o projeto é movido
+ * ou aberto em outra máquina.
+ */
+async function baixar(item, { pasta, nome = null, sub = 'midia' } = {}) {
+    if (!item || !item.url) return { ok: false, error: 'sem endereço para baixar' };
+    try {
+        const dados = await pegar(item.url, { binario: true });
+        const ext = extensaoPorConteudo(dados) || extensaoDe(item.url, '.jpg');
+        const limpo = (nome || String(item.titulo || 'midia'))
+            .normalize('NFD').replace(/[̀-ͯ]/g, '')
+            .replace(/[^a-z0-9]+/gi, '-').toLowerCase().slice(0, 40);
+        const destino = path.join(pasta, sub, `${limpo || 'midia'}-${Date.now().toString(36)}${ext}`);
+        guardar(destino, dados, {
+            titulo: item.titulo, autor: item.autor, licenca: item.licenca,
+            creditos: item.creditos, origem: item.url, fonte: item.fonte, quando: new Date().toISOString(),
+        });
+        return {
+            ok: true,
+            arquivo: destino,
+            relativo: path.relative(pasta, destino).replace(/\\/g, '/'),
+            bytes: dados.length,
+            creditos: item.creditos || null,
+        };
+    } catch (e) {
+        return { ok: false, error: `não deu para baixar: ${e.message}` };
+    }
+}
+
+// ── fontes ───────────────────────────────────────────────────────────────
+
+/* O leque. Antes eram seis arquivos .woff2 no pacote; agora é o Google Fonts
+   inteiro. Esta lista não LIMITA nada — qualquer família do Google Fonts
+   funciona no plano. Ela existe porque um modelo que não conhece o catálogo
+   escreve "Inter" em tudo, e o resultado é o que se reclamou: tudo igual. */
+const FONTES = {
+    display: ['Anton', 'Bebas Neue', 'Archivo Black', 'Oswald', 'Teko', 'Alfa Slab One',
+        'Bungee', 'Righteous', 'Bowlby One', 'Passion One', 'Ultra', 'Rubik Mono One'],
+    grotesca: ['Inter', 'Manrope', 'Plus Jakarta Sans', 'Outfit', 'Sora', 'Space Grotesk',
+        'DM Sans', 'Figtree', 'Onest', 'Geist', 'Satoshi', 'General Sans'],
+    serifa: ['Playfair Display', 'Fraunces', 'Instrument Serif', 'DM Serif Display',
+        'Libre Baskerville', 'Lora', 'Cormorant Garamond', 'Spectral', 'Newsreader'],
+    tecnica: ['JetBrains Mono', 'IBM Plex Mono', 'Space Mono', 'Azeret Mono', 'Martian Mono'],
+    manuscrita: ['Caveat', 'Kalam', 'Permanent Marker', 'Shadows Into Light', 'Gloria Hallelujah'],
+    condensada: ['Barlow Condensed', 'Archivo Narrow', 'Saira Condensed', 'Fjalla One', 'Roboto Condensed'],
+};
+
+/** A fonte existe no Google Fonts? Erra-se o nome com facilidade. */
+async function conferirFonte(familia) {
+    const url = `https://fonts.googleapis.com/css2?family=${encodeURIComponent(familia).replace(/%20/g, '+')}`;
+    try { await pegar(url); return { ok: true, familia }; }
+    catch { return { ok: false, error: `"${familia}" não existe no Google Fonts.` }; }
+}
+
+module.exports = {
+    extensaoPorConteudo,
+    pegar, guardar,
+    icone, procurarIcones, iconesDoPlano, COLECOES, procurarVideos, procurarMusica,
+    procurarImagens, procurarEditorial, procurarWikimedia, procurarArtic, buscasMenores, procurarSom, urlSom, baixar,
+    FONTES, conferirFonte,
+};

package/lib/plugin/estudio/assinatura.js

@@ -0,0 +1,108 @@
+/**
+ * assinatura.js — o estilo como um ARQUIVO com nome e números, que o vídeo
+ * novo é conferido contra e que guarda o que a pessoa disse dos vídeos.
+ *
+ *   Do desmontado do Forseth (rookies-lab, 07/10): o estilo vira um arquivo
+ *   nomeado, e o feedback da pessoa fica gravado nele. O que faltava lá: o
+ *   estilo era prosa, sem número — ninguém conferia se o vídeo seguiu.
+ *
+ * A assinatura de fábrica mora em lib/plugin/estudio/assinaturas/<nome>.json: as
+ * faixas medidas do vídeo que o Joel aprovou (08/10). A da pessoa mora em
+ * ~/.primocode/studio/assinaturas/<nome>.json e guarda só o que é dela: as
+ * faixas que ela ajustou e as notas ("adorei a virada", "texto demais").
+ * Lidas juntas: a dela por cima da de fábrica.
+ *
+ *   medir(partitura, plano)   os números do vídeo (os mesmos da assinatura)
+ *   conferir(nome, medidas)   o que saiu da faixa, em uma linha cada
+ *   anotar(nome, texto)       o feedback da pessoa, com a data
+ */
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const FABRICA = path.join(__dirname, 'assinaturas');
+const pastaDaPessoa = () => path.join(os.homedir(), '.primocode', 'studio', 'assinaturas');
+const r2 = (n) => Math.round(n * 100) / 100;
+
+function lerJson(arq) { try { return JSON.parse(fs.readFileSync(arq, 'utf8')); } catch { return null; } }
+
+/** A assinatura pelo nome: a de fábrica com a da pessoa por cima. null se não existe nenhuma. */
+function ler(nome) {
+    const n = String(nome || '').toLowerCase().replace(/[^a-z0-9-]/g, '');
+    if (!n) return null;
+    const base = lerJson(path.join(FABRICA, n + '.json'));
+    const dela = lerJson(path.join(pastaDaPessoa(), n + '.json'));
+    if (!base && !dela) return null;
+    const a = { nome: n, faixas: {}, notas: [], ...(base || {}) };
+    if (dela) {
+        for (const [k, v] of Object.entries(dela.faixas || {})) a.faixas[k] = { ...(a.faixas[k] || {}), ...v };
+        a.notas = [...(a.notas || []), ...(dela.notas || [])];
+    }
+    return a;
+}
+
+const mediana = (xs) => { const s = [...xs].sort((a, b) => a - b); return s.length ? (s.length % 2 ? s[(s.length - 1) / 2] : (s[s.length / 2 - 1] + s[s.length / 2]) / 2) : 0; };
+
+/* Uma "frase" na tela: no fluido, b.frases[].palavras; no gerativo, cada
+   linha (b.linhas[], com .palavras ou só .texto). */
+const frasesDe = (b) => [...(b.frases || []), ...(b.linhas || [])]
+    .map((f) => (Array.isArray(f.palavras) ? f.palavras.length : String(f.texto || '').split(/\s+/).filter(Boolean).length));
+
+/** Os números de um vídeo (fluido ou gerativo), da partitura e do plano. */
+function medir(partitura, plano) {
+    const B = (partitura && partitura.batidas) || [];
+    const dur = Number(partitura && partitura.duracao) || 0;
+    if (!B.length || !dur) return null;
+    const palavras = B.flatMap(frasesDe).filter((n) => n > 0);
+    const efeitos = ((plano && plano.audio && plano.audio.efeitos) || []).length;
+    return {
+        batida_mediana_s: r2(mediana(B.map((b) => b.ate - b.de))),
+        palavras_por_frase_max: Math.max(0, ...palavras),
+        palavras_por_frase_mediana: mediana(palavras),
+        // Corte seco: a transição do fluido, ou o fundo do gerativo que troca por corte.
+        cortes_secos: B.filter((b, i) => i > 0 && (b.transicao === 'corte' || b.troca === 'corte')).length,
+        fracao_gigante: r2(B.filter((b) => b.gigante || b.comp === 'gigante').length / B.length),
+        // Virada de fundo: a marcada no fluido, ou o fundo do gerativo que troca (corte, cortina ou inundação).
+        fracao_virada: r2(B.filter((b, i) => b.virada || (i > 0 && b.troca)).length / B.length),
+        efeitos_por_minuto: r2(efeitos / dur * 60),
+    };
+}
+
+/** O que saiu da faixa: [{faixa, valor, min, max, diz}]. Vazio = o vídeo seguiu a assinatura. */
+function conferir(nome, medidas) {
+    const a = ler(nome);
+    if (!a || !medidas) return { assinatura: null, fora: [] };
+    const fora = [];
+    for (const [k, f] of Object.entries(a.faixas || {})) {
+        const v = medidas[k];
+        if (v == null) continue;
+        if ((f.min != null && v < f.min) || (f.max != null && v > f.max)) fora.push({ faixa: k, valor: v, min: f.min, max: f.max, diz: f.diz });
+    }
+    return { assinatura: a.nome, fora };
+}
+
+/** Uma linha por faixa estourada, para o agente e o caderno. */
+function descrever(fora) {
+    return fora.map((x) => `${x.faixa} = ${x.valor} (a assinatura pede ${x.min != null ? x.min : '…'} a ${x.max != null ? x.max : '…'}: ${x.diz || ''})`);
+}
+
+/** O feedback da pessoa fica na assinatura dela, com a data. Devolve quantas notas ela tem. */
+function anotar(nome, texto, quando = new Date()) {
+    const n = String(nome || '').toLowerCase().replace(/[^a-z0-9-]/g, '');
+    const t = String(texto || '').trim();
+    if (!n || !t) return { ok: false, error: 'a assinatura precisa de nome e de texto.' };
+    const arq = path.join(pastaDaPessoa(), n + '.json');
+    const dela = lerJson(arq) || { nome: n, faixas: {}, notas: [] };
+    dela.notas = [...(dela.notas || []), { quando: quando.toISOString().slice(0, 10), texto: t }].slice(-40);
+    try { fs.mkdirSync(pastaDaPessoa(), { recursive: true }); fs.writeFileSync(arq, JSON.stringify(dela, null, 2)); }
+    catch (e) { return { ok: false, error: e.message }; }
+    return { ok: true, assinatura: n, notas: dela.notas.length };
+}
+
+/** As últimas notas, para ir na frente do pedido (o agente lê antes de fazer o próximo vídeo). */
+function notasRecentes(nome, n = 6) { const a = ler(nome); return a ? (a.notas || []).slice(-n) : []; }
+
+module.exports = { ler, medir, conferir, descrever, anotar, notasRecentes, FABRICA };