@fluidframework/merge-tree 2.12.0 → 2.13.0

package/src/mergeTree.ts

@@ -43,29 +43,24 @@ import {
 	walkAllChildSegments,
 } from "./mergeTreeNodeWalk.js";
 import {
-	BlockAction,
-	// eslint-disable-next-line import/no-deprecated
 	CollaborationWindow,
 	IMergeNode,
-	// eslint-disable-next-line import/no-deprecated
-	IMoveInfo,
-	// eslint-disable-next-line import/no-deprecated
-	IRemovalInfo,
 	ISegmentAction,
 	ISegmentChanges,
-	ISegmentLeaf,
 	InsertContext,
 	Marker,
 	MaxNodesInBlock,
 	MergeBlock,
-	// eslint-disable-next-line import/no-deprecated
 	SegmentGroup,
+	assertSegmentLeaf,
+	assignChild,
+	isSegmentLeaf,
 	reservedMarkerIdKey,
 	seqLTE,
-	toMoveInfo,
-	toRemovalInfo,
+	type IMergeNodeBuilder,
 	type ISegmentInternal,
-	// eslint-disable-next-line import/no-deprecated
+	type ISegmentLeaf,
+	type ISegmentPrivate,
 	type ObliterateInfo,
 } from "./mergeTreeNodes.js";
 import type { TrackingGroup } from "./mergeTreeTracking.js";
@@ -90,9 +85,24 @@ import {
 	refHasTileLabel,
 	refTypeIncludesFlag,
 } from "./referencePositions.js";
-// eslint-disable-next-line import/no-deprecated
 import { SegmentGroupCollection } from "./segmentGroupCollection.js";
