@adeu/core 1.27.0 → 1.29.0

package/dist/index.cjs

@@ -1226,6 +1226,18 @@ function get_paragraph_prefix(paragraph, style_cache, default_pstyle) {
     if (custom_level !== null) return "#".repeat(custom_level) + " ";
   }
   if (!style_name || style_name === "Normal") {
+    let is_inside_tc = false;
+    let curr = paragraph._element;
+    while (curr) {
+      if (curr.tagName === "w:tc") {
+        is_inside_tc = true;
+        break;
+      }
+      curr = curr.parentNode;
+    }
+    if (is_inside_tc) {
+      return "";
+    }
     const text = paragraph.text.trim();
     if (text && text.length < 100 && text === text.toUpperCase()) {
       let is_bold = false;
@@ -1297,6 +1309,50 @@ function split_boundary_whitespace(text) {
     text.substring(lead_len + core.length)
   ];
 }
+function compute_change_pair_map(states_list) {
+  const groups = [];
+  let current = [];
+  const seen_ids = /* @__PURE__ */ new Set();
+  for (const [ins_map, del_map] of states_list) {
+    const ins_entries = Object.entries(ins_map);
+    const del_entries = Object.entries(del_map);
+    if (ins_entries.length === 0 && del_entries.length === 0) {
+      if (current.length > 0) {
+        groups.push(current);
+        current = [];
+      }
+      continue;
+    }
+    const state_new = [];
+    for (const [uid, meta] of ins_entries) {
+      if (!seen_ids.has(uid)) {
+        state_new.push([uid, meta && meta.author || "Unknown"]);
+      }
+    }
+    for (const [uid, meta] of del_entries) {
+      if (!seen_ids.has(uid)) {
+        state_new.push([uid, meta && meta.author || "Unknown"]);
+      }
+    }
+    for (const [uid, author] of state_new) {
+      seen_ids.add(uid);
+      if (current.length > 0 && current[current.length - 1][1] !== author) {
+        groups.push(current);
+        current = [];
+      }
+      current.push([uid, author]);
+    }
+  }
+  if (current.length > 0) groups.push(current);
+  const pair_map = {};
+  for (const group of groups) {
+    if (group.length < 2) continue;
+    for (const [uid] of group) {
+      pair_map[uid] = group.filter(([u]) => u !== uid).map(([u]) => `Chg:${u}`).join(", ");
+    }
+  }
+  return pair_map;
+}
 function apply_formatting_to_segments(text, prefix, suffix) {
   if (!prefix && !suffix) return text;
   if (!text) return "";
@@ -1699,11 +1755,34 @@ ${header}`;
         const cell_start = current;
         current = this._map_blocks(cell, current);
         if (!this.clean_view && !this.original_view) {
-          const firstP = cell._element.getElementsByTagName("w:p")[0];
-          const paraId = firstP ? firstP.getAttribute("w14:paraId") : null;
+          let firstP = cell._element.getElementsByTagName("w:p")[0];
+          let paraId = firstP ? firstP.getAttribute("w14:paraId") : null;
+          const is_empty = current === cell_start;
+          if (!paraId && is_empty) {
+            if (!firstP) {
+              const xmlDoc = cell._element.ownerDocument;
+              firstP = xmlDoc.createElement("w:p");
+              cell._element.appendChild(firstP);
+            }
+            const allPs = Array.from(cell._element.ownerDocument.getElementsByTagName("w:p"));
+            const index = allPs.indexOf(firstP);
+            let hash = 2166136261;
+            const str = `fallback-paraId-${index}`;
+            for (let i = 0; i < str.length; i++) {
+              hash ^= str.charCodeAt(i);
+              hash += (hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24);
+            }
+            paraId = (hash >>> 0).toString(16).toUpperCase().padStart(8, "0");
+            firstP.setAttribute("w14:paraId", paraId);
+          }
           if (paraId && firstP) {
             const cellPara = new Paragraph(firstP, cell);
             this._add_virtual_text("", current, cellPara);
+            const has_content = current > cell_start;
+            if (has_content) {
+              this._add_virtual_text(" ", current, cellPara);
+              current += 1;
+            }
             const anchor = `{#cell:${paraId}}`;
             this._add_virtual_text(anchor, current, cellPara);
             current += anchor.length;
@@ -2054,6 +2133,8 @@ ${header}`;
     const change_lines = [];
     const comment_lines = [];
     const seen_sigs = /* @__PURE__ */ new Set();
+    const pair_map = compute_change_pair_map(states_list);
+    const pairSuffix = (uid) => pair_map[uid] ? ` (pairs with ${pair_map[uid]})` : "";
     for (const [ins_map, del_map, comments_set, fmt_map] of states_list) {
       for (const [uid, meta] of Object.entries(
         ins_map
@@ -2061,7 +2142,7 @@ ${header}`;
         const sig = `Chg:${uid}`;
         if (!seen_sigs.has(sig)) {
           const auth = meta.author || "Unknown";
-          change_lines.push(`[${sig} insert] ${auth}`);
+          change_lines.push(`[${sig} insert] ${auth}${pairSuffix(uid)}`);
           seen_sigs.add(sig);
         }
       }
@@ -2071,7 +2152,7 @@ ${header}`;
         const sig = `Chg:${uid}`;
         if (!seen_sigs.has(sig)) {
           const auth = meta.author || "Unknown";
-          change_lines.push(`[${sig} delete] ${auth}`);
+          change_lines.push(`[${sig} delete] ${auth}${pairSuffix(uid)}`);
           seen_sigs.add(sig);
         }
       }
@@ -2211,21 +2292,60 @@ ${header}`;
     }
     return results;
   }
