sagadeck 1.2.0 → 1.3.0

package/src/runtime/motion.js

@@ -9,7 +9,7 @@ for(const frame of document.querySelectorAll('iframe[data-motion]')){
   const begin=e=>{if(!slide?.classList.contains('current')||done||e.target.closest('input,textarea,select,[contenteditable=true]'))return;if(e.type==='keydown'&&![' ','Enter','ArrowRight','PageDown'].includes(e.key))return;e.preventDefault();e.stopImmediatePropagation();if(started){finish();return;}started=true;send('start');};
   document.addEventListener('keydown',begin,true);slide.addEventListener('click',begin,true);
  }
- window.addEventListener('message',e=>{if(e.source!==frame.contentWindow)return;if(e.data?.sagaMotion==='done')finish();if(e.data?.sagaMotion==='start-request'&&slide?.classList.contains('current')&&!done){if(started)finish();else{started=true;send('start');}}});
+ window.addEventListener('message',e=>{if(e.source!==frame.contentWindow)return;if(e.data?.sagaMotion==='done')finish();if(e.data?.sagaMotion==='ready')activate();if(e.data?.sagaMotion==='start-request'&&slide?.classList.contains('current')&&!done){if(started)finish();else{started=true;send('start');}}});
  const activate=()=>{const active=slide?.classList.contains('current');send('active',active);if(document.documentElement.classList.contains('export')||document.documentElement.dataset.motion==='none'||matchMedia('(prefers-reduced-motion: reduce)').matches)send('poster');if(!active){started=false;done=false;frame.style.visibility='';send('reset');}};
  frame.addEventListener('load',activate);if(slide)new MutationObserver(activate).observe(slide,{attributes:true,attributeFilter:['class']});
 }

package/src/runtime/runtime.js

@@ -809,8 +809,21 @@
       document.body.classList.add("mouse"); clearTimeout(mt); mt = setTimeout(() => document.body.classList.remove("mouse"), 1600);
       const l = $("#laser"); l.style.left = e.clientX + "px"; l.style.top = e.clientY + "px";
     });
-    let tx = null; document.addEventListener("touchstart", (e) => (tx = e.touches[0].clientX));
-    document.addEventListener("touchend", (e) => { if (tx == null) return; const d = e.changedTouches[0].clientX - tx; if (Math.abs(d) > 50) cmd(d < 0 ? "next" : "prev"); tx = null; });
+    // Mobile: arrastar pro lado troca de slide; tocar (sem arrastar) avança. Toque em controle
+    // (botão, link, campo, vídeo, widget, ir-para) continua sendo do controle, nunca avança.
+    let tx = null, ty = null, tt = 0;
+    document.addEventListener("touchstart", (e) => { const t = e.touches[0]; tx = t.clientX; ty = t.clientY; tt = Date.now(); }, { passive: true });
+    document.addEventListener("touchend", (e) => {
+      if (tx == null) return;
+      const t = e.changedTouches[0], dx = t.clientX - tx, dy = t.clientY - ty, dt = Date.now() - tt;
+      tx = ty = null;
+      if (Math.abs(dx) > 50 && Math.abs(dx) > Math.abs(dy)) { cmd(dx < 0 ? "next" : "prev"); return; }
+      if (Math.abs(dx) < 12 && Math.abs(dy) < 12 && dt < 500 && !e.target.closest("a,button,input,textarea,select,[contenteditable],video,audio,iframe,.widget,[data-goto]")) {
+        const sel = typeof getSelection === "function" && getSelection();
+        if (sel && !sel.isCollapsed) return; // selecionando texto: não avança
+        cmd("next");
+      }
+    }, { passive: true });
     const [i, k] = parseHash();
     slides.forEach((s) => s.classList.remove("current"));
     cur = -1;

package/src/studio/ai-chat-route.js

