sagadeck 1.2.0

package/src/carousel.js

@@ -0,0 +1,56 @@
+// Carrossel (layout carousel): um item por clique, com foto (sua) e texto.
+//   style: arc   — roda em semicírculo com as fotos; gira até o item da vez; o texto atual sai pela esquerda e o
+//                  novo entra da esquerda para a direita, sobrepondo
+//   style: rings — a foto em anéis: o de fora gira no sentido anti-horário, o de dentro no horário, e travam no
+//                  lugar formando a foto; o texto sobe junto com o anel de fora
+// Sem foto, cada item ganha uma foto de demonstração desenhada (SVG, funciona sem internet).
+import { md, esc } from "./markup.js";
+import { figureHTML } from "./elements.js";
+
+// ---- fotos de demonstração: paisagens desenhadas, uma paleta por item ----
+const SCENES = [
+  { sky: ["#ffb36b", "#ff6f61"], sun: "#fff3c4", far: "#b8577a", near: "#5b2a58", kind: "mountains" },
+  { sky: ["#8fd3f4", "#2f80ed"], sun: "#ffffff", far: "#1f5fa8", near: "#0d3b66", kind: "sea" },
+  { sky: ["#1b1f3b", "#51306d"], sun: "#ffe8a3", far: "#2c2350", near: "#120f26", kind: "city" },
+  { sky: ["#ffd29d", "#f08a4b"], sun: "#fff7e0", far: "#d9864a", near: "#9c4f2e", kind: "dunes" },
+  { sky: ["#c8f0d8", "#5fb88b"], sun: "#fbfff0", far: "#2f7d5b", near: "#174a35", kind: "forest" },
+];
+export function demoPhoto(k) {
+  const s = SCENES[k % SCENES.length], id = `g${k}`;
+  let land = "";
+  if (s.kind === "mountains") land = `<path d="M0 560 L180 360 L300 470 L470 280 L640 480 L800 380 L800 800 L0 800Z" fill="${s.far}"/><path d="M0 650 L220 500 L400 620 L600 470 L800 600 L800 800 L0 800Z" fill="${s.near}"/>`;
+  else if (s.kind === "sea") land = `<rect y="520" width="800" height="280" fill="${s.far}"/>${[0, 1, 2, 3, 4].map((i) => `<path d="M0 ${560 + i * 50} q100 -24 200 0 t200 0 t200 0 t200 0" stroke="#ffffff55" stroke-width="6" fill="none"/>`).join("")}<rect y="700" width="800" height="100" fill="${s.near}"/>`;
+  else if (s.kind === "city") land = [60, 150, 230, 330, 420, 520, 600, 690].map((x, i) => { const h = 180 + ((i * 97) % 220); return `<rect x="${x}" y="${800 - h - 120}" width="${70 + (i % 3) * 14}" height="${h + 120}" fill="${i % 2 ? s.far : s.near}"/>${Array.from({ length: 5 }, (_, j) => `<rect x="${x + 14}" y="${800 - h - 90 + j * 44}" width="12" height="16" fill="#ffd66b" opacity="${(i + j) % 3 ? 0.9 : 0.25}"/>`).join("")}`; }).join("");
+  else if (s.kind === "dunes") land = `<path d="M0 560 Q200 460 420 560 T800 520 L800 800 L0 800Z" fill="${s.far}"/><path d="M0 660 Q260 560 520 660 T800 640 L800 800 L0 800Z" fill="${s.near}"/>`;
+  else land = `<rect y="600" width="800" height="200" fill="${s.near}"/>${Array.from({ length: 11 }, (_, i) => `<path d="M${i * 78 - 10} 640 l40 -${170 + (i * 53) % 90} l40 ${170 + (i * 53) % 90}Z" fill="${i % 2 ? s.far : s.near}"/>`).join("")}`;
+  const svg = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 800 800"><defs><linearGradient id="${id}" x1="0" y1="0" x2="0" y2="1"><stop offset="0" stop-color="${s.sky[0]}"/><stop offset="1" stop-color="${s.sky[1]}"/></linearGradient></defs><rect width="800" height="800" fill="url(#${id})"/><circle cx="${540 - (k % 3) * 120}" cy="${260 + (k % 2) * 40}" r="${80 + (k % 3) * 18}" fill="${s.sun}" opacity=".92"/>${land}</svg>`;
+  return `data:image/svg+xml;base64,${Buffer.from(svg).toString("base64")}`;
+}
+
+// a foto do item: a da pessoa (image: caminho, link ou data:) ou a de demonstração
+function photo(item, k, ctx) {
+  if (item.image) {
+    const html = figureHTML({ image: item.image, fit: "cover", alt: item.alt || item.title || "" }, ctx);
+    const src = html.match(/src="([^"]+)"/)?.[1];
+    if (src) return src;
+  }
+  return demoPhoto(k);
+}
+
+export function carouselHTML(s, ctx, head) {
+  const items = (s.items || []).map((x) => (typeof x === "string" ? { title: x } : x || {}));
+  if (!items.length) items.push({ title: "Primeiro item", text: "Troque pelos seus itens: título, texto e foto." }, { title: "Segundo item" }, { title: "Terceiro item" });
+  const n = items.length, style = s.style === "rings" ? "rings" : "arc";
+  const text = (it, k) => `<article class="car-text${k === 0 ? " active" : ""}" data-lesson-k="${k}">${it.label ? `<div class="car-kicker t f-label">${md(it.label)}</div>` : `<div class="car-kicker t f-label">${String(k + 1).padStart(2, "0")} / ${String(n).padStart(2, "0")}</div>`}<h3 class="car-title t f-display">${md(it.title || "")}</h3>${it.text ? `<p class="car-body t f-body">${md(it.text)}</p>` : ""}</article>`;
+  const srcs = items.map((it, k) => photo(it, k, ctx));
+  const alt = (it) => esc(it.alt || it.title || "");
+  let visual;
+  if (style === "arc") {
+    const step = Math.max(24, Math.min(34, 200 / Math.max(1, Math.min(n, 6)))); // fotos grandes: vizinhos sem encostar
+    visual = `<div class="car-wheel" style="--step:${step}deg" aria-hidden="true"><div class="car-track"></div>${items.map((it, k) => `<div class="car-item${k === 0 ? " active" : ""}" data-lesson-k="${k}" style="--k:${k}"><div class="car-photo"><img src="${srcs[k]}" alt="${alt(it)}"></div></div>`).join("")}</div>`;
+  } else {
+    visual = `<div class="car-disc">${items.map((it, k) => `<div class="car-slide${k === 0 ? " active" : ""}" data-lesson-k="${k}"><div class="car-ring-out"><img src="${srcs[k]}" alt="${alt(it)}"></div><div class="car-ring-in"><img src="${srcs[k]}" alt=""></div></div>`).join("")}<div class="car-lock" aria-hidden="true"></div></div>
+      <nav class="car-dots" aria-hidden="true">${items.map((it, k) => `<span class="car-dot${k === 0 ? " active" : ""}" data-lesson-k="${k}"></span>`).join("")}</nav>`;
+  }
+  return `<div class="L-carousel car-${style}" data-lesson="carousel" data-lesson-count="${n}" style="--n:${n}">${s.title || s.kicker ? head(s) : ""}<div class="car-stage">${visual}<div class="car-texts">${items.map(text).join("")}</div></div></div>`;
+}

