@ansonlai/docx-redline-js 0.2.1 → 0.4.0

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

@@ -1,4 +1,4 @@
-// @ansonlai/docx-redline-js v0.2.1 — https://github.com/AnsonLai/docx-redline-js
+// @ansonlai/docx-redline-js v0.4.0 — https://github.com/AnsonLai/docx-redline-js
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -32,7 +32,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 // node_modules/diff-match-patch/index.js
 var require_diff_match_patch = __commonJS({
   "node_modules/diff-match-patch/index.js"(exports, module) {
-    var diff_match_patch2 = function() {
+    var diff_match_patch3 = function() {
       this.Diff_Timeout = 1;
       this.Diff_EditCost = 4;
       this.Match_Threshold = 0.5;
@@ -44,10 +44,10 @@ var require_diff_match_patch = __commonJS({
     var DIFF_DELETE = -1;
     var DIFF_INSERT = 1;
     var DIFF_EQUAL = 0;
-    diff_match_patch2.Diff = function(op, text) {
+    diff_match_patch3.Diff = function(op, text) {
       return [op, text];
     };
-    diff_match_patch2.prototype.diff_main = function(text1, text2, opt_checklines, opt_deadline) {
+    diff_match_patch3.prototype.diff_main = function(text1, text2, opt_checklines, opt_deadline) {
       if (typeof opt_deadline == "undefined") {
         if (this.Diff_Timeout <= 0) {
           opt_deadline = Number.MAX_VALUE;
@@ -61,7 +61,7 @@ var require_diff_match_patch = __commonJS({
       }
       if (text1 == text2) {
         if (text1) {
-          return [new diff_match_patch2.Diff(DIFF_EQUAL, text1)];
+          return [new diff_match_patch3.Diff(DIFF_EQUAL, text1)];
         }
         return [];
       }
@@ -79,30 +79,30 @@ var require_diff_match_patch = __commonJS({
       text2 = text2.substring(0, text2.length - commonlength);
       var diffs = this.diff_compute_(text1, text2, checklines, deadline);
       if (commonprefix) {
-        diffs.unshift(new diff_match_patch2.Diff(DIFF_EQUAL, commonprefix));
+        diffs.unshift(new diff_match_patch3.Diff(DIFF_EQUAL, commonprefix));
       }
       if (commonsuffix) {
-        diffs.push(new diff_match_patch2.Diff(DIFF_EQUAL, commonsuffix));
+        diffs.push(new diff_match_patch3.Diff(DIFF_EQUAL, commonsuffix));
       }
       this.diff_cleanupMerge(diffs);
       return diffs;
     };
-    diff_match_patch2.prototype.diff_compute_ = function(text1, text2, checklines, deadline) {
+    diff_match_patch3.prototype.diff_compute_ = function(text1, text2, checklines, deadline) {
       var diffs;
       if (!text1) {
-        return [new diff_match_patch2.Diff(DIFF_INSERT, text2)];
+        return [new diff_match_patch3.Diff(DIFF_INSERT, text2)];
       }
       if (!text2) {
-        return [new diff_match_patch2.Diff(DIFF_DELETE, text1)];
+        return [new diff_match_patch3.Diff(DIFF_DELETE, text1)];
       }
       var longtext = text1.length > text2.length ? text1 : text2;
       var shorttext = text1.length > text2.length ? text2 : text1;
       var i = longtext.indexOf(shorttext);
       if (i != -1) {
         diffs = [
-          new diff_match_patch2.Diff(DIFF_INSERT, longtext.substring(0, i)),
-          new diff_match_patch2.Diff(DIFF_EQUAL, shorttext),
-          new diff_match_patch2.Diff(
+          new diff_match_patch3.Diff(DIFF_INSERT, longtext.substring(0, i)),
+          new diff_match_patch3.Diff(DIFF_EQUAL, shorttext),
+          new diff_match_patch3.Diff(
             DIFF_INSERT,
             longtext.substring(i + shorttext.length)
           )
@@ -114,8 +114,8 @@ var require_diff_match_patch = __commonJS({
       }
       if (shorttext.length == 1) {
         return [
-          new diff_match_patch2.Diff(DIFF_DELETE, text1),
-          new diff_match_patch2.Diff(DIFF_INSERT, text2)
+          new diff_match_patch3.Diff(DIFF_DELETE, text1),
+          new diff_match_patch3.Diff(DIFF_INSERT, text2)
         ];
       }
       var hm = this.diff_halfMatch_(text1, text2);
@@ -128,7 +128,7 @@ var require_diff_match_patch = __commonJS({
         var diffs_a = this.diff_main(text1_a, text2_a, checklines, deadline);
         var diffs_b = this.diff_main(text1_b, text2_b, checklines, deadline);
         return diffs_a.concat(
-          [new diff_match_patch2.Diff(DIFF_EQUAL, mid_common)],
+          [new diff_match_patch3.Diff(DIFF_EQUAL, mid_common)],
           diffs_b
         );
       }
@@ -137,7 +137,7 @@ var require_diff_match_patch = __commonJS({
       }
       return this.diff_bisect_(text1, text2, deadline);
     };
-    diff_match_patch2.prototype.diff_lineMode_ = function(text1, text2, deadline) {
+    diff_match_patch3.prototype.diff_lineMode_ = function(text1, text2, deadline) {
       var a = this.diff_linesToChars_(text1, text2);
       text1 = a.chars1;
       text2 = a.chars2;
@@ -145,7 +145,7 @@ var require_diff_match_patch = __commonJS({
       var diffs = this.diff_main(text1, text2, false, deadline);
       this.diff_charsToLines_(diffs, linearray);
       this.diff_cleanupSemantic(diffs);
-      diffs.push(new diff_match_patch2.Diff(DIFF_EQUAL, ""));
+      diffs.push(new diff_match_patch3.Diff(DIFF_EQUAL, ""));
       var pointer = 0;
       var count_delete = 0;
       var count_insert = 0;
@@ -185,7 +185,7 @@ var require_diff_match_patch = __commonJS({
       diffs.pop();
       return diffs;
     };
-    diff_match_patch2.prototype.diff_bisect_ = function(text1, text2, deadline) {
+    diff_match_patch3.prototype.diff_bisect_ = function(text1, text2, deadline) {
       var text1_length = text1.length;
       var text2_length = text2.length;
       var max_d = Math.ceil((text1_length + text2_length) / 2);
@@ -269,11 +269,11 @@ var require_diff_match_patch = __commonJS({
         }
       }
       return [
-        new diff_match_patch2.Diff(DIFF_DELETE, text1),
-        new diff_match_patch2.Diff(DIFF_INSERT, text2)
+        new diff_match_patch3.Diff(DIFF_DELETE, text1),
+        new diff_match_patch3.Diff(DIFF_INSERT, text2)
       ];
     };
-    diff_match_patch2.prototype.diff_bisectSplit_ = function(text1, text2, x, y, deadline) {
+    diff_match_patch3.prototype.diff_bisectSplit_ = function(text1, text2, x, y, deadline) {
       var text1a = text1.substring(0, x);
       var text2a = text2.substring(0, y);
       var text1b = text1.substring(x);
@@ -282,7 +282,7 @@ var require_diff_match_patch = __commonJS({
       var diffsb = this.diff_main(text1b, text2b, false, deadline);
       return diffs.concat(diffsb);
     };
-    diff_match_patch2.prototype.diff_linesToChars_ = function(text1, text2) {
+    diff_match_patch3.prototype.diff_linesToChars_ = function(text1, text2) {
       var lineArray = [];
       var lineHash = {};
       lineArray[0] = "";
@@ -318,7 +318,7 @@ var require_diff_match_patch = __commonJS({
       var chars2 = diff_linesToCharsMunge_(text2);
       return { chars1, chars2, lineArray };
     };
-    diff_match_patch2.prototype.diff_charsToLines_ = function(diffs, lineArray) {
+    diff_match_patch3.prototype.diff_charsToLines_ = function(diffs, lineArray) {
       for (var i = 0; i < diffs.length; i++) {
         var chars = diffs[i][1];
         var text = [];
@@ -328,7 +328,7 @@ var require_diff_match_patch = __commonJS({
         diffs[i][1] = text.join("");
       }
     };
-    diff_match_patch2.prototype.diff_commonPrefix = function(text1, text2) {
+    diff_match_patch3.prototype.diff_commonPrefix = function(text1, text2) {
       if (!text1 || !text2 || text1.charAt(0) != text2.charAt(0)) {
         return 0;
       }
@@ -347,7 +347,7 @@ var require_diff_match_patch = __commonJS({
       }
       return pointermid;
     };
-    diff_match_patch2.prototype.diff_commonSuffix = function(text1, text2) {
+    diff_match_patch3.prototype.diff_commonSuffix = function(text1, text2) {
       if (!text1 || !text2 || text1.charAt(text1.length - 1) != text2.charAt(text2.length - 1)) {
         return 0;
       }
@@ -366,7 +366,7 @@ var require_diff_match_patch = __commonJS({
       }
       return pointermid;
     };
-    diff_match_patch2.prototype.diff_commonOverlap_ = function(text1, text2) {
+    diff_match_patch3.prototype.diff_commonOverlap_ = function(text1, text2) {
       var text1_length = text1.length;
       var text2_length = text2.length;
       if (text1_length == 0 || text2_length == 0) {
@@ -396,7 +396,7 @@ var require_diff_match_patch = __commonJS({
         }
       }
     };
-    diff_match_patch2.prototype.diff_halfMatch_ = function(text1, text2) {
+    diff_match_patch3.prototype.diff_halfMatch_ = function(text1, text2) {
       if (this.Diff_Timeout <= 0) {
         return null;
       }
@@ -475,7 +475,7 @@ var require_diff_match_patch = __commonJS({
       var mid_common = hm[4];
       return [text1_a, text1_b, text2_a, text2_b, mid_common];
     };
-    diff_match_patch2.prototype.diff_cleanupSemantic = function(diffs) {
+    diff_match_patch3.prototype.diff_cleanupSemantic = function(diffs) {
       var changes = false;
       var equalities = [];
       var equalitiesLength = 0;
@@ -506,7 +506,7 @@ var require_diff_match_patch = __commonJS({
             diffs.splice(
               equalities[equalitiesLength - 1],
               0,
-              new diff_match_patch2.Diff(DIFF_DELETE, lastEquality)
+              new diff_match_patch3.Diff(DIFF_DELETE, lastEquality)
             );
             diffs[equalities[equalitiesLength - 1] + 1][0] = DIFF_INSERT;
             equalitiesLength--;
@@ -535,7 +535,7 @@ var require_diff_match_patch = __commonJS({
           var overlap_length2 = this.diff_commonOverlap_(insertion, deletion);
           if (overlap_length1 >= overlap_length2) {
             if (overlap_length1 >= deletion.length / 2 || overlap_length1 >= insertion.length / 2) {
-              diffs.splice(pointer, 0, new diff_match_patch2.Diff(
+              diffs.splice(pointer, 0, new diff_match_patch3.Diff(
                 DIFF_EQUAL,
                 insertion.substring(0, overlap_length1)
               ));
@@ -545,7 +545,7 @@ var require_diff_match_patch = __commonJS({
             }
           } else {
             if (overlap_length2 >= deletion.length / 2 || overlap_length2 >= insertion.length / 2) {
-              diffs.splice(pointer, 0, new diff_match_patch2.Diff(
+              diffs.splice(pointer, 0, new diff_match_patch3.Diff(
                 DIFF_EQUAL,
                 deletion.substring(0, overlap_length2)
               ));
@@ -561,21 +561,21 @@ var require_diff_match_patch = __commonJS({
         pointer++;
       }
     };
-    diff_match_patch2.prototype.diff_cleanupSemanticLossless = function(diffs) {
+    diff_match_patch3.prototype.diff_cleanupSemanticLossless = function(diffs) {
       function diff_cleanupSemanticScore_(one, two) {
         if (!one || !two) {
           return 6;
         }
         var char1 = one.charAt(one.length - 1);
         var char2 = two.charAt(0);
-        var nonAlphaNumeric1 = char1.match(diff_match_patch2.nonAlphaNumericRegex_);
-        var nonAlphaNumeric2 = char2.match(diff_match_patch2.nonAlphaNumericRegex_);
-        var whitespace1 = nonAlphaNumeric1 && char1.match(diff_match_patch2.whitespaceRegex_);
-        var whitespace2 = nonAlphaNumeric2 && char2.match(diff_match_patch2.whitespaceRegex_);
-        var lineBreak1 = whitespace1 && char1.match(diff_match_patch2.linebreakRegex_);
-        var lineBreak2 = whitespace2 && char2.match(diff_match_patch2.linebreakRegex_);
-        var blankLine1 = lineBreak1 && one.match(diff_match_patch2.blanklineEndRegex_);
-        var blankLine2 = lineBreak2 && two.match(diff_match_patch2.blanklineStartRegex_);
+        var nonAlphaNumeric1 = char1.match(diff_match_patch3.nonAlphaNumericRegex_);
+        var nonAlphaNumeric2 = char2.match(diff_match_patch3.nonAlphaNumericRegex_);
+        var whitespace1 = nonAlphaNumeric1 && char1.match(diff_match_patch3.whitespaceRegex_);
+        var whitespace2 = nonAlphaNumeric2 && char2.match(diff_match_patch3.whitespaceRegex_);
+        var lineBreak1 = whitespace1 && char1.match(diff_match_patch3.linebreakRegex_);
+        var lineBreak2 = whitespace2 && char2.match(diff_match_patch3.linebreakRegex_);
+        var blankLine1 = lineBreak1 && one.match(diff_match_patch3.blanklineEndRegex_);
+        var blankLine2 = lineBreak2 && two.match(diff_match_patch3.blanklineStartRegex_);
         if (blankLine1 || blankLine2) {
           return 5;
         } else if (lineBreak1 || lineBreak2) {
@@ -637,12 +637,12 @@ var require_diff_match_patch = __commonJS({
         pointer++;
       }
     };
-    diff_match_patch2.nonAlphaNumericRegex_ = /[^a-zA-Z0-9]/;
-    diff_match_patch2.whitespaceRegex_ = /\s/;
-    diff_match_patch2.linebreakRegex_ = /[\r\n]/;
-    diff_match_patch2.blanklineEndRegex_ = /\n\r?\n$/;
-    diff_match_patch2.blanklineStartRegex_ = /^\r?\n\r?\n/;
-    diff_match_patch2.prototype.diff_cleanupEfficiency = function(diffs) {
+    diff_match_patch3.nonAlphaNumericRegex_ = /[^a-zA-Z0-9]/;
+    diff_match_patch3.whitespaceRegex_ = /\s/;
+    diff_match_patch3.linebreakRegex_ = /[\r\n]/;
+    diff_match_patch3.blanklineEndRegex_ = /\n\r?\n$/;
+    diff_match_patch3.blanklineStartRegex_ = /^\r?\n\r?\n/;
+    diff_match_patch3.prototype.diff_cleanupEfficiency = function(diffs) {
       var changes = false;
       var equalities = [];
       var equalitiesLength = 0;
@@ -674,7 +674,7 @@ var require_diff_match_patch = __commonJS({
             diffs.splice(
               equalities[equalitiesLength - 1],
               0,
-              new diff_match_patch2.Diff(DIFF_DELETE, lastEquality)
+              new diff_match_patch3.Diff(DIFF_DELETE, lastEquality)
             );
             diffs[equalities[equalitiesLength - 1] + 1][0] = DIFF_INSERT;
             equalitiesLength--;
@@ -696,8 +696,8 @@ var require_diff_match_patch = __commonJS({
         this.diff_cleanupMerge(diffs);
       }
     };
-    diff_match_patch2.prototype.diff_cleanupMerge = function(diffs) {
-      diffs.push(new diff_match_patch2.Diff(DIFF_EQUAL, ""));
+    diff_match_patch3.prototype.diff_cleanupMerge = function(diffs) {
+      diffs.push(new diff_match_patch3.Diff(DIFF_EQUAL, ""));
       var pointer = 0;
       var count_delete = 0;
       var count_insert = 0;
@@ -724,7 +724,7 @@ var require_diff_match_patch = __commonJS({
                   if (pointer - count_delete - count_insert > 0 && diffs[pointer - count_delete - count_insert - 1][0] == DIFF_EQUAL) {
                     diffs[pointer - count_delete - count_insert - 1][1] += text_insert.substring(0, commonlength);
                   } else {
-                    diffs.splice(0, 0, new diff_match_patch2.Diff(
+                    diffs.splice(0, 0, new diff_match_patch3.Diff(
                       DIFF_EQUAL,
                       text_insert.substring(0, commonlength)
                     ));
@@ -746,7 +746,7 @@ var require_diff_match_patch = __commonJS({
                 diffs.splice(
                   pointer,
                   0,
-                  new diff_match_patch2.Diff(DIFF_DELETE, text_delete)
+                  new diff_match_patch3.Diff(DIFF_DELETE, text_delete)
                 );
                 pointer++;
               }
@@ -754,7 +754,7 @@ var require_diff_match_patch = __commonJS({
                 diffs.splice(
                   pointer,
                   0,
-                  new diff_match_patch2.Diff(DIFF_INSERT, text_insert)
+                  new diff_match_patch3.Diff(DIFF_INSERT, text_insert)
                 );
                 pointer++;
               }
@@ -797,7 +797,7 @@ var require_diff_match_patch = __commonJS({
         this.diff_cleanupMerge(diffs);
       }
     };
-    diff_match_patch2.prototype.diff_xIndex = function(diffs, loc) {
+    diff_match_patch3.prototype.diff_xIndex = function(diffs, loc) {
       var chars1 = 0;
       var chars2 = 0;
       var last_chars1 = 0;
@@ -821,7 +821,7 @@ var require_diff_match_patch = __commonJS({
       }
       return last_chars2 + (loc - last_chars1);
     };
-    diff_match_patch2.prototype.diff_prettyHtml = function(diffs) {
+    diff_match_patch3.prototype.diff_prettyHtml = function(diffs) {
       var html = [];
       var pattern_amp = /&/g;
       var pattern_lt = /</g;
@@ -845,7 +845,7 @@ var require_diff_match_patch = __commonJS({
       }
       return html.join("");
     };
-    diff_match_patch2.prototype.diff_text1 = function(diffs) {
+    diff_match_patch3.prototype.diff_text1 = function(diffs) {
       var text = [];
       for (var x = 0; x < diffs.length; x++) {
         if (diffs[x][0] !== DIFF_INSERT) {
@@ -854,7 +854,7 @@ var require_diff_match_patch = __commonJS({
       }
       return text.join("");
     };
-    diff_match_patch2.prototype.diff_text2 = function(diffs) {
+    diff_match_patch3.prototype.diff_text2 = function(diffs) {
       var text = [];
       for (var x = 0; x < diffs.length; x++) {
         if (diffs[x][0] !== DIFF_DELETE) {
@@ -863,7 +863,7 @@ var require_diff_match_patch = __commonJS({
       }
       return text.join("");
     };
-    diff_match_patch2.prototype.diff_levenshtein = function(diffs) {
+    diff_match_patch3.prototype.diff_levenshtein = function(diffs) {
       var levenshtein = 0;
       var insertions = 0;
       var deletions = 0;
@@ -887,7 +887,7 @@ var require_diff_match_patch = __commonJS({
       levenshtein += Math.max(insertions, deletions);
       return levenshtein;
     };
-    diff_match_patch2.prototype.diff_toDelta = function(diffs) {
+    diff_match_patch3.prototype.diff_toDelta = function(diffs) {
       var text = [];
       for (var x = 0; x < diffs.length; x++) {
         switch (diffs[x][0]) {
@@ -904,7 +904,7 @@ var require_diff_match_patch = __commonJS({
       }
       return text.join("	").replace(/%20/g, " ");
     };
-    diff_match_patch2.prototype.diff_fromDelta = function(text1, delta) {
+    diff_match_patch3.prototype.diff_fromDelta = function(text1, delta) {
       var diffs = [];
       var diffsLength = 0;
       var pointer = 0;
@@ -914,7 +914,7 @@ var require_diff_match_patch = __commonJS({
         switch (tokens[x].charAt(0)) {
           case "+":
             try {
-              diffs[diffsLength++] = new diff_match_patch2.Diff(DIFF_INSERT, decodeURI(param));
+              diffs[diffsLength++] = new diff_match_patch3.Diff(DIFF_INSERT, decodeURI(param));
             } catch (ex) {
               throw new Error("Illegal escape in diff_fromDelta: " + param);
             }
@@ -928,9 +928,9 @@ var require_diff_match_patch = __commonJS({
             }
             var text = text1.substring(pointer, pointer += n);
             if (tokens[x].charAt(0) == "=") {
-              diffs[diffsLength++] = new diff_match_patch2.Diff(DIFF_EQUAL, text);
+              diffs[diffsLength++] = new diff_match_patch3.Diff(DIFF_EQUAL, text);
             } else {
-              diffs[diffsLength++] = new diff_match_patch2.Diff(DIFF_DELETE, text);
+              diffs[diffsLength++] = new diff_match_patch3.Diff(DIFF_DELETE, text);
             }
             break;
           default:
@@ -944,7 +944,7 @@ var require_diff_match_patch = __commonJS({
       }
       return diffs;
     };
-    diff_match_patch2.prototype.match_main = function(text, pattern, loc) {
+    diff_match_patch3.prototype.match_main = function(text, pattern, loc) {
       if (text == null || pattern == null || loc == null) {
         throw new Error("Null input. (match_main)");
       }
@@ -959,7 +959,7 @@ var require_diff_match_patch = __commonJS({
         return this.match_bitap_(text, pattern, loc);
       }
     };
-    diff_match_patch2.prototype.match_bitap_ = function(text, pattern, loc) {
+    diff_match_patch3.prototype.match_bitap_ = function(text, pattern, loc) {
       if (pattern.length > this.Match_MaxBits) {
         throw new Error("Pattern too long for this browser.");
       }
@@ -1030,7 +1030,7 @@ var require_diff_match_patch = __commonJS({
       }
       return best_loc;
     };
-    diff_match_patch2.prototype.match_alphabet_ = function(pattern) {
+    diff_match_patch3.prototype.match_alphabet_ = function(pattern) {
       var s = {};
       for (var i = 0; i < pattern.length; i++) {
         s[pattern.charAt(i)] = 0;
@@ -1040,7 +1040,7 @@ var require_diff_match_patch = __commonJS({
       }
       return s;
     };
-    diff_match_patch2.prototype.patch_addContext_ = function(patch, text) {
+    diff_match_patch3.prototype.patch_addContext_ = function(patch, text) {
       if (text.length == 0) {
         return;
       }
@@ -1059,21 +1059,21 @@ var require_diff_match_patch = __commonJS({
       padding += this.Patch_Margin;
       var prefix = text.substring(patch.start2 - padding, patch.start2);
       if (prefix) {
-        patch.diffs.unshift(new diff_match_patch2.Diff(DIFF_EQUAL, prefix));
+        patch.diffs.unshift(new diff_match_patch3.Diff(DIFF_EQUAL, prefix));
       }
       var suffix = text.substring(
         patch.start2 + patch.length1,
         patch.start2 + patch.length1 + padding
       );
       if (suffix) {
-        patch.diffs.push(new diff_match_patch2.Diff(DIFF_EQUAL, suffix));
+        patch.diffs.push(new diff_match_patch3.Diff(DIFF_EQUAL, suffix));
       }
       patch.start1 -= prefix.length;
       patch.start2 -= prefix.length;
       patch.length1 += prefix.length + suffix.length;
       patch.length2 += prefix.length + suffix.length;
     };
-    diff_match_patch2.prototype.patch_make = function(a, opt_b, opt_c) {
+    diff_match_patch3.prototype.patch_make = function(a, opt_b, opt_c) {
       var text1, diffs;
       if (typeof a == "string" && typeof opt_b == "string" && typeof opt_c == "undefined") {
         text1 = /** @type {string} */
@@ -1109,7 +1109,7 @@ var require_diff_match_patch = __commonJS({
         return [];
       }
       var patches = [];
-      var patch = new diff_match_patch2.patch_obj();
+      var patch = new diff_match_patch3.patch_obj();
       var patchDiffLength = 0;
       var char_count1 = 0;
       var char_count2 = 0;
@@ -1142,7 +1142,7 @@ var require_diff_match_patch = __commonJS({
               if (patchDiffLength) {
                 this.patch_addContext_(patch, prepatch_text);
                 patches.push(patch);
-                patch = new diff_match_patch2.patch_obj();
+                patch = new diff_match_patch3.patch_obj();
                 patchDiffLength = 0;
                 prepatch_text = postpatch_text;
                 char_count1 = char_count2;
@@ -1163,14 +1163,14 @@ var require_diff_match_patch = __commonJS({
       }
       return patches;
     };
-    diff_match_patch2.prototype.patch_deepCopy = function(patches) {
+    diff_match_patch3.prototype.patch_deepCopy = function(patches) {
       var patchesCopy = [];
       for (var x = 0; x < patches.length; x++) {
         var patch = patches[x];
-        var patchCopy = new diff_match_patch2.patch_obj();
+        var patchCopy = new diff_match_patch3.patch_obj();
         patchCopy.diffs = [];
         for (var y = 0; y < patch.diffs.length; y++) {
-          patchCopy.diffs[y] = new diff_match_patch2.Diff(patch.diffs[y][0], patch.diffs[y][1]);
+          patchCopy.diffs[y] = new diff_match_patch3.Diff(patch.diffs[y][0], patch.diffs[y][1]);
         }
         patchCopy.start1 = patch.start1;
         patchCopy.start2 = patch.start2;
@@ -1180,7 +1180,7 @@ var require_diff_match_patch = __commonJS({
       }
       return patchesCopy;
     };
-    diff_match_patch2.prototype.patch_apply = function(patches, text) {
+    diff_match_patch3.prototype.patch_apply = function(patches, text) {
       if (patches.length == 0) {
         return [text, []];
       }
@@ -1260,7 +1260,7 @@ var require_diff_match_patch = __commonJS({
       text = text.substring(nullPadding.length, text.length - nullPadding.length);
       return [text, results];
     };
-    diff_match_patch2.prototype.patch_addPadding = function(patches) {
+    diff_match_patch3.prototype.patch_addPadding = function(patches) {
       var paddingLength = this.Patch_Margin;
       var nullPadding = "";
       for (var x = 1; x <= paddingLength; x++) {
@@ -1273,7 +1273,7 @@ var require_diff_match_patch = __commonJS({
       var patch = patches[0];
       var diffs = patch.diffs;
       if (diffs.length == 0 || diffs[0][0] != DIFF_EQUAL) {
-        diffs.unshift(new diff_match_patch2.Diff(DIFF_EQUAL, nullPadding));
+        diffs.unshift(new diff_match_patch3.Diff(DIFF_EQUAL, nullPadding));
         patch.start1 -= paddingLength;
         patch.start2 -= paddingLength;
         patch.length1 += paddingLength;
@@ -1289,7 +1289,7 @@ var require_diff_match_patch = __commonJS({
       patch = patches[patches.length - 1];
       diffs = patch.diffs;
       if (diffs.length == 0 || diffs[diffs.length - 1][0] != DIFF_EQUAL) {
-        diffs.push(new diff_match_patch2.Diff(DIFF_EQUAL, nullPadding));
+        diffs.push(new diff_match_patch3.Diff(DIFF_EQUAL, nullPadding));
         patch.length1 += paddingLength;
         patch.length2 += paddingLength;
       } else if (paddingLength > diffs[diffs.length - 1][1].length) {
@@ -1300,7 +1300,7 @@ var require_diff_match_patch = __commonJS({
       }
       return nullPadding;
     };
-    diff_match_patch2.prototype.patch_splitMax = function(patches) {
+    diff_match_patch3.prototype.patch_splitMax = function(patches) {
       var patch_size = this.Match_MaxBits;
       for (var x = 0; x < patches.length; x++) {
         if (patches[x].length1 <= patch_size) {
@@ -1312,13 +1312,13 @@ var require_diff_match_patch = __commonJS({
         var start2 = bigpatch.start2;
         var precontext = "";
         while (bigpatch.diffs.length !== 0) {
-          var patch = new diff_match_patch2.patch_obj();
+          var patch = new diff_match_patch3.patch_obj();
           var empty = true;
           patch.start1 = start1 - precontext.length;
           patch.start2 = start2 - precontext.length;
           if (precontext !== "") {
             patch.length1 = patch.length2 = precontext.length;
-            patch.diffs.push(new diff_match_patch2.Diff(DIFF_EQUAL, precontext));
+            patch.diffs.push(new diff_match_patch3.Diff(DIFF_EQUAL, precontext));
           }
           while (bigpatch.diffs.length !== 0 && patch.length1 < patch_size - this.Patch_Margin) {
             var diff_type = bigpatch.diffs[0][0];
@@ -1332,7 +1332,7 @@ var require_diff_match_patch = __commonJS({
               patch.length1 += diff_text.length;
               start1 += diff_text.length;
               empty = false;
-              patch.diffs.push(new diff_match_patch2.Diff(diff_type, diff_text));
+              patch.diffs.push(new diff_match_patch3.Diff(diff_type, diff_text));
               bigpatch.diffs.shift();
             } else {
               diff_text = diff_text.substring(
@@ -1347,7 +1347,7 @@ var require_diff_match_patch = __commonJS({
               } else {
                 empty = false;
               }
-              patch.diffs.push(new diff_match_patch2.Diff(diff_type, diff_text));
+              patch.diffs.push(new diff_match_patch3.Diff(diff_type, diff_text));
               if (diff_text == bigpatch.diffs[0][1]) {
                 bigpatch.diffs.shift();
               } else {
@@ -1364,7 +1364,7 @@ var require_diff_match_patch = __commonJS({
             if (patch.diffs.length !== 0 && patch.diffs[patch.diffs.length - 1][0] === DIFF_EQUAL) {
               patch.diffs[patch.diffs.length - 1][1] += postcontext;
             } else {
-              patch.diffs.push(new diff_match_patch2.Diff(DIFF_EQUAL, postcontext));
+              patch.diffs.push(new diff_match_patch3.Diff(DIFF_EQUAL, postcontext));
             }
           }
           if (!empty) {
@@ -1373,14 +1373,14 @@ var require_diff_match_patch = __commonJS({
         }
       }
     };
-    diff_match_patch2.prototype.patch_toText = function(patches) {
+    diff_match_patch3.prototype.patch_toText = function(patches) {
       var text = [];
       for (var x = 0; x < patches.length; x++) {
         text[x] = patches[x];
       }
       return text.join("");
     };
-    diff_match_patch2.prototype.patch_fromText = function(textline) {
+    diff_match_patch3.prototype.patch_fromText = function(textline) {
       var patches = [];
       if (!textline) {
         return patches;
@@ -1393,7 +1393,7 @@ var require_diff_match_patch = __commonJS({
         if (!m) {
           throw new Error("Invalid patch string: " + text[textPointer]);
         }
-        var patch = new diff_match_patch2.patch_obj();
+        var patch = new diff_match_patch3.patch_obj();
         patches.push(patch);
         patch.start1 = parseInt(m[1], 10);
         if (m[2] === "") {
@@ -1424,11 +1424,11 @@ var require_diff_match_patch = __commonJS({
             throw new Error("Illegal escape in patch_fromText: " + line);
           }
           if (sign == "-") {
-            patch.diffs.push(new diff_match_patch2.Diff(DIFF_DELETE, line));
+            patch.diffs.push(new diff_match_patch3.Diff(DIFF_DELETE, line));
           } else if (sign == "+") {
-            patch.diffs.push(new diff_match_patch2.Diff(DIFF_INSERT, line));
+            patch.diffs.push(new diff_match_patch3.Diff(DIFF_INSERT, line));
           } else if (sign == " ") {
-            patch.diffs.push(new diff_match_patch2.Diff(DIFF_EQUAL, line));
+            patch.diffs.push(new diff_match_patch3.Diff(DIFF_EQUAL, line));
           } else if (sign == "@") {
             break;
           } else if (sign === "") {
@@ -1440,14 +1440,14 @@ var require_diff_match_patch = __commonJS({
       }
       return patches;
     };
-    diff_match_patch2.patch_obj = function() {
+    diff_match_patch3.patch_obj = function() {
       this.diffs = [];
       this.start1 = null;
       this.start2 = null;
       this.length1 = 0;
       this.length2 = 0;
     };
-    diff_match_patch2.patch_obj.prototype.toString = function() {
+    diff_match_patch3.patch_obj.prototype.toString = function() {
       var coords1, coords2;
       if (this.length1 === 0) {
         coords1 = this.start1 + ",0";
@@ -1481,48 +1481,14 @@ var require_diff_match_patch = __commonJS({
       }
       return text.join("").replace(/%20/g, " ");
     };
-    module.exports = diff_match_patch2;
-    module.exports["diff_match_patch"] = diff_match_patch2;
+    module.exports = diff_match_patch3;
+    module.exports["diff_match_patch"] = diff_match_patch3;
     module.exports["DIFF_DELETE"] = DIFF_DELETE;
     module.exports["DIFF_INSERT"] = DIFF_INSERT;
     module.exports["DIFF_EQUAL"] = DIFF_EQUAL;
   }
 });
 
-// adapters/xml-adapter.js
-var _DOMParser = globalThis.DOMParser;
-var _XMLSerializer = globalThis.XMLSerializer;
-function configureXmlProvider(options = {}) {
-  if (options.DOMParser) _DOMParser = options.DOMParser;
-  if (options.XMLSerializer) _XMLSerializer = options.XMLSerializer;
-}
-function createParser() {
-  if (!_DOMParser && globalThis.DOMParser) {
-    _DOMParser = globalThis.DOMParser;
-  }
-  if (!_DOMParser) {
-    throw new Error("DOMParser is not configured. Call configureXmlProvider({ DOMParser, XMLSerializer }) first.");
-  }
-  return new _DOMParser();
-}
-function createSerializer() {
-  if (!_XMLSerializer && globalThis.XMLSerializer) {
-    _XMLSerializer = globalThis.XMLSerializer;
-  }
-  if (!_XMLSerializer) {
-    throw new Error("XMLSerializer is not configured. Call configureXmlProvider({ DOMParser, XMLSerializer }) first.");
-  }
-  return new _XMLSerializer();
-}
-function parseXml(xmlString, contentType = "text/xml") {
-  const parser = createParser();
-  return parser.parseFromString(xmlString, contentType);
-}
-function serializeXml(node) {
-  const serializer = createSerializer();
-  return serializer.serializeToString(node);
-}
-
 // adapters/logger.js
 var _logger = console;
 var LEVELS = Object.freeze({
@@ -1565,6 +1531,86 @@ function error(...args) {
   }))(...args);
 }
 
+// adapters/xml-adapter.js
+var _DOMParser = globalThis.DOMParser;
+var _XMLSerializer = globalThis.XMLSerializer;
+function configureXmlProvider(options = {}) {
+  if (options.DOMParser) _DOMParser = options.DOMParser;
+  if (options.XMLSerializer) _XMLSerializer = options.XMLSerializer;
+}
+function createParser(options = {}) {
+  if (!_DOMParser && globalThis.DOMParser) {
+    _DOMParser = globalThis.DOMParser;
+  }
+  if (!_DOMParser) {
+    throw new Error("DOMParser is not configured. Call configureXmlProvider({ DOMParser, XMLSerializer }) first.");
+  }
+  return new _DOMParser(options);
+}
+function createSerializer() {
+  if (!_XMLSerializer && globalThis.XMLSerializer) {
+    _XMLSerializer = globalThis.XMLSerializer;
+  }
+  if (!_XMLSerializer) {
+    throw new Error("XMLSerializer is not configured. Call configureXmlProvider({ DOMParser, XMLSerializer }) first.");
+  }
+  return new _XMLSerializer();
+}
+function parseXml(xmlString, contentType = "text/xml") {
+  const result = parseOoxmlSafe(xmlString, contentType);
+  if (result.error) {
+    const parseError = new Error(result.error.message);
+    parseError.code = result.error.code;
+    throw parseError;
+  }
+  return result.doc;
+}
+function browserParseError(doc) {
+  if (!doc?.documentElement) return null;
+  if (String(doc.documentElement.localName || doc.documentElement.nodeName).toLowerCase() === "parsererror") {
+    return doc.documentElement;
+  }
+  return doc.getElementsByTagName?.("parsererror")?.[0] || null;
+}
+function parseOoxmlSafe(xmlString, contentType = "application/xml") {
+  const warnings = [];
+  if (typeof xmlString !== "string" || xmlString.trim() === "") {
+    return {
+      doc: null,
+      error: { code: "PARSE_ERROR", message: "Input is not a non-empty XML string." },
+      warnings
+    };
+  }
+  const onError = (level, message) => {
+    const diagnostic = String(message || "XML parser diagnostic.");
+    if (level === "fatalError") {
+      error("[XmlAdapter] XML fatal parse error:", diagnostic);
+    } else {
+      warnings.push(diagnostic);
+      warn(`[XmlAdapter] XML ${level || "warning"}:`, diagnostic);
+    }
+  };
+  try {
+    const parser = createParser({ onError });
+    const doc = parser.parseFromString(xmlString, contentType);
+    const parseError = browserParseError(doc);
+    if (!doc?.documentElement || parseError) {
+      const message = parseError?.textContent || "Could not parse XML input.";
+      error("[XmlAdapter] XML parse error:", message);
+      return { doc: null, error: { code: "PARSE_ERROR", message }, warnings };
+    }
+    return { doc, error: null, warnings };
+  } catch (caught) {
+    const message = caught?.message || String(caught || "Could not parse XML input.");
+    error("[XmlAdapter] XML parse error:", message);
+    return { doc: null, error: { code: "PARSE_ERROR", message }, warnings };
+  }
+}
+function serializeXml(node) {
+  const serializer = createSerializer();
+  return serializer.serializeToString(node);
+}
+
 // adapters/config.js
 var _defaultAuthor = "Author";
 var _platform = "Unknown";
@@ -1786,37 +1832,108 @@ function escapeXml(str) {
   if (!str) return "";
   return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
 }
-var revisionIdCounter = 1e3;
+var DEFAULT_REVISION_ID_START = 1e3;
+var MAX_PRACTICAL_REVISION_ID = 2147483647;
+var REVISION_ID_SAFETY_MARGIN = 1e4;
+var REVISION_ELEMENT_NAMES = /* @__PURE__ */ new Set([
+  "ins",
+  "del",
+  "moveFrom",
+  "moveTo",
+  "rPrChange",
+  "pPrChange",
+  "cellIns",
+  "cellDel",
+  "comment"
+]);
+var revisionAllocatorByDocument = /* @__PURE__ */ new WeakMap();
+function isRevisionIdElement(element) {
+  if (!element || element.nodeType !== 1) return false;
+  const localName = String(element.localName || element.nodeName || "").replace(/^.*:/, "");
+  if (!REVISION_ELEMENT_NAMES.has(localName)) return false;
+  return !element.namespaceURI || element.namespaceURI === NS_W || String(element.nodeName || "").startsWith("w:");
+}
+function readWordId(element) {
+  const raw = element?.getAttributeNS?.(NS_W, "id") || element?.getAttribute?.("w:id") || element?.getAttribute?.("id");
+  const parsed = Number.parseInt(String(raw ?? ""), 10);
+  return Number.isInteger(parsed) && parsed >= 0 ? parsed : null;
+}
+var RevisionIdAllocator = class {
+  constructor(startValue = DEFAULT_REVISION_ID_START) {
+    this.startValue = Number.isInteger(startValue) && startValue >= 0 ? startValue : DEFAULT_REVISION_ID_START;
+    this.nextId = this.startValue;
+    this.occupiedIds = /* @__PURE__ */ new Set();
+  }
+  seed(xmlDoc) {
+    let maxFound = -1;
+    const elements = Array.from(xmlDoc?.getElementsByTagName?.("*") || []);
+    if (xmlDoc?.nodeType === 1) elements.unshift(xmlDoc);
+    for (const element of elements) {
+      if (!isRevisionIdElement(element)) continue;
+      const id = readWordId(element);
+      if (id == null) continue;
+      this.occupiedIds.add(id);
+      maxFound = Math.max(maxFound, id);
+    }
+    const highRiskBoundary = MAX_PRACTICAL_REVISION_ID - REVISION_ID_SAFETY_MARGIN;
+    this.nextId = maxFound >= highRiskBoundary ? this.startValue : Math.max(this.nextId, maxFound + 1);
+    this.advanceToAvailableId();
+    return this.nextId;
+  }
+  advanceToAvailableId() {
+    const highRiskBoundary = MAX_PRACTICAL_REVISION_ID - REVISION_ID_SAFETY_MARGIN;
+    if (this.nextId >= highRiskBoundary) this.nextId = this.startValue;
+    while (this.occupiedIds.has(this.nextId)) {
+      this.nextId += 1;
+      if (this.nextId >= highRiskBoundary) this.nextId = this.startValue;
+    }
+  }
+  next() {
+    this.advanceToAvailableId();
+    const id = this.nextId;
+    this.occupiedIds.add(id);
+    this.nextId += 1;
+    return id;
+  }
+};
+var defaultRevisionIdAllocator = new RevisionIdAllocator();
+function setRevisionIdAllocatorForDocument(xmlNode, allocator) {
+  const xmlDoc = xmlNode?.nodeType === 9 ? xmlNode : xmlNode?.ownerDocument;
+  if (xmlDoc && allocator instanceof RevisionIdAllocator) {
+    revisionAllocatorByDocument.set(xmlDoc, allocator);
+  }
+  return allocator;
+}
+function getRevisionIdAllocatorForDocument(xmlNode) {
+  const xmlDoc = xmlNode?.nodeType === 9 ? xmlNode : xmlNode?.ownerDocument;
+  return xmlDoc ? revisionAllocatorByDocument.get(xmlDoc) || null : null;
+}
+function createRevisionIdAllocator(xmlDoc, startValue = DEFAULT_REVISION_ID_START) {
+  const allocator = new RevisionIdAllocator(startValue);
+  allocator.seed(xmlDoc);
+  setRevisionIdAllocatorForDocument(xmlDoc, allocator);
+  return allocator;
+}
 function getNextRevisionId() {
-  return revisionIdCounter++;
+  return defaultRevisionIdAllocator.next();
 }
 function getRevisionTimestamp(date = /* @__PURE__ */ new Date()) {
   return date.toISOString();
 }
-function createRevisionMetadata(author) {
+function createRevisionMetadata(author, allocatorOrNode = null) {
   const resolvedAuthor = typeof author === "string" && author.trim() ? author.trim() : getDefaultAuthor();
+  const allocator = allocatorOrNode instanceof RevisionIdAllocator ? allocatorOrNode : getRevisionIdAllocatorForDocument(allocatorOrNode) || defaultRevisionIdAllocator;
   return {
-    id: getNextRevisionId(),
+    id: allocator.next(),
     author: resolvedAuthor,
     date: getRevisionTimestamp()
   };
 }
-function seedRevisionIdsFromDocument(xmlDoc) {
-  let maxFound = -1;
-  const elements = Array.from(xmlDoc?.getElementsByTagName?.("*") || []);
-  for (const element of elements) {
-    for (const attr of Array.from(element.attributes || [])) {
-      if ((attr.localName || "").toLowerCase() !== "id") continue;
-      const parsed = Number.parseInt(attr.value, 10);
-      if (Number.isFinite(parsed)) {
-        maxFound = Math.max(maxFound, parsed);
-      }
-    }
-  }
-  if (maxFound >= revisionIdCounter) {
-    revisionIdCounter = maxFound + 1;
-  }
-  return revisionIdCounter;
+function seedRevisionIdsFromDocument(xmlDoc, allocator = defaultRevisionIdAllocator) {
+  const resolvedAllocator = allocator instanceof RevisionIdAllocator ? allocator : defaultRevisionIdAllocator;
+  const nextId = resolvedAllocator.seed(xmlDoc);
+  setRevisionIdAllocatorForDocument(xmlDoc, resolvedAllocator);
+  return nextId;
 }
 
 // core/paragraph-offset-policy.js
@@ -1894,10 +2011,12 @@ function ingestOoxml(ooxmlString, options = {}) {
     return { runModel, acceptedText, pPr: null };
   }
   try {
-    const doc = preParsedDoc || (() => {
-      const parser = createParser();
-      return parser.parseFromString(ooxmlString, "application/xml");
-    })();
+    const parsed = preParsedDoc ? { doc: preParsedDoc, error: null } : parseOoxmlSafe(ooxmlString, "application/xml");
+    const doc = parsed.doc;
+    if (parsed.error || !doc) {
+      error("OOXML parse error:", parsed.error?.message);
+      return { runModel, acceptedText, pPr: null, error: parsed.error };
+    }
     const parseError = getXmlParseError(doc);
     if (parseError) {
       error("OOXML parse error:", parseError.textContent);
@@ -2302,55 +2421,126 @@ function extractTrPr(trNode) {
 
 // pipeline/diff-engine.js
 var import_diff_match_patch = __toESM(require_diff_match_patch(), 1);
-var DMP = new import_diff_match_patch.diff_match_patch();
-function wordsToChars(text1, text2) {
+var TOKEN_CODE_POINT_BASE = 65536;
+var MAX_DIFF_TOKENS = 262144;
+var BMP_FIRST_CODE = 1;
+var BMP_BEFORE_SURROGATES = 55296 - BMP_FIRST_CODE;
+var BMP_AFTER_SURROGATES = 65536 - 57344;
+var DMP_SAFE_TOKEN_LIMIT = BMP_BEFORE_SURROGATES + BMP_AFTER_SURROGATES;
+var DiffTokenLimitError = class extends Error {
+  constructor(limit = MAX_DIFF_TOKENS) {
+    super(`Word diff exceeds the safe limit of ${limit} unique tokens.`);
+    this.name = "DiffTokenLimitError";
+    this.code = "DIFF_TOKEN_LIMIT";
+    this.limit = limit;
+  }
+};
+function isDiffTokenLimitError(error2) {
+  return error2?.code === "DIFF_TOKEN_LIMIT";
+}
+function createDiffEngine(options = {}) {
+  const timeout = options.diffTimeoutSeconds ?? 0;
+  if (!Number.isFinite(timeout) || timeout < 0) {
+    throw new TypeError("diffTimeoutSeconds must be a finite non-negative number.");
+  }
+  const engine = new import_diff_match_patch.diff_match_patch();
+  engine.Diff_Timeout = timeout;
+  return engine;
+}
+function tokenize(text) {
+  const tokens = [];
+  const leading = text.match(/^\s+/);
+  if (leading) tokens.push(leading[0]);
+  const regex = /(\S+)(\s*)/g;
+  regex.lastIndex = leading?.[0].length || 0;
+  let match;
+  while ((match = regex.exec(text)) !== null) {
+    if (match[1]) tokens.push(match[1]);
+    if (match[2]) tokens.push(match[2]);
+  }
+  return tokens;
+}
+function wordsToChars(text1, text2, options = {}) {
   const wordArray = [];
   const wordHash = /* @__PURE__ */ new Map();
-  function tokenize(text) {
-    const tokens = [];
-    const regex = /(\S+)(\s*)/g;
-    let match;
-    while ((match = regex.exec(text)) !== null) {
-      if (match[1]) tokens.push(match[1]);
-      if (match[2]) tokens.push(match[2]);
-    }
-    return tokens;
+  const maxTokens = options.maxTokens ?? MAX_DIFF_TOKENS;
+  if (!Number.isInteger(maxTokens) || maxTokens < 1 || maxTokens > MAX_DIFF_TOKENS) {
+    throw new RangeError(`maxTokens must be an integer from 1 to ${MAX_DIFF_TOKENS}.`);
   }
   function mapTokensToChars(tokens) {
     let chars = "";
+    const tokenIds = [];
     for (const token of tokens) {
-      if (wordHash.has(token)) {
-        chars += String.fromCharCode(wordHash.get(token));
-      } else {
-        const charCode = wordArray.length;
+      let tokenId = wordHash.get(token);
+      if (tokenId === void 0) {
+        if (wordArray.length >= maxTokens) throw new DiffTokenLimitError(maxTokens);
+        tokenId = wordArray.length;
         wordArray.push(token);
-        wordHash.set(token, charCode);
-        chars += String.fromCharCode(charCode);
+        wordHash.set(token, tokenId);
       }
+      tokenIds.push(tokenId);
+      chars += String.fromCodePoint(TOKEN_CODE_POINT_BASE + tokenId);
     }
-    return chars;
+    return { chars, tokenIds };
   }
   const tokens1 = tokenize(text1);
   const tokens2 = tokenize(text2);
+  const encoded1 = mapTokensToChars(tokens1);
+  const encoded2 = mapTokensToChars(tokens2);
   return {
-    chars1: mapTokensToChars(tokens1),
-    chars2: mapTokensToChars(tokens2),
-    wordArray
+    chars1: encoded1.chars,
+    chars2: encoded2.chars,
+    wordArray,
+    tokenIds1: encoded1.tokenIds,
+    tokenIds2: encoded2.tokenIds
   };
 }
-function charsToWords(diffs, wordArray) {
-  const wordDiffs = [];
-  for (const [op, chars] of diffs) {
+function tokenIdToBmpChar(tokenId) {
+  const code = tokenId < BMP_BEFORE_SURROGATES ? BMP_FIRST_CODE + tokenId : 57344 + (tokenId - BMP_BEFORE_SURROGATES);
+  return String.fromCharCode(code);
+}
+function bmpCharToTokenId(charCode) {
+  if (charCode >= BMP_FIRST_CODE && charCode < 55296) return charCode - BMP_FIRST_CODE;
+  if (charCode >= 57344 && charCode <= 65535) return BMP_BEFORE_SURROGATES + charCode - 57344;
+  throw new RangeError(`BMP diff token U+${charCode.toString(16).toUpperCase()} has no mapping.`);
+}
+function encodeTokenIdsForDmp(tokenIds) {
+  let chars = "";
+  for (const tokenId of tokenIds) chars += tokenIdToBmpChar(tokenId);
+  return chars;
+}
+function decodeBmpDiffs(diffs, wordArray) {
+  return diffs.map(([op, chars]) => {
     const parts = [];
-    for (let i = 0; i < chars.length; i++) {
-      const charCode = chars.charCodeAt(i);
-      if (charCode < wordArray.length) {
-        parts.push(wordArray[charCode]);
+    for (let index = 0; index < chars.length; index++) {
+      const tokenId = bmpCharToTokenId(chars.charCodeAt(index));
+      if (tokenId >= wordArray.length) {
+        throw new RangeError(`BMP diff token ${tokenId} has no mapping.`);
       }
+      parts.push(wordArray[tokenId]);
     }
-    wordDiffs.push([op, parts.join("")]);
-  }
-  return wordDiffs;
+    return [op, parts.join("")];
+  });
+}
+function deterministicLargeTokenDiff(tokenIds1, tokenIds2, wordArray) {
+  let prefixLength = 0;
+  const sharedLength = Math.min(tokenIds1.length, tokenIds2.length);
+  while (prefixLength < sharedLength && tokenIds1[prefixLength] === tokenIds2[prefixLength]) {
+    prefixLength++;
+  }
+  let suffixLength = 0;
+  while (suffixLength < sharedLength - prefixLength && tokenIds1[tokenIds1.length - 1 - suffixLength] === tokenIds2[tokenIds2.length - 1 - suffixLength]) {
+    suffixLength++;
+  }
+  const joinTokens = (ids) => ids.map((id) => wordArray[id]).join("");
+  const diffs = [];
+  if (prefixLength) diffs.push([0, joinTokens(tokenIds1.slice(0, prefixLength))]);
+  const deleted = tokenIds1.slice(prefixLength, tokenIds1.length - suffixLength);
+  const inserted = tokenIds2.slice(prefixLength, tokenIds2.length - suffixLength);
+  if (deleted.length) diffs.push([-1, joinTokens(deleted)]);
+  if (inserted.length) diffs.push([1, joinTokens(inserted)]);
+  if (suffixLength) diffs.push([0, joinTokens(tokenIds1.slice(tokenIds1.length - suffixLength))]);
+  return diffs;
 }
 function computeWordDiffs(originalText, newText, options = {}) {
   if (originalText === newText) {
@@ -2363,12 +2553,16 @@ function computeWordDiffs(originalText, newText, options = {}) {
     return [[-1, originalText]];
   }
   const { cleanupSemantic = true } = options;
-  const { chars1, chars2, wordArray } = wordsToChars(originalText, newText);
-  const charDiffs = DMP.diff_main(chars1, chars2);
+  const { wordArray, tokenIds1, tokenIds2 } = wordsToChars(originalText, newText, options);
+  if (wordArray.length > DMP_SAFE_TOKEN_LIMIT) {
+    return deterministicLargeTokenDiff(tokenIds1, tokenIds2, wordArray);
+  }
+  const dmp = createDiffEngine(options);
+  const charDiffs = dmp.diff_main(encodeTokenIdsForDmp(tokenIds1), encodeTokenIdsForDmp(tokenIds2));
   if (cleanupSemantic) {
-    DMP.diff_cleanupSemantic(charDiffs);
+    dmp.diff_cleanupSemantic(charDiffs);
   }
-  return charsToWords(charDiffs, wordArray);
+  return decodeBmpDiffs(charDiffs, wordArray);
 }
 function computeWordLevelDiffOps(originalText, newText, options = {}) {
   if (originalText === newText) {
@@ -2559,7 +2753,6 @@ function applyPatches(splitModel, diffOps, options) {
 function processInsertionOperation(context) {
   const {
     insertOp,
-    splitModel,
     styleLookup,
     patchedModel,
     state,
@@ -2824,7 +3017,7 @@ function buildParagraphOnlyPackage(paragraphXml) {
 var XMLNS_ATTR_REGEX2 = /\s+xmlns:[^=]+="[^"]*"/g;
 function serializeToOoxml(patchedModel, pPr, formatHints = [], options = {}) {
   const serializationOptions = normalizeSerializationOptions(options);
-  const { author, generateRedlines } = serializationOptions;
+  const { generateRedlines } = serializationOptions;
   const paragraphs = [];
   let currentPPrXml = "";
   let currentPPrElement = null;
@@ -2912,7 +3105,8 @@ function normalizeSerializationOptions(options) {
     return {
       author: getDefaultAuthor(),
       generateRedlines: true,
-      font: options
+      font: options,
+      revisionIdAllocator: null
     };
   }
   const normalized = options && typeof options === "object" ? options : {};
@@ -2920,7 +3114,8 @@ function normalizeSerializationOptions(options) {
   return {
     author: resolvedAuthor,
     generateRedlines: normalized.generateRedlines ?? true,
-    font: normalized.font ?? null
+    font: normalized.font ?? null,
+    revisionIdAllocator: normalized.revisionIdAllocator ?? null
   };
 }
 function buildRunXmlWithHints(item, formatHints, options = {}) {
@@ -2958,7 +3153,10 @@ function buildSimpleRun(text, rPrXml) {
   return `<w:r>${rPr}<w:t xml:space="preserve">${escapeXml(text)}</w:t></w:r>`;
 }
 function buildDeletionXml(item, options = {}) {
-  const metadata = createRevisionMetadata(options.author ?? getDefaultAuthor());
+  const metadata = createRevisionMetadata(
+    options.author ?? getDefaultAuthor(),
+    options.revisionIdAllocator
+  );
   const font = options.font ?? null;
   let rPr = item.rPrXml ? stripNamespaceDeclarations(item.rPrXml) : "";
   if (font) {
@@ -2967,7 +3165,10 @@ function buildDeletionXml(item, options = {}) {
   return `<w:del w:id="${metadata.id}" w:author="${escapeXml(metadata.author)}" w:date="${metadata.date}"><w:r>${rPr}<w:delText xml:space="preserve">${escapeXml(item.text)}</w:delText></w:r></w:del>`;
 }
 function buildInsertionXml(item, formatHints, options = {}) {
-  const metadata = createRevisionMetadata(options.author ?? getDefaultAuthor());
+  const metadata = createRevisionMetadata(
+    options.author ?? getDefaultAuthor(),
+    options.revisionIdAllocator
+  );
   const font = options.font ?? null;
   const applicableHints = getApplicableFormatHints(formatHints, item.startOffset, item.endOffset);
   let innerContent = "";
@@ -3287,8 +3488,8 @@ var NumberingService = class {
 
 // services/table-reconciliation.js
 function generateTableOoxml(tableData, options = {}) {
-  const { generateRedlines = false, author = "AI" } = options;
-  const tableInsertMeta = generateRedlines ? createRevisionMetadata(author) : null;
+  const { generateRedlines = false, author = "AI", revisionIdAllocator = null } = options;
+  const tableInsertMeta = generateRedlines ? createRevisionMetadata(author, revisionIdAllocator) : null;
   const numCols = tableData.headers?.length || (tableData.rows?.[0]?.length || 1);
   const tblPr = `
         <w:tblPr>
@@ -3323,7 +3524,11 @@ function generateTableOoxml(tableData, options = {}) {
         startOffset: 0,
         endOffset: cleanText.length
       }];
-      const runsOoxml = serializeToOoxml(runModel, null, formatHints, { author, generateRedlines });
+      const runsOoxml = serializeToOoxml(runModel, null, formatHints, {
+        author,
+        generateRedlines,
+        revisionIdAllocator
+      });
       const tcPr = '<w:tcPr><w:tcW w:w="0" w:type="auto"/></w:tcPr>';
       cellsXml += `<w:tc>${tcPr}${runsOoxml}</w:tc>`;
     }
@@ -3381,7 +3586,7 @@ function diffTablesWithVirtualGrid(oldGrid, newTableData) {
   return operations;
 }
 function serializeVirtualGridToOoxml(grid, operations, options) {
-  const { generateRedlines, author } = options;
+  const { generateRedlines, author, revisionIdAllocator = null } = options;
   const opIndex = buildTableOperationIndex(operations);
   let rowsXml = "";
   for (let row = 0; row < grid.rowCount; row++) {
@@ -3411,7 +3616,7 @@ function serializeVirtualGridToOoxml(grid, operations, options) {
     }
     let trPr = grid.trPrList[row] || "<w:trPr/>";
     if (rowDeleteOp && generateRedlines) {
-      const metadata = createRevisionMetadata(author);
+      const metadata = createRevisionMetadata(author, revisionIdAllocator);
       const delMark = `<w:del w:id="${metadata.id}" w:author="${escapeXml(metadata.author)}" w:date="${metadata.date}"/>`;
       if (trPr.includes("</w:trPr>")) {
         trPr = trPr.replace("</w:trPr>", `${delMark}</w:trPr>`);
@@ -3424,7 +3629,7 @@ function serializeVirtualGridToOoxml(grid, operations, options) {
   const insertOps = opIndex.rowInsertOperations;
   for (const op of insertOps) {
     let cellsXml = "";
-    const rowInsertMeta = generateRedlines ? createRevisionMetadata(author) : null;
+    const rowInsertMeta = generateRedlines ? createRevisionMetadata(author, revisionIdAllocator) : null;
     for (const cellText of op.cells) {
       const { cleanText, formatHints } = preprocessMarkdown(cellText);
       const runModel = [{
@@ -3435,7 +3640,11 @@ function serializeVirtualGridToOoxml(grid, operations, options) {
         startOffset: 0,
         endOffset: cleanText.length
       }];
-      const runsOoxml = serializeToOoxml(runModel, null, formatHints, { author, generateRedlines });
+      const runsOoxml = serializeToOoxml(runModel, null, formatHints, {
+        author,
+        generateRedlines,
+        revisionIdAllocator
+      });
       cellsXml += `<w:tc><w:tcPr><w:tcW w:w="0" w:type="auto"/></w:tcPr>${runsOoxml}</w:tc>`;
     }
     let trPr = "<w:trPr/>";
@@ -3473,7 +3682,7 @@ function buildTableOperationIndex(operations) {
   };
 }
 function reconcileCellContent(cell, newText, options) {
-  const { generateRedlines, author } = options;
+  const { generateRedlines, author, revisionIdAllocator = null } = options;
   const { cleanText, formatHints } = preprocessMarkdown(newText);
   const oldText = cell.getText();
   const diffOps = computeWordLevelDiffOps(oldText, cleanText);
@@ -3484,7 +3693,11 @@ function reconcileCellContent(cell, newText, options) {
     author,
     formatHints
   });
-  const runsOoxml = serializeToOoxml(patchedModel, baseBlock.pPr, formatHints, { author, generateRedlines });
+  const runsOoxml = serializeToOoxml(patchedModel, baseBlock.pPr, formatHints, {
+    author,
+    generateRedlines,
+    revisionIdAllocator
+  });
   return runsOoxml;
 }
 function serializeCellBlocks(blocks) {
@@ -3493,7 +3706,7 @@ function serializeCellBlocks(blocks) {
     return runsOoxml;
   }).join("");
 }
-function buildTcXml(cell, content, options) {
+function buildTcXml(cell, content, _options) {
   let tcPr = cell.tcPrXml;
   if (cell.colSpan > 1 && !tcPr.includes("gridSpan")) {
     tcPr = tcPr.replace("</w:tcPr>", `<w:gridSpan w:val="${cell.colSpan}"/></w:tcPr>`);
@@ -3547,6 +3760,7 @@ async function executeListGeneration(options) {
     generateRedlines = true,
     author = "AI",
     font = null,
+    revisionIdAllocator = null,
     numberingService
   } = options;
   const normalizedListText = normalizeCompositeListMarkers(cleanText);
@@ -3582,10 +3796,15 @@ async function executeListGeneration(options) {
           results.push(serializeToOoxml(deletionRuns, null, [], {
             author,
             generateRedlines,
-            font
+            font,
+            revisionIdAllocator
           }));
         }
-        results.push(generateTableOoxml(tableData, { generateRedlines, author }));
+        results.push(generateTableOoxml(tableData, {
+          generateRedlines,
+          author,
+          revisionIdAllocator
+        }));
         i = tableBlock.endIndex;
         continue;
       }
@@ -3600,6 +3819,7 @@ async function executeListGeneration(options) {
       generateRedlines,
       author,
       font,
+      revisionIdAllocator,
       deletionRuns
     );
     results.push(entry.ooxml);
@@ -3690,7 +3910,7 @@ function collectMarkdownTableBlock(lineMetadata, index) {
     endIndex: cursor - 1
   };
 }
-function buildListEntry(line, lineIndex, indentStep, numberingContext, numberingService, generateRedlines, author, font, deletionRuns) {
+function buildListEntry(line, lineIndex, indentStep, numberingContext, numberingService, generateRedlines, author, font, revisionIdAllocator, deletionRuns) {
   let pPrXml = "";
   let segmentText = "";
   if (line.headerMatch) {
@@ -3727,7 +3947,8 @@ function buildListEntry(line, lineIndex, indentStep, numberingContext, numbering
     ooxml: serializeToOoxml(runModel, pPrXml, formatHints, {
       author,
       generateRedlines,
-      font
+      font,
+      revisionIdAllocator
     })
   };
 }
@@ -3758,6 +3979,7 @@ var ReconciliationPipeline = class {
     this.validationMode = options.validationMode ?? "auto";
     this.numberingService = options.numberingService || new NumberingService();
     this.font = options.font || null;
+    this.revisionIdAllocator = options.revisionIdAllocator || null;
     this.platform = options.platform ?? getPlatform();
     this.isWebPlatform = options.isWebPlatform ?? isWebPlatform(this.platform);
     this.enableEventLoopYielding = options.enableEventLoopYielding ?? this.isWebPlatform;
@@ -3776,10 +3998,18 @@ var ReconciliationPipeline = class {
   async execute(originalOoxml, newText, options = {}) {
     const warnings = [];
     try {
-      const doc = options.xmlDoc || (() => {
-        const parser = createParser();
-        return parser.parseFromString(originalOoxml, "application/xml");
-      })();
+      const parsed = options.xmlDoc ? { doc: options.xmlDoc, error: null, warnings: [] } : parseOoxmlSafe(originalOoxml, "application/xml");
+      if (parsed.error || !parsed.doc) {
+        return {
+          ooxml: originalOoxml,
+          isValid: false,
+          status: "error",
+          error: parsed.error,
+          warnings: parsed.warnings || []
+        };
+      }
+      warnings.push(...parsed.warnings || []);
+      const doc = parsed.doc;
       const pElement = getFirstElementByTagNS(doc, "*", "p");
       const { runModel, acceptedText, pPr } = ingestOoxml(originalOoxml, { xmlDoc: doc });
       const numberingContext = pElement ? detectNumberingContext(pElement) : null;
@@ -3811,8 +4041,12 @@ var ReconciliationPipeline = class {
       }
       await this.maybeYield(runModel.length, Math.max(acceptedText.length, cleanText.length));
       const paragraphCount = runModel.filter((r) => r.kind === RunKind.PARAGRAPH_START).length;
+      const sourceIsMarkedMultilineList = isListTargetStrict(acceptedText) || isListTargetLoose(acceptedText);
+      const canPatchExistingMarkedList = isTargetList && sourceIsMarkedMultilineList && paragraphCount > 1 && acceptedText !== cleanText;
       log(`[Reconcile] isTargetList: ${isTargetList}, paragraphCount: ${paragraphCount}`);
-      if (isTargetList) {
+      if (canPatchExistingMarkedList) {
+        log("[Reconcile] Existing marked list edit detected; using run-aware patching to preserve formatting and paragraph boundaries.");
+      } else if (isTargetList) {
         log("[Reconcile] \u{1F3AF} ENTERING LIST GENERATION PATH");
         log(`[Reconcile] cleanText preview: ${cleanText.substring(0, 100)}...`);
         log(`[Reconcile] acceptedText preview: ${acceptedText.substring(0, 100)}...`);
@@ -3831,7 +4065,8 @@ var ReconciliationPipeline = class {
       await this.maybeYield(patchedModel.length, Math.max(acceptedText.length, cleanText.length));
       const resultOoxml = serializeToOoxml(patchedModel, pPr, formatHints, {
         author: this.author,
-        generateRedlines: this.generateRedlines
+        generateRedlines: this.generateRedlines,
+        revisionIdAllocator: this.revisionIdAllocator
       });
       if (this.shouldRunValidation()) {
         const validation = this.validateBasic(resultOoxml);
@@ -3849,7 +4084,8 @@ var ReconciliationPipeline = class {
       return {
         ooxml: originalOoxml,
         isValid: false,
-        warnings: [`Pipeline error: ${error2.message}`]
+        warnings: [`Pipeline error: ${error2.message}`],
+        error: error2?.code ? { code: error2.code, message: error2.message } : void 0
       };
     }
   }
@@ -3863,8 +4099,12 @@ var ReconciliationPipeline = class {
     const errors = [];
     try {
       const wrappedXml = `<root xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">${ooxml}</root>`;
-      const parser = createParser();
-      const doc = parser.parseFromString(wrappedXml, "application/xml");
+      const parsed = parseOoxmlSafe(wrappedXml, "application/xml");
+      const doc = parsed.doc;
+      if (parsed.error || !doc) {
+        errors.push("Generated OOXML is not well-formed XML: " + (parsed.error?.message || "parse error"));
+        return { isValid: false, errors };
+      }
       const parseError = getXmlParseError(doc);
       if (parseError) {
         errors.push("Generated OOXML is not well-formed XML: " + parseError.textContent.substring(0, 100));
@@ -3935,6 +4175,7 @@ var ReconciliationPipeline = class {
       generateRedlines: this.generateRedlines,
       author: this.author,
       font: this.font,
+      revisionIdAllocator: this.revisionIdAllocator,
       numberingService: this.numberingService
     });
   }
@@ -3964,7 +4205,8 @@ var ReconciliationPipeline = class {
     }
     const tableOoxml = generateTableOoxml(tableData, {
       generateRedlines: this.generateRedlines,
-      author: this.author
+      author: this.author,
+      revisionIdAllocator: this.revisionIdAllocator
     });
     return {
       ooxml: tableOoxml,
@@ -4340,7 +4582,7 @@ function extractFormattingFromOoxml(xmlDoc) {
 // engine/run-builders.js
 function createTrackChange(xmlDoc, type, run, author) {
   const wrapper = createWordElement(xmlDoc, type === "ins" ? "w:ins" : "w:del");
-  const metadata = createRevisionMetadata(author);
+  const metadata = createRevisionMetadata(author, xmlDoc);
   wrapper.setAttribute("w:id", String(metadata.id));
   wrapper.setAttribute("w:author", metadata.author);
   wrapper.setAttribute("w:date", metadata.date);
@@ -4382,7 +4624,7 @@ function markParagraphMark(xmlDoc, paragraph, author, type) {
     }
   }
   const marker = createWordElement(xmlDoc, type === "ins" ? "w:ins" : "w:del");
-  const metadata = createRevisionMetadata(author);
+  const metadata = createRevisionMetadata(author, xmlDoc);
   marker.setAttribute("w:id", String(metadata.id));
   marker.setAttribute("w:author", metadata.author);
   marker.setAttribute("w:date", metadata.date);
@@ -4521,7 +4763,7 @@ function injectFormattingToRPr(xmlDoc, baseRPr, format, author, generateRedlines
 }
 function snapshotAndAttachRPrChange(xmlDoc, rPr, author, dateStr, sourceNode) {
   const rPrChange = createWordElement(xmlDoc, "w:rPrChange");
-  const metadata = createRevisionMetadata(author);
+  const metadata = createRevisionMetadata(author, xmlDoc);
   rPrChange.setAttribute("w:id", String(metadata.id));
   rPrChange.setAttribute("w:author", metadata.author);
   rPrChange.setAttribute("w:date", dateStr || metadata.date);
@@ -5351,11 +5593,11 @@ function insertTextRuns(xmlDoc, parent, referenceNode, text, baseRPr, author, fo
 }
 
 // engine/surgical-mode.js
-function applySurgicalMode(xmlDoc, originalText, modifiedText, serializer, author, formatHints, generateRedlines = true, targetParagraph = null) {
+function applySurgicalMode(xmlDoc, originalText, modifiedText, serializer, author, formatHints, generateRedlines = true, targetParagraph = null, diffOptions = {}) {
   void originalText;
   const allParagraphs = targetParagraph ? [targetParagraph] : getDocumentParagraphs(xmlDoc);
   const { fullText, textSpans } = buildSurgicalTextSpans(allParagraphs);
-  const diffs = computeWordDiffs(fullText, modifiedText);
+  const diffs = computeWordDiffs(fullText, modifiedText, diffOptions);
   const spanIndex = buildSpanIndex(textSpans);
   let originalPos = 0;
   let newPos = 0;
@@ -5398,10 +5640,28 @@ function applySurgicalMode(xmlDoc, originalText, modifiedText, serializer, autho
 }
 
 // engine/reconstruction-mapper.js
+var import_diff_match_patch2 = __toESM(require_diff_match_patch(), 1);
+var DMP = new import_diff_match_patch2.diff_match_patch();
+function localNameOf(node) {
+  return String(node?.localName || node?.nodeName || "").replace(/^.*:/, "");
+}
+function wordAttribute(node, localName) {
+  return node?.getAttributeNS?.(NS_W, localName) || node?.getAttribute?.(`w:${localName}`) || node?.getAttribute?.(localName) || "";
+}
 function createRangeCursorLookup2(ranges) {
   let cursor = 0;
   return {
     at(index) {
+      if (cursor > 0 && (!ranges[cursor] || index < ranges[cursor].start)) {
+        let low = 0;
+        let high = cursor - 1;
+        while (low <= high) {
+          const middle = Math.floor((low + high) / 2);
+          if (ranges[middle].end <= index) low = middle + 1;
+          else high = middle - 1;
+        }
+        cursor = low;
+      }
       while (cursor < ranges.length && ranges[cursor].end <= index) {
         cursor++;
       }
@@ -5422,11 +5682,11 @@ function indexSentinelsByStart(sentinelMap) {
   });
   return sentinelMapByStart;
 }
-function buildReconstructionMapping(xmlDoc, modifiedText) {
+function buildReconstructionMapping(xmlDoc, modifiedText, selectedParagraphs = null) {
   const rootElement = xmlDoc.documentElement;
-  const isBodyRoot = rootElement.nodeName === "w:body" || rootElement.nodeName.endsWith(":package");
-  const paragraphs = getDocumentParagraphs(xmlDoc);
-  let body = getFirstElementByTag(xmlDoc, "w:body");
+  const isBodyRoot = isWordElement(rootElement, "body") || localNameOf(rootElement) === "package";
+  const paragraphs = selectedParagraphs || getDocumentParagraphs(xmlDoc);
+  let body = getFirstElementByTagNSOrTag(xmlDoc, NS_W, "body");
   if (!body && isBodyRoot) body = rootElement;
   let originalFullText = "";
   const propertyMap = [];
@@ -5434,7 +5694,8 @@ function buildReconstructionMapping(xmlDoc, modifiedText) {
   const sentinelMap = [];
   const referenceMap = /* @__PURE__ */ new Map();
   const tokenToCharMap = /* @__PURE__ */ new Map();
-  let nextCharCode = 57344;
+  const breakChars = /* @__PURE__ */ new Set();
+  const characterState = { nextCharCode: 57344 };
   const uniqueContainers = /* @__PURE__ */ new Set();
   paragraphs.forEach((paragraph, paragraphIndex) => {
     const paragraphStart = originalFullText.length;
@@ -5446,15 +5707,13 @@ function buildReconstructionMapping(xmlDoc, modifiedText) {
         sentinelMap,
         referenceMap,
         tokenToCharMap,
-        nextCharCode
+        characterState,
+        breakChars
       );
-      if (referenceMap.size > tokenToCharMap.size) {
-        nextCharCode++;
-      }
     });
     originalFullText = appendParagraphBoundary(originalFullText, paragraphIndex, paragraphs.length);
     const paragraphEnd = originalFullText.length;
-    const pPr = getFirstElementByTag(paragraph, "w:pPr");
+    const pPr = getFirstElementByTagNSOrTag(paragraph, NS_W, "pPr");
     const container = paragraph.parentNode;
     if (container) uniqueContainers.add(container);
     paragraphMap.push({
@@ -5464,7 +5723,13 @@ function buildReconstructionMapping(xmlDoc, modifiedText) {
       container: container || body
     });
   });
-  let processedModifiedText = modifiedText;
+  let displayOriginalText = "";
+  for (let index = 0; index < originalFullText.length; index++) {
+    const char = originalFullText[index];
+    displayOriginalText += breakChars.has(char) ? "\n" : char;
+  }
+  let processedModifiedText = preserveZeroWidthSentinels(displayOriginalText, modifiedText, sentinelMap);
+  processedModifiedText = preserveStructuralBreaks(displayOriginalText, originalFullText, processedModifiedText, breakChars);
   tokenToCharMap.forEach((char, tokenString) => {
     const escapedToken = tokenString.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
     processedModifiedText = processedModifiedText.replace(new RegExp(escapedToken, "g"), char);
@@ -5520,6 +5785,124 @@ function buildReconstructionMapping(xmlDoc, modifiedText) {
     isParagraphStart: (index) => paragraphStarts.has(index)
   };
 }
+function findReconstructionParagraphRange(xmlDoc, originalText) {
+  const paragraphs = getDocumentParagraphs(xmlDoc);
+  if (paragraphs.length === 0) return [];
+  const wanted = normalizeComparisonText(originalText);
+  const paragraphTexts = paragraphs.map(extractParagraphVisibleText);
+  if (!wanted) {
+    const emptyIndex = paragraphTexts.findIndex((text) => text === "");
+    return emptyIndex >= 0 ? [paragraphs[emptyIndex]] : null;
+  }
+  if (paragraphs.length === 1 && paragraphTexts[0] === "") {
+    return paragraphs;
+  }
+  const comparisons = [
+    (text) => text,
+    (text) => text.trim(),
+    (text) => text.replace(/\s+/g, " ").trim()
+  ];
+  for (const compare of comparisons) {
+    const expected = compare(wanted);
+    for (let start = 0; start < paragraphs.length; start++) {
+      let combined = "";
+      for (let end = start; end < paragraphs.length; end++) {
+        combined += (end === start ? "" : "\n") + paragraphTexts[end];
+        const candidate = compare(combined);
+        if (candidate === expected) return paragraphs.slice(start, end + 1);
+      }
+    }
+  }
+  return null;
+}
+function normalizeComparisonText(text) {
+  return String(text ?? "").replace(/\r\n?/g, "\n").replace(/\u00a0/g, " ");
+}
+function extractParagraphVisibleText(paragraph) {
+  let text = "";
+  const visit = (node) => {
+    for (const child of Array.from(node?.childNodes || [])) {
+      if (child.nodeType !== 1) continue;
+      if (isWordElement(child, "pPr") || isWordElement(child, "del") || isWordElement(child, "moveFrom")) continue;
+      if (isWordElement(child, "t")) text += child.textContent || "";
+      else if (isWordElement(child, "tab")) text += "	";
+      else if (isWordElement(child, "br") || isWordElement(child, "cr")) text += "\n";
+      else if (isWordElement(child, "noBreakHyphen")) text += "\u2011";
+      else visit(child);
+    }
+  };
+  visit(paragraph);
+  return normalizeComparisonText(text);
+}
+function preserveStructuralBreaks(displayOriginalText, internalOriginalText, modifiedText, breakChars) {
+  if (breakChars.size === 0) return modifiedText;
+  const diffs = DMP.diff_main(displayOriginalText, modifiedText);
+  let originalOffset = 0;
+  let result = "";
+  for (const [op, text] of diffs) {
+    if (op === 0) {
+      for (let index = 0; index < text.length; index++) {
+        const internalChar = internalOriginalText[originalOffset + index];
+        result += breakChars.has(internalChar) ? internalChar : text[index];
+      }
+      originalOffset += text.length;
+    } else if (op === -1) {
+      originalOffset += text.length;
+    } else {
+      result += text;
+    }
+  }
+  return result;
+}
+function preserveZeroWidthSentinels(displayOriginalText, modifiedText, sentinelMap) {
+  const sentinelsByInternalOffset = /* @__PURE__ */ new Map();
+  sentinelMap.forEach((sentinel) => {
+    if (sentinel.zeroWidth) sentinelsByInternalOffset.set(sentinel.start, sentinel);
+  });
+  if (sentinelsByInternalOffset.size === 0) return modifiedText;
+  let visibleOriginalText = "";
+  let visibleOffset = 0;
+  const sentinelsByVisibleBoundary = /* @__PURE__ */ new Map();
+  for (let internalOffset = 0; internalOffset < displayOriginalText.length; internalOffset++) {
+    const sentinel = sentinelsByInternalOffset.get(internalOffset);
+    if (sentinel) {
+      if (!sentinelsByVisibleBoundary.has(visibleOffset)) sentinelsByVisibleBoundary.set(visibleOffset, []);
+      sentinelsByVisibleBoundary.get(visibleOffset).push({
+        char: displayOriginalText[internalOffset],
+        affinity: sentinel.affinity || "right",
+        emitted: false
+      });
+      continue;
+    }
+    visibleOriginalText += displayOriginalText[internalOffset];
+    visibleOffset++;
+  }
+  const diffs = DMP.diff_main(visibleOriginalText, modifiedText);
+  let originalOffset = 0;
+  let result = "";
+  const emitSentinels = (boundary, affinity) => {
+    const sentinels = sentinelsByVisibleBoundary.get(boundary) || [];
+    for (const sentinel of sentinels) {
+      if (sentinel.emitted || affinity && sentinel.affinity !== affinity) continue;
+      result += sentinel.char;
+      sentinel.emitted = true;
+    }
+  };
+  for (const [op, text] of diffs) {
+    if (op === 1) {
+      emitSentinels(originalOffset, "left");
+      result += text;
+      continue;
+    }
+    for (let index = 0; index < text.length; index++) {
+      emitSentinels(originalOffset);
+      if (op === 0) result += text[index];
+      originalOffset++;
+    }
+  }
+  emitSentinels(originalOffset);
+  return result;
+}
 function preserveReferencePlaceholders(originalFullText, modifiedText, referenceMap) {
   let result = modifiedText;
   for (const referenceChar of referenceMap.keys()) {
@@ -5539,28 +5922,28 @@ function preserveReferencePlaceholders(originalFullText, modifiedText, reference
   }
   return result;
 }
-function processChildNode(child, originalFullText, propertyMap, sentinelMap, referenceMap, tokenToCharMap, nextCharCode) {
-  if (child.nodeName === "w:r") {
-    return processRunForReconstruction(child, originalFullText, propertyMap, sentinelMap, referenceMap, tokenToCharMap, nextCharCode);
+function processChildNode(child, originalFullText, propertyMap, sentinelMap, referenceMap, tokenToCharMap, characterState, breakChars) {
+  if (isWordElement(child, "r")) {
+    return processRunForReconstruction(child, originalFullText, propertyMap, sentinelMap, referenceMap, tokenToCharMap, characterState, breakChars);
   }
-  if (child.nodeName === "w:hyperlink") {
+  if (isWordElement(child, "hyperlink")) {
     return processHyperlinkForReconstruction(child, originalFullText, propertyMap);
   }
-  if (["w:sdt", "w:oMath", "m:oMath", "w:bookmarkStart", "w:bookmarkEnd"].includes(child.nodeName)) {
+  if (isWordElement(child, "sdt") || isWordElement(child, "oMath") || localNameOf(child) === "oMath" || isWordElement(child, "bookmarkStart") || isWordElement(child, "bookmarkEnd")) {
     sentinelMap.push({ start: originalFullText.length, node: child });
     return originalFullText + "\uFFFC";
   }
-  if (["w:commentRangeStart", "w:commentRangeEnd"].includes(child.nodeName)) {
+  if (isWordElement(child, "commentRangeStart") || isWordElement(child, "commentRangeEnd")) {
     sentinelMap.push({ start: originalFullText.length, node: child, isCommentMarker: true });
     return originalFullText;
   }
   return originalFullText;
 }
-function processRunForReconstruction(runElement, originalFullText, propertyMap, sentinelMap, referenceMap, tokenToCharMap, nextCharCode) {
+function processRunForReconstruction(runElement, originalFullText, propertyMap, sentinelMap, referenceMap, tokenToCharMap, characterState, breakChars) {
   let fullText = originalFullText;
-  const rPr = getFirstElementByTag(runElement, "w:rPr");
+  const rPr = getFirstElementByTagNSOrTag(runElement, NS_W, "rPr");
   Array.from(runElement.childNodes).forEach((runChild) => {
-    if (runChild.nodeName === "w:t") {
+    if (isWordElement(runChild, "t")) {
       const textContent = runChild.textContent || "";
       if (textContent.length > 0) {
         propertyMap.push({
@@ -5570,38 +5953,47 @@ function processRunForReconstruction(runElement, originalFullText, propertyMap,
         });
         fullText += textContent;
       }
-    } else if (runChild.nodeName === "w:br" || runChild.nodeName === "w:cr") {
-      fullText += "\n";
+    } else if (isWordElement(runChild, "br") || isWordElement(runChild, "cr")) {
+      const char = String.fromCharCode(characterState.nextCharCode++);
+      referenceMap.set(char, runChild);
+      breakChars.add(char);
+      fullText += char;
       propertyMap.push({ start: fullText.length - 1, end: fullText.length, rPr });
-    } else if (runChild.nodeName === "w:tab") {
+    } else if (isWordElement(runChild, "tab")) {
       fullText += "	";
       propertyMap.push({ start: fullText.length - 1, end: fullText.length, rPr });
-    } else if (runChild.nodeName === "w:noBreakHyphen") {
+    } else if (isWordElement(runChild, "noBreakHyphen")) {
       fullText += "\u2011";
       propertyMap.push({ start: fullText.length - 1, end: fullText.length, rPr });
-    } else if (["w:drawing", "w:pict", "w:object", "w:fldChar", "w:instrText", "w:sym"].includes(runChild.nodeName)) {
-      const textBoxContent = getFirstElementByTag(runChild, "w:txbxContent");
-      const hasTextBox = runChild.nodeName === "w:pict" && !!textBoxContent;
+    } else if (["drawing", "pict", "object", "fldChar", "instrText", "sym"].some((name) => isWordElement(runChild, name))) {
+      const textBoxContent = getFirstElementByTagNSOrTag(runChild, NS_W, "txbxContent");
+      const hasTextBox = isWordElement(runChild, "pict") && !!textBoxContent;
+      const isFieldStructure = isWordElement(runChild, "fldChar") || isWordElement(runChild, "instrText");
+      const fieldCharType = isWordElement(runChild, "fldChar") ? runChild.getAttributeNS?.(NS_W, "fldCharType") || runChild.getAttribute("w:fldCharType") || runChild.getAttribute("fldCharType") : null;
       sentinelMap.push({
         start: fullText.length,
         node: runChild,
+        wrapInRun: true,
+        rPr,
+        zeroWidth: isFieldStructure,
+        affinity: fieldCharType === "end" ? "left" : "right",
         isTextBox: hasTextBox,
         originalContainer: hasTextBox ? textBoxContent : void 0
       });
       fullText += "\uFFFC";
       propertyMap.push({ start: fullText.length - 1, end: fullText.length, rPr });
-    } else if (runChild.nodeName === "w:footnoteReference" || runChild.nodeName === "w:endnoteReference") {
-      const id = runChild.getAttribute("w:id");
+    } else if (isWordElement(runChild, "footnoteReference") || isWordElement(runChild, "endnoteReference")) {
+      const id = wordAttribute(runChild, "id");
       if (id) {
-        const type = runChild.nodeName === "w:footnoteReference" ? "FN" : "EN";
+        const type = isWordElement(runChild, "footnoteReference") ? "FN" : "EN";
         const tokenString = `{{__${type}_${id}__}}`;
-        const char = String.fromCharCode(nextCharCode);
+        const char = String.fromCharCode(characterState.nextCharCode++);
         referenceMap.set(char, runChild);
         tokenToCharMap.set(tokenString, char);
         fullText += char;
         propertyMap.push({ start: fullText.length - 1, end: fullText.length, rPr });
       }
-    } else if (runChild.nodeName === "w:commentReference") {
+    } else if (isWordElement(runChild, "commentReference")) {
       sentinelMap.push({ start: fullText.length, node: runChild, isCommentMarker: true });
     }
   });
@@ -5610,9 +6002,9 @@ function processRunForReconstruction(runElement, originalFullText, propertyMap,
 function processHyperlinkForReconstruction(hyperlinkElement, originalFullText, propertyMap) {
   let fullText = originalFullText;
   Array.from(hyperlinkElement.childNodes).forEach((hyperlinkChild) => {
-    if (hyperlinkChild.nodeName !== "w:r") return;
-    const rPr = getFirstElementByTag(hyperlinkChild, "w:rPr");
-    const texts = getElementsByTag(hyperlinkChild, "w:t");
+    if (!isWordElement(hyperlinkChild, "r")) return;
+    const rPr = getFirstElementByTagNSOrTag(hyperlinkChild, NS_W, "rPr");
+    const texts = getElementsByTagNSOrTag(hyperlinkChild, NS_W, "t");
     texts.forEach((textNode) => {
       const textContent = textNode.textContent || "";
       if (textContent.length === 0) return;
@@ -5632,7 +6024,6 @@ function processHyperlinkForReconstruction(hyperlinkElement, originalFullText, p
 function applyReconstructionDiffs(xmlDoc, diffs, context, serializer, author, formatHints, generateRedlines = true) {
   const {
     paragraphs,
-    paragraphMap,
     containerFragments,
     sentinelMapByStart,
     referenceMap,
@@ -5655,10 +6046,16 @@ function applyReconstructionDiffs(xmlDoc, diffs, context, serializer, author, fo
   }
   let currentOriginalIndex = 0;
   let currentInsertOffset = 0;
+  let pendingReplacementStart = null;
   const emittedCommentMarkers = /* @__PURE__ */ new WeakSet();
   for (const [op, text] of diffs) {
     if (op === 0 || op === -1) {
       const type = op === 0 ? "equal" : "delete";
+      if (op === 0) {
+        pendingReplacementStart = null;
+      } else if (pendingReplacementStart === null) {
+        pendingReplacementStart = currentOriginalIndex;
+      }
       let offset = 0;
       while (offset < text.length) {
         const chunkStart = currentOriginalIndex + offset;
@@ -5695,7 +6092,8 @@ function applyReconstructionDiffs(xmlDoc, diffs, context, serializer, author, fo
       continue;
     }
     if (op === 1) {
-      const properties = currentOriginalIndex > 0 && !isParagraphStart(currentOriginalIndex) ? getRunProperties(currentOriginalIndex - 1) : getRunProperties(currentOriginalIndex);
+      const propertyIndex = pendingReplacementStart !== null ? pendingReplacementStart : currentOriginalIndex > 0 && !isParagraphStart(currentOriginalIndex) ? currentOriginalIndex - 1 : currentOriginalIndex;
+      const properties = getRunProperties(propertyIndex);
       const appendResult = appendTextToCurrent(
         xmlDoc,
         text,
@@ -5718,29 +6116,46 @@ function applyReconstructionDiffs(xmlDoc, diffs, context, serializer, author, fo
       );
       currentParagraph = appendResult.currentParagraph;
       currentInsertOffset += text.length;
+      pendingReplacementStart = null;
     }
   }
+  const paragraphSet = new Set(paragraphs);
+  const insertionAnchors = /* @__PURE__ */ new Map();
+  paragraphs.forEach((paragraph) => {
+    const container = paragraph.parentNode;
+    if (!container || insertionAnchors.has(container)) return;
+    let anchor = paragraph.nextSibling;
+    while (anchor && paragraphSet.has(anchor)) anchor = anchor.nextSibling;
+    insertionAnchors.set(container, anchor);
+  });
   paragraphs.forEach((paragraph) => {
     if (paragraph.parentNode) {
       paragraph.parentNode.removeChild(paragraph);
     }
   });
+  let hasDocumentTarget = false;
+  let serializedDocumentOutput = "";
   containerFragments.forEach((fragment, container) => {
     const replacement = replacementContainers.get(container);
     const target = replacement || container;
     if (target.nodeType === 9) {
-      const firstChild = fragment.firstChild;
-      if (firstChild) {
-        target.appendChild(firstChild);
-        while (fragment.firstChild) {
-          target.documentElement.appendChild(fragment.firstChild);
-        }
+      hasDocumentTarget = true;
+      if (fragment.childNodes.length === 1) {
+        target.appendChild(fragment.firstChild);
+      } else {
+        serializedDocumentOutput = Array.from(fragment.childNodes).map((node) => serializer.serializeToString(node)).join("");
       }
       return;
     }
-    target.appendChild(fragment);
+    const anchor = replacement ? null : insertionAnchors.get(container);
+    if (anchor && anchor.parentNode === target) {
+      target.insertBefore(fragment, anchor);
+    } else {
+      target.appendChild(fragment);
+    }
   });
-  return { oxml: serializer.serializeToString(xmlDoc), hasChanges: true };
+  const oxml = hasDocumentTarget && serializedDocumentOutput ? serializedDocumentOutput : serializer.serializeToString(xmlDoc);
+  return { oxml, hasChanges: true };
 }
 function appendTextToCurrent(xmlDoc, text, type, rPr, wrapper, baseIndex, currentParagraphRef, containerFragments, sentinelMapByStart, referenceMap, replacementContainers, getParagraphInfo, createNewParagraph, author, formatHints = [], insertOffset = 0, generateRedlines = true, emittedCommentMarkers = /* @__PURE__ */ new WeakSet()) {
   let localBaseIndex = baseIndex;
@@ -5752,7 +6167,7 @@ function appendTextToCurrent(xmlDoc, text, type, rPr, wrapper, baseIndex, curren
     const commentMarkers = sentinelsAtOffset.filter((sentinel) => sentinel.isCommentMarker && !emittedCommentMarkers.has(sentinel.node));
     commentMarkers.forEach((marker) => {
       emittedCommentMarkers.add(marker.node);
-      if (marker.node.nodeName === "w:commentReference") {
+      if (isWordElement(marker.node, "commentReference")) {
         const run = createWordElement(xmlDoc, "w:r");
         run.appendChild(marker.node.cloneNode(true));
         localParagraph.appendChild(run);
@@ -5764,9 +6179,9 @@ function appendTextToCurrent(xmlDoc, text, type, rPr, wrapper, baseIndex, curren
       const info = getParagraphInfo(localBaseIndex + 1);
       const nextParagraph = createNewParagraph(info.pPr);
       if (generateRedlines && type === "insert") {
-        markParagraphMarkInserted(xmlDoc, nextParagraph, author);
+        markParagraphMarkInserted(xmlDoc, localParagraph, author);
       } else if (generateRedlines && type === "delete") {
-        markParagraphMarkDeleted(xmlDoc, nextParagraph, author);
+        markParagraphMarkDeleted(xmlDoc, localParagraph, author);
       }
       const fragment = containerFragments.get(info.container);
       if (fragment) {
@@ -5782,13 +6197,20 @@ function appendTextToCurrent(xmlDoc, text, type, rPr, wrapper, baseIndex, curren
       if (sentinel) {
         const clone = sentinel.node.cloneNode(true);
         if (sentinel.isTextBox && sentinel.originalContainer) {
-          const newContainer = getFirstElementByTag(clone, "w:txbxContent");
+          const newContainer = getFirstElementByTagNSOrTag(clone, NS_W, "txbxContent");
           if (newContainer) {
             while (newContainer.firstChild) newContainer.removeChild(newContainer.firstChild);
             replacementContainers.set(sentinel.originalContainer, newContainer);
           }
         }
-        localParagraph.appendChild(clone);
+        if (sentinel.wrapInRun) {
+          const run = createWordElement(xmlDoc, "w:r");
+          if (sentinel.rPr) run.appendChild(sentinel.rPr.cloneNode(true));
+          run.appendChild(clone);
+          localParagraph.appendChild(run);
+        } else {
+          localParagraph.appendChild(clone);
+        }
       }
       localBaseIndex++;
       if (type !== "delete") localInsertOffset++;
@@ -5847,12 +6269,24 @@ function appendTextToCurrent(xmlDoc, text, type, rPr, wrapper, baseIndex, curren
 }
 
 // engine/reconstruction-mode.js
-function applyReconstructionMode(xmlDoc, originalText, modifiedText, serializer, author, formatHints, generateRedlines = true) {
-  const mapping = buildReconstructionMapping(xmlDoc, modifiedText);
+function applyReconstructionMode(xmlDoc, originalText, modifiedText, serializer, author, formatHints, generateRedlines = true, diffOptions = {}) {
+  const selectedParagraphs = findReconstructionParagraphRange(xmlDoc, originalText);
+  if (selectedParagraphs === null) {
+    return withOoxmlSourceType({
+      oxml: serializer.serializeToString(xmlDoc),
+      hasChanges: false,
+      status: "error",
+      error: {
+        code: "PARTIAL_TARGET",
+        message: "Original text did not identify a complete contiguous paragraph range for reconstruction."
+      }
+    });
+  }
+  const mapping = buildReconstructionMapping(xmlDoc, modifiedText, selectedParagraphs);
   if (mapping.paragraphs.length === 0) {
     return withOoxmlSourceType({ oxml: serializer.serializeToString(xmlDoc), hasChanges: false });
   }
-  const diffs = computeWordDiffs(mapping.originalFullText, mapping.processedModifiedText);
+  const diffs = computeWordDiffs(mapping.originalFullText, mapping.processedModifiedText, diffOptions);
   return withOoxmlSourceType(applyReconstructionDiffs(
     xmlDoc,
     diffs,
@@ -5881,11 +6315,15 @@ function applyTableReconciliation(xmlDoc, modifiedText, serializer, parser, auth
   if (operations.length === 0) {
     return noChanges(serializer, xmlDoc);
   }
-  const options = { generateRedlines, author };
+  const options = {
+    generateRedlines,
+    author,
+    revisionIdAllocator: getRevisionIdAllocatorForDocument(xmlDoc)
+  };
   const reconciledOxml = serializeVirtualGridToOoxml(oldGrid, operations, options);
   const wrappedOxml = `<root xmlns:w="${NS_W}">${reconciledOxml}</root>`;
-  const reconcileParser = parser || createParser();
-  const reconciledDoc = reconcileParser.parseFromString(wrappedOxml, "application/xml");
+  const reconciledDoc = parseOoxmlSafe(wrappedOxml, "application/xml").doc;
+  if (!reconciledDoc) return noChanges(serializer, xmlDoc);
   const parseError = getXmlParseError(reconciledDoc);
   if (parseError) {
     error("[OxmlEngine] Failed to parse reconciled table OOXML:", parseError.textContent);
@@ -5901,14 +6339,15 @@ function applyTableReconciliation(xmlDoc, modifiedText, serializer, parser, auth
   return withOoxmlSourceType({ oxml: serializer.serializeToString(xmlDoc), hasChanges: true });
 }
 function applyTextToTableTransformation(xmlDoc, modifiedText, serializer, parser, author, generateRedlines) {
+  const revisionIdAllocator = getRevisionIdAllocatorForDocument(xmlDoc);
   const tableData = parseTable(modifiedText);
   if (!tableData || tableData.rows.length === 0 && tableData.headers.length === 0) {
     log("[OxmlEngine] Failed to parse table data from Markdown");
     return noChanges(serializer, xmlDoc);
   }
-  const tableOoxml = generateTableOoxml(tableData, { generateRedlines, author });
-  const activeParser = parser || createParser();
-  const tableDoc = activeParser.parseFromString(`<root xmlns:w="${NS_W}">${tableOoxml}</root>`, "application/xml");
+  const tableOoxml = generateTableOoxml(tableData, { generateRedlines, author, revisionIdAllocator });
+  const tableDoc = parseOoxmlSafe(`<root xmlns:w="${NS_W}">${tableOoxml}</root>`, "application/xml").doc;
+  if (!tableDoc) return noChanges(serializer, xmlDoc);
   const tableParseError = getXmlParseError(tableDoc);
   if (tableParseError) {
     error("[OxmlEngine] Failed to parse generated table OOXML:", tableParseError.textContent);
@@ -5931,13 +6370,15 @@ function applyTextToTableTransformation(xmlDoc, modifiedText, serializer, parser
   let firstParagraph = paragraphs[0];
   let parent = firstParagraph.parentNode;
   if (parent && parent.nodeType === 9) {
-    const wrappedDoc = activeParser.parseFromString(
+    const wrappedDoc = parseOoxmlSafe(
       `<w:document xmlns:w="${NS_W}"><w:body/></w:document>`,
       "application/xml"
-    );
+    ).doc;
+    if (!wrappedDoc) return noChanges(serializer, workingDoc);
     const wrappedBody = getFirstElementByTagNS(wrappedDoc, NS_W, "body");
     paragraphs.forEach((p) => wrappedBody.appendChild(wrappedDoc.importNode(p, true)));
     workingDoc = wrappedDoc;
+    setRevisionIdAllocatorForDocument(workingDoc, revisionIdAllocator);
     paragraphs = getElementsByTagNS(workingDoc, NS_W, "p");
     firstParagraph = paragraphs[0];
     parent = firstParagraph.parentNode;
@@ -5958,7 +6399,7 @@ function applyTextToTableTransformation(xmlDoc, modifiedText, serializer, parser
           }
         });
         const del = createWordElement(workingDoc, "w:del");
-        const metadata = createRevisionMetadata(author);
+        const metadata = createRevisionMetadata(author, workingDoc);
         del.setAttribute("w:id", String(metadata.id));
         del.setAttribute("w:author", metadata.author);
         del.setAttribute("w:date", metadata.date);
@@ -6022,17 +6463,19 @@ function authorMatchesNode(node, filter) {
   return !!nodeAuthor && nodeAuthor === filter.normalizedAuthor;
 }
 function parseXmlWithWarnings(oxml, parseFailurePrefix) {
-  const parser = createParser();
-  const xmlDoc = parser.parseFromString(oxml, "application/xml");
-  const parseError = getXmlParseError(xmlDoc);
-  if (parseError) {
+  const parsed = parseOoxmlSafe(oxml, "application/xml");
+  const parseError = parsed.doc ? getXmlParseError(parsed.doc) : null;
+  if (parsed.error || parseError) {
+    const message = parsed.error?.message || parseError?.textContent || "parse error";
     return {
       xmlDoc: null,
       serializer: null,
-      warning: `${parseFailurePrefix}: ${parseError.textContent || "parse error"}`
+      warning: `${parseFailurePrefix}: ${message}`,
+      warnings: parsed.warnings,
+      error: { code: "PARSE_ERROR", message }
     };
   }
-  return { xmlDoc, serializer: createSerializer(), warning: null };
+  return { xmlDoc: parsed.doc, serializer: createSerializer(), warning: null, warnings: parsed.warnings, error: null };
 }
 function removeNode(node) {
   if (node?.parentNode) {
@@ -6092,9 +6535,17 @@ function acceptTrackedChangesInOoxml(oxml, options = {}) {
   }
   const parseResult = parseXmlWithWarnings(oxml, "Failed to parse OOXML");
   if (!parseResult.xmlDoc) {
-    return { oxml, hasChanges: false, acceptedCount: 0, warnings: [parseResult.warning] };
+    return {
+      oxml,
+      hasChanges: false,
+      acceptedCount: 0,
+      status: "error",
+      error: parseResult.error,
+      warnings: [...parseResult.warnings || [], parseResult.warning]
+    };
   }
   const { xmlDoc, serializer } = parseResult;
+  warnings.push(...parseResult.warnings || []);
   let acceptedCount = 0;
   for (const insNode of getWordElementsByLocalName(xmlDoc, "ins")) {
     if (!insNode.parentNode || !authorMatchesNode(insNode, filter)) continue;
@@ -6226,9 +6677,17 @@ function rejectTrackedChangesInOoxml(oxml, options = {}) {
   }
   const parseResult = parseXmlWithWarnings(oxml, "Failed to parse OOXML");
   if (!parseResult.xmlDoc) {
-    return { oxml, hasChanges: false, rejectedCount: 0, warnings: [parseResult.warning] };
+    return {
+      oxml,
+      hasChanges: false,
+      rejectedCount: 0,
+      status: "error",
+      error: parseResult.error,
+      warnings: [...parseResult.warnings || [], parseResult.warning]
+    };
   }
   const { xmlDoc, serializer } = parseResult;
+  warnings.push(...parseResult.warnings || []);
   let rejectedCount = 0;
   for (const insNode of getWordElementsByLocalName(xmlDoc, "ins")) {
     if (!insNode.parentNode || !authorMatchesNode(insNode, filter)) continue;
@@ -6351,10 +6810,13 @@ function deleteCommentsByAuthorInOoxml(oxml, options = {}) {
       hasChanges: false,
       commentsRemoved: 0,
       referencesRemoved: 0,
-      warnings: [parseResult.warning]
+      status: "error",
+      error: parseResult.error,
+      warnings: [...parseResult.warnings || [], parseResult.warning]
     };
   }
   const { xmlDoc, serializer } = parseResult;
+  warnings.push(...parseResult.warnings || []);
   const { targetIds, commentNodes } = collectCommentTargetIds(xmlDoc, filter);
   if (filter.allAuthors) {
     for (const localName of ["commentRangeStart", "commentRangeEnd", "commentReference"]) {
@@ -6377,66 +6839,96 @@ function deleteCommentsByAuthorInOoxml(oxml, options = {}) {
 
 // engine/oxml-engine.js
 async function applyRedlineToOxml(oxml, originalText, modifiedText, options = {}) {
+  const inputOoxml = oxml;
+  let workingOoxml = oxml;
+  originalText = typeof originalText === "string" ? originalText : String(originalText ?? "");
+  modifiedText = typeof modifiedText === "string" ? modifiedText : String(modifiedText ?? "");
   const generateRedlines = options.generateRedlines ?? true;
   const author = options.author || getDefaultAuthor();
-  const parser = createParser();
   const serializer = createSerializer();
+  let parseWarnings = [];
+  const operationWarnings = [];
+  let normalizedExistingRevisions = false;
+  const keepNormalizedNoOp = options.existingRevisions === "accept-all-first-keep-normalized";
   const finalize = (result) => {
     const withStatus = { ...result };
+    if (normalizedExistingRevisions && withStatus.hasChanges === false && withStatus.status !== "error") {
+      if (keepNormalizedNoOp) {
+        withStatus.oxml = workingOoxml;
+        withStatus.hasChanges = true;
+        withStatus.warnings = [
+          ...Array.isArray(withStatus.warnings) ? withStatus.warnings : [],
+          "Existing revisions were accepted before redlining."
+        ];
+      } else {
+        withStatus.oxml = inputOoxml;
+      }
+    }
+    const warnings = [...parseWarnings, ...operationWarnings, ...Array.isArray(withStatus.warnings) ? withStatus.warnings : []];
+    if (warnings.length > 0) {
+      withStatus.warnings = [...new Set(warnings)];
+    }
     if (!withStatus.status) {
       withStatus.status = withStatus.hasChanges ? "ok" : "no-op";
     }
     return withOoxmlSourceType(withStatus);
   };
-  const noChanges2 = () => finalize({ oxml, hasChanges: false });
-  let xmlDoc;
-  try {
-    xmlDoc = parser.parseFromString(oxml, "text/xml");
-  } catch (e) {
-    error("[OxmlEngine] Failed to parse OXML:", e);
-    return finalize({
-      oxml,
-      hasChanges: false,
-      status: "error",
-      error: { code: "PARSE_ERROR", message: "Could not parse OOXML input." }
-    });
-  }
-  const parseError = getXmlParseError(xmlDoc);
-  if (parseError) {
-    error("[OxmlEngine] XML parse error:", parseError.textContent);
+  const finalizeUnchanged = () => {
+    if (normalizedExistingRevisions && keepNormalizedNoOp) {
+      return finalize({
+        oxml: workingOoxml,
+        hasChanges: true,
+        warnings: ["Existing revisions were accepted before redlining."]
+      });
+    }
+    return finalize({ oxml: inputOoxml, hasChanges: false });
+  };
+  const parsed = parseOoxmlSafe(inputOoxml, "text/xml");
+  parseWarnings = parsed.warnings;
+  let xmlDoc = parsed.doc;
+  const parseError = xmlDoc ? getXmlParseError(xmlDoc) : null;
+  if (parsed.error || parseError) {
+    const message = parsed.error?.message || parseError?.textContent || "Could not parse OOXML input.";
+    error("[OxmlEngine] XML parse error:", message);
     return finalize({
-      oxml,
+      oxml: inputOoxml,
       hasChanges: false,
       status: "error",
-      error: { code: "PARSE_ERROR", message: parseError.textContent || "Could not parse OOXML input." }
+      error: { code: "PARSE_ERROR", message }
     });
   }
-  seedRevisionIdsFromDocument(xmlDoc);
+  const revisionIdAllocator = options?._revisionIdAllocator instanceof RevisionIdAllocator ? options._revisionIdAllocator : new RevisionIdAllocator();
+  seedRevisionIdsFromDocument(xmlDoc, revisionIdAllocator);
   if (containsTrackedChanges(xmlDoc)) {
     const existingRevisionsPolicy = options.existingRevisions || "reject-input";
-    if (existingRevisionsPolicy === "accept-all-first") {
+    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(oxml, { allAuthors: true });
-      oxml = accepted.oxml;
-      xmlDoc = parser.parseFromString(oxml, "text/xml");
-      const acceptedParseError = getXmlParseError(xmlDoc);
-      if (acceptedParseError) {
-        error("[OxmlEngine] XML parse error after accepting existing revisions:", acceptedParseError.textContent);
+      const accepted = acceptTrackedChangesInOoxml(inputOoxml, { allAuthors: true });
+      if (accepted.status === "error") return finalize(accepted);
+      workingOoxml = accepted.oxml;
+      normalizedExistingRevisions = true;
+      const acceptedParsed = parseOoxmlSafe(workingOoxml, "text/xml");
+      parseWarnings.push(...acceptedParsed.warnings);
+      xmlDoc = acceptedParsed.doc;
+      const acceptedParseError = xmlDoc ? getXmlParseError(xmlDoc) : null;
+      if (acceptedParsed.error || acceptedParseError) {
+        const message = acceptedParsed.error?.message || acceptedParseError?.textContent || "Could not parse OOXML after accepting existing revisions.";
+        error("[OxmlEngine] XML parse error after accepting existing revisions:", message);
         return finalize({
-          oxml,
+          oxml: inputOoxml,
           hasChanges: false,
           status: "error",
           error: {
             code: "PARSE_ERROR",
-            message: "Could not parse OOXML after accepting existing revisions."
+            message
           }
         });
       }
-      seedRevisionIdsFromDocument(xmlDoc);
+      seedRevisionIdsFromDocument(xmlDoc, revisionIdAllocator);
     } else {
       log("[OxmlEngine] Existing revisions detected; rejecting input per existingRevisions policy");
       return finalize({
-        oxml,
+        oxml: inputOoxml,
         hasChanges: false,
         status: "error",
         error: {
@@ -6450,22 +6942,33 @@ async function applyRedlineToOxml(oxml, originalText, modifiedText, options = {}
   if (initialTableCellContext.hasTableWrapper && initialTableCellContext.targetParagraph && !options._isolatedTableCell) {
     log("[OxmlEngine] Isolating table-cell paragraph before diff");
     const isolatedOxml = serializeParagraphOnly(xmlDoc, initialTableCellContext.targetParagraph, serializer);
-    return applyRedlineToOxml(isolatedOxml, originalText, modifiedText, {
+    const isolatedResult = await applyRedlineToOxml(isolatedOxml, originalText, modifiedText, {
       ...options,
       _isolatedTableCell: true
     });
+    if (!isolatedResult.hasChanges && isolatedResult.status === "no-op") {
+      return finalizeUnchanged();
+    }
+    return isolatedResult;
+  }
+  const sanitizedText = options.sanitizeInput === true ? sanitizeAiResponse(modifiedText) : modifiedText;
+  if (sanitizedText !== modifiedText) {
+    operationWarnings.push("Input was sanitized; pass sanitizeInput: false to disable.");
   }
-  const sanitizedText = sanitizeAiResponse(modifiedText);
   const { cleanText: cleanModifiedText, formatHints } = preprocessMarkdown(sanitizedText);
   const hasTextChanges = cleanModifiedText.trim() !== originalText.trim();
   const hasFormatHints = formatHints.length > 0;
   const { existingFormatHints, textSpans, paragraphs } = extractFormattingFromOoxml(xmlDoc);
   const hasExistingFormatting = existingFormatHints.length > 0;
   const visibleText = textSpans.map((span) => textSpanVisibleText(span)).join("");
-  if (hasTextChanges && typeof originalText === "string" && originalText.trim() && !originalText.includes("\n") && !visibleText.includes(originalText.trim()) && !visibleText.replace(/[\t\n\u2011]/g, "").includes(originalText.trim().replace(/[\t\n\u2011]/g, "")) && !normalizeTargetText(visibleText).includes(normalizeTargetText(originalText))) {
+  const targetFound = originalText.includes("\n") || originalText.includes("\r") ? originalText.split(/\r?\n/).map(normalizeTargetText).filter(Boolean).every((line) => paragraphs.some((paragraph) => {
+    const paragraphText = textSpans.filter((span) => span.paragraph === paragraph).map(textSpanVisibleText).join("");
+    return normalizeTargetText(paragraphText).includes(line);
+  })) : visibleText.includes(originalText.trim()) || visibleText.replace(/[\t\n\u2011]/g, "").includes(originalText.trim().replace(/[\t\n\u2011]/g, "")) || normalizeTargetText(visibleText).includes(normalizeTargetText(originalText));
+  if (hasTextChanges && typeof originalText === "string" && originalText.trim() && !targetFound) {
     log("[OxmlEngine] Target text not found in OOXML");
     return finalize({
-      oxml,
+      oxml: inputOoxml,
       hasChanges: false,
       status: "error",
       error: {
@@ -6506,10 +7009,14 @@ async function applyRedlineToOxml(oxml, originalText, modifiedText, options = {}
     );
   };
   log(`[OxmlEngine] Text changes: ${hasTextChanges}, New format hints: ${formatHints.length}, Existing format hints: ${existingFormatHints.length}`);
-  const needsFormatRemoval = !hasTextChanges && !hasFormatHints && hasExistingFormatting;
+  const needsFormatRemoval = options.removeFormatting === true && !hasTextChanges && !hasFormatHints && hasExistingFormatting;
   if (!hasTextChanges && !hasFormatHints && !hasExistingFormatting) {
     log("[OxmlEngine] No text changes, no format hints, and no existing formatting detected");
-    return noChanges2();
+    return finalizeUnchanged();
+  }
+  if (!hasTextChanges && !hasFormatHints && hasExistingFormatting && !needsFormatRemoval) {
+    log("[OxmlEngine] No text or explicit formatting changes; preserving existing formatting");
+    return finalizeUnchanged();
   }
   if (needsFormatRemoval) {
     log("[OxmlEngine] Format REMOVAL detected: applying surgical replacement in OOXML");
@@ -6569,50 +7076,78 @@ async function applyRedlineToOxml(oxml, originalText, modifiedText, options = {}
   const isTargetList = isListTargetLoose(cleanModifiedText);
   const tableCellContext = initialTableCellContext;
   log(`[OxmlEngine] Mode: ${hasTables ? "SURGICAL" : "RECONSTRUCTION"}, formatHints: ${formatHints.length}, isMarkdownTable: ${isMarkdownTable}, isTargetList: ${isTargetList}, isTableCellParagraph: ${tableCellContext.isTableCellParagraph}`);
-  if (isMarkdownTable && !hasTables) {
-    log("[OxmlEngine] Text-to-table transformation: generating new table from Markdown");
-    return finalize(applyTextToTableTransformation(xmlDoc, cleanModifiedText, serializer, parser, author, generateRedlines));
-  }
-  if (hasTables && isMarkdownTable) {
-    return finalize(applyTableReconciliation(xmlDoc, cleanModifiedText, serializer, parser, author, generateRedlines));
-  }
-  if (hasTables) {
-    const surgicalTarget = tableCellContext.hasTableWrapper && tableCellContext.targetParagraph ? tableCellContext.targetParagraph : null;
-    if (surgicalTarget) {
-      log("[OxmlEngine] Table cell edit: scoping surgical mode to target paragraph");
+  try {
+    if (isMarkdownTable && !hasTables) {
+      log("[OxmlEngine] Text-to-table transformation: generating new table from Markdown");
+      return finalize(applyTextToTableTransformation(xmlDoc, cleanModifiedText, serializer, null, author, generateRedlines));
     }
-    const result = applySurgicalMode(
+    if (hasTables && isMarkdownTable) {
+      return finalize(applyTableReconciliation(xmlDoc, cleanModifiedText, serializer, null, author, generateRedlines));
+    }
+    if (hasTables) {
+      const surgicalTarget = tableCellContext.hasTableWrapper && tableCellContext.targetParagraph ? tableCellContext.targetParagraph : null;
+      if (surgicalTarget) {
+        log("[OxmlEngine] Table cell edit: scoping surgical mode to target paragraph");
+      }
+      const result = applySurgicalMode(
+        xmlDoc,
+        originalText,
+        cleanModifiedText,
+        serializer,
+        author,
+        formatHints,
+        generateRedlines,
+        surgicalTarget
+      );
+      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 });
+      }
+      return finalize(result);
+    }
+    if (isTargetList) {
+      log("[OxmlEngine] \u{1F3AF} Using reconciliation pipeline for list generation");
+      const pipeline = new ReconciliationPipeline({
+        author,
+        generateRedlines,
+        revisionIdAllocator
+      });
+      const result = await pipeline.execute(workingOoxml, sanitizedText, { xmlDoc });
+      if (result.error?.code === "DIFF_TOKEN_LIMIT") {
+        return finalize({ oxml: inputOoxml, hasChanges: false, status: "error", error: result.error });
+      }
+      if (result.isValid && result.ooxml && result.ooxml !== workingOoxml) {
+        const includeNumbering = result.includeNumbering === true;
+        log(`[OxmlEngine] Wrapping list OOXML with numbering definitions, includeNumbering=${includeNumbering}`);
+        const wrapped = wrapInDocumentFragment(result.ooxml, {
+          includeNumbering,
+          numberingXml: result.numberingXml
+        });
+        log(`[OxmlEngine] \u2705 Wrapped OOXML length: ${wrapped.length}`);
+        return finalize({ oxml: wrapped, hasChanges: true });
+      }
+      return finalizeUnchanged();
+    }
+    return finalize(applyReconstructionMode(
       xmlDoc,
       originalText,
       cleanModifiedText,
       serializer,
       author,
       formatHints,
-      generateRedlines,
-      surgicalTarget
-    );
-    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 });
-    }
-    return finalize(result);
-  }
-  if (isTargetList) {
-    log("[OxmlEngine] \u{1F3AF} Using reconciliation pipeline for list generation");
-    const pipeline = new ReconciliationPipeline({ author, generateRedlines });
-    const result = await pipeline.execute(oxml, modifiedText, { xmlDoc });
-    if (result.isValid && result.ooxml && result.ooxml !== oxml) {
-      log(`[OxmlEngine] Wrapping list OOXML with numbering definitions, includeNumbering=${result.includeNumbering}`);
-      const wrapped = wrapInDocumentFragment(result.ooxml, {
-        includeNumbering: result.includeNumbering ?? true,
-        numberingXml: result.numberingXml
+      generateRedlines
+    ));
+  } catch (caught) {
+    if (isDiffTokenLimitError(caught)) {
+      return finalize({
+        oxml: inputOoxml,
+        hasChanges: false,
+        status: "error",
+        error: { code: caught.code, message: caught.message }
       });
-      log(`[OxmlEngine] \u2705 Wrapped OOXML length: ${wrapped.length}`);
-      return finalize({ oxml: wrapped, hasChanges: true });
     }
-    return noChanges2();
+    throw caught;
   }
-  return finalize(applyReconstructionMode(xmlDoc, originalText, cleanModifiedText, serializer, author, formatHints, generateRedlines));
 }
 function normalizeTargetText(text) {
   return String(text || "").replace(/[\t\n\u2011]/g, " ").replace(/\s+/g, " ").trim();
@@ -6626,15 +7161,13 @@ function textSpanVisibleText(span) {
   return node?.textContent || "";
 }
 function sanitizeAiResponse(text) {
-  let cleaned = text;
-  cleaned = cleaned.replace(/^(Here is the redline:|Here is the text:|Sure, I can help:|Here's the updated text:)\s*/i, "");
-  cleaned = cleaned.replace(/\$\\text\{/g, "").replace(/\}\$/g, "");
-  cleaned = cleaned.replace(/\$([^0-9\n]+?)\$/g, "$1");
-  cleaned = cleaned.replace(/\\r\\n/g, "\n").replace(/\\n/g, "\n");
-  return cleaned;
+  return String(text ?? "").replace(
+    /^(?:Here is the redline:|Here is the text:|Sure, I can help:|Here's the updated text:)[ \t]*\r?\n/i,
+    ""
+  );
 }
 function parseOoxml(ooxmlString) {
-  return parseXml(ooxmlString, "application/xml");
+  return parseOoxmlSafe(ooxmlString, "application/xml").doc;
 }
 function serializeOoxml(doc) {
   return serializeXml(doc);
@@ -6644,6 +7177,11 @@ function serializeOoxml(doc) {
 function toArray(nodeList) {
   return Array.from(nodeList || []);
 }
+function createTargetNotFoundError(message) {
+  const error2 = new Error(message);
+  error2.code = "TARGET_NOT_FOUND";
+  return error2;
+}
 var WORD_MAIN_NS = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
 function getElementsByLocalName(node, localName) {
   if (!node) return [];
@@ -6657,8 +7195,22 @@ function getElementsByLocalName(node, localName) {
   return toArray(node.getElementsByTagName(localName));
 }
 function toParagraphText(paragraph) {
-  const textNodes = getElementsByLocalName(paragraph, "t");
-  return textNodes.map((node) => node.textContent || "").join("");
+  let text = "";
+  const visit = (node) => {
+    for (const child of toArray(node?.childNodes)) {
+      if (child?.nodeType !== 1) continue;
+      const localName = String(child.localName || child.nodeName || "").replace(/^.*:/, "");
+      if (localName === "t") {
+        text += child.textContent || "";
+      } else if (localName === "tab") {
+        text += "	";
+      } else {
+        visit(child);
+      }
+    }
+  };
+  visit(paragraph);
+  return text;
 }
 function getParagraphText(paragraph) {
   if (!paragraph) return "";
@@ -6814,9 +7366,9 @@ function resolveTargetParagraph(xmlDoc, options = {}) {
     const fuzzyMatch = findParagraphByBestTextMatch(xmlDoc, cleanTargetText, { onInfo });
     if (fuzzyMatch) return { paragraph: fuzzyMatch, resolvedBy: "fuzzy_text" };
   }
-  if (cleanTargetText) throw new Error(`Target paragraph not found: "${cleanTargetText}"`);
-  if (parsedRef) throw new Error(`Target paragraph reference not found: [P${parsedRef}]`);
-  throw new Error('Operation target missing: provide "target" text or "targetRef" ([P#]).');
+  if (cleanTargetText) throw createTargetNotFoundError(`Target paragraph not found: "${cleanTargetText}"`);
+  if (parsedRef) throw createTargetNotFoundError(`Target paragraph reference not found: [P${parsedRef}]`);
+  throw createTargetNotFoundError('Operation target missing: provide "target" text or "targetRef" ([P#]).');
 }
 function isParagraphInTable(paragraph) {
   return !!findContainingWordElement(paragraph, "tbl");
@@ -6903,7 +7455,9 @@ function resolveTargetParagraphWithSnapshot(xmlDoc, options = {}) {
     onInfo(`[Target] [P${parsedRef}] appears stale after prior edits; using strict text rematch for ${opType}.`);
     return { paragraph: bestCandidate.paragraph, resolvedBy: "strict_text_after_ref_drift" };
   }
-  return resolved;
+  throw createTargetNotFoundError(
+    `Target paragraph [P${parsedRef}] no longer matches its batch-start anchor.`
+  );
 }
 function resolveParagraphRangeByRefs(xmlDoc, startRef, endRef, options = {}) {
   if (!xmlDoc || !startRef || !endRef) return null;
@@ -7029,6 +7583,9 @@ function shouldPromoteBulletInsertionsToChildDepth(parsedItems, normalizedTarget
     return isNormalizedTextEqual(firstItem.text, normalizedTargetText);
   }
   if (firstItem?.kind === "list" && firstItem.markerType === "numbered") {
+    const firstLevel = firstItem.level || 0;
+    const alreadyIndented = trailingListItems.some((item) => (item.level || 0) > firstLevel);
+    if (alreadyIndented) return false;
     return isNormalizedTextEqual(firstItem.text, normalizedTargetText);
   }
   return false;
@@ -7471,10 +8028,7 @@ function enforceListBindingOnParagraphNodes(nodes, options = {}) {
     if (!ownerDoc) continue;
     let pPr = getDirectWordChild2(paragraph, "pPr");
     if (!pPr) {
-      pPr = ownerDoc.createElementNS(
-        "http://schemas.openxmlformats.org/wordprocessingml/2006/main",
-        "w:pPr"
-      );
+      pPr = createWordElement(ownerDoc, "w:pPr");
       paragraph.insertBefore(pPr, paragraph.firstChild);
     }
     if (clearParagraphPropertyChanges) {
@@ -7487,27 +8041,18 @@ function enforceListBindingOnParagraphNodes(nodes, options = {}) {
     }
     let numPr = getDirectWordChild2(pPr, "numPr");
     if (!numPr) {
-      numPr = ownerDoc.createElementNS(
-        "http://schemas.openxmlformats.org/wordprocessingml/2006/main",
-        "w:numPr"
-      );
+      numPr = createWordElement(ownerDoc, "w:numPr");
       pPr.appendChild(numPr);
     }
     let ilvlEl = getDirectWordChild2(numPr, "ilvl");
     if (!ilvlEl) {
-      ilvlEl = ownerDoc.createElementNS(
-        "http://schemas.openxmlformats.org/wordprocessingml/2006/main",
-        "w:ilvl"
-      );
+      ilvlEl = createWordElement(ownerDoc, "w:ilvl");
       numPr.appendChild(ilvlEl);
     }
     ilvlEl.setAttribute("w:val", String(ilvl));
     let numIdEl = getDirectWordChild2(numPr, "numId");
     if (!numIdEl) {
-      numIdEl = ownerDoc.createElementNS(
-        "http://schemas.openxmlformats.org/wordprocessingml/2006/main",
-        "w:numId"
-      );
+      numIdEl = createWordElement(ownerDoc, "w:numId");
       numPr.appendChild(numIdEl);
     }
     numIdEl.setAttribute("w:val", String(numId));
@@ -7516,8 +8061,8 @@ function enforceListBindingOnParagraphNodes(nodes, options = {}) {
   return updated;
 }
 function getFirstParagraphFromOxml(oxml) {
-  const parser = createParser();
-  const doc = parser.parseFromString(String(oxml || ""), "application/xml");
+  const doc = parseOoxmlSafe(oxml, "application/xml").doc;
+  if (!doc) return null;
   const parseError = getXmlParseError(doc);
   if (parseError) return null;
   const paragraphs = getDocumentParagraphNodes(doc);
@@ -7543,8 +8088,8 @@ function setElementVal(element, value) {
   element.setAttribute("w:val", String(value));
 }
 function extractFirstParagraphNumIdFromOxml(oxml) {
-  const parser = createParser();
-  const doc = parser.parseFromString(String(oxml || ""), "application/xml");
+  const doc = parseOoxmlSafe(oxml, "application/xml").doc;
+  if (!doc) return null;
   const parseError = getXmlParseError(doc);
   if (parseError) return null;
   const paragraphs = getDocumentParagraphNodes(doc);
@@ -7560,9 +8105,9 @@ function extractFirstParagraphNumIdFromOxml(oxml) {
 function applyStartOverrideToNumberingXml(numberingXml, targetNumId, startAt, options = {}) {
   if (!numberingXml || !targetNumId || !Number.isInteger(startAt) || startAt < 1) return numberingXml;
   const setAbstractStartOverride = options.setAbstractStartOverride !== false;
-  const parser = createParser();
   const serializer = createSerializer();
-  const numberingDoc = parser.parseFromString(String(numberingXml || ""), "application/xml");
+  const numberingDoc = parseOoxmlSafe(numberingXml, "application/xml").doc;
+  if (!numberingDoc) return numberingXml;
   const parseError = getXmlParseError(numberingDoc);
   if (parseError) return numberingXml;
   const nums = Array.from(numberingDoc.getElementsByTagNameNS("*", "num"));
@@ -7578,19 +8123,13 @@ function applyStartOverrideToNumberingXml(numberingXml, targetNumId, startAt, op
     return ilvl === 0;
   }) || null;
   if (!lvlOverride) {
-    lvlOverride = numberingDoc.createElementNS(
-      "http://schemas.openxmlformats.org/wordprocessingml/2006/main",
-      "w:lvlOverride"
-    );
+    lvlOverride = createWordElement(numberingDoc, "w:lvlOverride");
     lvlOverride.setAttribute("w:ilvl", "0");
     target.appendChild(lvlOverride);
   }
   let startOverride = Array.from(lvlOverride.getElementsByTagNameNS("*", "startOverride"))[0] || null;
   if (!startOverride) {
-    startOverride = numberingDoc.createElementNS(
-      "http://schemas.openxmlformats.org/wordprocessingml/2006/main",
-      "w:startOverride"
-    );
+    startOverride = createWordElement(numberingDoc, "w:startOverride");
     lvlOverride.appendChild(startOverride);
   }
   setElementVal(startOverride, startAt);
@@ -7606,19 +8145,13 @@ function applyStartOverrideToNumberingXml(numberingXml, targetNumId, startAt, op
         return ilvl === 0;
       }) || null;
       if (!lvl) {
-        lvl = numberingDoc.createElementNS(
-          "http://schemas.openxmlformats.org/wordprocessingml/2006/main",
-          "w:lvl"
-        );
+        lvl = createWordElement(numberingDoc, "w:lvl");
         lvl.setAttribute("w:ilvl", "0");
         abstractNum.appendChild(lvl);
       }
       let startNode = Array.from(lvl.getElementsByTagNameNS("*", "start"))[0] || null;
       if (!startNode) {
-        startNode = numberingDoc.createElementNS(
-          "http://schemas.openxmlformats.org/wordprocessingml/2006/main",
-          "w:start"
-        );
+        startNode = createWordElement(numberingDoc, "w:start");
         lvl.insertBefore(startNode, lvl.firstChild);
       }
       setElementVal(startNode, startAt);
@@ -7710,20 +8243,20 @@ async function executeSingleLineListStructuralFallback(plan, options = {}) {
 // core/redline-validation.js
 var REVISION_ID_ELEMENTS = /* @__PURE__ */ new Set(["ins", "del", "rPrChange", "pPrChange"]);
 var REVISION_DATE_PATTERN = /^\d{4}-\d{2}-\d{2}T/;
-function localNameOf(node) {
+function localNameOf2(node) {
   return String(node?.localName || node?.nodeName || "").replace(/^.*:/, "");
 }
 function elementsByLocalName(root, name) {
-  return Array.from(root.getElementsByTagName("*")).filter((el) => localNameOf(el) === name);
+  return Array.from(root.getElementsByTagName("*")).filter((el) => localNameOf2(el) === name);
 }
-function wordAttribute(node, name) {
+function wordAttribute2(node, name) {
   return node.getAttribute(`w:${name}`) || node.getAttribute(name) || "";
 }
 function xmlSpaceAttribute(node) {
   return node.getAttribute("xml:space") || node.getAttribute("space") || node.getAttributeNS?.("http://www.w3.org/XML/1998/namespace", "space") || "";
 }
 function isParagraphMarkRevision(node) {
-  return localNameOf(node.parentNode) === "rPr";
+  return localNameOf2(node.parentNode) === "rPr";
 }
 function parseOoxmlForValidation(oxml) {
   const attempt = (xml) => {
@@ -7759,13 +8292,28 @@ function validateRedlineOoxml(oxml) {
   const insElements = elementsByLocalName(doc, "ins");
   const delElements = elementsByLocalName(doc, "del");
   const revisions = insElements.concat(delElements);
+  for (const paragraph of elementsByLocalName(doc, "p")) {
+    const nested = Array.from(paragraph.getElementsByTagName("*")).find((el) => el !== paragraph && localNameOf2(el) === "p");
+    if (nested) {
+      addIssue("NESTED_PARAGRAPH", "error", `<${paragraph.nodeName}> contains nested <${nested.nodeName}>.`);
+    }
+  }
+  for (const body of elementsByLocalName(doc, "body")) {
+    const children = Array.from(body.childNodes || []).filter((child) => child.nodeType === 1);
+    const sectPrIndexes = children.map((child, index) => localNameOf2(child) === "sectPr" ? index : -1).filter((index) => index >= 0);
+    if (sectPrIndexes.length > 1) {
+      addIssue("MULTIPLE_BODY_SECTPR", "error", "<w:body> contains multiple direct <w:sectPr> elements.");
+    } else if (sectPrIndexes.length === 1 && sectPrIndexes[0] !== children.length - 1) {
+      addIssue("SECTPR_NOT_LAST", "error", "<w:sectPr> is not the last element child of <w:body>.");
+    }
+  }
   for (const revision of revisions) {
-    const nested = Array.from(revision.getElementsByTagName("*")).filter((el) => el !== revision && ["ins", "del"].includes(localNameOf(el)));
+    const nested = Array.from(revision.getElementsByTagName("*")).filter((el) => el !== revision && ["ins", "del"].includes(localNameOf2(el)));
     if (nested.length > 0) {
       addIssue(
         "NESTED_REVISION",
         "error",
-        `<${revision.nodeName}> (w:id="${wordAttribute(revision, "id")}") contains nested <${nested[0].nodeName}>.`
+        `<${revision.nodeName}> (w:id="${wordAttribute2(revision, "id")}") contains nested <${nested[0].nodeName}>.`
       );
     }
   }
@@ -7775,15 +8323,15 @@ function validateRedlineOoxml(oxml) {
       addIssue(
         "DEL_CONTAINS_T",
         "error",
-        `<w:del> (w:id="${wordAttribute(del, "id")}") contains <w:t>; deleted text must use <w:delText>.`
+        `<w:del> (w:id="${wordAttribute2(del, "id")}") contains <w:t>; deleted text must use <w:delText>.`
       );
     }
   }
   for (const revision of revisions) {
     const missing = [];
-    if (!wordAttribute(revision, "id")) missing.push("w:id");
-    if (!wordAttribute(revision, "author")) missing.push("w:author");
-    if (!REVISION_DATE_PATTERN.test(wordAttribute(revision, "date"))) missing.push("w:date");
+    if (!wordAttribute2(revision, "id")) missing.push("w:id");
+    if (!wordAttribute2(revision, "author")) missing.push("w:author");
+    if (!REVISION_DATE_PATTERN.test(wordAttribute2(revision, "date"))) missing.push("w:date");
     if (missing.length > 0) {
       addIssue(
         "MISSING_REVISION_METADATA",
@@ -7794,8 +8342,8 @@ function validateRedlineOoxml(oxml) {
   }
   const seenIds = /* @__PURE__ */ new Set();
   for (const node of Array.from(doc.getElementsByTagName("*"))) {
-    if (!REVISION_ID_ELEMENTS.has(localNameOf(node))) continue;
-    const id = wordAttribute(node, "id");
+    if (!REVISION_ID_ELEMENTS.has(localNameOf2(node))) continue;
+    const id = wordAttribute2(node, "id");
     if (!id) continue;
     if (seenIds.has(id)) {
       addIssue("DUPLICATE_REVISION_ID", "error", `Revision id ${id} appears more than once.`);
@@ -7823,7 +8371,7 @@ function validateRedlineOoxml(oxml) {
       addIssue(
         "EMPTY_REVISION_WRAPPER",
         "warning",
-        `<${revision.nodeName}> (w:id="${wordAttribute(revision, "id")}") wraps no content.`
+        `<${revision.nodeName}> (w:id="${wordAttribute2(revision, "id")}") wraps no content.`
       );
     }
   }
@@ -8262,20 +8810,9 @@ function hasParserError(doc) {
   return !!getXmlParseError(doc);
 }
 function parseWordOoxml(ooxml) {
-  const source = typeof ooxml === "string" ? ooxml : String(ooxml || "");
-  if (!source.trim()) {
-    return null;
-  }
-  try {
-    const parser = createParser();
-    const doc = parser.parseFromString(source, "application/xml");
-    if (hasParserError(doc)) {
-      return null;
-    }
-    return doc;
-  } catch {
-    return null;
-  }
+  const parsed = parseOoxmlSafe(ooxml, "application/xml");
+  if (parsed.error || hasParserError(parsed.doc)) return { ...parsed, doc: null };
+  return parsed;
 }
 function getWordParagraphs(doc) {
   if (!doc) return [];
@@ -8430,25 +8967,37 @@ function paragraphToMarkdown(paragraph) {
   return normalizedInline;
 }
 function ingestWordOoxmlToPlainText(ooxml) {
-  const doc = parseWordOoxml(ooxml);
-  if (!doc) return "";
+  return ingestWordOoxmlToPlainTextResult(ooxml).text;
+}
+function ingestWordOoxmlToPlainTextResult(ooxml) {
+  const parsed = parseWordOoxml(ooxml);
+  if (!parsed.doc) {
+    return { text: "", status: "error", error: parsed.error, warnings: parsed.warnings };
+  }
+  const doc = parsed.doc;
   const paragraphs = getWordParagraphs(doc);
   if (paragraphs.length === 0) {
     const fallback = normalizeInlineWhitespace(doc.documentElement?.textContent || "");
-    return fallback;
+    return { text: fallback, status: "ok", warnings: parsed.warnings };
   }
   const lines = paragraphs.map(paragraphToPlainText);
-  return lines.join("\n\n").trim();
+  return { text: lines.join("\n\n").trim(), status: "ok", warnings: parsed.warnings };
 }
 function ingestWordOoxmlToMarkdown(ooxml) {
-  const doc = parseWordOoxml(ooxml);
-  if (!doc) return "";
+  return ingestWordOoxmlToMarkdownResult(ooxml).text;
+}
+function ingestWordOoxmlToMarkdownResult(ooxml) {
+  const parsed = parseWordOoxml(ooxml);
+  if (!parsed.doc) {
+    return { text: "", status: "error", error: parsed.error, warnings: parsed.warnings };
+  }
+  const doc = parsed.doc;
   const paragraphs = getWordParagraphs(doc);
   if (paragraphs.length === 0) {
-    return "";
+    return { text: "", status: "ok", warnings: parsed.warnings };
   }
   const lines = paragraphs.map(paragraphToMarkdown);
-  return lines.join("\n\n").trim();
+  return { text: lines.join("\n\n").trim(), status: "ok", warnings: parsed.warnings };
 }
 
 // services/comment-builders.js
@@ -8620,12 +9169,12 @@ function injectMarkersIntoParagraph(xmlDoc, paragraph, textToFind, commentId, pa
 var PKG_NS = "http://schemas.microsoft.com/office/2006/xmlPackage";
 var RELS_NS = "http://schemas.openxmlformats.org/package/2006/relationships";
 function injectCommentsIntoPackage(packageOxml, commentsXml) {
-  const parser = createParser();
   const serializer = createSerializer();
-  const pkgDoc = parser.parseFromString(packageOxml, "text/xml");
-  const parseError = getXmlParseError(pkgDoc);
-  if (parseError) {
-    error("[CommentEngine] Failed to parse package:", parseError.textContent);
+  const packageParsed = parseOoxmlSafe(packageOxml, "text/xml");
+  const pkgDoc = packageParsed.doc;
+  const parseError = pkgDoc ? getXmlParseError(pkgDoc) : null;
+  if (packageParsed.error || parseError) {
+    error("[CommentEngine] Failed to parse package:", packageParsed.error?.message || parseError?.textContent);
     return packageOxml;
   }
   const pkgPackage = pkgDoc.documentElement;
@@ -8633,7 +9182,8 @@ function injectCommentsIntoPackage(packageOxml, commentsXml) {
   commentsPart.setAttribute("pkg:name", "/word/comments.xml");
   commentsPart.setAttribute("pkg:contentType", "application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml");
   const commentsXmlData = pkgDoc.createElementNS(PKG_NS, "pkg:xmlData");
-  const commentsDoc = parser.parseFromString(commentsXml, "text/xml");
+  const commentsDoc = parseOoxmlSafe(commentsXml, "text/xml").doc;
+  if (!commentsDoc) return packageOxml;
   commentsXmlData.appendChild(pkgDoc.importNode(commentsDoc.documentElement, true));
   commentsPart.appendChild(commentsXmlData);
   pkgPackage.appendChild(commentsPart);
@@ -8683,17 +9233,19 @@ function injectCommentsIntoPackage(packageOxml, commentsXml) {
 }
 
 // services/comment-engine.js
-function parseDocumentOxml(oxml, parser, parseFailureWarning) {
-  try {
-    const xmlDoc = parser.parseFromString(oxml, "text/xml");
-    const parseError = getXmlParseError(xmlDoc);
-    if (parseError) {
-      return { xmlDoc: null, warning: parseFailureWarning(parseError.textContent || "parse error") };
-    }
-    return { xmlDoc, warning: null };
-  } catch (error2) {
-    return { xmlDoc: null, warning: parseFailureWarning(error2.message) };
+function parseDocumentOxml(oxml, parseFailureWarning) {
+  const parsed = parseOoxmlSafe(oxml, "text/xml");
+  const parseError = parsed.doc ? getXmlParseError(parsed.doc) : null;
+  if (parsed.error || parseError) {
+    const message = parsed.error?.message || parseError?.textContent || "parse error";
+    return {
+      xmlDoc: null,
+      warning: parseFailureWarning(message),
+      warnings: parsed.warnings,
+      error: { code: "PARSE_ERROR", message }
+    };
   }
+  return { xmlDoc: parsed.doc, warning: null, warnings: parsed.warnings, error: null };
 }
 function injectCommentsIntoOoxml(oxml, comments, options = {}) {
   const author = options?.author || getDefaultAuthor();
@@ -8703,23 +9255,26 @@ function injectCommentsIntoOoxml(oxml, comments, options = {}) {
   if (!comments || comments.length === 0) {
     return {
       oxml,
+      hasChanges: false,
       commentsApplied: 0,
       warnings: ["No comments to inject"]
     };
   }
-  const parser = createParser();
   const serializer = createSerializer();
   const parseResult = parseDocumentOxml(
     oxml,
-    parser,
     (warning) => `Failed to parse OXML: ${warning}`
   );
+  warnings.push(...parseResult.warnings || []);
   if (!parseResult.xmlDoc) {
     error("[CommentEngine] Parse failure:", parseResult.warning);
     return {
       oxml,
+      hasChanges: false,
       commentsApplied: 0,
-      warnings: [parseResult.warning]
+      status: "error",
+      error: parseResult.error,
+      warnings: [...warnings, parseResult.warning]
     };
   }
   const xmlDoc = parseResult.xmlDoc;
@@ -8778,12 +9333,14 @@ function injectCommentsIntoOoxml(oxml, comments, options = {}) {
   if (placedComments.length === 0) {
     return {
       oxml,
+      hasChanges: false,
       commentsApplied: 0,
       warnings
     };
   }
   return {
     oxml: serializer.serializeToString(xmlDoc),
+    hasChanges: true,
     commentsXml: buildCommentsPartXml(placedComments),
     commentsApplied: placedComments.length,
     warnings
@@ -8853,6 +9410,7 @@ function removeFormattingFromRPr(rPr, formatTypes = ["all"]) {
 function applyFormattingRemovalToOoxml(ooxmlString, targetText, formatTypes) {
   if (!targetText || !ooxmlString) return ooxmlString;
   const doc = parseOoxml(ooxmlString);
+  if (!doc) return ooxmlString;
   const NS_W7 = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
   const runs = doc.getElementsByTagNameNS(NS_W7, "r");
   const insertions = doc.getElementsByTagNameNS(NS_W7, "ins");
@@ -8926,7 +9484,7 @@ function injectHighlightIntoRPr(doc, rPr, color = "yellow", options = {}) {
   rPrElement.appendChild(highlightEl);
   if (generateRedlines && previousRPrState) {
     const rPrChange = createWordElement(doc, "w:rPrChange");
-    const metadata = createRevisionMetadata(author);
+    const metadata = createRevisionMetadata(author, doc);
     rPrChange.setAttribute("w:id", String(metadata.id));
     rPrChange.setAttribute("w:author", metadata.author);
     rPrChange.setAttribute("w:date", metadata.date);
@@ -8940,64 +9498,70 @@ function injectHighlightIntoRPr(doc, rPr, color = "yellow", options = {}) {
 function applyHighlightToOoxml(ooxmlString, targetText, color = "yellow", options = {}) {
   if (!targetText || !ooxmlString) return ooxmlString;
   const doc = parseOoxml(ooxmlString);
+  if (!doc) return ooxmlString;
+  if (options?._revisionIdAllocator instanceof RevisionIdAllocator) {
+    seedRevisionIdsFromDocument(doc, options._revisionIdAllocator);
+  } else {
+    createRevisionIdAllocator(doc);
+  }
   const NS_W7 = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
   const getRunText = (run) => {
     const textNodes = run.getElementsByTagNameNS(NS_W7, "t");
     return Array.from(textNodes).map((t) => t.textContent).join("");
   };
   const allRuns = Array.from(doc.getElementsByTagNameNS(NS_W7, "r"));
-  for (let i = 0; i < allRuns.length; i++) {
-    const run = allRuns[i];
+  const cloneRunWithText2 = (sourceRun, text, shouldHighlight) => {
+    const clonedRun = sourceRun.cloneNode(true);
+    const textNodes = clonedRun.getElementsByTagNameNS(NS_W7, "t");
+    Array.from(textNodes).forEach(removeNode2);
+    const newText = createWordElement(doc, "w:t");
+    newText.setAttribute("xml:space", "preserve");
+    newText.textContent = text;
+    clonedRun.appendChild(newText);
+    if (shouldHighlight) {
+      const rPrElements = clonedRun.getElementsByTagNameNS(NS_W7, "rPr");
+      const existingRPr = rPrElements.length > 0 ? rPrElements[0] : null;
+      const newRPr = injectHighlightIntoRPr(doc, existingRPr, color, options);
+      if (existingRPr) {
+        clonedRun.replaceChild(newRPr, existingRPr);
+      } else {
+        clonedRun.insertBefore(newRPr, clonedRun.firstChild);
+      }
+    }
+    return clonedRun;
+  };
+  for (const run of allRuns) {
     const runText = getRunText(run);
     if (!runText) continue;
-    const matchIndex = runText.indexOf(targetText);
-    if (matchIndex === -1) continue;
+    const matchIndexes = [];
+    let searchOffset = 0;
+    while (searchOffset <= runText.length - targetText.length) {
+      const matchIndex = runText.indexOf(targetText, searchOffset);
+      if (matchIndex === -1) break;
+      matchIndexes.push(matchIndex);
+      searchOffset = matchIndex + targetText.length;
+    }
+    if (matchIndexes.length === 0) continue;
     const parent = run.parentNode;
     if (!parent) {
       console.warn("[Highlight] Run parent is null; skipping. Likely already processed.");
       continue;
     }
-    const prefixText = runText.substring(0, matchIndex);
-    const matchText = runText.substring(matchIndex, matchIndex + targetText.length);
-    const suffixText = runText.substring(matchIndex + targetText.length);
     const fragment = doc.createDocumentFragment();
-    if (prefixText.length > 0) {
-      const prefixRun = run.cloneNode(true);
-      const tNodes = prefixRun.getElementsByTagNameNS(NS_W7, "t");
-      Array.from(tNodes).forEach(removeNode2);
-      const newT = createWordElement(doc, "w:t");
-      newT.setAttribute("xml:space", "preserve");
-      newT.textContent = prefixText;
-      prefixRun.appendChild(newT);
-      fragment.appendChild(prefixRun);
-    }
-    if (matchText.length > 0) {
-      const matchRun = run.cloneNode(true);
-      const tNodes = matchRun.getElementsByTagNameNS(NS_W7, "t");
-      Array.from(tNodes).forEach(removeNode2);
-      const newT = createWordElement(doc, "w:t");
-      newT.setAttribute("xml:space", "preserve");
-      newT.textContent = matchText;
-      matchRun.appendChild(newT);
-      const rPrElements = matchRun.getElementsByTagNameNS(NS_W7, "rPr");
-      const existingRPr = rPrElements.length > 0 ? rPrElements[0] : null;
-      const newRPr = injectHighlightIntoRPr(doc, existingRPr, color, options);
-      if (existingRPr) {
-        matchRun.replaceChild(newRPr, existingRPr);
-      } else {
-        matchRun.insertBefore(newRPr, matchRun.firstChild);
+    let cursor = 0;
+    for (const matchIndex of matchIndexes) {
+      if (matchIndex > cursor) {
+        fragment.appendChild(cloneRunWithText2(run, runText.slice(cursor, matchIndex), false));
       }
-      fragment.appendChild(matchRun);
+      fragment.appendChild(cloneRunWithText2(
+        run,
+        runText.slice(matchIndex, matchIndex + targetText.length),
+        true
+      ));
+      cursor = matchIndex + targetText.length;
     }
-    if (suffixText.length > 0) {
-      const suffixRun = run.cloneNode(true);
-      const tNodes = suffixRun.getElementsByTagNameNS(NS_W7, "t");
-      Array.from(tNodes).forEach(removeNode2);
-      const newT = createWordElement(doc, "w:t");
-      newT.setAttribute("xml:space", "preserve");
-      newT.textContent = suffixText;
-      suffixRun.appendChild(newT);
-      fragment.appendChild(suffixRun);
+    if (cursor < runText.length) {
+      fragment.appendChild(cloneRunWithText2(run, runText.slice(cursor), false));
     }
     parent.replaceChild(fragment, run);
   }
@@ -9018,13 +9582,13 @@ var COMMENTS_PATH = "word/comments.xml";
 var CONTENT_TYPES_PATH = "[Content_Types].xml";
 var DOCUMENT_RELS_PATH = "word/_rels/document.xml.rels";
 function parseXmlStrictStandalone(xmlText, label = "xml") {
-  const parser = createParser();
-  const xmlDoc = parser.parseFromString(xmlText, "application/xml");
-  const parseError = xmlDoc.getElementsByTagName("parsererror")[0];
-  if (parseError) {
-    throw new Error(`[XML parse error] ${label}: ${parseError.textContent || "Unknown"}`);
+  const parsed = parseOoxmlSafe(xmlText, "application/xml");
+  if (parsed.error || !parsed.doc) {
+    const error2 = new Error(`[XML parse error] ${label}: ${parsed.error?.message || "Unknown"}`);
+    error2.code = "PARSE_ERROR";
+    throw error2;
   }
-  return xmlDoc;
+  return parsed.doc;
 }
 function isSectionPropertiesElement(node) {
   return !!node && node.nodeType === 1 && node.namespaceURI === NS_W6 && node.localName === "sectPr";
@@ -9088,9 +9652,8 @@ function getPackagePartName(partElement) {
   return partElement.getAttribute("pkg:name") || partElement.getAttribute("name") || "";
 }
 function extractFromPackageXml(packageXml) {
-  const parser = createParser();
   const serializer = createSerializer();
-  const pkgDoc = parser.parseFromString(packageXml, "application/xml");
+  const pkgDoc = parseXmlStrictStandalone(packageXml, "package OOXML");
   const parts = Array.from(pkgDoc.getElementsByTagNameNS("*", "part"));
   const documentPart = parts.find((part) => getPackagePartName(part) === "/word/document.xml");
   if (!documentPart) {
@@ -9123,23 +9686,37 @@ function extractFromPackageXml(packageXml) {
 }
 function extractReplacementNodesFromOoxml(outputOxml) {
   if (typeof outputOxml !== "string" || !outputOxml.trim()) {
-    throw new Error("Reconciliation engine returned no OOXML payload for this operation");
-  }
-  if (outputOxml.includes("<pkg:package")) {
-    return extractFromPackageXml(outputOxml);
+    return {
+      replacementNodes: [],
+      numberingXml: null,
+      sourceType: "fragment",
+      status: "error",
+      error: { code: "PARSE_ERROR", message: "Reconciliation engine returned no OOXML payload for this operation" }
+    };
   }
-  if (outputOxml.includes("<w:document")) {
-    const parser2 = createParser();
-    const doc = parser2.parseFromString(outputOxml, "application/xml");
-    const body = doc.getElementsByTagNameNS("*", "body")[0];
-    const replacementNodes2 = body ? Array.from(body.childNodes || []).filter((node) => node.nodeType === 1 && !isSectionPropertiesElement(node)) : Array.from(doc.childNodes || []).filter((node) => node.nodeType === 1);
-    return { replacementNodes: replacementNodes2, numberingXml: null, sourceType: "document" };
+  try {
+    if (outputOxml.includes("<pkg:package")) {
+      return extractFromPackageXml(outputOxml);
+    }
+    if (outputOxml.includes("<w:document")) {
+      const doc = parseXmlStrictStandalone(outputOxml, "document OOXML");
+      const body = doc.getElementsByTagNameNS("*", "body")[0];
+      const replacementNodes2 = body ? Array.from(body.childNodes || []).filter((node) => node.nodeType === 1 && !isSectionPropertiesElement(node)) : Array.from(doc.childNodes || []).filter((node) => node.nodeType === 1);
+      return { replacementNodes: replacementNodes2, numberingXml: null, sourceType: "document" };
+    }
+    const wrapped = `<root xmlns:w="${NS_W6}">${outputOxml}</root>`;
+    const fragmentDoc = parseXmlStrictStandalone(wrapped, "OOXML fragment");
+    const replacementNodes = Array.from(fragmentDoc.documentElement.childNodes || []).filter((node) => node.nodeType === 1);
+    return { replacementNodes, numberingXml: null, sourceType: "fragment" };
+  } catch (caught) {
+    return {
+      replacementNodes: [],
+      numberingXml: null,
+      sourceType: "fragment",
+      status: "error",
+      error: { code: "PARSE_ERROR", message: caught?.message || "Could not parse OOXML payload." }
+    };
   }
-  const wrapped = `<root xmlns:w="${NS_W6}">${outputOxml}</root>`;
-  const parser = createParser();
-  const fragmentDoc = parser.parseFromString(wrapped, "application/xml");
-  const replacementNodes = Array.from(fragmentDoc.documentElement.childNodes || []).filter((node) => node.nodeType === 1);
-  return { replacementNodes, numberingXml: null, sourceType: "fragment" };
 }
 function upsertContentTypeOverride(ctDoc, partName, contentType) {
   const overrides = Array.from(ctDoc.getElementsByTagNameNS("*", "Override"));
@@ -9199,18 +9776,17 @@ async function ensureNumberingArtifactsInZip(zip, numberingXmlList, options = {}
     onInfo("[Demo] Merging numbering.xml payload(s) into existing numbering definitions");
   }
   zip.file(NUMBERING_PATH, mergedNumberingXml);
-  const parser = createParser();
   const serializer = createSerializer();
   const ctText = await readZipText(zip, CONTENT_TYPES_PATH);
   if (ctText) {
-    const ctDoc = parser.parseFromString(ctText, "application/xml");
+    const ctDoc = parseXmlStrictStandalone(ctText, CONTENT_TYPES_PATH);
     if (upsertContentTypeOverride(ctDoc, "/word/numbering.xml", NUMBERING_CONTENT_TYPE)) {
       zip.file(CONTENT_TYPES_PATH, serializer.serializeToString(ctDoc));
     }
   }
   const relsText = await readZipText(zip, DOCUMENT_RELS_PATH);
   if (relsText) {
-    const relsDoc = parser.parseFromString(relsText, "application/xml");
+    const relsDoc = parseXmlStrictStandalone(relsText, DOCUMENT_RELS_PATH);
     if (upsertDocumentRelationship(relsDoc, NUMBERING_REL_TYPE, "numbering.xml")) {
       zip.file(DOCUMENT_RELS_PATH, serializer.serializeToString(relsDoc));
     }
@@ -9220,7 +9796,6 @@ async function ensureCommentsArtifactsInZip(zip, commentsXml, options = {}) {
   const onInfo = typeof options?.onInfo === "function" ? options.onInfo : () => {
   };
   if (!commentsXml) return;
-  const parser = createParser();
   const serializer = createSerializer();
   const existingText = await readZipText(zip, COMMENTS_PATH);
   if (!existingText) {
@@ -9244,14 +9819,14 @@ async function ensureCommentsArtifactsInZip(zip, commentsXml, options = {}) {
   }
   const ctText = await readZipText(zip, CONTENT_TYPES_PATH);
   if (ctText) {
-    const ctDoc = parser.parseFromString(ctText, "application/xml");
+    const ctDoc = parseXmlStrictStandalone(ctText, CONTENT_TYPES_PATH);
     if (upsertContentTypeOverride(ctDoc, "/word/comments.xml", COMMENTS_CONTENT_TYPE)) {
       zip.file(CONTENT_TYPES_PATH, serializer.serializeToString(ctDoc));
     }
   }
   const relsText = await readZipText(zip, DOCUMENT_RELS_PATH);
   if (relsText) {
-    const relsDoc = parser.parseFromString(relsText, "application/xml");
+    const relsDoc = parseXmlStrictStandalone(relsText, DOCUMENT_RELS_PATH);
     if (upsertDocumentRelationship(relsDoc, COMMENTS_REL_TYPE, "comments.xml")) {
       zip.file(DOCUMENT_RELS_PATH, serializer.serializeToString(relsDoc));
     }
@@ -9514,10 +10089,12 @@ async function reconcileMarkdownTableOoxml(oxml, originalText, markdownTable, op
 }
 async function applyRedlineToOxmlWithListFallback(oxml, originalText, modifiedText, options = {}) {
   const allowExistingListForFallback = options.listFallbackAllowExistingList !== false;
+  const fallbackModifiedText = options.sanitizeInput === true ? sanitizeAiResponse(modifiedText) : modifiedText;
+  const sanitizationWarnings = fallbackModifiedText !== modifiedText ? ["Input was sanitized; pass sanitizeInput: false to disable."] : [];
   const plan = buildSingleLineListStructuralFallbackPlan({
     oxml,
     originalText,
-    modifiedText,
+    modifiedText: fallbackModifiedText,
     allowExistingList: allowExistingListForFallback
   });
   const preferListFallback = options.preferListStructuralFallback !== false;
@@ -9537,7 +10114,7 @@ async function applyRedlineToOxmlWithListFallback(oxml, originalText, modifiedTe
       return withOoxmlSourceType({
         oxml: wrappedOxml2,
         hasChanges: true,
-        warnings: fallbackWarnings2,
+        warnings: [...sanitizationWarnings, ...fallbackWarnings2],
         listStructuralFallbackApplied: true,
         listStructuralFallbackKey: fallbackResult2.listStructuralFallbackKey || null,
         listStructuralFallbackNumberingXml: fallbackResult2.numberingXml || null
@@ -9656,7 +10233,9 @@ export {
   inferTableReplacementParagraphBlock,
   ingestOoxml,
   ingestWordOoxmlToMarkdown,
+  ingestWordOoxmlToMarkdownResult,
   ingestWordOoxmlToPlainText,
+  ingestWordOoxmlToPlainTextResult,
   injectCommentsIntoOoxml,
   injectCommentsIntoPackage2 as injectCommentsIntoPackage,
   insertBodyElementBeforeSectPr,
@@ -9670,8 +10249,8 @@ export {
   overwriteParagraphNumIds,
   parseMarkdownListContent,
   parseOoxml,
+  parseOoxmlSafe,
   parseParagraphReference,
-  parseXmlStrictStandalone,
   planListInsertionOnlyEdit,
   preprocessMarkdown,
   reconcileMarkdownTableOoxml,