primocode 10.19.0 → 11.1.0

package/lib/plugin/estudio/marca.js

@@ -0,0 +1,398 @@
+/**
+ * marca.js — a logo e a identidade visual de uma empresa, puxadas do site.
+ *
+ * Pedido do dono: "puxe a logo e identidade visual da empresa". O agente
+ * fazia peça de marca com `marca.cor` chutada e sem logo, ou pedia o arquivo
+ * ao usuário — e o usuário, que só disse "faz um vídeo para a Paris Group",
+ * não estava ali para mandar arquivo nenhum. O site da empresa TEM a logo,
+ * as cores e as fontes; é só ler como uma pessoa leria.
+ *
+ * ── O QUE SE LÊ, E EM QUE ORDEM ──────────────────────────────────────────
+ *   nome   og:site_name → <title> (sem o " | slogan")
+ *   frase  meta description / og:description (o "sobre" em uma linha)
+ *   logo   <img> com "logo" no src/alt/class (a de verdade, no cabeçalho) →
+ *          apple-touch-icon (180 px, o melhor ícone que todo site tem) →
+ *          og:image (é a imagem de compartilhar, às vezes é a logo, às vezes
+ *          uma foto — por isso vem por último) → favicon.
+ *          SVG ganha de PNG no mesmo lugar: escala sem borrar.
+ *   cores  meta theme-color primeiro (a empresa DISSE qual é a cor), depois
+ *          as cores mais repetidas no CSS (inline e nas folhas ligadas),
+ *          fora branco/preto/cinza — o que sobra é a paleta.
+ *   fontes os "family=" do Google Fonts e os font-family do CSS, fora as
+ *          genéricas (sans-serif, Arial, system-ui).
+ *
+ * A logo é BAIXADA para o projeto e ENVIADA ao estúdio: volta como
+ * "/midia/…", pronta para `marca.logo`. O resto volta como `marca` pronta
+ * para colar no documento.
+ *
+ * Zero dependências: o `pegar` do referencia.js (texto e binário), e o
+ * chute de domínio dele quando a pessoa deu só o nome.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const referencia = require('../../referencia.js');
+
+const GENERICAS_FONTE = /^(sans-serif|serif|monospace|system-ui|-apple-system|blinkmacsystemfont|segoe ui|arial|helvetica( neue)?|roboto|inherit|initial|ui-sans-serif|ui-serif|ui-monospace|apple color emoji|segoe ui emoji|noto color emoji|times new roman|courier new|verdana|tahoma|georgia)$/i;
+
+function absoluta(href, base) {
+    try { return new URL(String(href || '').replace(/&amp;/g, '&'), base).href; } catch { return null; }
+}
+
+function atributo(tag, nome) {
+    const m = new RegExp(`\\b${nome}\\s*=\\s*("([^"]*)"|'([^']*)'|([^\\s>]+))`, 'i').exec(tag);
+    return m ? (m[2] != null ? m[2] : m[3] != null ? m[3] : m[4]) : null;
+}
+
+function metas(html) {
+    const saida = {};
+    for (const tag of html.match(/<meta\b[^>]*>/gi) || []) {
+        const chave = atributo(tag, 'property') || atributo(tag, 'name');
+        const valor = atributo(tag, 'content');
+        if (chave && valor && saida[chave.toLowerCase()] == null) saida[chave.toLowerCase()] = valor.trim();
+    }
+    return saida;
+}
+
+/** As candidatas a logo, da melhor para a pior. */
+function candidatasALogo(html, base) {
+    const lista = [];
+    // 1. <img> que se chama logo — no cabeçalho é a logo de verdade.
+    for (const tag of html.match(/<img\b[^>]*>/gi) || []) {
+        const src = atributo(tag, 'src') || atributo(tag, 'data-src') || '';
+        const alt = atributo(tag, 'alt') || '';
+        const cls = atributo(tag, 'class') || '';
+        const id = atributo(tag, 'id') || '';
+        if (/logo|brand|marca/i.test(`${src} ${alt} ${cls} ${id}`) && !/sponsor|partner|cliente|client|parceir/i.test(`${alt} ${cls} ${src}`)) {
+            const u = absoluta(src, base);
+            // O `alt` vai junto: "Nubank logo" diz de QUEM é a logo, e o
+            // endereço nem sempre diz (CDN devolve hash por nome de arquivo).
+            // Quem usa isso é `ordenarPelaMarca`, no estudio/identidade.js.
+            if (u && !/^data:/.test(u)) lista.push({ url: u, alt, fonte: 'img-logo', nota: /\.svg(\?|$)/i.test(u) ? 30 : 20 });
+        }
+    }
+    // 1b. SVG inline no cabeçalho com "logo" no nome — não dá para baixar,
+    //     mas o agente pode saber que existe (e usar o nome em texto).
+    // 2. Ícones declarados.
+    for (const tag of html.match(/<link\b[^>]*>/gi) || []) {
+        const rel = (atributo(tag, 'rel') || '').toLowerCase();
+        const href = atributo(tag, 'href');
+        if (!href) continue;
+        const u = absoluta(href, base);
+        if (!u) continue;
+        if (/apple-touch-icon/.test(rel)) lista.push({ url: u, fonte: 'apple-touch-icon', nota: 15 });
+        else if (/\bicon\b/.test(rel)) {
+            const tam = parseInt((atributo(tag, 'sizes') || '0').split('x')[0], 10) || 0;
+            lista.push({ url: u, fonte: 'icon', nota: /\.svg(\?|$)/i.test(u) ? 14 : (tam >= 128 ? 10 : 4) });
+        }
+    }
+    // 3. og:image — a imagem de compartilhar. Às vezes é a logo, às vezes é
+    //    uma foto: fica atrás das declaradas.
+    const m = metas(html);
+    const og = m['og:image'] || m['twitter:image'];
+    if (og) { const u = absoluta(og, base); if (u) lista.push({ url: u, fonte: 'og:image', nota: 6 }); }
+    // 4. O favicon padrão, quando nada foi declarado.
+    lista.push({ url: absoluta('/favicon.ico', base), fonte: 'favicon', nota: 1 });
+    // Ordena e tira repetidos.
+    const vistos = new Set();
+    return lista.filter((c) => c.url && !vistos.has(c.url) && vistos.add(c.url)).sort((a, b) => b.nota - a.nota);
+}
+
+/** As cores de um CSS, contadas. Fora branco, preto e cinza. */
+function coresDe(css, contagem) {
+    const re = /#([0-9a-f]{6}|[0-9a-f]{3})\b|rgba?\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})/gi;
+    let m;
+    while ((m = re.exec(css))) {
+        let hex;
+        if (m[1]) {
+            hex = m[1].length === 3 ? m[1].split('').map((c) => c + c).join('') : m[1];
+        } else {
+            hex = [m[2], m[3], m[4]].map((n) => Math.min(255, +n).toString(16).padStart(2, '0')).join('');
+        }
+        hex = '#' + hex.toLowerCase();
+        const r = parseInt(hex.slice(1, 3), 16), g = parseInt(hex.slice(3, 5), 16), b = parseInt(hex.slice(5, 7), 16);
+        const max = Math.max(r, g, b), min = Math.min(r, g, b);
+        const sat = max === 0 ? 0 : (max - min) / max;
+        // Cinza (pouca saturação), quase branco e quase preto não são
+        // identidade — são o papel e a tinta de todo site.
+        if (sat < 0.18 || max < 40 || (min > 225)) continue;
+        contagem.set(hex, (contagem.get(hex) || 0) + 1);
+    }
+}
+
+function fontesDe(html, css) {
+    const achadas = new Map();
+    // Google Fonts: family=Plus+Jakarta+Sans:wght@400;700&family=Inter
+    for (const m of html.matchAll(/fonts\.googleapis\.com\/css2?\?([^"' >]+)/gi)) {
+        for (const f of m[1].matchAll(/family=([^&:]+)/g)) {
+            const nome = decodeURIComponent(f[1].replace(/\+/g, ' ')).trim();
+            if (nome) achadas.set(nome, (achadas.get(nome) || 0) + 10);
+        }
+    }
+    // Para em ; } e aspas: o CSS aqui inclui atributos style="…" da página,
+    // e sem a aspa como fim o nome da fonte engolia o atributo seguinte
+    // (medido: 'sans-serif"  style="color:#7fa6ff').
+    for (const m of css.matchAll(/font-family\s*:\s*([^;}]+)/gi)) {
+        for (const parte of m[1].split(',')) {
+            const nome = parte.trim().replace(/\s*!important/, '').replace(/^["']|["']$/g, '').trim();
+            if (!nome || nome.length > 40 || GENERICAS_FONTE.test(nome) || /[(){}:="']/.test(nome)) continue;
+            achadas.set(nome, (achadas.get(nome) || 0) + 1);
+        }
+    }
+    return [...achadas.entries()].sort((a, b) => b[1] - a[1]).map(([n]) => n).slice(0, 3);
+}
+
+/** Descobre o site quando veio só o nome: o chute de domínio do referencia.js. */
+async function acharSite(nome) {
+    const palpites = referencia.sitesProvaveis(`site da empresa "${nome}"`);
+    const { vivos, html } = await referencia.chutesVivos(palpites, 1);
+    if (vivos.length) return { url: vivos[0].url, html: html.get(vivos[0].url) };
+    // Sem chute vivo, o buscador.
+    const achados = await referencia.buscar(`${nome} site oficial`, 4);
+    for (const a of achados) {
+        if (/wikipedia|linkedin|instagram|facebook|youtube|twitter|x\.com/i.test(a.url)) continue;
+        const h = await referencia.pegar(a.url, { timeout: 8000 });
+        if (h && h.length > 500) return { url: a.url, html: h };
+    }
+    return null;
+}
+
+/**
+ * A tool. `site` (URL) ou `nome` (a empresa). Devolve a identidade e a
+ * `marca` pronta para o documento do estúdio.
+ */
+async function marcaDaEmpresa(args, { projectDir, studio }) {
+    const nome = String(args.nome || args.empresa || '').trim();
+    let site = String(args.site || args.url || '').trim();
+    if (!nome && !site) return { ok: false, error: 'Diga o nome da empresa (nome) ou o endereço do site (site).' };
+    if (site && !/^https?:\/\//i.test(site)) site = 'https://' + site;
+
+    let html = null;
+    if (site) html = await referencia.pegar(site, { timeout: 12000 });
+    if (!html && site && !/\/\/www\./i.test(site)) {
+        const comWww = site.replace(/^(https?:\/\/)/i, '$1www.');
+        html = await referencia.pegar(comWww, { timeout: 12000 });
+        if (html) site = comWww;
+    }
+    if (!html && nome) {
+        const achado = await acharSite(nome);
+        if (achado) { site = achado.url; html = achado.html; }
+    }
+    if (!html) {
+        return {
+            ok: false,
+            error: `Não achei o site de "${nome || site}".`,
+            comoCorrigir: 'Se souber o endereço, chame de novo com site:"https://…". Se não, siga SEM a logo: '
+                + 'use o nome em texto na assinatura ("tipo":"assinatura","nome":…) e uma cor de tema — '
+                + 'e diga ao usuário que a logo não foi encontrada para ele mandar o arquivo (studio_midia).',
+        };
+    }
+
+    const m = metas(html);
+    const titulo = (html.match(/<title[^>]*>([\s\S]*?)<\/title>/i) || [])[1] || '';
+    // Sem og:site_name nem <title> (site montado por JavaScript), o nome vem
+    // do domínio: "nubank.com.br" → "Nubank". Melhor que campo vazio.
+    const dominio = ((site.match(/^https?:\/\/(?:www\.)?([^/]+)/i) || [])[1] || '').split('.')[0];
+    const nomeSite = (m['og:site_name'] || m['application-name'] || titulo.split(/\s[|–—-]\s|\s·\s/)[0] || nome
+        || (dominio ? dominio.charAt(0).toUpperCase() + dominio.slice(1) : '')).trim().slice(0, 80);
+    const frase = (m['description'] || m['og:description'] || '').trim().slice(0, 240);
+
+    // Cores: theme-color declarada, depois o CSS (inline + até 3 folhas).
+    const contagem = new Map();
+    let css = (html.match(/<style\b[^>]*>([\s\S]*?)<\/style>/gi) || []).join('\n');
+    // Só o MIOLO do style="…": com o `style="` junto, o fim de um atributo
+    // virava começo do nome da fonte seguinte (medido: 'sans-serif" style=…').
+    css += ' ' + (html.match(/\sstyle\s*=\s*"[^"]*"/gi) || []).map((a) => a.replace(/^\sstyle\s*=\s*"|"$/g, '')).join('; ');
+    const folhas = [];
+    for (const tag of html.match(/<link\b[^>]*>/gi) || []) {
+        if (/stylesheet/i.test(atributo(tag, 'rel') || '')) {
+            const u = absoluta(atributo(tag, 'href'), site);
+            if (u && !/fonts\.googleapis/i.test(u)) folhas.push(u);
+        }
+    }
+    const conteudos = await Promise.all(folhas.slice(0, 3).map((u) => referencia.pegar(u, { timeout: 8000 })));
+    for (const c of conteudos) if (c) css += '\n' + c.slice(0, 300000);
+    coresDe(css, contagem);
+    const paleta = [...contagem.entries()].sort((a, b) => b[1] - a[1]).map(([c]) => c).slice(0, 6);
+    let principal = null;
+    const tema = m['theme-color'];
+    if (tema && /^#?[0-9a-f]{3,8}$/i.test(tema.replace('#', ''))) {
+        const h = tema.replace('#', '').toLowerCase();
+        principal = '#' + (h.length === 3 ? h.split('').map((c) => c + c).join('') : h.slice(0, 6));
+        const r = parseInt(principal.slice(1, 3), 16), g = parseInt(principal.slice(3, 5), 16), b = parseInt(principal.slice(5, 7), 16);
+        const max = Math.max(r, g, b), min = Math.min(r, g, b);
+        if (max === 0 || (max - min) / max < 0.18 || min > 225) principal = null;   // theme-color branco/preto não é a cor da marca
+    }
+    if (!principal) principal = paleta[0] || null;
+
+    const fontes = fontesDe(html, css);
+
+    // A logo: tenta as candidatas em ordem até uma baixar de verdade.
+    let logo = null;
+    const candidatas = candidatasALogo(html, site);
+    const tentadas = [];
+    for (const c of candidatas.slice(0, 6)) {
+        const bytes = await referencia.pegar(c.url, { timeout: 10000, binario: true });
+        if (!bytes || bytes.length < 200) { tentadas.push(`${c.fonte}: não abriu`); continue; }
+        const cab = bytes.subarray(0, 16);
+        const ext = /^<\?xml|^<svg/i.test(bytes.subarray(0, 64).toString('utf8').trim()) ? '.svg'
+            : cab[0] === 0x89 && cab[1] === 0x50 ? '.png'
+                : cab[0] === 0xff && cab[1] === 0xd8 ? '.jpg'
+                    : cab.subarray(0, 4).toString() === 'RIFF' ? '.webp'
+                        : cab[0] === 0x00 && cab[1] === 0x00 && cab[2] === 0x01 && cab[3] === 0x00 ? '.ico'
+                            : cab.subarray(0, 3).toString() === 'GIF' ? '.gif' : null;
+        if (!ext) { tentadas.push(`${c.fonte}: não é imagem`); continue; }
+        if (ext === '.ico' && candidatas.length > 1 && c.fonte === 'favicon') { tentadas.push('favicon: só .ico'); }
+        const pasta = path.join(projectDir || process.cwd(), 'midia');
+        fs.mkdirSync(pasta, { recursive: true });
+        const arquivo = path.join(pasta, `logo-${nomeSite.toLowerCase().normalize('NFD').replace(/[̀-ͯ]/g, '').replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '') || 'marca'}${ext}`);
+        fs.writeFileSync(arquivo, bytes);
+        let url = null;
+        if (studio && ext !== '.ico') {
+            const envio = await studio.midiaEnviar({ arquivo });
+            if (envio && envio.ok !== false) url = envio.url;
+        }
+        logo = { url: url || null, arquivoLocal: path.relative(projectDir || process.cwd(), arquivo), origem: c.url, fonte: c.fonte, formato: ext.slice(1), bytes: bytes.length };
+        break;
+    }
+
+    const marca = {};
+    if (principal) marca.cor = principal;
+    if (logo && logo.url) marca.logo = logo.url;
+    return {
+        ok: true,
+        nome: nomeSite || nome,
+        site,
+        frase: frase || null,
+        cores: { principal, paleta },
+        fontes,
+        logo,
+        marca,
+        comoUsar: (Object.keys(marca).length
+            ? `No documento do estúdio: "marca": ${JSON.stringify(marca)}. `
+            : 'Sem cor nem logo confiáveis: use o nome em texto na assinatura e o tema pelo assunto. ')
+            + (fontes.length ? `Fonte da marca: ${fontes[0]} (o estúdio usa a do tema; cite a fonte só se for pedir código/HTML). ` : '')
+            + (logo && !logo.url && logo.formato === 'ico' ? 'A única logo encontrada foi o favicon .ico, que o estúdio não usa — peça o arquivo ao usuário se a peça for de marca. ' : '')
+            + (frase ? `Uma linha sobre a empresa, do próprio site: "${frase}".` : ''),
+        tentativasDeLogo: tentadas.length ? tentadas : undefined,
+    };
+}
+
+/* A MARCA EM LISTA VIRA OBJETO (13/10). O agente escreve a marca do jeito
+   que leu: "cores": ["#22d3ee", "#0a0b0b", …], "fontes": ["Instrument
+   Serif", "JetBrains Mono"]. O Estúdio lê {fundo, destaque, tinta} e
+   {titulo, texto, mono}. Sem a conversão, `cores.fundo` não existia, o
+   gerativo achava que não havia marca e sorteava o humor: o motion do
+   PrimoCode saiu vermelho e creme em Bodoni, com o site preto e ciano.
+     cores   a primeira escura é o fundo, a primeira viva o destaque (a
+             segunda, o apoio), a primeira clara a tinta;
+     fontes  a mono vai para mono; das outras, a 1ª é título e a 2ª texto.
+   O que já é objeto passa intacto. */
+function marcaEmObjeto(m) {
+    if (!m || typeof m !== 'object') return {};
+    const out = { ...m };
+    /* Objeto com OUTROS nomes ({primaria, neutras: […]}, visto em 13/10): sem
+       fundo/destaque/tinta, todas as cores dele viram a lista e são lidas por
+       luz e saturação, como a lista do agente. */
+    const papeis = ['fundo', 'destaque', 'tinta', 'apoio'];
+    if (m.cores && typeof m.cores === 'object' && !Array.isArray(m.cores) && !papeis.some((k) => m.cores[k])) {
+        const todas = [];
+        const juntar = (v) => { if (Array.isArray(v)) v.forEach(juntar); else if (v && typeof v === 'object') Object.values(v).forEach(juntar); else if (typeof v === 'string') todas.push(v); };
+        juntar(m.cores);
+        m = { ...m, cores: todas };
+    }
+    if (Array.isArray(m.cores)) {
+        const rgb = (h) => { const n = parseInt(h.slice(1), 16); return [n >> 16, (n >> 8) & 255, n & 255].map((v) => v / 255); };
+        const luz = (h) => { const [r, g, b] = rgb(h); return 0.2126 * r + 0.7152 * g + 0.0722 * b; };
+        const sat = (h) => { const v = rgb(h); return Math.max(...v) - Math.min(...v); };
+        const cs = m.cores.map((x) => String((x && x.cor) || x || '').trim()).filter((x) => /^#[0-9a-f]{6}$/i.test(x));
+        const vivas = cs.filter((x) => sat(x) > 0.25);
+        const fundo = cs.find((x) => luz(x) < 0.12 && sat(x) <= 0.25);
+        const tinta = cs.find((x) => luz(x) > 0.8 && sat(x) <= 0.25);
+        out.cores = { ...(fundo ? { fundo } : {}), ...(vivas[0] ? { destaque: vivas[0] } : {}), ...(vivas[1] ? { apoio: vivas[1] } : {}), ...(tinta ? { tinta } : {}) };
+    }
+    if (Array.isArray(m.fontes)) {
+        const fs = m.fontes.map((f) => String((f && f.nome) || f || '').trim()).filter(Boolean);
+        const mono = fs.find((f) => /mono|code|consol/i.test(f));
+        const resto = fs.filter((f) => f !== mono);
+        out.fontes = { ...(resto[0] ? { titulo: resto[0] } : {}), ...(resto[1] ? { texto: resto[1] } : {}), ...(mono ? { mono } : {}) };
+    }
+    return out;
+}
+
+/* OS ÍCONES DO SITE (13/10: "não usa os ícones do site"). Os ícones de uma
+   landing quase sempre são <svg> inline (o desenho de traço ao lado de cada
+   cartão), e não arquivos. Aqui saem os pequenos — com viewBox, sem imagem
+   nem script dentro, até 4 KB — com um nome: o aria-label, o <title>, ou o
+   título (h2/h3/h4) logo depois dele no HTML. No roteiro viram "site:N". */
+function iconesDoSite(html, max = 12) {
+    const out = [], vistos = new Set();
+    const re = /<svg\b[^>]*>[\s\S]*?<\/svg>/gi;
+    let m;
+    while ((m = re.exec(String(html || ''))) && out.length < max) {
+        const svg = m[0];
+        if (svg.length > 4000 || /<(image|script|foreignObject)\b/i.test(svg) || !/viewBox=/i.test(svg)) continue;
+        const abre = svg.slice(0, svg.indexOf('>') + 1);
+        const lado = Number((abre.match(/\b(?:width|height)=["']?(\d+)/i) || [])[1] || 0);
+        if (lado > 120) continue;
+        const corpo = svg.replace(/\s+/g, ' ');
+        if (vistos.has(corpo)) continue;
+        vistos.add(corpo);
+        const depois = String(html).slice(re.lastIndex, re.lastIndex + 500);
+        const nome = (abre.match(/aria-label=["']([^"']+)/i) || [])[1]
+            || (svg.match(/<title>([^<]+)<\/title>/i) || [])[1]
+            || ((depois.match(/<h[2-4][^>]*>([\s\S]*?)<\/h[2-4]>/i) || [])[1] || '').replace(/<[^>]+>/g, '').trim()
+            || '';
+        out.push({ nome: nome.slice(0, 40), svg });
+    }
+    return out;
+}
+
+/* AS CORES DE UMA IMAGEM (a referência que a pessoa manda: o print do site,
+   um frame, um anúncio de que gostou). O ffmpeg reduz a imagem a 160 px e
+   devolve os pixels; as cores parecidas viram uma, e saem as 6 que mais
+   aparecem, da mais comum à menos. Sem ffmpeg, lista vazia. */
+function coresDaImagem(arquivo, max = 6) {
+    const { spawnSync } = require('child_process');
+    const r = spawnSync('ffmpeg', ['-v', 'error', '-i', arquivo, '-vf', 'scale=160:-1', '-frames:v', '1', '-f', 'rawvideo', '-pix_fmt', 'rgb24', '-'], { maxBuffer: 1 << 22 });
+    if (r.status !== 0 || !r.stdout || !r.stdout.length) return [];
+    const conta = new Map();
+    for (let i = 0; i + 2 < r.stdout.length; i += 3) {
+        const k = ((r.stdout[i] >> 3) << 10) | ((r.stdout[i + 1] >> 3) << 5) | (r.stdout[i + 2] >> 3);
+        conta.set(k, (conta.get(k) || 0) + 1);
+    }
+    const hex = (k) => '#' + [(k >> 10) & 31, (k >> 5) & 31, k & 31].map((v) => (v * 8 + 4).toString(16).padStart(2, '0')).join('');
+    const rgb = (h) => [1, 3, 5].map((i) => parseInt(h.slice(i, i + 2), 16));
+    const longe = (a, b) => { const x = rgb(a), y = rgb(b); return Math.hypot(x[0] - y[0], x[1] - y[1], x[2] - y[2]); };
+    // As 4 mais comuns, e as 2 mais VIVAS que aparecem de verdade: a cor da
+    // marca costuma ocupar pouca área (o ciano de um título, o botão), e sem
+    // isto o print dava só fundo e cinza.
+    const total = r.stdout.length / 3;
+    const sat = (h) => { const v = rgb(h); return (Math.max(...v) - Math.min(...v)) / 255; };
+    const lista = [...conta].sort((a, b) => b[1] - a[1]).map(([k, n]) => ({ h: hex(k), n }));
+    const out = [];
+    const por = (x) => { if (out.length < max && out.every((o) => longe(o, x.h) > 48)) out.push(x.h); };
+    for (const x of lista) { if (out.length >= Math.max(1, max - 2)) break; por(x); }
+    /* As vivas se espalham em dezenas de tons de 1 ou 2 pixels (a borda da
+       letra mistura com o fundo): contam por MATIZ, em faixas de 30°, e de
+       cada faixa vale o pixel mais vivo — o miolo da letra, não a borda. */
+    const faixas = new Map();
+    for (let i = 0; i + 2 < r.stdout.length; i += 3) {
+        const v = [r.stdout[i], r.stdout[i + 1], r.stdout[i + 2]], mx = Math.max(...v), mn = Math.min(...v), d = mx - mn;
+        if (d / 255 < 0.35 || mx < 60) continue;
+        const hh = mx === v[0] ? ((v[1] - v[2]) / d) % 6 : mx === v[1] ? (v[2] - v[0]) / d + 2 : (v[0] - v[1]) / d + 4;
+        const f = Math.floor(((hh * 60 + 360) % 360) / 30);
+        const x = faixas.get(f) || { n: 0, melhor: null, nota: -1 };
+        x.n++;
+        const nota = d * mx;
+        if (nota > x.nota) { x.nota = nota; x.melhor = '#' + v.map((c) => c.toString(16).padStart(2, '0')).join(''); }
+        faixas.set(f, x);
+    }
+    [...faixas.values()].filter((x) => x.n >= Math.max(8, total * 0.0005)).sort((a, b) => b.n - a.n).slice(0, 2).forEach((x) => por({ h: x.melhor }));
+    void sat; void lista;
+    return out;
+}
+
+module.exports = { marcaDaEmpresa, candidatasALogo, coresDe, fontesDe, metas, atributo, marcaEmObjeto, iconesDoSite, coresDaImagem };

package/lib/plugin/estudio/materiais.js

@@ -0,0 +1,218 @@
+/**
+ * materiais.js — peças soltas por estilo. A IA monta o vídeo DO ZERO.
+ *
+ * Um estilo migrado tem `materiais/<estilo>/` com só peças (formas, texturas, transições, tipografia, câmera, sons),
+ * a paleta, as regras e o índice `pecas.json`. Não existe Montagem, receita nem plano pronto: a IA lista as peças,
+ * lê as que quer, escreve a cena nova (TSX) e o conferir cobra a densidade mínima.
+ *
+ *   primocode kit pecas <estilo>                 as peças (nome · o que é · params · duração)
+ *   primocode kit pecas <estilo> ver <peça>      o código da peça (ou os dados do áudio)
+ *   primocode kit pecas <estilo> regras          as regras e a densidade mínima
+ *   primocode kit pecas <estilo> escrever <nome> --arquivo <cena.tsx>   grava a cena em motion/ e confere
+ *   primocode kit pecas <estilo> conferir <cena.tsx>
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const RAIZ = path.join(__dirname, '..', '..', '..', 'materiais');
+const CATEGORIAS = ['formas', 'texturas', 'transicoes', 'tipografia', 'camera', 'sons', 'trilha', 'paleta'];
+/** Nada disto pode existir como peça, nem ser lido nem importado no caminho da IA. */
+const PROIBIDO = /(^|[\\/'"._-])(Montagem|receita|plano)(\.(tsx?|jsx?|json))?(['"]|$)|Montagem\.tsx|receita\.json|plano\.json/;
+const MINIMO = { camadas: 4, pecasDiferentes: 6, chavesCamera: 4, efeitosPorCorte: 1, movimentoPorSegundo: 5 };
+
+/** Estilos que a pessoa criou (primocode kit criar) ficam em ~/.primocode/materiais; os do pacote em materiais/. */
+const raizUsuario = () => process.env.PRIMOCODE_MATERIAIS_USUARIO || path.join(require('os').homedir(), '.primocode', 'materiais');
+const nomeSeguro = (estilo) => String(estilo || '').replace(/[^a-z0-9-]/gi, '');
+/** `raiz` explícita (testes) manda; sem ela, o pacote primeiro e depois a pasta da pessoa. */
+const pastaDe = (estilo, raiz) => {
+    if (raiz) return path.join(raiz, nomeSeguro(estilo));
+    const pacote = path.join(RAIZ, nomeSeguro(estilo));
+    if (fs.existsSync(path.join(pacote, 'pecas.json'))) return pacote;
+    const dela = path.join(raizUsuario(), nomeSeguro(estilo));
+    return fs.existsSync(path.join(dela, 'pecas.json')) ? dela : pacote;
+};
+
+/** O estilo foi migrado pra peças soltas? */
+function migrado(estilo, raiz) { return !!estilo && fs.existsSync(path.join(pastaDe(estilo, raiz), 'pecas.json')); }
+function estilos(raiz) {
+    const de = (r) => { try { return fs.readdirSync(r, { withFileTypes: true }).filter((d) => d.isDirectory() && migrado(d.name, r)).map((d) => d.name); } catch { return []; } };
+    return raiz ? de(raiz) : [...new Set([...de(RAIZ), ...de(raizUsuario())])];
+}
+
+function ler(estilo, raiz) {
+    try { return JSON.parse(fs.readFileSync(path.join(pastaDe(estilo, raiz), 'pecas.json'), 'utf8')); } catch { return null; }
+}
+
+/** Confere o índice: campos, arquivos que existem, nenhuma peça que seja cena/vídeo pronto. Devolve a lista de erros. */
+function validar(estilo, raiz) {
+    const erros = [];
+    const idx = ler(estilo, raiz);
+    if (!idx) return [`materiais/${estilo}/pecas.json ausente ou inválido`];
+    const base = pastaDe(estilo, raiz);
+    if (!Array.isArray(idx.pecas) || !idx.pecas.length) return ['pecas.json sem peças'];
+    const nomes = new Set();
+    for (const p of idx.pecas) {
+        const q = `peça "${p && p.nome}"`;
+        if (!p || !p.nome || !p.categoria || !p.arquivo || !p.descricao) { erros.push(`${q}: faltam nome, categoria, arquivo ou descricao`); continue; }
+        if (nomes.has(p.nome)) erros.push(`${q}: nome repetido`);
+        nomes.add(p.nome);
+        if (!CATEGORIAS.includes(p.categoria)) erros.push(`${q}: categoria "${p.categoria}" fora de ${CATEGORIAS.join(', ')}`);
+        if (!Array.isArray(p.params)) erros.push(`${q}: params precisa ser lista`);
+        if (p.duracao != null && !(Array.isArray(p.duracao) && p.duracao.length === 2 && p.duracao[0] <= p.duracao[1])) erros.push(`${q}: duracao é null ou [min, max]`);
+        if (!Array.isArray(p.tags)) erros.push(`${q}: tags precisa ser lista`);
+        if (/\n/.test(p.descricao) || p.descricao.length > 200) erros.push(`${q}: a descrição é de uma linha (até 200 caracteres)`);
+        if (PROIBIDO.test(p.arquivo) || PROIBIDO.test(p.nome)) erros.push(`${q}: peça não pode ser Montagem, receita ou plano`);
+        const arq = path.join(base, p.arquivo);
+        if (!arq.startsWith(base + path.sep)) erros.push(`${q}: arquivo fora da pasta do estilo`);
+        else if (!fs.existsSync(arq)) erros.push(`${q}: arquivo ${p.arquivo} não existe`);
+        else if (/\.tsx?$/.test(arq) && fs.readFileSync(arq, 'utf8').split('\n').length > 140) erros.push(`${q}: arquivo grande demais pra ser uma peça (mais de 140 linhas)`);
+    }
+    for (const f of ['regras.md', 'cores/paleta.json', 'cores/paleta.png']) if (!fs.existsSync(path.join(base, f))) erros.push(`falta ${f}`);
+    return erros;
+}
+
+const linha = (p) => `- ${p.nome} [${p.categoria}] ${p.descricao} | params: ${(p.params || []).join(', ') || '-'} | duração: ${p.duracao ? p.duracao.join('-') + ' quadros' : 'contínua'} | tags: ${(p.tags || []).join(', ')}`;
+
+function listar(estilo, raiz) {
+    const idx = ler(estilo, raiz);
+    if (!idx) return { ok: false, texto: `O estilo "${estilo}" não tem peças soltas. Migrados: ${estilos(raiz).join(', ') || 'nenhum'}.` };
+    const porCat = {};
+    for (const p of idx.pecas) (porCat[p.categoria] = porCat[p.categoria] || []).push(p);
+    const out = [`# Peças de ${idx.estilo} (${idx.pecas.length}): só peças soltas, nenhuma cena pronta.`,
+        `Leia as regras (primocode kit pecas ${estilo} regras), leia as peças que vai usar (… ver <peça>), escreva a cena NOVA e grave (… escrever <nome> --arquivo <cena.tsx>).`, ''];
+    for (const c of CATEGORIAS) if (porCat[c]) out.push(`## ${c}`, ...porCat[c].map(linha), '');
+    return { ok: true, texto: out.join('\n').trim() };
+}
+
+function lerPeca(estilo, nome, raiz) {
+    const idx = ler(estilo, raiz);
+    const p = idx && idx.pecas.find((x) => x.nome.toLowerCase() === String(nome || '').toLowerCase());
+    if (!p) return { ok: false, texto: `Peça "${nome}" não existe em ${estilo}. Veja: primocode kit pecas ${estilo}` };
+    const arq = path.join(pastaDe(estilo, raiz), p.arquivo);
+    const cab = linha(p);
+    if (/\.(mp3|wav)$/.test(arq)) return { ok: true, texto: `${cab}\narquivo de áudio: ${p.arquivo} (toque com <Efeito som="${p.nome}" em={quadro}/> ou <Trilha/>; volume sugerido ${p.volumeSugerido ?? '-'})`, peca: p };
+    return { ok: true, texto: `${cab}\nimport: ${p.arquivo.replace(/\.tsx?$/, '')}\n\n${fs.readFileSync(arq, 'utf8')}`, peca: p };
+}
+
+function regras(estilo, raiz) {
+    try { return { ok: true, texto: fs.readFileSync(path.join(pastaDe(estilo, raiz), 'regras.md'), 'utf8') }; } catch { return { ok: false, texto: `Sem regras para ${estilo}.` }; }
+}
+
+/** O texto que entra no prompt da IA pra um estilo migrado (no lugar do `kit ver`). */
+function promptDoEstilo(estilo, raiz) {
+    const l = listar(estilo, raiz);
+    if (!l.ok) return l.texto;
+    return [`ESTILO ${estilo}: montagem a partir de peças soltas. Você COMPÕE a cena do zero; não há vídeo, receita nem plano pronto pra copiar.`,
+        'Passos: 1) leia o pedido e o roteiro; 2) escreva o plano da cena (linha do tempo em quadros, camadas, chaves de câmera, cues de som); 3) leia as peças que vai usar;',
+        '4) escreva UM arquivo TSX com a composição nova: import só do remotion e das peças, no caminho `./pecas/<categoria>/<Peça>` (ex.: `import {Agenda} from "./pecas/formas/Agenda"`, `import {e4} from "./pecas/base"`); exporte `Video` (componente) e `DURACAO` (quadros); 5) grave com `escrever`, que confere a densidade; 6) conserte o que o conferir apontar; 7) renderize.',
+        '', l.texto, '', `## referência (só pra OLHAR, nunca reaproveitar): ${path.join(pastaDe(estilo, raiz), 'referencia')}: referencia.mp4, quadro-1..4.png e analise.md (linha do tempo, câmera, easing, cortes na batida, peças de cada momento). Leia a análise e abra os quadros; a cena é escrita do zero.`, '', `## regras: leia ANTES de escrever a cena (identidade, movimento extravagante, som em camadas, densidade mínima): primocode kit pecas ${estilo} regras`].join('\n');
+}
+
+/**
+ * Densidade de movimento: quantos elementos se mexem ao mesmo tempo, em média, por segundo da linha do tempo.
+ * Lê a cena como texto: peças fora de qualquer <Cena> (fundo, partículas, câmera, moldura) valem o vídeo inteiro;
+ * peças dentro de uma <Cena de={a} ate={b}> valem só os quadros dela. Cada chave de câmera conta como um movimento
+ * no segundo em que cai. Áudio (Efeito, Trilha) não conta. Devolve { porSegundo, segundos, minimoPorSegundo }.
+ */
+function densidadeMovimento(src, idx, fps = 30) {
+    const ignora = new Set(['Efeito', 'Trilha', 'Cena', 'Fragment']);
+    const sons = new Set(idx.pecas.filter((p) => p.categoria === 'sons').map((p) => p.nome));
+    const conta = (trecho) => [...trecho.matchAll(/<([A-Z]\w*)\b/g)].filter((m) => !ignora.has(m[1]) && !sons.has(m[1]) && /^[A-Z]/.test(m[1])).length;
+    const abre = [...src.matchAll(/<Cena\b([^>]*)>/g)];
+    const fim = Math.max(0, ...[...src.matchAll(/\bDURACAO\s*=\s*(\d+)/g)].map((m) => +m[1])) || Math.max(0, ...abre.map((m) => +((m[1].match(/\bate=\{\s*(\d+)/) || [])[1] ?? 0)));
+    const total = fim || 0;
+    // intervalos das cenas
+    const cenas = [];
+    for (const m of abre) {
+        const ini = m.index + m[0].length;
+        const f = src.indexOf('</Cena>', ini);
+        const de = +((m[1].match(/\bde=\{\s*(\d+)/) || [])[1] ?? NaN), ate = +((m[1].match(/\bate=\{\s*(\d+)/) || [])[1] ?? NaN);
+        cenas.push({ ini: m.index, fim: f < 0 ? src.length : f, dentro: conta(src.slice(ini, f < 0 ? src.length : f)), quadros: ate - de });
+    }
+    let fora = src;
+    for (const c of [...cenas].reverse()) fora = fora.slice(0, c.ini) + fora.slice(c.fim + 7);
+    const globais = conta(fora);
+    const quadrosCenas = cenas.filter((c) => c.quadros > 0).reduce((a, c) => a + c.quadros, 0);
+    const base = total || quadrosCenas || fps;
+    const somaCenas = cenas.filter((c) => c.quadros > 0).reduce((a, c) => a + c.dentro * c.quadros, 0);
+    const chaves = (src.match(/\{\s*em\s*:/g) || []).length;
+    const segundos = base / fps;
+    const porSegundo = globais + somaCenas / base + chaves / Math.max(1, segundos);
+    return { porSegundo: Math.round(porSegundo * 10) / 10, segundos: Math.round(segundos * 10) / 10 };
+}
+
+const SEM_COMENTARIO = (s) => s.replace(/\/\*[\s\S]*?\*\//g, '').replace(/(^|[^:])\/\/.*$/gm, '$1');
+
+/**
+ * Conferir uma cena escrita pela IA (estático, sem render). Cobra: só importa peças do estilo, nada de Montagem/receita/plano,
+ * camadas, peças diferentes, chaves de câmera, SFX em todo corte, trilha. Devolve {ok, erros, medidas}.
+ */
+function conferirCena(estilo, codigo, raiz) {
+    const idx = ler(estilo, raiz);
+    const erros = [];
+    if (!idx) return { ok: false, erros: [`estilo ${estilo} sem peças`], medidas: {} };
+    const src = SEM_COMENTARIO(String(codigo || ''));
+    if (PROIBIDO.test(src)) erros.push('a cena não pode usar Montagem, receita nem plano: componha as peças direto');
+    const nomes = new Set(idx.pecas.map((p) => p.nome));
+    const usadas = new Set();
+    for (const m of src.matchAll(/import\s+(?:type\s+)?(?:\{([^}]*)\}|(\w+))\s+from\s+['"]([^'"]+)['"]/g)) {
+        const de = m[3];
+        if (/^(react|remotion)(\/|$)/.test(de)) continue;
+        if (!/(^|\/)(formas|texturas|transicoes|tipografia|camera|sons)\/|(^|\/)base$|(^|\/)paleta/.test(de) && !/\.(json|mp3|svg|png|jpg)$/.test(de)) { erros.push(`import fora das peças: "${de}"`); continue; }
+        for (const n of (m[1] || m[2] || '').split(',').map((x) => x.trim().split(/\s+as\s+/)[0]).filter(Boolean)) if (nomes.has(n)) usadas.add(n);
+    }
+    const cenas = (src.match(/<Cena\b/g) || []).length;
+    const cortes = Math.max(0, cenas - 1);
+    const efeitos = (src.match(/<Efeito\b/g) || []).length;
+    const chaves = (src.match(/\{\s*em\s*:/g) || []).length;
+    const camadasPorCena = cenas ? Math.round(([...usadas].filter((n) => !['Cena', 'Camera', 'CameraDeriva', 'Som'].includes(n)).length)) : 0;
+    const dens = densidadeMovimento(src, idx);
+    const medidas = { cenas, cortes, efeitos, chavesCamera: chaves, pecasDiferentes: usadas.size, camadas: camadasPorCena, movimentoPorSegundo: dens.porSegundo, segundos: dens.segundos };
+    if (!/<Camera\w*\b/.test(src)) erros.push('falta <Camera> (a câmera nunca para)');
+    if (!/<Trilha\b/.test(src)) erros.push('falta <Trilha> (trilha forte sempre)');
+    if (cenas < 2) erros.push('use ao menos 2 <Cena> (um vídeo é uma sequência de cenas)');
+    if (usadas.size < MINIMO.pecasDiferentes) erros.push(`só ${usadas.size} peças diferentes; mínimo ${MINIMO.pecasDiferentes}`);
+    if (camadasPorCena < MINIMO.camadas) erros.push(`só ${camadasPorCena} tipos de camada; mínimo ${MINIMO.camadas} (fundo, partículas, herói, apoio)`);
+    if (chaves < MINIMO.chavesCamera) erros.push(`só ${chaves} chaves de câmera; mínimo ${MINIMO.chavesCamera}`);
+    if (dens.porSegundo < MINIMO.movimentoPorSegundo) erros.push(`só ${dens.porSegundo} elementos em movimento por segundo; mínimo ${MINIMO.movimentoPorSegundo} (some partículas, fundo vivo, apoios e chaves de câmera)`);
+    if (efeitos < cortes * MINIMO.efeitosPorCorte) erros.push(`${efeitos} <Efeito> para ${cortes} cortes: SFX em todo corte (alvo 2 por corte)`);
+    return { ok: !erros.length, erros, medidas };
+}
+
+/** Grava a cena em <pasta>/motion/<nome>.tsx (com as peças ao lado, em motion/pecas/) e confere. */
+function escreverCena(estilo, pasta, nome, codigo, raiz) {
+    const slug = String(nome || '').toLowerCase().replace(/[^a-z0-9-]+/g, '-').replace(/^-+|-+$/g, '');
+    if (!slug) return { ok: false, texto: 'Dê um nome à cena: … escrever <nome> --arquivo <cena.tsx>' };
+    const c = conferirCena(estilo, codigo, raiz);
+    const proibido = c.erros.some((e) => /Montagem|receita|plano|import fora/.test(e));
+    if (proibido) return { ok: false, texto: `Cena recusada:\n- ${c.erros.join('\n- ')}`, ...c };
+    const dir = path.join(pasta, 'motion');
+    fs.mkdirSync(dir, { recursive: true });
+    const arq = path.join(dir, `${slug}.tsx`);
+    fs.writeFileSync(arq, codigo);
+    const texto = c.ok ? `Cena gravada em ${arq}. Conferida: ${JSON.stringify(c.medidas)}.`
+        : `Cena gravada em ${arq}, mas NÃO passou no conferir; conserte e grave de novo:\n- ${c.erros.join('\n- ')}`;
+    return { ok: true, passou: c.ok, texto, arquivo: arq, ...c };
+}
+
+/** Copia as peças do estilo pra <dir>/pecas e escreve a entrada do render que registra a cena da IA. */
+function prepararRender(estilo, dir, arqCena, { duracao, raiz } = {}) {
+    fs.mkdirSync(dir, { recursive: true });
+    const alvo = path.join(dir, 'pecas');
+    fs.rmSync(alvo, { recursive: true, force: true });
+    fs.cpSync(pastaDe(estilo, raiz), alvo, { recursive: true, filter: (src) => !/[\\/]referencia([\\/]|$)/.test(src) });
+    fs.copyFileSync(arqCena, path.join(dir, 'Cena-ia.tsx'));
+    fs.writeFileSync(path.join(dir, 'entrada.tsx'), `// gerado por lib/plugin/estudio/materiais.js
+import React from 'react';
+import {Composition, registerRoot} from 'remotion';
+import {Video, DURACAO} from './Cena-ia';
+const Raiz: React.FC = () => <Composition id="Video" component={Video as React.FC} durationInFrames={${duracao || 'DURACAO'}} fps={30} width={1080} height={1920} />;
+registerRoot(Raiz);
+`);
+    return { dir, entrada: path.join(dir, 'entrada.tsx') };
+}
+
+module.exports = { pastaDe, densidadeMovimento, RAIZ, CATEGORIAS, MINIMO, PROIBIDO, migrado, estilos, ler, validar, listar, lerPeca, regras, promptDoEstilo, conferirCena, escreverCena, prepararRender };