sagadeck 1.2.0

package/src/studio/public/art-preview.js

@@ -0,0 +1,10 @@
+// Cada direção tem seu próprio CSS: a prévia não muda o tema do editor nem das outras opções.
+window.SagaArtPreview = (container, rendered, label) => {
+  const frame = document.createElement('iframe');
+  frame.title = `Prévia: ${label}`;
+  frame.setAttribute('sandbox', '');
+  frame.style.cssText = 'width:1920px;height:1080px;border:0;transform-origin:0 0;pointer-events:none;position:absolute;left:0;top:0';
+  frame.srcdoc = `<!doctype html><html class="export"><meta charset="utf-8"><style>${rendered.baseCSS}\n${rendered.themeCSS}\nhtml,body{margin:0;width:1920px;height:1080px}.slide{opacity:1!important;visibility:visible!important;transform:none!important}</style><body>${rendered.html}</body></html>`;
+  container.replaceChildren(frame);
+  frame.style.transform = `scale(${container.clientWidth / 1920})`;
+};

package/src/studio/public/calc-fields.js

@@ -0,0 +1,11 @@
+// Formulário das experiências; carregado antes de slide-form.js.
+window.SagaCalcFields = (f, obj) => [f.text("kicker", "Chapéu"), f.text("title", "Título"), f.json("inputs", "Entradas", { rows: 8, hint: "{ V: { label, value, min, max, step, unit, latex }, nu: { value, fixed: true } } — cada entrada vira um controle deslizante (fixed: constante)." }),
+      f.list("outputs", "Resultados (na ordem: um pode usar os anteriores)", obj([f.text("name", "Nome (para usar nas fórmulas)", { mono: true }), f.text("label", "Rótulo"), f.text("fn", "Fórmula", { mono: true, placeholder: "V*D/nu" }), f.text("latex", "Fórmula para mostrar (LaTeX)", { mono: true }), f.text("unit", "Unidade"), f.num("decimals", "Casas decimais"),
+        f.more([f.text("of", "Faixas de qual valor?", { mono: true }), f.json("cases", "Faixas", { hint: "[{ below: 2300, text: Laminar, color: s3 }, { text: Turbulento, color: hi }] — ou fn por faixa" }), f.json("scale", "Régua", { hint: "{ min: 100, max: 1000000, log: true }" })])]),
+        { addLabel: "Adicionar resultado", newItem: () => ({ name: "r", label: "Resultado", fn: "" }) }),
+      f.text("prediction", "Pergunta antes de revelar"),
+      f.text("sweep", "Entrada no eixo da curva", { hint: "Nome da entrada; as outras ficam nos valores atuais." }),
+      f.text("explanation", "O que observar ao explorar"),
+      f.bool("illustrative", "Simulação ilustrativa"),
+      f.list("scenarios", "Cenários", obj([f.text("label", "Nome"), f.json("values", "Valores das entradas", { hint: '{ "V": 0.02 }' }), f.text("explanation", "O que este cenário mostra")]), { addLabel: "Adicionar cenário", newItem: () => ({ label: "Novo cenário", values: {} }) }),
+      f.text("note", "Nota embaixo")];

package/src/studio/public/chat-progress.js

@@ -0,0 +1,47 @@
+window.SagaChatProgress = function ({ dom, appendChatMessage, hydrateIcons, getChatJob }) {
+  function createProgressBubble(initial) {
+    const el = appendChatMessage("ai", "");
+    el.classList.add("ai-working");
+    const content = el.querySelector(".ai-content");
+    content.innerHTML = `<div class="work-line"><span class="work-dots"><i></i><i></i><i></i></span><span class="work-text"></span><span class="work-time">0s</span></div><div class="work-preview"></div>`;
+    const text = content.querySelector(".work-text");
+    const time = content.querySelector(".work-time");
+    const preview = content.querySelector(".work-preview");
+    const started = Date.now();
+    text.textContent = initial;
+    const timer = setInterval(() => {
+      const s = Math.round((Date.now() - started) / 1000);
+      time.textContent = `${s}s`;
+    }, 500);
+    return {
+      el,
+      update(ev) {
+        if (ev.type !== "progress") return;
+        text.textContent = ev.chars ? `${ev.text} (${(ev.chars / 1000).toFixed(1)} mil caracteres)` : ev.text;
+        // transformação da apresentação inteira: pode levar muitos minutos, então dá para parar (o feito fica guardado)
+        if (String(ev.phase || "").startsWith("transform") && !getChatJob() && !content.querySelector(".work-stop")) {
+          const stop = document.createElement("button");
+          stop.type = "button"; stop.className = "btn btn-ghost btn-sm work-stop";
+          stop.title = "Parar; o que já ficou pronto fica guardado e pedir de novo continua de onde parou";
+          stop.innerHTML = '<i class="ic" data-ic="square"></i> Parar'; hydrateIcons(stop);
+          stop.onclick = async () => { stop.disabled = true; await fetch("api/ai/transform/cancel", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ mode: ev.mode }) }).catch(() => {}); };
+          content.querySelector(".work-line").append(stop);
+        }
+        if (ev.preview) preview.textContent = ev.preview;
+        dom.chatMessages.scrollTop = dom.chatMessages.scrollHeight;
+      },
+      done() { clearInterval(timer); el.remove(); },
+      fail(msg) {
+        clearInterval(timer);
+        el.classList.remove("ai-working");
+        content.innerHTML = "";
+        const span = document.createElement("span");
+        span.style.color = "var(--danger)";
+        span.textContent = `Erro: ${msg}`;
+        content.appendChild(span);
+      },
+    };
+  }
+
+return createProgressBubble;
+};

package/src/studio/public/developer-fields.js