+  /**
+   * True when no run-backed span overlaps [start, start+length): the range
+   * covers only virtual projection text — meta bubbles (change/comment
+   * headers, timestamps), style markers, list prefixes. Such text does not
+   * exist in the document, so it can neither satisfy a match nor count
+   * toward ambiguity (QA 2026-07-19 ADEU-QA-002 C): an edit targeting "4"
+   * used to be rejected as "appears 8 times" because a comment bubble's
+   * timestamp matched.
+   *
+   * Anchor tokens ({#Bookmark}, {#cell:paraId}) are the exception: they are
+   * deliberate virtual TARGETING surfaces (empty-cell writes, bookmark
+   * anchors) and must stay matchable.
+   */
+  range_is_virtual_only(start, length) {
+    const end = start + length;
+    const overlapping = this.spans.filter(
+      (s) => s.end > start && s.start < end
+    );
+    if (overlapping.some((s) => s.run !== null)) return false;
+    return !overlapping.some(
+      (s) => s.run === null && s.text.startsWith("{#")
+    );
+  }
+  /** Filters find_all_match_indices output down to matches that touch at
+   * least one run-backed span. See range_is_virtual_only. */
+  drop_virtual_only_matches(matches) {
+    return matches.filter(
+      ([start, length]) => !this.range_is_virtual_only(start, length)
+    );
+  }
   find_match_index(target_text, is_regex = false) {
     if (is_regex) {
       try {
         const match = userSearch(target_text, this.full_text);
-        if (match) return [match.start, match.end - match.start];
+        if (match && !this.range_is_virtual_only(match.start, match.end - match.start)) {
+          return [match.start, match.end - match.start];
+        }
       } catch (e) {
         if (e instanceof RegexTimeoutError) throw e;
       }
       return [-1, 0];
     }
-    let start_idx = this.full_text.indexOf(target_text);
-    if (start_idx !== -1) return [start_idx, target_text.length];
+    let from = 0;
+    while (true) {
+      const idx = this.full_text.indexOf(target_text, from);
+      if (idx === -1) break;
+      if (!this.range_is_virtual_only(idx, target_text.length)) {
+        return [idx, target_text.length];
+      }
+      from = idx + 1;
+    }
     const norm_full = this._replace_smart_quotes(this.full_text);
     const norm_target = this._replace_smart_quotes(target_text);
-    start_idx = norm_full.indexOf(norm_target);
+    let start_idx = norm_full.indexOf(norm_target);
     if (start_idx !== -1) return [start_idx, target_text.length];
     const stripped_target = this._strip_markdown_formatting(target_text);
     if (this.full_text.includes(stripped_target)) {
@@ -2235,9 +2355,12 @@ ${header}`;
     const plain_first = this._find_plain_projection_matches(target_text);
     if (plain_first.length > 0) return plain_first[0];
     try {
-      const pattern = new RegExp(this._make_fuzzy_regex(target_text));
-      const match = pattern.exec(this.full_text);
-      if (match) return [match.index, match[0].length];
+      const pattern = new RegExp(this._make_fuzzy_regex(target_text), "g");
+      for (const match of this.full_text.matchAll(pattern)) {
+        if (!this.range_is_virtual_only(match.index, match[0].length)) {
+          return [match.index, match[0].length];
+        }
+      }
     } catch (e) {
     }
     return [-1, 0];
@@ -2766,6 +2889,157 @@ function _sequence_opcodes(a, b) {
   flushPending();
   return ops;
 }
+function _is_table_blob(block) {
+  const lines = block.split("\n");
+  return lines.length > 0 && lines.every((line) => line.includes(" | "));
+}
+function _table_blob_row_edits(orig_blob, mod_blob) {
+  const rows_o = orig_blob.split("\n");
+  const rows_m = mod_blob.split("\n");
+  if (rows_o.length !== rows_m.length) return null;
+  const row_edits = [];
+  for (let k = 0; k < rows_o.length; k++) {
+    if (rows_o[k] === rows_m[k]) continue;
+    row_edits.push({
+      type: "modify",
+      target_text: rows_o[k],
+      new_text: rows_m[k],
+      comment: "Diff: Table row modified",
+      _is_table_edit: true
+    });
+  }
+  return row_edits;
+}
+function _split_cross_paragraph_hunks(edits) {
+  const out = [];
+  for (const e of edits) {
+    const target = e.target_text || "";
+    const newText = e.new_text || "";
+    const idx = e._match_start_index;
+    if (idx === void 0 || idx === null || !target.includes("\n\n") || target.split("\n\n").length - 1 === newText.split("\n\n").length - 1) {
+      out.push(e);
+      continue;
+    }
+    const parts = target.split("\n\n");
+    if (parts.length < 2 || !parts[0].trim() || !parts[parts.length - 1].trim()) {
+      out.push(e);
+      continue;
+    }
+    let offset = idx;
+    for (const piece of parts.slice(0, -1)) {
+      out.push({
+        type: "modify",
+        target_text: piece + "\n\n",
+        new_text: "",
+        comment: e.comment || "Diff: Text deleted",
+        _match_start_index: offset
+      });
+      offset += piece.length + 2;
+    }
+    out.push({
+      type: "modify",
+      target_text: parts[parts.length - 1],
+      new_text: newText,
+      comment: e.comment,
+      _match_start_index: offset
+    });
+  }
+  return out;
+}
+function generate_edits_via_paragraph_alignment(original_text, modified_text) {
+  const orig_stripped = original_text.trimEnd();
+  const orig_ws = original_text.slice(orig_stripped.length);
+  const mod_stripped = modified_text.trimEnd();
+  modified_text = mod_stripped + orig_ws;
+  const orig_paragraphs = original_text.split("\n\n");
+  const mod_paragraphs = modified_text.split("\n\n");
+  const orig_offsets = [];
+  let current_offset = 0;
+  for (const p of orig_paragraphs) {
+    orig_offsets.push(current_offset);
+    current_offset += p.length + 2;
+  }
+  const opcodes = _sequence_opcodes(orig_paragraphs, mod_paragraphs);
+  const edits = [];
+  for (const [tag, i1, i2, j1, j2] of opcodes) {
+    if (tag === "equal") continue;
+    const offset = i1 < orig_offsets.length ? orig_offsets[i1] : original_text.length;
+    if (tag === "delete") {
+      if (i2 < orig_paragraphs.length) {
+        let piece_offset = offset;
+        for (let k = i1; k < i2; k++) {
+          const piece = orig_paragraphs[k] + "\n\n";
+          edits.push({
+            type: "modify",
+            target_text: piece,
+            new_text: "",
+            comment: "Diff: Text deleted",
+            _match_start_index: piece_offset
+          });
+          piece_offset += piece.length;
+        }
+      } else {
+        let deleted_text = orig_paragraphs.slice(i1, i2).join("\n\n");
+        let del_offset = offset;
+        if (i1 > 0) {
+          deleted_text = "\n\n" + deleted_text;
+          del_offset -= 2;
+        }
+        edits.push({
+          type: "modify",
+          target_text: deleted_text,
+          new_text: "",
+          comment: "Diff: Text deleted",
+          _match_start_index: del_offset
+        });
+      }
+    } else if (tag === "insert") {
+      let inserted_text = mod_paragraphs.slice(j1, j2).join("\n\n");
+      if (i1 < orig_paragraphs.length) {
+        inserted_text = inserted_text + "\n\n";
+      } else {
+        inserted_text = "\n\n" + inserted_text;
+      }
+      edits.push({
+        type: "modify",
+        target_text: "",
+        new_text: inserted_text,
+        comment: "Diff: Text inserted",
+        _match_start_index: offset
+      });
+    } else if (tag === "replace") {
+      if (i2 - i1 === j2 - j1 && Array.from({ length: i2 - i1 }).some(
+        (_, k) => _is_table_blob(orig_paragraphs[i1 + k]) || _is_table_blob(mod_paragraphs[j1 + k])
+      )) {
+        for (let k = 0; k < i2 - i1; k++) {
+          const orig_p = orig_paragraphs[i1 + k];
+          const mod_p = mod_paragraphs[j1 + k];
+          if (orig_p === mod_p) continue;
+          const pair_offset = orig_offsets[i1 + k];
+          const row_edits = _is_table_blob(orig_p) && _is_table_blob(mod_p) ? _table_blob_row_edits(orig_p, mod_p) : null;
+          if (row_edits !== null) {
+            edits.push(...row_edits);
+            continue;
+          }
+          const pair_edits = generate_edits_from_text(orig_p, mod_p);
+          for (const ce of pair_edits) {
+            ce._match_start_index = (ce._match_start_index || 0) + pair_offset;
+            edits.push(ce);
+          }
+        }
+        continue;
+      }
+      const orig_chunk = orig_paragraphs.slice(i1, i2).join("\n\n");
+      const mod_chunk = mod_paragraphs.slice(j1, j2).join("\n\n");
+      const chunk_edits = generate_edits_from_text(orig_chunk, mod_chunk);
+      for (const ce of chunk_edits) {
+        ce._match_start_index = (ce._match_start_index || 0) + offset;
+        edits.push(ce);
+      }
+    }
+  }
+  return _split_cross_paragraph_hunks(edits);
+}
 var _IMAGE_MARKER_RE = /!\[[^\]]*\]\(docx-image:[^)]*\)/g;
 function _drop_image_marker_hunks(edits, warnings) {
   const _normalized = (s) => s.replace(_IMAGE_MARKER_RE, "").replace(/\s+/g, " ").trim();
@@ -2963,7 +3237,7 @@ function generate_structured_edits(text_orig, struct_orig, text_mod, struct_mod)
     );
     const flat = _drop_marker_interior_hunks(
       _drop_image_marker_hunks(
-        generate_edits_from_text(text_orig, text_mod),
+        generate_edits_via_paragraph_alignment(text_orig, text_mod),
         warnings
       ),
       text_orig,
@@ -2989,7 +3263,7 @@ function generate_structured_edits(text_orig, struct_orig, text_mod, struct_mod)
       );
     }
     if (!tables_alignable) {
-      const part_edits = generate_edits_from_text(
+      const part_edits = generate_edits_via_paragraph_alignment(
         text_orig.substring(po_start, po_end),
         text_mod.substring(pm_start, pm_end)
       );
@@ -3014,7 +3288,7 @@ function generate_structured_edits(text_orig, struct_orig, text_mod, struct_mod)
       const seg_o_end = boundaries_o[seg_idx + 1][0];
       const seg_m_start = boundaries_m[seg_idx][1];
       const seg_m_end = boundaries_m[seg_idx + 1][0];
-      const seg_edits = generate_edits_from_text(
+      const seg_edits = generate_edits_via_paragraph_alignment(
         text_orig.substring(seg_o_start, seg_o_end),
         text_mod.substring(seg_m_start, seg_m_end)
       );
@@ -4462,10 +4736,21 @@ var RedlineEngine = class _RedlineEngine {
         parts_to_process.push(part._element);
       }
     }
+    let accepted_insertions = 0;
+    let accepted_deletions = 0;
+    let accepted_formatting = 0;
+    for (const root_element of parts_to_process) {
+      accepted_insertions += findAllDescendants(root_element, "w:ins").length;
+      accepted_deletions += findAllDescendants(root_element, "w:del").length;
+      for (const tag of ["w:rPrChange", "w:pPrChange", "w:sectPrChange"]) {
+        accepted_formatting += findAllDescendants(root_element, tag).length;
+      }
+    }
+    let removed_comments = 0;
     for (const root_element of parts_to_process) {
       const insNodes = findAllDescendants(root_element, "w:ins");
       for (const ins of insNodes) {
-        this._clean_wrapping_comments(ins);
+        removed_comments += this._clean_wrapping_comments(ins);
         const parent = ins.parentNode;
         if (!parent) continue;
         if (parent.tagName === "w:trPr") {
@@ -4509,8 +4794,8 @@ var RedlineEngine = class _RedlineEngine {
             if (has_content) {
               rPr.removeChild(delMark);
             } else {
-              this._clean_wrapping_comments(p);
-              this._delete_comments_in_element(p);
+              removed_comments += this._clean_wrapping_comments(p);
+              removed_comments += this._delete_comments_in_element(p);
               if (p.parentNode) {
                 p.parentNode.removeChild(p);
               }
@@ -4520,8 +4805,8 @@ var RedlineEngine = class _RedlineEngine {
       }
       const delNodes = findAllDescendants(root_element, "w:del");
       for (const d of delNodes) {
-        this._clean_wrapping_comments(d);
-        this._delete_comments_in_element(d);
+        removed_comments += this._clean_wrapping_comments(d);
+        removed_comments += this._delete_comments_in_element(d);
         const parent = d.parentNode;
         if (parent) {
           if (parent.tagName === "w:trPr") {
@@ -4616,6 +4901,12 @@ var RedlineEngine = class _RedlineEngine {
         }
       }
     }
+    return {
+      accepted_insertions,
+      accepted_deletions,
+      accepted_formatting,
+      removed_comments
+    };
   }
   /**
    * Revert every tracked change, returning the document to the state it had
@@ -4868,6 +5159,24 @@ var RedlineEngine = class _RedlineEngine {
    *
    * Does NOT attach comments; callers handle that.
    */
+  _clone_pPr_scrubbing_headings(existing_pPr) {
+    const pPr_clone = existing_pPr.cloneNode(true);
+    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;
+  }
   _track_insert_multiline(text, anchor_run, anchor_paragraph, reuse_id, positional_anchor_el = null, suppress_emphasis = false, insert_before = false) {
     if (!text) {
       return {
@@ -4989,7 +5298,7 @@ var RedlineEngine = class _RedlineEngine {
       } else {
         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));
         }
       }
       let pPr = findChild(new_p, "w:pPr");
@@ -5254,7 +5563,10 @@ var RedlineEngine = class _RedlineEngine {
     }
     return null;
   }
+  /** Returns how many comment BODIES were actually deleted (see below: only
+   *  our own are; foreign ones keep their body and lose only the anchor). */
   _clean_wrapping_comments(element) {
+    let deleted = 0;
     let first_node = element;
     while (true) {
       const prev2 = getPreviousElement(first_node);
@@ -5322,6 +5634,7 @@ var RedlineEngine = class _RedlineEngine {
         const is_own = author !== null && author === this.author;
         if (is_own) {
           this.comments_manager.deleteComment(c_id);
+          deleted++;
         }
         if (s.parentNode) s.parentNode.removeChild(s);
         for (const e of ends_to_remove) {
@@ -5339,13 +5652,17 @@ var RedlineEngine = class _RedlineEngine {
         }
       }
     }
+    return deleted;
   }
+  /** Returns how many comment bodies were deleted. */
   _delete_comments_in_element(element) {
+    let deleted = 0;
     const refs = findAllDescendants(element, "w:commentReference");
     for (const ref of refs) {
       const c_id = ref.getAttribute("w:id");
       if (c_id) {
         this.comments_manager.deleteComment(c_id);
+        deleted++;
         for (const tag of ["w:commentRangeStart", "w:commentRangeEnd"]) {
           const nodes = findAllDescendants(this.doc.element, tag);
           for (const node of nodes) {
@@ -5356,6 +5673,7 @@ var RedlineEngine = class _RedlineEngine {
         }
       }
     }
+    return deleted;
   }
   validate_edits(edits, index_offset = 0) {
     const errors = [];
@@ -5384,18 +5702,16 @@ var RedlineEngine = class _RedlineEngine {
           continue;
         }
       }
-      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 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.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;
@@ -5418,9 +5734,11 @@ var RedlineEngine = 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;
@@ -5642,10 +5960,15 @@ var RedlineEngine = class _RedlineEngine {
   }
   static _column_count_at(mapper, start, length) {
     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 = s.run._element;
+      let curr = 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.tagName === "w:tr") {
           return findAllDescendants(curr, "w:tc").filter(
@@ -5785,7 +6108,10 @@ var RedlineEngine = class _RedlineEngine {
       (c) => c === null || typeof c !== "object" || !["accept", "reject", "reply"].includes(c.type)
     );
     if (!dry_run_mode) {
-      const action_errors = actions.length > 0 ? this.validate_review_actions(actions) : [];
+      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];
@@ -5794,7 +6120,10 @@ var RedlineEngine = 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);
         }
@@ -5802,10 +6131,12 @@ var RedlineEngine = 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);
       }
@@ -5859,6 +6190,7 @@ var RedlineEngine = class _RedlineEngine {
             );
             reports_by_input[i] = {
               status: "failed",
+              type: edit.type || "modify",
               target_text: truncate_middle(edit.target_text || "", REPORT_ECHO_CAP),
               new_text: truncate_middle(_RedlineEngine._report_new_text(edit), REPORT_ECHO_CAP),
               warning,
@@ -5874,6 +6206,7 @@ var RedlineEngine = class _RedlineEngine {
             const previews = this._build_edit_context_previews(edit);
             reports_by_input[i] = {
               status: "applied",
+              type: edit.type || "modify",
               target_text: truncate_middle(edit.target_text || "", REPORT_ECHO_CAP),
               new_text: truncate_middle(_RedlineEngine._report_new_text(edit), REPORT_ECHO_CAP),
               warning: null,
@@ -5895,6 +6228,7 @@ var RedlineEngine = class _RedlineEngine {
             );
             reports_by_input[i] = {
               status: "failed",
+              type: edit.type || "modify",
               target_text: truncate_middle(edit.target_text || "", REPORT_ECHO_CAP),
               new_text: truncate_middle(_RedlineEngine._report_new_text(edit), REPORT_ECHO_CAP),
               warning,
@@ -5913,6 +6247,7 @@ var RedlineEngine = class _RedlineEngine {
             if (report.status === "applied") {
               reports_by_input[i] = {
                 status: "failed",
+                type: report.type || "modify",
                 target_text: report.target_text,
                 new_text: report.new_text,
                 warning: null,
@@ -5983,6 +6318,7 @@ var RedlineEngine = class _RedlineEngine {
           }
           edits_reports.push({
             status: success ? "applied" : "failed",
+            type: edit.type || "modify",
             target_text: truncate_middle(edit.target_text || "", REPORT_ECHO_CAP),
             new_text: truncate_middle(_RedlineEngine._report_new_text(edit), REPORT_ECHO_CAP),
             warning,
@@ -6000,6 +6336,11 @@ var RedlineEngine = 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
@@ -6041,19 +6382,66 @@ var RedlineEngine = 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;
         }
         if (matches.length > 0) {
-          edit._resolved_start_idx = matches[0][0];
-          edit._active_mapper_ref = resolved_mapper;
-          resolved_edits.push([edit, null]);
+          const match_mode = edit.match_mode || "strict";
+          const unique_matches = [];
+          const seen_trs = /* @__PURE__ */ new Set();
+          for (const match of matches) {
+            const start_idx = match[0];
+            const [anchor_run, anchor_para] = resolved_mapper.get_insertion_anchor(start_idx, false);
+            let target_element = null;
+            if (anchor_run) target_element = anchor_run._element;
+            else if (anchor_para) target_element = anchor_para._element;
+            let tr = target_element;
+            while (tr && tr.tagName !== "w:tr") tr = tr.parentNode;
+            if (tr) {
+              if (!seen_trs.has(tr)) {
+                seen_trs.add(tr);
+                unique_matches.push(match);
+              }
+            }
+          }
+          if (unique_matches.length > 0) {
+            let matches_to_apply = unique_matches;
+            if (match_mode === "strict" || match_mode === "first") {
+              matches_to_apply = unique_matches.slice(0, 1);
+            }
+            if (match_mode === "all" || matches_to_apply.length > 1) {
+              for (const m of matches_to_apply) {
+                const sub_edit = {
+                  ...edit,
+                  _resolved_start_idx: m[0],
+                  _active_mapper_ref: resolved_mapper,
+                  _parent_edit_ref: edit
+                };
+                resolved_edits.push([sub_edit, null]);
+              }
+            } else {
+              edit._resolved_start_idx = matches_to_apply[0][0];
+              edit._active_mapper_ref = resolved_mapper;
+              resolved_edits.push([edit, null]);
+            }
+          } else {
+            skipped++;
+            edit._applied_status = false;
+            const target_snippet = (edit.target_text || "").trim().substring(0, 40);
+            const msg = `- Failed to locate row target: '${target_snippet}...'`;
+            this.skipped_details.push(msg);
+            edit._error_msg = msg;
+          }
         } else {
           skipped++;
           edit._applied_status = false;
@@ -6218,10 +6606,156 @@ var RedlineEngine = class _RedlineEngine {
     }
     return [applied_logical, skipped_logical];
   }
+  /**
+   * 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.
+   */
+  _paragraph_has_visible_content(p_elem) {
+    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;
+        while (curr && curr !== p_elem.parentNode) {
+          if (curr.tagName === "w:del") {
+            is_deleted = true;
+            break;
+          }
+          curr = curr.parentNode;
+        }
+        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.
+   */
+  _get_paired_nodes(node) {
+    const pairs = [];
+    const author = node.getAttribute("w:author");
+    const transparent = /* @__PURE__ */ new Set([
+      "w:commentRangeStart",
+      "w:commentRangeEnd",
+      "w:commentReference",
+      "w:rPr",
+      "w:pPr"
+    ]);
+    const walk = (start, dir) => {
+      let cur = dir === "next" ? start.nextSibling : start.previousSibling;
+      while (cur) {
+        if (cur.nodeType !== 1) {
+          cur = dir === "next" ? cur.nextSibling : cur.previousSibling;
+          continue;
+        }
+        const el = cur;
+        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.
+   */
+  _resolution_group_ids(target_id) {
+    const nodes = [
+      ...findAllDescendants(this.doc.element, "w:ins"),
+      ...findAllDescendants(this.doc.element, "w:del")
+    ].filter((n) => n.getAttribute("w:id") === target_id);
+    const group = /* @__PURE__ */ new Set();
+    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.
+   */
+  validate_action_pairing(actions) {
+    const errors = [];
+    const group_first = /* @__PURE__ */ new Map();
+    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;
+      let conflict = null;
+      for (const gid of group) {
+        const prior = group_first.get(gid);
+        if (prior !== void 0 && 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 \u2014 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 \u2014 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).
+   */
   apply_review_actions(actions) {
     let applied = 0;
     let skipped = 0;
-    for (const action of actions) {
+    let already_resolved = 0;
+    const resolved_history = /* @__PURE__ */ new Map();
+    const sortedActions = actions.map((action, pos) => ({ action, pos })).sort((a, b) => {
+      const aPri = a.action.type === "reply" ? 0 : 1;
+      const bPri = b.action.type === "reply" ? 0 : 1;
+      if (aPri !== bPri) {
+        return aPri - bPri;
+      }
+      return a.pos - b.pos;
+    });
+    for (const { action, pos } of sortedActions) {
       const type = action.type;
       if (type === "reply") {
         const cid = action.target_id.replace("Com:", "");
@@ -6235,6 +6769,21 @@ var RedlineEngine = class _RedlineEngine {
         continue;
       }
       const target_id = action.target_id.replace("Chg:", "");
+      const prior_type = resolved_history.get(target_id);
+      if (prior_type !== void 0) {
+        if (prior_type === type) {
+          already_resolved++;
+          this.skipped_details.push(
+            `- Note: Action ${pos + 1} ('${type}' on ${action.target_id}) had no additional effect \u2014 the change was already resolved together with its replacement pair by an earlier action in this batch. Counted as already_resolved, not applied.`
+          );
+          continue;
+        }
+        this.skipped_details.push(
+          `- Action ${pos + 1} Failed: contradictory action \u2014 '${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
       );
@@ -6259,7 +6808,18 @@ var RedlineEngine = class _RedlineEngine {
         );
         continue;
       }
