sagadeck 1.8.0 → 1.9.0

package/src/export/pptx.js

@@ -48,6 +48,8 @@ function collectInPage([idx, nativeCharts]) {
   const isLeaf = (e) => {
     const d = getComputedStyle(e).display;
     if ((d.includes("flex") || d.includes("grid")) && e.children.length) return false;
+    // Na régua da calculadora, cada faixa e cada rótulo têm caixas próprias: agrupar perderia posições e fundos.
+    if (e.classList.contains("calc-track") || e.classList.contains("calc-band")) return false;
     let has = false;
     for (const c of e.childNodes) {
       if (c.nodeType === 3) { if (c.textContent.trim()) has = true; }
@@ -168,7 +170,7 @@ function collectInPage([idx, nativeCharts]) {
       return;
     }
     // coisas que viram imagem
-    if (tag.toLowerCase() === "svg" || tag === "IMG" || tag === "CANVAS" || tag === "VIDEO" ||
+    if (tag.toLowerCase() === "svg" || tag === "IMG" || tag === "CANVAS" || tag === "VIDEO" || (tag === "INPUT" && e.type === "range") ||
         e.classList.contains("katex") || (isLeaf(e) && e.querySelector(".katex")) || e.classList.contains("widget") || e.classList.contains("timer") || e.classList.contains("code") || e.classList.contains("raster") || transformed(cs)) {
       const vr = visualRect(e);
       e.setAttribute("data-pid", String(++pid));
@@ -327,7 +329,7 @@ function materializePseudos() {
 }
 
 // notes: false tira as notas do apresentador (mandar a apresentação para alguém sem a "cola")
-export async function exportPptx(htmlFile, outFile, { theme, meta, nativeCharts = false, notes = true, fontFallback, log = () => {} } = {}) {
+export async function exportPptx(htmlFile, outFile, { theme, meta, nativeCharts = false, notes = true, fontFallback, log = () => {}, onProgress = () => {} } = {}) {
   const notesOpt = notes !== false;
   const { browser, page, errors } = await openDeck(htmlFile, { scale: 2 });
   try {
@@ -351,6 +353,7 @@ export async function exportPptx(htmlFile, outFile, { theme, meta, nativeCharts
   const animBySlide = [];
 
   for (let i = 0; i < n; i++) {
+    onProgress({ phase: 'slides', completed: i, total: n, slide: i + 1 });
     const S = await page.evaluate((j) => window.sagadeck.steps(j), i);
     await page.evaluate(([j, k]) => window.sagadeck.goto(j, k, true), [i, S]);
     await settleSlide(page);
@@ -432,8 +435,10 @@ export async function exportPptx(htmlFile, outFile, { theme, meta, nativeCharts
     if (notes && withNotes) slide.addNotes(notesPlain(notes));
     animBySlide.push({ anims, tr: data.tr });
     log(`  slide ${i + 1}/${n}: ${data.items.length} objetos`);
+    onProgress({ phase: 'slides', completed: i + 1, total: n, slide: i + 1 });
   }
   // pós-processamento: animações + transições
+  onProgress({ phase: 'packing', completed: n, total: n });
   const buf = await pres.write({ outputType: "nodebuffer" });
   const zip = await JSZip.loadAsync(buf);
   for (let i = 0; i < animBySlide.length; i++) {

package/src/export/shots.js

@@ -4,7 +4,7 @@ import path from "node:path";
 import { openDeck, waitForResources, settleSlide } from "./browser.js";
 
 // Estado final de cada slide (todos os cliques revelados)
-export async function shots(htmlFile, outDir, { steps = false, scale = 1, only, jpeg = false } = {}) {
+export async function shots(htmlFile, outDir, { steps = false, scale = 1, only, jpeg = false, onProgress = () => {} } = {}) {
   fs.mkdirSync(outDir, { recursive: true });
   for (const f of fs.readdirSync(outDir)) if (/^slide-\d+.*\.(png|jpg)$|^folha-\d+\.png$/.test(f)) fs.unlinkSync(path.join(outDir, f));
   const { browser, page, errors } = await openDeck(htmlFile, { scale });
@@ -13,6 +13,7 @@ export async function shots(htmlFile, outDir, { steps = false, scale = 1, only,
   const files = [];
   for (let i = 0; i < n; i++) {
     if (only && !only.includes(i + 1)) continue;
+    onProgress({ phase: 'slides', completed: i, total: n, slide: i + 1 });
     const S = await page.evaluate((j) => window.sagadeck.steps(j), i);
     const list = steps ? Array.from({ length: S + 1 }, (_, k) => k) : [S];
     for (const k of list) {
@@ -23,6 +24,7 @@ export async function shots(htmlFile, outDir, { steps = false, scale = 1, only,
       await page.screenshot(jpeg ? { path: f, type: "jpeg", quality: 82 } : { path: f });
       files.push(f);
     }
+    onProgress({ phase: 'slides', completed: i + 1, total: n, slide: i + 1 });
   }
   return { files, errors };
   } finally { await browser.close(); }
@@ -49,19 +51,22 @@ export async function contactSheet(files, outDir, { perSheet = 12, cols = 3 } =
   } finally { await browser.close(); }
 }
 
-export async function pdf(htmlFile, outFile) {
+export async function pdf(htmlFile, outFile, { onProgress = () => {} } = {}) {
   const { browser, page } = await openDeck(htmlFile, { scale: 1 });
   try {
   const n = await page.evaluate(() => window.sagadeck.n);
   const imgs = [], links = [];
   for (let i = 0; i < n; i++) {
+    onProgress({ phase: 'slides', completed: i, total: n, slide: i + 1 });
     const S = await page.evaluate((j) => window.sagadeck.steps(j), i);
     await page.evaluate(([j, k]) => window.sagadeck.goto(j, k), [i, S]);
     await settleSlide(page);
     await page.waitForTimeout(50);
     imgs.push((await page.screenshot({ type: "jpeg", quality: 92 })).toString("base64"));
     links.push(await page.evaluate(gotoRects, i));
+    onProgress({ phase: 'slides', completed: i + 1, total: n, slide: i + 1 });
   }
+  onProgress({ phase: 'packing', completed: n, total: n });
   // cada página é a foto do slide; por cima, áreas clicáveis nos itens com goto (o PDF pula para a página do destino)
   const hit = (l) => `<a href="#p${l.to}" style="position:absolute;left:${l.x}px;top:${l.y}px;width:${l.w}px;height:${l.h}px"></a>`;
   const { w: W, h: H } = await page.evaluate(() => window.sagadeck.size || { w: 1920, h: 1080 }); // deck.aspect

package/src/fiscal/normalize.js

@@ -52,6 +52,25 @@ export function normalizeSpec(rawSpec) {  if (!rawSpec || typeof rawSpec !== "ob
   spec.slides = spec.slides.map((s) => {
     if (!s || typeof s !== "object") return { layout: "statement", text: String(s) };
 
+    // Tipografia cinética saiu (Narumi: "se ele não consegue ser melhor, remova completamente"): o deck que a usava
+    // vira uma frase em destaque com as mesmas frases, uma por clique; a cena de fundo não tinha onde ficar
+    if (s.layout === "kinetic") {
+      const beats = (Array.isArray(s.beats) ? s.beats : []).map((b) => (typeof b === "string" ? b : b?.text)).filter((t) => typeof t === "string" && t.trim());
+      const phrases = beats.length ? beats : [s.title || s.text, s.subtitle].filter((t) => typeof t === "string" && t.trim());
+      const { beats: _b, autoplay: _a, interval: _i, figure: _f, layout: _l, title: _t, subtitle: _s, text: _x, ...rest } = s;
+      s = phrases.length > 1 ? { ...rest, layout: "statement", lines: phrases, build: true } : { ...rest, layout: "statement", text: phrases[0] || "" };
+    }
+
+    // Texto no cenário saiu (Narumi: "ele é muito limitado e dá para fazer coisas melhores pedindo pra IA desenhar"):
+    // com imagem, vira imagem de página inteira com o título por cima; sem imagem, frase em destaque
+    if (s.layout === "scenography") {
+      const { scene: _sc, foreground: _fg, imageOpacity: _op, titleSize: _ts, subtitle, caption, title, image, kicker, ...rest } = s;
+      const detail = [subtitle, caption].filter((v) => v != null && String(v).trim()).map(String).join("\n\n");
+      s = image
+        ? { ...rest, layout: "full", image, ...(kicker ? { kicker } : {}), ...(title ? { title } : {}), ...(detail ? { caption: detail } : {}), overlay: "left" }
+        : { ...rest, layout: "statement", ...(kicker ? { kicker } : {}), text: String(title || "").replace(/\n/g, " ").trim(), ...(detail ? { by: detail } : {}) };
+    }
+
     // 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; }

package/src/fs-retry.js

@@ -2,18 +2,53 @@
 // enquanto sincroniza (e também o antivírus ou o indexador), o arquivo fica preso por um instante e o rename falha
 // com EPERM/EBUSY/EACCES. Em vez de perder o salvamento da pessoa, tenta de novo com espera curta e crescente
 // (~1 s no total). Qualquer outro erro (destino inexistente, disco cheio…) sobe na hora.
+//
+// Copiar e remover pasta NÃO usam fs.cpSync/fs.rmSync recursivos: o código nativo deles (std::filesystem) no
+// Windows quebra o processo inteiro (0xC0000409, sem exceção para pegar) ou "faz nada" quando o caminho tem
+// acento ou caractere fora do ASCII (nodejs/node#54476, #61878) — "Relatório (cópia)" da biblioteca é o caso da
+// vida real. A cópia/remoção caminha na mão por readdir/copyFile/unlink/rmdir (libuv), que lida com acento, e
+// cada arquivo ainda tolera o travamento de um instante (EPERM/EBUSY/EACCES), como o rename.
 import fs from "node:fs";
+import path from "node:path";
 
 const LOCKED = new Set(["EPERM", "EBUSY", "EACCES"]);
 export const RENAME_DELAYS = [20, 40, 80, 150, 250, 450];
 
 const pause = (ms) => Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
 
-export function renameRetry(from, to, { delays = RENAME_DELAYS } = {}) {
+// tenta de novo enquanto o erro for "travado por um instante"; o resto sobe na hora
+function retry(delays, fn) {
   for (let i = 0; ; i++) {
-    try { return fs.renameSync(from, to); } catch (e) {
+    try { return fn(); } catch (e) {
       if (!LOCKED.has(e?.code) || i >= delays.length) throw e;
       pause(delays[i]);
     }
   }
 }
+
+export function renameRetry(from, to, { delays = RENAME_DELAYS } = {}) {
+  return retry(delays, () => fs.renameSync(from, to));
+}
+
+// arquivo ou pasta inteira (com imagens): duplicar uma apresentação é o caso — no Windows o antivírus segura o
+// arquivo recém-criado por um instante e a cópia falhava com EPERM (era o flake do CI no "mover (pasta inteira…)").
+export function copyRetry(from, to, { delays = RENAME_DELAYS } = {}) {
+  const st = fs.statSync(from);
+  if (!st.isDirectory()) return retry(delays, () => fs.copyFileSync(from, to));
+  fs.mkdirSync(to, { recursive: true });
+  for (const e of fs.readdirSync(from, { withFileTypes: true })) {
+    copyRetry(path.join(from, e.name), path.join(to, e.name), { delays });
+  }
+}
+
+// pasta inteira ou arquivo: a lixeira apaga de vez e o import limpa a área de trabalho; no Windows um arquivo
+// travado derrubava a operação e o rmSync recursivo ainda errava com caminho acentuado (apagava nada, em silêncio).
+export function removeRetry(target, { delays = RENAME_DELAYS } = {}) {
+  let st;
+  try { st = fs.lstatSync(target); } catch (e) { if (e?.code === "ENOENT") return; throw e; }
+  if (st.isDirectory()) {
+    for (const name of fs.readdirSync(target)) removeRetry(path.join(target, name), { delays });
+    return retry(delays, () => fs.rmdirSync(target));
+  }
+  return retry(delays, () => fs.unlinkSync(target));
+}

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