@ansonlai/docx-redline-js 0.2.1 → 0.4.0

package/services/standalone-operation-runner.js

@@ -5,9 +5,16 @@
  * stay focused on UI + prompt orchestration.
  */
 
-import { createParser, createSerializer } from '../adapters/xml-adapter.js';
-import { createRevisionMetadata, seedRevisionIdsFromDocument } from '../core/types.js';
+import { createSerializer, parseOoxmlSafe } from '../adapters/xml-adapter.js';
+import { findReconstructionParagraphRange } from '../engine/reconstruction-mapper.js';
+import {
+    RevisionIdAllocator,
+    createRevisionMetadata,
+    seedRevisionIdsFromDocument,
+    setRevisionIdAllocatorForDocument
+} from '../core/types.js';
 import { createWordElement } from '../core/word-xml.js';
+import { markParagraphMarkInserted } from '../engine/run-builders.js';
 import {
     applyRedlineToOxml,
     reconcileMarkdownTableOoxml,
@@ -16,6 +23,7 @@ import {
     getParagraphText as getParagraphTextFromOxml,
     isMarkdownTableText,
     findContainingWordElement,
+    buildTargetReferenceSnapshot,
     resolveTargetParagraphWithSnapshot as resolveTargetParagraphWithSnapshotShared,
     buildSingleLineListStructuralFallbackPlan,
     executeSingleLineListStructuralFallback,
@@ -43,6 +51,15 @@ import {
 
 const NS_W = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
 
+function prepareRevisionAllocator(xmlDoc, options = {}) {
+    const allocator = options?._revisionIdAllocator instanceof RevisionIdAllocator
+        ? options._revisionIdAllocator
+        : new RevisionIdAllocator();
+    seedRevisionIdsFromDocument(xmlDoc, allocator);
+    setRevisionIdAllocatorForDocument(xmlDoc, allocator);
+    return allocator;
+}
+
 function getParagraphText(paragraph) {
     return getParagraphTextFromOxml(paragraph);
 }
@@ -68,68 +85,15 @@ function normalizeBodySectionOrder(xmlDoc) {
     normalizeBodySectionOrderStandalone(xmlDoc);
 }
 
-function directFieldCharType(node) {
-    if (!node || node.nodeType !== 1 || node.namespaceURI !== NS_W || node.localName !== 'r') return '';
-    const fldChar = Array.from(node.childNodes || []).find(
-        child => child && child.nodeType === 1 && child.namespaceURI === NS_W && child.localName === 'fldChar'
-    ) || null;
-    return fldChar?.getAttribute('w:fldCharType') || fldChar?.getAttribute('fldCharType') || '';
-}
-
-function hasInstrText(node) {
-    if (!node || node.nodeType !== 1) return false;
-    return Array.from(node.childNodes || []).some(
-        child => child && child.nodeType === 1 && child.namespaceURI === NS_W && child.localName === 'instrText'
-    );
-}
-
 function removeProofErrNodes(paragraph) {
     for (const node of Array.from(paragraph?.getElementsByTagNameNS?.(NS_W, 'proofErr') || [])) {
         node.parentNode?.removeChild(node);
     }
 }
 
-function unlinkFieldsInParagraph(paragraph) {
-    const children = Array.from(paragraph?.childNodes || []);
-    let inField = false;
-    let seenSeparate = false;
-
-    for (const child of children) {
-        if (child.nodeType !== 1) continue;
-
-        const fieldType = directFieldCharType(child);
-        if (fieldType === 'begin') {
-            inField = true;
-            seenSeparate = false;
-            child.parentNode?.removeChild(child);
-            continue;
-        }
-
-        if (!inField) continue;
-
-        if (fieldType === 'separate') {
-            seenSeparate = true;
-            child.parentNode?.removeChild(child);
-            continue;
-        }
-
-        if (fieldType === 'end') {
-            inField = false;
-            seenSeparate = false;
-            child.parentNode?.removeChild(child);
-            continue;
-        }
-
-        if (!seenSeparate || hasInstrText(child)) {
-            child.parentNode?.removeChild(child);
-        }
-    }
-}
-
 function preprocessRedlineTargetParagraph(targetParagraph) {
     if (!targetParagraph) return;
     removeProofErrNodes(targetParagraph);
-    unlinkFieldsInParagraph(targetParagraph);
 }
 
 function getDirectWordChild(element, localName) {
@@ -201,6 +165,14 @@ function buildInsertedListParagraph(xmlDoc, anchorParagraph, entry, revisionMeta
     }
     ensureListProperties(xmlDoc, paragraph, entry.ilvl, entry.numId);
 
+    // A new list item is a whole inserted paragraph, not merely inserted text.
+    // Tracking its paragraph mark lets Word (and our accept/reject helpers)
+    // remove the list paragraph itself on Reject All instead of leaving an
+    // empty bullet or number behind.
+    if (generateRedlines) {
+        markParagraphMarkInserted(xmlDoc, paragraph, author);
+    }
+
     const run = createWordElement(xmlDoc, 'w:r');
     const anchorFirstRun = Array.from(anchorParagraph.getElementsByTagNameNS(NS_W, 'r'))[0] || null;
     const anchorRunPr = anchorFirstRun ? getDirectWordChild(anchorFirstRun, 'rPr') : null;
@@ -214,7 +186,7 @@ function buildInsertedListParagraph(xmlDoc, anchorParagraph, entry, revisionMeta
     textNode.textContent = safeText;
     run.appendChild(textNode);
     if (generateRedlines) {
-        const metadata = revisionMetadata || createRevisionMetadata(author);
+        const metadata = revisionMetadata || createRevisionMetadata(author, xmlDoc);
         const ins = createWordElement(xmlDoc, 'w:ins');
         ins.setAttribute('w:id', String(metadata.id));
         ins.setAttribute('w:author', metadata.author);
@@ -355,7 +327,7 @@ function applyExplicitRangeListInsertions({
                 numId: entry.numId,
                 text: entry.text
             },
-            generateRedlines ? createRevisionMetadata(author) : null,
+            generateRedlines ? createRevisionMetadata(author, xmlDoc) : null,
             author,
             { generateRedlines }
         );
@@ -485,7 +457,7 @@ function buildFallbackInsertedPlainParagraph(xmlDoc, text, revisionMetadata, aut
     run.appendChild(textNode);
 
     if (generateRedlines) {
-        const metadata = revisionMetadata || createRevisionMetadata(author);
+        const metadata = revisionMetadata || createRevisionMetadata(author, xmlDoc);
         const ins = createWordElement(xmlDoc, 'w:ins');
         ins.setAttribute('w:id', String(metadata.id));
         ins.setAttribute('w:author', metadata.author);
@@ -522,7 +494,7 @@ function wrapParagraphContentInInsertion(xmlDoc, paragraph, revisionMetadata, au
     if (pPr) wrappedParagraph.appendChild(pPr.cloneNode(true));
 
     const ins = createWordElement(xmlDoc, 'w:ins');
-    const metadata = revisionMetadata || createRevisionMetadata(author);
+    const metadata = revisionMetadata || createRevisionMetadata(author, xmlDoc);
     ins.setAttribute('w:id', String(metadata.id));
     ins.setAttribute('w:author', metadata.author);
     ins.setAttribute('w:date', metadata.date);
@@ -818,14 +790,14 @@ async function applyToParagraphByExactText(documentXml, targetText, modifiedText
     const generateRedlines = options.generateRedlines !== false;
     const onInfo = typeof options?.onInfo === 'function' ? options.onInfo : () => { };
     const onWarn = typeof options?.onWarn === 'function' ? options.onWarn : () => { };
-    const parser = createParser();
     const serializer = createSerializer();
-    const xmlDoc = parser.parseFromString(documentXml, 'application/xml');
-    seedRevisionIdsFromDocument(xmlDoc);
+    const xmlDoc = parseOoxmlSafe(documentXml, 'application/xml').doc;
+    if (!xmlDoc) return { documentXml, hasChanges: false, status: 'error', error: { code: 'PARSE_ERROR', message: 'Could not parse document OOXML.' } };
+    const revisionIdAllocator = prepareRevisionAllocator(xmlDoc, options);
     const resolved = resolveTargetParagraph(xmlDoc, targetText, targetRef, 'redline', runtimeContext, { onInfo, onWarn });
     const targetParagraph = resolved.paragraph;
     preprocessRedlineTargetParagraph(targetParagraph);
-    const currentParagraphText = getParagraphText(targetParagraph).trim();
+    const currentParagraphText = getParagraphText(targetParagraph);
     const containingTable = findContainingWordElement(targetParagraph, 'tbl');
     const rawTableStructuralCandidate = !!containingTable
         && !targetEndRef
@@ -865,7 +837,9 @@ async function applyToParagraphByExactText(documentXml, targetText, modifiedText
             onInfo,
             onWarn
         })
-        : null;
+        : (typeof targetText === 'string' && /\r?\n/.test(targetText)
+            ? findReconstructionParagraphRange(xmlDoc, targetText)
+            : null);
     const hasExplicitRangeScope = Array.isArray(explicitRangeParagraphs) && explicitRangeParagraphs.length > 0;
     if (!useTableScope && hasExplicitRangeScope) {
         const insertionEntries = buildExplicitRangeInsertionEntries(explicitRangeParagraphs, effectiveModifiedText);
@@ -928,7 +902,7 @@ async function applyToParagraphByExactText(documentXml, targetText, modifiedText
                 markerType: 'numbered',
                 text: adjacencyInsertionCandidate.text
             },
-            generateRedlines ? createRevisionMetadata(author) : null,
+            generateRedlines ? createRevisionMetadata(author, xmlDoc) : null,
             author,
             { generateRedlines }
         );
@@ -961,7 +935,7 @@ async function applyToParagraphByExactText(documentXml, targetText, modifiedText
                 xmlDoc,
                 targetParagraph,
                 paragraphText,
-                generateRedlines ? createRevisionMetadata(author) : null,
+                generateRedlines ? createRevisionMetadata(author, xmlDoc) : null,
                 author,
                 { generateRedlines }
             );
@@ -992,7 +966,7 @@ async function applyToParagraphByExactText(documentXml, targetText, modifiedText
                 xmlDoc,
                 targetParagraph,
                 { ...entry, numId: insertionOnlyPlan.numId },
-                generateRedlines ? createRevisionMetadata(author) : null,
+                generateRedlines ? createRevisionMetadata(author, xmlDoc) : null,
                 author,
                 { generateRedlines }
             );
@@ -1070,12 +1044,14 @@ async function applyToParagraphByExactText(documentXml, targetText, modifiedText
             author,
             generateRedlines,
             existingRevisions: options.existingRevisions,
+            _revisionIdAllocator: revisionIdAllocator,
             _isolatedTableCell: useTableScope
         })
         : await applyRedlineToOxml(scopedXml, originalTextForApply, effectiveModifiedText, {
             author,
             generateRedlines,
             existingRevisions: options.existingRevisions,
+            _revisionIdAllocator: revisionIdAllocator,
             _isolatedTableCell: useTableScope
         });
     if (!result?.hasChanges) {
@@ -1131,13 +1107,18 @@ async function applyHighlightToParagraphByExactText(documentXml, targetText, tex
     const generateRedlines = options.generateRedlines !== false;
     const onInfo = typeof options?.onInfo === 'function' ? options.onInfo : () => { };
     const onWarn = typeof options?.onWarn === 'function' ? options.onWarn : () => { };
-    const parser = createParser();
     const serializer = createSerializer();
-    const xmlDoc = parser.parseFromString(documentXml, 'application/xml');
+    const xmlDoc = parseOoxmlSafe(documentXml, 'application/xml').doc;
+    if (!xmlDoc) return { documentXml, hasChanges: false, status: 'error', error: { code: 'PARSE_ERROR', message: 'Could not parse document OOXML.' } };
+    const revisionIdAllocator = prepareRevisionAllocator(xmlDoc, options);
     const resolved = resolveTargetParagraph(xmlDoc, targetText, targetRef, 'highlight', runtimeContext, { onInfo, onWarn });
     const targetParagraph = resolved.paragraph;
     const paragraphXml = serializer.serializeToString(targetParagraph);
-    const highlightedXml = applyHighlightToOoxml(paragraphXml, textToHighlight, color, { generateRedlines, author });
+    const highlightedXml = applyHighlightToOoxml(paragraphXml, textToHighlight, color, {
+        generateRedlines,
+        author,
+        _revisionIdAllocator: revisionIdAllocator
+    });
     if (!highlightedXml || highlightedXml === paragraphXml) return { documentXml, hasChanges: false };
     const { replacementNodes } = extractReplacementNodes(highlightedXml);
     const parent = targetParagraph.parentNode;
@@ -1150,9 +1131,10 @@ async function applyHighlightToParagraphByExactText(documentXml, targetText, tex
 async function applyCommentToParagraphByExactText(documentXml, targetText, textToComment, commentContent, author, targetRef = null, runtimeContext = null, options = {}) {
     const onInfo = typeof options?.onInfo === 'function' ? options.onInfo : () => { };
     const onWarn = typeof options?.onWarn === 'function' ? options.onWarn : () => { };
-    const parser = createParser();
     const serializer = createSerializer();
-    const xmlDoc = parser.parseFromString(documentXml, 'application/xml');
+    const xmlDoc = parseOoxmlSafe(documentXml, 'application/xml').doc;
+    if (!xmlDoc) return { documentXml, hasChanges: false, commentsXml: null, status: 'error', error: { code: 'PARSE_ERROR', message: 'Could not parse document OOXML.' } };
+    prepareRevisionAllocator(xmlDoc, options);
     const resolved = resolveTargetParagraph(xmlDoc, targetText, targetRef, 'comment', runtimeContext, { onInfo, onWarn });
     const targetParagraph = resolved.paragraph;
     const paragraphXml = serializer.serializeToString(targetParagraph);
@@ -1166,6 +1148,127 @@ async function applyCommentToParagraphByExactText(documentXml, targetText, textT
     return { documentXml: serializer.serializeToString(xmlDoc), hasChanges: true, commentsXml: commentResult.commentsXml || null, warnings: commentResult.warnings || [] };
 }
 
+function operationTargetPriority(op) {
+    if (op?.type === 'comment') return 0;
+    return 1;
+}
+
+/**
+ * Returns a stable operation order that resolves anchor-based operations before
+ * text edits can mutate their target text. Comments run first; all other
+ * operation types retain their original relative order.
+ *
+ * @param {Object[]} operations - Structured document operations
+ * @returns {Object[]} A reordered copy; input objects and input array are not mutated
+ */
+export function orderOperationsForStableTargets(operations = []) {
+    return (Array.isArray(operations) ? operations : [])
+        .map((operation, index) => ({ operation, index }))
+        .sort((a, b) => operationTargetPriority(a.operation) - operationTargetPriority(b.operation) || a.index - b.index)
+        .map(entry => entry.operation);
+}
+
+function mergeCommentsXml(existingXml, incomingXml) {
+    if (!incomingXml) return existingXml || null;
+    if (!existingXml) return incomingXml;
+
+    const serializer = createSerializer();
+    const existingDoc = parseOoxmlSafe(existingXml, 'application/xml').doc;
+    const incomingDoc = parseOoxmlSafe(incomingXml, 'application/xml').doc;
+    if (!existingDoc || !incomingDoc) return existingXml;
+    const existingRoot = existingDoc.documentElement;
+    const existingIds = new Set(
+        Array.from(existingRoot.getElementsByTagNameNS(NS_W, 'comment'))
+            .map(comment => comment.getAttribute('w:id') || comment.getAttribute('id'))
+            .filter(Boolean)
+    );
+
+    for (const comment of Array.from(incomingDoc.getElementsByTagNameNS(NS_W, 'comment'))) {
+        const id = comment.getAttribute('w:id') || comment.getAttribute('id');
+        if (id && existingIds.has(id)) continue;
+        existingRoot.appendChild(existingDoc.importNode(comment, true));
+        if (id) existingIds.add(id);
+    }
+    return serializer.serializeToString(existingDoc);
+}
+
+function cloneBatchRuntimeContext(runtimeContext) {
+    if (!runtimeContext || typeof runtimeContext !== 'object') return {};
+
+    const context = { ...runtimeContext };
+    if (runtimeContext.listFallbackSharedNumIdByKey instanceof Map) {
+        context.listFallbackSharedNumIdByKey = new Map(runtimeContext.listFallbackSharedNumIdByKey);
+    }
+    if (runtimeContext.tableStructuralRedlineKeys instanceof Set) {
+        context.tableStructuralRedlineKeys = new Set(runtimeContext.tableStructuralRedlineKeys);
+    }
+    if (runtimeContext.numberingIdState && typeof runtimeContext.numberingIdState === 'object') {
+        context.numberingIdState = {
+            ...runtimeContext.numberingIdState,
+            usedNumIds: runtimeContext.numberingIdState.usedNumIds instanceof Set
+                ? new Set(runtimeContext.numberingIdState.usedNumIds)
+                : runtimeContext.numberingIdState.usedNumIds,
+            usedAbstractNumIds: runtimeContext.numberingIdState.usedAbstractNumIds instanceof Set
+                ? new Set(runtimeContext.numberingIdState.usedAbstractNumIds)
+                : runtimeContext.numberingIdState.usedAbstractNumIds
+        };
+    }
+    if (runtimeContext.listFallbackSequenceState && typeof runtimeContext.listFallbackSequenceState === 'object') {
+        context.listFallbackSequenceState = {
+            ...runtimeContext.listFallbackSequenceState,
+            explicitByNumberingKey: runtimeContext.listFallbackSequenceState.explicitByNumberingKey instanceof Map
+                ? new Map(runtimeContext.listFallbackSequenceState.explicitByNumberingKey)
+                : runtimeContext.listFallbackSequenceState.explicitByNumberingKey
+        };
+    }
+    return context;
+}
+
+function commitBatchRuntimeContext(runtimeContext, context) {
+    if (!runtimeContext || typeof runtimeContext !== 'object') return;
+
+    if (runtimeContext.listFallbackSharedNumIdByKey instanceof Map && context.listFallbackSharedNumIdByKey instanceof Map) {
+        runtimeContext.listFallbackSharedNumIdByKey.clear();
+        for (const entry of context.listFallbackSharedNumIdByKey) runtimeContext.listFallbackSharedNumIdByKey.set(...entry);
+        context.listFallbackSharedNumIdByKey = runtimeContext.listFallbackSharedNumIdByKey;
+    }
+    if (runtimeContext.tableStructuralRedlineKeys instanceof Set && context.tableStructuralRedlineKeys instanceof Set) {
+        runtimeContext.tableStructuralRedlineKeys.clear();
+        for (const value of context.tableStructuralRedlineKeys) runtimeContext.tableStructuralRedlineKeys.add(value);
+        context.tableStructuralRedlineKeys = runtimeContext.tableStructuralRedlineKeys;
+    }
+    if (runtimeContext.numberingIdState && context.numberingIdState) {
+        for (const key of ['usedNumIds', 'usedAbstractNumIds']) {
+            if (runtimeContext.numberingIdState[key] instanceof Set && context.numberingIdState[key] instanceof Set) {
+                runtimeContext.numberingIdState[key].clear();
+                for (const value of context.numberingIdState[key]) runtimeContext.numberingIdState[key].add(value);
+                context.numberingIdState[key] = runtimeContext.numberingIdState[key];
+            }
+        }
+        Object.assign(runtimeContext.numberingIdState, context.numberingIdState);
+        context.numberingIdState = runtimeContext.numberingIdState;
+    }
+    if (runtimeContext.listFallbackSequenceState && context.listFallbackSequenceState) {
+        const originalMap = runtimeContext.listFallbackSequenceState.explicitByNumberingKey;
+        const updatedMap = context.listFallbackSequenceState.explicitByNumberingKey;
+        if (originalMap instanceof Map && updatedMap instanceof Map) {
+            originalMap.clear();
+            for (const entry of updatedMap) originalMap.set(...entry);
+            context.listFallbackSequenceState.explicitByNumberingKey = originalMap;
+        }
+        Object.assign(runtimeContext.listFallbackSequenceState, context.listFallbackSequenceState);
+        context.listFallbackSequenceState = runtimeContext.listFallbackSequenceState;
+    }
+    Object.assign(runtimeContext, context);
+}
+
+function normalizeOperationError(error) {
+    return {
+        code: typeof error?.code === 'string' && error.code ? error.code : 'OPERATION_ERROR',
+        message: error?.message || String(error)
+    };
+}
+
 /**
  * Applies one structured operation (`redline`, `highlight`, or `comment`) to
  * a full `word/document.xml` payload.
@@ -1182,6 +1285,14 @@ async function applyCommentToParagraphByExactText(documentXml, targetText, textT
  * @returns {Promise<{ documentXml: string, hasChanges: boolean, numberingXml?: string|null, commentsXml?: string|null, warnings?: string[] }>}
  */
 export async function applyOperationToDocumentXml(documentXml, op, author, runtimeContext = null, options = {}) {
+    const parsed = parseOoxmlSafe(documentXml, 'application/xml');
+    if (parsed.error || !parsed.doc) {
+        return { documentXml, hasChanges: false, status: 'error', error: parsed.error, warnings: parsed.warnings };
+    }
+    const operationOptions = {
+        ...options,
+        _revisionIdAllocator: prepareRevisionAllocator(parsed.doc, options)
+    };
     if (op?.type === 'highlight') {
         return applyHighlightToParagraphByExactText(
             documentXml,
@@ -1191,7 +1302,7 @@ export async function applyOperationToDocumentXml(documentXml, op, author, runti
             author,
             op.targetRef,
             runtimeContext,
-            options
+            operationOptions
         );
     }
     if (op?.type === 'comment') {
@@ -1203,7 +1314,7 @@ export async function applyOperationToDocumentXml(documentXml, op, author, runti
             author,
             op.targetRef,
             runtimeContext,
-            options
+            operationOptions
         );
     }
     return applyToParagraphByExactText(
@@ -1214,6 +1325,135 @@ export async function applyOperationToDocumentXml(documentXml, op, author, runti
         op?.targetRef,
         op?.targetEndRef,
         runtimeContext,
-        options
+        operationOptions
     );
 }
+
+/**
+ * Applies a batch of operations using stable target ordering. This prevents a
+ * later comment from missing original text changed by an earlier replacement
+ * in the same batch.
+ *
+ * Results retain each operation's original 1-based index even though execution
+ * is reordered. Numbering payloads are returned as an array so package callers
+ * can merge each one with `ensureNumberingArtifactsInZip`.
+ *
+ * @param {string} documentXml - Full `word/document.xml` payload
+ * @param {Object[]} operations - Structured operations
+ * @param {string} author - Revision/comment author
+ * @param {Object|null} [runtimeContext=null] - Shared turn context
+ * @param {{
+ *   atomic?: boolean,
+ *   continueOnError?: boolean,
+ *   generateRedlines?: boolean,
+ *   onInfo?: (message: string) => void,
+ *   onWarn?: (message: string) => void
+ * }} [options={}] - Runner options. `atomic` defaults to `true`, returning the
+ * original document and no package artifacts if any operation fails.
+ * `continueOnError` defaults to `true`, so all operations are attempted and
+ * represented in `results`; `false` stops after the first operation error.
+ * @returns {Promise<{
+ *   documentXml: string,
+ *   hasChanges: boolean,
+ *   commentsXml: string|null,
+ *   numberingXmlParts: string[],
+ *   results: Array<{index:number,type:string,status:string,warnings?:string[],error?:Object}>,
+ *   executionOrder: number[],
+ *   rolledBack?: boolean
+ * }>}
+ */
+export async function applyOperationsToDocumentXml(documentXml, operations, author, runtimeContext = null, options = {}) {
+    const parsed = parseOoxmlSafe(documentXml, 'application/xml');
+    if (parsed.error || !parsed.doc) {
+        return {
+            documentXml,
+            hasChanges: false,
+            commentsXml: null,
+            numberingXmlParts: [],
+            results: [],
+            executionOrder: [],
+            status: 'error',
+            error: parsed.error,
+            warnings: parsed.warnings
+        };
+    }
+    const sourceOperations = Array.isArray(operations) ? operations : [];
+    const scheduled = sourceOperations
+        .map((operation, index) => ({ operation, index }))
+        .sort((a, b) => operationTargetPriority(a.operation) - operationTargetPriority(b.operation) || a.index - b.index);
+
+    const atomic = options.atomic !== false;
+    const continueOnError = options.continueOnError !== false;
+    const context = cloneBatchRuntimeContext(runtimeContext);
+    if (!(context.targetRefSnapshot instanceof Map)) {
+        context.targetRefSnapshot = buildTargetReferenceSnapshot(parsed.doc);
+    }
+
+    let currentDocumentXml = documentXml;
+    let commentsXml = null;
+    let hasChanges = false;
+    const numberingXmlParts = [];
+    const results = [];
+    const executionOrder = [];
+    let operationFailed = false;
+
+    for (const entry of scheduled) {
+        const { operation, index } = entry;
+        executionOrder.push(index + 1);
+        try {
+            const result = await applyOperationToDocumentXml(
+                currentDocumentXml,
+                operation,
+                author,
+                context,
+                options
+            );
+            currentDocumentXml = result.documentXml;
+            hasChanges = hasChanges || result.hasChanges === true;
+            commentsXml = mergeCommentsXml(commentsXml, result.commentsXml || null);
+            if (result.numberingXml) numberingXmlParts.push(result.numberingXml);
+            const isError = result.status === 'error' || !!result.error;
+            operationFailed = operationFailed || isError;
+            results.push({
+                index: index + 1,
+                type: operation?.type || 'redline',
+                status: isError ? 'error' : (result.hasChanges ? 'applied' : 'no_change'),
+                ...(Array.isArray(result.warnings) && result.warnings.length > 0 ? { warnings: result.warnings } : {}),
+                ...(result.error ? { error: result.error } : {})
+            });
+            if (isError && !continueOnError) break;
+        } catch (error) {
+            const normalizedError = normalizeOperationError(error);
+            operationFailed = true;
+            results.push({
+                index: index + 1,
+                type: operation?.type || 'redline',
+                status: 'error',
+                warnings: [normalizedError.message],
+                error: normalizedError
+            });
+            if (!continueOnError) break;
+        }
+    }
+
+    results.sort((a, b) => a.index - b.index);
+    const rolledBack = atomic && operationFailed;
+    if (!rolledBack) commitBatchRuntimeContext(runtimeContext, context);
+
+    return {
+        documentXml: rolledBack ? documentXml : currentDocumentXml,
+        hasChanges: rolledBack ? false : hasChanges,
+        commentsXml: rolledBack ? null : commentsXml,
+        numberingXmlParts: rolledBack ? [] : numberingXmlParts,
+        results,
+        executionOrder,
+        ...(rolledBack ? {
+            rolledBack: true,
+            status: 'error',
+            error: {
+                code: 'BATCH_OPERATION_FAILED',
+                message: 'Atomic batch rolled back because one or more operations failed.'
+            }
+        } : {})
+    };
+}

package/services/table-reconciliation.js

@@ -7,7 +7,7 @@
 import { computeWordLevelDiffOps } from '../pipeline/diff-engine.js';
 import { splitRunsAtDiffBoundaries, applyPatches } from '../pipeline/patching.js';
 import { serializeToOoxml } from '../pipeline/serialization.js';
-import { NS_W, createRevisionMetadata, escapeXml, RunKind } from '../core/types.js';
+import { createRevisionMetadata, escapeXml, RunKind } from '../core/types.js';
 import { preprocessMarkdown } from '../pipeline/markdown-processor.js';
 
 /**
@@ -19,8 +19,8 @@ import { preprocessMarkdown } from '../pipeline/markdown-processor.js';
  * @returns {string} Complete w:tbl OOXML
  */
 export function generateTableOoxml(tableData, options = {}) {
-    const { generateRedlines = false, author = 'AI' } = options;
-    const tableInsertMeta = generateRedlines ? createRevisionMetadata(author) : null;
+    const { generateRedlines = false, author = 'AI', revisionIdAllocator = null } = options;
+    const tableInsertMeta = generateRedlines ? createRevisionMetadata(author, revisionIdAllocator) : null;
 
     // Determine number of columns
     const numCols = tableData.headers?.length || (tableData.rows?.[0]?.length || 1);
@@ -68,7 +68,11 @@ export function generateTableOoxml(tableData, options = {}) {
                 endOffset: cleanText.length
             }];
 
-            const runsOoxml = serializeToOoxml(runModel, null, formatHints, { author, generateRedlines });
+            const runsOoxml = serializeToOoxml(runModel, null, formatHints, {
+                author,
+                generateRedlines,
+                revisionIdAllocator
+            });
 
             // Cell properties
             const tcPr = '<w:tcPr><w:tcW w:w="0" w:type="auto"/></w:tcPr>';
@@ -164,7 +168,7 @@ export function diffTablesWithVirtualGrid(oldGrid, newTableData) {
  * @returns {string} Reconciled w:tbl OOXML
  */
 export function serializeVirtualGridToOoxml(grid, operations, options) {
-    const { generateRedlines, author } = options;
+    const { generateRedlines, author, revisionIdAllocator = null } = options;
     const opIndex = buildTableOperationIndex(operations);
 
     let rowsXml = '';
@@ -206,7 +210,7 @@ export function serializeVirtualGridToOoxml(grid, operations, options) {
         let trPr = grid.trPrList[row] || '<w:trPr/>';
 
         if (rowDeleteOp && generateRedlines) {
-            const metadata = createRevisionMetadata(author);
+            const metadata = createRevisionMetadata(author, revisionIdAllocator);
             const delMark = `<w:del w:id="${metadata.id}" w:author="${escapeXml(metadata.author)}" w:date="${metadata.date}"/>`;
             if (trPr.includes('</w:trPr>')) {
                 trPr = trPr.replace('</w:trPr>', `${delMark}</w:trPr>`);
@@ -222,7 +226,7 @@ export function serializeVirtualGridToOoxml(grid, operations, options) {
     const insertOps = opIndex.rowInsertOperations;
     for (const op of insertOps) {
         let cellsXml = '';
-        const rowInsertMeta = generateRedlines ? createRevisionMetadata(author) : null;
+        const rowInsertMeta = generateRedlines ? createRevisionMetadata(author, revisionIdAllocator) : null;
 
         for (const cellText of op.cells) {
             const { cleanText, formatHints } = preprocessMarkdown(cellText);
@@ -236,7 +240,11 @@ export function serializeVirtualGridToOoxml(grid, operations, options) {
                 endOffset: cleanText.length
             }];
 
-            const runsOoxml = serializeToOoxml(runModel, null, formatHints, { author, generateRedlines });
+            const runsOoxml = serializeToOoxml(runModel, null, formatHints, {
+                author,
+                generateRedlines,
+                revisionIdAllocator
+            });
             // serializeToOoxml already returns one or more w:p blocks.
             cellsXml += `<w:tc><w:tcPr><w:tcW w:w="0" w:type="auto"/></w:tcPr>${runsOoxml}</w:tc>`;
         }
@@ -293,7 +301,7 @@ function buildTableOperationIndex(operations) {
 }
 
 function reconcileCellContent(cell, newText, options) {
-    const { generateRedlines, author } = options;
+    const { generateRedlines, author, revisionIdAllocator = null } = options;
     const { cleanText, formatHints } = preprocessMarkdown(newText);
 
     // For now, satisfy with single block or join blocks
@@ -310,7 +318,11 @@ function reconcileCellContent(cell, newText, options) {
         formatHints
     });
 
-    const runsOoxml = serializeToOoxml(patchedModel, baseBlock.pPr, formatHints, { author, generateRedlines });
+    const runsOoxml = serializeToOoxml(patchedModel, baseBlock.pPr, formatHints, {
+        author,
+        generateRedlines,
+        revisionIdAllocator
+    });
     return runsOoxml;
 }
 
@@ -322,7 +334,7 @@ function serializeCellBlocks(blocks) {
     }).join('');
 }
 
-function buildTcXml(cell, content, options) {
+function buildTcXml(cell, content, _options) {
     let tcPr = cell.tcPrXml;
 
     // Ensure gridSpan is preserved