@fluidframework/sequence 2.0.0-rc.1.0.4 → 2.0.0-rc.2.0.0

package/dist/sequence-untrimmed.d.ts

@@ -59,32 +59,32 @@ import { TypedEventEmitter } from '@fluid-internal/client-utils';
 
 /**
  * Create revertibles for adding an interval
- * @internal
+ * @alpha
  */
 export declare function appendAddIntervalToRevertibles(interval: SequenceInterval, revertibles: SharedStringRevertible[]): SharedStringRevertible[];
 
 /**
  * Create revertibles for moving endpoints of an interval
- * @internal
+ * @alpha
  */
 export declare function appendChangeIntervalToRevertibles(string: SharedString, newInterval: SequenceInterval, previousInterval: SequenceInterval, revertibles: SharedStringRevertible[]): SharedStringRevertible[];
 
 /**
  * Create revertibles for deleting an interval
- * @internal
+ * @alpha
  */
 export declare function appendDeleteIntervalToRevertibles(string: SharedString, interval: SequenceInterval, revertibles: SharedStringRevertible[]): SharedStringRevertible[];
 
 /**
  * Create revertibles for changing properties of an interval
- * @internal
+ * @alpha
  */
 export declare function appendIntervalPropertyChangedToRevertibles(interval: SequenceInterval, deltas: PropertySet, revertibles: SharedStringRevertible[]): SharedStringRevertible[];
 
 /**
  * Create revertibles for SharedStringDeltas, handling indirectly modified intervals
  * (e.g. reverting remove of a range that contains an interval will move the interval back)
- * @internal
+ * @alpha
  */
 export declare function appendSharedStringDeltaToRevertibles(string: SharedString, delta: SequenceDeltaEvent, revertibles: SharedStringRevertible[]): void;
 
@@ -106,7 +106,7 @@ export declare function createEndpointInRangeIndex(sharedString: SharedString):
 export declare function createIdIntervalIndex<TInterval extends ISerializableInterval>(): IIdIntervalIndex<TInterval>;
 
 /**
- * @internal
+ * @alpha
  */
 export declare function createOverlappingIntervalsIndex(sharedString: SharedString): IOverlappingIntervalsIndex<SequenceInterval>;
 
@@ -127,7 +127,7 @@ export declare type DeserializeCallback = (properties: PropertySet) => void;
 
 /**
  * Clean up resources held by revertibles that are no longer needed.
- * @internal
+ * @alpha
  */
 export declare function discardSharedStringRevertibles(sharedString: SharedString, revertibles: SharedStringRevertible[]): void;
 
