primocode 10.16.0 → 10.17.1

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

@@ -26,10 +26,12 @@ function kBase(comp, P) {
 function kAmbiente(comp, P, cam) {
     if (KIT.cenaComElemento || !cam) return;
     var W = comp.width, H = comp.height, m = Math.min(W, H), ze = kZonaTexto(comp, false), mx = ze.x, my = ze.top, myb = ze.bot, k, colocados = [], R = [], ri;
-    for (ri = 0; ri < KIT.rects.length; ri++) if (KIT.rects[ri].cena == KIT.cenaIdx) R.push(kRectLayout(KIT.rects[ri]));
+    for (ri = 0; ri < KIT.rects.length; ri++) if (KIT.rects[ri].cena == KIT.cenaIdx && !KIT.rects[ri].fora) R.push(kRectLayout(KIT.rects[ri]));
     var tams = [m * 0.5, m * 0.15];
+    // folga do texto: 7% da largura (no mínimo 60 px), pra a câmera que empurra (até 1,1×) não encostar o objeto nas letras
+    var fo = Math.max(60, W * 0.07);
     function livre(x, y, w) {
-        var x0 = x - w / 2 - 60, x1 = x + w / 2 + 60, y0 = y - w / 2 - 60, y1 = y + w / 2 + 60, i;
+        var x0 = x - w / 2 - fo, x1 = x + w / 2 + fo, y0 = y - w / 2 - fo, y1 = y + w / 2 + fo, i;
         if (x - w / 2 < mx + W * 0.04 || x + w / 2 > W - mx - W * 0.04 || y - w / 2 < my + W * 0.04 || y + w / 2 > H - myb - W * 0.04) return false;
         for (i = 0; i < R.length; i++) { var r = R[i]; if (x0 < r.x1 && x1 > r.x0 && y0 < r.y1 && y1 > r.y0) return false; }
         for (i = 0; i < colocados.length; i++) { var q = colocados[i]; if (x0 < q[2] && x1 > q[0] && y0 < q[3] && y1 > q[1]) return false; }
@@ -48,13 +50,23 @@ function kAmbiente(comp, P, cam) {
         }
     }
 }
+// onde o raio que sai de (cx, cy) no ângulo a cruza a borda da caixa (+ m para fora); sem caixa, o próprio centro
+function kNaBorda(c, cx, cy, a, m) {
+    if (!c) return [cx, cy];
+    var dx = Math.cos(a), dy = Math.sin(a), hw = (c[2] - c[0]) / 2, hh = (c[3] - c[1]) / 2;
+    var k = Math.min(Math.abs(dx) > 1e-6 ? hw / Math.abs(dx) : 1e9, Math.abs(dy) > 1e-6 ? hh / Math.abs(dy) : 1e9) + (m || 0);
+    return [cx + dx * k, cy + dy * k];
+}
 // pontos que estalam em volta de um centro (confete discreto), com som
-function kEstouro(comp, cam, cx, cy, t, cor, n, raio, som0) {
+/* caixa (opcional, [x0, y0, x1, y1]): o estouro nasce na BORDA dela e vai para fora — o confete nunca passa por cima do texto que
+   mora dentro (o rótulo do botão virava "Começa: agora" com um ponto branco em cima do "r"). */
+function kEstouro(comp, cam, cx, cy, t, cor, n, raio, som0, caixa) {
     var i;
     for (i = 0; i < n; i++) {
         var a = (i / n) * Math.PI * 2 + 0.4, r = raio * (0.8 + 0.4 * ((i * 37) % 10) / 10), d = 10 + (i % 3) * 6;
-        var L = forma(comp, 'circulo', { x: cx, y: cy, w: d * 2, cor: cor, parent: cam.no, nome: 'estouro', alfa: 0 });
-        curva(kP(L), [[t, [cx, cy], null, 20], [t + 0.7, [cx + Math.cos(a) * r, cy + Math.sin(a) * r], 85, null]]);
+        var p0 = kNaBorda(caixa, cx, cy, a, d + 6), p1 = [p0[0] + Math.cos(a) * r, p0[1] + Math.sin(a) * r];
+        var L = forma(comp, 'circulo', { x: p0[0], y: p0[1], w: d * 2, cor: cor, parent: cam.no, nome: 'estouro', alfa: 0 });
+        curva(kP(L), [[t, p0, null, 20], [t + 0.7, p1, 85, null]]);
         curva(kO(L), [[t - 0.04, 0, null, 30], [t, 100, null, 30], [t + 0.2, 100, 50, 30], [t + 0.75, 0, 70, null]]);
         curva(kS(L), [[t, [40, 40], null, 20], [t + 0.25, [100, 100], 70, 30], [t + 0.75, [20, 20], 70, null]]);
     }
@@ -203,8 +215,8 @@ function cenaAntesDepois(comp, P, d) {
     var seta = texto(comp, '>', { fonte: P.fonteTitulo, tamanho: 190 * u, cor: P.ac, x: v ? W / 2 : W / 2, y: v ? H * 0.5 : H * 0.5, parent: cam.no, entrada: 'palavra', t0: t2 - 0.25, sublinhado: false, largura: 200, sobrepoe: true, semAuditoria: true });
     if (v) for (var s = 0; s < seta.camadas.length; s++) kR(seta.camadas[s]).expression = 'value + 90';
     som(t2 - 0.25, 'swoosh', 0.6);
-    var B = forma(comp, 'retangulo', { x: bx, y: by, w: cw, h: ch, r: 56 * u, cor: P.ac, parent: cam.no, nome: 'depois' });
-    var cor2 = kLum(P.ac) > 0.5 ? '#14110F' : '#FFFFFF';
+    var B = forma(comp, 'retangulo', { x: bx, y: by, w: cw, h: ch, r: 56 * u, cor: kCardAc(P), parent: cam.no, nome: 'depois' });
+    var cor2 = kSobreCard(P);
     mola(kS(B), t2, [60, 60], [100, 100], { quique: 0.7, dur: 0.75 });
     curva(kO(B), [[t2, 0, null, 30], [t2 + 0.1, 100, 60, null]]);
     mola(kR(B), t2, v ? 3 : -3, 0, { quique: 0.5, dur: 0.8 });
@@ -212,7 +224,7 @@ function cenaAntesDepois(comp, P, d) {
     texto(comp, 'DEPOIS', { fonte: P.fonteTitulo, tamanho: 44 * u, cor: P.bg, x: bx, y: by - ch / 2, parent: cam.no, entrada: 'sobe', t0: t2 + 0.18, largura: 220 * u, maxLinhas: 1, sublinhado: false });
     texto(comp, d.depois || '', { tamanho: 96 * u, cor: cor2, corDestaque: cor2, x: bx, y: by + 24 * u, parent: cam.no, entrada: 'palavra', t0: t2 + 0.32, largura: cw * 0.84, maxLinhas: 4, sublinhado: false });
     som(t2, 'impacto', 0.7); som(t2 + 0.05, 'brilho', 0.6);
-    kEstouro(comp, cam, bx, by, t2 + 0.05, P.fg, 8, ch * 0.75, false);
+    kEstouro(comp, cam, bx, by, t2 + 0.05, P.fg, 8, ch * 0.4, false, [bx - cw / 2, by - ch / 2, bx + cw / 2, by + ch / 2]);
     cam.empurra(0.8, v ? 0 : -60 * u, v ? -120 * u : 0, 1.02).empurra(t2 + 0.5, v ? 0 : 70 * u, v ? 130 * u : 0, 1.1).empurra(comp.duration - 0.2, v ? 0 : 90 * u, v ? 150 * u : 0, 1.13);
     fecha(comp);
 }
@@ -263,6 +275,19 @@ function cenaCitacao(comp, P, d) {
     fecha(comp);
 }
 
+// ---------------------------------------------------------------- o cursor que clica num botão
+/* kCursorNoBotao(comp, alvo, rot, ox, oy, cresce, preferido, u): a ponta do clique (no espaço do pai do cursor) pela regra da guarda
+   (gCursor): dentro do botão `alvo`, a setinha sem cobrir o rótulo `rot` (o retorno do texto(), com x, y, w, h no espaço do grupo do
+   botão, que está em ox, oy e cresce até `cresce`× no clique). Escreve a linha GUARDA da cena com a caixa do cursor e a do rótulo. */
+function kCursorNoBotao(comp, alvo, rot, ox, oy, cresce, preferido, u) {
+    var k = cresce || 1, cx = ox || 0, cy = oy || 0, rx = rot && rot.w ? rot.x : 0, ry = rot && rot.w ? rot.y : 0;
+    var rc0 = rot && rot.w ? [cx + (rx - rot.w / 2) * k, cy + (ry - rot.h / 2) * k, cx + (rx + rot.w / 2) * k, cy + (ry + rot.h / 2) * k] : null;
+    var r = gCursor(alvo, rc0 ? [rc0] : [], { w: 48 * u, h: 70 * u, folga: 10 * u, preferido: preferido });
+    var log = ['cursor: clica em [' + Math.round(r.ponta[0]) + ',' + Math.round(r.ponta[1]) + ']' + (r.movido ? ' (saiu de cima do texto)' : '') + (r.ok ? '' : ' na borda de baixo do botão')];
+    writeLn('GUARDA ' + JSON.stringify({ cena: KIT.cenaIdx, w: comp.width, h: comp.height, log: log, caixas: [{ tipo: 'cursor', nome: 'cursor', c: [Math.round(r.c[0]), Math.round(r.c[1]), Math.round(r.c[2]), Math.round(r.c[3])], fora: 0 }].concat(rc0 ? [{ tipo: 'texto', nome: 'rótulo do botão', c: [Math.round(rc0[0]), Math.round(rc0[1]), Math.round(rc0[2]), Math.round(rc0[3])], fora: 0 }] : []), violacoes: gVerificar([{ tipo: 'cursor', nome: 'cursor', c: r.c }].concat(rc0 ? [{ tipo: 'texto', nome: 'rótulo', c: rc0, livre: false }] : []), comp.width, comp.height, { zona: { x0: -1e9, x1: 1e9, y0: -1e9, y1: 1e9, trilho: null } }) }));
+    return r.ponta;
+}
+
 // ---------------------------------------------------------------- CTA
 /* O CTA: título que voa, botão SÓLIDO com brilho que varre (Merge Paths em Intersect: o brilho só existe dentro da pílula) e um
    ícone; o cursor entra, o botão afunda e volta com quique, estoura em ondas e partículas, com clique + impacto. Sem camada fantasma. */
@@ -296,7 +321,7 @@ function cenaCta(comp, P, d) {
     var ic = caminho(comp, [[-22 * u, 0], [24 * u, 0]], { cor: ink, esp: 11 * u, parent: btn, nome: 'seta-haste' });
     caminho(comp, [[6 * u, -20 * u], [26 * u, 0], [6 * u, 20 * u]], { cor: ink, esp: 11 * u, parent: btn, nome: 'seta-ponta' });
     var arrows = [];
-    texto(comp, d.botao || 'Começar agora', { fonte: P.fonteTitulo, tamanho: (v ? 84 : 58) * u, cor: ink, corDestaque: ink, x: -28 * u, y: 0, parent: btn, entrada: 'sobe', t0: tb + 0.08, largura: bw * 0.7, maxLinhas: 1, sublinhado: false, livre: true, fala: false });
+    var rot = texto(comp, d.botao || 'Começar agora', { fonte: P.fonteTitulo, tamanho: (v ? 84 : 58) * u, cor: ink, corDestaque: ink, x: -28 * u, y: 0, parent: btn, entrada: 'sobe', t0: tb + 0.08, largura: bw * 0.7, maxLinhas: 1, sublinhado: false, livre: true, fala: false });
     var iconX = bw / 2 - 74 * u;
     var j, kids = [];
     // posiciona a seta à direita do rótulo
@@ -307,7 +332,10 @@ function cenaCta(comp, P, d) {
     // o cursor entra, o botão afunda e explode
     var tp = tb + 1.05;
     var cur = kCursor(comp, cam.no, u, '#FFFFFF', '#101010');
-    var c0 = [bx + bw * 0.5, by + 460 * u], c1 = [bx + bw * 0.4, by + 6 * u];   // clica na borda direita, no ícone da seta (nunca em cima do texto)
+    // o cursor é ELEMENTO para a guarda: a ponta clica dentro do botão, depois do texto (na seta) ou na borda; a setinha
+    // inteira (48×70 a partir da ponta) nunca cobre o rótulo, nem com o botão crescendo 10% no estouro do clique
+    var c1 = kCursorNoBotao(comp, [bx - bw / 2, by - bh / 2, bx + bw / 2, by + bh / 2], rot, bx, by, 1.1, [bx + iconX - 4 * u, by + 10 * u], u);
+    var c0 = [c1[0] + bw * 0.1, by + 460 * u];
     kP(cur).setValue(c0);
     curva(kP(cur), [[tp - 0.75, c0, null, 18], [tp - 0.05, c1, 82, 40]]);
     curva(kO(cur), [[tp - 0.75, 0, null, 30], [tp - 0.55, 100, 60, null], [tp + 0.8, 100, null, 30], [tp + 1.05, 0, 60, null]]);
@@ -319,8 +347,9 @@ function cenaCta(comp, P, d) {
         curva(kS(on), [[tp + j * 0.07, [100, 100], null, 20], [tp + j * 0.07 + 0.7, [150 + j * 14, 220 + j * 30], 80, null]]);
         curva(kO(on), [[tp + j * 0.07 - 0.02, 0, null, 30], [tp + j * 0.07, 85, null, 30], [tp + j * 0.07 + 0.7, 0, 70, null]]);
     }
-    kEstouro(comp, cam, bx, by, tp + 0.04, P.ac, 16, bw * 0.4, false);
-    kEstouro(comp, cam, bx, by, tp + 0.08, P.fg, 10, bw * 0.3, false);
+    var cxBotao = [bx - bw / 2 * 1.1, by - bh / 2 * 1.1, bx + bw / 2 * 1.1, by + bh / 2 * 1.1];   // o botão a 110% no estouro
+    kEstouro(comp, cam, bx, by, tp + 0.04, P.ac, 16, bw * 0.25, false, cxBotao);
+    kEstouro(comp, cam, bx, by, tp + 0.08, P.fg, 10, bw * 0.18, false, cxBotao);
     som(tp, 'clique', 0.9); som(tp + 0.03, 'impacto', 0.6); som(tp + 0.1, 'brilho', 0.6);
     // depois do clique o botão respira e solta um halo, sem parar
     var halo = forma(comp, 'pilula', { x: bx, y: by, w: bw, h: bh, traco: P.ac, tracoL: 6 * u, alfa: 0, parent: cam.no, nome: 'halo' });
@@ -331,14 +360,14 @@ function cenaCta(comp, P, d) {
 }
 
 // ---------------------------------------------------------------- montagem
-/* O vocabulário de cenas: 8 clássicas (aqui) + 30 primitivas (primitivas.jsx). O diretor (maquina-diretor.js) escolhe. */
+/* O vocabulário de cenas: 8 clássicas (aqui) + 31 primitivas (primitivas.jsx; a 31ª, "foto", só entra quando o pedido traz foto). O diretor (maquina-diretor.js) escolhe. */
 var CENAS = {
     gancho: cenaGancho, celular: cenaCelular, numero: cenaNumero, lista: cenaLista, antes_depois: cenaAntesDepois, icones: cenaIcones, citacao: cenaCitacao, cta: cenaCta,
     cinetico: cenaCinetico, interface: cenaInterface, mergulho: cenaMergulho, camera_nulls: cenaCameraNulls, barras: cenaBarras, linha: cenaLinha, mapa: cenaMapa,
     cards_pulam: cenaCardsPulam, cursor: cenaCursor, notificacoes: cenaNotificacoes, chat: cenaChat, linha_tempo: cenaLinhaTempo, laco: cenaLaco, explosao: cenaExplosao,
     revela: cenaRevela, split: cenaSplit, heroi: cenaHeroi, particulas: cenaParticulas, relogio: cenaRelogio, calendario: cenaCalendario, funil: cenaFunil,
     parede_logos: cenaParedeLogos, prompt: cenaPrompt, odometro: cenaOdometro, medidor: cenaMedidor, carimbo: cenaCarimbo, leque: cenaLeque, ondas: cenaOndas,
-    rolagem: cenaRolagem, estrelas: cenaEstrelas
+    rolagem: cenaRolagem, estrelas: cenaEstrelas, foto: cenaFoto
 };
 
 function montar(PL) {
@@ -366,7 +395,10 @@ function montar(PL) {
         var c = PL.cenas[i], dur = c.dur + (i < n - 1 ? TROCA_DUR + 0.05 : 0), f = Math.max(1, Math.min(2.4, c.f || 1));
         // a cena é montada em tempo NOMINAL (dur × f) e tocada f vezes mais rápido dentro de uma comp-embrulho: tudo entra nos primeiros ~35%
         var comp = novaComp('CENA ' + i, W, H, dur * f, fps);
-        KIT.cenaComElemento = !!c.elemento; KIT.semAmbiente = !!c.semAmbiente || !{ cinetico: 1, gancho: 1, numero: 1, citacao: 1, particulas: 1, odometro: 1, relogio: 1, carimbo: 1 }[c.tipo];   // enfeite só onde há espaço livre de verdade (nada de herói em cima de janela, prompt ou botão) KIT.semRotulos = !!c.semRotulos; KIT.cenaHeroi = c.tipo == 'heroi' || c.tipo == 'revela'; KIT.titulosL = []; KIT.tituloB = null; KIT.t0 = starts[i]; KIT.cenaIdx = i; KIT.estilo = c.camera || PL.camera || 'deriva'; KIT.ajusteCena = c.ajuste || 1; KIT.f = f; KIT.entMax = 0;
+        // enfeite só onde há espaço livre de verdade (nada de herói em cima de janela, prompt ou botão)
+        KIT.cenaComElemento = !!c.elemento; KIT.semAmbiente = !!c.semAmbiente || !{ cinetico: 1, gancho: 1, numero: 1, citacao: 1, particulas: 1, odometro: 1, relogio: 1, carimbo: 1 }[c.tipo];
+        // (até 20/10 esta linha morava DEPOIS do comentário acima, na mesma linha: o cenaIdx, o t0, o ajuste e o f nunca eram postos)
+        KIT.semRotulos = !!c.semRotulos; KIT.cenaHeroi = c.tipo == 'heroi' || c.tipo == 'revela'; KIT.titulosL = []; KIT.tituloB = null; KIT.t0 = starts[i]; KIT.cenaIdx = i; KIT.estilo = c.camera || PL.camera || 'deriva'; KIT.ajusteCena = c.ajuste || 1; KIT.tituloDesce = c.tituloDesce || 0; KIT.f = f; KIT.entMax = 0;
         var P = c.pal; KIT.pal = P;
         P.fonteTitulo = PL.fontes.titulo; P.fonteTexto = PL.fontes.texto; P.fonteDestaque = PL.fontes.destaque;
         if (!CENAS[c.tipo]) KIT.avisos.push('cena ' + i + ': tipo desconhecido ' + c.tipo);

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

@@ -0,0 +1,274 @@
+/*  guarda.jsx — a GUARDA de layout do motion (ES3: só var e function).
+
+    O mesmo arquivo roda em dois lugares, ANTES do render:
+      1. no Node (lib/estudio/maquina-guarda.js carrega pelo vm): planeja a cena "foto" (foto, título, ícones) com a largura
+         medida da fonte e escreve o layout no plano;
+      2. no kit (o maquina.js concatena depois do base.jsx): no fecha() de CADA cena, com as caixas reais (sourceRectAtTime),
+         conserta o que o modelo ou o diretor puseram torto.
+
+    Regras (a régua do dono: muito movimento, mas NADA feio — nada gigante, nada sobreposto, nada colado na borda):
+      tamanho   texto até 88% da largura; ícone entre 12% e 24% do lado menor; foto entre 55% e 80% da largura no 9:16
+      zona      tudo dentro de 6% de margem; no 9:16 fora das faixas de interface do Reels/TikTok (10% em cima, 20% embaixo)
+                e do trilho de botões da direita
+      sobrepor  texto não encosta em nada (folga mínima); ícone nunca sobre texto, foto/rosto ou outro ícone
+      lotação   no máximo N elementos ao mesmo tempo (os ícones de menor prioridade saem)
+    Quando viola, CONSERTA (reposiciona, encolhe, tira o ícone de trás); se não der, pede a troca da peça (trocar: true).
+    Cada conserto vira uma linha do log da cena.
+
+    item = { id, tipo: 'texto'|'icone'|'foto'|'cartao'|'cursor', c: [x0, y0, x1, y1] (o envelope de todos os quadros-chave),
+             fixo (não move nem encolhe), prio (maior fica), nome, alvo (cursor: a caixa do botão que ele clica) }
+    cursor    a setinha é elemento: nunca em cima de letra; clica na borda do botão ou depois do texto (gCursor)
+*/
+
+var GUARDA = { margem: 0.06, folga: 28, maxSimult: 6, textoMaxL: 0.88, iconeMin: 0.12, iconeMax: 0.24, fotoMin: 0.55, fotoMax: 0.8, passo: 0.025 };
+
+function gAlto(W, H) { return H / W > 1.6; }
+/* A zona segura (no mesmo espaço das caixas). o.legenda: a legenda sobe a faixa de baixo. */
+function gZona(W, H, o) {
+    o = o || {};
+    var m = GUARDA.margem, z = { x0: W * m, x1: W * (1 - m), y0: H * m, y1: H * (1 - m), trilho: null };
+    if (gAlto(W, H)) {
+        z.y0 = H * 0.1; z.y1 = H * (o.legenda ? 0.73 : 0.8);
+        z.trilho = [W * 0.885, H * 0.5, W, H];   // a coluna de curtir/comentar/compartilhar
+    }
+    return z;
+}
+function gW(c) { return c[2] - c[0]; }
+function gH(c) { return c[3] - c[1]; }
+function gCx(c) { return (c[0] + c[2]) / 2; }
+function gCy(c) { return (c[1] + c[3]) / 2; }
+function gR(n) { return Math.round(n); }
+function gTxt(c) { return '[' + gR(c[0]) + ',' + gR(c[1]) + ',' + gR(c[2]) + ',' + gR(c[3]) + ']'; }
+function gCaixa(cx, cy, w, h) { return [cx - w / 2, cy - h / 2, cx + w / 2, cy + h / 2]; }
+function gMove(c, dx, dy) { return [c[0] + dx, c[1] + dy, c[2] + dx, c[3] + dy]; }
+function gEscala(c, k) { return gCaixa(gCx(c), gCy(c), gW(c) * k, gH(c) * k); }
+/* Encostam? (com folga m entre as duas) */
+function gToca(a, b, m) { m = m || 0; return a[0] < b[2] + m && b[0] < a[2] + m && a[1] < b[3] + m && b[1] < a[3] + m; }
+function gCabe(c, z) { return c[0] >= z.x0 - 0.5 && c[2] <= z.x1 + 0.5 && c[1] >= z.y0 - 0.5 && c[3] <= z.y1 + 0.5; }
+function gNoTrilho(c, z) { return !!z.trilho && gToca(c, z.trilho, 0); }
+function gNome(it) { return it.nome || (it.tipo + ' ' + it.id); }
+
+/* Põe a caixa dentro da zona (encolhe se for maior). Devolve a caixa nova. */
+function gEncaixa(c, z) {
+    var w = gW(c), h = gH(c), zw = z.x1 - z.x0, zh = z.y1 - z.y0, k = Math.min(1, zw / w, zh / h);
+    if (k < 1) c = gEscala(c, k);
+    var dx = 0, dy = 0;
+    if (c[0] < z.x0) dx = z.x0 - c[0]; else if (c[2] > z.x1) dx = z.x1 - c[2];
+    if (c[1] < z.y0) dy = z.y0 - c[1]; else if (c[3] > z.y1) dy = z.y1 - c[3];
+    return gMove(c, dx, dy);
+}
+
+/* Procura um lugar livre do tamanho (w, h) o mais perto de (cx, cy): nada em `ocupado` (com folga), dentro da zona, fora do trilho. */
+function gLugarLivre(cx, cy, w, h, z, ocupado, folga, W) {
+    var passo = Math.max(8, W * GUARDA.passo), melhor = null, md = 1e18, x, y, j;
+    for (y = z.y0 + h / 2; y <= z.y1 - h / 2 + 0.5; y += passo) {
+        for (x = z.x0 + w / 2; x <= z.x1 - w / 2 + 0.5; x += passo) {
+            var c = gCaixa(x, y, w, h), livre = !gNoTrilho(c, z);
+            for (j = 0; livre && j < ocupado.length; j++) if (gToca(c, ocupado[j], folga)) livre = false;
+            if (!livre) continue;
+            var d = (x - cx) * (x - cx) + (y - cy) * (y - cy);
+            if (d < md) { md = d; melhor = c; }
+        }
+    }
+    return melhor;
+}
+
+/* O CURSOR é um elemento como os outros: a ponta clica DENTRO do alvo (botão, campo), mas a setinha inteira (da ponta para a
+   direita e para baixo) nunca cobre letra. Clica na borda do botão ou depois do texto.
+   gCursor(alvo, textos, o) → { ponta: [x, y], c: caixa da setinha, movido, ok }
+   o = { w, h (a setinha a partir da ponta), folga, preferido: [x, y], pilula (o alvo é pílula: a ponta fica dentro do arredondado) } */
+function gCaixaCursor(p, w, h) { return [p[0] - 3, p[1] - 3, p[0] + w, p[1] + h]; }
+function gDentroAlvo(p, c, pilula) {
+    var h = gH(c), r = h / 2, cy = gCy(c), m = h * 0.1;
+    if (!pilula) return p[0] >= c[0] + m && p[0] <= c[2] - m && p[1] >= c[1] + m && p[1] <= c[3] - m;
+    var x = Math.max(c[0] + r, Math.min(c[2] - r, p[0]));
+    return (p[0] - x) * (p[0] - x) + (p[1] - cy) * (p[1] - cy) <= (r - m) * (r - m);
+}
+function gCursor(alvo, textos, o) {
+    o = o || {};
+    var w = o.w || 48, h = o.h || 70, folga = o.folga != null ? o.folga : 6, i, j, x, y;
+    var pref = o.preferido || [alvo[2] - gH(alvo) * 0.45, gCy(alvo) + gH(alvo) * 0.12];
+    var livre = function (p) {
+        if (!gDentroAlvo(p, alvo, o.pilula !== false)) return false;
+        var c = gCaixaCursor(p, w, h);
+        for (j = 0; j < textos.length; j++) if (gToca(c, textos[j], folga)) return false;
+        return true;
+    };
+    if (livre(pref)) return { ponta: pref, c: gCaixaCursor(pref, w, h), movido: false, ok: true };
+    var passo = Math.max(4, Math.min(gW(alvo), gH(alvo)) / 12), melhor = null, md = 1e18;
+    for (y = alvo[1]; y <= alvo[3]; y += passo) {
+        for (x = alvo[0]; x <= alvo[2]; x += passo) {
+            if (!livre([x, y])) continue;
+            var d = (x - pref[0]) * (x - pref[0]) + (y - pref[1]) * (y - pref[1]);
+            if (d < md) { md = d; melhor = [x, y]; }
+        }
+    }
+    if (melhor) return { ponta: melhor, c: gCaixaCursor(melhor, w, h), movido: true, ok: true };
+    // sem lugar dentro sem cobrir letra: a ponta vai para a borda de baixo do botão, abaixo do texto (a setinha pende para fora)
+    var baixo = alvo[3] - gH(alvo) * 0.06;
+    for (j = 0; j < textos.length; j++) if (gToca(textos[j], alvo, 0) && textos[j][3] + folga + 3 > baixo) baixo = textos[j][3] + folga + 3;
+    var p2 = [alvo[2] - gH(alvo) * 0.5, baixo];
+    return { ponta: p2, c: gCaixaCursor(p2, w, h), movido: true, ok: false };
+}
+
+/* TEXTO DENTRO DE CARTÃO (faixa, placa, botão): o texto cabe no cartão com folga. Não cabe: o corpo encolhe até o mínimo (kMin);
+   ainda não cabe: o cartão cresce em volta do texto (até a caixa `max`, se houver).
+   gTextoNoCartao(t, c, o) → { k (escala do texto), cartao (a caixa nova), cresceu, ok, log }   o = { folga, kMin, max } */
+function gTextoNoCartao(t, c, o) {
+    o = o || {};
+    var f = o.folga || 0, kMin = o.kMin == null ? 0.8 : o.kMin, log = [];
+    var k = Math.min(1, (gW(c) - 2 * f) / Math.max(1, gW(t)), (gH(c) - 2 * f) / Math.max(1, gH(t)));
+    var dentro = t[0] >= c[0] + f - 0.5 && t[2] <= c[2] - f + 0.5 && t[1] >= c[1] + f - 0.5 && t[3] <= c[3] - f + 0.5;
+    if (k >= 1 && dentro) return { k: 1, cartao: c, cresceu: false, ok: true, log: log };
+    if (k >= 1) k = 1;
+    else if (k >= kMin) log.push('texto apertado no cartão: o corpo encolheu para ' + Math.round(k * 100) + '%');
+    else k = kMin;
+    var w = Math.max(gW(c), gW(t) * k + 2 * f), h = Math.max(gH(c), gH(t) * k + 2 * f), ok = true;
+    if (o.max) { if (w > gW(o.max)) { w = gW(o.max); ok = false; } if (h > gH(o.max)) { h = gH(o.max); ok = false; } }
+    var nc = gCaixa(gCx(t), gCy(t), w, h), cresceu = w > gW(c) + 0.5 || h > gH(c) + 0.5 || Math.abs(gCy(t) - gCy(c)) > 0.5 || Math.abs(gCx(t) - gCx(c)) > 0.5;
+    if (cresceu) log.push('texto vazava do cartão: o cartão foi para ' + Math.round(w) + '×' + Math.round(h) + (ok ? '' : ' (no máximo; o texto ainda encosta)'));
+    return { k: k, cartao: nc, cresceu: cresceu, ok: ok, log: log };
+}
+
+/*
+ * gConsertar(itens, W, H, o) → { itens, log: [texto], trocar: bool, violacoes: [texto] }
+ * o = { zona (gZona), folga, so: 'icones' (só move/encolhe/tira ícones e a foto: o kit, com o texto já posto), legenda,
+ *       escalaMundo (layout → tela: a regra da foto 55–80% vale pro que se vê) }
+ * Cada item ganha: c (a caixa final), k (escala aplicada), dx/dy (deslocamento do centro), removido.
+ */
+function gConsertar(itens, W, H, o) {
+    o = o || {};
+    var z = o.zona || gZona(W, H, o), folga = o.folga != null ? o.folga : GUARDA.folga * Math.min(W, H) / 1080;
+    var log = [], trocar = false, i, j, a, b, alto = gAlto(W, H), lado = Math.min(W, H), soIcones = o.so == 'icones', em = o.escalaMundo || 1;
+    var L = [];
+    for (i = 0; i < itens.length; i++) { a = itens[i]; a.c0 = [a.c[0], a.c[1], a.c[2], a.c[3]]; a.removido = false; L.push(a); }
+    var pode = function (it) { return !it.fixo && (!soIcones || it.tipo == 'icone' || it.movel); };
+
+    // 1. tamanho por tipo
+    for (i = 0; i < L.length; i++) {
+        a = L[i];
+        if (!pode(a)) continue;
+        if (a.tipo == 'texto' && gW(a.c) > W * GUARDA.textoMaxL) { a.c = gEscala(a.c, W * GUARDA.textoMaxL / gW(a.c)); log.push('texto largo: ' + gNome(a) + ' encolheu para ' + Math.round(GUARDA.textoMaxL * 100) + '% da largura'); }
+        if (a.tipo == 'icone') {
+            var s = Math.max(gW(a.c), gH(a.c)) / (a.infla || 1);
+            if (s > lado * GUARDA.iconeMax) { a.c = gEscala(a.c, lado * GUARDA.iconeMax / s); log.push('ícone gigante: ' + gNome(a) + ' de ' + Math.round(s) + ' px para ' + Math.round(lado * GUARDA.iconeMax) + ' px'); }
+            else if (s < lado * GUARDA.iconeMin) { a.c = gEscala(a.c, lado * GUARDA.iconeMin / s); log.push('ícone pequeno: ' + gNome(a) + ' cresceu para ' + Math.round(lado * GUARDA.iconeMin) + ' px'); }
+        }
+        if (a.tipo == 'foto' && alto) {
+            var fw = gW(a.c) / (a.infla || 1) * em;   // no MUNDO: a regra é sobre o que o espectador vê
+            if (fw < W * GUARDA.fotoMin - 0.5) { a.c = gEscala(a.c, W * GUARDA.fotoMin / fw); log.push('foto pequena: ' + Math.round(fw / W * 100) + '% da largura, cresceu para ' + Math.round(GUARDA.fotoMin * 100) + '%'); }
+            else if (fw > W * GUARDA.fotoMax + 0.5) { a.c = gEscala(a.c, W * GUARDA.fotoMax / fw); log.push('foto gigante: ' + Math.round(fw / W * 100) + '% da largura, encolheu para ' + Math.round(GUARDA.fotoMax * 100) + '%'); }
+        }
+    }
+    // 2. zona segura (e o trilho de botões do 9:16)
+    for (i = 0; i < L.length; i++) {
+        a = L[i];
+        if (!pode(a) || a.livre) continue;
+        var antes = a.c;
+        if (!gCabe(a.c, z)) a.c = gEncaixa(a.c, z);
+        if (gNoTrilho(a.c, z) && (a.tipo == 'icone' || a.tipo == 'foto')) {
+            var nx = gMove(a.c, z.trilho[0] - folga * 0.5 - a.c[2], 0);
+            if (gCabe(nx, z)) a.c = nx; else { var ny = gMove(a.c, 0, z.trilho[1] - a.c[3]); if (gCabe(ny, z)) a.c = ny; }
+        }
+        if (antes !== a.c) log.push('fora da zona segura: ' + gNome(a) + ' ' + gTxt(antes) + ' → ' + gTxt(a.c));
+    }
+    // 3. texto × foto/cartão: afasta (a foto sobe ou desce; ou o texto), depois encolhe a foto até o mínimo; senão, troca a peça
+    for (i = 0; i < L.length; i++) {
+        a = L[i];
+        if (a.tipo != 'texto') continue;
+        for (j = 0; j < L.length; j++) {
+            b = L[j];
+            if (b === a || (b.tipo != 'foto' && b.tipo != 'cartao') || !gToca(a.c, b.c, folga)) continue;
+            var feito = false, tentativa;
+            if (pode(b)) {   // a foto vai para o lado oposto ao do texto
+                var cima = gCy(b.c) <= gCy(a.c);
+                for (tentativa = 0; tentativa < 12 && !feito; tentativa++) {
+                    var nb = cima ? gMove(b.c, 0, a.c[1] - folga - b.c[3]) : gMove(b.c, 0, a.c[3] + folga - b.c[1]);
+                    if (gCabe(nb, z)) { log.push('texto encostado na foto: ' + gNome(b) + ' foi para ' + (cima ? 'cima' : 'baixo') + (tentativa ? ' (encolhida ' + Math.round(gW(b.c) / W * 100) + '%)' : '')); b.c = nb; feito = true; break; }
+                    var min = b.tipo == 'foto' && alto ? W * GUARDA.fotoMin * (b.infla || 1) / em : gW(b.c0) * 0.6;
+                    if (gW(b.c) * 0.94 < min) break;
+                    b.c = gEscala(b.c, 0.94);
+                }
+            }
+            if (!feito && pode(a)) {
+                var embaixo = gCy(a.c) >= gCy(b.c);
+                var na = embaixo ? gMove(a.c, 0, b.c[3] + folga - a.c[1]) : gMove(a.c, 0, b.c[1] - folga - a.c[3]);
+                if (gCabe(na, z)) { log.push('texto encostado em ' + gNome(b) + ': o texto foi para ' + (embaixo ? 'baixo' : 'cima')); a.c = na; feito = true; }
+            }
+            if (!feito) { trocar = true; log.push('não coube: ' + gNome(a) + ' e ' + gNome(b) + ' se sobrepõem sem saída: troca a peça'); }
+        }
+    }
+    // 3b. cursor: nunca em cima de letra; a ponta continua dentro do alvo (o botão), a setinha vai para a borda ou depois do texto
+    var textosC = [];
+    for (i = 0; i < L.length; i++) if (L[i].tipo == 'texto' && !L[i].removido) textosC.push(L[i].c);
+    for (i = 0; i < L.length; i++) {
+        a = L[i];
+        if (a.tipo != 'cursor' || !a.alvo) continue;
+        var bateC = false;
+        for (j = 0; j < textosC.length; j++) if (gToca(a.c, textosC[j], folga * 0.25)) bateC = true;
+        if (!bateC) continue;
+        var rc = gCursor(a.alvo, textosC, { w: gW(a.c) - 3, h: gH(a.c) - 3, folga: folga * 0.25, pilula: a.pilula !== false });
+        log.push('cursor sobre o texto: ' + gNome(a) + ' ' + gTxt(a.c) + ' → ' + gTxt(rc.c) + (rc.ok ? '' : ' (na borda do botão)'));
+        a.c = rc.c; a.ponta = rc.ponta;
+    }
+    // 4. ícones: nunca sobre texto, foto/rosto, cartão ou outro ícone; acha um lugar livre, encolhe até o mínimo, ou sai
+    var ordem = [];
+    for (i = 0; i < L.length; i++) if (L[i].tipo == 'icone') ordem.push(L[i]);
+    ordem.sort(function (p, q) { return (q.prio || 0) - (p.prio || 0); });
+    var ocupado = [];
+    for (i = 0; i < L.length; i++) if (L[i].tipo != 'icone') ocupado.push(L[i].c);
+    for (i = 0; i < ordem.length; i++) {
+        a = ordem[i];
+        var bate = !gCabe(a.c, z) || gNoTrilho(a.c, z), quem = '';
+        for (j = 0; !bate && j < ocupado.length; j++) if (gToca(a.c, ocupado[j], folga)) bate = true;
+        if (!bate) { ocupado.push(a.c); continue; }
+        if (!pode(a)) { log.push('ícone fixo sobreposto: ' + gNome(a)); continue; }
+        for (j = 0; j < L.length; j++) if (L[j] !== a && !L[j].removido && L[j].tipo != 'icone' && gToca(a.c, L[j].c, folga)) { quem = L[j].tipo == 'texto' ? 'o texto' : (L[j].tipo == 'foto' ? 'a foto' : gNome(L[j])); break; }
+        var w = gW(a.c), h = gH(a.c), achou = null, k = 1, s0 = Math.max(w, h) / (a.infla || 1), minK = Math.min(1, lado * GUARDA.iconeMin / s0);
+        while (!achou && k >= minK - 0.001) {
+            achou = gLugarLivre(gCx(a.c), gCy(a.c), w * k, h * k, z, ocupado, folga, W);
+            if (!achou) k = k > minK + 0.001 ? Math.max(minK, k * 0.85) : minK - 1;
+        }
+        if (achou) {
+            log.push('ícone ' + (quem ? 'sobre ' + quem : 'fora do lugar') + ': ' + gNome(a) + ' ' + gTxt(a.c) + ' → ' + gTxt(achou) + (k < 0.999 ? ' (encolhido ' + Math.round(k * 100) + '%)' : ''));
+            a.c = achou; ocupado.push(achou);
+        } else { a.removido = true; log.push('ícone sem lugar livre' + (quem ? ' (estava sobre ' + quem + ')' : '') + ': ' + gNome(a) + ' saiu'); }
+    }
+    // 5. lotação: no máximo N ao mesmo tempo (sai o ícone de menor prioridade)
+    var vivos = 0;
+    for (i = 0; i < L.length; i++) if (!L[i].removido) vivos++;
+    for (i = ordem.length - 1; i >= 0 && vivos > (o.maxSimult || GUARDA.maxSimult); i--) {
+        if (ordem[i].removido || !pode(ordem[i])) continue;
+        ordem[i].removido = true; vivos--; log.push('elementos demais na cena: ' + gNome(ordem[i]) + ' saiu');
+    }
+    for (i = 0; i < L.length; i++) {
+        a = L[i];
+        a.k = gW(a.c) / Math.max(1e-6, gW(a.c0));
+        a.dx = gCx(a.c) - gCx(a.c0); a.dy = gCy(a.c) - gCy(a.c0);
+    }
+    return { itens: L, log: log, trocar: trocar, violacoes: gVerificar(L, W, H, { zona: z, folga: folga * 0.5 }) };
+}
+
+/* Só confere (não mexe): o que ainda viola. É a conferência por caixa quando não há olho (Vision) depois do render. */
+function gVerificar(itens, W, H, o) {
+    o = o || {};
+    var z = o.zona || gZona(W, H, o), folga = o.folga != null ? o.folga : 0, v = [], i, j, a, b;
+    for (i = 0; i < itens.length; i++) {
+        a = itens[i];
+        if (a.removido || a.livre) continue;
+        if (!gCabe(a.c, { x0: z.x0 - 6, x1: z.x1 + 6, y0: z.y0 - 6, y1: z.y1 + 6 })) v.push('fora da zona segura: ' + gNome(a) + ' ' + gTxt(a.c));
+        else if ((a.tipo == 'icone' || a.tipo == 'foto') && gNoTrilho(a.c, z)) v.push('no trilho de botões: ' + gNome(a));
+        for (j = i + 1; j < itens.length; j++) {
+            b = itens[j];
+            if (b.removido || b.livre) continue;
+            if (a.tipo == 'texto' && b.tipo == 'texto') continue;   // texto × texto: quem confere é o kit (tempos diferentes)
+            if (a.tipo == 'cursor' || b.tipo == 'cursor') {          // o cursor só não pode cobrir letra
+                if ((a.tipo == 'texto' || b.tipo == 'texto') && gToca(a.c, b.c, 0)) v.push('cursor sobre o texto: ' + gNome(a.tipo == 'cursor' ? b : a));
+                continue;
+            }
+            if ((a.tipo == 'cartao' && b.tipo == 'cartao')) continue;
+            if (gToca(a.c, b.c, folga - 1e-6) && (a.tipo == 'texto' || b.tipo == 'texto' || a.tipo == 'icone' || b.tipo == 'icone')) v.push('sobreposição: ' + gNome(a) + ' × ' + gNome(b));
+        }
+    }
+    return v;
+}