@adeu/core 1.25.0 → 1.27.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 = Math.max(start_idx, first_real_span.start) - 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(" | ")) {
@@ -2826,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 };
@@ -2931,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;
@@ -3891,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",
@@ -4671,7 +4809,7 @@ var RedlineEngine = class _RedlineEngine {
    *
    * Does NOT attach comments; callers handle that.
    */
-  _track_insert_multiline(text, anchor_run, anchor_paragraph, reuse_id, positional_anchor_el = null) {
+  _track_insert_multiline(text, anchor_run, anchor_paragraph, reuse_id, positional_anchor_el = null, suppress_emphasis = false, insert_before = false) {
     if (!text) {
       return {
         first_node: null,
@@ -4693,7 +4831,11 @@ var RedlineEngine = class _RedlineEngine {
       current_p = walker;
     }
     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;
+    const relocatable = /* @__PURE__ */ new Set(["w:r", "w:ins", "w:del"]);
+    const pos_from_positional = positional_anchor_el && positional_anchor_el.parentNode ? positional_anchor_el : null;
+    const pos_from_anchor_run = anchor_run !== null && anchor_run._element.parentNode ? anchor_run._element : null;
+    const pos_source = pos_from_positional ?? pos_from_anchor_run;
+    const suffix_includes_anchor = insert_before && pos_from_positional === null && pos_from_anchor_run !== null;
     if (current_p !== null && pos_source !== null) {
       let pos_anchor = pos_source;
       while (pos_anchor && pos_anchor.parentNode !== current_p) {
@@ -4704,8 +4846,7 @@ var RedlineEngine = class _RedlineEngine {
         }
       }
       if (pos_anchor) {
-        const relocatable = /* @__PURE__ */ new Set(["w:r", "w:ins", "w:del"]);
-        let nxt = pos_anchor.nextSibling;
+        let nxt = suffix_includes_anchor ? pos_anchor : pos_anchor.nextSibling;
         while (nxt) {
           if (nxt.nodeType === 1 && relocatable.has(nxt.tagName)) {
             suffix_nodes.push(nxt);
@@ -4713,6 +4854,14 @@ var RedlineEngine = class _RedlineEngine {
           nxt = nxt.nextSibling;
         }
       }
+    } else if (current_p !== null && insert_before) {
+      let child = current_p.firstChild;
+      while (child) {
+        if (child.nodeType === 1 && relocatable.has(child.tagName)) {
+          suffix_nodes.push(child);
+        }
+        child = child.nextSibling;
+      }
     }
     while (lines.length > 1 && lines[lines.length - 1] === "" && suffix_nodes.length === 0) {
       lines.pop();
@@ -4735,7 +4884,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;
     }
@@ -4799,7 +4949,8 @@ var RedlineEngine = class _RedlineEngine {
         clean_text,
         anchor_run,
         reuse_id,
-        xmlDoc
+        xmlDoc,
+        suppress_emphasis
       );
       if (content_ins) {
         new_p.appendChild(content_ins);
@@ -4825,7 +4976,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);
@@ -4838,15 +4989,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);
           }
@@ -4881,6 +5028,27 @@ var RedlineEngine = class _RedlineEngine {
     }
     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 = /(\*\*.*?\*\*)|(_.*?_)/;
@@ -5147,6 +5315,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
@@ -5422,6 +5600,45 @@ var RedlineEngine = class _RedlineEngine {
   }
   validate_review_actions(actions) {
     const errors = [];
+    const seen_resolutions = /* @__PURE__ */ new Map();
+    const seen_replies = /* @__PURE__ */ new Set();
+    for (let i = 0; i < actions.length; i++) {
+      const action = actions[i];
+      const type = action.type;
+      const target_id = action.target_id ?? "";
+      if (type === "reply") {
+        if (!String(action.text ?? "").trim()) {
+          errors.push(
+            `- Action ${i + 1} Failed: reply text for ${target_id} is empty or whitespace-only. Word would show a blank comment bubble \u2014 provide the reply content in 'text'.`
+          );
+          continue;
+        }
+        const reply_key = `${target_id}\0${String(action.text).trim()}`;
+        if (seen_replies.has(reply_key)) {
+          errors.push(
+            `- Action ${i + 1} Failed: duplicate reply \u2014 this batch already replies to ${target_id} with the same text. Remove the duplicate action.`
+          );
+        }
+        seen_replies.add(reply_key);
+      } else if (type === "accept" || type === "reject") {
+        const prior = seen_resolutions.get(target_id);
+        if (prior !== void 0) {
+          const [first_idx, first_type] = prior;
+          if (first_type === type) {
+            errors.push(
+              `- Action ${i + 1} Failed: duplicate action \u2014 Action ${first_idx + 1} in this batch already applies '${type}' to ${target_id}. A change can only be resolved once; remove the duplicate action.`
+            );
+          } else {
+            errors.push(
+              `- Action ${i + 1} Failed: conflicting actions \u2014 Action ${first_idx + 1} in this batch applies '${first_type}' to ${target_id}, but this action applies '${type}'. Decide the outcome and keep exactly one of them.`
+            );
+          }
+        } else {
+          seen_resolutions.set(target_id, [i, type]);
+        }
+      }
+    }
+    if (errors.length > 0) return errors;
     for (let i = 0; i < actions.length; i++) {
       const action = actions[i];
       const type = action.type;
@@ -5726,6 +5943,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",
@@ -5747,6 +5972,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;
@@ -5846,17 +6072,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);
       }
@@ -5906,8 +6133,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;
@@ -5915,7 +6144,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;
@@ -6408,6 +6650,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,
@@ -6608,7 +6851,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);
@@ -6640,7 +6884,12 @@ var RedlineEngine = class _RedlineEngine {
         final_new_text,
         anchor_run,
         anchor_para,
-        ins_id
+        ins_id,
+        null,
+        suppress_emphasis,
+        // Paragraph-start insertions attach BEFORE the anchor (see
+        // before_anchor below): the suffix relocation must know.
+        start_idx === 0
       );
       if (!result.first_node) return false;
       const is_inline_first = result.first_node.tagName === "w:ins";
@@ -6791,7 +7040,8 @@ var RedlineEngine = class _RedlineEngine {
         ins_id,
         // The insertion physically follows the deletion block; the style
         // run was detached when the deletion cloned it into <w:del>.
-        last_del
+        last_del,
+        suppress_emphasis
       );
       if (result.first_node) {
         const is_inline_first = result.first_node.tagName === "w:ins";
@@ -6825,7 +7075,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);
@@ -7309,6 +7561,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");
@@ -8052,8 +8324,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;
           }
@@ -8820,7 +9094,7 @@ function _collect_footnote_ids_fast(owned_items) {
 }
 
 // src/sanitize/core.ts
-import { strFromU8 as strFromU82, unzipSync as unzipSync2 } from "fflate";
+import { strFromU8 as strFromU82, unzipSync as unzipSync3 } from "fflate";
 
 // src/sanitize/report.ts
 var SanitizeReport = class {
@@ -8975,6 +9249,7 @@ async function finalize_document(doc, options) {
   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.");
@@ -9033,7 +9308,7 @@ var VERIFIED_CORE_FIELDS = [
   ["version", "version (cp:version)"]
 ];
 function verifySanitizedPackage(outBuffer) {
-  const unzipped = unzipSync2(new Uint8Array(outBuffer));
+  const unzipped = unzipSync3(new Uint8Array(outBuffer));
   const names = Object.keys(unzipped);
   const problems = [];
   if (names.includes("docProps/custom.xml")) {
@@ -9072,6 +9347,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,