@fluidframework/sequence 1.4.0-121020 → 2.0.0-dev-rc.1.0.0.224419

package/src/sequence.ts

@@ -2,62 +2,63 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-import { Deferred, bufferToString, assert } from "@fluidframework/common-utils";
-import { ChildLogger } from "@fluidframework/telemetry-utils";
-import {
-    ISequencedDocumentMessage,
-    MessageType,
-} from "@fluidframework/protocol-definitions";
+
+import { assert, Deferred } from "@fluidframework/core-utils";
+import { bufferToString } from "@fluid-internal/client-utils";
+import { LoggingError, createChildLogger } from "@fluidframework/telemetry-utils";
+import { ISequencedDocumentMessage, MessageType } from "@fluidframework/protocol-definitions";
 import {
-    IChannelAttributes,
-    IFluidDataStoreRuntime,
-    IChannelStorageService,
+	IChannelAttributes,
+	IFluidDataStoreRuntime,
+	IChannelStorageService,
 } from "@fluidframework/datastore-definitions";
 import {
-    Client,
-    createAnnotateRangeOp,
-    createGroupOp,
-    createInsertOp,
-    createRemoveRangeOp,
-    ICombiningOp,
-    IJSONSegment,
-    IMergeTreeAnnotateMsg,
-    IMergeTreeDeltaOp,
-    IMergeTreeGroupMsg,
-    IMergeTreeOp,
-    IMergeTreeRemoveMsg,
-    IRelativePosition,
-    ISegment,
-    ISegmentAction,
-    LocalReference,
-    LocalReferencePosition,
-    matchProperties,
-    MergeTreeDeltaType,
-    PropertySet,
-    RangeStackMap,
-    ReferencePosition,
-    ReferenceType,
-    SegmentGroup,
+	// eslint-disable-next-line import/no-deprecated
+	Client,
+	createAnnotateRangeOp,
+	// eslint-disable-next-line import/no-deprecated
+	createGroupOp,
+	createInsertOp,
+	createRemoveRangeOp,
+	IJSONSegment,
+	IMergeTreeAnnotateMsg,
+	IMergeTreeDeltaOp,
+	IMergeTreeGroupMsg,
+	IMergeTreeOp,
+	IMergeTreeRemoveMsg,
+	IRelativePosition,
+	ISegment,
+	ISegmentAction,
+	LocalReferencePosition,
+	matchProperties,
+	MergeTreeDeltaType,
+	PropertySet,
+	ReferencePosition,
+	ReferenceType,
+	MergeTreeRevertibleDriver,
+	SegmentGroup,
+	IMergeTreeObliterateMsg,
+	createObliterateRangeOp,
+	SlidingPreference,
 } from "@fluidframework/merge-tree";
 import { ObjectStoragePartition, SummaryTreeBuilder } from "@fluidframework/runtime-utils";
 import {
-    IFluidSerializer,
-    makeHandlesSerializable,
-    parseHandles,
-    SharedObject,
-    ISharedObjectEvents,
-    SummarySerializer,
+	IFluidSerializer,
+	makeHandlesSerializable,
+	parseHandles,
+	SharedObject,
+	ISharedObjectEvents,
 } from "@fluidframework/shared-object-base";
-import { IEventThisPlaceHolder } from "@fluidframework/common-definitions";
+import { IEventThisPlaceHolder } from "@fluidframework/core-interfaces";
 import { ISummaryTreeWithStats, ITelemetryContext } from "@fluidframework/runtime-definitions";
-
+import { DefaultMap, IMapOperation } from "./defaultMap";
+import { IMapMessageLocalMetadata, IValueChanged } from "./defaultMapInterfaces";
+import { SequenceInterval } from "./intervals";
 import {
-    IntervalCollection,
-    SequenceInterval,
-    SequenceIntervalCollectionValueType,
+	IIntervalCollection,
+	IntervalCollection,
+	SequenceIntervalCollectionValueType,
 } from "./intervalCollection";
-import { DefaultMap } from "./defaultMap";
-import { IMapMessageLocalMetadata, IValueChanged } from "./defaultMapInterfaces";
 import { SequenceDeltaEvent, SequenceMaintenanceEvent } from "./sequenceDeltaEvent";
 import { ISharedIntervalCollection } from "./sharedIntervalCollection";
 
@@ -67,7 +68,7 @@ const contentPath = "content";
 /**
  * Events emitted in response to changes to the sequence data.
  *
- *  @remarks
+ * @remarks
  *
  * The following is the list of events emitted.
  *
@@ -96,652 +97,806 @@ const contentPath = "content";
  * - `event` - Various information on the segments that were modified.
  *
  * - `target` - The sequence itself.
+ * @alpha
  */
 export interface ISharedSegmentSequenceEvents extends ISharedObjectEvents {
-    (event: "createIntervalCollection",
-        listener: (label: string, local: boolean, target: IEventThisPlaceHolder) => void);
-    (event: "sequenceDelta", listener: (event: SequenceDeltaEvent, target: IEventThisPlaceHolder) => void);
-    (event: "maintenance",
-        listener: (event: SequenceMaintenanceEvent, target: IEventThisPlaceHolder) => void);
+	(
+		event: "createIntervalCollection",
+		listener: (label: string, local: boolean, target: IEventThisPlaceHolder) => void,
+	): void;
+	(
+		event: "sequenceDelta",
+		listener: (event: SequenceDeltaEvent, target: IEventThisPlaceHolder) => void,
+	): void;
+	(
+		event: "maintenance",
+		listener: (event: SequenceMaintenanceEvent, target: IEventThisPlaceHolder) => void,
+	): void;
 }
 
+/**
+ * @alpha
+ */
 export abstract class SharedSegmentSequence<T extends ISegment>
