pindeck 0.0.0-stage → 2.8.0

package/lib/pptx-render.mjs

@@ -0,0 +1,100 @@
+/* Pictures of PowerPoint slides (macOS): PowerPoint, or else Keynote, exports the deck as a PDF with one
+   page per slide, hidden slides included; macOS PDFKit (pdf-render.jxa.js) then renders whole pages
+   (thumbnails, references for Claude) and regions (diagrams) to PNG.
+
+   Both apps are sandboxed, so the files go through a folder inside the app's own container, which
+   needs no permission dialog. macOS asks once whether PinDeck may control the app. An app that was
+   not running before is quit again afterwards. */
+
+import { execFile } from "node:child_process";
+import crypto from "node:crypto";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const JXA = path.join(path.dirname(fileURLToPath(import.meta.url)), "pdf-render.jxa.js");
+const APPS = [
+  { name: "Microsoft PowerPoint", bundle: "/Applications/Microsoft PowerPoint.app", container: "com.microsoft.Powerpoint" },
+  { name: "Keynote", bundle: "/Applications/Keynote.app", container: "com.apple.iWork.Keynote" },
+];
+
+const osa = (args, timeout = 240000) => new Promise((resolve, reject) =>
+  execFile("osascript", args, { timeout, maxBuffer: 1e7 }, (err, out, errOut) =>
+    err ? reject(new Error((errOut || err.message).trim().split("\n").pop())) : resolve(out.trim())));
+const q = (s) => JSON.stringify(s);   // AppleScript string literal (same quoting rules for paths)
+
+export function renderAvailable() {
+  return process.platform === "darwin" && APPS.some((a) => fs.existsSync(a.bundle));
+}
+
+function exportScript(app, pptx, pdf) {
+  if (app.name === "Microsoft PowerPoint") return `
+set wasRunning to application "Microsoft PowerPoint" is running
+tell application "Microsoft PowerPoint"
+  open (POSIX file ${q(pptx)})
+  set p to active presentation
+  repeat with i from 1 to (count of slides of p)
+    set hidden of slide show transition of slide i of p to false
+  end repeat
+  save p in (POSIX file ${q(pdf)}) as save as PDF
+  close p saving no
+  if not wasRunning then quit
+end tell
+return "ok"`;
+  return `
+set wasRunning to application "Keynote" is running
+tell application "Keynote"
+  set d to open (POSIX file ${q(pptx)})
+  repeat with s in slides of d
+    set skipped of s to false
+  end repeat
+  export d to (POSIX file ${q(pdf)}) as PDF
+  close d saving no
+  if not wasRunning then quit
+end tell
+return "ok"`;
+}
+
+/* Exports the deck to <workDir>/deck.pdf. Returns { pdf, app }. */
+export async function exportPdf(pptxPath, workDir) {
+  if (process.platform !== "darwin") throw new Error("Slide pictures need macOS with PowerPoint or Keynote.");
+  const errors = [];
+  for (const app of APPS) {
+    if (!fs.existsSync(app.bundle)) continue;
+    const box = path.join(os.homedir(), "Library", "Containers", app.container, "Data", "pindeck-import", crypto.randomBytes(6).toString("hex"));
+    try {
+      fs.mkdirSync(box, { recursive: true });
+      const inFile = path.join(box, "deck.pptx"), outFile = path.join(box, "deck.pdf");
+      fs.copyFileSync(pptxPath, inFile);
+      await osa(["-e", exportScript(app, inFile, outFile)]);
+      if (!fs.existsSync(outFile)) throw new Error("no PDF was written");
+      const pdf = path.join(workDir, "deck.pdf");
+      fs.copyFileSync(outFile, pdf);
+      return { pdf, app: app.name };
+    } catch (e) {
+      errors.push(`${app.name}: ${e.message}`);
+    } finally {
+      fs.rm(box, { recursive: true, force: true }, () => {});
+    }
+  }
+  throw new Error(errors.length ? errors.join("; ") : "Neither PowerPoint nor Keynote is installed.");
+}
+
+/* Renders pages or regions (see pdf-render.jxa.js). Returns the page count. Boxes are in slide px of a
+   page slideWidth wide; with slideWidth = the page width in points, they are in PDF points. */
+export async function renderJobs(pdf, jobs, workDir, { slideWidth = 1280 } = {}) {
+  return +(await runJxa({ pdf, slideWidth, jobs }, workDir));
+}
+
+/* Page count and page sizes in points: { pages, sizes: [[w, h], ...] } (macOS only, no other app needed) */
+export async function pdfInfo(pdf, workDir) {
+  return JSON.parse(await runJxa({ pdf, info: true }, workDir));
+}
+
+async function runJxa(spec, workDir) {
+  const file = path.join(workDir, `jobs-${crypto.randomBytes(4).toString("hex")}.json`);
+  fs.writeFileSync(file, JSON.stringify(spec));
+  try { return await osa(["-l", "JavaScript", JXA, file], 120000); }
+  finally { fs.rm(file, { force: true }, () => {}); }
+}

package/lib/pptx.mjs

