sagadeck 1.2.0

package/src/graph-lab.js

@@ -0,0 +1,24 @@
+import { esc } from './markup.js';
+import { iconSVG } from './figures/icons.js';
+
+// O exemplo é dado, não uma regra por assunto: a IA escolhe nós, relações e aparência.
+export const graphLabExample = { layout:'graphlab', title:'Qual rota sobrevive ao imprevisto?',
+  nodes:[{id:'fabrica',label:'Fábrica',icon:'factory',x:140,y:300},{id:'centro',label:'Centro de distribuição',icon:'warehouse',x:470,y:160},{id:'porto',label:'Porto',icon:'ship',x:470,y:460},{id:'loja',label:'Loja',icon:'store',x:850,y:300}],
+  edges:[{from:'fabrica',to:'centro',weight:4,label:'Rodovia'},{from:'fabrica',to:'porto',weight:2,label:'Ferrovia'},{from:'porto',to:'centro',weight:1},{from:'centro',to:'loja',weight:3},{from:'porto',to:'loja',weight:8}],
+  start:'fabrica',goal:'loja',explanation:'Selecione uma ligação e altere seu custo. Bloqueie um nó e compare a nova rota.' };
+
+export function graphLabHTML(s,ctx,head) {
+  const nodes=(s.nodes||[]).map(n=>typeof n==='string'?{id:n,label:n}:{...n,id:String(n.id||'')});
+  const ids=new Set();
+  for(const n of nodes){if(!n.id||ids.has(String(n.id)))throw new Error('graphlab: cada nó precisa de id único');ids.add(String(n.id));}
+  const edges=(s.edges||[]).map(e=>({...e,from:String(e.from),to:String(e.to),weight:Number(e.weight??1)}));
+  for(const e of edges){if(!ids.has(String(e.from))||!ids.has(String(e.to))||!Number.isFinite(e.weight)||e.weight<0)throw new Error('graphlab: ligação com destino inexistente ou custo negativo');}
+  const model={nodes,edges,directed:!!s.directed,start:s.start||nodes[0]?.id,goal:s.goal||nodes.at(-1)?.id};
+  const icons=nodes.map(n=>`<template data-gl-icon="${esc(n.id)}">${iconSVG(n.icon||'map-pin',{size:28})}</template>`).join('');
+  return `<div class="L-graphlab" data-graphlab>${head(s)}
+    <div class="gl-toolbar"><button data-gl-action="route">Calcular rota</button><button data-gl-action="walk">Visitar vizinhos</button><button data-gl-action="step">Próxima visita</button><button data-gl-action="focus">Focar seleção</button><button data-gl-action="fit">Ver tudo</button><button data-gl-action="reset">Restaurar</button></div>
+    <div class="gl-body"><div class="gl-canvas"><svg viewBox="0 0 1000 620" role="img" aria-label="Grafo explorável"><g class="gl-world"><g class="gl-edges"></g><g class="gl-nodes"></g></g></svg><div class="gl-zoom"><button data-gl-action="in" aria-label="Ampliar grafo">+</button><button data-gl-action="out" aria-label="Reduzir grafo">−</button></div></div>
+    <aside class="gl-inspector"><h3>Explore a rede</h3><p data-gl-details>Clique num nó ou numa ligação. Arraste os nós para reorganizar.</p><label>Origem<select data-gl-start></select></label><label>Destino<select data-gl-goal></select></label><output data-gl-result aria-live="polite">Escolha origem e destino para comparar caminhos.</output>
+    <details class="gl-edit-panel"><summary>Editar seleção</summary><label>Nome do nó<input data-gl-label></label><label>Custo da ligação<input data-gl-weight type="number" min="0" step="0.5"></label><label>Cor do destaque<input data-gl-color type="color" value="#e75b40"></label><div class="gl-edit"><button data-gl-action="add">Adicionar nó</button><button data-gl-action="connect">Ligar à origem</button><button data-gl-action="remove">Remover seleção</button></div></details></aside></div>
+    ${s.explanation?`<p class="gl-explanation">${esc(s.explanation)}</p>`:''}${icons}<script type="application/json" class="gl-model">${JSON.stringify(model).replace(/</g,'\\u003c')}</script></div>`;
+}

package/src/hologram.js

