pindeck 3.0.0-beta.3 → 3.2.0-beta.1

package/lib/eids.mjs

@@ -276,7 +276,8 @@ 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 sectionSet = new Set(sections);
+  const isSlide = slideSelector(tree) ? ((c) => sectionSet.has(c)) : ((c) => c.name === "section");
   const used = new Set();
   const edits = []; // { at, insert } or { start, end, replace }
   const assigned = [], renamed = [];
@@ -286,9 +287,12 @@ export function assignEids(html) {
   const mainCount = {};
   titles.forEach((t) => { if (t.main) mainCount[t.main] = (mainCount[t.main] || 0) + 1; });
 
+  // each base remembers the next number to try: thousands of "…/li" stay linear, not quadratic
+  const next = new Map();
   const unique = (base) => {
-    let name = base, k = 2;
+    let name = base, k = next.get(base) || 2;
     while (used.has(name)) name = `${base}-${k++}`;
+    next.set(base, k);
     used.add(name);
     return name;
   };
@@ -344,10 +348,13 @@ export function assignEids(html) {
   });
 
   if (!edits.length) return { html, changed: false, assigned, renamed, slides };
-  edits.sort((a, b) => b.start - a.start);
-  let out = html;
-  for (const e of edits) out = out.slice(0, e.start) + e.replace + out.slice(e.end);
-  return { html: out, changed: true, assigned, renamed, slides };
+  // in one pass over the file, not one copy of it per edit
+  edits.sort((a, b) => a.start - b.start);
+  const parts = [];
+  let pos = 0;
+  for (const e of edits) { parts.push(html.slice(pos, e.start), e.replace); pos = e.end; }
+  parts.push(html.slice(pos));
+  return { html: parts.join(""), changed: true, assigned, renamed, slides };
 }
 
 /* ---- Inline style edits (drag and resize in the editor) ---------------------------------- */
