@a3s-lab/office 0.49.0 → 0.51.0

package/README.md

@@ -309,6 +309,40 @@ and [CLI reference](./docs/latest/en/cli-reference.md).
 
 ## Current release
 
+Version `0.51.0` extends Writer Compare with bounded, WPS-referenced
+cross-paragraph text moves:
+
+- A unique lexical range can move between aligned simple text paragraphs or
+  headings in the same section and become one paired `move` review item.
+  Separators travel with the range; accepting, rejecting, undoing, or reopening
+  the DOCX preserves exact source and revised text.
+- The Review ribbon and Changes pane keep one localized **移动** card with
+  source/destination marks, destination navigation, author guidance, and
+  move-aware toast counts. Duplicate or mark-mismatched candidates, section
+  boundaries, rich or relationship-bound content, tables, and over-limit input
+  remain fail-closed ordinary revisions or diagnostics.
+- The WPS 12.0 COM/UIA probe observed `CompareDocuments` returning ordinary
+  delete/insert records for the tested reorder. A3S therefore documents this
+  paired inference as a bounded local enhancement, with no claim that WPS
+  exposed a native move type through that API.
+
+Version `0.50.0` extends Writer Compare with a bounded, WPS-referenced text
+move workflow:
+
+- Deterministic lexical ranges that move within one simple paragraph or heading
+  become one paired `move` review item. Separators travel with the range, and
+  accepting, rejecting, undoing, or reopening the DOCX preserves exact source
+  and revised text.
+- The Review ribbon and Changes pane expose one localized **移动** card with
+  source/destination marks, destination navigation, updated author guidance,
+  and move-aware toast counts. Ambiguous duplicates, rich or relationship-bound
+  content, cross-paragraph moves, and over-limit inputs remain fail-closed
+  boundaries.
+- The WPS 12.0 COM/UIA probe observed `CompareDocuments` returning ordinary
+  delete/insert records for the tested reorder. A3S therefore documents its
+  paired inference as a bounded local enhancement, with no claim that WPS
+  exposed a native move type through that API.
+
 Version `0.49.0` adds bounded native Writer move revisions and hardens the
 local PDF workflow:
 

package/dist/0~document-editor.js

@@ -17434,6 +17434,245 @@ function sortJsonValue(value) {
             sortJsonValue(child)
         ]));
 }
