@fluidframework/tree 2.0.0-rc.2.0.2 → 2.0.0-rc.3.0.0

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

@@ -3,79 +3,78 @@
  * Licensed under the MIT License.
  */
 
-import { assert, unreachableCase } from "@fluidframework/core-utils";
+import { assert, unreachableCase } from "@fluidframework/core-utils/internal";
+
 import {
 	ChangeAtomId,
 	RevisionMetadataSource,
 	RevisionTag,
 	TaggedChange,
 } from "../../core/index.js";
-import { brand, fail, IdAllocator } from "../../util/index.js";
-import { CrossFieldManager, CrossFieldTarget } from "../modular-schema/index.js";
+import { IdAllocator, brand, fail } from "../../util/index.js";
 import {
-	Changeset,
-	Mark,
-	MarkList,
-	NoopMarkType,
-	CellId,
-	NoopMark,
-	CellMark,
-	Detach,
-	MoveId,
-	MarkEffect,
-} from "./types.js";
+	CrossFieldManager,
+	CrossFieldTarget,
+	NodeChangeComposer,
+	NodeId,
+} from "../modular-schema/index.js";
+
+import { CellOrderingMethod, sequenceConfig } from "./config.js";
+import { EmptyInputCellMark, MoveMarkEffect } from "./helperTypes.js";
 import { MarkListFactory } from "./markListFactory.js";
 import { MarkQueue } from "./markQueue.js";
 import {
-	getMoveEffect,
-	setMoveEffect,
-	MoveEffectTable,
 	MoveEffect,
-	isMoveIn,
-	isMoveOut,
-	getMoveIn,
+	MoveEffectTable,
 	getCrossFieldTargetFromMove,
+	getMoveEffect,
+	getMoveIn,
+	isMoveIn,
 	isMoveMark,
+	isMoveOut,
+	setMoveEffect,
 } from "./moveEffectTable.js";
 import {
-	isNoopMark,
-	getOffsetInCellRange,
-	areOutputCellsEmpty,
+	CellId,
+	CellMark,
+	Changeset,
+	Detach,
+	Mark,
+	MarkEffect,
+	MarkList,
+	MoveId,
+	NoopMark,
+	NoopMarkType,
+} from "./types.js";
+import {
+	CellOrder,
+	areEqualCellIds,
 	areInputCellsEmpty,
+	areOutputCellsEmpty,
+	asAttachAndDetach,
+	cellSourcesFromMarks,
+	compareCellPositionsUsingTombstones,
+	compareCellsFromSameRevision,
 	compareLineages,
-	isDetach,
-	markHasCellEffect,
-	withNodeChange,
-	withRevision,
-	markEmptiesCells,
-	isNewAttach,
+	extractMarkEffect,
+	getEndpoint,
 	getInputCellId,
-	isAttach,
+	getOffsetInCellRange,
 	getOutputCellId,
+	isAttach,
+	isAttachAndDetachEffect,
+	isDetach,
+	isImpactfulCellRename,
+	isNewAttach,
+	isNoopMark,
+	markEmptiesCells,
 	markFillsCells,
-	extractMarkEffect,
-	getEndpoint,
-	areEqualCellIds,
+	markHasCellEffect,
 	normalizeCellRename,
-	asAttachAndDetach,
-	isImpactfulCellRename,
 	settleMark,
-	compareCellsFromSameRevision,
-	cellSourcesFromMarks,
-	compareCellPositionsUsingTombstones,
-	CellOrder,
-	isAttachAndDetachEffect,
+	withNodeChange,
+	withRevision,
 } from "./utils.js";
-import { EmptyInputCellMark, MoveMarkEffect } from "./helperTypes.js";
-import { CellOrderingMethod, sequenceConfig } from "./config.js";
-
-/**
- * @internal
- */
-export type NodeChangeComposer<TNodeChange> = (
-	change1: TNodeChange | undefined,
-	change2: TNodeChange | undefined,
-) => TNodeChange | undefined;
 
 /**
  * Composes a sequence of changesets into a single changeset.
@@ -89,31 +88,31 @@ export type NodeChangeComposer<TNodeChange> = (
  * - Support for moves is not implemented.
  * - Support for slices is not implemented.
  */
