@adeu/core 1.8.0 → 1.10.0

package/dist/index.js

@@ -26,6 +26,9 @@ function findAllDescendants(element, tagName) {
   return Array.from(element.getElementsByTagName(tagName));
 }
 function parseXml(xmlString) {
+  if (xmlString.startsWith("\uFEFF")) {
+    xmlString = xmlString.slice(1);
+  }
   return new DOMParser().parseFromString(xmlString, "text/xml");
 }
 function serializeXml(node) {
@@ -449,6 +452,21 @@ var CommentsManager = class {
     return part;
   }
   _ensureNamespaces() {
+    const root = this._commentsPart?._element;
+    if (!root) return;
+    const required = [
+      ["xmlns:w", NS.w],
+      ["xmlns:w14", NS.w14],
+      ["xmlns:w15", NS.w15],
+      ["xmlns:w16cid", NS.w16cid],
+      ["xmlns:w16cex", NS.w16cex],
+      ["xmlns:mc", NS.mc]
+    ];
+    for (const [attr, uri] of required) {
+      if (!root.getAttribute(attr)) {
+        root.setAttribute(attr, uri);
+      }
+    }
   }
   _getNextCommentId() {
     const ids = [0];
@@ -574,9 +592,9 @@ var CommentsManager = class {
     return commentId;
   }
   deleteComment(commentId) {
-    if (!this._commentsPart) return;
+    if (!this.commentsPart) return;
     let commentEl = null;
-    for (const c of findAllDescendants(this._commentsPart._element, "w:comment")) {
+    for (const c of findAllDescendants(this.commentsPart._element, "w:comment")) {
       if (c.getAttribute("w:id") === commentId) {
         commentEl = c;
         break;
@@ -600,7 +618,7 @@ var CommentsManager = class {
           if (child.getAttribute("w15:paraIdParent") === paraId) {
             const childParaId = child.getAttribute("w15:paraId");
             if (childParaId) {
-              for (const c of findAllDescendants(this._commentsPart._element, "w:comment")) {
+              for (const c of findAllDescendants(this.commentsPart._element, "w:comment")) {
                 for (const p of findAllDescendants(c, "w:p")) {
                   if (p.getAttribute("w14:paraId") === childParaId) {
                     const cid = c.getAttribute("w:id");
@@ -1834,6 +1852,29 @@ ${header}`;
 
 // src/diff.ts
 import diff_match_patch from "diff-match-patch";
+function _count_standalone_underscores(s) {
+  let count = 0;
+  let i = 0;
+  const n = s.length;
+  const isAlnum = (char) => /[a-zA-Z0-9]/.test(char);
+  while (i < n) {
+    if (s[i] === "_") {
+      let is_double = false;
+      if (i > 0 && s[i - 1] === "_" || i < n - 1 && s[i + 1] === "_") {
+        is_double = true;
+      }
+      let is_intra = false;
+      if (i > 0 && isAlnum(s[i - 1]) && i < n - 1 && isAlnum(s[i + 1])) {
+        is_intra = true;
+      }
+      if (!is_double && !is_intra) {
+        count++;
+      }
+    }
+    i++;
+  }
+  return count;
+}
 function trim_common_context(target, new_val) {
   if (!target || !new_val) return [0, 0];
   const isSpace = (char) => /\s/.test(char);
@@ -1864,7 +1905,7 @@ function trim_common_context(target, new_val) {
     const left = target.substring(0, prefix_len);
     const b_count = (left.match(/\*\*/g) || []).length;
     const u2_count = (left.match(/__/g) || []).length;
-    const u1_count = (left.replace(/__/g, "").match(/_/g) || []).length;
+    const u1_count = _count_standalone_underscores(left);
     if (b_count % 2 !== 0) {
       prefix_len = left.lastIndexOf("**");
       continue;
@@ -1875,10 +1916,14 @@ function trim_common_context(target, new_val) {
     }
     if (u1_count % 2 !== 0) {
       let idx = left.length - 1;
+      const isAlnum = (char) => /[a-zA-Z0-9]/.test(char);
       while (idx >= 0) {
         if (left[idx] === "_" && (idx === 0 || left[idx - 1] !== "_") && (idx === left.length - 1 || left[idx + 1] !== "_")) {
-          prefix_len = idx;
-          break;
+          const is_intra = idx > 0 && isAlnum(left[idx - 1]) && idx < left.length - 1 && isAlnum(left[idx + 1]);
+          if (!is_intra) {
+            prefix_len = idx;
+            break;
+          }
         }
         idx--;
       }
@@ -1938,7 +1983,7 @@ function trim_common_context(target, new_val) {
     const right = target.substring(target.length - suffix_len);
     const b_count = (right.match(/\*\*/g) || []).length;
     const u2_count = (right.match(/__/g) || []).length;
-    const u1_count = (right.replace(/__/g, "").match(/_/g) || []).length;
+    const u1_count = _count_standalone_underscores(right);
     if (b_count % 2 !== 0) {
       suffix_len -= right.indexOf("**") + 2;
       continue;
@@ -1949,10 +1994,14 @@ function trim_common_context(target, new_val) {
     }
     if (u1_count % 2 !== 0) {
       let idx_in_right = 0;
+      const isAlnum = (char) => /[a-zA-Z0-9]/.test(char);
       while (idx_in_right < right.length) {
         if (right[idx_in_right] === "_" && (idx_in_right === 0 || right[idx_in_right - 1] !== "_") && (idx_in_right === right.length - 1 || right[idx_in_right + 1] !== "_")) {
-          suffix_len -= idx_in_right + 1;
-          break;
+          const is_intra = idx_in_right > 0 && isAlnum(right[idx_in_right - 1]) && idx_in_right < right.length - 1 && isAlnum(right[idx_in_right + 1]);
+          if (!is_intra) {
+            suffix_len -= idx_in_right + 1;
+            break;
+          }
         }
         idx_in_right++;
       }
@@ -2599,6 +2648,36 @@ var RedlineEngine = class {
     this.mapper = new DocumentMapper(this.doc);
     this.comments_manager = new CommentsManager(this.doc);
   }
+  _check_punctuation_warning(target_text) {
+    if (!target_text) return null;
+    if (target_text.includes("_") || target_text.includes("-")) {
+      return `Warning: target_text '${target_text}' contains tokenization-splitting punctuation ('_' or '-'). This can trigger mid-word splits in the diff engine. Consider using a longer plain-prose anchor.`;
+    }
+    return null;
+  }
+  _build_edit_context_previews(edit) {
+    if (edit.type !== "modify") return [null, null];
+    if (edit._resolved_proxy_edit) {
+      edit = edit._resolved_proxy_edit;
+    }
+    const start_idx = edit._resolved_start_idx;
+    if (start_idx === void 0 || start_idx === null) return [null, null];
+    const target_text = edit.target_text || "";
+    const new_text = edit.new_text || "";
+    const length = target_text.length;
+    const active_mapper = edit._active_mapper_ref || this.mapper;
+    const full_text = active_mapper.full_text;
+    if (!full_text) return [null, null];
+    const before_start = Math.max(0, start_idx - 30);
+    const context_before = full_text.substring(before_start, start_idx);
+    const context_after = full_text.substring(start_idx + length, start_idx + length + 30);
+    const critic_markup = `${context_before}{--${target_text}--}{++${new_text}++}${context_after}`;
+    let clean_text = critic_markup;
+    clean_text = clean_text.replace(/\{>>.*?<<\}/gs, "");
+    clean_text = clean_text.replace(/\{--.*?--\}/gs, "");
+    clean_text = clean_text.replace(/\{\+\+(.*?)\+\+\}/gs, "$1");
+    return [critic_markup, clean_text];
+  }
   _scan_existing_ids() {
     let maxId = 0;
     for (const tag of ["w:ins", "w:del"]) {
@@ -2691,28 +2770,84 @@ var RedlineEngine = class {
         }
       }
     }
-    const comment_ids = /* @__PURE__ */ new Set();
-    for (const tag of [
-      "w:commentRangeStart",
-      "w:commentRangeEnd",
-      "w:commentReference"
-    ]) {
-      for (const node of findAllDescendants(this.doc.element, tag)) {
-        const cid = node.getAttribute("w:id");
-        if (cid) comment_ids.add(cid);
+    for (const root_element of parts_to_process) {
+      for (const tag of ["w:commentRangeStart", "w:commentRangeEnd"]) {
+        for (const el of findAllDescendants(root_element, tag)) {
+          el.parentNode?.removeChild(el);
+        }
       }
-    }
-    const comments_part = this.doc.pkg.parts.find(
-      (p) => p.contentType === "application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml"
-    );
-    if (comments_part) {
-      for (const c of findAllDescendants(comments_part._element, "w:comment")) {
-        const cid = c.getAttribute("w:id");
-        if (cid) comment_ids.add(cid);
+      const refs = findAllDescendants(root_element, "w:commentReference");
+      for (const ref of refs) {
+        const parent = ref.parentNode;
+        if (parent) {
+          if (parent.tagName === "w:r" || parent.tagName.endsWith(":r")) {
+            const nonRprChildren = Array.from(parent.childNodes).filter(
+              (c) => c.nodeType === 1 && c.tagName !== "w:rPr" && c.tagName !== "rPr"
+            );
+            if (nonRprChildren.length <= 1) {
+              parent.parentNode?.removeChild(parent);
+            } else {
+              parent.removeChild(ref);
+            }
+          } else {
+            parent.removeChild(ref);
+          }
+        }
       }
     }
-    for (const cid of comment_ids) {
-      this.comments_manager.deleteComment(cid);
+    const pkg = this.doc.pkg;
+    const comment_partnames = /* @__PURE__ */ new Set();
+    for (const part of pkg.parts) {
+      if (part.partname.toLowerCase().includes("comments")) {
+        comment_partnames.add(part.partname);
+        const withSlash = part.partname.startsWith("/") ? part.partname : "/" + part.partname;
+        const withoutSlash = part.partname.startsWith("/") ? part.partname.substring(1) : part.partname;
+        comment_partnames.add(withSlash);
+        comment_partnames.add(withoutSlash);
+      }
+    }
+    if (comment_partnames.size > 0) {
+      for (const part of pkg.parts) {
+        if (part.partname.endsWith(".rels")) {
+          const rels = findAllDescendants(part._element, "Relationship");
+          const toRemove = [];
+          for (const rel of rels) {
+            const target = rel.getAttribute("Target") || "";
+            if (target.toLowerCase().includes("comments")) {
+              toRemove.push(rel);
+              const sourcePath = part.partname.replace("/_rels/", "/").replace(".rels", "");
+              const sourcePart = pkg.getPartByPath(sourcePath);
+              if (sourcePart) {
+                const relId = rel.getAttribute("Id");
+                if (relId) sourcePart.rels.delete(relId);
+              }
+            }
+          }
+          for (const relEl of toRemove) {
+            relEl.parentNode?.removeChild(relEl);
+          }
+        }
+      }
+      const ctPart = pkg.getPartByPath("[Content_Types].xml");
+      if (ctPart) {
+        const overrides = findAllDescendants(ctPart._element, "Override");
+        const toRemove = [];
+        for (const override of overrides) {
+          const partName = override.getAttribute("PartName") || "";
+          if (comment_partnames.has(partName) || partName.toLowerCase().includes("comments")) {
+            toRemove.push(override);
+          }
+        }
+        for (const overrideEl of toRemove) {
+          overrideEl.parentNode?.removeChild(overrideEl);
+        }
+      }
+      pkg.parts = pkg.parts.filter((p) => !p.partname.toLowerCase().includes("comments"));
+      for (const key of Object.keys(pkg.unzipped)) {
+        if (key.toLowerCase().includes("comments")) {
+          delete pkg.unzipped[key];
+        }
+      }
     }
   }
   _getNextId() {
@@ -2803,40 +2938,40 @@ var RedlineEngine = class {
     }
   }
   /**
-  * Inserts `text` as one or more tracked paragraphs anchored relative to
-  * either an existing run or a paragraph. Returns:
-  *   { first_node, last_p, last_ins, used_block_mode }
-  * where:
-  *   - first_node: the first <w:ins> (for inline mode) OR the first new <w:p>
-  *     (for block mode). The caller uses this for splicing into the DOM and
-  *     for anchoring comments.
-  *   - last_p: the last new <w:p> created, if any. null when entirely inline.
-  *   - last_ins: the last <w:ins> created (inside the last new <w:p>, or the
-  *     sole inline ins). Used as the comment's end anchor.
-  *   - used_block_mode: true when the first line carried a heading/list style
-  *     marker and we created a new paragraph for it (rather than inlining it).
-  *
-  * Multi-paragraph rules (only when text contains '\n'):
-  *   - Each additional line becomes a new <w:p>, inserted after the anchor
-  *     paragraph in document order.
-  *   - Each new <w:p> gets a copy of the anchor paragraph's <w:pPr> (so list
-  *     numbering / indentation are preserved) unless the line itself starts
-  *     with a markdown heading or list marker, which overrides the style.
-  *   - Each new <w:p> carries a tracked paragraph-break marker
-  *     (<w:pPr><w:rPr><w:ins/></w:rPr></w:pPr>) so Word natively tracks the
-  *     paragraph break.
-  *   - Each new <w:p>'s content is wrapped in a <w:ins>, with inline bold/
-  *     italic markdown parsed via _parse_inline_markdown.
-  *
-  * The first line:
-  *   - If it carries a heading / list marker AND we have a paragraph anchor,
-  *     we drop into "block mode": no inline <w:ins>; the first line itself
-  *     becomes the first new <w:p>.
-  *   - Otherwise we emit a single inline <w:ins> for the first line (current
-  *     behaviour) and treat the remaining lines as block extensions.
-  *
-  * Does NOT attach comments; callers handle that.
-  */
+   * Inserts `text` as one or more tracked paragraphs anchored relative to
+   * either an existing run or a paragraph. Returns:
+   *   { first_node, last_p, last_ins, used_block_mode }
+   * where:
+   *   - first_node: the first <w:ins> (for inline mode) OR the first new <w:p>
+   *     (for block mode). The caller uses this for splicing into the DOM and
+   *     for anchoring comments.
+   *   - last_p: the last new <w:p> created, if any. null when entirely inline.
+   *   - last_ins: the last <w:ins> created (inside the last new <w:p>, or the
+   *     sole inline ins). Used as the comment's end anchor.
+   *   - used_block_mode: true when the first line carried a heading/list style
+   *     marker and we created a new paragraph for it (rather than inlining it).
+   *
+   * Multi-paragraph rules (only when text contains '\n'):
+   *   - Each additional line becomes a new <w:p>, inserted after the anchor
+   *     paragraph in document order.
+   *   - Each new <w:p> gets a copy of the anchor paragraph's <w:pPr> (so list
+   *     numbering / indentation are preserved) unless the line itself starts
+   *     with a markdown heading or list marker, which overrides the style.
+   *   - Each new <w:p> carries a tracked paragraph-break marker
+   *     (<w:pPr><w:rPr><w:ins/></w:rPr></w:pPr>) so Word natively tracks the
+   *     paragraph break.
+   *   - Each new <w:p>'s content is wrapped in a <w:ins>, with inline bold/
+   *     italic markdown parsed via _parse_inline_markdown.
+   *
+   * The first line:
+   *   - If it carries a heading / list marker AND we have a paragraph anchor,
+   *     we drop into "block mode": no inline <w:ins>; the first line itself
+   *     becomes the first new <w:p>.
+   *   - Otherwise we emit a single inline <w:ins> for the first line (current
+   *     behaviour) and treat the remaining lines as block extensions.
+   *
+   * Does NOT attach comments; callers handle that.
+   */
   _track_insert_multiline(text, anchor_run, anchor_paragraph, reuse_id) {
     if (!text) {
       return {
@@ -2976,7 +3111,15 @@ var RedlineEngine = class {
         const anchor_rPr = findChild(anchor_run._element, "w:rPr");
         if (anchor_rPr) {
           const clone = anchor_rPr.cloneNode(true);
-          for (const tag of ["w:vanish", "w:strike", "w:dstrike"]) {
+          for (const tag of [
+            "w:vanish",
+            "w:strike",
+            "w:dstrike",
+            "w:i",
+            "w:iCs",
+            "w:b",
+            "w:bCs"
+          ]) {
             const found = findChild(clone, tag);
             if (found) clone.removeChild(found);
           }
@@ -3250,6 +3393,16 @@ var RedlineEngine = class {
         matches = this.clean_mapper.find_all_match_indices(edit.target_text);
         if (matches.length > 0) activeText = this.clean_mapper.full_text;
       }
+      if (activeText === this.mapper.full_text && matches.length > 1) {
+        const liveMatches = matches.filter(([start, length]) => {
+          const realSpans = this.mapper.spans.filter(
+            (s) => s.run !== null && s.end > start && s.start < start + length
+          );
+          if (realSpans.length === 0) return true;
+          return realSpans.some((s) => !s.del_id);
+        });
+        if (liveMatches.length > 0) matches = liveMatches;
+      }
       if (matches.length === 0) {
         errors.push(
           `- Edit ${i + 1} Failed: Target text not found in document:
@@ -3269,6 +3422,31 @@ var RedlineEngine = class {
           )
         );
       }
+      if (matches.length === 1) {
+        const [m_start, m_len] = matches[0];
+        const matched = activeText.substring(m_start, m_start + m_len);
+        const [pfx, sfx] = trim_common_context(matched, edit.new_text || "");
+        const t_end = matched.length - sfx;
+        const final_target = matched.substring(pfx, t_end);
+        const final_new = (edit.new_text || "").substring(pfx, (edit.new_text || "").length - sfx);
+        if (final_target.includes("\n\n")) {
+          if (final_new.includes("\n\n")) {
+            const parts = matched.split("\n\n");
+            if (parts.length >= 2 && parts[0].trim() !== "" && parts[parts.length - 1].trim() !== "") {
+              errors.push(
+                `- Edit ${i + 1} Failed: target_text spans a paragraph boundary with body text on both sides. The paragraph break is a structural element, not literal text, so it cannot be replaced as a single span without corrupting the document. Split this into one edit per paragraph.`
+              );
+            }
+          } else {
+            const parts = final_target.split("\n\n");
+            if (parts.length >= 2 && parts[0].trim() !== "" && parts[parts.length - 1].trim() !== "") {
+              errors.push(
+                `- Edit ${i + 1} Failed: target_text spans a paragraph boundary with body text on both sides. The paragraph break is a structural element, not literal text, so it cannot be replaced as a single span without corrupting the document. Split this into one edit per paragraph.`
+              );
+            }
+          }
+        }
+      }
       for (const [start, length] of matches) {
         const spans = this.mapper.spans.filter(
           (s) => s.end > start && s.start < start + length
@@ -3332,7 +3510,33 @@ var RedlineEngine = class {
     }
     return errors;
   }
-  process_batch(changes) {
+  process_batch(changes, dry_run = false) {
+    if (dry_run) {
+      const baselines = /* @__PURE__ */ new Map();
+      for (const part of this.doc.pkg.parts) {
+        if (part._element) {
+          baselines.set(part, part._element.cloneNode(true));
+        }
+      }
+      try {
+        return this._process_batch_internal(changes, true);
+      } finally {
+        for (const [part, originalEl] of baselines.entries()) {
+          const doc = part._element.ownerDocument;
+          if (doc && doc.documentElement) {
+            doc.replaceChild(originalEl, doc.documentElement);
+          }
+          part._element = originalEl;
+        }
+        this.mapper = new DocumentMapper(this.doc);
+        this.comments_manager = new CommentsManager(this.doc);
+        this.clean_mapper = null;
+      }
+    } else {
+      return this._process_batch_internal(changes, false);
+    }
+  }
+  _process_batch_internal(changes, dry_run_mode = false) {
     this.skipped_details = [];
     const actions = changes.filter(
       (c) => ["accept", "reject", "reply"].includes(c.type)
@@ -3340,38 +3544,129 @@ var RedlineEngine = class {
     const edits = changes.filter(
       (c) => !["accept", "reject", "reply"].includes(c.type)
     );
-    const all_errors = [];
-    if (actions.length > 0) {
-      all_errors.push(...this.validate_review_actions(actions));
-    }
-    if (edits.length > 0) {
-      all_errors.push(...this.validate_edits(edits));
-    }
-    if (all_errors.length > 0) {
-      throw new BatchValidationError(all_errors);
+    if (!dry_run_mode) {
+      const all_errors = [];
+      if (actions.length > 0) {
+        all_errors.push(...this.validate_review_actions(actions));
+      }
+      if (edits.length > 0) {
+        all_errors.push(...this.validate_edits(edits));
+      }
+      if (all_errors.length > 0) {
+        throw new BatchValidationError(all_errors);
+      }
+    } else {
+      if (actions.length > 0) {
+        const action_errors = this.validate_review_actions(actions);
+        if (action_errors.length > 0) {
+          throw new BatchValidationError(action_errors);
+        }
+      }
     }
-    let applied_actions = 0, skipped_actions = 0;
+    let applied_actions = 0;
+    let skipped_actions = 0;
     if (actions.length > 0) {
       const res = this.apply_review_actions(actions);
       applied_actions = res[0];
       skipped_actions = res[1];
+      if (skipped_actions > 0) {
+        throw new BatchValidationError(this.skipped_details);
+      }
       if (applied_actions > 0) {
         this.mapper["_build_map"]();
         if (this.clean_mapper) this.clean_mapper["_build_map"]();
       }
     }
-    let applied_edits = 0, skipped_edits = 0;
+    const edits_reports = [];
+    let applied_edits = 0;
+    let skipped_edits = 0;
     if (edits.length > 0) {
-      const res = this.apply_edits(edits);
-      applied_edits = res[0];
-      skipped_edits = res[1];
+      if (dry_run_mode) {
+        for (const edit of edits) {
+          const single_errors = this.validate_edits([edit]);
+          const warning = this._check_punctuation_warning(edit.target_text || "");
+          if (single_errors.length > 0) {
+            skipped_edits++;
+            edits_reports.push({
+              status: "failed",
+              target_text: edit.target_text || "",
+              new_text: edit.new_text || "",
+              warning,
+              error: single_errors[0],
+              critic_markup: null,
+              clean_text: null
+            });
+            continue;
+          }
+          const res = this.apply_edits([edit]);
+          const applied = res[0];
+          if (applied > 0) {
+            applied_edits++;
+            const previews = this._build_edit_context_previews(edit);
+            edits_reports.push({
+              status: "applied",
+              target_text: edit.target_text || "",
+              new_text: edit.new_text || "",
+              warning,
+              error: null,
+              critic_markup: previews[0],
+              clean_text: previews[1]
+            });
+          } else {
+            skipped_edits++;
+            const error_msg = this.skipped_details.length > 0 ? this.skipped_details[this.skipped_details.length - 1] : "Failed to apply edit";
+            edits_reports.push({
+              status: "failed",
+              target_text: edit.target_text || "",
+              new_text: edit.new_text || "",
+              warning,
+              error: error_msg,
+              critic_markup: null,
+              clean_text: null
+            });
+          }
+        }
+      } else {
+        const errors = this.validate_edits(edits);
+        if (errors.length > 0) {
+          throw new BatchValidationError(errors);
+        }
+        const cloned_edits = edits.map((e) => JSON.parse(JSON.stringify(e)));
+        const res = this.apply_edits(cloned_edits);
+        applied_edits = res[0];
+        skipped_edits = res[1];
+        for (const edit of cloned_edits) {
+          const success = edit._applied_status || false;
+          const error_msg = edit._error_msg || null;
+          const warning = this._check_punctuation_warning(edit.target_text || "");
+          let critic_markup = null;
+          let clean_text = null;
+          if (success) {
+            const previews = this._build_edit_context_previews(edit);
+            critic_markup = previews[0];
+            clean_text = previews[1];
+          }
+          edits_reports.push({
+            status: success ? "applied" : "failed",
+            target_text: edit.target_text || "",
+            new_text: edit.new_text || "",
+            warning,
+            error: error_msg,
+            critic_markup,
+            clean_text
+          });
+        }
+      }
     }
     return {
       actions_applied: applied_actions,
       actions_skipped: skipped_actions,
       edits_applied: applied_edits,
       edits_skipped: skipped_edits,
-      skipped_details: this.skipped_details
+      skipped_details: this.skipped_details,
+      edits: edits_reports,
+      engine: "node",
+      version: "1.9.0"
     };
   }
   apply_edits(edits) {
@@ -3379,50 +3674,90 @@ var RedlineEngine = class {
     let skipped = 0;
     const resolved_edits = [];
     for (const edit of edits) {
-      if (edit._match_start_index !== void 0 && edit._match_start_index !== null) {
+      edit._applied_status = false;
+      edit._error_msg = null;
+    }
+    for (const edit of edits) {
+      if (edit._resolved_start_idx !== void 0 && edit._resolved_start_idx !== null) {
+        resolved_edits.push([edit, edit.new_text || null]);
+      } else if (edit._match_start_index !== void 0 && edit._match_start_index !== null) {
+        edit._resolved_start_idx = edit._match_start_index;
         resolved_edits.push([edit, edit.new_text || null]);
       } else if (edit.type === "insert_row" || edit.type === "delete_row") {
-        const [idx] = this.mapper.find_match_index(edit.target_text);
-        if (idx !== -1) {
-          edit._match_start_index = idx;
+        let matches = this.mapper.find_all_match_indices(edit.target_text);
+        if (matches.length === 0) {
+          if (!this.clean_mapper) {
+            this.clean_mapper = new DocumentMapper(this.doc, true);
+          }
+          matches = this.clean_mapper.find_all_match_indices(edit.target_text);
+        }
+        if (matches.length > 0) {
+          edit._resolved_start_idx = matches[0][0];
           resolved_edits.push([edit, null]);
         } else {
           skipped++;
-          this.skipped_details.push(
-            `- Failed to locate row target: '${(edit.target_text || "").substring(0, 40)}...'`
-          );
+          edit._applied_status = false;
+          const target_snippet = (edit.target_text || "").trim().substring(0, 40);
+          const msg = `- Failed to locate row target: '${target_snippet}...'`;
+          this.skipped_details.push(msg);
+          edit._error_msg = msg;
         }
       } else {
         const resolved = this._pre_resolve_heuristic_edit(edit);
         if (resolved) {
           if (Array.isArray(resolved)) {
-            for (const r of resolved) resolved_edits.push([r, r.new_text]);
+            for (const r of resolved) {
+              r._resolved_start_idx = r._match_start_index;
+              r._parent_edit_ref = edit;
+              if (edit._resolved_start_idx === void 0 || edit._resolved_start_idx === null) {
+                edit._resolved_start_idx = r._resolved_start_idx;
+              }
+              if (!edit._resolved_proxy_edit) {
+                edit._resolved_proxy_edit = r;
+              }
+              resolved_edits.push([r, r.new_text]);
+            }
           } else {
+            resolved._resolved_start_idx = resolved._match_start_index;
+            resolved._parent_edit_ref = edit;
+            edit._resolved_start_idx = resolved._resolved_start_idx;
+            edit._resolved_proxy_edit = resolved;
             resolved_edits.push([resolved, resolved.new_text]);
           }
         } else {
           skipped++;
-          this.skipped_details.push(
-            `- Failed to apply edit targeting: '${(edit.target_text || "insertion").substring(0, 40)}...'`
-          );
+          edit._applied_status = false;
+          const display_text = edit.target_text || "insertion";
+          const target_snippet = display_text.trim().substring(0, 40);
+          const msg = `- Failed to apply edit targeting: '${target_snippet}...'`;
+          this.skipped_details.push(msg);
+          edit._error_msg = msg;
         }
       }
     }
     resolved_edits.sort(
-      (a, b) => (b[0]._match_start_index || 0) - (a[0]._match_start_index || 0)
+      (a, b) => (b[0]._resolved_start_idx || 0) - (a[0]._resolved_start_idx || 0)
     );
     const occupied_ranges = [];
     for (const [edit, orig_new] of resolved_edits) {
-      const start = edit._match_start_index || 0;
+      const start = edit._resolved_start_idx || 0;
       const end = start + (edit.target_text ? edit.target_text.length : 0);
       const overlaps = occupied_ranges.some(
         ([occ_start, occ_end]) => start < occ_end && end > occ_start
       );
       if (overlaps) {
         skipped++;
-        this.skipped_details.push(
-          `- Skipped overlapping edit targeting: '${(edit.target_text || "insertion").substring(0, 40)}...'`
-        );
+        const display_text = edit.target_text || "insertion";
+        const target_snippet = display_text.trim().substring(0, 40);
+        const msg = `- Skipped overlapping edit targeting: '${target_snippet}...'`;
+        this.skipped_details.push(msg);
+        edit._applied_status = false;
+        edit._error_msg = msg;
+        const parent = edit._parent_edit_ref;
+        if (parent) {
+          parent._applied_status = false;
+          parent._error_msg = msg;
+        }
         continue;
       }
       let success = false;
@@ -3434,11 +3769,26 @@ var RedlineEngine = class {
       if (success) {
         applied++;
         occupied_ranges.push([start, end]);
+        edit._applied_status = true;
+        const parent = edit._parent_edit_ref;
+        if (parent) {
+          parent._applied_status = true;
+        }
       } else {
         skipped++;
-        this.skipped_details.push(
-          `- Failed to apply edit targeting: '${(edit.target_text || "insertion").substring(0, 40)}...'`
-        );
+        const display_text = edit.target_text || "insertion";
+        const target_snippet = display_text.trim().substring(0, 40);
+        const msg = `- Failed to apply edit targeting: '${target_snippet}...'`;
+        this.skipped_details.push(msg);
+        edit._applied_status = false;
+        edit._error_msg = msg;
+        const parent = edit._parent_edit_ref;
+        if (parent) {
+          if (!parent._applied_status) {
+            parent._applied_status = false;
+            parent._error_msg = msg;
+          }
+        }
       }
     }
     return [applied, skipped];
@@ -3531,7 +3881,7 @@ var RedlineEngine = class {
     return [applied, skipped];
   }
   _apply_table_edit(edit, rebuild_map) {
-    const start_idx = edit._match_start_index || 0;
+    const start_idx = edit._resolved_start_idx !== void 0 && edit._resolved_start_idx !== null ? edit._resolved_start_idx : edit._match_start_index || 0;
     const [anchor_run, anchor_para] = this.mapper.get_insertion_anchor(
       start_idx,
       rebuild_map
@@ -3575,9 +3925,31 @@ var RedlineEngine = class {
     }
     return false;
   }
+  /**
+   * Returns the first match of `target_text` in the raw mapper that is NOT
+   * entirely contained within a tracked deletion (<w:del>). Tracked-deleted
+   * copies are not live, editable text, so an edit must resolve to a live
+   * occurrence even when a dead copy appears earlier in the document
+   * (BUG-23-5). Falls back to the plain first match when no live copy is
+   * found (e.g. fuzzy/normalized matches the span filter cannot align).
+   */
+  _first_live_match(target_text) {
+    const all = this.mapper.find_all_match_indices(target_text);
+    if (all.length <= 1) {
+      return this.mapper.find_match_index(target_text);
+    }
+    for (const [start, length] of all) {
+      const realSpans = this.mapper.spans.filter(
+        (s) => s.run !== null && s.end > start && s.start < start + length
+      );
+      if (realSpans.length === 0) return [start, length];
+      if (realSpans.some((s) => !s.del_id)) return [start, length];
+    }
+    return this.mapper.find_match_index(target_text);
+  }
   _pre_resolve_heuristic_edit(edit) {
     if (!edit.target_text) return null;
-    let [start_idx, match_len] = this.mapper.find_match_index(edit.target_text);
+    let [start_idx, match_len] = this._first_live_match(edit.target_text);
     let use_clean_map = false;
     if (start_idx === -1) {
       if (!this.clean_mapper)
@@ -3641,7 +4013,7 @@ var RedlineEngine = class {
   _apply_single_edit_indexed(edit, orig_new, rebuild_map) {
     let op = edit._internal_op;
     const active_mapper = edit._active_mapper_ref || this.mapper;
-    const start_idx = edit._match_start_index || 0;
+    const start_idx = edit._resolved_start_idx !== void 0 && edit._resolved_start_idx !== null ? edit._resolved_start_idx : edit._match_start_index || 0;
     const length = edit.target_text ? edit.target_text.length : 0;
     const del_id = ["DELETION", "MODIFICATION"].includes(op) ? this._getNextId() : null;
     const ins_id = ["INSERTION", "MODIFICATION"].includes(op) ? this._getNextId() : null;
@@ -3690,6 +4062,76 @@ var RedlineEngine = class {
         rebuild_map
       );
       if (!anchor_run && !anchor_para) return false;
+      const _bug233_new = edit.new_text || "";
+      const _bug233_trailing_break = /\n\s*$/.test(_bug233_new);
+      let _bug233_target_para = null;
+      {
+        const startingSpans = active_mapper.spans.filter(
+          (s) => s.paragraph !== null && s.start === start_idx
+        );
+        if (startingSpans.length > 0 && startingSpans[0].paragraph) {
+          _bug233_target_para = startingSpans[0].paragraph._element;
+        }
+      }
+      if (_bug233_trailing_break && _bug233_target_para && _bug233_target_para.parentNode) {
+        const body = _bug233_target_para.parentNode;
+        const xmlDoc = this.doc.part._element.ownerDocument;
+        const lines = _bug233_new.split(/[\r\n]+/).filter((l) => l !== "");
+        let firstNew = null;
+        let lastNew = null;
+        let lastIns = null;
+        for (const raw_line of lines) {
+          const [clean_text, style_name] = this._parse_markdown_style(raw_line);
+          const new_p = xmlDoc.createElement("w:p");
+          if (style_name) {
+            this._set_paragraph_style(new_p, style_name);
+          } else {
+            const existing_pPr = findChild(_bug233_target_para, "w:pPr");
+            if (existing_pPr) new_p.appendChild(existing_pPr.cloneNode(true));
+          }
+          let pPr = findChild(new_p, "w:pPr");
+          if (!pPr) {
+            pPr = xmlDoc.createElement("w:pPr");
+            new_p.insertBefore(pPr, new_p.firstChild);
+          }
+          let rPr = findChild(pPr, "w:rPr");
+          if (!rPr) {
+            rPr = xmlDoc.createElement("w:rPr");
+            pPr.appendChild(rPr);
+          }
+          rPr.appendChild(this._create_track_change_tag("w:ins", "", ins_id));
+          const content_ins = this._build_tracked_ins_for_line(
+            clean_text,
+            anchor_run,
+            ins_id,
+            xmlDoc
+          );
+          if (content_ins) new_p.appendChild(content_ins);
+          body.insertBefore(new_p, _bug233_target_para);
+          if (!firstNew) firstNew = new_p;
+          lastNew = new_p;
+          lastIns = content_ins;
+        }
+        if (firstNew) {
+          if (edit.comment && lastNew && lastIns) {
+            const ascend = (el, p) => {
+              let cur = el;
+              while (cur.parentNode && cur.parentNode !== p)
+                cur = cur.parentNode;
+              return cur;
+            };
+            const startIns = findAllDescendants(firstNew, "w:ins")[0] || firstNew;
+            this._attach_comment_spanning(
+              firstNew,
+              ascend(startIns, firstNew),
+              lastNew,
+              ascend(lastIns, lastNew),
+              edit.comment
+            );
+          }
+          return true;
+        }
+      }
       const result = this._track_insert_multiline(
         edit.new_text || "",
         anchor_run,
@@ -5399,15 +5841,88 @@ function remove_all_comments(doc) {
     lines.push(`  ${status} "${_truncate(info.text || "", 60)}" (${info.author || "Unknown"})`);
     cm.deleteComment(cId);
   }
-  for (const tag of ["w:commentRangeStart", "w:commentRangeEnd", "w:commentReference"]) {
+  for (const tag of ["w:commentRangeStart", "w:commentRangeEnd"]) {
     for (const el of findAllDescendants(doc.element, tag)) {
       el.parentNode?.removeChild(el);
     }
   }
+  const refs = findAllDescendants(doc.element, "w:commentReference");
+  for (const ref of refs) {
+    const parent = ref.parentNode;
+    if (parent) {
+      if (parent.tagName === "w:r" || parent.tagName.endsWith(":r")) {
+        const nonRprChildren = Array.from(parent.childNodes).filter(
+          (c) => c.nodeType === 1 && c.tagName !== "w:rPr" && c.tagName !== "rPr"
+        );
+        if (nonRprChildren.length <= 1) {
+          parent.parentNode?.removeChild(parent);
+        } else {
+          parent.removeChild(ref);
+        }
+      } else {
+        parent.removeChild(ref);
+      }
+    }
+  }
   const resolvedCount = Object.values(data).filter((c) => c.resolved).length;
   const openCount = Object.values(data).filter((c) => !c.resolved).length;
   return [`Comments removed: ${keys.length} (${resolvedCount} resolved, ${openCount} open)`].concat(lines);
 }
+function eject_comment_parts(doc) {
+  const pkg = doc.pkg;
+  const comment_partnames = /* @__PURE__ */ new Set();
+  for (const part of pkg.parts) {
+    if (part.partname.toLowerCase().includes("comments")) {
+      comment_partnames.add(part.partname);
+      const withSlash = part.partname.startsWith("/") ? part.partname : "/" + part.partname;
+      const withoutSlash = part.partname.startsWith("/") ? part.partname.substring(1) : part.partname;
+      comment_partnames.add(withSlash);
+      comment_partnames.add(withoutSlash);
+    }
+  }
+  if (comment_partnames.size === 0) return;
+  for (const part of pkg.parts) {
+    if (part.partname.endsWith(".rels")) {
+      const rels = findAllDescendants(part._element, "Relationship");
+      const toRemove = [];
+      for (const rel of rels) {
+        const target = rel.getAttribute("Target") || "";
+        if (target.toLowerCase().includes("comments")) {
+          toRemove.push(rel);
+          const sourcePath = part.partname.replace("/_rels/", "/").replace(".rels", "");
+          const sourcePart = pkg.getPartByPath(sourcePath);
+          if (sourcePart) {
+            const relId = rel.getAttribute("Id");
+            if (relId) sourcePart.rels.delete(relId);
+          }
+        }
+      }
+      for (const relEl of toRemove) {
+        relEl.parentNode?.removeChild(relEl);
+      }
+    }
+  }
+  const ctPart = pkg.getPartByPath("[Content_Types].xml");
+  if (ctPart) {
+    const overrides = findAllDescendants(ctPart._element, "Override");
+    const toRemove = [];
+    for (const override of overrides) {
+      const partName = override.getAttribute("PartName") || "";
+      if (comment_partnames.has(partName) || partName.toLowerCase().includes("comments")) {
+        toRemove.push(override);
+      }
+    }
+    for (const overrideEl of toRemove) {
+      overrideEl.parentNode?.removeChild(overrideEl);
+    }
+  }
+  pkg.parts = pkg.parts.filter((p) => !p.partname.toLowerCase().includes("comments"));
+  for (const key of Object.keys(pkg.unzipped)) {
+    if (key.toLowerCase().includes("comments")) {
+      delete pkg.unzipped[key];
+    }
+  }
+}
 function replace_comment_authors(doc, newAuthor) {
   const cm = new CommentsManager(doc);
   if (!cm.commentsPart) return [];
@@ -5596,6 +6111,7 @@ async function finalize_document(doc, options) {
     const commentsSummary = get_comments_summary(doc);
     report.comments_removed = commentsSummary.total;
     report.add_transform_lines(remove_all_comments(doc));
+    eject_comment_parts(doc);
   } else if (options.sanitize_mode === "keep-markup") {
     const counts = count_tracked_changes(doc);
     report.tracked_changes_found = counts[0] + counts[1] + counts[2];