agent-whiteboard 1.0.4 → 1.2.0

package/dist/server/routes/snapshots.js

@@ -0,0 +1,119 @@
+import { getLastWorkspace, setLastWorkspace } from "../session.js";
+import { isValidSnapshotFilename, nodeToFrameSchema } from "../validate.js";
+import { isFrameArray, listAllSnapshots, listSnapshots, loadSnapshotContent } from "../snapshot-reader.js";
+import { deleteSnapshotFiles, deleteWorkspace, validateWorkspaceForDelete } from "../snapshot-writer.js";
+import { applyLoadedSnapshotResult, validateWorkspaceInput } from "../render-core.js";
+import { getSnapshotsRoot } from "../paths.js";
+export function registerSnapshotRoutes(app) {
+    // ── History navigator (v0.4 — Sprint 17) ──────────────────────────────────────
+    app.get("/snapshots", async (c) => {
+        // Workspace is mandatory, no lastWorkspace fallback — matches MCP's
+        // list_snapshots exactly (F3/NF20; same validateWorkspaceInput() both
+        // transports already use for render()/slideshow()).
+        const workspaceResult = validateWorkspaceInput(c.req.query("workspace"));
+        if (!workspaceResult.ok) {
+            return c.json({ ok: false, error: workspaceResult.error }, 400);
+        }
+        const { workspace } = workspaceResult;
+        const root = getSnapshotsRoot();
+        const snapshots = await listSnapshots(workspace, root);
+        return c.json({ ok: true, snapshots });
+    });
+    // ── Sprint 18 — GET /snapshots/all (v0.5) ────────────────────────────────────
+    app.get("/snapshots/all", async (c) => {
+        const workspace = getLastWorkspace();
+        const root = getSnapshotsRoot();
+        const workspaces = await listAllSnapshots(root, workspace);
+        return c.json({ ok: true, workspaces });
+    });
+    app.post("/snapshots/load", async (c) => {
+        const body = await c.req.json();
+        const filename = body.filename;
+        if (typeof filename !== "string") {
+            return c.json({ ok: false, error: "filename must be a string" }, 400);
+        }
+        // Path safety: filename must end with _screen.json and contain no / or ..
+        if (!isValidSnapshotFilename(filename)) {
+            return c.json({ ok: false, error: "invalid filename: path traversal not allowed" });
+        }
+        const currentWorkspace = getLastWorkspace();
+        const root = getSnapshotsRoot();
+        // Optional workspace override (v0.5 cross-workspace load).
+        let workspace;
+        if (body.workspace !== undefined) {
+            const validated = validateWorkspaceInput(body.workspace);
+            if (!validated.ok) {
+                return c.json({ ok: false, error: "invalid workspace: path traversal not allowed" }, 400);
+            }
+            workspace = validated.workspace;
+        }
+        else {
+            workspace = currentWorkspace;
+        }
+        const raw = await loadSnapshotContent(workspace, root, filename);
+        if (raw === null) {
+            return c.json({ ok: false, error: `snapshot not found: ${filename}` });
+        }
+        let snapshot;
+        try {
+            snapshot = JSON.parse(raw);
+        }
+        catch {
+            return c.json({ ok: false, error: "snapshot file is malformed JSON" });
+        }
+        if (!isFrameArray(snapshot.frames)) {
+            return c.json({ ok: false, error: "snapshot file is missing required fields" });
+        }
+        const frames = snapshot.frames;
+        const title = typeof snapshot.title === "string" ? snapshot.title : undefined;
+        const parsedNodeToFrame = nodeToFrameSchema.safeParse(snapshot.nodeToFrame);
+        const nodeToFrame = parsedNodeToFrame.success ? parsedNodeToFrame.data : undefined;
+        // Pre-v0.11 snapshots may lack an id (J1, `02`) — not addressable by the
+        // viewport cache; the browser falls back to treating it as unseen (auto-fit).
+        const snapshotId = typeof snapshot.id === "string" ? snapshot.id : undefined;
+        const rawPayload = typeof snapshot.rawPayload === "string" ? snapshot.rawPayload : undefined;
+        const result = await applyLoadedSnapshotResult(frames, workspace, title, nodeToFrame, snapshotId, rawPayload);
+        if (!result.ok) {
+            return c.json({ ok: false, error: result.error });
+        }
+        return c.json({ ok: true });
+    });
+    // ── Snapshot delete endpoints (v0.12) ─────────────────────────────────────
+    app.post("/snapshots/delete-files", async (c) => {
+        const body = await c.req.json();
+        const root = getSnapshotsRoot();
+        const validated = await validateWorkspaceForDelete(body.workspace, root);
+        if (!validated.ok) {
+            return c.json({ ok: false, error: validated.error }, validated.status);
+        }
+        const { workspace } = validated;
+        if (!Array.isArray(body.filenames) || body.filenames.length === 0) {
+            return c.json({ ok: false, error: "filenames must be a non-empty array" }, 400);
+        }
+        const filenames = body.filenames;
+        for (const f of filenames) {
+            if (typeof f !== "string") {
+                return c.json({ ok: false, error: "each filename must be a string" }, 400);
+            }
+        }
+        const result = await deleteSnapshotFiles(workspace, root, filenames);
+        if (!result.ok) {
+            return c.json({ ok: false, error: result.error }, 400);
+        }
+        return c.json({ ok: true, deleted: result.deleted });
+    });
+    app.post("/snapshots/delete-workspace", async (c) => {
+        const body = await c.req.json();
+        const root = getSnapshotsRoot();
+        const validated = await validateWorkspaceForDelete(body.workspace, root);
+        if (!validated.ok) {
+            return c.json({ ok: false, error: validated.error }, validated.status);
+        }
+        const { workspace } = validated;
+        await deleteWorkspace(workspace, root);
+        if (getLastWorkspace() === workspace) {
+            setLastWorkspace("");
+        }
+        return c.json({ ok: true });
+    });
+}

