sagadeck 1.8.0 → 1.10.0

package/src/import/office.js

@@ -8,6 +8,7 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { spawnSync } from "node:child_process";
+import { removeRetry } from "../fs-retry.js";
 
 const isWin = process.platform === "win32";
 const tmpDir = () => fs.mkdtempSync(path.join(os.tmpdir(), "sagadeck-import-"));
@@ -20,7 +21,7 @@ function powershell(script, args, timeout = 600000) {
     fs.writeFileSync(json, JSON.stringify(args), "utf8");
     const r = spawnSync("powershell.exe", ["-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-File", ps1, json], { encoding: "utf8", timeout, windowsHide: true });
     return { ok: r.status === 0, out: (r.stdout || "").trim(), err: (r.stderr || "").trim() };
-  } finally { fs.rmSync(dir, { recursive: true, force: true }); }
+  } finally { removeRetry(dir); }
 }
 
 let officeCache = null;
@@ -75,7 +76,7 @@ foreach ($p in $a.pairs) {
       spawnSync(lo, ["--headless", "--convert-to", "png", "--outdir", out, p.src], { timeout: 120000 });
       const f = fs.readdirSync(out).find((x) => x.endsWith(".png"));
       if (f) fs.copyFileSync(path.join(out, f), p.dst);
-      fs.rmSync(out, { recursive: true, force: true });
+      removeRetry(out);
     }
     return pairs.filter((p) => fs.existsSync(p.dst)).map((p) => p.dst);
   }
@@ -108,7 +109,7 @@ try {
   try {
     const r = powershell(script, { file: copy, out: outDir, width });
     if (!r.ok) return [];
-  } finally { fs.rmSync(work, { recursive: true, force: true }); }
+  } finally { removeRetry(work); }
   return fs.readdirSync(outDir).filter((f) => /^slide-\d+\.png$/.test(f)).sort().map((f) => path.join(outDir, f));
 }
 
@@ -119,5 +120,5 @@ export function libreOfficeToPdf(file) {
   const out = tmpDir();
   spawnSync(lo, ["--headless", "--convert-to", "pdf", "--outdir", out, file], { timeout: 300000 });
   const f = fs.readdirSync(out).find((x) => x.endsWith(".pdf"));
-  return f ? { pdf: path.join(out, f), cleanup: () => fs.rmSync(out, { recursive: true, force: true }) } : null;
+  return f ? { pdf: path.join(out, f), cleanup: () => removeRetry(out) } : null;
 }

package/src/layouts.js

@@ -12,7 +12,7 @@ import { adaptiveHTML } from "./adaptive-layouts.js";
 import { iconSVG, listIcons } from "./figures/icons.js";
 let iconNames = null;
 const diagramIconNames = () => (iconNames ||= new Set(listIcons()));
-import { el, text, figureHTML, imageSize, attrs, SIZES, list, cards, stats, steps, poll, timer, counter, code } from "./elements.js";
+import { el, text, figureHTML, imageSize, attrs, SIZES, list, cards, stats, steps, poll, timer, counter, code, popHTML } from "./elements.js";
 import { displayCodeLanguage, resolveCodeLanguage } from "./code-language.js";
 import { mathHTML, plotHTML } from "./science.js";
 import { infographicHTML, itemColors } from "./infographic.js";
