@fluidframework/tree 2.74.0-370705 → 2.80.0

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

@@ -6,55 +6,71 @@
 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 {
-	ComposeNodeManager,
-	NodeChangeComposer,
-	NodeId,
+import {
+	type CrossFieldManager,
+	CrossFieldTarget,
+	type NodeChangeComposer,
+	type NodeId,
 } from "../modular-schema/index.js";
 
+import type { MoveMarkEffect } from "./helperTypes.js";
 import { MarkListFactory } from "./markListFactory.js";
 import { MarkQueue } from "./markQueue.js";
-import type { NodeRangeQueryFunc } from "./moveEffectTable.js";
-import type {
-	CellMark,
-	Changeset,
-	Detach,
-	Mark,
-	MarkEffect,
-	MarkList,
-	NoopMark,
+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,
 } from "./types.js";
 import {
 	CellOrder,
 	areEqualCellIds,
 	areInputCellsEmpty,
 	areOutputCellsEmpty,
+	asAttachAndDetach,
 	cellSourcesFromMarks,
 	compareCellPositionsUsingTombstones,
 	extractMarkEffect,
-	getAttachedRootId,
-	getDetachOutputCellId,
-	getDetachedRootId,
+	getEndpoint,
 	getInputCellId,
-	getMovedNodeId,
 	getOutputCellId,
 	isAttach,
+	isAttachAndDetachEffect,
 	isDetach,
+	isImpactfulCellRename,
 	isNewAttach,
 	isNoopMark,
-	isPin,
 	isRename,
 	markEmptiesCells,
+	markFillsCells,
 	markHasCellEffect,
 	normalizeCellRename,
+	settleMark,
 	withNodeChange,
+	withRevision,
 } from "./utils.js";
 
 /**
@@ -74,25 +90,63 @@ export function compose(
 	change2: Changeset,
 	composeChild: NodeChangeComposer,
 	_genId: IdAllocator,
-	manager: ComposeNodeManager,
+	manager: CrossFieldManager,
 	revisionMetadata: RevisionMetadataSource,
 ): Changeset {
-	return composeMarkLists(change1, change2, composeChild, manager, revisionMetadata);
+	return composeMarkLists(
+		change1,
+		change2,
+		composeChild,
+		manager as MoveEffectTable,
+		revisionMetadata,
+	);
 }
 
 function composeMarkLists(
 	baseMarkList: MarkList,
 	newMarkList: MarkList,
 	composeChild: NodeChangeComposer,
-	moveEffects: ComposeNodeManager,
+	moveEffects: MoveEffectTable,
 	revisionMetadata: RevisionMetadataSource,
 ): MarkList {
 	const factory = new MarkListFactory();
 	const queue = new ComposeQueue(baseMarkList, newMarkList, moveEffects, revisionMetadata);
 	while (!queue.isEmpty()) {
 		const { baseMark, newMark } = queue.pop();
-		const composedMark = composeMarks(baseMark, newMark, composeChild, moveEffects);
-		factory.push(composedMark);
+		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);
+			}
+		}
 	}
 
 	return factory.list;
@@ -111,77 +165,206 @@ function composeMarks(
 	baseMark: Mark,
 	newMark: Mark,
 	composeChild: NodeChangeComposer,
-	moveEffects: ComposeNodeManager,
+	moveEffects: MoveEffectTable,
 ): Mark {
 	const nodeChange = handleNodeChanges(baseMark, newMark, composeChild, moveEffects);
-	return withNodeChange(composeMarksIgnoreChild(baseMark, newMark, moveEffects), nodeChange);
+
+	return withUpdatedEndpoint(
+		withNodeChange(composeMarksIgnoreChild(baseMark, newMark, moveEffects), nodeChange),
+		baseMark.count,
+		moveEffects,
+	);
 }
 
 function composeMarksIgnoreChild(
 	baseMark: Mark,
 	newMark: Mark,
-	moveEffects: ComposeNodeManager,
+	moveEffects: MoveEffectTable,
 ): Mark {
 	if (isNoopMark(baseMark)) {
 		return newMark;
 	} else if (isNoopMark(newMark)) {
-		return updateBaseMarkId(moveEffects, baseMark);
+		return 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(
-			baseMark.cellId !== undefined && newMark.cellId !== undefined,
-			"Expected marks to target an empty cell",
+			isAttach(newMark) || isAttachAndDetachEffect(newMark),
+			0x9f1 /* Unexpected mark type */,
 		);
 		return { ...newMark, cellId: baseMark.cellId };
 	} else if (isRename(newMark)) {
-		assert(isDetach(baseMark), 0x9f2 /* Unexpected mark type */);
-		return updateBaseMarkId(moveEffects, { ...baseMark, cellRename: newMark.idOverride });
+		assert(
+			isDetach(baseMark) || isAttachAndDetachEffect(baseMark),
+			0x9f2 /* Unexpected mark type */,
+		);
+		return isDetach(baseMark)
+			? { ...baseMark, idOverride: newMark.idOverride }
+			: { ...baseMark, detach: { ...baseMark.detach, idOverride: newMark.idOverride } };
 	}
 