-// eslint-disable-next-line import/no-deprecated
+import {
+	assertMoved,
+	assertRemoved,
+	isMergeNodeInfo,
+	isMoved,
+	isRemoved,
+	overwriteInfo,
+	removeRemovalInfo,
+	toMoveInfo,
+	toRemovalInfo,
+	type IInsertionInfo,
+	// eslint-disable-next-line import/no-deprecated
+	type IMoveInfo,
+	// eslint-disable-next-line import/no-deprecated
+	type IRemovalInfo,
+	type SegmentWithInfo,
+} from "./segmentInfos.js";
 import {
 	copyPropertiesAndManager,
 	PropertiesManager,
@@ -103,39 +113,21 @@ import { Side, type InteriorSequencePlace } from "./sequencePlace.js";
 import { SortedSegmentSet } from "./sortedSegmentSet.js";
 import { zamboniSegments } from "./zamboni.js";
 
-// eslint-disable-next-line import/no-deprecated
-function markSegmentMoved(seg: ISegmentLeaf, moveInfo: IMoveInfo): void {
-	seg.moveDst = moveInfo.moveDst;
-	seg.movedClientIds = [...moveInfo.movedClientIds];
-	seg.movedSeqs = [moveInfo.movedSeq];
-	seg.movedSeq = moveInfo.movedSeq;
-	seg.localMovedSeq = moveInfo.localMovedSeq;
-	seg.wasMovedOnInsert = moveInfo.wasMovedOnInsert;
-}
-
-// eslint-disable-next-line import/no-deprecated
-function isMoved(segment: ISegmentLeaf): segment is ISegmentLeaf & IMoveInfo {
-	return toMoveInfo(segment) !== undefined;
-}
-
-// eslint-disable-next-line import/no-deprecated
-function isRemoved(segment: ISegmentLeaf): segment is ISegmentLeaf & IRemovalInfo {
-	return toRemovalInfo(segment) !== undefined;
-}
-
-// eslint-disable-next-line import/no-deprecated
-function isRemovedAndAcked(segment: ISegmentLeaf): segment is ISegmentLeaf & IRemovalInfo {
+function isRemovedAndAcked(
+	segment: ISegmentPrivate,
+	// eslint-disable-next-line import/no-deprecated
+): segment is ISegmentLeaf & IRemovalInfo {
 	const removalInfo = toRemovalInfo(segment);
 	return removalInfo !== undefined && removalInfo.removedSeq !== UnassignedSequenceNumber;
 }
 
 // eslint-disable-next-line import/no-deprecated
-function isMovedAndAcked(segment: ISegmentLeaf): segment is ISegmentLeaf & IMoveInfo {
+function isMovedAndAcked(segment: ISegmentPrivate): segment is ISegmentLeaf & IMoveInfo {
 	const moveInfo = toMoveInfo(segment);
 	return moveInfo !== undefined && moveInfo.movedSeq !== UnassignedSequenceNumber;
 }
 
-function isRemovedAndAckedOrMovedAndAcked(segment: ISegmentLeaf): boolean {
+function isRemovedAndAckedOrMovedAndAcked(segment: ISegmentPrivate): boolean {
 	return isRemovedAndAcked(segment) || isMovedAndAcked(segment);
 }
 
@@ -188,12 +180,10 @@ function ackSegment(
 		}
 
 		case MergeTreeDeltaType.REMOVE: {
-			// eslint-disable-next-line import/no-deprecated
-			const removalInfo: IRemovalInfo | undefined = toRemovalInfo(segment);
-			assert(removalInfo !== undefined, 0x046 /* "On remove ack, missing removal info!" */);
+			assertRemoved(segment);
 			segment.localRemovedSeq = undefined;
-			if (removalInfo.removedSeq === UnassignedSequenceNumber) {
-				removalInfo.removedSeq = sequenceNumber;
+			if (segment.removedSeq === UnassignedSequenceNumber) {
+				segment.removedSeq = sequenceNumber;
 				return true;
 			}
 			return false;
@@ -201,18 +191,16 @@ function ackSegment(
 
 		case MergeTreeDeltaType.OBLITERATE:
 		case MergeTreeDeltaType.OBLITERATE_SIDED: {
-			// eslint-disable-next-line import/no-deprecated
-			const moveInfo: IMoveInfo | undefined = toMoveInfo(segment);
-			assert(moveInfo !== undefined, 0x86e /* On obliterate ack, missing move info! */);
+			assertMoved(segment);
 			const obliterateInfo = segmentGroup.obliterateInfo;
 			assert(obliterateInfo !== undefined, 0xa40 /* must have obliterate info */);
 			segment.localMovedSeq = obliterateInfo.localSeq = undefined;
-			const seqIdx = moveInfo.movedSeqs.indexOf(UnassignedSequenceNumber);
+			const seqIdx = segment.movedSeqs.indexOf(UnassignedSequenceNumber);
 			assert(seqIdx !== -1, 0x86f /* expected movedSeqs to contain unacked seq */);
-			moveInfo.movedSeqs[seqIdx] = sequenceNumber;
+			segment.movedSeqs[seqIdx] = sequenceNumber;
 
-			if (moveInfo.movedSeq === UnassignedSequenceNumber) {
-				moveInfo.movedSeq = sequenceNumber;
+			if (segment.movedSeq === UnassignedSequenceNumber) {
+				segment.movedSeq = sequenceNumber;
 				return true;
 			}
 
@@ -405,7 +393,6 @@ export function 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: ISegmentLeaf | undefined,
@@ -434,7 +421,8 @@ function getSlideToSegment(
 		}
 		if (
 			cache !== undefined &&
-			(seg.removedSeq === segment.removedSeq || seg.movedSeq === segment.movedSeq)
+			(toRemovalInfo(seg)?.removedSeq === toRemovalInfo(segment)?.removedSeq ||
+				toMoveInfo(seg)?.movedSeq === toMoveInfo(segment)?.movedSeq)
 		) {
 			cache.set(seg, result);
 		}
@@ -492,7 +480,7 @@ export function getSlideToSegoff(
 	segment: ISegmentInternal | undefined;
 	offset: number | undefined;
 } {
-	if (segoff.segment === undefined) {
+	if (!isSegmentLeaf(segoff.segment)) {
 		return segoff;
 	}
 	const [segment, _] = getSlideToSegment(
@@ -527,7 +515,7 @@ 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
+
 	private readonly seqOrdered = new DoublyLinkedList<ObliterateInfo>();
 
 	/**
@@ -549,7 +537,6 @@ class Obliterates {
 		}
 	}
 
-	// eslint-disable-next-line import/no-deprecated
 	public addOrUpdate(obliterateInfo: ObliterateInfo): void {
 		const { seq, start } = obliterateInfo;
 		if (seq !== UnassignedSequenceNumber) {
@@ -562,14 +549,14 @@ class Obliterates {
 		return this.startOrdered.size === 0;
 	}
 
-	// eslint-disable-next-line import/no-deprecated
 	public findOverlapping(seg: ISegmentLeaf): Iterable<ObliterateInfo> {
-		// eslint-disable-next-line import/no-deprecated
 		const overlapping: ObliterateInfo[] = [];
 		for (const start of this.startOrdered.items) {
-			if (start.getSegment()!.ordinal <= seg.ordinal) {
+			const startSeg = start.getSegment();
+			if (isMergeNodeInfo(startSeg) && startSeg.ordinal <= seg.ordinal) {
 				const ob = start.properties?.obliterate as ObliterateInfo;
-				if (ob.end.getSegment()!.ordinal >= seg.ordinal) {
+				const endSeg = ob.end.getSegment();
+				if (isMergeNodeInfo(endSeg) && endSeg.ordinal >= seg.ordinal) {
 					overlapping.push(ob);
 				}
 			} else {
@@ -593,10 +580,8 @@ export class MergeTree {
 
 	private static readonly theUnfinishedNode = { childCount: -1 } as unknown as MergeBlock;
 
-	// eslint-disable-next-line import/no-deprecated
 	public readonly collabWindow = new CollaborationWindow();
 
-	// eslint-disable-next-line import/no-deprecated
 	public readonly pendingSegments = new DoublyLinkedList<SegmentGroup>();
 
 	public readonly segmentsToScour = new Heap<LRUSegment>(LRUSegmentComparer);
@@ -675,7 +660,9 @@ export class MergeTree {
 			0x398 /* localSeq provided for local length without refSeq */,
 		);
 		assert(segment.seq !== undefined, 0x399 /* segment with no seq in mergeTree */);
-		const { seq, removedSeq, localRemovedSeq, movedSeq, localMovedSeq } = segment;
+		const { seq } = segment;
+		const { removedSeq, localRemovedSeq } = removalInfo ?? {};
+		const { movedSeq, localMovedSeq } = moveInfo ?? {};
 		if (seq === UnassignedSequenceNumber) {
 			assert(
 				segment.localSeq !== undefined,
@@ -717,13 +704,13 @@ export class MergeTree {
 		}
 	}
 
-	private addNode(block: MergeBlock, node: IMergeNode): number {
+	private addNode(block: MergeBlock, node: IMergeNodeBuilder): number {
 		const index = block.childCount++;
-		block.assignChild(node, index, false);
+		assignChild(block, node, index, false);
 		return index;
 	}
 
-	public reloadFromSegments(segments: ISegmentLeaf[]): void {
+	public reloadFromSegments(segments: SegmentWithInfo<IInsertionInfo>[]): void {
 		// This code assumes that a later call to `startCollaboration()` will initialize partial lengths.
 		assert(
 			!this.collabWindow.collaborating,
@@ -733,7 +720,7 @@ export class MergeTree {
 		const maxChildren = MaxNodesInBlock - 1;
 
 		// Starting with the leaf segments, recursively builds the B-Tree layer by layer from the bottom up.
-		const buildMergeBlock = (nodes: IMergeNode[]): IRootMergeBlock => {
+		const buildMergeBlock = (nodes: IMergeNodeBuilder[]): IRootMergeBlock => {
 			const blockCount = Math.ceil(nodes.length / maxChildren); // Compute # blocks require for this level of B-Tree
 			const blocks: MergeBlock[] = Array.from({ length: blockCount }); // Pre-alloc array to collect nodes
 
@@ -789,8 +776,8 @@ export class MergeTree {
 
 		// TODO: 'seq' may be less than the current sequence number when inserting pre-ACKed
 		//       segments from a snapshot.  We currently skip these for now.
-		if (leaf.parent!.needsScour !== true && seq > this.collabWindow.currentSeq) {
-			leaf.parent!.needsScour = true;
+		if (leaf.parent.needsScour !== true && seq > this.collabWindow.currentSeq) {
+			leaf.parent.needsScour = true;
 			this.segmentsToScour.add({ segment: leaf, maxSeq: seq });
 		}
 	}
@@ -834,34 +821,28 @@ export class MergeTree {
 		return totalOffset;
 	}
 
-	public getContainingSegment<T extends ISegmentLeaf>(
+	public getContainingSegment(
 		pos: number,
 		refSeq: number,
 		clientId: number,
 		localSeq?: number,
 	): {
-		segment: T | undefined;
+		segment: ISegmentLeaf | undefined;
 		offset: number | undefined;
 	} {
 		assert(
 			localSeq === undefined || clientId === this.collabWindow.clientId,
 			0x39b /* localSeq provided for non-local client */,
 		);
-		let segment: T | undefined;
+		let segment: ISegmentLeaf | undefined;
 		let offset: number | undefined;
 
-		const leaf = (
-			leafSeg: ISegmentLeaf,
-			segpos: number,
-			_refSeq: number,
-			_clientId: number,
-			start: number,
-		): boolean => {
-			segment = leafSeg as T;
+		const leaf = (leafSeg: ISegmentLeaf, _: number, start: number): boolean => {
+			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 };
 	}
 
@@ -1091,7 +1072,6 @@ export class MergeTree {
 			return;
 		}
 
-		// eslint-disable-next-line import/no-deprecated
 		const rebaseCollabWindow = new CollaborationWindow();
 		rebaseCollabWindow.loadFrom(this.collabWindow);
 		if (refSeq < this.collabWindow.minSeq) {
@@ -1214,13 +1194,13 @@ export class MergeTree {
 		clientId = this.collabWindow.clientId,
 		localSeq: number | undefined = this.collabWindow.localSeq,
 	): number {
-		const seg: ISegmentLeaf | undefined = refPos.getSegment();
-		if (seg?.parent === undefined) {
+		const seg = refPos.getSegment();
+		if (!isSegmentLeaf(seg)) {
 			// We have no idea where this reference is, because it refers to a segment which is not in the tree.
 			return DetachedReferencePosition;
 		}
 		if (refPos.isLeaf()) {
-			return this.getPosition(refPos, refSeq, clientId, localSeq);
+			return this.getPosition(seg, refSeq, clientId, localSeq);
 		}
 		if (refTypeIncludesFlag(refPos, ReferenceType.Transient) || seg.localRefs?.has(refPos)) {
 			if (
@@ -1229,13 +1209,15 @@ export class MergeTree {
 				!isSegmentPresent(seg, { refSeq, localSeq })
 			) {
 				const forward = refPos.slidingPreference === SlidingPreference.FORWARD;
+				const moveInfo = toMoveInfo(seg);
+				const removeInfo = toRemovalInfo(seg);
 				const slideSeq =
-					seg.movedSeq !== UnassignedSequenceNumber && seg.movedSeq !== undefined
-						? seg.movedSeq
-						: seg.removedSeq !== UnassignedSequenceNumber && seg.removedSeq !== undefined
-							? seg.removedSeq
+					moveInfo !== undefined && moveInfo.movedSeq !== UnassignedSequenceNumber
+						? moveInfo.movedSeq
+						: removeInfo !== undefined && removeInfo.removedSeq !== UnassignedSequenceNumber
+							? removeInfo.removedSeq
 							: refSeq;
-				const slideLocalSeq = seg.localMovedSeq ?? seg.localRemovedSeq;
+				const slideLocalSeq = moveInfo?.localMovedSeq ?? removeInfo?.localRemovedSeq;
 				const perspective = new PerspectiveImpl(this, {
 					refSeq: slideSeq,
 					localSeq: slideLocalSeq,
@@ -1272,14 +1254,13 @@ export class MergeTree {
 		let foundMarker: Marker | undefined;
 
 		const { segment } = this.getContainingSegment(startPos, UniversalSequenceNumber, clientId);
-		const segWithParent: ISegmentLeaf | undefined = segment;
-		if (segWithParent?.parent === undefined) {
+		if (!isSegmentLeaf(segment)) {
 			return undefined;
 		}
 
 		depthFirstNodeWalk(
-			segWithParent.parent,
-			segWithParent,
+			segment.parent,
+			segment,
 			(node) => {
 				if (node.isLeaf()) {
 					if (Marker.is(node) && refHasTileLabel(node, markerLabel)) {
@@ -1310,8 +1291,8 @@ export class MergeTree {
 	private updateRoot(splitNode: MergeBlock | undefined): void {
 		if (splitNode !== undefined) {
 			const newRoot = this.makeBlock(2);
-			newRoot.assignChild(this.root, 0, false);
-			newRoot.assignChild(splitNode, 1, false);
+			assignChild(newRoot, this.root, 0, false);
+			assignChild(newRoot, splitNode, 1, false);
 			this.root = newRoot;
 			this.nodeUpdateOrdinals(this.root);
 			this.nodeUpdateLengthNewStructure(this.root);
@@ -1339,8 +1320,8 @@ export class MergeTree {
 				if (MergeTree.options.zamboniSegments) {
 					this.addToLRUSet(pendingSegment, seq);
 				}
-				if (!nodesToUpdate.includes(pendingSegment.parent!)) {
-					nodesToUpdate.push(pendingSegment.parent!);
+				if (!nodesToUpdate.includes(pendingSegment.parent)) {
+					nodesToUpdate.push(pendingSegment.parent);
 				}
 				deltaSegments.push({
 					segment: pendingSegment,
@@ -1381,11 +1362,10 @@ export class MergeTree {
 
 	private addToPendingList(
 		segment: ISegmentLeaf,
-		// eslint-disable-next-line import/no-deprecated
+
 		segmentGroup?: SegmentGroup,
 		localSeq?: number,
 		previousProps?: PropertySet,
-		// eslint-disable-next-line import/no-deprecated
 	): SegmentGroup {
 		let _segmentGroup = segmentGroup;
 		if (_segmentGroup === undefined) {
@@ -1409,7 +1389,7 @@ export class MergeTree {
 		if (previousProps) {
 			_segmentGroup.previousProps!.push(previousProps);
 		}
-		// eslint-disable-next-line import/no-deprecated
+
 		const segmentGroups = (segment.segmentGroups ??= new SegmentGroupCollection(segment));
 		segmentGroups.enqueue(_segmentGroup);
 		return _segmentGroup;
@@ -1442,7 +1422,7 @@ export class MergeTree {
 		if (relativePos.id) {
 			marker = this.getMarkerFromId(relativePos.id);
 		}
-		if (marker) {
+		if (isSegmentLeaf(marker)) {
 			pos = this.getPosition(marker, refseq, clientId);
 			if (relativePos.before) {
 				if (relativePos.offset !== undefined) {
@@ -1460,7 +1440,7 @@ export class MergeTree {
 
 	public insertSegments(
 		pos: number,
-		segments: ISegmentLeaf[],
+		segments: ISegmentPrivate[],
 		refSeq: number,
 		clientId: number,
 		seq: number,
@@ -1527,7 +1507,7 @@ export class MergeTree {
 
 		const { currentSeq, clientId } = this.collabWindow;
 
-		if (segmentInfo?.segment) {
+		if (isSegmentLeaf(segmentInfo?.segment)) {
 			const segmentPosition = this.getPosition(segmentInfo.segment, currentSeq, clientId);
 			return segmentPosition + segmentInfo.offset!;
 		} else {
@@ -1537,7 +1517,7 @@ export class MergeTree {
 		}
 	}
 
-	private blockInsert<T extends ISegmentLeaf>(
+	private blockInsert<T extends ISegmentPrivate>(
 		pos: number,
 		refSeq: number,
 		clientId: number,
@@ -1555,7 +1535,7 @@ export class MergeTree {
 			});
 			return siblingExists;
 		};
-		// eslint-disable-next-line import/no-deprecated
+
 		let segmentGroup: SegmentGroup;
 		const saveIfLocal = (locSegment: ISegmentLeaf): void => {
 			// Save segment so we can assign sequence number when acked by server
@@ -1570,10 +1550,10 @@ export class MergeTree {
 				// In all other cases this has to be true (checked by addToLRUSet):
 				// locSegment.seq > this.collabWindow.currentSeq
 				else if (
-					locSegment.seq! > this.collabWindow.minSeq &&
+					locSegment.seq > this.collabWindow.minSeq &&
 					MergeTree.options.zamboniSegments
 				) {
-					this.addToLRUSet(locSegment, locSegment.seq!);
+					this.addToLRUSet(locSegment, locSegment.seq);
 				}
 			}
 		};
@@ -1582,6 +1562,7 @@ export class MergeTree {
 			_pos: number,
 			context: InsertContext,
 			// Keeping this function within the scope of blockInsert for readability.
+			// eslint-disable-next-line unicorn/consistent-function-scoping
 		): ISegmentChanges => {
 			const segmentChanges: ISegmentChanges = {};
 			if (segment) {
@@ -1594,107 +1575,109 @@ export class MergeTree {
 			return segmentChanges;
 		};
 
+		const insertInfo: IInsertionInfo = {
+			clientId,
+			seq,
+			localSeq,
+		};
 		// TODO: build tree from segs and insert all at once
 		let insertPos = pos;
-		for (const newSegment of newSegments) {
-			if (newSegment.cachedLength > 0) {
-				newSegment.seq = seq;
-				newSegment.localSeq = localSeq;
-				newSegment.clientId = clientId;
-				if (Marker.is(newSegment)) {
-					const markerId = newSegment.getId();
-					if (markerId) {
-						this.idToMarker.set(markerId, newSegment);
-					}
+		for (const newSegment of newSegments
+			.filter((s) => s.cachedLength > 0)
+			.map((s) => overwriteInfo(s, insertInfo))) {
+			if (Marker.is(newSegment)) {
+				const markerId = newSegment.getId();
+				if (markerId) {
+					this.idToMarker.set(markerId, newSegment);
 				}
+			}
 
-				const splitNode = this.insertingWalk(this.root, insertPos, refSeq, clientId, seq, {
-					leaf: onLeaf,
-					candidateSegment: newSegment,
-					continuePredicate: continueFrom,
-				});
+			const splitNode = this.insertingWalk(this.root, insertPos, refSeq, clientId, seq, {
+				leaf: onLeaf,
+				candidateSegment: newSegment,
+				continuePredicate: continueFrom,
+			});
 
-				if (newSegment.parent === undefined) {
-					// Indicates an attempt to insert past the end of the merge-tree's content.
-					const errorConstructor = localSeq === undefined ? DataProcessingError : UsageError;
-					throw new errorConstructor("MergeTree insert failed", {
-						currentSeq: this.collabWindow.currentSeq,
-						minSeq: this.collabWindow.minSeq,
-						segSeq: newSegment.seq,
-					});
-				}
+			if (!isSegmentLeaf(newSegment)) {
+				// Indicates an attempt to insert past the end of the merge-tree's content.
+				const errorConstructor = localSeq === undefined ? DataProcessingError : UsageError;
+				throw new errorConstructor("MergeTree insert failed", {
+					currentSeq: this.collabWindow.currentSeq,
+					minSeq: this.collabWindow.minSeq,
+					segSeq: insertInfo.seq,
+				});
+			}
 
-				this.updateRoot(splitNode);
+			this.updateRoot(splitNode);
 
-				insertPos += newSegment.cachedLength;
+			insertPos += newSegment.cachedLength;
 
-				if (!this.options?.mergeTreeEnableObliterate || this.obliterates.empty()) {
-					saveIfLocal(newSegment);
-					continue;
-				}
+			if (!this.options?.mergeTreeEnableObliterate || this.obliterates.empty()) {
+				saveIfLocal(newSegment);
+				continue;
+			}
 
-				let oldest: ObliterateInfo | undefined;
-				let normalizedOldestSeq: number = 0;
-				let newest: ObliterateInfo | undefined;
-				let normalizedNewestSeq: number = 0;
-				const movedClientIds: number[] = [];
-				const movedSeqs: number[] = [];
-				for (const ob of this.obliterates.findOverlapping(newSegment)) {
-					// compute a normalized seq that takes into account local seqs
-					// but is still comparable to remote seqs to keep the checks below easy
-					// REMOTE SEQUENCE NUMBERS                                     LOCAL SEQUENCE NUMBERS
-					// [0, 1, 2, 3, ..., 100, ..., 1000, ..., (MAX - MaxLocalSeq), L1, L2, L3, L4, ..., L100, ..., L1000, ...(MAX)]
-					const normalizedObSeq =
-						ob.seq === UnassignedSequenceNumber
-							? Number.MAX_SAFE_INTEGER - this.collabWindow.localSeq + ob.localSeq!
-							: ob.seq;
-					if (normalizedObSeq > refSeq) {
-						if (oldest === undefined || normalizedOldestSeq > normalizedObSeq) {
-							normalizedOldestSeq = normalizedObSeq;
-							oldest = ob;
-							movedClientIds.unshift(ob.clientId);
-							movedSeqs.unshift(ob.seq);
-						} else {
-							movedClientIds.push(ob.clientId);
-							movedSeqs.push(ob.seq);
-						}
-						if (newest === undefined || normalizedNewestSeq < normalizedObSeq) {
-							normalizedNewestSeq = normalizedObSeq;
-							newest = ob;
-						}
+			let oldest: ObliterateInfo | undefined;
+			let normalizedOldestSeq: number = 0;
+			let newest: ObliterateInfo | undefined;
+			let normalizedNewestSeq: number = 0;
+			const movedClientIds: number[] = [];
+			const movedSeqs: number[] = [];
+			for (const ob of this.obliterates.findOverlapping(newSegment)) {
+				// compute a normalized seq that takes into account local seqs
+				// but is still comparable to remote seqs to keep the checks below easy
+				// REMOTE SEQUENCE NUMBERS                                     LOCAL SEQUENCE NUMBERS
+				// [0, 1, 2, 3, ..., 100, ..., 1000, ..., (MAX - MaxLocalSeq), L1, L2, L3, L4, ..., L100, ..., L1000, ...(MAX)]
+				const normalizedObSeq =
+					ob.seq === UnassignedSequenceNumber
+						? Number.MAX_SAFE_INTEGER - this.collabWindow.localSeq + ob.localSeq!
+						: ob.seq;
+				if (normalizedObSeq > refSeq) {
+					if (oldest === undefined || normalizedOldestSeq > normalizedObSeq) {
+						normalizedOldestSeq = normalizedObSeq;
+						oldest = ob;
+						movedClientIds.unshift(ob.clientId);
+						movedSeqs.unshift(ob.seq);
+					} else {
+						movedClientIds.push(ob.clientId);
+						movedSeqs.push(ob.seq);
+					}
+					if (newest === undefined || normalizedNewestSeq < normalizedObSeq) {
+						normalizedNewestSeq = normalizedObSeq;
+						newest = ob;
 					}
 				}
+			}
 
-				if (oldest && newest?.clientId !== clientId) {
-					// eslint-disable-next-line import/no-deprecated
-					const moveInfo: IMoveInfo = {
-						movedClientIds,
-						movedSeq: oldest.seq,
-						movedSeqs,
-						localMovedSeq: oldest.localSeq,
-						wasMovedOnInsert: oldest.seq !== UnassignedSequenceNumber,
-					};
-
-					markSegmentMoved(newSegment, moveInfo);
-
-					if (moveInfo.localMovedSeq !== undefined) {
-						assert(
-							oldest.segmentGroup !== undefined,
-							0x86c /* expected segment group to exist */,
-						);
-
-						this.addToPendingList(newSegment, oldest.segmentGroup);
-					}
+			if (oldest && newest?.clientId !== clientId) {
+				// eslint-disable-next-line import/no-deprecated
+				const moveInfo: IMoveInfo = {
+					movedClientIds,
+					movedSeq: oldest.seq,
+					movedSeqs,
+					localMovedSeq: oldest.localSeq,
+					wasMovedOnInsert: oldest.seq !== UnassignedSequenceNumber,
+				};
+
+				overwriteInfo(newSegment, moveInfo);
+
+				if (moveInfo.localMovedSeq !== undefined) {
+					assert(
+						oldest.segmentGroup !== undefined,
+						0x86c /* expected segment group to exist */,
+					);
 
-					if (newSegment.parent) {
-						this.blockUpdatePathLengths(newSegment.parent, seq, clientId);
-					}
-				} else if (oldest && newest?.clientId === clientId) {
-					newSegment.prevObliterateByInserter = newest;
+					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);
 		}
 	}
 
@@ -1706,7 +1689,8 @@ export class MergeTree {
 			return {};
 		}
 
-		const next: ISegmentLeaf = segment.splitAt(pos)!;
+		const next = segment.splitAt(pos)!;
+		assertSegmentLeaf(next);
 
 		if (segment?.segmentGroups) {
 			next.segmentGroups ??= new SegmentGroupCollection(next);
@@ -1762,10 +1746,8 @@ export class MergeTree {
 
 			return (
 				newSeq > segSeq ||
-				(node.movedSeq !== undefined &&
-					node.movedSeq !== UnassignedSequenceNumber &&
-					node.movedSeq > seq) ||
-				(node.removedSeq !== undefined &&
+				(isMoved(node) && node.movedSeq !== UnassignedSequenceNumber && node.movedSeq > seq) ||
+				(isRemoved(node) &&
 					node.removedSeq !== UnassignedSequenceNumber &&
 					node.removedSeq > seq)
 			);
@@ -1788,7 +1770,7 @@ export class MergeTree {
 		const children = block.children;
 		let childIndex: number;
 		let child: IMergeNode;
-		let newNode: IMergeNode | undefined;
+		let newNode: IMergeNodeBuilder | undefined;
 		let fromSplit: MergeBlock | undefined;
 		for (childIndex = 0; childIndex < block.childCount; childIndex++) {
 			child = children[childIndex];
@@ -1812,7 +1794,7 @@ export class MergeTree {
 					const segment = child;
 					const segmentChanges = context.leaf(segment, _pos, context);
 					if (segmentChanges.replaceCurrent) {
-						block.assignChild(segmentChanges.replaceCurrent, childIndex, false);
+						assignChild(block, segmentChanges.replaceCurrent, childIndex, false);
 						segmentChanges.replaceCurrent.ordinal = child.ordinal;
 					}
 					if (segmentChanges.next) {
@@ -1865,7 +1847,7 @@ export class MergeTree {
 				block.children[i] = block.children[i - 1];
 				block.children[i].index = i;
 			}
-			block.assignChild(newNode, childIndex, false);
+			assignChild(block, newNode, childIndex, false);
 			block.childCount++;
 			block.setOrdinal(newNode, childIndex);
 			if (block.childCount < MaxNodesInBlock) {
@@ -1900,7 +1882,7 @@ export class MergeTree {
 		// Update ordinals to reflect lowered child count
 		this.nodeUpdateOrdinals(node);
 		for (let i = 0; i < halfCount; i++) {
-			newNode.assignChild(node.children[halfCount + i], i, false);
+			assignChild(newNode, node.children[halfCount + i], i, false);
 			node.children[halfCount + i] = undefined!;
 		}
 		this.nodeUpdateLengthNewStructure(node);
@@ -1937,7 +1919,7 @@ export class MergeTree {
 		clientId: number,
 		seq: number,
 		opArgs: IMergeTreeDeltaOpArgs,
-		// eslint-disable-next-line import/no-deprecated
+
 		rollback: PropertiesRollback = PropertiesRollback.None,
 	): void {
 		if (propsOrAdjust.adjust !== undefined) {
@@ -1949,7 +1931,7 @@ export class MergeTree {
 		const deltaSegments: IMergeTreeSegmentDelta[] = [];
 		const localSeq =
 			seq === UnassignedSequenceNumber ? ++this.collabWindow.localSeq : undefined;
-		// eslint-disable-next-line import/no-deprecated
+
 		let segmentGroup: SegmentGroup | undefined;
 		const opObj = propsOrAdjust.props ?? propsOrAdjust.adjust;
 		const annotateSegment = (segment: ISegmentLeaf): boolean => {
@@ -1990,7 +1972,7 @@ export class MergeTree {
 			return true;
 		};
 
-		this.nodeMap(refSeq, clientId, annotateSegment, undefined, undefined, start, end);
+		this.nodeMap(refSeq, clientId, annotateSegment, undefined, start, end);
 
 		// OpArgs == undefined => test code
 		if (deltaSegments.length > 0) {
@@ -2024,10 +2006,11 @@ export class MergeTree {
 
 		let _overwrite = false;
 		const localOverlapWithRefs: ISegmentLeaf[] = [];
-		const movedSegments: IMergeTreeSegmentDelta[] = [];
+		// eslint-disable-next-line import/no-deprecated
+		const movedSegments: SegmentWithInfo<IMoveInfo, ISegmentLeaf>[] = [];
 		const localSeq =
 			seq === UnassignedSequenceNumber ? ++this.collabWindow.localSeq : undefined;
-		// eslint-disable-next-line import/no-deprecated
+
 		const obliterate: ObliterateInfo = {
 			clientId,
 			end: createDetachedLocalReferencePosition(undefined),
@@ -2041,7 +2024,7 @@ export class MergeTree {
 		const { segment: startSeg } = this.getContainingSegment(start.pos, refSeq, clientId);
 		const { segment: endSeg } = this.getContainingSegment(end.pos, refSeq, clientId);
 		assert(
-			startSeg !== undefined && endSeg !== undefined,
+			isSegmentLeaf(startSeg) && isSegmentLeaf(endSeg),
 			0xa3f /* segments cannot be undefined */,
 		);
 
@@ -2078,12 +2061,7 @@ export class MergeTree {
 		}
 		this.obliterates.addOrUpdate(obliterate);
 
-		const markMoved = (
-			segment: ISegmentLeaf,
-			pos: number,
-			_start: number,
-			_end: number,
-		): boolean => {
+		const markMoved = (segment: ISegmentLeaf, pos: number): boolean => {
 			if (
 				(start.side === Side.After && startPos === pos + segment.cachedLength) || // exclusive start segment
 				(end.side === Side.Before &&
@@ -2103,26 +2081,29 @@ export class MergeTree {
 				return true;
 			}
 
-			if (
+			const wasMovedOnInsert =
 				clientId !== segment.clientId &&
 				segment.seq !== undefined &&
 				seq !== UnassignedSequenceNumber &&
-				(refSeq < segment.seq || segment.seq === UnassignedSequenceNumber)
-			) {
-				segment.wasMovedOnInsert = true;
-			}
+				(refSeq < segment.seq || segment.seq === UnassignedSequenceNumber);
 
 			if (existingMoveInfo === undefined) {
-				segment.movedClientIds = [clientId];
-				segment.movedSeq = seq;
-				segment.localMovedSeq = localSeq;
-				segment.movedSeqs = [seq];
+				// eslint-disable-next-line import/no-deprecated
+				const movedSeg = overwriteInfo<IMoveInfo, ISegmentLeaf>(segment, {
+					movedClientIds: [clientId],
+					movedSeq: seq,
+					localMovedSeq: localSeq,
+					movedSeqs: [seq],
+					wasMovedOnInsert,
+				});
 
-				if (!toRemovalInfo(segment)) {
-					movedSegments.push({ segment });
+				if (!toRemovalInfo(movedSeg)) {
+					movedSegments.push(movedSeg);
 				}
 			} else {
 				_overwrite = true;
+				// never move wasMovedOnInsert from true to false
+				existingMoveInfo.wasMovedOnInsert ||= wasMovedOnInsert;
 				if (existingMoveInfo.movedSeq === UnassignedSequenceNumber) {
 					// we moved this locally, but someone else moved it first
 					// so put them at the head of the list
@@ -2141,7 +2122,7 @@ export class MergeTree {
 					existingMoveInfo.movedSeqs.push(seq);
 				}
 			}
-
+			assertMoved(segment);
 			// Save segment so can assign moved sequence number when acked by server
 			if (this.collabWindow.collaborating) {
 				if (
@@ -2162,12 +2143,7 @@ export class MergeTree {
 			return true;
 		};
 
-		const afterMarkMoved = (
-			node: MergeBlock,
-			pos: number,
-			_start: number,
-			_end: number,
-		): boolean => {
+		const afterMarkMoved = (node: MergeBlock): boolean => {
 			if (_overwrite) {
 				this.nodeUpdateLengthNewStructure(node);
 			} else {
@@ -2180,7 +2156,6 @@ export class MergeTree {
 			refSeq,
 			clientId,
 			markMoved,
-			undefined,
 			afterMarkMoved,
 			start.pos,
 			end.pos + 1, // include the segment containing the end reference
@@ -2193,7 +2168,7 @@ export class MergeTree {
 		if (start.pos !== end.pos || start.side !== end.side) {
 			this.mergeTreeDeltaCallback?.(opArgs, {
 				operation: MergeTreeDeltaType.OBLITERATE,
-				deltaSegments: movedSegments,
+				deltaSegments: movedSegments.map((segment) => ({ segment })),
 			});
 		}
 
@@ -2201,7 +2176,7 @@ export class MergeTree {
 		// 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 (
@@ -2255,9 +2230,10 @@ export class MergeTree {
 		let _overwrite = false;
 		this.ensureIntervalBoundary(start, refSeq, clientId);
 		this.ensureIntervalBoundary(end, refSeq, clientId);
-		// eslint-disable-next-line import/no-deprecated
+
 		let segmentGroup: SegmentGroup;
-		const removedSegments: IMergeTreeSegmentDelta[] = [];
+		// eslint-disable-next-line import/no-deprecated
+		const removedSegments: SegmentWithInfo<IRemovalInfo, ISegmentLeaf>[] = [];
 		const localOverlapWithRefs: ISegmentLeaf[] = [];
 		const localSeq =
 			seq === UnassignedSequenceNumber ? ++this.collabWindow.localSeq : undefined;
@@ -2270,12 +2246,15 @@ export class MergeTree {
 			const existingRemovalInfo = toRemovalInfo(segment);
 
 			if (existingRemovalInfo === undefined) {
-				segment.removedClientIds = [clientId];
-				segment.removedSeq = seq;
-				segment.localRemovedSeq = localSeq;
+				// eslint-disable-next-line import/no-deprecated
+				const removed = overwriteInfo<IRemovalInfo, ISegmentLeaf>(segment, {
+					removedClientIds: [clientId],
+					removedSeq: seq,
+					localRemovedSeq: localSeq,
+				});
 
-				if (!toMoveInfo(segment)) {
-					removedSegments.push({ segment });
+				if (!toMoveInfo(removed)) {
+					removedSegments.push(removed);
 				}
 			} else {
 				_overwrite = true;
@@ -2295,7 +2274,7 @@ export class MergeTree {
 					existingRemovalInfo.removedClientIds.push(clientId);
 				}
 			}
-
+			assertRemoved(segment);
 			// Save segment so we can assign removed sequence number when acked by server
 			if (this.collabWindow.collaborating) {
 				if (
@@ -2311,12 +2290,7 @@ export class MergeTree {
 			}
 			return true;
 		};
-		const afterMarkRemoved = (
-			node: MergeBlock,
-			pos: number,
-			_start: number,
-			_end: number,
-		): boolean => {
+		const afterMarkRemoved = (node: MergeBlock): boolean => {
 			if (_overwrite) {
 				this.nodeUpdateLengthNewStructure(node);
 			} else {
@@ -2324,7 +2298,7 @@ export class MergeTree {
 			}
 			return true;
 		};
-		this.nodeMap(refSeq, clientId, markRemoved, undefined, afterMarkRemoved, start, end);
+		this.nodeMap(refSeq, clientId, markRemoved, afterMarkRemoved, start, end);
 		// these segments are already viewed as being removed locally and are not event-ed
 		// so can slide non-StayOnRemove refs immediately
 		this.slideAckedRemovedSegmentReferences(localOverlapWithRefs);
@@ -2332,14 +2306,14 @@ export class MergeTree {
 		if (removedSegments.length > 0) {
 			this.mergeTreeDeltaCallback?.(opArgs, {
 				operation: MergeTreeDeltaType.REMOVE,
-				deltaSegments: removedSegments,
+				deltaSegments: removedSegments.map((segment) => ({ segment })),
 			});
 		}
 		// these events are newly removed
 		// so we slide after eventing in case the consumer wants to make reference
 		// changes at remove time, like add a ref to track undo redo.
 		if (!this.collabWindow.collaborating || clientId !== this.collabWindow.clientId) {
-			this.slideAckedRemovedSegmentReferences(removedSegments.map(({ segment }) => segment));
+			this.slideAckedRemovedSegmentReferences(removedSegments);
 		}
 
 		if (
@@ -2354,36 +2328,30 @@ export class MergeTree {
 	/**
 	 * Revert an unacked local op
 	 */
-	// eslint-disable-next-line import/no-deprecated
+
 	public rollback(op: IMergeTreeDeltaOp, localOpMetadata: SegmentGroup): void {
 		if (op.type === MergeTreeDeltaType.REMOVE) {
-			const pendingSegmentGroup = this.pendingSegments.pop?.()?.data;
+			const pendingSegmentGroup = this.pendingSegments.pop()?.data;
 			if (pendingSegmentGroup === undefined || pendingSegmentGroup !== localOpMetadata) {
 				throw new Error("Rollback op doesn't match last edit");
 			}
 			// Disabling because a for of loop causes the type of segment to be ISegmentLeaf, which does not have parent information stored
 			// eslint-disable-next-line unicorn/no-array-for-each
 			pendingSegmentGroup.segments.forEach((segment: ISegmentLeaf) => {
-				const segmentSegmentGroup = segment?.segmentGroups?.pop?.();
+				const segmentSegmentGroup = segment?.segmentGroups?.pop();
 				assert(
 					segmentSegmentGroup === pendingSegmentGroup,
 					0x3ee /* Unexpected segmentGroup in segment */,
 				);
 
 				assert(
-					segment.removedClientIds !== undefined &&
-						segment.removedClientIds[0] === this.collabWindow.clientId,
+					isRemoved(segment) && segment.removedClientIds[0] === this.collabWindow.clientId,
 					0x39d /* Rollback segment removedClientId does not match local client */,
 				);
-				segment.removedClientIds = undefined;
-				segment.removedSeq = undefined;
-				segment.localRemovedSeq = undefined;
+				let updateNode: MergeBlock | undefined = segment.parent;
+				removeRemovalInfo(segment);
 
-				for (
-					let updateNode = segment.parent;
-					updateNode !== undefined;
-					updateNode = updateNode.parent
-				) {
+				for (updateNode; updateNode !== undefined; updateNode = updateNode.parent) {
 					this.blockUpdateLength(
 						updateNode,
 						UnassignedSequenceNumber,
@@ -2405,7 +2373,7 @@ export class MergeTree {
 			op.type === MergeTreeDeltaType.INSERT ||
 			op.type === MergeTreeDeltaType.ANNOTATE
 		) {
-			const pendingSegmentGroup = this.pendingSegments.pop?.()?.data;
+			const pendingSegmentGroup = this.pendingSegments.pop()?.data;
 			if (
 				pendingSegmentGroup === undefined ||
 				pendingSegmentGroup !== localOpMetadata ||
@@ -2414,8 +2382,8 @@ export class MergeTree {
 				throw new Error("Rollback op doesn't match last edit");
 			}
 			let i = 0;
-			for (const segment of pendingSegmentGroup.segments as ISegmentLeaf[]) {
-				const segmentSegmentGroup = segment?.segmentGroups?.pop?.();
+			for (const segment of pendingSegmentGroup.segments) {
+				const segmentSegmentGroup = segment?.segmentGroups?.pop();
 				assert(
 					segmentSegmentGroup === pendingSegmentGroup,
 					0x3ef /* Unexpected segmentGroup in segment */,
@@ -2467,7 +2435,7 @@ export class MergeTree {
 			}
 
 			// If not removed, increase position
-			if (seg.removedSeq === undefined) {
+			if (!isRemoved(seg)) {
 				segmentPosition += seg.cachedLength;
 			}
 
@@ -2488,7 +2456,7 @@ export class MergeTree {
 	public removeLocalReferencePosition(
 		lref: LocalReferencePosition,
 	): LocalReferencePosition | undefined {
-		const segment: ISegmentLeaf | undefined = lref.getSegment();
+		const segment: ISegmentPrivate | undefined = lref.getSegment();
 		return segment?.localRefs?.removeLocalRef(lref);
 	}
 
@@ -2496,7 +2464,7 @@ export class MergeTree {
 	endOfTree = new EndOfTreeSegment(this);
 
 	public createLocalReferencePosition(
-		_segment: ISegmentLeaf | "start" | "end",
+		_segment: ISegmentPrivate | "start" | "end",
 		offset: number,
 		refType: ReferenceType,
 		properties: PropertySet | undefined,
@@ -2517,7 +2485,6 @@ export class MergeTree {
 				"Can only create SlideOnRemove or Transient local reference position on a removed or obliterated segment",
 			);
 		}
-
 		let segment: ISegmentLeaf;
 
 		if (_segment === "start") {
@@ -2525,6 +2492,7 @@ export class MergeTree {
 		} else if (_segment === "end") {
 			segment = this.endOfTree;
 		} else {
+			assertSegmentLeaf(_segment);
 			segment = _segment;
 		}
 
@@ -2613,7 +2581,7 @@ export class MergeTree {
 		for (let i = 0; i < newOrder.length; i++) {
 			const seg = newOrder[i];
 			const { parent, index, ordinal } = currentOrder[i];
-			parent?.assignChild(seg, index, false);
+			assignChild(parent, seg, index, false);
 			seg.ordinal = ordinal;
 		}
 
@@ -2811,8 +2779,7 @@ export class MergeTree {
 		this.nodeMap(
 			refSeq,
 			clientId,
-			handler,
-			accum,
+			(seg, pos, _start, _end) => handler(seg, pos, refSeq, clientId, _start, _end, accum),
 			undefined,
 			start,
 			end,
@@ -2844,12 +2811,11 @@ 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.
 	 */
-	private nodeMap<TClientData>(
+	private nodeMap(
 		refSeq: number,
 		clientId: number,
-		leaf: ISegmentAction<TClientData>,
-		accum: TClientData,
-		post?: BlockAction<TClientData>,
+		leaf: (segment: ISegmentLeaf, pos: number, start: number, end: number) => boolean,
+		post?: (block: MergeBlock) => boolean,
 		start: number = 0,
 		end?: number,
 		localSeq?: number,
@@ -2895,17 +2861,14 @@ export class MergeTree {
 				}
 
 				if (node.isLeaf()) {
-					if (leaf(node, pos, refSeq, clientId, start - pos, endPos - pos, accum) === false) {
+					if (leaf(node, pos, start - pos, endPos - pos) === false) {
 						return NodeAction.Exit;
 					}
 					pos = nextPos;
 				}
 			},
 			undefined,
-			post === undefined
-				? undefined
-				: (block): boolean =>
-						post(block, pos, refSeq, clientId, start - pos, endPos - pos, accum),
+			post,
 		);
 	}
 }