@fluidframework/merge-tree 2.12.0 → 2.13.0

package/lib/mergeTree.js

@@ -14,40 +14,19 @@ import {
 LocalReferenceCollection, SlidingPreference, anyLocalReferencePosition, createDetachedLocalReferencePosition, filterLocalReferencePositions, } from "./localReference.js";
 import { MergeTreeMaintenanceType, } from "./mergeTreeDeltaCallback.js";
 import { NodeAction, backwardExcursion, depthFirstNodeWalk, forwardExcursion, walkAllChildSegments, } from "./mergeTreeNodeWalk.js";
-import { 
-// eslint-disable-next-line import/no-deprecated
-CollaborationWindow, Marker, MaxNodesInBlock, MergeBlock, reservedMarkerIdKey, seqLTE, toMoveInfo, toRemovalInfo, } from "./mergeTreeNodes.js";
+import { CollaborationWindow, Marker, MaxNodesInBlock, MergeBlock, assertSegmentLeaf, assignChild, isSegmentLeaf, reservedMarkerIdKey, seqLTE, } from "./mergeTreeNodes.js";
 import { createAnnotateRangeOp, createInsertSegmentOp, createRemoveRangeOp, } from "./opBuilder.js";
 import { MergeTreeDeltaType, ReferenceType, } from "./ops.js";
 import { PartialSequenceLengths } from "./partialLengths.js";
 import { PerspectiveImpl, isSegmentPresent } from "./perspective.js";
 import { createMap, extend, extendIfUndefined } from "./properties.js";
 import { DetachedReferencePosition, refGetTileLabels, refHasTileLabel, refTypeIncludesFlag, } from "./referencePositions.js";
-// eslint-disable-next-line import/no-deprecated
 import { SegmentGroupCollection } from "./segmentGroupCollection.js";
-// eslint-disable-next-line import/no-deprecated
+import { assertMoved, assertRemoved, isMergeNodeInfo, isMoved, isRemoved, overwriteInfo, removeRemovalInfo, toMoveInfo, toRemovalInfo, } from "./segmentInfos.js";
 import { copyPropertiesAndManager, PropertiesManager, PropertiesRollback, } from "./segmentPropertiesManager.js";
 import { Side } from "./sequencePlace.js";
 import { SortedSegmentSet } from "./sortedSegmentSet.js";
 import { zamboniSegments } from "./zamboni.js";
