primocode 10.16.0 → 10.17.1

package/lib/entrega.js

@@ -0,0 +1,58 @@
+/**
+ * entrega.js — relatório grande não se perde: corta e guarda o resto.
+ *
+ * Visto no pi-desktop (vastsa, LGPL-3.0; só a ideia, código nosso): o relatório
+ * do subagente tem teto, e o que passa do teto vai para um arquivo, com o
+ * caminho no fim do texto. Antes, o `entregaDoAgente` fazia `.slice(0, 4000)`
+ * e o resto sumia: o especialista escrevia 9 mil caracteres de achados e o
+ * agente principal lia a metade, sem saber que faltava metade.
+ *
+ * O corte cai no fim de um parágrafo (ou de uma linha), nunca no meio de uma
+ * palavra. O arquivo mora na pasta temporária e é liberado para leitura, então
+ * o `read_file` do agente principal alcança.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const TETO = 4000;
+
+function pontoDeCorte(texto, teto) {
+    const trecho = texto.slice(0, teto);
+    for (const sep of ['\n\n', '\n', '. ']) {
+        const i = trecho.lastIndexOf(sep);
+        if (i > teto * 0.6) return i + (sep === '. ' ? 1 : 0);
+    }
+    return teto;
+}
+
+/**
+ * @returns {{texto: string, arquivo: string|null, cortado: boolean}}
+ * `gravar(texto, quem)` devolve o caminho do arquivo (injetável no teste).
+ */
+function limitar(texto, { teto = TETO, quem = 'agente', gravar = gravarNaTemp } = {}) {
+    const t = String(texto == null ? '' : texto).trim();
+    if (t.length <= teto) return { texto: t, arquivo: null, cortado: false };
+    const corte = pontoDeCorte(t, teto);
+    let arquivo = null;
+    try { arquivo = gravar(t, quem); } catch { /* sem disco: corta e avisa mesmo assim */ }
+    const aviso = arquivo
+        ? `\n\n(…relatório cortado: ${t.length} caracteres, faltam ${t.length - corte}. O texto inteiro está em ${arquivo} — leia com read_file se precisar do resto.)`
+        : `\n\n(…relatório cortado: ${t.length} caracteres, faltam ${t.length - corte}. Não deu para guardar o resto; peça de novo ao agente, mais curto.)`;
+    return { texto: t.slice(0, corte).trimEnd() + aviso, arquivo, cortado: true };
+}
+
+function gravarNaTemp(texto, quem) {
+    const dir = path.join(os.tmpdir(), 'primocode-entregas');
+    fs.mkdirSync(dir, { recursive: true });
+    const nome = `${Date.now()}-${String(quem).toLowerCase().replace(/[^a-z0-9]+/g, '-').slice(0, 30) || 'agente'}.md`;
+    const arquivo = path.join(dir, nome);
+    fs.writeFileSync(arquivo, texto, 'utf8');
+    try { require('./tools').liberarLeitura(dir); } catch { /* sem tools: o arquivo existe do mesmo jeito */ }
+    return arquivo;
+}
+
+module.exports = { limitar, TETO };

package/lib/estudio/conferencia-visual.js

