@fluidframework/merge-tree 2.31.0 → 2.32.0

package/src/client.ts

@@ -32,6 +32,7 @@ import { LocalReferencePosition, SlidingPreference } from "./localReference.js";
 import {
 	MergeTree,
 	errorIfOptionNotTrue,
+	getSlideToSegoff,
 	isRemovedAndAcked,
 	type IMergeTreeOptionsInternal,
 } from "./mergeTree.js";
@@ -50,6 +51,8 @@ import {
 	SegmentGroup,
 	compareStrings,
 	isSegmentLeaf,
+	type ISegmentLeaf,
+	type ObliterateInfo,
 } from "./mergeTreeNodes.js";
 import {
 	createAdjustRangeOp,
@@ -103,6 +106,12 @@ import * as opstampUtils from "./stamps.js";
 type IMergeTreeDeltaRemoteOpArgs = Omit<IMergeTreeDeltaOpArgs, "sequencedMessage"> &
 	Required<Pick<IMergeTreeDeltaOpArgs, "sequencedMessage">>;
 
+interface RebasedObliterateEndpoint {
+	segment: ISegmentLeaf;
+	offset: number;
+	side: Side;
+}
+
 /**
  * A range [start, end)
  * @internal
@@ -783,14 +792,14 @@ export class Client extends TypedEventEmitter<IClientEvents> {
 	private ackPendingSegment(opArgs: IMergeTreeDeltaRemoteOpArgs): void {
 		if (opArgs.op.type === MergeTreeDeltaType.GROUP) {
 			for (const memberOp of opArgs.op.ops) {
-				this._mergeTree.ackPendingSegment({
+				this._mergeTree.ackOp({
 					groupOp: opArgs.op,
 					op: memberOp,
 					sequencedMessage: opArgs.sequencedMessage,
 				});
 			}
 		} else {
-			this._mergeTree.ackPendingSegment(opArgs);
+			this._mergeTree.ackOp(opArgs);
 		}
 	}
 
@@ -842,6 +851,83 @@ export class Client extends TypedEventEmitter<IClientEvents> {
 		return this._mergeTree.getPosition(segment, perspective);
 	}
 
+	/**
+	 * Rebases a sided local reference to the best fitting position in the current tree.
+	 */
+	private rebaseSidedLocalReference(
+		ref: LocalReferencePosition,
+		side: Side,
+		reconnectingPerspective: Perspective,
+		slidePreference: SlidingPreference,
+	): RebasedObliterateEndpoint {
+		const oldSegment = ref.getSegment();
+		const oldOffset = ref.getOffset();
+		assert(
+			oldSegment !== undefined && oldOffset !== undefined,
+			0xb61 /* Invalid old reference */,
+		);
+		const useNewSlidingBehavior = true;
+		// Destructuring segment + offset is convenient and segment is reassigned
+		// eslint-disable-next-line prefer-const
+		let { segment: newSegment, offset: newOffset } = getSlideToSegoff(
+			{ segment: oldSegment, offset: oldOffset },
+			slidePreference,
+			reconnectingPerspective,
+			useNewSlidingBehavior,
+		);
+
+		newSegment ??=
+			slidePreference === SlidingPreference.FORWARD
+				? this._mergeTree.endOfTree
+				: this._mergeTree.startOfTree;
+
+		assert(
+			isSegmentLeaf(newSegment) && newOffset !== undefined,
+			0xb62 /* Invalid new segment on rebase */,
+		);
+
+		const newSide: Side =
+			newSegment === oldSegment
+				? side
+				: // If the reference slid to a new position, the closest fit to the original position will be independent of
+					// the original side and "in the direction of where the reference was".
+					slidePreference === SlidingPreference.FORWARD
+					? Side.Before
+					: Side.After;
+
+		return { segment: newSegment, offset: newOffset, side: newSide };
+	}
+
+	private computeNewObliterateEndpoints(obliterateInfo: ObliterateInfo): {
+		start: RebasedObliterateEndpoint;
+		end: RebasedObliterateEndpoint;
+	} {
+		const { currentSeq, clientId } = this.getCollabWindow();
+		const reconnectingPerspective = new LocalReconnectingPerspective(
+			currentSeq,
+			clientId,
+			obliterateInfo.stamp.localSeq! - 1,
+		);
+
+		const newStart = this.rebaseSidedLocalReference(
+			obliterateInfo.start,
+			obliterateInfo.startSide,
+			reconnectingPerspective,
+			SlidingPreference.FORWARD,
+		);
+		const newEnd = this.rebaseSidedLocalReference(
+			obliterateInfo.end,
+			obliterateInfo.endSide,
+			reconnectingPerspective,
+			SlidingPreference.BACKWARD,
+		);
+
+		return {
+			start: newStart,
+			end: newEnd,
+		};
+	}
+
 	private resetPendingDeltaToOps(
 		resetOp: IMergeTreeDeltaOp,
 
@@ -853,20 +939,177 @@ export class Client extends TypedEventEmitter<IClientEvents> {
 			segmentGroup === NACKedSegmentGroup,
 			0x034 /* "Segment group not at head of pending rebase queue" */,
 		);
+		assert(
+			segmentGroup.localSeq !== undefined,
+			0x867 /* expected segment group localSeq to be defined */,
+		);
 		if (this.pendingRebase?.empty) {
 			this.pendingRebase = undefined;
 		}
 
-		// if this is an obliterate op, keep all segments in same segment group
+		if (
+			resetOp.type === MergeTreeDeltaType.OBLITERATE ||
+			resetOp.type === MergeTreeDeltaType.OBLITERATE_SIDED
+		) {
+			errorIfOptionNotTrue(this._mergeTree.options, "mergeTreeEnableObliterateReconnect");
 
-		const obliterateSegmentGroup: SegmentGroup = {
-			segments: [],
-			localSeq: segmentGroup.localSeq,
-			refSeq: this.getCollabWindow().currentSeq,
-			obliterateInfo: {
-				...segmentGroup.obliterateInfo!,
-			},
-		};
+			// sliceRemove reconnect logic is characteristically different from other ops (which can only apply to segments they originally saw).
+			// This is because the ranges that other ops apply to can be broken up by concurrent insertions, so even though setRemoves are originally
+			// applied to a contiguous set of segments, at resubmission time they may no longer be.
+			// On the other hand, the closest analog to a `sliceRemove` that we can submit is obtained by resolving the "closest" start and end points
+			// for that slice, updating the local obliterate metadata to reflect that slice, and submitting a single op.
+
+			const obliterateInfo: ObliterateInfo | undefined = segmentGroup.obliterateInfo;
+			assert(
+				obliterateInfo !== undefined,
+				0xb63 /* Resubmitting obliterate op without obliterate info in segment group */,
+			);
+			assert(
+				obliterateInfo.stamp.localSeq === segmentGroup.localSeq,
+				0xb64 /* Local seq mismatch */,
+			);
+
+			const cachedNewPositions = this.cachedObliterateRebases.get(
+				obliterateInfo.stamp.localSeq,
+			);
+			assert(
+				cachedNewPositions !== undefined,
+				0xb65 /* didn't compute new positions for obliterate on reconnect early enough */,
+			);
+			const {
+				start: { segment: newStartSegment, offset: newStartOffset, side: newStartSide },
+				end: { segment: newEndSegment, offset: newEndOffset, side: newEndSide },
+			} = cachedNewPositions;
+
+			const { currentSeq, clientId } = this.getCollabWindow();
+
+			if (newEndSegment.ordinal < newStartSegment.ordinal) {
+				for (const segment of segmentGroup.segments) {
+					assert(
+						isRemovedAndAcked(segment),
+						0xb66 /* On reconnect, obliterate applied to new segments even though original ones were not removed. */,
+					);
+					const lastRemove = segment.removes[segment.removes.length - 1];
+					assert(
+						lastRemove.type === "sliceRemove" && lastRemove.localSeq === segmentGroup.localSeq,
+						0xb67 /* Last remove should be the obliterate that is being resubmitted. */,
+					);
+					// The original obliterate affected this segment, but it has since been removed and overlapping removes
+					// are only possible when they are concurrent. We adjust the metadata on that segment now to reflect
+					// the fact that the obliterate no longer affects it.
+					segment.removes.pop();
+				}
+
+				this._mergeTree.rebaseObliterateTo(obliterateInfo, undefined);
+				return [];
+			}
+
+			assert(
+				obliterateInfo.tiebreakTrackingGroup !== undefined,
+				0xb68 /* Tiebreak tracking group missing */,
+			);
+
+			const newObliterate: ObliterateInfo = {
+				// Recreate the start position using the perspective that other clients will see.
+				// This may not be at the same position as the original reference, since the segment the original reference was on could have been removed.
+				start: this._mergeTree.createLocalReferencePosition(
+					newStartSegment,
+					newStartOffset,
+					ReferenceType.StayOnRemove,
+					undefined,
+				),
+				startSide: newStartSide,
+				end: this._mergeTree.createLocalReferencePosition(
+					newEndSegment,
+					newEndOffset,
+					ReferenceType.StayOnRemove,
+					undefined,
+				),
+				endSide: newEndSide,
+				refSeq: currentSeq,
+				// We reuse the localSeq from the original obliterate.
+				stamp: obliterateInfo.stamp,
+				segmentGroup: undefined,
+				tiebreakTrackingGroup: obliterateInfo.tiebreakTrackingGroup,
+			};
+			newObliterate.start.addProperties({ obliterate: newObliterate });
+			newObliterate.end.addProperties({ obliterate: newObliterate });
+			newObliterate.segmentGroup = {
+				segments: [],
+				localSeq: segmentGroup.localSeq,
+				refSeq: this.getCollabWindow().currentSeq,
+				obliterateInfo: newObliterate,
+			};
+
+			for (const segment of segmentGroup.segments) {
+				assert(
+					segment.segmentGroups?.remove(segmentGroup) === true,
+					0x035 /* "Segment group not in segment pending queue" */,
+				);
+				if (
+					(segment.ordinal > newStartSegment.ordinal &&
+						segment.ordinal < newEndSegment.ordinal) ||
+					(segment === newStartSegment && newStartSide === Side.Before) ||
+					(segment === newEndSegment && newEndSide === Side.After)
+				) {
+					segment.segmentGroups.enqueue(newObliterate.segmentGroup);
+				} else {
+					assert(
+						isRemovedAndAcked(segment),
+						0xb69 /* On reconnect, obliterate applied to new segments even though original ones were not removed. */,
+					);
+					const lastRemove = segment.removes[segment.removes.length - 1];
+					assert(
+						lastRemove.type === "sliceRemove" && lastRemove.localSeq === segmentGroup.localSeq,
+						0xb6a /* Last remove should be the obliterate that is being resubmitted. */,
+					);
+					// The original obliterate affected this segment, but it has since been removed and it's impossible to apply the
+					// local obliterate so that is so. We adjust the metadata on that segment now.
+					segment.removes.pop();
+				}
+			}
+
+			this._mergeTree.rebaseObliterateTo(obliterateInfo, newObliterate);
+			this._mergeTree.pendingSegments.push(newObliterate.segmentGroup);
+
+			const reconnectingPerspective = new LocalReconnectingPerspective(
+				currentSeq,
+				clientId,
+				obliterateInfo.stamp.localSeq - 1,
+			);
+
+			const newStartPos =
+				this._mergeTree.getPosition(newStartSegment, reconnectingPerspective) + newStartOffset;
+			const newEndPos =
+				this._mergeTree.getPosition(newEndSegment, reconnectingPerspective) + newEndOffset;
+			if (resetOp.type === MergeTreeDeltaType.OBLITERATE) {
+				assert(
+					newStartSide === Side.Before && newEndSide === Side.After,
+					0xb6b /* Non-sided obliterate should have start side before and end side after */,
+				);
+				// Use a non-sided obliterate op if the original op was non-sided. Some combinations of feature flags disallow sided obliterate ops
+				// but allow non-sided ones, and if we convert a non-sided op to a sided one on reconnect, we may cause errors.
+				return [
+					createObliterateRangeOp(
+						newStartPos,
+						newEndPos +
+							1 /* to make the end exclusive, see corresponding -1 in `createObliterateRangeOpSided` on converting non-sided to sided. */,
+					),
+				];
+			}
+			return [
+				createObliterateRangeOpSided(
+					{
+						pos: newStartPos,
+						side: newStartSide,
+					},
+					{
+						pos: newEndPos,
+						side: newEndSide,
+					},
+				),
+			];
+		}
 
 		const opList: IMergeTreeDeltaOp[] = [];
 		// We need to sort the segments by ordinal, as the segments are not sorted in the segment group.
@@ -879,11 +1122,7 @@ export class Client extends TypedEventEmitter<IClientEvents> {
 		)) {
 			assert(
 				segment.segmentGroups?.remove(segmentGroup) === true,
-				0x035 /* "Segment group not in segment pending queue" */,
-			);
-			assert(
-				segmentGroup.localSeq !== undefined,
-				0x867 /* expected segment group localSeq to be defined */,
+				0xb6c /* Segment group not in segment pending queue */,
 			);
 			const segmentPosition = this.findReconnectionPosition(segment, segmentGroup.localSeq);
 			let newOp: IMergeTreeDeltaOp | undefined;
@@ -966,44 +1205,18 @@ export class Client extends TypedEventEmitter<IClientEvents> {
 					}
 					break;
 				}
-				case MergeTreeDeltaType.OBLITERATE: {
-					errorIfOptionNotTrue(this._mergeTree.options, "mergeTreeEnableObliterateReconnect");
-					// Only bother resubmitting if nobody else has removed it in the meantime.
-					// When that happens, the first removal will have been acked.
-					if (isRemoved(segment) && opstampUtils.isLocal(segment.removes[0])) {
-						newOp = createObliterateRangeOp(
-							segmentPosition,
-							segmentPosition + segment.cachedLength,
-						);
-					}
-					break;
-				}
 				default: {
 					throw new Error(`Invalid op type`);
 				}
 			}
 