package/src/chrome.js

@@ -0,0 +1,65 @@
+// Cabeçalho e rodapé dos slides, com variáveis.
+//
+//   footer: "Texto"                     -> texto à esquerda + número à direita (como sempre foi)
+//   footer: false                       -> sem rodapé
+//   footer: { left: "{autor} · {evento}", center: "", right: "{pagina} / {total}" }
+//   header: { left: "{depto}", right: "{data:DD/MM/AAAA}" }
+//
+// Variáveis: {titulo} {autor} {evento} {depto} {data} {data:MASCARA} {pagina} {n} {total}
+//   {pagina} = 01, 02… · {n} = 1, 2… · MASCARA: DD MM AAAA AA MMM (jan) MMMM (janeiro) — também YYYY/YY
+// Campos do deck usados: title, author, event, department, date (AAAA-MM-DD; sem date, usa a data de hoje).
+import { esc, plain } from "./markup.js";
+
+const MESES = ["janeiro", "fevereiro", "março", "abril", "maio", "junho", "julho", "agosto", "setembro", "outubro", "novembro", "dezembro"];
+
+export function formatDate(date, mask = "DD/MM/AAAA") {
+  const d = date instanceof Date ? date : parseDate(date);
+  if (!d) return String(date ?? "");
+  const dd = String(d.getDate()).padStart(2, "0");
+  const mm = String(d.getMonth() + 1).padStart(2, "0");
+  const yyyy = String(d.getFullYear());
+  return mask.replace(/MMMM|MMM|AAAA|YYYY|AA|YY|DD|MM/g, (t) => ({
+    DD: dd, MM: mm, AAAA: yyyy, YYYY: yyyy, AA: yyyy.slice(2), YY: yyyy.slice(2), MMM: MESES[d.getMonth()].slice(0, 3), MMMM: MESES[d.getMonth()],
+  })[t]);
+}
+
+function parseDate(v) {
+  if (v == null || v === "" || v === "hoje") return new Date();
+  if (v instanceof Date) return v;
+  const m = String(v).match(/^(\d{4})-(\d{2})-(\d{2})/);
+  if (m) return new Date(+m[1], +m[2] - 1, +m[3]);
+  const br = String(v).match(/^(\d{2})\/(\d{2})\/(\d{4})$/);
+  if (br) return new Date(+br[3], +br[2] - 1, +br[1]);
+  return null;
+}
+
+export function fillTokens(tpl, spec, i, total) {
+  const vars = {
+    titulo: spec.title, autor: spec.author, evento: spec.event, depto: spec.department,
+    pagina: String(i + 1).padStart(2, "0"), n: String(i + 1), total: String(total),
+  };
+  return String(tpl ?? "").replace(/\{(\w+)(?::([^}]*))?\}/g, (all, k, arg) => {
+    if (k === "data") return formatDate(spec.date, arg || "DD/MM/AAAA");
+    return k in vars ? String(vars[k] ?? "") : all;
+  });
+}
+
+// Normaliza footer/header do deck em { left, center, right } (ou null = não tem)
+export function barSlots(v, spec, kind) {
+  if (v === false) return null;
+  if (v == null) return kind === "footer" && spec.title ? { left: "{titulo}", right: "{pagina}" } : null;
+  if (typeof v === "string") return { left: v, right: "{pagina}" };
+  if (typeof v === "object") return { left: v.left || "", center: v.center || "", right: v.right || "" };
+  return null;
+}
+
+export function barHTML(kind, spec, i, total) {
+  const slots = barSlots(spec[kind], spec, kind);
+  if (!slots) return "";
+  const cell = (pos) => {
+    const txt = fillTokens(slots[pos], spec, i, total).trim();
+    return `<span class="bar-${pos}${/^\d+$/.test(txt) ? " fn" : ""}">${esc(plain(txt))}</span>`;
+  };
+  if (!["left", "center", "right"].some((p) => String(slots[p] || "").trim())) return "";
+  return `<div class="${kind === "footer" ? "foot" : "headbar"} f-label">${cell("left")}${cell("center")}${cell("right")}</div>`;
+}