@@ -0,0 +1,76 @@
+/**
+ * conferencia-visual.js — o olho DEPOIS do render: o quadro de cada cena, lido de verdade.
+ *
+ *   conferir({quadros, pl, guarda, visao}) → {olho: 'vision'|'caixas', problemas: [{cena, tipo, texto}], leituras}
+ *
+ * Com o Vision do macOS (lib/estudio/visao.js): o texto que aparece no quadro (OCR) e os rostos. Reprova:
+ *   borda        texto a menos de 3% da beira do quadro (colado na borda)
+ *   rosto        texto em cima de um rosto
+ *   encavalado   duas linhas de texto uma em cima da outra
+ * Sempre (com ou sem o Vision): as caixas finais da guarda do kit (linhas "GUARDA {json}") conferidas de novo
+ * (maquina-guarda.verificarCaixas): sobreposição e fora da zona segura. Sem Vision, é só isso ("caixas").
+ * Puro na decisão (julgarLeitura): testável sem quadro nem Vision.
+ */
+'use strict';
+
+const G = require('./maquina-guarda.js');
+
+const LIM = { borda: 0.03, conf: 0.5, alturaMin: 0.012, rostoMin: 0.004 };
+const area = (c) => Math.max(0, c[2] - c[0]) * Math.max(0, c[3] - c[1]);
+const inter = (a, b) => Math.max(0, Math.min(a[2], b[2]) - Math.max(a[0], b[0])) * Math.max(0, Math.min(a[3], b[3]) - Math.max(a[1], b[1]));
+
+/** Os problemas de UM quadro lido pelo Vision ({w, h, textos:[{texto, conf, caixa}], rostos:[caixa]}). */
+function julgarLeitura(q, cena, { foto = null } = {}) {
+    const out = [];
+    if (!q || !q.ok || !q.w || !q.h) return out;
+    const W = q.w, H = q.h;
+    const textos = (q.textos || []).filter((t) => t.conf >= LIM.conf && (t.caixa[3] - t.caixa[1]) >= H * LIM.alturaMin && String(t.texto).replace(/[^A-Za-zÀ-ÿ0-9]/g, '').length >= 2);
+    // com a caixa da foto (já na escala do quadro), só vale rosto DENTRO dela: o fundo desfocado é a mesma foto ampliada e também tem rosto
+    const naFoto = (r) => !foto || ((r[0] + r[2]) / 2 >= foto[0] && (r[0] + r[2]) / 2 <= foto[2] && (r[1] + r[3]) / 2 >= foto[1] && (r[1] + r[3]) / 2 <= foto[3]);
+    const rostos = (q.rostos || []).filter((r) => area(r) >= W * H * LIM.rostoMin && naFoto(r));
+    for (const t of textos) {
+        const c = t.caixa;
+        if (c[0] < W * LIM.borda || c[2] > W * (1 - LIM.borda) || c[1] < H * LIM.borda || c[3] > H * (1 - LIM.borda)) out.push({ cena, tipo: 'borda', texto: `texto colado na borda: "${t.texto}"` });
+        for (const r of rostos) if (inter(c, r) > 0.15 * area(c)) out.push({ cena, tipo: 'rosto', texto: `texto sobre o rosto: "${t.texto}"` });
+    }
+    for (let i = 0; i < textos.length; i++) for (let j = i + 1; j < textos.length; j++) {
+        const a = textos[i].caixa, b = textos[j].caixa;
+        if (inter(a, b) > 0.3 * Math.min(area(a), area(b))) out.push({ cena, tipo: 'encavalado', texto: `textos encavalados: "${textos[i].texto}" × "${textos[j].texto}"` });
+    }
+    return out;
+}
+
+/** As linhas "GUARDA {json}" que o kit escreveu (uma por cena). */
+function lerGuarda(saida) {
+    return String(saida || '').split('\n').filter((l) => /^GUARDA \{/.test(l)).map((l) => { try { return JSON.parse(l.slice(7)); } catch { return null; } }).filter(Boolean);
+}
+
+/** `quadros[i]` é o quadro da cena i. `guarda` = lerGuarda(saida). `visao` injetável (testes); null = sem olho. */
+function conferir({ quadros = [], pl = {}, guarda = [], visao } = {}) {
+    const problemas = [];
+    const legenda = !!(pl.legenda && pl.legenda.chunks && pl.legenda.chunks.length);
+    for (const g of guarda) {
+        for (const v of G.verificarCaixas(g.caixas, g.w || pl.w, g.h || pl.h, { legenda })) problemas.push({ cena: g.cena, tipo: /fora|trilho/.test(v) ? 'zona' : 'sobreposicao', texto: v });
+    }
+    let V = visao;
+    if (V === undefined) { try { V = require('./visao.js'); } catch { V = null; } }
+    let olho = 'caixas', leituras = null;
+    if (V && V.disponivel() && quadros.length) {
+        const r = V.ler(quadros);
+        if (r && r.ok) {
+            olho = 'vision'; leituras = r.quadros;
+            r.quadros.forEach((q) => {
+                const i = quadros.indexOf(q.arquivo);
+                if (i < 0) return;
+                // a caixa da foto (layout) levada pro quadro: escala do quadro, câmera ~0,94 em volta do centro, 20% de folga
+                const g = guarda.find((x) => x.cena === i), fc = g && (g.caixas || []).find((c) => c.tipo === 'foto');
+                let foto = null;
+                if (fc && q.w) { const W0 = g.w || pl.w, H0 = g.h || pl.h, k = q.w / W0, cx = W0 / 2, cy = H0 / 2, e = (x, c0) => (c0 + (x - c0) * 0.94) * k; const fw = (fc.c[2] - fc.c[0]) * 0.1 * k, fh = (fc.c[3] - fc.c[1]) * 0.1 * k; foto = [e(fc.c[0], cx) - fw, e(fc.c[1], cy) - fh, e(fc.c[2], cx) + fw, e(fc.c[3], cy) + fh]; }
+                problemas.push(...julgarLeitura(q, i, { foto }));
+            });
+        }
+    }
+    return { olho, problemas, leituras };
+}
+
+module.exports = { conferir, julgarLeitura, lerGuarda, LIM };

package/lib/estudio/diretor.js

@@ -77,9 +77,14 @@ const PEDE_EFEITO = /\b(tir[ae]r?|remov\w*|troc\w*)\s+(o\s+)?fundo\b|\bsepar\w*\
    arquivo de vídeo em qualquer lugar da frase é edição. */
 const EDITA_ARQUIVO = /\b(edit\w*|edi[cç][aã]o|p[oõ]e\s+(ele\s+)?pra\s+editar)\b[\s\S]*\.(mp4|mov|mkv|webm|m4v)\b|\.(mp4|mov|mkv|webm|m4v)\b[\s\S]*\b(edit\w*|edi[cç][aã]o)\b/i;
 
+/* A gravação da pessoa FALANDO, sem caminho de arquivo na frase (20/10, a edição completa do
+   editor_pro): "edita meu vídeo", "faz um reels disso", "coloca legenda e efeitos nele". Fala de
+   uma gravação que JÁ existe ("disso", "meu vídeo", "nele"), não de criar um vídeo do zero. */
+const PEDE_EDICAO_FALADA = /\bedit\w*\s+(o\s+|esse\s+|este\s+)?(meu\s+)?(v[ií]deo|grava[cç][aã]o)\s+(meu|que\s+eu\s+gravei)\b|\bedit\w*\s+(o\s+)?meu\s+v[ií]deo\b|\b(faz|fa[cç]a|transform\w*|vir\w*)\s+(um\s+|uma\s+|em\s+)?(reels?|tiktok|shorts?|criativo|corte)\s+(disso|desse|dessa|deste|desta|com\s+(esse|essa|este|esta|a\s+minha|o\s+meu))\b|\bcoloc\w*\s+(uma\s+)?legendas?\s+e\s+(uns\s+)?efeitos?\b|\b(legend\w*|efeitos?)\b[\s\S]{0,30}\b(no\s+meu\s+v[ií]deo|na\s+minha\s+grava[cç][aã]o|nele|nessa\s+grava[cç][aã]o)\b/i;
+
 function precisaDeEdicao(texto) {
     const t = String(texto || '');
-    return PEDE_EDICAO.test(t) || PEDE_EFEITO.test(t) || EDITA_ARQUIVO.test(t);
+    return PEDE_EDICAO.test(t) || PEDE_EFEITO.test(t) || EDITA_ARQUIVO.test(t) || PEDE_EDICAO_FALADA.test(t);
 }
 
 // ── 2. as decisões que não são do modelo ─────────────────────────────────

package/lib/estudio/exportar.js

@@ -154,7 +154,9 @@ function registrar({ id, assunto, caminho, formato, duracao, assinatura, entrega
     try { fs.mkdirSync(path.dirname(arq), { recursive: true }); fs.writeFileSync(arq, JSON.stringify(l.slice(-200), null, 2)); } catch { /* sem disco: segue */ }
     return item;
 }
-const listar = (arq) => ler(arq).filter((v) => v.caminho && fs.existsSync(v.caminho)).sort((a, b) => String(b.data).localeCompare(String(a.data)));
+// mais novo primeiro; no empate de data (dois no mesmo milissegundo), vale a ordem de gravação: o último registrado vem antes
+const listar = (arq) => ler(arq).map((v, i) => ({ v, i })).filter(({ v }) => v.caminho && fs.existsSync(v.caminho))
+    .sort((a, b) => String(b.v.data).localeCompare(String(a.v.data)) || b.i - a.i).map(({ v }) => v);
 function abrirNoSistema(alvo) {
     if (process.env.PRIMOCODE_SEM_NAVEGADOR === '1') return false;   // app do Primo (voz): navegador só com clique explícito
     const cmd = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'cmd' : 'xdg-open';

package/lib/estudio/gosto.js

@@ -11,6 +11,8 @@
  *   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';
 
@@ -184,9 +186,44 @@ function resumo(gosto) {
     return partes.join(' ');
 }
 
-/** Só pergunta no primeiro pedido, com gente do outro lado: nunca em -p, CI ou teste. */
+/**
+ * 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 !tem(home) && !(args && args.gosto === false) && !env.PRIMOCODE_SEM_TELA && !env.CI && !!process.stdout.isTTY;
+    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) {
@@ -221,8 +258,12 @@ function abrirTela({ home, abrir, timeoutMs = 10 * 60 * 1000, porta = 0 } = {})
                     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')) {
+                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 });
@@ -261,4 +302,4 @@ function abrirTela({ home, abrir, timeoutMs = 10 * 60 * 1000, porta = 0 } = {})
 
 const _teste = { texto, MAX_TEXTO, aplicarNao };
 
-module.exports = { ESTILOS, GOSTEI, NAO_QUERO, arquivo, ler, salvar, tem, normalizar, pesos, resumo, abrirTela, deveAbrir, _teste };
+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

@@ -719,11 +719,8 @@ async function ferramentaMotion(args) {
         receita = r.projeto;
     }
     // primeiro motion: aprende o gosto antes de renderizar (a pessoa pode fechar ou pular; o render segue de qualquer jeito)
-    const gosto = require('./gosto.js');
-    if (gosto.deveAbrir(args)) {
-        try { console.error(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.')); } catch { /* sem terminal */ }
-        try { await gosto.abrirTela(); } catch { /* sem tela, segue */ }
-    }
+    // 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));
 }
 
@@ -737,6 +734,12 @@ 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);

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)) {