pindeck 3.1.0-beta.1 → 3.2.0-beta.1

package/lib/agent-process.mjs

@@ -1,4 +1,5 @@
 /* JSON-line subprocess transport. Requests and notifications never outlive their process. */
+import fs from 'node:fs';
 import { spawn } from 'node:child_process';
 import readline from 'node:readline';
 export class AgentProcess {
@@ -21,7 +22,9 @@ export class AgentProcess {
     });
     this.proc.stderr.on('data', d => { this.stderr = (this.stderr + d).slice(-2000); onStderr(String(d)); });
     this.proc.stdin.on('error', e => this.end(e));
-    this.proc.on('error', e => this.end(e));
+    // spawn reports a missing working folder as the binary's ENOENT: name the folder instead
+    this.proc.on('error', e => this.end(e.code === 'ENOENT' && cwd && !fs.existsSync(cwd)
+      ? new Error(`The deck folder ${cwd} is not there any more (moved or deleted).`) : e));
     this.proc.on('exit', (code, signal) => this.end(new Error(`Agent stopped (${signal || code}). ${this.stderr.trim()}`)));
   }
   write(value) { if (this.closed) throw new Error('Agent is not running.'); this.proc.stdin.write(JSON.stringify(value) + '\n'); }

package/lib/agent-tools.mjs