@@ -0,0 +1,158 @@
+// Chat lateral de IA (/api/ai/chat, /api/ai/chat/cancel): SSE, trabalhos canceláveis,
+// pesquisa fase 2, materiais, testes de slides api e junção a três. Saiu de server.js (P1);
+// o servidor passa o estado (ctx). Devolve true quando atendeu.
+import fs from "node:fs";
+import path from "node:path";
+import crypto from "node:crypto";
+import { loadSpec } from "../build.js";
+import { writeRecording } from "../api-client.js";
+import { editDeck } from "../ai/deck-ai.js";
+import { reviewExperience } from "../ai/quality.js";
+import { maybeResearch } from "../research/chat-research.js";
+import { chatErrorResult } from "./errors.js";
+import { cancellable, respond } from "./ai-response.js";
+import { prepareDocumentMaterials, takeMaterials } from "../ai/document-materials.js";
+import { styleAction } from "./style-routes.js";
+import * as Project from "./project.js";
+import { carryVisualEdits } from "./visual-keys.js";
+
+export async function aiChatRoutes({ req, res, pathname, url, W, readJSON, staleTab, llmAvailable, llmConfig, lookAt, withBase, apiBlocked, ensureEnsaio, readPastedLinks, imageOptions, apiContextFor, commandRunner, diagramCheck, slideSnapshots, persist, isBundledTemplate, runTransform, transforms, apiEnv }) {
+  if (pathname === "/api/ai/chat/cancel" && req.method === "POST") {
+    const body = await readJSON(req);
+    const job = W.aiChats?.get(body.requestId);
+    job?.abort();
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ ok: true, stopped: !!job }));
+    return true;
+  }
+  if (pathname === "/api/ai/chat" && req.method === "POST") {
+    const body = await readJSON(req);
+    if (staleTab(body, W, res)) return true;
+    const owner = W;
+    owner.aiChats ||= new Map();
+    const requestId = body.requestId || crypto.randomUUID();
+    const controller = new AbortController();
+    owner.aiChats.set(requestId, controller);
+    const signal = controller.signal;
+    const onClose = () => { if (!res.writableEnded && !['melhorar','recriar'].some(m => transforms.has(`${taskWorkspace.file}|${m}`))) controller.abort(); };
+    res.on('close', onClose);
+    // Capture o arquivo da tarefa: abrir outro deck não redireciona a escrita.
+    const taskWorkspace = { ...owner, spec: structuredClone(owner.spec) };
+    const prompt = body.message || "";
+    const spec = body.spec || taskWorkspace.spec;
+    const issues = body.issues || [];
+    // a IA vê (e testa) os slides api no ambiente atual, que pode ser o embutido "ensaio"
+    if (!apiBlocked(req) && (spec.slides || []).some((sl) => sl && sl.layout === "api")) await ensureEnsaio();
+
+    try { await respond(res, body.stream, async (send) => cancellable(async () => {
+      const emit = ev => { signal.throwIfAborted(); send(ev); };
+      let result;
+      const history = Array.isArray(body.history) ? body.history : [];
+      // o cache pode ter guardado uma queda de segundos do relay: confere de novo antes de desistir
+      if (!(await llmAvailable()) && !(await llmAvailable({ force: true }))) {
+        // Sem modelo, ninguém decide nada: nem "o que é X?" nem "resuma" viram edição por palavra-chave
+        // (as regras antigas trocavam o layout e enfiavam texto genérico no slide). O deck fica como está.
+        return {
+          reply: `A IA está desligada (nenhum LLM respondendo em ${llmConfig().url}), então não mexi em nada. Rode "modelrelay serve" ou defina SAGADECK_LLM_URL e mande de novo.`,
+          spec, actions: [], targetSlide: body.targetSlide, talk: true, mode: "off",
+        };
+      }
+      try {
+        const target = typeof body.targetSlide === "number" ? body.targetSlide : null;
+        const visuals = await lookAt(withBase(taskWorkspace, spec), target, prompt, emit);
+        // anexos: imagens vão como visão; documentos (id do /api/ai/context) vão como texto
+        let materials = await prepareDocumentMaterials(takeMaterials(taskWorkspace, (Array.isArray(body.attachments) ? body.attachments : [])
+          .filter((a) => a && typeof a === "object" && a.type === "doc").map((a) => a.id)), path.dirname(taskWorkspace.file), {signal,onProgress:emit});
+        for (const [i, url] of (Array.isArray(body.attachments) ? body.attachments : []).entries()) {
+          if (typeof url === "string" && url.startsWith("data:image/")) visuals.push({ label: `imagem colada pelo usuário ${i + 1}`, dataUrl: url });
+        }
+        // arquivos do projeto (contexto/): material para a IA, junto com os anexos da mensagem
+        const P = taskWorkspace.file && !isBundledTemplate(taskWorkspace.file) ? Project.projectOf(taskWorkspace.file) : null;
+        if (P) for (const doc of await Project.contextMaterials(P)) if (!materials.some((m) => m.name === doc.name || m.name === doc.name.split("/").pop())) materials.push(doc);
+        // links colados na mensagem: o servidor lê sozinho e conta nas ações
+        const linkActions = [];
+        for (const doc of await readPastedLinks(taskWorkspace, prompt, linkActions)) materials.push(doc);
+        // pesquisa na web no chat (fase 2): a IA decide se o que ela sabe basta; as fontes
+        // lidas entram nos materiais e a instrução de citação vai junto do pedido
+        const chatResearch = await maybeResearch({ prompt, materials, saveDir: taskWorkspace.file && !isBundledTemplate(taskWorkspace.file) ? path.dirname(taskWorkspace.file) : null, onProgress: (s) => emit({ phase: "step", text: s }) });
+        materials = chatResearch.materials;
+        if (chatResearch.report?.fontes?.length) linkActions.push(`Pesquisa na web: ${chatResearch.report.fontes.length} fonte(s) (${chatResearch.report.fontes.map((f) => f.site).join(", ")})`);
+        result = await editDeck({
+          spec: withBase(taskWorkspace, spec), signal,
+          instruction: chatResearch.instruction ? `${chatResearch.instruction}\n${prompt}` : prompt,
+          targetSlide: target,
+          issues,
+          images: true, // a IA decide (regra no prompt: só quando pedirem ou aceitarem)
+          imageOptions: imageOptions(taskWorkspace, withBase(taskWorkspace, spec)),
+          history,
+          onProgress: emit,
+          visuals,
+          materials,
+          renderNotes: Array.isArray(body.renderNotes) ? body.renderNotes.slice(0, 8) : [],
+          apiContext: apiContextFor(req, taskWorkspace),
+          drawCheck: diagramCheck,
+          runCommand: commandRunner(req, emit, body, taskWorkspace, signal),
+          reviewCheck: (deck, indices) => reviewExperience(deck, indices, { snapshot: slideSnapshots, onProgress: emit, signal, briefing:prompt }),
+          styles: taskWorkspace.file && !isBundledTemplate(taskWorkspace.file) ? { list: taskWorkspace.library.listStyles(), current: taskWorkspace.spec?.style?.name || null } : null,
+        });
+        signal.throwIfAborted();
+        if (linkActions.length) result.actions = [...linkActions, ...(result.actions || [])];
+        // a IA decidiu transformar a apresentação inteira (transform:): o trabalho em etapas, com o andamento aqui
+        if (result.transform) {
+          const transformed = await runTransform(taskWorkspace, withBase(taskWorkspace, spec), result, emit, prompt, visuals.filter(v => v.label.startsWith("imagem colada pelo usuário")), signal);
+          return owner.file === taskWorkspace.file ? transformed : { ...transformed, spec: owner.spec, talk: true, reply: transformed.reply + '\nO resultado ficou no arquivo original; você está em outra apresentação.' };
+        }
+        // a IA decidiu mexer no estilo (estilo:): aplicar, salvar, tirar ou padrão das novas
+        if (result.style) return styleAction({ W: taskWorkspace, spec: withBase(taskWorkspace, spec), result, persist, isBundledTemplate });
+        // Slides api: a IA pediu para testar (test: [n]) → o Studio executa, devolve o relatório e ela
+        // corrige, até 3 rodadas. Quem decide testar e o que corrigir é a IA; aqui só executa.
+        const convo = [...history, { role: "user", text: prompt }]
+        for (let round = 1; result.test?.length && round <= 3; round++) {
+          if (apiBlocked(req)) { result.actions.push("Testes de slides api só no Studio local."); break; }
+          const reports = [];
+          for (const i of result.test) {
+            const slide = result.spec.slides[i];
+            emit({ phase: "test", text: `Testando o slide ${i + 1} (${apiEnv.currentName() || "sem ambiente"})…` });
+            const r = await apiEnv.runSlide(slide, { vars: taskWorkspace.apiVars || {}, deckDir: taskWorkspace.file ? path.dirname(taskWorkspace.file) : null });
+            signal.throwIfAborted();
+            if (r.saved) taskWorkspace.apiVars = { ...(taskWorkspace.apiVars || {}), ...r.saved };
+            if (r.record) {
+              const key = globalThis.SagadeckApiCore.key(slide);
+              if (taskWorkspace.file && !isBundledTemplate(taskWorkspace.file)) writeRecording(taskWorkspace.file, key, r.record);
+              else (taskWorkspace.apiRecordings = taskWorkspace.apiRecordings || {})[key] = { ...r.record, at: new Date().toISOString() };
+            }
+            reports.push({ slide: i + 1, ...r.report });
+            result.actions.push(`Teste do slide ${i + 1}: ${r.report.ok ? "funcionou" : "falhou, " + String(r.report.erro || (r.report.status ? `HTTP ${r.report.status}` : "falhou")).slice(0, 140)}`);
+          }
+          convo.push({ role: "assistant", text: result.reply });
+          const instruction = `Resultado do teste (rodada ${round} de 3), executado no ambiente ${apiEnv.currentName()}:\n\`\`\`json\n${JSON.stringify(reports, null, 2).slice(0, 12000)}\n\`\`\`\nSe algo falhou ou tem "NÃO EXISTE", corrija os slides com base na resposta real e peça test de novo. Se tudo funcionou, confirme em uma frase, sem yaml.`;
+          emit({ phase: "test", text: reports.every((x) => x.ok) ? "Os testes passaram; conferindo…" : "Corrigindo com base no resultado…" });
+          const next = await editDeck({
+            spec: withBase(taskWorkspace, result.spec), signal, instruction, targetSlide: target, images: false,
+            imageOptions: imageOptions(taskWorkspace, withBase(taskWorkspace, result.spec)), history: convo, onProgress: emit, apiContext: apiContextFor(req, taskWorkspace),
+            drawCheck: diagramCheck, runCommand: commandRunner(req, emit, body, taskWorkspace, signal),
+          });
+          convo.push({ role: "user", text: instruction });
+          result = { ...next, actions: [...result.actions, ...(next.actions || [])], spec: next.spec };
+        }
+        result.mode = "llm";
+      } catch (e) {
+        if (signal.aborted) return { reply: "Parado a pedido. Nenhuma resposta pendente foi aplicada.", spec, actions: [], talk: true, mode: "cancelled" };
+        // Falhou no meio: não "chuta" com as regras (poderiam fazer outra coisa); deck fica como estava.
+        console.error("[Studio] IA falhou:", e.message);
+        return chatErrorResult(e,spec,body.targetSlide);
+      }
+      // o que a pessoa salvou enquanto a IA pensava não some: junção a três (base = o que foi para a IA)
+      signal.throwIfAborted();
+      const current = taskWorkspace.file && fs.existsSync(taskWorkspace.file) ? loadSpec(taskWorkspace.file) : owner.spec;
+      const merged = globalThis.SagadeckMerge.mergeDecks(spec, current || spec, result.spec);
+      taskWorkspace.spec = merged.deck;
+      carryVisualEdits(spec, taskWorkspace.spec); // a IA mudou o texto de um objeto ajustado: o ajuste acompanha
+      persist(taskWorkspace);
+      if (owner.file === taskWorkspace.file) owner.spec = taskWorkspace.spec;
+      return { ...result, spec: taskWorkspace.spec, conflicts: merged.conflicts, kept: merged.kept };
+    }, signal)); } finally { owner.aiChats.delete(requestId); res.off("close", onClose); }
+    return true;
+  }
+  return false;
+}

