@ansonlai/docx-redline-js 0.8.3 → 0.8.4

package/engine/oxml-engine.js

@@ -17,7 +17,7 @@ import {
 } from '../core/xml-query.js';
 import { createSerializer, parseOoxmlSafe, serializeXml } from '../adapters/xml-adapter.js';
 import { log, error } from '../adapters/logger.js';
-import { extractFormattingFromOoxml } from './format-extraction.js';
+import { buildTextSpansFromParagraphs, extractFormattingFromOoxml } from './format-extraction.js';
 import {
     applyFormatRemovalAsSurgicalReplacement,
     applyFormatOnlyChangesSurgical
@@ -28,8 +28,8 @@ import { applySurgicalMode } from './surgical-mode.js';
 import { applyReconstructionMode } from './reconstruction-mode.js';
 import { applyTableReconciliation, applyTextToTableTransformation } from './table-mode.js';
 import { getDefaultAuthor } from '../adapters/config.js';
-import { containsTrackedChanges, createWordElement, getTrackedChangeAuthors, withOoxmlSourceType } from '../core/word-xml.js';
-import { clonePropertiesWithoutRevisionHistory } from '../core/revision-cloning.js';
+import { containsTrackedChanges, createWordElement, getTrackedChangeAuthors, withOoxmlSourceType } from '../core/word-xml.js';
+import { clonePropertiesWithoutRevisionHistory } from '../core/revision-cloning.js';
 import {
     NS_W,
     RevisionIdAllocator,
@@ -40,75 +40,75 @@ import { extractCanonicalParagraphText } from '../core/paragraph-text.js';
 import { getDocumentParagraphs } from './format-extraction.js';
 import { isDiffTokenLimitError } from '../pipeline/diff-engine.js';
 import { NumberingService } from '../services/numbering-service.js';
-import { recordRouteSelection } from './route-selection.js';
-import { inspectForeignDeletedParagraphTarget } from '../core/paragraph-revision-safety.js';
-
-function getCommentIdsInOoxml(node) {
-    const ids = new Set();
-    for (const localName of ['commentRangeStart', 'commentRangeEnd', 'commentReference']) {
-        for (const marker of getElementsByTagNSOrTag(node, NS_W, localName)) {
-            const id = marker.getAttribute?.('w:id') || marker.getAttribute?.('id');
-            if (id !== '') ids.add(id);
-        }
-    }
-    return [...ids].sort((a, b) => Number(a) - Number(b) || a.localeCompare(b));
-}
-
-function directWordChild(node, localName) {
-    return Array.from(node?.childNodes || []).find(child => (
-        child?.nodeType === 1
-        && child.namespaceURI === NS_W
-        && child.localName === localName
-    )) || null;
-}
-
-function insertedParagraphMarkMetadata(paragraph, author) {
-    const marker = directWordChild(directWordChild(directWordChild(paragraph, 'pPr'), 'rPr'), 'ins');
-    if (!marker) return null;
-    const markerAuthor = marker.getAttribute('w:author') || marker.getAttributeNS(NS_W, 'author') || '';
-    if (markerAuthor.trim().toLowerCase() !== String(author || '').trim().toLowerCase()) return null;
-    return {
-        id: marker.getAttribute('w:id') || marker.getAttributeNS(NS_W, 'id') || '',
-        author: markerAuthor,
-        date: marker.getAttribute('w:date') || marker.getAttributeNS(NS_W, 'date') || ''
-    };
-}
-
-function emptyParagraphBaseline(paragraph, serializer) {
-    const clone = paragraph.cloneNode(false);
-    const pPr = directWordChild(paragraph, 'pPr');
-    if (pPr) clone.appendChild(clonePropertiesWithoutRevisionHistory(pPr));
-    return serializer.serializeToString(clone);
-}
-
-function restoreInsertedParagraphMark(oxml, metadata) {
-    if (!metadata || typeof oxml !== 'string' || !oxml.trim()) return oxml;
-    const parsed = parseOoxmlSafe(oxml, 'text/xml');
-    if (!parsed.doc || parsed.error) return oxml;
-    const paragraph = parsed.doc.documentElement?.localName === 'p'
-        ? parsed.doc.documentElement
-        : getDocumentParagraphs(parsed.doc)[0];
-    if (!paragraph) return oxml;
-
-    let pPr = directWordChild(paragraph, 'pPr');
-    if (!pPr) {
-        pPr = createWordElement(parsed.doc, 'w:pPr');
-        paragraph.insertBefore(pPr, paragraph.firstChild);
-    }
-    let rPr = directWordChild(pPr, 'rPr');
-    if (!rPr) {
-        rPr = createWordElement(parsed.doc, 'w:rPr');
-        pPr.appendChild(rPr);
-    }
-    if (!directWordChild(rPr, 'ins')) {
-        const marker = createWordElement(parsed.doc, 'w:ins');
-        if (metadata.id) marker.setAttribute('w:id', metadata.id);
-        marker.setAttribute('w:author', metadata.author);
-        if (metadata.date) marker.setAttribute('w:date', metadata.date);
-        rPr.appendChild(marker);
-    }
-    return serializeXml(parsed.doc);
-}
+import { recordRouteSelection } from './route-selection.js';
+import { inspectForeignDeletedParagraphTarget } from '../core/paragraph-revision-safety.js';
+
+function getCommentIdsInOoxml(node) {
+    const ids = new Set();
+    for (const localName of ['commentRangeStart', 'commentRangeEnd', 'commentReference']) {
+        for (const marker of getElementsByTagNSOrTag(node, NS_W, localName)) {
+            const id = marker.getAttribute?.('w:id') || marker.getAttribute?.('id');
+            if (id !== '') ids.add(id);
+        }
+    }
+    return [...ids].sort((a, b) => Number(a) - Number(b) || a.localeCompare(b));
+}
+
+function directWordChild(node, localName) {
+    return Array.from(node?.childNodes || []).find(child => (
+        child?.nodeType === 1
+        && child.namespaceURI === NS_W
+        && child.localName === localName
+    )) || null;
+}
+
+function insertedParagraphMarkMetadata(paragraph, author) {
+    const marker = directWordChild(directWordChild(directWordChild(paragraph, 'pPr'), 'rPr'), 'ins');
+    if (!marker) return null;
+    const markerAuthor = marker.getAttribute('w:author') || marker.getAttributeNS(NS_W, 'author') || '';
+    if (markerAuthor.trim().toLowerCase() !== String(author || '').trim().toLowerCase()) return null;
+    return {
+        id: marker.getAttribute('w:id') || marker.getAttributeNS(NS_W, 'id') || '',
+        author: markerAuthor,
+        date: marker.getAttribute('w:date') || marker.getAttributeNS(NS_W, 'date') || ''
+    };
+}
+
+function emptyParagraphBaseline(paragraph, serializer) {
+    const clone = paragraph.cloneNode(false);
+    const pPr = directWordChild(paragraph, 'pPr');
+    if (pPr) clone.appendChild(clonePropertiesWithoutRevisionHistory(pPr));
+    return serializer.serializeToString(clone);
+}
+
+function restoreInsertedParagraphMark(oxml, metadata) {
+    if (!metadata || typeof oxml !== 'string' || !oxml.trim()) return oxml;
+    const parsed = parseOoxmlSafe(oxml, 'text/xml');
+    if (!parsed.doc || parsed.error) return oxml;
+    const paragraph = parsed.doc.documentElement?.localName === 'p'
+        ? parsed.doc.documentElement
+        : getDocumentParagraphs(parsed.doc)[0];
+    if (!paragraph) return oxml;
+
+    let pPr = directWordChild(paragraph, 'pPr');
+    if (!pPr) {
+        pPr = createWordElement(parsed.doc, 'w:pPr');
+        paragraph.insertBefore(pPr, paragraph.firstChild);
+    }
+    let rPr = directWordChild(pPr, 'rPr');
+    if (!rPr) {
+        rPr = createWordElement(parsed.doc, 'w:rPr');
+        pPr.appendChild(rPr);
+    }
+    if (!directWordChild(rPr, 'ins')) {
+        const marker = createWordElement(parsed.doc, 'w:ins');
+        if (metadata.id) marker.setAttribute('w:id', metadata.id);
+        marker.setAttribute('w:author', metadata.author);
+        if (metadata.date) marker.setAttribute('w:date', metadata.date);
+        rPr.appendChild(marker);
+    }
+    return serializeXml(parsed.doc);
+}
 
 /**
  * Applies redline track changes to OOXML by modifying the DOM in-place.
@@ -119,7 +119,7 @@ function restoreInsertedParagraphMark(oxml, metadata) {
  * @param {Object} [options={}] - Options
  * @param {string} [options.author='AI'] - Author for track changes
  * @param {string|null} [options.targetParagraphId=null] - Preferred paragraph identity for table wrappers
- * @param {'merge-same-author'|'slice-cross-author'|'reject-input'|'accept-all-first'|'accept-all-first-keep-normalized'} [options.existingRevisions='merge-same-author'] - Policy for source OOXML with tracked changes
+ * @param {'merge-same-author'|'slice-cross-author'|'reject-input'|'accept-all-first'|'accept-all-first-keep-normalized'} [options.existingRevisions='merge-same-author'] - Policy for source OOXML with tracked changes
  * @param {boolean} [options.removeFormatting=false] - Remove existing core formatting when text is otherwise unchanged
  * @param {boolean} [options.sanitizeInput=false] - Strip a standalone leading assistant preface line
  * @returns {Promise<{ oxml: string, hasChanges: boolean, sourceType?: 'package'|'document'|'fragment', status?: 'ok'|'no-op'|'error', error?: { code: string, message: string } }>}
@@ -134,14 +134,14 @@ export async function applyRedlineToOxml(oxml, originalText, modifiedText, optio
     const serializer = createSerializer();
     let parseWarnings = [];
     const operationWarnings = [];
-    let normalizedExistingRevisions = false;
-    let preservedInsertedParagraphMark = null;
+    let normalizedExistingRevisions = false;
+    let preservedInsertedParagraphMark = null;
     const existingRevisionsPolicy = options.existingRevisions || 'merge-same-author';
     const keepNormalizedNoOp = existingRevisionsPolicy === 'accept-all-first-keep-normalized';
-    const finalize = result => {
-        const withStatus = { ...result };
+    const finalize = result => {
+        const withStatus = { ...result };
         if (normalizedExistingRevisions && withStatus.hasChanges === false && withStatus.status !== 'error') {
-            if (existingRevisionsPolicy === 'merge-same-author' || existingRevisionsPolicy === 'slice-cross-author') {
+            if (existingRevisionsPolicy === 'merge-same-author' || existingRevisionsPolicy === 'slice-cross-author') {
                 withStatus.oxml = workingOoxml;
                 withStatus.hasChanges = true;
                 withStatus.warnings = [
@@ -163,13 +163,13 @@ export async function applyRedlineToOxml(oxml, originalText, modifiedText, optio
         if (warnings.length > 0) {
             withStatus.warnings = [...new Set(warnings)];
         }
-        if (!withStatus.status) {
-            withStatus.status = withStatus.hasChanges ? 'ok' : 'no-op';
-        }
-        if (preservedInsertedParagraphMark && withStatus.hasChanges && typeof withStatus.oxml === 'string') {
-            withStatus.oxml = restoreInsertedParagraphMark(withStatus.oxml, preservedInsertedParagraphMark);
-        }
-        return withOoxmlSourceType(withStatus);
+        if (!withStatus.status) {
+            withStatus.status = withStatus.hasChanges ? 'ok' : 'no-op';
+        }
+        if (preservedInsertedParagraphMark && withStatus.hasChanges && typeof withStatus.oxml === 'string') {
+            withStatus.oxml = restoreInsertedParagraphMark(withStatus.oxml, preservedInsertedParagraphMark);
+        }
+        return withOoxmlSourceType(withStatus);
     };
     const finalizeUnchanged = () => {
         if (normalizedExistingRevisions && keepNormalizedNoOp) {
@@ -200,61 +200,61 @@ export async function applyRedlineToOxml(oxml, originalText, modifiedText, optio
     const revisionIdAllocator = options?._revisionIdAllocator instanceof RevisionIdAllocator
         ? options._revisionIdAllocator
         : new RevisionIdAllocator();
-    seedRevisionIdsFromDocument(xmlDoc, revisionIdAllocator);
-
-    const inputParagraphs = xmlDoc.documentElement && String(xmlDoc.documentElement.localName || '').toLowerCase() === 'p'
-        ? [xmlDoc.documentElement]
-        : getDocumentParagraphs(xmlDoc);
-    if (inputParagraphs.length === 1 && modifiedText.length > 0) {
-        const resurrectionTarget = inspectForeignDeletedParagraphTarget(inputParagraphs[0], author);
-        if (resurrectionTarget.matches) {
-            const ownerAuthor = resurrectionTarget.ownerAuthor || 'unattributed';
-            return finalize({
-                oxml: inputOoxml,
-                hasChanges: false,
-                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
-                }
-            });
-        }
-    }
-
-    if (containsTrackedChanges(xmlDoc)) {
-        if (existingRevisionsPolicy === 'merge-same-author' || existingRevisionsPolicy === 'slice-cross-author') {
+    seedRevisionIdsFromDocument(xmlDoc, revisionIdAllocator);
+
+    const inputParagraphs = xmlDoc.documentElement && String(xmlDoc.documentElement.localName || '').toLowerCase() === 'p'
+        ? [xmlDoc.documentElement]
+        : getDocumentParagraphs(xmlDoc);
+    if (inputParagraphs.length === 1 && modifiedText.length > 0) {
+        const resurrectionTarget = inspectForeignDeletedParagraphTarget(inputParagraphs[0], author);
+        if (resurrectionTarget.matches) {
+            const ownerAuthor = resurrectionTarget.ownerAuthor || 'unattributed';
+            return finalize({
+                oxml: inputOoxml,
+                hasChanges: false,
+                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
+                }
+            });
+        }
+    }
+
+    if (containsTrackedChanges(xmlDoc)) {
+        if (existingRevisionsPolicy === 'merge-same-author' || existingRevisionsPolicy === 'slice-cross-author') {
             const authors = getTrackedChangeAuthors(xmlDoc);
-            const currentAuthor = String(author || '').trim().toLowerCase();
-            const isSameAuthor = authors.length > 0 && authors.every(a => a.trim().toLowerCase() === currentAuthor);
-            if (isSameAuthor) {
-                const commentIds = getCommentIdsInOoxml(xmlDoc);
-                if (commentIds.length > 0) {
-                    return finalize({
-                        oxml: inputOoxml,
-                        hasChanges: false,
-                        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
-                        }
-                    });
-                }
-                log('[OxmlEngine] Existing revisions from same author detected; rejecting previous changes to merge against baseline');
-                const soleParagraph = inputParagraphs.length === 1 ? inputParagraphs[0] : null;
-                preservedInsertedParagraphMark = insertedParagraphMarkMetadata(soleParagraph, author);
-                const rejected = rejectTrackedChangesInOoxml(inputOoxml, { author });
-                if (rejected.status === 'error') return finalize(rejected);
-                workingOoxml = preservedInsertedParagraphMark && !String(rejected.oxml || '').trim()
-                    ? emptyParagraphBaseline(soleParagraph, serializer)
-                    : rejected.oxml;
+            const currentAuthor = String(author || '').trim().toLowerCase();
+            const isSameAuthor = authors.length > 0 && authors.every(a => a.trim().toLowerCase() === currentAuthor);
+            if (isSameAuthor) {
+                const commentIds = getCommentIdsInOoxml(xmlDoc);
+                if (commentIds.length > 0) {
+                    return finalize({
+                        oxml: inputOoxml,
+                        hasChanges: false,
+                        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
+                        }
+                    });
+                }
+                log('[OxmlEngine] Existing revisions from same author detected; rejecting previous changes to merge against baseline');
+                const soleParagraph = inputParagraphs.length === 1 ? inputParagraphs[0] : null;
+                preservedInsertedParagraphMark = insertedParagraphMarkMetadata(soleParagraph, author);
+                const rejected = rejectTrackedChangesInOoxml(inputOoxml, { author });
+                if (rejected.status === 'error') return finalize(rejected);
+                workingOoxml = preservedInsertedParagraphMark && !String(rejected.oxml || '').trim()
+                    ? emptyParagraphBaseline(soleParagraph, serializer)
+                    : rejected.oxml;
                 normalizedExistingRevisions = true;
                 const rejectedParsed = parseOoxmlSafe(workingOoxml, 'text/xml');
                 parseWarnings.push(...rejectedParsed.warnings);
                 xmlDoc = rejectedParsed.doc;
                 const rejectedParseError = xmlDoc ? getXmlParseError(xmlDoc) : null;
-                if (rejectedParsed.error || rejectedParseError) {
+                if (rejectedParsed.error || rejectedParseError) {
                     const message = rejectedParsed.error?.message || rejectedParseError?.textContent || 'Could not parse OOXML after rejecting same-author revisions.';
                     error('[OxmlEngine] XML parse error after rejecting same-author revisions:', message);
                     return finalize({
@@ -264,21 +264,21 @@ export async function applyRedlineToOxml(oxml, originalText, modifiedText, optio
                         error: {
                             code: 'PARSE_ERROR',
                             message
-                        }
-                    });
-                }
-                if (containsTrackedChanges(xmlDoc)) {
-                    return finalize({
-                        oxml: inputOoxml,
-                        hasChanges: false,
-                        status: 'error',
-                        error: {
-                            code: 'UNSAFE_REVISION_NESTING',
-                            message: 'Existing same-author revisions could not be completely restored to baseline; refusing to layer new revisions over unsupported revision markup.'
-                        }
-                    });
-                }
-                seedRevisionIdsFromDocument(xmlDoc, revisionIdAllocator);
+                        }
+                    });
+                }
+                if (containsTrackedChanges(xmlDoc)) {
+                    return finalize({
+                        oxml: inputOoxml,
+                        hasChanges: false,
+                        status: 'error',
+                        error: {
+                            code: 'UNSAFE_REVISION_NESTING',
+                            message: 'Existing same-author revisions could not be completely restored to baseline; refusing to layer new revisions over unsupported revision markup.'
+                        }
+                    });
+                }
+                seedRevisionIdsFromDocument(xmlDoc, revisionIdAllocator);
 
                 // Re-derive baseline text from the restored baseline OOXML:
                 const paragraphsInDoc = xmlDoc.documentElement && String(xmlDoc.documentElement.localName || '').toLowerCase() === 'p'
@@ -288,37 +288,37 @@ export async function applyRedlineToOxml(oxml, originalText, modifiedText, optio
                     ? paragraphsInDoc.map(p => extractCanonicalParagraphText(p)).join('\n')
                     : '';
                 originalText = baselineText;
-            } else if (existingRevisionsPolicy === 'merge-same-author') {
-                log('[OxmlEngine] Existing revisions detected from another/unattributed author; refusing per merge-same-author policy');
+            } else if (existingRevisionsPolicy === 'merge-same-author') {
+                log('[OxmlEngine] Existing revisions detected from another/unattributed author; refusing per merge-same-author policy');
                 return finalize({
                     oxml: inputOoxml,
                     hasChanges: false,
                     status: 'error',
                     error: {
-                        code: 'EXISTING_REVISIONS',
-                        message: `Input OOXML 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: existingRevisionsPolicy
+                        code: 'EXISTING_REVISIONS',
+                        message: `Input OOXML 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: existingRevisionsPolicy
                     }
                 });
-            } else {
-                const hasMoveRevision = ['moveFrom', 'moveTo'].some(localName => {
-                    return getElementsByTagNSOrTag(xmlDoc, NS_W, localName).length > 0;
-                });
-                if (hasMoveRevision) {
-                    return finalize({
-                        oxml: inputOoxml,
-                        hasChanges: false,
-                        status: 'error',
-                        error: {
-                            code: 'UNSAFE_REVISION_NESTING',
-                            message: 'Cross-author slicing does not support pending move revisions.'
-                        }
-                    });
-                }
-                log('[OxmlEngine] Existing revisions retained for cross-author surgical slicing');
-            }
-        } else if (existingRevisionsPolicy === 'accept-all-first' || existingRevisionsPolicy === 'accept-all-first-keep-normalized') {
+            } else {
+                const hasMoveRevision = ['moveFrom', 'moveTo'].some(localName => {
+                    return getElementsByTagNSOrTag(xmlDoc, NS_W, localName).length > 0;
+                });
+                if (hasMoveRevision) {
+                    return finalize({
+                        oxml: inputOoxml,
+                        hasChanges: false,
+                        status: 'error',
+                        error: {
+                            code: 'UNSAFE_REVISION_NESTING',
+                            message: 'Cross-author slicing does not support pending move revisions.'
+                        }
+                    });
+                }
+                log('[OxmlEngine] Existing revisions retained for cross-author surgical slicing');
+            }
+        } else if (existingRevisionsPolicy === 'accept-all-first' || existingRevisionsPolicy === 'accept-all-first-keep-normalized') {
             log('[OxmlEngine] Existing revisions detected; accepting all input revisions before redlining');
             const accepted = acceptTrackedChangesInOoxml(inputOoxml, { allAuthors: true });
             if (accepted.status === 'error') return finalize(accepted);
@@ -375,7 +375,7 @@ export async function applyRedlineToOxml(oxml, originalText, modifiedText, optio
         operationWarnings.push('Input was sanitized; pass sanitizeInput: false to disable.');
     }
     let structuredAnalysis = null;
-    if (options.structuredContent !== false) {
+    if (options.structuredContent !== false && options.literalTextEdit !== true) {
         structuredAnalysis = analyzeStructuredContent(sanitizedText);
         if (!structuredAnalysis.valid) {
             if (options.explicitStructuredContent === true) {
@@ -395,21 +395,32 @@ export async function applyRedlineToOxml(oxml, originalText, modifiedText, optio
     }
     const { cleanText: cleanModifiedText, formatHints } = preprocessMarkdown(sanitizedText);
 
-    const hasTextChanges = existingRevisionsPolicy === 'slice-cross-author'
-        ? cleanModifiedText !== originalText
-        : cleanModifiedText.trim() !== originalText.trim();
-    const hasFormatHints = formatHints.length > 0;
-
     const { existingFormatHints, textSpans, paragraphs } = extractFormattingFromOoxml(xmlDoc);
+    const hasLiteralTextChanges = existingRevisionsPolicy === 'slice-cross-author'
+        ? cleanModifiedText !== originalText
+        : cleanModifiedText.trim() !== originalText.trim();
+    // Markdown list markers can equal manually typed ones ("A. ..." lines), so
+    // an explicit structured-content request that turns plain paragraphs or
+    // soft-break lines into a list is a change even when the text is identical.
+    const hasListStructureChange = !hasLiteralTextChanges
+        && options.explicitStructuredContent === true
+        && isListTargetLoose(cleanModifiedText)
+        && !sourceMatchesListShape(paragraphs, cleanModifiedText);
+    const hasTextChanges = hasLiteralTextChanges || hasListStructureChange;
+    const hasFormatHints = formatHints.length > 0;
     const hasExistingFormatting = existingFormatHints.length > 0;
-    const visibleText = textSpans.map(span => textSpanVisibleText(span)).join('');
+    // Formatting spans carry only w:t text. Target matching also needs w:br,
+    // w:cr and w:tab so host text with soft line breaks (Word's Paragraph.text
+    // reports them as "\v") still matches its source paragraph.
+    const { textSpans: targetSpans } = buildTextSpansFromParagraphs(paragraphs);
+    const visibleText = targetSpans.map(span => textSpanVisibleText(span)).join('');
     const targetFound = originalText.includes('\n') || originalText.includes('\r')
         ? originalText
             .split(/\r?\n/)
             .map(normalizeTargetText)
             .filter(Boolean)
             .every(line => paragraphs.some(paragraph => {
-                const paragraphText = textSpans
+                const paragraphText = targetSpans
                     .filter(span => span.paragraph === paragraph)
                     .map(textSpanVisibleText)
                     .join('');
@@ -555,12 +566,14 @@ export async function applyRedlineToOxml(oxml, originalText, modifiedText, optio
     const tables = getElementsByTagNSOrTag(xmlDoc, NS_W, 'tbl');
     const hasTables = tables.length > 0;
     const isMarkdownTable = /^\|.+\|/.test(cleanModifiedText.trim()) && cleanModifiedText.includes('\n');
-    const isTargetList = isListTargetLoose(cleanModifiedText);
+    // Localized replacements are literal text edits: marker-like lines ("A. ..." separated by
+    // soft breaks) must not be re-interpreted as a request to build a numbered list.
+    const isTargetList = options.literalTextEdit !== true && isListTargetLoose(cleanModifiedText);
     const isStructuredContent = options.structuredContent !== false && structuredAnalysis?.requiresStructuredContent === true;
     const tableCellContext = initialTableCellContext;
 
-    const usesSurgicalTextMode = hasTables || existingRevisionsPolicy === 'slice-cross-author';
-    log(`[OxmlEngine] Mode: ${usesSurgicalTextMode ? 'SURGICAL' : 'RECONSTRUCTION'}, formatHints: ${formatHints.length}, isMarkdownTable: ${isMarkdownTable}, isTargetList: ${isTargetList}, isTableCellParagraph: ${tableCellContext.isTableCellParagraph}`);
+    const usesSurgicalTextMode = hasTables || existingRevisionsPolicy === 'slice-cross-author';
+    log(`[OxmlEngine] Mode: ${usesSurgicalTextMode ? 'SURGICAL' : 'RECONSTRUCTION'}, formatHints: ${formatHints.length}, isMarkdownTable: ${isMarkdownTable}, isTargetList: ${isTargetList}, isTableCellParagraph: ${tableCellContext.isTableCellParagraph}`);
 
     try {
     if (isMarkdownTable && !hasTables) {
@@ -573,8 +586,8 @@ export async function applyRedlineToOxml(oxml, originalText, modifiedText, optio
         recordRouteSelection(options, 'table', { transformation: 'table-reconciliation' });
         return finalize(applyTableReconciliation(xmlDoc, cleanModifiedText, serializer, null, author, generateRedlines));
     }
-    if (usesSurgicalTextMode) {
-        recordRouteSelection(options, 'surgical', { tableScoped: hasTables });
+    if (usesSurgicalTextMode) {
+        recordRouteSelection(options, 'surgical', { tableScoped: hasTables });
         const surgicalTarget = tableCellContext.hasTableWrapper && tableCellContext.targetParagraph
             ? tableCellContext.targetParagraph
             : null;
@@ -582,7 +595,7 @@ export async function applyRedlineToOxml(oxml, originalText, modifiedText, optio
             log('[OxmlEngine] Table cell edit: scoping surgical mode to target paragraph');
         }
 
-        const result = applySurgicalMode(
+        const result = applySurgicalMode(
             xmlDoc,
             originalText,
             cleanModifiedText,
@@ -592,14 +605,14 @@ export async function applyRedlineToOxml(oxml, originalText, modifiedText, optio
             generateRedlines,
             surgicalTarget,
             {},
-            options
-        );
-
-        if (result.status === 'error' && result.error?.code === 'PATCH_ROUNDTRIP_MISMATCH') {
-            return finalize({ ...result, oxml: inputOoxml, hasChanges: false });
-        }
-
-        if (tableCellContext.hasTableWrapper && result.hasChanges && tableCellContext.targetParagraph) {
+            options
+        );
+
+        if (result.status === 'error' && result.error?.code === 'PATCH_ROUNDTRIP_MISMATCH') {
+            return finalize({ ...result, oxml: inputOoxml, hasChanges: false });
+        }
+
+        if (tableCellContext.hasTableWrapper && result.hasChanges && tableCellContext.targetParagraph) {
             log('[OxmlEngine] Stripping table wrapper for table cell paragraph (surgical mode)');
             return finalize({ oxml: serializeParagraphOnly(xmlDoc, tableCellContext.targetParagraph, serializer), hasChanges: true });
         }
@@ -682,6 +695,13 @@ export async function applyRedlineToOxml(oxml, originalText, modifiedText, optio
     }
 }
 
+function sourceMatchesListShape(paragraphs, listText) {
+    const itemCount = String(listText).split(/\r?\n/).filter(line => line.trim()).length;
+    return paragraphs.length === itemCount && paragraphs.every(paragraph => (
+        getElementsByTagNSOrTag(paragraph, NS_W, 'numPr').length > 0
+    ));
+}
+
 function normalizeTargetText(text) {
     return String(text || '').replace(/[\t\n\u2011]/g, ' ').replace(/\s+/g, ' ').trim();
 }