@ansonlai/docx-redline-js 0.5.1 → 0.5.2

package/AGENTS.md

@@ -55,12 +55,12 @@ const result = await applyRedlineToOxml(oxml, originalText, modifiedText, {
 contains tracked changes from the same author, prior revisions by that author are
 reverted to the pre-revision baseline and re-diffed to the new text, cleanly
 merging the edits without accumulating intermediate revisions or nesting markup.
-If the paragraph contains revisions from a different reviewer, the edit fails
-with `EXISTING_REVISIONS` to safeguard third-party marks. Pass
-`existingRevisions: 'slice-cross-author'` (or `--existing-revisions slice-cross-author`)
-to preserve the other reviewer's attribution while applying Word-native
-insertions and deletions inside their pending insertion. Pass
-`existingRevisions: 'accept-all-first'` (or `--existing-revisions accept-all-first`
+If the paragraph contains revisions from a different reviewer, the edit fails
+with `EXISTING_REVISIONS` to safeguard third-party marks. Pass
+`existingRevisions: 'slice-cross-author'` (or `--existing-revisions slice-cross-author`)
+to preserve the other reviewer's attribution while applying Word-native
+insertions and deletions inside their pending insertion. Pass
+`existingRevisions: 'accept-all-first'` (or `--existing-revisions accept-all-first`
 via CLI) to normalize all prior revisions first, or `'reject-input'` to refuse any
 paragraph with open revisions. Use `'accept-all-first-keep-normalized'` only when
 accepted revisions should be returned as a real change even on a no-op edit.
@@ -263,12 +263,16 @@ docx-redline apply contract.docx --target "Original clause" --modified "New clau
 # 2. Direct edit without tracked changes (clean text, no revision clutter)
 docx-redline apply contract.docx --target "Typo fix" --modified "Fixed typo" --no-redlines --output clean.docx
 
-# 3. Batch operations with ops.json
+# 3. Cross-author edit inside another reviewer's pending insertion
+docx-redline apply contract.docx --target "Pending clause text" --modified "Updated clause text" --existing-revisions slice-cross-author --output reviewed.docx
+
+# 4. Batch operations with ops.json
 docx-redline apply contract.docx --operations operations.json --output reviewed.docx
 ```
 
 Key CLI defaults and behaviors:
 - **Author**: Automatically defaults to `'AI Redliner'` (overridable via `--author` or `DOCX_REDLINE_AUTHOR` environment variable).
+- **Existing revisions**: Defaults to `'merge-same-author'`. Pass `--existing-revisions slice-cross-author` to edit inside another reviewer's pending insertions with native carrier slicing.
 - **Overwrite behavior**: Destination files provided via `--output` overwrite by default. To protect existing destination files, pass `--no-overwrite` or `--no-clobber`. The source document is never overwritten unless `--in-place` is specified.
 - **Tracked changes**: Defaults to `generateRedlines: true`. When clean direct text is needed, pass `--no-redlines`.
 - **Atomic rollback (optional)**: Operations apply progressively by default (`atomic: false`). For all-or-nothing transactional rollback where any error halts and reverts all changes, pass `--atomic`.
@@ -392,7 +396,8 @@ When the CLI or runner returns an error code, follow these specific recovery act
 | `AMBIGUOUS_TARGET` | Multiple paragraphs match identical text. | Disambiguate by supplying `paragraphId`, `fingerprint`, `occurrence`, or `index` in the target descriptor. |
 | `ANCHOR_NOT_FOUND` / `AMBIGUOUS_ANCHOR` | Comment anchor text was not uniquely matched in paragraph. | Narrow `textToComment` to a unique exact substring, or omit `textToComment` to anchor the comment to the entire paragraph. |
 | `OVERLAPPING_TEXT_EDITS` | Multiple operations target the same paragraph concurrently. | Consolidate all changes to the same paragraph into a single `redline` or `replace` operation. |
-| `EXISTING_REVISIONS` | Target paragraph contains tracked changes from another author. | Fails closed to protect third-party review marks. Report the other reviewer's name to the user. Do not pass `accept-all-first` without explicit authorization. |
+| `EXISTING_REVISIONS` | Target paragraph contains tracked changes from another author. | Fails closed to protect third-party review marks. If editing inside that reviewer's pending insertion is intended, pass `--existing-revisions slice-cross-author` (or `existingRevisions: 'slice-cross-author'`). Do not pass `accept-all-first` without explicit user authorization. |
+| `PATCH_ROUNDTRIP_MISMATCH` | A cross-author surgical edit did not reconstruct the requested modified text exactly. | Treat the operation as unapplied. Re-extract the exact paragraph text and split the edit into a narrower operation that does not cross the reported structural boundary. |
 | `COMMENTED_CONTENT_MERGE` / `COMMENTED_CONTENT_DELETE` | Operation would overwrite, revert, or delete content with comments. | Fails closed to prevent orphaned comment threads. Report the comment author and text to the user; resolve the comment before re-editing. |
 | `INVALID_OPERATION` | Operation object violates schema or has incompatible fields. | Validate the JSON structure against [`document-operations.schema.json`](file:///c:/Users/Phara/Desktop/Projects/Docx%20Redline%20JS/docs/schemas/document-operations.schema.json) before targeting is attempted. |
 | `STRUCTURED_CONTENT_INVALID` | Malformed Markdown table or structure in replacement text. | Ensure tables include a separator row (`\| --- \| --- \|`) and consistent column counts; do not downgrade to raw text. |
@@ -531,7 +536,7 @@ orchestration/
 | `structuredContent` | `boolean` | `true` | Auto-detects Markdown tables, headings (`#`), and lists in replacement text and renders them as native Word elements (`w:tbl`, `w:pStyle`, `w:numPr`). Pass `false` to treat replacement text strictly as plain text. |
 | `pairReplacements` | `boolean` | `true` | Links adjacent `<w:del>` and `<w:ins>` revisions with matching timestamps so Word groups them as a single replacement in the Reviewing Pane. |
 | `strictTargets` | `boolean` | `true` (CLI/facade) | Requires exact target descriptors (`exactText`, `paragraphId`, `index`, `occurrence`, `fingerprint`) and forbids ambiguous matching. Defaults to `false` in low-level runner for backwards compatibility. |
-| `existingRevisions` | `string` | `'merge-same-author'` | How to handle paragraphs with existing tracked changes. `'merge-same-author'` merges the same author's work and protects other authors with `EXISTING_REVISIONS`. `'slice-cross-author'` retains same-author merging while allowing Word-native edits inside another author's pending insertion. Pass `'accept-all-first'` to normalize prior revisions or `'reject-input'` to refuse editing revised paragraphs. |
+| `existingRevisions` | `string` | `'merge-same-author'` | How to handle paragraphs with existing tracked changes. `'merge-same-author'` merges the same author's work and protects other authors with `EXISTING_REVISIONS`. `'slice-cross-author'` retains same-author merging while allowing Word-native edits inside another author's pending insertion. Pass `'accept-all-first'` to normalize prior revisions or `'reject-input'` to refuse editing revised paragraphs. |
 | `removeFormatting` | `boolean` | `false` | When `true` and the text is unchanged with no Markdown hints, strips existing bold/italic/underline/strikethrough formatting. |
 | `sanitizeInput` | `boolean` | `false` | Opt-in removal of standalone leading assistant-preface lines. Literal dollar signs and `\n` sequences are always preserved. |
 
@@ -617,7 +622,7 @@ directly into `word/document.xml`.
 5. `useNativeApi: true` means standalone mode cannot fully handle that operation path.
 6. `deleteCommentsByAuthorInOoxml` removes definitions and linked anchors only when they are present in the same OOXML payload. In a real `.docx`, `word/comments.xml` and `word/document.xml` are separate parts and must both be updated by the package integration layer.
 7. If output begins with `<pkg:package`, treat it as package-level OOXML and normalize it before writing anything back to `word/document.xml`.
-8. Existing revisions from the same author are merged by default against the pre-revision baseline (`merge-same-author`), while third-party revisions fail closed with `EXISTING_REVISIONS`. Pass `existingRevisions: 'slice-cross-author'` to preserve third-party attribution while editing inside pending insertions, `'accept-all-first'` to normalize all prior revisions first, or `'reject-input'` to refuse any revised paragraph.
+8. Existing revisions from the same author are merged by default against the pre-revision baseline (`merge-same-author`), while third-party revisions fail closed with `EXISTING_REVISIONS`. Pass `existingRevisions: 'slice-cross-author'` to preserve third-party attribution while editing inside pending insertions, `'accept-all-first'` to normalize all prior revisions first, or `'reject-input'` to refuse any revised paragraph.
 9. Caller content is not sanitized by default. Pass `sanitizeInput: true` only for raw assistant output; literal dollar delimiters and `\\n` sequences are never rewritten.
 10. Hyperlinks, bookmarks, comment markers, tabs/breaks, and footnote/endnote references are structural OOXML and should survive adjacent redline edits.
 11. Internally, create Word elements through `createWordElement` and tracked-change metadata through `createRevisionMetadata`.

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # Changelog
 
+## 0.5.1
+
+### Highlights & New Features
+
+- **Cross-Author Revision Slicing (`existingRevisions: 'slice-cross-author'`)**: Adds native support for editing text inside another reviewer's pending tracked insertion without erasing their attribution or requiring prior acceptance.
+  - **Word-Native Insertion Slicing**: When inserting text inside another author's pending `<w:ins>`, the engine splits the outer carrier into sibling `<w:ins>` elements at the paragraph level (`[ins(A), ins(B), ins(A)]`), ensuring strict ECMA-376 schema compliance without illegal `ins/ins` nesting.
+  - **Word-Native Deletion Slicing**: When deleting text inside another author's pending `<w:ins>`, the engine nests `<w:del>` directly inside `<w:ins>` per ECMA-376 Part 1 `CT_RunTrackChange` Section 17.13.5.21 and Microsoft Word Desktop 365 native behavior.
+  - **Boundary & Straddle Deletions**: Deletions straddling baseline text and pending insertions cleanly partition into separate top-level and nested `<w:del>` containers while sharing unified event/author attribution.
+  - **Multi-Author Stacked Revisions**: Multiple reviewers can independently delete or insert content within the same carrier insertion without cross-author interference.
+  - **Cascading & Coalescing Lifecycles**: Full round-trip lifecycle parity with Microsoft Word Desktop:
+    - Rejecting Author A cleanly discards Author A's insertion and any dependent nested deletions by Author B.
+    - Accepting Author A unwraps the insertion into baseline text while leaving Author B's deletions pending against the baseline.
+    - Rejecting Author B restores Author B's deleted text within Author A's insertion, and coalesces adjacent split `<w:ins>` fragments back into a single continuous carrier.
+  - **CLI & Facade Integration**: Fully exposed via the `docx-redline` CLI (`--existing-revisions slice-cross-author`), Node facade (`openDocx`), and batch operation runner.
+
+### Non-breaking Changes & Improvements
+
+- **Validation Update (`validateRedlineOoxml`)**: Refined `NESTED_REVISION` checks to permit direct `<w:ins><w:del>...</w:del></w:ins>` nesting (standard ECMA-376 and Word Desktop behavior), while continuing to strictly reject `ins/ins`, `del/del`, and `del/ins` nesting.
+- **Slicing Round-Trip Guard**: Cross-author surgical edits now preserve whitespace-only insertions (including ordinary-space replacements for NBSP characters beside hyperlinks) and verify the exact accepted-view text before reporting success. A mismatch fails closed with `PATCH_ROUNDTRIP_MISMATCH` and returns the original OOXML unchanged.
+- **Insertion Stress Hardening**: Slicing now detects edge whitespace changes exactly, uses a character-local insertion-only diff when the original text is an exact subsequence of the modified text, and coalesces new text into an existing same-author carrier when foreign revisions are also present. This prevents repeated phrases from relocating insertions and prevents invalid `w:ins/w:ins` nesting in mixed-author paragraphs.
+- **Preflight Inspection**: `preflightOperations` now inspects and validates `slice-cross-author` batches, reporting pending foreign-author carrier targets as `ready` instead of `EXISTING_REVISIONS`.
+- **Test Suite Expansion**: Added 6 new test suites covering 36 Word Desktop COM golden fixtures, carrier splitting invariants, the SYN-01..12d synthetic test matrix, PKG-01..06 strict package differential replay, the repeated-text/hyperlink whitespace regression, and 76 deterministic insertion stress scenarios (expanding the suite from 88 to 94 passing suites).
+
 ## 0.5.0
 
 ### ⚠️ Breaking changes

package/README.md

@@ -143,6 +143,8 @@ docx-redline extract contract.docx --range 10:30
 docx-redline preflight contract.docx --operations operations.json --author "Editor"
 docx-redline apply contract.docx --operations operations.json --author "Editor" --output reviewed.docx
 docx-redline validate reviewed.docx
+```
+
 ```bash
 # Inline one-liner edit (no operations file needed)
 docx-redline apply contract.docx --target "Original clause text" --modified "New clause text" --output reviewed.docx
@@ -150,6 +152,9 @@ docx-redline apply contract.docx --target "Original clause text" --modified "New
 # Direct edit without tracked changes
 docx-redline apply contract.docx --target "Typo fix" --modified "Fixed typo" --no-redlines --output clean.docx
 
+# Cross-author edit inside another reviewer's pending insertion
+docx-redline apply contract.docx --target "Another author's clause" --modified "Revised clause" --existing-revisions slice-cross-author --output reviewed.docx
+
 # High-assurance atomic batch
 docx-redline apply contract.docx --operations operations.json --atomic --output reviewed.docx
 ```
@@ -157,6 +162,7 @@ docx-redline apply contract.docx --operations operations.json --atomic --output
 All commands emit JSON on stdout. `apply` defaults:
 - **Author**: Defaults to `'AI Redliner'` (or `DOCX_REDLINE_AUTHOR` environment variable).
 - **Output overwrite**: Destination files provided via `--output` overwrite by default. Pass `--no-overwrite` or `--no-clobber` to safeguard existing destination files. The source input is never overwritten unless `--in-place` is specified.
+- **Existing revisions**: Defaults to `'merge-same-author'`. Pass `--existing-revisions slice-cross-author` to edit inside another reviewer's pending insertions with native carrier slicing.
 - **Transactionality**: Defaults to `atomic: false` (applies valid operations and reports any failures). Pass `--atomic` for all-or-nothing rollback on any operation error.
 - **Tracked changes**: Defaults to `generateRedlines: true`. Pass `--no-redlines` when clean direct text edits are desired.
 - **Inline edits**: Use `--target <text>` with `--modified <text>` or `--comment <text>` for quick one-liners without creating a JSON file.
@@ -183,13 +189,13 @@ See [the agent workflow in AGENTS.md](./AGENTS.md#agent-document-workflow-cli) a
 | `structuredContent` | `boolean` | `true` | Auto-detects Markdown tables, headings (`#`), and lists in replacement text and renders them as native Word elements (`w:tbl`, `w:pStyle`, `w:numPr`). Pass `false` to treat replacement text strictly as plain text. |
 | `pairReplacements` | `boolean` | `true` | Links adjacent `<w:del>` and `<w:ins>` revisions with matching timestamps so Word groups them as a single replacement in the Reviewing Pane. |
 | `strictTargets` | `boolean` | `true` (CLI/facade) | Requires exact target descriptors (`exactText`, `paragraphId`, `index`, `occurrence`, `fingerprint`) and forbids ambiguous matching. Defaults to `false` in low-level runner for backwards compatibility. |
-| `existingRevisions` | `string` | `'merge-same-author'` | How to handle paragraphs with existing tracked changes. `'merge-same-author'` merges revisions from the same author and protects other authors with `EXISTING_REVISIONS`. `'slice-cross-author'` keeps that same-author merge behavior while allowing Word-native edits inside another author's pending insertion. Pass `'accept-all-first'` to normalize prior revisions or `'reject-input'` to refuse editing revised paragraphs. |
+| `existingRevisions` | `string` | `'merge-same-author'` | How to handle paragraphs with existing tracked changes. `'merge-same-author'` merges revisions from the same author and protects other authors with `EXISTING_REVISIONS`. `'slice-cross-author'` keeps that same-author merge behavior while allowing Word-native edits inside another author's pending insertion. Pass `'accept-all-first'` to normalize prior revisions or `'reject-input'` to refuse editing revised paragraphs. |
 | `removeFormatting` | `boolean` | `false` | When `true` and the text is unchanged with no Markdown hints, strips existing bold/italic/underline/strikethrough formatting. |
-| `sanitizeInput` | `boolean` | `false` | Opt-in removal of standalone leading assistant-preface lines. Literal dollar signs and `\n` sequences are always preserved. |
-
-Same-author revision merging refuses paragraphs containing comment anchors with
-`COMMENTED_CONTENT_MERGE`; resolve those comments first so the merge cannot
-remove or orphan their anchors.
+| `sanitizeInput` | `boolean` | `false` | Opt-in removal of standalone leading assistant-preface lines. Literal dollar signs and `\n` sequences are always preserved. |
+
+Same-author revision merging refuses paragraphs containing comment anchors with
+`COMMENTED_CONTENT_MERGE`; resolve those comments first so the merge cannot
+remove or orphan their anchors.
 
 Common result fields:
 
@@ -205,6 +211,24 @@ the safe ceiling of 262,144 unique diff tokens return `DIFF_TOKEN_LIMIT` with
 the original OOXML unchanged so callers can split the operation without risking
 silent text loss.
 
+### Editing inside existing revisions (cross-author slicing)
+
+During multi-round legal negotiations, a reviewer often needs to edit text that was previously inserted by another reviewer whose revision is still pending. Pass `existingRevisions: 'slice-cross-author'` (or `--existing-revisions slice-cross-author` via CLI) to edit inside another author's pending insertion without erasing their attribution or requiring prior acceptance:
+
+```js
+const result = await applyRedlineToOxml(paragraphOoxml, originalText, modifiedText, {
+  generateRedlines: true,
+  author: 'Anson Lai',
+  existingRevisions: 'slice-cross-author'
+});
+```
+
+The engine applies Microsoft Word Desktop-native tracked change structures:
+- **Insertions inside pending insertions**: The carrier `<w:ins>` is split into sibling `<w:ins>` containers at the paragraph level (`[ins(Author A), ins(Author B), ins(Author A)]`), maintaining strict schema compliance without illegal `ins/ins` nesting.
+- **Deletions inside pending insertions**: The new `<w:del>` is nested directly inside the carrier `<w:ins>` (valid under ECMA-376 Part 1 `CT_RunTrackChange`), ensuring that if Author A's insertion is rejected, Author B's dependent deletion is cleanly removed with it.
+- **Straddle deletions**: Deletions spanning between baseline text and pending insertions cleanly partition across their respective container contexts without invalid coalescing.
+- **Lifecycle parity**: Accepting or rejecting either reviewer independently produces identical results to Microsoft Word Desktop's native review pane.
+
 ### Replacing a heading with a tracked list
 
 The list route treats a one-paragraph heading expanded into multiple markdown
@@ -309,11 +333,19 @@ an earlier block has already replaced.
 | `ensureCommentsExtendedArtifactsInZip(zip, commentsExtendedXml)` | Add or replace modern Word comment-thread metadata in a `.docx` package. |
 | `validateDocxPackage(zip)` | Validate `.docx` structural consistency. |
 
-Malformed OOXML never escapes these public transform APIs as a raw parser
-exception. Transforms return `status: 'error'` with `error.code === 'PARSE_ERROR'`;
-validators return a `PARSE_ERROR` issue. Recoverable XML parser
-diagnostics are forwarded through the configured logger and included in
-`warnings` where the result shape supports them.
+Malformed OOXML never escapes these public transform APIs as a raw parser
+exception. Transforms return `status: 'error'` with `error.code === 'PARSE_ERROR'`;
+validators return a `PARSE_ERROR` issue. Recoverable XML parser
+diagnostics are forwarded through the configured logger and included in
+`warnings` where the result shape supports them.
+
+Cross-author slicing also verifies its exact accepted-view text before success.
+If a structural boundary prevents exact reconstruction, the transform returns
+`status: 'error'` with `error.code === 'PATCH_ROUNDTRIP_MISMATCH'`,
+`hasChanges: false`, and the original OOXML unchanged.
+Pure insertion-only slicing uses an exact character-local diff so repeated words
+cannot move an insertion to a different occurrence. Leading/trailing spaces,
+tabs, and non-breaking spaces are treated as real changes rather than no-ops.
 
 ### Deep Imports
 

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

@@ -1,4 +1,4 @@
-// @ansonlai/docx-redline-js v0.5.1 — 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 [{
@@ -6208,6 +6219,7 @@ 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,
@@ -6229,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);
@@ -6443,6 +6455,11 @@ function isForeignInsertion(node, author) {
   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;
@@ -6541,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 = [];
@@ -6576,7 +6594,7 @@ 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) {
+        if (textWithoutNewlines.length > 0) {
           const checkResult = checkSafeAdjacencyForPairing(
             spanIndex,
             originalPos,
@@ -6601,7 +6619,7 @@ function applySurgicalMode(xmlDoc, originalText, modifiedText, serializer, autho
         i++;
         const [, nextText] = diffs[i];
         const textWithoutNewlines = nextText.replace(/\n/g, " ");
-        if (textWithoutNewlines.trim().length > 0) {
+        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({
@@ -6619,7 +6637,7 @@ function applySurgicalMode(xmlDoc, originalText, modifiedText, serializer, autho
       }
     } else if (op === 1) {
       const textWithoutNewlines = text.replace(/\n/g, " ");
-      if (textWithoutNewlines.trim().length > 0) {
+      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({
@@ -6636,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);
@@ -8243,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;
@@ -8396,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 });