package/src/studio/exporting.js

@@ -21,7 +21,7 @@ export function sendHtml(res,spec,audience){
 
 // Gera e envia um arquivo da apresentação. PPTX/PDF/roteiro usam o Chrome invisível (os mesmos
 // exportadores de "sagadeck pptx | pdf | roteiro"), numa pasta temporária.
-export async function sendExport(res, kind, spec, name, { notes = true, inline = false, audience } = {}) {
+export async function sendExport(res, kind, spec, name, { notes = true, inline = false, audience, macFonts = false } = {}) {
   spec=meetingSpec(spec,audience);
   const cd = (file) => `attachment; filename="${slugify(file.replace(/\.\w+$/, ""))}${path.extname(file)}"; filename*=UTF-8''${encodeURIComponent(file)}`;
   if (kind === "sagadeck") {
@@ -52,7 +52,7 @@ export async function sendExport(res, kind, spec, name, { notes = true, inline =
       const out = path.join(tmp, `saida-${what}`);
       if (what === "pptx") {
         const { exportPptx } = await import("../export/pptx.js");
-        errors.push(...(await exportPptx(htmlFile, out, { theme: r.theme, meta: { ...r.meta, slides: r.slidesMeta }, notes })).errors);
+        errors.push(...(await exportPptx(htmlFile, out, { theme: r.theme, meta: { ...r.meta, slides: r.slidesMeta }, notes, fontFallback: macFonts ? "mac" : undefined })).errors);
       } else if (what === "pdf") {
         const { pdf } = await import("../export/shots.js");
         // Preferências › Exportação: tema escuro com par claro (manual-noite → manual) sai claro no PDF, bom para imprimir

package/src/studio/library-routes.js

@@ -0,0 +1,158 @@
+// Rotas da biblioteca (/api/library/*): tópicos, decks, capas, download, importação e geração com IA.
+// Saiu de server.js (P1 monolitos); o servidor passa o estado (ctx). Sempre atende o prefixo: devolve true.
+import fs from "node:fs";
+import path from "node:path";
+import crypto from "node:crypto";
+import YAML from "yaml";
+import { buildHTML, loadSpec } from "../build.js";
+import { writeDeckFile } from "../deck-file.js";
+import { createExperienceDeck } from "../experiences.js";
+import { demoDeck } from "./demo-decks.js";
+import { DEMO_FILES } from "../api-demo.js";
+
+export async function libraryRoutes({ req, res, pathname, url, W, opts, readJSON, readBody, slideSnapshots, sendExport, galleryKey, galleryEntry, materializePreview, copyModelAssets, generateIntoLibrary, llmAvailable, llmConfig, respond, templateFile, TEMPLATE_DIRS }) {
+  const L = W.library;
+  const ok = (obj = {}) => { res.writeHead(200, { "Content-Type": "application/json" }); res.end(JSON.stringify({ ok: true, ...obj })); };
+  const fail = (e, code = 400) => { res.writeHead(code, { "Content-Type": "application/json" }); res.end(JSON.stringify({ error: e.message || String(e) })); };
+  try {
+    if (pathname === "/api/library" && req.method === "GET") {
+      const openId = W.file && W.file.startsWith(L.root + path.sep) ? L.idOf(W.file) : null;
+      return ok({ ...L.list(), user: W.user, multiuser: !!opts.multiuser, open: openId });
+    }
+    if (pathname === "/api/library/gallery-cover" && req.method === "GET") {
+      const key = galleryKey(url.searchParams.get("key")), entry = galleryEntry(key);
+      const spec = entry.dir ? { ...entry.spec, _dir: entry.dir } : entry.spec;
+      const cacheDir = path.join(L.root, ".cache", "vitrine");
+      const cached = path.join(cacheDir, `${crypto.createHash("sha1").update(`${key}|${JSON.stringify(entry.spec)}`).digest("hex")}.jpg`);
+      if (!fs.existsSync(cached)) {
+        const [shot] = await slideSnapshots(spec, 0, { mode: "final", width: 480 });
+        fs.mkdirSync(cacheDir, { recursive: true });
+        fs.writeFileSync(cached, Buffer.from(shot.dataUrl.split(",")[1], "base64"));
+      }
+      res.writeHead(200, { "Content-Type": "image/jpeg", "Cache-Control": "private, max-age=86400" });
+      res.end(fs.readFileSync(cached));
+      return;
+    }
+    if (pathname === "/api/library/cover" && req.method === "GET") {
+      const file = L.resolveId(url.searchParams.get("id"));
+      const st = fs.statSync(file);
+      const cacheDir = path.join(L.root, ".cache", "capas");
+      const cached = path.join(cacheDir, `${crypto.createHash("sha1").update(`${L.idOf(file)}|${st.mtimeMs}`).digest("hex")}.jpg`);
+      if (!fs.existsSync(cached)) {
+        const spec = loadSpec(file);
+        const [shot] = await slideSnapshots(spec, 0, { mode: "final", width: 480 });
+        fs.mkdirSync(cacheDir, { recursive: true });
+        fs.writeFileSync(cached, Buffer.from(shot.dataUrl.split(",")[1], "base64"));
+      }
+      res.writeHead(200, { "Content-Type": "image/jpeg", "Cache-Control": "private, max-age=31536000" });
+      res.end(fs.readFileSync(cached));
+      return;
+    }
+    if (pathname === "/api/library/download" && req.method === "GET") {
+      const file = L.resolveId(url.searchParams.get("id"));
+      const kind = url.searchParams.get("kind") || "sagadeck";
+      if (!["sagadeck", "pptx", "pdf", "roteiro", "tudo", "estudo", "estudo-html"].includes(kind)) throw new Error("formato inválido");
+      await sendExport(res, kind, loadSpec(file), path.basename(file).replace(/\.ya?ml$/i, ""), { audience:url.searchParams.get('audience')||undefined, notes: url.searchParams.get("notas") !== "0" });
+      return;
+    }
+    if (pathname === "/api/library/import" && req.method === "POST") {
+      const name = url.searchParams.get("name") || "Importada";
+      // PowerPoint: importação fiel (src/import); .sagadeck/.zip: pacote do sagadeck
+      if (/\.pptx$/i.test(name)) { const r = await L.importOffice(await readBody(req), url.searchParams.get("topic") || "", name); return ok({ id: r.id, slides: r.slides, snapshots: r.snapshots, snapBy: r.snapBy }); }
+      const id = await L.importPackage(await readBody(req), url.searchParams.get("topic") || "", name);
+      return ok({ id });
+    }
+    if (req.method !== "POST") return fail(new Error("método não suportado"), 405);
+    const b = await readJSON(req);
+    switch (pathname) {
+      case "/api/library/experience": {
+        const spec = createExperienceDeck(b.experience, { title: b.title });
+        buildHTML(spec); // Valida antes de criar o arquivo na biblioteca.
+        return ok({ id: L.createDeck(b.topic || "", spec) });
+      }
+      case "/api/library/topics": return ok({ id: L.createTopic(b.name, b.color) });
+      case "/api/library/topics/update": return ok({ id: L.updateTopic(b.id, b) });
+      case "/api/library/topics/delete": L.deleteTopic(b.id); return ok();
+      case "/api/library/decks": {
+        // nova: em branco (uma capa) — "com IA" usa /api/library/decks/ai
+        const title = String(b.title || "Nova apresentação").trim();
+        const id = L.createDeck(b.topic || "", { title, theme: b.theme || "bauhaus", duration: 10,
+          slides: [{ layout: "cover", title, subtitle: "Subtítulo", author: "" }] });
+        // estilo padrão da biblioteca (Brand Kit): sem tema escolhido, a nova já nasce nele
+        if (!b.theme && L.defaultStyle()) { const f = L.resolveId(id); writeDeckFile(f, L.withDefaultStyle(YAML.parse(fs.readFileSync(f, "utf8")), path.dirname(f))); }
+        return ok({ id });
+      }
+      case "/api/library/decks/model": {
+        // modelos de fábrica (src/studio/demo-decks.js): viram uma apresentação nova na biblioteca
+        const id = L.createDeck(b.topic || "Modelos", demoDeck(b.kind));
+        copyModelAssets(L, id, b.kind);
+        return ok({ id });
+      }
+      case "/api/library/decks/model-preview": {
+        // abre o item da vitrine sem criar arquivo; a cópia só nasce na primeira mudança
+        const key = galleryKey(b.key || b.kind), entry = galleryEntry(key);
+        W.spec = entry.dir ? { ...entry.spec, _dir: entry.dir } : entry.spec;
+        W.file = null;
+        W.preview = { key, topic: String(b.topic ?? "Modelos") }; // "" = sem tópico
+        W.chatHistory = [];
+        return ok({ spec: W.spec, preview: { key, title: W.spec.title, topic: W.preview.topic } });
+      }
+      case "/api/library/decks/model-use": {
+        // "Usar como base": cria a cópia agora, mesmo sem mudança
+        const made = materializePreview(W);
+        if (!made) throw new Error("Não há um modelo em prévia aberto.");
+        return ok(made);
+      }
+      case "/api/library/decks/example-cenario": {
+        // demonstração do Texto no cenário: o YAML e as imagens de exemplo (fundo e recorte transparente)
+        const dir0 = TEMPLATE_DIRS.map((d) => path.join(d, "cenario")).find((d) => fs.existsSync(d));
+        if (!dir0) throw new Error("o exemplo não veio no pacote (templates/cenario)");
+        const tpl = fs.readdirSync(dir0).find((f) => f.endsWith(".yaml"));
+        const id = L.createDeck(b.topic || "", YAML.parse(fs.readFileSync(path.join(dir0, tpl), "utf8")));
+        fs.cpSync(path.join(dir0, "imagens"), path.join(path.dirname(L.resolveId(id)), "imagens"), { recursive: true, force: false });
+        return ok({ id });
+      }
+      case "/api/library/decks/example": {
+        // exemplo de slides api (aula de APIs de IA): roda no ambiente embutido "ensaio", sem configurar nada
+        const tpl = templateFile("ensaio-api.yaml");
+        if (!tpl) throw new Error("o exemplo não veio no pacote (templates/ensaio-api.yaml)");
+        const id = L.createDeck(b.topic || "", YAML.parse(fs.readFileSync(tpl, "utf8")));
+        const dir = path.dirname(L.resolveId(id));
+        for (const [name, text] of Object.entries(DEMO_FILES)) fs.writeFileSync(path.join(dir, name), text);
+        return ok({ id });
+      }
+      case "/api/library/decks/move": return ok({ id: L.moveDeck(b.id, b.topic || "") });
+      case "/api/library/decks/rename": {
+        const id = L.renameDeck(b.id, String(b.title || "").trim() || "Sem título");
+        if (W.file === L.resolveId(b.id)) { W.file = L.resolveId(id); W.spec = loadSpec(W.file); }
+        return ok({ id });
+      }
+      case "/api/library/decks/duplicate": return ok({ id: L.duplicateDeck(b.id) });
+      case "/api/library/decks/trash": return ok({ slot: L.trashDeck(b.id) });
+      case "/api/library/decks/restore": return ok({ id: L.restoreDeck(b.slot) });
+      case "/api/library/decks/purge": L.purgeDeck(b.slot); return ok();
+      case "/api/library/trash/empty": return ok({ purged: L.emptyTrash() });
+      case "/api/library/open": {
+        W.preview = null;
+        const file = L.resolveId(b.id);
+        W.spec = loadSpec(file);
+        W.file = file;
+        return ok({ spec: W.spec, file: W.file, id: b.id });
+      }
+      case "/api/library/decks/ai": {
+        // gera com IA direto numa pasta nova da biblioteca (as imagens ficam dentro dela)
+        if (!(await llmAvailable({ force: true }))) return fail(new Error(`Nenhum LLM respondendo em ${llmConfig().url}.`), 503);
+        await respond(res, b.stream, async (emit) => {
+          const r = await generateIntoLibrary(W, b.topic || "", b, emit);
+          if (r.question) return { ok: true, question: r.question }; // o Studio mostra a pergunta e gera de novo com a resposta
+          return { ok: true, id: r.id, images: r.images, research: r.research, quality: r.quality, variety: r.variety };
+        });
+        return;
+      }
+    }
+    return fail(new Error("rota da biblioteca desconhecida"), 404);
+  } catch (e) {
+    return fail(e);
+  }
+  return true;
+}