@a3s-lab/office 0.49.0 → 0.50.0

package/README.md

@@ -309,6 +309,23 @@ and [CLI reference](./docs/latest/en/cli-reference.md).
 
 ## Current release
 
+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,222 @@ 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) {
+    const fullCandidates = [];
+    for (const [stepIndex, change] of changes.entries()){
+        if ('equal' === change.kind) continue;
+        const units = 'delete' === change.kind ? change.left : change.right;
+        const candidate = inlineMoveCandidate(stepIndex, change.kind, units);
+        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);
+    }
+    const tokenCandidates = [];
+    for (const [stepIndex, change] of changes.entries()){
+        if ('equal' === change.kind || consumedSteps.has(stepIndex)) continue;
+        const units = 'delete' === change.kind ? change.left : change.right;
+        tokenCandidates.push(...inlineMoveTokenCandidates(stepIndex, change.kind, units));
+    }
+    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);
+}
+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((left, right)=>left.deletion.stepIndex - right.deletion.stepIndex || left.insertion.stepIndex - right.insertion.stepIndex).slice(0, MAX_INFERRED_MOVES);
+}
+function inlineMoveCandidate(stepIndex, kind, units) {
+    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 {
+        stepIndex,
+        kind,
+        units,
+        start,
+        end,
+        startOffset,
+        endOffset,
+        text
+    };
+}
+function inlineMoveTokenCandidates(stepIndex, kind, units) {
+    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({
+            stepIndex,
+            kind,
+            units,
+            start: index,
+            end: index + 1,
+            startOffset: leadingWhitespace,
+            endOffset: unit.text.length,
+            text
+        });
+    }
+    return candidates;
+}
+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 +17713,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 +17782,7 @@ function planDocumentCombine(current, reviewed) {
     return {
         status: 'applied',
         document: document1,
-        summary: summarizeChanges(reviewedChanges),
+        summary: summarizeComparisonChanges(reviewedChanges),
         diagnostics: []
     };
 }
@@ -17638,11 +17854,11 @@ function comparePairedBlocks(current, revised, factory) {
     return current.type.create(attributes, inline);
 }
 function compareInlineContent(current, revised, factory) {
-    const currentUnits = inlineUnits(current);
-    const revisedUnits = inlineUnits(revised);
+    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);
-    const changes = diff ?? [
+    let changes = diff ?? [
         {
             kind: 'delete',
             left: currentUnits,
@@ -17654,14 +17870,48 @@ function compareInlineContent(current, revised, factory) {
             right: revisedUnits
         }
     ];
+    const baseMovePairs = inferInlineMovePairs(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 movePairs = inferInlineMovePairs(moveChanges, work_document_compare_marksEqual);
+            if (movePairs.length >= baseMovePairs.length && movePairs.length > 0) {
+                currentUnits = moveCurrentUnits;
+                revisedUnits = moveRevisedUnits;
+                changes = moveChanges;
+            }
+        }
+    }
+    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);
+    }
     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, movesByStep.get(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, movesByStep.get(stepIndex));
             continue;
         }
         let formattingIdentity = null;
@@ -17669,7 +17919,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 +17943,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 +17963,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 +17976,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 +18059,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 +18173,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 +18195,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 +18394,7 @@ function DocumentCompareDialog({ initialMode, restoreFocusTarget, onApplied, onC
                             }
                         }),
                         /*#__PURE__*/ jsx("small", {
-                            children: "该名称会显示在生成的插入、删除与格式修订中。"
+                            children: "该名称会显示在生成的插入、删除、移动与格式修订中。"
                         })
                     ]
                 }),
@@ -18223,7 +18432,7 @@ function ComparisonBoundary({ mode }) {
                 children: 'compare' === mode ? '确定性比较边界' : '安全合并边界'
             }),
             /*#__PURE__*/ jsx("p", {
-                children: 'compare' === mode ? '支持同一分节布局中的段落、标题、文字和格式差异；复杂对象或节布局变化会明确停止。' : '审阅副本必须包含修订，且拒绝全部修订后与当前文档一致；现有修订须先处理。'
+                children: 'compare' === mode ? '支持同一分节布局中的段落、标题、文字、格式差异，以及同一段内可安全识别的文本移动；复杂对象或节布局变化会明确停止。' : '审阅副本必须包含修订，且拒绝全部修订后与当前文档一致；现有修订须先处理。'
             })
         ]
     });
@@ -18294,7 +18503,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,60 @@
+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 {
+    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 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 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.
+ */
+export declare function inferInlineMovePairs(changes: readonly InlineDiffStep[], 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,11 +296,15 @@ 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
+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
+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.
 
 Combine validates rather than guesses. It rejects every imported revision on

package/package.json

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