@adeu/core 1.17.2 → 1.18.0

package/src/reject_and_nested_redline.test.ts

@@ -0,0 +1,137 @@
+/**
+ * Canonical track-change semantics for editing inside another author's pending
+ * insertion, plus reject_all_revisions round-trips. Mirrors the Python suite
+ * python/tests/test_reject_and_nested_redline.py (Python is canonical).
+ *
+ * When an author edits/deletes text inside another author's still-pending
+ * <w:ins>, the deletion is NESTED inside that <w:ins> and the replacement is a
+ * SIBLING after it (splitting the insertion if the edit is mid-insertion);
+ * <w:ins> is never nested in <w:ins>. This preserves authorship and makes
+ * reject-all revert the contingent text to nothing rather than promoting an
+ * unaccepted proposal to committed body text.
+ */
+import { describe, it, expect } from "vitest";
+import { createTestDocument, addParagraph } from "./test-utils.js";
+import { RedlineEngine } from "./engine.js";
+import { extractTextFromBuffer } from "./ingest.js";
+
+function foreignInsDoc(doc: any) {
+  const xmlDoc = doc.element.ownerDocument!;
+  const p = addParagraph(doc, "The party shall provide ");
+  const ins = xmlDoc.createElement("w:ins");
+  ins.setAttribute("w:id", "201");
+  ins.setAttribute("w:author", "Supplier's Counsel");
+  const r = xmlDoc.createElement("w:r");
+  const t = xmlDoc.createElement("w:t");
+  t.textContent = "written notice";
+  r.appendChild(t);
+  ins.appendChild(r);
+  p.appendChild(ins);
+  const r2 = xmlDoc.createElement("w:r");
+  const t2 = xmlDoc.createElement("w:t");
+  t2.textContent = " within 30 days.";
+  r2.appendChild(t2);
+  p.appendChild(r2);
+  return p;
+}
+
+async function cleanText(doc: any): Promise<string> {
+  return await extractTextFromBuffer(await doc.save());
+}
+
+describe("Canonical nesting + reject round-trips", () => {
+  it("modify inside a foreign insertion nests del and emits a sibling ins (no ins-in-ins)", async () => {
+    const doc = await createTestDocument();
+    const p = foreignInsDoc(doc);
+    const engine = new RedlineEngine(doc, "Reviewer AI");
+    const res = engine.process_batch(
+      [{ type: "modify", target_text: "written notice", new_text: "email notification" }] as any,
+      false,
+    );
+    expect(res.edits_applied).toBe(1);
+    expect(res.edits_skipped).toBe(0);
+
+    // del nested inside Supplier's <w:ins>; no <w:ins> nested in <w:ins>.
+    const insNodes = Array.from(p.getElementsByTagName("w:ins"));
+    const supplierIns = insNodes.find(
+      (i) => i.getAttribute("w:author") === "Supplier's Counsel",
+    )!;
+    expect(supplierIns).toBeTruthy();
+    expect(supplierIns.getElementsByTagName("w:del").length).toBeGreaterThan(0);
+    for (const i of insNodes) {
+      expect(i.getElementsByTagName("w:ins").length).toBe(0);
+    }
+    // Reviewer's replacement insertion exists as a separate node.
+    expect(
+      insNodes.some(
+        (i) =>
+          i.getAttribute("w:author") === "Reviewer AI" &&
+          (i.textContent || "").includes("email notification"),
+      ),
+    ).toBe(true);
+  });
+
+  it("accept-all and reject-all round-trip correctly for a foreign-ins modify", async () => {
+    const accDoc = await createTestDocument();
+    foreignInsDoc(accDoc);
+    const ae = new RedlineEngine(accDoc, "Reviewer AI");
+    ae.process_batch(
+      [{ type: "modify", target_text: "written notice", new_text: "email notification" }] as any,
+      false,
+    );
+    ae.accept_all_revisions();
+    expect(await cleanText(accDoc)).toContain(
+      "The party shall provide email notification within 30 days.",
+    );
+
+    const rejDoc = await createTestDocument();
+    foreignInsDoc(rejDoc);
+    const re = new RedlineEngine(rejDoc, "Reviewer AI");
+    re.process_batch(
+      [{ type: "modify", target_text: "written notice", new_text: "email notification" }] as any,
+      false,
+    );
+    re.reject_all_revisions();
+    const rejected = await cleanText(rejDoc);
+    // Reject reverts to the true baseline: the pending insertion vanishes.
+    expect(rejected).not.toContain("written notice");
+    expect(rejected).not.toContain("email notification");
+    expect(rejected).toContain("The party shall provide  within 30 days.");
+  });
+
+  it("insertion inside a foreign ins splits (no ins-in-ins) and round-trips", async () => {
+    const doc = await createTestDocument();
+    const p = foreignInsDoc(doc);
+    const e = new RedlineEngine(doc, "Reviewer AI");
+    // A modify that trims to a pure INSERTION inside the foreign <w:ins>.
+    const res = e.process_batch(
+      [{ type: "modify", target_text: "written notice", new_text: "written notice please" }] as any,
+      false,
+    );
+    expect(res.edits_applied).toBe(1);
+    for (const i of Array.from(p.getElementsByTagName("w:ins"))) {
+      expect(i.getElementsByTagName("w:ins").length).toBe(0);
+    }
+
+    const ad = await createTestDocument();
+    foreignInsDoc(ad);
+    const ae = new RedlineEngine(ad, "Reviewer AI");
+    ae.process_batch(
+      [{ type: "modify", target_text: "written notice", new_text: "written notice please" }] as any,
+      false,
+    );
+    ae.accept_all_revisions();
+    expect(await cleanText(ad)).toContain(
+      "The party shall provide written notice please within 30 days.",
+    );
+  });
+
+  it("reject-all restores the original for an own-author edit", async () => {
+    const doc = await createTestDocument();
+    addParagraph(doc, "The cat sat.");
+    const e = new RedlineEngine(doc, "Z");
+    e.process_batch([{ type: "modify", target_text: "cat", new_text: "dog" }] as any, false);
+    e.reject_all_revisions();
+    expect(await cleanText(doc)).toContain("The cat sat.");
+  });
+});