@@ -0,0 +1,22 @@
+window.SagaDeveloperFields = {
+  poll: (f,T)=>[f.text('kicker','Chapéu'),f.area('question','Pergunta'),f.text('context','Contexto'),f.list('options','Opções',T,{addLabel:'Adicionar opção'}),f.text('hint','Dica'),f.bool('manual','Decisão da reunião (contagens e aprovação salvas)'),f.json('values','Valores numéricos por opção (opcional)'),f.text('participantTitle','Título para divulgação'),f.select('audience','Visibilidade',[['organization','Só organização'],['all','Organização e participantes']],{empty:'Ambos'}),f.more([f.text('id','Identificador da enquete'),f.text('compare','Comparar com a enquete (identificador)'),f.num('titleSize','Tamanho da pergunta (px)')])],
+  portal: (f,obj) => [f.text('title','Título'),f.select('skin','Aparência',[['aurora','Aurora — claro e colorido'],['neon','Neon'],['editorial','Editorial'],['industrial','Industrial']],{empty:false,default:'neon'}),f.text('label','Convite no cenário'),f.text('caption','Legenda inicial'),f.list('items','Elementos para explorar',obj([f.text('title','Nome'),f.text('icon','Ícone Lucide'),f.photo('image','Sua imagem ou screenshot'),f.area('text','Descrição'),f.text('beforeWord','Texto integrado antes'),f.text('afterWord','Texto integrado depois'),f.area('before','Explicação antes'),f.area('after','Explicação depois'),f.list('objects','Objetos da transformação',obj([f.text('label','Nome'),f.text('icon','Ícone'),f.select('shape','Forma',[['panel','Painel'],['sheet','Documento'],['orb','Esfera'],['column','Coluna']],{empty:'Painel'})]),{newItem:()=>({label:'Nova etapa'})})]),{newItem:()=>({title:'Novo mundo',beforeWord:'ANTES',afterWord:'DEPOIS',objects:[{label:'Uma ideia'},{label:'Uma solução'}]})})],
+  playground: f => [f.text('title','Título'),f.area('html','HTML',{mono:true,rows:8}),f.area('css','CSS',{mono:true,rows:8}),f.area('javascript','JavaScript',{mono:true,rows:12}),f.area('explanation','Convite para explorar')],
+  collection: (f,obj,getCtx) => [
+    f.action('Importar coleção Postman', (s,button) => {
+      const ctx=getCtx(),input=document.createElement('input');input.type='file';input.accept='.json,application/json';input.hidden=true;input.dataset.collectionFile='';document.body.append(input);
+      input.onchange=async()=>{try{const file=input.files[0];if(!file)return;s.services=window.SagaApiCollections.importCollection(await file.text());if(button.isConnected)ctx.commit(true);}catch(e){button.textContent=e.message;}finally{input.remove();}};input.click();
+    }),
+    f.list('services','Serviços da coleção',obj([f.text('name','Nome no seletor'),f.text('id','Identificador'),f.select('mode','Modo',[['sync','Síncrono'],['polling','Polling'],['stream','Streaming']],{empty:'Síncrono'}),f.obj('request','Pedido',[f.select('method','Método',[['GET','GET'],['POST','POST'],['PUT','PUT'],['PATCH','PATCH'],['DELETE','DELETE']],{empty:'GET'}),f.text('url','Endpoint'),f.json('body','Corpo JSON'),f.json('headers','Cabeçalhos JSON')]),f.json('polling','Configuração de polling'),f.json('stream','Configuração de streaming')]),{addLabel:'Adicionar serviço',newItem:()=>({name:'Novo serviço',request:{method:'GET',url:'{{base}}/'}})})
+  ],
+  video: (f,getCtx) => [f.text('kicker','Chapéu'),f.text('title','Título'),f.text('url','YouTube ou arquivo local'),f.text('label','Descrição do vídeo'),f.select('start','Início da reprodução',[['manual','Clique para iniciar'],['normal','Controles de vídeo']],{empty:'Controles de vídeo'}),f.select('finish','Ao terminar',[['next','Ir para o próximo slide'],['reveal','Revelar a capa por baixo'],['stay','Permanecer neste slide']],{empty:'Permanecer neste slide'}),f.num('handoffAt','Passar ao próximo no tempo (segundos)',{min:0,step:0.01}),f.select('controls','Controles da abertura',[['stage','Palco: clique ou Espaço, sem botões'],['visible','Botões visíveis']],{empty:'Botões visíveis'}),f.photo('poster','Imagem inicial'),f.bool('loop','Loop silencioso automático'),
+    f.action('Inserir meu MP4',(s,button)=>{
+      const ctx=getCtx(),input=document.createElement('input');input.type='file';input.accept='video/mp4,.mp4';input.hidden=true;input.dataset.videoFile='';document.body.append(input);
+      input.onchange=async()=>{try{const file=input.files[0];if(!file)return;const url=await window.SagaProject.uploadFile(file,'videos');if(button.isConnected){s.url=url;ctx.commit(true);}}catch(e){button.textContent=e.message;}finally{input.remove();}};input.click();
+    }),
+    f.action('Baixar YouTube para MP4',async(s,button)=>{
+      const ctx=getCtx(),label=button.textContent;button.disabled=true;button.textContent='Baixando vídeo…';
+      try{const r=await fetch('api/video/download',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({url:s.url})}),data=await r.json();if(!r.ok)throw new Error(data.error);if(button.isConnected){s.youtubeSource=data.source;s.url=data.url;ctx.commit(true);}}
+      catch(e){button.textContent=e.message;return;}finally{button.disabled=false;}button.textContent=label;
+    }),f.text('caption','Legenda'),f.el('figure','Figura')]
+};

package/src/studio/public/explorer.js

