@adeu/core 1.28.0 → 1.29.0

package/package.json

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

package/src/diff.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { trim_common_context, generate_edits_from_text, create_word_patch_diff } from './diff.js';
+import { trim_common_context, generate_edits_from_text, create_word_patch_diff, generate_edits_via_paragraph_alignment } from './diff.js';
 
 describe('Diff Logic & Context Trimming', () => {
   it('handles basic prefix and suffix', () => {
@@ -71,4 +71,11 @@ describe('Diff Logic & Context Trimming', () => {
     expect(diff).toContain("+ Corporation");
     expect(diff).toContain(" This agreement is made between the"); // Within 40-char context window so no truncation
   });
+
+  it('handles trailing newline and whitespace safely in paragraph alignment', () => {
+    const original = "This is a single paragraph of the draft.";
+    const modified = "This is a single paragraph of the draft.\n";
+    const edits = generate_edits_via_paragraph_alignment(original, modified);
+    expect(edits.length).toBe(0);
+  });
 });

package/src/diff.ts

@@ -544,6 +544,12 @@ export function generate_edits_via_paragraph_alignment(
   original_text: string,
   modified_text: string,
 ): ModifyText[] {
+  // Normalize trailing whitespace/newlines in modified_text to match original_text
+  const orig_stripped = original_text.trimEnd();
+  const orig_ws = original_text.slice(orig_stripped.length);
+  const mod_stripped = modified_text.trimEnd();
+  modified_text = mod_stripped + orig_ws;
+
   const orig_paragraphs = original_text.split("\n\n");
   const mod_paragraphs = modified_text.split("\n\n");
 

package/src/engine.bugs.test.ts

@@ -568,4 +568,53 @@ describe("Resolved Bugs Core Engine Verification", () => {
     expect(caught.name).toBe("BatchValidationError");
     expect(caught.message).toContain("Invalid change format");
   });
+
+  it("BUG-REPRO: accept_all_revisions returns counts of accepted changes and removed comments", async () => {
+    const doc = await createTestDocument();
+    addParagraph(doc, "This is a test document.");
+    const engine = new RedlineEngine(doc);
+
+    engine.process_batch([
+      {
+        type: "modify",
+        target_text: "document",
+        new_text: "dossier",
+        comment: "Review note to be stripped",
+      },
+    ]);
+
+    const stats = engine.accept_all_revisions() as any;
+
+    expect(stats).toBeDefined();
+    expect(stats.accepted_insertions).toBe(1);
+    expect(stats.accepted_deletions).toBe(1);
+    expect(stats.accepted_formatting).toBe(0);
+    // Counted from comment bodies this call actually deleted, not from the
+    // document's comment total — the two coincide here, but see below.
+    expect(stats.removed_comments).toBe(1);
+  });
+
+  it("BUG-REPRO: removed_comments does not count comments it deliberately keeps", async () => {
+    const doc = await createTestDocument();
+    addParagraph(doc, "This is a test document.");
+    const engine = new RedlineEngine(doc);
+
+    engine.process_batch([
+      {
+        type: "modify",
+        target_text: "document",
+        new_text: "dossier",
+        comment: "Review note",
+      },
+    ]);
+
+    // A different reviewer now opens the redlined document. The existing
+    // comment is foreign to them, so it keeps its BODY by design (only the
+    // anchor is detached) and must not be reported as removed.
+    const other = new RedlineEngine(doc);
+    other.author = "Someone Else";
+    const stats = other.accept_all_revisions() as any;
+
+    expect(stats.removed_comments).toBe(0);
+  });
 });

package/src/engine.tables.test.ts

@@ -265,4 +265,35 @@ describe("Table Interop & Engine (Node.js Port)", () => {
     expect(errors[0]).toContain('Did you mean the literal "( x )"');
     expect(errors[0]).toContain("drop the ^/$ anchors");
   });
+
+  it("compiled report includes type for structural table operations", async () => {
+    const doc = await createTestDocument();
+    const tbl = addTable(doc, 2, 2);
+    setCellText(tbl, 0, 0, "Row1 Col1");
+    setCellText(tbl, 0, 1, "Row1 Col2");
+    setCellText(tbl, 1, 0, "Row2 Col1");
+    setCellText(tbl, 1, 1, "Row2 Col2");
+
+    const buf = await doc.save();
+    const midDoc = await DocumentObject.load(buf);
+    const engine = new RedlineEngine(midDoc);
+
+    const stats = engine.process_batch([
+      {
+        type: "insert_row",
+        target_text: "Row1 Col1",
+        position: "below",
+        cells: ["NewRow Col1", "NewRow Col2"],
+      } as InsertTableRow,
+      {
+        type: "delete_row",
+        target_text: "Row2 Col1",
+      } as DeleteTableRow,
+    ]);
+
+    expect(stats.edits_applied).toBe(2);
+    expect(stats.edits).toHaveLength(2);
+    expect(stats.edits[0].type).toBe("insert_row");
+    expect(stats.edits[1].type).toBe("delete_row");
+  });
 });

