@adeu/core 1.20.0 → 1.22.0

package/dist/index.cjs

@@ -34,10 +34,13 @@ __export(index_exports, {
   DocumentMapper: () => DocumentMapper,
   DocumentObject: () => DocumentObject,
   RedlineEngine: () => RedlineEngine,
+  RegexTimeoutError: () => RegexTimeoutError,
+  USER_PATTERN_TIMEOUT_MS: () => USER_PATTERN_TIMEOUT_MS,
   _extractTextFromDoc: () => _extractTextFromDoc,
   apply_edits_to_markdown: () => apply_edits_to_markdown,
   create_unified_diff: () => create_unified_diff,
   create_word_patch_diff: () => create_word_patch_diff,
+  describe_illegal_control_chars: () => describe_illegal_control_chars,
   extractTextFromBuffer: () => extractTextFromBuffer,
   extract_outline: () => extract_outline,
   finalize_document: () => finalize_document,
@@ -45,7 +48,10 @@ __export(index_exports, {
   identifyEngine: () => identifyEngine,
   paginate: () => paginate,
   split_structural_appendix: () => split_structural_appendix,
-  trim_common_context: () => trim_common_context
+  trim_common_context: () => trim_common_context,
+  userFindAllMatches: () => userFindAllMatches,
+  userSearch: () => userSearch,
+  validate_edit_strings: () => validate_edit_strings
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -794,6 +800,62 @@ function extract_comments_data(pkg) {
   return data;
 }
 
+// src/utils/safe-regex.ts
+var vm = __toESM(require("vm"), 1);
+var USER_PATTERN_TIMEOUT_MS = 2e3;
+var RegexTimeoutError = class extends Error {
+  pattern;
+  constructor(pattern) {
+    super(
+      `Regular expression exceeded the ${USER_PATTERN_TIMEOUT_MS / 1e3}s matching time budget (catastrophic backtracking). Simplify the pattern \u2014 nested quantifiers like (a+)+ are the usual cause \u2014 or use a literal target instead.`
+    );
+    this.name = "RegexTimeoutError";
+    this.pattern = pattern;
+  }
+};
+function runBudgeted(pattern, script, sandbox) {
+  try {
+    return vm.runInNewContext(script, sandbox, {
+      timeout: USER_PATTERN_TIMEOUT_MS
+    });
+  } catch (e) {
+    if (e && e.code === "ERR_SCRIPT_EXECUTION_TIMEOUT") {
+      throw new RegexTimeoutError(pattern);
+    }
+    throw e;
+  }
+}
+function userFindAllMatches(pattern, text, flags = "") {
+  const normalized = flags.includes("g") ? flags : flags + "g";
+  const re = new RegExp(pattern, normalized);
+  const raw = runBudgeted(
+    pattern,
+    `{
+      const out = [];
+      let m;
+      while ((m = re.exec(text)) !== null) {
+        out.push({ start: m.index, end: m.index + m[0].length });
+        if (m.index === re.lastIndex) re.lastIndex++;
+      }
+      out;
+    }`,
+    { re, text }
+  );
+  return raw.map((r) => ({ start: r.start, end: r.end }));
+}
+function userSearch(pattern, text, flags = "") {
+  const re = new RegExp(pattern, flags.replace("g", ""));
+  const raw = runBudgeted(
+    pattern,
+    `{
+      const m = re.exec(text);
+      m ? { start: m.index, end: m.index + m[0].length } : null;
+    }`,
+    { re, text }
+  );
+  return raw ? { start: raw.start, end: raw.end } : null;
+}
+
 // src/utils/docx.ts
 var QN_W_P = "w:p";
 var QN_W_R = "w:r";
@@ -1264,6 +1326,7 @@ function* iter_paragraph_content(paragraph) {
 }
 
 // src/mapper.ts
+var STYLE_MARKER_TEXTS = /* @__PURE__ */ new Set(["**", "__", "*", "_"]);
 var DocumentMapper = class {
   doc;
   clean_view;
@@ -1273,6 +1336,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 +1349,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,13 +1869,71 @@ ${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 {
-        const pattern = new RegExp(target_text);
-        const match = pattern.exec(this.full_text);
-        if (match) return [match.index, match[0].length];
+        const match = userSearch(target_text, this.full_text);
+        if (match) return [match.start, match.end - match.start];
       } catch (e) {
+        if (e instanceof RegexTimeoutError) throw e;
       }
       return [-1, 0];
     }
@@ -1825,6 +1948,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);
@@ -1837,37 +1962,40 @@ ${header}`;
     if (!target_text) return [];
     if (is_regex) {
       try {
-        const pattern = new RegExp(target_text, "g");
-        const matches2 = [...this.full_text.matchAll(pattern)];
-        if (matches2.length > 0)
-          return matches2.map((m) => [m.index, m[0].length]);
+        const matches2 = userFindAllMatches(target_text, this.full_text);
+        if (matches2.length > 0) return matches2.map((m) => [m.start, m.end - m.start]);
       } catch (e) {
+        if (e instanceof RegexTimeoutError) throw e;
       }
       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 [];
@@ -2815,7 +2943,9 @@ function apply_edits_to_markdown(markdown_text, edits, include_index = false, hi
       isolated_target,
       isolated_new,
       edit.comment,
-      orig_idx,
+      // 1-based, matching apply's "Edit N" reports and batch validation
+      // errors (QA 2026-07-17 F10; mirrors Python).
+      orig_idx + 1,
       include_index,
       highlight_only
     );
@@ -2857,18 +2987,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) {
@@ -2943,12 +3085,41 @@ 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.";
+var XML_ILLEGAL_CHARS_RE = /[\x00-\x08\x0b\x0c\x0e-\x1f]/g;
+function describe_illegal_control_chars(text) {
+  if (!text) return null;
+  const found = text.match(XML_ILLEGAL_CHARS_RE);
+  if (!found) return null;
+  const codes = Array.from(new Set(found.map((c) => `0x${c.charCodeAt(0).toString(16).padStart(2, "0")}`))).sort();
+  return codes.join(", ");
+}
 function validate_edit_strings(edits, index_offset = 0) {
   const errors = [];
   for (let i = 0; i < edits.length; i++) {
     const edit = edits[i];
     const t_text = edit.target_text || "";
     const n_text = edit.new_text || "";
+    const checked_fields = [
+      ["target_text", t_text],
+      ["new_text", n_text]
+    ];
+    if (edit.comment) checked_fields.push(["comment", edit.comment]);
+    (edit.cells || []).forEach((cell, cell_idx) => {
+      checked_fields.push([`cells[${cell_idx}]`, cell || ""]);
+    });
+    for (const [field_name, field_value] of checked_fields) {
+      const described = describe_illegal_control_chars(field_value);
+      if (described) {
+        errors.push(
+          `- Edit ${i + 1 + index_offset} Failed: \`${field_name}\` contains control character(s) (${described}) that cannot be stored in a DOCX. Remove them and re-submit.`
+        );
+      }
+    }
     if (n_text.includes("{++") || n_text.includes("{--") || n_text.includes("{>>") || n_text.includes("{==")) {
       errors.push(
         `- Edit ${i + 1 + index_offset} Failed: Do not manually write CriticMarkup tags ({++, {--, {>>, {==) in \`new_text\`. The engine handles redlining automatically. To add a comment, use the \`comment\` parameter.`
@@ -3046,7 +3217,7 @@ function validate_edit_strings(edits, index_offset = 0) {
   }
   return errors;
 }
-var RedlineEngine = class {
+var RedlineEngine = class _RedlineEngine {
   doc;
   author;
   timestamp;
@@ -3193,8 +3364,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, garbling previews with 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 rather than a misleading
+   * empty string (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;
     }
@@ -3213,17 +3560,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, "");
@@ -4164,7 +4527,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") {
@@ -4265,9 +4628,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++) {
@@ -4410,19 +4812,31 @@ 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;
+          try {
+            single_errors = this.validate_edits([edit], i);
+          } catch (e) {
+            if (!(e instanceof RegexTimeoutError)) throw e;
+            single_errors = [`- Edit ${i + 1} Failed: ${e.message}`];
+          }
           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
             };
@@ -4434,8 +4848,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],
@@ -4455,8 +4869,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,
@@ -4464,18 +4878,51 @@ 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;
+            try {
+              single_errors = this.validate_edits([edit], i);
+            } catch (e) {
+              if (!(e instanceof RegexTimeoutError)) throw e;
+              single_errors = [`- Edit ${i + 1} Failed: ${e.message}`];
+            }
             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;
             }
