@adeu/core 1.17.2 → 1.18.1

package/package.json

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

package/src/engine.bugs.test.ts

@@ -418,7 +418,7 @@ describe("Resolved Bugs Core Engine Verification", () => {
     expect(pTarget.parentNode).toBeNull();
   });
 
-  it("BUG-EXPLORE-2: Nested redline validation error includes actionable hint", async () => {
+  it("BUG-EXPLORE-2: a strict edit inside a foreign author's insertion applies (nested change)", async () => {
     const doc = await createTestDocument();
     addParagraph(doc, "Original baseline.");
 
@@ -432,20 +432,18 @@ describe("Resolved Bugs Core Engine Verification", () => {
       },
     ]);
 
-    // Author B tries to modify Author A's pending insertion
+    // Author B modifies Author A's pending insertion — this now applies: the
+    // enclosing <w:ins> is split and Author B's change nested inside it.
     const engineB = new RedlineEngine(doc, "Author B");
-
-    expect(() => {
-      engineB.process_batch([
-        {
-          type: "modify",
-          target_text: "Inserted by A.",
-          new_text: "Modified by B.",
-        },
-      ]);
-    }).toThrowError(
-      /Accept that change first or scope your edit outside of it/,
-    );
+    const result = engineB.process_batch([
+      {
+        type: "modify",
+        target_text: "Inserted by A.",
+        new_text: "Modified by B.",
+      },
+    ]);
+    expect(result.edits_applied).toBe(1);
+    expect(result.edits_skipped).toBe(0);
   });
 
   it("BUG-CROSS-PARA-1: Cross-paragraph modify coalesces paragraphs and tracks para-mark deletion", async () => {

package/src/engine.feedback.test.ts

@@ -31,7 +31,11 @@ describe("Feedback Layer & Dry Run Verification", () => {
     expect(stats.version).toBeDefined();
   });
 
-  it("punctuation anchor triggers warning", async () => {
+  it("punctuation anchor: no warning on clean apply", async () => {
+    // A punctuated anchor that matches and applies cleanly must NOT raise the
+    // tokenization-splitting warning. The redline preview already reports the
+    // change; a warning here is a false positive that pushes agents into
+    // needless "cleaner anchor" retries.
     const doc = await createTestDocument();
     addParagraph(doc, "Refer to sample_term_name in Section 4.");
     const engine = new RedlineEngine(doc, "Reviewer TS");
@@ -41,9 +45,37 @@ describe("Feedback Layer & Dry Run Verification", () => {
     ]);
 
     const report = stats.edits[0];
+    expect(report.status).toBe("applied");
+    expect(report.warning).toBeNull();
+
+    // Same expectation under dry_run.
+    const doc2 = await createTestDocument();
+    addParagraph(doc2, "Refer to sample_term_name in Section 4.");
+    const engine2 = new RedlineEngine(doc2, "Reviewer TS");
+    const dryStats = (engine2 as any).process_batch([
+      { type: "modify", target_text: "sample_term_name", new_text: "validated_term_name" }
+    ], true);
+    const dryReport = dryStats.edits[0];
+    expect(dryReport.status).toBe("applied");
+    expect(dryReport.warning).toBeNull();
+  });
+
+  it("punctuation anchor: warns only when match fails", async () => {
+    // When a punctuated anchor fails to match, the warning IS surfaced as
+    // recovery context (the punctuation may be why the match missed).
+    const doc = await createTestDocument();
+    addParagraph(doc, "Refer to sample_term_name in Section 4.");
+    const engine = new RedlineEngine(doc, "Reviewer TS");
+
+    const stats = (engine as any).process_batch([
+      { type: "modify", target_text: "phantom_term-x", new_text: "anything" }
+    ], true);
+
+    const report = stats.edits[0];
+    expect(report.status).toBe("failed");
     expect(report.warning).not.toBeNull();
     expect(report.warning.toLowerCase()).toContain("punctuation");
-    expect(report.warning).toContain("sample_term_name");
+    expect(report.warning).toContain("phantom_term-x");
   });
 
   it("dry_run does not mutate and reports safely", async () => {

package/src/engine.issue23.test.ts

@@ -422,31 +422,36 @@ describe("BUG-23-4: multi-paragraph target_text must produce actionable feedback
     }
   });
 
-  it("BUG-23-4-NN: rejects plain-paragraph N->N modifications spanning a paragraph boundary to prevent silent corruption", async () => {
+  it("BUG-23-4-NN: applies balanced plain-paragraph N->N modifications per paragraph, preserving the boundary", async () => {
     const doc = await createTestDocument();
     addParagraph(doc, "Clause 1 ends here.");
     addParagraph(doc, "Clause 2 begins here.");
 
     const engine = new RedlineEngine(doc, "Test Author");
 
-    let raised: any = null;
-    try {
-      engine.process_batch([
-        {
-          type: "modify",
-          target_text: "ends here.\n\nClause 2 begins",
-          new_text: "ends here. MERGED\n\nClause 2 begins CHANGED",
-        },
-      ]);
-    } catch (e: any) {
-      raised = e;
-    }
+    // Both target and replacement carry the same number of \n\n breaks, so the
+    // paragraph structure is preserved. The engine splits this into one sub-edit
+    // per paragraph and applies it as a single logical edit. (Unbalanced
+    // merges/splits are still rejected — see the regex case in engine.qa.test.)
+    const result = engine.process_batch([
+      {
+        type: "modify",
+        target_text: "ends here.\n\nClause 2 begins",
+        new_text: "ends here. MERGED\n\nClause 2 begins CHANGED",
+      },
+    ]);
 
-    expect(raised).not.toBeNull();
-    if (raised) {
-      expect(raised.name).toBe("BatchValidationError");
-      expect(raised.message.toLowerCase()).toContain("paragraph boundary");
-    }
+    expect(result.edits_applied).toBe(1);
+    expect(result.edits_skipped).toBe(0);
+
+    const buf = await doc.save();
+    const text = await extractTextFromBuffer(buf);
+    // The paragraph boundary must survive — the two clauses are NOT merged.
+    expect(text).not.toContain("ends here.Clause 2 begins");
+    expect(text).not.toContain("ends here. Clause 2 begins");
+    // Both per-paragraph insertions land.
+    expect(text).toContain("MERGED");
+    expect(text).toContain("CHANGED");
   });
 });