primocode 10.12.0 → 10.14.0

package/lib/estudio/kokoro.js

@@ -94,7 +94,9 @@ async function narrar(lista, mp3, { voz, uv, espeak = acharEspeak(), executar =
     roteiro pula as outras. */
 function ordem(voz, env = process.env, { soEdge = false } = {}) {
     if (soEdge) return ['edge'];
-    return querKokoro(voz, env) ? ['kokoro', 'edge'] : ['gemini', 'edge', 'kokoro'];
+    if (querKokoro(voz, env)) return ['kokoro', 'edge'];
+    // O VoiceStudio local vem primeiro (15/10); fechado, a cadeia segue para o Gemini na hora.
+    return env.PRIMOCODE_SEM_VOICESTUDIO ? ['gemini', 'edge', 'kokoro'] : ['voicestudio', 'gemini', 'edge', 'kokoro'];
 }
 
 /* A voz do Gemini no Edge: o narrar.py só conhece antonio, francisca e

package/lib/estudio/maquina-diretor.js

@@ -0,0 +1,393 @@
+/**
+ * maquina-diretor.js — o diretor do estudio_motion: do assunto a UMA direção própria, nunca um molde.
+ *
+ * O vocabulário (primitivas de cena, transições, estilos de câmera, sistemas tipográficos) vem das 68
+ * receitas do Clube e dos scripts AE dos 5 projetos. O modelo escolhe pelo JSON (tipo da cena, transições,
+ * câmera, tipografia, metáfora). O diretor COMPLETA o que faltar, com uma semente por vídeo, e confere a
+ * ASSINATURA do vídeo contra os últimos (~/.primocode/studio/assinaturas.json): se parece demais, sorteia de novo.
+ *
+ *   dirigir(args, {historico, semente}) → { metafora, semente, cenas, trocas, camera, tipografia, ritmo, paleta, assinatura }
+ *   similaridade(a, b)                  → 0..1
+ *   lerHistorico() / registrar(assinatura)
+ */
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+// ── o vocabulário ────────────────────────────────────────────────────────
+
+/** As primitivas: família (para não pôr duas iguais em fila), papéis em que servem e o que exigem. */
+const PRIMITIVAS = {
+    gancho: { fam: 'texto', entra: 1.4, papeis: ['gancho', 'cta', 'virada'], dur: 2.4 },
+    cinetico: { fam: 'texto', entra: 2.2, papeis: ['gancho', 'virada', 'cta'], dur: 2.6 },
+    particulas: { fam: 'texto', entra: 1.3, papeis: ['gancho', 'virada'], dur: 2.6 },
+    odometro: { fam: 'texto', entra: 2.4, papeis: ['gancho', 'virada'], dur: 3.0, itens: 3 },
+    citacao: { fam: 'texto', entra: 2.2, papeis: ['prova', 'virada'], dur: 2.8 },
+    cta: { fam: 'texto', entra: 1.1, papeis: ['cta'], dur: 2.8 },
+    carimbo: { fam: 'objeto', entra: 2.3, papeis: ['virada', 'prova', 'cta'], dur: 2.6 },
+    revela: { fam: 'objeto', entra: 1.5, papeis: ['gancho', 'virada', 'processo'], dur: 2.8, elemento: true },
+    heroi: { fam: 'objeto', entra: 2.5, papeis: ['gancho', 'processo', 'virada'], dur: 3.0, elemento: true },
+    explosao: { fam: 'objeto', entra: 1.8, papeis: ['processo', 'virada'], dur: 3.0, elemento: true, itens: 3 },
+    icones: { fam: 'objeto', entra: 1.7, papeis: ['processo'], dur: 2.8, itens: 3 },
+    leque: { fam: 'objeto', entra: 1.4, papeis: ['processo', 'prova'], dur: 3.0, elemento: true, itens: 3 },
+    parede_logos: { fam: 'objeto', entra: 1.3, papeis: ['prova', 'virada'], dur: 2.6, elemento: true },
+    celular: { fam: 'device', entra: 2.3, papeis: ['processo', 'prova'], dur: 3.4 },
+    mergulho: { fam: 'device', entra: 1.2, papeis: ['virada', 'processo'], dur: 3.2, elemento: true },
+    notificacoes: { fam: 'device', entra: 2.2, papeis: ['problema', 'prova', 'processo'], dur: 3.2, itens: 3 },
+    chat: { fam: 'device', entra: 1.8, papeis: ['problema', 'processo', 'prova'], dur: 3.4, itens: 3 },
+    interface: { fam: 'tela', entra: 1.7, papeis: ['processo', 'prova', 'gancho'], dur: 3.2, itens: 3 },
+    cursor: { fam: 'tela', entra: 3.4, papeis: ['processo'], dur: 3.6 },
+    prompt: { fam: 'tela', entra: 3.4, papeis: ['processo', 'gancho'], dur: 4.0, itens: 3 },
+    rolagem: { fam: 'tela', entra: 1.8, papeis: ['problema', 'prova'], dur: 3.0, elemento: true, itens: 3 },
+    numero: { fam: 'dados', entra: 2.0, papeis: ['prova', 'virada'], dur: 2.6 },
+    barras: { fam: 'dados', entra: 2.4, papeis: ['prova', 'problema'], dur: 3.0, itens: 4 },
+    linha: { fam: 'dados', entra: 2.5, papeis: ['prova', 'problema'], dur: 3.0 },
+    medidor: { fam: 'dados', entra: 2.5, papeis: ['prova', 'virada'], dur: 3.0 },
+    calendario: { fam: 'dados', entra: 1.7, papeis: ['problema', 'prova', 'processo'], dur: 3.0 },
+    funil: { fam: 'dados', entra: 2.4, papeis: ['processo', 'prova', 'problema'], dur: 3.4, itens: 3 },
+    relogio: { fam: 'dados', entra: 2.2, papeis: ['problema', 'gancho', 'virada'], dur: 3.0 },
+    lista: { fam: 'lista', entra: 2.1, papeis: ['processo', 'prova'], dur: 2.8, itens: 3 },
+    cards_pulam: { fam: 'lista', entra: 2.2, papeis: ['processo', 'problema', 'prova'], dur: 3.0, elemento: true, itens: 3 },
+    laco: { fam: 'fluxo', entra: 1.7, papeis: ['processo'], dur: 3.4, elemento: true, itens: 3 },
+    linha_tempo: { fam: 'fluxo', entra: 1.9, papeis: ['processo', 'prova'], dur: 3.2, itens: 3 },
+    camera_nulls: { fam: 'fluxo', entra: 3.0, papeis: ['processo'], dur: 3.6, elemento: true, itens: 3 },
+    mapa: { fam: 'lugar', entra: 2.7, papeis: ['problema', 'prova', 'processo'], dur: 3.0, itens: 3 },
+    split: { fam: 'comparacao', entra: 2.6, papeis: ['problema', 'virada'], dur: 3.2, elemento: true },
+    ondas: { fam: 'som', entra: 1.0, papeis: ['gancho', 'processo', 'virada'], dur: 2.8, elemento: true },
+    estrelas: { fam: 'social', entra: 2.7, papeis: ['prova'], dur: 3.2, elemento: true },
+};
+const TIPOS = Object.keys(PRIMITIVAS);
+
+const TRANSICOES = ['encolhe', 'empurra', 'zoom', 'persiana', 'chicote', 'desfoque', 'cortina', 'giro', 'tremor', 'abre', 'dissolve', 'corte'];   // sem íris/pontos: o círculo claro crescendo parecia flash
+const CAMERAS = ['deriva', 'pulso', 'trilho', 'orbita', 'push', 'chicote', 'cinema'];   // sem câmera na mão: tremedeira fora
+
+/** Sistemas tipográficos: fontes + como a palavra entra + como a palavra-chave é realçada. */
+const TIPOGRAFIAS = {
+    editorial: { fontes: { titulo: 'Poppins', texto: 'Plus Jakarta Sans', destaque: 'Playfair Display' }, entrada: 'palavra', realce: 'italico', passo: 0.1 },
+    poster: { fontes: { titulo: 'Anton', texto: 'Barlow Condensed', destaque: 'Anton' }, entrada: 'mascara', realce: 'caixa', caixa: 'alta', passo: 0.12, entreLinhas: 1.02 },
+    tecnica: { fontes: { titulo: 'Space Grotesk', texto: 'JetBrains Mono', destaque: 'Space Grotesk' }, entrada: 'letra', realce: 'sublinha', passo: 0.16, tracking: -10 },
+    manuscrita: { fontes: { titulo: 'Poppins', texto: 'Nunito', destaque: 'Caveat' }, entrada: 'sobe', realce: 'cor', passo: 0.1 },
+    pesada: { fontes: { titulo: 'Archivo Black', texto: 'Inter', destaque: 'Archivo Black' }, entrada: 'palavra', realce: 'caixa', passo: 0.09 },
+    serifa_fina: { fontes: { titulo: 'Instrument Serif', texto: 'Manrope', destaque: 'Instrument Serif' }, entrada: 'mascara', realce: 'italico', passo: 0.14, entreLinhas: 1.05 },
+    arredondada: { fontes: { titulo: 'Fredoka', texto: 'Nunito', destaque: 'Fredoka' }, entrada: 'sobe', realce: 'cor', passo: 0.1 },
+    geometrica: { fontes: { titulo: 'Outfit', texto: 'DM Sans', destaque: 'Outfit' }, entrada: 'sobe', realce: 'sublinha', passo: 0.08 },
+};
+
+// ── as metáforas: o que o assunto É, e o que ele pede ───────────────────
+
+const PALETAS = {
+    forno: { fundo: '#FFF1DC', tinta: '#3B1F0E', destaque: '#E8590C' },
+    rose: { fundo: '#FBEEE8', tinta: '#3A2230', destaque: '#D9486B' },
+    grafite: { fundo: '#0F1412', tinta: '#F2F5EF', destaque: '#C8F03C' },
+    floresta: { fundo: '#14301F', tinta: '#EDF5E4', destaque: '#F2B544' },
+    petroleo: { fundo: '#0E3B43', tinta: '#FFF4E6', destaque: '#FF8A5B' },
+    coral: { fundo: '#FFF6F0', tinta: '#1A1A1A', destaque: '#FF4B2B' },
+    tijolo: { fundo: '#F4E4D2', tinta: '#2B1710', destaque: '#B5472C' },
+    menta: { fundo: '#E6F4EC', tinta: '#12332A', destaque: '#0F9D6B' },
+    ouro: { fundo: '#111111', tinta: '#F6EBD0', destaque: '#E3B23C' },
+    limao: { fundo: '#FFF9C9', tinta: '#1B1B12', destaque: '#E5481E' },
+    mar: { fundo: '#0B2B33', tinta: '#EAF6F3', destaque: '#35D0BA' },
+};
+
+const METAFORAS = {
+    padaria: {
+        re: /p[aã]o|padaria|forno|confeit|bolo|caf[eé]|cozinha|restaurante|doce|pizza|lanche|hamb|sorvete|a[cç]a[ií]/i,
+        nome: 'forno que acorda a rua',
+        elementos: ['bread', 'croissant', 'alarm clock', 'hot beverage', 'cooking'],
+        animado: ['fire'], termos2d: [],
+        paletas: ['forno', 'tijolo', 'limao'],
+        nao: ['interface', 'prompt', 'cursor', 'rolagem', 'funil', 'medidor', 'parede_logos', 'camera_nulls', 'mergulho', 'laco', 'linha', 'ondas'],
+        prefere: { relogio: 3, heroi: 3, mapa: 2, estrelas: 2, cards_pulam: 2, explosao: 2, revela: 2, carimbo: 2, calendario: 1.5, leque: 2, particulas: 2, interface: 0.4, prompt: 0.2, cursor: 0.3, funil: 0.5, camera_nulls: 0.7 },
+        cameras: ['push', 'cinema', 'deriva'], tipografias: ['editorial', 'manuscrita', 'serifa_fina', 'arredondada'],
+        trocas: ['zoom', 'desfoque', 'encolhe', 'dissolve', 'cortina'],
+        musica: 'warm acoustic happy', itens: ['Pão francês', 'Croissant', 'Café coado', 'Bolo caseiro'],
+    },
+    clinica: {
+        re: /cl[ií]nica|est[eé]tica|beleza|sal[aã]o|cabelo|unha|spa|pele|sa[uú]de|m[eé]dic|dent|cliente|agenda|sumid|recuper/i,
+        nome: 'agenda que volta a encher',
+        elementos: ['calendar', 'speech balloon', 'sparkles', 'lotion bottle', 'heart', 'woman getting massage'],
+        animado: ['sparkles'], termos2d: [],
+        paletas: ['rose', 'menta', 'coral'],
+        nao: ['prompt', 'cursor', 'parede_logos', 'camera_nulls', 'ondas', 'mergulho'],
+        prefere: { calendario: 3, notificacoes: 3, chat: 3, funil: 2.5, split: 2.5, mapa: 1.5, estrelas: 2, barras: 1.5, linha: 1.5, cards_pulam: 1.5, relogio: 1, interface: 0.6, prompt: 0.3, cursor: 0.4, heroi: 1 },
+        cameras: ['trilho', 'orbita', 'deriva', 'pulso'], tipografias: ['serifa_fina', 'geometrica', 'editorial', 'arredondada'],
+        trocas: ['persiana', 'abre', 'desfoque', 'dissolve', 'cortina'],
+        musica: 'soft piano calm', itens: ['Lembrete enviado', 'Cliente respondeu', 'Horário confirmado', 'Retorno agendado'],
+    },
+    financas: {
+        re: /finan|dinheiro|invest|banco|cr[eé]dito|gasto|or[cç]amento|cart[aã]o|poupan|moeda|economi|controle/i,
+        nome: 'extrato que vira jogo ganho',
+        elementos: ['money bag', 'coin', 'credit card', 'chart increasing', 'bank', 'piggy bank'],
+        animado: ['money-with-wings'], termos2d: [],
+        paletas: ['floresta', 'ouro', 'mar'],
+        nao: ['mapa', 'relogio', 'ondas', 'leque', 'revela', 'particulas', 'prompt'],
+        prefere: { barras: 3, linha: 3, medidor: 3, numero: 2.5, funil: 2, calendario: 2, odometro: 2.5, cards_pulam: 2, interface: 2, notificacoes: 2, relogio: 0.6, mapa: 0.5, estrelas: 1, heroi: 1.5, carimbo: 1.5 },
+        cameras: ['pulso', 'trilho', 'push', 'orbita'], tipografias: ['tecnica', 'geometrica', 'pesada', 'poster'],
+        trocas: ['tremor', 'corte', 'chicote', 'empurra', 'zoom'],
+        musica: 'lofi upbeat chill', itens: ['Salário', 'Contas', 'Reserva', 'Sobra'],
+    },
+    software: {
+        re: /app\b|saas|software|c[oó]digo|program|tecnolog|\bia\b|intelig|primocode|sistema|plataforma|dados|site|digital|startup|sem saber/i,
+        nome: 'tela que se monta sozinha',
+        elementos: ['rocket', 'laptop', 'robot', 'light bulb', 'gear', 'mobile phone'],
+        animado: ['thinking-face'], termos2d: [],
+        paletas: ['grafite', 'mar', 'ouro'],
+        nao: ['mapa', 'relogio', 'leque', 'estrelas', 'calendario', 'carimbo'],
+        prefere: { interface: 3, cursor: 3, prompt: 3, mergulho: 2.5, camera_nulls: 2, rolagem: 2, parede_logos: 2, cinetico: 2, laco: 2, linha_tempo: 1.5, chat: 1.5, ondas: 1.2, relogio: 0.4, mapa: 0.3, estrelas: 0.8, carimbo: 1.2 },
+        cameras: ['push', 'pulso', 'chicote'], tipografias: ['tecnica', 'geometrica', 'pesada', 'editorial'],
+        trocas: ['corte', 'chicote', 'zoom', 'persiana', 'empurra', 'giro'],
+        musica: 'electronic technology minimal', itens: ['Você descreve', 'A IA monta', 'Você publica'],
+    },
+    geral: {
+        re: /./,
+        nome: 'a ideia em cena',
+        elementos: ['star', 'light bulb', 'sparkles', 'rocket'],
+        animado: [], termos2d: [],
+        paletas: ['petroleo', 'coral', 'grafite', 'tijolo', 'menta'],
+        nao: [], prefere: {},
+        cameras: CAMERAS, tipografias: Object.keys(TIPOGRAFIAS),
+        trocas: TRANSICOES,
+        musica: 'upbeat instrumental', itens: ['Passo um', 'Passo dois', 'Passo três'],
+    },
+};
+const achar = (assunto) => {
+    const a = String(assunto || '');
+    for (const k of ['padaria', 'clinica', 'financas', 'software']) if (METAFORAS[k].re.test(a)) return { chave: k, ...METAFORAS[k] };
+    return { chave: 'geral', ...METAFORAS.geral };
+};
+
+// ── semente e sorteio ────────────────────────────────────────────────────
+
+const hashTexto = (s) => { let h = 7; for (const c of String(s)) h = (h * 31 + c.charCodeAt(0)) >>> 0; return h; };
+function mulberry(a) {
+    return () => { a |= 0; a = (a + 0x6D2B79F5) | 0; let t = Math.imul(a ^ (a >>> 15), 1 | a); t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t; return ((t ^ (t >>> 14)) >>> 0) / 4294967296; };
+}
+/** Sorteio ponderado: itens [[valor, peso]]. */
+function sortear(rnd, itens) {
+    const total = itens.reduce((s, [, p]) => s + Math.max(0, p), 0);
+    if (total <= 0) return itens[0][0];
+    let x = rnd() * total;
+    for (const [v, p] of itens) { x -= Math.max(0, p); if (x <= 0) return v; }
+    return itens[itens.length - 1][0];
+}
+
+// ── o histórico de assinaturas ───────────────────────────────────────────
+
+const arquivoHistorico = () => process.env.PRIMOCODE_ASSINATURAS || path.join(os.homedir(), '.primocode', 'studio', 'assinaturas.json');
+function lerHistorico(arq = arquivoHistorico()) {
+    try { const j = JSON.parse(fs.readFileSync(arq, 'utf8')); return Array.isArray(j) ? j : []; } catch { return []; }
+}
+function registrar(assinatura, arq = arquivoHistorico()) {
+    const h = lerHistorico(arq);
+    h.push({ ...assinatura, quando: new Date().toISOString() });
+    try { fs.mkdirSync(path.dirname(arq), { recursive: true }); fs.writeFileSync(arq, JSON.stringify(h.slice(-40), null, 2)); } catch { /* sem disco: segue */ }
+    return h.length;
+}
+const jaccard = (a, b) => { const A = new Set(a), B = new Set(b); if (!A.size && !B.size) return 1; let i = 0; for (const x of A) if (B.has(x)) i++; return i / (A.size + B.size - i); };
+/** 0 (nada a ver) a 1 (o mesmo vídeo). Pesos: cenas, ordem, trocas, câmera, tipografia, metáfora, ritmo. */
+function similaridade(a, b) {
+    if (!a || !b) return 0;
+    const ordem = (() => { const n = Math.min(a.primitivas.length, b.primitivas.length); if (!n) return 0; let k = 0; for (let i = 0; i < n; i++) if (a.primitivas[i] === b.primitivas[i]) k++; return k / n; })();
+    return 0.3 * jaccard(a.primitivas, b.primitivas) + 0.15 * ordem + 0.15 * jaccard(a.trocas, b.trocas) + 0.12 * (a.camera === b.camera ? 1 : 0)
+        + 0.12 * (a.tipografia === b.tipografia ? 1 : 0) + 0.08 * (a.metafora === b.metafora ? 1 : 0) + 0.04 * (a.ritmo === b.ritmo ? 1 : 0) + 0.04 * (a.paleta === b.paleta ? 1 : 0);
+}
+const LIMITE_PARECIDO = 0.42;
+
+// ── o roteiro de papéis ──────────────────────────────────────────────────
+
+const MOLDES = [
+    ['gancho', 'problema', 'processo', 'prova', 'cta'],
+    ['gancho', 'processo', 'prova', 'virada', 'cta'],
+    ['gancho', 'prova', 'problema', 'processo', 'cta'],
+    ['problema', 'virada', 'processo', 'prova', 'cta'],
+    ['gancho', 'problema', 'virada', 'processo', 'prova', 'cta'],
+];
+function papeisPara(duracao, rnd, evita) {
+    let m = MOLDES.filter((x) => x.join() !== evita);
+    if (duracao < 11) m = m.filter((x) => x.length <= 5);
+    const base = m[Math.floor(rnd() * m.length)].slice();
+    // vídeos mais longos ganham mais um passo e mais uma prova
+    if (duracao >= 18) base.splice(base.indexOf('cta'), 0, 'processo');
+    if (duracao >= 26) base.splice(base.indexOf('cta'), 0, 'prova');
+    return base;
+}
+
+// ── completar os campos de cada cena ─────────────────────────────────────
+
+const limpa = (s, max) => String(s == null ? '' : s).replace(/[\r\n]+/g, ' ').replace(/\s+/g, ' ').trim().slice(0, max);
+const PARADAS = new Set('de da do das dos na no nas nos em um uma uns umas e ou que com por para pra ao aos às as os o a se sem'.split(' '));
+function marcarChave(titulo) {
+    if (!titulo || titulo.includes('*')) return titulo;
+    const ps = titulo.split(' ');
+    let melhor = -1, tam = 0;
+    ps.forEach((p, i) => { const l = p.replace(/[^\p{L}\p{N}]/gu, ''); if (l.length >= 4 && !PARADAS.has(l.toLowerCase()) && l.length > tam) { melhor = i; tam = l.length; } });
+    if (melhor < 0) return titulo;
+    ps[melhor] = '*' + ps[melhor] + '*';
+    return ps.join(' ');
+}
+const primeirasPalavras = (s, n) => String(s || '').replace(/\*/g, '').split(/\s+/).filter(Boolean).slice(0, n).join(' ');
+const itensDe = (v, n, m) => (Array.isArray(v) ? v : []).map((x) => limpa(typeof x === 'object' && x ? (x.titulo || x.texto || x.nome || '') : x, m)).filter(Boolean).slice(0, n);
+
+/** Põe em `c` o que a primitiva `tipo` precisa e o modelo não mandou. `ctx`: {assunto, meta, proxima}. */
+function completar(c, tipo, ctx) {
+    const spec = PRIMITIVAS[tipo];
+    const out = { ...c, tipo };
+    const base = limpa(c.titulo || c.texto || primeirasPalavras(c.fala, 6) || ctx.assunto, 80);
+    out.titulo = marcarChave(base);
+    out.sub = limpa(c.sub, 70) || undefined;
+    let it = itensDe(c.itens, 6, 28);
+    if (spec.itens && it.length < spec.itens) it = (it.length ? it.concat(ctx.meta.itens) : ctx.meta.itens).slice(0, Math.max(spec.itens, it.length));
+    out.itens = it;
+    out.valor = limpa(c.valor, 12) || (tipo === 'relogio' ? '7:00' : tipo === 'medidor' ? '82%' : tipo === 'estrelas' ? '4,9' : '100');
+    out.rotulo = limpa(c.rotulo, 60) || undefined;
+    out.antes = limpa(c.antes, 40) || 'Do jeito difícil';
+    out.depois = marcarChave(limpa(c.depois, 40) || 'Do jeito simples');
+    out.texto = limpa(c.texto || c.titulo, 140) || undefined;
+    out.autor = limpa(c.autor, 40) || undefined;
+    out.botao = limpa(c.botao, 26) || 'Começar agora';
+    out.toques = itensDe(c.toques, 4, 24);
+    if (ctx.proxima) { out.prox = limpa(ctx.proxima.titulo || ctx.proxima.texto, 40).replace(/\*/g, ''); }
+    out.fala = c.fala ? String(c.fala) : undefined;
+    out.dur = Math.max(1.4, Math.min(tipo === 'celular' || tipo === 'prompt' ? 5 : 4.2, Number(c.dur || c.duracao) || spec.dur));
+    return out;
+}
+
+// ── a direção ────────────────────────────────────────────────────────────
+
+const ALIAS = { antes: 'split', antesdepois: 'split', antes_depois: 'split', icone: 'icones', numero: 'numero', grafico: 'barras', grafico_barras: 'barras', grafico_linha: 'linha', cartas: 'leque', mundo: 'camera_nulls', tela: 'interface', cinetica: 'cinetico', logos: 'parede_logos', brasas: 'particulas', timeline: 'linha_tempo', notificacao: 'notificacoes', funil_vendas: 'funil', ponteiro: 'cursor', digitacao: 'prompt', scroll: 'rolagem', coracao: 'estrelas', prova_social: 'estrelas' };
+const normTipo = (t) => { const s = String(t || '').toLowerCase().replace(/[\s-]+/g, '_'); return ALIAS[s] || s; };
+
+/**
+ * Escolhe a primitiva de um papel: afinidade do assunto × novidade (o que os últimos vídeos usaram pesa menos) ×
+ * variedade dentro do vídeo (nada repetido, nada da mesma família em fila).
+ */
+function escolherPrimitiva(papel, ctx, rnd) {
+    const usados = ctx.usados, ultimaFam = ctx.ultimaFam;
+    const recentes = new Map();
+    ctx.historico.slice(-5).forEach((h, i, arr) => (h.primitivas || []).forEach((p) => recentes.set(p, (recentes.get(p) || 0) + 1 + i / arr.length)));
+    const nao = new Set(ctx.meta.nao || []);
+    const cand = TIPOS.filter((t) => PRIMITIVAS[t].papeis.includes(papel) && !usados.has(t) && !nao.has(t) && (!PRIMITIVAS[t].elemento || ctx.temElemento));
+    const lista = (cand.length ? cand : TIPOS.filter((t) => !usados.has(t) && PRIMITIVAS[t].papeis.includes(papel))).map((t) => {
+        let peso = 1;
+        peso *= ctx.meta.prefere[t] != null ? ctx.meta.prefere[t] : 1;
+        peso *= Math.pow(0.55, recentes.get(t) || 0);
+        if (PRIMITIVAS[t].fam === ultimaFam) peso *= 0.25;
+        if (PRIMITIVAS[t].papeis[0] === papel) peso *= 1.3;
+        return [t, peso];
+    });
+    return lista.length ? sortear(rnd, lista) : 'gancho';
+}
+
+/**
+ * dirigir: completa tudo o que o pedido não disse. `args`: assunto, cenas (cada uma com papel/tipo/campos), transicoes|trocas,
+ * camera, tipografia, metafora, duracao, semente, marca. Devolve a direção e a assinatura (sem gravar: quem grava é o chamador).
+ */
+function dirigir(args = {}, { historico = lerHistorico(), semente = null, temElemento = true } = {}) {
+    const assunto = limpa(args.assunto, 160) || 'Seu projeto';
+    const meta = achar(assunto + ' ' + (args.metafora || ''));
+    const duracao = Math.max(6, Math.min(60, Number(args.duracao) || 15));
+    const hist = historico.filter((h) => h && h.primitivas);
+    let melhor = null;
+    const base = semente != null ? Number(semente) : (args.semente != null ? Number(args.semente) : (Date.now() % 100000) + hashTexto(assunto) % 1000);
+    const fixa = semente != null || args.semente != null;
+    for (let tent = 0; tent < 14; tent++) {
+        const sem = base + tent * 7919;
+        const rnd = mulberry(sem);
+        const d = montarDirecao({ args, assunto, meta, duracao, hist, rnd, temElemento });
+        d.semente = sem;
+        d.assinatura.semente = sem;
+        d.assinatura.parecido = hist.length ? Math.max(...hist.slice(-6).map((h) => similaridade(d.assinatura, h))) : 0;
+        if (!melhor || d.assinatura.parecido < melhor.assinatura.parecido) melhor = d;
+        d.tentativas = tent + 1;
+        if (d.assinatura.parecido <= LIMITE_PARECIDO || (fixa && tent === 0 && args.cenas && args.cenas.length && args.cenas.every((c) => c && c.tipo))) { melhor = d; break; }
+    }
+    melhor.assinatura.repetiu = melhor.assinatura.parecido > LIMITE_PARECIDO;
+    return melhor;
+}
+
+function montarDirecao({ args, assunto, meta, duracao, hist, rnd, temElemento }) {
+    const ultimo = hist[hist.length - 1];
+    const ctx = { assunto, meta, hist, historico: hist, usados: new Set(), ultimaFam: null, temElemento };
+    // ritmo: duração média por cena
+    const ritmo = args.ritmo || sortear(rnd, [['rapido', 1], ['medio', 1.4], ['lento', 0.8]].map(([r, p]) => [r, p * (ultimo && ultimo.ritmo === r ? 0.4 : 1)]));
+    const media = ritmo === 'rapido' ? 2.5 : ritmo === 'lento' ? 3.5 : 3.0;   // cena de 2,5 a 3,5 s: o corte seco da câmera dá o pulso a cada ~1 s
+
+    // as cenas pedidas (ou os papéis sorteados)
+    let pedidas = Array.isArray(args.cenas) && args.cenas.length ? args.cenas.slice(0, 24).map((c) => (c && typeof c === 'object' ? c : { titulo: String(c || '') })) : null;
+    if (!pedidas) {
+        const n = Math.max(4, Math.round(duracao / media));
+        let papeis = papeisPara(duracao, rnd, ultimo && ultimo.molde);
+        while (papeis.length > n + 1 && papeis.includes('processo')) papeis.splice(papeis.lastIndexOf('processo'), 1);
+        pedidas = papeis.map((papel) => ({ papel }));
+    }
+    const papeisUsados = [];
+    const cenas = [];
+    pedidas.forEach((c, i) => {
+        let tipo = normTipo(c.tipo);
+        const papel = c.papel || (i === 0 ? 'gancho' : i === pedidas.length - 1 ? 'cta' : ['problema', 'processo', 'prova', 'virada'][i % 4]);
+        papeisUsados.push(papel);
+        if (!PRIMITIVAS[tipo]) tipo = papel === 'cta' ? 'cta' : escolherPrimitiva(papel, ctx, rnd);   // todo vídeo termina num CTA de verdade (botão grande)
+        ctx.usados.add(tipo);
+        ctx.ultimaFam = PRIMITIVAS[tipo].fam;
+        cenas.push({ c, tipo, papel });
+    });
+    // o assunto aparece em OBJETOS: pelo menos 2 cenas com primitiva que usa o elemento real (as que o modelo fixou ficam como estão)
+    if (temElemento) {
+        const nao = new Set(meta.nao || []);
+        const conta = () => cenas.filter((x) => PRIMITIVAS[x.tipo].elemento).length;
+        for (let i = 0; i < cenas.length && conta() < 2; i++) {
+            const x = cenas[(i * 2 + 1) % cenas.length];
+            if (PRIMITIVAS[x.tipo].elemento || (x.c && PRIMITIVAS[normTipo(x.c.tipo)])) continue;
+            const cand = TIPOS.filter((t) => PRIMITIVAS[t].elemento && PRIMITIVAS[t].papeis.includes(x.papel) && !nao.has(t) && !cenas.some((y) => y.tipo === t));
+            if (cand.length) { ctx.usados.delete(x.tipo); x.tipo = sortear(rnd, cand.map((t) => [t, meta.prefere[t] != null ? meta.prefere[t] : 1])); ctx.usados.add(x.tipo); }
+        }
+    }
+    const out = cenas.map(({ c, tipo, papel }, i) => {
+        const prox = cenas[i + 1];
+        const r = completar(c, tipo, { assunto, meta, proxima: prox && prox.c });
+        r.papel = papel;
+        return r;
+    });
+
+    // transições: pesadas pelo assunto, nunca a mesma em fila, nunca igual à dos últimos vídeos demais
+    const recT = new Map(); hist.slice(-4).forEach((h) => (h.trocas || []).forEach((t) => recT.set(t, (recT.get(t) || 0) + 1)));
+    const pedidasT = args.transicoes || args.trocas;
+    const trocas = [];
+    for (let i = 1; i < out.length; i++) {
+        let t = Array.isArray(pedidasT) && TRANSICOES.includes(pedidasT[i - 1]) ? pedidasT[i - 1] : null;
+        if (!t) {
+            if (out[i - 1].tipo === 'mergulho') t = rnd() < 0.5 ? 'corte' : 'dissolve';
+            else t = sortear(rnd, TRANSICOES.map((x) => [x, (['dissolve', 'desfoque', 'encolhe', 'mascara', 'abre', 'cortina'].includes(x) ? 0.4 : 1.4) * (meta.trocas.includes(x) ? 3 : 1) * Math.pow(0.6, recT.get(x) || 0) * (x === trocas[trocas.length - 1] ? 0 : 1) * (trocas.slice(-3).includes(x) ? 0.3 : 1)]));
+        }
+        trocas.push(t);
+    }
+
+    // câmera: um estilo principal + um secundário em algumas cenas
+    const recC = new Map(); hist.slice(-3).forEach((h) => recC.set(h.camera, (recC.get(h.camera) || 0) + 1));
+    const camera = CAMERAS.includes(args.camera) ? args.camera : sortear(rnd, CAMERAS.map((x) => [x, (meta.cameras.includes(x) ? 3 : 1) * Math.pow(0.45, recC.get(x) || 0)]));
+    const camera2 = sortear(rnd, CAMERAS.filter((x) => x !== camera).map((x) => [x, meta.cameras.includes(x) ? 2 : 1]));
+    out.forEach((c, i) => { c.camera = c.camera && CAMERAS.includes(c.camera) ? c.camera : (i % 3 === 2 ? camera2 : camera); });
+
+    // tipografia
+    const recTi = new Map(); hist.slice(-3).forEach((h) => recTi.set(h.tipografia, (recTi.get(h.tipografia) || 0) + 1));
+    const tipografia = TIPOGRAFIAS[args.tipografia] ? args.tipografia : sortear(rnd, Object.keys(TIPOGRAFIAS).map((x) => [x, (meta.tipografias.includes(x) ? 3 : 0.8) * Math.pow(0.4, recTi.get(x) || 0)]));
+
+    // paleta
+    const recP = new Map(); hist.slice(-3).forEach((h) => recP.set(h.paleta, (recP.get(h.paleta) || 0) + 1));
+    const paleta = PALETAS[args.paleta] ? args.paleta : sortear(rnd, meta.paletas.map((x) => [x, Math.pow(0.35, recP.get(x) || 0)]));
+    const ordemPal = sortear(rnd, [[0, 1], [1, 1], [2, 1]]);
+
+    const assinatura = {
+        metafora: meta.nome, chave: meta.chave, assunto, primitivas: out.map((c) => c.tipo), trocas, camera, camera2, tipografia, ritmo, paleta,
+        molde: papeisUsados.join(','), cenas: out.length, tipos_unicos: new Set(out.map((c) => c.tipo)).size,
+    };
+    return { metafora: meta, cenas: out, trocas, camera, tipografia, ritmo, paleta, ordemPal, assinatura };
+}
+
+/** Quantos itens do vocabulário (para o teste e para o relatório). */
+const VOCABULARIO = () => ({ primitivas: TIPOS.length, transicoes: TRANSICOES.length, cameras: CAMERAS.length, tipografias: Object.keys(TIPOGRAFIAS).length });
+
+module.exports = { PRIMITIVAS, TIPOS, TRANSICOES, CAMERAS, TIPOGRAFIAS, METAFORAS, PALETAS, achar, dirigir, similaridade, lerHistorico, registrar, completar, marcarChave, normTipo, escolherPrimitiva, VOCABULARIO, LIMITE_PARECIDO, hashTexto, mulberry, arquivoHistorico };

package/lib/estudio/maquina-elementos.js

@@ -0,0 +1,134 @@
+/**
+ * maquina-elementos.js — os ELEMENTOS REAIS do assunto: o pão do vídeo da padaria, o relógio, o calendário.
+ *
+ * Regra da casa: todo elemento tem que ter a ver com o assunto, e a escolha é do modelo (cardápio) com o diretor
+ * completando. Daqui saem arquivos que o EffectCraft importa (PNG, SVG ou sequência de PNG):
+ *
+ *   · ícone 3D Fluent (MIT), pelo índice do pacote (colecao.js), reamostrado 3× para não ficar mole no quadro;
+ *   · animação Noto (CC BY 4.0): o GIF vira sequência de PNG (o EffectCraft não importa Lottie: medido, "data files
+ *     can't be layers");
+ *   · logos (Wikimedia, SVG) e print do site (print-site.js), quando o pedido traz `logos` ou `site`.
+ *
+ * Cada arquivo guarda a licença ao lado (.json). Sem rede, usa o que já está na pasta do projeto.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const slug = (s) => String(s).normalize('NFD').replace(/[̀-ͯ]/g, '').replace(/[^a-z0-9]+/gi, '-').toLowerCase().replace(/^-|-$/g, '').slice(0, 40) || 'el';
+
+function ff(args) {
+    const r = spawnSync('ffmpeg', ['-y', '-hide_banner', '-loglevel', 'error', ...args], { encoding: 'utf8', timeout: 60000 });
+    return r.status === 0;
+}
+
+/** Reamostra o PNG 3D (256 px) para 768 px com lanczos e um realce leve, mantendo o alfa. */
+function ampliar(origem, destino) {
+    fs.mkdirSync(path.dirname(destino), { recursive: true });
+    const ok = ff(['-i', origem, '-vf', 'format=rgba,scale=768:768:flags=lanczos,unsharp=5:5:0.7:5:5:0.0', '-pix_fmt', 'rgba', destino]);
+    if (ok && fs.existsSync(destino)) return destino;
+    fs.copyFileSync(origem, destino);
+    return destino;
+}
+
+async function icone3d(termo, pasta) {
+    const colecao = require('./colecao.js');
+    const r = colecao.procurarIcones3d(termo, { quantas: 3 });
+    if (!r.ok || !r.icones.length) return null;
+    for (const ic of r.icones) {
+        const b = await colecao.baixar(ic.id, { pasta });
+        if (!b.ok) continue;
+        const origem = path.join(pasta, b.src);
+        const destino = path.join(pasta, 'midia', 'elementos', slug(ic.nome) + '.png');
+        ampliar(origem, destino);
+        const ficha = { fonte: ic.fonte, licenca: 'MIT', termo, nome: ic.nome };
+        try { fs.writeFileSync(destino.replace(/\.png$/, '.json'), JSON.stringify(ficha, null, 2)); } catch { /* sem ficha */ }
+        return { nome: ic.nome, termo, tipo: 'png', arquivo: destino, fonte: ic.fonte, licenca: 'MIT' };
+    }
+    return null;
+}
+
+async function animacao(termo, pasta) {
+    const colecao = require('./colecao.js');
+    const r = colecao.procurarAnimacoes(termo, { quantas: 2 });
+    if (!r.ok || !r.animacoes.length) return null;
+    const a = r.animacoes[0];
+    const dir = path.join(pasta, 'midia', 'elementos', slug(a.nome) + '-seq');
+    const primeiro = path.join(dir, 'f001.png');
+    if (!fs.existsSync(primeiro)) {
+        const gif = path.join(pasta, 'midia', 'elementos', slug(a.nome) + '.gif');
+        fs.mkdirSync(dir, { recursive: true });
+        const resp = await fetch(a.gif, { headers: { 'user-agent': 'primocode-estudio' }, signal: AbortSignal.timeout(20000) });
+        if (!resp.ok) return null;
+        fs.writeFileSync(gif, Buffer.from(await resp.arrayBuffer()));
+        if (!ff(['-i', gif, '-fps_mode', 'passthrough', path.join(dir, 'f%03d.png')]) || !fs.existsSync(primeiro)) return null;
+        try { fs.writeFileSync(path.join(dir, 'licenca.json'), JSON.stringify({ fonte: 'Noto Emoji Animation (Google)', licenca: 'CC BY 4.0', creditos: a.creditos, termo }, null, 2)); } catch { /* sem ficha */ }
+    }
+    return { nome: a.nome, termo, tipo: 'seq', arquivo: primeiro, fonte: 'Noto Emoji Animation (Google)', licenca: 'CC BY 4.0', creditos: a.creditos };
+}
+
+/** Logo (SVG) da marca, pelo Wikimedia Commons (acervo.js). */
+async function logo(marca, pasta) {
+    const acervo = require('./acervo.js');
+    const achados = await acervo.wikimediaLogos(marca, { quantos: 3 });
+    for (const l of achados || []) {
+        if (!/\.(svg|png)(\?|$)/i.test(l.url || '')) continue;
+        const b = await acervo.baixar(l.url, { titulo: marca + ' logo', meta: { licenca: l.licenca, autor: l.autor, fonte: 'wikimedia' }, pasta: path.join(pasta, 'midia', 'elementos') });
+        if (b.ok) return { nome: marca + ' (logo)', termo: marca, tipo: /\.svg$/i.test(b.arquivo) ? 'svg' : 'png', arquivo: b.arquivo, fonte: 'Wikimedia Commons', licenca: l.licenca || '?' };
+    }
+    return null;
+}
+
+async function printDoSite(url, pasta) {
+    const ps = require('./print-site.js');
+    const r = await ps.capturarSite(url, { pasta });
+    const arq = r && r.ok && r.src ? path.join(pasta, r.src) : null;
+    if (arq && fs.existsSync(arq)) return { nome: 'print do site', termo: url, tipo: 'png', arquivo: arq, fonte: url, licenca: 'do dono do site' };
+    return null;
+}
+
+/** Termos em inglês, na ordem: os pedidos, os da metáfora e as palavras do assunto (que o dicionário PT→EN conhece). */
+function termosDoAssunto({ assunto, pedidos = [], meta = null }) {
+    const colecao = require('./colecao.js');
+    const out = [];
+    const poe = (t) => { t = String(t || '').trim(); if (t && !out.includes(t)) out.push(t); };
+    pedidos.forEach(poe);
+    for (const w of String(assunto || '').toLowerCase().split(/[^\p{L}]+/u)) if (w.length > 2 && colecao.PT_EN[w]) poe(colecao.PT_EN[w]);
+    ((meta && meta.elementos) || []).forEach(poe);
+    return out;
+}
+
+/**
+ * Reúne `minimo` a `max` elementos reais. `deps.icone3d/animacao` são injetáveis (testes). Nunca lança.
+ * Devolve {ok, elementos, creditos, faltou}.
+ */
+async function reunir({ assunto, pedidos = [], meta = null, pasta, minimo = 3, max = 6, rede = true, logos = [], site = null, animados = true, deps = {} } = {}) {
+    if (!pasta) return { ok: false, error: 'faltou a pasta do projeto.', elementos: [] };
+    const ic3 = deps.icone3d || icone3d, an = deps.animacao || animacao;
+    const termos = termosDoAssunto({ assunto, pedidos, meta });
+    const elementos = [];
+    const tem = (e) => e && !elementos.some((x) => x.arquivo === e.arquivo || x.nome === e.nome);
+    try {
+        if (site && rede) { const e = await (deps.print || printDoSite)(site, pasta).catch(() => null); if (tem(e)) elementos.push(e); }
+        for (const m of logos || []) { if (!rede) break; const e = await (deps.logo || logo)(m, pasta).catch(() => null); if (tem(e)) elementos.push(e); }
+        for (const t of termos) {
+            if (elementos.length >= max) break;
+            const e = await ic3(t, pasta).catch(() => null);   // o ícone 3D mora no pacote; só o PNG desce da rede
+            if (tem(e)) elementos.push(e);
+        }
+        if (animados && rede && meta && meta.animado) {
+            for (const t of meta.animado.slice(0, 1)) { const e = await an(t, pasta).catch(() => null); if (tem(e) && elementos.length < max + 1) elementos.push(e); }
+        }
+        for (const t of ['sparkles', 'star', 'check mark button', 'light bulb']) {   // última reserva: ainda é "real", só menos específico
+            if (elementos.length >= minimo) break;
+            const e = await ic3(t, pasta).catch(() => null); if (tem(e)) elementos.push(e);
+        }
+    } catch (e) { return { ok: elementos.length >= minimo, error: e.message, elementos, creditos: [], faltou: Math.max(0, minimo - elementos.length) }; }
+    const creditos = elementos.filter((e) => e.creditos || /CC/i.test(e.licenca)).map((e) => ({ nome: e.nome, licenca: e.licenca, creditos: e.creditos || null }));
+    return { ok: elementos.length >= minimo, elementos, creditos, faltou: Math.max(0, minimo - elementos.length), termos };
+}
+
+module.exports = { reunir, icone3d, animacao, logo, printDoSite, termosDoAssunto, ampliar, slug };