@fluidframework/sequence 2.0.0-dev.4.4.0.162574 → 2.0.0-dev.5.2.0.169897

package/dist/intervalCollection.js

@@ -15,7 +15,7 @@ var __rest = (this && this.__rest) || function (s, e) {
     return t;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.intervalLocatorFromEndpoint = exports.IntervalCollection = exports.IntervalCollectionIterator = exports.makeOpsMap = exports.IntervalCollectionValueType = exports.SequenceIntervalCollectionValueType = exports.compareSequenceIntervalEnds = exports.LocalIntervalCollection = exports.createIntervalIndex = exports.createSequenceInterval = exports.SequenceInterval = exports.Interval = exports.IntervalType = void 0;
+exports.intervalLocatorFromEndpoint = exports.IntervalCollection = exports.makeOpsMap = exports.IntervalCollectionValueType = exports.SequenceIntervalCollectionValueType = exports.intervalHelpers = exports.sequenceIntervalHelpers = exports.compareSequenceIntervalStarts = exports.compareSequenceIntervalEnds = exports.LocalIntervalCollection = exports.createStartpointInRangeIndex = exports.createEndpointInRangeIndex = exports.createIntervalIndex = exports.createSequenceInterval = exports.SequenceInterval = exports.Interval = exports.IntervalStickiness = exports.IntervalType = exports.IntervalOpType = void 0;
 /* eslint-disable no-bitwise */
 const common_utils_1 = require("@fluidframework/common-utils");
 const container_utils_1 = require("@fluidframework/container-utils");
@@ -24,6 +24,17 @@ const telemetry_utils_1 = require("@fluidframework/telemetry-utils");
 const uuid_1 = require("uuid");
 const intervalTree_1 = require("./intervalTree");
 const reservedIntervalIdKey = "intervalId";
+/**
+ * Values are used in persisted formats (ops) and revertibles.
+ * @alpha
+ */
+exports.IntervalOpType = {
+    ADD: "add",
+    DELETE: "delete",
+    CHANGE: "change",
+    PROPERTY_CHANGED: "propertyChanged",
+    POSITION_REMOVE: "positionRemove",
+};
 var IntervalType;
 (function (IntervalType) {
     IntervalType[IntervalType["Simple"] = 0] = "Simple";
@@ -31,7 +42,7 @@ var IntervalType;
     /**
      * SlideOnRemove indicates that the ends of the interval will slide if the segment
      * they reference is removed and acked.
-     * See `packages\dds\merge-tree\REFERENCEPOSITIONS.md` for details
+     * See `packages\dds\merge-tree\docs\REFERENCEPOSITIONS.md` for details
      * SlideOnRemove is the default interval behavior and does not need to be specified.
      */
     IntervalType[IntervalType["SlideOnRemove"] = 2] = "SlideOnRemove";
@@ -52,6 +63,7 @@ function decompressInterval(interval, label) {
         sequenceNumber: interval[2],
         intervalType: interval[3],
         properties: Object.assign(Object.assign({}, interval[4]), { [merge_tree_1.reservedRangeLabelsKey]: [label] }),
+        stickiness: interval[5],
     };
 }
 /**
@@ -60,14 +72,57 @@ function decompressInterval(interval, label) {
  */
 function compressInterval(interval) {
     const { start, end, sequenceNumber, intervalType, properties } = interval;
-    return [
+    const base = [
         start,
         end,
         sequenceNumber,
         intervalType,
         Object.assign(Object.assign({}, properties), { [merge_tree_1.reservedRangeLabelsKey]: undefined }),
     ];
+    if (interval.stickiness !== undefined && interval.stickiness !== exports.IntervalStickiness.END) {
+        base.push(interval.stickiness);
+    }
+    return base;
+}
+function startReferenceSlidingPreference(stickiness) {
+    // if any start stickiness, prefer sliding backwards
+    return (stickiness & exports.IntervalStickiness.START) !== 0
+        ? merge_tree_1.SlidingPreference.BACKWARD
+        : merge_tree_1.SlidingPreference.FORWARD;
+}
+function endReferenceSlidingPreference(stickiness) {
+    // if any end stickiness, prefer sliding forwards
+    return (stickiness & exports.IntervalStickiness.END) !== 0
+        ? merge_tree_1.SlidingPreference.FORWARD
+        : merge_tree_1.SlidingPreference.BACKWARD;
 }
+/**
+ * Determines how an interval should expand when segments are inserted adjacent
+ * to the range it spans
+ *
+ * Note that interval stickiness is currently an experimental feature and must
+ * be explicitly enabled with the `intervalStickinessEnabled` flag
+ */
+exports.IntervalStickiness = {
+    /**
+     * Interval does not expand to include adjacent segments
+     */
+    NONE: 0b00,
+    /**
+     * Interval expands to include segments inserted adjacent to the start
+     */
+    START: 0b01,
+    /**
+     * Interval expands to include segments inserted adjacent to the end
+     *
+     * This is the default stickiness
+     */
+    END: 0b10,
+    /**
+     * Interval expands to include all segments inserted adjacent to it
+     */
+    FULL: 0b11,
+};
 /**
  * Serializable interval whose endpoints are plain-old numbers.
  */
@@ -101,7 +156,7 @@ class Interval {
      * Adds an auxiliary set of properties to this interval.
      * These properties can be recovered using `getAdditionalPropertySets`
      * @param props - set of properties to add
-     * @remarks - This gets called as part of the default conflict resolver for `IntervalCollection<Interval>`
+     * @remarks - This gets called as part of the default conflict resolver for `IIntervalCollection<Interval>`
      * (i.e. non-sequence-based interval collections). However, the additional properties don't get serialized.
      * This functionality seems half-baked.
      */
@@ -227,7 +282,7 @@ class Interval {
 }
 exports.Interval = Interval;
 /**
- * Interval impelmentation whose ends are associated with positions in a mutatable sequence.
+ * Interval implementation whose ends are associated with positions in a mutatable sequence.
  * As such, when content is inserted into the middle of the interval, the interval expands to
  * include that content.
  *
@@ -258,11 +313,12 @@ class SequenceInterval {
      * End endpoint of this interval.
      * @remarks - This endpoint can be resolved into a character position using the SharedString it's a part of.
      */
-    end, intervalType, props) {
+    end, intervalType, props, stickiness = exports.IntervalStickiness.END) {
         this.client = client;
         this.start = start;
         this.end = end;
         this.intervalType = intervalType;
+        this.stickiness = stickiness;
         this.propertyManager = new merge_tree_1.PropertiesManager();
         this.properties = {};
         if (props) {
@@ -314,13 +370,16 @@ class SequenceInterval {
         if (this.properties) {
             serializedInterval.properties = this.properties;
         }
+        if (this.stickiness !== exports.IntervalStickiness.END) {
+            serializedInterval.stickiness = this.stickiness;
+        }
         return serializedInterval;
     }
     /**
      * {@inheritDoc IInterval.clone}
      */
     clone() {
-        return new SequenceInterval(this.client, this.start, this.end, this.intervalType, this.properties);
+        return new SequenceInterval(this.client, this.start, this.end, this.intervalType, this.properties, this.stickiness);
     }
     /**
      * {@inheritDoc IInterval.compare}
@@ -404,7 +463,7 @@ class SequenceInterval {
      * {@inheritDoc IInterval.modify}
      * @deprecated - This API was never intended to be public and will be marked internal in a future release.
      */
-    modify(label, start, end, op, localSeq) {
+    modify(label, start, end, op, localSeq, stickiness = exports.IntervalStickiness.END) {
         const getRefType = (baseType) => {
             let refType = baseType;
             if (op === undefined) {
@@ -415,14 +474,14 @@ class SequenceInterval {
         };
         let startRef = this.start;
         if (start !== undefined) {
-            startRef = createPositionReference(this.client, start, getRefType(this.start.refType), op, undefined, localSeq);
+            startRef = createPositionReference(this.client, start, getRefType(this.start.refType), op, undefined, localSeq, startReferenceSlidingPreference(stickiness));
             if (this.start.properties) {
                 startRef.addProperties(this.start.properties);
             }
         }
         let endRef = this.end;
         if (end !== undefined) {
-            endRef = createPositionReference(this.client, end, getRefType(this.end.refType), op, undefined, localSeq);
+            endRef = createPositionReference(this.client, end, getRefType(this.end.refType), op, undefined, localSeq, endReferenceSlidingPreference(stickiness));
             if (this.end.properties) {
                 endRef.addProperties(this.end.properties);
             }
@@ -444,9 +503,9 @@ class SequenceInterval {
     }
 }
 exports.SequenceInterval = SequenceInterval;
-function createPositionReferenceFromSegoff(client, segoff, refType, op, localSeq, fromSnapshot) {
+function createPositionReferenceFromSegoff(client, segoff, refType, op, localSeq, fromSnapshot, slidingPreference) {
     if (segoff.segment) {
-        const ref = client.createLocalReferencePosition(segoff.segment, segoff.offset, refType, undefined);
+        const ref = client.createLocalReferencePosition(segoff.segment, segoff.offset, refType, undefined, slidingPreference);
         return ref;
     }
     // Creating references on detached segments is allowed for:
@@ -462,7 +521,7 @@ function createPositionReferenceFromSegoff(client, segoff, refType, op, localSeq
     }
     return (0, merge_tree_1.createDetachedLocalReferencePosition)(refType);
 }
-function createPositionReference(client, pos, refType, op, fromSnapshot, localSeq) {
+function createPositionReference(client, pos, refType, op, fromSnapshot, localSeq, slidingPreference) {
     let segoff;
     if (op) {
         (0, common_utils_1.assert)((refType & merge_tree_1.ReferenceType.SlideOnRemove) !== 0, 0x2f5 /* op create references must be SlideOnRemove */);
@@ -476,9 +535,9 @@ function createPositionReference(client, pos, refType, op, fromSnapshot, localSe
         (0, common_utils_1.assert)((refType & merge_tree_1.ReferenceType.SlideOnRemove) === 0 || !!fromSnapshot, 0x2f6 /* SlideOnRemove references must be op created */);
         segoff = client.getContainingSegment(pos, undefined, localSeq);
     }
-    return createPositionReferenceFromSegoff(client, segoff, refType, op, localSeq, fromSnapshot);
+    return createPositionReferenceFromSegoff(client, segoff, refType, op, localSeq, fromSnapshot, slidingPreference);
 }
-function createSequenceInterval(label, start, end, client, intervalType, op, fromSnapshot) {
+function createSequenceInterval(label, start, end, client, intervalType, op, fromSnapshot, stickiness = exports.IntervalStickiness.END) {
     let beginRefType = merge_tree_1.ReferenceType.RangeBegin;
     let endRefType = merge_tree_1.ReferenceType.RangeEnd;
     if (intervalType === IntervalType.Transient) {
@@ -502,14 +561,14 @@ function createSequenceInterval(label, start, end, client, intervalType, op, fro
             endRefType |= merge_tree_1.ReferenceType.StayOnRemove;
         }
     }
-    const startLref = createPositionReference(client, start, beginRefType, op, fromSnapshot);
-    const endLref = createPositionReference(client, end, endRefType, op, fromSnapshot);
+    const startLref = createPositionReference(client, start, beginRefType, op, fromSnapshot, undefined, startReferenceSlidingPreference(stickiness));
+    const endLref = createPositionReference(client, end, endRefType, op, fromSnapshot, undefined, endReferenceSlidingPreference(stickiness));
     const rangeProp = {
         [merge_tree_1.reservedRangeLabelsKey]: [label],
     };
     startLref.addProperties(rangeProp);
     endLref.addProperties(rangeProp);
-    const ival = new SequenceInterval(client, startLref, endLref, intervalType, rangeProp);
+    const ival = new SequenceInterval(client, startLref, endLref, intervalType, rangeProp, stickiness);
     return ival;
 }
 exports.createSequenceInterval = createSequenceInterval;
@@ -669,6 +728,119 @@ class EndpointIndex {
         this.endIntervalTree.remove(interval);
     }
 }
+/**
+ * Interface for intervals that have comparison override properties.
+ */
+const forceCompare = Symbol();
+/**
+ * Compares two objects based on their comparison override properties.
+ * @returns A number indicating the order of the intervals (negative for a is lower than b, 0 for tie, positive for a is greater than b).
+ */
+function compareOverrideables(a, b) {
+    var _a, _b;
+    const forceCompareA = (_a = a[forceCompare]) !== null && _a !== void 0 ? _a : 0;
+    const forceCompareB = (_b = b[forceCompare]) !== null && _b !== void 0 ? _b : 0;
+    return forceCompareA - forceCompareB;
+}
+class EndpointInRangeIndex {
+    constructor(helpers, client) {
+        this.helpers = helpers;
+        this.client = client;
+        this.intervalTree = new merge_tree_1.RedBlackTree((a, b) => {
+            const compareEndsResult = helpers.compareEnds(a, b);
+            if (compareEndsResult !== 0) {
+                return compareEndsResult;
+            }
+            const overrideablesComparison = compareOverrideables(a, b);
+            if (overrideablesComparison !== 0) {
+                return overrideablesComparison;
+            }
+            const aId = a.getIntervalId();
+            const bId = b.getIntervalId();
+            if (aId !== undefined && bId !== undefined) {
+                return aId.localeCompare(bId);
+            }
+            return 0;
+        });
+    }
+    add(interval) {
+        this.intervalTree.put(interval, interval);
+    }
+    remove(interval) {
+        this.intervalTree.remove(interval);
+    }
+    findIntervalsWithEndpointInRange(start, end) {
+        if (start <= 0 || start > end || this.intervalTree.isEmpty()) {
+            return [];
+        }
+        const results = [];
+        const action = (node) => {
+            results.push(node.data);
+            return true;
+        };
+        const transientStartInterval = this.helpers.create("transient", start, start, this.client, IntervalType.Transient);
+        const transientEndInterval = this.helpers.create("transient", end, end, this.client, IntervalType.Transient);
+        // Add comparison overrides to the transient intervals
+        transientStartInterval[forceCompare] = -1;
+        transientEndInterval[forceCompare] = 1;
+        this.intervalTree.mapRange(action, results, transientStartInterval, transientEndInterval);
+        return results;
+    }
+}
+class StartpointInRangeIndex {
+    constructor(helpers, client) {
+        this.helpers = helpers;
+        this.client = client;
+        this.intervalTree = new merge_tree_1.RedBlackTree((a, b) => {
+            (0, common_utils_1.assert)(typeof helpers.compareStarts === "function", 0x6d1 /* compareStarts does not exist in the helpers */);
+            const compareStartsResult = helpers.compareStarts(a, b);
+            if (compareStartsResult !== 0) {
+                return compareStartsResult;
+            }
+            const overrideablesComparison = compareOverrideables(a, b);
+            if (overrideablesComparison !== 0) {
+                return overrideablesComparison;
+            }
+            const aId = a.getIntervalId();
+            const bId = b.getIntervalId();
+            if (aId !== undefined && bId !== undefined) {
+                return aId.localeCompare(bId);
+            }
+            return 0;
+        });
+    }
+    add(interval) {
+        this.intervalTree.put(interval, interval);
+    }
+    remove(interval) {
+        this.intervalTree.remove(interval);
+    }
+    findIntervalsWithStartpointInRange(start, end) {
+        if (start <= 0 || start > end || this.intervalTree.isEmpty()) {
+            return [];
+        }
+        const results = [];
+        const action = (node) => {
+            results.push(node.data);
+            return true;
+        };
+        const transientStartInterval = this.helpers.create("transient", start, start, this.client, IntervalType.Transient);
+        const transientEndInterval = this.helpers.create("transient", end, end, this.client, IntervalType.Transient);
+        // Add comparison overrides to the transient intervals
+        transientStartInterval[forceCompare] = -1;
+        transientEndInterval[forceCompare] = 1;
+        this.intervalTree.mapRange(action, results, transientStartInterval, transientEndInterval);
+        return results;
+    }
+}
+function createEndpointInRangeIndex(helpers, client) {
+    return new EndpointInRangeIndex(helpers, client);
+}
+exports.createEndpointInRangeIndex = createEndpointInRangeIndex;
+function createStartpointInRangeIndex(helpers, client) {
+    return new StartpointInRangeIndex(helpers, client);
+}
+exports.createStartpointInRangeIndex = createStartpointInRangeIndex;
 class LocalIntervalCollection {
     constructor(client, label, helpers, 
     /** Callback invoked each time one of the endpoints of an interval slides. */
@@ -680,11 +852,11 @@ class LocalIntervalCollection {
         this.overlappingIntervalsIndex = new OverlappingIntervalsIndex(client, helpers);
         this.idIntervalIndex = new IdIntervalIndex();
         this.endIntervalIndex = new EndpointIndex(client, helpers);
-        this.indexes = [
+        this.indexes = new Set([
             this.overlappingIntervalsIndex,
             this.idIntervalIndex,
             this.endIntervalIndex,
-        ];
+        ]);
     }
     createLegacyId(start, end) {
         // Create a non-unique ID based on start and end to be used on intervals that come from legacy clients
@@ -724,17 +896,23 @@ class LocalIntervalCollection {
             index.remove(interval);
         }
     }
+    appendIndex(index) {
+        this.indexes.add(index);
+    }
+    removeIndex(index) {
+        return this.indexes.delete(index);
+    }
     removeExistingInterval(interval) {
         this.removeIntervalFromIndexes(interval);
         this.removeIntervalListeners(interval);
     }
-    createInterval(start, end, intervalType, op) {
-        return this.helpers.create(this.label, start, end, this.client, intervalType, op);
+    createInterval(start, end, intervalType, op, stickiness = exports.IntervalStickiness.END) {
+        return this.helpers.create(this.label, start, end, this.client, intervalType, op, undefined, stickiness);
     }
-    addInterval(start, end, intervalType, props, op) {
+    addInterval(start, end, intervalType, props, op, stickiness = exports.IntervalStickiness.END) {
         var _a;
         var _b;
-        const interval = this.createInterval(start, end, intervalType, op);
+        const interval = this.createInterval(start, end, intervalType, op, stickiness);
         if (interval) {
             if (!interval.properties) {
                 interval.properties = (0, merge_tree_1.createMap)();
@@ -787,7 +965,7 @@ class LocalIntervalCollection {
                 // either, so this must be special-cased.
                 return ref;
             }
-            return this.client.createLocalReferencePosition(segment, ref.getOffset(), merge_tree_1.ReferenceType.Transient, ref.properties);
+            return this.client.createLocalReferencePosition(segment, ref.getOffset(), merge_tree_1.ReferenceType.Transient, ref.properties, ref.slidingPreference);
         };
         if (interval instanceof SequenceInterval) {
             let previousInterval;
@@ -823,13 +1001,21 @@ exports.LocalIntervalCollection = LocalIntervalCollection;
 LocalIntervalCollection.legacyIdPrefix = "legacy";
 const compareSequenceIntervalEnds = (a, b) => (0, merge_tree_1.compareReferencePositions)(a.end, b.end);
 exports.compareSequenceIntervalEnds = compareSequenceIntervalEnds;
+const compareSequenceIntervalStarts = (a, b) => (0, merge_tree_1.compareReferencePositions)(a.start, b.start);
+exports.compareSequenceIntervalStarts = compareSequenceIntervalStarts;
+exports.sequenceIntervalHelpers = {
+    compareEnds: exports.compareSequenceIntervalEnds,
+    compareStarts: exports.compareSequenceIntervalStarts,
+    create: createSequenceInterval,
+};
+exports.intervalHelpers = {
+    compareEnds: (a, b) => a.end - b.end,
+    compareStarts: (a, b) => a.start - b.start,
+    create: createInterval,
+};
 class SequenceIntervalCollectionFactory {
-    load(emitter, raw = []) {
-        const helpers = {
-            compareEnds: exports.compareSequenceIntervalEnds,
-            create: createSequenceInterval,
-        };
-        return new IntervalCollection(helpers, true, emitter, raw);
+    load(emitter, raw = [], options) {
+        return new IntervalCollection(exports.sequenceIntervalHelpers, true, emitter, raw, options);
     }
     store(value) {
         return value.serializeInternal();
@@ -851,7 +1037,7 @@ SequenceIntervalCollectionValueType.Name = "sharedStringIntervalCollection";
 SequenceIntervalCollectionValueType._factory = new SequenceIntervalCollectionFactory();
 SequenceIntervalCollectionValueType._ops = makeOpsMap();
 const compareIntervalEnds = (a, b) => a.end - b.end;
-function createInterval(label, start, end, client) {
+function createInterval(label, start, end, client, intervalType, op, fromSnapshot) {
     const rangeProp = {};
     if (label && label.length > 0) {
         rangeProp[merge_tree_1.reservedRangeLabelsKey] = [label];
@@ -859,12 +1045,12 @@ function createInterval(label, start, end, client) {
     return new Interval(start, end, rangeProp);
 }
 class IntervalCollectionFactory {
-    load(emitter, raw = []) {
+    load(emitter, raw = [], options) {
         const helpers = {
             compareEnds: compareIntervalEnds,
             create: createInterval,
         };
-        const collection = new IntervalCollection(helpers, false, emitter, raw);
+        const collection = new IntervalCollection(helpers, false, emitter, raw, options);
         collection.attachGraph(undefined, "");
         return collection;
     }
@@ -896,7 +1082,7 @@ function makeOpsMap() {
     };
     return new Map([
         [
-            "add",
+            exports.IntervalOpType.ADD,
             {
                 process: (collection, params, local, op, localOpMetadata) => {
                     // if params is undefined, the interval was deleted during
@@ -911,7 +1097,7 @@ function makeOpsMap() {
             },
         ],
         [
-            "delete",
+            exports.IntervalOpType.DELETE,
             {
                 process: (collection, params, local, op) => {
                     (0, common_utils_1.assert)(op !== undefined, 0x3fc /* op should exist here */);
@@ -924,7 +1110,7 @@ function makeOpsMap() {
             },
         ],
         [
-            "change",
+            exports.IntervalOpType.CHANGE,
             {
                 process: (collection, params, local, op, localOpMetadata) => {
                     // if params is undefined, the interval was deleted during
@@ -960,21 +1146,17 @@ class IntervalCollectionIterator {
         };
     }
 }
-exports.IntervalCollectionIterator = IntervalCollectionIterator;
 /**
- * Collection of intervals that supports addition, modification, removal, and efficient spatial querying.
- * This class is not a DDS in its own right, but emits events on mutating operations such that it's possible to
- * integrate into a DDS.
- * This aligns with its usage in `SharedSegmentSequence`, which allows associating intervals to positions in the
- * sequence DDS which are broadcast to all other clients in an eventually consistent fashion.
+ * {@inheritdoc IIntervalCollection}
  */
 class IntervalCollection extends common_utils_1.TypedEventEmitter {
     /** @internal */
-    constructor(helpers, requiresClient, emitter, serializedIntervals) {
+    constructor(helpers, requiresClient, emitter, serializedIntervals, options = {}) {
         super();
         this.helpers = helpers;
         this.requiresClient = requiresClient;
         this.emitter = emitter;
+        this.options = options;
         this.localSeqToSerializedInterval = new Map();
         this.localSeqToRebasedInterval = new Map();
         this.pendingChangesStart = new Map();
@@ -986,6 +1168,36 @@ class IntervalCollection extends common_utils_1.TypedEventEmitter {
     get attached() {
         return !!this.localCollection;
     }
+    /**
+     * {@inheritdoc IIntervalCollection.attachIndex}
+     */
+    attachIndex(index) {
+        var _a;
+        if (!this.attached) {
+            throw new telemetry_utils_1.LoggingError("The local interval collection must exist");
+        }
+        for (const interval of this) {
+            index.add(interval);
+        }
+        (_a = this.localCollection) === null || _a === void 0 ? void 0 : _a.appendIndex(index);
+    }
+    /**
+     * {@inheritdoc IIntervalCollection.detachIndex}
+     */
+    detachIndex(index) {
+        var _a;
+        if (!this.attached) {
+            throw new telemetry_utils_1.LoggingError("The local interval collection must exist");
+        }
+        // Avoid removing intervals if the index does not exist
+        if (!((_a = this.localCollection) === null || _a === void 0 ? void 0 : _a.removeIndex(index))) {
+            return false;
+        }
+        for (const interval of this) {
+            index.remove(interval);
+        }
+        return true;
+    }
     rebasePositionWithSegmentSlide(pos, seqNumberFrom, localSeq) {
         var _a;
         if (!this.client) {
@@ -1041,8 +1253,8 @@ class IntervalCollection extends common_utils_1.TypedEventEmitter {
         if (this.savedSerializedIntervals) {
             for (const serializedInterval of this.savedSerializedIntervals) {
                 this.localCollection.ensureSerializedId(serializedInterval);
-                const { start, end, intervalType, properties } = serializedInterval;
-                const interval = this.helpers.create(label, start, end, client, intervalType, undefined, true);
+                const { start, end, intervalType, properties, stickiness } = serializedInterval;
+                const interval = this.helpers.create(label, start, end, client, intervalType, undefined, true, stickiness);
                 if (properties) {
                     interval.addProperties(properties);
                 }
@@ -1080,8 +1292,7 @@ class IntervalCollection extends common_utils_1.TypedEventEmitter {
         }
     }
     /**
-     * @returns the interval in this collection that has the provided `id`.
-     * If no interval in the collection has this `id`, returns `undefined`.
+     * {@inheritdoc IIntervalCollection.getIntervalById}
      */
     getIntervalById(id) {
         if (!this.localCollection) {
@@ -1090,16 +1301,9 @@ class IntervalCollection extends common_utils_1.TypedEventEmitter {
         return this.localCollection.idIntervalIndex.getIntervalById(id);
     }
     /**
-     * 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 props - properties of the 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.
+     * {@inheritdoc IIntervalCollection.add}
      */
-    add(start, end, intervalType, props) {
+    add(start, end, intervalType, props, stickiness = exports.IntervalStickiness.END) {
         var _a, _b;
         if (!this.localCollection) {
             throw new telemetry_utils_1.LoggingError("attach must be called prior to adding intervals");
@@ -1107,7 +1311,10 @@ class IntervalCollection extends common_utils_1.TypedEventEmitter {
         if (intervalType & IntervalType.Transient) {
             throw new telemetry_utils_1.LoggingError("Can not add transient intervals");
         }
-        const interval = this.localCollection.addInterval(start, end, intervalType, props);
+        if (stickiness !== exports.IntervalStickiness.END && !this.options.intervalStickinessEnabled) {
+            throw new container_utils_1.UsageError("attempted to set interval stickiness without enabling `intervalStickinessEnabled` feature flag");
+        }
+        const interval = this.localCollection.addInterval(start, end, intervalType, props, undefined, stickiness);
         if (interval) {
             const serializedInterval = {
                 end,
@@ -1115,6 +1322,7 @@ class IntervalCollection extends common_utils_1.TypedEventEmitter {
                 properties: interval.properties,
                 sequenceNumber: (_b = (_a = this.client) === null || _a === void 0 ? void 0 : _a.getCurrentSeq()) !== null && _b !== void 0 ? _b : 0,
                 start,
+                stickiness,
             };
             const localSeq = this.getNextLocalSeq();
             this.localSeqToSerializedInterval.set(localSeq, serializedInterval);
@@ -1146,9 +1354,7 @@ class IntervalCollection extends common_utils_1.TypedEventEmitter {
         this.emit("deleteInterval", interval, local, op);
     }
     /**
-     * Removes an interval from the collection.
-     * @param id - Id of the interval to remove
-     * @returns the removed interval
+     * {@inheritdoc IIntervalCollection.removeIntervalById}
      */
     removeIntervalById(id) {
         if (!this.localCollection) {
@@ -1161,10 +1367,7 @@ class IntervalCollection extends common_utils_1.TypedEventEmitter {
         return interval;
     }
     /**
-     * Changes the properties on an existing interval.
-     * @param id - Id of the interval whose properties should be changed
-     * @param props - Property set to apply to the interval. Shallow merging is used between any existing properties
-     * and `prop`, i.e. the interval will end up with a property object equivalent to `{ ...oldProps, ...props }`.
+     * {@inheritdoc IIntervalCollection.changeProperties}
      */
     changeProperties(id, props) {
         if (!this.attached) {
@@ -1194,11 +1397,7 @@ class IntervalCollection extends common_utils_1.TypedEventEmitter {
         }
     }
     /**
-     * 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.
-     * @returns the interval that was changed, if it existed in the collection.
+     * {@inheritdoc IIntervalCollection.change}
      */
     change(id, start, end) {
         if (!this.localCollection) {
@@ -1353,6 +1552,9 @@ class IntervalCollection extends common_utils_1.TypedEventEmitter {
             throw new telemetry_utils_1.LoggingError("attachSequence must be called");
         }
     }
+    /**
+     * {@inheritdoc IIntervalCollection.attachDeserializer}
+     */
     attachDeserializer(onDeserialize) {
         // If no deserializer is specified can skip all processing work
         if (!onDeserialize) {
@@ -1473,7 +1675,7 @@ class IntervalCollection extends common_utils_1.TypedEventEmitter {
             }
             if (needsStartUpdate) {
                 const props = interval.start.properties;
-                interval.start = createPositionReferenceFromSegoff(this.client, newStart, interval.start.refType, op);
+                interval.start = createPositionReferenceFromSegoff(this.client, newStart, interval.start.refType, op, startReferenceSlidingPreference(interval.stickiness));
                 if (props) {
                     interval.start.addProperties(props);
                 }
@@ -1485,7 +1687,7 @@ class IntervalCollection extends common_utils_1.TypedEventEmitter {
             }
             if (needsEndUpdate) {
                 const props = interval.end.properties;
-                interval.end = createPositionReferenceFromSegoff(this.client, newEnd, interval.end.refType, op);
+                interval.end = createPositionReferenceFromSegoff(this.client, newEnd, interval.end.refType, op, endReferenceSlidingPreference(interval.stickiness));
                 if (props) {
                     interval.end.addProperties(props);
                 }
@@ -1516,7 +1718,7 @@ class IntervalCollection extends common_utils_1.TypedEventEmitter {
             throw new telemetry_utils_1.LoggingError("attachSequence must be called");
         }
         this.localCollection.ensureSerializedId(serializedInterval);
-        const interval = this.localCollection.addInterval(serializedInterval.start, serializedInterval.end, serializedInterval.intervalType, serializedInterval.properties, op);
+        const interval = this.localCollection.addInterval(serializedInterval.start, serializedInterval.end, serializedInterval.intervalType, serializedInterval.properties, op, serializedInterval.stickiness);
         if (interval) {
             if (this.onDeserialize) {
                 this.onDeserialize(interval);
@@ -1559,40 +1761,35 @@ class IntervalCollection extends common_utils_1.TypedEventEmitter {
         return iterator;
     }
     /**
-     * @returns a forward iterator over all intervals in this collection with start point equal to `startPosition`.
+     * {@inheritdoc IIntervalCollection.CreateForwardIteratorWithStartPosition}
      */
     CreateForwardIteratorWithStartPosition(startPosition) {
         const iterator = new IntervalCollectionIterator(this, true, startPosition);
         return iterator;
     }
     /**
-     * @returns a backward iterator over all intervals in this collection with start point equal to `startPosition`.
+     * {@inheritdoc IIntervalCollection.CreateBackwardIteratorWithStartPosition}
      */
     CreateBackwardIteratorWithStartPosition(startPosition) {
         const iterator = new IntervalCollectionIterator(this, false, startPosition);
         return iterator;
     }
     /**
-     * @returns a forward iterator over all intervals in this collection with end point equal to `endPosition`.
+     * {@inheritdoc IIntervalCollection.CreateForwardIteratorWithEndPosition}
      */
     CreateForwardIteratorWithEndPosition(endPosition) {
         const iterator = new IntervalCollectionIterator(this, true, undefined, endPosition);
         return iterator;
     }
     /**
-     * @returns a backward iterator over all intervals in this collection with end point equal to `endPosition`.
+     * {@inheritdoc IIntervalCollection.CreateBackwardIteratorWithEndPosition}
      */
     CreateBackwardIteratorWithEndPosition(endPosition) {
         const iterator = new IntervalCollectionIterator(this, false, undefined, endPosition);
         return iterator;
     }
     /**
-     * Gathers iteration results that optionally match a start/end criteria into the provided array.
-     * @param results - Array to gather the results into. In lieu of a return value, this array will be populated with
-     * intervals matching the query upon edit.
-     * @param iteratesForward - whether or not iteration should be in the forward direction
-     * @param start - If provided, only match intervals whose start point is equal to `start`.
-     * @param end - If provided, only match intervals whose end point is equal to `end`.
+     * {@inheritdoc IIntervalCollection.gatherIterationResults}
      */
     gatherIterationResults(results, iteratesForward, start, end) {
         if (!this.localCollection) {
@@ -1601,8 +1798,7 @@ class IntervalCollection extends common_utils_1.TypedEventEmitter {
         this.localCollection.overlappingIntervalsIndex.gatherIterationResults(results, iteratesForward, start, end);
     }
     /**
-     * @returns an array of all intervals in this collection that overlap with the interval
-     * `[startPosition, endPosition]`.
+     * {@inheritdoc IIntervalCollection.findOverlappingIntervals}
      */
     findOverlappingIntervals(startPosition, endPosition) {
         if (!this.localCollection) {
@@ -1611,7 +1807,7 @@ class IntervalCollection extends common_utils_1.TypedEventEmitter {
         return this.localCollection.overlappingIntervalsIndex.findOverlappingIntervals(startPosition, endPosition);
     }
     /**
-     * Applies a function to each interval in this collection.
+     * {@inheritdoc IIntervalCollection.map}
      */
     map(fn) {
         if (!this.localCollection) {
@@ -1621,12 +1817,18 @@ class IntervalCollection extends common_utils_1.TypedEventEmitter {
             fn(interval);
         }
     }
+    /**
+     * {@inheritdoc IIntervalCollection.previousInterval}
+     */
     previousInterval(pos) {
         if (!this.localCollection) {
             throw new telemetry_utils_1.LoggingError("attachSequence must be called");
         }
         return this.localCollection.endIntervalIndex.previousInterval(pos);
     }
+    /**
+     * {@inheritdoc IIntervalCollection.nextInterval}
+     */
     nextInterval(pos) {
         if (!this.localCollection) {
             throw new telemetry_utils_1.LoggingError("attachSequence must be called");