@fluidframework/sequence 2.0.0-dev-rc.1.0.0.228517 → 2.0.0-dev-rc.2.0.0.245554

package/src/intervalIndex/index.ts

@@ -3,23 +3,23 @@
  * Licensed under the MIT License.
  */
 
-export { IntervalIndex } from "./intervalIndex";
-export { IIdIntervalIndex, createIdIntervalIndex } from "./idIntervalIndex";
-export { IEndpointIndex, createEndpointIndex, EndpointIndex } from "./endpointIndex";
+export { IntervalIndex } from "./intervalIndex.js";
+export { IIdIntervalIndex, createIdIntervalIndex } from "./idIntervalIndex.js";
+export { IEndpointIndex, createEndpointIndex, EndpointIndex } from "./endpointIndex.js";
 export {
 	IEndpointInRangeIndex,
 	createEndpointInRangeIndex,
 	EndpointInRangeIndex,
-} from "./endpointInRangeIndex";
+} from "./endpointInRangeIndex.js";
 export {
 	IStartpointInRangeIndex,
 	createStartpointInRangeIndex,
 	StartpointInRangeIndex,
-} from "./startpointInRangeIndex";
-export { SequenceIntervalIndexes } from "./sequenceIntervalIndexes";
+} from "./startpointInRangeIndex.js";
+export { SequenceIntervalIndexes } from "./sequenceIntervalIndexes.js";
 export {
 	IOverlappingIntervalsIndex,
 	createOverlappingIntervalsIndex,
 	OverlappingIntervalsIndex,
-} from "./overlappingIntervalsIndex";
-export { createOverlappingSequenceIntervalsIndex } from "./overlappingSequenceIntervalsIndex";
+} from "./overlappingIntervalsIndex.js";
+export { createOverlappingSequenceIntervalsIndex } from "./overlappingSequenceIntervalsIndex.js";

package/src/intervalIndex/intervalIndex.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { ISerializableInterval } from "../intervals";
+import { ISerializableInterval } from "../intervals/index.js";
 
 /**
  * Collection of intervals.

package/src/intervalIndex/overlappingIntervalsIndex.ts

@@ -11,14 +11,14 @@ import {
 	ISerializableInterval,
 	sequenceIntervalHelpers,
 	SequenceInterval,
-} from "../intervals";
-import { IntervalNode, IntervalTree } from "../intervalTree";
-import { SharedString } from "../sharedString";
-import { SequencePlace, endpointPosAndSide } from "../intervalCollection";
-import { IntervalIndex } from "./intervalIndex";
+} from "../intervals/index.js";
+import { IntervalNode, IntervalTree } from "../intervalTree.js";
+import { SharedString } from "../sharedString.js";
+import { SequencePlace, endpointPosAndSide } from "../intervalCollection.js";
+import { IntervalIndex } from "./intervalIndex.js";
 
 /**
- * @internal
+ * @alpha
  */
 export interface IOverlappingIntervalsIndex<TInterval extends ISerializableInterval>
 	extends IntervalIndex<TInterval> {
@@ -39,9 +39,6 @@ export interface IOverlappingIntervalsIndex<TInterval extends ISerializableInter
 	): void;
 }
 
