@ansonlai/docx-redline-js 0.5.0 → 0.5.2

package/engine/oxml-engine.js

@@ -61,7 +61,7 @@ function getCommentIdsInOoxml(node) {
  * @param {Object} [options={}] - Options
  * @param {string} [options.author='AI'] - Author for track changes
  * @param {string|null} [options.targetParagraphId=null] - Preferred paragraph identity for table wrappers
- * @param {'merge-same-author'|'reject-input'|'accept-all-first'|'accept-all-first-keep-normalized'} [options.existingRevisions='merge-same-author'] - Policy for source OOXML with tracked changes
+ * @param {'merge-same-author'|'slice-cross-author'|'reject-input'|'accept-all-first'|'accept-all-first-keep-normalized'} [options.existingRevisions='merge-same-author'] - Policy for source OOXML with tracked changes
  * @param {boolean} [options.removeFormatting=false] - Remove existing core formatting when text is otherwise unchanged
  * @param {boolean} [options.sanitizeInput=false] - Strip a standalone leading assistant preface line
  * @returns {Promise<{ oxml: string, hasChanges: boolean, sourceType?: 'package'|'document'|'fragment', status?: 'ok'|'no-op'|'error', error?: { code: string, message: string } }>}
@@ -82,7 +82,7 @@ export async function applyRedlineToOxml(oxml, originalText, modifiedText, optio
     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 = [
@@ -141,7 +141,7 @@ export async function applyRedlineToOxml(oxml, originalText, modifiedText, optio
     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);
@@ -202,8 +202,8 @@ export async function applyRedlineToOxml(oxml, originalText, modifiedText, optio
                     ? paragraphsInDoc.map(p => extractCanonicalParagraphText(p)).join('\n')
                     : '';
                 originalText = baselineText;
-            } else {
-                log('[OxmlEngine] Existing revisions detected from another/unattributed author; refusing per merge-same-author policy');
+            } 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,
                     hasChanges: false,
@@ -213,8 +213,24 @@ export async function applyRedlineToOxml(oxml, originalText, modifiedText, optio
                         message: `Input OOXML contains tracked changes from another author (${authors.length ? authors.join(', ') : 'unattributed'}). Pass existingRevisions: "accept-all-first" or resolve revisions first.`
                     }
                 });
-            }
-        } else if (existingRevisionsPolicy === 'accept-all-first' || existingRevisionsPolicy === 'accept-all-first-keep-normalized') {
+            } else {
+                const hasMoveRevision = ['moveFrom', 'moveTo'].some(localName => {
+                    return getElementsByTagNSOrTag(xmlDoc, NS_W, localName).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');
             const accepted = acceptTrackedChangesInOoxml(inputOoxml, { allAuthors: true });
             if (accepted.status === 'error') return finalize(accepted);
@@ -291,7 +307,9 @@ export async function applyRedlineToOxml(oxml, originalText, modifiedText, optio
     }
     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);
@@ -453,7 +471,8 @@ export async function applyRedlineToOxml(oxml, originalText, modifiedText, optio
     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) {
@@ -466,8 +485,8 @@ export async function applyRedlineToOxml(oxml, originalText, modifiedText, optio
         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;
@@ -475,7 +494,7 @@ export async function applyRedlineToOxml(oxml, originalText, modifiedText, optio
             log('[OxmlEngine] Table cell edit: scoping surgical mode to target paragraph');
         }
 
-        const result = applySurgicalMode(
+        const result = applySurgicalMode(
             xmlDoc,
             originalText,
             cleanModifiedText,
@@ -485,10 +504,14 @@ export async function applyRedlineToOxml(oxml, originalText, modifiedText, optio
             generateRedlines,
             surgicalTarget,
             {},
-            options
-        );
-
-        if (tableCellContext.hasTableWrapper && result.hasChanges && tableCellContext.targetParagraph) {
+            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 });
         }

package/engine/surgical-diff-application.js

@@ -12,7 +12,8 @@ import {
     getRunContentPieces,
     getRunTextLength,
     insertRunPiecesBefore,
-    sliceRunPieces
+    sliceRunPieces,
+    splitTrackChangeCarrier
 } from './surgical-run-splitting.js';
 import {
     findContainingSpan,
@@ -86,8 +87,7 @@ export function processDelete(xmlDoc, spanIndex, startPos, endPos, author, gener
         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;
@@ -111,31 +111,104 @@ export function processDelete(xmlDoc, spanIndex, startPos, endPos, author, gener
 
         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);
+        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
+        });
+    });
 
-        insertRunPiecesBefore(xmlDoc, parent, runElement, beforePieces, runSpans[0].rPr);
+    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]);
+        }
+    }
 
