@fluidframework/tree 2.74.0 → 2.81.0-374083

package/src/feature-libraries/sequence-field/compose.ts

@@ -6,71 +6,55 @@
 import { assert, unreachableCase, fail } from "@fluidframework/core-utils/internal";
 
 import {
+	areEqualChangeAtomIdOpts,
+	areEqualChangeAtomIds,
 	type ChangeAtomId,
 	type RevisionMetadataSource,
 	type RevisionTag,
-	offsetChangeAtomId,
 } from "../../core/index.js";
 import type { IdAllocator } from "../../util/index.js";
-import {
-	type CrossFieldManager,
-	CrossFieldTarget,
-	type NodeChangeComposer,
-	type NodeId,
+import type {
+	ComposeNodeManager,
+	NodeChangeComposer,
+	NodeId,
 } from "../modular-schema/index.js";
 
-import type { MoveMarkEffect } from "./helperTypes.js";
 import { MarkListFactory } from "./markListFactory.js";
 import { MarkQueue } from "./markQueue.js";
-import {
-	type MoveEffect,
-	type MoveEffectTable,
-	getCrossFieldTargetFromMove,
-	getMoveEffect,
-	getMoveIn,
-	isMoveIn,
-	isMoveMark,
-	isMoveOut,
-	setMoveEffect,
-} from "./moveEffectTable.js";
-import {
-	type Attach,
-	type CellMark,
-	type Changeset,
-	type Detach,
-	type Mark,
-	type MarkEffect,
-	type MarkList,
-	type MoveId,
-	type NoopMark,
-	NoopMarkType,
+import type { NodeRangeQueryFunc } from "./moveEffectTable.js";
+import type {
+	CellMark,
+	Changeset,
+	Detach,
+	Mark,
+	MarkEffect,
+	MarkList,
+	NoopMark,
 } from "./types.js";
 import {
 	CellOrder,
 	areEqualCellIds,
 	areInputCellsEmpty,
 	areOutputCellsEmpty,
-	asAttachAndDetach,
 	cellSourcesFromMarks,
 	compareCellPositionsUsingTombstones,
 	extractMarkEffect,
-	getEndpoint,
+	getAttachedRootId,
+	getDetachOutputCellId,
+	getDetachedRootId,
 	getInputCellId,
+	getMovedNodeId,
 	getOutputCellId,
 	isAttach,
-	isAttachAndDetachEffect,
 	isDetach,
-	isImpactfulCellRename,
 	isNewAttach,
 	isNoopMark,
+	isPin,
 	isRename,
 	markEmptiesCells,
-	markFillsCells,
 	markHasCellEffect,
 	normalizeCellRename,
-	settleMark,
 	withNodeChange,
-	withRevision,
 } from "./utils.js";
 
 /**
@@ -90,63 +74,25 @@ export function compose(
 	change2: Changeset,
 	composeChild: NodeChangeComposer,
 	_genId: IdAllocator,
-	manager: CrossFieldManager,
+	manager: ComposeNodeManager,
 	revisionMetadata: RevisionMetadataSource,
 ): Changeset {
-	return composeMarkLists(
-		change1,
-		change2,
-		composeChild,
-		manager as MoveEffectTable,
-		revisionMetadata,
-	);
+	return composeMarkLists(change1, change2, composeChild, manager, revisionMetadata);
 }
 
 function composeMarkLists(
 	baseMarkList: MarkList,
 	newMarkList: MarkList,
 	composeChild: NodeChangeComposer,
-	moveEffects: MoveEffectTable,
+	moveEffects: ComposeNodeManager,
 	revisionMetadata: RevisionMetadataSource,
 ): MarkList {
 	const factory = new MarkListFactory();
 	const queue = new ComposeQueue(baseMarkList, newMarkList, moveEffects, revisionMetadata);
 	while (!queue.isEmpty()) {
 		const { baseMark, newMark } = queue.pop();
-		if (newMark === undefined) {
-			assert(
-				baseMark !== undefined,
-				0x4db /* Non-empty queue should not return two undefined marks */,
-			);
-			factory.push(
-				composeMark(baseMark, moveEffects, (node: NodeId) =>
-					composeChildChanges(node, undefined, composeChild),
-				),
-			);
-		} else {
-			// We only compose changesets that will not be further rebased.
-			// It is therefore safe to remove any intentions that have no impact in the context they apply to.
-			const settledNewMark = settleMark(newMark);
-			if (baseMark === undefined) {
-				factory.push(
-					composeMark(settledNewMark, moveEffects, (node: NodeId) =>
-						composeChildChanges(undefined, node, composeChild),
-					),
-				);
-			} else {
-				// Past this point, we are guaranteed that `settledNewMark` and `baseMark` have the same length and
-				// start at the same location in the revision after the base changes.
-				// They therefore refer to the same range for that revision.
-				const settledBaseMark = settleMark(baseMark);
-				const composedMark = composeMarks(
-					settledBaseMark,
-					settledNewMark,
-					composeChild,
-					moveEffects,
-				);
-				factory.push(composedMark);
-			}
-		}
+		const composedMark = composeMarks(baseMark, newMark, composeChild, moveEffects);
+		factory.push(composedMark);
 	}
 
 	return factory.list;