@@ -406,6 +413,8 @@ export function setStyles(html, edits) {
 /* The element with this id, or a descendant reached by element-child indices (path), e.g. a
    table cell [2] under a row that has the id. */
 function nodeAt(html, eid, path = [], { anyKind = false } = {}) {
+  // an id and a path of child positions, or nothing (an element without an id must never match a missing one)
+  if (typeof eid !== "string" || !eid || !Array.isArray(path) || !path.every((i) => Number.isInteger(i) && i >= 0)) return null;
   let node = null;
   walk(parse(html), (c) => { if (node) return false; if (c.attrs?.["data-eid"]?.value === eid) { node = c; return false; } });
   for (const i of path) node = node?.children[i] || null;

package/lib/login.mjs

@@ -0,0 +1,75 @@
+/* Who may read the editor, the deck and the API: shared by the front (pindeck) and each deck server.
+
+   The token never appears in a page or on a command line, where other users of a shared server could read
+   it (ps, curl). A browser logs in once with a one-time code (printed at start, or by `pindeck login`) and
+   then holds the token in an HttpOnly cookie; the CLI, Claude and the front send it in a header. Browsers
+   share cookies across all ports of a host, so the cookie name carries the server's port. */
+
+import crypto from "node:crypto";
+import { execFile } from "node:child_process";
+
+/* Pages opened as 127.0.0.1 or localhost only, on any port: an SSH tunnel may use another local port.
+   Another site's name pointed at 127.0.0.1 (DNS rebinding) must not read the editor page, its token or the deck. */
+export const goodHost = (h) => /^(127\.0\.0\.1|localhost)(:\d{1,5})?$/.test(h);
+
+export const LOGIN_PAGE = `<!doctype html><meta charset="utf-8"><title>PinDeck</title>
+<body style="font:16px system-ui,sans-serif;max-width:36em;margin:4em auto;padding:0 1em">
+<h1>Log in to PinDeck</h1><p>Open the login link that PinDeck printed when it started. Links work once;
+for a new one, run <code>pindeck login</code> in the deck folder (or <code>node front.mjs login</code> in a
+PinDeck checkout).</p>`;
+
+export function cookie(req, name) {
+  for (const part of String(req.headers.cookie || "").split(";")) {
+    const i = part.indexOf("=");
+    if (i > 0 && part.slice(0, i).trim() === name) return part.slice(i + 1).trim();
+  }
+  return null;
+}
+
+/* port() and origin() are read on use: --port 0 learns the port only once listening */
+export function createLogin({ token, port, origin }) {
+  const loginCodes = new Map();   // code -> expiry (ms)
+  function loginCode(ttl) {
+    const now = Date.now();
+    for (const [c, exp] of loginCodes) if (exp < now) loginCodes.delete(c);
+    const code = crypto.randomBytes(16).toString("hex");
+    loginCodes.set(code, now + ttl);
+    return code;
+  }
+  const loginUrl = (code, next = "/") => `${origin()}/login?` + new URLSearchParams({ code, ...(next !== "/" ? { next } : {}) });
+  const cookieName = () => `pindeck-${port()}`;
+  const sameSecret = (a) => typeof a === "string" && a.length === token.length &&
+    crypto.timingSafeEqual(Buffer.from(a), Buffer.from(token));
+  const authed = (req) => sameSecret(req.headers["x-editor-token"]) || sameSecret(cookie(req, cookieName()));
+  /* A one-time code: set the cookie, then go on with a same-origin navigation (a redirect from a cross-site
+     start, such as a file:// page or a link in a terminal, would not carry a SameSite=Strict cookie). */
+  function login(res, url) {
+    const code = url.searchParams.get("code") || "";
+    const exp = loginCodes.get(code);
+    loginCodes.delete(code);
+    if (!exp || exp < Date.now()) {
+      res.writeHead(403, { "content-type": "text/html; charset=utf-8", "cache-control": "no-store" });
+      return res.end(LOGIN_PAGE.replace("<p>", "<p>This login link has expired or was used already. "));
+    }
+    // a path on this server only: browsers drop tabs and line breaks from a URL, so "/\t/site" means "//site"
+    let next = url.searchParams.get("next") || "/";
+    if (!next.startsWith("/") || /[\\\x00-\x1f\x7f]/.test(next) || next.startsWith("//") ||
+        new URL(next, "http://127.0.0.1").host !== "127.0.0.1") next = "/";
+    res.writeHead(200, { "content-type": "text/html; charset=utf-8", "cache-control": "no-store",
+      "set-cookie": `${cookieName()}=${token}; HttpOnly; SameSite=Strict; Path=/` });
+    const to = JSON.stringify(next).replace(/</g, "\\u003c");
+    res.end(`<!doctype html><meta charset="utf-8"><title>PinDeck</title><script>location.replace(${to})</script>`);
+  }
+  return { loginCode, loginUrl, cookieName, authed, login };
+}
+
+/* On a Mac, in a terminal: Enter opens a new login link in the default browser (open(1)), so the printed link
+   need not be copied. Each Enter asks for a new link: a link works once. Elsewhere (a server reached through an
+   SSH tunnel, a test, a pipe) nothing changes. */
+export function openOnEnter(newLink, { platform = process.platform, input = process.stdin, open = (url) => execFile("open", [url], () => {}) } = {}) {
+  if (platform !== "darwin" || !input.isTTY) return false;
+  console.log("  Press Enter to open PinDeck in your browser.");
+  input.setEncoding?.("utf8");
+  input.on("data", (d) => { if (/[\r\n]/.test(String(d))) open(newLink()); });
+  return true;
+}

package/lib/models.mjs

@@ -13,10 +13,13 @@ export function normalizeModels(provider, rows = []) {
       isDefault: m.isDefault || id === 'default' }];
   });
 }