-        if (generateRedlines && deletedPieces.length > 0) {
-            const delRun = createRunFromPieces(xmlDoc, deletedPieces, runSpans[0].rPr);
+    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).id } : 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);
         }
 
-        insertRunPiecesBefore(xmlDoc, parent, runElement, afterPieces, runSpans[0].rPr);
-        parent.removeChild(runElement);
-        changed = true;
-    });
+        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 = new Map();
+            spanIndex.revisionInsertionAnchors.set(endPos, {
+                carrier,
+                splitOffset: currentOffset,
+                rPr: firstRecord.rPr
+            });
+        }
+    }
 
     return changed;
 }
 
-export function processInsert(xmlDoc, spanIndex, pos, text, author, formatHints = [], insertOffset = 0, generateRedlines = true, fallbackParagraph = null, revisionMetadata = null, affinity = null) {
+export 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);
 
@@ -164,6 +237,31 @@ export function processInsert(xmlDoc, spanIndex, pos, text, author, formatHints
             return true;
         }
 
+        const generateNestedRevision = !(
+            generateRedlines
+            && existingRevisions === 'slice-cross-author'
+            && isSameAuthorInsertion(parent, author)
+        );
+
+        if (
+            generateRedlines
+            && existingRevisions === 'slice-cross-author'
+            && isForeignInsertion(parent, author)
+        ) {
+            return spliceInsertionAtCarrierOffset(
+                xmlDoc,
+                parent,
+                getCarrierSplitOffset(spanIndex, parent, 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
@@ -175,14 +273,14 @@ export function processInsert(xmlDoc, spanIndex, pos, text, author, formatHints
             const afterPieces = sliceRunPieces(xmlDoc, pieces, localInsertPos, getRunTextLength(pieces), false);
 
             insertRunPiecesBefore(xmlDoc, parent, targetSpan.runElement, beforePieces, targetSpan.rPr);
-            insertTextRuns(xmlDoc, parent, targetSpan.runElement, text, targetSpan.rPr, author, formatHints, insertOffset, generateRedlines, revisionMetadata);
+            insertTextRuns(xmlDoc, parent, targetSpan.runElement, text, targetSpan.rPr, author, formatHints, insertOffset, generateNestedRevision, revisionMetadata);
             insertRunPiecesBefore(xmlDoc, parent, targetSpan.runElement, afterPieces, targetSpan.rPr);
             parent.removeChild(targetSpan.runElement);
             return true;
         }
 
         const referenceNode = pos <= targetSpan.charStart ? targetSpan.runElement : targetSpan.runElement.nextSibling;
-        insertTextRuns(xmlDoc, parent, referenceNode, text, targetSpan.rPr, author, formatHints, insertOffset, generateRedlines, revisionMetadata);
+        insertTextRuns(xmlDoc, parent, referenceNode, text, targetSpan.rPr, author, formatHints, insertOffset, generateNestedRevision, revisionMetadata);
         return true;
     }
 
@@ -357,10 +455,96 @@ export function processInsert(xmlDoc, spanIndex, pos, text, author, formatHints
         }
     }
 
+    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);
 

package/engine/surgical-mode.js

@@ -6,7 +6,7 @@
  */
 
 import { getApplicableFormatHints } from '../pipeline/markdown-processor.js';
