primocode 10.17.1 → 11.0.0

package/lib/estudio/gosto/tela.html

@@ -246,6 +246,17 @@ pre { margin: 0; overflow-x: auto; background: var(--palco); border-radius: 18px
 .pular { font-size: 14px; color: var(--apagado); }
 .erro { margin: 14px auto 0; max-width: 46ch; text-align: center; color: var(--vermelho); font-size: 15px; }
 .nota { color: var(--apagado); font-size: 14px; margin: 0; max-width: 60ch; }
+.soltar { display: block; width: min(560px, 100%); margin: 0 auto 22px; padding: 38px 24px; font: inherit; text-align: center; cursor: pointer; color: var(--apagado); background: var(--palco); border: 1.5px dashed var(--linha); border-radius: 22px; transition: border-color .15s ease, color .15s ease; }
+.soltar:hover, .soltar.sobre { border-color: var(--ambar); color: var(--giz); }
+.soltar:focus-visible { outline: 2px solid var(--ambar); outline-offset: 3px; }
+#passoRef .lista { max-width: 560px; margin: 0 auto; }
+#passoRef .item { grid-template-columns: 96px minmax(0, 1fr) auto; gap: 16px; padding: 18px 22px; }
+#passoRef .previa { width: 96px; aspect-ratio: 1; object-fit: cover; border-radius: 14px; background: var(--bg); align-self: start; }
+#passoRef .cores { display: flex; gap: 6px; margin: 8px 0 0; }
+#passoRef .cor { width: 18px; height: 18px; border-radius: 50%; box-shadow: inset 0 0 0 1px var(--linha); }
+#passoRef .leva { margin: 8px 0 0; opacity: .8; }
+@media (max-width: 700px) { #passoRef .item { grid-template-columns: 72px minmax(0, 1fr); } #passoRef .previa { width: 72px; } #passoRef .item > .link { grid-column: 2; justify-self: start; } }
+#passoRef .item h3 { margin: 0 0 4px; font-size: 17px; overflow-wrap: anywhere; }
 code { font-family: var(--f-mono); font-size: .92em; }
 </style>
 
@@ -262,7 +273,7 @@ code { font-family: var(--f-mono); font-size: .92em; }
       <button class="seta seta-vai" id="setaVai" aria-label="Avançar" aria-controls="grade"><svg viewBox="0 0 24 24" aria-hidden="true"><path d="M9 5l7 7-7 7"/></svg></button>
     </div>
     <div class="acoes" style="margin-top:36px"><button class="btn btn-grande" id="ir2" disabled>Continuar</button></div>
-    <div class="acoes" style="margin-top:14px"><button class="link pular" id="pular">pular por agora</button></div>
+    <div class="acoes" style="margin-top:14px"><button class="link pular" id="pular">pular por agora</button><button class="link pular" id="irRef">ou solte vídeos que você curtiu</button></div>
   </section>
 
   <section id="passo2" hidden>
@@ -287,6 +298,15 @@ code { font-family: var(--f-mono); font-size: .92em; }
     <div class="acoes" style="margin-top:22px"><button class="btn" id="salvar">Salvar meu gosto</button><button class="link" id="volta2">voltar</button></div>
   </section>
 
+  <section id="passoRef" hidden>
+    <button class="soltar" id="soltar" type="button">Solte aqui os vídeos que você curtiu, ou clique pra escolher. Até 5, em mp4, mov, m4v ou webm.</button>
+    <input type="file" id="arquivosRef" accept="video/*" multiple hidden>
+    <p class="nota" id="jaTemRef" hidden style="text-align:center;margin:0 0 16px"></p>
+    <div class="lista" id="listaRef"></div>
+    <p class="erro" id="erroRef" role="alert" hidden></p>
+    <div class="acoes" style="margin-top:22px"><button class="btn" id="salvarRef" disabled>Salvar</button><button class="link" id="voltaRef">voltar</button></div>
+  </section>
+
   <section id="passo4" hidden>
     <div class="fim">
       <div class="fim-check" aria-hidden="true"><svg viewBox="0 0 52 52"><circle cx="26" cy="26" r="23"/><path d="M15.5 27l7 7 14-15"/></svg></div>
@@ -1083,11 +1103,12 @@ function ligarSetas(t = $('#grade'), volta = $('#setaVolta'), vai = $('#setaVai'
 }
 
 function mostrar(n) {
-  [1, 2, 3, 4].forEach((i) => { $('#passo' + i).hidden = i !== n; });
+  [1, 2, 3, 4, 'Ref'].forEach((i) => { $('#passo' + i).hidden = i !== n; });
   const t = { 1: ['Qual movimento tem a sua cara?', 'Toque nos estilos que você curtiu. Pode ser mais de um. O PrimoCode aprende com isso e usa nos próximos vídeos.'],
     2: ['Quase lá. Mais disso ou menos disso?', ''],
     3: ['E o que não pode ter?', 'Isso pesa contra no diretor. Marca só o que te incomoda de verdade.'],
-    4: ['Pronto. Seu próximo vídeo já sai com a sua cara.', ''] }[n];
+    4: ['Pronto. Seu próximo vídeo já sai com a sua cara.', ''],
+    Ref: ['Solte os motions que você curtiu', 'O PrimoCode mede cada vídeo aqui no seu computador (cortes, ritmo, movimento e cores) e usa como direção.'] }[n];
   $('#titulo').textContent = t[0];
   window.scrollTo({ top: 0, behavior: parar ? 'auto' : 'smooth' });
 }
@@ -1202,7 +1223,7 @@ let salvando = false;
 $('#ir3').addEventListener('click', () => {
   if (salvando) return;
   salvando = true; erro(''); $('#ir3').disabled = true;
-  mandar('/salvar', gostoJson()).then(() => mostrar(4)).catch((e) => {
+  mandar('/salvar', gostoJson()).then((j) => { mostrar(4); mostrarTendencia(j); }).catch((e) => {
     salvando = false; $('#ir3').disabled = false; $('#ir3').textContent = 'Tentar de novo';
     erro('Não consegui salvar: ' + e.message + '. O PrimoCode ainda está aberto no terminal?');
   });
@@ -1260,9 +1281,103 @@ function mandar(rota, corpo) {
   return fetch(rota, { method: 'POST', headers: { 'content-type': 'application/json', 'x-gosto-token': TOKEN }, body: JSON.stringify(corpo) })
     .then((r) => r.json().then((j) => { if (!r.ok || !j.ok) throw new Error(j.error || ('erro ' + r.status)); return j; }));
 }
+/* ── vídeos que a pessoa curtiu: solta, o PrimoCode mede, ela confere e tira o que não quer ── */
+const referencias = [];   // { nome, medida, frase, descricao? } — a descricao é o que o modelo viu; a pessoa corrige (frases e chips)
+let enviandoRef = false;
+function erroRef(msg) { const e = $('#erroRef'); e.hidden = !msg; e.textContent = msg || ''; }
+function atualizarRef() { $('#salvarRef').disabled = enviandoRef || !referencias.length; }
+/* O que o modelo viu no vídeo: os ids viram chips (clicar tira) e as frases ficam num campo, uma por linha.
+   Tudo que a pessoa deixar aqui é o que vai no /salvar: a IA decide, a pessoa confere. */
+function mostrarDescricao(ref, d, caixa) {
+  ref.descricao = { cameras: [...(d.cameras || [])], trocas: [...(d.trocas || [])], tipografias: [...(d.tipografias || [])], frases: [...(d.frases || [])] };
+  const chips = el('div', { class: 'chips', style: 'margin:12px 0 0' });
+  for (const grupo of ['cameras', 'trocas', 'tipografias']) {
+    for (const id of ref.descricao[grupo]) {
+      const chip = el('button', { class: 'chip', type: 'button', title: 'clique pra tirar', text: id + ' ×' });
+      chip.addEventListener('click', () => { ref.descricao[grupo] = ref.descricao[grupo].filter((x) => x !== id); chip.remove(); });
+      chips.appendChild(chip);
+    }
+  }
+  const frases = el('textarea', { 'aria-label': 'O que se vê neste vídeo, uma frase por linha' });
+  frases.value = ref.descricao.frases.join('\n');
+  frases.addEventListener('input', () => { ref.descricao.frases = frases.value.split('\n').map((x) => x.trim()).filter(Boolean).slice(0, 3); });
+  caixa.appendChild(chips);
+  caixa.appendChild(el('p', { class: 'nota', style: 'margin:12px 0 6px', text: 'O que o PrimoCode viu nele (corrija se errou):' }));
+  caixa.appendChild(frases);
+}
+async function enviarRef(arquivos) {
+  if (enviandoRef) return;
+  enviandoRef = true; erroRef(''); atualizarRef();
+  for (const f of arquivos) {
+    if (referencias.length >= 5) { erroRef('Já tem 5 vídeos. Tire um pra trazer outro.'); break; }
+    const dica = el('p', { class: 'nota', text: 'medindo e olhando o vídeo…' });
+    const tirar = el('button', { class: 'link', text: 'tirar' });
+    // o próprio arquivo, tocando mudo no cartão: com 3 ou 4 vídeos, o nome sozinho não diz qual é qual
+    const url = URL.createObjectURL(f);
+    const previa = el('video', { class: 'previa', src: url, 'aria-hidden': 'true' });
+    previa.muted = true; previa.loop = true; previa.playsInline = true; previa.autoplay = true;
+    const cartao = el('div', { class: 'item' }, [previa, el('div', {}, [el('h3', { text: f.name }), dica]), tirar]);
+    const largar = () => { URL.revokeObjectURL(url); cartao.remove(); };
+    $('#listaRef').appendChild(cartao);
+    try {
+      const r = await fetch('/referencia?nome=' + encodeURIComponent(f.name), { method: 'POST', headers: { 'x-gosto-token': TOKEN }, body: f })
+        .then((x) => x.json().then((j) => { if (!x.ok || !j.ok) throw new Error(j.error || ('erro ' + x.status)); return j; }));
+      const ref = { nome: r.nome, medida: r.medida, frase: r.frase };
+      referencias.push(ref);
+      // as cores viram bolinhas: "#fefdfd, #151318" não diz nada a quem olha a tela
+      dica.textContent = 'Entendi: ' + r.frase.replace(/^Trouxe 1 vídeo de referência: /, '').replace(/,? ?cores? #[0-9a-f]{6}(?:(?:, | e )#[0-9a-f]{6})*/i, '').replace(/\.?$/, '.');
+      const cores = el('div', { class: 'cores', 'aria-label': 'cores do vídeo' }, ((r.medida && r.medida.paleta) || []).slice(0, 5).map((h) => el('span', { class: 'cor', title: h, style: 'background:' + h })));
+      if (cores.childNodes.length) dica.after(cores);
+      // o que vem da referência e o que não vem: quem solta o vídeo de outra marca quer saber que não vai sair uma cópia
+      const leva = el('p', { class: 'nota leva', text: 'Levo daqui: o ritmo, o movimento e as cores. Não copio: o texto, a logo, a música nem as pessoas do vídeo.' });
+      (cores.childNodes.length ? cores : dica).after(leva);
+      if (r.descricao) mostrarDescricao(ref, r.descricao, dica.parentNode);
+      tirar.addEventListener('click', () => { referencias.splice(referencias.indexOf(ref), 1); largar(); erroRef(''); atualizarRef(); });
+    } catch (e) {
+      largar();
+      erroRef(f.name + ': ' + e.message);
+    }
+  }
+  enviandoRef = false; atualizarRef();
+  $('#arquivosRef').value = '';
+}
+const soltar = $('#soltar');
+soltar.addEventListener('click', () => $('#arquivosRef').click());
+soltar.addEventListener('dragover', (ev) => { ev.preventDefault(); soltar.classList.add('sobre'); });
+soltar.addEventListener('dragleave', () => soltar.classList.remove('sobre'));
+soltar.addEventListener('drop', (ev) => { ev.preventDefault(); soltar.classList.remove('sobre'); enviarRef(Array.from(ev.dataTransfer.files)); });
+$('#arquivosRef').addEventListener('change', (ev) => enviarRef(Array.from(ev.target.files)));
+$('#irRef').addEventListener('click', () => mostrar('Ref'));
+$('#voltaRef').addEventListener('click', () => mostrar(1));
+$('#salvarRef').addEventListener('click', () => {
+  if (enviandoRef) return;
+  $('#salvarRef').disabled = true; erroRef('');
+  const quando = new Date().toISOString();
+  mandar('/salvar', { modo: 'referencias', referencias: referencias.map((r) => ({ nome: r.nome, quando, medida: r.medida, ...(r.descricao ? { descricao: r.descricao } : {}) })) })
+    .then((j) => { mostrar(4); mostrarTendencia(j); })
+    .catch((e) => { atualizarRef(); erroRef('Não consegui salvar: ' + e.message + '. O PrimoCode ainda está aberto no terminal?'); });
+});
+
+/* Depois de salvar: O QUE muda no próximo vídeo, e não só "com a sua cara" (o mesmo texto do /gosto). */
+function mostrarTendencia(j) {
+  if (!j || !j.tende) return;
+  let p = $('#fimTende');
+  if (!p) { p = el('p', { class: 'fim-sub', id: 'fimTende', style: 'margin-top:6px' }); $('#fimSub').after(p); }
+  p.textContent = `O próximo motion tende a: ${j.tende}.`;
+}
 function erro(msg) { const e = $('#erro'); e.hidden = !msg; e.textContent = msg || ''; }
 
 passo1();
+/* Os vídeos que já estão no gosto (o servidor manda os nomes): sem isto, abrir o /referencias de novo parecia começar do zero. */
+(function jaTem() {
+  const nomes = (window.GOSTO && window.GOSTO.JA_TEM) || [];
+  if (!nomes.length) return;
+  const p = $('#jaTemRef');
+  p.textContent = `Já no seu gosto: ${nomes.join(', ')}. Os novos entram junto (até 5; o mais antigo sai). /gosto tirar N tira um.`;
+  p.hidden = false;
+  $('#irRef').textContent = `ou solte vídeos que você curtiu (já tem ${nomes.length})`;
+})();
+if (window.GOSTO && window.GOSTO.INICIO === 'referencias') mostrar('Ref');
 
 /* ── o fundo: ondas 3D em degradê, desenhadas na GPU ───────────────────────
    Seis camadas de onda, de trás pra frente; cada uma tem luz pela inclinação

package/lib/estudio/gosto-descrever.js

@@ -0,0 +1,87 @@
+/**
+ * gosto-descrever.js — o modelo olha o vídeo que a pessoa curtiu e descreve no vocabulário do diretor.
+ *
+ * A medida (gosto-medir.js) dá os números; aqui um mosaico de 12 quadros vai ao servidor (POST /api/gosto/descrever,
+ * Gemini com visão) e volta com câmeras, trocas e tipografias do vocabulário + 2 ou 3 frases do que se vê.
+ * A tela mostra isso e a pessoa corrige antes de salvar: a IA decide, a pessoa confere.
+ *
+ *   mosaico(arquivo, {duracao, saida})                12 quadros num JPEG só (ffmpeg), abaixo de ~1 MB
+ *   descrever(arquivo, medida, {api, servidor, token}) → {ok, descricao} | {ok:false, motivo}. Nunca lança.
+ *   filtrarDescricao(d, vocabulario)                  só ids do vocabulário, até 3 por grupo, até 3 frases de 160
+ *   vocabulario()                                     {cameras, trocas, tipografias} do maquina-diretor.js
+ */
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const LIMITE_MOSAICO = 1024 * 1024;   // o servidor recusa base64 acima de 1,5 MB: 1 MB de jpeg vira ~1,37 MB
+const MAX_FRASES = 3;
+const MAX_FRASE = 160;
+const GRUPOS = ['cameras', 'trocas', 'tipografias'];
+
+/** O vocabulário do diretor: o que o modelo pode escolher. */
+function vocabulario() {
+    const d = require('./maquina-diretor.js');
+    return { cameras: [...d.CAMERAS], trocas: [...d.TRANSICOES], tipografias: Object.keys(d.TIPOGRAFIAS) };
+}
+
+/** Só ids do vocabulário (sem repetir), até 3 por grupo; até 3 frases curtas, sem caractere de controle. */
+function filtrarDescricao(d, vocab) {
+    const o = d && typeof d === 'object' ? d : {};
+    const v = vocab || vocabulario();
+    const out = {};
+    for (const g of GRUPOS) {
+        const ok = new Set(Array.isArray(v[g]) ? v[g] : []);
+        out[g] = [...new Set(Array.isArray(o[g]) ? o[g] : [])].filter((x) => typeof x === 'string' && ok.has(x)).slice(0, 3);
+    }
+    out.frases = (Array.isArray(o.frases) ? o.frases : [])
+        .map((f) => String(f == null ? '' : f).replace(/[\u0000-\u001f\u007f]+/g, ' ').replace(/\s+/g, ' ').trim().slice(0, MAX_FRASE))
+        .filter(Boolean).slice(0, MAX_FRASES);
+    return out;
+}
+
+/** 12 quadros espaçados num JPEG 4x3 (mesma ideia da folhaDeContato do maquina-layout). Devolve o caminho ou null. */
+async function mosaico(arquivo, { duracao, saida } = {}) {
+    const dur = Math.max(1, Number(duracao) || 15);
+    const destino = saida || path.join(os.tmpdir(), `primocode-mosaico-${process.pid}-${Date.now()}.jpg`);
+    // qualidade 5 costuma bastar; se passar de 1 MB, baixa até caber
+    for (const q of [5, 9, 14, 20]) {
+        const r = spawnSync('ffmpeg', ['-y', '-v', 'error', '-i', arquivo, '-vf', `fps=12/${dur.toFixed(3)},scale=320:-2,tile=4x3`, '-frames:v', '1', '-q:v', String(q), destino], { encoding: 'utf8' });
+        if (r.status !== 0 || !fs.existsSync(destino)) return null;
+        if (fs.statSync(destino).size < LIMITE_MOSAICO) return destino;
+    }
+    try { fs.unlinkSync(destino); } catch { /* ok */ }
+    return null;
+}
+
+/**
+ * Monta o mosaico, pergunta ao servidor e devolve {ok:true, descricao} (já filtrada aqui: não confia no servidor)
+ * ou {ok:false, motivo}. `api` é injetável: { request(servidor, endpoint, payload, token) }.
+ */
+async function descrever(arquivo, medida, { api, servidor, token } = {}) {
+    let jpg = null;
+    try {
+        jpg = await mosaico(arquivo, { duracao: medida && medida.segundos });
+        if (!jpg) return { ok: false, motivo: 'sem_mosaico' };
+        let cliente = api, url = servidor, tk = token;
+        if (!cliente || !url) {
+            const cfg = require('../config.js').loadConfig();
+            cliente = cliente || require('../api.js');
+            url = url || cfg.server;
+            tk = tk !== undefined ? tk : cfg.token;
+        }
+        const vocab = vocabulario();
+        const r = await cliente.request(url, '/api/gosto/descrever', { imagem: fs.readFileSync(jpg).toString('base64'), medida: medida || {}, vocabulario: vocab }, tk);
+        if (!r || r.ok !== true || !r.descricao) return { ok: false, motivo: r && r.semVisao ? 'sem_visao' : String((r && (r.error || r.erro)) || 'sem_resposta').slice(0, 200) };
+        return { ok: true, descricao: filtrarDescricao(r.descricao, vocab) };
+    } catch (e) {
+        return { ok: false, motivo: String((e && e.message) || e).slice(0, 200) };
+    } finally {
+        if (jpg) { try { fs.unlinkSync(jpg); } catch { /* ok */ } }
+    }
+}
+
+module.exports = { mosaico, descrever, filtrarDescricao, vocabulario };

package/lib/estudio/gosto-medir.js

@@ -0,0 +1,204 @@
+/**
+ * gosto-medir.js — o gosto pela referência: mede o vídeo que a pessoa curtiu, sem modelo, no Mac.
+ *
+ *   medir(arquivo, {visao, segundosMax}) → {ok, arquivo, segundos, formato, cortes, cortesPorSegundo, ritmo, movimento, paleta, texto}
+ *   lerCortes(texto) · ritmoDe(cps) · movimentoDe(buf, W, H) · paletaDe(buf)     as contas, puras
+ *
+ * Só medida: quantos cortes, o quanto mexe, as cores, onde fica o texto. Nada de estilo fixo: o gosto.js só usa
+ * esses números pra inclinar pesos (regra do dono: gosto é contexto e peso, não trilho). Só os primeiros
+ * `segundosMax` segundos contam. `medir` nunca lança; sem o Vision, `texto` fica null e o resto segue.
+ */
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawn } = require('child_process');
+const video = require('./video.js');
+const { LIM } = require('./conferencia-visual.js');
+
+const QUADROS = 8;
+const r2 = (n) => Math.round(n * 100) / 100;
+
+/** Os instantes de cada corte, da saída do `select='gt(scene,0.3)',showinfo` (uma linha com pts_time por quadro que passou). */
+function lerCortes(texto) {
+    const out = [];
+    for (const linha of String(texto || '').split('\n')) {
+        const m = linha.match(/showinfo.*pts_time:\s*(-?[\d.]+)/);
+        if (m && Number(m[1]) > 0) out.push(r2(Number(m[1])));
+    }
+    return out;
+}
+
+/* O diretor usa cena média de 2,5 s (rápido), 3,0 s (médio) e 3,5 s (lento) (maquina-diretor.js:328-329).
+   Os cortes ficam no meio de cada par: cena de 2,75 s (0,364 cortes/s) e de 3,25 s (0,308 cortes/s). */
+const RITMO_CORTE = { rapido: 1 / 2.75, lento: 1 / 3.25 };
+/* Só corte não basta: no motion do PrimoCode a troca é chicote, zoom ou giro, e o `scene` do ffmpeg quase não vê. Medido em
+   24/10 em 3 motions reais: ToStudy 0,03 cortes/s com movimento 0,58; Chefe José 0,2 com 0,28; Padaria 0,12 com 0,22. Pelos
+   cortes, os três saíam "lento". Então o movimento também conta: 0,4 ou mais é rápido, 0,2 ou mais é pelo menos médio. */
+const RITMO_MOV = { rapido: 0.4, medio: 0.2 };
+function ritmoDe(cortesPorSegundo, movimento = 0) {
+    const c = Number(cortesPorSegundo) || 0, m = Number(movimento) || 0;
+    if (c >= RITMO_CORTE.rapido || m >= RITMO_MOV.rapido) return 'rapido';
+    return c >= RITMO_CORTE.lento || m >= RITMO_MOV.medio ? 'medio' : 'lento';
+}
+
+/* Mediana da diferença de luminância (0 a 255) entre quadros seguidos, dividida por MOV_REF. A mediana (e não a média) deixa
+   o corte seco de fora: ele pula ~47 num quadro só e não é "movimento". Medido em 24/10 a 10 fps, 64 px: cores chapadas em
+   3 cortes 0,0; testsrc do ffmpeg ~1,0. Com MOV_REF = 5 o testsrc dá ~0,2; passou de 1 corta em 1. */
+const MOV_REF = 5;
+function movimentoDe(buf, W, H) {
+    const tam = W * H, n = tam > 0 ? Math.floor(buf.length / tam) : 0;
+    if (n < 2) return 0;
+    const ds = [];
+    for (let q = 1; q < n; q++) {
+        let d = 0;
+        for (let i = 0, a = (q - 1) * tam, b = q * tam; i < tam; i++) d += Math.abs(buf[b + i] - buf[a + i]);
+        ds.push(d / tam);
+    }
+    ds.sort((x, y) => x - y);
+    const mediana = ds.length % 2 ? ds[(ds.length - 1) / 2] : (ds[ds.length / 2 - 1] + ds[ds.length / 2]) / 2;
+    return r2(Math.min(1, mediana / MOV_REF));
+}
+
+/** As até 5 cores que mais aparecem num buffer rgb24 (vários quadros juntos): 4 bits por canal, e cor parecida (< 60 de distância) soma na mais forte. */
+function paletaDe(buf) {
+    const cestas = new Map();
+    for (let i = 0; i + 2 < buf.length; i += 3) {
+        const k = ((buf[i] >> 4) << 8) | ((buf[i + 1] >> 4) << 4) | (buf[i + 2] >> 4);
+        const c = cestas.get(k) || { n: 0, r: 0, g: 0, b: 0 };
+        c.n++; c.r += buf[i]; c.g += buf[i + 1]; c.b += buf[i + 2];
+        cestas.set(k, c);
+    }
+    const cores = [...cestas.values()].sort((a, b) => b.n - a.n).map((c) => ({ n: c.n, rgb: [c.r / c.n, c.g / c.n, c.b / c.n] }));
+    const fica = [];
+    for (const c of cores) {
+        if (fica.length >= 5) break;
+        if (fica.some((f) => Math.hypot(f.rgb[0] - c.rgb[0], f.rgb[1] - c.rgb[1], f.rgb[2] - c.rgb[2]) < 60)) continue;
+        fica.push(c);
+    }
+    return fica.map((c) => '#' + c.rgb.map((v) => Math.round(v).toString(16).padStart(2, '0')).join(''));
+}
+
+const formatoDe = (w, h) => {
+    const r = w && h ? w / h : 0;
+    const perto = (alvo) => Math.abs(r - alvo) / alvo < 0.05;
+    return perto(9 / 16) ? '9:16' : perto(16 / 9) ? '16:9' : perto(1) ? '1:1' : 'outro';
+};
+
+/** Roda o ffmpeg e devolve a saída binária (stdout) e o texto do stderr. */
+function ffmpegBin(args, timeout = 5 * 60000) {
+    return new Promise((resolve) => {
+        const p = spawn(video.ffmpeg(), ['-hide_banner', '-nostats', ...args]);
+        const saida = [], erro = [];
+        p.stdout.on('data', (d) => saida.push(d));
+        p.stderr.on('data', (d) => erro.push(d));
+        const relogio = setTimeout(() => { try { p.kill(); } catch { /* já saiu */ } }, timeout);
+        p.on('close', (code) => { clearTimeout(relogio); resolve({ ok: code === 0, buf: Buffer.concat(saida), erro: Buffer.concat(erro).toString() }); });
+        p.on('error', (e) => { clearTimeout(relogio); resolve({ ok: false, buf: Buffer.alloc(0), erro: e.message }); });
+    });
+}
+
+/** O texto que aparece nos quadros lidos pelo Vision, com os mesmos filtros de confiança da conferência. Puro. */
+function julgarTexto(quadros) {
+    let comTexto = 0, alturas = [], centros = [];
+    for (const q of quadros) {
+        if (!q || !q.ok || !q.h) continue;
+        const ts = (q.textos || []).filter((t) => t.conf >= LIM.conf && (t.caixa[3] - t.caixa[1]) >= q.h * LIM.alturaMin && String(t.texto).replace(/[^A-Za-zÀ-ÿ0-9]/g, '').length >= 2);
+        if (!ts.length) continue;
+        comTexto++;
+        for (const t of ts) { alturas.push((t.caixa[3] - t.caixa[1]) / q.h); centros.push((t.caixa[1] + t.caixa[3]) / 2 / q.h); }
+    }
+    const n = quadros.filter((q) => q && q.ok && q.h).length;
+    if (!n) return null;
+    const media = (a) => (a.length ? a.reduce((x, y) => x + y, 0) / a.length : 0);
+    const y = media(centros);
+    return { fracaoComTexto: r2(comTexto / n), alturaMedia: Math.round(media(alturas) * 1000) / 1000, lugar: !centros.length ? null : y < 1 / 3 ? 'topo' : y < 2 / 3 ? 'meio' : 'baixo' };
+}
+
+async function medir(arquivo, { visao, segundosMax = 60 } = {}) {
+    let pasta = null;
+    try {
+        const info = await video.medir(arquivo);
+        if (!info.ok) return { ok: false, error: info.error };
+        if (!(info.segundos > 0) || !info.largura) return { ok: false, error: 'o vídeo não tem imagem ou duração' };
+        const dur = Math.min(info.segundos, segundosMax);
+        const t = ['-t', String(dur)];
+
+        const sc = await ffmpegBin([...t, '-i', arquivo, '-vf', "select='gt(scene,0.3)',showinfo", '-an', '-f', 'null', '-']);
+        const cortes = lerCortes(sc.erro).filter((s) => s < dur);
+        const cortesPorSegundo = r2(cortes.length / dur);
+
+        const H = Math.round(info.altura * 64 / info.largura / 2) * 2;   // o scale=64:-2 arredonda pro par mais perto
+        const mv = await ffmpegBin([...t, '-i', arquivo, '-vf', 'fps=10,scale=64:-2,format=gray', '-an', '-f', 'rawvideo', '-']);
+        const movimento = mv.ok ? movimentoDe(mv.buf, 64, H) : 0;
+
+        pasta = fs.mkdtempSync(path.join(os.tmpdir(), 'gosto-medir-'));
+        const pngs = [], pixels = [];
+        for (let i = 0; i < QUADROS; i++) {
+            const png = path.join(pasta, `q${i}.png`);
+            const q = await video.quadro(arquivo, png, (i + 0.5) * dur / QUADROS);
+            if (!q.ok) continue;
+            pngs.push(png);
+            const px = await ffmpegBin(['-i', png, '-vf', 'scale=64:-2', '-pix_fmt', 'rgb24', '-f', 'rawvideo', '-']);
+            if (px.ok) pixels.push(px.buf);
+        }
+        const paleta = paletaDe(Buffer.concat(pixels));
+
+        let V = visao;
+        if (V === undefined) { try { V = require('./visao.js'); } catch { V = null; } }
+        let texto = null;
+        if (V && V.disponivel() && pngs.length) {
+            const r = V.ler(pngs);
+            if (r && r.ok) texto = julgarTexto(r.quadros);
+        }
+
+        return { ok: true, arquivo, segundos: r2(info.segundos), formato: formatoDe(info.largura, info.altura), cortes, cortesPorSegundo, ritmo: ritmoDe(cortesPorSegundo, movimento), movimento, paleta, texto };
+    } catch (e) {
+        return { ok: false, error: String((e && e.message) || e) };
+    } finally {
+        if (pasta) { try { fs.rmSync(pasta, { recursive: true, force: true }); } catch { /* o sistema limpa */ } }
+    }
+}
+
+/* A medida em português, pro terminal: o JSON cru não dizia nada a quem não escreveu o código.
+   `cor` pinta um bloco de cada cor da paleta (truecolor); sem ela, só o hex. Pura. */
+const num = (n) => String(Math.round(n * 10) / 10).replace('.', ',');
+function explicar(m, { cor = false } = {}) {
+    if (!m || !m.ok) return [`não deu pra medir: ${(m && m.error) || 'erro desconhecido'}`];
+    const nome = path.basename(m.arquivo || 'vídeo');
+    const ritmo = { rapido: 'rápido', medio: 'médio', lento: 'lento' }[m.ritmo] || m.ritmo;
+    const cortes = m.cortes.length ? `${m.cortes.length} ${m.cortes.length === 1 ? 'corte seco' : 'cortes secos'} em ${num(m.segundos)} s` : 'sem corte seco';
+    const mexe = m.movimento >= RITMO_MOV.rapido ? 'muito' : m.movimento >= RITMO_MOV.medio ? 'médio' : m.movimento >= 0.1 ? 'pouco' : 'quase parado';
+    const bloco = (h) => {
+        if (!cor) return h;
+        const [r, g, b] = [1, 3, 5].map((i) => parseInt(h.slice(i, i + 2), 16));
+        return `\x1b[38;2;${r};${g};${b}m██\x1b[0m ${h}`;
+    };
+    const t = m.texto;
+    const texto = !t ? 'não medido (sem o Vision do macOS)' : !t.fracaoComTexto ? 'nenhum'
+        : `em ${Math.round(t.fracaoComTexto * 100)}% dos quadros, ${t.lugar === 'topo' ? 'no topo' : t.lugar === 'baixo' ? 'embaixo' : 'no meio'}, com ${Math.round(t.alturaMedia * 100)}% da altura`;
+    return [
+        `${nome} · ${num(m.segundos)} s · ${m.formato}`,
+        `  ritmo      ${ritmo} (${cortes})`,
+        `  movimento  ${mexe} (${String(m.movimento).replace(".", ",")})`,
+        `  cores      ${(m.paleta || []).map(bloco).join('  ') || 'nenhuma'}`,
+        `  texto      ${texto}`,
+    ];
+}
+
+/* Os vídeos de uma lista de caminhos: pasta vira os vídeos dela (só o primeiro nível, em ordem), arquivo fica
+   como está. É pra "primocode gosto medir ~/Downloads/motions-que-aprovei --salvar" de uma vez. */
+const EXT_VIDEO = /\.(mp4|mov|m4v|webm)$/i;
+function videosDe(caminhos) {
+    const out = [];
+    for (const c of caminhos || []) {
+        let st = null;
+        try { st = fs.statSync(c); } catch { out.push(c); continue; }   // não existe: o medir diz o erro
+        if (!st.isDirectory()) { out.push(c); continue; }
+        for (const f of fs.readdirSync(c).filter((f) => EXT_VIDEO.test(f) && !f.startsWith('.')).sort()) out.push(path.join(c, f));
+    }
+    return out;
+}
+
+module.exports = { medir, explicar, videosDe, lerCortes, ritmoDe, movimentoDe, paletaDe, julgarTexto, MOV_REF };

package/lib/estudio/gosto-prova.js

@@ -0,0 +1,52 @@
+/**
+ * gosto-prova.js — o /gosto provar: o que o seu gosto muda em N motions, sem renderizar nenhum.
+ *
+ *   provar(pesos, { assunto, n, plano }) → { linhas: [{ grupo, nome, sem, com }], n }
+ *   texto(r, assunto)                    → as linhas pro terminal                    (puro)
+ *
+ * Foi assim que o gosto fraco apareceu em 24/10 (a cor da Padaria mudava 1 vídeo em 30, e o ritmo nada): sorteando o
+ * PLANO de muitos motions, com e sem o gosto, e contando. Sem render, sai em um ou dois segundos. Mostra só o que
+ * mudou de verdade (2 vídeos ou mais), do que mais mudou pro que menos mudou.
+ */
+
+'use strict';
+
+const NOMES = { paleta: 'paleta', ritmo: 'ritmo', camera: 'câmera', tipografia: 'letra', troca: 'troca' };
+const RITMO = { rapido: 'rápido', medio: 'médio', lento: 'lento' };
+
+function contar(pesos, { assunto, n, plano }) {
+    const c = { paleta: {}, ritmo: {}, camera: {}, tipografia: {}, troca: {} };
+    const soma = (g, k) => { if (k) c[g][k] = (c[g][k] || 0) + 1; };
+    for (let s = 1; s <= n; s++) {
+        const pl = plano({ assunto, semente: s, gosto: pesos }, { historico: [] });
+        const d = pl.direcao || {};
+        soma('paleta', d.paleta); soma('ritmo', d.ritmo); soma('camera', d.camera); soma('tipografia', d.tipografia);
+        for (const t of new Set(d.trocas || [])) soma('troca', t);   // em quantos vídeos a troca aparece, não quantas vezes
+    }
+    return c;
+}
+
+function provar(pesos, { assunto = 'um vídeo de apresentação', n = 30, plano = require('./maquina.js').plano } = {}) {
+    const sem = contar(null, { assunto, n, plano }), com = contar(pesos, { assunto, n, plano });
+    const linhas = [];
+    for (const grupo of Object.keys(sem)) {
+        for (const nome of new Set([...Object.keys(sem[grupo]), ...Object.keys(com[grupo])])) {
+            const a = sem[grupo][nome] || 0, b = com[grupo][nome] || 0;
+            if (Math.abs(b - a) >= 2) linhas.push({ grupo, nome, sem: a, com: b });
+        }
+    }
+    linhas.sort((x, y) => Math.abs(y.com - y.sem) - Math.abs(x.com - x.sem));
+    return { linhas, n };
+}
+
+function texto(r, assunto) {
+    if (!r.linhas.length) return [`Em ${r.n} motions de "${assunto}", o seu gosto não mudou nada que dê pra contar. Traga vídeos com /taste referencias, ou suba a força: /taste força muito.`];
+    const out = [`Em ${r.n} motions de "${assunto}" (só o plano, sem renderizar), sem → com o seu gosto:`];
+    for (const l of r.linhas.slice(0, 8)) {
+        const nome = l.grupo === 'ritmo' ? RITMO[l.nome] || l.nome : l.nome;
+        out.push(`  ${(NOMES[l.grupo] + ' ' + nome).padEnd(20)} ${String(l.sem).padStart(2)} → ${String(l.com).padStart(2)}${l.com > l.sem ? '  ↑' : '  ↓'}`);
+    }
+    return out;
+}
+
+module.exports = { provar, texto };