@fluidframework/merge-tree 2.31.0 → 2.32.0

package/lib/client.js

@@ -11,11 +11,12 @@ import { LoggingError, UsageError, } from "@fluidframework/telemetry-utils/inter
 import { MergeTreeTextHelper } from "./MergeTreeTextHelper.js";
 import { RedBlackTree } from "./collections/index.js";
 import { NonCollabClient, UniversalSequenceNumber } from "./constants.js";
-import { MergeTree, errorIfOptionNotTrue, isRemovedAndAcked, } from "./mergeTree.js";
+import { SlidingPreference } from "./localReference.js";
+import { MergeTree, errorIfOptionNotTrue, getSlideToSegoff, isRemovedAndAcked, } from "./mergeTree.js";
 import { walkAllChildSegments } from "./mergeTreeNodeWalk.js";
 import { compareStrings, isSegmentLeaf, } from "./mergeTreeNodes.js";
 import { createAdjustRangeOp, createAnnotateMarkerOp, createAnnotateRangeOp, createGroupOp, createInsertSegmentOp, createObliterateRangeOp, createObliterateRangeOpSided, createRemoveRangeOp, } from "./opBuilder.js";
-import { MergeTreeDeltaType, } from "./ops.js";
+import { MergeTreeDeltaType, ReferenceType, } from "./ops.js";
 import { LocalReconnectingPerspective, PriorPerspective, } from "./perspective.js";
 import { DetachedReferencePosition } from "./referencePositions.js";
 import { isInserted, isRemoved, overwriteInfo, toRemovalInfo, } from "./segmentInfos.js";
