@adeu/core 1.13.0 → 1.15.0

package/src/domain.ts

@@ -1,7 +1,8 @@
-import { DocumentObject } from './docx/bridge.js';
-import { Paragraph, Run } from './docx/primitives.js';
-import { iter_block_items, get_run_text } from './utils/docx.js';
-import { findAllDescendants } from './docx/dom.js';
+import { DocumentObject } from "./docx/bridge.js";
+import { Paragraph, Run } from "./docx/primitives.js";
+import { iter_block_items, get_run_text } from "./utils/docx.js";
+import { findAllDescendants } from "./docx/dom.js";
+import { findDescendantsByLocalName } from "./sanitize/transforms.js";
 
 function boundedLevenshtein(a: string, b: string, maxDist: number = 2): number {
   if (a === b) return 0;
@@ -22,11 +23,7 @@ function boundedLevenshtein(a: string, b: string, maxDist: number = 2): number {
     let minInRow = i;
     for (let j = 1; j <= a.length; j++) {
       const cost = a[j - 1] === b[i - 1] ? 0 : 1;
-      const val = Math.min(
-        row[j] + 1,
-        newRow[j - 1] + 1,
-        row[j - 1] + cost
-      );
+      const val = Math.min(row[j] + 1, newRow[j - 1] + 1, row[j - 1] + cost);
       newRow.push(val);
       if (val < minInRow) minInRow = val;
     }
@@ -37,8 +34,8 @@ function boundedLevenshtein(a: string, b: string, maxDist: number = 2): number {
 }
 
 function _get_paragraph_text(p: Paragraph): string {
-  let text = '';
-  const runs = findAllDescendants(p._element, 'w:r');
+  let text = "";
+  const runs = findAllDescendants(p._element, "w:r");
   for (const r of runs) {
     text += get_run_text(new Run(r, p));
   }
@@ -47,14 +44,22 @@ function _get_paragraph_text(p: Paragraph): string {
 
 export function extract_all_domain_metadata(
   doc: DocumentObject,
-  base_text: string
-): [Record<string, { count: number }>, string[], Record<string, { anchored_to: string; referenced_from: string[] }>] {
+  base_text: string,
+): [
+  Record<string, { count: number }>,
+  string[],
+  Record<string, { anchored_to: string; referenced_from: string[] }>,
+] {
   const definitions: Record<string, { count: number }> = {};
   const duplicates = new Set<string>();
-  const raw_anchors: Record<string, { anchored_to: string; referenced_from: string[] }> = {};
+  const raw_anchors: Record<
+    string,
+    { anchored_to: string; referenced_from: string[] }
+  > = {};
   const raw_references: [string, string][] = [];
 
-  const leading_re = /^(?:[\d.\-()a-zA-Z]+\s*)?["“]([A-Z][A-Za-z0-9\s\-&'’]{1,60})["”]/;
+  const leading_re =
+    /^(?:[\d.\-()a-zA-Z]+\s*)?["“]([A-Z][A-Za-z0-9\s\-&'’]{1,60})["”]/;
   const inline_re = /\([^)]*?["“]([A-Z][A-Za-z0-9\s\-&'’]{1,60})["”][^)]*?\)/g;
 
   for (const item of iter_block_items(doc)) {
@@ -77,28 +82,31 @@ export function extract_all_domain_metadata(
       else definitions[term] = { count: 0 };
     }
 
-    const short_text = text.length > 60 ? text.substring(0, 60) + '...' : text;
+    const short_text = text.length > 60 ? text.substring(0, 60) + "..." : text;
 
-    const nodes = findAllDescendants(item._element, '*');
+    const nodes = findAllDescendants(item._element, "*");
     for (const node of nodes) {
-      if (node.tagName === 'w:bookmarkStart') {
-        const b_name = node.getAttribute('w:name');
-        if (b_name && (!b_name.startsWith('_') || b_name.startsWith('_Ref'))) {
+      if (node.tagName === "w:bookmarkStart") {
+        const b_name = node.getAttribute("w:name");
+        if (b_name && (!b_name.startsWith("_") || b_name.startsWith("_Ref"))) {
           if (!raw_anchors[b_name]) {
-            raw_anchors[b_name] = { anchored_to: short_text, referenced_from: [] };
+            raw_anchors[b_name] = {
+              anchored_to: short_text,
+              referenced_from: [],
+            };
           }
         }
       }
 
       let target: string | null = null;
-      if (node.tagName === 'w:fldSimple') {
-        const instr = node.getAttribute('w:instr') || '';
+      if (node.tagName === "w:fldSimple") {
+        const instr = node.getAttribute("w:instr") || "";
         const parts = instr.trim().split(/\s+/);
-        if (parts.length > 1 && parts[0] === 'REF') target = parts[1];
-      } else if (node.tagName === 'w:instrText') {
-        const instr = node.textContent || '';
+        if (parts.length > 1 && parts[0] === "REF") target = parts[1];
+      } else if (node.tagName === "w:instrText") {
+        const instr = node.textContent || "";
         const parts = instr.trim().split(/\s+/);
-        if (parts.length > 1 && parts[0] === 'REF') target = parts[1];
+        if (parts.length > 1 && parts[0] === "REF") target = parts[1];
       }
 
       if (target) raw_references.push([target, short_text]);
@@ -116,9 +124,10 @@ export function extract_all_domain_metadata(
   const def_keys = Object.keys(definitions);
   if (def_keys.length > 0) {
     const sorted_terms = def_keys.sort((a, b) => b.length - a.length);
-    const escapeRegExp = (str: string) => str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-    const alt = sorted_terms.map(escapeRegExp).join('|');
-    const usage_pattern = new RegExp(`(?<!["“])\\b(${alt})\\b(?![”"])`, 'g');
+    const escapeRegExp = (str: string) =>
+      str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const alt = sorted_terms.map(escapeRegExp).join("|");
+    const usage_pattern = new RegExp(`(?<!["“])\\b(${alt})\\b(?![”"])`, "g");
 
     for (const m of base_text.matchAll(usage_pattern)) {
       const matched_term = m[1];
@@ -134,12 +143,32 @@ export function extract_all_domain_metadata(
   }
 
   for (const term of duplicates) {
-    diagnostics.push(`[Error] Duplicate Definition: '${term}' is defined multiple times.`);
+    diagnostics.push(
+      `[Error] Duplicate Definition: '${term}' is defined multiple times.`,
+    );
   }
 
   const stop_words = new Set([
-    "The", "This", "That", "Such", "A", "An", "Any", "All", "Some", "No",
-    "Every", "Each", "As", "In", "Of", "For", "To", "On", "By", "With"
+    "The",
+    "This",
+    "That",
+    "Such",
+    "A",
+    "An",
+    "Any",
+    "All",
+    "Some",
+    "No",
+    "Every",
+    "Each",
+    "As",
+    "In",
+    "Of",
+    "For",
+    "To",
+    "On",
+    "By",
+    "With",
   ]);
 
   const all_cap_pattern = /\b[A-Z][a-zA-Z]*(?:\s+[A-Z][a-zA-Z]*)*\b/g;
@@ -160,11 +189,12 @@ export function extract_all_domain_metadata(
     const words = candidate.split(/\s+/);
     while (words.length > 0) {
       const first = words[0];
-      const title = first.charAt(0).toUpperCase() + first.slice(1).toLowerCase();
+      const title =
+        first.charAt(0).toUpperCase() + first.slice(1).toLowerCase();
       if (stop_words.has(title)) words.shift();
       else break;
     }
-    candidate = words.join(' ');
+    candidate = words.join(" ");
 
     if (candidate.length < 4) continue;
     if (valid_terms.has(candidate)) continue;
@@ -180,8 +210,8 @@ export function extract_all_domain_metadata(
 
     for (const term of candidate_terms) {
       if (Math.abs(candidate.length - term.length) > 2) continue;
-      if (candidate === term + 's' || candidate === term + 'es') continue;
-      if (term === candidate + 's' || term === candidate + 'es') continue;
+      if (candidate === term + "s" || candidate === term + "es") continue;
+      if (term === candidate + "s" || term === candidate + "es") continue;
 
       const dist = boundedLevenshtein(candidate, term, 2);
       if (dist === 0 || dist > 2) continue;
@@ -192,19 +222,20 @@ export function extract_all_domain_metadata(
       }
 
       if (!candidates_by_term[term]) candidates_by_term[term] = [];
-      if (!candidates_by_term[term].includes(candidate)) candidates_by_term[term].push(candidate);
+      if (!candidates_by_term[term].includes(candidate))
+        candidates_by_term[term].push(candidate);
     }
   }
 
   for (const [term, candidates] of Object.entries(candidates_by_term)) {
     candidates.sort();
-    const c_str = candidates.map(c => `'${c}'`).join(', ');
+    const c_str = candidates.map((c) => `'${c}'`).join(", ");
     diagnostics.push(`[Info] Possible Typos for '${term}': Found ${c_str}`);
   }
 
   function diag_sort_key(msg: string) {
-    if (msg.startsWith('[Error]')) return 0;
-    if (msg.startsWith('[Warning]')) return 1;
+    if (msg.startsWith("[Error]")) return 0;
+    if (msg.startsWith("[Warning]")) return 1;
     return 2;
   }
 
@@ -218,19 +249,88 @@ export function extract_all_domain_metadata(
   return [definitions, diagnostics, raw_anchors];
 }
 
-export function build_structural_appendix(doc: DocumentObject, base_text: string): string {
-  const [defs, diagnostics, anchors] = extract_all_domain_metadata(doc, base_text);
+/**
+ * Inspects word/settings.xml for privacy flags that cause Microsoft Word to
+ * silently strip authorship metadata (w:author, w:date, w:initials) from
+ * tracked changes and comments on the next save. These flags do not affect
+ * what this engine writes — but they will scrub the engine's attribution the
+ * next time Word opens and saves the file, breaking auditability and
+ * multi-turn agent state tracking.
+ *
+ * Returns a list of human-readable warning lines (without leading bullets);
+ * empty when no relevant flag is present or all flags are explicitly disabled.
+ */
+export function extract_document_settings_warnings(
+  doc: DocumentObject,
+): string[] {
+  const warnings: string[] = [];
+  const settingsPart = doc.pkg.getPartByPath("word/settings.xml");
+  if (!settingsPart) return warnings;
+
+  const isTruthy = (el: Element): boolean => {
+    // OOXML boolean rule: element present with no w:val attribute defaults to true.
+    // w:val of "0", "false", or "off" means disabled. Anything else (including
+    // "1", "true", "on") is enabled.
+    if (!el.hasAttribute("w:val")) return true;
+    const val = (el.getAttribute("w:val") || "").toLowerCase();
+    return val !== "0" && val !== "false" && val !== "off";
+  };
+
+  const removePersonal = findDescendantsByLocalName(
+    settingsPart._element,
+    "removePersonalInformation",
+  );
+  if (removePersonal.length > 0 && isTruthy(removePersonal[0])) {
+    warnings.push(
+      "[Warning] Privacy flag `removePersonalInformation` is enabled in word/settings.xml. " +
+        "Microsoft Word will strip the `w:author`, `w:initials`, and `w:date` attributes from every tracked change and comment the next time this document is opened and saved. " +
+        "Edits made by this agent will lose attribution, breaking audit trails and any multi-turn workflow that relies on identifying prior edits.",
+    );
+  }
+
+  const removeDateTime = findDescendantsByLocalName(
+    settingsPart._element,
+    "removeDateAndTime",
+  );
+  if (removeDateTime.length > 0 && isTruthy(removeDateTime[0])) {
+    warnings.push(
+      "[Warning] Privacy flag `removeDateAndTime` is enabled in word/settings.xml. " +
+        "Microsoft Word will strip the `w:date` attribute from every tracked change and comment the next time this document is opened and saved. " +
+        "Timestamps on this agent's edits will be lost on the next Word save.",
+    );
+  }
+
+  return warnings;
+}
+
+export function build_structural_appendix(
+  doc: DocumentObject,
+  base_text: string,
+): string {
+  const [defs, diagnostics, anchors] = extract_all_domain_metadata(
+    doc,
+    base_text,
+  );
+  const settings_warnings = extract_document_settings_warnings(doc);
 
   const lines: string[] = [
     "\n\n---",
     "",
     "<!-- READONLY_BOUNDARY_START -->",
     "# Document Structure (Read-Only)",
-    "The content below is metadata describing the document's reference structure. Do not include this section in any tracked changes or edits \u2014 it is for your context only and will be discarded on write."
+    "The content below is metadata describing the document's reference structure. Do not include this section in any tracked changes or edits \u2014 it is for your context only and will be discarded on write.",
   ];
 
   let has_content = false;
 
+  if (settings_warnings.length > 0) {
+    has_content = true;
+    lines.push("\n## Document Settings");
+    for (const warning of settings_warnings) {
+      lines.push(`- ${warning}`);
+    }
+  }
+
   if (Object.keys(defs).length > 0) {
     has_content = true;
     lines.push("\n## Defined Terms");
@@ -259,7 +359,7 @@ export function build_structural_appendix(doc: DocumentObject, base_text: string
   }
 
   if (has_content) {
-    return lines.join('\n');
+    return lines.join("\n");
   }
   return "";
-}
+}

package/src/engine.bugs.test.ts

@@ -531,4 +531,24 @@ describe("Resolved Bugs Core Engine Verification", () => {
     const final_comment_parts = doc.pkg.parts.filter(p => p.contentType.includes("comments"));
     expect(final_comment_parts.length).toBe(0);
   });
+
+  it("Double-Serialization Core: process_batch successfully processes double-serialized JSON strings", async () => {
+    const doc = await createTestDocument();
+    addParagraph(doc, "original text");
+    const engine = new RedlineEngine(doc);
+
+    // On unpatched code, this will throw a raw TypeError: Cannot create property '_applied_status' on string
+    // On patched code, it will successfully parse and apply the modify change
+    engine.process_batch([
+      JSON.stringify({
+        type: "modify",
+        target_text: "original text",
+        new_text: "updated text",
+      }),
+    ] as any);
+
+    const buf = await doc.save();
+    const text = await extractTextFromBuffer(buf, true);
+    expect(text).toContain("updated text");
+  });
 });

package/src/engine.qa.test.ts

@@ -0,0 +1,162 @@
+import { describe, it, expect } from "vitest";
+import { RedlineEngine } from "./engine.js";
+import { createTestDocument, addParagraph } from "./test-utils.js";
+
+describe("QA Report V2: Engine Logic", () => {
+  it("F6: Breadcrumb resolver does not dump paragraph bodies", async () => {
+    const doc = await createTestDocument();
+    
+    // Setup a heading
+    const p = addParagraph(doc, "2. Confidentiality");
+    const docEl = p.ownerDocument!;
+    const pPr = docEl.createElement("w:pPr");
+    const pStyle = docEl.createElement("w:pStyle");
+    pStyle.setAttribute("w:val", "Heading1");
+    pPr.appendChild(pStyle);
+    p.insertBefore(pPr, p.firstChild);
+
+    // Add a massive paragraph that could erroneously get caught by a greedy regex
+    addParagraph(doc, "This is a massive body paragraph ".repeat(20));
+    addParagraph(doc, "Target phrase is here.");
+
+    const engine = new RedlineEngine(doc);
+    engine.mapper["_build_map"]();
+    
+    const text = engine.mapper.full_text;
+    const start_idx = text.indexOf("Target phrase");
+    
+    const [path, page] = (engine as any)._get_heading_path_and_page(start_idx, text, [0, 1000]);
+    
+    expect(path).toContain("2. Confidentiality");
+    expect(path).not.toContain("This is a massive body paragraph");
+  });
+
+  it("F9: Empty insertion CriticMarkup artifact {++++} is suppressed", async () => {
+    const doc = await createTestDocument();
+    addParagraph(doc, "the Board of Directors");
+    const engine = new RedlineEngine(doc);
+
+    // Mock an edit that acts as a strict deletion/shrink (new_text is empty)
+    const edit = {
+      type: "modify",
+      target_text: " of Directors",
+      new_text: "",
+      _resolved_start_idx: "the Board".length,
+      _active_mapper_ref: engine.mapper
+    };
+    
+    engine.mapper["_build_map"]();
+    
+    const [critic_markup, clean_text] = (engine as any)._build_edit_context_previews(edit);
+    
+    expect(critic_markup).toContain("{-- of Directors--}");
+    // The {++++} artifact shouldn't exist if new_text is empty
+    expect(critic_markup).not.toContain("{++++}");
+    expect(clean_text).not.toContain("{++++}");
+  });
+
+  it("R2 & R3: all-mode page list is ascending and breadcrumb anchors on first occurrence", async () => {
+    const doc = await createTestDocument();
+    const xmlDoc = doc.element.ownerDocument!;
+    
+    const p1 = addParagraph(doc, "Heading one");
+    const pPr1 = xmlDoc.createElement("w:pPr");
+    const pStyle1 = xmlDoc.createElement("w:pStyle");
+    pStyle1.setAttribute("w:val", "Heading1");
+    pPr1.appendChild(pStyle1);
+    p1.insertBefore(pPr1, p1.firstChild);
+
+    addParagraph(doc, "Occurrence one.");
+
+    const p3 = addParagraph(doc, "Heading two");
+    const pPr2 = xmlDoc.createElement("w:pPr");
+    const pStyle2 = xmlDoc.createElement("w:pStyle");
+    pStyle2.setAttribute("w:val", "Heading2");
+    pPr2.appendChild(pStyle2);
+    p3.insertBefore(pPr2, p3.firstChild);
+
+    addParagraph(doc, "Occurrence two.");
+
+    const engine = new RedlineEngine(doc);
+    const edit = {
+      type: "modify",
+      target_text: "Occurrence",
+      new_text: "Match",
+      match_mode: "all"
+    };
+    const stats = engine.process_batch([edit], false);
+    
+    const report = stats.edits[0];
+    expect(report.heading_path).toContain("Heading one");
+    expect(report.heading_path).not.toContain("Heading two");
+
+    if (report.pages && report.pages.length > 1) {
+      expect(report.pages[0]).toBeLessThanOrEqual(report.pages[1]);
+    }
+  });
+
+  it("§5.3.2 Transactional rollback for foreign author", async () => {
+    const doc = await createTestDocument();
+    const xmlDoc = doc.element.ownerDocument!;
+    
+    const p = addParagraph(doc, "Target ");
+    const ins = xmlDoc.createElement("w:ins");
+    ins.setAttribute("w:id", "1");
+    ins.setAttribute("w:author", "Other User");
+    const r = xmlDoc.createElement("w:r");
+    const t = xmlDoc.createElement("w:t");
+    t.textContent = "word";
+    r.appendChild(t);
+    ins.appendChild(r);
+    p.appendChild(ins);
+
+    const engine = new RedlineEngine(doc);
+    const edit = {
+      type: "modify",
+      target_text: "Target word",
+      new_text: "Replaced",
+      match_mode: "all"
+    };
+
+    expect(() => engine.process_batch([edit], false)).toThrow(/targets an active insertion from another author/);
+  });
+
+  it("§5.3.3 Double-sided paragraph merge regex rejection", async () => {
+    const doc = await createTestDocument();
+    addParagraph(doc, "First part.");
+    addParagraph(doc, "Second part.");
+
+    const engine = new RedlineEngine(doc);
+    const edit = {
+      type: "modify",
+      target_text: "part.\\n\\nSecond",
+      new_text: "merged",
+      regex: true
+    };
+
+    expect(() => engine.process_batch([edit], false)).toThrow(/spans a paragraph boundary with body text on both sides/);
+  });
+
+  it("S1: Transactional rollback blocks all-mode edit overlapping foreign COMMENT_ONLY edit", async () => {
+    const doc = await createTestDocument();
+    addParagraph(doc, "This is constituting the Board of Directors today.");
+
+    const engineAlice = new RedlineEngine(doc, "Alice");
+    engineAlice.process_batch([{
+      type: "modify",
+      target_text: "constituting the Board of Directors",
+      new_text: "constituting the Board of Directors",
+      comment: "Alice touches this clause"
+    }]);
+
+    const engineBob = new RedlineEngine(doc, "Bob");
+    const editBob = {
+      type: "modify",
+      target_text: "the Board of Directors",
+      new_text: "the Supervisory Board",
+      match_mode: "all"
+    };
+
+    expect(() => engineBob.process_batch([editBob], false)).toThrow(/another author/i);
+  });
+});