-			if (newOp && resetOp.type === MergeTreeDeltaType.OBLITERATE) {
-				segment.segmentGroups.enqueue(obliterateSegmentGroup);
-
-				const first = opList[0];
-
-				if (
-					!!first &&
-					first.pos2 !== undefined &&
-					first.type !== MergeTreeDeltaType.OBLITERATE_SIDED &&
-					newOp.type !== MergeTreeDeltaType.OBLITERATE_SIDED
-				) {
-					first.pos2 += newOp.pos2! - newOp.pos1!;
-				} else {
-					opList.push(newOp);
-				}
-			} else if (newOp) {
+			if (newOp) {
 				const newSegmentGroup: SegmentGroup = {
 					segments: [],
 					localSeq: segmentGroup.localSeq,
 					refSeq: this.getCollabWindow().currentSeq,
 				};
+
 				segment.segmentGroups.enqueue(newSegmentGroup);
 
 				this._mergeTree.pendingSegments.push(newSegmentGroup);
@@ -1012,13 +1225,6 @@ export class Client extends TypedEventEmitter<IClientEvents> {
 			}
 		}
 
-		if (
-			resetOp.type === MergeTreeDeltaType.OBLITERATE &&
-			obliterateSegmentGroup.segments.length > 0
-		) {
-			this._mergeTree.pendingSegments.push(obliterateSegmentGroup);
-		}
-
 		return opList;
 	}
 
