docx-diff-editor 1.0.60 → 1.0.62

package/dist/index.mjs

@@ -822,17 +822,6 @@ async function parseHtmlToJson(html, SuperDoc) {
         }
       }, TIMEOUTS.CLEANUP_DELAY);
     };
-    const createMockPasteEvent = (htmlContent) => {
-      const dataTransfer = new DataTransfer();
-      dataTransfer.setData("text/html", htmlContent);
-      dataTransfer.setData("text/plain", "");
-      const event = new ClipboardEvent("paste", {
-        bubbles: true,
-        cancelable: true,
-        clipboardData: dataTransfer
-      });
-      return event;
-    };
     const tryPasteApproach = (sd, onSuccess, onFail) => {
       try {
         const editor = sd?.activeEditor;
@@ -986,6 +975,16 @@ function syncNumberingToParent(childEditor, parentEditor) {
     console.warn("[syncNumberingToParent] Failed to sync numbering definitions:", err);
   }
 }
+function createMockPasteEvent(htmlContent) {
+  const dataTransfer = new DataTransfer();
+  dataTransfer.setData("text/html", htmlContent);
+  dataTransfer.setData("text/plain", "");
+  return new ClipboardEvent("paste", {
+    bubbles: true,
+    cancelable: true,
+    clipboardData: dataTransfer
+  });
+}
 async function parseHtmlWithLinkedEditor(html, mainEditor) {
   const container = document.createElement("div");
   container.style.cssText = "position:absolute;top:-9999px;left:-9999px;width:800px;height:600px;visibility:hidden;";
@@ -1007,17 +1006,26 @@ async function parseHtmlWithLinkedEditor(html, mainEditor) {
         }
       }, TIMEOUTS.CLEANUP_DELAY);
     };
