@fluidframework/merge-tree 2.30.0 → 2.31.0

package/src/revertibles.ts

@@ -308,8 +308,7 @@ function revertLocalRemove(
 		driver.insertFromSpec(realPos, props.segSpec);
 		const insertSegment = mergeTreeWithRevert.getContainingSegment(
 			realPos,
-			mergeTreeWithRevert.collabWindow.currentSeq,
-			mergeTreeWithRevert.collabWindow.clientId,
+			mergeTreeWithRevert.localPerspective,
 		).segment;
 		assertSegmentLeaf(insertSegment);
 
@@ -395,11 +394,7 @@ function revertLocalAnnotate(
 }
 
 function getPosition(mergeTreeWithRevert: MergeTreeWithRevert, segment: ISegmentLeaf): number {
-	return mergeTreeWithRevert.getPosition(
-		segment,
-		mergeTreeWithRevert.collabWindow.currentSeq,
-		mergeTreeWithRevert.collabWindow.clientId,
-	);
+	return mergeTreeWithRevert.getPosition(segment, mergeTreeWithRevert.localPerspective);
 }
 
 /**

package/src/segmentInfos.ts

@@ -7,13 +7,13 @@ 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";
+import type { InsertOperationStamp, RemoveOperationStamp } from "./stamps.js";
 
 export interface StringToType {
 	"string": string;
 	"number": number;
 	"object": object;
-	"array": [];
+	"array": unknown[];
 	"boolean": boolean;
 }
 
@@ -46,25 +46,8 @@ export function propInstanceOf<P extends string, T>(
 /**
  * Contains insertion information associated to an {@link ISegment}.
  */
-export interface IInsertionInfo {
-	/**
-	 * Short clientId for the client that inserted this segment.
-	 */
-	clientId: number;
-	/**
-	 * Local seq at which this segment was inserted.
-	 * This is defined if and only if the insertion of the segment is pending ack, i.e. `seq` is UnassignedSequenceNumber.
-	 * Once the segment is acked, this field is cleared.
-	 *
-	 * @privateRemarks
-	 * See {@link CollaborationWindow.localSeq} for more information on the semantics of localSeq.
-	 */
-	localSeq?: number;
-	/**
-	 * Seq at which this segment was inserted.
-	 * If undefined, it is assumed the segment was inserted prior to the collab window's minimum sequence number.
-	 */
-	seq: number;
+export interface IHasInsertionInfo {
+	insert: InsertOperationStamp;
 }
 
 /**
@@ -73,10 +56,14 @@ export interface IInsertionInfo {
  * @param segmentLike - The segment-like object to convert.
  * @returns The insertion info object if the conversion is possible, otherwise undefined.
  */
-export const toInsertionInfo = (segmentLike: unknown): IInsertionInfo | undefined =>
-	hasProp(segmentLike, "clientId", "number") && hasProp(segmentLike, "seq", "number")
-		? segmentLike
+export const toInsertionInfo = (segmentLike: unknown): IHasInsertionInfo | undefined => {
+	return segmentLike !== undefined &&
+		hasProp(segmentLike, "insert", "object") &&
+		hasProp(segmentLike.insert, "clientId", "number") &&
+		hasProp(segmentLike.insert, "seq", "number")
+		? (segmentLike as IHasInsertionInfo)
 		: undefined;
+};
 
 /**
  * A type-guard which determines if the segment has insertion info, and
@@ -85,7 +72,7 @@ export const toInsertionInfo = (segmentLike: unknown): IInsertionInfo | undefine
  * @param segmentLike - The segment-like object to check.
  * @returns True if the segment has insertion info, otherwise false.
  */
-export const isInserted = (segmentLike: unknown): segmentLike is IInsertionInfo =>
+export const isInserted = (segmentLike: unknown): segmentLike is IHasInsertionInfo =>
 	toInsertionInfo(segmentLike) !== undefined;
 
 /**
@@ -94,9 +81,9 @@ export const isInserted = (segmentLike: unknown): segmentLike is IInsertionInfo
  * @param segmentLike - The segment-like object to check.
  * @throws Will throw an error if the segment does not have insertion info.
  */
-export const assertInserted: <T extends Partial<IInsertionInfo> | undefined>(
-	segmentLike: ISegmentInternal | Partial<IInsertionInfo> | T,
-) => asserts segmentLike is IInsertionInfo | Exclude<T, Partial<IInsertionInfo>> = (
+export const assertInserted: <T extends Partial<IHasInsertionInfo> | undefined>(
+	segmentLike: ISegmentInternal | Partial<IHasInsertionInfo> | T,
+) => asserts segmentLike is IHasInsertionInfo | Exclude<T, Partial<IHasInsertionInfo>> = (
 	segmentLike,
 ) =>
 	assert(
@@ -181,24 +168,15 @@ export const removeMergeNodeInfo: (nodeLike: IMergeNodeInfo) => asserts nodeLike
 	});
 
 /**
- * Contains removal information associated to an {@link ISegment}.
+ * Contains removal information associated with an {@link ISegment}.
+ *
+ * Segments can be removed concurrently by multiple clients.
  */
-export interface IRemovalInfo {
-	/**
-	 * Local seq at which this segment was removed, if the removal is yet-to-be acked.
-	 */
-	localRemovedSeq?: number;
+export interface IHasRemovalInfo {
 	/**
-	 * Seq at which this segment was removed.
+	 * Operation stamps which have removed this segment. This list is sorted by stamp order, where removes[0] is the earliest removal.
 	 */
-	removedSeq: number;
-	/**
-	 * List of client IDs that have removed this segment.
-	 * The client that actually removed the segment (i.e. whose removal op was sequenced first) is stored as the first
-	 * client in this list. Other clients in the list have all issued concurrent ops to remove the segment.
-	 * @remarks When this list has length \> 1, this is referred to as the "overlapping remove" case.
-	 */
-	removedClientIds: number[];
+	removes: RemoveOperationStamp[];
 }
 
 /**
@@ -207,11 +185,14 @@ export interface IRemovalInfo {
  * @param segmentLike - The segment-like object to convert.
  * @returns The removal info object if the conversion is possible, otherwise undefined.
  */
-export const toRemovalInfo = (segmentLike: unknown): IRemovalInfo | undefined =>
-	hasProp(segmentLike, "removedClientIds", "array") &&
-	hasProp(segmentLike, "removedSeq", "number")
-		? segmentLike
+export const toRemovalInfo = (segmentLike: unknown): IHasRemovalInfo | undefined => {
+	return hasProp(segmentLike, "removes", "array") &&
+		segmentLike.removes.length > 0 &&
+		hasProp(segmentLike.removes[0], "clientId", "number") &&
+		hasProp(segmentLike.removes[0], "seq", "number")
+		? (segmentLike as IHasRemovalInfo)
 		: undefined;
+};
 
 /**
  * A type-guard which determines if the segment has removal info, and
@@ -220,7 +201,10 @@ export const toRemovalInfo = (segmentLike: unknown): IRemovalInfo | undefined =>
  * @param segmentLike - The segment-like object to check.
  * @returns True if the segment has removal info, otherwise false.
  */
-export const isRemoved = (segmentLike: unknown): segmentLike is IRemovalInfo =>
+// export const isRemoved = (segmentLike: unknown): segmentLike is IHasRemovalInfo =>
+// 	toRemovalInfo(segmentLike) !== undefined;
+
+export const isRemoved = (segmentLike: unknown): segmentLike is IHasRemovalInfo =>
 	toRemovalInfo(segmentLike) !== undefined;
 
 /**
@@ -229,9 +213,11 @@ export const isRemoved = (segmentLike: unknown): segmentLike is IRemovalInfo =>
  * @param segmentLike - The segment-like object to check.
  * @throws Will throw an error if the segment does not have removal info.
  */
-export const assertRemoved: <T extends Partial<IRemovalInfo> | undefined>(
-	segmentLike: ISegmentInternal | Partial<IRemovalInfo> | T,
-) => asserts segmentLike is IRemovalInfo | Exclude<T, Partial<IRemovalInfo>> = (segmentLike) =>
+export const assertRemoved: <T extends Partial<IHasRemovalInfo> | undefined>(
+	segmentLike: ISegmentInternal | Partial<IHasRemovalInfo> | T,
+) => asserts segmentLike is IHasRemovalInfo | Exclude<T, Partial<IHasRemovalInfo>> = (
+	segmentLike,
+) =>
 	assert(segmentLike === undefined || isRemoved(segmentLike), 0xaa2 /* must be removalInfo */);
 
 /**
@@ -241,83 +227,15 @@ export const assertRemoved: <T extends Partial<IRemovalInfo> | undefined>(
  * ensures no further usage of the removed removal info is allowed. if continued use is required other
  * type coercion methods should be use to correctly re-type the variable.
  */
-export const removeRemovalInfo: (nodeLike: IRemovalInfo) => asserts nodeLike is never = (
+export const removeRemovalInfo: (nodeLike: IHasRemovalInfo) => asserts nodeLike is never = (
 	nodeLike,
 ) =>
-	Object.assign<IRemovalInfo, Record<keyof IRemovalInfo, undefined>>(nodeLike, {
-		localRemovedSeq: undefined,
-		removedClientIds: undefined,
-		removedSeq: undefined,
+	Object.assign<IHasRemovalInfo, Record<keyof IHasRemovalInfo, undefined>>(nodeLike, {
+		removes: undefined,
 	});
 
 /**
- * Tracks information about when and where this segment was moved to.
- *
- * Note that merge-tree does not currently support moving and only supports
- * obliterate. The fields below include "move" in their names to avoid renaming
- * in the future, when moves _are_ supported.
- */
-export interface IMoveInfo {
-	/**
-	 * Local seq at which this segment was moved if the move is yet-to-be
-	 * acked.
-	 */
-	localMovedSeq?: number;
-
-	/**
-	 * The first seq at which this segment was moved.
-	 */
-	movedSeq: number;
-
-	/**
-	 * All seqs at which this segment was moved. In the case of overlapping,
-	 * concurrent moves this array will contain multiple seqs.
-	 *
-	 * The seq at  `movedSeqs[i]` corresponds to the client id at `movedClientIds[i]`.
-	 *
-	 * The first element corresponds to the seq of the first move
-	 */
-	movedSeqs: number[];
-
-	/**
-	 * A reference to the inserted destination segment corresponding to this
-	 * segment's move.
-	 *
-	 * If undefined, the move was an obliterate.
-	 *
-	 * Currently this field is unused, as we only support obliterate operations
-	 */
-	moveDst?: ReferencePosition;
-
-	/**
-	 * List of client IDs that have moved this segment.
-	 *
-	 * The client that actually moved the segment (i.e. whose move op was sequenced
-	 * first) is stored as the first client in this list. Other clients in the
-	 * list have all issued concurrent ops to move the segment.
-	 */
-	movedClientIds: number[];
-}
-
-export const toMoveInfo = (segmentLike: unknown): IMoveInfo | undefined =>
-	hasProp(segmentLike, "movedClientIds", "array") &&
-	hasProp(segmentLike, "movedSeq", "number") &&
-	hasProp(segmentLike, "movedSeqs", "array")
-		? segmentLike
-		: undefined;
-
-/**
- * A type-guard which determines if the segment has move info, and
- * returns true if it does, along with applying strong typing.
- *
- * @param segmentLike - The segment-like object to check.
- * @returns True if the segment has move info, otherwise false.
- */
-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.
+ * Returns whether this segment was marked removed 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.
@@ -325,32 +243,21 @@ export const isMoved = (segmentLike: unknown): segmentLike is IMoveInfo =>
  * 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) {
+export function wasRemovedOnInsert(segment: IHasInsertionInfo & ISegmentPrivate): boolean {
+	const removeInfo = toRemovalInfo(segment);
+	const removedSeq = removeInfo?.removes[0].seq;
+	if (removedSeq === undefined || removedSeq === UnassignedSequenceNumber) {
 		return false;
 	}
 
-	const insertSeq = segment.seq;
-	return insertSeq === UnassignedSequenceNumber || insertSeq > movedSeq;
+	const insertSeq = segment.insert.seq;
+	return insertSeq === UnassignedSequenceNumber || insertSeq > removedSeq;
 }
 
-/**
- * Asserts that the segment has move info. Usage of this function should not produce a user facing error.
- *
- * @param segmentLike - The segment-like object to check.
- * @throws Will throw an error if the segment does not have move info.
- */
-export const assertMoved: <T extends Partial<IMoveInfo> | undefined>(
-	segmentLike: ISegmentInternal | Partial<IMoveInfo> | T,
-) => asserts segmentLike is IMoveInfo | Exclude<T, Partial<IMoveInfo>> = (segmentLike) =>
-	assert(segmentLike === undefined || isMoved(segmentLike), 0xaa3 /* must be moveInfo */);
-
 /**
  * A union type representing any segment info.
  */
-export type SegmentInfo = IMergeNodeInfo | IInsertionInfo | IMoveInfo | IRemovalInfo;
+export type SegmentInfo = IMergeNodeInfo | IHasInsertionInfo | IHasRemovalInfo;
 
 /**
  * A type representing a segment with additional info.

package/src/segmentPropertiesManager.ts

@@ -14,20 +14,6 @@ import type {
 } from "./ops.js";
 import { MapLike, PropertySet, clone, createMap } from "./properties.js";
 
-/**
- * @internal
- */
-export enum PropertiesRollback {
-	/**
-	 * Not in a rollback
-	 */
-	None,
-
-	/**
-	 * Rollback
-	 */
-	Rollback,
-}
 /**
  * Minimally copies properties and the property manager from source to destination.
  * @internal
@@ -203,9 +189,9 @@ export class PropertiesManager {
 		seq: number,
 		msn: number,
 		collaborating: boolean = false,
-		rollback: PropertiesRollback = PropertiesRollback.None,
+		rollback: boolean = false,
 	): MapLike<unknown> {
-		if (rollback === PropertiesRollback.Rollback) {
+		if (rollback) {
 			return this.rollbackProperties(op, seg, collaborating);
 		}
 		const rtn = applyChanges(op, seg, seq, (properties, deltas, key, value) => {

package/src/snapshotLoader.ts

@@ -25,11 +25,11 @@ import { NonCollabClient, UniversalSequenceNumber } from "./constants.js";
 import { MergeTree } from "./mergeTree.js";
 import { ISegmentPrivate } from "./mergeTreeNodes.js";
 import { IJSONSegment } from "./ops.js";
+import { PriorPerspective } from "./perspective.js";
 import {
-	IRemovalInfo,
+	IHasRemovalInfo,
 	overwriteInfo,
-	type IInsertionInfo,
-	type IMoveInfo,
+	type IHasInsertionInfo,
 	type SegmentWithInfo,
 } from "./segmentInfos.js";
 import {
@@ -39,6 +39,8 @@ import {
 } from "./snapshotChunks.js";
 import { SnapshotV1 } from "./snapshotV1.js";
 import { SnapshotLegacy } from "./snapshotlegacy.js";
+import type { RemoveOperationStamp } from "./stamps.js";
+import * as opstampUtils from "./stamps.js";
 
 export class SnapshotLoader {
 	private readonly logger: ITelemetryLoggerExt;
@@ -102,16 +104,21 @@ export class SnapshotLoader {
 
 	private readonly specToSegment = (
 		spec: IJSONSegment | IJSONSegmentWithMergeInfo,
-	): SegmentWithInfo<IInsertionInfo> => {
+	): SegmentWithInfo<IHasInsertionInfo> => {
 		if (hasMergeInfo(spec)) {
-			const seg = overwriteInfo<IInsertionInfo>(this.client.specToSegment(spec.json), {
-				clientId:
-					spec.client === undefined
-						? NonCollabClient
-						: this.client.getOrAddShortClientId(spec.client),
-				seq: spec.seq ?? UniversalSequenceNumber,
+			const seg = overwriteInfo<IHasInsertionInfo>(this.client.specToSegment(spec.json), {
+				insert: {
+					type: "insert",
+					seq: spec.seq ?? UniversalSequenceNumber,
+					clientId:
+						spec.client === undefined
+							? NonCollabClient
+							: this.client.getOrAddShortClientId(spec.client),
+				},
 			});
 
+			const removes: RemoveOperationStamp[] = [];
+
 			if (spec.removedSeq !== undefined) {
 				// this format had a bug where it didn't store all the overlap clients
 				// this is for back compat, so we change the singular id to an array
@@ -122,32 +129,58 @@ export class SnapshotLoader {
 					spec.removedClientIds ??= [specAsBuggyFormat.removedClient];
 				}
 				assert(spec.removedClientIds !== undefined, 0xaac /* must have removedClient ids */);
-				overwriteInfo<IRemovalInfo>(seg, {
-					removedSeq: spec.removedSeq,
-					removedClientIds: spec.removedClientIds.map((id) =>
-						this.client.getOrAddShortClientId(id),
+				const firstRemovedSeq = spec.removedSeq;
+				// TODO:AB#32299: To correctly support perspectives from other clients which don't assume they have seen
+				// all ops, we need to actually record these in the summary. For now we use fake data, and it turns
+				// out ok since none of these values end up being used. (specifically, the 'firstRemovedSeq' is fake
+				// for all values other than the actual first remove).
+				// This issue only affects V1 summaries, as the strategy in snapshotlegacy avoids storing merge info directly.
+				removes.push(
+					...spec.removedClientIds.map(
+						(id) =>
+							({
+								type: "setRemove",
+								seq: firstRemovedSeq,
+								clientId: this.client.getOrAddShortClientId(id),
+							}) as const,
 					),
-				});
+				);
 			}
 			if (spec.movedSeq !== undefined) {
 				assert(
 					spec.movedClientIds !== undefined && spec.movedSeqs !== undefined,
 					0xaa5 /* must have movedIds ids */,
 				);
-				overwriteInfo<IMoveInfo>(seg, {
-					movedSeq: spec.movedSeq,
-					movedSeqs: spec.movedSeqs,
-					movedClientIds: spec.movedClientIds.map((id) =>
-						this.client.getOrAddShortClientId(id),
+				assert(
+					spec.movedClientIds.length === spec.movedSeqs.length,
+					0xb5f /* Expected same length for client ids and seqs */,
+				);
+
+				removes.push(
+					...spec.movedClientIds.map(
+						(id, i) =>
+							({
+								type: "sliceRemove",
+								seq: spec.movedSeqs![i],
+								clientId: this.client.getOrAddShortClientId(id),
+							}) as const,
 					),
-				});
+				);
+			}
+
+			if (removes.length > 0) {
+				removes.sort(opstampUtils.compare);
+				overwriteInfo<IHasRemovalInfo>(seg, { removes });
 			}
 
 			return seg;
 		}
 		return overwriteInfo(this.client.specToSegment(spec), {
-			seq: UniversalSequenceNumber,
-			clientId: NonCollabClient,
+			insert: {
+				type: "insert",
+				seq: UniversalSequenceNumber,
+				clientId: NonCollabClient,
+			},
 		});
 	};
 
@@ -206,7 +239,7 @@ export class SnapshotLoader {
 		}
 
 		let chunksWithAttribution = chunk1.attribution === undefined ? 0 : 1;
-		const segs: SegmentWithInfo<IInsertionInfo>[] = [];
+		const segs: SegmentWithInfo<IHasInsertionInfo>[] = [];
 		let lengthSofar = chunk1.length;
 		for (
 			let chunkIndex = 1;
@@ -243,19 +276,18 @@ export class SnapshotLoader {
 
 		// Helper to insert segments at the end of the MergeTree.
 		const mergeTree = this.mergeTree;
-		const append = (segments: ISegmentPrivate[], cli: number, seq: number): void => {
+		const append = (segments: ISegmentPrivate[], clientId: number, seq: number): void => {
 			mergeTree.insertSegments(
 				mergeTree.root.cachedLength ?? 0,
 				segments,
-				/* refSeq: */ UniversalSequenceNumber,
-				cli,
-				seq,
+				new PriorPerspective(UniversalSequenceNumber, clientId),
+				{ seq, clientId },
 				undefined,
 			);
 		};
 
 		// Helpers to batch-insert segments that are below the min seq
-		const batch: SegmentWithInfo<IInsertionInfo>[] = [];
+		const batch: SegmentWithInfo<IHasInsertionInfo>[] = [];
 		const flushBatch = (): void => {
 			if (batch.length > 0) {
 				append(batch, NonCollabClient, UniversalSequenceNumber);
@@ -263,7 +295,7 @@ export class SnapshotLoader {
 		};
 
 		for (const seg of segs) {
-			const { clientId, seq } = seg;
+			const { clientId, seq } = seg.insert;
 			// If the segment can be batch inserted, add it to the 'batch' array.  Otherwise, flush
 			// any batched segments and then insert the current segment individually.
 			if (clientId === NonCollabClient && seq === UniversalSequenceNumber) {

package/src/snapshotV1.ts

@@ -19,13 +19,13 @@ import {
 } from "@fluidframework/telemetry-utils/internal";
 
 import { IAttributionCollection } from "./attributionCollection.js";
-import { UnassignedSequenceNumber } from "./constants.js";
+import { NonCollabClient } from "./constants.js";
 import { MergeTree } from "./mergeTree.js";
 import { walkAllChildSegments } from "./mergeTreeNodeWalk.js";
 import { ISegmentPrivate } from "./mergeTreeNodes.js";
 import type { IJSONSegment } from "./ops.js";
 import { PropertySet, matchProperties } from "./properties.js";
-import { assertInserted, isMoved, isRemoved } from "./segmentInfos.js";
+import { assertInserted, isRemoved } from "./segmentInfos.js";
 import {
 	IJSONSegmentWithMergeInfo,
 	JsonSegmentSpecs,
@@ -36,6 +36,8 @@ import {
 	type VersionedMergeTreeChunk,
 } from "./snapshotChunks.js";
 import { SnapshotLegacy } from "./snapshotlegacy.js";
+import type { OperationStamp } from "./stamps.js";
+import * as opstampUtils from "./stamps.js";
 
 export class SnapshotV1 {
 	// Split snapshot into two entries - headers (small) and body (overflow) for faster loading initial content
@@ -190,6 +192,7 @@ export class SnapshotV1 {
 	extractSync(): JsonSegmentSpecs[] {
 		const mergeTree = this.mergeTree;
 		const minSeq = this.header.minSequenceNumber;
+		const minSeqStamp: OperationStamp = { seq: minSeq, clientId: NonCollabClient };
 
 		let originalSegments = 0;
 		let segmentsAfterCombine = 0;
@@ -232,11 +235,10 @@ export class SnapshotV1 {
 			//   b) The segment was removed at or below the MSN.  Pending ops can no longer reference this
 			//      segment, and therefore we can discard it.
 			if (
-				segment.seq === UnassignedSequenceNumber ||
-				(isRemoved(segment) && segment.removedSeq <= minSeq) ||
-				(isMoved(segment) && segment.movedSeq <= minSeq)
+				opstampUtils.isLocal(segment.insert) ||
+				(isRemoved(segment) && opstampUtils.lte(segment.removes[0], minSeqStamp))
 			) {
-				if (segment.seq !== UnassignedSequenceNumber) {
+				if (opstampUtils.isAcked(segment.insert)) {
 					originalSegments += 1;
 				}
 				return true;
@@ -248,10 +250,8 @@ export class SnapshotV1 {
 			// (seq, client, etc.)  This information is only needed if the segment is above the MSN (and doesn't
 			// have a pending remove.)
 			if (
-				segment.seq <= minSeq && // Segment is below the MSN, and...
-				(!isRemoved(segment) || // .. Segment has not been removed, or...
-					segment.removedSeq === UnassignedSequenceNumber) && // .. Removal op to be delivered on reconnect
-				(!isMoved(segment) || segment.movedSeq === UnassignedSequenceNumber)
+				opstampUtils.lte(segment.insert, minSeqStamp) && // Segment is below the MSN, and...
+				(!isRemoved(segment) || opstampUtils.isLocal(segment.removes[0]))
 			) {
 				// This segment is below the MSN, which means that future ops will not reference it.  Attempt to
 				// coalesce the new segment with the previous (if any).
@@ -285,38 +285,46 @@ export class SnapshotV1 {
 					json: segment.toJSONObject() as IJSONSegment,
 				};
 				// If the segment insertion is above the MSN, record the insertion merge info.
-				if (segment.seq > minSeq) {
-					raw.seq = segment.seq;
-					raw.client = this.getLongClientId(segment.clientId);
+				if (opstampUtils.greaterThan(segment.insert, minSeqStamp)) {
+					raw.seq = segment.insert.seq;
+					raw.client = this.getLongClientId(segment.insert.clientId);
 				}
+
 				// We have already dispensed with removed segments below the MSN and removed segments with unassigned
 				// sequence numbers.  Any remaining removal info should be preserved.
-				if (isRemoved(segment)) {
+				if (isRemoved(segment) && segment.removes.some((r) => r.type === "setRemove")) {
+					const removes = segment.removes.filter((r) => r.type === "setRemove");
+					const firstRemove = removes[0];
 					assert(
-						segment.removedSeq !== UnassignedSequenceNumber && segment.removedSeq > minSeq,
+						opstampUtils.isAcked(firstRemove) &&
+							opstampUtils.greaterThan(firstRemove, minSeqStamp),
 						0x065 /* "On removal info preservation, segment has invalid removed sequence number!" */,
 					);
-					raw.removedSeq = segment.removedSeq;
+					// TODO:AB#32299 By not preserving sequence numbers other than the first move,
+					// We drop data here which will be necessary to allow perspectives of remote clients that
+					// don't include all of their ops. This should be remedied at some point.
+					raw.removedSeq = firstRemove.seq;
 
 					// back compat for when we split overlap and removed client
-					raw.removedClient =
-						segment.removedClientIds === undefined
-							? undefined
-							: this.getLongClientId(segment.removedClientIds[0]);
+					// This can be removed when we can safely assume no clients running Fluid packages <= 0.58 will ever
+					// load a document produced by a version beyond the removal. It is vestigial in the meantime.
+					raw.removedClient = this.getLongClientId(firstRemove.clientId);
 
-					raw.removedClientIds = segment.removedClientIds?.map((id) =>
-						this.getLongClientId(id),
-					);
+					raw.removedClientIds = removes.map(({ clientId }) => this.getLongClientId(clientId));
 				}
 
-				if (isMoved(segment)) {
+				if (isRemoved(segment) && segment.removes.some((r) => r.type === "sliceRemove")) {
+					// In this format, we used the term "move" to refer to a sliceRemove/obliterate.
+					const moves = segment.removes.filter((r) => r.type === "sliceRemove");
+					const firstMove = moves[0];
 					assert(
-						segment.movedSeq !== UnassignedSequenceNumber && segment.movedSeq > minSeq,
+						opstampUtils.isAcked(firstMove) &&
+							opstampUtils.greaterThan(firstMove, minSeqStamp),
 						0x873 /* On move info preservation, segment has invalid moved sequence number! */,
 					);
-					raw.movedSeq = segment.movedSeq;
-					raw.movedSeqs = segment.movedSeqs;
-					raw.movedClientIds = segment.movedClientIds?.map((id) => this.getLongClientId(id));
+					raw.movedSeq = firstMove.seq;
+					raw.movedSeqs = moves.map(({ seq }) => seq);
+					raw.movedClientIds = moves.map(({ clientId }) => this.getLongClientId(clientId));
 				}
 
 				// Sanity check that we are preserving either the seq > minSeq or a (re)moved segment's info.