@fluidframework/merge-tree 2.31.0 → 2.32.0

package/lib/mergeTree.js

@@ -7,20 +7,21 @@
 import { assert, Heap } from "@fluidframework/core-utils/internal";
 import { DataProcessingError, UsageError } from "@fluidframework/telemetry-utils/internal";
 import { DoublyLinkedList } from "./collections/index.js";
-import { NonCollabClient, TreeMaintenanceSequenceNumber, UnassignedSequenceNumber, UniversalSequenceNumber, } from "./constants.js";
+import { NonCollabClient, TreeMaintenanceSequenceNumber, UnassignedSequenceNumber, } from "./constants.js";
 import { EndOfTreeSegment, StartOfTreeSegment } from "./endOfTreeSegment.js";
-import { LocalReferenceCollection, SlidingPreference, anyLocalReferencePosition, createDetachedLocalReferencePosition, filterLocalReferencePositions, } from "./localReference.js";
+import { LocalReferenceCollection, SlidingPreference, anyLocalReferencePosition, filterLocalReferencePositions, } from "./localReference.js";
 import { MergeTreeMaintenanceType, } from "./mergeTreeDeltaCallback.js";
 import { LeafAction, NodeAction, backwardExcursion, depthFirstNodeWalk, forwardExcursion, walkAllChildSegments, } from "./mergeTreeNodeWalk.js";
 import { CollaborationWindow, Marker, MaxNodesInBlock, MergeBlock, assertSegmentLeaf, assignChild, getMinSeqPerspective, getMinSeqStamp, isSegmentLeaf, reservedMarkerIdKey, } from "./mergeTreeNodes.js";
+import { UnorderedTrackingGroup } from "./mergeTreeTracking.js";
 import { createAnnotateRangeOp, createInsertSegmentOp, createRemoveRangeOp, } from "./opBuilder.js";
 import { MergeTreeDeltaType, ReferenceType, } from "./ops.js";
 import { PartialSequenceLengths } from "./partialLengths.js";
-import { PriorPerspective, LocalReconnectingPerspective, LocalDefaultPerspective, RemoteObliteratePerspective, } from "./perspective.js";
+import { PriorPerspective, LocalReconnectingPerspective, LocalDefaultPerspective, RemoteObliteratePerspective, allAckedChangesPerspective, } from "./perspective.js";
 import { createMap, extend, extendIfUndefined } from "./properties.js";
 import { DetachedReferencePosition, refGetTileLabels, refHasTileLabel, refTypeIncludesFlag, } from "./referencePositions.js";
 import { SegmentGroupCollection } from "./segmentGroupCollection.js";
-import { assertRemoved, isMergeNodeInfo, isRemoved, overwriteInfo, removeRemovalInfo, toRemovalInfo, } from "./segmentInfos.js";
+import { assertRemoved, isInsideObliterate, isMergeNodeInfo, isRemoved, overwriteInfo, removeRemovalInfo, toRemovalInfo, } from "./segmentInfos.js";
 import { copyPropertiesAndManager, PropertiesManager, } from "./segmentPropertiesManager.js";
 import { Side } from "./sequencePlace.js";
 import { SortedSegmentSet } from "./sortedSegmentSet.js";
@@ -74,13 +75,6 @@ function ackSegment(segment, segmentGroup, opArgs, stamp) {
                 type: op.type === MergeTreeDeltaType.REMOVE ? "setRemove" : "sliceRemove",
             };
             segment.removes[segment.removes.length - 1] = removeStamp;