package/src/code-highlight.js

@@ -0,0 +1,68 @@
+import { esc } from "./markup.js";
+
+const KEYWORDS = {
+  Python: new Set("and as assert async await break class continue def del elif else except finally for from global if import in is lambda nonlocal not or pass raise return try while with yield".split(" ")),
+  Java: new Set("abstract assert boolean break byte case catch char class const continue default do double else enum extends final finally float for if implements import instanceof int interface long native new package private protected public return short static strictfp super switch synchronized this throw throws transient try void volatile while var record".split(" ")),
+  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(" ")),
+};
+
+const TYPES = {
+  Python: new Set("bool dict float int list object set str tuple".split(" ")),
+  Java: new Set("ArrayList Boolean Byte Character Double Float Integer List Long Map Object Set Short String".split(" ")),
+  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(" ")),
+};
+
+const CONSTANTS = new Set(["False", "None", "True", "false", "null", "true", "undefined", "NaN", "Infinity"]);
+
+function tokenPattern(language) {
+  const comments = language === "Python"
+    ? "#[^\\n]*"
+    : "\\/\\/[^\\n]*|\\/\\*[\\s\\S]*?\\*\\/";
+  const strings = language === "Python"
+    ? "(?:[rRuUbBfF]{0,2})(?:'''[\\s\\S]*?'''|\"\"\"[\\s\\S]*?\"\"\"|'(?:\\\\.|[^'\\\\])*'|\"(?:\\\\.|[^\"\\\\])*\")"
+    : "(?:\\$?@?\"(?:\"\"|\\\\.|[^\"\\\\])*\"|@?\"(?:\"\"|[^\"])*\"|'(?:\\\\.|[^'\\\\])*'|`(?:\\\\.|[^`\\\\])*`)";
+  const number = "(?:\\b(?:0[xX][\\da-fA-F]+|0[bB][01]+|\\d+(?:\\.\\d*)?(?:[eE][+-]?\\d+)?)(?:[fFdDlL])?|\\.\\d+(?:[eE][+-]?\\d+)?)";
+  return new RegExp(`(?<comment>${comments})|(?<string>${strings})|(?<number>${number})|(?<identifier>[A-Za-z_$][\\w$]*)|(?<operator>[-+*/%=&|^!<>~?:]+)|(?<punctuation>[{}()\\[\\].,;])`, "g");
+}
+
+function classify(match, language, source, offset) {
+  const groups = match.groups;
+  if (groups.comment) return "comment";
+  if (groups.string) return "string";
+  if (groups.number) return "number";
+  if (groups.identifier) {
+    const word = groups.identifier;
+    if (KEYWORDS[language].has(word)) return "keyword";
+    if (CONSTANTS.has(word)) return "constant";
+    if (TYPES[language].has(word)) return "type";
+    if (/^\s*\(/.test(source.slice(offset + match[0].length))) return "function";
+  }
+  if (groups.operator) return "operator";
+  if (groups.punctuation) return "punctuation";
+  return "";
+}
+
+export function highlightCode(source, language) {
+  const pattern = tokenPattern(language);
+  const lines = [""];
+  const append = (value, kind = "") => {
+    const parts = value.split("\n");
+    parts.forEach((part, index) => {
+      if (index) lines.push("");
+      if (part) lines[lines.length - 1] += kind ? `<span class="tok tok-${kind}">${esc(part)}</span>` : esc(part);
+    });
+  };
+
+  let cursor = 0;
+  for (const match of source.matchAll(pattern)) {
+    append(source.slice(cursor, match.index));
+    append(match[0], classify(match, language, source, match.index));
+    cursor = match.index + match[0].length;
+  }
+  append(source.slice(cursor));
+  return lines;
+}

package/src/code-lab-browser.js

@@ -0,0 +1,22 @@
+import { traceHTML } from './trace-view.js';
+// Mesmo interpretador do algoritmo animado; não há eval, rede nem processo Python no navegador.
+for(const root of document.querySelectorAll('[data-codelab]')){
+  const $=s=>root.querySelector(s),initial=JSON.parse($('.clab-model').textContent);let index=0;
+  const show=()=>{const frames=[...root.querySelectorAll('.dyn-frame')];index=Math.max(0,Math.min(frames.length-1,index));frames.forEach((e,i)=>{e.classList.toggle('active',i===index);e.setAttribute('aria-hidden',i!==index);});$('.clab-status').textContent=`Passo ${index+1} de ${frames.length}`;};
+  async function run(){if(initial.engine!=="trace"){return nativeRun()}try{const warnings=[],program=$('[data-clab-program]').value,call=$('[data-clab-call]').value;if(program.length>16000||call.length>2000)throw new Error('Reduza o programa ou a entrada para uma experiência de aula.');const html=traceHTML({maxSteps:initial.maxSteps},{program,call,view:null,name:'Sua execução'},{warnings},()=>'',(i,body,extra='')=>`<section class="lesson-panel dyn-frame ${extra}" data-lesson-panel="${i}">${body}</section>`);
+    if(warnings.length&&html.includes('dyn-error'))throw new Error(warnings.join(' '));$('.clab-stage').innerHTML=html;index=0;show();root.dataset.codelabReady='true';
+  }catch(e){$('.clab-status').textContent=`Não executou: ${e.message}`;}}
+  async function nativeRun(){
+    const button=$('[data-clab-run]');button.disabled=true;$('.clab-status').textContent='Executando '+initial.engine+'…';
+    try{
+      if(!/^https?:$/.test(location.protocol)||location.href==='about:srcdoc')throw new Error('Abra esta apresentação no Studio para usar o runtime nativo.');
+      const program=$('[data-clab-program]').value,call=$('[data-clab-call]').value.trim();
+      const code=program+(call?'\n'+(initial.engine==='python'?'print(repr('+call+'))':'console.log(await ('+call+'));'):'');
+      const response=await fetch('api/code/run',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({language:initial.engine,code})}),data=await response.json();
+      if(!response.ok)throw new Error(data.error||'Execução indisponível');
+      const pre=document.createElement('pre');pre.className='clab-native-output';pre.textContent=[data.stdout,data.stderr].filter(Boolean).join('\n')||'(sem saída)';$('.clab-stage').replaceChildren(pre);
+      $('.clab-status').textContent=(data.timedOut?'Tempo excedido':'Saída '+data.exitCode)+' · '+data.elapsedMs+' ms';root.dataset.codelabReady='true';
+    }catch(e){$('.clab-status').textContent='Não executou: '+e.message;}finally{button.disabled=false;}
+  }
+  $('[data-clab-run]').onclick=run;$('[data-clab-next]').onclick=()=>{index++;show();};$('[data-clab-prev]').onclick=()=>{index--;show();};$('[data-clab-reset]').onclick=()=>{$('[data-clab-program]').value=initial.program;$('[data-clab-call]').value=initial.call;run();};if(initial.engine==='trace')run();else{root.dataset.codelabReady='true';$('[data-clab-prev]').hidden=true;$('[data-clab-next]').hidden=true;$('.clab-status').textContent='Execução nativa · clique Executar para iniciar.';}
+}

