@fluidframework/sequence 2.0.0-internal.1.4.2 → 2.0.0-internal.2.0.0

package/src/intervalCollection.ts

@@ -15,10 +15,6 @@ import {
     ConflictAction,
     createMap,
     ICombiningOp,
-    IInterval,
-    IntervalConflictResolver,
-    IntervalNode,
-    IntervalTree,
     ISegment,
     MergeTreeDeltaType,
     minReferencePosition,
@@ -45,6 +41,7 @@ import {
     IValueType,
     IValueTypeOperationValue,
 } from "./defaultMapInterfaces";
+import { IInterval, IntervalConflictResolver, IntervalTree, IntervalNode } from "./intervalTree";
 
 const reservedIntervalIdKey = "intervalId";
 
@@ -67,17 +64,44 @@ export enum IntervalType {
     Transient = 0x4,
 }
 
+/**
+ * Serialized object representation of an interval.
+ * This representation is used for ops that create or change intervals.
+ * @internal
+ */
 export interface ISerializedInterval {
+    /**
+     * Sequence number at which `start` and `end` should be interpreted
+     *
+     * @remarks - It's unclear that this is necessary to store here.
+     * This should just be the refSeq on the op that modified the interval, which should be available via other means.
+     * At the time of writing, it's not plumbed through to the reconnect/rebase code, however, which does need it.
+     */
     sequenceNumber: number;
+    /** Start position of the interval (inclusive) */
     start: number;
+    /** End position of the interval (inclusive) */
     end: number;
+    /** Interval type to create */
     intervalType: IntervalType;
+    /** Any properties the interval has */
     properties?: PropertySet;
 }
 
+/**
+ * Represents a change that should be applied to an existing interval.
+ * Changes can modify any of start/end/properties, with `undefined` signifying no change should be made.
+ * @internal
+ */
+export type SerializedIntervalDelta =
+    Omit<ISerializedInterval, "start" | "end" | "properties">
+    & Partial<Pick<ISerializedInterval, "start" | "end" | "properties">>;
+
 /**
  * A size optimization to avoid redundantly storing keys when serializing intervals
- * as JSON. Intervals are of the format:
+ * as JSON for summaries.
+ *
+ * Intervals are of the format:
  *
  * [start, end, sequenceNumber, intervalType, properties]
  */
@@ -125,11 +149,22 @@ function compressInterval(interval: ISerializedInterval): CompressedSerializedIn
 }
 
 export interface ISerializableInterval extends IInterval {
+    /** Serializable bag of properties associated with the interval. */
     properties: PropertySet;
+    /** @internal */
     propertyManager: PropertiesManager;
-    serialize(client: Client): ISerializedInterval;
+    /** @internal */
+    serialize(): ISerializedInterval;
+    /** @internal */
     addProperties(props: PropertySet, collaborating?: boolean, seq?: number):
         PropertySet | undefined;
+    /**
+     * Gets the id associated with this interval.
+     * When the interval is used as part of an interval collection, this id can be used to modify or remove the
+     * interval.
+     * @remarks - This signature includes `undefined` strictly for backwards-compatibility reasons, as older versions
+     * of Fluid didn't always write interval ids.
+     */
     getIntervalId(): string | undefined;
 }
 
@@ -148,18 +183,28 @@ export interface IIntervalHelpers<TInterval extends ISerializableInterval> {
      */
     create(
         label: string,
-        start: number,
-        end: number,
-        client: Client,
-        intervalType?: IntervalType,
+        start: number | undefined,
+        end: number | undefined,
+        client: Client | undefined,
+        intervalType: IntervalType,
         op?: ISequencedDocumentMessage,
         fromSnapshot?: boolean,
     ): TInterval;
 }
 
