fix(tracked-changes): undo/redo applies to both document and comment bubbles (#2437)

* feat(comments): enhance undo/redo functionality for tracked changes

- Added functionality to resync tracked-change threads during undo/redo transactions in SuperDoc.
- Updated the comments store to reopen resolved tracked change comments when updates occur, ensuring they remain actionable.
- Introduced tests to verify the correct behavior of tracked changes during undo/redo operations, maintaining sidebar bubble visibility and state consistency.

* feat(comments): implement event emission for deleted tracked-change comments

* feat(comments): enhance comment handling for tracked changes on import

* fix(comments-store): preserve tracked-change thread state during undo/redo operations

* test(comments-store): add unit tests for resolved TC pruning and snapshot restore

- Test that already-resolved tracked-change comments survive empty replay sync
  (the `if (comment.resolvedTime) return true` guard in pruneStaleTrackedChangeComments)
- Test that snapshot restore works end-to-end: undo reopens thread, redo restores
  resolved state from WeakMap snapshot instead of hard-deleting

* fix(comments-store): emit UPDATE event when snapshot restores resolved state

When redo re-resolves a thread via the WeakMap snapshot, collaborators
were never notified — undo broadcast "reopened" but redo silently
re-resolved. Now emits an UPDATE event after snapshot restore so
collab peers stay in sync.

---------

Co-authored-by: Caio Pizzol <caio@harbourshare.com>

Author: palmer-cl

packages/superdoc/src/SuperDoc.test.js

@@ -177,6 +177,7 @@ const buildCommentsStore = () => ({
   handleEditorLocationsUpdate: vi.fn(),
   clearEditorCommentPositions: vi.fn(),
   handleTrackedChangeUpdate: vi.fn(),
+  syncTrackedChangePositionsWithDocument: vi.fn(),
   syncTrackedChangeComments: vi.fn(),
   removePendingComment: vi.fn(),
   setActiveComment: vi.fn(),
@@ -519,6 +520,52 @@ describe('SuperDoc.vue', () => {
     expect(commentsStoreStub.syncTrackedChangeComments).not.toHaveBeenCalled();
   });
 
+  it('resyncs tracked-change threads on undo/redo transactions', async () => {
+    const superdocStub = createSuperdocStub();
+    const wrapper = await mountComponent(superdocStub);
+    await nextTick();
+
+    const options = wrapper.findComponent(SuperEditorStub).props('options');
+    const editorMock = { options: { documentId: 'doc-1' } };
+
+    const makeTransaction = (inputType) => ({
+      getMeta: vi.fn((key) => (key === 'inputType' ? inputType : undefined)),
+    });
+
+    options.onTransaction({
+      editor: editorMock,
+      transaction: makeTransaction('historyUndo'),
+      duration: 4,
+    });
+
+    expect(commentsStoreStub.syncTrackedChangePositionsWithDocument).toHaveBeenCalledWith({
+      documentId: 'doc-1',
+      editor: editorMock,
+    });
+    expect(commentsStoreStub.syncTrackedChangeComments).toHaveBeenCalledWith({
+      superdoc: superdocStub,
+      editor: editorMock,
+    });
+
+    commentsStoreStub.syncTrackedChangePositionsWithDocument.mockClear();
+    commentsStoreStub.syncTrackedChangeComments.mockClear();
+
+    options.onTransaction({
+      editor: editorMock,
+      transaction: makeTransaction('historyRedo'),
+      duration: 5,
+    });
+
+    expect(commentsStoreStub.syncTrackedChangePositionsWithDocument).toHaveBeenCalledWith({
+      documentId: 'doc-1',
+      editor: editorMock,
+    });
+    expect(commentsStoreStub.syncTrackedChangeComments).toHaveBeenCalledWith({
+      superdoc: superdocStub,
+      editor: editorMock,
+    });
+  });
+
   it('reconciles replay updates by importedId before commentId to avoid duplicate comments', async () => {
     const superdocStub = createSuperdocStub();
     const wrapper = await mountComponent(superdocStub);

packages/superdoc/src/SuperDoc.vue

@@ -996,6 +996,7 @@ const onEditorTransaction = (payload = {}) => {
   if (inputType === 'historyUndo' || inputType === 'historyRedo') {
     const documentId = editor?.options?.documentId;
     syncTrackedChangePositionsWithDocument({ documentId, editor });
+    syncTrackedChangeComments({ superdoc: proxy.$superdoc, editor });
   }
 
   emitEditorTransaction(buildEditorTransactionPayload(payload));

packages/superdoc/src/components/CommentsLayer/CommentDialog.test.js

@@ -182,6 +182,7 @@ const mountDialog = async ({ baseCommentOverrides = {}, extraComments = [], prop
         resolveComment: vi.fn(),
       },
     },
+    focus: vi.fn(),
     emit: vi.fn(),
   };
 
@@ -282,15 +283,19 @@ describe('CommentDialog.vue', () => {
 
     const header = wrapper.findComponent(CommentHeaderStub);
     header.vm.$emit('resolve');
+    await nextTick();
     expect(superdocStub.activeEditor.commands.acceptTrackedChangeById).toHaveBeenCalledWith(baseComment.commentId);
     expect(baseComment.resolveComment).toHaveBeenCalledWith({
       email: superdocStoreStub.user.email,
       name: superdocStoreStub.user.name,
       superdoc: expect.any(Object),
     });
+    expect(superdocStub.focus).toHaveBeenCalledTimes(1);
 
     header.vm.$emit('reject');
+    await nextTick();
     expect(superdocStub.activeEditor.commands.rejectTrackedChangeById).toHaveBeenCalledWith(baseComment.commentId);
+    expect(superdocStub.focus).toHaveBeenCalledTimes(2);
   });
 
   it('calls custom accept handler instead of default behavior when configured', async () => {

packages/superdoc/src/components/CommentsLayer/CommentDialog.vue

@@ -400,6 +400,7 @@ const handleReject = () => {
     commentsStore.lastUpdate = new Date();
     activeComment.value = null;
     commentsStore.setActiveComment(proxy.$superdoc, activeComment.value);
+    proxy.$superdoc.focus?.();
   });
 };
 
@@ -427,6 +428,7 @@ const handleResolve = () => {
     commentsStore.lastUpdate = new Date();
     activeComment.value = null;
     commentsStore.setActiveComment(proxy.$superdoc, activeComment.value);
+    proxy.$superdoc.focus?.();
   });
 };
 

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

@@ -29,6 +29,7 @@ export const useCommentsStore = defineStore('comments', () => {
 
   const isDebugging = false;
   const debounceTimers = {};
+  const trackedChangeResolutionSnapshots = new WeakMap();
 
   const COMMENT_EVENTS = comments_module_events;
   const hasInitializedComments = ref(false);
@@ -188,12 +189,26 @@ export const useCommentsStore = defineStore('comments', () => {
 
   const clearResolvedMetadata = (comment) => {
     if (!comment) return;
+    if (
+      comment.resolvedTime !== undefined ||
+      comment.resolvedByEmail !== undefined ||
+      comment.resolvedByName !== undefined
+    ) {
+      trackedChangeResolutionSnapshots.set(comment, {
+        resolvedTime: comment.resolvedTime ?? null,
+        resolvedByEmail: comment.resolvedByEmail ?? null,
+        resolvedByName: comment.resolvedByName ?? null,
+      });
+    }
     // Sets the resolved state to null so it can be restored in the comments sidebar
     comment.resolvedTime = null;
     comment.resolvedByEmail = null;
     comment.resolvedByName = null;
   };
 
+  const getCommentEventPayload = (comment) =>
+    typeof comment?.getValues === 'function' ? comment.getValues() : { ...comment };
+
   /**
    * Check if a comment originated from the super-editor (or has no explicit source).
    * Comments without a source are assumed to be editor-backed for backward compatibility.
@@ -512,6 +527,10 @@ export const useCommentsStore = defineStore('comments', () => {
     if (event === 'add') {
       const existing = findTrackedChangeById();
       if (existing) {
+        // Undo/redo after accept/reject can rematerialize a previously resolved
+        // tracked change. Reopen the thread so the bubble is actionable again.
+        if (existing.resolvedTime) clearResolvedMetadata(existing);
+
         // Already exists (e.g. created during batch import) — update instead of duplicating
         // Partial resolution can turn a replacement into insert-only/delete-only, so
         // clear fields explicitly when the updated payload no longer includes them.
@@ -533,6 +552,7 @@ export const useCommentsStore = defineStore('comments', () => {
       // If we have an update event, simply update the composable comment
       const existingTrackedChange = findTrackedChangeById();
       if (!existingTrackedChange) return;
+      if (existingTrackedChange.resolvedTime) clearResolvedMetadata(existingTrackedChange);
 
       // Partial resolution can turn a replacement into insert-only/delete-only, so
       // clear fields explicitly when the updated payload no longer includes them.
@@ -960,21 +980,31 @@ export const useCommentsStore = defineStore('comments', () => {
     }, 0);
   };
 
-  const createCommentForTrackChanges = (editor, superdoc, trackedChangesOverride = null) => {
+  const createCommentForTrackChanges = (editor, superdoc, trackedChangesOverride = null, options = {}) => {
+    const { reopenResolved = false } = options;
     const trackedChanges = trackedChangesOverride ?? trackChangesHelpers.getTrackChanges(editor.state);
     const groupedChanges = groupChanges(trackedChanges);
     const activeDocumentId = editor?.options?.documentId != null ? String(editor.options.documentId) : null;
     if (!activeDocumentId) return;
 
-    // Build a Set of existing tracked-change IDs for O(1) lookup.
+    // Build a Set of existing unresolved tracked-change IDs for O(1) lookup.
     // Include both runtime and imported IDs to avoid duplicate threads when
     // replay/import flows remap commentId but marks still reference importedId.
-    const existingIds = new Set();
+    // History replay can opt in to excluding resolved tracked-change threads so
+    // undo/redo reopens them when their marks reappear. Initial import rebuilds
+    // keep resolved IDs in the set so resolved DOCX threads do not reopen on load.
+    const skipIds = new Set();
     commentsList.value.forEach((comment) => {
       if (!comment?.trackedChange) return;
       if (!belongsToDocument(comment, activeDocumentId)) return;
-      if (comment.commentId != null) existingIds.add(String(comment.commentId));
-      if (comment.importedId != null) existingIds.add(String(comment.importedId));
+      if (comment.resolvedTime && !reopenResolved) {
+        if (comment.commentId != null) skipIds.add(String(comment.commentId));
+        if (comment.importedId != null) skipIds.add(String(comment.importedId));
+        return;
+      }
+      if (comment.resolvedTime) return;
+      if (comment.commentId != null) skipIds.add(String(comment.commentId));
+      if (comment.importedId != null) skipIds.add(String(comment.importedId));
     });
 
     // Build a Map of change ID → tracked change entries for O(1) lookup per group.
@@ -991,7 +1021,7 @@ export const useCommentsStore = defineStore('comments', () => {
     // Build comment params directly from grouped changes — no PM dispatch needed
     groupedChanges.forEach(({ insertedMark, deletionMark, formatMark }) => {
       const id = insertedMark?.mark.attrs.id || deletionMark?.mark.attrs.id || formatMark?.mark.attrs.id;
-      if (!id || existingIds.has(id)) return;
+      if (!id || skipIds.has(id)) return;
 
       const marks = {
         ...(insertedMark && { insertedMark: insertedMark.mark }),
@@ -1012,9 +1042,9 @@ export const useCommentsStore = defineStore('comments', () => {
 
       if (params) {
         handleTrackedChangeUpdate({ superdoc, params });
-        existingIds.add(String(id));
-        if (params.changeId != null) existingIds.add(String(params.changeId));
-        if (params.importedId != null) existingIds.add(String(params.importedId));
+        skipIds.add(String(id));
+        if (params.changeId != null) skipIds.add(String(params.changeId));
+        if (params.importedId != null) skipIds.add(String(params.importedId));
       }
     });
 
@@ -1062,10 +1092,11 @@ export const useCommentsStore = defineStore('comments', () => {
    * @param {string | null} activeDocumentId Document currently being synced.
    * @returns {void}
    */
-  const pruneStaleTrackedChangeComments = (liveTrackedChangeIds, activeDocumentId) => {
+  const pruneStaleTrackedChangeComments = (liveTrackedChangeIds, activeDocumentId, superdoc = null) => {
     if (!(liveTrackedChangeIds instanceof Set) || !activeDocumentId) return;
 
     const removedIds = new Set();
+    const restoredComments = [];
     const previousComments = [...commentsList.value];
 
     commentsList.value = commentsList.value.filter((comment) => {
@@ -1078,12 +1109,32 @@ export const useCommentsStore = defineStore('comments', () => {
       const hasLiveImportedId = Boolean(importedId && liveTrackedChangeIds.has(importedId));
 
       if ((!commentId && !importedId) || hasLiveCommentId || hasLiveImportedId) return true;
+      if (comment.resolvedTime) return true;
+
+      const resolutionSnapshot = trackedChangeResolutionSnapshots.get(comment);
+      if (resolutionSnapshot) {
+        comment.resolvedTime = resolutionSnapshot.resolvedTime ?? Date.now();
+        comment.resolvedByEmail = resolutionSnapshot.resolvedByEmail ?? null;
+        comment.resolvedByName = resolutionSnapshot.resolvedByName ?? null;
+        restoredComments.push(comment);
+        return true;
+      }
 
       if (commentId) removedIds.add(commentId);
       if (importedId) removedIds.add(importedId);
       return false;
     });
 
+    restoredComments.forEach((comment) => {
+      const payload = getCommentEventPayload(comment);
+      const event = {
+        type: COMMENT_EVENTS.UPDATE,
+        comment: payload,
+      };
+      syncCommentsToClients(superdoc, event);
+      superdoc?.emit?.('comments-update', event);
+    });
+
     if (!removedIds.size) return;
 
     let didRemoveDescendants = true;
@@ -1110,6 +1161,24 @@ export const useCommentsStore = defineStore('comments', () => {
       });
     }
 
+    const removedComments = previousComments.filter((comment) => {
+      if (!belongsToDocument(comment, activeDocumentId)) return false;
+      const commentId = comment.commentId != null ? String(comment.commentId) : null;
+      const importedId = comment.importedId != null ? String(comment.importedId) : null;
+      return (commentId && removedIds.has(commentId)) || (importedId && removedIds.has(importedId));
+    });
+
+    removedComments.forEach((comment) => {
+      const payload = getCommentEventPayload(comment);
+      const event = {
+        type: COMMENT_EVENTS.DELETED,
+        comment: payload,
+        changes: [{ key: 'deleted', commentId: payload.commentId, fileId: payload.fileId }],
+      };
+      syncCommentsToClients(superdoc, event);
+      superdoc?.emit?.('comments-update', event);
+    });
+
     const activeCommentId = activeComment.value != null ? String(activeComment.value) : null;
     const activeCommentBelongsToActiveDocument = previousComments.some((comment) => {
       const commentId = comment.commentId != null ? String(comment.commentId) : null;
@@ -1148,8 +1217,8 @@ export const useCommentsStore = defineStore('comments', () => {
       liveTrackedChangeIds.add(String(id));
     });
 
-    pruneStaleTrackedChangeComments(liveTrackedChangeIds, activeDocumentId);
-    createCommentForTrackChanges(editor, superdoc, trackedChanges);
+    pruneStaleTrackedChangeComments(liveTrackedChangeIds, activeDocumentId, superdoc);
+    createCommentForTrackChanges(editor, superdoc, trackedChanges, { reopenResolved: true });
   };
 
   const normalizeDocxSchemaForExport = (value) => {