@fluidframework/tree 2.74.0 → 2.81.0-374083

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

@@ -14,7 +14,7 @@ import {
 	areEqualChangeAtomIds,
 	makeChangeAtomId,
 } from "../../core/index.js";
-import { type Mutable, brand } from "../../util/index.js";
+import { type Mutable, areAdjacentIntegerRanges, brand } from "../../util/index.js";
 import {
 	CrossFieldTarget,
 	type NodeId,
@@ -22,31 +22,21 @@ import {
 	type NestedChangesIndices,
 } from "../modular-schema/index.js";
 
-import type {
-	CellRename,
-	DetachOfRemovedNodes,
-	EmptyInputCellMark,
-	MoveMarkEffect,
-} from "./helperTypes.js";
+import type { DetachOfRemovedNodes, EmptyInputCellMark } from "./helperTypes.js";
 import {
 	type Attach,
-	type AttachAndDetach,
 	type CellId,
 	type CellMark,
 	type Changeset,
 	type Detach,
-	type DetachFields,
 	type HasRevisionTag,
-	type Insert,
 	type Mark,
 	type MarkEffect,
-	type MoveIn,
-	type MoveOut,
 	type NoopMark,
 	NoopMarkType,
-	type Remove,
 	type CellCount,
 	type Rename,
+	type Pin,
 } from "./types.js";
 
 export function isEmpty(change: Changeset): boolean {
@@ -65,23 +55,14 @@ export function createEmpty(): Changeset {
 export function getNestedChanges(change: Changeset): NestedChangesIndices {
 	const output: NestedChangesIndices = [];
 	let inputIndex = 0;
-	let outputIndex = 0;
 	for (const mark of change) {
 		const { changes, count } = mark;
 		if (changes !== undefined) {
-			output.push([
-				changes,
-				!areInputCellsEmpty(mark) ? inputIndex : undefined /* inputIndex */,
-				!areOutputCellsEmpty(mark) ? outputIndex : undefined /* outputIndex */,
-			]);
+			output.push([changes, inputIndex]);
 		}
 		if (!areInputCellsEmpty(mark)) {
 			inputIndex += count;
 		}
-
-		if (!areOutputCellsEmpty(mark)) {
-			outputIndex += count;
-		}
 	}
 	return output;
 }
@@ -96,10 +77,9 @@ export function isNewAttachEffect(
 	revision?: RevisionTag,
 ): boolean {
 	return (
-		(isAttach(effect) &&
-			cellId !== undefined &&
-			(effect.revision ?? revision) === (cellId.revision ?? revision)) ||
-		(isAttachAndDetachEffect(effect) && isNewAttachEffect(effect.attach, cellId, revision))
+		isAttach(effect) &&
+		cellId !== undefined &&
+		(effect.revision ?? revision) === (cellId.revision ?? revision)
 	);
 }
 
@@ -107,12 +87,12 @@ export function isRename(mark: MarkEffect): mark is Rename {
 	return mark.type === "Rename";
 }
 
-export function isInsert(mark: MarkEffect): mark is Insert {
+export function isInsert(mark: MarkEffect): mark is Attach {
 	return mark.type === "Insert";
 }
 
 export function isAttach(effect: MarkEffect): effect is Attach {
-	return effect.type === "Insert" || effect.type === "MoveIn";
+	return effect.type === "Insert";
 }
 
 export function isReattach(mark: Mark): boolean {
@@ -125,7 +105,7 @@ export function isReattachEffect(effect: MarkEffect, cellId: CellId | undefined)
 
 export function isActiveReattach(
 	mark: Mark,
-): mark is CellMark<Insert> & { conflictsWith?: undefined } {
+): mark is CellMark<Attach> & { conflictsWith?: undefined } {
 	return isAttach(mark) && isReattachEffect(mark, mark.cellId) && mark.cellId !== undefined;
 }
 
@@ -138,15 +118,24 @@ export function getInputCellId(mark: Mark): CellId | undefined {
 }
 
 export function getOutputCellId(mark: Mark): CellId | undefined {
-	if (isDetach(mark) || isRename(mark)) {
-		return getDetachOutputCellId(mark);
-	} else if (markFillsCells(mark)) {
-		return undefined;
-	} else if (isAttachAndDetachEffect(mark)) {
-		return getDetachOutputCellId(mark.detach);
+	const type = mark.type;
+	switch (type) {
+		case NoopMarkType: {
+			return getInputCellId(mark);
+		}
+		case "Insert": {
+			return undefined;
+		}
+		case "Remove": {
+			return getDetachOutputCellId(mark);
+		}
+		case "Rename": {
+			return mark.idOverride;
+		}
+		default: {
+			unreachableCase(type);
+		}
 	}
-
-	return getInputCellId(mark);
 }
 
 export function cellSourcesFromMarks(
@@ -208,12 +197,12 @@ export function compareCellPositionsUsingTombstones(
 		// If both changesets know of both cells, but we've been asked to compare different cells,
 		// Then either the changesets they originate from do not represent the same context,
 		// or the ordering of their cells in inconsistent.
-		// The only exception to this is when we're composing anonymous changesets in a transaction.
+		// The only exception to this is when we're composing changesets in a transaction since they have the same revision but different sets of cells.
 		assert(
-			oldMarkCell.revision === undefined && newMarkCell.revision === undefined,
+			oldMarkCell.revision === newMarkCell.revision,
 			0x8a0 /* Inconsistent cell ordering */,
 		);
-		// We are composing anonymous changesets in a transaction. The new changeset is creating a cell in a gap
+		// We are composing changesets in a transaction. The new changeset is creating a cell in a gap
 		// where the old changeset knows of some now empty cell. We order the new cell relative to the old cell in a
 		// way that is consistent with its tie-breaking behavior should the old cell be concurrently re-filled.
 		// Since only tie-break left is supported at the moment, the new cell comes first.
@@ -246,78 +235,72 @@ export function compareCellPositionsUsingTombstones(
 
 		// Note that these indices are for ordering the revisions in which the cells were named, not the revisions
 		// of the changesets in which the marks targeting these cells appear.
-		const oldCellRevisionIndex = metadata.getIndex(oldMarkCell.revision);
-		const newCellRevisionIndex = metadata.getIndex(newMarkCell.revision);
+		const revisionComparison = metadata.compareRevisions(
+			oldMarkCell.revision,
+			newMarkCell.revision,
+		);
 
 		// If the metadata defines an ordering for the revisions then the cell from the newer revision comes first.
-		if (newCellRevisionIndex !== undefined && oldCellRevisionIndex !== undefined) {
-			return newCellRevisionIndex > oldCellRevisionIndex
-				? CellOrder.NewThenOld
-				: CellOrder.OldThenNew;
-		}
-
-		if (newCellRevisionIndex === undefined && oldCellRevisionIndex === undefined) {
-			// While it is possible for both marks to refer to cells that were named in revisions that are outside
-			// the scope of the metadata, such a scenario should be handled above due to the fact that one of the two
-			// changesets should have tombstones or marks for both cells.
-			//
-			// To see this in the context of rebase, we must consider the lowest common ancestor (LCA) of each change's
-			// original (i.e., unrebased) edit with the head of the branch they will both reside on after the rebase.
-			// ...─(Ti)─...─(Tj)─...─(old')─(new') <- branch both change will reside on after rebase
-			//        |        └─...─(new)
-			//        └─...─(old)
-			// In the diagram above we can see that by the time `new` is being rebased over `old`, both changesets have
-			// been rebased over, and therefore have cell information for, changes `Tj` onwards. This means that one of
-			// The two changesets (the `old` one in the diagram above) will have tombstones or marks for any cells that
-			// `new` refers to so long as those cells were not created on `new`'s branch.
-			// Note that the change that contains the superset of cells (again, ignoring cells created on the other
-			// change's branch) is not always the older change. Consider the following scenario:
-			// ...─(Ti)─...─(Tj)─...─(old')─(new')
-			//        |        └─...─(old)
-			//        └─...─(new)
-			//
-			// The same scenario can arise in the context of compose (just consider composing `old'` and `new'` from
-			// the examples above) with the same resolution.
-			assert(false, 0x8a2 /* Invalid cell ordering scenario */);
-		}
-
-		// The absence of metadata for a cell with a defined revision means that the cell is from a revision that
-		// predates the edits that are within the scope of the metadata. Such a cell is therefore older than the one
-		// for which we do have metadata.
-		return oldCellRevisionIndex === undefined ? CellOrder.NewThenOld : CellOrder.OldThenNew;
+		if (revisionComparison !== 0) {
+			return revisionComparison > 0 ? CellOrder.NewThenOld : CellOrder.OldThenNew;
+		}
+
+		// While it is possible for both marks to refer to cells that were named in revisions that are outside
+		// the scope of the metadata, such a scenario should be handled above due to the fact that one of the two
+		// changesets should have tombstones or marks for both cells.
+		//
+		// To see this in the context of rebase, we must consider the lowest common ancestor (LCA) of each change's
+		// original (i.e., unrebased) edit with the head of the branch they will both reside on after the rebase.
+		// ...─(Ti)─...─(Tj)─...─(old')─(new') <- branch both change will reside on after rebase
+		//        |        └─...─(new)
+		//        └─...─(old)
+		// In the diagram above we can see that by the time `new` is being rebased over `old`, both changesets have
+		// been rebased over, and therefore have cell information for, changes `Tj` onwards. This means that one of
+		// The two changesets (the `old` one in the diagram above) will have tombstones or marks for any cells that
+		// `new` refers to so long as those cells were not created on `new`'s branch.
+		// Note that the change that contains the superset of cells (again, ignoring cells created on the other
+		// change's branch) is not always the older change. Consider the following scenario:
+		// ...─(Ti)─...─(Tj)─...─(old')─(new')
+		//        |        └─...─(old)
+		//        └─...─(new)
+		//
+		// The same scenario can arise in the context of compose (just consider composing `old'` and `new'` from
+		// the examples above) with the same resolution.
+		assert(false, 0x8a2 /* Invalid cell ordering scenario */);
 	}
 }
 
 /**
  * Gets the ID of the cell in the output context of the given detach `mark`.
  */
-export function getDetachOutputCellId(mark: Detach | Rename): ChangeAtomId {
-	if (isRename(mark)) {
-		return mark.idOverride;
+export function getDetachOutputCellId(mark: Detach): ChangeAtomId {
+	if (mark.cellRename !== undefined) {
+		return mark.cellRename;
 	}
-	if (mark.idOverride !== undefined) {
-		return mark.idOverride;
+
+	if (mark.detachCellId !== undefined) {
+		return mark.detachCellId;
 	}
-	return mark.revision === undefined
-		? { localId: mark.id }
-		: { revision: mark.revision, localId: mark.id };
+
+	return getDetachedRootId(mark);
+}
+
+/**
+ * Gets the ID of the node to be attached in the input context of the given detach `mark`.
+ */
+export function getAttachedRootId(mark: Attach): ChangeAtomId {
+	return makeChangeAtomId(mark.id, mark.revision);
 }
 
 /**
  * Gets the ID of the detached node in the output context of the given detach `mark`.
  */
-export function getDetachedNodeId(mark: Detach | Rename): ChangeAtomId {
-	switch (mark.type) {
-		case "Rename":
-		case "Remove": {
-			return getDetachOutputCellId(mark);
-		}
-		case "MoveOut": {
-			return makeChangeAtomId(mark.id, mark.revision);
-		}
-		default:
-			unreachableCase(mark);
-	}
+export function getDetachedRootId(mark: Detach): ChangeAtomId {
+	return makeChangeAtomId(mark.id, mark.revision);
+}
+
+export function getMovedNodeId(mark: Attach | Detach): ChangeAtomId {
+	return makeChangeAtomId(mark.id, mark.revision);
 }
 
 /**
@@ -328,65 +311,18 @@ export function normalizeCellRename(
 	count: CellCount,
 	attach: Attach,
 	detach: Detach,
-): CellMark<AttachAndDetach | DetachOfRemovedNodes | Rename | NoopMark> {
-	if (attach.type === "MoveIn") {
-		if (detach.type === "MoveOut") {
-			const outputId = getDetachOutputCellId(detach);
-			// Note that the output ID may be the same as the cellId. In such a scenario,
-			// we output an (impact-less) Rename mark anyway (as opposed to a Skip)
-			// because the resulting Rename may be rebased over other changes that rename the input cell,
-			// eventually leading to an impactful rename.
-			return {
-				type: "Rename",
-				count,
-				cellId,
-				idOverride: outputId,
-			};
-		}
-	} else {
-		// Normalization: when the attach is an insert/revive, we rely on the implicit reviving semantics of the
-		// detach instead of using an explicit revive effect in an AttachAndDetach
-		return {
-			...detach,
-			count,
-			cellId,
-		};
-	}
+): CellMark<DetachOfRemovedNodes | Rename | NoopMark> {
+	const outputId = getDetachOutputCellId(detach);
+	// Note that the output ID may be the same as the cellId. In such a scenario,
+	// we output an (impact-less) Rename mark anyway (as opposed to a Skip)
+	// because the resulting Rename may be rebased over other changes that rename the input cell,
+	// eventually leading to an impactful rename.
 	return {
-		type: "AttachAndDetach",
-		attach,
-		detach,
-		count,
-		cellId,
-	};
-}
-
-/**
- * Preserves the semantics of the given `mark` but repackages it into an `AttachAndDetach` mark if it is not already one.
- */
-export function asAttachAndDetach(mark: CellMark<CellRename>): CellMark<AttachAndDetach> {
-	if (mark.type === "AttachAndDetach") {
-		return mark;
-	}
-	const { cellId, count, changes, revision, ...effect } = mark;
-	const attachAndDetach: CellMark<AttachAndDetach | Detach> = {
-		type: "AttachAndDetach",
+		type: "Rename",
 		count,
 		cellId,
-		attach: {
-			type: "Insert",
-			id: mark.id,
-		},
-		detach: effect,
+		idOverride: outputId,
 	};
-	if (changes !== undefined) {
-		attachAndDetach.changes = changes;
-	}
-	if (revision !== undefined) {
-		attachAndDetach.attach.revision = revision;
-		attachAndDetach.detach.revision = revision;
-	}
-	return attachAndDetach;
 }
 
 export function cloneMark<TMark extends Mark>(mark: TMark): TMark {
@@ -400,10 +336,6 @@ export function cloneMark<TMark extends Mark>(mark: TMark): TMark {
 
 export function cloneMarkEffect<TEffect extends MarkEffect>(effect: TEffect): TEffect {
 	const clone = { ...effect };
-	if (clone.type === "AttachAndDetach") {
-		clone.attach = cloneMarkEffect(clone.attach);
-		clone.detach = cloneMarkEffect(clone.detach);
-	}
 	return clone;
 }
 
@@ -442,18 +374,6 @@ export function markHasCellEffect(mark: Mark): boolean {
 	return areInputCellsEmpty(mark) !== areOutputCellsEmpty(mark);
 }
 
-export function isAttachAndDetachEffect(effect: MarkEffect): effect is AttachAndDetach {
-	return effect.type === "AttachAndDetach";
-}
-
-export function isDetachOfRemovedNodes(mark: Mark): mark is CellMark<DetachOfRemovedNodes> {
-	return isDetach(mark) && mark.cellId !== undefined;
-}
-
-export function isImpactfulCellRename(mark: Mark): mark is CellMark<CellRename> {
-	return (isAttachAndDetachEffect(mark) || isDetachOfRemovedNodes(mark)) && isImpactful(mark);
-}
-
 export function areInputCellsEmpty(mark: Mark): mark is EmptyInputCellMark {
 	return mark.cellId !== undefined;
 }
@@ -461,35 +381,22 @@ export function areInputCellsEmpty(mark: Mark): mark is EmptyInputCellMark {
 export function areOutputCellsEmpty(mark: Mark): boolean {
 	const type = mark.type;
 	switch (type) {
-		case NoopMarkType:
+		case NoopMarkType: {
 			return mark.cellId !== undefined;
+		}
 		case "Remove":
-		case "Rename":
-		case "MoveOut":
-		case "AttachAndDetach":
+		case "Rename": {
 			return true;
-		case "MoveIn":
-		case "Insert":
+		}
+		case "Insert": {
 			return false;
-		default:
+		}
+		default: {
 			unreachableCase(type);
+		}
 	}
 }
 
-/**
- * Creates a mark that is equivalent to the given `mark` but with effects removed if those have no impact in the input
- * context of that mark.
- *
- * @param mark - The mark to settle. Never mutated.
- * @returns either the original mark or a shallow clone of it with effects stripped out.
- */
-export function settleMark(mark: Mark): Mark {
-	if (isImpactful(mark)) {
-		return mark;
-	}
-	return omitMarkEffect(mark);
-}
-
 /**
  * Returns true if and only iff the given `mark` would have impact on the field when applied.
  *
@@ -500,10 +407,12 @@ export function settleMark(mark: Mark): Mark {
 export function isImpactful(mark: Mark): boolean {
 	const type = mark.type;
 	switch (type) {
-		case NoopMarkType:
+		case NoopMarkType: {
 			return false;
-		case "Rename":
+		}
+		case "Rename": {
 			return true;
+		}
 		case "Remove": {
 			const inputId = getInputCellId(mark);
 			if (inputId === undefined) {
@@ -513,18 +422,13 @@ export function isImpactful(mark: Mark): boolean {
 			assert(outputId !== undefined, 0x824 /* Remove marks must have an output cell ID */);
 			return !areEqualChangeAtomIds(inputId, outputId);
 		}
-		case "AttachAndDetach":
-		case "MoveOut":
-			return true;
-		case "MoveIn":
-			// MoveIn marks always target an empty cell.
-			assert(mark.cellId !== undefined, 0x825 /* MoveIn marks should target empty cells */);
-			return true;
-		case "Insert":
+		case "Insert": {
 			// A Revive has no impact if the nodes are already in the document.
 			return mark.cellId !== undefined;
-		default:
+		}
+		default: {
 			unreachableCase(type);
+		}
 	}
 }
 
@@ -565,14 +469,18 @@ export function compareCellsFromSameRevision(
 
 export function isDetach(mark: MarkEffect | undefined): mark is Detach {
 	const type = mark?.type;
-	return type === "Remove" || type === "MoveOut";
+	return type === "Remove";
 }
 
-export function isRemoveMark(mark: Mark | undefined): mark is CellMark<Remove> {
+export function isPin(mark: Mark): mark is Pin {
+	return mark?.type === "Insert" && mark.cellId === undefined;
+}
+
+export function isRemoveMark(mark: Mark | undefined): mark is CellMark<Detach> {
 	return mark?.type === "Remove";
 }
 
-function areMergeableChangeAtoms(
+export function areMergeableChangeAtoms(
 	lhs: ChangeAtomId | undefined,
 	lhsCount: number,
 	rhs: ChangeAtomId | undefined,
@@ -582,29 +490,11 @@ function areMergeableChangeAtoms(
 	}
 
 	return (
-		lhs.revision === rhs.revision && areAdjacentIdRanges(lhs.localId, lhsCount, rhs.localId)
+		lhs.revision === rhs.revision &&
+		areAdjacentIntegerRanges(lhs.localId, lhsCount, rhs.localId)
 	);
 }
 
-function areAdjacentIdRanges(
-	firstStart: ChangesetLocalId,
-	firstLength: number,
-	secondStart: ChangesetLocalId,
-): boolean {
-	return (firstStart as number) + firstLength === secondStart;
-}
-
-function haveMergeableIdOverrides(
-	lhs: DetachFields,
-	lhsCount: number,
-	rhs: DetachFields,
-): boolean {
-	if (lhs.idOverride !== undefined && rhs.idOverride !== undefined) {
-		return areMergeableCellIds(lhs.idOverride, lhsCount, rhs.idOverride);
-	}
-	return (lhs.idOverride === undefined) === (rhs.idOverride === undefined);
-}
-
 function areMergeableCellIds(
 	lhs: CellId | undefined,
 	lhsCount: number,
@@ -654,48 +544,28 @@ function tryMergeEffects(
 		return lhs;
 	}
 
-	if (rhs.type === "AttachAndDetach") {
-		const lhsAttachAndDetach = lhs as AttachAndDetach;
-		const attach = tryMergeEffects(lhsAttachAndDetach.attach, rhs.attach, lhsCount);
-		const detach = tryMergeEffects(lhsAttachAndDetach.detach, rhs.detach, lhsCount);
-		if (attach === undefined || detach === undefined) {
-			return undefined;
-		}
-
-		assert(
-			isAttach(attach) && isDetach(detach),
-			0x826 /* Merged marks should be same type as input marks */,
-		);
-		return { ...lhsAttachAndDetach, attach, detach };
-	}
-
 	if (
 		(lhs as Partial<HasRevisionTag>).revision !== (rhs as Partial<HasRevisionTag>).revision
 	) {
 		return undefined;
 	}
 
-	if (isDetach(lhs) && isDetach(rhs) && !haveMergeableIdOverrides(lhs, lhsCount, rhs)) {
+	if (
+		isDetach(lhs) &&
+		isDetach(rhs) &&
+		!areMergeableChangeAtoms(lhs.cellRename, lhsCount, rhs.cellRename)
+	) {
 		return undefined;
 	}
 
 	const type = rhs.type;
 	switch (type) {
-		case "MoveIn": {
-			const lhsMoveIn = lhs as MoveIn;
-			if (
-				(lhsMoveIn.id as number) + lhsCount === rhs.id &&
-				areMergeableChangeAtoms(lhsMoveIn.finalEndpoint, lhsCount, rhs.finalEndpoint)
-			) {
-				return lhsMoveIn;
-			}
-			break;
-		}
 		case "Remove": {
-			const lhsDetach = lhs as Remove;
+			const lhsDetach = lhs as Detach;
 			if (
 				(lhsDetach.id as number) + lhsCount === rhs.id &&
-				haveMergeableIdOverrides(lhsDetach, lhsCount, rhs)
+				areMergeableChangeAtoms(lhsDetach.cellRename, lhsCount, rhs.cellRename) &&
+				areMergeableChangeAtoms(lhsDetach.detachCellId, lhsCount, rhs.detachCellId)
 			) {
 				return lhsDetach;
 			}
@@ -703,31 +573,24 @@ function tryMergeEffects(
 		}
 		case "Rename": {
 			const lhsDetach = lhs as Rename;
-			if (haveMergeableIdOverrides(lhsDetach, lhsCount, rhs)) {
+			if (areMergeableChangeAtoms(lhsDetach.idOverride, lhsCount, rhs.idOverride)) {
 				return lhsDetach;
 			}
 			break;
 		}
-		case "MoveOut": {
-			const lhsMoveOut = lhs as MoveOut;
+		case "Insert": {
+			const lhsInsert = lhs as Attach;
 			if (
-				(lhsMoveOut.id as number) + lhsCount === rhs.id &&
-				haveMergeableIdOverrides(lhsMoveOut, lhsCount, rhs) &&
-				areMergeableChangeAtoms(lhsMoveOut.finalEndpoint, lhsCount, rhs.finalEndpoint)
+				(lhsInsert.id as number) + lhsCount === rhs.id &&
+				areMergeableChangeAtoms(lhsInsert.detachCellId, lhsCount, rhs.detachCellId)
 			) {
-				return lhsMoveOut;
-			}
-			break;
-		}
-		case "Insert": {
-			const lhsInsert = lhs as Insert;
-			if ((lhsInsert.id as number) + lhsCount === rhs.id) {
 				return lhsInsert;
 			}
 			break;
 		}
-		default:
+		default: {
 			unreachableCase(type);
+		}
 	}
 
 	return undefined;
@@ -768,8 +631,9 @@ export function splitMarkEffect<TEffect extends MarkEffect>(
 ): [TEffect, TEffect] {
 	const type = effect.type;
 	switch (type) {
-		case NoopMarkType:
+		case NoopMarkType: {
 			return [effect, effect];
+		}
 		case "Insert": {
 			const effect1: TEffect = {
 				...effect,
@@ -778,23 +642,23 @@ export function splitMarkEffect<TEffect extends MarkEffect>(
 				...effect,
 				id: (effect.id as number) + length,
 			};
-			return [effect1, effect2];
-		}
-		case "MoveIn": {
-			const effect2: TEffect = { ...effect, id: (effect.id as number) + length };
-			const move2 = effect2 as MoveIn;
-			if (move2.finalEndpoint !== undefined) {
-				move2.finalEndpoint = splitDetachEvent(move2.finalEndpoint, length);
+
+			if (effect.detachCellId !== undefined) {
+				(effect2 as Attach).detachCellId = splitDetachEvent(effect.detachCellId, length);
 			}
-			return [effect, effect2];
+			return [effect1, effect2];
 		}
 		case "Remove": {
 			const effect1 = { ...effect };
 			const id2: ChangesetLocalId = brand((effect.id as number) + length);
 			const effect2 = { ...effect, id: id2 };
-			const effect2Remove = effect2 as Mutable<Remove>;
-			if (effect2Remove.idOverride !== undefined) {
-				effect2Remove.idOverride = splitDetachEvent(effect2Remove.idOverride, length);
+			const effect2Remove = effect2 as Mutable<Detach>;
+			if (effect2Remove.cellRename !== undefined) {
+				effect2Remove.cellRename = splitDetachEvent(effect2Remove.cellRename, length);
+			}
+
+			if (effect2Remove.detachCellId !== undefined) {
+				effect2Remove.detachCellId = splitDetachEvent(effect2Remove.detachCellId, length);
 			}
 			return [effect1, effect2];
 		}
@@ -807,42 +671,9 @@ export function splitMarkEffect<TEffect extends MarkEffect>(
 			}
 			return [effect1, effect2];
 		}
-		case "MoveOut": {
-			const effect2 = {
-				...effect,
-				id: (effect.id as number) + length,
-			};
-
-			const return2 = effect2 as Mutable<MoveOut>;
-
-			if (return2.idOverride !== undefined) {
-				return2.idOverride = splitDetachEvent(return2.idOverride, length);
-			}
-
-			if (return2.finalEndpoint !== undefined) {
-				return2.finalEndpoint = splitDetachEvent(return2.finalEndpoint, length);
-			}
-			return [effect, effect2];
-		}
-		case "AttachAndDetach": {
-			const [attach1, attach2] = splitMarkEffect(effect.attach, length);
-			const [detach1, detach2] = splitMarkEffect(effect.detach, length);
-			const effect1 = {
-				...effect,
-				attach: attach1,
-				detach: detach1,
-			};
-
-			const effect2 = {
-				...effect,
-				attach: attach2,
-				detach: detach2,
-			};
-
-			return [effect1, effect2];
-		}
-		default:
+		default: {
 			unreachableCase(type);
+		}
 	}
 }
 
@@ -876,10 +707,10 @@ export function withNodeChange<TMark extends CellMark<TKind>, TKind extends Mark
 	changes: NodeId | undefined,
 ): TMark {
 	const newMark = { ...mark };
-	if (changes !== undefined) {
-		newMark.changes = changes;
-	} else {
+	if (changes === undefined) {
 		delete newMark.changes;
+	} else {
+		newMark.changes = changes;
 	}
 	return newMark;
 }
@@ -909,12 +740,6 @@ function addRevision(effect: MarkEffect, revision: RevisionTag): void {
 		return;
 	}
 
-	if (effect.type === "AttachAndDetach") {
-		addRevision(effect.attach, revision);
-		addRevision(effect.detach, revision);
-		return;
-	}
-
 	assert(
 		effect.revision === undefined || effect.revision === revision,
 		0x829 /* Should not overwrite mark revision */,
@@ -922,73 +747,53 @@ function addRevision(effect: MarkEffect, revision: RevisionTag): void {
 	effect.revision = revision;
 }
 
-export function getEndpoint(effect: MoveMarkEffect): ChangeAtomId {
-	return effect.finalEndpoint ?? { revision: effect.revision, localId: effect.id };
-}
-
 export function getCrossFieldKeys(change: Changeset): CrossFieldKeyRange[] {
 	const keys: CrossFieldKeyRange[] = [];
 	for (const mark of change) {
-		keys.push(...getCrossFieldKeysForMarkEffect(mark, mark.count));
+		keys.push(...getCrossFieldKeysForMark(mark, mark.count));
 	}
 
 	return keys;
 }
 
-function getCrossFieldKeysForMarkEffect(
-	effect: MarkEffect,
-	count: number,
-): CrossFieldKeyRange[] {
-	switch (effect.type) {
-		case "Insert":
-			// An insert behaves like a move where the source and destination are at the same location.
-			// An insert can become a move when after rebasing.
-			return [
-				{
-					key: {
-						target: CrossFieldTarget.Source,
-						revision: effect.revision,
-						localId: effect.id,
-					},
-					count,
-				},
+function getCrossFieldKeysForMark(mark: Mark, count: number): CrossFieldKeyRange[] {
+	switch (mark.type) {
+		case "Insert": {
+			const keys = [
 				{
 					key: {
+						revision: mark.revision,
+						localId: mark.id,
 						target: CrossFieldTarget.Destination,
-						revision: effect.revision,
-						localId: effect.id,
 					},
 					count,
 				},
 			];
-		case "MoveOut":
-			return [
-				{
-					key: {
-						target: CrossFieldTarget.Source,
-						revision: effect.revision,
-						localId: effect.id,
-					},
+
+			if (mark.cellId === undefined) {
+				// This is a pin, which is treated as a detach and attach.
+				keys.push({
+					key: { revision: mark.revision, localId: mark.id, target: CrossFieldTarget.Source },
 					count,
-				},
-			];
-		case "MoveIn":
+				});
+			}
+
+			return keys;
+		}
+		case "Remove": {
 			return [
 				{
 					key: {
-						target: CrossFieldTarget.Destination,
-						revision: effect.revision,
-						localId: effect.id,
+						revision: mark.revision,
+						localId: mark.id,
+						target: CrossFieldTarget.Source,
 					},
 					count,
 				},
 			];
-		case "AttachAndDetach":
-			return [
-				...getCrossFieldKeysForMarkEffect(effect.attach, count),
-				...getCrossFieldKeysForMarkEffect(effect.detach, count),
-			];
-		default:
+		}
+		default: {
 			return [];
+		}
 	}
 }