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

package/dist/{sequence.js → sequence.cjs}

@@ -1,81 +1,30 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SharedSegmentSequence = void 0;
 /*!
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-const common_utils_1 = require("@fluidframework/common-utils");
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resetReentrancyLogCounter = exports.SharedSegmentSequence = void 0;
+const core_utils_1 = require("@fluidframework/core-utils");
+const client_utils_1 = require("@fluid-internal/client-utils");
 const telemetry_utils_1 = require("@fluidframework/telemetry-utils");
 const protocol_definitions_1 = require("@fluidframework/protocol-definitions");
 const merge_tree_1 = require("@fluidframework/merge-tree");
 const runtime_utils_1 = require("@fluidframework/runtime-utils");
 const shared_object_base_1 = require("@fluidframework/shared-object-base");
-const intervalCollection_1 = require("./intervalCollection");
-const defaultMap_1 = require("./defaultMap");
-const sequenceDeltaEvent_1 = require("./sequenceDeltaEvent");
+const defaultMap_1 = require("./defaultMap.cjs");
+const intervalCollection_1 = require("./intervalCollection.cjs");
+const sequenceDeltaEvent_1 = require("./sequenceDeltaEvent.cjs");
 const snapshotFileName = "header";
 const contentPath = "content";
+/**
+ * @alpha
+ */
 class SharedSegmentSequence extends shared_object_base_1.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 common_utils_1.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 merge_tree_1.Client(segmentFromSpec, telemetry_utils_1.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_1.SequenceDeltaEvent(opArgs, deltaArgs, this.client), this);