@@ -56,7 +57,7 @@ export class Client extends TypedEventEmitter {
         this.getMinInFlightRefSeq = getMinInFlightRefSeq;
         this.clientNameToIds = new RedBlackTree(compareStrings);
         this.shortClientIdMap = [];
-        this.lastNormalizationRefSeq = 0;
+        this.cachedObliterateRebases = new Map();
         this._mergeTree = new MergeTree(options);
         this._mergeTree.mergeTreeDeltaCallback = (opArgs, deltaArgs) => {
             this.emit("delta", opArgs, deltaArgs, this);
@@ -492,7 +493,7 @@ export class Client extends TypedEventEmitter {
     ackPendingSegment(opArgs) {
         if (opArgs.op.type === MergeTreeDeltaType.GROUP) {
             for (const memberOp of opArgs.op.ops) {
-                this._mergeTree.ackPendingSegment({
+                this._mergeTree.ackOp({
                     groupOp: opArgs.op,
                     op: memberOp,
                     sequencedMessage: opArgs.sequencedMessage,
@@ -500,7 +501,7 @@ export class Client extends TypedEventEmitter {
             }
         }
         else {
-            this._mergeTree.ackPendingSegment(opArgs);
+            this._mergeTree.ackOp(opArgs);
         }
     }
     getOrAddShortClientId(longClientId) {
@@ -540,22 +541,140 @@ export class Client extends TypedEventEmitter {
         const perspective = new LocalReconnectingPerspective(currentSeq, clientId, localSeq);
         return this._mergeTree.getPosition(segment, perspective);
     }
+    /**
+     * Rebases a sided local reference to the best fitting position in the current tree.
+     */
+    rebaseSidedLocalReference(ref, side, reconnectingPerspective, slidePreference) {
+        const oldSegment = ref.getSegment();
+        const oldOffset = ref.getOffset();
+        assert(oldSegment !== undefined && oldOffset !== undefined, 0xb61 /* Invalid old reference */);
+        const useNewSlidingBehavior = true;
+        // Destructuring segment + offset is convenient and segment is reassigned
+        // eslint-disable-next-line prefer-const
+        let { segment: newSegment, offset: newOffset } = getSlideToSegoff({ segment: oldSegment, offset: oldOffset }, slidePreference, reconnectingPerspective, useNewSlidingBehavior);
+        newSegment ??=
+            slidePreference === SlidingPreference.FORWARD
+                ? this._mergeTree.endOfTree
+                : this._mergeTree.startOfTree;
+        assert(isSegmentLeaf(newSegment) && newOffset !== undefined, 0xb62 /* Invalid new segment on rebase */);
+        const newSide = newSegment === oldSegment
+            ? side
+            : // If the reference slid to a new position, the closest fit to the original position will be independent of
+                // the original side and "in the direction of where the reference was".
+                slidePreference === SlidingPreference.FORWARD
+                    ? Side.Before
+                    : Side.After;
+        return { segment: newSegment, offset: newOffset, side: newSide };
+    }
+    computeNewObliterateEndpoints(obliterateInfo) {
+        const { currentSeq, clientId } = this.getCollabWindow();
+        const reconnectingPerspective = new LocalReconnectingPerspective(currentSeq, clientId, obliterateInfo.stamp.localSeq - 1);
+        const newStart = this.rebaseSidedLocalReference(obliterateInfo.start, obliterateInfo.startSide, reconnectingPerspective, SlidingPreference.FORWARD);
+        const newEnd = this.rebaseSidedLocalReference(obliterateInfo.end, obliterateInfo.endSide, reconnectingPerspective, SlidingPreference.BACKWARD);
+        return {
+            start: newStart,
+            end: newEnd,
+        };
+    }
     resetPendingDeltaToOps(resetOp, segmentGroup) {
         assert(!!segmentGroup, 0x033 /* "Segment group undefined" */);
         const NACKedSegmentGroup = this.pendingRebase?.shift()?.data;
         assert(segmentGroup === NACKedSegmentGroup, 0x034 /* "Segment group not at head of pending rebase queue" */);
+        assert(segmentGroup.localSeq !== undefined, 0x867 /* expected segment group localSeq to be defined */);
         if (this.pendingRebase?.empty) {
             this.pendingRebase = undefined;
         }
-        // if this is an obliterate op, keep all segments in same segment group
-        const obliterateSegmentGroup = {
-            segments: [],
-            localSeq: segmentGroup.localSeq,
-            refSeq: this.getCollabWindow().currentSeq,
-            obliterateInfo: {
-                ...segmentGroup.obliterateInfo,
-            },
-        };
+        if (resetOp.type === MergeTreeDeltaType.OBLITERATE ||
+            resetOp.type === MergeTreeDeltaType.OBLITERATE_SIDED) {
+            errorIfOptionNotTrue(this._mergeTree.options, "mergeTreeEnableObliterateReconnect");
+            // sliceRemove reconnect logic is characteristically different from other ops (which can only apply to segments they originally saw).
+            // This is because the ranges that other ops apply to can be broken up by concurrent insertions, so even though setRemoves are originally
+            // applied to a contiguous set of segments, at resubmission time they may no longer be.
+            // On the other hand, the closest analog to a `sliceRemove` that we can submit is obtained by resolving the "closest" start and end points
+            // for that slice, updating the local obliterate metadata to reflect that slice, and submitting a single op.
+            const obliterateInfo = segmentGroup.obliterateInfo;
+            assert(obliterateInfo !== undefined, 0xb63 /* Resubmitting obliterate op without obliterate info in segment group */);
+            assert(obliterateInfo.stamp.localSeq === segmentGroup.localSeq, 0xb64 /* Local seq mismatch */);
+            const cachedNewPositions = this.cachedObliterateRebases.get(obliterateInfo.stamp.localSeq);
+            assert(cachedNewPositions !== undefined, 0xb65 /* didn't compute new positions for obliterate on reconnect early enough */);
+            const { start: { segment: newStartSegment, offset: newStartOffset, side: newStartSide }, end: { segment: newEndSegment, offset: newEndOffset, side: newEndSide }, } = cachedNewPositions;
+            const { currentSeq, clientId } = this.getCollabWindow();
+            if (newEndSegment.ordinal < newStartSegment.ordinal) {
+                for (const segment of segmentGroup.segments) {
+                    assert(isRemovedAndAcked(segment), 0xb66 /* On reconnect, obliterate applied to new segments even though original ones were not removed. */);
+                    const lastRemove = segment.removes[segment.removes.length - 1];
+                    assert(lastRemove.type === "sliceRemove" && lastRemove.localSeq === segmentGroup.localSeq, 0xb67 /* Last remove should be the obliterate that is being resubmitted. */);
+                    // The original obliterate affected this segment, but it has since been removed and overlapping removes
+                    // are only possible when they are concurrent. We adjust the metadata on that segment now to reflect
+                    // the fact that the obliterate no longer affects it.
+                    segment.removes.pop();
+                }
+                this._mergeTree.rebaseObliterateTo(obliterateInfo, undefined);
+                return [];
+            }
+            assert(obliterateInfo.tiebreakTrackingGroup !== undefined, 0xb68 /* Tiebreak tracking group missing */);
+            const newObliterate = {
+                // Recreate the start position using the perspective that other clients will see.
+                // This may not be at the same position as the original reference, since the segment the original reference was on could have been removed.
+                start: this._mergeTree.createLocalReferencePosition(newStartSegment, newStartOffset, ReferenceType.StayOnRemove, undefined),
+                startSide: newStartSide,
+                end: this._mergeTree.createLocalReferencePosition(newEndSegment, newEndOffset, ReferenceType.StayOnRemove, undefined),
+                endSide: newEndSide,
+                refSeq: currentSeq,
+                // We reuse the localSeq from the original obliterate.
+                stamp: obliterateInfo.stamp,
+                segmentGroup: undefined,
+                tiebreakTrackingGroup: obliterateInfo.tiebreakTrackingGroup,
+            };
+            newObliterate.start.addProperties({ obliterate: newObliterate });
+            newObliterate.end.addProperties({ obliterate: newObliterate });
+            newObliterate.segmentGroup = {
+                segments: [],
+                localSeq: segmentGroup.localSeq,
+                refSeq: this.getCollabWindow().currentSeq,
+                obliterateInfo: newObliterate,
+            };
+            for (const segment of segmentGroup.segments) {
+                assert(segment.segmentGroups?.remove(segmentGroup) === true, 0x035 /* "Segment group not in segment pending queue" */);
+                if ((segment.ordinal > newStartSegment.ordinal &&
+                    segment.ordinal < newEndSegment.ordinal) ||
+                    (segment === newStartSegment && newStartSide === Side.Before) ||
+                    (segment === newEndSegment && newEndSide === Side.After)) {
+                    segment.segmentGroups.enqueue(newObliterate.segmentGroup);
+                }
+                else {
+                    assert(isRemovedAndAcked(segment), 0xb69 /* On reconnect, obliterate applied to new segments even though original ones were not removed. */);
+                    const lastRemove = segment.removes[segment.removes.length - 1];
+                    assert(lastRemove.type === "sliceRemove" && lastRemove.localSeq === segmentGroup.localSeq, 0xb6a /* Last remove should be the obliterate that is being resubmitted. */);
+                    // The original obliterate affected this segment, but it has since been removed and it's impossible to apply the
+                    // local obliterate so that is so. We adjust the metadata on that segment now.
+                    segment.removes.pop();
+                }
+            }
+            this._mergeTree.rebaseObliterateTo(obliterateInfo, newObliterate);
+            this._mergeTree.pendingSegments.push(newObliterate.segmentGroup);
+            const reconnectingPerspective = new LocalReconnectingPerspective(currentSeq, clientId, obliterateInfo.stamp.localSeq - 1);
+            const newStartPos = this._mergeTree.getPosition(newStartSegment, reconnectingPerspective) + newStartOffset;
+            const newEndPos = this._mergeTree.getPosition(newEndSegment, reconnectingPerspective) + newEndOffset;
+            if (resetOp.type === MergeTreeDeltaType.OBLITERATE) {
+                assert(newStartSide === Side.Before && newEndSide === Side.After, 0xb6b /* Non-sided obliterate should have start side before and end side after */);
+                // Use a non-sided obliterate op if the original op was non-sided. Some combinations of feature flags disallow sided obliterate ops
+                // but allow non-sided ones, and if we convert a non-sided op to a sided one on reconnect, we may cause errors.
+                return [
+                    createObliterateRangeOp(newStartPos, newEndPos +
+                        1 /* to make the end exclusive, see corresponding -1 in `createObliterateRangeOpSided` on converting non-sided to sided. */),
+                ];
+            }
+            return [
+                createObliterateRangeOpSided({
+                    pos: newStartPos,
+                    side: newStartSide,
+                }, {
+                    pos: newEndPos,
+                    side: newEndSide,
+                }),
+            ];
+        }
         const opList = [];
         // We need to sort the segments by ordinal, as the segments are not sorted in the segment group.
         // The reason they need them sorted, as they have the same local sequence number and which means
@@ -563,8 +682,7 @@ export class Client extends TypedEventEmitter {
         // By sorting we ensure the nearer segment will be applied and sequenced before the farther segments
         // so their recalculated positions will be correct.
         for (const segment of segmentGroup.segments.sort((a, b) => a.ordinal < b.ordinal ? -1 : 1)) {
-            assert(segment.segmentGroups?.remove(segmentGroup) === true, 0x035 /* "Segment group not in segment pending queue" */);
-            assert(segmentGroup.localSeq !== undefined, 0x867 /* expected segment group localSeq to be defined */);
+            assert(segment.segmentGroups?.remove(segmentGroup) === true, 0xb6c /* Segment group not in segment pending queue */);
             const segmentPosition = this.findReconnectionPosition(segment, segmentGroup.localSeq);
             let newOp;
             switch (resetOp.type) {
@@ -618,33 +736,11 @@ export class Client extends TypedEventEmitter {
                     }
                     break;
                 }
-                case MergeTreeDeltaType.OBLITERATE: {
-                    errorIfOptionNotTrue(this._mergeTree.options, "mergeTreeEnableObliterateReconnect");
-                    // Only bother resubmitting if nobody else has removed it in the meantime.
-                    // When that happens, the first removal will have been acked.
-                    if (isRemoved(segment) && opstampUtils.isLocal(segment.removes[0])) {
-                        newOp = createObliterateRangeOp(segmentPosition, segmentPosition + segment.cachedLength);
-                    }
-                    break;
-                }
                 default: {
                     throw new Error(`Invalid op type`);
                 }
             }
-            if (newOp && resetOp.type === MergeTreeDeltaType.OBLITERATE) {
-                segment.segmentGroups.enqueue(obliterateSegmentGroup);
-                const first = opList[0];
-                if (!!first &&
-                    first.pos2 !== undefined &&
-                    first.type !== MergeTreeDeltaType.OBLITERATE_SIDED &&
-                    newOp.type !== MergeTreeDeltaType.OBLITERATE_SIDED) {
-                    first.pos2 += newOp.pos2 - newOp.pos1;
-                }
-                else {
-                    opList.push(newOp);
-                }
-            }
-            else if (newOp) {
+            if (newOp) {
                 const newSegmentGroup = {
                     segments: [],
                     localSeq: segmentGroup.localSeq,
@@ -655,10 +751,6 @@ export class Client extends TypedEventEmitter {
                 opList.push(newOp);
             }
         }
-        if (resetOp.type === MergeTreeDeltaType.OBLITERATE &&
-            obliterateSegmentGroup.segments.length > 0) {
-            this._mergeTree.pendingSegments.push(obliterateSegmentGroup);
-        }
         return opList;
     }
     applyRemoteOp(opArgs) {
@@ -789,11 +881,28 @@ export class Client extends TypedEventEmitter {
             assert(firstGroupNode !== undefined, 0x70e /* segment group must exist in pending list */);
             this.pendingRebase = this._mergeTree.pendingSegments.splice(firstGroupNode);
         }
-        const rebaseTo = this.getCollabWindow().currentSeq;
-        if (rebaseTo !== this.lastNormalizationRefSeq) {
+        const collabWindow = this.getCollabWindow();
+        if (this.lastNormalization === undefined ||
+            collabWindow.currentSeq !== this.lastNormalization.refSeq ||
+            collabWindow.localSeq !== this.lastNormalization.localRefSeq) {
+            // Compute obliterate endpoint destinations before segments are normalized.
+            // Segment normalization can affect what should be the semantically correct segments for the endpoints to be placed on.
+            this.cachedObliterateRebases.clear();
+            for (const group of [...this._mergeTree.pendingSegments, ...this.pendingRebase]) {
+                const { obliterateInfo } = group.data;
+                if (obliterateInfo !== undefined) {
+                    const { start, end } = this.computeNewObliterateEndpoints(obliterateInfo);
+                    const { localSeq } = obliterateInfo.stamp;
+                    assert(localSeq !== undefined, 0xb6d /* Local seq must be defined */);
+                    this.cachedObliterateRebases.set(localSeq, { start, end });
+                }
+            }
             this.emit("normalize", this);
             this._mergeTree.normalizeSegmentsOnRebase();
-            this.lastNormalizationRefSeq = rebaseTo;
+            this.lastNormalization = {
+                refSeq: collabWindow.currentSeq,
+                localRefSeq: collabWindow.localSeq,
+            };
         }
         const opList = [];
         if (resetOp.type === MergeTreeDeltaType.GROUP) {