-    extends SharedObject<ISharedSegmentSequenceEvents>
-    implements ISharedIntervalCollection<SequenceInterval> {
-    get loaded(): Promise<void> {
-        return this.loadedDeferred.promise;
-    }
-
-    private static createOpsFromDelta(event: SequenceDeltaEvent): IMergeTreeDeltaOp[] {
-        const ops: IMergeTreeDeltaOp[] = [];
-        for (const r of event.ranges) {
-            switch (event.deltaOperation) {
-                case MergeTreeDeltaType.ANNOTATE: {
-                    const lastAnnotate = ops[ops.length - 1] as IMergeTreeAnnotateMsg;
-                    const props = {};
-                    for (const key of Object.keys(r.propertyDeltas)) {
-                        props[key] = r.segment.properties?.[key] ?? null;
-                    }
-                    if (lastAnnotate && lastAnnotate.pos2 === r.position &&
-                        matchProperties(lastAnnotate.props, props)) {
-                        lastAnnotate.pos2 += r.segment.cachedLength;
-                    } else {
-                        ops.push(createAnnotateRangeOp(
-                            r.position,
-                            r.position + r.segment.cachedLength,
-                            props,
-                            undefined));
-                    }
-                    break;
-                }
-
-                case MergeTreeDeltaType.INSERT:
-                    ops.push(createInsertOp(
-                        r.position,
-                        r.segment.clone().toJSONObject()));
-                    break;
-
-                case MergeTreeDeltaType.REMOVE: {
-                    const lastRem = ops[ops.length - 1] as IMergeTreeRemoveMsg;
-                    if (lastRem?.pos1 === r.position) {
-                        lastRem.pos2 += r.segment.cachedLength;
-                    } else {
-                        ops.push(createRemoveRangeOp(
-                            r.position,
-                            r.position + r.segment.cachedLength));
-                    }
-                    break;
-                }
-
-                default:
-            }
-        }
-        return ops;
-    }
-
-    protected client: Client;
-    // Deferred that triggers once the object is loaded
-    protected loadedDeferred = new Deferred<void>();
-    // cache out going ops created when partial loading
-    private readonly loadedDeferredOutgoingOps:
-        [IMergeTreeOp, SegmentGroup | SegmentGroup[]][] = [];
-    // cache incoming ops that arrive when partial loading
-    private deferIncomingOps = true;
-    private readonly loadedDeferredIncomingOps: ISequencedDocumentMessage[] = [];
-
-    private messagesSinceMSNChange: ISequencedDocumentMessage[] = [];
-    private readonly intervalCollections: DefaultMap<IntervalCollection<SequenceInterval>>;
-    constructor(
-        private readonly dataStoreRuntime: IFluidDataStoreRuntime,
-        public id: string,
-        attributes: IChannelAttributes,
-        public readonly segmentFromSpec: (spec: IJSONSegment) => ISegment,
-    ) {
-        super(id, dataStoreRuntime, attributes, "fluid_sequence_");
-
-        this.loadedDeferred.promise.catch((error) => {
-            this.logger.sendErrorEvent({ eventName: "SequenceLoadFailed" }, error);
-        });
-
-        this.client = new Client(
-            segmentFromSpec,
-            ChildLogger.create(this.logger, "SharedSegmentSequence.MergeTreeClient"),
-            dataStoreRuntime.options);
-
-        super.on("newListener", (event) => {
-            switch (event) {
-                case "sequenceDelta":
-                    if (!this.client.mergeTreeDeltaCallback) {
-                        this.client.mergeTreeDeltaCallback = (opArgs, deltaArgs) => {
-                            this.emit("sequenceDelta", new SequenceDeltaEvent(opArgs, deltaArgs, this.client), this);
-                        };
-                    }
-                    break;
-                case "maintenance":
-                    if (!this.client.mergeTreeMaintenanceCallback) {
-                        this.client.mergeTreeMaintenanceCallback = (args, opArgs) => {
-                            this.emit("maintenance", new SequenceMaintenanceEvent(opArgs, args, this.client), this);
-                        };
-                    }
-                    break;
-                default:
-            }
-        });
-        super.on("removeListener", (event: string | symbol) => {
-            switch (event) {
-                case "sequenceDelta":
-                    if (super.listenerCount(event) === 0) {
-                        this.client.mergeTreeDeltaCallback = undefined;
-                    }
-                    break;
-                case "maintenance":
-                    if (super.listenerCount(event) === 0) {
-                        this.client.mergeTreeMaintenanceCallback = undefined;
-                    }
-                    break;
-                default:
-                    break;
-            }
-        });
-
-        this.intervalCollections = new DefaultMap(
-            this.serializer,
-            this.handle,
-            (op, localOpMetadata) => this.submitLocalMessage(op, localOpMetadata),
-            new SequenceIntervalCollectionValueType(),
-        );
-    }
-
-    /**
-     * @param start - The inclusive start of the range to remove
-     * @param end - The exclusive end of the range to remove
-     */
-    public removeRange(start: number, end: number): IMergeTreeRemoveMsg {
-        const removeOp = this.client.removeRangeLocal(start, end);
-        if (removeOp) {
-            this.submitSequenceMessage(removeOp);
-        }
-        return removeOp;
-    }
-
-    public groupOperation(groupOp: IMergeTreeGroupMsg) {
-        this.client.localTransaction(groupOp);
-        this.submitSequenceMessage(groupOp);
-    }
-
-    public getContainingSegment(pos: number) {
-        return this.client.getContainingSegment<T>(pos);
-    }
-
-    /**
-     * Returns the length of the current sequence for the client
-     */
-    public getLength() {
-        return this.client.getLength();
-    }
-
-    /**
-     * Returns the current position of a segment, and -1 if the segment
-     * does not exist in this sequence
-     * @param segment - The segment to get the position of
-     */
-    public getPosition(segment: ISegment): number {
-        return this.client.getPosition(segment);
-    }
-
-    /**
-     * Annotates the range with the provided properties
-     *
-     * @param start - The inclusive start position of the range to annotate
-     * @param end - The exclusive end position of the range to annotate
-     * @param props - The properties to annotate the range with
-     * @param combiningOp - Optional. Specifies how to combine values for the property, such as "incr" for increment.
-     *
-     */
-    public annotateRange(
-        start: number,
-        end: number,
-        props: PropertySet,
-        combiningOp?: ICombiningOp) {
-        const annotateOp =
-            this.client.annotateRangeLocal(start, end, props, combiningOp);
-        if (annotateOp) {
-            this.submitSequenceMessage(annotateOp);
-        }
-    }
-
-    public getPropertiesAtPosition(pos: number) {
-        return this.client.getPropertiesAtPosition(pos);
-    }
-
-    public getRangeExtentsOfPosition(pos: number) {
-        return this.client.getRangeExtentsOfPosition(pos);
-    }
-
-    /**
-     * @deprecated - use createLocalReferencePosition
-     */
-    public createPositionReference(
-        segment: T,
-        offset: number,
-        refType: ReferenceType): LocalReference {
-        const lref = new LocalReference(this.client, segment, offset, refType);
-        if (refType !== ReferenceType.Transient) {
-            this.addLocalReference(lref);
-        }
-        return lref;
-    }
-
-    public createLocalReferencePosition(
-        segment: T,
-        offset: number,
-        refType: ReferenceType,
-        properties: PropertySet | undefined): LocalReferencePosition {
-        return this.client.createLocalReferencePosition(
-            segment,
-            offset,
-            refType,
-            properties);
-    }
-
-    /**
-     * @deprecated - use localReferencePositionToPosition
-     */
-    public localRefToPos(localRef: LocalReference) {
-        return this.client.localReferencePositionToPosition(localRef);
-    }
-
-    public localReferencePositionToPosition(lref: ReferencePosition): number {
-        return this.client.localReferencePositionToPosition(lref);
-    }
-
-    /**
-     * Resolves a remote client's position against the local sequence
-     * and returns the remote client's position relative to the local
-     * sequence. The client ref seq must be above the minimum sequence number
-     * or the return value will be undefined.
-     * Generally this method is used in conjunction with signals which provide
-     * point in time values for the below parameters, and is useful for things
-     * like displaying user position. It should not be used with persisted values
-     * as persisted values will quickly become invalid as the remoteClientRefSeq
-     * moves below the minimum sequence number
-     * @param remoteClientPosition - The remote client's position to resolve
-     * @param remoteClientRefSeq - The reference sequence number of the remote client
-     * @param remoteClientId - The client id of the remote client
-     */
-    public resolveRemoteClientPosition(
-        remoteClientPosition: number,
-        remoteClientRefSeq: number,
-        remoteClientId: string): number {
-        return this.client.resolveRemoteClientPosition(
-            remoteClientPosition,
-            remoteClientRefSeq,
-            remoteClientId);
-    }
-
-    public submitSequenceMessage(message: IMergeTreeOp) {
-        if (!this.isAttached()) {
-            return;
-        }
-        const translated = makeHandlesSerializable(message, this.serializer, this.handle);
-        const metadata = this.client.peekPendingSegmentGroups(
-            message.type === MergeTreeDeltaType.GROUP ? message.ops.length : 1);
-
-        // if loading isn't complete, we need to cache
-        // local ops until loading is complete, and then
-        // they will be resent
-        if (!this.loadedDeferred.isCompleted) {
-            this.loadedDeferredOutgoingOps.push([translated, metadata]);
-        } else {
-            this.submitLocalMessage(translated, metadata);
-        }
-    }
-
-    /**
-     * @deprecated - use createLocalReferencePosition
-     */
-    public addLocalReference(lref: LocalReference) {
-        return this.client.addLocalReference(lref);
-    }
-
-    /**
-     * @deprecated - use removeLocalReferencePosition
-     */
-    public removeLocalReference(lref: LocalReference) {
-        return this.client.removeLocalReferencePosition(lref);
-    }
-
-    public removeLocalReferencePosition(lref: LocalReferencePosition) {
-        return this.client.removeLocalReferencePosition(lref);
-    }
-
-    /**
-     * Given a position specified relative to a marker id, lookup the marker
-     * and convert the position to a character position.
-     * @param relativePos - Id of marker (may be indirect) and whether position is before or after marker.
-     */
-    public posFromRelativePos(relativePos: IRelativePosition) {
-        return this.client.posFromRelativePos(relativePos);
-    }
-
-    /**
-     * Walk the underlying segments of the sequence.
-     * The walked segments may extend beyond the range
-     * if the segments cross the ranges start or end boundaries.
-     * Set split range to true to ensure only segments within the
-     * range are walked.
-     *
-     * @param handler - The function to handle each segment
-     * @param start - Optional. The start of range walk.
-     * @param end - Optional. The end of range walk
-     * @param accum - Optional. An object that will be passed to the handler for accumulation
-     * @param splitRange - Optional. Splits boundary segments on the range boundaries
-     */
-    public walkSegments<TClientData>(
-        handler: ISegmentAction<TClientData>,
-        start?: number, end?: number, accum?: TClientData,
-        splitRange: boolean = false) {
-        return this.client.walkSegments<TClientData>(handler, start, end, accum, splitRange);
-    }
-
-    public getStackContext(startPos: number, rangeLabels: string[]): RangeStackMap {
-        return this.client.getStackContext(startPos, rangeLabels);
-    }
-
-    public getCurrentSeq() {
-        return this.client.getCurrentSeq();
-    }
-
-    public insertAtReferencePosition(pos: ReferencePosition, segment: T) {
-        const insertOp = this.client.insertAtReferencePositionLocal(pos, segment);
-        if (insertOp) {
-            this.submitSequenceMessage(insertOp);
-        }
-    }
-
-    /**
-     * @deprecated - IntervalCollections are created on a first-write wins basis, and concurrent creates
-     * are supported. Use `getIntervalCollection` instead.
-     */
-    public async waitIntervalCollection(
-        label: string,
-    ): Promise<IntervalCollection<SequenceInterval>> {
-        return this.intervalCollections.get(label);
-    }
-
-    public getIntervalCollection(label: string): IntervalCollection<SequenceInterval> {
-        return this.intervalCollections.get(label);
-    }
-
-    /**
-     * @returns an iterable object that enumerates the IntervalCollection labels
-     * Usage:
-     * const iter = this.getIntervalCollectionKeys();
-     * for (key of iter)
-     *     const collection = this.getIntervalCollection(key);
-     *     ...
-    */
-    public getIntervalCollectionLabels(): IterableIterator<string> {
-        return this.intervalCollections.keys();
-    }
-
-    protected summarizeCore(
-        serializer: IFluidSerializer,
-        telemetryContext?: ITelemetryContext,
-    ): ISummaryTreeWithStats {
-        const builder = new SummaryTreeBuilder();
-
-        // conditionally write the interval collection blob
-        // only if it has entries
-        if (this.intervalCollections.size > 0) {
-            builder.addBlob(snapshotFileName, this.intervalCollections.serialize(serializer));
-        }
-
-        builder.addWithStats(contentPath, this.summarizeMergeTree(serializer));
-
-        return builder.getSummaryTree();
-    }
-
-    /**
-     * Runs serializer over the GC data for this SharedMatrix.
-     * All the IFluidHandle's represent routes to other objects.
-     */
-    protected processGCDataCore(serializer: SummarySerializer) {
-        if (this.intervalCollections.size > 0) {
-            this.intervalCollections.serialize(serializer);
-        }
-
-        this.client.serializeGCData(this.handle, serializer);
-    }
-
-    /**
-     * Replace the range specified from start to end with the provided segment
-     * This is done by inserting the segment at the end of the range, followed
-     * by removing the contents of the range
-     * For a zero or reverse range (start \>= end), insert at end do not remove anything
-     * @param start - The start of the range to replace
-     * @param end - The end of the range to replace
-     * @param segment - The segment that will replace the range
-     */
-    protected replaceRange(start: number, end: number, segment: ISegment) {
-        // Insert at the max end of the range when start > end, but still remove the range later
-        const insertIndex: number = Math.max(start, end);
-
-        // Insert first, so local references can slide to the inserted seg if any
-        const insert = this.client.insertSegmentLocal(insertIndex, segment);
-        if (insert) {
-            if (start < end) {
-                const remove = this.client.removeRangeLocal(start, end);
-                this.submitSequenceMessage(createGroupOp(insert, remove));
-            } else {
-                this.submitSequenceMessage(insert);
-            }
-        }
-    }
-
-    protected onConnect() {
-        // Update merge tree collaboration information with new client ID and then resend pending ops
-        this.client.startOrUpdateCollaboration(this.runtime.clientId);
-    }
-
-    protected onDisconnect() { }
-
-    protected reSubmitCore(content: any, localOpMetadata: unknown) {
-        if (!this.intervalCollections.tryResubmitMessage(content, localOpMetadata as IMapMessageLocalMetadata)) {
-            this.submitSequenceMessage(
-                this.client.regeneratePendingOp(
-                    content as IMergeTreeOp,
-                    localOpMetadata as SegmentGroup | SegmentGroup[]));
-        }
-    }
-
-    /**
-     * {@inheritDoc @fluidframework/shared-object-base#SharedObject.loadCore}
-     */
-    protected async loadCore(storage: IChannelStorageService) {
-        if (await storage.contains(snapshotFileName)) {
-            const blob = await storage.readBlob(snapshotFileName);
-            const header = bufferToString(blob, "utf8");
-            this.intervalCollections.populate(header);
-        }
-
-        try {
-            // this will load the header, and return a promise
-            // that will resolve when the body is loaded
-            // and the catchup ops are available.
-            const { catchupOpsP } = await this.client.load(
-                this.runtime,
-                new ObjectStoragePartition(storage, contentPath),
-                this.serializer);
-
-            // setup a promise to process the
-            // catch up ops, and finishing the loading process
-            const loadCatchUpOps = catchupOpsP
-                .then((msgs) => {
-                    msgs.forEach((m) => {
-                        const collabWindow = this.client.getCollabWindow();
-                        if (m.minimumSequenceNumber < collabWindow.minSeq
-                            || m.referenceSequenceNumber < collabWindow.minSeq
-                            || m.sequenceNumber <= collabWindow.minSeq
-                            || m.sequenceNumber <= collabWindow.currentSeq) {
-                            throw new Error(`Invalid catchup operations in snapshot: ${JSON.stringify({
-                                op: {
-                                    seq: m.sequenceNumber,
-                                    minSeq: m.minimumSequenceNumber,
-                                    refSeq: m.referenceSequenceNumber,
-                                },
-                                collabWindow: {
-                                    seq: collabWindow.currentSeq,
-                                    minSeq: collabWindow.minSeq,
-                                },
-                            })}`);
-                        }
-                        this.processMergeTreeMsg(m);
-                    });
-                    this.loadFinished();
-                })
-                .catch((error) => {
-                    this.loadFinished(error);
-                });
-            if (this.dataStoreRuntime.options?.sequenceInitializeFromHeaderOnly !== true) {
-                // if we not doing partial load, await the catch up ops,
-                // and the finalization of the load
-                await loadCatchUpOps;
-            }
-        } catch (error) {
-            this.loadFinished(error);
-        }
-    }
-
-    protected processCore(message: ISequencedDocumentMessage, local: boolean, localOpMetadata: unknown) {
-        // if loading isn't complete, we need to cache all
-        // incoming ops to be applied after loading is complete
-        if (this.deferIncomingOps) {
-            assert(!local, 0x072 /* "Unexpected local op when loading not finished" */);
-            this.loadedDeferredIncomingOps.push(message);
-        } else {
-            assert(message.type === MessageType.Operation, 0x073 /* "Sequence message not operation" */);
-
-            const handled = this.intervalCollections.tryProcessMessage(
-                message.contents,
-                local,
-                message,
-                localOpMetadata,
-            );
-
-            if (!handled) {
-                this.processMergeTreeMsg(message, local);
-            }
-        }
-    }
-
-    protected didAttach() {
-        // If we are not local, and we've attached we need to start generating and sending ops
-        // so start collaboration and provide a default client id incase we are not connected
-        if (this.isAttached()) {
-            this.client.startOrUpdateCollaboration(this.runtime.clientId ?? "attached");
-        }
-    }
-
-    protected initializeLocalCore() {
-        super.initializeLocalCore();
-        this.loadFinished();
-    }
-
-    /**
-     * {@inheritDoc @fluidframework/shared-object-base#SharedObjectCore.applyStashedOp}
-     */
-    protected applyStashedOp(content: any): unknown {
-        return this.client.applyStashedOp(content);
-    }
-
-    private summarizeMergeTree(serializer: IFluidSerializer): ISummaryTreeWithStats {
-        // Are we fully loaded? If not, things will go south
-        assert(this.loadedDeferred.isCompleted, 0x074 /* "Snapshot called when not fully loaded" */);
-        const minSeq = this.runtime.deltaManager.minimumSequenceNumber;
-
-        this.processMinSequenceNumberChanged(minSeq);
-
-        this.messagesSinceMSNChange.forEach((m) => { m.minimumSequenceNumber = minSeq; });
-
-        return this.client.summarize(this.runtime, this.handle, serializer, this.messagesSinceMSNChange);
-    }
-
-    private processMergeTreeMsg(rawMessage: ISequencedDocumentMessage, local?: boolean) {
-        const message = parseHandles(rawMessage, this.serializer);
-
-        const ops: IMergeTreeDeltaOp[] = [];
-        function transformOps(event: SequenceDeltaEvent) {
-            ops.push(...SharedSegmentSequence.createOpsFromDelta(event));
-        }
-        const needsTransformation = message.referenceSequenceNumber !== message.sequenceNumber - 1;
-        let stashMessage: Readonly<ISequencedDocumentMessage> = message;
-        if (this.runtime.options?.newMergeTreeSnapshotFormat !== true) {
-            if (needsTransformation) {
-                this.on("sequenceDelta", transformOps);
-            }
-        }
-
-        this.client.applyMsg(message, local);
-
-        if (this.runtime.options?.newMergeTreeSnapshotFormat !== true) {
-            if (needsTransformation) {
-                this.removeListener("sequenceDelta", transformOps);
-                // shallow clone the message as we only overwrite top level properties,
-                // like referenceSequenceNumber and content only
-                stashMessage = {
-                    ...message,
-                    referenceSequenceNumber: stashMessage.sequenceNumber - 1,
-                    contents: ops.length !== 1 ? createGroupOp(...ops) : ops[0],
-                };
-            }
-
-            this.messagesSinceMSNChange.push(stashMessage);
-
-            // Do GC every once in a while...
-            if (this.messagesSinceMSNChange.length > 20
-                && this.messagesSinceMSNChange[20].sequenceNumber < message.minimumSequenceNumber) {
-                this.processMinSequenceNumberChanged(message.minimumSequenceNumber);
-            }
-        }
-    }
-
-    private processMinSequenceNumberChanged(minSeq: number) {
-        let index = 0;
-        for (; index < this.messagesSinceMSNChange.length; index++) {
-            if (this.messagesSinceMSNChange[index].sequenceNumber > minSeq) {
-                break;
-            }
-        }
-        if (index !== 0) {
-            this.messagesSinceMSNChange = this.messagesSinceMSNChange.slice(index);
-        }
-    }
-
-    private loadFinished(error?: any) {
-        if (!this.loadedDeferred.isCompleted) {
-            // Initialize the interval collections
-            this.initializeIntervalCollections();
-            if (error) {
-                this.loadedDeferred.reject(error);
-                throw error;
-            } else {
-                // it is important this series remains synchronous
-                // first we stop deferring incoming ops, and apply then all
-                this.deferIncomingOps = false;
-                for (const message of this.loadedDeferredIncomingOps) {
-                    this.processCore(message, false, undefined);
-                }
-                this.loadedDeferredIncomingOps.length = 0;
-
-                // then resolve the loaded promise
-                // and resubmit all the outstanding ops, as the snapshot
-                // is fully loaded, and all outstanding ops are applied
-                this.loadedDeferred.resolve();
-
-                for (const [messageContent, opMetadata] of this.loadedDeferredOutgoingOps) {
-                    this.reSubmitCore(messageContent, opMetadata);
-                }
-                this.loadedDeferredOutgoingOps.length = 0;
-            }
-        }
-    }
-
-    private initializeIntervalCollections() {
-        // Listen and initialize new SharedIntervalCollections
-        this.intervalCollections.eventEmitter.on("create", ({ key, previousValue }: IValueChanged, local: boolean) => {
-            const intervalCollection = this.intervalCollections.get(key);
-            if (!intervalCollection.attached) {
-                intervalCollection.attachGraph(this.client, key);
-            }
-            assert(previousValue === undefined, 0x2c1 /* "Creating an interval collection that already exists?" */);
-            this.emit("createIntervalCollection", key, local, this);
-        });
-
-        // Initialize existing SharedIntervalCollections
-        for (const key of this.intervalCollections.keys()) {
-            const intervalCollection = this.intervalCollections.get(key);
-            intervalCollection.attachGraph(this.client, key);
-        }
-    }
+	extends SharedObject<ISharedSegmentSequenceEvents>
+	implements ISharedIntervalCollection<SequenceInterval>, MergeTreeRevertibleDriver
+{
+	get loaded(): Promise<void> {
+		return this.loadedDeferred.promise;
+	}
+
+	/**
+	 * This is a safeguard to avoid problematic reentrancy of local ops. This type of scenario occurs if the user of SharedString subscribes
+	 * to the `sequenceDelta` event and uses the callback for a local op to submit further local ops.
+	 * Historically (before 2.0.0-internal.6.1.0), doing so would result in eventual consistency issues or a corrupted document.
+	 * These issues were fixed in #16815 which makes such reentrancy no different from applying the ops in order but not from within the change events,
+	 * but there is still little test coverage for reentrant scenarios.
+	 * Additionally, applications submitting ops from inside change events need to take extreme care that their data models also support reentrancy.
+	 * Since this is likely not the case, by default SharedString throws when encountering reentrant ops.
+	 *
+	 * An application using SharedString which explicitly wants to opt in to allowing reentrancy anyway can set `sharedStringPreventReentrancy`
+	 * on the data store options to `false`.
+	 */
+	protected guardReentrancy: <TRet>(callback: () => TRet) => TRet;
+
+	private static createOpsFromDelta(event: SequenceDeltaEvent): IMergeTreeDeltaOp[] {
+		const ops: IMergeTreeDeltaOp[] = [];
+		for (const r of event.ranges) {
+			switch (event.deltaOperation) {
+				case MergeTreeDeltaType.ANNOTATE: {
+					const lastAnnotate = ops[ops.length - 1] as IMergeTreeAnnotateMsg;
+					const props: PropertySet = {};
+					for (const key of Object.keys(r.propertyDeltas)) {
+						props[key] = r.segment.properties?.[key] ?? null;
+					}
+					if (
+						lastAnnotate &&
+						lastAnnotate.pos2 === r.position &&
+						matchProperties(lastAnnotate.props, props)
+					) {
+						lastAnnotate.pos2 += r.segment.cachedLength;
+					} else {
+						ops.push(
+							createAnnotateRangeOp(
+								r.position,
+								r.position + r.segment.cachedLength,
+								props,
+							),
+						);
+					}
+					break;
+				}
+
+				case MergeTreeDeltaType.INSERT:
+					ops.push(createInsertOp(r.position, r.segment.clone().toJSONObject()));
+					break;
+
+				case MergeTreeDeltaType.REMOVE: {
+					const lastRem = ops[ops.length - 1] as IMergeTreeRemoveMsg;
+					if (lastRem?.pos1 === r.position) {
+						assert(
+							lastRem.pos2 !== undefined,
+							0x3ff /* pos2 should not be undefined here */,
+						);
+						lastRem.pos2 += r.segment.cachedLength;
+					} else {
+						ops.push(
+							createRemoveRangeOp(r.position, r.position + r.segment.cachedLength),
+						);
+					}
+					break;
+				}
+
+				case MergeTreeDeltaType.OBLITERATE: {
+					const lastRem = ops[ops.length - 1] as IMergeTreeObliterateMsg;
+					if (lastRem?.pos1 === r.position) {
+						assert(
+							lastRem.pos2 !== undefined,
+							0x874 /* pos2 should not be undefined here */,
+						);
+						lastRem.pos2 += r.segment.cachedLength;
+					} else {
+						ops.push(
+							createObliterateRangeOp(
+								r.position,
+								r.position + r.segment.cachedLength,
+							),
+						);
+					}
+					break;
+				}
+
+				default:
+			}
+		}
+		return ops;
+	}
+
+	// eslint-disable-next-line import/no-deprecated
+	protected client: Client;
+	/** `Deferred` that triggers once the object is loaded */
+	protected loadedDeferred = new Deferred<void>();
+	// cache out going ops created when partial loading
+	private readonly loadedDeferredOutgoingOps: [IMergeTreeOp, SegmentGroup | SegmentGroup[]][] =
+		[];
+	// cache incoming ops that arrive when partial loading
+	private deferIncomingOps = true;
+	private readonly loadedDeferredIncomingOps: ISequencedDocumentMessage[] = [];
+
+	private messagesSinceMSNChange: ISequencedDocumentMessage[] = [];
+	private readonly intervalCollections: DefaultMap<IntervalCollection<SequenceInterval>>;
+	constructor(
+		private readonly dataStoreRuntime: IFluidDataStoreRuntime,
+		public id: string,
+		attributes: IChannelAttributes,
+		public readonly segmentFromSpec: (spec: IJSONSegment) => ISegment,
+	) {
+		super(id, dataStoreRuntime, attributes, "fluid_sequence_");
+
+		this.guardReentrancy =
+			dataStoreRuntime.options.sharedStringPreventReentrancy ?? true
+				? ensureNoReentrancy
+				: createReentrancyDetector((depth) => {
+						if (totalReentrancyLogs > 0) {
+							totalReentrancyLogs--;
+							this.logger.sendTelemetryEvent(
+								{ eventName: "LocalOpReentry", depth },
+								new LoggingError(reentrancyErrorMessage),
+							);
+						}
+				  });
+
+		this.loadedDeferred.promise.catch((error) => {
+			this.logger.sendErrorEvent({ eventName: "SequenceLoadFailed" }, error);
+		});
+
+		// eslint-disable-next-line import/no-deprecated
+		this.client = new Client(
+			segmentFromSpec,
+			createChildLogger({
+				logger: this.logger,
+				namespace: "SharedSegmentSequence.MergeTreeClient",
+			}),
+			dataStoreRuntime.options,
+		);
+
+		this.client.prependListener("delta", (opArgs, deltaArgs) => {
+			const event = new SequenceDeltaEvent(opArgs, deltaArgs, this.client);
+			if (opArgs.stashed !== true && event.isLocal) {
+				this.submitSequenceMessage(opArgs.op);
+			}
+			this.emit("sequenceDelta", event, this);
+		});
+
+		this.client.on("maintenance", (args, opArgs) => {
+			this.emit("maintenance", new SequenceMaintenanceEvent(opArgs, args, this.client), this);
+		});
+
+		this.intervalCollections = new DefaultMap(
+			this.serializer,
+			this.handle,
+			(op, localOpMetadata) => this.submitLocalMessage(op, localOpMetadata),
+			new SequenceIntervalCollectionValueType(),
+			dataStoreRuntime.options,
+		);
+	}
+
+	/**
+	 * @param start - The inclusive start of the range to remove
+	 * @param end - The exclusive end of the range to remove
+	 */
+	public removeRange(start: number, end: number): void {
+		this.guardReentrancy(() => this.client.removeRangeLocal(start, end));
+	}
+
+	/**
+	 * Obliterate is similar to remove, but differs in that segments concurrently
+	 * inserted into an obliterated range will also be removed
+	 *
+	 * @param start - The inclusive start of the range to obliterate
+	 * @param end - The exclusive end of the range to obliterate
+	 */
+	public obliterateRange(start: number, end: number): void {
+		this.guardReentrancy(() => this.client.obliterateRangeLocal(start, end));
+	}
+
+	/**
+	 * @deprecated The ability to create group ops will be removed in an upcoming
+	 * release, as group ops are redundant with the native batching capabilities
+	 * of the runtime
+	 */
+	public groupOperation(groupOp: IMergeTreeGroupMsg) {
+		this.guardReentrancy(() => this.client.localTransaction(groupOp));
+	}
+
+	/**
+	 * Finds the segment information (i.e. segment + offset) corresponding to a character position in the SharedString.
+	 * If the position is past the end of the string, `segment` and `offset` on the returned object may be undefined.
+	 * @param pos - Character position (index) into the current local view of the SharedString.
+	 */
+	public getContainingSegment(pos: number): {
+		segment: T | undefined;
+		offset: number | undefined;
+	} {
+		return this.client.getContainingSegment<T>(pos);
+	}
+
+	/**
+	 * Returns the length of the current sequence for the client
+	 */
+	public getLength() {
+		return this.client.getLength();
+	}
+
+	/**
+	 * Returns the current position of a segment, and -1 if the segment
+	 * does not exist in this sequence
+	 * @param segment - The segment to get the position of
+	 */
+	public getPosition(segment: ISegment): number {
+		return this.client.getPosition(segment);
+	}
+
+	/**
+	 * Annotates the range with the provided properties
+	 *
+	 * @param start - The inclusive start position of the range to annotate
+	 * @param end - The exclusive end position of the range to annotate
+	 * @param props - The properties to annotate the range with
+	 *
+	 */
+	public annotateRange(start: number, end: number, props: PropertySet): void {
+		this.guardReentrancy(() => this.client.annotateRangeLocal(start, end, props));
+	}
+
+	public getPropertiesAtPosition(pos: number) {
+		return this.client.getPropertiesAtPosition(pos);
+	}
+
+	public getRangeExtentsOfPosition(pos: number) {
+		return this.client.getRangeExtentsOfPosition(pos);
+	}
+
+	/**
+	 * Creates a `LocalReferencePosition` on this SharedString. If the refType does not include
+	 * ReferenceType.Transient, the returned reference will be added to the localRefs on the provided segment.
+	 * @param segment - Segment to add the local reference on
+	 * @param offset - Offset on the segment at which to place the local reference
+	 * @param refType - ReferenceType for the created local reference
+	 * @param properties - PropertySet to place on the created local reference
+	 */
+	public createLocalReferencePosition(
+		segment: T,
+		offset: number,
+		refType: ReferenceType,
+		properties: PropertySet | undefined,
+		slidingPreference?: SlidingPreference,
+		canSlideToEndpoint?: boolean,
+	): LocalReferencePosition {
+		return this.client.createLocalReferencePosition(
+			segment,
+			offset,
+			refType,
+			properties,
+			slidingPreference,
+			canSlideToEndpoint,
+		);
+	}
+
+	/**
+	 * Resolves a `ReferencePosition` into a character position using this client's perspective.
+	 */
+	public localReferencePositionToPosition(lref: ReferencePosition): number {
+		return this.client.localReferencePositionToPosition(lref);
+	}
+
+	/**
+	 * Removes a `LocalReferencePosition` from this SharedString.
+	 */
+	public removeLocalReferencePosition(lref: LocalReferencePosition) {
+		return this.client.removeLocalReferencePosition(lref);
+	}
+
+	/**
+	 * Resolves a remote client's position against the local sequence
+	 * and returns the remote client's position relative to the local
+	 * sequence. The client ref seq must be above the minimum sequence number
+	 * or the return value will be undefined.
+	 * Generally this method is used in conjunction with signals which provide
+	 * point in time values for the below parameters, and is useful for things
+	 * like displaying user position. It should not be used with persisted values
+	 * as persisted values will quickly become invalid as the remoteClientRefSeq
+	 * moves below the minimum sequence number
+	 * @param remoteClientPosition - The remote client's position to resolve
+	 * @param remoteClientRefSeq - The reference sequence number of the remote client
+	 * @param remoteClientId - The client id of the remote client
+	 */
+	public resolveRemoteClientPosition(
+		remoteClientPosition: number,
+		remoteClientRefSeq: number,
+		remoteClientId: string,
+	): number | undefined {
+		return this.client.resolveRemoteClientPosition(
+			remoteClientPosition,
+			remoteClientRefSeq,
+			remoteClientId,
+		);
+	}
+
+	private submitSequenceMessage(message: IMergeTreeOp) {
+		if (!this.isAttached()) {
+			return;
+		}
+		const translated = makeHandlesSerializable(message, this.serializer, this.handle);
+		const metadata = this.client.peekPendingSegmentGroups(
+			message.type === MergeTreeDeltaType.GROUP ? message.ops.length : 1,
+		);
+
+		// if loading isn't complete, we need to cache
+		// local ops until loading is complete, and then
+		// they will be present
+		if (!this.loadedDeferred.isCompleted) {
+			this.loadedDeferredOutgoingOps.push(metadata ? [translated, metadata] : translated);
+		} else {
+			this.submitLocalMessage(translated, metadata);
+		}
+	}
+
+	/**
+	 * Given a position specified relative to a marker id, lookup the marker
+	 * and convert the position to a character position.
+	 * @param relativePos - Id of marker (may be indirect) and whether position is before or after marker.
+	 */
+	public posFromRelativePos(relativePos: IRelativePosition) {
+		return this.client.posFromRelativePos(relativePos);
+	}
+
+	/**
+	 * Walk the underlying segments of the sequence.
+	 * The walked segments may extend beyond the range if the segments cross the
+	 * ranges start or end boundaries.
+	 *
+	 * Set split range to true to ensure only segments within the range are walked.
+	 *
+	 * @param handler - The function to handle each segment. Traversal ends if
+	 * this function returns true.
+	 * @param start - Optional. The start of range walk.
+	 * @param end - Optional. The end of range walk
+	 * @param accum - Optional. An object that will be passed to the handler for accumulation
+	 * @param splitRange - Optional. Splits boundary segments on the range boundaries
+	 */
+	public walkSegments<TClientData>(
+		handler: ISegmentAction<TClientData>,
+		start?: number,
+		end?: number,
+		accum?: TClientData,
+		splitRange: boolean = false,
+	): void {
+		this.client.walkSegments(handler, start, end, accum as TClientData, splitRange);
+	}
+
+	/**
+	 * @returns The most recent sequence number which has been acked by the server and processed by this
+	 * SharedSegmentSequence.
+	 */
+	public getCurrentSeq() {
+		return this.client.getCurrentSeq();
+	}
+
+	/**
+	 * Inserts a segment directly before a `ReferencePosition`.
+	 * @param refPos - The reference position to insert the segment at
+	 * @param segment - The segment to insert
+	 */
+	public insertAtReferencePosition(pos: ReferencePosition, segment: T): void {
+		this.guardReentrancy(() => this.client.insertAtReferencePositionLocal(pos, segment));
+	}
+	/**
+	 * Inserts a segment
+	 * @param start - The position to insert the segment at
+	 * @param spec - The segment to inserts spec
+	 */
+	public insertFromSpec(pos: number, spec: IJSONSegment): void {
+		const segment = this.segmentFromSpec(spec);
+		this.guardReentrancy(() => this.client.insertSegmentLocal(pos, segment));
+	}
+
+	/**
+	 * Retrieves the interval collection keyed on `label`. If no such interval collection exists,
+	 * creates one.
+	 */
+	public getIntervalCollection(label: string): IIntervalCollection<SequenceInterval> {
+		return this.intervalCollections.get(label);
+	}
+
+	/**
+	 * @returns An iterable object that enumerates the IntervalCollection labels.
+	 *
+	 * @example
+	 *
+	 * ```typescript
+	 * const iter = this.getIntervalCollectionKeys();
+	 * for (key of iter)
+	 *     const collection = this.getIntervalCollection(key);
+	 *     ...
+	 * ```
+	 */
+	public getIntervalCollectionLabels(): IterableIterator<string> {
+		return this.intervalCollections.keys();
+	}
+
+	/**
+	 * {@inheritDoc @fluidframework/shared-object-base#SharedObject.summarizeCore}
+	 */
+	protected summarizeCore(
+		serializer: IFluidSerializer,
+		telemetryContext?: ITelemetryContext,
+	): ISummaryTreeWithStats {
+		const builder = new SummaryTreeBuilder();
+
+		// conditionally write the interval collection blob
+		// only if it has entries
+		if (this.intervalCollections.size > 0) {
+			builder.addBlob(snapshotFileName, this.intervalCollections.serialize(serializer));
+		}
+
+		builder.addWithStats(contentPath, this.summarizeMergeTree(serializer));
+
+		return builder.getSummaryTree();
+	}
+
+	/**
+	 * Runs serializer over the GC data for this SharedMatrix.
+	 * All the IFluidHandle's represent routes to other objects.
+	 */
+	protected processGCDataCore(serializer: IFluidSerializer) {
+		if (this.intervalCollections.size > 0) {
+			this.intervalCollections.serialize(serializer);
+		}
+
+		this.client.serializeGCData(this.handle, serializer);
+	}
+
+	/**
+	 * Replace the range specified from start to end with the provided segment
+	 * This is done by inserting the segment at the end of the range, followed
+	 * by removing the contents of the range
+	 * For a zero or reverse range (start \>= end), insert at end do not remove anything
+	 * @param start - The start of the range to replace
+	 * @param end - The end of the range to replace
+	 * @param segment - The segment that will replace the range
+	 */
+	protected replaceRange(start: number, end: number, segment: ISegment): void {
+		// Insert at the max end of the range when start > end, but still remove the range later
+		const insertIndex: number = Math.max(start, end);
+
+		// Insert first, so local references can slide to the inserted seg if any
+		const insert = this.client.insertSegmentLocal(insertIndex, segment);
+		if (insert) {
+			if (start < end) {
+				this.client.removeRangeLocal(start, end);
+			}
+		}
+	}
+
+	/**
+	 * {@inheritDoc @fluidframework/shared-object-base#SharedObject.onConnect}
+	 */
+	protected onConnect() {
+		// Update merge tree collaboration information with new client ID and then resend pending ops
+		this.client.startOrUpdateCollaboration(this.runtime.clientId);
+	}
+
+	/**
+	 * {@inheritDoc @fluidframework/shared-object-base#SharedObject.onDisconnect}
+	 */
+	protected onDisconnect() {}
+
+	/**
+	 * {@inheritDoc @fluidframework/shared-object-base#SharedObject.reSubmitCore}
+	 */
+	protected reSubmitCore(content: any, localOpMetadata: unknown) {
+		if (
+			!this.intervalCollections.tryResubmitMessage(
+				content,
+				localOpMetadata as IMapMessageLocalMetadata,
+			)
+		) {
+			this.submitSequenceMessage(
+				this.client.regeneratePendingOp(
+					content as IMergeTreeOp,
+					localOpMetadata as SegmentGroup | SegmentGroup[],
+				),
+			);
+		}
+	}
+
+	/**
+	 * {@inheritDoc @fluidframework/shared-object-base#SharedObject.loadCore}
+	 */
+	protected async loadCore(storage: IChannelStorageService) {
+		if (await storage.contains(snapshotFileName)) {
+			const blob = await storage.readBlob(snapshotFileName);
+			const header = bufferToString(blob, "utf8");
+			this.intervalCollections.populate(header);
+		}
+
+		try {
+			// this will load the header, and return a promise
+			// that will resolve when the body is loaded
+			// and the catchup ops are available.
+			const { catchupOpsP } = await this.client.load(
+				this.runtime,
+				new ObjectStoragePartition(storage, contentPath),
+				this.serializer,
+			);
+
+			// setup a promise to process the
+			// catch up ops, and finishing the loading process
+			const loadCatchUpOps = catchupOpsP
+				.then((msgs) => {
+					msgs.forEach((m) => {
+						const collabWindow = this.client.getCollabWindow();
+						if (
+							m.minimumSequenceNumber < collabWindow.minSeq ||
+							m.referenceSequenceNumber < collabWindow.minSeq ||
+							m.sequenceNumber <= collabWindow.minSeq ||
+							// sequenceNumber could be the same if messages are part of a grouped batch
+							m.sequenceNumber < collabWindow.currentSeq
+						) {
+							throw new Error(
+								`Invalid catchup operations in snapshot: ${JSON.stringify({
+									op: {
+										seq: m.sequenceNumber,
+										minSeq: m.minimumSequenceNumber,
+										refSeq: m.referenceSequenceNumber,
+									},
+									collabWindow: {
+										seq: collabWindow.currentSeq,
+										minSeq: collabWindow.minSeq,
+									},
+								})}`,
+							);
+						}
+						this.processMergeTreeMsg(m);
+					});
+					this.loadFinished();
+				})
+				.catch((error) => {
+					this.loadFinished(error);
+				});
+			if (this.dataStoreRuntime.options?.sequenceInitializeFromHeaderOnly !== true) {
+				// if we not doing partial load, await the catch up ops,
+				// and the finalization of the load
+				await loadCatchUpOps;
+			}
+		} catch (error) {
+			this.loadFinished(error);
+		}
+	}
+
+	/**
+	 * {@inheritDoc @fluidframework/shared-object-base#SharedObject.processCore}
+	 */
+	protected processCore(
+		message: ISequencedDocumentMessage,
+		local: boolean,
+		localOpMetadata: unknown,
+	) {
+		// if loading isn't complete, we need to cache all
+		// incoming ops to be applied after loading is complete
+		if (this.deferIncomingOps) {
+			assert(!local, 0x072 /* "Unexpected local op when loading not finished" */);
+			this.loadedDeferredIncomingOps.push(message);
+		} else {
+			assert(
+				message.type === MessageType.Operation,
+				0x073 /* "Sequence message not operation" */,
+			);
+
+			const handled = this.intervalCollections.tryProcessMessage(
+				message.contents as IMapOperation,
+				local,
+				message,
+				localOpMetadata,
+			);
+
+			if (!handled) {
+				this.processMergeTreeMsg(message, local);
+			}
+		}
+	}
+
+	/**
+	 * {@inheritDoc @fluidframework/shared-object-base#SharedObject.didAttach}
+	 */
+	protected didAttach() {
+		// If we are not local, and we've attached we need to start generating and sending ops
+		// so start collaboration and provide a default client id incase we are not connected
+		if (this.isAttached()) {
+			this.client.startOrUpdateCollaboration(this.runtime.clientId ?? "attached");
+		}
+	}
+
+	/**
+	 * {@inheritDoc @fluidframework/shared-object-base#SharedObject.initializeLocalCore}
+	 */
+	protected initializeLocalCore() {
+		super.initializeLocalCore();
+		this.loadFinished();
+	}
+
+	/**
+	 * {@inheritDoc @fluidframework/shared-object-base#SharedObjectCore.applyStashedOp}
+	 */
+	protected applyStashedOp(content: any): unknown {
+		return this.client.applyStashedOp(parseHandles(content, this.serializer));
+	}
+
+	private summarizeMergeTree(serializer: IFluidSerializer): ISummaryTreeWithStats {
+		// Are we fully loaded? If not, things will go south
+		assert(
+			this.loadedDeferred.isCompleted,
+			0x074 /* "Snapshot called when not fully loaded" */,
+		);
+		const minSeq = this.runtime.deltaManager.minimumSequenceNumber;
+
+		this.processMinSequenceNumberChanged(minSeq);
+
+		this.messagesSinceMSNChange.forEach((m) => {
+			m.minimumSequenceNumber = minSeq;
+		});
+
+		return this.client.summarize(
+			this.runtime,
+			this.handle,
+			serializer,
+			this.messagesSinceMSNChange,
+		);
+	}
+
+	private processMergeTreeMsg(rawMessage: ISequencedDocumentMessage, local?: boolean) {
+		const message = parseHandles(rawMessage, this.serializer);
+
+		const ops: IMergeTreeDeltaOp[] = [];
+		function transformOps(event: SequenceDeltaEvent) {
+			ops.push(...SharedSegmentSequence.createOpsFromDelta(event));
+		}
+		const needsTransformation = message.referenceSequenceNumber !== message.sequenceNumber - 1;
+		let stashMessage: Readonly<ISequencedDocumentMessage> = message;
+		if (this.runtime.options?.newMergeTreeSnapshotFormat !== true) {
+			if (needsTransformation) {
+				this.on("sequenceDelta", transformOps);
+			}
+		}
+
+		this.client.applyMsg(message, local);
+
+		if (this.runtime.options?.newMergeTreeSnapshotFormat !== true) {
+			if (needsTransformation) {
+				this.removeListener("sequenceDelta", transformOps);
+				// shallow clone the message as we only overwrite top level properties,
+				// like referenceSequenceNumber and content only
+				stashMessage = {
+					...message,
+					referenceSequenceNumber: stashMessage.sequenceNumber - 1,
+					// eslint-disable-next-line import/no-deprecated
+					contents: ops.length !== 1 ? createGroupOp(...ops) : ops[0],
+				};
+			}
+
+			this.messagesSinceMSNChange.push(stashMessage);
+
+			// Do GC every once in a while...
+			if (
+				this.messagesSinceMSNChange.length > 20 &&
+				this.messagesSinceMSNChange[20].sequenceNumber < message.minimumSequenceNumber
+			) {
+				this.processMinSequenceNumberChanged(message.minimumSequenceNumber);
+			}
+		}
+	}
+
+	private processMinSequenceNumberChanged(minSeq: number) {
+		let index = 0;
+		for (; index < this.messagesSinceMSNChange.length; index++) {
+			if (this.messagesSinceMSNChange[index].sequenceNumber > minSeq) {
+				break;
+			}
+		}
+		if (index !== 0) {
+			this.messagesSinceMSNChange = this.messagesSinceMSNChange.slice(index);
+		}
+	}
+
+	private loadFinished(error?: any) {
+		if (!this.loadedDeferred.isCompleted) {
+			// Initialize the interval collections
+			this.initializeIntervalCollections();
+			if (error) {
+				this.loadedDeferred.reject(error);
+				throw error;
+			} else {
+				// it is important this series remains synchronous
+				// first we stop deferring incoming ops, and apply then all
+				this.deferIncomingOps = false;
+				for (const message of this.loadedDeferredIncomingOps) {
+					this.processCore(message, false, undefined);
+				}
+				this.loadedDeferredIncomingOps.length = 0;
+
+				// then resolve the loaded promise
+				// and resubmit all the outstanding ops, as the snapshot
+				// is fully loaded, and all outstanding ops are applied
+				this.loadedDeferred.resolve();
+
+				for (const [messageContent, opMetadata] of this.loadedDeferredOutgoingOps) {
+					this.reSubmitCore(messageContent, opMetadata);
+				}
+				this.loadedDeferredOutgoingOps.length = 0;
+			}
+		}
+	}
+
+	private initializeIntervalCollections() {
+		// Listen and initialize new SharedIntervalCollections
+		this.intervalCollections.eventEmitter.on(
+			"create",
+			({ key, previousValue }: IValueChanged, local: boolean) => {
+				const intervalCollection = this.intervalCollections.get(key);
+				if (!intervalCollection.attached) {
+					intervalCollection.attachGraph(this.client, key);
+				}
+				assert(
+					previousValue === undefined,
+					0x2c1 /* "Creating an interval collection that already exists?" */,
+				);
+				this.emit("createIntervalCollection", key, local, this);
+			},
+		);
+
+		// Initialize existing SharedIntervalCollections
+		for (const key of this.intervalCollections.keys()) {
+			const intervalCollection = this.intervalCollections.get(key);
+			intervalCollection.attachGraph(this.client, key);
+		}
+	}
+}
+
+function createReentrancyDetector(
+	onReentrancy: (depth: number) => void,
+): <T>(callback: () => T) => T {
+	let depth = 0;
+	function detectReentrancy<T>(callback: () => T): T {
+		if (depth > 0) {
+			onReentrancy(depth);
+		}
+		depth++;
+		try {
+			return callback();
+		} finally {
+			depth--;
+		}
+	}
+
+	return detectReentrancy;
 }
+
+/**
+ * Apps which generate reentrant behavior may do so at a high frequency.
+ * Logging even per-SharedSegmentSequence instance might be too noisy, and having a few logs from a session
+ * is likely enough.
+ */
+let totalReentrancyLogs = 3;
+
+/**
+ * Resets the reentrancy log counter. Test-only API.
+ */
+export function resetReentrancyLogCounter() {
+	totalReentrancyLogs = 3;
+}
+
+const reentrancyErrorMessage = "Reentrancy detected in sequence local ops";
+const ensureNoReentrancy = createReentrancyDetector(() => {
+	throw new LoggingError(reentrancyErrorMessage);
+});