@@ -40,44 +40,11 @@ const codeEditor = (s, { source, highlight = s.highlight, footer = "CÓDIGO · L
 };
 // As cenas de aula deixam todo o conteúdo no HTML: funcionam offline e têm resumo estático.
 const lessonSteps = (items, fallback) => Array.isArray(items) && items.length ? items.map((p) => typeof p === "string" ? { title: p } : (p || {})) : [fallback];
-const kineticPhrases = (value) => {
-  const words = String(value || "").match(/==[^=]+==|\*\*.*?\*\*|\*[^*]+\*|~~.*?~~|`[^`]+`|\[[^\]]+\]\([^)]+\)|\S+/g) || [];
-  const connectors = new Set(["a", "as", "de", "do", "da", "dos", "das", "e", "em", "no", "na", "nos", "nas", "para", "por", "com", "o", "os"]);
-  const phrases = [];
-  while (words.length) {
-    let take = Math.ceil(words.length / Math.ceil(words.length / 4));
-    const last = words[take - 1]?.replace(/^[^A-Za-zÀ-ÿ]+|[^A-Za-zÀ-ÿ]+$/g, "").toLowerCase();
-    if (take > 1 && connectors.has(last)) take--;
-    phrases.push(words.splice(0, take).join(" "));
-  }
-  return phrases;
-};
 const lessonControls = (items) => `<nav class="lesson-controls" aria-label="Etapas da explicação"><button type="button" data-lesson-prev aria-label="Etapa anterior" disabled>${iconSVG("arrow-left", { size: 26, stroke: 2 })}</button><div class="lesson-dots">${items.map((p, i) => `<button type="button" data-lesson-go="${i}" aria-label="Etapa ${i + 1}: ${esc(p.title || "Explicação")}" aria-current="${i === 0 ? "step" : "false"}">${String(i + 1).padStart(2, "0")}</button>`).join("")}</div><button type="button" data-lesson-next aria-label="Próxima etapa" ${items.length === 1 ? "disabled" : ""}>${iconSVG("arrow-right", { size: 26, stroke: 2 })}</button></nav>`;
 const lessonPanels = (items, output = false) => `<div class="lesson-panels" aria-live="polite" aria-atomic="true">${items.map((p, i) => `<article class="lesson-panel${i === 0 ? " active" : ""}" data-lesson-panel="${i}" data-highlight="${esc(JSON.stringify([].concat(p.highlight || []).filter(Number.isFinite)))}"><div class="lesson-counter f-label">${String(i + 1).padStart(2, "0")} / ${String(items.length).padStart(2, "0")}</div>${text(p.title || `Etapa ${i + 1}`, "h3", { class: "lesson-title", size: 48 })}${p.text ? text(p.text, "body", { class: "lesson-text", size: 32 }) : ""}${output && p.output != null ? `<div class="lesson-output"><div class="lesson-output-label f-label">Saída esperada · simulação</div><pre class="f-mono">${esc(p.output)}</pre></div>` : ""}</article>`).join("")}</div>`;
 const lessonSummary = (items) => `<div class="lesson-summary">${items.map((p, i) => `<article><div class="f-label lesson-summary-number">${String(i + 1).padStart(2, "0")}</div><div><strong class="f-heading">${md(p.title || `Etapa ${i + 1}`)}</strong>${p.text ? `<p class="f-body">${md(p.text)}</p>` : ""}${p.output != null ? `<pre class="f-mono">${esc(p.output)}</pre>` : ""}</div></article>`).join("")}</div>`;
 const percent = (value, fallback, min = 0, max = 100) => Number.isFinite(Number(value)) ? Math.max(min, Math.min(max, Number(value))) : fallback;
 
-// Texto no cenário: as composições. label = nome no formulário; size = tamanho padrão do título (titleSize vence);
-// props = cenografia extra (só texto e caixas; os desenhos são CSS em base.css, nada de símbolo unicode).
-const candles = () => Array.from({ length: 30 }, (_, i) => {
-  const y = 120 + Math.round(Math.sin(i * 0.55) * 90 + i * 11), h = 40 + ((i * 37) % 90), up = (i * 7) % 3 !== 0;
-  return `<i class="candle ${up ? 'up' : 'down'}" style="--x:${i * 64}px;--y:${y}px;--h:${h}px"></i>`;
-}).join('');
-export const SCENES = {
-  stage: { label: 'Palco e profundidade', size: 230, tone: 'dark' },
-  floor: { label: 'Chão em perspectiva', size: 230 },
-  signs: { label: 'Placas na cidade', size: 230, tone: 'dark' },
-  terminal: { label: 'Terminal hacker', size: 150, tone: 'dark', props: () => `<pre class="scene-code">${Array.from({ length: 34 }, (_, i) => `${(0x7f3a00 + i * 16).toString(16)}  ${Array.from({ length: 12 }, (_, j) => ((i * 31 + j * 17) % 256).toString(16).padStart(2, '0')).join(' ')}  ${['ssh saga@deck','sudo apresentar --ao-vivo','git push origin ideia','cat segredo.txt | grep plano','nmap -sV palco.local','tail -f plateia.log'][i % 6]}`).join('\n')}</pre><div class="scene-scan"></div>` },
-  cafe: { label: 'Lousa de café', size: 170, tone: 'dark', props: () => `<div class="scene-neon">aberto</div><ul class="scene-menu"><li><span>espresso</span><span>7</span></li><li><span>coado do dia</span><span>9</span></li><li><span>pão de queijo</span><span>6</span></li><li><span>ideia nova</span><span>grátis</span></li></ul>` },
-  travel: { label: 'Cartão de embarque', size: 140, props: () => `<div class="scene-pass"><div class="scene-pass-top">CARTÃO DE EMBARQUE</div><dl><div><dt>DE</dt><dd>GRU</dd></div><div><dt>PARA</dt><dd>LIS</dd></div><div><dt>VOO</dt><dd>SG 2026</dd></div><div><dt>PORTÃO</dt><dd>12</dd></div><div><dt>ASSENTO</dt><dd>7A</dd></div><div><dt>EMBARQUE</dt><dd>09:40</dd></div></dl><div class="scene-barcode"></div></div>` },
-  ticker: { label: 'Pregão financeiro', size: 190, tone: 'dark', props: () => `<div class="scene-tape"><span>IBOV 128.430 <b class="up">+1,24%</b></span><span>USD/BRL 5,02 <b class="down">-0,31%</b></span><span>SAGA3 42,10 <b class="up">+8,90%</b></span><span>IDEIA11 99,00 <b class="up">+12,5%</b></span><span>BTC 312.004 <b class="down">-2,05%</b></span><span>SELIC 10,50%</span><span>IBOV 128.430 <b class="up">+1,24%</b></span></div><div class="scene-candles">${candles()}</div>` },
-  marquee: { label: 'Letreiro de cinema', size: 150, tone: 'dark', props: () => `<div class="scene-curtain left"></div><div class="scene-curtain right"></div><div class="scene-ticket">SESSÃO 20H</div>` },
-  blueprint: { label: 'Planta técnica', size: 170, tone: 'accent', props: () => `<div class="scene-dim h"><span>1920</span></div><div class="scene-dim v"><span>1080</span></div><table class="scene-stamp"><tr><td>PROJETO</td><td>SAGADECK</td></tr><tr><td>FOLHA</td><td>01 / 13</td></tr><tr><td>ESCALA</td><td>1:1</td></tr><tr><td>REVISÃO</td><td>A</td></tr></table>` },
-  magazine: { label: 'Capa de revista', size: 210, props: () => `<div class="scene-masthead">SAGA</div><div class="scene-issue">EDIÇÃO 13 <i></i> SETEMBRO 2026 <i></i> R$ 24,90</div><ul class="scene-lines"><li><b>+10</b> ideias que mudam o jogo</li><li><b>Exclusivo</b> os bastidores do palco</li><li><b>Guia</b> como contar uma história</li></ul><div class="scene-barcode"></div>` },
-  orbit: { label: 'Órbita', size: 170, tone: 'dark', props: () => `<div class="scene-stars"></div><div class="scene-stars far"></div><div class="scene-hud"><span>LAT -23.55</span><span>LON -46.63</span><span>ALT 408 KM</span><span>V 7,66 KM/S</span></div>` },
-  synthwave: { label: 'Neon anos 80', size: 190, tone: 'dark', props: () => `<div class="scene-sun"></div><div class="scene-grid"></div><div class="scene-mountains"></div>` },
-  gallery: { label: 'Parede de galeria', size: 170, props: () => `<div class="scene-spot"></div><div class="scene-plaque"><b>Sem título</b><span>2026. Texto sobre parede.</span><span>Coleção particular</span></div><div class="scene-baseboard"></div>` },
-};
 
 // No blocks, "rótulo e depois o gráfico" é o título do gráfico, e dois ou mais gráficos seguidos ficam lado a lado:
 // empilhados, cada um ganhava 200 e poucos px de altura e, mantendo a proporção, saía estreito no meio do slide.
@@ -169,39 +136,119 @@ export const LAYOUTS = {
       ${s.text ? `<div class="df-rule e" style="--d:2;"></div>${text(s.text, "lead", { class: "df-text e", style: "--d:3;", step: s.build ? 2 : undefined })}` : ""}</div>${fig}</div>${src(s)}${add(s, ctx)}`;
   },
 
-  // Calendário (pedido: "um infográfico em forma de calendário dos próximos filmes"): um cartão por mês com evento, com
-  // o mini calendário do mês (os dias marcados na cor do evento) e a lista embaixo; o que não tem data vai no cartão
-  // "sem data". Datas: 2026-12-18, 18/12/2026, 2026-12 (só o mês) ou nada.
+  // Calendário (pedido: "um infográfico em forma de calendário dos próximos filmes"). Visões (`view`):
+  //  - meses: um cartão por mês com o mini calendário (os dias marcados na cor do evento) e a lista embaixo;
+  //  - mes: um mês grande, como calendário de parede, com os eventos escritos nos dias (muitos eventos num mês);
+  //  - semana: uma coluna por dia, com o horário (programação de um evento, semana de lançamento);
+  //  - lista: agenda compacta agrupada por mês, em colunas (muitos meses cheios).
+  // Sem `view`, escolhe sozinho: cabe nos cartões, meses; um mês só que não cabe, mes; vários meses cheios, lista
+  // (pedido de Narumi: muitos eventos no mesmo mês enchiam o cartão e passavam da altura do slide). `month` (2026-11)
+  // escolhe o mês da visão mes; `week` (uma data) a semana da visão semana. Datas: 2026-12-18, 18/12/2026, 2026-12
+  // (só o mês) ou nada; hora em `time` ("14:00") ou junto da data ("2026-12-18 14:00").
   calendar(s, ctx) {
     const MESES = ["jan", "fev", "mar", "abr", "mai", "jun", "jul", "ago", "set", "out", "nov", "dez"];
+    const MESES_LONGOS = ["janeiro", "fevereiro", "março", "abril", "maio", "junho", "julho", "agosto", "setembro", "outubro", "novembro", "dezembro"];
+    const DIAS = ["dom", "seg", "ter", "qua", "qui", "sex", "sáb"];
+    const warn = (m) => ctx?.warnings?.push(`calendário: ${m}`);
     const parse = (d) => {
-      const t = String(d ?? "").trim();
-      let m = t.match(/^(\d{4})-(\d{1,2})(?:-(\d{1,2}))?$/); if (m) return { y: +m[1], mo: +m[2] - 1, d: m[3] ? +m[3] : null };
-      m = t.match(/^(\d{1,2})\/(\d{1,2})\/(\d{4})$/); if (m) return { y: +m[3], mo: +m[2] - 1, d: +m[1] };
-      m = t.match(/^(\d{1,2})\/(\d{4})$/); if (m) return { y: +m[2], mo: +m[1] - 1, d: null };
+      const raw = String(d ?? "").trim();
+      const hm = raw.match(/[ T](\d{1,2})[:h](\d{2})$/);
+      const t = hm ? raw.slice(0, hm.index).trim() : raw;
+      const time = hm ? `${hm[1].padStart(2, "0")}:${hm[2]}` : null;
+      let m = t.match(/^(\d{4})-(\d{1,2})(?:-(\d{1,2}))?$/); if (m) return { y: +m[1], mo: +m[2] - 1, d: m[3] ? +m[3] : null, time };
+      m = t.match(/^(\d{1,2})\/(\d{1,2})\/(\d{4})$/); if (m) return { y: +m[3], mo: +m[2] - 1, d: +m[1], time };
+      m = t.match(/^(\d{1,2})\/(\d{4})$/); if (m) return { y: +m[2], mo: +m[1] - 1, d: null, time };
       return null;
     };
+    const timeOf = (e) => (e.time != null && String(e.time).trim() ? String(e.time).trim().replace("h", ":") : e.at?.time || "");
     const events = (Array.isArray(s.events) ? s.events : []).filter((e) => e && typeof e === "object").map((e, i) => ({ ...e, i, at: parse(e.date) }));
     const undated = [...events.filter((e) => !e.at || e.at.mo < 0 || e.at.mo > 11), ...(Array.isArray(s.undated) ? s.undated.map((e) => (typeof e === "string" ? { title: e } : e)) : [])];
+    const dated = events.filter((x) => x.at && x.at.mo >= 0 && x.at.mo <= 11).sort((a, b) => a.at.y - b.at.y || a.at.mo - b.at.mo || (a.at.d || 99) - (b.at.d || 99) || timeOf(a).localeCompare(timeOf(b)));
     const months = new Map();
-    for (const e of events.filter((x) => x.at && x.at.mo >= 0 && x.at.mo <= 11).sort((a, b) => a.at.y - b.at.y || a.at.mo - b.at.mo || (a.at.d || 99) - (b.at.d || 99))) {
-      const key = `${e.at.y}-${e.at.mo}`; if (!months.has(key)) months.set(key, { y: e.at.y, mo: e.at.mo, list: [] }); months.get(key).list.push(e);
-    }
+    for (const e of dated) { const key = `${e.at.y}-${e.at.mo}`; if (!months.has(key)) months.set(key, { y: e.at.y, mo: e.at.mo, list: [] }); months.get(key).list.push(e); }
     const colors = itemColors(ctx?.theme || { colors: {} }, 6).map((h) => `#${h}`); // as do infográfico: do tema, diferentes entre si e com contraste
     const tagColor = new Map(); const colorOf = (e) => e.color ? (/^#?[0-9a-f]{6}$/i.test(e.color) ? `#${String(e.color).replace("#", "")}` : /^[a-z][\w-]*$/i.test(e.color) ? `var(--${e.color})` : "var(--hi)") : (e.tag ? (tagColor.has(e.tag) || tagColor.set(e.tag, colors[tagColor.size % colors.length]), tagColor.get(e.tag)) : colors[0]);
-    const card = (m, k) => {
-      const first = new Date(Date.UTC(m.y, m.mo, 1)).getUTCDay(), days = new Date(Date.UTC(m.y, m.mo + 1, 0)).getUTCDate();
-      const byDay = new Map(m.list.filter((e) => e.at.d).map((e) => [e.at.d, e]));
-      const cells = [...Array(first).fill(`<i></i>`), ...Array.from({ length: days }, (_, j) => { const e = byDay.get(j + 1); return e ? `<b style="--c:${colorOf(e)}">${j + 1}</b>` : `<i>${j + 1}</i>`; })].join("");
-      const items = m.list.map((e) => `<li class="ca-ev" style="--c:${colorOf(e)}"><span class="t f-label ca-day">${e.at.d ? String(e.at.d).padStart(2, "0") : "—"}</span><div class="ca-what">${text(e.title || "", "h3", { class: "ca-title", size: 26 })}${e.text ? text(e.text, "small", { class: "ca-text muted", size: 18 }) : ""}${e.tag ? `<span class="t f-label ca-tag">${md(String(e.tag))}</span>` : ""}</div></li>`).join("");
-      return `<section class="ca-month e" style="--d:${2 + k};"${s.build ? ` data-step="${k + 1}"` : ""}><header class="ca-head"><span class="t f-display ca-mo">${MESES[m.mo]}</span><span class="t f-label ca-y">${m.y}</span></header><div class="ca-grid" aria-hidden="true">${"DSTQQSS".split("").map((d) => `<u>${d}</u>`).join("")}${cells}</div><ul class="ca-list">${items}</ul></section>`;
-    };
-    const list = [...months.values()];
-    const und = undated.length ? `<section class="ca-month ca-undated e" style="--d:${2 + list.length};"><header class="ca-head"><span class="t f-display ca-mo">${md(String(s.undatedTitle || "sem data"))}</span></header><ul class="ca-list">${undated.map((e) => `<li class="ca-ev" style="--c:var(--muted)"><span class="t f-label ca-day">?</span><div class="ca-what">${text(e.title || "", "h3", { class: "ca-title", size: 24 })}${e.text ? text(e.text, "small", { class: "ca-text muted", size: 17 }) : ""}</div></li>`).join("")}</ul></section>` : "";
-    const n = list.length + (und ? 1 : 0), cols = s.cols || Math.min(n, n <= 4 ? n : n <= 6 ? 3 : 4);
-    const cardsHTML = list.map(card).join(""); // antes da legenda: os cartões é que dão a cor de cada tipo
+    const step = (k) => (s.build ? ` data-step="${k + 1}"` : "");
+    let list = [...months.values()];
+    const und = (k) => undated.length ? `<section class="ca-month ca-undated e" style="--d:${2 + k};"><header class="ca-head"><span class="t f-display ca-mo">${md(String(s.undatedTitle || "sem data"))}</span></header><ul class="ca-list">${undated.map((e) => `<li class="ca-ev" style="--c:var(--muted)"><span class="t f-label ca-day">?</span><div class="ca-what">${text(e.title || "", "h3", { class: "ca-title", size: 24 })}${e.text ? text(e.text, "small", { class: "ca-text muted", size: 17 }) : ""}</div></li>`).join("")}</ul></section>` : "";
+
+    // cabe nos cartões? Medido no navegador: com título, a área dos cartões tem ~698 px (uma fileira); a lista começa
+    // ~245 px abaixo do topo do cartão num mês de 5 semanas (27 px a mais por semana); evento ocupa 27 px (54 com detalhe)
+    const nCards = list.length + (undated.length ? 1 : 0);
+    const cols = s.cols || Math.min(nCards, nCards <= 4 ? nCards : nCards <= 6 ? 3 : 4) || 1;
+    const rows = Math.ceil(nCards / cols) || 1;
+    const cardH = ((s.title || s.kicker ? 698 : 860) - (rows - 1) * 22) / rows;
+    const weeksOf = (m) => Math.ceil((new Date(Date.UTC(m.y, m.mo, 1)).getUTCDay() + new Date(Date.UTC(m.y, m.mo + 1, 0)).getUTCDate()) / 7);
+    const need = (m) => m.list.reduce((h, e) => h + (e.text ? 54 : 27), 0) + (m.list.length - 1) * 10;
+    const full = list.filter((m) => need(m) > cardH - 18 - 245 - (weeksOf(m) - 5) * 27 + 4);
+    let view = ["meses", "mes", "semana", "lista"].includes(s.view) ? s.view : null;
+    if (s.view && !view) warn(`visão "${s.view}" não existe (use meses, mes, semana ou lista)`);
+    if (!view) view = s.month ? "mes" : !full.length ? "meses" : list.length === 1 ? "mes" : "lista";
+    if (view === "meses" && full.length) warn(`${full.map((m) => `${MESES_LONGOS[m.mo]} tem ${m.list.length} eventos`).join(", ")} e não cabe no cartão; use view: mes (no Studio: Um slide por mês) ou view: lista`);
+
+    const chipOf = (e) => `<span class="cm-ev t f-body" style="--c:${colorOf(e)}">${timeOf(e) ? `<b>${esc(timeOf(e))}</b> ` : ""}${md(String(e.title || ""))}</span>`;
+    let body;
+    if (view === "mes") {
+      // o mês grande: `month` escolhe; senão os meses com evento (até dois lado a lado)
+      if (s.month) {
+        const want = parse(s.month);
+        if (!want) warn(`mês "${s.month}" não é uma data (use 2026-11)`);
+        else list = [months.get(`${want.y}-${want.mo}`) || { y: want.y, mo: want.mo, list: [] }];
+      }
+      if (list.length > 2) { warn(`${list.length} meses na visão de mês: mostrando os dois primeiros; use Um slide por mês (no Studio) ou view: lista`); list = list.slice(0, 2); }
+      const big = (m, k) => {
+        const first = new Date(Date.UTC(m.y, m.mo, 1)).getUTCDay(), days = new Date(Date.UTC(m.y, m.mo + 1, 0)).getUTCDate();
+        const weeks = Math.ceil((first + days) / 7), max = weeks > 5 ? 2 : 3;
+        const byDay = new Map(); for (const e of m.list.filter((x) => x.at.d)) (byDay.get(e.at.d) || byDay.set(e.at.d, []).get(e.at.d)).push(e);
+        const cells = Array.from({ length: weeks * 7 }, (_, j) => {
+          const d = j - first + 1;
+          if (d < 1 || d > days) return `<div class="cm-cell out"></div>`;
+          const evs = byDay.get(d) || [];
+          if (evs.length > max) warn(`dia ${d} de ${MESES_LONGOS[m.mo]} tem ${evs.length} eventos; ${evs.length - max} ficaram no "+ mais" (use view: semana para ver todos)`);
+          return `<div class="cm-cell${evs.length ? " has" : ""}"><span class="cm-d t f-label">${d}</span>${evs.slice(0, max).map(chipOf).join("")}${evs.length > max ? `<span class="cm-more t f-label">+ ${evs.length - max} mais</span>` : ""}</div>`;
+        }).join("");
+        const noDay = m.list.filter((x) => !x.at.d);
+        return `<section class="cm-month e" style="--d:${2 + k};--weeks:${weeks}"${step(k)}><header class="ca-head"><span class="t f-display ca-mo">${MESES_LONGOS[m.mo]}</span><span class="t f-label ca-y">${m.y}</span></header>
+          <div class="cm-grid">${DIAS.map((d) => `<u class="t f-label">${d}</u>`).join("")}${cells}</div>${noDay.length ? `<div class="cm-noday"><span class="t f-label">no mês</span>${noDay.map(chipOf).join("")}</div>` : ""}</section>`;
+      };
+      body = `<div class="cm-months" style="--cols:${list.length || 1}">${list.map(big).join("")}${undated.length ? `<div class="cm-side">${und(list.length)}</div>` : ""}</div>`;
+    } else if (view === "semana") {
+      // semanas (de domingo a sábado) com evento de dia marcado; `week` escolhe uma
+      const startOf = (y, mo, d) => { const t = Date.UTC(y, mo, d); return t - new Date(t).getUTCDay() * 864e5; };
+      const withDay = dated.filter((e) => e.at.d);
+      let starts = [...new Set(withDay.map((e) => startOf(e.at.y, e.at.mo, e.at.d)))].sort((a, b) => a - b);
+      if (s.week) { const w = parse(s.week); if (w?.d) starts = [startOf(w.y, w.mo, w.d)]; else warn(`semana "${s.week}" precisa de um dia (2026-11-12)`); }
+      if (starts.length > 2) { warn(`${starts.length} semanas com evento: mostrando as duas primeiras; use week: (uma data) num slide por semana, ou view: lista`); starts = starts.slice(0, 2); }
+      if (!starts.length) warn("nenhum evento com dia marcado para a visão de semana");
+      const busy = (t0, j) => { const day = new Date(t0 + j * 864e5); return withDay.some((e) => e.at.y === day.getUTCFullYear() && e.at.mo === day.getUTCMonth() && e.at.d === day.getUTCDate()); };
+      const days = starts.some((t0) => busy(t0, 0) || busy(t0, 6)) ? [0, 1, 2, 3, 4, 5, 6] : [1, 2, 3, 4, 5]; // fim de semana vazio sai
+      const week = (t0, k) => `<section class="cw-week e" style="--d:${2 + k};--days:${days.length}"${step(k)}>${days.map((j) => {
+        const day = new Date(t0 + j * 864e5), y = day.getUTCFullYear(), mo = day.getUTCMonth(), d = day.getUTCDate();
+        const evs = withDay.filter((e) => e.at.y === y && e.at.mo === mo && e.at.d === d);
+        return `<div class="cw-day${evs.length ? " has" : ""}"><header class="cw-h"><span class="t f-label">${DIAS[j]}</span><b class="t f-display">${d}</b><span class="t f-label cw-mo">${MESES[mo]}</span></header>
+          ${evs.map((e) => `<div class="cw-ev" style="--c:${colorOf(e)}">${timeOf(e) ? `<span class="t f-label cw-t">${esc(timeOf(e))}</span>` : ""}${text(e.title || "", "h3", { class: "cw-title", size: 22 })}${e.text ? text(e.text, "small", { class: "cw-text muted", size: 16 }) : ""}${e.tag ? `<span class="t f-label ca-tag">${md(String(e.tag))}</span>` : ""}</div>`).join("")}</div>`;
+      }).join("")}</section>`;
+      body = `<div class="cw-weeks" style="--rows:${starts.length || 1}">${starts.map(week).join("")}</div>${undated.length ? `<div class="cm-noday"><span class="t f-label">${md(String(s.undatedTitle || "sem data"))}</span>${undated.map((e) => chipOf({ ...e, color: "muted" })).join("")}</div>` : ""}`;
+    } else if (view === "lista") {
+      // agenda: os meses em sequência, em colunas; a letra diminui com a quantidade
+      const total = dated.length + undated.length;
+      const ncol = s.cols || (total > 24 ? 3 : total > 10 ? 2 : 1);
+      if (total > 48) warn(`${total} eventos numa lista só ficam pequenos demais; divida em dois slides (no Studio: Um slide por mês)`);
+      const fs = total > 36 ? 15 : total > 20 ? 17 : total > 10 ? 20 : 24;
+      const row = (e) => `<li class="cl-ev" style="--c:${colorOf(e)}"><span class="cl-d"><b class="t f-display">${e.at?.d ? String(e.at.d).padStart(2, "0") : "—"}</b>${e.at?.d ? `<small class="t f-label">${DIAS[new Date(Date.UTC(e.at.y, e.at.mo, e.at.d)).getUTCDay()]}</small>` : ""}</span><div class="cl-what"><span class="cl-title t f-body">${timeOf(e) ? `<b class="cl-t">${esc(timeOf(e))}</b> ` : ""}${md(String(e.title || ""))}</span>${e.text ? `<small class="cl-text t f-body muted">${md(String(e.text))}</small>` : ""}</div>${e.tag ? `<span class="t f-label ca-tag">${md(String(e.tag))}</span>` : ""}</li>`;
+      body = `<div class="cl-list" style="--ncol:${ncol};--cal-fs:${fs}px">${list.map((m, k) => `<section class="cl-month e" style="--d:${2 + k};"${step(k)}><header class="cl-h"><span class="t f-display">${MESES_LONGOS[m.mo]}</span><span class="t f-label ca-y">${m.y}</span></header><ul>${m.list.map(row).join("")}</ul></section>`).join("")}${undated.length ? `<section class="cl-month e" style="--d:${2 + list.length};"><header class="cl-h"><span class="t f-display">${md(String(s.undatedTitle || "sem data"))}</span></header><ul>${undated.map((e) => row({ ...e, color: "muted" })).join("")}</ul></section>` : ""}</div>`;
+    } else {
+      const card = (m, k) => {
+        const first = new Date(Date.UTC(m.y, m.mo, 1)).getUTCDay(), days = new Date(Date.UTC(m.y, m.mo + 1, 0)).getUTCDate();
+        const byDay = new Map(m.list.filter((e) => e.at.d).map((e) => [e.at.d, e]));
+        const cells = [...Array(first).fill(`<i></i>`), ...Array.from({ length: days }, (_, j) => { const e = byDay.get(j + 1); return e ? `<b style="--c:${colorOf(e)}">${j + 1}</b>` : `<i>${j + 1}</i>`; })].join("");
+        const items = m.list.map((e) => `<li class="ca-ev" style="--c:${colorOf(e)}"><span class="t f-label ca-day">${e.at.d ? String(e.at.d).padStart(2, "0") : "—"}</span><div class="ca-what">${text(e.title || "", "h3", { class: "ca-title", size: 26 })}${e.text ? text(e.text, "small", { class: "ca-text muted", size: 18 }) : ""}${e.tag ? `<span class="t f-label ca-tag">${md(String(e.tag))}</span>` : ""}</div></li>`).join("");
+        return `<section class="ca-month e" style="--d:${2 + k};"${step(k)}><header class="ca-head"><span class="t f-display ca-mo">${MESES[m.mo]}</span><span class="t f-label ca-y">${m.y}</span></header><div class="ca-grid" aria-hidden="true">${"DSTQQSS".split("").map((d) => `<u>${d}</u>`).join("")}${cells}</div><ul class="ca-list">${items}</ul></section>`;
+      };
+      body = `<div class="ca-months" style="--cols:${cols};">${list.map(card).join("")}${und(list.length)}</div>`;
+    }
     const legend = tagColor.size > 1 ? `<div class="ca-legend">${[...tagColor].map(([t, c]) => `<span class="t f-label" style="--c:${c}"><i></i>${md(String(t))}</span>`).join("")}</div>` : "";
-    return `<div class="L-calendar">${head(s)}${legend}<div class="ca-months" style="--cols:${cols};">${cardsHTML}${und}</div></div>${src(s)}${add(s, ctx)}`;
+    return `<div class="L-calendar" data-view="${view}">${head(s)}${legend}${body}</div>${src(s)}${add(s, ctx)}`;
   },
 
   // Pôster (infográfico de uma página, como uma figura de revista científica): ilustração principal, painéis com letra
@@ -393,7 +440,7 @@ export const LAYOUTS = {
     const body = ev.map((e, i) => `<div${attrs({ step: e.step ?? build(s, i) }, `tl-ev ${hl.has(i) ? "hl" : ""}`)}>
         <div class="tl-dot"></div><div class="tl-when t f-display">${md(e.when)}</div>
         <div class="tl-title t f-heading">${md(e.title || "")}</div>${e.text ? `<div class="tl-text t f-body">${md(e.text)}</div>` : ""}
-        ${e.tag ? `<div class="tl-tag t f-label">${md(e.tag)}</div>` : ""}</div>`).join("");
+        ${e.tag ? `<div class="tl-tag t f-label">${md(e.tag)}</div>` : ""}${e.more ? popHTML(e.more, "above") : ""}</div>`).join("");
     return `<div class="L-timeline">${head(s)}<div class="tl" style="--n:${ev.length}"><div class="tl-line"></div>${body}</div>${s.after ? text(s.after, "h3", { class: "tl-after", step: s.afterStep ?? (s.build ? ev.length + 1 : 1), face: "quote", size: 48 }) : ""}</div>${src(s)}${add(s, ctx)}`;
   },
 
@@ -489,42 +536,6 @@ export const LAYOUTS = {
     return `<div class="L-spotlight" data-lesson="spotlight" data-lesson-count="${spots.length}">${head(s)}<div class="lesson-row"><div class="spotlight-visual"><div class="spotlight-canvas"><div class="spotlight-zoom"><div class="spotlight-image">${el(visual, ctx, 1100, 660)}</div><div class="spotlight-regions">${regions}</div></div></div>${s.caption ? text(s.caption, "small", { class: "spotlight-caption", size: 24 }) : ""}</div><aside class="lesson-aside">${lessonPanels(spots)}${lessonSummary(spots)}${lessonControls(spots)}</aside></div></div>${src(s)}${add(s, ctx)}`;
   },
 
-  kinetic(s, ctx) {
-    const beats = Array.isArray(s.beats) && s.beats.length
-      ? s.beats.map((beat) => typeof beat === "string" ? { text: beat } : beat || {})
-      : [
-          ...kineticPhrases(s.title || s.text),
-          ...kineticPhrases(s.subtitle),
-        ].map((text, i) => ({
-          text, style: "clean", position: "left", size: "medium",
-          ...(i === 0 && s.kicker ? { tag: s.kicker } : {}),
-        }));
-    if (!beats.length) beats.push({ text: "Uma ideia em movimento", style: "clean", position: "left", color: "white", size: "large" });
-    const frames = beats.map((beat, i) => {
-      const style = ["clean", "poster", "editorial", "outline", "marker"].includes(beat.style) ? beat.style : "clean";
-      const position = ["left", "center", "right", "top", "bottom"].includes(beat.position) ? beat.position : "left";
-      const color = ["white", "gold", "pink", "cyan"].includes(beat.color) ? beat.color : "white";
-      const size = ["small", "medium", "large"].includes(beat.size) ? beat.size : "medium";
-      return `<article class="kinetic-frame${i === 0 ? " active" : ""}" data-lesson-panel="${i}" data-position="${position}" data-style="${style}" data-color="${color}" data-size="${size}" aria-hidden="${i !== 0}">
-        <div class="kinetic-word" data-fit>${md(beat.text || "")}</div>
-        ${beat.tag ? `<div class="kinetic-tag">${md(beat.tag)}</div>` : ""}
-      </article>`;
-    }).join("");
-    const scene = s.figure ? el(s.figure, ctx, 1920, slideSize(ctx.spec).h) : "";
-    const interval = Math.max(450, Math.min(5000, Number(s.interval) || 1000));
-    const autoplay = s.autoplay !== false && beats.length > 1;
-    const summary = `<div class="kinetic-summary" aria-label="Frases da sequência">${beats.map((beat) => `<span>${md(beat.text || "")}</span>`).join("")}</div>`;
-    return `<div class="L-kinetic" data-lesson="kinetic" data-lesson-count="${beats.length}" data-kinetic-interval="${interval}" data-kinetic-autoplay="${autoplay}">
-      <div class="kinetic-scene" aria-hidden="true">${scene}</div><div class="kinetic-shade" aria-hidden="true"></div>
-      <div class="kinetic-grain" aria-hidden="true"></div>
-      <div class="kinetic-sequence" aria-live="polite" aria-atomic="true">${frames}</div>
-      <div class="kinetic-controls"><button type="button" class="kinetic-toggle" data-kinetic-toggle aria-pressed="${autoplay}" aria-label="${autoplay ? "Pausar" : "Reproduzir"} sequência"${beats.length < 2 ? " disabled" : ""}>${autoplay ? "Pausar" : "Reproduzir"}</button>
-        <nav class="kinetic-dots" aria-label="Frases da sequência">${beats.map((beat, i) => `<button type="button" data-lesson-go="${i}" aria-label="Frase ${i + 1}: ${esc(beat.text || "")}" aria-current="${i === 0 ? "step" : "false"}">${String(i + 1).padStart(2, "0")}</button>`).join("")}</nav>
-        <button type="button" class="kinetic-next" data-lesson-next aria-label="Próxima frase">${iconSVG("arrow-right", { size: 26, stroke: 2 })}</button>
-      </div>${summary}
-    </div>${add(s, ctx)}`;
-  },
-
   blocks(s, ctx) {
     return `<div class="L-blocks">${head(s, s.titleAs || "h2")}<div class="bl-body">${el(chartsSideBySide(s.content || []), ctx)}</div>${s.caption ? text(s.caption, "small", { class: "bl-caption muted" }) : ""}</div>${src(s)}${add(s, ctx)}`;
   },
@@ -746,10 +757,4 @@ export const LAYOUTS = {
   science(s, ctx) {
     return `<div class="L-science">${head(s)}<div class="science-body${s.plot === false ? ' equations-only' : !(s.equations || []).length ? ' plot-only' : ''}"><div class="science-equations">${mathHTML(s.equations || [])}</div>${s.plot === false ? '' : plotHTML(s.plot || {}, ctx)}</div>${s.caption ? text(s.caption,'small') : ''}</div>${add(s,ctx)}`;
   },
-  scenography(s, ctx) {
-    const scene = Object.hasOwn(SCENES, s.scene) ? s.scene : 'stage';
-    const op = s.imageOpacity == null || s.imageOpacity === '' ? 0.85 : Math.max(0, Math.min(1, Number(s.imageOpacity) || 0));
-    const props = SCENES[scene].props?.() || '';
-    return `<div class="L-scenography raster scene-${scene}"><div class="scene-atmosphere"></div>${s.image ? `<div class="scene-image" style="opacity:${op}">${el({image:s.image},ctx,1920,slideSize(ctx.spec).h)}</div>` : ''}${props ? `<div class="scene-props" aria-hidden="true">${props}</div>` : ''}<div class="scene-architecture" aria-hidden="true"><i></i><i></i><i></i><i></i><i></i></div><div class="scene-type"><div class="scene-eyebrow t f-label">${md(s.kicker || 'IDEIAS QUE OCUPAM ESPAÇO')}</div>${text(s.title || 'ALÉM DO\nÓBVIO','hero',{class:'scene-title',fit:true,size:s.titleSize || SCENES[scene].size})}${s.subtitle ? text(s.subtitle,'lead',{class:'scene-subtitle'}) : ''}</div>${s.foreground ? `<div class="scene-foreground">${el({image:s.foreground,fit:'contain'},ctx,1920,1080)}</div>` : '<div class="scene-sculpture" aria-hidden="true"><i></i><b></b></div>'}<div class="scene-caption f-label">${esc(s.caption || 'SAGA / NOVAS PERSPECTIVAS')}</div></div>${add(s,ctx)}`;
-  },
 };

package/src/lessons.js

@@ -34,7 +34,7 @@ function givenTex(g) {
   if (g.latex) return g.latex;
   const value = typeof g.value === "string" && isProse(g.value) ? `\\text{${g.value.replace(/[{}\\$]/g, "")}}` : commaTex(g.value);
   // % (e # & _ $) são comandos no LaTeX: "60 %" saía como erro vermelho na conta da criança
-  const unit = g.unit ? String(g.unit).replace(/[%#&_$]/g, (c) => `\\${c}`).replace(/°/g, "^{\\circ}").replace(/ /g, "\\,") : "";
+  const unit = g.unit ? String(g.unit).replace(/(?<!\\)[%#&_$]/g, (c) => `\\${c}`).replace(/°/g, "^{\\circ}").replace(/ /g, "\\,") : "";
   return `${g.symbol ?? ""} = ${value}${unit ? `\\ \\mathrm{${unit}}` : ""}`;
 }
 export function solutionHTML(s, ctx, head) {

package/src/library.js

@@ -14,7 +14,7 @@
 //
 // O id de uma apresentação é o caminho do .yaml dela, relativo à biblioteca, com "/" (ex.: "Palestras/X/X.yaml").
 import fs from "node:fs";
-import { renameRetry } from "./fs-retry.js";
+import { renameRetry, copyRetry, removeRetry } from "./fs-retry.js";
 import os from "node:os";
 import { execFileSync } from "node:child_process";
 import path from "node:path";
@@ -228,7 +228,7 @@ export function openLibrary(root, { trashDays } = {}) {
     const dir = topicDir(id);
     const left = fs.readdirSync(dir).filter((n) => !hidden(n));
     if (left.length) throw new Error("o tópico não está vazio: mova ou exclua as apresentações antes");
-    fs.rmSync(dir, { recursive: true, force: true });
+    removeRetry(dir);
   }
 
   // ---- apresentações ----
@@ -291,7 +291,7 @@ export function openLibrary(root, { trashDays } = {}) {
     const title = `${info.title} (cópia)`;
     const ext = unit === file ? path.extname(file) : "";
     const to = uniquePath(path.dirname(unit), safeName(title), ext);
-    fs.cpSync(unit, to, { recursive: true });
+    copyRetry(unit, to);
     let yaml = unit === file ? to : path.join(to, path.basename(file));
     if (unit !== file && path.basename(file).replace(/\.ya?ml$/i, "") === path.basename(unit)) {
       const renamed = path.join(to, path.basename(to) + path.extname(file));
@@ -404,11 +404,11 @@ export function openLibrary(root, { trashDays } = {}) {
     const ext = isFile ? path.extname(o.unit) : "";
     const to = uniquePath(dest, path.basename(o.unit, ext), ext);
     renameRetry(path.join(slot, o.unit), to);
-    fs.rmSync(slot, { recursive: true, force: true });
+    removeRetry(slot);
     return idOf(isFile ? to : path.join(to, o.yaml));
   }
   function purgeDeck(slotId) {
-    fs.rmSync(path.join(root, TRASH, path.basename(slotId)), { recursive: true, force: true });
+    removeRetry(path.join(root, TRASH, path.basename(slotId)));
   }
   // esvaziar a lixeira: tudo de uma vez (a pessoa confirma antes, no Studio)
   function emptyTrash() {
@@ -484,7 +484,7 @@ export function openLibrary(root, { trashDays } = {}) {
       if (!src.startsWith(path.resolve(fromDir)) || !fs.existsSync(src)) continue;
       const dst = path.join(dir, ...rel.split("/"));
       fs.mkdirSync(path.dirname(dst), { recursive: true });
-      fs.copyFileSync(src, dst);
+      copyRetry(src, dst);
     }
     fs.writeFileSync(path.join(dir, "estilo.yaml"), YAML.stringify(style, { indent: 2, lineWidth: 0 }));
     return { id, name: style.name };
@@ -505,7 +505,7 @@ export function openLibrary(root, { trashDays } = {}) {
       const to = `imagens/estilo/${slug(id)}/${path.basename(rel)}`;
       const dst = path.join(deckDir, ...to.split("/"));
       fs.mkdirSync(path.dirname(dst), { recursive: true });
-      fs.copyFileSync(src, dst);
+      copyRetry(src, dst);
       map.set(rel, to);
     }
     const master = structuredClone(style.master);

package/src/map-analysis.js

@@ -58,6 +58,7 @@ export function circle([lat, lon], metros, n = 32) {
 }
 
 // faixa de `metros` em volta de uma linha, para DESENHAR: retângulos dos trechos e círculos nos vértices (MultiPolygon).
+// Os pedaços se sobrepõem: a feature leva `_faixa: true` e o mapa a desenha sem contorno (uma mancha só).
 // Para CONTAR o que está dentro, use pointLine (exato).
 export function lineBuffer(geometry, metros) {
   const lines = geometry.type === "LineString" ? [geometry.coordinates] : geometry.type === "MultiLineString" ? geometry.coordinates : [];
@@ -73,7 +74,9 @@ export function lineBuffer(geometry, metros) {
       polys.push([[[lon1 + ox, lat1 + oy], [lon2 + ox, lat2 + oy], [lon2 - ox, lat2 - oy], [lon1 - ox, lat1 - oy], [lon1 + ox, lat1 + oy]]]);
     }
   }
-  return { type: "MultiPolygon", coordinates: polys };
+  // todos no mesmo sentido (anti-horário): onde os pedaços se sobrepõem, a área preenche uma vez só, sem buraco
+  const ccw = (ring) => { let a = 0; for (let i = 0; i < ring.length - 1; i++) a += ring[i][0] * ring[i + 1][1] - ring[i + 1][0] * ring[i][1]; return a >= 0 ? ring : [...ring].reverse(); };
+  return { type: "MultiPolygon", coordinates: polys.map(([ring]) => [ccw(ring)]) };
 }
 
 // "onde instalar o próximo": os `quantos` lugares mais longe de todos os existentes (e uns dos outros), dentro da área

package/src/map-config.js

@@ -12,9 +12,12 @@ export function mapaFile(env = process.env, home = os.homedir()) {
 }
 
 const OSM = "© colaboradores do OpenStreetMap";
+const OFM = '<a href="https://openfreemap.org/" target="_blank" rel="noopener">OpenFreeMap</a> · © <a href="https://openmaptiles.org/" target="_blank" rel="noopener">OpenMapTiles</a> · © <a href="https://www.openstreetmap.org/copyright" target="_blank" rel="noopener">colaboradores do OpenStreetMap</a>';
 export const MAP_DEFAULTS = {
-  // fundo de ruas; "claro" e "escuro" são o mesmo fundo com filtro de cor (sem outro provedor)
+  // ruas conserva o OpenStreetMap; fundos de dados são vetoriais, sem a fronteira marítima desenhada no mar
   tiles: { url: "https://tile.openstreetmap.org/{z}/{x}/{y}.png", attribution: OSM, maxZoom: 19 },
+  claro: { url: "https://tiles.openfreemap.org/styles/positron", tipo: "vetorial", attribution: OFM, maxZoom: 20 },
+  escuro: { url: "https://tiles.openfreemap.org/styles/dark", tipo: "vetorial", attribution: OFM, maxZoom: 20 },
   // satélite só com provedor configurado (costuma pedir chave); sem ele, o slide usa as ruas e avisa
   satelite: null,
   geocoder: { provedor: "nominatim", url: "https://nominatim.openstreetmap.org", porSegundo: 1 },
@@ -37,7 +40,10 @@ export function loadMapConfig(file = mapaFile(), env = process.env) {
   let raw = {};
   try { raw = JSON.parse(fs.readFileSync(file, "utf8")) || {}; } catch { raw = {}; }
   return Object.fromEntries(Object.entries(MAP_DEFAULTS).map(([k, base]) => {
-    const s = service(raw[k], base);
+    let s = service(raw[k], base);
+    // arquivo antigo com tiles próprios (ou desligados): respeita esse fundo nos três modos
+    if (["claro", "escuro"].includes(k) && !Object.hasOwn(raw, k) && Object.hasOwn(raw, "tiles") && (raw.tiles === null || raw.tiles?.url && raw.tiles.url !== MAP_DEFAULTS.tiles.url)) s = service(raw.tiles, MAP_DEFAULTS.tiles);
+    if (s && ["tiles", "claro", "escuro", "satelite"].includes(k)) s = { ...s, tipo: s.url.includes("{z}") ? "raster" : s.tipo || "raster" };
     if (s && !s.key && s.keyEnv && env[s.keyEnv]) return [k, { ...s, key: env[s.keyEnv], keyFrom: "variável" }];
     return [k, s];
   }));
@@ -78,6 +84,6 @@ export function maskedMapConfig(cfg) {
 // o que pode ir para dentro do HTML da apresentação: só o fundo (o navegador busca os tiles). Chave de rotas e de
 // geocodificação nunca vai para o deck.
 export function tilesForDeck(cfg = loadMapConfig()) {
-  const pick = (t) => (t ? { url: t.url, attribution: t.attribution || OSM, maxZoom: t.maxZoom || 19 } : null);
-  return { tiles: pick(cfg.tiles), satelite: pick(cfg.satelite) };
+  const pick = (t) => (t ? { url: t.url, tipo: t.tipo || "raster", attribution: t.attribution || OSM, maxZoom: t.maxZoom || 19 } : null);
+  return { tiles: pick(cfg.tiles), claro: pick(cfg.claro === undefined ? cfg.tiles : cfg.claro), escuro: pick(cfg.escuro === undefined ? cfg.tiles : cfg.escuro), satelite: pick(cfg.satelite) };
 }

package/src/map.js

@@ -110,9 +110,10 @@ export function fromKML(xml) {
 
 function fromGeoJSON(obj) {
   if (!obj || typeof obj !== "object") return [];
-  if (obj.type === "FeatureCollection") return (obj.features || []).filter((f) => f && f.geometry);
-  if (obj.type === "Feature") return obj.geometry ? [obj] : [];
-  if (obj.type && obj.coordinates) return [{ type: "Feature", properties: {}, geometry: obj }];
+  // _i: a posição da forma no arquivo (o editor do Studio acha a forma clicada por ela)
+  if (obj.type === "FeatureCollection") return (obj.features || []).map((f, i) => (f && f.geometry ? { ...f, properties: { ...f.properties, _i: i } } : null)).filter(Boolean);
+  if (obj.type === "Feature") return obj.geometry ? [{ ...obj, properties: { ...obj.properties, _i: 0 } }] : [];
+  if (obj.type && obj.coordinates) return [{ type: "Feature", properties: { _i: 0 }, geometry: obj }];
   return [];
 }
 
@@ -125,7 +126,7 @@ function fromAreas(values, warn) {
     const uf = g.uf[code], pais = g.paises[code];
     if (!uf && !pais) { warn(`mapa: "${k}" não é uma UF (SP, RJ…) nem um país (BR, PT…)`); continue; }
     const poly = uf || pais.poly;
-    features.push({ type: "Feature", properties: { nome: uf ? code : pais.nome, valor: v }, geometry: { type: "MultiPolygon", coordinates: poly } });
+    features.push({ type: "Feature", properties: { nome: uf ? code : pais.nome, valor: v, _cod: String(k) }, geometry: { type: "MultiPolygon", coordinates: poly } });
   }
   return features;
 }
@@ -204,6 +205,10 @@ export function mapModel(s, ctx) {
         const head = [...new Set(rows.flatMap((p) => Object.keys(p)))];
         features = pointsFromRows(head, rows.map((p) => head.map((h) => p[h] ?? "")), layer, warn).features;
       }
+    } else if (layer.geojson && typeof layer.geojson === "object") {
+      // escrito no próprio slide (desenho pequeno, demonstração); dados de verdade ficam num arquivo do projeto
+      features = fromGeoJSON(layer.geojson);
+      if (!features.length) warn(`mapa: o GeoJSON da camada "${layer.name || i + 1}" não tem formas`);
     } else if (layer.geojson) {
       const text = readText(layer.geojson, ctx, "GeoJSON");
       try { features = text == null ? [] : fromGeoJSON(JSON.parse(text)); } catch { warn(`mapa: "${layer.geojson}" não é um GeoJSON válido`); }
@@ -217,14 +222,22 @@ export function mapModel(s, ctx) {
     if (!features.length && layer.areas == null) warn(`mapa: a camada "${layer.name || i + 1}" ficou vazia`);
     const step = layer.step ?? (s.build ? i + 1 : undefined);
     layers.push({
-      name: layer.name || layer.title || `Camada ${i + 1}`, kind,
-      source: typeof layer.points === "string" ? layer.points.trim() : layer.geojson || layer.gpx || layer.kml || null, step: Number.isFinite(Number(step)) ? Number(step) : undefined,
+      name: layer.name || layer.title || `Camada ${i + 1}`, kind, index: i, // index: a camada no slide (o editor do Studio)
+      source: typeof layer.points === "string" ? layer.points.trim() : (typeof layer.geojson === "string" ? layer.geojson : null) || layer.gpx || layer.kml || null, step: Number.isFinite(Number(step)) ? Number(step) : undefined,
       view: viewOf(layer.view), legend: layer.legend || null, prefix: layer.prefix || "", suffix: layer.suffix || "",
       style: styleOf(features, layer, warn), data: { type: "FeatureCollection", features },
     });
   });
   const basemap = BASEMAPS.includes(s.basemap) ? s.basemap : "ruas";
   if (s.basemap && !BASEMAPS.includes(s.basemap)) warn(`mapa: fundo "${s.basemap}" não existe (use ${BASEMAPS.join(", ")})`);
+  // camadas da mesma medida (a mesma coluna ou a mesma unidade na legenda) dividem uma escala: cada uma com a sua,
+  // a Bahia (2.900) saía tão forte quanto Minas (5.100) só por ser a maior da camada dela
+  const groups = new Map();
+  for (const l of layers) if (l.style.scale) { const k = `${l.style.colorBy}|${l.legend || ""}`; (groups.get(k) || groups.set(k, []).get(k)).push(l); }
+  for (const g of groups.values()) if (g.length > 1) {
+    const scale = { min: Math.min(...g.map((l) => l.style.scale.min)), max: Math.max(...g.map((l) => l.style.scale.max)) };
+    for (const l of g) l.style.scale = scale;
+  }
   return { basemap, view: viewOf(s.view), bounds: bboxOf(layers), layers, tiles: ctx?.mapTiles || null };
 }
 
@@ -249,11 +262,11 @@ export function mapPreviewSVG(model, w = 1600, h = 760) {
   for (const layer of model.layers) for (const f of layer.data.features) {
     const g = f.geometry, col = color(layer, f);
     const lines = (cs) => cs.map((l) => `M${l.map(P).join("L")}`).join("");
-    if (g.type === "Point") { const [x, y] = P(g.coordinates).split(","); out.push(`<circle cx="${x}" cy="${y}" r="9" fill="${col}" stroke="var(--bg)" stroke-width="3"/>`); }
+    if (g.type === "Point") { const [x, y] = P(g.coordinates).split(","); out.push(`<circle cx="${x}" cy="${y}" r="8" fill="${col}" stroke="#fff" stroke-width="3"/>`); }
     else if (g.type === "LineString") out.push(`<path d="${lines([g.coordinates])}" fill="none" stroke="${col}" stroke-width="5"/>`);
     else if (g.type === "MultiLineString") out.push(`<path d="${lines(g.coordinates)}" fill="none" stroke="${col}" stroke-width="5"/>`);
     else if (g.type === "Polygon") out.push(`<path d="${lines(g.coordinates)}Z" fill="${col}" fill-opacity=".35" stroke="${col}" stroke-width="2"/>`);
-    else if (g.type === "MultiPolygon") out.push(`<path d="${g.coordinates.map((p) => lines(p) + "Z").join("")}" fill="${col}" fill-opacity=".35" stroke="${col}" stroke-width="2"/>`);
+    else if (g.type === "MultiPolygon") out.push(`<path d="${g.coordinates.map((p) => lines(p) + "Z").join("")}" fill="${col}" fill-opacity=".35" stroke="${col}" stroke-width="${f.properties?._faixa ? 0 : 2}"/>`);
   }
   return `<svg class="map-preview" viewBox="0 0 ${w} ${h}" preserveAspectRatio="xMidYMid meet" aria-hidden="true">${out.join("")}</svg>`;
 }

package/src/mcp/server.js

@@ -129,6 +129,18 @@ const TOOLS = [
       required: ["query"],
     },
   },
+  {
+    name: "sagadeck_ia_check",
+    description: "Testa a IA configurada nesta máquina, sem tela: texto, visão (o modelo precisa dizer as cores de uma imagem), geração de imagem, pesquisa na web e vídeo, cada um com uma chamada de verdade, em paralelo. Rode antes de usar recursos de IA. Status por recurso: ok, falhou, nao_configurado ou sem_prova (vídeo sem gerar). Vídeo só é gerado de verdade com video_real: true (é cobrado).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        so: { type: "array", items: { type: "string", enum: ["texto", "visao", "imagem", "pesquisa", "video"] }, description: "Só estes recursos (padrão: todos)" },
+        rapido: { type: "boolean", description: "Pula geração de imagem e vídeo (os lentos e cobrados)" },
+        video_real: { type: "boolean", description: "Gera um clipe curto de verdade e confere o MP4 (cobrado; leva minutos)" },
+      },
+    },
+  },
   {
     name: "sagadeck_launch_studio",
     description: "Inicia o SagaDeck Studio (página web estilo PowerPoint com canvas visual, edição WYSIWYG e chat lateral com IA).",
@@ -221,6 +233,11 @@ export function runMCPServer() {
 
 async function handleToolCall(name, args) {
   switch (name) {
+    case "sagadeck_ia_check": {
+      const { iaCheck } = await import("../ai/ia-check.js");
+      return iaCheck({ only: args.so, rapido: !!args.rapido, videoReal: !!args.video_real });
+    }
+
     case "sagadeck_read_deck": {
       const spec = loadSpec(path.resolve(args.path));
       return {