@fluidframework/merge-tree 2.0.0-rc.2.0.1 → 2.0.0-rc.3.0.0

package/src/mergeTree.ts

@@ -6,9 +6,12 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
 /* eslint-disable no-bitwise */
 
-import { assert, Heap, IComparer } from "@fluidframework/core-utils";
-import { DataProcessingError, UsageError } from "@fluidframework/telemetry-utils";
+import { assert, Heap, IComparer } from "@fluidframework/core-utils/internal";
+import { DataProcessingError, UsageError } from "@fluidframework/telemetry-utils/internal";
+
 import { IAttributionCollectionSerializer } from "./attributionCollection.js";
+// eslint-disable-next-line import/no-deprecated
+import { Client } from "./client.js";
 import { DoublyLinkedList, ListNode } from "./collections/index.js";
 import {
 	NonCollabClient,
@@ -16,69 +19,66 @@ import {
 	UnassignedSequenceNumber,
 	UniversalSequenceNumber,
 } from "./constants.js";
+import { EndOfTreeSegment, StartOfTreeSegment } from "./endOfTreeSegment.js";
 import {
-	anyLocalReferencePosition,
-	filterLocalReferencePositions,
 	LocalReferenceCollection,
 	LocalReferencePosition,
 	SlidingPreference,
+	anyLocalReferencePosition,
+	filterLocalReferencePositions,
 } from "./localReference.js";
+import {
+	IMergeTreeDeltaOpArgs,
+	IMergeTreeSegmentDelta,
+	MergeTreeDeltaCallback,
+	MergeTreeMaintenanceCallback,
+	MergeTreeMaintenanceType,
+} from "./mergeTreeDeltaCallback.js";
+import {
+	NodeAction,
+	backwardExcursion,
+	depthFirstNodeWalk,
+	forwardExcursion,
+	walkAllChildSegments,
+} from "./mergeTreeNodeWalk.js";
 import {
 	BlockAction,
 	// eslint-disable-next-line import/no-deprecated
 	CollaborationWindow,
-	IHierBlock,
-	IMergeBlock,
-	ISegmentLeaf,
+	HierMergeBlock,
 	IMergeNode,
 	IMoveInfo,
-	InsertContext,
 	IRemovalInfo,
 	ISegment,
 	ISegmentAction,
 	ISegmentChanges,
+	ISegmentLeaf,
+	InsertContext,
 	Marker,
 	MaxNodesInBlock,
 	MergeBlock,
-	reservedMarkerIdKey,
 	// eslint-disable-next-line import/no-deprecated
 	SegmentGroup,
-	toMoveInfo,
+	reservedMarkerIdKey,
 	seqLTE,
+	toMoveInfo,
 	toRemovalInfo,
 } from "./mergeTreeNodes.js";
-import {
-	IMergeTreeDeltaOpArgs,
-	IMergeTreeSegmentDelta,
-	MergeTreeDeltaCallback,
-	MergeTreeMaintenanceCallback,
-	MergeTreeMaintenanceType,
-} from "./mergeTreeDeltaCallback.js";
+import type { TrackingGroup } from "./mergeTreeTracking.js";
 import { createAnnotateRangeOp, createInsertSegmentOp, createRemoveRangeOp } from "./opBuilder.js";
 import { IMergeTreeDeltaOp, IRelativePosition, MergeTreeDeltaType, ReferenceType } from "./ops.js";
 import { PartialSequenceLengths } from "./partialLengths.js";
 // eslint-disable-next-line import/no-deprecated
-import { createMap, extend, extendIfUndefined, MapLike, PropertySet } from "./properties.js";
+import { MapLike, PropertySet, createMap, extend, extendIfUndefined } from "./properties.js";
 import {
-	refTypeIncludesFlag,
-	ReferencePosition,
 	DetachedReferencePosition,
+	ReferencePosition,
 	refGetTileLabels,
 	refHasTileLabel,
+	refTypeIncludesFlag,
 } from "./referencePositions.js";
 import { PropertiesRollback } from "./segmentPropertiesManager.js";
-import {
-	backwardExcursion,
-	depthFirstNodeWalk,
-	forwardExcursion,
-	NodeAction,
-	walkAllChildSegments,
-} from "./mergeTreeNodeWalk.js";
-import type { TrackingGroup } from "./mergeTreeTracking.js";
 import { zamboniSegments } from "./zamboni.js";
-// eslint-disable-next-line import/no-deprecated
-import { Client } from "./client.js";
-import { EndOfTreeSegment, StartOfTreeSegment } from "./endOfTreeSegment.js";
 
 function wasRemovedAfter(seg: ISegment, seq: number): boolean {
 	return (
@@ -154,23 +154,6 @@ function addTileIfNotPresent(tile: ReferencePosition, tiles: MapLike<ReferencePo
 	}
 }
 
-class HierMergeBlock extends MergeBlock implements IHierBlock {
-	public rightmostTiles: MapLike<ReferencePosition>;
-	public leftmostTiles: MapLike<ReferencePosition>;
-
-	constructor(childCount: number) {
-		super(childCount);
-		// eslint-disable-next-line import/no-deprecated
-		this.rightmostTiles = createMap<ReferencePosition>();
-		// eslint-disable-next-line import/no-deprecated
-		this.leftmostTiles = createMap<ReferencePosition>();
-	}
-
-	public hierBlock() {
-		return this;
-	}
-}
-
 /**
  * @alpha
  */
@@ -279,7 +262,7 @@ export interface LRUSegment {
 	maxSeq: number;
 }
 
-export interface IRootMergeBlock extends IMergeBlock {
+export interface IRootMergeBlock extends MergeBlock {
 	mergeTree?: MergeTree;
 }
 
@@ -422,7 +405,7 @@ export class MergeTree {
 		zamboniSegments: true,
 	};
 
-	private static readonly theUnfinishedNode = { childCount: -1 } as unknown as IMergeBlock;
+	private static readonly theUnfinishedNode = { childCount: -1 } as unknown as MergeBlock;
 
 	// eslint-disable-next-line import/no-deprecated
 	public readonly collabWindow = new CollaborationWindow();
@@ -575,7 +558,7 @@ export class MergeTree {
 		}
 	}
 
-	private addNode(block: IMergeBlock, node: IMergeNode) {
+	private addNode(block: MergeBlock, node: IMergeNode) {
 		const index = block.childCount++;
 		block.assignChild(node, index, false);
 		return index;
@@ -593,7 +576,7 @@ export class MergeTree {
 		// Starting with the leaf segments, recursively builds the B-Tree layer by layer from the bottom up.
 		const buildMergeBlock = (nodes: IMergeNode[]): IRootMergeBlock => {
 			const blockCount = Math.ceil(nodes.length / maxChildren); // Compute # blocks require for this level of B-Tree
-			const blocks: IMergeBlock[] = new Array(blockCount); // Pre-alloc array to collect nodes
+			const blocks: MergeBlock[] = new Array(blockCount); // Pre-alloc array to collect nodes
 
 			// For each block in this level of the B-Tree...
 			for (
@@ -676,7 +659,7 @@ export class MergeTree {
 
 		let totalOffset = 0;
 		let parent = node.parent;
-		let prevParent: IMergeBlock | undefined;
+		let prevParent: MergeBlock | undefined;
 		while (parent) {
 			const children = parent.children;
 			for (let childIndex = 0; childIndex < parent.childCount; childIndex++) {
@@ -927,7 +910,7 @@ export class MergeTree {
 		);
 	}
 
-	private blockLength(node: IMergeBlock, refSeq: number, clientId: number): number {
+	private blockLength(node: MergeBlock, refSeq: number, clientId: number): number {
 		return this.collabWindow.collaborating && clientId !== this.collabWindow.clientId
 			? node.partialLengths!.getPartialLength(refSeq, clientId)
 			: node.cachedLength ?? 0;
@@ -1110,16 +1093,16 @@ export class MergeTree {
 		depthFirstNodeWalk(
 			segWithParent.parent,
 			segWithParent,
-			(seg) => {
-				if (seg.isLeaf()) {
-					if (Marker.is(seg) && refHasTileLabel(seg, markerLabel)) {
-						foundMarker = seg;
+			(node) => {
+				if (node.isLeaf()) {
+					if (Marker.is(node) && refHasTileLabel(node, markerLabel)) {
+						foundMarker = node;
 					}
 				} else {
-					const block = seg as IHierBlock;
+					assert(node.hierBlock(), 0x90b /* must be hierBlock */);
 					const marker = forwards
-						? block.leftmostTiles[markerLabel]
-						: block.rightmostTiles[markerLabel];
+						? node.leftmostTiles[markerLabel]
+						: node.rightmostTiles[markerLabel];
 					if (marker !== undefined) {
 						assert(
 							marker.isLeaf() && Marker.is(marker),
@@ -1138,7 +1121,7 @@ export class MergeTree {
 		return foundMarker;
 	}
 
-	private updateRoot(splitNode: IMergeBlock | undefined) {
+	private updateRoot(splitNode: MergeBlock | undefined) {
 		if (splitNode !== undefined) {
 			const newRoot = this.makeBlock(2);
 			newRoot.assignChild(this.root, 0, false);
@@ -1156,7 +1139,7 @@ export class MergeTree {
 	public ackPendingSegment(opArgs: IMergeTreeDeltaOpArgs) {
 		const seq = opArgs.sequencedMessage!.sequenceNumber;
 		const pendingSegmentGroup = this.pendingSegments.shift()?.data;
-		const nodesToUpdate: IMergeBlock[] = [];
+		const nodesToUpdate: MergeBlock[] = [];
 		let overwrite = false;
 		if (pendingSegmentGroup !== undefined) {
 			const deltaSegments: IMergeTreeSegmentDelta[] = [];
@@ -1401,7 +1384,7 @@ export class MergeTree {
 		localSeq: number | undefined,
 		newSegments: T[],
 	) {
-		const continueFrom = (node: IMergeBlock) => {
+		const continueFrom = (node: MergeBlock) => {
 			let siblingExists = false;
 			forwardExcursion(node, () => {
 				siblingExists = true;
@@ -1682,7 +1665,7 @@ export class MergeTree {
 	}
 
 	private insertingWalk(
-		block: IMergeBlock,
+		block: MergeBlock,
 		pos: number,
 		refSeq: number,
 		clientId: number,
@@ -1695,7 +1678,7 @@ export class MergeTree {
 		let childIndex: number;
 		let child: IMergeNode;
 		let newNode: IMergeNode | undefined;
-		let fromSplit: IMergeBlock | undefined;
+		let fromSplit: MergeBlock | undefined;
 		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
@@ -1801,7 +1784,7 @@ export class MergeTree {
 		}
 	}
 
-	private split(node: IMergeBlock) {
+	private split(node: MergeBlock) {
 		const halfCount = MaxNodesInBlock / 2;
 		const newNode = this.makeBlock(halfCount);
 		node.childCount = halfCount;
@@ -1816,7 +1799,7 @@ export class MergeTree {
 		return newNode;
 	}
 
-	public nodeUpdateOrdinals(block: IMergeBlock) {
+	public nodeUpdateOrdinals(block: MergeBlock) {
 		for (let i = 0; i < block.childCount; i++) {
 			const child = block.children[i];
 			block.setOrdinal(child, i);
@@ -1987,7 +1970,7 @@ export class MergeTree {
 			return true;
 		};
 
-		const afterMarkMoved = (node: IMergeBlock, pos: number, _start: number, _end: number) => {
+		const afterMarkMoved = (node: MergeBlock, pos: number, _start: number, _end: number) => {
 			if (_overwrite) {
 				this.nodeUpdateLengthNewStructure(node);
 			} else {
@@ -2098,7 +2081,7 @@ export class MergeTree {
 			}
 			return true;
 		};
-		const afterMarkRemoved = (node: IMergeBlock, pos: number, _start: number, _end: number) => {
+		const afterMarkRemoved = (node: MergeBlock, pos: number, _start: number, _end: number) => {
 			if (_overwrite) {
 				this.nodeUpdateLengthNewStructure(node);
 			} else {
@@ -2260,7 +2243,7 @@ export class MergeTree {
 		return segmentPosition;
 	}
 
-	public nodeUpdateLengthNewStructure(node: IMergeBlock, recur = false) {
+	public nodeUpdateLengthNewStructure(node: MergeBlock, recur = false) {
 		this.blockUpdate(node);
 		if (this.collabWindow.collaborating) {
 			this.localPartialsComputed = false;
@@ -2498,22 +2481,21 @@ export class MergeTree {
 				}
 			}
 		} else {
-			const block = node as IHierBlock;
+			assert(node.hierBlock(), 0x90c /* must be hier block */);
 			// eslint-disable-next-line import/no-deprecated
-			extend(rightmostTiles, block.rightmostTiles);
+			extend(rightmostTiles, node.rightmostTiles);
 			// eslint-disable-next-line import/no-deprecated
-			extendIfUndefined(leftmostTiles, block.leftmostTiles);
+			extendIfUndefined(leftmostTiles, node.leftmostTiles);
 		}
 	}
 
-	private blockUpdate(block: IMergeBlock) {
+	private blockUpdate(block: MergeBlock) {
 		let len: number | undefined;
-		const hierBlock = block.hierBlock();
-		if (hierBlock) {
+		if (block.hierBlock()) {
 			// eslint-disable-next-line import/no-deprecated
-			hierBlock.rightmostTiles = createMap<Marker>();
+			block.rightmostTiles = createMap<Marker>();
 			// eslint-disable-next-line import/no-deprecated
-			hierBlock.leftmostTiles = createMap<Marker>();
+			block.leftmostTiles = createMap<Marker>();
 		}
 		for (let i = 0; i < block.childCount; i++) {
 			const child = block.children[i];
@@ -2522,8 +2504,8 @@ export class MergeTree {
 				len ??= 0;
 				len += nodeLength;
 			}
-			if (hierBlock) {
-				this.addNodeReferences(child, hierBlock.rightmostTiles, hierBlock.leftmostTiles);
+			if (block.hierBlock()) {
+				this.addNodeReferences(child, block.rightmostTiles, block.leftmostTiles);
 			}
 		}
 
@@ -2531,12 +2513,12 @@ export class MergeTree {
 	}
 
 	public blockUpdatePathLengths(
-		startBlock: IMergeBlock | undefined,
+		startBlock: MergeBlock | undefined,
 		seq: number,
 		clientId: number,
 		newStructure = false,
 	) {
-		let block: IMergeBlock | undefined = startBlock;
+		let block: MergeBlock | undefined = startBlock;
 		while (block !== undefined) {
 			if (newStructure) {
 				this.nodeUpdateLengthNewStructure(block);
@@ -2547,7 +2529,7 @@ export class MergeTree {
 		}
 	}
 
-	private blockUpdateLength(node: IMergeBlock, seq: number, clientId: number) {
+	private blockUpdateLength(node: MergeBlock, seq: number, clientId: number) {
 		this.blockUpdate(node);
 		this.localPartialsComputed = false;
 		if (

package/src/mergeTreeDeltaCallback.ts

@@ -2,11 +2,13 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
+
 import { ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
+
+import { ISegment } from "./mergeTreeNodes.js";
 // eslint-disable-next-line import/no-deprecated
 import { IMergeTreeGroupMsg, IMergeTreeOp, MergeTreeDeltaType } from "./ops.js";
 import { PropertySet } from "./properties.js";
-import { ISegment } from "./mergeTreeNodes.js";
 
 /**
  * @alpha

package/src/mergeTreeNodeWalk.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { IMergeBlock, IMergeNode, ISegment } from "./mergeTreeNodes.js";
+import { type MergeBlock, IMergeNode, ISegment } from "./mergeTreeNodes.js";
 
 export const LeafAction = {
 	Exit: false,
@@ -33,11 +33,11 @@ export type NodeAction = (typeof NodeAction)[keyof typeof NodeAction] | Exclude<
  * @returns true if we naturally exit, false if exiting due to Exit action result
  */
 export function depthFirstNodeWalk(
-	startBlock: IMergeBlock,
+	startBlock: MergeBlock,
 	startChild: IMergeNode | undefined,
 	downAction?: (node: IMergeNode) => NodeAction,
 	leafActionOverride?: (seg: ISegment) => LeafAction,
-	upAction?: (block: IMergeBlock) => void,
+	upAction?: (block: MergeBlock) => void,
 	forward: boolean = true,
 ): boolean {
 	const increment = forward ? 1 : -1;
@@ -56,7 +56,7 @@ export function depthFirstNodeWalk(
 		let blockResult: NodeAction;
 		while (start?.isLeaf() === false) {
 			// cast is safe due to isLeaf === false in while above
-			block = start as IMergeBlock;
+			block = start as MergeBlock;
 			childCount = block.childCount;
 			blockResult = downAction?.(block);
 			// setting start undefined will skip the leaf walk
@@ -168,7 +168,7 @@ export function backwardExcursion(
  * @returns true if we naturally exit, false if exiting due to leaf action result
  */
 export function walkAllChildSegments(
-	startBlock: IMergeBlock,
+	startBlock: MergeBlock,
 	leafAction: (segment: ISegment) => boolean | undefined | void,
 ): boolean {
 	if (startBlock.childCount === 0) {
@@ -177,7 +177,7 @@ export function walkAllChildSegments(
 
 	// undefined shouldn't actually be added, but this allows subsequent check for `node.parent` to typecheck
 	// without further runtime work.
-	const ancestors = new Set<IMergeBlock | undefined>();
+	const ancestors = new Set<MergeBlock | undefined>();
 	for (let cur = startBlock.parent; cur !== undefined; cur = cur.parent) {
 		ancestors.add(cur);
 	}

package/src/mergeTreeNodes.ts

@@ -5,8 +5,9 @@
 
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
 
-import { assert } from "@fluidframework/core-utils";
-import { AttributionKey } from "@fluidframework/runtime-definitions";
+import { assert } from "@fluidframework/core-utils/internal";
+import { AttributionKey } from "@fluidframework/runtime-definitions/internal";
+
 import { IAttributionCollection } from "./attributionCollection.js";
 import { LocalClientId, UnassignedSequenceNumber, UniversalSequenceNumber } from "./constants.js";
 import { LocalReferenceCollection } from "./localReference.js";
@@ -14,10 +15,10 @@ import { IMergeTreeDeltaOpArgs } from "./mergeTreeDeltaCallback.js";
 import { TrackingGroupCollection } from "./mergeTreeTracking.js";
 import { IJSONSegment, IMarkerDef, MergeTreeDeltaType, ReferenceType } from "./ops.js";
 import { computeHierarchicalOrdinal } from "./ordinal.js";
-import { PartialSequenceLengths } from "./partialLengths.js";
+import type { PartialSequenceLengths } from "./partialLengths.js";
 // eslint-disable-next-line import/no-deprecated
-import { clone, createMap, MapLike, PropertySet } from "./properties.js";
-import { refTypeIncludesFlag, ReferencePosition, refGetTileLabels } from "./referencePositions.js";
+import { PropertySet, clone, createMap, type MapLike } from "./properties.js";
+import { ReferencePosition, refGetTileLabels, refTypeIncludesFlag } from "./referencePositions.js";
 import { SegmentGroupCollection } from "./segmentGroupCollection.js";
 import { PropertiesManager, PropertiesRollback } from "./segmentPropertiesManager.js";
 
@@ -41,52 +42,8 @@ export interface IMergeNodeCommon {
  * someday we may split tree leaves from segments, but for now they are the same
  * this is just a convenience type that makes it clear that we need something that is both a segment and a leaf node
  */
-export type ISegmentLeaf = ISegment & { parent?: IMergeBlock };
-export type IMergeNode = IMergeBlock | ISegmentLeaf;
-/**
- * Internal (i.e. non-leaf) node in a merge tree.
- * @internal
- */
-export interface IMergeBlock extends IMergeNodeCommon {
-	parent?: IMergeBlock;
-
-	needsScour?: boolean;
-	/**
-	 * Number of direct children of this node
-	 */
-	childCount: number;
-	/**
-	 * Array of child nodes.
-	 *
-	 * @remarks To avoid reallocation, this is always initialized to have maximum length as deemed by
-	 * the merge tree's branching factor. Use `childCount` to determine how many children this node actually has.
-	 */
-	children: IMergeNode[];
-	/**
-	 * Supports querying the total length of all descendants of this IMergeBlock from the perspective of any
-	 * (clientId, seq) within the collab window.
-	 *
-	 * @remarks This is only optional for implementation reasons (internal nodes can be created/moved without
-	 * immediately initializing the partial lengths). Aside from mid-update on tree operations, these lengths
-	 * objects are always defined.
-	 */
-	partialLengths?: PartialSequenceLengths;
-	/**
-	 * The length of the contents of the node.
-	 */
-	cachedLength: number | undefined;
-	hierBlock(): IHierBlock | undefined;
-	assignChild(child: IMergeNode, index: number, updateOrdinal?: boolean): void;
-	setOrdinal(child: IMergeNode, index: number): void;
-}
-
-/**
- * @internal
- */
-export interface IHierBlock extends IMergeBlock {
-	rightmostTiles: MapLike<ReferencePosition>;
-	leftmostTiles: MapLike<ReferencePosition>;
-}
+export type ISegmentLeaf = ISegment & { parent?: MergeBlock };
+export type IMergeNode = MergeBlock | ISegmentLeaf;
 
 /**
  * Contains removal information associated to an {@link ISegment}.
@@ -350,7 +307,7 @@ export interface ISegmentChanges {
 export interface BlockAction<TClientData> {
 	// eslint-disable-next-line @typescript-eslint/prefer-function-type
 	(
-		block: IMergeBlock,
+		block: MergeBlock,
 		pos: number,
 		refSeq: number,
 		clientId: number,
@@ -366,7 +323,7 @@ export interface BlockAction<TClientData> {
 export interface NodeAction<TClientData> {
 	// eslint-disable-next-line @typescript-eslint/prefer-function-type
 	(
-		node: IMergeNode,
+		node: MergeNode,
 		pos: number,
 		refSeq: number,
 		clientId: number,
@@ -382,7 +339,7 @@ export interface NodeAction<TClientData> {
 export interface InsertContext {
 	candidateSegment?: ISegment;
 	leaf: (segment: ISegment | undefined, pos: number, ic: InsertContext) => ISegmentChanges;
-	continuePredicate?: (continueFromBlock: IMergeBlock) => boolean;
+	continuePredicate?: (continueFromBlock: MergeBlock) => boolean;
 }
 
 /**
@@ -409,6 +366,7 @@ export interface SegmentGroup {
 
 /**
  * @alpha
+ * @deprecated - unused and will be removed
  */
 export class MergeNode implements IMergeNodeCommon {
 	index: number = 0;
@@ -431,16 +389,34 @@ export const MaxNodesInBlock = 8;
 /**
  * @internal
  */
-export class MergeBlock extends MergeNode implements IMergeBlock {
-	parent?: IMergeBlock;
+export class MergeBlock implements IMergeNodeCommon {
 	public children: IMergeNode[];
+	public needsScour?: boolean;
+	public parent?: MergeBlock;
+	public index: number = 0;
+	public ordinal: string = "";
+	public cachedLength: number | undefined = 0;
+
+	isLeaf(): this is ISegment {
+		return false;
+	}
+
+	/**
+	 * Supports querying the total length of all descendants of this IMergeBlock from the perspective of any
+	 * (clientId, seq) within the collab window.
+	 *
+	 * @remarks This is only optional for implementation reasons (internal nodes can be created/moved without
+	 * immediately initializing the partial lengths). Aside from mid-update on tree operations, these lengths
+	 * objects are always defined.
+	 */
+	partialLengths?: PartialSequenceLengths;
+
 	public constructor(public childCount: number) {
-		super();
 		this.children = new Array<IMergeNode>(MaxNodesInBlock);
 	}
 
-	public hierBlock(): IHierBlock | undefined {
-		return undefined;
+	public hierBlock(): this is HierMergeBlock {
+		return false;
 	}
 
 	public setOrdinal(child: IMergeNode, index: number) {
@@ -467,6 +443,23 @@ export class MergeBlock extends MergeNode implements IMergeBlock {
 	}
 }
 
+export class HierMergeBlock extends MergeBlock {
+	public rightmostTiles: MapLike<ReferencePosition>;
+	public leftmostTiles: MapLike<ReferencePosition>;
+
+	constructor(childCount: number) {
+		super(childCount);
+		// eslint-disable-next-line import/no-deprecated
+		this.rightmostTiles = createMap<ReferencePosition>();
+		// eslint-disable-next-line import/no-deprecated
+		this.leftmostTiles = createMap<ReferencePosition>();
+	}
+
+	public hierBlock(): this is HierMergeBlock {
+		return true;
+	}
+}
+
 export function seqLTE(seq: number, minOrRefSeq: number) {
 	return seq !== UnassignedSequenceNumber && seq <= minOrRefSeq;
 }
@@ -474,7 +467,7 @@ export function seqLTE(seq: number, minOrRefSeq: number) {
 /**
  * @alpha
  */
-export abstract class BaseSegment extends MergeNode implements ISegment {
+export abstract class BaseSegment implements ISegment {
 	public clientId: number = LocalClientId;
 	public seq: number = UniversalSequenceNumber;
 	public removedSeq?: number;
@@ -483,6 +476,10 @@ export abstract class BaseSegment extends MergeNode implements ISegment {
 	public movedSeqs?: number[];
 	public movedClientIds?: number[];
 	public wasMovedOnInsert?: boolean | undefined;
+	public index: number = 0;
+	public ordinal: string = "";
+	public cachedLength: number = 0;
+
 	public readonly segmentGroups: SegmentGroupCollection = new SegmentGroupCollection(this);
 	public readonly trackingCollection: TrackingGroupCollection = new TrackingGroupCollection(this);
 	/***/
@@ -695,9 +692,10 @@ export abstract class BaseSegment extends MergeNode implements ISegment {
  *
  * @remarks In general, marker ids should be accessed using the inherent method
  * {@link Marker.getId}. Marker ids should not be updated after creation.
- * @internal
+ * @alpha
  */
 export const reservedMarkerIdKey = "markerId";
+
 /**
  * @internal
  */

package/src/opBuilder.ts

@@ -6,14 +6,14 @@
 import { ISegment, Marker } from "./mergeTreeNodes.js";
 import {
 	IMergeTreeAnnotateMsg,
+	IMergeTreeDeltaOp,
 	// eslint-disable-next-line import/no-deprecated
 	IMergeTreeGroupMsg,
 	IMergeTreeInsertMsg,
-	IMergeTreeRemoveMsg,
-	MergeTreeDeltaType,
-	IMergeTreeDeltaOp,
 	// eslint-disable-next-line import/no-deprecated
 	IMergeTreeObliterateMsg,
+	IMergeTreeRemoveMsg,
+	MergeTreeDeltaType,
 } from "./ops.js";
 import { PropertySet } from "./properties.js";
 

package/src/ordinal.ts

@@ -4,7 +4,7 @@
  */
 
 /* eslint-disable no-bitwise */
-import { assert } from "@fluidframework/core-utils";
+import { assert } from "@fluidframework/core-utils/internal";
 
 export function computeHierarchicalOrdinal(
 	maxCount: number,