+/**
+ * Serializable interval whose endpoints are plain-old numbers.
+ */
 export class Interval implements ISerializableInterval {
+    /**
+     * {@inheritDoc ISerializableInterval.properties}
+     */
     public properties: PropertySet;
-    public auxProps: PropertySet[];
+    /** @internal */
+    public auxProps: PropertySet[] | undefined;
+    /**
+     * {@inheritDoc ISerializableInterval.propertyManager}
+     */
     public propertyManager: PropertiesManager;
     constructor(
         public start: number,
@@ -174,6 +219,9 @@ export class Interval implements ISerializableInterval {
         }
     }
 
+    /**
+     * {@inheritDoc ISerializableInterval.getIntervalId}
+     */
     public getIntervalId(): string | undefined {
         const id = this.properties?.[reservedIntervalIdKey];
         if (id === undefined) {
@@ -182,10 +230,21 @@ export class Interval implements ISerializableInterval {
         return `${id}`;
     }
 
-    public getAdditionalPropertySets() {
-        return this.auxProps;
+    /**
+     * @returns an array containing any auxiliary property sets added with `addPropertySet`.
+     */
+    public getAdditionalPropertySets(): PropertySet[] {
+        return this.auxProps ?? [];
     }
 
+    /**
+     * 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>`
+     * (i.e. non-sequence-based interval collections). However, the additional properties don't get serialized.
+     * This functionality seems half-baked.
+     */
     public addPropertySet(props: PropertySet) {
         if (this.auxProps === undefined) {
             this.auxProps = [];
@@ -193,12 +252,15 @@ export class Interval implements ISerializableInterval {
         this.auxProps.push(props);
     }
 
-    public serialize(client: Client): ISerializedInterval {
-        const seq = client?.getCurrentSeq() ?? 0;
+    /**
+     * {@inheritDoc ISerializableInterval.serialize}
+     * @internal
+     */
+    public serialize(): ISerializedInterval {
         const serializedInterval: ISerializedInterval = {
             end: this.end,
             intervalType: 0,
-            sequenceNumber: seq,
+            sequenceNumber: 0,
             start: this.start,
         };
         if (this.properties) {
@@ -207,10 +269,16 @@ export class Interval implements ISerializableInterval {
         return serializedInterval;
     }
 
+    /**
+     * {@inheritDoc IInterval.clone}
+     */
     public clone() {
         return new Interval(this.start, this.end, this.properties);
     }
 
+    /**
+     * {@inheritDoc IInterval.compare}
+     */
     public compare(b: Interval) {
         const startResult = this.compareStart(b);
         if (startResult === 0) {
@@ -233,20 +301,32 @@ export class Interval implements ISerializableInterval {
         }
     }
 
+    /**
+     * {@inheritDoc IInterval.compareStart}
+     */
     public compareStart(b: Interval) {
         return this.start - b.start;
     }
 
+    /**
+     * {@inheritDoc IInterval.compareEnd}
+     */
     public compareEnd(b: Interval) {
         return this.end - b.end;
     }
 
+    /**
+     * {@inheritDoc IInterval.overlaps}
+     */
     public overlaps(b: Interval) {
         const result = (this.start <= b.end) &&
             (this.end >= b.start);
         return result;
     }
 
+    /**
+     * {@inheritDoc IInterval.union}
+     */
     public union(b: Interval) {
         return new Interval(Math.min(this.start, b.start),
             Math.max(this.end, b.end), this.properties);
@@ -256,6 +336,9 @@ export class Interval implements ISerializableInterval {
         return this.properties;
     }
 
+    /**
+     * {@inheritDoc ISerializableInterval.addProperties}
+     */
     public addProperties(
         newProps: PropertySet,
         collaborating: boolean = false,
@@ -268,6 +351,9 @@ export class Interval implements ISerializableInterval {
         }
     }
 
+    /**
+     * {@inheritDoc IInterval.modify}
+     */
     public modify(label: string, start: number, end: number, op?: ISequencedDocumentMessage) {
         const startPos = start ?? this.start;
         const endPos = end ?? this.end;
@@ -293,13 +379,32 @@ export class Interval implements ISerializableInterval {
     }
 }
 
+/**
+ * Interval impelmentation 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.
+ */
 export class SequenceInterval implements ISerializableInterval {
+    /**
+     * {@inheritDoc ISerializableInterval.properties}
+     */
     public properties: PropertySet;
+    /**
+     * {@inheritDoc ISerializableInterval.propertyManager}
+     */
     public propertyManager: PropertiesManager;
 
     constructor(
         private readonly client: Client,
+        /**
+         * Start endpoint of this interval.
+         * @remarks - This endpoint can be resolved into a character position using the SharedString it's a part of.
+         */
         public start: LocalReferencePosition,
+        /**
+         * End endpoint of this interval.
+         * @remarks - This endpoint can be resolved into a character position using the SharedString it's a part of.
+         */
         public end: LocalReferencePosition,
         public intervalType: IntervalType,
         props?: PropertySet,
@@ -344,13 +449,17 @@ export class SequenceInterval implements ISerializableInterval {
         }
     }
 
-    public serialize(client: Client): ISerializedInterval {
-        const startPosition = client.localReferencePositionToPosition(this.start);
-        const endPosition = client.localReferencePositionToPosition(this.end);
+    /**
+     * {@inheritDoc ISerializableInterval.serialize}
+     * @internal
+     */
+    public serialize(): ISerializedInterval {
+        const startPosition = this.client.localReferencePositionToPosition(this.start);
+        const endPosition = this.client.localReferencePositionToPosition(this.end);
         const serializedInterval: ISerializedInterval = {
             end: endPosition,
             intervalType: this.intervalType,
-            sequenceNumber: client.getCurrentSeq(),
+            sequenceNumber: this.client.getCurrentSeq(),
             start: startPosition,
         };
 
@@ -361,10 +470,16 @@ export class SequenceInterval implements ISerializableInterval {
         return serializedInterval;
     }
 
+    /**
+     * {@inheritDoc IInterval.clone}
+     */
     public clone() {
         return new SequenceInterval(this.client, this.start, this.end, this.intervalType, this.properties);
     }
 
+    /**
+     * {@inheritDoc IInterval.compare}
+     */
     public compare(b: SequenceInterval) {
         const startResult = this.compareStart(b);
         if (startResult === 0) {
@@ -387,20 +502,32 @@ export class SequenceInterval implements ISerializableInterval {
         }
     }
 
+    /**
+     * {@inheritDoc IInterval.compareStart}
+     */
     public compareStart(b: SequenceInterval) {
         return compareReferencePositions(this.start, b.start);
     }
 
+    /**
+     * {@inheritDoc IInterval.compareEnd}
+     */
     public compareEnd(b: SequenceInterval) {
         return compareReferencePositions(this.end, b.end);
     }
 
+    /**
+     * {@inheritDoc IInterval.overlaps}
+     */
     public overlaps(b: SequenceInterval) {
         const result = (compareReferencePositions(this.start, b.end) <= 0) &&
             (compareReferencePositions(this.end, b.start) >= 0);
         return result;
     }
 
+    /**
+     * {@inheritDoc ISerializableInterval.getIntervalId}
+     */
     public getIntervalId(): string | undefined {
         const id = this.properties?.[reservedIntervalIdKey];
         if (id === undefined) {
@@ -409,11 +536,17 @@ export class SequenceInterval implements ISerializableInterval {
         return `${id}`;
     }
 
+    /**
+     * {@inheritDoc IInterval.union}
+     */
     public union(b: SequenceInterval) {
         return new SequenceInterval(this.client, minReferencePosition(this.start, b.start),
             maxReferencePosition(this.end, b.end), this.intervalType);
     }
 
+    /**
+     * {@inheritDoc ISerializableInterval.addProperties}
+     */
     public addProperties(
         newProps: PropertySet,
         collab: boolean = false,
@@ -424,12 +557,19 @@ export class SequenceInterval implements ISerializableInterval {
         return this.propertyManager.addProperties(this.properties, newProps, op, seq, collab);
     }
 
+    /**
+     * @returns whether this interval overlaps two numerical positions.
+     * @remarks - this is currently strict overlap, which doesn't align with the endpoint treatment of`.overlaps()`
+     */
     public overlapsPos(bstart: number, bend: number) {
         const startPos = this.client.localReferencePositionToPosition(this.start);
         const endPos = this.client.localReferencePositionToPosition(this.end);
         return (endPos > bstart) && (startPos < bend);
     }
 
+    /**
+     * {@inheritDoc IInterval.modify}
+     */
     public modify(label: string, start: number, end: number, op?: ISequencedDocumentMessage, localSeq?: number) {
         const getRefType = (baseType: ReferenceType): ReferenceType => {
             let refType = baseType;
@@ -445,7 +585,9 @@ export class SequenceInterval implements ISerializableInterval {
             startRef = createPositionReference(
                 this.client, start, getRefType(this.start.refType), op, undefined, localSeq,
             );
-            startRef.addProperties(this.start.properties);
+            if (this.start.properties) {
+                startRef.addProperties(this.start.properties);
+            }
         }
 
         let endRef = this.end;
@@ -453,7 +595,9 @@ export class SequenceInterval implements ISerializableInterval {
             endRef = createPositionReference(
                 this.client, end, getRefType(this.end.refType), op, undefined, localSeq,
             );
-            endRef.addProperties(this.end.properties);
+            if (this.end.properties) {
+                endRef.addProperties(this.end.properties);
+            }
         }
 
         const newInterval = new SequenceInterval(this.client, startRef, endRef, this.intervalType);
@@ -506,21 +650,22 @@ function createPositionReference(
         segoff = client.getContainingSegment(pos, op);
         segoff = client.getSlideToSegment(segoff);
     } else {
-        assert((refType & ReferenceType.SlideOnRemove) === 0 || fromSnapshot,
+        assert((refType & ReferenceType.SlideOnRemove) === 0 || !!fromSnapshot,
             0x2f6 /* SlideOnRemove references must be op created */);
         segoff = client.getContainingSegment(pos, undefined, localSeq);
     }
     return createPositionReferenceFromSegoff(client, segoff, refType, op);
 }
 
-function createSequenceInterval(
+export function createSequenceInterval(
     label: string,
     start: number,
     end: number,
     client: Client,
-    intervalType?: IntervalType,
+    intervalType: IntervalType,
     op?: ISequencedDocumentMessage,
-    fromSnapshot?: boolean): SequenceInterval {
+    fromSnapshot?: boolean,
+): SequenceInterval {
     let beginRefType = ReferenceType.RangeBegin;
     let endRefType = ReferenceType.RangeEnd;
     if (intervalType === IntervalType.Transient) {
@@ -551,7 +696,13 @@ function createSequenceInterval(
     startLref.addProperties(rangeProp);
     endLref.addProperties(rangeProp);
 
-    const ival = new SequenceInterval(client, startLref, endLref, intervalType, rangeProp);
+    const ival = new SequenceInterval(
+        client,
+        startLref,
+        endLref,
+        intervalType,
+        rangeProp,
+    );
     return ival;
 }
 
@@ -565,7 +716,7 @@ export function createIntervalIndex(conflict?: IntervalConflictResolver<Interval
         compareEnds: compareIntervalEnds,
         create: createInterval,
     };
-    const lc = new LocalIntervalCollection<Interval>(undefined, "", helpers);
+    const lc = new LocalIntervalCollection<Interval>(undefined as any as Client, "", helpers);
     if (conflict) {
         lc.addConflictResolver(conflict);
     } else {
@@ -588,7 +739,7 @@ export class LocalIntervalCollection<TInterval extends ISerializableInterval> {
         private readonly label: string,
         private readonly helpers: IIntervalHelpers<TInterval>,
         /** Callback invoked each time one of the endpoints of an interval slides. */
-        private readonly onPositionChange?: (interval: TInterval) => void,
+        private readonly onPositionChange?: (interval: TInterval, previousInterval: TInterval) => void,
     ) {
         // eslint-disable-next-line @typescript-eslint/unbound-method
         this.endIntervalTree = new RedBlackTree<TInterval, TInterval>(helpers.compareEnds);
@@ -723,6 +874,10 @@ export class LocalIntervalCollection<TInterval extends ISerializableInterval> {
         }
     }
 
+    /**
+     * @returns an array of all intervals contained in this collection that overlap the range
+     * `[startPosition, endPosition]`.
+     */
     public findOverlappingIntervals(startPosition: number, endPosition: number) {
         if (endPosition < startPosition || this.intervalTree.intervals.isEmpty()) {
             return [];
@@ -831,7 +986,7 @@ export class LocalIntervalCollection<TInterval extends ISerializableInterval> {
         this.intervalIdMap.set(id, interval);
     }
 
-    public add(interval: TInterval) {
+    public add(interval: TInterval): void {
         this.linkEndpointsToInterval(interval);
         this.addIntervalToIndex(interval);
         this.addIntervalListeners(interval);
@@ -843,8 +998,8 @@ export class LocalIntervalCollection<TInterval extends ISerializableInterval> {
 
     public changeInterval(
         interval: TInterval,
-        start: number,
-        end: number,
+        start: number | undefined,
+        end: number | undefined,
         op?: ISequencedDocumentMessage,
         localSeq?: number,
     ) {
@@ -857,23 +1012,46 @@ export class LocalIntervalCollection<TInterval extends ISerializableInterval> {
     }
 
     public serialize(): ISerializedIntervalCollectionV2 {
-        const client = this.client;
         const intervals = this.intervalTree.intervals.keys();
-
         return {
             label: this.label,
-            intervals: intervals.map((interval) => compressInterval(interval.serialize(client))),
+            intervals: intervals.map((interval) => compressInterval(interval.serialize())),
             version: 2,
         };
     }
 
     private addIntervalListeners(interval: TInterval) {
+        const cloneRef = (ref: LocalReferencePosition) => {
+            const segment = ref.getSegment();
+            if (segment === undefined) {
+                // Cloning is unnecessary: refs which have slid off the string entirely
+                // never get slid back on. Creation code for refs doesn't accept undefined segment
+                // either, so this must be special-cased.
+                return ref;
+            }
+
+            return this.client.createLocalReferencePosition(
+                segment,
+                ref.getOffset(),
+                ReferenceType.Transient,
+                ref.properties,
+            );
+        };
         if (interval instanceof SequenceInterval) {
+            let previousInterval: TInterval & SequenceInterval | undefined;
             interval.addPositionChangeListeners(
-                () => this.removeIntervalFromIndex(interval),
                 () => {
+                    assert(!previousInterval, 0x3f9 /* Invalid interleaving of before/after slide */);
+                    previousInterval = interval.clone() as TInterval & SequenceInterval;
+                    previousInterval.start = cloneRef(previousInterval.start);
+                    previousInterval.end = cloneRef(previousInterval.end);
+                    this.removeIntervalFromIndex(interval);
+                },
+                () => {
+                    assert(previousInterval !== undefined, 0x3fa /* Invalid interleaving of before/after slide */);
                     this.addIntervalToIndex(interval);
-                    this.onPositionChange?.(interval);
+                    this.onPositionChange?.(interval, previousInterval);
+                    previousInterval = undefined;
                 },
             );
         }
@@ -886,7 +1064,7 @@ export class LocalIntervalCollection<TInterval extends ISerializableInterval> {
     }
 }
 
-const compareSequenceIntervalEnds = (a: SequenceInterval, b: SequenceInterval): number =>
+export const compareSequenceIntervalEnds = (a: SequenceInterval, b: SequenceInterval): number =>
     compareReferencePositions(a.end, b.end);
 
 class SequenceIntervalCollectionFactory
@@ -902,7 +1080,7 @@ class SequenceIntervalCollectionFactory
         return new IntervalCollection<SequenceInterval>(helpers, true, emitter, raw);
     }
 
-    public store(value: IntervalCollection<SequenceInterval>): ISerializedIntervalCollectionV2 {
+    public store(value: IntervalCollection<SequenceInterval>): ISerializedInterval[] | ISerializedIntervalCollectionV2 {
         return value.serializeInternal();
     }
 }
@@ -952,7 +1130,7 @@ class IntervalCollectionFactory
             create: createInterval,
         };
         const collection = new IntervalCollection<Interval>(helpers, false, emitter, raw);
-        collection.attachGraph(undefined, "");
+        collection.attachGraph(undefined as any as Client, "");
         return collection;
     }
 
@@ -982,7 +1160,7 @@ export class IntervalCollectionValueType
     private static readonly _ops = makeOpsMap<Interval>();
 }
 
-function makeOpsMap<T extends ISerializableInterval>(): Map<string, IValueOperation<IntervalCollection<T>>> {
+export function makeOpsMap<T extends ISerializableInterval>(): Map<string, IValueOperation<IntervalCollection<T>>> {
     const rebase = (
         collection: IntervalCollection<T>,
         op: IValueTypeOperationValue,
@@ -1004,6 +1182,7 @@ function makeOpsMap<T extends ISerializableInterval>(): Map<string, IValueOperat
                     if (!params) {
                         return;
                     }
+                    assert(op !== undefined, 0x3fb /* op should exist here */);
                     collection.ackAdd(params, local, op);
                 },
                 rebase,
@@ -1013,6 +1192,7 @@ function makeOpsMap<T extends ISerializableInterval>(): Map<string, IValueOperat
             "delete",
             {
                 process: (collection, params, local, op) => {
+                    assert(op !== undefined, 0x3fc /* op should exist here */);
                     collection.ackDelete(params, local, op);
                 },
                 rebase: (collection, op, localOpMetadata) => {
@@ -1030,6 +1210,7 @@ function makeOpsMap<T extends ISerializableInterval>(): Map<string, IValueOperat
                     if (!params) {
                         return;
                     }
+                    assert(op !== undefined, 0x3fd /* op should exist here */);
                     collection.ackChange(params, local, op);
                 },
                 rebase,
@@ -1039,7 +1220,8 @@ function makeOpsMap<T extends ISerializableInterval>(): Map<string, IValueOperat
 
 export type DeserializeCallback = (properties: PropertySet) => void;
 
-export class IntervalCollectionIterator<TInterval extends ISerializableInterval> {
+export class IntervalCollectionIterator<TInterval extends ISerializableInterval>
+    implements Iterator<TInterval> {
     private readonly results: TInterval[];
     private index: number;
 
@@ -1054,43 +1236,80 @@ export class IntervalCollectionIterator<TInterval extends ISerializableInterval>
         collection.gatherIterationResults(this.results, iteratesForward, start, end);
     }
 
-    public next() {
-        let _value: TInterval | undefined;
-        let _done: boolean = true;
-
+    public next(): IteratorResult<TInterval> {
         if (this.index < this.results.length) {
-            _value = this.results[this.index++];
-            _done = false;
+            return {
+                value: this.results[this.index++],
+                done: false,
+            };
         }
 
         return {
-            value: _value,
-            done: _done,
+            value: undefined,
+            done: true,
         };
     }
 }
 
+/**
+ * Change events emitted by `IntervalCollection`s
+ */
 export interface IIntervalCollectionEvent<TInterval extends ISerializableInterval> extends IEvent {
     /**
-     * This event is invoked whenever the properties or endpoints of an interval may have changed.
+     * This event is invoked whenever the endpoints of an interval may have changed.
      * This can happen on:
-     * - endpoint modification (local or remote)
-     * - ack of an endpoint modification
-     * - property change (local or remote)
-     * - position change due to segment sliding (will always appear as a local change)
+     * - local endpoint modification
+     * - ack of a remote endpoint modification
+     * - position change due to segment sliding (slides due to mergeTree segment deletion will always appear local)
      * The `interval` argument reflects the new values.
+     * `previousInterval` contains transient `ReferencePosition`s at the same location as the interval's original
+     * endpoints. These references should be used for position information only.
+     * `local` reflects whether the change originated locally.
+     * `op` is defined if and only if the server has acked this change.
      */
     (event: "changeInterval",
-        listener: (interval: TInterval, local: boolean, op: ISequencedDocumentMessage | undefined) => void);
+        listener: (
+            interval: TInterval,
+            previousInterval: TInterval,
+            local: boolean,
+            op: ISequencedDocumentMessage | undefined
+        ) => void);
+    /**
+     * This event is invoked whenever an interval is added or removed from the collection.
+     * `local` reflects whether the change originated locally.
+     * `op` is defined if and only if the server has acked this change.
+     */
     (event: "addInterval" | "deleteInterval",
-        listener: (interval: TInterval, local: boolean, op: ISequencedDocumentMessage) => void);
-    (event: "propertyChanged", listener: (interval: TInterval, propertyArgs: PropertySet) => void);
+        listener: (interval: TInterval, local: boolean, op: ISequencedDocumentMessage | undefined) => void);
+    /**
+     * This event is invoked whenever an interval's properties have changed.
+     * `interval` reflects the state of the updated properties.
+     * `propertyDeltas` is a map-like whose keys contain all values that were changed, and whose
+     * values contain all previous values of the property set.
+     * This object can be used directly in a call to `changeProperties` to revert the property change if desired.
+     * `local` reflects whether the change originated locally.
+     * `op` is defined if and only if the server has acked this change.
+     */
+    (event: "propertyChanged",
+        listener: (
+            interval: TInterval,
+            propertyDeltas: PropertySet,
+            local: boolean,
+            op: ISequencedDocumentMessage | undefined
+        ) => void);
 }
 
+/**
+ * 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.
+ */
 export class IntervalCollection<TInterval extends ISerializableInterval>
     extends TypedEventEmitter<IIntervalCollectionEvent<TInterval>> {
     private savedSerializedIntervals?: ISerializedInterval[];
-    private localCollection: LocalIntervalCollection<TInterval>;
+    private localCollection: LocalIntervalCollection<TInterval> | undefined;
     private onDeserialize: DeserializeCallback | undefined;
     private client: Client | undefined;
     private readonly pendingChangesStart: Map<string, ISerializedInterval[]> = new Map<string, ISerializedInterval[]>();
@@ -1114,6 +1333,7 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
             : serializedIntervals.intervals.map((i) => decompressInterval(i, serializedIntervals.label));
     }
 
+    /** @internal */
     public attachGraph(client: Client, label: string) {
         if (this.attached) {
             throw new LoggingError("Only supports one Sequence attach");
@@ -1129,7 +1349,7 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
             client,
             label,
             this.helpers,
-            (interval) => this.emit("changeInterval", interval, true, undefined),
+            (interval, previousInterval) => this.emitChange(interval, previousInterval, true),
         );
         if (this.savedSerializedIntervals) {
             for (const serializedInterval of this.savedSerializedIntervals) {
@@ -1144,7 +1364,9 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
                     undefined,
                     true,
                 );
-                interval.addProperties(properties);
+                if (properties) {
+                    interval.addProperties(properties);
+                }
                 this.localCollection.add(interval);
             }
         }
@@ -1162,15 +1384,43 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
         return 0;
     }
 
+    private emitChange(
+        interval: TInterval,
+        previousInterval: TInterval,
+        local: boolean,
+        op?: ISequencedDocumentMessage,
+    ): void {
+        // Temporarily make references transient so that positional queries work (non-transient refs
+        // on resolve to DetachedPosition on any segments that don't contain them). The original refType
+        // is restored as single-endpoint changes re-use previous references.
+        let startRefType: ReferenceType;
+        let endRefType: ReferenceType;
+        if (previousInterval instanceof SequenceInterval) {
+            startRefType = previousInterval.start.refType;
+            endRefType = previousInterval.end.refType;
+            previousInterval.start.refType = ReferenceType.Transient;
+            previousInterval.end.refType = ReferenceType.Transient;
+            this.emit("changeInterval", interval, previousInterval, local, op);
+            previousInterval.start.refType = startRefType;
+            previousInterval.end.refType = endRefType;
+        } else {
+            this.emit("changeInterval", interval, previousInterval, local, op);
+        }
+    }
+
+    /**
+     * @returns the interval in this collection that has the provided `id`.
+     * If no interval in the collection has this `id`, returns `undefined`.
+     */
     public getIntervalById(id: string) {
-        if (!this.attached) {
+        if (!this.localCollection) {
             throw new LoggingError("attach must be called before accessing intervals");
         }
         return this.localCollection.getIntervalById(id);
     }
 
     /**
-     * Create a new interval and add it to the collection
+     * Creates a new interval and add it to the collection.
      * @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.
@@ -1182,8 +1432,8 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
         end: number,
         intervalType: IntervalType,
         props?: PropertySet,
-    ) {
-        if (!this.attached) {
+    ): TInterval {
+        if (!this.localCollection) {
             throw new LoggingError("attach must be called prior to adding intervals");
         }
         if (intervalType & IntervalType.Transient) {
@@ -1210,6 +1460,9 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
     }
 
     private deleteExistingInterval(interval: TInterval, local: boolean, op?: ISequencedDocumentMessage) {
+        if (!this.localCollection) {
+            throw new LoggingError("Attach must be called before accessing intervals");
+        }
         // The given interval is known to exist in the collection.
         this.localCollection.removeExistingInterval(interval);
 
@@ -1219,7 +1472,7 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
                 this.emitter.emit(
                     "delete",
                     undefined,
-                    interval.serialize(this.client),
+                    interval.serialize(),
                     { localSeq: this.getNextLocalSeq() },
                 );
             } else {
@@ -1232,7 +1485,15 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
         this.emit("deleteInterval", interval, local, op);
     }
 
+    /**
+     * Removes an interval from the collection.
+     * @param id - Id of the interval to remove
+     * @returns the removed interval
+     */
     public removeIntervalById(id: string) {
+        if (!this.localCollection) {
+            throw new LoggingError("Attach must be called before accessing intervals");
+        }
         const interval = this.localCollection.getIntervalById(id);
         if (interval) {
             this.deleteExistingInterval(interval, true, undefined);
@@ -1240,6 +1501,12 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
         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 }`.
+     */
     public changeProperties(id: string, props: PropertySet) {
         if (!this.attached) {
             throw new LoggingError("Attach must be called before accessing intervals");
@@ -1255,7 +1522,7 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
         if (interval) {
             // Pass Unassigned as the sequence number to indicate that this is a local op that is waiting for an ack.
             const deltaProps = interval.addProperties(props, true, UnassignedSequenceNumber);
-            const serializedInterval: ISerializedInterval = interval.serialize(this.client);
+            const serializedInterval: ISerializedInterval = interval.serialize();
 
             // Emit a change op that will only change properties. Add the ID to
             // the property bag provided by the caller.
@@ -1265,13 +1532,19 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
             serializedInterval.properties = props;
             serializedInterval.properties[reservedIntervalIdKey] = interval.getIntervalId();
             this.emitter.emit("change", undefined, serializedInterval, { localSeq: this.getNextLocalSeq() });
-            this.emit("propertyChanged", interval, deltaProps);
+            this.emit("propertyChanged", interval, deltaProps, true, undefined);
         }
-        this.emit("changeInterval", interval, true, undefined);
     }
 
+    /**
+     * 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.
+     */
     public change(id: string, start?: number, end?: number): TInterval | undefined {
-        if (!this.attached) {
+        if (!this.localCollection) {
             throw new LoggingError("Attach must be called before accessing intervals");
         }
 
@@ -1283,7 +1556,10 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
         const interval = this.getIntervalById(id);
         if (interval) {
             const newInterval = this.localCollection.changeInterval(interval, start, end);
-            const serializedInterval: ISerializedInterval = interval.serialize(this.client);
+            if (!newInterval) {
+                return undefined;
+            }
+            const serializedInterval: SerializedIntervalDelta = interval.serialize();
             serializedInterval.start = start;
             serializedInterval.end = end;
             // Emit a property bag containing only the ID, as we don't intend for this op to change any properties.
@@ -1293,14 +1569,14 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
             };
             this.emitter.emit("change", undefined, serializedInterval, { localSeq: this.getNextLocalSeq() });
             this.addPendingChange(id, serializedInterval);
-            this.emit("changeInterval", newInterval, true, undefined);
+            this.emitChange(newInterval, interval, true);
             return newInterval;
         }
         // No interval to change
         return undefined;
     }
 
-    private addPendingChange(id: string, serializedInterval: ISerializedInterval) {
+    private addPendingChange(id: string, serializedInterval: SerializedIntervalDelta) {
         if (serializedInterval.start !== undefined) {
             this.addPendingChangeHelper(id, this.pendingChangesStart, serializedInterval);
         }
@@ -1311,10 +1587,10 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
 
     private addPendingChangeHelper(
         id: string,
-        pendingChanges: Map<string, ISerializedInterval[]>,
-        serializedInterval: ISerializedInterval,
+        pendingChanges: Map<string, SerializedIntervalDelta[]>,
+        serializedInterval: SerializedIntervalDelta,
     ) {
-        let entries: ISerializedInterval[] | undefined = pendingChanges.get(id);
+        let entries: SerializedIntervalDelta[] | undefined = pendingChanges.get(id);
         if (!entries) {
             entries = [];
             pendingChanges.set(id, entries);
@@ -1322,7 +1598,7 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
         entries.push(serializedInterval);
     }
 
-    private removePendingChange(serializedInterval: ISerializedInterval) {
+    private removePendingChange(serializedInterval: SerializedIntervalDelta) {
         // Change ops always have an ID.
         const id: string = serializedInterval.properties?.[reservedIntervalIdKey];
         if (serializedInterval.start !== undefined) {
@@ -1335,8 +1611,8 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
 
     private removePendingChangeHelper(
         id: string,
-        pendingChanges: Map<string, ISerializedInterval[]>,
-        serializedInterval: ISerializedInterval,
+        pendingChanges: Map<string, SerializedIntervalDelta[]>,
+        serializedInterval: SerializedIntervalDelta,
     ) {
         const entries = pendingChanges.get(id);
         if (entries) {
@@ -1363,64 +1639,72 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
 
     /** @internal */
     public ackChange(serializedInterval: ISerializedInterval, local: boolean, op: ISequencedDocumentMessage) {
-        if (!this.attached) {
+        if (!this.localCollection) {
             throw new LoggingError("Attach must be called before accessing intervals");
         }
 
-        let interval: TInterval | undefined;
-
         if (local) {
             // This is an ack from the server. Remove the pending change.
             this.removePendingChange(serializedInterval);
-            const id: string = serializedInterval.properties?.[reservedIntervalIdKey];
-            interval = this.getIntervalById(id);
-            if (interval) {
-                // Let the propertyManager prune its pending change-properties set.
-                interval.propertyManager?.ackPendingProperties(
-                    {
-                        type: MergeTreeDeltaType.ANNOTATE,
-                        props: serializedInterval.properties ?? {},
-                    });
+        }
 
-                this.ackInterval(interval, op);
-            }
+        // Note that the ID is in the property bag only to allow us to find the interval.
+        // This API cannot change the ID, and writing to the ID property will result in an exception. So we
+        // strip it out of the properties here.
+        const { [reservedIntervalIdKey]: id, ...newProps } = serializedInterval.properties ?? {};
+        assert(id !== undefined, 0x3fe /* id must exist on the interval */);
+        const interval: TInterval | undefined = this.getIntervalById(id);
+        if (!interval) {
+            // The interval has been removed locally; no-op.
+            return;
+        }
+
+        if (local) {
+            // Let the propertyManager prune its pending change-properties set.
+            interval.propertyManager?.ackPendingProperties(
+                {
+                    type: MergeTreeDeltaType.ANNOTATE,
+                    props: serializedInterval.properties ?? {},
+                });
+
+            this.ackInterval(interval, op);
         } 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.
-            // Note that the ID is in the property bag only to allow us to find the interval.
-            // This API cannot change the ID, and writing to the ID property will result in an exception. So we
-            // strip it out of the properties here.
-            const { [reservedIntervalIdKey]: id, ...newProps } = serializedInterval.properties;
-            interval = this.getIntervalById(id);
-            if (interval) {
-                let start: number | undefined;
-                let end: number | undefined;
-                // Track pending start/end independently of one another.
-                if (!this.hasPendingChangeStart(id)) {
-                    start = serializedInterval.start;
-                }
-                if (!this.hasPendingChangeEnd(id)) {
-                    end = serializedInterval.end;
-                }
-                if (start !== undefined || end !== undefined) {
-                    // If changeInterval gives us a new interval, work with that one. Otherwise keep working with
-                    // the one we originally found in the tree.
-                    interval = this.localCollection.changeInterval(interval, start, end, op) ?? interval;
-                }
-                const deltaProps = interval.addProperties(newProps, true, op.sequenceNumber);
-                if (this.onDeserialize) {
-                    this.onDeserialize(interval);
-                }
-                this.emit("propertyChanged", interval, deltaProps);
+            let start: number | undefined;
+            let end: number | undefined;
+            // Track pending start/end independently of one another.
+            if (!this.hasPendingChangeStart(id)) {
+                start = serializedInterval.start;
+            }
+            if (!this.hasPendingChangeEnd(id)) {
+                end = serializedInterval.end;
+            }
+
+            let newInterval = interval;
+            if (start !== undefined || end !== undefined) {
+                // 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;
+            }
+            const deltaProps = newInterval.addProperties(newProps, true, op.sequenceNumber);
+            if (this.onDeserialize) {
+                this.onDeserialize(newInterval);
+            }
+
+            if (newInterval !== interval) {
+                this.emitChange(newInterval, interval, local, op);
+            }
+
+            const changedProperties = Object.keys(newProps).length > 0;
+            if (changedProperties) {
+                this.emit("propertyChanged", interval, deltaProps, local, op);
             }
-        }
-        if (interval) {
-            this.emit("changeInterval", interval, local, op);
         }
     }
 
     public addConflictResolver(conflictResolver: IntervalConflictResolver<TInterval>): void {
-        if (!this.attached) {
+        if (!this.localCollection) {
             throw new LoggingError("attachSequence must be called");
         }
         this.localCollection.addConflictResolver(conflictResolver);
@@ -1436,7 +1720,7 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
         this.onDeserialize = onDeserialize;
 
         // Trigger the async prepare work across all values in the collection
-        this.localCollection.map((interval) => {
+        this.localCollection?.map((interval) => {
             onDeserialize(interval);
         });
     }
@@ -1450,9 +1734,9 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
      */
     public rebaseLocalInterval(
         opName: string,
-        serializedInterval: ISerializedInterval,
+        serializedInterval: SerializedIntervalDelta,
         localSeq: number,
-    ): ISerializedInterval | undefined {
+    ): SerializedIntervalDelta | undefined {
         if (!this.client) {
             // If there's no associated mergeTree client, the originally submitted op is still correct.
             return serializedInterval;
@@ -1468,9 +1752,9 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
             this.client.rebasePosition(end, sequenceNumber, localSeq);
 
         const intervalId = properties?.[reservedIntervalIdKey];
-        const localInterval = this.localCollection.getIntervalById(intervalId);
+        const localInterval = this.localCollection?.getIntervalById(intervalId);
 
-        const rebased: ISerializedInterval = {
+        const rebased: SerializedIntervalDelta = {
             start: startRebased,
             end: endRebased,
             intervalType,
@@ -1487,7 +1771,7 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
         // delete the interval
         if (startRebased === DetachedReferencePosition || endRebased === DetachedReferencePosition) {
             if (localInterval) {
-                this.localCollection.removeExistingInterval(localInterval);
+                this.localCollection?.removeExistingInterval(localInterval);
             }
             return undefined;
         }
@@ -1508,18 +1792,24 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
         // we need to slide because the reference has been removed
         if (startSegment || endSegment) {
             const newStart =
-                startSegment && this.client.getPosition(startSegment.segment, localSeq) + startSegment.offset;
+                startSegment && this.client.getPosition(startSegment.segment, localSeq) + (startSegment.offset ?? 0);
             const newEnd =
-                endSegment && this.client.getPosition(endSegment.segment, localSeq) + endSegment.offset;
+                endSegment && this.client.getPosition(endSegment.segment, localSeq) + (endSegment.offset ?? 0);
 
-            this.localCollection.changeInterval(localInterval, newStart, newEnd, undefined, localSeq);
+            this.localCollection?.changeInterval(localInterval, newStart, newEnd, undefined, localSeq);
         }
 
         return rebased;
     }
 
     private getSlideToSegment(lref: LocalReferencePosition) {
+        if (!this.client) {
+            throw new LoggingError("client does not exist");
+        }
         const segoff = { segment: lref.getSegment(), offset: lref.getOffset() };
+        if (segoff.segment?.localRefs?.has(lref) !== true) {
+            return undefined;
+        }
         const newSegoff = this.client.getSlideToSegment(segoff);
         const value: { segment: ISegment | undefined; offset: number | undefined; } | undefined
             = (segoff.segment === newSegoff.segment && segoff.offset === newSegoff.offset) ? undefined : newSegoff;
@@ -1563,28 +1853,51 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
         const needsEndUpdate = newEnd !== undefined && !hasPendingEndChange;
 
         if (needsStartUpdate || needsEndUpdate) {
+            if (!this.localCollection) {
+                throw new LoggingError("Attach must be called before accessing intervals");
+            }
+
+            // `interval`'s endpoints will get modified in-place, so clone it prior to doing so for event emission.
+            const oldInterval = interval.clone() as TInterval & SequenceInterval;
+
             // In this case, where we change the start or end of an interval,
             // it is necessary to remove and re-add the interval listeners.
             // This ensures that the correct listeners are added to the LocalReferencePosition.
             this.localCollection.removeExistingInterval(interval);
+            if (!this.client) {
+                throw new LoggingError("client does not exist");
+            }
 
             if (needsStartUpdate) {
                 const props = interval.start.properties;
-                this.client.removeLocalReferencePosition(interval.start);
                 interval.start = createPositionReferenceFromSegoff(this.client, newStart, interval.start.refType, op);
                 if (props) {
                     interval.start.addProperties(props);
                 }
+                const oldSeg = oldInterval.start.getSegment();
+                // remove and rebuild start interval as transient for event
+                this.client.removeLocalReferencePosition(oldInterval.start);
+                oldInterval.start.refType = ReferenceType.Transient;
+                oldSeg?.localRefs?.addLocalRef(
+                    oldInterval.start,
+                    oldInterval.start.getOffset());
             }
             if (needsEndUpdate) {
                 const props = interval.end.properties;
-                this.client.removeLocalReferencePosition(interval.end);
                 interval.end = createPositionReferenceFromSegoff(this.client, newEnd, interval.end.refType, op);
                 if (props) {
                     interval.end.addProperties(props);
                 }
+                // remove and rebuild end interval as transient for event
+                const oldSeg = oldInterval.end.getSegment();
+                this.client.removeLocalReferencePosition(oldInterval.end);
+                oldInterval.end.refType = ReferenceType.Transient;
+                oldSeg?.localRefs?.addLocalRef(
+                    oldInterval.end,
+                    oldInterval.end.getOffset());
             }
             this.localCollection.add(interval);
+            this.emitChange(interval, oldInterval as TInterval, true, op);
         }
     }
 
@@ -1602,7 +1915,7 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
             return;
         }
 
-        if (!this.attached) {
+        if (!this.localCollection) {
             throw new LoggingError("attachSequence must be called");
         }
 
@@ -1638,7 +1951,7 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
             return;
         }
 
-        if (!this.attached) {
+        if (!this.localCollection) {
             throw new LoggingError("attach must be called prior to deleting intervals");
         }
 
@@ -1653,76 +1966,106 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
      * @internal
      */
     public serializeInternal(): ISerializedIntervalCollectionV2 {
-        if (!this.attached) {
+        if (!this.localCollection) {
             throw new LoggingError("attachSequence must be called");
         }
 
         return this.localCollection.serialize();
     }
 
+    /**
+     * @returns an iterator over all intervals in this collection.
+     */
     public [Symbol.iterator](): IntervalCollectionIterator<TInterval> {
         const iterator = new IntervalCollectionIterator<TInterval>(this);
         return iterator;
     }
 
+    /**
+     * @returns a forward iterator over all intervals in this collection with start point equal to `startPosition`.
+     */
     public CreateForwardIteratorWithStartPosition(startPosition: number): IntervalCollectionIterator<TInterval> {
         const iterator = new IntervalCollectionIterator<TInterval>(this, true, startPosition);
         return iterator;
     }
 
+    /**
+     * @returns a backward iterator over all intervals in this collection with start point equal to `startPosition`.
+     */
     public CreateBackwardIteratorWithStartPosition(startPosition: number): IntervalCollectionIterator<TInterval> {
         const iterator = new IntervalCollectionIterator<TInterval>(this, false, startPosition);
         return iterator;
     }
 
+    /**
+     * @returns a forward iterator over all intervals in this collection with end point equal to `endPosition`.
+     */
     public CreateForwardIteratorWithEndPosition(endPosition: number): IntervalCollectionIterator<TInterval> {
         const iterator = new IntervalCollectionIterator<TInterval>(this, true, undefined, endPosition);
         return iterator;
     }
 
+    /**
+     * @returns a backward iterator over all intervals in this collection with end point equal to `endPosition`.
+     */
     public CreateBackwardIteratorWithEndPosition(endPosition: number): IntervalCollectionIterator<TInterval> {
         const iterator = new IntervalCollectionIterator<TInterval>(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`.
+     */
     public gatherIterationResults(
         results: TInterval[],
         iteratesForward: boolean,
         start?: number,
         end?: number) {
-        if (!this.attached) {
+        if (!this.localCollection) {
             return;
         }
 
         this.localCollection.gatherIterationResults(results, iteratesForward, start, end);
     }
 
+    /**
+     * @returns an array of all intervals in this collection that overlap with the interval
+     * `[startPosition, endPosition]`.
+     */
     public findOverlappingIntervals(startPosition: number, endPosition: number): TInterval[] {
-        if (!this.attached) {
+        if (!this.localCollection) {
             throw new LoggingError("attachSequence must be called");
         }
 
         return this.localCollection.findOverlappingIntervals(startPosition, endPosition);
     }
 
+    /**
+     * Applies a function to each interval in this collection.
+     */
     public map(fn: (interval: TInterval) => void) {
-        if (!this.attached) {
+        if (!this.localCollection) {
             throw new LoggingError("attachSequence must be called");
         }
 
         this.localCollection.map(fn);
     }
 
-    public previousInterval(pos: number): TInterval {
-        if (!this.attached) {
+    public previousInterval(pos: number): TInterval | undefined {
+        if (!this.localCollection) {
             throw new LoggingError("attachSequence must be called");
         }
 
         return this.localCollection.previousInterval(pos);
     }
 
-    public nextInterval(pos: number): TInterval {
-        if (!this.attached) {
+    public nextInterval(pos: number): TInterval | undefined {
+        if (!this.localCollection) {
             throw new LoggingError("attachSequence must be called");
         }