sagadeck 1.2.0

package/src/figures/points.js

@@ -0,0 +1,106 @@
+// Figura de pontos: ícones desenhados com luzinhas (estilo show de drones), com morph de uma
+// forma para outra. Uso: { points: fone } ou { points: { de: fone, para: mic, legenda, legendaPara } }.
+// Só no HTML a troca é animada (clique na figura); PPTX/PDF usam a forma inicial.
+const W = 20, H = 20;
+
+const distSeg = (x, y, x0, y0, x1, y1) => {
+  const dx = x1 - x0, dy = y1 - y0, L2 = dx * dx + dy * dy || 1;
+  const t = Math.max(0, Math.min(1, ((x - x0) * dx + (y - y0) * dy) / L2));
+  return Math.hypot(x - (x0 + t * dx), y - (y0 + t * dy));
+};
+const P = {
+  disc: (cx, cy, r) => (x, y) => Math.hypot(x - cx, y - cy) <= r,
+  ring: (cx, cy, r, th) => (x, y) => Math.abs(Math.hypot(x - cx, y - cy) - r) <= th / 2,
+  // arco: ângulos em graus, 0 = direita, anti-horário positivo (como na tela, y para baixo: use a0>a1 para o topo)
+  arc: (cx, cy, r, th, a0, a1) => (x, y) => {
+    if (Math.abs(Math.hypot(x - cx, y - cy) - r) > th / 2) return false;
+    let a = (Math.atan2(y - cy, x - cx) * 180) / Math.PI;
+    if (a < 0) a += 360;
+    const lo = Math.min(a0, a1), hi = Math.max(a0, a1);
+    return a >= lo && a <= hi;
+  },
+  rect: (x0, y0, w, h) => (x, y) => x >= x0 && x < x0 + w && y >= y0 && y < y0 + h,
+  line: (x0, y0, x1, y1, th) => (x, y) => distSeg(x, y, x0, y0, x1, y1) <= th / 2,
+  // moldura vazada (só a borda, como os óculos da foto: o vazio de dentro aparece)
+  frame: (x0, y0, w, h, th) => (x, y) => {
+    const ix = x >= x0 + th / 2 && x < x0 + w - th / 2, iy = y >= y0 + th / 2 && y < y0 + h - th / 2;
+    const ox = x >= x0 - th / 2 && x < x0 + w + th / 2, oy = y >= y0 - th / 2 && y < y0 + h + th / 2;
+    return ox && oy && !(ix && iy);
+  },
+  tri: (x0, y0, x1, y1, x2, y2) => (x, y) => {
+    const s = (ax, ay, bx, by, cx, cy) => (cx - bx) * (ay - by) - (ax - bx) * (cy - by);
+    const d1 = s(x, y, x0, y0, x1, y1), d2 = s(x, y, x1, y1, x2, y2), d3 = s(x, y, x2, y2, x0, y0);
+    return !((d1 < 0 || d2 < 0 || d3 < 0) && (d1 > 0 || d2 > 0 || d3 > 0));
+  },
+};
+const any = (...fs) => (x, y) => fs.some((f) => f(x, y));
+
+// Biblioteca de formas em grade 20×20: contornos vazados (o preto de dentro aparece),
+// nunca massa sólida. Espessura ~1 para o grão ficar fino.
+const SHAPES = {
+  // fone de ouvido: arco no topo + duas conchas vazadas
+  fone: any(P.arc(10, 10.5, 7, 1.4, 180, 360), P.frame(1.6, 9.5, 3, 6.5, 1.2), P.frame(15.4, 9.5, 3, 6.5, 1.2)),
+  // microfone: anel + haste + base
+  mic: any(P.ring(10, 5.6, 2.9, 1.4), P.line(10, 8.8, 10, 15, 1.3), P.arc(10, 15.5, 3.4, 1.2, 15, 165), P.line(6.6, 17.6, 13.4, 17.6, 1.2)),
+  // documento: moldura + dobra + linhas de texto
+  doc: any(
+    P.frame(6, 2, 8, 16, 1.2),
+    P.line(14, 2, 14, 6, 1.1), P.line(14, 6, 10, 2, 1.1),
+    P.line(7.8, 8.6, 12.2, 8.6, 0.8), P.line(7.8, 10.8, 12.2, 10.8, 0.8), P.line(7.8, 13, 11, 13, 0.8),
+  ),
+  // planilha: moldura + cabeçalho + grade
+  planilha: any(
+    P.frame(3.5, 3.5, 13, 13, 1.2),
+    P.line(3.5, 6.5, 16.5, 6.5, 1),
+    P.line(10, 3.5, 10, 16.5, 0.8), P.line(3.5, 10, 16.5, 10, 0.8), P.line(3.5, 13.2, 16.5, 13.2, 0.8),
+  ),
+  // busca: lupa (já era contorno)
+  busca: any(P.ring(8.4, 8.4, 5, 1.6), P.line(12, 12, 17, 17, 1.8)),
+  // conversa: balão vazado + rabinho + uma linha de texto
+  chat: any(
+    P.frame(2.5, 4, 15, 9, 1.2),
+    P.line(6, 13, 9, 13, 1.1), P.line(9, 13, 6.5, 17, 1.1), P.line(6.5, 17, 6, 13, 1.1),
+    P.line(4.8, 7.5, 15.2, 7.5, 0.8), P.line(4.8, 10, 12.5, 10, 0.8),
+  ),
+};
+export const POINT_SHAPES = Object.keys(SHAPES);
+
+function sample(shape) {
+  const f = SHAPES[shape];
+  if (!f) throw new Error(`points: forma desconhecida "${shape}" (vale: ${POINT_SHAPES.join(", ")})`);
+  // passo quarto de ponto: areia fina (milhares de grãos), não bolinhas de macarrão
+  const pts = [];
+  for (let y = 0; y < H; y += 0.25) for (let x = 0; x < W; x += 0.25) if (f(x + 0.125, y + 0.125)) pts.push({ x: x + 0.125, y: y + 0.125 });
+  return pts;
+}
+
+// ordena pelo ângulo em torno do centroide: pontos vizinhos viajam juntos no morph
+function order(pts) {
+  const cx = pts.reduce((a, p) => a + p.x, 0) / pts.length, cy = pts.reduce((a, p) => a + p.y, 0) / pts.length;
+  return [...pts].sort((a, b) => Math.atan2(a.y - cy, a.x - cx) - Math.atan2(b.y - cy, b.x - cx));
+}
+
+export function pointsSVG(spec, { id = "pts" } = {}) {
+  const single = typeof spec === "string" ? spec : spec.de;
+  const target = typeof spec === "string" ? null : spec.para;
+  const A = order(sample(single));
+  const B = target ? order(sample(target)) : null;
+  // equaliza: a menor repete os próprios pontos até empatar (o morph só translada)
+  const N = Math.max(A.length, B ? B.length : 0);
+  const pad = (v) => Array.from({ length: N }, (_, i) => v[i % v.length]);
+  const a = pad(A), b = B ? pad(B) : null;
+  const dots = a.map((p, i) => {
+    // grão de areia: miúdo, opacidade variada; um em cada nove é joia (o magenta da foto)
+    const op = (0.5 + (((i * 2654435761) % 50) / 100)).toFixed(2);
+    const jewel = i % 9 === 8 ? ` class="pts-dot pts-jewel"` : ` class="pts-dot"`;
+    return `<circle${jewel} cx="${p.x.toFixed(2)}" cy="${p.y.toFixed(2)}" r="0.18" fill-opacity="${op}"/>`;
+  }).join("");
+  const model = b ? `<script class="pts-model" type="application/json">${JSON.stringify({ a, b }).replace(/</g, "\\u003c")}</script>` : "";
+  const label = typeof spec === "object" && (spec.legenda || spec.legendaPara)
+    ? `<div class="pts-legend f-label" data-legenda-a="${escAttr(spec.legenda || "")}" data-legenda-b="${escAttr(spec.legendaPara || spec.legenda || "")}" aria-live="polite">${escAttr(spec.legenda || "")}</div>`
+    : "";
+  const wrap = b ? ` data-points-morph="${id}" role="button" tabindex="0" aria-label="Transformar a figura (clique)"` : "";
+  return `<div class="fig fig-points pts"${wrap}><svg class="pts-svg" viewBox="0 0 ${W} ${H}" role="img" aria-label="Figura de pontos: ${escAttr(String(target ? `${single} virando ${target}` : single))}">${dots}</svg>${model}${label}</div>`;
+}
+
+const escAttr = (s) => String(s ?? "").replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;");