@@ -0,0 +1,340 @@
+/* PowerPoint (.pptx) reader: turns a presentation into a plain model PinDeck can import.
+
+   readPptx(buffer) -> { width, height, slides: [slide] } with, per slide:
+     n, hidden, layout ("title", "secHead", "obj", ... or the layout's name), kind (title/section/content),
+     title, subtitle (strings), shapes (every shape with its box and, for text, its paragraphs),
+     steps (build steps: which shapes or paragraphs appear or disappear on which click), notes
+   Boxes are in slide pixels with the slide 1280 px wide (the PinDeck canvas). */
+
+import path from "node:path";
+import { readZip } from "./zip.mjs";
+import { parseXml, kid, kids, path as xpath, find, findAll, textOf } from "./xml.mjs";
+
+const R = "r:id", EMBED = "r:embed", LINK = "r:link";
+const BROWSER_IMAGES = new Set(["png", "jpg", "jpeg", "gif", "svg", "webp", "avif", "bmp"]);
+const on = (v) => v === "1" || v === "true" || v === "on";   // OOXML booleans
+
+function relsOf(zip, part) {
+  const relPath = path.posix.join(path.posix.dirname(part), "_rels", path.posix.basename(part) + ".rels");
+  const xml = zip.text(relPath);
+  const out = {};
+  if (!xml) return out;
+  for (const r of findAll(parseXml(xml), "Relationship")) {
+    const t = r.attrs.Target || "";
+    // relative to the part's folder, or absolute from the package root ("/ppt/slides/slide1.xml")
+    const target = r.attrs.TargetMode === "External" ? t
+      : path.posix.normalize(t.startsWith("/") ? t.slice(1) : path.posix.join(path.posix.dirname(part), t));
+    out[r.attrs.Id] = { target, type: (r.attrs.Type || "").split("/").pop(), external: r.attrs.TargetMode === "External" };
+  }
+  return out;
+}
+
+/* ---- Text ------------------------------------------------------------------------------------------ */
+/* A coloured run (not black, white or grey, and not a dark or light theme colour) is an accent */
+function accentColour(fill) {
+  const rgb = fill && kid(fill, "a:srgbClr")?.attrs.val;
+  if (rgb) {
+    const [r, g, b] = [0, 2, 4].map((i) => parseInt(rgb.slice(i, i + 2), 16) / 255);
+    const max = Math.max(r, g, b), min = Math.min(r, g, b);
+    return max > 0.25 && (max - min) / max > 0.4;
+  }
+  const scheme = fill && kid(fill, "a:schemeClr")?.attrs.val;
+  return !!scheme && /^accent\d$/.test(scheme);
+}
+
+function runsOf(p, rels) {
+  const runs = [];
+  const visit = (el) => {
+    for (const c of el.children || []) {
+      if (!c.name) continue;
+      if (c.name === "a:r" || c.name === "a:fld") {
+        const rPr = kid(c, "a:rPr");
+        const link = rPr && kid(rPr, "a:hlinkClick");
+        // only web and mail links: a javascript: or file: link must not reach the deck
+        const href = link && rels[link.attrs[R]]?.external && /^(https?:|mailto:)/i.test(rels[link.attrs[R]].target.trim())
+          ? rels[link.attrs[R]].target.trim() : null;
+        runs.push({ text: textOf(kid(c, "a:t")), b: rPr?.attrs.b === "1", i: rPr?.attrs.i === "1", href,
+          sup: rPr?.attrs.baseline > 0, sub: rPr?.attrs.baseline < 0, hl: accentColour(rPr && kid(rPr, "a:solidFill")) });
+      } else if (c.name === "a:br") runs.push({ br: true });
+      else if (c.name === "a14:m" || c.name === "m:oMathPara" || c.name === "m:oMath") runs.push({ math: c });
+      else if (c.name === "mc:AlternateContent") {
+        // prefer the math in mc:Choice; fall back to the plain text of mc:Fallback
+        const choice = kid(c, "mc:Choice"), fb = kid(c, "mc:Fallback");
+        const m = choice && (find(choice, "a14:m") || find(choice, "m:oMathPara") || find(choice, "m:oMath"));
+        if (m) runs.push({ math: m });
+        else if (fb) visit(fb);
+      }
+    }
+  };
+  visit(p);
+  // PowerPoint splits text into many runs (spell checking, edits); join neighbours that look the same.
+  // A run of only spaces carries no visible formatting, so it joins the run before it.
+  const same = (a, b) => a.b === b.b && a.i === b.i && a.href === b.href && a.sup === b.sup && a.sub === b.sub && a.hl === b.hl;
+  const out = [];
+  for (const r of runs) {
+    const last = out[out.length - 1];
+    if (r.text != null && last?.text != null && (same(last, r) || (!r.text.trim() && !r.href))) last.text += r.text;
+    else out.push(r.text != null ? { ...r } : r);
+  }
+  return out;
+}
+/* Font sizes in hundredths of a point per list level (1-9), from a list style (a:lstStyle, p:bodyStyle) */
+function levelSizes(style) {
+  const out = {};
+  for (let l = 1; l <= 9; l++) {
+    const sz = xpath(style, `a:lvl${l}pPr`, "a:defRPr")?.attrs.sz;
+    if (sz) out[l - 1] = +sz;
+  }
+  return out;
+}
+/* sizes: { own (the shape's lstStyle), inherited (master body or other style), base (presentation default) } */
+function paragraphsOf(txBody, rels, { bulletsByDefault, sizes = {}, pxPerPt = 1 }) {
+  if (!txBody) return [];
+  const out = [];
+  const own = levelSizes(kid(txBody, "a:lstStyle"));
+  const scale = +(xpath(txBody, "a:bodyPr", "a:normAutofit")?.attrs.fontScale || 100000) / 100000;
+  let index = -1;
+  for (const p of kids(txBody, "a:p")) {
+    index++;   // counts empty paragraphs too: animations refer to paragraphs by this number
+    const pPr = kid(p, "a:pPr");
+    const runs = runsOf(p, rels);
+    const lvl = +(pPr?.attrs.lvl || 0);
+    const runSz = Math.max(0, ...findAll(p, "a:rPr").map((r) => +(r.attrs.sz || 0)));
+    const sz = runSz || +(kid(p, "a:endParaRPr")?.attrs.sz || 0) || own[lvl] || sizes.inherited?.[lvl] || sizes.base?.[lvl] || 1800;
+    const plain = runs.map((r) => r.text || "").join("");
+    if (!plain.trim() && !runs.some((r) => r.math)) continue;
+    const level = +(pPr?.attrs.lvl || 0);
+    let bullet = bulletsByDefault;
+    if (pPr && kid(pPr, "a:buNone")) bullet = false;
+    if (pPr && (kid(pPr, "a:buChar") || kid(pPr, "a:buAutoNum"))) bullet = true;
+    out.push({ index, level, bullet, numbered: !!(pPr && kid(pPr, "a:buAutoNum")), runs, size: sz / 100 * scale * pxPerPt });
+  }
+  return out;
+}
+const plainText = (paras) => paras.map((p) => p.runs.map((r) => (r.br ? "\n" : r.math ? findAll(r.math, "m:t").map(textOf).join("") : r.text || "")).join("")).join("\n").trim();
+
+/* ---- Geometry: group transforms map child coordinates onto the slide -------------------------------- */
+const IDENTITY = { sx: 1, sy: 1, tx: 0, ty: 0 };
+function boxOf(spPr, t) {
+  const x = spPr && kid(spPr, "a:xfrm");
+  const off = x && kid(x, "a:off"), ext = x && kid(x, "a:ext");
+  if (!off || !ext) return null;
+  return { x: +off.attrs.x * t.sx + t.tx, y: +off.attrs.y * t.sy + t.ty, w: +ext.attrs.cx * t.sx, h: +ext.attrs.cy * t.sy };
+}
+function groupTransform(grpSpPr, t) {
+  const x = grpSpPr && kid(grpSpPr, "a:xfrm");
+  if (!x) return t;
+  const off = kid(x, "a:off"), ext = kid(x, "a:ext"), chOff = kid(x, "a:chOff"), chExt = kid(x, "a:chExt");
+  if (!off || !ext || !chOff || !chExt) return t;
+  const sx = (+ext.attrs.cx / (+chExt.attrs.cx || 1)), sy = (+ext.attrs.cy / (+chExt.attrs.cy || 1));
+  // child -> parent: (c - chOff) * s + off, then the parent's own transform
+  return { sx: sx * t.sx, sy: sy * t.sy, tx: (+off.attrs.x - +chOff.attrs.x * sx) * t.sx + t.tx, ty: (+off.attrs.y - +chOff.attrs.y * sy) * t.sy + t.ty };
+}
+
+/* ---- Placeholders: positions come from the layout or master when the slide does not set them ---------- */
+function placeholderOf(sp) {
+  const nvPr = xpath(sp, "p:nvSpPr", "p:nvPr") || xpath(sp, "p:nvPicPr", "p:nvPr") || xpath(sp, "p:nvGraphicFramePr", "p:nvPr");
+  const ph = nvPr && kid(nvPr, "p:ph");
+  return ph ? { type: ph.attrs.type || "body", idx: ph.attrs.idx ?? null } : null;
+}
+function placeholderBoxes(zip, part) {
+  const xml = zip.text(part);
+  if (!xml) return [];
+  const out = [];
+  for (const sp of findAll(parseXml(xml), "p:sp")) {
+    const ph = placeholderOf(sp), b = boxOf(kid(sp, "p:spPr"), IDENTITY);
+    if (ph && b) out.push({ ...ph, box: b });
+  }
+  return out;
+}
+function inheritBox(ph, layoutPhs, masterPhs) {
+  const same = (list) => list.find((p) => ph.idx != null && p.idx === ph.idx) ||
+    list.find((p) => p.type === ph.type || (ph.type === "ctrTitle" && p.type === "title") || (ph.type === "subTitle" && p.type === "body"));
+  return (same(layoutPhs) || same(masterPhs))?.box || null;
+}
+
+/* ---- Shapes ------------------------------------------------------------------------------------------- */
+const hasVisibleFill = (sp) => {
+  const spPr = kid(sp, "p:spPr");
+  if (spPr && kid(spPr, "a:noFill")) return false;
+  if (spPr && ["a:solidFill", "a:gradFill", "a:blipFill", "a:pattFill"].some((n) => kid(spPr, n))) return true;
+  const fillRef = xpath(sp, "p:style", "a:fillRef");
+  return !!fillRef && +fillRef.attrs.idx > 0;
+};
+const hasVisibleLine = (sp) => {
+  const ln = xpath(sp, "p:spPr", "a:ln");
+  if (ln && kid(ln, "a:noFill")) return false;
+  if (ln && kid(ln, "a:solidFill")) return true;
+  const lnRef = xpath(sp, "p:style", "a:lnRef");
+  return !!lnRef && +lnRef.attrs.idx > 0;
+};
+
+/* groupId: the id of the outermost group a shape is in (an animation of a group moves all its shapes) */
+function collectShapes(tree, t, ctx, out, groupId = null) {
+  for (const c of tree.children || []) {
+    if (!c.name) continue;
+    if (c.name === "p:grpSp") {
+      if (on(xpath(c, "p:nvGrpSpPr", "p:cNvPr")?.attrs.hidden)) continue;
+      collectShapes(c, groupTransform(kid(c, "p:grpSpPr"), t), ctx, out, groupId || xpath(c, "p:nvGrpSpPr", "p:cNvPr")?.attrs.id || null);
+      continue;
+    }
+    if (c.name === "mc:AlternateContent") { const ch = kid(c, "mc:Choice") || kid(c, "mc:Fallback"); if (ch) collectShapes(ch, t, ctx, out, groupId); continue; }
+    if (!["p:sp", "p:pic", "p:graphicFrame", "p:cxnSp"].includes(c.name)) continue;
+    const ph = placeholderOf(c);
+    const spPr = kid(c, "p:spPr") || kid(c, "p:xfrm") && { children: [{ ...kid(c, "p:xfrm"), name: "a:xfrm" }] };
+    let box = boxOf(spPr, t);
+    if (!box && ph) box = inheritBox(ph, ctx.layoutPhs, ctx.masterPhs);
+    const cNvPr = xpath(c, "p:nvSpPr", "p:cNvPr") || xpath(c, "p:nvPicPr", "p:cNvPr") || xpath(c, "p:nvGraphicFramePr", "p:cNvPr") || xpath(c, "p:nvCxnSpPr", "p:cNvPr");
+    if (on(cNvPr?.attrs.hidden)) continue;   // hidden in PowerPoint's selection pane
+    const s = { tag: c.name.slice(2), id: cNvPr?.attrs.id || null, group: groupId, name: cNvPr?.attrs.name || "", descr: cNvPr?.attrs.descr || "", ph, box };
+    if (c.name === "p:sp") {
+      s.txBox = xpath(c, "p:nvSpPr", "p:cNvSpPr")?.attrs.txBox === "1";
+      s.geom = xpath(c, "p:spPr", "a:prstGeom")?.attrs.prst || (xpath(c, "p:spPr", "a:custGeom") ? "custom" : null);
+      s.paras = paragraphsOf(kid(c, "p:txBody"), ctx.rels, { bulletsByDefault: !!ph && ["body", "obj"].includes(ph.type),
+        pxPerPt: ctx.pxPerPt, sizes: { inherited: ph ? (["title", "ctrTitle"].includes(ph.type) ? ctx.styles.title : ctx.styles.body) : ctx.styles.other, base: ctx.styles.base } });
+      s.filled = hasVisibleFill(c);
+      s.lined = hasVisibleLine(c);
+    } else if (c.name === "p:pic") {
+      const blip = find(c, "a:blip");
+      const rel = blip && ctx.rels[blip.attrs[EMBED] || blip.attrs[LINK]];
+      s.media = rel && !rel.external ? rel.target : null;
+      s.ext = s.media ? path.posix.extname(s.media).slice(1).toLowerCase() : null;
+      s.displayable = !!s.ext && BROWSER_IMAGES.has(s.ext);
+      s.cropped = !!find(c, "a:srcRect") && Object.keys(find(c, "a:srcRect").attrs).length > 0;
+      const nvPr = xpath(c, "p:nvPicPr", "p:nvPr");
+      const av = nvPr && (kid(nvPr, "a:audioFile") || kid(nvPr, "a:videoFile"));
+      const p14 = nvPr && find(nvPr, "p14:media");
+      if (av || p14) {
+        const r = ctx.rels[(p14 && p14.attrs[EMBED]) || (av && (av.attrs[LINK] || av.attrs[EMBED]))];
+        s.av = { kind: av?.name === "a:videoFile" ? "video" : r && /video|\.(mp4|mov|m4v|webm)$/i.test(r.target) ? "video" : "audio",
+          media: r && !r.external ? r.target : null };
+      }
+    } else if (c.name === "p:graphicFrame") {
+      const uri = find(c, "a:graphicData")?.attrs.uri || "";
+      s.table = uri.endsWith("/table") ? tableOf(find(c, "a:tbl"), ctx) : null;
+      s.chart = uri.endsWith("/chart");
+      s.diagram = uri.endsWith("/diagram");
+      s.ole = uri.endsWith("/ole");
+    }
+    if (s.box) s.box = { x: s.box.x / ctx.emu, y: s.box.y / ctx.emu, w: s.box.w / ctx.emu, h: s.box.h / ctx.emu };
+    out.push(s);
+  }
+  return out;
+}
+
+/* Tables: rows of cells with their paragraphs; merged cells are marked so they can be left out */
+function tableOf(tbl, ctx) {
+  if (!tbl) return null;
+  const pr = kid(tbl, "a:tblPr");
+  const rows = kids(tbl, "a:tr").map((tr) => kids(tr, "a:tc").map((tc) => ({
+    paras: paragraphsOf(kid(tc, "a:txBody"), ctx.rels, { bulletsByDefault: false, pxPerPt: ctx.pxPerPt, sizes: { inherited: ctx.styles.other, base: ctx.styles.base } }),
+    colspan: +(tc.attrs.gridSpan || 1), rowspan: +(tc.attrs.rowSpan || 1),
+    merged: on(tc.attrs.hMerge) || on(tc.attrs.vMerge),
+    below: on(tc.attrs.vMerge) && !on(tc.attrs.hMerge),   // under a row-spanning cell (holds its colspan)
+  })));
+  return { rows, header: on(pr?.attrs.firstRow) };
+}
+
+/* ---- Build steps ----------------------------------------------------------------------------------------
+   The main sequence of p:timing: each click starts a group; effects "with" or "after" the previous one
+   belong to the same click. Returns [{ click, kind: "in" | "out", shape, from, to }] where from/to are
+   paragraph numbers when only some paragraphs of a text animate. Effects before the first click play
+   when the slide opens (click 0). */
+function stepsOf(root) {
+  const seq = findAll(find(root, "p:timing"), "p:cTn").find((n) => n.attrs.nodeType === "mainSeq");
+  if (!seq) return [];
+  const out = [];
+  let click = 0;
+  for (const group of kids(kid(seq, "p:childTnLst"), "p:par")) {
+    const cTn = kid(group, "p:cTn");
+    // a click starts the group, unless it plays by itself when the slide opens: then PowerPoint adds
+    // an onBegin condition to the "indefinite" one
+    const conds = kids(xpath(cTn, "p:stCondLst"), "p:cond");
+    if (conds.some((c) => c.attrs.delay === "indefinite") && !conds.some((c) => c.attrs.evt === "onBegin")) click++;
+    for (const eff of findAll(group, "p:cTn").filter((n) => n.attrs.presetClass)) {
+      const kind = eff.attrs.presetClass === "entr" ? "in" : eff.attrs.presetClass === "exit" ? "out" : null;
+      if (!kind) continue;
+      const seen = new Set();
+      for (const tgt of findAll(eff, "p:spTgt")) {
+        const rg = xpath(tgt, "p:txEl", "p:pRg");
+        const key = `${tgt.attrs.spid}/${rg ? rg.attrs.st + "-" + rg.attrs.end : ""}`;
+        if (seen.has(key)) continue;   // one effect animates its target in several behaviours
+        seen.add(key);
+        out.push({ click, kind, shape: tgt.attrs.spid, from: rg ? +rg.attrs.st : null, to: rg ? +rg.attrs.end : null });
+      }
+    }
+  }
+  return out;
+}
+
+/* ---- Presentation ---------------------------------------------------------------------------------------- */
+export function readPptx(buf) {
+  const zip = readZip(buf);
+  const presPart = "ppt/presentation.xml";
+  const pres = parseXml(zip.text(presPart) || "");
+  const presRels = relsOf(zip, presPart);
+  const sz = find(pres, "p:sldSz");
+  const cx = +(sz?.attrs.cx || 12192000), cy = +(sz?.attrs.cy || 6858000);
+  const emu = cx / 1280;
+  const baseSizes = levelSizes(find(pres, "p:defaultTextStyle"));
+  const masterStyles = new Map();
+  const stylesOf = (part) => {
+    if (!part) return {};
+    if (!masterStyles.has(part)) {
+      const tx = find(parseXml(zip.text(part) || ""), "p:txStyles");
+      masterStyles.set(part, { title: levelSizes(kid(tx, "p:titleStyle")), body: levelSizes(kid(tx, "p:bodyStyle")), other: levelSizes(kid(tx, "p:otherStyle")) });
+    }
+    return masterStyles.get(part);
+  };
+  const slides = [];
+  let n = 0;
+  for (const id of findAll(pres, "p:sldId")) {
+    const part = presRels[id.attrs[R]]?.target;
+    if (!part || !zip.has(part)) continue;
+    n++;
+    const sld = parseXml(zip.text(part));
+    const root = kid(sld, "p:sld");
+    const rels = relsOf(zip, part);
+    const layoutPart = Object.values(rels).find((r) => r.type === "slideLayout")?.target;
+    const layoutXml = layoutPart && zip.text(layoutPart);
+    const layoutRoot = layoutXml && kid(parseXml(layoutXml), "p:sldLayout");
+    const masterPart = layoutPart && Object.values(relsOf(zip, layoutPart)).find((r) => r.type === "slideMaster")?.target;
+    const ctx = { rels, emu, pxPerPt: 1280 / (cx / 12700), styles: { ...stylesOf(masterPart), base: baseSizes }, layoutPhs: layoutPart ? placeholderBoxes(zip, layoutPart) : [], masterPhs: masterPart ? placeholderBoxes(zip, masterPart) : [] };
+    const tree = xpath(root, "p:cSld", "p:spTree");
+    const shapes = tree ? collectShapes(tree, IDENTITY, ctx, []) : [];
+
+    const isTitlePh = (s) => s.ph && ["title", "ctrTitle"].includes(s.ph.type);
+    const titleShape = shapes.find(isTitlePh);
+    const titleLines = titleShape ? plainText(titleShape.paras).split(/\n+/).map((l) => l.trim()).filter(Boolean) : [];
+    const subShape = shapes.find((s) => s.ph?.type === "subTitle");
+    const layoutType = layoutRoot?.attrs.type || "";
+    const layoutName = kid(layoutRoot, "p:cSld")?.attrs.name || "";
+    // custom layouts have no type; a first slide whose layout is called "Title ..." is the title slide
+    const kind = layoutType === "title" || titleShape?.ph.type === "ctrTitle" ||
+      (n === 1 && /title|titel/i.test(layoutName) && !/content|inhalt|text|only|nur/i.test(layoutName)) ? "title"
+      : layoutType === "secHead" || /^section|abschnitt/i.test(layoutName) ? "section" : "content";
+
+    // notes: the body placeholder of the notes slide
+    const notesPart = Object.values(rels).find((r) => r.type === "notesSlide")?.target;
+    let notes = "";
+    if (notesPart && zip.has(notesPart)) {
+      const nx = parseXml(zip.text(notesPart));
+      const body = findAll(nx, "p:sp").find((sp) => placeholderOf(sp)?.type === "body");
+      if (body) notes = plainText(paragraphsOf(kid(body, "p:txBody"), {}, { bulletsByDefault: false }));
+    }
+
+    slides.push({
+      n, part, hidden: root?.attrs.show === "0" || root?.attrs.show === "false", layout: layoutType || layoutName, kind,
+      // a subtitle placeholder often holds the authors, event and institute too: its first line is the subtitle
+      title: titleLines[0] || "", subtitle: subShape ? plainText(subShape.paras.slice(0, 1)).replace(/\s*\n\s*/g, " ") : titleLines.slice(1).join(" "),
+      titleParas: titleShape?.paras || [],
+      shapes: shapes.filter((s) => !(s.ph && ["dt", "ftr", "sldNum", "hdr"].includes(s.ph.type))),
+      steps: stepsOf(root),
+      notes,
+    });
+  }
+  return { width: 1280, height: Math.round(1280 * cy / cx), slides, zip };
+}
+
+/* Media bytes of a part path (e.g. "ppt/media/image3.png"). */
+export const mediaOf = (model, part) => model.zip.read(part);