@@ -465,6 +465,19 @@ export declare interface IIntervalCollectionEvent<TInterval extends ISerializabl
      * `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): void;
+    /**
+     * This event is invoked whenever an interval's endpoints or properties (or both) have changed.
+     * `interval` reflects the state of the updated endpoints or 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.
+     * 'previousInterval' contains transient `ReferencePosition`s at the same location as the interval's original
+     * endpoints. These references should be used for position information only. In the case of a property change
+     * only, this argument should be undefined.
+     * `local` reflects whether the change originated locally.
+     * `slide` is true if the change is due to sliding on removal of position.
+     */
+    (event: "changed", listener: (interval: TInterval, propertyDeltas: PropertySet, previousInterval: TInterval | undefined, local: boolean, slide: boolean) => void): void;
 }
 
 /**
@@ -642,7 +655,7 @@ export declare function intervalLocatorFromEndpoint(potentialEndpoint: LocalRefe
 
 /**
  * Values are used in revertibles.
- * @internal
+ * @alpha
  */
 export declare const IntervalOpType: {
     readonly PROPERTY_CHANGED: "propertyChanged";
@@ -653,13 +666,13 @@ export declare const IntervalOpType: {
 };
 
 /**
- * @internal
+ * @alpha
  */
 export declare type IntervalOpType = (typeof IntervalOpType)[keyof typeof IntervalOpType];
 
 /**
  * Data for undoing edits affecting Intervals.
- * @internal
+ * @alpha
  */
 export declare type IntervalRevertible = {
     event: typeof IntervalOpType.CHANGE;
@@ -754,7 +767,7 @@ export declare enum IntervalType {
 }
 
 /**
- * @internal
+ * @alpha
  */
 export declare interface IOverlappingIntervalsIndex<TInterval extends ISerializableInterval> extends IntervalIndex<TInterval> {
     /**
@@ -981,7 +994,7 @@ export { reservedTileLabelsKey }
 
 /**
  * Invoke revertibles to reverse prior edits
- * @internal
+ * @alpha
  */
 export declare function revertSharedStringRevertibles(sharedString: SharedString, revertibles: SharedStringRevertible[]): void;
 
@@ -1355,6 +1368,35 @@ export declare abstract class SharedSegmentSequence<T extends ISegment> extends
      */
     protected guardReentrancy: <TRet>(callback: () => TRet) => TRet;
     private static createOpsFromDelta;
+    /**
+     * Note: this field only provides a lower-bound on the reference sequence numbers for in-flight ops.
+     * The exact reason isn't understood, but some e2e tests suggest that the runtime may sometimes process
+     * incoming leave/join ops before putting an op that this DDS submits over the wire.
+     *
+     * E.g. SharedString submits an op while deltaManager has lastSequenceNumber = 10, but before the runtime
+     * puts this op over the wire, it processes a client join/leave op with sequence number 11, so the referenceSequenceNumber
+     * on the SharedString op is 11.
+     *
+     * The reference sequence numbers placed in this queue are also not accurate for stashed ops due to how the applyStashedOp
+     * flow works at the runtime level. This is a legitimate bug, and AB#6602 tracks one way to fix it (stop reaching all the way
+     * to deltaManager's lastSequenceNumber to obtain refSeq, instead leveraging some analogous notion on the container or datastore
+     * runtime).
+     */
+    private readonly inFlightRefSeqs;
+    private ongoingResubmitRefSeq;
+    /**
+     * Gets the reference sequence number (i.e. sequence number of the runtime's last processed op) for an op submitted
+     * in the current context.
+     *
+     * This value can be optionally overridden using `useResubmitRefSeq`.
+     * IntervalCollection's resubmit logic currently relies on preserving merge information from when the op was originally submitted,
+     * even if the op is resubmitted more than once. Thus during resubmit, `inFlightRefSeqs` gets populated with the
+     * original refSeq rather than the refSeq at the time of reconnection.
+     *
+     * @remarks - In some not fully understood cases, the runtime may process incoming ops before putting an op that this
+     * DDS submits over the wire. See `inFlightRefSeqs` for more details.
+     */
+    private get currentRefSeq();
     protected client: Client;
     /** `Deferred` that triggers once the object is loaded */
     protected loadedDeferred: Deferred<void>;
@@ -1427,6 +1469,11 @@ export declare abstract class SharedSegmentSequence<T extends ISegment> extends
     createLocalReferencePosition(segment: T, offset: number, refType: ReferenceType, properties: PropertySet | undefined, slidingPreference?: SlidingPreference, canSlideToEndpoint?: boolean): LocalReferencePosition;
     /**
      * Resolves a `ReferencePosition` into a character position using this client's perspective.
+     *
+     * Reference positions that point to a character that has been removed will
+     * always return the position of the nearest non-removed character, regardless
+     * of `ReferenceType`. To handle this case specifically, one may wish
+     * to look at the segment returned by `ReferencePosition.getSegment`.
      */
     localReferencePositionToPosition(lref: ReferencePosition): number;
     /**
@@ -1555,12 +1602,21 @@ export declare abstract class SharedSegmentSequence<T extends ISegment> extends
     /**
      * {@inheritDoc @fluidframework/shared-object-base#SharedObjectCore.applyStashedOp}
      */
-    protected applyStashedOp(content: any): unknown;
+    protected applyStashedOp(content: any): void;
     private summarizeMergeTree;
+    /**
+     *
+     * @param message - Message with decoded and hydrated handles
+     */
     private processMergeTreeMsg;
     private processMinSequenceNumberChanged;
     private loadFinished;
     private initializeIntervalCollections;
+    /**
+     * Overrides the "currently applicable reference sequence number" for the duration of the callback.
+     * See remarks on `currentRefSeq` for more context.
+     */
+    private useResubmitRefSeq;
 }
 
 /**
@@ -1709,12 +1765,15 @@ export declare class SharedStringFactory implements IChannelFactory {
      * {@inheritDoc @fluidframework/datastore-definitions#IChannelFactory.load}
      */
     load(runtime: IFluidDataStoreRuntime, id: string, services: IChannelServices, attributes: IChannelAttributes): Promise<SharedString>;
+    /**
+     * {@inheritDoc @fluidframework/datastore-definitions#IChannelFactory.create}
+     */
     create(document: IFluidDataStoreRuntime, id: string): SharedString;
 }
 
 /**
  * Data for undoing edits on SharedStrings and Intervals.
- * @internal
+ * @alpha
  */
 export declare type SharedStringRevertible = MergeTreeDeltaRevertible | IntervalRevertible;
 

package/dist/sequence.d.ts

@@ -9,10 +9,10 @@ import { Client, IJSONSegment, IMergeTreeGroupMsg, IRelativePosition, ISegment,
 import { IFluidSerializer, SharedObject, ISharedObjectEvents } from "@fluidframework/shared-object-base";
 import { IEventThisPlaceHolder } from "@fluidframework/core-interfaces";
 import { ISummaryTreeWithStats, ITelemetryContext } from "@fluidframework/runtime-definitions";
-import { SequenceInterval } from "./intervals";
-import { IIntervalCollection } from "./intervalCollection";
-import { SequenceDeltaEvent, SequenceMaintenanceEvent } from "./sequenceDeltaEvent";
-import { ISharedIntervalCollection } from "./sharedIntervalCollection";
+import { SequenceInterval } from "./intervals/index.js";
+import { IIntervalCollection } from "./intervalCollection.js";
+import { SequenceDeltaEvent, SequenceMaintenanceEvent } from "./sequenceDeltaEvent.js";
+import { ISharedIntervalCollection } from "./sharedIntervalCollection.js";
 /**
  * Events emitted in response to changes to the sequence data.
  *
@@ -74,6 +74,35 @@ export declare abstract class SharedSegmentSequence<T extends ISegment> extends
      */
     protected guardReentrancy: <TRet>(callback: () => TRet) => TRet;
     private static createOpsFromDelta;
+    /**
+     * Note: this field only provides a lower-bound on the reference sequence numbers for in-flight ops.
+     * The exact reason isn't understood, but some e2e tests suggest that the runtime may sometimes process
+     * incoming leave/join ops before putting an op that this DDS submits over the wire.
+     *
+     * E.g. SharedString submits an op while deltaManager has lastSequenceNumber = 10, but before the runtime
+     * puts this op over the wire, it processes a client join/leave op with sequence number 11, so the referenceSequenceNumber
+     * on the SharedString op is 11.
+     *
+     * The reference sequence numbers placed in this queue are also not accurate for stashed ops due to how the applyStashedOp
+     * flow works at the runtime level. This is a legitimate bug, and AB#6602 tracks one way to fix it (stop reaching all the way
+     * to deltaManager's lastSequenceNumber to obtain refSeq, instead leveraging some analogous notion on the container or datastore
+     * runtime).
+     */
+    private readonly inFlightRefSeqs;
+    private ongoingResubmitRefSeq;
+    /**
+     * Gets the reference sequence number (i.e. sequence number of the runtime's last processed op) for an op submitted
+     * in the current context.
+     *
+     * This value can be optionally overridden using `useResubmitRefSeq`.
+     * IntervalCollection's resubmit logic currently relies on preserving merge information from when the op was originally submitted,
+     * even if the op is resubmitted more than once. Thus during resubmit, `inFlightRefSeqs` gets populated with the
+     * original refSeq rather than the refSeq at the time of reconnection.
+     *
+     * @remarks - In some not fully understood cases, the runtime may process incoming ops before putting an op that this
+     * DDS submits over the wire. See `inFlightRefSeqs` for more details.
+     */
+    private get currentRefSeq();
     protected client: Client;
     /** `Deferred` that triggers once the object is loaded */
     protected loadedDeferred: Deferred<void>;
@@ -146,6 +175,11 @@ export declare abstract class SharedSegmentSequence<T extends ISegment> extends
     createLocalReferencePosition(segment: T, offset: number, refType: ReferenceType, properties: PropertySet | undefined, slidingPreference?: SlidingPreference, canSlideToEndpoint?: boolean): LocalReferencePosition;
     /**
      * Resolves a `ReferencePosition` into a character position using this client's perspective.
+     *
+     * Reference positions that point to a character that has been removed will
+     * always return the position of the nearest non-removed character, regardless
+     * of `ReferenceType`. To handle this case specifically, one may wish
+     * to look at the segment returned by `ReferencePosition.getSegment`.
      */
     localReferencePositionToPosition(lref: ReferencePosition): number;
     /**
@@ -274,12 +308,21 @@ export declare abstract class SharedSegmentSequence<T extends ISegment> extends
     /**
      * {@inheritDoc @fluidframework/shared-object-base#SharedObjectCore.applyStashedOp}
      */
-    protected applyStashedOp(content: any): unknown;
+    protected applyStashedOp(content: any): void;
     private summarizeMergeTree;
+    /**
+     *
+     * @param message - Message with decoded and hydrated handles
+     */
     private processMergeTreeMsg;
     private processMinSequenceNumberChanged;
     private loadFinished;
     private initializeIntervalCollections;
+    /**
+     * Overrides the "currently applicable reference sequence number" for the duration of the callback.
+     * See remarks on `currentRefSeq` for more context.
+     */
+    private useResubmitRefSeq;
 }
 /**
  * Resets the reentrancy log counter. Test-only API.

package/dist/sequence.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sequence.d.ts","sourceRoot":"","sources":["../src/sequence.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"sequence.d.ts","sourceRoot":"","sources":["../src/sequence.ts"],"names":[],"mappings":"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"}

package/dist/sequence.js

@@ -3,8 +3,12 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resetReentrancyLogCounter = exports.SharedSegmentSequence = void 0;
+const double_ended_queue_1 = __importDefault(require("double-ended-queue"));
 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");
@@ -12,9 +16,9 @@ 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 defaultMap_1 = require("./defaultMap");
-const intervalCollection_1 = require("./intervalCollection");
-const sequenceDeltaEvent_1 = require("./sequenceDeltaEvent");
+const defaultMap_js_1 = require("./defaultMap.js");
+const intervalCollection_js_1 = require("./intervalCollection.js");
+const sequenceDeltaEvent_js_1 = require("./sequenceDeltaEvent.js");
 const snapshotFileName = "header";
 const contentPath = "content";
 /**
@@ -74,11 +78,41 @@ class SharedSegmentSequence extends shared_object_base_1.SharedObject {
         }
         return ops;
     }
+    /**
+     * Gets the reference sequence number (i.e. sequence number of the runtime's last processed op) for an op submitted
+     * in the current context.
+     *
+     * This value can be optionally overridden using `useResubmitRefSeq`.
+     * IntervalCollection's resubmit logic currently relies on preserving merge information from when the op was originally submitted,
+     * even if the op is resubmitted more than once. Thus during resubmit, `inFlightRefSeqs` gets populated with the
+     * original refSeq rather than the refSeq at the time of reconnection.
+     *
+     * @remarks - In some not fully understood cases, the runtime may process incoming ops before putting an op that this
+     * DDS submits over the wire. See `inFlightRefSeqs` for more details.
+     */
+    get currentRefSeq() {
+        return this.ongoingResubmitRefSeq ?? this.runtime.deltaManager.lastSequenceNumber;
+    }
     constructor(dataStoreRuntime, id, attributes, segmentFromSpec) {
         super(id, dataStoreRuntime, attributes, "fluid_sequence_");
         this.dataStoreRuntime = dataStoreRuntime;
         this.id = id;
         this.segmentFromSpec = segmentFromSpec;
+        /**
+         * Note: this field only provides a lower-bound on the reference sequence numbers for in-flight ops.
+         * The exact reason isn't understood, but some e2e tests suggest that the runtime may sometimes process
+         * incoming leave/join ops before putting an op that this DDS submits over the wire.
+         *
+         * E.g. SharedString submits an op while deltaManager has lastSequenceNumber = 10, but before the runtime
+         * puts this op over the wire, it processes a client join/leave op with sequence number 11, so the referenceSequenceNumber
+         * on the SharedString op is 11.
+         *
+         * The reference sequence numbers placed in this queue are also not accurate for stashed ops due to how the applyStashedOp
+         * flow works at the runtime level. This is a legitimate bug, and AB#6602 tracks one way to fix it (stop reaching all the way
+         * to deltaManager's lastSequenceNumber to obtain refSeq, instead leveraging some analogous notion on the container or datastore
+         * runtime).
+         */
+        this.inFlightRefSeqs = new double_ended_queue_1.default();
         /** `Deferred` that triggers once the object is loaded */
         this.loadedDeferred = new core_utils_1.Deferred();
         // cache out going ops created when partial loading
@@ -87,6 +121,7 @@ class SharedSegmentSequence extends shared_object_base_1.SharedObject {
         this.deferIncomingOps = true;
         this.loadedDeferredIncomingOps = [];
         this.messagesSinceMSNChange = [];
+        const getMinInFlightRefSeq = () => this.inFlightRefSeqs.get(0);
         this.guardReentrancy =
             dataStoreRuntime.options.sharedStringPreventReentrancy ?? true
                 ? ensureNoReentrancy
@@ -103,18 +138,24 @@ class SharedSegmentSequence extends shared_object_base_1.SharedObject {
         this.client = new merge_tree_1.Client(segmentFromSpec, (0, telemetry_utils_1.createChildLogger)({
             logger: this.logger,
             namespace: "SharedSegmentSequence.MergeTreeClient",
-        }), dataStoreRuntime.options);
+        }), dataStoreRuntime.options, getMinInFlightRefSeq);
         this.client.prependListener("delta", (opArgs, deltaArgs) => {
-            const event = new sequenceDeltaEvent_1.SequenceDeltaEvent(opArgs, deltaArgs, this.client);
-            if (opArgs.stashed !== true && event.isLocal) {
+            const event = new sequenceDeltaEvent_js_1.SequenceDeltaEvent(opArgs, deltaArgs, this.client);
+            if (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.emit("maintenance", new sequenceDeltaEvent_js_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);
+        this.intervalCollections = new defaultMap_js_1.DefaultMap(this.serializer, this.handle, (op, localOpMetadata) => {
+            if (!this.isAttached()) {
+                return;
+            }
+            this.inFlightRefSeqs.push(this.currentRefSeq);
+            this.submitLocalMessage(op, localOpMetadata);
+        }, new intervalCollection_js_1.SequenceIntervalCollectionValueType(), dataStoreRuntime.options);
     }
     /**
      * @param start - The inclusive start of the range to remove
@@ -193,6 +234,11 @@ class SharedSegmentSequence extends shared_object_base_1.SharedObject {
     }
     /**
      * Resolves a `ReferencePosition` into a character position using this client's perspective.
+     *
+     * Reference positions that point to a character that has been removed will
+     * always return the position of the nearest non-removed character, regardless
+     * of `ReferenceType`. To handle this case specifically, one may wish
+     * to look at the segment returned by `ReferencePosition.getSegment`.
      */
     localReferencePositionToPosition(lref) {
         return this.client.localReferencePositionToPosition(lref);
@@ -224,16 +270,16 @@ class SharedSegmentSequence extends shared_object_base_1.SharedObject {
         if (!this.isAttached()) {
             return;
         }
-        const translated = (0, shared_object_base_1.makeHandlesSerializable)(message, this.serializer, this.handle);
+        this.inFlightRefSeqs.push(this.currentRefSeq);
         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 present
         if (!this.loadedDeferred.isCompleted) {
-            this.loadedDeferredOutgoingOps.push(metadata ? [translated, metadata] : translated);
+            this.loadedDeferredOutgoingOps.push(metadata ? [message, metadata] : message);
         }
         else {
-            this.submitLocalMessage(translated, metadata);
+            this.submitLocalMessage(message, metadata);
         }
     }
     /**
@@ -343,11 +389,9 @@ class SharedSegmentSequence extends shared_object_base_1.SharedObject {
         // Insert at the max end of the range when start > end, but still remove the range later
         const insertIndex = Math.max(start, end);
         // Insert first, so local references can slide to the inserted seg if any
-        const insert = this.client.insertSegmentLocal(insertIndex, segment);
-        if (insert) {
-            if (start < end) {
-                this.client.removeRangeLocal(start, end);
-            }
+        const insert = this.guardReentrancy(() => this.client.insertSegmentLocal(insertIndex, segment));
+        if (insert && start < end) {
+            this.removeRange(start, end);
         }
     }
     /**
@@ -365,9 +409,13 @@ class SharedSegmentSequence extends shared_object_base_1.SharedObject {
      * {@inheritDoc @fluidframework/shared-object-base#SharedObject.reSubmitCore}
      */
     reSubmitCore(content, localOpMetadata) {
-        if (!this.intervalCollections.tryResubmitMessage(content, localOpMetadata)) {
-            this.submitSequenceMessage(this.client.regeneratePendingOp(content, localOpMetadata));
-        }
+        const originalRefSeq = this.inFlightRefSeqs.shift();
+        (0, core_utils_1.assert)(originalRefSeq !== undefined, 0x8bb /* Expected a recorded refSeq when resubmitting an op */);
+        this.useResubmitRefSeq(originalRefSeq, () => {
+            if (!this.intervalCollections.tryResubmitMessage(content, localOpMetadata)) {
+                this.submitSequenceMessage(this.client.regeneratePendingOp(content, localOpMetadata));
+            }
+        });
     }
     /**
      * {@inheritDoc @fluidframework/shared-object-base#SharedObject.loadCore}
@@ -413,7 +461,7 @@ class SharedSegmentSequence extends shared_object_base_1.SharedObject {
                 .catch((error) => {
                 this.loadFinished(error);
             });
-            if (this.dataStoreRuntime.options?.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;
@@ -427,6 +475,17 @@ class SharedSegmentSequence extends shared_object_base_1.SharedObject {
      * {@inheritDoc @fluidframework/shared-object-base#SharedObject.processCore}
      */
     processCore(message, local, localOpMetadata) {
+        if (local) {
+            const recordedRefSeq = this.inFlightRefSeqs.shift();
+            (0, core_utils_1.assert)(recordedRefSeq !== undefined, 0x8bc /* No pending recorded refSeq found */);
+            // TODO: AB#7076: Some equivalent assert should be enabled. This fails some e2e stashed op tests because
+            // the deltaManager may have seen more messages than the runtime has processed while amidst the stashed op
+            // flow, so e.g. when `applyStashedOp` is called and the DDS is put in a state where it expects an ack for
+            // one of its messages, the delta manager has actually already seen subsequent messages from collaborators
+            // which the in-flight message is concurrent to.
+            // See "handles stashed ops created on top of sequenced local ops" for one such test case.
+            // assert(recordedRefSeq <= message.referenceSequenceNumber, "RefSeq mismatch");
+        }
         // if loading isn't complete, we need to cache all
         // incoming ops to be applied after loading is complete
         if (this.deferIncomingOps) {
@@ -462,11 +521,9 @@ class SharedSegmentSequence extends shared_object_base_1.SharedObject {
      * {@inheritDoc @fluidframework/shared-object-base#SharedObjectCore.applyStashedOp}
      */
     applyStashedOp(content) {
-        const parsedContent = (0, shared_object_base_1.parseHandles)(content, this.serializer);
-        const metadata = this.intervalCollections.tryGetStashedOpLocalMetadata(parsedContent) ??
-            this.client.applyStashedOp(parsedContent);
-        (0, core_utils_1.assert)(!!metadata, 0x87d /* Metadata is undefined */);
-        return metadata;
+        if (!this.intervalCollections.tryApplyStashedOp(content)) {
+            this.client.applyStashedOp(content);
+        }
     }
     summarizeMergeTree(serializer) {
         // Are we fully loaded? If not, things will go south
@@ -478,21 +535,24 @@ class SharedSegmentSequence extends shared_object_base_1.SharedObject {
         });
         return this.client.summarize(this.runtime, this.handle, serializer, this.messagesSinceMSNChange);
     }
-    processMergeTreeMsg(rawMessage, local) {
-        const message = (0, shared_object_base_1.parseHandles)(rawMessage, this.serializer);
+    /**
+     *
+     * @param message - Message with decoded and hydrated handles
+     */
+    processMergeTreeMsg(message, local) {
         const ops = [];
         function transformOps(event) {
             ops.push(...SharedSegmentSequence.createOpsFromDelta(event));
         }
         const needsTransformation = message.referenceSequenceNumber !== message.sequenceNumber - 1;
         let stashMessage = message;
-        if (this.runtime.options?.newMergeTreeSnapshotFormat !== true) {
+        if (this.runtime.options.newMergeTreeSnapshotFormat !== true) {
             if (needsTransformation) {
                 this.on("sequenceDelta", transformOps);
             }
         }
         this.client.applyMsg(message, local);
-        if (this.runtime.options?.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,
@@ -566,6 +626,20 @@ class SharedSegmentSequence extends shared_object_base_1.SharedObject {
             intervalCollection.attachGraph(this.client, key);
         }
     }
+    /**
+     * Overrides the "currently applicable reference sequence number" for the duration of the callback.
+     * See remarks on `currentRefSeq` for more context.
+     */
+    useResubmitRefSeq(refSeq, callback) {
+        const previousResubmitRefSeq = this.ongoingResubmitRefSeq;
+        this.ongoingResubmitRefSeq = refSeq;
+        try {
+            callback();
+        }
+        finally {
+            this.ongoingResubmitRefSeq = previousResubmitRefSeq;
+        }
+    }
 }
 exports.SharedSegmentSequence = SharedSegmentSequence;
 function createReentrancyDetector(onReentrancy) {