@adeu/core 1.26.0 → 1.28.0

package/src/engine.ts

@@ -1409,6 +1409,28 @@ export class RedlineEngine {
    *
    * Does NOT attach comments; callers handle that.
    */
+  private _clone_pPr_scrubbing_headings(existing_pPr: Element): Element {
+    const pPr_clone = existing_pPr.cloneNode(true) as Element;
+    const pStyle_el = findChild(pPr_clone, "w:pStyle");
+    if (pStyle_el) {
+      const style_val = pStyle_el.getAttribute("w:val");
+      if (style_val) {
+        const is_heading =
+          style_val.startsWith("Heading") ||
+          style_val === "Title" ||
+          style_val.replace(/\s+/g, "").startsWith("Heading");
+        if (is_heading) {
+          pPr_clone.removeChild(pStyle_el);
+        }
+      }
+    }
+    const outlineLvl_el = findChild(pPr_clone, "w:outlineLvl");
+    if (outlineLvl_el) {
+      pPr_clone.removeChild(outlineLvl_el);
+    }
+    return pPr_clone;
+  }
+
   private _track_insert_multiline(
     text: string,
     anchor_run: Run | null,
@@ -1423,6 +1445,12 @@ export class RedlineEngine {
     // authoritative: strip inherited bold/italic from the anchor style
     // (QA 2026-07-19 F-02).
     suppress_emphasis: boolean = false,
+    // True when the caller will attach the insertion BEFORE the anchor
+    // (paragraph-start insertions): the anchor itself then belongs to the
+    // relocating suffix (hunt-profile counterexample, 2026-07-19 —
+    // "00." + insert "0.\n\n0 " must read "0.\n\n0 00.", never
+    // "0.00.\n\n0 "). Mirrors the Python engine.
+    insert_before: boolean = false,
   ): {
     first_node: Element | null;
     last_p: Element | null;
@@ -1459,12 +1487,21 @@ export class RedlineEngine {
     // DOM, and the insertion lands immediately after it, so its following
     // child-of-paragraph siblings are exactly the suffix.
     const suffix_nodes: Element[] = [];
-    const pos_source =
+    const relocatable = new Set(["w:r", "w:ins", "w:del"]);
+    // insert_before with a RUN anchor: the insertion precedes the anchor, so
+    // the anchor run itself is part of the suffix. (The explicit
+    // positional_anchor_el is only passed by flows that insert AFTER it.)
+    const pos_from_positional =
       positional_anchor_el && positional_anchor_el.parentNode
         ? positional_anchor_el
-        : anchor_run !== null && anchor_run._element.parentNode
-          ? anchor_run._element
-          : null;
+        : null;
+    const pos_from_anchor_run =
+      anchor_run !== null && anchor_run._element.parentNode
+        ? anchor_run._element
+        : null;
+    const pos_source = pos_from_positional ?? pos_from_anchor_run;
+    const suffix_includes_anchor =
+      insert_before && pos_from_positional === null && pos_from_anchor_run !== null;
     if (current_p !== null && pos_source !== null) {
       let pos_anchor: Element | null = pos_source;
       while (pos_anchor && pos_anchor.parentNode !== current_p) {
@@ -1475,8 +1512,9 @@ export class RedlineEngine {
         }
       }
       if (pos_anchor) {
-        const relocatable = new Set(["w:r", "w:ins", "w:del"]);
-        let nxt = pos_anchor.nextSibling;
+        let nxt: Node | null = suffix_includes_anchor
+          ? pos_anchor
+          : pos_anchor.nextSibling;
         while (nxt) {
           if (nxt.nodeType === 1 && relocatable.has((nxt as Element).tagName)) {
             suffix_nodes.push(nxt as Element);
@@ -1484,6 +1522,20 @@ export class RedlineEngine {
           nxt = nxt.nextSibling;
         }
       }
+    } else if (current_p !== null && insert_before) {
+      // No attached anchor run at all (paragraph-anchored insertion at
+      // paragraph START): everything in the host paragraph follows the
+      // insertion point, so it all relocates (mirrors the Python engine).
+      let child = current_p.firstChild;
+      while (child) {
+        if (
+          child.nodeType === 1 &&
+          relocatable.has((child as Element).tagName)
+        ) {
+          suffix_nodes.push(child as Element);
+        }
+        child = child.nextSibling;
+      }
     }
 
     // Drop the trailing empty line ONLY when there is no suffix to relocate.
@@ -1583,7 +1635,7 @@ export class RedlineEngine {
         // Inherit pPr from the anchor paragraph (preserves list numbering).
         const existing_pPr = findChild(current_p, "w:pPr");
         if (existing_pPr) {
-          new_p.appendChild(existing_pPr.cloneNode(true));
+          new_p.appendChild(this._clone_pPr_scrubbing_headings(existing_pPr));
         }
       }
 
@@ -2104,9 +2156,13 @@ export class RedlineEngine {
         }
       }
 
-      let matches = this.mapper.find_all_match_indices(
-        edit.target_text,
-        is_regex,
+      // Matches covering ONLY virtual projection text (meta bubbles,
+      // timestamps, style markers) are phantoms: they can neither be edited
+      // nor legitimately ambiguate a real match — a target of "4" was
+      // rejected as "appears 8 times" because comment-bubble timestamps
+      // matched (QA 2026-07-19 ADEU-QA-002 C).
+      let matches = this.mapper.drop_virtual_only_matches(
+        this.mapper.find_all_match_indices(edit.target_text, is_regex),
       );
       let activeText = this.mapper.full_text;
       let target_mapper = this.mapper;
@@ -2114,9 +2170,8 @@ export class RedlineEngine {
       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.drop_virtual_only_matches(
+          this.clean_mapper.find_all_match_indices(edit.target_text, is_regex),
         );
         if (matches.length > 0) {
           activeText = this.clean_mapper.full_text;
@@ -2134,9 +2189,9 @@ export class RedlineEngine {
           const realSpans = this.mapper.spans.filter(
             (s) => s.run !== null && s.end > start && s.start < start + length,
           );
-          if (realSpans.length === 0) return true; // virtual-only; keep
-          // Keep only if at least one overlapping real span is live (not
-          // part of a tracked deletion).
+          // Virtual-only matches were already dropped above; here we only
+          // skip matches buried entirely inside tracked deletions.
+          if (realSpans.length === 0) return true;
           return realSpans.some((s) => !s.del_id);
         });
         matches = liveMatches;
@@ -2149,9 +2204,11 @@ 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.drop_virtual_only_matches(
+          this.original_mapper.find_all_match_indices(
+            edit.target_text,
+            is_regex,
+          ),
         );
         if (orig_matches.length > 0) {
           is_deleted_text = true;
@@ -2505,10 +2562,15 @@ export class RedlineEngine {
     length: number,
   ): number | null {
     for (const s of mapper.spans) {
-      if (s.run === null || s.end <= start || s.start >= start + length) {
+      if (s.end <= start || s.start >= start + length) {
         continue;
       }
-      let curr: Node | null = s.run._element;
+      let curr: Node | null = null;
+      if (s.run !== null) {
+        curr = s.run._element;
+      } else if (s.paragraph !== null) {
+        curr = s.paragraph._element;
+      }
       while (curr) {
         if (curr.nodeType === 1 && (curr as Element).tagName === "w:tr") {
           return findAllDescendants(curr as Element, "w:tc").filter(
@@ -2523,6 +2585,60 @@ export class RedlineEngine {
 
   public validate_review_actions(actions: any[]): string[] {
     const errors: string[] = [];
+
+    // Document-context-free shape checks (QA 2026-07-19 v8 F-07), mirroring
+    // Python's validate_review_action_batch: blank replies render as empty
+    // Word comment bubbles; a duplicated or conflicting accept/reject on one
+    // target_id either double-counts as "applied" or contradicts itself.
+    // Distinct IDs one action resolves as a group (a modification's del+ins
+    // pair) stay legitimate, as do DIFFERENT replies to the same comment.
+    const seen_resolutions = new Map<string, [number, string]>();
+    const seen_replies = new Set<string>();
+    for (let i = 0; i < actions.length; i++) {
+      const action = actions[i];
+      const type = action.type;
+      const target_id = action.target_id ?? "";
+      if (type === "reply") {
+        if (!String(action.text ?? "").trim()) {
+          errors.push(
+            `- Action ${i + 1} Failed: reply text for ${target_id} is empty or ` +
+              `whitespace-only. Word would show a blank comment bubble — provide the ` +
+              `reply content in 'text'.`,
+          );
+          continue;
+        }
+        const reply_key = `${target_id}${String(action.text).trim()}`;
+        if (seen_replies.has(reply_key)) {
+          errors.push(
+            `- Action ${i + 1} Failed: duplicate reply — this batch already replies to ` +
+              `${target_id} with the same text. Remove the duplicate action.`,
+          );
+        }
+        seen_replies.add(reply_key);
+      } else if (type === "accept" || type === "reject") {
+        const prior = seen_resolutions.get(target_id);
+        if (prior !== undefined) {
+          const [first_idx, first_type] = prior;
+          if (first_type === type) {
+            errors.push(
+              `- Action ${i + 1} Failed: duplicate action — Action ${first_idx + 1} in this ` +
+                `batch already applies '${type}' to ${target_id}. A change can only be ` +
+                `resolved once; remove the duplicate action.`,
+            );
+          } else {
+            errors.push(
+              `- Action ${i + 1} Failed: conflicting actions — Action ${first_idx + 1} in ` +
+                `this batch applies '${first_type}' to ${target_id}, but this action applies ` +
+                `'${type}'. Decide the outcome and keep exactly one of them.`,
+            );
+          }
+        } else {
+          seen_resolutions.set(target_id, [i, type]);
+        }
+      }
+    }
+    if (errors.length > 0) return errors;
+
     for (let i = 0; i < actions.length; i++) {
       const action = actions[i];
       const type = action.type;
@@ -2659,9 +2775,15 @@ export class RedlineEngine {
     // _insert_and_split_ins).
 
     // BUG-7: Unified single-pass validation in wet-run / standard mode.
+    // The document-aware pairing check runs BEFORE any action mutates the
+    // DOM: accept + reject across one replacement's del+ins pair is a
+    // contradiction, not two independent operations (ADEU-QA-004).
     if (!dry_run_mode) {
-      const action_errors =
+      let action_errors =
         actions.length > 0 ? this.validate_review_actions(actions) : [];
+      if (actions.length > 0 && action_errors.length === 0) {
+        action_errors = this.validate_action_pairing(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];
@@ -2670,7 +2792,10 @@ export class RedlineEngine {
       }
     } else {
       if (actions.length > 0) {
-        const action_errors = this.validate_review_actions(actions);
+        let action_errors = this.validate_review_actions(actions);
+        if (action_errors.length === 0) {
+          action_errors = this.validate_action_pairing(actions);
+        }
         if (action_errors.length > 0) {
           throw new BatchValidationError(action_errors);
         }
@@ -2679,10 +2804,12 @@ export class RedlineEngine {
 
     let applied_actions = 0;
     let skipped_actions = 0;
+    let already_resolved_actions = 0;
     if (actions.length > 0) {
       const res = this.apply_review_actions(actions);
       applied_actions = res[0];
       skipped_actions = res[1];
+      already_resolved_actions = res[2];
       if (skipped_actions > 0) {
         throw new BatchValidationError(this.skipped_details);
       }
@@ -2920,6 +3047,11 @@ export class RedlineEngine {
     return {
       actions_applied: applied_actions,
       actions_skipped: skipped_actions,
+      // Actions whose target was already resolved by an earlier action of
+      // this batch (via its replacement pair): consistent no-ops, never
+      // counted as applied — every reported "applied" action causes an
+      // observable state transition (ADEU-QA-004).
+      actions_already_resolved: already_resolved_actions,
       edits_applied: applied_edits,
       edits_skipped: skipped_edits,
       // edits_applied counts change OBJECTS; this is the total number of
@@ -2975,13 +3107,17 @@ export class RedlineEngine {
         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") {
-        let matches = this.mapper.find_all_match_indices(edit.target_text);
+        let matches = this.mapper.drop_virtual_only_matches(
+          this.mapper.find_all_match_indices(edit.target_text),
+        );
         let resolved_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);
+          matches = this.clean_mapper.drop_virtual_only_matches(
+            this.clean_mapper.find_all_match_indices(edit.target_text),
+          );
           resolved_mapper = this.clean_mapper;
         }
 
@@ -3205,11 +3341,165 @@ export class RedlineEngine {
     return [applied_logical, skipped_logical];
   }
 
-  public apply_review_actions(actions: any[]): [number, number] {
+  /**
+   * True when the paragraph still carries visible content (w:t text, w:tab,
+   * w:br) that is NOT wrapped in a tracked deletion — i.e. the paragraph
+   * would render non-empty in the accepted document.
+   */
+  private _paragraph_has_visible_content(p_elem: Element): boolean {
+    for (const tag of ["w:t", "w:tab", "w:br"]) {
+      const nodes = findAllDescendants(p_elem, tag);
+      for (const node of nodes) {
+        let is_deleted = false;
+        let curr = node.parentNode as Element | null;
+        while (curr && curr !== p_elem.parentNode) {
+          if (curr.tagName === "w:del") {
+            is_deleted = true;
+            break;
+          }
+          curr = curr.parentNode as Element | null;
+        }
+        if (!is_deleted) {
+          if (tag === "w:t" && !node.textContent) continue;
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+  /**
+   * All contiguous same-author w:ins/w:del siblings that form one logical
+   * modification block with `node` (a replacement's del+ins pair). Mirrors
+   * the Python engine's _get_paired_nodes: comment range markers and
+   * rPr/pPr are transparent; a different author or any other element breaks
+   * the group.
+   */
+  private _get_paired_nodes(node: Element): Element[] {
+    const pairs: Element[] = [];
+    const author = node.getAttribute("w:author");
+    const transparent = new Set([
+      "w:commentRangeStart",
+      "w:commentRangeEnd",
+      "w:commentReference",
+      "w:rPr",
+      "w:pPr",
+    ]);
+
+    const walk = (start: Element, dir: "next" | "prev") => {
+      let cur: Node | null =
+        dir === "next" ? start.nextSibling : start.previousSibling;
+      while (cur) {
+        if (cur.nodeType !== 1) {
+          cur = dir === "next" ? cur.nextSibling : cur.previousSibling;
+          continue;
+        }
+        const el = cur as Element;
+        if (transparent.has(el.tagName)) {
+          cur = dir === "next" ? cur.nextSibling : cur.previousSibling;
+          continue;
+        }
+        if (
+          (el.tagName === "w:ins" || el.tagName === "w:del") &&
+          el.getAttribute("w:author") === author
+        ) {
+          pairs.push(el);
+          cur = dir === "next" ? cur.nextSibling : cur.previousSibling;
+          continue;
+        }
+        break;
+      }
+    };
+
+    walk(node, "next");
+    walk(node, "prev");
+    return pairs;
+  }
+
+  /**
+   * All revision ids that resolve as ONE unit with `target_id`: the ids of
+   * every contiguous same-author w:ins/w:del sibling of its elements (a
+   * replacement's del+ins pair), plus the id itself.
+   */
+  private _resolution_group_ids(target_id: string): Set<string> {
+    const nodes = [
+      ...findAllDescendants(this.doc.element, "w:ins"),
+      ...findAllDescendants(this.doc.element, "w:del"),
+    ].filter((n) => n.getAttribute("w:id") === target_id);
+    const group = new Set<string>();
+    if (nodes.length === 0) return group;
+    group.add(target_id);
+    for (const node of nodes) {
+      for (const paired of this._get_paired_nodes(node)) {
+        const pid = paired.getAttribute("w:id");
+        if (pid) group.add(pid);
+      }
+    }
+    return group;
+  }
+
+  /**
+   * Document-aware validation (QA 2026-07-19 ADEU-QA-004): a replacement's
+   * del+ins pair carries two distinct ids but resolves as one unit, so a
+   * batch that accepts one side and rejects the other is contradictory.
+   * Rejecting it up front — before any action mutates the document — keeps
+   * the batch transactional.
+   */
+  public validate_action_pairing(actions: any[]): string[] {
+    const errors: string[] = [];
+    const group_first = new Map<string, [number, string, string]>();
+    for (let pos = 0; pos < actions.length; pos++) {
+      const act = actions[pos];
+      if (act.type !== "accept" && act.type !== "reject") continue;
+      const raw_id = String(act.target_id ?? "");
+      if (raw_id.startsWith("Com:")) continue;
+      const target_id = raw_id.startsWith("Chg:") ? raw_id.slice(4) : raw_id;
+      const group = this._resolution_group_ids(target_id);
+      if (group.size === 0) continue; // unknown ids fail with their own not-found error
+      let conflict: [number, string, string] | null = null;
+      for (const gid of group) {
+        const prior = group_first.get(gid);
+        if (prior !== undefined && prior[1] !== act.type) {
+          conflict = prior;
+          break;
+        }
+      }
+      if (conflict !== null) {
+        const [first_pos, first_type, first_id] = conflict;
+        errors.push(
+          `- Action ${pos + 1} Failed: conflicting actions on one replacement — Action ` +
+            `${first_pos + 1} applies '${first_type}' to Chg:${first_id}, and Chg:${target_id} is ` +
+            `part of the same change (a replacement's contiguous del+ins pair resolves as one ` +
+            `unit, so '${first_type}' already decides both sides). Accepting one side and ` +
+            `rejecting the other is contradictory — decide the outcome and submit exactly one ` +
+            `action for the pair.`,
+        );
+        continue;
+      }
+      for (const gid of group) {
+        if (!group_first.has(gid)) {
+          group_first.set(gid, [pos, act.type, target_id]);
+        }
+      }
+    }
+    return errors;
+  }
+
+  /**
+   * Returns [applied, skipped, already_resolved]. `applied` counts actions
+   * that caused an observable state transition; an action naming an id an
+   * earlier action of this batch already resolved (via its replacement pair)
+   * is counted in `already_resolved` instead — never as applied
+   * (QA 2026-07-19 ADEU-QA-004).
+   */
+  public apply_review_actions(actions: any[]): [number, number, number] {
     let applied = 0;
     let skipped = 0;
+    let already_resolved = 0;
+    const resolved_history = new Map<string, string>(); // id -> resolving action type
 
-    for (const action of actions) {
+    for (let pos = 0; pos < actions.length; pos++) {
+      const action = actions[pos];
       const type = action.type;
       if (type === "reply") {
         const cid = action.target_id.replace("Com:", "");
@@ -3224,6 +3514,32 @@ export class RedlineEngine {
       }
 
       const target_id = action.target_id.replace("Chg:", "");
+
+      const prior_type = resolved_history.get(target_id);
+      if (prior_type !== undefined) {
+        if (prior_type === type) {
+          // Consistent follow-up on the pair: legitimate agent workflow
+          // ("accept both ids of the replacement"), but no state transition
+          // happens — report it accurately (ADEU-QA-004).
+          already_resolved++;
+          this.skipped_details.push(
+            `- Note: Action ${pos + 1} ('${type}' on ${action.target_id}) had no additional effect — ` +
+              `the change was already resolved together with its replacement pair by an earlier ` +
+              `action in this batch. Counted as already_resolved, not applied.`,
+          );
+          continue;
+        }
+        // Contradiction. validate_action_pairing rejects this shape before
+        // anything mutates; this guard covers direct callers.
+        this.skipped_details.push(
+          `- Action ${pos + 1} Failed: contradictory action — '${type}' on ${action.target_id}, but ` +
+            `the change was already resolved as '${prior_type}' together with its replacement ` +
+            `pair by an earlier action in this batch.`,
+        );
+        skipped++;
+        continue;
+      }
+
       const all_ins = findAllDescendants(this.doc.element, "w:ins").filter(
         (n) => n.getAttribute("w:id") === target_id,
       );
@@ -3263,7 +3579,25 @@ export class RedlineEngine {
         continue;
       }
 
+      // A modification is one logical unit stored as a contiguous
+      // same-author del+ins pair: resolving either side resolves BOTH —
+      // Word's atomic replacement handling, and the Python engine's
+      // long-standing behavior. Without this, accepting the deletion side
+      // left the paired insertion pending (engine divergence,
+      // QA 2026-07-19 ADEU-QA-004).
+      const group_nodes = new Set<Element>(all_nodes);
       for (const node of all_nodes) {
+        for (const paired of this._get_paired_nodes(node)) {
+          group_nodes.add(paired);
+        }
+      }
+      const resolved_now = new Set<string>();
+      for (const node of group_nodes) {
+        const rid = node.getAttribute("w:id");
+        if (rid) resolved_now.add(rid);
+      }
+
+      for (const node of group_nodes) {
         const is_ins = node.tagName === "w:ins";
         const parent_tag = node.parentNode
           ? (node.parentNode as Element).tagName
@@ -3318,9 +3652,12 @@ export class RedlineEngine {
           }
         }
       }
+      for (const rid of resolved_now) {
+        resolved_history.set(rid, type);
+      }
       applied++;
     }
-    return [applied, skipped];
+    return [applied, skipped, already_resolved];
   }
 
   private _apply_table_edit(edit: any, rebuild_map: boolean): boolean {
@@ -3402,18 +3739,16 @@ 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.drop_virtual_only_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.drop_virtual_only_matches(
+        this.clean_mapper.find_all_match_indices(edit.target_text, is_regex),
       );
       if (matches.length > 0) use_clean_map = true;
       else return null;
@@ -3427,6 +3762,8 @@ export class RedlineEngine {
         (span) =>
           span.run !== null && span.end > s && span.start < s + match_len,
       );
+      // Virtual-only matches were already dropped above; here we only skip
+      // matches buried entirely inside tracked deletions.
       if (realSpans.length === 0 || realSpans.some((span) => !span.del_id)) {
         live_matches.push([s, match_len]);
       }
@@ -4106,7 +4443,9 @@ export class RedlineEngine {
             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));
+            if (existing_pPr) {
+              new_p.appendChild(this._clone_pPr_scrubbing_headings(existing_pPr));
+            }
           }
           let pPr = findChild(new_p, "w:pPr");
           if (!pPr) {
@@ -4161,6 +4500,9 @@ export class RedlineEngine {
         ins_id!,
         null,
         suppress_emphasis,
+        // Paragraph-start insertions attach BEFORE the anchor (see
+        // before_anchor below): the suffix relocation must know.
+        start_idx === 0,
       );
 
       if (!result.first_node) return false;
@@ -4447,7 +4789,41 @@ export class RedlineEngine {
           }
 
           if (p2_element && p2_element.tagName === "w:p") {
+            // Decide the merged container's properties BEFORE p2's children
+            // move in: when p1 keeps no visible content (a FULL paragraph
+            // deletion), the only surviving text is p2's — the merged
+            // paragraph must carry p2's properties (style, numbering).
+            // Keeping p1's restyled the following paragraph: deleting a
+            // heading turned the next body paragraph into a heading,
+            // deleting a plain paragraph before a list item stripped the
+            // item's numbering (QA 2026-07-19 ADEU-QA-002 B).
+            const p1_fully_deleted =
+              !this._paragraph_has_visible_content(p1_element);
+
             let pPr = findChild(p1_element, "w:pPr");
+            if (p1_fully_deleted) {
+              const p2_pPr = findChild(p2_element, "w:pPr");
+              const adopted = (
+                p2_pPr
+                  ? p2_pPr.cloneNode(true)
+                  : p1_element.ownerDocument!.createElement("w:pPr")
+              ) as Element;
+              // Section properties belong to p1's position in the document
+              // flow, never to p2's styling — carry them over so a section
+              // boundary is not destroyed.
+              if (pPr) {
+                const sect = findChild(pPr, "w:sectPr");
+                if (sect && !findChild(adopted, "w:sectPr")) {
+                  adopted.appendChild(sect.cloneNode(true));
+                }
+                p1_element.removeChild(pPr);
+              }
+              p1_element.insertBefore(
+                adopted,
+                p1_element.firstChild as Node | null,
+              );
+              pPr = adopted;
+            }
             if (!pPr) {
               pPr = p1_element.ownerDocument!.createElement("w:pPr") as Element;
               p1_element.insertBefore(
@@ -4460,8 +4836,10 @@ export class RedlineEngine {
               rPr = p1_element.ownerDocument!.createElement("w:rPr") as Element;
               pPr!.appendChild(rPr);
             }
-            const del_mark = this._create_track_change_tag("w:del");
-            rPr!.appendChild(del_mark);
+            if (!findChild(rPr!, "w:del")) {
+              const del_mark = this._create_track_change_tag("w:del");
+              rPr!.appendChild(del_mark);
+            }
 
             const children = Array.from(p2_element.childNodes);
             for (const child of children) {
@@ -4531,27 +4909,7 @@ export class RedlineEngine {
 
     // PHASE 2: Check for orphaned paragraphs with zero visible content remaining
     for (const p_elem of affected_ps) {
-      let has_visible = false;
-      for (const tag of ["w:t", "w:tab", "w:br"]) {
-        const nodes = findAllDescendants(p_elem, tag);
-        for (const node of nodes) {
-          let is_deleted = false;
-          let curr = node.parentNode as Element | null;
-          while (curr && curr !== p_elem.parentNode) {
-            if (curr.tagName === "w:del") {
-              is_deleted = true;
-              break;
-            }
-            curr = curr.parentNode as Element | null;
-          }
-          if (!is_deleted) {
-            if (tag === "w:t" && !node.textContent) continue;
-            has_visible = true;
-            break;
-          }
-        }
-        if (has_visible) break;
-      }
+      const has_visible = this._paragraph_has_visible_content(p_elem);
 
       if (!has_visible) {
         let pPr = findChild(p_elem, "w:pPr");