@adeu/core 1.26.0 → 1.28.0

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");
+  });
+});

package/src/repro_qa_report_v9.test.ts

@@ -0,0 +1,392 @@
+// FILE: node/packages/core/src/repro_qa_report_v9.test.ts
+/**
+ * Node-engine repro tests for the 2026-07-19 black-box QA and UX evaluation
+ * of 1.27.0 (adeu 1.27.0+7a0a821). Mirrors
+ * python/tests/test_repro_qa_report_v9.py for the findings that live in the
+ * shared core engine:
+ *
+ *   ADEU-QA-001  sanitize reports CLEAN while a w:docVar secret survives in
+ *                word/settings.xml
+ *   ADEU-QA-002  structured diff output is not replayable for paragraph
+ *                deletions/reorderings; three mechanisms: (A) word-level
+ *                hunks crossing paragraph boundaries, (B) full-paragraph
+ *                deletion bleeding the deleted paragraph's style onto the
+ *                following one, (C) virtual meta-bubble text satisfying or
+ *                ambiguating matches
+ *   ADEU-QA-004  a replacement's del+ins pair reads as two independent IDs;
+ *                the Node engine additionally did NOT group-resolve pairs at
+ *                all (accepting the deletion left the insertion pending —
+ *                an engine-parity divergence), and follow-up actions on the
+ *                paired id were miscounted as applied
+ *
+ * Every test fails against the commit preceding its fix.
+ */
+
+import { describe, it, expect } from "vitest";
+import { strFromU8, unzipSync } from "fflate";
+import { createTestDocument, addParagraph } from "./test-utils.js";
+import { DocumentObject } from "./docx/bridge.js";
+import { RedlineEngine, BatchValidationError } from "./engine.js";
+import { DocumentMapper } from "./mapper.js";
+import { _extractTextFromDoc, extractTextFromBuffer } from "./ingest.js";
+import {
+  generate_structured_edits,
+  generate_edits_via_paragraph_alignment,
+} from "./diff.js";
+import { finalize_document } from "./sanitize/core.js";
+import { findAllDescendants, findChild } from "./docx/dom.js";
+
+const SECRET = "SECRET-MATTER-4711-CONFIDENTIAL";
+
+function cleanText(doc: DocumentObject): string {
+  return _extractTextFromDoc(doc, true, false) as string;
+}
+
+function structured(doc: DocumentObject): { text: string; structure: any } {
+  return _extractTextFromDoc(doc, true, false, false, true) as {
+    text: string;
+    structure: any;
+  };
+}
+
+function addStyledParagraph(
+  doc: DocumentObject,
+  text: string,
+  styleId: string,
+): Element {
+  const p = addParagraph(doc, text);
+  const xmlDoc = p.ownerDocument!;
+  const pPr = xmlDoc.createElement("w:pPr");
+  const pStyle = xmlDoc.createElement("w:pStyle");
+  pStyle.setAttribute("w:val", styleId);
+  pPr.appendChild(pStyle);
+  p.insertBefore(pPr, p.firstChild);
+  return p;
+}
+
+/** 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, "Editor");
+  engine.apply_edits([
+    { type: "modify", target_text: "30 days", new_text: "60 days" },
+  ]);
+  return DocumentObject.load(await doc.save());
+}
+
+// ---------------------------------------------------------------------------
+// ADEU-QA-001: sanitizer must not report CLEAN while w:docVar secrets remain
+// ---------------------------------------------------------------------------
+
+describe("ADEU-QA-001: sanitize strips document variables", () => {
+  async function buildDocVarDoc(): Promise<DocumentObject> {
+    const doc = await createTestDocument();
+    addParagraph(doc, "An ordinary contract paragraph.");
+    const settings = doc.pkg.getPartByPath("word/settings.xml");
+    expect(settings).toBeTruthy();
+    const xmlDoc = settings!._element.ownerDocument!;
+    const docVars = xmlDoc.createElement("w:docVars");
+    const docVar = xmlDoc.createElement("w:docVar");
+    docVar.setAttribute("w:name", "MatterRef");
+    docVar.setAttribute("w:val", SECRET);
+    docVars.appendChild(docVar);
+    settings!._element.appendChild(docVars);
+    return doc;
+  }
+
+  it("full sanitize removes w:docVar values from the saved package", async () => {
+    const doc = await buildDocVarDoc();
+    const pre = await doc.save();
+    expect(strFromU8(unzipSync(new Uint8Array(pre))["word/settings.xml"])).toContain(
+      SECRET,
+    );
+
+    const doc2 = await DocumentObject.load(pre);
+    const result = await finalize_document(doc2, {
+      filename: "docvar.docx",
+      sanitize_mode: "full",
+    });
+    expect(result.outBuffer).toBeTruthy();
+    const members = unzipSync(new Uint8Array(result.outBuffer!));
+    for (const [name, bytes] of Object.entries(members)) {
+      expect(
+        strFromU8(bytes).includes(SECRET),
+        `secret still present in ${name}`,
+      ).toBe(false);
+    }
+  });
+
+  it("report names the variable but never echoes its value", async () => {
+    const doc = await buildDocVarDoc();
+    const result = await finalize_document(doc, {
+      filename: "docvar.docx",
+      sanitize_mode: "full",
+    });
+    expect(result.reportText.toLowerCase()).toContain("document variable");
+    expect(result.reportText).toContain("MatterRef");
+    expect(result.reportText).not.toContain(SECRET);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// ADEU-QA-002: structural diffs must replay; deletions must not restyle
+// ---------------------------------------------------------------------------
+
+describe("ADEU-QA-002 B: full-paragraph deletion keeps the following style", () => {
+  it("deleting a styled paragraph does not restyle the following one", async () => {
+    const doc = await createTestDocument();
+    addStyledParagraph(doc, "Definitions", "Heading2");
+    addParagraph(doc, "The first body paragraph after the heading.");
+    addParagraph(doc, "A second body paragraph.");
+
+    const text_o = cleanText(doc);
+    // The projection may or may not render "## " depending on the fixture's
+    // styles.xml; delete the whole first paragraph block as it projects.
+    const first_block = text_o.split("\n\n")[0];
+    const text_m = text_o.replace(first_block + "\n\n", "");
+
+    const edits = generate_edits_via_paragraph_alignment(text_o, text_m);
+    const engine = new RedlineEngine(doc, "QA");
+    engine.process_batch(edits);
+
+    expect(cleanText(doc).trim()).toBe(text_m.trim());
+
+    // The merged container must carry the FOLLOWING paragraph's properties:
+    // no Heading2 pStyle may survive on a paragraph whose visible text is
+    // the body paragraph's.
+    for (const p of findAllDescendants(doc.element, "w:p")) {
+      const pPr = findChild(p, "w:pPr");
+      const pStyle = pPr ? findChild(pPr, "w:pStyle") : null;
+      if (pStyle && pStyle.getAttribute("w:val") === "Heading2") {
+        throw new Error(
+          "the deleted heading's style bled onto the surviving paragraph",
+        );
+      }
+    }
+  });
+
+  it("structured diff replays a first-paragraph deletion exactly", async () => {
+    const orig = await createTestDocument();
+    addStyledParagraph(orig, "Definitions", "Heading2");
+    addParagraph(orig, "The first body paragraph after the heading.");
+    addParagraph(orig, "A second body paragraph.");
+
+    const mod = await createTestDocument();
+    addParagraph(mod, "The first body paragraph after the heading.");
+    addParagraph(mod, "A second body paragraph.");
+
+    const { text: text_o, structure: struct_o } = structured(orig);
+    const { text: text_m, structure: struct_m } = structured(mod);
+    const { edits } = generate_structured_edits(
+      text_o,
+      struct_o,
+      text_m,
+      struct_m,
+    );
+
+    // Node diff output keeps pins through JSON (plain properties).
+    const replayed = JSON.parse(JSON.stringify(edits));
+    const engine = new RedlineEngine(orig, "QA");
+    engine.process_batch(replayed);
+    expect(cleanText(orig).trim()).toBe(text_m.trim());
+  });
+
+  it("structured diff replays an adjacent paragraph swap exactly", async () => {
+    const paras = [
+      "Clause one sets the scene for the agreement.",
+      "Clause two lists the payment obligations of the parties.",
+      "Clause three covers termination and remedies at law.",
+      "Clause four is the confidentiality clause.",
+    ];
+    const orig = await createTestDocument();
+    for (const p of paras) addParagraph(orig, p);
+    const swapped = [paras[0], paras[2], paras[1], paras[3]];
+    const mod = await createTestDocument();
+    for (const p of swapped) addParagraph(mod, p);
+
+    const { text: text_o, structure: struct_o } = structured(orig);
+    const { text: text_m, structure: struct_m } = structured(mod);
+    const { edits } = generate_structured_edits(
+      text_o,
+      struct_o,
+      text_m,
+      struct_m,
+    );
+
+    const engine = new RedlineEngine(orig, "QA");
+    engine.process_batch(JSON.parse(JSON.stringify(edits)));
+    expect(cleanText(orig).trim()).toBe(text_m.trim());
+  });
+});
+
+describe("ADEU-QA-002 C: virtual projection text never matches", () => {
+  it("a target existing only in a meta bubble is not found", async () => {
+    const doc = await buildTrackedChangeDoc();
+    const engine = new RedlineEngine(doc, "Reviewer");
+    // "Editor" appears ONLY inside the {>>[Chg:1 delete] Editor ...<<}
+    // bubble — never in document text.
+    expect(() =>
+      engine.process_batch([
+        { type: "modify", target_text: "Editor", new_text: "X" },
+      ]),
+    ).toThrow(/not found/i);
+  });
+
+  it("a digit unique in body text resolves despite bubble timestamps", async () => {
+    const doc = await createTestDocument();
+    addParagraph(doc, "Clause 7 applies to this agreement.");
+    addParagraph(doc, "Another paragraph.");
+    const engine = new RedlineEngine(doc, "Editor");
+    engine.process_batch([
+      {
+        type: "modify",
+        target_text: "Another",
+        new_text: "A different",
+        comment: "Reviewed on 2026-07-19",
+      },
+    ]);
+    const doc2 = await DocumentObject.load(await doc.save());
+
+    const engine2 = new RedlineEngine(doc2, "Reviewer");
+    const stats = engine2.process_batch([
+      { type: "modify", target_text: "7", new_text: "9" },
+    ]);
+    expect(stats.edits_applied).toBe(1);
+    expect(cleanText(doc2)).toContain("Clause 9 applies");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// ADEU-QA-004: replacement del+ins pairs — parity, linkage, counts
+// ---------------------------------------------------------------------------
+
+describe("ADEU-QA-004: replacement pair semantics", () => {
+  it("projection annotates paired changes in both ingest and mapper", async () => {
+    const doc = await buildTrackedChangeDoc();
+    const raw = await extractTextFromBuffer(await doc.save());
+    expect(raw).toContain("[Chg:1 delete] Editor (pairs with Chg:2)");
+    expect(raw).toContain("[Chg:2 insert] Editor (pairs with Chg:1)");
+
+    const doc2 = await DocumentObject.load(await doc.save());
+    const mapper = new DocumentMapper(doc2);
+    const rawNoAppendix = _extractTextFromDoc(doc2, false, false) as string;
+    expect(mapper.full_text).toBe(rawNoAppendix);
+  });
+
+  it("standalone changes carry no pairing annotation", async () => {
+    const doc = await createTestDocument();
+    addParagraph(doc, "Payment is due in 30 days.");
+    const engine = new RedlineEngine(doc, "Editor");
+    engine.apply_edits([
+      { type: "modify", target_text: "Payment is due in 30 days.", new_text: "" },
+    ]);
+    const raw = await extractTextFromBuffer(await doc.save());
+    expect(raw).not.toContain("pairs with");
+  });
+
+  it("accepting the deletion side resolves the paired insertion (engine parity)", async () => {
+    const doc = await buildTrackedChangeDoc();
+    const engine = new RedlineEngine(doc, "Reviewer");
+    const stats = engine.process_batch([
+      { type: "accept", target_id: "Chg:1" },
+    ]);
+    expect(stats.actions_applied).toBe(1);
+
+    const final = cleanText(doc);
+    expect(final).toContain("60 days");
+    expect(final).not.toContain("30 days");
+    // The paired insertion must be fully resolved, not left pending.
+    expect(findAllDescendants(doc.element, "w:ins").length).toBe(0);
+    expect(findAllDescendants(doc.element, "w:del").length).toBe(0);
+  });
+
+  it("accepting both sides counts one state transition", async () => {
+    const doc = await buildTrackedChangeDoc();
+    const engine = new RedlineEngine(doc, "Reviewer");
+    const stats = engine.process_batch([
+      { type: "accept", target_id: "Chg:1" },
+      { type: "accept", target_id: "Chg:2" },
+    ]);
+    expect(stats.actions_applied).toBe(1);
+    expect(stats.actions_already_resolved).toBe(1);
+    expect(stats.actions_skipped).toBe(0);
+    const details = (stats.skipped_details || []).join("\n").toLowerCase();
+    expect(details).toContain("already resolved");
+
+    const final = cleanText(doc);
+    expect(final).toContain("60 days");
+    expect(final).not.toContain("30 days");
+  });
+
+  it("rejecting both sides counts one state transition", async () => {
+    const doc = await buildTrackedChangeDoc();
+    const engine = new RedlineEngine(doc, "Reviewer");
+    const stats = engine.process_batch([
+      { type: "reject", target_id: "Chg:1" },
+      { type: "reject", target_id: "Chg:2" },
+    ]);
+    expect(stats.actions_applied).toBe(1);
+    expect(stats.actions_already_resolved).toBe(1);
+
+    const final = cleanText(doc);
+    expect(final).toContain("30 days");
+    expect(final).not.toContain("60 days");
+  });
+
+  it("contradictory actions on one pair are rejected up front", async () => {
+    const doc = await buildTrackedChangeDoc();
+    const engine = new RedlineEngine(doc, "Reviewer");
+    let error: any = null;
+    try {
+      engine.process_batch([
+        { type: "accept", target_id: "Chg:1" },
+        { type: "reject", target_id: "Chg:2" },
+      ]);
+    } catch (e) {
+      error = e;
+    }
+    expect(error).toBeInstanceOf(BatchValidationError);
+    const msg = (error.errors || []).join("\n");
+    expect(msg).toContain("Chg:1");
+    expect(msg).toContain("Chg:2");
+    expect(msg.toLowerCase()).toContain("pair");
+    // Transactional: nothing may have been resolved.
+    expect(findAllDescendants(doc.element, "w:ins").length).toBeGreaterThan(0);
+    expect(findAllDescendants(doc.element, "w:del").length).toBeGreaterThan(0);
+  });
+
+  it("independent changes still resolve independently", async () => {
+    const doc = await createTestDocument();
+    addParagraph(doc, "First paragraph mentioning alpha.");
+    addParagraph(doc, "Second paragraph mentioning beta.");
+    const engine = new RedlineEngine(doc, "Editor");
+    engine.apply_edits([
+      { type: "modify", target_text: "alpha", new_text: "ALPHA" },
+    ]);
+    engine.apply_edits([
+      { type: "modify", target_text: "beta", new_text: "BETA" },
+    ]);
+    const doc2 = await DocumentObject.load(await doc.save());
+
+    const raw = await extractTextFromBuffer(await doc2.save());
+    const del_ids = [...raw.matchAll(/\[Chg:(\d+) delete\]/g)].map(
+      (m) => m[1],
+    );
+    expect(del_ids.length).toBe(2);
+
+    const engine2 = new RedlineEngine(doc2, "Reviewer");
+    const stats = engine2.process_batch([
+      { type: "accept", target_id: `Chg:${del_ids[0]}` },
+      { type: "reject", target_id: `Chg:${del_ids[1]}` },
+    ]);
+    expect(stats.actions_applied).toBe(2);
+    expect(stats.actions_already_resolved || 0).toBe(0);
+
+    const final = cleanText(doc2);
+    expect(final).toContain("ALPHA");
+    expect(final).toContain("beta");
+    expect(final).not.toContain("BETA");
+  });
+});

package/src/sanitize/core.ts

@@ -69,6 +69,7 @@ export async function finalize_document(doc: DocumentObject, options: FinalizeOp
   report.add_transform_lines(transforms.scrub_timestamps(doc));
   report.add_transform_lines(transforms.strip_custom_xml(doc));
   report.add_transform_lines(transforms.strip_custom_properties(doc));
+  report.add_transform_lines(transforms.strip_document_variables(doc));
   report.add_transform_lines(transforms.strip_image_alt_text(doc));
   
   const warnings = transforms.audit_hyperlinks(doc);
@@ -181,6 +182,16 @@ export function verifySanitizedPackage(outBuffer: Buffer): void {
       }
     }
   }
+  if (names.includes('word/settings.xml')) {
+    // Document variables are invisible metadata (QA ADEU-QA-001): a surviving
+    // w:docVar means the strip transform silently failed.
+    const settings = parseXml(strFromU8(unzipped['word/settings.xml']));
+    if (
+      transforms.findDescendantsByLocalName(settings.documentElement! as unknown as Element, 'docVar').length > 0
+    ) {
+      problems.push('word/settings.xml still contains document variables (w:docVar)');
+    }
+  }
 
   if (problems.length > 0) {
     throw new Error(