@ansonlai/docx-redline-js 0.8.4 → 0.10.0

package/pipeline/markdown-processor.js

@@ -35,7 +35,10 @@ const MARKDOWN_PATTERNS = [
     { regex: /\*\*\+\+(.+?)\+\+\*\*/, format: { bold: true, underline: true } },
     // Bold: **text** or __text__
     { regex: /\*\*(.+?)\*\*/, format: { bold: true } },
-    { regex: /__(.+?)__/, format: { bold: true } },
+    // Underscore delimiters follow CommonMark flanking rules: not intraword, not part of a
+    // longer underscore run, and never around whitespace. So signature lines ("_____")
+    // and snake_case identifiers stay literal text.
+    { regex: /(?<![A-Za-z0-9_])__(?=[^_\s])(.+?)(?<=[^_\s])__(?![A-Za-z0-9_])/, format: { bold: true } },
     // Underline: ++text++
     { regex: /\+\+(.+?)\+\+/, format: { underline: true } },
     // Strikethrough: ~~text~~ or ~text~
@@ -43,7 +46,7 @@ const MARKDOWN_PATTERNS = [
     { regex: /~(.+?)~/, format: { strikethrough: true } },
     // Italic: *text* or _text_ (using lookahead only for compatibility)
     { regex: /\*(?!\*)(.+?)\*(?!\*)/, format: { italic: true } },
-    { regex: /_(?!_)(.+?)_(?!_)/, format: { italic: true } }
+    { regex: /(?<![A-Za-z0-9_])_(?=[^_\s])(.+?)(?<=[^_\s])_(?![A-Za-z0-9_])/, format: { italic: true } }
 ];
 
 /**

package/pipeline/pipeline.js

@@ -6,7 +6,7 @@
 
 import { ingestOoxml } from './ingestion.js';
 import { preprocessMarkdown } from './markdown-processor.js';
-import { isListTargetLoose, isListTargetStrict } from './list-markers.js';
+import { isListTargetLoose, isListTargetStrict } from './list-markers.js';
 import { computeWordLevelDiffOps } from './diff-engine.js';
 import { splitRunsAtDiffBoundaries, applyPatches } from './patching.js';
 import { serializeToOoxml, wrapInDocumentFragment } from './serialization.js';
@@ -15,26 +15,26 @@ import { NumberingService } from '../services/numbering-service.js';
 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 { 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';
-
-const WEB_PLATFORM_NAMES = new Set(['officeonline', 'officeweb', 'web']);
-
-function isWebPlatform(platform) {
-    if (!platform) return false;
-    return WEB_PLATFORM_NAMES.has(String(platform).toLowerCase());
-}
-
-function isProductionBuild() {
-    return typeof process !== 'undefined' && process?.env?.NODE_ENV === 'production';
-}
-
-function yieldToEventLoop() {
-    return new Promise(resolve => setTimeout(resolve, 0));
-}
+import { detectContentType, parseListItems, parseTable } from './content-analysis.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';
+
+const WEB_PLATFORM_NAMES = new Set(['officeonline', 'officeweb', 'web']);
+
+function isWebPlatform(platform) {
+    if (!platform) return false;
+    return WEB_PLATFORM_NAMES.has(String(platform).toLowerCase());
+}
+
+function isProductionBuild() {
+    return typeof process !== 'undefined' && process?.env?.NODE_ENV === 'production';
+}
+
+function yieldToEventLoop() {
+    return new Promise(resolve => setTimeout(resolve, 0));
+}
 
 /**
  * Main reconciliation pipeline class.
@@ -47,114 +47,114 @@ export class ReconciliationPipeline {
      * @param {string} [options.author='AI'] - Author for track changes
      * @param {boolean} [options.validateOutput=true] - Validate output before returning
      */
-    constructor(options = {}) {
-        this.generateRedlines = options.generateRedlines ?? true;
-        this.author = options.author ?? 'AI';
-        this.validateOutput = options.validateOutput ?? true;
-        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;
-        this.yieldRunThreshold = options.yieldRunThreshold ?? 50;
-        this.yieldCharThreshold = options.yieldCharThreshold ?? 5000;
-        this.disableSemanticCleanupOverChars = options.disableSemanticCleanupOverChars ?? (this.isWebPlatform ? 8000 : Number.POSITIVE_INFINITY);
-    }
+    constructor(options = {}) {
+        this.generateRedlines = options.generateRedlines ?? true;
+        this.author = options.author ?? 'AI';
+        this.validateOutput = options.validateOutput ?? true;
+        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;
+        this.yieldRunThreshold = options.yieldRunThreshold ?? 50;
+        this.yieldCharThreshold = options.yieldCharThreshold ?? 5000;
+        this.disableSemanticCleanupOverChars = options.disableSemanticCleanupOverChars ?? (this.isWebPlatform ? 8000 : Number.POSITIVE_INFINITY);
+    }
 
     /**
-     * Executes the reconciliation pipeline.
-     * 
-     * @param {string} originalOoxml - Original OOXML paragraph content
-     * @param {string} newText - New text with optional markdown formatting
-     * @param {{ xmlDoc?: Document|null }} [options={}] - Optional execution options
-     * @returns {Promise<import('../core/types.js').ReconciliationResult>}
-     */
-    async execute(originalOoxml, newText, options = {}) {
-        const warnings = [];
-
-        try {
-            // Stage 1: Ingest OOXML
-            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 });
-            const numberingContext = pElement ? detectNumberingContext(pElement) : null;
-
-            log(`[Reconcile] Ingested ${runModel.length} runs, ${acceptedText.length} chars, numbering:`, numberingContext);
-            await this.maybeYield(runModel.length, Math.max(acceptedText.length, newText?.length || 0));
-
-            // Stage 2: Preprocess markdown
-            const { cleanText, formatHints } = preprocessMarkdown(newText);
-            log(`[Reconcile] Preprocessed: ${formatHints.length} format hints`);
-            await this.maybeYield(runModel.length, Math.max(acceptedText.length, cleanText.length));
-
-            // Detect list-target content before any no-op short-circuit.
-            // Structural conversion may still be required even when text is identical
-            // (for example plain "A./B./C." lines -> true Word numbered list paragraphs).
-            const isTargetListStrict = isListTargetStrict(cleanText);
-            const isTargetListLoose = isListTargetLoose(cleanText);
-            const isTargetList = isTargetListStrict || isTargetListLoose;
-            if (!isTargetListStrict && isTargetListLoose) {
-                log('[Reconcile] List-target detected via loose marker parsing; bypassing no-op short-circuit for structural conversion.');
-            }
-
-            // Early exit if no change
-            if (acceptedText === cleanText && formatHints.length === 0 && !isTargetList) {
-                log('[Reconcile] No changes detected');
-                return {
-                    ooxml: originalOoxml,
-                    isValid: true,
-                    warnings: ['No changes detected']
+     * Executes the reconciliation pipeline.
+     * 
+     * @param {string} originalOoxml - Original OOXML paragraph content
+     * @param {string} newText - New text with optional markdown formatting
+     * @param {{ xmlDoc?: Document|null }} [options={}] - Optional execution options
+     * @returns {Promise<import('../core/types.js').ReconciliationResult>}
+     */
+    async execute(originalOoxml, newText, options = {}) {
+        const warnings = [];
+
+        try {
+            // Stage 1: Ingest OOXML
+            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 || []
                 };
-            }
-
-            // Stage 3: Compute word-level diff
-            const shouldCleanupSemantic = Math.max(acceptedText.length, cleanText.length) < this.disableSemanticCleanupOverChars;
-            const diffOps = computeWordLevelDiffOps(acceptedText, cleanText, {
-                cleanupSemantic: shouldCleanupSemantic
-            });
-            if (!shouldCleanupSemantic) {
-                log('[Reconcile] Skipping semantic diff cleanup for large web payload');
-            }
-            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;
-            const sourceIsMarkedMultilineList = isListTargetStrict(acceptedText) || isListTargetLoose(acceptedText);
-            const canPatchExistingMarkedList = isTargetList
-                && sourceIsMarkedMultilineList
-                && paragraphCount > 1
-                && acceptedText !== cleanText;
-
-            log(`[Reconcile] isTargetList: ${isTargetList}, paragraphCount: ${paragraphCount}`);
-
-            // 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);
-            }
+            }
+            warnings.push(...(parsed.warnings || []));
+            const doc = parsed.doc;
+            const pElement = getFirstElementByTagNS(doc, '*', 'p');
+
+            const { runModel, acceptedText, pPr } = ingestOoxml(originalOoxml, { xmlDoc: doc });
+            const numberingContext = pElement ? detectNumberingContext(pElement) : null;
+
+            log(`[Reconcile] Ingested ${runModel.length} runs, ${acceptedText.length} chars, numbering:`, numberingContext);
+            await this.maybeYield(runModel.length, Math.max(acceptedText.length, newText?.length || 0));
+
+            // Stage 2: Preprocess markdown
+            const { cleanText, formatHints } = preprocessMarkdown(newText);
+            log(`[Reconcile] Preprocessed: ${formatHints.length} format hints`);
+            await this.maybeYield(runModel.length, Math.max(acceptedText.length, cleanText.length));
+
+            // Detect list-target content before any no-op short-circuit.
+            // Structural conversion may still be required even when text is identical
+            // (for example plain "A./B./C." lines -> true Word numbered list paragraphs).
+            const isTargetListStrict = isListTargetStrict(cleanText);
+            const isTargetListLoose = isListTargetLoose(cleanText);
+            const isTargetList = isTargetListStrict || isTargetListLoose;
+            if (!isTargetListStrict && isTargetListLoose) {
+                log('[Reconcile] List-target detected via loose marker parsing; bypassing no-op short-circuit for structural conversion.');
+            }
+
+            // Early exit if no change
+            if (acceptedText === cleanText && formatHints.length === 0 && !isTargetList) {
+                log('[Reconcile] No changes detected');
+                return {
+                    ooxml: originalOoxml,
+                    isValid: true,
+                    warnings: ['No changes detected']
+                };
+            }
+
+            // Stage 3: Compute word-level diff
+            const shouldCleanupSemantic = Math.max(acceptedText.length, cleanText.length) < this.disableSemanticCleanupOverChars;
+            const diffOps = computeWordLevelDiffOps(acceptedText, cleanText, {
+                cleanupSemantic: shouldCleanupSemantic
+            });
+            if (!shouldCleanupSemantic) {
+                log('[Reconcile] Skipping semantic diff cleanup for large web payload');
+            }
+            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;
+            const sourceIsMarkedMultilineList = isListTargetStrict(acceptedText) || isListTargetLoose(acceptedText);
+            const canPatchExistingMarkedList = isTargetList
+                && sourceIsMarkedMultilineList
+                && paragraphCount > 1
+                && acceptedText !== cleanText;
+
+            log(`[Reconcile] isTargetList: ${isTargetList}, paragraphCount: ${paragraphCount}`);
+
+            // 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`);
 
@@ -163,29 +163,29 @@ export class ReconciliationPipeline {
             log(`[Reconcile] Split into ${splitModel.length} runs`);
 
             // Stage 5: Apply patches
-            const patchedModel = applyPatches(splitModel, diffOps, {
-                generateRedlines: this.generateRedlines,
-                author: this.author,
-                formatHints,
-                numberingService: this.numberingService
-            });
-            log(`[Reconcile] Patched model has ${patchedModel.length} runs`);
-            await this.maybeYield(patchedModel.length, Math.max(acceptedText.length, cleanText.length));
+            const patchedModel = applyPatches(splitModel, diffOps, {
+                generateRedlines: this.generateRedlines,
+                author: this.author,
+                formatHints,
+                numberingService: this.numberingService
+            });
+            log(`[Reconcile] Patched model has ${patchedModel.length} runs`);
+            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,
-                revisionIdAllocator: this.revisionIdAllocator
+            const resultOoxml = serializeToOoxml(patchedModel, pPr, formatHints, {
+                author: this.author,
+                generateRedlines: this.generateRedlines,
+                revisionIdAllocator: this.revisionIdAllocator
             });
 
-            // Stage 7: Basic validation
-            if (this.shouldRunValidation()) {
-                const validation = this.validateBasic(resultOoxml);
-                if (!validation.isValid) {
-                    warnings.push(...validation.errors);
-                }
-            }
+            // Stage 7: Basic validation
+            if (this.shouldRunValidation()) {
+                const validation = this.validateBasic(resultOoxml);
+                if (!validation.isValid) {
+                    warnings.push(...validation.errors);
+                }
+            }
 
             return {
                 ooxml: resultOoxml,
@@ -193,15 +193,15 @@ export class ReconciliationPipeline {
                 warnings
             };
 
-        } 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
-            };
-        }
+        } 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
+            };
+        }
     }
 
     /**
@@ -210,19 +210,19 @@ export class ReconciliationPipeline {
      * @param {string} ooxml - Generated OOXML
      * @returns {{ isValid: boolean, errors: string[] }}
      */