@@ -0,0 +1,30 @@
+// Geometrias projetadas em perspectiva; a tipografia e o conteúdo continuam nativos.
+export function drawHologram(ctx,o,t,w,h){
+ const unit=Math.min(w,h),project=(v,l)=>{
+  const a=t*l.speed*.12+l.rotation,ca=Math.cos(a),sa=Math.sin(a),x=v[0]*ca+v[2]*sa,z=-v[0]*sa+v[2]*ca,y=v[1]*Math.cos(.38)-z*Math.sin(.38),depth=z*Math.cos(.38)+v[1]*Math.sin(.38),p=3.8/(3.8+depth);
+  return [w*l.x+x*unit*l.scale*p,h*l.y+y*unit*l.scale*p,depth];
+ };
+ const line=(vertices,l,color,closed=false)=>{ctx.beginPath();vertices.forEach((v,i)=>{const p=project(v,l);i?ctx.lineTo(p[0],p[1]):ctx.moveTo(p[0],p[1]);});if(closed)ctx.closePath();ctx.strokeStyle=color;ctx.lineWidth=Math.max(.6,unit/1000);ctx.stroke();};
+ const ring=(l,radius,tilt,color)=>{const v=[];for(let i=0;i<=96;i++){const a=i*Math.PI/48;v.push([radius*Math.cos(a),radius*Math.sin(a)*Math.sin(tilt),radius*Math.sin(a)*Math.cos(tilt)]);}line(v,l,color);};
+ ctx.save();ctx.globalAlpha=o.opacity;
+ for(const l of o.layers){
+  ctx.save();
+  if(l.shape==='sphere'){
+   for(let j=-3;j<=3;j++){const phi=j*Math.PI/9,v=[];for(let n=0;n<=64;n++){const a=n*Math.PI/32;v.push([Math.cos(phi)*Math.cos(a),Math.sin(phi),Math.cos(phi)*Math.sin(a)]);}line(v,l,o.foreground);}
+   for(let j=0;j<8;j++){const a=j*Math.PI/4,v=[];for(let n=0;n<=64;n++){const p=-Math.PI/2+n*Math.PI/64;v.push([Math.cos(p)*Math.cos(a),Math.sin(p),Math.cos(p)*Math.sin(a)]);}line(v,l,o.foreground);}
+  }else if(l.shape==='cube'){
+   const v=[[-1,-1,-1],[1,-1,-1],[1,1,-1],[-1,1,-1],[-1,-1,1],[1,-1,1],[1,1,1],[-1,1,1]];
+   for(const ids of [[0,1,2,3],[4,5,6,7]]){const face=ids.map(i=>project(v[i],l));ctx.beginPath();face.forEach((p,i)=>i?ctx.lineTo(...p.slice(0,2)):ctx.moveTo(...p.slice(0,2)));ctx.closePath();ctx.save();ctx.globalAlpha*=.08;ctx.fillStyle=o.secondary;ctx.fill();ctx.restore();line(ids.map(i=>v[i]),l,o.foreground,true);}
+   for(let i=0;i<4;i++)line([v[i],v[i+4]],l,o.foreground);
+  }else if(l.shape==='plane'){
+   for(let j=-4;j<=4;j++){const n=j/4;line([[-1,n,0],[1,n,0]],l,o.secondary);line([[n,-1,0],[n,1,0]],l,o.secondary);}
+   line([[-1,-1,0],[1,-1,0],[1,1,0],[-1,1,0]],l,o.foreground,true);
+  }
+  ring(l,1.3,.15,o.secondary);ring(l,1.45,1.3,o.accent);
+  for(let i=0;i<48;i++){const a=i*Math.PI/24;line([[1.48*Math.cos(a),0,1.48*Math.sin(a)],[(i%4?1.51:1.57)*Math.cos(a),0,(i%4?1.51:1.57)*Math.sin(a)]],l,i%4?o.secondary:o.accent);}
+  const orbit=t*l.speed*.24+l.rotation,p=project([1.3*Math.cos(orbit),.2,1.3*Math.sin(orbit)],l);
+  ctx.fillStyle=o.accent;ctx.beginPath();ctx.arc(p[0],p[1],Math.max(1,unit/500),0,Math.PI*2);ctx.fill();
+  ctx.restore();
+ }
+ ctx.restore();
+}

package/src/identity.js