-    try {
-      mainEditor.createChildEditor({
-        element: container,
-        html,
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        onCreate: ({ editor: localEditor }) => {
+    const pasteAndExtract = (editor) => {
+      try {
+        if (!editor?.view?.pasteHTML) {
+          throw new Error("pasteHTML not available on child editor");
+        }
+        editor.commands?.focus?.();
+        if (editor.commands?.selectAll && editor.commands?.deleteSelection) {
+          editor.commands.selectAll();
+          editor.commands.deleteSelection();
+        }
+        const mockEvent = createMockPasteEvent(html);
+        editor.view.pasteHTML(html, mockEvent);
+        setTimeout(() => {
           if (resolved) return;
           try {
-            childEditor = localEditor;
-            syncNumberingToParent(localEditor, mainEditor);
-            const json = localEditor.getJSON();
+            syncNumberingToParent(editor, mainEditor);
+            const json = editor.getJSON();
+            if (!json?.content?.length) {
+              throw new Error("Paste produced empty document");
+            }
             const normalizedJson = normalizeRunProperties(json);
             resolved = true;
             cleanup();
@@ -1027,6 +1035,23 @@ async function parseHtmlWithLinkedEditor(html, mainEditor) {
             cleanup();
             reject(err);
           }
+        }, 100);
+      } catch (err) {
+        resolved = true;
+        cleanup();
+        reject(err);
+      }
+    };
+    try {
+      mainEditor.createChildEditor({
+        element: container,
+        html: "<p></p>",
+        // Minimal empty document - actual HTML pasted via pasteHTML
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        onCreate: ({ editor: localEditor }) => {
+          if (resolved) return;
+          childEditor = localEditor;
+          pasteAndExtract(localEditor);
         },
         onError: (error) => {
           if (resolved) return;
@@ -1751,410 +1776,175 @@ function alignListItems(listA, listB, listPathA, listPathB) {
   }
   return alignNodes(itemsA, itemsB);
 }
-function cloneNode(node) {
-  return JSON.parse(JSON.stringify(node));
+
+// src/services/attrComparer.ts
+var KNOWN_DEFAULTS = {
+  paragraph: {
+    textAlign: "left",
+    indent: 0,
+    lineSpacing: 1
+  },
+  heading: {
+    level: 1,
+    textAlign: "left"
+  },
+  table: {
+    alignment: "left",
+    borderStyle: "single"
+  },
+  tableCell: {
+    verticalAlign: "top",
+    colspan: 1,
+    rowspan: 1
+  },
+  listItem: {
+    indent: 0
+  },
+  image: {
+    width: "auto",
+    height: "auto"
+  }
+};
+var IGNORED_ATTRS = /* @__PURE__ */ new Set([
+  "id",
+  "class",
+  "data-id",
+  "data-pm-slice",
+  "__trackAttrChanges"
+]);
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && Object.prototype.toString.call(value) === "[object Object]";
 }
-function getMarkSpansForRange(spansB, start, end) {
-  const result = [];
-  for (const span of spansB) {
-    if (span.to > start && span.from < end) {
-      const overlapStart = Math.max(span.from, start);
-      const overlapEnd = Math.min(span.to, end);
-      result.push({
-        relStart: overlapStart - start,
-        relEnd: overlapEnd - start,
-        marks: span.marks || []
+function deepEqual2(a, b) {
+  if (a === b) return true;
+  if (typeof a !== typeof b) return false;
+  if (a === null || b === null) return a === b;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) return false;
+    return a.every((val, i) => deepEqual2(val, b[i]));
+  }
+  if (isPlainObject(a) && isPlainObject(b)) {
+    const keysA = Object.keys(a);
+    const keysB = Object.keys(b);
+    if (keysA.length !== keysB.length) return false;
+    return keysA.every((key) => deepEqual2(a[key], b[key]));
+  }
+  return false;
+}
+function normalizeValue(value, key, nodeType) {
+  if (value !== void 0 && value !== null) {
+    return value;
+  }
+  const defaults = KNOWN_DEFAULTS[nodeType];
+  if (defaults && key in defaults) {
+    return defaults[key];
+  }
+  return value;
+}
+function compareAttrs(attrsA, attrsB, nodeType = "", prefix = "") {
+  const diffs = [];
+  const a = attrsA || {};
+  const b = attrsB || {};
+  const allKeys = /* @__PURE__ */ new Set([...Object.keys(a), ...Object.keys(b)]);
+  for (const key of allKeys) {
+    if (IGNORED_ATTRS.has(key)) continue;
+    const fullKey = prefix ? `${prefix}.${key}` : key;
+    const valueA = normalizeValue(a[key], key, nodeType);
+    const valueB = normalizeValue(b[key], key, nodeType);
+    if (isPlainObject(valueA) && isPlainObject(valueB)) {
+      const nestedDiffs = compareAttrs(
+        valueA,
+        valueB,
+        nodeType,
+        fullKey
+      );
+      diffs.push(...nestedDiffs);
+      continue;
+    }
+    if (!deepEqual2(valueA, valueB)) {
+      diffs.push({
+        key: fullKey,
+        before: valueA,
+        after: valueB
       });
     }
   }
-  return result;
+  return diffs;
 }
-function createInsertedTextNodes(text, posB, spansB, author, replacementId) {
-  const result = [];
-  const trackMark = createTrackInsertMark(author, replacementId);
-  if (posB === void 0 || spansB.length === 0) {
-    return [{
-      type: "text",
-      text,
-      marks: [trackMark]
-    }];
-  }
-  const markSpans = getMarkSpansForRange(spansB, posB, posB + text.length);
-  if (markSpans.length === 0) {
-    return [{
-      type: "text",
-      text,
-      marks: [trackMark]
-    }];
+function compareNodeAttrs(nodeA, nodeB) {
+  const nodeType = nodeA.type || nodeB.type || "";
+  return compareAttrs(nodeA.attrs, nodeB.attrs, nodeType);
+}
+
+// src/services/tableBlockDiffer.ts
+function detectColumnChanges(matchedRows, tableA, tableB, tablePathA, tablePathB) {
+  const changes = [];
+  if (matchedRows.length === 0) return changes;
+  const firstMatch = matchedRows[0];
+  const rowIdxA = firstMatch.pathA[firstMatch.pathA.length - 1];
+  const rowIdxB = firstMatch.pathB[firstMatch.pathB.length - 1];
+  const rowA = tableA.content?.[rowIdxA];
+  const rowB = tableB.content?.[rowIdxB];
+  if (!rowA || !rowB) return changes;
+  const cellCountA = rowA.content?.length || 0;
+  const cellCountB = rowB.content?.length || 0;
+  const diff = cellCountB - cellCountA;
+  if (diff === 0) return changes;
+  let consistent = true;
+  for (const match of matchedRows) {
+    const idxA = match.pathA[match.pathA.length - 1];
+    const idxB = match.pathB[match.pathB.length - 1];
+    const rA = tableA.content?.[idxA];
+    const rB = tableB.content?.[idxB];
+    if (!rA || !rB) continue;
+    const countA = rA.content?.length || 0;
+    const countB = rB.content?.length || 0;
+    if (countB - countA !== diff) {
+      consistent = false;
+      break;
+    }
   }
-  markSpans.sort((a, b) => a.relStart - b.relStart);
-  let processedUpTo = 0;
-  for (const span of markSpans) {
-    if (span.relStart > processedUpTo) {
-      result.push({
-        type: "text",
-        text: text.substring(processedUpTo, span.relStart),
-        marks: [trackMark]
+  if (!consistent) return changes;
+  if (diff > 0) {
+    for (let i = 0; i < diff; i++) {
+      changes.push({
+        id: v4(),
+        type: "columnInsert",
+        nodeType: "tableColumn",
+        path: [...tablePathB],
+        node: { type: "column", position: cellCountA + i }
       });
     }
-    if (span.relEnd > span.relStart) {
-      const spanText = text.substring(span.relStart, span.relEnd);
-      const normalizedSpanMarks = normalizeMarksForRendering(span.marks);
-      const marks = [...normalizedSpanMarks, trackMark];
-      result.push({
-        type: "text",
-        text: spanText,
-        marks
+  } else {
+    for (let i = 0; i < Math.abs(diff); i++) {
+      changes.push({
+        id: v4(),
+        type: "columnDelete",
+        nodeType: "tableColumn",
+        path: [...tablePathA],
+        node: { type: "column", position: cellCountB + i }
       });
-      processedUpTo = span.relEnd;
     }
   }
-  if (processedUpTo < text.length) {
-    result.push({
-      type: "text",
-      text: text.substring(processedUpTo),
-      marks: [trackMark]
-    });
-  }
-  return result;
+  return changes;
 }
-function mergeDocuments(docA, docB, diffResult, author = DEFAULT_AUTHOR) {
-  const merged = cloneNode(docA);
-  const charStates = [];
-  let insertions = [];
-  const formatChanges = diffResult.formatChanges || [];
-  function getFormatChangeAt(pos) {
-    for (const fc of formatChanges) {
-      if (pos >= fc.from && pos < fc.to) {
-        return fc;
-      }
-    }
-    return null;
-  }
-  let docAOffset = 0;
-  const segments = diffResult.segments;
-  for (let segIdx = 0; segIdx < segments.length; segIdx++) {
-    const segment = segments[segIdx];
-    if (segment.type === "equal") {
-      for (let i = 0; i < segment.text.length; i++) {
-        charStates[docAOffset + i] = { type: "equal" };
-      }
-      docAOffset += segment.text.length;
-    } else if (segment.type === "delete") {
-      const nextSegment = segments[segIdx + 1];
-      const isReplacement = nextSegment && nextSegment.type === "insert";
-      const replacementId = isReplacement ? v4() : void 0;
-      for (let i = 0; i < segment.text.length; i++) {
-        charStates[docAOffset + i] = { type: "delete", replacementId };
-      }
-      docAOffset += segment.text.length;
-      if (isReplacement && nextSegment) {
-        insertions.push({
-          afterOffset: docAOffset,
-          text: nextSegment.text,
-          replacementId,
-          posB: nextSegment.posB
-          // Capture docB position for mark lookup
-        });
-        segIdx++;
-      }
-    } else if (segment.type === "insert") {
-      insertions.push({
-        afterOffset: docAOffset,
-        text: segment.text,
-        posB: segment.posB
-        // Capture docB position for mark lookup
-      });
-    }
-  }
-  const spansB = diffResult.spansB || [];
-  function transformNode(node, nodeOffset, path) {
-    if (node.type === "text" && node.text) {
-      const text = node.text;
-      const result = [];
-      let i = 0;
-      while (i < text.length) {
-        const charOffset = nodeOffset + i;
-        const charState = charStates[charOffset] || { type: "equal" };
-        const insertionsHere = insertions.filter((ins) => ins.afterOffset === charOffset);
-        for (const ins of insertionsHere) {
-          const insertedNodes = createInsertedTextNodes(
-            ins.text,
-            ins.posB,
-            spansB,
-            author,
-            ins.replacementId
-          );
-          result.push(...insertedNodes);
-        }
-        const currentFormatChange = getFormatChangeAt(nodeOffset + i);
-        let j = i + 1;
-        while (j < text.length) {
-          const nextState = charStates[nodeOffset + j] || { type: "equal" };
-          if (nextState.type !== charState.type) break;
-          if (insertions.some((ins) => ins.afterOffset === nodeOffset + j)) break;
-          const nextFormatChange = getFormatChangeAt(nodeOffset + j);
-          if (currentFormatChange !== nextFormatChange) break;
-          j++;
-        }
-        const chunk = text.substring(i, j);
-        let marks = [...node.marks || []];
-        if (charState.type === "delete") {
-          marks.push(createTrackDeleteMark(author, charState.replacementId));
-        } else if (charState.type === "equal") {
-          if (currentFormatChange) {
-            const trackFormatMark = createTrackFormatMark(
-              currentFormatChange.before,
-              currentFormatChange.after,
-              author
-            );
-            const normalizedAfterMarks = normalizeMarksForRendering(currentFormatChange.after);
-            marks = [...normalizedAfterMarks, trackFormatMark];
-          }
-        }
-        result.push({
-          type: "text",
-          text: chunk,
-          marks: marks.length > 0 ? marks : void 0
-        });
-        i = j;
-      }
-      const endOffset = nodeOffset + text.length;
-      const endInsertions = insertions.filter((ins) => ins.afterOffset === endOffset);
-      for (const ins of endInsertions) {
-        const insertedNodes = createInsertedTextNodes(
-          ins.text,
-          ins.posB,
-          spansB,
-          author,
-          ins.replacementId
-        );
-        result.push(...insertedNodes);
-      }
-      insertions = insertions.filter(
-        (ins) => ins.afterOffset < nodeOffset || ins.afterOffset > endOffset
-      );
-      return { nodes: result, consumedLength: text.length };
-    }
-    if (node.content && Array.isArray(node.content)) {
-      const newContent = [];
-      let offset = nodeOffset;
-      for (const child of node.content) {
-        const { nodes, consumedLength } = transformNode(child, offset);
-        newContent.push(...nodes);
-        offset += consumedLength;
-      }
-      return {
-        nodes: [{ ...node, content: newContent }],
-        consumedLength: offset - nodeOffset
-      };
-    }
-    return { nodes: [node], consumedLength: 0 };
-  }
-  if (merged.content && Array.isArray(merged.content)) {
-    const newContent = [];
-    let offset = 0;
-    for (let i = 0; i < merged.content.length; i++) {
-      const child = merged.content[i];
-      const { nodes, consumedLength } = transformNode(child, offset);
-      newContent.push(...nodes);
-      offset += consumedLength;
-    }
-    merged.content = newContent;
-  }
-  if (insertions.length > 0) {
-    for (const ins of insertions) {
-      const insertedNodes = createInsertedTextNodes(
-        ins.text,
-        ins.posB,
-        spansB,
-        author,
-        ins.replacementId
-      );
-      const insertNode = {
-        type: "paragraph",
-        content: [
-          {
-            type: "run",
-            content: insertedNodes
-          }
-        ]
-      };
-      if (!merged.content) merged.content = [];
-      merged.content.push(insertNode);
-    }
-  }
-  return merged;
-}
-
-// src/services/attrComparer.ts
-var KNOWN_DEFAULTS = {
-  paragraph: {
-    textAlign: "left",
-    indent: 0,
-    lineSpacing: 1
-  },
-  heading: {
-    level: 1,
-    textAlign: "left"
-  },
-  table: {
-    alignment: "left",
-    borderStyle: "single"
-  },
-  tableCell: {
-    verticalAlign: "top",
-    colspan: 1,
-    rowspan: 1
-  },
-  listItem: {
-    indent: 0
-  },
-  image: {
-    width: "auto",
-    height: "auto"
-  }
-};
-var IGNORED_ATTRS = /* @__PURE__ */ new Set([
-  "id",
-  "class",
-  "data-id",
-  "data-pm-slice",
-  "__trackAttrChanges"
-]);
-function isPlainObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value) && Object.prototype.toString.call(value) === "[object Object]";
-}
-function deepEqual2(a, b) {
-  if (a === b) return true;
-  if (typeof a !== typeof b) return false;
-  if (a === null || b === null) return a === b;
-  if (Array.isArray(a) && Array.isArray(b)) {
-    if (a.length !== b.length) return false;
-    return a.every((val, i) => deepEqual2(val, b[i]));
-  }
-  if (isPlainObject(a) && isPlainObject(b)) {
-    const keysA = Object.keys(a);
-    const keysB = Object.keys(b);
-    if (keysA.length !== keysB.length) return false;
-    return keysA.every((key) => deepEqual2(a[key], b[key]));
-  }
-  return false;
-}
-function normalizeValue(value, key, nodeType) {
-  if (value !== void 0 && value !== null) {
-    return value;
-  }
-  const defaults = KNOWN_DEFAULTS[nodeType];
-  if (defaults && key in defaults) {
-    return defaults[key];
-  }
-  return value;
-}
-function compareAttrs(attrsA, attrsB, nodeType = "", prefix = "") {
-  const diffs = [];
-  const a = attrsA || {};
-  const b = attrsB || {};
-  const allKeys = /* @__PURE__ */ new Set([...Object.keys(a), ...Object.keys(b)]);
-  for (const key of allKeys) {
-    if (IGNORED_ATTRS.has(key)) continue;
-    const fullKey = prefix ? `${prefix}.${key}` : key;
-    const valueA = normalizeValue(a[key], key, nodeType);
-    const valueB = normalizeValue(b[key], key, nodeType);
-    if (isPlainObject(valueA) && isPlainObject(valueB)) {
-      const nestedDiffs = compareAttrs(
-        valueA,
-        valueB,
-        nodeType,
-        fullKey
-      );
-      diffs.push(...nestedDiffs);
-      continue;
-    }
-    if (!deepEqual2(valueA, valueB)) {
-      diffs.push({
-        key: fullKey,
-        before: valueA,
-        after: valueB
-      });
-    }
-  }
-  return diffs;
-}
-function compareNodeAttrs(nodeA, nodeB) {
-  const nodeType = nodeA.type || nodeB.type || "";
-  return compareAttrs(nodeA.attrs, nodeB.attrs, nodeType);
-}
-
-// src/services/tableBlockDiffer.ts
-function detectColumnChanges(matchedRows, tableA, tableB, tablePathA, tablePathB) {
-  const changes = [];
-  if (matchedRows.length === 0) return changes;
-  const firstMatch = matchedRows[0];
-  const rowIdxA = firstMatch.pathA[firstMatch.pathA.length - 1];
-  const rowIdxB = firstMatch.pathB[firstMatch.pathB.length - 1];
-  const rowA = tableA.content?.[rowIdxA];
-  const rowB = tableB.content?.[rowIdxB];
-  if (!rowA || !rowB) return changes;
-  const cellCountA = rowA.content?.length || 0;
-  const cellCountB = rowB.content?.length || 0;
-  const diff = cellCountB - cellCountA;
-  if (diff === 0) return changes;
-  let consistent = true;
-  for (const match of matchedRows) {
-    const idxA = match.pathA[match.pathA.length - 1];
-    const idxB = match.pathB[match.pathB.length - 1];
-    const rA = tableA.content?.[idxA];
-    const rB = tableB.content?.[idxB];
-    if (!rA || !rB) continue;
-    const countA = rA.content?.length || 0;
-    const countB = rB.content?.length || 0;
-    if (countB - countA !== diff) {
-      consistent = false;
-      break;
-    }
-  }
-  if (!consistent) return changes;
-  if (diff > 0) {
-    for (let i = 0; i < diff; i++) {
-      changes.push({
-        id: v4(),
-        type: "columnInsert",
-        nodeType: "tableColumn",
-        path: [...tablePathB],
-        node: { type: "column", position: cellCountA + i }
-      });
-    }
-  } else {
-    for (let i = 0; i < Math.abs(diff); i++) {
-      changes.push({
-        id: v4(),
-        type: "columnDelete",
-        nodeType: "tableColumn",
-        path: [...tablePathA],
-        node: { type: "column", position: cellCountB + i }
-      });
-    }
-  }
-  return changes;
-}
-function diffTables(tableA, tableB, tablePathA, tablePathB) {
-  const result = {
-    rowChanges: [],
-    columnChanges: [],
-    cellMatches: [],
-    tableAttrChanges: null,
-    cellAttrChanges: []
-  };
-  const tableAttrDiffs = compareNodeAttrs(tableA, tableB);
-  if (tableAttrDiffs.length > 0) {
-    result.tableAttrChanges = {
-      id: v4(),
-      nodeType: "table",
-      pathA: tablePathA,
-      pathB: tablePathB,
-      changes: tableAttrDiffs
-    };
+function diffTables(tableA, tableB, tablePathA, tablePathB) {
+  const result = {
+    rowChanges: [],
+    columnChanges: [],
+    cellMatches: [],
+    tableAttrChanges: null,
+    cellAttrChanges: []
+  };
+  const tableAttrDiffs = compareNodeAttrs(tableA, tableB);
+  if (tableAttrDiffs.length > 0) {
+    result.tableAttrChanges = {
+      id: v4(),
+      nodeType: "table",
+      pathA: tablePathA,
+      pathB: tablePathB,
+      changes: tableAttrDiffs
+    };
   }
   const rowAlignment = alignTableRows(tableA, tableB, tablePathA, tablePathB);
   for (const inserted of rowAlignment.insertions) {
@@ -2213,290 +2003,777 @@ function diffTables(tableA, tableB, tablePathA, tablePathB) {
       }
     }
   }
-  return result;
-}
-function isTable(node) {
-  return node?.type === "table";
-}
-function isTableRow(node) {
-  return node?.type === "tableRow";
-}
-function getRowLocation(tablePath, rowIndex, tableIndex) {
-  return `Table ${tableIndex + 1}, Row ${rowIndex + 1}`;
-}
-function getRowPreview(row, maxLength = 50) {
-  const cells = [];
-  for (const cell of row.content || []) {
-    const cellText = extractCellText(cell);
-    if (cellText) {
-      cells.push(cellText);
+  return result;
+}
+function isTable(node) {
+  return node?.type === "table";
+}
+function isTableRow(node) {
+  return node?.type === "tableRow";
+}
+function getRowLocation(tablePath, rowIndex, tableIndex) {
+  return `Table ${tableIndex + 1}, Row ${rowIndex + 1}`;
+}
+function getRowPreview(row, maxLength = 50) {
+  const cells = [];
+  for (const cell of row.content || []) {
+    const cellText = extractCellText(cell);
+    if (cellText) {
+      cells.push(cellText);
+    }
+  }
+  const preview = cells.join(" | ");
+  if (preview.length > maxLength) {
+    return preview.substring(0, maxLength - 3) + "...";
+  }
+  return preview;
+}
+function extractCellText(cell) {
+  if (!cell.content) return "";
+  const texts = [];
+  for (const child of cell.content) {
+    if (child.type === "text") {
+      texts.push(child.text || "");
+    } else if (child.type === "paragraph" && child.content) {
+      for (const pChild of child.content) {
+        if (pChild.type === "text") {
+          texts.push(pChild.text || "");
+        }
+      }
+    }
+  }
+  return texts.join("").trim();
+}
+function isList(node) {
+  return node?.type === "bulletList" || node?.type === "orderedList";
+}
+function isListItem(node) {
+  return node?.type === "listItem";
+}
+function extractListItemText(item) {
+  const texts = [];
+  function extract(node) {
+    if (!node) return;
+    if (node.type === "text") {
+      texts.push(node.text || "");
+    }
+    if (node.content && Array.isArray(node.content)) {
+      for (const child of node.content) {
+        if (!isList(child)) {
+          extract(child);
+        }
+      }
+    }
+  }
+  extract(item);
+  return texts.join("").trim();
+}
+function findNestedLists(item) {
+  const lists = [];
+  if (!item.content) return lists;
+  for (const child of item.content) {
+    if (isList(child)) {
+      lists.push(child);
+    }
+  }
+  return lists;
+}
+function diffLists(listA, listB, listPathA, listPathB, depth = 0) {
+  const result = {
+    itemChanges: [],
+    itemMatches: [],
+    nestedChanges: []
+  };
+  const alignment = alignListItems(listA, listB, listPathA, listPathB);
+  for (const inserted of alignment.insertions) {
+    result.itemChanges.push({
+      id: v4(),
+      type: "listItemInsert",
+      nodeType: "listItem",
+      path: inserted.path,
+      node: inserted.node
+    });
+  }
+  for (const deleted of alignment.deletions) {
+    result.itemChanges.push({
+      id: v4(),
+      type: "listItemDelete",
+      nodeType: "listItem",
+      path: deleted.path,
+      node: deleted.node
+    });
+  }
+  result.itemMatches = alignment.matched;
+  for (const match of alignment.matched) {
+    const itemIdxA = match.pathA[match.pathA.length - 1];
+    const itemIdxB = match.pathB[match.pathB.length - 1];
+    const itemA = listA.content?.[itemIdxA];
+    const itemB = listB.content?.[itemIdxB];
+    if (!itemA || !itemB) continue;
+    const nestedA = findNestedLists(itemA);
+    const nestedB = findNestedLists(itemB);
+    const maxNested = Math.max(nestedA.length, nestedB.length);
+    for (let i = 0; i < maxNested; i++) {
+      const nA = nestedA[i];
+      const nB = nestedB[i];
+      if (nA && nB) {
+        const nestedResult = diffLists(
+          nA,
+          nB,
+          [...match.pathA, i],
+          [...match.pathB, i],
+          depth + 1
+        );
+        result.nestedChanges.push(nestedResult);
+      } else if (!nA && nB) {
+        result.itemChanges.push({
+          id: v4(),
+          type: "listItemInsert",
+          nodeType: "nestedList",
+          path: [...match.pathB, i],
+          node: nB
+        });
+      } else if (nA && !nB) {
+        result.itemChanges.push({
+          id: v4(),
+          type: "listItemDelete",
+          nodeType: "nestedList",
+          path: [...match.pathA, i],
+          node: nA
+        });
+      }
+    }
+  }
+  return result;
+}
+function getListItemLocation(listPath, itemIndex, listIndex, depth = 0) {
+  const depthStr = depth > 0 ? ` (nested, level ${depth + 1})` : "";
+  return `List ${listIndex + 1}, Item ${itemIndex + 1}${depthStr}`;
+}
+function getListItemPreview(item, maxLength = 50) {
+  const text = extractListItemText(item);
+  if (text.length > maxLength) {
+    return text.substring(0, maxLength - 3) + "...";
+  }
+  return text || "(empty item)";
+}
+function isImage(node) {
+  return node?.type === "image";
+}
+function isHorizontalRule(node) {
+  return node?.type === "horizontalRule" || node?.type === "hr";
+}
+function isHardBreak(node) {
+  return node?.type === "hardBreak";
+}
+function isPageBreak(node) {
+  return node?.type === "pageBreak";
+}
+function isEmbedded(node) {
+  const embeddedTypes = [
+    "equation",
+    "math",
+    "embed",
+    "chart",
+    "drawing",
+    "shape"
+  ];
+  return embeddedTypes.includes(node?.type);
+}
+function isAtomicNode(node) {
+  return isImage(node) || isHorizontalRule(node) || isHardBreak(node) || isPageBreak(node) || isEmbedded(node);
+}
+function getImageIdentifier(node) {
+  if (!isImage(node)) return "";
+  const attrs = node.attrs || {};
+  if (attrs.src) {
+    return `src:${attrs.src}`;
+  }
+  if (attrs.data) {
+    return `data:${simpleHash2(attrs.data)}`;
+  }
+  if (attrs.alt) {
+    return `alt:${attrs.alt}`;
+  }
+  return "unknown";
+}
+function simpleHash2(str) {
+  let hash = 5381;
+  const sample = str.substring(0, 1e3);
+  for (let i = 0; i < sample.length; i++) {
+    hash = (hash << 5) + hash ^ sample.charCodeAt(i);
+  }
+  return (hash >>> 0).toString(16);
+}
+function findImages(doc, basePath = []) {
+  const images = [];
+  function traverse(node, path) {
+    if (!node) return;
+    if (isImage(node)) {
+      images.push({ node, path: [...path] });
+    }
+    if (node.content && Array.isArray(node.content)) {
+      node.content.forEach((child, i) => {
+        traverse(child, [...path, i]);
+      });
+    }
+  }
+  traverse(doc, basePath);
+  return images;
+}
+function diffImages(docA, docB) {
+  const imagesA = findImages(docA);
+  const imagesB = findImages(docB);
+  const inserted = [];
+  const deleted = [];
+  const idsA = /* @__PURE__ */ new Map();
+  const idsB = /* @__PURE__ */ new Map();
+  for (const img of imagesA) {
+    const id = getImageIdentifier(img.node);
+    idsA.set(id, img);
+  }
+  for (const img of imagesB) {
+    const id = getImageIdentifier(img.node);
+    idsB.set(id, img);
+  }
+  for (const [id, img] of idsA) {
+    if (!idsB.has(id)) {
+      deleted.push({
+        id: v4(),
+        type: "imageDelete",
+        nodeType: "image",
+        path: img.path,
+        node: img.node
+      });
+    }
+  }
+  for (const [id, img] of idsB) {
+    if (!idsA.has(id)) {
+      inserted.push({
+        id: v4(),
+        type: "imageInsert",
+        nodeType: "image",
+        path: img.path,
+        node: img.node
+      });
     }
   }
-  const preview = cells.join(" | ");
-  if (preview.length > maxLength) {
-    return preview.substring(0, maxLength - 3) + "...";
+  return { inserted, deleted };
+}
+function getImageLocation(path) {
+  if (path.length <= 1) {
+    return `Image at position ${path[0] + 1}`;
   }
-  return preview;
+  return `Image (nested at depth ${path.length})`;
 }
-function extractCellText(cell) {
-  if (!cell.content) return "";
-  const texts = [];
-  for (const child of cell.content) {
-    if (child.type === "text") {
-      texts.push(child.text || "");
-    } else if (child.type === "paragraph" && child.content) {
-      for (const pChild of child.content) {
-        if (pChild.type === "text") {
-          texts.push(pChild.text || "");
-        }
-      }
+function getImagePreview(node) {
+  if (!isImage(node)) return "";
+  const attrs = node.attrs || {};
+  if (attrs.alt) {
+    return `"${attrs.alt}"`;
+  }
+  if (attrs.src) {
+    const src = attrs.src;
+    const filename = src.split("/").pop()?.split("?")[0];
+    if (filename) {
+      return filename;
     }
   }
-  return texts.join("").trim();
+  return "(image)";
 }
-function isList(node) {
-  return node?.type === "bulletList" || node?.type === "orderedList";
+
+// src/services/blockLevelMerger.ts
+function markAllTextAsInserted(node, sharedId, author) {
+  if (node.type === "text") {
+    const existingMarks = normalizeMarksForRendering(node.marks || []);
+    return {
+      ...node,
+      marks: [...existingMarks, createTrackInsertMark(author, sharedId)]
+    };
+  }
+  if (node.content && Array.isArray(node.content)) {
+    return {
+      ...node,
+      content: node.content.map(
+        (child) => markAllTextAsInserted(child, sharedId, author)
+      )
+    };
+  }
+  return node;
 }
-function isListItem(node) {
-  return node?.type === "listItem";
+function markAllTextAsDeleted(node, sharedId, author) {
+  if (node.type === "text") {
+    const existingMarks = normalizeMarksForRendering(node.marks || []);
+    return {
+      ...node,
+      marks: [...existingMarks, createTrackDeleteMark(author, sharedId)]
+    };
+  }
+  if (node.content && Array.isArray(node.content)) {
+    return {
+      ...node,
+      content: node.content.map(
+        (child) => markAllTextAsDeleted(child, sharedId, author)
+      )
+    };
+  }
+  return node;
 }
-function extractListItemText(item) {
+function cloneNode(node) {
+  return JSON.parse(JSON.stringify(node));
+}
+function extractTextPreview(node, maxLength = 50) {
   const texts = [];
-  function extract(node) {
-    if (!node) return;
-    if (node.type === "text") {
-      texts.push(node.text || "");
+  function extract(n) {
+    if (n.type === "text") {
+      texts.push(n.text || "");
     }
-    if (node.content && Array.isArray(node.content)) {
-      for (const child of node.content) {
-        if (!isList(child)) {
-          extract(child);
-        }
+    if (n.content) {
+      for (const child of n.content) {
+        extract(child);
       }
     }
   }
-  extract(item);
-  return texts.join("").trim();
-}
-function findNestedLists(item) {
-  const lists = [];
-  if (!item.content) return lists;
-  for (const child of item.content) {
-    if (isList(child)) {
-      lists.push(child);
-    }
+  extract(node);
+  const text = texts.join("").trim();
+  if (text.length > maxLength) {
+    return text.substring(0, maxLength - 3) + "...";
   }
-  return lists;
+  return text || "(empty)";
 }
-function diffLists(listA, listB, listPathA, listPathB, depth = 0) {
-  const result = {
-    itemChanges: [],
-    itemMatches: [],
-    nestedChanges: []
-  };
-  const alignment = alignListItems(listA, listB, listPathA, listPathB);
+function processStructuralChanges(docA, docB, author = DEFAULT_AUTHOR) {
+  const changes = [];
+  const infos = [];
+  const alignment = alignDocuments(docA, docB);
+  let tableIndex = 0;
+  let listIndex = 0;
+  let paragraphIndex = 0;
   for (const inserted of alignment.insertions) {
-    result.itemChanges.push({
-      id: v4(),
-      type: "listItemInsert",
-      nodeType: "listItem",
+    const node = inserted.node;
+    const sharedId = v4();
+    const date = (/* @__PURE__ */ new Date()).toISOString();
+    let type = "paragraphInsert";
+    let location = "";
+    let preview = "";
+    if (isTable(node)) {
+      type = "rowInsert";
+      location = `New table at position ${inserted.path[0] + 1}`;
+      preview = `Table with ${node.content?.length || 0} rows`;
+      tableIndex++;
+    } else if (isList(node)) {
+      type = "listItemInsert";
+      location = `New list at position ${inserted.path[0] + 1}`;
+      preview = `List with ${node.content?.length || 0} items`;
+      listIndex++;
+    } else {
+      type = "paragraphInsert";
+      paragraphIndex++;
+      location = `Paragraph ${paragraphIndex}`;
+      preview = extractTextPreview(node);
+    }
+    changes.push({
+      id: sharedId,
+      type,
+      nodeType: node.type,
       path: inserted.path,
-      node: inserted.node
+      node: markAllTextAsInserted(cloneNode(node), sharedId, author)
     });
-  }
-  for (const deleted of alignment.deletions) {
-    result.itemChanges.push({
-      id: v4(),
-      type: "listItemDelete",
-      nodeType: "listItem",
-      path: deleted.path,
-      node: deleted.node
+    infos.push({
+      id: sharedId,
+      type,
+      nodeType: node.type,
+      location,
+      preview,
+      author,
+      date
     });
   }
-  result.itemMatches = alignment.matched;
-  for (const match of alignment.matched) {
-    const itemIdxA = match.pathA[match.pathA.length - 1];
-    const itemIdxB = match.pathB[match.pathB.length - 1];
-    const itemA = listA.content?.[itemIdxA];
-    const itemB = listB.content?.[itemIdxB];
-    if (!itemA || !itemB) continue;
-    const nestedA = findNestedLists(itemA);
-    const nestedB = findNestedLists(itemB);
-    const maxNested = Math.max(nestedA.length, nestedB.length);
-    for (let i = 0; i < maxNested; i++) {
-      const nA = nestedA[i];
-      const nB = nestedB[i];
-      if (nA && nB) {
-        const nestedResult = diffLists(
-          nA,
-          nB,
-          [...match.pathA, i],
-          [...match.pathB, i],
-          depth + 1
-        );
-        result.nestedChanges.push(nestedResult);
-      } else if (!nA && nB) {
-        result.itemChanges.push({
-          id: v4(),
-          type: "listItemInsert",
-          nodeType: "nestedList",
-          path: [...match.pathB, i],
-          node: nB
+  for (const deleted of alignment.deletions) {
+    const node = deleted.node;
+    const sharedId = v4();
+    const date = (/* @__PURE__ */ new Date()).toISOString();
+    let type = "paragraphDelete";
+    let location = "";
+    let preview = "";
+    if (isTable(node)) {
+      type = "rowDelete";
+      location = `Deleted table at position ${deleted.path[0] + 1}`;
+      preview = `Table with ${node.content?.length || 0} rows`;
+    } else if (isList(node)) {
+      type = "listItemDelete";
+      location = `Deleted list at position ${deleted.path[0] + 1}`;
+      preview = `List with ${node.content?.length || 0} items`;
+    } else {
+      type = "paragraphDelete";
+      location = `Deleted paragraph`;
+      preview = extractTextPreview(node);
+    }
+    changes.push({
+      id: sharedId,
+      type,
+      nodeType: node.type,
+      path: deleted.path,
+      node: markAllTextAsDeleted(cloneNode(node), sharedId, author)
+    });
+    infos.push({
+      id: sharedId,
+      type,
+      nodeType: node.type,
+      location,
+      preview,
+      author,
+      date
+    });
+  }
+  for (const match of alignment.matched) {
+    const nodeA = docA.content?.[match.pathA[0]];
+    const nodeB = docB.content?.[match.pathB[0]];
+    if (!nodeA || !nodeB) continue;
+    if (isTable(nodeA) && isTable(nodeB)) {
+      tableIndex++;
+      const tableResult = diffTables(nodeA, nodeB, match.pathA, match.pathB);
+      for (const rowChange of tableResult.rowChanges) {
+        const sharedId = rowChange.id;
+        const date = (/* @__PURE__ */ new Date()).toISOString();
+        const rowIndex = rowChange.path[rowChange.path.length - 1];
+        const isInsert = rowChange.type === "rowInsert";
+        const location = getRowLocation(rowChange.path, rowIndex, tableIndex - 1);
+        const preview = getRowPreview(rowChange.node);
+        const markedNode = isInsert ? markAllTextAsInserted(cloneNode(rowChange.node), sharedId, author) : markAllTextAsDeleted(cloneNode(rowChange.node), sharedId, author);
+        changes.push({
+          ...rowChange,
+          node: markedNode
         });
-      } else if (nA && !nB) {
-        result.itemChanges.push({
-          id: v4(),
-          type: "listItemDelete",
-          nodeType: "nestedList",
-          path: [...match.pathA, i],
-          node: nA
+        infos.push({
+          id: sharedId,
+          type: rowChange.type,
+          nodeType: "tableRow",
+          location,
+          preview,
+          author,
+          date
+        });
+      }
+    }
+    if (isList(nodeA) && isList(nodeB)) {
+      listIndex++;
+      const listResult = diffLists(nodeA, nodeB, match.pathA, match.pathB);
+      for (const itemChange of listResult.itemChanges) {
+        const sharedId = itemChange.id;
+        const date = (/* @__PURE__ */ new Date()).toISOString();
+        const itemIndex = itemChange.path[itemChange.path.length - 1];
+        const isInsert = itemChange.type === "listItemInsert";
+        const location = getListItemLocation(itemChange.path, itemIndex, listIndex - 1);
+        const preview = getListItemPreview(itemChange.node);
+        const markedNode = isInsert ? markAllTextAsInserted(cloneNode(itemChange.node), sharedId, author) : markAllTextAsDeleted(cloneNode(itemChange.node), sharedId, author);
+        changes.push({
+          ...itemChange,
+          node: markedNode
+        });
+        infos.push({
+          id: sharedId,
+          type: itemChange.type,
+          nodeType: "listItem",
+          location,
+          preview,
+          author,
+          date
         });
       }
     }
   }
-  return result;
-}
-function getListItemLocation(listPath, itemIndex, listIndex, depth = 0) {
-  const depthStr = depth > 0 ? ` (nested, level ${depth + 1})` : "";
-  return `List ${listIndex + 1}, Item ${itemIndex + 1}${depthStr}`;
-}
-function getListItemPreview(item, maxLength = 50) {
-  const text = extractListItemText(item);
-  if (text.length > maxLength) {
-    return text.substring(0, maxLength - 3) + "...";
+  const imageChanges = diffImages(docA, docB);
+  for (const imgInsert of imageChanges.inserted) {
+    const sharedId = imgInsert.id;
+    const date = (/* @__PURE__ */ new Date()).toISOString();
+    infos.push({
+      id: sharedId,
+      type: "imageInsert",
+      nodeType: "image",
+      location: getImageLocation(imgInsert.path),
+      preview: getImagePreview(imgInsert.node),
+      author,
+      date
+    });
+    changes.push(imgInsert);
   }
-  return text || "(empty item)";
-}
-function isImage(node) {
-  return node?.type === "image";
-}
-function isHorizontalRule(node) {
-  return node?.type === "horizontalRule" || node?.type === "hr";
-}
-function isHardBreak(node) {
-  return node?.type === "hardBreak";
-}
-function isPageBreak(node) {
-  return node?.type === "pageBreak";
+  for (const imgDelete of imageChanges.deleted) {
+    const sharedId = imgDelete.id;
+    const date = (/* @__PURE__ */ new Date()).toISOString();
+    infos.push({
+      id: sharedId,
+      type: "imageDelete",
+      nodeType: "image",
+      location: getImageLocation(imgDelete.path),
+      preview: getImagePreview(imgDelete.node),
+      author,
+      date
+    });
+    changes.push(imgDelete);
+  }
+  return { changes, infos };
 }
-function isEmbedded(node) {
-  const embeddedTypes = [
-    "equation",
-    "math",
-    "embed",
-    "chart",
-    "drawing",
-    "shape"
-  ];
-  return embeddedTypes.includes(node?.type);
+function generateStructuralChangeSummary(infos) {
+  const summary = [];
+  const rowInserts = infos.filter((i) => i.type === "rowInsert").length;
+  const rowDeletes = infos.filter((i) => i.type === "rowDelete").length;
+  const paragraphInserts = infos.filter((i) => i.type === "paragraphInsert").length;
+  const paragraphDeletes = infos.filter((i) => i.type === "paragraphDelete").length;
+  const listItemInserts = infos.filter((i) => i.type === "listItemInsert").length;
+  const listItemDeletes = infos.filter((i) => i.type === "listItemDelete").length;
+  const imageInserts = infos.filter((i) => i.type === "imageInsert").length;
+  const imageDeletes = infos.filter((i) => i.type === "imageDelete").length;
+  if (rowInserts > 0) summary.push(`${rowInserts} row(s) inserted`);
+  if (rowDeletes > 0) summary.push(`${rowDeletes} row(s) deleted`);
+  if (paragraphInserts > 0) summary.push(`${paragraphInserts} paragraph(s) inserted`);
+  if (paragraphDeletes > 0) summary.push(`${paragraphDeletes} paragraph(s) deleted`);
+  if (listItemInserts > 0) summary.push(`${listItemInserts} list item(s) inserted`);
+  if (listItemDeletes > 0) summary.push(`${listItemDeletes} list item(s) deleted`);
+  if (imageInserts > 0) summary.push(`${imageInserts} image(s) inserted`);
+  if (imageDeletes > 0) summary.push(`${imageDeletes} image(s) deleted`);
+  return summary;
 }
-function isAtomicNode(node) {
-  return isImage(node) || isHorizontalRule(node) || isHardBreak(node) || isPageBreak(node) || isEmbedded(node);
+function cloneNode2(node) {
+  return JSON.parse(JSON.stringify(node));
 }
-function getImageIdentifier(node) {
-  if (!isImage(node)) return "";
-  const attrs = node.attrs || {};
-  if (attrs.src) {
-    return `src:${attrs.src}`;
-  }
-  if (attrs.data) {
-    return `data:${simpleHash2(attrs.data)}`;
-  }
-  if (attrs.alt) {
-    return `alt:${attrs.alt}`;
+function getMarkSpansForRange(spansB, start, end) {
+  const result = [];
+  for (const span of spansB) {
+    if (span.to > start && span.from < end) {
+      const overlapStart = Math.max(span.from, start);
+      const overlapEnd = Math.min(span.to, end);
+      result.push({
+        relStart: overlapStart - start,
+        relEnd: overlapEnd - start,
+        marks: span.marks || []
+      });
+    }
   }
-  return "unknown";
+  return result;
 }
-function simpleHash2(str) {
-  let hash = 5381;
-  const sample = str.substring(0, 1e3);
-  for (let i = 0; i < sample.length; i++) {
-    hash = (hash << 5) + hash ^ sample.charCodeAt(i);
+function createInsertedTextNodes(text, posB, spansB, author, replacementId) {
+  const result = [];
+  const trackMark = createTrackInsertMark(author, replacementId);
+  if (posB === void 0 || spansB.length === 0) {
+    return [{
+      type: "text",
+      text,
+      marks: [trackMark]
+    }];
   }
-  return (hash >>> 0).toString(16);
-}
-function findImages(doc, basePath = []) {
-  const images = [];
-  function traverse(node, path) {
-    if (!node) return;
-    if (isImage(node)) {
-      images.push({ node, path: [...path] });
+  const markSpans = getMarkSpansForRange(spansB, posB, posB + text.length);
+  if (markSpans.length === 0) {
+    return [{
+      type: "text",
+      text,
+      marks: [trackMark]
+    }];
+  }
+  markSpans.sort((a, b) => a.relStart - b.relStart);
+  let processedUpTo = 0;
+  for (const span of markSpans) {
+    if (span.relStart > processedUpTo) {
+      result.push({
+        type: "text",
+        text: text.substring(processedUpTo, span.relStart),
+        marks: [trackMark]
+      });
     }
-    if (node.content && Array.isArray(node.content)) {
-      node.content.forEach((child, i) => {
-        traverse(child, [...path, i]);
+    if (span.relEnd > span.relStart) {
+      const spanText = text.substring(span.relStart, span.relEnd);
+      const normalizedSpanMarks = normalizeMarksForRendering(span.marks);
+      const marks = [...normalizedSpanMarks, trackMark];
+      result.push({
+        type: "text",
+        text: spanText,
+        marks
       });
+      processedUpTo = span.relEnd;
     }
   }
-  traverse(doc, basePath);
-  return images;
-}
-function diffImages(docA, docB) {
-  const imagesA = findImages(docA);
-  const imagesB = findImages(docB);
-  const inserted = [];
-  const deleted = [];
-  const idsA = /* @__PURE__ */ new Map();
-  const idsB = /* @__PURE__ */ new Map();
-  for (const img of imagesA) {
-    const id = getImageIdentifier(img.node);
-    idsA.set(id, img);
-  }
-  for (const img of imagesB) {
-    const id = getImageIdentifier(img.node);
-    idsB.set(id, img);
+  if (processedUpTo < text.length) {
+    result.push({
+      type: "text",
+      text: text.substring(processedUpTo),
+      marks: [trackMark]
+    });
   }
-  for (const [id, img] of idsA) {
-    if (!idsB.has(id)) {
-      deleted.push({
-        id: v4(),
-        type: "imageDelete",
-        nodeType: "image",
-        path: img.path,
-        node: img.node
-      });
+  return result;
+}
+function mergeDocuments(docA, docB, diffResult, author = DEFAULT_AUTHOR) {
+  const merged = cloneNode2(docA);
+  const charStates = [];
+  let insertions = [];
+  const formatChanges = diffResult.formatChanges || [];
+  function getFormatChangeAt(pos) {
+    for (const fc of formatChanges) {
+      if (pos >= fc.from && pos < fc.to) {
+        return fc;
+      }
     }
+    return null;
   }
-  for (const [id, img] of idsB) {
-    if (!idsA.has(id)) {
-      inserted.push({
-        id: v4(),
-        type: "imageInsert",
-        nodeType: "image",
-        path: img.path,
-        node: img.node
+  let docAOffset = 0;
+  const segments = diffResult.segments;
+  for (let segIdx = 0; segIdx < segments.length; segIdx++) {
+    const segment = segments[segIdx];
+    if (segment.type === "equal") {
+      for (let i = 0; i < segment.text.length; i++) {
+        charStates[docAOffset + i] = { type: "equal" };
+      }
+      docAOffset += segment.text.length;
+    } else if (segment.type === "delete") {
+      const nextSegment = segments[segIdx + 1];
+      const isReplacement = nextSegment && nextSegment.type === "insert";
+      const replacementId = isReplacement ? v4() : void 0;
+      for (let i = 0; i < segment.text.length; i++) {
+        charStates[docAOffset + i] = { type: "delete", replacementId };
+      }
+      docAOffset += segment.text.length;
+      if (isReplacement && nextSegment) {
+        insertions.push({
+          afterOffset: docAOffset,
+          text: nextSegment.text,
+          replacementId,
+          posB: nextSegment.posB
+          // Capture docB position for mark lookup
+        });
+        segIdx++;
+      }
+    } else if (segment.type === "insert") {
+      insertions.push({
+        afterOffset: docAOffset,
+        text: segment.text,
+        posB: segment.posB
+        // Capture docB position for mark lookup
       });
     }
   }
-  return { inserted, deleted };
-}
-function getImageLocation(path) {
-  if (path.length <= 1) {
-    return `Image at position ${path[0] + 1}`;
+  const spansB = diffResult.spansB || [];
+  function transformNode(node, nodeOffset, path) {
+    if (node.type === "text" && node.text) {
+      const text = node.text;
+      const result = [];
+      let i = 0;
+      while (i < text.length) {
+        const charOffset = nodeOffset + i;
+        const charState = charStates[charOffset] || { type: "equal" };
+        const insertionsHere = insertions.filter((ins) => ins.afterOffset === charOffset);
+        for (const ins of insertionsHere) {
+          const insertedNodes = createInsertedTextNodes(
+            ins.text,
+            ins.posB,
+            spansB,
+            author,
+            ins.replacementId
+          );
+          result.push(...insertedNodes);
+        }
+        const currentFormatChange = getFormatChangeAt(nodeOffset + i);
+        let j = i + 1;
+        while (j < text.length) {
+          const nextState = charStates[nodeOffset + j] || { type: "equal" };
+          if (nextState.type !== charState.type) break;
+          if (insertions.some((ins) => ins.afterOffset === nodeOffset + j)) break;
+          const nextFormatChange = getFormatChangeAt(nodeOffset + j);
+          if (currentFormatChange !== nextFormatChange) break;
+          j++;
+        }
+        const chunk = text.substring(i, j);
+        let marks = [...node.marks || []];
+        if (charState.type === "delete") {
+          marks.push(createTrackDeleteMark(author, charState.replacementId));
+        } else if (charState.type === "equal") {
+          if (currentFormatChange) {
+            const trackFormatMark = createTrackFormatMark(
+              currentFormatChange.before,
+              currentFormatChange.after,
+              author
+            );
+            const normalizedAfterMarks = normalizeMarksForRendering(currentFormatChange.after);
+            marks = [...normalizedAfterMarks, trackFormatMark];
+          }
+        }
+        result.push({
+          type: "text",
+          text: chunk,
+          marks: marks.length > 0 ? marks : void 0
+        });
+        i = j;
+      }
+      const endOffset = nodeOffset + text.length;
+      const endInsertions = insertions.filter((ins) => ins.afterOffset === endOffset);
+      for (const ins of endInsertions) {
+        const insertedNodes = createInsertedTextNodes(
+          ins.text,
+          ins.posB,
+          spansB,
+          author,
+          ins.replacementId
+        );
+        result.push(...insertedNodes);
+      }
+      insertions = insertions.filter(
+        (ins) => ins.afterOffset < nodeOffset || ins.afterOffset > endOffset
+      );
+      return { nodes: result, consumedLength: text.length };
+    }
+    if (node.content && Array.isArray(node.content)) {
+      const newContent = [];
+      let offset = nodeOffset;
+      for (const child of node.content) {
+        const { nodes, consumedLength } = transformNode(child, offset);
+        newContent.push(...nodes);
+        offset += consumedLength;
+      }
+      return {
+        nodes: [{ ...node, content: newContent }],
+        consumedLength: offset - nodeOffset
+      };
+    }
+    return { nodes: [node], consumedLength: 0 };
   }
-  return `Image (nested at depth ${path.length})`;
-}
-function getImagePreview(node) {
-  if (!isImage(node)) return "";
-  const attrs = node.attrs || {};
-  if (attrs.alt) {
-    return `"${attrs.alt}"`;
+  if (merged.content && Array.isArray(merged.content)) {
+    const newContent = [];
+    let offset = 0;
+    for (let i = 0; i < merged.content.length; i++) {
+      const child = merged.content[i];
+      const { nodes, consumedLength } = transformNode(child, offset);
+      newContent.push(...nodes);
+      offset += consumedLength;
+    }
+    merged.content = newContent;
   }
-  if (attrs.src) {
-    const src = attrs.src;
-    const filename = src.split("/").pop()?.split("?")[0];
-    if (filename) {
-      return filename;
+  if (insertions.length > 0) {
+    for (const ins of insertions) {
+      const insertedNodes = createInsertedTextNodes(
+        ins.text,
+        ins.posB,
+        spansB,
+        author,
+        ins.replacementId
+      );
+      const insertNode = {
+        type: "paragraph",
+        content: [
+          {
+            type: "run",
+            content: insertedNodes
+          }
+        ]
+      };
+      if (!merged.content) merged.content = [];
+      merged.content.push(insertNode);
     }
   }
-  return "(image)";
+  return merged;
 }
 
 // src/services/structuralMerger.ts
-function cloneNode2(node) {
+function cloneNode3(node) {
   return JSON.parse(JSON.stringify(node));
 }
-function markAllTextAsInserted(node, sharedId, author) {
+function markAllTextAsInserted2(node, sharedId, author) {
   if (node.type === "text") {
     const existingMarks = normalizeMarksForRendering(node.marks || []);
     return {
@@ -2508,13 +2785,13 @@ function markAllTextAsInserted(node, sharedId, author) {
     return {
       ...node,
       content: node.content.map(
-        (child) => markAllTextAsInserted(child, sharedId, author)
+        (child) => markAllTextAsInserted2(child, sharedId, author)
       )
     };
   }
   return { ...node };
 }
-function markAllTextAsDeleted(node, sharedId, author) {
+function markAllTextAsDeleted2(node, sharedId, author) {
   if (node.type === "text") {
     const existingMarks = normalizeMarksForRendering(node.marks || []);
     return {
@@ -2526,13 +2803,13 @@ function markAllTextAsDeleted(node, sharedId, author) {
     return {
       ...node,
       content: node.content.map(
-        (child) => markAllTextAsDeleted(child, sharedId, author)
+        (child) => markAllTextAsDeleted2(child, sharedId, author)
       )
     };
   }
   return { ...node };
 }
-function extractTextPreview(node, maxLength = 50) {
+function extractTextPreview2(node, maxLength = 50) {
   const texts = [];
   function extract(n) {
     if (n.type === "text") {
@@ -2718,7 +2995,7 @@ function mergeMatchedBlock(nodeA, nodeB, blockIndex, author) {
     diff,
     author
   );
-  const mergedNode = merged.content?.[0] || cloneNode2(nodeB);
+  const mergedNode = merged.content?.[0] || cloneNode3(nodeB);
   return { mergedNode, infos, changes };
 }
 function mergeMatchedTable(tableA, tableB, tableIndex, author) {
@@ -2747,13 +3024,13 @@ function mergeMatchedTable(tableA, tableB, tableIndex, author) {
         if (deletedIndices.has(checkIdx) && !processedDeletions.has(checkIdx)) {
           const deletedRow = rowsA[checkIdx];
           const changeId = v4();
-          mergedRows.push(markAllTextAsDeleted(cloneNode2(deletedRow), changeId, author));
+          mergedRows.push(markAllTextAsDeleted2(cloneNode3(deletedRow), changeId, author));
           tableInfos.push({
             id: changeId,
             type: "rowDelete",
             nodeType: "tableRow",
             location: `Table ${tableIndex}, Row ${checkIdx + 1}`,
-            preview: extractTextPreview(deletedRow),
+            preview: extractTextPreview2(deletedRow),
             author,
             date: (/* @__PURE__ */ new Date()).toISOString()
           });
@@ -2765,13 +3042,13 @@ function mergeMatchedTable(tableA, tableB, tableIndex, author) {
       changeCount += changes;
     } else {
       const changeId = v4();
-      mergedRows.push(markAllTextAsInserted(cloneNode2(rowB), changeId, author));
+      mergedRows.push(markAllTextAsInserted2(cloneNode3(rowB), changeId, author));
       tableInfos.push({
         id: changeId,
         type: "rowInsert",
         nodeType: "tableRow",
         location: `Table ${tableIndex}, Row ${idxB + 1}`,
-        preview: extractTextPreview(rowB),
+        preview: extractTextPreview2(rowB),
         author,
         date: (/* @__PURE__ */ new Date()).toISOString()
       });
@@ -2781,13 +3058,13 @@ function mergeMatchedTable(tableA, tableB, tableIndex, author) {
     const idxA = deletion.path[deletion.path.length - 1];
     if (!processedDeletions.has(idxA)) {
       const changeId = v4();
-      mergedRows.push(markAllTextAsDeleted(cloneNode2(deletion.node), changeId, author));
+      mergedRows.push(markAllTextAsDeleted2(cloneNode3(deletion.node), changeId, author));
       tableInfos.push({
         id: changeId,
         type: "rowDelete",
         nodeType: "tableRow",
         location: `Table ${tableIndex}, Row ${idxA + 1}`,
-        preview: extractTextPreview(deletion.node),
+        preview: extractTextPreview2(deletion.node),
         author,
         date: (/* @__PURE__ */ new Date()).toISOString()
       });
@@ -2825,13 +3102,13 @@ function mergeMatchedList(listA, listB, listIndex, author) {
         if (deletedIndices.has(checkIdx) && !processedDeletions.has(checkIdx)) {
           const deletedItem = itemsA[checkIdx];
           const changeId = v4();
-          mergedItems.push(markAllTextAsDeleted(cloneNode2(deletedItem), changeId, author));
+          mergedItems.push(markAllTextAsDeleted2(cloneNode3(deletedItem), changeId, author));
           listInfos.push({
             id: changeId,
             type: "listItemDelete",
             nodeType: "listItem",
             location: `List ${listIndex}, Item ${checkIdx + 1}`,
-            preview: extractTextPreview(deletedItem),
+            preview: extractTextPreview2(deletedItem),
             author,
             date: (/* @__PURE__ */ new Date()).toISOString()
           });
@@ -2843,13 +3120,13 @@ function mergeMatchedList(listA, listB, listIndex, author) {
       changeCount += changes;
     } else {
       const changeId = v4();
-      mergedItems.push(markAllTextAsInserted(cloneNode2(itemB), changeId, author));
+      mergedItems.push(markAllTextAsInserted2(cloneNode3(itemB), changeId, author));
       listInfos.push({
         id: changeId,
         type: "listItemInsert",
         nodeType: "listItem",
         location: `List ${listIndex}, Item ${idxB + 1}`,
-        preview: extractTextPreview(itemB),
+        preview: extractTextPreview2(itemB),
         author,
         date: (/* @__PURE__ */ new Date()).toISOString()
       });
@@ -2859,13 +3136,13 @@ function mergeMatchedList(listA, listB, listIndex, author) {
     const idxA = deletion.path[deletion.path.length - 1];
     if (!processedDeletions.has(idxA)) {
       const changeId = v4();
-      mergedItems.push(markAllTextAsDeleted(cloneNode2(deletion.node), changeId, author));
+      mergedItems.push(markAllTextAsDeleted2(cloneNode3(deletion.node), changeId, author));
       listInfos.push({
         id: changeId,
         type: "listItemDelete",
         nodeType: "listItem",
         location: `List ${listIndex}, Item ${idxA + 1}`,
-        preview: extractTextPreview(deletion.node),
+        preview: extractTextPreview2(deletion.node),
         author,
         date: (/* @__PURE__ */ new Date()).toISOString()
       });
@@ -2879,14 +3156,14 @@ function mergeMatchedList(listA, listB, listIndex, author) {
 }
 function createInsertedBlock(node, blockIndex, author) {
   const changeId = v4();
-  const markedNode = markAllTextAsInserted(cloneNode2(node), changeId, author);
+  const markedNode = markAllTextAsInserted2(cloneNode3(node), changeId, author);
   const nodeDesc = getNodeTypeDescription(node);
   const info = {
     id: changeId,
     type: isTable(node) ? "rowInsert" : isList(node) ? "listItemInsert" : isImage(node) ? "imageInsert" : "paragraphInsert",
     nodeType: node.type || "unknown",
     location: `${nodeDesc} inserted at position ${blockIndex}`,
-    preview: extractTextPreview(node),
+    preview: extractTextPreview2(node),
     author,
     date: (/* @__PURE__ */ new Date()).toISOString()
   };
@@ -2894,14 +3171,14 @@ function createInsertedBlock(node, blockIndex, author) {
 }
 function createDeletedBlock(node, blockIndex, author) {
   const changeId = v4();
-  const markedNode = markAllTextAsDeleted(cloneNode2(node), changeId, author);
+  const markedNode = markAllTextAsDeleted2(cloneNode3(node), changeId, author);
   const nodeDesc = getNodeTypeDescription(node);
   const info = {
     id: changeId,
     type: isTable(node) ? "rowDelete" : isList(node) ? "listItemDelete" : isImage(node) ? "imageDelete" : "paragraphDelete",
     nodeType: node.type || "unknown",
     location: `${nodeDesc} deleted from position ${blockIndex}`,
-    preview: extractTextPreview(node),
+    preview: extractTextPreview2(node),
     author,
     date: (/* @__PURE__ */ new Date()).toISOString()
   };
@@ -2960,8 +3237,9 @@ var DocxDiffEditor = forwardRef(
     const mountedRef = useRef(true);
     const initRef = useRef(false);
     const readyRef = useRef(false);
+    const rollbackJsonRef = useRef(null);
     const [isLoading, setIsLoading] = useState(true);
-    const [error, setError] = useState(null);
+    const [fatalError, setFatalError] = useState(null);
     const [sourceJson, setSourceJson] = useState(null);
     const [mergedJson, setMergedJson] = useState(null);
     const [diffResult, setDiffResult] = useState(null);
@@ -3018,11 +3296,31 @@ var DocxDiffEditor = forwardRef(
         sd.setTrackedChangesPreferences({ mode: "off", enabled: false });
       }
     }, []);
-    const handleError = useCallback(
-      (err) => {
-        const error2 = err instanceof Error ? err : new Error(err);
-        setError(error2.message);
-        onError?.(error2);
+    const handleFatalError = useCallback(
+      (err, operation) => {
+        const error = err instanceof Error ? err : new Error(err);
+        setFatalError(error.message);
+        onError?.({
+          error,
+          type: "fatal",
+          operation,
+          recoverable: false,
+          message: error.message
+        });
+      },
+      [onError]
+    );
+    const handleOperationError = useCallback(
+      (err, operation, phase) => {
+        const error = err instanceof Error ? err : new Error(err);
+        onError?.({
+          error,
+          type: "operation",
+          operation,
+          recoverable: true,
+          message: error.message,
+          phase
+        });
       },
       [onError]
     );
@@ -3180,7 +3478,7 @@ var DocxDiffEditor = forwardRef(
         return;
       }
       setIsLoading(true);
-      setError(null);
+      setFatalError(null);
       destroySuperdoc();
       try {
         const { SuperDoc } = await import('superdoc');
@@ -3203,17 +3501,19 @@ var DocxDiffEditor = forwardRef(
           if (sd?.activeEditor && isProseMirrorJSON(initialSource)) {
             setEditorContent(sd.activeEditor, initialSource);
             setSourceJson(initialSource);
+            rollbackJsonRef.current = initialSource;
             onSourceLoaded?.(initialSource);
           }
         } else {
           setSourceJson(json);
+          rollbackJsonRef.current = json;
           onSourceLoaded?.(json);
         }
         setIsLoading(false);
         onReady?.();
       } catch (err) {
         console.error("Failed to initialize SuperDoc:", err);
-        handleError(err instanceof Error ? err : new Error("Failed to load editor"));
+        handleFatalError(err instanceof Error ? err : new Error("Failed to load editor"), "init");
         setIsLoading(false);
         initRef.current = false;
       }
@@ -3227,7 +3527,7 @@ var DocxDiffEditor = forwardRef(
       destroySuperdoc,
       createSuperdoc,
       setEditorContent,
-      handleError
+      handleFatalError
     ]);
     useEffect(() => {
       mountedRef.current = true;
@@ -3262,42 +3562,98 @@ var DocxDiffEditor = forwardRef(
          * Accepts File (DOCX), HTML string, or ProseMirror JSON.
          * Note: This destroys and recreates the SuperDoc instance.
          * For JSON content updates, prefer updateContent() to preserve the existing template.
+         * 
+         * On failure, attempts to preserve the previous editor state.
+         * Returns void on success, or SetSourceError on recoverable failure.
          */
         async setSource(content) {
           if (!SuperDocRef.current) {
-            throw new Error("Editor not initialized");
+            const error = new Error("Editor not initialized");
+            handleOperationError(error, "setSource");
+            return { success: false, error, message: error.message };
           }
+          const currentRollback = superdocRef.current?.activeEditor ? superdocRef.current.activeEditor.getJSON() : rollbackJsonRef.current;
           setIsLoading(true);
-          setError(null);
+          setFatalError(null);
           try {
             const contentType = detectContentType(content);
-            let json;
-            destroySuperdoc();
-            if (contentType === "file") {
-              const result = await createSuperdoc({ document: content });
-              json = result.json;
-            } else if (contentType === "html") {
-              const result = await createSuperdoc({ html: content });
-              json = result.json;
-            } else {
-              const result = await createSuperdoc(templateDocx ? { document: templateDocx } : {});
-              if (result.superdoc?.activeEditor && isProseMirrorJSON(content)) {
-                setEditorContent(result.superdoc.activeEditor, content);
-                json = content;
+            let validatedJson = null;
+            try {
+              if (contentType === "file") {
+                validatedJson = await parseDocxFile(content, SuperDocRef.current);
+              } else if (contentType === "html") {
+                validatedJson = await parseHtmlToJson(content, SuperDocRef.current);
               } else {
+                if (!isProseMirrorJSON(content)) {
+                  throw new Error("Invalid ProseMirror JSON structure");
+                }
+                validatedJson = content;
+              }
+            } catch (parseErr) {
+              const error = parseErr instanceof Error ? parseErr : new Error("Failed to parse content");
+              handleOperationError(error, "setSource");
+              setIsLoading(false);
+              return { success: false, error, message: error.message };
+            }
+            destroySuperdoc();
+            let json;
+            try {
+              if (contentType === "file") {
+                const result = await createSuperdoc({ document: content });
+                json = result.json;
+              } else if (contentType === "html") {
+                const result = await createSuperdoc({ html: content });
                 json = result.json;
+              } else {
+                const result = await createSuperdoc(templateDocx ? { document: templateDocx } : {});
+                if (result.superdoc?.activeEditor && validatedJson) {
+                  setEditorContent(result.superdoc.activeEditor, validatedJson);
+                  json = validatedJson;
+                } else {
+                  json = result.json;
+                }
+              }
+            } catch (createErr) {
+              console.warn("[DocxDiffEditor] Failed to create new editor, attempting recovery:", createErr);
+              if (currentRollback) {
+                try {
+                  const recoveryResult = await createSuperdoc(templateDocx ? { document: templateDocx } : {});
+                  if (recoveryResult.superdoc?.activeEditor) {
+                    setEditorContent(recoveryResult.superdoc.activeEditor, currentRollback);
+                    setSourceJson(currentRollback);
+                    setEditingMode(superdocRef.current);
+                  }
+                  const error = createErr instanceof Error ? createErr : new Error("Failed to set source");
+                  handleOperationError(error, "setSource");
+                  setIsLoading(false);
+                  return { success: false, error, message: error.message };
+                } catch (recoveryErr) {
+                  console.error("[DocxDiffEditor] Recovery failed:", recoveryErr);
+                  const error = createErr instanceof Error ? createErr : new Error("Failed to set source");
+                  handleFatalError(error, "setSource");
+                  setIsLoading(false);
+                  return { success: false, error, message: error.message };
+                }
+              } else {
+                const error = createErr instanceof Error ? createErr : new Error("Failed to set source");
+                handleFatalError(error, "setSource");
+                setIsLoading(false);
+                return { success: false, error, message: error.message };
               }
             }
             setSourceJson(json);
             setMergedJson(null);
             setDiffResult(null);
             setEditingMode(superdocRef.current);
+            rollbackJsonRef.current = json;
             onSourceLoaded?.(json);
+            setIsLoading(false);
+            return;
           } catch (err) {
-            handleError(err instanceof Error ? err : new Error("Failed to set source"));
-            throw err;
-          } finally {
+            const error = err instanceof Error ? err : new Error("Failed to set source");
+            handleFatalError(error, "setSource");
             setIsLoading(false);
+            return { success: false, error, message: error.message };
           }
         },
         /**
@@ -3309,21 +3665,27 @@ var DocxDiffEditor = forwardRef(
          * 
          * To compare against the original source document, call setSource() again
          * before compareWith().
+         * 
+         * Returns a union type - check `result.success` to determine outcome:
+         * - `success: true` - Comparison succeeded
+         * - `success: false` - Comparison failed, editor unchanged
          */
         async compareWith(content) {
           if (!SuperDocRef.current) {
-            throw new Error("Editor not initialized");
+            const error = new Error("Editor not initialized");
+            handleOperationError(error, "compareWith", "parsing");
+            return { success: false, error, message: error.message, phase: "parsing" };
           }
           if (!superdocRef.current?.activeEditor) {
-            throw new Error("Editor not ready. Ensure a document is loaded first.");
+            const error = new Error("Editor not ready. Ensure a document is loaded first.");
+            handleOperationError(error, "compareWith", "parsing");
+            return { success: false, error, message: error.message, phase: "parsing" };
           }
+          const rollbackJson = superdocRef.current.activeEditor.getJSON();
           setIsLoading(true);
+          let newJson;
+          const contentType = detectContentType(content);
           try {
-            const currentEditorJson = superdocRef.current.activeEditor.getJSON();
-            const cleanBaseline = acceptAllChangesInJson(currentEditorJson) || { type: "doc", content: [] };
-            setSourceJson(cleanBaseline);
-            const contentType = detectContentType(content);
-            let newJson;
             if (contentType === "file") {
               newJson = await parseDocxFile(content, SuperDocRef.current);
             } else if (contentType === "html") {
@@ -3378,91 +3740,122 @@ var DocxDiffEditor = forwardRef(
               }
               newJson = content;
             }
+          } catch (parseErr) {
+            const error = parseErr instanceof Error ? parseErr : new Error("Failed to parse content");
+            handleOperationError(error, "compareWith", "parsing");
+            setIsLoading(false);
+            return { success: false, error, message: error.message, phase: "parsing" };
+          }
+          let normalizedMerged;
+          let normalizedNewJson;
+          let structInfos;
+          let diff;
+          let cleanBaseline;
+          try {
+            const currentEditorJson = superdocRef.current.activeEditor.getJSON();
+            cleanBaseline = acceptAllChangesInJson(currentEditorJson) || { type: "doc", content: [] };
             const cleanNewJson = acceptAllChangesInJson(newJson) || { type: "doc", content: [] };
-            const normalizedNewJson = normalizeRunProperties(cleanNewJson);
+            normalizedNewJson = normalizeRunProperties(cleanNewJson);
             const structuralResult = mergeWithStructuralAwareness(
               cleanBaseline,
               normalizedNewJson,
               author
             );
             const merged = structuralResult.mergedDoc;
-            const structInfos = structuralResult.structuralInfos;
-            const normalizedMerged = normalizeRunProperties(merged);
-            setMergedJson(normalizedMerged);
-            const diff = diffDocuments(cleanBaseline, cleanNewJson);
-            setDiffResult(diff);
-            let usedFallback = false;
-            if (superdocRef.current?.activeEditor) {
-              try {
-                setEditorContent(superdocRef.current.activeEditor, normalizedMerged);
-                enableReviewMode(superdocRef.current);
-                const sd = superdocRef.current;
-                if (sd.commentsStore?.processLoadedDocxComments) {
-                  setTimeout(() => {
-                    try {
-                      sd.commentsStore.processLoadedDocxComments({
-                        superdoc: sd,
-                        editor: sd.activeEditor,
-                        comments: [],
-                        // Empty array - we just want to trigger createCommentForTrackChanges
-                        documentId: sd.activeEditor?.options?.documentId || "primary"
-                      });
-                    } catch (err) {
-                      console.warn("[DocxDiffEditor] Failed to process track changes for bubbles:", err);
-                    }
-                  }, 50);
-                }
-              } catch (contentErr) {
-                console.warn(
-                  "[DocxDiffEditor] Failed to apply merged content with track changes. Falling back to direct content update without track bubbles.",
-                  contentErr
-                );
-                usedFallback = true;
+            structInfos = structuralResult.structuralInfos;
+            normalizedMerged = normalizeRunProperties(merged);
+            diff = diffDocuments(cleanBaseline, cleanNewJson);
+          } catch (mergeErr) {
+            const error = mergeErr instanceof Error ? mergeErr : new Error("Failed to merge documents");
+            handleOperationError(error, "compareWith", "merging");
+            setIsLoading(false);
+            return { success: false, error, message: error.message, phase: "merging" };
+          }
+          let usedFallback = false;
+          try {
+            setEditorContent(superdocRef.current.activeEditor, normalizedMerged);
+            enableReviewMode(superdocRef.current);
+            const sd = superdocRef.current;
+            if (sd.commentsStore?.processLoadedDocxComments) {
+              setTimeout(() => {
                 try {
-                  setEditorContent(superdocRef.current.activeEditor, normalizedNewJson);
-                  setEditingMode(superdocRef.current);
-                } catch (fallbackErr) {
-                  console.error("[DocxDiffEditor] Fallback content update also failed:", fallbackErr);
-                  throw contentErr;
+                  sd.commentsStore.processLoadedDocxComments({
+                    superdoc: sd,
+                    editor: sd.activeEditor,
+                    comments: [],
+                    documentId: sd.activeEditor?.options?.documentId || "primary"
+                  });
+                } catch (err) {
+                  console.warn("[DocxDiffEditor] Failed to process track changes for bubbles:", err);
                 }
-              }
-            }
-            if (!usedFallback) {
-              setStructuralChanges(structInfos);
-              setIsPaneDismissed(false);
-            } else {
-              setStructuralChanges([]);
+              }, 50);
             }
-            const insertions = diff.segments.filter((s) => s.type === "insert").length;
-            const deletions = diff.segments.filter((s) => s.type === "delete").length;
-            const formatChanges = diff.formatChanges?.length || 0;
-            const structuralChangeCount = usedFallback ? 0 : structInfos.length;
-            const combinedSummary = [...structuralResult.summary];
-            if (diff.summary.length > 0 && structuralResult.summary.length === 0) {
-              combinedSummary.push(...diff.summary);
+          } catch (contentErr) {
+            console.warn(
+              "[DocxDiffEditor] Failed to apply merged content with track changes. Falling back to direct content update without track bubbles.",
+              contentErr
+            );
+            usedFallback = true;
+            try {
+              setEditorContent(superdocRef.current.activeEditor, normalizedNewJson);
+              setEditingMode(superdocRef.current);
+            } catch (fallbackErr) {
+              console.warn("[DocxDiffEditor] Fallback content update failed, attempting rollback:", fallbackErr);
+              try {
+                setEditorContent(superdocRef.current.activeEditor, rollbackJson);
+                setEditingMode(superdocRef.current);
+                const error = contentErr instanceof Error ? contentErr : new Error("Failed to apply comparison");
+                handleOperationError(error, "compareWith", "applying");
+                setIsLoading(false);
+                return { success: false, error, message: error.message, phase: "applying" };
+              } catch (rollbackErr) {
+                console.error("[DocxDiffEditor] All recovery attempts failed:", rollbackErr);
+                const error = contentErr instanceof Error ? contentErr : new Error("Failed to apply comparison");
+                handleFatalError(error, "compareWith");
+                setIsLoading(false);
+                return { success: false, error, message: error.message, phase: "applying" };
+              }
             }
-            if (usedFallback) {
-              combinedSummary.push("Note: Track change visualization unavailable for this content");
+          }
+          setSourceJson(cleanBaseline);
+          setMergedJson(normalizedMerged);
+          setDiffResult(diff);
+          rollbackJsonRef.current = usedFallback ? normalizedNewJson : normalizedMerged;
+          if (!usedFallback) {
+            setStructuralChanges(structInfos);
+            setIsPaneDismissed(false);
+          } else {
+            setStructuralChanges([]);
+          }
+          const insertions = diff.segments.filter((s) => s.type === "insert").length;
+          const deletions = diff.segments.filter((s) => s.type === "delete").length;
+          const formatChanges = diff.formatChanges?.length || 0;
+          const structuralChangeCount = usedFallback ? 0 : structInfos.length;
+          const combinedSummary = [...diff.summary || []];
+          if (structInfos.length > 0 && !usedFallback) {
+            const structSummaries = generateStructuralChangeSummary(structInfos);
+            if (structSummaries.length > 0) {
+              combinedSummary.unshift(...structSummaries);
             }
-            const result = {
-              totalChanges: insertions + deletions + formatChanges + structuralChangeCount,
-              insertions,
-              deletions,
-              formatChanges,
-              structuralChanges: structuralChangeCount,
-              summary: combinedSummary,
-              mergedJson: usedFallback ? normalizedNewJson : merged,
-              structuralChangeInfos: usedFallback ? [] : structInfos,
-              usedFallback
-            };
-            onComparisonComplete?.(result);
-            return result;
-          } catch (err) {
-            handleError(err instanceof Error ? err : new Error("Comparison failed"));
-            throw err;
-          } finally {
-            setIsLoading(false);
           }
+          if (usedFallback) {
+            combinedSummary.push("Note: Track change visualization unavailable for this content");
+          }
+          const result = {
+            success: true,
+            totalChanges: insertions + deletions + formatChanges + structuralChangeCount,
+            insertions,
+            deletions,
+            formatChanges,
+            structuralChanges: structuralChangeCount,
+            summary: combinedSummary,
+            mergedJson: usedFallback ? normalizedNewJson : normalizedMerged,
+            structuralChangeInfos: usedFallback ? [] : structInfos,
+            usedFallback
+          };
+          onComparisonComplete?.(result);
+          setIsLoading(false);
+          return result;
         },
         /**
          * Get raw diff segments
@@ -3790,7 +4183,8 @@ var DocxDiffEditor = forwardRef(
         setEditingMode,
         onSourceLoaded,
         onComparisonComplete,
-        handleError
+        handleFatalError,
+        handleOperationError
       ]
     );
     return /* @__PURE__ */ jsxs("div", { className: `dde-container ${className}`.trim(), children: [
@@ -3798,7 +4192,7 @@ var DocxDiffEditor = forwardRef(
         /* @__PURE__ */ jsx("div", { className: "dde-loading__spinner" }),
         /* @__PURE__ */ jsx("p", { className: "dde-loading__text", children: "Loading document..." })
       ] }),
-      error && /* @__PURE__ */ jsxs("div", { className: "dde-error", children: [
+      fatalError && /* @__PURE__ */ jsxs("div", { className: "dde-error", children: [
         /* @__PURE__ */ jsx("div", { className: "dde-error__icon", children: /* @__PURE__ */ jsx(
           "svg",
           {
@@ -3818,7 +4212,7 @@ var DocxDiffEditor = forwardRef(
           }
         ) }),
         /* @__PURE__ */ jsx("p", { className: "dde-error__title", children: "Failed to load document" }),
-        /* @__PURE__ */ jsx("p", { className: "dde-error__message", children: error })
+        /* @__PURE__ */ jsx("p", { className: "dde-error__message", children: fatalError })
       ] }),
       showToolbar && /* @__PURE__ */ jsx(
         "div",
@@ -3855,256 +4249,6 @@ var DocxDiffEditor_default = DocxDiffEditor;
 
 // src/services/index.ts
 init_nodeFingerprint();
-function markAllTextAsInserted2(node, sharedId, author) {
-  if (node.type === "text") {
-    const existingMarks = normalizeMarksForRendering(node.marks || []);
-    return {
-      ...node,
-      marks: [...existingMarks, createTrackInsertMark(author, sharedId)]
-    };
-  }
-  if (node.content && Array.isArray(node.content)) {
-    return {
-      ...node,
-      content: node.content.map(
-        (child) => markAllTextAsInserted2(child, sharedId, author)
-      )
-    };
-  }
-  return node;
-}
-function markAllTextAsDeleted2(node, sharedId, author) {
-  if (node.type === "text") {
-    const existingMarks = normalizeMarksForRendering(node.marks || []);
-    return {
-      ...node,
-      marks: [...existingMarks, createTrackDeleteMark(author, sharedId)]
-    };
-  }
-  if (node.content && Array.isArray(node.content)) {
-    return {
-      ...node,
-      content: node.content.map(
-        (child) => markAllTextAsDeleted2(child, sharedId, author)
-      )
-    };
-  }
-  return node;
-}
-function cloneNode3(node) {
-  return JSON.parse(JSON.stringify(node));
-}
-function extractTextPreview2(node, maxLength = 50) {
-  const texts = [];
-  function extract(n) {
-    if (n.type === "text") {
-      texts.push(n.text || "");
-    }
-    if (n.content) {
-      for (const child of n.content) {
-        extract(child);
-      }
-    }
-  }
-  extract(node);
-  const text = texts.join("").trim();
-  if (text.length > maxLength) {
-    return text.substring(0, maxLength - 3) + "...";
-  }
-  return text || "(empty)";
-}
-function processStructuralChanges(docA, docB, author = DEFAULT_AUTHOR) {
-  const changes = [];
-  const infos = [];
-  const alignment = alignDocuments(docA, docB);
-  let tableIndex = 0;
-  let listIndex = 0;
-  let paragraphIndex = 0;
-  for (const inserted of alignment.insertions) {
-    const node = inserted.node;
-    const sharedId = v4();
-    const date = (/* @__PURE__ */ new Date()).toISOString();
-    let type = "paragraphInsert";
-    let location = "";
-    let preview = "";
-    if (isTable(node)) {
-      type = "rowInsert";
-      location = `New table at position ${inserted.path[0] + 1}`;
-      preview = `Table with ${node.content?.length || 0} rows`;
-      tableIndex++;
-    } else if (isList(node)) {
-      type = "listItemInsert";
-      location = `New list at position ${inserted.path[0] + 1}`;
-      preview = `List with ${node.content?.length || 0} items`;
-      listIndex++;
-    } else {
-      type = "paragraphInsert";
-      paragraphIndex++;
-      location = `Paragraph ${paragraphIndex}`;
-      preview = extractTextPreview2(node);
-    }
-    changes.push({
-      id: sharedId,
-      type,
-      nodeType: node.type,
-      path: inserted.path,
-      node: markAllTextAsInserted2(cloneNode3(node), sharedId, author)
-    });
-    infos.push({
-      id: sharedId,
-      type,
-      nodeType: node.type,
-      location,
-      preview,
-      author,
-      date
-    });
-  }
-  for (const deleted of alignment.deletions) {
-    const node = deleted.node;
-    const sharedId = v4();
-    const date = (/* @__PURE__ */ new Date()).toISOString();
-    let type = "paragraphDelete";
-    let location = "";
-    let preview = "";
-    if (isTable(node)) {
-      type = "rowDelete";
-      location = `Deleted table at position ${deleted.path[0] + 1}`;
-      preview = `Table with ${node.content?.length || 0} rows`;
-    } else if (isList(node)) {
-      type = "listItemDelete";
-      location = `Deleted list at position ${deleted.path[0] + 1}`;
-      preview = `List with ${node.content?.length || 0} items`;
-    } else {
-      type = "paragraphDelete";
-      location = `Deleted paragraph`;
-      preview = extractTextPreview2(node);
-    }
-    changes.push({
-      id: sharedId,
-      type,
-      nodeType: node.type,
-      path: deleted.path,
-      node: markAllTextAsDeleted2(cloneNode3(node), sharedId, author)
-    });
-    infos.push({
-      id: sharedId,
-      type,
-      nodeType: node.type,
-      location,
-      preview,
-      author,
-      date
-    });
-  }
-  for (const match of alignment.matched) {
-    const nodeA = docA.content?.[match.pathA[0]];
-    const nodeB = docB.content?.[match.pathB[0]];
-    if (!nodeA || !nodeB) continue;
-    if (isTable(nodeA) && isTable(nodeB)) {
-      tableIndex++;
-      const tableResult = diffTables(nodeA, nodeB, match.pathA, match.pathB);
-      for (const rowChange of tableResult.rowChanges) {
-        const sharedId = rowChange.id;
-        const date = (/* @__PURE__ */ new Date()).toISOString();
-        const rowIndex = rowChange.path[rowChange.path.length - 1];
-        const isInsert = rowChange.type === "rowInsert";
-        const location = getRowLocation(rowChange.path, rowIndex, tableIndex - 1);
-        const preview = getRowPreview(rowChange.node);
-        const markedNode = isInsert ? markAllTextAsInserted2(cloneNode3(rowChange.node), sharedId, author) : markAllTextAsDeleted2(cloneNode3(rowChange.node), sharedId, author);
-        changes.push({
-          ...rowChange,
-          node: markedNode
-        });
-        infos.push({
-          id: sharedId,
-          type: rowChange.type,
-          nodeType: "tableRow",
-          location,
-          preview,
-          author,
-          date
-        });
-      }
-    }
-    if (isList(nodeA) && isList(nodeB)) {
-      listIndex++;
-      const listResult = diffLists(nodeA, nodeB, match.pathA, match.pathB);
-      for (const itemChange of listResult.itemChanges) {
-        const sharedId = itemChange.id;
-        const date = (/* @__PURE__ */ new Date()).toISOString();
-        const itemIndex = itemChange.path[itemChange.path.length - 1];
-        const isInsert = itemChange.type === "listItemInsert";
-        const location = getListItemLocation(itemChange.path, itemIndex, listIndex - 1);
-        const preview = getListItemPreview(itemChange.node);
-        const markedNode = isInsert ? markAllTextAsInserted2(cloneNode3(itemChange.node), sharedId, author) : markAllTextAsDeleted2(cloneNode3(itemChange.node), sharedId, author);
-        changes.push({
-          ...itemChange,
-          node: markedNode
-        });
-        infos.push({
-          id: sharedId,
-          type: itemChange.type,
-          nodeType: "listItem",
-          location,
-          preview,
-          author,
-          date
-        });
-      }
-    }
-  }
-  const imageChanges = diffImages(docA, docB);
-  for (const imgInsert of imageChanges.inserted) {
-    const sharedId = imgInsert.id;
-    const date = (/* @__PURE__ */ new Date()).toISOString();
-    infos.push({
-      id: sharedId,
-      type: "imageInsert",
-      nodeType: "image",
-      location: getImageLocation(imgInsert.path),
-      preview: getImagePreview(imgInsert.node),
-      author,
-      date
-    });
-    changes.push(imgInsert);
-  }
-  for (const imgDelete of imageChanges.deleted) {
-    const sharedId = imgDelete.id;
-    const date = (/* @__PURE__ */ new Date()).toISOString();
-    infos.push({
-      id: sharedId,
-      type: "imageDelete",
-      nodeType: "image",
-      location: getImageLocation(imgDelete.path),
-      preview: getImagePreview(imgDelete.node),
-      author,
-      date
-    });
-    changes.push(imgDelete);
-  }
-  return { changes, infos };
-}
-function generateStructuralChangeSummary(infos) {
-  const summary = [];
-  const rowInserts = infos.filter((i) => i.type === "rowInsert").length;
-  const rowDeletes = infos.filter((i) => i.type === "rowDelete").length;
-  const paragraphInserts = infos.filter((i) => i.type === "paragraphInsert").length;
-  const paragraphDeletes = infos.filter((i) => i.type === "paragraphDelete").length;
-  const listItemInserts = infos.filter((i) => i.type === "listItemInsert").length;
-  const listItemDeletes = infos.filter((i) => i.type === "listItemDelete").length;
-  const imageInserts = infos.filter((i) => i.type === "imageInsert").length;
-  const imageDeletes = infos.filter((i) => i.type === "imageDelete").length;
-  if (rowInserts > 0) summary.push(`${rowInserts} row(s) inserted`);
-  if (rowDeletes > 0) summary.push(`${rowDeletes} row(s) deleted`);
-  if (paragraphInserts > 0) summary.push(`${paragraphInserts} paragraph(s) inserted`);
-  if (paragraphDeletes > 0) summary.push(`${paragraphDeletes} paragraph(s) deleted`);
-  if (listItemInserts > 0) summary.push(`${listItemInserts} list item(s) inserted`);
-  if (listItemDeletes > 0) summary.push(`${listItemDeletes} list item(s) deleted`);
-  if (imageInserts > 0) summary.push(`${imageInserts} image(s) inserted`);
-  if (imageDeletes > 0) summary.push(`${imageDeletes} image(s) deleted`);
-  return summary;
-}
 
 // src/blankTemplate.ts
 var BLANK_DOCX_BASE64 = `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`;