@adeu/core 1.18.5 → 1.19.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adeu/core",
-  "version": "1.18.5",
+  "version": "1.19.1",
   "description": "",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",

package/src/engine.ts

@@ -11,7 +11,7 @@ import {
   ReplyComment,
   DocumentChange,
 } from "./models.js";
-import { trim_common_context } from "./diff.js";
+import { trim_common_context, generate_edits_from_text } from "./diff.js";
 import { findChild, findAllDescendants, serializeXml } from "./docx/dom.js";
 import { split_structural_appendix, paginate } from "./pagination.js";
 import {
@@ -345,6 +345,89 @@ export class RedlineEngine {
     }
     return null;
   }
+
+  private _word_diff_sub_edits(
+    target_str: string,
+    new_str: string,
+    base_offset: number,
+    parent_comment: string | null = null,
+    is_table: boolean = false,
+    active_mapper: any = null,
+  ): any[] {
+    let raw_sub_edits: any[] = [];
+    try {
+      raw_sub_edits = generate_edits_from_text(target_str, new_str);
+    } catch (e) {
+      console.error("generate_edits_from_text failed, falling back to wholesale edit", e);
+      raw_sub_edits = [];
+    }
+
+    if (!raw_sub_edits || raw_sub_edits.length === 0) {
+      const fallback_edit: any = {
+        type: "modify",
+        target_text: target_str,
+        new_text: new_str,
+        comment: parent_comment,
+      };
+      fallback_edit._resolved_start_idx = base_offset;
+      fallback_edit._match_start_index = base_offset;
+      fallback_edit._active_mapper_ref = active_mapper;
+      if (is_table) {
+        fallback_edit._is_table_edit = true;
+      }
+      if (target_str === new_str) {
+        fallback_edit._internal_op = "COMMENT_ONLY";
+      } else if (!target_str && new_str) {
+        fallback_edit._internal_op = "INSERTION";
+      } else if (target_str && !new_str) {
+        fallback_edit._internal_op = "DELETION";
+      } else if (target_str && new_str) {
+        fallback_edit._internal_op = "MODIFICATION";
+      } else {
+        fallback_edit._internal_op = "COMMENT_ONLY";
+      }
+      return [fallback_edit];
+    }
+
+    const sub_edits: any[] = [];
+    let comment_assigned = false;
+    for (const raw_edit of raw_sub_edits) {
+      const sub_start = base_offset + (raw_edit._match_start_index || 0);
+      const should_attach_comment = (parent_comment !== null) && !comment_assigned;
+      if (should_attach_comment) {
+        comment_assigned = true;
+      }
+
+      const sub_edit: any = {
+        type: "modify",
+        target_text: raw_edit.target_text,
+        new_text: raw_edit.new_text,
+        comment: should_attach_comment ? parent_comment : null,
+      };
+      sub_edit._resolved_start_idx = sub_start;
+      sub_edit._match_start_index = sub_start;
+      sub_edit._active_mapper_ref = active_mapper;
+      if (is_table) {
+        sub_edit._is_table_edit = true;
+      }
+
+      const t_val = raw_edit.target_text;
+      const n_val = raw_edit.new_text;
+      if (!t_val && n_val) {
+        sub_edit._internal_op = "INSERTION";
+      } else if (t_val && !n_val) {
+        sub_edit._internal_op = "DELETION";
+      } else if (t_val && n_val) {
+        sub_edit._internal_op = "MODIFICATION";
+      } else {
+        sub_edit._internal_op = "COMMENT_ONLY";
+      }
+
+      sub_edits.push(sub_edit);
+    }
+
+    return sub_edits;
+  }
   /**
    * Best-effort "did you mean" hint for a failed target. The common loop trap
    * (observed in the field) is an anchored regex like `^\( x \)$` against a
@@ -1525,6 +1608,18 @@ export class RedlineEngine {
         continue;
       }
       if (!edit.target_text) continue;
+      // Caller-pinned indexes (e.g. generate_edits_from_text output) resolve
+      // by position, not content: ambiguity / not-found checks are meaningless
+      // for them and false-positive whenever the target coincidentally matches
+      // unrelated text (a comment timestamp, an earlier redline). The
+      // string-shape checks above still apply.
+      if (
+        (edit._match_start_index !== undefined &&
+          edit._match_start_index !== null) ||
+        (edit._resolved_start_idx !== undefined &&
+          edit._resolved_start_idx !== null)
+      )
+        continue;
 
       const is_regex = (edit as any).regex || false;
       const match_mode = (edit as any).match_mode || "strict";
@@ -1953,9 +2048,41 @@ export class RedlineEngine {
     let skipped_edits = 0;
 
     if (edits.length > 0) {
+      // Sequential application rebuilds the mapper after every applied edit,
+      // shifting every position at/after that edit. Caller-pinned indexes
+      // (_match_start_index / _resolved_start_idx, e.g. generate_edits_from_text
+      // output) are coordinates in the INITIAL document state, so apply indexed
+      // edits bottom-up first — positions below an applied edit never move (the
+      // same invariant apply_edits' reverse sweep relies on) — then let
+      // text-anchored edits re-resolve against the mutated text as before.
+      // Reports are keyed by `i` so they stay in batch order.
+      const pinned_idx = (e: any): number | null => {
+        if (
+          e._resolved_start_idx !== undefined &&
+          e._resolved_start_idx !== null
+        )
+          return e._resolved_start_idx;
+        if (
+          e._match_start_index !== undefined &&
+          e._match_start_index !== null
+        )
+          return e._match_start_index;
+        return null;
+      };
+      const ordered_edits = edits
+        .map((edit, i) => ({ edit: edit as any, i }))
+        .sort((a, b) => {
+          const ka = pinned_idx(a.edit);
+          const kb = pinned_idx(b.edit);
+          if (ka === null && kb === null) return a.i - b.i;
+          if (ka === null) return 1;
+          if (kb === null) return -1;
+          return kb - ka || a.i - b.i;
+        });
+
       if (dry_run_mode) {
-        for (let i = 0; i < edits.length; i++) {
-          const edit = edits[i];
+        const reports_by_input: any[] = new Array(edits.length);
+        for (const { edit, i } of ordered_edits) {
           const single_errors = this.validate_edits([edit], i);
           if (single_errors.length > 0) {
             skipped_edits++;
@@ -1967,7 +2094,7 @@ export class RedlineEngine {
             const warning = this._check_punctuation_warning(
               (edit as any).target_text || "",
             );
-            edits_reports.push({
+            reports_by_input[i] = {
               status: "failed",
               target_text: (edit as any).target_text || "",
               new_text: (edit as any).new_text || "",
@@ -1975,14 +2102,14 @@ export class RedlineEngine {
               error: single_errors[0],
               critic_markup: null,
               clean_text: null,
-            });
+            };
             continue;
           }
           const res = this.apply_edits([edit], page_offsets);
           if ((edit as any)._applied_status) {
             applied_edits++;
             const previews = this._build_edit_context_previews(edit);
-            edits_reports.push({
+            reports_by_input[i] = {
               status: "applied",
               target_text: (edit as any).target_text || "",
               new_text: (edit as any).new_text || "",
@@ -1994,7 +2121,7 @@ export class RedlineEngine {
               heading_path: (edit as any)._heading_path || "",
               occurrences_modified: (edit as any)._occurrences_modified || 0,
               match_mode: (edit as any).match_mode || "strict",
-            });
+            };
             this.mapper = new DocumentMapper(this.doc);
             this.clean_mapper = null;
           } else {
@@ -2006,7 +2133,7 @@ export class RedlineEngine {
             const warning = this._check_punctuation_warning(
               (edit as any).target_text || "",
             );
-            edits_reports.push({
+            reports_by_input[i] = {
               status: "failed",
               target_text: (edit as any).target_text || "",
               new_text: (edit as any).new_text || "",
@@ -2014,17 +2141,17 @@ export class RedlineEngine {
               error: error_msg,
               critic_markup: null,
               clean_text: null,
-            });
+            };
           }
         }
+        edits_reports.push(...reports_by_input);
       } else {
         // Simulated dry-run sequentially for wet-run validation parity
         const snapshot = takeSnapshot(this.doc);
         const originalCurrentId = this.current_id;
         try {
           const sequential_errors: string[] = [];
-          for (let i = 0; i < edits.length; i++) {
-            const edit = edits[i];
+          for (const { edit, i } of ordered_edits) {
             const single_errors = this.validate_edits([edit], i);
             if (single_errors.length > 0) {
               sequential_errors.push(...single_errors);
@@ -2224,7 +2351,8 @@ export class RedlineEngine {
 
       let success = false;
       if (edit.type === "modify") {
-        success = this._apply_single_edit_indexed(edit, orig_new, false);
+        const rebuild = edit._split_group_id !== undefined && edit._split_group_id !== null;
+        success = this._apply_single_edit_indexed(edit, orig_new, rebuild);
       } else if (edit.type === "insert_row" || edit.type === "delete_row") {
         success = this._apply_table_edit(edit, false);
       }
@@ -2591,6 +2719,97 @@ export class RedlineEngine {
         continue;
       }
 
+      let overlaps_virtual_pipe = false;
+      if (active_mapper) {
+        overlaps_virtual_pipe = active_mapper.spans.some(
+          (s: any) =>
+            s.text === " | " &&
+            (s.run === null || s.run === undefined) &&
+            s.start < start_idx + match_len &&
+            s.end > start_idx,
+        );
+      }
+
+      if (overlaps_virtual_pipe) {
+        const actual_cells = actual_doc_text.split("|");
+        const new_cells = current_effective_new_text.split("|");
+
+        if (actual_cells.length === new_cells.length && actual_cells.length > 1) {
+          const sub_edits: any[] = [];
+          let search_offset = start_idx;
+
+          // Determine which cell receives the comment
+          let target_comment_idx = 0;
+          for (let idx = 0; idx < actual_cells.length; idx++) {
+            if (actual_cells[idx].trim() !== new_cells[idx].trim()) {
+              target_comment_idx = idx;
+              break;
+            }
+          }
+
+          for (let cell_idx = 0; cell_idx < actual_cells.length; cell_idx++) {
+            const a_cell = actual_cells[cell_idx];
+            const n_cell = new_cells[cell_idx];
+            const a_clean = a_cell.trim();
+            const n_clean = n_cell.trim();
+
+            let actual_start = search_offset;
+            if (a_clean) {
+              actual_start = this.mapper.full_text.indexOf(a_clean, search_offset);
+              if (actual_start === -1 || actual_start > search_offset + 10) {
+                actual_start = search_offset;
+              }
+            }
+
+            const should_attach_comment = (edit.comment !== null && edit.comment !== undefined) && (cell_idx === target_comment_idx);
+
+            if (a_clean !== n_clean || should_attach_comment) {
+              const cell_sub_edits = this._word_diff_sub_edits(
+                a_clean,
+                n_clean,
+                actual_start,
+                should_attach_comment ? edit.comment : null,
+                true,
+                active_mapper,
+              );
+              for (const se of cell_sub_edits) {
+                se._original_target_text = edit.target_text;
+                se._split_group_id = start_idx;
+                sub_edits.push(se);
+              }
+            }
+
+            if (a_clean) {
+              search_offset = actual_start + a_clean.length;
+            }
+
+            const next_pipe = this.mapper.full_text.indexOf(" | ", search_offset);
+            if (next_pipe !== -1 && next_pipe <= search_offset + 10) {
+              search_offset = next_pipe + 3;
+            } else {
+              search_offset += a_cell.length + 1;
+            }
+          }
+
+          for (const sub of sub_edits) {
+            all_sub_edits.push(sub);
+          }
+          continue;
+        } else {
+          throw new BatchValidationError([
+            `Target text spans ${actual_cells.length} table cells, but replacement provides ${new_cells.length}. To modify text without altering table structure (rows or columns), ensure the replacement contains the exact same number of '|' separators (e.g., replace with 'CellC | ' to empty the second cell).`
+          ]);
+        }
+      }
+
+      let has_markdown = false;
+      if (edit.target_text && (edit.target_text.includes("**") || edit.target_text.includes("_"))) {
+        has_markdown = true;
+      }
+      if (current_effective_new_text && (current_effective_new_text.includes("**") || current_effective_new_text.includes("_"))) {
+        has_markdown = true;
+      }
+
       let effective_op = "";
       let final_target = "";
       let final_new = "";
@@ -2598,9 +2817,7 @@ export class RedlineEngine {
 
       if (current_effective_new_text.startsWith(actual_doc_text)) {
         effective_op = "INSERTION";
-        final_new = current_effective_new_text.substring(
-          actual_doc_text.length,
-        );
+        final_new = current_effective_new_text.substring(actual_doc_text.length);
         effective_start_idx = start_idx + match_len;
       } else {
         const [prefix_len, suffix_len] = trim_common_context(
@@ -2613,84 +2830,101 @@ export class RedlineEngine {
         final_target = actual_doc_text.substring(prefix_len, t_end);
         final_new = current_effective_new_text.substring(prefix_len, n_end);
         effective_start_idx = start_idx + prefix_len;
+      }
 
-        // Balanced multi-paragraph modification: the matched span crosses one or
-        // more paragraph breaks and the replacement preserves the same number of
-        // breaks. Apply it as one independent sub-edit per paragraph segment so
-        // the structural \n\n breaks are left intact. Each sub-edit shares a
-        // _split_group_id (the occurrence's start index) so the batch report
-        // counts it as a single applied edit. Unbalanced cases (a genuine
-        // paragraph merge or split) fall through to the single-span path and are
-        // rejected by validate_edits.
-        const target_segs = actual_doc_text.split("\n\n");
-        const new_segs = current_effective_new_text.split("\n\n");
-        if (
-          actual_doc_text.includes("\n\n") &&
-          target_segs.length === new_segs.length
-        ) {
-          const split_sub_edits: any[] = [];
-          let seg_offset = start_idx;
-          let comment_assigned = false;
-          for (let k = 0; k < target_segs.length; k++) {
-            const t_seg = target_segs[k];
-            const n_seg = new_segs[k];
-            if (t_seg !== n_seg) {
-              const [seg_prefix, seg_suffix] = trim_common_context(
-                t_seg,
-                n_seg,
-              );
-              const seg_target = t_seg.substring(
-                seg_prefix,
-                t_seg.length - seg_suffix,
-              );
-              const seg_new = n_seg.substring(
-                seg_prefix,
-                n_seg.length - seg_suffix,
-              );
-              const seg_start = seg_offset + seg_prefix;
-              let seg_op: string;
-              if (!seg_target && seg_new) seg_op = "INSERTION";
-              else if (seg_target && !seg_new) seg_op = "DELETION";
-              else if (seg_target && seg_new) seg_op = "MODIFICATION";
-              else seg_op = "COMMENT_ONLY";
-              const seg_comment =
-                edit.comment && !comment_assigned ? edit.comment : null;
-              if (seg_comment) comment_assigned = true;
-              split_sub_edits.push({
-                type: "modify",
-                target_text: seg_target,
-                new_text: seg_new,
-                comment: seg_comment,
-                _match_start_index: seg_start,
-                _internal_op: seg_op,
-                _active_mapper_ref: active_mapper,
-                _split_group_id: start_idx,
-              });
+      if (has_markdown) {
+        if (!final_target && final_new) {
+          effective_op = "INSERTION";
+        } else if (final_target && !final_new) {
+          effective_op = "DELETION";
+        } else if (final_target && final_new) {
+          effective_op = "MODIFICATION";
+        } else {
+          all_sub_edits.push({
+            type: "modify",
+            target_text: final_target,
+            new_text: final_new,
+            comment: edit.comment,
+            _match_start_index: effective_start_idx,
+            _internal_op: "COMMENT_ONLY",
+            _active_mapper_ref: active_mapper,
+          });
+          continue;
+        }
+
+        all_sub_edits.push({
+          type: "modify",
+          target_text: final_target,
+          new_text: final_new,
+          comment: edit.comment,
+          _resolved_start_idx: effective_start_idx,
+          _match_start_index: effective_start_idx,
+          _internal_op: effective_op,
+          _active_mapper_ref: active_mapper,
+        });
+        continue;
+      }
+
+      // Balanced multi-paragraph modification: the matched span crosses one or
+      // more paragraph breaks and the replacement preserves the same number of
+      // breaks. Apply it as one independent sub-edit per paragraph segment so
+      // the structural \n\n breaks are left intact. Each sub-edit shares a
+      // _split_group_id (the occurrence's start index) so the batch report
+      // counts it as a single applied edit. Unbalanced cases (a genuine
+      // paragraph merge or split) fall through to the single-span path and are
+      // rejected by validate_edits.
+      const target_segs = actual_doc_text.split("\n\n");
+      const new_segs = current_effective_new_text.split("\n\n");
+      if (
+        actual_doc_text.includes("\n\n") &&
+        target_segs.length === new_segs.length
+      ) {
+        const split_sub_edits: any[] = [];
+        let seg_offset = start_idx;
+        let comment_assigned = false;
+        for (let k = 0; k < target_segs.length; k++) {
+          const t_seg = target_segs[k];
+          const n_seg = new_segs[k];
+          if (t_seg !== n_seg) {
+            const seg_comment =
+              edit.comment && !comment_assigned ? edit.comment : null;
+            const seg_sub_edits = this._word_diff_sub_edits(
+              t_seg,
+              n_seg,
+              seg_offset,
+              seg_comment,
+              false,
+              active_mapper,
+            );
+            if (seg_sub_edits.some((se) => se.comment !== null && se.comment !== undefined)) {
+              comment_assigned = true;
+            }
+            for (const se of seg_sub_edits) {
+              se._split_group_id = start_idx;
+              split_sub_edits.push(se);
             }
-            // Advance past this segment plus its "\n\n" separator span.
-            seg_offset += t_seg.length + 2;
-          }
-          if (split_sub_edits.length > 0) {
-            for (const sub of split_sub_edits) all_sub_edits.push(sub);
-            continue;
           }
+          // Advance past this segment plus its "\n\n" separator span.
+          seg_offset += t_seg.length + 2;
+        }
+        if (split_sub_edits.length > 0) {
+          for (const sub of split_sub_edits) all_sub_edits.push(sub);
+          continue;
         }
-
-        if (!final_target && final_new) effective_op = "INSERTION";
-        else if (final_target && !final_new) effective_op = "DELETION";
-        else if (final_target && final_new) effective_op = "MODIFICATION";
-        else effective_op = "COMMENT_ONLY";
       }
 
-      all_sub_edits.push({
-        type: "modify",
-        target_text: final_target,
-        new_text: final_new,
-        comment: edit.comment,
-        _match_start_index: effective_start_idx,
-        _internal_op: effective_op,
-        _active_mapper_ref: active_mapper,
-      });
+      const sub_edits = this._word_diff_sub_edits(
+        actual_doc_text,
+        current_effective_new_text,
+        start_idx,
+        edit.comment,
+        false,
+        active_mapper,
+      );
+      for (const se of sub_edits) {
+        se._split_group_id = start_idx;
+        all_sub_edits.push(se);
+      }
     }
 
     if (all_sub_edits.length === 0) return null;
@@ -2708,20 +2942,24 @@ export class RedlineEngine {
    */
   private _insert_and_split_ins(
     parent_ins: Element,
-    split_after: Element,
+    anchor: Element,
     new_elem: Element,
+    split_before: boolean = false,
   ) {
     const grandparent = parent_ins.parentNode as Element | null;
     if (!grandparent) return;
     // cloneNode(false) copies the attributes (author/id/date) onto both halves.
+    // The split lands after `anchor` by default; with split_before the anchor
+    // itself goes to the right half so new_elem ends up in front of it.
     const left = parent_ins.cloneNode(false) as Element;
     const right = parent_ins.cloneNode(false) as Element;
     let toRight = false;
     for (const kid of Array.from(parent_ins.childNodes)) {
       parent_ins.removeChild(kid);
+      if (split_before && kid === anchor) toRight = true;
       if (!toRight) {
         left.appendChild(kid);
-        if (kid === split_after) toRight = true;
+        if (kid === anchor) toRight = true;
       } else {
         right.appendChild(kid);
       }
@@ -2747,6 +2985,22 @@ export class RedlineEngine {
         : edit._match_start_index || 0;
     const length = edit.target_text ? edit.target_text.length : 0;
 
+    // Indexed edits (caller-supplied _match_start_index, e.g. straight from
+    // generate_edits_from_text) bypass _pre_resolve_heuristic_edit — the only
+    // place _internal_op is normally assigned. Without this fallback the
+    // deletion sweep below still runs but no insertion branch does: a
+    // replacement silently degrades to a pure tracked deletion and a pure
+    // insertion fails. Mirrors the Python engine.
+    if (op === undefined || op === null) {
+      if (!edit.target_text && edit.new_text) {
+        op = "INSERTION";
+      } else if (edit.target_text && !edit.new_text) {
+        op = "DELETION";
+      } else {
+        op = "MODIFICATION";
+      }
+    }
+
     if (op === "STYLE_ONLY" || op === "STYLE_AND_TEXT") {
       const [anchor_run, anchor_para] = active_mapper.get_insertion_anchor(
         start_idx,
@@ -2993,21 +3247,39 @@ export class RedlineEngine {
         if (anchor_run) {
           const anchor_parent = anchor_run._element
             .parentNode as Element | null;
+          // get_insertion_anchor(0) resolves to the document's FIRST run: the
+          // insertion point precedes it, so the new <w:ins> must land before
+          // the anchor, not after (mirrors the Python engine's insert_before
+          // path).
+          const before_anchor = start_idx === 0;
           if (anchor_parent && anchor_parent.tagName === "w:ins") {
             // Inserting inside another author's pending <w:ins>: split it so our
-            // new <w:ins> lands as a sibling right after the anchor run, never
+            // new <w:ins> lands as a sibling right next to the anchor run, never
             // <w:ins> nested in <w:ins> (mirrors the MODIFICATION path and the
             // Python engine).
             this._insert_and_split_ins(
               anchor_parent,
               anchor_run._element,
               result.first_node,
+              before_anchor,
             );
+          } else if (before_anchor && anchor_parent) {
+            anchor_parent.insertBefore(result.first_node, anchor_run._element);
           } else {
             insertAfter(result.first_node, anchor_run._element);
           }
         } else if (anchor_para) {
-          anchor_para._element.appendChild(result.first_node);
+          // Paragraph-anchored insertion: the anchor resolves to a paragraph
+          // (not a run) for zero-width paragraph-start spans — e.g. index 0 of
+          // the document. The insertion point is the START of the paragraph
+          // content, so land right after pPr, mirroring the Python engine;
+          // appendChild would drop the text at the paragraph's END.
+          const para_el = anchor_para._element;
+          let ref: Node | null = para_el.firstChild;
+          while (ref && (ref as Element).tagName === "w:pPr") {
+            ref = ref.nextSibling;
+          }
+          para_el.insertBefore(result.first_node, ref);
         }
       }