+function createComparisonIdentityFactory(currentSignature, revisedSignature, options) {
+    const seed = stableHash(`${options.mode}\u0000${currentSignature}\u0000${revisedSignature}`);
+    const author = boundedMetadata(options.author, 256) || 'A3S Work user';
+    const date = normalizedDate(options.date);
+    const summary = emptyComparisonSummary();
+    let sequence = 0;
+    return {
+        summary,
+        create (kind) {
+            sequence += 1;
+            if ('insertion' === kind) summary.insertions += 1;
+            else if ('deletion' === kind) summary.deletions += 1;
+            else if ('formatting' === kind) summary.formatting += 1;
+            else if ('move' === kind) summary.moves = (summary.moves ?? 0) + 1;
+            else summary.paragraphFormatting += 1;
+            return {
+                id: `compare-${seed}-${kind}-${sequence.toString(36)}`,
+                author,
+                date
+            };
+        },
+        paragraphIdentity (channel) {
+            return {
+                paragraphId: wordParagraphId(`${seed}:${channel}:paragraph`),
+                textId: wordParagraphId(`${seed}:${channel}:text`)
+            };
+        }
+    };
+}
+function summarizeComparisonChanges(changes) {
+    const summary = emptyComparisonSummary();
+    for (const change of changes)if ('insertion' === change.kind) summary.insertions += 1;
+    else if ('deletion' === change.kind) summary.deletions += 1;
+    else if ('formatting' === change.kind) summary.formatting += 1;
+    else if ('move' === change.kind) summary.moves = (summary.moves ?? 0) + 1;
+    else summary.paragraphFormatting += 1;
+    return summary;
+}
+function emptyComparisonSummary() {
+    return {
+        deletions: 0,
+        formatting: 0,
+        insertions: 0,
+        paragraphFormatting: 0
+    };
+}
+const MAX_INFERRED_MOVE_TEXT = 65536;
+const MAX_INFERRED_MOVES = 256;
+function work_document_compare_moves_appendRevisionUnits(target, units, kind, identity, schema, stripReviewMarks) {
+    for (const unit of units)target.push(schema.text(unit.text, [
+        ...stripReviewMarks(unit.marks),
+        schema.marks.documentChange.create({
+            kind,
+            id: identity.id,
+            actorId: identity.actorId ?? '',
+            author: identity.author,
+            date: identity.date,
+            before: ''
+        })
+    ]));
+}
+function inferInlineMovePairs(changes, marksEqual) {
+    return inferInlineMovePairsAcrossScopes([
+        {
+            scope: '',
+            changes
+        }
+    ], marksEqual);
+}
+function inferInlineMovePairsAcrossScopes(comparisons, marksEqual) {
+    const fullCandidates = [];
+    for (const comparison of comparisons)for (const [stepIndex, change] of comparison.changes.entries()){
+        if ('equal' === change.kind) continue;
+        const units = 'delete' === change.kind ? change.left : change.right;
+        const candidate = inlineMoveCandidate(stepIndex, change.kind, units, comparison.scope);
+        if (candidate) fullCandidates.push(candidate);
+    }
+    const fullPairs = pairInlineMoveCandidates(fullCandidates, marksEqual);
+    const consumedSteps = new Set();
+    for (const pair of fullPairs){
+        consumedSteps.add(moveStepKey(pair.deletion));
+        consumedSteps.add(moveStepKey(pair.insertion));
+    }
+    const tokenCandidates = [];
+    for (const comparison of comparisons)for (const [stepIndex, change] of comparison.changes.entries()){
+        if ('equal' === change.kind || consumedSteps.has(moveStepKey({
+            scope: comparison.scope,
+            stepIndex
+        }))) continue;
+        const units = 'delete' === change.kind ? change.left : change.right;
+        tokenCandidates.push(...inlineMoveTokenCandidates(stepIndex, change.kind, units, comparison.scope));
+    }
+    return [
+        ...fullPairs,
+        ...pairInlineMoveCandidates(tokenCandidates, marksEqual)
+    ].sort(compareMovePairs).slice(0, MAX_INFERRED_MOVES);
+}
+function appendComparisonRevisionUnits(target, units, kind, schema, factory, stripReviewMarks, appendRevisionUnits, moves) {
+    if (!moves?.length) return void appendRevisionUnits(target, units, kind, factory.create(kind), schema, stripReviewMarks);
+    const byUnit = new Map();
+    for (const move of [
+        ...moves
+    ].sort((left, right)=>left.candidate.start - right.candidate.start))for(let index = move.candidate.start; index < move.candidate.end; index += 1){
+        if (byUnit.has(index)) return void appendRevisionUnits(target, units, kind, factory.create(kind), schema, stripReviewMarks);
+        byUnit.set(index, move);
+    }
+    let ordinary = [];
+    const flushOrdinary = ()=>{
+        if (!ordinary.length) return;
+        appendRevisionUnits(target, ordinary, kind, factory.create(kind), schema, stripReviewMarks);
+        ordinary = [];
+    };
+    for (const [index, unit] of units.entries()){
+        const move = byUnit.get(index);
+        if (!move) {
+            ordinary.push(unit);
+            continue;
+        }
+        const start = index === move.candidate.start ? move.candidate.startOffset : 0;
+        const end = index === move.candidate.end - 1 ? move.candidate.endOffset : unit.text.length;
+        const prefix = unit.text.slice(0, start);
+        const marked = unit.text.slice(start, end);
+        const suffix = unit.text.slice(end);
+        if (prefix) ordinary.push({
+            text: prefix,
+            marks: unit.marks
+        });
+        flushOrdinary();
+        if (marked) appendMoveRevisionUnits(target, [
+            {
+                text: marked,
+                marks: unit.marks
+            }
+        ], move.role, move.identity, schema, stripReviewMarks);
+        ordinary = suffix ? [
+            {
+                text: suffix,
+                marks: unit.marks
+            }
+        ] : [];
+    }
+    flushOrdinary();
+}
+function pairInlineMoveCandidates(candidates, marksEqual) {
+    const grouped = new Map();
+    for (const candidate of candidates){
+        const group = grouped.get(candidate.text) ?? {
+            deletion: [],
+            insertion: []
+        };
+        ('delete' === candidate.kind ? group.deletion : group.insertion).push(candidate);
+        grouped.set(candidate.text, group);
+    }
+    return Array.from(grouped.values()).filter(({ deletion, insertion })=>1 === deletion.length && 1 === insertion.length && inlineMoveCandidatesEqual(deletion[0], insertion[0], marksEqual)).map(({ deletion, insertion })=>({
+            deletion: deletion[0],
+            insertion: insertion[0]
+        })).sort(compareMovePairs).slice(0, MAX_INFERRED_MOVES);
+}
+function inlineMoveCandidate(stepIndex, kind, units, scope = '') {
+    let start = 0;
+    while(start < units.length && isWhitespaceUnit(units[start]))start += 1;
+    let end = units.length;
+    while(end > start && isWhitespaceUnit(units[end - 1]))end -= 1;
+    if (start === end) return null;
+    const first = units[start];
+    const last = units[end - 1];
+    const startOffset = first.leadingWhitespaceAttached ? 0 : first.text.length - first.text.trimStart().length;
+    const endOffset = last.leadingWhitespaceAttached ? last.text.length : last.text.trimEnd().length;
+    const text = units.slice(start, end).map((unit, index, selected)=>unit.text.slice(0 === index ? startOffset : 0, index === selected.length - 1 ? endOffset : unit.text.length)).join('');
+    if (!text || text.length > MAX_INFERRED_MOVE_TEXT || !/[\p{L}\p{N}]/u.test(text)) return null;
+    return {
+        ...scope ? {
+            scope
+        } : {},
+        stepIndex,
+        kind,
+        units,
+        start,
+        end,
+        startOffset,
+        endOffset,
+        text
+    };
+}
+function inlineMoveTokenCandidates(stepIndex, kind, units, scope = '') {
+    const candidates = [];
+    for (const [index, unit] of units.entries()){
+        const leadingWhitespace = unit.text.length - unit.text.trimStart().length;
+        const text = unit.text.slice(leadingWhitespace);
+        if (text && !(text.length > MAX_INFERRED_MOVE_TEXT) && /[\p{L}\p{N}]/u.test(text)) candidates.push({
+            ...scope ? {
+                scope
+            } : {},
+            stepIndex,
+            kind,
+            units,
+            start: index,
+            end: index + 1,
+            startOffset: leadingWhitespace,
+            endOffset: unit.text.length,
+            text
+        });
+    }
+    return candidates;
+}
+function moveStepKey(candidate) {
+    return `${candidate.scope ?? ''}\u0000${candidate.stepIndex}`;
+}
+function compareMovePairs(left, right) {
+    return (left.deletion.scope ?? '').localeCompare(right.deletion.scope ?? '') || left.deletion.stepIndex - right.deletion.stepIndex || (left.insertion.scope ?? '').localeCompare(right.insertion.scope ?? '') || left.insertion.stepIndex - right.insertion.stepIndex || left.deletion.start - right.deletion.start;
+}
+function inlineMoveCandidatesEqual(left, right, marksEqual) {
+    const leftUnits = selectedMoveUnits(left);
+    const rightUnits = selectedMoveUnits(right);
+    return leftUnits.length === rightUnits.length && leftUnits.every((unit, index)=>unit.text === rightUnits[index]?.text && marksEqual(unit.marks, rightUnits[index]?.marks ?? []));
+}
+function selectedMoveUnits(candidate) {
+    return candidate.units.slice(candidate.start, candidate.end).map((unit, index, selected)=>({
+            text: unit.text.slice(0 === index ? candidate.startOffset : 0, index === selected.length - 1 ? candidate.endOffset : unit.text.length),
+            marks: unit.marks
+        })).filter((unit)=>unit.text.length > 0);
+}
+function isWhitespaceUnit(unit) {
+    return '' === unit.text.trim();
+}
+function appendMoveRevisionUnits(target, units, role, identity, schema, stripReviewMarks) {
+    for (const unit of units)target.push(schema.text(unit.text, [
+        ...stripReviewMarks(unit.marks),
+        schema.marks.documentChange.create({
+            kind: 'move',
+            moveRole: role,
+            id: identity.id,
+            actorId: identity.actorId ?? '',
+            author: identity.author,
+            date: identity.date,
+            before: ''
+        })
+    ]));
+}
 const MAX_COMPARISON_BLOCKS = 1024;
 const MAX_COMPARISON_TEXT = 1000000;
 const MAX_BLOCK_ALIGNMENT_CELLS = 1100000;
