pmx-canvas 0.6.5 → 0.7.0

package/src/server/canvas-operations.ts

@@ -5,6 +5,7 @@ import { recomputeCodeGraph } from './code-graph.js';
 import { diffLayouts } from './mutation-history.js';
 import {
   canvasState,
+  defaultBoardName,
   type CanvasEdge,
   type CanvasNodeState,
   type CanvasNodeUpdate,
@@ -20,6 +21,7 @@ import {
   type ExternalMcpTransportConfig,
 } from './mcp-app-runtime.js';
 import { mutationHistory } from './mutation-history.js';
+import { intentRegistry } from './intent-registry.js';
 import { clampCreateNodeSize } from './canvas-validation.js';
 import { computeGroupBounds, findOpenCanvasPosition } from './placement.js';
 import { searchNodes } from './spatial-analysis.js';
@@ -645,6 +647,7 @@ export function primeCanvasRuntimeBackends(options: { forceRehydrateExtApps?: bo
 export async function syncCanvasRuntimeBackends(
   options: { forceRehydrateExtApps?: boolean; alreadyPrimed?: boolean } = {},
 ): Promise<{ rehydrated: number; failed: number }> {
+  const boardGeneration = canvasState.boardGeneration;
   const targetIds =
     options.alreadyPrimed === true
       ? canvasState
@@ -656,6 +659,7 @@ export async function syncCanvasRuntimeBackends(
   let failed = 0;
 
   for (const nodeId of targetIds) {
+    if (canvasState.boardGeneration !== boardGeneration) break;
     const current = canvasState.getNode(nodeId);
     if (!isExtAppNode(current)) continue;
 
@@ -683,6 +687,10 @@ export async function syncCanvasRuntimeBackends(
           ? { serverName: current.data.serverName.trim() }
           : {}),
       });
+      if (canvasState.boardGeneration !== boardGeneration) {
+        closeMcpAppSession(opened.sessionId);
+        continue;
+      }
       const toolInput = resolveExtAppRehydratedToolInput(current, opened.toolInput);
       const storedCheckpointId = getStoredExcalidrawCheckpointId(current);
       const toolResult = isExcalidrawCreateView(opened.serverName, opened.toolName)
@@ -707,6 +715,7 @@ export async function syncCanvasRuntimeBackends(
       });
       rehydrated++;
     } catch (error) {
+      if (canvasState.boardGeneration !== boardGeneration) continue;
       canvasState.withSuppressedRecording(() => {
         setExtAppRuntimeState(nodeId, {
           appSessionId: null,
@@ -1060,6 +1069,7 @@ export async function refreshCanvasWebpageNode(
   }
 
   const currentData = existing.data;
+  const boardGeneration = canvasState.boardGeneration;
   const configuredUrl =
     typeof options.url === 'string' && options.url.trim().length > 0
       ? options.url
@@ -1085,16 +1095,11 @@ export async function refreshCanvasWebpageNode(
     };
   }
 
-  const fetchingData: Record<string, unknown> = {
-    ...currentData,
-    url: normalizedUrl,
-    status: 'fetching',
-  };
-  delete fetchingData.error;
-  canvasState.updateNode(id, { data: fetchingData });
-
   try {
     const snapshot = await fetchWebpageSnapshot(normalizedUrl);
+    if (canvasState.boardGeneration !== boardGeneration) {
+      return { ok: false, id, error: 'The board changed during webpage refresh.' };
+    }
     const latest = canvasState.getNode(id);
     if (!latest || latest.type !== 'webpage') {
       return { ok: false, id, error: `Webpage node "${id}" disappeared during refresh.` };
@@ -1128,6 +1133,9 @@ export async function refreshCanvasWebpageNode(
     canvasState.updateNode(id, { data: nextData });
     return { ok: true, id };
   } catch (error) {
+    if (canvasState.boardGeneration !== boardGeneration) {
+      return { ok: false, id, error: 'The board changed during webpage refresh.' };
+    }
     const details = getWebpageFetchErrorDetails(error);
     const latest = canvasState.getNode(id);
     if (latest?.type === 'webpage') {
@@ -1462,14 +1470,65 @@ export async function restoreCanvasSnapshot(idOrName: string): Promise<{ ok: boo
   const ok = canvasState.restoreSnapshot(idOrName);
   if (ok) {
     primeCanvasRuntimeBackends({ forceRehydrateExtApps: true });
+    const boardGeneration = canvasState.boardGeneration;
     void syncCanvasRuntimeBackends({ forceRehydrateExtApps: true, alreadyPrimed: true }).finally(() => {
-      emitCanvasLayoutUpdate();
+      if (canvasState.boardGeneration === boardGeneration) emitCanvasLayoutUpdate();
     });
     canvasState.flushToDisk();
   }
   return { ok };
 }
 
+/**
+ * Open a board (or Home for null): the state layer saves the current board and
+ * loads the next, and everything else that holds the old board in memory is
+ * reset — undo closures, pending intents, file watchers, app sessions and the
+ * code graph (the trace chain restarts itself when its last node is gone).
+ * Agent and human presence are kept: they belong to the people and agents,
+ * not to a board.
+ */
+export function openCanvasBoard(id: string | null): { ok: boolean } {
+  if (!canvasState.switchBoard(id)) return { ok: false };
+  mutationHistory.reset();
+  intentRegistry.reset();
+  startBoardRuntime();
+  return { ok: true };
+}
+
+function startBoardRuntime(): void {
+  primeCanvasRuntimeBackends({ forceRehydrateExtApps: true });
+  scheduleCodeGraphRecompute();
+  emitCanvasLayoutUpdate();
+  // App rehydration can take a network round trip; it finishes in the background.
+  const boardGeneration = canvasState.boardGeneration;
+  void syncCanvasRuntimeBackends({ forceRehydrateExtApps: true, alreadyPrimed: true }).finally(() => {
+    if (canvasState.boardGeneration === boardGeneration) emitCanvasLayoutUpdate();
+  });
+}
+
+/**
+ * Restore the whole library from a backup file (the current file is kept as
+ * `<db>.before-restore`); the restored library opens on its last open board.
+ */
+export function restoreCanvasLibrary(file: string): void {
+  canvasState.replaceDatabase(file);
+  mutationHistory.reset();
+  intentRegistry.reset();
+  startBoardRuntime();
+}
+
+/**
+ * A write that arrives while no board is open (Home) lands on the most recently
+ * opened board, or on a new board when the workspace has none — nothing on
+ * Home is displaced, because Home holds nothing. Intents and undo history are
+ * kept: whatever was signalled on Home was aimed at the board this opens.
+ */
+export function openBoardForWrite(): void {
+  if (canvasState.activeBoardId) return;
+  const recent = canvasState.listBoards()[0] ?? canvasState.createBoard(defaultBoardName());
+  if (recent && canvasState.switchBoard(recent.id)) startBoardRuntime();
+}
+
 export function deleteCanvasSnapshot(id: string): { ok: boolean } {
   return { ok: canvasState.deleteSnapshot(id) };
 }

package/src/server/canvas-provenance.ts

@@ -7,6 +7,7 @@ export type CanvasNodeType =
   | 'webpage'
   | 'json-render'
   | 'graph'
+  | 'board'
   | 'prompt'
   | 'response'
   | 'status'

package/src/server/canvas-schema.ts

@@ -107,6 +107,18 @@ const CANVAS_CREATE_TYPES: CanvasCreateTypeSchema[] = [
       'When a markdown node is path-backed (`data.path`), the server persists `data.provenance` so snapshots keep a refreshable file source.',
     ],
   },
+  {
+    type: 'board',
+    kind: 'node',
+    description: 'Text-only link to another board by durable id.',
+    endpoint: '/api/canvas/node',
+    mcpTool: 'canvas_node (action:"add")',
+    fields: [
+      { name: 'title', type: 'string', required: false, description: 'Pinned fallback title.' },
+      { name: 'data', type: 'object', required: true, description: 'Contains boardId, the durable target board id.' },
+    ],
+    example: { type: 'board', title: 'Research', data: { boardId: 'board-abc123' } },
+  },
   {
     type: 'status',
     kind: 'node',