package/src/code-lab.js

@@ -0,0 +1,3 @@
+import { esc } from './markup.js';
+export const codeLabExample={layout:'codelab',title:'Mude a entrada. Explique a saída.',program:'def lotes(total, tamanho):\n    feitos = 0\n    while feitos < total:\n        feitos += tamanho\n        print(min(feitos, total))\n    return feitos',call:'lotes(12, 5)',explanation:'Teste uma entrada que termina exatamente no tamanho do lote e outra que deixa um resto. Como você corrigiria o retorno?'};
+export function codeLabHTML(s,ctx,head){return `<div class="L-codelab" data-codelab>${head(s)}<div class="clab-toolbar"><label>Chamada / entrada<input data-clab-call value="${esc(s.call||'')}" spellcheck="false"></label><button data-clab-run>Executar minha versão</button><button data-clab-prev>Voltar passo</button><button data-clab-next>Próximo passo</button><button data-clab-reset>Restaurar</button></div><div class="clab-body"><details class="clab-editor"><summary>Editar o programa</summary><textarea data-clab-program spellcheck="false" aria-label="Programa">${esc(s.program||'')}</textarea><small>${s.engine && s.engine!=="trace" ? "Execução nativa no Studio com o runtime instalado. Clique Executar; imports usam os pacotes da máquina." : "Python de aula, executado offline: listas, dicionários, funções, laços, math, heapq e deque. Para bibliotecas externas, escolha execução nativa."}</small></details><div class="clab-stage" aria-live="polite"></div></div><output class="clab-status"></output>${s.explanation?`<p class="gl-explanation">${esc(s.explanation)}</p>`:''}<script type="application/json" class="clab-model">${JSON.stringify({engine:s.engine||'trace',program:s.program||'',call:s.call||'',maxSteps:s.maxSteps||120}).replace(/</g,'\\u003c')}</script></div>`;}

