@fluidframework/merge-tree 2.11.0 → 2.13.0

package/dist/mergeTree.js

@@ -22,40 +22,26 @@ const partialLengths_js_1 = require("./partialLengths.js");
 const perspective_js_1 = require("./perspective.js");
 const properties_js_1 = require("./properties.js");
 const referencePositions_js_1 = require("./referencePositions.js");
-// eslint-disable-next-line import/no-deprecated
 const segmentGroupCollection_js_1 = require("./segmentGroupCollection.js");
-// eslint-disable-next-line import/no-deprecated
+const segmentInfos_js_1 = require("./segmentInfos.js");
 const segmentPropertiesManager_js_1 = require("./segmentPropertiesManager.js");
 const sequencePlace_js_1 = require("./sequencePlace.js");
 const sortedSegmentSet_js_1 = require("./sortedSegmentSet.js");
 const zamboni_js_1 = require("./zamboni.js");
-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;
-}
-function isMoved(segment) {
-    return (0, mergeTreeNodes_js_1.toMoveInfo)(segment) !== undefined;
-}
-function isRemoved(segment) {
-    return (0, mergeTreeNodes_js_1.toRemovalInfo)(segment) !== undefined;
-}
 function isRemovedAndAcked(segment) {
-    const removalInfo = (0, mergeTreeNodes_js_1.toRemovalInfo)(segment);
+    const removalInfo = (0, segmentInfos_js_1.toRemovalInfo)(segment);
     return removalInfo !== undefined && removalInfo.removedSeq !== constants_js_1.UnassignedSequenceNumber;
 }