+      const group_nodes = new Set(all_nodes);
       for (const node of all_nodes) {
+        for (const paired of this._get_paired_nodes(node)) {
+          group_nodes.add(paired);
+        }
+      }
+      const resolved_now = /* @__PURE__ */ new Set();
+      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.tagName : "";
         const is_trPr = parent_tag === "w:trPr";
@@ -6311,9 +6871,12 @@ var RedlineEngine = class _RedlineEngine {
           }
         }
       }
+      for (const rid of resolved_now) {
+        resolved_history.set(rid, type);
+      }
       applied++;
     }
-    return [applied, skipped];
+    return [applied, skipped, already_resolved];
   }
   _apply_table_edit(edit, rebuild_map) {
     const start_idx = edit._resolved_start_idx !== void 0 && edit._resolved_start_idx !== null ? edit._resolved_start_idx : edit._match_start_index || 0;
@@ -6373,17 +6936,15 @@ var RedlineEngine = class _RedlineEngine {
     if (!edit.target_text) return null;
     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;
@@ -6893,7 +7454,9 @@ var RedlineEngine = 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) {
@@ -7151,7 +7714,24 @@ var RedlineEngine = class _RedlineEngine {
             p2_element = getNextElement(p2_element);
           }
           if (p2_element && p2_element.tagName === "w:p") {
+            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");
+              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
+              );
+              pPr = adopted;
+            }
             if (!pPr) {
               pPr = p1_element.ownerDocument.createElement("w:pPr");
               p1_element.insertBefore(
@@ -7164,8 +7744,10 @@ var RedlineEngine = class _RedlineEngine {
               rPr = p1_element.ownerDocument.createElement("w:rPr");
               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) {
               if (child.nodeType === 1 && child.tagName === "w:pPr") {
@@ -7219,27 +7801,7 @@ var RedlineEngine = class _RedlineEngine {
       }
     }
     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;
-          while (curr && curr !== p_elem.parentNode) {
-            if (curr.tagName === "w:del") {
-              is_deleted = true;
-              break;
-            }
-            curr = curr.parentNode;
-          }
-          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");
         if (!pPr) {
@@ -7798,6 +8360,31 @@ function strip_custom_properties(doc) {
   const count = Math.max(lines.length, 1);
   return [`Custom document properties: ${count} removed (docProps/custom.xml)`].concat(lines);
 }
+function strip_document_variables(doc) {
+  const settingsPart = doc.pkg.getPartByPath("word/settings.xml");
+  if (!settingsPart) return [];
+  const names = [];
+  let removedAny = false;
+  for (const container of findDescendantsByLocalName(settingsPart._element, "docVars")) {
+    for (const child of Array.from(container.childNodes)) {
+      const el = child;
+      const tag = el.tagName || "";
+      if (tag === "docVar" || tag.endsWith(":docVar")) {
+        names.push(el.getAttribute("w:name") || el.getAttribute("name") || "(unnamed)");
+      }
+    }
+    container.parentNode?.removeChild(container);
+    removedAny = true;
+  }
+  for (const stray of findDescendantsByLocalName(settingsPart._element, "docVar")) {
+    names.push(stray.getAttribute("w:name") || stray.getAttribute("name") || "(unnamed)");
+    stray.parentNode?.removeChild(stray);
+    removedAny = true;
+  }
+  if (!removedAny) return [];
+  const shown = Array.from(new Set(names)).sort().join(", ") || "(unnamed)";
+  return [`Document variables: ${names.length} removed (${shown})`];
+}
 function strip_image_alt_text(doc) {
   let count = 0;
   for (const docPr of findDescendantsByLocalName(doc.element, "docPr")) {
@@ -8316,10 +8903,28 @@ function extract_table(table, comments_map, cleanView, cursor, paragraph_offsets
         paragraph_offsets
       );
       if (!cleanView) {
-        const firstP = cell._element.getElementsByTagName("w:p")[0];
-        const paraId = firstP ? firstP.getAttribute("w14:paraId") : null;
+        let firstP = cell._element.getElementsByTagName("w:p")[0];
+        let paraId = firstP ? firstP.getAttribute("w14:paraId") : null;
+        if (!paraId && (!cell_content || cell_content.trim() === "")) {
+          if (!firstP) {
+            const xmlDoc = cell._element.ownerDocument;
+            firstP = xmlDoc.createElement("w:p");
+            cell._element.appendChild(firstP);
+          }
+          const allPs = Array.from(cell._element.ownerDocument.getElementsByTagName("w:p"));
+          const index = allPs.indexOf(firstP);
+          let hash = 2166136261;
+          const str = `fallback-paraId-${index}`;
+          for (let i = 0; i < str.length; i++) {
+            hash ^= str.charCodeAt(i);
+            hash += (hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24);
+          }
+          paraId = (hash >>> 0).toString(16).toUpperCase().padStart(8, "0");
+          firstP.setAttribute("w14:paraId", paraId);
+        }
         if (paraId) {
-          const anchor = `{#cell:${paraId}}`;
+          const space_pad = cell_content ? " " : "";
+          const anchor = `${space_pad}{#cell:${paraId}}`;
           cell_content = cell_content + anchor;
         }
       }
@@ -8584,6 +9189,8 @@ function _build_merged_meta_block(states_list, comments_map) {
   const change_lines = [];
   const comment_lines = [];
   const seen_sigs = /* @__PURE__ */ new Set();
+  const pair_map = compute_change_pair_map(states_list);
+  const pairSuffix = (uid) => pair_map[uid] ? ` (pairs with ${pair_map[uid]})` : "";
   for (const [ins_map, del_map, comments_set, fmt_map] of states_list) {
     let render_comment2 = function(cid) {
       if (!comments_map[cid]) return;
@@ -8612,7 +9219,9 @@ function _build_merged_meta_block(states_list, comments_map) {
     )) {
       const sig = `Chg:${uid}`;
       if (!seen_sigs.has(sig)) {
-        change_lines.push(`[${sig} insert] ${meta.author || "Unknown"}`);
+        change_lines.push(
+          `[${sig} insert] ${meta.author || "Unknown"}${pairSuffix(uid)}`
+        );
         seen_sigs.add(sig);
       }
     }
@@ -8621,7 +9230,9 @@ function _build_merged_meta_block(states_list, comments_map) {
     )) {
       const sig = `Chg:${uid}`;
       if (!seen_sigs.has(sig)) {
-        change_lines.push(`[${sig} delete] ${meta.author || "Unknown"}`);
+        change_lines.push(
+          `[${sig} delete] ${meta.author || "Unknown"}${pairSuffix(uid)}`
+        );
         seen_sigs.add(sig);
       }
     }
@@ -9183,14 +9794,14 @@ var SanitizeReport = class {
       const lower = line.toLowerCase();
       if (lower.includes("tracked change") || lower.includes("insertion") || lower.includes("deletion") || lower.includes("accepted")) {
         this.change_lines.push(line);
+      } else if (lower.includes("author") || lower.includes("template") || lower.includes("company") || lower.includes("manager") || lower.includes("metadata") || lower.includes("timestamp") || lower.includes("custom xml") || lower.includes("custom propert") || lower.includes("identifier") || lower.includes("document variable") || lower.includes("language") || lower.includes("version") || lower.includes("last modified by") || lower.includes("revision count") || lower.includes("last printed") || lower.includes("description/comments")) {
+        this.metadata_lines.push(line);
       } else if (lower.includes("comment") || lower.includes("[open]") || lower.includes("[resolved]")) {
         if (lower.includes("kept") || lower.includes("visible")) {
           this.kept_comment_lines.push(line);
         } else {
           this.removed_comment_lines.push(line);
         }
-      } else if (lower.includes("author") || lower.includes("template") || lower.includes("company") || lower.includes("manager") || lower.includes("metadata") || lower.includes("timestamp") || lower.includes("custom xml") || lower.includes("custom propert") || lower.includes("identifier") || lower.includes("language") || lower.includes("version") || lower.includes("last modified by") || lower.includes("revision count") || lower.includes("last printed")) {
-        this.metadata_lines.push(line);
       } else if (lower.includes("hyperlink") || lower.includes("warning")) {
         this.warnings.push(line);
       } else {
@@ -9269,7 +9880,7 @@ async function finalize_document(doc, options) {
     report.tracked_changes_found = total;
     if (total > 0 && !options.accept_all) {
       report.status = "blocked";
-      report.blocked_reason = `Document contains ${total} unresolved tracked changes (${counts[0]} insertions, ${counts[1]} deletions, ${counts[2]} formatting). Review in Word first, or set accept_all=true.`;
+      report.blocked_reason = `Document contains ${total} unresolved tracked changes (${counts[0]} insertions, ${counts[1]} deletions, ${counts[2]} formatting). Review in Word first, set accept_all=true, or set sanitize_mode='keep-markup'.`;
       return { reportText: report.render() };
     }
     if (total > 0) {
@@ -9303,6 +9914,7 @@ async function finalize_document(doc, options) {
   report.add_transform_lines(scrub_timestamps(doc));
   report.add_transform_lines(strip_custom_xml(doc));
   report.add_transform_lines(strip_custom_properties(doc));
+  report.add_transform_lines(strip_document_variables(doc));
   report.add_transform_lines(strip_image_alt_text(doc));
   const warnings = audit_hyperlinks(doc);
   for (const w of warnings) report.warnings.push(w);
@@ -9386,6 +9998,12 @@ function verifySanitizedPackage(outBuffer) {
       }
     }
   }
+  if (names.includes("word/settings.xml")) {
+    const settings = parseXml((0, import_fflate3.strFromU8)(unzipped["word/settings.xml"]));
+    if (findDescendantsByLocalName(settings.documentElement, "docVar").length > 0) {
+      problems.push("word/settings.xml still contains document variables (w:docVar)");
+    }
+  }
   if (problems.length > 0) {
     throw new Error(
       "Sanitize integrity check failed \u2014 the saved package still contains metadata this run claims to remove:\n  - " + problems.join("\n  - ") + "\nRefusing to report a clean document."