@ansonlai/docx-redline-js 0.8.2 → 0.8.4

package/services/document-operation-mutations.js

@@ -20,20 +20,20 @@ import {
 } from '../engine/rpr-helpers.js';
 import { refreshRunPropertyChangeIds } from '../core/revision-cloning.js';
 import { getDefaultAuthor } from '../adapters/config.js';
-import { applyRedlineToOxml as applyRedlineToOxmlEngine } from '../engine/oxml-engine.js';
-import {
-    getParagraphRestorationRefusal,
-    inspectForeignDeletedParagraphTarget
-} from '../core/paragraph-revision-safety.js';
-import { extractCanonicalParagraphText } from '../core/paragraph-text.js';
-import { validateRedlineOoxml } from '../core/redline-validation.js';
-import { subtractValidationIssueMultiset, validationErrors } from '../core/validation-delta.js';
-import { clonePropertiesWithoutRevisionHistory } from '../core/revision-cloning.js';
-import {
-    getRunContentPieces,
-    getRunTextLength,
-    splitTrackChangeCarrier
-} from '../engine/surgical-run-splitting.js';
+import { applyRedlineToOxml as applyRedlineToOxmlEngine } from '../engine/oxml-engine.js';
+import {
+    getParagraphRestorationRefusal,
+    inspectForeignDeletedParagraphTarget
+} from '../core/paragraph-revision-safety.js';
+import { extractCanonicalParagraphText } from '../core/paragraph-text.js';
+import { validateRedlineOoxml } from '../core/redline-validation.js';
+import { subtractValidationIssueMultiset, validationErrors } from '../core/validation-delta.js';
+import { clonePropertiesWithoutRevisionHistory } from '../core/revision-cloning.js';
+import {
+    getRunContentPieces,
+    getRunTextLength,
+    splitTrackChangeCarrier
+} from '../engine/surgical-run-splitting.js';
 import { applyHighlightToOoxml } from '../engine/formatting-removal.js';
 import { parseTable as parseMarkdownTable } from '../pipeline/pipeline.js';
 import { injectCommentsIntoOoxml } from './comment-engine.js';
