@adeu/core 1.17.1 → 1.18.0

package/src/engine.ts

@@ -65,6 +65,81 @@ function insertAtIndex(parent: Element, index: number, child: Node) {
   }
 }
 
+
+function safeCloneEdit(val: any, seen: WeakMap<any, any> = new WeakMap()): any {
+  if (val === null || typeof val !== "object") {
+    return val;
+  }
+  if (seen.has(val)) {
+    return seen.get(val);
+  }
+  if (val.nodeType !== undefined || typeof val.cloneNode === "function") {
+    return val;
+  }
+  if (Array.isArray(val)) {
+    const copy: any[] = [];
+    seen.set(val, copy);
+    for (let i = 0; i < val.length; i++) {
+      copy.push(safeCloneEdit(val[i], seen));
+    }
+    return copy;
+  }
+  const copy: any = {};
+  seen.set(val, copy);
+  for (const key of Object.keys(val)) {
+    copy[key] = safeCloneEdit(val[key], seen);
+  }
+  return copy;
+}
+
+function takeSnapshot(doc: any): any {
+  const parts = [...doc.pkg.parts];
+  const unzipped = { ...doc.pkg.unzipped };
+  const rels = new Map<any, Map<string, any>>();
+  const elements = new Map<any, Element>();
+  for (const part of parts) {
+    rels.set(part, new Map(part.rels));
+    if (part._element) {
+      elements.set(part, part._element.cloneNode(true) as Element);
+    }
+  }
+  return { parts, unzipped, rels, elements };
+}
+
+function restoreSnapshot(doc: any, snapshot: any): void {
+  doc.pkg.parts = [...snapshot.parts];
+  for (const key of Object.keys(doc.pkg.unzipped)) {
+    delete doc.pkg.unzipped[key];
+  }
+  for (const [key, val] of Object.entries(snapshot.unzipped)) {
+    doc.pkg.unzipped[key] = val;
+  }
+  for (const part of snapshot.parts) {
+    part.rels = new Map(snapshot.rels.get(part)!);
+    const originalEl = snapshot.elements.get(part);
+    if (originalEl && part._element) {
+      const xmlDoc = part._element.ownerDocument;
+      if (xmlDoc && xmlDoc.documentElement) {
+        xmlDoc.replaceChild(originalEl, xmlDoc.documentElement);
+      }
+      part._element = originalEl;
+    }
+  }
+}
+
+function stripMatchingHeadingHashes(target: string, newText: string): [string, string] {
+  if (!target || !newText) return [target, newText];
+  const targetMatch = target.match(/^(#+)\s+/);
+  const newMatch = newText.match(/^(#+)\s+/);
+  if (targetMatch && newMatch && targetMatch[1] === newMatch[1]) {
+    const hashes = targetMatch[1];
+    const targetClean = target.substring(hashes.length).trimStart();
+    const newClean = newText.substring(hashes.length).trimStart();
+    return [targetClean, newClean];
+  }
+  return [target, newText];
+}
+
 // --- Validation ---
 export class BatchValidationError extends Error {
   public errors: string[];
@@ -75,7 +150,7 @@ export class BatchValidationError extends Error {
   }
 }
 
-export function validate_edit_strings(edits: any[]): string[] {
+export function validate_edit_strings(edits: any[], index_offset: number = 0): string[] {
   const errors: string[] = [];
 
   for (let i = 0; i < edits.length; i++) {
@@ -90,7 +165,7 @@ export function validate_edit_strings(edits: any[]): string[] {
       n_text.includes("{==")
     ) {
       errors.push(
-        `- Edit ${i + 1} Failed: Do not manually write CriticMarkup tags ({++, {--, {>>, {==) in \`new_text\`. The engine handles redlining automatically. To add a comment, use the \`comment\` parameter.`,
+        `- Edit ${i + 1 + index_offset} Failed: Do not manually write CriticMarkup tags ({++, {--, {>>, {==) in \`new_text\`. The engine handles redlining automatically. To add a comment, use the \`comment\` parameter.`,
       );
     }
 
@@ -107,11 +182,11 @@ export function validate_edit_strings(edits: any[]): string[] {
           )
         ) {
           errors.push(
-            `- Edit ${i + 1} Failed: Cannot insert footnote/endnote markers via text replace. Markers like \`[^fn-N]\` are read-only projections. Use Word's References menu.`,
+            `- Edit ${i + 1 + index_offset} Failed: Cannot insert footnote/endnote markers via text replace. Markers like \`[^fn-N]\` are read-only projections. Use Word's References menu.`,
           );
         } else {
           errors.push(
-            `- Edit ${i + 1} Failed: Cannot delete footnote/endnote references via text replace. The marker corresponds to a structural XML element.`,
+            `- Edit ${i + 1 + index_offset} Failed: Cannot delete footnote/endnote references via text replace. The marker corresponds to a structural XML element.`,
           );
         }
       }
@@ -123,11 +198,11 @@ export function validate_edit_strings(edits: any[]): string[] {
       if (t_links.length !== n_links.length) {
         if (n_links.length > t_links.length) {
           errors.push(
-            `- Edit ${i + 1} Failed: Cannot insert hyperlinks via text replace. Use a dedicated structural operation.`,
+            `- Edit ${i + 1 + index_offset} Failed: Cannot insert hyperlinks via text replace. Use a dedicated structural operation.`,
           );
         } else {
           errors.push(
-            `- Edit ${i + 1} Failed: Cannot delete hyperlinks via text replace. The marker corresponds to a structural XML element.`,
+            `- Edit ${i + 1 + index_offset} Failed: Cannot delete hyperlinks via text replace. The marker corresponds to a structural XML element.`,
           );
         }
       } else if (
@@ -135,7 +210,7 @@ export function validate_edit_strings(edits: any[]): string[] {
         JSON.stringify(t_links) !== JSON.stringify(n_links)
       ) {
         errors.push(
-          `- Edit ${i + 1} Failed: Can only edit or retarget one hyperlink per text replacement. Please split into multiple edits.`,
+          `- Edit ${i + 1 + index_offset} Failed: Can only edit or retarget one hyperlink per text replacement. Please split into multiple edits.`,
         );
       }
     }
@@ -146,18 +221,18 @@ export function validate_edit_strings(edits: any[]): string[] {
       if (t_xrefs.length !== n_xrefs.length) {
         if (n_xrefs.length > t_xrefs.length) {
           errors.push(
-            `- Edit ${i + 1} Failed: Cannot insert cross-references via text replace. Markers are read-only projections.`,
+            `- Edit ${i + 1 + index_offset} Failed: Cannot insert cross-references via text replace. Markers are read-only projections.`,
           );
         } else {
           errors.push(
-            `- Edit ${i + 1} Failed: Cannot delete cross-references via text replace. The marker corresponds to a structural XML element.`,
+            `- Edit ${i + 1 + index_offset} Failed: Cannot delete cross-references via text replace. The marker corresponds to a structural XML element.`,
           );
         }
       } else {
         // Advanced XREF validation simplified for port scope
         if (JSON.stringify(t_xrefs) !== JSON.stringify(n_xrefs)) {
           errors.push(
-            `- Edit ${i + 1} Failed: Modifying or retargeting cross-reference markers is disallowed to prevent dependency corruption.`,
+            `- Edit ${i + 1 + index_offset} Failed: Modifying or retargeting cross-reference markers is disallowed to prevent dependency corruption.`,
           );
         }
       }
@@ -172,7 +247,7 @@ export function validate_edit_strings(edits: any[]): string[] {
           t_anchors.filter((x: string) => x === a).length
         ) {
           errors.push(
-            `- Edit ${i + 1} Failed: Cannot modify or insert internal anchor markers (\`{#...}\`). These represent structural XML bookmarks.`,
+            `- Edit ${i + 1 + index_offset} Failed: Cannot modify or insert internal anchor markers (\`{#...}\`). These represent structural XML bookmarks.`,
           );
           break;
         }
@@ -190,7 +265,7 @@ export function validate_edit_strings(edits: any[]): string[] {
             stripped.substring(level) === ""
           ) {
             errors.push(
-              `- Edit ${i + 1} Failed: Heading level ${level} is not supported (maximum is 6).`,
+              `- Edit ${i + 1 + index_offset} Failed: Heading level ${level} is not supported (maximum is 6).`,
             );
             break;
           }
@@ -202,10 +277,12 @@ export function validate_edit_strings(edits: any[]): string[] {
       t_text.includes("READONLY_BOUNDARY_START") ||
       n_text.includes("READONLY_BOUNDARY_START") ||
       t_text.includes("# Document Structure (Read-Only)") ||
-      n_text.includes("# Document Structure (Read-Only)")
+      n_text.includes("# Document Structure (Read-Only)") ||
+      t_text.includes("Document Structure (Read-Only)") ||
+      n_text.includes("Document Structure (Read-Only)")
     ) {
       errors.push(
-        `- Edit ${i + 1} Failed: Modification targets the read-only boundary (Structural Appendix). This section cannot be edited.`,
+        `- Edit ${i + 1 + index_offset} Failed: Modification targets the read-only boundary (Structural Appendix). This section cannot be edited.`,
       );
     }
   }
@@ -233,11 +310,7 @@ export class RedlineEngine {
     const w16du_ns =
       "http://schemas.microsoft.com/office/word/2023/wordml/word16du";
     for (const part of this.doc.pkg.parts) {
-      if (
-        part === this.doc.part ||
-        (part.contentType.includes("wordprocessingml") &&
-          part.contentType.endsWith("+xml"))
-      ) {
+      if (part === this.doc.part) {
         if (!part._element.hasAttribute("xmlns:w16du")) {
           part._element.setAttribute("xmlns:w16du", w16du_ns);
         }
@@ -256,7 +329,51 @@ export class RedlineEngine {
     }
     return null;
   }
-
+  /**
+   * Best-effort "did you mean" hint for a failed target. The common loop trap
+   * (observed in the field) is an anchored regex like `^\( x \)$` against a
+   * mid-document string: ^/$ bind to the whole full_text, so it never matches
+   * even though the literal `( x )` is present. We strip regex anchoring/escapes
+   * and probe full_text for a literal occurrence; if found, we tell the model
+   * the exact literal that WOULD match so it drops the anchors instead of
+   * escalating the regex further.
+   */
+  private _nearest_match_hint(
+    target_text: string | undefined,
+    is_regex: boolean,
+  ): string {
+    if (!target_text) return "";
+    let probe = target_text;
+    if (is_regex) {
+      // Strip leading/trailing anchors and surrounding \s* the model tends to add.
+      probe = probe.replace(/^\^/, "").replace(/\$$/, "");
+      probe = probe.replace(/^\\s\*/, "").replace(/\\s\*$/, "");
+      // Unescape the common literal escapes so "\( x \)" -> "( x )".
+      probe = probe.replace(/\\([.^$*+?()[\]{}|\\/])/g, "$1");
+    }
+    probe = probe.trim();
+    if (!probe || probe === target_text) {
+      // No anchors to strip, or nothing changed: nothing useful to suggest.
+      if (!is_regex) return "";
+    }
+    const idx = this.mapper.full_text.indexOf(probe);
+    if (idx !== -1) {
+      const ctx_start = Math.max(0, idx - 15);
+      const ctx_end = Math.min(
+        this.mapper.full_text.length,
+        idx + probe.length + 15,
+      );
+      const ctx = this.mapper.full_text
+        .substring(ctx_start, ctx_end)
+        .replace(/\n/g, " ");
+      return (
+        `\n  Did you mean the literal "${probe}"? It appears in the document` +
+        ` (…${ctx}…). If you used a regex, drop the ^/$ anchors — they match` +
+        ` the start/end of the entire document, not a line.`
+      );
+    }
+    return "";
+  }
   private _build_edit_context_previews(
     edit: any,
   ): [string | null, string | null] {
@@ -264,10 +381,23 @@ export class RedlineEngine {
     if (edit._resolved_proxy_edit) {
       edit = edit._resolved_proxy_edit;
     }
-    const start_idx = edit._resolved_start_idx;
+    let start_idx = edit._resolved_start_idx;
     if (start_idx === undefined || start_idx === null) return [null, null];
-    const target_text = edit.target_text || "";
-    const new_text = edit.new_text || "";
+    let target_text = edit.target_text || "";
+    let new_text = edit.new_text || "";
+
+    const [clean_target, target_style] = this._parse_markdown_style(target_text);
+    if (target_style && target_style.startsWith("Heading")) {
+      const prefix_len = target_text.length - clean_target.length;
+      start_idx += prefix_len;
+      target_text = clean_target;
+    }
+
+    const [clean_new, new_style] = this._parse_markdown_style(new_text);
+    if (new_style && new_style.startsWith("Heading")) {
+      new_text = clean_new;
+    }
+
     const length = target_text.length;
     const active_mapper = edit._active_mapper_ref || this.mapper;
     const full_text = active_mapper.full_text;
@@ -303,7 +433,11 @@ export class RedlineEngine {
     return maxId;
   }
 
-  private _get_heading_path_and_page(start_idx: number, text: string, page_offsets: number[]): [string, number] {
+  private _get_heading_path_and_page(
+    start_idx: number,
+    text: string,
+    page_offsets: number[],
+  ): [string, number] {
     let page = 1;
     for (let i = 0; i < page_offsets.length; i++) {
       if (start_idx >= page_offsets[i]) {
@@ -317,14 +451,17 @@ export class RedlineEngine {
     const lines = textBefore.split("\n");
     const path: string[] = [];
     let current_level = 999;
-    
+
     for (let i = lines.length - 1; i >= 0; i--) {
       const line = lines[i];
       const m = line.match(/^(#{1,6})\s+(.*)/);
       if (m) {
         const level = m[1].length;
         if (level < current_level) {
-          let cleanHeading = m[2].replace(/\*\*|__|[*_]/g, "").replace(/\{#[^}]+\}/g, "").trim();
+          let cleanHeading = m[2]
+            .replace(/\*\*|__|[*_]/g, "")
+            .replace(/\{#[^}]+\}/g, "")
+            .trim();
           if (cleanHeading.length > 80) {
             cleanHeading = cleanHeading.substring(0, 80) + "...";
           }
@@ -536,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();
@@ -1220,33 +1457,39 @@ export class RedlineEngine {
     }
   }
 
-  public validate_edits(edits: any[]): string[] {
+  public validate_edits(edits: any[], index_offset: number = 0): string[] {
     const errors: string[] = [];
     if (!this.mapper.full_text) this.mapper["_build_map"]();
 
-    errors.push(...validate_edit_strings(edits));
+    errors.push(...validate_edit_strings(edits, index_offset));
 
     for (let i = 0; i < edits.length; i++) {
       const edit = edits[i];
       if (typeof edit !== "object" || edit === null) {
         errors.push(
-          `- Edit ${i + 1} Failed: Invalid change format. Expected a JSON object, but received a primitive ${typeof edit}. Do not pass raw strings.`
+          `- Edit ${i + 1 + index_offset} Failed: Invalid change format. Expected a JSON object, but received a primitive ${typeof edit}. Do not pass raw strings.`,
         );
         continue;
       }
       if (!edit.target_text) continue;
-      
+
       const is_regex = (edit as any).regex || false;
       const match_mode = (edit as any).match_mode || "strict";
 
-      let matches = this.mapper.find_all_match_indices(edit.target_text, is_regex);
+      let matches = this.mapper.find_all_match_indices(
+        edit.target_text,
+        is_regex,
+      );
       let activeText = this.mapper.full_text;
       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);
+        matches = this.clean_mapper.find_all_match_indices(
+          edit.target_text,
+          is_regex,
+        );
         if (matches.length > 0) {
           activeText = this.clean_mapper.full_text;
           target_mapper = this.clean_mapper;
@@ -1278,7 +1521,10 @@ export class RedlineEngine {
         if (!this.original_mapper) {
           this.original_mapper = new DocumentMapper(this.doc, false, true);
         }
-        const orig_matches = this.original_mapper.find_all_match_indices(edit.target_text, is_regex);
+        const orig_matches = this.original_mapper.find_all_match_indices(
+          edit.target_text,
+          is_regex,
+        );
         if (orig_matches.length > 0) {
           is_deleted_text = true;
           for (const [start, length] of orig_matches) {
@@ -1289,7 +1535,10 @@ export class RedlineEngine {
               if (s.run !== null) {
                 let parent = s.run._element as Node | null;
                 while (parent) {
-                  if (parent.nodeType === 1 && (parent as Element).tagName === "w:del") {
+                  if (
+                    parent.nodeType === 1 &&
+                    (parent as Element).tagName === "w:del"
+                  ) {
                     const auth = (parent as Element).getAttribute("w:author");
                     if (auth) {
                       deleted_authors.add(auth);
@@ -1306,30 +1555,36 @@ export class RedlineEngine {
 
       if (matches.length === 0) {
         if (is_deleted_text) {
-          const author_phrase = deleted_authors.size > 0
-            ? `by ${Array.from(deleted_authors).sort().join(", ")}`
-            : "by an existing revision";
+          const author_phrase =
+            deleted_authors.size > 0
+              ? `by ${Array.from(deleted_authors).sort().join(", ")}`
+              : "by an existing revision";
           errors.push(
-            `- Edit ${i + 1} Failed: Target text matches text inside a tracked deletion ${author_phrase}. Reject/accept that change first or target the active replacement text instead.`,
+            `- Edit ${i + 1 + index_offset} Failed: Target text matches text inside a tracked deletion ${author_phrase}. Reject/accept that change first or target the active replacement text instead.`,
           );
         } else {
+          const hint = this._nearest_match_hint(edit.target_text, is_regex);
           errors.push(
-            `- Edit ${i + 1} Failed: Target text not found in document:\n  "${edit.target_text}"`,
+            `- Edit ${i + 1 + index_offset} Failed: Target text not found in document:\n  "${edit.target_text}"${hint}`,
           );
         }
       } else if (matches.length > 1 && match_mode === "strict") {
-        const positions: [number, number][] = matches.map(([start, length]) => [
-          start,
-          start + length,
-        ]);
-        errors.push(
-          format_ambiguity_error(
-            i + 1,
-            edit.target_text,
-            activeText,
-            positions,
-          ),
-        );
+        if (edit.target_text.includes("|")) {
+          matches = matches.slice(0, 1);
+        } else {
+          const positions: [number, number][] = matches.map(([start, length]) => [
+            start,
+            start + length,
+          ]);
+          errors.push(
+            format_ambiguity_error(
+              i + 1 + index_offset,
+              edit.target_text,
+              activeText,
+              positions,
+            ),
+          );
+        }
       }
 
       // BUG-23-4: when the effective (context-trimmed) target spans a
@@ -1346,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} 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.`,
-              );
+          // 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,
@@ -1385,21 +1665,48 @@ export class RedlineEngine {
             ).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) nestedAuthors.add(auth);
+              if (auth && auth !== this.author) {
+                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} Failed: Modification targets an active insertion from another author (${Array.from(nestedAuthors).join(", ")}). Accept that change first or scope your edit outside of it.`,
+            `- 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.`,
           );
         }
       }
@@ -1481,22 +1788,13 @@ export class RedlineEngine {
     }
 
     if (dry_run) {
-      const baselines = new Map<any, Element>();
-      for (const part of this.doc.pkg.parts) {
-        if (part._element) {
-          baselines.set(part, part._element.cloneNode(true) as Element);
-        }
-      }
+      const snapshot = takeSnapshot(this.doc);
+      const originalCurrentId = this.current_id;
       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;
-        }
+        restoreSnapshot(this.doc, snapshot);
+        this.current_id = originalCurrentId;
         this.mapper = new DocumentMapper(this.doc);
         this.comments_manager = new CommentsManager(this.doc);
         this.clean_mapper = null;
@@ -1510,23 +1808,52 @@ export class RedlineEngine {
     changes: DocumentChange[],
     dry_run_mode: boolean = false,
   ): any {
+    // Pre-process edits: strip identical leading heading hashes from target_text and new_text
+    for (const c of changes) {
+      if (c && typeof c === "object" && (c as any).type === "modify" && (c as any).target_text && (c as any).new_text) {
+        const [strippedTarget, strippedNew] = stripMatchingHeadingHashes((c as any).target_text, (c as any).new_text);
+        (c as any).target_text = strippedTarget;
+        (c as any).new_text = strippedNew;
+      }
+    }
+
     this.skipped_details = [];
-    const actions = changes.filter((c) =>
-      c !== null && typeof c === "object" && ["accept", "reject", "reply"].includes(c.type),
+
+    const actions = changes.filter(
+      (c) =>
+        c !== null &&
+        typeof c === "object" &&
+        ["accept", "reject", "reply"].includes(c.type),
     );
     const edits = changes.filter(
-      (c) => c === null || typeof c !== "object" || !["accept", "reject", "reply"].includes(c.type),
+      (c) =>
+        c === null ||
+        typeof c !== "object" ||
+        !["accept", "reject", "reply"].includes(c.type),
     );
 
-    // BUG-7: Unified single-pass validation in wet-run / standard mode
+    // 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) {
-      const all_errors: string[] = [];
-      if (actions.length > 0) {
-        all_errors.push(...this.validate_review_actions(actions));
-      }
-      if (edits.length > 0) {
-        all_errors.push(...this.validate_edits(edits));
-      }
+      const action_errors =
+        actions.length > 0 ? this.validate_review_actions(actions) : [];
+      const validate_edits_now = edits.length > 0 && action_errors.length > 0;
+      const edit_errors = validate_edits_now ? this.validate_edits(edits) : [];
+      const all_errors = [
+        ...action_errors,
+        ...edit_errors,
+      ];
       if (all_errors.length > 0) {
         throw new BatchValidationError(all_errors);
       }
@@ -1564,8 +1891,9 @@ export class RedlineEngine {
 
     if (edits.length > 0) {
       if (dry_run_mode) {
-        for (const edit of edits) {
-          const single_errors = this.validate_edits([edit]);
+        for (let i = 0; i < edits.length; i++) {
+          const edit = edits[i];
+          const single_errors = this.validate_edits([edit], i);
           const warning = this._check_punctuation_warning(
             (edit as any).target_text || "",
           );
@@ -1599,6 +1927,8 @@ export class RedlineEngine {
               occurrences_modified: (edit as any)._occurrences_modified || 0,
               match_mode: (edit as any).match_mode || "strict",
             });
+            this.mapper = new DocumentMapper(this.doc);
+            this.clean_mapper = null;
           } else {
             skipped_edits++;
             const error_msg =
@@ -1617,16 +1947,40 @@ export class RedlineEngine {
           }
         }
       } else {
-        const errors = this.validate_edits(edits);
-        if (errors.length > 0) {
-          throw new BatchValidationError(errors);
+        // Simulated dry-run sequentially for wet-run validation parity
+        const snapshot = takeSnapshot(this.doc);
+        const originalCurrentId = this.current_id;
+        try {
+          const sequential_errors: string[] = [];
+          for (let i = 0; i < edits.length; i++) {
+            const edit = edits[i];
+            const single_errors = this.validate_edits([edit], i);
+            if (single_errors.length > 0) {
+              sequential_errors.push(...single_errors);
+            } else {
+              this.apply_edits([edit], page_offsets);
+              this.mapper = new DocumentMapper(this.doc);
+              this.clean_mapper = null;
+            }
+          }
+          if (sequential_errors.length > 0) {
+            throw new BatchValidationError(sequential_errors);
+          }
+        } catch (err) {
+          restoreSnapshot(this.doc, snapshot);
+          this.current_id = originalCurrentId;
+          this.mapper = new DocumentMapper(this.doc);
+          this.comments_manager = new CommentsManager(this.doc);
+          this.clean_mapper = null;
+          throw err;
         }
-        const cloned_edits = edits.map((e) => JSON.parse(JSON.stringify(e)));
-        const res = this.apply_edits(cloned_edits, page_offsets);
-        applied_edits = cloned_edits.filter((e) => (e as any)._applied_status).length;
-        skipped_edits = cloned_edits.length - applied_edits;
 
-        for (const edit of cloned_edits) {
+        applied_edits = edits.filter(
+          (e) => (e as any)._applied_status,
+        ).length;
+        skipped_edits = edits.length - applied_edits;
+
+        for (const edit of edits) {
           const success = (edit as any)._applied_status || false;
           const error_msg = (edit as any)._error_msg || null;
           const warning = this._check_punctuation_warning(
@@ -1655,7 +2009,6 @@ export class RedlineEngine {
         }
       }
     }
-
     return {
       actions_applied: applied_actions,
       actions_skipped: skipped_actions,
@@ -1668,7 +2021,10 @@ export class RedlineEngine {
     };
   }
 
-  public apply_edits(edits: any[], page_offsets: number[] = []): [number, number] {
+  public apply_edits(
+    edits: any[],
+    page_offsets: number[] = [],
+  ): [number, number] {
     let applied = 0;
     let skipped = 0;
 
@@ -1765,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;
@@ -1797,21 +2157,45 @@ 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;
-          const [path, page] = this._get_heading_path_and_page(start, this.mapper.full_text, page_offsets);
+          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,
+            page_offsets,
+          );
           const pages: number[] = parent._pages || [];
           if (!pages.includes(page)) pages.unshift(page);
           parent._pages = pages;
           parent._heading_path = path;
         } else {
-          edit._occurrences_modified = (edit._occurrences_modified || 0) + 1;
-          const [path, page] = this._get_heading_path_and_page(start, this.mapper.full_text, page_offsets);
+          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,
+            page_offsets,
+          );
           const pages: number[] = edit._pages || [];
           if (!pages.includes(page)) pages.unshift(page);
           edit._pages = pages;
@@ -1993,13 +2377,19 @@ export class RedlineEngine {
     const is_regex = edit.regex || false;
     const match_mode = edit.match_mode || "strict";
 
-    let matches = this.mapper.find_all_match_indices(edit.target_text, is_regex);
+    let matches = this.mapper.find_all_match_indices(
+      edit.target_text,
+      is_regex,
+    );
     let use_clean_map = false;
 
     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);
+      matches = this.clean_mapper.find_all_match_indices(
+        edit.target_text,
+        is_regex,
+      );
       if (matches.length > 0) use_clean_map = true;
       else return null;
     }
@@ -2009,7 +2399,8 @@ export class RedlineEngine {
     let live_matches: [number, number][] = [];
     for (const [s, match_len] of matches) {
       const realSpans = active_mapper.spans.filter(
-        (span) => span.run !== null && span.end > s && span.start < s + match_len
+        (span) =>
+          span.run !== null && span.end > s && span.start < s + match_len,
       );
       if (realSpans.length === 0 || realSpans.some((span) => !span.del_id)) {
         live_matches.push([s, match_len]);
@@ -2031,23 +2422,72 @@ export class RedlineEngine {
       );
       let current_effective_new_text = edit.new_text || "";
 
+      // Cell anchors ({#cell:<paraId>}) are pure position markers with no real
+      // content — they let the model address an empty (or any) table cell that
+      // has no run to diff against. Treat such a target as a clean INSERTION at
+      // the anchor's paragraph: never delete the marker, never run trim_common_context
+      // (which refuses to split inside {#...} markup and yields a no-op MODIFICATION).
+      // Strip any echoed anchor from new_text so the model can send either
+      // "June 22, 2026" or "June 22, 2026{#cell:...}" and get the same result.
+      if (/^\{#cell:[^}]+\}$/.test(actual_doc_text.trim())) {
+        let ins_text = current_effective_new_text;
+        // Drop a leading/trailing copy of the same anchor token if echoed.
+        ins_text = ins_text.split(actual_doc_text.trim()).join("");
+        if (ins_text) {
+          all_sub_edits.push({
+            type: "modify",
+            target_text: "",
+            new_text: ins_text,
+            comment: edit.comment,
+            // Insert at the anchor token's start so the new run lands inside
+            // the cell paragraph that get_insertion_anchor resolves there.
+            _match_start_index: start_idx,
+            _internal_op: "INSERTION",
+            _active_mapper_ref: active_mapper,
+          });
+        } else if (edit.comment) {
+          // Anchor target with empty effective new_text but a comment: attach
+          // the comment to the cell paragraph.
+          all_sub_edits.push({
+            type: "modify",
+            target_text: "",
+            new_text: "",
+            comment: edit.comment,
+            _match_start_index: start_idx,
+            _internal_op: "COMMENT_ONLY",
+            _active_mapper_ref: active_mapper,
+          });
+        }
+        continue;
+      }
+
       if (is_regex && current_effective_new_text) {
         try {
-          current_effective_new_text = actual_doc_text.replace(new RegExp(edit.target_text), current_effective_new_text);
+          current_effective_new_text = actual_doc_text.replace(
+            new RegExp(edit.target_text),
+            current_effective_new_text,
+          );
         } catch (e) {}
       }
 
-      const [edit_target_clean, edit_target_style] = this._parse_markdown_style(edit.target_text);
-      const [edit_new_clean, edit_new_style] = this._parse_markdown_style(current_effective_new_text);
+      const [edit_target_clean, edit_target_style] = this._parse_markdown_style(
+        edit.target_text,
+      );
+      const [edit_new_clean, edit_new_style] = this._parse_markdown_style(
+        current_effective_new_text,
+      );
 
       if (edit_target_style !== edit_new_style) {
         const [actual_clean] = this._parse_markdown_style(actual_doc_text);
         const final_target = actual_clean;
         const final_new = edit_new_clean;
-        const style_op = final_target === final_new ? "STYLE_ONLY" : "STYLE_AND_TEXT";
+        const style_op =
+          final_target === final_new ? "STYLE_ONLY" : "STYLE_AND_TEXT";
         const prefix_offset = actual_doc_text.indexOf(actual_clean);
-        const effective_start_idx = start_idx + (prefix_offset !== -1 ? prefix_offset : 0);
-        const resolved_style = edit_new_style !== null ? edit_new_style : "Normal";
+        const effective_start_idx =
+          start_idx + (prefix_offset !== -1 ? prefix_offset : 0);
+        const resolved_style =
+          edit_new_style !== null ? edit_new_style : "Normal";
 
         all_sub_edits.push({
           type: "modify",
@@ -2085,7 +2525,9 @@ export class RedlineEngine {
 
       if (current_effective_new_text.startsWith(actual_doc_text)) {
         effective_op = "INSERTION";
-        final_new = current_effective_new_text.substring(actual_doc_text.length);
+        final_new = current_effective_new_text.substring(
+          actual_doc_text.length,
+        );
         effective_start_idx = start_idx + match_len;
       } else {
         const [prefix_len, suffix_len] = trim_common_context(
@@ -2099,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";
@@ -2121,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,
@@ -2172,7 +2708,10 @@ export class RedlineEngine {
             while (end_p && end_p.tagName !== "w:p")
               end_p = end_p.parentNode as Element;
             if (start_p && end_p) {
-              const ascend_to_paragraph_child = (el: Element, p: Element): Element => {
+              const ascend_to_paragraph_child = (
+                el: Element,
+                p: Element,
+              ): Element => {
                 let cur: Element = el;
                 while (cur.parentNode && cur.parentNode !== p) {
                   cur = cur.parentNode as Element;
@@ -2182,7 +2721,12 @@ export class RedlineEngine {
               const first_anchor = ascend_to_paragraph_child(first_el, start_p);
               const last_anchor = ascend_to_paragraph_child(last_el, end_p);
               if (start_p === end_p) {
-                this._attach_comment(start_p, first_anchor, last_anchor, edit.comment);
+                this._attach_comment(
+                  start_p,
+                  first_anchor,
+                  last_anchor,
+                  edit.comment,
+                );
               } else {
                 this._attach_comment_spanning(
                   start_p,
@@ -2371,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);
         }
@@ -2513,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