agent-whiteboard 1.0.3 → 1.1.0

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.3",
+  "version": "1.1.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};