@@ -165,206 +111,77 @@ function composeMarks(
 	baseMark: Mark,
 	newMark: Mark,
 	composeChild: NodeChangeComposer,
-	moveEffects: MoveEffectTable,
+	moveEffects: ComposeNodeManager,
 ): Mark {
 	const nodeChange = handleNodeChanges(baseMark, newMark, composeChild, moveEffects);
-
-	return withUpdatedEndpoint(
-		withNodeChange(composeMarksIgnoreChild(baseMark, newMark, moveEffects), nodeChange),
-		baseMark.count,
-		moveEffects,
-	);
+	return withNodeChange(composeMarksIgnoreChild(baseMark, newMark, moveEffects), nodeChange);
 }
 
 function composeMarksIgnoreChild(
 	baseMark: Mark,
 	newMark: Mark,
-	moveEffects: MoveEffectTable,
+	moveEffects: ComposeNodeManager,
 ): Mark {
 	if (isNoopMark(baseMark)) {
 		return newMark;
 	} else if (isNoopMark(newMark)) {
-		return baseMark;
+		return updateBaseMarkId(moveEffects, baseMark);
 	}
 
 	if (isRename(baseMark) && isRename(newMark)) {
+		if (areEqualChangeAtomIdOpts(baseMark.cellId, newMark.idOverride)) {
+			return createNoopMark(baseMark.count, undefined, baseMark.cellId);
+		}
 		return { ...baseMark, idOverride: newMark.idOverride };
 	} else if (isRename(baseMark)) {
+		assert(isAttach(newMark), 0x9f1 /* Unexpected mark type */);
 		assert(
-			isAttach(newMark) || isAttachAndDetachEffect(newMark),
-			0x9f1 /* Unexpected mark type */,
+			baseMark.cellId !== undefined && newMark.cellId !== undefined,
+			"Expected marks to target an empty cell",
 		);
 		return { ...newMark, cellId: baseMark.cellId };
 	} else if (isRename(newMark)) {
-		assert(
-			isDetach(baseMark) || isAttachAndDetachEffect(baseMark),
-			0x9f2 /* Unexpected mark type */,
-		);
-		return isDetach(baseMark)
-			? { ...baseMark, idOverride: newMark.idOverride }
-			: { ...baseMark, detach: { ...baseMark.detach, idOverride: newMark.idOverride } };
+		assert(isDetach(baseMark), 0x9f2 /* Unexpected mark type */);
+		return updateBaseMarkId(moveEffects, { ...baseMark, cellRename: newMark.idOverride });
 	}
 
-	if (isImpactfulCellRename(newMark)) {
-		const newAttachAndDetach = asAttachAndDetach(newMark);
-		assert(
-			newAttachAndDetach.cellId !== undefined,
-			0x9f3 /* Impactful cell rename must target empty cell */,
+	if (!markHasCellEffect(baseMark)) {
+		assert(baseMark.type === "Insert", "Expected baseMark to be a pin");
+
+		// `newMark` can be either a remove or another pin.
+		// A pin is treated as a detach and attach, so we call `composeAttachDetach` in either case.
+		moveEffects.composeAttachDetach(
+			getAttachedRootId(baseMark),
+			{
+				revision: newMark.revision,
+				localId: newMark.id,
+			},
+			baseMark.count,
 		);
-		const newDetachRevision = newAttachAndDetach.detach.revision;
-		if (markEmptiesCells(baseMark)) {
-			// baseMark is a detach which cancels with the attach portion of the AttachAndDetach,
-			// so we are just left with the detach portion of the AttachAndDetach.
-			const newDetach: CellMark<Detach> = {
-				...newAttachAndDetach.detach,
-				count: baseMark.count,
-			};
 
-			if (isMoveIn(newAttachAndDetach.attach) && isMoveOut(newAttachAndDetach.detach)) {
-				assert(isMoveOut(baseMark), 0x808 /* Unexpected mark type */);
-
-				// The base changeset and new changeset both move these nodes.
-				// Call the original position of the nodes A, the position after the base changeset is applied B,
-				// and the position after the new changeset is applied C.
-				// The new changeset moves the nodes from B, temporarily returns them to A, and then moves them to C.
-				// The composition of the base and new changesets will be a move directly from A to C,
-				// since the move from A to B cancels out with the return from B to A.
-				// This if-block is handling marks at A.
-				// When we compose the marks at B we will link the start of the base move (A to B)
-				// with the end of the new move (B to C).
-				// Because we are replacing the mark representing the start of the move with the new changeset's
-				// move-out from A, we update the base move-in at B to consider that its start point.
-				const newDetachId = {
-					revision: newDetachRevision,
-					localId: newAttachAndDetach.detach.id,
-				};
-
-				setTruncatedEndpointForInner(
-					moveEffects,
-					CrossFieldTarget.Destination,
-					getEndpoint(baseMark),
-					baseMark.count,
-					newDetachId,
-				);
-
-				const newEndpoint = getComposedEndpoint(
-					moveEffects,
-					CrossFieldTarget.Source,
-					baseMark.revision,
-					baseMark.id,
-					baseMark.count,
-				);
-
-				if (newEndpoint !== undefined) {
-					changeFinalEndpoint(newDetach as MoveMarkEffect, newEndpoint);
-					setTruncatedEndpoint(
-						moveEffects,
-						CrossFieldTarget.Destination,
-						newEndpoint,
-						baseMark.count,
-						newDetachId,
-					);
+		const pinId = getAttachedRootId(baseMark);
+		return newMark.type === "Remove"
+			? {
+					...newMark,
+					detachCellId: baseMark.detachCellId ?? pinId,
+					cellRename: getDetachOutputCellId(newMark),
 				}
-			}
-
-			return newDetach;
-		}
-
-		if (isImpactfulCellRename(baseMark)) {
-			assert(
-				baseMark.cellId !== undefined,
-				0x9f4 /* Impactful cell rename must target empty cell */,
-			);
-			const baseAttachAndDetach = asAttachAndDetach(baseMark);
-			const newOutputId = getOutputCellId(newAttachAndDetach);
-
-			const originalAttach = { ...baseAttachAndDetach.attach };
-			const finalDetach = { ...newAttachAndDetach.detach };
-
-			handleMovePivot(baseMark.count, originalAttach, finalDetach, moveEffects);
-
-			if (areEqualCellIds(newOutputId, baseAttachAndDetach.cellId)) {
-				return { count: baseAttachAndDetach.count, cellId: baseAttachAndDetach.cellId };
-			}
-
-			// `newMark`'s attach portion cancels with `baseMark`'s detach portion.
-			const detachRevision = finalDetach.revision;
-			if (detachRevision !== undefined) {
-				finalDetach.revision = detachRevision;
-			}
-
-			return normalizeCellRename(baseMark.cellId, baseMark.count, originalAttach, finalDetach);
-		}
-
-		return normalizeCellRename(
-			newAttachAndDetach.cellId,
-			newAttachAndDetach.count,
-			newAttachAndDetach.attach,
-			newAttachAndDetach.detach,
-		);
-	}
-	if (isImpactfulCellRename(baseMark)) {
-		const baseAttachAndDetach = asAttachAndDetach(baseMark);
-		if (markFillsCells(newMark)) {
-			const originalAttach = withRevision(
-				{
-					...baseAttachAndDetach.attach,
-					cellId: baseAttachAndDetach.cellId,
-					count: baseAttachAndDetach.count,
-				},
-				baseAttachAndDetach.attach.revision,
+			: newMark;
+	} else if (!markHasCellEffect(newMark)) {
+		if (isAttach(newMark) && isAttach(baseMark)) {
+			// When composing two inserts, the second insert (which is a pin) should take precedence.
+			// We treat the pin as a detach and reattach.
+			moveEffects.composeAttachDetach(
+				getAttachedRootId(baseMark),
+				getAttachedRootId(newMark),
+				baseMark.count,
 			);
 
-			if (isMoveIn(baseAttachAndDetach.attach) && isMoveOut(baseAttachAndDetach.detach)) {
-				assert(isMoveIn(newMark), 0x809 /* Unexpected mark type */);
-
-				const originalAttachId = {
-					revision: baseAttachAndDetach.attach.revision,
-					localId: baseAttachAndDetach.attach.id,
-				};
-
-				setTruncatedEndpointForInner(
-					moveEffects,
-					CrossFieldTarget.Source,
-					getEndpoint(newMark),
-					baseAttachAndDetach.count,
-					originalAttachId,
-				);
-
-				const newEndpoint = getComposedEndpoint(
-					moveEffects,
-					CrossFieldTarget.Destination,
-					newMark.revision,
-					newMark.id,
-					newMark.count,
-				);
-
-				if (newEndpoint !== undefined) {
-					changeFinalEndpoint(originalAttach as MoveMarkEffect, newEndpoint);
-					setTruncatedEndpoint(
-						moveEffects,
-						CrossFieldTarget.Source,
-						newEndpoint,
-						baseMark.count,
-						originalAttachId,
-					);
-				}
-			}
-
-			return originalAttach;
-		} else {
-			// Other mark types have been handled by previous conditional branches.
-			assert(newMark.type === NoopMarkType, 0x80a /* Unexpected mark type */);
-			return baseMark;
+			const composed = { cellId: baseMark.cellId, ...newMark };
+			delete composed.detachCellId;
+			return composed;
 		}
-	}
-
-	if (!markHasCellEffect(baseMark) && !markHasCellEffect(newMark)) {
-		return createNoopMark(newMark.count, undefined, getInputCellId(baseMark));
-	} else if (!markHasCellEffect(baseMark)) {
-		return newMark;
-	} else if (!markHasCellEffect(newMark)) {
-		return baseMark;
+		return updateBaseMarkId(moveEffects, baseMark);
 	} else if (areInputCellsEmpty(baseMark)) {
 		assert(isDetach(newMark), 0x71c /* Unexpected mark type */);
 		assert(isAttach(baseMark), 0x71d /* Expected generative mark */);
@@ -372,7 +189,11 @@ function composeMarksIgnoreChild(
 		const attach = extractMarkEffect(baseMark);
 		const detach = extractMarkEffect(newMark);
 
-		handleMovePivot(baseMark.count, attach, detach, moveEffects);
+		moveEffects.composeAttachDetach(
+			getAttachedRootId(baseMark),
+			getDetachedRootId(newMark),
+			baseMark.count,
+		);
 
 		if (areEqualCellIds(getOutputCellId(newMark), baseMark.cellId)) {
 			// The output and input cell IDs are the same, so this mark has no effect.
@@ -380,74 +201,45 @@ function composeMarksIgnoreChild(
 		}
 		return normalizeCellRename(baseMark.cellId, baseMark.count, attach, detach);
 	} else {
-		const length = baseMark.count;
-		return createNoopMark(length, undefined);
-	}
-}
-
-/**
- * Checks if `baseAttach` and `newDetach` are both moves, and if so updates their move endpoints as appropriate,
- * and removes their `finalEndpoint` endpoint fields. Note that can mutate `baseAttach` and `newDetach`.
- * If the effects are not both moves this function does nothing.
- * @param count - The number of cells targeted
- * @param baseAttach - The base attach effect at this location
- * @param newDetach - The new detach effect at this location
- */
-function handleMovePivot(
-	count: number,
-	baseAttach: Attach,
-	newDetach: Detach,
-	moveEffects: MoveEffectTable,
-): void {
-	if (isMoveIn(baseAttach) && isMoveOut(newDetach)) {
-		const finalSource = getEndpoint(baseAttach);
-		const finalDest = getEndpoint(newDetach);
-
-		setEndpoint(moveEffects, CrossFieldTarget.Source, finalSource, count, finalDest);
-
-		const truncatedEndpoint1 = getTruncatedEndpointForInner(
-			moveEffects,
-			CrossFieldTarget.Destination,
-			baseAttach.revision,
-			baseAttach.id,
-			count,
-		);
-
-		if (truncatedEndpoint1 !== undefined) {
-			setTruncatedEndpoint(
-				moveEffects,
-				CrossFieldTarget.Destination,
-				finalDest,
-				count,
-				truncatedEndpoint1,
-			);
+		assert(baseMark.type === "Remove", "Unexpected mark type");
+		assert(newMark.type === "Insert", "Unexpected mark type");
+		const detachId = getDetachedRootId(baseMark);
+		const attachId = getAttachedRootId(newMark);
+
+		// Note that we cannot assert that this returns true,
+		// as it may not be until a second pass that MCF can tell that this is a reattach of the same node.
+		moveEffects.composeDetachAttach(detachId, attachId, baseMark.count, true);
+
+		// The composition has no net effect but we preserve the second change's intention to pin the nodes here.
+		const composedMark = { ...newMark };
+		delete composedMark.cellId;
+		const baseDetachCellId = baseMark.detachCellId ?? detachId;
+		if (!areEqualChangeAtomIds(baseDetachCellId, attachId)) {
+			composedMark.detachCellId = baseDetachCellId;
 		}
 
-		setEndpoint(moveEffects, CrossFieldTarget.Destination, finalDest, count, finalSource);
-
-		const truncatedEndpoint2 = getTruncatedEndpointForInner(
-			moveEffects,
-			CrossFieldTarget.Source,
-			newDetach.revision,
-			newDetach.id,
-			count,
-		);
+		return composedMark;
+	}
+}
 
-		if (truncatedEndpoint2 !== undefined) {
-			setTruncatedEndpoint(
-				moveEffects,
-				CrossFieldTarget.Source,
-				finalSource,
-				count,
-				truncatedEndpoint2,
-			);
+function updateBaseMarkId(moveEffects: ComposeNodeManager, baseMark: Mark): Mark {
+	if (isDetach(baseMark)) {
+		const baseDetachId = getDetachedRootId(baseMark);
+		const updatedDetachId = getUpdatedDetachId(moveEffects, baseMark);
+		if (
+			updatedDetachId !== undefined &&
+			!areEqualChangeAtomIds(updatedDetachId, baseDetachId)
+		) {
+			return {
+				...baseMark,
+				revision: updatedDetachId.revision,
+				id: updatedDetachId.localId,
+				detachCellId: baseMark.detachCellId ?? baseDetachId,
+			};
 		}
-
-		// The `finalEndpoint` field of AttachAndDetach move effect pairs is not used,
-		// so we remove it as a normalization.
-		delete baseAttach.finalEndpoint;
-		delete newDetach.finalEndpoint;
 	}
+
+	return baseMark;
 }
 
 function createNoopMark(
@@ -470,18 +262,21 @@ function handleNodeChanges(
 	baseMark: Mark,
 	newMark: Mark,
 	composeChild: NodeChangeComposer,
-	moveEffects: MoveEffectTable,
+	moveEffects: ComposeNodeManager,
 ): NodeId | undefined {
-	if (newMark.changes !== undefined) {
-		const baseSource = getMoveIn(baseMark);
-
-		// TODO: Make sure composeChild is not called twice on the node changes.
-		if (baseSource !== undefined) {
-			setModifyAfter(moveEffects, getEndpoint(baseSource), newMark.changes);
-			return undefined;
-		}
+	if (
+		newMark.changes !== undefined &&
+		baseMark.type === "Insert" &&
+		baseMark.cellId !== undefined
+	) {
+		moveEffects.sendNewChangesToBaseSourceLocation(
+			getAttachedRootId(baseMark),
+			newMark.changes,
+		);
+		return undefined;
 	}
 
+	// TODO: Make sure composeChild is not called twice on the node changes.
 	return composeChildChanges(baseMark.changes, newMark.changes, composeChild);
 }
 
@@ -497,16 +292,6 @@ function composeChildChanges(
 	return composeChild(baseChange, newChange);
 }
 
-function composeMark<TMark extends Mark>(
-	mark: TMark,
-	moveEffects: MoveEffectTable,
-	composeChild: (node: NodeId) => NodeId | undefined,
-): TMark {
-	const nodeChanges = mark.changes !== undefined ? composeChild(mark.changes) : undefined;
-	const updatedMark = withUpdatedEndpoint(mark, mark.count, moveEffects);
-	return withNodeChange(updatedMark, nodeChanges);
-}
-
 export class ComposeQueue {
 	private readonly baseMarks: MarkQueue;
 	private readonly newMarks: MarkQueue;
@@ -516,11 +301,16 @@ export class ComposeQueue {
 	public constructor(
 		baseMarks: Changeset,
 		newMarks: Changeset,
-		private readonly moveEffects: MoveEffectTable,
+		private readonly moveEffects: ComposeNodeManager,
 		private readonly revisionMetadata: RevisionMetadataSource,
 	) {
-		this.baseMarks = new MarkQueue(baseMarks, moveEffects);
-		this.newMarks = new MarkQueue(newMarks, moveEffects);
+		const queryFunc: NodeRangeQueryFunc = (mark) =>
+			isDetach(mark) || isPin(mark)
+				? moveEffects.getNewChangesForBaseDetach(getMovedNodeId(mark), mark.count).length
+				: mark.count;
+
+		this.baseMarks = new MarkQueue(baseMarks, queryFunc);
+		this.newMarks = new MarkQueue(newMarks, (mark) => mark.count);
 		this.baseMarksCellSources = cellSourcesFromMarks(baseMarks, getOutputCellId);
 		this.newMarksCellSources = cellSourcesFromMarks(newMarks, getInputCellId);
 	}
@@ -533,7 +323,7 @@ export class ComposeQueue {
 		const baseMark = this.baseMarks.peek();
 		const newMark = this.newMarks.peek();
 		if (baseMark === undefined && newMark === undefined) {
-			return {};
+			fail("Should not pop when queue is empty");
 		} else if (baseMark === undefined) {
 			return this.dequeueNew();
 		} else if (newMark === undefined) {
@@ -564,14 +354,18 @@ export class ComposeQueue {
 				this.revisionMetadata,
 			);
 			switch (comparison) {
-				case CellOrder.SameCell:
+				case CellOrder.SameCell: {
 					return this.dequeueBoth();
-				case CellOrder.OldThenNew:
+				}
+				case CellOrder.OldThenNew: {
 					return this.dequeueBase();
-				case CellOrder.NewThenOld:
+				}
+				case CellOrder.NewThenOld: {
 					return this.dequeueNew();
-				default:
+				}
+				default: {
 					unreachableCase(comparison);
+				}
 			}
 		} else if (areOutputCellsEmpty(baseMark)) {
 			return this.dequeueBase();
@@ -585,10 +379,6 @@ export class ComposeQueue {
 	private dequeueBase(length: number = Number.POSITIVE_INFINITY): ComposeMarks {
 		const baseMark = this.baseMarks.dequeueUpTo(length);
 		const movedChanges = getMovedChangesFromMark(this.moveEffects, baseMark);
-		if (movedChanges !== undefined) {
-			this.moveEffects.onMoveIn(movedChanges);
-		}
-
 		const newMark = createNoopMark(baseMark.count, movedChanges, getOutputCellId(baseMark));
 		return { baseMark, newMark };
 	}
@@ -633,195 +423,26 @@ export class ComposeQueue {
 }
 
 interface ComposeMarks {
-	baseMark?: Mark;
-	newMark?: Mark;
+	baseMark: Mark;
+	newMark: Mark;
 }
 
 function getMovedChangesFromMark(
-	moveEffects: MoveEffectTable,
+	moveEffects: ComposeNodeManager,
 	markEffect: MarkEffect,
 ): NodeId | undefined {
-	if (isAttachAndDetachEffect(markEffect)) {
-		return getMovedChangesFromMark(moveEffects, markEffect.detach);
-	}
-	if (!isMoveOut(markEffect)) {
+	if (!isDetach(markEffect)) {
 		return undefined;
 	}
 
-	return getModifyAfter(moveEffects, markEffect.revision, markEffect.id);
-}
-
-// It is expected that the range from `id` to `id + count - 1` has the same move effect.
-// The call sites to this function are making queries about a mark which has already been split by a `MarkQueue`
-// to match the ranges in `moveEffects`.
-// TODO: Reduce the duplication between this and other MoveEffect helpers
-function getModifyAfter(
-	moveEffects: MoveEffectTable,
-	revision: RevisionTag | undefined,
-	id: MoveId,
-): NodeId | undefined {
-	const target = CrossFieldTarget.Source;
-	const effect = getMoveEffect(moveEffects, target, revision, id, 1);
-
-	if (effect.value?.modifyAfter !== undefined) {
-		return effect.value.modifyAfter;
-	}
-
-	return undefined;
-}
-
-// TODO: Reduce the duplication between this and other MoveEffect helpers
-function setModifyAfter(
-	moveEffects: MoveEffectTable,
-	{ revision, localId: id }: ChangeAtomId,
-	modifyAfter: NodeId,
-): void {
-	const target = CrossFieldTarget.Source;
-	const count = 1;
-	const effect = getMoveEffect(moveEffects, target, revision, id, count, false);
-	const newEffect: MoveEffect =
-		effect.value !== undefined ? { ...effect.value, modifyAfter } : { modifyAfter };
-	setMoveEffect(moveEffects, target, revision, id, count, newEffect);
-}
-
-function setEndpoint(
-	moveEffects: MoveEffectTable,
-	target: CrossFieldTarget,
-	id: ChangeAtomId,
-	count: number,
-	endpoint: ChangeAtomId,
-): void {
-	const effect = getMoveEffect(moveEffects, target, id.revision, id.localId, count, false);
-	const newEffect = effect.value !== undefined ? { ...effect.value, endpoint } : { endpoint };
-	setMoveEffect(moveEffects, target, id.revision, id.localId, effect.length, newEffect);
-
-	const remainingCount = count - effect.length;
-	if (remainingCount > 0) {
-		setEndpoint(
-			moveEffects,
-			target,
-			offsetChangeAtomId(id, effect.length),
-			remainingCount,
-			offsetChangeAtomId(endpoint, effect.length),
-		);
-	}
-}
-
-function setTruncatedEndpoint(
-	moveEffects: MoveEffectTable,
-	target: CrossFieldTarget,
-	id: ChangeAtomId,
-	count: number,
-	truncatedEndpoint: ChangeAtomId,
-): void {
-	const effect = getMoveEffect(moveEffects, target, id.revision, id.localId, count);
-	const newEffect =
-		effect.value !== undefined
-			? { ...effect.value, truncatedEndpoint }
-			: { truncatedEndpoint };
-
-	setMoveEffect(moveEffects, target, id.revision, id.localId, effect.length, newEffect);
-
-	const remainingCount = count - effect.length;
-	if (remainingCount > 0) {
-		setTruncatedEndpoint(
-			moveEffects,
-			target,
-			offsetChangeAtomId(id, effect.length),
-			remainingCount,
-			offsetChangeAtomId(truncatedEndpoint, effect.length),
-		);
-	}
-}
-
-function setTruncatedEndpointForInner(
-	moveEffects: MoveEffectTable,
-	target: CrossFieldTarget,
-	id: ChangeAtomId,
-	count: number,
-	truncatedEndpointForInner: ChangeAtomId,
-): void {
-	const effect = getMoveEffect(moveEffects, target, id.revision, id.localId, count);
-	const newEffect =
-		effect.value !== undefined
-			? { ...effect.value, truncatedEndpointForInner }
-			: { truncatedEndpointForInner };
-	setMoveEffect(moveEffects, target, id.revision, id.localId, effect.length, newEffect);
-
-	const remainingCount = count - effect.length;
-	if (remainingCount > 0) {
-		setTruncatedEndpointForInner(
-			moveEffects,
-			target,
-			offsetChangeAtomId(id, effect.length),
-			remainingCount,
-			offsetChangeAtomId(truncatedEndpointForInner, effect.length),
-		);
-	}
-}
-
-function withUpdatedEndpoint<TMark extends MarkEffect>(
-	mark: TMark,
-	count: number,
-	effects: MoveEffectTable,
-): TMark {
-	if (isAttachAndDetachEffect(mark)) {
-		return {
-			...mark,
-			attach: withUpdatedEndpoint(mark.attach, count, effects),
-			detach: withUpdatedEndpoint(mark.detach, count, effects),
-		};
-	}
-
-	if (!isMoveMark(mark)) {
-		return mark;
-	}
-	const finalDest = getComposedEndpoint(
-		effects,
-		getCrossFieldTargetFromMove(mark),
-		mark.revision,
-		mark.id,
-		count,
-	);
-
-	if (finalDest === undefined) {
-		return mark;
-	}
-
-	const output = { ...mark };
-	changeFinalEndpoint(output, finalDest);
-
-	return output;
-}
-
-function changeFinalEndpoint(mark: MoveMarkEffect, endpoint: ChangeAtomId): void {
-	if (areEqualCellIds(endpoint, { revision: mark.revision, localId: mark.id })) {
-		delete mark.finalEndpoint;
-	} else {
-		mark.finalEndpoint = endpoint;
-	}
-}
-
-function getComposedEndpoint(
-	moveEffects: MoveEffectTable,
-	target: CrossFieldTarget,
-	revision: RevisionTag | undefined,
-	id: MoveId,
-	count: number,
-): ChangeAtomId | undefined {
-	const effect = getMoveEffect(moveEffects, target, revision, id, count);
-	assert(effect.length === count, 0x815 /* Expected effect to cover entire mark */);
-	return effect.value?.truncatedEndpoint ?? effect.value?.endpoint;
+	return moveEffects.getNewChangesForBaseDetach(getDetachedRootId(markEffect), 1).value
+		?.nodeChange;
 }
 
-function getTruncatedEndpointForInner(
-	moveEffects: MoveEffectTable,
-	target: CrossFieldTarget,
-	revision: RevisionTag | undefined,
-	id: MoveId,
-	count: number,
+function getUpdatedDetachId(
+	manager: ComposeNodeManager,
+	mark: CellMark<Detach>,
 ): ChangeAtomId | undefined {
-	const effect = getMoveEffect(moveEffects, target, revision, id, count);
-	assert(effect.length === count, 0x934 /* Expected effect to cover entire mark */);
-	return effect.value?.truncatedEndpointForInner;
+	return manager.getNewChangesForBaseDetach(getDetachedRootId(mark), mark.count).value
+		?.detachId;
 }