-import { computeWordDiffs } from '../pipeline/diff-engine.js';
+import { computeInsertionOnlyDiffs, computeWordDiffs } from '../pipeline/diff-engine.js';
 import { getDocumentParagraphs } from './format-extraction.js';
 import { buildSpanIndex, buildSurgicalTextSpans, forEachOverlappingSpan } from './surgical-spans.js';
 import {
@@ -16,8 +16,9 @@ import {
 } from './surgical-diff-application.js';
 import { withOoxmlSourceType } from '../core/word-xml.js';
 import { createReplacementRevisionEvent } from '../core/types.js';
+import { extractCanonicalParagraphText } from '../core/paragraph-text.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 };
@@ -32,7 +33,10 @@ function checkSafeAdjacencyForPairing(spanIndex, startPos, endPos) {
 
     // Parent container itself cannot be an existing revision or unsupported container
     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 };
     }
 
@@ -108,7 +112,10 @@ export function applySurgicalMode(xmlDoc, originalText, modifiedText, serializer
         : 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 = [];
@@ -148,8 +155,13 @@ export function applySurgicalMode(xmlDoc, originalText, modifiedText, serializer
             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 };
@@ -170,8 +182,8 @@ export function applySurgicalMode(xmlDoc, originalText, modifiedText, serializer
                 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),
@@ -188,8 +200,8 @@ export function applySurgicalMode(xmlDoc, originalText, modifiedText, serializer
             }
         } 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),
@@ -206,9 +218,42 @@ export function applySurgicalMode(xmlDoc, originalText, modifiedText, serializer
         }
     }
 
+    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);
+}

package/engine/surgical-run-splitting.js

@@ -1,6 +1,15 @@
 import { createWordElement, isWordElement } from '../core/word-xml.js';
+import {
+    NS_W,
+    RevisionIdAllocator,
+    createRevisionIdAllocator,
+    getRevisionIdAllocatorForDocument
+} from '../core/types.js';
+import { refreshRunPropertyChangeIds } from '../core/revision-cloning.js';
 import { getRunChildText, isTextLikeRunChild } from './surgical-spans.js';
 
+const TRACK_CHANGE_CARRIERS = new Set(['ins']);
+
 export function getRunContentPieces(runElement) {
     const pieces = [];
     let offset = 0;
@@ -62,6 +71,100 @@ export function insertRunPiecesBefore(xmlDoc, parent, referenceNode, pieces, rPr
     return run;
 }
 
+/**
+ * Splits a run-level tracked-change carrier at an accepted-view character
+ * offset without mutating the source carrier. The original revision ID stays
+ * with the leading fragment; an interior trailing fragment receives a fresh,
+ * document-scoped ID while all other carrier metadata remains unchanged.
+ *
+ * @param {Document} xmlDoc
+ * @param {Element} carrierElement
+ * @param {number} splitOffset
+ * @param {RevisionIdAllocator|null} [allocator=null]
+ * @returns {{ leftCarrier: Element|null, rightCarrier: Element|null }}
+ */
+export 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, localName, value) {
+    if (typeof element.setAttributeNS === 'function') {
+        element.setAttributeNS(NS_W, `w:${localName}`, value);
+    } else {
+        element.setAttribute(`w:${localName}`, 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');

package/index.d.ts

@@ -1,6 +1,6 @@
 export type OoxmlSourceType = 'package' | 'document' | 'fragment';
 export type RedlineStatus = 'ok' | 'no-op' | 'error';
-export type ExistingRevisionsPolicy = 'merge-same-author' | 'reject-input' | 'accept-all-first' | 'accept-all-first-keep-normalized';
+export type ExistingRevisionsPolicy = 'merge-same-author' | 'slice-cross-author' | 'reject-input' | 'accept-all-first' | 'accept-all-first-keep-normalized';
 export type RevisionView = 'accepted' | 'rejected';
 
 export interface RevisionTextSegment {