@@ -17497,7 +17736,7 @@ function planDocumentCompare(current, revised, options) {
     const limits = comparisonLimits(currentSections, revisedSections);
     if (limits) return unsupportedResult(limits);
     const diagnostics = [];
-    const factory = comparisonIdentityFactory(current, revised, options);
+    const factory = createComparisonIdentityFactory(comparisonSemanticSignature(current), comparisonSemanticSignature(revised), options);
     const comparedSections = [];
     for(let sectionIndex = 0; sectionIndex < currentSections.length; sectionIndex += 1){
         const currentSection = currentSections[sectionIndex];
@@ -17566,7 +17805,7 @@ function planDocumentCombine(current, reviewed) {
     return {
         status: 'applied',
         document: document1,
-        summary: summarizeChanges(reviewedChanges),
+        summary: summarizeComparisonChanges(reviewedChanges),
         diagnostics: []
     };
 }
@@ -17582,40 +17821,129 @@ function compareSectionBlocks(currentSection, revisedSection, sectionIndex, fact
         });
         return null;
     }
-    const result = [];
+    const slots = [];
     for (const [blockIndex, step] of alignment.entries()){
         if ('equal' === step.kind) {
-            result.push(step.left);
+            slots.push({
+                kind: 'node',
+                node: step.left
+            });
             continue;
         }
         if ('delete' === step.kind) {
             const deleted = structuralChangeBlock(step.left, 'deletion', factory, `section-${sectionIndex}-delete-${blockIndex}`);
-            if (deleted) result.push(deleted);
+            if (deleted) slots.push({
+                kind: 'node',
+                node: deleted
+            });
             else diagnostics.push(structuralBlockDiagnostic(step.left, sectionIndex, blockIndex));
             continue;
         }
         if ('insert' === step.kind) {
             const inserted = structuralChangeBlock(step.right, 'insertion', factory, `section-${sectionIndex}-insert-${blockIndex}`);
-            if (inserted) result.push(inserted);
+            if (inserted) slots.push({
+                kind: 'node',
+                node: inserted
+            });
             else diagnostics.push(structuralBlockDiagnostic(step.right, sectionIndex, blockIndex));
             continue;
         }
-        const compared = comparePairedBlocks(step.left, step.right, factory);
-        if (compared) {
-            result.push(compared);
+        const prepared = preparePairedBlock(step.left, step.right, `section-${sectionIndex}-block-${blockIndex}`);
+        if (prepared) {
+            slots.push({
+                kind: 'paired',
+                comparison: prepared
+            });
             continue;
         }
         const deleted = structuralChangeBlock(step.left, 'deletion', factory, `section-${sectionIndex}-replace-delete-${blockIndex}`);
         const inserted = structuralChangeBlock(step.right, 'insertion', factory, `section-${sectionIndex}-replace-insert-${blockIndex}`);
-        if (deleted && inserted) result.push(deleted, inserted);
-        else diagnostics.push(structuralBlockDiagnostic(step.left, sectionIndex, blockIndex));
+        if (deleted) slots.push({
+            kind: 'node',
+            node: deleted
+        });
+        if (inserted) slots.push({
+            kind: 'node',
+            node: inserted
+        });
+        if (!deleted || !inserted) diagnostics.push(structuralBlockDiagnostic(step.left, sectionIndex, blockIndex));
     }
-    return result;
+    const pairedSlots = slots.filter((slot)=>'paired' === slot.kind);
+    const initialComparisons = pairedSlots.map(({ comparison })=>({
+            scope: comparison.scope,
+            changes: comparison.inline.variant.changes
+        }));
+    const initialMovePairs = inferInlineMovePairsAcrossScopes(initialComparisons, work_document_compare_marksEqual);
+    const attachedComparisons = pairedSlots.map(({ comparison })=>({
+            scope: comparison.scope,
+            changes: comparison.inline.attached?.changes ?? comparison.inline.variant.changes
+        }));
+    const attachedMovePairs = inferInlineMovePairsAcrossScopes(attachedComparisons, work_document_compare_marksEqual);
+    const pairedByScope = new Map(pairedSlots.map((slot)=>[
+            slot.comparison.scope,
+            slot.comparison
+        ]));
+    const attachedScopes = new Set();
+    for (const pair of [
+        ...initialMovePairs,
+        ...attachedMovePairs
+    ]){
+        const deletionScope = pair.deletion.scope ?? '';
+        const insertionScope = pair.insertion.scope ?? '';
+        if (deletionScope === insertionScope) continue;
+        const deletionBlock = pairedByScope.get(deletionScope);
+        const insertionBlock = pairedByScope.get(insertionScope);
+        if (deletionBlock?.inline.attached && insertionBlock?.inline.attached) {
+            attachedScopes.add(deletionScope);
+            attachedScopes.add(insertionScope);
+        }
+    }
+    const selectedComparisons = pairedSlots.map(({ comparison })=>({
+            scope: comparison.scope,
+            changes: (attachedScopes.has(comparison.scope) ? comparison.inline.attached : comparison.inline.variant)?.changes ?? comparison.inline.variant.changes
+        }));
+    const movePairs = inferInlineMovePairsAcrossScopes(selectedComparisons, work_document_compare_marksEqual);
+    const useAttachedVariants = attachedScopes.size > 0 && movePairs.length >= initialMovePairs.length;
+    const movesByScope = new Map();
+    for (const pair of useAttachedVariants ? movePairs : initialMovePairs){
+        const identity = factory.create('move');
+        appendMoveAssignment(movesByScope, pair.deletion, 'from', identity);
+        appendMoveAssignment(movesByScope, pair.insertion, 'to', identity);
+    }
+    return slots.flatMap((slot)=>{
+        if ('node' === slot.kind) return [
+            slot.node
+        ];
+        const compared = renderPairedBlock(slot.comparison, factory, movesByScope.get(slot.comparison.scope), useAttachedVariants && attachedScopes.has(slot.comparison.scope) ? slot.comparison.inline.attached ?? slot.comparison.inline.variant : slot.comparison.inline.variant);
+        return compared ? [
+            compared
+        ] : [];
+    });
+}
+function appendMoveAssignment(target, candidate, role, identity) {
+    const scope = candidate.scope ?? '';
+    const assignments = target.get(scope) ?? [];
+    assignments.push({
+        role,
+        candidate,
+        identity
+    });
+    target.set(scope, assignments);
 }
