@fluidframework/sequence 2.43.0-343119 → 2.50.0-345060

package/src/intervalCollection.ts

@@ -7,16 +7,19 @@
 
 import { TypedEventEmitter } from "@fluid-internal/client-utils";
 import { IEvent } from "@fluidframework/core-interfaces";
-import { assert, unreachableCase } from "@fluidframework/core-utils/internal";
+import {
+	assert,
+	DoublyLinkedList,
+	unreachableCase,
+	type ListNode,
+} from "@fluidframework/core-utils/internal";
 import { ISequencedDocumentMessage } from "@fluidframework/driver-definitions/internal";
 import {
 	Client,
-	DetachedReferencePosition,
 	ISegment,
 	LocalReferencePosition,
 	PropertySet,
 	ReferenceType,
-	SlidingPreference,
 	getSlideToSegoff,
 	refTypeIncludesFlag,
 	reservedRangeLabelsKey,
@@ -25,8 +28,7 @@ import {
 	endpointPosAndSide,
 	type ISegmentInternal,
 	createLocalReconnectingPerspective,
-	DoublyLinkedList,
-	type ListNode,
+	SlidingPreference,
 } from "@fluidframework/merge-tree/internal";
 import { LoggingError, UsageError } from "@fluidframework/telemetry-utils/internal";
 import { v4 as uuid } from "uuid";
@@ -57,9 +59,7 @@ import {
 	SerializedIntervalDelta,
 	createPositionReferenceFromSegoff,
 	createSequenceInterval,
-	endReferenceSlidingPreference,
 	getSerializedProperties,
-	startReferenceSlidingPreference,
 } from "./intervals/index.js";
 
 export type ISerializedIntervalCollectionV1 = ISerializedInterval[];
@@ -70,7 +70,7 @@ export interface ISerializedIntervalCollectionV2 {
 	intervals: CompressedSerializedInterval[];
 }
 
-export function sidesFromStickiness(stickiness: IntervalStickiness) {
+function sidesFromStickiness(stickiness: IntervalStickiness) {
 	const startSide = (stickiness & IntervalStickiness.START) !== 0 ? Side.After : Side.Before;
 	const endSide = (stickiness & IntervalStickiness.END) !== 0 ? Side.Before : Side.After;
 
@@ -138,25 +138,6 @@ export function toOptionalSequencePlace(
 	return typeof pos === "number" && side !== undefined ? { pos, side } : pos;
 }
 
-export function computeStickinessFromSide(
-	startPos: number | "start" | "end" | undefined = -1,
-	startSide: Side = Side.Before,
-	endPos: number | "start" | "end" | undefined = -1,
-	endSide: Side = Side.Before,
-): IntervalStickiness {
-	let stickiness: IntervalStickiness = IntervalStickiness.NONE;
-
-	if (startSide === Side.After || startPos === "start") {
-		stickiness |= IntervalStickiness.START;
-	}
-
-	if (endSide === Side.Before || endPos === "end") {
-		stickiness |= IntervalStickiness.END;
-	}
-
-	return stickiness as IntervalStickiness;
-}
-
 export class LocalIntervalCollection {
 	public readonly overlappingIntervalsIndex: ISequenceOverlappingIntervalsIndex;
 	public readonly idIntervalIndex: IIdIntervalIndex;
@@ -721,25 +702,27 @@ function removeMetadataFromPendingChanges(
 ): IntervalMessageLocalMetadata {
 	const acked = (localOpMetadataNode as ListNode<IntervalMessageLocalMetadata>)?.remove()
 		?.data;
-	assert(acked !== undefined, "local change must exist");
+	assert(acked !== undefined, 0xbbe /* local change must exist */);
 	acked.endpointChangesNode?.remove();
 	return acked;
 }
 
 function clearEmptyPendingEntry(pendingChanges: PendingChanges, id: string) {
 	const pending = pendingChanges[id];
-	assert(pending !== undefined, "pending must exist for local process");
+	assert(pending !== undefined, 0xbbf /* pending must exist for local process */);
 	if (pending.local.empty) {
 		assert(
 			pending.endpointChanges?.empty !== false,
-			"endpointChanges must be empty if not pending changes",
+			0xbc0 /* endpointChanges must be empty if not pending changes */,
 		);
 		// eslint-disable-next-line @typescript-eslint/no-dynamic-delete
 		delete pendingChanges[id];
 	}
 }
 
-function hasEndpointChanges(serialized: SerializedIntervalDelta) {
+function hasEndpointChanges(
+	serialized: SerializedIntervalDelta,
+): serialized is ISerializedInterval {
 	return serialized.start !== undefined && serialized.end !== undefined;
 }
 
@@ -781,6 +764,7 @@ export class IntervalCollection
 			if (md.type === "add" || (md.type === "change" && hasEndpointChanges(op.value))) {
 				const endpointChanges = (pending.endpointChanges ??= new DoublyLinkedList());
 				md.endpointChangesNode = endpointChanges.push(md).last;
+				md.rebased = undefined;
 			}
 			submitDelta(op, pending.local.push(md).last);
 		};
@@ -887,7 +871,7 @@ export class IntervalCollection
 		const { opName, value } = op;
 		assert(
 			(local === false && localOpMetadata === undefined) || opName === localOpMetadata?.type,
-			"must be same type",
+			0xbc1 /* must be same type */,
 		);
 		switch (opName) {
 			case "add": {
@@ -924,6 +908,7 @@ export class IntervalCollection
 	public resubmitMessage(
 		op: IIntervalCollectionTypeOperationValue,
 		maybeMetadata: unknown,
+		squash: boolean,
 	): void {
 		const { opName, value } = op;
 
@@ -932,7 +917,7 @@ export class IntervalCollection
 		const rebasedValue =
 			localOpMetadata.endpointChangesNode === undefined
 				? value
-				: this.rebaseLocalInterval(localOpMetadata);
+				: this.rebaseLocalInterval(value, localOpMetadata, squash);
 
 		if (rebasedValue === undefined) {
 			const { id } = getSerializedProperties(value);
@@ -974,69 +959,69 @@ export class IntervalCollection
 		}
 	}
 
-	private rebasePositionWithSegmentSlide(
-		pos: number | "start" | "end",
-		seqNumberFrom: number,
+	private rebaseReferenceWithSegmentSlide(
+		ref: LocalReferencePosition,
 		localSeq: number,
-	): number | "start" | "end" | undefined {
+		squash: boolean,
+	): { segment: ISegment; offset: number } | undefined {
 		if (!this.client) {
 			throw new LoggingError("mergeTree client must exist");
 		}
 
-		if (pos === "start" || pos === "end") {
-			return pos;
-		}
-
 		const { clientId } = this.client.getCollabWindow();
-		const { segment, offset } =
-			this.client.getContainingSegment(
-				pos,
-				{
-					referenceSequenceNumber: seqNumberFrom,
-					clientId: this.client.getLongClientId(clientId),
-				},
-				localSeq,
-			) ?? {};
-
-		// if segment is undefined, it slid off the string
-		assert(segment !== undefined && offset !== undefined, 0x54e /* No segment found */);
+		const segment: ISegmentInternal | undefined = ref.getSegment();
+		if (segment?.endpointType) {
+			return { segment, offset: 0 };
+		}
+		const offset = ref.getOffset();
 
 		const segoff = getSlideToSegoff(
-			{ segment, offset },
-			undefined,
-			createLocalReconnectingPerspective(this.client.getCurrentSeq(), clientId, localSeq),
-			this.options.mergeTreeReferencesCanSlideToEndpoint,
+			segment === undefined ? undefined : { segment, offset },
+			ref.slidingPreference,
+			createLocalReconnectingPerspective(
+				this.client.getCurrentSeq(),
+				clientId,
+				localSeq,
+				squash,
+			),
+			ref.canSlideToEndpoint,
 		);
 
 		// case happens when rebasing op, but concurrently entire string has been deleted
-		if (segoff?.segment === undefined || segoff.offset === undefined) {
-			return DetachedReferencePosition;
+		if (segoff === undefined) {
+			if (ref.canSlideToEndpoint !== true) {
+				return undefined;
+			}
+			return {
+				segment:
+					ref.slidingPreference === SlidingPreference.FORWARD
+						? this.client.endOfTree
+						: this.client.startOfTree,
+				offset: 0,
+			};
 		}
-
-		assert(
-			offset !== undefined && 0 <= offset && offset < segment.cachedLength,
-			0x54f /* Invalid offset */,
-		);
-		return this.client.findReconnectionPosition(segoff.segment, localSeq) + segoff.offset;
+		return segoff;
 	}
 
 	private computeRebasedPositions(
 		localOpMetadata: IntervalAddLocalMetadata | IntervalChangeLocalMetadata,
-	): ISerializedInterval | SerializedIntervalDelta {
+		squash: boolean,
+	): Record<"start" | "end", { segment: ISegmentInternal; offset: number }> | "detached" {
 		assert(
 			this.client !== undefined,
 			0x550 /* Client should be defined when computing rebased position */,
 		);
-		const { localSeq, original } = localOpMetadata;
-		const rebased = { ...original };
-		const { start, end, sequenceNumber } = original;
-		if (start !== undefined) {
-			rebased.start = this.rebasePositionWithSegmentSlide(start, sequenceNumber, localSeq);
+
+		const { localSeq, interval } = localOpMetadata;
+		const start = this.rebaseReferenceWithSegmentSlide(interval.start, localSeq, squash);
+		if (start === undefined) {
+			return "detached";
 		}
-		if (end !== undefined) {
-			rebased.end = this.rebasePositionWithSegmentSlide(end, sequenceNumber, localSeq);
+		const end = this.rebaseReferenceWithSegmentSlide(interval.end, localSeq, squash);
+		if (end === undefined) {
+			return "detached";
 		}
-		return rebased;
+		return { start, end };
 	}
 
 	public attachGraph(client: Client, label: string) {
@@ -1051,11 +1036,11 @@ export class IntervalCollection
 		// Instantiate the local interval collection based on the saved intervals
 		this.client = client;
 		if (client) {
-			client.on("normalize", () => {
+			client.on("normalize", (squash) => {
 				for (const pending of Object.values(this.pending)) {
 					if (pending?.endpointChanges !== undefined) {
 						for (const local of pending.endpointChanges) {
-							local.data.rebased = this.computeRebasedPositions(local.data);
+							local.data.rebased = this.computeRebasedPositions(local.data, squash);
 						}
 					}
 				}
@@ -1216,7 +1201,7 @@ export class IntervalCollection
 					{
 						type: "add",
 						localSeq,
-						original: serializedInterval,
+						interval,
 					},
 				);
 			}
@@ -1345,7 +1330,7 @@ export class IntervalCollection
 					type: "change",
 					localSeq,
 					previous: interval.serialize(),
-					original: serializedInterval,
+					interval: newInterval ?? interval,
 				};
 
 				this.submitDelta(
@@ -1369,8 +1354,10 @@ export class IntervalCollection
 			}
 			if (newInterval) {
 				this.emitChange(newInterval, interval, true, false);
-				this.client?.removeLocalReferencePosition(interval.start);
-				this.client?.removeLocalReferencePosition(interval.end);
+				// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+				interval.start.properties!.interval = undefined;
+				// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+				interval.end.properties!.interval = undefined;
 			}
 			return newInterval;
 		}
@@ -1477,65 +1464,71 @@ export class IntervalCollection
 	 *
 	 */
 	public rebaseLocalInterval(
+		original: SerializedIntervalDelta,
 		localOpMetadata: IntervalAddLocalMetadata | IntervalChangeLocalMetadata,
+		squash: boolean,
 	): SerializedIntervalDelta | undefined {
-		const original = localOpMetadata.original;
-		if (!this.client) {
+		if (!this.client || !hasEndpointChanges(original)) {
 			// If there's no associated mergeTree client, the originally submitted op is still correct.
 			return original;
 		}
-		if (!this.attached) {
+		if (!this.attached || this.localCollection === undefined) {
 			throw new LoggingError("attachSequence must be called");
 		}
 
-		const { localSeq } = localOpMetadata;
-		const { intervalType, properties, stickiness, startSide, endSide } = original;
+		const { localSeq, interval } = localOpMetadata;
 		const { id } = getSerializedProperties(original);
-		const { start: startRebased, end: endRebased } = (localOpMetadata.rebased ??=
-			this.computeRebasedPositions(localOpMetadata));
-
-		const localInterval = this.localCollection?.idIntervalIndex.getIntervalById(id);
-
-		const rebased: SerializedIntervalDelta = {
-			start: startRebased,
-			end: endRebased,
-			intervalType,
-			sequenceNumber: this.client?.getCurrentSeq() ?? 0,
-			properties,
-			stickiness,
-			startSide,
-			endSide,
-		};
+		const rebasedEndpoint = (localOpMetadata.rebased ??= this.computeRebasedPositions(
+			localOpMetadata,
+			squash,
+		));
+		const localInterval = this.localCollection.idIntervalIndex.getIntervalById(id);
 
 		// if the interval slid off the string, rebase the op to be a noop and delete the interval.
-		if (
-			!this.options.mergeTreeReferencesCanSlideToEndpoint &&
-			(startRebased === DetachedReferencePosition || endRebased === DetachedReferencePosition)
-		) {
-			if (localInterval) {
+		if (rebasedEndpoint === "detached") {
+			if (
+				localInterval !== undefined &&
+				(localInterval === interval || localOpMetadata.type === "add")
+			) {
 				this.localCollection?.removeExistingInterval(localInterval);
 			}
 			return undefined;
 		}
 
-		if (localInterval !== undefined) {
-			// The rebased op may place this interval's endpoints on different segments. Calling `changeInterval` here
-			// updates the local client's state to be consistent with the emitted op.
-			this.localCollection?.changeInterval(
-				localInterval,
-				toOptionalSequencePlace(startRebased, startSide ?? Side.Before),
-				toOptionalSequencePlace(endRebased, endSide ?? Side.Before),
-				undefined,
-				localSeq,
-			);
+		const { start, end } = rebasedEndpoint;
+		if (
+			interval.start.getSegment() !== start.segment ||
+			interval.start.getOffset() !== start.offset ||
+			interval.end.getSegment() !== end.segment ||
+			interval.end.getOffset() !== end.offset
+		) {
+			if (localInterval === interval) {
+				this.localCollection.removeExistingInterval(localInterval);
+			}
+			const old = interval.clone();
+			interval.moveEndpointReferences(rebasedEndpoint);
+			if (localInterval === interval) {
+				this.localCollection.add(interval);
+				this.emitChange(interval, old, true, true);
+			}
+			this.client.removeLocalReferencePosition(old.start);
+			this.client.removeLocalReferencePosition(old.end);
 		}
 
-		return rebased;
+		return {
+			...original,
+			start:
+				start.segment.endpointType ??
+				this.client.findReconnectionPosition(start.segment, localSeq) + start.offset,
+			end:
+				end.segment.endpointType ??
+				this.client.findReconnectionPosition(end.segment, localSeq) + end.offset,
+			sequenceNumber: this.client?.getCurrentSeq() ?? 0,
+		};
 	}
 
 	private getSlideToSegment(
 		lref: LocalReferencePosition,
-		slidingPreference: SlidingPreference,
 	): { segment: ISegment; offset: number } | undefined {
 		if (!this.client) {
 			throw new LoggingError("client does not exist");
@@ -1553,9 +1546,9 @@ export class IntervalCollection
 		}
 		return getSlideToSegoff(
 			segoff,
-			slidingPreference,
+			lref.slidingPreference,
 			undefined,
-			this.options.mergeTreeReferencesCanSlideToEndpoint,
+			lref.canSlideToEndpoint,
 		);
 	}
 
@@ -1567,14 +1560,8 @@ export class IntervalCollection
 			return;
 		}
 
-		const newStart = this.getSlideToSegment(
-			interval.start,
-			startReferenceSlidingPreference(interval.stickiness),
-		);
-		const newEnd = this.getSlideToSegment(
-			interval.end,
-			endReferenceSlidingPreference(interval.stickiness),
-		);
+		const newStart = this.getSlideToSegment(interval.start);
+		const newEnd = this.getSlideToSegment(interval.end);
 
 		const id = interval.getIntervalId();
 		const hasPendingChange = this.hasPendingEndpointChanges(id);
@@ -1606,16 +1593,14 @@ export class IntervalCollection
 
 			if (needsStartUpdate) {
 				const props = interval.start.properties;
-				interval.start = createPositionReferenceFromSegoff(
-					this.client,
-					newStart,
-					interval.start.refType,
+				interval.start = createPositionReferenceFromSegoff({
+					client: this.client,
+					segoff: newStart,
+					refType: interval.start.refType,
 					op,
-					undefined,
-					undefined,
-					startReferenceSlidingPreference(interval.stickiness),
-					startReferenceSlidingPreference(interval.stickiness) === SlidingPreference.BACKWARD,
-				);
+					slidingPreference: interval.start.slidingPreference,
+					canSlideToEndpoint: interval.start.canSlideToEndpoint,
+				});
 				if (props) {
 					interval.start.addProperties(props);
 				}
@@ -1627,16 +1612,14 @@ export class IntervalCollection
 			}
 			if (needsEndUpdate) {
 				const props = interval.end.properties;
-				interval.end = createPositionReferenceFromSegoff(
-					this.client,
-					newEnd,
-					interval.end.refType,
+				interval.end = createPositionReferenceFromSegoff({
+					client: this.client,
+					segoff: newEnd,
+					refType: interval.end.refType,
 					op,
-					undefined,
-					undefined,
-					endReferenceSlidingPreference(interval.stickiness),
-					endReferenceSlidingPreference(interval.stickiness) === SlidingPreference.FORWARD,
-				);
+					slidingPreference: interval.end.slidingPreference,
+					canSlideToEndpoint: interval.end.canSlideToEndpoint,
+				});
 				if (props) {
 					interval.end.addProperties(props);
 				}

package/src/intervalCollectionMap.ts

@@ -188,12 +188,16 @@ export class IntervalCollectionMap {
 	 * also sent if we are asked to resubmit the message.
 	 * @returns True if the operation was submitted, false otherwise.
 	 */
-	public tryResubmitMessage(content: unknown, localOpMetadata: unknown): boolean {
+	public tryResubmitMessage(
+		content: unknown,
+		localOpMetadata: unknown,
+		squash: boolean,
+	): boolean {
 		if (isMapOperation(content)) {
 			const { value, key } = content;
 			const localValue = this.data.get(key);
 			assert(localValue !== undefined, 0x3f8 /* Local value expected on resubmission */);
-			localValue.resubmitMessage(value, localOpMetadata);
+			localValue.resubmitMessage(value, localOpMetadata, squash);
 			return true;
 		}
 		return false;

package/src/intervalCollectionMapInterfaces.ts

@@ -3,8 +3,9 @@
  * Licensed under the MIT License.
  */
 
+import type { ListNode } from "@fluidframework/core-utils/internal";
 import { ISequencedDocumentMessage } from "@fluidframework/driver-definitions/internal";
-import { IMergeTreeOptions, ListNode } from "@fluidframework/merge-tree/internal";
+import { IMergeTreeOptions, type ISegmentInternal } from "@fluidframework/merge-tree/internal";
 
 import type {
 	IntervalCollection,
@@ -15,28 +16,34 @@ import {
 	ISerializedInterval,
 	IntervalDeltaOpType,
 	SerializedIntervalDelta,
+	type SequenceIntervalClass,
 } from "./intervals/index.js";
 
 export interface IntervalAddLocalMetadata {
 	type: typeof IntervalDeltaOpType.ADD;
 	localSeq: number;
 	endpointChangesNode?: ListNode<IntervalAddLocalMetadata | IntervalChangeLocalMetadata>;
-	rebased?: ISerializedInterval;
-	original: ISerializedInterval;
+	rebased?:
+		| Record<"start" | "end", { segment: ISegmentInternal; offset: number }>
+		| "detached";
+	interval: SequenceIntervalClass;
 }
 export interface IntervalChangeLocalMetadata {
 	type: typeof IntervalDeltaOpType.CHANGE;
 	localSeq: number;
 	previous: ISerializedInterval;
 	endpointChangesNode?: ListNode<IntervalChangeLocalMetadata | IntervalChangeLocalMetadata>;
-	rebased?: SerializedIntervalDelta;
-	original: SerializedIntervalDelta;
+	rebased?:
+		| Record<"start" | "end", { segment: ISegmentInternal; offset: number }>
+		| "detached";
+	interval: SequenceIntervalClass;
 }
 export interface IntervalDeleteLocalMetadata {
 	type: typeof IntervalDeltaOpType.DELETE;
 	localSeq: number;
 	previous: ISerializedInterval;
 	endpointChangesNode?: undefined;
+	interval?: undefined;
 }
 export type IntervalMessageLocalMetadata =
 	| IntervalAddLocalMetadata

package/src/intervals/intervalUtils.ts

@@ -57,7 +57,7 @@ export interface IInterval {
 		end: SequencePlace | undefined,
 		op?: ISequencedDocumentMessage,
 		localSeq?: number,
-		useNewSlidingBehavior?: boolean,
+		canSlideToEndpoint?: boolean,
 	): IInterval | undefined;
 	/**
 	 * @returns whether this interval overlaps with `b`.
@@ -264,8 +264,12 @@ export const IntervalStickiness = {
 export type IntervalStickiness = (typeof IntervalStickiness)[keyof typeof IntervalStickiness];
 
 export function startReferenceSlidingPreference(
-	stickiness: IntervalStickiness,
+	startPos: number | "start" | "end" | undefined,
+	startSide: Side,
+	endPos: number | "start" | "end" | undefined,
+	endSide: Side,
 ): SlidingPreference {
+	const stickiness = computeStickinessFromSide(startPos, startSide, endPos, endSide);
 	// if any start stickiness, prefer sliding backwards
 	return (stickiness & IntervalStickiness.START) === 0
 		? SlidingPreference.FORWARD
@@ -273,10 +277,34 @@ export function startReferenceSlidingPreference(
 }
 
 export function endReferenceSlidingPreference(
-	stickiness: IntervalStickiness,
+	startPos: number | "start" | "end" | undefined,
+	startSide: Side,
+	endPos: number | "start" | "end" | undefined,
+	endSide: Side,
 ): SlidingPreference {
+	const stickiness = computeStickinessFromSide(startPos, startSide, endPos, endSide);
+
 	// if any end stickiness, prefer sliding forwards
 	return (stickiness & IntervalStickiness.END) === 0
 		? SlidingPreference.BACKWARD
 		: SlidingPreference.FORWARD;
 }
+
+export function computeStickinessFromSide(
+	startPos: number | "start" | "end" | undefined,
+	startSide: Side,
+	endPos: number | "start" | "end" | undefined,
+	endSide: Side,
+): IntervalStickiness {
+	let stickiness: IntervalStickiness = IntervalStickiness.NONE;
+
+	if (startSide === Side.After || startPos === "start") {
+		stickiness |= IntervalStickiness.START;
+	}
+
+	if (endSide === Side.Before || endPos === "end") {
+		stickiness |= IntervalStickiness.END;
+	}
+
+	return stickiness as IntervalStickiness;
+}