package/src/code-language.js

@@ -0,0 +1,52 @@
+const EXTENSIONS = new Map([
+  [".py", "Python"],
+  [".pyw", "Python"],
+  [".java", "Java"],
+  [".js", "JavaScript"],
+  [".jsx", "JavaScript"],
+  [".mjs", "JavaScript"],
+  [".cjs", "JavaScript"],
+  [".ts", "TypeScript"],
+  [".tsx", "TypeScript"],
+  [".mts", "TypeScript"],
+  [".cts", "TypeScript"],
+  [".cs", "C#"],
+]);
+
+const ALIASES = new Map([
+  ["python", "Python"],
+  ["py", "Python"],
+  ["java", "Java"],
+  ["javascript", "JavaScript"],
+  ["js", "JavaScript"],
+  ["node", "JavaScript"],
+  ["nodejs", "JavaScript"],
+  ["typescript", "TypeScript"],
+  ["ts", "TypeScript"],
+  ["c#", "C#"],
+  ["csharp", "C#"],
+  ["cs", "C#"],
+]);
+
+export function inferCodeLanguage(filename) {
+  const basename = String(filename || "").trim().split(/[\\/]/).pop() || "";
+  const dot = basename.lastIndexOf(".");
+  if (dot <= 0) return "";
+  const extension = basename.slice(dot).toLowerCase();
+  return EXTENSIONS.get(extension) || "";
+}
+
+export function normalizeCodeLanguage(language) {
+  const key = String(language || "").trim().toLowerCase().replace(/[\s._-]/g, "");
+  return ALIASES.get(key) || "";
+}
+
+export function resolveCodeLanguage(language, filename) {
+  const requested = String(language || "").trim();
+  return requested ? normalizeCodeLanguage(requested) : inferCodeLanguage(filename);
+}
+
+export function displayCodeLanguage(language, filename) {
+  const requested = String(language || "").trim();
+  return normalizeCodeLanguage(requested) || requested || inferCodeLanguage(filename);
+}

package/src/csv.js

@@ -0,0 +1,74 @@
+// CSV como o Excel abre: descobre o separador (vírgula, ponto e vírgula, tab ou barra; a linha "sep=;" do Excel
+// manda), respeita aspas (separador, aspas "" e quebra de linha dentro da célula), guarda BOM e fim de linha para
+// gravar de volta igual. Serve ao motor (tabelas e pontos do deck) e ao Studio (planilha do projeto).
+
+const CANDIDATES = [",", ";", "\t", "|"];
+
+function splitRows(text, delim, limit = Infinity) {
+  const rows = [];
+  let row = [], cell = "", quoted = false, i = 0, wasQuoted = false;
+  const n = text.length;
+  while (i < n && rows.length < limit) {
+    const c = text[i];
+    if (quoted) {
+      if (c === '"') { if (text[i + 1] === '"') { cell += '"'; i += 2; continue; } quoted = false; i++; continue; }
+      cell += c; i++; continue;
+    }
+    if (c === '"' && cell.trim() === "" && !wasQuoted) { quoted = true; wasQuoted = true; cell = ""; i++; continue; }
+    if (c === delim) { row.push(cell); cell = ""; wasQuoted = false; i++; continue; }
+    if (c === "\r" || c === "\n") {
+      row.push(cell); rows.push(row); row = []; cell = ""; wasQuoted = false;
+      i += c === "\r" && text[i + 1] === "\n" ? 2 : 1; continue;
+    }
+    cell += c; i++;
+  }
+  if (rows.length < limit && (cell !== "" || row.length || wasQuoted)) { row.push(cell); rows.push(row); }
+  return rows;
+}
+
+export function detectDelimiter(text) {
+  const t = String(text ?? "").replace(/^/, "");
+  const sep = t.match(/^sep=(.)\r?\n/i);
+  if (sep) return sep[1];
+  let best = { d: ",", score: -1, width: 0 };
+  for (const d of CANDIDATES) {
+    const rows = splitRows(t, d, 40).filter((r) => r.some((c) => c.trim() !== ""));
+    if (!rows.length) continue;
+    const counts = new Map();
+    for (const r of rows) counts.set(r.length, (counts.get(r.length) || 0) + 1);
+    const [width, freq] = [...counts].sort((a, b) => b[1] - a[1] || b[0] - a[0])[0];
+    if (width < 2) continue;
+    const score = freq / rows.length;
+    if (score > best.score + 1e-9 || (Math.abs(score - best.score) < 1e-9 && width > best.width)) best = { d, score, width };
+  }
+  return best.d;
+}
+
+export function parseCSV(text, delimiter) {
+  let t = String(text ?? "");
+  const bom = t.startsWith("");
+  if (bom) t = t.slice(1);
+  const eol = /\r\n/.test(t) ? "\r\n" : "\n";
+  const d = delimiter || detectDelimiter(t);
+  let sepLine = false;
+  const m = t.match(/^sep=(.)\r?\n/i);
+  if (m) { sepLine = true; t = t.slice(m[0].length); }
+  let rows = splitRows(t, d);
+  while (rows.length && rows.at(-1).every((c) => c === "")) rows.pop();
+  const width = Math.max(0, ...rows.map((r) => r.length));
+  rows = rows.map((r) => (r.length < width ? [...r, ...Array(width - r.length).fill("")] : r));
+  return { rows, delimiter: d, eol, bom, sepLine };
+}
+
+export function toCSV(rows, { delimiter = ",", eol = "\n", bom = false, sepLine = false } = {}) {
+  const needs = (c) => c.includes(delimiter) || c.includes('"') || c.includes("\n") || c.includes("\r") || /^\s|\s$/.test(c);
+  const line = (r) => r.map((c) => { const s = String(c ?? ""); return needs(s) ? `"${s.replace(/"/g, '""')}"` : s; }).join(delimiter);
+  let out = (sepLine ? `sep=${delimiter}${eol}` : "") + rows.map(line).join(eol) + (rows.length ? eol : "");
+  if (bom) out = "" + out;
+  return out;
+}
+
+export const DELIMITER_NAMES = { ",": "vírgula", ";": "ponto e vírgula", "\t": "tab", "|": "barra" };
+
+// no Studio (carregado como módulo): o mesmo leitor para o realce e para colar na planilha
+if (typeof window !== "undefined") window.SagaCSV = { detect: detectDelimiter, parse: parseCSV, stringify: toCSV };