-            const { obliterateInfo } = segmentGroup;
-            const hasObliterateInfo = obliterateInfo !== undefined;
-            const isObliterate = op.type !== MergeTreeDeltaType.REMOVE;
-            assert(hasObliterateInfo === isObliterate, 0xa40 /* must have obliterate info */);
-            if (hasObliterateInfo) {
-                obliterateInfo.stamp = removeStamp;
-            }
             break;
         }
         default: {
@@ -117,8 +111,10 @@ export function findRootMergeBlock(segmentOrNode) {
  * This can reduce the number of times the tree needs to be scanned if a range containing many
  * SlideOnRemove references is removed.
  */
-function getSlideToSegment(segment, slidingPreference = SlidingPreference.FORWARD, cache, useNewSlidingBehavior = false) {
-    if (!segment || !isRemovedAndAcked(segment) || segment.endpointType !== undefined) {
+function getSlideToSegment(segment, slidingPreference = SlidingPreference.FORWARD, perspective, cache, useNewSlidingBehavior = false) {
+    if (!segment ||
+        perspective.isSegmentPresent(segment) ||
+        segment.endpointType !== undefined) {
         return [segment, undefined];
     }
     const cachedSegment = cache?.get(segment);
@@ -128,7 +124,7 @@ function getSlideToSegment(segment, slidingPreference = SlidingPreference.FORWAR
     const result = {};
     cache?.set(segment, result);
     const goFurtherToFindSlideToSegment = (seg) => {
-        if (opstampUtils.isAcked(seg.insert) && !isRemovedAndAcked(seg)) {
+        if (perspective.isSegmentPresent(seg)) {
             result.seg = seg;
             return false;
         }
@@ -179,11 +175,11 @@ function getSlideToSegment(segment, slidingPreference = SlidingPreference.FORWAR
  * @returns segment and offset to slide the reference to
  * @internal
  */
-export function getSlideToSegoff(segoff, slidingPreference = SlidingPreference.FORWARD, useNewSlidingBehavior = false) {
+export function getSlideToSegoff(segoff, slidingPreference = SlidingPreference.FORWARD, perspective = allAckedChangesPerspective, useNewSlidingBehavior = false) {
     if (!isSegmentLeaf(segoff.segment)) {
         return segoff;
     }
-    const [segment, _] = getSlideToSegment(segoff.segment, slidingPreference, undefined, useNewSlidingBehavior);
+    const [segment, _] = getSlideToSegment(segoff.segment, slidingPreference, perspective, undefined, useNewSlidingBehavior);
     if (segment === segoff.segment) {
         return segoff;
     }
@@ -224,6 +220,9 @@ class Obliterates {
             this.mergeTree.removeLocalReferencePosition(ob.data.end);
         }
     }
+    onNormalize() {
+        this.startOrdered.onSortOrderChange();
+    }
     addOrUpdate(obliterateInfo) {
         const { stamp: { seq }, start, } = obliterateInfo;
         if (seq !== UnassignedSequenceNumber) {
@@ -252,6 +251,39 @@ class Obliterates {
         }
         return overlapping;
     }
+    /**
+     * Remove a local obliterate from this data structure.
+     * @privateRemarks
+     * This data structure could support removing non-local obliterates if we wanted it to, but when adding support for that
+     * we should reconsider the indexing structure for seq ordered obliterates (right now it would be an O(# obliterates) operation)
+     */
+    removeLocalObliterate(obliterateInfo) {
+        assert(obliterateInfo.stamp.seq === UnassignedSequenceNumber, 0xb6e /* Expected local obliterate */);
+        this.startOrdered.remove(obliterateInfo.start);
+    }
+    /**
+     * Returns an iterator over the `ObliterateInfo` for all obliterates in the collab window. Obliterates are not guaranteed to be ordered.
+     * The iterator is not guaranteed to be valid over edits to the set of obliterates.
+     */
+    [Symbol.iterator]() {
+        let index = 0;
+        const { items: starts } = this.startOrdered;
+        const iterator = {
+            next() {
+                if (index < starts.length) {
+                    const start = starts[index++];
+                    const info = start.properties?.obliterate;
+                    assert(info?.start !== undefined && info?.end !== undefined, 0xb6f /* Expected obliterateInfo endpoint to map to its obliterate */);
+                    return { value: info, done: false };
+                }
+                return { value: undefined, done: true };
+            },
+            [Symbol.iterator]() {
+                return this;
+            },
+        };
+        return iterator;
+    }
 }
 /**
  * @internal
@@ -287,13 +319,8 @@ export class MergeTree {
                 next.segmentGroups ??= new SegmentGroupCollection(next);
                 segment.segmentGroups.copyTo(next.segmentGroups);
             }
-            if (segment.obliteratePrecedingInsertion) {
-                next.obliteratePrecedingInsertion = segment.obliteratePrecedingInsertion;
-            }
             copyPropertiesAndManager(segment, next);
-            if (segment.localRefs) {
-                segment.localRefs.split(pos, next);
-            }
+            segment.localRefs?.split(pos, next);
             this.mergeTreeMaintenanceCallback?.({
                 operation: MergeTreeMaintenanceType.SPLIT,
                 deltaSegments: [{ segment }, { segment: next }],
@@ -306,6 +333,12 @@ export class MergeTree {
         this._root.mergeTree = this;
         this.attributionPolicy = options?.attribution?.policyFactory?.();
     }
+    rebaseObliterateTo(existing, newObliterate) {
+        this.obliterates.removeLocalObliterate(existing);
+        if (newObliterate !== undefined) {
+            this.obliterates.addOrUpdate(newObliterate);
+        }
+    }
     get root() {
         return this._root;
     }
@@ -519,7 +552,7 @@ export class MergeTree {
             if (!segment.localRefs || !anyLocalReferencePosition(segment.localRefs, pred)) {
                 return;
             }
-            const [slideToSegment, maybeEndpoint] = getSlideToSegment(segment, slidingPreference, slidingPreference === SlidingPreference.FORWARD
+            const [slideToSegment, maybeEndpoint] = getSlideToSegment(segment, slidingPreference, allAckedChangesPerspective, slidingPreference === SlidingPreference.FORWARD
                 ? forwardSegmentCache
                 : backwardSegmentCache, this.options?.mergeTreeReferencesCanSlideToEndpoint);
             const slideIsForward = slideToSegment === undefined ? false : slideToSegment.ordinal > segment.ordinal;
@@ -720,10 +753,9 @@ export class MergeTree {
         this.nodeUpdateLengthNewStructure(this.root);
     }
     /**
-     * Assign sequence number to existing segment; update partial lengths to reflect the change
-     * @param seq - sequence number given by server to pending segment
+     * Assign sequence number to existing segments affected by an op; update partial lengths to reflect the change
      */
-    ackPendingSegment(opArgs) {
+    ackOp(opArgs) {
         const seq = opArgs.sequencedMessage.sequenceNumber;
         const stamp = {
             seq,
@@ -733,9 +765,25 @@ export class MergeTree {
         const nodesToUpdate = [];
         let overwrite = false;
         if (pendingSegmentGroup !== undefined) {
+            const { obliterateInfo, segments } = pendingSegmentGroup;
+            const hasObliterateInfo = obliterateInfo !== undefined;
+            const isObliterate = opArgs.op.type === MergeTreeDeltaType.OBLITERATE ||
+                opArgs.op.type === MergeTreeDeltaType.OBLITERATE_SIDED;
+            assert(hasObliterateInfo === isObliterate, 0xa40 /* must have obliterate info */);
+            if (hasObliterateInfo) {
+                obliterateInfo.stamp = { ...stamp, type: "sliceRemove" };
+                this.obliterates.addOrUpdate(obliterateInfo);
+                assert(obliterateInfo.tiebreakTrackingGroup !== undefined, 0xb70 /* obliterateInfo should have a tiebreak tracking group on ack */);
+                for (const segment of obliterateInfo.tiebreakTrackingGroup.tracked) {
+                    segment.trackingCollection.unlink(obliterateInfo.tiebreakTrackingGroup);
+                    assert(isSegmentLeaf(segment) && isInsideObliterate(segment), 0xb71 /* Expected segment leaf inside obliterate */);
+                    segment.insertionRefSeqStamp = undefined;
+                }
+                obliterateInfo.tiebreakTrackingGroup = undefined;
+            }
             const deltaSegments = [];
             const overlappingRemoves = [];
-            pendingSegmentGroup.segments.map((pendingSegment) => {
+            segments.map((pendingSegment) => {
                 const overlappingRemove = !ackSegment(pendingSegment, pendingSegmentGroup, opArgs, stamp);
                 overwrite ||= overlappingRemove;
                 overlappingRemoves.push(overlappingRemove);
@@ -749,16 +797,12 @@ export class MergeTree {
                     segment: pendingSegment,
                 });
             });
-            if (pendingSegmentGroup.obliterateInfo !== undefined) {
-                pendingSegmentGroup.obliterateInfo.stamp = { type: "sliceRemove", ...stamp };
-                this.obliterates.addOrUpdate(pendingSegmentGroup.obliterateInfo);
-            }
             // Perform slides after all segments have been acked, so that
             // positions after slide are final
             if (opArgs.op.type === MergeTreeDeltaType.REMOVE ||
                 opArgs.op.type === MergeTreeDeltaType.OBLITERATE ||
                 opArgs.op.type === MergeTreeDeltaType.OBLITERATE_SIDED) {
-                this.slideAckedRemovedSegmentReferences(pendingSegmentGroup.segments);
+                this.slideAckedRemovedSegmentReferences(segments);
             }
             this.mergeTreeMaintenanceCallback?.({
                 deltaSegments,
@@ -775,6 +819,7 @@ export class MergeTree {
     addToPendingList(segment, segmentGroup, localSeq, previousProps) {
         let _segmentGroup = segmentGroup;
         if (_segmentGroup === undefined) {
+            assert(localSeq !== undefined, 0xb72 /* Local seq should be passed when creating new segment group */);
             _segmentGroup = {
                 segments: [],
                 localSeq,
@@ -952,16 +997,15 @@ export class MergeTree {
                 saveIfLocal(newSegment);
                 continue;
             }
+            const refSeqStamp = {
+                seq: perspective.refSeq,
+                clientId: stamp.clientId,
+            };
             const overlappingAckedObliterates = [];
             let oldest;
             let newest;
             let newestAcked;
             let oldestUnacked;
-            const refSeqStamp = {
-                seq: perspective.refSeq,
-                clientId: stamp.clientId,
-                localSeq: stamp.localSeq,
-            };
             for (const ob of this.obliterates.findOverlapping(newSegment)) {
                 if (opstampUtils.greaterThan(ob.stamp, refSeqStamp)) {
                     // Any obliterate from the same client that's inserting this segment cannot cause the segment to be marked as
@@ -994,7 +1038,16 @@ export class MergeTree {
                     }
                 }
             }
-            newSegment.obliteratePrecedingInsertion = newest;
+            overwriteInfo(newSegment, {
+                obliteratePrecedingInsertion: newest,
+            });
+            if (newest !== undefined && opstampUtils.isLocal(newest.stamp)) {
+                assert(newest?.tiebreakTrackingGroup !== undefined, 0xb73 /* Expected local obliterateinfo to have tiebreak group */);
+                newest.tiebreakTrackingGroup.link(newSegment);
+                overwriteInfo(newSegment, {
+                    insertionRefSeqStamp: refSeqStamp,
+                });
+            }
             // See doc comment on obliteratePrecedingInsertion for more details: if the newest obliterate was performed
             // by the same client that's inserting this segment, we let them insert into this range and therefore don't
             // mark it obliterated.
@@ -1025,6 +1078,16 @@ export class MergeTree {
             saveIfLocal(newSegment);
         }
     }
+    computeObliteratePrecedingInsertion(segment, refSeqStamp) {
+        let newest;
+        for (const ob of this.obliterates.findOverlapping(segment)) {
+            if (opstampUtils.greaterThan(ob.stamp, refSeqStamp) &&
+                (newest === undefined || opstampUtils.greaterThan(ob.stamp, newest.stamp))) {
+                newest = ob;
+            }
+        }
+        return newest;
+    }
     ensureIntervalBoundary(pos, perspective) {
         this.insertingWalk(pos, perspective, {
             seq: TreeMaintenanceSequenceNumber,
@@ -1047,12 +1110,12 @@ export class MergeTree {
         }
     }
     insertingWalk(pos, perspective, stamp, context) {
-        const { remainder } = this.insertRecursive(this.root, pos, perspective, stamp, context);
+        const { remainder } = this.insertRecursive(this.root, pos, perspective, stamp, context, true);
         if (remainder !== undefined) {
             this.updateRoot(remainder);
         }
     }
-    insertRecursive(block, pos, perspective, stamp, context, isLastChildBlock = true) {
+    insertRecursive(block, pos, perspective, stamp, context, isLastBlock) {
         let _pos = pos;
         const children = block.children;
         let childIndex;
@@ -1062,9 +1125,11 @@ export class MergeTree {
         let hadChanges = false;
         for (childIndex = 0; childIndex < block.childCount; childIndex++) {
             child = children[childIndex];
-            // ensure we walk down the far edge of the tree, even if all sub-tree is eligible for zamboni
-            const isLastNonLeafBlock = isLastChildBlock && !child.isLeaf() && childIndex === block.childCount - 1;
-            const len = this.nodeLength(child, perspective) ?? (isLastChildBlock ? 0 : undefined);
+            // removed blocks below the min seq will have an undefined length, and be skipped
+            // however if it is the last block in the layer of the tree we don't want to skip it, so we correctly
+            // walk down the far edge of the tree.
+            const isLastChildOfLastBlock = isLastBlock && childIndex === block.childCount - 1;
+            const len = this.nodeLength(child, perspective) ?? (isLastChildOfLastBlock ? 0 : undefined);
             if (len === undefined) {
                 // if the seg len is undefined, the segment
                 // will be removed, so should just be skipped for now
@@ -1091,9 +1156,8 @@ export class MergeTree {
                     }
                 }
                 else {
-                    const childBlock = child;
                     // Internal node
-                    const insertResult = this.insertRecursive(childBlock, _pos, perspective, stamp, context, isLastNonLeafBlock);
+                    const insertResult = this.insertRecursive(child, _pos, perspective, stamp, context, isLastChildOfLastBlock);
                     hadChanges ||= insertResult.hadChanges;
                     if (insertResult.remainder === undefined) {
                         if (insertResult.hadChanges) {
@@ -1240,33 +1304,36 @@ export class MergeTree {
         let _overwrite = false;
         const localOverlapWithRefs = [];
         const removedSegments = [];
+        const createRefFromSequencePlace = (place) => {
+            const { segment: placeSeg, offset: placeOffset } = this.getContainingSegment(place.pos, perspective);
+            assert(isSegmentLeaf(placeSeg) && placeOffset !== undefined, 0xa3f /* segments cannot be undefined */);
+            return this.createLocalReferencePosition(placeSeg, placeOffset, ReferenceType.StayOnRemove, undefined);
+        };
         const obliterate = {
-            start: createDetachedLocalReferencePosition(undefined),
-            end: createDetachedLocalReferencePosition(undefined),
+            start: createRefFromSequencePlace(start),
+            startSide: start.side,
+            end: createRefFromSequencePlace(end),
+            endSide: end.side,
             refSeq: perspective.refSeq,
             stamp,
             segmentGroup: undefined,
+            tiebreakTrackingGroup: undefined,
         };
-        const { segment: startSeg } = this.getContainingSegment(start.pos, perspective);
-        const { segment: endSeg } = this.getContainingSegment(end.pos, perspective);
-        assert(isSegmentLeaf(startSeg) && isSegmentLeaf(endSeg), 0xa3f /* segments cannot be undefined */);
-        obliterate.start = this.createLocalReferencePosition(startSeg, start.side === Side.Before ? 0 : Math.max(startSeg.cachedLength - 1, 0), ReferenceType.StayOnRemove, {
-            obliterate,
-        });
-        obliterate.end = this.createLocalReferencePosition(endSeg, end.side === Side.Before ? 0 : Math.max(endSeg.cachedLength - 1, 0), ReferenceType.StayOnRemove, {
-            obliterate,
-        });
-        // Always create a segment group for obliterate,
-        // even if there are no segments currently in the obliteration range.
-        // Segments may be concurrently inserted into the obliteration range,
-        // at which point they are added to the segment group.
-        obliterate.segmentGroup = {
-            segments: [],
-            localSeq: stamp.localSeq,
-            refSeq: this.collabWindow.currentSeq,
-            obliterateInfo: obliterate,
-        };
+        // Link references back to this obliterate info
+        obliterate.start.addProperties({ obliterate });
+        obliterate.end.addProperties({ obliterate });
         if (this.collabWindow.collaborating && stamp.clientId === this.collabWindow.clientId) {
+            // Always create a segment group for local obliterates,
+            // even if there are no segments currently in the obliteration range.
+            // Segments may be concurrently inserted into the obliteration range,
+            // at which point they are added to the segment group.
+            obliterate.segmentGroup = {
+                segments: [],
+                localSeq: stamp.localSeq,
+                refSeq: this.collabWindow.currentSeq,
+                obliterateInfo: obliterate,
+            };
+            obliterate.tiebreakTrackingGroup = new UnorderedTrackingGroup();
             this.pendingSegments.push(obliterate.segmentGroup);
         }
         this.obliterates.addOrUpdate(obliterate);
@@ -1284,6 +1351,7 @@ export class MergeTree {
             // Specifically, we want to avoid marking a local-only segment as obliterated when we know one of our own local obliterates
             // will win against the obliterate we're processing, hence the early exit.
             if (opstampUtils.isLocal(segment.insert) &&
+                isInsideObliterate(segment) &&
                 segment.obliteratePrecedingInsertion?.stamp.seq === UnassignedSequenceNumber &&
                 opstampUtils.isAcked(stamp)) {
                 // We chose to not obliterate this segment because we are aware of an unacked local obliteration.
@@ -1449,6 +1517,10 @@ export class MergeTree {
      * Revert an unacked local op
      */
     rollback(op, localOpMetadata) {
+        const rollbackStamp = {
+            seq: TreeMaintenanceSequenceNumber,
+            clientId: NonCollabClient,
+        };
         if (op.type === MergeTreeDeltaType.REMOVE) {
             const pendingSegmentGroup = this.pendingSegments.pop()?.data;
             if (pendingSegmentGroup === undefined || pendingSegmentGroup !== localOpMetadata) {
@@ -1462,16 +1534,10 @@ export class MergeTree {
                 assert(isRemoved(segment) &&
                     segment.removes[0].clientId === this.collabWindow.clientId &&
                     segment.removes[0].type === "setRemove", 0x39d /* Rollback segment removedClientId does not match local client */);
-                let updateNode = segment.parent;
                 // This also removes obliterates, but that should be ok as we can only remove a segment once.
                 // If we were able to remove it locally, that also means there are no remote removals (since rollback is synchronous).
                 removeRemovalInfo(segment);
-                for (updateNode; updateNode !== undefined; updateNode = updateNode.parent) {
-                    this.blockUpdateLength(updateNode, {
-                        seq: UnassignedSequenceNumber,
-                        clientId: this.collabWindow.clientId,
-                    });
-                }
+                this.blockUpdatePathLengths(segment.parent, rollbackStamp);
                 // Note: optional chaining short-circuits:
                 // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Optional_chaining#short-circuiting
                 this.mergeTreeDeltaCallback?.({
@@ -1499,25 +1565,19 @@ export class MergeTree {
                 if (op.type === MergeTreeDeltaType.INSERT) {
                     segment.insert = {
                         type: "insert",
-                        seq: UniversalSequenceNumber,
-                        clientId: this.collabWindow.clientId,
+                        ...rollbackStamp,
                     };
                     const removeOp = createRemoveRangeOp(start, start + segment.cachedLength);
                     const removeStamp = {
                         type: "setRemove",
-                        seq: UniversalSequenceNumber,
-                        clientId: this.collabWindow.clientId,
+                        ...rollbackStamp,
                     };
                     this.markRangeRemoved(start, start + segment.cachedLength, this.localPerspective, removeStamp, { op: removeOp, rollback: true });
                 } /* op.type === MergeTreeDeltaType.ANNOTATE */
                 else {
                     const props = pendingSegmentGroup.previousProps[i];
                     const annotateOp = createAnnotateRangeOp(start, start + segment.cachedLength, props);
-                    const annotateStamp = {
-                        seq: UniversalSequenceNumber,
-                        clientId: this.collabWindow.clientId,
-                    };
-                    this.annotateRange(start, start + segment.cachedLength, { props }, this.localPerspective, annotateStamp, { op: annotateOp, rollback: true });
+                    this.annotateRange(start, start + segment.cachedLength, { props }, this.localPerspective, rollbackStamp, { op: annotateOp, rollback: true });
                     i++;
                 }
             }
@@ -1578,7 +1638,17 @@ export class MergeTree {
         const segRef = localRefs.createLocalRef(offset, refType, properties, slidingPreference, canSlideToEndpoint);
         return segRef;
     }
-    // Segments should either be removed remotely, removed locally, or inserted locally
+    /**
+     * Segments should either be removed remotely, removed locally, or inserted locally
+     *
+     * See description of {@link normalizeSegmentsOnRebase}.
+     *
+     * This normalizes a block of adjacent segments whose positions have collapsed between the time of the original submission and now
+     * such that removed segments come after ones that still exist.
+     *
+     * TODO:AB#34898: It looks like this method has some bugs, search code for this tag for an example test that demonstrates
+     * segment normalization yielding an order that remote clients wouldn't have seen.
+     */
     normalizeAdjacentSegments(affectedSegments) {
         // Eagerly demand this since we're about to shift elements in the list around
         const currentOrder = Array.from(affectedSegments, ({ data: seg }) => ({
@@ -1713,6 +1783,45 @@ export class MergeTree {
             return true;
         });
         normalize();
+        this.obliterates.onNormalize();
+        const segmentTiebreakChanges = new Set();
+        for (const info of this.obliterates) {
+            if (info.tiebreakTrackingGroup !== undefined) {
+                for (const segment of info.tiebreakTrackingGroup.tracked) {
+                    // Recompute previous obliterate
+                    assert(isSegmentLeaf(segment) &&
+                        isInsideObliterate(segment) &&
+                        segment.insertionRefSeqStamp !== undefined, 0xb74 /* Expected segment leaf inside obliterate with insertionRefSeqStamp */);
+                    // This may have changed as a result of segments shuffling: outstanding local obliterates that previously surrounded a segment may no longer surround it.
+                    const newObliteratePrecedingInsertion = this.computeObliteratePrecedingInsertion(segment, segment.insertionRefSeqStamp);
+                    if (newObliteratePrecedingInsertion !== info) {
+                        segmentTiebreakChanges.add({
+                            segment,
+                            old: info,
+                            new: newObliteratePrecedingInsertion,
+                        });
+                    }
+                }
+            }
+        }
+        for (const { segment, old, new: newInfo } of segmentTiebreakChanges) {
+            // Update tiebreak tracking groups on old/new segment as well as `ISegmentInsideObliterateInfo` state
+            // which we only keep around as long as obliterates are in flight.
+            old.tiebreakTrackingGroup?.unlink(segment);
+            if (newInfo?.tiebreakTrackingGroup === undefined) {
+                // Segment is either no longer inside any obliterate or only inside acked obliterates.
+                overwriteInfo(segment, {
+                    obliteratePrecedingInsertion: newInfo,
+                    insertionRefSeqStamp: undefined,
+                });
+            }
+            else {
+                overwriteInfo(segment, {
+                    obliteratePrecedingInsertion: newInfo,
+                });
+                newInfo.tiebreakTrackingGroup.link(segment);
+            }
+        }
     }
     blockUpdate(block) {
         let len;