-/**
- * @public
- */
 export class OverlappingIntervalsIndex<TInterval extends ISerializableInterval>
 	implements IOverlappingIntervalsIndex<TInterval>
 {
@@ -150,7 +147,9 @@ export class OverlappingIntervalsIndex<TInterval extends ISerializableInterval>
 		if (
 			startPos === undefined ||
 			endPos === undefined ||
-			endPos < startPos ||
+			(typeof startPos === "number" && typeof endPos === "number" && endPos < startPos) ||
+			(startPos === "end" && endPos !== "end") ||
+			(startPos !== "start" && endPos === "start") ||
 			this.intervalTree.intervals.isEmpty()
 		) {
 			return [];
@@ -177,7 +176,7 @@ export class OverlappingIntervalsIndex<TInterval extends ISerializableInterval>
 }
 
 /**
- * @internal
+ * @alpha
  */
 export function createOverlappingIntervalsIndex(
 	sharedString: SharedString,

package/src/intervalIndex/overlappingSequenceIntervalsIndex.ts

@@ -16,10 +16,10 @@ import {
 	IntervalType,
 	SequenceInterval,
 	createPositionReferenceFromSegoff,
-} from "../intervals";
-import { SharedString } from "../sharedString";
-import { SequenceIntervalIndexes } from "./sequenceIntervalIndexes";
-import { OverlappingIntervalsIndex } from "./overlappingIntervalsIndex";
+} from "../intervals/index.js";
+import { SharedString } from "../sharedString.js";
+import { SequenceIntervalIndexes } from "./sequenceIntervalIndexes.js";
+import { OverlappingIntervalsIndex } from "./overlappingIntervalsIndex.js";
 
 /**
  * @public

package/src/intervalIndex/sequenceIntervalIndexes.ts

@@ -4,8 +4,8 @@
  */
 
 import { ISegment } from "@fluidframework/merge-tree";
-import { SequenceInterval } from "../intervals";
-import { IOverlappingIntervalsIndex } from "./overlappingIntervalsIndex";
+import { SequenceInterval } from "../intervals/index.js";
+import { IOverlappingIntervalsIndex } from "./overlappingIntervalsIndex.js";
 
 /**
  * This namespace contains specialiazations of indexes which support spatial queries

package/src/intervalIndex/startpointInRangeIndex.ts

@@ -11,10 +11,10 @@ import {
 	IntervalType,
 	SequenceInterval,
 	sequenceIntervalHelpers,
-} from "../intervals";
-import { SharedString } from "../sharedString";
-import { IntervalIndex } from "./intervalIndex";
-import { HasComparisonOverride, compareOverrideables, forceCompare } from "./intervalIndexUtils";
+} from "../intervals/index.js";
+import { SharedString } from "../sharedString.js";
+import { IntervalIndex } from "./intervalIndex.js";
+import { HasComparisonOverride, compareOverrideables, forceCompare } from "./intervalIndexUtils.js";
 
 /**
  * Collection of intervals.

package/src/intervalTree.ts

@@ -10,7 +10,7 @@ import {
 	RedBlackTree,
 	RBNodeActions,
 } from "@fluidframework/merge-tree";
-import { IInterval } from "./intervals";
+import { IInterval } from "./intervals/index.js";
 
 export interface AugmentedIntervalNode {
 	minmax: IInterval;

package/src/intervals/index.ts

@@ -16,11 +16,11 @@ export {
 	CompressedSerializedInterval,
 	endReferenceSlidingPreference,
 	startReferenceSlidingPreference,
-} from "./intervalUtils";
-export { Interval, createInterval, intervalHelpers } from "./interval";
+} from "./intervalUtils.js";
+export { Interval, createInterval, intervalHelpers } from "./interval.js";
 export {
 	SequenceInterval,
 	createSequenceInterval,
 	createPositionReferenceFromSegoff,
 	sequenceIntervalHelpers,
-} from "./sequenceInterval";
+} from "./sequenceInterval.js";

package/src/intervals/interval.ts

@@ -13,10 +13,8 @@ import {
 import { ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
 import { assert } from "@fluidframework/core-utils";
 import { UsageError } from "@fluidframework/telemetry-utils";
-import { SequencePlace } from "../intervalCollection";
-import { IIntervalHelpers, ISerializableInterval, ISerializedInterval } from "./intervalUtils";
-
-const reservedIntervalIdKey = "intervalId";
+import { SequencePlace, reservedIntervalIdKey } from "../intervalCollection.js";
+import { IIntervalHelpers, ISerializableInterval, ISerializedInterval } from "./intervalUtils.js";
 
 /**
  * Serializable interval whose endpoints are plain-old numbers.

package/src/intervals/intervalUtils.ts

@@ -12,7 +12,7 @@ import {
 	SlidingPreference,
 } from "@fluidframework/merge-tree";
 import { ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
-import { SequencePlace, Side } from "../intervalCollection";
+import { SequencePlace, Side } from "../intervalCollection.js";
 
 /**
  * Basic interval abstraction
@@ -81,7 +81,7 @@ export type IntervalDeltaOpType = (typeof IntervalDeltaOpType)[keyof typeof Inte
 
 /**
  * Values are used in revertibles.
- * @internal
+ * @alpha
  */
 export const IntervalOpType = {
 	...IntervalDeltaOpType,
@@ -89,7 +89,7 @@ export const IntervalOpType = {
 	POSITION_REMOVE: "positionRemove",
 } as const;
 /**
- * @internal
+ * @alpha
  */
 export type IntervalOpType = (typeof IntervalOpType)[keyof typeof IntervalOpType];
 

package/src/intervals/sequenceInterval.ts

@@ -31,8 +31,9 @@ import {
 	Side,
 	computeStickinessFromSide,
 	endpointPosAndSide,
+	reservedIntervalIdKey,
 	sidesFromStickiness,
-} from "../intervalCollection";
+} from "../intervalCollection.js";
 import {
 	IIntervalHelpers,
 	ISerializableInterval,
@@ -41,9 +42,7 @@ import {
 	IntervalType,
 	endReferenceSlidingPreference,
 	startReferenceSlidingPreference,
-} from "./intervalUtils";
-
-const reservedIntervalIdKey = "intervalId";
+} from "./intervalUtils.js";
 
 function compareSides(sideA: Side, sideB: Side): number {
 	if (sideA === sideB) {

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/sequence";
-export const pkgVersion = "2.0.0-dev-rc.1.0.0.228517";
+export const pkgVersion = "2.0.0-dev-rc.2.0.0.245554";

package/src/revertibles.ts

@@ -23,14 +23,14 @@ import {
 	getSlideToSegoff,
 	SlidingPreference,
 } from "@fluidframework/merge-tree";
-import { InteriorSequencePlace, Side } from "./intervalCollection";
-import { IntervalOpType, SequenceInterval } from "./intervals";
-import { SharedString, SharedStringSegment } from "./sharedString";
-import { ISequenceDeltaRange, SequenceDeltaEvent } from "./sequenceDeltaEvent";
+import { InteriorSequencePlace, Side } from "./intervalCollection.js";
+import { IntervalOpType, SequenceInterval } from "./intervals/index.js";
+import { SharedString, SharedStringSegment } from "./sharedString.js";
+import { ISequenceDeltaRange, SequenceDeltaEvent } from "./sequenceDeltaEvent.js";
 
 /**
  * Data for undoing edits on SharedStrings and Intervals.
- * @internal
+ * @alpha
  */
 export type SharedStringRevertible = MergeTreeDeltaRevertible | IntervalRevertible;
 
@@ -38,7 +38,7 @@ const idMap = new Map<string, string>();
 
 /**
  * Data for undoing edits affecting Intervals.
- * @internal
+ * @alpha
  */
 export type IntervalRevertible =
 	| {
@@ -92,7 +92,7 @@ function getUpdatedId(intervalId: string): string {
 
 /**
  * Create revertibles for adding an interval
- * @internal
+ * @alpha
  */
 export function appendAddIntervalToRevertibles(
 	interval: SequenceInterval,
@@ -108,7 +108,7 @@ export function appendAddIntervalToRevertibles(
 
 /**
  * Create revertibles for deleting an interval
- * @internal
+ * @alpha
  */
 export function appendDeleteIntervalToRevertibles(
 	string: SharedString,
@@ -160,7 +160,7 @@ export function appendDeleteIntervalToRevertibles(
 
 /**
  * Create revertibles for moving endpoints of an interval
- * @internal
+ * @alpha
  */
 export function appendChangeIntervalToRevertibles(
 	string: SharedString,
@@ -210,7 +210,7 @@ export function appendChangeIntervalToRevertibles(
 
 /**
  * Create revertibles for changing properties of an interval
- * @internal
+ * @alpha
  */
 export function appendIntervalPropertyChangedToRevertibles(
 	interval: SequenceInterval,
@@ -270,7 +270,7 @@ function addIfRevertibleRef(
 /**
  * Create revertibles for SharedStringDeltas, handling indirectly modified intervals
  * (e.g. reverting remove of a range that contains an interval will move the interval back)
- * @internal
+ * @alpha
  */
 export function appendSharedStringDeltaToRevertibles(
 	string: SharedString,
@@ -363,7 +363,7 @@ export function appendSharedStringDeltaToRevertibles(
 
 /**
  * Clean up resources held by revertibles that are no longer needed.
- * @internal
+ * @alpha
  */
 export function discardSharedStringRevertibles(
 	sharedString: SharedString,
@@ -654,7 +654,7 @@ function revertLocalSequenceRemove(
 
 /**
  * Invoke revertibles to reverse prior edits
- * @internal
+ * @alpha
  */
 export function revertSharedStringRevertibles(
 	sharedString: SharedString,

package/src/sequence.ts

@@ -3,6 +3,7 @@
  * Licensed under the MIT License.
  */
 
+import Deque from "double-ended-queue";
 import { assert, Deferred } from "@fluidframework/core-utils";
 import { bufferToString } from "@fluid-internal/client-utils";
 import { LoggingError, createChildLogger } from "@fluidframework/telemetry-utils";
@@ -44,23 +45,17 @@ import {
 import { ObjectStoragePartition, SummaryTreeBuilder } from "@fluidframework/runtime-utils";
 import {
 	IFluidSerializer,
-	makeHandlesSerializable,
-	parseHandles,
 	SharedObject,
 	ISharedObjectEvents,
 } from "@fluidframework/shared-object-base";
 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 {
-	IIntervalCollection,
-	IntervalCollection,
-	SequenceIntervalCollectionValueType,
-} from "./intervalCollection";
-import { SequenceDeltaEvent, SequenceMaintenanceEvent } from "./sequenceDeltaEvent";
-import { ISharedIntervalCollection } from "./sharedIntervalCollection";
+import { IntervalCollectionMap, IMapOperation } from "./intervalCollectionMap.js";
+import { IMapMessageLocalMetadata, IValueChanged } from "./intervalCollectionMapInterfaces.js";
+import { SequenceInterval } from "./intervals/index.js";
+import { IIntervalCollection, SequenceIntervalCollectionValueType } from "./intervalCollection.js";
+import { SequenceDeltaEvent, SequenceMaintenanceEvent } from "./sequenceDeltaEvent.js";
+import { ISharedIntervalCollection } from "./sharedIntervalCollection.js";
 
 const snapshotFileName = "header";
 const contentPath = "content";
@@ -212,6 +207,40 @@ export abstract class SharedSegmentSequence<T extends ISegment>
 		return ops;
 	}
 
+	/**
+	 * Note: this field only provides a lower-bound on the reference sequence numbers for in-flight ops.
+	 * The exact reason isn't understood, but some e2e tests suggest that the runtime may sometimes process
+	 * incoming leave/join ops before putting an op that this DDS submits over the wire.
+	 *
+	 * E.g. SharedString submits an op while deltaManager has lastSequenceNumber = 10, but before the runtime
+	 * puts this op over the wire, it processes a client join/leave op with sequence number 11, so the referenceSequenceNumber
+	 * on the SharedString op is 11.
+	 *
+	 * The reference sequence numbers placed in this queue are also not accurate for stashed ops due to how the applyStashedOp
+	 * flow works at the runtime level. This is a legitimate bug, and AB#6602 tracks one way to fix it (stop reaching all the way
+	 * to deltaManager's lastSequenceNumber to obtain refSeq, instead leveraging some analogous notion on the container or datastore
+	 * runtime).
+	 */
+	private readonly inFlightRefSeqs = new Deque<number>();
+
+	private ongoingResubmitRefSeq: number | undefined;
+
+	/**
+	 * Gets the reference sequence number (i.e. sequence number of the runtime's last processed op) for an op submitted
+	 * in the current context.
+	 *
+	 * This value can be optionally overridden using `useResubmitRefSeq`.
+	 * IntervalCollection's resubmit logic currently relies on preserving merge information from when the op was originally submitted,
+	 * even if the op is resubmitted more than once. Thus during resubmit, `inFlightRefSeqs` gets populated with the
+	 * original refSeq rather than the refSeq at the time of reconnection.
+	 *
+	 * @remarks - In some not fully understood cases, the runtime may process incoming ops before putting an op that this
+	 * DDS submits over the wire. See `inFlightRefSeqs` for more details.
+	 */
+	private get currentRefSeq() {
+		return this.ongoingResubmitRefSeq ?? this.runtime.deltaManager.lastSequenceNumber;
+	}
+
 	// eslint-disable-next-line import/no-deprecated
 	protected client: Client;
 	/** `Deferred` that triggers once the object is loaded */
@@ -224,7 +253,7 @@ export abstract class SharedSegmentSequence<T extends ISegment>
 	private readonly loadedDeferredIncomingOps: ISequencedDocumentMessage[] = [];
 
 	private messagesSinceMSNChange: ISequencedDocumentMessage[] = [];
-	private readonly intervalCollections: DefaultMap<IntervalCollection<SequenceInterval>>;
+	private readonly intervalCollections: IntervalCollectionMap<SequenceInterval>;
 	constructor(
 		private readonly dataStoreRuntime: IFluidDataStoreRuntime,
 		public id: string,
@@ -233,6 +262,7 @@ export abstract class SharedSegmentSequence<T extends ISegment>
 	) {
 		super(id, dataStoreRuntime, attributes, "fluid_sequence_");
 
+		const getMinInFlightRefSeq = () => this.inFlightRefSeqs.get(0);
 		this.guardReentrancy =
 			dataStoreRuntime.options.sharedStringPreventReentrancy ?? true
 				? ensureNoReentrancy
@@ -258,11 +288,12 @@ export abstract class SharedSegmentSequence<T extends ISegment>
 				namespace: "SharedSegmentSequence.MergeTreeClient",
 			}),
 			dataStoreRuntime.options,
+			getMinInFlightRefSeq,
 		);
 
 		this.client.prependListener("delta", (opArgs, deltaArgs) => {
 			const event = new SequenceDeltaEvent(opArgs, deltaArgs, this.client);
-			if (opArgs.stashed !== true && event.isLocal) {
+			if (event.isLocal) {
 				this.submitSequenceMessage(opArgs.op);
 			}
 			this.emit("sequenceDelta", event, this);
@@ -272,10 +303,17 @@ export abstract class SharedSegmentSequence<T extends ISegment>
 			this.emit("maintenance", new SequenceMaintenanceEvent(opArgs, args, this.client), this);
 		});
 
-		this.intervalCollections = new DefaultMap(
+		this.intervalCollections = new IntervalCollectionMap(
 			this.serializer,
 			this.handle,
-			(op, localOpMetadata) => this.submitLocalMessage(op, localOpMetadata),
+			(op, localOpMetadata) => {
+				if (!this.isAttached()) {
+					return;
+				}
+
+				this.inFlightRefSeqs.push(this.currentRefSeq);
+				this.submitLocalMessage(op, localOpMetadata);
+			},
 			new SequenceIntervalCollectionValueType(),
 			dataStoreRuntime.options,
 		);
@@ -385,6 +423,11 @@ export abstract class SharedSegmentSequence<T extends ISegment>
 
 	/**
 	 * Resolves a `ReferencePosition` into a character position using this client's perspective.
+	 *
+	 * Reference positions that point to a character that has been removed will
+	 * always return the position of the nearest non-removed character, regardless
+	 * of `ReferenceType`. To handle this case specifically, one may wish
+	 * to look at the segment returned by `ReferencePosition.getSegment`.
 	 */
 	public localReferencePositionToPosition(lref: ReferencePosition): number {
 		return this.client.localReferencePositionToPosition(lref);
@@ -427,7 +470,9 @@ export abstract class SharedSegmentSequence<T extends ISegment>
 		if (!this.isAttached()) {
 			return;
 		}
-		const translated = makeHandlesSerializable(message, this.serializer, this.handle);
+
+		this.inFlightRefSeqs.push(this.currentRefSeq);
+
 		const metadata = this.client.peekPendingSegmentGroups(
 			message.type === MergeTreeDeltaType.GROUP ? message.ops.length : 1,
 		);
@@ -436,9 +481,9 @@ export abstract class SharedSegmentSequence<T extends ISegment>
 		// local ops until loading is complete, and then
 		// they will be present
 		if (!this.loadedDeferred.isCompleted) {
-			this.loadedDeferredOutgoingOps.push(metadata ? [translated, metadata] : translated);
+			this.loadedDeferredOutgoingOps.push(metadata ? [message, metadata] : (message as any));
 		} else {
-			this.submitLocalMessage(translated, metadata);
+			this.submitLocalMessage(message, metadata);
 		}
 	}
 
@@ -571,11 +616,12 @@ export abstract class SharedSegmentSequence<T extends ISegment>
 		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);
-			}
+		const insert = this.guardReentrancy(() =>
+			this.client.insertSegmentLocal(insertIndex, segment),
+		);
+
+		if (insert && start < end) {
+			this.removeRange(start, end);
 		}
 	}
 
@@ -596,19 +642,26 @@ export abstract class SharedSegmentSequence<T extends ISegment>
 	 * {@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[],
-				),
-			);
-		}
+		const originalRefSeq = this.inFlightRefSeqs.shift();
+		assert(
+			originalRefSeq !== undefined,
+			0x8bb /* Expected a recorded refSeq when resubmitting an op */,
+		);
+		this.useResubmitRefSeq(originalRefSeq, () => {
+			if (
+				!this.intervalCollections.tryResubmitMessage(
+					content,
+					localOpMetadata as IMapMessageLocalMetadata,
+				)
+			) {
+				this.submitSequenceMessage(
+					this.client.regeneratePendingOp(
+						content as IMergeTreeOp,
+						localOpMetadata as SegmentGroup | SegmentGroup[],
+					),
+				);
+			}
+		});
 	}
 
 	/**
@@ -665,7 +718,7 @@ export abstract class SharedSegmentSequence<T extends ISegment>
 				.catch((error) => {
 					this.loadFinished(error);
 				});
-			if (this.dataStoreRuntime.options?.sequenceInitializeFromHeaderOnly !== true) {
+			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;
@@ -683,6 +736,18 @@ export abstract class SharedSegmentSequence<T extends ISegment>
 		local: boolean,
 		localOpMetadata: unknown,
 	) {
+		if (local) {
+			const recordedRefSeq = this.inFlightRefSeqs.shift();
+			assert(recordedRefSeq !== undefined, 0x8bc /* No pending recorded refSeq found */);
+			// TODO: AB#7076: Some equivalent assert should be enabled. This fails some e2e stashed op tests because
+			// the deltaManager may have seen more messages than the runtime has processed while amidst the stashed op
+			// flow, so e.g. when `applyStashedOp` is called and the DDS is put in a state where it expects an ack for
+			// one of its messages, the delta manager has actually already seen subsequent messages from collaborators
+			// which the in-flight message is concurrent to.
+			// See "handles stashed ops created on top of sequenced local ops" for one such test case.
+			// assert(recordedRefSeq <= message.referenceSequenceNumber, "RefSeq mismatch");
+		}
+
 		// if loading isn't complete, we need to cache all
 		// incoming ops to be applied after loading is complete
 		if (this.deferIncomingOps) {
@@ -729,13 +794,10 @@ export abstract class SharedSegmentSequence<T extends ISegment>
 	/**
 	 * {@inheritDoc @fluidframework/shared-object-base#SharedObjectCore.applyStashedOp}
 	 */
-	protected applyStashedOp(content: any): unknown {
-		const parsedContent = parseHandles(content, this.serializer);
-		const metadata =
-			this.intervalCollections.tryGetStashedOpLocalMetadata(parsedContent) ??
-			this.client.applyStashedOp(parsedContent);
-		assert(!!metadata, 0x87d /* Metadata is undefined */);
-		return metadata;
+	protected applyStashedOp(content: any): void {
+		if (!this.intervalCollections.tryApplyStashedOp(content)) {
+			this.client.applyStashedOp(content);
+		}
 	}
 
 	private summarizeMergeTree(serializer: IFluidSerializer): ISummaryTreeWithStats {
@@ -760,16 +822,18 @@ export abstract class SharedSegmentSequence<T extends ISegment>
 		);
 	}
 
-	private processMergeTreeMsg(rawMessage: ISequencedDocumentMessage, local?: boolean) {
-		const message = parseHandles(rawMessage, this.serializer);
-
+	/**
+	 *
+	 * @param message - Message with decoded and hydrated handles
+	 */
+	private processMergeTreeMsg(message: ISequencedDocumentMessage, local?: boolean) {
 		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 (this.runtime.options.newMergeTreeSnapshotFormat !== true) {
 			if (needsTransformation) {
 				this.on("sequenceDelta", transformOps);
 			}
@@ -777,7 +841,7 @@ export abstract class SharedSegmentSequence<T extends ISegment>
 
 		this.client.applyMsg(message, local);
 
-		if (this.runtime.options?.newMergeTreeSnapshotFormat !== true) {
+		if (this.runtime.options.newMergeTreeSnapshotFormat !== true) {
 			if (needsTransformation) {
 				this.removeListener("sequenceDelta", transformOps);
 				// shallow clone the message as we only overwrite top level properties,
@@ -866,6 +930,20 @@ export abstract class SharedSegmentSequence<T extends ISegment>
 			intervalCollection.attachGraph(this.client, key);
 		}
 	}
+
+	/**
+	 * Overrides the "currently applicable reference sequence number" for the duration of the callback.
+	 * See remarks on `currentRefSeq` for more context.
+	 */
+	private useResubmitRefSeq(refSeq: number, callback: () => void) {
+		const previousResubmitRefSeq = this.ongoingResubmitRefSeq;
+		this.ongoingResubmitRefSeq = refSeq;
+		try {
+			callback();
+		} finally {
+			this.ongoingResubmitRefSeq = previousResubmitRefSeq;
+		}
+	}
 }
 
 function createReentrancyDetector(

package/src/sequenceFactory.ts

@@ -10,8 +10,8 @@ import {
 	IChannelFactory,
 } from "@fluidframework/datastore-definitions";
 import { Marker, TextSegment } from "@fluidframework/merge-tree";
-import { pkgVersion } from "./packageVersion";
-import { SharedString, SharedStringSegment } from "./sharedString";
+import { pkgVersion } from "./packageVersion.js";
+import { SharedString, SharedStringSegment } from "./sharedString.js";
 
 /**
  * @alpha
@@ -63,6 +63,9 @@ export class SharedStringFactory implements IChannelFactory {
 		return sharedString;
 	}
 
+	/**
+	 * {@inheritDoc @fluidframework/datastore-definitions#IChannelFactory.create}
+	 */
 	public create(document: IFluidDataStoreRuntime, id: string): SharedString {
 		const sharedString = new SharedString(document, id, this.attributes);
 		sharedString.initializeLocal();