-                        };
-                    }
-                    break;
-                case "maintenance":
-                    if (!this.client.mergeTreeMaintenanceCallback) {
-                        this.client.mergeTreeMaintenanceCallback = (args, opArgs) => {
-                            this.emit("maintenance", new sequenceDeltaEvent_1.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_1.DefaultMap(this.serializer, this.handle, (op, localOpMetadata) => this.submitLocalMessage(op, localOpMetadata), new intervalCollection_1.SequenceIntervalCollectionValueType());
-    }
     get loaded() {
         return this.loadedDeferred.promise;
     }
     static createOpsFromDelta(event) {
-        var _a, _b;
         const ops = [];
         for (const r of event.ranges) {
             switch (event.deltaOperation) {
@@ -83,14 +32,15 @@ class SharedSegmentSequence extends shared_object_base_1.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 &&
                         (0, merge_tree_1.matchProperties)(lastAnnotate.props, props)) {
                         lastAnnotate.pos2 += r.segment.cachedLength;
                     }
                     else {
-                        ops.push((0, merge_tree_1.createAnnotateRangeOp)(r.position, r.position + r.segment.cachedLength, props, undefined));
+                        ops.push((0, merge_tree_1.createAnnotateRangeOp)(r.position, r.position + r.segment.cachedLength, props));
                     }
                     break;
                 }
@@ -99,7 +49,8 @@ class SharedSegmentSequence extends shared_object_base_1.SharedObject {
                     break;
                 case merge_tree_1.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) {
+                        (0, core_utils_1.assert)(lastRem.pos2 !== undefined, 0x3ff /* pos2 should not be undefined here */);
                         lastRem.pos2 += r.segment.cachedLength;
                     }
                     else {
@@ -107,26 +58,94 @@ class SharedSegmentSequence extends shared_object_base_1.SharedObject {
                     }
                     break;
                 }
+                case merge_tree_1.MergeTreeDeltaType.OBLITERATE: {
+                    const lastRem = ops[ops.length - 1];
+                    if (lastRem?.pos1 === r.position) {
+                        (0, core_utils_1.assert)(lastRem.pos2 !== undefined, 0x874 /* pos2 should not be undefined here */);
+                        lastRem.pos2 += r.segment.cachedLength;
+                    }
+                    else {
+                        ops.push((0, merge_tree_1.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 core_utils_1.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 telemetry_utils_1.LoggingError(reentrancyErrorMessage));
+                    }
+                });
+        this.loadedDeferred.promise.catch((error) => {
+            this.logger.sendErrorEvent({ eventName: "SequenceLoadFailed" }, error);
+        });
+        // eslint-disable-next-line import/no-deprecated
+        this.client = new merge_tree_1.Client(segmentFromSpec, (0, telemetry_utils_1.createChildLogger)({
+            logger: this.logger,
+            namespace: "SharedSegmentSequence.MergeTreeClient",
+        }), dataStoreRuntime.options);
+        this.client.prependListener("delta", (opArgs, deltaArgs) => {
+            const event = new sequenceDeltaEvent_1.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 sequenceDeltaEvent_1.SequenceMaintenanceEvent(opArgs, args, this.client), this);
+        });
+        this.intervalCollections = new defaultMap_1.DefaultMap(this.serializer, this.handle, (op, localOpMetadata) => this.submitLocalMessage(op, localOpMetadata), new intervalCollection_1.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);
     }
@@ -150,14 +169,10 @@ class SharedSegmentSequence extends shared_object_base_1.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);
@@ -166,27 +181,28 @@ class SharedSegmentSequence extends shared_object_base_1.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 merge_tree_1.LocalReference(this.client, segment, offset, refType);
-        if (refType !== merge_tree_1.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
@@ -212,29 +228,14 @@ class SharedSegmentSequence extends shared_object_base_1.SharedObject {
         const metadata = this.client.peekPendingSegmentGroups(message.type === merge_tree_1.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.
@@ -245,53 +246,70 @@ class SharedSegmentSequence extends shared_object_base_1.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 runtime_utils_1.SummaryTreeBuilder();
         // conditionally write the interval collection blob
@@ -328,19 +346,24 @@ class SharedSegmentSequence extends shared_object_base_1.SharedObject {
         const insert = this.client.insertSegmentLocal(insertIndex, segment);
         if (insert) {
             if (start < end) {
-                const remove = this.client.removeRangeLocal(start, end);
-                this.submitSequenceMessage((0, merge_tree_1.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));
@@ -350,10 +373,9 @@ class SharedSegmentSequence extends shared_object_base_1.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 = (0, common_utils_1.bufferToString)(blob, "utf8");
+            const header = (0, client_utils_1.bufferToString)(blob, "utf8");
             this.intervalCollections.populate(header);
         }
         try {
@@ -367,10 +389,11 @@ class SharedSegmentSequence extends shared_object_base_1.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,
@@ -390,7 +413,7 @@ class SharedSegmentSequence extends shared_object_base_1.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;
@@ -400,29 +423,37 @@ class SharedSegmentSequence extends shared_object_base_1.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
         if (this.deferIncomingOps) {
-            (0, common_utils_1.assert)(!local, 0x072 /* "Unexpected local op when loading not finished" */);
+            (0, core_utils_1.assert)(!local, 0x072 /* "Unexpected local op when loading not finished" */);
             this.loadedDeferredIncomingOps.push(message);
         }
         else {
-            (0, common_utils_1.assert)(message.type === protocol_definitions_1.MessageType.Operation, 0x073 /* "Sequence message not operation" */);
+            (0, core_utils_1.assert)(message.type === protocol_definitions_1.MessageType.Operation, 0x073 /* "Sequence message not operation" */);
             const handled = this.intervalCollections.tryProcessMessage(message.contents, local, message, localOpMetadata);
             if (!handled) {
                 this.processMergeTreeMsg(message, local);
             }
         }
     }
+    /**
+     * {@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();
@@ -431,18 +462,19 @@ class SharedSegmentSequence extends shared_object_base_1.SharedObject {
      * {@inheritDoc @fluidframework/shared-object-base#SharedObjectCore.applyStashedOp}
      */
     applyStashedOp(content) {
-        return this.client.applyStashedOp(content);
+        return this.client.applyStashedOp((0, shared_object_base_1.parseHandles)(content, this.serializer));
     }
     summarizeMergeTree(serializer) {
         // Are we fully loaded? If not, things will go south
-        (0, common_utils_1.assert)(this.loadedDeferred.isCompleted, 0x074 /* "Snapshot called when not fully loaded" */);
+        (0, core_utils_1.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 = (0, shared_object_base_1.parseHandles)(rawMessage, this.serializer);
         const ops = [];
         function transformOps(event) {
@@ -450,23 +482,28 @@ class SharedSegmentSequence extends shared_object_base_1.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 ? (0, merge_tree_1.createGroupOp)(...ops) : ops[0] });
+                stashMessage = {
+                    ...message,
+                    referenceSequenceNumber: stashMessage.sequenceNumber - 1,
+                    // eslint-disable-next-line import/no-deprecated
+                    contents: ops.length !== 1 ? (0, merge_tree_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);
             }
         }
@@ -516,7 +553,7 @@ class SharedSegmentSequence extends shared_object_base_1.SharedObject {
             if (!intervalCollection.attached) {
                 intervalCollection.attachGraph(this.client, key);
             }
-            (0, common_utils_1.assert)(previousValue === undefined, 0x2c1 /* "Creating an interval collection that already exists?" */);
+            (0, core_utils_1.assert)(previousValue === undefined, 0x2c1 /* "Creating an interval collection that already exists?" */);
             this.emit("createIntervalCollection", key, local, this);
         });
         // Initialize existing SharedIntervalCollections
@@ -527,4 +564,37 @@ class SharedSegmentSequence extends shared_object_base_1.SharedObject {
     }
 }
 exports.SharedSegmentSequence = SharedSegmentSequence;
-//# 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.
+ */
+function resetReentrancyLogCounter() {
+    totalReentrancyLogs = 3;
+}
+exports.resetReentrancyLogCounter = resetReentrancyLogCounter;
+const reentrancyErrorMessage = "Reentrancy detected in sequence local ops";
+const ensureNoReentrancy = createReentrancyDetector(() => {
+    throw new telemetry_utils_1.LoggingError(reentrancyErrorMessage);
+});
+//# sourceMappingURL=sequence.cjs.map