@ansonlai/docx-redline-js 0.8.4 → 0.10.0

package/engine/table-mode.js

@@ -2,30 +2,30 @@
  * Table-specific reconciliation and transformation flows.
  */
 
-import {
-    NS_W,
-    createRevisionMetadata,
-    getRevisionIdAllocatorForDocument,
-    setRevisionIdAllocatorForDocument
-} from '../core/types.js';
-import {
-    getElementsByTagNS,
-    getElementsByTagNSOrTag,
-    getFirstElementByTagNS,
-    getFirstElementByTagNSOrTag,
-    getXmlParseError
-} from '../core/xml-query.js';
-import { parseOoxmlSafe } from '../adapters/xml-adapter.js';
-import { log, error } from '../adapters/logger.js';
-import { diffTablesWithVirtualGrid, serializeVirtualGridToOoxml, generateTableOoxml } from '../services/table-reconciliation.js';
-import { parseTable } from '../pipeline/pipeline.js';
-import { ingestTableToVirtualGrid } from '../pipeline/ingestion.js';
-import { createWordElement, withOoxmlSourceType } from '../core/word-xml.js';
-import { markParagraphMarkDeleted } from './run-builders.js';
-
-function noChanges(serializer, xmlDoc) {
-    return withOoxmlSourceType({ oxml: serializer.serializeToString(xmlDoc), hasChanges: false });
-}
+import {
+    NS_W,
+    createRevisionMetadata,
+    getRevisionIdAllocatorForDocument,
+    setRevisionIdAllocatorForDocument
+} from '../core/types.js';
+import {
+    getElementsByTagNS,
+    getElementsByTagNSOrTag,
+    getFirstElementByTagNS,
+    getFirstElementByTagNSOrTag,
+    getXmlParseError
+} from '../core/xml-query.js';
+import { parseOoxmlSafe } from '../adapters/xml-adapter.js';
+import { log, error } from '../adapters/logger.js';
+import { diffTablesWithVirtualGrid, serializeVirtualGridToOoxml, generateTableOoxml } from '../services/table-reconciliation.js';
+import { parseTable } from '../pipeline/pipeline.js';
+import { ingestTableToVirtualGrid } from '../pipeline/ingestion.js';
+import { createWordElement, withOoxmlSourceType } from '../core/word-xml.js';
+import { markParagraphDeleted } from './paragraph-mark-revisions.js';
+
+function noChanges(serializer, xmlDoc) {
+    return withOoxmlSourceType({ oxml: serializer.serializeToString(xmlDoc), hasChanges: false });
+}
 
 /**
  * Applies structural reconciliation to tables using Virtual Grid.
@@ -38,8 +38,8 @@ function noChanges(serializer, xmlDoc) {
  * @param {boolean} [generateRedlines=true] - Track change toggle
  * @returns {{ oxml: string, hasChanges: boolean }}
  */
