pindeck 2.8.0 → 2.8.1

package/README.md

@@ -249,6 +249,12 @@ Without PowerPoint or Keynote (or on other systems than macOS) only the text and
 
 ## Versions
 
+* **2.8.1**: fixes from a review. Speaker notes that fail to load leave the field empty and locked, instead
+  of showing the previous slide's notes and saving your edits over them. A save that fails because the
+  server cannot be reached is reported, and the edits after it (drags, text, bullets, notes) are still
+  saved instead of being dropped without a word. Stop no longer ends a turn started after it. Slides in
+  vertical stacks keep their order and ids, and a slide moved to the end goes after a final stack.
+  A first automated test suite (`npm test`).
 * **2.8**: a code review: safer, sturdier, and a PowerPoint import that keeps more. The server answers
   only to `127.0.0.1` and `localhost`, so another website cannot read the editor's token (DNS
   rebinding). A missing `claude` command ends the turn with a message instead of leaving the chat

package/lib/eids.mjs

@@ -145,7 +145,7 @@ function find(node, pred) {
   return hit;
 }
 
-/* Slides are the <section>s inside the element with class "slides" (Reveal.js). */
+/* Slides are leaf <section>s inside .slides; vertical-stack containers are not slides. */
 export function findSlides(tree) {
   const slidesEl = find(tree, (c) => classesOf(c).includes("slides"));
   if (!slidesEl) return [];
@@ -153,8 +153,8 @@ export function findSlides(tree) {
   const visit = (node) => {
     for (const c of node.children) {
       if (c.name !== "section") continue;
-      out.push(c);
-      visit(c); // vertical stacks
+      if (c.children.some((child) => child.name === "section")) visit(c);
+      else out.push(c);
     }
   };
   visit(slidesEl);
@@ -218,10 +218,11 @@ export function assignEids(html) {
 
   // Keep every existing, non-duplicate id first so new names never collide with them.
   const keep = new Set();
-  sections.forEach((s) => walk({ children: [s] }, (c) => {
+  // Reserve container ids too, including ids assigned to stacks by older versions.
+  walk(tree, (c) => {
     const v = c.attrs?.["data-eid"]?.value;
     if (v && !used.has(v)) { used.add(v); keep.add(c); c.eid = v; }
-  }));
+  });
 
   const slides = [];
   sections.forEach((section, i) => {
@@ -518,7 +519,9 @@ export function moveSlide(html, eid, beforeEid) {
     const at = slideBlock(cut, byEid(rest, beforeEid)).start;
     out = cut.slice(0, at) + text + `\n\n${indent}` + cut.slice(at);
   } else {
-    const last = rest.filter((s) => s.parent.name !== "section").at(-1);
+    // 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"))
+      .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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pindeck",
-  "version": "2.8.0",
+  "version": "2.8.1",
   "description": "PinDeck: a local editor for HTML slide decks. Pin elements, describe the change, and Claude Code edits the slides.",
   "keywords": [
     "slides",
@@ -32,7 +32,8 @@
     "LICENSE"
   ],
   "scripts": {
-    "start": "node server.mjs"
+    "start": "node server.mjs",
+    "test": "node --test"
   },
   "engines": {
     "node": ">=20"

package/public/editor.js

@@ -100,28 +100,28 @@ window.__editorHost = {
     return d.html;
   },
   commitText(edit) {
-    editChain = editChain.then(async () => {
+    queueEdit(async () => {
       const res = await api("text", edit);
       if (!res.ok) toast((await res.json().catch(() => ({}))).error || "Could not save the text.");
       loadMain();   // re-render: math, footer numbers, and the file as saved
-    });
+    }, "Could not save the text.");
   },
   commitSplit(op, done) {
-    editChain = editChain.then(async () => {
+    queueEdit(async () => {
       const res = await api("split", op);
       const d = await res.json().catch(() => ({}));
       if (!res.ok) { toast(d.error || "Could not add the bullet."); loadMain(); return; }
       done?.(d.eid);
-    });
+    }, "Could not add the bullet.");
   },
   commitRemove(eid) {
-    editChain = editChain.then(async () => {
+    queueEdit(async () => {
       const res = await api("remove", { eid });
       if (!res.ok) toast((await res.json().catch(() => ({}))).error || "Could not remove the bullet.");
       loadMain();
-    });
+    }, "Could not remove the bullet.");
   },
-  refresh() { editChain = editChain.then(() => loadMain()); },
+  refresh() { queueEdit(() => loadMain(), "Could not reload the slide."); },
   editingChanged(on) { state.editing = on; },
   requestDelete(eid) { requestDelete(eid); },
   dropFiles(files, at) { attachFiles(files, at); },
@@ -131,15 +131,20 @@ window.__editorHost = {
 
 /* ---- Hand edits (drag, resize, nudge) ---------------------------------------------------------- */
 let editChain = Promise.resolve(), nudgeAcc = null, nudgeTimer = null;
+// Saves run one after another. An edit that throws (offline, server gone) is reported and the queue
+// carries on, so one failure never silently skips the edits after it.
+function queueEdit(fn, failMsg = "Could not save the change.") {
+  editChain = editChain.catch(() => {}).then(fn).catch(() => { toast(failMsg); });
+  return editChain;
+}
 function postEdit(op, label) {
-  editChain = editChain.then(async () => {
+  return queueEdit(async () => {
     const res = await api("edit", { ops: [op], label });
     if (!res.ok) {
       toast((await res.json().catch(() => ({}))).error || "Could not save the change.");
       loadMain();   // show the file as it is
     }
   });
-  return editChain;
 }
 function flushNudge() {
   clearTimeout(nudgeTimer);
@@ -285,29 +290,47 @@ async function loadNotes() {
   if (!eid || document.activeElement === notesBox) return;
   const seq = ++notesSeq;
   await editChain.catch(() => {});   // a save still on its way would otherwise be read back as the old text
-  if (seq !== notesSeq) return;
+  if (seq !== notesSeq || notesDirty()) return;
   const res = await api(`notes?${new URLSearchParams({ eid })}`).catch(() => null);
   const d = res?.ok ? await res.json().catch(() => null) : null;
-  if (seq !== notesSeq || document.activeElement === notesBox) return;   // a newer load, or the user started typing
-  notes = { eid, text: d?.text || "", html: !!d?.html };
+  if (seq !== notesSeq || document.activeElement === notesBox || notesDirty()) return;
+  if (!d) {   // detach from the previous slide, so its notes are not shown, or saved over, as this one's
+    notes = { eid: null, text: "", html: false };
+    notesBox.value = "";
+    notesBox.disabled = true;
+    return notesStatus("Could not load");
+  }
+  notes = { eid, text: d.text || "", html: !!d.html };
   notesBox.value = notes.text;
+  notesBox.disabled = false;
   notesStatus();
 }
 function saveNotes() {
-  if (!notesDirty()) return;
+  if (!notesDirty()) return Promise.resolve(true);
   const edit = { eid: notes.eid, text: notesBox.value, html: notes.html };
   flushNudge();
-  editChain = editChain.then(async () => {
+  const run = async () => {
     notesStatus("Saving…");
-    const res = await api("notes", edit);
-    const d = await res.json().catch(() => ({}));
-    if (!res.ok) { notesStatus(); return toast(d.error || "Could not save the notes."); }   // the text stays, to save again
+    let res, d;
+    try {
+      res = await api("notes", edit);
+      d = await res.json().catch(() => ({}));
+    } catch {}   // a network failure must not break the shared edit queue
+    if (!res?.ok) {
+      notesStatus("Not saved");
+      toast(d?.error || "Could not save the notes.");
+      return false;
+    }
     if (notes.eid === edit.eid) notes.text = edit.text;
     notesStatus("Saved");
     setTimeout(() => { if ($("notes-status").textContent === "Saved") notesStatus(); }, 1500);
-  });
+    return true;
+  };
+  return queueEdit(run, "Could not save the notes.");
 }
-notesBox.addEventListener("blur", () => { saveNotes(); loadNotes(); });   // then show the slide we are on now
+notesBox.addEventListener("blur", async () => {
+  if (await saveNotes()) loadNotes();   // retain a failed draft and its original slide id for retry
+});
 notesBox.addEventListener("keydown", (e) => {
   if (e.key === "Enter" && (e.metaKey || e.ctrlKey)) { e.preventDefault(); notesBox.blur(); }
   else if (e.key === "Escape") { e.preventDefault(); notesBox.value = notes.text; notesBox.blur(); }

package/server.mjs

@@ -964,8 +964,11 @@ const server = http.createServer(async (req, res) => {
     }
     if (p === "/api/stop" && req.method === "POST") {
       if (state.busy && session.running) {
+        const interruptedTurn = state.turn;
         session.interrupt();
-        setTimeout(() => { if (state.busy) { session.stop(); } }, 5000); // force if it does not answer
+        setTimeout(() => {
+          if (state.busy && state.turn === interruptedTurn) session.stop();
+        }, 5000); // force only if the interrupted turn does not answer
       }
       return json(res, 200, {});
     }