@@ -0,0 +1,443 @@
+/* Projeto no estilo VS Code: a pasta da apresentação vira uma árvore de arquivos (à esquerda, no lugar dos slides)
+   e cada arquivo abre numa aba no centro.
+   - Apresentação (sempre a primeira aba): o slide, como sempre.
+   - texto da apresentação (.yaml): editor à esquerda e o slide à direita, atualizando enquanto digita.
+   - texto e código (.md, .txt, .json, .yaml, .py, .js, .css, .html…): editor com números de linha e realce
+     (viewers.js); o .md com a prévia ao lado.
+   - planilha (.csv, .tsv, .xlsx): grade como no Excel (separador descoberto; csv/tsv editáveis, gravam no mesmo
+     formato), o tipo de cada coluna e sugestões de gráfico com prévia (regras ou IA); "Inserir no slide" cria o
+     gráfico ligado à planilha (from:, com Atualizar). "Texto" mostra o arquivo cru, cada coluna de uma cor.
+   - PDF: as páginas (pdf.js do próprio Studio). DOCX: o documento para ler (edição fica no Word).
+   - imagem: a prévia e "Usar num slide".
+   Ctrl+V de um print (fora de um campo de texto) guarda em contexto/. Tudo o que está em contexto/ vai para a IA. */
+(function () {
+  let ctx = null;
+  let treeData = null;
+  const openTabs = []; // { path, kind, name, dirty, text, sheet }
+  let active = "__deck__";
+  const expanded = new Set(["contexto"]);
+  const $ = (s, r = document) => r.querySelector(s);
+  const esc = (s) => String(s ?? "").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+  const api = async (url, body) => {
+    const r = await fetch(url, body === undefined ? {} : { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(body) });
+    const j = await r.json().catch(() => ({}));
+    if (!r.ok || j.error) throw new Error(j.error || `erro ${r.status}`);
+    return j;
+  };
+  const KIND_ICON = { deck: "presentation", md: "file-text", text: "file-code", sheet: "file-spreadsheet", image: "file-image", pdf: "file-text", docx: "file-text", pptx: "presentation", other: "file" };
+  const LANG_LABEL = { json: "JSON", yaml: "YAML", md: "Markdown", js: "JavaScript", py: "Python", css: "CSS", html: "HTML", xml: "XML", sql: "SQL", sh: "Shell", ini: "Config", csv: "CSV", tsv: "TSV", c: "C / Java", m: "MATLAB", tex: "LaTeX", plain: "Texto" };
+  const fileUrl = (p) => `api/project/file?path=${encodeURIComponent(p)}&t=${Date.now()}`;
+  const readAsDataUrl = (file) => new Promise((ok, bad) => { const fr = new FileReader(); fr.onload = () => ok(fr.result); fr.onerror = bad; fr.readAsDataURL(file); });
+
+  // ------------------------------------------------------------------ árvore
+  async function refreshTree() {
+    const host = $("#project-tree");
+    try { treeData = await api("api/project/tree"); }
+    catch (e) { treeData = null; host.innerHTML = `<div class="ex-empty">${esc(e.message)}</div>`; return; }
+    host.innerHTML = `<div class="ex-root" title="${esc(treeData.name)}"><i class="ic" data-ic="folder-open"></i><b>${esc(treeData.name)}</b></div>${renderEntries(treeData.entries, 0)}`;
+    ctx.hydrate(host);
+  }
+  const rowActions = (e) => e.protected ? "" : `<span class="ex-acts"><i class="ic" data-ic="pencil" data-act="rename" role="button" aria-label="Renomear ${esc(e.name)}" title="Renomear (F2)"></i><i class="ic" data-ic="trash-2" data-act="delete" role="button" aria-label="Apagar ${esc(e.name)}" title="Apagar (Delete)"></i></span>`;
+  function renderEntries(list, depth) {
+    return list.map((e) => {
+      const pad = `style="padding-left:${10 + depth * 14}px"`;
+      const sel = selected === e.path ? " sel" : "";
+      if (e.type === "dir") {
+        const open = expanded.has(e.path);
+        return `<div class="ex-row ex-dir${e.protected ? " ex-protected" : ""}${sel}" data-path="${esc(e.path)}" data-type="dir" draggable="${!e.protected}" ${pad} title="${e.protected ? "Pasta do Studio (conversa, cache e lixeira do projeto): só some junto com o projeto" : esc(e.path)}"><i class="ic ex-caret" data-ic="${open ? "chevron-down" : "chevron-right"}"></i><i class="ic" data-ic="folder"></i><span class="ex-name">${esc(e.name)}</span>${rowActions(e)}</div>${open ? renderEntries(e.children || [], depth + 1) : ""}`;
+      }
+      return `<div class="ex-row ex-file${e.protected ? " ex-protected" : ""}${active === e.path ? " active" : ""}${sel}" data-path="${esc(e.path)}" data-type="file" data-kind="${e.kind}" draggable="${!e.protected}" ${pad} title="${esc(e.path)}"><i class="ic" data-ic="${KIND_ICON[e.kind] || "file"}"></i><span class="ex-name">${esc(e.name)}</span>${rowActions(e)}</div>`;
+    }).join("");
+  }
+  const findEntry = (p, list = treeData?.entries || []) => { for (const e of list) { if (e.path === p) return e; if (e.children) { const f = findEntry(p, e.children); if (f) return f; } } return null; };
+  const dirOf = (p) => { const e = findEntry(p); return !p ? "" : e?.type === "dir" ? p : p.split("/").slice(0, -1).join("/"); };
+  let selected = "";
+  const rowOf = (p) => $(`#project-tree .ex-row[data-path="${CSS.escape(p)}"]`);
+  function select(p, { focus = true } = {}) {
+    selected = p;
+    $("#project-tree").querySelectorAll(".ex-row.sel").forEach((r) => r.classList.remove("sel"));
+    const row = rowOf(p);
+    row?.classList.add("sel");
+    row?.scrollIntoView({ block: "nearest" });
+    if (focus) $("#project-tree").focus({ preventScroll: true });
+  }
+  function openRow(row) {
+    if (row.dataset.type === "dir") { expanded.has(row.dataset.path) ? expanded.delete(row.dataset.path) : expanded.add(row.dataset.path); refreshTree(); }
+    else openFile(row.dataset.path, row.dataset.kind);
+  }
+
+  function bindTree() {
+    const host = $("#project-tree");
+    host.addEventListener("click", (ev) => {
+      if (ev.target.closest(".ex-edit")) return;
+      const row = ev.target.closest(".ex-row"); if (!row) return;
+      const act = ev.target.closest("[data-act]")?.dataset.act;
+      select(row.dataset.path);
+      if (act === "rename") return renameEntry(row.dataset.path);
+      if (act === "delete") return deleteEntry(row.dataset.path);
+      openRow(row);
+    });
+    // teclado como no VS Code: setas andam, Enter abre, F2 renomeia, Delete apaga
+    host.addEventListener("keydown", (ev) => {
+      if (ev.target.closest(".ex-edit")) return;
+      const rows = [...host.querySelectorAll(".ex-row")], i = rows.findIndex((r) => r.dataset.path === selected);
+      const row = rows[i];
+      if (ev.key === "ArrowDown" || ev.key === "ArrowUp") { ev.preventDefault(); const n = rows[Math.max(0, Math.min(rows.length - 1, i + (ev.key === "ArrowDown" ? 1 : -1)))]; if (n) select(n.dataset.path); return; }
+      if (!row) return;
+      if (ev.key === "ArrowRight" && row.dataset.type === "dir" && !expanded.has(selected)) { ev.preventDefault(); expanded.add(selected); refreshTree(); }
+      else if (ev.key === "ArrowLeft" && row.dataset.type === "dir" && expanded.has(selected)) { ev.preventDefault(); expanded.delete(selected); refreshTree(); }
+      else if (ev.key === "Enter") { ev.preventDefault(); openRow(row); }
+      else if (ev.key === "F2") { ev.preventDefault(); renameEntry(selected); }
+      else if (ev.key === "Delete") { ev.preventDefault(); deleteEntry(selected); }
+    });
+    host.addEventListener("contextmenu", (ev) => {
+      ev.preventDefault();
+      const row = ev.target.closest(".ex-row");
+      if (row) select(row.dataset.path, { focus: false });
+      menuAt(ev, row);
+    });
+    host.addEventListener("dblclick", (ev) => { const row = ev.target.closest(".ex-row.ex-file"); if (row && !row.classList.contains("ex-protected") && ev.target.closest(".ex-name")) renameEntry(row.dataset.path); });
+    // arrastar: arquivo do computador para uma pasta (envia) ou item da árvore para outra pasta (move)
+    host.addEventListener("dragstart", (ev) => { const row = ev.target.closest(".ex-row"); if (row) ev.dataTransfer.setData("text/x-saga-path", row.dataset.path); });
+    host.addEventListener("dragover", (ev) => { ev.preventDefault(); host.querySelectorAll(".drop").forEach((r) => r.classList.remove("drop")); ev.target.closest(".ex-dir")?.classList.add("drop"); });
+    host.addEventListener("dragleave", () => host.querySelectorAll(".drop").forEach((r) => r.classList.remove("drop")));
+    host.addEventListener("drop", async (ev) => {
+      ev.preventDefault();
+      host.querySelectorAll(".drop").forEach((r) => r.classList.remove("drop"));
+      const dir = ev.target.closest(".ex-dir")?.dataset.path ?? "contexto";
+      const moving = ev.dataTransfer.getData("text/x-saga-path");
+      try {
+        if (moving) { if (dirOf(moving) !== dir) { await api("api/project/move", { path: moving, dir }); expanded.add(dir); } }
+        else for (const f of ev.dataTransfer.files) await uploadFile(f, dir);
+        refreshTree();
+      } catch (e) { ctx.toast(e.message); }
+    });
+  }
+  // botão direito: o mesmo menu do resto do Studio
+  function menuAt(ev, row) {
+    const p = row?.dataset.path || "", prot = !!row?.classList.contains("ex-protected"), isDir = row ? row.dataset.type === "dir" : true;
+    const here = row ? (isDir ? p : dirOf(p)) : "";
+    const items = [
+      row && !isDir && { label: "Abrir", ic: "folder-open", fn: () => openFile(p, row.dataset.kind) },
+      !prot && { label: "Novo arquivo", ic: "file-plus", fn: () => newFile(here || "contexto") },
+      !prot && { label: "Nova pasta", ic: "folder-plus", fn: () => newFolder(here) },
+      !prot && { label: "Enviar arquivos para cá", ic: "upload", fn: () => { uploadTarget = here || "contexto"; $("#ex-upload-input").click(); } },
+      row && { sep: true },
+      row && !prot && { label: "Renomear", ic: "pencil", key: "F2", fn: () => renameEntry(p) },
+      row && { label: "Copiar caminho", ic: "copy", fn: () => navigator.clipboard?.writeText(p).then(() => ctx.toast(`Copiado: ${p}`)) },
+      row && !isDir && row.dataset.kind === "image" && { label: "Usar num slide", ic: "plus", fn: () => ctx.insertSlide({ layout: "image", image: p, title: p.split("/").pop().replace(/\.[a-z0-9]+$/i, "") }) },
+      row && !prot && { sep: true },
+      row && !prot && { label: "Apagar", ic: "trash-2", key: "Delete", danger: true, fn: () => deleteEntry(p) },
+    ].filter(Boolean);
+    ctx.contextMenu(ev, items);
+  }
+  // campo de nome dentro da árvore (renomear e criar), como no VS Code: Enter confirma, Esc desiste
+  function inlineName(anchorRow, initial, { depth = 0, icon = "file", create = false } = {}) {
+    return new Promise((resolve) => {
+      const input = Object.assign(document.createElement("input"), { className: "ex-edit", value: initial, spellcheck: false });
+      input.setAttribute("aria-label", create ? "Nome do novo item" : "Novo nome");
+      let row = anchorRow, holder;
+      if (create || !row) {
+        holder = document.createElement("div");
+        holder.className = "ex-row ex-new";
+        holder.style.paddingLeft = `${10 + depth * 14}px`;
+        holder.innerHTML = `<i class="ic" data-ic="${icon}"></i>`;
+        holder.append(input);
+        (anchorRow ? anchorRow.after(holder) : $("#project-tree").append(holder));
+        ctx.hydrate(holder);
+      } else {
+        row.classList.add("editing");
+        row.querySelector(".ex-name").replaceWith(input);
+      }
+      input.focus();
+      const dot = initial.lastIndexOf(".");
+      input.setSelectionRange(0, dot > 0 ? dot : initial.length); // como no VS Code: seleciona o nome sem a extensão
+      let done = false;
+      const finish = (value) => { if (done) return; done = true; holder?.remove(); resolve(value); };
+      input.addEventListener("keydown", (ev) => {
+        ev.stopPropagation();
+        if (ev.key === "Enter") { ev.preventDefault(); finish(input.value.trim() || null); }
+        if (ev.key === "Escape") { ev.preventDefault(); finish(null); refreshTree(); }
+      });
+      input.addEventListener("blur", () => finish(input.value.trim() || null));
+    });
+  }
+  const depthOf = (p) => (p ? p.split("/").length : 0);
+  async function newFile(dir = dirOf(selected) || "contexto") {
+    expanded.add(dir); await refreshTree();
+    const name = await inlineName(dir ? rowOf(dir) : null, "anotações.md", { depth: depthOf(dir), icon: "file-text", create: true });
+    if (!name) return refreshTree();
+    try { const r = await api("api/project/create", { dir, name, text: "" }); await refreshTree(); select(r.path); openFile(r.path); } catch (e) { ctx.toast(e.message); refreshTree(); }
+  }
+  async function newFolder(dir = dirOf(selected)) {
+    if (dir) { expanded.add(dir); await refreshTree(); }
+    const name = await inlineName(dir ? rowOf(dir) : null, "nova pasta", { depth: depthOf(dir), icon: "folder", create: true });
+    if (!name) return refreshTree();
+    try { const r = await api("api/project/mkdir", { dir, name }); expanded.add(r.path); await refreshTree(); select(r.path); } catch (e) { ctx.toast(e.message); refreshTree(); }
+  }
+  async function renameEntry(p) {
+    const row = rowOf(p); if (!row || row.classList.contains("ex-protected")) return;
+    const cur = p.split("/").pop(), name = await inlineName(row, cur);
+    if (!name || name === cur) return refreshTree();
+    try {
+      const r = await api("api/project/rename", { path: p, name });
+      const t = openTabs.find((x) => x.path === p);
+      if (t) { t.path = r.path; t.name = r.path.split("/").pop(); if (active === p) active = r.path; renderTabs(); }
+      if (expanded.has(p)) { expanded.delete(p); expanded.add(r.path); }
+      await refreshTree(); select(r.path);
+    } catch (e) { ctx.toast(e.message); refreshTree(); }
+  }
+  // apagar: sem pergunta (vai para a lixeira do projeto) e com Desfazer
+  async function deleteEntry(p) {
+    const row = rowOf(p); if (!row || row.classList.contains("ex-protected")) return;
+    const rows = [...$("#project-tree").querySelectorAll(".ex-row")], i = rows.indexOf(row);
+    try {
+      const r = await api("api/project/delete", { path: p });
+      closeTab(p, true);
+      await refreshTree();
+      const next = rows[i + 1] || rows[i - 1];
+      if (next && rowOf(next.dataset.path)) select(next.dataset.path);
+      ctx.toast(`"${p.split("/").pop()}" foi para a lixeira do projeto.`, 8000, { label: "Desfazer", fn: async () => { await api("api/project/restore", { path: r.trashed }); await refreshTree(); select(p); } });
+    } catch (e) { ctx.toast(e.message); }
+  }
+  let uploadTarget = null;
+  async function uploadFile(file, dir = "contexto") {
+    const r = await api("api/project/upload", { dir, name: file.name, dataUrl: await readAsDataUrl(file) });
+    expanded.add(dir);
+    return r.path;
+  }
+  // print colado: vai para contexto/ com data e hora no nome (e a IA passa a ver o texto dos documentos de lá)
+  async function savePastedImage(blob) {
+    const stamp = new Date().toISOString().slice(0, 19).replace("T", " ").replace(/:/g, "-");
+    const ext = (blob.type.split("/")[1] || "png").replace("jpeg", "jpg");
+    const path = await uploadFile(new File([blob], `print ${stamp}.${ext}`, { type: blob.type }), "contexto");
+    await refreshTree();
+    return path;
+  }
+
+  // ------------------------------------------------------------------ abas
+  function renderTabs() {
+    const bar = $("#doc-tabs");
+    bar.innerHTML = `<button type="button" class="doc-tab${active === "__deck__" ? " active" : ""}" data-doc="__deck__"><i class="ic" data-ic="presentation"></i><span>Apresentação</span></button>` +
+      openTabs.map((t) => `<button type="button" class="doc-tab${active === t.path ? " active" : ""}" data-doc="${esc(t.path)}" title="${esc(t.path)}"><i class="ic" data-ic="${KIND_ICON[t.kind] || "file"}"></i><span>${esc(t.name)}</span>${t.dirty ? '<span class="doc-dirty" aria-label="não gravado"></span>' : ""}<i class="ic doc-close" data-ic="x" data-close="${esc(t.path)}" role="button" aria-label="Fechar ${esc(t.name)}"></i></button>`).join("");
+    ctx.hydrate(bar);
+  }
+  function bindTabs() {
+    $("#doc-tabs").addEventListener("click", (ev) => {
+      const c = ev.target.closest("[data-close]"); if (c) { ev.stopPropagation(); closeTab(c.dataset.close); return; }
+      const t = ev.target.closest("[data-doc]"); if (t) activate(t.dataset.doc);
+    });
+    $("#doc-tabs").addEventListener("auxclick", (ev) => { const t = ev.target.closest("[data-doc]"); if (ev.button === 1 && t && t.dataset.doc !== "__deck__") closeTab(t.dataset.doc); });
+  }
+  function closeTab(p, force = false) {
+    const i = openTabs.findIndex((t) => t.path === p); if (i < 0) return;
+    if (!force && openTabs[i].dirty && !confirm("Fechar sem gravar as mudanças?")) return;
+    openTabs.splice(i, 1);
+    if (active === p) activate(openTabs[i - 1]?.path || openTabs[i]?.path || "__deck__");
+    else renderTabs();
+  }
+  async function openFile(p, kind) {
+    kind = kind || findEntry(p)?.kind || "other";
+    if (!openTabs.some((t) => t.path === p)) openTabs.push({ path: p, kind, name: p.split("/").pop() });
+    await activate(p);
+  }
+  async function activate(p) {
+    active = p;
+    renderTabs();
+    $("#project-tree")?.querySelectorAll(".ex-file").forEach((r) => r.classList.toggle("active", r.dataset.path === p));
+    const editor = $("#canvas-stage-wrapper"), view = $("#doc-view");
+    editor.classList.remove("doc-side", "doc-full");
+    if (p === "__deck__") { view.innerHTML = ""; view.classList.add("hidden"); ctx.relayout(); return; }
+    const t = openTabs.find((x) => x.path === p);
+    view.classList.remove("hidden");
+    editor.classList.add(t.kind === "deck" ? "doc-side" : "doc-full");
+    try {
+      if (t.kind === "deck") await showDeckText(view, t);
+      else if (t.kind === "md" || t.kind === "text" || (t.kind === "sheet" && t.asText)) await showText(view, t);
+      else if (t.kind === "sheet") await showSheet(view, t);
+      else if (t.kind === "image") showImage(view, t);
+      else if (t.kind === "pdf") await showPdf(view, t);
+      else if (t.kind === "docx") await showDocx(view, t);
+      else view.innerHTML = `<div class="dv-info"><i class="ic" data-ic="file"></i><b>${esc(t.name)}</b><p>O texto deste arquivo vai como material para a IA.</p><a class="btn btn-small" href="${fileUrl(t.path)}" download="${esc(t.name)}">Baixar</a></div>`;
+    } catch (e) { view.innerHTML = `<div class="dv-info">${esc(e.message)}</div>`; }
+    ctx.hydrate(view);
+    ctx.relayout();
+  }
+
+  // ------------------------------------------------------------------ editores de texto
+  let deckTimer = 0;
+  async function showDeckText(view, t) {
+    const r = await (await fetch("api/deck")).json();
+    view.innerHTML = `<div class="dv-head"><i class="ic" data-ic="presentation"></i><b>${esc(t.name)}</b><span class="dv-status" id="dv-status">o slide ao lado atualiza enquanto você digita</span></div>`;
+    const { wrap, ta, paint } = window.SagaViewers.codeEditor({ text: r.yaml || "", highlighter: (v) => ctx.highlightYaml(v).replace(/\n$/, "") });
+    ta.id = "deck-text-editor";
+    view.append(wrap);
+    ta.addEventListener("input", () => {
+      clearTimeout(deckTimer);
+      deckTimer = setTimeout(async () => {
+        const st = $("#dv-status");
+        try {
+          const res = await fetch("api/deck", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ yaml: ta.value }) });
+          const j = await res.json();
+          if (!res.ok || !j.ok) throw new Error(j.error || "YAML inválido");
+          st.textContent = "aplicado"; st.classList.remove("error");
+          await ctx.reloadDeck();
+        } catch (e) { st.textContent = e.message; st.classList.add("error"); }
+      }, 450);
+    });
+    t.refresh = async () => { if (document.activeElement === ta) return; const r2 = await (await fetch("api/deck")).json(); if (r2.yaml !== ta.value) { ta.value = r2.yaml; paint(); } };
+  }
+  // markdown simples para a prévia (títulos, listas, negrito, itálico, código, links)
+  function mdToHtml(src) {
+    const inline = (s) => esc(s).replace(/`([^`]+)`/g, "<code>$1</code>").replace(/\*\*([^*]+)\*\*/g, "<b>$1</b>").replace(/\*([^*]+)\*/g, "<i>$1</i>").replace(/\[([^\]]+)\]\((https?:[^)]+)\)/g, '<a href="$2" target="_blank" rel="noopener">$1</a>');
+    const out = []; let list = null, code = null;
+    for (const line of String(src).split("\n")) {
+      if (code) { if (/^```/.test(line)) { out.push(`<pre>${esc(code.join("\n"))}</pre>`); code = null; } else code.push(line); continue; }
+      if (/^```/.test(line)) { code = []; continue; }
+      const li = line.match(/^\s*[-*]\s+(.*)$/) || line.match(/^\s*\d+[.)]\s+(.*)$/);
+      if (li) { if (!list) { list = []; } list.push(`<li>${inline(li[1])}</li>`); continue; }
+      if (list) { out.push(`<ul>${list.join("")}</ul>`); list = null; }
+      const h = line.match(/^(#{1,4})\s+(.*)$/);
+      if (h) out.push(`<h${h[1].length}>${inline(h[2])}</h${h[1].length}>`);
+      else if (line.trim()) out.push(`<p>${inline(line)}</p>`);
+    }
+    if (list) out.push(`<ul>${list.join("")}</ul>`);
+    if (code) out.push(`<pre>${esc(code.join("\n"))}</pre>`);
+    return out.join("");
+  }
+  async function showText(view, t) {
+    const text = t.text ?? (await (await fetch(fileUrl(t.path))).text());
+    const md = t.kind === "md";
+    const lang = window.SagaViewers.langOf(t.name);
+    const asGrid = t.kind === "sheet" ? `<button type="button" class="btn btn-small" data-as-grid title="Ver como planilha"><i class="ic" data-ic="table"></i> Planilha</button>` : "";
+    view.innerHTML = `<div class="dv-head"><i class="ic" data-ic="${KIND_ICON[t.kind]}"></i><b>${esc(t.name)}</b><span class="dv-lang">${esc(LANG_LABEL[lang] || lang)}</span><span class="dv-status" id="dv-status">grava sozinho</span>${asGrid}</div><div class="dv-split${md ? "" : " one"}"></div>`;
+    view.querySelector("[data-as-grid]")?.addEventListener("click", () => { t.asText = false; t.text = undefined; activate(t.path); });
+    const split = view.querySelector(".dv-split");
+    const { wrap, ta } = window.SagaViewers.codeEditor({ text, lang });
+    ta.classList.add("dv-text");
+    ta.dataset.path = t.path;
+    split.append(wrap);
+    const prev = md ? Object.assign(document.createElement("div"), { className: "dv-md" }) : null;
+    if (prev) { prev.innerHTML = mdToHtml(text); split.append(prev); }
+    let timer = 0;
+    ta.addEventListener("input", () => {
+      t.text = ta.value; t.dirty = true; renderTabs();
+      if (prev) prev.innerHTML = mdToHtml(ta.value);
+      clearTimeout(timer);
+      timer = setTimeout(async () => {
+        try { await api("api/project/write", { path: t.path, text: ta.value }); t.dirty = false; renderTabs(); $("#dv-status").textContent = "gravado"; }
+        catch (e) { $("#dv-status").textContent = e.message; }
+      }, 500);
+    });
+  }
+  function showImage(view, t) {
+    view.innerHTML = `<div class="dv-head"><i class="ic" data-ic="file-image"></i><b>${esc(t.name)}</b><button type="button" class="btn btn-small" data-use-image><i class="ic" data-ic="plus"></i> Usar num slide</button></div><div class="dv-img"><img src="${fileUrl(t.path)}" alt="${esc(t.name)}"></div>`;
+    view.querySelector("[data-use-image]").onclick = () => ctx.insertSlide({ layout: "image", image: t.path, title: t.name.replace(/\.[a-z0-9]+$/i, "") });
+  }
+
+  // ------------------------------------------------------------------ planilha + sugestões de gráfico
+  const TYPE_LABEL = { number: "número", percent: "porcentagem", date: "tempo", category: "categoria", text: "texto" };
+  async function showSheet(view, t) {
+    const data = await api(`api/project/sheet?path=${encodeURIComponent(t.path)}&all=1`);
+    const sheet = data.sheets.find((s) => s.name === t.sheet) || data.sheets[0];
+    t.sheet = sheet.name;
+    const complete = sheet.rows.length >= sheet.total;
+    const editable = data.editable && complete;
+    const tabs = data.sheets.length > 1 ? `<div class="sh-tabs">${data.sheets.map((s) => `<button type="button" class="sh-tab${s.name === sheet.name ? " active" : ""}" data-sheet="${esc(s.name)}">${esc(s.name)}</button>`).join("")}</div>` : "";
+    const cols = sheet.columns;
+    const DELIM = { ",": "vírgula", ";": "ponto e vírgula", "\t": "tab", "|": "barra" };
+    const sepInfo = data.delimiter ? ` · separado por ${DELIM[data.delimiter] || data.delimiter}` : "";
+    const asText = /\.(csv|tsv)$/i.test(t.name) ? `<button type="button" class="btn btn-small" data-as-text title="Ver o arquivo como texto"><i class="ic" data-ic="file-code"></i> Texto</button>` : "";
+    view.innerHTML = `<div class="dv-head"><i class="ic" data-ic="file-spreadsheet"></i><b>${esc(t.name)}</b><span class="dv-status" id="dv-status">${sheet.total} linhas · ${cols.length} colunas${sepInfo}${editable ? "" : " · só leitura"}</span>${asText}<button type="button" class="btn btn-small" data-toggle-suggest title="Gráficos que fazem sentido com estes dados"><i class="ic" data-ic="chart-column"></i> Gráficos</button></div>${tabs}
+      <div class="sh-body${t.hideSuggest ? " no-suggest" : ""}"><div class="sh-grid-wrap" id="sh-grid"></div>
+      <aside class="sh-suggest"><div class="sh-suggest-head"><b>Gráficos que fazem sentido</b><button type="button" class="btn btn-small" data-ai-suggest title="A IA confere o tipo das colunas e sugere gráficos, títulos e nomes dos eixos"><i class="ic" data-ic="sparkles"></i> Sugerir com IA</button></div><div class="sh-cards" id="sh-cards"><div class="ex-empty">Olhando as colunas…</div></div></aside></div>`;
+    const types = [];
+    for (const c of cols) types[c.index] = { type: c.type, label: TYPE_LABEL[c.type] || c.type };
+    let timer = 0;
+    window.SagaViewers.sheetGrid(view.querySelector("#sh-grid"), {
+      rows: sheet.rows, editable, hasHeader: sheet.hasHeader, types,
+      onChange: (rows) => {
+        const st = $("#dv-status"); st.textContent = "gravando…"; t.dirty = true; renderTabs();
+        clearTimeout(timer);
+        timer = setTimeout(async () => {
+          try { await api("api/project/sheet-write", { path: t.path, rows }); t.dirty = false; renderTabs(); st.textContent = `gravado${sepInfo}`; st.classList.remove("error"); }
+          catch (e) { st.textContent = e.message; st.classList.add("error"); }
+        }, 500);
+      },
+    });
+    view.querySelectorAll("[data-sheet]").forEach((b) => b.onclick = () => { t.sheet = b.dataset.sheet; activate(t.path); });
+    view.querySelector("[data-as-text]")?.addEventListener("click", () => { t.asText = true; t.text = undefined; activate(t.path); });
+    view.querySelector("[data-toggle-suggest]").onclick = () => { t.hideSuggest = !t.hideSuggest; view.querySelector(".sh-body").classList.toggle("no-suggest", t.hideSuggest); };
+    view.querySelector("[data-ai-suggest]").onclick = (ev) => loadSuggestions(t, true, ev.currentTarget);
+    ctx.hydrate(view);
+    loadSuggestions(t, false);
+  }
+  async function showPdf(view, t) {
+    view.innerHTML = `<div class="dv-head"><i class="ic" data-ic="file-text"></i><b>${esc(t.name)}</b><a class="btn btn-small" href="${fileUrl(t.path)}" download="${esc(t.name)}" title="Baixar o PDF"><i class="ic" data-ic="download"></i></a></div><div class="pv" id="pv-host"></div>`;
+    ctx.hydrate(view);
+    await window.SagaViewers.pdfView(view.querySelector("#pv-host"), fileUrl(t.path), { name: t.name });
+    ctx.hydrate(view);
+  }
+  async function showDocx(view, t) {
+    const { html } = await api(`api/project/docx?path=${encodeURIComponent(t.path)}`);
+    view.innerHTML = `<div class="dv-head"><i class="ic" data-ic="file-text"></i><b>${esc(t.name)}</b><span class="dv-status">só leitura (edite no Word)</span><a class="btn btn-small" href="${fileUrl(t.path)}" download="${esc(t.name)}" title="Baixar o documento"><i class="ic" data-ic="download"></i></a></div><div class="dx" id="dx-host"></div>`;
+    window.SagaViewers.docxView(view.querySelector("#dx-host"), html);
+  }
+  async function loadSuggestions(t, ai, btn) {
+    const host = $("#sh-cards"); if (!host) return;
+    if (btn) { btn.disabled = true; btn.classList.add("busy"); }
+    if (ai) host.insertAdjacentHTML("afterbegin", '<div class="ex-empty sh-thinking">A IA está olhando as colunas…</div>');
+    try {
+      const r = await api("api/project/chart-suggestions", { path: t.path, sheet: t.sheet, ai });
+      if (active !== t.path) return;
+      if (r.ai?.columns?.length) r.ai.columns.forEach((c) => { const chip = document.querySelector(`[data-col-type="${CSS.escape(c.nome)}"]`); if (chip && c.tipo) { chip.textContent = `${c.tipo} · IA`; chip.classList.add("by-ai"); } });
+      if (!r.suggestions.length) { host.innerHTML = '<div class="ex-empty">Não achei um gráfico que faça sentido com estas colunas. Precisa de ao menos uma coluna de números.</div>'; return; }
+      host.innerHTML = r.suggestions.map((s, i) => `<article class="sh-card${s.ai ? " by-ai" : ""}"><div class="sh-prev lc-prev"><div class="thumb-render">${s.html || ""}</div></div><div class="sh-card-body"><b>${esc(s.title)}</b>${s.ai ? '<span class="sh-ai f-label">IA</span>' : ""}<p>${esc(s.why)}</p><button type="button" class="btn btn-primary btn-sm" data-insert="${i}"><i class="ic" data-ic="plus"></i> Inserir no slide</button></div></article>`).join("");
+      host.querySelectorAll("[data-insert]").forEach((b) => b.onclick = () => { ctx.insertSlide(r.suggestions[+b.dataset.insert].slide); ctx.toast("Gráfico inserido depois do slide atual (ligado à planilha: Formatar › Atualizar da planilha)."); });
+      host.querySelectorAll(".sh-prev").forEach((el) => scaleObs.observe(el));
+      host.querySelectorAll(".pl, mark, .chart").forEach((e) => e.classList.add("play")); // a prévia já mostra o gráfico desenhado
+      ctx.hydrate(host);
+    } catch (e) { host.querySelector(".sh-thinking")?.remove(); ctx.toast(e.message); }
+    finally { if (btn) { btn.disabled = false; btn.classList.remove("busy"); } }
+  }
+  const scaleObs = new ResizeObserver((es) => es.forEach(({ target }) => { if (target.clientWidth) target.style.setProperty("--thumb-scale", String(target.clientWidth / 1920)); }));
+
+  // ------------------------------------------------------------------ montagem
+  function setView(which) {
+    const files = which === "files";
+    $("#rail-tab-slides").classList.toggle("active", !files);
+    $("#rail-tab-files").classList.toggle("active", files);
+    $("#thumbnails-list").classList.toggle("hidden", files);
+    $("#project-explorer").classList.toggle("hidden", !files);
+    $("#btn-add-slide-mini").classList.toggle("hidden", files);
+    try { localStorage.setItem("sagadeck.railView", which); } catch {}
+    if (files) refreshTree();
+  }
+  function setup(c) {
+    ctx = c;
+    $("#rail-tab-slides").onclick = () => setView("slides");
+    $("#rail-tab-files").onclick = () => setView("files");
+    $("#ex-new-file").onclick = () => newFile();
+    $("#ex-new-folder").onclick = () => newFolder();
+    $("#ex-refresh").onclick = () => refreshTree();
+    const up = $("#ex-upload-input");
+    $("#ex-upload").onclick = () => up.click();
+    up.onchange = async () => { try { const dir = uploadTarget ?? (dirOf(selected) || "contexto"); uploadTarget = null; for (const f of up.files) await uploadFile(f, dir); up.value = ""; refreshTree(); ctx.toast("Arquivo no projeto."); } catch (e) { ctx.toast(e.message); } };
+    window.SagaViewers.contextMenu = (ev, items) => ctx.contextMenu(ev, items);
+    bindTree(); bindTabs(); renderTabs();
+    // Ctrl+V de print em qualquer lugar do editor (fora de campo de texto): vai para contexto/
+    document.addEventListener("paste", async (ev) => {
+      if (ev.defaultPrevented || ev.target.closest?.("input, textarea, [contenteditable], #chat-form")) return;
+      const img = [...(ev.clipboardData?.items || [])].find((it) => it.kind === "file" && it.type.startsWith("image/"));
+      if (!img) return;
+      ev.preventDefault();
+      try { const p = await savePastedImage(img.getAsFile()); ctx.toast(`Print guardado em ${p}. A IA vê o que está em contexto/.`, 6000, { label: "Abrir", fn: () => { setView("files"); openFile(p, "image"); } }); }
+      catch (e) { ctx.toast(e.message); }
+    });
+    setView("slides"); // ao abrir, a barra da esquerda mostra os slides (Arquivos é um clique)
+  }
+  // o deck mudou por outro caminho (formulário, IA, arrastar): a aba do texto da apresentação acompanha
+  function deckChanged() { openTabs.find((t) => t.kind === "deck")?.refresh?.(); }
+  const wantsPaste = () => !$("#project-explorer").classList.contains("hidden") || active !== "__deck__";
+  window.SagaProject = { setup, refreshTree, openFile, deckChanged, savePastedImage, uploadFile, wantsPaste, activeTab: () => active };
+})();

package/src/studio/public/history.js

@@ -0,0 +1,58 @@
+// Desfazer / refazer único do Studio: TODA mudança do deck (formulário, arrastar na tela, YAML, IA, transformação,
+// revisão, estilo) vira um passo, com um rótulo que diz de onde veio. O histórico é por apresentação (outra abre,
+// ele recomeça). Digitação seguida no mesmo campo vira um passo só. Serve ao Studio e aos testes (Node).
+(function (root) {
+  // onde duas versões diferem (caminhos até as folhas, poucos níveis): digitar no mesmo campo muda sempre o mesmo
+  // caminho; arrastar e depois apagar o objeto mudam caminhos diferentes (dx × hidden) e viram dois passos
+  function diffPaths(a, b, path = "", out = [], depth = 6) {
+    if (out.length > 24) return out;
+    if (a === b) return out;
+    const oa = a && typeof a === "object", ob = b && typeof b === "object";
+    if (!oa || !ob || depth === 0 || Array.isArray(a) !== Array.isArray(b) || (Array.isArray(a) && a.length !== b.length)) { out.push(path); return out; }
+    for (const k of new Set([...Object.keys(a), ...Object.keys(b)])) if (JSON.stringify(a[k]) !== JSON.stringify(b[k])) diffPaths(a[k], b[k], `${path}/${k}`, out, depth - 1);
+    return out;
+  }
+  function createHistory({ limit = 100, coalesceMs = 1500, now = () => Date.now() } = {}) {
+    let undo = [], redo = [], current = null, key = undefined, lastAt = 0, lastLabel = null, lastWhere = null;
+    const api = {
+      // começa de novo (apresentação aberta)
+      reset(deck, file) { undo = []; redo = []; current = deck ? JSON.stringify(deck) : null; key = file; lastLabel = null; },
+      // registra o estado atual; outra apresentação recomeça o histórico. Devolve true se virou um passo novo.
+      note(deck, label = "Edição", file = key) {
+        if (file !== key) { api.reset(deck, file); return false; }
+        const json = JSON.stringify(deck);
+        if (current === null) { current = json; return false; }
+        if (json === current) return false;
+        const t = now();
+        const where = diffPaths(JSON.parse(current), deck).sort().join("|");
+        const merge = label === lastLabel && label === "Edição" && t - lastAt < coalesceMs && where === lastWhere && undo.length;
+        if (!merge) { undo.push({ json: current, label }); if (undo.length > limit) undo.shift(); }
+        redo = []; current = json; lastAt = t; lastLabel = label; lastWhere = where;
+        return !merge;
+      },
+      // o servidor completou o deck (uid de slide novo, ajuste levado junto): o estado atual é esse, sem passo novo
+      rebase(deck) { current = JSON.stringify(deck); },
+      undo() {
+        if (!undo.length) return null;
+        const e = undo.pop();
+        redo.push({ json: current, label: e.label });
+        current = e.json; lastLabel = null;
+        return { deck: JSON.parse(e.json), label: e.label };
+      },
+      redo() {
+        if (!redo.length) return null;
+        const e = redo.pop();
+        undo.push({ json: current, label: e.label });
+        current = e.json; lastLabel = null;
+        return { deck: JSON.parse(e.json), label: e.label };
+      },
+      get canUndo() { return undo.length > 0; },
+      get canRedo() { return redo.length > 0; },
+      get undoLabel() { return undo.at(-1)?.label || null; },
+      get redoLabel() { return redo.at(-1)?.label || null; },
+      get size() { return undo.length; },
+    };
+    return api;
+  }
+  root.SagaHistory = { createHistory };
+})(typeof globalThis !== "undefined" ? globalThis : window);