package/src/decision-lab.js

@@ -0,0 +1,20 @@
+import './runtime/decision-lab.js';
+import { esc } from './markup.js';
+export const calculateDecisionLab = globalThis.SagaDecisionLab.calculate;
+export function decisionLabHTML(input = {}) {
+  const v = globalThis.SagaDecisionLab.normalize(input), r = calculateDecisionLab(v);
+  const fmt = n => n.toLocaleString('pt-BR', { maximumFractionDigits: 1 });
+  const controls = [
+    ['errorRate', 'Erros da automação (%)', 100, .1],
+    ['reviewRate', 'Casos revisados (%)', 100, 1],
+    ['catchRate', 'Erros que o revisor corrige (%)', 100, 1],
+    ['introducedRate', 'Acertos que o revisor estraga (%)', 100, .1],
+  ];
+  return `<div class="decision-lab" data-decision-lab="${esc(JSON.stringify(v))}">
+    <div class="dl-controls">${controls.map(([key,label,max,step]) => `<label>${label}<output data-output="${key}">${fmt(v[key])}</output><input aria-label="${label}" data-param="${key}" type="range" min="0" max="${max}" step="${step}" value="${v[key]}"></label>`).join('')}<button type="button" data-reset>Restaurar premissas</button></div>
+    <div class="dl-results" aria-live="polite"><div class="dl-compare"><article><span>Automação sozinha</span><strong data-output="automatic">${fmt(r.automatic)}</strong><small>erros esperados</small></article><article><span>Com revisão</span><strong data-output="reviewed">${fmt(r.reviewed)}</strong><small>erros esperados</small></article></div>
+    <p class="dl-verdict" data-verdict>${fmt(Math.abs(r.delta))} erros ${r.delta > 0 ? 'a mais' : 'a menos'} com revisão</p>
+    <p class="dl-detail"><b data-output="caught">${fmt(r.caught)}</b> corrigidos · <b data-output="introduced">${fmt(r.introduced)}</b> introduzidos<br><b data-output="hours">${fmt(r.hours)}</b> horas de revisão</p></div>
+    <div class="dl-assumptions">Simulação hipotética · ${fmt(v.volume)} decisões · ${fmt(v.seconds)} s/revisão · taxas constantes, revisão sem seleção por risco. Não estima danos nem filas.</div>
+  </div>`;
+}

package/src/deck-file.js