-    validateBasic(ooxml) {
+    validateBasic(ooxml) {
         const errors = [];
 
         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 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 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) {
@@ -242,40 +242,40 @@ export class ReconciliationPipeline {
             isValid: errors.length === 0,
             errors
         };
-    }
-
-    /**
-     * Decides if basic output validation should run for this pipeline instance.
-     *
-     * Modes:
-     * - `always`: validate whenever `validateOutput` is true
-     * - `never`: never validate
-     * - `auto` (default): skip only in production web runtime
-     *
-     * @returns {boolean}
-     */
-    shouldRunValidation() {
-        if (!this.validateOutput) return false;
-
-        if (this.validationMode === 'always') return true;
-        if (this.validationMode === 'never') return false;
-
-        // Auto mode: avoid extra parse round-trips in Word Online production.
-        return !(this.isWebPlatform && isProductionBuild());
-    }
-
-    /**
-     * Yields to the event loop for large operations to keep web UI responsive.
-     *
-     * @param {number} runCount - Run model size
-     * @param {number} charCount - Text size
-     * @returns {Promise<void>}
-     */
-    async maybeYield(runCount, charCount) {
-        if (!this.enableEventLoopYielding) return;
-        if (runCount <= this.yieldRunThreshold && charCount <= this.yieldCharThreshold) return;
-        await yieldToEventLoop();
-    }
+    }
+
+    /**
+     * Decides if basic output validation should run for this pipeline instance.
+     *
+     * Modes:
+     * - `always`: validate whenever `validateOutput` is true
+     * - `never`: never validate
+     * - `auto` (default): skip only in production web runtime
+     *
+     * @returns {boolean}
+     */
+    shouldRunValidation() {
+        if (!this.validateOutput) return false;
+
+        if (this.validationMode === 'always') return true;
+        if (this.validationMode === 'never') return false;
+
+        // Auto mode: avoid extra parse round-trips in Word Online production.
+        return !(this.isWebPlatform && isProductionBuild());
+    }
+
+    /**
+     * Yields to the event loop for large operations to keep web UI responsive.
+     *
+     * @param {number} runCount - Run model size
+     * @param {number} charCount - Text size
+     * @returns {Promise<void>}
+     */
+    async maybeYield(runCount, charCount) {
+        if (!this.enableEventLoopYielding) return;
+        if (runCount <= this.yieldRunThreshold && charCount <= this.yieldCharThreshold) return;
+        await yieldToEventLoop();
+    }
 
     /**
      * Wraps the reconciled content for document insertion.
@@ -303,10 +303,10 @@ export class ReconciliationPipeline {
             originalRunModel,
             originalText,
             generateRedlines: this.generateRedlines,
-            author: this.author,
-            font: this.font,
-            revisionIdAllocator: this.revisionIdAllocator,
-            numberingService: this.numberingService
+            author: this.author,
+            font: this.font,
+            revisionIdAllocator: this.revisionIdAllocator,
+            numberingService: this.numberingService
         });
     }
 
@@ -337,10 +337,12 @@ export class ReconciliationPipeline {
             };
         }
 
-        const tableOoxml = generateTableOoxml(tableData, {
-            generateRedlines: this.generateRedlines,
-            author: this.author,
-            revisionIdAllocator: this.revisionIdAllocator
+        const tableOoxml = generateTableOoxml(tableData, {
+            generateRedlines: this.generateRedlines,
+            author: this.author,
+            revisionIdAllocator: this.revisionIdAllocator,
+            // Word-native inserted table: tracked rows so Reject All removes the whole table.
+            trackAsBlock: true
         });
 
         return {

package/scripts/export-validation-fixtures.mjs

@@ -16,6 +16,7 @@ import {
   rejectTrackedChangesInOoxml
 } from '../services/revision-comment-management.js';
 import { WORD_TASK_CASES } from '../tests/fixtures/word-task-cases.mjs';
+import { mergeNumberingParts } from '../services/numbering-allocation.js';
 
 const { DOMParser, XMLSerializer } = await import('@xmldom/xmldom');
 configureXmlProvider({ DOMParser, XMLSerializer });
@@ -56,7 +57,8 @@ for (const testCase of cases) {
       sourceDocumentXml,
       testCase.batchOperations,
       'Validation',
-      null,
+      // A numbering binding resolves against the source numbering part, as it does in a real package.
+      testCase.sourceNumbering ? { numberingXml: testCase.packageParts?.numberingXml } : null,
       operationOptions
     )
     : await applyOperationToDocumentXml(
@@ -118,7 +120,7 @@ for (const testCase of cases) {
   }
 
   if (testCase.requiredNumberingFormats) {
-    const numberingXml = testCase.packageParts?.numberingXml || result.numberingXml || '';
+    const numberingXml = [testCase.packageParts?.numberingXml, result.numberingXml, ...(result.numberingXmlParts || [])].filter(Boolean).join('');
     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`);
@@ -162,14 +164,20 @@ for (const testCase of cases) {
     continue;
   }
 
+  // A batch returns numbering payloads as parts; merge them into the source part through the one allocator merge.
+  const batchNumberingXml = Array.isArray(result.numberingXmlParts) && result.numberingXmlParts.length > 0
+    ? mergeNumberingParts(testCase.packageParts?.numberingXml || '', result.numberingXmlParts)
+    : null;
+  const resultNumberingXml = result.numberingXml || batchNumberingXml || null;
   writeFileSync(join(outputDir, `${testCase.name}.document.xml`), result.documentXml, 'utf8');
-  if (result.numberingXml) {
-    writeFileSync(join(outputDir, `${testCase.name}.numbering.xml`), result.numberingXml, 'utf8');
+  if (resultNumberingXml) {
+    writeFileSync(join(outputDir, `${testCase.name}.numbering.xml`), resultNumberingXml, 'utf8');
   }
 
   const packageParts = {
-    numberingXml: result.numberingXml || null,
-    ...(testCase.packageParts || {})
+    numberingXml: resultNumberingXml,
+    ...(testCase.packageParts || {}),
+    ...(batchNumberingXml ? { numberingXml: batchNumberingXml } : {})
   };
   let packageEntries;
   let docx;
@@ -228,6 +236,11 @@ for (const testCase of cases) {
     sourceText: testCase.sourceText || testCase.original,
     modifiedText: preprocessMarkdown(testCase.modified).cleanText,
     requiredNumberingFormats: testCase.requiredNumberingFormats || [],
+    ...(testCase.expectedAcceptedListStrings ? {
+      expectedAcceptedListStrings: testCase.expectedAcceptedListStrings,
+      expectedRejectedListStrings: testCase.expectedRejectedListStrings
+    } : {}),
+    ...(testCase.expectedAcceptedListGroupSizes ? { expectedAcceptedListGroupSizes: testCase.expectedAcceptedListGroupSizes } : {}),
     untouchedPartSha256
   };
   writeFileSync(join(outputDir, `${testCase.name}.expected.json`), `${JSON.stringify(expected, null, 2)}\n`, 'utf8');