@ansonlai/docx-redline-js 0.5.3 → 0.6.0

package/services/error-recovery.js

@@ -0,0 +1,174 @@
+export const ERROR_RECOVERY_VERSION = 1;
+
+const RULES = Object.freeze({
+    INVALID_OPERATION: ['request', 'request_fixable', 'change_request'],
+    INVALID_AGENT_REQUEST: ['request', 'request_fixable', 'change_request'],
+    INVALID_FILTER: ['request', 'request_fixable', 'change_request'],
+    INVALID_OPERATIONS_FILE: ['request', 'request_fixable', 'change_request'],
+    OPERATIONS_REQUIRED: ['request', 'request_fixable', 'change_request'],
+    UNKNOWN_OPTION: ['request', 'request_fixable', 'change_request'],
+    UNEXPECTED_ARGUMENT: ['request', 'request_fixable', 'change_request'],
+    INVALID_ACTION: ['request', 'request_fixable', 'change_request'],
+    INVALID_PROFILE: ['request', 'request_fixable', 'change_request'],
+    INVALID_REVISION_TOKEN: ['revision-check', 'request_fixable', 'change_request'],
+    BATCH_OPERATION_FAILED: ['batch-execution', 'request_fixable', 'inspect_failed_operations'],
+    REVISION_TOKEN_SCOPE_MISMATCH: ['revision-check', 'request_fixable', 'change_request'],
+    REVISION_MISMATCH: ['revision-check', 'target_refresh_required', 'reinspect'],
+    TARGET_NOT_FOUND: ['target-resolution', 'target_refresh_required', 'reinspect'],
+    SOURCE_TARGET_NOT_FOUND: ['target-resolution', 'target_refresh_required', 'reinspect'],
+    TARGET_TEXT_MISMATCH: ['target-resolution', 'target_refresh_required', 'reinspect'],
+    TARGET_FINGERPRINT_MISMATCH: ['target-resolution', 'target_refresh_required', 'reinspect'],
+    TARGET_INDEX_MISMATCH: ['target-resolution', 'target_refresh_required', 'reinspect'],
+    TARGET_OCCURRENCE_MISMATCH: ['target-resolution', 'candidate_selection_required', 'choose_candidate'],
+    STALE_TARGET_HANDLE: ['target-resolution', 'target_refresh_required', 'reinspect'],
+    TARGET_HANDLE_NOT_FOUND: ['target-resolution', 'target_refresh_required', 'reinspect'],
+    AMBIGUOUS_TARGET: ['target-resolution', 'candidate_selection_required', 'choose_candidate'],
+    TARGET_RANGE_INVALID: ['target-resolution', 'request_fixable', 'change_target_range'],
+    ANCHOR_NOT_FOUND: ['anchor-resolution', 'request_fixable', 'change_anchor'],
+    AMBIGUOUS_ANCHOR: ['anchor-resolution', 'candidate_selection_required', 'choose_candidate'],
+    PATCH_SOURCE_NOT_FOUND: ['patch-compilation', 'request_fixable', 'change_patch'],
+    AMBIGUOUS_PATCH_SOURCE: ['patch-compilation', 'candidate_selection_required', 'choose_occurrence'],
+    OVERLAPPING_PATCHES: ['patch-compilation', 'source_conflict', 'combine_patches'],
+    CONFLICTING_PATCHES: ['patch-compilation', 'source_conflict', 'combine_patches'],
+    PATCH_ROUNDTRIP_MISMATCH: ['patch-validation', 'request_fixable', 'reinspect_and_narrow'],
+    DIFF_TOKEN_LIMIT: ['patch-compilation', 'request_fixable', 'narrow_operation'],
+    STRUCTURED_CONTENT_INVALID: ['request', 'request_fixable', 'change_request'],
+    UNSUPPORTED_INSERTION_AFFINITY: ['request', 'request_fixable', 'change_request'],
+    EXISTING_REVISIONS: ['target-safety', 'policy_choice_required', 'set_option'],
+    COMMENTED_CONTENT_MERGE: ['target-safety', 'user_authorization_required', 'resolve_comments'],
+    COMMENTED_CONTENT_DELETE: ['target-safety', 'user_authorization_required', 'resolve_comments'],
+    OVERLAPPING_SOURCE_TARGETS: ['batch-compilation', 'source_conflict', 'consolidate_operations'],
+    OVERLAPPING_TEXT_EDITS: ['batch-compilation', 'source_conflict', 'consolidate_operations'],
+    REVISION_ORDER_CONFLICT: ['batch-compilation', 'source_conflict', 'split_or_consolidate_operations'],
+    TARGET_CONSUMED_BY_OPERATION: ['batch-execution', 'source_conflict', 'use_created_content_dependency'],
+    CAPTURE_FANOUT_CONFLICT: ['batch-compilation', 'source_conflict', 'split_or_chain_capture_consumers'],
+    DUPLICATE_CAPTURE_KEY: ['batch-compilation', 'request_fixable', 'rename_capture'],
+    CAPTURE_NOT_FOUND: ['batch-compilation', 'request_fixable', 'add_or_correct_capture'],
+    CAPTURE_DEPENDENCY_CYCLE: ['batch-compilation', 'source_conflict', 'replan_batch'],
+    AMBIGUOUS_CAPTURE_SELECTION: ['batch-compilation', 'candidate_selection_required', 'choose_candidate'],
+    CAPTURE_STALE: ['batch-execution', 'source_conflict', 'replan_batch'],
+    GENERATED_OOXML_INVALID: ['validation', 'library_or_builder_failure', 'report_library_failure'],
+    DOCUMENT_SERIALIZATION_FAILED: ['serialization', 'library_or_builder_failure', 'report_library_failure'],
+    PACKAGE_OPERATION_FAILED: ['package', 'library_or_builder_failure', 'report_library_failure'],
+    PACKAGE_VALIDATION: ['package-validation', 'library_or_builder_failure', 'report_library_failure'],
+    MUTATION_RECEIPT_MISMATCH: ['receipt-validation', 'library_or_builder_failure', 'report_library_failure'],
+    FOREIGN_PARAGRAPH_MARK_DELETION: ['target-safety', 'policy_choice_required', 'use_restore_or_leave_deleted'],
+    RESTORATION_STATE_REQUIRED: ['target-safety', 'target_refresh_required', 'reinspect'],
+    RESTORATION_COUNT_MISMATCH: ['request', 'request_fixable', 'change_request'],
+    REJECTED_INSERTION_STATE_REQUIRED: ['target-safety', 'target_refresh_required', 'reinspect'],
+    UNSAFE_REVISION_NESTING: ['target-safety', 'manual_document_resolution', 'manual_resolution'],
+    UNSAFE_REVISION_BOUNDARY: ['target-safety', 'manual_document_resolution', 'manual_resolution'],
+    UNSAFE_PARAGRAPH_BOUNDARY: ['target-safety', 'manual_document_resolution', 'manual_resolution'],
+    UNSAFE_DELETED_TABLE_ROW: ['target-safety', 'manual_document_resolution', 'manual_resolution'],
+    UNSUPPORTED_MOVE_REVISION: ['target-safety', 'manual_document_resolution', 'manual_resolution'],
+    SECTION_BREAK_PARAGRAPH: ['target-safety', 'manual_document_resolution', 'manual_resolution'],
+    UNSAFE_PARAGRAPH_PLACEMENT: ['target-safety', 'manual_document_resolution', 'manual_resolution'],
+    UNSUPPORTED_REVISION_VIEW_MUTATION: ['target-safety', 'manual_document_resolution', 'manual_resolution']
+});
+
+function issueSummary(error) {
+    const issues = Array.isArray(error?.generatedIssues)
+        ? error.generatedIssues
+        : (Array.isArray(error?.issues) ? error.issues : null);
+    if (!issues) return null;
+    const byCode = new Map();
+    for (const issue of issues) {
+        const code = issue?.code || 'UNKNOWN';
+        byCode.set(code, (byCode.get(code) || 0) + 1);
+    }
+    return {
+        total: issues.length,
+        byCode: Array.from(byCode, ([code, count]) => ({ code, count }))
+    };
+}
+
+function ruleFor(code) {
+    return RULES[code] || ['operation', 'manual_document_resolution', 'inspect_error'];
+}
+
+/** Add stable machine recovery metadata while preserving code-specific details. */
+export function normalizeErrorWithRecovery(error, context = {}) {
+    const source = error && typeof error === 'object' ? error : {};
+    const code = typeof source.code === 'string' && source.code ? source.code : 'OPERATION_ERROR';
+    const [defaultStage, category, action] = ruleFor(code);
+    const details = {};
+    for (const [key, value] of Object.entries(source)) {
+        if (key === 'name' || key === 'stack' || key === 'message' || key === 'code') continue;
+        details[key] = value;
+    }
+    const requiresAuthorization = category === 'user_authorization_required';
+    const requiresReinspection = category === 'target_refresh_required'
+        || code === 'PATCH_ROUNDTRIP_MISMATCH';
+    const recovery = {
+        action,
+        sameArgumentsSafe: false,
+        requiresReinspection,
+        requiresUserAuthorization: requiresAuthorization,
+        ...(code === 'EXISTING_REVISIONS' ? {
+            field: 'existingRevisions',
+            recommendedValue: 'slice-cross-author'
+        } : {}),
+        ...(source.recovery && typeof source.recovery === 'object' ? source.recovery : {})
+    };
+    const summary = issueSummary(source);
+    const derivedContext = {
+        ...context,
+        ...(Array.isArray(source.revisionAuthors) ? { revisionAuthors: source.revisionAuthors } : {}),
+        ...(source.currentPolicy ? { currentPolicy: source.currentPolicy } : {})
+    };
+    if (
+        ['TARGET_TEXT_MISMATCH', 'TARGET_FINGERPRINT_MISMATCH'].includes(code)
+        && Array.isArray(source.candidates)
+        && source.candidates.length === 1
+    ) {
+        derivedContext.currentTarget = source.candidates[0];
+        derivedContext.requiresRecomposeModified = true;
+    }
+    return {
+        recoveryVersion: ERROR_RECOVERY_VERSION,
+        code,
+        message: source.message || String(error),
+        stage: source.stage || defaultStage,
+        category: source.category || category,
+        ...details,
+        ...(Object.keys(derivedContext).length > 0 || source.context ? {
+            context: { ...(source.context || {}), ...derivedContext }
+        } : {}),
+        ...(summary ? { issueSummary: summary } : {}),
+        recovery
+    };
+}
+
+export function createRetryPlan({
+    atomic = false,
+    rolledBack = false,
+    results = [],
+    receipts = [],
+    operationCount = null
+} = {}) {
+    const count = Number.isInteger(operationCount)
+        ? operationCount
+        : Math.max(results.length, receipts.length);
+    const attempted = new Set(results.map(result => result?.index).filter(Number.isInteger));
+    const failedIndexes = results
+        .filter(result => result?.status === 'error')
+        .map(result => result.index)
+        .filter(Number.isInteger);
+    const committedIndexes = receipts
+        .filter(receipt => receipt?.committed === true)
+        .map(receipt => receipt.operationIndex)
+        .filter(Number.isInteger);
+    const unattemptedIndexes = [];
+    for (let index = 1; index <= count; index += 1) {
+        if (!attempted.has(index)) unattemptedIndexes.push(index);
+    }
+    const base = rolledBack || atomic || committedIndexes.length === 0 ? 'original' : 'output';
+    return {
+        base,
+        committedIndexes,
+        failedIndexes,
+        unattemptedIndexes,
+        replayWholeBatch: base === 'original',
+        sameArgumentsSafe: false
+    };
+}

