@ansonlai/docx-redline-js 0.1.4 → 0.1.6

package/docs/VALIDATION.md

@@ -0,0 +1,48 @@
+# Validation
+
+This package works on OOXML strings and intentionally leaves `.docx` zip
+packaging to consumers. Release validation should therefore check both XML
+invariants and at least one real OOXML consumer.
+
+## Automated Checks
+
+Run:
+
+```bash
+npm test
+npm run test:isolation
+npm run check:types
+```
+
+## Export Fixture Parts
+
+Run:
+
+```bash
+node scripts/export-validation-fixtures.mjs
+```
+
+The script writes generated `word/document.xml` payloads to
+`tmp/validation-docx/`. If a case emits numbering XML, it writes that alongside
+the document XML. The script does not create full `.docx` files because the
+library intentionally avoids a zip dependency.
+
+## Manual Consumer Checks
+
+To inspect in Microsoft Word or LibreOffice:
+
+1. Start from a minimal valid `.docx` package.
+2. Replace `word/document.xml` with one generated `*.document.xml` fixture.
+3. Add matching `word/numbering.xml` when present.
+4. Open the document and confirm the file opens without repair prompts and the
+   expected tracked changes are visible.
+
+On Windows with desktop Word installed, the optional COM smoke script described
+in the improvement plan can be used to open a completed `.docx` and count
+revisions.
+
+With LibreOffice installed, a quick parser check is:
+
+```bash
+soffice --headless --convert-to pdf path/to/fixtures/*.docx
+```

package/docs/plans/2026-03-01-release-0.1.4-design.md

@@ -0,0 +1,31 @@
+# 0.1.4 Release Prep Design
+
+**Objective:** Prepare the repository for a `0.1.4` patch release without publishing from this session.
+
+## Scope
+
+- Bump the package version from `0.1.3` to `0.1.4` in release metadata.
+- Update local release-note examples that are pinned to the prior version.
+- Run release preflight verification locally after the version bump.
+- Hand off the exact npm commands for the manual publish step.
+
+## Approach
+
+Use minimal, explicit edits so the release prep is easy to review. Keep the release workflow local and manual, consistent with the existing policy in `.anson/release-ci-cd-notes.md`.
+
+## Verification
+
+Run the same preflight commands documented in the local release notes:
+
+- `npm test:isolation`
+- `npm test`
+- `npm run build`
+- `npm pack --dry-run`
+
+## Manual Handoff
+
+After verification, provide the exact commands for:
+
+- `npm whoami`
+- `npm publish --access public`
+- `npm view @ansonlai/docx-redline-js version`

package/docs/plans/2026-03-01-release-0.1.4.md