package/dist/server/snapshot-reader.js

@@ -1,5 +1,6 @@
-import { readdirSync, readFileSync } from "fs";
+import { readdir, readFile } from "fs/promises";
 import { join } from "path";
+import { nodeToFrameSchema } from "./validate.js";
 /** Shared "is this a valid Frame[]" predicate (F6/NF23) — the one implementation checking non-empty array + per-element shape. */
 export function isFrameArray(value) {
     return (Array.isArray(value) &&
@@ -21,11 +22,17 @@ export function isFrameArray(value) {
 export function badgeType(frames) {
     return frames.length > 1 ? "step-frames" : frames[0].type;
 }
-export function listSnapshots(workspace, dir) {
+/**
+ * NF49: async fs/promises I/O throughout this file — `listSnapshots()` and
+ * `listAllSnapshots()` (below) read every snapshot file in a workspace (or
+ * every workspace), so a synchronous implementation blocks the event loop
+ * for the whole scan; the async equivalents yield between file reads.
+ */
+export async function listSnapshots(workspace, dir) {
     const workspaceDir = join(dir, workspace);
     let files;
     try {
-        files = readdirSync(workspaceDir).filter((f) => f.endsWith("_screen.json"));
+        files = (await readdir(workspaceDir)).filter((f) => f.endsWith("_screen.json"));
     }
     catch {
         return [];
@@ -33,7 +40,7 @@ export function listSnapshots(workspace, dir) {
     const entries = [];
     for (const filename of files) {
         try {
-            const raw = readFileSync(join(workspaceDir, filename), "utf-8");
+            const raw = await readFile(join(workspaceDir, filename), "utf-8");
             const parsed = JSON.parse(raw);
             if (typeof parsed.timestamp !== "string" || !isFrameArray(parsed.frames)) {
                 console.error(`[agent-whiteboard] snapshot-reader: skipping malformed file: ${filename}`);
@@ -64,10 +71,10 @@ export function listSnapshots(workspace, dir) {
  * Scan every workspace subdirectory under `dir` and return their snapshots grouped.
  * Workspaces with no readable snapshots are omitted from the result.
  */
-export function listAllSnapshots(dir, currentWorkspace) {
+export async function listAllSnapshots(dir, currentWorkspace) {
     let entries;
     try {
-        entries = readdirSync(dir, { withFileTypes: true })
+        entries = (await readdir(dir, { withFileTypes: true }))
             .filter((d) => d.isDirectory())
             .map((d) => d.name);
     }
@@ -76,7 +83,7 @@ export function listAllSnapshots(dir, currentWorkspace) {
     }
     const groups = [];
     for (const name of entries) {
-        const snapshots = listSnapshots(name, dir);
+        const snapshots = await listSnapshots(name, dir);
         if (snapshots.length === 0)
             continue;
         groups.push({ name, isCurrent: name === currentWorkspace, snapshots });
@@ -88,18 +95,18 @@ export function listAllSnapshots(dir, currentWorkspace) {
  * Read the raw content of a single snapshot file.
  * Returns null if the file does not exist or cannot be read.
  */
-export function loadSnapshotContent(workspace, dir, filename) {
+export async function loadSnapshotContent(workspace, dir, filename) {
     try {
-        return readFileSync(join(dir, workspace, filename), "utf-8");
+        return await readFile(join(dir, workspace, filename), "utf-8");
     }
     catch {
         return null;
     }
 }
 /** Best-effort read of a snapshot file's `id` field, for viewport-cache cleanup on delete. */
-export function readSnapshotIdSafe(fullPath) {
+export async function readSnapshotIdSafe(fullPath) {
     try {
-        const raw = readFileSync(fullPath, "utf-8");
+        const raw = await readFile(fullPath, "utf-8");
         const parsed = JSON.parse(raw);
         return typeof parsed.id === "string" ? parsed.id : undefined;
     }
@@ -114,10 +121,10 @@ export function readSnapshotIdSafe(fullPath) {
  * mirrors `session.ts`'s `exportCanvas()`: `rawPayload ?? frames[0].payload`.
  * Old snapshots without an `id` field are silently skipped.
  */
-export function findSnapshotById(id, dir) {
+export async function findSnapshotById(id, dir) {
     let workspaceDirs;
     try {
-        workspaceDirs = readdirSync(dir, { withFileTypes: true })
+        workspaceDirs = (await readdir(dir, { withFileTypes: true }))
             .filter((d) => d.isDirectory())
             .map((d) => d.name);
     }
@@ -128,14 +135,14 @@ export function findSnapshotById(id, dir) {
         const workspaceDir = join(dir, workspace);
         let files;
         try {
-            files = readdirSync(workspaceDir).filter((f) => f.endsWith("_screen.json"));
+            files = (await readdir(workspaceDir)).filter((f) => f.endsWith("_screen.json"));
         }
         catch {
             continue;
         }
         for (const filename of files) {
             try {
-                const raw = readFileSync(join(workspaceDir, filename), "utf-8");
+                const raw = await readFile(join(workspaceDir, filename), "utf-8");
                 const parsed = JSON.parse(raw);
                 if (parsed.id === id && isFrameArray(parsed.frames)) {
                     return typeof parsed.rawPayload === "string" ? parsed.rawPayload : parsed.frames[0].payload;
@@ -148,6 +155,36 @@ export function findSnapshotById(id, dir) {
     }
     return null;
 }
+/**
+ * Scan a single workspace directory for a snapshot whose `id` field matches,
+ * returning its filename and verbatim file contents (not the parsed
+ * record) — the zip export pipeline (F36) adds files byte-for-byte rather
+ * than re-rendering them. Old snapshots without an `id` field are never
+ * matched. Returns null if no match or the workspace directory is absent.
+ */
+export async function findSnapshotFileByIdInWorkspace(workspace, id, dir) {
+    const workspaceDir = join(dir, workspace);
+    let files;
+    try {
+        files = (await readdir(workspaceDir)).filter((f) => f.endsWith("_screen.json"));
+    }
+    catch {
+        return null;
+    }
+    for (const filename of files) {
+        try {
+            const raw = await readFile(join(workspaceDir, filename), "utf-8");
+            const parsed = JSON.parse(raw);
+            if (parsed.id === id) {
+                return { filename, raw };
+            }
+        }
+        catch (err) {
+            console.error(`[agent-whiteboard] snapshot-reader: skipping unreadable file ${filename}:`, err instanceof Error ? err.message : String(err));
+        }
+    }
+    return null;
+}
 /**
  * Scan a single workspace directory for a snapshot whose `id` field matches.
  * Returns the full parsed record (frames, timestamp, title?, nodeToFrame?)
@@ -155,18 +192,18 @@ export function findSnapshotById(id, dir) {
  * directory is absent). Old snapshots without an `id` field are silently
  * skipped.
  */
-export function findSnapshotByIdInWorkspace(workspace, id, dir) {
+export async function findSnapshotByIdInWorkspace(workspace, id, dir) {
     const workspaceDir = join(dir, workspace);
     let files;
     try {
-        files = readdirSync(workspaceDir).filter((f) => f.endsWith("_screen.json"));
+        files = (await readdir(workspaceDir)).filter((f) => f.endsWith("_screen.json"));
     }
     catch {
         return null;
     }
     for (const filename of files) {
         try {
-            const raw = readFileSync(join(workspaceDir, filename), "utf-8");
+            const raw = await readFile(join(workspaceDir, filename), "utf-8");
             const parsed = JSON.parse(raw);
             if (parsed.id === id && typeof parsed.timestamp === "string" && isFrameArray(parsed.frames)) {
                 const record = {
@@ -176,8 +213,9 @@ export function findSnapshotByIdInWorkspace(workspace, id, dir) {
                 if (typeof parsed.title === "string") {
                     record.title = parsed.title;
                 }
-                if (parsed.nodeToFrame !== null && typeof parsed.nodeToFrame === "object") {
-                    record.nodeToFrame = parsed.nodeToFrame;
+                const parsedNodeToFrame = nodeToFrameSchema.safeParse(parsed.nodeToFrame);
+                if (parsedNodeToFrame.success) {
+                    record.nodeToFrame = parsedNodeToFrame.data;
                 }
                 return record;
             }

package/dist/server/snapshot-writer.js

@@ -1,4 +1,6 @@
-import { existsSync, mkdirSync, readdirSync, rmSync, unlinkSync, writeFileSync } from "fs";
+import { randomUUID } from "node:crypto";
+import { mkdirSync, writeFileSync } from "fs";
+import { readdir, rm, stat, unlink } from "fs/promises";
 import { join, resolve, sep } from "path";
 import { getSnapshotsRoot } from "./paths.js";
 import { readSnapshotIdSafe } from "./snapshot-reader.js";
@@ -8,7 +10,7 @@ import { deleteViewports } from "./viewport-cache.js";
  * broadcast the id to the browser (e.g. for viewport-cache keying) without
  * waiting on the (synchronous, but logically separate) disk write. */
 export function generateSnapshotId() {
-    return crypto.randomUUID();
+    return randomUUID();
 }
 export function saveSnapshot(frames, options, rawPayload, id) {
     try {
@@ -17,7 +19,7 @@ export function saveSnapshot(frames, options, rawPayload, id) {
         const dir = join(root, workspace);
         mkdirSync(dir, { recursive: true });
         const now = new Date();
-        const usedId = id ?? crypto.randomUUID();
+        const usedId = id ?? randomUUID();
         // Include the (already-unique) id so two writes in the same second never collide.
         const filename = `${formatTimestamp(now)}_${usedId}_screen.json`;
         const content = {
@@ -51,7 +53,7 @@ function formatTimestamp(d) {
  * e.g. workspace ".", B6) and existence (404 if the workspace was never
  * created or was already deleted).
  */
-export function validateWorkspaceForDelete(workspace, root) {
+export async function validateWorkspaceForDelete(workspace, root) {
     const validated = validateWorkspaceInput(workspace);
     if (!validated.ok) {
         return { ok: false, error: validated.error, status: 400 };
@@ -60,7 +62,8 @@ export function validateWorkspaceForDelete(workspace, root) {
     if (!resolve(dir).startsWith(resolve(root) + sep)) {
         return { ok: false, error: "invalid workspace: path traversal not allowed", status: 400 };
     }
-    if (!existsSync(dir)) {
+    const dirExists = await stat(dir).then(() => true, () => false);
+    if (!dirExists) {
         return { ok: false, error: "workspace not found", status: 404 };
     }
     return { ok: true, workspace: validated.workspace };
@@ -70,7 +73,7 @@ export function validateWorkspaceForDelete(workspace, root) {
  * viewport-cache entries (C3, `02`). Missing files are silently skipped.
  * Shared by POST /snapshots/delete-files (NF26, v0.28 Sprint 59).
  */
-export function deleteSnapshotFiles(workspace, root, filenames) {
+export async function deleteSnapshotFiles(workspace, root, filenames) {
     for (const f of filenames) {
         if (!isValidSnapshotFilename(f)) {
             return { ok: false, error: `invalid filename: ${f}` };
@@ -81,9 +84,9 @@ export function deleteSnapshotFiles(workspace, root, filenames) {
     const deletedIds = [];
     for (const f of filenames) {
         const fullPath = join(workspaceDir, f);
-        const id = readSnapshotIdSafe(fullPath);
+        const id = await readSnapshotIdSafe(fullPath);
         try {
-            unlinkSync(fullPath);
+            await unlink(fullPath);
             deleted++;
             if (id !== undefined)
                 deletedIds.push(id);
@@ -92,7 +95,7 @@ export function deleteSnapshotFiles(workspace, root, filenames) {
             // Missing files are silently skipped.
         }
     }
-    deleteViewports(deletedIds);
+    await deleteViewports(deletedIds);
     return { ok: true, deleted };
 }
 /**
@@ -100,18 +103,17 @@ export function deleteSnapshotFiles(workspace, root, filenames) {
  * for every snapshot that lived in it (C3, `02`). Shared by
  * POST /snapshots/delete-workspace (NF26, v0.28 Sprint 59).
  */
-export function deleteWorkspace(workspace, root) {
+export async function deleteWorkspace(workspace, root) {
     const workspaceDir = join(root, workspace);
     let idsToClean = [];
     try {
-        idsToClean = readdirSync(workspaceDir)
-            .filter((f) => f.endsWith("_screen.json"))
-            .map((f) => readSnapshotIdSafe(join(workspaceDir, f)))
-            .filter((id) => id !== undefined);
+        const filenames = (await readdir(workspaceDir)).filter((f) => f.endsWith("_screen.json"));
+        const ids = await Promise.all(filenames.map((f) => readSnapshotIdSafe(join(workspaceDir, f))));
+        idsToClean = ids.filter((id) => id !== undefined);
     }
     catch {
         // Workspace directory unreadable/absent — nothing to clean up.
     }
-    rmSync(workspaceDir, { recursive: true, force: true });
-    deleteViewports(idsToClean);
+    await rm(workspaceDir, { recursive: true, force: true });
+    await deleteViewports(idsToClean);
 }

package/dist/server/validate.js

@@ -1,6 +1,7 @@
 // Server-side payload validation helpers.
 import mermaid from "mermaid";
 import { z } from "zod";
+import { validateQuizPayload } from "./quiz.js";
 /**
  * Shared shape schemas for `node_actions` (wait_click) and `node_to_frame`
  * (commit_step_frames) — the single implementation both MCP's zod
@@ -138,3 +139,16 @@ export async function validateFrame(frame) {
     }
     return null;
 }
+/**
+ * Types accepted by render() — the frame types plus "quiz" (F44). Quiz is
+ * deliberately NOT a FRAME_TYPE: it is a single interactive page, not
+ * something that makes sense inside a slideshow or step-frames sequence
+ * (wait_quiz hands back one submission), so validateFrame() keeps rejecting it.
+ */
+export const RENDER_TYPES = [...FRAME_TYPES, "quiz"];
+/** The one validator for render() payloads, shared by POST /render and the MCP `render` tool. */
+export async function validateRenderPayload(type, payload) {
+    if (type === "quiz")
+        return validateQuizPayload(payload);
+    return validateFrame({ type, payload });
+}

package/dist/server/viewport-cache.js

@@ -4,19 +4,37 @@
 // step-frames sequence persists its own manual viewport independently, consistent
 // with each frame now getting its own auto-fit trigger (was a bare `id` key,
 // shared across a whole sequence, pre-v0.26.1).
-import { mkdirSync, readFileSync, writeFileSync } from "fs";
+//
+// NF49 (v1.4): reads/writes go through fs/promises instead of blocking the event
+// loop, and the on-disk file is treated as a write-back cache — kept in memory
+// after the first load and flushed to disk on a coalesced delay (see
+// `scheduleFlush()`) instead of a full synchronous read-modify-write per
+// zoom/pan event.
+import { mkdir, readFile, writeFile } from "fs/promises";
 import { join } from "path";
 import { getSnapshotsRoot } from "./paths.js";
 function cachePath() {
     return join(getSnapshotsRoot(), "viewport-cache.json");
 }
-function readCache() {
+function cacheKey(id, frameIndex) {
+    return `${id}:${frameIndex}`;
+}
+// In-memory cache, lazily loaded on first access. `cachedForPath` guards
+// against a stale in-memory cache surviving a change to the underlying
+// snapshots root (WHITEBOARD_SNAPSHOTS_DIR) — reloads transparently if the
+// resolved cache path differs from the one currently held in memory.
+let cache;
+let cachedForPath;
+async function loadCache() {
+    const path = cachePath();
+    if (cache !== undefined && cachedForPath === path)
+        return cache;
     try {
-        const raw = readFileSync(cachePath(), "utf-8");
+        const raw = await readFile(path, "utf-8");
         const parsed = JSON.parse(raw);
-        if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
-            return {};
-        return parsed;
+        cache = typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)
+            ? parsed
+            : {};
     }
     catch (err) {
         // ENOENT (no cache file yet, e.g. first run) is expected and not logged.
@@ -25,45 +43,99 @@ function readCache() {
         if (err?.code !== "ENOENT") {
             console.error("[agent-whiteboard] viewport-cache read failed, resetting cache:", err instanceof Error ? err.message : String(err));
         }
-        return {};
+        cache = {};
     }
+    cachedForPath = path;
+    return cache;
 }
-function writeCache(cache) {
+async function flushCache() {
+    if (cache === undefined)
+        return;
     try {
-        mkdirSync(getSnapshotsRoot(), { recursive: true });
-        writeFileSync(cachePath(), JSON.stringify(cache, null, 2), "utf-8");
+        await mkdir(getSnapshotsRoot(), { recursive: true });
+        await writeFile(cachePath(), JSON.stringify(cache, null, 2), "utf-8");
     }
     catch (err) {
         console.error("[agent-whiteboard] viewport-cache write failed:", err instanceof Error ? err.message : String(err));
     }
 }
-function cacheKey(id, frameIndex) {
-    return `${id}:${frameIndex}`;
+/**
+ * Delay before a scheduled flush fires. Exported so tests can advance fake
+ * timers by exactly this amount instead of hardcoding a duplicate constant.
+ */
+export const VIEWPORT_CACHE_FLUSH_DELAY_MS = 250;
+let flushTimer;
+/**
+ * Coalesces bursts of writes (continuous zoom/pan produces many `setViewport`
+ * calls in quick succession) into a single disk write roughly
+ * `VIEWPORT_CACHE_FLUSH_DELAY_MS` after the first update in a burst, instead
+ * of a full synchronous rewrite per update. A timer already pending absorbs
+ * every subsequent call in the same burst — it is not reset per call, so a
+ * sustained stream of updates still flushes periodically rather than being
+ * postponed indefinitely.
+ */
+function scheduleFlush() {
+    if (flushTimer !== undefined)
+        return;
+    flushTimer = setTimeout(() => {
+        flushTimer = undefined;
+        void flushCache();
+    }, VIEWPORT_CACHE_FLUSH_DELAY_MS);
+}
+export async function getViewport(id, frameIndex) {
+    const c = await loadCache();
+    return c[cacheKey(id, frameIndex)];
 }
-export function getViewport(id, frameIndex) {
-    return readCache()[cacheKey(id, frameIndex)];
+export async function setViewport(id, frameIndex, viewport) {
+    const c = await loadCache();
+    c[cacheKey(id, frameIndex)] = viewport;
+    scheduleFlush();
 }
-export function setViewport(id, frameIndex, viewport) {
-    const cache = readCache();
-    cache[cacheKey(id, frameIndex)] = viewport;
-    writeCache(cache);
+/**
+ * Immediately flushes the in-memory cache to disk, bypassing (and cancelling)
+ * any pending debounced flush. Not needed in production — `setViewport`'s
+ * own scheduled flush is sufficient — but lets tests assert on-disk state
+ * deterministically without waiting on the real debounce delay or racing
+ * fake timers against real fs/promises I/O.
+ */
+export async function flushViewportCacheNow() {
+    if (flushTimer !== undefined) {
+        clearTimeout(flushTimer);
+        flushTimer = undefined;
+    }
+    await flushCache();
+}
+/**
+ * Drops the in-memory cache and cancels any pending flush, forcing the next
+ * call to reload from disk. Not needed in production (the snapshots root
+ * doesn't change at runtime); exists for tests whose fixtures recreate the
+ * snapshots directory on the same path between cases (`cachedForPath`'s
+ * path-based invalidation can't detect that on its own).
+ */
+export function resetViewportCacheForTest() {
+    cache = undefined;
+    cachedForPath = undefined;
+    if (flushTimer !== undefined) {
+        clearTimeout(flushTimer);
+        flushTimer = undefined;
+    }
 }
-export function deleteViewport(id) {
-    deleteViewports([id]);
+export async function deleteViewport(id) {
+    await deleteViewports([id]);
 }
 /** Removes every per-frame entry for each given snapshot id (prefix match on "<id>:"). */
-export function deleteViewports(ids) {
+export async function deleteViewports(ids) {
     if (ids.length === 0)
         return;
-    const cache = readCache();
+    const c = await loadCache();
     const prefixes = ids.map((id) => `${id}:`);
     let changed = false;
-    for (const key of Object.keys(cache)) {
+    for (const key of Object.keys(c)) {
         if (prefixes.some((prefix) => key.startsWith(prefix))) {
-            delete cache[key];
+            delete c[key];
             changed = true;
         }
     }
     if (changed)
-        writeCache(cache);
+        scheduleFlush();
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-whiteboard",
-  "version": "1.0.4",
+  "version": "1.2.0",
   "description": "A domain-agnostic interactive whiteboard for AI teacher agents — render diagrams, math, charts, and HTML to a local browser tab via MCP tools.",
   "type": "module",
   "bin": {
@@ -48,16 +48,21 @@
     "test": "vitest run",
     "test:e2e": "playwright test",
     "lint": "eslint .",
-    "lint:fix": "eslint . --fix"
+    "lint:fix": "eslint . --fix",
+    "prepublishOnly": "npm run build"
   },
   "dependencies": {
     "@hono/node-server": "^1.13.7",
     "@modelcontextprotocol/sdk": "^1.12.1",
+    "@types/archiver": "^7.0.0",
     "@types/dompurify": "^3.2.0",
+    "archiver": "^7.0.1",
     "bootstrap": "^5.3.8",
-    "dompurify": "^3.4.7",
-    "happy-dom": "^20.10.6",
+    "dompurify": "^3.4.15",
+    "extract-zip": "^2.0.1",
     "hono": "^4.7.11",
+    "jsdom": "^26.1.0",
+    "jszip": "^3.10.1",
     "katex": "^0.17.0",
     "mermaid": "^11.15.0",
     "open": "^10.1.2",
@@ -69,10 +74,11 @@
   "devDependencies": {
     "@eslint/js": "^10.0.1",
     "@playwright/test": "^1.60.0",
-    "@sveltejs/vite-plugin-svelte": "^2.4.6",
+    "@sveltejs/vite-plugin-svelte": "^3.1.2",
     "@testing-library/jest-dom": "^6.9.1",
     "@testing-library/svelte": "^4.2.3",
     "@tsconfig/svelte": "^5.0.4",
+    "@types/jsdom": "^30.0.0",
     "@types/node": "^20.17.57",
     "@types/ws": "^8.18.1",
     "concurrently": "^9.1.2",
@@ -85,8 +91,8 @@
     "tsx": "^3.14.0",
     "typescript": "^5.8.3",
     "typescript-eslint": "^8.62.1",
-    "vite": "^4.5.10",
-    "vitest": "^0.34.6",
+    "vite": "^5.4.21",
+    "vitest": "^3.2.7",
     "wait-on": "^8.0.3"
   }
 }

package/dist/client/assets/architecture-7EHR7CIX-1221aa61.js

@@ -1 +0,0 @@
-import{A as c,f as i}from"./mermaid-parser.core-52f9cd92.js";import"./index-ffc5af4b.js";export{c as ArchitectureModule,i as createArchitectureServices};