sagadeck 1.8.0 → 1.10.0

package/src/api-client.js

@@ -362,12 +362,43 @@ export class ApiEnvironments {
     return out.filter((s) => typeof s === "string" && s.length >= 6);
   }
 
-  maskText(env, text) {
+  maskText(env, text, contextual = false) {
     let s = String(text);
-    for (const secret of this.secrets(env)) s = s.split(secret).join(C.mask(secret));
+    if (!contextual) { for (const secret of this.secrets(env)) s = s.split(secret).join(C.mask(secret)); return s; }
+    // Pedidos importados codificam segredos em JSON/query/form. A resposta e o relatório podem
+    // devolver essas representações; nenhuma delas deve revelar o valor, mesmo quando curto.
+    const replacements = new Map();
+    for (const secret of [...this.secrets(env), ...Object.values(this.secretVars(env))].filter(Boolean)) {
+      const masked = C.mask(secret);
+      for (const [raw, safe] of [[secret, masked], [encodeURIComponent(secret), encodeURIComponent(masked)], [JSON.stringify(secret).slice(1, -1), JSON.stringify(masked).slice(1, -1)]]) if (!replacements.has(raw)) replacements.set(raw, safe);
+    }
+    for (const [raw, safe] of [...replacements].sort((a, b) => b[0].length - a[0].length)) s = s.split(raw).join(safe);
     return s;
   }
 
+  maskValue(env, value, depth = 0) {
+    if (typeof value === "string") {
+      const masked = this.maskText(env, value, true);
+      if (depth > 64 || !/^\s*[\[{\"]/.test(value) || Object.values(this.secretVars(env)).includes(value)) return masked;
+      try { JSON.parse(value); } catch { return masked; }
+      // APIs podem devolver JSON dentro de strings de logs. Decodifica cada string e mascara
+      // recursivamente; troca apenas esses spans para preservar números grandes e formatação.
+      let result = "", last = 0;
+      for (let at = 0; at < value.length; at++) {
+        if (value[at] !== '"') continue;
+        const from = at++;
+        while (at < value.length) { if (value[at] === "\\") at += 2; else if (value[at++] === '"') break; }
+        const decoded = JSON.parse(value.slice(from, at)), safe = this.maskValue(env, decoded, depth + 1);
+        if (safe !== decoded) { result += value.slice(last, from) + JSON.stringify(safe); last = at; }
+        at--;
+      }
+      return result + value.slice(last);
+    }
+    if (Array.isArray(value)) return value.map(item => this.maskValue(env, item, depth + 1));
+    if (value && typeof value === "object") return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, this.maskValue(env, item, depth + 1)]));
+    return value;
+  }
+
   async token(env, { renew = false } = {}) {
     const t = env.token;
     if (!t || !t.url) return null;
@@ -420,13 +451,13 @@ export class ApiEnvironments {
       });
       throw new ApiError(`Ambiente "${env.name}" não tem ${names.join(", ")} configurado em secrets:`, "config");
     }
-    req = { ...req, url: C.render(req.url, sv), headers: C.render(req.headers || {}, sv), body: C.render(req.body, sv) };
+    req = { ...req, url: C.renderURL(req.url, sv, req.urlEncoding), headers: C.render(req.headers || {}, sv), body: C.renderBody(req.body, sv, req.bodyEncoding) };
     const headers = { Accept: "application/json, text/event-stream, */*", ...C.render(env.headers || {}, sv), ...(req.headers || {}) };
     let body = req.body;
     const file = req.file || null; // { name, type, data: Buffer } — o arquivo do slide (upload ou base64)
     const needsFile = (req.form && Object.values(req.form).includes("@file")) || /\{\{\s*file\./.test(JSON.stringify(body ?? ""));
     if (needsFile && !file) throw new ApiError("Este slide precisa de um arquivo: arraste um para o slide ou defina file: no YAML.", "config");
-    if (file && body != null) body = C.render(body, { "file.base64": file.data.toString("base64"), "file.name": file.name, "file.type": file.type || "application/octet-stream" });
+    if (file && body != null) body = C.renderBody(body, { "file.base64": file.data.toString("base64"), "file.name": file.name, "file.type": file.type || "application/octet-stream" }, req.bodyEncoding);
     if (req.form) {
       // multipart/form-data, montado à mão (sem dependências)
       const boundary = "----sagadeck" + Math.random().toString(16).slice(2);
@@ -453,8 +484,9 @@ export class ApiEnvironments {
       const tok = await this.token(env, { renew });
       return tok ? { ...headers, [authHeader]: (t.prefix ?? "Bearer ") + tok } : headers;
     };
-    const sent = (h) => ({ method, url: this.maskText(env, req.url), headers: JSON.parse(this.maskText(env, JSON.stringify(h))), ...(file ? { file: { name: file.name, type: file.type, size: file.data.length } } : {}) });
-    return { env, method, body, withToken, sent, timeout: (Number(env.timeout) || 60) * 1000 };
+    const contextual = !!(req.bodyEncoding || req.urlEncoding);
+    const sent = (h) => ({ method, url: this.maskText(env, req.url, contextual), headers: contextual ? this.maskValue(env, h) : JSON.parse(this.maskText(env, JSON.stringify(h))), ...(file ? { file: { name: file.name, type: file.type, size: file.data.length } } : {}) });
+    return { env, method, url: req.url, body, withToken, sent, contextual, timeout: (Number(env.timeout) || 60) * 1000 };
   }
 
   // Pedido completo: a resposta volta inteira (JSON ou texto), com os segredos mascarados.
@@ -463,7 +495,7 @@ export class ApiEnvironments {
     const run = async (renew) => {
       const headers = await p.withToken(renew);
       const t0 = Date.now();
-      const res = await open({ method: p.method, url: req.url, headers, body: p.body, ca: this.ca(p.env), insecure: !!p.env.insecure, timeout: p.timeout });
+      const res = await open({ method: p.method, url: p.url, headers, body: p.body, ca: this.ca(p.env), insecure: !!p.env.insecure, timeout: p.timeout });
       const buf = await readAll(res);
       return { res, buf, headers, ms: Date.now() - t0 };
     };
@@ -483,7 +515,7 @@ export class ApiEnvironments {
     }
     // áudio (TTS): vai inteiro, em base64, para o slide tocar
     const body = /^audio\//i.test(type) ? { _audio: true, type: type.split(";")[0], base64: r.buf.toString("base64") }
-      : parseBody(Buffer.from(this.maskText(p.env, r.buf.toString("utf8"))), type);
+      : p.contextual ? this.maskValue(p.env, parseBody(r.buf, type)) : parseBody(Buffer.from(this.maskText(p.env, r.buf.toString("utf8"))), type);
     return {
       ok: r.res.statusCode < 400, status: r.res.statusCode, statusText: r.res.statusMessage || "", ms: r.ms, size: r.buf.length,
       type, body, sent: p.sent(r.headers), env: p.env.name, token: this.tokenInfo(p.env.name), ...(jwt ? { jwt } : {}),
@@ -610,7 +642,7 @@ export class ApiEnvironments {
   async open(req) {
     const p = await this.prepare(req);
     const headers = await p.withToken(false);
-    const res = await open({ method: p.method, url: req.url, headers, body: p.body, ca: this.ca(p.env), insecure: !!p.env.insecure, timeout: p.timeout });
-    return { res, env: p.env, sent: p.sent(headers), mask: (s) => this.maskText(p.env, s) };
+    const res = await open({ method: p.method, url: p.url, headers, body: p.body, ca: this.ca(p.env), insecure: !!p.env.insecure, timeout: p.timeout });
+    return { res, env: p.env, sent: p.sent(headers), mask: (s) => this.maskText(p.env, s, p.contextual) };
   }
 }

package/src/build.js

@@ -8,9 +8,9 @@ import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import YAML from "yaml";
-import { resolveTheme, themeCSS, scopedThemeCSS } from "./themes.js";
+import { resolveTheme, themeCSS, scopedThemeCSS, THEMES } from "./themes.js";
 import { identityFor, identitiesFile } from "./identity.js";
-import { LAYOUTS, SCENES, fullAsFigure } from "./layouts.js";
+import { LAYOUTS, fullAsFigure } from "./layouts.js";
 import { setDeckLocale } from "./locale.js";
 import { applyVisualEdits } from "./visual-edits.js";
 import { el, imageSrc } from "./elements.js";
@@ -24,6 +24,12 @@ import { loadMapConfig, mapaFile, tilesForDeck } from "./map-config.js";
 
 const HERE = path.dirname(fileURLToPath(import.meta.url));
 const read = (p) => fs.readFileSync(path.join(HERE, p), "utf8");
+let mapBackgroundAssets;
+const embeddedMapBackground = (spec, tiles) => {
+  if (!spec.slides.some((s) => s.layout === "map" && tiles?.[s.basemap || spec.defaults?.basemap]?.tipo === "vetorial")) return "";
+  mapBackgroundAssets ||= JSON.stringify(Object.fromEntries(Object.entries({ js: "maplibre-gl.js", css: "maplibre-gl.css", worker: "maplibre-worker.js", adapter: "maplibre-leaflet.js" }).map(([key, file]) => [key, fs.readFileSync(path.join(HERE, "runtime/vendor", file)).toString("base64")])));
+  return `<script type="application/json" id="map-background-assets">${mapBackgroundAssets}</script>`;
+};
 
 export function loadSpec(file) {
   const src = fs.readFileSync(file, "utf8");
@@ -59,7 +65,7 @@ export function inferLayout(s) {
 }
 
 const DEFAULT_TONE = { section: "accent", cover: "light", end: "dark" };
-const NO_FOOTER = new Set(["cover", "section", "end", "image", "canvas", "full", "headline", "kinetic", "scenography"]);
+const NO_FOOTER = new Set(["cover", "section", "end", "image", "canvas", "full", "headline"]);
 
 export function wordCount(s) {
   const txt = [];
@@ -81,7 +87,11 @@ export function wordCount(s) {
 // identidade do deck (fontes da empresa, do arquivo local; ver src/identity.js)
 const identityOf = (spec) => (spec.identity ? identityFor(spec.identity) : null);
 const slideTheme = (s, deckTheme, spec) => (s.theme || s.palette ? resolveTheme(s.theme || spec.theme, s.palette ?? spec.palette, identityOf(spec)) : deckTheme);
-const skinCSS = (name) => { try { return read(`runtime/skins/${name}.css`); } catch { return ""; } };
+// tema irmão (skin: "musgo" no wine): usa a pele do outro, com o seletor trocado para o nome dele
+const skinCSS = (name) => {
+  const base = THEMES[name]?.skin;
+  try { return base ? read(`runtime/skins/${base}.css`).replaceAll(`.th-${base}`, `.th-${name}`) : read(`runtime/skins/${name}.css`); } catch { return ""; }
+};
 export function deckThemeCSS(spec, deckTheme) {
   const looks = new Map(), names = new Set([deckTheme.name]);
   for (const raw of spec.slides || []) {
@@ -145,7 +155,7 @@ export function buildHTML(rawSpec, opts = {}) {
     const layout = inferLayout(s);
     const fn = LAYOUTS[layout];
     if (!fn) throw new Error(`Slide ${i + 1}: layout "${layout}" não existe. Use: ${Object.keys(LAYOUTS).join(", ")}`);
-    const tone = s.tone || (layout === "scenography" && SCENES[s.scene || "stage"]?.tone) || DEFAULT_TONE[layout] || spec.tone || "light";
+    const tone = s.tone || DEFAULT_TONE[layout] || spec.tone || "light";
     let inner;
     const th = slideTheme(s, theme, spec), sctx = th === theme ? ctx : { ...ctx, theme: th };
     try { inner = fn(s, sctx); } catch (e) { throw new Error(`Slide ${i + 1} (${layout}${s.title ? `: ${plain(s.title).slice(0, 40)}` : ""}): ${e.message}`); }
@@ -234,7 +244,7 @@ ${spec.slides.some((s) => s.layout === "diagram") ? `<script>${read("runtime/ven
 ${spec.slides.some(s => s.layout === "science") ? `<script>${read("runtime/vendor/plotly.min.js").replace(/<\/script/gi,"<\\/script")}</script><script>${read("runtime/formula.js")}</script><script>${read("runtime/science.js")}</script>` : ""}
 ${spec.slides.some(s => s.layout === "calc") ? `${spec.slides.some(s => s.layout === "science") ? "" : `<script>${read("runtime/formula.js")}</script>`}<script>${read("runtime/calc.js")}</script>` : ""}
 ${spec.slides.some(s=>s.layout==="portal") ? `<script>${read("runtime/portal-scene.js")}</script>` : ""}
-${spec.slides.some((s) => s.layout === "map") ? `<style>${read("runtime/vendor/leaflet.css")}</style><script>${read("runtime/vendor/leaflet.js").replace(/<\/script/gi, "<\\/script")}</script><script>${read("runtime/map.js")}</script>` : ""}
+${spec.slides.some((s) => s.layout === "map") ? `${embeddedMapBackground(spec, mapTiles)}<style>${read("runtime/vendor/leaflet.css")}</style><script>${read("runtime/vendor/leaflet.js").replace(/<\/script/gi, "<\\/script")}</script><script>${read("runtime/map-background.js")}</script><script>${read("runtime/map.js")}</script>` : ""}
 ${JSON.stringify(spec.slides || []).includes('"points"') ? `<script>${read("runtime/points.js")}</script>` : ""}
 ${spec.slides.some(s=>s.layout==="playground") ? `<script>${read("runtime/playground.js")}</script>` : ""}
 ${hasApi ? `${apiScripts}\n<script>${read("runtime/api-ui.js")}</script><script>${read("runtime/api-collection-ui.js")}</script>` : ""}
@@ -258,21 +268,41 @@ export function setFitDefaults(d = {}) {
 export const fitDefaults = () => ({ ...FIT_DEFAULTS });
 
 // eco ambiente: camada viva discreta atrás do conteúdo (só no HTML; PPTX/PDF usam o quadro parado)
-const AMBIENT = ["pontos", "grade"];
-function ambientOf(s, i, ctx) {
-  if (s.ambient == null || s.ambient === "") return "";
+// (rede: nós à deriva ligados por proximidade, num canvas animado pelo runtime; o tema pode pô-la sozinha na capa,
+// coverAmbient, e ambient: false tira)
+const AMBIENT = ["pontos", "grade", "rede"];
+function ambientOf(s, i, ctx, theme, layout) {
+  if (s.ambient === false) return "";
+  if (s.ambient == null || s.ambient === "") return layout === "cover" && theme?.coverAmbient ? theme.coverAmbient : "";
   if (!AMBIENT.includes(s.ambient)) { ctx.warnings?.push(`slide ${i + 1}: ambiente "${s.ambient}" desconhecido (vale: ${AMBIENT.join(", ")})`); return ""; }
   return s.ambient;
 }
+// faixa que corre na capa: `ticker: [..]` no slide, ou automática nos temas com ticker (musgo), com os títulos das
+// seções (sem seções suficientes, os dos slides). `ticker: false` desliga. Só no HTML; parada sem movimento/exportação.
+function tickerOf(s, spec, theme, layout) {
+  if (s.ticker === false || layout !== "cover") return null;
+  const clean = (list) => [...new Set(list.map((x) => plain(String(x ?? "")).trim()).filter(Boolean))].slice(0, 16);
+  if (Array.isArray(s.ticker)) return clean(s.ticker);
+  if (!theme.ticker && s.ticker !== true) return null;
+  const others = (spec.slides || []).filter((x) => x && typeof x === "object");
+  let items = clean(others.filter((x) => inferLayout(x) === "section").map((x) => x.title || x.kicker));
+  if (items.length < 3) items = clean(others.filter((x) => !isCoverLayout(inferLayout(x))).map((x) => x.title || x.kicker));
+  return items.length ? items : null;
+}
+function tickerHTML(items) {
+  const run = items.map((t) => `<span class="tk-it t f-mono">${esc(t)}</span><span class="tk-sep"></span>`).join("");
+  const dur = Math.max(24, Math.round(items.join("").length * 0.22));
+  return `<div class="ticker" aria-hidden="true"><div class="tk-track" style="--tk-dur:${dur}s">${run}${run}</div></div>`;
+}
 // <section> de um slide: tom, textura, estilo do destaque, fundo, área, cabeçalho e rodapé.
 // Única montagem para o Studio (renderSlide) e para a apresentação/exportação (buildHTML).
 function slideShell({ s, i, spec, theme, ctx, layout, tone, inner: innerIn, current = false }) {
   let inner = innerIn;
-  const ambient = ambientOf(s, i, ctx);
+  const ambient = ambientOf(s, i, ctx, theme, layout);
   const deco = s.deco ?? theme.deco;
   const style = (s.bg ? `--bg:#${String(s.bg).replace("#", "")};` : "") + (s.fg ? `--fg:#${String(s.fg).replace("#", "")};` : "");
   const bars = s.footer !== false && (s.footer === true || !NO_FOOTER.has(layout));
-  const area = layout === "canvas" || layout === "full" || layout === "kinetic" || layout === "scenography" ? "free" : "safe";
+  const area = layout === "canvas" || layout === "full" ? "free" : "safe";
   const motionAccent = area === 'safe' && s.motionAccent && typeof s.motionAccent === 'object';
   // estilo do ==destaque== (marca-texto | sublinhado | cor | negrito | nenhum), no deck ou por slide
   const markStyle = s.markStyle || spec.markStyle;
@@ -293,7 +323,7 @@ function slideShell({ s, i, spec, theme, ctx, layout, tone, inner: innerIn, curr
     if (hd) { bandTitle = `<div class="master-title">${hd[0].replace(/<[a-z0-9]+ [^>]*class="[^"]*\bttl\b[^"]*"[^>]*/, (tag) => `${tag}${/\sdata-fit[\s=>]|\sdata-fit$/.test(tag) ? "" : " data-fit"} data-fit-self`)}</div>`; inner = inner.replace(hd[0], ""); }
   }
   let html = `<section class="slide${current ? " current" : ""}${withMaster ? ` has-master${isCoverLayout(layout) ? " master-cover" : ""}${band ? " master-band" : ""}` : ""} th-${theme.name} lk-${theme.key} tone-${tone} ${deco && deco !== "none" ? "deco-" + deco : ""} ${markStyle && markStyle !== "marca-texto" ? "ms-" + markStyle : ""} L-${layout}-slide${["compact", "dense"].includes(s.density) ? " density-" + s.density : ""}" data-idx="${i}"${s.uid ? ` data-uid="${esc(String(s.uid))}"` : ""} data-layout="${layout}" data-tr="${s.transition || "fade"}"${ambient ? ` data-ambient="${ambient}"` : ""}${nav}${fitAttrs}${!Array.isArray(s.steps) && Number.isFinite(Number(s.steps)) && Number(s.steps) > 0 ? ` data-steps="${Number(s.steps)}"` : ""}${style ? ` style="${style}"` : ""}>`;
-  if (ambient) html += `<div class="ambient" aria-hidden="true"></div>`;
+  if (ambient) html += `<div class="ambient" aria-hidden="true">${ambient === "rede" ? "<canvas></canvas>" : ""}</div>`;
   if (s.background) html += `<div class="bgfig" style="${s.backgroundStyle || ""}">${el(s.background, ctx, 1920, slideSize(spec).h)}</div>`;
   // mestre do deck (logos, faixas, número da página: src/master.js), atrás do conteúdo
   if (withMaster) html += `<div class="master" aria-hidden="true">${masterElements(spec, layout, i).map((e) => el(e, ctx)).join("")}</div>`;
@@ -302,7 +332,9 @@ function slideShell({ s, i, spec, theme, ctx, layout, tone, inner: innerIn, curr
   if (bars && s.header !== false) html += barHTML("header", spec, i, total);
   if (bandTitle) html += applyVisualEdits(bandTitle, s.visualEdits, { src: (p) => imageSrc(p, ctx) || p });
   html += `<div class="${area}${motionAccent ? ' with-motion-accent' : ''}">${applyVisualEdits(inner, s.visualEdits, { src: (p) => imageSrc(p, ctx) || p })}</div>`;
-  if (motionAccent) {const fg=s.fg||theme.tones[tone]?.fg||'ink';html += `<div class="motion-accent" aria-hidden="true">${el({motion:{background:'transparent',foreground:theme.colors[fg]||fg,...s.motionAccent}},ctx,320,90)}</div>`;}
+  const ticker = tickerOf(s, spec, theme, layout);
+  if (ticker) html += tickerHTML(ticker);
+  if (motionAccent) {const fg=s.fg||theme.tones[tone]?.fg||'ink';html +=`<div class="motion-accent" aria-hidden="true">${el({motion:{background:'transparent',foreground:theme.colors[fg]||fg,...s.motionAccent}},ctx,320,90)}</div>`;}
   if (bars) html += barHTML("footer", spec, i, total);
   if (s.back != null && s.back !== "") {
     const alvo = (spec.slides || []).find((x) => x && String(x.id) === String(s.back));
@@ -321,7 +353,7 @@ export function renderSlide(raw, i = 0, spec = {}) {
   const layout = inferLayout(s);
   const fn = LAYOUTS[layout];
   if (!fn) throw new Error(`Slide ${i + 1}: layout "${layout}" não existe.`);
-  const tone = s.tone || (layout === "scenography" && SCENES[s.scene || "stage"]?.tone) || DEFAULT_TONE[layout] || spec.tone || "light";
+  const tone = s.tone || DEFAULT_TONE[layout] || spec.tone || "light";
   const inner = fn(s, ctx);
   const deco = s.deco ?? theme.deco;
   const html = slideShell({ s, i, spec, theme, ctx, layout, tone, inner, current: true });

package/src/code-highlight.js

@@ -6,6 +6,9 @@ const KEYWORDS = {
   JavaScript: new Set("async await break case catch class const continue debugger default delete do else export extends finally for from function if import in instanceof let new of return static super switch this throw try typeof var void while with yield".split(" ")),
   TypeScript: new Set("abstract any as asserts async await bigint boolean break case catch class const constructor continue declare default delete do else enum export extends finally for from function get if implements import in infer instanceof interface is keyof let namespace never new number object of package private protected public readonly return set static string super switch symbol this throw try type typeof undefined unique unknown var void while with yield".split(" ")),
   "C#": new Set("abstract as async await base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw try typeof uint ulong unchecked unsafe ushort using virtual void volatile while".split(" ")),
+  Bash: new Set("if then else elif fi for in do done while until case esac function select time export local readonly return exit source".split(" ")),
+  JSON: new Set(),
+  SQL: new Set("SELECT FROM WHERE JOIN INNER LEFT RIGHT FULL OUTER CROSS ON AS AND OR NOT IN IS NULL DISTINCT GROUP BY ORDER HAVING LIMIT OFFSET ASC DESC INSERT INTO VALUES UPDATE SET DELETE CREATE TABLE INDEX VIEW DROP ALTER WITH UNION ALL EXISTS CASE WHEN THEN ELSE END BETWEEN LIKE RETURNING BEGIN COMMIT ROLLBACK PRIMARY KEY REFERENCES DEFAULT".split(" ")),
 };
 
 const TYPES = {
@@ -14,11 +17,19 @@ const TYPES = {
   JavaScript: new Set("Array Boolean Date Map Number Object Promise Set String".split(" ")),
   TypeScript: new Set("Array any bigint boolean never number object string symbol unknown void".split(" ")),
   "C#": new Set("bool byte char DateTime decimal double float int List long object short string Task uint ulong var void".split(" ")),
+  Bash: new Set(),
+  JSON: new Set(),
+  SQL: new Set("INT INTEGER BIGINT TEXT VARCHAR BOOLEAN FLOAT DOUBLE DECIMAL NUMERIC DATE TIMESTAMP JSON JSONB".split(" ")),
 };
 
+const SHELL_COMMANDS = new Set("curl echo printf git npm node python python3 pip pytest jq cat grep sed awk ls cd pwd mkdir rm cp mv sleep read test find sort head tail".split(" "));
+
 const CONSTANTS = new Set(["False", "None", "True", "false", "null", "true", "undefined", "NaN", "Infinity"]);
 
 function tokenPattern(language) {
+  if (language === "Bash") return /(?<comment>(?<!\S)#[^\n]*)|(?<string>'[^']*'|"(?:\\[\s\S]|[^"\\])*")|(?<variable>\$(?:\{[^}\n]+\}|[A-Za-z_][\w]*|[\d?@#*!$-]))|(?<flag>(?<!\S)--?[A-Za-z][\w-]*(?:=[^\s]+)?)|(?<number>\b\d+(?:\.\d+)?\b)|(?<identifier>[A-Za-z_][\w]*)|(?<operator>[|&;<>]+)|(?<punctuation>[{}()\[\]])/g;
+  if (language === "JSON") return /(?<comment>\/\/[^\n]*|\/\*[\s\S]*?\*\/)|(?<string>"(?:\\.|[^"\\])*")|(?<number>\b\d+(?:\.\d+)?(?:[eE][+-]?\d+)?\b)|(?<identifier>true|false|null)|(?<punctuation>[{}\[\],:])/g;
+  if (language === "SQL") return /(?<comment>--[^\n]*|\/\*[\s\S]*?\*\/)|(?<string>'(?:''|[^'])*'|"(?:""|[^"])*"|`[^`]*`)|(?<number>\b\d+(?:\.\d+)?(?:[eE][+-]?\d+)?\b)|(?<identifier>[A-Za-z_][\w$]*)|(?<operator>[-+*/%=&|^!<>~]+)|(?<punctuation>[{}()\[\].,;])/g;
   const comments = language === "Python"
     ? "#[^\\n]*"
     : "\\/\\/[^\\n]*|\\/\\*[\\s\\S]*?\\*\\/";
@@ -32,13 +43,18 @@ function tokenPattern(language) {
 function classify(match, language, source, offset) {
   const groups = match.groups;
   if (groups.comment) return "comment";
+  if (groups.variable) return "constant";
+  if (groups.flag) return "keyword";
+  if (groups.string && language === "JSON" && /^\s*:/.test(source.slice(offset + match[0].length))) return "type";
   if (groups.string) return "string";
   if (groups.number) return "number";
   if (groups.identifier) {
     const word = groups.identifier;
-    if (KEYWORDS[language].has(word)) return "keyword";
+    const normalized = language === "SQL" ? word.toUpperCase() : word;
+    if (KEYWORDS[language].has(normalized)) return "keyword";
     if (CONSTANTS.has(word)) return "constant";
-    if (TYPES[language].has(word)) return "type";
+    if (TYPES[language].has(normalized)) return "type";
+    if (language === "Bash" && SHELL_COMMANDS.has(word)) return "function";
     if (/^\s*\(/.test(source.slice(offset + match[0].length))) return "function";
   }
   if (groups.operator) return "operator";
@@ -47,6 +63,7 @@ function classify(match, language, source, offset) {
 }
 
 export function highlightCode(source, language) {
+  if (!KEYWORDS[language]) return source.split("\n").map(esc);
   const pattern = tokenPattern(language);
   const lines = [""];
   const append = (value, kind = "") => {

package/src/code-language.js

@@ -11,6 +11,11 @@ const EXTENSIONS = new Map([
   [".mts", "TypeScript"],
   [".cts", "TypeScript"],
   [".cs", "C#"],
+  [".sh", "Bash"],
+  [".bash", "Bash"],
+  [".json", "JSON"],
+  [".jsonc", "JSON"],
+  [".sql", "SQL"],
 ]);
 
 const ALIASES = new Map([
@@ -26,6 +31,13 @@ const ALIASES = new Map([
   ["c#", "C#"],
   ["csharp", "C#"],
   ["cs", "C#"],
+  ["bash", "Bash"],
+  ["shell", "Bash"],
+  ["sh", "Bash"],
+  ["curl", "Bash"],
+  ["json", "JSON"],
+  ["jsonc", "JSON"],
+  ["sql", "SQL"],
 ]);
 
 export function inferCodeLanguage(filename) {
@@ -48,5 +60,6 @@ export function resolveCodeLanguage(language, filename) {
 
 export function displayCodeLanguage(language, filename) {
   const requested = String(language || "").trim();
+  if (requested.toLowerCase() === "curl") return "cURL";
   return normalizeCodeLanguage(requested) || requested || inferCodeLanguage(filename);
 }

package/src/elements.js

@@ -9,7 +9,7 @@ import katex from "katex";
 import { formatNumber, decimalSeparator } from "./locale.js";
 import fs from "node:fs";
 import path from "node:path";
-import { md, esc } from "./markup.js";
+import { md, esc, plain } from "./markup.js";
 import { iconSVG } from "./figures/icons.js";
 import { picto } from "./figures/pictos.js";
 import { diagram } from "./figures/diagrams.js";
@@ -258,6 +258,7 @@ export function el(e, ctx, w, h) {
   if (e.poll) return poll(e, ctx);
   if (e.list) return list(e);
   if (e.cards) return cards(e, ctx);
+  if (e.pop) return popEl(e);
   if (e.stats || e.kpis) return stats(e, ctx);
   if (e.steps || e.process || e.flow) return steps(e, ctx);
   if (e.progress != null) return progress(e);
@@ -478,6 +479,7 @@ export function cards(e, ctx) {
     if (c.check === true || c.status === "pro") extraWidgets += `<div class="check-pill pro">${iconSVG("check", { size: 26, stroke: 2.4 })} ${c.checkText ? md(c.checkText) : "Recomendado"}</div>`;
     if (c.check === false || c.status === "con") extraWidgets += `<div class="check-pill con">${iconSVG("x", { size: 26, stroke: 2.4 })} ${c.checkText ? md(c.checkText) : "Evitar"}</div>`;
 
+    if (c.flip != null && c.flip !== "") return flipCard(c, step, top, badgeHtml, extraWidgets);
     return `<div${attrs({ ...c, step, card: c.hl ? "hi" : true }, "cd")}>
       <div style="display:flex;justify-content:space-between;align-items:center;width:100%;">
         ${top}
@@ -493,6 +495,42 @@ export function cards(e, ctx) {
   return `<div${attrs(e, "cards", `grid-template-columns:repeat(${cols},1fr);`)}>${body}</div>`;
 }
 
+// Cartão que vira (flip: no cartão): clicar gira e mostra o verso (flipTitle + flip; "back" já é o Voltar da navegação). Frente e verso ficam no
+// mesmo lugar da grade; o mais alto dita a altura. Na exportação e no PPTX vale a frente.
+function flipCard(c, step, top, badgeHtml, extraWidgets) {
+  const face = `card${c.hl ? " card-hi" : ""} flip-face`;
+  const back = typeof c.flip === "object" ? c.flip : { text: c.flip };
+  return `<div${attrs({ ...c, step, card: false }, "cd flip")} data-flip tabindex="0" role="button" aria-pressed="false" aria-label="${esc(plain(String(c.title || "Cartão")))}: virar">
+    <div class="flip-in">
+      <div class="${face} flip-front">
+        <div style="display:flex;justify-content:space-between;align-items:center;width:100%;">${top}${badgeHtml}</div>
+        ${c.title ? `<div class="cd-title t f-heading">${md(c.title)}</div>` : ""}
+        ${c.text ? `<div class="cd-text t f-body">${md(c.text)}</div>` : ""}
+        ${extraWidgets}
+        ${c.foot ? `<div class="cd-foot t f-label">${md(c.foot)}</div>` : ""}
+        <span class="flip-hint" aria-hidden="true">${iconSVG("rotate-ccw", { size: 28, stroke: 2.2 })}</span>
+      </div>
+      <div class="${face} flip-back" aria-hidden="true">
+        ${back.title || c.flipTitle ? `<div class="cd-title t f-heading">${md(back.title || c.flipTitle)}</div>` : ""}
+        <div class="cd-text t f-body">${md(String(back.text ?? ""))}</div>
+        <span class="flip-hint" aria-hidden="true">${iconSVG("rotate-ccw", { size: 28, stroke: 2.2 })}</span>
+      </div>
+    </div>
+  </div>`;
+}
+
+// Botão + com balão (pop): clicar abre um balãozinho com título e texto e escurece o resto do slide; clicar de novo,
+// fora dele ou trocar de slide fecha. side: above (padrão) | below | left | right. Na exportação, fechado.
+export function popHTML(more, side = "above") {
+  const m = typeof more === "object" && more ? more : { text: more };
+  const sd = ["above", "below", "left", "right"].includes(m.side || side) ? m.side || side : "above";
+  return `<span class="pop pop-${sd}" data-pop><button type="button" class="pop-btn" aria-expanded="false" aria-label="${esc(plain(String(m.title || "Ver mais")))}">${iconSVG("plus", { size: 30, stroke: 2.6 })}</button><span class="pop-card" role="note">${m.title ? `<span class="pop-title t f-heading">${md(String(m.title))}</span>` : ""}<span class="pop-text t f-body">${md(String(m.text ?? ""))}</span></span></span>`;
+}
+function popEl(e) {
+  const m = typeof e.pop === "object" ? e.pop : { text: e.pop, title: e.title, side: e.side };
+  return `<span${attrs(e, "pop-el")}>${popHTML(m)}</span>`;
+}
+
 export function stats(e, ctx) {
   const items = e.stats || e.kpis || [];
   const cols = e.cols || Math.min(items.length, 4) || 3;

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));
+}