@@ -42,12 +42,13 @@ import {
     getParagraphId,
     createParagraphFingerprint,
     isMarkdownTableText,
+    normalizeWhitespaceForTargeting,
     findContainingWordElement,
-    resolveTargetParagraphWithSnapshot as resolveTargetParagraphWithSnapshotShared,
-    resolveParagraphRangeByRefs,
-    getDocumentParagraphNodes,
-    validateParagraphBoundaryMutation
-} from '../core/paragraph-targeting.js';
+    resolveTargetParagraphWithSnapshot as resolveTargetParagraphWithSnapshotShared,
+    resolveParagraphRangeByRefs,
+    getDocumentParagraphNodes,
+    validateParagraphBoundaryMutation
+} from '../core/paragraph-targeting.js';
 import {
     synthesizeExpandedListScopeEdit,
     planListInsertionOnlyEdit,
@@ -70,6 +71,7 @@ import {
 import {
     reserveNextNumberingIdPair,
     remapNumberingPayloadForDocument,
+    reuseSourceListNumbering,
     overwriteParagraphNumIds,
     extractFirstParagraphNumId,
     buildExplicitDecimalMultilevelNumberingXml
@@ -81,17 +83,20 @@ import {
 import { prepareRevisionAllocator } from './document-operation-session.js';
 import {
     buildExplicitRangeInsertionEntries,
+    deriveParagraphThenTableAppend,
     deriveSingleParagraphListAdjacencyInsertion,
     deriveSingleParagraphPlainAdjacencyInsertion
 } from './operation-heuristics.js';
-import { resolveTargetFromCapture, ensureParagraphIdsOnImportedNode } from './capture-engine.js';
-import {
-    acceptTrackedChangesInOoxml,
-    rejectTrackedChangesInOoxml
-} from './revision-comment-management.js';
-
-const NS_W = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
-const NS_W14 = 'http://schemas.microsoft.com/office/word/2010/wordml';
+import { generateTableOoxml } from './table-reconciliation.js';
+import { preprocessMarkdown } from '../pipeline/markdown-processor.js';
+import { resolveTargetFromCapture, ensureParagraphIdsOnImportedNode } from './capture-engine.js';
+import {
+    acceptTrackedChangesInOoxml,
+    rejectTrackedChangesInOoxml
+} from './revision-comment-management.js';
+
+const NS_W = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
+const NS_W14 = 'http://schemas.microsoft.com/office/word/2010/wordml';
 
 function getCommentIdsInElement(element) {
     const ids = new Set();
@@ -169,111 +174,111 @@ async function reconcileMarkdownTableOoxml(oxml, originalText, markdownTable, op
     };
 }
 
-function getParagraphText(paragraph) {
-    return getParagraphTextFromOxml(paragraph);
-}
-
-function escapeInvisibleText(value, maxLength = 96) {
-    const text = String(value ?? '');
-    const bounded = text.length > maxLength ? `${text.slice(0, maxLength)}…` : text;
-    return bounded
-        .replace(/\\/g, '\\\\')
-        .replace(/\r/g, '\\r')
-        .replace(/\n/g, '\\n')
-        .replace(/\t/g, '\\t')
-        .replace(/\u00a0/g, '\\u00A0')
-        .replace(/\u202f/g, '\\u202F')
-        .replace(/\u2060/g, '\\u2060');
-}
-
-function codePointLabel(value, offset) {
-    if (offset >= value.length) return 'END';
-    return `U+${value.codePointAt(offset).toString(16).toUpperCase().padStart(4, '0')}`;
-}
-
-function describeTargetTextMatch(actualText, requestedText) {
-    const actual = String(actualText ?? '');
-    const requested = String(requestedText ?? '');
-    if (actual === requested) return { mode: 'exact' };
-
-    const differences = [];
-    const limit = Math.min(actual.length, requested.length);
-    for (let offset = 0; offset < limit && differences.length < 8; offset++) {
-        if (actual[offset] === requested[offset]) continue;
-        differences.push({
-            offset,
-            sourceCodePoint: codePointLabel(actual, offset),
-            requestedCodePoint: codePointLabel(requested, offset)
-        });
-    }
-    if (actual.length !== requested.length && differences.length < 8) {
-        differences.push({
-            offset: limit,
-            sourceCodePoint: codePointLabel(actual, limit),
-            requestedCodePoint: codePointLabel(requested, limit)
-        });
-    }
-
-    const spaceEquivalent = actual.length === requested.length
-        && actual.replace(/\u00a0/g, ' ') === requested.replace(/\u00a0/g, ' ');
-    return {
-        mode: spaceEquivalent ? 'space_equivalent' : 'normalized',
-        differences,
-        sourceExcerpt: escapeInvisibleText(actual),
-        requestedExcerpt: escapeInvisibleText(requested)
-    };
-}
-
-function resolvedTargetDiagnostics(xmlDoc, paragraph, metadata, targetText, options) {
-    const revisionView = options?.targetDescriptor?.revisionView === 'rejected'
-        ? 'rejected'
-        : 'accepted';
-    const viewMetadata = metadata?.revisionView === revisionView ? metadata : null;
-    const index = viewMetadata?.index ?? getDocumentParagraphNodes(xmlDoc).indexOf(paragraph) + 1;
-    const paragraphId = viewMetadata?.paragraphId ?? getParagraphId(paragraph);
-    const inTable = viewMetadata?.inTable ?? !!findContainingWordElement(paragraph, 'tbl');
-    const text = viewMetadata?.text ?? extractCanonicalParagraphText(paragraph, { revisionView });
-    const fingerprint = viewMetadata?.fingerprint ?? createParagraphFingerprint(paragraph, {
-        text,
-        index,
-        paragraphId,
-        inTable,
-        revisionView
-    });
-    return {
-        index,
-        paragraphId,
-        text,
-        fingerprint,
-        revisionView,
-        inTable,
-        targetTextMatch: describeTargetTextMatch(
-            text,
-            options?.targetDescriptor?.text ?? options?.targetDescriptor?.exactText ?? targetText
-        )
-    };
-}
-
-function resolveTargetParagraph(xmlDoc, targetText, targetRef, opType, runtimeContext = null, options = {}) {
+function getParagraphText(paragraph) {
+    return getParagraphTextFromOxml(paragraph);
+}
+
+function escapeInvisibleText(value, maxLength = 96) {
+    const text = String(value ?? '');
+    const bounded = text.length > maxLength ? `${text.slice(0, maxLength)}…` : text;
+    return bounded
+        .replace(/\\/g, '\\\\')
+        .replace(/\r/g, '\\r')
+        .replace(/\n/g, '\\n')
+        .replace(/\t/g, '\\t')
+        .replace(/\u00a0/g, '\\u00A0')
+        .replace(/\u202f/g, '\\u202F')
+        .replace(/\u2060/g, '\\u2060');
+}
+
+function codePointLabel(value, offset) {
+    if (offset >= value.length) return 'END';
+    return `U+${value.codePointAt(offset).toString(16).toUpperCase().padStart(4, '0')}`;
+}
+
+function describeTargetTextMatch(actualText, requestedText) {
+    const actual = String(actualText ?? '');
+    const requested = String(requestedText ?? '');
+    if (actual === requested) return { mode: 'exact' };
+
+    const differences = [];
+    const limit = Math.min(actual.length, requested.length);
+    for (let offset = 0; offset < limit && differences.length < 8; offset++) {
+        if (actual[offset] === requested[offset]) continue;
+        differences.push({
+            offset,
+            sourceCodePoint: codePointLabel(actual, offset),
+            requestedCodePoint: codePointLabel(requested, offset)
+        });
+    }
+    if (actual.length !== requested.length && differences.length < 8) {
+        differences.push({
+            offset: limit,
+            sourceCodePoint: codePointLabel(actual, limit),
+            requestedCodePoint: codePointLabel(requested, limit)
+        });
+    }
+
+    const spaceEquivalent = actual.length === requested.length
+        && actual.replace(/\u00a0/g, ' ') === requested.replace(/\u00a0/g, ' ');
+    return {
+        mode: spaceEquivalent ? 'space_equivalent' : 'normalized',
+        differences,
+        sourceExcerpt: escapeInvisibleText(actual),
+        requestedExcerpt: escapeInvisibleText(requested)
+    };
+}
+
+function resolvedTargetDiagnostics(xmlDoc, paragraph, metadata, targetText, options) {
+    const revisionView = options?.targetDescriptor?.revisionView === 'rejected'
+        ? 'rejected'
+        : 'accepted';
+    const viewMetadata = metadata?.revisionView === revisionView ? metadata : null;
+    const index = viewMetadata?.index ?? getDocumentParagraphNodes(xmlDoc).indexOf(paragraph) + 1;
+    const paragraphId = viewMetadata?.paragraphId ?? getParagraphId(paragraph);
+    const inTable = viewMetadata?.inTable ?? !!findContainingWordElement(paragraph, 'tbl');
+    const text = viewMetadata?.text ?? extractCanonicalParagraphText(paragraph, { revisionView });
+    const fingerprint = viewMetadata?.fingerprint ?? createParagraphFingerprint(paragraph, {
+        text,
+        index,
+        paragraphId,
+        inTable,
+        revisionView
+    });
+    return {
+        index,
+        paragraphId,
+        text,
+        fingerprint,
+        revisionView,
+        inTable,
+        targetTextMatch: describeTargetTextMatch(
+            text,
+            options?.targetDescriptor?.text ?? options?.targetDescriptor?.exactText ?? targetText
+        )
+    };
+}
+
+function resolveTargetParagraph(xmlDoc, targetText, targetRef, opType, runtimeContext = null, options = {}) {
     const onInfo = typeof options?.onInfo === 'function' ? options.onInfo : () => { };
     const onWarn = typeof options?.onWarn === 'function' ? options.onWarn : () => { };
     const session = options?._documentOperationSession || null;
-    const paragraphMetadataIndex = session?.getParagraphMetadataIndex?.() || null;
-
-    if (options?._compiledSourceId && options?._sourceTargetRegistry) {
-        const resolved = options._sourceTargetRegistry.resolve(options._compiledSourceId, xmlDoc);
-        if (resolved?.error || !resolved?.paragraph) return resolved;
-        resolved.resolvedBy = options._compiledResolvedBy || resolved.resolvedBy;
-        if (options?._resolutionCapture) {
-            const paragraph = resolved.paragraph;
-            const metadata = paragraphMetadataIndex?.byParagraph?.get(paragraph) || null;
-            Object.assign(options._resolutionCapture, {
-                resolvedBy: resolved.resolvedBy,
-                resolvedTarget: resolvedTargetDiagnostics(xmlDoc, paragraph, metadata, targetText, options)
-            });
-        }
-        return resolved;
-    }
+    const paragraphMetadataIndex = session?.getParagraphMetadataIndex?.() || null;
+
+    if (options?._compiledSourceId && options?._sourceTargetRegistry) {
+        const resolved = options._sourceTargetRegistry.resolve(options._compiledSourceId, xmlDoc);
+        if (resolved?.error || !resolved?.paragraph) return resolved;
+        resolved.resolvedBy = options._compiledResolvedBy || resolved.resolvedBy;
+        if (options?._resolutionCapture) {
+            const paragraph = resolved.paragraph;
+            const metadata = paragraphMetadataIndex?.byParagraph?.get(paragraph) || null;
+            Object.assign(options._resolutionCapture, {
+                resolvedBy: resolved.resolvedBy,
+                resolvedTarget: resolvedTargetDiagnostics(xmlDoc, paragraph, metadata, targetText, options)
+            });
+        }
+        return resolved;
+    }
 
     if (options?.targetDescriptor?.captureRef) {
         try {
@@ -281,10 +286,10 @@ function resolveTargetParagraph(xmlDoc, targetText, targetRef, opType, runtimeCo
             if (options?._resolutionCapture && resolved?.paragraph) {
                 const paragraph = resolved.paragraph;
                 const metadata = paragraphMetadataIndex?.byParagraph?.get(paragraph) || null;
-                Object.assign(options._resolutionCapture, {
-                    resolvedBy: resolved.resolvedBy,
-                    resolvedTarget: resolvedTargetDiagnostics(xmlDoc, paragraph, metadata, targetText, options)
-                });
+                Object.assign(options._resolutionCapture, {
+                    resolvedBy: resolved.resolvedBy,
+                    resolvedTarget: resolvedTargetDiagnostics(xmlDoc, paragraph, metadata, targetText, options)
+                });
             }
             return resolved;
         } catch (error) {
@@ -311,10 +316,10 @@ function resolveTargetParagraph(xmlDoc, targetText, targetRef, opType, runtimeCo
     if (options?._resolutionCapture && resolved?.paragraph) {
         const paragraph = resolved.paragraph;
         const metadata = paragraphMetadataIndex?.byParagraph?.get(paragraph) || null;
-        Object.assign(options._resolutionCapture, {
-            resolvedBy: resolved.resolvedBy,
-            resolvedTarget: resolvedTargetDiagnostics(xmlDoc, paragraph, metadata, targetText, options)
-        });
+        Object.assign(options._resolutionCapture, {
+            resolvedBy: resolved.resolvedBy,
+            resolvedTarget: resolvedTargetDiagnostics(xmlDoc, paragraph, metadata, targetText, options)
+        });
     }
     return resolved;
 }
@@ -351,7 +356,7 @@ function preprocessRedlineTargetParagraph(targetParagraph) {
     removeProofErrNodes(targetParagraph);
 }
 
-function getDirectWordChild(element, localName) {
+function getDirectWordChild(element, localName) {
     if (!element) return null;
     return Array.from(element.childNodes || []).find(
         node => node && node.nodeType === 1 && node.namespaceURI === NS_W && node.localName === localName
@@ -416,7 +421,7 @@ function buildInsertedListParagraph(xmlDoc, anchorParagraph, entry, revisionMeta
 
     const anchorPPr = getDirectWordChild(anchorParagraph, 'pPr');
     if (anchorPPr) {
-        paragraph.appendChild(clonePropertiesWithoutRevisionHistory(anchorPPr));
+        paragraph.appendChild(clonePropertiesWithoutRevisionHistory(anchorPPr));
     }
     ensureListProperties(xmlDoc, paragraph, entry.ilvl, entry.numId);
 
@@ -432,7 +437,7 @@ function buildInsertedListParagraph(xmlDoc, anchorParagraph, entry, revisionMeta
     const anchorFirstRun = Array.from(anchorParagraph.getElementsByTagNameNS(NS_W, 'r'))[0] || null;
     const anchorRunPr = anchorFirstRun ? getDirectWordChild(anchorFirstRun, 'rPr') : null;
     if (anchorRunPr) {
-        run.appendChild(clonePropertiesWithoutRevisionHistory(anchorRunPr));
+        run.appendChild(clonePropertiesWithoutRevisionHistory(anchorRunPr));
     }
 
     const textNode = createWordElement(xmlDoc, 'w:t');
@@ -505,21 +510,21 @@ function applyExplicitRangeListInsertions({
     normalizeBodySectionOrder(xmlDoc);
     return true;
 }
-function buildFallbackInsertedPlainParagraph(xmlDoc, text, revisionMetadata, author, options = {}) {
+function buildFallbackInsertedPlainParagraph(xmlDoc, text, revisionMetadata, author, options = {}) {
     const generateRedlines = options.generateRedlines !== false;
     const paragraph = createWordElement(xmlDoc, 'w:p');
     const run = createWordElement(xmlDoc, 'w:r');
     const textNode = createWordElement(xmlDoc, 'w:t');
     const safeText = String(text || '');
     if (/^\s|\s$/.test(safeText)) textNode.setAttribute('xml:space', 'preserve');
-    textNode.textContent = safeText;
-    run.appendChild(textNode);
-
-    if (generateRedlines) {
-        if (options.trackParagraphMark === true) {
-            markParagraphMarkInserted(xmlDoc, paragraph, author);
-        }
-        const metadata = revisionMetadata || createRevisionMetadata(author, xmlDoc, 'ins');
+    textNode.textContent = safeText;
+    run.appendChild(textNode);
+
+    if (generateRedlines) {
+        if (options.trackParagraphMark === true) {
+            markParagraphMarkInserted(xmlDoc, paragraph, author);
+        }
+        const metadata = revisionMetadata || createRevisionMetadata(author, xmlDoc, 'ins');
         const ins = createWordElement(xmlDoc, 'w:ins');
         ins.setAttribute('w:id', String(metadata.id));
         ins.setAttribute('w:author', metadata.author);
@@ -536,12 +541,12 @@ function buildFallbackInsertedPlainParagraph(xmlDoc, text, revisionMetadata, aut
 function buildEmptyParagraphTemplateFromAnchor(xmlDoc, anchorParagraph) {
     const paragraph = createWordElement(xmlDoc, 'w:p');
     const anchorPPr = getDirectWordChild(anchorParagraph, 'pPr');
-    if (anchorPPr) paragraph.appendChild(clonePropertiesWithoutRevisionHistory(anchorPPr));
+    if (anchorPPr) paragraph.appendChild(clonePropertiesWithoutRevisionHistory(anchorPPr));
 
     const run = createWordElement(xmlDoc, 'w:r');
     const anchorFirstRun = Array.from(anchorParagraph.getElementsByTagNameNS(NS_W, 'r'))[0] || null;
     const anchorRunPr = anchorFirstRun ? getDirectWordChild(anchorFirstRun, 'rPr') : null;
-    if (anchorRunPr) run.appendChild(clonePropertiesWithoutRevisionHistory(anchorRunPr));
+    if (anchorRunPr) run.appendChild(clonePropertiesWithoutRevisionHistory(anchorRunPr));
 
     const textNode = createWordElement(xmlDoc, 'w:t');
     textNode.textContent = '';
@@ -550,19 +555,19 @@ function buildEmptyParagraphTemplateFromAnchor(xmlDoc, anchorParagraph) {
     return paragraph;
 }
 
-function wrapParagraphContentInInsertion(xmlDoc, paragraph, revisionMetadata, author, options = {}) {
-    const wrappedParagraph = createWordElement(xmlDoc, 'w:p');
-    const pPr = options.sanitizeParagraphProperties === true
-        ? createSanitizedRestorationPPr(xmlDoc, paragraph)
-        : clonePropertiesWithoutRevisionHistory(getDirectWordChild(paragraph, 'pPr'));
-    if (pPr) wrappedParagraph.appendChild(pPr);
-    if (options.paragraphId) wrappedParagraph.setAttributeNS(NS_W14, 'w14:paraId', options.paragraphId);
-    if (options.trackParagraphMark === true) {
-        markParagraphMarkInserted(xmlDoc, wrappedParagraph, author);
-    }
-
-    const ins = createWordElement(xmlDoc, 'w:ins');
-    const metadata = revisionMetadata || createRevisionMetadata(author, xmlDoc, 'ins');
+function wrapParagraphContentInInsertion(xmlDoc, paragraph, revisionMetadata, author, options = {}) {
+    const wrappedParagraph = createWordElement(xmlDoc, 'w:p');
+    const pPr = options.sanitizeParagraphProperties === true
+        ? createSanitizedRestorationPPr(xmlDoc, paragraph)
+        : clonePropertiesWithoutRevisionHistory(getDirectWordChild(paragraph, 'pPr'));
+    if (pPr) wrappedParagraph.appendChild(pPr);
+    if (options.paragraphId) wrappedParagraph.setAttributeNS(NS_W14, 'w14:paraId', options.paragraphId);
+    if (options.trackParagraphMark === true) {
+        markParagraphMarkInserted(xmlDoc, wrappedParagraph, author);
+    }
+
+    const ins = createWordElement(xmlDoc, 'w:ins');
+    const metadata = revisionMetadata || createRevisionMetadata(author, xmlDoc, 'ins');
     ins.setAttribute('w:id', String(metadata.id));
     ins.setAttribute('w:author', metadata.author);
     ins.setAttribute('w:date', metadata.date);
@@ -603,9 +608,9 @@ async function buildInsertedPlainParagraph(xmlDoc, anchorParagraph, text, revisi
         return buildFallbackInsertedPlainParagraph(
             xmlDoc,
             text,
-            revisionMetadata,
-            author,
-            { ...options, generateRedlines }
+            revisionMetadata,
+            author,
+            { ...options, generateRedlines }
         );
     }
 
@@ -613,10 +618,10 @@ async function buildInsertedPlainParagraph(xmlDoc, anchorParagraph, text, revisi
         return sourceParagraph;
     }
 
-    return wrapParagraphContentInInsertion(xmlDoc, sourceParagraph, revisionMetadata, author, options);
+    return wrapParagraphContentInInsertion(xmlDoc, sourceParagraph, revisionMetadata, author, options);
 }
 
-function collectNumberingIdsFromNodes(nodes) {
+function collectNumberingIdsFromNodes(nodes) {
     const ids = new Set();
     for (const node of nodes || []) {
         const numIdNodes = Array.from(node?.getElementsByTagNameNS?.('*', 'numId') || []);
@@ -628,719 +633,719 @@ function collectNumberingIdsFromNodes(nodes) {
         }
     }
     return Array.from(ids);
-}
-
-function directDeletionCarrierText(carrier) {
-    return Array.from(carrier?.childNodes || []).reduce((text, child) => {
-        return text + (child?.nodeType === 1 && child.namespaceURI === NS_W && child.localName === 'r'
-            ? getRunContentPieces(child).map(piece => piece.text).join('')
-            : '');
-    }, '');
-}
-
-function findOccurrenceOffset(text, needle, occurrence) {
-    let from = 0;
-    let found = -1;
-    for (let index = 0; index < occurrence; index++) {
-        found = text.indexOf(needle, from);
-        if (found < 0) return -1;
-        from = found + Math.max(needle.length, 1);
-    }
-    return found;
-}
-
-function countNonOverlappingOccurrences(text, needle) {
-    if (!needle) return 0;
-    let count = 0;
-    let from = 0;
-    while (from <= text.length) {
-        const found = text.indexOf(needle, from);
-        if (found < 0) break;
-        count += 1;
-        from = found + needle.length;
-    }
-    return count;
-}
-
-function hasUnsupportedDeletionSplitMarkup(paragraph, carrier) {
-    const unsafeParagraphNames = new Set([
-        'commentRangeStart', 'commentRangeEnd', 'commentReference',
-        'bookmarkStart', 'bookmarkEnd', 'moveFromRangeStart', 'moveFromRangeEnd',
-        'moveToRangeStart', 'moveToRangeEnd'
-    ]);
-    if (Array.from(paragraph.getElementsByTagName?.('*') || []).some(node => unsafeParagraphNames.has(node.localName))) {
-        return true;
-    }
-    for (const child of Array.from(carrier?.childNodes || [])) {
-        if (child.nodeType !== 1) continue;
-        if (!(child.namespaceURI === NS_W && child.localName === 'r')) return true;
-        for (const runChild of Array.from(child.childNodes || [])) {
-            if (runChild.nodeType !== 1 || runChild.namespaceURI !== NS_W) continue;
-            if (!['rPr', 'delText', 't', 'tab', 'br', 'cr', 'noBreakHyphen', 'softHyphen'].includes(runChild.localName)) return true;
-        }
-    }
-    return false;
-}
-
-function insertedRunPropertiesAtDeletionOffset(carrier, localOffset) {
-    let offset = 0;
-    for (const child of Array.from(carrier?.childNodes || [])) {
-        if (!(child?.nodeType === 1 && child.namespaceURI === NS_W && child.localName === 'r')) continue;
-        const length = getRunTextLength(getRunContentPieces(child));
-        if (localOffset <= offset + length) {
-            return clonePropertiesWithoutRevisionHistory(getDirectWordChild(child, 'rPr'));
-        }
-        offset += length;
-    }
-    return null;
-}
-
-const RESTORATION_PPR_ALLOWLIST = new Set([
-    'pStyle', 'numPr', 'ind', 'jc', 'spacing', 'tabs',
-    'keepNext', 'keepLines', 'outlineLvl', 'contextualSpacing'
-]);
-
-function wordAttribute(node, localName) {
-    return node?.getAttribute?.(`w:${localName}`) || node?.getAttribute?.(localName) || '';
-}
-
-function normalizedAuthor(author) {
-    return String(author || '').trim().toLowerCase();
-}
-
-function directWordParagraphSibling(paragraph, direction = 'nextSibling') {
-    let cursor = paragraph?.[direction] || null;
-    while (cursor) {
-        if (cursor.nodeType === 1 && cursor.namespaceURI === NS_W && cursor.localName === 'p') return cursor;
-        cursor = cursor[direction] || null;
-    }
-    return null;
-}
-
-function createSanitizedRestorationPPr(xmlDoc, sourceParagraph) {
-    const sourcePPr = getDirectWordChild(sourceParagraph, 'pPr');
-    const pPr = createWordElement(xmlDoc, 'w:pPr');
-    if (!sourcePPr) return pPr;
-    for (const child of Array.from(sourcePPr.childNodes || [])) {
-        if (child.nodeType !== 1 || child.namespaceURI !== NS_W) continue;
-        if (!RESTORATION_PPR_ALLOWLIST.has(child.localName)) continue;
-        pPr.appendChild(xmlDoc.importNode(child, true));
-    }
-    return pPr;
-}
-
-function collectRestorationAnchorWarnings(sourceParagraph) {
-    const warnings = [];
-    const bookmarkNames = new Set();
-    for (const node of Array.from(sourceParagraph?.getElementsByTagNameNS?.(NS_W, 'bookmarkStart') || [])) {
-        const name = wordAttribute(node, 'name') || '(unnamed)';
-        bookmarkNames.add(name);
-    }
-    for (const name of bookmarkNames) warnings.push(`RESTORATION_DROPPED_BOOKMARK:${name}`);
-
-    const commentIds = new Set();
-    for (const localName of ['commentRangeStart', 'commentRangeEnd', 'commentReference']) {
-        for (const node of Array.from(sourceParagraph?.getElementsByTagNameNS?.(NS_W, localName) || [])) {
-            const id = wordAttribute(node, 'id');
-            if (id !== '') commentIds.add(id);
-        }
-    }
-    for (const id of commentIds) warnings.push(`RESTORATION_DROPPED_COMMENT:${id}`);
-    return warnings;
-}
-
-function removeRestorationAnchors(paragraph) {
-    const anchorNames = [
-        'bookmarkStart', 'bookmarkEnd',
-        'commentRangeStart', 'commentRangeEnd', 'commentReference'
-    ];
-    for (const localName of anchorNames) {
-        for (const node of Array.from(paragraph?.getElementsByTagNameNS?.(NS_W, localName) || [])) {
-            node.parentNode?.removeChild(node);
-        }
-    }
-    for (const run of Array.from(paragraph?.getElementsByTagNameNS?.(NS_W, 'r') || [])) {
-        const meaningful = Array.from(run.childNodes || []).some(child => (
-            child.nodeType === 1 && child.namespaceURI === NS_W && child.localName !== 'rPr'
-        ));
-        if (!meaningful) run.parentNode?.removeChild(run);
-    }
-}
-
-function buildRejectedRestorationTemplate(xmlDoc, sourceParagraph, serializer) {
-    const rejected = rejectTrackedChangesInOoxml(serializer.serializeToString(sourceParagraph), { allAuthors: true });
-    const parsed = parseOoxmlSafe(rejected.oxml, 'application/xml');
-    const rejectedParagraph = parsed.doc?.getElementsByTagNameNS?.(NS_W, 'p')?.[0] || null;
-    if (!rejectedParagraph) return null;
-
-    const paragraph = createWordElement(xmlDoc, 'w:p');
-    paragraph.appendChild(createSanitizedRestorationPPr(xmlDoc, sourceParagraph));
-    for (const child of Array.from(rejectedParagraph.childNodes || [])) {
-        if (child.nodeType === 1 && child.namespaceURI === NS_W && child.localName === 'pPr') continue;
-        paragraph.appendChild(xmlDoc.importNode(child, true));
-    }
-    removeRestorationAnchors(paragraph);
-    return paragraph;
-}
-
-async function editRestorationTemplate(xmlDoc, template, modifiedText, author, serializer) {
-    const originalText = extractCanonicalParagraphText(template);
-    if (originalText === modifiedText) return template;
-    const result = await applyRedlineToOxml(
-        serializer.serializeToString(template),
-        originalText,
-        modifiedText,
-        {
-            author,
-            generateRedlines: false,
-            structuredContent: false
-        }
-    );
-    if (result?.status === 'error' || typeof result?.oxml !== 'string') return null;
-    const extracted = extractReplacementNodes(result.oxml);
-    const paragraph = (extracted.replacementNodes || []).find(node => (
-        node?.nodeType === 1 && node.namespaceURI === NS_W && node.localName === 'p'
-    ));
-    return paragraph ? xmlDoc.importNode(paragraph, true) : null;
-}
-
-function allocateFreshParagraphId(xmlDoc, operationSession) {
-    const used = new Set(getDocumentParagraphNodes(xmlDoc)
-        .map(paragraph => paragraph.getAttributeNS?.(NS_W14, 'paraId') || paragraph.getAttribute?.('w14:paraId') || '')
-        .filter(Boolean)
-        .map(value => value.toUpperCase()));
-    let candidate = null;
-    do {
-        candidate = operationSession?.generateParagraphId?.()
-            || (0x40000000 + used.size + 1).toString(16).toUpperCase();
-    } while (used.has(candidate.toUpperCase()));
-    return candidate;
-}
-
-function trackRestoredParagraph(xmlDoc, paragraph, author, operationSession) {
-    const root = xmlDoc.documentElement;
-    if (root && !root.getAttribute('xmlns:w14')) root.setAttribute('xmlns:w14', NS_W14);
-    return wrapParagraphContentInInsertion(xmlDoc, paragraph, null, author, {
-        paragraphId: allocateFreshParagraphId(xmlDoc, operationSession),
-        sanitizeParagraphProperties: true,
-        trackParagraphMark: true
-    });
-}
-
-function isInsertedParagraphByAuthor(paragraph, author) {
-    const pPr = getDirectWordChild(paragraph, 'pPr');
-    const rPr = getDirectWordChild(pPr, 'rPr');
-    const marker = getDirectWordChild(rPr, 'ins');
-    return !!marker && normalizedAuthor(wordAttribute(marker, 'author')) === normalizedAuthor(author);
-}
-
-function followingParagraphBlock(lastSource, count) {
-    const paragraphs = [];
-    let cursor = lastSource;
-    for (let i = 0; i < count; i++) {
-        cursor = directWordParagraphSibling(cursor, 'nextSibling');
-        if (!cursor) return [];
-        paragraphs.push(cursor);
-    }
-    return paragraphs;
-}
-
-function paragraphTextVector(oxml) {
-    const parsed = parseOoxmlSafe(oxml, 'application/xml');
-    if (parsed.error || !parsed.doc) return null;
-    return getDocumentParagraphNodes(parsed.doc).map(paragraph => extractCanonicalParagraphText(paragraph));
-}
-
-function sameTextVector(left, right) {
-    return Array.isArray(left) && Array.isArray(right)
-        && left.length === right.length
-        && left.every((value, index) => value === right[index]);
-}
-
-function lifecycleTextVector(oxml, action) {
-    const result = action === 'accept'
-        ? acceptTrackedChangesInOoxml(oxml, { allAuthors: true })
-        : rejectTrackedChangesInOoxml(oxml, { allAuthors: true });
-    return paragraphTextVector(result.oxml);
-}
-
-function buildExpectedRestorationDocument(beforeXml, sourceStartIndex, existingIndexes, templates) {
-    const parsed = parseOoxmlSafe(beforeXml, 'application/xml');
-    if (parsed.error || !parsed.doc) return null;
-    const expectedDoc = parsed.doc;
-    const originalParagraphs = getDocumentParagraphNodes(expectedDoc);
-    const lastSource = originalParagraphs[sourceStartIndex + templates.length - 1] || null;
-    if (!lastSource?.parentNode) return null;
-
-    for (const index of [...existingIndexes].sort((a, b) => b - a)) {
-        const paragraph = originalParagraphs[index];
-        paragraph?.parentNode?.removeChild(paragraph);
-    }
-    const insertionPoint = lastSource.nextSibling;
-    for (const template of templates) {
-        lastSource.parentNode.insertBefore(expectedDoc.importNode(template, true), insertionPoint);
-    }
-    return createSerializer().serializeToString(expectedDoc);
-}
-
-function verifyParagraphRestorationLifecycle(beforeXml, outputXml, sourceStartIndex, existingIndexes, templates, insertedParagraphs = []) {
-    const baselineValidation = validateRedlineOoxml(beforeXml);
-    const outputValidation = validateRedlineOoxml(outputXml);
-    const generatedIssues = subtractValidationIssueMultiset(outputValidation.issues, baselineValidation.issues);
-    const envelopeIssues = insertedParagraphs.flatMap(paragraph => (
-        validateRedlineOoxml(createSerializer().serializeToString(paragraph)).issues
-            .filter(issue => issue.severity === 'error')
-    ));
-    const generatedErrors = validationErrors(generatedIssues);
-    if (generatedErrors.length > 0 || envelopeIssues.length > 0) {
-        return {
-            valid: false,
-            stage: 'validation',
-            code: 'GENERATED_OOXML_INVALID',
-            generatedIssues,
-            envelopeIssues,
-            message: [...generatedErrors, ...envelopeIssues].map(issue => issue.message).join(' ')
-        };
-    }
-
-    const expectedXml = buildExpectedRestorationDocument(beforeXml, sourceStartIndex, existingIndexes, templates);
-    if (!expectedXml) return { valid: false, stage: 'expected-document', message: 'Could not construct the restoration lifecycle oracle.' };
-
-    const comparisons = [
-        ['current', paragraphTextVector(expectedXml), paragraphTextVector(outputXml)],
-        ['accept-all', lifecycleTextVector(expectedXml, 'accept'), lifecycleTextVector(outputXml, 'accept')],
-        ['reject-all', lifecycleTextVector(beforeXml, 'reject'), lifecycleTextVector(outputXml, 'reject')]
-    ];
-    for (const [stage, expected, actual] of comparisons) {
-        if (!sameTextVector(expected, actual)) {
-            return {
-                valid: false,
-                stage,
-                expected,
-                actual,
-                message: `Paragraph restoration ${stage} lifecycle text did not match the expected body-scoped paragraph sequence.`
-            };
-        }
-    }
-    return { valid: true };
-}
-
-/**
- * Inserts a new tracked run at an exact offset inside text visible only in the
- * rejected view of a wholly deleted paragraph. The foreign deletion is split,
- * never rewritten or re-authored.
- */
-export async function insertIntoRejectedDeletedText(
-    documentXml,
-    targetText,
-    anchor,
-    modified,
-    author,
-    targetRef = null,
-    runtimeContext = null,
-    options = {}
-) {
-    const { serializer, xmlDoc, operationSession } = resolveMutationDocument(documentXml, options);
-    if (!xmlDoc) {
-        return {
-            documentXml,
-            hasChanges: false,
-            status: 'error',
-            error: { code: 'PARSE_ERROR', message: 'Could not parse document OOXML.' }
-        };
-    }
-
-    const resolved = resolveTargetParagraph(xmlDoc, targetText, targetRef, 'insert', runtimeContext, options);
-    if (resolved?.error || !resolved?.paragraph) {
-        return {
-            documentXml,
-            hasChanges: false,
-            status: 'error',
-            error: resolved?.error || { code: 'TARGET_NOT_FOUND', message: 'Rejected-view insertion target was not found.' }
-        };
-    }
-
-    const paragraph = resolved.paragraph;
-    const state = inspectForeignDeletedParagraphTarget(paragraph, author);
-    if (!state.matches) {
-        return {
-            documentXml,
-            hasChanges: false,
-            status: 'error',
-            error: {
-                code: 'REJECTED_INSERTION_STATE_REQUIRED',
-                message: 'Rejected-view insertion requires a wholly deleted paragraph owned by another author.'
-            }
-        };
-    }
-    const structuralRefusal = getParagraphRestorationRefusal(paragraph, { requireFollowingParagraph: false });
-    if (structuralRefusal) {
-        return { documentXml, hasChanges: false, status: 'error', error: structuralRefusal };
-    }
-    if (/\r|\n/.test(modified)) {
-        return {
-            documentXml,
-            hasChanges: false,
-            status: 'error',
-            error: {
-                code: 'UNSAFE_PARAGRAPH_BOUNDARY',
-                message: 'Rejected-view insertion supports run-level text only; use restore for paragraph boundaries.'
-            }
-        };
-    }
-
-    const rejectedText = extractCanonicalParagraphText(paragraph, { revisionView: 'rejected' });
-    if (!anchor.occurrenceExplicit && countNonOverlappingOccurrences(rejectedText, anchor.exactText) > 1) {
-        return {
-            documentXml,
-            hasChanges: false,
-            status: 'error',
-            error: {
-                code: 'AMBIGUOUS_ANCHOR',
-                message: 'The rejected-view insertion anchor is repeated; provide anchor.occurrence explicitly.'
-            }
-        };
-    }
-    const anchorStart = findOccurrenceOffset(rejectedText, anchor.exactText, anchor.occurrence);
-    if (anchorStart < 0) {
-        return {
-            documentXml,
-            hasChanges: false,
-            status: 'error',
-            error: { code: 'ANCHOR_NOT_FOUND', message: 'The rejected-view insertion anchor was not found at the requested occurrence.' }
-        };
-    }
-    const insertionOffset = anchorStart + anchor.offset;
-    const carriers = Array.from(paragraph.childNodes || []).filter(
-        node => node?.nodeType === 1 && node.namespaceURI === NS_W && node.localName === 'del'
-    );
-    if (carriers.some(carrier => hasUnsupportedDeletionSplitMarkup(paragraph, carrier))) {
-        return {
-            documentXml,
-            hasChanges: false,
-            status: 'error',
-            error: {
-                code: 'UNSAFE_REVISION_BOUNDARY',
-                message: 'The rejected-view insertion boundary contains comments, bookmarks, fields, hyperlinks, moves, or non-text run markup that cannot be split safely.'
-            }
-        };
-    }
-    let carrierStart = 0;
-    let targetCarrier = null;
-    let carrierOffset = 0;
-    for (const carrier of carriers) {
-        const length = directDeletionCarrierText(carrier).length;
-        if (insertionOffset >= carrierStart && insertionOffset <= carrierStart + length) {
-            targetCarrier = carrier;
-            carrierOffset = insertionOffset - carrierStart;
-            break;
-        }
-        carrierStart += length;
-    }
-    if (!targetCarrier || carriers.map(directDeletionCarrierText).join('') !== rejectedText) {
-        return {
-            documentXml,
-            hasChanges: false,
-            status: 'error',
-            error: {
-                code: 'UNSAFE_REVISION_NESTING',
-                message: 'The rejected-view anchor is not contained in a supported direct deletion carrier.'
-            }
-        };
-    }
-
-    const runProperties = insertedRunPropertiesAtDeletionOffset(targetCarrier, carrierOffset);
-    const { leftCarrier, rightCarrier } = splitTrackChangeCarrier(
-        xmlDoc,
-        targetCarrier,
-        carrierOffset,
-        options._revisionIdAllocator || null
-    );
-    const insertion = createWordElement(xmlDoc, 'w:ins');
-    const metadata = createRevisionMetadata(author, options._revisionIdAllocator || xmlDoc, 'ins');
-    insertion.setAttribute('w:id', String(metadata.id));
-    insertion.setAttribute('w:author', metadata.author);
-    insertion.setAttribute('w:date', metadata.date);
-    const run = createWordElement(xmlDoc, 'w:r');
-    if (runProperties) run.appendChild(runProperties);
-    const textNode = createWordElement(xmlDoc, 'w:t');
-    if (/^\s|\s$/.test(modified)) textNode.setAttribute('xml:space', 'preserve');
-    textNode.textContent = modified;
-    run.appendChild(textNode);
-    insertion.appendChild(run);
-
-    const parent = targetCarrier.parentNode;
-    if (leftCarrier) parent.insertBefore(leftCarrier, targetCarrier);
-    parent.insertBefore(insertion, targetCarrier);
-    if (rightCarrier) parent.insertBefore(rightCarrier, targetCarrier);
-    options?._mutationRemovedNodes?.push(targetCarrier);
-    parent.removeChild(targetCarrier);
-    options?._mutationLiveNodes?.push(paragraph, insertion);
-    operationSession?.invalidateParagraphMetadata?.();
-
-    const outputXml = serializer.serializeToString(xmlDoc);
-    const outputRejected = extractCanonicalParagraphText(paragraph, { revisionView: 'rejected' });
-    const outputAccepted = extractCanonicalParagraphText(paragraph, { revisionView: 'accepted' });
-    if (outputRejected !== rejectedText || !outputAccepted.includes(modified)) {
-        return {
-            documentXml,
-            hasChanges: false,
-            status: 'error',
-            error: {
-                code: 'PATCH_ROUNDTRIP_MISMATCH',
-                message: 'Rejected-view insertion did not preserve the deleted source and expose the requested inserted text.'
-            }
-        };
-    }
-    return { documentXml: outputXml, hasChanges: true, status: 'ok' };
-}
-
-/**
- * Materializes an explicit counterproposal for one or more paragraphs wholly
- * deleted (content and paragraph mark) by another author.
- */
-export async function restoreDeletedParagraphByExactText(
-    documentXml,
-    targetText,
-    modified,
-    author,
-    targetRef = null,
-    targetEndRef = null,
-    runtimeContext = null,
-    options = {}
-) {
-    const { serializer, xmlDoc, operationSession } = resolveMutationDocument(documentXml, options);
-    if (!xmlDoc) {
-        return {
-            documentXml,
-            hasChanges: false,
-            status: 'error',
-            error: { code: 'PARSE_ERROR', message: 'Could not parse document OOXML.' }
-        };
-    }
-
-    const resolved = resolveTargetParagraph(xmlDoc, targetText, targetRef, 'restore', runtimeContext, options);
-    if (resolved?.error || !resolved?.paragraph) {
-        return {
-            documentXml,
-            hasChanges: false,
-            status: 'error',
-            error: resolved?.error || { code: 'TARGET_NOT_FOUND', message: 'Restoration target paragraph not found.' }
-        };
-    }
-
-    const firstSource = resolved.paragraph;
-    let sourceParagraphs = [firstSource];
-    if (options._compiledSourceEndId) {
-        const endResolved = resolveTargetParagraph(
-            xmlDoc,
-            options.targetEndDescriptor?.text || '',
-            targetEndRef,
-            'restore',
-            runtimeContext,
-            { ...options, _compiledSourceId: options._compiledSourceEndId }
-        );
-        const allParagraphs = endResolved?.paragraph ? getDocumentParagraphNodes(xmlDoc) : [];
-        const startIndex = allParagraphs.indexOf(firstSource);
-        const endIndex = allParagraphs.indexOf(endResolved?.paragraph);
-        sourceParagraphs = startIndex >= 0 && endIndex >= startIndex
-            ? allParagraphs.slice(startIndex, endIndex + 1)
-            : null;
-    } else if (targetEndRef) {
-        sourceParagraphs = resolveParagraphRangeByRefs(xmlDoc, targetRef, targetEndRef, {
-            opType: 'restore',
-            targetRefSnapshot: runtimeContext?.targetRefSnapshot || null,
-            onInfo: options.onInfo,
-            onWarn: options.onWarn
-        });
-    } else if (options.targetEndDescriptor) {
-        const endResolved = resolveTargetParagraph(
-            xmlDoc,
-            options.targetEndDescriptor.text,
-            options.targetEndDescriptor.index,
-            'restore',
-            runtimeContext,
-            {
-                ...options,
-                targetDescriptor: options.targetEndDescriptor,
-                _compiledSourceId: options._compiledSourceEndId || null
-            }
-        );
-        const allParagraphs = endResolved?.paragraph ? getDocumentParagraphNodes(xmlDoc) : [];
-        const startIndex = allParagraphs.indexOf(firstSource);
-        const endIndex = allParagraphs.indexOf(endResolved?.paragraph);
-        sourceParagraphs = startIndex >= 0 && endIndex >= startIndex
-            ? allParagraphs.slice(startIndex, endIndex + 1)
-            : null;
-    }
-    if (!Array.isArray(sourceParagraphs) || sourceParagraphs.length === 0 || sourceParagraphs[0] !== firstSource) {
-        return {
-            documentXml,
-            hasChanges: false,
-            status: 'error',
-            error: {
-                code: 'RESTORATION_COUNT_MISMATCH',
-                message: 'The restoration range could not be resolved as a contiguous paragraph block.'
-            }
-        };
-    }
-
-    const replacements = Array.isArray(modified) ? modified.map(String) : [String(modified || '')];
-    if (replacements.length !== sourceParagraphs.length || replacements.some(text => text.length === 0)) {
-        return {
-            documentXml,
-            hasChanges: false,
-            status: 'error',
-            error: {
-                code: 'RESTORATION_COUNT_MISMATCH',
-                message: `Restoration requires exactly one non-empty replacement per source paragraph (${sourceParagraphs.length} expected, ${replacements.length} received).`
-            }
-        };
-    }
-
-    const parent = firstSource.parentNode;
-    if (!parent || sourceParagraphs.some(paragraph => paragraph.parentNode !== parent)) {
-        return {
-            documentXml,
-            hasChanges: false,
-            status: 'error',
-            error: {
-                code: 'UNSAFE_PARAGRAPH_PLACEMENT',
-                message: 'Restoration source paragraphs must be a contiguous block in one structural container.'
-            }
-        };
-    }
-
-    for (const paragraph of sourceParagraphs) {
-        const structuralRefusal = getParagraphRestorationRefusal(paragraph);
-        if (structuralRefusal?.code === 'UNSUPPORTED_MOVE_REVISION') {
-            return {
-                documentXml,
-                hasChanges: false,
-                status: 'error',
-                error: structuralRefusal
-            };
-        }
-        const state = inspectForeignDeletedParagraphTarget(paragraph, author);
-        if (!state.matches) {
-            return {
-                documentXml,
-                hasChanges: false,
-                status: 'error',
-                error: {
-                    code: 'RESTORATION_STATE_REQUIRED',
-                    message: state.hasParagraphMarkDeletion && !state.foreignParagraphMarkDeletion
-                        ? 'Explicit cross-author restoration does not apply to a paragraph deleted by the current author; use merge-same-author.'
-                        : 'Explicit restoration requires a foreign paragraph-mark deletion with every pre-existing content node deleted.',
-                    ...(state.ownerAuthor ? { ownerAuthor: state.ownerAuthor } : {})
-                }
-            };
-        }
-        const refusal = structuralRefusal || getParagraphRestorationRefusal(paragraph);
-        if (refusal) {
-            return {
-                documentXml,
-                hasChanges: false,
-                status: 'error',
-                error: refusal
-            };
-        }
-    }
-
-    const lastSource = sourceParagraphs[sourceParagraphs.length - 1];
-    const existingBlock = followingParagraphBlock(lastSource, sourceParagraphs.length);
-    const hasExistingRestoration = existingBlock.length === sourceParagraphs.length
-        && existingBlock.every(paragraph => isInsertedParagraphByAuthor(paragraph, author));
-    if (
-        hasExistingRestoration
-        && existingBlock.every((paragraph, index) => extractCanonicalParagraphText(paragraph) === replacements[index])
-    ) {
-        return {
-            documentXml,
-            hasChanges: false,
-            status: 'no-op',
-            warnings: ['An identical same-author paragraph restoration already exists.']
-        };
-    }
-
-    const beforeXml = serializer.serializeToString(xmlDoc);
-    const beforeParagraphs = getDocumentParagraphNodes(xmlDoc);
-    const sourceStartIndex = beforeParagraphs.indexOf(firstSource);
-    const existingIndexes = hasExistingRestoration
-        ? existingBlock.map(paragraph => beforeParagraphs.indexOf(paragraph))
-        : [];
-    const templates = [];
-    const warnings = [];
-    for (let index = 0; index < sourceParagraphs.length; index++) {
-        const source = sourceParagraphs[index];
-        warnings.push(...collectRestorationAnchorWarnings(source));
-        const template = buildRejectedRestorationTemplate(xmlDoc, source, serializer);
-        const edited = template
-            ? await editRestorationTemplate(xmlDoc, template, replacements[index], author, serializer)
-            : null;
-        if (!edited) {
-            return {
-                documentXml,
-                hasChanges: false,
-                status: 'error',
-                error: {
-                    code: 'PATCH_ROUNDTRIP_MISMATCH',
-                    message: `Could not reconstruct restoration paragraph ${index + 1} from its rejected revision view.`
-                }
-            };
-        }
-        templates.push(edited);
-    }
-
-    const insertedParagraphs = templates.map(template => {
-        const paragraph = xmlDoc.importNode(template, true);
-        return trackRestoredParagraph(xmlDoc, paragraph, author, operationSession);
-    });
-    const insertionPoint = lastSource.nextSibling;
-    for (const paragraph of insertedParagraphs) parent.insertBefore(paragraph, insertionPoint);
-    if (hasExistingRestoration) {
-        for (const paragraph of existingBlock) {
-            options?._mutationRemovedNodes?.push(paragraph);
-            paragraph.parentNode?.removeChild(paragraph);
-        }
-    }
-    options?._mutationLiveNodes?.push(...insertedParagraphs);
-    normalizeBodySectionOrder(xmlDoc);
-
-    const outputXml = serializer.serializeToString(xmlDoc);
-    const oracle = verifyParagraphRestorationLifecycle(
-        beforeXml,
-        outputXml,
-        sourceStartIndex,
-        existingIndexes,
-        templates,
-        insertedParagraphs
-    );
-    if (!oracle.valid) {
-        return {
-            documentXml,
-            hasChanges: false,
-            status: 'error',
-            error: {
-                code: oracle.code || 'PATCH_ROUNDTRIP_MISMATCH',
-                message: oracle.message,
-                stage: oracle.stage,
-                ...(oracle.generatedIssues ? { generatedIssues: oracle.generatedIssues } : {}),
-                ...(oracle.envelopeIssues ? { envelopeIssues: oracle.envelopeIssues } : {}),
-                ...(oracle.expected ? { expected: oracle.expected } : {}),
-                ...(oracle.actual ? { actual: oracle.actual } : {})
-            }
-        };
-    }
-
-    return {
-        documentXml: completedDocumentXml(xmlDoc, serializer, documentXml, operationSession),
-        hasChanges: true,
-        status: 'ok',
-        numberingXml: null,
-        ...(warnings.length > 0 ? { warnings: [...new Set(warnings)] } : {})
-    };
-}
+}
+
+function directDeletionCarrierText(carrier) {
+    return Array.from(carrier?.childNodes || []).reduce((text, child) => {
+        return text + (child?.nodeType === 1 && child.namespaceURI === NS_W && child.localName === 'r'
+            ? getRunContentPieces(child).map(piece => piece.text).join('')
+            : '');
+    }, '');
+}
+
+function findOccurrenceOffset(text, needle, occurrence) {
+    let from = 0;
+    let found = -1;
+    for (let index = 0; index < occurrence; index++) {
+        found = text.indexOf(needle, from);
+        if (found < 0) return -1;
+        from = found + Math.max(needle.length, 1);
+    }
+    return found;
+}
+
+function countNonOverlappingOccurrences(text, needle) {
+    if (!needle) return 0;
+    let count = 0;
+    let from = 0;
+    while (from <= text.length) {
+        const found = text.indexOf(needle, from);
+        if (found < 0) break;
+        count += 1;
+        from = found + needle.length;
+    }
+    return count;
+}
+
+function hasUnsupportedDeletionSplitMarkup(paragraph, carrier) {
+    const unsafeParagraphNames = new Set([
+        'commentRangeStart', 'commentRangeEnd', 'commentReference',
+        'bookmarkStart', 'bookmarkEnd', 'moveFromRangeStart', 'moveFromRangeEnd',
+        'moveToRangeStart', 'moveToRangeEnd'
+    ]);
+    if (Array.from(paragraph.getElementsByTagName?.('*') || []).some(node => unsafeParagraphNames.has(node.localName))) {
+        return true;
+    }
+    for (const child of Array.from(carrier?.childNodes || [])) {
+        if (child.nodeType !== 1) continue;
+        if (!(child.namespaceURI === NS_W && child.localName === 'r')) return true;
+        for (const runChild of Array.from(child.childNodes || [])) {
+            if (runChild.nodeType !== 1 || runChild.namespaceURI !== NS_W) continue;
+            if (!['rPr', 'delText', 't', 'tab', 'br', 'cr', 'noBreakHyphen', 'softHyphen'].includes(runChild.localName)) return true;
+        }
+    }
+    return false;
+}
+
+function insertedRunPropertiesAtDeletionOffset(carrier, localOffset) {
+    let offset = 0;
+    for (const child of Array.from(carrier?.childNodes || [])) {
+        if (!(child?.nodeType === 1 && child.namespaceURI === NS_W && child.localName === 'r')) continue;
+        const length = getRunTextLength(getRunContentPieces(child));
+        if (localOffset <= offset + length) {
+            return clonePropertiesWithoutRevisionHistory(getDirectWordChild(child, 'rPr'));
+        }
+        offset += length;
+    }
+    return null;
+}
+
+const RESTORATION_PPR_ALLOWLIST = new Set([
+    'pStyle', 'numPr', 'ind', 'jc', 'spacing', 'tabs',
+    'keepNext', 'keepLines', 'outlineLvl', 'contextualSpacing'
+]);
+
+function wordAttribute(node, localName) {
+    return node?.getAttribute?.(`w:${localName}`) || node?.getAttribute?.(localName) || '';
+}
+
+function normalizedAuthor(author) {
+    return String(author || '').trim().toLowerCase();
+}
+
+function directWordParagraphSibling(paragraph, direction = 'nextSibling') {
+    let cursor = paragraph?.[direction] || null;
+    while (cursor) {
+        if (cursor.nodeType === 1 && cursor.namespaceURI === NS_W && cursor.localName === 'p') return cursor;
+        cursor = cursor[direction] || null;
+    }
+    return null;
+}
+
+function createSanitizedRestorationPPr(xmlDoc, sourceParagraph) {
+    const sourcePPr = getDirectWordChild(sourceParagraph, 'pPr');
+    const pPr = createWordElement(xmlDoc, 'w:pPr');
+    if (!sourcePPr) return pPr;
+    for (const child of Array.from(sourcePPr.childNodes || [])) {
+        if (child.nodeType !== 1 || child.namespaceURI !== NS_W) continue;
+        if (!RESTORATION_PPR_ALLOWLIST.has(child.localName)) continue;
+        pPr.appendChild(xmlDoc.importNode(child, true));
+    }
+    return pPr;
+}
+
+function collectRestorationAnchorWarnings(sourceParagraph) {
+    const warnings = [];
+    const bookmarkNames = new Set();
+    for (const node of Array.from(sourceParagraph?.getElementsByTagNameNS?.(NS_W, 'bookmarkStart') || [])) {
+        const name = wordAttribute(node, 'name') || '(unnamed)';
+        bookmarkNames.add(name);
+    }
+    for (const name of bookmarkNames) warnings.push(`RESTORATION_DROPPED_BOOKMARK:${name}`);
+
+    const commentIds = new Set();
+    for (const localName of ['commentRangeStart', 'commentRangeEnd', 'commentReference']) {
+        for (const node of Array.from(sourceParagraph?.getElementsByTagNameNS?.(NS_W, localName) || [])) {
+            const id = wordAttribute(node, 'id');
+            if (id !== '') commentIds.add(id);
+        }
+    }
+    for (const id of commentIds) warnings.push(`RESTORATION_DROPPED_COMMENT:${id}`);
+    return warnings;
+}
+
+function removeRestorationAnchors(paragraph) {
+    const anchorNames = [
+        'bookmarkStart', 'bookmarkEnd',
+        'commentRangeStart', 'commentRangeEnd', 'commentReference'
+    ];
+    for (const localName of anchorNames) {
+        for (const node of Array.from(paragraph?.getElementsByTagNameNS?.(NS_W, localName) || [])) {
+            node.parentNode?.removeChild(node);
+        }
+    }
+    for (const run of Array.from(paragraph?.getElementsByTagNameNS?.(NS_W, 'r') || [])) {
+        const meaningful = Array.from(run.childNodes || []).some(child => (
+            child.nodeType === 1 && child.namespaceURI === NS_W && child.localName !== 'rPr'
+        ));
+        if (!meaningful) run.parentNode?.removeChild(run);
+    }
+}
+
+function buildRejectedRestorationTemplate(xmlDoc, sourceParagraph, serializer) {
+    const rejected = rejectTrackedChangesInOoxml(serializer.serializeToString(sourceParagraph), { allAuthors: true });
+    const parsed = parseOoxmlSafe(rejected.oxml, 'application/xml');
+    const rejectedParagraph = parsed.doc?.getElementsByTagNameNS?.(NS_W, 'p')?.[0] || null;
+    if (!rejectedParagraph) return null;
+
+    const paragraph = createWordElement(xmlDoc, 'w:p');
+    paragraph.appendChild(createSanitizedRestorationPPr(xmlDoc, sourceParagraph));
+    for (const child of Array.from(rejectedParagraph.childNodes || [])) {
+        if (child.nodeType === 1 && child.namespaceURI === NS_W && child.localName === 'pPr') continue;
+        paragraph.appendChild(xmlDoc.importNode(child, true));
+    }
+    removeRestorationAnchors(paragraph);
+    return paragraph;
+}
+
+async function editRestorationTemplate(xmlDoc, template, modifiedText, author, serializer) {
+    const originalText = extractCanonicalParagraphText(template);
+    if (originalText === modifiedText) return template;
+    const result = await applyRedlineToOxml(
+        serializer.serializeToString(template),
+        originalText,
+        modifiedText,
+        {
+            author,
+            generateRedlines: false,
+            structuredContent: false
+        }
+    );
+    if (result?.status === 'error' || typeof result?.oxml !== 'string') return null;
+    const extracted = extractReplacementNodes(result.oxml);
+    const paragraph = (extracted.replacementNodes || []).find(node => (
+        node?.nodeType === 1 && node.namespaceURI === NS_W && node.localName === 'p'
+    ));
+    return paragraph ? xmlDoc.importNode(paragraph, true) : null;
+}
+
+function allocateFreshParagraphId(xmlDoc, operationSession) {
+    const used = new Set(getDocumentParagraphNodes(xmlDoc)
+        .map(paragraph => paragraph.getAttributeNS?.(NS_W14, 'paraId') || paragraph.getAttribute?.('w14:paraId') || '')
+        .filter(Boolean)
+        .map(value => value.toUpperCase()));
+    let candidate = null;
+    do {
+        candidate = operationSession?.generateParagraphId?.()
+            || (0x40000000 + used.size + 1).toString(16).toUpperCase();
+    } while (used.has(candidate.toUpperCase()));
+    return candidate;
+}
+
+function trackRestoredParagraph(xmlDoc, paragraph, author, operationSession) {
+    const root = xmlDoc.documentElement;
+    if (root && !root.getAttribute('xmlns:w14')) root.setAttribute('xmlns:w14', NS_W14);
+    return wrapParagraphContentInInsertion(xmlDoc, paragraph, null, author, {
+        paragraphId: allocateFreshParagraphId(xmlDoc, operationSession),
+        sanitizeParagraphProperties: true,
+        trackParagraphMark: true
+    });
+}
+
+function isInsertedParagraphByAuthor(paragraph, author) {
+    const pPr = getDirectWordChild(paragraph, 'pPr');
+    const rPr = getDirectWordChild(pPr, 'rPr');
+    const marker = getDirectWordChild(rPr, 'ins');
+    return !!marker && normalizedAuthor(wordAttribute(marker, 'author')) === normalizedAuthor(author);
+}
+
+function followingParagraphBlock(lastSource, count) {
+    const paragraphs = [];
+    let cursor = lastSource;
+    for (let i = 0; i < count; i++) {
+        cursor = directWordParagraphSibling(cursor, 'nextSibling');
+        if (!cursor) return [];
+        paragraphs.push(cursor);
+    }
+    return paragraphs;
+}
+
+function paragraphTextVector(oxml) {
+    const parsed = parseOoxmlSafe(oxml, 'application/xml');
+    if (parsed.error || !parsed.doc) return null;
+    return getDocumentParagraphNodes(parsed.doc).map(paragraph => extractCanonicalParagraphText(paragraph));
+}
+
+function sameTextVector(left, right) {
+    return Array.isArray(left) && Array.isArray(right)
+        && left.length === right.length
+        && left.every((value, index) => value === right[index]);
+}
+
+function lifecycleTextVector(oxml, action) {
+    const result = action === 'accept'
+        ? acceptTrackedChangesInOoxml(oxml, { allAuthors: true })
+        : rejectTrackedChangesInOoxml(oxml, { allAuthors: true });
+    return paragraphTextVector(result.oxml);
+}
+
+function buildExpectedRestorationDocument(beforeXml, sourceStartIndex, existingIndexes, templates) {
+    const parsed = parseOoxmlSafe(beforeXml, 'application/xml');
+    if (parsed.error || !parsed.doc) return null;
+    const expectedDoc = parsed.doc;
+    const originalParagraphs = getDocumentParagraphNodes(expectedDoc);
+    const lastSource = originalParagraphs[sourceStartIndex + templates.length - 1] || null;
+    if (!lastSource?.parentNode) return null;
+
+    for (const index of [...existingIndexes].sort((a, b) => b - a)) {
+        const paragraph = originalParagraphs[index];
+        paragraph?.parentNode?.removeChild(paragraph);
+    }
+    const insertionPoint = lastSource.nextSibling;
+    for (const template of templates) {
+        lastSource.parentNode.insertBefore(expectedDoc.importNode(template, true), insertionPoint);
+    }
+    return createSerializer().serializeToString(expectedDoc);
+}
+
+function verifyParagraphRestorationLifecycle(beforeXml, outputXml, sourceStartIndex, existingIndexes, templates, insertedParagraphs = []) {
+    const baselineValidation = validateRedlineOoxml(beforeXml);
+    const outputValidation = validateRedlineOoxml(outputXml);
+    const generatedIssues = subtractValidationIssueMultiset(outputValidation.issues, baselineValidation.issues);
+    const envelopeIssues = insertedParagraphs.flatMap(paragraph => (
+        validateRedlineOoxml(createSerializer().serializeToString(paragraph)).issues
+            .filter(issue => issue.severity === 'error')
+    ));
+    const generatedErrors = validationErrors(generatedIssues);
+    if (generatedErrors.length > 0 || envelopeIssues.length > 0) {
+        return {
+            valid: false,
+            stage: 'validation',
+            code: 'GENERATED_OOXML_INVALID',
+            generatedIssues,
+            envelopeIssues,
+            message: [...generatedErrors, ...envelopeIssues].map(issue => issue.message).join(' ')
+        };
+    }
+
+    const expectedXml = buildExpectedRestorationDocument(beforeXml, sourceStartIndex, existingIndexes, templates);
+    if (!expectedXml) return { valid: false, stage: 'expected-document', message: 'Could not construct the restoration lifecycle oracle.' };
+
+    const comparisons = [
+        ['current', paragraphTextVector(expectedXml), paragraphTextVector(outputXml)],
+        ['accept-all', lifecycleTextVector(expectedXml, 'accept'), lifecycleTextVector(outputXml, 'accept')],
+        ['reject-all', lifecycleTextVector(beforeXml, 'reject'), lifecycleTextVector(outputXml, 'reject')]
+    ];
+    for (const [stage, expected, actual] of comparisons) {
+        if (!sameTextVector(expected, actual)) {
+            return {
+                valid: false,
+                stage,
+                expected,
+                actual,
+                message: `Paragraph restoration ${stage} lifecycle text did not match the expected body-scoped paragraph sequence.`
+            };
+        }
+    }
+    return { valid: true };
+}
+
+/**
+ * Inserts a new tracked run at an exact offset inside text visible only in the
+ * rejected view of a wholly deleted paragraph. The foreign deletion is split,
+ * never rewritten or re-authored.
+ */
+export async function insertIntoRejectedDeletedText(
+    documentXml,
+    targetText,
+    anchor,
+    modified,
+    author,
+    targetRef = null,
+    runtimeContext = null,
+    options = {}
+) {
+    const { serializer, xmlDoc, operationSession } = resolveMutationDocument(documentXml, options);
+    if (!xmlDoc) {
+        return {
+            documentXml,
+            hasChanges: false,
+            status: 'error',
+            error: { code: 'PARSE_ERROR', message: 'Could not parse document OOXML.' }
+        };
+    }
+
+    const resolved = resolveTargetParagraph(xmlDoc, targetText, targetRef, 'insert', runtimeContext, options);
+    if (resolved?.error || !resolved?.paragraph) {
+        return {
+            documentXml,
+            hasChanges: false,
+            status: 'error',
+            error: resolved?.error || { code: 'TARGET_NOT_FOUND', message: 'Rejected-view insertion target was not found.' }
+        };
+    }
+
+    const paragraph = resolved.paragraph;
+    const state = inspectForeignDeletedParagraphTarget(paragraph, author);
+    if (!state.matches) {
+        return {
+            documentXml,
+            hasChanges: false,
+            status: 'error',
+            error: {
+                code: 'REJECTED_INSERTION_STATE_REQUIRED',
+                message: 'Rejected-view insertion requires a wholly deleted paragraph owned by another author.'
+            }
+        };
+    }
+    const structuralRefusal = getParagraphRestorationRefusal(paragraph, { requireFollowingParagraph: false });
+    if (structuralRefusal) {
+        return { documentXml, hasChanges: false, status: 'error', error: structuralRefusal };
+    }
+    if (/\r|\n/.test(modified)) {
+        return {
+            documentXml,
+            hasChanges: false,
+            status: 'error',
+            error: {
+                code: 'UNSAFE_PARAGRAPH_BOUNDARY',
+                message: 'Rejected-view insertion supports run-level text only; use restore for paragraph boundaries.'
+            }
+        };
+    }
+
+    const rejectedText = extractCanonicalParagraphText(paragraph, { revisionView: 'rejected' });
+    if (!anchor.occurrenceExplicit && countNonOverlappingOccurrences(rejectedText, anchor.exactText) > 1) {
+        return {
+            documentXml,
+            hasChanges: false,
+            status: 'error',
+            error: {
+                code: 'AMBIGUOUS_ANCHOR',
+                message: 'The rejected-view insertion anchor is repeated; provide anchor.occurrence explicitly.'
+            }
+        };
+    }
+    const anchorStart = findOccurrenceOffset(rejectedText, anchor.exactText, anchor.occurrence);
+    if (anchorStart < 0) {
+        return {
+            documentXml,
+            hasChanges: false,
+            status: 'error',
+            error: { code: 'ANCHOR_NOT_FOUND', message: 'The rejected-view insertion anchor was not found at the requested occurrence.' }
+        };
+    }
+    const insertionOffset = anchorStart + anchor.offset;
+    const carriers = Array.from(paragraph.childNodes || []).filter(
+        node => node?.nodeType === 1 && node.namespaceURI === NS_W && node.localName === 'del'
+    );
+    if (carriers.some(carrier => hasUnsupportedDeletionSplitMarkup(paragraph, carrier))) {
+        return {
+            documentXml,
+            hasChanges: false,
+            status: 'error',
+            error: {
+                code: 'UNSAFE_REVISION_BOUNDARY',
+                message: 'The rejected-view insertion boundary contains comments, bookmarks, fields, hyperlinks, moves, or non-text run markup that cannot be split safely.'
+            }
+        };
+    }
+    let carrierStart = 0;
+    let targetCarrier = null;
+    let carrierOffset = 0;
+    for (const carrier of carriers) {
+        const length = directDeletionCarrierText(carrier).length;
+        if (insertionOffset >= carrierStart && insertionOffset <= carrierStart + length) {
+            targetCarrier = carrier;
+            carrierOffset = insertionOffset - carrierStart;
+            break;
+        }
+        carrierStart += length;
+    }
+    if (!targetCarrier || carriers.map(directDeletionCarrierText).join('') !== rejectedText) {
+        return {
+            documentXml,
+            hasChanges: false,
+            status: 'error',
+            error: {
+                code: 'UNSAFE_REVISION_NESTING',
+                message: 'The rejected-view anchor is not contained in a supported direct deletion carrier.'
+            }
+        };
+    }
+
+    const runProperties = insertedRunPropertiesAtDeletionOffset(targetCarrier, carrierOffset);
+    const { leftCarrier, rightCarrier } = splitTrackChangeCarrier(
+        xmlDoc,
+        targetCarrier,
+        carrierOffset,
+        options._revisionIdAllocator || null
+    );
+    const insertion = createWordElement(xmlDoc, 'w:ins');
+    const metadata = createRevisionMetadata(author, options._revisionIdAllocator || xmlDoc, 'ins');
+    insertion.setAttribute('w:id', String(metadata.id));
+    insertion.setAttribute('w:author', metadata.author);
+    insertion.setAttribute('w:date', metadata.date);
+    const run = createWordElement(xmlDoc, 'w:r');
+    if (runProperties) run.appendChild(runProperties);
+    const textNode = createWordElement(xmlDoc, 'w:t');
+    if (/^\s|\s$/.test(modified)) textNode.setAttribute('xml:space', 'preserve');
+    textNode.textContent = modified;
+    run.appendChild(textNode);
+    insertion.appendChild(run);
+
+    const parent = targetCarrier.parentNode;
+    if (leftCarrier) parent.insertBefore(leftCarrier, targetCarrier);
+    parent.insertBefore(insertion, targetCarrier);
+    if (rightCarrier) parent.insertBefore(rightCarrier, targetCarrier);
+    options?._mutationRemovedNodes?.push(targetCarrier);
+    parent.removeChild(targetCarrier);
+    options?._mutationLiveNodes?.push(paragraph, insertion);
+    operationSession?.invalidateParagraphMetadata?.();
+
+    const outputXml = serializer.serializeToString(xmlDoc);
+    const outputRejected = extractCanonicalParagraphText(paragraph, { revisionView: 'rejected' });
+    const outputAccepted = extractCanonicalParagraphText(paragraph, { revisionView: 'accepted' });
+    if (outputRejected !== rejectedText || !outputAccepted.includes(modified)) {
+        return {
+            documentXml,
+            hasChanges: false,
+            status: 'error',
+            error: {
+                code: 'PATCH_ROUNDTRIP_MISMATCH',
+                message: 'Rejected-view insertion did not preserve the deleted source and expose the requested inserted text.'
+            }
+        };
+    }
+    return { documentXml: outputXml, hasChanges: true, status: 'ok' };
+}
+
+/**
+ * Materializes an explicit counterproposal for one or more paragraphs wholly
+ * deleted (content and paragraph mark) by another author.
+ */
+export async function restoreDeletedParagraphByExactText(
+    documentXml,
+    targetText,
+    modified,
+    author,
+    targetRef = null,
+    targetEndRef = null,
+    runtimeContext = null,
+    options = {}
+) {
+    const { serializer, xmlDoc, operationSession } = resolveMutationDocument(documentXml, options);
+    if (!xmlDoc) {
+        return {
+            documentXml,
+            hasChanges: false,
+            status: 'error',
+            error: { code: 'PARSE_ERROR', message: 'Could not parse document OOXML.' }
+        };
+    }
+
+    const resolved = resolveTargetParagraph(xmlDoc, targetText, targetRef, 'restore', runtimeContext, options);
+    if (resolved?.error || !resolved?.paragraph) {
+        return {
+            documentXml,
+            hasChanges: false,
+            status: 'error',
+            error: resolved?.error || { code: 'TARGET_NOT_FOUND', message: 'Restoration target paragraph not found.' }
+        };
+    }
+
+    const firstSource = resolved.paragraph;
+    let sourceParagraphs = [firstSource];
+    if (options._compiledSourceEndId) {
+        const endResolved = resolveTargetParagraph(
+            xmlDoc,
+            options.targetEndDescriptor?.text || '',
+            targetEndRef,
+            'restore',
+            runtimeContext,
+            { ...options, _compiledSourceId: options._compiledSourceEndId }
+        );
+        const allParagraphs = endResolved?.paragraph ? getDocumentParagraphNodes(xmlDoc) : [];
+        const startIndex = allParagraphs.indexOf(firstSource);
+        const endIndex = allParagraphs.indexOf(endResolved?.paragraph);
+        sourceParagraphs = startIndex >= 0 && endIndex >= startIndex
+            ? allParagraphs.slice(startIndex, endIndex + 1)
+            : null;
+    } else if (targetEndRef) {
+        sourceParagraphs = resolveParagraphRangeByRefs(xmlDoc, targetRef, targetEndRef, {
+            opType: 'restore',
+            targetRefSnapshot: runtimeContext?.targetRefSnapshot || null,
+            onInfo: options.onInfo,
+            onWarn: options.onWarn
+        });
+    } else if (options.targetEndDescriptor) {
+        const endResolved = resolveTargetParagraph(
+            xmlDoc,
+            options.targetEndDescriptor.text,
+            options.targetEndDescriptor.index,
+            'restore',
+            runtimeContext,
+            {
+                ...options,
+                targetDescriptor: options.targetEndDescriptor,
+                _compiledSourceId: options._compiledSourceEndId || null
+            }
+        );
+        const allParagraphs = endResolved?.paragraph ? getDocumentParagraphNodes(xmlDoc) : [];
+        const startIndex = allParagraphs.indexOf(firstSource);
+        const endIndex = allParagraphs.indexOf(endResolved?.paragraph);
+        sourceParagraphs = startIndex >= 0 && endIndex >= startIndex
+            ? allParagraphs.slice(startIndex, endIndex + 1)
+            : null;
+    }
+    if (!Array.isArray(sourceParagraphs) || sourceParagraphs.length === 0 || sourceParagraphs[0] !== firstSource) {
+        return {
+            documentXml,
+            hasChanges: false,
+            status: 'error',
+            error: {
+                code: 'RESTORATION_COUNT_MISMATCH',
+                message: 'The restoration range could not be resolved as a contiguous paragraph block.'
+            }
+        };
+    }
+
+    const replacements = Array.isArray(modified) ? modified.map(String) : [String(modified || '')];
+    if (replacements.length !== sourceParagraphs.length || replacements.some(text => text.length === 0)) {
+        return {
+            documentXml,
+            hasChanges: false,
+            status: 'error',
+            error: {
+                code: 'RESTORATION_COUNT_MISMATCH',
+                message: `Restoration requires exactly one non-empty replacement per source paragraph (${sourceParagraphs.length} expected, ${replacements.length} received).`
+            }
+        };
+    }
+
+    const parent = firstSource.parentNode;
+    if (!parent || sourceParagraphs.some(paragraph => paragraph.parentNode !== parent)) {
+        return {
+            documentXml,
+            hasChanges: false,
+            status: 'error',
+            error: {
+                code: 'UNSAFE_PARAGRAPH_PLACEMENT',
+                message: 'Restoration source paragraphs must be a contiguous block in one structural container.'
+            }
+        };
+    }
+
+    for (const paragraph of sourceParagraphs) {
+        const structuralRefusal = getParagraphRestorationRefusal(paragraph);
+        if (structuralRefusal?.code === 'UNSUPPORTED_MOVE_REVISION') {
+            return {
+                documentXml,
+                hasChanges: false,
+                status: 'error',
+                error: structuralRefusal
+            };
+        }
+        const state = inspectForeignDeletedParagraphTarget(paragraph, author);
+        if (!state.matches) {
+            return {
+                documentXml,
+                hasChanges: false,
+                status: 'error',
+                error: {
+                    code: 'RESTORATION_STATE_REQUIRED',
+                    message: state.hasParagraphMarkDeletion && !state.foreignParagraphMarkDeletion
+                        ? 'Explicit cross-author restoration does not apply to a paragraph deleted by the current author; use merge-same-author.'
+                        : 'Explicit restoration requires a foreign paragraph-mark deletion with every pre-existing content node deleted.',
+                    ...(state.ownerAuthor ? { ownerAuthor: state.ownerAuthor } : {})
+                }
+            };
+        }
+        const refusal = structuralRefusal || getParagraphRestorationRefusal(paragraph);
+        if (refusal) {
+            return {
+                documentXml,
+                hasChanges: false,
+                status: 'error',
+                error: refusal
+            };
+        }
+    }
+
+    const lastSource = sourceParagraphs[sourceParagraphs.length - 1];
+    const existingBlock = followingParagraphBlock(lastSource, sourceParagraphs.length);
+    const hasExistingRestoration = existingBlock.length === sourceParagraphs.length
+        && existingBlock.every(paragraph => isInsertedParagraphByAuthor(paragraph, author));
+    if (
+        hasExistingRestoration
+        && existingBlock.every((paragraph, index) => extractCanonicalParagraphText(paragraph) === replacements[index])
+    ) {
+        return {
+            documentXml,
+            hasChanges: false,
+            status: 'no-op',
+            warnings: ['An identical same-author paragraph restoration already exists.']
+        };
+    }
+
+    const beforeXml = serializer.serializeToString(xmlDoc);
+    const beforeParagraphs = getDocumentParagraphNodes(xmlDoc);
+    const sourceStartIndex = beforeParagraphs.indexOf(firstSource);
+    const existingIndexes = hasExistingRestoration
+        ? existingBlock.map(paragraph => beforeParagraphs.indexOf(paragraph))
+        : [];
+    const templates = [];
+    const warnings = [];
+    for (let index = 0; index < sourceParagraphs.length; index++) {
+        const source = sourceParagraphs[index];
+        warnings.push(...collectRestorationAnchorWarnings(source));
+        const template = buildRejectedRestorationTemplate(xmlDoc, source, serializer);
+        const edited = template
+            ? await editRestorationTemplate(xmlDoc, template, replacements[index], author, serializer)
+            : null;
+        if (!edited) {
+            return {
+                documentXml,
+                hasChanges: false,
+                status: 'error',
+                error: {
+                    code: 'PATCH_ROUNDTRIP_MISMATCH',
+                    message: `Could not reconstruct restoration paragraph ${index + 1} from its rejected revision view.`
+                }
+            };
+        }
+        templates.push(edited);
+    }
+
+    const insertedParagraphs = templates.map(template => {
+        const paragraph = xmlDoc.importNode(template, true);
+        return trackRestoredParagraph(xmlDoc, paragraph, author, operationSession);
+    });
+    const insertionPoint = lastSource.nextSibling;
+    for (const paragraph of insertedParagraphs) parent.insertBefore(paragraph, insertionPoint);
+    if (hasExistingRestoration) {
+        for (const paragraph of existingBlock) {
+            options?._mutationRemovedNodes?.push(paragraph);
+            paragraph.parentNode?.removeChild(paragraph);
+        }
+    }
+    options?._mutationLiveNodes?.push(...insertedParagraphs);
+    normalizeBodySectionOrder(xmlDoc);
+
+    const outputXml = serializer.serializeToString(xmlDoc);
+    const oracle = verifyParagraphRestorationLifecycle(
+        beforeXml,
+        outputXml,
+        sourceStartIndex,
+        existingIndexes,
+        templates,
+        insertedParagraphs
+    );
+    if (!oracle.valid) {
+        return {
+            documentXml,
+            hasChanges: false,
+            status: 'error',
+            error: {
+                code: oracle.code || 'PATCH_ROUNDTRIP_MISMATCH',
+                message: oracle.message,
+                stage: oracle.stage,
+                ...(oracle.generatedIssues ? { generatedIssues: oracle.generatedIssues } : {}),
+                ...(oracle.envelopeIssues ? { envelopeIssues: oracle.envelopeIssues } : {}),
+                ...(oracle.expected ? { expected: oracle.expected } : {}),
+                ...(oracle.actual ? { actual: oracle.actual } : {})
+            }
+        };
+    }
+
+    return {
+        documentXml: completedDocumentXml(xmlDoc, serializer, documentXml, operationSession),
+        hasChanges: true,
+        status: 'ok',
+        numberingXml: null,
+        ...(warnings.length > 0 ? { warnings: [...new Set(warnings)] } : {})
+    };
+}
 
 async function tryExplicitDecimalHeaderListConversion({
     xmlDoc,
@@ -1643,25 +1648,25 @@ export async function applyToParagraphByExactText(documentXml, targetText, modif
             error: resolved?.error || { code: 'TARGET_NOT_FOUND', message: 'Target paragraph not found.' }
         };
     }
-    const targetParagraph = resolved.paragraph;
-    if (typeof modifiedText === 'string' && modifiedText.length > 0) {
-        const resurrectionTarget = inspectForeignDeletedParagraphTarget(targetParagraph, author);
-        if (resurrectionTarget.matches) {
-            const ownerAuthor = resurrectionTarget.ownerAuthor || 'unattributed';
-            return {
-                documentXml,
-                hasChanges: false,
-                numberingXml: null,
-                status: 'error',
-                error: {
-                    code: 'FOREIGN_PARAGRAPH_MARK_DELETION',
-                    message: `Refusing to add visible text to a paragraph whose paragraph mark is deleted by another author (${ownerAuthor}). Use explicit paragraph restoration when supported.`,
-                    ownerAuthor
-                }
-            };
-        }
-    }
-    preprocessRedlineTargetParagraph(targetParagraph);
+    const targetParagraph = resolved.paragraph;
+    if (typeof modifiedText === 'string' && modifiedText.length > 0) {
+        const resurrectionTarget = inspectForeignDeletedParagraphTarget(targetParagraph, author);
+        if (resurrectionTarget.matches) {
+            const ownerAuthor = resurrectionTarget.ownerAuthor || 'unattributed';
+            return {
+                documentXml,
+                hasChanges: false,
+                numberingXml: null,
+                status: 'error',
+                error: {
+                    code: 'FOREIGN_PARAGRAPH_MARK_DELETION',
+                    message: `Refusing to add visible text to a paragraph whose paragraph mark is deleted by another author (${ownerAuthor}). Use explicit paragraph restoration when supported.`,
+                    ownerAuthor
+                }
+            };
+        }
+    }
+    preprocessRedlineTargetParagraph(targetParagraph);
     const currentParagraphText = getParagraphText(targetParagraph);
     if (modifiedText === '') {
         const commentIds = getCommentIdsInElement(targetParagraph);
@@ -1682,7 +1687,7 @@ export async function applyToParagraphByExactText(documentXml, targetText, modif
         }
     }
     const boundaryCheck = validateParagraphBoundaryMutation(targetParagraph, modifiedText, options);
-    if (!boundaryCheck.valid) {
+    if (!boundaryCheck.valid) {
         return {
             documentXml,
             hasChanges: false,
@@ -1691,111 +1696,111 @@ export async function applyToParagraphByExactText(documentXml, targetText, modif
             error: {
                 code: boundaryCheck.code,
                 message: boundaryCheck.message
-            }
-        };
-    }
-    const hasRevisions = containsTrackedChanges(targetParagraph);
-    const existingPolicy = options.existingRevisions || 'merge-same-author';
-    if (
-        hasRevisions
-        && existingPolicy !== 'accept-all-first'
-        && existingPolicy !== 'accept-all-first-keep-normalized'
-    ) {
-        if (existingPolicy === 'merge-same-author' || existingPolicy === 'slice-cross-author') {
-            const authors = getTrackedChangeAuthors(targetParagraph);
-            const opAuthor = String(author || '').trim().toLowerCase();
-            const allSame = authors.length > 0 && authors.every(a => a.trim().toLowerCase() === opAuthor);
-            if (!allSame && existingPolicy === 'merge-same-author') {
-                return {
-                    documentXml,
-                    hasChanges: false,
-                    numberingXml: null,
-                    status: 'error',
-                    error: {
-                        code: 'EXISTING_REVISIONS',
-                        message: `Target paragraph contains tracked changes from another author (${authors.length ? authors.join(', ') : 'unattributed'}). Use existingRevisions: "slice-cross-author" for a surgical edit that preserves reviewer history; accepting or rejecting revisions requires separate authorization.`,
-                        revisionAuthors: authors,
-                        currentPolicy: existingPolicy
-                    }
-                };
-            }
-            const mergeCommentIds = allSame ? getCommentIdsInElement(targetParagraph) : [];
-            if (mergeCommentIds.length > 0) {
-                const comments = commentDetailsForIds(mergeCommentIds, options._existingCommentDetails);
-                return {
-                    documentXml,
-                    hasChanges: false,
-                    numberingXml: null,
-                    status: 'error',
-                    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 } : {})
-                    }
-                };
-            }
-            if (!allSame) {
-                const hasMove = targetParagraph.getElementsByTagNameNS(NS_W, 'moveFrom').length > 0
-                    || targetParagraph.getElementsByTagNameNS(NS_W, 'moveTo').length > 0;
-                if (hasMove) {
-                    return {
-                        documentXml,
-                        hasChanges: false,
-                        numberingXml: null,
-                        status: 'error',
-                        error: {
-                            code: 'UNSAFE_REVISION_NESTING',
-                            message: 'Cross-author slicing does not support pending move revisions.'
-                        }
-                    };
-                }
-            }
-        } else {
-            const hasDel = targetParagraph.getElementsByTagNameNS(NS_W, 'del').length > 0;
-            const hasMove = targetParagraph.getElementsByTagNameNS(NS_W, 'moveFrom').length > 0
-                || targetParagraph.getElementsByTagNameNS(NS_W, 'moveTo').length > 0;
-            if (hasDel) {
-                return {
-                    documentXml,
-                    hasChanges: false,
-                    numberingXml: null,
-                    status: 'error',
-                    error: {
-                        code: 'UNSAFE_REVISION_NESTING',
-                        message: 'Refusing to replace content with pending deletions; nesting revisions is unsafe.'
-                    }
-                };
-            }
-            if (hasMove) {
-                return {
-                    documentXml,
-                    hasChanges: false,
-                    numberingXml: null,
-                    status: 'error',
-                    error: {
-                        code: 'UNSAFE_REVISION_NESTING',
-                        message: 'Refusing to mutate content with move revisions until move lifecycle is designed.'
-                    }
-                };
-            }
-            return {
-                documentXml,
-                hasChanges: false,
-                numberingXml: null,
-                status: 'error',
-                error: {
-                    code: 'EXISTING_REVISIONS',
-                    message: 'Target paragraph contains tracked changes and existingRevisions is "reject-input".'
-                }
-            };
-        }
-    }
-    if (
-        modifiedText === ''
-        && currentParagraphText === ''
-        && !(hasRevisions && existingPolicy === 'merge-same-author')
-    ) {
+            }
+        };
+    }
+    const hasRevisions = containsTrackedChanges(targetParagraph);
+    const existingPolicy = options.existingRevisions || 'merge-same-author';
+    if (
+        hasRevisions
+        && existingPolicy !== 'accept-all-first'
+        && existingPolicy !== 'accept-all-first-keep-normalized'
+    ) {
+        if (existingPolicy === 'merge-same-author' || existingPolicy === 'slice-cross-author') {
+            const authors = getTrackedChangeAuthors(targetParagraph);
+            const opAuthor = String(author || '').trim().toLowerCase();
+            const allSame = authors.length > 0 && authors.every(a => a.trim().toLowerCase() === opAuthor);
+            if (!allSame && existingPolicy === 'merge-same-author') {
+                return {
+                    documentXml,
+                    hasChanges: false,
+                    numberingXml: null,
+                    status: 'error',
+                    error: {
+                        code: 'EXISTING_REVISIONS',
+                        message: `Target paragraph contains tracked changes from another author (${authors.length ? authors.join(', ') : 'unattributed'}). Use existingRevisions: "slice-cross-author" for a surgical edit that preserves reviewer history; accepting or rejecting revisions requires separate authorization.`,
+                        revisionAuthors: authors,
+                        currentPolicy: existingPolicy
+                    }
+                };
+            }
+            const mergeCommentIds = allSame ? getCommentIdsInElement(targetParagraph) : [];
+            if (mergeCommentIds.length > 0) {
+                const comments = commentDetailsForIds(mergeCommentIds, options._existingCommentDetails);
+                return {
+                    documentXml,
+                    hasChanges: false,
+                    numberingXml: null,
+                    status: 'error',
+                    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 } : {})
+                    }
+                };
+            }
+            if (!allSame) {
+                const hasMove = targetParagraph.getElementsByTagNameNS(NS_W, 'moveFrom').length > 0
+                    || targetParagraph.getElementsByTagNameNS(NS_W, 'moveTo').length > 0;
+                if (hasMove) {
+                    return {
+                        documentXml,
+                        hasChanges: false,
+                        numberingXml: null,
+                        status: 'error',
+                        error: {
+                            code: 'UNSAFE_REVISION_NESTING',
+                            message: 'Cross-author slicing does not support pending move revisions.'
+                        }
+                    };
+                }
+            }
+        } else {
+            const hasDel = targetParagraph.getElementsByTagNameNS(NS_W, 'del').length > 0;
+            const hasMove = targetParagraph.getElementsByTagNameNS(NS_W, 'moveFrom').length > 0
+                || targetParagraph.getElementsByTagNameNS(NS_W, 'moveTo').length > 0;
+            if (hasDel) {
+                return {
+                    documentXml,
+                    hasChanges: false,
+                    numberingXml: null,
+                    status: 'error',
+                    error: {
+                        code: 'UNSAFE_REVISION_NESTING',
+                        message: 'Refusing to replace content with pending deletions; nesting revisions is unsafe.'
+                    }
+                };
+            }
+            if (hasMove) {
+                return {
+                    documentXml,
+                    hasChanges: false,
+                    numberingXml: null,
+                    status: 'error',
+                    error: {
+                        code: 'UNSAFE_REVISION_NESTING',
+                        message: 'Refusing to mutate content with move revisions until move lifecycle is designed.'
+                    }
+                };
+            }
+            return {
+                documentXml,
+                hasChanges: false,
+                numberingXml: null,
+                status: 'error',
+                error: {
+                    code: 'EXISTING_REVISIONS',
+                    message: 'Target paragraph contains tracked changes and existingRevisions is "reject-input".'
+                }
+            };
+        }
+    }
+    if (
+        modifiedText === ''
+        && currentParagraphText === ''
+        && !(hasRevisions && existingPolicy === 'merge-same-author')
+    ) {
         if (generateRedlines) {
             markParagraphMarkDeleted(xmlDoc, targetParagraph, author, createRevisionMetadata(author, xmlDoc));
             options?._mutationLiveNodes?.push(targetParagraph);
@@ -1944,6 +1949,102 @@ export async function applyToParagraphByExactText(documentXml, targetText, modif
         };
     }
 
+    // Retained paragraph followed by a Markdown table: keep the source paragraph in place (so its own
+    // content, formatting and revisions are untouched), apply any requested inline formatting to it,
+    // and insert the table after it instead of rewriting the paragraph as a deletion plus a copy.
+    const tableAppendCandidate = (
+        !useTableScope
+        && !hasExplicitRangeScope
+        && !targetListInfo
+        && !containingTable
+        && !targetEndRef
+    )
+        ? deriveParagraphThenTableAppend(effectiveModifiedText)
+        : null;
+    const tableAppendParagraph = tableAppendCandidate
+        ? preprocessMarkdown(tableAppendCandidate.paragraphMarkdown)
+        : null;
+    if (
+        tableAppendCandidate
+        && normalizeWhitespaceForTargeting(tableAppendParagraph.cleanText) === normalizeWhitespaceForTargeting(currentParagraphText)
+    ) {
+        const tableData = parseMarkdownTable(tableAppendCandidate.tableText);
+        if (tableData.headers.length > 0 || tableData.rows.length > 0) {
+            onInfo('[Table] Applying retained-paragraph table append heuristic.');
+            const parent = targetParagraph.parentNode;
+            if (!parent) throw new Error('Target paragraph has no parent for table append');
+            const followingNode = targetParagraph.nextSibling;
+            if (tableAppendParagraph.formatHints.length > 0) {
+                const formatted = await applyRedlineToOxml(
+                    serializer.serializeToString(targetParagraph),
+                    currentParagraphText || targetText,
+                    tableAppendCandidate.paragraphMarkdown,
+                    {
+                        author,
+                        generateRedlines,
+                        existingRevisions: options.existingRevisions || 'merge-same-author',
+                        structuredContent: false,
+                        _revisionIdAllocator: revisionIdAllocator
+                    }
+                );
+                if (formatted?.status === 'error') {
+                    return {
+                        documentXml,
+                        hasChanges: false,
+                        numberingXml: null,
+                        status: 'error',
+                        error: formatted.error
+                    };
+                }
+                if (formatted?.hasChanges) {
+                    if (typeof formatted.oxml !== 'string') {
+                        throw new Error('Reconciliation engine did not return OOXML for a changed paragraph format');
+                    }
+                    for (const node of extractReplacementNodes(formatted.oxml).replacementNodes) {
+                        const imported = xmlDoc.importNode(node, true);
+                        ensureParagraphIdsOnImportedNode(imported, operationSession);
+                        options?._mutationLiveNodes?.push(parent.insertBefore(imported, targetParagraph));
+                    }
+                    options?._mutationRemovedNodes?.push(targetParagraph);
+                    parent.removeChild(targetParagraph);
+                }
+            }
+            const tableOoxml = generateTableOoxml(tableData, {
+                generateRedlines,
+                author,
+                revisionIdAllocator,
+                trackAsBlock: true
+            });
+            for (const node of extractReplacementNodes(tableOoxml).replacementNodes) {
+                options?._mutationLiveNodes?.push(parent.insertBefore(xmlDoc.importNode(node, true), followingNode));
+            }
+            // Word cannot end the body (or a container) with a table: it would add an untracked paragraph
+            // there that Reject All leaves behind. Supply the paragraph ourselves with a tracked-inserted
+            // mark so Reject All removes it and the source paragraph count is restored.
+            const endsContainer = !followingNode
+                || (followingNode.nodeType === 1 && followingNode.namespaceURI === NS_W && followingNode.localName === 'sectPr');
+            if (endsContainer) {
+                const trailing = createWordElement(xmlDoc, 'w:p');
+                const trailingPPr = clonePropertiesWithoutRevisionHistory(getDirectWordChild(targetParagraph, 'pPr'));
+                if (trailingPPr) {
+                    for (const child of Array.from(trailingPPr.childNodes)) {
+                        if (child.nodeType === 1 && ['sectPr', 'numPr'].includes(child.localName)) trailingPPr.removeChild(child);
+                    }
+                    trailing.appendChild(trailingPPr);
+                }
+                if (generateRedlines) markParagraphMarkInserted(xmlDoc, trailing, author);
+                ensureParagraphIdsOnImportedNode(trailing, operationSession);
+                options?._mutationLiveNodes?.push(parent.insertBefore(trailing, followingNode));
+            }
+            normalizeBodySectionOrder(xmlDoc);
+            return {
+                documentXml: completedDocumentXml(xmlDoc, serializer, documentXml, operationSession),
+                hasChanges: true,
+                numberingXml: null
+            };
+        }
+    }
+
     const plainAdjacencyInsertionCandidate = (
         !bypassSingleParagraphHeuristics
         && !useTableScope
@@ -1971,7 +2072,9 @@ export async function applyToParagraphByExactText(documentXml, targetText, modif
                 paragraphText,
                 generateRedlines ? createRevisionMetadata(author, xmlDoc) : null,
                 author,
-                { generateRedlines }
+                // A wholly inserted paragraph must track its own paragraph mark; otherwise Word's
+                // Reject All removes the text but leaves an empty paragraph behind.
+                { generateRedlines, trackParagraphMark: true }
             );
             const imported = xmlDoc.importNode(plainParagraph, true);
             ensureParagraphIdsOnImportedNode(imported, operationSession);
@@ -2078,8 +2181,8 @@ export async function applyToParagraphByExactText(documentXml, targetText, modif
                 ? explicitRangeParagraphs.map(paragraph => getParagraphText(paragraph)).join('\n')
                 : (inferredTableRangeParagraphs
                     ? inferredTableRangeParagraphs.map(paragraph => getParagraphText(paragraph)).join('\n')
-                    : (currentParagraphText || targetText))
-        );
+                    : (currentParagraphText || targetText))
+        );
     const scopedXml = useTableScope
         ? serializer.serializeToString(containingTable)
         : (
@@ -2112,6 +2215,7 @@ export async function applyToParagraphByExactText(documentXml, targetText, modif
             explicitStructuredContent: options.explicitStructuredContent === true,
             pairReplacements: options.pairReplacements === true,
             insertionAffinity: options.insertionAffinity || null,
+            literalTextEdit: options.literalTextEdit === true,
             _revisionIdAllocator: revisionIdAllocator,
             _isolatedTableCell: useTableScope
         });
@@ -2135,6 +2239,14 @@ export async function applyToParagraphByExactText(documentXml, targetText, modif
     const extracted = extractReplacementNodes(result.oxml);
     let replacementNodes = removeListPackagingSentinel(extracted.replacementNodes, result.warnings);
     let numberingXml = extracted.numberingXml;
+    if (numberingXml && runtimeContext?.numberingIdState && !useTableScope) {
+        const sourceParagraphs = useListScope ? listScopeEdit.paragraphs : (explicitRangeParagraphs || [targetParagraph]);
+        const continued = reuseSourceListNumbering(numberingXml, replacementNodes, sourceParagraphs, runtimeContext.numberingIdState);
+        if (continued) {
+            replacementNodes = continued.replacementNodes;
+            numberingXml = null;
+        }
+    }
     if (numberingXml && runtimeContext?.numberingIdState) {
         const normalizedNumbering = remapNumberingPayloadForDocument(numberingXml, replacementNodes, runtimeContext.numberingIdState);
         replacementNodes = normalizedNumbering.replacementNodes;
@@ -2418,7 +2530,12 @@ export async function applyFormattingToParagraphByExactText(
     }
 
     const targetDescriptor = options.targetDescriptor;
-    const occurrence = targetDescriptor?.occurrence ?? null;
+    // `textOccurrence` is the dedicated in-paragraph selector. Legacy calls without it keep
+    // reading `target.occurrence` (which also selects the N-th matching paragraph).
+    const explicitTextOccurrence = Number.isInteger(options.textOccurrence) && options.textOccurrence > 0
+        ? options.textOccurrence
+        : null;
+    const occurrence = explicitTextOccurrence ?? targetDescriptor?.occurrence ?? null;
     let matchStart = -1;
     if (occurrence != null && occurrence > 0) {
         let count = 0;
@@ -2437,6 +2554,18 @@ export async function applyFormattingToParagraphByExactText(
         matchStart = fullParaText.indexOf(textToFormat);
     }
 
+    if (matchStart === -1 && explicitTextOccurrence != null && fullParaText.includes(textToFormat)) {
+        return {
+            documentXml,
+            hasChanges: false,
+            status: 'error',
+            error: {
+                code: 'PATCH_SOURCE_NOT_FOUND',
+                message: `Occurrence ${explicitTextOccurrence} of text to format was not found in target paragraph: "${textToFormat}".`
+            }
+        };
+    }
+
     if (matchStart === -1) {
         return {
             documentXml,