@@ -0,0 +1,119 @@
+// Gravar o .yaml do deck sem estragar o arquivo.
+//
+// O arquivo é da pessoa: pode ter comentários, estilos ({ a: 1 } numa linha, blocos |) e ordem própria. Regravar tudo
+// com YAML.stringify apaga isso e, a cada salvamento, "mexe" em slides que ninguém tocou. Aqui:
+//   1. o arquivo atual é aberto como documento YAML e só os nós que MUDARAM são trocados (campo a campo, item a item);
+//      slides iguais, inclusive movidos de lugar, são reaproveitados com comentários e formatação;
+//   2. linhas intocadas voltam byte a byte (a biblioteca só normaliza o espaço antes de um comentário);
+//   3. o texto final é relido e comparado com o deck: se não bater, grava o deck inteiro (correção primeiro);
+//   4. a troca é atômica: escreve num temporário ao lado e renomeia (nunca fica um arquivo pela metade).
+import fs from "node:fs";
+import path from "node:path";
+import { isDeepStrictEqual } from "node:util";
+import YAML from "yaml";
+
+const same = (a, b) => isDeepStrictEqual(a, b);
+const isObj = (v) => v && typeof v === "object" && !Array.isArray(v);
+const publicOf = (spec) => Object.fromEntries(Object.entries(JSON.parse(JSON.stringify(spec))).filter(([k]) => !k.startsWith("_")));
+
+export const fullYaml = (spec) => YAML.stringify(publicOf(spec), { indent: 2 });
+
+// troca o valor de um par chave/valor mantendo o nó (e o comentário) quando os dois lados são escalares
+function setValue(doc, map, key, oldVal, newVal) {
+  const node = map.get(key, true);
+  if (YAML.isScalar(node) && !isObj(newVal) && !Array.isArray(newVal) && !isObj(oldVal) && !Array.isArray(oldVal)) {
+    node.value = newVal;
+    if (typeof newVal === "string" && newVal.includes("\n")) node.type = "BLOCK_LITERAL";
+    return;
+  }
+  if (YAML.isMap(node) && isObj(oldVal) && isObj(newVal)) return syncMap(doc, node, oldVal, newVal);
+  if (YAML.isSeq(node) && Array.isArray(oldVal) && Array.isArray(newVal)) return syncSeq(doc, node, oldVal, newVal);
+  map.set(key, doc.createNode(newVal));
+}
+
+function syncMap(doc, map, oldObj, newObj) {
+  for (const k of Object.keys(oldObj)) if (!(k in newObj)) map.delete(k);
+  for (const [k, v] of Object.entries(newObj)) {
+    if (!(k in oldObj)) map.set(k, doc.createNode(v));
+    else if (!same(oldObj[k], v)) setValue(doc, map, k, oldObj[k], v);
+  }
+}
+
+// Itens de lista: primeiro reaproveita os iguais (mesmo que tenham mudado de lugar), depois edita no lugar os que
+// estão na mesma posição e são do mesmo tipo (mesmo layout), e só então cria nós novos.
+function syncSeq(doc, seq, oldArr, newArr) {
+  const nodes = seq.items, used = new Set(), out = new Array(newArr.length);
+  newArr.forEach((v, j) => {
+    let best = -1;
+    oldArr.forEach((o, i) => { if (!used.has(i) && same(o, v) && (best < 0 || Math.abs(i - j) < Math.abs(best - j))) best = i; });
+    if (best >= 0) { used.add(best); out[j] = nodes[best]; }
+  });
+  newArr.forEach((v, j) => {
+    if (out[j]) return;
+    const o = oldArr[j];
+    if (j < oldArr.length && !used.has(j) && isObj(o) && isObj(v) && o.layout === v.layout && YAML.isMap(nodes[j])) {
+      used.add(j); syncMap(doc, nodes[j], o, v); out[j] = nodes[j];
+    } else if (j < oldArr.length && !used.has(j) && !isObj(o) && !Array.isArray(o) && !isObj(v) && !Array.isArray(v) && YAML.isScalar(nodes[j])) {
+      used.add(j); nodes[j].value = v; out[j] = nodes[j];
+    } else out[j] = doc.createNode(v);
+  });
+  seq.items = out;
+}
+
+// A biblioteca normaliza espaços (antes de comentário, dentro de [ ] e { }). Linha cujo conteúdo sem espaços é igual
+// ao de uma linha do arquivo original volta como estava. Seguro: se uma troca dessas mudasse o sentido, a releitura
+// em deckText não bateria com o deck e a gravação cairia na escrita completa.
+function keepOriginalSpacing(original, text) {
+  const norm = (l) => l.replace(/\s+/g, "");
+  const pool = new Map();
+  for (const l of original.split("\n")) { const k = norm(l); if (!pool.has(k)) pool.set(k, []); pool.get(k).push(l); }
+  return text.split("\n").map((l) => { const q = pool.get(norm(l)); return q && q.length ? q.shift() : l; }).join("\n");
+}
+
+export function deckText(spec, currentText) {
+  const want = publicOf(spec);
+  if (currentText != null) {
+    try {
+      const doc = YAML.parseDocument(currentText);
+      if (!doc.errors.length && YAML.isMap(doc.contents)) {
+        const have = doc.toJS() || {};
+        if (same(have, want)) return currentText; // nada mudou: o arquivo fica intocado
+        syncMap(doc, doc.contents, have, want);
+        const text = keepOriginalSpacing(currentText, doc.toString({ lineWidth: 0 }));
+        if (same(YAML.parse(text), want)) return text;
+      }
+    } catch { /* cai na escrita completa */ }
+  }
+  return fullYaml(want);
+}
+
+// Portátil: caminho absoluto que aponta para DENTRO da pasta do deck vira relativo (mudar a pasta de lugar ou mandar
+// para outra pessoa não quebra). Fora da pasta fica como está (o .sagadeck empacotado traz esses para dentro).
+const FILE_KEYS = new Set(["image", "foreground", "src", "file", "audio", "video", "css", "widgets", "poster"]);
+const isAbs = (p) => typeof p === "string" && (path.isAbsolute(p) || /^[A-Za-z]:[\\/]/.test(p)) && !/^[a-z]+:\/\//i.test(p);
+export function relativizePaths(spec, deckDir) {
+  const dir = path.resolve(deckDir);
+  const fix = (p) => {
+    if (!isAbs(p)) return p;
+    const rel = path.relative(dir, path.resolve(p));
+    return rel && !rel.startsWith("..") && !path.isAbsolute(rel) ? rel.split(path.sep).join("/") : p;
+  };
+  const walk = (v, key) => {
+    if (Array.isArray(v)) return v.map((x) => (FILE_KEYS.has(key) && typeof x === "string" ? fix(x) : walk(x, key)));
+    if (v && typeof v === "object") return Object.fromEntries(Object.entries(v).map(([k, x]) => [k, FILE_KEYS.has(k) && typeof x === "string" ? fix(x) : walk(x, k)]));
+    return v;
+  };
+  return walk(spec, "");
+}
+
+// grava de forma atômica: temporário na mesma pasta + rename (no Windows, rename substitui o destino)
+export function writeDeckFile(file, spec) {
+  let current = null;
+  try { current = fs.readFileSync(file, "utf8"); } catch { /* arquivo novo */ }
+  const text = deckText(relativizePaths(publicOf(spec), path.dirname(file)), current);
+  if (text === current) return false;
+  const tmp = path.join(path.dirname(file), `.${path.basename(file)}.${process.pid}.${Date.now()}.tmp`);
+  fs.writeFileSync(tmp, text, "utf8");
+  try { fs.renameSync(tmp, file); } catch (e) { fs.rmSync(tmp, { force: true }); throw e; }
+  return true;
+}

