@fluidframework/merge-tree 2.30.0 → 2.31.0

package/lib/mergeTree.js

@@ -11,89 +11,83 @@ import { NonCollabClient, TreeMaintenanceSequenceNumber, UnassignedSequenceNumbe
 import { EndOfTreeSegment, StartOfTreeSegment } from "./endOfTreeSegment.js";
 import { LocalReferenceCollection, SlidingPreference, anyLocalReferencePosition, createDetachedLocalReferencePosition, filterLocalReferencePositions, } from "./localReference.js";
 import { MergeTreeMaintenanceType, } from "./mergeTreeDeltaCallback.js";
-import { NodeAction, backwardExcursion, depthFirstNodeWalk, forwardExcursion, walkAllChildSegments, } from "./mergeTreeNodeWalk.js";
-import { CollaborationWindow, Marker, MaxNodesInBlock, MergeBlock, assertSegmentLeaf, assignChild, isSegmentLeaf, reservedMarkerIdKey, seqLTE, } from "./mergeTreeNodes.js";
+import { LeafAction, NodeAction, backwardExcursion, depthFirstNodeWalk, forwardExcursion, walkAllChildSegments, } from "./mergeTreeNodeWalk.js";
+import { CollaborationWindow, Marker, MaxNodesInBlock, MergeBlock, assertSegmentLeaf, assignChild, getMinSeqPerspective, getMinSeqStamp, isSegmentLeaf, reservedMarkerIdKey, } from "./mergeTreeNodes.js";
 import { createAnnotateRangeOp, createInsertSegmentOp, createRemoveRangeOp, } from "./opBuilder.js";
 import { MergeTreeDeltaType, ReferenceType, } from "./ops.js";
 import { PartialSequenceLengths } from "./partialLengths.js";
-import { LocalDefaultPerspective, LocalReconnectingPerspective, PriorPerspective, } from "./perspective.js";
+import { PriorPerspective, LocalReconnectingPerspective, LocalDefaultPerspective, RemoteObliteratePerspective, } from "./perspective.js";
 import { createMap, extend, extendIfUndefined } from "./properties.js";
 import { DetachedReferencePosition, refGetTileLabels, refHasTileLabel, refTypeIncludesFlag, } from "./referencePositions.js";
 import { SegmentGroupCollection } from "./segmentGroupCollection.js";
-import { assertMoved, assertRemoved, isMergeNodeInfo, isMoved, isRemoved, overwriteInfo, removeRemovalInfo, toMoveInfo, toRemovalInfo, wasMovedOnInsert, } from "./segmentInfos.js";
-import { copyPropertiesAndManager, PropertiesManager, PropertiesRollback, } from "./segmentPropertiesManager.js";
+import { assertRemoved, isMergeNodeInfo, isRemoved, overwriteInfo, removeRemovalInfo, toRemovalInfo, } from "./segmentInfos.js";
+import { copyPropertiesAndManager, PropertiesManager, } from "./segmentPropertiesManager.js";
 import { Side } from "./sequencePlace.js";
 import { SortedSegmentSet } from "./sortedSegmentSet.js";
+import * as opstampUtils from "./stamps.js";
 import { zamboniSegments } from "./zamboni.js";
-function isRemovedAndAcked(segment) {
+export function isRemovedAndAcked(segment) {
     const removalInfo = toRemovalInfo(segment);
-    return removalInfo !== undefined && removalInfo.removedSeq !== UnassignedSequenceNumber;
-}
-function isMovedAndAcked(segment) {
-    const moveInfo = toMoveInfo(segment);
-    return moveInfo !== undefined && moveInfo.movedSeq !== UnassignedSequenceNumber;
-}
-function isRemovedAndAckedOrMovedAndAcked(segment) {
-    return isRemovedAndAcked(segment) || isMovedAndAcked(segment);
-}
-function isRemovedOrMoved(segment) {
-    return isRemoved(segment) || isMoved(segment);
+    return removalInfo !== undefined && opstampUtils.isAcked(removalInfo.removes[0]);
 }
 function nodeTotalLength(mergeTree, node) {
     if (!node.isLeaf()) {
         return node.cachedLength;
     }
-    return mergeTree.localNetLength(node);
+    return mergeTree.leafLength(node);
 }
 const LRUSegmentComparer = {
     min: { maxSeq: -2 },
     compare: (a, b) => a.maxSeq - b.maxSeq,
 };
-function ackSegment(segment, segmentGroup, opArgs) {
+function ackSegment(segment, segmentGroup, opArgs, stamp) {
     const currentSegmentGroup = segment.segmentGroups?.dequeue();
     assert(currentSegmentGroup === segmentGroup, 0x043 /* "On ack, unexpected segmentGroup!" */);
     assert(opArgs.sequencedMessage !== undefined, 0xa6e /* must have sequencedMessage */);
     const { op, sequencedMessage: { sequenceNumber, minimumSequenceNumber }, } = opArgs;
+    let allowIncrementalPartialLengthsUpdate = true;
     switch (op.type) {
         case MergeTreeDeltaType.ANNOTATE: {
             assert(!!segment.propertyManager, 0x044 /* "On annotate ack, missing segment property manager!" */);
             segment.propertyManager.ack(sequenceNumber, minimumSequenceNumber, op);
-            return true;
+            break;
         }
         case MergeTreeDeltaType.INSERT: {
-            assert(segment.seq === UnassignedSequenceNumber, 0x045 /* "On insert, seq number already assigned!" */);
-            segment.seq = sequenceNumber;
-            segment.localSeq = undefined;
-            return true;
-        }
-        case MergeTreeDeltaType.REMOVE: {
-            assertRemoved(segment);
-            segment.localRemovedSeq = undefined;
-            if (segment.removedSeq === UnassignedSequenceNumber) {
-                segment.removedSeq = sequenceNumber;
-                return true;
-            }
-            return false;
+            assert(opstampUtils.isLocal(segment.insert), 0x045 /* "On insert, seq number already assigned!" */);
+            segment.insert = {
+                ...stamp,
+                type: "insert",
+            };
+            break;
         }
+        case MergeTreeDeltaType.REMOVE:
         case MergeTreeDeltaType.OBLITERATE:
         case MergeTreeDeltaType.OBLITERATE_SIDED: {
-            assertMoved(segment);
-            const obliterateInfo = segmentGroup.obliterateInfo;
-            assert(obliterateInfo !== undefined, 0xa40 /* must have obliterate info */);
-            segment.localMovedSeq = obliterateInfo.localSeq = undefined;
-            const seqIdx = segment.movedSeqs.indexOf(UnassignedSequenceNumber);
-            assert(seqIdx !== -1, 0x86f /* expected movedSeqs to contain unacked seq */);
-            segment.movedSeqs[seqIdx] = sequenceNumber;
-            if (segment.movedSeq === UnassignedSequenceNumber) {
-                segment.movedSeq = sequenceNumber;
-                return true;
+            assertRemoved(segment);
+            const latestRemove = segment.removes[segment.removes.length - 1];
+            assert(opstampUtils.isLocal(latestRemove), 0xb5d /* Expected last remove to be unacked */);
+            assert(segment.removes.length === 1 ||
+                opstampUtils.isAcked(segment.removes[segment.removes.length - 2]), 0xb5e /* Expected prior remove to be acked */);
+            allowIncrementalPartialLengthsUpdate = segment.removes.length === 1;
+            const removeStamp = {
+                ...stamp,
+                type: op.type === MergeTreeDeltaType.REMOVE ? "setRemove" : "sliceRemove",
+            };
+            segment.removes[segment.removes.length - 1] = removeStamp;
+            const { obliterateInfo } = segmentGroup;
+            const hasObliterateInfo = obliterateInfo !== undefined;
+            const isObliterate = op.type !== MergeTreeDeltaType.REMOVE;
+            assert(hasObliterateInfo === isObliterate, 0xa40 /* must have obliterate info */);
+            if (hasObliterateInfo) {
+                obliterateInfo.stamp = removeStamp;
             }
-            return false;
+            break;
         }
         default: {
             throw new Error(`${op.type} is in unrecognized operation type`);
         }
     }
+    return allowIncrementalPartialLengthsUpdate;
 }
 export function errorIfOptionNotTrue(options, option) {
     if (options?.[option] !== true) {
@@ -124,9 +118,7 @@ export function findRootMergeBlock(segmentOrNode) {
  * SlideOnRemove references is removed.
  */
 function getSlideToSegment(segment, slidingPreference = SlidingPreference.FORWARD, cache, useNewSlidingBehavior = false) {
-    if (!segment ||
-        !isRemovedAndAckedOrMovedAndAcked(segment) ||
-        segment.endpointType !== undefined) {
+    if (!segment || !isRemovedAndAcked(segment) || segment.endpointType !== undefined) {
         return [segment, undefined];
     }
     const cachedSegment = cache?.get(segment);
@@ -136,13 +128,12 @@ function getSlideToSegment(segment, slidingPreference = SlidingPreference.FORWAR
     const result = {};
     cache?.set(segment, result);
     const goFurtherToFindSlideToSegment = (seg) => {
-        if (seg.seq !== UnassignedSequenceNumber && !isRemovedAndAckedOrMovedAndAcked(seg)) {
+        if (opstampUtils.isAcked(seg.insert) && !isRemovedAndAcked(seg)) {
             result.seg = seg;
             return false;
         }
         if (cache !== undefined &&
-            (toRemovalInfo(seg)?.removedSeq === toRemovalInfo(segment)?.removedSeq ||
-                toMoveInfo(seg)?.movedSeq === toMoveInfo(segment)?.movedSeq)) {
+            toRemovalInfo(seg)?.removes[0].seq === toRemovalInfo(segment)?.removes[0].seq) {
             cache.set(seg, result);
         }
         return true;
@@ -208,10 +199,10 @@ class Obliterates {
     constructor(mergeTree) {
         this.mergeTree = mergeTree;
         /**
-         * Array containing the all move operations within the
+         * Array containing the all obliterate operations within the
          * collab window.
          *
-         * The moves are stored in sequence order which accelerates clean up in setMinSeq
+         * The obliterates are stored in sequence order which accelerates clean up in setMinSeq
          *
          * See https://github.com/microsoft/FluidFramework/blob/main/packages/dds/merge-tree/docs/Obliterate.md#remote-perspective
          * for additional context
@@ -226,7 +217,7 @@ class Obliterates {
     }
     setMinSeq(minSeq) {
         // eslint-disable-next-line @typescript-eslint/no-non-null-asserted-optional-chain
-        while (!this.seqOrdered.empty && this.seqOrdered.first?.data.seq <= minSeq) {
+        while (!this.seqOrdered.empty && this.seqOrdered.first?.data.stamp.seq <= minSeq) {
             const ob = this.seqOrdered.shift();
             this.startOrdered.remove(ob.data.start);
             this.mergeTree.removeLocalReferencePosition(ob.data.start);
@@ -234,7 +225,7 @@ class Obliterates {
         }
     }
     addOrUpdate(obliterateInfo) {
-        const { seq, start } = obliterateInfo;
+        const { stamp: { seq }, start, } = obliterateInfo;
         if (seq !== UnassignedSequenceNumber) {
             this.seqOrdered.push(obliterateInfo);
         }
@@ -266,12 +257,14 @@ class Obliterates {
  * @internal
  */
 export class MergeTree {
+    get localPerspective() {
+        return this.collabWindow.localPerspective;
+    }
     constructor(options) {
         this.options = options;
         this.collabWindow = new CollaborationWindow();
         this.pendingSegments = new DoublyLinkedList();
         this.segmentsToScour = new Heap(LRUSegmentComparer);
-        this.localPerspective = new LocalDefaultPerspective(this.collabWindow.clientId);
         /**
          * Whether or not all blocks in the mergeTree currently have information about local partial lengths computed.
          * This information is only necessary on reconnect, and otherwise costly to bookkeep.
@@ -326,61 +319,20 @@ export class MergeTree {
         return block;
     }
     /**
-     * Compute the net length of this segment from a local perspective.
-     * @param segment - Segment whose length to find
-     * @param localSeq - localSeq at which to find the length of this segment. If not provided,
-     * default is to consider the local client's current perspective. Only local sequence
-     * numbers corresponding to un-acked operations give valid results.
+     * Compute the net length of this segment leaf from some perspective.
+     * @returns - Undefined if the segment has been removed and its removal is common knowledge to all collaborators (and therefore
+     * may not even be present on clients that have loaded from a summary beyond this point). Otherwise, the length of the segment.
      */
-    localNetLength(segment, refSeq, localSeq) {
+    leafLength(segment, perspective = this.localPerspective) {
         const removalInfo = toRemovalInfo(segment);
-        const moveInfo = toMoveInfo(segment);
-        if (localSeq === undefined) {
-            if (removalInfo !== undefined || moveInfo !== undefined) {
-                if ((!!removalInfo && !seqLTE(removalInfo.removedSeq, this.collabWindow.minSeq)) ||
-                    (!!moveInfo && !seqLTE(moveInfo.movedSeq, this.collabWindow.minSeq))) {
-                    return 0;
-                }
-                // this segment removed and outside the collab window which means it is zamboni eligible
-                // this also means the segment could not exist, so we should not consider it
-                // when making decisions about conflict resolutions
-                return undefined;
-            }
-            else {
-                return segment.cachedLength;
-            }
-        }
-        assert(refSeq !== undefined, 0x398 /* localSeq provided for local length without refSeq */);
-        assert(segment.seq !== undefined, 0x399 /* segment with no seq in mergeTree */);
-        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
-            if (segment.localSeq > localSeq ||
-                (localRemovedSeq !== undefined && localRemovedSeq <= localSeq) ||
-                (localMovedSeq !== undefined && localMovedSeq <= localSeq)) {
-                return 0;
-            }
-            const { cachedLength } = segment;
-            return cachedLength;
-        }
-        else {
-            // inserted remotely
-            if (seq > refSeq ||
-                (removedSeq !== undefined &&
-                    removedSeq !== UnassignedSequenceNumber &&
-                    removedSeq <= refSeq) ||
-                (movedSeq !== undefined &&
-                    movedSeq !== UnassignedSequenceNumber &&
-                    movedSeq <= refSeq) ||
-                (localRemovedSeq !== undefined && localRemovedSeq <= localSeq) ||
-                (localMovedSeq !== undefined && localMovedSeq <= localSeq)) {
-                return 0;
-            }
-            return segment.cachedLength;
+        if (removalInfo &&
+            getMinSeqPerspective(this.collabWindow).hasOccurred(removalInfo.removes[0])) {
+            // this segment's removal has already moved outside the collab window which means it is zamboni eligible
+            // this also means the segment could be completely absent from other client's in-memory merge trees,
+            // so we should not consider it when making decisions about conflict resolutions
+            return undefined;
         }
+        return perspective.isSegmentPresent(segment) ? segment.cachedLength : 0;
     }
     unlinkMarker(marker) {
         const id = marker.getId();
@@ -438,6 +390,7 @@ export class MergeTree {
         this.collabWindow.minSeq = minSeq;
         this.collabWindow.collaborating = true;
         this.collabWindow.currentSeq = currentSeq;
+        this.collabWindow.localPerspective = new LocalDefaultPerspective(localClientId);
         this.nodeUpdateLengthNewStructure(this.root, true);
     }
     addToLRUSet(leaf, seq) {
@@ -450,8 +403,8 @@ export class MergeTree {
             this.segmentsToScour.add({ segment: leaf, maxSeq: seq });
         }
     }
-    getLength(refSeq, clientId) {
-        return this.blockLength(this.root, refSeq, clientId);
+    getLength(perspective) {
+        return this.nodeLength(this.root, perspective) ?? 0;
     }
     /**
      * Returns the current length of the MergeTree for the local client.
@@ -459,7 +412,7 @@ export class MergeTree {
     get length() {
         return this.root.cachedLength;
     }
-    getPosition(node, refSeq, clientId, localSeq) {
+    getPosition(node, perspective) {
         if (node.isLeaf() && node.endpointType === "start") {
             return 0;
         }
@@ -473,15 +426,16 @@ export class MergeTree {
                 if ((!!prevParent && child === prevParent) || child === node) {
                     break;
                 }
-                totalOffset += this.nodeLength(child, refSeq, clientId, localSeq) ?? 0;
+                totalOffset += this.nodeLength(child, perspective) ?? 0;
             }
             prevParent = parent;
             parent = parent.parent;
         }
         return totalOffset;
     }
-    getContainingSegment(pos, refSeq, clientId, localSeq) {
-        assert(localSeq === undefined || clientId === this.collabWindow.clientId, 0x39b /* localSeq provided for non-local client */);
+    getContainingSegment(pos, perspective) {
+        assert(perspective.localSeq === undefined ||
+            perspective.clientId === this.collabWindow.clientId, 0x39b /* localSeq provided for non-local client */);
         let segment;
         let offset;
         const leaf = (leafSeg, _, start) => {
@@ -489,7 +443,7 @@ export class MergeTree {
             offset = start;
             return false;
         };
-        this.nodeMap(refSeq, clientId, leaf, undefined, pos, pos + 1, localSeq);
+        this.nodeMap(perspective, leaf, undefined, pos, pos + 1);
         return { segment, offset };
     }
     /**
@@ -582,7 +536,7 @@ export class MergeTree {
         const forwardSegmentCache = new Map();
         const backwardSegmentCache = new Map();
         for (const segment of segments) {
-            assert(isRemovedAndAckedOrMovedAndAcked(segment), 0x2f1 /* slideReferences from a segment which has not been removed and acked */);
+            assert(isRemovedAndAcked(segment), 0x2f1 /* slideReferences from a segment which has not been removed and acked */);
             if (segment.localRefs === undefined || segment.localRefs.empty) {
                 continue;
             }
@@ -602,11 +556,6 @@ export class MergeTree {
         slideGroup(currentForwardSlideDestination, currentForwardSlideIsForward, currentForwardSlideGroup, forwardPred, currentForwardMaybeEndpoint);
         slideGroup(currentBackwardSlideDestination, currentBackwardSlideIsForward, currentBackwardSlideGroup, backwardPred, currentBackwardMaybeEndpoint);
     }
-    blockLength(node, refSeq, clientId) {
-        return this.collabWindow.collaborating && clientId !== this.collabWindow.clientId
-            ? node.partialLengths.getPartialLength(refSeq, clientId)
-            : (node.cachedLength ?? 0);
-    }
     /**
      * Compute local partial length information
      *
@@ -624,62 +573,27 @@ export class MergeTree {
         this.root.partialLengths = PartialSequenceLengths.combine(this.root, rebaseCollabWindow, true, true);
         this.localPartialsComputed = true;
     }
-    nodeLength(node, refSeq, clientId, localSeq) {
-        if (!this.collabWindow.collaborating || this.collabWindow.clientId === clientId) {
-            if (node.isLeaf()) {
-                return this.localNetLength(node, refSeq, localSeq);
-            }
-            else if (localSeq === undefined ||
-                // All changes are visible. Small note on why we allow refSeq >= this.collabWindow.currentSeq rather than just equality:
-                // merge-tree eventing occurs before the collab window is updated to account for whatever op it is processing, and we want
-                // to support resolving positions from within the event handler which account for that op. e.g. undo-redo relies on this
-                // behavior with local references.
-                (localSeq === this.collabWindow.localSeq && refSeq >= this.collabWindow.currentSeq)) {
-                // Local client sees all segments, even when collaborating
-                return node.cachedLength;
-            }
-            else {
-                this.computeLocalPartials(refSeq);
-                // Local client should see all segments except those after localSeq.
-                const partialLen = node.partialLengths.getPartialLength(refSeq, clientId, localSeq);
-                PartialSequenceLengths.options.verifyExpected?.(this, node, refSeq, clientId, localSeq);
-                return partialLen;
-            }
-        }
-        else {
-            // Sequence number within window
-            if (node.isLeaf()) {
-                const segment = node;
-                const removalInfo = toRemovalInfo(segment);
-                const moveInfo = toMoveInfo(segment);
-                if (removalInfo !== undefined) {
-                    if (seqLTE(removalInfo.removedSeq, this.collabWindow.minSeq)) {
-                        return undefined;
-                    }
-                    if (seqLTE(removalInfo.removedSeq, refSeq) ||
-                        removalInfo.removedClientIds.includes(clientId)) {
-                        return 0;
-                    }
-                }
-                if (moveInfo !== undefined) {
-                    if (seqLTE(moveInfo.movedSeq, this.collabWindow.minSeq)) {
-                        return undefined;
-                    }
-                    if (seqLTE(moveInfo.movedSeq, refSeq) ||
-                        moveInfo.movedClientIds.includes(clientId)) {
-                        return 0;
-                    }
-                }
-                return seqLTE(node.seq ?? 0, refSeq) || segment.clientId === clientId
-                    ? segment.cachedLength
-                    : 0;
-            }
-            else {
-                const partialLen = node.partialLengths.getPartialLength(refSeq, clientId);
-                PartialSequenceLengths.options.verifyExpected?.(this, node, refSeq, clientId);
-                return partialLen;
-            }
-        }
+    nodeLength(node, perspective) {
+        if (node.isLeaf()) {
+            return this.leafLength(node, perspective);
+        }
+        const { refSeq, clientId, localSeq } = perspective;
+        const isLocalPerspective = !this.collabWindow.collaborating || this.collabWindow.clientId === clientId;
+        if (isLocalPerspective &&
+            (localSeq === undefined ||
+                (localSeq === this.collabWindow.localSeq && refSeq >= this.collabWindow.currentSeq))) {
+            // All changes are visible. Small note on why we allow refSeq >= this.collabWindow.currentSeq rather than just equality:
+            // merge-tree eventing occurs before the collab window is updated to account for whatever op it is processing, and we want
+            // to support resolving positions from within the event handler which account for that op. e.g. undo-redo relies on this
+            // behavior with local references.
+            return node.cachedLength;
+        }
+        if (localSeq !== undefined) {
+            this.computeLocalPartials(refSeq);
+        }
+        const length = node.partialLengths.getPartialLength(refSeq, clientId, localSeq);
+        PartialSequenceLengths.options.verifyExpected?.(this, node, refSeq, clientId, localSeq);
+        return length;
     }
     setMinSeq(minSeq) {
         assert(minSeq <= this.collabWindow.currentSeq, 0x04e /* "Trying to set minSeq above currentSeq of collab window!" */);
@@ -705,44 +619,61 @@ export class MergeTree {
     referencePositionToLocalPosition(refPos, 
     // Note: this is not `this.collabWindow.currentSeq` because we want to support resolving local reference positions to positions
     // from within event handlers, and the collab window's sequence numbers are not updated in time in all of those cases.
-    refSeq = Number.MAX_SAFE_INTEGER, clientId = this.collabWindow.clientId, localSeq = this.collabWindow.localSeq) {
+    refSeq = Number.MAX_SAFE_INTEGER, clientId = this.collabWindow.clientId, localSeq = undefined) {
         const perspective = clientId === this.collabWindow.clientId
             ? localSeq === undefined
                 ? this.localPerspective
                 : new LocalReconnectingPerspective(refSeq, clientId, localSeq)
             : new PriorPerspective(refSeq, clientId);
         const seg = refPos.getSegment();
-        if (!isSegmentLeaf(seg)) {
+        if (seg === undefined || !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(seg, refSeq, clientId, localSeq);
+            return this.getPosition(seg, perspective);
         }
         if (refTypeIncludesFlag(refPos, ReferenceType.Transient) || seg.localRefs?.has(refPos)) {
             if (seg !== this.startOfTree &&
                 seg !== this.endOfTree &&
                 !perspective.isSegmentPresent(seg)) {
                 const forward = refPos.slidingPreference === SlidingPreference.FORWARD;
-                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 = moveInfo?.localMovedSeq ?? removeInfo?.localRemovedSeq;
-                const slidePerspective = slideLocalSeq === undefined
+                const firstRemove = removeInfo?.removes[0];
+                const slideSeq = firstRemove !== undefined && opstampUtils.isAcked(firstRemove)
+                    ? firstRemove.seq
+                    : refSeq;
+                const slidePerspective = firstRemove?.localSeq === undefined
                     ? new PriorPerspective(slideSeq, this.collabWindow.clientId)
-                    : new LocalReconnectingPerspective(slideSeq, this.collabWindow.clientId, slideLocalSeq);
-                const slidSegment = slidePerspective.nextSegment(this, seg, forward);
-                return (this.getPosition(slidSegment, refSeq, clientId, localSeq) +
+                    : new LocalReconnectingPerspective(slideSeq, this.collabWindow.clientId, firstRemove.localSeq);
+                const slidSegment = this.nextSegment(slidePerspective, seg, forward);
+                return (this.getPosition(slidSegment, perspective) +
                     (forward ? 0 : slidSegment.cachedLength === 0 ? 0 : slidSegment.cachedLength - 1));
             }
-            return this.getPosition(seg, refSeq, clientId, localSeq) + refPos.getOffset();
+            return this.getPosition(seg, perspective) + refPos.getOffset();
         }
         return DetachedReferencePosition;
     }
+    /**
+     * Returns the immediately adjacent segment in the specified direction from this perspective.
+     * There may actually be multiple segments between the given segment and the returned segment,
+     * but they were either inserted after this perspective, or have been removed before this perspective.
+     *
+     * @param segment - The segment to start from.
+     * @param forward - The direction to search.
+     * @returns the next segment in the specified direction, or the start or end of the tree if there is no next segment.
+     */
+    nextSegment(perspective, segment, forward = true) {
+        let next;
+        const action = (seg) => {
+            if (perspective.isSegmentPresent(seg)) {
+                next = seg;
+                return LeafAction.Exit;
+            }
+        };
+        (forward ? forwardExcursion : backwardExcursion)(segment, action);
+        return next ?? (forward ? this.endOfTree : this.startOfTree);
+    }
     /**
      * Finds the nearest reference with ReferenceType.Tile to `startPos` in the direction dictated by `forwards`.
      * Uses depthFirstNodeWalk in addition to block-accelerated functionality. The search position will be included in
@@ -755,9 +686,9 @@ export class MergeTree {
      * @param markerLabel - Label of the marker to search for
      * @param forwards - Whether the string should be searched in the forward or backward direction
      */
-    searchForMarker(startPos, clientId, markerLabel, forwards = true) {
+    searchForMarker(startPos, markerLabel, forwards = true) {
         let foundMarker;
-        const { segment } = this.getContainingSegment(startPos, UniversalSequenceNumber, clientId);
+        const { segment } = this.getContainingSegment(startPos, this.localPerspective);
         if (!isSegmentLeaf(segment)) {
             return undefined;
         }
@@ -781,14 +712,12 @@ export class MergeTree {
         return foundMarker;
     }
     updateRoot(splitNode) {
-        if (splitNode !== undefined) {
-            const newRoot = this.makeBlock(2);
-            assignChild(newRoot, this.root, 0, false);
-            assignChild(newRoot, splitNode, 1, false);
-            this.root = newRoot;
-            this.nodeUpdateOrdinals(this.root);
-            this.nodeUpdateLengthNewStructure(this.root);
-        }
+        const newRoot = this.makeBlock(2);
+        assignChild(newRoot, this.root, 0, false);
+        assignChild(newRoot, splitNode, 1, false);
+        this.root = newRoot;
+        this.nodeUpdateOrdinals(this.root);
+        this.nodeUpdateLengthNewStructure(this.root);
     }
     /**
      * Assign sequence number to existing segment; update partial lengths to reflect the change
@@ -796,6 +725,10 @@ export class MergeTree {
      */
     ackPendingSegment(opArgs) {
         const seq = opArgs.sequencedMessage.sequenceNumber;
+        const stamp = {
+            seq,
+            clientId: this.collabWindow.clientId,
+        };
         const pendingSegmentGroup = this.pendingSegments.shift()?.data;
         const nodesToUpdate = [];
         let overwrite = false;
@@ -803,8 +736,8 @@ export class MergeTree {
             const deltaSegments = [];
             const overlappingRemoves = [];
             pendingSegmentGroup.segments.map((pendingSegment) => {
-                const overlappingRemove = !ackSegment(pendingSegment, pendingSegmentGroup, opArgs);
-                overwrite ||= overlappingRemove || toMoveInfo(pendingSegment) !== undefined;
+                const overlappingRemove = !ackSegment(pendingSegment, pendingSegmentGroup, opArgs, stamp);
+                overwrite ||= overlappingRemove;
                 overlappingRemoves.push(overlappingRemove);
                 if (MergeTree.options.zamboniSegments) {
                     this.addToLRUSet(pendingSegment, seq);
@@ -817,7 +750,7 @@ export class MergeTree {
                 });
             });
             if (pendingSegmentGroup.obliterateInfo !== undefined) {
-                pendingSegmentGroup.obliterateInfo.seq = seq;
+                pendingSegmentGroup.obliterateInfo.stamp = { type: "sliceRemove", ...stamp };
                 this.obliterates.addOrUpdate(pendingSegmentGroup.obliterateInfo);
             }
             // Perform slides after all segments have been acked, so that
@@ -831,9 +764,8 @@ export class MergeTree {
                 deltaSegments,
                 operation: MergeTreeMaintenanceType.ACKNOWLEDGED,
             }, opArgs);
-            const clientId = this.collabWindow.clientId;
             for (const node of nodesToUpdate) {
-                this.blockUpdatePathLengths(node, seq, clientId, overwrite);
+                this.blockUpdatePathLengths(node, stamp, overwrite);
             }
         }
         if (MergeTree.options.zamboniSegments) {
@@ -867,11 +799,7 @@ export class MergeTree {
     // TODO: error checking
     getMarkerFromId(id) {
         const marker = this.idToMarker.get(id);
-        return marker === undefined ||
-            isRemoved(marker) ||
-            (isMoved(marker) && marker.moveDst === undefined)
-            ? undefined
-            : marker;
+        return marker === undefined || isRemoved(marker) ? undefined : marker;
     }
     /**
      * Given a position specified relative to a marker id, lookup the marker
@@ -880,14 +808,14 @@ export class MergeTree {
      * @param refseq - The reference sequence number at which to compute the position.
      * @param clientId - The client id with which to compute the position.
      */
-    posFromRelativePos(relativePos, refseq = this.collabWindow.currentSeq, clientId = this.collabWindow.clientId) {
+    posFromRelativePos(relativePos, perspective) {
         let pos = -1;
         let marker;
         if (relativePos.id) {
             marker = this.getMarkerFromId(relativePos.id);
         }
         if (isSegmentLeaf(marker)) {
-            pos = this.getPosition(marker, refseq, clientId);
+            pos = this.getPosition(marker, perspective);
             if (relativePos.before) {
                 if (relativePos.offset !== undefined) {
                     pos -= relativePos.offset;
@@ -902,14 +830,14 @@ export class MergeTree {
         }
         return pos;
     }
-    insertSegments(pos, segments, refSeq, clientId, seq, opArgs) {
-        this.ensureIntervalBoundary(pos, refSeq, clientId);
-        const localSeq = seq === UnassignedSequenceNumber ? ++this.collabWindow.localSeq : undefined;
-        this.blockInsert(pos, refSeq, clientId, seq, localSeq, segments);
+    insertSegments(pos, segments, perspective, stampArg, opArgs) {
+        const stamp = { ...stampArg, type: "insert" };
+        this.ensureIntervalBoundary(pos, perspective);
+        this.blockInsert(pos, perspective, stamp, segments);
         // opArgs == undefined => loading snapshot or test code
         if (opArgs !== undefined) {
             const deltaSegments = segments
-                .filter((segment) => !toMoveInfo(segment))
+                .filter((segment) => !isRemoved(segment))
                 .map((segment) => ({ segment }));
             if (deltaSegments.length > 0) {
                 this.mergeTreeDeltaCallback?.(opArgs, {
@@ -920,7 +848,7 @@ export class MergeTree {
         }
         if (this.collabWindow.collaborating &&
             MergeTree.options.zamboniSegments &&
-            seq !== UnassignedSequenceNumber) {
+            opstampUtils.isAcked(stamp)) {
             zamboniSegments(this);
         }
     }
@@ -942,19 +870,19 @@ export class MergeTree {
         if (remoteClientRefSeq < this.collabWindow.minSeq) {
             return undefined;
         }
-        const segmentInfo = this.getContainingSegment(remoteClientPosition, remoteClientRefSeq, remoteClientId);
-        const { currentSeq, clientId } = this.collabWindow;
+        const remotePerspective = new PriorPerspective(remoteClientRefSeq, remoteClientId);
+        const segmentInfo = this.getContainingSegment(remoteClientPosition, remotePerspective);
         if (isSegmentLeaf(segmentInfo?.segment)) {
-            const segmentPosition = this.getPosition(segmentInfo.segment, currentSeq, clientId);
+            const segmentPosition = this.getPosition(segmentInfo.segment, this.localPerspective);
             return segmentPosition + segmentInfo.offset;
         }
         else {
-            if (remoteClientPosition === this.getLength(remoteClientRefSeq, remoteClientId)) {
-                return this.getLength(currentSeq, clientId);
+            if (remoteClientPosition === this.getLength(remotePerspective)) {
+                return this.getLength(this.localPerspective);
             }
         }
     }
-    blockInsert(pos, refSeq, clientId, seq, localSeq, newSegments) {
+    blockInsert(pos, perspective, stamp, newSegments) {
         // Keeping this function within the scope of blockInsert for readability.
         // eslint-disable-next-line unicorn/consistent-function-scoping
         const continueFrom = (node) => {
@@ -969,16 +897,16 @@ export class MergeTree {
         const saveIfLocal = (locSegment) => {
             // Save segment so we can assign sequence number when acked by server
             if (this.collabWindow.collaborating) {
-                if (locSegment.seq === UnassignedSequenceNumber &&
-                    clientId === this.collabWindow.clientId) {
-                    segmentGroup = this.addToPendingList(locSegment, segmentGroup, localSeq);
+                if (opstampUtils.isLocal(locSegment.insert) &&
+                    stamp.clientId === this.collabWindow.clientId) {
+                    segmentGroup = this.addToPendingList(locSegment, segmentGroup, stamp.localSeq);
                 }
                 // LocSegment.seq === 0 when coming from SharedSegmentSequence.loadBody()
                 // In all other cases this has to be true (checked by addToLRUSet):
                 // locSegment.seq > this.collabWindow.currentSeq
-                else if (locSegment.seq > this.collabWindow.minSeq &&
-                    MergeTree.options.zamboniSegments) {
-                    this.addToLRUSet(locSegment, locSegment.seq);
+                else if (MergeTree.options.zamboniSegments &&
+                    opstampUtils.greaterThan(locSegment.insert, getMinSeqStamp(this.collabWindow))) {
+                    this.addToLRUSet(locSegment, locSegment.insert.seq);
                 }
             }
         };
@@ -994,85 +922,71 @@ 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
             .filter((s) => s.cachedLength > 0)
-            .map((s) => overwriteInfo(s, insertInfo))) {
+            .map((s) => overwriteInfo(s, { insert: stamp }))) {
             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, {
+            this.insertingWalk(insertPos, perspective, stamp, {
                 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;
+                const errorConstructor = stamp.localSeq === undefined ? DataProcessingError : UsageError;
                 throw new errorConstructor("MergeTree insert failed", {
                     currentSeq: this.collabWindow.currentSeq,
                     minSeq: this.collabWindow.minSeq,
-                    segSeq: insertInfo.seq,
+                    segSeq: stamp.seq,
                 });
             }
-            this.updateRoot(splitNode);
             insertPos += newSegment.cachedLength;
             if (!this.options?.mergeTreeEnableObliterate || this.obliterates.empty()) {
                 saveIfLocal(newSegment);
                 continue;
             }
+            const overlappingAckedObliterates = [];
             let oldest;
-            let normalizedOldestSeq = 0;
             let newest;
-            let normalizedNewestSeq = 0;
-            const movedClientIds = [];
-            const movedSeqs = [];
             let newestAcked;
             let oldestUnacked;
+            const refSeqStamp = {
+                seq: perspective.refSeq,
+                clientId: stamp.clientId,
+                localSeq: stamp.localSeq,
+            };
             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 (opstampUtils.greaterThan(ob.stamp, refSeqStamp)) {
                     // Any obliterate from the same client that's inserting this segment cannot cause the segment to be marked as
                     // obliterated (since that client must have performed the obliterate before this insertion).
                     // We still need to consider such obliterates when determining the winning obliterate for the insertion point,
                     // see `obliteratePrecedingInsertion` docs.
-                    if (clientId !== ob.clientId) {
-                        if (oldest === undefined || normalizedOldestSeq > normalizedObSeq) {
-                            normalizedOldestSeq = normalizedObSeq;
-                            oldest = ob;
-                            movedClientIds.unshift(ob.clientId);
-                            movedSeqs.unshift(ob.seq);
+                    if (stamp.clientId !== ob.stamp.clientId) {
+                        if (opstampUtils.isAcked(ob.stamp)) {
+                            overlappingAckedObliterates.push(ob.stamp);
                         }
-                        else {
-                            movedClientIds.push(ob.clientId);
-                            movedSeqs.push(ob.seq);
+                        if (oldest === undefined || opstampUtils.lessThan(ob.stamp, oldest.stamp)) {
+                            oldest = ob;
                         }
                     }
-                    if (newest === undefined || normalizedNewestSeq < normalizedObSeq) {
-                        normalizedNewestSeq = normalizedObSeq;
+                    if (newest === undefined || opstampUtils.greaterThan(ob.stamp, newest.stamp)) {
                         newest = ob;
                     }
-                    if (ob.seq !== UnassignedSequenceNumber &&
-                        (newestAcked === undefined || newestAcked.seq < ob.seq)) {
+                    if (opstampUtils.isAcked(ob.stamp) &&
+                        (newestAcked === undefined ||
+                            opstampUtils.greaterThan(ob.stamp, newestAcked.stamp))) {
                         newestAcked = ob;
                     }
-                    if (ob.seq === UnassignedSequenceNumber &&
-                        (oldestUnacked === undefined || oldestUnacked.localSeq > ob.localSeq)) {
+                    if (opstampUtils.isLocal(ob.stamp) &&
+                        (oldestUnacked === undefined ||
+                            opstampUtils.greaterThan(oldestUnacked.stamp, ob.stamp))) {
                         // There can be one local obliterate surrounding a segment if a client repeatedly obliterates
                         // a region (ex: in the text ABCDEFG, obliterate D, then obliterate CE, then BF). In this case,
                         // the first one that's applied will be the one that actually removes the segment.
@@ -1084,32 +998,20 @@ export class MergeTree {
             // See doc comment on obliteratePrecedingInsertion for more details: if the newest obliterate was performed
             // by the same client that's inserting this segment, we let them insert into this range and therefore don't
             // mark it obliterated.
-            if (oldest && newest?.clientId !== clientId) {
-                let moveInfo;
-                if (newestAcked === newest || newestAcked?.clientId !== clientId) {
-                    moveInfo = {
-                        movedClientIds,
-                        movedSeq: oldest.seq,
-                        movedSeqs,
-                        localMovedSeq: oldestUnacked?.localSeq,
-                    };
-                }
-                else {
-                    assert(oldestUnacked !== undefined, 0xb55 /* Expected local obliterate to be defined if newestAcked is not equal to newest */);
-                    // There's a pending local obliterate for this range, so it will be marked as obliterated by us. However,
-                    // all other clients are under the impression that the most recent acked obliterate won the right to insert
-                    // in this range.
-                    moveInfo = {
-                        movedClientIds: [oldestUnacked.clientId],
-                        movedSeq: oldestUnacked.seq,
-                        movedSeqs: [oldestUnacked.seq],
-                        localMovedSeq: oldestUnacked.localSeq,
-                    };
+            if (oldest && newest?.stamp.clientId !== stamp.clientId) {
+                const removeInfo = { removes: [] };
+                if (newestAcked === newest || newestAcked?.stamp.clientId !== stamp.clientId) {
+                    removeInfo.removes = overlappingAckedObliterates;
+                    // Because we found these by looking at overlapping obliterates, they are not necessarily currently sorted by seq.
+                    // Address that now.
+                    removeInfo.removes.sort(opstampUtils.compare);
                 }
-                overwriteInfo(newSegment, moveInfo);
-                if (moveInfo.localMovedSeq !== undefined) {
-                    assert(oldestUnacked?.segmentGroup !== undefined, 0x86c /* expected segment group to exist */);
-                    this.addToPendingList(newSegment, oldestUnacked?.segmentGroup);
+                // Note that we don't need to worry about preserving any existing remove information since the segment is new.
+                overwriteInfo(newSegment, removeInfo);
+                if (oldestUnacked !== undefined) {
+                    removeInfo.removes.push(oldestUnacked.stamp);
+                    assert(oldestUnacked.segmentGroup !== undefined, 0x86c /* expected segment group to exist */);
+                    this.addToPendingList(newSegment, oldestUnacked.segmentGroup);
                 }
                 if (newSegment.parent) {
                     // The incremental update codepath in theory can handle most cases where segments are obliterated upon insertion,
@@ -1117,90 +1019,95 @@ export class MergeTree {
                     // lengths inside the inserting walk, we'd be at risk of double-counting the insertion in any case if we allow
                     // incremental updates here.
                     const newStructure = true;
-                    this.blockUpdatePathLengths(newSegment.parent, moveInfo.movedSeq, clientId, newStructure);
+                    this.blockUpdatePathLengths(newSegment.parent, removeInfo.removes[0], newStructure);
                 }
             }
             saveIfLocal(newSegment);
         }
     }
-    ensureIntervalBoundary(pos, refSeq, clientId) {
-        const splitNode = this.insertingWalk(this.root, pos, refSeq, clientId, TreeMaintenanceSequenceNumber, { leaf: this.splitLeafSegment });
-        this.updateRoot(splitNode);
+    ensureIntervalBoundary(pos, perspective) {
+        this.insertingWalk(pos, perspective, {
+            seq: TreeMaintenanceSequenceNumber,
+            clientId: perspective.clientId,
+        }, { leaf: this.splitLeafSegment });
     }
     // Assume called only when pos == len
-    breakTie(pos, node, seq) {
+    breakTie(pos, node, insertStamp) {
         if (node.isLeaf()) {
             if (pos !== 0) {
                 return false;
             }
-            // normalize the seq numbers
-            // if the new seg is local (UnassignedSequenceNumber) give it the highest possible
-            // seq for comparison, as it will get a seq higher than any other seq once sequences
-            // if the current seg is local (UnassignedSequenceNumber) give it the second highest
-            // possible seq, as the highest is reserved for the previous.
-            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 ||
-                (isMoved(node) && node.movedSeq !== UnassignedSequenceNumber && node.movedSeq > seq) ||
+            return (opstampUtils.greaterThan(insertStamp, node.insert) ||
                 (isRemoved(node) &&
-                    node.removedSeq !== UnassignedSequenceNumber &&
-                    node.removedSeq > seq));
+                    opstampUtils.isAcked(node.removes[0]) &&
+                    opstampUtils.greaterThan(node.removes[0], insertStamp)));
         }
         else {
             return true;
         }
     }
-    insertingWalk(block, pos, refSeq, clientId, seq, context, isLastChildBlock = true) {
+    insertingWalk(pos, perspective, stamp, context) {
+        const { remainder } = this.insertRecursive(this.root, pos, perspective, stamp, context);
+        if (remainder !== undefined) {
+            this.updateRoot(remainder);
+        }
+    }
+    insertRecursive(block, pos, perspective, stamp, context, isLastChildBlock = true) {
         let _pos = pos;
         const children = block.children;
         let childIndex;
         let child;
         let newNode;
         let fromSplit;
+        let hadChanges = false;
         for (childIndex = 0; childIndex < block.childCount; childIndex++) {
             child = children[childIndex];
             // ensure we walk down the far edge of the tree, even if all sub-tree is eligible for zamboni
             const isLastNonLeafBlock = isLastChildBlock && !child.isLeaf() && childIndex === block.childCount - 1;
-            const len = this.nodeLength(child, refSeq, clientId) ?? (isLastChildBlock ? 0 : undefined);
+            const len = this.nodeLength(child, perspective) ?? (isLastChildBlock ? 0 : undefined);
             if (len === undefined) {
                 // if the seg len is undefined, the segment
                 // will be removed, so should just be skipped for now
                 continue;
             }
             assert(len >= 0, 0x4bc /* Length should not be negative */);
-            if (_pos < len || (_pos === len && this.breakTie(_pos, child, seq))) {
+            if (_pos < len || (_pos === len && this.breakTie(_pos, child, stamp))) {
                 // Found entry containing pos
                 if (child.isLeaf()) {
                     const segment = child;
                     const segmentChanges = context.leaf(segment, _pos, context);
                     if (segmentChanges.replaceCurrent) {
+                        hadChanges = true;
                         assignChild(block, segmentChanges.replaceCurrent, childIndex, false);
                         segmentChanges.replaceCurrent.ordinal = child.ordinal;
                     }
                     if (segmentChanges.next) {
+                        hadChanges = true;
                         newNode = segmentChanges.next;
                         childIndex++; // Insert after
                     }
                     else {
-                        // No change
-                        return undefined;
+                        return { remainder: undefined, hadChanges };
                     }
                 }
                 else {
                     const childBlock = child;
                     // Internal node
-                    const splitNode = this.insertingWalk(childBlock, _pos, refSeq, clientId, seq, context, isLastNonLeafBlock);
-                    if (splitNode === undefined) {
-                        this.blockUpdateLength(block, seq, clientId);
-                        return undefined;
+                    const insertResult = this.insertRecursive(childBlock, _pos, perspective, stamp, context, isLastNonLeafBlock);
+                    hadChanges ||= insertResult.hadChanges;
+                    if (insertResult.remainder === undefined) {
+                        if (insertResult.hadChanges) {
+                            this.blockUpdateLength(block, stamp);
+                        }
+                        return insertResult;
                     }
-                    else if (splitNode === MergeTree.theUnfinishedNode) {
+                    else if (insertResult.remainder === MergeTree.theUnfinishedNode) {
                         _pos -= len; // Act as if shifted segment
                         continue;
                     }
                     else {
-                        newNode = splitNode;
-                        fromSplit = splitNode;
+                        newNode = insertResult.remainder;
+                        fromSplit = insertResult.remainder;
                         childIndex++; // Insert after
                     }
                 }
@@ -1212,7 +1119,7 @@ export class MergeTree {
         }
         if (!newNode && _pos === 0) {
             if (context.continuePredicate?.(block)) {
-                return MergeTree.theUnfinishedNode;
+                return { remainder: MergeTree.theUnfinishedNode, hadChanges };
             }
             else {
                 const segmentChanges = context.leaf(undefined, _pos, context);
@@ -1221,6 +1128,7 @@ export class MergeTree {
             }
         }
         if (newNode) {
+            hadChanges = true;
             for (let i = block.childCount; i > childIndex; i--) {
                 block.children[i] = block.children[i - 1];
                 block.children[i].index = i;
@@ -1232,19 +1140,19 @@ export class MergeTree {
                 if (fromSplit) {
                     this.nodeUpdateOrdinals(fromSplit);
                 }
-                this.blockUpdateLength(block, seq, clientId);
-                return undefined;
+                this.blockUpdateLength(block, stamp);
+                return { remainder: undefined, hadChanges };
             }
             else {
                 // Don't update ordinals because higher block will do it
                 const newNodeFromSplit = this.split(block);
-                PartialSequenceLengths.options.verifyExpected?.(this, block, refSeq, clientId);
-                PartialSequenceLengths.options.verifyExpected?.(this, newNodeFromSplit, refSeq, clientId);
-                return newNodeFromSplit;
+                PartialSequenceLengths.options.verifyExpected?.(this, block, perspective.refSeq, stamp.clientId);
+                PartialSequenceLengths.options.verifyExpected?.(this, newNodeFromSplit, perspective.refSeq, stamp.clientId);
+                return { remainder: newNodeFromSplit, hadChanges };
             }
         }
         else {
-            return undefined;
+            return { remainder: undefined, hadChanges };
         }
     }
     split(node) {
@@ -1279,16 +1187,14 @@ export class MergeTree {
      * @param clientId - The id of the client making the annotate
      * @param seq - The sequence number of the annotate operation
      * @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, rollback = PropertiesRollback.None) {
+    annotateRange(start, end, propsOrAdjust, perspective, stamp, opArgs) {
         if (propsOrAdjust.adjust !== undefined) {
             errorIfOptionNotTrue(this.options, "mergeTreeEnableAnnotateAdjust");
         }
-        this.ensureIntervalBoundary(start, refSeq, clientId);
-        this.ensureIntervalBoundary(end, refSeq, clientId);
+        this.ensureIntervalBoundary(start, perspective);
+        this.ensureIntervalBoundary(end, perspective);
         const deltaSegments = [];
-        const localSeq = seq === UnassignedSequenceNumber ? ++this.collabWindow.localSeq : undefined;
         let segmentGroup;
         const opObj = propsOrAdjust.props ?? propsOrAdjust.adjust;
         const annotateSegment = (segment) => {
@@ -1296,23 +1202,23 @@ export class MergeTree {
                 !(reservedMarkerIdKey in opObj) ||
                 opObj.markerId === segment.properties?.markerId, 0x5ad /* Cannot change the markerId of an existing marker */);
             const propertyManager = (segment.propertyManager ??= new PropertiesManager());
-            const propertyDeltas = propertyManager.handleProperties(propsOrAdjust, segment, seq, this.collabWindow.minSeq, this.collabWindow.collaborating, rollback);
-            if (!isRemovedOrMoved(segment)) {
+            const propertyDeltas = propertyManager.handleProperties(propsOrAdjust, segment, stamp.seq, this.collabWindow.minSeq, this.collabWindow.collaborating, opArgs?.rollback === true);
+            if (!isRemoved(segment)) {
                 deltaSegments.push({ segment, propertyDeltas });
             }
             if (this.collabWindow.collaborating) {
-                if (seq === UnassignedSequenceNumber) {
-                    segmentGroup = this.addToPendingList(segment, segmentGroup, localSeq, propertyDeltas);
+                if (opstampUtils.isLocal(stamp)) {
+                    segmentGroup = this.addToPendingList(segment, segmentGroup, stamp.localSeq, propertyDeltas);
                 }
                 else {
                     if (MergeTree.options.zamboniSegments) {
-                        this.addToLRUSet(segment, seq);
+                        this.addToLRUSet(segment, stamp.seq);
                     }
                 }
             }
             return true;
         };
-        this.nodeMap(refSeq, clientId, annotateSegment, undefined, start, end);
+        this.nodeMap(perspective, annotateSegment, undefined, start, end);
         // OpArgs == undefined => test code
         if (deltaSegments.length > 0) {
             this.mergeTreeDeltaCallback?.(opArgs, {
@@ -1321,34 +1227,28 @@ export class MergeTree {
             });
         }
         if (this.collabWindow.collaborating &&
-            seq !== UnassignedSequenceNumber &&
+            opstampUtils.isAcked(stamp) &&
             MergeTree.options.zamboniSegments) {
             zamboniSegments(this);
         }
     }
-    obliterateRangeSided(start, end, refSeq, clientId, seq, opArgs) {
+    obliterateRangeSided(start, end, perspective, stamp, opArgs) {
         const startPos = start.side === Side.Before ? start.pos : start.pos + 1;
         const endPos = end.side === Side.Before ? end.pos : end.pos + 1;
-        this.ensureIntervalBoundary(startPos, refSeq, clientId);
-        this.ensureIntervalBoundary(endPos, refSeq, clientId);
+        this.ensureIntervalBoundary(startPos, perspective);
+        this.ensureIntervalBoundary(endPos, perspective);
         let _overwrite = false;
         const localOverlapWithRefs = [];
-        const movedSegments = [];
-        const localSeq = seq === UnassignedSequenceNumber ? ++this.collabWindow.localSeq : undefined;
-        const perspective = seq === UnassignedSequenceNumber
-            ? this.localPerspective
-            : new PriorPerspective(refSeq, clientId);
+        const removedSegments = [];
         const obliterate = {
-            clientId,
-            end: createDetachedLocalReferencePosition(undefined),
-            refSeq,
-            seq,
             start: createDetachedLocalReferencePosition(undefined),
-            localSeq,
+            end: createDetachedLocalReferencePosition(undefined),
+            refSeq: perspective.refSeq,
+            stamp,
             segmentGroup: undefined,
         };
-        const { segment: startSeg } = this.getContainingSegment(start.pos, refSeq, clientId);
-        const { segment: endSeg } = this.getContainingSegment(end.pos, refSeq, clientId);
+        const { segment: startSeg } = this.getContainingSegment(start.pos, perspective);
+        const { segment: endSeg } = this.getContainingSegment(end.pos, perspective);
         assert(isSegmentLeaf(startSeg) && isSegmentLeaf(endSeg), 0xa3f /* segments cannot be undefined */);
         obliterate.start = this.createLocalReferencePosition(startSeg, start.side === Side.Before ? 0 : Math.max(startSeg.cachedLength - 1, 0), ReferenceType.StayOnRemove, {
             obliterate,
@@ -1362,15 +1262,15 @@ export class MergeTree {
         // at which point they are added to the segment group.
         obliterate.segmentGroup = {
             segments: [],
-            localSeq,
+            localSeq: stamp.localSeq,
             refSeq: this.collabWindow.currentSeq,
             obliterateInfo: obliterate,
         };
-        if (this.collabWindow.collaborating && clientId === this.collabWindow.clientId) {
+        if (this.collabWindow.collaborating && stamp.clientId === this.collabWindow.clientId) {
             this.pendingSegments.push(obliterate.segmentGroup);
         }
         this.obliterates.addOrUpdate(obliterate);
-        const markMoved = (segment, pos) => {
+        const markRemoved = (segment, pos) => {
             if ((start.side === Side.After && startPos === pos + segment.cachedLength) || // exclusive start segment
                 (end.side === Side.Before && endPos === pos && perspective.isSegmentPresent(segment)) // exclusive end segment
             ) {
@@ -1378,173 +1278,136 @@ export class MergeTree {
                 // These segments are outside of the obliteration range though, so return true to keep walking.
                 return true;
             }
-            const existingMoveInfo = toMoveInfo(segment);
+            const existingRemoveInfo = toRemovalInfo(segment);
             // The "last-to-obliterate-gets-to-insert" policy described by the doc comment on `obliteratePrecedingInsertion`
             // is mostly handled by logic at insertion time, but we need a small bit of handling here.
             // Specifically, we want to avoid marking a local-only segment as obliterated when we know one of our own local obliterates
             // will win against the obliterate we're processing, hence the early exit.
-            if (segment.seq === UnassignedSequenceNumber &&
-                segment.obliteratePrecedingInsertion?.seq === UnassignedSequenceNumber &&
-                seq !== UnassignedSequenceNumber) {
+            if (opstampUtils.isLocal(segment.insert) &&
+                segment.obliteratePrecedingInsertion?.stamp.seq === UnassignedSequenceNumber &&
+                opstampUtils.isAcked(stamp)) {
                 // 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;
             }
             // Partial lengths incrementality is not supported for overlapping obliterate/removes.
-            _overwrite ||= existingMoveInfo !== undefined || toRemovalInfo(segment) !== undefined;
-            if (existingMoveInfo === undefined) {
-                const movedSeg = overwriteInfo(segment, {
-                    movedClientIds: [clientId],
-                    movedSeq: seq,
-                    localMovedSeq: localSeq,
-                    movedSeqs: [seq],
+            _overwrite ||= existingRemoveInfo !== undefined;
+            // - Record the segment as removed
+            // - If this was the first thing to remove the segment from the local view, add it to removedSegments
+            // - Otherwise, if it was the first thing to remove the segment from the acked view, add it to localOverlapWithRefs (so we can slide them)
+            if (existingRemoveInfo === undefined) {
+                const removed = overwriteInfo(segment, {
+                    removes: [stamp],
                 });
-                const existingRemoval = toRemovalInfo(movedSeg);
-                if (existingRemoval === undefined) {
-                    movedSegments.push(movedSeg);
-                }
-                else if (existingRemoval.removedSeq === UnassignedSequenceNumber &&
-                    segment.localRefs?.empty === false) {
-                    // We removed this locally already so we don't need to event it again, but it might have references
-                    // that need sliding now that a move may have been acked.
-                    localOverlapWithRefs.push(segment);
-                }
+                removedSegments.push(removed);
             }
             else {
-                if (existingMoveInfo.movedSeq === UnassignedSequenceNumber) {
-                    assert(!wasMovedOnInsert(segment), 0xab4 /* Local obliterate cannot have removed a segment as soon as it was inserted */);
-                    assert(seq !== UnassignedSequenceNumber, 0xab5 /* Cannot obliterate the same segment locally twice */);
-                    // we moved this locally, but someone else moved it first
-                    // so put them at the head of the list
-                    // The list isn't ordered, but we keep the first move at the head
-                    // for partialLengths bookkeeping purposes
-                    existingMoveInfo.movedClientIds.unshift(clientId);
-                    existingMoveInfo.movedSeq = seq;
-                    existingMoveInfo.movedSeqs.unshift(seq);
-                    if (segment.localRefs?.empty === false) {
-                        localOverlapWithRefs.push(segment);
-                    }
-                }
-                else {
-                    // Do not replace earlier sequence number for move
-                    existingMoveInfo.movedClientIds.push(clientId);
-                    existingMoveInfo.movedSeqs.push(seq);
+                // The segment has already been removed, so we don't need to add it to removedSegments. However,
+                // if it's only been removed locally, we still need to slide any references that may exist on it.
+                if (!opstampUtils.hasAnyAckedOperation(existingRemoveInfo.removes) &&
+                    segment.localRefs?.empty === false) {
+                    localOverlapWithRefs.push(segment);
                 }
+                opstampUtils.spliceIntoList(existingRemoveInfo.removes, stamp);
             }
-            assertMoved(segment);
-            // Save segment so can assign moved sequence number when acked by server
+            assertRemoved(segment);
+            // Save segment so can assign sequence number when acked by server
             if (this.collabWindow.collaborating) {
-                if (segment.movedSeq === UnassignedSequenceNumber &&
-                    clientId === this.collabWindow.clientId) {
-                    obliterate.segmentGroup = this.addToPendingList(segment, obliterate.segmentGroup, localSeq);
+                if (opstampUtils.isLocal(segment.removes[0]) &&
+                    stamp.clientId === this.collabWindow.clientId) {
+                    obliterate.segmentGroup = this.addToPendingList(segment, obliterate.segmentGroup, stamp.localSeq);
                 }
                 else {
                     if (MergeTree.options.zamboniSegments) {
-                        this.addToLRUSet(segment, seq);
+                        this.addToLRUSet(segment, stamp.seq);
                     }
                 }
             }
             return true;
         };
-        const afterMarkMoved = (node) => {
+        const afterMarkRemoved = (node) => {
             if (_overwrite) {
                 this.nodeUpdateLengthNewStructure(node);
             }
             else {
-                this.blockUpdateLength(node, seq, clientId);
+                this.blockUpdateLength(node, stamp);
             }
             return true;
         };
-        this.nodeMap(refSeq, clientId, markMoved, afterMarkMoved, start.pos, end.pos + 1, // include the segment containing the end reference
-        undefined, seq === UnassignedSequenceNumber ? undefined : seq);
+        this.nodeMap(perspective, markRemoved, afterMarkRemoved, start.pos, end.pos + 1, // include the segment containing the end reference
+        // Use a visibilityPerspective which includes all segments (including local ones) which are in the obliteration range.
+        // This ensures that concurrently inserted segments will also be marked obliterated.
+        opstampUtils.isLocal(stamp)
+            ? perspective
+            : new RemoteObliteratePerspective(stamp.clientId));
         this.slideAckedRemovedSegmentReferences(localOverlapWithRefs);
         // opArgs == undefined => test code
         if (start.pos !== end.pos || start.side !== end.side) {
             this.mergeTreeDeltaCallback?.(opArgs, {
                 operation: MergeTreeDeltaType.OBLITERATE,
-                deltaSegments: movedSegments.map((segment) => ({ segment })),
+                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(movedSegments);
+        if (!this.collabWindow.collaborating || stamp.clientId !== this.collabWindow.clientId) {
+            this.slideAckedRemovedSegmentReferences(removedSegments);
         }
         if (this.collabWindow.collaborating &&
-            seq !== UnassignedSequenceNumber &&
+            opstampUtils.isAcked(stamp) &&
             MergeTree.options.zamboniSegments) {
             zamboniSegments(this);
         }
     }
-    obliterateRange(start, end, refSeq, clientId, seq, opArgs) {
+    obliterateRange(start, end, perspective, stampArg, opArgs) {
         errorIfOptionNotTrue(this.options, "mergeTreeEnableObliterate");
+        const stamp = { ...stampArg, type: "sliceRemove" };
         if (this.options?.mergeTreeEnableSidedObliterate) {
             assert(typeof start === "object" && typeof end === "object", 0xa45 /* Start and end must be of type InteriorSequencePlace if mergeTreeEnableSidedObliterate is enabled. */);
-            this.obliterateRangeSided(start, end, refSeq, clientId, seq, opArgs);
+            this.obliterateRangeSided(start, end, perspective, stamp, opArgs);
         }
         else {
             assert(typeof start === "number" && typeof end === "number", 0xa46 /* Start and end must be numbers if mergeTreeEnableSidedObliterate is not enabled. */);
-            this.obliterateRangeSided({ pos: start, side: Side.Before }, { pos: end - 1, side: Side.After }, refSeq, clientId, seq, opArgs);
+            this.obliterateRangeSided({ pos: start, side: Side.Before }, { pos: end - 1, side: Side.After }, perspective, stamp, opArgs);
         }
     }
-    markRangeRemoved(start, end, refSeq, clientId, seq, opArgs) {
+    markRangeRemoved(start, end, perspective, stampArg, opArgs) {
         let _overwrite = false;
-        this.ensureIntervalBoundary(start, refSeq, clientId);
-        this.ensureIntervalBoundary(end, refSeq, clientId);
+        const stamp = { ...stampArg, type: "setRemove" };
+        this.ensureIntervalBoundary(start, perspective);
+        this.ensureIntervalBoundary(end, perspective);
         let segmentGroup;
         const removedSegments = [];
         const localOverlapWithRefs = [];
-        const localSeq = seq === UnassignedSequenceNumber ? ++this.collabWindow.localSeq : undefined;
         const markRemoved = (segment, pos, _start, _end) => {
             const existingRemovalInfo = toRemovalInfo(segment);
             // Partial lengths incrementality is not supported for overlapping obliterate/removes.
-            _overwrite ||= existingRemovalInfo !== undefined || toMoveInfo(segment) !== undefined;
+            _overwrite ||= existingRemovalInfo !== undefined;
             if (existingRemovalInfo === undefined) {
                 const removed = overwriteInfo(segment, {
-                    removedClientIds: [clientId],
-                    removedSeq: seq,
-                    localRemovedSeq: localSeq,
+                    removes: [stamp],
                 });
-                const existingMoveInfo = toMoveInfo(removed);
-                if (existingMoveInfo === undefined) {
-                    removedSegments.push(removed);
-                }
-                else if (existingMoveInfo.movedSeq === UnassignedSequenceNumber &&
-                    segment.localRefs?.empty === false) {
-                    // We moved this locally already so we don't need to event it again, but it might have references
-                    // that need sliding now that a remove may have been acked.
-                    localOverlapWithRefs.push(segment);
-                }
+                removedSegments.push(removed);
             }
             else {
-                if (existingRemovalInfo.removedSeq === UnassignedSequenceNumber) {
-                    // we removed this locally, but someone else removed it first
-                    // so put them at the head of the list
-                    // The list isn't ordered, but we keep the first removal at the head
-                    // for partialLengths bookkeeping purposes
-                    existingRemovalInfo.removedClientIds.unshift(clientId);
-                    existingRemovalInfo.removedSeq = seq;
-                    if (segment.localRefs?.empty === false) {
-                        localOverlapWithRefs.push(segment);
-                    }
-                }
-                else {
-                    // Do not replace earlier sequence number for remove
-                    existingRemovalInfo.removedClientIds.push(clientId);
+                if (!opstampUtils.hasAnyAckedOperation(existingRemovalInfo.removes) &&
+                    segment.localRefs?.empty === false) {
+                    localOverlapWithRefs.push(segment);
                 }
+                opstampUtils.spliceIntoList(existingRemovalInfo.removes, stamp);
             }
             assertRemoved(segment);
             // Save segment so we can assign removed sequence number when acked by server
             if (this.collabWindow.collaborating) {
-                if (segment.removedSeq === UnassignedSequenceNumber &&
-                    clientId === this.collabWindow.clientId) {
-                    segmentGroup = this.addToPendingList(segment, segmentGroup, localSeq);
+                if (opstampUtils.isLocal(segment.removes[0]) &&
+                    stamp.clientId === this.collabWindow.clientId) {
+                    segmentGroup = this.addToPendingList(segment, segmentGroup, stamp.localSeq);
                 }
                 else {
                     if (MergeTree.options.zamboniSegments) {
-                        this.addToLRUSet(segment, seq);
+                        this.addToLRUSet(segment, stamp.seq);
                     }
                 }
             }
@@ -1555,11 +1418,11 @@ export class MergeTree {
                 this.nodeUpdateLengthNewStructure(node);
             }
             else {
-                this.blockUpdateLength(node, seq, clientId);
+                this.blockUpdateLength(node, stamp);
             }
             return true;
         };
-        this.nodeMap(refSeq, clientId, markRemoved, afterMarkRemoved, start, end);
+        this.nodeMap(perspective, 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);
@@ -1573,11 +1436,11 @@ export class MergeTree {
         // 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) {
+        if (!this.collabWindow.collaborating || stamp.clientId !== this.collabWindow.clientId) {
             this.slideAckedRemovedSegmentReferences(removedSegments);
         }
         if (this.collabWindow.collaborating &&
-            seq !== UnassignedSequenceNumber &&
+            opstampUtils.isAcked(stamp) &&
             MergeTree.options.zamboniSegments) {
             zamboniSegments(this);
         }
@@ -1596,15 +1459,25 @@ export class MergeTree {
             pendingSegmentGroup.segments.forEach((segment) => {
                 const segmentSegmentGroup = segment?.segmentGroups?.pop();
                 assert(segmentSegmentGroup === pendingSegmentGroup, 0x3ee /* Unexpected segmentGroup in segment */);
-                assert(isRemoved(segment) && segment.removedClientIds[0] === this.collabWindow.clientId, 0x39d /* Rollback segment removedClientId does not match local client */);
+                assert(isRemoved(segment) &&
+                    segment.removes[0].clientId === this.collabWindow.clientId &&
+                    segment.removes[0].type === "setRemove", 0x39d /* Rollback segment removedClientId does not match local client */);
                 let updateNode = segment.parent;
+                // This also removes obliterates, but that should be ok as we can only remove a segment once.
+                // If we were able to remove it locally, that also means there are no remote removals (since rollback is synchronous).
                 removeRemovalInfo(segment);
                 for (updateNode; updateNode !== undefined; updateNode = updateNode.parent) {
-                    this.blockUpdateLength(updateNode, UnassignedSequenceNumber, this.collabWindow.clientId);
+                    this.blockUpdateLength(updateNode, {
+                        seq: UnassignedSequenceNumber,
+                        clientId: this.collabWindow.clientId,
+                    });
                 }
                 // Note: optional chaining short-circuits:
                 // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Optional_chaining#short-circuiting
-                this.mergeTreeDeltaCallback?.({ op: createInsertSegmentOp(this.findRollbackPosition(segment), segment) }, {
+                this.mergeTreeDeltaCallback?.({
+                    op: createInsertSegmentOp(this.findRollbackPosition(segment), segment),
+                    rollback: true,
+                }, {
                     operation: MergeTreeDeltaType.INSERT,
                     deltaSegments: [{ segment }],
                 });
@@ -1624,15 +1497,27 @@ export class MergeTree {
                 assert(segmentSegmentGroup === pendingSegmentGroup, 0x3ef /* Unexpected segmentGroup in segment */);
                 const start = this.findRollbackPosition(segment);
                 if (op.type === MergeTreeDeltaType.INSERT) {
-                    segment.seq = UniversalSequenceNumber;
-                    segment.localSeq = undefined;
+                    segment.insert = {
+                        type: "insert",
+                        seq: UniversalSequenceNumber,
+                        clientId: this.collabWindow.clientId,
+                    };
                     const removeOp = createRemoveRangeOp(start, start + segment.cachedLength);
-                    this.markRangeRemoved(start, start + segment.cachedLength, UniversalSequenceNumber, this.collabWindow.clientId, UniversalSequenceNumber, { op: removeOp });
+                    const removeStamp = {
+                        type: "setRemove",
+                        seq: UniversalSequenceNumber,
+                        clientId: this.collabWindow.clientId,
+                    };
+                    this.markRangeRemoved(start, start + segment.cachedLength, this.localPerspective, removeStamp, { op: removeOp, rollback: true });
                 } /* op.type === MergeTreeDeltaType.ANNOTATE */
                 else {
                     const props = pendingSegmentGroup.previousProps[i];
                     const annotateOp = createAnnotateRangeOp(start, start + segment.cachedLength, props);
-                    this.annotateRange(start, start + segment.cachedLength, { props }, UniversalSequenceNumber, this.collabWindow.clientId, UniversalSequenceNumber, { op: annotateOp }, PropertiesRollback.Rollback);
+                    const annotateStamp = {
+                        seq: UniversalSequenceNumber,
+                        clientId: this.collabWindow.clientId,
+                    };
+                    this.annotateRange(start, start + segment.cachedLength, { props }, this.localPerspective, annotateStamp, { op: annotateOp, rollback: true });
                     i++;
                 }
             }
@@ -1673,7 +1558,7 @@ export class MergeTree {
     createLocalReferencePosition(_segment, offset, refType, properties, slidingPreference, canSlideToEndpoint) {
         if (_segment !== "start" &&
             _segment !== "end" &&
-            isRemovedAndAckedOrMovedAndAcked(_segment) &&
+            isRemovedAndAcked(_segment) &&
             !refTypeIncludesFlag(refType, ReferenceType.SlideOnRemove | ReferenceType.Transient | ReferenceType.StayOnRemove) &&
             _segment.endpointType === undefined) {
             throw new UsageError("Can only create SlideOnRemove or Transient local reference position on a removed or obliterated segment");
@@ -1717,15 +1602,15 @@ export class MergeTree {
                 affectedSegments.insertAfter(lastLocalSegment, segmentToSlide.data);
             }
             else if (isRemoved(segmentToSlide.data)) {
-                assert(segmentToSlide.data.localRemovedSeq !== undefined, 0x54d /* Removed segment that hasnt had its removal acked should be locally removed */);
+                assert(segmentToSlide.data.removes[0].seq !== 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;
                 let cur = segmentToSlide;
                 let scan = cur.next;
                 while (scan !== undefined &&
                     !isRemovedAndAcked(scan.data) &&
-                    scan.data.localSeq !== undefined &&
-                    scan.data.localSeq > segmentToSlide.data.localRemovedSeq) {
+                    scan.data.insert.localSeq !== undefined &&
+                    opstampUtils.greaterThan(scan.data.insert, segmentToSlide.data.removes[0])) {
                     cur = scan;
                     scan = scan.next;
                 }
@@ -1810,11 +1695,11 @@ export class MergeTree {
             }
         };
         walkAllChildSegments(this.root, (seg) => {
-            if (isRemoved(seg) || seg.seq === UnassignedSequenceNumber) {
+            if (isRemoved(seg) || opstampUtils.isLocal(seg.insert)) {
                 if (isRemovedAndAcked(seg)) {
                     rangeContainsRemoteRemovedSegs = true;
                 }
-                if (seg.seq === UnassignedSequenceNumber) {
+                if (opstampUtils.isLocal(seg.insert)) {
                     rangeContainsLocalSegs = true;
                 }
                 currentRangeToNormalize.push(seg);
@@ -1842,7 +1727,7 @@ export class MergeTree {
             }
             if (node.isLeaf()) {
                 const segment = node;
-                if ((this.localNetLength(segment) ?? 0) > 0 && Marker.is(segment)) {
+                if ((this.leafLength(segment) ?? 0) > 0 && Marker.is(segment)) {
                     const markerId = segment.getId();
                     // Also in insertMarker but need for reload segs case
                     // can add option for this only from reload segs
@@ -1872,33 +1757,33 @@ export class MergeTree {
         block.rightmostTiles = rightmostTiles;
         block.cachedLength = len;
     }
-    blockUpdatePathLengths(startBlock, seq, clientId, newStructure = false) {
+    blockUpdatePathLengths(startBlock, stamp, newStructure = false) {
         let block = startBlock;
         while (block !== undefined) {
             if (newStructure) {
                 this.nodeUpdateLengthNewStructure(block);
             }
             else {
-                this.blockUpdateLength(block, seq, clientId);
+                this.blockUpdateLength(block, stamp);
             }
             block = block.parent;
         }
     }
-    blockUpdateLength(node, seq, clientId) {
+    blockUpdateLength(node, stamp) {
         this.blockUpdate(node);
         this.localPartialsComputed = false;
         if (this.collabWindow.collaborating &&
-            seq !== UnassignedSequenceNumber &&
-            seq !== TreeMaintenanceSequenceNumber) {
+            opstampUtils.isAcked(stamp) &&
+            stamp.seq !== TreeMaintenanceSequenceNumber) {
             if (node.partialLengths !== undefined &&
                 MergeTree.options.incrementalUpdate &&
-                clientId !== NonCollabClient) {
-                node.partialLengths.update(node, seq, clientId, this.collabWindow);
+                stamp.clientId !== NonCollabClient) {
+                node.partialLengths.update(node, stamp.seq, stamp.clientId, this.collabWindow);
             }
             else {
                 node.partialLengths = PartialSequenceLengths.combine(node, this.collabWindow);
             }
-            PartialSequenceLengths.options.verifyExpected?.(this, node, seq, clientId);
+            PartialSequenceLengths.options.verifyExpected?.(this, node, stamp.seq, stamp.clientId);
         }
     }
     /**
@@ -1908,16 +1793,16 @@ export class MergeTree {
      *
      * See `this.nodeMap` for additional documentation
      */
-    mapRange(handler, refSeq, clientId, accum, start, end, splitRange = false, visibilitySeq = refSeq) {
+    mapRange(handler, perspective, accum, start, end, splitRange = false, visibilityPerspective = perspective) {
         if (splitRange) {
             if (start) {
-                this.ensureIntervalBoundary(start, refSeq, clientId);
+                this.ensureIntervalBoundary(start, perspective);
             }
             if (end) {
-                this.ensureIntervalBoundary(end, refSeq, clientId);
+                this.ensureIntervalBoundary(end, perspective);
             }
         }
-        this.nodeMap(refSeq, clientId, (seg, pos, _start, _end) => handler(seg, pos, refSeq, clientId, _start, _end, accum), undefined, start, end, undefined, visibilitySeq);
+        this.nodeMap(perspective, (seg, pos, _start, _end) => handler(seg, pos, perspective.refSeq, perspective.clientId, _start, _end, accum), undefined, start, end, visibilityPerspective);
     }
     /**
      * Map over all visible segments in a given range
@@ -1942,8 +1827,8 @@ 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, post, start = 0, end, localSeq, visibilitySeq = refSeq) {
-        const endPos = end ?? this.nodeLength(this.root, refSeq, clientId, localSeq) ?? 0;
+    nodeMap(perspective, leaf, post, start = 0, end, visibilityPerspective = perspective) {
+        const endPos = end ?? this.nodeLength(this.root, perspective) ?? 0;
         if (endPos === start) {
             return;
         }
@@ -1952,12 +1837,15 @@ export class MergeTree {
             if (endPos <= pos) {
                 return NodeAction.Exit;
             }
-            const len = this.nodeLength(node, visibilitySeq, clientId, localSeq);
-            const lenAtRefSeq = (visibilitySeq === refSeq
-                ? len
-                : this.nodeLength(node, refSeq, clientId, localSeq)) ?? 0;
-            const isUnackedAndInObliterate = visibilitySeq !== refSeq &&
-                (!node.isLeaf() || node.seq === UnassignedSequenceNumber);
+            const len = this.nodeLength(node, visibilityPerspective);
+            const lenAtRefSeq = (visibilityPerspective === perspective ? len : this.nodeLength(node, perspective)) ??
+                0;
+            // NOTE: This code ensures that obliterates have a chance to mark segments which have been inserted locally
+            // as also having been obliterated on the local client. With the introduction of RemoteObliteratePerspective,
+            // it's feasible we could remove it if the `nodeLength` calculation also respects that perspective for blocks
+            // and not just leaves.
+            const isUnackedAndInObliterate = visibilityPerspective !== perspective &&
+                (!node.isLeaf() || opstampUtils.isLocal(node.insert));
             if ((len === undefined && lenAtRefSeq === 0) ||
                 (len === 0 && !isUnackedAndInObliterate && lenAtRefSeq === 0)) {
                 return NodeAction.Skip;
@@ -1982,5 +1870,10 @@ MergeTree.options = {
     insertAfterRemovedSegs: true,
     zamboniSegments: true,
 };
+/**
+ * A sentinel value that indicates an inserting walk should continue to the next block sibling.
+ * This can occur for example when tie-break forces insertion of a segment past an entire block (and
+ * the inserting walk first recurses into the block before realizing that).
+ */
 MergeTree.theUnfinishedNode = { childCount: -1 };
 //# sourceMappingURL=mergeTree.js.map