@fluidframework/sequence 2.0.0-internal.6.4.0 → 2.0.0-internal.7.0.0

package/src/intervalCollection.ts

@@ -24,6 +24,7 @@ import {
 	UnassignedSequenceNumber,
 	DetachedReferencePosition,
 	UniversalSequenceNumber,
+	SlidingPreference,
 } from "@fluidframework/merge-tree";
 import { ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
 import { LoggingError, UsageError } from "@fluidframework/telemetry-utils";
@@ -64,6 +65,52 @@ import {
 	createIdIntervalIndex,
 } from "./intervalIndex";
 
+/**
+ * Defines a position and side relative to a character in a sequence.
+ *
+ * For this purpose, sequences look like:
+ *
+ * `{start} - {character 0} - {character 1} - ... - {character N} - {end}`
+ *
+ * Each `{value}` in the diagram is a character within a sequence.
+ * Each `-` in the above diagram is a position where text could be inserted.
+ * Each position between a `{value}` and a `-` is a `SequencePlace`.
+ *
+ * The special endpoints `{start}` and `{end}` refer to positions outside the
+ * contents of the string.
+ *
+ * This gives us 2N + 2 possible positions to refer to within a string, where N
+ * is the number of characters.
+ *
+ * If the position is specified with a bare number, the side defaults to
+ * `Side.Before`.
+ *
+ * If a SequencePlace is the endpoint of a range (e.g. start/end of an interval or search range),
+ * the Side value means it is exclusive if it is nearer to the other position and inclusive if it is farther.
+ * E.g. the start of a range with Side.After is exclusive of the character at the position.
+ */
+export type SequencePlace = number | "start" | "end" | InteriorSequencePlace;
+
+/**
+ * A sequence place that does not refer to the special endpoint segments.
+ *
+ * See {@link SequencePlace} for additional context.
+ */
+export interface InteriorSequencePlace {
+	pos: number;
+	side: Side;
+}
+
+/**
+ * Defines a side relative to a character in a sequence.
+ *
+ * @remarks See {@link SequencePlace} for additional context on usage.
+ */
+export enum Side {
+	Before = 0,
+	After = 1,
+}
+
 const reservedIntervalIdKey = "intervalId";
 
 export interface ISerializedIntervalCollectionV2 {
@@ -72,6 +119,13 @@ export interface ISerializedIntervalCollectionV2 {
 	intervals: CompressedSerializedInterval[];
 }
 
+export function sidesFromStickiness(stickiness: IntervalStickiness) {
+	const startSide = (stickiness & IntervalStickiness.START) !== 0 ? Side.After : Side.Before;
+	const endSide = (stickiness & IntervalStickiness.END) !== 0 ? Side.Before : Side.After;
+
+	return { startSide, endSide };
+}
+
 /**
  * Decompress an interval after loading a summary from JSON. The exact format
  * of this compression is unspecified and subject to change
@@ -80,13 +134,17 @@ function decompressInterval(
 	interval: CompressedSerializedInterval,
 	label?: string,
 ): ISerializedInterval {
+	const stickiness = interval[5] ?? IntervalStickiness.END;
+	const { startSide, endSide } = sidesFromStickiness(stickiness);
 	return {
 		start: interval[0],
 		end: interval[1],
 		sequenceNumber: interval[2],
 		intervalType: interval[3],
 		properties: { ...interval[4], [reservedRangeLabelsKey]: [label] },
-		stickiness: interval[5],
+		stickiness,
+		startSide,
+		endSide,
 	};
 }
 
@@ -97,7 +155,7 @@ function decompressInterval(
 function compressInterval(interval: ISerializedInterval): CompressedSerializedInterval {
 	const { start, end, sequenceNumber, intervalType, properties } = interval;
 
-	const base: CompressedSerializedInterval = [
+	let base: CompressedSerializedInterval = [
 		start,
 		end,
 		sequenceNumber,
@@ -108,18 +166,69 @@ function compressInterval(interval: ISerializedInterval): CompressedSerializedIn
 	];
 
 	if (interval.stickiness !== undefined && interval.stickiness !== IntervalStickiness.END) {
-		base.push(interval.stickiness);
+		// reassignment to make it easier for typescript to reason about types
+		base = [...base, interval.stickiness];
 	}
 
 	return base;
 }
 
+export function endpointPosAndSide(
+	start: SequencePlace | undefined,
+	end: SequencePlace | undefined,
+) {
+	const startIsPlainEndpoint = typeof start === "number" || start === "start" || start === "end";
+	const endIsPlainEndpoint = typeof end === "number" || end === "start" || end === "end";
+
+	const startSide = startIsPlainEndpoint ? Side.Before : start?.side;
+	const endSide = endIsPlainEndpoint ? Side.Before : end?.side;
+
+	const startPos = startIsPlainEndpoint ? start : start?.pos;
+	const endPos = endIsPlainEndpoint ? end : end?.pos;
+
+	return {
+		startSide,
+		endSide,
+		startPos,
+		endPos,
+	};
+}
+
+function toSequencePlace(pos: number | "start" | "end", side: Side): SequencePlace {
+	return typeof pos === "number" ? { pos, side } : pos;
+}
+
+function toOptionalSequencePlace(
+	pos: number | "start" | "end" | undefined,
+	side: Side = Side.Before,
+): SequencePlace | undefined {
+	return typeof pos === "number" ? { 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 function createIntervalIndex() {
 	const helpers: IIntervalHelpers<Interval> = {
-		compareEnds: (a: Interval, b: Interval) => a.end - b.end,
 		create: createInterval,
 	};
-	const lc = new LocalIntervalCollection<Interval>(undefined as any as Client, "", helpers);
+	const lc = new LocalIntervalCollection<Interval>(undefined as any as Client, "", helpers, {});
 	return lc;
 }
 
@@ -134,6 +243,7 @@ export class LocalIntervalCollection<TInterval extends ISerializableInterval> {
 		private readonly client: Client,
 		private readonly label: string,
 		private readonly helpers: IIntervalHelpers<TInterval>,
+		private readonly options: Partial<SequenceOptions>,
 		/** Callback invoked each time one of the endpoints of an interval slides. */
 		private readonly onPositionChange?: (
 			interval: TInterval,
@@ -150,7 +260,7 @@ export class LocalIntervalCollection<TInterval extends ISerializableInterval> {
 		]);
 	}
 
-	public createLegacyId(start: number, end: number): string {
+	public createLegacyId(start: number | "start" | "end", end: number | "start" | "end"): string {
 		// Create a non-unique ID based on start and end to be used on intervals that come from legacy clients
 		// without ID's.
 		return `${LocalIntervalCollection.legacyIdPrefix}${start}-${end}`;
@@ -205,11 +315,10 @@ export class LocalIntervalCollection<TInterval extends ISerializableInterval> {
 	}
 
 	public createInterval(
-		start: number,
-		end: number,
+		start: SequencePlace,
+		end: SequencePlace,
 		intervalType: IntervalType,
 		op?: ISequencedDocumentMessage,
-		stickiness: IntervalStickiness = IntervalStickiness.END,
 	): TInterval {
 		return this.helpers.create(
 			this.label,
@@ -219,19 +328,18 @@ export class LocalIntervalCollection<TInterval extends ISerializableInterval> {
 			intervalType,
 			op,
 			undefined,
-			stickiness,
+			this.options.mergeTreeReferencesCanSlideToEndpoint,
 		);
 	}
 
 	public addInterval(
-		start: number,
-		end: number,
+		start: SequencePlace,
+		end: SequencePlace,
 		intervalType: IntervalType,
 		props?: PropertySet,
 		op?: ISequencedDocumentMessage,
-		stickiness: IntervalStickiness = IntervalStickiness.END,
 	) {
-		const interval: TInterval = this.createInterval(start, end, intervalType, op, stickiness);
+		const interval: TInterval = this.createInterval(start, end, intervalType, op);
 		if (interval) {
 			if (!interval.properties) {
 				interval.properties = createMap<any>();
@@ -278,14 +386,19 @@ export class LocalIntervalCollection<TInterval extends ISerializableInterval> {
 
 	public changeInterval(
 		interval: TInterval,
-		start: number | undefined,
-		end: number | undefined,
+		start: SequencePlace | undefined,
+		end: SequencePlace | undefined,
 		op?: ISequencedDocumentMessage,
 		localSeq?: number,
 	) {
-		const newInterval = interval.modify(this.label, start, end, op, localSeq) as
-			| TInterval
-			| undefined;
+		const newInterval = interval.modify(
+			this.label,
+			start,
+			end,
+			op,
+			localSeq,
+			this.options.mergeTreeReferencesCanSlideToEndpoint,
+		) as TInterval | undefined;
 		if (newInterval) {
 			this.removeExistingInterval(interval);
 			this.add(newInterval);
@@ -319,6 +432,7 @@ export class LocalIntervalCollection<TInterval extends ISerializableInterval> {
 				ReferenceType.Transient,
 				ref.properties,
 				ref.slidingPreference,
+				ref.canSlideToEndpoint,
 			);
 		};
 		if (interval instanceof SequenceInterval) {
@@ -412,7 +526,6 @@ class IntervalCollectionFactory implements IValueFactory<IntervalCollection<Inte
 		options?: Partial<SequenceOptions>,
 	): IntervalCollection<Interval> {
 		const helpers: IIntervalHelpers<Interval> = {
-			compareEnds: (a: Interval, b: Interval) => a.end - b.end,
 			create: createInterval,
 		};
 		const collection = new IntervalCollection<Interval>(helpers, false, emitter, raw, options);
@@ -633,21 +746,82 @@ export interface IIntervalCollection<TInterval extends ISerializableInterval>
 	getIntervalById(id: string): TInterval | undefined;
 	/**
 	 * Creates a new interval and add it to the collection.
-	 * @param start - interval start position (inclusive)
-	 * @param end - interval end position (exclusive)
-	 * @param intervalType - type of the interval. All intervals are SlideOnRemove. Intervals may not be Transient.
+	 * @param start - interval start position
+	 * @param end - interval end position
+	 * @param intervalType - type of the interval. All intervals are SlideOnRemove.
+	 * Intervals may not be Transient.
 	 * @param props - properties of the interval
-	 * @param stickiness - {@link (IntervalStickiness:type)} to apply to the added interval.
 	 * @returns The created interval
-	 * @remarks See documentation on {@link SequenceInterval} for comments on interval endpoint semantics: there are subtleties
-	 * with how the current half-open behavior is represented.
+	 * @remarks See documentation on {@link SequenceInterval} for comments on
+	 * interval endpoint semantics: there are subtleties with how the current
+	 * half-open behavior is represented.
+	 *
+	 * Note that intervals may behave unexpectedly if the entire contents
+	 * of the string are deleted. In this case, it is possible for one endpoint
+	 * of the interval to become detached, while the other remains on the string.
+	 *
+	 * By adjusting the `side` and `pos` values of the `start` and `end` parameters,
+	 * it is possible to control whether the interval expands to include content
+	 * inserted at its start or end.
+	 *
+	 *	See {@link SequencePlace} for more details on the model.
+	 *
+	 *	@example
+	 *
+	 *	Given the string "ABCD":
+	 *
+	 *```typescript
+	 *	// Refers to "BC". If any content is inserted before B or after C, this
+	 *	// interval will include that content
+	 *	//
+	 *	// Picture:
+	 *	// \{start\} - A[- B - C -]D - \{end\}
+	 *	// \{start\} - A - B - C - D - \{end\}
+	 *	collection.add(\{ pos: 0, side: Side.After \}, \{ pos: 3, side: Side.Before \}, IntervalType.SlideOnRemove);
+	 *	// Equivalent to specifying the same positions and Side.Before.
+	 *	// Refers to "ABC". Content inserted after C will be included in the
+	 *	// interval, but content inserted before A will not.
+	 *	// \{start\} -[A - B - C -]D - \{end\}
+	 *	// \{start\} - A - B - C - D - \{end\}
+	 *	collection.add(0, 3, IntervalType.SlideOnRemove);
+	 *```
+	 *
+	 * In the case of the first example, if text is deleted,
+	 *
+	 * ```typescript
+	 *	// Delete the character "B"
+	 *	string.removeRange(1, 2);
+	 * ```
+	 *
+	 * The start point of the interval will slide to the position immediately
+	 * before "C", and the same will be true.
+	 *
+	 * ```
+	 * \{start\} - A[- C -]D - \{end\}
+	 * ```
+	 *
+	 * In this case, text inserted immediately before "C" would be included in
+	 * the interval.
+	 *
+	 * ```typescript
+	 * string.insertText(1, "EFG");
+	 * ```
+	 *
+	 * With the string now being,
+	 *
+	 * ```
+	 * \{start\} - A[- E - F - G - C -]D - \{end\}
+	 * ```
+	 *
+	 * @privateRemarks TODO: ADO:5205 the above comment regarding behavior in
+	 * the case that the entire interval has been deleted should be resolved at
+	 * the same time as this ticket
 	 */
 	add(
-		start: number,
-		end: number,
+		start: SequencePlace,
+		end: SequencePlace,
 		intervalType: IntervalType,
 		props?: PropertySet,
-		stickiness?: IntervalStickiness,
 	): TInterval;
 	/**
 	 * Removes an interval from the collection.
@@ -665,11 +839,11 @@ export interface IIntervalCollection<TInterval extends ISerializableInterval>
 	/**
 	 * Changes the endpoints of an existing interval.
 	 * @param id - Id of the interval to change
-	 * @param start - New start value, if defined. `undefined` signifies this endpoint should be left unchanged.
-	 * @param end - New end value, if defined. `undefined` signifies this endpoint should be left unchanged.
+	 * @param start - New start value. This can be the existing position to keep it unchanged.
+	 * @param end - New end value. This can be the existing position to keep it unchanged.
 	 * @returns the interval that was changed, if it existed in the collection.
 	 */
-	change(id: string, start?: number, end?: number): TInterval | undefined;
+	change(id: string, start: SequencePlace, end: SequencePlace): TInterval | undefined;
 
 	attachDeserializer(onDeserialize: DeserializeCallback): void;
 	/**
@@ -812,13 +986,18 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
 	}
 
 	private rebasePositionWithSegmentSlide(
-		pos: number,
+		pos: number | "start" | "end",
 		seqNumberFrom: number,
 		localSeq: number,
-	): number | undefined {
+	): number | "start" | "end" | 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,
@@ -832,7 +1011,12 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
 		// if segment is undefined, it slid off the string
 		assert(segment !== undefined, 0x54e /* No segment found */);
 
-		const segoff = getSlideToSegoff({ segment, offset }) ?? segment;
+		const segoff =
+			getSlideToSegoff(
+				{ segment, offset },
+				undefined,
+				this.options.mergeTreeReferencesCanSlideToEndpoint,
+			) ?? segment;
 
 		// case happens when rebasing op, but concurrently entire string has been deleted
 		if (segoff.segment === undefined || segoff.offset === undefined) {
@@ -896,12 +1080,28 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
 			client,
 			label,
 			this.helpers,
+			this.options,
 			(interval, previousInterval) => this.emitChange(interval, previousInterval, true, true),
 		);
 		if (this.savedSerializedIntervals) {
 			for (const serializedInterval of this.savedSerializedIntervals) {
 				this.localCollection.ensureSerializedId(serializedInterval);
-				const { start, end, intervalType, properties, stickiness } = serializedInterval;
+				const {
+					start: startPos,
+					end: endPos,
+					intervalType,
+					properties,
+					startSide,
+					endSide,
+				} = serializedInterval;
+				const start =
+					typeof startPos === "number" && startSide !== undefined
+						? { pos: startPos, side: startSide }
+						: startPos;
+				const end =
+					typeof endPos === "number" && endSide !== undefined
+						? { pos: endPos, side: endSide }
+						: endPos;
 				const interval = this.helpers.create(
 					label,
 					start,
@@ -910,7 +1110,7 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
 					intervalType,
 					undefined,
 					true,
-					stickiness,
+					this.options.mergeTreeReferencesCanSlideToEndpoint,
 				);
 				if (properties) {
 					interval.addProperties(properties);
@@ -967,15 +1167,25 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
 		return this.localCollection.idIntervalIndex.getIntervalById(id);
 	}
 
+	private assertStickinessEnabled(start: SequencePlace, end: SequencePlace) {
+		if (
+			!(typeof start === "number" && typeof end === "number") &&
+			!this.options.intervalStickinessEnabled
+		) {
+			throw new UsageError(
+				"attempted to set interval stickiness without enabling `intervalStickinessEnabled` feature flag",
+			);
+		}
+	}
+
 	/**
 	 * {@inheritdoc IIntervalCollection.add}
 	 */
 	public add(
-		start: number,
-		end: number,
+		start: SequencePlace,
+		end: SequencePlace,
 		intervalType: IntervalType,
 		props?: PropertySet,
-		stickiness: IntervalStickiness = IntervalStickiness.END,
 	): TInterval {
 		if (!this.localCollection) {
 			throw new LoggingError("attach must be called prior to adding intervals");
@@ -983,19 +1193,26 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
 		if (intervalType & IntervalType.Transient) {
 			throw new LoggingError("Can not add transient intervals");
 		}
-		if (stickiness !== IntervalStickiness.END && !this.options.intervalStickinessEnabled) {
-			throw new UsageError(
-				"attempted to set interval stickiness without enabling `intervalStickinessEnabled` feature flag",
-			);
-		}
+
+		const { startSide, endSide, startPos, endPos } = endpointPosAndSide(start, end);
+
+		assert(
+			startPos !== undefined &&
+				endPos !== undefined &&
+				startSide !== undefined &&
+				endSide !== undefined,
+			0x793 /* start and end cannot be undefined because they were not passed in as undefined */,
+		);
+
+		const stickiness = computeStickinessFromSide(startPos, startSide, endPos, endSide);
+
+		this.assertStickinessEnabled(start, end);
 
 		const interval: TInterval = this.localCollection.addInterval(
-			start,
-			end,
+			toSequencePlace(startPos, startSide),
+			toSequencePlace(endPos, endSide),
 			intervalType,
 			props,
-			undefined,
-			stickiness,
 		);
 
 		if (interval) {
@@ -1003,13 +1220,15 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
 				setSlideOnRemove(interval.start);
 				setSlideOnRemove(interval.end);
 			}
-			const serializedInterval = {
-				end,
+			const serializedInterval: ISerializedInterval = {
+				start: startPos,
+				end: endPos,
 				intervalType,
 				properties: interval.properties,
 				sequenceNumber: this.client?.getCurrentSeq() ?? 0,
-				start,
 				stickiness,
+				startSide,
+				endSide,
 			};
 			const localSeq = this.getNextLocalSeq();
 			this.localSeqToSerializedInterval.set(localSeq, serializedInterval);
@@ -1110,7 +1329,7 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
 	/**
 	 * {@inheritdoc IIntervalCollection.change}
 	 */
-	public change(id: string, start?: number, end?: number): TInterval | undefined {
+	public change(id: string, start: SequencePlace, end: SequencePlace): TInterval | undefined {
 		if (!this.localCollection) {
 			throw new LoggingError("Attach must be called before accessing intervals");
 		}
@@ -1131,8 +1350,13 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
 				setSlideOnRemove(newInterval.end);
 			}
 			const serializedInterval: SerializedIntervalDelta = interval.serialize();
-			serializedInterval.start = start;
-			serializedInterval.end = end;
+			const { startPos, startSide, endPos, endSide } = endpointPosAndSide(start, end);
+			const stickiness = computeStickinessFromSide(startPos, startSide, endPos, endSide);
+			serializedInterval.start = startPos;
+			serializedInterval.end = endPos;
+			serializedInterval.startSide = startSide;
+			serializedInterval.endSide = endSide;
+			serializedInterval.stickiness = stickiness;
 			// Emit a property bag containing only the ID, as we don't intend for this op to change any properties.
 			serializedInterval.properties = {
 				[reservedIntervalIdKey]: interval.getIntervalId(),
@@ -1261,8 +1485,8 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
 		} else {
 			// If there are pending changes with this ID, don't apply the remote start/end change, as the local ack
 			// should be the winning change.
-			let start: number | undefined;
-			let end: number | undefined;
+			let start: number | "start" | "end" | undefined;
+			let end: number | "start" | "end" | undefined;
 			// Track pending start/end independently of one another.
 			if (!this.hasPendingChangeStart(id)) {
 				start = serializedInterval.start;
@@ -1276,7 +1500,12 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
 				// If changeInterval gives us a new interval, work with that one. Otherwise keep working with
 				// the one we originally found in the tree.
 				newInterval =
-					this.localCollection.changeInterval(interval, start, end, op) ?? interval;
+					this.localCollection.changeInterval(
+						interval,
+						toOptionalSequencePlace(start, serializedInterval.startSide),
+						toOptionalSequencePlace(end, serializedInterval.endSide),
+						op,
+					) ?? interval;
 			}
 			const deltaProps = newInterval.addProperties(newProps, true, op.sequenceNumber);
 			if (this.onDeserialize) {
@@ -1332,7 +1561,7 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
 			throw new LoggingError("attachSequence must be called");
 		}
 
-		const { intervalType, properties } = serializedInterval;
+		const { intervalType, properties, stickiness, startSide, endSide } = serializedInterval;
 
 		const { start: startRebased, end: endRebased } =
 			this.localSeqToRebasedInterval.get(localSeq) ?? this.computeRebasedPositions(localSeq);
@@ -1346,6 +1575,9 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
 			intervalType,
 			sequenceNumber: this.client?.getCurrentSeq() ?? 0,
 			properties,
+			stickiness,
+			startSide,
+			endSide,
 		};
 
 		if (
@@ -1377,8 +1609,8 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
 			// updates the local client's state to be consistent with the emitted op.
 			this.localCollection?.changeInterval(
 				localInterval,
-				startRebased,
-				endRebased,
+				toOptionalSequencePlace(startRebased, startSide),
+				toOptionalSequencePlace(endRebased, endSide),
 				undefined,
 				localSeq,
 			);
@@ -1397,7 +1629,11 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
 		if (segoff.segment?.localRefs?.has(lref) !== true) {
 			return undefined;
 		}
-		const newSegoff = getSlideToSegoff(segoff);
+		const newSegoff = getSlideToSegoff(
+			segoff,
+			undefined,
+			this.options.mergeTreeReferencesCanSlideToEndpoint,
+		);
 		const value: { segment: ISegment | undefined; offset: number | undefined } | undefined =
 			segoff.segment === newSegoff.segment && segoff.offset === newSegoff.offset
 				? undefined
@@ -1405,7 +1641,7 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
 		return value;
 	}
 
-	private ackInterval(interval: TInterval, op: ISequencedDocumentMessage) {
+	private ackInterval(interval: TInterval, op: ISequencedDocumentMessage): void {
 		// Only SequenceIntervals need potential sliding
 		if (!(interval instanceof SequenceInterval)) {
 			return;
@@ -1459,7 +1695,11 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
 					newStart,
 					interval.start.refType,
 					op,
+					undefined,
+					undefined,
 					startReferenceSlidingPreference(interval.stickiness),
+					startReferenceSlidingPreference(interval.stickiness) ===
+						SlidingPreference.BACKWARD,
 				);
 				if (props) {
 					interval.start.addProperties(props);
@@ -1477,7 +1717,11 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
 					newEnd,
 					interval.end.refType,
 					op,
+					undefined,
+					undefined,
 					endReferenceSlidingPreference(interval.stickiness),
+					endReferenceSlidingPreference(interval.stickiness) ===
+						SlidingPreference.FORWARD,
 				);
 				if (props) {
 					interval.end.addProperties(props);
@@ -1521,12 +1765,11 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
 		this.localCollection.ensureSerializedId(serializedInterval);
 
 		const interval: TInterval = this.localCollection.addInterval(
-			serializedInterval.start,
-			serializedInterval.end,
+			toSequencePlace(serializedInterval.start, serializedInterval.startSide ?? Side.Before),
+			toSequencePlace(serializedInterval.end, serializedInterval.endSide ?? Side.Before),
 			serializedInterval.intervalType,
 			serializedInterval.properties,
 			op,
-			serializedInterval.stickiness,
 		);
 
 		if (interval) {

package/src/intervalIndex/endpointInRangeIndex.ts

@@ -39,7 +39,7 @@ export class EndpointInRangeIndex<TInterval extends ISerializableInterval>
 		private readonly helpers: IIntervalHelpers<TInterval>,
 	) {
 		this.intervalTree = new RedBlackTree<TInterval, TInterval>((a: TInterval, b: TInterval) => {
-			const compareEndsResult = helpers.compareEnds(a, b);
+			const compareEndsResult = a.compareEnd(b);
 			if (compareEndsResult !== 0) {
 				return compareEndsResult;
 			}

package/src/intervalIndex/endpointIndex.ts

@@ -39,8 +39,7 @@ export class EndpointIndex<TInterval extends ISerializableInterval>
 		private readonly client: Client,
 		private readonly helpers: IIntervalHelpers<TInterval>,
 	) {
-		// eslint-disable-next-line @typescript-eslint/unbound-method
-		this.endIntervalTree = new RedBlackTree<TInterval, TInterval>(helpers.compareEnds);
+		this.endIntervalTree = new RedBlackTree<TInterval, TInterval>((a, b) => a.compareEnd(b));
 	}
 
 	public previousInterval(pos: number): TInterval | undefined {