package/src/diagram/napkin-examples.js

@@ -0,0 +1,13 @@
+// Exemplos do "Diagrama de texto" — usados pelo Studio (cartões de exemplo) e pela suíte de testes.
+// Cada exemplo diz qual layout as regras locais (sem IA) devem escolher.
+export const NAPKIN_EXAMPLES = {
+  steps: { label: "Processo", layout: "steps", text: "Etapas do atendimento:\n1. Cliente abre chamado pelo app\n2. Triagem automática classifica a urgência\n3. Especialista responde em até 2 h\n4. Cliente avalia o atendimento" },
+  funnel: { label: "Funil", layout: "funnel", text: "Funil de vendas do trimestre:\n- Visitas ao site: 120 mil\n- Cadastros: 18 mil\n- Reuniões: 2.400\n- Contratos: 900" },
+  stats: { label: "Números", layout: "stats", text: "Resultados do trimestre:\n- Receita: +42%\n- ARR: R$ 8,4 mi\n- Churn mensal: 0,6%\n- NPS: 91" },
+  compare: { label: "Antes × depois", layout: "compare", text: "Antes vs depois da automação:\n- Relatório levava 3 dias vs sai em 2 horas\n- 12 planilhas manuais vs um painel único\n- Erros de digitação vs dados validados na origem" },
+  timeline: { label: "Linha do tempo", layout: "timeline", text: "Nossa história:\n2019 — fundação com 3 pessoas\n2021 — primeiro cliente grande\n2023 — expansão para o Chile\n2026 — 200 pessoas e 4 países" },
+  cards: { label: "Pilares", layout: "cards", text: "3 pilares da estratégia:\n1. Segurança: criptografia de ponta a ponta\n2. Velocidade: resposta em menos de 1 segundo\n3. Simplicidade: nada de manual" },
+  pyramid: { label: "Pirâmide", layout: "pyramid", text: "Pirâmide de necessidades do cliente:\n- Topo: encantamento\n- Meio: conveniência\n- Base: confiança e segurança" },
+  matrix: { label: "Matriz 2×2", layout: "matrix", text: "Priorização por impacto e esforço:\n- Alto impacto, pouco esforço: fazer já\n- Alto impacto, muito esforço: planejar\n- Baixo impacto, pouco esforço: delegar\n- Baixo impacto, muito esforço: evitar" },
+  agenda: { label: "Agenda", layout: "agenda", text: "Agenda do workshop:\n1. Abertura (10 min)\n2. O problema (20 min)\n3. Mão na massa (40 min)\n4. Próximos passos (10 min)" },
+};