@adeu/core 1.23.0 → 1.26.0

package/dist/index.js

@@ -1228,12 +1228,27 @@ function get_run_style_markers(run, is_heading = null) {
   }
   return [prefix, suffix];
 }
+function split_boundary_whitespace(text) {
+  const core = text.trim();
+  if (!core) return ["", "", text];
+  const lead_len = text.length - text.trimStart().length;
+  return [
+    text.substring(0, lead_len),
+    text.substring(lead_len, lead_len + core.length),
+    text.substring(lead_len + core.length)
+  ];
+}
 function apply_formatting_to_segments(text, prefix, suffix) {
   if (!prefix && !suffix) return text;
   if (!text) return "";
-  if (!text.includes("\n")) return `${prefix}${text}${suffix}`;
+  const wrap = (segment) => {
+    const [lead, core, trail] = split_boundary_whitespace(segment);
+    if (!core) return segment;
+    return `${lead}${prefix}${core}${suffix}${trail}`;
+  };
+  if (!text.includes("\n")) return wrap(text);
   const parts = text.split("\n");
-  return parts.map((p) => p ? `${prefix}${p}${suffix}` : "").join("\n");
+  return parts.map((p) => p ? wrap(p) : "").join("\n");
 }
 function get_run_text(run) {
   let text = "";
@@ -1686,7 +1701,7 @@ ${header}`;
         this._add_virtual_text(s_tok, current, paragraph);
         current += s_tok.length;
       }
-      for (const [kind, txt, r_obj, i_id, d_id, c_ids] of pending_runs) {
+      for (const [kind, txt, r_obj, r_off, i_id, d_id, c_ids] of pending_runs) {
         if (kind === "virtual") {
           this._add_virtual_text(txt, current, paragraph, active_hyperlink_id);
         } else {
@@ -1700,7 +1715,8 @@ ${header}`;
             del_id: d_id || void 0,
             hyperlink_id: active_hyperlink_id || void 0,
             comment_ids: c_ids.length > 0 ? c_ids : void 0,
-            part_index: this._current_part_index
+            part_index: this._current_part_index,
+            run_offset: r_off
           };
           this.spans.push(s);
           this._text_chunks.push(txt);
@@ -1735,20 +1751,42 @@ ${header}`;
           if (text === "" || /^\s*$/.test(text)) continue;
           leading_strip_active = false;
         }
+        let run_local = 0;
+        const append_wrapped = (segment) => {
+          const [lead, core, trail] = split_boundary_whitespace(segment);
+          if (!core) {
+            run_parts.push(["real", segment, item, run_local]);
+            run_local += segment.length;
+            return;
+          }
+          if (lead) {
+            run_parts.push(["real", lead, item, run_local]);
+            run_local += lead.length;
+          }
+          if (prefix) run_parts.push(["virtual", prefix, null, 0]);
+          run_parts.push(["real", core, item, run_local]);
+          run_local += core.length;
+          if (suffix) run_parts.push(["virtual", suffix, null, 0]);
+          if (trail) {
+            run_parts.push(["real", trail, item, run_local]);
+            run_local += trail.length;
+          }
+        };
         if (text.includes("\n") && (prefix || suffix)) {
           const parts = text.split("\n");
           for (let idx = 0; idx < parts.length; idx++) {
-            if (idx > 0) run_parts.push(["real", "\n", item]);
-            if (parts[idx]) {
-              if (prefix) run_parts.push(["virtual", prefix, null]);
-              run_parts.push(["real", parts[idx], item]);
-              if (suffix) run_parts.push(["virtual", suffix, null]);
+            if (idx > 0) {
+              run_parts.push(["real", "\n", item, run_local]);
+              run_local += 1;
             }
+            if (parts[idx]) append_wrapped(parts[idx]);
           }
+        } else if ((prefix || suffix) && text) {
+          append_wrapped(text);
         } else {
-          if (prefix) run_parts.push(["virtual", prefix, null]);
-          if (text) run_parts.push(["real", text, item]);
-          if (suffix) run_parts.push(["virtual", suffix, null]);
+          if (prefix) run_parts.push(["virtual", prefix, null, 0]);
+          if (text) run_parts.push(["real", text, item, 0]);
+          if (suffix) run_parts.push(["virtual", suffix, null, 0]);
         }
         if (this.clean_view && Object.keys(active_del).length > 0) {
         }
@@ -1772,7 +1810,7 @@ ${header}`;
               skip_leading_prefix = true;
             }
             const curr_comment_ids = Array.from(active_ids);
