@adeu/core 1.26.0 → 1.27.0

package/package.json

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

package/src/engine.ts

@@ -1423,6 +1423,12 @@ export class RedlineEngine {
     // authoritative: strip inherited bold/italic from the anchor style
     // (QA 2026-07-19 F-02).
     suppress_emphasis: boolean = false,
+    // True when the caller will attach the insertion BEFORE the anchor
+    // (paragraph-start insertions): the anchor itself then belongs to the
+    // relocating suffix (hunt-profile counterexample, 2026-07-19 —
+    // "00." + insert "0.\n\n0 " must read "0.\n\n0 00.", never
+    // "0.00.\n\n0 "). Mirrors the Python engine.
+    insert_before: boolean = false,
   ): {
     first_node: Element | null;
     last_p: Element | null;
@@ -1459,12 +1465,21 @@ export class RedlineEngine {
     // DOM, and the insertion lands immediately after it, so its following
     // child-of-paragraph siblings are exactly the suffix.
     const suffix_nodes: Element[] = [];
-    const pos_source =
+    const relocatable = new Set(["w:r", "w:ins", "w:del"]);
+    // insert_before with a RUN anchor: the insertion precedes the anchor, so
+    // the anchor run itself is part of the suffix. (The explicit
+    // positional_anchor_el is only passed by flows that insert AFTER it.)
+    const pos_from_positional =
       positional_anchor_el && positional_anchor_el.parentNode
         ? positional_anchor_el
-        : anchor_run !== null && anchor_run._element.parentNode
-          ? anchor_run._element
-          : null;
+        : null;
+    const pos_from_anchor_run =
+      anchor_run !== null && anchor_run._element.parentNode
+        ? anchor_run._element
+        : null;
+    const pos_source = pos_from_positional ?? pos_from_anchor_run;
+    const suffix_includes_anchor =
+      insert_before && pos_from_positional === null && pos_from_anchor_run !== null;
     if (current_p !== null && pos_source !== null) {
       let pos_anchor: Element | null = pos_source;
       while (pos_anchor && pos_anchor.parentNode !== current_p) {
@@ -1475,8 +1490,9 @@ export class RedlineEngine {
         }
       }
       if (pos_anchor) {
-        const relocatable = new Set(["w:r", "w:ins", "w:del"]);
-        let nxt = pos_anchor.nextSibling;
+        let nxt: Node | null = suffix_includes_anchor
+          ? pos_anchor
+          : pos_anchor.nextSibling;
         while (nxt) {
           if (nxt.nodeType === 1 && relocatable.has((nxt as Element).tagName)) {
             suffix_nodes.push(nxt as Element);
@@ -1484,6 +1500,20 @@ export class RedlineEngine {
           nxt = nxt.nextSibling;
         }
       }
+    } else if (current_p !== null && insert_before) {
+      // No attached anchor run at all (paragraph-anchored insertion at
+      // paragraph START): everything in the host paragraph follows the
+      // insertion point, so it all relocates (mirrors the Python engine).
+      let child = current_p.firstChild;
+      while (child) {
+        if (
+          child.nodeType === 1 &&
+          relocatable.has((child as Element).tagName)
+        ) {
+          suffix_nodes.push(child as Element);
+        }
+        child = child.nextSibling;
+      }
     }
 
     // Drop the trailing empty line ONLY when there is no suffix to relocate.
@@ -2523,6 +2553,60 @@ export class RedlineEngine {
 
   public validate_review_actions(actions: any[]): string[] {
     const errors: string[] = [];
+
+    // Document-context-free shape checks (QA 2026-07-19 v8 F-07), mirroring
+    // Python's validate_review_action_batch: blank replies render as empty
+    // Word comment bubbles; a duplicated or conflicting accept/reject on one
+    // target_id either double-counts as "applied" or contradicts itself.
+    // Distinct IDs one action resolves as a group (a modification's del+ins
+    // pair) stay legitimate, as do DIFFERENT replies to the same comment.
+    const seen_resolutions = new Map<string, [number, string]>();
+    const seen_replies = new Set<string>();
+    for (let i = 0; i < actions.length; i++) {
+      const action = actions[i];
+      const type = action.type;
+      const target_id = action.target_id ?? "";
+      if (type === "reply") {
+        if (!String(action.text ?? "").trim()) {
+          errors.push(
+            `- Action ${i + 1} Failed: reply text for ${target_id} is empty or ` +
+              `whitespace-only. Word would show a blank comment bubble — provide the ` +
+              `reply content in 'text'.`,
+          );
+          continue;
+        }
+        const reply_key = `${target_id}${String(action.text).trim()}`;
+        if (seen_replies.has(reply_key)) {
+          errors.push(
+            `- Action ${i + 1} Failed: duplicate reply — this batch already replies to ` +
+              `${target_id} with the same text. Remove the duplicate action.`,
+          );
+        }
+        seen_replies.add(reply_key);
+      } else if (type === "accept" || type === "reject") {
+        const prior = seen_resolutions.get(target_id);
+        if (prior !== undefined) {
+          const [first_idx, first_type] = prior;
+          if (first_type === type) {
+            errors.push(
+              `- Action ${i + 1} Failed: duplicate action — Action ${first_idx + 1} in this ` +
+                `batch already applies '${type}' to ${target_id}. A change can only be ` +
+                `resolved once; remove the duplicate action.`,
+            );
+          } else {
+            errors.push(
+              `- Action ${i + 1} Failed: conflicting actions — Action ${first_idx + 1} in ` +
+                `this batch applies '${first_type}' to ${target_id}, but this action applies ` +
+                `'${type}'. Decide the outcome and keep exactly one of them.`,
+            );
+          }
+        } else {
+          seen_resolutions.set(target_id, [i, type]);
+        }
+      }
+    }
+    if (errors.length > 0) return errors;
+
     for (let i = 0; i < actions.length; i++) {
       const action = actions[i];
       const type = action.type;
@@ -4161,6 +4245,9 @@ export class RedlineEngine {
         ins_id!,
         null,
         suppress_emphasis,
+        // Paragraph-start insertions attach BEFORE the anchor (see
+        // before_anchor below): the suffix relocation must know.
+        start_idx === 0,
       );
 
       if (!result.first_node) return false;

package/src/mapper.ts

@@ -1172,8 +1172,16 @@ export class DocumentMapper {
     const first_real_span = real_spans[0];
     let start_split_adjustment = 0;
 
+    // A range may START on a virtual span (word-diff hunks absorb a style
+    // marker adjacent to real changes, e.g. the `**` closing a bold run).
+    // Virtual characters have no physical width: clamp to the first real
+    // span's start or the subtraction goes negative and the split point
+    // lands INSIDE the preceding run's kept text — the "**The Suppli**"
+    // partial-word artifact (QA 2026-07-19 v8 F-04).
     const local_start =
-      start_idx - first_real_span.start + (first_real_span.run_offset || 0);
+      Math.max(start_idx, first_real_span.start) -
+      first_real_span.start +
+      (first_real_span.run_offset || 0);
     if (local_start > 0) {
       const split_source = working_runs[0];
       const [, right_run] = this._split_run_at_index(

package/src/repro_qa_report_v8.test.ts

@@ -0,0 +1,265 @@
+// FILE: node/packages/core/src/repro_qa_report_v8.test.ts
+/**
+ * Node-engine repro tests for the 2026-07-19 black-box QA and UX report on
+ * 1.26.0 (adeu 1.26.0+0741eaf). Mirrors python/tests/test_repro_qa_report_v8.py
+ * for the findings that live in the shared core engine:
+ *
+ *   F-04  replacing a full sentence that crosses bold/italic formatting runs
+ *         leaves a partial word bold (`**The Suppli** must perform ...`):
+ *         the word-diff hunk absorbs the closing `**` marker, the resolved
+ *         range starts on a virtual span, and the run-local split offset
+ *         underflows into the preceding run's kept text
+ *   F-07  review-action validation permits blank replies and duplicate /
+ *         conflicting accept-reject pairs on one target_id
+ *
+ * Every test fails against the commit preceding its fix.
+ */
+
+import { describe, it, expect } from "vitest";
+import { createTestDocument, addParagraph } from "./test-utils.js";
+import { DocumentObject } from "./docx/bridge.js";
+import { RedlineEngine, BatchValidationError } from "./engine.js";
+import { _extractTextFromDoc, extractTextFromBuffer } from "./ingest.js";
+
+function addStyledRun(
+  p: Element,
+  text: string,
+  style: { bold?: boolean; italic?: boolean; underline?: boolean } = {},
+): Element {
+  const xmlDoc = p.ownerDocument!;
+  const r = xmlDoc.createElement("w:r");
+  if (style.bold || style.italic || style.underline) {
+    const rPr = xmlDoc.createElement("w:rPr");
+    if (style.bold) rPr.appendChild(xmlDoc.createElement("w:b"));
+    if (style.italic) rPr.appendChild(xmlDoc.createElement("w:i"));
+    if (style.underline) {
+      const u = xmlDoc.createElement("w:u");
+      u.setAttribute("w:val", "single");
+      rPr.appendChild(u);
+    }
+    r.appendChild(rPr);
+  }
+  const t = xmlDoc.createElement("w:t");
+  t.textContent = text;
+  if (text !== text.trim()) t.setAttribute("xml:space", "preserve");
+  r.appendChild(t);
+  p.appendChild(r);
+  return r;
+}
+
+function addEmptyParagraph(doc: DocumentObject): Element {
+  const xmlDoc = doc.element.ownerDocument!;
+  const p = xmlDoc.createElement("w:p");
+  doc.element.appendChild(p);
+  return p;
+}
+
+/** The QA report's F-04 fixture: bold "The Supplier ", italic
+ * "shall provide ", underlined remainder — one sentence, three runs. */
+async function buildCrossRunDoc(): Promise<DocumentObject> {
+  const doc = await createTestDocument();
+  const p = addEmptyParagraph(doc);
+  addStyledRun(p, "The Supplier ", { bold: true });
+  addStyledRun(p, "shall provide ", { italic: true });
+  addStyledRun(p, "the Services with reasonable skill and care.", {
+    underline: true,
+  });
+  return doc;
+}
+
+function cleanText(doc: DocumentObject): string {
+  return _extractTextFromDoc(doc, {
+    cleanView: true,
+    includeAppendix: false,
+  }) as string;
+}
+
+/** A document carrying exactly one tracked modification (Chg:1 + Chg:2). */
+async function buildTrackedChangeDoc(): Promise<DocumentObject> {
+  const doc = await createTestDocument();
+  addParagraph(doc, "Payment is due in 30 days.");
+  addParagraph(doc, "Second paragraph here.");
+  const engine = new RedlineEngine(doc);
+  engine.apply_edits([
+    { type: "modify", target_text: "30 days", new_text: "60 days" },
+  ]);
+  return DocumentObject.load(await doc.save());
+}
+
+/** A document carrying exactly one comment; returns [doc, "Com:<id>"]. */
+async function buildCommentDoc(): Promise<[DocumentObject, string]> {
+  const doc = await createTestDocument();
+  addParagraph(doc, "Alpha beta gamma.");
+  addParagraph(doc, "Delta epsilon.");
+  const engine = new RedlineEngine(doc);
+  engine.process_batch([
+    {
+      type: "modify",
+      target_text: "Alpha beta gamma.",
+      new_text: "Alpha beta gamma.",
+      comment: "Please review.",
+    },
+  ]);
+  const buf = await doc.save();
+  const reloaded = await DocumentObject.load(buf);
+  const projected = await extractTextFromBuffer(buf);
+  const m = projected.match(/\[Com:(\d+)/);
+  expect(m, `expected a comment id in ${projected}`).toBeTruthy();
+  return [reloaded, `Com:${m![1]}`];
+}
+
+// ---------------------------------------------------------------------------
+// F-04: full-span replacements across formatting runs keep words whole
+// ---------------------------------------------------------------------------
+
+describe("QA v8 F-04: cross-run full-span replacement fidelity", () => {
+  const TARGET =
+    "The Supplier shall provide the Services with reasonable skill and care.";
+  const NEW = "The Supplier must perform the Services professionally.";
+
+  it("leaves no partial-word bold after the replacement", async () => {
+    const doc = await buildCrossRunDoc();
+    const engine = new RedlineEngine(doc);
+    const stats = engine.process_batch([
+      { type: "modify", target_text: TARGET, new_text: NEW },
+    ]);
+    expect(stats.edits_applied).toBe(1);
+
+    const clean = cleanText(doc);
+    expect(clean).not.toContain("**The Suppli**");
+    expect(clean).not.toContain("Suppli**");
+    expect(clean.trim()).toBe(
+      "**The Supplier** must perform the Services professionally.",
+    );
+  });
+
+  it("accepted document matches the clean view", async () => {
+    const doc = await buildCrossRunDoc();
+    const engine = new RedlineEngine(doc);
+    engine.process_batch([
+      { type: "modify", target_text: TARGET, new_text: NEW },
+    ]);
+    engine.accept_all_revisions();
+    const accepted = _extractTextFromDoc(doc, {
+      cleanView: false,
+      includeAppendix: false,
+    }) as string;
+    expect(accepted.trim()).toBe(
+      "**The Supplier** must perform the Services professionally.",
+    );
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Hunt-profile counterexample (python property suite, 2026-07-19): a
+// paragraph-splitting insertion at paragraph START must relocate the host
+// paragraph's content into the LAST new paragraph. Deterministic pin,
+// mirrored here because both engines shared the suffix-relocation logic.
+// ---------------------------------------------------------------------------
+
+describe("QA v8: paragraph-start splitting insertion", () => {
+  it("relocates the host paragraph content into the last new paragraph", async () => {
+    const doc = await createTestDocument();
+    addParagraph(doc, "00.");
+    const engine = new RedlineEngine(doc);
+    const edit: any = {
+      type: "modify",
+      target_text: "",
+      new_text: "0.\n\n0 ",
+      _match_start_index: 0,
+    };
+    engine.apply_edits([edit]);
+    engine.accept_all_revisions();
+    const final = _extractTextFromDoc(doc, {
+      cleanView: true,
+      includeAppendix: false,
+    }) as string;
+    expect(final.trim()).toBe("0.\n\n0 00.");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// F-07: blank replies and duplicate review actions are rejected
+// ---------------------------------------------------------------------------
+
+describe("QA v8 F-07: review-action validation", () => {
+  it("rejects a blank reply", async () => {
+    const [doc, comId] = await buildCommentDoc();
+    const engine = new RedlineEngine(doc);
+    expect(() =>
+      engine.process_batch([{ type: "reply", target_id: comId, text: "   " }]),
+    ).toThrowError(BatchValidationError);
+    try {
+      engine.process_batch([{ type: "reply", target_id: comId, text: "   " }]);
+    } catch (e: any) {
+      expect(e.errors.join("\n").toLowerCase()).toContain("empty");
+    }
+  });
+
+  it("rejects a duplicate accept of the same target_id", async () => {
+    const doc = await buildTrackedChangeDoc();
+    const engine = new RedlineEngine(doc);
+    try {
+      engine.process_batch([
+        { type: "accept", target_id: "Chg:1" },
+        { type: "accept", target_id: "Chg:1" },
+      ]);
+      expect.unreachable("duplicate accept must be rejected");
+    } catch (e: any) {
+      expect(e).toBeInstanceOf(BatchValidationError);
+      expect(e.errors.join("\n").toLowerCase()).toContain("duplicate");
+    }
+  });
+
+  it("rejects conflicting accept + reject on one target_id", async () => {
+    const doc = await buildTrackedChangeDoc();
+    const engine = new RedlineEngine(doc);
+    try {
+      engine.process_batch([
+        { type: "accept", target_id: "Chg:1" },
+        { type: "reject", target_id: "Chg:1" },
+      ]);
+      expect.unreachable("conflicting actions must be rejected");
+    } catch (e: any) {
+      expect(e).toBeInstanceOf(BatchValidationError);
+      expect(e.errors.join("\n").toLowerCase()).toContain("conflict");
+    }
+  });
+
+  it("rejects a duplicated identical reply", async () => {
+    const [doc, comId] = await buildCommentDoc();
+    const engine = new RedlineEngine(doc);
+    try {
+      engine.process_batch([
+        { type: "reply", target_id: comId, text: "Same reply." },
+        { type: "reply", target_id: comId, text: "Same reply." },
+      ]);
+      expect.unreachable("duplicate identical reply must be rejected");
+    } catch (e: any) {
+      expect(e).toBeInstanceOf(BatchValidationError);
+      expect(e.errors.join("\n").toLowerCase()).toContain("duplicate");
+    }
+  });
+
+  it("still allows distinct replies to the same comment", async () => {
+    const [doc, comId] = await buildCommentDoc();
+    const engine = new RedlineEngine(doc);
+    const stats = engine.process_batch([
+      { type: "reply", target_id: comId, text: "First reply." },
+      { type: "reply", target_id: comId, text: "Second reply." },
+    ]);
+    expect(stats.actions_applied).toBe(2);
+    expect(stats.actions_skipped).toBe(0);
+  });
+
+  it("still allows accepting the del+ins pair of one modification", async () => {
+    const doc = await buildTrackedChangeDoc();
+    const engine = new RedlineEngine(doc);
+    const stats = engine.process_batch([
+      { type: "accept", target_id: "Chg:1" },
+      { type: "accept", target_id: "Chg:2" },
+    ]);
+    expect(stats.actions_skipped).toBe(0);
+    expect(cleanText(doc)).toContain("60 days");
+  });
+});