-// eslint-disable-next-line import/no-deprecated
-function markSegmentMoved(seg, moveInfo) {
-    seg.moveDst = moveInfo.moveDst;
-    seg.movedClientIds = [...moveInfo.movedClientIds];
-    seg.movedSeqs = [moveInfo.movedSeq];
-    seg.movedSeq = moveInfo.movedSeq;
-    seg.localMovedSeq = moveInfo.localMovedSeq;
-    seg.wasMovedOnInsert = moveInfo.wasMovedOnInsert;
-}
-// eslint-disable-next-line import/no-deprecated
-function isMoved(segment) {
-    return toMoveInfo(segment) !== undefined;
-}
-// eslint-disable-next-line import/no-deprecated
-function isRemoved(segment) {
-    return toRemovalInfo(segment) !== undefined;
-}
-// eslint-disable-next-line import/no-deprecated
 function isRemovedAndAcked(segment) {
     const removalInfo = toRemovalInfo(segment);
     return removalInfo !== undefined && removalInfo.removedSeq !== UnassignedSequenceNumber;
@@ -91,29 +70,25 @@ function ackSegment(segment, segmentGroup, opArgs) {
             return true;
         }
         case MergeTreeDeltaType.REMOVE: {
-            // eslint-disable-next-line import/no-deprecated
-            const removalInfo = toRemovalInfo(segment);
-            assert(removalInfo !== undefined, 0x046 /* "On remove ack, missing removal info!" */);
+            assertRemoved(segment);
             segment.localRemovedSeq = undefined;
-            if (removalInfo.removedSeq === UnassignedSequenceNumber) {
-                removalInfo.removedSeq = sequenceNumber;
+            if (segment.removedSeq === UnassignedSequenceNumber) {
+                segment.removedSeq = sequenceNumber;
                 return true;
             }
             return false;
         }
         case MergeTreeDeltaType.OBLITERATE:
         case MergeTreeDeltaType.OBLITERATE_SIDED: {
-            // eslint-disable-next-line import/no-deprecated
-            const moveInfo = toMoveInfo(segment);
-            assert(moveInfo !== undefined, 0x86e /* On obliterate ack, missing move info! */);
+            assertMoved(segment);
             const obliterateInfo = segmentGroup.obliterateInfo;
             assert(obliterateInfo !== undefined, 0xa40 /* must have obliterate info */);
             segment.localMovedSeq = obliterateInfo.localSeq = undefined;
-            const seqIdx = moveInfo.movedSeqs.indexOf(UnassignedSequenceNumber);
+            const seqIdx = segment.movedSeqs.indexOf(UnassignedSequenceNumber);
             assert(seqIdx !== -1, 0x86f /* expected movedSeqs to contain unacked seq */);
-            moveInfo.movedSeqs[seqIdx] = sequenceNumber;
-            if (moveInfo.movedSeq === UnassignedSequenceNumber) {
-                moveInfo.movedSeq = sequenceNumber;
+            segment.movedSeqs[seqIdx] = sequenceNumber;
+            if (segment.movedSeq === UnassignedSequenceNumber) {
+                segment.movedSeq = sequenceNumber;
                 return true;
             }
             return false;
@@ -150,7 +125,6 @@ export function findRootMergeBlock(segmentOrNode) {
  * entries for all segments visited during excursion.
  * This can reduce the number of times the tree needs to be scanned if a range containing many
  * SlideOnRemove references is removed.
- * @internal
  */
 function getSlideToSegment(segment, slidingPreference = SlidingPreference.FORWARD, cache, useNewSlidingBehavior = false) {
     if (!segment ||
@@ -170,7 +144,8 @@ function getSlideToSegment(segment, slidingPreference = SlidingPreference.FORWAR
             return false;
         }
         if (cache !== undefined &&
-            (seg.removedSeq === segment.removedSeq || seg.movedSeq === segment.movedSeq)) {
+            (toRemovalInfo(seg)?.removedSeq === toRemovalInfo(segment)?.removedSeq ||
+                toMoveInfo(seg)?.movedSeq === toMoveInfo(segment)?.movedSeq)) {
             cache.set(seg, result);
         }
         return true;
@@ -217,7 +192,7 @@ function getSlideToSegment(segment, slidingPreference = SlidingPreference.FORWAR
  * @internal
  */
 export function getSlideToSegoff(segoff, slidingPreference = SlidingPreference.FORWARD, useNewSlidingBehavior = false) {
-    if (segoff.segment === undefined) {
+    if (!isSegmentLeaf(segoff.segment)) {
         return segoff;
     }
     const [segment, _] = getSlideToSegment(segoff.segment, slidingPreference, undefined, useNewSlidingBehavior);
@@ -244,7 +219,6 @@ class Obliterates {
          * See https://github.com/microsoft/FluidFramework/blob/main/packages/dds/merge-tree/docs/Obliterate.md#remote-perspective
          * for additional context
          */
-        // eslint-disable-next-line import/no-deprecated
         this.seqOrdered = new DoublyLinkedList();
         /**
          * This contains a sorted lists of all obliterate starts
@@ -262,7 +236,6 @@ class Obliterates {
             this.mergeTree.removeLocalReferencePosition(ob.data.end);
         }
     }
-    // eslint-disable-next-line import/no-deprecated
     addOrUpdate(obliterateInfo) {
         const { seq, start } = obliterateInfo;
         if (seq !== UnassignedSequenceNumber) {
@@ -273,14 +246,14 @@ class Obliterates {
     empty() {
         return this.startOrdered.size === 0;
     }
-    // eslint-disable-next-line import/no-deprecated
     findOverlapping(seg) {
-        // eslint-disable-next-line import/no-deprecated
         const overlapping = [];
         for (const start of this.startOrdered.items) {
-            if (start.getSegment().ordinal <= seg.ordinal) {
+            const startSeg = start.getSegment();
+            if (isMergeNodeInfo(startSeg) && startSeg.ordinal <= seg.ordinal) {
                 const ob = start.properties?.obliterate;
-                if (ob.end.getSegment().ordinal >= seg.ordinal) {
+                const endSeg = ob.end.getSegment();
+                if (isMergeNodeInfo(endSeg) && endSeg.ordinal >= seg.ordinal) {
                     overlapping.push(ob);
                 }
             }
@@ -298,9 +271,7 @@ class Obliterates {
 export class MergeTree {
     constructor(options) {
         this.options = options;
-        // eslint-disable-next-line import/no-deprecated
         this.collabWindow = new CollaborationWindow();
-        // eslint-disable-next-line import/no-deprecated
         this.pendingSegments = new DoublyLinkedList();
         this.segmentsToScour = new Heap(LRUSegmentComparer);
         /**
@@ -318,6 +289,7 @@ export class MergeTree {
                 return {};
             }
             const next = segment.splitAt(pos);
+            assertSegmentLeaf(next);
             if (segment?.segmentGroups) {
                 next.segmentGroups ?? (next.segmentGroups = new SegmentGroupCollection(next));
                 segment.segmentGroups.copyTo(next.segmentGroups);
@@ -380,7 +352,9 @@ export class MergeTree {
         }
         assert(refSeq !== undefined, 0x398 /* localSeq provided for local length without refSeq */);
         assert(segment.seq !== undefined, 0x399 /* segment with no seq in mergeTree */);
-        const { seq, removedSeq, localRemovedSeq, movedSeq, localMovedSeq } = segment;
+        const { seq } = segment;
+        const { removedSeq, localRemovedSeq } = removalInfo ?? {};
+        const { movedSeq, localMovedSeq } = moveInfo ?? {};
         if (seq === UnassignedSequenceNumber) {
             assert(segment.localSeq !== undefined, 0x39a /* unacked segment with undefined localSeq */);
             // inserted locally, still un-acked
@@ -416,7 +390,7 @@ export class MergeTree {
     }
     addNode(block, node) {
         const index = block.childCount++;
-        block.assignChild(node, index, false);
+        assignChild(block, node, index, false);
         return index;
     }
     reloadFromSegments(segments) {
@@ -510,12 +484,12 @@ export class MergeTree {
         assert(localSeq === undefined || clientId === this.collabWindow.clientId, 0x39b /* localSeq provided for non-local client */);
         let segment;
         let offset;
-        const leaf = (leafSeg, segpos, _refSeq, _clientId, start) => {
+        const leaf = (leafSeg, _, start) => {
             segment = leafSeg;
             offset = start;
             return false;
         };
-        this.nodeMap(refSeq, clientId, leaf, undefined, undefined, pos, pos + 1, localSeq);
+        this.nodeMap(refSeq, clientId, leaf, undefined, pos, pos + 1, localSeq);
         return { segment, offset };
     }
     /**
@@ -650,7 +624,6 @@ export class MergeTree {
         if (this.localPartialsComputed) {
             return;
         }
-        // eslint-disable-next-line import/no-deprecated
         const rebaseCollabWindow = new CollaborationWindow();
         rebaseCollabWindow.loadFrom(this.collabWindow);
         if (refSeq < this.collabWindow.minSeq) {
@@ -734,24 +707,26 @@ export class MergeTree {
      */
     referencePositionToLocalPosition(refPos, refSeq = Number.MAX_SAFE_INTEGER, clientId = this.collabWindow.clientId, localSeq = this.collabWindow.localSeq) {
         const seg = refPos.getSegment();
-        if (seg?.parent === undefined) {
+        if (!isSegmentLeaf(seg)) {
             // We have no idea where this reference is, because it refers to a segment which is not in the tree.
             return DetachedReferencePosition;
         }
         if (refPos.isLeaf()) {
-            return this.getPosition(refPos, refSeq, clientId, localSeq);
+            return this.getPosition(seg, refSeq, clientId, localSeq);
         }
         if (refTypeIncludesFlag(refPos, ReferenceType.Transient) || seg.localRefs?.has(refPos)) {
             if (seg !== this.startOfTree &&
                 seg !== this.endOfTree &&
                 !isSegmentPresent(seg, { refSeq, localSeq })) {
                 const forward = refPos.slidingPreference === SlidingPreference.FORWARD;
-                const slideSeq = seg.movedSeq !== UnassignedSequenceNumber && seg.movedSeq !== undefined
-                    ? seg.movedSeq
-                    : seg.removedSeq !== UnassignedSequenceNumber && seg.removedSeq !== undefined
-                        ? seg.removedSeq
+                const moveInfo = toMoveInfo(seg);
+                const removeInfo = toRemovalInfo(seg);
+                const slideSeq = moveInfo !== undefined && moveInfo.movedSeq !== UnassignedSequenceNumber
+                    ? moveInfo.movedSeq
+                    : removeInfo !== undefined && removeInfo.removedSeq !== UnassignedSequenceNumber
+                        ? removeInfo.removedSeq
                         : refSeq;
-                const slideLocalSeq = seg.localMovedSeq ?? seg.localRemovedSeq;
+                const slideLocalSeq = moveInfo?.localMovedSeq ?? removeInfo?.localRemovedSeq;
                 const perspective = new PerspectiveImpl(this, {
                     refSeq: slideSeq,
                     localSeq: slideLocalSeq,
@@ -779,11 +754,10 @@ export class MergeTree {
     searchForMarker(startPos, clientId, markerLabel, forwards = true) {
         let foundMarker;
         const { segment } = this.getContainingSegment(startPos, UniversalSequenceNumber, clientId);
-        const segWithParent = segment;
-        if (segWithParent?.parent === undefined) {
+        if (!isSegmentLeaf(segment)) {
             return undefined;
         }
-        depthFirstNodeWalk(segWithParent.parent, segWithParent, (node) => {
+        depthFirstNodeWalk(segment.parent, segment, (node) => {
             if (node.isLeaf()) {
                 if (Marker.is(node) && refHasTileLabel(node, markerLabel)) {
                     foundMarker = node;
@@ -805,8 +779,8 @@ export class MergeTree {
     updateRoot(splitNode) {
         if (splitNode !== undefined) {
             const newRoot = this.makeBlock(2);
-            newRoot.assignChild(this.root, 0, false);
-            newRoot.assignChild(splitNode, 1, false);
+            assignChild(newRoot, this.root, 0, false);
+            assignChild(newRoot, splitNode, 1, false);
             this.root = newRoot;
             this.nodeUpdateOrdinals(this.root);
             this.nodeUpdateLengthNewStructure(this.root);
@@ -862,9 +836,7 @@ export class MergeTree {
             zamboniSegments(this);
         }
     }
-    addToPendingList(segment, 
-    // eslint-disable-next-line import/no-deprecated
-    segmentGroup, localSeq, previousProps) {
+    addToPendingList(segment, segmentGroup, localSeq, previousProps) {
         let _segmentGroup = segmentGroup;
         if (_segmentGroup === undefined) {
             _segmentGroup = {
@@ -884,7 +856,6 @@ export class MergeTree {
         if (previousProps) {
             _segmentGroup.previousProps.push(previousProps);
         }
-        // eslint-disable-next-line import/no-deprecated
         const segmentGroups = (segment.segmentGroups ?? (segment.segmentGroups = new SegmentGroupCollection(segment)));
         segmentGroups.enqueue(_segmentGroup);
         return _segmentGroup;
@@ -911,7 +882,7 @@ export class MergeTree {
         if (relativePos.id) {
             marker = this.getMarkerFromId(relativePos.id);
         }
-        if (marker) {
+        if (isSegmentLeaf(marker)) {
             pos = this.getPosition(marker, refseq, clientId);
             if (relativePos.before) {
                 if (relativePos.offset !== undefined) {
@@ -969,7 +940,7 @@ export class MergeTree {
         }
         const segmentInfo = this.getContainingSegment(remoteClientPosition, remoteClientRefSeq, remoteClientId);
         const { currentSeq, clientId } = this.collabWindow;
-        if (segmentInfo?.segment) {
+        if (isSegmentLeaf(segmentInfo?.segment)) {
             const segmentPosition = this.getPosition(segmentInfo.segment, currentSeq, clientId);
             return segmentPosition + segmentInfo.offset;
         }
@@ -990,7 +961,6 @@ export class MergeTree {
             });
             return siblingExists;
         };
-        // eslint-disable-next-line import/no-deprecated
         let segmentGroup;
         const saveIfLocal = (locSegment) => {
             // Save segment so we can assign sequence number when acked by server
@@ -1020,93 +990,95 @@ export class MergeTree {
             }
             return segmentChanges;
         };
+        const insertInfo = {
+            clientId,
+            seq,
+            localSeq,
+        };
         // TODO: build tree from segs and insert all at once
         let insertPos = pos;
-        for (const newSegment of newSegments) {
-            if (newSegment.cachedLength > 0) {
-                newSegment.seq = seq;
-                newSegment.localSeq = localSeq;
-                newSegment.clientId = clientId;
-                if (Marker.is(newSegment)) {
-                    const markerId = newSegment.getId();
-                    if (markerId) {
-                        this.idToMarker.set(markerId, newSegment);
-                    }
+        for (const newSegment of newSegments
+            .filter((s) => s.cachedLength > 0)
+            .map((s) => overwriteInfo(s, insertInfo))) {
+            if (Marker.is(newSegment)) {
+                const markerId = newSegment.getId();
+                if (markerId) {
+                    this.idToMarker.set(markerId, newSegment);
                 }
-                const splitNode = this.insertingWalk(this.root, insertPos, refSeq, clientId, seq, {
-                    leaf: onLeaf,
-                    candidateSegment: newSegment,
-                    continuePredicate: continueFrom,
+            }
+            const splitNode = this.insertingWalk(this.root, insertPos, refSeq, clientId, seq, {
+                leaf: onLeaf,
+                candidateSegment: newSegment,
+                continuePredicate: continueFrom,
+            });
+            if (!isSegmentLeaf(newSegment)) {
+                // Indicates an attempt to insert past the end of the merge-tree's content.
+                const errorConstructor = localSeq === undefined ? DataProcessingError : UsageError;
+                throw new errorConstructor("MergeTree insert failed", {
+                    currentSeq: this.collabWindow.currentSeq,
+                    minSeq: this.collabWindow.minSeq,
+                    segSeq: insertInfo.seq,
                 });
-                if (newSegment.parent === undefined) {
-                    // Indicates an attempt to insert past the end of the merge-tree's content.
-                    const errorConstructor = localSeq === undefined ? DataProcessingError : UsageError;
-                    throw new errorConstructor("MergeTree insert failed", {
-                        currentSeq: this.collabWindow.currentSeq,
-                        minSeq: this.collabWindow.minSeq,
-                        segSeq: newSegment.seq,
-                    });
-                }
-                this.updateRoot(splitNode);
-                insertPos += newSegment.cachedLength;
-                if (!this.options?.mergeTreeEnableObliterate || this.obliterates.empty()) {
-                    saveIfLocal(newSegment);
-                    continue;
-                }
-                let oldest;
-                let normalizedOldestSeq = 0;
-                let newest;
-                let normalizedNewestSeq = 0;
-                const movedClientIds = [];
-                const movedSeqs = [];
-                for (const ob of this.obliterates.findOverlapping(newSegment)) {
-                    // compute a normalized seq that takes into account local seqs
-                    // but is still comparable to remote seqs to keep the checks below easy
-                    // REMOTE SEQUENCE NUMBERS                                     LOCAL SEQUENCE NUMBERS
-                    // [0, 1, 2, 3, ..., 100, ..., 1000, ..., (MAX - MaxLocalSeq), L1, L2, L3, L4, ..., L100, ..., L1000, ...(MAX)]
-                    const normalizedObSeq = ob.seq === UnassignedSequenceNumber
-                        ? Number.MAX_SAFE_INTEGER - this.collabWindow.localSeq + ob.localSeq
-                        : ob.seq;
-                    if (normalizedObSeq > refSeq) {
-                        if (oldest === undefined || normalizedOldestSeq > normalizedObSeq) {
-                            normalizedOldestSeq = normalizedObSeq;
-                            oldest = ob;
-                            movedClientIds.unshift(ob.clientId);
-                            movedSeqs.unshift(ob.seq);
-                        }
-                        else {
-                            movedClientIds.push(ob.clientId);
-                            movedSeqs.push(ob.seq);
-                        }
-                        if (newest === undefined || normalizedNewestSeq < normalizedObSeq) {
-                            normalizedNewestSeq = normalizedObSeq;
-                            newest = ob;
-                        }
+            }
+            this.updateRoot(splitNode);
+            insertPos += newSegment.cachedLength;
+            if (!this.options?.mergeTreeEnableObliterate || this.obliterates.empty()) {
+                saveIfLocal(newSegment);
+                continue;
+            }
+            let oldest;
+            let normalizedOldestSeq = 0;
+            let newest;
+            let normalizedNewestSeq = 0;
+            const movedClientIds = [];
+            const movedSeqs = [];
+            for (const ob of this.obliterates.findOverlapping(newSegment)) {
+                // compute a normalized seq that takes into account local seqs
+                // but is still comparable to remote seqs to keep the checks below easy
+                // REMOTE SEQUENCE NUMBERS                                     LOCAL SEQUENCE NUMBERS
+                // [0, 1, 2, 3, ..., 100, ..., 1000, ..., (MAX - MaxLocalSeq), L1, L2, L3, L4, ..., L100, ..., L1000, ...(MAX)]
+                const normalizedObSeq = ob.seq === UnassignedSequenceNumber
+                    ? Number.MAX_SAFE_INTEGER - this.collabWindow.localSeq + ob.localSeq
+                    : ob.seq;
+                if (normalizedObSeq > refSeq) {
+                    if (oldest === undefined || normalizedOldestSeq > normalizedObSeq) {
+                        normalizedOldestSeq = normalizedObSeq;
+                        oldest = ob;
+                        movedClientIds.unshift(ob.clientId);
+                        movedSeqs.unshift(ob.seq);
                     }
-                }
-                if (oldest && newest?.clientId !== clientId) {
-                    // eslint-disable-next-line import/no-deprecated
-                    const moveInfo = {
-                        movedClientIds,
-                        movedSeq: oldest.seq,
-                        movedSeqs,
-                        localMovedSeq: oldest.localSeq,
-                        wasMovedOnInsert: oldest.seq !== UnassignedSequenceNumber,
-                    };
-                    markSegmentMoved(newSegment, moveInfo);
-                    if (moveInfo.localMovedSeq !== undefined) {
-                        assert(oldest.segmentGroup !== undefined, 0x86c /* expected segment group to exist */);
-                        this.addToPendingList(newSegment, oldest.segmentGroup);
+                    else {
+                        movedClientIds.push(ob.clientId);
+                        movedSeqs.push(ob.seq);
                     }
-                    if (newSegment.parent) {
-                        this.blockUpdatePathLengths(newSegment.parent, seq, clientId);
+                    if (newest === undefined || normalizedNewestSeq < normalizedObSeq) {
+                        normalizedNewestSeq = normalizedObSeq;
+                        newest = ob;
                     }
                 }
-                else if (oldest && newest?.clientId === clientId) {
-                    newSegment.prevObliterateByInserter = newest;
+            }
+            if (oldest && newest?.clientId !== clientId) {
+                // eslint-disable-next-line import/no-deprecated
+                const moveInfo = {
+                    movedClientIds,
+                    movedSeq: oldest.seq,
+                    movedSeqs,
+                    localMovedSeq: oldest.localSeq,
+                    wasMovedOnInsert: oldest.seq !== UnassignedSequenceNumber,
+                };
+                overwriteInfo(newSegment, moveInfo);
+                if (moveInfo.localMovedSeq !== undefined) {
+                    assert(oldest.segmentGroup !== undefined, 0x86c /* expected segment group to exist */);
+                    this.addToPendingList(newSegment, oldest.segmentGroup);
                 }
-                saveIfLocal(newSegment);
+                if (newSegment.parent) {
+                    this.blockUpdatePathLengths(newSegment.parent, seq, clientId);
+                }
+            }
+            else if (oldest && newest?.clientId === clientId) {
+                newSegment.prevObliterateByInserter = newest;
             }
+            saveIfLocal(newSegment);
         }
     }
     ensureIntervalBoundary(pos, refSeq, clientId) {
@@ -1127,10 +1099,8 @@ export class MergeTree {
             const newSeq = seq === UnassignedSequenceNumber ? Number.MAX_SAFE_INTEGER : seq;
             const segSeq = node.seq === UnassignedSequenceNumber ? Number.MAX_SAFE_INTEGER - 1 : (node.seq ?? 0);
             return (newSeq > segSeq ||
-                (node.movedSeq !== undefined &&
-                    node.movedSeq !== UnassignedSequenceNumber &&
-                    node.movedSeq > seq) ||
-                (node.removedSeq !== undefined &&
+                (isMoved(node) && node.movedSeq !== UnassignedSequenceNumber && node.movedSeq > seq) ||
+                (isRemoved(node) &&
                     node.removedSeq !== UnassignedSequenceNumber &&
                     node.removedSeq > seq));
         }
@@ -1162,7 +1132,7 @@ export class MergeTree {
                     const segment = child;
                     const segmentChanges = context.leaf(segment, _pos, context);
                     if (segmentChanges.replaceCurrent) {
-                        block.assignChild(segmentChanges.replaceCurrent, childIndex, false);
+                        assignChild(block, segmentChanges.replaceCurrent, childIndex, false);
                         segmentChanges.replaceCurrent.ordinal = child.ordinal;
                     }
                     if (segmentChanges.next) {
@@ -1213,7 +1183,7 @@ export class MergeTree {
                 block.children[i] = block.children[i - 1];
                 block.children[i].index = i;
             }
-            block.assignChild(newNode, childIndex, false);
+            assignChild(block, newNode, childIndex, false);
             block.childCount++;
             block.setOrdinal(newNode, childIndex);
             if (block.childCount < MaxNodesInBlock) {
@@ -1242,7 +1212,7 @@ export class MergeTree {
         // Update ordinals to reflect lowered child count
         this.nodeUpdateOrdinals(node);
         for (let i = 0; i < halfCount; i++) {
-            newNode.assignChild(node.children[halfCount + i], i, false);
+            assignChild(newNode, node.children[halfCount + i], i, false);
             node.children[halfCount + i] = undefined;
         }
         this.nodeUpdateLengthNewStructure(node);
@@ -1269,9 +1239,7 @@ export class MergeTree {
      * @param opArgs - The op args for the annotate op. this is passed to the merge tree callback if there is one
      * @param rollback - Whether this is for a local rollback and what kind
      */
-    annotateRange(start, end, propsOrAdjust, refSeq, clientId, seq, opArgs, 
-    // eslint-disable-next-line import/no-deprecated
-    rollback = PropertiesRollback.None) {
+    annotateRange(start, end, propsOrAdjust, refSeq, clientId, seq, opArgs, rollback = PropertiesRollback.None) {
         if (propsOrAdjust.adjust !== undefined) {
             errorIfOptionNotTrue(this.options, "mergeTreeEnableAnnotateAdjust");
         }
@@ -1279,7 +1247,6 @@ export class MergeTree {
         this.ensureIntervalBoundary(end, refSeq, clientId);
         const deltaSegments = [];
         const localSeq = seq === UnassignedSequenceNumber ? ++this.collabWindow.localSeq : undefined;
-        // eslint-disable-next-line import/no-deprecated
         let segmentGroup;
         const opObj = propsOrAdjust.props ?? propsOrAdjust.adjust;
         const annotateSegment = (segment) => {
@@ -1303,7 +1270,7 @@ export class MergeTree {
             }
             return true;
         };
-        this.nodeMap(refSeq, clientId, annotateSegment, undefined, undefined, start, end);
+        this.nodeMap(refSeq, clientId, annotateSegment, undefined, start, end);
         // OpArgs == undefined => test code
         if (deltaSegments.length > 0) {
             this.mergeTreeDeltaCallback?.(opArgs, {
@@ -1324,9 +1291,9 @@ export class MergeTree {
         this.ensureIntervalBoundary(endPos, refSeq, clientId);
         let _overwrite = false;
         const localOverlapWithRefs = [];
+        // eslint-disable-next-line import/no-deprecated
         const movedSegments = [];
         const localSeq = seq === UnassignedSequenceNumber ? ++this.collabWindow.localSeq : undefined;
-        // eslint-disable-next-line import/no-deprecated
         const obliterate = {
             clientId,
             end: createDetachedLocalReferencePosition(undefined),
@@ -1338,7 +1305,7 @@ export class MergeTree {
         };
         const { segment: startSeg } = this.getContainingSegment(start.pos, refSeq, clientId);
         const { segment: endSeg } = this.getContainingSegment(end.pos, refSeq, clientId);
-        assert(startSeg !== undefined && endSeg !== undefined, 0xa3f /* segments cannot be undefined */);
+        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,
         });
@@ -1359,7 +1326,7 @@ export class MergeTree {
             this.pendingSegments.push(obliterate.segmentGroup);
         }
         this.obliterates.addOrUpdate(obliterate);
-        const markMoved = (segment, pos, _start, _end) => {
+        const markMoved = (segment, pos) => {
             if ((start.side === Side.After && startPos === pos + segment.cachedLength) || // exclusive start segment
                 (end.side === Side.Before &&
                     endPos === pos &&
@@ -1376,23 +1343,27 @@ export class MergeTree {
                 // Other clients will also choose not to obliterate this segment because the most recent obliteration has the same clientId
                 return true;
             }
-            if (clientId !== segment.clientId &&
+            const wasMovedOnInsert = clientId !== segment.clientId &&
                 segment.seq !== undefined &&
                 seq !== UnassignedSequenceNumber &&
-                (refSeq < segment.seq || segment.seq === UnassignedSequenceNumber)) {
-                segment.wasMovedOnInsert = true;
-            }
+                (refSeq < segment.seq || segment.seq === UnassignedSequenceNumber);
             if (existingMoveInfo === undefined) {
-                segment.movedClientIds = [clientId];
-                segment.movedSeq = seq;
-                segment.localMovedSeq = localSeq;
-                segment.movedSeqs = [seq];
-                if (!toRemovalInfo(segment)) {
-                    movedSegments.push({ segment });
+                // eslint-disable-next-line import/no-deprecated
+                const movedSeg = overwriteInfo(segment, {
+                    movedClientIds: [clientId],
+                    movedSeq: seq,
+                    localMovedSeq: localSeq,
+                    movedSeqs: [seq],
+                    wasMovedOnInsert,
+                });
+                if (!toRemovalInfo(movedSeg)) {
+                    movedSegments.push(movedSeg);
                 }
             }
             else {
                 _overwrite = true;
+                // never move wasMovedOnInsert from true to false
+                existingMoveInfo.wasMovedOnInsert || (existingMoveInfo.wasMovedOnInsert = wasMovedOnInsert);
                 if (existingMoveInfo.movedSeq === UnassignedSequenceNumber) {
                     // we moved this locally, but someone else moved it first
                     // so put them at the head of the list
@@ -1411,6 +1382,7 @@ export class MergeTree {
                     existingMoveInfo.movedSeqs.push(seq);
                 }
             }
+            assertMoved(segment);
             // Save segment so can assign moved sequence number when acked by server
             if (this.collabWindow.collaborating) {
                 if (segment.movedSeq === UnassignedSequenceNumber &&
@@ -1425,7 +1397,7 @@ export class MergeTree {
             }
             return true;
         };
-        const afterMarkMoved = (node, pos, _start, _end) => {
+        const afterMarkMoved = (node) => {
             if (_overwrite) {
                 this.nodeUpdateLengthNewStructure(node);
             }
@@ -1434,21 +1406,21 @@ export class MergeTree {
             }
             return true;
         };
-        this.nodeMap(refSeq, clientId, markMoved, undefined, afterMarkMoved, start.pos, end.pos + 1, // include the segment containing the end reference
+        this.nodeMap(refSeq, clientId, markMoved, afterMarkMoved, start.pos, end.pos + 1, // include the segment containing the end reference
         undefined, seq === UnassignedSequenceNumber ? undefined : seq);
         this.slideAckedRemovedSegmentReferences(localOverlapWithRefs);
         // opArgs == undefined => test code
         if (start.pos !== end.pos || start.side !== end.side) {
             this.mergeTreeDeltaCallback?.(opArgs, {
                 operation: MergeTreeDeltaType.OBLITERATE,
-                deltaSegments: movedSegments,
+                deltaSegments: movedSegments.map((segment) => ({ segment })),
             });
         }
         // these events are newly removed
         // so we slide after eventing in case the consumer wants to make reference
         // changes at remove time, like add a ref to track undo redo.
         if (!this.collabWindow.collaborating || clientId !== this.collabWindow.clientId) {
-            this.slideAckedRemovedSegmentReferences(movedSegments.map(({ segment }) => segment));
+            this.slideAckedRemovedSegmentReferences(movedSegments);
         }
         if (this.collabWindow.collaborating &&
             seq !== UnassignedSequenceNumber &&
@@ -1471,19 +1443,22 @@ export class MergeTree {
         let _overwrite = false;
         this.ensureIntervalBoundary(start, refSeq, clientId);
         this.ensureIntervalBoundary(end, refSeq, clientId);
-        // eslint-disable-next-line import/no-deprecated
         let segmentGroup;
+        // eslint-disable-next-line import/no-deprecated
         const removedSegments = [];
         const localOverlapWithRefs = [];
         const localSeq = seq === UnassignedSequenceNumber ? ++this.collabWindow.localSeq : undefined;
         const markRemoved = (segment, pos, _start, _end) => {
             const existingRemovalInfo = toRemovalInfo(segment);
             if (existingRemovalInfo === undefined) {
-                segment.removedClientIds = [clientId];
-                segment.removedSeq = seq;
-                segment.localRemovedSeq = localSeq;
-                if (!toMoveInfo(segment)) {
-                    removedSegments.push({ segment });
+                // eslint-disable-next-line import/no-deprecated
+                const removed = overwriteInfo(segment, {
+                    removedClientIds: [clientId],
+                    removedSeq: seq,
+                    localRemovedSeq: localSeq,
+                });
+                if (!toMoveInfo(removed)) {
+                    removedSegments.push(removed);
                 }
             }
             else {
@@ -1504,6 +1479,7 @@ export class MergeTree {
                     existingRemovalInfo.removedClientIds.push(clientId);
                 }
             }
+            assertRemoved(segment);
             // Save segment so we can assign removed sequence number when acked by server
             if (this.collabWindow.collaborating) {
                 if (segment.removedSeq === UnassignedSequenceNumber &&
@@ -1518,7 +1494,7 @@ export class MergeTree {
             }
             return true;
         };
-        const afterMarkRemoved = (node, pos, _start, _end) => {
+        const afterMarkRemoved = (node) => {
             if (_overwrite) {
                 this.nodeUpdateLengthNewStructure(node);
             }
@@ -1527,7 +1503,7 @@ export class MergeTree {
             }
             return true;
         };
-        this.nodeMap(refSeq, clientId, markRemoved, undefined, afterMarkRemoved, start, end);
+        this.nodeMap(refSeq, clientId, markRemoved, afterMarkRemoved, start, end);
         // these segments are already viewed as being removed locally and are not event-ed
         // so can slide non-StayOnRemove refs immediately
         this.slideAckedRemovedSegmentReferences(localOverlapWithRefs);
@@ -1535,14 +1511,14 @@ export class MergeTree {
         if (removedSegments.length > 0) {
             this.mergeTreeDeltaCallback?.(opArgs, {
                 operation: MergeTreeDeltaType.REMOVE,
-                deltaSegments: removedSegments,
+                deltaSegments: removedSegments.map((segment) => ({ segment })),
             });
         }
         // these events are newly removed
         // so we slide after eventing in case the consumer wants to make reference
         // changes at remove time, like add a ref to track undo redo.
         if (!this.collabWindow.collaborating || clientId !== this.collabWindow.clientId) {
-            this.slideAckedRemovedSegmentReferences(removedSegments.map(({ segment }) => segment));
+            this.slideAckedRemovedSegmentReferences(removedSegments);
         }
         if (this.collabWindow.collaborating &&
             seq !== UnassignedSequenceNumber &&
@@ -1553,24 +1529,21 @@ export class MergeTree {
     /**
      * Revert an unacked local op
      */
-    // eslint-disable-next-line import/no-deprecated
     rollback(op, localOpMetadata) {
         if (op.type === MergeTreeDeltaType.REMOVE) {
-            const pendingSegmentGroup = this.pendingSegments.pop?.()?.data;
+            const pendingSegmentGroup = this.pendingSegments.pop()?.data;
             if (pendingSegmentGroup === undefined || pendingSegmentGroup !== localOpMetadata) {
                 throw new Error("Rollback op doesn't match last edit");
             }
             // Disabling because a for of loop causes the type of segment to be ISegmentLeaf, which does not have parent information stored
             // eslint-disable-next-line unicorn/no-array-for-each
             pendingSegmentGroup.segments.forEach((segment) => {
-                const segmentSegmentGroup = segment?.segmentGroups?.pop?.();
+                const segmentSegmentGroup = segment?.segmentGroups?.pop();
                 assert(segmentSegmentGroup === pendingSegmentGroup, 0x3ee /* Unexpected segmentGroup in segment */);
-                assert(segment.removedClientIds !== undefined &&
-                    segment.removedClientIds[0] === this.collabWindow.clientId, 0x39d /* Rollback segment removedClientId does not match local client */);
-                segment.removedClientIds = undefined;
-                segment.removedSeq = undefined;
-                segment.localRemovedSeq = undefined;
-                for (let updateNode = segment.parent; updateNode !== undefined; updateNode = updateNode.parent) {
+                assert(isRemoved(segment) && segment.removedClientIds[0] === this.collabWindow.clientId, 0x39d /* Rollback segment removedClientId does not match local client */);
+                let updateNode = segment.parent;
+                removeRemovalInfo(segment);
+                for (updateNode; updateNode !== undefined; updateNode = updateNode.parent) {
                     this.blockUpdateLength(updateNode, UnassignedSequenceNumber, this.collabWindow.clientId);
                 }
                 // Note: optional chaining short-circuits:
@@ -1583,7 +1556,7 @@ export class MergeTree {
         }
         else if (op.type === MergeTreeDeltaType.INSERT ||
             op.type === MergeTreeDeltaType.ANNOTATE) {
-            const pendingSegmentGroup = this.pendingSegments.pop?.()?.data;
+            const pendingSegmentGroup = this.pendingSegments.pop()?.data;
             if (pendingSegmentGroup === undefined ||
                 pendingSegmentGroup !== localOpMetadata ||
                 (op.type === MergeTreeDeltaType.ANNOTATE && !pendingSegmentGroup.previousProps)) {
@@ -1591,7 +1564,7 @@ export class MergeTree {
             }
             let i = 0;
             for (const segment of pendingSegmentGroup.segments) {
-                const segmentSegmentGroup = segment?.segmentGroups?.pop?.();
+                const segmentSegmentGroup = segment?.segmentGroups?.pop();
                 assert(segmentSegmentGroup === pendingSegmentGroup, 0x3ef /* Unexpected segmentGroup in segment */);
                 const start = this.findRollbackPosition(segment);
                 if (op.type === MergeTreeDeltaType.INSERT) {
@@ -1623,7 +1596,7 @@ export class MergeTree {
                 return false;
             }
             // If not removed, increase position
-            if (seg.removedSeq === undefined) {
+            if (!isRemoved(seg)) {
                 segmentPosition += seg.cachedLength;
             }
             return true;
@@ -1657,6 +1630,7 @@ export class MergeTree {
             segment = this.endOfTree;
         }
         else {
+            assertSegmentLeaf(_segment);
             segment = _segment;
         }
         // eslint-disable-next-line import/no-deprecated
@@ -1721,7 +1695,7 @@ export class MergeTree {
         for (let i = 0; i < newOrder.length; i++) {
             const seg = newOrder[i];
             const { parent, index, ordinal } = currentOrder[i];
-            parent?.assignChild(seg, index, false);
+            assignChild(parent, seg, index, false);
             seg.ordinal = ordinal;
         }
         for (const [segment, groups] of perSegmentTrackingGroups.entries()) {
@@ -1888,7 +1862,7 @@ export class MergeTree {
                 this.ensureIntervalBoundary(end, refSeq, clientId);
             }
         }
-        this.nodeMap(refSeq, clientId, handler, accum, undefined, start, end, undefined, visibilitySeq);
+        this.nodeMap(refSeq, clientId, (seg, pos, _start, _end) => handler(seg, pos, refSeq, clientId, _start, _end, accum), undefined, start, end, undefined, visibilitySeq);
     }
     /**
      * Map over all visible segments in a given range
@@ -1913,7 +1887,7 @@ export class MergeTree {
      * but it will not count as a segment within the range. That is, it will be
      * ignored for the purposes of tracking when traversal should end.
      */
-    nodeMap(refSeq, clientId, leaf, accum, post, start = 0, end, localSeq, visibilitySeq = refSeq) {
+    nodeMap(refSeq, clientId, leaf, post, start = 0, end, localSeq, visibilitySeq = refSeq) {
         const endPos = end ?? this.nodeLength(this.root, refSeq, clientId, localSeq) ?? 0;
         if (endPos === start) {
             return;
@@ -1940,14 +1914,12 @@ export class MergeTree {
                 return NodeAction.Skip;
             }
             if (node.isLeaf()) {
-                if (leaf(node, pos, refSeq, clientId, start - pos, endPos - pos, accum) === false) {
+                if (leaf(node, pos, start - pos, endPos - pos) === false) {
                     return NodeAction.Exit;
                 }
                 pos = nextPos;
             }
-        }, undefined, post === undefined
-            ? undefined
-            : (block) => post(block, pos, refSeq, clientId, start - pos, endPos - pos, accum));
+        }, undefined, post);
     }
 }
 MergeTree.options = {