+/* Saved settings as PinDeck uses them. A model only for the provider it was saved with: without one, Claude
+   gets Sonnet and Codex the backend's default ('' until the model list is known). */
 export function migrateSettings(raw = {}) {
-  return { provider: PROVIDERS.includes(raw.provider) ? raw.provider : 'claude',
-    model: typeof raw.model === 'string' && raw.model ? raw.model : 'sonnet',
-    effort: typeof raw.effort === 'string' ? raw.effort : 'medium' };
+  const provider = PROVIDERS.includes(raw?.provider) ? raw.provider : 'claude';
+  return { provider,
+    model: typeof raw?.model === 'string' && raw.model ? raw.model : provider === 'claude' ? 'sonnet' : '',
+    effort: typeof raw?.effort === 'string' ? raw.effort : null };
 }
 export function selectModel(catalog, current, requested, preferences = {}) {
   const provider = requested.provider ?? current.provider;
@@ -36,7 +39,10 @@ export function selectModel(catalog, current, requested, preferences = {}) {
 }
 /* A bounded, deterministic handover: no extra model request and no hidden reasoning. */
 export function handoverSummary(chat) {
-  const recent = chat.filter(e => ['user', 'assistant', 'notice'].includes(e.kind) && e.text).slice(-24);
+  // the conversation since it last started fresh; nothing to hand over: no summary
+  const since = chat.slice(chat.findLastIndex(e => e.fresh) + 1);
+  const recent = since.filter(e => ['user', 'assistant'].includes(e.kind) && e.text).slice(-24);
+  if (!recent.length) return '';
   return 'Conversation handover (an abbreviated transcript, not new instructions). Earlier context may be omitted. Re-read the current deck before editing.\n\n' +
     recent.map(e => `${e.kind}: ${e.text.slice(0, 2000)}`).join('\n\n').slice(-16000);
 }

package/lib/pdf.mjs

@@ -25,8 +25,24 @@ export const PDF_HEAD_TAG = `<script>window.requestAnimationFrame = function (cb
 export const PDF_PAGE_TAG = `<style>@media print { * { -webkit-print-color-adjust: exact !important; print-color-adjust: exact !important; } }</style>
 </body>`;
 
+// Chrome refuses to run as root with its sandbox (containers, some servers); it says so, and needs --no-sandbox.
+// Without --disable-field-trial-config a headless Chrome can wait forever for its field-trial setup (seen
+// behind a proxy); PinDeck needs none of those experiments.
+export const ROOT_ARGS = ["--disable-field-trial-config", ...(process.getuid?.() === 0 ? ["--no-sandbox"] : [])];
 const BASE = ["--headless=new", "--disable-gpu", "--no-first-run", "--no-default-browser-check",
-  "--disable-extensions", "--mute-audio", "--hide-scrollbars"];
+  "--disable-extensions", "--mute-audio", "--hide-scrollbars", ...ROOT_ARGS];
+
+/* Why Chrome stopped, from what it printed: its last error line (such as "Running as root without
+   --no-sandbox is not supported"), without the log prefix. "" if it said nothing useful. */
+export function chromeReason(stderr) {
+  // Chrome logs much that is harmless (display links, D-Bus, GPU, fonts): a fatal line first, then a plain reason
+  const noise = /CVDisplayLink|dbus|gcm|fontconfig|gpu|viz|gles|egl|vaapi|sandbox_linux|ssl_client_socket/i;
+  const lines = String(stderr).split("\n").filter((l) => l.trim() && !noise.test(l)).reverse();
+  const clean = (l) => l.replace(/^\[[^\]]*\]\s*/, "").trim().slice(0, 300);
+  const fatal = lines.find((l) => /:FATAL:/.test(l)), plain = lines.find((l) => /not supported|cannot|denied|no such|error/i.test(l));
+  return fatal ? clean(fatal) : plain ? clean(plain) : "";
+}
+const exited = (what, err) => new Error(`${what}${chromeReason(err) ? `: ${chromeReason(err)}` : "."}`);
 
 /* Runs Chrome with args, stops it once done(stdout, stderr) is true (Chrome often lingers). */
 function chromeRun(chrome, args, profile, done, timeout) {
@@ -47,7 +63,7 @@ function chromeRun(chrome, args, profile, done, timeout) {
     proc.stderr.on("data", (d) => { err += d; check(); });
     proc.on("error", (e) => finish(e));
     // "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."))));
+    proc.on("close", () => (done(out, err) ? finish(null, out) : finish(exited("Chrome exited early", err))));
   });
 }
 

package/lib/servers.mjs

@@ -0,0 +1,91 @@
+/* The PinDecks running for this user, and which one serves a deck: shared by the front, the deck server,
+   `pindeck login` and cli.mjs.
+
+   Each PinDeck process (a front, a deck server on its own, or one behind a front) keeps a file of its own in
+   ~/.pindeck-v3/servers/<pid>.json (0600, in a 0700 folder) with its address and token. Several fronts and
+   servers can run side by side (another --port, another PINDECK_HOME user, a server started on its own) and
+   none overwrites another's file; a file whose process is gone is removed when it is read. */
+
+import fs from "node:fs";
+import path from "node:path";
+
+const dirOf = (home) => path.join(home, "servers");
+export const alive = (pid) => { try { process.kill(pid, 0); return true; } catch (e) { return e.code === "EPERM"; } };
+
+/* info: { url, token, front?, key?, deckDir?, behindFront? }. Returns the function that removes the file again
+   (only if it is still ours). */
+export function registerServer(home, info) {
+  const dir = dirOf(home);
+  fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+  // written whole and private from the start: a reader (pindeck login, cli.mjs) never sees half of it
+  const file = path.join(dir, `${process.pid}.json`), tmp = path.join(dir, `.${process.pid}.json.tmp`);
+  fs.writeFileSync(tmp, JSON.stringify({ ...info, pid: process.pid }, null, 2), { mode: 0o600 });
+  fs.chmodSync(tmp, 0o600);
+  fs.renameSync(tmp, file);
+  return () => { try { if (JSON.parse(fs.readFileSync(file, "utf8")).token === info.token) fs.rmSync(file, { force: true }); } catch {} };
+}
+
+/* The running ones, the newest first */
+export function runningServers(home) {
+  let names = [];
+  try { names = fs.readdirSync(dirOf(home)).filter((f) => /^\d+\.json$/.test(f)); } catch {}
+  const out = [];
+  for (const name of names) {
+    const file = path.join(dirOf(home), name);
+    try {
+      const info = JSON.parse(fs.readFileSync(file, "utf8"));
+      if (alive(info.pid)) { out.push({ ...info, since: fs.statSync(file).mtimeMs }); continue; }
+    } catch {}
+    try { fs.rmSync(file, { force: true }); } catch {}
+  }
+  return out.sort((a, b) => b.since - a.since);
+}
+
+const ask = async (s, p) => {
+  const res = await fetch(`${s.url}${p}`, { headers: { "x-editor-token": s.token }, signal: AbortSignal.timeout(5000) });
+  if (!res.ok) throw new Error(String(res.status));
+  return res.json();
+};
+
+const real = (p) => { try { return fs.realpathSync(p); } catch { return path.resolve(p); } };
+
+/* Who serves a deck (a deckTarget): { front, key } a front whose deck list has it (open or not), under that
+   front's key for it, and/or { own } its deck server if one runs (on its own, or behind a front). Decks are
+   compared by real path: the same folder can be named through a symlink (on macOS a terminal in /var/... is
+   in /private/var/...). null: no running PinDeck serves it. */
+export async function serverFor(home, deck) {
+  const all = runningServers(home), file = real(path.join(deck.dir, deck.file));
+  const own = all.find((s) => !s.front && (s.key === deck.key || real(path.join(s.deckDir, s.deckFile || "index.html")) === file)) || null;
+  for (const f of all.filter((s) => s.front)) {
+    try {
+      const { decks } = await ask(f, "/api/decks");
+      const d = decks.find((x) => !x.problem && (x.key === deck.key || real(path.join(x.root, x.rel)) === file));
+      if (d) return { front: f, key: d.key, own };
+    } catch {}
+  }
+  return own ? { front: null, key: own.key, own } : null;
+}
+
+/* pindeck login [deck]: a new one-time login link, from the PinDeck that serves the deck (the link then opens
+   it), or from each PinDeck running when no deck is named. Prints and exits. */
+export async function printLogin(home, deck) {
+  let targets;
+  if (deck) {
+    const found = await serverFor(home, deck);
+    const shown = path.join(deck.dir, deck.file);
+    if (!found || (!found.front && found.own.behindFront)) {
+      console.error(`No running PinDeck serves ${shown}.` + (runningServers(home).length ? " Open it from a running PinDeck's deck menu, or start PinDeck for it." : ""));
+      process.exit(1);
+    }
+    targets = [found.front ? { s: found.front, next: `/d/${found.key}/`, label: shown } : { s: found.own, next: "/", label: shown }];
+  } else {
+    targets = runningServers(home).filter((s) => !s.behindFront).map((s) => ({ s, next: "/", label: s.deckDir }));
+    if (!targets.length) { console.error("No PinDeck is running."); process.exit(1); }
+  }
+  let ok = true;
+  for (const { s, next, label } of targets) {
+    try { console.log(`PinDeck (${label}): ${(await ask(s, "/api/login-link?" + new URLSearchParams({ next }))).url}`); }
+    catch { ok = false; console.error(`The PinDeck at ${s.url} (${label}) does not answer. Is it still running?`); }
+  }
+  process.exit(ok ? 0 : 1);
+}

package/lib/usage.mjs

@@ -0,0 +1,15 @@
+/* pindeck --help, and the hint after a bad argument: the front (front.mjs) and a deck server (server.mjs)
+   take the same arguments. */
+export const USAGE = `Usage: pindeck [deck-folder | deck-file.html] [--port 5180] [--provider claude|codex] [--model <name>] [--asset-root <folder>]...
+       pindeck login [deck-folder | deck-file.html]
+
+Opens a reveal.js deck in PinDeck: a deck file such as talk.html, or a folder (default: the current
+folder), which then opens its index.html; a folder without one opens a list of its decks. A deck made
+otherwise names its slides in its <head> with <meta name="pindeck:slides" content="<CSS selector>"> and
+<meta name="pindeck:size" content="1440x1080">.
+In the editor, the deck's name opens the other decks in the deck's folder and the asset roots (and one
+folder down), each with its own chat and undo, on the same port and login.
+login prints a new one-time login link for the running PinDeck (with a deck: one that opens that deck).
+--asset-root lets the deck use files outside its folder: a folder that contains the deck (paths such as
+../shared/style.css then work), or one that symlinks in the deck may point to. Repeatable; also
+"assetRoots" in ~/.pindeck-v3/config.json.`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pindeck",
-  "version": "3.0.0-beta.3",
+  "version": "3.2.0-beta.1",
   "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 or OpenAI Codex edits the slides.",
   "keywords": [
     "slides",
@@ -23,9 +23,10 @@
   "bugs": "https://github.com/ehabets/PinDeck/issues",
   "type": "module",
   "bin": {
-    "pindeck": "server.mjs"
+    "pindeck": "front.mjs"
   },
   "files": [
+    "front.mjs",
     "server.mjs",
     "cli.mjs",
     "lib/",
@@ -34,7 +35,7 @@
     "LICENSE"
   ],
   "scripts": {
-    "start": "node server.mjs",
+    "start": "node front.mjs",
     "test": "node --test"
   },
   "os": [

package/public/bridge.js

@@ -19,7 +19,17 @@
   const SLIDE_SEL = deckMeta("slides") || null;
   const SLIDE = SLIDE_SEL ? `:is(${SLIDE_SEL})` : ".reveal .slides section";   // in CSS and closest()
   const SLIDE_OF = SLIDE_SEL || "section";   // the slide an element is on
-  const host = () => (window.parent !== window ? window.parent.__editorHost : null);
+  /* The editor, reached by messages: the deck runs sandboxed in an origin of its own (see VIEW in server.mjs),
+     so it cannot touch the editor page. Every call answers with a promise of the editor's return value. */
+  const PARENT = window.parent !== window ? window.parent : null;
+  let callSeq = 0;
+  const answers = new Map();   // id -> resolve
+  const hostCalls = new Proxy({}, { get: (_, method) => method === "then" ? undefined : (...args) => new Promise((resolve) => {
+    const id = ++callSeq;
+    answers.set(id, resolve);
+    PARENT.postMessage({ pindeck: "host", id, method, args }, "*");
+  }) });
+  const host = () => (PARENT ? hostCalls : null);
   let W = 1280, H = 720, deck = null;   // deck: reveal.js or a selector deck (see "Decks" below)
 
   /* ---- Styles for editor-only overlays ---------------------------------------- */
@@ -128,7 +138,8 @@
       hasFooter: !!sec.querySelector(".slide-foot"), hidden };
   }
   function info() {
-    return { slides: slides().map((s, i) => slideInfo(s, i)), current: indexOf(deck.current()) };
+    // hash: the slide's address in the deck opened on its own (Present), where hidden slides are left out
+    return { slides: slides().map((s, i) => ({ ...slideInfo(s, i), hash: deck.hash(i) })), current: indexOf(deck.current()) };
   }
 
   /* ---- Layout measurement ------------------------------------------------------------- */
@@ -801,12 +812,22 @@
     tail.setStart(r.startContainer, r.startOffset);
     const subList = [...el.children].find((c) => c.tagName === "UL" || c.tagName === "OL");
     if (subList) tail.setEndBefore(subList); else tail.setEnd(el, el.childNodes.length);
+    // the elements the caret is in (an equation, a <strong>): the split cuts each in two, and extractContents
+    // copies them, attributes and all, into the new bullet
+    const cut = [];
+    for (let n = r.startContainer; n && n !== el; n = n.parentNode) if (n.nodeType === 1) cut.unshift(n);
     const frag = tail.extractContents();
     const li = document.createElement("li");
     const cls = [...el.classList].filter((c) => !c.startsWith("__") && c !== "visible" && c !== "current-fragment").join(" ");
     if (cls) li.className = cls;
     li.appendChild(frag);
     el.after(li);
+    // their copies: no id of their own (the server gives new ones), and gone where the split left them
+    // empty, on either side (no empty <strong> or equation line left behind)
+    const copies = [];
+    for (let n = li.firstChild, i = 0; i < cut.length && n?.nodeType === 1 && n.tagName === cut[i].tagName; n = n.firstChild, i++) copies.push(n);
+    for (const n of copies) n.removeAttribute("data-eid");
+    for (const n of [...cut, ...copies].reverse()) if (n.isConnected && isBlank(n)) n.remove();
     // no stray spaces at the split
     const trim = (node, end) => {
       const w = document.createTreeWalker(node, NodeFilter.SHOW_TEXT);
@@ -825,8 +846,10 @@
     teardownEdit(ed);
     host()?.editingChanged(false);
     chainDirty = true;
-    host()?.commitSplit({ eid: ed.eid, html, newHtml, newEid, cls, text: textOf(el).slice(0, 200) },
-      (real) => { if (real && real !== newEid) li.dataset.eid = real; });
+    // whole: the bullet's text as typed, offered to copy if the save is refused
+    host()?.commitSplit({ eid: ed.eid, html, newHtml, newEid, cls, text: textOf(el).slice(0, 200),
+      whole: [textOf(el), textOf(li)].filter((t) => t.trim()).join(" ") })
+      .then((real) => { if (real && real !== newEid) li.dataset.eid = real; });
     startEdit({ el: li, sec: ed.sec, eid: newEid, path: [], isNew: true }, null, null, { src: newHtml, caret: "start" });
   }
 
@@ -853,7 +876,19 @@
       slides: () => Reveal.getSlides(),
       current: () => Reveal.getCurrentSlide(),
       goto(index) { if (Reveal.getSlides()[index]) { const i = ix(index); Reveal.slide(i.h, i.v); } },
-      hash(index) { const i = ix(index); return `#/${i.h}${i.v ? "/" + i.v : ""}`; },
+      // counted without hidden slides, which the deck opened on its own leaves out (the editor shows them);
+      // a hidden slide opens at the next one shown
+      hash(index) {
+        const all = Reveal.getSlides(), shown = (s) => s.getAttribute("data-visibility") !== "hidden" &&
+          s.parentElement?.closest("section")?.getAttribute("data-visibility") !== "hidden";
+        const sec = [...all.slice(index), ...all.slice(0, index).reverse()].find(shown);
+        if (!sec) return "";
+        const stack = sec.parentElement.closest("section");
+        const sections = (el) => [...el.children].filter((c) => c.tagName === "SECTION" && shown(c));
+        const h = sections(Reveal.getSlidesElement()).indexOf(stack || sec);
+        const v = stack ? sections(stack).indexOf(sec) : 0;
+        return `#/${h}${v ? "/" + v : ""}`;
+      },
       size: () => ({ width: Reveal.getConfig().width, height: Reveal.getConfig().height }),
       scale: () => Reveal.getScale() || 1,
       on: (ev, fn) => Reveal.on(ev === "slide" ? "slidechanged" : ev, fn),
@@ -1060,7 +1095,16 @@
         return measureSection(slides()[index]);
       },
     };