-	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,
+	if (isImpactfulCellRename(newMark)) {
+		const newAttachAndDetach = asAttachAndDetach(newMark);
+		assert(
+			newAttachAndDetach.cellId !== undefined,
+			0x9f3 /* Impactful cell rename must target empty cell */,
 		);
+		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,
+				);
 
-		const pinId = getAttachedRootId(baseMark);
-		return newMark.type === "Remove"
-			? {
-					...newMark,
-					detachCellId: baseMark.detachCellId ?? pinId,
-					cellRename: getDetachOutputCellId(newMark),
+				if (newEndpoint !== undefined) {
+					changeFinalEndpoint(newDetach as MoveMarkEffect, newEndpoint);
+					setTruncatedEndpoint(
+						moveEffects,
+						CrossFieldTarget.Destination,
+						newEndpoint,
+						baseMark.count,
+						newDetachId,
+					);
 				}
-			: 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,
+			}
+
+			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);
 
-			const composed = { cellId: baseMark.cellId, ...newMark };
-			delete composed.detachCellId;
-			return composed;
+			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 updateBaseMarkId(moveEffects, baseMark);
+
+		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,
+			);
+
+			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;
+		}
+	}
+
+	if (!markHasCellEffect(baseMark) && !markHasCellEffect(newMark)) {
+		return createNoopMark(newMark.count, undefined, getInputCellId(baseMark));
+	} else if (!markHasCellEffect(baseMark)) {
+		return newMark;
+	} else if (!markHasCellEffect(newMark)) {
+		return baseMark;
 	} else if (areInputCellsEmpty(baseMark)) {
 		assert(isDetach(newMark), 0x71c /* Unexpected mark type */);
 		assert(isAttach(baseMark), 0x71d /* Expected generative mark */);
@@ -189,11 +372,7 @@ function composeMarksIgnoreChild(
 		const attach = extractMarkEffect(baseMark);
 		const detach = extractMarkEffect(newMark);
 
-		moveEffects.composeAttachDetach(
-			getAttachedRootId(baseMark),
-			getDetachedRootId(newMark),
-			baseMark.count,
-		);
+		handleMovePivot(baseMark.count, attach, detach, moveEffects);
 
 		if (areEqualCellIds(getOutputCellId(newMark), baseMark.cellId)) {
 			// The output and input cell IDs are the same, so this mark has no effect.
@@ -201,45 +380,74 @@ function composeMarksIgnoreChild(
 		}
 		return normalizeCellRename(baseMark.cellId, baseMark.count, attach, detach);
 	} else {
-		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;
-		}
-
-		return composedMark;
+		const length = baseMark.count;
+		return createNoopMark(length, undefined);
 	}
 }
 