@@ -1145,10 +1351,15 @@ export class Client extends TypedEventEmitter<IClientEvents> {
 		);
 	}
 
-	private lastNormalizationRefSeq = 0;
+	private lastNormalization: undefined | { refSeq: number; localRefSeq: number };
 
 	private pendingRebase: DoublyLinkedList<SegmentGroup> | undefined;
 
+	private readonly cachedObliterateRebases: Map<
+		number, // obliterateInfo.stamp.localSeq
+		{ start: RebasedObliterateEndpoint; end: RebasedObliterateEndpoint }
+	> = new Map();
+
 	/**
 	 * Given a pending operation and segment group, regenerate the op, so it
 	 * can be resubmitted
@@ -1179,11 +1390,31 @@ export class Client extends TypedEventEmitter<IClientEvents> {
 			this.pendingRebase = this._mergeTree.pendingSegments.splice(firstGroupNode);
 		}
 
-		const rebaseTo = this.getCollabWindow().currentSeq;
-		if (rebaseTo !== this.lastNormalizationRefSeq) {
+		const collabWindow = this.getCollabWindow();
+		if (
+			this.lastNormalization === undefined ||
+			collabWindow.currentSeq !== this.lastNormalization.refSeq ||
+			collabWindow.localSeq !== this.lastNormalization.localRefSeq
+		) {
+			// Compute obliterate endpoint destinations before segments are normalized.
+			// Segment normalization can affect what should be the semantically correct segments for the endpoints to be placed on.
+			this.cachedObliterateRebases.clear();
+			for (const group of [...this._mergeTree.pendingSegments, ...this.pendingRebase]) {
+				const { obliterateInfo } = group.data;
+				if (obliterateInfo !== undefined) {
+					const { start, end } = this.computeNewObliterateEndpoints(obliterateInfo);
+					const { localSeq } = obliterateInfo.stamp;
+					assert(localSeq !== undefined, 0xb6d /* Local seq must be defined */);
+					this.cachedObliterateRebases.set(localSeq, { start, end });
+				}
+			}
 			this.emit("normalize", this);
+
 			this._mergeTree.normalizeSegmentsOnRebase();
-			this.lastNormalizationRefSeq = rebaseTo;
+			this.lastNormalization = {
+				refSeq: collabWindow.currentSeq,
+				localRefSeq: collabWindow.localSeq,
+			};
 		}
 
 		const opList: IMergeTreeDeltaOp[] = [];

package/src/index.ts

@@ -141,5 +141,5 @@ export {
 	revertMergeTreeDeltaRevertibles,
 } from "./revertibles.js";
 export type { OperationStamp } from "./stamps.js";
-export type { Perspective } from "./perspective.js";
+export { createLocalReconnectingPerspective, type Perspective } from "./perspective.js";
 export type { IMergeTreeTextHelper } from "./MergeTreeTextHelper.js";