-export function compose<TNodeChange>(
-	change1: TaggedChange<Changeset<TNodeChange>>,
-	change2: TaggedChange<Changeset<TNodeChange>>,
-	composeChild: NodeChangeComposer<TNodeChange>,
+export function compose(
+	change1: TaggedChange<Changeset>,
+	change2: TaggedChange<Changeset>,
+	composeChild: NodeChangeComposer,
 	_genId: IdAllocator,
 	manager: CrossFieldManager,
 	revisionMetadata: RevisionMetadataSource,
-): Changeset<TNodeChange> {
+): Changeset {
 	return composeMarkLists(
 		change1,
 		change2,
 		composeChild,
-		manager as MoveEffectTable<TNodeChange>,
+		manager as MoveEffectTable,
 		revisionMetadata,
 	);
 }
 
-function composeMarkLists<TNodeChange>(
-	{ change: baseMarkList, revision: baseRev }: TaggedChange<MarkList<TNodeChange>>,
-	{ change: newMarkList, revision: newRev }: TaggedChange<MarkList<TNodeChange>>,
-	composeChild: NodeChangeComposer<TNodeChange>,
-	moveEffects: MoveEffectTable<TNodeChange>,
+function composeMarkLists(
+	{ change: baseMarkList, revision: baseRev }: TaggedChange<MarkList>,
+	{ change: newMarkList, revision: newRev }: TaggedChange<MarkList>,
+	composeChild: NodeChangeComposer,
+	moveEffects: MoveEffectTable,
 	revisionMetadata: RevisionMetadataSource,
-): MarkList<TNodeChange> {
-	const factory = new MarkListFactory<TNodeChange>();
+): MarkList {
+	const factory = new MarkListFactory();
 	const queue = new ComposeQueue(
 		baseRev,
 		baseMarkList,
@@ -130,7 +129,7 @@ function composeMarkLists<TNodeChange>(
 				0x4db /* Non-empty queue should not return two undefined marks */,
 			);
 			factory.push(
-				composeMark(baseMark, baseRev, moveEffects, (node: TNodeChange) =>
+				composeMark(baseMark, baseRev, moveEffects, (node: NodeId) =>
 					composeChildChanges(node, undefined, composeChild),
 				),
 			);
@@ -140,7 +139,7 @@ function composeMarkLists<TNodeChange>(
 			const settledNewMark = settleMark(newMark, newRev, revisionMetadata);
 			if (baseMark === undefined) {
 				factory.push(
-					composeMark(settledNewMark, newRev, moveEffects, (node: TNodeChange) =>
+					composeMark(settledNewMark, newRev, moveEffects, (node: NodeId) =>
 						composeChildChanges(undefined, node, composeChild),
 					),
 				);
@@ -175,48 +174,46 @@ function composeMarkLists<TNodeChange>(
  * Its input range should be the same as `baseMark`'s output range.
  * @returns A mark that is equivalent to applying both `baseMark` and `newMark` successively.
  */
-function composeMarks<TNodeChange>(
+function composeMarks(
 	baseRev: RevisionTag | undefined,
-	baseMark: Mark<TNodeChange>,
+	baseMark: Mark,
 	newRev: RevisionTag | undefined,
-	newMark: Mark<TNodeChange>,
-	composeChild: NodeChangeComposer<TNodeChange>,
-	moveEffects: MoveEffectTable<TNodeChange>,
+	newMark: Mark,
+	composeChild: NodeChangeComposer,
+	moveEffects: MoveEffectTable,
 	revisionMetadata: RevisionMetadataSource,
-): Mark<TNodeChange> {
+): Mark {
 	const nodeChange = handleNodeChanges(baseMark, baseRev, newMark, composeChild, moveEffects);
 
-	// We apply endpoint updates after handling node changes because moved nodes should be sent to the endpoint in the base changeset,
-	// not the endpoint in the composed changeset.
-	return withNodeChange(
-		composeMarksIgnoreChild(
-			withUpdatedEndpoint(
+	return withUpdatedEndpoint(
+		withNodeChange(
+			composeMarksIgnoreChild(
 				withRevision(baseMark, baseRev),
-				baseMark.count,
-				baseRev,
+				withRevision(newMark, newRev),
 				moveEffects,
+				revisionMetadata,
 			),
-			withUpdatedEndpoint(withRevision(newMark, newRev), newMark.count, newRev, moveEffects),
-			moveEffects,
-			revisionMetadata,
+			nodeChange,
 		),
-		nodeChange,
+		baseMark.count,
+		undefined,
+		moveEffects,
 	);
 }
 
-function composeMarksIgnoreChild<TNodeChange>(
-	baseMark: Mark<TNodeChange>,
-	newMark: Mark<TNodeChange>,
-	moveEffects: MoveEffectTable<TNodeChange>,
+function composeMarksIgnoreChild(
+	baseMark: Mark,
+	newMark: Mark,
+	moveEffects: MoveEffectTable,
 	revisionMetadata: RevisionMetadataSource,
-): Mark<TNodeChange> {
+): Mark {
 	if (isImpactfulCellRename(newMark, undefined, revisionMetadata)) {
 		const newAttachAndDetach = asAttachAndDetach(newMark);
 		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, TNodeChange> = {
+			const newDetach: CellMark<Detach> = {
 				...newAttachAndDetach.detach,
 				count: baseMark.count,
 			};
@@ -235,15 +232,20 @@ function composeMarksIgnoreChild<TNodeChange>(
 				// 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.
-				setEndpoint(
+				const newDetachId = {
+					revision: newDetachRevision,
+					localId: newAttachAndDetach.detach.id,
+				};
+
+				setTruncatedEndpointForInner(
 					moveEffects,
 					CrossFieldTarget.Destination,
 					getEndpoint(baseMark, undefined),
 					baseMark.count,
-					{ revision: newDetachRevision, localId: newAttachAndDetach.detach.id },
+					newDetachId,
 				);
 
-				const newEndpoint = getNewEndpoint(
+				const newEndpoint = getComposedEndpoint(
 					moveEffects,
 					CrossFieldTarget.Source,
 					baseMark.revision,
@@ -253,6 +255,13 @@ function composeMarksIgnoreChild<TNodeChange>(
 
 				if (newEndpoint !== undefined) {
 					changeFinalEndpoint(newDetach as MoveMarkEffect, newEndpoint);
+					setTruncatedEndpoint(
+						moveEffects,
+						CrossFieldTarget.Destination,
+						newEndpoint,
+						baseMark.count,
+						newDetachId,
+					);
 				}
 			}
 
@@ -263,26 +272,6 @@ function composeMarksIgnoreChild<TNodeChange>(
 			const baseAttachAndDetach = asAttachAndDetach(baseMark);
 			const newOutputId = getOutputCellId(newAttachAndDetach, undefined, revisionMetadata);
 
-			if (isMoveIn(baseAttachAndDetach.attach) && isMoveOut(newAttachAndDetach.detach)) {
-				const moveStartId = getEndpoint(baseAttachAndDetach.attach, undefined);
-				const moveEndId = getEndpoint(newAttachAndDetach.detach, undefined);
-				setEndpoint(
-					moveEffects,
-					CrossFieldTarget.Source,
-					moveStartId,
-					baseMark.count,
-					moveEndId,
-				);
-
-				setEndpoint(
-					moveEffects,
-					CrossFieldTarget.Destination,
-					moveEndId,
-					baseMark.count,
-					moveStartId,
-				);
-			}
-
 			if (areEqualCellIds(newOutputId, baseAttachAndDetach.cellId)) {
 				return { count: baseAttachAndDetach.count, cellId: baseAttachAndDetach.cellId };
 			}
@@ -309,28 +298,51 @@ function composeMarksIgnoreChild<TNodeChange>(
 	if (isImpactfulCellRename(baseMark, undefined, revisionMetadata)) {
 		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 */);
-				setEndpoint(
+
+				const originalAttachId = {
+					revision: baseAttachAndDetach.attach.revision,
+					localId: baseAttachAndDetach.attach.id,
+				};
+
+				setTruncatedEndpointForInner(
 					moveEffects,
 					CrossFieldTarget.Source,
 					getEndpoint(newMark, undefined),
 					baseAttachAndDetach.count,
-					{
-						revision: baseAttachAndDetach.attach.revision,
-						localId: baseAttachAndDetach.attach.id,
-					},
+					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,
+					);
+				}
 			}
 
-			const originalAttach = withRevision(
-				{
-					...baseAttachAndDetach.attach,
-					cellId: baseAttachAndDetach.cellId,
-					count: baseAttachAndDetach.count,
-				},
-				baseAttachAndDetach.attach.revision,
-			);
 			return originalAttach;
 		} else {
 			// Other mark types have been handled by previous conditional branches.
@@ -373,6 +385,24 @@ function composeMarksIgnoreChild<TNodeChange>(
 				finalDest,
 			);
 
+			const truncatedEndpoint1 = getTruncatedEndpointForInner(
+				moveEffects,
+				CrossFieldTarget.Destination,
+				attach.revision,
+				attach.id,
+				baseMark.count,
+			);
+
+			if (truncatedEndpoint1 !== undefined) {
+				setTruncatedEndpoint(
+					moveEffects,
+					CrossFieldTarget.Destination,
+					finalDest,
+					baseMark.count,
+					truncatedEndpoint1,
+				);
+			}
+
 			setEndpoint(
 				moveEffects,
 				CrossFieldTarget.Destination,
@@ -381,6 +411,24 @@ function composeMarksIgnoreChild<TNodeChange>(
 				finalSource,
 			);
 
+			const truncatedEndpoint2 = getTruncatedEndpointForInner(
+				moveEffects,
+				CrossFieldTarget.Source,
+				detach.revision,
+				detach.id,
+				baseMark.count,
+			);
+
+			if (truncatedEndpoint2 !== undefined) {
+				setTruncatedEndpoint(
+					moveEffects,
+					CrossFieldTarget.Source,
+					finalSource,
+					baseMark.count,
+					truncatedEndpoint2,
+				);
+			}
+
 			// The `finalEndpoint` field of AttachAndDetach move effect pairs is not used,
 			// so we remove it as a normalization.
 			delete attach.finalEndpoint;
@@ -406,12 +454,12 @@ function composeMarksIgnoreChild<TNodeChange>(
 	}
 }
 
-function createNoopMark<TNodeChange>(
+function createNoopMark(
 	length: number,
-	nodeChange: TNodeChange | undefined,
+	nodeChange: NodeId | undefined,
 	cellId?: ChangeAtomId,
-): Mark<TNodeChange> {
-	const mark: CellMark<NoopMark, TNodeChange> = { count: length };
+): Mark {
+	const mark: CellMark<NoopMark> = { count: length };
 	if (nodeChange !== undefined) {
 		assert(length === 1, 0x692 /* A mark with a node change must have length one */);
 		mark.changes = nodeChange;
@@ -422,13 +470,13 @@ function createNoopMark<TNodeChange>(
 	return mark;
 }
 
-function handleNodeChanges<TNodeChange>(
-	baseMark: Mark<TNodeChange>,
+function handleNodeChanges(
+	baseMark: Mark,
 	baseRev: RevisionTag | undefined,
-	newMark: Mark<TNodeChange>,
-	composeChild: NodeChangeComposer<TNodeChange>,
-	moveEffects: MoveEffectTable<TNodeChange>,
-): TNodeChange | undefined {
+	newMark: Mark,
+	composeChild: NodeChangeComposer,
+	moveEffects: MoveEffectTable,
+): NodeId | undefined {
 	if (newMark.changes !== undefined) {
 		const baseSource = getMoveIn(baseMark);
 
@@ -442,11 +490,11 @@ function handleNodeChanges<TNodeChange>(
 	return composeChildChanges(baseMark.changes, newMark.changes, composeChild);
 }
 
-function composeChildChanges<TNodeChange>(
-	baseChange: TNodeChange | undefined,
-	newChange: TNodeChange | undefined,
-	composeChild: NodeChangeComposer<TNodeChange>,
-): TNodeChange | undefined {
+function composeChildChanges(
+	baseChange: NodeId | undefined,
+	newChange: NodeId | undefined,
+	composeChild: NodeChangeComposer,
+): NodeId | undefined {
 	if (baseChange === undefined && newChange === undefined) {
 		return undefined;
 	}
@@ -454,29 +502,29 @@ function composeChildChanges<TNodeChange>(
 	return composeChild(baseChange, newChange);
 }
 
-function composeMark<TNodeChange, TMark extends Mark<TNodeChange>>(
+function composeMark<TMark extends Mark>(
 	mark: TMark,
 	revision: RevisionTag | undefined,
-	moveEffects: MoveEffectTable<TNodeChange>,
-	composeChild: (node: TNodeChange) => TNodeChange | undefined,
+	moveEffects: MoveEffectTable,
+	composeChild: (node: NodeId) => NodeId | undefined,
 ): TMark {
 	const nodeChanges = mark.changes !== undefined ? composeChild(mark.changes) : undefined;
 	const updatedMark = withUpdatedEndpoint(mark, mark.count, revision, moveEffects);
 	return withNodeChange(withRevision(updatedMark, revision), nodeChanges);
 }
 
-export class ComposeQueue<T> {
-	private readonly baseMarks: MarkQueue<T>;
-	private readonly newMarks: MarkQueue<T>;
+export class ComposeQueue {
+	private readonly baseMarks: MarkQueue;
+	private readonly newMarks: MarkQueue;
 	private readonly baseMarksCellSources: ReadonlySet<RevisionTag | undefined>;
 	private readonly newMarksCellSources: ReadonlySet<RevisionTag | undefined>;
 
 	public constructor(
 		baseRevision: RevisionTag | undefined,
-		baseMarks: Changeset<T>,
+		baseMarks: Changeset,
 		private readonly newRevision: RevisionTag | undefined,
-		newMarks: Changeset<T>,
-		private readonly moveEffects: MoveEffectTable<T>,
+		newMarks: Changeset,
+		private readonly moveEffects: MoveEffectTable,
 		private readonly revisionMetadata: RevisionMetadataSource,
 	) {
 		this.baseMarks = new MarkQueue(baseMarks, baseRevision, moveEffects);
@@ -499,7 +547,7 @@ export class ComposeQueue<T> {
 		return this.baseMarks.isEmpty() && this.newMarks.isEmpty();
 	}
 
-	public pop(): ComposeMarks<T> {
+	public pop(): ComposeMarks {
 		const baseMark = this.baseMarks.peek();
 		const newMark = this.newMarks.peek();
 		if (baseMark === undefined && newMark === undefined) {
@@ -580,7 +628,7 @@ export class ComposeQueue<T> {
 		}
 	}
 
-	private dequeueBase(length: number = Infinity): ComposeMarks<T> {
+	private dequeueBase(length: number = Infinity): ComposeMarks {
 		const baseMark = this.baseMarks.dequeueUpTo(length);
 		const movedChanges = getMovedChangesFromMark(
 			this.moveEffects,
@@ -596,7 +644,7 @@ export class ComposeQueue<T> {
 		return { baseMark, newMark };
 	}
 
-	private dequeueNew(length: number = Infinity): ComposeMarks<T> {
+	private dequeueNew(length: number = Infinity): ComposeMarks {
 		const newMark = this.newMarks.dequeueUpTo(length);
 		const baseMark = createNoopMark(
 			newMark.count,
@@ -610,7 +658,7 @@ export class ComposeQueue<T> {
 		};
 	}
 
-	private dequeueBoth(): ComposeMarks<T> {
+	private dequeueBoth(): ComposeMarks {
 		const length = this.peekMinLength();
 		const baseMark = this.baseMarks.dequeueUpTo(length);
 		let newMark = this.newMarks.dequeueUpTo(length);
@@ -622,7 +670,7 @@ export class ComposeQueue<T> {
 
 		if (movedChanges !== undefined) {
 			assert(newMark.changes === undefined, 0x8da /* Unexpected node changeset collision */);
-			newMark = withNodeChange(newMark, movedChanges as T);
+			newMark = withNodeChange(newMark, movedChanges);
 		}
 
 		return {
@@ -643,9 +691,9 @@ export class ComposeQueue<T> {
 	}
 }
 
-interface ComposeMarks<T> {
-	baseMark?: Mark<T>;
-	newMark?: Mark<T>;
+interface ComposeMarks {
+	baseMark?: Mark;
+	newMark?: Mark;
 }
 
 // TODO: Try to share more logic with the version in rebase.ts.
@@ -660,7 +708,7 @@ interface ComposeMarks<T> {
 function compareCellPositions(
 	baseCellId: CellId,
 	baseCellCount: number,
-	newMark: EmptyInputCellMark<unknown>,
+	newMark: EmptyInputCellMark,
 	newIntention: RevisionTag | undefined,
 	metadata: RevisionMetadataSource,
 ): number {
@@ -735,11 +783,11 @@ function compareCellPositions(
 	return (baseRevisionIndex ?? -Infinity) > newRevisionIndex ? -Infinity : Infinity;
 }
 
-function getMovedChangesFromMark<T>(
-	moveEffects: MoveEffectTable<T>,
+function getMovedChangesFromMark(
+	moveEffects: MoveEffectTable,
 	markEffect: MarkEffect,
 	revision: RevisionTag | undefined,
-): T | undefined {
+): NodeId | undefined {
 	if (isAttachAndDetachEffect(markEffect)) {
 		return getMovedChangesFromMark(moveEffects, markEffect.detach, revision);
 	}
@@ -754,11 +802,11 @@ function getMovedChangesFromMark<T>(
 // 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<T>(
-	moveEffects: MoveEffectTable<T>,
+function getModifyAfter(
+	moveEffects: MoveEffectTable,
 	revision: RevisionTag | undefined,
 	id: MoveId,
-): T | undefined {
+): NodeId | undefined {
 	const target = CrossFieldTarget.Source;
 	const effect = getMoveEffect(moveEffects, target, revision, id, 1);
 
@@ -770,21 +818,21 @@ function getModifyAfter<T>(
 }
 
 // TODO: Reduce the duplication between this and other MoveEffect helpers
-function setModifyAfter<T>(
-	moveEffects: MoveEffectTable<T>,
+function setModifyAfter(
+	moveEffects: MoveEffectTable,
 	{ revision, localId: id }: ChangeAtomId,
-	modifyAfter: T,
+	modifyAfter: NodeId,
 ) {
 	const target = CrossFieldTarget.Source;
 	const count = 1;
 	const effect = getMoveEffect(moveEffects, target, revision, id, count, false);
-	const newEffect: MoveEffect<T> =
+	const newEffect: MoveEffect =
 		effect.value !== undefined ? { ...effect.value, modifyAfter } : { modifyAfter };
 	setMoveEffect(moveEffects, target, revision, id, count, newEffect);
 }
 
 function setEndpoint(
-	moveEffects: MoveEffectTable<unknown>,
+	moveEffects: MoveEffectTable,
 	target: CrossFieldTarget,
 	id: ChangeAtomId,
 	count: number,
@@ -806,11 +854,62 @@ function setEndpoint(
 	}
 }
 
+function setTruncatedEndpoint(
+	moveEffects: MoveEffectTable,
+	target: CrossFieldTarget,
+	id: ChangeAtomId,
+	count: number,
+	truncatedEndpoint: ChangeAtomId,
+) {
+	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,
+) {
+	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,
 	revision: RevisionTag | undefined,
-	effects: MoveEffectTable<unknown>,
+	effects: MoveEffectTable,
 ): TMark {
 	if (isAttachAndDetachEffect(mark)) {
 		return {
@@ -825,7 +924,7 @@ function withUpdatedEndpoint<TMark extends MarkEffect>(
 	}
 
 	const markRevision = mark.revision ?? revision;
-	const finalDest = getNewEndpoint(
+	const finalDest = getComposedEndpoint(
 		effects,
 		getCrossFieldTargetFromMove(mark),
 		markRevision,
@@ -851,8 +950,8 @@ function changeFinalEndpoint(mark: MoveMarkEffect, endpoint: ChangeAtomId) {
 	}
 }
 
-function getNewEndpoint(
-	moveEffects: MoveEffectTable<unknown>,
+function getComposedEndpoint(
+	moveEffects: MoveEffectTable,
 	target: CrossFieldTarget,
 	revision: RevisionTag | undefined,
 	id: MoveId,
@@ -860,11 +959,19 @@ function getNewEndpoint(
 ): ChangeAtomId | undefined {
 	const effect = getMoveEffect(moveEffects, target, revision, id, count);
 	assert(effect.length === count, 0x815 /* Expected effect to cover entire mark */);
-	if (effect.value?.endpoint === undefined) {
-		return undefined;
-	}
+	return effect.value?.truncatedEndpoint ?? effect.value?.endpoint;
+}
 
-	return effect.value.endpoint;
+function getTruncatedEndpointForInner(
+	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, 0x934 /* Expected effect to cover entire mark */);
+	return effect.value?.truncatedEndpointForInner;
 }
 
 function offsetChangeAtomId(id: ChangeAtomId, offset: number): ChangeAtomId {