primocode 10.15.2 → 10.17.0

package/lib/estudio/gosto.js

@@ -0,0 +1,305 @@
+/**
+ * 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
+ *   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 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;
+}
+
+/** 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) });
+    }
+    return {
+        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,
+    };
+}
+
+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;
+}
+
+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) {
+        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));
+    }
+    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;
+}
+
+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);
+}
+
+const lista = (a) => (a.length <= 1 ? a.join('') : a.slice(0, -1).join(', ') + ' e ' + a[a.length - 1]);
+
+/** Frases em PT-BR pro modelo. Nulo → ''. */
+function resumo(gosto) {
+    if (!gosto) return '';
+    if (gosto.pulou && !(gosto.nao_quero || []).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 (!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 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('../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);
+    });
+}
+
+/**
+ * Abre a tela no navegador. Resolve {ok:true, gosto} (salvou), {ok:false, motivo:'pulou'|'tempo'|'sem_tela'}.
+ * `abrir(url)` e `home` são injetáveis (testes).
+ */
+function abrirTela({ home, abrir, timeoutMs = 10 * 60 * 1000, porta = 0 } = {}) {
+    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' }); }
+        const dados = JSON.stringify({ ESTILOS, GOSTEI, NAO_QUERO }).replace(/</g, '\\u003c');
+        let fim = false, timer = null;
+        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 === '/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)' }); }
+                    const g = salvar(corpo, home);
+                    dizer(200, { ok: true, resumo: resumo(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('../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 };
+
+module.exports = { ESTILOS, GOSTEI, NAO_QUERO, arquivo, ler, salvar, tem, normalizar, pesos, resumo, abrirTela, deveAbrir, modoTela, antesDoMotion, PROTOCOLO, linhaProtocolo, urlDaLinha, _teste };

package/lib/estudio/index.js

@@ -718,6 +718,9 @@ async function ferramentaMotion(args) {
         if (r.bloqueado) return { ok: false, error: r.aviso, projeto: r.projeto };
         receita = r.projeto;
     }
+    // primeiro motion: aprende o gosto antes de renderizar (a pessoa pode fechar ou pular; o render segue de qualquer jeito)
+    // no terminal abre o navegador; no app (desktop ou Primo.app, -p com PRIMOCODE_APP=1) o app abre a tela pela linha de protocolo
+    try { await require('./gosto.js').antesDoMotion(args); } catch { /* sem tela, segue */ }
     return require('./cota.js').comCota(() => renderMotion(args, p, receita));
 }
 
@@ -731,10 +734,18 @@ async function renderMotion(args, p, receita) {
             args.cenas = args.cenas.map((c, i) => (i === args.cenas.length - 1 && c && !c.logo ? { ...c, logo: kitM.logo } : c));
         }
     }
+    // As fotos do pedido: as que a IA passou em `fotos` e as que o terminal achou no texto do pedido (referencias.imagens()).
+    // Antes só o prepararRoteiro (Remotion) as lia: no motion elas viravam "referência" e nenhuma peça aceitava foto.
+    const doPedido = referencias.imagens();
+    const dadas = Array.isArray(args.fotos) ? args.fotos : (args.fotos ? [args.fotos] : []);
+    const todas = [...new Set([...dadas, ...doPedido])];
+    if (todas.length) args = { ...args, fotos: todas, ...(dadas.length ? {} : { fotosImplicitas: true }) };
     const r = await require('./maquina.js').motion(args, { pasta: p.pasta, receita, deps: { narrar } });
     if (r.ok) projeto.anotar(p.id, 'motion', `${r.duracao}s, ${r.cenas.length} cenas, ${r.lufs} LUFS`);
     if (r.ok) entregar(args, p, r);
-    return r.ok ? { ...r, nota: 'Abra os quadros (png em ae/) para conferir. Se algo ficou torto, mude o JSON e rode de novo.' } : r;
+    if (!r.ok) return r;
+    const gostoResumo = (() => { try { const G = require('./gosto.js'); return G.resumo(G.ler()); } catch { return ''; } })();
+    return { ...r, ...(gostoResumo ? { gosto: gostoResumo } : {}), nota: 'Abra os quadros (png em ae/) para conferir. Se algo ficou torto, mude o JSON e rode de novo.' };
 }
 
 // ── estudio_editar ───────────────────────────────────────────────────────

package/lib/estudio/kit-ae/base.jsx

@@ -259,13 +259,27 @@ function kAtmosfera(comp, P) {
 }
 
 /* O título é SEMPRE a camada de cima da cena (nada atravessa a caixa dele): as palavras vão para o topo da pilha. */
-function kTituloPorCima() {
+function kTituloPorCima(comp) {
     var i, T = KIT.titulosL || [];
+    if (comp && T.length && KIT.tituloB != null) kPlacaDoTitulo(comp);
     for (i = T.length - 1; i >= 0; i--) { try { T[i].moveToBeginning(); } catch (e) { } }
     KIT.titulosL = [];
 }
+/* A GUARDA do título sobre peça que sangra (mapa, parede, feed, pan, zoom: passam por trás do título de propósito): uma placa da cor do
+   fundo da cena atrás da faixa do título, com a borda de baixo em degradê. O título nunca fica em cima de rua, grade ou cartão. */
+function kPlacaDoTitulo(comp) {
+    var i, sangra = false, c = KIT.cams[comp.name];
+    for (i = 1; i <= comp.numLayers && !sangra; i++) { var L = comp.layer(i); if (/^(mapa|parede|feed|pan|zoom)/.test(L.name) && L.parent && kEhCam(L.parent)) sangra = true; }
+    if (!sangra || !c || !c.camNo || !KIT.pal) return;
+    var W = comp.width, H = comp.height, u = Math.min(W, H) / 1080, B = KIT.tituloB, top = -H * 0.2;
+    var pl = forma(comp, 'retangulo', { x: W / 2, y: (top + B) / 2, w: W * 1.6, h: B - top, cor: KIT.pal.bg, parent: c.camNo, nome: 'fundo-titulo' });
+    var deg = forma(comp, 'retangulo', { x: W / 2, y: B + 45 * u, w: W * 1.6, h: 90 * u, cor: KIT.pal.bg, alfa: 55, parent: c.camNo, nome: 'fundo-titulo-degrade' });
+    try { var mk = deg.property('ADBE Mask Parade').addProperty('ADBE Mask Atom'); mk.property('ADBE Mask Shape').setValue(kRetShape(-W, -60 * u, W, 20 * u, 0)); mk.property('ADBE Mask Feather').setValue([0, 50 * u]); } catch (e) { }
+    KIT.guardaPlaca = (KIT.guardaPlaca || 0) + 1;
+    writeLn('GUARDA ' + JSON.stringify({ cena: KIT.cenaIdx, w: W, h: H, log: ['título sobre peça que sangra: placa da cor do fundo atrás do título'], caixas: [] }));
+}
 // fecha(comp): aplica a câmera da comp, a atmosfera (luz, flash, look) e confere o layout. Chame uma vez, depois de montar a cena.
-function fecha(comp) { var c = KIT.cams[comp.name]; kTituloPorCima(); kAjustaConteudo(comp, c); if (KIT.ambienteFn) KIT.ambienteFn(comp, c); if (c) kAplicaCamera(c); kAtmosfera(comp, KIT.pal || { ac: '#FFFFFF' }); kConfereCena(comp); kAuditoria(comp); }
+function fecha(comp) { var c = KIT.cams[comp.name]; kTituloPorCima(comp); kAjustaConteudo(comp, c); kGuarda(comp); if (KIT.ambienteFn) KIT.ambienteFn(comp, c); if (c) kAplicaCamera(c); kAtmosfera(comp, KIT.pal || { ac: '#FFFFFF' }); kConfereCena(comp); kAuditoria(comp); }
 
 // ---------------------------------------------------------------- formas
 function kMascaraRect(L, x0, y0, x1, y1, r) {
@@ -507,7 +521,7 @@ function texto(comp, str, o) {
     if (seg) {   // encaixa na área segura: 8% nos lados; no 9:16 respeita as faixas de UI do Reels (14% em cima, 20% embaixo)
         var zs = kZonaTexto(comp), mxp = zs.x, myp = zs.top, myb = zs.bot;
         x = Math.max(mxp + wMax / 2, Math.min(W - mxp - wMax / 2, x));
-        y = Math.max(myp + bloco / 2, Math.min(H - myb - bloco / 2, y));
+        y = Math.max(myp + bloco / 2 + (o.titulo ? (KIT.tituloDesce || 0) * H : 0), Math.min(H - myb - bloco / 2, y));   // tituloDesce: a câmera levou o título pra cima da faixa do Reels
         x = Math.round(x / 8) * 8; y = Math.round(y / 8) * 8;   // grade de 8 px
     }
     wMax = 0;
@@ -558,6 +572,23 @@ function kQuebra(ws, sw, maxW) {
     }
     return linhas;
 }
+/* Quanto tempo (nominal) a entrada leva até a palavra estar INTEIRA na tela. 'voa' e 'letra' montam letra por letra (em ordem
+   aleatória no 'voa'): a palavra só se lê no fim. Quem tira a palavra da tela antes disso mostra "q … ho" no lugar de "quentinho". */
+function kTempoMontagem(modo, txt) {
+    var n = Math.max(1, String(txt || '').replace(/\*/g, '').length);
+    if (modo == 'voa') return 0.3 + n * 0.06;
+    if (modo == 'letra') return 0.12 + n * 0.045;
+    if (modo == 'mascara') return 0.4;
+    if (modo == 'sobe') return 0.35;
+    return 0.2;   // 'palavra': inteira desde o primeiro quadro, crescendo; aos 0,2 s já passa de 90%
+}
+/* A entrada que cabe na janela da palavra (entra em ti, sai em fim): a pedida, se a palavra fica inteira por `leitura` s; senão a
+   mais rápida que deixe ler; no último caso, 'palavra' (inteira desde o começo, só cresce). */
+function kEntradaQueCabe(modo, txt, janela, leitura) {
+    var ord = [modo, 'mascara', 'sobe', 'palavra'], i;
+    for (i = 0; i < ord.length; i++) if (kTempoMontagem(ord[i], txt) + (leitura || 0) <= janela) return ord[i];
+    return 'palavra';
+}
 function kAnimaPalavra(comp, L, modo, ti, x, y, w, tam, linha, idx, txt) {
     kMarcaEntrada(ti);
     var drift = Math.max(2, tam / 55);
@@ -680,9 +711,13 @@ function celular(comp, o) {
 
 /* botao(comp, {x,y,w,h,rotulo,cor,corTexto,parent,t0}) + botao.aperta(t): o botão que afunda e volta. */
 function botao(comp, o) {
+    // a pílula cabe o rótulo: o texto() não desce de 3,6% da altura (fora de aparelho), então mede ANTES e alarga (nunca texto vazando do botão)
+    var tamB = (o.tam || 44) * KIT.ajuste * KIT.ajusteCena; if (kEhCam(o.parent || null) || !o.parent) tamB = Math.max(tamB, comp.height * 0.036);
+    var wr = kMedir(comp, String(o.rotulo || 'Toque aqui'), o.fonte || (KIT.marca && KIT.marca.titulo) || 'Poppins', tamB);
+    o.w = Math.min(comp.width * 0.84, Math.max(o.w || 360, wr / 0.86 + tamB * 0.4)); o.h = Math.max(o.h || 110, tamB * 1.6);
     var b = forma(comp, 'pilula', { x: o.x, y: o.y, w: o.w || 360, h: o.h || 110, cor: o.cor || '#FFFFFF', parent: o.parent, nome: 'botao', entrada: o.entrada === false ? null : 'pop', t0: o.t0 || 0, quique: 0.6 });
     var tx = texto(comp, o.rotulo || 'Toque aqui', { x: o.x, y: o.y, tamanho: o.tam || 44, cor: o.corTexto || '#000000', parent: o.parent, entrada: 'sobe', t0: (o.t0 || 0) + 0.08, largura: (o.w || 360) * 0.86, maxLinhas: 1, fonte: o.fonte });
-    return { forma: b, texto: tx, aperta: function (t) {
+    return { forma: b, texto: tx, w: o.w, h: o.h, aperta: function (t) {
         // 100%: o valor lido de uma propriedade com chaves é o do tempo 0 (a mola de entrada começa em 0)
         curva(kS(b), [[t, [100, 100], null, 25], [t + 0.07, [90, 90], 70, 40], [t + 0.25, [100, 100], 70, null]]);
         som(t, 'clique', 0.9);
@@ -809,9 +844,11 @@ function elemento(comp, e, o) {
     if (typeof e == 'number') e = kElem(e);
     var w = o.w || 300, h = o.h || w, L = null;
     if ((!o.parent || kEhCam(o.parent)) && w < comp.width * 0.12 && o.nome != 'ambiente') { var kk = comp.width * 0.12 / w; w *= kk; h *= kk; o.w = w; o.h = h; }   // ícone de apoio ≥ 12% da largura
-    if ((!o.parent || kEhCam(o.parent)) && o.x != null) { var ze0 = kZonaTexto(comp, false); o.x = Math.max(ze0.x + w / 2, Math.min(comp.width - ze0.x - w / 2, Math.round(o.x / 8) * 8)); o.y = Math.max(ze0.top + h / 2, Math.min(comp.height - ze0.bot - h / 2, Math.round(o.y / 8) * 8)); if (o.nome != 'ambiente') KIT.rects.push({ espaco: (o.parent && o.parent.name == 'CONTEUDO') ? 'c' : 't', cena: KIT.cenaIdx, x0: o.x - w / 2, x1: o.x + w / 2, y0: o.y - h / 2, y1: o.y + h / 2, t0: 0, t1: 1, texto: false, sobrepoe: true, nome: 'elemento ' + (e && e.nome || '') }); }
+    var rectEl = null, fx = o.folgaX || 0, fy = o.folgaY || 0;   // folga: o balanço do elemento (a guarda reserva o envelope inteiro)
+    if ((!o.parent || kEhCam(o.parent)) && o.x != null) { var ze0 = kZonaTexto(comp, false); o.x = Math.max(ze0.x + w / 2, Math.min(comp.width - ze0.x - w / 2, Math.round(o.x / 8) * 8)); o.y = Math.max(ze0.top + h / 2, Math.min(comp.height - ze0.bot - h / 2, Math.round(o.y / 8) * 8)); if (o.nome != 'ambiente') { rectEl = { espaco: (o.parent && o.parent.name == 'CONTEUDO') ? 'c' : 't', cena: KIT.cenaIdx, x0: o.x - w / 2 - fx, x1: o.x + w / 2 + fx, y0: o.y - h / 2 - fy, y1: o.y + h / 2 + fy, t0: 0, t1: 1, texto: false, sobrepoe: true, nome: 'elemento ' + (e && e.nome || ''), camadas: [], infla: (w + 2 * fx) / w }; KIT.rects.push(rectEl); } }
     if (!e) {
         L = forma(comp, 'circulo', { x: o.x, y: o.y, w: Math.min(w, h) * 0.85, cor: o.corFallback || '#8A8A8A', parent: o.parent, nome: 'elemento-reserva' });
+        if (rectEl) rectEl.camadas.push(L);
     } else {
         KIT.cache = KIT.cache || {};
         var it = KIT.cache[e.arquivo];
@@ -823,9 +860,10 @@ function elemento(comp, e, o) {
         }
         if (!it) return elemento(comp, null, o);
         L = kPoeEl(comp, it, e, o, o.t0 && e.tipo == 'seq' ? o.t0 : 0);
+        if (rectEl) rectEl.camadas.push(L);
         if (e.tipo == 'seq' && it.duration > 0.1) {   // o GIF acaba em ~1 s: repete até o fim da cena
             var n, dur = it.duration, ini = (o.t0 || 0) + dur;
-            for (n = 0; n < 12 && ini < comp.duration; n++, ini += dur) kPoeEl(comp, it, e, o, ini);
+            for (n = 0; n < 12 && ini < comp.duration; n++, ini += dur) { var Lr = kPoeEl(comp, it, e, o, ini); if (rectEl) rectEl.camadas.push(Lr); }
         }
         KIT.nElem = (KIT.nElem || 0) + 1;
     }
@@ -962,7 +1000,7 @@ function kConfereCena(comp) {
     }
     var W = comp.width, H = comp.height, R = KIT.rects, i, j, a, b, zt = kZonaTexto(comp, true), ze = kZonaTexto(comp, false), mx = ze.x - 2, my = ze.top - 2;
     var mine = [];
-    for (i = 0; i < R.length; i++) if (R[i].cena == KIT.cenaIdx && !R[i].conferido) { R[i].conferido = true; mine.push(kRectLayout(R[i])); }
+    for (i = 0; i < R.length; i++) if (R[i].cena == KIT.cenaIdx && !R[i].conferido && !R[i].fora) { R[i].conferido = true; mine.push(kRectLayout(R[i])); }
     for (i = 0; i < mine.length; i++) {
         a = mine[i];
         if (a.banda) continue;
@@ -987,6 +1025,57 @@ function kConfereCena(comp) {
     }
 }
 
+// ---------------------------------------------------------------- a guarda de layout (kit-ae/guarda.jsx), com as caixas reais
+/* kGuarda(comp): no fecha() de cada cena, ANTES do render. Junta as caixas registradas (texto medido com sourceRectAtTime, elementos
+   com o envelope do balanço, a foto) e roda gConsertar: ícone sobre texto/foto/outro ícone muda de lugar, encolhe ou sai; a foto que
+   encosta no texto sobe ou desce; o que não tem saída vira "AVISO cena N: guarda: troca a peça". Move por expressão (value + delta),
+   que soma às chaves e ao balanço sem mexer neles. Escreve "GUARDA {json}" com o log e as caixas finais (o Node confere depois). */
+function kZonaGuarda(comp) {
+    var W = comp.width, H = comp.height, z = gZona(W, H, { legenda: KIT.enqDy > 0 }), a = kParaLayout(comp, z.x0, z.y0), b = kParaLayout(comp, z.x1, z.y1), tr = null;
+    if (z.trilho) { var t = kParaLayout(comp, z.trilho[0], z.trilho[1]); tr = [t.x, t.y, W * 2, H * 2]; }
+    return { x0: a.x, y0: a.y, x1: b.x, y1: b.y, trilho: tr };
+}
+function kExpr(prop) { var e = ''; try { e = prop.expression || ''; } catch (er) { e = ''; } return e ? '(' + e + ')' : 'value'; }
+function kDesloca(L, dx, dy, k) {
+    try {
+        if (Math.abs(dx) > 0.5 || Math.abs(dy) > 0.5) { var p = kP(L); p.expression = 'var gv = ' + kExpr(p) + '; gv.length > 2 ? [gv[0] + ' + dx.toFixed(1) + ', gv[1] + ' + dy.toFixed(1) + ', gv[2]] : [gv[0] + ' + dx.toFixed(1) + ', gv[1] + ' + dy.toFixed(1) + ']'; }
+        if (k && Math.abs(k - 1) > 0.005) { var sc = kS(L); sc.expression = 'var gs = ' + kExpr(sc) + '; gs.length > 2 ? [gs[0] * ' + k.toFixed(4) + ', gs[1] * ' + k.toFixed(4) + ', gs[2]] : [gs[0] * ' + k.toFixed(4) + ', gs[1] * ' + k.toFixed(4) + ']'; }
+    } catch (e) { KIT.avisos.push('cena ' + KIT.cenaIdx + ': a guarda não conseguiu mover ' + L.name + ': ' + e); }
+}
+function kSome(L) { try { kO(L).expression = '0'; } catch (e) { } try { L.enabled = false; } catch (e2) { } }
+function kGuarda(comp) {
+    if (KIT.guarda === false) return;
+    var W = comp.width, H = comp.height, R = KIT.rects, itens = [], refs = [], i, j;
+    for (i = 0; i < R.length; i++) {
+        var r0 = R[i];
+        if (r0.cena != KIT.cenaIdx || r0.banda || r0.fora) continue;
+        if (r0.texto && r0.livre) continue;   // texto dentro de aparelho (celular, janela): mora no desenho dele
+        var r = kRectLayout(r0), tipo;
+        if (r0.texto) tipo = 'texto';
+        else if (r0.guarda == 'foto') tipo = 'foto';
+        else if (!r0.camadas || !r0.camadas.length || KIT.cenaHeroi || (r.x1 - r.x0) / (r0.infla || 1) > W * 0.3) tipo = 'cartao';
+        else tipo = 'icone';
+        itens.push({ id: i, tipo: tipo, nome: tipo == 'texto' ? 'texto "' + String(r0.nome).slice(0, 24) + '"' : String(r0.nome || tipo).replace(/^elemento /, 'ícone '), c: [r.x0, r.y0, r.x1, r.y1], fixo: tipo == 'texto' || tipo == 'cartao', movel: tipo == 'foto', prio: tipo == 'icone' ? 1 : 5, infla: r0.infla || 1 });
+        refs.push(r0);
+    }
+    if (!itens.length) return;
+    var u = Math.min(W, H) / 1080;
+    var res = gConsertar(itens, W, H, { zona: kZonaGuarda(comp), so: 'icones', folga: (KIT.guardaFolga || 10) * u, escalaMundo: KIT.enq * 1.03 });
+    var caixas = [];
+    for (j = 0; j < res.itens.length; j++) {
+        var a = res.itens[j], q = refs[j], esc = (q.espaco == 'c' && KIT.remap) ? KIT.remap.s : 1, cl = q.camadas || [], m;
+        caixas.push({ tipo: a.tipo, nome: a.nome, c: [Math.round(a.c[0]), Math.round(a.c[1]), Math.round(a.c[2]), Math.round(a.c[3])], fora: a.removido ? 1 : 0 });
+        if (a.removido) { for (m = 0; m < cl.length; m++) kSome(cl[m]); q.fora = true; continue; }
+        if (Math.abs(a.dx) > 0.5 || Math.abs(a.dy) > 0.5 || Math.abs(a.k - 1) > 0.005) {
+            for (m = 0; m < cl.length; m++) kDesloca(cl[m], a.dx / esc, a.dy / esc, a.k);
+            var cx = (q.x0 + q.x1) / 2 + a.dx / esc, cy = (q.y0 + q.y1) / 2 + a.dy / esc, hw = (q.x1 - q.x0) / 2 * a.k, hh = (q.y1 - q.y0) / 2 * a.k;
+            q.x0 = cx - hw; q.x1 = cx + hw; q.y0 = cy - hh; q.y1 = cy + hh;
+        }
+    }
+    if (res.trocar) KIT.avisos.push('cena ' + KIT.cenaIdx + ': guarda: troca a peça (' + res.log[res.log.length - 1] + ')');
+    writeLn('GUARDA ' + JSON.stringify({ cena: KIT.cenaIdx, w: W, h: H, log: res.log, caixas: caixas, violacoes: res.violacoes }));
+}
+
 // ---------------------------------------------------------------- quando as coisas entram (a regra dos 30–40%)
 /* kEntradaMax(comp): o instante (nominal) em que a ÚLTIMA camada de conteúdo fica visível, lido das chaves de opacidade, e o que
    kEntrada/kAnimaPalavra registraram. Cursor, ondas, partículas e atmosfera não contam: não são elementos novos. */
@@ -1039,6 +1128,13 @@ function kCaixaMundo(L, t, cache) {
     for (i = 0; i < 4; i++) { X.push(m[0] * xs[i] + m[2] * ys[i] + m[4]); Y.push(m[1] * xs[i] + m[3] * ys[i] + m[5]); }
     return [Math.min(X[0], X[1], X[2], X[3]), Math.min(Y[0], Y[1], Y[2], Y[3]), Math.max(X[0], X[1], X[2], X[3]), Math.max(Y[0], Y[1], Y[2], Y[3])];
 }
+/* a caixa da setinha no mundo: o desenho dela (sourceRectAtTime da forma) com escala, pais e câmera */
+function kCaixaCursorMundo(L, t, cache) {
+    var q = L.sourceRectAtTime(t, false), m = kMatMundo(L, t, cache), r = [q.left, q.top, q.left + q.width, q.top + q.height];
+    var xs = [r[0], r[2], r[0], r[2]], ys = [r[1], r[1], r[3], r[3]], i, X = [], Y = [];
+    for (i = 0; i < 4; i++) { X.push(m[0] * xs[i] + m[2] * ys[i] + m[4]); Y.push(m[1] * xs[i] + m[3] * ys[i] + m[5]); }
+    return [Math.min(X[0], X[1], X[2], X[3]), Math.min(Y[0], Y[1], Y[2], Y[3]), Math.max(X[0], X[1], X[2], X[3]), Math.max(Y[0], Y[1], Y[2], Y[3])];
+}
 var KIT_SKIP_CADEIA = /^(feed|mapa|parede|pan|zoom|celular|janela|papel|carimbo|slot|carta)/;
 function kAuditoria(comp) {
     if (KIT.auditoria === false) return;
@@ -1046,25 +1142,26 @@ function kAuditoria(comp) {
     var cand = [];
     for (i = 1; i <= comp.numLayers; i++) {
         var L = comp.layer(i), nm = L.name;
-        var ehTexto = nm.indexOf('palavra ') == 0, ehEl = nm.indexOf('el ') == 0 || nm == 'elemento-reserva' || nm == 'ambiente';
-        if (!ehTexto && !ehEl) continue;
+        var ehTexto = nm.indexOf('palavra ') == 0, ehEl = nm.indexOf('el ') == 0 || nm == 'elemento-reserva' || nm == 'ambiente', ehCur = nm == 'cursor';
+        if (!ehTexto && !ehEl && !ehCur) continue;
         var skip = false, P = L.parent;
         while (P) { if (KIT_SKIP_CADEIA.test(P.name)) { skip = true; break; } P = P.parent; }
         var nominal = (L.comment != null && L.comment !== '') ? parseFloat(L.comment) : 0;
         if (isNaN(nominal)) nominal = 0;
-        cand.push({ L: L, nome: nm, texto: ehTexto, skip: skip, entra: nominal, amb: nm == 'ambiente' });
+        cand.push({ L: L, nome: nm, texto: ehTexto, cursor: ehCur, skip: skip && !ehCur, entra: ehCur ? 0 : nominal, amb: nm == 'ambiente' });
     }
     var passo = 0.1 * f, dur = comp.duration, fim = dur - 0.55 * f, t, amostras = 0, nFora = 0, nCol = 0, vistos = {}, exs = 0;
     for (t = 0.3 * f; t < fim; t += passo) {
         var cache = {}, vis = [];
         for (i = 0; i < cand.length; i++) {
             var c = cand[i];
-            if (c.skip || t < c.entra + 0.5 * f) continue;
+            if (c.skip || (!c.cursor && t < c.entra + 0.5 * f)) continue;
             try {
                 var tr = c.L.property('ADBE Transform Group');
                 if (tr.property('ADBE Opacity').valueAtTime(t, false) < 40) continue;
                 if (t < c.L.inPoint || t >= c.L.outPoint) continue;
-                var bx = kCaixaMundo(c.L, t, cache);
+                var bx = c.cursor ? kCaixaCursorMundo(c.L, t, cache) : kCaixaMundo(c.L, t, cache);
+                if (c.cursor) { var bx2 = kCaixaCursorMundo(c.L, t + 0.05 * f, {}); if (Math.abs(bx2[0] - bx[0]) + Math.abs(bx2[1] - bx[1]) > 4) continue; }   // em trânsito: só conta parado (no clique)
                 if (bx[2] - bx[0] < 2 || bx[3] - bx[1] < 2) continue;
                 var h0 = bx[3] - bx[1];
                 vis.push({ c: c, b: bx, tinta: c.texto ? [bx[0], bx[1] + h0 * 0.14, bx[2], bx[3] - h0 * 0.14] : bx });
@@ -1075,13 +1172,22 @@ function kAuditoria(comp) {
         for (i = 0; i < vis.length; i++) {
             var a = vis[i], b = a.b;
             var zz = a.c.texto ? zT : zE, limX0 = zz.x0, limX1 = zz.x1, limY0 = zz.y0, limY1 = zz.y1;
-            if (b[0] < limX0 - 8 || b[2] > limX1 + 8 || b[1] < limY0 - 8 || b[3] > limY1 + 8) {
+            if (!a.c.cursor && b[0] < limX0 - 12 || b[2] > limX1 + 12 || b[1] < limY0 - 12 || b[3] > limY1 + 12) {   // 12 px (1%): a respiração da câmera passa disso e não encosta na borda
                 foraT = true;
                 var kf = 'f:' + a.c.nome;
                 if (!vistos[kf] && exs < 8) { vistos[kf] = 1; exs++; KIT.avisos.push('cena ' + KIT.cenaIdx + ': ' + (a.c.texto ? 'texto' : 'elemento') + ' fora da área segura (quadro ' + (t / f).toFixed(1) + ' s): ' + a.c.nome.replace('palavra ', '') + ' [' + Math.round(b[0]) + ',' + Math.round(b[1]) + ',' + Math.round(b[2]) + ',' + Math.round(b[3]) + ']'); }
             }
             for (j = i + 1; j < vis.length; j++) {
                 var bt = a.tinta, o2 = vis[j].tinta, ox = Math.min(bt[2], o2[2]) - Math.max(bt[0], o2[0]), oy = Math.min(bt[3], o2[3]) - Math.max(bt[1], o2[1]);
+                if (a.c.cursor || vis[j].c.cursor) {   // o cursor é elemento: nunca em cima de letra (com elemento, pode)
+                    var tx2 = a.c.cursor ? vis[j].c : a.c;
+                    if (tx2.texto && ox > 2 && oy > 2) {
+                        colT = true;
+                        var kq = 'q:' + tx2.nome;
+                        if (!vistos[kq] && exs < 8) { vistos[kq] = 1; exs++; KIT.avisos.push('cena ' + KIT.cenaIdx + ': cursor sobre o texto (quadro ' + (t / f).toFixed(1) + ' s): ' + tx2.nome.replace('palavra ', '')); }
+                    }
+                    continue;
+                }
                 if (ox > 5 && oy > 5) {
                     var A1 = (bt[2] - bt[0]) * (bt[3] - bt[1]), A2 = (o2[2] - o2[0]) * (o2[3] - o2[1]);
                     if (ox * oy > 0.05 * Math.min(A1, A2)) {