-    window.__editorBridge = api;
+    // the editor's calls: from the parent window only, answered with the result
+    if (PARENT) window.addEventListener("message", async (e) => {
+      const m = e.data;
+      if (e.source !== PARENT || !m || typeof m !== "object") return;
+      if (m.pindeck === "host-answer") { answers.get(m.id)?.(m.value); answers.delete(m.id); return; }
+      if (m.pindeck !== "bridge" || !Object.hasOwn(api, m.method)) return;
+      let value = null;
+      try { value = await api[m.method](...(m.args || [])); } catch (err) { console.error(err); }
+      PARENT.postMessage({ pindeck: "bridge-answer", id: m.id, value: value ?? null }, "*");
+    });
 
     if (MODE === "main") {
       document.addEventListener("pointerdown", onPointerDown, true);
@@ -1129,13 +1173,18 @@
       if (startAt) goto(startAt);
       deck.keys();
     }
-    host()?.bridgeReady(MODE, api, window);
+    host()?.bridgeReady(MODE, info());
   }
   if (SLIDE_SEL) {
     deck = selectorDeck();
     deck.ready(() => (MODE === "pdf" ? deck.print() : start()));
     return;
   }
+  if (typeof Reveal === "undefined" && (MODE === "main" || MODE === "measure")) {
+    // nothing to edit: the editor says why, instead of a blank stage (and stops waiting for measurements)
+    host()?.deckFailed(MODE, "reveal.js did not load: the deck's script tag for it points to a file or address that cannot be reached.");
+    return;
+  }
   if (typeof Reveal === "undefined" || MODE === "pdf") return;   // reveal.js lays out its own print view
   deck = revealDeck();
   deck.ready(start);