package/src/repro.report.test.ts

@@ -57,10 +57,10 @@ describe("Webinar Report Bug Reproductions", () => {
     expect(res.edits_skipped).toBe(0);
   });
 
-  it("Bug 2: Revision History Lockouts (Active Insertion Collisions)", async () => {
+  it("Bug 2: editing across a foreign author's insertion boundary is refused (provenance-safe)", async () => {
     const doc = await createTestDocument();
     const xmlDoc = doc.element.ownerDocument!;
-    
+
     const p = addParagraph(doc, "The party shall provide ");
     const ins = xmlDoc.createElement("w:ins");
     ins.setAttribute("w:id", "123");
@@ -78,20 +78,22 @@ describe("Webinar Report Bug Reproductions", () => {
     suffixRun.appendChild(suffixText);
     p.appendChild(suffixRun);
 
-    // Create an engine with a different user name to trigger co-authoring lockout
     const engine = new RedlineEngine(doc, "Reviewer");
 
-    // Standard edit targeting the paragraph text containing the active insertion
+    // The target STRADDLES Supplier's Counsel's pending <w:ins> boundary
+    // (foreign-inserted "written notice" + plain " within 30 days."). Canonical
+    // behavior is to REFUSE rather than silently lift the foreign insertion into
+    // committed text (which would launder another author's pending proposal and
+    // erase their provenance). The agent must accept that change first, or scope
+    // the edit within / outside the insertion. (Matches the Python engine.)
     const edit = {
       type: "modify",
       target_text: "written notice within 30 days.",
       new_text: "notice within 15 business days.",
     };
-
-    // Under normal collaborative conditions, this edit should succeed.
-    // However, on the current unpatched codebase, the dry-run engine aborts with a BatchValidationError.
-    const res = engine.process_batch([edit as any], true);
-    expect(res.edits_applied).toBe(1);
+    expect(() => engine.process_batch([edit as any], false)).toThrow(
+      /active insertion from another author/,
+    );
   });
 
   it("Bug 3: Table Layout Ambiguity and Markdown Loss of Fidelity", async () => {

package/src/repro_qa_report_v3.test.ts

@@ -27,7 +27,7 @@ describe("QA Report V3 Defects Reproductions", () => {
     expect(res.edits_skipped).toBe(0);
   });
 
-  it("TC2: NODE dry-run ≠ real write (active-insertion guard) [report F2, F3]", async () => {
+  it("TC2: NODE dry-run == real write for an edit inside a foreign insertion [report F2, F3]", async () => {
     const doc = await createTestDocument();
     const xmlDoc = doc.element.ownerDocument!;
 
@@ -37,7 +37,7 @@ describe("QA Report V3 Defects Reproductions", () => {
     ins.setAttribute("w:id", "101");
     ins.setAttribute("w:author", "Original Drafter");
     ins.setAttribute("w:date", "2026-06-29T12:00:00Z");
-    
+
     const r = xmlDoc.createElement("w:r");
     const t = xmlDoc.createElement("w:t");
     t.textContent = "five (5)";
@@ -51,33 +51,25 @@ describe("QA Report V3 Defects Reproductions", () => {
     suffixRun.appendChild(suffixText);
     p.appendChild(suffixRun);
 
-    // Create an engine with a different user name ("QA Tester") to trigger lockout
     const engine = new RedlineEngine(doc, "QA Tester");
 
-    const edit = {
-      type: "modify",
-      target_text: "five (5)",
-      new_text: "seven (7)",
-    } as any;
-
-    // Run A: dry_run = true
-    const resDry = engine.process_batch([edit], true);
-    expect(resDry.edits_applied).toBe(0);
-    expect(resDry.edits_skipped).toBe(1);
-    expect(resDry.edits[0].status).toBe("failed");
-    expect(resDry.edits[0].error).toContain("active insertion");
-
-    // Run B: dry_run = false
-    let wetRunError: any = null;
-    try {
-      engine.process_batch([edit], false);
-    } catch (e) {
-      wetRunError = e;
-    }
-
-    expect(wetRunError).not.toBeNull();
-    expect(wetRunError.name).toBe("BatchValidationError");
-    expect(wetRunError.message).toContain("active insertion");
+    // A strict edit fully contained inside a foreign insertion now applies: the
+    // enclosing <w:ins> is split and the change nested. Dry-run and write agree.
+    // (Fresh edit object per call: a dry-run mutates the edit's resolution state.)
+    const resDry = engine.process_batch(
+      [{ type: "modify", target_text: "five (5)", new_text: "seven (7)" } as any],
+      true,
+    );
+    expect(resDry.edits_applied).toBe(1);
+    expect(resDry.edits_skipped).toBe(0);
+    expect(resDry.edits[0].status).toBe("applied");
+
+    const resWet = engine.process_batch(
+      [{ type: "modify", target_text: "five (5)", new_text: "seven (7)" } as any],
+      false,
+    );
+    expect(resWet.edits_applied).toBe(1);
+    expect(resWet.edits_skipped).toBe(0);
   });
 
   it("TC3: Heading targeted by markdown '#' corrupts instead of failing [report F4, F5]", async () => {

package/src/repro_report_boundary_failures.test.ts

@@ -0,0 +1,108 @@
+import { describe, it, expect } from "vitest";
+import { createTestDocument, addParagraph } from "./test-utils.js";
+import { RedlineEngine } from "./engine.js";
+import { serializeXml } from "./docx/dom.js";
+
+describe("Report Bug Reproductions: Boundaries and Active Insertions", () => {
+  it("TC_BOUNDARY: target_text spans a paragraph boundary with body text on both sides", async () => {
+    const doc = await createTestDocument();
+    
+    // Add two paragraphs
+    addParagraph(doc, "First paragraph text.");
+    addParagraph(doc, "Second paragraph text.");
+
+    const engine = new RedlineEngine(doc);
+
+    // Target text that spans across the paragraph boundary
+    const edit = {
+      type: "modify",
+      target_text: "First paragraph text.\n\nSecond paragraph text.",
+      new_text: "First paragraph text. New.\n\nSecond paragraph text. New.",
+    } as any;
+
+    // On the unpatched codebase, this throws a BatchValidationError ("target_text spans a paragraph boundary").
+    // We assert that the batch executes successfully to replicate the failure on unpatched environments.
+    const result = engine.process_batch([edit], false);
+    expect(result.edits_applied).toBe(1);
+    expect(result.edits_skipped).toBe(0);
+  });
+
+  it("TC_CONFLICT: Modification targets an active insertion from another author", async () => {
+    const doc = await createTestDocument();
+    const xmlDoc = doc.element.ownerDocument!;
+
+    // Create a paragraph with an active insertion from another author (Supplier's Counsel)
+    const p = addParagraph(doc, "The party shall provide ");
+    const ins = xmlDoc.createElement("w:ins");
+    ins.setAttribute("w:id", "201");
+    ins.setAttribute("w:author", "Supplier's Counsel");
+    ins.setAttribute("w:date", "2026-06-30T08:00:00Z");
+
+    const r = xmlDoc.createElement("w:r");
+    const t = xmlDoc.createElement("w:t");
+    t.textContent = "written notice";
+    r.appendChild(t);
+    ins.appendChild(r);
+    p.appendChild(ins);
+
+    const suffixRun = xmlDoc.createElement("w:r");
+    const suffixText = xmlDoc.createElement("w:t");
+    suffixText.textContent = " within 30 days.";
+    suffixRun.appendChild(suffixText);
+    p.appendChild(suffixRun);
+
+    // Engine is instantiated by Reviewer AI (a different author)
+    const engine = new RedlineEngine(doc, "Reviewer AI");
+
+    const edit = {
+      type: "modify",
+      target_text: "written notice",
+      new_text: "email notification",
+    } as any;
+
+    // On the unpatched codebase, this throws a BatchValidationError ("Modification targets an active insertion from another author").
+    // We assert that the batch executes successfully to replicate the failure on unpatched environments.
+    const result = engine.process_batch([edit], false);
+    expect(result.edits_applied).toBe(1);
+    expect(result.edits_skipped).toBe(0);
+  });
+
+  it("comment-only edit on a foreign author's insertion attaches the comment without crashing", async () => {
+    // Regression guard (cross-engine parity): a COMMENT_ONLY edit (new_text ==
+    // target_text + comment) whose target lies entirely inside another author's
+    // pending <w:ins> must attach the comment around that insertion, not crash.
+    const doc = await createTestDocument();
+    const xmlDoc = doc.element.ownerDocument!;
+
+    const p = addParagraph(doc, "Prefix ");
+    const ins = xmlDoc.createElement("w:ins");
+    ins.setAttribute("w:id", "9");
+    ins.setAttribute("w:author", "Author A");
+    const r = xmlDoc.createElement("w:r");
+    const t = xmlDoc.createElement("w:t");
+    t.textContent = "beta";
+    r.appendChild(t);
+    ins.appendChild(r);
+    p.appendChild(ins);
+
+    const engine = new RedlineEngine(doc, "Editor");
+    const edit = {
+      type: "modify",
+      target_text: "beta",
+      new_text: "beta",
+      comment: "flag this clause",
+    } as any;
+
+    const result = engine.process_batch([edit], false);
+    expect(result.edits_applied).toBe(1);
+    expect(result.edits_skipped).toBe(0);
+
+    const xml = serializeXml(p);
+    // The foreign insertion survives and the comment range wraps it.
+    expect(xml).toContain('w:author="Author A"');
+    expect(xml.indexOf("commentRangeStart")).toBeLessThan(
+      xml.indexOf('w:ins w:id="9"'),
+    );
+    expect(xml).toContain("commentRangeEnd");
+  });
+});