@ansonlai/docx-redline-js 0.5.0 → 0.5.2

package/dist/docx-redline-js.esm.js

@@ -1,4 +1,4 @@
-// @ansonlai/docx-redline-js v0.5.0 — https://github.com/AnsonLai/docx-redline-js
+// @ansonlai/docx-redline-js v0.5.2 — https://github.com/AnsonLai/docx-redline-js
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -2634,6 +2634,17 @@ function computeWordDiffs(originalText, newText, options = {}) {
   }
   return decodeBmpDiffs(charDiffs, wordArray);
 }
+function computeInsertionOnlyDiffs(originalText, newText) {
+  if (originalText === newText) return [[0, originalText]];
+  if (!originalText) return [[1, newText]];
+  let originalIndex = 0;
+  for (let modifiedIndex = 0; modifiedIndex < newText.length && originalIndex < originalText.length; modifiedIndex++) {
+    if (newText[modifiedIndex] === originalText[originalIndex]) originalIndex++;
+  }
+  if (originalIndex !== originalText.length) return null;
+  const diffs = createDiffEngine().diff_main(originalText, newText);
+  return diffs.some(([op]) => op === -1) ? null : diffs;
+}
 function computeWordLevelDiffOps(originalText, newText, options = {}) {
   if (originalText === newText) {
     return [{
@@ -5879,7 +5890,26 @@ function describeInsertionBoundary(spanIndex, pos, fallbackParagraph = null) {
   };
 }
 
+// core/revision-cloning.js
+function refreshRunPropertyChangeIds(root, allocator = null) {
+  if (!root) return root;
+  const xmlDoc = root.nodeType === 9 ? root : root.ownerDocument;
+  const resolvedAllocator = allocator instanceof RevisionIdAllocator ? allocator : getRevisionIdAllocatorForDocument(xmlDoc) || createRevisionIdAllocator(xmlDoc);
+  const candidates = [root, ...Array.from(root.getElementsByTagName?.("*") || [])];
+  for (const node of candidates) {
+    if (!isWordElement(node, "rPrChange")) continue;
+    const nextId = String(resolvedAllocator.next());
+    if (typeof node.setAttributeNS === "function") {
+      node.setAttributeNS(NS_W, "w:id", nextId);
+    } else {
+      node.setAttribute("w:id", nextId);
+    }
+  }
+  return root;
+}
+
 // engine/surgical-run-splitting.js
+var TRACK_CHANGE_CARRIERS = /* @__PURE__ */ new Set(["ins"]);
 function getRunContentPieces(runElement) {
   const pieces = [];
   let offset = 0;
@@ -5928,6 +5958,74 @@ function insertRunPiecesBefore(xmlDoc, parent, referenceNode, pieces, rPr) {
   parent.insertBefore(run, referenceNode);
   return run;
 }
+function splitTrackChangeCarrier(xmlDoc, carrierElement, splitOffset, allocator = null) {
+  const carrierName = getLocalName(carrierElement);
+  if (!TRACK_CHANGE_CARRIERS.has(carrierName)) {
+    throw new TypeError("splitTrackChangeCarrier requires a w:ins carrier.");
+  }
+  if (!Number.isInteger(splitOffset) || splitOffset < 0) {
+    throw new RangeError("splitOffset must be a non-negative integer.");
+  }
+  const children = Array.from(carrierElement.childNodes || []);
+  const totalLength = children.reduce((length, child) => {
+    return length + (isWordElement(child, "r") ? getRunTextLength(getRunContentPieces(child)) : 0);
+  }, 0);
+  if (splitOffset > totalLength) {
+    throw new RangeError(`splitOffset ${splitOffset} exceeds carrier text length ${totalLength}.`);
+  }
+  if (splitOffset === 0) {
+    return { leftCarrier: null, rightCarrier: carrierElement.cloneNode(true) };
+  }
+  if (splitOffset === totalLength) {
+    return { leftCarrier: carrierElement.cloneNode(true), rightCarrier: null };
+  }
+  const leftCarrier = carrierElement.cloneNode(false);
+  const rightCarrier = carrierElement.cloneNode(false);
+  let offset = 0;
+  for (const child of children) {
+    if (!isWordElement(child, "r")) {
+      const destination = offset <= splitOffset ? leftCarrier : rightCarrier;
+      destination.appendChild(child.cloneNode(true));
+      continue;
+    }
+    const pieces = getRunContentPieces(child);
+    const runLength = getRunTextLength(pieces);
+    const runEnd = offset + runLength;
+    if (runEnd <= splitOffset) {
+      leftCarrier.appendChild(child.cloneNode(true));
+    } else if (offset >= splitOffset) {
+      rightCarrier.appendChild(child.cloneNode(true));
+    } else {
+      const localOffset = splitOffset - offset;
+      const rPr = Array.from(child.childNodes || []).find((node) => isWordElement(node, "rPr")) || null;
+      const leftPieces = sliceRunPieces(xmlDoc, pieces, 0, localOffset, false);
+      const rightPieces = sliceRunPieces(xmlDoc, pieces, localOffset, runLength, false);
+      leftCarrier.appendChild(createRunFromPieces(xmlDoc, leftPieces, rPr));
+      const rightRun = createRunFromPieces(xmlDoc, rightPieces, rPr);
+      refreshRunPropertyChangeIds(rightRun, resolveAllocator(xmlDoc, allocator));
+      rightCarrier.appendChild(rightRun);
+    }
+    offset = runEnd;
+  }
+  const resolvedAllocator = resolveAllocator(xmlDoc, allocator);
+  const nextId = resolvedAllocator.next();
+  setWordAttribute(rightCarrier, "id", String(nextId));
+  resolvedAllocator._receiptCollector?.recordRevision(nextId, carrierName);
+  return { leftCarrier, rightCarrier };
+}
+function resolveAllocator(xmlDoc, allocator) {
+  return allocator instanceof RevisionIdAllocator ? allocator : getRevisionIdAllocatorForDocument(xmlDoc) || createRevisionIdAllocator(xmlDoc);
+}
+function setWordAttribute(element, localName2, value) {
+  if (typeof element.setAttributeNS === "function") {
+    element.setAttributeNS(NS_W, `w:${localName2}`, value);
+  } else {
+    element.setAttribute(`w:${localName2}`, value);
+  }
+}
+function getLocalName(element) {
+  return String(element?.localName || element?.nodeName || "").replace(/^.*:/, "");
+}
 function cloneRunPiece(xmlDoc, sourceNode, text, asDeletedText) {
   if (asDeletedText) {
     const delText = createWordElement(xmlDoc, "w:delText");
@@ -6003,8 +6101,7 @@ function processDelete(xmlDoc, spanIndex, startPos, endPos, author, generateRedl
     if (!spansByRun.has(span.runElement)) spansByRun.set(span.runElement, []);
     spansByRun.get(span.runElement).push(span);
   });
-  let changed = false;
-  let usedDelMetadata = false;
+  const records = [];
   spansByRun.forEach((runSpans, runElement) => {
     const parent = runElement.parentNode;
     if (!parent) return;
@@ -6022,24 +6119,84 @@ function processDelete(xmlDoc, spanIndex, startPos, endPos, author, generateRedl
       deleteEnd = Math.max(deleteEnd, piece.start + spanDeleteEnd);
     });
     if (!Number.isFinite(deleteStart) || deleteEnd <= deleteStart) return;
-    const beforePieces = sliceRunPieces(xmlDoc, pieces, 0, deleteStart, false);
-    const deletedPieces = sliceRunPieces(xmlDoc, pieces, deleteStart, deleteEnd, true);
-    const afterPieces = sliceRunPieces(xmlDoc, pieces, deleteEnd, getRunTextLength(pieces), false);
-    insertRunPiecesBefore(xmlDoc, parent, runElement, beforePieces, runSpans[0].rPr);
-    if (generateRedlines && deletedPieces.length > 0) {
-      const delRun = createRunFromPieces(xmlDoc, deletedPieces, runSpans[0].rPr);
-      const metadata = revisionMetadata ? usedDelMetadata ? { ...revisionMetadata, id: createRevisionMetadata(author, xmlDoc).id } : revisionMetadata : null;
+    records.push({
+      runElement,
+      parent,
+      rPr: runSpans[0].rPr,
+      beforePieces: sliceRunPieces(xmlDoc, pieces, 0, deleteStart, false),
+      deletedPieces: sliceRunPieces(xmlDoc, pieces, deleteStart, deleteEnd, true),
+      afterPieces: sliceRunPieces(xmlDoc, pieces, deleteEnd, getRunTextLength(pieces), false),
+      globalStart: Math.max(startPos, Math.min(...runSpans.map((span) => span.charStart))),
+      globalEnd: Math.min(endPos, Math.max(...runSpans.map((span) => span.charEnd))),
+      carrierGlobalStart: isWordElement(parent, "ins") ? getCarrierGlobalStart(spanIndex, parent) : null
+    });
+  });
+  const groups = [];
+  for (const record of records) {
+    const previousGroup = groups[groups.length - 1];
+    const previousRecord = previousGroup?.[previousGroup.length - 1];
+    if (previousRecord && previousRecord.parent === record.parent && nextElementSibling(previousRecord.runElement) === record.runElement) {
+      previousGroup.push(record);
+    } else {
+      groups.push([record]);
+    }
+  }
+  let changed = false;
+  let usedDelMetadata = false;
+  for (const group of groups) {
+    const firstRecord = group[0];
+    let delWrapper = null;
+    if (generateRedlines && group.some((record) => record.deletedPieces.length > 0)) {
+      const metadata = revisionMetadata ? usedDelMetadata ? { ...revisionMetadata, id: createRevisionMetadata(author, xmlDoc, "del").id } : revisionMetadata : null;
       usedDelMetadata = true;
-      const delWrapper = createTrackChange(xmlDoc, "del", delRun, author, metadata);
-      parent.insertBefore(delWrapper, runElement);
+      delWrapper = createTrackChange(xmlDoc, "del", null, author, metadata);
+    }
+    for (const record of group) {
+      const { parent, runElement } = record;
+      insertRunPiecesBefore(xmlDoc, parent, runElement, record.beforePieces, record.rPr);
+      if (delWrapper && record === firstRecord) {
+        parent.insertBefore(delWrapper, runElement);
+      }
+      if (delWrapper && record.deletedPieces.length > 0) {
+        delWrapper.appendChild(createRunFromPieces(xmlDoc, record.deletedPieces, record.rPr));
+      }
+      insertRunPiecesBefore(xmlDoc, parent, runElement, record.afterPieces, record.rPr);
+      parent.removeChild(runElement);
+      changed = true;
+    }
+    const carrier = isWordElement(firstRecord.parent, "ins") ? firstRecord.parent : null;
+    const groupEnd = Math.max(...group.map((record) => record.globalEnd));
+    if (carrier && groupEnd === endPos) {
+      const carrierStart = firstRecord.carrierGlobalStart;
+      const deletedBeforeEnd = group.filter((record) => record.globalStart < endPos).reduce((sum, record) => sum + record.deletedPieces.reduce((n, piece) => n + (piece.textContent || "").length, 0), 0);
+      const currentOffset = Math.max(0, endPos - carrierStart - deletedBeforeEnd);
+      if (!spanIndex.revisionInsertionAnchors) spanIndex.revisionInsertionAnchors = /* @__PURE__ */ new Map();
+      spanIndex.revisionInsertionAnchors.set(endPos, {
+        carrier,
+        splitOffset: currentOffset,
+        rPr: firstRecord.rPr
+      });
     }
-    insertRunPiecesBefore(xmlDoc, parent, runElement, afterPieces, runSpans[0].rPr);
-    parent.removeChild(runElement);
-    changed = true;
-  });
+  }
   return changed;
 }
-function processInsert(xmlDoc, spanIndex, pos, text, author, formatHints = [], insertOffset = 0, generateRedlines = true, fallbackParagraph = null, revisionMetadata = null, affinity = null) {
+function processInsert(xmlDoc, spanIndex, pos, text, author, formatHints = [], insertOffset = 0, generateRedlines = true, fallbackParagraph = null, revisionMetadata = null, affinity = null, existingRevisions = "merge-same-author") {
+  const mutationAnchor = spanIndex.revisionInsertionAnchors?.get(pos) || null;
+  if (mutationAnchor && existingRevisions === "slice-cross-author" && isConnected(mutationAnchor.carrier) && isForeignInsertion(mutationAnchor.carrier, author)) {
+    spanIndex.revisionInsertionAnchors.delete(pos);
+    return spliceInsertionAtCarrierOffset(
+      xmlDoc,
+      mutationAnchor.carrier,
+      mutationAnchor.splitOffset,
+      text,
+      mutationAnchor.rPr,
+      author,
+      formatHints,
+      insertOffset,
+      generateRedlines,
+      revisionMetadata
+    );
+  }
   if (!affinity) {
     let targetSpan = findContainingSpan(spanIndex, pos);
     if (!targetSpan && pos > 0) {
@@ -6062,6 +6219,21 @@ function processInsert(xmlDoc, spanIndex, pos, text, author, formatHints = [], i
       insertTextRuns(xmlDoc, fallbackParagraph, null, text, targetSpan.rPr, author, formatHints, insertOffset, generateRedlines, revisionMetadata);
       return true;
     }
+    const generateNestedRevision = !(generateRedlines && existingRevisions === "slice-cross-author" && isSameAuthorInsertion(parent2, author));
+    if (generateRedlines && existingRevisions === "slice-cross-author" && isForeignInsertion(parent2, author)) {
+      return spliceInsertionAtCarrierOffset(
+        xmlDoc,
+        parent2,
+        getCarrierSplitOffset(spanIndex, parent2, pos),
+        text,
+        targetSpan.rPr,
+        author,
+        formatHints,
+        insertOffset,
+        generateRedlines,
+        revisionMetadata
+      );
+    }
     const pieces = getRunContentPieces(targetSpan.runElement);
     const targetPiece = pieces.find((piece) => piece.node === targetSpan.textElement);
     const localInsertPos = targetPiece ? targetPiece.start + Math.max(0, Math.min(pos - targetSpan.charStart, targetSpan.charEnd - targetSpan.charStart)) : pos <= targetSpan.charStart ? 0 : getRunTextLength(pieces);
@@ -6069,13 +6241,13 @@ function processInsert(xmlDoc, spanIndex, pos, text, author, formatHints = [], i
       const beforePieces = sliceRunPieces(xmlDoc, pieces, 0, localInsertPos, false);
       const afterPieces = sliceRunPieces(xmlDoc, pieces, localInsertPos, getRunTextLength(pieces), false);
       insertRunPiecesBefore(xmlDoc, parent2, targetSpan.runElement, beforePieces, targetSpan.rPr);
-      insertTextRuns(xmlDoc, parent2, targetSpan.runElement, text, targetSpan.rPr, author, formatHints, insertOffset, generateRedlines, revisionMetadata);
+      insertTextRuns(xmlDoc, parent2, targetSpan.runElement, text, targetSpan.rPr, author, formatHints, insertOffset, generateNestedRevision, revisionMetadata);
       insertRunPiecesBefore(xmlDoc, parent2, targetSpan.runElement, afterPieces, targetSpan.rPr);
       parent2.removeChild(targetSpan.runElement);
       return true;
     }
     const referenceNode2 = pos <= targetSpan.charStart ? targetSpan.runElement : targetSpan.runElement.nextSibling;
-    insertTextRuns(xmlDoc, parent2, referenceNode2, text, targetSpan.rPr, author, formatHints, insertOffset, generateRedlines, revisionMetadata);
+    insertTextRuns(xmlDoc, parent2, referenceNode2, text, targetSpan.rPr, author, formatHints, insertOffset, generateNestedRevision, revisionMetadata);
     return true;
   }
   const boundary = describeInsertionBoundary(spanIndex, pos, fallbackParagraph);
@@ -6224,9 +6396,78 @@ function processInsert(xmlDoc, spanIndex, pos, text, author, formatHints = [], i
       return true;
     }
   }
+  if (generateRedlines && existingRevisions === "slice-cross-author" && isForeignInsertion(parent, author)) {
+    return spliceInsertionAtCarrierOffset(
+      xmlDoc,
+      parent,
+      getCarrierSplitOffset(spanIndex, parent, pos),
+      text,
+      baseRPr,
+      author,
+      formatHints,
+      insertOffset,
+      generateRedlines,
+      revisionMetadata
+    );
+  }
   insertTextRuns(xmlDoc, parent, referenceNode, text, baseRPr, author, formatHints, insertOffset, generateRedlines, revisionMetadata);
   return true;
 }
+function spliceInsertionAtCarrierOffset(xmlDoc, carrier, splitOffset, text, baseRPr, author, formatHints, insertOffset, generateRedlines, revisionMetadata) {
+  const parent = carrier.parentNode;
+  if (!parent) return false;
+  const { leftCarrier, rightCarrier } = splitTrackChangeCarrier(xmlDoc, carrier, splitOffset);
+  if (leftCarrier) parent.insertBefore(leftCarrier, carrier);
+  insertTextRuns(
+    xmlDoc,
+    parent,
+    carrier,
+    text,
+    withoutRunPropertyChanges(baseRPr),
+    author,
+    formatHints,
+    insertOffset,
+    generateRedlines,
+    revisionMetadata
+  );
+  if (rightCarrier) parent.insertBefore(rightCarrier, carrier);
+  parent.removeChild(carrier);
+  return true;
+}
+function withoutRunPropertyChanges(rPr) {
+  if (!rPr) return null;
+  const clone = rPr.cloneNode(true);
+  const changes = Array.from(clone.getElementsByTagName?.("*") || []).filter((node) => isWordElement(node, "rPrChange"));
+  changes.forEach((node) => node.parentNode?.removeChild(node));
+  return clone;
+}
+function getCarrierSplitOffset(spanIndex, carrier, pos) {
+  const carrierStart = getCarrierGlobalStart(spanIndex, carrier);
+  const carrierLength = spanIndex.spans.filter((span) => span.runElement?.parentNode === carrier).reduce((length, span) => length + (span.charEnd - span.charStart), 0);
+  return Math.max(0, Math.min(pos - carrierStart, carrierLength));
+}
+function getCarrierGlobalStart(spanIndex, carrier) {
+  const carrierSpans = spanIndex.spans.filter((span) => span.runElement?.parentNode === carrier);
+  return carrierSpans.length > 0 ? Math.min(...carrierSpans.map((span) => span.charStart)) : 0;
+}
+function isForeignInsertion(node, author) {
+  if (!isWordElement(node, "ins")) return false;
+  const carrierAuthor = node.getAttribute("w:author") || node.getAttributeNS?.(NS_W, "author") || "";
+  return carrierAuthor.trim().toLowerCase() !== String(author || "").trim().toLowerCase();
+}
+function isSameAuthorInsertion(node, author) {
+  if (!isWordElement(node, "ins")) return false;
+  const carrierAuthor = node.getAttribute("w:author") || node.getAttributeNS?.(NS_W, "author") || "";
+  return carrierAuthor.trim().toLowerCase() === String(author || "").trim().toLowerCase();
+}
+function nextElementSibling(node) {
+  let sibling = node?.nextSibling || null;
+  while (sibling && sibling.nodeType !== 1) sibling = sibling.nextSibling;
+  return sibling;
+}
+function isConnected(node) {
+  return !!node?.parentNode;
+}
 function insertTextRuns(xmlDoc, parent, referenceNode, text, baseRPr, author, formatHints, insertOffset, generateRedlines, revisionMetadata = null) {
   const applicableHints = getApplicableFormatHints(formatHints, insertOffset, insertOffset + text.length);
   if (applicableHints.length === 0) {
@@ -6250,7 +6491,7 @@ function insertTextRuns(xmlDoc, parent, referenceNode, text, baseRPr, author, fo
 }
 
 // engine/surgical-mode.js
-function checkSafeAdjacencyForPairing(spanIndex, startPos, endPos) {
+function checkSafeAdjacencyForPairing(spanIndex, startPos, endPos, allowInsertionCarrier = false) {
   const spans = [];
   forEachOverlappingSpan(spanIndex, startPos, endPos, (span) => spans.push(span));
   if (spans.length === 0) return { safe: false };
@@ -6260,7 +6501,7 @@ function checkSafeAdjacencyForPairing(spanIndex, startPos, endPos) {
   const sameParent = spans.every((s) => s.runElement?.parentNode === parent);
   if (!sameParent) return { safe: false, structuralBoundary: true };
   const parentLocal = parent.localName || parent.nodeName.replace(/^.*:/, "");
-  if (["hyperlink", "sdt", "ins", "del", "moveFrom", "moveTo"].includes(parentLocal)) {
+  if (["hyperlink", "sdt", "del", "moveFrom", "moveTo"].includes(parentLocal) || parentLocal === "ins" && !allowInsertionCarrier) {
     return { safe: false, structuralBoundary: true };
   }
   const structuralTags = /* @__PURE__ */ new Set([
@@ -6317,7 +6558,8 @@ function applySurgicalMode(xmlDoc, originalText, modifiedText, serializer, autho
   void originalText;
   const allParagraphs = targetParagraph ? [targetParagraph] : getDocumentParagraphs(xmlDoc);
   const { fullText, textSpans } = buildSurgicalTextSpans(allParagraphs);
-  const diffs = computeWordDiffs(fullText, modifiedText, diffOptions);
+  const insertionOnlyDiffs = options.existingRevisions === "slice-cross-author" ? computeInsertionOnlyDiffs(fullText, modifiedText) : null;
+  const diffs = insertionOnlyDiffs || computeWordDiffs(fullText, modifiedText, diffOptions);
   const spanIndex = buildSpanIndex(textSpans);
   const pairReplacements = options.pairReplacements === true;
   const warnings = [];
@@ -6352,8 +6594,13 @@ function applySurgicalMode(xmlDoc, originalText, modifiedText, serializer, autho
       if (pairReplacements && generateRedlines && hasNextInsert) {
         const nextText = diffs[i + 1][1];
         const textWithoutNewlines = nextText.replace(/\n/g, " ");
-        if (textWithoutNewlines.trim().length > 0) {
-          const checkResult = checkSafeAdjacencyForPairing(spanIndex, originalPos, originalPos + text.length);
+        if (textWithoutNewlines.length > 0) {
+          const checkResult = checkSafeAdjacencyForPairing(
+            spanIndex,
+            originalPos,
+            originalPos + text.length,
+            options?.existingRevisions === "slice-cross-author"
+          );
           if (checkResult.safe) {
             const event = createReplacementRevisionEvent(author, xmlDoc);
             delMetadata = { id: event.deletionId, author: event.author, date: event.date };
@@ -6372,8 +6619,8 @@ function applySurgicalMode(xmlDoc, originalText, modifiedText, serializer, autho
         i++;
         const [, nextText] = diffs[i];
         const textWithoutNewlines = nextText.replace(/\n/g, " ");
-        if (textWithoutNewlines.trim().length > 0) {
-          const insertResult = processInsert(xmlDoc, spanIndex, originalPos, textWithoutNewlines, author, formatHints, newPos, generateRedlines, allParagraphs[0] || null, insMetadata, options?.insertionAffinity || null);
+        if (textWithoutNewlines.length > 0) {
+          const insertResult = processInsert(xmlDoc, spanIndex, originalPos, textWithoutNewlines, author, formatHints, newPos, generateRedlines, allParagraphs[0] || null, insMetadata, options?.insertionAffinity || null, options?.existingRevisions || "merge-same-author");
           if (insertResult && typeof insertResult === "object" && insertResult.error) {
             return withOoxmlSourceType({
               oxml: serializer.serializeToString(xmlDoc),
@@ -6390,8 +6637,8 @@ function applySurgicalMode(xmlDoc, originalText, modifiedText, serializer, autho
       }
     } else if (op === 1) {
       const textWithoutNewlines = text.replace(/\n/g, " ");
-      if (textWithoutNewlines.trim().length > 0) {
-        const insertResult = processInsert(xmlDoc, spanIndex, originalPos, textWithoutNewlines, author, formatHints, newPos, generateRedlines, allParagraphs[0] || null, null, options?.insertionAffinity || null);
+      if (textWithoutNewlines.length > 0) {
+        const insertResult = processInsert(xmlDoc, spanIndex, originalPos, textWithoutNewlines, author, formatHints, newPos, generateRedlines, allParagraphs[0] || null, null, options?.insertionAffinity || null, options?.existingRevisions || "merge-same-author");
         if (insertResult && typeof insertResult === "object" && insertResult.error) {
           return withOoxmlSourceType({
             oxml: serializer.serializeToString(xmlDoc),
@@ -6407,12 +6654,42 @@ function applySurgicalMode(xmlDoc, originalText, modifiedText, serializer, autho
       newPos += text.length;
     }
   }
+  const actualText = allParagraphs.map((paragraph) => extractCanonicalParagraphText(paragraph)).join("\n");
+  const expectedText = String(modifiedText).replace(/\r\n/g, "\n");
+  if (options.existingRevisions === "slice-cross-author" && actualText !== expectedText) {
+    const mismatchOffset = firstMismatchOffset(expectedText, actualText);
+    return withOoxmlSourceType({
+      oxml: serializer.serializeToString(xmlDoc),
+      hasChanges: false,
+      status: "error",
+      error: {
+        code: "PATCH_ROUNDTRIP_MISMATCH",
+        message: "Generated OOXML accepted-view text does not match the requested modified text; the mutation was rejected.",
+        mismatchOffset,
+        expectedExcerpt: excerptAt(expectedText, mismatchOffset),
+        actualExcerpt: excerptAt(actualText, mismatchOffset)
+      },
+      ...warnings.length > 0 ? { warnings: [...new Set(warnings)] } : {}
+    });
+  }
   return withOoxmlSourceType({
     oxml: serializer.serializeToString(xmlDoc),
     hasChanges,
     ...warnings.length > 0 ? { warnings: [...new Set(warnings)] } : {}
   });
 }
+function firstMismatchOffset(expected, actual) {
+  const limit = Math.min(expected.length, actual.length);
+  for (let index = 0; index < limit; index++) {
+    if (expected[index] !== actual[index]) return index;
+  }
+  return limit;
+}
+function excerptAt(text, offset, radius = 40) {
+  const start = Math.max(0, offset - radius);
+  const end = Math.min(text.length, offset + radius);
+  return text.slice(start, end);
+}
 
 // engine/reconstruction-mapper.js
 var import_diff_match_patch2 = __toESM(require_diff_match_patch(), 1);
@@ -7380,6 +7657,30 @@ function unwrapNode(node) {
   parent.removeChild(node);
   return true;
 }
+function nextElementSibling2(node) {
+  let sibling = node?.nextSibling || null;
+  while (sibling && sibling.nodeType !== 1) sibling = sibling.nextSibling;
+  return sibling;
+}
+function revisionMetadataWithoutId(node) {
+  return Array.from(node?.attributes || []).filter((attribute) => String(attribute.localName || attribute.name || "").toLowerCase() !== "id").map((attribute) => `${attribute.namespaceURI || ""}|${attribute.localName || attribute.name}=${attribute.value}`).sort().join("\n");
+}
+function coalesceAdjacentCompatibleInsertions(xmlDoc) {
+  let coalesced = 0;
+  const insertions = getWordElementsByLocalName(xmlDoc, "ins");
+  for (const insertion of insertions) {
+    if (!insertion.parentNode || isParagraphMarkRevisionMarker(insertion)) continue;
+    let sibling = nextElementSibling2(insertion);
+    while (isWordElement5(sibling, "ins") && normalizeAuthor(getAttributeByLocalName(sibling, "author")) === normalizeAuthor(getAttributeByLocalName(insertion, "author")) && revisionMetadataWithoutId(sibling) === revisionMetadataWithoutId(insertion)) {
+      const next = nextElementSibling2(sibling);
+      while (sibling.firstChild) insertion.appendChild(sibling.firstChild);
+      sibling.parentNode?.removeChild(sibling);
+      coalesced += 1;
+      sibling = next;
+    }
+  }
+  return coalesced;
+}
 function isTableRowRevisionMarker(node) {
   const parent = node?.parentNode;
   return isWordElement5(parent, "trPr") && isWordElement5(parent?.parentNode, "tr");
@@ -7627,6 +7928,7 @@ function rejectTrackedChangesInOoxml(oxml, options = {}) {
       if (rejectPropertyChangeNode(changeNode, localName2)) rejectedCount += 1;
     }
   }
+  coalesceAdjacentCompatibleInsertions(xmlDoc);
   const serializedOxml = parseResult.isFragmentWrapped ? Array.from(xmlDoc.documentElement.childNodes).map((n) => serializer.serializeToString(n)).join("") : serializer.serializeToString(xmlDoc);
   return {
     oxml: serializedOxml,
@@ -7778,7 +8080,7 @@ async function applyRedlineToOxml(oxml, originalText, modifiedText, options = {}
   const finalize = (result) => {
     const withStatus = { ...result };
     if (normalizedExistingRevisions && withStatus.hasChanges === false && withStatus.status !== "error") {
-      if (existingRevisionsPolicy === "merge-same-author") {
+      if (existingRevisionsPolicy === "merge-same-author" || existingRevisionsPolicy === "slice-cross-author") {
         withStatus.oxml = workingOoxml;
         withStatus.hasChanges = true;
         withStatus.warnings = [
@@ -7832,7 +8134,7 @@ async function applyRedlineToOxml(oxml, originalText, modifiedText, options = {}
   const revisionIdAllocator = options?._revisionIdAllocator instanceof RevisionIdAllocator ? options._revisionIdAllocator : new RevisionIdAllocator();
   seedRevisionIdsFromDocument(xmlDoc, revisionIdAllocator);
   if (containsTrackedChanges(xmlDoc)) {
-    if (existingRevisionsPolicy === "merge-same-author") {
+    if (existingRevisionsPolicy === "merge-same-author" || existingRevisionsPolicy === "slice-cross-author") {
       const authors = getTrackedChangeAuthors(xmlDoc);
       const currentAuthor = String(author || "").trim().toLowerCase();
       const isSameAuthor = authors.length > 0 && authors.every((a) => a.trim().toLowerCase() === currentAuthor);
@@ -7887,7 +8189,7 @@ async function applyRedlineToOxml(oxml, originalText, modifiedText, options = {}
         const paragraphsInDoc = xmlDoc.documentElement && String(xmlDoc.documentElement.localName || "").toLowerCase() === "p" ? [xmlDoc.documentElement] : getDocumentParagraphs(xmlDoc);
         const baselineText = paragraphsInDoc.length > 0 ? paragraphsInDoc.map((p) => extractCanonicalParagraphText(p)).join("\n") : "";
         originalText = baselineText;
-      } else {
+      } else if (existingRevisionsPolicy === "merge-same-author") {
         log("[OxmlEngine] Existing revisions detected from another/unattributed author; refusing per merge-same-author policy");
         return finalize({
           oxml: inputOoxml,
@@ -7898,6 +8200,22 @@ async function applyRedlineToOxml(oxml, originalText, modifiedText, options = {}
             message: `Input OOXML contains tracked changes from another author (${authors.length ? authors.join(", ") : "unattributed"}). Pass existingRevisions: "accept-all-first" or resolve revisions first.`
           }
         });
+      } else {
+        const hasMoveRevision = ["moveFrom", "moveTo"].some((localName2) => {
+          return getElementsByTagNSOrTag(xmlDoc, NS_W, localName2).length > 0;
+        });
+        if (hasMoveRevision) {
+          return finalize({
+            oxml: inputOoxml,
+            hasChanges: false,
+            status: "error",
+            error: {
+              code: "UNSAFE_REVISION_NESTING",
+              message: "Cross-author slicing does not support pending move revisions."
+            }
+          });
+        }
+        log("[OxmlEngine] Existing revisions retained for cross-author surgical slicing");
       }
     } else if (existingRevisionsPolicy === "accept-all-first" || existingRevisionsPolicy === "accept-all-first-keep-normalized") {
       log("[OxmlEngine] Existing revisions detected; accepting all input revisions before redlining");
@@ -7973,7 +8291,7 @@ async function applyRedlineToOxml(oxml, originalText, modifiedText, options = {}
     }
   }
   const { cleanText: cleanModifiedText, formatHints } = preprocessMarkdown(sanitizedText);
-  const hasTextChanges = cleanModifiedText.trim() !== originalText.trim();
+  const hasTextChanges = existingRevisionsPolicy === "slice-cross-author" ? cleanModifiedText !== originalText : cleanModifiedText.trim() !== originalText.trim();
   const hasFormatHints = formatHints.length > 0;
   const { existingFormatHints, textSpans, paragraphs } = extractFormattingFromOoxml(xmlDoc);
   const hasExistingFormatting = existingFormatHints.length > 0;
@@ -8096,7 +8414,8 @@ async function applyRedlineToOxml(oxml, originalText, modifiedText, options = {}
   const isTargetList = isListTargetLoose(cleanModifiedText);
   const isStructuredContent = options.structuredContent !== false && structuredAnalysis?.requiresStructuredContent === true;
   const tableCellContext = initialTableCellContext;
-  log(`[OxmlEngine] Mode: ${hasTables ? "SURGICAL" : "RECONSTRUCTION"}, formatHints: ${formatHints.length}, isMarkdownTable: ${isMarkdownTable}, isTargetList: ${isTargetList}, isTableCellParagraph: ${tableCellContext.isTableCellParagraph}`);
+  const usesSurgicalTextMode = hasTables || existingRevisionsPolicy === "slice-cross-author";
+  log(`[OxmlEngine] Mode: ${usesSurgicalTextMode ? "SURGICAL" : "RECONSTRUCTION"}, formatHints: ${formatHints.length}, isMarkdownTable: ${isMarkdownTable}, isTargetList: ${isTargetList}, isTableCellParagraph: ${tableCellContext.isTableCellParagraph}`);
   try {
     if (isMarkdownTable && !hasTables) {
       recordRouteSelection(options, "table", { transformation: "text-to-table" });
@@ -8107,8 +8426,8 @@ async function applyRedlineToOxml(oxml, originalText, modifiedText, options = {}
       recordRouteSelection(options, "table", { transformation: "table-reconciliation" });
       return finalize(applyTableReconciliation(xmlDoc, cleanModifiedText, serializer, null, author, generateRedlines));
     }
-    if (hasTables) {
-      recordRouteSelection(options, "surgical", { tableScoped: true });
+    if (usesSurgicalTextMode) {
+      recordRouteSelection(options, "surgical", { tableScoped: hasTables });
       const surgicalTarget = tableCellContext.hasTableWrapper && tableCellContext.targetParagraph ? tableCellContext.targetParagraph : null;
       if (surgicalTarget) {
         log("[OxmlEngine] Table cell edit: scoping surgical mode to target paragraph");
@@ -8125,6 +8444,9 @@ async function applyRedlineToOxml(oxml, originalText, modifiedText, options = {}
         {},
         options
       );
+      if (result.status === "error" && result.error?.code === "PATCH_ROUNDTRIP_MISMATCH") {
+        return finalize({ ...result, oxml: inputOoxml, hasChanges: false });
+      }
       if (tableCellContext.hasTableWrapper && result.hasChanges && tableCellContext.targetParagraph) {
         log("[OxmlEngine] Stripping table wrapper for table cell paragraph (surgical mode)");
         return finalize({ oxml: serializeParagraphOnly(xmlDoc, tableCellContext.targetParagraph, serializer), hasChanges: true });
@@ -9611,11 +9933,15 @@ function validateRedlineOoxml(oxml) {
   }
   for (const revision of revisions) {
     const nested = Array.from(revision.getElementsByTagName("*")).filter((el) => el !== revision && ["ins", "del"].includes(localNameOf2(el)));
-    if (nested.length > 0) {
+    const invalidNested = nested.find((candidate) => {
+      if (localNameOf2(revision) !== "ins" || localNameOf2(candidate) !== "del") return true;
+      return candidate.parentNode !== revision;
+    });
+    if (invalidNested) {
       addIssue(
         "NESTED_REVISION",
         "error",
-        `<${revision.nodeName}> (w:id="${wordAttribute2(revision, "id")}") contains nested <${nested[0].nodeName}>.`
+        `<${revision.nodeName}> (w:id="${wordAttribute2(revision, "id")}") contains invalid nested <${invalidNested.nodeName}>.`
       );
     }
   }
@@ -10804,24 +11130,6 @@ function buildCommentsExtendedPartXml(entries) {
   return `<w15:commentsEx xmlns:w15="${NS_W15}">${body}</w15:commentsEx>`;
 }
 
-// core/revision-cloning.js
-function refreshRunPropertyChangeIds(root, allocator = null) {
-  if (!root) return root;
-  const xmlDoc = root.nodeType === 9 ? root : root.ownerDocument;
-  const resolvedAllocator = allocator instanceof RevisionIdAllocator ? allocator : getRevisionIdAllocatorForDocument(xmlDoc) || createRevisionIdAllocator(xmlDoc);
-  const candidates = [root, ...Array.from(root.getElementsByTagName?.("*") || [])];
-  for (const node of candidates) {
-    if (!isWordElement(node, "rPrChange")) continue;
-    const nextId = String(resolvedAllocator.next());
-    if (typeof node.setAttributeNS === "function") {
-      node.setAttributeNS(NS_W, "w:id", nextId);
-    } else {
-      node.setAttribute("w:id", nextId);
-    }
-  }
-  return root;
-}
-
 // services/comment-locator.js
 function createParagraphTextIndex(paragraph, options = {}) {
   const revisionView = options.revisionView === "current" ? "accepted" : options.revisionView || "accepted";