@fluidframework/merge-tree 1.2.6 → 2.0.0-dev.1.3.0.96595

package/src/mergeTree.ts

@@ -24,7 +24,35 @@ import {
     UnassignedSequenceNumber,
     UniversalSequenceNumber,
 } from "./constants";
-import { LocalReference, LocalReferenceCollection, LocalReferencePosition } from "./localReference";
+import {
+    assertLocalReferences,
+     LocalReferenceCollection,
+     LocalReferencePosition,
+} from "./localReference";
+import {
+	BaseSegment,
+	BlockUpdateActions,
+	CollaborationWindow,
+	IHierBlock,
+	IMergeBlock,
+	IMergeNode,
+	IncrementalExecOp,
+	IncrementalMapState,
+	InsertContext,
+	internedSpaces,
+	ISegment,
+	ISegmentAction,
+	ISegmentChanges,
+	Marker,
+	MaxNodesInBlock,
+	MergeBlock,
+	MergeNode,
+	MergeTreeStats,
+	MinListener,
+	SegmentActions,
+	SegmentGroup,
+	toRemovalInfo,
+ } from "./mergeTreeNodes";
 import {
     IMergeTreeDeltaOpArgs,
     IMergeTreeSegmentDelta,
@@ -32,83 +60,38 @@ import {
     MergeTreeMaintenanceCallback,
     MergeTreeMaintenanceType,
 } from "./mergeTreeDeltaCallback";
-import { TrackingGroupCollection } from "./mergeTreeTracking";
+import { createAnnotateRangeOp, createInsertSegmentOp, createRemoveRangeOp } from "./opBuilder";
 import {
     ICombiningOp,
-    IJSONSegment,
-    IMarkerDef,
+    IMergeTreeDeltaOp,
     IRelativePosition,
     MergeTreeDeltaType,
     ReferenceType,
 } from "./ops";
 import { PartialSequenceLengths } from "./partialLengths";
 import {
-    clone,
     createMap,
     extend,
-    extendIfUndefined,
     MapLike,
     matchProperties,
     PropertySet,
 } from "./properties";
 import {
     refTypeIncludesFlag,
-    RangeStackMap,
     ReferencePosition,
-    refGetRangeLabels,
-    refGetTileLabels,
-    refHasRangeLabel,
-    refHasRangeLabels,
-    refHasTileLabel,
-    refHasTileLabels,
+    DetachedReferencePosition,
+	RangeStackMap,
+	refHasRangeLabel,
+	refGetRangeLabels,
+	refGetTileLabels,
+	refHasTileLabel,
  } from "./referencePositions";
-import { SegmentGroupCollection } from "./segmentGroupCollection";
-import { PropertiesManager } from "./segmentPropertiesManager";
-import { Client } from "./client";
-
-export interface IMergeNodeCommon {
-    parent?: IMergeBlock;
-    /**
-     * The length of the contents of the node.
-     */
-    cachedLength: number;
-    index: number;
-    ordinal: string;
-    isLeaf(): this is ISegment;
-}
-
-export type IMergeNode = IMergeBlock | ISegment;
-
-// Node with segments as children
-export interface IMergeBlock extends IMergeNodeCommon {
-    needsScour?: boolean;
-    childCount: number;
-    children: IMergeNode[];
-    partialLengths?: PartialSequenceLengths;
-    hierBlock(): IHierBlock | undefined;
-    assignChild(child: IMergeNode, index: number, updateOrdinal?: boolean): void;
-    setOrdinal(child: IMergeNode, index: number): void;
-}
-
-export interface IHierBlock extends IMergeBlock {
-    hierToString(indentCount: number): string;
-    addNodeReferences(mergeTree: MergeTree, node: IMergeNode): void;
-    rightmostTiles: MapLike<ReferencePosition>;
-    leftmostTiles: MapLike<ReferencePosition>;
-    rangeStacks: RangeStackMap;
-}
+import { PropertiesRollback } from "./segmentPropertiesManager";
 
-export interface IRemovalInfo {
-    removedSeq: number;
-    removedClientIds: number[];
-}
-export function toRemovalInfo(maybe: Partial<IRemovalInfo> | undefined): IRemovalInfo | undefined {
-    if (maybe?.removedClientIds !== undefined && maybe?.removedSeq !== undefined) {
-        return maybe as IRemovalInfo;
-    }
-    assert(maybe?.removedClientIds === undefined && maybe?.removedSeq === undefined,
-        0x2bf /* "both removedClientIds and removedSeq should be set or not set" */);
-}
+const minListenerComparer: Comparer<MinListener> = {
+    min: { minRequired: Number.MIN_VALUE, onMinGE: () => { assert(false, 0x048 /* "onMinGE()" */); } },
+    compare: (a, b) => a.minRequired - b.minRequired,
+};
 
 function isRemoved(segment: ISegment): boolean {
     return toRemovalInfo(segment) !== undefined;
@@ -119,153 +102,111 @@ function isRemovedAndAcked(segment: ISegment): boolean {
     return removalInfo !== undefined && removalInfo.removedSeq !== UnassignedSequenceNumber;
 }
 
-/**
- * A segment representing a portion of the merge tree.
- */
-export interface ISegment extends IMergeNodeCommon, Partial<IRemovalInfo> {
-    readonly type: string;
-    readonly segmentGroups: SegmentGroupCollection;
-    readonly trackingCollection: TrackingGroupCollection;
-    propertyManager?: PropertiesManager;
-    localSeq?: number;
-    localRemovedSeq?: number;
-    seq?: number;  // If not present assumed to be previous to window min
-    clientId: number;
-    localRefs?: LocalReferenceCollection;
-    properties?: PropertySet;
-    addProperties(
-        newProps: PropertySet,
-        op?: ICombiningOp,
-        seq?: number,
-        collabWindow?: CollaborationWindow,
-    ): PropertySet | undefined;
-    clone(): ISegment;
-    canAppend(segment: ISegment): boolean;
-    append(segment: ISegment): void;
-    splitAt(pos: number): ISegment | undefined;
-    toJSONObject(): any;
-    /**
-     * Acks the current segment against the segment group, op, and merge tree.
-     *
-     * Throws error if the segment state doesn't match segment group or op.
-     * E.g. Segment group not first is pending queue.
-     * Inserted segment does not have unassigned sequence number.
-     *
-     * Returns true if the op  modifies the segment, otherwise false.
-     * The only current false case is overlapping remove, where a segment is removed
-     * by a previously sequenced operation before the current operation is acked.
-     */
-    ack(segmentGroup: SegmentGroup, opArgs: IMergeTreeDeltaOpArgs, mergeTree: MergeTree): boolean;
-}
-
-export interface IMarkerModifiedAction {
-    // eslint-disable-next-line @typescript-eslint/prefer-function-type
-    (marker: Marker): void;
-}
-
-export interface ISegmentAction<TClientData> {
-    // eslint-disable-next-line @typescript-eslint/prefer-function-type
-    (segment: ISegment, pos: number, refSeq: number, clientId: number, start: number,
-        end: number, accum: TClientData): boolean;
-}
-
-export interface ISegmentChanges {
-    next?: ISegment;
-    replaceCurrent?: ISegment;
-}
-
-export interface BlockAction<TClientData> {
-    // eslint-disable-next-line @typescript-eslint/prefer-function-type
-    (
-        block: IMergeBlock,
-        pos: number,
-        refSeq: number,
-        clientId: number,
-        start: number | undefined,
-        end: number | undefined,
-        accum: TClientData,
-    ): boolean;
-}
-
-export interface NodeAction<TClientData> {
-    // eslint-disable-next-line @typescript-eslint/prefer-function-type
-    (
-        node: IMergeNode,
-        pos: number,
-        refSeq: number,
-        clientId: number,
-        start: number | undefined,
-        end: number | undefined,
-        clientData: TClientData,
-    ): boolean;
-}
-
-export interface IncrementalSegmentAction<TContext> {
-    (segment: ISegment, state: IncrementalMapState<TContext>);
-}
-
-export interface IncrementalBlockAction<TContext> {
-    (state: IncrementalMapState<TContext>);
+function nodeTotalLength(mergeTree: MergeTree, node: IMergeNode) {
+    if (!node.isLeaf()) {
+        return node.cachedLength;
+    }
+    return mergeTree.localNetLength(node);
 }
 
-export interface BlockUpdateActions {
-    child: (block: IMergeBlock, index: number) => void;
-}
+const LRUSegmentComparer: Comparer<LRUSegment> = {
+    min: { maxSeq: -2 },
+    compare: (a, b) => a.maxSeq - b.maxSeq,
+};
 
-export interface InsertContext {
-    candidateSegment?: ISegment;
-    prepareEvents?: boolean;
-    structureChange?: boolean;
-    leaf: (segment: ISegment | undefined, pos: number, ic: InsertContext) => ISegmentChanges;
-    continuePredicate?: (continueFromBlock: IMergeBlock) => boolean;
+interface IReferenceSearchInfo {
+    mergeTree: MergeTree;
+    tileLabel: string;
+    tilePrecedesPos?: boolean;
+    tile?: ReferencePosition;
 }
 
-export interface SegmentActions<TClientData> {
-    leaf?: ISegmentAction<TClientData>;
-    shift?: NodeAction<TClientData>;
-    contains?: NodeAction<TClientData>;
-    pre?: BlockAction<TClientData>;
-    post?: BlockAction<TClientData>;
+interface IMarkerSearchRangeInfo {
+    mergeTree: MergeTree;
+    rangeLabels: string[];
+    stacks: RangeStackMap;
 }
 
-export interface IncrementalSegmentActions<TContext> {
-    leaf: IncrementalSegmentAction<TContext>;
-    pre?: IncrementalBlockAction<TContext>;
-    post?: IncrementalBlockAction<TContext>;
+function applyLeafRangeMarker(marker: Marker, searchInfo: IMarkerSearchRangeInfo) {
+    for (const rangeLabel of searchInfo.rangeLabels) {
+        if (refHasRangeLabel(marker, rangeLabel)) {
+            let currentStack = searchInfo.stacks[rangeLabel];
+            if (currentStack === undefined) {
+                currentStack = new Stack<Marker>();
+                searchInfo.stacks[rangeLabel] = currentStack;
+            }
+            applyRangeReference(currentStack, marker);
+        }
+    }
 }
 
-export interface SearchResult {
-    text: string;
-    pos: number;
+function recordRangeLeaf(
+    segment: ISegment, segpos: number,
+    refSeq: number, clientId: number, start: number | undefined, end: number | undefined,
+    searchInfo: IMarkerSearchRangeInfo) {
+    if (Marker.is(segment)) {
+        if (segment.refType &
+            (ReferenceType.NestBegin | ReferenceType.NestEnd)) {
+            applyLeafRangeMarker(segment, searchInfo);
+        }
+    }
+    return false;
 }
 
-export interface MergeTreeStats {
-    maxHeight: number;
-    nodeCount: number;
-    leafCount: number;
-    removedLeafCount: number;
-    liveCount: number;
-    histo: number[];
-    windowTime?: number;
-    packTime?: number;
-    ordTime?: number;
-    maxOrdTime?: number;
+function rangeShift(
+    node: IMergeNode, segpos: number, refSeq: number, clientId: number,
+    offset: number | undefined, end: number | undefined, searchInfo: IMarkerSearchRangeInfo) {
+    if (node.isLeaf()) {
+        const seg = node;
+        if (((searchInfo.mergeTree.localNetLength(seg) ?? 0) > 0) && Marker.is(seg)) {
+            if (seg.refType &
+                (ReferenceType.NestBegin | ReferenceType.NestEnd)) {
+                applyLeafRangeMarker(seg, searchInfo);
+            }
+        }
+    } else {
+        const block = <IHierBlock>node;
+        applyStackDelta(searchInfo.stacks, block.rangeStacks);
+    }
+    return true;
 }
 
-export interface SegmentGroup {
-    segments: ISegment[];
-    localSeq: number;
+function recordTileStart(
+    segment: ISegment,
+    segpos: number,
+    refSeq: number,
+    clientId: number,
+    start: number,
+    end: number,
+    searchInfo: IReferenceSearchInfo) {
+    if (Marker.is(segment)) {
+        if (refHasTileLabel(segment, searchInfo.tileLabel)) {
+            searchInfo.tile = segment;
+        }
+    }
+    return false;
 }
 
-export class MergeNode implements IMergeNodeCommon {
-    index: number = 0;
-    ordinal: string = "";
-    parent?: IMergeBlock;
-    cachedLength: number = 0;
-
-    isLeaf() {
-        return false;
+function tileShift(
+    node: IMergeNode, segpos: number, refSeq: number, clientId: number,
+    offset: number | undefined, end: number | undefined, searchInfo: IReferenceSearchInfo) {
+    if (node.isLeaf()) {
+        const seg = node;
+        if ((searchInfo.mergeTree.localNetLength(seg) > 0) && Marker.is(seg)) {
+            if (refHasTileLabel(seg, searchInfo.tileLabel)) {
+                searchInfo.tile = seg;
+            }
+        }
+    } else {
+        const block = <IHierBlock>node;
+        const marker = searchInfo.tilePrecedesPos
+            ? <Marker>block.rightmostTiles[searchInfo.tileLabel]
+            : <Marker>block.leftmostTiles[searchInfo.tileLabel];
+        if (marker !== undefined) {
+            searchInfo.tile = marker;
+        }
     }
+    return true;
 }
 
 function addTile(tile: ReferencePosition, tiles: object) {
@@ -328,685 +269,144 @@ function addNodeReferences(
     leftmostTiles: MapLike<ReferencePosition>, rangeStacks: RangeStackMap) {
     function updateRangeInfo(label: string, refPos: ReferencePosition) {
         let stack = rangeStacks[label];
-        if (stack === undefined) {
-            stack = new Stack<ReferencePosition>();
-            rangeStacks[label] = stack;
-        }
-        applyRangeReference(stack, refPos);
-    }
-    if (node.isLeaf()) {
-        const segment = node;
-        if ((mergeTree.localNetLength(segment) ?? 0) > 0) {
-            if (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
-                if (markerId) {
-                    mergeTree.mapIdToSegment(markerId, segment);
-                }
-                if (refTypeIncludesFlag(segment, ReferenceType.Tile)) {
-                    addTile(segment, rightmostTiles);
-                    addTileIfNotPresent(segment, leftmostTiles);
-                }
-                if (segment.refType & (ReferenceType.NestBegin | ReferenceType.NestEnd)) {
-                    const rangeLabels = refGetRangeLabels(segment);
-                    if (rangeLabels) {
-                        for (const label of rangeLabels) {
-                            updateRangeInfo(label, segment);
-                        }
-                    }
-                }
-            } else {
-                const baseSegment = node as BaseSegment;
-                if (baseSegment.localRefs && (baseSegment.localRefs.hierRefCount !== undefined) &&
-                    (baseSegment.localRefs.hierRefCount > 0)) {
-                    for (const lref of baseSegment.localRefs) {
-                        if (refTypeIncludesFlag(lref, ReferenceType.Tile)) {
-                            addTile(lref, rightmostTiles);
-                            addTileIfNotPresent(lref, leftmostTiles);
-                        }
-                        if (lref.refType & (ReferenceType.NestBegin | ReferenceType.NestEnd)) {
-                            for (const label of refGetRangeLabels(lref)!) {
-                                updateRangeInfo(label, lref);
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    } else {
-        const block = <IHierBlock>node;
-        applyStackDelta(rangeStacks, block.rangeStacks);
-        extend(rightmostTiles, block.rightmostTiles);
-        extendIfUndefined(leftmostTiles, block.leftmostTiles);
-    }
-}
-
-export function ordinalToArray(ord: string) {
-    const a: number[] = [];
-    if (ord) {
-        for (let i = 0, len = ord.length; i < len; i++) {
-            a.push(ord.charCodeAt(i));
-        }
-    }
-    return a;
-}
-
-// Note that the actual branching factor of the MergeTree is `MaxNodesInBlock - 1`.  This is because
-// the MergeTree always inserts first, then checks for overflow and splits if the child count equals
-// `MaxNodesInBlock`.  (i.e., `MaxNodesInBlock` contains 1 extra slot for temporary storage to
-// facilitate splits.)
-export const MaxNodesInBlock = 8;
-
-export class MergeBlock extends MergeNode implements IMergeBlock {
-    public children: IMergeNode[];
-    public constructor(public childCount: number) {
-        super();
-        this.children = new Array<IMergeNode>(MaxNodesInBlock);
-    }
-
-    public hierBlock(): HierMergeBlock | undefined {
-        return undefined;
-    }
-
-    public setOrdinal(child: IMergeNode, index: number) {
-        let childCount = this.childCount;
-        if (childCount === 8) {
-            childCount = 7;
-        }
-        assert((childCount >= 1) && (childCount <= 7), 0x040 /* "Child count is not within [1,7] range!" */);
-        let localOrdinal: number;
-        const ordinalWidth = 1 << (MaxNodesInBlock - (childCount + 1));
-        if (index === 0) {
-            localOrdinal = ordinalWidth - 1;
-        } else {
-            const prevOrd = this.children[index - 1].ordinal;
-            const prevOrdCode = prevOrd.charCodeAt(prevOrd.length - 1);
-            localOrdinal = prevOrdCode + ordinalWidth;
-        }
-        child.ordinal = this.ordinal + String.fromCharCode(localOrdinal);
-        assert(child.ordinal.length === (this.ordinal.length + 1), 0x041 /* "Unexpected child ordinal length!" */);
-        if (index > 0) {
-            assert(
-                child.ordinal > this.children[index - 1].ordinal,
-                0x042, /* "Child ordinal <= previous sibling ordinal!" */
-            );
-        }
-    }
-
-    public assignChild(child: IMergeNode, index: number, updateOrdinal = true) {
-        child.parent = this;
-        child.index = index;
-        if (updateOrdinal) {
-            this.setOrdinal(child, index);
-        }
-        this.children[index] = child;
-    }
-}
-
-class HierMergeBlock extends MergeBlock implements IMergeBlock {
-    public rightmostTiles: MapLike<ReferencePosition>;
-    public leftmostTiles: MapLike<ReferencePosition>;
-    public rangeStacks: MapLike<Stack<ReferencePosition>>;
-
-    constructor(childCount: number) {
-        super(childCount);
-        this.rightmostTiles = createMap<ReferencePosition>();
-        this.leftmostTiles = createMap<ReferencePosition>();
-        this.rangeStacks = createMap<Stack<ReferencePosition>>();
-    }
-
-    public addNodeReferences(mergeTree: MergeTree, node: IMergeNode) {
-        addNodeReferences(mergeTree, node, this.rightmostTiles, this.leftmostTiles,
-            this.rangeStacks);
-    }
-
-    public hierBlock() {
-        return this;
-    }
-
-    public hierToString(indentCount: number) {
-        let strbuf = "";
-        // eslint-disable-next-line guard-for-in, no-restricted-syntax
-        for (const key in this.rangeStacks) {
-            const stack = this.rangeStacks[key];
-            strbuf += internedSpaces(indentCount);
-            strbuf += `${key}: `;
-            for (const item of stack.items) {
-                strbuf += `${item.toString()} `;
-            }
-            strbuf += "\n";
-        }
-        return strbuf;
-    }
-}
-
-function nodeTotalLength(mergeTree: MergeTree, node: IMergeNode) {
-    if (!node.isLeaf()) {
-        return node.cachedLength;
-    }
-    return mergeTree.localNetLength(node);
-}
-
-export abstract class BaseSegment extends MergeNode implements ISegment {
-    public clientId: number = LocalClientId;
-    public seq: number = UniversalSequenceNumber;
-    public removedSeq?: number;
-    public removedClientIds?: number[];
-    public readonly segmentGroups: SegmentGroupCollection = new SegmentGroupCollection(this);
-    public readonly trackingCollection: TrackingGroupCollection = new TrackingGroupCollection(this);
-    public propertyManager?: PropertiesManager;
-    public properties?: PropertySet;
-    public localRefs?: LocalReferenceCollection;
-    public abstract readonly type: string;
-    public localSeq?: number;
-    public localRemovedSeq?: number;
-
-    public addProperties(newProps: PropertySet, op?: ICombiningOp, seq?: number, collabWindow?: CollaborationWindow) {
-        if (!this.propertyManager) {
-            this.propertyManager = new PropertiesManager();
-        }
-        if (!this.properties) {
-            this.properties = createMap<any>();
-        }
-        return this.propertyManager.addProperties(
-            this.properties,
-            newProps,
-            op,
-            seq,
-            collabWindow && collabWindow.collaborating,
-        );
-    }
-
-    public hasProperty(key: string): boolean {
-        return !!this.properties && (this.properties[key] !== undefined);
-    }
-
-    public isLeaf() {
-        return true;
-    }
-
-    protected cloneInto(b: ISegment) {
-        b.clientId = this.clientId;
-        // TODO: deep clone properties
-        b.properties = clone(this.properties);
-        b.removedClientIds = this.removedClientIds?.slice();
-        // TODO: copy removed client overlap and branch removal info
-        b.removedSeq = this.removedSeq;
-        b.seq = this.seq;
-    }
-
-    public canAppend(segment: ISegment): boolean {
-        return false;
-    }
-
-    protected addSerializedProps(jseg: IJSONSegment) {
-        if (this.properties) {
-            jseg.props = this.properties;
-        }
-    }
-
-    public abstract toJSONObject(): any;
-
-    public ack(segmentGroup: SegmentGroup, opArgs: IMergeTreeDeltaOpArgs, mergeTree: MergeTree): boolean {
-        const currentSegmentGroup = this.segmentGroups.dequeue();
-        assert(currentSegmentGroup === segmentGroup, 0x043 /* "On ack, unexpected segmentGroup!" */);
-        switch (opArgs.op.type) {
-            case MergeTreeDeltaType.ANNOTATE:
-                assert(!!this.propertyManager, 0x044 /* "On annotate ack, missing segment property manager!" */);
-                this.propertyManager.ackPendingProperties(opArgs.op);
-                return true;
-
-            case MergeTreeDeltaType.INSERT:
-                assert(this.seq === UnassignedSequenceNumber, 0x045 /* "On insert, seq number already assigned!" */);
-                this.seq = opArgs.sequencedMessage!.sequenceNumber;
-                this.localSeq = undefined;
-                return true;
-
-            case MergeTreeDeltaType.REMOVE:
-                const removalInfo: IRemovalInfo | undefined = toRemovalInfo(this);
-                assert(removalInfo !== undefined, 0x046 /* "On remove ack, missing removal info!" */);
-                this.localRemovedSeq = undefined;
-                if (removalInfo.removedSeq === UnassignedSequenceNumber) {
-                    removalInfo.removedSeq = opArgs.sequencedMessage!.sequenceNumber;
-                    return true;
-                }
-                return false;
-
-            default:
-                throw new Error(`${opArgs.op.type} is in unrecognized operation type`);
-        }
-    }
-
-    public splitAt(pos: number): ISegment | undefined {
-        if (pos > 0) {
-            const leafSegment = this.createSplitSegmentAt(pos);
-            if (leafSegment) {
-                this.copyPropertiesTo(leafSegment);
-                leafSegment.parent = this.parent;
-
-                // Give the leaf a temporary yet valid ordinal.
-                // when this segment is put in the tree, it will get it's real ordinal,
-                // but this ordinal meets all the necessary invariants for now.
-                leafSegment.ordinal = this.ordinal + String.fromCharCode(0);
-
-                leafSegment.removedClientIds = this.removedClientIds?.slice();
-                leafSegment.removedSeq = this.removedSeq;
-                leafSegment.localRemovedSeq = this.localRemovedSeq;
-                leafSegment.seq = this.seq;
-                leafSegment.localSeq = this.localSeq;
-                leafSegment.clientId = this.clientId;
-                this.segmentGroups.copyTo(leafSegment);
-                this.trackingCollection.copyTo(leafSegment);
-                if (this.localRefs) {
-                    this.localRefs.split(pos, leafSegment);
-                }
-            }
-            return leafSegment;
-        }
-    }
-
-    private copyPropertiesTo(other: ISegment) {
-        if (this.propertyManager) {
-            if (this.properties) {
-                other.propertyManager = new PropertiesManager();
-                other.properties = this.propertyManager.copyTo(
-                    this.properties,
-                    other.properties,
-                    other.propertyManager,
-                );
-            }
-        }
-    }
-
-    public abstract clone(): ISegment;
-    public abstract append(segment: ISegment): void;
-    protected abstract createSplitSegmentAt(pos: number): BaseSegment | undefined;
-}
-
-export const reservedMarkerIdKey = "markerId";
-export const reservedMarkerSimpleTypeKey = "markerSimpleType";
-
-export interface IJSONMarkerSegment extends IJSONSegment {
-    marker: IMarkerDef;
-}
-
-export class Marker extends BaseSegment implements ReferencePosition {
-    public static readonly type = "Marker";
-    public static is(segment: ISegment): segment is Marker {
-        return segment.type === Marker.type;
-    }
-    public readonly type = Marker.type;
-
-    public static make(
-        refType: ReferenceType, props?: PropertySet) {
-        const marker = new Marker(refType);
-        if (props) {
-            marker.addProperties(props);
-        }
-        return marker;
-    }
-
-    constructor(public refType: ReferenceType) {
-        super();
-        this.cachedLength = 1;
-    }
-
-    toJSONObject() {
-        const obj: IJSONMarkerSegment = { marker: { refType: this.refType } };
-        super.addSerializedProps(obj);
-        return obj;
-    }
-
-    static fromJSONObject(spec: any) {
-        if (spec && typeof spec === "object" && "marker" in spec) {
-            return Marker.make(
-                spec.marker.refType,
-                spec.props as PropertySet);
-        }
-        return undefined;
-    }
-
-    clone() {
-        const b = Marker.make(this.refType, this.properties);
-        this.cloneInto(b);
-        return b;
-    }
-
-    getSegment() {
-        return this;
-    }
-
-    getOffset() {
-        return 0;
-    }
-
-    hasSimpleType(simpleTypeName: string) {
-        return !!this.properties &&
-            this.properties[reservedMarkerSimpleTypeKey] === simpleTypeName;
-    }
-
-    getProperties() {
-        return this.properties;
-    }
-
-    getId(): string | undefined {
-        if (this.properties && this.properties[reservedMarkerIdKey]) {
-            return this.properties[reservedMarkerIdKey] as string;
-        }
-    }
-
-    /**
-     * @deprecated - use refHasTileLabels
-     */
-    hasTileLabels() {
-        return refHasTileLabels(this);
-    }
-    /**
-     * @deprecated - use refHasRangeLabels
-     */
-    hasRangeLabels() {
-        return refHasRangeLabels(this);
-    }
-    /**
-     * @deprecated - use refHasTileLabel
-     */
-    hasTileLabel(label: string): boolean {
-        return refHasTileLabel(this, label);
-    }
-    /**
-     * @deprecated - use refHasRangeLabel
-     */
-    hasRangeLabel(label: string): boolean {
-        return refHasRangeLabel(this, label);
-    }
-    /**
-     * @deprecated - use refGetTileLabels
-     */
-    getTileLabels(): string[] | undefined {
-        return refGetTileLabels(this);
-    }
-    /**
-     * @deprecated - use refGetRangeLabels
-     */
-    getRangeLabels(): string[] | undefined {
-        return refGetRangeLabels(this);
-    }
-
-    toString() {
-        let bbuf = "";
-        if (refTypeIncludesFlag(this, ReferenceType.Tile)) {
-            bbuf += "Tile";
-        }
-        if (refTypeIncludesFlag(this, ReferenceType.NestBegin)) {
-            if (bbuf.length > 0) {
-                bbuf += "; ";
-            }
-            bbuf += "RangeBegin";
-        }
-        if (refTypeIncludesFlag(this, ReferenceType.NestEnd)) {
-            if (bbuf.length > 0) {
-                bbuf += "; ";
-            }
-            bbuf += "RangeEnd";
-        }
-        let lbuf = "";
-        const id = this.getId();
-        if (id) {
-            bbuf += ` (${id}) `;
-        }
-        const tileLabels = refGetTileLabels(this);
-        if (tileLabels) {
-            lbuf += "tile -- ";
-            for (let i = 0, len = tileLabels.length; i < len; i++) {
-                const tileLabel = tileLabels[i];
-                if (i > 0) {
-                    lbuf += "; ";
-                }
-                lbuf += tileLabel;
-            }
-        }
-        const rangeLabels = refGetRangeLabels(this);
-        if (rangeLabels) {
-            let rangeKind = "begin";
-            if (refTypeIncludesFlag(this, ReferenceType.NestEnd)) {
-                rangeKind = "end";
-            }
-            if (tileLabels) {
-                lbuf += " ";
-            }
-            lbuf += `range ${rangeKind} -- `;
-            const labels = rangeLabels;
-            for (let i = 0, len = labels.length; i < len; i++) {
-                const rangeLabel = labels[i];
-                if (i > 0) {
-                    lbuf += "; ";
-                }
-                lbuf += rangeLabel;
-            }
-        }
-        let pbuf = "";
-        if (this.properties) {
-            pbuf += JSON.stringify(this.properties, (key, value) => {
-                // Avoid circular reference when stringifying makers containing handles.
-                // (Substitute a debug string instead.)
-                const handle = !!value && value.IFluidHandle;
-
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-                return handle
-                    ? `#Handle(${handle.routeContext.path}/${handle.path})`
-                    : value;
-            });
-        }
-        return `M ${bbuf}: ${lbuf} ${pbuf}`;
-    }
-
-    protected createSplitSegmentAt(pos: number) {
-        return undefined;
-    }
-
-    canAppend(segment: ISegment): boolean {
-        return false;
-    }
-
-    append() { throw new Error("Can not append to marker"); }
-}
-
-export enum IncrementalExecOp {
-    Go,
-    Stop,
-    Yield,
-}
-
-export class IncrementalMapState<TContext> {
-    op = IncrementalExecOp.Go;
-    constructor(
-        public block: IMergeBlock,
-        public actions: IncrementalSegmentActions<TContext>,
-        public pos: number,
-        public refSeq: number,
-        public clientId: number,
-        public context: TContext,
-        public start: number,
-        public end: number,
-        public childIndex = 0,
-    ) {
-    }
-}
-
-export class CollaborationWindow {
-    clientId = LocalClientId;
-    collaborating = false;
-    // Lowest-numbered segment in window; no client can reference a state before this one
-    minSeq = 0;
-    // Highest-numbered segment in window and current
-    // reference segment for this client
-    currentSeq = 0;
-
-    localSeq = 0;
-
-    loadFrom(a: CollaborationWindow) {
-        this.clientId = a.clientId;
-        this.collaborating = a.collaborating;
-        this.minSeq = a.minSeq;
-        this.currentSeq = a.currentSeq;
-    }
-}
-
-export const compareNumbers = (a: number, b: number) => a - b;
-
-export const compareStrings = (a: string, b: string) => a.localeCompare(b);
-
-const indentStrings = ["", " ", "  "];
-export function internedSpaces(n: number) {
-    if (indentStrings[n] === undefined) {
-        indentStrings[n] = "";
-        for (let i = 0; i < n; i++) {
-            indentStrings[n] += " ";
-        }
-    }
-    return indentStrings[n];
-}
-
-export interface IConsensusInfo {
-    marker: Marker;
-    callback: (m: Marker) => void;
-}
-
-export interface ClientSeq {
-    refSeq: number;
-    clientId: string;
-}
-
-export const clientSeqComparer: Comparer<ClientSeq> = {
-    min: { refSeq: -1, clientId: "" },
-    compare: (a, b) => a.refSeq - b.refSeq,
-};
-
-export interface LRUSegment {
-    segment?: ISegment;
-    maxSeq: number;
-}
-
-const LRUSegmentComparer: Comparer<LRUSegment> = {
-    min: { maxSeq: -2 },
-    compare: (a, b) => a.maxSeq - b.maxSeq,
-};
-
-export interface SegmentAccumulator {
-    segments: ISegment[];
-}
-
-interface IReferenceSearchInfo {
-    mergeTree: MergeTree;
-    tileLabel: string;
-    posPrecedesTile?: boolean;
-    tile?: ReferencePosition;
-}
-
-interface IMarkerSearchRangeInfo {
-    mergeTree: MergeTree;
-    rangeLabels: string[];
-    stacks: RangeStackMap;
-}
-
-function applyLeafRangeMarker(marker: Marker, searchInfo: IMarkerSearchRangeInfo) {
-    for (const rangeLabel of searchInfo.rangeLabels) {
-        if (refHasRangeLabel(marker, rangeLabel)) {
-            let currentStack = searchInfo.stacks[rangeLabel];
-            if (currentStack === undefined) {
-                currentStack = new Stack<Marker>();
-                searchInfo.stacks[rangeLabel] = currentStack;
-            }
-            applyRangeReference(currentStack, marker);
-        }
-    }
-}
-function recordRangeLeaf(
-    segment: ISegment, segpos: number,
-    refSeq: number, clientId: number, start: number | undefined, end: number | undefined,
-    searchInfo: IMarkerSearchRangeInfo) {
-    if (Marker.is(segment)) {
-        if (segment.refType &
-            (ReferenceType.NestBegin | ReferenceType.NestEnd)) {
-            applyLeafRangeMarker(segment, searchInfo);
+        if (stack === undefined) {
+            stack = new Stack<ReferencePosition>();
+            rangeStacks[label] = stack;
         }
+        applyRangeReference(stack, refPos);
     }
-    return false;
-}
-
-function rangeShift(
-    node: IMergeNode, segpos: number, refSeq: number, clientId: number,
-    offset: number | undefined, end: number | undefined, searchInfo: IMarkerSearchRangeInfo) {
     if (node.isLeaf()) {
-        const seg = node;
-        if (((searchInfo.mergeTree.localNetLength(seg) ?? 0) > 0) && Marker.is(seg)) {
-            if (seg.refType &
-                (ReferenceType.NestBegin | ReferenceType.NestEnd)) {
-                applyLeafRangeMarker(seg, searchInfo);
+        const segment = node;
+        if ((mergeTree.localNetLength(segment) ?? 0) > 0) {
+            if (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
+                if (markerId) {
+                    mergeTree.mapIdToSegment(markerId, segment);
+                }
+                if (refTypeIncludesFlag(segment, ReferenceType.Tile)) {
+                    addTile(segment, rightmostTiles);
+                    addTileIfNotPresent(segment, leftmostTiles);
+                }
+                if (segment.refType & (ReferenceType.NestBegin | ReferenceType.NestEnd)) {
+                    const rangeLabels = refGetRangeLabels(segment);
+                    if (rangeLabels) {
+                        for (const label of rangeLabels) {
+                            updateRangeInfo(label, segment);
+                        }
+                    }
+                }
+            } else {
+                const baseSegment = node as BaseSegment;
+                if (baseSegment.localRefs && (baseSegment.localRefs.hierRefCount !== undefined) &&
+                    (baseSegment.localRefs.hierRefCount > 0)) {
+                    for (const lref of baseSegment.localRefs) {
+                        if (refTypeIncludesFlag(lref, ReferenceType.Tile)) {
+                            addTile(lref, rightmostTiles);
+                            addTileIfNotPresent(lref, leftmostTiles);
+                        }
+                        if (lref.refType & (ReferenceType.NestBegin | ReferenceType.NestEnd)) {
+                            for (const label of refGetRangeLabels(lref)!) {
+                                updateRangeInfo(label, lref);
+                            }
+                        }
+                    }
+                }
             }
         }
     } else {
         const block = <IHierBlock>node;
-        applyStackDelta(searchInfo.stacks, block.rangeStacks);
+        applyStackDelta(rangeStacks, block.rangeStacks);
+        extend(rightmostTiles, block.rightmostTiles);
+        extendIfUndefined(leftmostTiles, block.leftmostTiles);
     }
-    return true;
 }
 
-function recordTileStart(
-    segment: ISegment,
-    segpos: number,
-    refSeq: number,
-    clientId: number,
-    start: number,
-    end: number,
-    searchInfo: IReferenceSearchInfo) {
-    if (Marker.is(segment)) {
-        if (refHasTileLabel(segment, searchInfo.tileLabel)) {
-            searchInfo.tile = segment;
+function extendIfUndefined<T>(base: MapLike<T>, extension: MapLike<T> | undefined) {
+    if (extension !== undefined) {
+        // eslint-disable-next-line no-restricted-syntax
+        for (const key in extension) {
+            if (base[key] === undefined) {
+                base[key] = extension[key];
+            }
         }
     }
-    return false;
+    return base;
 }
 
-function tileShift(
-    node: IMergeNode, segpos: number, refSeq: number, clientId: number,
-    offset: number | undefined, end: number | undefined, searchInfo: IReferenceSearchInfo) {
-    if (node.isLeaf()) {
-        const seg = node;
-        if ((searchInfo.mergeTree.localNetLength(seg) > 0) && Marker.is(seg)) {
-            if (refHasTileLabel(seg, searchInfo.tileLabel)) {
-                searchInfo.tile = seg;
+class HierMergeBlock extends MergeBlock implements IHierBlock {
+    public rightmostTiles: MapLike<ReferencePosition>;
+    public leftmostTiles: MapLike<ReferencePosition>;
+    public rangeStacks: MapLike<Stack<ReferencePosition>>;
+
+    constructor(childCount: number) {
+        super(childCount);
+        this.rightmostTiles = createMap<ReferencePosition>();
+        this.leftmostTiles = createMap<ReferencePosition>();
+        this.rangeStacks = createMap<Stack<ReferencePosition>>();
+    }
+
+    /**
+     * @deprecated For internal use only. public export will be removed.
+     * @internal
+     */
+    public addNodeReferences(mergeTree: MergeTree, node: IMergeNode) {
+        addNodeReferences(mergeTree, node, this.rightmostTiles, this.leftmostTiles,
+            this.rangeStacks);
+    }
+
+    public hierBlock() {
+        return this;
+    }
+
+    public hierToString(indentCount: number) {
+        let strbuf = "";
+        // eslint-disable-next-line guard-for-in, no-restricted-syntax
+        for (const key in this.rangeStacks) {
+            const stack = this.rangeStacks[key];
+            strbuf += internedSpaces(indentCount);
+            strbuf += `${key}: `;
+            for (const item of stack.items) {
+                strbuf += `${item.toString()} `;
             }
+            strbuf += "\n";
         }
-    } else {
-        const block = <IHierBlock>node;
-        let marker: Marker;
-        if (searchInfo.posPrecedesTile) {
-            marker = <Marker>block.rightmostTiles[searchInfo.tileLabel];
-        } else {
-            marker = <Marker>block.leftmostTiles[searchInfo.tileLabel];
-        }
-        if (marker !== undefined) {
-            searchInfo.tile = marker;
-        }
+        return strbuf;
     }
-    return true;
 }
 
-export interface MinListener {
-    minRequired: number;
-    onMinGE(minSeq: number): void;
+/**
+ * @deprecated For internal use only. public export will be removed.
+ * @internal
+ */
+ export interface ClientSeq {
+    refSeq: number;
+    clientId: string;
 }
 
-const minListenerComparer: Comparer<MinListener> = {
-    min: { minRequired: Number.MIN_VALUE, onMinGE: () => { assert(false, 0x048 /* "onMinGE()" */); } },
-    compare: (a, b) => a.minRequired - b.minRequired,
+/**
+ * @deprecated For internal use only. public export will be removed.
+ * @internal
+ */
+ export const clientSeqComparer: Comparer<ClientSeq> = {
+    min: { refSeq: -1, clientId: "" },
+    compare: (a, b) => a.refSeq - b.refSeq,
 };
 
-export type LocalReferenceMapper = (id: string) => LocalReference;
+/**
+ * @deprecated For internal use only. public export will be removed.
+ * @internal
+ */
+export interface LRUSegment {
+    segment?: ISegment;
+    maxSeq: number;
+}
 
-// Represents a sequence of text segments
+/**
+ * @deprecated For internal use only. public export will be removed.
+ * @internal
+ */
 export class MergeTree {
     private static readonly zamboniSegmentsMaxCount = 2;
     public static readonly options = {
@@ -1021,8 +421,19 @@ export class MergeTree {
     root: IMergeBlock;
     private readonly blockUpdateActions: BlockUpdateActions = MergeTree.initBlockUpdateActions;
     public readonly collabWindow = new CollaborationWindow();
+
+    /**
+     * @deprecated  for internal use only. public export will be removed.
+     * @internal
+     */
     public pendingSegments: List<SegmentGroup> | undefined;
     private segmentsToScour: Heap<LRUSegment> | undefined;
+    /**
+     * 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.
+     * This field enables tracking whether partials need to be recomputed using localSeq information.
+     */
+    private localPartialsComputed = false;
     // TODO: add remove on segment remove
     // for now assume only markers have ids and so point directly at the Segment
     // if we need to have pointers to non-markers, we can change to point at local refs
@@ -1072,11 +483,36 @@ export class MergeTree {
         return b;
     }
 
-    public localNetLength(segment: ISegment) {
+    /**
+     * 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.
+     */
+    public localNetLength(segment: ISegment, refSeq?: number, localSeq?: number) {
         const removalInfo = toRemovalInfo(segment);
-        if (removalInfo !== undefined) {
-            return 0;
+        if (localSeq === undefined) {
+            return removalInfo !== undefined ? 0 : 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, removedSeq, localRemovedSeq } = segment;
+        if (seq !== UnassignedSequenceNumber) {
+            // inserted remotely
+            if (seq > refSeq
+                    || (removedSeq !== undefined && removedSeq !== UnassignedSequenceNumber && removedSeq <= refSeq)
+                    || (localRemovedSeq !== undefined && localRemovedSeq <= localSeq)) {
+                return 0;
+            }
+            return segment.cachedLength;
         } else {
+            assert(segment.localSeq !== undefined, 0x39a /* unacked segment with undefined localSeq */);
+            // inserted locally, still un-acked
+            if (segment.localSeq > localSeq || (localRemovedSeq !== undefined && localRemovedSeq <= localSeq)) {
+                return 0;
+            }
             return segment.cachedLength;
         }
     }
@@ -1218,11 +654,7 @@ export class MergeTree {
                                 segment.trackingCollection.trackingGroups.forEach((tg) => tg.unlink(segment));
                             } else {
                                 holdNodes.push(segment);
-                                if (this.localNetLength(segment) > 0) {
-                                    prevSegment = segment;
-                                } else {
-                                    prevSegment = undefined;
-                                }
+                                prevSegment = this.localNetLength(segment) > 0 ? segment : undefined;
                             }
                         } else {
                             holdNodes.push(segment);
@@ -1390,7 +822,7 @@ export class MergeTree {
      */
     public get length() { return this.root.cachedLength; }
 
-    public getPosition(node: MergeNode, refSeq: number, clientId: number) {
+    public getPosition(node: MergeNode, refSeq: number, clientId: number, localSeq?: number) {
         let totalOffset = 0;
         let parent = node.parent;
         let prevParent: IMergeBlock | undefined;
@@ -1401,7 +833,7 @@ export class MergeTree {
                 if ((prevParent && (child === prevParent)) || (child === node)) {
                     break;
                 }
-                totalOffset += this.nodeLength(child, refSeq, clientId) ?? 0;
+                totalOffset += this.nodeLength(child, refSeq, clientId, localSeq) ?? 0;
             }
             prevParent = parent;
             parent = parent.parent;
@@ -1409,7 +841,9 @@ export class MergeTree {
         return totalOffset;
     }
 
-    public getContainingSegment<T extends ISegment>(pos: number, refSeq: number, clientId: number) {
+    public getContainingSegment<T extends ISegment>(pos: number, refSeq: number, clientId: number, localSeq?: number) {
+        assert(localSeq === undefined || clientId === this.collabWindow.clientId,
+            0x39b /* localSeq provided for non-local client */);
         let segment: T | undefined;
         let offset: number | undefined;
 
@@ -1418,18 +852,19 @@ export class MergeTree {
             offset = start;
             return false;
         };
-        this.searchBlock(this.root, pos, 0, refSeq, clientId, { leaf }, undefined);
+        this.searchBlock(this.root, pos, 0, refSeq, clientId, { leaf }, undefined, localSeq);
         return { segment, offset };
     }
 
     /**
-     * @internal must only be used by client
-     * @param segoff - The segment and offset to slide from
-     * @returns The segment and offset to slide to
+     * @remarks Must only be used by client.
+     * @param segment - The segment to slide from.
+     * @returns The segment to.
+     * @internal
      */
-    public _getSlideToSegment(segoff: { segment: ISegment | undefined; offset: number | undefined; }) {
-        if (!segoff.segment || !isRemovedAndAcked(segoff.segment)) {
-            return segoff;
+    public _getSlideToSegment(segment: ISegment | undefined): ISegment | undefined {
+        if (!segment || !isRemovedAndAcked(segment)) {
+            return segment;
         }
         let slideToSegment: ISegment | undefined;
         const goFurtherToFindSlideToSegment = (seg) => {
@@ -1440,22 +875,13 @@ export class MergeTree {
             return true;
         };
         // Slide to the next farthest valid segment in the tree.
-        this.rightExcursion(segoff.segment, goFurtherToFindSlideToSegment);
+        this.rightExcursion(segment, goFurtherToFindSlideToSegment);
         if (slideToSegment) {
-            return { segment: slideToSegment, offset: 0 };
+            return slideToSegment;
         }
         // If no such segment is found, slide to the last valid segment.
-        this.leftExcursion(segoff.segment, goFurtherToFindSlideToSegment);
-
-        // Workaround TypeScript issue (https://github.com/microsoft/TypeScript/issues/9998)
-        slideToSegment = slideToSegment as ISegment | undefined;
-
-        if (slideToSegment) {
-            // If slid nearer then offset should be at the end of the segment
-            return { segment: slideToSegment, offset: slideToSegment.cachedLength - 1 };
-        }
-
-        return { segment: undefined, offset: 0 };
+        this.leftExcursion(segment, goFurtherToFindSlideToSegment);
+        return slideToSegment;
     }
 
     /**
@@ -1464,31 +890,26 @@ export class MergeTree {
      * Otherwise eventual consistency is not guaranteed.
      * See `packages\dds\merge-tree\REFERENCEPOSITIONS.md`
      */
-    private slideReferences(segment: ISegment, refsToSlide: LocalReference[]) {
+    private slideReferences(segment: ISegment, refsToSlide: Iterable<LocalReferencePosition>) {
         assert(
             isRemovedAndAcked(segment),
             0x2f1 /* slideReferences from a segment which has not been removed and acked */);
         assert(!!segment.localRefs, 0x2f2 /* Ref not in the segment localRefs */);
-        const newSegoff = this._getSlideToSegment({ segment, offset: 0 });
-        const newSegment = newSegoff.segment;
-        if (newSegment && !newSegment.localRefs) {
-            newSegment.localRefs = new LocalReferenceCollection(newSegment);
-        }
-        for (const ref of refsToSlide) {
-            ref.callbacks?.beforeSlide?.();
-            const removedRef = segment.localRefs.removeLocalRef(ref);
-            assert(ref === removedRef, 0x2f3 /* Ref not in the segment localRefs */);
-            if (!newSegment) {
-                // No valid segments (all nodes removed or not yet created)
-                ref.segment = undefined;
-                ref.offset = 0;
+        const newSegment = this._getSlideToSegment(segment);
+        if (newSegment) {
+            const localRefs = newSegment.localRefs ??= new LocalReferenceCollection(newSegment);
+            if (newSegment.ordinal < segment.ordinal) {
+                localRefs.addAfterTombstones(refsToSlide);
             } else {
-                ref.segment = newSegment;
-                ref.offset = newSegoff.offset ?? 0;
-                assert(!!newSegment.localRefs, 0x2f4 /* localRefs must be allocated */);
-                newSegment.localRefs.addLocalRef(ref);
+                localRefs.addBeforeTombstones(refsToSlide);
+            }
+        } else {
+            for (const ref of refsToSlide) {
+                ref.callbacks?.beforeSlide?.();
+                assertLocalReferences(ref);
+                ref.link(undefined, 0, undefined);
+                ref.callbacks?.afterSlide?.();
             }
-            ref.callbacks?.afterSlide?.();
         }
         // TODO is it required to update the path lengths?
         if (newSegment) {
@@ -1497,21 +918,23 @@ export class MergeTree {
         }
     }
 
-    private updateSegmentRefsAfterMarkRemoved(segment: ISegment, pending: boolean) {
+    private updateSegmentRefsAfterMarkRemoved(segment: ISegment, pending: boolean):
+        LocalReferencePosition[] | undefined {
         if (!segment.localRefs || segment.localRefs.empty) {
-            return;
+            return undefined;
         }
-        const refsToSlide: LocalReference[] = [];
-        const refsToStay: LocalReference[] = [];
+        const refsToSlide: ReferencePosition[] = [];
+        const removedRefs: LocalReferencePosition[] = [];
         for (const lref of segment.localRefs) {
             if (refTypeIncludesFlag(lref, ReferenceType.StayOnRemove)) {
-                refsToStay.push(lref);
-            } else if (refTypeIncludesFlag(lref, ReferenceType.SlideOnRemove)) {
-                if (pending) {
-                    refsToStay.push(lref);
-                } else {
+                continue;
+            } if (refTypeIncludesFlag(lref, ReferenceType.SlideOnRemove)) {
+                if (!pending) {
                     refsToSlide.push(lref);
                 }
+            } else {
+                segment.localRefs.removeLocalRef(lref);
+                removedRefs.push(lref);
             }
         }
         // Rethink implementation of keeping and sliding refs once other reference
@@ -1519,28 +942,40 @@ export class MergeTree {
         if (!pending) {
             this.slideReferences(segment, refsToSlide);
         }
-        segment.localRefs.clear();
-        for (const lref of refsToStay) {
-            lref.segment = segment;
-            segment.localRefs.addLocalRef(lref);
-        }
+        // return only the refs that have been entirely removed
+        return removedRefs.length > 0 ? removedRefs : undefined;
     }
 
     private blockLength(node: IMergeBlock, refSeq: number, clientId: number) {
-        if ((this.collabWindow.collaborating) && (clientId !== this.collabWindow.clientId)) {
-            return node.partialLengths!.getPartialLength(refSeq, clientId);
-        } else {
-            return node.cachedLength;
-        }
+        return (this.collabWindow.collaborating) && (clientId !== this.collabWindow.clientId)
+            ? node.partialLengths!.getPartialLength(refSeq, clientId)
+            : node.cachedLength;
     }
 
-    private nodeLength(node: IMergeNode, refSeq: number, clientId: number) {
+    private nodeLength(node: IMergeNode, refSeq: number, clientId: number, localSeq?: number) {
         if ((!this.collabWindow.collaborating) || (this.collabWindow.clientId === clientId)) {
-            // Local client sees all segments, even when collaborating
-            if (!node.isLeaf()) {
+            if (node.isLeaf()) {
+                return this.localNetLength(node, refSeq, localSeq);
+            } else if (localSeq === undefined) {
+                // Local client sees all segments, even when collaborating
                 return node.cachedLength;
             } else {
-                return this.localNetLength(node);
+                if (!this.localPartialsComputed) {
+                    const rebaseCollabWindow = new CollaborationWindow();
+                    rebaseCollabWindow.loadFrom(this.collabWindow);
+                    if (refSeq < this.collabWindow.minSeq) {
+                        rebaseCollabWindow.minSeq = refSeq;
+                    }
+                    this.root.partialLengths = PartialSequenceLengths.combine(
+                        this.root,
+                        rebaseCollabWindow,
+                        true,
+                        true,
+                    );
+                    this.localPartialsComputed = true;
+                }
+                // Local client should see all segments except those after localSeq.
+                return node.partialLengths!.getPartialLength(refSeq, clientId, localSeq);
             }
         } else {
             // Sequence number within window
@@ -1562,11 +997,7 @@ export class MergeTree {
                     ((segment.seq !== UnassignedSequenceNumber) && (segment.seq! <= refSeq)))) {
                     // Segment happened by reference sequence number or segment from requesting client
                     if (removalInfo !== undefined) {
-                        if (removalInfo.removedClientIds.includes(clientId)) {
-                            return 0;
-                        } else {
-                            return segment.cachedLength;
-                        }
+                        return removalInfo.removedClientIds.includes(clientId) ? 0 : segment.cachedLength;
                     } else {
                         return segment.cachedLength;
                     }
@@ -1626,13 +1057,23 @@ export class MergeTree {
         refSeq = this.collabWindow.currentSeq,
         clientId = this.collabWindow.clientId) {
         const seg = refPos.getSegment();
-        if (seg && seg.parent) {
-            const offset = !seg.removedSeq ? refPos.getOffset() : 0;
-            return offset + this.getPosition(seg, refSeq, clientId);
+        if (seg?.parent === undefined) {
+            return DetachedReferencePosition;
         }
-        return LocalReference.DetachedPosition;
+        if (refPos.isLeaf()) {
+            return this.getPosition(refPos, refSeq, clientId);
+        }
+        if (refTypeIncludesFlag(refPos, ReferenceType.Transient)
+            || seg.localRefs?.has(refPos)) {
+                const offset = isRemoved(seg) ? 0 : refPos.getOffset();
+                return offset + this.getPosition(seg, refSeq, clientId);
+        }
+        return DetachedReferencePosition;
     }
-
+    /**
+     * @deprecated  for internal use only. public export will be removed.
+     * @internal
+     */
     public getStackContext(startPos: number, clientId: number, rangeLabels: string[]) {
         const searchInfo: IMarkerSearchRangeInfo = {
             mergeTree: this,
@@ -1646,14 +1087,22 @@ export class MergeTree {
     }
 
     // TODO: filter function
-    public findTile(startPos: number, clientId: number, tileLabel: string, posPrecedesTile = true) {
+    /**
+     * Finds the nearest reference with ReferenceType.Tile to `startPos` in the direction dictated by `tilePrecedesPos`.
+     *
+     * @param startPos - Position at which to start the search
+     * @param clientId - clientId dictating the perspective to search from
+     * @param tileLabel - Label of the tile to search for
+     * @param tilePrecedesPos - Whether the desired tile comes before (true) or after (false) `startPos`
+     */
+    public findTile(startPos: number, clientId: number, tileLabel: string, tilePrecedesPos = true) {
         const searchInfo: IReferenceSearchInfo = {
             mergeTree: this,
-            posPrecedesTile,
+            tilePrecedesPos,
             tileLabel,
         };
 
-        if (posPrecedesTile) {
+        if (tilePrecedesPos) {
             this.search(startPos, UniversalSequenceNumber, clientId,
                 { leaf: recordTileStart, shift: tileShift }, searchInfo);
         } else {
@@ -1667,8 +1116,8 @@ export class MergeTree {
                 const marker = <Marker>searchInfo.tile;
                 pos = this.getPosition(marker, UniversalSequenceNumber, clientId);
             } else {
-                const localRef = <LocalReference>searchInfo.tile;
-                pos = localRef.toPosition();
+                const localRef = searchInfo.tile;
+                pos = this.referencePositionToLocalPosition(localRef, UniversalSequenceNumber, clientId);
             }
             return { tile: searchInfo.tile, pos };
         }
@@ -1681,8 +1130,15 @@ export class MergeTree {
     }
 
     private searchBlock<TClientData>(
-        block: IMergeBlock, pos: number, segpos: number, refSeq: number, clientId: number,
-        actions: SegmentActions<TClientData> | undefined, clientData: TClientData): ISegment | undefined {
+        block: IMergeBlock,
+        pos: number,
+        segpos: number,
+        refSeq: number,
+        clientId: number,
+        actions: SegmentActions<TClientData> | undefined,
+        clientData: TClientData,
+        localSeq?: number,
+    ): ISegment | undefined {
         let _pos = pos;
         let _segpos = segpos;
         const children = block.children;
@@ -1692,14 +1148,14 @@ export class MergeTree {
         const contains = actions && actions.contains;
         for (let childIndex = 0; childIndex < block.childCount; childIndex++) {
             const child = children[childIndex];
-            const len = this.nodeLength(child, refSeq, clientId) ?? 0;
+            const len = this.nodeLength(child, refSeq, clientId, localSeq) ?? 0;
             if (
                 (!contains && _pos < len)
                 || (contains && contains(child, _pos, refSeq, clientId, undefined, undefined, clientData))
             ) {
                 // Found entry containing pos
                 if (!child.isLeaf()) {
-                    return this.searchBlock(child, _pos, _segpos, refSeq, clientId, actions, clientData);
+                    return this.searchBlock(child, _pos, _segpos, refSeq, clientId, actions, clientData, localSeq);
                 } else {
                     if (actions && actions.leaf) {
                         actions.leaf(child, _segpos, refSeq, clientId, _pos, -1, clientData);
@@ -1824,13 +1280,26 @@ export class MergeTree {
         }
     }
 
-    private addToPendingList(segment: ISegment, segmentGroup?: SegmentGroup, localSeq?: number) {
+    private addToPendingList(segment: ISegment, segmentGroup?: SegmentGroup, localSeq?: number,
+        previousProps?: PropertySet) {
         let _segmentGroup = segmentGroup;
         if (_segmentGroup === undefined) {
             // TODO: review the cast
             _segmentGroup = { segments: [], localSeq } as SegmentGroup;
+            if (previousProps) {
+                _segmentGroup.previousProps = [];
+            }
             this.pendingSegments!.enqueue(_segmentGroup);
         }
+
+        if ((!_segmentGroup.previousProps && previousProps) ||
+            (_segmentGroup.previousProps && !previousProps)) {
+            throw new Error("All segments in group should have previousProps or none");
+        }
+        if (previousProps) {
+            _segmentGroup.previousProps!.push(previousProps);
+        }
+
         segment.segmentGroups.enqueue(_segmentGroup);
         return _segmentGroup;
     }
@@ -1929,7 +1398,7 @@ export class MergeTree {
                     const splitNode = this.split(block);
                     if (block === this.root) {
                         this.updateRoot(splitNode);
-                        // Update root already updates all it's children ordinals
+                        // Update root already updates all its children ordinals
                         ordinalUpdateNode = undefined;
                     } else {
                         this.insertChildNode(block.parent!, splitNode, block.index + 1);
@@ -2398,10 +1867,12 @@ 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
      */
     public annotateRange(
         start: number, end: number, props: PropertySet, combiningOp: ICombiningOp | undefined, refSeq: number,
-        clientId: number, seq: number, opArgs: IMergeTreeDeltaOpArgs) {
+        clientId: number, seq: number, opArgs: IMergeTreeDeltaOpArgs,
+        rollback: PropertiesRollback = PropertiesRollback.None) {
         this.ensureIntervalBoundary(start, refSeq, clientId);
         this.ensureIntervalBoundary(end, refSeq, clientId);
         const deltaSegments: IMergeTreeSegmentDelta[] = [];
@@ -2409,11 +1880,12 @@ export class MergeTree {
         let segmentGroup: SegmentGroup | undefined;
 
         const annotateSegment = (segment: ISegment) => {
-            const propertyDeltas = segment.addProperties(props, combiningOp, seq, this.collabWindow);
+            const propertyDeltas = segment.addProperties(props, combiningOp, seq, this.collabWindow, rollback);
             deltaSegments.push({ segment, propertyDeltas });
             if (this.collabWindow.collaborating) {
                 if (seq === UnassignedSequenceNumber) {
-                    segmentGroup = this.addToPendingList(segment, segmentGroup, localSeq);
+                    segmentGroup = this.addToPendingList(segment, segmentGroup, localSeq,
+                        propertyDeltas ? propertyDeltas : {});
                 } else {
                     if (MergeTree.options.zamboniSegments) {
                         this.addToLRUSet(segment, seq);
@@ -2449,13 +1921,13 @@ export class MergeTree {
         seq: number,
         overwrite = false,
         opArgs: IMergeTreeDeltaOpArgs,
-    ) {
+    ): void {
         let _overwrite = overwrite;
         this.ensureIntervalBoundary(start, refSeq, clientId);
         this.ensureIntervalBoundary(end, refSeq, clientId);
         let segmentGroup: SegmentGroup;
         const removedSegments: IMergeTreeSegmentDelta[] = [];
-        const segmentsWithRefs: ISegment[] = [];
+        const localOverlapWithRefs: ISegment[] = [];
         const localSeq = seq === UnassignedSequenceNumber ? ++this.collabWindow.localSeq : undefined;
         const markRemoved = (segment: ISegment, pos: number, _start: number, _end: number) => {
             const existingRemovalInfo = toRemovalInfo(segment);
@@ -2464,11 +1936,14 @@ export class MergeTree {
                 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 first removal at the head.
+                    // 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;
-                    segment.localRemovedSeq = undefined;
+                    if (segment.localRefs?.empty === false) {
+                        localOverlapWithRefs.push(segment);
+                    }
                 } else {
                     // Do not replace earlier sequence number for remove
                     existingRemovalInfo.removedClientIds.push(clientId);
@@ -2480,9 +1955,6 @@ export class MergeTree {
 
                 removedSegments.push({ segment });
             }
-            if (segment.localRefs && !segment.localRefs.empty) {
-                segmentsWithRefs.push(segment);
-            }
 
             // Save segment so can assign removed sequence number when acked by server
             if (this.collabWindow.collaborating) {
@@ -2505,11 +1977,12 @@ export class MergeTree {
             return true;
         };
         this.mapRange({ leaf: markRemoved, post: afterMarkRemoved }, refSeq, clientId, undefined, start, end);
-        const pending = this.collabWindow.collaborating && clientId === this.collabWindow.clientId;
-        for (const segment of segmentsWithRefs) {
-            this.updateSegmentRefsAfterMarkRemoved(segment, pending);
-        }
-
+        // these segments are already viewed as being removed locally and are not event-ed
+        // so can slide non-StayOnRemove refs immediately
+        localOverlapWithRefs.forEach(
+            (s) => this.slideReferences(s, Array.from(s.localRefs!)
+                .filter((localRef) => !refTypeIncludesFlag(localRef, ReferenceType.StayOnRemove))),
+        );
         // opArgs == undefined => test code
         if (this.mergeTreeDeltaCallback && removedSegments.length > 0) {
             this.mergeTreeDeltaCallback(
@@ -2519,6 +1992,20 @@ export class MergeTree {
                     deltaSegments: removedSegments,
                 });
         }
+        const pending = this.collabWindow.collaborating && clientId === this.collabWindow.clientId;
+        // 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.
+        removedSegments.forEach((rSeg) => {
+            const removedRefs = this.updateSegmentRefsAfterMarkRemoved(rSeg.segment, pending);
+            if (segmentGroup && removedRefs) {
+                if (!segmentGroup.removedReferences) {
+                    segmentGroup.removedReferences = [];
+                }
+                segmentGroup.removedReferences.push(...removedRefs);
+            }
+        });
+
         if (this.collabWindow.collaborating && (seq !== UnassignedSequenceNumber)) {
             if (MergeTree.options.zamboniSegments) {
                 this.zamboniSegments();
@@ -2526,10 +2013,122 @@ export class MergeTree {
         }
     }
 
+    /**
+     * Revert an unacked local op
+     */
+    public rollback(op: IMergeTreeDeltaOp, localOpMetadata: SegmentGroup) {
+        if (op.type === MergeTreeDeltaType.REMOVE) {
+            const pendingSegmentGroup = this.pendingSegments?.pop?.();
+            if (pendingSegmentGroup === undefined || pendingSegmentGroup !== localOpMetadata) {
+                throw new Error("Rollback op doesn't match last edit");
+            }
+            for (const segment of pendingSegmentGroup.segments) {
+                const segmentSegmentGroup = segment.segmentGroups.pop ? segment.segmentGroups.pop() : undefined;
+                assert(segmentSegmentGroup === pendingSegmentGroup, 0x39c /* Unexpected segmentGroup in segment */);
+
+                assert(segment.removedClientIds !== undefined
+                    && segment.removedClientIds[0] === this.collabWindow.clientId,
+                    0x39d /* Rollback segment removedClientId does not match local client */);
+                segment.removedClientIds = undefined;
+                segment.removedSeq = undefined;
+                segment.localRemovedSeq = undefined;
+
+                if (this.mergeTreeDeltaCallback) {
+                    const insertOp = createInsertSegmentOp(this.findRollbackPosition(segment), segment);
+                    this.mergeTreeDeltaCallback(
+                        { op: insertOp },
+                        {
+                            operation: MergeTreeDeltaType.INSERT,
+                            deltaSegments: [{ segment }],
+                        });
+                }
+
+                for (let updateNode = segment.parent; updateNode !== undefined; updateNode = updateNode.parent) {
+                    this.blockUpdateLength(updateNode, UnassignedSequenceNumber, this.collabWindow.clientId);
+                }
+            }
+            if (pendingSegmentGroup.removedReferences) {
+                for (const ref of pendingSegmentGroup.removedReferences) {
+                    const seg = ref.getSegment();
+                    if (!seg) {
+                        throw new Error("Cannot rollback reference without segment");
+                    }
+                    const localRefs = seg.localRefs ??= new LocalReferenceCollection(seg);
+                    localRefs.addLocalRef(ref, ref.getOffset());
+                }
+            }
+        } else if (op.type === MergeTreeDeltaType.INSERT || op.type === MergeTreeDeltaType.ANNOTATE) {
+            const pendingSegmentGroup = this.pendingSegments?.pop?.();
+            if (pendingSegmentGroup === undefined || pendingSegmentGroup !== localOpMetadata
+                || (op.type === MergeTreeDeltaType.ANNOTATE && !pendingSegmentGroup.previousProps)) {
+                throw new Error("Rollback op doesn't match last edit");
+            }
+            let i = 0;
+            for (const segment of pendingSegmentGroup.segments) {
+                const segmentSegmentGroup = segment.segmentGroups.pop ? segment.segmentGroups.pop() : undefined;
+                assert(segmentSegmentGroup === pendingSegmentGroup, 0x39e /* Unexpected segmentGroup in segment */);
+
+                const start = this.findRollbackPosition(segment);
+                if (op.type === MergeTreeDeltaType.INSERT) {
+                    const removeOp = createRemoveRangeOp(start, start + segment.cachedLength);
+                    this.markRangeRemoved(
+                        start,
+                        start + segment.cachedLength,
+                        UniversalSequenceNumber,
+                        this.collabWindow.clientId,
+                        UniversalSequenceNumber,
+                        false,
+                        { op: removeOp });
+                } else /* op.type === MergeTreeDeltaType.ANNOTATE */ {
+                    const props = pendingSegmentGroup.previousProps![i];
+                    const rollbackType = (op.combiningOp && op.combiningOp.name === "rewrite") ?
+                        PropertiesRollback.Rewrite : PropertiesRollback.Rollback;
+                    const annotateOp = createAnnotateRangeOp(start, start + segment.cachedLength, props, undefined);
+                    this.annotateRange(
+                        start,
+                        start + segment.cachedLength,
+                        props,
+                        undefined,
+                        UniversalSequenceNumber,
+                        this.collabWindow.clientId,
+                        UniversalSequenceNumber,
+                        { op: annotateOp },
+                        rollbackType);
+                    i++;
+                }
+            }
+        } else {
+            throw new Error("Unsupported op type for rollback");
+        }
+    }
+
+    /**
+     * Walk the segments up to the current segment and calculate its position
+     */
+    private findRollbackPosition(segment: ISegment) {
+        let segmentPosition = 0;
+        this.walkAllSegments(this.root, (seg) => {
+            // If we've found the desired segment, terminate the walk and return 'segmentPosition'.
+            if (seg === segment) {
+                return false;
+            }
+
+            // If not removed, increase position
+            if (seg.removedSeq === undefined) {
+                segmentPosition += seg.cachedLength;
+            }
+
+            return true;
+        });
+
+        return segmentPosition;
+    }
+
     private nodeUpdateLengthNewStructure(node: IMergeBlock, recur = false) {
         this.blockUpdate(node);
         if (this.collabWindow.collaborating) {
-            node.partialLengths = PartialSequenceLengths.combine(this, node, this.collabWindow, recur);
+            this.localPartialsComputed = false;
+            node.partialLengths = PartialSequenceLengths.combine(node, this.collabWindow, recur);
         }
     }
 
@@ -2545,53 +2144,26 @@ export class MergeTree {
         }
     }
     public createLocalReferencePosition(
-        segment: ISegment, offset: number | undefined, refType: ReferenceType, properties: PropertySet | undefined,
-        client: Client,
+        segment: ISegment, offset: number, refType: ReferenceType, properties: PropertySet | undefined,
     ): LocalReferencePosition {
-        if (isRemoved(segment)) {
-            if (!refTypeIncludesFlag(refType, ReferenceType.SlideOnRemove | ReferenceType.Transient)) {
-                throw new UsageError(
-                    "Can only create SlideOnRemove or Transient local reference position on a removed segment");
-            }
+        if (
+            isRemovedAndAcked(segment)
+            && !refTypeIncludesFlag(refType, ReferenceType.SlideOnRemove | ReferenceType.Transient)
+        ) {
+            throw new UsageError(
+                "Can only create SlideOnRemove or Transient local reference position on a removed segment",
+            );
         }
         const localRefs = segment.localRefs ?? new LocalReferenceCollection(segment);
         segment.localRefs = localRefs;
 
-        const segRef = localRefs.createLocalRef(offset, refType, properties, client);
+        const segRef = localRefs.createLocalRef(offset, refType, properties);
 
         this.blockUpdatePathLengths(segment.parent, TreeMaintenanceSequenceNumber,
             LocalClientId);
         return segRef;
     }
 
-    /**
-     * @deprecated - use removeLocalReferencePosition
-     */
-    public removeLocalReference(segment: ISegment, lref: LocalReference) {
-        if (segment.localRefs) {
-            const removedRef = segment.localRefs.removeLocalRef(lref);
-            if (removedRef) {
-                this.blockUpdatePathLengths(segment.parent, TreeMaintenanceSequenceNumber,
-                    LocalClientId);
-            }
-        }
-    }
-
-    /**
-     * @deprecated - use createLocalReference
-     */
-    public addLocalReference(lref: LocalReference) {
-        const segment = lref.segment!;
-        let localRefs = segment.localRefs;
-        if (!localRefs) {
-            localRefs = new LocalReferenceCollection(segment);
-            segment.localRefs = localRefs;
-        }
-        localRefs.addLocalRef(lref);
-        this.blockUpdatePathLengths(segment.parent, TreeMaintenanceSequenceNumber,
-            LocalClientId);
-    }
-
     private blockUpdate(block: IMergeBlock) {
         let len = 0;
         const hierBlock = block.hierBlock();
@@ -2604,8 +2176,13 @@ export class MergeTree {
             const child = block.children[i];
             len += nodeTotalLength(this, child) ?? 0;
             if (hierBlock) {
-                hierBlock.addNodeReferences(this, child);
-            }
+                addNodeReferences(
+                    this,
+                    child,
+                    hierBlock.rightmostTiles,
+                    hierBlock.leftmostTiles,
+                    hierBlock.rangeStacks);
+                }
             if (this.blockUpdateActions) {
                 this.blockUpdateActions.child(block, i);
             }
@@ -2632,6 +2209,7 @@ export class MergeTree {
 
     private blockUpdateLength(node: IMergeBlock, seq: number, clientId: number) {
         this.blockUpdate(node);
+        this.localPartialsComputed = false;
         if (
             this.collabWindow.collaborating
             && seq !== UnassignedSequenceNumber
@@ -2642,9 +2220,9 @@ export class MergeTree {
                 && MergeTree.options.incrementalUpdate
                 && clientId !== NonCollabClient
             ) {
-                node.partialLengths.update(this, node, seq, clientId, this.collabWindow);
+                node.partialLengths.update(node, seq, clientId, this.collabWindow);
             } else {
-                node.partialLengths = PartialSequenceLengths.combine(this, node, this.collabWindow);
+                node.partialLengths = PartialSequenceLengths.combine(node, this.collabWindow);
             }
         }
     }
@@ -2679,6 +2257,10 @@ export class MergeTree {
         this.nodeMap(this.root, actions, 0, refSeq, clientId, accum, start, end);
     }
 
+    /**
+     * @deprecated  for internal use only. public export will be removed.
+     * @internal
+     */
     public incrementalBlockMap<TContext>(stateStack: Stack<IncrementalMapState<TContext>>) {
         while (!stateStack.empty()) {
             // We already check the stack is not empty