package/services/operation-batch-compiler.js

@@ -0,0 +1,394 @@
+import {
+    buildParagraphMetadataIndex,
+    getDocumentParagraphNodes,
+    getParagraphId,
+    resolveTargetParagraph
+} from '../core/paragraph-targeting.js';
+import {
+    normalizeDocumentOperation,
+    normalizeTargetDescriptor,
+    validateDocumentOperation
+} from './document-operation-contract.js';
+
+const TEXT_WRITE_KINDS = new Set(['redline', 'restore', 'rejected-insert']);
+const FORMAT_WRITE_KINDS = new Set(['highlight', 'format', 'paragraph-format']);
+
+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 isParagraphAttached(document, paragraph) {
+    return !!paragraph && getDocumentParagraphNodes(document).includes(paragraph);
+}
+
+function paragraphNodesFromMutation(nodes = []) {
+    const paragraphs = [];
+    for (const node of nodes) {
+        if (!node || node.nodeType !== 1) continue;
+        if (node.localName === 'p') paragraphs.push(node);
+        for (const paragraph of Array.from(node.getElementsByTagNameNS?.('*', 'p') || [])) {
+            if (!paragraphs.includes(paragraph)) paragraphs.push(paragraph);
+        }
+    }
+    return paragraphs;
+}
+
+/** Session-local source identities over live paragraph nodes. */
+export class SourceTargetRegistry {
+    constructor(document) {
+        this.document = document;
+        this.nextId = 1;
+        this.entries = new Map();
+        this.idsByNode = new WeakMap();
+    }
+
+    register(paragraph, metadata = {}) {
+        const existing = this.idsByNode.get(paragraph);
+        if (existing) return existing;
+        const sourceId = `S${this.nextId++}`;
+        this.entries.set(sourceId, {
+            sourceId,
+            paragraph,
+            sourceIndex: metadata.index || null,
+            paragraphId: metadata.paragraphId || null,
+            fingerprint: metadata.fingerprint || null,
+            text: metadata.text || '',
+            revisionView: metadata.revisionView === 'rejected' ? 'rejected' : 'accepted',
+            consumed: false,
+            consumedByOperation: null
+        });
+        this.idsByNode.set(paragraph, sourceId);
+        return sourceId;
+    }
+
+    describe(sourceId) {
+        const entry = this.entries.get(sourceId);
+        if (!entry) return null;
+        return {
+            sourceId,
+            index: entry.sourceIndex,
+            paragraphId: entry.paragraphId,
+            fingerprint: entry.fingerprint,
+            text: entry.text,
+            revisionView: entry.revisionView
+        };
+    }
+
+    resolve(sourceId, document = this.document) {
+        const entry = this.entries.get(sourceId);
+        if (!entry) {
+            return {
+                error: {
+                    code: 'SOURCE_TARGET_NOT_FOUND',
+                    message: `Compiled source target ${String(sourceId)} was not found.`
+                }
+            };
+        }
+        if (entry.consumed) {
+            return {
+                error: {
+                    code: 'TARGET_CONSUMED_BY_OPERATION',
+                    message: `Compiled source target ${sourceId} was consumed by operation ${entry.consumedByOperation}.`,
+                    sourceTarget: this.describe(sourceId),
+                    consumedByOperation: entry.consumedByOperation
+                }
+            };
+        }
+        if (isParagraphAttached(document, entry.paragraph)) {
+            return { paragraph: entry.paragraph, resolvedBy: 'batch_source' };
+        }
+        return {
+            error: {
+                code: 'TARGET_CONSUMED_BY_OPERATION',
+                message: `Compiled source target ${sourceId} is no longer present in the live document.`,
+                sourceTarget: this.describe(sourceId),
+                consumedByOperation: entry.consumedByOperation
+            }
+        };
+    }
+
+    createSavepoint(document = this.document) {
+        const paragraphs = getDocumentParagraphNodes(document);
+        return new Map(Array.from(this.entries, ([sourceId, entry]) => [sourceId, {
+            paragraphIndex: paragraphs.indexOf(entry.paragraph),
+            consumed: entry.consumed,
+            consumedByOperation: entry.consumedByOperation
+        }]));
+    }
+
+    restoreSavepoint(document, snapshot) {
+        this.document = document;
+        this.idsByNode = new WeakMap();
+        const paragraphs = getDocumentParagraphNodes(document);
+        for (const [sourceId, entry] of this.entries) {
+            const saved = snapshot instanceof Map ? snapshot.get(sourceId) : null;
+            entry.consumed = saved?.consumed === true;
+            entry.consumedByOperation = saved?.consumedByOperation || null;
+            entry.paragraph = Number.isInteger(saved?.paragraphIndex) && saved.paragraphIndex >= 0
+                ? (paragraphs[saved.paragraphIndex] || null)
+                : null;
+            if (entry.paragraph) this.idsByNode.set(entry.paragraph, sourceId);
+        }
+    }
+
+    commitMutation(sourceId, removedNodes, liveNodes, operationIndex) {
+        const entry = this.entries.get(sourceId);
+        if (!entry || !Array.isArray(removedNodes) || !removedNodes.includes(entry.paragraph)) return;
+        const candidates = paragraphNodesFromMutation(liveNodes);
+        const sameId = entry.paragraphId
+            ? candidates.filter(paragraph => getParagraphId(paragraph) === entry.paragraphId)
+            : [];
+        const successor = sameId.length === 1
+            ? sameId[0]
+            : (candidates.length === 1 ? candidates[0] : null);
+        if (successor) {
+            entry.paragraph = successor;
+            this.idsByNode.set(successor, sourceId);
+            return;
+        }
+        entry.paragraph = null;
+        entry.consumed = true;
+        entry.consumedByOperation = operationIndex;
+    }
+}
+
+function resolvedTarget(metadata, revisionView) {
+    return {
+        index: metadata.index,
+        paragraphId: metadata.paragraphId,
+        fingerprint: metadata.fingerprint,
+        text: metadata.text,
+        inTable: metadata.inTable,
+        revisionView
+    };
+}
+
+function resolveDescriptor(xmlDoc, descriptor, kind, strictTargets, metadataIndices, callbacks = {}) {
+    const revisionView = descriptor?.revisionView === 'rejected' ? 'rejected' : 'accepted';
+    if (!metadataIndices[revisionView]) {
+        metadataIndices[revisionView] = buildParagraphMetadataIndex(xmlDoc, { revisionView });
+    }
+    const index = metadataIndices[revisionView];
+    const resolution = resolveTargetParagraph(xmlDoc, {
+        targetText: descriptor.text,
+        targetRef: descriptor.index,
+        targetDescriptor: descriptor,
+        opType: kind,
+        strictAmbiguity: strictTargets,
+        paragraphMetadataIndex: index,
+        metadataIndices,
+        onInfo: callbacks.onInfo,
+        onWarn: callbacks.onWarn
+    });
+    const metadata = index.byParagraph.get(resolution.paragraph);
+    return {
+        paragraph: resolution.paragraph,
+        resolvedBy: resolution.resolvedBy,
+        metadata: resolvedTarget(metadata, revisionView)
+    };
+}
+
+function buildConflict(code, message, bindings, target, action) {
+    return {
+        code,
+        message,
+        operationIndexes: bindings.map(binding => binding.index).sort((a, b) => a - b),
+        target,
+        recovery: {
+            action,
+            sameArgumentsSafe: false,
+            requiresReinspection: false,
+            requiresUserAuthorization: false
+        }
+    };
+}
+
+/** Resolve source targets once and derive source-level conflicts before mutation. */
+export function compileOperationBatch(xmlDoc, operations = [], options = {}) {
+    const sourceOperations = Array.isArray(operations) ? operations : [];
+    const strictTargets = options.strictTargets !== false;
+    const registry = new SourceTargetRegistry(xmlDoc);
+    const metadataIndices = {
+        accepted: buildParagraphMetadataIndex(xmlDoc, { revisionView: 'accepted' }),
+        rejected: null
+    };
+    const bindings = [];
+    const compiledOperations = [];
+
+    for (let index = 0; index < sourceOperations.length; index += 1) {
+        const sourceOperation = sourceOperations[index];
+        const validation = validateDocumentOperation(sourceOperation);
+        const operation = validation.operation || normalizeDocumentOperation(sourceOperation);
+        const binding = {
+            index: index + 1,
+            operationKind: operation.operationKind,
+            operationId: operation.operationId,
+            sourceIds: [],
+            warnings: []
+        };
+        const compiled = { ...sourceOperation };
+
+        const dynamicOccurrence = operation.targetDescriptor?.occurrence != null
+            && !operation.targetDescriptor?.paragraphId
+            && !operation.targetDescriptor?.fingerprint;
+        const compositeTextTarget = typeof operation.targetDescriptor?.text === 'string'
+            && /\r|\n/.test(operation.targetDescriptor.text)
+            && !operation.targetEndDescriptor;
+        if (dynamicOccurrence || compositeTextTarget) binding.dynamic = true;
+
+        if (
+            validation.valid
+            && operation.operationKind !== 'comment_reply'
+            && !operation.targetDescriptor?.captureRef
+            && !binding.dynamic
+        ) {
+            try {
+                const start = resolveDescriptor(
+                    xmlDoc,
+                    operation.targetDescriptor,
+                    operation.operationKind,
+                    strictTargets,
+                    metadataIndices,
+                    {
+                        onInfo: options.onInfo,
+                        onWarn: warning => binding.warnings.push(String(warning))
+                    }
+                );
+                const startId = registry.register(start.paragraph, start.metadata);
+                binding.sourceIds.push(startId);
+                binding.resolvedBy = start.resolvedBy;
+                binding.resolvedTarget = start.metadata;
+                compiled._compiledSourceId = startId;
+                compiled._compiledResolvedBy = start.resolvedBy;
+                if (binding.warnings.length > 0) compiled._compiledWarnings = binding.warnings;
+
+                const targetEndDescriptor = operation.targetEndDescriptor
+                    || (operation.targetEndRef != null
+                        ? normalizeTargetDescriptor(null, operation.targetEndRef, operation.targetDescriptor.revisionView)
+                        : null);
+                if (targetEndDescriptor) {
+                    const end = resolveDescriptor(
+                        xmlDoc,
+                        targetEndDescriptor,
+                        operation.operationKind,
+                        strictTargets,
+                        metadataIndices,
+                        {
+                            onInfo: options.onInfo,
+                            onWarn: warning => binding.warnings.push(String(warning))
+                        }
+                    );
+                    const endId = registry.register(end.paragraph, end.metadata);
+                    compiled._compiledSourceEndId = endId;
+                    const paragraphs = getDocumentParagraphNodes(xmlDoc);
+                    const startIndex = paragraphs.indexOf(start.paragraph);
+                    const endIndex = paragraphs.indexOf(end.paragraph);
+                    if (startIndex < 0 || endIndex < startIndex) {
+                        throw Object.assign(new Error('Target range is not a forward contiguous paragraph range.'), {
+                            code: 'TARGET_RANGE_INVALID'
+                        });
+                    }
+                    for (const paragraph of paragraphs.slice(startIndex, endIndex + 1)) {
+                        const viewIndex = metadataIndices[operation.targetDescriptor.revisionView] || metadataIndices.accepted;
+                        const metadata = viewIndex.byParagraph.get(paragraph);
+                        binding.sourceIds.push(registry.register(paragraph, metadata || {}));
+                    }
+                    binding.sourceIds = [...new Set(binding.sourceIds)];
+                    binding.resolvedTargetEnd = end.metadata;
+                }
+            } catch (error) {
+                binding.error = normalizedError(error);
+            }
+        }
+        bindings.push(binding);
+        compiledOperations.push(compiled);
+    }
+
+    const existingCaptureKeys = new Set(compiledOperations.map(operation => operation?.captureKey).filter(Boolean));
+    let nextImplicitCapture = 1;
+    for (const binding of bindings) {
+        if (binding.error?.code !== 'TARGET_NOT_FOUND') continue;
+        const consumerIndex = binding.index - 1;
+        const consumer = normalizeDocumentOperation(sourceOperations[consumerIndex]);
+        const targetText = consumer.targetDescriptor?.text;
+        if (!targetText) continue;
+        const producers = sourceOperations.flatMap((candidate, producerIndex) => {
+            if (producerIndex === consumerIndex || typeof candidate?.modified !== 'string') return [];
+            const createdParagraphs = candidate.modified.split(/\r?\n/).map(text => text.trim()).filter(Boolean);
+            return createdParagraphs.includes(targetText.trim()) ? [{ candidate, producerIndex }] : [];
+        });
+        if (producers.length !== 1) continue;
+        const [{ candidate: producer, producerIndex }] = producers;
+        let captureKey = producer.captureKey || compiledOperations[producerIndex].captureKey;
+        if (!captureKey) {
+            do {
+                captureKey = `__batch_created_${nextImplicitCapture++}`;
+            } while (existingCaptureKeys.has(captureKey));
+            existingCaptureKeys.add(captureKey);
+            compiledOperations[producerIndex].captureKey = captureKey;
+        }
+        compiledOperations[consumerIndex].target = { captureRef: captureKey, select: targetText };
+        delete compiledOperations[consumerIndex]._compiledSourceId;
+        delete compiledOperations[consumerIndex]._compiledResolvedBy;
+        delete binding.error;
+        binding.sourceIds = [];
+        binding.resolvedBy = 'created_content_dependency';
+        binding.createdByOperation = producerIndex + 1;
+        binding.captureRef = captureKey;
+    }
+
+    const bySource = new Map();
+    for (const binding of bindings) {
+        if (binding.error || binding.dynamic) continue;
+        for (const sourceId of binding.sourceIds) {
+            if (!bySource.has(sourceId)) bySource.set(sourceId, []);
+            bySource.get(sourceId).push(binding);
+        }
+    }
+
+    const conflicts = [];
+    const conflictKeys = new Set();
+    for (const [sourceId, sourceBindings] of bySource) {
+        const textWrites = sourceBindings.filter(binding => TEXT_WRITE_KINDS.has(binding.operationKind));
+        const formatWrites = sourceBindings.filter(binding => FORMAT_WRITE_KINDS.has(binding.operationKind));
+        if (textWrites.length > 1) {
+            const key = `text:${textWrites.map(binding => binding.index).sort().join(',')}`;
+            if (!conflictKeys.has(key)) {
+                conflictKeys.add(key);
+                conflicts.push(buildConflict(
+                    'OVERLAPPING_SOURCE_TARGETS',
+                    `Operations ${textWrites.map(binding => binding.index).join(', ')} contain incompatible text writes to the same batch-start source target.`,
+                    textWrites,
+                    registry.describe(sourceId),
+                    'consolidate_operations'
+                ));
+            }
+        }
+        if (textWrites.length > 0 && formatWrites.length > 0) {
+            const affected = [...textWrites, ...formatWrites];
+            const key = `format:${affected.map(binding => binding.index).sort().join(',')}`;
+            if (!conflictKeys.has(key)) {
+                conflictKeys.add(key);
+                conflicts.push(buildConflict(
+                    'REVISION_ORDER_CONFLICT',
+                    `Operations ${affected.map(binding => binding.index).join(', ')} combine text and formatting writes on the same batch-start source target.`,
+                    affected,
+                    registry.describe(sourceId),
+                    'split_or_consolidate_operations'
+                ));
+            }
+        }
+    }
+
+    return {
+        valid: conflicts.length === 0 && bindings.every(binding => !binding.error),
+        compiledOperations,
+        bindings,
+        conflicts,
+        registry
+    };
+}