@@ -25,8 +25,11 @@ export function createDeckTools({ deckDir, readDirs = [], cliFile, env, pdfTextF
   const roots = () => [deck, ...readDirs.flatMap(d => { try { return [fs.realpathSync(d)]; } catch { return []; } })];
   const inside = (root, file) => file === root || file.startsWith(root + path.sep);
   const envNow = () => (typeof env === 'function' ? env() : env);
-  const isLocked = rel => (typeof locked === 'function' ? locked() : locked)
-    .some(p => p.endsWith('/**') ? rel === p.slice(0, -3) || rel.startsWith(p.slice(0, -2)) : rel === p);
+  // compared regardless of case and Unicode form: on macOS's usual volumes .GIT/config and BRAND.CSS are the
+  // locked files themselves
+  const fold = p => p.normalize('NFC').toLowerCase();
+  const isLocked = rel => (typeof locked === 'function' ? locked() : locked).map(fold)
+    .some(p => p.endsWith('/**') ? fold(rel) === p.slice(0, -3) || fold(rel).startsWith(p.slice(0, -2)) : fold(rel) === p);
   function checked(file, write = false) {
     if (typeof file !== 'string' || !file || file.includes('\0')) throw new Error('Invalid file path.');
     const full = path.resolve(deck, file);

package/lib/asset-roots.mjs

@@ -0,0 +1,22 @@
+/* Asset roots: folders outside the deck whose files the deck may use, from --asset-root (repeatable) and
+   "assetRoots" in config.json. Shared by the front, which lists their decks, and each deck server, which
+   serves their files, so both read them alike. */
+
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+export const expandHome = (p) => (p === "~" || p.startsWith("~/") ? path.join(os.homedir(), p.slice(1)) : p);
+
+/* { roots, missing }: absolute paths, each once, in the order given; missing: those that are not folders */
+export function assetRoots(args = [], config = {}) {
+  const roots = [], missing = [];
+  for (const r of [...args, ...(Array.isArray(config?.assetRoots) ? config.assetRoots : [])]) {
+    const abs = path.resolve(expandHome(String(r)));
+    if (roots.includes(abs) || missing.includes(abs)) continue;
+    let dir = false;
+    try { dir = fs.statSync(abs).isDirectory(); } catch {}
+    (dir ? roots : missing).push(abs);
+  }
+  return { roots, missing };
+}

package/lib/claude.mjs

@@ -12,11 +12,19 @@ export class ClaudeSession {
     if (this.running) return;
     this.stopped = false;
     const env = typeof this.env === 'function' ? this.env() : this.env;
+    /* The sign-in check: "not signed in" only when the CLI says so. A CLI without `auth status --json` (older
+       than PinDeck's tested versions) or with other output starts anyway; the session then reports any problem. */
+    let signedIn = null;
     try {
       const { stdout } = await exec(process.env.CLAUDE_BIN || 'claude', ['auth', 'status', '--json'],
         { env: { ...process.env, ...env }, timeout: 15000, maxBuffer: 65536 });
-      if (!JSON.parse(stdout).loggedIn) throw new Error('Not signed in.');
-    } catch (e) { throw new Error(e.code === 'ENOENT' ? 'Claude CLI is not installed (or set CLAUDE_BIN).' : 'Claude is not signed in. Run claude auth login, then refresh models.'); }
+      signedIn = JSON.parse(stdout).loggedIn;
+    } catch (e) {
+      if (e.code === 'ENOENT') throw new Error('Claude CLI is not installed (or set CLAUDE_BIN).');
+      if (e.killed) throw new Error('Claude did not answer its sign-in check within 15 s. Try again (Refresh models).');
+      try { signedIn = JSON.parse(e.stdout).loggedIn; } catch {}   // signed out: the CLI answers, and exits 1
+    }
+    if (signedIn === false) throw new Error('Claude is not signed in. Run claude auth login, then refresh models.');
     if (this.stopped) throw new Error('Agent stopped.');
     const transport = new AgentProcess({ binary: process.env.CLAUDE_BIN || 'claude', cwd: this.cwd, env,
       args: ['-p', '--input-format', 'stream-json', '--output-format', 'stream-json', '--verbose',

package/lib/deck-files.mjs

@@ -57,17 +57,19 @@ export function revision(dir, files) {
 
 /* The deck's files for undo: every file a turn may change, with its content (bigger files: only size and
    time, too large to keep a copy of). Hidden files and folders (.git), node_modules, and the vendor/ and
-   export/ folders are left out; so are symlinks, which point elsewhere. */
+   export/ folders are left out; so are symlinks, which point elsewhere, and the paths in skip (other decks
+   in the folder: their files and folders, as paths relative to dir). */
 const SKIP_TOP = new Set(["vendor", "export", "node_modules"]);
 export const KEEP_BYTES = 2 * 1024 * 1024;
-export function scanFiles(dir, maxBytes = KEEP_BYTES) {
-  const files = new Map();
+export function scanFiles(dir, { maxBytes = KEEP_BYTES, skip = [] } = {}) {
+  const files = new Map(), skipped = new Set(skip);
   const walk = (rel) => {
     let entries = [];
     try { entries = fs.readdirSync(path.join(dir, rel), { withFileTypes: true }); } catch { return; }
     for (const e of entries) {
       if (e.name.startsWith(".") || e.name === "node_modules") continue;
       const r = rel ? `${rel}/${e.name}` : e.name;
+      if (skipped.has(r)) continue;
       if (e.isDirectory()) { if (rel || !SKIP_TOP.has(e.name)) walk(r); continue; }
       if (!e.isFile()) continue;
       try {

package/lib/deck-list.mjs

@@ -11,18 +11,36 @@ const SKIP = new Set(["node_modules", "export"]);   // dependencies, and PinDeck
 const MAX_FILES = 300;
 const MAX_BYTES = 5 * 1024 * 1024;
 
+// symlinks count as what they point to
+const kind = (dir, e) => { if (!e.isSymbolicLink()) return e; try { return fs.statSync(path.join(dir, e.name)); } catch { return e; } };
 const htmlFiles = (dir) => {
   try {
     return fs.readdirSync(dir, { withFileTypes: true })
-      .filter((e) => e.isFile() && /\.html?$/i.test(e.name) && !e.name.startsWith(".")).map((e) => e.name).sort();
+      .filter((e) => /\.html$/i.test(e.name) && !e.name.startsWith(".") && kind(dir, e).isFile()).map((e) => e.name).sort();
   } catch { return []; }
 };
 const subfolders = (dir) => {
   try {
     return fs.readdirSync(dir, { withFileTypes: true })
-      .filter((e) => e.isDirectory() && !e.name.startsWith(".") && !SKIP.has(e.name)).map((e) => e.name).sort();
+      .filter((e) => !e.name.startsWith(".") && !SKIP.has(e.name) && kind(dir, e).isDirectory()).map((e) => e.name).sort();
   } catch { return []; }
 };
+/* A deck file that is a symlink to a file in another folder cannot be opened: its relative paths (theme.css,
+   figures/) would be looked up beside the link, where the files are not. Why, or null. */
+export function linkProblem(dir, file) {
+  const abs = path.join(dir, file);
+  try {
+    if (!fs.lstatSync(abs).isSymbolicLink()) return null;
+    const real = fs.realpathSync(abs);
+    if (path.dirname(real) === fs.realpathSync(dir)) return null;
+    return `${file} is a link to a deck in another folder: open that deck itself (${real}).`;
+  } catch { return null; }
+}
+
+/* What each file's check found, by path, while its size and modification time stay the same: listing is
+   asked for on every deck menu and every first request for a deck, and reading every deck each time held up
+   the front, which passes on all decks' requests. */
+const checked = new Map();
 
 /* [{ key, dir, file, rel, root, problem }]: rel is the path shown in the menu, relative to its root;
    problem is null for a deck PinDeck can open. A file under several roots is listed once, under the first. */
@@ -36,9 +54,14 @@ export function listDecks(roots) {
         seen.add(abs);
         let problem = null;
         try {
-          const size = fs.statSync(abs).size;
-          problem = size > MAX_BYTES ? `${file} is larger than 5 MB, too large for a deck.`
-            : unsupportedMessage(fs.readFileSync(abs, "utf8"), file)?.replace(/ Nothing was changed\.$/, "") || null;
+          const st = fs.statSync(abs), known = checked.get(abs);
+          if (known && known.mtimeMs === st.mtimeMs && known.size === st.size) problem = known.problem;
+          else {
+            problem = st.size > MAX_BYTES ? `${file} is larger than 5 MB, too large for a deck.`
+              : unsupportedMessage(fs.readFileSync(abs, "utf8"), file)?.replace(/ Nothing was changed\.$/, "") || null;
+            checked.set(abs, { mtimeMs: st.mtimeMs, size: st.size, problem });
+          }
+          problem = linkProblem(dir, file) || problem;
         } catch (e) { problem = `${file} cannot be read (${e.code || e.message}).`; }
         const t = deckTarget(file === "index.html" ? dir : abs);
         out.push({ key: t.key, dir, file, rel: path.relative(root, abs).split(path.sep).join("/"), root, problem });

package/lib/deck-target.mjs

@@ -8,15 +8,33 @@ import crypto from "node:crypto";
 
 export const homeDir = (env = process.env) => env.PINDECK_HOME || path.join(os.homedir(), ".pindeck-v3");
 
-/* A file (talk.html), or a folder, which means its index.html. A path ending in .html or .htm that is
+/* PinDeck 2 keeps its chats and settings in files of the same names, in other formats: the two versions in one
+   folder (one PINDECK_HOME for both) overwrite each other's. PinDeck 3 saves a provider with every chat and
+   PinDeck 2 never does, so a chat without one was written by version 2: copied over (which works), or written
+   by a PinDeck 2 that uses this folder too (which does not). Returns the warning, or null. */
+export function homeWarning(home) {
+  let decks = [];
+  try { decks = fs.readdirSync(path.join(home, "decks")).slice(0, 500); } catch { return null; }
+  for (const d of decks) {
+    let chat;
+    try { chat = JSON.parse(fs.readFileSync(path.join(home, "decks", d, "chat.json"), "utf8")); } catch { continue; }
+    if (chat && typeof chat === "object" && !("provider" in chat))
+      return `${home} holds a chat written by PinDeck 2 (decks/${d}/chat.json). If PinDeck 2 uses this folder too, ` +
+        `give PinDeck 3 another one (PINDECK_HOME; by default ~/.pindeck-v3): the two versions overwrite each ` +
+        `other's settings and chats. Chats copied over from PinDeck 2 are fine.`;
+  }
+  return null;
+}
+
+/* A file (talk.html), or a folder, which means its index.html. A path ending in .html that is
    not a folder is a file, so a missing file gets a clear message. */
 export function deckTarget(target) {
   const abs = path.resolve(target);
   const isFolder = (() => { try { return fs.statSync(abs).isDirectory(); } catch { return false; } })();
-  const dir = isFolder || !/\.html?$/i.test(abs) ? abs : path.dirname(abs);
+  const dir = isFolder || !/\.html$/i.test(abs) ? abs : path.dirname(abs);
   const file = dir === abs ? "index.html" : path.basename(abs);
   const named = file !== "index.html";   // a deck file with its own name; several can share a folder
-  const name = named ? file.replace(/\.html?$/i, "") : path.basename(dir);   // for exports and titles
+  const name = named ? file.replace(/\.html$/i, "") : path.basename(dir);   // for exports and titles
   /* State per deck file. A folder's index.html keeps the key it always had, so existing chats and undo
      histories stay; a named file gets its own, so two decks in one folder never share chat or undo. */
   const key = (named ? `${path.basename(dir)}-${name}` : path.basename(dir)).replace(/[^\w.-]+/g, "_") + "-" +

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

@@ -6,6 +6,7 @@
    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. */
@@ -50,8 +51,10 @@ export function createLogin({ token, port, origin }) {
       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("/") || next.startsWith("//") || next.includes("\\")) 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");
@@ -59,3 +62,14 @@ export function createLogin({ token, port, origin }) {
   }
   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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pindeck",
-  "version": "3.1.0-beta.1",
+  "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",

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

@@ -60,12 +60,14 @@ code { font: 12.5px ui-monospace, SFMono-Regular, Menlo, monospace; background:
 .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-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-wrap { 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; }
 /* the deck's name; behind the front (several decks on one port) it opens the deck menu */
-.deck-wrap { min-width: 0; margin-left: 2px; }
+.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; }
@@ -161,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); }