@ansonlai/docx-redline-js 0.4.0 → 0.5.0

package/services/operation-preflight.js

@@ -0,0 +1,366 @@
+/**
+ * Read-only preflight for document operation batches.
+ */
+
+import { parseOoxmlSafe } from '../adapters/xml-adapter.js';
+import { getDefaultAuthor } from '../adapters/config.js';
+import { containsTrackedChanges, getTrackedChangeAuthors } from '../core/word-xml.js';
+import { NS_W } from '../core/types.js';
+import { extractCanonicalParagraphText } from '../core/paragraph-text.js';
+import {
+    buildParagraphMetadataIndex,
+    createParagraphFingerprint,
+    findContainingWordElement,
+    getDocumentParagraphNodes,
+    getParagraphId,
+    normalizeWhitespaceForTargeting,
+    resolveTargetParagraph,
+    validateParagraphBoundaryMutation
+} from '../core/paragraph-targeting.js';
+import { createParagraphTextIndex, resolveTextInParagraphIndex } from './comment-locator.js';
+import {
+    normalizeDocumentOperation,
+    resolveDocumentOperationAuthor,
+    validateDocumentOperation
+} from './document-operation-contract.js';
+import { buildOperationDependencyPlan } from './batch-operation-orchestrator.js';
+
+function normalizedError(error) {
+    return {
+        code: typeof error?.code === 'string' && error.code ? error.code : 'OPERATION_ERROR',
+        message: error?.message || String(error),
+        ...(Array.isArray(error?.candidates) ? { candidates: error.candidates } : {})
+    };
+}
+
+function operationNeedsNumbering(operation) {
+    if (operation.operationKind !== 'redline' || typeof operation.modified !== 'string') return false;
+    return operation.modified.split(/\r?\n/).some(line => /^\s*(?:[-+*]|\d+[.)])\s+/.test(line));
+}
+
+function targetMetadata(xmlDoc, paragraph, resolvedBy, suppliedText, paragraphMetadataIndex = null, revisionView = 'accepted') {
+    const cached = paragraphMetadataIndex?.byParagraph?.get(paragraph) || null;
+    const paragraphs = cached ? null : getDocumentParagraphNodes(xmlDoc);
+    const actualText = cached?.text ?? extractCanonicalParagraphText(paragraph, { revisionView });
+    const normalizedSupplied = normalizeWhitespaceForTargeting(suppliedText || '');
+    const normalizedActual = normalizeWhitespaceForTargeting(actualText);
+    return {
+        resolvedBy,
+        resolvedTarget: {
+            index: cached?.index ?? paragraphs.indexOf(paragraph) + 1,
+            paragraphId: cached?.paragraphId ?? getParagraphId(paragraph),
+            text: actualText,
+            fingerprint: cached?.fingerprint ?? createParagraphFingerprint(paragraph, { text: actualText, revisionView }),
+            inTable: cached?.inTable ?? !!findContainingWordElement(paragraph, 'tbl'),
+            revisionView
+        },
+        matchDiagnostics: {
+            exactTextMatch: typeof suppliedText === 'string' && suppliedText === actualText,
+            normalizedTextMatch: !!normalizedSupplied && normalizedSupplied === normalizedActual,
+            suppliedText: suppliedText || '',
+            actualText,
+            revisionView
+        }
+    };
+}
+
+function buildConflict(code, message, operationIndexes, target) {
+    return { code, message, operationIndexes, target };
+}
+
+function getCommentIdsInParagraph(paragraph) {
+    const ids = new Set();
+    for (const localName of ['commentRangeStart', 'commentRangeEnd', 'commentReference']) {
+        for (const node of Array.from(paragraph?.getElementsByTagNameNS?.('*', localName) || [])) {
+            const id = node.getAttribute('w:id') || node.getAttribute('id');
+            if (id !== '') ids.add(id);
+        }
+    }
+    return Array.from(ids).sort((a, b) => Number(a) - Number(b) || a.localeCompare(b));
+}
+
+export function preflightOperations(documentXml, operations, author, options = {}) {
+    const parsed = parseOoxmlSafe(documentXml, 'application/xml');
+    if (parsed.error || !parsed.doc) {
+        return {
+            valid: false,
+            status: 'error',
+            error: parsed.error,
+            results: [],
+            conflicts: [],
+            authorsUsed: [],
+            requiredArtifacts: { comments: false, numbering: false }
+        };
+    }
+
+    const xmlDoc = parsed.doc;
+    const metadataIndices = {
+        accepted: buildParagraphMetadataIndex(xmlDoc, { revisionView: 'accepted' }),
+        rejected: null
+    };
+    const sourceOperations = Array.isArray(operations) ? operations : [];
+    const dependencyPlan = buildOperationDependencyPlan(sourceOperations);
+    if (!dependencyPlan.valid) {
+        return {
+            valid: false,
+            status: 'error',
+            error: dependencyPlan.error,
+            results: [],
+            conflicts: [],
+            authorsUsed: [],
+            requiredArtifacts: { comments: false, numbering: false }
+        };
+    }
+
+    const strictTargets = options.strictTargets !== false;
+    const results = [];
+    const authorsUsed = new Set();
+    let commentsRequired = false;
+    let numberingRequired = false;
+
+    for (let index = 0; index < sourceOperations.length; index++) {
+        const sourceOperation = sourceOperations[index];
+        const validation = validateDocumentOperation(sourceOperation);
+        const fallbackOperation = normalizeDocumentOperation(sourceOperation);
+        const operation = validation.operation || fallbackOperation;
+        const authorUsed = resolveDocumentOperationAuthor(operation, author, getDefaultAuthor());
+        authorsUsed.add(authorUsed);
+
+        if (!validation.valid) {
+            results.push({
+                index: index + 1,
+                type: sourceOperation?.type || 'redline',
+                operationType: operation.operationKind,
+                status: 'error',
+                authorUsed,
+                error: validation.error
+            });
+            continue;
+        }
+
+        commentsRequired = commentsRequired || operation.operationKind === 'comment' || operation.operationKind === 'comment_reply';
+        numberingRequired = numberingRequired || operationNeedsNumbering(operation);
+
+        if (operation.operationKind === 'comment_reply') {
+            const parentId = String(operation.parentCommentId);
+            const parent = options._existingCommentDetails?.[parentId];
+            results.push(parent ? {
+                index: index + 1, type: sourceOperation.type, operationType: operation.operationKind,
+                status: 'ready', authorUsed, resolvedBy: 'parent_comment', parentCommentId: parentId
+            } : {
+                index: index + 1, type: sourceOperation.type, operationType: operation.operationKind,
+                status: 'error', authorUsed,
+                error: { code: 'PARENT_COMMENT_NOT_FOUND', message: `Parent comment '${parentId}' was not found.` }
+            });
+            continue;
+        }
+
+        if (operation.targetDescriptor?.captureRef) {
+            results.push({
+                index: index + 1,
+                type: sourceOperation?.type || 'redline',
+                operationType: operation.operationKind,
+                status: 'deferred',
+                authorUsed,
+                resolvedBy: 'capture',
+                captureRef: operation.targetDescriptor.captureRef,
+                ...(operation.targetDescriptor.select ? { select: operation.targetDescriptor.select } : {})
+            });
+            continue;
+        }
+
+        const targetView = operation.targetDescriptor?.revisionView === 'rejected' ? 'rejected' : 'accepted';
+        let currentMetadataIndex = targetView === 'rejected'
+            ? (metadataIndices.rejected || (metadataIndices.rejected = buildParagraphMetadataIndex(xmlDoc, { revisionView: 'rejected' })))
+            : metadataIndices.accepted;
+
+        try {
+            const resolved = resolveTargetParagraph(xmlDoc, {
+                targetText: operation.target,
+                targetRef: operation.targetRef,
+                targetDescriptor: operation.targetDescriptor,
+                opType: operation.operationKind,
+                strictAmbiguity: strictTargets,
+                paragraphMetadataIndex: currentMetadataIndex,
+                metadataIndices,
+                onInfo: options.onInfo,
+                onWarn: options.onWarn
+            });
+            const paragraph = resolved.paragraph;
+            const metadata = targetMetadata(xmlDoc, paragraph, resolved.resolvedBy, operation.target, currentMetadataIndex, targetView);
+            const paragraphText = metadata.resolvedTarget.text;
+            const anchor = operation.operationKind === 'comment'
+                ? (operation.textToComment || paragraphText)
+                : (operation.operationKind === 'highlight'
+                    ? operation.textToHighlight
+                    : (operation.operationKind === 'format' ? operation.textToFormat : null));
+            const anchorResolution = operation.operationKind === 'comment' && anchor != null
+                ? resolveTextInParagraphIndex(createParagraphTextIndex(paragraph, { revisionView: targetView }), anchor)
+                : null;
+            const anchorFound = anchor == null
+                || (anchorResolution ? anchorResolution.found : paragraphText.includes(anchor));
+            const hasRevisions = containsTrackedChanges(paragraph);
+            const existingPolicy = operation.existingRevisions
+                || options.existingRevisions
+                || 'merge-same-author';
+            const deletingWholeParagraph = operation.operationKind === 'redline' && operation.modified === '';
+            const commentIds = deletingWholeParagraph ? getCommentIdsInParagraph(paragraph) : [];
+
+            let error = null;
+            if (!anchorFound) {
+                error = anchorResolution?.error || {
+                    code: 'ANCHOR_NOT_FOUND',
+                    message: `Anchor text was not found in target paragraph: "${anchor}".`
+                };
+            } else if (commentIds.length > 0) {
+                const comments = commentIds
+                    .map(id => options._existingCommentDetails?.[id])
+                    .filter(Boolean);
+                error = {
+                    code: 'COMMENTED_CONTENT_DELETE',
+                    message: 'Refusing to delete a paragraph with existing comments. Resolve or explicitly remove the comments before deleting the paragraph.',
+                    commentIds,
+                    ...(comments.length > 0 ? { comments } : {})
+                };
+            } else if (
+                operation.operationKind === 'redline'
+                && hasRevisions
+                && existingPolicy !== 'accept-all-first'
+                && existingPolicy !== 'accept-all-first-keep-normalized'
+            ) {
+                if (existingPolicy === 'merge-same-author') {
+                    const authors = getTrackedChangeAuthors(paragraph);
+                    const opAuthor = String(authorUsed || '').trim().toLowerCase();
+                    const allSame = authors.length > 0 && authors.every(a => a.trim().toLowerCase() === opAuthor);
+                    if (!allSame) {
+                        error = {
+                            code: 'EXISTING_REVISIONS',
+                            message: `Target paragraph contains tracked changes from another author (${authors.length ? authors.join(', ') : 'unattributed'}). Pass existingRevisions: "accept-all-first" or resolve revisions first.`
+                        };
+                    } else {
+                        const mergeCommentIds = getCommentIdsInParagraph(paragraph);
+                        if (mergeCommentIds.length > 0) {
+                            const comments = mergeCommentIds
+                                .map(id => options._existingCommentDetails?.[id])
+                                .filter(Boolean);
+                            error = {
+                                code: 'COMMENTED_CONTENT_MERGE',
+                                message: 'Refusing to merge existing revisions in commented content because reverting the prior revisions could remove or orphan comment anchors.',
+                                commentIds: mergeCommentIds,
+                                ...(comments.length > 0 ? { comments } : {})
+                            };
+                        }
+                    }
+                } else {
+                    const hasDel = paragraph.getElementsByTagNameNS(NS_W, 'del').length > 0;
+                    const hasMove = paragraph.getElementsByTagNameNS(NS_W, 'moveFrom').length > 0
+                        || paragraph.getElementsByTagNameNS(NS_W, 'moveTo').length > 0;
+                    if (hasDel) {
+                        error = {
+                            code: 'UNSAFE_REVISION_NESTING',
+                            message: 'Refusing to replace content with pending deletions; nesting revisions is unsafe.'
+                        };
+                    } else if (hasMove) {
+                        error = {
+                            code: 'UNSAFE_REVISION_NESTING',
+                            message: 'Refusing to mutate content with move revisions until move lifecycle is designed.'
+                        };
+                    } else {
+                        error = {
+                            code: 'EXISTING_REVISIONS',
+                            message: 'Target paragraph contains tracked changes and existingRevisions is "reject-input".'
+                        };
+                    }
+                }
+            }
+
+            if (!error && operation.operationKind === 'redline') {
+                const boundaryCheck = validateParagraphBoundaryMutation(paragraph, operation.modified, options);
+                if (!boundaryCheck.valid) {
+                    error = {
+                        code: boundaryCheck.code,
+                        message: boundaryCheck.message
+                    };
+                }
+            }
+
+            results.push({
+                index: index + 1,
+                type: sourceOperation?.type || 'redline',
+                operationType: operation.operationKind,
+                status: error ? 'error' : 'ready',
+                authorUsed,
+                ...metadata,
+                anchor: anchor == null ? null : {
+                    text: anchor,
+                    found: anchorFound,
+                    ...(anchorResolution?.found ? {
+                        resolvedBy: anchorResolution.resolvedBy,
+                        start: anchorResolution.start,
+                        end: anchorResolution.end
+                    } : {}),
+                    ...(!anchorResolution?.found && Array.isArray(anchorResolution?.error?.candidates)
+                        ? { candidates: anchorResolution.error.candidates }
+                        : {})
+                },
+                hasRevisions,
+                existingRevisions: existingPolicy,
+                ...(resolved?.warnings?.length ? { warnings: resolved.warnings } : {}),
+                ...(error ? { error } : {})
+            });
+        } catch (error) {
+            results.push({
+                index: index + 1,
+                type: sourceOperation?.type || 'redline',
+                operationType: operation.operationKind,
+                status: 'error',
+                authorUsed,
+                error: normalizedError(error)
+            });
+        }
+    }
+
+    const conflicts = [];
+    const byTarget = new Map();
+    for (const result of results) {
+        const targetIndex = result.resolvedTarget?.index;
+        if (!targetIndex) continue;
+        if (!byTarget.has(targetIndex)) byTarget.set(targetIndex, []);
+        byTarget.get(targetIndex).push(result);
+    }
+
+    for (const [targetIndex, targetResults] of byTarget) {
+        const redlines = targetResults.filter(result => result.operationType === 'redline');
+        const highlights = targetResults.filter(result => result.operationType === 'highlight');
+        const target = targetResults[0].resolvedTarget;
+        if (redlines.length > 1) {
+            conflicts.push(buildConflict(
+                'OVERLAPPING_TEXT_EDITS',
+                `Multiple text edits target paragraph ${targetIndex}; later operations may use a stale anchor.`,
+                redlines.map(result => result.index),
+                target
+            ));
+        }
+        if (redlines.length > 0 && highlights.length > 0) {
+            conflicts.push(buildConflict(
+                'REVISION_ORDER_CONFLICT',
+                `A text edit and highlight target paragraph ${targetIndex}; operation order can invalidate the target or existing-revision policy.`,
+                [...redlines, ...highlights].map(result => result.index).sort((a, b) => a - b),
+                target
+            ));
+        }
+    }
+
+    const hasErrors = results.some(result => result.status === 'error');
+    return {
+        valid: !hasErrors && conflicts.length === 0,
+        status: !hasErrors && conflicts.length === 0 ? 'ok' : 'error',
+        results,
+        conflicts,
+        authorsUsed: Array.from(authorsUsed),
+        requiredArtifacts: {
+            comments: commentsRequired,
+            numbering: numberingRequired
+        }
+    };
+}

