@ansonlai/docx-redline-js 0.8.4 → 0.10.0

package/pipeline/list-generation.js

@@ -1,419 +1,415 @@
-/**
- * List generation flow extracted from ReconciliationPipeline.
- */
-
-import { preprocessMarkdown } from './markdown-processor.js';
-import { matchListMarker, stripListMarker } from './list-markers.js';
-import { serializeToOoxml } from './serialization.js';
-import { generateTableOoxml } from '../services/table-reconciliation.js';
-import { parseTable } from './content-analysis.js';
-import { log } from '../adapters/logger.js';
-import { createRevisionMetadata, NS_W, RunKind } from '../core/types.js';
-import { parseOoxmlSafe, serializeXml } from '../adapters/xml-adapter.js';
-import { createWordElement } from '../core/word-xml.js';
-
-/**
- * Executes list generation when paragraph content expands into list/table blocks.
- *
- * @param {Object} options - Generation options
- * @param {string} options.cleanText - Preprocessed target text
- * @param {Object|null} options.numberingContext - Existing numbering context
- * @param {Array} [options.originalRunModel=[]] - Original run model
- * @param {string} [options.originalText=''] - Original text fallback
- * @param {boolean} [options.generateRedlines=true] - Track-change toggle
- * @param {string} [options.author='AI'] - Author metadata
- * @param {string|null} [options.font=null] - Optional font
- * @param {import('../services/numbering-service.js').NumberingService} options.numberingService - Numbering service
- * @returns {Promise<import('../core/types.js').ReconciliationResult>}
- */
-export async function executeListGeneration(options) {
-    const {
-        cleanText,
-        numberingContext,
-        originalRunModel = [],
-        originalText = '',
-        generateRedlines = true,
-        author = 'AI',
-        font = null,
-        revisionIdAllocator = null,
-        numberingService
-    } = options;
-
-    const normalizedListText = normalizeCompositeListMarkers(cleanText);
-    const lineMetadata = buildLineMetadata(normalizedListText);
-    const rawLines = lineMetadata.map(line => line.raw);
-    const results = [];
-    const sourcePPr = getSourceParagraphProperties(originalRunModel);
-    const inheritedTypographyRPrXml = extractInheritedTypographyRPrXml(originalRunModel, sourcePPr);
-    const inheritedHeadingRPrXml = extractInheritedTypographyRPrXml(
-        originalRunModel,
-        sourcePPr,
-        ['rFonts', 'kern', 'position', 'rtl', 'cs', 'lang']
-    );
-
-    let deletionRuns = [];
-    if (generateRedlines) {
-        if (originalRunModel && originalRunModel.length > 0) {
-            deletionRuns = originalRunModel
-                .filter(run => run.kind === 'text' || run.kind === 'run')
-                .map(run => ({ ...run, kind: 'deletion', author }));
-        } else if (originalText && originalText.trim().length > 0) {
-            const trimmed = originalText.trim();
-            deletionRuns = [{
-                kind: 'deletion',
-                text: trimmed,
-                author,
-                startOffset: 0,
-                endOffset: trimmed.length
-            }];
-        }
-    }
-
-    const sourceParagraphCount = (originalRunModel || [])
-        .filter(run => run.kind === RunKind.PARAGRAPH_START).length;
-    if (generateRedlines && sourceParagraphCount > 0 && (sourceParagraphCount > 1 || deletionRuns.length === 0)) {
-        // Each source paragraph keeps its own deleted paragraph (content and tracked-deleted mark), so
-        // Reject All restores every original paragraph boundary instead of merging them into one.
-        // Serialize each source paragraph on its own so empty paragraphs are emitted too (an empty
-        // paragraph carrying only its tracked-deleted mark).
-        let segment = null;
-        const flushSegment = () => {
-            if (!segment) return;
-            results.push(serializeToOoxml(segment, null, [], {
-                author,
-                generateRedlines,
-                revisionIdAllocator
-            }));
-            segment = null;
-        };
-        for (const run of originalRunModel) {
-            if (run.kind === RunKind.PARAGRAPH_START) {
-                flushSegment();
-                segment = [{
-                    ...run,
-                    pPrElement: null,
-                    pPrXml: addParagraphMarkRevision(
-                        run.pPrElement || run.pPrXml || null,
-                        'del',
-                        author,
-                        revisionIdAllocator
-                    )
-                }];
-            } else if (segment && (run.kind === 'text' || run.kind === 'run')) {
-                segment.push({ ...run, kind: 'deletion', author });
-            }
-        }
-        flushSegment();
-    } else if (generateRedlines && deletionRuns.length > 0) {
-        const deletedPPr = addParagraphMarkRevision(sourcePPr, 'del', author, revisionIdAllocator);
-        const deletedParagraph = serializeToOoxml(deletionRuns, deletedPPr, [], {
-            author,
-            generateRedlines,
-            revisionIdAllocator
-        });
-        results.push(deletedParagraph);
-    }
-
-    const indentStep = detectIndentationStep(rawLines);
-    log(`[ListGen] Detected indentation step: ${indentStep} spaces/chars`);
-
-    const firstMarker = lineMetadata.find(line => line.marker)?.marker || '';
-    const { format: defaultFormat } = numberingService.detectNumberingFormat(firstMarker);
-    log(`[ListGen] Detected primary marker: "${firstMarker}", format: ${defaultFormat}`);
-
-    for (let i = 0; i < lineMetadata.length; i++) {
-        const tableBlock = collectMarkdownTableBlock(lineMetadata, i);
-        if (tableBlock) {
-            const tableData = parseTable(tableBlock.tableText);
-            if (tableData.headers.length > 0 || tableData.rows.length > 0) {
-                results.push(generateTableOoxml(tableData, {
-                    generateRedlines,
-                    author,
-                    revisionIdAllocator,
-                    trackAsBlock: true
-                }));
-                i = tableBlock.endIndex;
-                continue;
-            }
-        }
-
-        const line = lineMetadata[i];
-        const entry = buildListEntry(
-            line,
-            indentStep,
-            numberingContext,
-            numberingService,
-            generateRedlines,
-            author,
-            font,
-            revisionIdAllocator,
-            inheritedTypographyRPrXml,
-            inheritedHeadingRPrXml
-        );
-        results.push(entry.ooxml);
-    }
-
-    const numberingXml = numberingService.generateNumberingXml();
-    const finalOoxml = results.join('');
-
-    log(`[ListGen] ✅ Generated OOXML for ${results.length} paragraphs, total length: ${finalOoxml.length}`);
-    log(`[ListGen] First 200 chars: ${finalOoxml.substring(0, 200)}...`);
-
-    return {
-        ooxml: finalOoxml,
-        isValid: true,
-        warnings: ['Paragraph expanded to list fragment'],
-        type: 'fragment',
-        includeNumbering: true,
-        numberingXml
-    };
-}
-
-/**
- * Heuristically detects indentation step (spaces/tabs per level).
- *
- * @param {string[]} lines - Raw lines
- * @returns {number}
- */
-export function detectIndentationStep(lines) {
-    const indentations = lines
-        .map(line => line.match(/^(\s*)/)[0].length)
-        .filter(length => length > 0)
-        .sort((a, b) => a - b);
-
-    if (indentations.length === 0) return 2;
-
-    let minJump = indentations[0];
-    for (let i = 1; i < indentations.length; i++) {
-        const jump = indentations[i] - indentations[i - 1];
-        if (jump > 0 && jump < minJump) {
-            minJump = jump;
-        }
-    }
-
-    return minJump || 2;
-}
-
-function buildLineMetadata(cleanText) {
-    return cleanText
-        .split('\n')
-        .filter(line => line.trim().length > 0)
-        .map(raw => {
-            const markerMatch = matchListMarker(raw);
-            const headerMatch = raw.match(/^\s*(#{1,9})\s+(.*)/);
-            return {
-                raw,
-                marker: markerMatch ? markerMatch[2].trim() : '',
-                headerMatch,
-                indentSize: (raw.match(/^(\s*)/)?.[1].length) || 0,
-                isTableLine: /^\s*\|/.test(raw),
-                isTableSeparator: /^\s*\|?[\s:-]*-[-\s|:]*\|?\s*$/.test(raw)
-            };
-        });
-}
-
-function normalizeCompositeListMarkers(text) {
-    const lines = String(text || '').split('\n');
-    const nonEmptyIndexes = lines
-        .map((line, index) => ({ line, index }))
-        .filter(entry => entry.line.trim().length > 0);
-    if (nonEmptyIndexes.length < 2) return text;
-
-    const rewrites = [];
-    let rewrittenCount = 0;
-
-    for (const { line, index } of nonEmptyIndexes) {
-        const outerMarkerMatch = matchListMarker(line);
-        if (!outerMarkerMatch) return text;
-
-        const stripped = stripListMarker(line);
-        const innerMarkerMatch = matchListMarker(stripped);
-        if (!innerMarkerMatch) return text;
-
-        const outerMarker = (outerMarkerMatch[2] || '').trim();
-        const innerMarker = (innerMarkerMatch[2] || '').trim();
-        if (!outerMarker || !innerMarker || outerMarker === innerMarker) return text;
-
-        const indent = outerMarkerMatch[1] || '';
-        const rewritten = `${indent}${stripped.trimStart()}`;
-        rewrites.push({ index, rewritten });
-        rewrittenCount++;
-    }
-
-    if (rewrittenCount < 2) return text;
-
-    const updated = lines.slice();
-    for (const rewrite of rewrites) {
-        updated[rewrite.index] = rewrite.rewritten;
-    }
-    log(`[ListGen] Normalized ${rewrittenCount} composite list markers (e.g., "- A." -> "A.").`);
-    return updated.join('\n');
-}
-
-function collectMarkdownTableBlock(lineMetadata, index) {
-    const current = lineMetadata[index];
-    const next = lineMetadata[index + 1];
-
-    if (!current?.isTableLine || !next?.isTableLine || !next?.isTableSeparator) {
-        return null;
-    }
-
-    const tableLines = [];
-    let cursor = index;
-    while (cursor < lineMetadata.length && lineMetadata[cursor].isTableLine) {
-        tableLines.push(lineMetadata[cursor].raw);
-        cursor++;
-    }
-
-    return {
-        tableText: tableLines.join('\n'),
-        endIndex: cursor - 1
-    };
-}
-
-function buildListEntry(
-    line,
-    indentStep,
-    numberingContext,
-    numberingService,
-    generateRedlines,
-    author,
-    font,
-    revisionIdAllocator,
-    inheritedTypographyRPrXml,
-    inheritedHeadingRPrXml
-) {
-    let pPrXml = '';
-    let segmentText = '';
-    let insertedRPrXml = inheritedTypographyRPrXml;
-
-    if (line.headerMatch) {
-        const level = Math.min(line.headerMatch[1].length, 9);
-        const outlineLevel = Math.min(level - 1, 8);
-        const headingSizes = [32, 28, 26, 24, 22, 20, 20, 20, 20];
-        const headingSize = headingSizes[level - 1] || headingSizes[headingSizes.length - 1];
-        segmentText = line.headerMatch[2].trim();
-        pPrXml = `<w:pPr><w:pStyle w:val="Heading${level}"/><w:outlineLvl w:val="${outlineLevel}"/><w:rPr><w:b/><w:sz w:val="${headingSize}"/><w:szCs w:val="${headingSize}"/></w:rPr></w:pPr>`;
-        insertedRPrXml = mergeRunProperties(
-            inheritedHeadingRPrXml,
-            `<w:rPr><w:b/><w:sz w:val="${headingSize}"/><w:szCs w:val="${headingSize}"/></w:rPr>`
-        );
-    } else if (line.marker) {
-        const lineFormat = numberingService.detectNumberingFormat(line.marker);
-        const indentLevel = indentStep > 0 ? Math.floor(line.indentSize / indentStep) : 0;
-        const contextLevel = numberingContext?.ilvl || 0;
-        const ilvl = lineFormat.format === 'outline'
-            ? Math.min(8, lineFormat.depth)
-            : Math.min(8, indentLevel + contextLevel);
-
-        segmentText = stripListMarker(line.raw);
-        const numId = numberingService.getOrCreateNumId({ type: lineFormat.format }, numberingContext);
-        pPrXml = numberingService.buildListPPr(numId, ilvl);
-    } else {
-        segmentText = line.raw;
-    }
-
-    if (generateRedlines) {
-        pPrXml = addParagraphMarkRevision(
-            pPrXml || '<w:pPr/>',
-            'ins',
-            author,
-            revisionIdAllocator
-        );
-    }
-
-    const { cleanText, formatHints } = preprocessMarkdown(segmentText);
-    const runModel = [];
-
-    runModel.push({
-        kind: generateRedlines ? 'insertion' : 'run',
-        text: cleanText,
-        rPrXml: insertedRPrXml,
-        author,
-        startOffset: 0,
-        endOffset: cleanText.length
-    });
-
-    return {
-        ooxml: serializeToOoxml(runModel, pPrXml, formatHints, {
-            author,
-            generateRedlines,
-            font,
-            revisionIdAllocator
-        })
-    };
-}
-
-function getSourceParagraphProperties(originalRunModel) {
-    const paragraphStart = (originalRunModel || []).find(run => run.kind === RunKind.PARAGRAPH_START);
-    return paragraphStart?.pPrElement || paragraphStart?.pPrXml || null;
-}
-
-function extractInheritedTypographyRPrXml(
-    originalRunModel,
-    sourcePPr,
-    tagOrder = ['rFonts', 'kern', 'position', 'sz', 'szCs', 'rtl', 'cs', 'lang']
-) {
-    const sources = (originalRunModel || [])
-        .filter(run => (run.kind === RunKind.TEXT || run.kind === 'text') && run.rPrXml)
-        .map(run => run.rPrXml);
-
-    if (sourcePPr) {
-        sources.push(typeof sourcePPr === 'string' ? sourcePPr : serializeXml(sourcePPr));
-    }
-
-    const inherited = [];
-    for (const tagName of tagOrder) {
-        let match = null;
-        for (const source of sources) {
-            match = String(source || '').match(new RegExp(`<w:${tagName}\\b[^>]*(?:\\/>|>[\\s\\S]*?<\\/w:${tagName}>)`));
-            if (match) break;
-        }
-        if (match) inherited.push(match[0]);
-    }
-
-    return inherited.length > 0 ? `<w:rPr>${inherited.join('')}</w:rPr>` : '';
-}
-
-function mergeRunProperties(...sources) {
-    const properties = sources
-        .map(source => String(source || '').replace(/^\s*<w:rPr[^>]*>|<\/w:rPr>\s*$/g, ''))
-        .filter(Boolean)
-        .join('');
-    return properties ? `<w:rPr>${properties}</w:rPr>` : '';
-}
-
-function addParagraphMarkRevision(xml, type, author, revisionIdAllocator) {
-    const metadata = createRevisionMetadata(author, revisionIdAllocator);
-    let pPr;
-    let ownerDoc;
-
-    if (xml?.nodeType === 1) {
-        pPr = xml.cloneNode(true);
-        ownerDoc = pPr.ownerDocument;
-    } else {
-        const pPrXml = typeof xml === 'string' && xml.trim() ? xml : '<w:pPr/>';
-        const parsed = parseOoxmlSafe(`<w:root xmlns:w="${NS_W}">${pPrXml}</w:root>`);
-        if (!parsed.doc) {
-            throw new Error(parsed.error?.message || 'Could not parse paragraph properties for list revision');
-        }
-        ownerDoc = parsed.doc;
-        pPr = Array.from(ownerDoc.documentElement.childNodes || []).find(node => (
-            node.nodeType === 1 && node.localName === 'pPr'
-        ));
-    }
-
-    if (!pPr || !ownerDoc) throw new Error('List paragraph properties are unavailable');
-    let rPr = Array.from(pPr.childNodes || []).find(node => node.nodeType === 1 && node.localName === 'rPr');
-    if (!rPr) {
-        rPr = createWordElement(ownerDoc, 'w:rPr');
-        pPr.appendChild(rPr);
-    }
-
-    const marker = createWordElement(ownerDoc, type === 'del' ? 'w:del' : 'w:ins');
-    marker.setAttribute('w:id', String(metadata.id));
-    marker.setAttribute('w:author', metadata.author);
-    marker.setAttribute('w:date', metadata.date);
-    rPr.appendChild(marker);
-    return serializeXml(pPr);
-}
+/**
+ * List generation flow extracted from ReconciliationPipeline.
+ */
+
+import { preprocessMarkdown } from './markdown-processor.js';
+import { matchListMarker, stripListMarker } from './list-markers.js';
+import { serializeToOoxml } from './serialization.js';
+import { generateTableOoxml } from '../services/table-reconciliation.js';
+import { parseTable } from './content-analysis.js';
+import { log } from '../adapters/logger.js';
+import { NS_W, RunKind } from '../core/types.js';
+import { parseOoxmlSafe, serializeXml } from '../adapters/xml-adapter.js';
+import { setParagraphPropertiesMarkRevision } from '../engine/paragraph-mark-revisions.js';
+
+/**
+ * Executes list generation when paragraph content expands into list/table blocks.
+ *
+ * @param {Object} options - Generation options
+ * @param {string} options.cleanText - Preprocessed target text
+ * @param {Object|null} options.numberingContext - Existing numbering context
+ * @param {Array} [options.originalRunModel=[]] - Original run model
+ * @param {string} [options.originalText=''] - Original text fallback
+ * @param {boolean} [options.generateRedlines=true] - Track-change toggle
+ * @param {string} [options.author='AI'] - Author metadata
+ * @param {string|null} [options.font=null] - Optional font
+ * @param {import('../services/numbering-service.js').NumberingService} options.numberingService - Numbering service
+ * @returns {Promise<import('../core/types.js').ReconciliationResult>}
+ */
+export async function executeListGeneration(options) {
+    const {
+        cleanText,
+        numberingContext,
+        originalRunModel = [],
+        originalText = '',
+        generateRedlines = true,
+        author = 'AI',
+        font = null,
+        revisionIdAllocator = null,
+        numberingService
+    } = options;
+
+    const normalizedListText = normalizeCompositeListMarkers(cleanText);
+    const lineMetadata = buildLineMetadata(normalizedListText);
+    const rawLines = lineMetadata.map(line => line.raw);
+    const results = [];
+    const sourcePPr = getSourceParagraphProperties(originalRunModel);
+    const inheritedTypographyRPrXml = extractInheritedTypographyRPrXml(originalRunModel, sourcePPr);
+    const inheritedHeadingRPrXml = extractInheritedTypographyRPrXml(
+        originalRunModel,
+        sourcePPr,
+        ['rFonts', 'kern', 'position', 'rtl', 'cs', 'lang']
+    );
+
+    let deletionRuns = [];
+    if (generateRedlines) {
+        if (originalRunModel && originalRunModel.length > 0) {
+            deletionRuns = originalRunModel
+                .filter(run => run.kind === 'text' || run.kind === 'run'
+                    || run.kind === RunKind.CONTAINER_START || run.kind === RunKind.CONTAINER_END)
+                .map(run => (run.kind === RunKind.CONTAINER_START || run.kind === RunKind.CONTAINER_END
+                    ? run
+                    : { ...run, kind: 'deletion', author }));
+        } else if (originalText && originalText.trim().length > 0) {
+            const trimmed = originalText.trim();
+            deletionRuns = [{
+                kind: 'deletion',
+                text: trimmed,
+                author,
+                startOffset: 0,
+                endOffset: trimmed.length
+            }];
+        }
+    }
+
+    const sourceParagraphCount = (originalRunModel || [])
+        .filter(run => run.kind === RunKind.PARAGRAPH_START).length;
+    if (generateRedlines && sourceParagraphCount > 0 && (sourceParagraphCount > 1 || deletionRuns.length === 0)) {
+        // Each source paragraph keeps its own deleted paragraph (content and tracked-deleted mark), so
+        // Reject All restores every original paragraph boundary instead of merging them into one.
+        // Serialize each source paragraph on its own so empty paragraphs are emitted too (an empty
+        // paragraph carrying only its tracked-deleted mark).
+        let segment = null;
+        const flushSegment = () => {
+            if (!segment) return;
+            results.push(serializeToOoxml(segment, null, [], {
+                author,
+                generateRedlines,
+                revisionIdAllocator
+            }));
+            segment = null;
+        };
+        for (const run of originalRunModel) {
+            if (run.kind === RunKind.PARAGRAPH_START) {
+                flushSegment();
+                segment = [{
+                    ...run,
+                    pPrElement: null,
+                    pPrXml: addParagraphMarkRevision(
+                        run.pPrElement || run.pPrXml || null,
+                        'del',
+                        author,
+                        revisionIdAllocator
+                    )
+                }];
+            } else if (segment && (run.kind === 'text' || run.kind === 'run')) {
+                segment.push({ ...run, kind: 'deletion', author });
+            } else if (segment && (run.kind === RunKind.CONTAINER_START || run.kind === RunKind.CONTAINER_END)) {
+                // Keep the hyperlink / content-control wrapper around the deleted runs so Reject All restores
+                // the text inside it, not as loose runs next to it.
+                segment.push(run);
+            }
+        }
+        flushSegment();
+    } else if (generateRedlines && deletionRuns.length > 0) {
+        const deletedPPr = addParagraphMarkRevision(sourcePPr, 'del', author, revisionIdAllocator);
+        const deletedParagraph = serializeToOoxml(deletionRuns, deletedPPr, [], {
+            author,
+            generateRedlines,
+            revisionIdAllocator
+        });
+        results.push(deletedParagraph);
+    }
+
+    const indentStep = detectIndentationStep(rawLines);
+    log(`[ListGen] Detected indentation step: ${indentStep} spaces/chars`);
+
+    const firstMarker = lineMetadata.find(line => line.marker)?.marker || '';
+    const { format: defaultFormat } = numberingService.detectNumberingFormat(firstMarker);
+    log(`[ListGen] Detected primary marker: "${firstMarker}", format: ${defaultFormat}`);
+
+    for (let i = 0; i < lineMetadata.length; i++) {
+        const tableBlock = collectMarkdownTableBlock(lineMetadata, i);
+        if (tableBlock) {
+            const tableData = parseTable(tableBlock.tableText);
+            if (tableData.headers.length > 0 || tableData.rows.length > 0) {
+                results.push(generateTableOoxml(tableData, {
+                    generateRedlines,
+                    author,
+                    revisionIdAllocator,
+                    trackAsBlock: true
+                }));
+                i = tableBlock.endIndex;
+                continue;
+            }
+        }
+
+        const line = lineMetadata[i];
+        const entry = buildListEntry(
+            line,
+            indentStep,
+            numberingContext,
+            numberingService,
+            generateRedlines,
+            author,
+            font,
+            revisionIdAllocator,
+            inheritedTypographyRPrXml,
+            inheritedHeadingRPrXml
+        );
+        results.push(entry.ooxml);
+    }
+
+    const numberingXml = numberingService.generateNumberingXml();
+    const finalOoxml = results.join('');
+
+    log(`[ListGen] ✅ Generated OOXML for ${results.length} paragraphs, total length: ${finalOoxml.length}`);
+    log(`[ListGen] First 200 chars: ${finalOoxml.substring(0, 200)}...`);
+
+    return {
+        ooxml: finalOoxml,
+        isValid: true,
+        warnings: ['Paragraph expanded to list fragment'],
+        type: 'fragment',
+        includeNumbering: true,
+        numberingXml
+    };
+}
+
+/**
+ * Heuristically detects indentation step (spaces/tabs per level).
+ *
+ * @param {string[]} lines - Raw lines
+ * @returns {number}
+ */
+export function detectIndentationStep(lines) {
+    const indentations = lines
+        .map(line => line.match(/^(\s*)/)[0].length)
+        .filter(length => length > 0)
+        .sort((a, b) => a - b);
+
+    if (indentations.length === 0) return 2;
+
+    let minJump = indentations[0];
+    for (let i = 1; i < indentations.length; i++) {
+        const jump = indentations[i] - indentations[i - 1];
+        if (jump > 0 && jump < minJump) {
+            minJump = jump;
+        }
+    }
+
+    return minJump || 2;
+}
+
+function buildLineMetadata(cleanText) {
+    return cleanText
+        .split('\n')
+        .filter(line => line.trim().length > 0)
+        .map(raw => {
+            const markerMatch = matchListMarker(raw);
+            const headerMatch = raw.match(/^\s*(#{1,9})\s+(.*)/);
+            return {
+                raw,
+                marker: markerMatch ? markerMatch[2].trim() : '',
+                headerMatch,
+                indentSize: (raw.match(/^(\s*)/)?.[1].length) || 0,
+                isTableLine: /^\s*\|/.test(raw),
+                isTableSeparator: /^\s*\|?[\s:-]*-[-\s|:]*\|?\s*$/.test(raw)
+            };
+        });
+}
+
+function normalizeCompositeListMarkers(text) {
+    const lines = String(text || '').split('\n');
+    const nonEmptyIndexes = lines
+        .map((line, index) => ({ line, index }))
+        .filter(entry => entry.line.trim().length > 0);
+    if (nonEmptyIndexes.length < 2) return text;
+
+    const rewrites = [];
+    let rewrittenCount = 0;
+
+    for (const { line, index } of nonEmptyIndexes) {
+        const outerMarkerMatch = matchListMarker(line);
+        if (!outerMarkerMatch) return text;
+
+        const stripped = stripListMarker(line);
+        const innerMarkerMatch = matchListMarker(stripped);
+        if (!innerMarkerMatch) return text;
+
+        const outerMarker = (outerMarkerMatch[2] || '').trim();
+        const innerMarker = (innerMarkerMatch[2] || '').trim();
+        if (!outerMarker || !innerMarker || outerMarker === innerMarker) return text;
+
+        const indent = outerMarkerMatch[1] || '';
+        const rewritten = `${indent}${stripped.trimStart()}`;
+        rewrites.push({ index, rewritten });
+        rewrittenCount++;
+    }
+
+    if (rewrittenCount < 2) return text;
+
+    const updated = lines.slice();
+    for (const rewrite of rewrites) {
+        updated[rewrite.index] = rewrite.rewritten;
+    }
+    log(`[ListGen] Normalized ${rewrittenCount} composite list markers (e.g., "- A." -> "A.").`);
+    return updated.join('\n');
+}
+
+function collectMarkdownTableBlock(lineMetadata, index) {
+    const current = lineMetadata[index];
+    const next = lineMetadata[index + 1];
+
+    if (!current?.isTableLine || !next?.isTableLine || !next?.isTableSeparator) {
+        return null;
+    }
+
+    const tableLines = [];
+    let cursor = index;
+    while (cursor < lineMetadata.length && lineMetadata[cursor].isTableLine) {
+        tableLines.push(lineMetadata[cursor].raw);
+        cursor++;
+    }
+
+    return {
+        tableText: tableLines.join('\n'),
+        endIndex: cursor - 1
+    };
+}
+
+function buildListEntry(
+    line,
+    indentStep,
+    numberingContext,
+    numberingService,
+    generateRedlines,
+    author,
+    font,
+    revisionIdAllocator,
+    inheritedTypographyRPrXml,
+    inheritedHeadingRPrXml
+) {
+    let pPrXml = '';
+    let segmentText = '';
+    let insertedRPrXml = inheritedTypographyRPrXml;
+
+    if (line.headerMatch) {
+        const level = Math.min(line.headerMatch[1].length, 9);
+        const outlineLevel = Math.min(level - 1, 8);
+        const headingSizes = [32, 28, 26, 24, 22, 20, 20, 20, 20];
+        const headingSize = headingSizes[level - 1] || headingSizes[headingSizes.length - 1];
+        segmentText = line.headerMatch[2].trim();
+        pPrXml = `<w:pPr><w:pStyle w:val="Heading${level}"/><w:outlineLvl w:val="${outlineLevel}"/><w:rPr><w:b/><w:sz w:val="${headingSize}"/><w:szCs w:val="${headingSize}"/></w:rPr></w:pPr>`;
+        insertedRPrXml = mergeRunProperties(
+            inheritedHeadingRPrXml,
+            `<w:rPr><w:b/><w:sz w:val="${headingSize}"/><w:szCs w:val="${headingSize}"/></w:rPr>`
+        );
+    } else if (line.marker) {
+        const lineFormat = numberingService.detectNumberingFormat(line.marker);
+        const indentLevel = indentStep > 0 ? Math.floor(line.indentSize / indentStep) : 0;
+        const contextLevel = numberingContext?.ilvl || 0;
+        const ilvl = lineFormat.format === 'outline'
+            ? Math.min(8, lineFormat.depth)
+            : Math.min(8, indentLevel + contextLevel);
+
+        segmentText = stripListMarker(line.raw);
+        const numId = numberingService.getOrCreateNumId({ type: lineFormat.format }, numberingContext);
+        pPrXml = numberingService.buildListPPr(numId, ilvl);
+    } else {
+        segmentText = line.raw;
+    }
+
+    if (generateRedlines) {
+        pPrXml = addParagraphMarkRevision(
+            pPrXml || '<w:pPr/>',
+            'ins',
+            author,
+            revisionIdAllocator
+        );
+    }
+
+    const { cleanText, formatHints } = preprocessMarkdown(segmentText);
+    const runModel = [];
+
+    runModel.push({
+        kind: generateRedlines ? 'insertion' : 'run',
+        text: cleanText,
+        rPrXml: insertedRPrXml,
+        author,
+        startOffset: 0,
+        endOffset: cleanText.length
+    });
+
+    return {
+        ooxml: serializeToOoxml(runModel, pPrXml, formatHints, {
+            author,
+            generateRedlines,
+            font,
+            revisionIdAllocator
+        })
+    };
+}
+
+function getSourceParagraphProperties(originalRunModel) {
+    const paragraphStart = (originalRunModel || []).find(run => run.kind === RunKind.PARAGRAPH_START);
+    return paragraphStart?.pPrElement || paragraphStart?.pPrXml || null;
+}
+
+function extractInheritedTypographyRPrXml(
+    originalRunModel,
+    sourcePPr,
+    tagOrder = ['rFonts', 'kern', 'position', 'sz', 'szCs', 'rtl', 'cs', 'lang']
+) {
+    const sources = (originalRunModel || [])
+        .filter(run => (run.kind === RunKind.TEXT || run.kind === 'text') && run.rPrXml)
+        .map(run => run.rPrXml);
+
+    if (sourcePPr) {
+        sources.push(typeof sourcePPr === 'string' ? sourcePPr : serializeXml(sourcePPr));
+    }
+
+    const inherited = [];
+    for (const tagName of tagOrder) {
+        let match = null;
+        for (const source of sources) {
+            match = String(source || '').match(new RegExp(`<w:${tagName}\\b[^>]*(?:\\/>|>[\\s\\S]*?<\\/w:${tagName}>)`));
+            if (match) break;
+        }
+        if (match) inherited.push(match[0]);
+    }
+
+    return inherited.length > 0 ? `<w:rPr>${inherited.join('')}</w:rPr>` : '';
+}
+
+function mergeRunProperties(...sources) {
+    const properties = sources
+        .map(source => String(source || '').replace(/^\s*<w:rPr[^>]*>|<\/w:rPr>\s*$/g, ''))
+        .filter(Boolean)
+        .join('');
+    return properties ? `<w:rPr>${properties}</w:rPr>` : '';
+}
+
+function addParagraphMarkRevision(xml, type, author, revisionIdAllocator) {
+    let pPr;
+    let ownerDoc;
+
+    if (xml?.nodeType === 1) {
+        pPr = xml.cloneNode(true);
+        ownerDoc = pPr.ownerDocument;
+    } else {
+        const pPrXml = typeof xml === 'string' && xml.trim() ? xml : '<w:pPr/>';
+        const parsed = parseOoxmlSafe(`<w:root xmlns:w="${NS_W}">${pPrXml}</w:root>`);
+        if (!parsed.doc) {
+            throw new Error(parsed.error?.message || 'Could not parse paragraph properties for list revision');
+        }
+        ownerDoc = parsed.doc;
+        pPr = Array.from(ownerDoc.documentElement.childNodes || []).find(node => (
+            node.nodeType === 1 && node.localName === 'pPr'
+        ));
+    }
+
+    if (!pPr || !ownerDoc) throw new Error('List paragraph properties are unavailable');
+    setParagraphPropertiesMarkRevision(pPr, type === 'del' ? 'del' : 'ins', { author, revisionIdAllocator });
+    return serializeXml(pPr);
+}