@fluidframework/sequence 1.4.0-121020 → 2.0.0-dev-rc.1.0.0.224419

package/lib/{sequence.js → sequence.mjs}

@@ -2,77 +2,30 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-import { Deferred, bufferToString, assert } from "@fluidframework/common-utils";
-import { ChildLogger } from "@fluidframework/telemetry-utils";
-import { MessageType, } from "@fluidframework/protocol-definitions";
-import { Client, createAnnotateRangeOp, createGroupOp, createInsertOp, createRemoveRangeOp, LocalReference, matchProperties, MergeTreeDeltaType, ReferenceType, } from "@fluidframework/merge-tree";
+import { assert, Deferred } from "@fluidframework/core-utils";
+import { bufferToString } from "@fluid-internal/client-utils";
+import { LoggingError, createChildLogger } from "@fluidframework/telemetry-utils";
+import { MessageType } from "@fluidframework/protocol-definitions";
+import { 
+// eslint-disable-next-line import/no-deprecated
+Client, createAnnotateRangeOp, 
+// eslint-disable-next-line import/no-deprecated
+createGroupOp, createInsertOp, createRemoveRangeOp, matchProperties, MergeTreeDeltaType, createObliterateRangeOp, } from "@fluidframework/merge-tree";
 import { ObjectStoragePartition, SummaryTreeBuilder } from "@fluidframework/runtime-utils";
 import { makeHandlesSerializable, parseHandles, SharedObject, } from "@fluidframework/shared-object-base";
-import { SequenceIntervalCollectionValueType, } from "./intervalCollection";
-import { DefaultMap } from "./defaultMap";
-import { SequenceDeltaEvent, SequenceMaintenanceEvent } from "./sequenceDeltaEvent";
+import { DefaultMap } from "./defaultMap.mjs";
+import { SequenceIntervalCollectionValueType, } from "./intervalCollection.mjs";
+import { SequenceDeltaEvent, SequenceMaintenanceEvent } from "./sequenceDeltaEvent.mjs";
 const snapshotFileName = "header";
 const contentPath = "content";
