@adeu/core 1.17.2 → 1.18.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adeu/core",
-  "version": "1.17.2",
+  "version": "1.18.0",
   "description": "",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",

package/src/engine.bugs.test.ts

@@ -418,7 +418,7 @@ describe("Resolved Bugs Core Engine Verification", () => {
     expect(pTarget.parentNode).toBeNull();
   });
 
-  it("BUG-EXPLORE-2: Nested redline validation error includes actionable hint", async () => {
+  it("BUG-EXPLORE-2: a strict edit inside a foreign author's insertion applies (nested change)", async () => {
     const doc = await createTestDocument();
     addParagraph(doc, "Original baseline.");
 
@@ -432,20 +432,18 @@ describe("Resolved Bugs Core Engine Verification", () => {
       },
     ]);
 
-    // Author B tries to modify Author A's pending insertion
+    // Author B modifies Author A's pending insertion — this now applies: the
+    // enclosing <w:ins> is split and Author B's change nested inside it.
     const engineB = new RedlineEngine(doc, "Author B");
-
-    expect(() => {
-      engineB.process_batch([
-        {
-          type: "modify",
-          target_text: "Inserted by A.",
-          new_text: "Modified by B.",
-        },
-      ]);
-    }).toThrowError(
-      /Accept that change first or scope your edit outside of it/,
-    );
+    const result = engineB.process_batch([
+      {
+        type: "modify",
+        target_text: "Inserted by A.",
+        new_text: "Modified by B.",
+      },
+    ]);
+    expect(result.edits_applied).toBe(1);
+    expect(result.edits_skipped).toBe(0);
   });
 
   it("BUG-CROSS-PARA-1: Cross-paragraph modify coalesces paragraphs and tracks para-mark deletion", async () => {

package/src/engine.issue23.test.ts

@@ -422,31 +422,36 @@ describe("BUG-23-4: multi-paragraph target_text must produce actionable feedback
     }
   });
 
-  it("BUG-23-4-NN: rejects plain-paragraph N->N modifications spanning a paragraph boundary to prevent silent corruption", async () => {
+  it("BUG-23-4-NN: applies balanced plain-paragraph N->N modifications per paragraph, preserving the boundary", async () => {
     const doc = await createTestDocument();
     addParagraph(doc, "Clause 1 ends here.");
     addParagraph(doc, "Clause 2 begins here.");
 
     const engine = new RedlineEngine(doc, "Test Author");
 
-    let raised: any = null;
-    try {
-      engine.process_batch([
-        {
-          type: "modify",
-          target_text: "ends here.\n\nClause 2 begins",
-          new_text: "ends here. MERGED\n\nClause 2 begins CHANGED",
-        },
-      ]);
-    } catch (e: any) {
-      raised = e;
-    }
+    // Both target and replacement carry the same number of \n\n breaks, so the
+    // paragraph structure is preserved. The engine splits this into one sub-edit
+    // per paragraph and applies it as a single logical edit. (Unbalanced
+    // merges/splits are still rejected — see the regex case in engine.qa.test.)
+    const result = engine.process_batch([
+      {
+        type: "modify",
+        target_text: "ends here.\n\nClause 2 begins",
+        new_text: "ends here. MERGED\n\nClause 2 begins CHANGED",
+      },
+    ]);
 
-    expect(raised).not.toBeNull();
-    if (raised) {
-      expect(raised.name).toBe("BatchValidationError");
-      expect(raised.message.toLowerCase()).toContain("paragraph boundary");
-    }
+    expect(result.edits_applied).toBe(1);
+    expect(result.edits_skipped).toBe(0);
+
+    const buf = await doc.save();
+    const text = await extractTextFromBuffer(buf);
+    // The paragraph boundary must survive — the two clauses are NOT merged.
+    expect(text).not.toContain("ends here.Clause 2 begins");
+    expect(text).not.toContain("ends here. Clause 2 begins");
+    // Both per-paragraph insertions land.
+    expect(text).toContain("MERGED");
+    expect(text).toContain("CHANGED");
   });
 });
 

package/src/engine.ts

@@ -673,6 +673,106 @@ export class RedlineEngine {
     }
   }
 