package/src/figures/qr.js

@@ -0,0 +1,29 @@
+// QR code como SVG (um único path, nítido em qualquer tamanho e no PowerPoint).
+//   { qr: "https://linkedin.com/in/…", size: 360, label: "LinkedIn", color: "#111", bg: "#fff" }
+// O QR sempre sai escuro sobre claro, com margem ("quiet zone"): é o que os celulares leem melhor,
+// inclusive quando o slide tem tom escuro.
+import qrcode from "qrcode-generator";
+
+export function qrSVG(data, { ec = "M", ink = "#111", paper = "#fff", margin = 2 } = {}) {
+  const text = String(data ?? "").trim();
+  if (!text) throw new Error("qr: informe o texto ou link do QR code (ex.: qr: https://linkedin.com/in/voce)");
+  const q = qrcode(0, ec);
+  q.addData(text, "Byte");
+  q.make();
+  const n = q.getModuleCount();
+  const size = n + margin * 2;
+  let d = "";
+  for (let r = 0; r < n; r++) {
+    for (let c = 0; c < n; c++) {
+      if (!q.isDark(r, c)) continue;
+      let run = 1; // junta módulos escuros vizinhos da mesma linha num retângulo só (SVG menor)
+      while (c + run < n && q.isDark(r, c + run)) run++;
+      d += `M${c + margin} ${r + margin}h${run}v1h-${run}z`;
+      c += run - 1;
+    }
+  }
+  return `<svg class="qr-svg" viewBox="0 0 ${size} ${size}" shape-rendering="crispEdges" role="img" aria-label="QR code: ${escAttr(text)}">`
+    + `<rect width="${size}" height="${size}" fill="${paper}"/><path d="${d}" fill="${ink}"/></svg>`;
+}
+
+const escAttr = (s) => s.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;");

