@ansonlai/docx-redline-js 0.5.3 → 0.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ansonlai/docx-redline-js",
-  "version": "0.5.3",
+  "version": "0.6.0",
   "description": "Host-independent OOXML reconciliation engine for .docx manipulation with track changes",
   "license": "MIT",
   "type": "module",
@@ -44,7 +44,13 @@
     "bin/",
     "orchestration/",
     "scripts/",
-    "docs/",
+    "!scripts/benchmark-agent-workflow.mjs",
+    "!scripts/lib/agent-performance-cases.mjs",
+    "docs/AGENT_FAST_START.md",
+    "docs/AGENT_KNOWLEDGE_BASE.md",
+    "docs/TESTING.md",
+    "docs/schemas/document-operations.schema.json",
+    "docs/validation-reports/2026-09-12-agent-protocol-rollout.md",
     "index.js",
     "index.d.ts",
     "dist/",
@@ -77,10 +83,11 @@
   "scripts": {
     "build": "node scripts/build.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",
+    "lint": "eslint index.js adapters core engine pipeline services orchestration scripts examples 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",
     "benchmark:session": "node scripts/benchmark-operation-session.mjs",
+    "benchmark:agent": "node scripts/benchmark-agent-workflow.mjs",
     "benchmark:targeting": "node scripts/benchmark-targeting-hot-paths.mjs",
     "benchmark:tests": "node scripts/benchmark-test-runner.mjs",
     "profile:routes": "node scripts/profile-route-selection.mjs",

package/pipeline/diff-engine.js

@@ -232,6 +232,21 @@ export function computeWordDiffs(originalText, newText, options = {}) {
     return decodeBmpDiffs(charDiffs, wordArray);
 }
 
+/**
+ * Computes a character-local diff without semantic cleanup. This is used to
+ * refine whitespace-only substitutions that a word-level token groups with
+ * adjacent unchanged content (for example, an NBSP beside a hyperlink).
+ *
+ * @param {string} originalText
+ * @param {string} newText
+ * @param {{ diffTimeoutSeconds?: number }} [options={}]
+ * @returns {Array<[number, string]>}
+ */
+export function computeCharacterDiffs(originalText, newText, options = {}) {
+    if (originalText === newText) return [[0, originalText]];
+    return createDiffEngine(options).diff_main(originalText, newText);
+}
+
 /**
  * Returns a character-local diff only when the modified string can be made
  * solely by inserting into the original. This prevents word-token cleanup

package/scripts/generate-cross-author-slicing-fixtures.ps1

@@ -76,7 +76,7 @@ try {
 
     # -------------------------------------------------------------------------
     # Scenario 1: insert-interior
-    # Author A (Barry) inserts: "amended by this Agreement."
+    # Author A (John) inserts: "amended by this Agreement."
     # Author B (Anson) inserts "MASTER " before "Agreement"
     # -------------------------------------------------------------------------
     Write-Host "1. insert-interior"
@@ -85,8 +85,8 @@ try {
     $doc.Range(0, 0).Text = "Contract terms "
     
     # Author A insertion
-    $global:word.UserName = "Barry Plasteras"
-    $global:word.UserInitials = "BP"
+    $global:word.UserName = "John Doe"
+    $global:word.UserInitials = "JD"
     $doc.TrackRevisions = $true
     $endR = $doc.Range($doc.Content.End - 1, $doc.Content.End - 1)
     $endR.Text = "amended by this Agreement."
@@ -103,7 +103,7 @@ try {
 
     # -------------------------------------------------------------------------
     # Scenario 2: delete-interior
-    # Author A (Barry) inserts: "The Services will process the Input to generate outputs for Customer."
+    # Author A (John) inserts: "The Platform will process the Data to generate deliverables for Client."
     # Author B (Anson) deletes: "generate "
     # -------------------------------------------------------------------------
     Write-Host "2. delete-interior"
@@ -112,11 +112,11 @@ try {
     $doc.Range(0, 0).Text = "Background. "
     
     # Author A insertion
-    $global:word.UserName = "Barry Plasteras"
-    $global:word.UserInitials = "BP"
+    $global:word.UserName = "John Doe"
+    $global:word.UserInitials = "JD"
     $doc.TrackRevisions = $true
     $endR = $doc.Range($doc.Content.End - 1, $doc.Content.End - 1)
-    $endR.Text = "The Services will process the Input to generate outputs for Customer."
+    $endR.Text = "The Platform will process the Data to generate deliverables for Client."
     
     # Author B deletion inside Author A's insertion
     $global:word.UserName = "Anson Lai"
@@ -129,8 +129,8 @@ try {
 
     # -------------------------------------------------------------------------
     # Scenario 3: delete-boundary-start
-    # Author A (Barry) inserts: "Notwithstanding the foregoing, the NDA remains in effect."
-    # Author B (Anson) deletes: "Notwithstanding the foregoing, "
+    # Author A (John) inserts: "Notwithstanding anything to the contrary, the confidentiality terms remain in effect."
+    # Author B (Anson) deletes: "Notwithstanding anything to the contrary, "
     # -------------------------------------------------------------------------
     Write-Host "3. delete-boundary-start"
     $doc = $global:word.Documents.Add()
@@ -138,16 +138,16 @@ try {
     $doc.Range(0, 0).Text = "Section 1. "
     
     # Author A insertion
-    $global:word.UserName = "Barry Plasteras"
-    $global:word.UserInitials = "BP"
+    $global:word.UserName = "John Doe"
+    $global:word.UserInitials = "JD"
     $doc.TrackRevisions = $true
     $endR = $doc.Range($doc.Content.End - 1, $doc.Content.End - 1)
-    $endR.Text = "Notwithstanding the foregoing, the NDA remains in effect."
+    $endR.Text = "Notwithstanding anything to the contrary, the confidentiality terms remain in effect."
     
     # Author B deletion at start of insertion
     $global:word.UserName = "Anson Lai"
     $global:word.UserInitials = "AL"
-    $delWord = "Notwithstanding the foregoing, "
+    $delWord = "Notwithstanding anything to the contrary, "
     $foundPos = Find-RequiredText $doc $delWord "delete-boundary-start"
     $delRange = $doc.Range($foundPos, $foundPos + $delWord.Length)
     $delRange.Delete() | Out-Null
@@ -155,8 +155,8 @@ try {
 
     # -------------------------------------------------------------------------
     # Scenario 4: delete-boundary-end
-    # Author A (Barry) inserts: "subject to Section 2.8 and applicable law."
-    # Author B (Anson) deletes: " and applicable law."
+    # Author A (John) inserts: "subject to Section 4.2 and applicable standards."
+    # Author B (Anson) deletes: " and applicable standards."
     # -------------------------------------------------------------------------
     Write-Host "4. delete-boundary-end"
     $doc = $global:word.Documents.Add()
@@ -164,16 +164,16 @@ try {
     $doc.Range(0, 0).Text = "Compliance: "
     
     # Author A insertion
-    $global:word.UserName = "Barry Plasteras"
-    $global:word.UserInitials = "BP"
+    $global:word.UserName = "John Doe"
+    $global:word.UserInitials = "JD"
     $doc.TrackRevisions = $true
     $endR = $doc.Range($doc.Content.End - 1, $doc.Content.End - 1)
-    $endR.Text = "subject to Section 2.8 and applicable law."
+    $endR.Text = "subject to Section 4.2 and applicable standards."
     
     # Author B deletion at end of insertion
     $global:word.UserName = "Anson Lai"
     $global:word.UserInitials = "AL"
-    $delWord = " and applicable law."
+    $delWord = " and applicable standards."
     $foundPos = Find-RequiredText $doc $delWord "delete-boundary-end"
     $delRange = $doc.Range($foundPos, $foundPos + $delWord.Length)
     $delRange.Delete() | Out-Null
@@ -182,7 +182,7 @@ try {
     # -------------------------------------------------------------------------
     # Scenario 5: delete-straddle-baseline-insertion
     # Baseline: "Baseline start "
-    # Author A (Barry) inserts: "inserted finish."
+    # Author A (John) inserts: "inserted finish."
     # Author B (Anson) deletes: "start inserted" (straddling baseline and insertion)
     # -------------------------------------------------------------------------
     Write-Host "5. delete-straddle-baseline-insertion"
@@ -191,8 +191,8 @@ try {
     $doc.Range(0, 0).Text = "Baseline start "
     
     # Author A insertion
-    $global:word.UserName = "Barry Plasteras"
-    $global:word.UserInitials = "BP"
+    $global:word.UserName = "John Doe"
+    $global:word.UserInitials = "JD"
     $doc.TrackRevisions = $true
     $endR = $doc.Range($doc.Content.End - 1, $doc.Content.End - 1)
     $endR.Text = "inserted finish."
@@ -209,7 +209,7 @@ try {
     # -------------------------------------------------------------------------
     # Scenario 6: multi-author-stacked
     # Baseline: "Provision "
-    # Author A (Barry) inserts: "first draft of the proposal with initial metrics."
+    # Author A (John) inserts: "first draft of the proposal with initial metrics."
     # Author B (Anson) deletes: "of the proposal "
     # Author C (Chris) deletes: "initial " from the remaining text
     # -------------------------------------------------------------------------
@@ -219,8 +219,8 @@ try {
     $doc.Range(0, 0).Text = "Provision "
     
     # Author A insertion
-    $global:word.UserName = "Barry Plasteras"
-    $global:word.UserInitials = "BP"
+    $global:word.UserName = "John Doe"
+    $global:word.UserInitials = "JD"
     $doc.TrackRevisions = $true
     $endR = $doc.Range($doc.Content.End - 1, $doc.Content.End - 1)
     $endR.Text = "first draft of the proposal with initial metrics."

package/services/batch-operation-orchestrator.js

@@ -19,10 +19,12 @@ import {
     computeDocumentPartsRevisionToken,
     areRevisionTokensEqual
 } from './revision-token.js';
-import {
-    createEmptyReceipt,
-    reconcileReceiptsAgainstOutput
-} from './receipt-collector.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';
 
@@ -70,9 +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 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];
@@ -107,13 +110,40 @@ export function buildOperationDependencyPlan(operations = []) {
                     }
                 };
             }
-            if (!dependencies[i].has(producerIndex)) {
-                dependencies[i].add(producerIndex);
-                dependents[producerIndex].add(i);
-                inDegrees[i]++;
-            }
-        }
-    }
+            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
+            }
+        };
+    }
 
     // 3. Stable topological sort with comment priority among ready nodes
     const ready = [];
@@ -191,62 +221,56 @@ export async function applyOperationsToDocumentXml(documentXml, operations, auth
         i + 1,
         op?.operationId,
         resolveDocumentOperationAuthor(op, author, defaultAuthor),
-        'not_attempted'
+        'not_attempted'
     ));
-
-    if (options.existingRevisions != null && !isExistingRevisionsPolicy(options.existingRevisions)) {
+    const failedBeforeExecution = (error, extra = {}) => {
+        const receipts = emptyReceipts();
         return {
             documentXml,
             hasChanges: false,
             commentsXml: null,
             numberingXmlParts: [],
             results: [],
-            receipts: emptyReceipts(),
+            receipts,
             executionOrder: [],
             authorsUsed: [],
+            ...(options.atomic === true ? { rolledBack: true } : {}),
             status: 'error',
-            error: {
-                code: 'INVALID_OPERATION',
-                message: `Unsupported existingRevisions policy: "${String(options.existingRevisions)}".`
-            }
+            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 {
-                documentXml,
-                hasChanges: false,
-                commentsXml: null,
-                numberingXmlParts: [],
-                results: [],
-                receipts: emptyReceipts(),
-                executionOrder: [],
-                authorsUsed: [],
-                status: 'error',
-                error: {
-                    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 {
-                documentXml,
-                hasChanges: false,
-                commentsXml: null,
-                numberingXmlParts: [],
-                results: [],
-                receipts: emptyReceipts(),
-                executionOrder: [],
-                authorsUsed: [],
-                status: 'error',
-                error: {
-                    code: 'REVISION_TOKEN_SCOPE_MISMATCH',
-                    message: `Revision token scope mismatch: expected 'document-parts', got '${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,
@@ -256,21 +280,12 @@ export async function applyOperationsToDocumentXml(documentXml, operations, auth
             stylesXml: runtimeContext?.stylesXml || options.stylesXml
         }, options);
         if (!areRevisionTokensEqual(currentToken.value, options.expectedRevision.value)) {
-            return {
-                documentXml,
-                hasChanges: false,
-                commentsXml: null,
-                numberingXmlParts: [],
-                results: [],
-                receipts: emptyReceipts(),
-                executionOrder: [],
-                authorsUsed: [],
-                status: 'error',
-                error: {
-                    code: 'REVISION_MISMATCH',
-                    message: `Document revision mismatch: expected '${options.expectedRevision.value}', current is '${currentToken.value}'.`
-                }
-            };
+            return failedBeforeExecution({
+                code: 'REVISION_MISMATCH',
+                message: `Document revision mismatch: expected '${options.expectedRevision.value}', current is '${currentToken.value}'.`,
+                expectedRevision: options.expectedRevision,
+                currentRevision: currentToken
+            });
         }
     }
 
@@ -281,34 +296,73 @@ export async function applyOperationsToDocumentXml(documentXml, operations, auth
             _deferDocumentSerialization: true
         });
     if (!session.valid) {
-        return {
-            documentXml,
-            hasChanges: false,
-            commentsXml: null,
-            numberingXmlParts: [],
-            results: [],
-            receipts: emptyReceipts(),
-            executionOrder: [],
-            authorsUsed: [],
-            status: 'error',
-            error: session.parseResult.error,
-            warnings: session.parseResult.warnings
-        };
+        return failedBeforeExecution(session.parseResult.error, { warnings: session.parseResult.warnings });
     }
-    const dependencyPlan = buildOperationDependencyPlan(sourceOperations);
+    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);
     if (!dependencyPlan.valid) {
-        return {
-            documentXml,
-            hasChanges: false,
-            commentsXml: null,
-            numberingXmlParts: [],
-            results: [],
-            receipts: emptyReceipts(),
-            executionOrder: [],
-            authorsUsed: [],
-            status: 'error',
-            error: dependencyPlan.error
-        };
+        return failedBeforeExecution(dependencyPlan.error);
     }
     const scheduled = dependencyPlan.scheduled;
 
@@ -332,9 +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);
-        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,
@@ -374,8 +456,11 @@ export async function applyOperationsToDocumentXml(documentXml, operations, auth
                 ...(result.receipt ? { receipt: result.receipt } : {})
             });
             if (isError && !continueOnError) break;
-        } catch (error) {
-            const normalizedError = normalizeOperationError(error);
+        } 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(
@@ -476,8 +561,8 @@ export async function applyOperationsToDocumentXml(documentXml, operations, auth
 
     if (!rolledBack) commitBatchRuntimeContext(runtimeContext, context);
 
-    return {
-        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,
@@ -491,23 +576,33 @@ export async function applyOperationsToDocumentXml(documentXml, operations, auth
         ...(rolledBack ? {
             rolledBack: true,
             status: 'error',
-            error: {
-                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: reconciliationError
-        } : (operationFailed ? {
-            status: hasChanges ? 'partial' : 'error',
-            error: {
-                code: 'BATCH_OPERATION_FAILED',
-                message: 'One or more operations failed.'
-            }
-        } : {
-            status: 'ok'
-        })))
-    };
-}
+            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;
+}

package/services/document-inspection.js

@@ -199,9 +199,10 @@ export function inspectDocumentParts(parts, options = {}) {
     const resolveNumbering = createNumberingResolver(numberingPart.doc);
     let nearestHeading = null;
     const paragraphNodes = getDocumentParagraphNodes(documentPart.doc);
-    const commentAnchors = collectDocumentCommentAnchors(paragraphNodes, options.revisionView || 'accepted');
+    const revisionView = options.revisionView === 'rejected' ? 'rejected' : 'accepted';
+    const commentAnchors = collectDocumentCommentAnchors(paragraphNodes, revisionView);
     let paragraphs = paragraphNodes.map((paragraph, zeroIndex) => {
-        const text = extractCanonicalParagraphText(paragraph, { revisionView: options.revisionView || 'accepted' });
+        const text = extractCanonicalParagraphText(paragraph, { revisionView });
         const level = headingLevel(paragraph);
         if (level) nearestHeading = { level, text };
         const ids = [...new Set([...descendants(paragraph, 'commentRangeStart'), ...descendants(paragraph, 'commentReference')].map(node => attr(node, 'id')).filter(Boolean))];
@@ -215,7 +216,8 @@ export function inspectDocumentParts(parts, options = {}) {
         const humanReference = [provision, headingText, text.slice(0, options.excerptLength || 120)].filter(Boolean).join(' — ');
         const segments = extractParagraphRevisionSegments(paragraph);
         return {
-            index, ref: `P${index}`, paragraphId: getParagraphId(paragraph), fingerprint: createParagraphFingerprint(paragraph),
+            index, ref: `P${index}`, paragraphId: getParagraphId(paragraph),
+            fingerprint: createParagraphFingerprint(paragraph, { text, index, revisionView }), revisionView,
             text, exactText: text, excerpt: text.slice(0, options.excerptLength || 120), humanReference, inTable: hasAncestor(paragraph, 'tc'), table: structure.table,
             styleId, headingLevel: level, nearestHeading, list, structuralReferences: structure.references, hasRevisions: authors.length > 0, revisionAuthors: authors, commentIds: ids,
             segments