@fluidframework/merge-tree 2.21.0 → 2.23.0-323641

package/dist/mergeTree.js

@@ -286,6 +286,8 @@ class MergeTree {
         // for now assume only markers have ids and so point directly at the Segment
         // if we need to have pointers to non-markers, we can change to point at local refs
         this.idToMarker = new Map();
+        // TODO:AB#29553: This property doesn't seem to be adequately round-tripped through summarization.
+        // Specifically, it seems like we drop information about obliterates within the collab window for at least V1 summaries.
         this.obliterates = new Obliterates(this);
         this.splitLeafSegment = (segment, pos) => {
             if (!(pos > 0 && segment)) {
@@ -294,11 +296,11 @@ class MergeTree {
             const next = segment.splitAt(pos);
             (0, mergeTreeNodes_js_1.assertSegmentLeaf)(next);
             if (segment?.segmentGroups) {
-                next.segmentGroups ?? (next.segmentGroups = new segmentGroupCollection_js_1.SegmentGroupCollection(next));
+                next.segmentGroups ??= new segmentGroupCollection_js_1.SegmentGroupCollection(next);
                 segment.segmentGroups.copyTo(next.segmentGroups);
             }
-            if (segment.prevObliterateByInserter) {
-                next.prevObliterateByInserter = segment.prevObliterateByInserter;
+            if (segment.obliteratePrecedingInsertion) {
+                next.obliteratePrecedingInsertion = segment.obliteratePrecedingInsertion;
             }
             (0, segmentPropertiesManager_js_1.copyPropertiesAndManager)(segment, next);
             if (segment.localRefs) {
@@ -795,7 +797,7 @@ class MergeTree {
             const overlappingRemoves = [];
             pendingSegmentGroup.segments.map((pendingSegment) => {
                 const overlappingRemove = !ackSegment(pendingSegment, pendingSegmentGroup, opArgs);
-                overwrite = overlappingRemove || overwrite;
+                overwrite ||= overlappingRemove || (0, segmentInfos_js_1.toMoveInfo)(pendingSegment) !== undefined;
                 overlappingRemoves.push(overlappingRemove);
                 if (MergeTree.options.zamboniSegments) {
                     this.addToLRUSet(pendingSegment, seq);
@@ -851,7 +853,7 @@ class MergeTree {
         if (previousProps) {
             _segmentGroup.previousProps.push(previousProps);
         }
-        const segmentGroups = (segment.segmentGroups ?? (segment.segmentGroups = new segmentGroupCollection_js_1.SegmentGroupCollection(segment)));
+        const segmentGroups = (segment.segmentGroups ??= new segmentGroupCollection_js_1.SegmentGroupCollection(segment));
         segmentGroups.enqueue(_segmentGroup);
         return _segmentGroup;
     }
@@ -1036,15 +1038,21 @@ class MergeTree {
                     ? Number.MAX_SAFE_INTEGER - this.collabWindow.localSeq + ob.localSeq
                     : ob.seq;
                 if (normalizedObSeq > refSeq) {
-                    if (oldest === undefined || normalizedOldestSeq > normalizedObSeq) {
-                        normalizedOldestSeq = normalizedObSeq;
-                        oldest = ob;
-                        movedClientIds.unshift(ob.clientId);
-                        movedSeqs.unshift(ob.seq);
-                    }
-                    else {
-                        movedClientIds.push(ob.clientId);
-                        movedSeqs.push(ob.seq);
+                    // Any obliterate from the same client that's inserting this segment cannot cause the segment to be marked as
+                    // obliterated (since that client must have performed the obliterate before this insertion).
+                    // We still need to consider such obliterates when determining the winning obliterate for the insertion point,
+                    // see `obliteratePrecedingInsertion` docs.
+                    if (clientId !== ob.clientId) {
+                        if (oldest === undefined || normalizedOldestSeq > normalizedObSeq) {
+                            normalizedOldestSeq = normalizedObSeq;
+                            oldest = ob;
+                            movedClientIds.unshift(ob.clientId);
+                            movedSeqs.unshift(ob.seq);
+                        }
+                        else {
+                            movedClientIds.push(ob.clientId);
+                            movedSeqs.push(ob.seq);
+                        }
                     }
                     if (newest === undefined || normalizedNewestSeq < normalizedObSeq) {
                         normalizedNewestSeq = normalizedObSeq;
@@ -1052,6 +1060,10 @@ class MergeTree {
                     }
                 }
             }
+            newSegment.obliteratePrecedingInsertion = newest;
+            // See doc comment on obliteratePrecedingInsertion for more details: if the newest obliterate was performed
+            // by the same client that's inserting this segment, we let them insert into this range and therefore don't
+            // mark it obliterated.
             if (oldest && newest?.clientId !== clientId) {
                 const moveInfo = {
                     movedClientIds,
@@ -1066,12 +1078,14 @@ class MergeTree {
                     this.addToPendingList(newSegment, oldest.segmentGroup);
                 }
                 if (newSegment.parent) {
-                    this.blockUpdatePathLengths(newSegment.parent, seq, clientId);
+                    // The incremental update codepath in theory can handle most cases where segments are obliterated upon insertion,
+                    // but it's not idempotent with respect to segment insertion in the first place. Since we already update partial
+                    // lengths inside the inserting walk, we'd be at risk of double-counting the insertion in any case if we allow
+                    // incremental updates here.
+                    const newStructure = true;
+                    this.blockUpdatePathLengths(newSegment.parent, moveInfo.movedSeq, clientId, newStructure);
                 }
             }
-            else if (oldest && newest?.clientId === clientId) {
-                newSegment.prevObliterateByInserter = newest;
-            }
             saveIfLocal(newSegment);
         }
     }
@@ -1247,7 +1261,7 @@ class MergeTree {
             (0, internal_1.assert)(!mergeTreeNodes_js_1.Marker.is(segment) ||
                 !(mergeTreeNodes_js_1.reservedMarkerIdKey in opObj) ||
                 opObj.markerId === segment.properties?.markerId, 0x5ad /* Cannot change the markerId of an existing marker */);
-            const propertyManager = (segment.propertyManager ?? (segment.propertyManager = new segmentPropertiesManager_js_1.PropertiesManager()));
+            const propertyManager = (segment.propertyManager ??= new segmentPropertiesManager_js_1.PropertiesManager());
             const propertyDeltas = propertyManager.handleProperties(propsOrAdjust, segment, seq, this.collabWindow.minSeq, this.collabWindow.collaborating, rollback);
             if (!isRemovedOrMoved(segment)) {
                 deltaSegments.push({ segment, propertyDeltas });
@@ -1323,40 +1337,53 @@ class MergeTree {
             if ((start.side === sequencePlace_js_1.Side.After && startPos === pos + segment.cachedLength) || // exclusive start segment
                 (end.side === sequencePlace_js_1.Side.Before &&
                     endPos === pos &&
-                    (0, perspective_js_1.isSegmentPresent)(segment, { refSeq, localSeq })) // exclusive end segment
+                    // TODO:AB#29765: The clientId check here should be handled by isSegmentPresent and/or PerspectiveImpl
+                    (segment.clientId === clientId || (0, perspective_js_1.isSegmentPresent)(segment, { refSeq, localSeq }))) // exclusive end segment
             ) {
                 // We walk these segments because we want to also walk any concurrently inserted segments between here and the obliterated segments.
                 // These segments are outside of the obliteration range though, so return true to keep walking.
                 return true;
             }
             const existingMoveInfo = (0, segmentInfos_js_1.toMoveInfo)(segment);
-            if (segment.prevObliterateByInserter?.seq === constants_js_1.UnassignedSequenceNumber) {
+            // The "last-to-obliterate-gets-to-insert" policy described by the doc comment on `obliteratePrecedingInsertion`
+            // is mostly handled by logic at insertion time, but we need a small bit of handling here.
+            // Specifically, we want to avoid marking a local-only segment as obliterated when we know one of our own local obliterates
+            // will win against the obliterate we're processing, hence the early exit.
+            if (segment.seq === constants_js_1.UnassignedSequenceNumber &&
+                segment.obliteratePrecedingInsertion?.seq === constants_js_1.UnassignedSequenceNumber &&
+                seq !== constants_js_1.UnassignedSequenceNumber) {
                 // We chose to not obliterate this segment because we are aware of an unacked local obliteration.
                 // The local obliterate has not been sequenced yet, so it is still the newest obliterate we are aware of.
                 // Other clients will also choose not to obliterate this segment because the most recent obliteration has the same clientId
                 return true;
             }
-            const wasMovedOnInsert = clientId !== segment.clientId &&
-                segment.seq !== undefined &&
-                seq !== constants_js_1.UnassignedSequenceNumber &&
-                (refSeq < segment.seq || segment.seq === constants_js_1.UnassignedSequenceNumber);
+            // Partial lengths incrementality is not supported for overlapping obliterate/removes.
+            _overwrite ||= existingMoveInfo !== undefined || (0, segmentInfos_js_1.toRemovalInfo)(segment) !== undefined;
             if (existingMoveInfo === undefined) {
                 const movedSeg = (0, segmentInfos_js_1.overwriteInfo)(segment, {
                     movedClientIds: [clientId],
                     movedSeq: seq,
                     localMovedSeq: localSeq,
                     movedSeqs: [seq],
-                    wasMovedOnInsert,
+                    wasMovedOnInsert: segment.seq === constants_js_1.UnassignedSequenceNumber && seq !== constants_js_1.UnassignedSequenceNumber,
                 });
-                if (!(0, segmentInfos_js_1.toRemovalInfo)(movedSeg)) {
+                const existingRemoval = (0, segmentInfos_js_1.toRemovalInfo)(movedSeg);
+                if (existingRemoval === undefined) {
                     movedSegments.push(movedSeg);
                 }
+                else if (existingRemoval.removedSeq === constants_js_1.UnassignedSequenceNumber &&
+                    segment.localRefs?.empty === false) {
+                    // We removed this locally already so we don't need to event it again, but it might have references
+                    // that need sliding now that a move may have been acked.
+                    localOverlapWithRefs.push(segment);
+                }
             }
             else {
-                _overwrite = true;
-                // never move wasMovedOnInsert from true to false
-                existingMoveInfo.wasMovedOnInsert || (existingMoveInfo.wasMovedOnInsert = wasMovedOnInsert);
                 if (existingMoveInfo.movedSeq === constants_js_1.UnassignedSequenceNumber) {
+                    // Should not need explicit set here, but this should be implied:
+                    (0, internal_1.assert)(!existingMoveInfo.wasMovedOnInsert, 0xab4 /* Local obliterate cannot have removed a segment as soon as it was inserted */);
+                    (0, internal_1.assert)(seq !== constants_js_1.UnassignedSequenceNumber, 0xab5 /* Cannot obliterate the same segment locally twice */);
+                    existingMoveInfo.wasMovedOnInsert = segment.seq === constants_js_1.UnassignedSequenceNumber;
                     // we moved this locally, but someone else moved it first
                     // so put them at the head of the list
                     // The list isn't ordered, but we keep the first move at the head
@@ -1441,18 +1468,26 @@ class MergeTree {
         const localSeq = seq === constants_js_1.UnassignedSequenceNumber ? ++this.collabWindow.localSeq : undefined;
         const markRemoved = (segment, pos, _start, _end) => {
             const existingRemovalInfo = (0, segmentInfos_js_1.toRemovalInfo)(segment);
+            // Partial lengths incrementality is not supported for overlapping obliterate/removes.
+            _overwrite ||= existingRemovalInfo !== undefined || (0, segmentInfos_js_1.toMoveInfo)(segment) !== undefined;
             if (existingRemovalInfo === undefined) {
                 const removed = (0, segmentInfos_js_1.overwriteInfo)(segment, {
                     removedClientIds: [clientId],
                     removedSeq: seq,
                     localRemovedSeq: localSeq,
                 });
-                if (!(0, segmentInfos_js_1.toMoveInfo)(removed)) {
+                const existingMoveInfo = (0, segmentInfos_js_1.toMoveInfo)(removed);
+                if (existingMoveInfo === undefined) {
                     removedSegments.push(removed);
                 }
+                else if (existingMoveInfo.movedSeq === constants_js_1.UnassignedSequenceNumber &&
+                    segment.localRefs?.empty === false) {
+                    // We moved this locally already so we don't need to event it again, but it might have references
+                    // that need sliding now that a remove may have been acked.
+                    localOverlapWithRefs.push(segment);
+                }
             }
             else {
-                _overwrite = true;
                 if (existingRemovalInfo.removedSeq === constants_js_1.UnassignedSequenceNumber) {
                     // we removed this locally, but someone else removed it first
                     // so put them at the head of the list
@@ -1771,7 +1806,7 @@ class MergeTree {
             const node = block.children[i];
             const nodeLength = nodeTotalLength(this, node);
             if (nodeLength !== undefined) {
-                len ?? (len = 0);
+                len ??= 0;
                 len += nodeLength;
             }
             if (node.isLeaf()) {
@@ -1791,7 +1826,7 @@ class MergeTree {
                                 // The later, and right most children overwrite
                                 // whereas early, and left most do not overwrite
                                 rightmostTiles[tileLabel] = segment;
-                                leftmostTiles[tileLabel] ?? (leftmostTiles[tileLabel] = segment);
+                                leftmostTiles[tileLabel] ??= segment;
                             }
                         }
                     }