@adeu/core 1.19.1 → 1.21.0

package/dist/index.cjs

@@ -1264,6 +1264,7 @@ function* iter_paragraph_content(paragraph) {
 }
 
 // src/mapper.ts
+var STYLE_MARKER_TEXTS = /* @__PURE__ */ new Set(["**", "__", "*", "_"]);
 var DocumentMapper = class {
   doc;
   clean_view;
@@ -1273,6 +1274,7 @@ var DocumentMapper = class {
   spans = [];
   appendix_start_index = -1;
   _text_chunks = [];
+  _plain_projection = null;
   constructor(doc, clean_view = false, original_view = false) {
     this.doc = doc;
     this.clean_view = clean_view;
@@ -1285,6 +1287,7 @@ var DocumentMapper = class {
     this.spans = [];
     this._text_chunks = [];
     this.full_text = "";
+    this._plain_projection = null;
     for (const part of iter_document_parts(this.doc)) {
       current_offset = this._map_blocks(part, current_offset);
       if (this.spans.length > 0 && this.spans[this.spans.length - 1].text !== "\n\n") {
@@ -1804,6 +1807,64 @@ ${header}`;
     if (remaining) parts.push(escapeRegExp(remaining));
     return parts.join("");
   }
+  /**
+   * Returns [plain_text, offset_map] where plain_text is full_text with the
+   * VIRTUAL markdown style delimiters (bold/italic markers emitted around
+   * formatted runs) removed, and offset_map[i] is the full_text index of
+   * plain_text[i].
+   *
+   * Formatting run boundaries can fall mid-word (e.g. a paragraph projected
+   * as "**Al**pha"), where neither exact matching nor the whitespace-anchored
+   * fuzzy regex can find the plain target "Alpha". Matching against this
+   * projection and mapping the span back to full_text closes that gap (QA H2).
+   *
+   * Built lazily and invalidated by _build_map(): most batches never need it.
+   */
+  _get_plain_projection() {
+    if (this._plain_projection === null) {
+      const chunks = [];
+      const offsets = [];
+      for (const s of this.spans) {
+        if (s.run === null && s.paragraph !== null && STYLE_MARKER_TEXTS.has(s.text)) {
+          continue;
+        }
+        chunks.push(s.text);
+        for (let k = s.start; k < s.end; k++) offsets.push(k);
+      }
+      this._plain_projection = [chunks.join(""), offsets];
+    }
+    return this._plain_projection;
+  }
+  /**
+   * Matches a markdown-stripped target against the plain projection and maps
+   * each hit back to a [start, length] span in full_text. Interior style
+   * markers end up inside the returned span (so "Alpha" over "**Al**pha"
+   * resolves to the "Al**pha" range); markers just outside the matched
+   * characters are excluded.
+   */
+  _find_plain_projection_matches(target_text) {
+    const [plain_text, offsets] = this._get_plain_projection();
+    if (plain_text.length === this.full_text.length) {
+      return [];
+    }
+    const norm_target = this._replace_smart_quotes(
+      this._strip_markdown_formatting(target_text)
+    );
+    if (!norm_target) return [];
+    const norm_plain = this._replace_smart_quotes(plain_text);
+    const results = [];
+    let from = 0;
+    while (true) {
+      const p_start = norm_plain.indexOf(norm_target, from);
+      if (p_start === -1) break;
+      const p_end = p_start + norm_target.length;
+      const raw_start = offsets[p_start];
+      const raw_end = offsets[p_end - 1] + 1;
+      results.push([raw_start, raw_end - raw_start]);
+      from = p_end;
+    }
+    return results;
+  }
   find_match_index(target_text, is_regex = false) {
     if (is_regex) {
       try {
@@ -1825,6 +1886,8 @@ ${header}`;
       start_idx = this.full_text.indexOf(stripped_target);
       return [start_idx, stripped_target.length];
     }
+    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);
@@ -1845,29 +1908,33 @@ ${header}`;
       }
       return [];
     }
-    const escapeRegExp = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    let matches = [
-      ...this.full_text.matchAll(new RegExp(escapeRegExp(target_text), "g"))
-    ];
-    if (matches.length > 0) return matches.map((m) => [m.index, m[0].length]);
+    const findAllLiteral = (haystack, needle) => {
+      const out = [];
+      if (!needle) return out;
+      let from = 0;
+      while (true) {
+        const idx = haystack.indexOf(needle, from);
+        if (idx === -1) break;
+        out.push([idx, needle.length]);
+        from = idx + needle.length;
+      }
+      return out;
+    };
+    let matches = findAllLiteral(this.full_text, target_text);
+    if (matches.length > 0) return matches;
     const norm_full = this._replace_smart_quotes(this.full_text);
     const norm_target = this._replace_smart_quotes(target_text);
-    matches = [
-      ...norm_full.matchAll(new RegExp(escapeRegExp(norm_target), "g"))
-    ];
-    if (matches.length > 0) return matches.map((m) => [m.index, m[0].length]);
+    matches = findAllLiteral(norm_full, norm_target);
+    if (matches.length > 0) return matches;
     const stripped_target = this._strip_markdown_formatting(target_text);
-    matches = [
-      ...this.full_text.matchAll(
-        new RegExp(escapeRegExp(stripped_target), "g")
-      )
-    ];
-    if (matches.length > 0) return matches.map((m) => [m.index, m[0].length]);
+    matches = findAllLiteral(this.full_text, stripped_target);
+    if (matches.length > 0) return matches;
+    const plain_matches = this._find_plain_projection_matches(target_text);
+    if (plain_matches.length > 0) return plain_matches;
     try {
       const pattern = new RegExp(this._make_fuzzy_regex(target_text), "g");
-      matches = [...this.full_text.matchAll(pattern)];
-      if (matches.length > 0)
-        return matches.map((m) => [m.index, m[0].length]);
+      const fuzzy = [...this.full_text.matchAll(pattern)];
+      if (fuzzy.length > 0) return fuzzy.map((m) => [m.index, m[0].length]);
     } catch (e) {
     }
     return [];
@@ -1941,7 +2008,16 @@ ${header}`;
         if (preceding[i].run) return [preceding[i].run, preceding[i].paragraph];
       }
       for (let i = preceding.length - 1; i >= 0; i--) {
-        if (preceding[i].paragraph) return [null, preceding[i].paragraph];
+        const para = preceding[i].paragraph;
+        if (para) {
+          for (let j = this.spans.length - 1; j >= 0; j--) {
+            const prev = this.spans[j];
+            if (prev.end <= index && prev.run !== null && prev.paragraph === para) {
+              return [prev.run, prev.paragraph];
+            }
+          }
+          return [null, para];
+        }
       }
     }
     const containing = this.spans.filter(
@@ -2848,18 +2924,30 @@ function format_ambiguity_error(edit_index, target_text, haystack, match_positio
   }
   lines.push("  To resolve, re-send this edit using ONE of these strategies:");
   lines.push(
-    `    1. Set "match_mode": "all" to modify ALL ${total} occurrences (same target_text).`
+    '    1. RECOMMENDED: Provide more surrounding context in your target_text to uniquely identify a single location (keep the default "match_mode": "strict").'
   );
   lines.push(
-    '    2. Set "match_mode": "first" to modify only the FIRST occurrence (same target_text).'
+    `    2. Set "match_mode": "all" to modify ALL ${total} occurrences \u2014 only after verifying from the occurrence list above that EVERY occurrence should change.`
   );
   lines.push(
-    '    3. Please provide more surrounding context in your target_text to uniquely identify a single location (keep the default "match_mode": "strict").'
+    '    3. Set "match_mode": "first" to modify only the FIRST occurrence \u2014 only after verifying the first occurrence above is the one you intend to change.'
   );
   return lines.join("\n");
 }
 
+// src/utils/text.ts
+var REPORT_ECHO_CAP = 500;
+var PREVIEW_TEXT_CAP = 200;
+function truncate_middle(text, cap) {
+  if (text === null || text === void 0 || text.length <= cap) return text;
+  const head = Math.max(1, Math.floor(cap * 2 / 3));
+  const tail = Math.max(1, cap - head);
+  const omitted = text.length - head - tail;
+  return `${text.slice(0, head)}\u2026 [${omitted.toLocaleString("en-US")} chars omitted] \u2026${text.slice(-tail)}`;
+}
+
 // src/engine.ts
+var PREVIEW_CONTEXT_CHARS = 30;
 function getNextElement(el) {
   let next = el.nextSibling;
   while (next) {
@@ -2934,6 +3022,11 @@ var BatchValidationError = class extends Error {
     this.errors = errors;
   }
 };
+function sequential_context_hint(applied_so_far) {
+  return `
+  Note: ${applied_so_far} earlier edit(s) in this batch were already applied. Batches apply sequentially \u2014 each edit must target the document text as it reads AFTER the preceding edits (e.g. target the replacement text an earlier edit introduced, not the original wording).`;
+}
+var TRANSACTIONAL_NOT_APPLIED_ERROR = "Not applied: the batch is transactional and other edits failed validation (see their errors). Fix or remove those edits and re-run.";
 function validate_edit_strings(edits, index_offset = 0) {
   const errors = [];
   for (let i = 0; i < edits.length; i++) {
@@ -3037,7 +3130,7 @@ function validate_edit_strings(edits, index_offset = 0) {
   }
   return errors;
 }
-var RedlineEngine = class {
+var RedlineEngine = class _RedlineEngine {
   doc;
   author;
   timestamp;
@@ -3184,8 +3277,184 @@ var RedlineEngine = class {
     }
     return "";
   }
+  // CriticMarkup wrapper pairs used when tidying preview context windows.
+  static _PREVIEW_WRAPPER_PAIRS = [
+    ["{--", "--}"],
+    ["{++", "++}"],
+    ["{==", "==}"],
+    ["{>>", "<<}"]
+  ];
+  /**
+   * Makes a fixed-width slice of the raw-view projection presentable: drops
+   * complete {>>...<<} meta blocks (annotations of pre-existing changes, not
+   * part of this edit) and any wrapper fragments the window boundary chopped
+   * in half. Without this, previews leak internal scaffolding like
+   * "[Chg:5 delete]" (QA H1). Mirrors the Python engine.
+   */
+  static _tidy_preview_context(snippet, side) {
+    snippet = snippet.replace(/\{>>[\s\S]*?<<\}/g, "");
+    for (const [open_tok, close_tok] of _RedlineEngine._PREVIEW_WRAPPER_PAIRS) {
+      if (side === "before") {
+        let depth = 0;
+        let cut = 0;
+        let i = 0;
+        while (i < snippet.length) {
+          if (snippet.startsWith(open_tok, i)) {
+            depth += 1;
+            i += open_tok.length;
+          } else if (snippet.startsWith(close_tok, i)) {
+            if (depth === 0) cut = i + close_tok.length;
+            else depth -= 1;
+            i += close_tok.length;
+          } else {
+            i += 1;
+          }
+        }
+        snippet = snippet.substring(cut);
+      } else {
+        const opens = [];
+        let i = 0;
+        while (i < snippet.length) {
+          if (snippet.startsWith(open_tok, i)) {
+            opens.push(i);
+            i += open_tok.length;
+          } else if (snippet.startsWith(close_tok, i)) {
+            if (opens.length > 0) opens.pop();
+            i += close_tok.length;
+          } else {
+            i += 1;
+          }
+        }
+        if (opens.length > 0) snippet = snippet.substring(0, opens[0]);
+      }
+    }
+    if (side === "before") {
+      snippet = snippet.replace(/^[-+=<>]{0,2}\}/, "");
+    } else {
+      snippet = snippet.replace(/\{[-+=<>]{0,2}$/, "");
+    }
+    return snippet;
+  }
+  /**
+   * Snapshots the document text around a resolved edit BEFORE anything is
+   * applied. Previews rendered after the batch mutates the DOM cannot slice
+   * full_text at the stored offsets: applied edits shift offsets and inject
+   * tracked-change markup, which produced garbled previews mixing unrelated
+   * edits and internal scaffolding (QA H1).
+   */
+  _capture_preview_context(edit) {
+    if (edit.type !== "modify") return;
+    const start_idx = edit._resolved_start_idx;
+    if (start_idx === void 0 || start_idx === null) return;
+    const active_mapper = edit._active_mapper_ref || this.mapper;
+    const full_text = active_mapper.full_text;
+    if (!full_text) return;
+    const length = (edit.target_text || "").length;
+    const before = full_text.substring(
+      Math.max(0, start_idx - PREVIEW_CONTEXT_CHARS),
+      start_idx
+    );
+    const after = full_text.substring(
+      start_idx + length,
+      start_idx + length + PREVIEW_CONTEXT_CHARS
+    );
+    edit._preview_context = [
+      _RedlineEngine._tidy_preview_context(before, "before"),
+      _RedlineEngine._tidy_preview_context(after, "after")
+    ];
+  }
+  /**
+   * Like _capture_preview_context, but snapshots the context around the
+   * ORIGINAL edit's full matched span (stashed by _pre_resolve_heuristic_edit),
+   * so the report preview can present the complete logical change of a
+   * compound modification instead of its first sub-edit.
+   */
+  _capture_parent_preview_context(parent) {
+    if (!parent || parent.type !== "modify") return;
+    if (parent._preview_context || !parent._preview_span) return;
+    const [start_idx, match_len] = parent._preview_span;
+    const active_mapper = parent._preview_mapper_ref || this.mapper;
+    const full_text = active_mapper.full_text;
+    if (!full_text) return;
+    const before = full_text.substring(
+      Math.max(0, start_idx - PREVIEW_CONTEXT_CHARS),
+      start_idx
+    );
+    const after = full_text.substring(
+      start_idx + match_len,
+      start_idx + match_len + PREVIEW_CONTEXT_CHARS
+    );
+    parent._preview_context = [
+      _RedlineEngine._tidy_preview_context(before, "before"),
+      _RedlineEngine._tidy_preview_context(after, "after")
+    ];
+  }
+  /**
+   * Renders the preview from the edit's full matched span. The common
+   * prefix/suffix between matched and replacement text is moved into the
+   * surrounding context so the {--...--}{++...++} block shows the minimal
+   * complete change.
+   */
+  _build_full_match_preview(edit) {
+    let [context_before, context_after] = edit._preview_context;
+    let matched = edit._preview_matched_text || "";
+    let new_text = edit._preview_new_text !== void 0 && edit._preview_new_text !== null ? edit._preview_new_text : edit.new_text || "";
+    const [matched_clean, matched_style] = this._parse_markdown_style(matched);
+    const [new_clean, new_style] = this._parse_markdown_style(new_text);
+    if (matched_style && matched_style.startsWith("Heading")) {
+      context_before = context_before + matched.substring(0, matched.length - matched_clean.length);
+      matched = matched_clean;
+    }
+    if (new_style && new_style.startsWith("Heading")) {
+      new_text = new_clean;
+    }
+    const [prefix_len, suffix_len] = trim_common_context(matched, new_text);
+    let display_target = matched.substring(
+      prefix_len,
+      matched.length - suffix_len
+    );
+    let display_new = new_text.substring(
+      prefix_len,
+      new_text.length - suffix_len
+    );
+    context_before = context_before + matched.substring(0, prefix_len);
+    if (suffix_len) {
+      context_after = matched.substring(matched.length - suffix_len) + context_after;
+    }
+    display_target = truncate_middle(display_target, PREVIEW_TEXT_CAP);
+    display_new = truncate_middle(display_new, PREVIEW_TEXT_CAP);
+    let critic_markup;
+    if (!display_target && !display_new) {
+      const anchor = truncate_middle(matched, PREVIEW_TEXT_CAP);
+      const body = anchor ? `{==${anchor}==}` : "";
+      critic_markup = `${context_before.substring(0, context_before.length - matched.length)}${body}${context_after}`;
+    } else {
+      const deletion = display_target ? `{--${display_target}--}` : "";
+      const insertion = display_new ? `{++${display_new}++}` : "";
+      critic_markup = `${context_before}${deletion}${insertion}${context_after}`;
+    }
+    let clean_text = critic_markup;
+    clean_text = clean_text.replace(/\{>>[\s\S]*?<<\}/g, "");
+    clean_text = clean_text.replace(/\{--[\s\S]*?--\}/g, "");
+    clean_text = clean_text.replace(/\{\+\+([\s\S]*?)\+\+\}/g, "$1");
+    return [critic_markup, clean_text];
+  }
+  /**
+   * The "new text" a batch report should show for an edit. InsertTableRow has
+   * no new_text field — surface its cell contents instead of the misleading
+   * empty string the report used to print (QA M4).
+   */
+  static _report_new_text(edit) {
+    if (edit && edit.type === "insert_row" && Array.isArray(edit.cells)) {
+      return edit.cells.join(" | ");
+    }
+    return edit && edit.new_text || "";
+  }
   _build_edit_context_previews(edit) {
     if (edit.type !== "modify") return [null, null];
+    if (edit._preview_span && edit._preview_context) {
+      return this._build_full_match_preview(edit);
+    }
     if (edit._resolved_proxy_edit) {
       edit = edit._resolved_proxy_edit;
     }
@@ -3204,17 +3473,33 @@ var RedlineEngine = class {
       new_text = clean_new;
     }
     const length = target_text.length;
-    const active_mapper = edit._active_mapper_ref || this.mapper;
-    const full_text = active_mapper.full_text;
-    if (!full_text) return [null, null];
-    const before_start = Math.max(0, start_idx - 30);
-    const context_before = full_text.substring(before_start, start_idx);
-    const context_after = full_text.substring(
-      start_idx + length,
-      start_idx + length + 30
-    );
-    const insertion = new_text ? `{++${new_text}++}` : "";
-    const critic_markup = `${context_before}{--${target_text}--}${insertion}${context_after}`;
+    let context_before;
+    let context_after;
+    if (edit._preview_context) {
+      [context_before, context_after] = edit._preview_context;
+    } else {
+      const active_mapper = edit._active_mapper_ref || this.mapper;
+      const full_text = active_mapper.full_text;
+      if (!full_text) return [null, null];
+      context_before = _RedlineEngine._tidy_preview_context(
+        full_text.substring(
+          Math.max(0, start_idx - PREVIEW_CONTEXT_CHARS),
+          start_idx
+        ),
+        "before"
+      );
+      context_after = _RedlineEngine._tidy_preview_context(
+        full_text.substring(
+          start_idx + length,
+          start_idx + length + PREVIEW_CONTEXT_CHARS
+        ),
+        "after"
+      );
+    }
+    const display_target = truncate_middle(target_text, PREVIEW_TEXT_CAP);
+    const display_new = truncate_middle(new_text, PREVIEW_TEXT_CAP);
+    const insertion = display_new ? `{++${display_new}++}` : "";
+    const critic_markup = `${context_before}{--${display_target}--}${insertion}${context_after}`;
     let clean_text = critic_markup;
     clean_text = clean_text.replace(/\{>>.*?<<\}/gs, "");
     clean_text = clean_text.replace(/\{--.*?--\}/gs, "");
@@ -4155,7 +4440,7 @@ var RedlineEngine = class {
           const hint = this._nearest_match_hint(edit.target_text, is_regex);
           errors.push(
             `- Edit ${i + 1 + index_offset} Failed: Target text not found in document:
-  "${edit.target_text}"${hint}`
+  "${truncate_middle(edit.target_text, REPORT_ECHO_CAP)}"${hint}`
           );
         }
       } else if (matches.length > 1 && match_mode === "strict") {
@@ -4256,9 +4541,48 @@ var RedlineEngine = class {
           );
         }
       }
+      if ((edit.type === "insert_row" || edit.type === "delete_row") && matches.length > 0) {
+        const [start, length] = matches[0];
+        const n_cols = _RedlineEngine._column_count_at(
+          target_mapper,
+          start,
+          length
+        );
+        if (n_cols === null) {
+          errors.push(
+            `- Edit ${i + 1 + index_offset} Failed: ${edit.type} target text was found, but it is not inside a table row. Anchor the operation on text that appears within the table.`
+          );
+        } else if (edit.type === "insert_row" && Array.isArray(edit.cells) && edit.cells.length > n_cols) {
+          errors.push(
+            `- Edit ${i + 1 + index_offset} Failed: insert_row provides ${edit.cells.length} cells but the target table has ${n_cols} column(s). The extra cell(s) would be dropped. Provide at most ${n_cols} cells \u2014 rows given fewer cells are padded with empty ones.`
+          );
+        }
+      }
     }
     return errors;
   }
+  /**
+   * Number of columns (w:tc elements) in the table row containing the text at
+   * [start, start+length) in `mapper`, or null if that text is not inside a
+   * table row.
+   */
+  static _column_count_at(mapper, start, length) {
+    for (const s of mapper.spans) {
+      if (s.run === null || s.end <= start || s.start >= start + length) {
+        continue;
+      }
+      let curr = s.run._element;
+      while (curr) {
+        if (curr.nodeType === 1 && curr.tagName === "w:tr") {
+          return findAllDescendants(curr, "w:tc").filter(
+            (tc) => tc.parentNode === curr
+          ).length;
+        }
+        curr = curr.parentNode;
+      }
+    }
+    return null;
+  }
   validate_review_actions(actions) {
     const errors = [];
     for (let i = 0; i < actions.length; i++) {
@@ -4401,19 +4725,25 @@ var RedlineEngine = class {
       });
       if (dry_run_mode) {
         const reports_by_input = new Array(edits.length);
+        const validation_failed_idx = /* @__PURE__ */ new Set();
         for (const { edit, i } of ordered_edits) {
-          const single_errors = this.validate_edits([edit], i);
+          let single_errors = this.validate_edits([edit], i);
           if (single_errors.length > 0) {
+            if (applied_edits > 0) {
+              const hint = sequential_context_hint(applied_edits);
+              single_errors = single_errors.map((err) => err + hint);
+            }
+            validation_failed_idx.add(i);
             skipped_edits++;
             const warning = this._check_punctuation_warning(
               edit.target_text || ""
             );
             reports_by_input[i] = {
               status: "failed",
-              target_text: edit.target_text || "",
-              new_text: edit.new_text || "",
+              target_text: truncate_middle(edit.target_text || "", REPORT_ECHO_CAP),
+              new_text: truncate_middle(_RedlineEngine._report_new_text(edit), REPORT_ECHO_CAP),
               warning,
-              error: single_errors[0],
+              error: single_errors.join("\n"),
               critic_markup: null,
               clean_text: null
             };
@@ -4425,8 +4755,8 @@ var RedlineEngine = class {
             const previews = this._build_edit_context_previews(edit);
             reports_by_input[i] = {
               status: "applied",
-              target_text: edit.target_text || "",
-              new_text: edit.new_text || "",
+              target_text: truncate_middle(edit.target_text || "", REPORT_ECHO_CAP),
+              new_text: truncate_middle(_RedlineEngine._report_new_text(edit), REPORT_ECHO_CAP),
               warning: null,
               error: null,
               critic_markup: previews[0],
@@ -4446,8 +4776,8 @@ var RedlineEngine = class {
             );
             reports_by_input[i] = {
               status: "failed",
-              target_text: edit.target_text || "",
-              new_text: edit.new_text || "",
+              target_text: truncate_middle(edit.target_text || "", REPORT_ECHO_CAP),
+              new_text: truncate_middle(_RedlineEngine._report_new_text(edit), REPORT_ECHO_CAP),
               warning,
               error: error_msg,
               critic_markup: null,
@@ -4455,18 +4785,45 @@ var RedlineEngine = class {
             };
           }
         }
+        if (validation_failed_idx.size > 0) {
+          applied_edits = 0;
+          skipped_edits = edits.length;
+          for (let i = 0; i < reports_by_input.length; i++) {
+            const report = reports_by_input[i];
+            if (!report || validation_failed_idx.has(i)) continue;
+            if (report.status === "applied") {
+              reports_by_input[i] = {
+                status: "failed",
+                target_text: report.target_text,
+                new_text: report.new_text,
+                warning: null,
+                error: TRANSACTIONAL_NOT_APPLIED_ERROR,
+                critic_markup: null,
+                clean_text: null
+              };
+            }
+          }
+        }
         edits_reports.push(...reports_by_input);
       } else {
         const snapshot = takeSnapshot(this.doc);
         const originalCurrentId = this.current_id;
         try {
           const sequential_errors = [];
+          let applied_so_far = 0;
           for (const { edit, i } of ordered_edits) {
-            const single_errors = this.validate_edits([edit], i);
+            let single_errors = this.validate_edits([edit], i);
             if (single_errors.length > 0) {
+              if (applied_so_far > 0) {
+                const hint = sequential_context_hint(applied_so_far);
+                single_errors = single_errors.map((err) => err + hint);
+              }
               sequential_errors.push(...single_errors);
             } else {
               this.apply_edits([edit], page_offsets);
+              if (edit._applied_status) {
+                applied_so_far++;
+              }
               this.mapper = new DocumentMapper(this.doc);
               this.clean_mapper = null;
             }
@@ -4501,8 +4858,8 @@ var RedlineEngine = class {
           }
           edits_reports.push({
             status: success ? "applied" : "failed",
-            target_text: edit.target_text || "",
-            new_text: edit.new_text || "",
+            target_text: truncate_middle(edit.target_text || "", REPORT_ECHO_CAP),
+            new_text: truncate_middle(_RedlineEngine._report_new_text(edit), REPORT_ECHO_CAP),
             warning,
             error: error_msg,
             critic_markup,
@@ -4604,6 +4961,12 @@ var RedlineEngine = class {
     resolved_edits.sort(
       (a, b) => (b[0]._resolved_start_idx || 0) - (a[0]._resolved_start_idx || 0)
     );
+    for (const [res_edit] of resolved_edits) {
+      this._capture_preview_context(res_edit);
+      if (res_edit._parent_edit_ref) {
+        this._capture_parent_preview_context(res_edit._parent_edit_ref);
+      }
+    }
     const occupied_ranges = [];
     const counted_split_groups = /* @__PURE__ */ new Set();
     for (const [edit, orig_new] of resolved_edits) {
@@ -4804,7 +5167,15 @@ var RedlineEngine = class {
       const trPr = tr.ownerDocument.createElement("w:trPr");
       new_tr.appendChild(trPr);
       trPr.appendChild(this._create_track_change_tag("w:ins"));
-      for (const cellText of edit.cells) {
+      const anchor_cols = findAllDescendants(tr, "w:tc").filter(
+        (tc) => tc.parentNode === tr
+      ).length;
+      let cell_values = Array.isArray(edit.cells) ? [...edit.cells] : [];
+      if (anchor_cols > 0) {
+        while (cell_values.length < anchor_cols) cell_values.push("");
+        cell_values = cell_values.slice(0, anchor_cols);
+      }
+      for (const cellText of cell_values) {
         const tc = tr.ownerDocument.createElement("w:tc");
         const p = tr.ownerDocument.createElement("w:p");
         const r = tr.ownerDocument.createElement("w:r");
@@ -4900,6 +5271,12 @@ var RedlineEngine = class {
         } catch (e) {
         }
       }
+      if (!edit._preview_span) {
+        edit._preview_span = [start_idx, match_len];
+        edit._preview_matched_text = actual_doc_text;
+        edit._preview_new_text = current_effective_new_text;
+        edit._preview_mapper_ref = active_mapper;
+      }
       const [edit_target_clean, edit_target_style] = this._parse_markdown_style(
         edit.target_text
       );
@@ -5359,19 +5736,24 @@ var RedlineEngine = class {
       const is_inline_first = result.first_node.tagName === "w:ins";
       if (is_inline_first) {
         if (anchor_run) {
-          const anchor_parent = anchor_run._element.parentNode;
+          let anchor_el = anchor_run._element;
+          let anchor_parent = anchor_el.parentNode;
+          if (anchor_parent && anchor_parent.tagName === "w:del") {
+            anchor_el = anchor_parent;
+            anchor_parent = anchor_el.parentNode;
+          }
           const before_anchor = start_idx === 0;
           if (anchor_parent && anchor_parent.tagName === "w:ins") {
             this._insert_and_split_ins(
               anchor_parent,
-              anchor_run._element,
+              anchor_el,
               result.first_node,
               before_anchor
             );
           } else if (before_anchor && anchor_parent) {
-            anchor_parent.insertBefore(result.first_node, anchor_run._element);
+            anchor_parent.insertBefore(result.first_node, anchor_el);
           } else {
-            insertAfter(result.first_node, anchor_run._element);
+            insertAfter(result.first_node, anchor_el);
           }
         } else if (anchor_para) {
           const para_el = anchor_para._element;