@@ -0,0 +1,108 @@
+# 0.1.4 Release Prep Implementation Plan
+
+> **For Claude:** REQUIRED SUB-SKILL: Use superpowers:executing-plans to implement this plan task-by-task.
+
+**Goal:** Prepare the repository for a local/manual `0.1.4` release and verify it is ready to publish.
+
+**Architecture:** Keep the release prep narrowly scoped to version metadata, local release instructions, and preflight verification. Do not publish from the implementation step; instead, leave the workspace in a verified, reviewable state and hand off the final npm commands.
+
+**Tech Stack:** Node.js, npm, PowerShell, package metadata files
+
+---
+
+### Task 1: Update Release Metadata
+
+**Files:**
+- Create: `docs/plans/2026-03-01-release-0.1.4-design.md`
+- Create: `docs/plans/2026-03-01-release-0.1.4.md`
+- Modify: `package.json`
+- Modify: `package-lock.json`
+- Modify: `.anson/release-ci-cd-notes.md`
+
+**Step 1: Write the failing test**
+
+Inspect the current version references and confirm they still show `0.1.3`.
+
+**Step 2: Run test to verify it fails**
+
+Run: `rg -uu -n "0\\.1\\.3|0\\.1\\.4" .`
+Expected: package metadata and local release-note examples still point to `0.1.3`.
+
+**Step 3: Write minimal implementation**
+
+- Change package version fields to `0.1.4`.
+- Update local release-note example commands and CDN URLs to `0.1.4`.
+- Save the release design and implementation plan docs.
+
+**Step 4: Run test to verify it passes**
+
+Run: `rg -uu -n "0\\.1\\.3|0\\.1\\.4" package.json package-lock.json .anson/release-ci-cd-notes.md`
+Expected: only `0.1.4` appears in those release-facing files.
+
+**Step 5: Commit**
+
+```bash
+git add docs/plans/2026-03-01-release-0.1.4-design.md docs/plans/2026-03-01-release-0.1.4.md package.json package-lock.json .anson/release-ci-cd-notes.md
+git commit -m "release: prep v0.1.4"
+```
+
+### Task 2: Run Release Preflight
+
+**Files:**
+- Modify: `dist/docx-redline-js.esm.js`
+
+**Step 1: Write the failing test**
+
+Assume the built artifact banner still reflects the previous version until the build runs.
+
+**Step 2: Run test to verify it fails**
+
+Run: `rg -n "v0\\.1\\.3|v0\\.1\\.4" dist/docx-redline-js.esm.js`
+Expected: the banner still shows `v0.1.3` before rebuilding.
+
+**Step 3: Write minimal implementation**
+
+Run the documented preflight:
+
+- `npm test:isolation`
+- `npm test`
+- `npm run build`
+- `npm pack --dry-run`
+
+**Step 4: Run test to verify it passes**
+
+Run: `rg -n "v0\\.1\\.3|v0\\.1\\.4" dist/docx-redline-js.esm.js`
+Expected: the banner shows `v0.1.4`, and the preflight commands complete successfully.
+
+**Step 5: Commit**
+
+```bash
+git add dist/docx-redline-js.esm.js
+git commit -m "build: refresh dist for v0.1.4"
+```
+
+### Task 3: Publish Handoff
+
+**Files:**
+- No file changes
+
+**Step 1: Write the failing test**
+
+Confirm the package is not yet published from this session.
+
+**Step 2: Run test to verify it fails**
+
+Run: `npm view @ansonlai/docx-redline-js version`
+Expected: the registry version may still report the prior published release until you publish manually.
+
+**Step 3: Write minimal implementation**
+
+Provide the exact local commands for npm auth check, publish, optional tag push, and post-publish verification.
+
+**Step 4: Run test to verify it passes**
+
+User runs the publish commands locally and confirms `npm view @ansonlai/docx-redline-js version` returns `0.1.4`.
+
+**Step 5: Commit**
+
+No additional commit required.

package/engine/format-application.js

@@ -8,13 +8,13 @@
 import { mergeFormats } from '../pipeline/markdown-processor.js';
 import { applyFormatOverridesToRPr, extractFormatFromRPr } from './rpr-helpers.js';
 import { snapshotAndAttachRPrChange, injectFormattingToRPr } from './run-builders.js';
-import { getDocumentParagraphs, buildTextSpansFromParagraphs } from './format-extraction.js';
-import { buildParagraphInfos, findTargetParagraphInfo } from './format-paragraph-targeting.js';
-import { splitSpansAtBoundaries, applyFormatHintsToSpansRobust } from './format-span-application.js';
-import { getRevisionTimestamp } from '../core/types.js';
+import { getDocumentParagraphs, buildTextSpansFromParagraphs } from './format-extraction.js';
+import { buildParagraphInfos, findTargetParagraphInfo } from './format-paragraph-targeting.js';
+import { splitSpansAtBoundaries, applyFormatHintsToSpansRobust } from './format-span-application.js';
 import { warn, log } from '../adapters/logger.js';
 import { getFirstElementByTag } from '../core/xml-query.js';
 import { getDefaultAuthor } from '../adapters/config.js';
+import { createWordElement } from '../core/word-xml.js';
 
 const NS_W = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
 
