@ansonlai/docx-redline-js 0.2.1 → 0.4.0

package/pipeline/patching.js

@@ -182,9 +182,8 @@ export function applyPatches(splitModel, diffOps, options) {
 
 function processInsertionOperation(context) {
     const {
-        insertOp,
-        splitModel,
-        styleLookup,
+        insertOp,
+        styleLookup,
         patchedModel,
         state,
         options,

package/pipeline/pipeline.js

@@ -16,7 +16,7 @@ import { detectNumberingContext } from './ingestion.js';
 import { generateTableOoxml } from '../services/table-reconciliation.js';
 import { executeListGeneration, detectIndentationStep } from './list-generation.js';
 import { detectContentType, parseListItems, parseTable } from './content-analysis.js';
-import { createParser } from '../adapters/xml-adapter.js';
+import { parseOoxmlSafe } from '../adapters/xml-adapter.js';
 import { log, error as logError } from '../adapters/logger.js';
 import { getFirstElementByTagNS, getXmlParseError } from '../core/xml-query.js';
 import { getPlatform } from '../adapters/config.js';
@@ -54,6 +54,7 @@ export class ReconciliationPipeline {
         this.validationMode = options.validationMode ?? 'auto';
         this.numberingService = options.numberingService || new NumberingService();
         this.font = options.font || null;
+        this.revisionIdAllocator = options.revisionIdAllocator || null;
         this.platform = options.platform ?? getPlatform();
         this.isWebPlatform = options.isWebPlatform ?? isWebPlatform(this.platform);
         this.enableEventLoopYielding = options.enableEventLoopYielding ?? this.isWebPlatform;
@@ -75,10 +76,20 @@ export class ReconciliationPipeline {
 
         try {
             // Stage 1: Ingest OOXML
-            const doc = options.xmlDoc || (() => {
-                const parser = createParser();
-                return parser.parseFromString(originalOoxml, 'application/xml');
-            })();
+            const parsed = options.xmlDoc
+                ? { doc: options.xmlDoc, error: null, warnings: [] }
+                : parseOoxmlSafe(originalOoxml, 'application/xml');
+            if (parsed.error || !parsed.doc) {
+                return {
+                    ooxml: originalOoxml,
+                    isValid: false,
+                    status: 'error',
+                    error: parsed.error,
+                    warnings: parsed.warnings || []
+                };
+            }
+            warnings.push(...(parsed.warnings || []));
+            const doc = parsed.doc;
             const pElement = getFirstElementByTagNS(doc, '*', 'p');
 
             const { runModel, acceptedText, pPr } = ingestOoxml(originalOoxml, { xmlDoc: doc });
@@ -122,19 +133,28 @@ export class ReconciliationPipeline {
             }
             await this.maybeYield(runModel.length, Math.max(acceptedText.length, cleanText.length));
 
-            // Count actual paragraph elements ingested
-            const paragraphCount = runModel.filter(r => r.kind === RunKind.PARAGRAPH_START).length;
-
+            // Count actual paragraph elements ingested
+            const paragraphCount = runModel.filter(r => r.kind === RunKind.PARAGRAPH_START).length;
+            const sourceIsMarkedMultilineList = isListTargetStrict(acceptedText) || isListTargetLoose(acceptedText);
+            const canPatchExistingMarkedList = isTargetList
+                && sourceIsMarkedMultilineList
+                && paragraphCount > 1
+                && acceptedText !== cleanText;
+
             log(`[Reconcile] isTargetList: ${isTargetList}, paragraphCount: ${paragraphCount}`);
-
-            // If target is a list, always use list generation logic
-            // This handles both expansion (1 para -> N items) and conversion (N paras -> M items)
-            if (isTargetList) {
-                log('[Reconcile] 🎯 ENTERING LIST GENERATION PATH');
-                log(`[Reconcile] cleanText preview: ${cleanText.substring(0, 100)}...`);
-                log(`[Reconcile] acceptedText preview: ${acceptedText.substring(0, 100)}...`);
-                return this.executeListGeneration(cleanText, numberingContext, runModel);
-            }
+
+            // Preserve already-marked multi-paragraph lists during ordinary text edits.
+            // Rebuilding the whole block would discard unchanged run formatting and
+            // place all source deletion runs in the first generated paragraph, which
+            // makes rejection merge the original paragraph boundaries.
+            if (canPatchExistingMarkedList) {
+                log('[Reconcile] Existing marked list edit detected; using run-aware patching to preserve formatting and paragraph boundaries.');
+            } else if (isTargetList) {
+                log('[Reconcile] 🎯 ENTERING LIST GENERATION PATH');
+                log(`[Reconcile] cleanText preview: ${cleanText.substring(0, 100)}...`);
+                log(`[Reconcile] acceptedText preview: ${acceptedText.substring(0, 100)}...`);
+                return this.executeListGeneration(cleanText, numberingContext, runModel);
+            }
 
             log(`[Reconcile] Computed ${diffOps.length} diff operations`);
 
@@ -153,9 +173,10 @@ export class ReconciliationPipeline {
             await this.maybeYield(patchedModel.length, Math.max(acceptedText.length, cleanText.length));
 
             // Stage 6: Serialize to OOXML
-            const resultOoxml = serializeToOoxml(patchedModel, pPr, formatHints, {
-                author: this.author,
-                generateRedlines: this.generateRedlines
+            const resultOoxml = serializeToOoxml(patchedModel, pPr, formatHints, {
+                author: this.author,
+                generateRedlines: this.generateRedlines,
+                revisionIdAllocator: this.revisionIdAllocator
             });
 
             // Stage 7: Basic validation
@@ -172,14 +193,15 @@ export class ReconciliationPipeline {
                 warnings
             };
 
-        } catch (error) {
-            logError('[Reconcile] Pipeline error:', error);
-            return {
-                ooxml: originalOoxml,
-                isValid: false,
-                warnings: [`Pipeline error: ${error.message}`]
-            };
-        }
+        } catch (error) {
+            logError('[Reconcile] Pipeline error:', error);
+            return {
+                ooxml: originalOoxml,
+                isValid: false,
+                warnings: [`Pipeline error: ${error.message}`],
+                error: error?.code ? { code: error.code, message: error.message } : undefined
+            };
+        }
     }
 
     /**
@@ -194,8 +216,13 @@ export class ReconciliationPipeline {
         try {
             // Check for well-formed XML by wrapping in namespace container
             const wrappedXml = `<root xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">${ooxml}</root>`;
-            const parser = createParser();
-            const doc = parser.parseFromString(wrappedXml, 'application/xml');
+            const parsed = parseOoxmlSafe(wrappedXml, 'application/xml');
+            const doc = parsed.doc;
+
+            if (parsed.error || !doc) {
+                errors.push('Generated OOXML is not well-formed XML: ' + (parsed.error?.message || 'parse error'));
+                return { isValid: false, errors };
+            }
 
             const parseError = getXmlParseError(doc);
             if (parseError) {
@@ -276,9 +303,10 @@ export class ReconciliationPipeline {
             originalRunModel,
             originalText,
             generateRedlines: this.generateRedlines,
-            author: this.author,
-            font: this.font,
-            numberingService: this.numberingService
+            author: this.author,
+            font: this.font,
+            revisionIdAllocator: this.revisionIdAllocator,
+            numberingService: this.numberingService
         });
     }
 
@@ -309,9 +337,10 @@ export class ReconciliationPipeline {
             };
         }
 
-        const tableOoxml = generateTableOoxml(tableData, {
-            generateRedlines: this.generateRedlines,
-            author: this.author
+        const tableOoxml = generateTableOoxml(tableData, {
+            generateRedlines: this.generateRedlines,
+            author: this.author,
+            revisionIdAllocator: this.revisionIdAllocator
         });
 
         return {

package/pipeline/serialization.js

@@ -24,7 +24,7 @@ const XMLNS_ATTR_REGEX = /\s+xmlns:[^=]+="[^"]*"/g;
  */
 export function serializeToOoxml(patchedModel, pPr, formatHints = [], options = {}) {
     const serializationOptions = normalizeSerializationOptions(options);
-    const { author, generateRedlines } = serializationOptions;
+    const { generateRedlines } = serializationOptions;
     const paragraphs = [];
     let currentPPrXml = '';
     let currentPPrElement = null;
@@ -140,7 +140,8 @@ function normalizeSerializationOptions(options) {
         return {
             author: getDefaultAuthor(),
             generateRedlines: true,
-            font: options
+            font: options,
+            revisionIdAllocator: null
         };
     }
 
@@ -152,7 +153,8 @@ function normalizeSerializationOptions(options) {
     return {
         author: resolvedAuthor,
         generateRedlines: normalized.generateRedlines ?? true,
-        font: normalized.font ?? null
+        font: normalized.font ?? null,
+        revisionIdAllocator: normalized.revisionIdAllocator ?? null
     };
 }
 
@@ -228,7 +230,10 @@ function buildSimpleRun(text, rPrXml) {
  * @returns {string}
  */
 function buildDeletionXml(item, options = {}) {
-    const metadata = createRevisionMetadata(options.author ?? getDefaultAuthor());
+    const metadata = createRevisionMetadata(
+        options.author ?? getDefaultAuthor(),
+        options.revisionIdAllocator
+    );
     const font = options.font ?? null;
     let rPr = item.rPrXml ? stripNamespaceDeclarations(item.rPrXml) : '';
 
@@ -250,7 +255,10 @@ function buildDeletionXml(item, options = {}) {
  * @returns {string}
  */
 function buildInsertionXml(item, formatHints, options = {}) {
-    const metadata = createRevisionMetadata(options.author ?? getDefaultAuthor());
+    const metadata = createRevisionMetadata(
+        options.author ?? getDefaultAuthor(),
+        options.revisionIdAllocator
+    );
     const font = options.font ?? null;
 
     // Build the inner run content with format hints

package/scripts/build-test-dashboard.mjs

@@ -0,0 +1,43 @@
+import { execFileSync } from 'child_process';
+import { existsSync, readFileSync } from 'fs';
+import { join, resolve } from 'path';
+
+const repoRoot = process.cwd();
+const syntheticDir = join(repoRoot, 'tmp', 'dashboard-docx');
+const corpusSourceDir = join(repoRoot, 'tmp', 'superdoc-corpus');
+const corpusFixturesArgIndex = process.argv.indexOf('--corpus-fixtures-dir');
+if (corpusFixturesArgIndex >= 0 && !process.argv[corpusFixturesArgIndex + 1]) {
+    throw new Error('--corpus-fixtures-dir requires a path');
+}
+const suppliedCorpusFixturesDir = corpusFixturesArgIndex >= 0;
+const corpusFixturesDir = suppliedCorpusFixturesDir
+    ? resolve(repoRoot, process.argv[corpusFixturesArgIndex + 1])
+    : join(repoRoot, 'tmp', 'superdoc-word-fixtures');
+const manifest = JSON.parse(readFileSync(
+    join(repoRoot, 'tests', 'corpus', 'superdoc-english-legal-administrative.json'),
+    'utf8'
+));
+const run = (script, args = []) => execFileSync(process.execPath, [script, ...args], {
+    cwd: repoRoot,
+    stdio: 'inherit'
+});
+
+run('scripts/export-validation-fixtures.mjs', ['--output-dir', syntheticDir]);
+
+const corpusReady = manifest.documents.every(item =>
+    existsSync(join(corpusSourceDir, `${item.id}.docx`))
+);
+if (corpusReady && suppliedCorpusFixturesDir) {
+    if (!existsSync(join(corpusFixturesDir, 'suite.json'))) {
+        throw new Error(`Supplied corpus fixture directory has no suite.json: ${corpusFixturesDir}`);
+    }
+} else if (corpusReady) {
+    run('scripts/prepare-superdoc-word-corpus.mjs');
+} else {
+    console.warn('Real-document corpus is not downloaded; embedding synthetic DOCX previews only.');
+    console.warn('Run npm run test:corpus:word once to fetch and validate the pinned corpus.');
+}
+
+const args = ['scripts/generate-test-dashboard.mjs', '--fixtures-dir', syntheticDir];
+if (corpusReady) args.push('--corpus-fixtures-dir', corpusFixturesDir);
+run(args[0], args.slice(1));

package/scripts/check-types.mjs

@@ -1,29 +1,21 @@
-import { readFileSync } from 'fs';
+import { readFileSync } from 'node:fs';
 
-const dts = readFileSync(new URL('../index.d.ts', import.meta.url), 'utf8');
-
-const requiredSnippets = [
-  'export interface RedlineOptions',
-  'export interface RedlineResult',
-  'export function applyRedlineToOxml',
-  'export function acceptTrackedChangesInOoxml',
-  'export function rejectTrackedChangesInOoxml',
-  'export function deleteCommentsByAuthorInOoxml',
-  'export function validateRedlineOoxml'
-];
-
-for (const snippet of requiredSnippets) {
-  if (!dts.includes(snippet)) {
-    throw new Error(`Missing declaration snippet: ${snippet}`);
-  }
+const declarationPath = new URL('../index.d.ts', import.meta.url);
+const declarationText = readFileSync(declarationPath, 'utf8');
+const declaredRuntimeNames = new Set();
+const declarationPattern = /^export\s+(?:declare\s+)?(?:function|class|const|let|var|enum)\s+([A-Za-z_$][\w$]*)/gm;
+for (const match of declarationText.matchAll(declarationPattern)) {
+    declaredRuntimeNames.add(match[1]);
 }
 
-let balance = 0;
-for (const char of dts) {
-  if (char === '{') balance += 1;
-  if (char === '}') balance -= 1;
-  if (balance < 0) throw new Error('index.d.ts has unbalanced braces');
+const runtimeModule = await import('../index.js');
+const runtimeNames = Object.keys(runtimeModule).sort();
+const missingDeclarations = runtimeNames.filter(name => !declaredRuntimeNames.has(name));
+
+if (missingDeclarations.length > 0) {
+    throw new Error(
+        `Runtime exports missing from index.d.ts:\n${missingDeclarations.map(name => `- ${name}`).join('\n')}`
+    );
 }
-if (balance !== 0) throw new Error('index.d.ts has unbalanced braces');
 
-console.log('PASS: index.d.ts declaration smoke check');
+console.log(`PASS: ${runtimeNames.length} runtime exports have declarations`);

package/scripts/export-validation-fixtures.mjs

@@ -1,71 +1,158 @@
+import { createHash } from 'crypto';
 import { mkdirSync, writeFileSync } from 'fs';
-import { join } from 'path';
+import { join, resolve } from 'path';
 
 import { configureXmlProvider } from '../adapters/xml-adapter.js';
 import { validateRedlineOoxml } from '../core/redline-validation.js';
 import { preprocessMarkdown } from '../pipeline/markdown-processor.js';
-import { applyOperationToDocumentXml } from '../services/standalone-operation-runner.js';
-import { buildMinimalDocx } from './lib/minimal-zip.mjs';
+import {
+  applyOperationToDocumentXml,
+  applyOperationsToDocumentXml
+} from '../services/standalone-operation-runner.js';
+import { buildMinimalDocx, buildMinimalDocxEntries } from './lib/minimal-zip.mjs';
+import { unzipEntries } from './lib/zip-reader.mjs';
+import {
+  acceptTrackedChangesInOoxml,
+  rejectTrackedChangesInOoxml
+} from '../services/revision-comment-management.js';
+import { WORD_TASK_CASES } from '../tests/fixtures/word-task-cases.mjs';
 
 const { DOMParser, XMLSerializer } = await import('@xmldom/xmldom');
 configureXmlProvider({ DOMParser, XMLSerializer });
 
 const NS_W = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
-const outputDir = join(process.cwd(), 'tmp', 'validation-docx');
+const outputArgIndex = process.argv.indexOf('--output-dir');
+const requestedOutputDir = outputArgIndex >= 0 ? process.argv[outputArgIndex + 1] : null;
+if (outputArgIndex >= 0 && !requestedOutputDir) throw new Error('--output-dir requires a path');
+const outputDir = requestedOutputDir
+  ? resolve(process.cwd(), requestedOutputDir)
+  : join(process.cwd(), 'tmp', 'validation-docx');
 mkdirSync(outputDir, { recursive: true });
 
+const escapeXmlText = text => String(text)
+  .replace(/&/g, '&')
+  .replace(/</g, '&lt;')
+  .replace(/>/g, '&gt;');
+
 const baseDocument = text => `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
 <w:document xmlns:w="${NS_W}">
   <w:body>
-    <w:p><w:r><w:t xml:space="preserve">${text}</w:t></w:r></w:p>
+    ${String(text).split(/\r?\n/).map(paragraphText =>
+      `<w:p><w:r><w:t xml:space="preserve">${escapeXmlText(paragraphText)}</w:t></w:r></w:p>`
+    ).join('\n    ')}
     <w:sectPr/>
   </w:body>
 </w:document>`;
 
-const cases = [
-  {
-    name: 'simple-redline',
-    original: 'The old sentence.',
-    modified: 'The new sentence.'
-  },
-  {
-    name: 'paragraph-insert',
-    original: 'one',
-    modified: 'one\ntwo'
-  },
-  {
-    name: 'format-only',
-    original: 'Make word bold',
-    modified: 'Make **word** bold'
-  },
-  {
-    name: 'whitespace-heavy',
-    original: 'Alpha beta gamma delta.',
-    modified: 'Alpha  beta REPLACED delta.'
-  },
-  {
-    name: 'unicode-replace',
-    original: 'Term 条款 applies to café.',
-    modified: 'Term 合同 applies to café 🚀.'
-  }
-];
+const cases = WORD_TASK_CASES;
 
 let failures = 0;
 
 for (const testCase of cases) {
-  const result = await applyOperationToDocumentXml(
-    baseDocument(testCase.original),
-    { type: 'redline', target: testCase.original, modified: testCase.modified },
-    'Validation',
-    null,
-    { generateRedlines: true }
-  );
-
-  if (!result?.hasChanges || result?.status === 'error') {
+  const sourceDocumentXml = testCase.sourceDocumentXml || baseDocument(testCase.sourceText || testCase.original);
+  const operationOptions = { generateRedlines: true, ...(testCase.operationOptions || {}) };
+  const result = Array.isArray(testCase.batchOperations)
+    ? await applyOperationsToDocumentXml(
+      sourceDocumentXml,
+      testCase.batchOperations,
+      'Validation',
+      null,
+      operationOptions
+    )
+    : await applyOperationToDocumentXml(
+      sourceDocumentXml,
+      testCase.operation || { type: 'redline', target: testCase.original, modified: testCase.modified },
+      'Validation',
+      null,
+      operationOptions
+    );
+
+  if (testCase.expectAtomicRollback) {
+    if (
+      result?.hasChanges ||
+      result?.rolledBack !== true ||
+      result?.error?.code !== 'BATCH_OPERATION_FAILED' ||
+      result?.documentXml !== sourceDocumentXml
+    ) {
+      console.error(`FAIL ${testCase.name}: expected an atomic batch rollback`);
+      failures++;
+      continue;
+    }
+  } else if ((!result?.hasChanges && !testCase.expectNoOp) || result?.status === 'error') {
     console.error(`FAIL ${testCase.name}: redline did not apply (status=${result?.status}, error=${result?.error?.message})`);
     failures++;
     continue;
   }
+  if (testCase.expectNoOp && (result?.hasChanges || result?.status !== 'no-op' || result?.documentXml !== sourceDocumentXml)) {
+    console.error(`FAIL ${testCase.name}: expected a byte-identical no-op preserving prior revisions`);
+    failures++;
+    continue;
+  }
+
+  if (Number.isInteger(testCase.maxRevisionId)) {
+    const resultDoc = new DOMParser().parseFromString(result.documentXml, 'application/xml');
+    const revisionNames = ['ins', 'del', 'moveFrom', 'moveTo', 'rPrChange', 'pPrChange', 'cellIns', 'cellDel'];
+    const revisionIds = revisionNames
+      .flatMap(name => Array.from(resultDoc.getElementsByTagNameNS(NS_W, name)))
+      .map(node => Number.parseInt(node.getAttribute('w:id') || node.getAttribute('id') || '', 10))
+      .filter(Number.isFinite);
+    if (revisionIds.length === 0 || revisionIds.some(id => id > testCase.maxRevisionId)) {
+      console.error(`FAIL ${testCase.name}: revision IDs exceeded ${testCase.maxRevisionId}: ${revisionIds.join(', ')}`);
+      failures++;
+      continue;
+    }
+  }
+
+  if (testCase.requiredElements) {
+    const resultDoc = new DOMParser().parseFromString(result.documentXml, 'application/xml');
+    let missingRequiredElement = false;
+    for (const [localName, minimumCount] of Object.entries(testCase.requiredElements)) {
+      const actualCount = resultDoc.getElementsByTagNameNS(NS_W, localName).length;
+      if (actualCount < minimumCount) {
+        console.error(`FAIL ${testCase.name}: expected at least ${minimumCount} w:${localName} element(s), found ${actualCount}`);
+        failures++;
+        missingRequiredElement = true;
+      }
+    }
+    if (missingRequiredElement) continue;
+  }
+
+  if (testCase.requiredNumberingFormats) {
+    const numberingXml = testCase.packageParts?.numberingXml || result.numberingXml || '';
+    for (const format of testCase.requiredNumberingFormats) {
+      if (!numberingXml.includes(`<w:numFmt w:val="${format}"`)) {
+        console.error(`FAIL ${testCase.name}: required numbering format ${format} is missing`);
+        failures++;
+        continue;
+      }
+    }
+  }
+
+  if (testCase.requiredElementParents || testCase.requiredElementText) {
+    const resultDoc = new DOMParser().parseFromString(result.documentXml, 'application/xml');
+    let structuralRequirementFailed = false;
+
+    for (const [localName, parentLocalName] of Object.entries(testCase.requiredElementParents || {})) {
+      const nodes = Array.from(resultDoc.getElementsByTagNameNS(NS_W, localName));
+      const invalidNodes = nodes.filter(node => node.parentNode?.namespaceURI !== NS_W || node.parentNode?.localName !== parentLocalName);
+      if (invalidNodes.length > 0) {
+        console.error(`FAIL ${testCase.name}: ${invalidNodes.length} w:${localName} element(s) were not direct children of w:${parentLocalName}`);
+        failures++;
+        structuralRequirementFailed = true;
+      }
+    }
+
+    for (const [localName, expectedTexts] of Object.entries(testCase.requiredElementText || {})) {
+      const actualTexts = Array.from(resultDoc.getElementsByTagNameNS(NS_W, localName), node => node.textContent || '');
+      if (JSON.stringify(actualTexts) !== JSON.stringify(expectedTexts)) {
+        console.error(`FAIL ${testCase.name}: w:${localName} text mismatch; expected ${JSON.stringify(expectedTexts)}, found ${JSON.stringify(actualTexts)}`);
+        failures++;
+        structuralRequirementFailed = true;
+      }
+    }
+
+    if (structuralRequirementFailed) continue;
+  }
 
   const validation = validateRedlineOoxml(result.documentXml);
   const validationErrors = validation.issues.filter(issue => issue.severity === 'error');
@@ -80,22 +167,79 @@ for (const testCase of cases) {
     writeFileSync(join(outputDir, `${testCase.name}.numbering.xml`), result.numberingXml, 'utf8');
   }
 
-  const docx = buildMinimalDocx(result.documentXml, { numberingXml: result.numberingXml || null });
+  const packageParts = {
+    numberingXml: result.numberingXml || null,
+    ...(testCase.packageParts || {})
+  };
+  let packageEntries;
+  let docx;
+  try {
+    packageEntries = buildMinimalDocxEntries(result.documentXml, packageParts);
+    docx = buildMinimalDocx(result.documentXml, packageParts);
+  } catch (error) {
+    console.error(`FAIL ${testCase.name}: package validation failed: ${error.message}`);
+    failures++;
+    continue;
+  }
+
+  const unpacked = unzipEntries(docx);
+  const untouchedPartSha256 = {};
+  for (const entry of packageEntries.filter(item => /^word\/(?:comments|footnotes|endnotes|header[0-9]+|footer[0-9]+)\.xml$/.test(item.name))) {
+    const expectedBytes = Buffer.isBuffer(entry.data) ? entry.data : Buffer.from(entry.data, 'utf8');
+    const actualBytes = unpacked.get(entry.name);
+    if (!actualBytes?.equals(expectedBytes)) {
+      console.error(`FAIL ${testCase.name}: packaged ${entry.name} was not byte-identical to the configured source part`);
+      failures++;
+      docx = null;
+      break;
+    }
+    untouchedPartSha256[entry.name] = createHash('sha256').update(actualBytes).digest('hex');
+  }
+  if (!docx) continue;
   writeFileSync(join(outputDir, `${testCase.name}.docx`), docx);
 
+  const sourceDocx = buildMinimalDocx(sourceDocumentXml, testCase.packageParts || {});
+  const acceptedXml = acceptTrackedChangesInOoxml(result.documentXml, { allAuthors: true }).oxml;
+  const rejectedXml = rejectTrackedChangesInOoxml(result.documentXml, { allAuthors: true }).oxml;
+  const acceptedDocx = buildMinimalDocx(acceptedXml, packageParts);
+  const rejectedDocx = buildMinimalDocx(rejectedXml, packageParts);
+  writeFileSync(join(outputDir, `${testCase.name}.source.docx`), sourceDocx);
+  writeFileSync(join(outputDir, `${testCase.name}.accepted.docx`), acceptedDocx);
+  writeFileSync(join(outputDir, `${testCase.name}.rejected.docx`), rejectedDocx);
+
   // Expected text is derived from edit *intent*, not from this library's
   // accept/reject transforms, so external consumers (Word COM, LibreOffice)
   // act as independent oracles.
   const expected = {
     name: testCase.name,
-    expectedAcceptedText: preprocessMarkdown(testCase.modified).cleanText,
-    expectedRejectedText: testCase.original
+    category: testCase.category,
+    task: testCase.task,
+    coverageMetadata: testCase.coverageMetadata,
+    textFidelity: testCase.textFidelity || 'exact',
+    assertionMode: testCase.assertionMode || 'exact',
+    expectedAcceptedText: testCase.expectedAcceptedText ?? preprocessMarkdown(testCase.modified).cleanText,
+    expectedRejectedText: testCase.expectedRejectedText ?? testCase.original,
+    ...(testCase.assertionMode === 'contains' ? {
+      expectedAcceptedContains: testCase.expectedAcceptedContains || [],
+      expectedAcceptedAbsent: testCase.expectedAcceptedAbsent || [],
+      expectedRejectedContains: testCase.expectedRejectedContains || [],
+      expectedRejectedAbsent: testCase.expectedRejectedAbsent || []
+    } : {}),
+    sourceText: testCase.sourceText || testCase.original,
+    modifiedText: preprocessMarkdown(testCase.modified).cleanText,
+    requiredNumberingFormats: testCase.requiredNumberingFormats || [],
+    untouchedPartSha256
   };
   writeFileSync(join(outputDir, `${testCase.name}.expected.json`), `${JSON.stringify(expected, null, 2)}\n`, 'utf8');
 
-  console.log(`wrote ${testCase.name}: .document.xml, .docx, .expected.json`);
+  console.log(`wrote ${testCase.name}: source, tracked, accepted, rejected, XML, and expectations`);
 }
 
+writeFileSync(join(outputDir, 'suite.json'), `${JSON.stringify({
+  name: 'English legal and administrative Word differential suite',
+  cases: cases.map(testCase => testCase.name)
+}, null, 2)}\n`, 'utf8');
+
 writeFileSync(join(outputDir, 'README.md'), `# Validation Fixtures
 
 Generated by \`node scripts/export-validation-fixtures.mjs\`.
@@ -106,6 +250,8 @@ Each case produces:
   XSD validation and manual inspection).
 - \`<name>.docx\` — a minimal package assembled by release tooling only (the
   published library still has no zip dependency).
+- \`<name>.source.docx\`, \`<name>.accepted.docx\`, and
+  \`<name>.rejected.docx\` — comparison states for the local HTML dashboard.
 - \`<name>.expected.json\` — the accept-all / reject-all plain-text outcomes
   derived from edit intent, used by external-consumer differential checks.