package/src/engine.ts

@@ -905,10 +905,30 @@ export class RedlineEngine {
       }
     }
 
+    // Pre-count revisions before mutating. Unit is REVISION ELEMENTS, matching
+    // the Python engine and sanitize's count_tracked_changes so no two surfaces
+    // report different totals for one document.
+    let accepted_insertions = 0;
+    let accepted_deletions = 0;
+    let accepted_formatting = 0;
+    for (const root_element of parts_to_process) {
+      accepted_insertions += findAllDescendants(root_element, "w:ins").length;
+      accepted_deletions += findAllDescendants(root_element, "w:del").length;
+      for (const tag of ["w:rPrChange", "w:pPrChange", "w:sectPrChange"]) {
+        accepted_formatting += findAllDescendants(root_element, tag).length;
+      }
+    }
+
+    // Counted as it happens below, not pre-read from the comments part: this
+    // method only deletes the bodies of OUR OWN comments wrapping a resolved
+    // revision (foreign ones keep their body by design), so the document's
+    // comment total would claim removals that never happened.
+    let removed_comments = 0;
+
     for (const root_element of parts_to_process) {
       const insNodes = findAllDescendants(root_element, "w:ins");
       for (const ins of insNodes) {
-        this._clean_wrapping_comments(ins);
+        removed_comments += this._clean_wrapping_comments(ins);
         const parent = ins.parentNode as Element | null;
         if (!parent) continue;
 
@@ -956,8 +976,8 @@ export class RedlineEngine {
             if (has_content) {
               rPr.removeChild(delMark);
             } else {
-              this._clean_wrapping_comments(p);
-              this._delete_comments_in_element(p);
+              removed_comments += this._clean_wrapping_comments(p);
+              removed_comments += this._delete_comments_in_element(p);
               if (p.parentNode) {
                 p.parentNode.removeChild(p);
               }
@@ -968,8 +988,8 @@ export class RedlineEngine {
 
       const delNodes = findAllDescendants(root_element, "w:del");
       for (const d of delNodes) {
-        this._clean_wrapping_comments(d);
-        this._delete_comments_in_element(d);
+        removed_comments += this._clean_wrapping_comments(d);
+        removed_comments += this._delete_comments_in_element(d);
         const parent = d.parentNode as Element | null;
         if (parent) {
           if (parent.tagName === "w:trPr") {
@@ -1089,6 +1109,13 @@ export class RedlineEngine {
         }
       }
     }
+
+    return {
+      accepted_insertions,
+      accepted_deletions,
+      accepted_formatting,
+      removed_comments,
+    };
   }
 
   /**
@@ -1985,7 +2012,10 @@ export class RedlineEngine {
     }
     return null;
   }
-  private _clean_wrapping_comments(element: Element) {
+  /** Returns how many comment BODIES were actually deleted (see below: only
+   *  our own are; foreign ones keep their body and lose only the anchor). */
+  private _clean_wrapping_comments(element: Element): number {
+    let deleted = 0;
     let first_node: Element = element;
     while (true) {
       const prev = getPreviousElement(first_node);
@@ -2071,6 +2101,7 @@ export class RedlineEngine {
         const is_own = author !== null && author === this.author;
         if (is_own) {
           this.comments_manager.deleteComment(c_id);
+          deleted++;
         }
         if (s.parentNode) s.parentNode.removeChild(s);
         for (const e of ends_to_remove) {
@@ -2088,14 +2119,18 @@ export class RedlineEngine {
         }
       }
     }
+    return deleted;
   }
 
-  private _delete_comments_in_element(element: Element) {
+  /** Returns how many comment bodies were deleted. */
+  private _delete_comments_in_element(element: Element): number {
+    let deleted = 0;
     const refs = findAllDescendants(element, "w:commentReference");
     for (const ref of refs) {
       const c_id = ref.getAttribute("w:id");
       if (c_id) {
         this.comments_manager.deleteComment(c_id);
+        deleted++;
         for (const tag of ["w:commentRangeStart", "w:commentRangeEnd"]) {
           const nodes = findAllDescendants(this.doc.element, tag);
           for (const node of nodes) {
@@ -2106,6 +2141,7 @@ export class RedlineEngine {
         }
       }
     }
+    return deleted;
   }
 
   public validate_edits(edits: any[], index_offset: number = 0): string[] {
@@ -2893,6 +2929,7 @@ export class RedlineEngine {
             );
             reports_by_input[i] = {
               status: "failed",
+              type: (edit as any).type || "modify",
               target_text: truncate_middle((edit as any).target_text || "", REPORT_ECHO_CAP),
               new_text: truncate_middle(RedlineEngine._report_new_text(edit), REPORT_ECHO_CAP),
               warning: warning,
@@ -2908,6 +2945,7 @@ export class RedlineEngine {
             const previews = this._build_edit_context_previews(edit);
             reports_by_input[i] = {
               status: "applied",
+              type: (edit as any).type || "modify",
               target_text: truncate_middle((edit as any).target_text || "", REPORT_ECHO_CAP),
               new_text: truncate_middle(RedlineEngine._report_new_text(edit), REPORT_ECHO_CAP),
               warning: null,
@@ -2932,6 +2970,7 @@ export class RedlineEngine {
             );
             reports_by_input[i] = {
               status: "failed",
+              type: (edit as any).type || "modify",
               target_text: truncate_middle((edit as any).target_text || "", REPORT_ECHO_CAP),
               new_text: truncate_middle(RedlineEngine._report_new_text(edit), REPORT_ECHO_CAP),
               warning: warning,
@@ -2954,6 +2993,7 @@ export class RedlineEngine {
             if (report.status === "applied") {
               reports_by_input[i] = {
                 status: "failed",
+                type: report.type || "modify",
                 target_text: report.target_text,
                 new_text: report.new_text,
                 warning: null,
@@ -3030,6 +3070,7 @@ export class RedlineEngine {
           }
           edits_reports.push({
             status: success ? "applied" : "failed",
+            type: (edit as any).type || "modify",
             target_text: truncate_middle((edit as any).target_text || "", REPORT_ECHO_CAP),
             new_text: truncate_middle(RedlineEngine._report_new_text(edit), REPORT_ECHO_CAP),
             warning: warning,
@@ -3122,13 +3163,64 @@ export class RedlineEngine {
         }
 
         if (matches.length > 0) {
-          // Record WHICH mapper produced the offset: a clean-view index
-          // resolved against the raw mapper lands rows at the wrong position
-          // once earlier edits in the batch put tracked changes in the
-          // anchor row.
-          edit._resolved_start_idx = matches[0][0];
-          edit._active_mapper_ref = resolved_mapper;
-          resolved_edits.push([edit, null]);
+          const match_mode = edit.match_mode || "strict";
+
+          // We need to resolve matches to unique w:tr elements to deduplicate them.
+          const unique_matches: [number, number][] = [];
+          const seen_trs = new Set<any>();
+
+          for (const match of matches) {
+            const start_idx = match[0];
+            const [anchor_run, anchor_para] = resolved_mapper.get_insertion_anchor(start_idx, false);
+            let target_element: Element | null = null;
+            if (anchor_run) target_element = anchor_run._element;
+            else if (anchor_para) target_element = anchor_para._element;
+
+            let tr: Element | null = target_element;
+            while (tr && tr.tagName !== "w:tr") tr = tr.parentNode as Element;
+
+            if (tr) {
+              if (!seen_trs.has(tr)) {
+                seen_trs.add(tr);
+                unique_matches.push(match);
+              }
+            }
+          }
+
+          if (unique_matches.length > 0) {
+            let matches_to_apply = unique_matches;
+            if (match_mode === "strict" || match_mode === "first") {
+              matches_to_apply = unique_matches.slice(0, 1);
+            }
+
+            if (match_mode === "all" || matches_to_apply.length > 1) {
+              // Create sub-edits for each match so that they are processed as independent operations,
+              // and the occurrences_modified and applied_status are tracked correctly on the parent.
+              for (const m of matches_to_apply) {
+                const sub_edit = {
+                  ...edit,
+                  _resolved_start_idx: m[0],
+                  _active_mapper_ref: resolved_mapper,
+                  _parent_edit_ref: edit,
+                };
+                resolved_edits.push([sub_edit, null]);
+              }
+            } else {
+              // Single match case for non-"all" modes
+              edit._resolved_start_idx = matches_to_apply[0][0];
+              edit._active_mapper_ref = resolved_mapper;
+              resolved_edits.push([edit, null]);
+            }
+          } else {
+            skipped++;
+            edit._applied_status = false;
+            const target_snippet = (edit.target_text || "")
+              .trim()
+              .substring(0, 40);
+            const msg = `- Failed to locate row target: '${target_snippet}...'`;
+            this.skipped_details.push(msg);
+            edit._error_msg = msg;
+          }
         } else {
           skipped++;
           edit._applied_status = false;
@@ -3498,8 +3590,22 @@ export class RedlineEngine {
     let already_resolved = 0;
     const resolved_history = new Map<string, string>(); // id -> resolving action type
 
-    for (let pos = 0; pos < actions.length; pos++) {
-      const action = actions[pos];
+    // Sort actions internally: non-destructive metadata operations (ReplyComment) first,
+    // followed by destructive structural operations (AcceptChange, RejectChange).
+    // Stable sort preserves the original relative ordering, and we preserve `pos`
+    // so diagnostic messages refer to the original array indexes.
+    const sortedActions = actions
+      .map((action, pos) => ({ action, pos }))
+      .sort((a, b) => {
+        const aPri = a.action.type === "reply" ? 0 : 1;
+        const bPri = b.action.type === "reply" ? 0 : 1;
+        if (aPri !== bPri) {
+          return aPri - bPri;
+        }
+        return a.pos - b.pos;
+      });
+
+    for (const { action, pos } of sortedActions) {
       const type = action.type;
       if (type === "reply") {
         const cid = action.target_id.replace("Com:", "");

package/src/ingest.ts

@@ -254,10 +254,27 @@ export function extract_table(
       // via the mapper). We key on the cell's first paragraph w14:paraId, which
       // Word assigns and keeps stable across reads.
       if (!cleanView) {
-        const firstP = cell._element.getElementsByTagName("w:p")[0] as
+        let firstP = cell._element.getElementsByTagName("w:p")[0] as
           | Element
           | undefined;
-        const paraId = firstP ? firstP.getAttribute("w14:paraId") : null;
+        let paraId = firstP ? firstP.getAttribute("w14:paraId") : null;
+        if (!paraId && (!cell_content || cell_content.trim() === "")) {
+          if (!firstP) {
+            const xmlDoc = cell._element.ownerDocument!;
+            firstP = xmlDoc.createElement("w:p");
+            cell._element.appendChild(firstP);
+          }
+          const allPs = Array.from(cell._element.ownerDocument!.getElementsByTagName("w:p"));
+          const index = allPs.indexOf(firstP);
+          let hash = 2166136261;
+          const str = `fallback-paraId-${index}`;
+          for (let i = 0; i < str.length; i++) {
+            hash ^= str.charCodeAt(i);
+            hash += (hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24);
+          }
+          paraId = (hash >>> 0).toString(16).toUpperCase().padStart(8, '0');
+          firstP.setAttribute("w14:paraId", paraId);
+        }
         if (paraId) {
           const space_pad = cell_content ? " " : "";
           const anchor = `${space_pad}{#cell:${paraId}}`;

package/src/mapper.ts

@@ -348,10 +348,28 @@ export class DocumentMapper {
         // can resolve "write into this cell" even when the cell is empty
         // (pPr-only paragraph with no run).
         if (!this.clean_view && !this.original_view) {
-          const firstP = cell._element.getElementsByTagName("w:p")[0] as
+          let firstP = cell._element.getElementsByTagName("w:p")[0] as
             | Element
             | undefined;
-          const paraId = firstP ? firstP.getAttribute("w14:paraId") : null;
+          let paraId = firstP ? firstP.getAttribute("w14:paraId") : null;
+          const is_empty = current === cell_start;
+          if (!paraId && is_empty) {
+            if (!firstP) {
+              const xmlDoc = cell._element.ownerDocument!;
+              firstP = xmlDoc.createElement("w:p");
+              cell._element.appendChild(firstP);
+            }
+            const allPs = Array.from(cell._element.ownerDocument!.getElementsByTagName("w:p"));
+            const index = allPs.indexOf(firstP);
+            let hash = 2166136261;
+            const str = `fallback-paraId-${index}`;
+            for (let i = 0; i < str.length; i++) {
+              hash ^= str.charCodeAt(i);
+              hash += (hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24);
+            }
+            paraId = (hash >>> 0).toString(16).toUpperCase().padStart(8, '0');
+            firstP.setAttribute("w14:paraId", paraId);
+          }
           if (paraId && firstP) {
             // Zero-width span bound to the empty cell paragraph: gives
             // get_insertion_anchor a paragraph to land on. Placed at the anchor

package/src/repro_agy_bug.test.ts

@@ -0,0 +1,108 @@
+import { describe, it, expect } from "vitest";
+import { createTestDocument, addTable, setCellText } from "./test-utils.js";
+import { extractTextFromBuffer } from "./ingest.js";
+import { RedlineEngine } from "./engine.js";
+
+describe("QA Regression Test - Finding F1: Missing cell anchors for empty table cells", () => {
+  it("should generate and render stable cell anchors for empty table cells", async () => {
+    // 1. Build a document containing a table with empty/blank cells.
+    // In this document, the cells are constructed programmatically without any pre-existing w14:paraId.
+    const doc = await createTestDocument();
+    const tbl = addTable(doc, 1, 2);
+    setCellText(tbl, 0, 0, "Hello");
+    // Cell (0,1) is left completely empty, with no pre-existing w14:paraId attribute on its w:p element.
+
+    const buf = await doc.save();
+
+    // 2. Ingest/extract text from the document.
+    const text = await extractTextFromBuffer(buf, false);
+
+    // 3. Assert correct behavior.
+    // The empty cell must still render a trailing {#cell:<id>} anchor so that it can be targeted for edits.
+    // We expect the output to be formatted like: Hello | {#cell:<id>}
+    const cellAnchorRegex = /Hello \| \{#cell:[0-9a-fA-F]{8}\}/;
+    expect(text).toSatisfy((val: string) => {
+      return cellAnchorRegex.test(val);
+    }, `Expected extracted text to contain a cell anchor for the empty cell, but got:\n"${text}"`);
+  });
+});
+
+describe("QA Regression Test - Top Bug: match_mode='all' fails to affect multiple matches for table row edits", () => {
+  it("should delete all rows containing target_text when match_mode is all", async () => {
+    const doc = await createTestDocument();
+    const tbl = addTable(doc, 3, 3);
+    setCellText(tbl, 0, 0, "ID");
+    setCellText(tbl, 0, 1, "Name");
+    setCellText(tbl, 0, 2, "Notes");
+
+    setCellText(tbl, 1, 0, "1");
+    setCellText(tbl, 1, 1, "Alice");
+    setCellText(tbl, 1, 2, "First record");
+
+    setCellText(tbl, 2, 0, "2");
+    setCellText(tbl, 2, 1, "");
+    setCellText(tbl, 2, 2, "Second record with empty name");
+
+    const buf = await doc.save();
+    const midDoc = await (doc.constructor as any).load(buf);
+
+    const engine = new RedlineEngine(midDoc);
+    const stats = engine.process_batch([
+      {
+        type: "delete_row",
+        target_text: "record",
+        match_mode: "all",
+      } as any,
+    ]);
+
+    expect(stats.edits_applied).toBe(1);
+    expect(stats.occurrences_modified).toBe(2);
+
+    engine.accept_all_revisions();
+    const finalBuf = await midDoc.save();
+    const clean_text = await extractTextFromBuffer(finalBuf, true);
+
+    expect(clean_text).not.toContain("First record");
+    expect(clean_text).not.toContain("Second record with empty name");
+  });
+
+  it("should insert rows adjacent to all rows containing target_text when match_mode is all", async () => {
+    const doc = await createTestDocument();
+    const tbl = addTable(doc, 3, 3);
+    setCellText(tbl, 0, 0, "ID");
+    setCellText(tbl, 0, 1, "Name");
+    setCellText(tbl, 0, 2, "Notes");
+
+    setCellText(tbl, 1, 0, "1");
+    setCellText(tbl, 1, 1, "Alice");
+    setCellText(tbl, 1, 2, "First record");
+
+    setCellText(tbl, 2, 0, "2");
+    setCellText(tbl, 2, 1, "");
+    setCellText(tbl, 2, 2, "Second record with empty name");
+
+    const buf = await doc.save();
+    const midDoc = await (doc.constructor as any).load(buf);
+
+    const engine = new RedlineEngine(midDoc);
+    const stats = engine.process_batch([
+      {
+        type: "insert_row",
+        target_text: "record",
+        match_mode: "all",
+        position: "below",
+        cells: ["NEW_ID", "NEW_NAME", "NEW_NOTES"],
+      } as any,
+    ]);
+
+    expect(stats.edits_applied).toBe(1);
+    expect(stats.occurrences_modified).toBe(2);
+
+    engine.accept_all_revisions();
+    const finalBuf = await midDoc.save();
+    const clean_text = await extractTextFromBuffer(finalBuf, true);
+
+    const occurrences = (clean_text.match(/NEW_ID \| NEW_NAME \| NEW_NOTES/g) || []).length;
+    expect(occurrences).toBe(2);
+  });
+});

package/src/sanitize/core.ts

@@ -29,7 +29,7 @@ export async function finalize_document(doc: DocumentObject, options: FinalizeOp
 
     if (total > 0 && !options.accept_all) {
       report.status = 'blocked';
-      report.blocked_reason = `Document contains ${total} unresolved tracked changes (${counts[0]} insertions, ${counts[1]} deletions, ${counts[2]} formatting). Review in Word first, or set accept_all=true.`;
+      report.blocked_reason = `Document contains ${total} unresolved tracked changes (${counts[0]} insertions, ${counts[1]} deletions, ${counts[2]} formatting). Review in Word first, set accept_all=true, or set sanitize_mode='keep-markup'.`;
       return { reportText: report.render() };
     }
 

package/src/sanitize/sanitize.test.ts

@@ -220,6 +220,7 @@ describe("Finalize Document (Core)", () => {
 
     expect(res.reportText).toContain("BLOCKED:");
     expect(res.reportText).toContain("unresolved tracked changes");
+    expect(res.reportText).toContain("sanitize_mode='keep-markup'");
   });
 
   describe("Resolved Bugs Sanitize Parity Verification", () => {