+/**
+ * @alpha
+ */
 export class SharedSegmentSequence extends SharedObject {
-    constructor(dataStoreRuntime, id, attributes, segmentFromSpec) {
-        super(id, dataStoreRuntime, attributes, "fluid_sequence_");
-        this.dataStoreRuntime = dataStoreRuntime;
-        this.id = id;
-        this.segmentFromSpec = segmentFromSpec;
-        // Deferred that triggers once the object is loaded
-        this.loadedDeferred = new Deferred();
-        // cache out going ops created when partial loading
-        this.loadedDeferredOutgoingOps = [];
-        // cache incoming ops that arrive when partial loading
-        this.deferIncomingOps = true;
-        this.loadedDeferredIncomingOps = [];
-        this.messagesSinceMSNChange = [];
-        this.loadedDeferred.promise.catch((error) => {
-            this.logger.sendErrorEvent({ eventName: "SequenceLoadFailed" }, error);
-        });
-        this.client = new Client(segmentFromSpec, ChildLogger.create(this.logger, "SharedSegmentSequence.MergeTreeClient"), dataStoreRuntime.options);
-        super.on("newListener", (event) => {
-            switch (event) {
-                case "sequenceDelta":
-                    if (!this.client.mergeTreeDeltaCallback) {
-                        this.client.mergeTreeDeltaCallback = (opArgs, deltaArgs) => {
-                            this.emit("sequenceDelta", new SequenceDeltaEvent(opArgs, deltaArgs, this.client), this);
-                        };
-                    }
-                    break;
-                case "maintenance":
-                    if (!this.client.mergeTreeMaintenanceCallback) {
-                        this.client.mergeTreeMaintenanceCallback = (args, opArgs) => {
-                            this.emit("maintenance", new SequenceMaintenanceEvent(opArgs, args, this.client), this);
-                        };
-                    }
-                    break;
-                default:
-            }
-        });
-        super.on("removeListener", (event) => {
-            switch (event) {
-                case "sequenceDelta":
-                    if (super.listenerCount(event) === 0) {
-                        this.client.mergeTreeDeltaCallback = undefined;
-                    }
-                    break;
-                case "maintenance":
-                    if (super.listenerCount(event) === 0) {
-                        this.client.mergeTreeMaintenanceCallback = undefined;
-                    }
-                    break;
-                default:
-                    break;
-            }
-        });
-        this.intervalCollections = new DefaultMap(this.serializer, this.handle, (op, localOpMetadata) => this.submitLocalMessage(op, localOpMetadata), new SequenceIntervalCollectionValueType());
-    }
     get loaded() {
         return this.loadedDeferred.promise;
     }
     static createOpsFromDelta(event) {
-        var _a, _b;
         const ops = [];
         for (const r of event.ranges) {
             switch (event.deltaOperation) {
@@ -80,14 +33,15 @@ export class SharedSegmentSequence extends SharedObject {
                     const lastAnnotate = ops[ops.length - 1];
                     const props = {};
                     for (const key of Object.keys(r.propertyDeltas)) {
-                        props[key] = (_b = (_a = r.segment.properties) === null || _a === void 0 ? void 0 : _a[key]) !== null && _b !== void 0 ? _b : null;
+                        props[key] = r.segment.properties?.[key] ?? null;
                     }
-                    if (lastAnnotate && lastAnnotate.pos2 === r.position &&
+                    if (lastAnnotate &&
+                        lastAnnotate.pos2 === r.position &&
                         matchProperties(lastAnnotate.props, props)) {
                         lastAnnotate.pos2 += r.segment.cachedLength;
                     }
                     else {
-                        ops.push(createAnnotateRangeOp(r.position, r.position + r.segment.cachedLength, props, undefined));
+                        ops.push(createAnnotateRangeOp(r.position, r.position + r.segment.cachedLength, props));
                     }
                     break;
                 }
@@ -96,7 +50,8 @@ export class SharedSegmentSequence extends SharedObject {
                     break;
                 case MergeTreeDeltaType.REMOVE: {
                     const lastRem = ops[ops.length - 1];
-                    if ((lastRem === null || lastRem === void 0 ? void 0 : lastRem.pos1) === r.position) {
+                    if (lastRem?.pos1 === r.position) {
+                        assert(lastRem.pos2 !== undefined, 0x3ff /* pos2 should not be undefined here */);
                         lastRem.pos2 += r.segment.cachedLength;
                     }
                     else {
@@ -104,26 +59,94 @@ export class SharedSegmentSequence extends SharedObject {
                     }
                     break;
                 }
+                case MergeTreeDeltaType.OBLITERATE: {
+                    const lastRem = ops[ops.length - 1];
+                    if (lastRem?.pos1 === r.position) {
+                        assert(lastRem.pos2 !== undefined, 0x874 /* pos2 should not be undefined here */);
+                        lastRem.pos2 += r.segment.cachedLength;
+                    }
+                    else {
+                        ops.push(createObliterateRangeOp(r.position, r.position + r.segment.cachedLength));
+                    }
+                    break;
+                }
                 default:
             }
         }
         return ops;
     }
+    constructor(dataStoreRuntime, id, attributes, segmentFromSpec) {
+        super(id, dataStoreRuntime, attributes, "fluid_sequence_");
+        this.dataStoreRuntime = dataStoreRuntime;
+        this.id = id;
+        this.segmentFromSpec = segmentFromSpec;
+        /** `Deferred` that triggers once the object is loaded */
+        this.loadedDeferred = new Deferred();
+        // cache out going ops created when partial loading
+        this.loadedDeferredOutgoingOps = [];
+        // cache incoming ops that arrive when partial loading
+        this.deferIncomingOps = true;
+        this.loadedDeferredIncomingOps = [];
+        this.messagesSinceMSNChange = [];
+        this.guardReentrancy =
+            dataStoreRuntime.options.sharedStringPreventReentrancy ?? true
+                ? ensureNoReentrancy
+                : createReentrancyDetector((depth) => {
+                    if (totalReentrancyLogs > 0) {
+                        totalReentrancyLogs--;
+                        this.logger.sendTelemetryEvent({ eventName: "LocalOpReentry", depth }, new LoggingError(reentrancyErrorMessage));
+                    }
+                });
+        this.loadedDeferred.promise.catch((error) => {
+            this.logger.sendErrorEvent({ eventName: "SequenceLoadFailed" }, error);
+        });
+        // eslint-disable-next-line import/no-deprecated
+        this.client = new Client(segmentFromSpec, createChildLogger({
+            logger: this.logger,
+            namespace: "SharedSegmentSequence.MergeTreeClient",
+        }), dataStoreRuntime.options);
+        this.client.prependListener("delta", (opArgs, deltaArgs) => {
+            const event = new SequenceDeltaEvent(opArgs, deltaArgs, this.client);
+            if (opArgs.stashed !== true && event.isLocal) {
+                this.submitSequenceMessage(opArgs.op);
+            }
+            this.emit("sequenceDelta", event, this);
+        });
+        this.client.on("maintenance", (args, opArgs) => {
+            this.emit("maintenance", new SequenceMaintenanceEvent(opArgs, args, this.client), this);
+        });
+        this.intervalCollections = new DefaultMap(this.serializer, this.handle, (op, localOpMetadata) => this.submitLocalMessage(op, localOpMetadata), new SequenceIntervalCollectionValueType(), dataStoreRuntime.options);
+    }
     /**
      * @param start - The inclusive start of the range to remove
      * @param end - The exclusive end of the range to remove
      */
     removeRange(start, end) {
-        const removeOp = this.client.removeRangeLocal(start, end);
-        if (removeOp) {
-            this.submitSequenceMessage(removeOp);
-        }
-        return removeOp;
+        this.guardReentrancy(() => this.client.removeRangeLocal(start, end));
     }
+    /**
+     * Obliterate is similar to remove, but differs in that segments concurrently
+     * inserted into an obliterated range will also be removed
+     *
+     * @param start - The inclusive start of the range to obliterate
+     * @param end - The exclusive end of the range to obliterate
+     */
+    obliterateRange(start, end) {
+        this.guardReentrancy(() => this.client.obliterateRangeLocal(start, end));
+    }
+    /**
+     * @deprecated The ability to create group ops will be removed in an upcoming
+     * release, as group ops are redundant with the native batching capabilities
+     * of the runtime
+     */
     groupOperation(groupOp) {
-        this.client.localTransaction(groupOp);
-        this.submitSequenceMessage(groupOp);
+        this.guardReentrancy(() => this.client.localTransaction(groupOp));
     }
+    /**
+     * Finds the segment information (i.e. segment + offset) corresponding to a character position in the SharedString.
+     * If the position is past the end of the string, `segment` and `offset` on the returned object may be undefined.
+     * @param pos - Character position (index) into the current local view of the SharedString.
+     */
     getContainingSegment(pos) {
         return this.client.getContainingSegment(pos);
     }
@@ -147,14 +170,10 @@ export class SharedSegmentSequence extends SharedObject {
      * @param start - The inclusive start position of the range to annotate
      * @param end - The exclusive end position of the range to annotate
      * @param props - The properties to annotate the range with
-     * @param combiningOp - Optional. Specifies how to combine values for the property, such as "incr" for increment.
      *
      */
-    annotateRange(start, end, props, combiningOp) {
-        const annotateOp = this.client.annotateRangeLocal(start, end, props, combiningOp);
-        if (annotateOp) {
-            this.submitSequenceMessage(annotateOp);
-        }
+    annotateRange(start, end, props) {
+        this.guardReentrancy(() => this.client.annotateRangeLocal(start, end, props));
     }
     getPropertiesAtPosition(pos) {
         return this.client.getPropertiesAtPosition(pos);
@@ -163,27 +182,28 @@ export class SharedSegmentSequence extends SharedObject {
         return this.client.getRangeExtentsOfPosition(pos);
     }
     /**
-     * @deprecated - use createLocalReferencePosition
+     * Creates a `LocalReferencePosition` on this SharedString. If the refType does not include
+     * ReferenceType.Transient, the returned reference will be added to the localRefs on the provided segment.
+     * @param segment - Segment to add the local reference on
+     * @param offset - Offset on the segment at which to place the local reference
+     * @param refType - ReferenceType for the created local reference
+     * @param properties - PropertySet to place on the created local reference
      */
-    createPositionReference(segment, offset, refType) {
-        const lref = new LocalReference(this.client, segment, offset, refType);
-        if (refType !== ReferenceType.Transient) {
-            this.addLocalReference(lref);
-        }
-        return lref;
-    }
-    createLocalReferencePosition(segment, offset, refType, properties) {
-        return this.client.createLocalReferencePosition(segment, offset, refType, properties);
+    createLocalReferencePosition(segment, offset, refType, properties, slidingPreference, canSlideToEndpoint) {
+        return this.client.createLocalReferencePosition(segment, offset, refType, properties, slidingPreference, canSlideToEndpoint);
     }
     /**
-     * @deprecated - use localReferencePositionToPosition
+     * Resolves a `ReferencePosition` into a character position using this client's perspective.
      */
-    localRefToPos(localRef) {
-        return this.client.localReferencePositionToPosition(localRef);
-    }
     localReferencePositionToPosition(lref) {
         return this.client.localReferencePositionToPosition(lref);
     }
+    /**
+     * Removes a `LocalReferencePosition` from this SharedString.
+     */
+    removeLocalReferencePosition(lref) {
+        return this.client.removeLocalReferencePosition(lref);
+    }
     /**
      * Resolves a remote client's position against the local sequence
      * and returns the remote client's position relative to the local
@@ -209,29 +229,14 @@ export class SharedSegmentSequence extends SharedObject {
         const metadata = this.client.peekPendingSegmentGroups(message.type === MergeTreeDeltaType.GROUP ? message.ops.length : 1);
         // if loading isn't complete, we need to cache
         // local ops until loading is complete, and then
-        // they will be resent
+        // they will be present
         if (!this.loadedDeferred.isCompleted) {
-            this.loadedDeferredOutgoingOps.push([translated, metadata]);
+            this.loadedDeferredOutgoingOps.push(metadata ? [translated, metadata] : translated);
         }
         else {
             this.submitLocalMessage(translated, metadata);
         }
     }
-    /**
-     * @deprecated - use createLocalReferencePosition
-     */
-    addLocalReference(lref) {
-        return this.client.addLocalReference(lref);
-    }
-    /**
-     * @deprecated - use removeLocalReferencePosition
-     */
-    removeLocalReference(lref) {
-        return this.client.removeLocalReferencePosition(lref);
-    }
-    removeLocalReferencePosition(lref) {
-        return this.client.removeLocalReferencePosition(lref);
-    }
     /**
      * Given a position specified relative to a marker id, lookup the marker
      * and convert the position to a character position.
@@ -242,53 +247,70 @@ export class SharedSegmentSequence extends SharedObject {
     }
     /**
      * Walk the underlying segments of the sequence.
-     * The walked segments may extend beyond the range
-     * if the segments cross the ranges start or end boundaries.
-     * Set split range to true to ensure only segments within the
-     * range are walked.
+     * The walked segments may extend beyond the range if the segments cross the
+     * ranges start or end boundaries.
      *
-     * @param handler - The function to handle each segment
+     * Set split range to true to ensure only segments within the range are walked.
+     *
+     * @param handler - The function to handle each segment. Traversal ends if
+     * this function returns true.
      * @param start - Optional. The start of range walk.
      * @param end - Optional. The end of range walk
      * @param accum - Optional. An object that will be passed to the handler for accumulation
      * @param splitRange - Optional. Splits boundary segments on the range boundaries
      */
     walkSegments(handler, start, end, accum, splitRange = false) {
-        return this.client.walkSegments(handler, start, end, accum, splitRange);
-    }
-    getStackContext(startPos, rangeLabels) {
-        return this.client.getStackContext(startPos, rangeLabels);
+        this.client.walkSegments(handler, start, end, accum, splitRange);
     }
+    /**
+     * @returns The most recent sequence number which has been acked by the server and processed by this
+     * SharedSegmentSequence.
+     */
     getCurrentSeq() {
         return this.client.getCurrentSeq();
     }
+    /**
+     * Inserts a segment directly before a `ReferencePosition`.
+     * @param refPos - The reference position to insert the segment at
+     * @param segment - The segment to insert
+     */
     insertAtReferencePosition(pos, segment) {
-        const insertOp = this.client.insertAtReferencePositionLocal(pos, segment);
-        if (insertOp) {
-            this.submitSequenceMessage(insertOp);
-        }
+        this.guardReentrancy(() => this.client.insertAtReferencePositionLocal(pos, segment));
     }
     /**
-     * @deprecated - IntervalCollections are created on a first-write wins basis, and concurrent creates
-     * are supported. Use `getIntervalCollection` instead.
+     * Inserts a segment
+     * @param start - The position to insert the segment at
+     * @param spec - The segment to inserts spec
      */
-    async waitIntervalCollection(label) {
-        return this.intervalCollections.get(label);
+    insertFromSpec(pos, spec) {
+        const segment = this.segmentFromSpec(spec);
+        this.guardReentrancy(() => this.client.insertSegmentLocal(pos, segment));
     }
+    /**
+     * Retrieves the interval collection keyed on `label`. If no such interval collection exists,
+     * creates one.
+     */
     getIntervalCollection(label) {
         return this.intervalCollections.get(label);
     }
     /**
-     * @returns an iterable object that enumerates the IntervalCollection labels
-     * Usage:
+     * @returns An iterable object that enumerates the IntervalCollection labels.
+     *
+     * @example
+     *
+     * ```typescript
      * const iter = this.getIntervalCollectionKeys();
      * for (key of iter)
      *     const collection = this.getIntervalCollection(key);
      *     ...
-    */
+     * ```
+     */
     getIntervalCollectionLabels() {
         return this.intervalCollections.keys();
     }
+    /**
+     * {@inheritDoc @fluidframework/shared-object-base#SharedObject.summarizeCore}
+     */
     summarizeCore(serializer, telemetryContext) {
         const builder = new SummaryTreeBuilder();
         // conditionally write the interval collection blob
@@ -325,19 +347,24 @@ export class SharedSegmentSequence extends SharedObject {
         const insert = this.client.insertSegmentLocal(insertIndex, segment);
         if (insert) {
             if (start < end) {
-                const remove = this.client.removeRangeLocal(start, end);
-                this.submitSequenceMessage(createGroupOp(insert, remove));
-            }
-            else {
-                this.submitSequenceMessage(insert);
+                this.client.removeRangeLocal(start, end);
             }
         }
     }
+    /**
+     * {@inheritDoc @fluidframework/shared-object-base#SharedObject.onConnect}
+     */
     onConnect() {
         // Update merge tree collaboration information with new client ID and then resend pending ops
         this.client.startOrUpdateCollaboration(this.runtime.clientId);
     }
+    /**
+     * {@inheritDoc @fluidframework/shared-object-base#SharedObject.onDisconnect}
+     */
     onDisconnect() { }
+    /**
+     * {@inheritDoc @fluidframework/shared-object-base#SharedObject.reSubmitCore}
+     */
     reSubmitCore(content, localOpMetadata) {
         if (!this.intervalCollections.tryResubmitMessage(content, localOpMetadata)) {
             this.submitSequenceMessage(this.client.regeneratePendingOp(content, localOpMetadata));
@@ -347,7 +374,6 @@ export class SharedSegmentSequence extends SharedObject {
      * {@inheritDoc @fluidframework/shared-object-base#SharedObject.loadCore}
      */
     async loadCore(storage) {
-        var _a;
         if (await storage.contains(snapshotFileName)) {
             const blob = await storage.readBlob(snapshotFileName);
             const header = bufferToString(blob, "utf8");
@@ -364,10 +390,11 @@ export class SharedSegmentSequence extends SharedObject {
                 .then((msgs) => {
                 msgs.forEach((m) => {
                     const collabWindow = this.client.getCollabWindow();
-                    if (m.minimumSequenceNumber < collabWindow.minSeq
-                        || m.referenceSequenceNumber < collabWindow.minSeq
-                        || m.sequenceNumber <= collabWindow.minSeq
-                        || m.sequenceNumber <= collabWindow.currentSeq) {
+                    if (m.minimumSequenceNumber < collabWindow.minSeq ||
+                        m.referenceSequenceNumber < collabWindow.minSeq ||
+                        m.sequenceNumber <= collabWindow.minSeq ||
+                        // sequenceNumber could be the same if messages are part of a grouped batch
+                        m.sequenceNumber < collabWindow.currentSeq) {
                         throw new Error(`Invalid catchup operations in snapshot: ${JSON.stringify({
                             op: {
                                 seq: m.sequenceNumber,
@@ -387,7 +414,7 @@ export class SharedSegmentSequence extends SharedObject {
                 .catch((error) => {
                 this.loadFinished(error);
             });
-            if (((_a = this.dataStoreRuntime.options) === null || _a === void 0 ? void 0 : _a.sequenceInitializeFromHeaderOnly) !== true) {
+            if (this.dataStoreRuntime.options?.sequenceInitializeFromHeaderOnly !== true) {
                 // if we not doing partial load, await the catch up ops,
                 // and the finalization of the load
                 await loadCatchUpOps;
@@ -397,6 +424,9 @@ export class SharedSegmentSequence extends SharedObject {
             this.loadFinished(error);
         }
     }
+    /**
+     * {@inheritDoc @fluidframework/shared-object-base#SharedObject.processCore}
+     */
     processCore(message, local, localOpMetadata) {
         // if loading isn't complete, we need to cache all
         // incoming ops to be applied after loading is complete
@@ -412,14 +442,19 @@ export class SharedSegmentSequence extends SharedObject {
             }
         }
     }
+    /**
+     * {@inheritDoc @fluidframework/shared-object-base#SharedObject.didAttach}
+     */
     didAttach() {
-        var _a;
         // If we are not local, and we've attached we need to start generating and sending ops
         // so start collaboration and provide a default client id incase we are not connected
         if (this.isAttached()) {
-            this.client.startOrUpdateCollaboration((_a = this.runtime.clientId) !== null && _a !== void 0 ? _a : "attached");
+            this.client.startOrUpdateCollaboration(this.runtime.clientId ?? "attached");
         }
     }
+    /**
+     * {@inheritDoc @fluidframework/shared-object-base#SharedObject.initializeLocalCore}
+     */
     initializeLocalCore() {
         super.initializeLocalCore();
         this.loadFinished();
@@ -428,18 +463,19 @@ export class SharedSegmentSequence extends SharedObject {
      * {@inheritDoc @fluidframework/shared-object-base#SharedObjectCore.applyStashedOp}
      */
     applyStashedOp(content) {
-        return this.client.applyStashedOp(content);
+        return this.client.applyStashedOp(parseHandles(content, this.serializer));
     }
     summarizeMergeTree(serializer) {
         // Are we fully loaded? If not, things will go south
         assert(this.loadedDeferred.isCompleted, 0x074 /* "Snapshot called when not fully loaded" */);
         const minSeq = this.runtime.deltaManager.minimumSequenceNumber;
         this.processMinSequenceNumberChanged(minSeq);
-        this.messagesSinceMSNChange.forEach((m) => { m.minimumSequenceNumber = minSeq; });
+        this.messagesSinceMSNChange.forEach((m) => {
+            m.minimumSequenceNumber = minSeq;
+        });
         return this.client.summarize(this.runtime, this.handle, serializer, this.messagesSinceMSNChange);
     }
     processMergeTreeMsg(rawMessage, local) {
-        var _a, _b;
         const message = parseHandles(rawMessage, this.serializer);
         const ops = [];
         function transformOps(event) {
@@ -447,23 +483,28 @@ export class SharedSegmentSequence extends SharedObject {
         }
         const needsTransformation = message.referenceSequenceNumber !== message.sequenceNumber - 1;
         let stashMessage = message;
-        if (((_a = this.runtime.options) === null || _a === void 0 ? void 0 : _a.newMergeTreeSnapshotFormat) !== true) {
+        if (this.runtime.options?.newMergeTreeSnapshotFormat !== true) {
             if (needsTransformation) {
                 this.on("sequenceDelta", transformOps);
             }
         }
         this.client.applyMsg(message, local);
-        if (((_b = this.runtime.options) === null || _b === void 0 ? void 0 : _b.newMergeTreeSnapshotFormat) !== true) {
+        if (this.runtime.options?.newMergeTreeSnapshotFormat !== true) {
             if (needsTransformation) {
                 this.removeListener("sequenceDelta", transformOps);
                 // shallow clone the message as we only overwrite top level properties,
                 // like referenceSequenceNumber and content only
-                stashMessage = Object.assign(Object.assign({}, message), { referenceSequenceNumber: stashMessage.sequenceNumber - 1, contents: ops.length !== 1 ? createGroupOp(...ops) : ops[0] });
+                stashMessage = {
+                    ...message,
+                    referenceSequenceNumber: stashMessage.sequenceNumber - 1,
+                    // eslint-disable-next-line import/no-deprecated
+                    contents: ops.length !== 1 ? createGroupOp(...ops) : ops[0],
+                };
             }
             this.messagesSinceMSNChange.push(stashMessage);
             // Do GC every once in a while...
-            if (this.messagesSinceMSNChange.length > 20
-                && this.messagesSinceMSNChange[20].sequenceNumber < message.minimumSequenceNumber) {
+            if (this.messagesSinceMSNChange.length > 20 &&
+                this.messagesSinceMSNChange[20].sequenceNumber < message.minimumSequenceNumber) {
                 this.processMinSequenceNumberChanged(message.minimumSequenceNumber);
             }
         }
@@ -523,4 +564,36 @@ export class SharedSegmentSequence extends SharedObject {
         }
     }
 }
-//# sourceMappingURL=sequence.js.map
+function createReentrancyDetector(onReentrancy) {
+    let depth = 0;
+    function detectReentrancy(callback) {
+        if (depth > 0) {
+            onReentrancy(depth);
+        }
+        depth++;
+        try {
+            return callback();
+        }
+        finally {
+            depth--;
+        }
+    }
+    return detectReentrancy;
+}
+/**
+ * Apps which generate reentrant behavior may do so at a high frequency.
+ * Logging even per-SharedSegmentSequence instance might be too noisy, and having a few logs from a session
+ * is likely enough.
+ */
+let totalReentrancyLogs = 3;
+/**
+ * Resets the reentrancy log counter. Test-only API.
+ */
+export function resetReentrancyLogCounter() {
+    totalReentrancyLogs = 3;
+}
+const reentrancyErrorMessage = "Reentrancy detected in sequence local ops";
+const ensureNoReentrancy = createReentrancyDetector(() => {
+    throw new LoggingError(reentrancyErrorMessage);
+});
+//# sourceMappingURL=sequence.mjs.map