@ansonlai/docx-redline-js 0.7.2 → 0.8.1

package/services/batch-operation-orchestrator.js

@@ -1,8 +1,8 @@
 import { createSerializer, parseOoxmlSafe } from '../adapters/xml-adapter.js';
 import { getDefaultAuthor } from '../adapters/config.js';
-import {
-    isExistingRevisionsPolicy,
-    normalizeDocumentOperation,
+import {
+    isExistingRevisionsPolicy,
+    normalizeDocumentOperation,
     resolveDocumentOperationAuthor
 } from './document-operation-contract.js';
 import {
@@ -19,17 +19,17 @@ import {
     computeDocumentPartsRevisionToken,
     areRevisionTokensEqual
 } from './revision-token.js';
-import {
-    createEmptyReceipt,
-    reconcileReceiptsAgainstOutput
-} from './receipt-collector.js';
-import { compileOperationBatch } from './operation-batch-compiler.js';
-import { createRetryPlan } from './error-recovery.js';
+import {
+    createEmptyReceipt,
+    reconcileReceiptsAgainstOutput
+} from './receipt-collector.js';
+import { compileOperationBatch } from './operation-batch-compiler.js';
+import { createRetryPlan } from './error-recovery.js';
 
 const NS_W = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
 
 function operationTargetPriority(op) {
-    return op?.type === 'comment' || op?.type === 'comment_reply' ? 0 : 1;
+    return op?.type === 'comment' || op?.type === 'comment_reply' || op?.type === 'comment_resolve' ? 0 : 1;
 }
 
 /**
@@ -72,10 +72,10 @@ export function buildOperationDependencyPlan(operations = []) {
     }
 
     // 2. Build dependency edges
-    const inDegrees = new Array(list.length).fill(0);
-    const dependents = Array.from({ length: list.length }, () => new Set());
-    const dependencies = Array.from({ length: list.length }, () => new Set());
-    const mutatingCaptureConsumers = new Map();
+    const inDegrees = new Array(list.length).fill(0);
+    const dependents = Array.from({ length: list.length }, () => new Set());
+    const dependencies = Array.from({ length: list.length }, () => new Set());
+    const mutatingCaptureConsumers = new Map();
 
     for (let i = 0; i < list.length; i++) {
         const op = list[i];
@@ -110,40 +110,40 @@ export function buildOperationDependencyPlan(operations = []) {
                     }
                 };
             }
-            if (!dependencies[i].has(producerIndex)) {
-                dependencies[i].add(producerIndex);
-                dependents[producerIndex].add(i);
-                inDegrees[i]++;
-            }
-            const kind = normalizeDocumentOperation(op).operationKind;
-            if (kind !== 'comment' && kind !== 'comment_reply') {
-                if (!mutatingCaptureConsumers.has(ref)) mutatingCaptureConsumers.set(ref, []);
-                mutatingCaptureConsumers.get(ref).push({
-                    index: i,
-                    select: op?.target?.select ?? op?.targetDescriptor?.select ?? null
-                });
-            }
-        }
-    }
-
-    for (const [captureRef, consumers] of mutatingCaptureConsumers) {
-        if (consumers.length < 2) continue;
-        const selectors = consumers.map(consumer => consumer.select);
-        const distinctSelectors = new Set(selectors);
-        if (selectors.every(selector => typeof selector === 'string' && selector.length > 0)
-            && distinctSelectors.size === selectors.length) {
-            continue;
-        }
-        return {
-            valid: false,
-            error: {
-                code: 'CAPTURE_FANOUT_CONFLICT',
-                message: `Capture "${captureRef}" has overlapping or unscoped mutating consumers at operation indices ${consumers.map(consumer => consumer.index + 1).join(', ')}.`,
-                operationIndexes: consumers.map(consumer => consumer.index + 1),
-                captureRef
-            }
-        };
-    }
+            if (!dependencies[i].has(producerIndex)) {
+                dependencies[i].add(producerIndex);
+                dependents[producerIndex].add(i);
+                inDegrees[i]++;
+            }
+            const kind = normalizeDocumentOperation(op).operationKind;
+            if (kind !== 'comment' && kind !== 'comment_reply' && kind !== 'comment_resolve') {
+                if (!mutatingCaptureConsumers.has(ref)) mutatingCaptureConsumers.set(ref, []);
+                mutatingCaptureConsumers.get(ref).push({
+                    index: i,
+                    select: op?.target?.select ?? op?.targetDescriptor?.select ?? null
+                });
+            }
+        }
+    }
+
+    for (const [captureRef, consumers] of mutatingCaptureConsumers) {
+        if (consumers.length < 2) continue;
+        const selectors = consumers.map(consumer => consumer.select);
+        const distinctSelectors = new Set(selectors);
+        if (selectors.every(selector => typeof selector === 'string' && selector.length > 0)
+            && distinctSelectors.size === selectors.length) {
+            continue;
+        }
+        return {
+            valid: false,
+            error: {
+                code: 'CAPTURE_FANOUT_CONFLICT',
+                message: `Capture "${captureRef}" has overlapping or unscoped mutating consumers at operation indices ${consumers.map(consumer => consumer.index + 1).join(', ')}.`,
+                operationIndexes: consumers.map(consumer => consumer.index + 1),
+                captureRef
+            }
+        };
+    }
 
     // 3. Stable topological sort with comment priority among ready nodes
     const ready = [];
@@ -214,63 +214,63 @@ function mergeCommentsXml(existingXml, incomingXml) {
     return serializer.serializeToString(existingDoc);
 }
 
-export async function applyOperationsToDocumentXml(documentXml, operations, author, runtimeContext = null, options = {}) {
+export async function applyOperationsToDocumentXml(documentXml, operations, author, runtimeContext = null, options = {}) {
     const sourceOperations = Array.isArray(operations) ? operations : [];
     const defaultAuthor = getDefaultAuthor();
-    const emptyReceipts = () => sourceOperations.map((op, i) => createEmptyReceipt(
+    const emptyReceipts = () => sourceOperations.map((op, i) => createEmptyReceipt(
         i + 1,
         op?.operationId,
         resolveDocumentOperationAuthor(op, author, defaultAuthor),
-        'not_attempted'
-    ));
-    const failedBeforeExecution = (error, extra = {}) => {
-        const receipts = emptyReceipts();
-        return {
-            documentXml,
-            hasChanges: false,
-            commentsXml: null,
-            numberingXmlParts: [],
-            results: [],
-            receipts,
-            executionOrder: [],
-            authorsUsed: [],
-            ...(options.atomic === true ? { rolledBack: true } : {}),
-            status: 'error',
-            error: normalizeOperationError(error),
-            retryPlan: createRetryPlan({
-                atomic: options.atomic === true,
-                rolledBack: options.atomic === true,
-                results: [],
-                receipts,
-                operationCount: sourceOperations.length
-            }),
-            ...extra
-        };
-    };
-
-    if (options.existingRevisions != null && !isExistingRevisionsPolicy(options.existingRevisions)) {
-        return failedBeforeExecution({
-            code: 'INVALID_OPERATION',
-            message: `Unsupported existingRevisions policy: "${String(options.existingRevisions)}".`,
-            field: 'existingRevisions'
-        });
-    }
+        'not_attempted'
+    ));
+    const failedBeforeExecution = (error, extra = {}) => {
+        const receipts = emptyReceipts();
+        return {
+            documentXml,
+            hasChanges: false,
+            commentsXml: null,
+            numberingXmlParts: [],
+            results: [],
+            receipts,
+            executionOrder: [],
+            authorsUsed: [],
+            ...(options.atomic === true ? { rolledBack: true } : {}),
+            status: 'error',
+            error: normalizeOperationError(error),
+            retryPlan: createRetryPlan({
+                atomic: options.atomic === true,
+                rolledBack: options.atomic === true,
+                results: [],
+                receipts,
+                operationCount: sourceOperations.length
+            }),
+            ...extra
+        };
+    };
+
+    if (options.existingRevisions != null && !isExistingRevisionsPolicy(options.existingRevisions)) {
+        return failedBeforeExecution({
+            code: 'INVALID_OPERATION',
+            message: `Unsupported existingRevisions policy: "${String(options.existingRevisions)}".`,
+            field: 'existingRevisions'
+        });
+    }
 
     if (options?.expectedRevision) {
         const tokenValidation = validateRevisionToken(options.expectedRevision);
         if (!tokenValidation.valid) {
-            return failedBeforeExecution({
-                code: tokenValidation.error?.code || 'INVALID_REVISION_TOKEN',
-                message: tokenValidation.error?.message || 'Invalid revision token.'
-            });
+            return failedBeforeExecution({
+                code: tokenValidation.error?.code || 'INVALID_REVISION_TOKEN',
+                message: tokenValidation.error?.message || 'Invalid revision token.'
+            });
         }
         if (options.expectedRevision.scope !== 'document-parts') {
-            return failedBeforeExecution({
-                code: 'REVISION_TOKEN_SCOPE_MISMATCH',
-                message: `Revision token scope mismatch: expected 'document-parts', got '${options.expectedRevision.scope}'.`,
-                expectedScope: 'document-parts',
-                actualScope: options.expectedRevision.scope
-            });
+            return failedBeforeExecution({
+                code: 'REVISION_TOKEN_SCOPE_MISMATCH',
+                message: `Revision token scope mismatch: expected 'document-parts', got '${options.expectedRevision.scope}'.`,
+                expectedScope: 'document-parts',
+                actualScope: options.expectedRevision.scope
+            });
         }
         const currentToken = await computeDocumentPartsRevisionToken({
             documentXml,
@@ -280,12 +280,12 @@ export async function applyOperationsToDocumentXml(documentXml, operations, auth
             stylesXml: runtimeContext?.stylesXml || options.stylesXml
         }, options);
         if (!areRevisionTokensEqual(currentToken.value, options.expectedRevision.value)) {
-            return failedBeforeExecution({
-                code: 'REVISION_MISMATCH',
-                message: `Document revision mismatch: expected '${options.expectedRevision.value}', current is '${currentToken.value}'.`,
-                expectedRevision: options.expectedRevision,
-                currentRevision: currentToken
-            });
+            return failedBeforeExecution({
+                code: 'REVISION_MISMATCH',
+                message: `Document revision mismatch: expected '${options.expectedRevision.value}', current is '${currentToken.value}'.`,
+                expectedRevision: options.expectedRevision,
+                currentRevision: currentToken
+            });
         }
     }
 
@@ -296,73 +296,73 @@ export async function applyOperationsToDocumentXml(documentXml, operations, auth
             _deferDocumentSerialization: true
         });
     if (!session.valid) {
-        return failedBeforeExecution(session.parseResult.error, { warnings: session.parseResult.warnings });
+        return failedBeforeExecution(session.parseResult.error, { warnings: session.parseResult.warnings });
+    }
+    const compilation = compileOperationBatch(session.document, sourceOperations, {
+        strictTargets: options.strictTargets !== false,
+        onInfo: options.onInfo,
+        onWarn: options.onWarn
+    });
+    session.sourceTargetRegistry = compilation.registry;
+    if (compilation.conflicts.length > 0) {
+        const conflictByIndex = new Map();
+        for (const conflict of compilation.conflicts) {
+            for (const index of conflict.operationIndexes) {
+                if (!conflictByIndex.has(index)) conflictByIndex.set(index, conflict);
+            }
+        }
+        const conflictResults = Array.from(conflictByIndex, ([index, conflict]) => {
+            const operation = sourceOperations[index - 1];
+            const authorUsed = resolveDocumentOperationAuthor(operation, author, defaultAuthor);
+            const normalizedConflict = normalizeOperationError(conflict, {
+                operationIndex: index,
+                ...(operation?.operationId ? { operationId: operation.operationId } : {})
+            });
+            return {
+                index,
+                type: operation?.type || 'redline',
+                operationType: normalizeDocumentOperation(operation).operationKind,
+                status: 'error',
+                authorUsed,
+                error: normalizedConflict,
+                receipt: createEmptyReceipt(index, operation?.operationId, authorUsed, 'refused')
+            };
+        }).sort((left, right) => left.index - right.index);
+        const receipts = sourceOperations.map((operation, index) => {
+            const conflictResult = conflictResults.find(result => result.index === index + 1);
+            return conflictResult?.receipt || createEmptyReceipt(
+                index + 1,
+                operation?.operationId,
+                resolveDocumentOperationAuthor(operation, author, defaultAuthor),
+                'not_attempted'
+            );
+        });
+        return {
+            documentXml,
+            hasChanges: false,
+            commentsXml: null,
+            numberingXmlParts: [],
+            results: conflictResults,
+            receipts,
+            executionOrder: [],
+            authorsUsed: [],
+            rolledBack: options.atomic === true,
+            status: 'error',
+            error: normalizeOperationError(compilation.conflicts[0]),
+            conflicts: compilation.conflicts.map(conflict => normalizeOperationError(conflict)),
+            retryPlan: createRetryPlan({
+                atomic: options.atomic === true,
+                rolledBack: options.atomic === true,
+                results: conflictResults,
+                receipts,
+                operationCount: sourceOperations.length
+            })
+        };
     }
-    const compilation = compileOperationBatch(session.document, sourceOperations, {
-        strictTargets: options.strictTargets !== false,
-        onInfo: options.onInfo,
-        onWarn: options.onWarn
-    });
-    session.sourceTargetRegistry = compilation.registry;
-    if (compilation.conflicts.length > 0) {
-        const conflictByIndex = new Map();
-        for (const conflict of compilation.conflicts) {
-            for (const index of conflict.operationIndexes) {
-                if (!conflictByIndex.has(index)) conflictByIndex.set(index, conflict);
-            }
-        }
-        const conflictResults = Array.from(conflictByIndex, ([index, conflict]) => {
-            const operation = sourceOperations[index - 1];
-            const authorUsed = resolveDocumentOperationAuthor(operation, author, defaultAuthor);
-            const normalizedConflict = normalizeOperationError(conflict, {
-                operationIndex: index,
-                ...(operation?.operationId ? { operationId: operation.operationId } : {})
-            });
-            return {
-                index,
-                type: operation?.type || 'redline',
-                operationType: normalizeDocumentOperation(operation).operationKind,
-                status: 'error',
-                authorUsed,
-                error: normalizedConflict,
-                receipt: createEmptyReceipt(index, operation?.operationId, authorUsed, 'refused')
-            };
-        }).sort((left, right) => left.index - right.index);
-        const receipts = sourceOperations.map((operation, index) => {
-            const conflictResult = conflictResults.find(result => result.index === index + 1);
-            return conflictResult?.receipt || createEmptyReceipt(
-                index + 1,
-                operation?.operationId,
-                resolveDocumentOperationAuthor(operation, author, defaultAuthor),
-                'not_attempted'
-            );
-        });
-        return {
-            documentXml,
-            hasChanges: false,
-            commentsXml: null,
-            numberingXmlParts: [],
-            results: conflictResults,
-            receipts,
-            executionOrder: [],
-            authorsUsed: [],
-            rolledBack: options.atomic === true,
-            status: 'error',
-            error: normalizeOperationError(compilation.conflicts[0]),
-            conflicts: compilation.conflicts.map(conflict => normalizeOperationError(conflict)),
-            retryPlan: createRetryPlan({
-                atomic: options.atomic === true,
-                rolledBack: options.atomic === true,
-                results: conflictResults,
-                receipts,
-                operationCount: sourceOperations.length
-            })
-        };
-    }
-    const executableOperations = compilation.compiledOperations;
-    const dependencyPlan = buildOperationDependencyPlan(executableOperations);
+    const executableOperations = compilation.compiledOperations;
+    const dependencyPlan = buildOperationDependencyPlan(executableOperations);
     if (!dependencyPlan.valid) {
-        return failedBeforeExecution(dependencyPlan.error);
+        return failedBeforeExecution(dependencyPlan.error);
     }
     const scheduled = dependencyPlan.scheduled;
 
@@ -373,7 +373,7 @@ export async function applyOperationsToDocumentXml(documentXml, operations, auth
         context.targetRefSnapshot = session.initialTargetReferenceSnapshot;
     }
     session.runtimeContext = context;
-    if (sourceOperations.some(op => op?.type === 'comment_reply')) {
+    if (sourceOperations.some(op => op?.type === 'comment_reply' || op?.type === 'comment_resolve')) {
         session.commentsXml = context.commentsXml || options.commentsXml || null;
         session.commentsExtendedXml = context.commentsExtendedXml || options.commentsExtendedXml || null;
         session.commentsXmlMode = 'replace';
@@ -386,37 +386,37 @@ export async function applyOperationsToDocumentXml(documentXml, operations, auth
     const authorsUsed = session.authorsUsed;
     let operationFailed = false;
 
-    for (const { operation, index } of scheduled) {
-        executionOrder.push(index + 1);
-        const sourceBinding = compilation.bindings[index];
-        if (sourceBinding?.error) {
-            operationFailed = true;
-            const authorUsed = resolveDocumentOperationAuthor(operation, author, defaultAuthor);
-            const errorReceipt = createEmptyReceipt(
-                index + 1,
-                operation?.operationId,
-                authorUsed,
-                'refused'
-            );
-            const normalizedBindingError = normalizeOperationError(sourceBinding.error, {
-                operationIndex: index + 1,
-                ...(operation?.operationId ? { operationId: operation.operationId } : {})
-            });
-            errorReceipt.warnings.push(normalizedBindingError.message);
-            results.push({
-                index: index + 1,
-                type: operation?.type || 'redline',
-                status: 'error',
-                operationType: normalizeDocumentOperation(operation).operationKind,
-                authorUsed,
-                warnings: [normalizedBindingError.message],
-                error: normalizedBindingError,
-                receipt: errorReceipt
-            });
-            if (!continueOnError) break;
-            continue;
-        }
-        try {
+    for (const { operation, index } of scheduled) {
+        executionOrder.push(index + 1);
+        const sourceBinding = compilation.bindings[index];
+        if (sourceBinding?.error) {
+            operationFailed = true;
+            const authorUsed = resolveDocumentOperationAuthor(operation, author, defaultAuthor);
+            const errorReceipt = createEmptyReceipt(
+                index + 1,
+                operation?.operationId,
+                authorUsed,
+                'refused'
+            );
+            const normalizedBindingError = normalizeOperationError(sourceBinding.error, {
+                operationIndex: index + 1,
+                ...(operation?.operationId ? { operationId: operation.operationId } : {})
+            });
+            errorReceipt.warnings.push(normalizedBindingError.message);
+            results.push({
+                index: index + 1,
+                type: operation?.type || 'redline',
+                status: 'error',
+                operationType: normalizeDocumentOperation(operation).operationKind,
+                authorUsed,
+                warnings: [normalizedBindingError.message],
+                error: normalizedBindingError,
+                receipt: errorReceipt
+            });
+            if (!continueOnError) break;
+            continue;
+        }
+        try {
             const result = await applyOperationToDocumentXml(
                 session.currentDocumentXml,
                 operation,
@@ -450,18 +450,21 @@ export async function applyOperationsToDocumentXml(documentXml, operations, auth
                 authorUsed: result.authorUsed,
                 ...(result.resolvedBy ? { resolvedBy: result.resolvedBy } : {}),
                 ...(result.resolvedTarget ? { resolvedTarget: result.resolvedTarget } : {}),
-                ...(result.resolvedAnchor ? { resolvedAnchor: result.resolvedAnchor } : {}),
-                ...(result.change ? { change: result.change } : {}),
-                ...(Array.isArray(result.warnings) && result.warnings.length > 0 ? { warnings: result.warnings } : {}),
+                ...(result.resolvedAnchor ? { resolvedAnchor: result.resolvedAnchor } : {}),
+                ...(result.change ? { change: result.change } : {}),
+                ...(result.operationType === 'comment_resolve' && !isError
+                    ? { resolved: result.resolved, threadRootId: result.threadRootId, commentIds: result.commentIds }
+                    : {}),
+                ...(Array.isArray(result.warnings) && result.warnings.length > 0 ? { warnings: result.warnings } : {}),
                 ...(result.error ? { error: result.error } : {}),
                 ...(result.receipt ? { receipt: result.receipt } : {})
             });
             if (isError && !continueOnError) break;
-        } catch (error) {
-            const normalizedError = normalizeOperationError(error, {
-                operationIndex: index + 1,
-                ...(operation?.operationId ? { operationId: operation.operationId } : {})
-            });
+        } catch (error) {
+            const normalizedError = normalizeOperationError(error, {
+                operationIndex: index + 1,
+                ...(operation?.operationId ? { operationId: operation.operationId } : {})
+            });
             operationFailed = true;
             const authorUsed = resolveDocumentOperationAuthor(operation, author, getDefaultAuthor());
             const errorReceipt = createEmptyReceipt(
@@ -532,34 +535,34 @@ export async function applyOperationsToDocumentXml(documentXml, operations, auth
         }
     }
 
-    if (rolledBack) {
-        for (const r of results) {
-            if (r.receipt && r.receipt.attemptedDisposition === 'applied') {
-                r.receipt.finalDisposition = 'rolled_back';
-                r.receipt.committed = false;
-            }
-            if (r.change) {
-                r.change.finalDisposition = 'rolled_back';
-                r.change.committed = false;
-            }
-        }
+    if (rolledBack) {
+        for (const r of results) {
+            if (r.receipt && r.receipt.attemptedDisposition === 'applied') {
+                r.receipt.finalDisposition = 'rolled_back';
+                r.receipt.committed = false;
+            }
+            if (r.change) {
+                r.change.finalDisposition = 'rolled_back';
+                r.change.committed = false;
+            }
+        }
         for (const receipt of allReceipts) {
             if (receipt.attemptedDisposition === 'applied') {
                 receipt.finalDisposition = 'rolled_back';
                 receipt.committed = false;
             }
         }
-    } else {
-        for (const r of results) {
-            if (r.receipt && r.receipt.attemptedDisposition === 'applied') {
-                r.receipt.committed = true;
-                r.receipt.finalDisposition = 'applied';
-            }
-            if (r.change) {
-                r.change.finalDisposition = 'applied';
-                r.change.committed = true;
-            }
-        }
+    } else {
+        for (const r of results) {
+            if (r.receipt && r.receipt.attemptedDisposition === 'applied') {
+                r.receipt.committed = true;
+                r.receipt.finalDisposition = 'applied';
+            }
+            if (r.change) {
+                r.change.finalDisposition = 'applied';
+                r.change.committed = true;
+            }
+        }
         for (const receipt of allReceipts) {
             if (receipt.attemptedDisposition === 'applied') {
                 receipt.committed = true;
@@ -570,8 +573,8 @@ export async function applyOperationsToDocumentXml(documentXml, operations, auth
 
     if (!rolledBack) commitBatchRuntimeContext(runtimeContext, context);
 
-    const batchResult = {
-        documentXml: rolledBack ? session.rollback() : outputDocumentXml,
+    const batchResult = {
+        documentXml: rolledBack ? session.rollback() : outputDocumentXml,
         hasChanges: rolledBack ? false : hasChanges,
         commentsXml: rolledBack ? null : session.commentsXml,
         commentsExtendedXml: rolledBack ? null : session.commentsExtendedXml,
@@ -585,33 +588,33 @@ export async function applyOperationsToDocumentXml(documentXml, operations, auth
         ...(rolledBack ? {
             rolledBack: true,
             status: 'error',
-            error: normalizeOperationError({
-                code: reconciliationError ? reconciliationError.code : (serializationError ? 'DOCUMENT_SERIALIZATION_FAILED' : 'BATCH_OPERATION_FAILED'),
-                message: reconciliationError?.message
-                    || serializationError?.message
-                    || 'Atomic batch rolled back because one or more operations failed.'
-            })
-        } : (reconciliationError ? {
-            status: 'error',
-            error: normalizeOperationError(reconciliationError)
-        } : (operationFailed ? {
-            status: hasChanges ? 'partial' : 'error',
-            error: normalizeOperationError({
-                code: 'BATCH_OPERATION_FAILED',
-                message: 'One or more operations failed.'
-            })
-        } : {
-            status: 'ok'
-        })))
-    };
-    if (batchResult.status === 'error' || batchResult.status === 'partial') {
-        batchResult.retryPlan = createRetryPlan({
-            atomic,
-            rolledBack,
-            results: batchResult.results,
-            receipts: batchResult.receipts,
-            operationCount: sourceOperations.length
-        });
-    }
-    return batchResult;
-}
+            error: normalizeOperationError({
+                code: reconciliationError ? reconciliationError.code : (serializationError ? 'DOCUMENT_SERIALIZATION_FAILED' : 'BATCH_OPERATION_FAILED'),
+                message: reconciliationError?.message
+                    || serializationError?.message
+                    || 'Atomic batch rolled back because one or more operations failed.'
+            })
+        } : (reconciliationError ? {
+            status: 'error',
+            error: normalizeOperationError(reconciliationError)
+        } : (operationFailed ? {
+            status: hasChanges ? 'partial' : 'error',
+            error: normalizeOperationError({
+                code: 'BATCH_OPERATION_FAILED',
+                message: 'One or more operations failed.'
+            })
+        } : {
+            status: 'ok'
+        })))
+    };
+    if (batchResult.status === 'error' || batchResult.status === 'partial') {
+        batchResult.retryPlan = createRetryPlan({
+            atomic,
+            rolledBack,
+            results: batchResult.results,
+            receipts: batchResult.receipts,
+            operationCount: sourceOperations.length
+        });
+    }
+    return batchResult;
+}