@adeu/core 1.19.0 → 1.20.0

package/package.json

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

package/src/engine.ts

@@ -357,9 +357,8 @@ export class RedlineEngine {
     let raw_sub_edits: any[] = [];
     try {
       raw_sub_edits = generate_edits_from_text(target_str, new_str);
-      console.log("_word_diff_sub_edits RAW_SUB_EDITS:", JSON.stringify(raw_sub_edits, null, 2));
     } catch (e) {
-      console.warn("generate_edits_from_text failed, falling back to wholesale edit", e);
+      console.error("generate_edits_from_text failed, falling back to wholesale edit", e);
       raw_sub_edits = [];
     }
 
@@ -3246,8 +3245,17 @@ export class RedlineEngine {
       const is_inline_first = result.first_node.tagName === "w:ins";
       if (is_inline_first) {
         if (anchor_run) {
-          const anchor_parent = anchor_run._element
-            .parentNode as Element | null;
+          let anchor_el: Element = anchor_run._element;
+          let anchor_parent = anchor_el.parentNode as Element | null;
+          // A tracked-deleted anchor (run inside <w:del>) cannot host the
+          // new <w:ins> as a child — an insertion nested inside a deletion
+          // is invalid revision XML. Lift the anchor to the <w:del> wrapper
+          // so the insert lands beside the whole block (mirrors the Python
+          // engine).
+          if (anchor_parent && anchor_parent.tagName === "w:del") {
+            anchor_el = anchor_parent;
+            anchor_parent = anchor_el.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
@@ -3260,14 +3268,14 @@ export class RedlineEngine {
             // Python engine).
             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) {
           // Paragraph-anchored insertion: the anchor resolves to a paragraph

package/src/mapper.ts

@@ -989,7 +989,27 @@ export class DocumentMapper {
         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) {
+          // Every span ending exactly here is virtual (CriticMarkup
+          // wrappers, {>>...<<} meta blocks, prefixes). If real text
+          // precedes this index in the SAME paragraph, anchor after its
+          // last run: falling back to the bare paragraph would drop the
+          // insertion at paragraph start, ahead of the very redlines and
+          // comment ranges that fence off the true position (mirrors the
+          // Python mapper).
+          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];
+        }
       }
     }
 

package/src/repro.insertion-anchor.test.ts

@@ -0,0 +1,91 @@
+import { describe, it, expect } from "vitest";
+import { readFileSync } from "node:fs";
+import { resolve, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { DocumentObject } from "./docx/bridge.js";
+import { RedlineEngine } from "./engine.js";
+import { extractTextFromBuffer } from "./ingest.js";
+import { createTestDocument, addParagraph } from "./test-utils.js";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Reproduction for the insertion-anchor bug (2026-07, golden.docx):
+// ModifyText("document" -> "finalized document") is diff-minimized to a
+// zero-width INSERTION of "finalized " immediately before "document". The
+// target paragraph already carries tracked changes ({--initial --}
+// {++golden ++}) and three comment ranges, so in the raw projection the
+// insertion index sits right after a virtual {>>...<<} meta block.
+// get_insertion_anchor only looked for a run-backed span ENDING exactly at
+// that index; every span ending there is virtual, so it fell back to
+// (null, paragraph) and the engine dropped the new <w:ins> at the START of
+// the paragraph — "finalized This is the golden document" after accept-all.
+// The fix anchors after the nearest preceding REAL run in the same
+// paragraph (mirrors the Python engine/mapper fix).
+describe("Zero-width insertion anchoring with preceding redlines/comments", () => {
+  it("lands the insertion before its target, not at paragraph start (golden.docx)", async () => {
+    const fixturePath = resolve(
+      __dirname,
+      "../../../../shared/fixtures/golden.docx",
+    );
+    const buf = readFileSync(fixturePath);
+    const doc = await DocumentObject.load(buf);
+    const engine = new RedlineEngine(doc, "T");
+
+    const stats = engine.process_batch([
+      { type: "modify", target_text: "document", new_text: "finalized document" },
+    ]);
+    expect(stats.edits_applied).toBe(1);
+
+    const out = await doc.save();
+    const clean = await extractTextFromBuffer(out, true);
+    expect(clean).toContain("golden finalized document");
+    expect(clean.startsWith("finalized This is")).toBe(false);
+
+    const red = await extractTextFromBuffer(out);
+    expect(red.startsWith("{++finalized")).toBe(false);
+  });
+
+  it("does not nest <w:ins> inside <w:del> when the anchor run is tracked-deleted", async () => {
+    const doc = await createTestDocument();
+    addParagraph(doc, "This is the initial document");
+
+    // Pass 1: track-delete "initial " so the raw projection becomes
+    // "This is the {--initial --}{>>[Chg:1 delete] T<<}document".
+    const engine1 = new RedlineEngine(doc, "T");
+    engine1.process_batch([
+      { type: "modify", target_text: "initial ", new_text: "" },
+    ]);
+    const deleted = await doc.save();
+
+    // Pass 2: zero-width insertion right before "document".
+    const doc2 = await DocumentObject.load(deleted);
+    const engine2 = new RedlineEngine(doc2, "T2");
+    engine2.process_batch([
+      { type: "modify", target_text: "document", new_text: "finalized document" },
+    ]);
+
+    const dels = Array.from(doc2.element.getElementsByTagName("w:del"));
+    for (const del of dels) {
+      expect(del.getElementsByTagName("w:ins").length).toBe(0);
+    }
+
+    const out = await doc2.save();
+    const clean = await extractTextFromBuffer(out, true);
+    expect(clean).toContain("This is the finalized document");
+  });
+
+  it("keeps genuine paragraph-start insertions at the paragraph start", async () => {
+    const doc = await createTestDocument();
+    addParagraph(doc, "Alpha beta gamma");
+    const engine = new RedlineEngine(doc, "T");
+
+    engine.process_batch([
+      { type: "modify", target_text: "Alpha", new_text: "Intro Alpha" },
+    ]);
+
+    const out = await doc.save();
+    const clean = await extractTextFromBuffer(out, true);
+    expect(clean).toContain("Intro Alpha beta gamma");
+  });
+});