@@ -62,9 +62,8 @@ function normalizePrecomputedFormatContext(precomputedContext) {
  */
 export function applyFormatRemovalAsSurgicalReplacement(xmlDoc, textSpans, existingFormatHints, serializer, author, generateRedlines = true) {
     void textSpans;
-    let hasAnyChanges = false;
-    const processedRuns = new Set();
-    const dateStr = getRevisionTimestamp();
+    let hasAnyChanges = false;
+    const processedRuns = new Set();
 
     log(`[OxmlEngine] Surgical format removal: ${existingFormatHints.length} hints to process (using w:rPrChange)`);
 
@@ -76,14 +75,14 @@ export function applyFormatRemovalAsSurgicalReplacement(xmlDoc, textSpans, exist
 
         log('[OxmlEngine] Processing run for surgical format removal, format:', hint.format);
 
-        let rPr = getFirstElementByTag(run, 'w:rPr');
-        if (!rPr) {
-            rPr = xmlDoc.createElement('w:rPr');
-            run.insertBefore(rPr, run.firstChild);
-        }
-
+        let rPr = getFirstElementByTag(run, 'w:rPr');
+        if (!rPr) {
+            rPr = createWordElement(xmlDoc, 'w:rPr');
+            run.insertBefore(rPr, run.firstChild);
+        }
+
         if (generateRedlines) {
-            snapshotAndAttachRPrChange(xmlDoc, rPr, author || getDefaultAuthor(), dateStr);
+            snapshotAndAttachRPrChange(xmlDoc, rPr, author || getDefaultAuthor());
         }
 
         applyFormatOverridesToRPr(xmlDoc, rPr, hint.format);

package/engine/format-span-application.js

@@ -5,8 +5,9 @@
  * text spans without owning paragraph targeting concerns.
  */
 
-import { mergeFormats } from '../pipeline/markdown-processor.js';
-import { injectFormattingToRPr, createTextRun } from './run-builders.js';
+import { mergeFormats } from '../pipeline/markdown-processor.js';
+import { injectFormattingToRPr, createTextRun } from './run-builders.js';
+import { createWordElement } from '../core/word-xml.js';
 
 /**
  * Splits spans at all supplied absolute boundaries.
@@ -166,10 +167,10 @@ function addFormattingToRun(xmlDoc, run, format, author, generateRedlines) {
     let rPr = run.getElementsByTagName('w:rPr')[0];
     const baseRPr = rPr ? rPr.cloneNode(true) : null;
 
-    if (!rPr) {
-        rPr = xmlDoc.createElement('w:rPr');
-        run.insertBefore(rPr, run.firstChild);
-    }
+    if (!rPr) {
+        rPr = createWordElement(xmlDoc, 'w:rPr');
+        run.insertBefore(rPr, run.firstChild);
+    }
 
     const newRPr = injectFormattingToRPr(xmlDoc, baseRPr, format, author, generateRedlines);
 

package/engine/formatting-removal.js

@@ -7,6 +7,8 @@
 
 import { parseOoxml, serializeOoxml } from './oxml-engine.js';
 import { getDefaultAuthor } from '../adapters/config.js';
+import { createRevisionMetadata } from '../core/types.js';
+import { createWordElement } from '../core/word-xml.js';
 
 /**
  * Removes specific formatting properties from a run properties (w:rPr) element.
@@ -154,7 +156,7 @@ export function injectHighlightIntoRPr(doc, rPr, color = 'yellow', options = {})
     let rPrElement = rPr;
     if (!rPrElement) {
         // Create new rPr element
-        rPrElement = doc.createElementNS(NS_W, 'w:rPr');
+        rPrElement = createWordElement(doc, 'w:rPr');
     } else {
         rPrElement = rPr.cloneNode(true);
     }
@@ -163,7 +165,7 @@ export function injectHighlightIntoRPr(doc, rPr, color = 'yellow', options = {})
     // Clone the *original* rPr children before we touch them
     let previousRPrState = null;
     if (generateRedlines) {
-        previousRPrState = doc.createElementNS(NS_W, 'w:rPr');
+        previousRPrState = createWordElement(doc, 'w:rPr');
         Array.from(rPrElement.childNodes).forEach(child => {
             // Don't include existing rPrChange in the "previous" state wrapper usually, 
             // but for simplicity we clone children. Word generally handles nested track changes poorly,
@@ -180,18 +182,19 @@ export function injectHighlightIntoRPr(doc, rPr, color = 'yellow', options = {})
     Array.from(existingHighlight).forEach(el => el.remove());
 
     // Create and add new highlight element
-    const highlightEl = doc.createElementNS(NS_W, 'w:highlight');
+    const highlightEl = createWordElement(doc, 'w:highlight');
     highlightEl.setAttributeNS(NS_W, 'w:val', ooxmlColor);
     rPrElement.appendChild(highlightEl);
 
     // --- WRAP IN REDLINES IF ENABLED ---
     if (generateRedlines && previousRPrState) {
-        const rPrChange = doc.createElementNS(NS_W, 'w:rPrChange');
-
-        // Attributes
-        rPrChange.setAttributeNS(NS_W, 'w:id', Math.floor(Math.random() * 9999999).toString());
-        rPrChange.setAttributeNS(NS_W, 'w:author', author);
-        rPrChange.setAttributeNS(NS_W, 'w:date', new Date().toISOString());
+        const rPrChange = createWordElement(doc, 'w:rPrChange');
+
+        // Attributes
+        const metadata = createRevisionMetadata(author);
+        rPrChange.setAttribute('w:id', String(metadata.id));
+        rPrChange.setAttribute('w:author', metadata.author);
+        rPrChange.setAttribute('w:date', metadata.date);
 
         // Format: <w:rPrChange ...> <w:rPr>...previous...</w:rPr> </w:rPrChange>
         rPrChange.appendChild(previousRPrState);
@@ -272,7 +275,7 @@ export function applyHighlightToOoxml(ooxmlString, targetText, color = 'yellow',
             const tNodes = prefixRun.getElementsByTagNameNS(NS_W, 't');
             // Simply remove all t nodes and add one with new text to avoid complexity of multiple t nodes
             Array.from(tNodes).forEach(t => t.remove());
-            const newT = doc.createElementNS(NS_W, 'w:t');
+            const newT = createWordElement(doc, 'w:t');
             // Preserve xml:space="preserve" if it existed, or just add it usually
             newT.setAttribute('xml:space', 'preserve');
             newT.textContent = prefixText;
@@ -286,7 +289,7 @@ export function applyHighlightToOoxml(ooxmlString, targetText, color = 'yellow',
             // Update text content
             const tNodes = matchRun.getElementsByTagNameNS(NS_W, 't');
             Array.from(tNodes).forEach(t => t.remove());
-            const newT = doc.createElementNS(NS_W, 'w:t');
+            const newT = createWordElement(doc, 'w:t');
             newT.setAttribute('xml:space', 'preserve');
             newT.textContent = matchText;
             matchRun.appendChild(newT);
@@ -310,7 +313,7 @@ export function applyHighlightToOoxml(ooxmlString, targetText, color = 'yellow',
             // Update text content
             const tNodes = suffixRun.getElementsByTagNameNS(NS_W, 't');
             Array.from(tNodes).forEach(t => t.remove());
-            const newT = doc.createElementNS(NS_W, 'w:t');
+            const newT = createWordElement(doc, 'w:t');
             newT.setAttribute('xml:space', 'preserve');
             newT.textContent = suffixText;
             suffixRun.appendChild(newT);

package/engine/oxml-engine.js

@@ -7,11 +7,11 @@
 import { preprocessMarkdown } from '../pipeline/markdown-processor.js';
 import { isListTargetLoose } from '../pipeline/list-markers.js';
 import { ReconciliationPipeline } from '../pipeline/pipeline.js';
-import { wrapInDocumentFragment } from '../pipeline/serialization.js';
-import {
-    getElementsByTag,
-    getXmlParseError
-} from '../core/xml-query.js';
+import { wrapInDocumentFragment } from '../pipeline/serialization.js';
+import {
+    getElementsByTagNSOrTag,
+    getXmlParseError
+} from '../core/xml-query.js';
 import { createParser, createSerializer, parseXml, serializeXml } from '../adapters/xml-adapter.js';
 import { log, error } from '../adapters/logger.js';
 import { extractFormattingFromOoxml } from './format-extraction.js';
@@ -25,6 +25,9 @@ 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, withOoxmlSourceType } from '../core/word-xml.js';
+import { NS_W, seedRevisionIdsFromDocument } from '../core/types.js';
+import { acceptTrackedChangesInOoxml } from '../services/revision-comment-management.js';
 
 /**
  * Applies redline track changes to OOXML by modifying the DOM in-place.
@@ -32,33 +35,87 @@ import { getDefaultAuthor } from '../adapters/config.js';
  * @param {string} oxml - Original OOXML string
  * @param {string} originalText - Original plain text
  * @param {string} modifiedText - New text (may contain markdown)
- * @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
- * @returns {Promise<{ oxml: string, hasChanges: boolean }>}
- */
+ * @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 {'reject-input'|'accept-all-first'} [options.existingRevisions='reject-input'] - Policy for source OOXML with tracked changes
+ * @returns {Promise<{ oxml: string, hasChanges: boolean, sourceType?: 'package'|'document'|'fragment', status?: 'ok'|'no-op'|'error', error?: { code: string, message: string } }>}
+ */
 export async function applyRedlineToOxml(oxml, originalText, modifiedText, options = {}) {
     const generateRedlines = options.generateRedlines ?? true;
     const author = options.author || getDefaultAuthor();
     const parser = createParser();
     const serializer = createSerializer();
-    const noChanges = () => ({ oxml, hasChanges: false });
+    const finalize = result => {
+        const withStatus = { ...result };
+        if (!withStatus.status) {
+            withStatus.status = withStatus.hasChanges ? 'ok' : 'no-op';
+        }
+        return withOoxmlSourceType(withStatus);
+    };
+    const noChanges = () => finalize({ oxml, hasChanges: false });
 
     let xmlDoc;
     try {
         xmlDoc = parser.parseFromString(oxml, 'text/xml');
-    } catch (e) {
-        error('[OxmlEngine] Failed to parse OXML:', e);
-        return noChanges();
-    }
-
-    const parseError = getXmlParseError(xmlDoc);
-    if (parseError) {
-        error('[OxmlEngine] XML parse error:', parseError.textContent);
-        return noChanges();
-    }
-
-    const initialTableCellContext = detectTableCellContext(xmlDoc, originalText, options);
+    } catch (e) {
+        error('[OxmlEngine] Failed to parse OXML:', e);
+        return finalize({
+            oxml,
+            hasChanges: false,
+            status: 'error',
+            error: { code: 'PARSE_ERROR', message: 'Could not parse OOXML input.' }
+        });
+    }
+
+    const parseError = getXmlParseError(xmlDoc);
+    if (parseError) {
+        error('[OxmlEngine] XML parse error:', parseError.textContent);
+        return finalize({
+            oxml,
+            hasChanges: false,
+            status: 'error',
+            error: { code: 'PARSE_ERROR', message: parseError.textContent || 'Could not parse OOXML input.' }
+        });
+    }
+    seedRevisionIdsFromDocument(xmlDoc);
+
+    if (containsTrackedChanges(xmlDoc)) {
+        const existingRevisionsPolicy = options.existingRevisions || 'reject-input';
+        if (existingRevisionsPolicy === 'accept-all-first') {
+            log('[OxmlEngine] Existing revisions detected; accepting all input revisions before redlining');
+            const accepted = acceptTrackedChangesInOoxml(oxml, { allAuthors: true });
+            oxml = accepted.oxml;
+            xmlDoc = parser.parseFromString(oxml, 'text/xml');
+            const acceptedParseError = getXmlParseError(xmlDoc);
+            if (acceptedParseError) {
+                error('[OxmlEngine] XML parse error after accepting existing revisions:', acceptedParseError.textContent);
+                return finalize({
+                    oxml,
+                    hasChanges: false,
+                    status: 'error',
+                    error: {
+                        code: 'PARSE_ERROR',
+                        message: 'Could not parse OOXML after accepting existing revisions.'
+                    }
+                });
+            }
+            seedRevisionIdsFromDocument(xmlDoc);
+        } else {
+            log('[OxmlEngine] Existing revisions detected; rejecting input per existingRevisions policy');
+            return finalize({
+                oxml,
+                hasChanges: false,
+                status: 'error',
+                error: {
+                    code: 'EXISTING_REVISIONS',
+                    message: 'Input OOXML contains existing tracked changes. Pass existingRevisions: "accept-all-first" to normalize before redlining.'
+                }
+            });
+        }
+    }
+
+    const initialTableCellContext = detectTableCellContext(xmlDoc, originalText, options);
     if (initialTableCellContext.hasTableWrapper && initialTableCellContext.targetParagraph && !options._isolatedTableCell) {
         log('[OxmlEngine] Isolating table-cell paragraph before diff');
         const isolatedOxml = serializeParagraphOnly(xmlDoc, initialTableCellContext.targetParagraph, serializer);
@@ -74,8 +131,29 @@ export async function applyRedlineToOxml(oxml, originalText, modifiedText, optio
     const hasTextChanges = cleanModifiedText.trim() !== originalText.trim();
     const hasFormatHints = formatHints.length > 0;
 
-    const { existingFormatHints, textSpans, paragraphs } = extractFormattingFromOoxml(xmlDoc);
+    const { existingFormatHints, textSpans, paragraphs } = extractFormattingFromOoxml(xmlDoc);
     const hasExistingFormatting = existingFormatHints.length > 0;
+    const visibleText = textSpans.map(span => textSpanVisibleText(span)).join('');
+    if (
+        hasTextChanges
+        && typeof originalText === 'string'
+        && originalText.trim()
+        && !originalText.includes('\n')
+        && !visibleText.includes(originalText.trim())
+        && !visibleText.replace(/[\t\n\u2011]/g, '').includes(originalText.trim().replace(/[\t\n\u2011]/g, ''))
+        && !normalizeTargetText(visibleText).includes(normalizeTargetText(originalText))
+    ) {
+        log('[OxmlEngine] Target text not found in OOXML');
+        return finalize({
+            oxml,
+            hasChanges: false,
+            status: 'error',
+            error: {
+                code: 'TARGET_NOT_FOUND',
+                message: 'Original text was not found in the supplied OOXML.'
+            }
+        });
+    }
     let paragraphInfos = null;
     const getParagraphInfos = () => {
         if (!paragraphInfos) {
@@ -149,13 +227,13 @@ export async function applyRedlineToOxml(oxml, originalText, modifiedText, optio
         );
 
         if (tableCellCtx.hasTableWrapper && targetParagraph) {
-            return {
-                oxml: serializeParagraphOnly(xmlDoc, targetParagraph, serializer),
-                hasChanges: removalResult.hasChanges
-            };
-        }
-
-        return removalResult;
+            return finalize({
+                oxml: serializeParagraphOnly(xmlDoc, targetParagraph, serializer),
+                hasChanges: removalResult.hasChanges
+            });
+        }
+
+        return finalize(removalResult);
     }
 
     if (!hasTextChanges && hasFormatHints) {
@@ -173,16 +251,16 @@ export async function applyRedlineToOxml(oxml, originalText, modifiedText, optio
             const formatResult = applyFormatOnlyWithOoxmlFallback(precomputedFormatContext);
 
             log('[OxmlEngine] Stripping table wrapper for table cell paragraph (format-only)');
-            return {
+            return finalize({
                 oxml: serializeParagraphOnly(xmlDoc, tableCellCtx.targetParagraph, serializer),
                 hasChanges: formatResult.hasChanges
-            };
+            });
         }
 
-        return applyFormatOnlyWithOoxmlFallback(precomputedFormatContext);
+        return finalize(applyFormatOnlyWithOoxmlFallback(precomputedFormatContext));
     }
 
-    const tables = getElementsByTag(xmlDoc, 'w:tbl');
+    const tables = getElementsByTagNSOrTag(xmlDoc, NS_W, 'tbl');
     const hasTables = tables.length > 0;
     const isMarkdownTable = /^\|.+\|/.test(cleanModifiedText.trim()) && cleanModifiedText.includes('\n');
     const isTargetList = isListTargetLoose(cleanModifiedText);
@@ -192,12 +270,12 @@ export async function applyRedlineToOxml(oxml, originalText, modifiedText, optio
 
     if (isMarkdownTable && !hasTables) {
         log('[OxmlEngine] Text-to-table transformation: generating new table from Markdown');
-        return applyTextToTableTransformation(xmlDoc, cleanModifiedText, serializer, parser, author, generateRedlines);
-    }
-
-    if (hasTables && isMarkdownTable) {
-        return applyTableReconciliation(xmlDoc, cleanModifiedText, serializer, parser, author, generateRedlines);
-    }
+        return finalize(applyTextToTableTransformation(xmlDoc, cleanModifiedText, serializer, parser, author, generateRedlines));
+    }
+
+    if (hasTables && isMarkdownTable) {
+        return finalize(applyTableReconciliation(xmlDoc, cleanModifiedText, serializer, parser, author, generateRedlines));
+    }
     if (hasTables) {
         const surgicalTarget = tableCellContext.hasTableWrapper && tableCellContext.targetParagraph
             ? tableCellContext.targetParagraph
@@ -217,11 +295,11 @@ export async function applyRedlineToOxml(oxml, originalText, modifiedText, optio
             surgicalTarget
         );
 
-        if (tableCellContext.hasTableWrapper && result.hasChanges && tableCellContext.targetParagraph) {
-            log('[OxmlEngine] Stripping table wrapper for table cell paragraph (surgical mode)');
-            return { oxml: serializeParagraphOnly(xmlDoc, tableCellContext.targetParagraph, serializer), hasChanges: true };
-        }
-        return result;
+        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 });
+        }
+        return finalize(result);
     }
     if (isTargetList) {
         log('[OxmlEngine] 🎯 Using reconciliation pipeline for list generation');
@@ -235,15 +313,28 @@ export async function applyRedlineToOxml(oxml, originalText, modifiedText, optio
                 numberingXml: result.numberingXml
             });
             log(`[OxmlEngine] ✅ Wrapped OOXML length: ${wrapped.length}`);
-            return { oxml: wrapped, hasChanges: true };
-        }
-        return noChanges();
-    }
-
-    return applyReconstructionMode(xmlDoc, originalText, cleanModifiedText, serializer, author, formatHints, generateRedlines);
-}
-
-/**
+            return finalize({ oxml: wrapped, hasChanges: true });
+        }
+        return noChanges();
+    }
+
+    return finalize(applyReconstructionMode(xmlDoc, originalText, cleanModifiedText, serializer, author, formatHints, generateRedlines));
+}
+
+function normalizeTargetText(text) {
+    return String(text || '').replace(/[\t\n\u2011]/g, ' ').replace(/\s+/g, ' ').trim();
+}
+
+function textSpanVisibleText(span) {
+    const node = span?.textElement;
+    const localName = String(node?.localName || node?.nodeName || '').replace(/^.*:/, '');
+    if (localName === 'tab') return '\t';
+    if (localName === 'br' || localName === 'cr') return '\n';
+    if (localName === 'noBreakHyphen') return '\u2011';
+    return node?.textContent || '';
+}
+
+/**
  * Sanitizes AI response text by removing common prefixes.
  *
  * @param {string} text - AI response text