package/src/figures/ufmap.js

@@ -0,0 +1,48 @@
+// Mapa do Brasil por UF em grade (cartograma de ladrilhos): cada estado é um quadrado na posição aproximada dele.
+// Sem geodados de fora (nada pede coisa à internet) e legível em slide: a cor diz o valor, o rótulo diz a UF.
+import { esc } from "../markup.js";
+
+// [coluna, linha] de cada UF, do norte ao sul, do oeste ao leste
+export const UF_GRID = {
+  RR: [1, 0], AP: [3, 0],
+  AM: [1, 1], PA: [2, 1], MA: [3, 1], CE: [4, 1], RN: [5, 1],
+  AC: [0, 2], RO: [1, 2], TO: [2, 2], PI: [3, 2], PE: [4, 2], PB: [5, 2],
+  MT: [1, 3], GO: [2, 3], BA: [3, 3], SE: [4, 3], AL: [5, 3],
+  MS: [1, 4], DF: [2, 4], MG: [3, 4], ES: [4, 4],
+  PR: [1, 5], SP: [2, 5], RJ: [3, 5],
+  SC: [1, 6],
+  RS: [1, 7],
+};
+
+const fmt = (v) => (Number.isFinite(v) ? v.toLocaleString("pt-BR", { maximumFractionDigits: 1 }) : "");
+
+// o: { ufmap: { SP: 120, RJ: 80, … }, suffix, prefix, highlight: [SP], legend: "texto", showValues }
+export function ufmap(o, warnings) {
+  const raw = o.ufmap && typeof o.ufmap === "object" ? o.ufmap : {};
+  const vals = {};
+  for (const [k, v] of Object.entries(raw)) {
+    const uf = String(k).trim().toUpperCase();
+    if (!UF_GRID[uf]) { warnings?.push(`ufmap: "${k}" não é uma UF (use a sigla: SP, RJ, MG…)`); continue; }
+    const n = typeof v === "number" ? v : parseFloat(String(v).replace(/\./g, "").replace(",", "."));
+    if (Number.isFinite(n)) vals[uf] = n;
+  }
+  const nums = Object.values(vals);
+  const min = nums.length ? Math.min(...nums) : 0, max = nums.length ? Math.max(...nums) : 1;
+  const hl = new Set([].concat(o.highlight ?? []).map((x) => String(x).toUpperCase()));
+  // mapa pequeno (quadro estreito): só as siglas, os valores ficam ilegíveis
+  const S = 100, G = 8, showVal = o.showValues ?? !(o.cw && o.cw < 420);
+  const cells = Object.entries(UF_GRID).map(([uf, [c, r]]) => {
+    const x = c * (S + G), y = r * (S + G), has = uf in vals;
+    // escala de 18% a 100% da cor de destaque: o menor valor ainda aparece
+    const k = has ? (max === min ? 100 : Math.round(18 + ((vals[uf] - min) / (max - min)) * 82)) : 0;
+    const fill = has ? `color-mix(in srgb,var(--em) ${k}%,var(--surface))` : "color-mix(in srgb,var(--fg) 7%,var(--surface))";
+    const ink = has && k > 55 ? "var(--bg)" : "var(--fg)";
+    const val = has && showVal ? `<text x="${x + S / 2}" y="${y + 74}" text-anchor="middle" font-size="22" style="fill:${ink}" class="uf-v f-body">${esc(`${o.prefix || ""}${fmt(vals[uf])}${o.suffix || ""}`)}</text>` : "";
+    return `<g class="uf-cell${has ? "" : " uf-empty"}${hl.has(uf) ? " uf-hl" : ""}" data-uf="${uf}">
+      <rect x="${x}" y="${y}" width="${S}" height="${S}" rx="12" style="fill:${fill}${hl.has(uf) ? ";stroke:var(--fg);stroke-width:6" : ""}"/>
+      <text x="${x + S / 2}" y="${y + (val ? 44 : 60)}" text-anchor="middle" font-size="30" font-weight="700" style="fill:${ink}" class="uf-n f-heading">${uf}</text>${val}</g>`;
+  });
+  const W = 6 * (S + G) - G, H = 8 * (S + G) - G;
+  const legend = nums.length ? `<div class="uf-legend f-label"><span>${esc(`${o.prefix || ""}${fmt(min)}${o.suffix || ""}`)}</span><i></i><span>${esc(`${o.prefix || ""}${fmt(max)}${o.suffix || ""}`)}</span>${o.legend ? `<b>${esc(o.legend)}</b>` : ""}</div>` : "";
+  return `<div class="ufmap"><svg class="ufmap-svg" viewBox="0 0 ${W} ${H}" preserveAspectRatio="xMidYMid meet" role="img" aria-label="Mapa do Brasil por UF">${cells.join("")}</svg>${legend}</div>`;
+}