package/services/receipt-collector.js

@@ -0,0 +1,288 @@
+/**
+ * Internal mutation receipt collector for tracking allocated revision,
+ * comment, numbering, and relationship IDs per operation.
+ */
+
+export class ReceiptCollector {
+    constructor() {
+        this.receipts = [];
+        this.activeReceipt = null;
+    }
+
+    beginOperation(operationIndex, operationId = null, authorUsed = null) {
+        this.activeReceipt = {
+            operationIndex: typeof operationIndex === 'number' ? operationIndex : 1,
+            ...(operationId ? { operationId: String(operationId) } : {}),
+            attemptedDisposition: 'applied',
+            finalDisposition: 'applied',
+            committed: true,
+            ...(authorUsed ? { authorUsed: String(authorUsed) } : {}),
+            revisionItems: [],
+            commentIds: [],
+            numberingIds: [],
+            relationshipIds: [],
+            affectedTargets: [],
+            warnings: []
+        };
+    }
+
+    recordRevision(id, kind = 'structural', partName = 'word/document.xml') {
+        if (!this.activeReceipt || id == null) return;
+        const strId = String(id);
+        if (!this.activeReceipt.revisionItems.some(item => item.id === strId && item.kind === kind && item.partName === partName)) {
+            this.activeReceipt.revisionItems.push({
+                id: strId,
+                kind,
+                partName
+            });
+        }
+    }
+
+    recordComment(id, _partName = 'word/comments.xml') {
+        if (!this.activeReceipt || id == null) return;
+        const strId = String(id);
+        if (!this.activeReceipt.commentIds.includes(strId)) {
+            this.activeReceipt.commentIds.push(strId);
+        }
+    }
+
+    recordNumbering(id, _partName = 'word/numbering.xml') {
+        if (!this.activeReceipt || id == null) return;
+        const strId = String(id);
+        if (!this.activeReceipt.numberingIds.includes(strId)) {
+            this.activeReceipt.numberingIds.push(strId);
+        }
+    }
+
+    recordRelationship(id, _partName = 'word/_rels/document.xml.rels') {
+        if (!this.activeReceipt || id == null) return;
+        const strId = String(id);
+        if (!this.activeReceipt.relationshipIds.includes(strId)) {
+            this.activeReceipt.relationshipIds.push(strId);
+        }
+    }
+
+    recordAffectedTarget(target) {
+        if (!this.activeReceipt || !target) return;
+        this.activeReceipt.affectedTargets.push(JSON.parse(JSON.stringify(target)));
+    }
+
+    recordWarning(warning) {
+        if (!this.activeReceipt || !warning) return;
+        this.activeReceipt.warnings.push(String(warning));
+    }
+
+    commitOperation(disposition = 'applied') {
+        if (!this.activeReceipt) return null;
+        this.activeReceipt.attemptedDisposition = disposition;
+        this.activeReceipt.finalDisposition = disposition;
+        this.activeReceipt.committed = disposition === 'applied';
+        const committed = JSON.parse(JSON.stringify(this.activeReceipt));
+        this.receipts.push(committed);
+        this.activeReceipt = null;
+        return committed;
+    }
+
+    abortOperation(disposition = 'refused') {
+        if (!this.activeReceipt) return null;
+        this.activeReceipt.attemptedDisposition = disposition;
+        this.activeReceipt.finalDisposition = disposition;
+        this.activeReceipt.committed = false;
+        const aborted = JSON.parse(JSON.stringify(this.activeReceipt));
+        this.activeReceipt = null;
+        return aborted;
+    }
+
+    createSavepoint() {
+        return {
+            receipts: JSON.parse(JSON.stringify(this.receipts)),
+            activeReceipt: this.activeReceipt ? JSON.parse(JSON.stringify(this.activeReceipt)) : null
+        };
+    }
+
+    restoreSavepoint(savepoint) {
+        if (!savepoint) return;
+        this.receipts = Array.isArray(savepoint.receipts)
+            ? JSON.parse(JSON.stringify(savepoint.receipts))
+            : [];
+        this.activeReceipt = savepoint.activeReceipt
+            ? JSON.parse(JSON.stringify(savepoint.activeReceipt))
+            : null;
+    }
+
+    clear() {
+        this.receipts = [];
+        this.activeReceipt = null;
+    }
+
+    markRolledBack() {
+        for (const receipt of this.receipts) {
+            if (receipt.attemptedDisposition === 'applied') {
+                receipt.finalDisposition = 'rolled_back';
+                receipt.committed = false;
+            }
+        }
+        this.activeReceipt = null;
+    }
+
+    getReceipts() {
+        return JSON.parse(JSON.stringify(this.receipts));
+    }
+
+    getCurrentReceipt() {
+        return this.activeReceipt ? JSON.parse(JSON.stringify(this.activeReceipt)) : null;
+    }
+}
+
+/**
+ * Creates an empty receipt structure for unattempted, refused, or no-op operations.
+ *
+ * @param {number} operationIndex
+ * @param {string|null} [operationId]
+ * @param {string|null} [authorUsed]
+ * @param {'applied'|'no_change'|'refused'|'not_attempted'} [disposition]
+ * @returns {Object}
+ */
+export function createEmptyReceipt(operationIndex, operationId = null, authorUsed = null, disposition = 'not_attempted') {
+    return {
+        operationIndex: typeof operationIndex === 'number' ? operationIndex : 1,
+        ...(operationId ? { operationId: String(operationId) } : {}),
+        attemptedDisposition: disposition,
+        finalDisposition: disposition,
+        committed: false,
+        ...(authorUsed ? { authorUsed: String(authorUsed) } : {}),
+        revisionItems: [],
+        commentIds: [],
+        numberingIds: [],
+        relationshipIds: [],
+        affectedTargets: [],
+        warnings: []
+    };
+}
+
+/**
+ * Reconciles committed mutation receipts against the generated/committed output parts.
+ *
+ * @param {Object} parts
+ * @param {string} parts.documentXml - Serialized word/document.xml
+ * @param {string|null} [parts.commentsXml] - Serialized word/comments.xml
+ * @param {string|null} [parts.numberingXml] - Serialized word/numbering.xml
+ * @param {string[]} [parts.numberingXmlParts] - Additional numbering XML parts
+ * @param {string|null} [parts.relationshipsXml] - Serialized word/_rels/document.xml.rels
+ * @param {Array<Object>} receipts - Array of MutationReceipt objects
+ * @returns {{ valid: boolean, error?: { code: string, message: string } }}
+ */
+export function reconcileReceiptsAgainstOutput(parts, receipts) {
+    if (!Array.isArray(receipts) || receipts.length === 0) {
+        return { valid: true };
+    }
+
+    const committedReceipts = receipts.filter(r => r && r.committed === true && r.finalDisposition === 'applied');
+    if (committedReceipts.length === 0) {
+        return { valid: true };
+    }
+
+    const revisionIdSet = new Set();
+    if (parts?.documentXml && typeof parts.documentXml === 'string') {
+        const revRegex = /<(?:w:)?(?:ins|del|rPrChange|pPrChange|moveFrom|moveTo)\b[^>]*?\b(?:w:)?id="([^"]+)"/g;
+        let m;
+        while ((m = revRegex.exec(parts.documentXml)) !== null) {
+            revisionIdSet.add(m[1]);
+        }
+    }
+
+    const commentIdSet = new Set();
+    if (parts?.commentsXml && typeof parts.commentsXml === 'string') {
+        const comRegex = /<(?:w:)?comment\b[^>]*?\b(?:w:)?id="([^"]+)"/g;
+        let m;
+        while ((m = comRegex.exec(parts.commentsXml)) !== null) {
+            commentIdSet.add(m[1]);
+        }
+    }
+
+    const numberingIdSet = new Set();
+    const combinedNumbering = [parts?.numberingXml, ...(parts?.numberingXmlParts || [])].filter(Boolean).join('\n');
+    if (combinedNumbering) {
+        const numRegex = /<(?:w:)?num\b[^>]*?\b(?:w:)?numId="([^"]+)"/g;
+        let m;
+        while ((m = numRegex.exec(combinedNumbering)) !== null) {
+            numberingIdSet.add(m[1]);
+        }
+    }
+    if (parts?.documentXml && typeof parts.documentXml === 'string') {
+        const docNumRegex = /<(?:w:)?numId\b[^>]*?\b(?:w:)?val="([^"]+)"/g;
+        let m;
+        while ((m = docNumRegex.exec(parts.documentXml)) !== null) {
+            numberingIdSet.add(m[1]);
+        }
+    }
+
+    const relIdSet = new Set();
+    if (parts?.relationshipsXml && typeof parts.relationshipsXml === 'string') {
+        const relRegex = /<Relationship\b[^>]*?\bId="([^"]+)"/g;
+        let m;
+        while ((m = relRegex.exec(parts.relationshipsXml)) !== null) {
+            relIdSet.add(m[1]);
+        }
+    }
+
+    for (const receipt of committedReceipts) {
+        if (Array.isArray(receipt.revisionItems)) {
+            for (const item of receipt.revisionItems) {
+                if (item.partName === 'word/document.xml' && !revisionIdSet.has(String(item.id))) {
+                    return {
+                        valid: false,
+                        error: {
+                            code: 'RECEIPT_RECONCILIATION_FAILED',
+                            message: `Committed revision id '${item.id}' (kind: ${item.kind}) was not found in word/document.xml.`
+                        }
+                    };
+                }
+            }
+        }
+
+        if (Array.isArray(receipt.commentIds)) {
+            for (const id of receipt.commentIds) {
+                if (!commentIdSet.has(String(id))) {
+                    return {
+                        valid: false,
+                        error: {
+                            code: 'RECEIPT_RECONCILIATION_FAILED',
+                            message: `Committed comment id '${id}' was not found in word/comments.xml.`
+                        }
+                    };
+                }
+            }
+        }
+
+        if (Array.isArray(receipt.numberingIds)) {
+            for (const id of receipt.numberingIds) {
+                if (!numberingIdSet.has(String(id))) {
+                    return {
+                        valid: false,
+                        error: {
+                            code: 'RECEIPT_RECONCILIATION_FAILED',
+                            message: `Committed numbering id '${id}' was not found in numbering parts or document.`
+                        }
+                    };
+                }
+            }
+        }
+
+        if (parts?.relationshipsXml && Array.isArray(receipt.relationshipIds)) {
+            for (const id of receipt.relationshipIds) {
+                if (!relIdSet.has(String(id))) {
+                    return {
+                        valid: false,
+                        error: {
+                            code: 'RECEIPT_RECONCILIATION_FAILED',
+                            message: `Committed relationship id '${id}' was not found in document.xml.rels.`
+                        }
+                    };
+                }
+            }
+        }
+    }
+
+    return { valid: true };
+}