fix: persist comments on reload in collab mode

packages/superdoc/src/SuperDoc.test.js

@@ -638,6 +638,21 @@ describe('SuperDoc.vue', () => {
     expect(commentsStoreStub.clearEditorCommentPositions).toHaveBeenCalled();
   });
 
+  it('forwards empty comment position payloads to store-level guard', async () => {
+    const superdocStub = createSuperdocStub();
+    const wrapper = await mountComponent(superdocStub);
+    await nextTick();
+
+    const options = wrapper.findComponent(SuperEditorStub).props('options');
+    options.onCommentLocationsUpdate({
+      allCommentPositions: {},
+      allCommentIds: [],
+    });
+    await nextTick();
+
+    expect(commentsStoreStub.handleEditorLocationsUpdate).toHaveBeenCalledWith({}, []);
+  });
+
   it('clears PDF selections when viewing mode is active to keep tools hidden', async () => {
     const superdocStub = createSuperdocStub();
     superdocStub.config.documentMode = 'viewing';

packages/superdoc/src/SuperDoc.vue

@@ -250,7 +250,6 @@ const onEditorReady = ({ editor, presentationEditor }) => {
   presentationEditor.on('commentPositions', ({ positions }) => {
     const commentsConfig = proxy.$superdoc.config.modules?.comments;
     if (!commentsConfig || commentsConfig === false) return;
-    if (!positions || Object.keys(positions).length === 0) return;
     if (!shouldRenderCommentsInViewing.value) {
       commentsStore.clearEditorCommentPositions?.();
       return;
@@ -453,6 +452,11 @@ const editorOptions = (doc) => {
     proxy.$superdoc.listeners?.('fonts-resolved')?.length > 0 ? proxy.$superdoc.listeners('fonts-resolved')[0] : null;
   const useLayoutEngine = proxy.$superdoc.config.useLayoutEngine !== false;
 
+  const ydocFragment = doc.ydoc?.getXmlFragment?.('supereditor');
+  const ydocMeta = doc.ydoc?.getMap?.('meta');
+  const ydocHasContent = (ydocFragment && ydocFragment.length > 0) || (ydocMeta && Boolean(ydocMeta.get('docx')));
+  const isNewFile = doc.isNewFile && !ydocHasContent;
+
   const options = {
     isDebug: proxy.$superdoc.config.isDebug || false,
     documentId: doc.id,
@@ -493,7 +497,7 @@ const editorOptions = (doc) => {
     onTransaction: onEditorTransaction,
     ydoc: doc.ydoc,
     collaborationProvider: doc.provider || null,
-    isNewFile: doc.isNewFile || false,
+    isNewFile,
     handleImageUpload: proxy.$superdoc.config.handleImageUpload,
     externalExtensions: proxy.$superdoc.config.editorExtensions || [],
     suppressDefaultDocxStyles: proxy.$superdoc.config.suppressDefaultDocxStyles,

packages/superdoc/src/core/SuperDoc.js

@@ -399,6 +399,9 @@ export class SuperDoc extends EventEmitter {
     this.superdocStore.init(this.config);
     const commentsModuleConfig = this.config.modules.comments;
     this.commentsStore.init(commentsModuleConfig && commentsModuleConfig !== false ? commentsModuleConfig : {});
+    if (this.isCollaborative) {
+      initCollaborationComments(this);
+    }
     this.#syncViewingVisibility();
   }
 

packages/superdoc/src/core/collaboration/collaboration.test.js

@@ -2,6 +2,7 @@ import { describe, it, expect, vi, beforeAll, beforeEach, afterEach } from 'vite
 import * as collaborationModule from './collaboration.js';
 import {
   initCollaborationComments,
+  loadCommentsFromYdoc,
   initSuperdocYdoc,
   makeDocumentsCollaborative,
   syncCommentsToClients,
@@ -292,6 +293,58 @@ describe('collaboration helpers', () => {
     expect(useCommentMock).toHaveBeenCalledTimes(2);
   });
 
+  it('initCollaborationComments loads existing comments from ydoc on init', () => {
+    commentsArray.items = [
+      new MockYMap(Object.entries({ commentId: 'c1', text: 'Hello' })),
+      new MockYMap(Object.entries({ commentId: 'c1', text: 'Duplicate' })),
+      new MockYMap(Object.entries({ commentId: 'c2', text: 'Another' })),
+    ];
+
+    initCollaborationComments(superdoc);
+
+    expect(useCommentMock).toHaveBeenCalledTimes(2);
+    expect(superdoc.commentsStore.commentsList).toEqual([{ normalized: 'c1' }, { normalized: 'c2' }]);
+  });
+
+  it('loadCommentsFromYdoc hydrates comments from importedId and deduplicates by stable key', () => {
+    commentsArray.items = [
+      new MockYMap(Object.entries({ importedId: 'legacy-1', text: 'legacy without commentId' })),
+      new MockYMap(Object.entries({ importedId: 'legacy-1', text: 'duplicate legacy' })),
+      new MockYMap(Object.entries({ commentId: 'c2', text: 'normal comment' })),
+      new MockYMap(Object.entries({ commentId: 'c2', text: 'duplicate normal comment' })),
+    ];
+    superdoc.provider.synced = true;
+
+    const loaded = loadCommentsFromYdoc(superdoc);
+
+    expect(loaded).toBe(true);
+    expect(useCommentMock).toHaveBeenCalledTimes(2);
+    expect(useCommentMock).toHaveBeenNthCalledWith(
+      1,
+      expect.objectContaining({ importedId: 'legacy-1', commentId: 'legacy-1' }),
+    );
+    expect(useCommentMock).toHaveBeenNthCalledWith(2, expect.objectContaining({ commentId: 'c2' }));
+    expect(superdoc.commentsStore.commentsList).toEqual([{ normalized: 'legacy-1' }, { normalized: 'c2' }]);
+    expect(superdoc.commentsStore.hasSyncedCollaborationComments).toBe(true);
+  });
+
+  it('initCollaborationComments re-hydrates store on repeated init without duplicating listeners', () => {
+    commentsArray.items = [new MockYMap(Object.entries({ commentId: 'c1', text: 'first' }))];
+
+    initCollaborationComments(superdoc);
+    expect(commentsArray._observers.size).toBe(1);
+    expect(superdoc.provider.on).toHaveBeenCalledTimes(1);
+    expect(superdoc.commentsStore.commentsList).toEqual([{ normalized: 'c1' }]);
+
+    // Simulate store reset after mount; second init should re-hydrate but not add listeners again.
+    superdoc.commentsStore.commentsList = [];
+    initCollaborationComments(superdoc);
+
+    expect(commentsArray._observers.size).toBe(1);
+    expect(superdoc.provider.on).toHaveBeenCalledTimes(1);
+    expect(superdoc.commentsStore.commentsList).toEqual([{ normalized: 'c1' }]);
+  });
+
   it('initCollaborationComments skips when module disabled', () => {
     superdoc.config.modules.comments = false;
     initCollaborationComments(superdoc);

packages/superdoc/src/core/collaboration/helpers.js

@@ -3,6 +3,51 @@ import useComment from '../../components/CommentsLayer/use-comment';
 
 import { addYComment, updateYComment, deleteYComment } from './collaboration-comments';
 
+/**
+ * Load comments from the ydoc into the comments store.
+ *
+ * @param {Object} superdoc The SuperDoc instance
+ * @returns {boolean} True if comments were loaded into the store
+ */
+export const loadCommentsFromYdoc = (superdoc) => {
+  if (!superdoc?.ydoc || !superdoc?.commentsStore) return false;
+  const commentsArray = superdoc.ydoc.getArray('comments');
+  const comments = commentsArray.toJSON();
+  const seenCommentIdByKey = new Map();
+  const filtered = [];
+  comments.forEach((c) => {
+    const key = c?.importedId ?? c?.commentId;
+    if (!key) return;
+    if (seenCommentIdByKey.has(key)) {
+      const existingCommentId = seenCommentIdByKey.get(key);
+      const currentCommentId = c?.commentId;
+
+      if (existingCommentId && currentCommentId && existingCommentId !== currentCommentId) {
+        console.warn(
+          `[SuperDoc] Duplicate collaboration comment key "${key}" detected with conflicting commentId values. Keeping first entry and dropping duplicate.`,
+          {
+            key,
+            keptCommentId: existingCommentId,
+            droppedCommentId: currentCommentId,
+          },
+        );
+      }
+      return;
+    }
+    seenCommentIdByKey.set(key, c?.commentId);
+    if (!c?.commentId) {
+      filtered.push({ ...c, commentId: key });
+      return;
+    }
+    filtered.push(c);
+  });
+  superdoc.commentsStore.commentsList = filtered.map((c) => useComment(c));
+  if (superdoc.provider?.synced) {
+    superdoc.commentsStore.hasSyncedCollaborationComments = true;
+  }
+  return true;
+};
+
 /**
  * Initialize sync for comments if the module is enabled
  *
@@ -11,44 +56,51 @@ import { addYComment, updateYComment, deleteYComment } from './collaboration-com
  */
 export const initCollaborationComments = (superdoc) => {
   if (!superdoc.config.modules.comments || !superdoc.provider) return;
+  if (superdoc._commentsCollabInitialized) {
+    loadCommentsFromYdoc(superdoc);
+    return;
+  }
+  superdoc._commentsCollabInitialized = true;
 
   // If we have comments and collaboration, wait for sync and then let the store know when its ready
+  const commentsArray = superdoc.ydoc.getArray('comments');
+  const updateCommentsStore = () => loadCommentsFromYdoc(superdoc);
+
   const onSuperDocYdocSynced = () => {
+    if (!updateCommentsStore()) {
+      setTimeout(updateCommentsStore, 0);
+    }
     // Update the editor comment locations
-    const parent = superdoc.commentsStore.commentsParentElement;
-    const ids = superdoc.commentsStore.editorCommentIds;
-    superdoc.commentsStore.handleEditorLocationsUpdate(parent, ids);
-    superdoc.commentsStore.hasSyncedCollaborationComments = true;
+    if (superdoc.commentsStore) {
+      const parent = superdoc.commentsStore.commentsParentElement;
+      const ids = superdoc.commentsStore.editorCommentIds;
+      superdoc.commentsStore.handleEditorLocationsUpdate(parent, ids);
+      superdoc.commentsStore.hasSyncedCollaborationComments = true;
+    }
 
     superdoc.provider.off('synced', onSuperDocYdocSynced);
   };
 
   // Listen for the synced event
   superdoc.provider.on('synced', onSuperDocYdocSynced);
 
-  // Get the comments map from the Y.Doc
-  const commentsArray = superdoc.ydoc.getArray('comments');
+  // Load any existing comments immediately (in case provider synced before we subscribed)
+  if (!updateCommentsStore()) {
+    setTimeout(updateCommentsStore, 0);
+  }
 
   // Observe changes to the comments map
   commentsArray.observe((event) => {
+    if (!superdoc.commentsStore) return;
     // Ignore events if triggered by the current user
     const currentUser = superdoc.config.user;
-    const { user = {} } = event.transaction.origin;
+    const origin = event?.transaction?.origin;
+    const { user = {} } = origin || {};
 
     if (currentUser.name === user.name && currentUser.email === user.email) return;
 
     // Update conversations
-    const comments = commentsArray.toJSON();
-
-    const seen = new Set();
-    const filtered = [];
-    comments.forEach((c) => {
-      if (!seen.has(c.commentId)) {
-        seen.add(c.commentId);
-        filtered.push(c);
-      }
-    });
-    superdoc.commentsStore.commentsList = filtered.map((c) => useComment(c));
+    updateCommentsStore();
   });
 };
 

packages/superdoc/src/stores/comments-store.js

@@ -635,6 +635,9 @@ export const useCommentsStore = defineStore('comments', () => {
   const deleteComment = ({ commentId: commentIdToDelete, superdoc }) => {
     const commentIndex = commentsList.value.findIndex((c) => c.commentId === commentIdToDelete);
     const comment = commentsList.value[commentIndex];
+    if (!comment) {
+      return;
+    }
     const { commentId, importedId } = comment;
     const { fileId } = comment;
 
@@ -821,6 +824,9 @@ export const useCommentsStore = defineStore('comments', () => {
    * @returns {void}
    */
   const handleEditorLocationsUpdate = (allCommentPositions) => {
+    if ((!allCommentPositions || Object.keys(allCommentPositions).length === 0) && commentsList.value.length > 0) {
+      return;
+    }
     editorCommentPositions.value = allCommentPositions || {};
   };