@fluidframework/merge-tree 2.23.0-323641 → 2.23.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fluidframework/merge-tree",
-  "version": "2.23.0-323641",
+  "version": "2.23.0",
   "description": "Merge tree",
   "homepage": "https://fluidframework.com",
   "repository": {
@@ -81,30 +81,30 @@
     "temp-directory": "nyc/.nyc_output"
   },
   "dependencies": {
-    "@fluid-internal/client-utils": "2.23.0-323641",
-    "@fluidframework/container-definitions": "2.23.0-323641",
-    "@fluidframework/core-interfaces": "2.23.0-323641",
-    "@fluidframework/core-utils": "2.23.0-323641",
-    "@fluidframework/datastore-definitions": "2.23.0-323641",
-    "@fluidframework/driver-definitions": "2.23.0-323641",
-    "@fluidframework/runtime-definitions": "2.23.0-323641",
-    "@fluidframework/runtime-utils": "2.23.0-323641",
-    "@fluidframework/shared-object-base": "2.23.0-323641",
-    "@fluidframework/telemetry-utils": "2.23.0-323641"
+    "@fluid-internal/client-utils": "~2.23.0",
+    "@fluidframework/container-definitions": "~2.23.0",
+    "@fluidframework/core-interfaces": "~2.23.0",
+    "@fluidframework/core-utils": "~2.23.0",
+    "@fluidframework/datastore-definitions": "~2.23.0",
+    "@fluidframework/driver-definitions": "~2.23.0",
+    "@fluidframework/runtime-definitions": "~2.23.0",
+    "@fluidframework/runtime-utils": "~2.23.0",
+    "@fluidframework/shared-object-base": "~2.23.0",
+    "@fluidframework/telemetry-utils": "~2.23.0"
   },
   "devDependencies": {
     "@arethetypeswrong/cli": "^0.17.1",
     "@biomejs/biome": "~1.9.3",
-    "@fluid-internal/mocha-test-setup": "2.23.0-323641",
-    "@fluid-private/stochastic-test-utils": "2.23.0-323641",
-    "@fluid-private/test-pairwise-generator": "2.23.0-323641",
+    "@fluid-internal/mocha-test-setup": "~2.23.0",
+    "@fluid-private/stochastic-test-utils": "~2.23.0",
+    "@fluid-private/test-pairwise-generator": "~2.23.0",
     "@fluid-tools/benchmark": "^0.50.0",
-    "@fluid-tools/build-cli": "^0.53.0",
+    "@fluid-tools/build-cli": "^0.54.0",
     "@fluidframework/build-common": "^2.0.3",
-    "@fluidframework/build-tools": "^0.53.0",
+    "@fluidframework/build-tools": "^0.54.0",
     "@fluidframework/eslint-config-fluid": "^5.7.3",
     "@fluidframework/merge-tree-previous": "npm:@fluidframework/merge-tree@2.22.0",
-    "@fluidframework/test-runtime-utils": "2.23.0-323641",
+    "@fluidframework/test-runtime-utils": "~2.23.0",
     "@microsoft/api-extractor": "7.47.8",
     "@types/diff": "^3.5.1",
     "@types/mocha": "^10.0.10",

package/src/mergeTree.ts

@@ -95,6 +95,7 @@ import {
 	removeRemovalInfo,
 	toMoveInfo,
 	toRemovalInfo,
+	wasMovedOnInsert,
 	type IInsertionInfo,
 	type IMoveInfo,
 	type IRemovalInfo,
@@ -1083,7 +1084,14 @@ export class MergeTree {
 		if (!this.collabWindow.collaborating || this.collabWindow.clientId === clientId) {
 			if (node.isLeaf()) {
 				return this.localNetLength(node, refSeq, localSeq);
-			} else if (localSeq === undefined) {
+			} else if (
+				localSeq === undefined ||
+				// All changes are visible. Small note on why we allow refSeq >= this.collabWindow.currentSeq rather than just equality:
+				// merge-tree eventing occurs before the collab window is updated to account for whatever op it is processing, and we want
+				// to support resolving positions from within the event handler which account for that op. e.g. undo-redo relies on this
+				// behavior with local references.
+				(localSeq === this.collabWindow.localSeq && refSeq >= this.collabWindow.currentSeq)
+			) {
 				// Local client sees all segments, even when collaborating
 				return node.cachedLength;
 			} else {
@@ -1178,6 +1186,8 @@ export class MergeTree {
 	 */
 	public referencePositionToLocalPosition(
 		refPos: ReferencePosition,
+		// Note: this is not `this.collabWindow.currentSeq` because we want to support resolving local reference positions to positions
+		// from within event handlers, and the collab window's sequence numbers are not updated in time in all of those cases.
 		refSeq = Number.MAX_SAFE_INTEGER,
 		clientId = this.collabWindow.clientId,
 		localSeq: number | undefined = this.collabWindow.localSeq,
@@ -1611,6 +1621,8 @@ export class MergeTree {
 			let normalizedNewestSeq: number = 0;
 			const movedClientIds: number[] = [];
 			const movedSeqs: number[] = [];
+			let newestAcked: ObliterateInfo | undefined;
+			let oldestUnacked: ObliterateInfo | undefined;
 			for (const ob of this.obliterates.findOverlapping(newSegment)) {
 				// compute a normalized seq that takes into account local seqs
 				// but is still comparable to remote seqs to keep the checks below easy
@@ -1641,6 +1653,23 @@ export class MergeTree {
 						normalizedNewestSeq = normalizedObSeq;
 						newest = ob;
 					}
+
+					if (
+						ob.seq !== UnassignedSequenceNumber &&
+						(newestAcked === undefined || newestAcked.seq < ob.seq)
+					) {
+						newestAcked = ob;
+					}
+
+					if (
+						ob.seq === UnassignedSequenceNumber &&
+						(oldestUnacked === undefined || oldestUnacked.localSeq! > ob.localSeq!)
+					) {
+						// There can be one local obliterate surrounding a segment if a client repeatedly obliterates
+						// a region (ex: in the text ABCDEFG, obliterate D, then obliterate CE, then BF). In this case,
+						// the first one that's applied will be the one that actually removes the segment.
+						oldestUnacked = ob;
+					}
 				}
 			}
 
@@ -1649,23 +1678,39 @@ export class MergeTree {
 			// 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: IMoveInfo = {
-					movedClientIds,
-					movedSeq: oldest.seq,
-					movedSeqs,
-					localMovedSeq: oldest.localSeq,
-					wasMovedOnInsert: oldest.seq !== UnassignedSequenceNumber,
-				};
+				let moveInfo: IMoveInfo;
+				if (newestAcked === newest || newestAcked?.clientId !== clientId) {
+					moveInfo = {
+						movedClientIds,
+						movedSeq: oldest.seq,
+						movedSeqs,
+						localMovedSeq: oldestUnacked?.localSeq,
+					};
+				} else {
+					assert(
+						oldestUnacked !== undefined,
+						0xb55 /* Expected local obliterate to be defined if newestAcked is not equal to newest */,
+					);
+					// There's a pending local obliterate for this range, so it will be marked as obliterated by us. However,
+					// all other clients are under the impression that the most recent acked obliterate won the right to insert
+					// in this range.
+					moveInfo = {
+						movedClientIds: [oldestUnacked.clientId],
+						movedSeq: oldestUnacked.seq,
+						movedSeqs: [oldestUnacked.seq],
+						localMovedSeq: oldestUnacked.localSeq,
+					};
+				}
 
 				overwriteInfo(newSegment, moveInfo);
 
 				if (moveInfo.localMovedSeq !== undefined) {
 					assert(
-						oldest.segmentGroup !== undefined,
+						oldestUnacked?.segmentGroup !== undefined,
 						0x86c /* expected segment group to exist */,
 					);
 
-					this.addToPendingList(newSegment, oldest.segmentGroup);
+					this.addToPendingList(newSegment, oldestUnacked?.segmentGroup);
 				}
 
 				if (newSegment.parent) {
@@ -2104,8 +2149,6 @@ export class MergeTree {
 					movedSeq: seq,
 					localMovedSeq: localSeq,
 					movedSeqs: [seq],
-					wasMovedOnInsert:
-						segment.seq === UnassignedSequenceNumber && seq !== UnassignedSequenceNumber,
 				});
 
 				const existingRemoval = toRemovalInfo(movedSeg);
@@ -2121,16 +2164,15 @@ export class MergeTree {
 				}
 			} else {
 				if (existingMoveInfo.movedSeq === UnassignedSequenceNumber) {
-					// Should not need explicit set here, but this should be implied:
 					assert(
-						!existingMoveInfo.wasMovedOnInsert,
+						!wasMovedOnInsert(segment),
 						0xab4 /* Local obliterate cannot have removed a segment as soon as it was inserted */,
 					);
 					assert(
 						seq !== UnassignedSequenceNumber,
 						0xab5 /* Cannot obliterate the same segment locally twice */,
 					);
-					existingMoveInfo.wasMovedOnInsert = segment.seq === 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

package/src/mergeTreeNodes.ts

@@ -375,7 +375,6 @@ export abstract class BaseSegment implements ISegment {
 			overwriteInfo<IMoveInfo>(seg, {
 				movedSeq: this.movedSeq,
 				movedSeqs: [...this.movedSeqs],
-				wasMovedOnInsert: this.wasMovedOnInsert,
 				movedClientIds: [...this.movedClientIds],
 			});
 		}
@@ -441,7 +440,6 @@ export abstract class BaseSegment implements ISegment {
 				movedSeq: this.movedSeq,
 				movedSeqs: [...this.movedSeqs],
 				localMovedSeq: this.localMovedSeq,
-				wasMovedOnInsert: this.wasMovedOnInsert,
 			});
 		}
 

package/src/partialLengths.ts

@@ -14,7 +14,12 @@ import {
 	seqLTE,
 	type MergeBlock,
 } from "./mergeTreeNodes.js";
-import { toRemovalInfo, toMoveInfo, assertInserted } from "./segmentInfos.js";
+import {
+	toRemovalInfo,
+	toMoveInfo,
+	assertInserted,
+	wasMovedOnInsert,
+} from "./segmentInfos.js";
 import { SortedSet } from "./sortedSet.js";
 
 class PartialSequenceLengthsSet extends SortedSet<PartialSequenceLength> {
@@ -472,8 +477,7 @@ export class PartialSequenceLengths {
 			if (child.isLeaf()) {
 				// Leaf segment
 				const segment = child;
-				const moveInfo = toMoveInfo(segment);
-				if (moveInfo?.wasMovedOnInsert) {
+				if (wasMovedOnInsert(segment)) {
 					PartialSequenceLengths.accountForMoveOnInsert(
 						combinedPartialLengths,
 						segment,
@@ -511,7 +515,10 @@ export class PartialSequenceLengths {
 	): void {
 		assertInserted(segment);
 		const moveInfo = toMoveInfo(segment);
-		assert(moveInfo?.wasMovedOnInsert === true, 0xab7 /* Segment was not moved on insert */);
+		assert(
+			moveInfo !== undefined && wasMovedOnInsert(segment),
+			0xab7 /* Segment was not moved on insert */,
+		);
 		if (moveInfo.movedSeq <= collabWindow.minSeq) {
 			// This segment was obliterated as soon as it was inserted, and everyone was aware of the obliterate.
 			// Thus every single client treats this segment as length 0 from every perspective, and no adjustments
@@ -843,7 +850,7 @@ export class PartialSequenceLengths {
 						segment.seq !== undefined &&
 						moveInfo &&
 						moveInfo.movedSeq < segment.seq &&
-						moveInfo.wasMovedOnInsert
+						wasMovedOnInsert(segment)
 					) {
 						this.addClientAdjustment(clientId, moveInfo.movedSeq, segment.cachedLength);
 						failIncrementalPropagation = true;

package/src/segmentInfos.ts

@@ -5,6 +5,7 @@
 
 import { assert, isObject } from "@fluidframework/core-utils/internal";
 
+import { UnassignedSequenceNumber } from "./constants.js";
 import { ISegmentInternal, ISegmentPrivate, MergeBlock } from "./mergeTreeNodes.js";
 import type { ReferencePosition } from "./referencePositions.js";
 
@@ -296,31 +297,12 @@ export interface IMoveInfo {
 	 * list have all issued concurrent ops to move the segment.
 	 */
 	movedClientIds: number[];
-
-	/**
-	 * If this segment was inserted into a concurrently moved range and
-	 * the move op was sequenced before the insertion op. In this case,
-	 * the segment is visible only to the inserting client
-	 *
-	 * `wasMovedOnInsert` only applies for acked obliterates. That is, if
-	 * a segment inserted by a remote client is moved on insertion by a local
-	 * and unacked obliterate, we do not consider it as having been moved
-	 * on insert
-	 *
-	 * If a segment is moved on insertion, its length is only ever visible to
-	 * the client that inserted the segment. This is relevant in partial length
-	 * calculations
-	 *
-	 * @privateRemarks
-	 * TODO:AB#29553: This property is not persisted in the summary, but it should be.
-	 */
-	wasMovedOnInsert: boolean;
 }
+
 export const toMoveInfo = (segmentLike: unknown): IMoveInfo | undefined =>
 	hasProp(segmentLike, "movedClientIds", "array") &&
 	hasProp(segmentLike, "movedSeq", "number") &&
-	hasProp(segmentLike, "movedSeqs", "array") &&
-	hasProp(segmentLike, "wasMovedOnInsert", "boolean")
+	hasProp(segmentLike, "movedSeqs", "array")
 		? segmentLike
 		: undefined;
 
@@ -334,6 +316,26 @@ export const toMoveInfo = (segmentLike: unknown): IMoveInfo | undefined =>
 export const isMoved = (segmentLike: unknown): segmentLike is IMoveInfo =>
 	toMoveInfo(segmentLike) !== undefined;
 
+/**
+ * Returns whether this segment was marked moved as soon as its insertion was acked.
+ *
+ * This can happen when an an insert occurs concurrent to an obliterate over the range the segment was inserted into,
+ * and the obliterate was sequenced first.
+ *
+ * When this happens, the segment is only ever visible to the client that inserted the segment
+ * (and only until that client has seen the obliterate which removed their segment).
+ */
+export function wasMovedOnInsert(segment: IInsertionInfo & ISegmentPrivate): boolean {
+	const moveInfo = toMoveInfo(segment);
+	const movedSeq = moveInfo?.movedSeq;
+	if (movedSeq === undefined || movedSeq === UnassignedSequenceNumber) {
+		return false;
+	}
+
+	const insertSeq = segment.seq;
+	return insertSeq === UnassignedSequenceNumber || insertSeq > movedSeq;
+}
+
 /**
  * Asserts that the segment has move info. Usage of this function should not produce a user facing error.
  *

package/src/snapshotLoader.ts

@@ -140,8 +140,6 @@ export class SnapshotLoader {
 					movedClientIds: spec.movedClientIds.map((id) =>
 						this.client.getOrAddShortClientId(id),
 					),
-					// TODO:AB#29553: This property should be derived from segment data, not hard-coded.
-					wasMovedOnInsert: false,
 				});
 			}