@a3s-lab/office 0.50.0 → 0.51.0

package/README.md

@@ -309,6 +309,23 @@ 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:
 

package/dist/0~document-editor.js

@@ -17496,29 +17496,40 @@ function work_document_compare_moves_appendRevisionUnits(target, units, kind, id
     ]));
 }
 function inferInlineMovePairs(changes, marksEqual) {
+    return inferInlineMovePairsAcrossScopes([
+        {
+            scope: '',
+            changes
+        }
+    ], marksEqual);
+}
+function inferInlineMovePairsAcrossScopes(comparisons, marksEqual) {
     const fullCandidates = [];
-    for (const [stepIndex, change] of changes.entries()){
+    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);
+        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(pair.deletion.stepIndex);
-        consumedSteps.add(pair.insertion.stepIndex);
+        consumedSteps.add(moveStepKey(pair.deletion));
+        consumedSteps.add(moveStepKey(pair.insertion));
     }
     const tokenCandidates = [];
-    for (const [stepIndex, change] of changes.entries()){
-        if ('equal' === change.kind || consumedSteps.has(stepIndex)) continue;
+    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));
+        tokenCandidates.push(...inlineMoveTokenCandidates(stepIndex, change.kind, units, comparison.scope));
     }
     return [
         ...fullPairs,
         ...pairInlineMoveCandidates(tokenCandidates, marksEqual)
-    ].sort((left, right)=>left.deletion.stepIndex - right.deletion.stepIndex || left.insertion.stepIndex - right.insertion.stepIndex || left.deletion.start - right.deletion.start).slice(0, MAX_INFERRED_MOVES);
+    ].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);
@@ -17579,9 +17590,9 @@ function pairInlineMoveCandidates(candidates, marksEqual) {
     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((left, right)=>left.deletion.stepIndex - right.deletion.stepIndex || left.insertion.stepIndex - right.insertion.stepIndex).slice(0, MAX_INFERRED_MOVES);
+        })).sort(compareMovePairs).slice(0, MAX_INFERRED_MOVES);
 }
-function inlineMoveCandidate(stepIndex, kind, units) {
+function inlineMoveCandidate(stepIndex, kind, units, scope = '') {
     let start = 0;
     while(start < units.length && isWhitespaceUnit(units[start]))start += 1;
     let end = units.length;
@@ -17594,6 +17605,9 @@ function inlineMoveCandidate(stepIndex, kind, units) {
     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,
@@ -17604,12 +17618,15 @@ function inlineMoveCandidate(stepIndex, kind, units) {
         text
     };
 }
-function inlineMoveTokenCandidates(stepIndex, kind, units) {
+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,
@@ -17622,6 +17639,12 @@ function inlineMoveTokenCandidates(stepIndex, kind, units) {
     }
     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);
@@ -17798,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);
@@ -17853,65 +17965,65 @@ function comparePairedBlocks(current, revised, factory) {
     }
     return current.type.create(attributes, inline);
 }
-function compareInlineContent(current, revised, factory) {
-    let currentUnits = inlineUnits(current);
-    let revisedUnits = inlineUnits(revised);
-    if (!currentUnits || !revisedUnits) return null;
-    const diff = boundedDocumentSequenceDiff(currentUnits, revisedUnits, (left, right)=>left.text === right.text, MAX_INLINE_DIFF_CELLS);
-    let changes = diff ?? [
-        {
-            kind: 'delete',
-            left: currentUnits,
-            right: []
-        },
-        {
-            kind: 'insert',
-            left: [],
-            right: revisedUnits
-        }
-    ];
-    const baseMovePairs = inferInlineMovePairs(changes, work_document_compare_marksEqual);
+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) {
-                currentUnits = moveCurrentUnits;
-                revisedUnits = moveRevisedUnits;
-                changes = moveChanges;
-            }
+            if (movePairs.length >= baseMovePairs.length && movePairs.length > 0) return {
+                variant: moveVariant,
+                attached: moveVariant
+            };
+            return {
+                variant,
+                attached: moveVariant
+            };
         }
     }
-    const movePairs = inferInlineMovePairs(changes, work_document_compare_marksEqual);
-    const movesByStep = new Map();
-    for (const pair of movePairs){
-        const identity = factory.create('move');
-        const deletion = movesByStep.get(pair.deletion.stepIndex) ?? [];
-        deletion.push({
-            role: 'from',
-            candidate: pair.deletion,
-            identity
-        });
-        movesByStep.set(pair.deletion.stepIndex, deletion);
-        const insertion = movesByStep.get(pair.insertion.stepIndex) ?? [];
-        insertion.push({
-            role: 'to',
-            candidate: pair.insertion,
-            identity
-        });
-        movesByStep.set(pair.insertion.stepIndex, insertion);
-    }
+    return {
+        variant
+    };
+}
+function renderInlineComparison(current, variant, factory, moves) {
+    const { changes } = variant;
     const nodes = [];
     for (const [stepIndex, change] of changes.entries()){
         if ('delete' === change.kind) {
-            appendComparisonRevisionUnits(nodes, change.left, 'deletion', current.type.schema, factory, withoutReviewMarks, work_document_compare_moves_appendRevisionUnits, movesByStep.get(stepIndex));
+            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) {
-            appendComparisonRevisionUnits(nodes, change.right, 'insertion', current.type.schema, factory, withoutReviewMarks, work_document_compare_moves_appendRevisionUnits, movesByStep.get(stepIndex));
+            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;

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

@@ -20,6 +20,8 @@ export type InlineDiffStep = {
     right: InlineUnit[];
 };
 export interface InlineMoveCandidate {
+    /** Stable comparison scope (for example, the containing paragraph). */
+    scope?: string;
     stepIndex: number;
     kind: 'delete' | 'insert';
     units: InlineUnit[];
@@ -33,6 +35,10 @@ export interface InlineMovePair {
     deletion: InlineMoveCandidate;
     insertion: InlineMoveCandidate;
 }
+export interface InlineMoveComparison {
+    scope: string;
+    changes: readonly InlineDiffStep[];
+}
 export interface InlineMoveAssignment {
     role: WorkDocumentMoveRole;
     candidate: InlineMoveCandidate;
@@ -47,11 +53,17 @@ type AppendRevisionUnits = (target: ProseMirrorNode[], units: readonly InlineUni
 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 only deterministic same-text ranges inside one block. Duplicate
- * candidates and ranges whose marks differ are deliberately left as ordinary
- * insertions/deletions so Compare never guesses at an ambiguous move.
+ * 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.

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

@@ -296,16 +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. A bounded same-paragraph 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 result is one `move` identity with source and
+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,
-rich, cross-paragraph, and over-limit candidates remain ordinary revisions or
-diagnostics rather than being guessed into moves; native paired moves remain
-reviewable when they already exist.
+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.50.0",
+  "version": "0.51.0",
   "description": "Open-source collaborative browser editors for documents, Markdown, spreadsheets, presentations, and PDFs.",
   "keywords": [
     "office",