collabmd 0.1.54 → 0.1.55

package/src/domain/file-kind.js

@@ -1,6 +1,7 @@
 const MARKDOWN_FILE_EXTENSIONS = Object.freeze(['.md', '.markdown', '.mdx']);
 const HTML_FILE_EXTENSIONS = Object.freeze(['.html', '.htm']);
 const BASE_FILE_EXTENSION = '.base';
+const CANVAS_FILE_EXTENSION = '.canvas';
 const EXCALIDRAW_FILE_EXTENSION = '.excalidraw';
 const DRAWIO_FILE_EXTENSION = '.drawio';
 const MERMAID_FILE_EXTENSIONS = Object.freeze(['.mmd', '.mermaid']);
@@ -10,6 +11,7 @@ const STRUCTURIZR_FILE_EXTENSIONS = Object.freeze([STRUCTURIZR_FILE_EXTENSION]);
 const PDF_FILE_EXTENSION = '.pdf';
 const IMAGE_ATTACHMENT_EXTENSIONS = Object.freeze(['.png', '.jpg', '.jpeg', '.webp', '.gif', '.svg']);
 const DIAGRAM_FILE_EXTENSIONS = Object.freeze([
+  CANVAS_FILE_EXTENSION,
   EXCALIDRAW_FILE_EXTENSION,
   DRAWIO_FILE_EXTENSION,
   ...MERMAID_FILE_EXTENSIONS,
@@ -24,7 +26,7 @@ const VAULT_FILE_EXTENSIONS = Object.freeze([
   PDF_FILE_EXTENSION,
   ...IMAGE_ATTACHMENT_EXTENSIONS,
 ]);
-const STRIP_VAULT_EXTENSION_PATTERN = /\.(?:md|markdown|mdx|html?|base|excalidraw|drawio|mmd|mermaid|puml|plantuml|dsl|pdf|png|jpe?g|webp|gif|svg)$/i;
+const STRIP_VAULT_EXTENSION_PATTERN = /\.(?:md|markdown|mdx|html?|base|canvas|excalidraw|drawio|mmd|mermaid|puml|plantuml|dsl|pdf|png|jpe?g|webp|gif|svg)$/i;
 
 function normalizeFilePath(filePath) {
   return String(filePath ?? '').trim().toLowerCase();
@@ -37,6 +39,7 @@ function hasFileExtension(filePath, extensions) {
 
 export {
   BASE_FILE_EXTENSION,
+  CANVAS_FILE_EXTENSION,
   DIAGRAM_FILE_EXTENSIONS,
   DRAWIO_FILE_EXTENSION,
   EXCALIDRAW_FILE_EXTENSION,
@@ -64,6 +67,10 @@ export function getVaultFileKind(filePath) {
     return 'base';
   }
 
+  if (hasFileExtension(filePath, [CANVAS_FILE_EXTENSION])) {
+    return 'canvas';
+  }
+
   if (hasFileExtension(filePath, [EXCALIDRAW_FILE_EXTENSION])) {
     return 'excalidraw';
   }
@@ -129,6 +136,10 @@ export function isExcalidrawFilePath(filePath) {
   return getVaultFileKind(filePath) === 'excalidraw';
 }
 
+export function isCanvasFilePath(filePath) {
+  return getVaultFileKind(filePath) === 'canvas';
+}
+
 export function isBaseFilePath(filePath) {
   return getVaultFileKind(filePath) === 'base';
 }
@@ -160,6 +171,7 @@ export function isImageAttachmentFilePath(filePath) {
 export function isDiagramFilePath(filePath) {
   const kind = getVaultFileKind(filePath);
   return kind === 'excalidraw'
+    || kind === 'canvas'
     || kind === 'drawio'
     || kind === 'mermaid'
     || kind === 'plantuml'

package/src/server/application/workspace-reconciliation.js

@@ -11,8 +11,6 @@ import {
   createWorkspaceTree,
   deriveNextWorkspaceStateForApiMutation as deriveNextWorkspaceStateFromApiMutation,
   diffWorkspaceEntries,
-  isIncrementalWorkspaceMutationAction,
-  readWorkspacePathState as readWorkspacePathStateFromAdapter,
 } from '../domain/workspace-state.js';
 
 function createEventId() {
@@ -87,18 +85,6 @@ export class WorkspaceReconciliation {
     return this.workspaceTree;
   }
 
-  isIncrementalApiAction(action) {
-    return isIncrementalWorkspaceMutationAction(action);
-  }
-
-  async readWorkspacePathState(pathValue, {
-    expectDirectory = null,
-  } = {}) {
-    return readWorkspacePathStateFromAdapter(this.workspaceStateAdapter, pathValue, {
-      expectDirectory,
-    });
-  }
-
   async deriveNextWorkspaceStateForApiMutation(action, workspaceChange = {}) {
     return deriveNextWorkspaceStateFromApiMutation(this.workspaceStateAdapter, {
       action,

package/src/server/domain/backlink-index.js

@@ -49,7 +49,6 @@ export class BacklinkIndex {
     /** @type {Set<string>} file path membership set */
     this._fileSet = new Set();
     this._wikiTargetIndex = createWikiTargetIndex(this._fileList);
-    this._built = false;
     this._requestedBuildVersion = 0;
     this._completedBuildVersion = 0;
     this._buildPromise = null;
@@ -141,7 +140,7 @@ export class BacklinkIndex {
     this.rawTargetKeysBySource.clear();
     this.rawTargetSources.clear();
 
-    const snapshot = workspaceState ?? await this._resolveWorkspaceState();
+    const snapshot = workspaceState ?? await this.vaultFileStore.scanWorkspaceState();
     this._fileList = Array.from(snapshot?.filePaths ?? snapshot?.markdownPaths ?? []);
     this._fileSet = new Set(this._fileList);
     this._sourceFileList = Array.from(
@@ -165,23 +164,9 @@ export class BacklinkIndex {
       }
     }
 
-    this._built = true;
     console.log(`[backlinks] Index built: ${this._sourceFileList.length} markdown sources, ${this._fileList.length} targets, ${this.reverse.size} targets with backlinks`);
   }
 
-  async _resolveWorkspaceState() {
-    if (typeof this.vaultFileStore.scanWorkspaceState === 'function') {
-      return this.vaultFileStore.scanWorkspaceState();
-    }
-
-    const tree = await this.vaultFileStore.tree();
-    const filePaths = flattenTree(tree);
-    return {
-      filePaths,
-      markdownPaths: filePaths.filter((filePath) => isMarkdownFilePath(filePath)),
-    };
-  }
-
   /**
    * Incrementally update the index when a file's content changes.
    * Call this after every persist / write.
@@ -469,13 +454,6 @@ export class BacklinkIndex {
     return results;
   }
 
-  /**
-   * Get the count of backlinks for a file (cheap — no I/O).
-   */
-  getBacklinkCount(filePath) {
-    return this.reverse.get(filePath)?.size ?? 0;
-  }
-
   // --- Private methods ---
 
   _indexFile(filePath, content, { targetPathAliases = new Map() } = {}) {
@@ -621,16 +599,3 @@ export class BacklinkIndex {
     }
   }
 }
-
-/** Flatten a vault tree into an array of file paths. */
-function flattenTree(nodes) {
-  const files = [];
-  for (const node of nodes) {
-    if (node.type && node.type !== 'directory') {
-      files.push(node.path);
-    } else if (node.children) {
-      files.push(...flattenTree(node.children));
-    }
-  }
-  return files;
-}

package/src/server/domain/bases/base-index-snapshot-store.js

@@ -26,17 +26,11 @@ function cloneSnapshotRowRecord(rowRecord) {
   };
 }
 
-function createWorkspaceFileSetSignature(fileEntries = []) {
-  return fileEntries.join('\n');
-}
-
-function createRowCacheKey(filePath, workspaceState, fileSetSignature) {
+function createRowMetadataSignature(filePath, workspaceState) {
   const metadata = workspaceState?.metadata?.get(filePath) ?? null;
   return [
-    filePath,
     Number.isFinite(metadata?.mtimeMs) ? metadata.mtimeMs : '',
     Number.isFinite(metadata?.size) ? metadata.size : '',
-    fileSetSignature,
   ].join('\0');
 }
 
@@ -139,6 +133,8 @@ export class BaseIndexSnapshotStore {
     this.indexSnapshot = null;
     this.lastWorkspaceState = null;
     this.rowRecordCache = new Map();
+    this.rowRecordCacheFileSetSignature = '';
+    this.rowRecordCacheGeneration = 0;
   }
 
   async getWorkspaceState() {
@@ -305,13 +301,16 @@ export class BaseIndexSnapshotStore {
   async buildIndexSnapshot(workspaceState = null) {
     const resolvedWorkspaceState = workspaceState ?? await this.getWorkspaceState();
     const fileEntries = listWorkspaceFilePaths(resolvedWorkspaceState);
-    const fileSetSignature = createWorkspaceFileSetSignature(fileEntries);
+    const cacheGeneration = this.prepareRowRecordCache(fileEntries);
     const wikiTargetIndex = createWikiTargetIndex(fileEntries);
     const markdownContents = new Map();
+    // Keep reused rows available if another build replaces the shared cache during I/O.
+    const cachedRowRecords = new Map(fileEntries.map((filePath) => [
+      filePath, this.getCachedRowRecord(filePath, resolvedWorkspaceState, cacheGeneration),
+    ]));
 
     await mapWithConcurrency(resolvedWorkspaceState.markdownPaths ?? [], INDEX_READ_CONCURRENCY, async (filePath) => {
-      const cacheKey = createRowCacheKey(filePath, resolvedWorkspaceState, fileSetSignature);
-      if (!this.rowRecordCache.has(cacheKey)) {
+      if (!cachedRowRecords.get(filePath)) {
         markdownContents.set(filePath, await this.vaultFileStore.readMarkdownFile(filePath));
       }
     });
@@ -322,13 +321,16 @@ export class BaseIndexSnapshotStore {
     const rawTargetSourcesByKey = new Map();
     const nextRowRecordCache = new Map();
     fileEntries.forEach((filePath) => {
-      const cacheKey = createRowCacheKey(filePath, resolvedWorkspaceState, fileSetSignature);
-      const cachedRowRecord = this.rowRecordCache.get(cacheKey);
+      const cachedRowRecord = cachedRowRecords.get(filePath);
       const markdownContent = markdownContents.get(filePath) ?? null;
       const rowRecord = cachedRowRecord
         ? cloneSnapshotRowRecord(cachedRowRecord)
         : this.createSnapshotRow(filePath, resolvedWorkspaceState, wikiTargetIndex, markdownContent);
-      nextRowRecordCache.set(cacheKey, cloneSnapshotRowRecord(rowRecord));
+      nextRowRecordCache.set(filePath, {
+        generation: cacheGeneration,
+        metadataSignature: createRowMetadataSignature(filePath, resolvedWorkspaceState),
+        rowRecord: cloneSnapshotRowRecord(rowRecord),
+      });
       rowsByPath.set(filePath, rowRecord.row);
       forwardLinksByPath.set(filePath, rowRecord.forwardLinks);
       rawTargetKeysBySourcePath.set(filePath, rowRecord.rawTargetKeys);
@@ -411,7 +413,7 @@ export class BaseIndexSnapshotStore {
         return pathValue && isWorkspaceFileEntry(entry);
       });
 
-    const fileSetSignature = createWorkspaceFileSetSignature(snapshot.filePaths);
+    const cacheGeneration = this.prepareRowRecordCache(snapshot.filePaths);
     await mapWithConcurrency(filePathsToRefresh, INDEX_READ_CONCURRENCY, async (filePath) => {
       const markdownContent = isMarkdownFilePath(filePath)
         ? await this.vaultFileStore.readMarkdownFile(filePath)
@@ -419,11 +421,11 @@ export class BaseIndexSnapshotStore {
       const rowRecord = this.createSnapshotRow(filePath, workspaceState, snapshot.wikiTargetIndex, markdownContent, {
         targetPathAliases,
       });
-      this.invalidateRowRecordCachePath(filePath);
-      this.rowRecordCache.set(
-        createRowCacheKey(filePath, workspaceState, fileSetSignature),
-        cloneSnapshotRowRecord(rowRecord),
-      );
+      this.rowRecordCache.set(filePath, {
+        generation: cacheGeneration,
+        metadataSignature: createRowMetadataSignature(filePath, workspaceState),
+        rowRecord: cloneSnapshotRowRecord(rowRecord),
+      });
       this.removeRawTargetSourceContributions(snapshot, filePath);
       snapshot.rowsByPath.set(filePath, rowRecord.row);
       snapshot.forwardLinksByPath.set(filePath, rowRecord.forwardLinks);
@@ -431,12 +433,27 @@ export class BaseIndexSnapshotStore {
     });
   }
 
+  prepareRowRecordCache(filePaths) {
+    const signature = JSON.stringify(filePaths);
+    if (signature !== this.rowRecordCacheFileSetSignature) {
+      // Link resolution depends on every target path, including previously missing files.
+      this.rowRecordCache.clear();
+      this.rowRecordCacheFileSetSignature = signature;
+      this.rowRecordCacheGeneration += 1;
+    }
+    return this.rowRecordCacheGeneration;
+  }
+
+  getCachedRowRecord(filePath, workspaceState, generation) {
+    const cached = this.rowRecordCache.get(filePath);
+    return cached?.generation === generation
+      && cached.metadataSignature === createRowMetadataSignature(filePath, workspaceState)
+      ? cached.rowRecord
+      : null;
+  }
+
   invalidateRowRecordCachePath(filePath) {
-    Array.from(this.rowRecordCache.keys()).forEach((cacheKey) => {
-      if (cacheKey === filePath || cacheKey.startsWith(`${filePath}\0`)) {
-        this.rowRecordCache.delete(cacheKey);
-      }
-    });
+    this.rowRecordCache.delete(filePath);
   }
 
   async ensureIndexSnapshot({ basePath = '', sourcePath = '' } = {}) {

package/src/server/domain/bases/base-query-service.js

@@ -56,32 +56,6 @@ function sortRows(rows, sortChain = []) {
   });
 }
 
-function compareRowsBySortChain(left, right, sortChain = []) {
-  for (const sortConfig of sortChain) {
-    const delta = compareValues(left.rawCells[sortConfig.property], right.rawCells[sortConfig.property]);
-    if (delta !== 0) {
-      return sortConfig.direction === 'desc' ? -delta : delta;
-    }
-  }
-
-  return String(left.file.path ?? '').localeCompare(String(right.file.path ?? ''));
-}
-
-function insertSortedBounded(rows, row, {
-  limit,
-  sortChain = [],
-}) {
-  let insertIndex = rows.findIndex((existingRow) => compareRowsBySortChain(row, existingRow, sortChain) < 0);
-  if (insertIndex === -1) {
-    insertIndex = rows.length;
-  }
-
-  rows.splice(insertIndex, 0, row);
-  if (rows.length > limit) {
-    rows.pop();
-  }
-}
-
 function pruneFilterNodeForProperty(filterNode, propertyId = '') {
   if (!propertyId || !filterNode) {
     return filterNode;
@@ -225,21 +199,12 @@ export class BaseQueryService {
     columns = [],
     definition,
     evaluatedPropertyIds,
-    limit = null,
-    maxRows = this.maxResultRows,
     snapshot,
-    sortChain = [],
     search = '',
     thisFile,
   }) {
+    // ponytail: retain matching rows for one native sort; use bounded selection if heap profiles require it.
     const rows = [];
-    const effectiveMaxRows = Number.isInteger(maxRows) && maxRows > 0 ? maxRows : Infinity;
-    const effectiveLimit = Number.isInteger(limit) && limit > 0 ? limit : Infinity;
-    const canBoundDuringCollection = Number.isFinite(Math.min(effectiveLimit, effectiveMaxRows))
-      && sortChain.length > 0
-      && !activeView.groupBy?.property
-      && (activeView.summaries?.length ?? 0) === 0;
-    const hardLimit = Math.min(effectiveLimit, effectiveMaxRows);
 
     const filePaths = snapshot.filePaths ?? [];
     for (let chunkStart = 0; chunkStart < filePaths.length; chunkStart += BASE_QUERY_ROW_CHUNK_SIZE) {
@@ -275,14 +240,6 @@ export class BaseQueryService {
           continue;
         }
 
-        if (canBoundDuringCollection) {
-          insertSortedBounded(rows, candidateRow, {
-            limit: hardLimit,
-            sortChain,
-          });
-          continue;
-        }
-
         rows.push(candidateRow);
       }
 
@@ -390,10 +347,7 @@ export class BaseQueryService {
     let rows = await this.collectCandidateRows({
       ...context,
       astCache,
-      limit: requestedLimit,
-      maxRows: this.maxResultRows,
       search,
-      sortChain,
     });
     rows = sortRows(rows, sortChain);
 

package/src/server/domain/collaboration/collaboration-room.js

@@ -14,7 +14,21 @@ import {
 import { CollaborationDocumentStore } from './collaboration-document-store.js';
 import { logPerfEvent } from '../../config/perf-logging.js';
 import { populateCommentThreads, serializeCommentThreads } from '../../../domain/comment-threads.js';
-import { getVaultFileKind } from '../../../domain/file-kind.js';
+import { getVaultFileKind, isCanvasFilePath } from '../../../domain/file-kind.js';
+import {
+  buildCanvasRoomDocument,
+  CANVAS_EDGES_KEY,
+  CANVAS_EDGE_ORDER_KEY,
+  CANVAS_META_KEY,
+  CANVAS_NODES_KEY,
+  CANVAS_NODE_ORDER_KEY,
+  isCanvasRoomDocStructured,
+  mergeCanvasDocuments,
+  parseCanvasJson,
+  replaceCanvasRoomDocument,
+  serializeCanvasDocument,
+  serializeCanvasRoomDocument,
+} from '../../../domain/canvas-room-codec.js';
 import {
   applySceneDiffToExcalidrawRoom,
   EXCALIDRAW_APP_STATE_KEY,
@@ -292,7 +306,28 @@ export class CollaborationRoom {
             if (snapshot) {
               snapshotExists = true;
               try {
-                if (isExcalidrawRoom(this.name)) {
+                if (isCanvasFilePath(this.name)) {
+                  const validationDoc = new Y.Doc({ gc: true });
+                  try {
+                    Y.applyUpdate(validationDoc, snapshot, 'hydrate');
+                    const stored = serializeCanvasRoomDocument(validationDoc);
+                    const content = await this.documentStore.readContent();
+                    const meta = validationDoc.getMap(CANVAS_META_KEY);
+                    if (meta.has('externalConflict')) {
+                      let invalid = false;
+                      try { parseCanvasJson(content); } catch { invalid = true; }
+                      meta.set('externalConflict', { content, invalid });
+                    } else {
+                      const external = parseCanvasJson(content);
+                      if (stored !== serializeCanvasDocument(external)) {
+                        replaceCanvasRoomDocument(validationDoc, external);
+                      }
+                    }
+                    Y.applyUpdate(this.doc, Y.encodeStateAsUpdate(validationDoc), 'hydrate');
+                  } finally {
+                    validationDoc.destroy();
+                  }
+                } else if (isExcalidrawRoom(this.name)) {
                   const validationDoc = new Y.Doc({ gc: true });
                   try {
                     Y.applyUpdate(validationDoc, snapshot, 'hydrate');
@@ -332,7 +367,13 @@ export class CollaborationRoom {
               const ytext = this.doc.getText('codemirror');
               const comments = this.doc.getArray('comments');
               this.doc.transact(() => {
-                if (isExcalidrawRoom(this.name)) {
+                if (isCanvasFilePath(this.name)) {
+                  try {
+                    replaceCanvasRoomDocument(this.doc, parseCanvasJson(content));
+                  } catch {
+                    this.doc.getMap(CANVAS_META_KEY).set('invalidContent', true);
+                  }
+                } else if (isExcalidrawRoom(this.name)) {
                   const parsedScene = tryParseExcalidrawSceneJson(content);
                   if (parsedScene) {
                     migrateLegacyExcalidrawRoomData(this.doc, parsedScene);
@@ -346,7 +387,7 @@ export class CollaborationRoom {
               }, 'hydrate');
 
               const replacementSnapshot = Y.encodeStateAsUpdate(this.doc);
-              if (snapshotNeedsReplacement) {
+              if (snapshotNeedsReplacement || isCanvasFilePath(this.name)) {
                 await this.documentStore.writeSnapshot(replacementSnapshot);
               } else {
                 void this.documentStore.writeSnapshot(replacementSnapshot).catch((error) => {
@@ -462,6 +503,13 @@ export class CollaborationRoom {
       this.contentDirty = true;
     };
 
+    if (isCanvasFilePath(this.name)) {
+      for (const key of [CANVAS_NODES_KEY, CANVAS_EDGES_KEY, CANVAS_NODE_ORDER_KEY, CANVAS_EDGE_ORDER_KEY, CANVAS_META_KEY]) {
+        this.doc.getMap(key).observeDeep((_events, transaction) => markFromTransaction(transaction));
+      }
+      return;
+    }
+
     if (isExcalidrawRoom(this.name)) {
       this.doc.getMap(EXCALIDRAW_ELEMENTS_KEY).observeDeep((_events, transaction) => {
         markFromTransaction(transaction);
@@ -482,6 +530,12 @@ export class CollaborationRoom {
 
   resetContentBaseline() {
     this.persistedContentBaseline = this.getPersistedContent();
+    if (isCanvasFilePath(this.name)) {
+      const conflict = this.doc.getMap(CANVAS_META_KEY).get('externalConflict');
+      if (conflict) {
+        this.persistedContentBaseline = conflict.invalid ? null : serializeCanvasDocument(parseCanvasJson(conflict.content));
+      }
+    }
     this.contentDirty = false;
   }
 
@@ -555,15 +609,38 @@ export class CollaborationRoom {
         return;
       }
 
-      const content = this.getPersistedContent();
+      let content = this.getPersistedContent();
       if (content === null) {
-        console.warn(`[room:${this.name}] Skipping persist because the Excalidraw scene is invalid`);
+        console.warn(`[room:${this.name}] Skipping persist because the document is invalid`);
         return;
       }
+      if (isCanvasFilePath(this.name) && content !== this.persistedContentBaseline && !this.doc.getMap(CANVAS_META_KEY).has('externalConflict')) {
+        const externalContent = await this.documentStore.readContent();
+        if (this.deleted || this.destroyed) return;
+        if (externalContent === null) {
+          this.markDeleted();
+          return;
+        }
+        let externalBaseline = null;
+        let invalid = false;
+        try { externalBaseline = serializeCanvasDocument(parseCanvasJson(externalContent)); } catch { invalid = true; }
+        content = this.getPersistedContent();
+        if (content === null) return;
+        // A filesystem observation may still be queued when the save timer fires.
+        if (externalBaseline !== this.persistedContentBaseline) {
+          this.persistedContentBaseline = externalBaseline;
+          if (externalBaseline !== content) {
+            this.doc.transact(() => {
+              this.doc.getMap(CANVAS_META_KEY).set('externalConflict', { content: externalContent, invalid });
+            }, 'workspace-reconcile');
+          }
+        }
+      }
       // Compare inline: refreshContentDirty() would serialize the document
       // a second time for the same check.
-      const includeContent = content !== this.persistedContentBaseline;
-      this.contentDirty = includeContent;
+      const conflict = isCanvasFilePath(this.name) && this.doc.getMap(CANVAS_META_KEY).has('externalConflict');
+      this.contentDirty = content !== this.persistedContentBaseline;
+      const includeContent = this.contentDirty && !conflict;
       const commentThreads = serializeCommentThreads(this.doc.getArray('comments'));
       await this.documentStore.persistState({
         commentThreads,
@@ -616,6 +693,46 @@ export class CollaborationRoom {
     }
 
     const comments = this.doc.getArray('comments');
+    if (isCanvasFilePath(this.name)) {
+      let external;
+      try {
+        external = parseCanvasJson(content);
+      } catch {
+        this.doc.transact(() => {
+          this.doc.getMap(CANVAS_META_KEY).set('externalConflict', { content, invalid: true });
+        }, 'workspace-reconcile');
+        this.persistedContentBaseline = null;
+        // Preserve the pending document in a sidecar while the invalid file remains untouched.
+        await this.persist();
+        return { ok: false, reason: 'invalid-canvas' };
+      }
+
+      const meta = this.doc.getMap(CANVAS_META_KEY);
+      const current = this.getPersistedContent();
+      const hasPendingChanges = current !== null && current !== this.persistedContentBaseline;
+      const reconciliation = hasPendingChanges && this.persistedContentBaseline !== null
+        ? mergeCanvasDocuments(parseCanvasJson(this.persistedContentBaseline), buildCanvasRoomDocument(this.doc), external)
+        : { conflict: hasPendingChanges, document: external };
+      const hadConflict = meta.has('externalConflict');
+      this.doc.transact(() => {
+        if (reconciliation.conflict || hadConflict) {
+          meta.set('externalConflict', { content, invalid: false });
+        } else {
+          replaceCanvasRoomDocument(this.doc, reconciliation.document);
+          meta.delete('invalidContent');
+        }
+        if (replaceCommentThreads) {
+          if (comments.length > 0) comments.delete(0, comments.length);
+          populateCommentThreads(comments, commentThreads);
+        }
+      }, 'workspace-reconcile');
+      this.persistedContentBaseline = serializeCanvasDocument(external);
+      this.refreshContentDirty();
+      if (this.contentDirty && !meta.has('externalConflict')) this.schedulePersist();
+      else await this.persist();
+      return { ok: true, highlightRange: null, conflict: meta.has('externalConflict') };
+    }
+
     if (isExcalidrawRoom(this.name)) {
       const parsedExcalidrawScene = tryParseExcalidrawSceneJson(content);
       if (!parsedExcalidrawScene) {
@@ -712,10 +829,6 @@ export class CollaborationRoom {
     }
   }
 
-  unmarkDeleted() {
-    this.deleted = false;
-  }
-
   isDeleted() {
     return this.deleted;
   }
@@ -917,14 +1030,14 @@ export class CollaborationRoom {
   }
 
   readEditableContent() {
-    if (!this.hydrated || this.deleted || this.destroyed || isExcalidrawRoom(this.name)) {
+    if (!this.hydrated || this.deleted || this.destroyed || isExcalidrawRoom(this.name) || isCanvasFilePath(this.name)) {
       return null;
     }
     return this.doc.getText('codemirror').toString();
   }
 
   applyExactTextChanges(changes, { origin = 'agent' } = {}) {
-    if (!this.hydrated || this.deleted || this.destroyed || isExcalidrawRoom(this.name)) {
+    if (!this.hydrated || this.deleted || this.destroyed || isExcalidrawRoom(this.name) || isCanvasFilePath(this.name)) {
       throw new Error('The collaborative document is unavailable');
     }
     const ytext = this.doc.getText('codemirror');
@@ -962,6 +1075,14 @@ export class CollaborationRoom {
       return null;
     }
 
+    if (isCanvasFilePath(this.name)) {
+      try {
+        return isCanvasRoomDocStructured(this.doc) ? serializeCanvasRoomDocument(this.doc) : null;
+      } catch {
+        return null;
+      }
+    }
+
     if (!isExcalidrawRoom(this.name)) {
       return this.doc.getText('codemirror').toString();
     }
@@ -1027,7 +1148,20 @@ export class CollaborationRoom {
           const encoder = encoding.createEncoder();
           encoding.writeVarUint(encoder, MSG_AGENT_FLUSH_ACK);
           encoding.writeVarString(encoder, requestId);
-          sendMessage.call(this, ws, encoding.toUint8Array(encoder), this);
+          const acknowledge = () => sendMessage.call(this, ws, encoding.toUint8Array(encoder), this);
+          if (isCanvasFilePath(this.name)) {
+            const available = () => this.hydrated && !this.deleted && !this.destroyed
+              && this.documentStore?.hasPersistence() && this.getPersistedContent() !== null;
+            if (available()) {
+              void this.persist().then(() => {
+                if (available()) acknowledge();
+              }).catch((error) => {
+                console.error(`[room:${this.name}] Failed to persist canvas before flush acknowledgement:`, error.message);
+              });
+            }
+          } else {
+            acknowledge();
+          }
           break;
         }
 

package/src/server/domain/collaboration/room-registry.js

@@ -1,3 +1,5 @@
+import { getVaultFileKind } from '../../../domain/file-kind.js';
+
 export class RoomRegistry {
   constructor({ createRoom }) {
     this.createRoom = createRoom;
@@ -31,6 +33,10 @@ export class RoomRegistry {
       return false;
     }
 
+    const oldKind = getVaultFileKind(oldName);
+    const newKind = getVaultFileKind(newName);
+    if (oldKind !== newKind && [oldKind, newKind].includes('canvas')) return false;
+
     const room = this.rooms.get(oldName);
     if (!room) {
       return false;
@@ -61,12 +67,6 @@ export class RoomRegistry {
     return Array.from(this.rooms.entries());
   }
 
-  async reloadAllFromDisk() {
-    await Promise.allSettled(
-      Array.from(this.rooms.values(), (room) => room.reloadFromDisk?.()),
-    );
-  }
-
   async reconcileWorkspaceChange(workspaceChange = {}) {
     const deletedPaths = new Set(workspaceChange.deletedPaths ?? []);
     const renamedPaths = Array.isArray(workspaceChange.renamedPaths) ? workspaceChange.renamedPaths : [];
@@ -128,7 +128,7 @@ export class RoomRegistry {
           }
 
           const result = await room.reloadFromDisk?.();
-          if (result && result.ok === false && result.reason === 'invalid-excalidraw') {
+          if (result && result.ok === false && ['invalid-excalidraw', 'invalid-canvas'].includes(result.reason)) {
             reloadRequiredPaths.push(pathValue);
           } else if (result?.highlightRange) {
             highlightRanges.push({