-export function applyTableReconciliation(xmlDoc, modifiedText, serializer, parser, author, generateRedlines = true) {
-    const tableNodes = getElementsByTagNSOrTag(xmlDoc, NS_W, 'tbl');
+export function applyTableReconciliation(xmlDoc, modifiedText, serializer, parser, author, generateRedlines = true) {
+    const tableNodes = getElementsByTagNSOrTag(xmlDoc, NS_W, 'tbl');
     const newTableData = parseTable(modifiedText);
     const hasNewContent = newTableData.rows.length > 0 || newTableData.headers.length > 0;
 
@@ -55,15 +55,15 @@ export function applyTableReconciliation(xmlDoc, modifiedText, serializer, parse
         return noChanges(serializer, xmlDoc);
     }
 
-    const options = {
-        generateRedlines,
-        author,
-        revisionIdAllocator: getRevisionIdAllocatorForDocument(xmlDoc)
-    };
+    const options = {
+        generateRedlines,
+        author,
+        revisionIdAllocator: getRevisionIdAllocatorForDocument(xmlDoc)
+    };
     const reconciledOxml = serializeVirtualGridToOoxml(oldGrid, operations, options);
     const wrappedOxml = `<root xmlns:w="${NS_W}">${reconciledOxml}</root>`;
-    const reconciledDoc = parseOoxmlSafe(wrappedOxml, 'application/xml').doc;
-    if (!reconciledDoc) return noChanges(serializer, xmlDoc);
+    const reconciledDoc = parseOoxmlSafe(wrappedOxml, 'application/xml').doc;
+    if (!reconciledDoc) return noChanges(serializer, xmlDoc);
 
     const parseError = getXmlParseError(reconciledDoc);
     if (parseError) {
@@ -71,7 +71,7 @@ export function applyTableReconciliation(xmlDoc, modifiedText, serializer, parse
         return noChanges(serializer, xmlDoc);
     }
 
-    const newTableNode = getFirstElementByTagNSOrTag(reconciledDoc, NS_W, 'tbl');
+    const newTableNode = getFirstElementByTagNSOrTag(reconciledDoc, NS_W, 'tbl');
     if (!newTableNode) {
         error('[OxmlEngine] No table found in reconciled OOXML');
         return noChanges(serializer, xmlDoc);
@@ -80,7 +80,7 @@ export function applyTableReconciliation(xmlDoc, modifiedText, serializer, parse
     const importedTable = xmlDoc.importNode(newTableNode, true);
     targetTable.parentNode.replaceChild(importedTable, targetTable);
 
-    return withOoxmlSourceType({ oxml: serializer.serializeToString(xmlDoc), hasChanges: true });
+    return withOoxmlSourceType({ oxml: serializer.serializeToString(xmlDoc), hasChanges: true });
 }
 
 /**
@@ -94,17 +94,17 @@ export function applyTableReconciliation(xmlDoc, modifiedText, serializer, parse
  * @param {boolean} generateRedlines - Track change toggle
  * @returns {{ oxml: string, hasChanges: boolean }}
  */
-export function applyTextToTableTransformation(xmlDoc, modifiedText, serializer, parser, author, generateRedlines) {
-    const revisionIdAllocator = getRevisionIdAllocatorForDocument(xmlDoc);
+export function applyTextToTableTransformation(xmlDoc, modifiedText, serializer, parser, author, generateRedlines) {
+    const revisionIdAllocator = getRevisionIdAllocatorForDocument(xmlDoc);
     const tableData = parseTable(modifiedText);
     if (!tableData || (tableData.rows.length === 0 && tableData.headers.length === 0)) {
         log('[OxmlEngine] Failed to parse table data from Markdown');
         return noChanges(serializer, xmlDoc);
     }
 
-    const tableOoxml = generateTableOoxml(tableData, { generateRedlines, author, revisionIdAllocator });
-    const tableDoc = parseOoxmlSafe(`<root xmlns:w="${NS_W}">${tableOoxml}</root>`, 'application/xml').doc;
-    if (!tableDoc) return noChanges(serializer, xmlDoc);
+    const tableOoxml = generateTableOoxml(tableData, { generateRedlines, author, revisionIdAllocator, trackAsBlock: true });
+    const tableDoc = parseOoxmlSafe(`<root xmlns:w="${NS_W}">${tableOoxml}</root>`, 'application/xml').doc;
+    if (!tableDoc) return noChanges(serializer, xmlDoc);
 
     const tableParseError = getXmlParseError(tableDoc);
     if (tableParseError) {
@@ -132,16 +132,16 @@ export function applyTextToTableTransformation(xmlDoc, modifiedText, serializer,
     let parent = firstParagraph.parentNode;
 
     if (parent && parent.nodeType === 9) {
-        const wrappedDoc = parseOoxmlSafe(
-            `<w:document xmlns:w="${NS_W}"><w:body/></w:document>`,
-            'application/xml'
-        ).doc;
-        if (!wrappedDoc) return noChanges(serializer, workingDoc);
+        const wrappedDoc = parseOoxmlSafe(
+            `<w:document xmlns:w="${NS_W}"><w:body/></w:document>`,
+            'application/xml'
+        ).doc;
+        if (!wrappedDoc) return noChanges(serializer, workingDoc);
         const wrappedBody = getFirstElementByTagNS(wrappedDoc, NS_W, 'body');
         paragraphs.forEach(p => wrappedBody.appendChild(wrappedDoc.importNode(p, true)));
 
-        workingDoc = wrappedDoc;
-        setRevisionIdAllocatorForDocument(workingDoc, revisionIdAllocator);
+        workingDoc = wrappedDoc;
+        setRevisionIdAllocatorForDocument(workingDoc, revisionIdAllocator);
         paragraphs = getElementsByTagNS(workingDoc, NS_W, 'p');
         firstParagraph = paragraphs[0];
         parent = firstParagraph.parentNode;
@@ -149,26 +149,26 @@ export function applyTextToTableTransformation(xmlDoc, modifiedText, serializer,
 
     const importedTable = workingDoc.importNode(newTableElement, true);
 
-    if (generateRedlines) {
-        paragraphs.forEach(p => {
-            markParagraphMarkDeleted(workingDoc, p, author);
-            const runs = getElementsByTagNS(p, NS_W, 'r');
-            runs.forEach(run => {
+    if (generateRedlines) {
+        paragraphs.forEach(p => {
+            markParagraphDeleted(p, { author, revisionIdAllocator: workingDoc });
+            const runs = getElementsByTagNS(p, NS_W, 'r');
+            runs.forEach(run => {
                 const textNodes = getElementsByTagNS(run, NS_W, 't');
                 textNodes.forEach(t => {
                     const text = t.textContent || '';
                     if (text.trim()) {
-                        const delText = createWordElement(workingDoc, 'w:delText');
-                        delText.textContent = text;
-                        t.parentNode.replaceChild(delText, t);
+                        const delText = createWordElement(workingDoc, 'w:delText');
+                        delText.textContent = text;
+                        t.parentNode.replaceChild(delText, t);
                     }
                 });
-
-                const del = createWordElement(workingDoc, 'w:del');
-                const metadata = createRevisionMetadata(author, workingDoc, 'del');
-                del.setAttribute('w:id', String(metadata.id));
-                del.setAttribute('w:author', metadata.author);
-                del.setAttribute('w:date', metadata.date);
+
+                const del = createWordElement(workingDoc, 'w:del');
+                const metadata = createRevisionMetadata(author, workingDoc, 'del');
+                del.setAttribute('w:id', String(metadata.id));
+                del.setAttribute('w:author', metadata.author);
+                del.setAttribute('w:date', metadata.date);
                 run.parentNode.insertBefore(del, run);
                 del.appendChild(run);
             });
@@ -183,5 +183,5 @@ export function applyTextToTableTransformation(xmlDoc, modifiedText, serializer,
     }
 
     log('[OxmlEngine] Text-to-table transformation complete');
-    return withOoxmlSourceType({ oxml: serializer.serializeToString(workingDoc), hasChanges: true });
-}
+    return withOoxmlSourceType({ oxml: serializer.serializeToString(workingDoc), hasChanges: true });
+}

package/index.d.ts

@@ -1,6 +1,6 @@
 export type OoxmlSourceType = 'package' | 'document' | 'fragment';
 export type RedlineStatus = 'ok' | 'no-op' | 'partial' | 'error';
-export type ExistingRevisionsPolicy = 'merge-same-author' | 'slice-cross-author' | 'reject-input' | 'accept-all-first' | 'accept-all-first-keep-normalized';
+export type ExistingRevisionsPolicy = 'auto' | 'merge-same-author' | 'slice-cross-author' | 'reject-input' | 'accept-all-first' | 'accept-all-first-keep-normalized';
 export type RevisionView = 'accepted' | 'rejected';
 
 export interface RevisionTextSegment {
@@ -30,6 +30,16 @@ export type {
   DocumentOperationBatchResult,
   HighlightDocumentOperation,
   InsertionAffinity,
+  ListConversionDiagnostic,
+  ListFormatDocumentOperation,
+  ListFormatRequest,
+  ListFormatConvertPlainRequest,
+  ListFormatChangeFormatRequest,
+  ListFormatJoinRequest,
+  ListFormatResult,
+  ListFormatConvertPlainResult,
+  ListFormatRebindResult,
+  ListNumberFormat,
   LocalizedReplacement,
   LocalizedReplacementChange,
   OperationConflict,
@@ -52,6 +62,13 @@ export interface RedlineError {
     | 'DIFF_TOKEN_LIMIT'
     | 'UNSUPPORTED_REVISION_VIEW_MUTATION'
     | 'UNSUPPORTED_INSERTION_AFFINITY'
+    | 'UNSUPPORTED_LIST_CONVERSION'
+    | 'UNSUPPORTED_LIST_FORMAT_CHANGE'
+    | 'LIST_MARKER_NOT_FOUND'
+    | 'LIST_MARKER_AMBIGUOUS'
+    | 'LIST_MARKER_UNSUPPORTED'
+    | 'LIST_FORMAT_TARGET_IS_LIST'
+    | 'LIST_FORMAT_STYLE_NUMBERED'
     | 'UNSAFE_PARAGRAPH_BOUNDARY'
     | 'FOREIGN_PARAGRAPH_MARK_DELETION'
     | 'RESTORATION_STATE_REQUIRED'
@@ -80,6 +97,11 @@ export interface RedlineError {
   recoveryVersion?: number;
   category?: 'request_fixable' | 'target_refresh_required' | 'candidate_selection_required' | 'policy_choice_required' | 'user_authorization_required' | 'source_conflict' | 'library_or_builder_failure' | 'manual_document_resolution' | string;
   context?: Record<string, unknown>;
+  /** List-conversion errors: the literal marker, the requested list kind/format and the kept source definition. */
+  listMarker?: string;
+  requestedList?: { kind: 'bullet' | 'numbered'; format: string };
+  sourceList?: { numId: string; level: number; kind: 'bullet' | 'numbered'; format: string };
+  targetExcerpt?: string;
   recovery?: {
     action: string;
     sameArgumentsSafe: boolean;
@@ -87,6 +109,8 @@ export interface RedlineError {
     requiresUserAuthorization: boolean;
     field?: string;
     recommendedValue?: unknown;
+    allowedValue?: unknown;
+    hint?: string;
   };
   expectedRevision?: RevisionToken;
   currentRevision?: RevisionToken;
@@ -348,6 +372,11 @@ export function inspectDocumentParts(parts: { documentXml: string; commentsXml?:
 export function buildRevisionTokenFraming(options: { scope: string; entries?: unknown }): { framing: Uint8Array; scope: string; version: number; coveredParts: string[] };
 export function computeRevisionToken(options: { scope: string; entries?: unknown; digestFn?: (bytes: Uint8Array) => Promise<string> }): Promise<RevisionToken>;
 export function computeRevisionTokenSync(options: { scope: string; entries?: unknown; digestFn: (bytes: Uint8Array) => string }): RevisionToken;
+/** Compare two inspections by visible text, table position, list label, review segments and comments (ids, dates and run boundaries ignored). */
+export function compareDocumentInspections(expected: { paragraphs: unknown[]; comments?: unknown[] }, actual: { paragraphs: unknown[]; comments?: unknown[] }): { matches: boolean; differences: Array<{ path: string; expected: unknown; actual: unknown }> };
+export function inspectionReviewShape(inspection: { paragraphs: unknown[]; comments?: unknown[] }): { paragraphs: unknown[]; comments: string[] };
+/** Resolve `existingRevisions: 'auto'` for one target node; other policies are returned unchanged. */
+export function resolveExistingRevisionsPolicy(policy: ExistingRevisionsPolicy | null | undefined, node: unknown, author: string): ExistingRevisionsPolicy | null | undefined;
 export function computeDocumentPartsRevisionToken(parts: unknown, options?: { digestFn?: (bytes: Uint8Array) => Promise<string> }): Promise<RevisionToken>;
 export function validateRevisionToken(token: unknown): { valid: boolean; error?: { code: string; message: string } };
 export function areRevisionTokensEqual(a: string, b: string): boolean;
@@ -437,7 +466,29 @@ export function overwriteParagraphNumIds(oxml: string, numId: string | number):
 export function extractFirstParagraphNumId(oxml: string): string | null;
 export function buildExplicitDecimalMultilevelNumberingXml(options?: Record<string, unknown>): string;
 export function remapNumberingPayloadForDocument(numberingXml: string, state: unknown): unknown;
-export function mergeNumberingXmlBySchemaOrder(baseXml: string, incomingXml: string): string;
+export interface NumberingIdConflict { kind: 'abstractNum' | 'num'; id: number }
+export interface NumberingMergeOptions { onConflict?: (conflict: NumberingIdConflict) => void }
+export interface NumberingIntegrityIssue { code: string; severity: 'error'; message: string; numId?: number; abstractNumId?: number; ilvl?: number }
+export function mergeNumberingXmlBySchemaOrder(baseXml: string, incomingXml: string, options?: NumberingMergeOptions): string;
+export function mergeNumberingParts(existingXml: string | null | undefined, incomingParts: string | Array<string | null | undefined> | null | undefined, options?: NumberingMergeOptions): string;
+export function allocateNumberingDefinition(params: {
+    numberingIdState: unknown;
+    sourceNumberingXml?: string | null;
+    sourceNumId?: number | string | null;
+    levels?: Array<{ ilvl: number; numFmt?: string; lvlText?: string; start?: number }>;
+    startOverrides?: Record<number | string, number>;
+}): { numId: number; abstractNumId: number; numberingXml: string } | null;
+export function allocateNumberingForReplacement(params: {
+    numberingXml: string | null;
+    replacementNodes: unknown[];
+    sourceParagraphs?: unknown[];
+    numberingIdState?: unknown;
+    allowContinueSource?: boolean;
+}): { policy: 'continue-source' | 'allocate' | 'passthrough'; numberingXml: string | null; replacementNodes: unknown[]; numId?: number };
+export function applyStartOverridesToNum(numElement: unknown, startOverrides: Record<number | string, number>): void;
+export function copyLevelGeometry(sourceLvl: unknown, targetLvl: unknown): void;
+export function canonicalNumberingDefinition(numbering: unknown, numId: string | number): string | null;
+export function validateNumberingIntegrity(documentXml: unknown, numberingXml?: unknown): NumberingIntegrityIssue[];
 
 export function buildListMarkdown(items: unknown[], options?: Record<string, unknown>): string;
 export function inferNumberingStyleFromMarker(marker: string): string;

package/index.js

@@ -260,9 +260,18 @@ export {
     overwriteParagraphNumIds,
     extractFirstParagraphNumId,
     buildExplicitDecimalMultilevelNumberingXml,
-    remapNumberingPayloadForDocument,
-    mergeNumberingXmlBySchemaOrder
+    remapNumberingPayloadForDocument
 } from './services/numbering-helpers.js';
+export {
+    allocateNumberingDefinition,
+    allocateNumberingForReplacement,
+    applyStartOverridesToNum,
+    canonicalNumberingDefinition,
+    copyLevelGeometry,
+    mergeNumberingParts,
+    mergeNumberingXmlBySchemaOrder,
+    validateNumberingIntegrity
+} from './services/numbering-allocation.js';
 
 // Pipeline components
 export { ReconciliationPipeline } from './pipeline/pipeline.js';
@@ -275,6 +284,8 @@ export {
 } from './pipeline/ingestion-export.js';
 export { extractCanonicalParagraphText, readCanonicalRunText, isNodeVisibleInRevisionView, extractParagraphRevisionSegments } from './core/paragraph-text.js';
 export { inspectDocumentParts } from './services/document-inspection.js';
+export { compareDocumentInspections, inspectionReviewShape } from './services/inspection-comparison.js';
+export { resolveExistingRevisionsPolicy } from './core/word-xml.js';
 export {
     buildRevisionTokenFraming,
     computeRevisionToken,

package/node/cli-help.js

@@ -144,6 +144,7 @@ export const CLI_COMMAND_HELP = Object.freeze({
             option('textToComment', '--text-to-comment <text>', 'Anchor an inline comment to an exact subspan.'),
             option('targetRef', '--target-ref <N>', 'Disambiguate an inline target with a 1-based machine index.'),
             option('existingRevisions', '--existing-revisions <policy>', 'Select revision handling; cross-author slicing must be deliberate.'),
+            option('revisionFidelity', '--revision-fidelity <enforce|warn|off>', 'Reject All verification of each tracked operation (default enforce: refuse with REVISION_FIDELITY_VIOLATION); the agent profile rejects off.'),
             option('atomic', '--atomic[=true|false]', 'Choose all-or-nothing or progressive batch execution.'),
             option('generateRedlines', '--generate-redlines[=true|false]', 'Control tracked-change generation.'),
             option('noRedlines', '--no-redlines', 'Apply clean text without tracked-change markup.'),

package/node/cli.js

@@ -7,11 +7,12 @@ import { validateRedlineOoxml } from '../core/redline-validation.js';
 import { configureLogger } from '../adapters/logger.js';
 import { isExistingRevisionsPolicy } from '../services/document-operation-contract.js';
 import { normalizeErrorWithRecovery } from '../services/error-recovery.js';
+import { REVISION_FIDELITY_MODES, resolveRevisionFidelityMode } from '../services/revision-fidelity-verifier.js';
 import { localizedReplacementOffsets } from '../services/localized-replacement-compiler.js';
 import { buildCliHelp, CLI_COMMANDS, commandOptionKeys } from './cli-help.js';
 
 const suffixes = { apply: 'redlined', accept: 'accepted', reject: 'rejected', 'delete-comments': 'comments-removed' };
-const CLI_CONTRACT_VERSION = 8;
+const CLI_CONTRACT_VERSION = 9;
 const DEFAULT_INSPECTION_LIMIT = 20;
 const INSPECTION_SOFT_BYTE_LIMIT = 48 * 1024;
 const CLI_CAPABILITIES = [
@@ -39,7 +40,13 @@ const CLI_CAPABILITIES = [
     'comment-resolve-operation-v1',
     'delete-comments-by-id-v1',
     'header-footer-parts-v1',
-    'format-text-occurrence-v1'
+    'format-text-occurrence-v1',
+    'revision-fidelity-v1',
+    'list-conversion-diagnostics-v1',
+    'paragraph-numbering-binding-v1',
+    'list-format-v1',
+    'list-format-change-v1',
+    'existing-revisions-auto-v1'
 ];
 const commandOptions = Object.fromEntries(CLI_COMMANDS.map(command => [command, new Set(commandOptionKeys(command))]));
 
@@ -597,7 +604,9 @@ function compactError(error) {
         'code', 'stage', 'mismatchOffset', 'expectedExcerpt', 'actualExcerpt',
         'expectedCodePoint', 'actualCodePoint', 'ownerAuthor', 'commentIds',
         'recoveryVersion', 'category', 'field', 'captureRef', 'operationIndexes',
-        'consumedByOperation', 'expectedScope', 'actualScope'
+        'consumedByOperation', 'expectedScope', 'actualScope',
+        'invariants', 'violations', 'verificationMode', 'baselineView',
+        'listMarker', 'requestedList', 'sourceList', 'targetExcerpt'
     ];
     const compact = {};
     for (const field of fields) {
@@ -823,6 +832,12 @@ export async function executeCli(argv, io = process) {
     if (profile && profile !== 'agent') {
         return cliError('INVALID_PROFILE', `Unknown execution profile: "${profile}". Supported profiles: agent.`);
     }
+    if (flags.revisionFidelity != null && !REVISION_FIDELITY_MODES.includes(String(flags.revisionFidelity))) {
+        return cliError('INVALID_OPERATION', `Unsupported revision-fidelity mode: "${String(flags.revisionFidelity)}". Use enforce, warn or off.`);
+    }
+    if (profile === 'agent' && String(flags.revisionFidelity) === 'off') {
+        return cliError('INVALID_PROFILE', 'The agent profile requires Reject All verification; --revision-fidelity off is only for diagnosis outside the agent profile.');
+    }
     let inspectOptions = null;
     if (command === 'inspect' || command === 'extract') {
         try { inspectOptions = inspectionOptions(flags); }
@@ -925,6 +940,7 @@ export async function executeCli(argv, io = process) {
                 validate: true,
                 generateRedlines,
                 existingRevisions: flags.existingRevisions || 'merge-same-author',
+                verifyRevisionFidelity: resolveRevisionFidelityMode(flags.revisionFidelity == null ? undefined : String(flags.revisionFidelity)),
                 requireComplete
             };
             const result = await document.applyOperations(operations, {
@@ -932,8 +948,10 @@ export async function executeCli(argv, io = process) {
                 atomic,
                 validate: true,
                 strictTargets: true,
+                strictListConversion: agentProfile || atomic,
                 generateRedlines,
                 ...(flags.existingRevisions ? { existingRevisions: flags.existingRevisions } : {}),
+                verifyRevisionFidelity: effectiveOptions.verifyRevisionFidelity,
                 ...(expectedRevision ? { expectedRevision } : {})
             });
             const localizedVerificationFailed = (result.results || []).some(item => item?.change && (

package/orchestration/list-structural-fallback.js

@@ -5,7 +5,9 @@
 
 import { createSerializer, parseOoxmlSafe } from '../adapters/xml-adapter.js';
 import { getXmlParseError } from '../core/xml-query.js';
-import { NS_W } from '../core/types.js';
+import { NS_W, createRevisionMetadata } from '../core/types.js';
+import { clonePropertiesWithoutRevisionHistory } from '../core/revision-cloning.js';
+import { getCurrentNumIdElements } from '../core/current-properties.js';
 import { createWordElement } from '../core/word-xml.js';
 import {
     getDocumentParagraphNodes,
@@ -62,12 +64,47 @@ export function stripSingleLineListMarkerPrefix(text) {
     return String(candidate.contentText || '').trim();
 }
 
-function parseMarkerStart(marker, numberingStyle) {
-    if (numberingStyle !== 'decimal') return null;
-    const match = String(marker || '').trim().match(/^(\d+)\.?$/);
-    if (!match) return null;
-    const value = Number.parseInt(match[1], 10);
-    return Number.isFinite(value) && value > 0 ? value : null;
+const ROMAN_VALUES = { i: 1, v: 5, x: 10, l: 50, c: 100, d: 500, m: 1000 };
+
+function parseRomanNumeral(text) {
+    const letters = String(text || '').toLowerCase();
+    if (!/^[ivxlcdm]+$/.test(letters)) return null;
+    let total = 0;
+    for (let i = 0; i < letters.length; i++) {
+        const value = ROMAN_VALUES[letters[i]];
+        const next = ROMAN_VALUES[letters[i + 1]] || 0;
+        total += value < next ? -value : value;
+    }
+    return total;
+}
+
+/**
+ * Derives the numeric start a literal marker implies: `7.` -> 7, `C.` -> 3, `iv.` -> 4.
+ * Decimal markers keep every positive value (including 1). Letter and roman markers report only
+ * values above 1, because the default start (1) needs no override and keeps the shared-list behavior.
+ *
+ * @param {string} marker
+ * @param {string} numberingStyle
+ * @returns {number|null}
+ */
+export function parseMarkerStart(marker, numberingStyle) {
+    const text = String(marker || '').trim();
+    let value = null;
+    if (numberingStyle === 'decimal') {
+        const match = text.match(/^(\d+)\.?$/);
+        value = match ? Number.parseInt(match[1], 10) : null;
+    } else if (numberingStyle === 'lowerRoman' || numberingStyle === 'upperRoman') {
+        const match = text.match(/^([A-Za-z]+)[.)]?$/);
+        value = match ? parseRomanNumeral(match[1]) : null;
+    } else if (numberingStyle === 'lowerAlpha' || numberingStyle === 'upperAlpha') {
+        const match = text.match(/^([A-Za-z])[.)]?$/);
+        value = match ? match[1].toLowerCase().charCodeAt(0) - 96 : null;
+    } else {
+        return null;
+    }
+    if (!Number.isFinite(value) || value < 1) return null;
+    if (numberingStyle !== 'decimal' && value === 1) return null;
+    return value;
 }
 
 /**
@@ -199,7 +236,8 @@ function getDirectWordChild(element, localName) {
  *   numId: string|number,
  *   ilvl?: number,
  *   clearParagraphPropertyChanges?: boolean,
- *   removeListPropertyNode?: boolean
+ *   removeListPropertyNode?: boolean,
+ *   trackPropertyChange?: { author?: string, revisionIdAllocator?: object|null }|null
  * }} options - Binding options
  * @returns {number} Number of paragraph nodes updated
  */
@@ -209,6 +247,7 @@ export function enforceListBindingOnParagraphNodes(nodes, options = {}) {
     const ilvl = Number.isInteger(options?.ilvl) ? Math.max(0, options.ilvl) : 0;
     const clearParagraphPropertyChanges = options?.clearParagraphPropertyChanges !== false;
     const removeListPropertyNode = options?.removeListPropertyNode !== false;
+    const trackPropertyChange = options?.trackPropertyChange || null;
 
     const paragraphs = (Array.isArray(nodes) ? nodes : [])
         .filter(node => node && node.nodeType === 1 && node.localName === 'p');
@@ -224,6 +263,9 @@ export function enforceListBindingOnParagraphNodes(nodes, options = {}) {
             paragraph.insertBefore(pPr, paragraph.firstChild);
         }
 
+        // Snapshot the pre-binding pPr so Reject All restores the unnumbered paragraph.
+        const priorPPr = trackPropertyChange ? clonePropertiesWithoutRevisionHistory(pPr) : null;
+
         if (clearParagraphPropertyChanges) {
             const pPrChange = getDirectWordChild(pPr, 'pPrChange');
             if (pPrChange) pPr.removeChild(pPrChange);
@@ -253,6 +295,20 @@ export function enforceListBindingOnParagraphNodes(nodes, options = {}) {
             numPr.appendChild(numIdEl);
         }
         numIdEl.setAttribute('w:val', String(numId));
+
+        if (trackPropertyChange && !getDirectWordChild(pPr, 'pPrChange')) {
+            const metadata = createRevisionMetadata(
+                trackPropertyChange.author,
+                trackPropertyChange.revisionIdAllocator || ownerDoc,
+                'pPrChange'
+            );
+            const pPrChange = createWordElement(ownerDoc, 'w:pPrChange');
+            pPrChange.setAttribute('w:id', String(metadata.id));
+            pPrChange.setAttribute('w:author', metadata.author);
+            pPrChange.setAttribute('w:date', metadata.date);
+            pPrChange.appendChild(priorPPr || createWordElement(ownerDoc, 'w:pPr'));
+            pPr.appendChild(pPrChange);
+        }
         updated++;
     }
 
@@ -311,7 +367,8 @@ function extractFirstParagraphNumIdFromOxml(oxml) {
     // Tracked-change output leads with a deleted-original paragraph that carries
     // no numPr, so the generated list binding is the first paragraph that has one.
     for (const paragraph of paragraphs) {
-        const numIdNodes = Array.from(paragraph.getElementsByTagNameNS('*', 'numId'));
+        // Current numIds only; a pPrChange snapshot must not supply the generated list binding.
+        const numIdNodes = getCurrentNumIdElements(paragraph);
         for (const numIdNode of numIdNodes) {
             const numId = getElementId(numIdNode, ['w:val', 'val']);
             if (numId != null) return String(numId);
@@ -433,6 +490,7 @@ export function buildSingleLineListStructuralFallbackPlan(options = {}) {
         numberingKey: `${modifiedCandidate.type}:${modifiedCandidate.numberingStyle}:single`,
         originalText,
         wasListParagraph: !!existingListInfo,
+        numberingStyle: modifiedCandidate.numberingStyle,
         startAt: modifiedCandidate.startAt
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ansonlai/docx-redline-js",
-  "version": "0.8.4",
+  "version": "0.10.0",
   "description": "Host-independent OOXML reconciliation engine for .docx manipulation with track changes",
   "license": "MIT",
   "type": "module",