pindeck 2.8.2 → 2.10.0

package/lib/eids.mjs

@@ -145,8 +145,97 @@ function find(node, pred) {
   return hit;
 }
 
-/* Slides are leaf <section>s inside .slides; vertical-stack containers are not slides. */
+/* ---- Decks made without reveal.js ----------------------------------------------------------------
+   A deck names its slides with <meta name="pindeck:slides" content="main.deck > section.slide">, a CSS
+   selector, and its size with <meta name="pindeck:size" content="1440x1080">. Selectors stay simple, so
+   the server and the browser find the same slides: tag names, #id, .class, [attr] and [attr="value"],
+   joined by spaces (descendant) or ">" (child), in a comma-separated list. */
+
+const metaOf = (tree, name) => {
+  const m = find(tree, (c) => c.name === "meta" && c.attrs.name?.value.trim().toLowerCase() === `pindeck:${name}`);
+  return m ? decode(m.attrs.content?.value || "").trim() || null : null;
+};
+/* The deck's slide selector, or null for a reveal.js deck */
+export const slideSelector = (tree) => metaOf(tree, "slides");
+/* The deck's slide size from <meta name="pindeck:size">: { width, height } or null */
+export function deckSize(tree) {
+  const m = /^(\d{2,5})\s*[x×*,\s]\s*(\d{2,5})$/i.exec(metaOf(tree, "size") || "");
+  return m ? { width: +m[1], height: +m[2] } : null;
+}
+
+const IDENT = "-?[_a-zA-Z\\u00a0-\\uffff][\\w\\u00a0-\\uffff-]*";
+const COMPOUND = new RegExp(`^(?:(\\*|${IDENT})|#(${IDENT})|\\.(${IDENT})|\\[\\s*(${IDENT})\\s*(?:=\\s*(?:"([^"]*)"|'([^']*)'|(${IDENT}))\\s*)?\\])`);
+/* "main.deck > section.slide, aside.extra" -> one list of compounds and combinators per selector.
+   Throws with the part it cannot read (pseudo-classes, +, ~ ...). */
+export function parseSelector(sel) {
+  const parts = [];   // top-level commas only: not inside [attr="a,b"]
+  let quote = null, depth = 0, from = 0;
+  for (let i = 0; i < sel.length; i++) {
+    const c = sel[i];
+    if (quote) { if (c === quote) quote = null; }
+    else if (c === '"' || c === "'") quote = c;
+    else if (c === "[") depth++;
+    else if (c === "]") depth--;
+    else if (c === "," && !depth) { parts.push(sel.slice(from, i)); from = i + 1; }
+  }
+  parts.push(sel.slice(from));
+  return parts.map((part) => {
+    const steps = [];   // [{ tag, ids, classes, attrs }, ">" | " ", { ... }, ...]
+    let s = part.trim(), cur = null;
+    if (!s) throw new Error(`empty selector in "${sel}"`);
+    while (s) {
+      const ws = /^\s+/.exec(s);
+      const gt = /^\s*>\s*/.exec(s);
+      if (gt) { if (!cur) throw new Error(`"${part.trim()}" starts with ">"`); steps.push(">"); cur = null; s = s.slice(gt[0].length); continue; }
+      if (ws) { steps.push(" "); cur = null; s = s.slice(ws[0].length); continue; }
+      const m = COMPOUND.exec(s);
+      if (!m) throw new Error(`"${s.slice(0, 20)}" in "${part.trim()}" is not supported (use tags, #id, .class, [attr], spaces and ">")`);
+      if (!cur) { cur = { tag: null, ids: [], classes: [], attrs: [] }; steps.push(cur); }
+      if (m[1]) {
+        if (cur.tag || cur.ids.length || cur.classes.length || cur.attrs.length) throw new Error(`a tag name must come first in "${part.trim()}"`);
+        cur.tag = m[1] === "*" ? null : m[1].toLowerCase();
+      }
+      else if (m[2]) cur.ids.push(m[2]);
+      else if (m[3]) cur.classes.push(m[3]);
+      else cur.attrs.push({ name: m[4].toLowerCase(), value: m[5] ?? m[6] ?? m[7] ?? null });
+      s = s.slice(m[0].length);
+    }
+    if (typeof steps.at(-1) === "string") throw new Error(`"${part.trim()}" ends with a combinator`);
+    return steps;
+  });
+}
+function compoundMatches(node, c) {
+  if (!node.attrs) return false;   // the root
+  if (c.tag && node.name !== c.tag) return false;
+  if (c.ids.some((id) => node.attrs.id?.value !== id)) return false;
+  const cls = classesOf(node);
+  if (c.classes.some((k) => !cls.includes(k))) return false;
+  return c.attrs.every((a) => node.attrs[a.name] && (a.value == null || node.attrs[a.name].value === a.value));
+}
+/* steps[i] matches node, and the steps before it match its ancestors as their combinators say */
+function stepsMatch(node, steps, i = steps.length - 1) {
+  if (!compoundMatches(node, steps[i])) return false;
+  if (i === 0) return true;
+  if (steps[i - 1] === ">") return !!node.parent && stepsMatch(node.parent, steps, i - 2);
+  for (let a = node.parent; a; a = a.parent) if (stepsMatch(a, steps, i - 2)) return true;
+  return false;
+}
+/* Elements matching the selector, in document order; an element holding another match is a stack of
+   slides, not a slide (as with reveal.js's vertical stacks) */
+function selectorSlides(tree, sel) {
+  let list;
+  try { list = parseSelector(sel); } catch { return []; }
+  const hits = [];
+  walk(tree, (c) => { if (list.some((steps) => stepsMatch(c, steps))) hits.push(c); });
+  const inside = (a, b) => { for (let p = b.parent; p; p = p.parent) if (p === a) return true; return false; };
+  return hits.filter((h) => !hits.some((o) => o !== h && inside(h, o)));
+}
+
+/* Slides are leaf <section>s inside .slides; vertical-stack containers are not slides. A deck that names
+   its slides with <meta name="pindeck:slides"> has the elements that selector matches instead. */
 export function findSlides(tree) {
+  const sel = slideSelector(tree);
+  if (sel) return selectorSlides(tree, sel);
   const slidesEl = find(tree, (c) => classesOf(c).includes("slides"));
   if (!slidesEl) return [];
   const out = [];
@@ -187,6 +276,7 @@ function elementName(node) {
 export function assignEids(html) {
   const tree = parse(html);
   const sections = findSlides(tree);
+  const isSlide = slideSelector(tree) ? ((c) => sections.includes(c)) : ((c) => c.name === "section");
   const used = new Set();
   const edits = []; // { at, insert } or { start, end, replace }
   const assigned = [], renamed = [];
@@ -240,7 +330,7 @@ export function assignEids(html) {
     // Pass 2: elements inside the slide
     const visit = (node, inSvg) => {
       for (const c of node.children) {
-        if (c.name === "section") continue; // nested slide, handled on its own
+        if (isSlide(c)) continue; // nested slide, handled on its own
         const cls = classesOf(c);
         if (c.name === "aside" && cls.includes("notes")) continue;
         if (c.attrs["data-noeid"]) continue;
@@ -423,10 +513,11 @@ const slideKind = (n) => classList(n).find((c) => /-slide$/.test(c)) || "content
      content    title and two placeholder bullets, from a content slide (the current one if it is one)
      section    a section divider, from the deck's first divider
      duplicate  a copy of the current slide
-   Element ids are left out; assignEids() gives the new slide fresh ones.
+   Element ids are left out; assignEids() gives the new slide fresh ones. In a deck made without reveal.js,
+   the slide's own id is left out too: such decks (and Present) go to slides by their id.
    Returns { html, index } (index of the new slide) or { error }. */
 export function insertSlide(html, kind, afterEid) {
-  const slides = findSlides(parse(html));
+  const tree = parse(html), slides = findSlides(tree);
   if (!slides.length) return { error: "The deck has no slides." };
   const after = slides.find((s) => s.attrs["data-eid"]?.value === afterEid) || slides.at(-1);
   const hasHead = (s) => { let h = false; walk({ children: [s] }, (c) => { if (/^h[1-3]$/.test(c.name)) h = true; }); return h; };
@@ -437,6 +528,7 @@ export function insertSlide(html, kind, afterEid) {
   if (!tpl) return { error: kind === "section" ? "This deck has no section divider to model a new one on." : "This deck has no content slide to model a new one on." };
 
   let frag = html.slice(tpl.start, elementEnd(html, tpl)).replace(/\s+data-eid="[^"]*"/g, "");
+  if (slideSelector(tree)) frag = frag.replace(/^(<[^>]*?)\s+id=(?:"[^"]*"|'[^']*'|[^\s>]+)/, "$1");   // the opening tag only
   if (kind !== "duplicate") frag = placeholderSlide(frag, kind, slides.filter((s, i) => i <= slides.indexOf(after) && slideKind(s) === "section-slide").length + 1);
 
   const indent = lineIndent(html, after.start);
@@ -500,12 +592,13 @@ function slideBlock(html, s) {
    are. Slides inside vertical stacks are not moved. Returns { html, changed, from, index } or { error }. */
 export function moveSlide(html, eid, beforeEid) {
   const byEid = (all, e) => all.find((s) => s.attrs["data-eid"]?.value === e);
-  const slides = findSlides(parse(html));
+  const tree = parse(html), slides = findSlides(tree);
+  const bySelector = !!slideSelector(tree);   // such decks have no vertical stacks
   const slide = byEid(slides, eid), target = beforeEid == null ? null : byEid(slides, beforeEid);
   if (!slide || (beforeEid != null && !target)) return { error: "Slide not found in the file." };
-  if ([slide, target].some((s) => s?.parent.name === "section")) return { error: "Slides inside a vertical stack cannot be moved yet." };
+  if (!bySelector && [slide, target].some((s) => s?.parent.name === "section")) return { error: "Slides inside a vertical stack cannot be moved yet." };
   const from = slides.indexOf(slide);
-  const top = slide.parent.children.filter((c) => c.name === "section");
+  const top = slide.parent.children.filter((c) => (bySelector ? slides.includes(c) : c.name === "section"));
   const next = top[top.indexOf(slide) + 1] || null;
   if (target === slide || target === next) return { html, changed: false, from, index: from };
 
@@ -520,7 +613,7 @@ export function moveSlide(html, eid, beforeEid) {
     out = cut.slice(0, at) + text + `\n\n${indent}` + cut.slice(at);
   } else {
     // A final vertical stack is absent from the leaf-slide list, but we must insert after it.
-    const last = find(parse(cut), (c) => classesOf(c).includes("slides"))
+    const last = bySelector ? rest.at(-1) : find(parse(cut), (c) => classesOf(c).includes("slides"))
       .children.filter((c) => c.name === "section").at(-1);
     const at = elementEnd(cut, last);
     out = cut.slice(0, at) + `\n\n${indent}` + text + cut.slice(at);

package/lib/frameworks.mjs

@@ -0,0 +1,59 @@
+/* Which slide framework a deck uses. PinDeck edits reveal.js decks: <section> slides inside an element
+   with class "slides" (inside <div class="reveal">). Any other deck can name its slides itself with
+   <meta name="pindeck:slides" content="CSS selector"> (see lib/eids.mjs) and is then edited too. Other
+   frameworks are recognised by their markup and scripts, so the user gets a clear "not supported (yet)"
+   before PinDeck changes anything, instead of an editor without slides. Only tags and scripts are looked
+   at, never the slides' text, so a talk that mentions "impress.js" is not taken for one. */
+
+import { parse, findSlides, slideSelector, deckSize, parseSelector } from "./eids.mjs";
+
+const OTHERS = [   // name, markers; the first match wins (Marp before bespoke.js, which it is built on)
+  ["Marp", /\bmarpit\b|bespoke-marp|data-marpit|marp-cli/i],
+  ["Slidev", /slidev/i],
+  ["impress.js", /id=["']impress["']|impress(\.min)?\.js/i],
+  ["remark", /remark(-latest)?(\.min)?\.js|remark\.create\s*\(/i],
+  ["Spectacle", /<script[^>]+src=["'][^"']*spectacle/i],
+  ["Shower", /class=["'][^"']*\bshower\b|shower-core/i],
+  ["deck.js", /deck-container|deck\.core(\.min)?\.js/i],
+  ["bespoke.js", /bespoke(\.min)?\.js|bespoke\.from\s*\(/i],
+];
+
+/* Tags and script contents only: the slides' text could name any framework */
+const markup = (html) => [...String(html).matchAll(/<script\b[^>]*>[\s\S]*?<\/script>|<[^>]+>/gi)].map((m) => m[0]).join("\n");
+
+/* { name, supported }: reveal.js decks are supported, including one without slides yet, and so is a deck
+   whose <meta name="pindeck:slides"> selector finds slides and whose <meta name="pindeck:size"> gives their
+   size ({ name: "selector", selector, supported }) */
+export function detectFramework(html) {
+  const tree = parse(html), selector = slideSelector(tree);
+  if (selector) return { name: "selector", selector, supported: findSlides(tree).length > 0 && !!deckSize(tree) };
+  if (findSlides(tree).length) return { name: "reveal.js", supported: true };
+  const tags = markup(html);
+  const other = OTHERS.find(([, re]) => re.test(tags));
+  if (other) return { name: other[0], supported: false };
+  if (/class=["'][^"']*\breveal\b/i.test(tags) || /Reveal\.initialize\s*\(/.test(tags)) return { name: "reveal.js", supported: true };
+  return { name: null, supported: false };
+}
+
+const HOW = `A deck made otherwise can name its slides in its <head>: ` +
+  `<meta name="pindeck:slides" content="main.deck > section.slide"> (a CSS selector for the slides) and ` +
+  `<meta name="pindeck:size" content="1440x1080"> (their size in px).`;
+
+/* The message for a deck PinDeck cannot edit, or null */
+export function unsupportedMessage(html, file) {
+  const fw = detectFramework(html);
+  if (fw.supported) return null;
+  if (fw.name === "selector") {
+    // the slides are found: the size is what is missing (headless Chrome and the PDF pages need it)
+    if (findSlides(parse(html)).length) return `${file}: <meta name="pindeck:size"> is missing or not a size ` +
+      `such as content="1440x1080" (the slides' width and height in px). PinDeck opens the slides at that size ` +
+      `for screenshots and PDFs. Nothing was changed.`;
+    let why = "matches no elements";
+    try { parseSelector(fw.selector); } catch (e) { why = `cannot be used: ${e.message}`; }
+    return `${file}: the slide selector "${fw.selector}" in <meta name="pindeck:slides"> ${why}. Nothing was changed.`;
+  }
+  const what = fw.name ? `${file} is a ${fw.name} deck.` :
+    `${file} has no reveal.js slides (a <div class="reveal"> with <div class="slides"> holding <section> slides).`;
+  return `${what} PinDeck works with reveal.js decks; other frameworks may follow. ${HOW} ` +
+    `Nothing was changed.`;
+}

package/lib/instructions.mjs

@@ -0,0 +1,74 @@
+/* The deck's own instructions for Claude (CLAUDE.md, AGENTS.md), with @path imports expanded.
+
+   PinDeck does not load CLAUDE.md files from parent folders the way Claude Code does: those are usually
+   written for coding work PinDeck's Claude cannot do (tests, commits, package managers), they change
+   with where the deck happens to sit, and on a shared server a parent folder may be writable by others.
+   A deck pulls in shared rules explicitly instead: "Follow @../shared/STYLE.md" includes that file.
+
+   An import is "@" followed by a path (relative to the file it is in, absolute, or ~/...), at the start
+   of a line or after a space or "(". It is expanded only when that path is a text file: an e-mail address
+   or an @mention stays as it is. Imports in code spans and code blocks are left alone. Included files may
+   import others, up to 5 levels deep; each file is included once (no cycles), and all included text
+   together is limited to 200 KB. The imported text follows the file that imports it. */
+
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+const MAX_DEPTH = 5, MAX_BYTES = 200_000;
+
+/* Apply fn to the text outside code: fenced blocks (``` or ~~~) and `code spans` stay as they are */
+function outsideCode(text, fn) {
+  let fence = null;
+  return text.split("\n").map((line) => {
+    const f = /^\s*(```|~~~)/.exec(line);
+    if (f) { fence = fence ? (fence === f[1] ? null : fence) : f[1]; return line; }
+    if (fence) return line;
+    return line.split(/(`+[^`]*`+)/).map((part, i) => (i % 2 ? part : fn(part))).join("");
+  }).join("\n");
+}
+
+const resolveRef = (ref, dir) => (ref === "~" || ref.startsWith("~/") ? path.join(os.homedir(), ref.slice(1))
+  : path.resolve(dir, ref));
+
+function readText(file) {
+  try {
+    if (!fs.statSync(file).isFile()) return null;
+    const buf = fs.readFileSync(file);
+    return buf.includes(0) ? null : buf.toString("utf8");
+  } catch { return null; }
+}
+
+function expand(file, text, depth, seen, budget) {
+  const dir = path.dirname(file), found = [];
+  const body = outsideCode(text, (part) => part.replace(/(^|[\s(])@([^\s`()<>"']+)/g, (m, pre, raw) => {
+    const ref = raw.replace(/[.,:;!?]+$/, ""), tail = raw.slice(ref.length);   // "see @STYLE.md." ends a sentence
+    const abs = resolveRef(ref, dir);
+    const content = readText(abs);
+    if (content == null) return m;   // not a file: an e-mail address, an @mention, a typo
+    let real = abs;
+    try { real = fs.realpathSync(abs); } catch {}
+    const note = (why) => `${pre}${ref} (${why})${tail}`;
+    if (seen.has(real)) return note("included once, above or below");
+    if (depth >= MAX_DEPTH) return note("not included: imports nested too deep");
+    if (Buffer.byteLength(content) > budget.left) return note("not included: imported files over 200 KB in all");
+    budget.left -= Buffer.byteLength(content);
+    seen.add(real);
+    found.push({ ref, abs, content });
+    return note("included below");
+  }));
+  const parts = [body.trim()];
+  for (const imp of found) {
+    parts.push(`### ${imp.ref} (included by ${path.basename(file)})\n` + expand(imp.abs, imp.content, depth + 1, seen, budget));
+  }
+  return parts.filter(Boolean).join("\n\n");
+}
+
+/* A deck instruction file with its imports, or null when it is missing or empty */
+export function readInstructions(file) {
+  const text = readText(file);
+  if (text == null || !text.trim()) return null;
+  let real = file;
+  try { real = fs.realpathSync(file); } catch {}
+  return expand(file, text, 0, new Set([real]), { left: MAX_BYTES });
+}

package/lib/pdf-render.jxa.js

@@ -39,10 +39,12 @@ function run(argv) {
       null, w, h, 8, 4, true, false, $.NSDeviceRGBColorSpace, 0, 0);
     const ctx = $.NSGraphicsContext.graphicsContextWithBitmapImageRep(rep);
     $.NSGraphicsContext.saveGraphicsState;
-    $.NSGraphicsContext.currentContext = ctx;
-    $.NSColor.whiteColor.setFill;
-    $.NSRectFill($.NSMakeRect(0, 0, w, h));
+    $.NSGraphicsContext.setCurrentContext(ctx);
     const cg = ctx.CGContext;
+    // a white page, as in a PDF viewer (and as Poppler renders on Linux): most PDFs paint no background,
+    // and a transparent picture would show dark text on a dark slide
+    $.CGContextSetRGBFillColor(cg, 1, 1, 1, 1);
+    $.CGContextFillRect(cg, $.CGRectMake(0, 0, w, h));
     $.CGContextScaleCTM(cg, scale, scale);
     $.CGContextTranslateCTM(cg, tx, ty);
     page.drawWithBoxToContext($.kPDFDisplayBoxMediaBox, cg);

package/lib/pdf.mjs

@@ -46,7 +46,8 @@ function chromeRun(chrome, args, profile, done, timeout) {
     proc.stdout.on("data", (d) => { out += d; check(); });
     proc.stderr.on("data", (d) => { err += d; check(); });
     proc.on("error", (e) => finish(e));
-    proc.on("exit", () => (done(out, err) ? finish(null, out) : finish(new Error("Chrome exited early."))));
+    // "close", not "exit": at exit Chrome's last output (the line saying the file is written) may still be unread
+    proc.on("close", () => (done(out, err) ? finish(null, out) : finish(new Error("Chrome exited early."))));
   });
 }
 
@@ -61,7 +62,8 @@ export async function printLayout(chrome, url, profile) {
 /* Step 2: print a (static) page to a PDF file. */
 export async function printPdf(chrome, url, out, profile) {
   try { fs.rmSync(out, { force: true }); } catch {}
-  await chromeRun(chrome, ["--no-pdf-header-footer", `--print-to-pdf=${out}`, url], profile,
+  // the virtual-time budget lets Chrome follow PinDeck's login start page to the print page before printing
+  await chromeRun(chrome, ["--virtual-time-budget=5000", "--no-pdf-header-footer", `--print-to-pdf=${out}`, url], profile,
     (_o, e) => /bytes written to file/.test(e), 90000);
   if (!fs.existsSync(out)) throw new Error("Chrome did not write the PDF.");
   return out;

package/lib/platform-notice.mjs

@@ -2,13 +2,13 @@ import http from 'node:http';
 
 export function createPlatformNoticeServer(platform) {
   const windows = platform === 'win32';
-  const heading = windows ? 'Windows support is on the roadmap' : 'PinDeck currently requires macOS';
+  const heading = windows ? 'Windows support is on the roadmap' : 'PinDeck runs on macOS and Linux';
   const explanation = windows
-    ? 'PinDeck is currently available for macOS only. Windows support is planned for a future version; there is no release date yet.'
-    : 'This version of PinDeck supports macOS only. Linux and other operating systems are not supported yet.';
-  const html = `<!doctype html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>PinDeck · macOS required</title><style>
+    ? 'PinDeck runs on macOS and, as a beta, on Linux. Windows support is planned for a future version; there is no release date yet.'
+    : 'This version of PinDeck runs on macOS and, as a beta, on Linux. This operating system is not supported.';
+  const html = `<!doctype html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>PinDeck · system not supported</title><style>
   :root{font-family:system-ui,sans-serif;color:#243348;background:#f4f6f8;color-scheme:light}*{box-sizing:border-box}body{margin:0;min-height:100vh;display:grid;place-items:center;padding:24px}main{width:min(100%,620px);padding:40px;background:white;border:1px solid #dde3ea;border-radius:18px;box-shadow:0 12px 40px #20334d0a}.brand{font-weight:700;color:#c36516;margin:0 0 32px}h1{font-size:clamp(26px,5vw,36px);line-height:1.2;margin:0 0 20px}p{line-height:1.65}a{color:#945012}footer{margin-top:28px;font-size:14px;color:#596577}
-  </style></head><body><main><p class="brand">PinDeck</p><h1>${heading}</h1><p>${explanation}</p><p>Your deck has not been opened or changed, and no AI backend has been started.</p><p>You can use PinDeck on a Mac or follow updates on <a href="https://github.com/ehabets/PinDeck">GitHub</a>.</p><footer>Close this tab and press Ctrl+C in the terminal to stop this notice.</footer></main></body></html>`;
+  </style></head><body><main><p class="brand">PinDeck</p><h1>${heading}</h1><p>${explanation}</p><p>Your deck has not been opened or changed, and no AI backend has been started.</p><p>You can run PinDeck on a Mac or a Linux machine (and use it from this browser through an SSH tunnel), or follow updates on <a href="https://github.com/ehabets/PinDeck">GitHub</a>.</p><footer>Close this tab and press Ctrl+C in the terminal to stop this notice.</footer></main></body></html>`;
   return http.createServer((req, res) => {
     if (req.method !== 'GET' && req.method !== 'HEAD') { res.writeHead(405, { Allow: 'GET, HEAD' }); return res.end(); }
     res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8', 'Cache-Control': 'no-store',
@@ -28,7 +28,7 @@ export async function showPlatformNotice(port, platform = process.platform) {
     });
     server.listen(port, '127.0.0.1', () => {
       process.once('SIGINT', stop); process.once('SIGTERM', stop);
-      console.log(`PinDeck requires macOS. Open http://127.0.0.1:${server.address().port}/ for details. Press Ctrl+C to stop.`);
+      console.log(`PinDeck runs on macOS and Linux only. Open http://127.0.0.1:${server.address().port}/ for details. Press Ctrl+C to stop.`);
     });
   });
 }

package/lib/pptx-render.mjs

@@ -1,6 +1,10 @@
-/* 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.
+/* Pictures of PowerPoint slides, and of PDF pages.
+
+   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, PDF figures) to PNG.
+   Linux: LibreOffice (soffice --headless) exports the PDF, and Poppler (pdfinfo, pdftoppm) renders it.
+   Both are optional; lib/capabilities.mjs turns the features on when they are found.
 
    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
@@ -11,7 +15,8 @@ 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";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { findExecutable } from "./capabilities.mjs";
 
 const JXA = path.join(path.dirname(fileURLToPath(import.meta.url)), "pdf-render.jxa.js");
 const APPS = [
@@ -24,8 +29,16 @@ const osa = (args, timeout = 240000) => new Promise((resolve, reject) =>
     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)
 
+const mac = () => process.platform === "darwin";
+const tool = (...names) => names.map((n) => findExecutable(n).path).find(Boolean) || null;
+const run = (cmd, args, timeout = 120000) => new Promise((resolve, reject) =>
+  execFile(cmd, args, { timeout, maxBuffer: 1e7 }, (err, out, errOut) =>
+    err ? reject(new Error(String(errOut || err.message).trim().split("\n").pop())) : resolve(String(out))));
+export const popplerAvailable = () => !!(tool("pdftoppm") && tool("pdfinfo"));
+export const sofficePath = () => tool("soffice", "libreoffice");
+
 export function renderAvailable() {
-  return process.platform === "darwin" && APPS.some((a) => fs.existsSync(a.bundle));
+  return mac() ? APPS.some((a) => fs.existsSync(a.bundle)) : !!(sofficePath() && popplerAvailable());
 }
 
 function exportScript(app, pptx, pdf) {
@@ -58,7 +71,7 @@ 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.");
+  if (!mac()) return exportPdfLibreOffice(pptxPath, workDir);
   const errors = [];
   for (const app of APPS) {
     if (!fs.existsSync(app.bundle)) continue;
@@ -81,17 +94,73 @@ export async function exportPdf(pptxPath, workDir) {
   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. */
+/* Linux: LibreOffice exports the deck, hidden slides included (so page n is slide n). Its own profile in
+   the work folder, so a LibreOffice the user has open, or a stale lock, does not get in the way. */
+async function exportPdfLibreOffice(pptxPath, workDir) {
+  const soffice = sofficePath();
+  if (!soffice) throw new Error("LibreOffice (soffice) is not installed.");
+  const dir = fs.mkdtempSync(path.join(workDir, "libreoffice-"));
+  try {
+    const inFile = path.join(dir, "deck.pptx");
+    fs.copyFileSync(pptxPath, inFile);
+    await run(soffice, ["--headless", "--norestore", `-env:UserInstallation=${pathToFileURL(path.join(dir, "profile")).href}`,
+      "--convert-to", 'pdf:impress_pdf_Export:{"ExportHiddenSlides":{"type":"boolean","value":"true"}}',
+      "--outdir", dir, inFile], 240000);
+    const out = path.join(dir, "deck.pdf");
+    if (!fs.existsSync(out)) throw new Error("LibreOffice wrote no PDF.");
+    const pdf = path.join(workDir, "deck.pdf");
+    fs.copyFileSync(out, pdf);
+    return { pdf, app: "LibreOffice" };
+  } finally {
+    fs.rm(dir, { recursive: true, force: true }, () => {});
+  }
+}
+
+/* Renders pages or regions (see pdf-render.jxa.js for the jobs). 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 } = {}) {
+  if (!mac()) return renderPoppler(pdf, jobs, slideWidth);
   return +(await runJxa({ pdf, slideWidth, jobs }, workDir));
 }
 
-/* Page count and page sizes in points: { pages, sizes: [[w, h], ...] } (macOS only, no other app needed) */
+/* Page count and page sizes in points: { pages, sizes: [[w, h], ...] } (PDFKit or Poppler, no other app) */
 export async function pdfInfo(pdf, workDir) {
+  if (!mac()) return popplerInfo(pdf);
   return JSON.parse(await runJxa({ pdf, info: true }, workDir));
 }
 
+async function popplerInfo(pdf, exact = false) {
+  const pages = +(/^Pages:\s+(\d+)/m.exec(await run(tool("pdfinfo"), [pdf])) || [])[1];
+  if (!pages) throw new Error("pdfinfo could not read the PDF.");
+  const out = await run(tool("pdfinfo"), ["-f", "1", "-l", String(pages), pdf]);
+  const sizes = [...out.matchAll(/^Page\s+(\d+)\s+size:\s+([\d.]+) x ([\d.]+)/gm)]
+    .sort((a, b) => a[1] - b[1]).map((m) => (exact ? [+m[2], +m[3]] : [Math.round(+m[2]), Math.round(+m[3])]));
+  return { pages, sizes };
+}
+
+/* The same jobs as pdf-render.jxa.js, with pdftoppm: whole pages scaled to a width, or a box of the page
+   (in slide px) at job.scale output px per slide px. White background, as PDFKit's. */
+async function renderPoppler(pdf, jobs, slideWidth) {
+  const info = await popplerInfo(pdf, true);
+  for (const job of jobs) {
+    const size = info.sizes[job.page - 1];
+    if (!size) continue;
+    const [pw, ph] = size;
+    const args = ["-f", String(job.page), "-l", String(job.page), "-png", "-singlefile"];
+    if (job.box) {
+      const [x, y, bw, bh] = job.box, s = job.scale || 2, f = pw / (slideWidth || 1280);   // PDF points per slide px
+      args.push("-r", String((s / f) * 72), "-x", String(Math.round(x * s)), "-y", String(Math.round(y * s)),
+        "-W", String(Math.max(1, Math.round(bw * s))), "-H", String(Math.max(1, Math.round(bh * s))));
+    } else {
+      const scale = (job.width || 1280) / pw;
+      args.push("-scale-to-x", String(Math.round(pw * scale)), "-scale-to-y", String(Math.round(ph * scale)));
+    }
+    const prefix = job.out.replace(/\.png$/i, "");   // pdftoppm adds .png
+    await run(tool("pdftoppm"), [...args, pdf, prefix]);
+  }
+  return info.pages;
+}
+
 async function runJxa(spec, workDir) {
   const file = path.join(workDir, `jobs-${crypto.randomBytes(4).toString("hex")}.json`);
   fs.writeFileSync(file, JSON.stringify(spec));

package/lib/system-prompt.md

@@ -12,7 +12,9 @@ Each user message may start with an <editor-context> block:
 - 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.
+- {{DECK}}: the slides. theme.css: the styles. Edit these. You may also edit or create other files in the
+  deck folder when a request needs it (a script such as deck.js, a style sheet, the deck's notes), but not
+  vendor/ (third-party libraries). The user can undo everything a turn changed in one step.
 - 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
@@ -37,7 +39,7 @@ 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,
+`figures/` folder; <editor-context> lists their paths (relative to {{DECK}}), 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
@@ -84,7 +86,7 @@ If the user asks for a PDF, run `{{CLI}} pdf handout` (one page per slide, build
 
 ## 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
+inline styles on the element in {{DECK}}: `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

package/lib/waveform.mjs

@@ -1,7 +1,9 @@
 /* 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. */
+   WAV is read directly; other formats are converted to WAV first, with afconvert on macOS or ffmpeg on
+   Linux, when available. */
 
 import { execFile } from "node:child_process";
+import { findExecutable } from "./capabilities.mjs";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
@@ -52,12 +54,16 @@ function svgOf(wav) {
 /* 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") {
+  // other formats: decoded to 16-bit WAV by afconvert (macOS) or ffmpeg (Linux, when installed)
+  const ffmpeg = process.platform !== "darwin" && findExecutable("ffmpeg").path;
+  if (!wav && (process.platform === "darwin" || ffmpeg)) {
     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 },
+      const [cmd, args] = ffmpeg ? [ffmpeg, ["-v", "error", "-y", "-i", src, "-f", "wav", "-acodec", "pcm_s16le", out]]
+        : ["afconvert", ["-f", "WAVE", "-d", "LEI16", src, out]];
+      await new Promise((resolve, reject) => execFile(cmd, args, { timeout: 60000 },
         (err) => (err ? reject(err) : resolve())));
       wav = readWav(fs.readFileSync(out));
     } catch { wav = null; }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pindeck",
-  "version": "2.8.2",
-  "description": "PinDeck: a local macOS editor for HTML slide decks. Pin elements, describe the change, and Claude Code edits the slides.",
+  "version": "2.10.0",
+  "description": "PinDeck: an editor for HTML slide decks on macOS, and on Linux (beta) through an SSH tunnel. Pin elements, describe the change, and Claude Code edits the slides.",
   "keywords": [
     "slides",
     "presentation",
@@ -35,7 +35,10 @@
     "start": "node server.mjs",
     "test": "node --test"
   },
-  "os": ["darwin"],
+  "os": [
+    "darwin",
+    "linux"
+  ],
   "engines": {
     "node": ">=20"
   }