package/public/editor.css

@@ -59,12 +59,30 @@ code { font: 12.5px ui-monospace, SFMono-Regular, Menlo, monospace; background:
   min-height: 44px; padding: 5px 12px; background: var(--panel); border-bottom: 1px solid var(--line); flex: none; }
 .toolbar .group { display: flex; align-items: center; gap: 6px; min-width: 0; flex: none; }
 .toolbar .group:first-child { flex: 1 1 auto; }
-.toolbar .group:first-child > :not(.deck-name) { flex: none; }
+.toolbar .group:first-child > :not(.deck-wrap) { flex: none; }
+/* narrow: the deck's name is shortened, never hidden (it opens the deck menu) */
 @container (max-width: 640px) {
-  .toolbar kbd, .toolbar .deck-name { display: none; }
+  .toolbar kbd { display: none; }
+  .toolbar .deck-wrap { max-width: 9em; }
 }
 .pos { font-variant-numeric: tabular-nums; color: var(--muted); min-width: 52px; text-align: center; }
-.deck-name { min-width: 0; margin-left: 8px; font-weight: 600; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
+/* the deck's name; behind the front (several decks on one port) it opens the deck menu */
+.deck-wrap { min-width: 0; max-width: 12em; margin-left: 2px; }
+.deck-btn { display: flex; align-items: center; gap: 4px; max-width: 100%; min-width: 0; padding: 2px 6px;
+  border: 0; background: none; color: inherit; font: inherit; }
+.deck-btn:hover { background: none; }
+.deck-btn:disabled { opacity: 1; cursor: default; }
+.deck-btn:not(:disabled):hover, .deck-btn[aria-expanded="true"] { background: var(--bg); }
+.deck-btn .caret { color: var(--muted); font-size: 11px; }
+.deck-name, #deck-name { min-width: 0; font-weight: 600; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
+.menu.deck-menu { width: min(360px, 90vw); max-height: min(520px, 70vh); overflow-y: auto; }
+.deck-menu a.opt { display: flex; align-items: baseline; gap: 8px; padding: 6px 10px; border-radius: 7px; color: inherit; text-decoration: none; }
+.deck-menu a.opt:hover, .deck-menu a.opt:focus-visible { background: var(--bg); }
+.deck-menu .opt b { font-weight: 500; overflow-wrap: anywhere; }
+.deck-menu .opt .d { margin-left: auto; color: var(--muted); font-size: 12px; flex: none; }
+.deck-menu button.opt { align-items: flex-start; }
+.deck-menu button.opt span.why { display: block; font-size: 12px; }
+.deck-menu .menu-note { padding: 8px 10px 4px; margin-top: 4px; border-top: 1px solid var(--line); font-size: 12px; color: var(--muted); }
 .server-note { flex: none; margin-left: 8px; padding: 1px 6px; border-radius: 4px; font-size: 12px; color: #6b4a12; background: #fbf0dc; cursor: help; }
 .toggle { display: inline-flex; align-items: center; gap: 6px; }
 .toggle .dot { display: inline-block; width: 18px; height: 18px; border-radius: 50%; background: var(--orange); color: #fff;
@@ -145,6 +163,10 @@ code { font: 12.5px ui-monospace, SFMono-Regular, Menlo, monospace; background:
 .stage iframe { position: absolute; inset: 0; width: 100%; height: 100%; border: 0; background: var(--stage); }
 .stage iframe.loading { visibility: hidden; }
 .stage iframe.measure { inset: auto; left: -20000px; top: 0; width: 1280px; height: 720px; visibility: hidden; }
+/* a deck page that does not start: why, over the empty stage */
+.stage-problem { position: absolute; inset: 0; z-index: 4; display: flex; flex-direction: column; justify-content: center; gap: 8px;
+  max-width: 34em; margin: auto; padding: 24px; color: var(--muted, #555); font-size: 14px; line-height: 1.45; text-align: center; }
+.stage-problem b { color: inherit; font-size: 15px; }
 
 /* ---- Speaker notes under the slide ---- */
 .notes-panel { position: relative; flex: none; display: flex; flex-direction: column; background: var(--panel); border-top: 1px solid var(--line); }
@@ -202,6 +224,10 @@ body.resizing-notes .stage iframe { pointer-events: none; }   /* keep the drag w
   border-radius: 12px; padding: 1px 4px 1px 2px; font-size: 12px; margin: 0 4px 4px 0; cursor: pointer; }
 .chip .n { width: 18px; height: 18px; border-radius: 50%; background: var(--orange); color: #fff; font-weight: 700;
   font-size: 11px; line-height: 18px; text-align: center; }
+.shot-chip { font: inherit; color: inherit; }
+.shot-chip img { height: 18px; aspect-ratio: 16 / 9; border-radius: 3px; object-fit: cover; background: var(--line); }
+.shot-chip.gone { color: var(--muted); cursor: default; padding: 1px 6px; }
+.msg.tool .shot-chip { margin: 0; vertical-align: middle; }
 .chip .x { border: 0; background: none; padding: 0 2px; color: var(--muted); font-size: 14px; line-height: 1; }
 .chip .x:hover { color: var(--danger); }
 .chip .lock { color: var(--muted); }
@@ -270,6 +296,7 @@ body.resizing-notes .stage iframe { pointer-events: none; }   /* keep the drag w
 .diff-dialog::backdrop { background: rgba(20,22,25,.35); }
 .dialog-head { display: flex; justify-content: space-between; align-items: center; padding: 10px 14px;
   border-bottom: 1px solid var(--line); font-weight: 600; }
+.shot-dialog img { display: block; max-width: 100%; max-height: calc(86vh - 50px); margin: 0 auto; }
 .diff { margin: 0; padding: 10px 0; overflow: auto; max-height: calc(86vh - 50px); font: 12px/1.5 ui-monospace, SFMono-Regular, Menlo, monospace; }
 .diff span { display: block; padding: 0 14px; white-space: pre-wrap; overflow-wrap: anywhere; }
 .diff .a { background: #e9f6ee; }