package/src/fiscal/autofix.js

@@ -0,0 +1,377 @@
+// sagadeck · Fiscal Inteligente e Motor de Auto-Correção
+// Detecta e repara automaticamente:
+// 1. Sobreposição de elementos (bounding box collision)
+// 2. Transgressão de margens seguras (safe area overflow)
+// 3. Estouro de texto e fontes fora dos limites (horizontal/vertical overflow)
+// 4. Elementos fora das coordenadas do slide (0..1920, 0..1080)
+// 5. Excesso de texto anti-sono (move narrativa secundária para notes:)
+import { wordLimit } from "../purpose.js";
+import { normalizeSpec } from "./normalize.js";
+
+export function parseIssueText(text) {
+  if (!text) return { target: "", detail: "" };
+  const parts = text.split("⟂").map((s) => s.trim());
+  return {
+    elements: parts,
+    target: parts[0] || text,
+    detail: parts[1] || "",
+  };
+}
+
+export function optimizeTriggerTitle(s) {
+  if (!s.title || typeof s.title !== "string") return null;
+  let title = s.title.trim();
+  const original = title;
+  let modified = false;
+  let newKicker = s.kicker;
+
+  // 1. Separador tipo "Contexto: Frase de Impacto"
+  const sepMatch = title.match(/^([^:–—]+)[:–—-]\s*(.+)$/);
+  if (sepMatch && !newKicker && sepMatch[1].trim().split(/\s+/).length <= 4) {
+    newKicker = sepMatch[1].trim();
+    title = sepMatch[2].trim();
+    title = title.charAt(0).toUpperCase() + title.slice(1);
+    modified = true;
+  }
+
+  // 2. Limpar preâmbulos prolixos comuns de IA (ex: "A implementação de...", "Um estudo sobre...", etc.)
+  const preambles = [
+    "A implementação de", "O processo de", "Um estudo detalhado sobre", "Um estudo sobre",
+    "Uma visão geral sobre", "Como funciona a", "Como fazer para", "Estratégias eficazes para",
+    "Estratégias para", "Principais desafios na", "Principais desafios em"
+  ];
+  for (const p of preambles) {
+    const re = new RegExp(`^${p}\\s+`, "i");
+    if (re.test(title)) {
+      title = title.replace(re, "").trim();
+      title = title.charAt(0).toUpperCase() + title.slice(1);
+      modified = true;
+      break;
+    }
+  }
+
+  // (Removidas: cortar o título nas 5 primeiras palavras e pintar uma palavra com ==marca-texto==.
+  //  Cortavam frases no meio e deixavam todos os títulos com o mesmo destaque. Ênfase é decisão de
+  //  quem escreve; título longo é tratado pelo ajuste de tamanho (fit).)
+
+  if (modified) {
+    // o título original fica registrado em `auto` (antes), sem poluir as anotações
+    s.title = title;
+    if (newKicker && !s.kicker) s.kicker = newKicker;
+    return `Título longo/spoiler encurtado para título-gatilho ("${title}"); tese completa preservada nas notas.`;
+  }
+  return null;
+}
+
+// Toda mudança da auto-correção fica registrada no próprio slide, em `auto`:
+//   auto: [{ campo, antes, motivo, quando }]
+// Assim o Studio mostra (e desfaz) o que foi automático, e a IA sabe que não foi ela nem o usuário.
+export function autofixSlide(slide, spec = {}, issues = []) {
+  const res = autofixSlideCore(slide, spec, issues);
+  if (!res.modified) return res;
+  res.slide.auto = recordAuto(slide, res.slide, res.actions);
+  return res;
+}
+
+const AUTO_SKIP = new Set(["auto"]);
+export function recordAuto(before, after, actions, por = "auto-correção") {
+  const log = Array.isArray(before.auto) ? before.auto.map((e) => ({ ...e })) : [];
+  const keys = new Set([...Object.keys(before), ...Object.keys(after)]);
+  const motivo = actions.join("; ");
+  for (const k of keys) {
+    if (AUTO_SKIP.has(k) || k.startsWith("_")) continue;
+    if (JSON.stringify(before[k]) === JSON.stringify(after[k])) continue;
+    const prev = log.find((e) => e.campo === k);
+    if (prev) { prev.motivo = `${prev.motivo}; ${motivo}`; continue; } // mantém o valor original mais antigo
+    log.push({ campo: k, antes: before[k] === undefined ? null : before[k], motivo, por, quando: new Date().toISOString().slice(0, 16).replace("T", " ") });
+  }
+  return log;
+}
+
+function autofixSlideCore(slide, spec = {}, issues = []) {
+  const s = JSON.parse(JSON.stringify(slide));
+  const actions = [];
+  const layout = s.layout || "blocks";
+
+  // 1. Se recebemos lista de problemas do fiscal / DOM
+  if (Array.isArray(issues) && issues.length > 0) {
+    for (const issue of issues) {
+      const kind = issue.kind;
+
+      // --- Caso: Sobreposição ---
+      if (kind === "sobreposicao") {
+        if (layout === "canvas" && Array.isArray(s.elements)) {
+          // No canvas, calcular caixas e empurrar elemento de baixo
+          let adjusted = false;
+          for (let i = 0; i < s.elements.length; i++) {
+            for (let j = i + 1; j < s.elements.length; j++) {
+              const A = s.elements[i];
+              const B = s.elements[j];
+              const ax = A.x ?? 0, ay = A.y ?? 0, aw = A.w ?? 400, ah = A.h ?? 150;
+              const bx = B.x ?? 0, by = B.y ?? 0, bw = B.w ?? 400, bh = B.h ?? 150;
+              const ix = Math.min(ax + aw, bx + bw) - Math.max(ax, bx);
+              const iy = Math.min(ay + ah, by + bh) - Math.max(ay, by);
+              if (ix > 8 && iy > 8) {
+                // Sobreposição detectada: empurrar B para baixo de A
+                B.y = ay + ah + 24;
+                // Garantir que não saia da margem inferior (976px)
+                if (B.y + bh > 976) {
+                  B.y = 976 - bh;
+                  // Se ainda colidir, alinhar horizontalmente se couber
+                  if (ax + aw + bw + 24 <= 1800) {
+                    B.x = ax + aw + 24;
+                    B.y = ay;
+                  }
+                }
+                adjusted = true;
+                actions.push(`Reposicionado elemento no canvas para eliminar sobreposição com "${issue.text}"`);
+              }
+            }
+          }
+        } else {
+          // Layouts padrão: reduzir titleSize ou diminuir altura de blocos
+          const curSize = s.titleSize || (layout === "cover" ? 140 : layout === "statement" ? 110 : 92);
+          const newSize = Math.max(48, Math.round(curSize * 0.78));
+          if (newSize !== curSize) {
+            s.titleSize = newSize;
+            actions.push(`Reduzido titleSize de ${curSize}px para ${newSize}px para eliminar sobreposição`);
+          }
+          if (s.fit !== false) s.fit = true;
+        }
+      }
+
+      // --- Caso: Passa da Margem Inferior (Overflow vertical da safe area) ---
+      if (kind === "passa-da-margem-inferior") {
+        const pxOverflow = issue.px || 30;
+
+        // Se o título estiver grande, reduzi-lo
+        const curSize = s.titleSize || (layout === "cover" ? 140 : layout === "section" ? 150 : 92);
+        if (curSize > 56) {
+          const newSize = Math.max(48, Math.round(curSize * 0.75));
+          s.titleSize = newSize;
+          actions.push(`Ajustado tamanho do título (${curSize}px -> ${newSize}px) para recolher o conteúdo à margem segura (+${pxOverflow}px)`);
+        }
+
+        // Se layout for cards e estiver em 1 ou 2 colunas com mais de 3 cards, expandir para 3 ou 4 colunas
+        if (layout === "cards" && Array.isArray(s.items) && s.items.length >= 3) {
+          const curCols = s.cols || (s.items.length >= 4 ? 2 : s.items.length);
+          if (curCols < 4 && s.items.length >= 4) {
+            s.cols = Math.min(4, s.items.length);
+            actions.push(`Expandida grade de cards para ${s.cols} colunas para evitar estouro da margem inferior`);
+          }
+        }
+
+        // Se layout for list e tiver muitos itens
+        if (layout === "list" && Array.isArray(s.items) && s.items.length > 5) {
+          const removed = s.items.slice(5);
+          s.items = s.items.slice(0, 5);
+          s.notes = (s.notes ? s.notes + "\n\n" : "") + "> Itens adicionais para fala:\n" + removed.map((r) => "- " + (typeof r === "object" ? r.text || r.title : r)).join("\n");
+          actions.push(`Movidos ${removed.length} itens excedentes da lista para as notas do apresentador`);
+        }
+
+        // Se houver corpo/texto longo, compactar e mover narrativa para notas
+        if (typeof s.body === "string" && s.body.length > 160) {
+          const sentences = s.body.split(/(?<=[.?!])\s+/);
+          if (sentences.length > 1) {
+            const keep = sentences[0];
+            const toNotes = sentences.slice(1).join(" ");
+            s.body = keep;
+            s.notes = (s.notes ? s.notes + "\n\n" : "") + `> Fala complementar: ${toNotes}`;
+            actions.push(`Compactado texto do corpo e transferida narrativa detalhada para notas do apresentador`);
+          }
+        }
+      }
+
+      // --- Caso: Estouro Horizontal / Texto Saindo da Margem ---
+      if (kind === "estouro-horizontal") {
+        const curSize = s.titleSize || s.size || 92;
+        const newSize = Math.max(44, Math.round(curSize * 0.76));
+        s.titleSize = newSize;
+        s.fit = true;
+        actions.push(`Reduzida fonte (${curSize}px -> ${newSize}px) e ativado ajuste automático (fit: true) para evitar estouro horizontal`);
+      }
+
+      // --- Caso: Fora do Slide (coordenadas menores que 0 ou maiores que 1920x1080) ---
+      if (kind === "fora-do-slide") {
+        if (layout === "canvas" && Array.isArray(s.elements)) {
+          s.elements.forEach((el, idx) => {
+            const w = el.w || 300;
+            const h = el.h || 120;
+            const origX = el.x ?? 0;
+            const origY = el.y ?? 0;
+            // Safe zone: left 120, right 1800, top 92, bottom 976
+            const clampedX = Math.max(120, Math.min(origX, 1800 - w));
+            const clampedY = Math.max(92, Math.min(origY, 976 - h));
+            if (clampedX !== origX || clampedY !== origY) {
+              el.x = clampedX;
+              el.y = clampedY;
+              actions.push(`Elemento #${idx + 1} no canvas reajustado para dentro da área segura ([${clampedX}, ${clampedY}])`);
+            }
+          });
+        }
+      }
+
+      // --- Caso: Baixo Contraste ---
+      if (kind === "baixo-contraste") {
+        // Alternar tom para garantir legibilidade máxima
+        const prevTone = s.tone || "light";
+        s.tone = prevTone === "light" ? "dark" : "light";
+        delete s.fg;
+        delete s.bg;
+        actions.push(`Ajustado tom do slide de "${prevTone}" para "${s.tone}" para atender ao contraste mínimo WCAG`);
+      }
+    }
+  }
+
+  // 2. Verificações heurísticas universais (Anti-sono, Títulos-Gatilho e Geometria Segura)
+
+  // Otimização de Título-Gatilho (Anti-spoiler / Memória rápida)
+  const titleAction = optimizeTriggerTitle(s);
+  if (titleAction) actions.push(titleAction);
+
+  // Regra Anti-sono Inteligente: excesso de palavras no slide
+  const words = countSlideWords(s);
+  const maxWords = wordLimit(s, spec); // material de consulta/aula: o texto explicativo fica no slide
+  if (words > maxWords) {
+    let fixedWords = false;
+
+    // Transbordo do corpo (body) para notas
+    if (s.body && typeof s.body === "string" && s.body.split(/\s+/).length > 15) {
+      const parts = s.body.split(/(?<=[.?!])\s+/);
+      if (parts.length > 1) {
+        s.body = parts[0];
+        const extra = parts.slice(1).join(" ");
+        s.notes = (s.notes ? s.notes + "\n\n" : "") + `> Fala complementar do slide:\n${extra}`;
+        fixedWords = true;
+      }
+    }
+
+    // Transbordo de cartões (cards com texto longo)
+    if (layout === "cards" && Array.isArray(s.items)) {
+      s.items.forEach((item, idx) => {
+        if (typeof item === "object" && item.text && item.text.split(/\s+/).length > 12) {
+          const parts = item.text.split(/(?<=[.?!])\s+/);
+          if (parts.length > 1) {
+            item.text = parts[0];
+            const extra = parts.slice(1).join(" ");
+            s.notes = (s.notes ? s.notes + "\n\n" : "") + `> Card #${idx + 1} (${item.title || "Item"}):\n${extra}`;
+            fixedWords = true;
+          }
+        }
+      });
+    }
+
+    // Transbordo de bullets excedentes
+    if (Array.isArray(s.bullets) && s.bullets.length > 4) {
+      const removed = s.bullets.slice(4);
+      s.bullets = s.bullets.slice(0, 4);
+      s.notes = (s.notes ? s.notes + "\n\n" : "") + `> Tópicos adicionais para o apresentador:\n` + removed.map((b) => `- ${b}`).join("\n");
+      fixedWords = true;
+    }
+
+    if (fixedWords) {
+      actions.push(`Slide anti-sono: reduzido de ${words} para ${countSlideWords(s)} palavras; excedente transferido para as notas`);
+    }
+  }
+
+  // Verificação de Título Excessivamente Longo sem titleSize definido
+  if (s.title && typeof s.title === "string" && s.title.length > 55 && !s.titleSize) {
+    s.titleSize = layout === "cover" ? 96 : 68;
+    actions.push(`Título longo detectado: configurado titleSize=${s.titleSize}px para evitar quebra indesejada`);
+  }
+
+  // Verificação de Colunas de Cards (se 4 ou mais cards, garantir pelo menos 3 colunas)
+  if (layout === "cards" && Array.isArray(s.items) && s.items.length >= 4 && (!s.cols || s.cols < 3)) {
+    s.cols = Math.min(4, s.items.length);
+    actions.push(`Reorganizada distribuição de cards em ${s.cols} colunas`);
+  }
+
+  // Verificação em Canvas livre: garantir que nenhum elemento colida ou fique fora das margens
+  if (layout === "canvas" && Array.isArray(s.elements)) {
+    // Ordena verticalmente e distribui se colidir
+    s.elements.forEach((el) => {
+      const w = el.w || 320;
+      const h = el.h || 120;
+      if (el.x == null) el.x = 120;
+      if (el.y == null) el.y = 120;
+      el.x = Math.max(120, Math.min(el.x, 1800 - w));
+      el.y = Math.max(92, Math.min(el.y, 976 - h));
+    });
+
+    for (let i = 0; i < s.elements.length; i++) {
+      for (let j = i + 1; j < s.elements.length; j++) {
+        const A = s.elements[i];
+        const B = s.elements[j];
+        const aw = A.w || 320, ah = A.h || 120;
+        const bw = B.w || 320, bh = B.h || 120;
+        const ix = Math.min(A.x + aw, B.x + bw) - Math.max(A.x, B.x);
+        const iy = Math.min(A.y + ah, B.y + bh) - Math.max(A.y, B.y);
+        if (ix > 8 && iy > 8) {
+          if (A.y + ah + bh + 24 <= 976) {
+            B.y = A.y + ah + 24;
+            actions.push(`Resolvida sobreposição entre elementos #${i + 1} e #${j + 1} no canvas`);
+          } else if (A.x + aw + bw + 24 <= 1800) {
+            B.x = A.x + aw + 24;
+            B.y = A.y;
+            actions.push(`Alinhado elemento #${j + 1} horizontalmente ao lado do elemento #${i + 1}`);
+          }
+        }
+      }
+    }
+  }
+
+  return { slide: s, actions, modified: actions.length > 0 };
+}
+
+export function autofixDeck(spec, issuesReport = []) {
+  const newSpec = normalizeSpec(spec);
+  const issuesBySlide = new Map();
+
+  if (Array.isArray(issuesReport)) {
+    for (const item of issuesReport) {
+      if (item && item.slide && Array.isArray(item.issues)) {
+        issuesBySlide.set(item.slide - 1, item.issues);
+      }
+    }
+  }
+
+  const allActions = [];
+  let totalFixed = 0;
+
+  newSpec.slides = newSpec.slides.map((rawSlide, index) => {
+    const slideIssues = issuesBySlide.get(index) || [];
+    const { slide: fixedSlide, actions, modified } = autofixSlide(rawSlide, newSpec, slideIssues);
+    if (modified) {
+      totalFixed++;
+      allActions.push({
+        slide: index + 1,
+        layout: fixedSlide.layout || "auto",
+        actions,
+      });
+    }
+    return fixedSlide;
+  });
+
+  return {
+    spec: newSpec,
+    modifiedSlidesCount: totalFixed,
+    actions: allActions,
+    clean: true,
+  };
+}
+
+function countSlideWords(s) {
+  const txt = [];
+  const walk = (v, k) => {
+    if (k === "notes" || k === "source" || k === "id" || k === "layout" || k === "tone") return;
+    if (typeof v === "string") {
+      if (!/^(\.|https?:|#?[0-9a-f]{6}$)/i.test(v)) txt.push(v);
+    } else if (Array.isArray(v)) {
+      v.forEach((x) => walk(x));
+    } else if (v && typeof v === "object" && !v.svg && !v.chart && !v.html) {
+      for (const [kk, vv] of Object.entries(v)) walk(vv, kk);
+    }
+  };
+  walk(s);
+  return txt.join(" ").split(/\s+/).filter((w) => w.length > 1).length;
+}

package/src/fiscal/normalize.js

@@ -0,0 +1,115 @@
+// sagadeck · Normalizador Flexível de Schema (Anti-Alucinação para IAs)
+// Tolerante a variações sintáticas, termos em português e aliases comuns que
+// modelos de IA econômicos (Haiku, Flash, GPT-4o-mini, DeepSeek) possam gerar.
+
+const COLOR_MAP = {
+  azul: "0066FF",
+  verde: "10B981",
+  amarelo: "F59E0B",
+  vermelho: "EF4444",
+  roxo: "8B5CF6",
+  rosa: "EC4899",
+  cinza: "86868B",
+  preto: "1D1D1F",
+  branco: "FFFFFF",
+};
+
+export function normalizeSpec(rawSpec) {
+  if (!rawSpec || typeof rawSpec !== "object") return rawSpec;
+  const spec = JSON.parse(JSON.stringify(rawSpec));
+
+  // 1. Normalização no nível da raiz
+  if (spec.tema && !spec.theme) {
+    spec.theme = spec.tema;
+    delete spec.tema;
+  }
+  if (spec.titulo && !spec.title) {
+    spec.title = spec.titulo;
+    delete spec.titulo;
+  }
+  if (spec.duracao && !spec.duration) {
+    spec.duration = spec.duracao;
+    delete spec.duracao;
+  }
+  if (!Array.isArray(spec.slides)) {
+    if (Array.isArray(spec.slide)) spec.slides = spec.slide;
+    else if (spec.slides && typeof spec.slides === "object") spec.slides = Object.values(spec.slides);
+    else spec.slides = [];
+  }
+
+  // 2. Normalização slide a slide
+  spec.slides = spec.slides.map((s) => {
+    if (!s || typeof s !== "object") return { layout: "statement", text: String(s) };
+
+    // Termos em português para campos básicos
+    if (s.titulo && !s.title) { s.title = s.titulo; delete s.titulo; }
+    if (s.subtitulo && !s.subtitle) { s.subtitle = s.subtitulo; delete s.subtitulo; }
+    if (s.notas && !s.notes) { s.notes = s.notas; delete s.notas; }
+    if (s.fonte && !s.source) { s.source = s.fonte; delete s.fonte; }
+    if (s.tempo && !s.time) { s.time = s.tempo; delete s.tempo; }
+    if (s.tom && !s.tone) { s.tone = s.tom; delete s.tom; }
+
+    // Aliases para layout stats (KPIs)
+    if (s.kpis || s.metricas) {
+      s.stats = s.stats || s.kpis || s.metricas;
+      delete s.kpis;
+      delete s.metricas;
+    }
+    if (Array.isArray(s.stats)) {
+      s.stats = s.stats.map((st) => {
+        if (typeof st !== "object") return { value: String(st) };
+        if (st.valor && !st.value) { st.value = st.valor; delete st.valor; }
+        if (st.rotulo && !st.label) { st.label = st.rotulo; delete st.rotulo; }
+        if (st.tendencia && !st.trend) { st.trend = st.tendencia; delete st.tendencia; }
+        if (st.icone && !st.icon) { st.icon = st.icone; delete st.icone; }
+        return st;
+      });
+    }
+
+    // Aliases para layout steps (Processo)
+    if (s.process || s.fluxo || s.passos || s.etapas) {
+      s.steps = s.steps || s.process || s.fluxo || s.passos || s.etapas;
+      delete s.process;
+      delete s.fluxo;
+      delete s.passos;
+      delete s.etapas;
+    }
+    if (Array.isArray(s.steps)) {
+      s.steps = s.steps.map((st, i) => {
+        if (typeof st !== "object") return { stepNum: i + 1, title: String(st) };
+        if (st.passo && !st.title) { st.title = st.passo; delete st.passo; }
+        if (st.etapa && !st.title) { st.title = st.etapa; delete st.etapa; }
+        if (st.descricao && !st.text) { st.text = st.descricao; delete st.descricao; }
+        if (st.texto && !st.text) { st.text = st.texto; delete st.texto; }
+        if (st.icone && !st.icon) { st.icon = st.icone; delete st.icone; }
+        if (st.step && !st.stepNum && typeof st.step === "number") st.stepNum = st.step;
+        return st;
+      });
+    }
+
+    // Aliases em cards
+    if (Array.isArray(s.items)) {
+      s.items = s.items.map((it) => {
+        if (typeof it !== "object") return it;
+        if (it.titulo && !it.title) { it.title = it.titulo; delete it.titulo; }
+        if (it.texto && !it.text) { it.text = it.texto; delete it.texto; }
+        if (it.icone && !it.icon) { it.icon = it.icone; delete it.icone; }
+        if (it.progresso != null && it.progress == null) { it.progress = it.progresso; delete it.progresso; }
+        if (it.avaliacao != null && it.rating == null) { it.rating = it.avaliacao; delete it.avaliacao; }
+        return it;
+      });
+    }
+
+    // Cores comuns em português
+    if (s.color && COLOR_MAP[s.color.toLowerCase()]) {
+      s.color = COLOR_MAP[s.color.toLowerCase()];
+    }
+    if (s.bg && COLOR_MAP[s.bg.toLowerCase()]) {
+      s.bg = COLOR_MAP[s.bg.toLowerCase()];
+    }
+
+    return s;
+  });
+
+  return spec;
+}