-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,
-			};
+/**
+ * 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,
+			);
+		}
+
+		setEndpoint(moveEffects, CrossFieldTarget.Destination, finalDest, count, finalSource);
+
+		const truncatedEndpoint2 = getTruncatedEndpointForInner(
+			moveEffects,
+			CrossFieldTarget.Source,
+			newDetach.revision,
+			newDetach.id,
+			count,
+		);
+
+		if (truncatedEndpoint2 !== undefined) {
+			setTruncatedEndpoint(
+				moveEffects,
+				CrossFieldTarget.Source,
+				finalSource,
+				count,
+				truncatedEndpoint2,
+			);
 		}
-	}
 
-	return baseMark;
+		// The `finalEndpoint` field of AttachAndDetach move effect pairs is not used,
+		// so we remove it as a normalization.
+		delete baseAttach.finalEndpoint;
+		delete newDetach.finalEndpoint;
+	}
 }
 
 function createNoopMark(
@@ -262,19 +470,18 @@ function handleNodeChanges(
 	baseMark: Mark,
 	newMark: Mark,
 	composeChild: NodeChangeComposer,
-	moveEffects: ComposeNodeManager,
+	moveEffects: MoveEffectTable,
 ): NodeId | undefined {
 	if (newMark.changes !== undefined) {
-		if (baseMark.type === "Insert" && baseMark.cellId !== undefined) {
-			moveEffects.sendNewChangesToBaseSourceLocation(
-				getAttachedRootId(baseMark),
-				newMark.changes,
-			);
+		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;
 		}
 	}
 
-	// TODO: Make sure composeChild is not called twice on the node changes.
 	return composeChildChanges(baseMark.changes, newMark.changes, composeChild);
 }
 
@@ -290,6 +497,16 @@ 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 ? undefined : composeChild(mark.changes);
+	const updatedMark = withUpdatedEndpoint(mark, mark.count, moveEffects);
+	return withNodeChange(updatedMark, nodeChanges);
+}
+
 export class ComposeQueue {
 	private readonly baseMarks: MarkQueue;
 	private readonly newMarks: MarkQueue;
@@ -299,16 +516,11 @@ export class ComposeQueue {
 	public constructor(
 		baseMarks: Changeset,
 		newMarks: Changeset,
-		private readonly moveEffects: ComposeNodeManager,
+		private readonly moveEffects: MoveEffectTable,
 		private readonly revisionMetadata: RevisionMetadataSource,
 	) {
-		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.baseMarks = new MarkQueue(baseMarks, moveEffects);
+		this.newMarks = new MarkQueue(newMarks, moveEffects);
 		this.baseMarksCellSources = cellSourcesFromMarks(baseMarks, getOutputCellId);
 		this.newMarksCellSources = cellSourcesFromMarks(newMarks, getInputCellId);
 	}
@@ -321,7 +533,7 @@ export class ComposeQueue {
 		const baseMark = this.baseMarks.peek();
 		const newMark = this.newMarks.peek();
 		if (baseMark === undefined && newMark === undefined) {
-			fail("Should not pop when queue is empty");
+			return {};
 		} else if (baseMark === undefined) {
 			return this.dequeueNew();
 		} else if (newMark === undefined) {
@@ -352,14 +564,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();
@@ -373,6 +589,10 @@ 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 };
 	}
@@ -417,26 +637,195 @@ export class ComposeQueue {
 }
 
 interface ComposeMarks {
-	baseMark: Mark;
-	newMark: Mark;
+	baseMark?: Mark;
+	newMark?: Mark;
 }
 
 function getMovedChangesFromMark(
-	moveEffects: ComposeNodeManager,
+	moveEffects: MoveEffectTable,
 	markEffect: MarkEffect,
 ): NodeId | undefined {
-	if (!isDetach(markEffect)) {
+	if (isAttachAndDetachEffect(markEffect)) {
+		return getMovedChangesFromMark(moveEffects, markEffect.detach);
+	}
+	if (!isMoveOut(markEffect)) {
 		return undefined;
 	}
 
-	return moveEffects.getNewChangesForBaseDetach(getDetachedRootId(markEffect), 1).value
-		?.nodeChange;
+	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 ? { modifyAfter } : { ...effect.value, 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 ? { endpoint } : { ...effect.value, 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
+			? { truncatedEndpoint }
+			: { ...effect.value, 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
+			? { truncatedEndpointForInner }
+			: { ...effect.value, 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;
 }
 
-function getUpdatedDetachId(
-	manager: ComposeNodeManager,
-	mark: CellMark<Detach>,
+function getTruncatedEndpointForInner(
+	moveEffects: MoveEffectTable,
+	target: CrossFieldTarget,
+	revision: RevisionTag | undefined,
+	id: MoveId,
+	count: number,
 ): ChangeAtomId | undefined {
-	return manager.getNewChangesForBaseDetach(getDetachedRootId(mark), mark.count).value
-		?.detachId;
+	const effect = getMoveEffect(moveEffects, target, revision, id, count);
+	assert(effect.length === count, 0x934 /* Expected effect to cover entire mark */);
+	return effect.value?.truncatedEndpointForInner;
 }