-function comparePairedBlocks(current, revised, factory) {
+function preparePairedBlock(current, revised, scope) {
     if (!isSimpleTextBlock(current) || !isSimpleTextBlock(revised)) return null;
     if (current.type !== revised.type || blockStructuralSignature(current) !== blockStructuralSignature(revised)) return null;
-    const inline = compareInlineContent(current, revised, factory);
+    const comparison = prepareInlineComparison(current, revised);
+    return comparison ? {
+        current,
+        revised,
+        scope,
+        inline: comparison
+    } : null;
+}
+function renderPairedBlock(comparison, factory, moves, variant) {
+    const { current, revised } = comparison;
+    const inline = renderInlineComparison(current, variant, factory, moves);
     if (!inline) return null;
     const before = serializeDocumentParagraphFormatting(current.attrs);
     const after = serializeDocumentParagraphFormatting(revised.attrs);
@@ -17637,31 +17965,65 @@ function comparePairedBlocks(current, revised, factory) {
     }
     return current.type.create(attributes, inline);
 }
-function compareInlineContent(current, revised, factory) {
-    const currentUnits = inlineUnits(current);
-    const revisedUnits = inlineUnits(revised);
-    if (!currentUnits || !revisedUnits) return null;
-    const diff = boundedDocumentSequenceDiff(currentUnits, revisedUnits, (left, right)=>left.text === right.text, MAX_INLINE_DIFF_CELLS);
-    const changes = diff ?? [
-        {
-            kind: 'delete',
-            left: currentUnits,
-            right: []
-        },
-        {
-            kind: 'insert',
-            left: [],
-            right: revisedUnits
+function prepareInlineComparison(current, revised) {
+    const baseCurrentUnits = inlineUnits(current);
+    const baseRevisedUnits = inlineUnits(revised);
+    if (!baseCurrentUnits || !baseRevisedUnits) return null;
+    const diff = boundedDocumentSequenceDiff(baseCurrentUnits, baseRevisedUnits, (left, right)=>left.text === right.text, MAX_INLINE_DIFF_CELLS);
+    const baseVariant = {
+        currentUnits: baseCurrentUnits,
+        revisedUnits: baseRevisedUnits,
+        changes: diff ?? [
+            {
+                kind: 'delete',
+                left: baseCurrentUnits,
+                right: []
+            },
+            {
+                kind: 'insert',
+                left: [],
+                right: baseRevisedUnits
+            }
+        ]
+    };
+    const variant = baseVariant;
+    const baseMovePairs = inferInlineMovePairs(variant.changes, work_document_compare_marksEqual);
+    const moveCurrentUnits = inlineUnits(current, true);
+    const moveRevisedUnits = inlineUnits(revised, true);
+    if (moveCurrentUnits && moveRevisedUnits && current.textContent.length + revised.textContent.length <= 131072) {
+        const moveDiff = boundedDocumentSequenceDiff(moveCurrentUnits, moveRevisedUnits, (left, right)=>left.text === right.text, MAX_INLINE_DIFF_CELLS);
+        if (moveDiff) {
+            const moveChanges = moveDiff;
+            const moveVariant = {
+                currentUnits: moveCurrentUnits,
+                revisedUnits: moveRevisedUnits,
+                changes: moveChanges
+            };
+            const movePairs = inferInlineMovePairs(moveChanges, work_document_compare_marksEqual);
+            if (movePairs.length >= baseMovePairs.length && movePairs.length > 0) return {
+                variant: moveVariant,
+                attached: moveVariant
+            };
+            return {
+                variant,
+                attached: moveVariant
+            };
         }
-    ];
+    }
+    return {
+        variant
+    };
+}
+function renderInlineComparison(current, variant, factory, moves) {
+    const { changes } = variant;
     const nodes = [];
-    for (const change of changes){
+    for (const [stepIndex, change] of changes.entries()){
         if ('delete' === change.kind) {
-            appendRevisionUnits(nodes, change.left, 'deletion', factory.create('deletion'), current.type.schema);
+            appendComparisonRevisionUnits(nodes, change.left, 'deletion', current.type.schema, factory, withoutReviewMarks, work_document_compare_moves_appendRevisionUnits, moves?.filter((move)=>move.candidate.stepIndex === stepIndex));
             continue;
         }
         if ('insert' === change.kind) {
-            appendRevisionUnits(nodes, change.right, 'insertion', factory.create('insertion'), current.type.schema);
+            appendComparisonRevisionUnits(nodes, change.right, 'insertion', current.type.schema, factory, withoutReviewMarks, work_document_compare_moves_appendRevisionUnits, moves?.filter((move)=>move.candidate.stepIndex === stepIndex));
             continue;
         }
         let formattingIdentity = null;
@@ -17669,7 +18031,7 @@ function compareInlineContent(current, revised, factory) {
         for(let index = 0; index < change.left.length; index += 1){
             const left = change.left[index];
             const right = change.right[index];
-            if (marksEqual(left.marks, right.marks)) {
+            if (work_document_compare_marksEqual(left.marks, right.marks)) {
                 nodes.push(current.type.schema.text(left.text, [
                     ...left.marks
                 ]));
@@ -17693,12 +18055,12 @@ function compareInlineContent(current, revised, factory) {
             }
             const deletion = factory.create('deletion');
             const insertion = factory.create('insertion');
-            appendRevisionUnits(nodes, [
+            work_document_compare_moves_appendRevisionUnits(nodes, [
                 left
-            ], 'deletion', deletion, current.type.schema);
-            appendRevisionUnits(nodes, [
+            ], 'deletion', deletion, current.type.schema, withoutReviewMarks);
+            work_document_compare_moves_appendRevisionUnits(nodes, [
                 right
-            ], 'insertion', insertion, current.type.schema);
+            ], 'insertion', insertion, current.type.schema, withoutReviewMarks);
             formattingIdentity = null;
             formattingSignature = '';
         }
@@ -17713,9 +18075,9 @@ function structuralChangeBlock(block, kind, factory, identityChannel) {
         textId: block.attrs.textId
     };
     const nodes = [];
-    for (const unit of inlineUnits(block) ?? [])appendRevisionUnits(nodes, [
+    for (const unit of inlineUnits(block) ?? [])work_document_compare_moves_appendRevisionUnits(nodes, [
         unit
-    ], kind, identity, block.type.schema);
+    ], kind, identity, block.type.schema, withoutReviewMarks);
     return block.type.create({
         ...block.attrs,
         ...paragraphIdentity,
@@ -17726,19 +18088,6 @@ function structuralChangeBlock(block, kind, factory, identityChannel) {
         blockChangeDate: identity.date
     }, model_Fragment.fromArray(nodes));
 }
-function appendRevisionUnits(target, units, kind, identity, schema) {
-    for (const unit of units)target.push(schema.text(unit.text, [
-        ...withoutReviewMarks(unit.marks),
-        schema.marks.documentChange.create({
-            kind,
-            id: identity.id,
-            actorId: identity.actorId ?? '',
-            author: identity.author,
-            date: identity.date,
-            before: ''
-        })
-    ]));
-}
 function comparisonMark(node, kind, identity, before) {
     return node.type.schema.marks.documentChange.create({
         kind,
@@ -17822,19 +18171,35 @@ function hasStructuralBlockRevisions(document1) {
     });
     return found;
 }
-function inlineUnits(node) {
+function inlineUnits(node, attachLeadingWhitespace = false) {
     if (!isSimpleTextBlock(node)) return null;
     const units = [];
     node.forEach((child)=>{
         const text = child.text ?? '';
-        for (const part of text.match(/\s+|[\p{L}\p{N}_]+|[^\s\p{L}\p{N}_]/gu) ?? [])units.push({
-            text: part,
-            marks: child.marks
+        let pendingWhitespace = '';
+        for (const part of text.match(/\s+|[\p{L}\p{N}_]+|[^\s\p{L}\p{N}_]/gu) ?? []){
+            if (attachLeadingWhitespace && '' === part.trim()) {
+                pendingWhitespace += part;
+                continue;
+            }
+            units.push({
+                text: attachLeadingWhitespace ? `${pendingWhitespace}${part}` : part,
+                marks: child.marks,
+                ...attachLeadingWhitespace ? {
+                    leadingWhitespaceAttached: true
+                } : {}
+            });
+            pendingWhitespace = '';
+        }
+        if (attachLeadingWhitespace && pendingWhitespace) units.push({
+            text: pendingWhitespace,
+            marks: child.marks,
+            leadingWhitespaceAttached: true
         });
     });
     return units;
 }
-function marksEqual(left, right) {
+function work_document_compare_marksEqual(left, right) {
     const normalizedLeft = withoutReviewMarks(left);
     const normalizedRight = withoutReviewMarks(right);
     return normalizedLeft.length === normalizedRight.length && normalizedLeft.every((mark, index)=>mark.eq(normalizedRight[index]));
@@ -17920,42 +18285,6 @@ function transferCombineIdentities(current, reviewed) {
     if ('documentSection' === reviewed.type.name) attributes.id = current.attrs.id;
     return reviewed.isText ? reviewed : reviewed.type.create(attributes, model_Fragment.fromArray(content), reviewed.marks);
 }
-function comparisonIdentityFactory(current, revised, options) {
-    const seed = stableHash(`${options.mode}\u0000${comparisonSemanticSignature(current)}\u0000${comparisonSemanticSignature(revised)}`);
-    const author = boundedMetadata(options.author, 256) || 'A3S Work user';
-    const date = normalizedDate(options.date);
-    const summary = emptyComparisonSummary();
-    let sequence = 0;
-    return {
-        summary,
-        create (kind) {
-            sequence += 1;
-            if ('insertion' === kind) summary.insertions += 1;
-            else if ('deletion' === kind) summary.deletions += 1;
-            else if ('formatting' === kind) summary.formatting += 1;
-            else summary.paragraphFormatting += 1;
-            return {
-                id: `compare-${seed}-${kind}-${sequence.toString(36)}`,
-                author,
-                date
-            };
-        },
-        paragraphIdentity (channel) {
-            return {
-                paragraphId: wordParagraphId(`${seed}:${channel}:paragraph`),
-                textId: wordParagraphId(`${seed}:${channel}:text`)
-            };
-        }
-    };
-}
-function summarizeChanges(changes) {
-    const summary = emptyComparisonSummary();
-    for (const change of changes)if ('insertion' === change.kind) summary.insertions += 1;
-    else if ('deletion' === change.kind) summary.deletions += 1;
-    else if ('formatting' === change.kind) summary.formatting += 1;
-    else summary.paragraphFormatting += 1;
-    return summary;
-}
 function structuralBlockDiagnostic(block, section, blockIndex) {
     return 'paragraph' === block.type.name || 'heading' === block.type.name ? {
         code: 'empty-structural-change',
@@ -17978,14 +18307,6 @@ function unsupportedResult(diagnostic) {
         ]
     };
 }
-function emptyComparisonSummary() {
-    return {
-        deletions: 0,
-        formatting: 0,
-        insertions: 0,
-        paragraphFormatting: 0
-    };
-}
 function childNodes(node) {
     const children = [];
     node.forEach((child)=>{
@@ -18185,7 +18506,7 @@ function DocumentCompareDialog({ initialMode, restoreFocusTarget, onApplied, onC
                             }
                         }),
                         /*#__PURE__*/ jsx("small", {
-                            children: "该名称会显示在生成的插入、删除与格式修订中。"
+                            children: "该名称会显示在生成的插入、删除、移动与格式修订中。"
                         })
                     ]
                 }),
@@ -18223,7 +18544,7 @@ function ComparisonBoundary({ mode }) {
                 children: 'compare' === mode ? '确定性比较边界' : '安全合并边界'
             }),
             /*#__PURE__*/ jsx("p", {
-                children: 'compare' === mode ? '支持同一分节布局中的段落、标题、文字和格式差异；复杂对象或节布局变化会明确停止。' : '审阅副本必须包含修订，且拒绝全部修订后与当前文档一致；现有修订须先处理。'
+                children: 'compare' === mode ? '支持同一分节布局中的段落、标题、文字、格式差异，以及同一段内可安全识别的文本移动；复杂对象或节布局变化会明确停止。' : '审阅副本必须包含修订，且拒绝全部修订后与当前文档一致；现有修订须先处理。'
             })
         ]
     });
@@ -18294,7 +18615,7 @@ function useDocumentComparison({ editor, onApplied }) {
         }
     };
     const applied = (result)=>{
-        const count = result.summary.insertions + result.summary.deletions + result.summary.formatting + result.summary.paragraphFormatting;
+        const count = result.summary.insertions + result.summary.deletions + result.summary.formatting + result.summary.paragraphFormatting + (result.summary.moves ?? 0);
         close();
         onApplied();
         showToast(`已生成 ${count} 项可审阅修订`, 'success');

package/dist/internal/features/work/work-document-compare-identities.d.ts

@@ -0,0 +1,28 @@
+import type { WorkDocumentChange, WorkDocumentChangeIdentity } from './work-document-changes';
+import type { WorkDocumentChangeKind } from './work-types';
+export type DocumentComparisonMode = 'compare' | 'combine';
+export interface DocumentComparisonSummary {
+    insertions: number;
+    deletions: number;
+    formatting: number;
+    paragraphFormatting: number;
+    /** Number of paired text moves inferred by Compare (when non-zero). */
+    moves?: number;
+}
+export interface DocumentComparisonOptions {
+    mode: DocumentComparisonMode;
+    author: string;
+    date: string;
+    sourceName: string;
+}
+export interface ComparisonIdentityFactory {
+    create(kind: WorkDocumentChangeKind, before?: string): WorkDocumentChangeIdentity;
+    paragraphIdentity(channel: string): {
+        paragraphId: string;
+        textId: string;
+    };
+    summary: DocumentComparisonSummary;
+}
+export declare function createComparisonIdentityFactory(currentSignature: string, revisedSignature: string, options: DocumentComparisonOptions): ComparisonIdentityFactory;
+export declare function summarizeComparisonChanges(changes: readonly WorkDocumentChange[]): DocumentComparisonSummary;
+export declare function emptyComparisonSummary(): DocumentComparisonSummary;

package/dist/internal/features/work/work-document-compare-moves.d.ts

@@ -0,0 +1,72 @@
+import type { Mark as ProseMirrorMark, Node as ProseMirrorNode, Schema } from '@tiptap/pm/model';
+import type { WorkDocumentChangeIdentity, WorkDocumentChangeKind } from './work-document-changes';
+import type { WorkDocumentMoveRole } from './work-types';
+export interface InlineUnit {
+    text: string;
+    marks: readonly ProseMirrorMark[];
+    leadingWhitespaceAttached?: boolean;
+}
+export type InlineDiffStep = {
+    kind: 'equal';
+    left: InlineUnit[];
+    right: InlineUnit[];
+} | {
+    kind: 'delete';
+    left: InlineUnit[];
+    right: [];
+} | {
+    kind: 'insert';
+    left: [];
+    right: InlineUnit[];
+};
+export interface InlineMoveCandidate {
+    /** Stable comparison scope (for example, the containing paragraph). */
+    scope?: string;
+    stepIndex: number;
+    kind: 'delete' | 'insert';
+    units: InlineUnit[];
+    start: number;
+    end: number;
+    startOffset: number;
+    endOffset: number;
+    text: string;
+}
+export interface InlineMovePair {
+    deletion: InlineMoveCandidate;
+    insertion: InlineMoveCandidate;
+}
+export interface InlineMoveComparison {
+    scope: string;
+    changes: readonly InlineDiffStep[];
+}
+export interface InlineMoveAssignment {
+    role: WorkDocumentMoveRole;
+    candidate: InlineMoveCandidate;
+    identity: WorkDocumentChangeIdentity;
+}
+export interface ComparisonMoveIdentityFactory {
+    create(kind: WorkDocumentChangeKind): WorkDocumentChangeIdentity;
+}
+type MarksEqual = (left: readonly ProseMirrorMark[], right: readonly ProseMirrorMark[]) => boolean;
+type StripReviewMarks = (marks: readonly ProseMirrorMark[]) => ProseMirrorMark[];
+type AppendRevisionUnits = (target: ProseMirrorNode[], units: readonly InlineUnit[], kind: 'insertion' | 'deletion', identity: WorkDocumentChangeIdentity, schema: Schema, stripReviewMarks: StripReviewMarks) => void;
+export declare const MAX_INFERRED_MOVE_TEXT = 65536;
+export declare function appendRevisionUnits(target: ProseMirrorNode[], units: readonly InlineUnit[], kind: 'insertion' | 'deletion', identity: WorkDocumentChangeIdentity, schema: Schema, stripReviewMarks: StripReviewMarks): void;
+/**
+ * Pairs deterministic same-text ranges. A comparison may contain several
+ * simple blocks, which lets Compare represent a bounded move between
+ * paragraphs while still rejecting duplicate or mark-mismatched candidates.
+ */
+export declare function inferInlineMovePairs(changes: readonly InlineDiffStep[], marksEqual: MarksEqual): InlineMovePair[];
+/**
+ * Infers moves across a bounded set of simple-block diffs. Candidate scopes
+ * are retained on each side so callers can put the resulting marks back into
+ * the right paragraph without flattening the document tree.
+ */
+export declare function inferInlineMovePairsAcrossScopes(comparisons: readonly InlineMoveComparison[], marksEqual: MarksEqual): InlineMovePair[];
+/**
+ * Splits an ordinary diff step around paired move ranges while retaining the
+ * exact whitespace and mark boundaries needed to reconstruct either version.
+ */
+export declare function appendComparisonRevisionUnits(target: ProseMirrorNode[], units: InlineUnit[], kind: 'insertion' | 'deletion', schema: Schema, factory: ComparisonMoveIdentityFactory, stripReviewMarks: StripReviewMarks, appendRevisionUnits: AppendRevisionUnits, moves?: readonly InlineMoveAssignment[]): void;
+export {};

package/dist/internal/features/work/work-document-compare.d.ts

@@ -1,5 +1,6 @@
 import { type Content, type Editor } from '@tiptap/core';
-export type DocumentComparisonMode = 'compare' | 'combine';
+import { type DocumentComparisonOptions, type DocumentComparisonSummary } from './work-document-compare-identities';
+export type { DocumentComparisonMode, DocumentComparisonOptions, DocumentComparisonSummary, } from './work-document-compare-identities';
 export type DocumentComparisonDiagnosticCode = 'changed-complex-structure' | 'combine-baseline-mismatch' | 'combine-resolution-invalid' | 'combine-structural-revisions' | 'combine-without-revisions' | 'comparison-limit-exceeded' | 'current-revisions-present' | 'empty-structural-change' | 'invalid-revised-content' | 'revised-revisions-present' | 'section-layout-mismatch' | 'unsupported-inline-review-state';
 export interface DocumentComparisonDiagnostic {
     code: DocumentComparisonDiagnosticCode;
@@ -7,18 +8,6 @@ export interface DocumentComparisonDiagnostic {
     section?: number;
     block?: number;
 }
-export interface DocumentComparisonSummary {
-    insertions: number;
-    deletions: number;
-    formatting: number;
-    paragraphFormatting: number;
-}
-export interface DocumentComparisonOptions {
-    mode: DocumentComparisonMode;
-    author: string;
-    date: string;
-    sourceName: string;
-}
 export interface DocumentComparisonApplyResult {
     status: 'applied' | 'unchanged' | 'unsupported';
     summary: DocumentComparisonSummary;

package/docs/latest/en/browser-editor-architecture.md

@@ -296,12 +296,19 @@ The current and imported TipTap/ProseMirror trees remain immutable while a
 deterministic weighted block alignment pairs related paragraphs and headings;
 an LCS token diff then produces insertion and deletion marks, while exact mark
 and paragraph-property snapshots produce character- and paragraph-formatting
-revisions. Stable semantic signatures seed generated identities, so the same
-inputs and options produce the same ordering and IDs. Only a fully admitted
-plan replaces the mounted document, and that replacement is one transaction,
-one controlled publication, and one Undo record. The planner does not infer
-move pairs from arbitrary delete/insert similarities; native paired moves remain
-reviewable when they already exist.
+revisions. A bounded move pass may pair a lexical range that occurs exactly
+once in a delete chunk and once in an insert chunk when its marks and carried
+separators match. The pass retains a stable paragraph scope, so it can pair
+aligned simple text blocks within one document section without flattening the
+document tree; section boundaries, rich blocks, and structural objects remain
+outside this inference. The result is one `move` identity with source and
+destination roles. Stable semantic signatures seed generated identities, so the
+same inputs and options produce the same ordering and IDs. Only a fully
+admitted plan replaces the mounted document, and that replacement is one
+transaction, one controlled publication, and one Undo record. Duplicate,
+mark-mismatched, section-boundary, rich, and over-limit candidates remain
+ordinary revisions or diagnostics rather than being guessed into moves; native
+paired moves remain reviewable when they already exist.
 
 Combine validates rather than guesses. It rejects every imported revision on
 an immutable reviewed snapshot and compares the resulting semantic signature

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@a3s-lab/office",
-  "version": "0.49.0",
+  "version": "0.51.0",
   "description": "Open-source collaborative browser editors for documents, Markdown, spreadsheets, presentations, and PDFs.",
   "keywords": [
     "office",