package/lib/system-prompt.md

@@ -0,0 +1,97 @@
+You are working inside PinDeck, a slide editor. The user sees the deck in a browser
+and talks to you through a narrow chat sidebar next to the slides.
+
+## What a message contains
+Each user message may start with an <editor-context> block:
+- the slide the user is looking at,
+- numbered pins [1], [2], ... : clicks on slide elements. Each pin names the element by its
+  data-eid, its box in slide coordinates, the click point and the clicked word. The user refers
+  to pins by number ("1: move left", "make [3] bold").
+- a measured layout of the affected slides (1280 x 720 px canvas, origin top left), taken in the
+  user's browser, with any layout issues found.
+- sometimes the path of a screenshot of the slide with the pin markers drawn on it.
+
+## Files
+- index.html: the slides. theme.css: the styles. Edit these.
+- brand.css is LOCKED (logos, footer, brand colours). Never edit it. If a request needs a brand
+  change, say so instead. Elements marked brand-locked are positioned by brand.css.
+- Follow the deck's CLAUDE.md (at the end of these instructions) and README.md for the template's
+  conventions.
+
+## Element ids
+Every slide <section> and visible element has a data-eid attribute ("summary", "summary/callout").
+- Keep existing ids unchanged when you edit an element, even if you change its content or class.
+- When you add an element, give it data-eid="<slide-eid>/<short-name>", unique in the deck.
+- When you add a slide, give the <section> a new id (a slug of its title) and prefix its elements.
+- The editor adds missing ids after your turn, so a forgotten one is not fatal.
+
+## SVG markers and gradients
+reveal.js hides every slide but the current one, and a marker, gradient or pattern used through
+url(#id) draws nothing while the element defining it is hidden. Define shared ones in the deck's
+`<svg class="svg-defs">` right after `<body>`, outside the slides (add that SVG if the deck has none).
+
+## Hidden slides
+A slide with data-visibility="hidden" on its <section> is hidden: it stays in the deck and in the
+editor, but reveal.js skips it when presenting and in PDF exports. The user hides and shows slides
+in the editor. Do not delete hidden slides, and do not unhide them unless asked.
+
+## Attached files
+The user can attach figures and audio to a message. PinDeck has already saved them in the deck's
+`figures/` folder; <editor-context> lists their paths (relative to index.html), size and, for audio,
+the duration and a generated waveform SVG. If a file was dropped onto a slide, the drop position is
+given too. Put them on slides with the deck's existing patterns: a figure like the other `figure.fig`
+blocks, audio like the deck's audio demo (audio element, play button, waveform). Read an image
+directly to see what it shows before you write a caption: Read scales large photos down itself, so
+never convert or resize files first. Do not rename or move the files.
+
+## Attached PDFs
+The user can also attach a PDF: a figure or table to take over, or a paper or report with more
+details. PDFs are not part of the deck: PinDeck keeps them outside the deck folder, and
+<editor-context> gives the absolute path, the page count and the page size. Read the PDF directly
+(for more than 10 pages, Read with pages, e.g. "3-6", at most 20 pages at a time) and use what the
+user asks for: facts, numbers and wording for slides, or a figure.
+- Tables: rebuild them as HTML tables in the deck's table style; do not use a picture of a table.
+- Figures: render the figure to PNG and put it on the slide like any other figure.
+    {{CLI}} pdf-figure <pdf> <page> [x,y,w,h] [figures/<name>.png]
+  The box x,y,w,h is in fractions of the page from the top left (e.g. 0.12,0.08,0.76,0.3); without
+  it the whole page is rendered. Without a figures/ name the PNG goes to a scratch folder and the
+  command prints its path: Read it to check the crop (the whole figure with its axis labels, no
+  caption or body text), adjust the box, then render once more with a figures/ name. That file may
+  be rendered again under the same name; other existing files are never overwritten. The PNG is
+  1600 px wide by default (--width <px> to change it).
+- Never put the PDF itself on a slide or link it from the deck.
+
+## Commands
+The only shell commands you can run here are the PinDeck commands below ({{CLI}} ...), each on
+its own: no scripts, heredocs, temporary files, loops, variables or `&&` chains, and no python, sips,
+convert or ls. Such commands are refused (or need an approval nobody can give) and are not run. A
+refused command did nothing: do not retry it as it is, do it another way.
+- To change files, use Edit, even for large changes: several Edit calls in a row are fine.
+- To look at files, use Read, Grep and Glob.
+- To check several slides, name them all: `{{CLI}} layout 9 10 11 --issues`.
+
+## Checking your work
+The browser reloads by itself when you save. After changing positions, sizes, fonts or content
+amount, check the result:
+  {{CLI}} layout <slide-eid or number>...
+It prints the measured layout and issues (content below the footer rule, outside the slide,
+overlapping elements, clipped text); add --issues to print only the issues. Fix what you caused. Use
+  {{CLI}} shot <slide-eid or number>...
+only when you need a visual judgement the numbers cannot give (balance, figure content, colour)
+or the user asks; it prints the path of a PNG, which you then Read.
+If the user asks for a PDF, run `{{CLI}} pdf handout` (one page per slide, build steps complete) or
+`{{CLI}} pdf presentation` (one page per build step); it prints the path of the PDF.
+
+## Hand edits
+The user can also select, move and resize elements in the editor. Those changes are written as
+inline styles on the element in index.html: `translate: Xpx Ypx` for moves, `width`/`height` (and
+`max-width`/`max-height: none`) for sizes. You get a note about each one. Treat them as intended;
+keep them unless asked. If the user asks to clean up, move them into proper CSS rules.
+The user can also edit text in place (double-click); you get a note with the new text. Keep their
+wording unless asked to change it.
+A selected element is listed in <editor-context>; "this" or "it" usually means that element.
+
+## Replies
+Replies appear in a narrow sidebar. Keep them short: 1 to 4 sentences saying what you changed,
+referring to pins by number. No code dumps; the user can open the diff. If a request is
+ambiguous and would change several slides or the whole theme, ask first.

package/lib/waveform.mjs

@@ -0,0 +1,67 @@
+/* Waveform SVG for an audio file, as the editor makes for attached audio (bars, viewBox 1000 x 120):
+   WAV is read directly; other formats are converted to WAV first with macOS afconvert, if available. */
+
+import { execFile } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+/* Samples of a PCM or float WAV file as one array per channel (null if the format is not supported,
+   or the file is damaged) */
+function readWav(buf) {
+  try { return wavOf(buf); } catch { return null; }
+}
+function wavOf(buf) {
+  if (buf.toString("ascii", 0, 4) !== "RIFF" || buf.toString("ascii", 8, 12) !== "WAVE") return null;
+  let fmt = null, data = null;
+  for (let p = 12; p + 8 <= buf.length;) {
+    const id = buf.toString("ascii", p, p + 4), size = buf.readUInt32LE(p + 4);
+    if (id === "fmt ") fmt = { format: buf.readUInt16LE(p + 8), channels: buf.readUInt16LE(p + 10), bits: buf.readUInt16LE(p + 22) };
+    if (id === "data") data = buf.subarray(p + 8, Math.min(buf.length, p + 8 + size));
+    p += 8 + size + (size & 1);
+  }
+  if (!fmt || !data || !fmt.channels || !fmt.bits) return null;
+  const format = fmt.format === 0xfffe ? (fmt.bits === 32 && data.length ? 3 : 1) : fmt.format;   // extensible: guess from the bits
+  const bytes = fmt.bits / 8, frames = Math.floor(data.length / (bytes * fmt.channels));
+  const read = format === 3 && fmt.bits === 32 ? (o) => data.readFloatLE(o)
+    : format === 1 && fmt.bits === 16 ? (o) => data.readInt16LE(o) / 32768
+    : format === 1 && fmt.bits === 24 ? (o) => data.readIntLE(o, 3) / 8388608
+    : format === 1 && fmt.bits === 32 ? (o) => data.readInt32LE(o) / 2147483648
+    : format === 1 && fmt.bits === 8 ? (o) => (data[o] - 128) / 128 : null;
+  if (!read) return null;
+  return { frames, channels: fmt.channels, sample: (i, c) => read((i * fmt.channels + c) * bytes) };
+}
+
+function svgOf(wav) {
+  const n = 220, W = 1000, H = 120, len = wav.frames;
+  const peaks = [];
+  for (let i = 0; i < n; i++) {
+    let m = 0;
+    const a = Math.floor((i * len) / n), b = Math.floor(((i + 1) * len) / n);
+    for (let c = 0; c < wav.channels; c++) for (let j = a; j < b; j += 4) m = Math.max(m, Math.abs(wav.sample(j, c)));
+    peaks.push(m);
+  }
+  const top = Math.max(...peaks) || 1;
+  const bars = peaks.map((p, i) => {
+    const h = Math.max(3, (p / top) * (H - 10));
+    return `<rect x="${(i * W / n + 1.2).toFixed(1)}" y="${((H - h) / 2).toFixed(1)}" width="${(W / n - 2.4).toFixed(1)}" height="${h.toFixed(1)}" rx="2"/>`;
+  }).join("");
+  return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${W} ${H}" preserveAspectRatio="none"><g fill="#6B7785">${bars}</g></svg>`;
+}
+
+/* Returns the SVG text, or null if the audio cannot be read */
+export async function waveformSvg(data, ext) {
+  let wav = /^wav(e)?$/i.test(ext) ? readWav(data) : null;
+  if (!wav && process.platform === "darwin") {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pindeck-wave-"));
+    try {
+      const src = path.join(dir, `in.${ext || "audio"}`), out = path.join(dir, "out.wav");
+      fs.writeFileSync(src, data);
+      await new Promise((resolve, reject) => execFile("afconvert", ["-f", "WAVE", "-d", "LEI16", src, out], { timeout: 60000 },
+        (err) => (err ? reject(err) : resolve())));
+      wav = readWav(fs.readFileSync(out));
+    } catch { wav = null; }
+    finally { fs.rmSync(dir, { recursive: true, force: true }); }
+  }
+  try { return wav && wav.frames ? svgOf(wav) : null; } catch { return null; }
+}

package/lib/xml.mjs

@@ -0,0 +1,55 @@
+/* Tiny XML parser for Office Open XML: elements, attributes and text, nothing more.
+   Names keep their prefixes ("p:sp", "a:t"); entities are decoded. */
+
+const ENT = { amp: "&", lt: "<", gt: ">", quot: '"', apos: "'" };
+const decode = (s) => s.replace(/&(#x[0-9a-f]+|#\d+|\w+);/gi, (m, e) => {
+  if (e[0] !== "#") return ENT[e] ?? m;
+  const cp = e[1] === "x" || e[1] === "X" ? parseInt(e.slice(2), 16) : +e.slice(1);
+  return cp <= 0x10ffff ? String.fromCodePoint(cp) : "\ufffd";   // no such character: a stand-in, not an error
+});
+
+export function parseXml(src) {
+  const root = { name: "#doc", attrs: {}, children: [] };
+  const stack = [root];
+  const re = /<!--[\s\S]*?-->|<\?[\s\S]*?\?>|<!\[CDATA\[([\s\S]*?)\]\]>|<(\/?)([\w:.-]+)((?:\s+[\w:.-]+\s*=\s*(?:"[^"]*"|'[^']*'))*)\s*(\/?)>|([^<]+)/g;
+  let m;
+  while ((m = re.exec(src))) {
+    const top = stack[stack.length - 1];
+    if (m[1] !== undefined) { top.children.push({ text: m[1] }); continue; }
+    if (m[6] !== undefined) { if (top !== root) top.children.push({ text: decode(m[6]) }); continue; }
+    if (!m[3]) continue;   // comment or processing instruction
+    if (m[2]) { if (stack.length > 1) stack.pop(); continue; }   // a stray closing tag never closes the document
+    const el = { name: m[3], attrs: {}, children: [] };
+    for (const a of m[4].matchAll(/([\w:.-]+)\s*=\s*(?:"([^"]*)"|'([^']*)')/g)) el.attrs[a[1]] = decode(a[2] ?? a[3]);
+    top.children.push(el);
+    if (!m[5]) stack.push(el);
+  }
+  return root;
+}
+
+/* Helpers on parsed elements */
+export const kids = (el, name) => (el?.children || []).filter((c) => c.name && (!name || c.name === name));
+export const kid = (el, name) => (el?.children || []).find((c) => c.name === name) || null;
+export function path(el, ...names) {
+  let cur = el;
+  for (const n of names) { cur = kid(cur, n); if (!cur) return null; }
+  return cur;
+}
+export function find(el, name) {   // first descendant with this name
+  for (const c of el?.children || []) {
+    if (!c.name) continue;
+    if (c.name === name) return c;
+    const hit = find(c, name);
+    if (hit) return hit;
+  }
+  return null;
+}
+export function findAll(el, name, out = []) {
+  for (const c of el?.children || []) {
+    if (!c.name) continue;
+    if (c.name === name) out.push(c);
+    findAll(c, name, out);
+  }
+  return out;
+}
+export const textOf = (el) => (el?.children || []).map((c) => (c.text != null ? c.text : textOf(c))).join("");