+  /**
+   * Revert every tracked change, returning the document to the state it had
+   * before any revision was proposed. The exact inverse of
+   * accept_all_revisions:
+   *
+   *   - <w:ins>  -> removed together with all of its content (the proposed
+   *                 insertion never existed); an inserted row (<w:ins> in
+   *                 <w:trPr>) drops the whole row.
+   *   - <w:del>  -> unwrapped, restoring the original text (<w:delText> becomes
+   *                 <w:t> again); a row-deletion mark in <w:trPr> is removed so
+   *                 the row survives.
+   *   - paragraph-mark <w:del> in pPr/rPr -> removed, undoing a proposed merge.
+   *
+   * Comments are annotations, not revisions, so standalone comments are left in
+   * place; only anchors stranded inside a rejected insertion are cleaned up.
+   *
+   * Insertions are reverted before deletions are restored so a deletion nested
+   * inside a foreign author's insertion is removed wholesale with the insertion
+   * — the contingent text disappears rather than being promoted to committed
+   * body text.
+   *
+   * Known limitation: tracked paragraph STRUCTURE changes (a split recorded as a
+   * pilcrow <w:ins>, or a merge recorded as a pilcrow <w:del>) are reverted only
+   * to the extent of dropping/keeping the mark; the original paragraph boundary
+   * is not reconstructed, because the merge protocol coalesces paragraphs
+   * destructively at edit time. Reverting run-level insertions/deletions (the
+   * common case) is exact. This limitation is shared with the Python engine.
+   */
+  public reject_all_revisions() {
+    const parts_to_process: Element[] = [this.doc.element];
+
+    for (const part of this.doc.pkg.parts) {
+      if (part === this.doc.part) continue;
+      if (
+        part.contentType.includes("wordprocessingml") &&
+        part.contentType.endsWith("+xml")
+      ) {
+        parts_to_process.push(part._element);
+      }
+    }
+
+    for (const root_element of parts_to_process) {
+      // 1. Reject insertions: drop the <w:ins> and everything inside it.
+      //    Document order means an outer <w:ins> is handled before a nested
+      //    one; removing the outer detaches the inner (guarded below).
+      const insNodes = findAllDescendants(root_element, "w:ins");
+      for (const ins of insNodes) {
+        const parent = ins.parentNode as Element | null;
+        if (!parent) continue;
+        this._clean_wrapping_comments(ins);
+        this._delete_comments_in_element(ins);
+        if (parent.tagName === "w:trPr") {
+          const row = parent.parentNode as Element | null;
+          if (row && row.parentNode) {
+            row.parentNode.removeChild(row);
+          }
+        } else {
+          parent.removeChild(ins);
+        }
+      }
+
+      // 2. Reject paragraph-mark deletions: keep the paragraph break.
+      const pNodes = findAllDescendants(root_element, "w:p");
+      for (const p of pNodes) {
+        const pPr = findChild(p, "w:pPr");
+        if (pPr) {
+          const rPr = findChild(pPr, "w:rPr");
+          const delMark = rPr ? findChild(rPr, "w:del") : null;
+          if (rPr && delMark) {
+            rPr.removeChild(delMark);
+          }
+        }
+      }
+
+      // 3. Reject deletions: restore the original text.
+      const delNodes = findAllDescendants(root_element, "w:del");
+      for (const d of delNodes) {
+        const parent = d.parentNode as Element | null;
+        if (!parent) continue;
+        this._clean_wrapping_comments(d);
+        if (parent.tagName === "w:trPr") {
+          parent.removeChild(d);
+          continue;
+        }
+        const delTexts = Array.from(d.getElementsByTagName("w:delText"));
+        for (const dt of delTexts) {
+          const t = d.ownerDocument!.createElement("w:t");
+          t.textContent = dt.textContent;
+          if (dt.hasAttribute("xml:space"))
+            t.setAttribute("xml:space", "preserve");
+          dt.parentNode?.replaceChild(t, dt);
+        }
+        while (d.firstChild) {
+          parent.insertBefore(d.firstChild, d);
+        }
+        parent.removeChild(d);
+      }
+    }
+  }
+
   private _getNextId(): string {
     this.current_id++;
     return this.current_id.toString();
@@ -1501,38 +1601,63 @@ export class RedlineEngine {
           (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 + index_offset} 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 + index_offset} 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.`,
-              );
+          // A *balanced* multi-paragraph modification (target and replacement
+          // carry the same number of paragraph breaks) is safe: it is split
+          // into one sub-edit per paragraph segment and applied, leaving the
+          // structural \n\n breaks untouched. Only reject when the paragraph
+          // structure would actually change (a merge or split), which cannot be
+          // expressed as a per-paragraph text replacement. See
+          // _pre_resolve_heuristic_edit.
+          const balanced =
+            matched.split("\n\n").length ===
+            (edit.new_text || "").split("\n\n").length;
+          if (!balanced) {
+            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 + index_offset} 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 + index_offset} 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(
+        // Filter spans from the SAME mapper the match indices came from
+        // (target_mapper may be the clean mapper); using this.mapper.spans here
+        // would read a different coordinate space and miss the foreign <w:ins>
+        // overlap for clean-mapper-resolved targets — silently letting a
+        // partial straddle through. (Python filters target_mapper.spans too.)
+        const spans = target_mapper.spans.filter(
           (s) => s.end > start && s.start < start + length,
         );
-        const nestedAuthors = new Set<string>();
+        const insAuthors = new Set<string>();
+        const commentAuthors = new Set<string>();
+        // Does any real (run-backed) text in the target lie OUTSIDE a foreign
+        // insertion? If so the target only partially overlaps the insertion and
+        // replacing it as one span would straddle the <w:ins> boundary — that
+        // case must still be refused.
+        let hasNonForeignRealText = false;
         for (const s of spans) {
+          if (s.run === null) continue;
+          let isForeignIns = false;
           if (s.ins_id) {
             const insNodes = findAllDescendants(
               this.doc.element,
@@ -1541,24 +1666,45 @@ export class RedlineEngine {
             if (insNodes.length > 0) {
               const auth = insNodes[0].getAttribute("w:author");
               if (auth && auth !== this.author) {
-                const is_fully_contained_in_ins = start >= s.start && (start + length) <= s.end;
-                const is_lockout = is_fully_contained_in_ins || match_mode === "all";
-                if (is_lockout) {
-                  nestedAuthors.add(auth);
-                }
+                insAuthors.add(auth);
+                isForeignIns = true;
               }
             }
           }
+          if (!isForeignIns) hasNonForeignRealText = true;
+        }
+        for (const s of spans) {
           if (s.comment_ids) {
             for (const cid of s.comment_ids) {
               const c_data = this.mapper.comments_map[cid];
               if (c_data && c_data.author && c_data.author !== this.author) {
-                nestedAuthors.add(c_data.author);
+                commentAuthors.add(c_data.author);
               }
             }
           }
         }
-        if (nestedAuthors.size > 0) {
+        if (insAuthors.size > 0 || commentAuthors.size > 0) {
+          // A single (strict/first) modification whose target lies ENTIRELY
+          // inside foreign-authored insertion(s), with no foreign comment
+          // overlap, is allowed: track_delete_run splits the enclosing <w:ins>
+          // and nests the change, producing valid tracked-change XML. Refuse the
+          // remaining cases — match_mode "all" fan-outs, partial overlaps that
+          // straddle the insertion boundary, and edits touching another author's
+          // comment range.
+          const fullyWithinForeignIns =
+            insAuthors.size > 0 &&
+            !hasNonForeignRealText &&
+            commentAuthors.size === 0;
+          if (
+            (match_mode === "strict" || match_mode === "first") &&
+            fullyWithinForeignIns
+          ) {
+            continue;
+          }
+          const nestedAuthors = new Set<string>([
+            ...insAuthors,
+            ...commentAuthors,
+          ]);
           errors.push(
             `- Edit ${i + 1 + index_offset} Failed: Modification targets an active insertion from another author (${Array.from(nestedAuthors).join(", ")}). Accept that change first or scope your edit outside of it.`,
           );
@@ -1686,60 +1832,17 @@ export class RedlineEngine {
         !["accept", "reject", "reply"].includes(c.type),
     );
 
-    // Run edits_for_merge logic to unwrap collaborative active insertions
-    let mapper_dirty = false;
-    for (const edit of edits as any[]) {
-      if (typeof edit !== "object" || edit === null || !edit.target_text) continue;
-      const is_regex = edit.regex || false;
-      let matches = this.mapper.find_all_match_indices(edit.target_text, is_regex);
-      let target_mapper = this.mapper;
-      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, is_regex);
-        target_mapper = this.clean_mapper!;
-      }
-      for (const [start, length] of matches) {
-        const spans = target_mapper.spans.filter(
-          (s) => s.end > start && s.start < start + length,
-        );
-        for (const s of spans) {
-          if (s.ins_id) {
-            const insNodes = findAllDescendants(this.doc.element, "w:ins").filter(
-              (n) => n.getAttribute("w:id") === s.ins_id,
-            );
-            if (insNodes.length > 0) {
-              const auth = insNodes[0].getAttribute("w:author");
-              if (auth && auth !== this.author) {
-                const is_fully_contained_in_ins = start >= s.start && (start + length) <= s.end;
-                const match_mode = edit.match_mode || "strict";
-                if (!is_fully_contained_in_ins && match_mode !== "all") {
-                  const node = insNodes[0];
-                  this._clean_wrapping_comments(node);
-                  const parent = node.parentNode as Element | null;
-                  if (parent) {
-                    if (parent.tagName === "w:trPr") {
-                      parent.removeChild(node);
-                    } else {
-                      while (node.firstChild) {
-                        parent.insertBefore(node.firstChild, node);
-                      }
-                      parent.removeChild(node);
-                    }
-                  }
-                  mapper_dirty = true;
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-    if (mapper_dirty) {
-      this.mapper = new DocumentMapper(this.doc);
-      this.clean_mapper = null;
-    }
+    // NOTE: a previous "edits_for_merge" pre-pass here silently UNWRAPPED a
+    // foreign author's <w:ins> when a strict/first edit only partially straddled
+    // its boundary — turning that author's tracked-inserted text into untracked
+    // committed body text before the edit applied, destroying their provenance.
+    // That is the same provenance-laundering failure mode the canonical engine
+    // refuses, so it has been removed: a partial straddle now surfaces the
+    // standard validation error ("Modification targets an active insertion from
+    // another author …") via validate_edits, matching the Python engine. An edit
+    // fully CONTAINED inside a foreign <w:ins> stays allowed and is handled by
+    // nesting the <w:del> inside that <w:ins> (see _apply_single_edit_indexed /
+    // _insert_and_split_ins).
 
     // BUG-7: Unified single-pass validation in wet-run / standard mode.
     if (!dry_run_mode) {
@@ -2018,6 +2121,10 @@ export class RedlineEngine {
         (b[0]._resolved_start_idx || 0) - (a[0]._resolved_start_idx || 0),
     );
     const occupied_ranges: [number, number][] = [];
+    // Sub-edits split from one balanced multi-paragraph modification share a
+    // _split_group_id; count the group as a single applied edit (and a single
+    // occurrence), even though it touches several paragraphs.
+    const counted_split_groups = new Set<number>();
 
     for (const [edit, orig_new] of resolved_edits) {
       const start = edit._resolved_start_idx || 0;
@@ -2050,14 +2157,27 @@ export class RedlineEngine {
       }
 
       if (success) {
-        applied++;
+        // A balanced multi-paragraph split fans one logical edit into several
+        // paragraph sub-edits sharing a _split_group_id; count it once. Edits
+        // with no group id (the common case) always count.
+        const group_id = edit._split_group_id;
+        const first_in_group =
+          group_id === undefined ||
+          group_id === null ||
+          !counted_split_groups.has(group_id);
+        if (first_in_group && group_id !== undefined && group_id !== null) {
+          counted_split_groups.add(group_id);
+        }
+        if (first_in_group) applied++;
         occupied_ranges.push([start, end]);
         edit._applied_status = true;
         const parent = edit._parent_edit_ref;
         if (parent) {
           parent._applied_status = true;
-          parent._occurrences_modified =
-            (parent._occurrences_modified || 0) + 1;
+          if (first_in_group) {
+            parent._occurrences_modified =
+              (parent._occurrences_modified || 0) + 1;
+          }
           const [path, page] = this._get_heading_path_and_page(
             start,
             this.mapper.full_text,
@@ -2068,7 +2188,9 @@ export class RedlineEngine {
           parent._pages = pages;
           parent._heading_path = path;
         } else {
-          edit._occurrences_modified = (edit._occurrences_modified || 0) + 1;
+          if (first_in_group) {
+            edit._occurrences_modified = (edit._occurrences_modified || 0) + 1;
+          }
           const [path, page] = this._get_heading_path_and_page(
             start,
             this.mapper.full_text,
@@ -2419,6 +2541,65 @@ export class RedlineEngine {
         final_new = current_effective_new_text.substring(prefix_len, n_end);
         effective_start_idx = start_idx + prefix_len;
 
+        // Balanced multi-paragraph modification: the matched span crosses one or
+        // more paragraph breaks and the replacement preserves the same number of
+        // breaks. Apply it as one independent sub-edit per paragraph segment so
+        // the structural \n\n breaks are left intact. Each sub-edit shares a
+        // _split_group_id (the occurrence's start index) so the batch report
+        // counts it as a single applied edit. Unbalanced cases (a genuine
+        // paragraph merge or split) fall through to the single-span path and are
+        // rejected by validate_edits.
+        const target_segs = actual_doc_text.split("\n\n");
+        const new_segs = current_effective_new_text.split("\n\n");
+        if (
+          actual_doc_text.includes("\n\n") &&
+          target_segs.length === new_segs.length
+        ) {
+          const split_sub_edits: any[] = [];
+          let seg_offset = start_idx;
+          let comment_assigned = false;
+          for (let k = 0; k < target_segs.length; k++) {
+            const t_seg = target_segs[k];
+            const n_seg = new_segs[k];
+            if (t_seg !== n_seg) {
+              const [seg_prefix, seg_suffix] = trim_common_context(t_seg, n_seg);
+              const seg_target = t_seg.substring(
+                seg_prefix,
+                t_seg.length - seg_suffix,
+              );
+              const seg_new = n_seg.substring(
+                seg_prefix,
+                n_seg.length - seg_suffix,
+              );
+              const seg_start = seg_offset + seg_prefix;
+              let seg_op: string;
+              if (!seg_target && seg_new) seg_op = "INSERTION";
+              else if (seg_target && !seg_new) seg_op = "DELETION";
+              else if (seg_target && seg_new) seg_op = "MODIFICATION";
+              else seg_op = "COMMENT_ONLY";
+              const seg_comment =
+                edit.comment && !comment_assigned ? edit.comment : null;
+              if (seg_comment) comment_assigned = true;
+              split_sub_edits.push({
+                type: "modify",
+                target_text: seg_target,
+                new_text: seg_new,
+                comment: seg_comment,
+                _match_start_index: seg_start,
+                _internal_op: seg_op,
+                _active_mapper_ref: active_mapper,
+                _split_group_id: start_idx,
+              });
+            }
+            // Advance past this segment plus its "\n\n" separator span.
+            seg_offset += t_seg.length + 2;
+          }
+          if (split_sub_edits.length > 0) {
+            for (const sub of split_sub_edits) all_sub_edits.push(sub);
+            continue;
+          }
+        }
+
         if (!final_target && final_new) effective_op = "INSERTION";
         else if (final_target && !final_new) effective_op = "DELETION";
         else if (final_target && final_new) effective_op = "MODIFICATION";
@@ -2441,6 +2622,41 @@ export class RedlineEngine {
     return all_sub_edits[0];
   }
 
+  /**
+   * Split a <w:ins> so that everything up to and INCLUDING split_after stays in
+   * a left <w:ins>, new_elem is placed between, and the remainder moves to a
+   * right <w:ins> — all at the grandparent level. Used when revising another
+   * author's pending insertion: the <w:del> stays nested in their <w:ins> while
+   * our replacement <w:ins> lands as a sibling, so we never nest <w:ins> in
+   * <w:ins>.
+   */
+  private _insert_and_split_ins(
+    parent_ins: Element,
+    split_after: Element,
+    new_elem: Element,
+  ) {
+    const grandparent = parent_ins.parentNode as Element | null;
+    if (!grandparent) return;
+    // cloneNode(false) copies the attributes (author/id/date) onto both halves.
+    const left = parent_ins.cloneNode(false) as Element;
+    const right = parent_ins.cloneNode(false) as Element;
+    let toRight = false;
+    for (const kid of Array.from(parent_ins.childNodes)) {
+      parent_ins.removeChild(kid);
+      if (!toRight) {
+        left.appendChild(kid);
+        if (kid === split_after) toRight = true;
+      } else {
+        right.appendChild(kid);
+      }
+    }
+    if (left.childNodes.length > 0) grandparent.insertBefore(left, parent_ins);
+    grandparent.insertBefore(new_elem, parent_ins);
+    if (right.childNodes.length > 0)
+      grandparent.insertBefore(right, parent_ins);
+    grandparent.removeChild(parent_ins);
+  }
+
   private _apply_single_edit_indexed(
     edit: any,
     orig_new: string | null,
@@ -2699,7 +2915,20 @@ export class RedlineEngine {
       const is_inline_first = result.first_node.tagName === "w:ins";
       if (is_inline_first) {
         if (anchor_run) {
-          insertAfter(result.first_node, anchor_run._element);
+          const anchor_parent = anchor_run._element.parentNode as Element | null;
+          if (anchor_parent && anchor_parent.tagName === "w:ins") {
+            // Inserting inside another author's pending <w:ins>: split it so our
+            // new <w:ins> lands as a sibling right after the anchor run, never
+            // <w:ins> nested in <w:ins> (mirrors the MODIFICATION path and the
+            // Python engine).
+            this._insert_and_split_ins(
+              anchor_parent,
+              anchor_run._element,
+              result.first_node,
+            );
+          } else {
+            insertAfter(result.first_node, anchor_run._element);
+          }
         } else if (anchor_para) {
           anchor_para._element.appendChild(result.first_node);
         }
@@ -2841,8 +3070,17 @@ export class RedlineEngine {
       if (result.first_node) {
         const is_inline_first = result.first_node.tagName === "w:ins";
         if (is_inline_first) {
-          // Inline: place the first <w:ins> immediately after last_del.
-          insertAfter(result.first_node, last_del);
+          const del_parent = last_del!.parentNode as Element | null;
+          if (del_parent && del_parent.tagName === "w:ins") {
+            // Revising another author's pending insertion: keep the <w:del>
+            // nested in their <w:ins> and splice our new <w:ins> in right after
+            // it by splitting their <w:ins>, so we never nest <w:ins> in
+            // <w:ins>.
+            this._insert_and_split_ins(del_parent, last_del!, result.first_node);
+          } else {
+            // Inline: place the first <w:ins> immediately after last_del.
+            insertAfter(result.first_node, last_del!);
+          }
           ins_elem = result.first_node;
         } else {
           // Block-mode first paragraph was already inserted after the anchor