@@ -0,0 +1,86 @@
+// Identidades: as fontes (e a paleta preferida) da empresa da pessoa. Ficam só na máquina dela, em
+// ~/.sagadeck/identidades.yaml (ou SAGADECK_IDENTIDADES): o nome da fonte de uma empresa nunca entra no
+// software nem no repositório. O deck só diz qual usar (identity: trabalho); sem o arquivo nesta máquina, o deck
+// abre com as fontes do tema e um aviso.
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import YAML from "yaml";
+
+// (no Windows, C:\Users\<você>\.sagadeck\identidades.yaml, ao lado do ambientes.yaml)
+export function identitiesFile(env = process.env, home = os.homedir()) {
+  return env.SAGADECK_IDENTIDADES || path.join(home, ".sagadeck", "identidades.yaml");
+}
+
+// Modelo comentado (o Studio cria quando a pessoa pede para configurar)
+export const IDENTITY_TEMPLATE = `# Identidades do sagadeck: as fontes e cores da sua empresa. Este arquivo fica só neste computador.
+#
+# Cada identidade tem um nome curto (usado no deck: "identity: trabalho") e:
+#   nome:    como aparece no Studio
+#   fontes:  por papel, em ordem de preferência; se nenhuma estiver instalada, entra a fonte do tema
+#     titulo:   títulos e manchetes (nos temas com personalidade, como rabisco e pop, o título fica com a
+#               fonte do tema e o resto usa a da empresa)
+#     corpo:    textos, listas e subtítulos
+#     compacta: rótulos, legendas e tabelas (opcional; sem ela, vale a do corpo)
+#     codigo:   código (opcional)
+#   paleta:  uma das paletas do sagadeck (rubi, ametista, tangerina, safira, esmeralda, tinta…) ou as suas cores:
+#            { paper: "FFFFFF", ink: "3B2B33", accent: "B83A6E", alert: "CC092F", family: ["F9DCE5", "D9668F"] }
+#            (vale quando o deck não escolheu outra paleta)
+#
+# O arquivo da fonte não é embutido na apresentação (a licença de fontes de empresa costuma proibir): quem abrir
+# numa máquina sem a fonte vê a do tema.
+
+trabalho:
+  nome: Trabalho
+  fontes:
+    titulo: ["Nome da Fonte Sans", "Nome da Fonte Sans Compact"]
+    corpo: ["Nome da Fonte Sans"]
+    compacta: ["Nome da Fonte Sans Compact"]
+  paleta: rubi
+`;
+
+let cache = { file: null, mtime: 0, size: -1, data: null };
+
+// { file, exists, identities: { id: { id, name, fonts: { titulo, corpo, compacta, codigo }, palette } }, error }
+export function loadIdentities(env = process.env) {
+  const file = identitiesFile(env);
+  let st = null;
+  try { st = fs.statSync(file); } catch { return { file, exists: false, identities: {}, error: null }; }
+  if (cache.file === file && cache.mtime === st.mtimeMs && cache.size === st.size && cache.data) return cache.data;
+  let data;
+  try {
+    const raw = YAML.parse(fs.readFileSync(file, "utf8")) || {};
+    if (typeof raw !== "object" || Array.isArray(raw)) throw new Error("o arquivo precisa ser uma lista de identidades (nome: { fontes, paleta })");
+    const list = (v) => [].concat(v || []).map((x) => String(x).trim().replace(/^["']|["']$/g, "")).filter(Boolean).slice(0, 6);
+    const identities = {};
+    for (const [id, v] of Object.entries(raw)) {
+      if (!v || typeof v !== "object") continue;
+      const f = v.fontes || v.fonts || {};
+      identities[id] = {
+        id, name: String(v.nome || v.name || id),
+        fonts: { titulo: list(f.titulo || f.title), corpo: list(f.corpo || f.body), compacta: list(f.compacta || f.compact), codigo: list(f.codigo || f.code) },
+        palette: v.paleta ?? v.palette ?? null,
+      };
+    }
+    data = { file, exists: true, identities, error: null };
+  } catch (e) {
+    data = { file, exists: true, identities: {}, error: `identidades.yaml com erro: ${e.message}` };
+  }
+  cache = { file, mtime: st.mtimeMs, size: st.size, data };
+  return data;
+}
+
+export function identityFor(id, env = process.env) {
+  if (!id) return null;
+  return loadIdentities(env).identities[id] || null;
+}
+
+// cria o modelo comentado (sem sobrescrever o que existe)
+export function ensureIdentitiesFile(env = process.env) {
+  const file = identitiesFile(env);
+  if (!fs.existsSync(file)) {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, IDENTITY_TEMPLATE, "utf8");
+  }
+  return file;
+}

package/src/import/crop.js

@@ -0,0 +1,59 @@
+// Recortes de imagem (PNG) pelo Chromium: serve para tirar, da foto fiel do slide original, a região de um objeto
+// que o sagadeck não desenha igual (equação antiga em WMF com fontes de símbolo, SmartArt…).
+import fs from "node:fs";
+
+// fotos reduzidas (JPEG) para mandar ao modelo de visão: menos tokens, a mesma leitura
+export async function imagesAsDataUrls(files, { width = 1024, quality = 0.82 } = {}) {
+  if (!files.length) return [];
+  const { findBrowser } = await import("../export/browser.js");
+  const { chromium } = await import("playwright-core");
+  const browser = await chromium.launch({ executablePath: findBrowser() });
+  try {
+    const page = await browser.newPage();
+    await page.setContent("<body></body>");
+    const out = [];
+    for (const f of files) {
+      if (!f || !fs.existsSync(f)) { out.push(null); continue; }
+      const ext = f.toLowerCase().endsWith(".png") ? "png" : "jpeg";
+      const data = `data:image/${ext};base64,${fs.readFileSync(f).toString("base64")}`;
+      out.push(await page.evaluate(async ([data, width, quality]) => {
+        const img = new Image(); img.src = data; await img.decode();
+        const w = Math.min(width, img.width), h = Math.round((img.height * w) / img.width);
+        const c = document.createElement("canvas"); c.width = w; c.height = h;
+        const g = c.getContext("2d"); g.fillStyle = "#fff"; g.fillRect(0, 0, w, h); g.drawImage(img, 0, 0, w, h);
+        return c.toDataURL("image/jpeg", quality);
+      }, [data, width, quality]));
+    }
+    return out;
+  } finally { await browser.close(); }
+}
+
+export async function cropRegions(jobs) {
+  if (!jobs.length) return [];
+  const { findBrowser } = await import("../export/browser.js");
+  const { chromium } = await import("playwright-core");
+  const browser = await chromium.launch({ executablePath: findBrowser() });
+  const done = [];
+  try {
+    const page = await browser.newPage();
+    await page.setContent("<body></body>");
+    const bySrc = new Map();
+    for (const j of jobs) { if (!bySrc.has(j.src)) bySrc.set(j.src, []); bySrc.get(j.src).push(j); }
+    for (const [src, list] of bySrc) {
+      if (!fs.existsSync(src)) continue;
+      const data = `data:image/png;base64,${fs.readFileSync(src).toString("base64")}`;
+      const outs = await page.evaluate(async ([data, list]) => {
+        const img = new Image(); img.src = data; await img.decode();
+        return list.map((j) => {
+          const x = Math.max(0, Math.floor(j.x)), y = Math.max(0, Math.floor(j.y));
+          const w = Math.max(1, Math.min(img.width - x, Math.ceil(j.w))), h = Math.max(1, Math.min(img.height - y, Math.ceil(j.h)));
+          const c = document.createElement("canvas"); c.width = w; c.height = h;
+          c.getContext("2d").drawImage(img, x, y, w, h, 0, 0, w, h);
+          return c.toDataURL("image/png");
+        });
+      }, [data, list.map(({ x, y, w, h }) => ({ x, y, w, h }))]);
+      outs.forEach((u, k) => { fs.writeFileSync(list[k].dst, Buffer.from(u.split(",")[1], "base64")); done.push(list[k].dst); });
+    }
+  } finally { await browser.close(); }
+  return done;
+}

package/src/import/index.js

@@ -0,0 +1,132 @@
+// Importar uma apresentação para uma pasta de deck: lê (src/import/pptx.js), grava as mídias em imagens/original/
+// (WMF/EMF viram PNG), guarda uma cópia do original e a foto de cada slide em original/ (PowerPoint ou LibreOffice,
+// se houver) e devolve o deck. Cada slide lembra de onde veio (original: { slide, image }).
+import fs from "node:fs";
+import crypto from "node:crypto";
+import path from "node:path";
+import JSZip from "jszip";
+import { importPptx, plainOf } from "./pptx.js";
+import { metafilesToPng, powerPointSnapshots, libreOfficeToPdf } from "./office.js";
+
+const gcd = (a, b) => (b ? gcd(b, a % b) : a);
+export function aspectOf(cx, cy) {
+  const r = cx / cy;
+  if (Math.abs(r - 16 / 9) < 0.005) return undefined;
+  if (Math.abs(r - 4 / 3) < 0.005) return "4:3";
+  if (Math.abs(r - 16 / 10) < 0.005) return "16:10";
+  const g = gcd(Math.round(cx / 1000), Math.round(cy / 1000)) || 1;
+  return `${Math.round(cx / 1000) / g}:${Math.round(cy / 1000) / g}`;
+}
+
+export async function importToDir(buf, dir, { fileName = "original.pptx", snapshots = true, log = () => {} } = {}) {
+  fs.mkdirSync(dir, { recursive: true });
+  const res = await importPptx(buf);
+  const zip = await JSZip.loadAsync(buf);
+  // mídias
+  const rename = new Map(), convert = [];
+  for (const m of res.media) {
+    const f = zip.file(m.zipPath);
+    if (!f) continue;
+    const abs = path.join(dir, ...m.name.split("/"));
+    fs.mkdirSync(path.dirname(abs), { recursive: true });
+    fs.writeFileSync(abs, await f.async("nodebuffer"));
+    if (["wmf", "emf", "tif", "tiff"].includes(m.ext)) convert.push({ src: abs, dst: abs.replace(/\.[a-z]+$/i, ".png"), from: m.name });
+  }
+  // mídia repetida (o mesmo logo gravado uma vez por slide): fica um arquivo só
+  const seen = new Map();
+  for (const m of res.media) {
+    const abs = path.join(dir, ...m.name.split("/"));
+    if (!fs.existsSync(abs)) continue;
+    const h = crypto.createHash("sha1").update(fs.readFileSync(abs)).digest("hex");
+    if (seen.has(h)) { rename.set(m.name, seen.get(h)); fs.rmSync(abs, { force: true }); const i = convert.findIndex((c) => c.from === m.name); if (i >= 0) convert.splice(i, 1); }
+    else seen.set(h, m.name);
+  }
+  if (convert.length) {
+    log(`convertendo ${convert.length} figura(s) WMF/EMF`);
+    const done = new Set(metafilesToPng(convert.map(({ src, dst }) => ({ src, dst }))));
+    for (const c of convert) if (done.has(c.dst)) { rename.set(c.from, c.from.replace(/\.[a-z]+$/i, ".png")); fs.rmSync(c.src, { force: true }); }
+  }
+  // repetida → a primeira; WMF/EMF → o PNG convertido (em cadeia)
+  const resolve = (n) => { let v = n; for (let k = 0; k < 4 && rename.has(v); k++) v = rename.get(v); return v; };
+  const fix = (e) => {
+    if (e?.image) e.image = resolve(e.image);
+    if (e?.drawing) e.drawing = String(e.drawing).replace(/href="media:([^"]+)"/g, (m, r) => `href="media:${resolve(r)}"`);
+    return e;
+  };
+  // original e fotos
+  const origDir = path.join(dir, "original");
+  fs.mkdirSync(origDir, { recursive: true });
+  const origFile = path.join(origDir, path.basename(fileName));
+  fs.writeFileSync(origFile, buf);
+  let snaps = [], snapBy = null;
+  if (snapshots) {
+    log("fotografando os slides do original");
+    snaps = powerPointSnapshots(origFile, origDir);
+    if (snaps.length) snapBy = "PowerPoint";
+    else {
+      const lo = libreOfficeToPdf(origFile);
+      if (lo) {
+        try { const { renderPdfPages } = await import("./pdf-render.js"); snaps = await renderPdfPages(fs.readFileSync(lo.pdf), origDir); snapBy = "LibreOffice"; }
+        catch (e) { log(`sem foto do original (${e.message})`); }
+        finally { lo.cleanup(); }
+      }
+    }
+  }
+  // o que não sai igual (equação OLE em WMF/EMF, SmartArt): recorte da foto fiel do slide, na mesma posição
+  const isMeta = (n) => /\.(wmf|emf)$/i.test(n || "");
+  const jobs = [];
+  for (const s of res.slides) {
+    const snap = path.join(origDir, `slide-${String(s.n).padStart(2, "0")}.png`);
+    const has = snaps.length && fs.existsSync(snap);
+    s.elements.forEach((e, k) => {
+      if (!(e.fromSnapshot || (e.ole && isMeta(e.image)))) return;
+      if (!has) return;
+      const rel = `imagens/original/recorte-${String(s.n).padStart(2, "0")}-${k + 1}.png`;
+      jobs.push({ src: snap, dst: path.join(dir, ...rel.split("/")), x: e.x, y: e.y, w: e.w, h: e.h, e, rel });
+    });
+    if (!has) s.elements = s.elements.filter((e) => !e.fromSnapshot);
+  }
+  if (jobs.length) {
+    log(`recortando ${jobs.length} objeto(s) da foto do original`);
+    try {
+      const { cropRegions } = await import("./crop.js");
+      const ok = new Set(await cropRegions(jobs));
+      for (const j of jobs) if (ok.has(j.dst)) { j.e.image = j.rel; j.e.fit = "fill"; delete j.e.crop; delete j.e.fromSnapshot; j.e.fromOriginal = true; }
+    } catch (e) { log(`sem recorte (${e.message})`); }
+    for (const s of res.slides) s.elements = s.elements.filter((e) => !e.fromSnapshot);
+  }
+  const snapOf = (n) => { const f = `original/slide-${String(n).padStart(2, "0")}.png`; return fs.existsSync(path.join(dir, f)) ? f : null; };
+  // deck
+  const slides = res.slides.map((s) => {
+    const bgColor = s.background?.color && s.background.color.toUpperCase() !== "FFFFFF" ? s.background.color : undefined;
+    const out = { layout: "canvas", title: s.title || `Slide ${s.n}` };
+    if (bgColor) out.bg = bgColor;
+    if (s.background?.image) out.background = { image: resolve(s.background.image), fit: "fill" };
+    out.elements = s.elements.map((e) => { const c = fix({ ...e }); delete c.kind; return c; });
+    if (s.notes) out.notes = s.notes;
+    out.original = { slide: s.n, ...(snapOf(s.n) ? { image: snapOf(s.n) } : {}), ...(s.layoutName ? { layout: s.layoutName } : {}) };
+    if (s.hidden) out.hidden = true;
+    return out;
+  });
+  const title = res.slides.map((s) => s.title).find((t) => t && t.length > 3) || path.basename(fileName).replace(/\.[a-z]+$/i, "");
+  const spec = {
+    title,
+    ...(aspectOf(res.cx, res.cy) ? { aspect: aspectOf(res.cx, res.cy) } : {}),
+    theme: "manual",
+    footer: false,
+    import: { from: path.basename(fileName), slides: slides.length, fonts: res.fonts, colors: res.scheme, ...(snapBy ? { snapshots: snapBy } : {}), ...(res.warnings.length ? { warnings: res.warnings.slice(0, 40) } : {}) },
+    slides,
+  };
+  return { spec, media: res.media.length, converted: rename.size, snapshots: snaps.length, snapBy, warnings: res.warnings };
+}
+
+// texto de cada slide importado, compacto, para a IA ler o original (títulos, textos por posição, tabelas, notas)
+export function outlineOf(spec) {
+  return (spec.slides || []).map((s, i) => {
+    const els = (s.elements || []).filter((e) => !e.deco);
+    const texts = els.filter((e) => e.textbox).map((e) => plainOf(e).trim()).filter((t) => t && !/^\d{1,3}$/.test(t));
+    const tables = els.filter((e) => e.tableData).map((e) => e.tableData.map((r) => r.join(" | ")).join("\n"));
+    const imgs = els.filter((e) => e.image).length;
+    return [`## ${i + 1}. ${s.title || ""}`, ...texts, ...tables.map((t) => `[tabela]\n${t}`), imgs ? `[${imgs} imagem(ns)]` : "", s.notes ? `[notas] ${s.notes}` : ""].filter(Boolean).join("\n");
+  }).join("\n\n");
+}

package/src/import/legacy-word.js

@@ -0,0 +1,42 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import {execFile} from 'node:child_process';
+import {promisify} from 'node:util';
+
+const run=promisify(execFile), conversions=new Map();
+// Word legado precisa de um conversor real: não decodifique o binário como texto.
+export async function convertLegacyWord(bytes,format='docx') {
+  if(!['docx','pdf'].includes(format))throw Error('Formato de conversão inválido.');
+  const key=crypto.createHash('sha256').update(bytes).digest('hex')+format;
+  if(conversions.has(key))return conversions.get(key);
+  const pending=(async()=>{
+    const dir=await fs.mkdtemp(path.join(os.tmpdir(),'sagadeck-word-'));
+    const input=path.join(dir,'source.doc'),output=path.join(dir,'source.'+format);
+    try {
+      await fs.writeFile(input,bytes);
+      if(process.platform==='win32') {
+        const script=path.join(dir,'convert.ps1');
+        await fs.writeFile(script,`param([string]$inputFile,[string]$outputFile)
+$word=$null; $document=$null
+try {
+  $word=New-Object -ComObject Word.Application
+  $word.Visible=$false; $word.DisplayAlerts=0; $word.AutomationSecurity=3
+  $document=$word.Documents.Open($inputFile,$false,$true)
+  $document.SaveAs2($outputFile,${format==='pdf'?17:16})
+} finally {
+  if($document){$document.Close(0); [void][Runtime.InteropServices.Marshal]::FinalReleaseComObject($document)}
+  if($word){$word.Quit(); [void][Runtime.InteropServices.Marshal]::FinalReleaseComObject($word)}
+}`);
+        const command=(await fs.readFile(script,'utf8')).replace('param([string]$inputFile,[string]$outputFile)',`$ErrorActionPreference='Stop'; $inputFile='${input.replace(/'/g,"''")}'; $outputFile='${output.replace(/'/g,"''")}'`);
+        await run('powershell.exe',['-NoProfile','-NonInteractive','-EncodedCommand',Buffer.from(command,'utf16le').toString('base64')],{timeout:120000,windowsHide:true});
+      } else await run(process.env.SAGADECK_OFFICE_BIN||'libreoffice',['-env:UserInstallation=file://'+path.join(dir,'profile'),'--headless','--convert-to',format,'--outdir',dir,input],{timeout:120000});
+      return await fs.readFile(output);
+    } catch(cause) {throw new Error('Não foi possível converter o Word antigo (.doc). É necessário Microsoft Word no Windows ou LibreOffice no servidor; você também pode enviar o arquivo como .docx.',{cause});}
+    finally {await fs.rm(dir,{recursive:true,force:true});}
+  })();
+  conversions.set(key,pending);
+  try {return await pending;} catch(e){conversions.delete(key);throw e;}
+  finally {if(conversions.size>4)conversions.delete(conversions.keys().next().value);}
+}

package/src/import/merge.js

@@ -0,0 +1,45 @@
+// Slides progressivos → um slide que se monta por cliques. Muita gente "anima" no PowerPoint copiando o slide e
+// acrescentando partes (o ciclo da água em 7 slides). Aqui cada elemento aparece no clique em que surgiu (step) e
+// some no clique em que saiu (exit). Sem IA: é o mesmo desenho, só que num slide.
+const keyOf = (e) => { const { step, exit, deco, ...rest } = e || {}; return JSON.stringify(rest); };
+
+export function mergeProgressive(slides) {
+  const list = (slides || []).filter((s) => s && Array.isArray(s.elements));
+  if (!list.length) throw new Error("nenhum slide com elementos para juntar");
+  if (list.length === 1) return structuredClone(list[0]);
+  const out = [];
+  let alive = new Map(); // chave -> elemento no resultado (vivo no passo anterior)
+  list.forEach((s, k) => {
+    const now = new Map();
+    for (const e of s.elements) {
+      const key = keyOf(e);
+      if (now.has(key)) { // repetido no mesmo slide: outra instância
+        const c = structuredClone(e); if (k > 0) c.step = k; out.push(c); continue;
+      }
+      if (alive.has(key)) now.set(key, alive.get(key));
+      else { const c = structuredClone(e); if (k > 0) c.step = k; out.push(c); now.set(key, c); }
+    }
+    for (const [key, el] of alive) if (!now.has(key)) el.exit = k;
+    alive = now;
+  });
+  const first = list[0];
+  const notes = list.map((s) => s.notes).filter(Boolean).join("\n\n");
+  return {
+    ...structuredClone({ ...first, elements: undefined, notes: undefined }),
+    elements: out,
+    ...(notes ? { notes } : {}),
+    original: { ...(first.original || {}), merged: list.map((s) => s.original?.slide).filter(Boolean) },
+  };
+}
+
+// é uma sequência progressiva? (cada slide mantém boa parte do anterior: o mesmo desenho crescendo)
+export function isProgressive(slides) {
+  if (!slides || slides.length < 2) return false;
+  for (let k = 1; k < slides.length; k++) {
+    const prev = new Set((slides[k - 1].elements || []).map(keyOf));
+    const cur = (slides[k].elements || []).map(keyOf);
+    const kept = cur.filter((x) => prev.has(x)).length;
+    if (!prev.size || kept / prev.size < 0.5) return false;
+  }
+  return true;
+}

package/src/import/office.js

@@ -0,0 +1,123 @@
+// O que o sistema oferece para importar melhor (tudo opcional; sem nada disso a importação funciona igual):
+//   - Windows: WMF/EMF (figuras antigas do Office) viram PNG pelo próprio Windows (System.Drawing), sem Office.
+//   - PowerPoint instalado: a foto fiel de cada slide (para comparar e para a IA ver). Abre uma CÓPIA do arquivo,
+//     só para leitura e sem janela; fecha só o que abriu e nunca fecha o PowerPoint de quem está usando.
+//   - LibreOffice (comum no Linux): converte o .pptx em PDF, e as páginas viram PNG pelo pdf.js (src/import/pdf-render.js);
+//     também converte WMF/EMF.
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+
+const isWin = process.platform === "win32";
+const tmpDir = () => fs.mkdtempSync(path.join(os.tmpdir(), "sagadeck-import-"));
+
+function powershell(script, args, timeout = 600000) {
+  const dir = tmpDir();
+  try {
+    const ps1 = path.join(dir, "run.ps1"), json = path.join(dir, "args.json");
+    fs.writeFileSync(ps1, "\uFEFF" + script, "utf8");
+    fs.writeFileSync(json, JSON.stringify(args), "utf8");
+    const r = spawnSync("powershell.exe", ["-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-File", ps1, json], { encoding: "utf8", timeout, windowsHide: true });
+    return { ok: r.status === 0, out: (r.stdout || "").trim(), err: (r.stderr || "").trim() };
+  } finally { fs.rmSync(dir, { recursive: true, force: true }); }
+}
+
+let officeCache = null;
+export function powerPointAvailable() {
+  if (!isWin || process.env.SAGADECK_NO_OFFICE) return false;
+  if (officeCache != null) return officeCache;
+  const r = powershell("$t = [type]::GetTypeFromProgID('PowerPoint.Application'); if ($t) { 'sim' } else { 'nao' }", {}, 30000);
+  officeCache = r.ok && r.out === "sim";
+  return officeCache;
+}
+export function libreOfficeBin() {
+  if (process.env.SAGADECK_NO_OFFICE) return null;
+  const names = isWin ? ["soffice.exe"] : ["soffice", "libreoffice"];
+  const dirs = [...String(process.env.PATH || "").split(path.delimiter), ...(isWin ? ["C:\\Program Files\\LibreOffice\\program", "C:\\Program Files (x86)\\LibreOffice\\program"] : ["/usr/bin", "/usr/local/bin", "/opt/libreoffice/program", "/Applications/LibreOffice.app/Contents/MacOS"])];
+  for (const d of dirs) for (const n of names) { const f = path.join(d, n); if (d && fs.existsSync(f)) return f; }
+  return null;
+}
+
+// WMF/EMF → PNG. pairs: [{ src, dst }] (caminhos absolutos). Devolve os dst que ficaram prontos.
+export function metafilesToPng(pairs, { maxSide = 2400 } = {}) {
+  if (!pairs.length) return [];
+  if (isWin && !process.env.SAGADECK_NO_OFFICE) {
+    const script = `
+$ErrorActionPreference = 'Continue'
+Add-Type -AssemblyName System.Drawing
+$a = Get-Content -Raw -Encoding UTF8 $args[0] | ConvertFrom-Json
+foreach ($p in $a.pairs) {
+  try {
+    $m = New-Object System.Drawing.Imaging.Metafile($p.src)
+    $w = [double]$m.Width; $h = [double]$m.Height
+    if ($w -le 0 -or $h -le 0) { $m.Dispose(); continue }
+    $k = [Math]::Min(4.0, [Math]::Max(1.0, $a.maxSide / [Math]::Max($w, $h)))
+    if ([Math]::Max($w, $h) * $k -gt $a.maxSide) { $k = $a.maxSide / [Math]::Max($w, $h) }
+    $bw = [int][Math]::Max(1, $w * $k); $bh = [int][Math]::Max(1, $h * $k)
+    $b = New-Object System.Drawing.Bitmap($bw, $bh)
+    $g = [System.Drawing.Graphics]::FromImage($b)
+    $g.SmoothingMode = 'AntiAlias'; $g.InterpolationMode = 'HighQualityBicubic'; $g.TextRenderingHint = 'AntiAliasGridFit'
+    $g.Clear([System.Drawing.Color]::Transparent)
+    $g.DrawImage($m, 0, 0, $bw, $bh)
+    $b.Save($p.dst, [System.Drawing.Imaging.ImageFormat]::Png)
+    $g.Dispose(); $b.Dispose(); $m.Dispose()
+    Write-Output ("ok " + $p.dst)
+  } catch { Write-Output ("falhou " + $p.src) }
+}`;
+    powershell(script, { pairs, maxSide });
+    return pairs.filter((p) => fs.existsSync(p.dst)).map((p) => p.dst);
+  }
+  const lo = libreOfficeBin();
+  if (lo) {
+    for (const p of pairs) {
+      const out = tmpDir();
+      spawnSync(lo, ["--headless", "--convert-to", "png", "--outdir", out, p.src], { timeout: 120000 });
+      const f = fs.readdirSync(out).find((x) => x.endsWith(".png"));
+      if (f) fs.copyFileSync(path.join(out, f), p.dst);
+      fs.rmSync(out, { recursive: true, force: true });
+    }
+    return pairs.filter((p) => fs.existsSync(p.dst)).map((p) => p.dst);
+  }
+  return [];
+}
+
+// Foto de cada slide pelo PowerPoint: outDir/slide-01.png… Devolve a lista de arquivos (vazia se não deu).
+export function powerPointSnapshots(pptxFile, outDir, { width = 1920 } = {}) {
+  if (!powerPointAvailable()) return [];
+  fs.mkdirSync(outDir, { recursive: true });
+  const work = tmpDir();
+  const copy = path.join(work, "copia" + path.extname(pptxFile));
+  fs.copyFileSync(pptxFile, copy); // trabalha numa cópia: o original pode estar aberto (e travado) no PowerPoint
+  const script = `
+$ErrorActionPreference = 'Stop'
+$a = Get-Content -Raw -Encoding UTF8 $args[0] | ConvertFrom-Json
+$pp = New-Object -ComObject PowerPoint.Application
+$had = $pp.Presentations.Count
+$pres = $pp.Presentations.Open($a.file, -1, 0, 0)
+try {
+  $h = [int]([double]$a.width * $pres.PageSetup.SlideHeight / $pres.PageSetup.SlideWidth)
+  for ($i = 1; $i -le $pres.Slides.Count; $i++) {
+    $pres.Slides.Item($i).Export((Join-Path $a.out ('slide-{0:D2}.png' -f $i)), 'PNG', [int]$a.width, $h)
+  }
+  Write-Output $pres.Slides.Count
+} finally {
+  $pres.Close()
+  if ($had -eq 0 -and $pp.Presentations.Count -eq 0) { $pp.Quit() }
+}`;
+  try {
+    const r = powershell(script, { file: copy, out: outDir, width });
+    if (!r.ok) return [];
+  } finally { fs.rmSync(work, { recursive: true, force: true }); }
+  return fs.readdirSync(outDir).filter((f) => /^slide-\d+\.png$/.test(f)).sort().map((f) => path.join(outDir, f));
+}
+
+// .pptx → .pdf pelo LibreOffice (para fotografar as páginas quando não há PowerPoint)
+export function libreOfficeToPdf(file) {
+  const lo = libreOfficeBin();
+  if (!lo) return null;
+  const out = tmpDir();
+  spawnSync(lo, ["--headless", "--convert-to", "pdf", "--outdir", out, file], { timeout: 300000 });
+  const f = fs.readdirSync(out).find((x) => x.endsWith(".pdf"));
+  return f ? { pdf: path.join(out, f), cleanup: () => fs.rmSync(out, { recursive: true, force: true }) } : null;
+}

package/src/import/omml.js

@@ -0,0 +1,69 @@
+// Equação do Office (OMML, <m:oMath>) → LaTeX para o KaTeX: frações, índices, raízes, somatórios/integrais,
+// parênteses, barras e acentos, funções, matrizes. O que não conhece vira o texto que tem dentro.
+import { kids, kid, textOf } from "./xml.js";
+
+const NARY = { "∑": "\\sum", "∏": "\\prod", "∫": "\\int", "∬": "\\iint", "∭": "\\iiint", "∮": "\\oint", "⋃": "\\bigcup", "⋂": "\\bigcap" };
+const SYM = { "α": "\\alpha", "β": "\\beta", "γ": "\\gamma", "δ": "\\delta", "Δ": "\\Delta", "ε": "\\varepsilon", "θ": "\\theta", "λ": "\\lambda", "μ": "\\mu", "ν": "\\nu", "π": "\\pi", "ρ": "\\rho", "σ": "\\sigma", "Σ": "\\Sigma", "τ": "\\tau", "φ": "\\varphi", "ω": "\\omega", "Ω": "\\Omega", "≤": "\\le ", "≥": "\\ge ", "≠": "\\ne ", "≈": "\\approx ", "×": "\\times ", "·": "\\cdot ", "∞": "\\infty ", "→": "\\to ", "±": "\\pm ", "∂": "\\partial ", "∇": "\\nabla " };
+const ACC = { "̅": "\\overline", "̂": "\\hat", "̃": "\\tilde", "̇": "\\dot", "⃗": "\\vec", "̄": "\\bar" };
+const FUNCS = new Set(["sin", "cos", "tan", "log", "ln", "exp", "lim", "max", "min", "sec", "csc", "cot", "arcsin", "arccos", "arctan"]);
+
+// letras matemáticas do Unicode (𝑥, 𝐀, 𝛼…) que o Word usa: viram a letra comum, que o KaTeX já põe em itálico
+function plainLetter(c) {
+  const cp = c.codePointAt(0);
+  if (cp === 0x210e) return "h";
+  if (cp >= 0x1d400 && cp <= 0x1d6a3) { const k = (cp - 0x1d400) % 52; return String.fromCharCode(k < 26 ? 65 + k : 97 + k - 26); }
+  if (cp >= 0x1d6a8 && cp <= 0x1d7c9) { const greek = "ΑΒΓΔΕΖΗΘΙΚΛΜΝΞΟΠΡϴΣΤΥΦΧΨΩ∇αβγδεζηθικλμνξοπρςστυφχψω∂ϵϑϰϕϱϖ"; return greek[(cp - 0x1d6a8) % 58] || c; }
+  if (cp >= 0x1d7ce && cp <= 0x1d7ff) return String((cp - 0x1d7ce) % 10);
+  return c;
+}
+const esc = (s) => [...s].map(plainLetter).map((c) => (SYM[c] ? SYM[c].replace(/([a-zA-Z])$/, "$1 ") : /[{}#$%&_]/.test(c) ? `\\${c}` : c)).join("");
+const val = (n, name) => kid(kid(n, name), "val")?.attrs["m:val"] ?? kid(n, name)?.attrs?.["m:val"];
+
+export function ommlToLatex(node) {
+  const conv = (n) => (n ? kids(n).map(one).join("") : "");
+  const arg = (n, name) => conv(kid(n, name));
+  const g = (s) => (s.length === 1 ? s : `{${s}}`);
+  function one(n) {
+    const k = n.name.split(":").pop();
+    switch (k) {
+      case "r": {
+        const t = kids(n, "t").map(textOf).join("");
+        const sty = kid(kid(n, "rPr"), "sty")?.attrs["m:val"];
+        if (FUNCS.has(t.trim())) return `\\${t.trim()} `;
+        return sty === "p" && /[a-z]{2,}/i.test(t) ? `\\mathrm{${esc(t)}}` : esc(t);
+      }
+      case "f": return `\\frac{${arg(n, "num")}}{${arg(n, "den")}}`;
+      case "sSup": return `${g(arg(n, "e"))}^{${arg(n, "sup")}}`;
+      case "sSub": return `${g(arg(n, "e"))}_{${arg(n, "sub")}}`;
+      case "sSubSup": return `${g(arg(n, "e"))}_{${arg(n, "sub")}}^{${arg(n, "sup")}}`;
+      case "sPre": return `{}_{${arg(n, "sub")}}^{${arg(n, "sup")}}${g(arg(n, "e"))}`;
+      case "rad": { const deg = arg(n, "deg"); return deg ? `\\sqrt[${deg}]{${arg(n, "e")}}` : `\\sqrt{${arg(n, "e")}}`; }
+      case "nary": {
+        const ch = kid(kid(n, "naryPr"), "chr")?.attrs["m:val"] || "∫";
+        const sub = arg(n, "sub"), sup = arg(n, "sup");
+        return `${NARY[ch] || esc(ch)}${sub ? `_{${sub}}` : ""}${sup ? `^{${sup}}` : ""} ${arg(n, "e")}`;
+      }
+      case "d": {
+        const pr = kid(n, "dPr");
+        const beg = kid(pr, "begChr")?.attrs["m:val"] ?? "(", end = kid(pr, "endChr")?.attrs["m:val"] ?? ")";
+        const sep = kid(pr, "sepChr")?.attrs["m:val"] ?? ",";
+        const L = (c) => (c === "" ? "." : c === "{" ? "\\{" : c === "}" ? "\\}" : c === "|" ? "|" : c === "‖" ? "\\|" : c === "⌈" ? "\\lceil" : c === "⌉" ? "\\rceil" : c === "⌊" ? "\\lfloor" : c === "⌋" ? "\\rfloor" : c === "〈" || c === "⟨" ? "\\langle" : c === "〉" || c === "⟩" ? "\\rangle" : c);
+        return `\\left${L(beg)}${kids(n, "e").map(conv).join(sep)}\\right${L(end)}`;
+      }
+      case "bar": return `${kid(kid(n, "barPr"), "pos")?.attrs["m:val"] === "bot" ? "\\underline" : "\\overline"}{${arg(n, "e")}}`;
+      case "acc": { const ch = kid(kid(n, "accPr"), "chr")?.attrs["m:val"] || "̂"; return `${ACC[ch] || "\\hat"}{${arg(n, "e")}}`; }
+      case "func": return `${arg(n, "fName").trim()} ${arg(n, "e")}`;
+      case "limLow": return `${arg(n, "e")}_{${arg(n, "lim")}}`;
+      case "limUpp": return `${arg(n, "e")}^{${arg(n, "lim")}}`;
+      case "groupChr": return `\\underbrace{${arg(n, "e")}}`;
+      case "box": case "borderBox": return arg(n, "e");
+      case "eqArr": return `\\begin{aligned}${kids(n, "e").map(conv).join("\\\\")}\\end{aligned}`;
+      case "m": return `\\begin{matrix}${kids(n, "mr").map((r) => kids(r, "e").map(conv).join("&")).join("\\\\")}\\end{matrix}`;
+      case "e": case "num": case "den": case "sub": case "sup": case "deg": case "fName": case "lim": case "oMath": case "oMathPara": return conv(n);
+      case "rPr": case "fPr": case "sSupPr": case "sSubPr": case "sSubSupPr": case "radPr": case "naryPr": case "dPr": case "barPr": case "accPr": case "funcPr": case "ctrlPr": case "limLowPr": case "limUppPr": case "eqArrPr": case "mPr": case "groupChrPr": case "boxPr": case "borderBoxPr": case "sPrePr": case "oMathParaPr": return "";
+      default: return conv(n) || textOf(n);
+    }
+  }
+  return one(node).replace(/\s+/g, " ").trim();
+}
+void val;