+// eslint-disable-next-line import/no-deprecated
 function isMovedAndAcked(segment) {
-    const moveInfo = (0, mergeTreeNodes_js_1.toMoveInfo)(segment);
+    const moveInfo = (0, segmentInfos_js_1.toMoveInfo)(segment);
     return moveInfo !== undefined && moveInfo.movedSeq !== constants_js_1.UnassignedSequenceNumber;
 }
 function isRemovedAndAckedOrMovedAndAcked(segment) {
     return isRemovedAndAcked(segment) || isMovedAndAcked(segment);
 }
 function isRemovedOrMoved(segment) {
-    return isRemoved(segment) || isMoved(segment);
+    return (0, segmentInfos_js_1.isRemoved)(segment) || (0, segmentInfos_js_1.isMoved)(segment);
 }
 function nodeTotalLength(mergeTree, node) {
     if (!node.isLeaf()) {
@@ -85,27 +71,25 @@ function ackSegment(segment, segmentGroup, opArgs) {
             return true;
         }
         case ops_js_1.MergeTreeDeltaType.REMOVE: {
-            const removalInfo = (0, mergeTreeNodes_js_1.toRemovalInfo)(segment);
-            (0, internal_1.assert)(removalInfo !== undefined, 0x046 /* "On remove ack, missing removal info!" */);
+            (0, segmentInfos_js_1.assertRemoved)(segment);
             segment.localRemovedSeq = undefined;
-            if (removalInfo.removedSeq === constants_js_1.UnassignedSequenceNumber) {
-                removalInfo.removedSeq = sequenceNumber;
+            if (segment.removedSeq === constants_js_1.UnassignedSequenceNumber) {
+                segment.removedSeq = sequenceNumber;
                 return true;
             }
             return false;
         }
         case ops_js_1.MergeTreeDeltaType.OBLITERATE:
         case ops_js_1.MergeTreeDeltaType.OBLITERATE_SIDED: {
-            const moveInfo = (0, mergeTreeNodes_js_1.toMoveInfo)(segment);
-            (0, internal_1.assert)(moveInfo !== undefined, 0x86e /* On obliterate ack, missing move info! */);
+            (0, segmentInfos_js_1.assertMoved)(segment);
             const obliterateInfo = segmentGroup.obliterateInfo;
             (0, internal_1.assert)(obliterateInfo !== undefined, 0xa40 /* must have obliterate info */);
             segment.localMovedSeq = obliterateInfo.localSeq = undefined;
-            const seqIdx = moveInfo.movedSeqs.indexOf(constants_js_1.UnassignedSequenceNumber);
+            const seqIdx = segment.movedSeqs.indexOf(constants_js_1.UnassignedSequenceNumber);
             (0, internal_1.assert)(seqIdx !== -1, 0x86f /* expected movedSeqs to contain unacked seq */);
-            moveInfo.movedSeqs[seqIdx] = sequenceNumber;
-            if (moveInfo.movedSeq === constants_js_1.UnassignedSequenceNumber) {
-                moveInfo.movedSeq = sequenceNumber;
+            segment.movedSeqs[seqIdx] = sequenceNumber;
+            if (segment.movedSeq === constants_js_1.UnassignedSequenceNumber) {
+                segment.movedSeq = sequenceNumber;
                 return true;
             }
             return false;
@@ -144,7 +128,6 @@ exports.findRootMergeBlock = findRootMergeBlock;
  * 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 = localReference_js_1.SlidingPreference.FORWARD, cache, useNewSlidingBehavior = false) {
     if (!segment ||
@@ -164,7 +147,8 @@ function getSlideToSegment(segment, slidingPreference = localReference_js_1.Slid
             return false;
         }
         if (cache !== undefined &&
-            (seg.removedSeq === segment.removedSeq || seg.movedSeq === segment.movedSeq)) {
+            ((0, segmentInfos_js_1.toRemovalInfo)(seg)?.removedSeq === (0, segmentInfos_js_1.toRemovalInfo)(segment)?.removedSeq ||
+                (0, segmentInfos_js_1.toMoveInfo)(seg)?.movedSeq === (0, segmentInfos_js_1.toMoveInfo)(segment)?.movedSeq)) {
             cache.set(seg, result);
         }
         return true;
@@ -211,7 +195,7 @@ function getSlideToSegment(segment, slidingPreference = localReference_js_1.Slid
  * @internal
  */
 function getSlideToSegoff(segoff, slidingPreference = localReference_js_1.SlidingPreference.FORWARD, useNewSlidingBehavior = false) {
-    if (segoff.segment === undefined) {
+    if (!(0, mergeTreeNodes_js_1.isSegmentLeaf)(segoff.segment)) {
         return segoff;
     }
     const [segment, _] = getSlideToSegment(segoff.segment, slidingPreference, undefined, useNewSlidingBehavior);
@@ -239,7 +223,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 index_js_1.DoublyLinkedList();
         /**
          * This contains a sorted lists of all obliterate starts
@@ -257,7 +240,6 @@ class Obliterates {
             this.mergeTree.removeLocalReferencePosition(ob.data.end);
         }
     }
-    // eslint-disable-next-line import/no-deprecated
     addOrUpdate(obliterateInfo) {
         const { seq, start } = obliterateInfo;
         if (seq !== constants_js_1.UnassignedSequenceNumber) {
@@ -268,14 +250,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 ((0, segmentInfos_js_1.isMergeNodeInfo)(startSeg) && startSeg.ordinal <= seg.ordinal) {
                 const ob = start.properties?.obliterate;
-                if (ob.end.getSegment().ordinal >= seg.ordinal) {
+                const endSeg = ob.end.getSegment();
+                if ((0, segmentInfos_js_1.isMergeNodeInfo)(endSeg) && endSeg.ordinal >= seg.ordinal) {
                     overlapping.push(ob);
                 }
             }
@@ -293,9 +275,7 @@ class Obliterates {
 class MergeTree {
     constructor(options) {
         this.options = options;
-        // eslint-disable-next-line import/no-deprecated
         this.collabWindow = new mergeTreeNodes_js_1.CollaborationWindow();
-        // eslint-disable-next-line import/no-deprecated
         this.pendingSegments = new index_js_1.DoublyLinkedList();
         this.segmentsToScour = new internal_1.Heap(LRUSegmentComparer);
         /**
@@ -313,6 +293,7 @@ class MergeTree {
                 return {};
             }
             const next = segment.splitAt(pos);
+            (0, mergeTreeNodes_js_1.assertSegmentLeaf)(next);
             if (segment?.segmentGroups) {
                 next.segmentGroups ?? (next.segmentGroups = new segmentGroupCollection_js_1.SegmentGroupCollection(next));
                 segment.segmentGroups.copyTo(next.segmentGroups);
@@ -356,8 +337,8 @@ class MergeTree {
      * numbers corresponding to un-acked operations give valid results.
      */
     localNetLength(segment, refSeq, localSeq) {
-        const removalInfo = (0, mergeTreeNodes_js_1.toRemovalInfo)(segment);
-        const moveInfo = (0, mergeTreeNodes_js_1.toMoveInfo)(segment);
+        const removalInfo = (0, segmentInfos_js_1.toRemovalInfo)(segment);
+        const moveInfo = (0, segmentInfos_js_1.toMoveInfo)(segment);
         if (localSeq === undefined) {
             if (removalInfo !== undefined || moveInfo !== undefined) {
                 if ((!!removalInfo && !(0, mergeTreeNodes_js_1.seqLTE)(removalInfo.removedSeq, this.collabWindow.minSeq)) ||
@@ -375,7 +356,9 @@ class MergeTree {
         }
         (0, internal_1.assert)(refSeq !== undefined, 0x398 /* localSeq provided for local length without refSeq */);
         (0, internal_1.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 === constants_js_1.UnassignedSequenceNumber) {
             (0, internal_1.assert)(segment.localSeq !== undefined, 0x39a /* unacked segment with undefined localSeq */);
             // inserted locally, still un-acked
@@ -411,7 +394,7 @@ class MergeTree {
     }
     addNode(block, node) {
         const index = block.childCount++;
-        block.assignChild(node, index, false);
+        (0, mergeTreeNodes_js_1.assignChild)(block, node, index, false);
         return index;
     }
     reloadFromSegments(segments) {
@@ -505,12 +488,12 @@ class MergeTree {
         (0, internal_1.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 };
     }
     /**
@@ -535,7 +518,9 @@ class MergeTree {
      */
     slideAckedRemovedSegmentReferences(segments) {
         // References are slid in groups to preserve their order.
+        // eslint-disable-next-line import/no-deprecated
         let currentForwardSlideGroup = [];
+        // eslint-disable-next-line import/no-deprecated
         let currentBackwardSlideGroup = [];
         let currentForwardMaybeEndpoint;
         let currentForwardSlideDestination;
@@ -543,7 +528,9 @@ class MergeTree {
         let currentBackwardMaybeEndpoint;
         let currentBackwardSlideDestination;
         let currentBackwardSlideIsForward;
-        const slideGroup = (currentSlideDestination, currentSlideIsForward, currentSlideGroup, pred, maybeEndpoint) => {
+        const slideGroup = (currentSlideDestination, currentSlideIsForward, 
+        // eslint-disable-next-line import/no-deprecated
+        currentSlideGroup, pred, maybeEndpoint) => {
             if (currentSlideIsForward === undefined) {
                 return;
             }
@@ -551,6 +538,7 @@ class MergeTree {
             const endpointRefsToAdd = currentSlideGroup.map((collection) => (0, localReference_js_1.filterLocalReferencePositions)(collection, (ref) => pred(ref) && !!ref.canSlideToEndpoint));
             if (maybeEndpoint) {
                 const endpoint = maybeEndpoint === "start" ? this.startOfTree : this.endOfTree;
+                // eslint-disable-next-line import/no-deprecated
                 const localRefs = localReference_js_1.LocalReferenceCollection.setOrGet(endpoint);
                 if (currentSlideIsForward) {
                     localRefs.addBeforeTombstones(...endpointRefsToAdd);
@@ -571,6 +559,7 @@ class MergeTree {
                 }
             }
             else {
+                // eslint-disable-next-line import/no-deprecated
                 const localRefs = localReference_js_1.LocalReferenceCollection.setOrGet(currentSlideDestination);
                 if (currentSlideIsForward) {
                     localRefs.addBeforeTombstones(...nonEndpointRefsToAdd);
@@ -580,7 +569,9 @@ class MergeTree {
                 }
             }
         };
-        const trySlideSegment = (segment, currentSlideDestination, currentSlideIsForward, currentSlideGroup, pred, slidingPreference, currentMaybeEndpoint, reassign) => {
+        const trySlideSegment = (segment, currentSlideDestination, currentSlideIsForward, 
+        // eslint-disable-next-line import/no-deprecated
+        currentSlideGroup, pred, slidingPreference, currentMaybeEndpoint, reassign) => {
             // avoid sliding logic if this segment doesn't have any references
             // with the given sliding preference
             if (!segment.localRefs || !(0, localReference_js_1.anyLocalReferencePosition)(segment.localRefs, pred)) {
@@ -637,7 +628,6 @@ class MergeTree {
         if (this.localPartialsComputed) {
             return;
         }
-        // eslint-disable-next-line import/no-deprecated
         const rebaseCollabWindow = new mergeTreeNodes_js_1.CollaborationWindow();
         rebaseCollabWindow.loadFrom(this.collabWindow);
         if (refSeq < this.collabWindow.minSeq) {
@@ -667,8 +657,8 @@ class MergeTree {
             // Sequence number within window
             if (node.isLeaf()) {
                 const segment = node;
-                const removalInfo = (0, mergeTreeNodes_js_1.toRemovalInfo)(segment);
-                const moveInfo = (0, mergeTreeNodes_js_1.toMoveInfo)(segment);
+                const removalInfo = (0, segmentInfos_js_1.toRemovalInfo)(segment);
+                const moveInfo = (0, segmentInfos_js_1.toMoveInfo)(segment);
                 if (removalInfo !== undefined) {
                     if ((0, mergeTreeNodes_js_1.seqLTE)(removalInfo.removedSeq, this.collabWindow.minSeq)) {
                         return undefined;
@@ -721,24 +711,26 @@ 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 (!(0, mergeTreeNodes_js_1.isSegmentLeaf)(seg)) {
             // We have no idea where this reference is, because it refers to a segment which is not in the tree.
             return referencePositions_js_1.DetachedReferencePosition;
         }
         if (refPos.isLeaf()) {
-            return this.getPosition(refPos, refSeq, clientId, localSeq);
+            return this.getPosition(seg, refSeq, clientId, localSeq);
         }
         if ((0, referencePositions_js_1.refTypeIncludesFlag)(refPos, ops_js_1.ReferenceType.Transient) || seg.localRefs?.has(refPos)) {
             if (seg !== this.startOfTree &&
                 seg !== this.endOfTree &&
                 !(0, perspective_js_1.isSegmentPresent)(seg, { refSeq, localSeq })) {
                 const forward = refPos.slidingPreference === localReference_js_1.SlidingPreference.FORWARD;
-                const slideSeq = seg.movedSeq !== constants_js_1.UnassignedSequenceNumber && seg.movedSeq !== undefined
-                    ? seg.movedSeq
-                    : seg.removedSeq !== constants_js_1.UnassignedSequenceNumber && seg.removedSeq !== undefined
-                        ? seg.removedSeq
+                const moveInfo = (0, segmentInfos_js_1.toMoveInfo)(seg);
+                const removeInfo = (0, segmentInfos_js_1.toRemovalInfo)(seg);
+                const slideSeq = moveInfo !== undefined && moveInfo.movedSeq !== constants_js_1.UnassignedSequenceNumber
+                    ? moveInfo.movedSeq
+                    : removeInfo !== undefined && removeInfo.removedSeq !== constants_js_1.UnassignedSequenceNumber
+                        ? removeInfo.removedSeq
                         : refSeq;
-                const slideLocalSeq = seg.localMovedSeq ?? seg.localRemovedSeq;
+                const slideLocalSeq = moveInfo?.localMovedSeq ?? removeInfo?.localRemovedSeq;
                 const perspective = new perspective_js_1.PerspectiveImpl(this, {
                     refSeq: slideSeq,
                     localSeq: slideLocalSeq,
@@ -766,11 +758,10 @@ class MergeTree {
     searchForMarker(startPos, clientId, markerLabel, forwards = true) {
         let foundMarker;
         const { segment } = this.getContainingSegment(startPos, constants_js_1.UniversalSequenceNumber, clientId);
-        const segWithParent = segment;
-        if (segWithParent?.parent === undefined) {
+        if (!(0, mergeTreeNodes_js_1.isSegmentLeaf)(segment)) {
             return undefined;
         }
-        (0, mergeTreeNodeWalk_js_1.depthFirstNodeWalk)(segWithParent.parent, segWithParent, (node) => {
+        (0, mergeTreeNodeWalk_js_1.depthFirstNodeWalk)(segment.parent, segment, (node) => {
             if (node.isLeaf()) {
                 if (mergeTreeNodes_js_1.Marker.is(node) && (0, referencePositions_js_1.refHasTileLabel)(node, markerLabel)) {
                     foundMarker = node;
@@ -792,8 +783,8 @@ class MergeTree {
     updateRoot(splitNode) {
         if (splitNode !== undefined) {
             const newRoot = this.makeBlock(2);
-            newRoot.assignChild(this.root, 0, false);
-            newRoot.assignChild(splitNode, 1, false);
+            (0, mergeTreeNodes_js_1.assignChild)(newRoot, this.root, 0, false);
+            (0, mergeTreeNodes_js_1.assignChild)(newRoot, splitNode, 1, false);
             this.root = newRoot;
             this.nodeUpdateOrdinals(this.root);
             this.nodeUpdateLengthNewStructure(this.root);
@@ -849,9 +840,7 @@ class MergeTree {
             (0, zamboni_js_1.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 = {
@@ -871,7 +860,6 @@ class MergeTree {
         if (previousProps) {
             _segmentGroup.previousProps.push(previousProps);
         }
-        // eslint-disable-next-line import/no-deprecated
         const segmentGroups = (segment.segmentGroups ?? (segment.segmentGroups = new segmentGroupCollection_js_1.SegmentGroupCollection(segment)));
         segmentGroups.enqueue(_segmentGroup);
         return _segmentGroup;
@@ -880,8 +868,8 @@ class MergeTree {
     getMarkerFromId(id) {
         const marker = this.idToMarker.get(id);
         return marker === undefined ||
-            isRemoved(marker) ||
-            (isMoved(marker) && marker.moveDst === undefined)
+            (0, segmentInfos_js_1.isRemoved)(marker) ||
+            ((0, segmentInfos_js_1.isMoved)(marker) && marker.moveDst === undefined)
             ? undefined
             : marker;
     }
@@ -898,7 +886,7 @@ class MergeTree {
         if (relativePos.id) {
             marker = this.getMarkerFromId(relativePos.id);
         }
-        if (marker) {
+        if ((0, mergeTreeNodes_js_1.isSegmentLeaf)(marker)) {
             pos = this.getPosition(marker, refseq, clientId);
             if (relativePos.before) {
                 if (relativePos.offset !== undefined) {
@@ -921,7 +909,7 @@ class MergeTree {
         // opArgs == undefined => loading snapshot or test code
         if (opArgs !== undefined) {
             const deltaSegments = segments
-                .filter((segment) => !(0, mergeTreeNodes_js_1.toMoveInfo)(segment))
+                .filter((segment) => !(0, segmentInfos_js_1.toMoveInfo)(segment))
                 .map((segment) => ({ segment }));
             if (deltaSegments.length > 0) {
                 this.mergeTreeDeltaCallback?.(opArgs, {
@@ -956,7 +944,7 @@ class MergeTree {
         }
         const segmentInfo = this.getContainingSegment(remoteClientPosition, remoteClientRefSeq, remoteClientId);
         const { currentSeq, clientId } = this.collabWindow;
-        if (segmentInfo?.segment) {
+        if ((0, mergeTreeNodes_js_1.isSegmentLeaf)(segmentInfo?.segment)) {
             const segmentPosition = this.getPosition(segmentInfo.segment, currentSeq, clientId);
             return segmentPosition + segmentInfo.offset;
         }
@@ -977,7 +965,6 @@ 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
@@ -1007,92 +994,95 @@ 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 (mergeTreeNodes_js_1.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) => (0, segmentInfos_js_1.overwriteInfo)(s, insertInfo))) {
+            if (mergeTreeNodes_js_1.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 (!(0, mergeTreeNodes_js_1.isSegmentLeaf)(newSegment)) {
+                // Indicates an attempt to insert past the end of the merge-tree's content.
+                const errorConstructor = localSeq === undefined ? internal_2.DataProcessingError : internal_2.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 ? internal_2.DataProcessingError : internal_2.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 === constants_js_1.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 === constants_js_1.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) {
-                    const moveInfo = {
-                        movedClientIds,
-                        movedSeq: oldest.seq,
-                        movedSeqs,
-                        localMovedSeq: oldest.localSeq,
-                        wasMovedOnInsert: oldest.seq !== constants_js_1.UnassignedSequenceNumber,
-                    };
-                    markSegmentMoved(newSegment, moveInfo);
-                    if (moveInfo.localMovedSeq !== undefined) {
-                        (0, internal_1.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 !== constants_js_1.UnassignedSequenceNumber,
+                };
+                (0, segmentInfos_js_1.overwriteInfo)(newSegment, moveInfo);
+                if (moveInfo.localMovedSeq !== undefined) {
+                    (0, internal_1.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) {
@@ -1113,10 +1103,8 @@ class MergeTree {
             const newSeq = seq === constants_js_1.UnassignedSequenceNumber ? Number.MAX_SAFE_INTEGER : seq;
             const segSeq = node.seq === constants_js_1.UnassignedSequenceNumber ? Number.MAX_SAFE_INTEGER - 1 : (node.seq ?? 0);
             return (newSeq > segSeq ||
-                (node.movedSeq !== undefined &&
-                    node.movedSeq !== constants_js_1.UnassignedSequenceNumber &&
-                    node.movedSeq > seq) ||
-                (node.removedSeq !== undefined &&
+                ((0, segmentInfos_js_1.isMoved)(node) && node.movedSeq !== constants_js_1.UnassignedSequenceNumber && node.movedSeq > seq) ||
+                ((0, segmentInfos_js_1.isRemoved)(node) &&
                     node.removedSeq !== constants_js_1.UnassignedSequenceNumber &&
                     node.removedSeq > seq));
         }
@@ -1148,7 +1136,7 @@ class MergeTree {
                     const segment = child;
                     const segmentChanges = context.leaf(segment, _pos, context);
                     if (segmentChanges.replaceCurrent) {
-                        block.assignChild(segmentChanges.replaceCurrent, childIndex, false);
+                        (0, mergeTreeNodes_js_1.assignChild)(block, segmentChanges.replaceCurrent, childIndex, false);
                         segmentChanges.replaceCurrent.ordinal = child.ordinal;
                     }
                     if (segmentChanges.next) {
@@ -1199,7 +1187,7 @@ class MergeTree {
                 block.children[i] = block.children[i - 1];
                 block.children[i].index = i;
             }
-            block.assignChild(newNode, childIndex, false);
+            (0, mergeTreeNodes_js_1.assignChild)(block, newNode, childIndex, false);
             block.childCount++;
             block.setOrdinal(newNode, childIndex);
             if (block.childCount < mergeTreeNodes_js_1.MaxNodesInBlock) {
@@ -1228,7 +1216,7 @@ 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);
+            (0, mergeTreeNodes_js_1.assignChild)(newNode, node.children[halfCount + i], i, false);
             node.children[halfCount + i] = undefined;
         }
         this.nodeUpdateLengthNewStructure(node);
@@ -1255,9 +1243,7 @@ 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 = segmentPropertiesManager_js_1.PropertiesRollback.None) {
+    annotateRange(start, end, propsOrAdjust, refSeq, clientId, seq, opArgs, rollback = segmentPropertiesManager_js_1.PropertiesRollback.None) {
         if (propsOrAdjust.adjust !== undefined) {
             errorIfOptionNotTrue(this.options, "mergeTreeEnableAnnotateAdjust");
         }
@@ -1265,7 +1251,6 @@ class MergeTree {
         this.ensureIntervalBoundary(end, refSeq, clientId);
         const deltaSegments = [];
         const localSeq = seq === constants_js_1.UnassignedSequenceNumber ? ++this.collabWindow.localSeq : undefined;
-        // eslint-disable-next-line import/no-deprecated
         let segmentGroup;
         const opObj = propsOrAdjust.props ?? propsOrAdjust.adjust;
         const annotateSegment = (segment) => {
@@ -1289,7 +1274,7 @@ 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, {
@@ -1310,9 +1295,9 @@ class MergeTree {
         this.ensureIntervalBoundary(endPos, refSeq, clientId);
         let _overwrite = false;
         const localOverlapWithRefs = [];
+        // eslint-disable-next-line import/no-deprecated
         const movedSegments = [];
         const localSeq = seq === constants_js_1.UnassignedSequenceNumber ? ++this.collabWindow.localSeq : undefined;
-        // eslint-disable-next-line import/no-deprecated
         const obliterate = {
             clientId,
             end: (0, localReference_js_1.createDetachedLocalReferencePosition)(undefined),
@@ -1324,7 +1309,7 @@ class MergeTree {
         };
         const { segment: startSeg } = this.getContainingSegment(start.pos, refSeq, clientId);
         const { segment: endSeg } = this.getContainingSegment(end.pos, refSeq, clientId);
-        (0, internal_1.assert)(startSeg !== undefined && endSeg !== undefined, 0xa3f /* segments cannot be undefined */);
+        (0, internal_1.assert)((0, mergeTreeNodes_js_1.isSegmentLeaf)(startSeg) && (0, mergeTreeNodes_js_1.isSegmentLeaf)(endSeg), 0xa3f /* segments cannot be undefined */);
         obliterate.start = this.createLocalReferencePosition(startSeg, start.side === sequencePlace_js_1.Side.Before ? 0 : Math.max(startSeg.cachedLength - 1, 0), ops_js_1.ReferenceType.StayOnRemove, {
             obliterate,
         });
@@ -1345,7 +1330,7 @@ class MergeTree {
             this.pendingSegments.push(obliterate.segmentGroup);
         }
         this.obliterates.addOrUpdate(obliterate);
-        const markMoved = (segment, pos, _start, _end) => {
+        const markMoved = (segment, pos) => {
             if ((start.side === sequencePlace_js_1.Side.After && startPos === pos + segment.cachedLength) || // exclusive start segment
                 (end.side === sequencePlace_js_1.Side.Before &&
                     endPos === pos &&
@@ -1355,30 +1340,34 @@ class MergeTree {
                 // These segments are outside of the obliteration range though, so return true to keep walking.
                 return true;
             }
-            const existingMoveInfo = (0, mergeTreeNodes_js_1.toMoveInfo)(segment);
+            const existingMoveInfo = (0, segmentInfos_js_1.toMoveInfo)(segment);
             if (segment.prevObliterateByInserter?.seq === constants_js_1.UnassignedSequenceNumber) {
                 // We chose to not obliterate this segment because we are aware of an unacked local obliteration.
                 // The local obliterate has not been sequenced yet, so it is still the newest obliterate we are aware of.
                 // 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 !== constants_js_1.UnassignedSequenceNumber &&
-                (refSeq < segment.seq || segment.seq === constants_js_1.UnassignedSequenceNumber)) {
-                segment.wasMovedOnInsert = true;
-            }
+                (refSeq < segment.seq || segment.seq === constants_js_1.UnassignedSequenceNumber);
             if (existingMoveInfo === undefined) {
-                segment.movedClientIds = [clientId];
-                segment.movedSeq = seq;
-                segment.localMovedSeq = localSeq;
-                segment.movedSeqs = [seq];
-                if (!(0, mergeTreeNodes_js_1.toRemovalInfo)(segment)) {
-                    movedSegments.push({ segment });
+                // eslint-disable-next-line import/no-deprecated
+                const movedSeg = (0, segmentInfos_js_1.overwriteInfo)(segment, {
+                    movedClientIds: [clientId],
+                    movedSeq: seq,
+                    localMovedSeq: localSeq,
+                    movedSeqs: [seq],
+                    wasMovedOnInsert,
+                });
+                if (!(0, segmentInfos_js_1.toRemovalInfo)(movedSeg)) {
+                    movedSegments.push(movedSeg);
                 }
             }
             else {
                 _overwrite = true;
+                // never move wasMovedOnInsert from true to false
+                existingMoveInfo.wasMovedOnInsert || (existingMoveInfo.wasMovedOnInsert = wasMovedOnInsert);
                 if (existingMoveInfo.movedSeq === constants_js_1.UnassignedSequenceNumber) {
                     // we moved this locally, but someone else moved it first
                     // so put them at the head of the list
@@ -1397,6 +1386,7 @@ class MergeTree {
                     existingMoveInfo.movedSeqs.push(seq);
                 }
             }
+            (0, segmentInfos_js_1.assertMoved)(segment);
             // Save segment so can assign moved sequence number when acked by server
             if (this.collabWindow.collaborating) {
                 if (segment.movedSeq === constants_js_1.UnassignedSequenceNumber &&
@@ -1411,7 +1401,7 @@ class MergeTree {
             }
             return true;
         };
-        const afterMarkMoved = (node, pos, _start, _end) => {
+        const afterMarkMoved = (node) => {
             if (_overwrite) {
                 this.nodeUpdateLengthNewStructure(node);
             }
@@ -1420,21 +1410,21 @@ 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 === constants_js_1.UnassignedSequenceNumber ? undefined : seq);
         this.slideAckedRemovedSegmentReferences(localOverlapWithRefs);
         // opArgs == undefined => test code
         if (start.pos !== end.pos || start.side !== end.side) {
             this.mergeTreeDeltaCallback?.(opArgs, {
                 operation: ops_js_1.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 !== constants_js_1.UnassignedSequenceNumber &&
@@ -1457,19 +1447,22 @@ 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 === constants_js_1.UnassignedSequenceNumber ? ++this.collabWindow.localSeq : undefined;
         const markRemoved = (segment, pos, _start, _end) => {
-            const existingRemovalInfo = (0, mergeTreeNodes_js_1.toRemovalInfo)(segment);
+            const existingRemovalInfo = (0, segmentInfos_js_1.toRemovalInfo)(segment);
             if (existingRemovalInfo === undefined) {
-                segment.removedClientIds = [clientId];
-                segment.removedSeq = seq;
-                segment.localRemovedSeq = localSeq;
-                if (!(0, mergeTreeNodes_js_1.toMoveInfo)(segment)) {
-                    removedSegments.push({ segment });
+                // eslint-disable-next-line import/no-deprecated
+                const removed = (0, segmentInfos_js_1.overwriteInfo)(segment, {
+                    removedClientIds: [clientId],
+                    removedSeq: seq,
+                    localRemovedSeq: localSeq,
+                });
+                if (!(0, segmentInfos_js_1.toMoveInfo)(removed)) {
+                    removedSegments.push(removed);
                 }
             }
             else {
@@ -1490,6 +1483,7 @@ class MergeTree {
                     existingRemovalInfo.removedClientIds.push(clientId);
                 }
             }
+            (0, segmentInfos_js_1.assertRemoved)(segment);
             // Save segment so we can assign removed sequence number when acked by server
             if (this.collabWindow.collaborating) {
                 if (segment.removedSeq === constants_js_1.UnassignedSequenceNumber &&
@@ -1504,7 +1498,7 @@ class MergeTree {
             }
             return true;
         };
-        const afterMarkRemoved = (node, pos, _start, _end) => {
+        const afterMarkRemoved = (node) => {
             if (_overwrite) {
                 this.nodeUpdateLengthNewStructure(node);
             }
@@ -1513,7 +1507,7 @@ 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);
@@ -1521,14 +1515,14 @@ class MergeTree {
         if (removedSegments.length > 0) {
             this.mergeTreeDeltaCallback?.(opArgs, {
                 operation: ops_js_1.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 !== constants_js_1.UnassignedSequenceNumber &&
@@ -1539,24 +1533,21 @@ class MergeTree {
     /**
      * Revert an unacked local op
      */
-    // eslint-disable-next-line import/no-deprecated
     rollback(op, localOpMetadata) {
         if (op.type === ops_js_1.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();
                 (0, internal_1.assert)(segmentSegmentGroup === pendingSegmentGroup, 0x3ee /* Unexpected segmentGroup in segment */);
-                (0, internal_1.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) {
+                (0, internal_1.assert)((0, segmentInfos_js_1.isRemoved)(segment) && segment.removedClientIds[0] === this.collabWindow.clientId, 0x39d /* Rollback segment removedClientId does not match local client */);
+                let updateNode = segment.parent;
+                (0, segmentInfos_js_1.removeRemovalInfo)(segment);
+                for (updateNode; updateNode !== undefined; updateNode = updateNode.parent) {
                     this.blockUpdateLength(updateNode, constants_js_1.UnassignedSequenceNumber, this.collabWindow.clientId);
                 }
                 // Note: optional chaining short-circuits:
@@ -1569,7 +1560,7 @@ class MergeTree {
         }
         else if (op.type === ops_js_1.MergeTreeDeltaType.INSERT ||
             op.type === ops_js_1.MergeTreeDeltaType.ANNOTATE) {
-            const pendingSegmentGroup = this.pendingSegments.pop?.()?.data;
+            const pendingSegmentGroup = this.pendingSegments.pop()?.data;
             if (pendingSegmentGroup === undefined ||
                 pendingSegmentGroup !== localOpMetadata ||
                 (op.type === ops_js_1.MergeTreeDeltaType.ANNOTATE && !pendingSegmentGroup.previousProps)) {
@@ -1577,7 +1568,7 @@ class MergeTree {
             }
             let i = 0;
             for (const segment of pendingSegmentGroup.segments) {
-                const segmentSegmentGroup = segment?.segmentGroups?.pop?.();
+                const segmentSegmentGroup = segment?.segmentGroups?.pop();
                 (0, internal_1.assert)(segmentSegmentGroup === pendingSegmentGroup, 0x3ef /* Unexpected segmentGroup in segment */);
                 const start = this.findRollbackPosition(segment);
                 if (op.type === ops_js_1.MergeTreeDeltaType.INSERT) {
@@ -1609,7 +1600,7 @@ class MergeTree {
                 return false;
             }
             // If not removed, increase position
-            if (seg.removedSeq === undefined) {
+            if (!(0, segmentInfos_js_1.isRemoved)(seg)) {
                 segmentPosition += seg.cachedLength;
             }
             return true;
@@ -1643,8 +1634,10 @@ class MergeTree {
             segment = this.endOfTree;
         }
         else {
+            (0, mergeTreeNodes_js_1.assertSegmentLeaf)(_segment);
             segment = _segment;
         }
+        // eslint-disable-next-line import/no-deprecated
         const localRefs = localReference_js_1.LocalReferenceCollection.setOrGet(segment);
         const segRef = localRefs.createLocalRef(offset, refType, properties, slidingPreference, canSlideToEndpoint);
         return segRef;
@@ -1672,7 +1665,7 @@ class MergeTree {
                 affectedSegments.remove(segmentToSlide);
                 affectedSegments.insertAfter(lastLocalSegment, segmentToSlide.data);
             }
-            else if (isRemoved(segmentToSlide.data)) {
+            else if ((0, segmentInfos_js_1.isRemoved)(segmentToSlide.data)) {
                 (0, internal_1.assert)(segmentToSlide.data.localRemovedSeq !== undefined, 0x54d /* Removed segment that hasnt had its removal acked should be locally removed */);
                 // Slide each locally removed item past all segments that have localSeq > lremoveItem.localSeq
                 // but not past remotely removed segments;
@@ -1706,7 +1699,7 @@ 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);
+            (0, mergeTreeNodes_js_1.assignChild)(parent, seg, index, false);
             seg.ordinal = ordinal;
         }
         for (const [segment, groups] of perSegmentTrackingGroups.entries()) {
@@ -1766,7 +1759,7 @@ class MergeTree {
             }
         };
         (0, mergeTreeNodeWalk_js_1.walkAllChildSegments)(this.root, (seg) => {
-            if (isRemoved(seg) || seg.seq === constants_js_1.UnassignedSequenceNumber) {
+            if ((0, segmentInfos_js_1.isRemoved)(seg) || seg.seq === constants_js_1.UnassignedSequenceNumber) {
                 if (isRemovedAndAcked(seg)) {
                     rangeContainsRemoteRemovedSegs = true;
                 }
@@ -1873,7 +1866,7 @@ 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
@@ -1898,7 +1891,7 @@ 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;
@@ -1925,14 +1918,12 @@ class MergeTree {
                 return mergeTreeNodeWalk_js_1.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 mergeTreeNodeWalk_js_1.NodeAction.Exit;
                 }
                 pos = nextPos;
             }
-        }, undefined, post === undefined
-            ? undefined
-            : (block) => post(block, pos, refSeq, clientId, start - pos, endPos - pos, accum));
+        }, undefined, post);
     }
 }
 exports.MergeTree = MergeTree;