-            for (const [kind, txt, r_obj] of run_parts) {
+            for (const [kind, txt, r_obj, r_off] of run_parts) {
               if (skip_leading_prefix && kind === "virtual" && txt === new_style[0]) {
                 skip_leading_prefix = false;
                 continue;
@@ -1781,6 +1819,7 @@ ${header}`;
                 kind,
                 txt,
                 r_obj,
+                r_off,
                 curr_ins_id,
                 curr_del_id,
                 curr_comment_ids
@@ -1792,11 +1831,12 @@ ${header}`;
             current_wrappers = new_wrappers;
             current_style = new_style;
             const curr_comment_ids = Array.from(active_ids);
-            for (const [kind, txt, r_obj] of run_parts) {
+            for (const [kind, txt, r_obj, r_off] of run_parts) {
               pending_runs.push([
                 kind,
                 txt,
                 r_obj,
+                r_off,
                 curr_ins_id,
                 curr_del_id,
                 curr_comment_ids
@@ -2208,39 +2248,43 @@ ${header}`;
       (s) => s.end > start_idx && s.start < end_idx
     );
     if (affected_spans.length === 0) return [];
-    const working_runs = affected_spans.filter((s) => s.run !== null).map((s) => s.run);
-    if (working_runs.length === 0) return [];
-    let dom_modified = false;
-    const first_real_span = affected_spans.find((s) => s.run !== null);
-    let start_split_adjustment = 0;
-    if (first_real_span) {
-      const local_start = start_idx - first_real_span.start;
-      if (local_start > 0) {
-        const idx_in_working = 0;
-        const [, right_run] = this._split_run_at_index(
-          working_runs[idx_in_working],
-          local_start
-        );
-        working_runs[idx_in_working] = right_run;
-        dom_modified = true;
-        start_split_adjustment = local_start;
+    const real_spans = affected_spans.filter((s) => s.run !== null);
+    if (real_spans.length === 0) return [];
+    const working_runs = [];
+    for (const s of real_spans) {
+      if (!working_runs.some((r) => r === s.run)) {
+        working_runs.push(s.run);
       }
     }
-    const last_real_span = [...affected_spans].reverse().find((s) => s.run !== null);
-    if (last_real_span) {
-      const is_same_run = first_real_span === last_real_span;
-      const run_to_split = working_runs[working_runs.length - 1];
-      let overlap_end = Math.min(last_real_span.end, end_idx);
-      let local_end = overlap_end - last_real_span.start;
-      if (is_same_run && start_split_adjustment > 0) {
-        local_end -= start_split_adjustment;
-      }
-      const run_text = get_run_text(run_to_split);
-      if (local_end > 0 && local_end < run_text.length) {
-        const [left_run] = this._split_run_at_index(run_to_split, local_end);
-        working_runs[working_runs.length - 1] = left_run;
-        dom_modified = true;
-      }
+    let dom_modified = false;
+    const first_real_span = real_spans[0];
+    let start_split_adjustment = 0;
+    const local_start = start_idx - first_real_span.start + (first_real_span.run_offset || 0);
+    if (local_start > 0) {
+      const split_source = working_runs[0];
+      const [, right_run] = this._split_run_at_index(
+        split_source,
+        local_start
+      );
+      for (let w = 0; w < working_runs.length; w++) {
+        if (working_runs[w] === split_source) working_runs[w] = right_run;
+      }
+      dom_modified = true;
+      start_split_adjustment = local_start;
+    }
+    const last_real_span = real_spans[real_spans.length - 1];
+    const is_same_run = first_real_span.run === last_real_span.run;
+    const run_to_split = working_runs[working_runs.length - 1];
+    const overlap_end = Math.min(last_real_span.end, end_idx);
+    let local_end = overlap_end - last_real_span.start + (last_real_span.run_offset || 0);
+    if (is_same_run && start_split_adjustment > 0) {
+      local_end -= start_split_adjustment;
+    }
+    const run_text = get_run_text(run_to_split);
+    if (local_end > 0 && local_end < run_text.length) {
+      const [left_run] = this._split_run_at_index(run_to_split, local_end);
+      working_runs[working_runs.length - 1] = left_run;
+      dom_modified = true;
     }
     if (dom_modified && rebuild_map) {
       this._build_map();
@@ -2277,7 +2321,7 @@ ${header}`;
         }
         return [null, span.paragraph];
       } else {
-        const offset = index - span.start;
+        const offset = index - span.start + (span.run_offset || 0);
         const [left] = this._split_run_at_index(span.run, offset);
         if (rebuild_map) this._build_map();
         return [left, span.paragraph];
@@ -2348,6 +2392,7 @@ ${header}`;
 };
 
 // src/diff.ts
+import { unzipSync as unzipSync2 } from "fflate";
 import diff_match_patch from "diff-match-patch";
 function _count_standalone_underscores(s) {
   let count = 0;
@@ -2685,6 +2730,37 @@ function _drop_image_marker_hunks(edits, warnings) {
   }
   return kept;
 }
+function _drop_marker_interior_hunks(edits, text_orig, warnings) {
+  const marker_spans = [];
+  for (const m of text_orig.matchAll(_IMAGE_MARKER_RE)) {
+    marker_spans.push([m.index, m.index + m[0].length]);
+  }
+  if (marker_spans.length === 0) return edits;
+  const kept = [];
+  let warned = false;
+  for (const e of edits) {
+    const idx = e._match_start_index;
+    if (idx === void 0 || idx === null) {
+      kept.push(e);
+      continue;
+    }
+    const end = idx + (e.target_text || "").length;
+    const cuts_into_marker = marker_spans.some(
+      ([m_start, m_end]) => m_start < end && idx < m_end && !(idx <= m_start && m_end <= end)
+    );
+    if (!cuts_into_marker) {
+      kept.push(e);
+      continue;
+    }
+    if (!warned) {
+      warnings.push(
+        "An image's alternative text differs between the documents. Image markers (![alt](docx-image:N)) are read-only projections, so this difference cannot be expressed as a text edit \u2014 it was skipped; update the image or its alt text manually in Word."
+      );
+      warned = true;
+    }
+  }
+  return kept;
+}
 function _rows_are_plain(text, table) {
   for (const row of table.rows) {
     if (text.substring(row.start, row.end) !== row.cells.join(" | ")) {
@@ -2787,7 +2863,8 @@ function _row_ops_for_table(table_o, table_m, opcodes, warnings) {
             type: "modify",
             target_text: o_txt,
             new_text: m_txt,
-            comment: "Diff: Table row modified"
+            comment: "Diff: Table row modified",
+            _is_table_edit: true
           });
         }
       }
@@ -2825,8 +2902,12 @@ function generate_structured_edits(text_orig, struct_orig, text_mod, struct_mod)
     warnings.push(
       `The documents have different part layouts (${kinds_o.join(" + ") || "none"} vs ${kinds_m.join(" + ") || "none"}); comparing flattened text instead. Header/footer additions or removals cannot be expressed as text edits.`
     );
-    const flat = _drop_image_marker_hunks(
-      generate_edits_from_text(text_orig, text_mod),
+    const flat = _drop_marker_interior_hunks(
+      _drop_image_marker_hunks(
+        generate_edits_from_text(text_orig, text_mod),
+        warnings
+      ),
+      text_orig,
       warnings
     );
     return { edits: [...flat], warnings };
@@ -2889,14 +2970,18 @@ function generate_structured_edits(text_orig, struct_orig, text_mod, struct_mod)
         if (row_opcodes !== null) {
           edits.push(..._row_ops_for_table(t_o, t_m, row_opcodes, warnings));
         } else {
-          const tbl_edits = generate_edits_from_text(
-            text_orig.substring(t_o.start, t_o.end),
-            text_mod.substring(t_m.start, t_m.end)
-          );
-          for (const e of tbl_edits) {
-            e._match_start_index = (e._match_start_index || 0) + t_o.start;
+          for (let k = 0; k < t_o.rows.length; k++) {
+            const o_txt = t_o.rows[k].cells.join(" | ");
+            const m_txt = t_m.rows[k].cells.join(" | ");
+            if (o_txt === m_txt) continue;
+            edits.push({
+              type: "modify",
+              target_text: o_txt,
+              new_text: m_txt,
+              comment: "Diff: Table row modified",
+              _is_table_edit: true
+            });
           }
-          edits.push(...tbl_edits);
         }
       }
     }
@@ -2914,7 +2999,7 @@ function generate_structured_edits(text_orig, struct_orig, text_mod, struct_mod)
   };
   let ambiguous_anchor_warned = false;
   for (const e of edits) {
-    if ((e.type === "insert_row" || e.type === "delete_row") && !ambiguous_anchor_warned) {
+    if ((e.type === "insert_row" || e.type === "delete_row" || e._is_table_edit) && !ambiguous_anchor_warned) {
       if (e.target_text && countOccurrences(text_orig, e.target_text) > 1) {
         warnings.push(
           `The row anchor "${e.target_text.substring(0, 60)}" appears more than once in the document. Applying this diff from its JSON output may be rejected as ambiguous \u2014 make the anchor rows unique, or apply the row changes with explicit insert_row/delete_row edits.`
@@ -2926,12 +3011,63 @@ function generate_structured_edits(text_orig, struct_orig, text_mod, struct_mod)
   const modify_edits = edits.filter(
     (e) => e.type === "modify"
   );
-  const kept_modifies = new Set(_drop_image_marker_hunks(modify_edits, warnings));
+  const kept_modifies = new Set(
+    _drop_marker_interior_hunks(
+      _drop_image_marker_hunks(modify_edits, warnings),
+      text_orig,
+      warnings
+    )
+  );
   const final_edits = edits.filter(
     (e) => e.type !== "modify" || kept_modifies.has(e)
   );
   return { edits: final_edits, warnings };
 }
+function collect_media_difference_warnings(original_docx, modified_docx) {
+  const media_hashes = (data) => {
+    const hashes = /* @__PURE__ */ new Map();
+    try {
+      const unzipped = unzipSync2(data);
+      for (const [name, bytes] of Object.entries(unzipped)) {
+        if (!name.startsWith("word/media/")) continue;
+        let h1 = 2166136261;
+        let h2 = 3421674724;
+        for (let i = 0; i < bytes.length; i++) {
+          h1 = Math.imul(h1 ^ bytes[i], 16777619) >>> 0;
+          h2 = Math.imul(h2 ^ bytes[bytes.length - 1 - i], 16777619) >>> 0;
+        }
+        hashes.set(name, `${bytes.length}:${h1.toString(16)}:${h2.toString(16)}`);
+      }
+    } catch {
+      return /* @__PURE__ */ new Map();
+    }
+    return hashes;
+  };
+  const hashes_orig = media_hashes(original_docx);
+  const hashes_mod = media_hashes(modified_docx);
+  const changed = [];
+  const added = [];
+  const removed = [];
+  for (const [name, hash] of hashes_orig) {
+    if (!hashes_mod.has(name)) removed.push(name);
+    else if (hashes_mod.get(name) !== hash) changed.push(name);
+  }
+  for (const name of hashes_mod.keys()) {
+    if (!hashes_orig.has(name)) added.push(name);
+  }
+  changed.sort();
+  added.sort();
+  removed.sort();
+  if (changed.length + added.length + removed.length === 0) return [];
+  const parts = [];
+  if (changed.length) parts.push(`${changed.length} changed`);
+  if (added.length) parts.push(`${added.length} added`);
+  if (removed.length) parts.push(`${removed.length} removed`);
+  const names = [...changed, ...added, ...removed].slice(0, 5).join(", ");
+  return [
+    `The documents' embedded media differ (${parts.join(", ")}: ${names}). This diff compares TEXT only \u2014 an empty edit list does not mean the documents are visually identical. Image changes must be applied manually in Word.`
+  ];
+}
 function create_unified_diff(original_text, modified_text, context_lines = 3) {
   const dmp = new diff_match_patch.diff_match_patch();
   dmp.Diff_Timeout = 2;
@@ -3886,6 +4022,13 @@ var RedlineEngine = class _RedlineEngine {
       console.error("generate_edits_from_text failed, falling back to wholesale edit", e);
       raw_sub_edits = [];
     }
+    const _marker_only = (text) => {
+      const stripped = text.trim();
+      return stripped.length > 0 && /^[*_]+$/.test(stripped);
+    };
+    raw_sub_edits = raw_sub_edits.filter(
+      (e) => !((!e.target_text || _marker_only(e.target_text)) && (!e.new_text || _marker_only(e.new_text)) && (e.target_text || e.new_text))
+    );
     if (!raw_sub_edits || raw_sub_edits.length === 0) {
       const fallback_edit = {
         type: "modify",
@@ -4666,7 +4809,7 @@ var RedlineEngine = class _RedlineEngine {
    *
    * Does NOT attach comments; callers handle that.
    */
-  _track_insert_multiline(text, anchor_run, anchor_paragraph, reuse_id) {
+  _track_insert_multiline(text, anchor_run, anchor_paragraph, reuse_id, positional_anchor_el = null, suppress_emphasis = false) {
     if (!text) {
       return {
         first_node: null,
@@ -4687,7 +4830,29 @@ var RedlineEngine = class _RedlineEngine {
       }
       current_p = walker;
     }
-    while (lines.length > 1 && lines[lines.length - 1] === "") {
+    const suffix_nodes = [];
+    const pos_source = positional_anchor_el && positional_anchor_el.parentNode ? positional_anchor_el : anchor_run !== null && anchor_run._element.parentNode ? anchor_run._element : null;
+    if (current_p !== null && pos_source !== null) {
+      let pos_anchor = pos_source;
+      while (pos_anchor && pos_anchor.parentNode !== current_p) {
+        pos_anchor = pos_anchor.parentNode;
+        if (pos_anchor === current_p) {
+          pos_anchor = null;
+          break;
+        }
+      }
+      if (pos_anchor) {
+        const relocatable = /* @__PURE__ */ new Set(["w:r", "w:ins", "w:del"]);
+        let nxt = pos_anchor.nextSibling;
+        while (nxt) {
+          if (nxt.nodeType === 1 && relocatable.has(nxt.tagName)) {
+            suffix_nodes.push(nxt);
+          }
+          nxt = nxt.nextSibling;
+        }
+      }
+    }
+    while (lines.length > 1 && lines[lines.length - 1] === "" && suffix_nodes.length === 0) {
       lines.pop();
     }
     if (lines.length === 0) {
@@ -4708,7 +4873,8 @@ var RedlineEngine = class _RedlineEngine {
         first_clean === lines[0] ? lines[0] : lines[0],
         anchor_run,
         reuse_id,
-        xmlDoc
+        xmlDoc,
+        suppress_emphasis
       );
       first_node = inline_ins;
     }
@@ -4772,7 +4938,8 @@ var RedlineEngine = class _RedlineEngine {
         clean_text,
         anchor_run,
         reuse_id,
-        xmlDoc
+        xmlDoc,
+        suppress_emphasis
       );
       if (content_ins) {
         new_p.appendChild(content_ins);
@@ -4785,6 +4952,12 @@ var RedlineEngine = class _RedlineEngine {
         first_node = new_p;
       }
     }
+    if (!block_mode && last_p && suffix_nodes.length > 0) {
+      for (const node of suffix_nodes) {
+        node.parentNode?.removeChild(node);
+        last_p.appendChild(node);
+      }
+    }
     return { first_node, last_p, last_ins, used_block_mode: block_mode };
   }
   /**
@@ -4792,7 +4965,7 @@ var RedlineEngine = class _RedlineEngine {
    * <w:r> elements representing the inline markdown segments of `line_text`.
    * Returns null if line_text is empty.
    */
-  _build_tracked_ins_for_line(line_text, anchor_run, reuse_id, xmlDoc) {
+  _build_tracked_ins_for_line(line_text, anchor_run, reuse_id, xmlDoc, suppress_emphasis = false) {
     if (!line_text && line_text !== "") return null;
     const ins = this._create_track_change_tag("w:ins", "", reuse_id);
     const segments = this._parse_inline_markdown(line_text);
@@ -4805,15 +4978,11 @@ var RedlineEngine = class _RedlineEngine {
         const anchor_rPr = findChild(anchor_run._element, "w:rPr");
         if (anchor_rPr) {
           const clone = anchor_rPr.cloneNode(true);
-          for (const tag of [
-            "w:vanish",
-            "w:strike",
-            "w:dstrike",
-            "w:i",
-            "w:iCs",
-            "w:b",
-            "w:bCs"
-          ]) {
+          const strip_tags = ["w:vanish", "w:strike", "w:dstrike", "w:i", "w:iCs"];
+          if (suppress_emphasis) {
+            strip_tags.push("w:b", "w:bCs");
+          }
+          for (const tag of strip_tags) {
             const found = findChild(clone, tag);
             if (found) clone.removeChild(found);
           }
@@ -4842,12 +5011,33 @@ var RedlineEngine = class _RedlineEngine {
     if (stripped_text.startsWith("* ") || stripped_text.startsWith("- ")) {
       return [stripped_text.substring(2).trim(), "List Paragraph"];
     }
-    const match = stripped_text.match(/^\d+\.\s+/);
+    const match = stripped_text.match(/^1\.\s+/);
     if (match) {
       return [stripped_text.substring(match[0].length).trim(), "List Number"];
     }
     return [text, null];
   }
+  /**
+   * True when this edit's target or replacement text carries explicit
+   * bold/italic markers, making the markers AUTHORITATIVE for the inserted
+   * runs' formatting. Replacing `**X**` with `_X_` must yield italic-only
+   * text, and replacing `**X**` with `X` must yield plain text — inheriting
+   * the replaced span's run properties on top of (or instead of) the
+   * requested markers silently produces the wrong document while the report
+   * claims success (QA 2026-07-19 F-02). Plain-text edits (no markers on
+   * either side) keep inheriting the context style so partial replacements
+   * inside a styled span never lose formatting.
+   */
+  _edit_declares_emphasis(edit) {
+    for (const text of [edit?.target_text, edit?.new_text]) {
+      if (!text || !text.includes("**") && !text.includes("_")) continue;
+      const segments = this._parse_inline_markdown(text);
+      if (segments.some(([, props]) => props && Object.keys(props).length > 0)) {
+        return true;
+      }
+    }
+    return false;
+  }
   _parse_inline_markdown(text, baseStyle = {}) {
     if (!text) return [];
     const tokenPattern = /(\*\*.*?\*\*)|(_.*?_)/;
@@ -5114,6 +5304,16 @@ var RedlineEngine = class _RedlineEngine {
         continue;
       const is_regex = edit.regex || false;
       const match_mode = edit.match_mode || "strict";
+      if (is_regex) {
+        try {
+          new RegExp(edit.target_text);
+        } catch (regex_err) {
+          errors.push(
+            `- Edit ${i + 1 + index_offset} Failed: target_text is not a valid regular expression (${regex_err?.message ?? regex_err}). Fix the pattern, or set "regex": false to match the text literally.`
+          );
+          continue;
+        }
+      }
       let matches = this.mapper.find_all_match_indices(
         edit.target_text,
         is_regex
@@ -5693,6 +5893,14 @@ var RedlineEngine = class _RedlineEngine {
       actions_skipped: skipped_actions,
       edits_applied: applied_edits,
       edits_skipped: skipped_edits,
+      // edits_applied counts change OBJECTS; this is the total number of
+      // document occurrences they modified (match_mode="all" fan-out), so
+      // automation never has to guess which of the two a count means
+      // (QA 2026-07-19 F-21).
+      occurrences_modified: edits_reports.reduce(
+        (sum, r) => sum + (r.occurrences_modified || 0),
+        0
+      ),
       skipped_details: this.skipped_details,
       edits: edits_reports,
       engine: "node",
@@ -5714,6 +5922,7 @@ var RedlineEngine = class _RedlineEngine {
       }
       edit._applied_status = false;
       edit._error_msg = null;
+      edit._any_sub_failure = false;
     }
     for (const edit of edits) {
       if (typeof edit !== "object" || edit === null) continue;
@@ -5724,14 +5933,17 @@ var RedlineEngine = class _RedlineEngine {
         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 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);
+          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]);
         } else {
           skipped++;
@@ -5810,17 +6022,18 @@ var RedlineEngine = class _RedlineEngine {
         this.skipped_details.push(msg);
         edit._applied_status = false;
         edit._error_msg = msg;
+        edit._any_sub_failure = true;
         const parent = edit._parent_edit_ref;
         if (parent) {
           parent._applied_status = false;
           parent._error_msg = msg;
+          parent._any_sub_failure = true;
         }
         continue;
       }
       let success = false;
       if (edit.type === "modify") {
-        const rebuild = edit._split_group_id !== void 0 && edit._split_group_id !== null;
-        success = this._apply_single_edit_indexed(edit, orig_new, rebuild);
+        success = this._apply_single_edit_indexed(edit, orig_new, false);
       } else if (edit.type === "insert_row" || edit.type === "delete_row") {
         success = this._apply_table_edit(edit, false);
       }
@@ -5870,8 +6083,10 @@ var RedlineEngine = class _RedlineEngine {
         this.skipped_details.push(msg);
         edit._applied_status = false;
         edit._error_msg = msg;
+        edit._any_sub_failure = true;
         const parent = edit._parent_edit_ref;
         if (parent) {
+          parent._any_sub_failure = true;
           if (!parent._applied_status) {
             parent._applied_status = false;
             parent._error_msg = msg;
@@ -5879,7 +6094,20 @@ var RedlineEngine = class _RedlineEngine {
         }
       }
     }
-    return [applied, skipped];
+    let applied_logical = 0;
+    let skipped_logical = 0;
+    for (const input_edit of edits) {
+      if (typeof input_edit !== "object" || input_edit === null) {
+        skipped_logical++;
+        continue;
+      }
+      if (input_edit._applied_status && !input_edit._any_sub_failure) {
+        applied_logical++;
+      } else {
+        skipped_logical++;
+      }
+    }
+    return [applied_logical, skipped_logical];
   }
   apply_review_actions(actions) {
     let applied = 0;
@@ -5980,7 +6208,8 @@ var RedlineEngine = class _RedlineEngine {
   }
   _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;
-    const [anchor_run, anchor_para] = this.mapper.get_insertion_anchor(
+    const active_mapper = edit._active_mapper_ref || this.mapper;
+    const [anchor_run, anchor_para] = active_mapper.get_insertion_anchor(
       start_idx,
       rebuild_map
     );
@@ -6161,9 +6390,14 @@ var RedlineEngine = class _RedlineEngine {
       if (overlaps_virtual_pipe) {
         const actual_cells = actual_doc_text.split("|");
         const new_cells = current_effective_new_text.split("|");
-        if (actual_cells.length === new_cells.length && actual_cells.length > 1) {
+        if (actual_cells.length !== new_cells.length) {
+          throw new BatchValidationError([
+            `Target text spans ${actual_cells.length} table cells, but replacement provides ${new_cells.length}. To modify text without altering table structure (rows or columns), ensure the replacement contains the exact same number of '|' separators (e.g., replace with 'CellC | ' to empty the second cell).`
+          ]);
+        }
+        if (actual_cells.length > 1) {
           const sub_edits2 = [];
-          let search_offset = start_idx;
+          let cell_start_in_target = 0;
           let target_comment_idx = 0;
           for (let idx = 0; idx < actual_cells.length; idx++) {
             if (actual_cells[idx].trim() !== new_cells[idx].trim()) {
@@ -6176,13 +6410,7 @@ var RedlineEngine = class _RedlineEngine {
             const n_cell = new_cells[cell_idx];
             const a_clean = a_cell.trim();
             const n_clean = n_cell.trim();
-            let actual_start = search_offset;
-            if (a_clean) {
-              actual_start = this.mapper.full_text.indexOf(a_clean, search_offset);
-              if (actual_start === -1 || actual_start > search_offset + 10) {
-                actual_start = search_offset;
-              }
-            }
+            const actual_start = start_idx + cell_start_in_target + (a_clean ? a_cell.indexOf(a_clean) : 0);
             const should_attach_comment = edit.comment !== null && edit.comment !== void 0 && cell_idx === target_comment_idx;
             if (a_clean !== n_clean || should_attach_comment) {
               const cell_sub_edits = this._word_diff_sub_edits(
@@ -6199,24 +6427,12 @@ var RedlineEngine = class _RedlineEngine {
                 sub_edits2.push(se);
               }
             }
-            if (a_clean) {
-              search_offset = actual_start + a_clean.length;
-            }
-            const next_pipe = this.mapper.full_text.indexOf(" | ", search_offset);
-            if (next_pipe !== -1 && next_pipe <= search_offset + 10) {
-              search_offset = next_pipe + 3;
-            } else {
-              search_offset += a_cell.length + 1;
-            }
+            cell_start_in_target += a_cell.length + 1;
           }
           for (const sub of sub_edits2) {
             all_sub_edits.push(sub);
           }
           continue;
-        } else {
-          throw new BatchValidationError([
-            `Target text spans ${actual_cells.length} table cells, but replacement provides ${new_cells.length}. To modify text without altering table structure (rows or columns), ensure the replacement contains the exact same number of '|' separators (e.g., replace with 'CellC | ' to empty the second cell).`
-          ]);
         }
       }
       let has_markdown = false;
@@ -6310,6 +6526,19 @@ var RedlineEngine = class _RedlineEngine {
           continue;
         }
       }
+      if (!final_target && final_new) {
+        all_sub_edits.push({
+          type: "modify",
+          target_text: "",
+          new_text: final_new,
+          comment: edit.comment,
+          _resolved_start_idx: effective_start_idx,
+          _match_start_index: effective_start_idx,
+          _internal_op: "INSERTION",
+          _active_mapper_ref: active_mapper
+        });
+        continue;
+      }
       const sub_edits = this._word_diff_sub_edits(
         actual_doc_text,
         current_effective_new_text,
@@ -6371,6 +6600,7 @@ var RedlineEngine = class _RedlineEngine {
         op = "MODIFICATION";
       }
     }
+    const suppress_emphasis = this._edit_declares_emphasis(edit);
     if (op === "STYLE_ONLY" || op === "STYLE_AND_TEXT") {
       const [anchor_run, anchor_para] = active_mapper.get_insertion_anchor(
         start_idx,
@@ -6571,7 +6801,8 @@ var RedlineEngine = class _RedlineEngine {
             clean_text,
             anchor_run,
             ins_id,
-            xmlDoc
+            xmlDoc,
+            suppress_emphasis
           );
           if (content_ins) new_p.appendChild(content_ins);
           body.insertBefore(new_p, _bug233_target_para);
@@ -6603,7 +6834,9 @@ var RedlineEngine = class _RedlineEngine {
         final_new_text,
         anchor_run,
         anchor_para,
-        ins_id
+        ins_id,
+        null,
+        suppress_emphasis
       );
       if (!result.first_node) return false;
       const is_inline_first = result.first_node.tagName === "w:ins";
@@ -6751,7 +6984,11 @@ var RedlineEngine = class _RedlineEngine {
         edit.new_text,
         style_source_run,
         mod_anchor_para,
-        ins_id
+        ins_id,
+        // The insertion physically follows the deletion block; the style
+        // run was detached when the deletion cloned it into <w:del>.
+        last_del,
+        suppress_emphasis
       );
       if (result.first_node) {
         const is_inline_first = result.first_node.tagName === "w:ins";
@@ -6785,7 +7022,9 @@ var RedlineEngine = class _RedlineEngine {
             edit.new_text,
             anchor,
             first_span.paragraph,
-            ins_id
+            ins_id,
+            null,
+            suppress_emphasis
           );
           if (result.first_node) {
             p1_el.appendChild(result.first_node);
@@ -7269,6 +7508,26 @@ function normalize_change_dates(doc) {
   }
   return count ? [`Track change timestamps: ${count} normalized`] : [];
 }
+function normalize_comment_dates(doc) {
+  let count = 0;
+  const fixed = "2025-01-01T00:00:00Z";
+  for (const part of doc.pkg.parts) {
+    if (!part.contentType.includes("comments")) continue;
+    for (const el of findAllDescendants(part._element, "w:comment")) {
+      if (el.hasAttribute("w:date")) {
+        el.setAttribute("w:date", fixed);
+        count++;
+      }
+    }
+    for (const el of findAllDescendants(part._element, "w16cex:commentExtensible")) {
+      if (el.hasAttribute("w16cex:dateUtc")) {
+        el.setAttribute("w16cex:dateUtc", fixed);
+        count++;
+      }
+    }
+  }
+  return count ? [`Comment timestamps: ${count} normalized`] : [];
+}
 function scrub_doc_properties(doc) {
   const lines = [];
   const corePart = doc.pkg.getPartByPath("docProps/core.xml");
@@ -7298,7 +7557,10 @@ function scrub_doc_properties(doc) {
       ["keywords", "Keywords"],
       ["subject", "Subject"],
       ["contentStatus", "Content status"],
-      ["description", "Description/comments"]
+      ["description", "Description/comments"],
+      ["identifier", "Identifier"],
+      ["language", "Language"],
+      ["version", "Version"]
     ];
     for (const [local, label] of leakFields) {
       findDescendantsByLocalName(corePart._element, local).forEach((c) => {
@@ -7356,27 +7618,73 @@ function scrub_timestamps(doc) {
   }
   return modified ? ["Timestamps normalized to epoch"] : [];
 }
-function strip_custom_xml(doc) {
-  const customParts = doc.pkg.parts.filter((p) => p.partname.includes("/customXml"));
-  if (customParts.length === 0) return [];
-  const partnames = new Set(customParts.map((p) => p.partname));
-  doc.pkg.parts = doc.pkg.parts.filter((p) => !partnames.has(p.partname));
-  const removeRelationsTo = (relsPart) => {
+function ejectPackageMembers(doc, matcher, relTargetMatcher) {
+  const pkg = doc.pkg;
+  const normalized = (p) => p.startsWith("/") ? p.substring(1) : p;
+  for (const part of pkg.parts) {
+    if (!part.partname.endsWith(".rels")) continue;
     const toRemove = [];
-    for (const rel of findAllDescendants(relsPart._element, "Relationship")) {
-      const target = rel.getAttribute("Target");
-      if (target && target.includes("customXml")) toRemove.push(rel);
+    for (const rel of findAllDescendants(part._element, "Relationship")) {
+      const target = rel.getAttribute("Target") || "";
+      if (relTargetMatcher(target)) {
+        toRemove.push(rel);
+        const sourcePath = part.partname.replace("/_rels/", "/").replace(".rels", "");
+        const sourcePart = pkg.getPartByPath(sourcePath);
+        if (sourcePart) {
+          const relId = rel.getAttribute("Id");
+          if (relId) sourcePart.rels.delete(relId);
+        }
+      }
     }
     toRemove.forEach((r) => r.parentNode?.removeChild(r));
-  };
-  const rootRels = doc.pkg.getPartByPath("_rels/.rels");
-  if (rootRels) removeRelationsTo(rootRels);
-  const docRels = doc.pkg.getOrCreateRelsPart(doc.part.partname);
-  if (docRels) removeRelationsTo(docRels);
+  }
+  const ctPart = pkg.getPartByPath("[Content_Types].xml");
+  if (ctPart) {
+    const toRemove = [];
+    for (const override of findAllDescendants(ctPart._element, "Override")) {
+      const partName = override.getAttribute("PartName") || "";
+      if (matcher(normalized(partName))) toRemove.push(override);
+    }
+    toRemove.forEach((o) => o.parentNode?.removeChild(o));
+  }
+  pkg.parts = pkg.parts.filter((p) => !matcher(normalized(p.partname)));
+  for (const key of Object.keys(pkg.unzipped)) {
+    if (matcher(normalized(key))) delete pkg.unzipped[key];
+  }
+}
+function strip_custom_xml(doc) {
+  const isCustomXml = (path) => path.startsWith("customXml/");
+  const customParts = doc.pkg.parts.filter(
+    (p) => isCustomXml(p.partname.startsWith("/") ? p.partname.substring(1) : p.partname)
+  );
+  const leakedMembers = Object.keys(doc.pkg.unzipped).filter(isCustomXml);
+  if (customParts.length === 0 && leakedMembers.length === 0) return [];
+  ejectPackageMembers(doc, isCustomXml, (target) => target.includes("customXml"));
   for (const sdtPr of findAllDescendants(doc.element, "w:sdtPr")) {
     findChildren(sdtPr, "w:dataBinding").forEach((b) => sdtPr.removeChild(b));
   }
-  return [`Custom XML parts: ${customParts.length} removed`];
+  return [`Custom XML parts: ${Math.max(customParts.length, leakedMembers.length)} removed`];
+}
+var CUSTOM_PROPS_PATH = "docProps/custom.xml";
+function strip_custom_properties(doc) {
+  const part = doc.pkg.getPartByPath(CUSTOM_PROPS_PATH);
+  const leaked = Object.keys(doc.pkg.unzipped).includes(CUSTOM_PROPS_PATH);
+  if (!part && !leaked) return [];
+  const lines = [];
+  if (part) {
+    for (const prop of findDescendantsByLocalName(part._element, "property")) {
+      const name = prop.getAttribute("name") || "(unnamed)";
+      const value = (prop.textContent || "").trim();
+      lines.push(`  Custom property removed: ${name} = "${_truncate(value, 60)}"`);
+    }
+  }
+  ejectPackageMembers(
+    doc,
+    (path) => path === CUSTOM_PROPS_PATH,
+    (target) => target.includes("docProps/custom.xml")
+  );
+  const count = Math.max(lines.length, 1);
+  return [`Custom document properties: ${count} removed (docProps/custom.xml)`].concat(lines);
 }
 function strip_image_alt_text(doc) {
   let count = 0;
@@ -7963,8 +8271,10 @@ function build_paragraph_text(paragraph, comments_map, cleanView, style_cache, d
         const new_wrappers = cleanView ? ["", ""] : _get_wrappers(active_ins, active_del, active_comments, active_fmt);
         const new_style = [prefix, suffix];
         if (pending_text && new_wrappers[0] === current_wrappers[0] && new_wrappers[1] === current_wrappers[1]) {
-          if (new_style[0] === current_style[0] && new_style[1] === current_style[1] && current_style[0] !== "" && pending_text.endsWith(current_style[1]) && seg.startsWith(new_style[0])) {
-            pending_text = pending_text.slice(0, -current_style[1].length) + seg.slice(new_style[0].length);
+          const escaped_prefix = new_style[0].replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+          const lead_match = new_style[0] !== "" || new_style[1] !== "" ? seg.match(new RegExp("^(\\s*)" + escaped_prefix)) : null;
+          if (new_style[0] === current_style[0] && new_style[1] === current_style[1] && current_style[0] !== "" && pending_text.endsWith(current_style[1]) && lead_match !== null) {
+            pending_text = pending_text.slice(0, -current_style[1].length) + lead_match[1] + seg.slice(lead_match[0].length);
           } else {
             pending_text += seg;
           }
@@ -8730,6 +9040,9 @@ function _collect_footnote_ids_fast(owned_items) {
   return ordered;
 }
 
+// src/sanitize/core.ts
+import { strFromU8 as strFromU82, unzipSync as unzipSync3 } from "fflate";
+
 // src/sanitize/report.ts
 var SanitizeReport = class {
   filename;
@@ -8764,7 +9077,7 @@ var SanitizeReport = class {
         } 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("last modified by") || lower.includes("revision count") || lower.includes("last printed")) {
+      } 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);
@@ -8877,11 +9190,13 @@ async function finalize_document(doc, options) {
   report.add_transform_lines(scrub_doc_properties(doc));
   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_image_alt_text(doc));
   const warnings = audit_hyperlinks(doc);
   for (const w of warnings) report.warnings.push(w);
   for (const w of detect_watermarks(doc)) report.warnings.push(w);
   report.add_transform_lines(normalize_change_dates(doc));
+  report.add_transform_lines(normalize_comment_dates(doc));
   if (options.protection_mode === "read_only" || options.protection_mode === "encrypt") {
     if (options.protection_mode === "encrypt") {
       report.warnings.push("Encryption mode (AES compound wrappers) is strictly unsupported in the zero-dependency Node engine. Falling back to native Word Read-Only lock.");
@@ -8924,8 +9239,47 @@ async function finalize_document(doc, options) {
   }
   if (report.warnings.length > 0) report.status = "clean_with_warnings";
   const outBuffer = await doc.save();
+  verifySanitizedPackage(outBuffer);
   return { reportText: report.render(), outBuffer };
 }
+var VERIFIED_CORE_FIELDS = [
+  ["creator", "author (dc:creator)"],
+  ["lastModifiedBy", "last modified by (cp:lastModifiedBy)"],
+  ["identifier", "identifier (dc:identifier)"],
+  ["description", "description (dc:description)"],
+  ["keywords", "keywords (cp:keywords)"],
+  ["category", "category (cp:category)"],
+  ["subject", "subject (dc:subject)"],
+  ["contentStatus", "content status (cp:contentStatus)"],
+  ["language", "language (dc:language)"],
+  ["version", "version (cp:version)"]
+];
+function verifySanitizedPackage(outBuffer) {
+  const unzipped = unzipSync3(new Uint8Array(outBuffer));
+  const names = Object.keys(unzipped);
+  const problems = [];
+  if (names.includes("docProps/custom.xml")) {
+    problems.push("docProps/custom.xml (custom document properties) is still in the package");
+  }
+  if (names.some((n) => n.startsWith("customXml/"))) {
+    problems.push("customXml/* parts are still in the package");
+  }
+  if (names.includes("docProps/core.xml")) {
+    const core = parseXml(strFromU82(unzipped["docProps/core.xml"]));
+    for (const [local, label] of VERIFIED_CORE_FIELDS) {
+      for (const el of findDescendantsByLocalName(core.documentElement, local)) {
+        if ((el.textContent || "").trim()) {
+          problems.push(`core property ${label} still contains a value`);
+        }
+      }
+    }
+  }
+  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."
+    );
+  }
+}
 
 // src/index.ts
 function identifyEngine() {
@@ -8940,6 +9294,7 @@ export {
   USER_PATTERN_TIMEOUT_MS,
   _extractTextFromDoc,
   apply_edits_to_markdown,
+  collect_media_difference_warnings,
   create_unified_diff,
   create_word_patch_diff,
   describe_illegal_control_chars,