@fluidframework/tree 2.74.0-370705 → 2.80.0

package/src/feature-libraries/modular-schema/modularChangeFamily.ts

@@ -5,8 +5,13 @@
 
 import { assert, fail } from "@fluidframework/core-utils/internal";
 import { BTree } from "@tylerbu/sorted-btree-es6";
+import { UsageError } from "@fluidframework/telemetry-utils/internal";
 
-import type { ICodecFamily } from "../../codec/index.js";
+import {
+	FluidClientVersion,
+	type CodecWriteOptions,
+	type ICodecFamily,
+} from "../../codec/index.js";
 import {
 	type ChangeEncodingContext,
 	type ChangeFamily,
@@ -22,30 +27,24 @@ import {
 	EditBuilder,
 	type FieldKey,
 	type FieldKindIdentifier,
+	type FieldUpPath,
 	type RevisionInfo,
 	type RevisionMetadataSource,
 	type RevisionTag,
 	type TaggedChange,
+	type UpPath,
 	makeDetachedNodeId,
-	replaceAtomRevisions,
 	revisionMetadataSourceFromInfo,
 	areEqualChangeAtomIds,
 	type ChangeAtomId,
 	areEqualChangeAtomIdOpts,
 	tagChange,
 	makeAnonChange,
+	newChangeAtomIdRangeMap,
 	type DeltaDetachedNodeChanges,
 	type DeltaDetachedNodeRename,
 	mapTaggedChange,
-	newChangeAtomIdRangeMap,
-	newChangeAtomIdTransform,
-	type ChangeAtomIdRangeMap,
-	offsetChangeAtomId,
-	type NormalizedUpPath,
-	type NormalizedFieldUpPath,
-	isDetachedUpPathRoot,
-	subtractChangeAtomIds,
-	makeChangeAtomId,
+	type RevisionReplacer,
 } from "../../core/index.js";
 import {
 	type IdAllocationState,
@@ -61,19 +60,14 @@ import {
 	type TupleBTree,
 	RangeMap,
 	balancedReduce,
-	type RangeQueryEntry,
-	type RangeQueryResultFragment,
 } from "../../util/index.js";
 import type { TreeChunk } from "../chunked-forest/index.js";
 
 import {
-	type ComposeNodeManager,
+	type CrossFieldManager,
 	type CrossFieldMap,
 	CrossFieldTarget,
-	type DetachedNodeEntry,
-	type InvertNodeManager,
-	type RebaseDetachedNodeEntry,
-	type RebaseNodeManager,
+	getFirstFromCrossFieldMap,
 	setInCrossFieldMap,
 } from "./crossFieldQueries.js";
 import {
@@ -84,28 +78,26 @@ import {
 import { convertGenericChange, genericFieldKind } from "./genericFieldKind.js";
 import type { GenericChangeset } from "./genericFieldKindTypes.js";
 import {
-	type ChangeAtomIdBTree,
-	type ChangeAtomIdKey,
 	type CrossFieldKey,
 	type CrossFieldKeyRange,
 	type CrossFieldKeyTable,
-	type CrossFieldRangeTable,
 	type FieldChange,
 	type FieldChangeMap,
 	type FieldChangeset,
 	type FieldId,
-	getFromChangeAtomIdMap,
 	type ModularChangeset,
-	newCrossFieldRangeTable,
+	newCrossFieldKeyTable,
+	type NoChangeConstraint,
 	type NodeChangeset,
 	type NodeId,
-	type NodeLocation,
-	rangeQueryChangeAtomIdMap,
-	type RebaseVersion,
-	type RootNodeTable,
-	setInChangeAtomIdMap,
 } from "./modularChangeTypes.js";
 import type { FlexFieldKind } from "./fieldKind.js";
+import {
+	getFromChangeAtomIdMap,
+	setInChangeAtomIdMap,
+	type ChangeAtomIdBTree,
+} from "../changeAtomIdBTree.js";
+import { lt } from "semver-ts";
 
 /**
  * Implementation of ChangeFamily which delegates work in a given field to the appropriate FieldKind
@@ -123,6 +115,7 @@ export class ModularChangeFamily
 	public constructor(
 		fieldKinds: ReadonlyMap<FieldKindIdentifier, FlexFieldKind>,
 		public readonly codecs: ICodecFamily<ModularChangeset, ChangeEncodingContext>,
+		public readonly codecOptions: CodecWriteOptions,
 	) {
 		this.fieldKinds = fieldKinds;
 	}
@@ -149,9 +142,9 @@ export class ModularChangeFamily
 	} {
 		// TODO: Handle the case where changes have conflicting field kinds
 		const kind =
-			change1.fieldKind !== genericFieldKind.identifier
-				? change1.fieldKind
-				: change2.fieldKind;
+			change1.fieldKind === genericFieldKind.identifier
+				? change2.fieldKind
+				: change1.fieldKind;
 
 		if (kind === genericFieldKind.identifier) {
 			// Both changes are generic
@@ -190,14 +183,14 @@ export class ModularChangeFamily
 	}
 
 	public compose(changes: TaggedChange<ModularChangeset>[]): ModularChangeset {
-		const { maxId } = getRevInfoFromTaggedChanges(changes);
+		const { revInfos, maxId } = getRevInfoFromTaggedChanges(changes);
 		const idState: IdAllocationState = { maxId };
 
 		const pairwiseDelegate = (
 			left: ModularChangeset,
 			right: ModularChangeset,
 		): ModularChangeset => {
-			return this.composePair(left, right, idState);
+			return this.composePair(left, right, revInfos, idState);
 		};
 
 		const innerChanges = changes.map((change) => change.change);
@@ -207,11 +200,10 @@ export class ModularChangeFamily
 	private composePair(
 		change1: ModularChangeset,
 		change2: ModularChangeset,
+		revInfos: RevisionInfo[],
 		idState: IdAllocationState,
 	): ModularChangeset {
-		const revInfos = composeRevInfos(change1.revisions, change2.revisions);
-
-		const { fieldChanges, nodeChanges, nodeToParent, nodeAliases, crossFieldKeys, rootNodes } =
+		const { fieldChanges, nodeChanges, nodeToParent, nodeAliases, crossFieldKeys } =
 			this.composeAllFields(change1, change2, revInfos, idState);
 
 		const { allBuilds, allDestroys, allRefreshers } = composeBuildsDestroysAndRefreshers(
@@ -219,7 +211,12 @@ export class ModularChangeFamily
 			change2,
 		);
 
-		const composed = makeModularChangeset({
+		// The composed changeset has a "no change" constraint if either change has one
+		const noChangeConstraint = change1.noChangeConstraint ?? change2.noChangeConstraint;
+		const noChangeConstraintOnRevert =
+			change1.noChangeConstraintOnRevert ?? change2.noChangeConstraintOnRevert;
+
+		return makeModularChangeset({
 			fieldChanges,
 			nodeChanges,
 			nodeToParent,
@@ -227,15 +224,12 @@ export class ModularChangeFamily
 			crossFieldKeys,
 			maxId: idState.maxId,
 			revisions: revInfos,
-			rootNodes,
+			noChangeConstraint,
+			noChangeConstraintOnRevert,
 			builds: allBuilds,
 			destroys: allDestroys,
 			refreshers: allRefreshers,
 		});
-
-		// XXX: This is an expensive assert which should be disabled before merging.
-		this.validateChangeset(composed);
-		return composed;
 	}
 
 	private composeAllFields(
@@ -265,38 +259,14 @@ export class ModularChangeFamily
 			mergeTupleBTrees(change1.nodeChanges, change2.nodeChanges),
 		);
 
-		const composedNodeToParent: ChangeAtomIdBTree<NodeLocation> = brand(
+		const composedNodeToParent: ChangeAtomIdBTree<FieldId> = brand(
 			mergeTupleBTrees(change1.nodeToParent, change2.nodeToParent),
 		);
 		const composedNodeAliases: ChangeAtomIdBTree<NodeId> = brand(
 			mergeTupleBTrees(change1.nodeAliases, change2.nodeAliases),
 		);
 
-		const pendingCompositions: PendingCompositions = {
-			nodeIdsToCompose: [],
-			affectedBaseFields: newTupleBTree(),
-		};
-
-		const movedCrossFieldKeys: CrossFieldKeyTable = newCrossFieldRangeTable();
-		const removedCrossFieldKeys: CrossFieldRangeTable<boolean> = newCrossFieldRangeTable();
-
-		const composedRoots = composeRootTables(
-			change1,
-			change2,
-			composedNodeToParent,
-			movedCrossFieldKeys,
-			removedCrossFieldKeys,
-			pendingCompositions,
-		);
-
-		const crossFieldTable = newComposeTable(
-			change1,
-			change2,
-			composedRoots,
-			movedCrossFieldKeys,
-			removedCrossFieldKeys,
-			pendingCompositions,
-		);
+		const crossFieldTable = newComposeTable(change1, change2, composedNodeToParent);
 
 		const composedFields = this.composeFieldMaps(
 			change1.fieldChanges,
@@ -317,32 +287,17 @@ export class ModularChangeFamily
 			revisionMetadata,
 		);
 
-		for (const entry of crossFieldTable.renamesToDelete.entries()) {
-			deleteNodeRenameFrom(crossFieldTable.composedRootNodes, entry.start, entry.length);
-		}
-
-		for (const [nodeId, location] of crossFieldTable.movedNodeToParent.entries()) {
-			// Moved nodes are from change2.
-			// If there is a corresponding node in change1, then composedNodeToParent will already have the correct entry,
-			// because the location of the node is the same in change1 and the composed change
-			// (since they have the same input context).
-			if (crossFieldTable.newToBaseNodeId.get(nodeId) === undefined) {
-				composedNodeToParent.set(nodeId, location);
-			}
-		}
-
+		// Currently no field kinds require making changes to cross-field keys during composition, so we can just merge the two tables.
+		const composedCrossFieldKeys = RangeMap.union(
+			change1.crossFieldKeys,
+			change2.crossFieldKeys,
+		);
 		return {
 			fieldChanges: composedFields,
 			nodeChanges: composedNodeChanges,
 			nodeToParent: composedNodeToParent,
 			nodeAliases: composedNodeAliases,
-			crossFieldKeys: composeCrossFieldKeyTables(
-				change1.crossFieldKeys,
-				change2.crossFieldKeys,
-				crossFieldTable.movedCrossFieldKeys,
-				crossFieldTable.removedCrossFieldKeys,
-			),
-			rootNodes: composedRoots,
+			crossFieldKeys: composedCrossFieldKeys,
 		};
 	}
 
@@ -354,16 +309,17 @@ export class ModularChangeFamily
 	): void {
 		const context = crossFieldTable.fieldToContext.get(fieldChange);
 		assert(context !== undefined, 0x8cc /* Should have context for every invalidated field */);
-		const { change1: fieldChange1, change2: fieldChange2, composedChange } = context;
-
-		crossFieldTable.pendingCompositions.affectedBaseFields.delete(
-			fieldIdKeyFromFieldId(context.fieldId),
-		);
+		const { fieldId, change1: fieldChange1, change2: fieldChange2, composedChange } = context;
 
 		const rebaser = getChangeHandler(this.fieldKinds, composedChange.fieldKind).rebaser;
 		const composeNodes = (child1: NodeId | undefined, child2: NodeId | undefined): NodeId => {
-			if (child1 !== undefined && child2 !== undefined) {
-				addNodesToCompose(crossFieldTable, child1, child2);
+			if (
+				child1 !== undefined &&
+				child2 !== undefined &&
+				getFromChangeAtomIdMap(crossFieldTable.newToBaseNodeId, child2) === undefined
+			) {
+				setInChangeAtomIdMap(crossFieldTable.newToBaseNodeId, child2, child1);
+				crossFieldTable.pendingCompositions.nodeIdsToCompose.push([child1, child2]);
 			}
 
 			return child1 ?? child2 ?? fail(0xb22 /* Should not compose two undefined nodes */);
@@ -374,7 +330,7 @@ export class ModularChangeFamily
 			fieldChange2,
 			composeNodes,
 			genId,
-			new ComposeNodeManagerI(crossFieldTable, context.fieldId, false),
+			new ComposeManager(crossFieldTable, fieldChange, fieldId, false),
 			revisionMetadata,
 		);
 		composedChange.change = brand(amendedChange);
@@ -386,7 +342,7 @@ export class ModularChangeFamily
 	 * - discovering that two node changesets refer to the same node (`nodeIdsToCompose`)
 	 * - a previously composed field being invalidated by a cross field effect (`invalidatedFields`)
 	 * - a field which was copied directly from an input changeset being invalidated by a cross field effect
-	 * (`affectedBaseFields`)
+	 * (`affectedBaseFields` and `affectedNewFields`)
 	 *
 	 * Updating an element may invalidate further elements. This function runs until there is no more invalidation.
 	 */
@@ -394,59 +350,72 @@ export class ModularChangeFamily
 		table: ComposeTable,
 		composedFields: FieldChangeMap,
 		composedNodes: ChangeAtomIdBTree<NodeChangeset>,
-		composedNodeToParent: ChangeAtomIdBTree<NodeLocation>,
+		composedNodeToParent: ChangeAtomIdBTree<FieldId>,
 		nodeAliases: ChangeAtomIdBTree<NodeId>,
 		genId: IdAllocator,
 		metadata: RevisionMetadataSource,
 	): void {
 		const pending = table.pendingCompositions;
-		while (pending.nodeIdsToCompose.length > 0 || pending.affectedBaseFields.length > 0) {
-			this.processPendingNodeCompositions(
+		while (
+			table.invalidatedFields.size > 0 ||
+			pending.nodeIdsToCompose.length > 0 ||
+			pending.affectedBaseFields.length > 0 ||
+			pending.affectedNewFields.length > 0
+		) {
+			// Note that the call to `composeNodesById` can add entries to `crossFieldTable.nodeIdPairs`.
+			for (const [id1, id2] of pending.nodeIdsToCompose) {
+				this.composeNodesById(
+					table.baseChange.nodeChanges,
+					table.newChange.nodeChanges,
+					composedNodes,
+					composedNodeToParent,
+					nodeAliases,
+					id1,
+					id2,
+					genId,
+					table,
+					metadata,
+				);
+			}
+
+			pending.nodeIdsToCompose.length = 0;
+
+			this.composeAffectedFields(
 				table,
+				table.baseChange,
+				true,
+				pending.affectedBaseFields,
+				composedFields,
 				composedNodes,
-				composedNodeToParent,
-				nodeAliases,
 				genId,
 				metadata,
 			);
 
 			this.composeAffectedFields(
 				table,
-				table.baseChange,
-				pending.affectedBaseFields,
+				table.newChange,
+				false,
+				pending.affectedNewFields,
 				composedFields,
 				composedNodes,
 				genId,
 				metadata,
 			);
+
+			this.processInvalidatedCompositions(table, genId, metadata);
 		}
 	}
 
-	private processPendingNodeCompositions(
+	private processInvalidatedCompositions(
 		table: ComposeTable,
-		composedNodes: ChangeAtomIdBTree<NodeChangeset>,
-		composedNodeToParent: ChangeAtomIdBTree<NodeLocation>,
-		nodeAliases: ChangeAtomIdBTree<NodeId>,
 		genId: IdAllocator,
 		metadata: RevisionMetadataSource,
 	): void {
-		// Note that the call to `composeNodesById` can add entries to `crossFieldTable.nodeIdPairs`.
-		for (const [id1, id2] of table.pendingCompositions.nodeIdsToCompose) {
-			this.composeNodesById(
-				table.baseChange,
-				table.newChange,
-				composedNodes,
-				composedNodeToParent,
-				nodeAliases,
-				id1,
-				id2,
-				genId,
-				table,
-				metadata,
-			);
+		const fieldsToUpdate = table.invalidatedFields;
+		table.invalidatedFields = new Set();
+		for (const fieldChange of fieldsToUpdate) {
+			this.composeInvalidatedField(fieldChange, table, genId, metadata);
 		}
-
-		table.pendingCompositions.nodeIdsToCompose.length = 0;
 	}
 
 	/**
@@ -463,79 +432,63 @@ export class ModularChangeFamily
 	private composeAffectedFields(
 		table: ComposeTable,
 		change: ModularChangeset,
+		areBaseFields: boolean,
 		affectedFields: BTree<FieldIdKey, true>,
 		composedFields: FieldChangeMap,
 		composedNodes: ChangeAtomIdBTree<NodeChangeset>,
 		genId: IdAllocator,
 		metadata: RevisionMetadataSource,
 	): void {
-		const fieldsToProcess = affectedFields.clone();
-		affectedFields.clear();
-
-		for (const fieldIdKey of fieldsToProcess.keys()) {
-			const fieldId = fieldIdFromFieldIdKey(fieldIdKey);
-			const fieldChange = fieldChangeFromId(change, fieldId);
+		for (const fieldIdKey of affectedFields.keys()) {
+			const fieldId = normalizeFieldId(fieldIdFromFieldIdKey(fieldIdKey), change.nodeAliases);
+			const fieldChange = fieldChangeFromId(change.fieldChanges, change.nodeChanges, fieldId);
 
 			if (
 				table.fieldToContext.has(fieldChange) ||
 				table.newFieldToBaseField.has(fieldChange)
 			) {
-				this.composeInvalidatedField(fieldChange, table, genId, metadata);
-			} else {
-				this.composeFieldWithNoNewChange(
-					table,
-					fieldChange,
-					fieldId,
-					composedFields,
-					composedNodes,
-					genId,
-					metadata,
-				);
+				// This function handles fields which were not part of the intersection of the two changesets but which need to be updated anyway.
+				// If we've already processed this field then either it is up to date
+				// or there is pending inval which will be handled in processInvalidatedCompositions.
+				continue;
 			}
-		}
-	}
 
-	private composeFieldWithNoNewChange(
-		table: ComposeTable,
-		baseFieldChange: FieldChange,
-		fieldId: FieldId,
-		composedFields: FieldChangeMap,
-		composedNodes: ChangeAtomIdBTree<NodeChangeset>,
-		genId: IdAllocator,
-		metadata: RevisionMetadataSource,
-	): void {
-		const emptyChange = this.createEmptyFieldChange(baseFieldChange.fieldKind);
+			const emptyChange = this.createEmptyFieldChange(fieldChange.fieldKind);
+			const [change1, change2] = areBaseFields
+				? [fieldChange, emptyChange]
+				: [emptyChange, fieldChange];
 
-		const composedField = this.composeFieldChanges(
-			fieldId,
-			baseFieldChange,
-			emptyChange,
-			genId,
-			table,
-			metadata,
-		);
+			const composedField = this.composeFieldChanges(
+				fieldId,
+				change1,
+				change2,
+				genId,
+				table,
+				metadata,
+			);
 
-		if (fieldId.nodeId === undefined) {
-			composedFields.set(fieldId.field, composedField);
-			return;
-		}
+			if (fieldId.nodeId === undefined) {
+				composedFields.set(fieldId.field, composedField);
+				continue;
+			}
 
-		const nodeId = normalizeNodeId(
-			getFromChangeAtomIdMap(table.newToBaseNodeId, fieldId.nodeId) ?? fieldId.nodeId,
-			table.baseChange.nodeAliases,
-		);
+			const nodeId =
+				getFromChangeAtomIdMap(table.newToBaseNodeId, fieldId.nodeId) ?? fieldId.nodeId;
 
-		// We clone the node changeset before mutating it, as it may be from one of the input changesets.
-		const nodeChangeset: Mutable<NodeChangeset> = cloneNodeChangeset(
-			nodeChangeFromId(composedNodes, table.baseChange.nodeAliases, nodeId),
-		);
-		setInChangeAtomIdMap(composedNodes, nodeId, nodeChangeset);
+			let nodeChangeset = nodeChangeFromId(composedNodes, nodeId);
+			if (!table.composedNodes.has(nodeChangeset)) {
+				nodeChangeset = cloneNodeChangeset(nodeChangeset);
+				setInChangeAtomIdMap(composedNodes, nodeId, nodeChangeset);
+			}
 
-		if (nodeChangeset.fieldChanges === undefined) {
-			nodeChangeset.fieldChanges = new Map();
+			if (nodeChangeset.fieldChanges === undefined) {
+				nodeChangeset.fieldChanges = new Map();
+			}
+
+			nodeChangeset.fieldChanges.set(fieldId.field, composedField);
 		}
 
-		nodeChangeset.fieldChanges.set(fieldId.field, composedField);
+		affectedFields.clear();
 	}
 
 	private composeFieldMaps(
@@ -554,29 +507,17 @@ export class ModularChangeFamily
 		for (const [field, fieldChange1] of change1) {
 			const fieldId: FieldId = { nodeId: parentId, field };
 			const fieldChange2 = change2.get(field);
-
-			const cachedComposedFieldChange =
-				crossFieldTable.fieldToContext.get(fieldChange1)?.composedChange;
-
-			if (fieldChange2 === undefined && cachedComposedFieldChange !== undefined) {
-				// This can happen if the field was previous processed in `composeFieldWithNoNewChange`.
-				// If `change2` does not have a change for this field, then without this check we would
-				// lose the composed field change and instead simply have `change1`'s change.
-				composedFields.set(field, cachedComposedFieldChange);
-				continue;
-			}
-
 			const composedField =
-				fieldChange2 !== undefined
-					? this.composeFieldChanges(
+				fieldChange2 === undefined
+					? fieldChange1
+					: this.composeFieldChanges(
 							fieldId,
 							fieldChange1,
 							fieldChange2,
 							genId,
 							crossFieldTable,
 							revisionMetadata,
-						)
-					: fieldChange1;
+						);
 
 			composedFields.set(field, composedField);
 		}
@@ -597,7 +538,7 @@ export class ModularChangeFamily
 	 * will be added to `crossFieldTable.pendingCompositions.nodeIdsToCompose`.
 	 *
 	 * Any fields which had cross-field information sent to them as part of this field composition
-	 * will be added to `affectedBaseFields` in `crossFieldTable.pendingCompositions`.
+	 * will be added to either `affectedBaseFields` or `affectedNewFields` in `crossFieldTable.pendingCompositions`.
 	 *
 	 * Any composed `FieldChange` which is invalidated by new cross-field information will be added to `crossFieldTable.invalidatedFields`.
 	 */
@@ -616,14 +557,15 @@ export class ModularChangeFamily
 			change2: change2Normalized,
 		} = this.normalizeFieldChanges(change1, change2);
 
-		const manager = new ComposeNodeManagerI(crossFieldTable, fieldId);
+		const manager = new ComposeManager(crossFieldTable, change1, fieldId);
 
 		const composedChange = changeHandler.rebaser.compose(
 			change1Normalized,
 			change2Normalized,
 			(child1, child2) => {
 				if (child1 !== undefined && child2 !== undefined) {
-					addNodesToCompose(crossFieldTable, child1, child2);
+					setInChangeAtomIdMap(crossFieldTable.newToBaseNodeId, child2, child1);
+					crossFieldTable.pendingCompositions.nodeIdsToCompose.push([child1, child2]);
 				}
 				return child1 ?? child2 ?? fail(0xb23 /* Should not compose two undefined nodes */);
 			},
@@ -649,19 +591,19 @@ export class ModularChangeFamily
 	}
 
 	private composeNodesById(
-		change1: ModularChangeset,
-		change2: ModularChangeset,
+		nodeChanges1: ChangeAtomIdBTree<NodeChangeset>,
+		nodeChanges2: ChangeAtomIdBTree<NodeChangeset>,
 		composedNodes: ChangeAtomIdBTree<NodeChangeset>,
-		composedNodeToParent: ChangeAtomIdBTree<NodeLocation>,
-		composedAliases: ChangeAtomIdBTree<NodeId>,
+		composedNodeToParent: ChangeAtomIdBTree<FieldId>,
+		nodeAliases: ChangeAtomIdBTree<NodeId>,
 		id1: NodeId,
 		id2: NodeId,
 		idAllocator: IdAllocator,
 		crossFieldTable: ComposeTable,
 		revisionMetadata: RevisionMetadataSource,
 	): void {
-		const nodeChangeset1 = nodeChangeFromId(change1.nodeChanges, change1.nodeAliases, id1);
-		const nodeChangeset2 = nodeChangeFromId(change2.nodeChanges, change2.nodeAliases, id2);
+		const nodeChangeset1 = nodeChangeFromId(nodeChanges1, id1);
+		const nodeChangeset2 = nodeChangeFromId(nodeChanges2, id2);
 		const composedNodeChangeset = this.composeNodeChanges(
 			id1,
 			nodeChangeset1,
@@ -676,11 +618,13 @@ export class ModularChangeFamily
 		if (!areEqualChangeAtomIds(id1, id2)) {
 			composedNodes.delete([id2.revision, id2.localId]);
 			composedNodeToParent.delete([id2.revision, id2.localId]);
-			setInChangeAtomIdMap(composedAliases, id2, id1);
+			setInChangeAtomIdMap(nodeAliases, id2, id1);
 
 			// We need to delete id1 to avoid forming a cycle in case id1 already had an alias.
-			composedAliases.delete([id1.revision, id1.localId]);
+			nodeAliases.delete([id1.revision, id1.localId]);
 		}
+
+		crossFieldTable.composedNodes.add(composedNodeChangeset);
 	}
 
 	private composeNodeChanges(
@@ -715,7 +659,7 @@ export class ModularChangeFamily
 			revisionMetadata,
 		);
 
-		const composedNodeChange: Mutable<NodeChangeset> = {};
+		const composedNodeChange: NodeChangeset = {};
 
 		if (composedFieldChanges.size > 0) {
 			composedNodeChange.fieldChanges = composedFieldChanges;
@@ -735,8 +679,8 @@ export class ModularChangeFamily
 	/**
 	 * @param change - The change to invert.
 	 * @param isRollback - Whether the inverted change is meant to rollback a change on a branch as is the case when
-	 * @param revisionForInvert - The revision for the invert changeset.
 	 * performing a sandwich rebase.
+	 * @param revisionForInvert - The revision for the invert changeset.
 	 */
 	public invert(
 		change: TaggedChange<ModularChangeset>,
@@ -756,6 +700,9 @@ export class ModularChangeFamily
 			? [{ revision: revisionForInvert, rollbackOf: change.revision }]
 			: [{ revision: revisionForInvert }];
 
+		const noChangeConstraint = change.change.noChangeConstraintOnRevert;
+		const noChangeConstraintOnRevert = change.change.noChangeConstraint;
+
 		if (hasConflicts(change.change)) {
 			return makeModularChangeset({
 				maxId: change.change.maxId as number,
@@ -767,14 +714,9 @@ export class ModularChangeFamily
 		const genId: IdAllocator = idAllocatorFromMaxId(change.change.maxId ?? -1);
 
 		const crossFieldTable: InvertTable = {
-			change: change.change,
-			entries: newChangeAtomIdRangeMap(),
+			...newCrossFieldTable<FieldChange>(),
 			originalFieldToContext: new Map(),
-			invertRevision: revisionForInvert,
 			invertedNodeToParent: brand(change.change.nodeToParent.clone()),
-			invalidatedFields: new Set(),
-			invertedRoots: invertRootTable(change.change, isRollback),
-			attachToDetachId: newChangeAtomIdTransform(),
 		};
 		const { revInfos: oldRevInfos } = getRevInfoFromTaggedChanges([change]);
 		const revisionMetadata = revisionMetadataSourceFromInfo(oldRevInfos);
@@ -815,7 +757,7 @@ export class ModularChangeFamily
 					context !== undefined,
 					0x851 /* Should have context for every invalidated field */,
 				);
-				const { invertedField } = context;
+				const { invertedField, fieldId } = context;
 
 				const amendedChange = getChangeHandler(
 					this.fieldKinds,
@@ -825,7 +767,7 @@ export class ModularChangeFamily
 					isRollback,
 					genId,
 					revisionForInvert,
-					new InvertNodeManagerI(crossFieldTable, context.fieldId),
+					new InvertManager(crossFieldTable, fieldChange, fieldId),
 					revisionMetadata,
 				);
 				invertedField.change = brand(amendedChange);
@@ -834,19 +776,18 @@ export class ModularChangeFamily
 
 		const crossFieldKeys = this.makeCrossFieldKeyTable(invertedFields, invertedNodes);
 
-		this.processInvertRenames(crossFieldTable);
-
 		return makeModularChangeset({
 			fieldChanges: invertedFields,
 			nodeChanges: invertedNodes,
 			nodeToParent: crossFieldTable.invertedNodeToParent,
-			rootNodes: crossFieldTable.invertedRoots,
 			nodeAliases: change.change.nodeAliases,
 			crossFieldKeys,
 			maxId: genId.getMaxId(),
 			revisions: revInfos,
 			constraintViolationCount: change.change.constraintViolationCountOnRevert,
 			constraintViolationCountOnRevert: change.change.constraintViolationCount,
+			noChangeConstraint,
+			noChangeConstraintOnRevert,
 			destroys,
 		});
 	}
@@ -864,7 +805,7 @@ export class ModularChangeFamily
 
 		for (const [field, fieldChange] of changes) {
 			const fieldId = { nodeId: parentId, field };
-			const manager = new InvertNodeManagerI(crossFieldTable, fieldId);
+			const manager = new InvertManager(crossFieldTable, fieldChange, fieldId);
 			const invertedChange = getChangeHandler(
 				this.fieldKinds,
 				fieldChange.fieldKind,
@@ -901,7 +842,7 @@ export class ModularChangeFamily
 		revisionMetadata: RevisionMetadataSource,
 		revisionForInvert: RevisionTag,
 	): NodeChangeset {
-		const inverse: Mutable<NodeChangeset> = {};
+		const inverse: NodeChangeset = {};
 
 		// If the node has a constraint, it should be inverted to a node-exist-on-revert constraint. This ensure that if
 		// the inverse is inverted again, the original input constraint will be restored.
@@ -931,17 +872,6 @@ export class ModularChangeFamily
 		return inverse;
 	}
 
-	private processInvertRenames(table: InvertTable): void {
-		for (const {
-			start: newAttachId,
-			value: originalDetachId,
-			length,
-		} of table.attachToDetachId.entries()) {
-			// Note that the detach location is already set in `invertDetach`.
-			addNodeRename(table.invertedRoots, originalDetachId, newAttachId, length, undefined);
-		}
-	}
-
 	public rebase(
 		taggedChange: TaggedChange<ModularChangeset>,
 		potentiallyConflictedOver: TaggedChange<ModularChangeset>,
@@ -961,41 +891,17 @@ export class ModularChangeFamily
 		const idState: IdAllocationState = { maxId };
 		const genId: IdAllocator = idAllocatorFromState(idState);
 
-		const affectedBaseFields: TupleBTree<FieldIdKey, boolean> = newTupleBTree();
-		const nodesToRebase: [newChangeset: NodeId, baseChangeset: NodeId][] = [];
-
-		const rebasedNodeToParent: ChangeAtomIdBTree<NodeLocation> = brand(
-			change.nodeToParent.clone(),
-		);
-
-		const rebaseVersion = Math.max(
-			change.rebaseVersion,
-			over.change.rebaseVersion,
-		) as RebaseVersion;
-
-		const rebasedRootNodes = rebaseRoots(
-			change,
-			over.change,
-			affectedBaseFields,
-			nodesToRebase,
-			rebasedNodeToParent,
-			rebaseVersion,
-		);
 		const crossFieldTable: RebaseTable = {
-			rebaseVersion,
-			entries: newDetachedEntryMap(),
+			...newCrossFieldTable<FieldChange>(),
 			newChange: change,
 			baseChange: over.change,
 			baseFieldToContext: new Map(),
-			baseRoots: over.change.rootNodes,
-			rebasedRootNodes,
 			baseToRebasedNodeId: newTupleBTree(),
 			rebasedFields: new Set(),
-			rebasedNodeToParent,
-			rebasedDetachLocations: newChangeAtomIdRangeMap(),
-			movedDetaches: newChangeAtomIdRangeMap(),
+			rebasedNodeToParent: brand(change.nodeToParent.clone()),
+			rebasedCrossFieldKeys: change.crossFieldKeys.clone(),
 			nodeIdPairs: [],
-			affectedBaseFields,
+			affectedBaseFields: newTupleBTree(),
 			fieldsWithUnattachedChild: new Set(),
 		};
 
@@ -1011,14 +917,13 @@ export class ModularChangeFamily
 		const rebasedNodes: ChangeAtomIdBTree<NodeChangeset> = brand(change.nodeChanges.clone());
 
 		const rebasedFields = this.rebaseIntersectingFields(
-			nodesToRebase,
 			crossFieldTable,
 			rebasedNodes,
 			genId,
 			rebaseMetadata,
 		);
 
-		this.rebaseInvalidatedFields(
+		this.rebaseInvalidatedElements(
 			rebasedFields,
 			rebasedNodes,
 			crossFieldTable,
@@ -1026,78 +931,49 @@ export class ModularChangeFamily
 			genId,
 		);
 
-		fixupRebasedDetachLocations(crossFieldTable);
-
 		const constraintState = newConstraintState(change.constraintViolationCount ?? 0);
 		const revertConstraintState = newConstraintState(
 			change.constraintViolationCountOnRevert ?? 0,
 		);
 
-		this.updateConstraints(
+		let noChangeConstraint = change.noChangeConstraint;
+		if (noChangeConstraint !== undefined && !noChangeConstraint.violated) {
+			noChangeConstraint = { violated: true };
+			constraintState.violationCount += 1;
+		}
+
+		this.updateConstraintsForFields(
 			rebasedFields,
-			rebasedNodes,
-			rebasedRootNodes,
+			NodeAttachState.Attached,
+			NodeAttachState.Attached,
 			constraintState,
 			revertConstraintState,
-		);
-
-		const fieldsWithRootMoves = getFieldsWithRootMoves(
-			crossFieldTable.rebasedRootNodes,
-			change.nodeAliases,
-		);
-
-		const fieldToRootChanges = getFieldToRootChanges(
-			crossFieldTable.rebasedRootNodes,
-			change.nodeAliases,
+			rebasedNodes,
 		);
 
 		const rebased = makeModularChangeset({
-			fieldChanges: this.pruneFieldMap(
-				rebasedFields,
-				undefined,
-				rebasedNodes,
-				crossFieldTable.rebasedNodeToParent,
-				change.nodeAliases,
-				crossFieldTable.rebasedRootNodes,
-				fieldsWithRootMoves,
-				fieldToRootChanges,
-			),
+			fieldChanges: this.pruneFieldMap(rebasedFields, rebasedNodes),
 			nodeChanges: rebasedNodes,
 			nodeToParent: crossFieldTable.rebasedNodeToParent,
-			rootNodes: this.pruneRoots(
-				crossFieldTable.rebasedRootNodes,
-				rebasedNodes,
-				crossFieldTable.rebasedNodeToParent,
-				change.nodeAliases,
-				fieldsWithRootMoves,
-				fieldToRootChanges,
-			),
-			// TODO: Do we need to include aliases for node changesets added during rebasing?
 			nodeAliases: change.nodeAliases,
-			crossFieldKeys: rebaseCrossFieldKeys(
-				change.crossFieldKeys,
-				crossFieldTable.movedDetaches,
-				crossFieldTable.rebasedDetachLocations,
-			),
+			crossFieldKeys: crossFieldTable.rebasedCrossFieldKeys,
 			maxId: idState.maxId,
 			revisions: change.revisions,
 			constraintViolationCount: constraintState.violationCount,
 			constraintViolationCountOnRevert: revertConstraintState.violationCount,
+			noChangeConstraint,
+			noChangeConstraintOnRevert: change.noChangeConstraintOnRevert,
 			builds: change.builds,
 			destroys: change.destroys,
 			refreshers: change.refreshers,
-			rebaseVersion,
 		});
 
-		// XXX: This is an expensive assert which should be disabled before merging.
-		this.validateChangeset(rebased);
 		return rebased;
 	}
 
 	// This performs a first pass on all fields which have both new and base changes.
 	// TODO: Can we also handle additional passes in this method?
 	private rebaseIntersectingFields(
-		rootChanges: [newChangeset: NodeId, baseChangeset: NodeId][],
 		crossFieldTable: RebaseTable,
 		rebasedNodes: ChangeAtomIdBTree<NodeChangeset>,
 		genId: IdAllocator,
@@ -1114,18 +990,6 @@ export class ModularChangeFamily
 			metadata,
 		);
 
-		for (const [newChildChange, baseChildChange] of rootChanges) {
-			const rebasedNode = this.rebaseNodeChange(
-				newChildChange,
-				baseChildChange,
-				genId,
-				crossFieldTable,
-				metadata,
-			);
-
-			setInChangeAtomIdMap(rebasedNodes, newChildChange, rebasedNode);
-		}
-
 		// This loop processes all fields which have both base and new changes.
 		// Note that the call to `rebaseNodeChange` can add entries to `crossFieldTable.nodeIdPairs`.
 		for (const [newId, baseId, _attachState] of crossFieldTable.nodeIdPairs) {
@@ -1143,150 +1007,146 @@ export class ModularChangeFamily
 		return rebasedFields;
 	}
 
-	private rebaseFieldWithoutNewChanges(
-		baseFieldChange: FieldChange,
-		baseFieldId: FieldId,
-		crossFieldTable: RebaseTable,
+	// This processes fields which have no new changes but have been invalidated by another field.
+	private rebaseFieldsWithoutNewChanges(
 		rebasedFields: FieldChangeMap,
 		rebasedNodes: ChangeAtomIdBTree<NodeChangeset>,
+		crossFieldTable: RebaseTable,
 		genId: IdAllocator,
 		metadata: RebaseRevisionMetadata,
-
-		/**
-		 * The ID of a node in `baseFieldChange` which should be included in the rebased field change.
-		 */
-		baseNodeId?: NodeId,
 	): void {
-		// This field has no changes in the new changeset, otherwise it would have been added to
-		// `crossFieldTable.baseFieldToContext` when processing fields with both base and new changes.
-		const rebaseChild = (
-			child: NodeId | undefined,
-			baseChild: NodeId | undefined,
-			stateChange: NodeAttachState | undefined,
-		): NodeId | undefined => {
-			assert(child === undefined, 0x9c3 /* There should be no new changes in this field */);
-			if (baseChild === undefined || baseNodeId === undefined) {
-				return undefined;
-			}
-
-			return areEqualChangeAtomIds(
-				normalizeNodeId(baseChild, crossFieldTable.baseChange.nodeAliases),
+		const baseChange = crossFieldTable.baseChange;
+		for (const [revision, localId, fieldKey] of crossFieldTable.affectedBaseFields.keys()) {
+			const baseNodeId =
+				localId === undefined
+					? undefined
+					: normalizeNodeId({ revision, localId }, baseChange.nodeAliases);
+
+			const baseFieldChange = fieldMapFromNodeId(
+				baseChange.fieldChanges,
+				baseChange.nodeChanges,
 				baseNodeId,
-			)
-				? baseNodeId
-				: undefined;
-		};
-
-		const handler = getChangeHandler(this.fieldKinds, baseFieldChange.fieldKind);
-		const fieldChange: FieldChange = {
-			...baseFieldChange,
-			change: brand(handler.createEmpty()),
-		};
+			).get(fieldKey);
 
-		const rebasedNodeId =
-			baseFieldId.nodeId !== undefined
-				? rebasedNodeIdFromBaseNodeId(crossFieldTable, baseFieldId.nodeId)
-				: undefined;
+			assert(
+				baseFieldChange !== undefined,
+				0x9c2 /* Cross field key registered for empty field */,
+			);
+			if (crossFieldTable.baseFieldToContext.has(baseFieldChange)) {
+				// This field has already been processed because there were changes to rebase.
+				continue;
+			}
 
-		const fieldId: FieldId = { nodeId: rebasedNodeId, field: baseFieldId.field };
+			// This field has no changes in the new changeset, otherwise it would have been added to
+			// `crossFieldTable.baseFieldToContext` when processing fields with both base and new changes.
+			const rebaseChild = (
+				child: NodeId | undefined,
+				baseChild: NodeId | undefined,
+				stateChange: NodeAttachState | undefined,
+			): NodeId | undefined => {
+				assert(child === undefined, 0x9c3 /* There should be no new changes in this field */);
+				return undefined;
+			};
 
-		const rebasedField: unknown = handler.rebaser.rebase(
-			fieldChange.change,
-			baseFieldChange.change,
-			rebaseChild,
-			genId,
-			new RebaseNodeManagerI(crossFieldTable, fieldId),
-			metadata,
-			crossFieldTable.rebaseVersion,
-		);
+			const handler = getChangeHandler(this.fieldKinds, baseFieldChange.fieldKind);
+			const fieldChange: FieldChange = {
+				...baseFieldChange,
+				change: brand(handler.createEmpty()),
+			};
 
-		const rebasedFieldChange: FieldChange = {
-			...baseFieldChange,
-			change: brand(rebasedField),
-		};
+			const rebasedNodeId =
+				baseNodeId === undefined
+					? undefined
+					: rebasedNodeIdFromBaseNodeId(crossFieldTable, baseNodeId);
 
-		const context: RebaseFieldContext = {
-			newChange: fieldChange,
-			baseChange: baseFieldChange,
-			rebasedChange: rebasedFieldChange,
-			fieldId,
-			baseNodeIds: newTupleBTree(),
-		};
+			const fieldId: FieldId = { nodeId: rebasedNodeId, field: fieldKey };
+			const rebasedField: unknown = handler.rebaser.rebase(
+				fieldChange.change,
+				baseFieldChange.change,
+				rebaseChild,
+				genId,
+				new RebaseManager(crossFieldTable, baseFieldChange, fieldId),
+				metadata,
+			);
 
-		if (baseNodeId !== undefined) {
-			setInChangeAtomIdMap(context.baseNodeIds, baseNodeId, true);
-		}
+			const rebasedFieldChange: FieldChange = {
+				...baseFieldChange,
+				change: brand(rebasedField),
+			};
 
-		crossFieldTable.baseFieldToContext.set(baseFieldChange, context);
+			// TODO: Deduplicate
+			crossFieldTable.baseFieldToContext.set(baseFieldChange, {
+				newChange: fieldChange,
+				baseChange: baseFieldChange,
+				rebasedChange: rebasedFieldChange,
+				fieldId,
+				baseNodeIds: [],
+			});
+			crossFieldTable.rebasedFields.add(rebasedFieldChange);
 
-		crossFieldTable.rebasedFields.add(rebasedFieldChange);
+			this.attachRebasedField(
+				rebasedFields,
+				rebasedNodes,
+				crossFieldTable,
+				rebasedFieldChange,
+				fieldId,
+				genId,
+				metadata,
+			);
+		}
+	}
 
-		this.attachRebasedField(
+	private rebaseInvalidatedElements(
+		rebasedFields: FieldChangeMap,
+		rebasedNodes: ChangeAtomIdBTree<NodeChangeset>,
+		table: RebaseTable,
+		metadata: RebaseRevisionMetadata,
+		idAllocator: IdAllocator,
+	): void {
+		this.rebaseFieldsWithoutNewChanges(
 			rebasedFields,
 			rebasedNodes,
-			crossFieldTable,
-			rebasedFieldChange,
-			fieldId,
-			genId,
+			table,
+			idAllocator,
 			metadata,
 		);
+
+		this.rebaseFieldsWithUnattachedChild(table, metadata, idAllocator);
+		this.rebaseInvalidatedFields(table, metadata, idAllocator);
 	}
 
 	private rebaseInvalidatedFields(
-		rebasedFields: FieldChangeMap,
-		rebasedNodes: ChangeAtomIdBTree<NodeChangeset>,
 		crossFieldTable: RebaseTable,
 		rebaseMetadata: RebaseRevisionMetadata,
 		genId: IdAllocator,
 	): void {
-		while (crossFieldTable.affectedBaseFields.size > 0) {
-			const baseFields = crossFieldTable.affectedBaseFields.clone();
-			crossFieldTable.affectedBaseFields.clear();
-
-			for (const baseFieldIdKey of baseFields.keys()) {
-				const baseFieldId = normalizeFieldId(
-					fieldIdFromFieldIdKey(baseFieldIdKey),
-					crossFieldTable.baseChange.nodeAliases,
-				);
-
-				const baseField = fieldChangeFromId(crossFieldTable.baseChange, baseFieldId);
-
-				assert(
-					baseField !== undefined,
-					0x9c2 /* Cross field key registered for empty field */,
-				);
+		const fieldsToUpdate = crossFieldTable.invalidatedFields;
+		crossFieldTable.invalidatedFields = new Set();
+		for (const field of fieldsToUpdate) {
+			this.rebaseInvalidatedField(field, crossFieldTable, rebaseMetadata, genId);
+		}
+	}
 
-				const context = crossFieldTable.baseFieldToContext.get(baseField);
-				if (context === undefined) {
-					this.rebaseFieldWithoutNewChanges(
-						baseField,
-						baseFieldId,
-						crossFieldTable,
-						rebasedFields,
-						rebasedNodes,
-						genId,
-						rebaseMetadata,
-					);
-				} else {
-					this.rebaseInvalidatedField(
-						baseField,
-						crossFieldTable,
-						context,
-						rebaseMetadata,
-						genId,
-					);
-				}
-			}
+	private rebaseFieldsWithUnattachedChild(
+		table: RebaseTable,
+		metadata: RebaseRevisionMetadata,
+		idAllocator: IdAllocator,
+	): void {
+		for (const field of table.fieldsWithUnattachedChild) {
+			table.invalidatedFields.delete(field);
+			this.rebaseInvalidatedField(field, table, metadata, idAllocator, true);
 		}
 	}
 
 	private rebaseInvalidatedField(
 		baseField: FieldChange,
 		crossFieldTable: RebaseTable,
-		context: RebaseFieldContext,
 		rebaseMetadata: RebaseRevisionMetadata,
 		genId: IdAllocator,
+		allowInval = false,
 	): void {
+		const context = crossFieldTable.baseFieldToContext.get(baseField);
+		assert(context !== undefined, 0x852 /* Every field should have a context */);
 		const {
 			changeHandler,
 			change1: fieldChangeset,
@@ -1301,28 +1161,25 @@ export class ModularChangeFamily
 				return curr;
 			}
 
-			if (base !== undefined && getFromChangeAtomIdMap(context.baseNodeIds, base) === true) {
-				return base;
+			if (base !== undefined) {
+				for (const id of context.baseNodeIds) {
+					if (areEqualChangeAtomIds(base, id)) {
+						return base;
+					}
+				}
 			}
 
 			return undefined;
 		};
 
-		let allowInval = false;
-		if (crossFieldTable.fieldsWithUnattachedChild.has(baseField)) {
-			crossFieldTable.fieldsWithUnattachedChild.delete(baseField);
-			allowInval = true;
-		}
-
 		context.rebasedChange.change = brand(
 			changeHandler.rebaser.rebase(
 				fieldChangeset,
 				baseChangeset,
 				rebaseChild,
 				genId,
-				new RebaseNodeManagerI(crossFieldTable, context.fieldId, allowInval),
+				new RebaseManager(crossFieldTable, baseField, context.fieldId, allowInval),
 				rebaseMetadata,
-				crossFieldTable.rebaseVersion,
 			),
 		);
 	}
@@ -1342,19 +1199,13 @@ export class ModularChangeFamily
 		}
 		const rebasedNode = getFromChangeAtomIdMap(rebasedNodes, nodeId);
 		if (rebasedNode !== undefined) {
-			const updatedRebasedNode: Mutable<NodeChangeset> = cloneNodeChangeset(rebasedNode);
-			setInChangeAtomIdMap(rebasedNodes, nodeId, updatedRebasedNode);
-
-			if (updatedRebasedNode.fieldChanges === undefined) {
-				updatedRebasedNode.fieldChanges = new Map([[fieldKey, rebasedField]]);
+			if (rebasedNode.fieldChanges === undefined) {
+				rebasedNode.fieldChanges = new Map([[fieldKey, rebasedField]]);
 				return;
 			}
 
-			assert(
-				!updatedRebasedNode.fieldChanges.has(fieldKey),
-				0x9c4 /* Expected an empty field */,
-			);
-			updatedRebasedNode.fieldChanges.set(fieldKey, rebasedField);
+			assert(!rebasedNode.fieldChanges.has(fieldKey), 0x9c4 /* Expected an empty field */);
+			rebasedNode.fieldChanges.set(fieldKey, rebasedField);
 			return;
 		}
 
@@ -1365,14 +1216,14 @@ export class ModularChangeFamily
 		setInChangeAtomIdMap(rebasedNodes, nodeId, newNode);
 		setInChangeAtomIdMap(table.baseToRebasedNodeId, nodeId, nodeId);
 
-		const parentBase = getNodeParent(table.baseChange, nodeId);
+		const parentFieldId = getParentFieldId(table.baseChange, nodeId);
 
 		this.attachRebasedNode(
 			rebasedFields,
 			rebasedNodes,
 			table,
 			nodeId,
-			parentBase,
+			parentFieldId,
 			idAllocator,
 			metadata,
 		);
@@ -1383,100 +1234,65 @@ export class ModularChangeFamily
 		rebasedNodes: ChangeAtomIdBTree<NodeChangeset>,
 		table: RebaseTable,
 		baseNodeId: NodeId,
-		parentBase: NodeLocation,
+		parentFieldIdBase: FieldId,
 		idAllocator: IdAllocator,
 		metadata: RebaseRevisionMetadata,
 	): void {
-		if (parentBase.root !== undefined) {
-			const renamedRoot = firstAttachIdFromDetachId(
-				table.baseChange.rootNodes,
-				parentBase.root,
-				1,
-			).value;
-
-			const attachField = table.baseChange.crossFieldKeys.getFirst(
-				{ ...renamedRoot, target: CrossFieldTarget.Destination },
-				1,
-			).value;
-
-			if (attachField !== undefined) {
-				// The base change inserts this node into `attachField`, so the rebased change should represent this node there.
-				const normalizedAttachField = normalizeFieldId(
-					attachField,
-					table.baseChange.nodeAliases,
-				);
-
-				const entry: DetachedNodeEntry = table.entries.getFirst(renamedRoot, 1).value ?? {};
-				table.entries.set(renamedRoot, 1, { ...entry, nodeChange: baseNodeId });
-				table.affectedBaseFields.set(fieldIdKeyFromFieldId(normalizedAttachField), true);
-				this.attachRebasedNode(
-					rebasedFields,
-					rebasedNodes,
-					table,
-					baseNodeId,
-					{ field: normalizedAttachField },
-					idAllocator,
-					metadata,
-				);
-			} else {
-				const baseDetachLocation = table.baseChange.rootNodes.detachLocations.getFirst(
-					parentBase.root,
-					1,
-				).value;
-
-				assignRootChange(
-					table.rebasedRootNodes,
-					table.rebasedNodeToParent,
-					renamedRoot,
-					baseNodeId,
-					baseDetachLocation,
-					table.rebaseVersion,
-				);
-
-				// We need to make sure the rebased changeset includes the detach location,
-				// so we add that field to `affectedBaseFields` unless it's already been processed.
-				if (
-					baseDetachLocation !== undefined &&
-					!table.baseFieldToContext.has(
-						fieldChangeFromId(table.baseChange, baseDetachLocation),
-					)
-				) {
-					table.affectedBaseFields.set(fieldIdKeyFromFieldId(baseDetachLocation), true);
-				}
-			}
-
-			return;
-		}
-
-		const parentFieldIdBase = parentBase.field;
-		const baseFieldChange = fieldChangeFromId(table.baseChange, parentFieldIdBase);
+		const baseFieldChange = fieldChangeFromId(
+			table.baseChange.fieldChanges,
+			table.baseChange.nodeChanges,
+			parentFieldIdBase,
+		);
 
 		const rebasedFieldId = rebasedFieldIdFromBaseId(table, parentFieldIdBase);
-		setInChangeAtomIdMap(table.rebasedNodeToParent, baseNodeId, { field: rebasedFieldId });
+		setInChangeAtomIdMap(table.rebasedNodeToParent, baseNodeId, rebasedFieldId);
 
 		const context = table.baseFieldToContext.get(baseFieldChange);
 		if (context !== undefined) {
 			// We've already processed this field.
-			// The new child node will be attached in the next pass.
-			// Note that adding to `fieldsWithUnattachedChild` allows that field to generate new invalidations,
-			// so to avoid invalidation cycles we make sure we only add to it once per new unattached child.
-			// This is done by checking whether `context.baseNodeIds` already contained `baseNodeId`.
-			if (setInChangeAtomIdMap(context.baseNodeIds, baseNodeId, true)) {
-				table.fieldsWithUnattachedChild.add(baseFieldChange);
-				table.affectedBaseFields.set(fieldIdKeyFromFieldId(parentFieldIdBase), true);
-			}
+			// The new child node will be attached in rebaseFieldsWithUnattachedChild.
+			context.baseNodeIds.push(baseNodeId);
+			table.fieldsWithUnattachedChild.add(baseFieldChange);
 			return;
 		}
 
-		this.rebaseFieldWithoutNewChanges(
-			baseFieldChange,
-			parentFieldIdBase,
-			table,
+		const handler = getChangeHandler(this.fieldKinds, baseFieldChange.fieldKind);
+
+		const fieldChange: FieldChange = {
+			...baseFieldChange,
+			change: brand(handler.createEmpty()),
+		};
+
+		const rebasedChangeset = handler.rebaser.rebase(
+			handler.createEmpty(),
+			baseFieldChange.change,
+			(_idNew, idBase) =>
+				idBase !== undefined && areEqualChangeAtomIds(idBase, baseNodeId)
+					? baseNodeId
+					: undefined,
+			idAllocator,
+			new RebaseManager(table, baseFieldChange, rebasedFieldId),
+			metadata,
+		);
+
+		const rebasedField: FieldChange = { ...baseFieldChange, change: brand(rebasedChangeset) };
+		table.rebasedFields.add(rebasedField);
+		table.baseFieldToContext.set(baseFieldChange, {
+			newChange: fieldChange,
+			baseChange: baseFieldChange,
+			rebasedChange: rebasedField,
+			fieldId: rebasedFieldId,
+			baseNodeIds: [],
+		});
+
+		this.attachRebasedField(
 			rebasedFields,
 			rebasedNodes,
+			table,
+			rebasedField,
+			rebasedFieldId,
 			idAllocator,
 			metadata,
-			baseNodeId,
 		);
 	}
 
@@ -1515,7 +1331,7 @@ export class ModularChangeFamily
 				change2: baseChangeset,
 			} = this.normalizeFieldChanges(fieldChange, baseChange);
 
-			const manager = new RebaseNodeManagerI(crossFieldTable, fieldId);
+			const manager = new RebaseManager(crossFieldTable, baseChange, fieldId);
 
 			const rebasedField = changeHandler.rebaser.rebase(
 				fieldChangeset,
@@ -1524,7 +1340,6 @@ export class ModularChangeFamily
 				genId,
 				manager,
 				revisionMetadata,
-				crossFieldTable.rebaseVersion,
 			);
 
 			const rebasedFieldChange: FieldChange = {
@@ -1539,7 +1354,7 @@ export class ModularChangeFamily
 				newChange: fieldChange,
 				rebasedChange: rebasedFieldChange,
 				fieldId,
-				baseNodeIds: newTupleBTree(),
+				baseNodeIds: [],
 			});
 
 			crossFieldTable.rebasedFields.add(rebasedFieldChange);
@@ -1555,16 +1370,8 @@ export class ModularChangeFamily
 		crossFieldTable: RebaseTable,
 		revisionMetadata: RebaseRevisionMetadata,
 	): NodeChangeset {
-		const change = nodeChangeFromId(
-			crossFieldTable.newChange.nodeChanges,
-			crossFieldTable.newChange.nodeAliases,
-			newId,
-		);
-		const over = nodeChangeFromId(
-			crossFieldTable.baseChange.nodeChanges,
-			crossFieldTable.baseChange.nodeAliases,
-			baseId,
-		);
+		const change = nodeChangeFromId(crossFieldTable.newChange.nodeChanges, newId);
+		const over = nodeChangeFromId(crossFieldTable.baseChange.nodeChanges, baseId);
 
 		const baseMap: FieldChangeMap = over?.fieldChanges ?? new Map();
 
@@ -1580,7 +1387,7 @@ export class ModularChangeFamily
 					)
 				: change.fieldChanges;
 
-		const rebasedChange: Mutable<NodeChangeset> = {};
+		const rebasedChange: NodeChangeset = {};
 
 		if (fieldChanges !== undefined && fieldChanges.size > 0) {
 			rebasedChange.fieldChanges = fieldChanges;
@@ -1598,37 +1405,6 @@ export class ModularChangeFamily
 		return rebasedChange;
 	}
 
-	private updateConstraints(
-		rebasedFields: FieldChangeMap,
-		rebasedNodes: ChangeAtomIdBTree<NodeChangeset>,
-		rebasedRoots: RootNodeTable,
-		constraintState: ConstraintState,
-		revertConstraintState: ConstraintState,
-	): void {
-		this.updateConstraintsForFields(
-			rebasedFields,
-			NodeAttachState.Attached,
-			NodeAttachState.Attached,
-			constraintState,
-			revertConstraintState,
-			rebasedNodes,
-		);
-
-		for (const [_detachId, nodeId] of rebasedRoots.nodeChanges.entries()) {
-			// XXX: This is incorrect if the rebased changeset attaches the node.
-			// Efficiently computing whether the changeset attaches the node would require maintaining a mapping from node ID to attach ID.
-			const detachedInOutput = true;
-			this.updateConstraintsForNode(
-				nodeId,
-				NodeAttachState.Detached,
-				detachedInOutput ? NodeAttachState.Detached : NodeAttachState.Attached,
-				rebasedNodes,
-				constraintState,
-				revertConstraintState,
-			);
-		}
-	}
-
 	private updateConstraintsForFields(
 		fields: FieldChangeMap,
 		parentInputAttachState: NodeAttachState,
@@ -1639,18 +1415,20 @@ export class ModularChangeFamily
 	): void {
 		for (const field of fields.values()) {
 			const handler = getChangeHandler(this.fieldKinds, field.fieldKind);
-			for (const [nodeId] of handler.getNestedChanges(field.change)) {
-				// XXX: This is incorrect if the rebased changeset detaches this node.
-				// Efficiently computing whether the changeset detaches the node would require maintaining a mapping from node ID to detach ID.
-				const isOutputDetached = false;
+			for (const [nodeId, inputIndex, outputIndex] of handler.getNestedChanges(field.change)) {
+				const isInputDetached = inputIndex === undefined;
+				const inputAttachState =
+					parentInputAttachState === NodeAttachState.Detached || isInputDetached
+						? NodeAttachState.Detached
+						: NodeAttachState.Attached;
+				const isOutputDetached = outputIndex === undefined;
 				const outputAttachState =
 					parentOutputAttachState === NodeAttachState.Detached || isOutputDetached
 						? NodeAttachState.Detached
 						: NodeAttachState.Attached;
-
 				this.updateConstraintsForNode(
 					nodeId,
-					parentInputAttachState,
+					inputAttachState,
 					outputAttachState,
 					nodes,
 					constraintState,
@@ -1668,15 +1446,12 @@ export class ModularChangeFamily
 		constraintState: ConstraintState,
 		revertConstraintState: ConstraintState,
 	): void {
-		const node = getFromChangeAtomIdMap(nodes, nodeId) ?? fail(0xb24 /* Unknown node ID */);
-
-		const updatedNode: Mutable<NodeChangeset> = { ...node };
-		setInChangeAtomIdMap(nodes, nodeId, updatedNode);
-
+		const node =
+			nodes.get([nodeId.revision, nodeId.localId]) ?? fail(0xb24 /* Unknown node ID */);
 		if (node.nodeExistsConstraint !== undefined) {
 			const isNowViolated = inputAttachState === NodeAttachState.Detached;
 			if (node.nodeExistsConstraint.violated !== isNowViolated) {
-				updatedNode.nodeExistsConstraint = {
+				node.nodeExistsConstraint = {
 					...node.nodeExistsConstraint,
 					violated: isNowViolated,
 				};
@@ -1686,7 +1461,7 @@ export class ModularChangeFamily
 		if (node.nodeExistsConstraintOnRevert !== undefined) {
 			const isNowViolated = outputAttachState === NodeAttachState.Detached;
 			if (node.nodeExistsConstraintOnRevert.violated !== isNowViolated) {
-				updatedNode.nodeExistsConstraintOnRevert = {
+				node.nodeExistsConstraintOnRevert = {
 					...node.nodeExistsConstraintOnRevert,
 					violated: isNowViolated,
 				};
@@ -1708,13 +1483,7 @@ export class ModularChangeFamily
 
 	private pruneFieldMap(
 		changeset: FieldChangeMap | undefined,
-		parentId: NodeId | undefined,
 		nodeMap: ChangeAtomIdBTree<NodeChangeset>,
-		nodeToParent: ChangeAtomIdBTree<NodeLocation>,
-		aliases: ChangeAtomIdBTree<NodeId>,
-		roots: RootNodeTable,
-		fieldsWithRootMoves: TupleBTree<FieldIdKey, boolean>,
-		fieldsToRootChanges: TupleBTree<FieldIdKey, ChangeAtomId[]>,
 	): FieldChangeMap | undefined {
 		if (changeset === undefined) {
 			return undefined;
@@ -1725,48 +1494,10 @@ export class ModularChangeFamily
 			const handler = getChangeHandler(this.fieldKinds, fieldChange.fieldKind);
 
 			const prunedFieldChangeset = handler.rebaser.prune(fieldChange.change, (nodeId) =>
-				this.pruneNodeChange(
-					nodeId,
-					nodeMap,
-					nodeToParent,
-					aliases,
-					roots,
-					fieldsWithRootMoves,
-					fieldsToRootChanges,
-				),
+				this.pruneNodeChange(nodeId, nodeMap),
 			);
 
-			const fieldId: FieldId = { nodeId: parentId, field };
-			const fieldIdKey = fieldIdKeyFromFieldId(fieldId);
-			const rootsWithChanges = fieldsToRootChanges.get(fieldIdKey) ?? [];
-			let hasRootWithNodeChange = false;
-			for (const rootId of rootsWithChanges) {
-				const nodeId =
-					getFromChangeAtomIdMap(roots.nodeChanges, rootId) ?? fail("No root change found");
-
-				const isRootChangeEmpty =
-					this.pruneNodeChange(
-						nodeId,
-						nodeMap,
-						nodeToParent,
-						aliases,
-						roots,
-						fieldsWithRootMoves,
-						fieldsToRootChanges,
-					) === undefined;
-
-				if (isRootChangeEmpty) {
-					roots.nodeChanges.delete([rootId.revision, rootId.localId]);
-					tryRemoveDetachLocation(roots, rootId, 1);
-				} else {
-					hasRootWithNodeChange = true;
-				}
-			}
-
-			const hasRootChanges =
-				hasRootWithNodeChange || fieldsWithRootMoves.get(fieldIdKey) === true;
-
-			if (!handler.isEmpty(prunedFieldChangeset) || hasRootChanges) {
+			if (!handler.isEmpty(prunedFieldChangeset)) {
 				prunedChangeset.set(field, { ...fieldChange, change: brand(prunedFieldChangeset) });
 			}
 		}
@@ -1774,65 +1505,15 @@ export class ModularChangeFamily
 		return prunedChangeset.size > 0 ? prunedChangeset : undefined;
 	}
 
-	private pruneRoots(
-		roots: RootNodeTable,
-		nodeMap: ChangeAtomIdBTree<NodeChangeset>,
-		nodeToParent: ChangeAtomIdBTree<NodeLocation>,
-		aliases: ChangeAtomIdBTree<NodeId>,
-		fieldsWithRootMoves: TupleBTree<FieldIdKey, boolean>,
-		fieldsToRootChanges: TupleBTree<FieldIdKey, ChangeAtomId[]>,
-	): RootNodeTable {
-		const pruned: RootNodeTable = { ...roots, nodeChanges: newTupleBTree() };
-		for (const [rootIdKey, nodeId] of roots.nodeChanges.entries()) {
-			const rootId: ChangeAtomId = { revision: rootIdKey[0], localId: rootIdKey[1] };
-			const hasDetachLocation = roots.detachLocations.getFirst(rootId, 1).value !== undefined;
-
-			// If the root has a detach location it should be pruned by recursion when pruning the field it was detached from.
-			const prunedId = hasDetachLocation
-				? nodeId
-				: this.pruneNodeChange(
-						nodeId,
-						nodeMap,
-						nodeToParent,
-						aliases,
-						roots,
-						fieldsWithRootMoves,
-						fieldsToRootChanges,
-					);
-
-			if (prunedId !== undefined) {
-				pruned.nodeChanges.set(rootIdKey, prunedId);
-			}
-
-			tryRemoveDetachLocation(pruned, rootId, 1);
-		}
-
-		return pruned;
-	}
-
 	private pruneNodeChange(
 		nodeId: NodeId,
-		nodes: ChangeAtomIdBTree<NodeChangeset>,
-		nodeToParent: ChangeAtomIdBTree<NodeLocation>,
-		aliases: ChangeAtomIdBTree<NodeId>,
-		roots: RootNodeTable,
-		fieldsWithRootMoves: TupleBTree<FieldIdKey, boolean>,
-		fieldsToRootChanges: TupleBTree<FieldIdKey, ChangeAtomId[]>,
+		nodeMap: ChangeAtomIdBTree<NodeChangeset>,
 	): NodeId | undefined {
-		const changeset = nodeChangeFromId(nodes, aliases, nodeId);
+		const changeset = nodeChangeFromId(nodeMap, nodeId);
 		const prunedFields =
-			changeset.fieldChanges !== undefined
-				? this.pruneFieldMap(
-						changeset.fieldChanges,
-						nodeId,
-						nodes,
-						nodeToParent,
-						aliases,
-						roots,
-						fieldsWithRootMoves,
-						fieldsToRootChanges,
-					)
-				: undefined;
+			changeset.fieldChanges === undefined
+				? undefined
+				: this.pruneFieldMap(changeset.fieldChanges, nodeMap);
 
 		const prunedChange = { ...changeset, fieldChanges: prunedFields };
 		if (prunedChange.fieldChanges === undefined) {
@@ -1840,116 +1521,78 @@ export class ModularChangeFamily
 		}
 
 		if (isEmptyNodeChangeset(prunedChange)) {
-			const nodeIdKey: ChangeAtomIdKey = [nodeId.revision, nodeId.localId];
-
-			// TODO: Shouldn't we also delete all aliases associated with this node?
-			nodes.delete(nodeIdKey);
-			nodeToParent.delete(nodeIdKey);
+			nodeMap.delete([nodeId.revision, nodeId.localId]);
 			return undefined;
 		} else {
-			setInChangeAtomIdMap(nodes, nodeId, prunedChange);
+			setInChangeAtomIdMap(nodeMap, nodeId, prunedChange);
 			return nodeId;
 		}
 	}
 
+	public getRevisions(change: ModularChangeset): Set<RevisionTag | undefined> {
+		const aggregated: Set<RevisionTag | undefined> = new Set();
+		for (const revInfo of change.revisions ?? [{ revision: undefined }]) {
+			aggregated.add(revInfo.revision);
+		}
+		return aggregated;
+	}
+
 	public changeRevision(
 		change: ModularChangeset,
-		newRevision: RevisionTag | undefined,
-		rollbackOf?: RevisionTag,
+		replacer: RevisionReplacer,
 	): ModularChangeset {
-		const oldRevisions = new Set(
-			change.revisions === undefined || change.revisions.length === 0
-				? [undefined]
-				: change.revisions.map((revInfo) => revInfo.revision),
+		const updatedFields = this.replaceFieldMapRevisions(change.fieldChanges, replacer);
+		const updatedNodes = replaceIdMapRevisions(change.nodeChanges, replacer, (nodeChangeset) =>
+			this.replaceNodeChangesetRevisions(nodeChangeset, replacer),
 		);
-		const updatedFields = this.replaceFieldMapRevisions(
-			change.fieldChanges,
-			oldRevisions,
-			newRevision,
+		const updatedNodeToParent = replaceIdMapRevisions(
+			change.nodeToParent,
+			replacer,
+			(fieldId) =>
+				replaceFieldIdRevision(normalizeFieldId(fieldId, change.nodeAliases), replacer),
 		);
 
-		const updatedNodes: ChangeAtomIdBTree<NodeChangeset> = newTupleBTree();
-		for (const [[revision, id], nodeChangeset] of change.nodeChanges.entries()) {
-			updatedNodes.set(
-				[replaceRevision(revision, oldRevisions, newRevision), id],
-				this.replaceNodeChangesetRevisions(nodeChangeset, oldRevisions, newRevision),
-			);
-		}
-
-		const updatedNodeToParent: ChangeAtomIdBTree<NodeLocation> = newTupleBTree();
-		for (const [[revision, id], location] of change.nodeToParent.entries()) {
-			updatedNodeToParent.set(
-				[replaceRevision(revision, oldRevisions, newRevision), id],
-				replaceNodeLocationRevision(
-					normalizeNodeLocation(location, change.nodeAliases),
-					oldRevisions,
-					newRevision,
-				),
-			);
-		}
-
 		const updated: Mutable<ModularChangeset> = {
 			...change,
 			fieldChanges: updatedFields,
 			nodeChanges: updatedNodes,
 			nodeToParent: updatedNodeToParent,
-			rootNodes: replaceRootTableRevision(
-				change.rootNodes,
-				oldRevisions,
-				newRevision,
-				change.nodeAliases,
-			),
 
 			// We've updated all references to old node IDs, so we no longer need an alias table.
 			nodeAliases: newTupleBTree(),
-			crossFieldKeys: change.crossFieldKeys.mapEntries(
-				(key) => replaceCrossFieldKeyRevision(key, oldRevisions, newRevision),
-				(id) =>
-					replaceFieldIdRevision(
-						normalizeFieldId(id, change.nodeAliases),
-						oldRevisions,
-						newRevision,
-					),
+			crossFieldKeys: replaceCrossFieldKeyTableRevisions(
+				change.crossFieldKeys,
+				replacer,
+				change.nodeAliases,
 			),
 		};
 
 		if (change.builds !== undefined) {
-			updated.builds = replaceIdMapRevisions(change.builds, oldRevisions, newRevision);
+			updated.builds = replaceIdMapRevisions(change.builds, replacer);
 		}
 
 		if (change.destroys !== undefined) {
-			updated.destroys = replaceIdMapRevisions(change.destroys, oldRevisions, newRevision);
+			updated.destroys = replaceIdMapRevisions(change.destroys, replacer);
 		}
 
 		if (change.refreshers !== undefined) {
-			updated.refreshers = replaceIdMapRevisions(change.refreshers, oldRevisions, newRevision);
+			updated.refreshers = replaceIdMapRevisions(change.refreshers, replacer);
 		}
 
-		if (newRevision !== undefined) {
-			const revInfo: Mutable<RevisionInfo> = { revision: newRevision };
-			if (rollbackOf !== undefined) {
-				revInfo.rollbackOf = rollbackOf;
-			}
-
-			updated.revisions = [revInfo];
-		} else {
-			delete updated.revisions;
-		}
+		updated.revisions = [{ revision: replacer.updatedRevision }];
 
 		return updated;
 	}
 
 	private replaceNodeChangesetRevisions(
 		nodeChangeset: NodeChangeset,
-		oldRevisions: Set<RevisionTag | undefined>,
-		newRevision: RevisionTag | undefined,
+		replacer: RevisionReplacer,
 	): NodeChangeset {
 		const updated = { ...nodeChangeset };
 		if (nodeChangeset.fieldChanges !== undefined) {
 			updated.fieldChanges = this.replaceFieldMapRevisions(
 				nodeChangeset.fieldChanges,
-				oldRevisions,
-				newRevision,
+				replacer,
 			);
 		}
 
@@ -1958,15 +1601,14 @@ export class ModularChangeFamily
 
 	private replaceFieldMapRevisions(
 		fields: FieldChangeMap,
-		oldRevisions: Set<RevisionTag | undefined>,
-		newRevision: RevisionTag | undefined,
+		replacer: RevisionReplacer,
 	): FieldChangeMap {
 		const updatedFields: FieldChangeMap = new Map();
 		for (const [field, fieldChange] of fields) {
 			const updatedFieldChange = getChangeHandler(
 				this.fieldKinds,
 				fieldChange.fieldKind,
-			).rebaser.replaceRevisions(fieldChange.change, oldRevisions, newRevision);
+			).rebaser.replaceRevisions(fieldChange.change, replacer);
 
 			updatedFields.set(field, { ...fieldChange, change: brand(updatedFieldChange) });
 		}
@@ -1978,7 +1620,7 @@ export class ModularChangeFamily
 		fields: FieldChangeMap,
 		nodes: ChangeAtomIdBTree<NodeChangeset>,
 	): CrossFieldKeyTable {
-		const keys: CrossFieldKeyTable = newCrossFieldRangeTable();
+		const keys: CrossFieldKeyTable = newCrossFieldKeyTable();
 		this.populateCrossFieldKeyTableForFieldMap(keys, fields, undefined);
 		nodes.forEachPair(([revision, localId], node) => {
 			if (node.fieldChanges !== undefined) {
@@ -2008,9 +1650,10 @@ export class ModularChangeFamily
 	}
 
 	public buildEditor(
+		mintRevisionTag: () => RevisionTag,
 		changeReceiver: (change: TaggedChange<ModularChangeset>) => void,
 	): ModularEditBuilder {
-		return new ModularEditBuilder(this, this.fieldKinds, changeReceiver);
+		return new ModularEditBuilder(this, this.fieldKinds, changeReceiver, this.codecOptions);
 	}
 
 	private createEmptyFieldChange(fieldKind: FieldKindIdentifier): FieldChange {
@@ -2019,102 +1662,60 @@ export class ModularChangeFamily
 	}
 
 	public validateChangeset(change: ModularChangeset): void {
-		const unreachableNodes: ChangeAtomIdBTree<NodeLocation> = brand(
-			change.nodeToParent.clone(),
-		);
-
-		const unreachableCFKs = change.crossFieldKeys.clone();
-
-		this.validateFieldChanges(
-			change,
-			change.fieldChanges,
-			undefined,
-			unreachableNodes,
-			unreachableCFKs,
-		);
+		let numNodes = this.validateFieldChanges(change, change.fieldChanges, undefined);
 
 		for (const [[revision, localId], node] of change.nodeChanges.entries()) {
 			if (node.fieldChanges === undefined) {
 				continue;
 			}
 
-			const nodeId = normalizeNodeId({ revision, localId }, change.nodeAliases);
-			this.validateFieldChanges(
-				change,
-				node.fieldChanges,
-				nodeId,
-				unreachableNodes,
-				unreachableCFKs,
-			);
-		}
-
-		for (const [detachIdKey, nodeId] of change.rootNodes.nodeChanges.entries()) {
-			const detachId: ChangeAtomId = { revision: detachIdKey[0], localId: detachIdKey[1] };
-			const location = getNodeParent(change, nodeId);
-			assert(areEqualChangeAtomIdOpts(location.root, detachId), "Inconsistent node location");
-
-			const normalizedNodeId = normalizeNodeId(nodeId, change.nodeAliases);
-			unreachableNodes.delete([normalizedNodeId.revision, normalizedNodeId.localId]);
+			const nodeId: NodeId = { revision, localId };
+			const numChildren = this.validateFieldChanges(change, node.fieldChanges, nodeId);
 
-			const fieldChanges = nodeChangeFromId(
-				change.nodeChanges,
-				change.nodeAliases,
-				nodeId,
-			).fieldChanges;
-
-			if (fieldChanges !== undefined) {
-				this.validateFieldChanges(
-					change,
-					fieldChanges,
-					normalizedNodeId,
-					unreachableNodes,
-					unreachableCFKs,
-				);
-			}
+			numNodes += numChildren;
 		}
 
-		assert(unreachableNodes.size === 0, "Unreachable nodes found");
-		assert(unreachableCFKs.entries().length === 0, "Unreachable cross-field keys found");
+		assert(
+			numNodes === change.nodeChanges.size,
+			0xa4d /* Node table contains unparented nodes */,
+		);
 	}
 
 	/**
-	 * Asserts that each node has a correct entry in `change.nodeToParent`,
-	 * and each cross field key has a correct entry in `change.crossFieldKeys`.
+	 * Asserts that each child and cross field key in each field has a correct entry in
+	 * `nodeToParent` or `crossFieldKeyTable`.
 	 * @returns the number of children found.
 	 */
 	private validateFieldChanges(
 		change: ModularChangeset,
 		fieldChanges: FieldChangeMap,
 		nodeParent: NodeId | undefined,
-		unreachableNodes: ChangeAtomIdBTree<NodeLocation>,
-		unreachableCFKs: CrossFieldRangeTable<FieldId>,
-	): void {
+	): number {
+		let numChildren = 0;
 		for (const [field, fieldChange] of fieldChanges.entries()) {
 			const fieldId = { nodeId: nodeParent, field };
 			const handler = getChangeHandler(this.fieldKinds, fieldChange.fieldKind);
 			for (const [child, _index] of handler.getNestedChanges(fieldChange.change)) {
-				const parentFieldId = getNodeParent(change, child);
+				const parentFieldId = getParentFieldId(change, child);
 				assert(
-					parentFieldId.field !== undefined && areEqualFieldIds(parentFieldId.field, fieldId),
+					areEqualFieldIds(parentFieldId, fieldId),
 					0xa4e /* Inconsistent node parentage */,
 				);
-
-				unreachableNodes.delete([child.revision, child.localId]);
+				numChildren += 1;
 			}
 
 			for (const keyRange of handler.getCrossFieldKeys(fieldChange.change)) {
 				const fields = getFieldsForCrossFieldKey(change, keyRange.key, keyRange.count);
-				assert(fields.length > 0, "Unregistered cross-field key");
-				for (const fieldFromLookup of fields) {
-					assert(
-						areEqualFieldIds(fieldFromLookup, fieldId),
-						0xa4f /* Inconsistent cross field keys */,
-					);
-				}
-
-				unreachableCFKs.delete(keyRange.key, keyRange.count);
+				assert(
+					fields.length === 1 &&
+						fields[0] !== undefined &&
+						areEqualFieldIds(fields[0], fieldId),
+					0xa4f /* Inconsistent cross field keys */,
+				);
 			}
 		}
+
+		return numChildren;
 	}
 
 	private getEffectiveChange(change: ModularChangeset): ModularChangeset {
@@ -2130,8 +1731,7 @@ export class ModularChangeFamily
 	private muteChange(change: ModularChangeset): ModularChangeset {
 		const muted: Mutable<ModularChangeset> = {
 			...change,
-			rootNodes: muteRootChanges(change.rootNodes),
-			crossFieldKeys: newCrossFieldRangeTable(),
+			crossFieldKeys: newCrossFieldKeyTable(),
 			fieldChanges: this.muteFieldChanges(change.fieldChanges),
 			nodeChanges: brand(change.nodeChanges.mapValues((v) => this.muteNodeChange(v))),
 		};
@@ -2163,34 +1763,43 @@ export class ModularChangeFamily
 	}
 }
 
-function replaceCrossFieldKeyRevision(
-	key: CrossFieldKey,
-	oldRevisions: Set<RevisionTag | undefined>,
-	newRevision: RevisionTag | undefined,
-): CrossFieldKey {
-	return {
-		target: key.target,
-		revision: replaceRevision(key.revision, oldRevisions, newRevision),
-		localId: key.localId,
-	};
-}
+function replaceCrossFieldKeyTableRevisions(
+	table: CrossFieldKeyTable,
+	replacer: RevisionReplacer,
+	nodeAliases: ChangeAtomIdBTree<NodeId>,
+): CrossFieldKeyTable {
+	const updated: CrossFieldKeyTable = newCrossFieldKeyTable();
+	for (const entry of table.entries()) {
+		const key = entry.start;
+		const updatedKey: CrossFieldKey = replacer.getUpdatedAtomId(key);
+
+		const field = entry.value;
+		const normalizedFieldId = normalizeFieldId(field, nodeAliases);
+		const updatedNodeId =
+			normalizedFieldId.nodeId === undefined
+				? undefined
+				: replacer.getUpdatedAtomId(normalizedFieldId.nodeId);
+
+		const updatedValue: FieldId = {
+			...normalizedFieldId,
+			nodeId: updatedNodeId,
+		};
+
+		updated.set(updatedKey, entry.length, updatedValue);
+	}
 
-function replaceRevision(
-	revision: RevisionTag | undefined,
-	oldRevisions: Set<RevisionTag | undefined>,
-	newRevision: RevisionTag | undefined,
-): RevisionTag | undefined {
-	return oldRevisions.has(revision) ? newRevision : revision;
+	return updated;
 }
 
 function replaceIdMapRevisions<T>(
 	map: ChangeAtomIdBTree<T>,
-	oldRevisions: Set<RevisionTag | undefined>,
-	newRevision: RevisionTag | undefined,
+	replacer: RevisionReplacer,
+	valueMapper: (value: T) => T = (value) => value,
 ): ChangeAtomIdBTree<T> {
 	const updated: ChangeAtomIdBTree<T> = newTupleBTree();
-	for (const [[revision, id], value] of map.entries()) {
-		updated.set([replaceRevision(revision, oldRevisions, newRevision), id], value);
+	for (const [[revision, localId], value] of map.entries()) {
+		const newAtom = replacer.getUpdatedAtomId({ revision, localId });
+		updated.set([newAtom.revision, newAtom.localId], valueMapper(value));
 	}
 
 	return updated;
@@ -2266,20 +1875,6 @@ function composeBuildsDestroysAndRefreshers(
 		}
 	}
 
-	// It's possible to have a build and a refresher for the same root because an attach operation need not be performed in the same changeset as the corresponding build.
-	if (change1.builds !== undefined && change2.refreshers !== undefined) {
-		for (const [key, chunk] of change2.refreshers.entries()) {
-			assert(chunk.topLevelLength === 1, "Expected refresher chunk to have length 1");
-			const match = change1.builds.getPairOrNextLower(key);
-			if (match !== undefined) {
-				const [buildKey, buildChunk] = match;
-				if (buildKey[0] === key[0] && buildKey[1] + buildChunk.topLevelLength > key[1]) {
-					allRefreshers.delete(key);
-				}
-			}
-		}
-	}
-
 	return { allBuilds, allDestroys, allRefreshers };
 }
 
@@ -2311,77 +1906,27 @@ export function* relevantRemovedRoots(
 	change: ModularChangeset,
 	fieldKinds: ReadonlyMap<FieldKindIdentifier, FlexFieldKind>,
 ): Iterable<DeltaDetachedNodeId> {
-	const rootIds: ChangeAtomIdRangeMap<boolean> = newChangeAtomIdRangeMap();
-	addAttachesToSet(change, rootIds);
-	addRenamesToSet(change, rootIds);
-
-	for (const [[revision, localId]] of change.rootNodes.nodeChanges.entries()) {
-		rootIds.set({ revision, localId }, 1, true);
-	}
-
-	for (const entry of rootIds.entries()) {
-		for (let offset = 0; offset < entry.length; offset++) {
-			const detachId = offsetChangeAtomId(entry.start, offset);
-			yield makeDetachedNodeId(detachId.revision, detachId.localId);
-		}
-	}
-}
-
-export function* getBuildIds(change: ModularChangeset): Iterable<DeltaDetachedNodeId> {
-	if (change.builds !== undefined) {
-		for (const [[revision, localId]] of change.builds.entries()) {
-			yield makeDetachedNodeId(revision, localId);
-		}
-	}
-}
-
-function addAttachesToSet(
-	change: ModularChangeset,
-	rootIds: ChangeAtomIdRangeMap<boolean>,
-): void {
-	// This includes each attach which does not have a corresponding detach.
-	for (const entry of change.crossFieldKeys.entries()) {
-		if (entry.start.target !== CrossFieldTarget.Destination) {
-			continue;
-		}
-
-		for (const detachIdEntry of change.rootNodes.newToOldId.getAll2(
-			entry.start,
-			entry.length,
-		)) {
-			const detachId =
-				detachIdEntry.value ?? offsetChangeAtomId(entry.start, detachIdEntry.offset);
-			for (const detachEntry of change.crossFieldKeys.getAll2(
-				{ ...detachId, target: CrossFieldTarget.Source },
-				detachIdEntry.length,
-			)) {
-				if (detachEntry.value === undefined) {
-					rootIds.set(
-						offsetChangeAtomId(detachId, detachEntry.offset),
-						detachEntry.length,
-						true,
-					);
-				}
-			}
-		}
-	}
+	yield* relevantRemovedRootsFromFields(change.fieldChanges, change.nodeChanges, fieldKinds);
 }
 
-function addRenamesToSet(
-	change: ModularChangeset,
-	rootIds: ChangeAtomIdRangeMap<boolean>,
-): void {
-	for (const renameEntry of change.rootNodes.oldToNewId.entries()) {
-		for (const detachEntry of change.crossFieldKeys.getAll2(
-			{ ...renameEntry.start, target: CrossFieldTarget.Source },
-			renameEntry.length,
-		)) {
-			// We only want to include renames of nodes which are detached in the input context of the changeset.
-			// So if there is a detach for the node, the rename is not relevant.
-			if (detachEntry.value === undefined) {
-				rootIds.set(renameEntry.start, renameEntry.length, true);
+function* relevantRemovedRootsFromFields(
+	change: FieldChangeMap,
+	nodeChanges: ChangeAtomIdBTree<NodeChangeset>,
+	fieldKinds: ReadonlyMap<FieldKindIdentifier, FlexFieldKind>,
+): Iterable<DeltaDetachedNodeId> {
+	for (const [_, fieldChange] of change) {
+		const handler = getChangeHandler(fieldKinds, fieldChange.fieldKind);
+		const delegate = function* (node: NodeId): Iterable<DeltaDetachedNodeId> {
+			const nodeChangeset = nodeChangeFromId(nodeChanges, node);
+			if (nodeChangeset.fieldChanges !== undefined) {
+				yield* relevantRemovedRootsFromFields(
+					nodeChangeset.fieldChanges,
+					nodeChanges,
+					fieldKinds,
+				);
 			}
-		}
+		};
+		yield* handler.relevantRemovedRoots(fieldChange.change, delegate);
 	}
 }
 
@@ -2441,6 +1986,9 @@ export function updateRefreshers(
 	const {
 		fieldChanges,
 		nodeChanges,
+		nodeToParent,
+		nodeAliases,
+		crossFieldKeys,
 		maxId,
 		revisions,
 		constraintViolationCount,
@@ -2452,10 +2000,9 @@ export function updateRefreshers(
 	return makeModularChangeset({
 		fieldChanges,
 		nodeChanges,
-		nodeToParent: change.nodeToParent,
-		nodeAliases: change.nodeAliases,
-		rootNodes: change.rootNodes,
-		crossFieldKeys: change.crossFieldKeys,
+		nodeToParent,
+		nodeAliases,
+		crossFieldKeys,
 		maxId: maxId as number,
 		revisions,
 		constraintViolationCount,
@@ -2478,42 +2025,18 @@ export function intoDelta(
 ): DeltaRoot {
 	const change = taggedChange.change;
 	const rootDelta: Mutable<DeltaRoot> = {};
+	const global: DeltaDetachedNodeChanges[] = [];
+	const rename: DeltaDetachedNodeRename[] = [];
 
 	if (!hasConflicts(change)) {
 		// If there are no constraint violations, then tree changes apply.
 		const fieldDeltas = intoDeltaImpl(
 			change.fieldChanges,
 			change.nodeChanges,
-			change.nodeAliases,
 			fieldKinds,
+			global,
+			rename,
 		);
-
-		const global: DeltaDetachedNodeChanges[] = [];
-		for (const [[major, minor], nodeId] of change.rootNodes.nodeChanges.entries()) {
-			global.push({
-				id: { major, minor },
-				fields: deltaFromNodeChange(
-					nodeChangeFromId(change.nodeChanges, change.nodeAliases, nodeId),
-					change.nodeChanges,
-					change.nodeAliases,
-					fieldKinds,
-				),
-			});
-		}
-
-		const rename: DeltaDetachedNodeRename[] = [];
-		for (const {
-			start: oldId,
-			value: newId,
-			length,
-		} of change.rootNodes.oldToNewId.entries()) {
-			rename.push({
-				count: length,
-				oldId: makeDetachedNodeId(oldId.revision, oldId.localId),
-				newId: makeDetachedNodeId(newId.revision, newId.localId),
-			});
-		}
-
 		if (fieldDeltas.size > 0) {
 			rootDelta.fields = fieldDeltas;
 		}
@@ -2542,7 +2065,6 @@ export function intoDelta(
 	if (change.refreshers && change.refreshers.size > 0) {
 		rootDelta.refreshers = copyDetachedNodes(change.refreshers);
 	}
-
 	return rootDelta;
 }
 
@@ -2568,22 +2090,29 @@ function copyDetachedNodes(
 function intoDeltaImpl(
 	change: FieldChangeMap,
 	nodeChanges: ChangeAtomIdBTree<NodeChangeset>,
-	nodeAliases: ChangeAtomIdBTree<NodeId>,
 	fieldKinds: ReadonlyMap<FieldKindIdentifier, FlexFieldKind>,
+	global: DeltaDetachedNodeChanges[],
+	rename: DeltaDetachedNodeRename[],
 ): Map<FieldKey, DeltaFieldChanges> {
 	const delta: Map<FieldKey, DeltaFieldChanges> = new Map();
 
 	for (const [field, fieldChange] of change) {
-		const fieldDelta = getChangeHandler(fieldKinds, fieldChange.fieldKind).intoDelta(
+		const {
+			local: fieldChanges,
+			global: fieldGlobal,
+			rename: fieldRename,
+		} = getChangeHandler(fieldKinds, fieldChange.fieldKind).intoDelta(
 			fieldChange.change,
 			(childChange): DeltaFieldMap => {
-				const nodeChange = nodeChangeFromId(nodeChanges, nodeAliases, childChange);
-				return deltaFromNodeChange(nodeChange, nodeChanges, nodeAliases, fieldKinds);
+				const nodeChange = nodeChangeFromId(nodeChanges, childChange);
+				return deltaFromNodeChange(nodeChange, nodeChanges, fieldKinds, global, rename);
 			},
 		);
-		if (fieldDelta !== undefined && fieldDelta.length > 0) {
-			delta.set(field, fieldDelta);
+		if (fieldChanges !== undefined && fieldChanges.length > 0) {
+			delta.set(field, fieldChanges);
 		}
+		fieldGlobal?.forEach((c) => global.push(c));
+		fieldRename?.forEach((r) => rename.push(r));
 	}
 	return delta;
 }
@@ -2591,11 +2120,12 @@ function intoDeltaImpl(
 function deltaFromNodeChange(
 	change: NodeChangeset,
 	nodeChanges: ChangeAtomIdBTree<NodeChangeset>,
-	nodeAliases: ChangeAtomIdBTree<NodeId>,
 	fieldKinds: ReadonlyMap<FieldKindIdentifier, FlexFieldKind>,
+	global: DeltaDetachedNodeChanges[],
+	rename: DeltaDetachedNodeRename[],
 ): DeltaFieldMap {
 	if (change.fieldChanges !== undefined) {
-		return intoDeltaImpl(change.fieldChanges, nodeChanges, nodeAliases, fieldKinds);
+		return intoDeltaImpl(change.fieldChanges, nodeChanges, fieldKinds, global, rename);
 	}
 	// TODO: update the API to allow undefined to be returned here
 	return new Map();
@@ -2660,21 +2190,19 @@ export function getChangeHandler(
 	return getFieldKind(fieldKinds, kind).changeHandler;
 }
 
-interface InvertTable {
-	change: ModularChangeset;
+// TODO: TFieldData could instead just be a numeric ID generated by the CrossFieldTable
+// The CrossFieldTable could have a generic field ID to context table
+interface CrossFieldTable<TFieldData> {
+	srcTable: CrossFieldMap<unknown>;
+	dstTable: CrossFieldMap<unknown>;
+	srcDependents: CrossFieldMap<TFieldData>;
+	dstDependents: CrossFieldMap<TFieldData>;
+	invalidatedFields: Set<TFieldData>;
+}
 
-	// Entries are keyed on attach ID
-	entries: CrossFieldMap<NodeId>;
+interface InvertTable extends CrossFieldTable<FieldChange> {
 	originalFieldToContext: Map<FieldChange, InvertContext>;
-	invertedNodeToParent: ChangeAtomIdBTree<NodeLocation>;
-	invertRevision: RevisionTag;
-	invalidatedFields: Set<FieldChange>;
-	invertedRoots: RootNodeTable;
-
-	/**
-	 * Maps from attach ID in the inverted changeset to the corresponding detach ID in the base changeset.
-	 */
-	attachToDetachId: ChangeAtomIdRangeMap<ChangeAtomId>;
+	invertedNodeToParent: ChangeAtomIdBTree<FieldId>;
 }
 
 interface InvertContext {
@@ -2682,11 +2210,7 @@ interface InvertContext {
 	invertedField: FieldChange;
 }
 
-interface RebaseTable {
-	readonly rebaseVersion: RebaseVersion;
-
-	// Entries are keyed on attach ID
-	readonly entries: CrossFieldMap<RebaseDetachedNodeEntry>;
+interface RebaseTable extends CrossFieldTable<FieldChange> {
 	readonly baseChange: ModularChangeset;
 	readonly newChange: ModularChangeset;
 
@@ -2695,13 +2219,10 @@ interface RebaseTable {
 	 * to the context for the field.
 	 */
 	readonly baseFieldToContext: Map<FieldChange, RebaseFieldContext>;
-	readonly baseRoots: RootNodeTable;
 	readonly baseToRebasedNodeId: ChangeAtomIdBTree<NodeId>;
 	readonly rebasedFields: Set<FieldChange>;
-	readonly rebasedNodeToParent: ChangeAtomIdBTree<NodeLocation>;
-	readonly rebasedDetachLocations: ChangeAtomIdRangeMap<FieldId>;
-	readonly movedDetaches: ChangeAtomIdRangeMap<boolean>;
-	readonly rebasedRootNodes: RootNodeTable;
+	readonly rebasedNodeToParent: ChangeAtomIdBTree<FieldId>;
+	readonly rebasedCrossFieldKeys: CrossFieldKeyTable;
 
 	/**
 	 * List of unprocessed (newId, baseId) pairs encountered so far.
@@ -2715,7 +2236,7 @@ interface RebaseTable {
 	readonly fieldsWithUnattachedChild: Set<FieldChange>;
 }
 
-export type FieldIdKey = [RevisionTag | undefined, ChangesetLocalId | undefined, FieldKey];
+type FieldIdKey = [RevisionTag | undefined, ChangesetLocalId | undefined, FieldKey];
 
 interface RebaseFieldContext {
 	baseChange: FieldChange;
@@ -2727,43 +2248,32 @@ interface RebaseFieldContext {
 	 * The set of node IDs in the base changeset which should be included in the rebased field,
 	 * even if there is no corresponding node changeset in the new change.
 	 */
-	baseNodeIds: ChangeAtomIdBTree<boolean>;
+	baseNodeIds: NodeId[];
 }
 
 function newComposeTable(
 	baseChange: ModularChangeset,
 	newChange: ModularChangeset,
-	composedRootNodes: RootNodeTable,
-	movedCrossFieldKeys: CrossFieldKeyTable,
-	removedCrossFieldKeys: CrossFieldRangeTable<boolean>,
-	pendingCompositions: PendingCompositions,
+	composedNodeToParent: ChangeAtomIdBTree<FieldId>,
 ): ComposeTable {
 	return {
-		rebaseVersion: Math.max(
-			baseChange.rebaseVersion,
-			newChange.rebaseVersion,
-		) as RebaseVersion,
-		entries: newDetachedEntryMap(),
+		...newCrossFieldTable<FieldChange>(),
 		baseChange,
 		newChange,
 		fieldToContext: new Map(),
 		newFieldToBaseField: new Map(),
 		newToBaseNodeId: newTupleBTree(),
 		composedNodes: new Set(),
-		movedNodeToParent: newTupleBTree(),
-		composedRootNodes,
-		movedCrossFieldKeys,
-		removedCrossFieldKeys,
-		renamesToDelete: newChangeAtomIdRangeMap(),
-		pendingCompositions,
+		composedNodeToParent,
+		pendingCompositions: {
+			nodeIdsToCompose: [],
+			affectedBaseFields: newTupleBTree(),
+			affectedNewFields: newTupleBTree(),
+		},
 	};
 }
 
-interface ComposeTable {
-	readonly rebaseVersion: RebaseVersion;
-
-	// Entries are keyed on detach ID
-	readonly entries: ChangeAtomIdRangeMap<DetachedNodeEntry>;
+interface ComposeTable extends CrossFieldTable<FieldChange> {
 	readonly baseChange: ModularChangeset;
 	readonly newChange: ModularChangeset;
 
@@ -2774,11 +2284,7 @@ interface ComposeTable {
 	readonly newFieldToBaseField: Map<FieldChange, FieldChange>;
 	readonly newToBaseNodeId: ChangeAtomIdBTree<NodeId>;
 	readonly composedNodes: Set<NodeChangeset>;
-	readonly movedNodeToParent: ChangeAtomIdBTree<NodeLocation>;
-	readonly composedRootNodes: RootNodeTable;
-	readonly movedCrossFieldKeys: CrossFieldKeyTable;
-	readonly removedCrossFieldKeys: CrossFieldRangeTable<boolean>;
-	readonly renamesToDelete: ChangeAtomIdRangeMap<boolean>;
+	readonly composedNodeToParent: ChangeAtomIdBTree<FieldId>;
 	readonly pendingCompositions: PendingCompositions;
 }
 
@@ -2793,6 +2299,11 @@ interface PendingCompositions {
 	 * The set of fields in the base changeset which have been affected by a cross field effect.
 	 */
 	readonly affectedBaseFields: BTree<FieldIdKey, true>;
+
+	/**
+	 * The set of fields in the new changeset which have been affected by a cross field effect.
+	 */
+	readonly affectedNewFields: BTree<FieldIdKey, true>;
 }
 
 interface ComposeFieldContext {
@@ -2805,6 +2316,16 @@ interface ComposeFieldContext {
 	composedChange: FieldChange;
 }
 
+function newCrossFieldTable<T>(): CrossFieldTable<T> {
+	return {
+		srcTable: newChangeAtomIdRangeMap(),
+		dstTable: newChangeAtomIdRangeMap(),
+		srcDependents: newChangeAtomIdRangeMap(),
+		dstDependents: newChangeAtomIdRangeMap(),
+		invalidatedFields: new Set(),
+	};
+}
+
 interface ConstraintState {
 	violationCount: number;
 }
@@ -2815,703 +2336,291 @@ function newConstraintState(violationCount: number): ConstraintState {
 	};
 }
 
-class InvertNodeManagerI implements InvertNodeManager {
+abstract class CrossFieldManagerI<T> implements CrossFieldManager {
 	public constructor(
-		private readonly table: InvertTable,
-		private readonly fieldId: FieldId,
+		protected readonly crossFieldTable: CrossFieldTable<T>,
+		private readonly currentFieldKey: T,
+		protected readonly allowInval = true,
 	) {}
 
-	public invertDetach(
-		detachId: ChangeAtomId,
+	public set(
+		target: CrossFieldTarget,
+		revision: RevisionTag | undefined,
+		id: ChangesetLocalId,
 		count: number,
-		nodeChange: NodeId | undefined,
-		newAttachId: ChangeAtomId,
+		newValue: unknown,
+		invalidateDependents: boolean,
 	): void {
-		if (nodeChange !== undefined) {
-			assert(count === 1, "A node change should only affect one node");
-
-			const attachEntry = firstAttachIdFromDetachId(
-				this.table.change.rootNodes,
-				detachId,
-				count,
-			);
-
-			const attachFieldEntry = this.table.change.crossFieldKeys.getFirst(
-				{ target: CrossFieldTarget.Destination, ...attachEntry.value },
-				count,
-			);
-
-			if (attachFieldEntry.value !== undefined) {
-				setInCrossFieldMap(this.table.entries, attachEntry.value, count, nodeChange);
-				this.table.invalidatedFields.add(
-					fieldChangeFromId(this.table.change, attachFieldEntry.value),
-				);
-			} else {
-				assignRootChange(
-					this.table.invertedRoots,
-					this.table.invertedNodeToParent,
-					attachEntry.value,
-					nodeChange,
-					this.fieldId,
-					this.table.change.rebaseVersion,
+		if (invalidateDependents && this.allowInval) {
+			const lastChangedId = (id as number) + count - 1;
+			let firstId = id;
+			while (firstId <= lastChangedId) {
+				const dependentEntry = getFirstFromCrossFieldMap(
+					this.getDependents(target),
+					revision,
+					firstId,
+					lastChangedId - firstId + 1,
 				);
+				if (dependentEntry.value !== undefined) {
+					this.crossFieldTable.invalidatedFields.add(dependentEntry.value);
+				}
+
+				firstId = brand(firstId + dependentEntry.length);
 			}
 		}
+		setInCrossFieldMap(this.getMap(target), revision, id, count, newValue);
+	}
 
-		if (!areEqualChangeAtomIds(detachId, newAttachId)) {
-			for (const entry of doesChangeAttachNodes(
-				this.table.change.crossFieldKeys,
-				detachId,
+	public get(
+		target: CrossFieldTarget,
+		revision: RevisionTag | undefined,
+		id: ChangesetLocalId,
+		count: number,
+		addDependency: boolean,
+	): RangeQueryResult<ChangeAtomId, unknown> {
+		if (addDependency) {
+			// We assume that if there is already an entry for this ID it is because
+			// a field handler has called compose on the same node multiple times.
+			// In this case we only want to update the latest version, so we overwrite the dependency.
+			setInCrossFieldMap(
+				this.getDependents(target),
+				revision,
+				id,
 				count,
-			)) {
-				if (!entry.value) {
-					this.table.attachToDetachId.set(newAttachId, count, detachId);
-					this.table.invertedRoots.detachLocations.set(detachId, count, this.fieldId);
-				}
-			}
+				this.currentFieldKey,
+			);
 		}
+		return getFirstFromCrossFieldMap(this.getMap(target), revision, id, count);
 	}
 
-	public invertAttach(
-		attachId: ChangeAtomId,
+	public abstract onMoveIn(id: NodeId): void;
+
+	public abstract moveKey(
+		target: CrossFieldTarget,
+		revision: RevisionTag | undefined,
+		id: ChangesetLocalId,
 		count: number,
-	): RangeQueryResult<DetachedNodeEntry> {
-		let countToProcess = count;
+	): void;
 
-		const detachIdEntry = firstDetachIdFromAttachId(
-			this.table.change.rootNodes,
-			attachId,
-			countToProcess,
-		);
+	private getMap(target: CrossFieldTarget): CrossFieldMap<unknown> {
+		return target === CrossFieldTarget.Source
+			? this.crossFieldTable.srcTable
+			: this.crossFieldTable.dstTable;
+	}
 
-		countToProcess = detachIdEntry.length;
+	private getDependents(target: CrossFieldTarget): CrossFieldMap<T> {
+		return target === CrossFieldTarget.Source
+			? this.crossFieldTable.srcDependents
+			: this.crossFieldTable.dstDependents;
+	}
+}
 
-		const detachEntry = getFirstFieldForCrossFieldKey(
-			this.table.change,
-			{ target: CrossFieldTarget.Source, ...detachIdEntry.value },
-			countToProcess,
-		);
-		countToProcess = detachEntry.length;
+class InvertManager extends CrossFieldManagerI<FieldChange> {
+	public constructor(
+		table: InvertTable,
+		field: FieldChange,
+		private readonly fieldId: FieldId,
+		allowInval = true,
+	) {
+		super(table, field, allowInval);
+	}
 
-		let result: RangeQueryResult<DetachedNodeEntry>;
-		if (detachEntry.value !== undefined) {
-			const moveEntry = this.table.entries.getFirst(attachId, countToProcess);
-			result = { ...moveEntry, value: { nodeChange: moveEntry.value } };
-		} else {
-			// This node is detached in the input context of the original change.
-			const nodeIdEntry = rangeQueryChangeAtomIdMap(
-				this.table.change.rootNodes.nodeChanges,
-				detachIdEntry.value,
-				countToProcess,
-			);
+	public override onMoveIn(id: ChangeAtomId): void {
+		setInChangeAtomIdMap(this.table.invertedNodeToParent, id, this.fieldId);
+	}
 
-			countToProcess = nodeIdEntry.length;
-			result = {
-				value: { nodeChange: nodeIdEntry.value, detachId: detachIdEntry.value },
-				length: countToProcess,
-			};
-		}
+	public override moveKey(
+		target: CrossFieldTarget,
+		revision: RevisionTag | undefined,
+		id: ChangesetLocalId,
+		count: number,
+	): void {
+		assert(false, 0x9c5 /* Keys should not be moved manually during invert */);
+	}
 
-		if (result.value?.nodeChange !== undefined) {
-			setInChangeAtomIdMap(this.table.invertedNodeToParent, result.value.nodeChange, {
-				field: this.fieldId,
-			});
-		}
-		return result;
+	private get table(): InvertTable {
+		return this.crossFieldTable as InvertTable;
 	}
 }
 
-class RebaseNodeManagerI implements RebaseNodeManager {
+class RebaseManager extends CrossFieldManagerI<FieldChange> {
 	public constructor(
-		private readonly table: RebaseTable,
+		table: RebaseTable,
+		currentField: FieldChange,
 		private readonly fieldId: FieldId,
-		private readonly allowInval: boolean = true,
-	) {}
-
-	public getNewChangesForBaseAttach(
-		baseAttachId: ChangeAtomId,
-		count: number,
-	): RangeQueryResult<RebaseDetachedNodeEntry | undefined> {
-		let countToProcess = count;
-
-		const detachEntry = firstDetachIdFromAttachId(
-			this.table.baseChange.rootNodes,
-			baseAttachId,
-			countToProcess,
-		);
-
-		countToProcess = detachEntry.length;
-
-		const nodeEntry = rangeQueryChangeAtomIdMap(
-			this.table.newChange.rootNodes.nodeChanges,
-			detachEntry.value,
-			countToProcess,
-		);
-
-		countToProcess = nodeEntry.length;
-		const newNodeId = nodeEntry.value;
-
-		const newRenameEntry = this.table.newChange.rootNodes.oldToNewId.getFirst(
-			detachEntry.value,
-			countToProcess,
-		);
-
-		countToProcess = newRenameEntry.length;
-
-		let result: RangeQueryResult<DetachedNodeEntry | undefined>;
-		// eslint-disable-next-line unicorn/prefer-ternary
-		if (newNodeId !== undefined || newRenameEntry.value !== undefined) {
-			result = {
-				...newRenameEntry,
-				value: { detachId: newRenameEntry.value, nodeChange: newNodeId },
-			};
-		} else {
-			// This handles the case where the base changeset has moved these nodes,
-			// meaning they were attached in the input context of the base changeset.
-			result = this.table.entries.getFirst(baseAttachId, countToProcess);
-		}
-
-		// TODO: Consider moving these two checks into a separate method so that this function has no side effects.
-		if (result.value?.detachId !== undefined) {
-			this.table.rebasedDetachLocations.set(
-				result.value.detachId,
-				result.length,
-				this.fieldId,
-			);
-		}
-
-		if (result.value?.nodeChange !== undefined) {
-			setInChangeAtomIdMap(this.table.rebasedNodeToParent, result.value.nodeChange, {
-				field: this.fieldId,
-			});
-		}
-
-		return result;
+		allowInval = true,
+	) {
+		super(table, currentField, allowInval);
 	}
 
-	public rebaseOverDetach(
-		baseDetachId: ChangeAtomId,
+	public override set(
+		target: CrossFieldTarget,
+		revision: RevisionTag | undefined,
+		id: ChangesetLocalId,
 		count: number,
-		newDetachId: ChangeAtomId | undefined,
-		nodeChange: NodeId | undefined,
-		cellRename?: ChangeAtomId,
+		newValue: unknown,
+		invalidateDependents: boolean,
 	): void {
-		let countToProcess = count;
-		const attachIdEntry = firstAttachIdFromDetachId(
-			this.table.baseRoots,
-			baseDetachId,
-			countToProcess,
-		);
-		const baseAttachId = attachIdEntry.value;
-		countToProcess = attachIdEntry.length;
-
-		const attachFieldEntry = getFirstFieldForCrossFieldKey(
-			this.table.baseChange,
-			{ ...baseAttachId, target: CrossFieldTarget.Destination },
-			countToProcess,
-		);
-		countToProcess = attachFieldEntry.length;
+		if (invalidateDependents && this.allowInval) {
+			const newFieldIds = getFieldsForCrossFieldKey(
+				this.table.newChange,
+				{
+					target,
+					revision,
+					localId: id,
+				},
+				count,
+			);
 
-		const detachedMoveEntry = this.table.baseChange.rootNodes.outputDetachLocations.getFirst(
-			baseDetachId,
-			countToProcess,
-		);
-		countToProcess = detachedMoveEntry.length;
-
-		const destinationField = attachFieldEntry.value ?? detachedMoveEntry.value;
-		if (destinationField !== undefined) {
-			// The base detach is part of a move (or move of detach location) in the base changeset.
-			setInCrossFieldMap(this.table.entries, baseAttachId, countToProcess, {
-				nodeChange,
-				detachId: newDetachId,
-				cellRename,
-			});
+			assert(
+				newFieldIds.length === 0,
+				0x9c6 /* TODO: Modifying a cross-field key from the new changeset is currently unsupported */,
+			);
 
-			if (nodeChange !== undefined || newDetachId !== undefined) {
-				this.invalidateBaseFields([destinationField]);
-			}
-		}
+			const baseFieldIds = getFieldsForCrossFieldKey(
+				this.table.baseChange,
+				{
+					target,
+					revision,
+					localId: id,
+				},
+				count,
+			);
 
-		if (attachFieldEntry.value === undefined) {
-			// These nodes are detached in the output context of the base changeset.
-			if (nodeChange !== undefined) {
-				assignRootChange(
-					this.table.rebasedRootNodes,
-					this.table.rebasedNodeToParent,
-					baseAttachId,
-					nodeChange,
-					this.fieldId,
-					this.table.rebaseVersion,
-				);
-			}
+			assert(
+				baseFieldIds.length > 0,
+				0x9c7 /* Cross field key not registered in base or new change */,
+			);
 
-			if (newDetachId !== undefined) {
-				addNodeRename(
-					this.table.rebasedRootNodes,
-					baseAttachId,
-					newDetachId,
-					countToProcess,
-					this.fieldId,
+			for (const baseFieldId of baseFieldIds) {
+				this.table.affectedBaseFields.set(
+					[baseFieldId.nodeId?.revision, baseFieldId.nodeId?.localId, baseFieldId.field],
+					true,
 				);
 			}
 		}
 
-		if (newDetachId !== undefined) {
-			this.table.movedDetaches.set(newDetachId, countToProcess, true);
-		}
-
-		if (countToProcess < count) {
-			const remainingCount = count - countToProcess;
-
-			const nextDetachId =
-				newDetachId !== undefined
-					? offsetChangeAtomId(newDetachId, countToProcess)
-					: undefined;
-
-			this.rebaseOverDetach(
-				offsetChangeAtomId(baseDetachId, countToProcess),
-				remainingCount,
-				nextDetachId,
-				nodeChange,
-			);
-		}
-	}
-
-	public addDetach(id: ChangeAtomId, count: number): void {
-		this.table.rebasedDetachLocations.set(id, count, this.fieldId);
-	}
-
-	public removeDetach(id: ChangeAtomId, count: number): void {
-		this.table.movedDetaches.set(id, count, true);
-	}
-
-	public doesBaseAttachNodes(
-		id: ChangeAtomId,
-		count: number,
-	): RangeQueryEntry<ChangeAtomId, boolean> {
-		let countToProcess = count;
-		const attachEntry = getFirstAttachField(
-			this.table.baseChange.crossFieldKeys,
-			id,
-			countToProcess,
-		);
-
-		countToProcess = attachEntry.length;
-		return { start: id, value: attachEntry.value !== undefined, length: countToProcess };
+		super.set(target, revision, id, count, newValue, invalidateDependents);
 	}
 
-	public getBaseRename(
-		id: ChangeAtomId,
-		count: number,
-	): RangeQueryResult<ChangeAtomId | undefined> {
-		return this.table.baseChange.rootNodes.oldToNewId.getFirst(id, count);
+	public override onMoveIn(id: ChangeAtomId): void {
+		setInChangeAtomIdMap(this.table.rebasedNodeToParent, id, this.fieldId);
 	}
 
-	public getNewRenameForBaseRename(
-		baseRenameTo: ChangeAtomId,
+	public override moveKey(
+		target: CrossFieldTarget,
+		revision: RevisionTag | undefined,
+		id: ChangesetLocalId,
 		count: number,
-	): RangeQueryResult<ChangeAtomId | undefined> {
-		let countToProcess = count;
-		const inputEntry = firstDetachIdFromAttachId(
-			this.table.baseChange.rootNodes,
-			baseRenameTo,
-			countToProcess,
-		);
-
-		const attachEntry = getFirstAttachField(
-			this.table.baseChange.crossFieldKeys,
-			baseRenameTo,
-			countToProcess,
+	): void {
+		this.table.rebasedCrossFieldKeys.set(
+			{ target, revision, localId: id },
+			count,
+			this.fieldId,
 		);
-
-		countToProcess = attachEntry.length;
-		if (attachEntry.value !== undefined) {
-			// These nodes are attached in the output context of the base changeset.
-			return { value: undefined, length: countToProcess };
-		}
-
-		countToProcess = inputEntry.length;
-		const inputId = inputEntry.value;
-
-		const moveEntry = this.table.entries.getFirst(inputId, countToProcess);
-
-		countToProcess = moveEntry.length;
-		if (moveEntry.value !== undefined) {
-			return { ...moveEntry, value: moveEntry.value.cellRename ?? moveEntry.value.detachId };
-		}
-
-		return this.table.newChange.rootNodes.oldToNewId.getFirst(inputId, countToProcess);
-	}
-
-	private invalidateBaseFields(fields: FieldId[]): void {
-		if (this.allowInval) {
-			for (const fieldId of fields) {
-				this.table.affectedBaseFields.set(fieldIdKeyFromFieldId(fieldId), true);
-			}
-		}
 	}
-}
-
-function assignRootChange(
-	table: RootNodeTable,
-	nodeToParent: ChangeAtomIdBTree<NodeLocation> | undefined,
-	detachId: ChangeAtomId,
-	nodeId: NodeId,
-	detachLocation: FieldId | undefined,
-	rebaseVersion: RebaseVersion,
-): void {
-	assert(
-		rebaseVersion >= 2 || detachLocation !== undefined,
-		"All root changes need a detach location to support compatibility with older client versions",
-	);
-
-	setInChangeAtomIdMap(table.nodeChanges, detachId, nodeId);
 
-	if (nodeToParent !== undefined) {
-		setInChangeAtomIdMap(nodeToParent, nodeId, { root: detachId });
+	private get table(): RebaseTable {
+		return this.crossFieldTable as RebaseTable;
 	}
-
-	table.detachLocations.set(detachId, 1, detachLocation);
 }
 
-class ComposeNodeManagerI implements ComposeNodeManager {
+// TODO: Deduplicate this with RebaseTable
+class ComposeManager extends CrossFieldManagerI<FieldChange> {
 	public constructor(
-		private readonly table: ComposeTable,
+		table: ComposeTable,
+		currentField: FieldChange,
 		private readonly fieldId: FieldId,
-		private readonly allowInval: boolean = true,
-	) {}
-
-	public getNewChangesForBaseDetach(
-		baseDetachId: ChangeAtomId,
-		count: number,
-	): RangeQueryResult<DetachedNodeEntry | undefined> {
-		let countToProcess = count;
-
-		const baseAttachEntry = getFirstFieldForCrossFieldKey(
-			this.table.baseChange,
-			{ target: CrossFieldTarget.Destination, ...baseDetachId },
-			countToProcess,
-		);
-
-		countToProcess = baseAttachEntry.length;
-
-		let result: RangeQueryResult<DetachedNodeEntry | undefined>;
-		if (baseAttachEntry.value !== undefined) {
-			// The base detach was part of a move.
-			// We check if we've previously seen a node change at the move destination.
-			const entry = this.table.entries.getFirst(baseDetachId, countToProcess);
-			result = { value: entry.value, length: entry.length };
-		} else {
-			// The detached nodes are still detached in the new change's input context.
-			const rootEntry = rangeQueryChangeAtomIdMap(
-				this.table.newChange.rootNodes.nodeChanges,
-				baseDetachId,
-				countToProcess,
-			);
-
-			countToProcess = rootEntry.length;
-
-			const newRenameEntry = this.table.newChange.rootNodes.oldToNewId.getFirst(
-				baseDetachId,
-				countToProcess,
-			);
-
-			countToProcess = newRenameEntry.length;
-
-			result = {
-				value: { nodeChange: rootEntry.value, detachId: newRenameEntry.value },
-				length: countToProcess,
-			};
-		}
-
-		// TODO: Consider moving this to a separate method so that this method can be side-effect free.
-		if (result.value?.nodeChange !== undefined) {
-			setInChangeAtomIdMap(this.table.movedNodeToParent, result.value.nodeChange, {
-				field: this.fieldId,
-			});
-		}
-
-		return result;
+		allowInval = true,
+	) {
+		super(table, currentField, allowInval);
 	}
 
-	public composeAttachDetach(
-		baseAttachId: ChangeAtomId,
-		newDetachId: ChangeAtomId,
+	public override set(
+		target: CrossFieldTarget,
+		revision: RevisionTag | undefined,
+		id: ChangesetLocalId,
 		count: number,
+		newValue: unknown,
+		invalidateDependents: boolean,
 	): void {
-		let countToProcess = count;
-
-		const newAttachEntry = getFirstAttachField(
-			this.table.newChange.crossFieldKeys,
-			newDetachId,
-			countToProcess,
-		);
-
-		countToProcess = newAttachEntry.length;
-
-		// Both changes can have the same ID if they came from inverse changesets.
-		// If the new detach is part of a move,
-		// then both input changesets contain the attach cross-field key for this ID.
-		// The new attach may still exist in the composed changeset so we do not remove it here.
-		// The new attach will typically cancel with a base detach,
-		// in which case the cross-field key will be removed in `composeDetachAttach`.
-		const hasNewAttachWithBaseAttachId =
-			areEqualChangeAtomIds(baseAttachId, newDetachId) && newAttachEntry.value !== undefined;
-
-		if (!hasNewAttachWithBaseAttachId) {
-			this.table.removedCrossFieldKeys.set(
-				{ ...baseAttachId, target: CrossFieldTarget.Destination },
-				countToProcess,
-				true,
+		if (invalidateDependents && this.allowInval) {
+			const newFieldIds = getFieldsForCrossFieldKey(
+				this.table.newChange,
+				{
+					target,
+					revision,
+					localId: id,
+				},
+				count,
 			);
-		}
-
-		const baseDetachEntry = getFirstDetachField(
-			this.table.baseChange.crossFieldKeys,
-			baseAttachId,
-			countToProcess,
-		);
-
-		countToProcess = baseDetachEntry.length;
-
-		const baseRootIdEntry = firstDetachIdFromAttachId(
-			this.table.baseChange.rootNodes,
-			baseAttachId,
-			countToProcess,
-		);
-		countToProcess = baseRootIdEntry.length;
-
-		const baseDetachId = baseRootIdEntry.value;
-
-		if (baseDetachEntry.value !== undefined) {
-			// The base change moves these nodes.
-			const prevEntry =
-				this.table.entries.getFirst(baseAttachId, baseDetachEntry.length).value ?? {};
 
-			this.table.entries.set(baseAttachId, baseDetachEntry.length, {
-				...prevEntry,
-				detachId: newDetachId,
-			});
-
-			// The new detach will replace the base detach, so we remove the key for the base detach, unless they have the same ID.
-			if (!areEqualChangeAtomIds(baseAttachId, newDetachId)) {
-				this.table.removedCrossFieldKeys.set(
-					{ ...baseAttachId, target: CrossFieldTarget.Source },
-					countToProcess,
-					true,
+			if (newFieldIds.length > 0) {
+				for (const newFieldId of newFieldIds) {
+					this.table.pendingCompositions.affectedNewFields.set(
+						[newFieldId.nodeId?.revision, newFieldId.nodeId?.localId, newFieldId.field],
+						true,
+					);
+				}
+			} else {
+				const baseFieldIds = getFieldsForCrossFieldKey(
+					this.table.baseChange,
+					{
+						target,
+						revision,
+						localId: id,
+					},
+					count,
 				);
-			}
 
-			this.table.movedCrossFieldKeys.set(
-				{ ...newDetachId, target: CrossFieldTarget.Source },
-				countToProcess,
-				baseDetachEntry.value,
-			);
-
-			this.invalidateBaseFields([baseDetachEntry.value]);
-		} else {
-			const baseDetachLocationEntry = this.table.baseChange.rootNodes.detachLocations.getFirst(
-				baseDetachId,
-				countToProcess,
-			);
-			countToProcess = baseDetachLocationEntry.length;
-
-			// These nodes were detached in the base change's input context,
-			// so the net effect of the two changes is a rename.
-			appendNodeRename(
-				this.table.composedRootNodes,
-				baseAttachId,
-				newDetachId,
-				baseDetachEntry.length,
-				this.table.baseChange.rootNodes,
-				baseDetachLocationEntry.value ?? this.fieldId,
-			);
-
-			this.table.removedCrossFieldKeys.set(
-				{ ...newDetachId, target: CrossFieldTarget.Source },
-				countToProcess,
-				true,
-			);
-		}
-
-		if (newAttachEntry.value === undefined) {
-			const newOutputDetachLocationEntry =
-				this.table.newChange.rootNodes.outputDetachLocations.getFirst(
-					newDetachId,
-					countToProcess,
+				assert(
+					baseFieldIds.length > 0,
+					0x9c8 /* Cross field key not registered in base or new change */,
 				);
 
-			countToProcess = newOutputDetachLocationEntry.length;
-
-			this.table.composedRootNodes.outputDetachLocations.set(
-				newDetachId,
-				countToProcess,
-				newOutputDetachLocationEntry.value ?? this.fieldId,
-			);
-		}
-
-		if (countToProcess < count) {
-			const remainingCount = count - countToProcess;
-			this.composeAttachDetach(
-				offsetChangeAtomId(baseAttachId, countToProcess),
-				offsetChangeAtomId(newDetachId, countToProcess),
-				remainingCount,
-			);
-		}
-	}
-
-	public sendNewChangesToBaseSourceLocation(
-		baseAttachId: ChangeAtomId,
-		newChanges: NodeId,
-	): void {
-		const { value: baseDetachId } = firstDetachIdFromAttachId(
-			this.table.baseChange.rootNodes,
-			baseAttachId,
-			1,
-		);
-
-		const detachFields = getFieldsForCrossFieldKey(
-			this.table.baseChange,
-			{
-				...baseDetachId,
-				target: CrossFieldTarget.Source,
-			},
-			1,
-		);
-
-		if (detachFields.length > 0) {
-			// The base attach is part of a move in the base changeset.
-			const prevEntry = this.table.entries.getFirst(baseDetachId, 1).value ?? {};
-			this.table.entries.set(baseDetachId, 1, { ...prevEntry, nodeChange: newChanges });
-
-			if (newChanges !== undefined) {
-				this.invalidateBaseFields(detachFields);
-			}
-		} else {
-			const baseNodeId = getFromChangeAtomIdMap(
-				this.table.baseChange.rootNodes.nodeChanges,
-				baseDetachId,
-			);
-
-			if (baseNodeId !== undefined) {
-				addNodesToCompose(this.table, baseNodeId, newChanges);
-			} else {
-				assignRootChange(
-					this.table.composedRootNodes,
-					this.table.movedNodeToParent,
-					baseDetachId,
-					newChanges,
-					this.fieldId,
-					this.table.rebaseVersion,
-				);
+				for (const baseFieldId of baseFieldIds) {
+					this.table.pendingCompositions.affectedBaseFields.set(
+						[baseFieldId.nodeId?.revision, baseFieldId.nodeId?.localId, baseFieldId.field],
+						true,
+					);
+				}
 			}
 		}
-	}
 
-	private areSameNodes(
-		baseDetachId: ChangeAtomId,
-		newAttachId: ChangeAtomId,
-		count: number,
-	): RangeQueryResult<boolean> {
-		const renamedDetachEntry = firstAttachIdFromDetachId(
-			this.table.composedRootNodes,
-			baseDetachId,
-			count,
-		);
+		super.set(target, revision, id, count, newValue, invalidateDependents);
+	}
 
-		const isReattachOfSameNodes = areEqualChangeAtomIds(renamedDetachEntry.value, newAttachId);
-		return { ...renamedDetachEntry, value: isReattachOfSameNodes };
+	public override onMoveIn(id: ChangeAtomId): void {
+		setInChangeAtomIdMap(this.table.composedNodeToParent, id, this.fieldId);
 	}
 
-	public composeDetachAttach(
-		baseDetachId: ChangeAtomId,
-		newAttachId: ChangeAtomId,
+	public override moveKey(
+		target: CrossFieldTarget,
+		revision: RevisionTag | undefined,
+		id: ChangesetLocalId,
 		count: number,
-		composeToPin: boolean,
 	): void {
-		const areSameEntry = this.areSameNodes(baseDetachId, newAttachId, count);
-
-		const countToProcess = areSameEntry.length;
-		if (areSameEntry.value) {
-			// These nodes have been moved back to their original location, so the composed changeset should not have any renames for them.
-			// Note that deleting the rename from `this.table.composedRootNodes` would change the result of this method
-			// if it were rerun due to the field being invalidated, so we instead record that the rename should be deleted later.
-			this.table.renamesToDelete.set(baseDetachId, countToProcess, true);
-		}
-
-		if (composeToPin) {
-			this.table.movedCrossFieldKeys.set(
-				{ target: CrossFieldTarget.Source, ...newAttachId },
-				countToProcess,
-				this.fieldId,
-			);
-
-			if (!areEqualChangeAtomIds(baseDetachId, newAttachId)) {
-				// The pin will have `newAttachId` as both its detach and attach ID.
-				// So we remove `baseDetachId` unless that is equal to the pin's detach ID.
-				this.table.removedCrossFieldKeys.set(
-					{ target: CrossFieldTarget.Source, ...baseDetachId },
-					countToProcess,
-					true,
-				);
-			}
-
-			// Note that while change2 should already have this key, change1 may have a rollback for the same ID in a different location.
-			// In that case, change1's attach should be canceled out by a detach from change2.
-			// Here we make sure that the composed change has the correct location (this field) for the attach ID.
-			this.table.movedCrossFieldKeys.set(
-				{ target: CrossFieldTarget.Destination, ...newAttachId },
-				countToProcess,
-				this.fieldId,
-			);
-		} else {
-			this.table.removedCrossFieldKeys.set(
-				{ target: CrossFieldTarget.Source, ...baseDetachId },
-				countToProcess,
-				true,
-			);
-
-			this.table.removedCrossFieldKeys.set(
-				{ target: CrossFieldTarget.Destination, ...newAttachId },
-				countToProcess,
-				true,
-			);
-		}
-
-		if (countToProcess < count) {
-			this.composeAttachDetach(
-				offsetChangeAtomId(baseDetachId, countToProcess),
-				offsetChangeAtomId(newAttachId, countToProcess),
-				count - countToProcess,
-			);
-		}
+		throw new Error("Moving cross-field keys during compose is currently unsupported");
 	}
 
-	private invalidateBaseFields(fields: FieldId[]): void {
-		if (this.allowInval) {
-			for (const fieldId of fields) {
-				this.table.pendingCompositions.affectedBaseFields.set(
-					fieldIdKeyFromFieldId(fieldId),
-					true,
-				);
-			}
-		}
+	private get table(): ComposeTable {
+		return this.crossFieldTable as ComposeTable;
 	}
 }
 
 function makeModularChangeset(
 	props: {
-		rebaseVersion?: RebaseVersion;
 		fieldChanges?: FieldChangeMap;
 		nodeChanges?: ChangeAtomIdBTree<NodeChangeset>;
-		rootNodes?: RootNodeTable;
-		nodeToParent?: ChangeAtomIdBTree<NodeLocation>;
+		nodeToParent?: ChangeAtomIdBTree<FieldId>;
 		nodeAliases?: ChangeAtomIdBTree<NodeId>;
 		crossFieldKeys?: CrossFieldKeyTable;
 		maxId: number;
 		revisions?: readonly RevisionInfo[];
 		constraintViolationCount?: number;
 		constraintViolationCountOnRevert?: number;
+		noChangeConstraint?: NoChangeConstraint;
+		noChangeConstraintOnRevert?: NoChangeConstraint;
 		builds?: ChangeAtomIdBTree<TreeChunk>;
 		destroys?: ChangeAtomIdBTree<number>;
 		refreshers?: ChangeAtomIdBTree<TreeChunk>;
@@ -3520,13 +2629,11 @@ function makeModularChangeset(
 	},
 ): ModularChangeset {
 	const changeset: Mutable<ModularChangeset> = {
-		rebaseVersion: props.rebaseVersion ?? 1,
 		fieldChanges: props.fieldChanges ?? new Map(),
 		nodeChanges: props.nodeChanges ?? newTupleBTree(),
-		rootNodes: props.rootNodes ?? newRootTable(),
 		nodeToParent: props.nodeToParent ?? newTupleBTree(),
 		nodeAliases: props.nodeAliases ?? newTupleBTree(),
-		crossFieldKeys: props.crossFieldKeys ?? newCrossFieldRangeTable(),
+		crossFieldKeys: props.crossFieldKeys ?? newCrossFieldKeyTable(),
 	};
 
 	if (props.revisions !== undefined && props.revisions.length > 0) {
@@ -3544,6 +2651,12 @@ function makeModularChangeset(
 	) {
 		changeset.constraintViolationCountOnRevert = props.constraintViolationCountOnRevert;
 	}
+	if (props.noChangeConstraint !== undefined) {
+		changeset.noChangeConstraint = props.noChangeConstraint;
+	}
+	if (props.noChangeConstraintOnRevert !== undefined) {
+		changeset.noChangeConstraintOnRevert = props.noChangeConstraintOnRevert;
+	}
 	if (props.builds !== undefined && props.builds.size > 0) {
 		changeset.builds = props.builds;
 	}
@@ -3553,25 +2666,23 @@ function makeModularChangeset(
 	if (props.refreshers !== undefined && props.refreshers.size > 0) {
 		changeset.refreshers = props.refreshers;
 	}
-
 	return changeset;
 }
 
 export class ModularEditBuilder extends EditBuilder<ModularChangeset> {
 	private transactionDepth: number = 0;
 	private idAllocator: IdAllocator;
+	private readonly codecOptions: CodecWriteOptions;
 
 	public constructor(
 		family: ChangeFamily<ChangeFamilyEditor, ModularChangeset>,
 		private readonly fieldKinds: ReadonlyMap<FieldKindIdentifier, FlexFieldKind>,
 		changeReceiver: (change: TaggedChange<ModularChangeset>) => void,
+		codecOptions: CodecWriteOptions,
 	) {
 		super(family, changeReceiver);
 		this.idAllocator = idAllocatorFromMaxId();
-	}
-
-	public isInTransaction(): boolean {
-		return this.transactionDepth > 0;
+		this.codecOptions = codecOptions;
 	}
 
 	public override enterTransaction(): void {
@@ -3628,7 +2739,7 @@ export class ModularEditBuilder extends EditBuilder<ModularChangeset> {
 	 * @param revision - the revision of the change
 	 */
 	public submitChange(
-		field: NormalizedFieldUpPath,
+		field: FieldUpPath,
 		fieldKind: FieldKindIdentifier,
 		change: FieldChangeset,
 		revision: RevisionTag,
@@ -3642,8 +2753,7 @@ export class ModularEditBuilder extends EditBuilder<ModularChangeset> {
 			fieldChange: { fieldKind, change },
 			nodeChanges: newTupleBTree(),
 			nodeToParent: newTupleBTree(),
-			crossFieldKeys: newCrossFieldRangeTable(),
-			rootNodes: newRootTable(),
+			crossFieldKeys: newCrossFieldKeyTable(),
 			idAllocator: this.idAllocator,
 			localCrossFieldKeys,
 			revision,
@@ -3665,7 +2775,6 @@ export class ModularEditBuilder extends EditBuilder<ModularChangeset> {
 					? makeModularChangeset({
 							maxId: this.idAllocator.getMaxId(),
 							builds: change.builds,
-							rootNodes: renameTableFromRenameDescriptions(change.renames ?? []),
 							revisions: [{ revision: change.revision }],
 						})
 					: buildModularChangesetFromField({
@@ -3676,8 +2785,7 @@ export class ModularEditBuilder extends EditBuilder<ModularChangeset> {
 							},
 							nodeChanges: newTupleBTree(),
 							nodeToParent: newTupleBTree(),
-							crossFieldKeys: newCrossFieldRangeTable(),
-							rootNodes: newRootTable(),
+							crossFieldKeys: newCrossFieldKeyTable(),
 							idAllocator: this.idAllocator,
 							localCrossFieldKeys: getChangeHandler(
 								this.fieldKinds,
@@ -3687,7 +2795,7 @@ export class ModularEditBuilder extends EditBuilder<ModularChangeset> {
 						}),
 			);
 		});
-		const revInfo = Array.from(revisions).map((revision) => ({ revision }));
+		const revInfo = [...revisions].map((revision) => ({ revision }));
 		const composedChange: Mutable<ModularChangeset> = {
 			...this.changeFamily.rebaser.compose(changeMaps),
 			revisions: revInfo,
@@ -3704,7 +2812,7 @@ export class ModularEditBuilder extends EditBuilder<ModularChangeset> {
 		return brand(this.idAllocator.allocate(count));
 	}
 
-	public addNodeExistsConstraint(path: NormalizedUpPath, revision: RevisionTag): void {
+	public addNodeExistsConstraint(path: UpPath, revision: RevisionTag): void {
 		const nodeChange: NodeChangeset = {
 			nodeExistsConstraint: { violated: false },
 		};
@@ -3716,8 +2824,7 @@ export class ModularEditBuilder extends EditBuilder<ModularChangeset> {
 					nodeChange,
 					nodeChanges: newTupleBTree(),
 					nodeToParent: newTupleBTree(),
-					crossFieldKeys: newCrossFieldRangeTable(),
-					rootNodes: newRootTable(),
+					crossFieldKeys: newCrossFieldKeyTable(),
 					idAllocator: this.idAllocator,
 					revision,
 				}),
@@ -3726,7 +2833,7 @@ export class ModularEditBuilder extends EditBuilder<ModularChangeset> {
 		);
 	}
 
-	public addNodeExistsConstraintOnRevert(path: NormalizedUpPath, revision: RevisionTag): void {
+	public addNodeExistsConstraintOnRevert(path: UpPath, revision: RevisionTag): void {
 		const nodeChange: NodeChangeset = {
 			nodeExistsConstraintOnRevert: { violated: false },
 		};
@@ -3738,8 +2845,7 @@ export class ModularEditBuilder extends EditBuilder<ModularChangeset> {
 					nodeChange,
 					nodeChanges: newTupleBTree(),
 					nodeToParent: newTupleBTree(),
-					crossFieldKeys: newCrossFieldRangeTable(),
-					rootNodes: newRootTable(),
+					crossFieldKeys: newCrossFieldKeyTable(),
 					idAllocator: this.idAllocator,
 					revision,
 				}),
@@ -3747,15 +2853,44 @@ export class ModularEditBuilder extends EditBuilder<ModularChangeset> {
 			),
 		);
 	}
+
+	public addNoChangeConstraint(revision: RevisionTag): void {
+		if (lt(this.codecOptions.minVersionForCollab, FluidClientVersion.v2_80)) {
+			throw new UsageError(
+				`No change constraints require min client version of at least ${FluidClientVersion.v2_80}`,
+			);
+		}
+
+		const changeset = makeModularChangeset({
+			maxId: -1,
+			noChangeConstraint: { violated: false },
+		});
+
+		this.applyChange(tagChange(changeset, revision));
+	}
+
+	public addNoChangeConstraintOnRevert(revision: RevisionTag): void {
+		if (lt(this.codecOptions.minVersionForCollab, FluidClientVersion.v2_80)) {
+			throw new UsageError(
+				`No change constraints require min client version of at least ${FluidClientVersion.v2_80}`,
+			);
+		}
+
+		const changeset = makeModularChangeset({
+			maxId: -1,
+			noChangeConstraintOnRevert: { violated: false },
+		});
+
+		this.applyChange(tagChange(changeset, revision));
+	}
 }
 
-export function buildModularChangesetFromField(props: {
-	path: NormalizedFieldUpPath;
+function buildModularChangesetFromField(props: {
+	path: FieldUpPath;
 	fieldChange: FieldChange;
 	nodeChanges: ChangeAtomIdBTree<NodeChangeset>;
-	nodeToParent: ChangeAtomIdBTree<NodeLocation>;
+	nodeToParent: ChangeAtomIdBTree<FieldId>;
 	crossFieldKeys: CrossFieldKeyTable;
-	rootNodes: RootNodeTable;
 	localCrossFieldKeys?: CrossFieldKeyRange[];
 	revision: RevisionTag;
 	idAllocator?: IdAllocator;
@@ -3767,7 +2902,6 @@ export function buildModularChangesetFromField(props: {
 		nodeChanges,
 		nodeToParent,
 		crossFieldKeys,
-		rootNodes,
 		idAllocator = idAllocatorFromMaxId(),
 		localCrossFieldKeys = [],
 		childId,
@@ -3776,17 +2910,14 @@ export function buildModularChangesetFromField(props: {
 	const fieldChanges: FieldChangeMap = new Map([[path.field, fieldChange]]);
 
 	if (path.parent === undefined) {
-		const field = { nodeId: undefined, field: path.field };
 		for (const { key, count } of localCrossFieldKeys) {
-			crossFieldKeys.set(key, count, field);
+			crossFieldKeys.set(key, count, { nodeId: undefined, field: path.field });
 		}
 
 		if (childId !== undefined) {
 			setInChangeAtomIdMap(nodeToParent, childId, {
-				field: {
-					nodeId: undefined,
-					field: path.field,
-				},
+				nodeId: undefined,
+				field: path.field,
 			});
 		}
 
@@ -3795,7 +2926,6 @@ export function buildModularChangesetFromField(props: {
 			nodeChanges,
 			nodeToParent,
 			crossFieldKeys,
-			rootNodes,
 			maxId: idAllocator.getMaxId(),
 			revisions: [{ revision }],
 		});
@@ -3806,7 +2936,6 @@ export function buildModularChangesetFromField(props: {
 	};
 
 	const parentId: NodeId = { localId: brand(idAllocator.allocate()), revision };
-	const fieldId = { nodeId: parentId, field: path.field };
 
 	for (const { key, count } of localCrossFieldKeys) {
 		crossFieldKeys.set(key, count, { nodeId: parentId, field: path.field });
@@ -3814,7 +2943,8 @@ export function buildModularChangesetFromField(props: {
 
 	if (childId !== undefined) {
 		setInChangeAtomIdMap(nodeToParent, childId, {
-			field: fieldId,
+			nodeId: parentId,
+			field: path.field,
 		});
 	}
 
@@ -3824,7 +2954,6 @@ export function buildModularChangesetFromField(props: {
 		nodeChanges,
 		nodeToParent,
 		crossFieldKeys,
-		rootNodes,
 		idAllocator,
 		revision,
 		nodeId: parentId,
@@ -3832,58 +2961,45 @@ export function buildModularChangesetFromField(props: {
 }
 
 function buildModularChangesetFromNode(props: {
-	path: NormalizedUpPath;
+	path: UpPath;
 	nodeChange: NodeChangeset;
 	nodeChanges: ChangeAtomIdBTree<NodeChangeset>;
-	nodeToParent: ChangeAtomIdBTree<NodeLocation>;
+	nodeToParent: ChangeAtomIdBTree<FieldId>;
 	crossFieldKeys: CrossFieldKeyTable;
-	rootNodes: RootNodeTable;
 	idAllocator: IdAllocator;
 	revision: RevisionTag;
 	nodeId?: NodeId;
 }): ModularChangeset {
 	const {
 		path,
-		nodeId = { localId: brand(props.idAllocator.allocate()), revision: props.revision },
+		idAllocator,
+		revision,
+		nodeChanges,
+		nodeChange,
+		nodeId = { localId: brand(idAllocator.allocate()), revision },
 	} = props;
-	setInChangeAtomIdMap(props.nodeChanges, nodeId, props.nodeChange);
-
-	if (isDetachedUpPathRoot(path)) {
-		props.rootNodes.nodeChanges.set(
-			[path.detachedNodeId.major, brand(path.detachedNodeId.minor)],
-			nodeId,
-		);
-		return makeModularChangeset({
-			rootNodes: props.rootNodes,
-			nodeChanges: props.nodeChanges,
-			nodeToParent: props.nodeToParent,
-			crossFieldKeys: props.crossFieldKeys,
-			maxId: props.idAllocator.getMaxId(),
-			revisions: [{ revision: props.revision }],
-		});
-	} else {
-		const fieldChangeset = genericFieldKind.changeHandler.editor.buildChildChanges([
-			[path.parentIndex, nodeId],
-		]);
-
-		const fieldChange: FieldChange = {
-			fieldKind: genericFieldKind.identifier,
-			change: fieldChangeset,
-		};
+	setInChangeAtomIdMap(nodeChanges, nodeId, nodeChange);
+	const fieldChangeset = genericFieldKind.changeHandler.editor.buildChildChanges([
+		[path.parentIndex, nodeId],
+	]);
+
+	const fieldChange: FieldChange = {
+		fieldKind: genericFieldKind.identifier,
+		change: fieldChangeset,
+	};
 
-		return buildModularChangesetFromField({
-			...props,
-			path: { parent: path.parent, field: path.parentField },
-			fieldChange,
-			localCrossFieldKeys: [],
-			childId: nodeId,
-		});
-	}
+	return buildModularChangesetFromField({
+		...props,
+		path: { parent: path.parent, field: path.parentField },
+		fieldChange,
+		localCrossFieldKeys: [],
+		childId: nodeId,
+	});
 }
 
 export interface FieldEditDescription {
 	type: "field";
-	field: NormalizedFieldUpPath;
+	field: FieldUpPath;
 	fieldKind: FieldKindIdentifier;
 	change: FieldChangeset;
 	revision: RevisionTag;
@@ -3893,23 +3009,6 @@ export interface GlobalEditDescription {
 	type: "global";
 	revision: RevisionTag;
 	builds?: ChangeAtomIdBTree<TreeChunk>;
-	renames?: RenameDescription[];
-}
-
-export interface RenameDescription {
-	count: number;
-	oldId: ChangeAtomId;
-	newId: ChangeAtomId;
-	detachLocation: FieldId | undefined;
-}
-
-function renameTableFromRenameDescriptions(renames: RenameDescription[]): RootNodeTable {
-	const table = newRootTable();
-	for (const rename of renames) {
-		addNodeRename(table, rename.oldId, rename.newId, rename.count, rename.detachLocation);
-	}
-
-	return table;
 }
 
 export type EditDescription = FieldEditDescription | GlobalEditDescription;
@@ -3920,10 +3019,31 @@ function getRevInfoFromTaggedChanges(changes: TaggedChange<ModularChangeset>[]):
 } {
 	let maxId = -1;
 	const revInfos: RevisionInfo[] = [];
+	const revisions = new Set<RevisionTag>();
 	for (const taggedChange of changes) {
 		const change = taggedChange.change;
 		maxId = Math.max(change.maxId ?? -1, maxId);
-		revInfos.push(...revisionInfoFromTaggedChange(taggedChange));
+		const infosToAdd = revisionInfoFromTaggedChange(taggedChange);
+		for (const info of infosToAdd) {
+			if (!revisions.has(info.revision)) {
+				revisions.add(info.revision);
+				revInfos.push(info);
+			}
+		}
+	}
+
+	const rolledBackRevisions: RevisionTag[] = [];
+	for (const info of revInfos) {
+		if (info.rollbackOf !== undefined) {
+			rolledBackRevisions.push(info.rollbackOf);
+		}
+	}
+
+	rolledBackRevisions.reverse();
+	for (const revision of rolledBackRevisions) {
+		if (!revisions.has(revision)) {
+			revInfos.push({ revision });
+		}
 	}
 
 	return { maxId: brand(maxId), revInfos };
@@ -3945,28 +3065,25 @@ function revisionInfoFromTaggedChange(
 	return revInfos;
 }
 
-function fieldChangeFromId(change: ModularChangeset, id: FieldId): FieldChange {
-	const fieldId = normalizeFieldId(id, change.nodeAliases);
-	const fieldMap = fieldMapFromNodeId(
-		change.fieldChanges,
-		change.nodeChanges,
-		change.nodeAliases,
-		fieldId.nodeId,
-	);
+function fieldChangeFromId(
+	fields: FieldChangeMap,
+	nodes: ChangeAtomIdBTree<NodeChangeset>,
+	id: FieldId,
+): FieldChange {
+	const fieldMap = fieldMapFromNodeId(fields, nodes, id.nodeId);
 	return fieldMap.get(id.field) ?? fail(0xb25 /* No field exists for the given ID */);
 }
 
 function fieldMapFromNodeId(
 	rootFieldMap: FieldChangeMap,
 	nodes: ChangeAtomIdBTree<NodeChangeset>,
-	aliases: ChangeAtomIdBTree<NodeId>,
 	nodeId: NodeId | undefined,
 ): FieldChangeMap {
 	if (nodeId === undefined) {
 		return rootFieldMap;
 	}
 
-	const node = nodeChangeFromId(nodes, aliases, nodeId);
+	const node = nodeChangeFromId(nodes, nodeId);
 	assert(node.fieldChanges !== undefined, 0x9c9 /* Expected node to have field changes */);
 	return node.fieldChanges;
 }
@@ -3983,26 +3100,17 @@ function rebasedNodeIdFromBaseNodeId(table: RebaseTable, baseId: NodeId): NodeId
 	return getFromChangeAtomIdMap(table.baseToRebasedNodeId, baseId) ?? baseId;
 }
 
-function nodeChangeFromId(
-	nodes: ChangeAtomIdBTree<NodeChangeset>,
-	aliases: ChangeAtomIdBTree<NodeId>,
-	id: NodeId,
-): NodeChangeset {
-	const normalizedId = normalizeNodeId(id, aliases);
-	const node = getFromChangeAtomIdMap(nodes, normalizedId);
+function nodeChangeFromId(nodes: ChangeAtomIdBTree<NodeChangeset>, id: NodeId): NodeChangeset {
+	const node = getFromChangeAtomIdMap(nodes, id);
 	assert(node !== undefined, 0x9ca /* Unknown node ID */);
 	return node;
 }
 
 function fieldIdFromFieldIdKey([revision, localId, field]: FieldIdKey): FieldId {
-	const nodeId = localId !== undefined ? { revision, localId } : undefined;
+	const nodeId = localId === undefined ? undefined : { revision, localId };
 	return { nodeId, field };
 }
 
-function fieldIdKeyFromFieldId(fieldId: FieldId): FieldIdKey {
-	return [fieldId.nodeId?.revision, fieldId.nodeId?.localId, fieldId.field];
-}
-
 function cloneNodeChangeset(nodeChangeset: NodeChangeset): NodeChangeset {
 	if (nodeChangeset.fieldChanges !== undefined) {
 		return { ...nodeChangeset, fieldChanges: new Map(nodeChangeset.fieldChanges) };
@@ -4011,41 +3119,21 @@ function cloneNodeChangeset(nodeChangeset: NodeChangeset): NodeChangeset {
 	return { ...nodeChangeset };
 }
 
-function replaceNodeLocationRevision(
-	location: NodeLocation,
-	oldRevisions: Set<RevisionTag | undefined>,
-	newRevision: RevisionTag | undefined,
-): NodeLocation {
-	return location.field !== undefined
-		? { field: replaceFieldIdRevision(location.field, oldRevisions, newRevision) }
-		: { root: replaceAtomRevisions(location.root, oldRevisions, newRevision) };
-}
-
-function replaceFieldIdRevision(
-	fieldId: FieldId,
-	oldRevisions: Set<RevisionTag | undefined>,
-	newRevision: RevisionTag | undefined,
-): FieldId {
+function replaceFieldIdRevision(fieldId: FieldId, replacer: RevisionReplacer): FieldId {
 	if (fieldId.nodeId === undefined) {
 		return fieldId;
 	}
 
 	return {
 		...fieldId,
-		nodeId: replaceAtomRevisions(fieldId.nodeId, oldRevisions, newRevision),
+		nodeId: replacer.getUpdatedAtomId(fieldId.nodeId),
 	};
 }
 
-export function getNodeParent(changeset: ModularChangeset, nodeId: NodeId): NodeLocation {
-	const normalizedNodeId = normalizeNodeId(nodeId, changeset.nodeAliases);
-	const location = getFromChangeAtomIdMap(changeset.nodeToParent, normalizedNodeId);
-	assert(location !== undefined, 0x9cb /* Parent field should be defined */);
-
-	if (location.field !== undefined) {
-		return { field: normalizeFieldId(location.field, changeset.nodeAliases) };
-	}
-
-	return location;
+export function getParentFieldId(changeset: ModularChangeset, nodeId: NodeId): FieldId {
+	const parentId = getFromChangeAtomIdMap(changeset.nodeToParent, nodeId);
+	assert(parentId !== undefined, 0x9cb /* Parent field should be defined */);
+	return normalizeFieldId(parentId, changeset.nodeAliases);
 }
 
 function getFieldsForCrossFieldKey(
@@ -4058,49 +3146,21 @@ function getFieldsForCrossFieldKey(
 		.map(({ value: fieldId }) => normalizeFieldId(fieldId, changeset.nodeAliases));
 }
 
-function getFirstFieldForCrossFieldKey(
-	changeset: ModularChangeset,
-	key: CrossFieldKey,
-	count: number,
-): RangeQueryResult<FieldId | undefined> {
-	const result = changeset.crossFieldKeys.getFirst(key, count);
-	if (result.value === undefined) {
-		return result;
-	}
-
-	return { ...result, value: normalizeFieldId(result.value, changeset.nodeAliases) };
-}
-
-function normalizeNodeLocation(
-	location: NodeLocation,
-	nodeAliases: ChangeAtomIdBTree<NodeId>,
-): NodeLocation {
-	if (location.field !== undefined) {
-		return { field: normalizeFieldId(location.field, nodeAliases) };
-	}
-
-	return location;
-}
-
 // This is only exported for use in test utilities.
 export function normalizeFieldId(
 	fieldId: FieldId,
 	nodeAliases: ChangeAtomIdBTree<NodeId>,
 ): FieldId {
-	return fieldId.nodeId !== undefined
-		? { ...fieldId, nodeId: normalizeNodeId(fieldId.nodeId, nodeAliases) }
-		: fieldId;
+	return fieldId.nodeId === undefined
+		? fieldId
+		: { ...fieldId, nodeId: normalizeNodeId(fieldId.nodeId, nodeAliases) };
 }
 
 /**
  * @returns The canonical form of nodeId, according to nodeAliases
  */
-export function normalizeNodeId(
-	nodeId: NodeId,
-	nodeAliases: ChangeAtomIdBTree<NodeId>,
-): NodeId {
+function normalizeNodeId(nodeId: NodeId, nodeAliases: ChangeAtomIdBTree<NodeId>): NodeId {
 	let currentId = nodeId;
-	let cycleProbeId: NodeId | undefined = nodeId;
 
 	// eslint-disable-next-line no-constant-condition
 	while (true) {
@@ -4110,16 +3170,6 @@ export function normalizeNodeId(
 		}
 
 		currentId = dealiased;
-
-		if (cycleProbeId !== undefined) {
-			cycleProbeId = getFromChangeAtomIdMap(nodeAliases, cycleProbeId);
-		}
-
-		if (cycleProbeId !== undefined) {
-			cycleProbeId = getFromChangeAtomIdMap(nodeAliases, cycleProbeId);
-		}
-
-		assert(!areEqualChangeAtomIdOpts(cycleProbeId, currentId), "Alias cycle detected");
 	}
 }
 
@@ -4130,8 +3180,7 @@ function hasConflicts(change: ModularChangeset): boolean {
 interface ModularChangesetContent {
 	fieldChanges: FieldChangeMap;
 	nodeChanges: ChangeAtomIdBTree<NodeChangeset>;
-	nodeToParent: ChangeAtomIdBTree<NodeLocation>;
-	rootNodes: RootNodeTable;
+	nodeToParent: ChangeAtomIdBTree<FieldId>;
 	nodeAliases: ChangeAtomIdBTree<NodeId>;
 	crossFieldKeys: CrossFieldKeyTable;
 }
@@ -4139,826 +3188,3 @@ interface ModularChangesetContent {
 function areEqualFieldIds(a: FieldId, b: FieldId): boolean {
 	return areEqualChangeAtomIdOpts(a.nodeId, b.nodeId) && a.field === b.field;
 }
-
-function firstAttachIdFromDetachId(
-	roots: RootNodeTable,
-	detachId: ChangeAtomId,
-	count: number,
-): RangeQueryResult<ChangeAtomId> {
-	const result = roots.oldToNewId.getFirst(detachId, count);
-	return { ...result, value: result.value ?? detachId };
-}
-
-function firstDetachIdFromAttachId(
-	roots: RootNodeTable,
-	attachId: ChangeAtomId,
-	count: number,
-): RangeQueryEntry<ChangeAtomId, ChangeAtomId> {
-	const result = roots.newToOldId.getFirst(attachId, count);
-	return { ...result, start: attachId, value: result.value ?? attachId };
-}
-
-function rebaseCrossFieldKeys(
-	sourceTable: CrossFieldKeyTable,
-	movedDetaches: ChangeAtomIdRangeMap<boolean>,
-	newDetachLocations: ChangeAtomIdRangeMap<FieldId>,
-): CrossFieldKeyTable {
-	const rebasedTable = sourceTable.clone();
-	for (const entry of movedDetaches.entries()) {
-		rebasedTable.delete({ ...entry.start, target: CrossFieldTarget.Source }, entry.length);
-	}
-
-	for (const entry of newDetachLocations.entries()) {
-		rebasedTable.set(
-			{ ...entry.start, target: CrossFieldTarget.Source },
-			entry.length,
-			entry.value,
-		);
-	}
-
-	return rebasedTable;
-}
-
-export function newRootTable(): RootNodeTable {
-	return {
-		newToOldId: newChangeAtomIdTransform(),
-		oldToNewId: newChangeAtomIdTransform(),
-		nodeChanges: newTupleBTree(),
-		detachLocations: newChangeAtomIdRangeMap(),
-		outputDetachLocations: newChangeAtomIdRangeMap(),
-	};
-}
-
-function rebaseRoots(
-	change: ModularChangeset,
-	base: ModularChangeset,
-	affectedBaseFields: TupleBTree<FieldIdKey, boolean>,
-	nodesToRebase: [newChangeset: NodeId, baseChangeset: NodeId][],
-	rebasedNodeToParent: ChangeAtomIdBTree<NodeLocation>,
-	rebaseVersion: RebaseVersion,
-): RootNodeTable {
-	const rebasedRoots = newRootTable();
-	for (const renameEntry of change.rootNodes.oldToNewId.entries()) {
-		rebaseRename(change.rootNodes, rebasedRoots, renameEntry, base, affectedBaseFields);
-	}
-
-	for (const [detachIdKey, nodeId] of change.rootNodes.nodeChanges.entries()) {
-		const changes = base.rootNodes.nodeChanges.get(detachIdKey);
-		if (changes !== undefined) {
-			nodesToRebase.push([nodeId, changes]);
-		}
-
-		const detachId = makeChangeAtomId(detachIdKey[1], detachIdKey[0]);
-		const attachId = firstAttachIdFromDetachId(base.rootNodes, detachId, 1).value;
-		const baseAttachEntry = base.crossFieldKeys.getFirst(
-			{ target: CrossFieldTarget.Destination, ...attachId },
-			1,
-		);
-		if (baseAttachEntry.value !== undefined) {
-			affectedBaseFields.set(fieldIdKeyFromFieldId(baseAttachEntry.value), true);
-			rebasedNodeToParent.delete(detachIdKey);
-		} else {
-			const renamedDetachId = firstAttachIdFromDetachId(base.rootNodes, detachId, 1).value;
-			const baseOutputDetachLocation = base.rootNodes.outputDetachLocations.getFirst(
-				renamedDetachId,
-				1,
-			).value;
-
-			if (baseOutputDetachLocation !== undefined) {
-				affectedBaseFields.set(fieldIdKeyFromFieldId(baseOutputDetachLocation), true);
-			}
-
-			const detachLocation =
-				baseOutputDetachLocation ??
-				change.rootNodes.detachLocations.getFirst(detachId, 1).value;
-
-			// Note that `baseOutputDetachLocation` may contain a node ID from the base changeset.
-			// We will replace the detach location entry with the node ID from the rebased changeset in `fixupRebasedDetachLocations`
-			assignRootChange(
-				rebasedRoots,
-				rebasedNodeToParent,
-				renamedDetachId,
-				nodeId,
-				detachLocation,
-				rebaseVersion,
-			);
-		}
-	}
-
-	for (const entry of change.rootNodes.outputDetachLocations.entries()) {
-		rebasedRoots.outputDetachLocations.set(entry.start, entry.length, entry.value);
-	}
-
-	return rebasedRoots;
-}
-
-function rebaseRename(
-	newRoots: RootNodeTable,
-	rebasedRoots: RootNodeTable,
-	renameEntry: RangeQueryEntry<ChangeAtomId, ChangeAtomId>,
-	base: ModularChangeset,
-	affectedBaseFields: TupleBTree<FieldIdKey, boolean>,
-): void {
-	let count = renameEntry.length;
-	const baseRenameEntry = firstAttachIdFromDetachId(base.rootNodes, renameEntry.start, count);
-	count = baseRenameEntry.length;
-
-	const baseAttachEntry = base.crossFieldKeys.getFirst(
-		{
-			...baseRenameEntry.value,
-			target: CrossFieldTarget.Destination,
-		},
-		count,
-	);
-
-	count = baseAttachEntry.length;
-
-	if (baseAttachEntry.value !== undefined) {
-		// This rename represents an intention to detach these nodes.
-		// The rebased change should have a detach in the field where the base change attaches the nodes,
-		// so we need to ensure that field is processed.
-		affectedBaseFields.set(
-			fieldIdKeyFromFieldId(normalizeFieldId(baseAttachEntry.value, base.nodeAliases)),
-			true,
-		);
-	} else {
-		const baseOutputDetachLocation = base.rootNodes.outputDetachLocations.getFirst(
-			baseRenameEntry.value,
-			1,
-		).value;
-
-		if (baseOutputDetachLocation !== undefined) {
-			affectedBaseFields.set(fieldIdKeyFromFieldId(baseOutputDetachLocation), true);
-		}
-
-		const detachEntry = newRoots.detachLocations.getFirst(renameEntry.start, count);
-		count = detachEntry.length;
-
-		const detachLocation = baseOutputDetachLocation ?? detachEntry.value;
-
-		// Note that `baseOutputDetachLocation` may contain a node ID from the base changeset.
-		// We will replace the detach location entry with the node ID from the rebased changeset in `fixupRebasedDetachLocations`
-		addNodeRename(
-			rebasedRoots,
-			baseRenameEntry.value,
-			renameEntry.value,
-			count,
-			detachLocation,
-		);
-	}
-
-	const countRemaining = renameEntry.length - count;
-	if (countRemaining > 0) {
-		rebaseRename(
-			newRoots,
-			rebasedRoots,
-			{
-				start: offsetChangeAtomId(renameEntry.start, count),
-				value: offsetChangeAtomId(renameEntry.value, count),
-				length: countRemaining,
-			},
-			base,
-			affectedBaseFields,
-		);
-	}
-}
-
-/**
- * For each root detach location, replaces any node ID from the base changeset
- * with the corresponding ID in the new changeset.
- */
-function fixupRebasedDetachLocations(table: RebaseTable): void {
-	for (const {
-		start,
-		length,
-		value: detachLocation,
-	} of table.rebasedRootNodes.detachLocations.entries()) {
-		const normalizedDetachLocation = normalizeFieldId(
-			detachLocation,
-			table.baseChange.nodeAliases,
-		);
-
-		if (normalizedDetachLocation.nodeId !== undefined) {
-			const rebasedNodeId = getFromChangeAtomIdMap(
-				table.baseToRebasedNodeId,
-				normalizedDetachLocation.nodeId,
-			);
-
-			if (rebasedNodeId !== undefined) {
-				table.rebasedRootNodes.detachLocations.set(start, length, {
-					...normalizedDetachLocation,
-					nodeId: rebasedNodeId,
-				});
-			}
-		}
-	}
-}
-
-function addNodesToCompose(table: ComposeTable, id1: NodeId, id2: NodeId): void {
-	const normalizedId1 = normalizeNodeId(id1, table.baseChange.nodeAliases);
-	const normalizedId2 = normalizeNodeId(id2, table.newChange.nodeAliases);
-	if (getFromChangeAtomIdMap(table.newToBaseNodeId, normalizedId2) === undefined) {
-		setInChangeAtomIdMap(table.newToBaseNodeId, normalizedId2, normalizedId1);
-		table.pendingCompositions.nodeIdsToCompose.push([normalizedId1, normalizedId2]);
-	}
-}
-
-function composeRevInfos(
-	revisions1: readonly RevisionInfo[] | undefined,
-	revisions2: readonly RevisionInfo[] | undefined,
-): RevisionInfo[] {
-	const result: RevisionInfo[] = [...(revisions1 ?? []), ...(revisions2 ?? [])];
-	return result;
-}
-
-function composeCrossFieldKeyTables(
-	table1: CrossFieldKeyTable,
-	table2: CrossFieldKeyTable,
-	movedCrossFieldKeys: CrossFieldKeyTable,
-	removedCrossFieldKeys: CrossFieldRangeTable<boolean>,
-): CrossFieldKeyTable {
-	const composedTable = RangeMap.union(table1, table2);
-	for (const entry of movedCrossFieldKeys.entries()) {
-		composedTable.set(entry.start, entry.length, entry.value);
-	}
-
-	for (const entry of removedCrossFieldKeys.entries()) {
-		composedTable.delete(entry.start, entry.length);
-	}
-
-	return composedTable;
-}
-
-function composeRootTables(
-	change1: ModularChangeset,
-	change2: ModularChangeset,
-	composedNodeToParent: ChangeAtomIdBTree<NodeLocation>,
-	movedCrossFieldKeys: CrossFieldKeyTable,
-	removedCrossFieldKeys: CrossFieldRangeTable<boolean>,
-	pendingCompositions: PendingCompositions,
-): RootNodeTable {
-	const composedTable = cloneRootTable(change1.rootNodes);
-
-	for (const renameEntry of change2.rootNodes.oldToNewId.entries()) {
-		composeRename(
-			change1,
-			change2,
-			composedTable,
-			renameEntry.start,
-			renameEntry.value,
-			renameEntry.length,
-			movedCrossFieldKeys,
-			removedCrossFieldKeys,
-			pendingCompositions,
-		);
-	}
-
-	for (const [[revision2, id2], nodeId2] of change2.rootNodes.nodeChanges.entries()) {
-		const detachId2 = { revision: revision2, localId: id2 };
-		const detachId1 = firstDetachIdFromAttachId(change1.rootNodes, detachId2, 1).value;
-		const nodeId1 = getFromChangeAtomIdMap(change1.rootNodes.nodeChanges, detachId1);
-
-		if (nodeId1 !== undefined) {
-			pendingCompositions.nodeIdsToCompose.push([nodeId1, nodeId2]);
-		} else {
-			const fieldId = getFieldsForCrossFieldKey(
-				change1,
-				{ ...detachId1, target: CrossFieldTarget.Source },
-				1,
-			)[0];
-
-			if (fieldId !== undefined) {
-				// In this case, this node is attached in the input context of change1,
-				// and is represented in detachFieldId.
-				pendingCompositions.affectedBaseFields.set(
-					[fieldId.nodeId?.revision, fieldId.nodeId?.localId, fieldId.field],
-					true,
-				);
-			} else {
-				assignRootChange(
-					composedTable,
-					composedNodeToParent,
-					detachId1,
-					nodeId2,
-					change1.rootNodes.detachLocations.getFirst(detachId1, 1).value ??
-						change2.rootNodes.detachLocations.getFirst(detachId2, 1).value,
-					Math.max(change1.rebaseVersion, change2.rebaseVersion) as RebaseVersion,
-				);
-			}
-		}
-	}
-
-	for (const outputDetachEntry of change1.rootNodes.outputDetachLocations.entries()) {
-		composeOutputDetachLocation(
-			outputDetachEntry.start,
-			outputDetachEntry.length,
-			outputDetachEntry.value,
-			change2,
-			composedTable,
-		);
-	}
-
-	for (const entry of change2.rootNodes.outputDetachLocations.entries()) {
-		composedTable.outputDetachLocations.set(entry.start, entry.length, entry.value);
-	}
-
-	return composedTable;
-}
-
-function composeOutputDetachLocation(
-	outputDetachId1: ChangeAtomId,
-	count: number,
-	detachLocation: FieldId,
-	change2: ModularChangeset,
-	composedTable: RootNodeTable,
-): void {
-	let countToProcess = count;
-	const renameEntry = firstAttachIdFromDetachId(
-		change2.rootNodes,
-		outputDetachId1,
-		countToProcess,
-	);
-	countToProcess = renameEntry.length;
-
-	const attachEntry = getFirstAttachField(
-		change2.crossFieldKeys,
-		renameEntry.value,
-		countToProcess,
-	);
-	countToProcess = attachEntry.length;
-
-	composedTable.outputDetachLocations.delete(outputDetachId1, countToProcess);
-
-	if (attachEntry.value === undefined) {
-		// We update the key for the detach location to the renamed ID of the root in the composed output context.
-		composedTable.outputDetachLocations.set(renameEntry.value, countToProcess, detachLocation);
-	} else {
-		// These nodes are attached by `change2` and thus attached in the composed output context,
-		// so there should be no output detach location.
-	}
-
-	const countRemaining = count - countToProcess;
-	if (countRemaining > 0) {
-		composeOutputDetachLocation(
-			offsetChangeAtomId(outputDetachId1, countToProcess),
-			countRemaining,
-			detachLocation,
-			change2,
-			composedTable,
-		);
-	}
-}
-
-function composeRename(
-	change1: ModularChangeset,
-	change2: ModularChangeset,
-	mergedTable: RootNodeTable,
-	oldId: ChangeAtomId,
-	newId: ChangeAtomId,
-	count: number,
-	movedCrossFieldKeys: CrossFieldKeyTable,
-	removedCrossFieldKeys: CrossFieldRangeTable<boolean>,
-	pendingCompositions: PendingCompositions,
-): void {
-	let countToProcess = count;
-	const detachEntry = getFirstDetachField(change1.crossFieldKeys, oldId, countToProcess);
-	countToProcess = detachEntry.length;
-
-	if (detachEntry.value !== undefined) {
-		// `change1` detached these nodes,
-		// so we invalidate the detach location so that the detach's ID can be replaced with the new ID.
-		pendingCompositions.affectedBaseFields.set(fieldIdKeyFromFieldId(detachEntry.value), true);
-
-		if (!areEqualChangeAtomIds(oldId, newId)) {
-			// `change1`'s detach will be replaced by `change2`'s detach, so we update the cross-field keys.
-			removedCrossFieldKeys.set(
-				{ ...oldId, target: CrossFieldTarget.Source },
-				countToProcess,
-				true,
-			);
-		}
-
-		movedCrossFieldKeys.set(
-			{ ...newId, target: CrossFieldTarget.Source },
-			countToProcess,
-			detachEntry.value,
-		);
-	} else {
-		// `change1` may also have a rename to `renameEntry.value`, in which case it must refer to a different node.
-		// That node must have been attached by `change1` and detached by `change2`.
-		// The final rename for that node will be created in `composeAttachDetach`.
-		// We delete any such rename for now to avoid colliding with the rename currently being processed.
-		deleteNodeRenameTo(mergedTable, newId, countToProcess);
-
-		// The nodes were detached before `change`, so we append this rename.
-		appendNodeRename(
-			mergedTable,
-			oldId,
-			newId,
-			countToProcess,
-			change1.rootNodes,
-			change2.rootNodes.detachLocations.getFirst(oldId, countToProcess).value,
-		);
-	}
-
-	if (countToProcess < count) {
-		composeRename(
-			change1,
-			change2,
-			mergedTable,
-			offsetChangeAtomId(oldId, countToProcess),
-			offsetChangeAtomId(newId, countToProcess),
-			count - countToProcess,
-			movedCrossFieldKeys,
-			removedCrossFieldKeys,
-			pendingCompositions,
-		);
-	}
-}
-
-export function cloneRootTable(table: RootNodeTable): RootNodeTable {
-	return {
-		oldToNewId: table.oldToNewId.clone(),
-		newToOldId: table.newToOldId.clone(),
-		nodeChanges: brand(table.nodeChanges.clone()),
-		detachLocations: table.detachLocations.clone(),
-		outputDetachLocations: table.outputDetachLocations.clone(),
-	};
-}
-
-function invertRootTable(change: ModularChangeset, isRollback: boolean): RootNodeTable {
-	const invertedRoots: RootNodeTable = newRootTable();
-	for (const [[revision, localId], nodeId] of change.rootNodes.nodeChanges.entries()) {
-		const detachId: ChangeAtomId = { revision, localId };
-		const renamedId = firstAttachIdFromDetachId(change.rootNodes, detachId, 1).value;
-
-		// This checks whether `change` attaches this node.
-		// If it does, the node is not detached in the input context of the inverse, and so should not be included in the root table.
-		if (
-			change.crossFieldKeys.getFirst({ ...renamedId, target: CrossFieldTarget.Destination }, 1)
-				.value === undefined
-		) {
-			assignRootChange(
-				invertedRoots,
-				undefined,
-				renamedId,
-				nodeId,
-				change.rootNodes.detachLocations.getFirst(detachId, 1).value,
-				change.rebaseVersion,
-			);
-		}
-	}
-
-	if (isRollback) {
-		// We only invert renames of nodes which are not attached or detached by this changeset.
-		// When we invert an attach we will create a detach which incorporates the rename.
-		for (const {
-			start: oldId,
-			value: newId,
-			length,
-		} of change.rootNodes.oldToNewId.entries()) {
-			invertRename(change, invertedRoots, oldId, newId, length);
-		}
-	}
-
-	return invertedRoots;
-}
-
-function invertRename(
-	change: ModularChangeset,
-	invertedRoots: RootNodeTable,
-	oldId: ChangeAtomId,
-	newId: ChangeAtomId,
-	length: number,
-): void {
-	for (const detachEntry of doesChangeDetachNodes(change.crossFieldKeys, newId, length)) {
-		assert(
-			!detachEntry.value,
-			"A changeset should not have a rename and detach for the same node.",
-		);
-	}
-
-	let countProcessed = length;
-	const attachEntry = getFirstAttachField(change.crossFieldKeys, newId, countProcessed);
-	countProcessed = attachEntry.length;
-	if (attachEntry.value === undefined) {
-		const outputDetachEntry = change.rootNodes.outputDetachLocations.getFirst(
-			newId,
-			countProcessed,
-		);
-		countProcessed = outputDetachEntry.length;
-
-		const inputDetachEntry = change.rootNodes.detachLocations.getFirst(oldId, countProcessed);
-		countProcessed = inputDetachEntry.length;
-
-		addNodeRename(
-			invertedRoots,
-			newId,
-			oldId,
-			countProcessed,
-			outputDetachEntry.value ?? inputDetachEntry.value,
-		);
-	}
-
-	if (countProcessed < length) {
-		invertRename(
-			change,
-			invertedRoots,
-			offsetChangeAtomId(oldId, countProcessed),
-			offsetChangeAtomId(newId, countProcessed),
-			length - countProcessed,
-		);
-	}
-}
-
-function doesChangeAttachNodes(
-	table: CrossFieldKeyTable,
-	id: ChangeAtomId,
-	count: number,
-): RangeQueryResultFragment<boolean>[] {
-	return table
-		.getAll2({ ...id, target: CrossFieldTarget.Destination }, count)
-		.map((entry) => ({ ...entry, value: entry.value !== undefined }));
-}
-
-function doesChangeDetachNodes(
-	table: CrossFieldKeyTable,
-	id: ChangeAtomId,
-	count: number,
-): RangeQueryResultFragment<boolean>[] {
-	return table
-		.getAll2({ ...id, target: CrossFieldTarget.Source }, count)
-		.map((entry) => ({ ...entry, value: entry.value !== undefined }));
-}
-
-export function getFirstDetachField(
-	table: CrossFieldKeyTable,
-	id: ChangeAtomId,
-	count: number,
-): RangeQueryResult<FieldId | undefined> {
-	return table.getFirst({ target: CrossFieldTarget.Source, ...id }, count);
-}
-
-export function getFirstAttachField(
-	table: CrossFieldKeyTable,
-	id: ChangeAtomId,
-	count: number,
-): RangeQueryResult<FieldId | undefined> {
-	return table.getFirst({ target: CrossFieldTarget.Destination, ...id }, count);
-}
-
-export function addNodeRename(
-	table: RootNodeTable,
-	oldId: ChangeAtomId,
-	newId: ChangeAtomId,
-	count: number,
-	detachLocation: FieldId | undefined,
-): void {
-	if (areEqualChangeAtomIds(oldId, newId)) {
-		return;
-	}
-
-	for (const entry of table.oldToNewId.getAll2(oldId, count)) {
-		assert(
-			entry.value === undefined ||
-				areEqualChangeAtomIds(entry.value, offsetChangeAtomId(newId, entry.offset)),
-			"Rename collision detected",
-		);
-	}
-
-	for (const entry of table.newToOldId.getAll2(newId, count)) {
-		assert(
-			entry.value === undefined ||
-				areEqualChangeAtomIds(entry.value, offsetChangeAtomId(oldId, entry.offset)),
-			"Rename collision detected",
-		);
-	}
-
-	table.oldToNewId.set(oldId, count, newId);
-	table.newToOldId.set(newId, count, oldId);
-
-	if (detachLocation !== undefined) {
-		table.detachLocations.set(oldId, count, detachLocation);
-	}
-}
-
-/**
- * Deletes any renames from `id`.
- */
-function deleteNodeRenameFrom(roots: RootNodeTable, id: ChangeAtomId, count: number): void {
-	for (const entry of roots.oldToNewId.getAll(id, count)) {
-		deleteNodeRenameEntry(roots, entry.start, entry.value, entry.length);
-	}
-}
-
-/**
- * Deletes any renames to `id`.
- */
-function deleteNodeRenameTo(roots: RootNodeTable, id: ChangeAtomId, count: number): void {
-	for (const entry of roots.newToOldId.getAll(id, count)) {
-		deleteNodeRenameEntry(roots, entry.value, entry.start, entry.length);
-	}
-}
-
-function appendNodeRename(
-	composedTable: RootNodeTable,
-	oldId: ChangeAtomId,
-	newId: ChangeAtomId,
-	count: number,
-	change1Table: RootNodeTable,
-	detachLocation: FieldId | undefined,
-): void {
-	let countToProcess = count;
-	const rename1Entry = change1Table.newToOldId.getFirst(oldId, countToProcess);
-	countToProcess = rename1Entry.length;
-
-	if (rename1Entry.value !== undefined) {
-		deleteNodeRenameFrom(composedTable, rename1Entry.value, countToProcess);
-	}
-
-	addNodeRename(
-		composedTable,
-		rename1Entry.value ?? oldId,
-		newId,
-		countToProcess,
-		detachLocation,
-	);
-
-	tryRemoveDetachLocation(composedTable, newId, countToProcess);
-
-	if (countToProcess < count) {
-		const countRemaining = count - countToProcess;
-		appendNodeRename(
-			composedTable,
-			offsetChangeAtomId(oldId, countToProcess),
-			offsetChangeAtomId(newId, countToProcess),
-			countRemaining,
-			change1Table,
-			detachLocation,
-		);
-	}
-}
-
-function tryRemoveDetachLocation(
-	roots: RootNodeTable,
-	rootId: ChangeAtomId,
-	count: number,
-): void {
-	let countProcessed = count;
-	const renameEntry = roots.oldToNewId.getFirst(rootId, countProcessed);
-	countProcessed = renameEntry.length;
-
-	const outputDetachEntry = roots.outputDetachLocations.getFirst(rootId, countProcessed);
-	countProcessed = outputDetachEntry.length;
-
-	const nodeChangeEntry = rangeQueryChangeAtomIdMap(roots.nodeChanges, rootId, countProcessed);
-	countProcessed = nodeChangeEntry.length;
-
-	if (
-		nodeChangeEntry.value === undefined &&
-		renameEntry.value === undefined &&
-		outputDetachEntry.value === undefined
-	) {
-		roots.detachLocations.delete(rootId, countProcessed);
-	}
-
-	const countRemaining = count - countProcessed;
-	if (countRemaining > 0) {
-		tryRemoveDetachLocation(roots, offsetChangeAtomId(rootId, countProcessed), countRemaining);
-	}
-}
-
-/**
- * Deletes the entry renaming the ID range of length `count` from `oldId` to `newId`.
- * This function assumes that such an entry exists.
- */
-function deleteNodeRenameEntry(
-	roots: RootNodeTable,
-	oldId: ChangeAtomId,
-	newId: ChangeAtomId,
-	count: number,
-): void {
-	roots.oldToNewId.delete(oldId, count);
-	roots.newToOldId.delete(newId, count);
-}
-
-function replaceRootTableRevision(
-	table: RootNodeTable,
-	oldRevisions: Set<RevisionTag | undefined>,
-	newRevision: RevisionTag | undefined,
-	nodeAliases: ChangeAtomIdBTree<NodeId>,
-): RootNodeTable {
-	const oldToNewId = table.oldToNewId.mapEntries(
-		(id) => replaceAtomRevisions(id, oldRevisions, newRevision),
-		(id) => replaceAtomRevisions(id, oldRevisions, newRevision),
-	);
-
-	const newToOldId = table.newToOldId.mapEntries(
-		(id) => replaceAtomRevisions(id, oldRevisions, newRevision),
-		(id) => replaceAtomRevisions(id, oldRevisions, newRevision),
-	);
-
-	const nodeChanges: ChangeAtomIdBTree<NodeId> = newTupleBTree(
-		[...table.nodeChanges.entries()].map(([[revision, id], nodeId]) => [
-			[oldRevisions.has(revision) ? newRevision : revision, id],
-			replaceAtomRevisions(normalizeNodeId(nodeId, nodeAliases), oldRevisions, newRevision),
-		]),
-	);
-
-	const detachLocations = table.detachLocations.mapEntries(
-		(id) => replaceAtomRevisions(id, oldRevisions, newRevision),
-		(fieldId) =>
-			replaceFieldIdRevision(
-				normalizeFieldId(fieldId, nodeAliases),
-				oldRevisions,
-				newRevision,
-			),
-	);
-
-	const outputDetachLocations = table.outputDetachLocations.mapEntries(
-		(id) => replaceAtomRevisions(id, oldRevisions, newRevision),
-		(fieldId) =>
-			replaceFieldIdRevision(
-				normalizeFieldId(fieldId, nodeAliases),
-				oldRevisions,
-				newRevision,
-			),
-	);
-
-	return { oldToNewId, newToOldId, nodeChanges, detachLocations, outputDetachLocations };
-}
-
-function newDetachedEntryMap(): ChangeAtomIdRangeMap<DetachedNodeEntry> {
-	return new RangeMap(offsetChangeAtomId, subtractChangeAtomIds, offsetDetachedNodeEntry);
-}
-
-function offsetDetachedNodeEntry(entry: DetachedNodeEntry, count: number): DetachedNodeEntry {
-	assert(
-		count <= 1 || entry.nodeChange === undefined,
-		"Cannot split an entry with a node change",
-	);
-
-	return entry.detachId !== undefined
-		? { ...entry, detachId: offsetChangeAtomId(entry.detachId, count) }
-		: entry;
-}
-
-function getFieldsWithRootMoves(
-	roots: RootNodeTable,
-	nodeAliases: ChangeAtomIdBTree<NodeId>,
-): TupleBTree<FieldIdKey, boolean> {
-	const fields: TupleBTree<FieldIdKey, boolean> = newTupleBTree();
-	for (const { start: rootId, value: fieldId, length } of roots.detachLocations.entries()) {
-		let isRootMoved = false;
-		for (const renameEntry of roots.oldToNewId.getAll2(rootId, length)) {
-			if (renameEntry.value !== undefined) {
-				isRootMoved = true;
-			}
-		}
-
-		for (const outputDetachEntry of roots.outputDetachLocations.getAll2(rootId, length)) {
-			if (outputDetachEntry.value !== undefined) {
-				isRootMoved = true;
-			}
-		}
-
-		if (isRootMoved) {
-			fields.set(fieldIdKeyFromFieldId(normalizeFieldId(fieldId, nodeAliases)), true);
-		}
-	}
-
-	return fields;
-}
-
-function getFieldToRootChanges(
-	roots: RootNodeTable,
-	nodeAliases: ChangeAtomIdBTree<NodeId>,
-): TupleBTree<FieldIdKey, ChangeAtomId[]> {
-	const fields: TupleBTree<FieldIdKey, ChangeAtomId[]> = newTupleBTree();
-	for (const rootIdKey of roots.nodeChanges.keys()) {
-		const rootId: ChangeAtomId = { revision: rootIdKey[0], localId: rootIdKey[1] };
-		const detachLocation = roots.detachLocations.getFirst(rootId, 1).value;
-		if (detachLocation !== undefined) {
-			const fieldIdKey = fieldIdKeyFromFieldId(normalizeFieldId(detachLocation, nodeAliases));
-			let rootsInField = fields.get(fieldIdKey);
-			if (rootsInField === undefined) {
-				rootsInField = [];
-				fields.set(fieldIdKey, rootsInField);
-			}
-
-			rootsInField.push(rootId);
-		}
-	}
-
-	return fields;
-}
-
-function muteRootChanges(roots: RootNodeTable): RootNodeTable {
-	return {
-		oldToNewId: newChangeAtomIdTransform(),
-		newToOldId: newChangeAtomIdTransform(),
-		nodeChanges: brand(roots.nodeChanges.clone()),
-		detachLocations: roots.detachLocations.clone(),
-		outputDetachLocations: newChangeAtomIdRangeMap(),
-	};
-}