@ansonlai/docx-redline-js 0.2.1 → 0.4.0

package/orchestration/list-structural-fallback.js

@@ -3,8 +3,9 @@
  * text no-op but the target is marker-prefixed plain text (for example `1. X`).
  */
 
-import { createParser, createSerializer } from '../adapters/xml-adapter.js';
+import { createSerializer, parseOoxmlSafe } from '../adapters/xml-adapter.js';
 import { getXmlParseError } from '../core/xml-query.js';
+import { createWordElement } from '../core/word-xml.js';
 import {
     getDocumentParagraphNodes,
     normalizeWhitespaceForTargeting
@@ -217,10 +218,7 @@ export function enforceListBindingOnParagraphNodes(nodes, options = {}) {
 
         let pPr = getDirectWordChild(paragraph, 'pPr');
         if (!pPr) {
-            pPr = ownerDoc.createElementNS(
-                'http://schemas.openxmlformats.org/wordprocessingml/2006/main',
-                'w:pPr'
-            );
+            pPr = createWordElement(ownerDoc, 'w:pPr');
             paragraph.insertBefore(pPr, paragraph.firstChild);
         }
 
@@ -236,29 +234,20 @@ export function enforceListBindingOnParagraphNodes(nodes, options = {}) {
 
         let numPr = getDirectWordChild(pPr, 'numPr');
         if (!numPr) {
-            numPr = ownerDoc.createElementNS(
-                'http://schemas.openxmlformats.org/wordprocessingml/2006/main',
-                'w:numPr'
-            );
+            numPr = createWordElement(ownerDoc, 'w:numPr');
             pPr.appendChild(numPr);
         }
 
         let ilvlEl = getDirectWordChild(numPr, 'ilvl');
         if (!ilvlEl) {
-            ilvlEl = ownerDoc.createElementNS(
-                'http://schemas.openxmlformats.org/wordprocessingml/2006/main',
-                'w:ilvl'
-            );
+            ilvlEl = createWordElement(ownerDoc, 'w:ilvl');
             numPr.appendChild(ilvlEl);
         }
         ilvlEl.setAttribute('w:val', String(ilvl));
 
         let numIdEl = getDirectWordChild(numPr, 'numId');
         if (!numIdEl) {
-            numIdEl = ownerDoc.createElementNS(
-                'http://schemas.openxmlformats.org/wordprocessingml/2006/main',
-                'w:numId'
-            );
+            numIdEl = createWordElement(ownerDoc, 'w:numId');
             numPr.appendChild(numIdEl);
         }
         numIdEl.setAttribute('w:val', String(numId));
@@ -269,8 +258,8 @@ export function enforceListBindingOnParagraphNodes(nodes, options = {}) {
 }
 
 function getFirstParagraphFromOxml(oxml) {
-    const parser = createParser();
-    const doc = parser.parseFromString(String(oxml || ''), 'application/xml');
+    const doc = parseOoxmlSafe(oxml, 'application/xml').doc;
+    if (!doc) return null;
     const parseError = getXmlParseError(doc);
     if (parseError) return null;
     const paragraphs = getDocumentParagraphNodes(doc);
@@ -301,8 +290,8 @@ function setElementVal(element, value) {
 }
 
 function extractFirstParagraphNumIdFromOxml(oxml) {
-    const parser = createParser();
-    const doc = parser.parseFromString(String(oxml || ''), 'application/xml');
+    const doc = parseOoxmlSafe(oxml, 'application/xml').doc;
+    if (!doc) return null;
     const parseError = getXmlParseError(doc);
     if (parseError) return null;
 
@@ -321,9 +310,9 @@ function extractFirstParagraphNumIdFromOxml(oxml) {
 function applyStartOverrideToNumberingXml(numberingXml, targetNumId, startAt, options = {}) {
     if (!numberingXml || !targetNumId || !Number.isInteger(startAt) || startAt < 1) return numberingXml;
     const setAbstractStartOverride = options.setAbstractStartOverride !== false;
-    const parser = createParser();
     const serializer = createSerializer();
-    const numberingDoc = parser.parseFromString(String(numberingXml || ''), 'application/xml');
+    const numberingDoc = parseOoxmlSafe(numberingXml, 'application/xml').doc;
+    if (!numberingDoc) return numberingXml;
     const parseError = getXmlParseError(numberingDoc);
     if (parseError) return numberingXml;
 
@@ -343,20 +332,14 @@ function applyStartOverrideToNumberingXml(numberingXml, targetNumId, startAt, op
             return ilvl === 0;
         }) || null;
     if (!lvlOverride) {
-        lvlOverride = numberingDoc.createElementNS(
-            'http://schemas.openxmlformats.org/wordprocessingml/2006/main',
-            'w:lvlOverride'
-        );
+        lvlOverride = createWordElement(numberingDoc, 'w:lvlOverride');
         lvlOverride.setAttribute('w:ilvl', '0');
         target.appendChild(lvlOverride);
     }
 
     let startOverride = Array.from(lvlOverride.getElementsByTagNameNS('*', 'startOverride'))[0] || null;
     if (!startOverride) {
-        startOverride = numberingDoc.createElementNS(
-            'http://schemas.openxmlformats.org/wordprocessingml/2006/main',
-            'w:startOverride'
-        );
+        startOverride = createWordElement(numberingDoc, 'w:startOverride');
         lvlOverride.appendChild(startOverride);
     }
     setElementVal(startOverride, startAt);
@@ -377,20 +360,14 @@ function applyStartOverrideToNumberingXml(numberingXml, targetNumId, startAt, op
                     return ilvl === 0;
                 }) || null;
             if (!lvl) {
-                lvl = numberingDoc.createElementNS(
-                    'http://schemas.openxmlformats.org/wordprocessingml/2006/main',
-                    'w:lvl'
-                );
+                lvl = createWordElement(numberingDoc, 'w:lvl');
                 lvl.setAttribute('w:ilvl', '0');
                 abstractNum.appendChild(lvl);
             }
 
             let startNode = Array.from(lvl.getElementsByTagNameNS('*', 'start'))[0] || null;
             if (!startNode) {
-                startNode = numberingDoc.createElementNS(
-                    'http://schemas.openxmlformats.org/wordprocessingml/2006/main',
-                    'w:start'
-                );
+                startNode = createWordElement(numberingDoc, 'w:start');
                 lvl.insertBefore(startNode, lvl.firstChild);
             }
             setElementVal(startNode, startAt);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ansonlai/docx-redline-js",
-  "version": "0.2.1",
+  "version": "0.4.0",
   "description": "Host-independent OOXML reconciliation engine for .docx manipulation with track changes",
   "license": "MIT",
   "type": "module",
@@ -52,13 +52,31 @@
   },
   "devDependencies": {
     "@xmldom/xmldom": "^0.9.0",
-    "esbuild": "^0.28.1"
+    "c8": "^12.0.0",
+    "docx-preview": "^0.4.0",
+    "esbuild": "^0.28.1",
+    "eslint": "^10.9.1",
+    "jszip": "^3.10.1",
+    "typescript": "^7.0.2"
   },
   "scripts": {
     "build": "node scripts/build.mjs",
-    "check:types": "node scripts/check-types.mjs",
+    "check:types": "tsc -p tsconfig.types.json && node scripts/check-types.mjs",
+    "lint": "eslint index.js adapters core engine pipeline services orchestration scripts tests",
+    "test:coverage": "c8 --reporter=text --reporter=json --reporter=json-summary --reports-dir=coverage node scripts/run-tests.mjs",
+    "coverage:gaps": "node scripts/report-coverage-gaps.mjs",
     "smoke:word": "powershell -File scripts/word-com-smoke.ps1",
     "smoke:word:diff": "powershell -File scripts/word-com-differential.ps1",
+    "test:word": "powershell -NoProfile -ExecutionPolicy Bypass -File scripts/word-com-suite.ps1",
+    "test:word:visual": "powershell -NoProfile -ExecutionPolicy Bypass -File scripts/word-com-visual-suite.ps1",
+    "test:corpus:word": "powershell -NoProfile -ExecutionPolicy Bypass -File scripts/word-com-corpus-suite.ps1",
+    "test:corpus:word:visual": "powershell -NoProfile -ExecutionPolicy Bypass -File scripts/word-com-corpus-visual-suite.ps1",
+    "test:visual:inspect": "node scripts/inspect-visual-evidence.mjs",
+    "test:visual:sample": "node scripts/sample-multimodal-visual-check.mjs",
+    "corpus:fetch:superdoc": "node scripts/fetch-superdoc-corpus.mjs",
+    "report:word:coverage": "node scripts/report-word-coverage.mjs",
+    "report:test:dashboard": "node scripts/build-test-dashboard.mjs",
+    "review:word:prepare": "node scripts/prepare-word-review.mjs",
     "test": "node scripts/run-tests.mjs",
     "test:isolation": "node tests/no_word_api_index_check.mjs && node tests/core_dependency_graph_check.mjs",
     "prepublishOnly": "npm run test:isolation && npm run build"
@@ -81,4 +99,4 @@
   "engines": {
     "node": ">=20.0.0"
   }
-}
+}

package/pipeline/diff-engine.js

@@ -7,7 +7,54 @@
 import { diff_match_patch } from 'diff-match-patch';
 import { DiffOp } from '../core/types.js';
 
-const DMP = new diff_match_patch();
+export const TOKEN_CODE_POINT_BASE = 0x10000;
+export const MAX_DIFF_TOKENS = 0x40000;
+
+// diff-match-patch's JavaScript port operates on UTF-16 code units, not
+// Unicode code points. Keep its private encoding in the BMP while skipping
+// surrogates; larger token sets take the deterministic token-array fallback.
+const BMP_FIRST_CODE = 1;
+const BMP_BEFORE_SURROGATES = 0xD800 - BMP_FIRST_CODE;
+const BMP_AFTER_SURROGATES = 0x10000 - 0xE000;
+const DMP_SAFE_TOKEN_LIMIT = BMP_BEFORE_SURROGATES + BMP_AFTER_SURROGATES;
+
+export class DiffTokenLimitError extends Error {
+    constructor(limit = MAX_DIFF_TOKENS) {
+        super(`Word diff exceeds the safe limit of ${limit} unique tokens.`);
+        this.name = 'DiffTokenLimitError';
+        this.code = 'DIFF_TOKEN_LIMIT';
+        this.limit = limit;
+    }
+}
+
+export function isDiffTokenLimitError(error) {
+    return error?.code === 'DIFF_TOKEN_LIMIT';
+}
+
+export function createDiffEngine(options = {}) {
+    const timeout = options.diffTimeoutSeconds ?? 0;
+    if (!Number.isFinite(timeout) || timeout < 0) {
+        throw new TypeError('diffTimeoutSeconds must be a finite non-negative number.');
+    }
+    const engine = new diff_match_patch();
+    engine.Diff_Timeout = timeout;
+    return engine;
+}
+
+function tokenize(text) {
+    const tokens = [];
+    const leading = text.match(/^\s+/);
+    if (leading) tokens.push(leading[0]);
+
+    const regex = /(\S+)(\s*)/g;
+    regex.lastIndex = leading?.[0].length || 0;
+    let match;
+    while ((match = regex.exec(text)) !== null) {
+        if (match[1]) tokens.push(match[1]);
+        if (match[2]) tokens.push(match[2]);
+    }
+    return tokens;
+}
 
 /**
  * Converts text into word tokens represented as unique characters.
@@ -15,47 +62,47 @@ const DMP = new diff_match_patch();
  * 
  * @param {string} text1 - First text to tokenize
  * @param {string} text2 - Second text to tokenize
- * @returns {{ chars1: string, chars2: string, wordArray: string[] }}
- */
-export function wordsToChars(text1, text2) {
-    const wordArray = [];
-    const wordHash = new Map();
-
-    function tokenize(text) {
-        const tokens = [];
-        const regex = /(\S+)(\s*)/g;
-        let match;
-        while ((match = regex.exec(text)) !== null) {
-            if (match[1]) tokens.push(match[1]);
-            if (match[2]) tokens.push(match[2]);
-        }
-        return tokens;
-    }
-
-    function mapTokensToChars(tokens) {
-        let chars = '';
-        for (const token of tokens) {
-            if (wordHash.has(token)) {
-                chars += String.fromCharCode(wordHash.get(token));
-            } else {
-                const charCode = wordArray.length;
-                wordArray.push(token);
-                wordHash.set(token, charCode);
-                chars += String.fromCharCode(charCode);
-            }
-        }
-        return chars;
-    }
-
-    const tokens1 = tokenize(text1);
-    const tokens2 = tokenize(text2);
-
-    return {
-        chars1: mapTokensToChars(tokens1),
-        chars2: mapTokensToChars(tokens2),
-        wordArray
-    };
-}
+ * @param {{ maxTokens?: number }} [options={}] - Internal/test capacity override
+ * @returns {{ chars1: string, chars2: string, wordArray: string[], tokenIds1: number[], tokenIds2: number[] }}
+ */
+export function wordsToChars(text1, text2, options = {}) {
+    const wordArray = [];
+    const wordHash = new Map();
+    const maxTokens = options.maxTokens ?? MAX_DIFF_TOKENS;
+    if (!Number.isInteger(maxTokens) || maxTokens < 1 || maxTokens > MAX_DIFF_TOKENS) {
+        throw new RangeError(`maxTokens must be an integer from 1 to ${MAX_DIFF_TOKENS}.`);
+    }
+
+    function mapTokensToChars(tokens) {
+        let chars = '';
+        const tokenIds = [];
+        for (const token of tokens) {
+            let tokenId = wordHash.get(token);
+            if (tokenId === undefined) {
+                if (wordArray.length >= maxTokens) throw new DiffTokenLimitError(maxTokens);
+                tokenId = wordArray.length;
+                wordArray.push(token);
+                wordHash.set(token, tokenId);
+            }
+            tokenIds.push(tokenId);
+            chars += String.fromCodePoint(TOKEN_CODE_POINT_BASE + tokenId);
+        }
+        return { chars, tokenIds };
+    }
+
+    const tokens1 = tokenize(text1);
+    const tokens2 = tokenize(text2);
+    const encoded1 = mapTokensToChars(tokens1);
+    const encoded2 = mapTokensToChars(tokens2);
+
+    return {
+        chars1: encoded1.chars,
+        chars2: encoded2.chars,
+        wordArray,
+        tokenIds1: encoded1.tokenIds,
+        tokenIds2: encoded2.tokenIds
+    };
+}
 
 /**
  * Converts character-encoded diffs back to actual word diffs.
@@ -65,20 +112,87 @@ export function wordsToChars(text1, text2) {
  * @returns {Array} DMP-style diff array with actual words
  */
 export function charsToWords(diffs, wordArray) {
-    const wordDiffs = [];
+    const originalChars = diffs.filter(([op]) => op !== 1).map(([, chars]) => chars).join('');
+    const modifiedChars = diffs.filter(([op]) => op !== -1).map(([, chars]) => chars).join('');
+
+    const decode = chars => {
+        const tokenIds = [];
+        for (let i = 0; i < chars.length;) {
+            const codePoint = chars.codePointAt(i);
+            const tokenId = codePoint - TOKEN_CODE_POINT_BASE;
+            if (!Number.isInteger(tokenId) || tokenId < 0 || tokenId >= wordArray.length) {
+                throw new RangeError(`Diff token code point U+${codePoint.toString(16).toUpperCase()} has no mapping.`);
+            }
+            tokenIds.push(tokenId);
+            i += codePoint > 0xFFFF ? 2 : 1;
+        }
+        return tokenIds;
+    };
+
+    // Reconstruct both encoded sides before decoding. A UTF-16-based diff
+    // engine may split a surrogate pair across adjacent diff tuples even
+    // though the complete original/modified streams remain valid.
+    return deterministicLargeTokenDiff(decode(originalChars), decode(modifiedChars), wordArray);
+}
+
+function tokenIdToBmpChar(tokenId) {
+    const code = tokenId < BMP_BEFORE_SURROGATES
+        ? BMP_FIRST_CODE + tokenId
+        : 0xE000 + (tokenId - BMP_BEFORE_SURROGATES);
+    return String.fromCharCode(code);
+}
 
-    for (const [op, chars] of diffs) {
+function bmpCharToTokenId(charCode) {
+    if (charCode >= BMP_FIRST_CODE && charCode < 0xD800) return charCode - BMP_FIRST_CODE;
+    if (charCode >= 0xE000 && charCode <= 0xFFFF) return BMP_BEFORE_SURROGATES + charCode - 0xE000;
+    throw new RangeError(`BMP diff token U+${charCode.toString(16).toUpperCase()} has no mapping.`);
+}
+
+function encodeTokenIdsForDmp(tokenIds) {
+    let chars = '';
+    for (const tokenId of tokenIds) chars += tokenIdToBmpChar(tokenId);
+    return chars;
+}
+
+function decodeBmpDiffs(diffs, wordArray) {
+    return diffs.map(([op, chars]) => {
         const parts = [];
-        for (let i = 0; i < chars.length; i++) {
-            const charCode = chars.charCodeAt(i);
-            if (charCode < wordArray.length) {
-                parts.push(wordArray[charCode]);
+        for (let index = 0; index < chars.length; index++) {
+            const tokenId = bmpCharToTokenId(chars.charCodeAt(index));
+            if (tokenId >= wordArray.length) {
+                throw new RangeError(`BMP diff token ${tokenId} has no mapping.`);
             }
+            parts.push(wordArray[tokenId]);
         }
-        wordDiffs.push([op, parts.join('')]);
+        return [op, parts.join('')];
+    });
+}
+
+function deterministicLargeTokenDiff(tokenIds1, tokenIds2, wordArray) {
+    let prefixLength = 0;
+    const sharedLength = Math.min(tokenIds1.length, tokenIds2.length);
+    while (prefixLength < sharedLength && tokenIds1[prefixLength] === tokenIds2[prefixLength]) {
+        prefixLength++;
     }
 
-    return wordDiffs;
+    let suffixLength = 0;
+    while (
+        suffixLength < sharedLength - prefixLength
+        && tokenIds1[tokenIds1.length - 1 - suffixLength] === tokenIds2[tokenIds2.length - 1 - suffixLength]
+    ) {
+        suffixLength++;
+    }
+
+    const joinTokens = ids => ids.map(id => wordArray[id]).join('');
+    const diffs = [];
+    if (prefixLength) diffs.push([0, joinTokens(tokenIds1.slice(0, prefixLength))]);
+
+    const deleted = tokenIds1.slice(prefixLength, tokenIds1.length - suffixLength);
+    const inserted = tokenIds2.slice(prefixLength, tokenIds2.length - suffixLength);
+    if (deleted.length) diffs.push([-1, joinTokens(deleted)]);
+    if (inserted.length) diffs.push([1, joinTokens(inserted)]);
+    if (suffixLength) diffs.push([0, joinTokens(tokenIds1.slice(tokenIds1.length - suffixLength))]);
+    return diffs;
 }
 
 /**
@@ -86,7 +200,7 @@ export function charsToWords(diffs, wordArray) {
  *
  * @param {string} originalText - Original text
  * @param {string} newText - New text
- * @param {{ cleanupSemantic?: boolean }} [options={}] - Diff options
+ * @param {{ cleanupSemantic?: boolean, diffTimeoutSeconds?: number, maxTokens?: number }} [options={}] - Diff options
  * @returns {Array<[number, string]>}
  */
 export function computeWordDiffs(originalText, newText, options = {}) {
@@ -104,13 +218,18 @@ export function computeWordDiffs(originalText, newText, options = {}) {
 
     const { cleanupSemantic = true } = options;
 
-    const { chars1, chars2, wordArray } = wordsToChars(originalText, newText);
-    const charDiffs = DMP.diff_main(chars1, chars2);
+    const { wordArray, tokenIds1, tokenIds2 } = wordsToChars(originalText, newText, options);
+    if (wordArray.length > DMP_SAFE_TOKEN_LIMIT) {
+        return deterministicLargeTokenDiff(tokenIds1, tokenIds2, wordArray);
+    }
+
+    const dmp = createDiffEngine(options);
+    const charDiffs = dmp.diff_main(encodeTokenIdsForDmp(tokenIds1), encodeTokenIdsForDmp(tokenIds2));
     if (cleanupSemantic) {
-        DMP.diff_cleanupSemantic(charDiffs);
+        dmp.diff_cleanupSemantic(charDiffs);
     }
 
-    return charsToWords(charDiffs, wordArray);
+    return decodeBmpDiffs(charDiffs, wordArray);
 }
 
 /**

package/pipeline/ingestion-export.js

@@ -8,7 +8,7 @@
  * - Run-level bold/italic formatting
  */
 
-import { createParser } from '../adapters/xml-adapter.js';
+import { parseOoxmlSafe } from '../adapters/xml-adapter.js';
 import { NS_W } from '../core/types.js';
 import { getXmlParseError } from '../core/xml-query.js';
 
@@ -19,21 +19,9 @@ function hasParserError(doc) {
 }
 
 function parseWordOoxml(ooxml) {
-    const source = typeof ooxml === 'string' ? ooxml : String(ooxml || '');
-    if (!source.trim()) {
-        return null;
-    }
-
-    try {
-        const parser = createParser();
-        const doc = parser.parseFromString(source, 'application/xml');
-        if (hasParserError(doc)) {
-            return null;
-        }
-        return doc;
-    } catch {
-        return null;
-    }
+    const parsed = parseOoxmlSafe(ooxml, 'application/xml');
+    if (parsed.error || hasParserError(parsed.doc)) return { ...parsed, doc: null };
+    return parsed;
 }
 
 function getWordParagraphs(doc) {
@@ -223,17 +211,31 @@ function paragraphToMarkdown(paragraph) {
  * @returns {string}
  */
 export function ingestWordOoxmlToPlainText(ooxml) {
-    const doc = parseWordOoxml(ooxml);
-    if (!doc) return '';
+    return ingestWordOoxmlToPlainTextResult(ooxml).text;
+}
+
+/**
+ * Result-returning plain-text ingestion for callers that need parse failures
+ * distinguished from legitimately empty documents.
+ *
+ * @param {unknown} ooxml
+ * @returns {{ text: string, status: 'ok'|'error', error?: {code:string,message:string}, warnings?: string[] }}
+ */
+export function ingestWordOoxmlToPlainTextResult(ooxml) {
+    const parsed = parseWordOoxml(ooxml);
+    if (!parsed.doc) {
+        return { text: '', status: 'error', error: parsed.error, warnings: parsed.warnings };
+    }
+    const doc = parsed.doc;
 
     const paragraphs = getWordParagraphs(doc);
     if (paragraphs.length === 0) {
         const fallback = normalizeInlineWhitespace(doc.documentElement?.textContent || '');
-        return fallback;
+        return { text: fallback, status: 'ok', warnings: parsed.warnings };
     }
 
     const lines = paragraphs.map(paragraphToPlainText);
-    return lines.join('\n\n').trim();
+    return { text: lines.join('\n\n').trim(), status: 'ok', warnings: parsed.warnings };
 }
 
 /**
@@ -243,14 +245,27 @@ export function ingestWordOoxmlToPlainText(ooxml) {
  * @returns {string}
  */
 export function ingestWordOoxmlToMarkdown(ooxml) {
-    const doc = parseWordOoxml(ooxml);
-    if (!doc) return '';
+    return ingestWordOoxmlToMarkdownResult(ooxml).text;
+}
+
+/**
+ * Result-returning markdown ingestion counterpart.
+ *
+ * @param {unknown} ooxml
+ * @returns {{ text: string, status: 'ok'|'error', error?: {code:string,message:string}, warnings?: string[] }}
+ */
+export function ingestWordOoxmlToMarkdownResult(ooxml) {
+    const parsed = parseWordOoxml(ooxml);
+    if (!parsed.doc) {
+        return { text: '', status: 'error', error: parsed.error, warnings: parsed.warnings };
+    }
+    const doc = parsed.doc;
 
     const paragraphs = getWordParagraphs(doc);
     if (paragraphs.length === 0) {
-        return '';
+        return { text: '', status: 'ok', warnings: parsed.warnings };
     }
 
     const lines = paragraphs.map(paragraphToMarkdown);
-    return lines.join('\n\n').trim();
+    return { text: lines.join('\n\n').trim(), status: 'ok', warnings: parsed.warnings };
 }

package/pipeline/ingestion-paragraph.js

@@ -6,7 +6,7 @@
 
 import { NS_W, RunKind, ContainerKind } from '../core/types.js';
 import { appendParagraphBoundary, advanceOffsetForParagraphBoundary } from '../core/paragraph-offset-policy.js';
-import { createParser, serializeXml } from '../adapters/xml-adapter.js';
+import { parseOoxmlSafe, serializeXml } from '../adapters/xml-adapter.js';
 import { warn, error as logError } from '../adapters/logger.js';
 import {
     getElementsByTagNS,
@@ -35,10 +35,12 @@ export function ingestOoxml(ooxmlString, options = {}) {
     }
 
     try {
-        const doc = preParsedDoc || (() => {
-            const parser = createParser();
-            return parser.parseFromString(ooxmlString, 'application/xml');
-        })();
+        const parsed = preParsedDoc ? { doc: preParsedDoc, error: null } : parseOoxmlSafe(ooxmlString, 'application/xml');
+        const doc = parsed.doc;
+        if (parsed.error || !doc) {
+            logError('OOXML parse error:', parsed.error?.message);
+            return { runModel, acceptedText, pPr: null, error: parsed.error };
+        }
 
         const parseError = getXmlParseError(doc);
         if (parseError) {

package/pipeline/list-generation.js

@@ -30,9 +30,10 @@ export async function executeListGeneration(options) {
         originalRunModel = [],
         originalText = '',
         generateRedlines = true,
-        author = 'AI',
-        font = null,
-        numberingService
+        author = 'AI',
+        font = null,
+        revisionIdAllocator = null,
+        numberingService
     } = options;
 
     const normalizedListText = normalizeCompositeListMarkers(cleanText);
@@ -72,13 +73,18 @@ export async function executeListGeneration(options) {
             if (tableData.headers.length > 0 || tableData.rows.length > 0) {
                 if (generateRedlines && results.length === 0 && deletionRuns.length > 0) {
                     results.push(serializeToOoxml(deletionRuns, null, [], {
-                        author,
-                        generateRedlines,
-                        font
-                    }));
+                        author,
+                        generateRedlines,
+                        font,
+                        revisionIdAllocator
+                    }));
                 }
 
-                results.push(generateTableOoxml(tableData, { generateRedlines, author }));
+                results.push(generateTableOoxml(tableData, {
+                    generateRedlines,
+                    author,
+                    revisionIdAllocator
+                }));
                 i = tableBlock.endIndex;
                 continue;
             }
@@ -92,9 +98,10 @@ export async function executeListGeneration(options) {
             numberingContext,
             numberingService,
             generateRedlines,
-            author,
-            font,
-            deletionRuns
+            author,
+            font,
+            revisionIdAllocator,
+            deletionRuns
         );
         results.push(entry.ooxml);
     }
@@ -226,9 +233,10 @@ function buildListEntry(
     numberingContext,
     numberingService,
     generateRedlines,
-    author,
-    font,
-    deletionRuns
+    author,
+    font,
+    revisionIdAllocator,
+    deletionRuns
 ) {
     let pPrXml = '';
     let segmentText = '';
@@ -272,9 +280,10 @@ function buildListEntry(
 
     return {
         ooxml: serializeToOoxml(runModel, pPrXml, formatHints, {
-            author,
-            generateRedlines,
-            font
-        })
+            author,
+            generateRedlines,
+            font,
+            revisionIdAllocator
+        })
     };
 }