@@ -4510,8 +4957,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,
@@ -4578,7 +5025,18 @@ var RedlineEngine = class {
           edit._error_msg = msg;
         }
       } else {
-        const resolved = this._pre_resolve_heuristic_edit(edit);
+        let resolved;
+        try {
+          resolved = this._pre_resolve_heuristic_edit(edit);
+        } catch (e) {
+          if (!(e instanceof RegexTimeoutError)) throw e;
+          skipped++;
+          edit._applied_status = false;
+          const msg = `- Failed to apply edit targeting: '${(edit.target_text || "").substring(0, 40)}...' (${e.message})`;
+          this.skipped_details.push(msg);
+          edit._error_msg = msg;
+          continue;
+        }
         if (resolved) {
           if (Array.isArray(resolved)) {
             for (const r of resolved) {
@@ -4613,6 +5071,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) {
@@ -4731,6 +5195,16 @@ var RedlineEngine = class {
         );
         continue;
       }
+      const dup_authors = Array.from(
+        new Set(all_nodes.map((n) => n.getAttribute("w:author") || "Unknown"))
+      ).sort();
+      if (dup_authors.length > 1) {
+        skipped++;
+        this.skipped_details.push(
+          `- Failed to apply action: ${type} on Chg:${target_id} is ambiguous. The document contains ${all_nodes.length} tracked-change elements sharing w:id=${target_id} from different authors (${dup_authors.join(", ")}) \u2014 duplicate revision IDs produced outside this engine (e.g. by a document merge or copy-paste). Acting on this ID would resolve all of them at once. Resolve these changes individually in Word, or apply the intended outcome as an explicit text edit instead.`
+        );
+        continue;
+      }
       for (const node of all_nodes) {
         const is_ins = node.tagName === "w:ins";
         const parent_tag = node.parentNode ? node.parentNode.tagName : "";
@@ -4813,7 +5287,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");
@@ -4909,6 +5391,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
       );
@@ -6032,6 +6520,27 @@ function scrub_doc_properties(doc) {
         c.textContent = "";
       }
     });
+    const titles = findDescendantsByLocalName(corePart._element, "title");
+    titles.forEach((c) => {
+      if (c.textContent) {
+        lines.push(`Title kept (review manually): "${c.textContent}"`);
+      }
+    });
+    const leakFields = [
+      ["category", "Category"],
+      ["keywords", "Keywords"],
+      ["subject", "Subject"],
+      ["contentStatus", "Content status"],
+      ["description", "Description/comments"]
+    ];
+    for (const [local, label] of leakFields) {
+      findDescendantsByLocalName(corePart._element, local).forEach((c) => {
+        if (c.textContent) {
+          lines.push(`${label}: ${c.textContent}`);
+          c.textContent = "";
+        }
+      });
+    }
     const revisions = findDescendantsByLocalName(corePart._element, "revision");
     revisions.forEach((c) => {
       if (c.textContent && parseInt(c.textContent) > 1) {
@@ -6237,7 +6746,11 @@ function extract_all_domain_metadata(doc, base_text) {
     for (const term of def_keys) {
       if (definitions[term].count === 0) {
         delete definitions[term];
-        duplicates.delete(term);
+        if (!duplicates.has(term)) {
+          diagnostics.push(
+            `[Warning] Unused Definition: '${term}' is defined but never used.`
+          );
+        }
       }
     }
   }
@@ -7573,10 +8086,13 @@ function identifyEngine() {
   DocumentMapper,
   DocumentObject,
   RedlineEngine,
+  RegexTimeoutError,
+  USER_PATTERN_TIMEOUT_MS,
   _extractTextFromDoc,
   apply_edits_to_markdown,
   create_unified_diff,
   create_word_patch_diff,
+  describe_illegal_control_chars,
   extractTextFromBuffer,
   extract_outline,
   finalize_document,
@@ -7584,6 +8100,9 @@ function identifyEngine() {
   identifyEngine,
   paginate,
   split_structural_appendix,
-  trim_common_context
+  trim_common_context,
+  userFindAllMatches,
+  userSearch,
+  validate_edit_strings
 });
 //# sourceMappingURL=index.cjs.map