primocode 11.0.0 → 11.2.0

package/lib/plugin/estudio/gosto.js

@@ -0,0 +1,608 @@
+/**
+ * gosto.js — aprender o gosto da pessoa pro motion.
+ *
+ * No PRIMEIRO estudio_motion, antes de renderizar, abre uma tela local com 20 motions tocando em loop num carrossel:
+ * a pessoa escolhe os que curtiu e, numa pergunta só, marca "mais disso" e "menos disso". Fica em ~/.primocode/gosto-motion.json.
+ *
+ * Regra do dono: o gosto é CONTEXTO E PESO, não trilho. O diretor (maquina-diretor.js) continua sorteando com
+ * variedade e histórico; aqui só saem multiplicadores (pesos). Nunca vira "estilo fixo".
+ *
+ *   ler() / salvar() / tem()   o arquivo
+ *   pesos(gosto)               multiplicadores pro diretor (tudo 1 = neutro)
+ *   resumo(gosto)              1 a 3 frases pro modelo ler
+ *   adicionarReferencia()      soma um vídeo de referência já medido (gosto-medir.js): até 5, pesos suaves
+ *   fraseDeUmaReferencia()     a frase de um vídeo só (a tela mostra como "Entendi: …")
+ *                              cada referência pode trazer `descricao` (gosto-descrever.js: o modelo olhou o vídeo e
+ *                              escolheu câmeras, trocas e tipografias do diretor + frases; a pessoa conferiu na tela)
+ *   abrirTela()                servidor local 127.0.0.1 + token; resolve {ok, gosto} | {ok:false, motivo}
+ *   antesDoMotion()            no terminal abre o navegador; no app (-p com PRIMOCODE_APP=1) escreve
+ *                              `primocode:abrir-gosto <url>` no stderr e o app (desktop ou Primo.app) abre a tela
+ */
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const http = require('http');
+const crypto = require('crypto');
+
+// Só nomes do vocabulário do diretor (maquina-diretor.js: CAMERAS, TRANSICOES, TIPOGRAFIAS).
+const ESTILOS = [
+    { id: 'brincalhao', nome: 'Brincalhão', frase: 'Quica, gira, pula. Leve e cheio de vida.', ritmo: 'rapido', cameras: ['pulso', 'orbita'], trocas: ['giro', 'encolhe', 'abre'], tipografias: ['arredondada', 'manuscrita'], overshoot: 0.18 },
+    { id: 'premium', nome: 'Premium', frase: 'Lento, liso, caro. Desfoque saindo e nada de susto.', ritmo: 'lento', cameras: ['cinema', 'deriva'], trocas: ['desfoque', 'dissolve', 'cortina'], tipografias: ['serifa_fina', 'editorial'], overshoot: 0 },
+    { id: 'corporativo', nome: 'Direto', frase: 'Entra empurrando, corte seco, tudo alinhado.', ritmo: 'medio', cameras: ['trilho', 'push'], trocas: ['empurra', 'persiana', 'corte'], tipografias: ['geometrica', 'tecnica'], overshoot: 0.04 },
+    { id: 'energico', nome: 'Enérgico', frase: 'Chicote, punch de câmera, letra entrando rápido.', ritmo: 'rapido', cameras: ['chicote', 'pulso'], trocas: ['chicote', 'tremor', 'zoom', 'corte'], tipografias: ['pesada', 'poster'], overshoot: 0.25 },
+    { id: 'cinema3d', nome: 'Cinema 3D', frase: 'Profundidade: tudo orbita e vem do fundo.', ritmo: 'medio', cameras: ['orbita', 'cinema', 'push'], trocas: ['giro', 'zoom', 'empurra'], tipografias: ['poster', 'editorial'], overshoot: 0.1 },
+    { id: 'cinetico', nome: 'Letra que dança', frase: 'Cada letra entra sozinha, girando e trocando de peso.', ritmo: 'rapido', cameras: ['pulso', 'push'], trocas: ['corte', 'chicote', 'encolhe'], tipografias: ['poster', 'pesada', 'tecnica'], overshoot: 0.15 },
+    { id: 'cubo', nome: 'Cubo', frase: 'Um cubo 3D gira de face em face e dá cambalhota.', ritmo: 'medio', cameras: ['orbita', 'push'], trocas: ['giro', 'zoom'], tipografias: ['pesada', 'poster'], overshoot: 0.2 },
+    { id: 'glitch', nome: 'Glitch', frase: 'A palavra treme e se parte em fatias coloridas.', ritmo: 'rapido', cameras: ['chicote', 'pulso'], trocas: ['tremor', 'corte'], tipografias: ['tecnica', 'pesada'], overshoot: 0.05 },
+    { id: 'espiral', nome: 'Espiral', frase: 'Pontos giram até o centro e explodem na palavra.', ritmo: 'rapido', cameras: ['orbita', 'pulso'], trocas: ['zoom', 'encolhe'], tipografias: ['pesada', 'arredondada'], overshoot: 0.2 },
+    { id: 'slot', nome: 'Caça-níquel', frase: 'Cada letra roda como num rolo e trava uma por vez.', ritmo: 'rapido', cameras: ['pulso', 'trilho'], trocas: ['corte', 'persiana'], tipografias: ['pesada', 'poster'], overshoot: 0.1 },
+    { id: 'tunel', nome: 'Túnel', frase: 'Quadros saem do centro girando, a palavra pulsa.', ritmo: 'rapido', cameras: ['push', 'pulso'], trocas: ['zoom', 'giro'], tipografias: ['geometrica', 'poster'], overshoot: 0.1 },
+    { id: 'mosaico', nome: 'Mosaico', frase: 'Azulejos viram em onda e mostram a palavra.', ritmo: 'medio', cameras: ['push', 'deriva'], trocas: ['persiana', 'abre'], tipografias: ['geometrica', 'pesada'], overshoot: 0.15 },
+    { id: 'estilhaco', nome: 'Estilhaço', frase: 'Um impacto quebra a palavra e ela se junta de volta.', ritmo: 'rapido', cameras: ['chicote', 'pulso'], trocas: ['zoom', 'tremor'], tipografias: ['pesada', 'poster'], overshoot: 0.22 },
+    { id: 'contador', nome: 'Contador', frase: 'Os números rolam até 100% com a barra enchendo.', ritmo: 'medio', cameras: ['push', 'trilho'], trocas: ['empurra', 'corte'], tipografias: ['tecnica', 'geometrica'], overshoot: 0.06 },
+    { id: 'orbita', nome: 'Órbita', frase: 'Anéis inclinados giram em volta da palavra.', ritmo: 'medio', cameras: ['orbita', 'cinema'], trocas: ['giro', 'dissolve'], tipografias: ['geometrica'], overshoot: 0.08 },
+    { id: 'equalizador', nome: 'Equalizador', frase: 'Barras dançam e a palavra quica na batida.', ritmo: 'rapido', cameras: ['pulso', 'chicote'], trocas: ['corte', 'tremor'], tipografias: ['pesada', 'poster'], overshoot: 0.12 },
+    { id: 'cartas', nome: 'Cartas', frase: 'Um baralho cai, abre em leque e junta de novo.', ritmo: 'medio', cameras: ['cinema', 'deriva'], trocas: ['abre', 'giro'], tipografias: ['editorial', 'arredondada'], overshoot: 0.18 },
+    { id: 'gota', nome: 'Gota', frase: 'Uma gota cai, abre ondas e a palavra sobe delas.', ritmo: 'lento', cameras: ['deriva', 'cinema'], trocas: ['desfoque', 'dissolve'], tipografias: ['serifa_fina', 'editorial'], overshoot: 0.12 },
+    { id: 'split', nome: 'Corte ao meio', frase: 'As metades da palavra entram por lados opostos.', ritmo: 'rapido', cameras: ['trilho', 'chicote'], trocas: ['persiana', 'empurra'], tipografias: ['pesada', 'tecnica'], overshoot: 0.04 },
+    { id: 'traco', nome: 'Traço', frase: 'Uma linha se desenha e revela a palavra atrás.', ritmo: 'medio', cameras: ['trilho', 'deriva'], tipografias: ['manuscrita', 'editorial'], trocas: ['abre', 'cortina'], overshoot: 0.08 },
+];
+
+/** O que a pessoa pode ter gostado (passo 2). */
+const GOSTEI = [
+    { id: 'rapido', nome: 'a velocidade' },
+    { id: 'quique', nome: 'o quique (passa do ponto e volta)' },
+    { id: 'tres_d', nome: 'o 3D' },
+    { id: 'camera', nome: 'a câmera mexendo' },
+    { id: 'letra', nome: 'a letra' },
+    { id: 'cortes', nome: 'os cortes' },
+    { id: 'cores', nome: 'as cores' },
+    { id: 'calmo', nome: 'ser calmo e liso' },
+];
+
+/** O que a pessoa NÃO quer (passo 3). */
+const NAO_QUERO = [
+    { id: 'lento', nome: 'devagar demais', curto: 'devagar demais' },
+    { id: 'liso', nome: 'liso, sem graça', curto: 'liso' },
+    { id: 'exagero', nome: 'exagerado, sujo', curto: 'exagero' },
+    { id: 'flash', nome: 'flash na tela', curto: 'flash' },
+    { id: 'tremido', nome: 'tremido demais', curto: 'tremido' },
+    { id: 'letra_pequena', nome: 'letra pequena', curto: 'letra pequena' },
+];
+
+const MAX_TEXTO = 280;
+const MAX_REFERENCIAS = 5;
+const MAX_POR_TELA = MAX_REFERENCIAS * 3;
+const RITMOS = ['rapido', 'medio', 'lento'];
+const FORMATOS = ['9:16', '16:9', '1:1', 'outro'];
+const LUGARES = ['topo', 'meio', 'baixo'];
+/* movimento de gosto-medir.js (0 a 1): o testsrc do ffmpeg dá ~0,2, então 0,4 é o dobro dele (mexe de verdade) e 0,1 é quase parado */
+const FORCAS_VALIDAS = ['pouco', 'medio', 'muito'];
+const MOVIMENTO_ALTO = 0.4;
+const MOVIMENTO_BAIXO = 0.1;
+const ID_ESTILO = new Set(ESTILOS.map((e) => e.id));
+const ID_GOSTEI = new Set(GOSTEI.map((e) => e.id));
+const ID_NAO = new Set(NAO_QUERO.map((e) => e.id));
+
+function arquivo(home = os.homedir()) { return path.join(home, '.primocode', 'gosto-motion.json'); }
+
+function texto(s) {
+    // tira caracteres de controle (menos nada: quebra de linha vira espaço) e corta
+    return String(s == null ? '' : s).replace(/[\u0000-\u001f\u007f]+/g, ' ').replace(/\s+/g, ' ').trim().slice(0, MAX_TEXTO);
+}
+
+function unicos(lista, valido) {
+    const out = [];
+    for (const x of Array.isArray(lista) ? lista : []) if (valido.has(x) && !out.includes(x)) out.push(x);
+    return out;
+}
+
+const num = (v, min, max, casas = 2) => {
+    const n = Number(v);
+    return Number.isFinite(n) ? Math.round(Math.max(min, Math.min(max, n)) * 10 ** casas) / 10 ** casas : 0;
+};
+
+/** Da medida do vídeo (gosto-medir.js) guarda só os números, com o tipo conferido. */
+function normalizarMedida(m) {
+    const o = m && typeof m === 'object' ? m : {};
+    const t = o.texto && typeof o.texto === 'object' ? o.texto : null;
+    return {
+        segundos: num(o.segundos, 0, 86400),
+        formato: FORMATOS.includes(o.formato) ? o.formato : 'outro',
+        cortesPorSegundo: num(o.cortesPorSegundo, 0, 100),
+        ritmo: RITMOS.includes(o.ritmo) ? o.ritmo : 'medio',
+        movimento: num(o.movimento, 0, 1),
+        paleta: (Array.isArray(o.paleta) ? o.paleta : []).filter((c) => /^#[0-9a-f]{6}$/i.test(c)).map((c) => c.toLowerCase()).slice(0, 5),
+        texto: t ? { fracaoComTexto: num(t.fracaoComTexto, 0, 1), alturaMedia: num(t.alturaMedia, 0, 1, 3), lugar: LUGARES.includes(t.lugar) ? t.lugar : null } : null,
+    };
+}
+
+/** A descrição que o modelo deu (e a pessoa conferiu): só ids do diretor, frases cortadas. null se não sobrou nada. */
+function normalizarDescricao(d) {
+    if (!d || typeof d !== 'object') return null;
+    const f = require('./gosto-descrever.js').filtrarDescricao(d);
+    f.frases = f.frases.map((x) => texto(x)).filter(Boolean);
+    return f.cameras.length || f.trocas.length || f.tipografias.length || f.frases.length ? f : null;
+}
+
+function normalizarReferencias(lista) {
+    const out = [];
+    for (const r of Array.isArray(lista) ? lista : []) {
+        if (!r || typeof r !== 'object' || !r.medida || typeof r.medida !== 'object') continue;
+        const item = { nome: texto(r.nome).slice(0, 80), quando: typeof r.quando === 'string' && !Number.isNaN(Date.parse(r.quando)) ? r.quando : new Date().toISOString(), medida: normalizarMedida(r.medida) };
+        const descricao = normalizarDescricao(r.descricao);
+        if (descricao) item.descricao = descricao;   // sem descrição o item fica como na fatia 2
+        out.push(item);
+        if (out.length >= MAX_REFERENCIAS) break;
+    }
+    return out;
+}
+
+/** Aceita só ids conhecidos, corta texto, tira controle. */
+function normalizar(d) {
+    const o = d && typeof d === 'object' ? d : {};
+    const escolhidos = [];
+    for (const e of Array.isArray(o.escolhidos) ? o.escolhidos : []) {
+        if (!e || !ID_ESTILO.has(e.id) || escolhidos.some((x) => x.id === e.id)) continue;
+        escolhidos.push({ id: e.id, gostei: unicos(e.gostei, ID_GOSTEI), texto: texto(e.texto) });
+    }
+    const g = {
+        versao: 1,
+        quando: typeof o.quando === 'string' && !Number.isNaN(Date.parse(o.quando)) ? o.quando : new Date().toISOString(),
+        escolhidos,
+        nao_quero: unicos(o.nao_quero, ID_NAO),
+        nao_texto: texto(o.nao_texto),
+        pulou: !!o.pulou,
+        ...(FORCAS_VALIDAS.includes(o.forca) && o.forca !== 'medio' ? { forca: o.forca } : {}),   // médio é o padrão: não entra no arquivo
+    };
+    const referencias = normalizarReferencias(o.referencias);
+    if (referencias.length) g.referencias = referencias;   // sem referência o arquivo fica igual ao de antes
+    return g;
+}
+
+function ler(home) {
+    try { return normalizar(JSON.parse(fs.readFileSync(arquivo(home), 'utf8'))); } catch { return null; }
+}
+
+function salvar(dados, home) {
+    const n = normalizar(dados);
+    const f = arquivo(home);
+    fs.mkdirSync(path.dirname(f), { recursive: true });
+    fs.writeFileSync(f, JSON.stringify(n, null, 2));
+    return n;
+}
+
+/** Soma um vídeo de referência (a medida de gosto-medir.js) ao gosto salvo: até 5, a mais antiga sai quando enche. Devolve o gosto. */
+function adicionarReferencia(medida, { nome, home } = {}) {
+    const g = ler(home) || normalizar({});
+    const lista = [...(g.referencias || []), { nome: nome || (medida && medida.arquivo ? path.basename(String(medida.arquivo)) : ''), quando: new Date().toISOString(), medida }];
+    return salvar({ ...g, referencias: lista.slice(-MAX_REFERENCIAS) }, home);
+}
+
+/* ESTILOS COM NOME (ideia do Jitter: o efeito salvo e reusado): um gosto por cliente ou por marca. O gosto em uso
+   continua sendo o gosto-motion.json; os nomeados moram em ~/.primocode/gosto-estilos/<nome>.json e só entram
+   em uso pelo /taste usar. */
+const pastaDosEstilos = (home = os.homedir()) => path.join(home, '.primocode', 'gosto-estilos');
+const nomeDoEstilo = (n) => String(n || '').normalize('NFD').replace(/[\u0300-\u036f]/g, '').toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 40);
+function salvarEstilo(nome, { home } = {}) {
+    const n = nomeDoEstilo(nome), g = ler(home);
+    if (!n) return { ok: false, error: 'dê um nome ao estilo: /taste salvar <nome>' };
+    if (!g) return { ok: false, error: 'ainda não tem gosto pra salvar: /taste referencias ou /taste refazer primeiro' };
+    fs.mkdirSync(pastaDosEstilos(home), { recursive: true });
+    fs.writeFileSync(path.join(pastaDosEstilos(home), n + '.json'), JSON.stringify(normalizar(g), null, 2));
+    return { ok: true, nome: n };
+}
+function usarEstilo(nome, { home } = {}) {
+    const n = nomeDoEstilo(nome);
+    let g;
+    try { g = JSON.parse(fs.readFileSync(path.join(pastaDosEstilos(home), n + '.json'), 'utf8')); } catch { return { ok: false, error: `não tem estilo "${n || nome}". /taste estilos lista os que existem` }; }
+    return { ok: true, nome: n, gosto: salvar(g, home) };
+}
+/** /gosto força pouco|médio|muito: quanto as referências pesam no próximo motion. */
+function definirForca(forca, { home } = {}) {
+    const f = String(forca || '').normalize('NFD').replace(/[\u0300-\u036f]/g, '').toLowerCase().trim();
+    if (!FORCAS_VALIDAS.includes(f)) return { ok: false, error: 'a força é pouco, médio ou muito: /taste força muito' };
+    const g = ler(home) || normalizar({});
+    return { ok: true, forca: f, gosto: salvar({ ...g, forca: f }, home) };
+}
+
+function estilos({ home } = {}) {
+    try { return fs.readdirSync(pastaDosEstilos(home)).filter((f) => f.endsWith('.json')).map((f) => f.slice(0, -5)).sort(); } catch { return []; }
+}
+
+/** Tira a referência N (1 = a primeira da lista do /gosto). Devolve o gosto, ou null se não há a N. */
+function tirarReferencia(n, { home } = {}) {
+    const g = ler(home);
+    const i = Number(n) - 1;
+    if (!g || !Array.isArray(g.referencias) || !(i >= 0 && i < g.referencias.length)) return null;
+    return salvar({ ...g, referencias: g.referencias.filter((_, k) => k !== i) }, home);
+}
+
+/** O /gosto em linhas: os estilos do carrossel e cada vídeo de referência, numerado pro /gosto tirar N. Pura. */
+function listar(gosto) {
+    if (!gosto) return [];
+    const out = [];
+    const esc = (gosto.escolhidos || []).map((x) => (ESTILOS.find((s) => s.id === x.id) || {}).nome).filter(Boolean);
+    if (esc.length) out.push(`Estilos que você escolheu: ${lista(esc)}.`);
+    const nao = (gosto.nao_quero || []).map((i) => (NAO_QUERO.find((c) => c.id === i) || {}).curto).filter(Boolean);
+    if (nao.length) out.push(`Não quer: ${nao.join(', ')}.`);
+    (gosto.referencias || []).forEach((r, k) => {
+        out.push(`${k + 1}. ${r.nome || 'vídeo'} — ${fraseDeUmaReferencia(r.medida).replace(/^Trouxe 1 vídeo de referência: /, '')}`);
+        for (const f of ((r.descricao && r.descricao.frases) || [])) out.push(`   "${f}"`);
+    });
+    if (gosto.forca && gosto.forca !== 'medio' && (gosto.referencias || []).length) out.push(`Força das referências: ${gosto.forca === 'pouco' ? 'pouco (só sugerem)' : 'muito (puxam forte)'}.`);
+    const pra = inclinacao(pesos(gosto));
+    if (pra) out.push(`O próximo motion tende a: ${pra}.`);
+    return out;
+}
+
+/* Pra onde os pesos inclinam o diretor, em palavras: só o que ganhou de verdade (1,5× ou mais), no máximo dois por
+   grupo. É o que a pessoa quer saber quando abre o /taste: "o que muda no meu próximo vídeo?". Pura. */
+function inclinacao(p) {
+    if (!p) return '';
+    const fortes = (grupo, min = 1.5) => Object.entries(p[grupo] || {}).filter(([, v]) => v >= min).sort((a, b) => b[1] - a[1]).slice(0, 2).map(([n]) => n);
+    const partes = [];
+    const r = Object.entries(p.ritmo || {}).sort((a, b) => b[1] - a[1]);
+    if (r.length && r[0][1] >= 1.5 && r[0][1] >= 1.3 * (r[1] ? r[1][1] : 1)) partes.push(`ritmo ${{ rapido: 'rápido', medio: 'médio', lento: 'lento' }[r[0][0]]}`);
+    const cam = fortes('cameras'); if (cam.length) partes.push(`câmera ${lista(cam)}`);
+    const tr = fortes('trocas'); if (tr.length) partes.push(`troca ${lista(tr)}`);
+    const tp = fortes('tipografias'); if (tp.length) partes.push(`letra ${lista(tp)}`);
+    const pal = fortes('paletas', 1.8).slice(0, 1); if (pal.length) partes.push(`paleta ${pal[0]}`);
+    return partes.join(', ');
+}
+
+function tem(home) { return fs.existsSync(arquivo(home)); }
+
+/** Multiplicadores pro diretor. Tudo em 1 = neutro. Nunca fixa nada: só inclina o sorteio. */
+function pesos(gosto) {
+    const p = { ritmo: { rapido: 1, medio: 1, lento: 1 }, cameras: {}, trocas: {}, tipografias: {}, overshoot: null };
+    const mult = (grupo, nome, k, teto = 5) => { p[grupo][nome] = Math.min(teto, (p[grupo][nome] != null ? p[grupo][nome] : 1) * k); };
+    const baixa = (grupo, nome, k) => { p[grupo][nome] = (p[grupo][nome] != null ? p[grupo][nome] : 1) * k; };
+    if (!gosto || gosto.pulou || !Array.isArray(gosto.escolhidos) || !gosto.escolhidos.length) {
+        aplicarReferencias(p, gosto && gosto.referencias, mult, gosto && gosto.forca);   // o vídeo que a pessoa trouxe vale mesmo sem o carrossel
+        if (gosto && Array.isArray(gosto.nao_quero) && !gosto.pulou) aplicarNao(p, gosto.nao_quero, baixa);
+        return p;
+    }
+    const chips = new Set();
+    let somaOver = 0, nOver = 0;
+    for (const esc of gosto.escolhidos) {
+        const e = ESTILOS.find((x) => x.id === esc.id);
+        if (!e) continue;
+        p.ritmo[e.ritmo] *= 1.8;
+        e.cameras.forEach((n) => mult('cameras', n, 2.2));
+        e.trocas.forEach((n) => mult('trocas', n, 2.2));
+        e.tipografias.forEach((n) => mult('tipografias', n, 2.2));
+        somaOver += e.overshoot; nOver++;
+        (esc.gostei || []).forEach((g) => chips.add(g));
+    }
+    aplicarReferencias(p, gosto.referencias, mult, gosto.forca);
+    if (chips.has('rapido')) p.ritmo.rapido *= 1.5;
+    if (chips.has('calmo')) { p.ritmo.lento *= 1.5; baixa('trocas', 'tremor', 0.4); baixa('trocas', 'chicote', 0.4); }
+    if (chips.has('quique')) { mult('trocas', 'giro', 1.4); mult('trocas', 'encolhe', 1.4); }
+    if (chips.has('tres_d')) { mult('cameras', 'orbita', 1.5); mult('cameras', 'cinema', 1.5); mult('trocas', 'giro', 1.4); }
+    if (chips.has('camera')) ['pulso', 'chicote', 'orbita'].forEach((n) => mult('cameras', n, 1.3));
+    if (chips.has('cortes')) { mult('trocas', 'corte', 1.4); mult('trocas', 'chicote', 1.4); }
+    aplicarNao(p, gosto.nao_quero || [], baixa);
+    let over = nOver ? somaOver / nOver : null;
+    if (over != null) {
+        if (chips.has('quique')) over += 0.05;
+        if ((gosto.nao_quero || []).includes('exagero')) over -= 0.05;
+        over = Math.round(Math.max(0, Math.min(0.3, over)) * 1000) / 1000;
+    }
+    p.overshoot = over;
+    return p;
+}
+
+/** Cada vídeo de referência inclina o ritmo dele (x1,6) e, se mexe muito, as câmeras de punch (x1,3).
+ *  O que o modelo viu nele (câmera, troca, tipografia) também sobe x1,6. Só inclina. */
+/* Quanto as referências pesam (/gosto força; ideia do Runway, "pouco / médio / igual"): o multiplicador de cada
+   referência elevado a este expoente. Médio é o de sempre; pouco quase só sugere; muito puxa forte, mas ainda é peso. */
+const FORCAS = { pouco: 0.5, medio: 1, muito: 2.2 };
+function aplicarReferencias(p, referencias, mult, forca = 'medio') {
+    const e = FORCAS[forca] || 1;
+    const k = (v) => Math.pow(v, e);
+    for (const r of Array.isArray(referencias) ? referencias : []) {
+        const m = r && r.medida;
+        if (!m) continue;
+        if (p.ritmo[m.ritmo] != null) p.ritmo[m.ritmo] *= k(1.6);
+        if (m.movimento >= MOVIMENTO_ALTO) ['pulso', 'chicote'].forEach((n) => mult('cameras', n, k(1.3)));
+        const d = r.descricao;
+        if (d) for (const grupo of ['cameras', 'trocas', 'tipografias']) (d[grupo] || []).forEach((n) => mult(grupo, n, k(1.6)));
+    }
+    const cores = (Array.isArray(referencias) ? referencias : []).flatMap((r) => ((r && r.medida && r.medida.paleta) || []).slice(0, 5));
+    if (cores.length) p.paletas = Object.fromEntries(Object.entries(pesoDasPaletas(cores)).map(([n, v]) => [n, Math.round(k(v) * 100) / 100]));
+}
+
+/* As cores dos vídeos que a pessoa trouxe inclinam a paleta do diretor (maquina-diretor.js PALETAS): cada paleta
+   ganha de 1× a 2,5× conforme o fundo e o destaque dela se parecem com alguma cor das referências. É peso: o diretor
+   só sorteia entre as paletas da metáfora, e a marca do pedido continua mandando. Puro. */
+function pesoDasPaletas(cores) {
+    const rgb = (h) => { const n = parseInt(String(h).replace('#', '').slice(0, 6), 16); return [n >> 16, (n >> 8) & 255, n & 255]; };
+    const dist = (a, b) => Math.hypot(a[0] - b[0], a[1] - b[1], a[2] - b[2]);   // 0 a ~441
+    const viva = (c) => (Math.max(...c) - Math.min(...c)) / 255 > 0.35;           // saturação simples: o acento, não o branco nem o preto
+    const refs = cores.filter((c) => /^#[0-9a-f]{6}$/i.test(c)).map(rgb);
+    const acentos = refs.filter(viva);
+    const out = {};
+    if (!refs.length) return out;
+    const sim = (h, lista) => Math.max(0, 1 - Math.min(...lista.map((r) => dist(rgb(h), r))) / 160);   // 160: cores do mesmo grupo
+    const notas = Object.entries(require('./maquina-diretor.js').PALETAS).map(([nome, pal]) =>
+        // o destaque é o que dá a cara da paleta: pesa mais, e só contra as cores vivas da referência
+        [nome, acentos.length ? 0.35 * sim(pal.fundo, refs) + 0.65 * sim(pal.destaque, acentos) : sim(pal.fundo, refs)]);
+    /* RELATIVO, não absoluto: a referência creme e marrom da Padaria parecia com forno, limão E tijolo (1,7×, 1,7× e
+       2,15×), e em 30 vídeos o tijolo ia de 11 pra 12 — o gosto quase não aparecia. Agora a paleta mais parecida
+       ganha 2,5×, a menos parecida 1×, e as outras no meio, pela distância até elas. */
+    const vals = notas.map(([, v]) => v), min = Math.min(...vals), max = Math.max(...vals);
+    for (const [nome, v] of notas) {
+        const rel = max > min ? (v - min) / (max - min) : 0;
+        out[nome] = Math.round((1 + 1.5 * rel * rel) * 100) / 100;
+    }
+    return out;
+}
+
+function aplicarNao(p, nao, baixa) {
+    if (nao.includes('lento')) p.ritmo.lento *= 0.3;
+    if (nao.includes('liso')) { baixa('trocas', 'dissolve', 0.4); baixa('trocas', 'desfoque', 0.4); }
+    if (nao.includes('exagero')) { baixa('trocas', 'tremor', 0.4); baixa('trocas', 'chicote', 0.4); }
+    if (nao.includes('tremido')) baixa('trocas', 'tremor', 0.2);
+    /* "letra pequena" só ia na frase pro modelo, e o sorteio da tipografia não sabia (medido em 24/10): agora puxa as de
+       letra grande e pesada e afasta as finas. O "flash" não tem troca na máquina (as de íris saíram: maquina-diretor.js);
+       ele só existe no estilo impacto, que não lê o gosto. */
+    if (nao.includes('letra_pequena')) {
+        ['poster', 'pesada'].forEach((n) => { p.tipografias[n] = (p.tipografias[n] != null ? p.tipografias[n] : 1) * 2; });
+        ['serifa_fina', 'manuscrita', 'tecnica'].forEach((n) => baixa('tipografias', n, 0.3));
+    }
+}
+
+const lista = (a) => (a.length <= 1 ? a.join('') : a.slice(0, -1).join(', ') + ' e ' + a[a.length - 1]);
+
+/** Uma frase só pros vídeos de referência: ritmo que mais aparece, média de cortes/s, quanto mexe e as cores. */
+function fraseReferencias(refs) {
+    const ms = refs.map((r) => r.medida);
+    const media = (f) => ms.reduce((s, m) => s + f(m), 0) / ms.length;
+    const ritmo = RITMOS.map((r) => [r, ms.filter((m) => m.ritmo === r).length]).sort((a, b) => b[1] - a[1])[0][0];
+    const cps = String(Math.round(media((m) => m.cortesPorSegundo) * 10) / 10).replace('.', ',');
+    const mov = media((m) => m.movimento);
+    const cores = [];
+    for (const m of ms) for (const c of m.paleta) if (!cores.includes(c) && cores.length < 3) cores.push(c);
+    // quase sem corte seco, o ritmo veio do movimento (chicote, zoom): "0 cortes/s" ao lado de "rápido" parecia erro
+    const comoCorta = media((m) => m.cortesPorSegundo) < 0.1 ? 'sem corte seco' : `${cps} cortes/s`;
+    const itens = [`ritmo ${ritmo === 'rapido' ? 'rápido' : ritmo === 'medio' ? 'médio' : 'lento'} (${comoCorta})`];
+    if (mov >= MOVIMENTO_ALTO) itens.push('muito movimento'); else if (mov < MOVIMENTO_BAIXO) itens.push('pouco movimento');
+    if (cores.length) itens.push(`cores ${lista(cores)}`);
+    return `Trouxe ${refs.length} ${refs.length === 1 ? 'vídeo' : 'vídeos'} de referência: ${itens.join(', ')}.`;
+}
+
+/** A mesma frase de fraseReferencias, pra um vídeo só: é o que a tela mostra como "Entendi: …". */
+function fraseDeUmaReferencia(medida) {
+    return fraseReferencias([{ medida: normalizarMedida(medida) }]);
+}
+
+/** Frases em PT-BR pro modelo. Nulo → ''. */
+function resumo(gosto) {
+    if (!gosto) return '';
+    const refs = gosto.referencias || [];
+    if (gosto.pulou && !(gosto.nao_quero || []).length && !refs.length) return 'A pessoa pulou a tela de gosto: sem preferência salva.';
+    const partes = [];
+    const esc = (gosto.escolhidos || []).map((x) => {
+        const e = ESTILOS.find((s) => s.id === x.id);
+        if (!e) return null;
+        const g = (x.gostei || []).map((i) => (GOSTEI.find((c) => c.id === i) || {}).nome).filter(Boolean);
+        return g.length ? `${e.nome} (${g.join(', ')})` : e.nome;
+    }).filter(Boolean);
+    if (esc.length) partes.push(`Gosto salvo da pessoa: gostou de ${lista(esc)}.`);
+    const nao = (gosto.nao_quero || []).map((i) => (NAO_QUERO.find((c) => c.id === i) || {}).curto).filter(Boolean);
+    if (nao.length) partes.push(`Não quer: ${nao.join(', ')}.`);
+    const txt = [(gosto.escolhidos || []).map((x) => x.texto).filter(Boolean).join(' / '), gosto.nao_texto ? 'não quer: ' + gosto.nao_texto : ''].filter(Boolean).join(' · ');
+    if (txt) partes.push(`Escreveu: "${txt}".`);
+    if (refs.length) partes.push(fraseReferencias(refs));
+    // o que o modelo viu, das referências mais novas: no máximo 3 frases no total
+    const vistas = [];
+    for (const r of [...refs].reverse()) for (const f of (r.descricao && r.descricao.frases) || []) if (vistas.length < 3 && !vistas.includes(f)) vistas.push(f);
+    if (vistas.length) partes.push(`O que se vê nelas: ${vistas.map((f) => `"${f}"`).join('; ')}.`);
+    if (!partes.length) return '';
+    partes.push('Use como direção, não como molde.');
+    return partes.join(' ');
+}
+
+/**
+ * Onde a tela de gosto abre no primeiro motion (sem gosto salvo):
+ *   'terminal' → no navegador, como sempre (tem terminal de verdade, fora do -p);
+ *   'app'      → o motor roda em -p dentro do app desktop ou do Primo.app (PRIMOCODE_APP=1): ele NÃO abre navegador,
+ *                escreve no stderr a linha de protocolo `primocode:abrir-gosto <url>` e o app abre a tela;
+ *   null       → não abre (já tem gosto, gosto:false, CI, script sem app).
+ */
+function modoTela(args = {}, env = process.env, home, tty = !!process.stdout.isTTY) {
+    if (tem(home) || (args && args.gosto === false) || env.CI) return null;
+    if (env.PRIMOCODE_APP === '1') return 'app';
+    if (env.PRIMOCODE_SEM_TELA || !tty) return null;
+    return 'terminal';
+}
+
+/** Só pergunta no primeiro pedido, com gente do outro lado (terminal ou app): nunca em CI ou script sem app. */
+function deveAbrir(args = {}, env = process.env, home) {
+    return modoTela(args, env, home) !== null;
+}
+
+/** A tela pedida pela pessoa (/referencias, /gosto refazer): no app (PRIMOCODE_APP=1) o navegador fica bloqueado,
+    então ela vai pela linha de protocolo e o app abre a janela; no terminal, pelo navegador. Resolve como abrirTela. */
+function abrirOndeDer(opcoes = {}, { env = process.env, stderr = process.stderr } = {}) {
+    if (env.PRIMOCODE_APP === '1') return abrirTela({ ...opcoes, abrir: (url) => stderr.write(linhaProtocolo(url)) });
+    return abrirTela(opcoes);
+}
+
+/** A linha que o app lê no stderr do motor. */
+const PROTOCOLO = 'primocode:abrir-gosto';
+const linhaProtocolo = (url) => `${PROTOCOLO} ${url}\n`;
+/** A URL da linha de protocolo, só se for a tela local (127.0.0.1, porta, token hex). null no resto. */
+function urlDaLinha(linha) {
+    const m = String(linha || '').trim().match(/^primocode:abrir-gosto (http:\/\/127\.0\.0\.1:(\d{2,5})\/\?t=([0-9a-f]{32}))$/);
+    return m ? m[1] : null;
+}
+
+/**
+ * O primeiro motion: abre a tela onde der (terminal → navegador; app → linha de protocolo pro app abrir) e espera.
+ * Resolve o que abrirTela resolve, ou {ok:false, motivo:'nao_abre'} sem fazer nada.
+ */
+async function antesDoMotion(args = {}, { env = process.env, home, tty, stderr = process.stderr, abrir, timeoutMs } = {}) {
+    const modo = modoTela(args, env, home, tty);
+    if (!modo) return { ok: false, motivo: 'nao_abre' };
+    if (modo === 'app') return abrirTela({ home, timeoutMs, abrir: (url) => stderr.write(linhaProtocolo(url)) });
+    try { stderr.write(require('../../tui/ui.js').c.warn('  ⎿ Antes do primeiro motion: abri uma tela pra aprender o seu gosto (até 10 min). Feche ou pule pra seguir.') + '\n'); } catch { /* sem terminal */ }
+    return abrirTela({ home, timeoutMs, abrir });
+}
+
+function lerCorpo(req, limite = 20 * 1024) {
+    return new Promise((resolve, reject) => {
+        let tam = 0; const partes = [];
+        req.on('data', (c) => {
+            tam += c.length;
+            if (tam > limite) { reject(new Error('grande')); req.destroy(); return; }
+            partes.push(c);
+        });
+        req.on('end', () => resolve(Buffer.concat(partes).toString('utf8')));
+        req.on('error', reject);
+    });
+}
+
+const EXT_VIDEO = ['.mp4', '.mov', '.m4v', '.webm'];
+const LIMITE_VIDEO = 300 * 1024 * 1024;
+
+/** Grava o corpo cru num arquivo, em stream (sem juntar na memória), e dá o nome pelo sha1 do conteúdo. Passou do limite: apaga o parcial e lança 'grande'. */
+function gravarVideo(req, pasta, ext, limite) {
+    return new Promise((resolve, reject) => {
+        fs.mkdirSync(pasta, { recursive: true });
+        const tmp = path.join(pasta, `.parcial-${crypto.randomBytes(6).toString('hex')}`);
+        const out = fs.createWriteStream(tmp);
+        const sha = crypto.createHash('sha1');
+        let tam = 0, acabou = false;
+        const falhar = (e) => {
+            if (acabou) return;
+            acabou = true;
+            req.unpipe(out); req.resume();
+            out.destroy();
+            try { fs.unlinkSync(tmp); } catch { /* já não existe */ }
+            reject(e);
+        };
+        req.on('data', (c) => {
+            tam += c.length;
+            if (tam > limite) return falhar(new Error('grande'));
+            sha.update(c);
+        });
+        req.on('error', falhar);
+        req.on('aborted', () => falhar(new Error('cortado')));
+        out.on('error', falhar);
+        out.on('finish', () => {
+            if (acabou) return;
+            acabou = true;
+            if (!tam) { try { fs.unlinkSync(tmp); } catch { /* ok */ } return reject(new Error('vazio')); }
+            const destino = path.join(pasta, sha.digest('hex').slice(0, 12) + ext);
+            fs.renameSync(tmp, destino);
+            resolve(destino);
+        });
+        req.pipe(out);
+    });
+}
+
+/**
+ * Abre a tela no navegador. Resolve {ok:true, gosto} (salvou), {ok:false, motivo:'pulou'|'tempo'|'sem_tela'}.
+ * `abrir(url)`, `home`, `visao` e `limiteVideo` são injetáveis (testes).
+ * `inicio`: 'carrossel' (padrão) ou 'referencias' (a página abre direto no passo de soltar vídeos).
+ * POST /referencia?nome=x.mp4 recebe o vídeo cru, mede (gosto-medir.js), pede ao modelo a descrição (gosto-descrever.js)
+ * e devolve {ok, id, nome, medida, frase, descricao?}. `descrever(arquivo, medida)` é injetável; null desliga.
+ * Se o modelo falhar, segue sem descrição: o cartão fica só com a medida.
+ */
+function abrirTela({ home, abrir, timeoutMs = 10 * 60 * 1000, porta = 0, inicio = 'carrossel', visao, limiteVideo = LIMITE_VIDEO, descrever } = {}) {
+    const descreverVideo = descrever === null ? null : (descrever || ((arq, medida) => require('./gosto-descrever.js').descrever(arq, medida)));
+    return new Promise((resolve) => {
+        const token = crypto.randomBytes(16).toString('hex');
+        let html;
+        try { html = fs.readFileSync(path.join(__dirname, 'gosto', 'tela.html'), 'utf8'); } catch { return resolve({ ok: false, motivo: 'sem_tela' }); }
+        // os vídeos que já estão no gosto: quem abre o /referencias de novo vê o que já trouxe (só o nome)
+        const jaTem = ((ler(home) || {}).referencias || []).map((r) => String(r.nome || 'vídeo').slice(0, 80));
+        const dados = JSON.stringify({ ESTILOS, GOSTEI, NAO_QUERO, INICIO: inicio === 'referencias' ? 'referencias' : 'carrossel', JA_TEM: jaTem }).replace(/</g, '\\u003c');
+        let fim = false, timer = null, recebidos = 0;
+        const srv = http.createServer(async (req, res) => {
+            const u = new URL(req.url, 'http://127.0.0.1');
+            const dizer = (cod, corpo, tipo = 'application/json; charset=utf-8') => { res.writeHead(cod, { 'content-type': tipo, 'cache-control': 'no-store' }); res.end(typeof corpo === 'string' ? corpo : JSON.stringify(corpo)); };
+            try {
+                if (req.method === 'GET' && u.pathname === '/') {
+                    if (u.searchParams.get('t') !== token) return dizer(403, 'token inválido', 'text/plain; charset=utf-8');
+                    return dizer(200, html.split('__TOKEN__').join(token).split('__DADOS__').join(dados), 'text/html; charset=utf-8');
+                }
+                if (req.method === 'POST' && u.pathname === '/referencia') {
+                    if (req.headers['x-gosto-token'] !== token) return dizer(403, { ok: false, error: 'token inválido' });
+                    const nome = path.basename(String(u.searchParams.get('nome') || ''));
+                    const ext = path.extname(nome).toLowerCase();
+                    if (!EXT_VIDEO.includes(ext)) return dizer(400, { ok: false, error: `só aceito vídeo (${EXT_VIDEO.join(', ')}), e este é "${nome || 'sem nome'}"` });
+                    // a tela segura 5 de cada vez (tirar devolve a vaga lá); aqui é só o teto contra abuso: 3 trocas por vaga
+                    if (recebidos >= MAX_POR_TELA) return dizer(409, { ok: false, error: `já chegaram ${MAX_POR_TELA} vídeos nesta tela. Salve e abra /taste referencias de novo pra trazer mais` });
+                    let arq;
+                    try { arq = await gravarVideo(req, path.join(home || os.homedir(), '.primocode', 'gosto-referencias'), ext, limiteVideo); }
+                    catch (e) {
+                        if (e.message === 'grande') return dizer(413, { ok: false, error: `vídeo grande demais (o limite é ${Math.round(limiteVideo / 1048576)} MB)` });
+                        return dizer(400, { ok: false, error: e.message === 'vazio' ? 'o vídeo chegou vazio' : 'o envio foi cortado' });
+                    }
+                    recebidos++;
+                    const medida = await require('./gosto-medir.js').medir(arq, { visao });
+                    if (!medida.ok) return dizer(422, { ok: false, error: medida.error || 'não consegui ler este vídeo' });
+                    let descricao = null;
+                    if (descreverVideo) {
+                        try {
+                            const d = await Promise.race([descreverVideo(arq, medida), new Promise((r) => { const t = setTimeout(() => r(null), 90 * 1000); if (t.unref) t.unref(); })]);
+                            if (d && d.ok) descricao = normalizarDescricao(d.descricao);
+                        } catch { /* sem descrição: o cartão fica só com a medida */ }
+                    }
+                    return dizer(200, { ok: true, id: path.basename(arq, ext), nome: nome.slice(0, 80), medida, frase: fraseDeUmaReferencia(medida), ...(descricao ? { descricao } : {}) });
+                }
+                if (req.method === 'POST' && (u.pathname === '/salvar' || u.pathname === '/pular' || u.pathname === '/fechar')) {
+                    if (req.headers['x-gosto-token'] !== token) return dizer(403, { ok: false, error: 'token inválido' });
+                    if (u.pathname === '/fechar') {   // o app fechou a janela sem salvar: o motion segue, nada é gravado (o próximo pergunta de novo)
+                        dizer(200, { ok: true });
+                        return terminar({ ok: false, motivo: 'fechou' });
+                    }
+                    if (u.pathname === '/pular') {
+                        salvar({ pulou: true }, home);
+                        dizer(200, { ok: true });
+                        return terminar({ ok: false, motivo: 'pulou' });
+                    }
+                    let corpo;
+                    try { corpo = JSON.parse(await lerCorpo(req)); } catch { return dizer(400, { ok: false, error: 'corpo inválido (JSON até 20 KB)' }); }
+                    // modo 'referencias': junta com o gosto que já existe (o carrossel fica como estava) e guarda as 5 mais novas
+                    if (corpo && corpo.modo === 'referencias') {
+                        const antes = ler(home) || normalizar({});
+                        corpo = { ...antes, referencias: [...(antes.referencias || []), ...normalizarReferencias(corpo.referencias)].slice(-MAX_REFERENCIAS) };
+                    }
+                    const g = salvar(corpo, home);
+                    dizer(200, { ok: true, resumo: resumo(g), tende: inclinacao(pesos(g)) });
+                    return terminar({ ok: true, gosto: g });
+                }
+                dizer(404, 'não achei', 'text/plain; charset=utf-8');
+            } catch (e) { try { dizer(500, { ok: false, error: String(e.message || e) }); } catch { /* já respondeu */ } }
+        });
+        function terminar(r) {
+            if (fim) return;
+            fim = true;
+            clearTimeout(timer);
+            try { srv.close(); } catch { /* já fechou */ }
+            // deixa a resposta sair e depois derruba o que sobrar de conexão aberta (keep-alive do navegador)
+            const t = setTimeout(() => { try { if (srv.closeAllConnections) srv.closeAllConnections(); } catch { /* ok */ } }, 300);
+            if (t.unref) t.unref();
+            resolve(r);
+        }
+        srv.on('error', () => terminar({ ok: false, motivo: 'sem_tela' }));
+        srv.listen(porta, '127.0.0.1', () => {
+            timer = setTimeout(() => terminar({ ok: false, motivo: 'tempo' }), timeoutMs);
+            const url = `http://127.0.0.1:${srv.address().port}/?t=${token}`;
+            try {
+                const r = (abrir || ((x) => require('../../tool/tools.js').openInBrowser(x)))(url);
+                if (r && typeof r.catch === 'function') r.catch(() => {});
+            } catch { /* sem navegador: a pessoa espera o tempo ou pula */ }
+        });
+    });
+}
+
+const _teste = { texto, MAX_TEXTO, aplicarNao, pesoDasPaletas, inclinacao };
+
+module.exports = { ESTILOS, GOSTEI, NAO_QUERO, arquivo, ler, salvar, tem, normalizar, pesos, resumo, adicionarReferencia, tirarReferencia, listar, abrirOndeDer, salvarEstilo, usarEstilo, estilos, nomeDoEstilo, definirForca, fraseDeUmaReferencia, abrirTela, deveAbrir, modoTela, antesDoMotion, PROTOCOLO, linhaProtocolo, urlDaLinha, _teste };