@fluidframework/tree 2.74.0 → 2.81.0-374083

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,24 +27,30 @@ 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,
@@ -55,14 +66,19 @@ import {
 	type TupleBTree,
 	RangeMap,
 	balancedReduce,
+	type RangeQueryEntry,
+	type RangeQueryResultFragment,
 } from "../../util/index.js";
 import type { TreeChunk } from "../chunked-forest/index.js";
 
 import {
-	type CrossFieldManager,
+	type ComposeNodeManager,
 	type CrossFieldMap,
 	CrossFieldTarget,
-	getFirstFromCrossFieldMap,
+	type DetachedNodeEntry,
+	type InvertNodeManager,
+	type RebaseDetachedNodeEntry,
+	type RebaseNodeManager,
 	setInCrossFieldMap,
 } from "./crossFieldQueries.js";
 import {
@@ -73,20 +89,31 @@ import {
 import { convertGenericChange, genericFieldKind } from "./genericFieldKind.js";
 import type { GenericChangeset } from "./genericFieldKindTypes.js";
 import {
-	type ChangeAtomIdBTree,
 	type CrossFieldKey,
 	type CrossFieldKeyRange,
 	type CrossFieldKeyTable,
+	type CrossFieldRangeTable,
 	type FieldChange,
 	type FieldChangeMap,
 	type FieldChangeset,
 	type FieldId,
 	type ModularChangeset,
-	newCrossFieldKeyTable,
+	newCrossFieldRangeTable,
+	type NoChangeConstraint,
 	type NodeChangeset,
 	type NodeId,
+	type NodeLocation,
+	type RebaseVersion,
+	type RootNodeTable,
 } from "./modularChangeTypes.js";
 import type { FlexFieldKind } from "./fieldKind.js";
+import { lt } from "semver-ts";
+import {
+	getFromChangeAtomIdMap,
+	rangeQueryChangeAtomIdMap,
+	setInChangeAtomIdMap,
+	type ChangeAtomIdBTree,
+} from "../changeAtomIdBTree.js";
 
 /**
  * Implementation of ChangeFamily which delegates work in a given field to the appropriate FieldKind
@@ -104,6 +131,7 @@ export class ModularChangeFamily
 	public constructor(
 		fieldKinds: ReadonlyMap<FieldKindIdentifier, FlexFieldKind>,
 		public readonly codecs: ICodecFamily<ModularChangeset, ChangeEncodingContext>,
+		public readonly codecOptions: CodecWriteOptions,
 	) {
 		this.fieldKinds = fieldKinds;
 	}
@@ -130,9 +158,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
@@ -171,14 +199,14 @@ export class ModularChangeFamily
 	}
 
 	public compose(changes: TaggedChange<ModularChangeset>[]): ModularChangeset {
-		const { revInfos, maxId } = getRevInfoFromTaggedChanges(changes);
+		const { maxId } = getRevInfoFromTaggedChanges(changes);
 		const idState: IdAllocationState = { maxId };
 
 		const pairwiseDelegate = (
 			left: ModularChangeset,
 			right: ModularChangeset,
 		): ModularChangeset => {
-			return this.composePair(left, right, revInfos, idState);
+			return this.composePair(left, right, idState);
 		};
 
 		const innerChanges = changes.map((change) => change.change);
@@ -188,10 +216,11 @@ export class ModularChangeFamily
 	private composePair(
 		change1: ModularChangeset,
 		change2: ModularChangeset,
-		revInfos: RevisionInfo[],
 		idState: IdAllocationState,
 	): ModularChangeset {
-		const { fieldChanges, nodeChanges, nodeToParent, nodeAliases, crossFieldKeys } =
+		const revInfos = composeRevInfos(change1.revisions, change2.revisions);
+
+		const { fieldChanges, nodeChanges, nodeToParent, nodeAliases, crossFieldKeys, rootNodes } =
 			this.composeAllFields(change1, change2, revInfos, idState);
 
 		const { allBuilds, allDestroys, allRefreshers } = composeBuildsDestroysAndRefreshers(
@@ -199,7 +228,12 @@ export class ModularChangeFamily
 			change2,
 		);
 
-		return 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;
+
+		const composed = makeModularChangeset({
 			fieldChanges,
 			nodeChanges,
 			nodeToParent,
@@ -207,16 +241,23 @@ export class ModularChangeFamily
 			crossFieldKeys,
 			maxId: idState.maxId,
 			revisions: revInfos,
+			rootNodes,
 			builds: allBuilds,
 			destroys: allDestroys,
 			refreshers: allRefreshers,
+			noChangeConstraint,
+			noChangeConstraintOnRevert,
 		});
+
+		// XXX: This is an expensive assert which should be disabled before merging.
+		validateChangeset(composed, this.fieldKinds);
+		return composed;
 	}
 
 	private composeAllFields(
 		potentiallyConflictedChange1: ModularChangeset,
 		potentiallyConflictedChange2: ModularChangeset,
-		revInfos: RevisionInfo[],
+		revInfos: readonly RevisionInfo[],
 		idState: IdAllocationState,
 	): ModularChangesetContent {
 		// Our current cell ordering scheme in sequences depends on being able to rebase over a change with conflicts.
@@ -240,14 +281,38 @@ export class ModularChangeFamily
 			mergeTupleBTrees(change1.nodeChanges, change2.nodeChanges),
 		);
 
-		const composedNodeToParent: ChangeAtomIdBTree<FieldId> = brand(
+		const composedNodeToParent: ChangeAtomIdBTree<NodeLocation> = brand(
 			mergeTupleBTrees(change1.nodeToParent, change2.nodeToParent),
 		);
 		const composedNodeAliases: ChangeAtomIdBTree<NodeId> = brand(
 			mergeTupleBTrees(change1.nodeAliases, change2.nodeAliases),
 		);
 
-		const crossFieldTable = newComposeTable(change1, change2, composedNodeToParent);
+		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 composedFields = this.composeFieldMaps(
 			change1.fieldChanges,
@@ -268,17 +333,32 @@ export class ModularChangeFamily
 			revisionMetadata,
 		);
 
-		// 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,
-		);
+		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);
+			}
+		}
+
 		return {
 			fieldChanges: composedFields,
 			nodeChanges: composedNodeChanges,
 			nodeToParent: composedNodeToParent,
 			nodeAliases: composedNodeAliases,
-			crossFieldKeys: composedCrossFieldKeys,
+			crossFieldKeys: composeCrossFieldKeyTables(
+				change1.crossFieldKeys,
+				change2.crossFieldKeys,
+				crossFieldTable.movedCrossFieldKeys,
+				crossFieldTable.removedCrossFieldKeys,
+			),
+			rootNodes: composedRoots,
 		};
 	}
 
@@ -290,17 +370,16 @@ export class ModularChangeFamily
 	): void {
 		const context = crossFieldTable.fieldToContext.get(fieldChange);
 		assert(context !== undefined, 0x8cc /* Should have context for every invalidated field */);
-		const { fieldId, change1: fieldChange1, change2: fieldChange2, composedChange } = context;
+		const { change1: fieldChange1, change2: fieldChange2, composedChange } = context;
+
+		crossFieldTable.pendingCompositions.affectedBaseFields.delete(
+			fieldIdKeyFromFieldId(context.fieldId),
+		);
 
 		const rebaser = getChangeHandler(this.fieldKinds, composedChange.fieldKind).rebaser;
 		const composeNodes = (child1: NodeId | undefined, child2: NodeId | undefined): NodeId => {
-			if (
-				child1 !== undefined &&
-				child2 !== undefined &&
-				getFromChangeAtomIdMap(crossFieldTable.newToBaseNodeId, child2) === undefined
-			) {
-				setInChangeAtomIdMap(crossFieldTable.newToBaseNodeId, child2, child1);
-				crossFieldTable.pendingCompositions.nodeIdsToCompose.push([child1, child2]);
+			if (child1 !== undefined && child2 !== undefined) {
+				addNodesToCompose(crossFieldTable, child1, child2);
 			}
 
 			return child1 ?? child2 ?? fail(0xb22 /* Should not compose two undefined nodes */);
@@ -311,7 +390,7 @@ export class ModularChangeFamily
 			fieldChange2,
 			composeNodes,
 			genId,
-			new ComposeManager(crossFieldTable, fieldChange, fieldId, false),
+			new ComposeNodeManagerI(crossFieldTable, context.fieldId, false),
 			revisionMetadata,
 		);
 		composedChange.change = brand(amendedChange);
@@ -323,7 +402,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` and `affectedNewFields`)
+	 * (`affectedBaseFields`)
 	 *
 	 * Updating an element may invalidate further elements. This function runs until there is no more invalidation.
 	 */
@@ -331,72 +410,59 @@ export class ModularChangeFamily
 		table: ComposeTable,
 		composedFields: FieldChangeMap,
 		composedNodes: ChangeAtomIdBTree<NodeChangeset>,
-		composedNodeToParent: ChangeAtomIdBTree<FieldId>,
+		composedNodeToParent: ChangeAtomIdBTree<NodeLocation>,
 		nodeAliases: ChangeAtomIdBTree<NodeId>,
 		genId: IdAllocator,
 		metadata: RevisionMetadataSource,
 	): void {
 		const pending = table.pendingCompositions;
-		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(
+		while (pending.nodeIdsToCompose.length > 0 || pending.affectedBaseFields.length > 0) {
+			this.processPendingNodeCompositions(
 				table,
-				table.baseChange,
-				true,
-				pending.affectedBaseFields,
-				composedFields,
 				composedNodes,
+				composedNodeToParent,
+				nodeAliases,
 				genId,
 				metadata,
 			);
 
 			this.composeAffectedFields(
 				table,
-				table.newChange,
-				false,
-				pending.affectedNewFields,
+				table.baseChange,
+				pending.affectedBaseFields,
 				composedFields,
 				composedNodes,
 				genId,
 				metadata,
 			);
-
-			this.processInvalidatedCompositions(table, genId, metadata);
 		}
 	}
 
-	private processInvalidatedCompositions(
+	private processPendingNodeCompositions(
 		table: ComposeTable,
+		composedNodes: ChangeAtomIdBTree<NodeChangeset>,
+		composedNodeToParent: ChangeAtomIdBTree<NodeLocation>,
+		nodeAliases: ChangeAtomIdBTree<NodeId>,
 		genId: IdAllocator,
 		metadata: RevisionMetadataSource,
 	): void {
-		const fieldsToUpdate = table.invalidatedFields;
-		table.invalidatedFields = new Set();
-		for (const fieldChange of fieldsToUpdate) {
-			this.composeInvalidatedField(fieldChange, table, genId, metadata);
+		// 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,
+			);
 		}
+
+		table.pendingCompositions.nodeIdsToCompose.length = 0;
 	}
 
 	/**
@@ -413,63 +479,79 @@ 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 {
-		for (const fieldIdKey of affectedFields.keys()) {
-			const fieldId = normalizeFieldId(fieldIdFromFieldIdKey(fieldIdKey), change.nodeAliases);
-			const fieldChange = fieldChangeFromId(change.fieldChanges, change.nodeChanges, fieldId);
+		const fieldsToProcess = affectedFields.clone();
+		affectedFields.clear();
+
+		for (const fieldIdKey of fieldsToProcess.keys()) {
+			const fieldId = fieldIdFromFieldIdKey(fieldIdKey);
+			const fieldChange = fieldChangeFromId(change, fieldId);
 
 			if (
 				table.fieldToContext.has(fieldChange) ||
 				table.newFieldToBaseField.has(fieldChange)
 			) {
-				// 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;
+				this.composeInvalidatedField(fieldChange, table, genId, metadata);
+			} else {
+				this.composeFieldWithNoNewChange(
+					table,
+					fieldChange,
+					fieldId,
+					composedFields,
+					composedNodes,
+					genId,
+					metadata,
+				);
 			}
+		}
+	}
 
-			const emptyChange = this.createEmptyFieldChange(fieldChange.fieldKind);
-			const [change1, change2] = areBaseFields
-				? [fieldChange, emptyChange]
-				: [emptyChange, fieldChange];
-
-			const composedField = this.composeFieldChanges(
-				fieldId,
-				change1,
-				change2,
-				genId,
-				table,
-				metadata,
-			);
+	private composeFieldWithNoNewChange(
+		table: ComposeTable,
+		baseFieldChange: FieldChange,
+		fieldId: FieldId,
+		composedFields: FieldChangeMap,
+		composedNodes: ChangeAtomIdBTree<NodeChangeset>,
+		genId: IdAllocator,
+		metadata: RevisionMetadataSource,
+	): void {
+		const emptyChange = this.createEmptyFieldChange(baseFieldChange.fieldKind);
 
-			if (fieldId.nodeId === undefined) {
-				composedFields.set(fieldId.field, composedField);
-				continue;
-			}
+		const composedField = this.composeFieldChanges(
+			fieldId,
+			baseFieldChange,
+			emptyChange,
+			genId,
+			table,
+			metadata,
+		);
 
-			const nodeId =
-				getFromChangeAtomIdMap(table.newToBaseNodeId, fieldId.nodeId) ?? fieldId.nodeId;
+		if (fieldId.nodeId === undefined) {
+			composedFields.set(fieldId.field, composedField);
+			return;
+		}
 
-			let nodeChangeset = nodeChangeFromId(composedNodes, nodeId);
-			if (!table.composedNodes.has(nodeChangeset)) {
-				nodeChangeset = cloneNodeChangeset(nodeChangeset);
-				setInChangeAtomIdMap(composedNodes, nodeId, nodeChangeset);
-			}
+		const nodeId = normalizeNodeId(
+			getFromChangeAtomIdMap(table.newToBaseNodeId, fieldId.nodeId) ?? fieldId.nodeId,
+			table.baseChange.nodeAliases,
+		);
 
-			if (nodeChangeset.fieldChanges === undefined) {
-				nodeChangeset.fieldChanges = new Map();
-			}
+		// 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);
 
-			nodeChangeset.fieldChanges.set(fieldId.field, composedField);
+		if (nodeChangeset.fieldChanges === undefined) {
+			nodeChangeset.fieldChanges = new Map();
 		}
 
-		affectedFields.clear();
+		nodeChangeset.fieldChanges.set(fieldId.field, composedField);
 	}
 
 	private composeFieldMaps(
@@ -488,17 +570,29 @@ 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);
 		}
@@ -519,7 +613,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 either `affectedBaseFields` or `affectedNewFields` in `crossFieldTable.pendingCompositions`.
+	 * will be added to `affectedBaseFields` in `crossFieldTable.pendingCompositions`.
 	 *
 	 * Any composed `FieldChange` which is invalidated by new cross-field information will be added to `crossFieldTable.invalidatedFields`.
 	 */
@@ -538,15 +632,14 @@ export class ModularChangeFamily
 			change2: change2Normalized,
 		} = this.normalizeFieldChanges(change1, change2);
 
-		const manager = new ComposeManager(crossFieldTable, change1, fieldId);
+		const manager = new ComposeNodeManagerI(crossFieldTable, fieldId);
 
 		const composedChange = changeHandler.rebaser.compose(
 			change1Normalized,
 			change2Normalized,
 			(child1, child2) => {
 				if (child1 !== undefined && child2 !== undefined) {
-					setInChangeAtomIdMap(crossFieldTable.newToBaseNodeId, child2, child1);
-					crossFieldTable.pendingCompositions.nodeIdsToCompose.push([child1, child2]);
+					addNodesToCompose(crossFieldTable, child1, child2);
 				}
 				return child1 ?? child2 ?? fail(0xb23 /* Should not compose two undefined nodes */);
 			},
@@ -572,19 +665,19 @@ export class ModularChangeFamily
 	}
 
 	private composeNodesById(
-		nodeChanges1: ChangeAtomIdBTree<NodeChangeset>,
-		nodeChanges2: ChangeAtomIdBTree<NodeChangeset>,
+		change1: ModularChangeset,
+		change2: ModularChangeset,
 		composedNodes: ChangeAtomIdBTree<NodeChangeset>,
-		composedNodeToParent: ChangeAtomIdBTree<FieldId>,
-		nodeAliases: ChangeAtomIdBTree<NodeId>,
+		composedNodeToParent: ChangeAtomIdBTree<NodeLocation>,
+		composedAliases: ChangeAtomIdBTree<NodeId>,
 		id1: NodeId,
 		id2: NodeId,
 		idAllocator: IdAllocator,
 		crossFieldTable: ComposeTable,
 		revisionMetadata: RevisionMetadataSource,
 	): void {
-		const nodeChangeset1 = nodeChangeFromId(nodeChanges1, id1);
-		const nodeChangeset2 = nodeChangeFromId(nodeChanges2, id2);
+		const nodeChangeset1 = nodeChangeFromId(change1.nodeChanges, change1.nodeAliases, id1);
+		const nodeChangeset2 = nodeChangeFromId(change2.nodeChanges, change2.nodeAliases, id2);
 		const composedNodeChangeset = this.composeNodeChanges(
 			id1,
 			nodeChangeset1,
@@ -599,13 +692,11 @@ export class ModularChangeFamily
 		if (!areEqualChangeAtomIds(id1, id2)) {
 			composedNodes.delete([id2.revision, id2.localId]);
 			composedNodeToParent.delete([id2.revision, id2.localId]);
-			setInChangeAtomIdMap(nodeAliases, id2, id1);
+			setInChangeAtomIdMap(composedAliases, id2, id1);
 
 			// We need to delete id1 to avoid forming a cycle in case id1 already had an alias.
-			nodeAliases.delete([id1.revision, id1.localId]);
+			composedAliases.delete([id1.revision, id1.localId]);
 		}
-
-		crossFieldTable.composedNodes.add(composedNodeChangeset);
 	}
 
 	private composeNodeChanges(
@@ -640,7 +731,7 @@ export class ModularChangeFamily
 			revisionMetadata,
 		);
 
-		const composedNodeChange: NodeChangeset = {};
+		const composedNodeChange: Mutable<NodeChangeset> = {};
 
 		if (composedFieldChanges.size > 0) {
 			composedNodeChange.fieldChanges = composedFieldChanges;
@@ -660,8 +751,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>,
@@ -681,6 +772,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,
@@ -692,9 +786,14 @@ export class ModularChangeFamily
 		const genId: IdAllocator = idAllocatorFromMaxId(change.change.maxId ?? -1);
 
 		const crossFieldTable: InvertTable = {
-			...newCrossFieldTable<FieldChange>(),
+			change: change.change,
+			entries: newChangeAtomIdRangeMap(),
 			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);
@@ -735,7 +834,7 @@ export class ModularChangeFamily
 					context !== undefined,
 					0x851 /* Should have context for every invalidated field */,
 				);
-				const { invertedField, fieldId } = context;
+				const { invertedField } = context;
 
 				const amendedChange = getChangeHandler(
 					this.fieldKinds,
@@ -745,7 +844,7 @@ export class ModularChangeFamily
 					isRollback,
 					genId,
 					revisionForInvert,
-					new InvertManager(crossFieldTable, fieldChange, fieldId),
+					new InvertNodeManagerI(crossFieldTable, context.fieldId),
 					revisionMetadata,
 				);
 				invertedField.change = brand(amendedChange);
@@ -754,16 +853,21 @@ 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,
 		});
 	}
@@ -781,7 +885,7 @@ export class ModularChangeFamily
 
 		for (const [field, fieldChange] of changes) {
 			const fieldId = { nodeId: parentId, field };
-			const manager = new InvertManager(crossFieldTable, fieldChange, fieldId);
+			const manager = new InvertNodeManagerI(crossFieldTable, fieldId);
 			const invertedChange = getChangeHandler(
 				this.fieldKinds,
 				fieldChange.fieldKind,
@@ -818,7 +922,7 @@ export class ModularChangeFamily
 		revisionMetadata: RevisionMetadataSource,
 		revisionForInvert: RevisionTag,
 	): NodeChangeset {
-		const inverse: NodeChangeset = {};
+		const inverse: Mutable<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.
@@ -848,6 +952,17 @@ 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>,
@@ -867,17 +982,41 @@ 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 = {
-			...newCrossFieldTable<FieldChange>(),
+			rebaseVersion,
+			entries: newDetachedEntryMap(),
 			newChange: change,
 			baseChange: over.change,
 			baseFieldToContext: new Map(),
+			baseRoots: over.change.rootNodes,
+			rebasedRootNodes,
 			baseToRebasedNodeId: newTupleBTree(),
 			rebasedFields: new Set(),
-			rebasedNodeToParent: brand(change.nodeToParent.clone()),
-			rebasedCrossFieldKeys: change.crossFieldKeys.clone(),
+			rebasedNodeToParent,
+			rebasedDetachLocations: newChangeAtomIdRangeMap(),
+			movedDetaches: newChangeAtomIdRangeMap(),
 			nodeIdPairs: [],
-			affectedBaseFields: newTupleBTree(),
+			affectedBaseFields,
 			fieldsWithUnattachedChild: new Set(),
 		};
 
@@ -893,13 +1032,14 @@ export class ModularChangeFamily
 		const rebasedNodes: ChangeAtomIdBTree<NodeChangeset> = brand(change.nodeChanges.clone());
 
 		const rebasedFields = this.rebaseIntersectingFields(
+			nodesToRebase,
 			crossFieldTable,
 			rebasedNodes,
 			genId,
 			rebaseMetadata,
 		);
 
-		this.rebaseInvalidatedElements(
+		this.rebaseInvalidatedFields(
 			rebasedFields,
 			rebasedNodes,
 			crossFieldTable,
@@ -907,40 +1047,86 @@ export class ModularChangeFamily
 			genId,
 		);
 
+		fixupRebasedDetachLocations(crossFieldTable);
+
 		const constraintState = newConstraintState(change.constraintViolationCount ?? 0);
 		const revertConstraintState = newConstraintState(
 			change.constraintViolationCountOnRevert ?? 0,
 		);
-		this.updateConstraintsForFields(
+
+		let noChangeConstraint = change.noChangeConstraint;
+		if (noChangeConstraint !== undefined && !noChangeConstraint.violated) {
+			noChangeConstraint = { violated: true };
+			constraintState.violationCount += 1;
+		}
+
+		this.updateConstraints(
 			rebasedFields,
-			NodeAttachState.Attached,
-			NodeAttachState.Attached,
+			rebasedNodes,
+			rebasedRootNodes,
 			constraintState,
 			revertConstraintState,
-			rebasedNodes,
+		);
+
+		const fieldsWithRootMoves = getFieldsWithRootMoves(
+			crossFieldTable.rebasedRootNodes,
+			change.nodeAliases,
+		);
+
+		const fieldToRootChanges = getFieldToRootChanges(
+			crossFieldTable.rebasedRootNodes,
+			change.nodeAliases,
 		);
 
 		const rebased = makeModularChangeset({
-			fieldChanges: this.pruneFieldMap(rebasedFields, rebasedNodes),
+			fieldChanges: this.pruneFieldMap(
+				rebasedFields,
+				undefined,
+				rebasedNodes,
+				crossFieldTable.rebasedNodeToParent,
+				change.nodeAliases,
+				crossFieldTable.rebasedRootNodes,
+				fieldsWithRootMoves,
+				fieldToRootChanges,
+			),
 			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: crossFieldTable.rebasedCrossFieldKeys,
+			crossFieldKeys: rebaseCrossFieldKeys(
+				change.crossFieldKeys,
+				crossFieldTable.movedDetaches,
+				crossFieldTable.rebasedDetachLocations,
+			),
 			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.
+		validateChangeset(rebased, this.fieldKinds);
 		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,
@@ -957,6 +1143,18 @@ 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) {
@@ -974,146 +1172,150 @@ export class ModularChangeFamily
 		return rebasedFields;
 	}
 
-	// This processes fields which have no new changes but have been invalidated by another field.
-	private rebaseFieldsWithoutNewChanges(
+	private rebaseFieldWithoutNewChanges(
+		baseFieldChange: FieldChange,
+		baseFieldId: FieldId,
+		crossFieldTable: RebaseTable,
 		rebasedFields: FieldChangeMap,
 		rebasedNodes: ChangeAtomIdBTree<NodeChangeset>,
-		crossFieldTable: RebaseTable,
 		genId: IdAllocator,
 		metadata: RebaseRevisionMetadata,
-	): void {
-		const baseChange = crossFieldTable.baseChange;
-		for (const [revision, localId, fieldKey] of crossFieldTable.affectedBaseFields.keys()) {
-			const baseNodeId =
-				localId !== undefined
-					? normalizeNodeId({ revision, localId }, baseChange.nodeAliases)
-					: undefined;
-
-			const baseFieldChange = fieldMapFromNodeId(
-				baseChange.fieldChanges,
-				baseChange.nodeChanges,
-				baseNodeId,
-			).get(fieldKey);
 
-			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;
+		/**
+		 * 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;
 			}
 
-			// 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;
-			};
+			return areEqualChangeAtomIds(
+				normalizeNodeId(baseChild, crossFieldTable.baseChange.nodeAliases),
+				baseNodeId,
+			)
+				? baseNodeId
+				: undefined;
+		};
 
-			const handler = getChangeHandler(this.fieldKinds, baseFieldChange.fieldKind);
-			const fieldChange: FieldChange = {
-				...baseFieldChange,
-				change: brand(handler.createEmpty()),
-			};
+		const handler = getChangeHandler(this.fieldKinds, baseFieldChange.fieldKind);
+		const fieldChange: FieldChange = {
+			...baseFieldChange,
+			change: brand(handler.createEmpty()),
+		};
 
-			const rebasedNodeId =
-				baseNodeId !== undefined
-					? rebasedNodeIdFromBaseNodeId(crossFieldTable, baseNodeId)
-					: undefined;
+		const rebasedNodeId =
+			baseFieldId.nodeId === undefined
+				? undefined
+				: rebasedNodeIdFromBaseNodeId(crossFieldTable, baseFieldId.nodeId);
 
-			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,
-			);
+		const fieldId: FieldId = { nodeId: rebasedNodeId, field: baseFieldId.field };
 
-			const rebasedFieldChange: FieldChange = {
-				...baseFieldChange,
-				change: brand(rebasedField),
-			};
+		const rebasedField: unknown = handler.rebaser.rebase(
+			fieldChange.change,
+			baseFieldChange.change,
+			rebaseChild,
+			genId,
+			new RebaseNodeManagerI(crossFieldTable, fieldId),
+			metadata,
+			crossFieldTable.rebaseVersion,
+		);
 
-			// TODO: Deduplicate
-			crossFieldTable.baseFieldToContext.set(baseFieldChange, {
-				newChange: fieldChange,
-				baseChange: baseFieldChange,
-				rebasedChange: rebasedFieldChange,
-				fieldId,
-				baseNodeIds: [],
-			});
-			crossFieldTable.rebasedFields.add(rebasedFieldChange);
+		const rebasedFieldChange: FieldChange = {
+			...baseFieldChange,
+			change: brand(rebasedField),
+		};
 
-			this.attachRebasedField(
-				rebasedFields,
-				rebasedNodes,
-				crossFieldTable,
-				rebasedFieldChange,
-				fieldId,
-				genId,
-				metadata,
-			);
+		const context: RebaseFieldContext = {
+			newChange: fieldChange,
+			baseChange: baseFieldChange,
+			rebasedChange: rebasedFieldChange,
+			fieldId,
+			baseNodeIds: newTupleBTree(),
+		};
+
+		if (baseNodeId !== undefined) {
+			setInChangeAtomIdMap(context.baseNodeIds, baseNodeId, true);
 		}
-	}
 
-	private rebaseInvalidatedElements(
-		rebasedFields: FieldChangeMap,
-		rebasedNodes: ChangeAtomIdBTree<NodeChangeset>,
-		table: RebaseTable,
-		metadata: RebaseRevisionMetadata,
-		idAllocator: IdAllocator,
-	): void {
-		this.rebaseFieldsWithoutNewChanges(
+		crossFieldTable.baseFieldToContext.set(baseFieldChange, context);
+
+		crossFieldTable.rebasedFields.add(rebasedFieldChange);
+
+		this.attachRebasedField(
 			rebasedFields,
 			rebasedNodes,
-			table,
-			idAllocator,
+			crossFieldTable,
+			rebasedFieldChange,
+			fieldId,
+			genId,
 			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 {
-		const fieldsToUpdate = crossFieldTable.invalidatedFields;
-		crossFieldTable.invalidatedFields = new Set();
-		for (const field of fieldsToUpdate) {
-			this.rebaseInvalidatedField(field, crossFieldTable, rebaseMetadata, genId);
-		}
-	}
+		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,
+				);
 
-	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);
+				const baseField = fieldChangeFromId(crossFieldTable.baseChange, baseFieldId);
+
+				assert(
+					baseField !== undefined,
+					0x9c2 /* Cross field key registered for empty field */,
+				);
+
+				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 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,
@@ -1128,25 +1330,28 @@ export class ModularChangeFamily
 				return curr;
 			}
 
-			if (base !== undefined) {
-				for (const id of context.baseNodeIds) {
-					if (areEqualChangeAtomIds(base, id)) {
-						return base;
-					}
-				}
+			if (base !== undefined && getFromChangeAtomIdMap(context.baseNodeIds, base) === true) {
+				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 RebaseManager(crossFieldTable, baseField, context.fieldId, allowInval),
+				new RebaseNodeManagerI(crossFieldTable, context.fieldId, allowInval),
 				rebaseMetadata,
+				crossFieldTable.rebaseVersion,
 			),
 		);
 	}
@@ -1166,14 +1371,20 @@ export class ModularChangeFamily
 		}
 		const rebasedNode = getFromChangeAtomIdMap(rebasedNodes, nodeId);
 		if (rebasedNode !== undefined) {
-			if (rebasedNode.fieldChanges === undefined) {
-				rebasedNode.fieldChanges = new Map([[fieldKey, rebasedField]]);
+			const updatedRebasedNode: Mutable<NodeChangeset> = cloneNodeChangeset(rebasedNode);
+			setInChangeAtomIdMap(rebasedNodes, nodeId, updatedRebasedNode);
+
+			if (updatedRebasedNode.fieldChanges === undefined) {
+				updatedRebasedNode.fieldChanges = new Map([[fieldKey, rebasedField]]);
 				return;
 			}
 
-			assert(!rebasedNode.fieldChanges.has(fieldKey), 0x9c4 /* Expected an empty field */);
-			rebasedNode.fieldChanges.set(fieldKey, rebasedField);
-			return;
+			assert(
+				!updatedRebasedNode.fieldChanges.has(fieldKey),
+				0x9c4 /* Expected an empty field */,
+			);
+			updatedRebasedNode.fieldChanges.set(fieldKey, rebasedField);
+			return;
 		}
 
 		const newNode: NodeChangeset = {
@@ -1183,14 +1394,14 @@ export class ModularChangeFamily
 		setInChangeAtomIdMap(rebasedNodes, nodeId, newNode);
 		setInChangeAtomIdMap(table.baseToRebasedNodeId, nodeId, nodeId);
 
-		const parentFieldId = getParentFieldId(table.baseChange, nodeId);
+		const parentBase = getNodeParent(table.baseChange, nodeId);
 
 		this.attachRebasedNode(
 			rebasedFields,
 			rebasedNodes,
 			table,
 			nodeId,
-			parentFieldId,
+			parentBase,
 			idAllocator,
 			metadata,
 		);
@@ -1201,65 +1412,100 @@ export class ModularChangeFamily
 		rebasedNodes: ChangeAtomIdBTree<NodeChangeset>,
 		table: RebaseTable,
 		baseNodeId: NodeId,
-		parentFieldIdBase: FieldId,
+		parentBase: NodeLocation,
 		idAllocator: IdAllocator,
 		metadata: RebaseRevisionMetadata,
 	): void {
-		const baseFieldChange = fieldChangeFromId(
-			table.baseChange.fieldChanges,
-			table.baseChange.nodeChanges,
-			parentFieldIdBase,
-		);
+		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) {
+				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);
+				}
+			} else {
+				// 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,
+				);
+			}
+
+			return;
+		}
+
+		const parentFieldIdBase = parentBase.field;
+		const baseFieldChange = fieldChangeFromId(table.baseChange, parentFieldIdBase);
 
 		const rebasedFieldId = rebasedFieldIdFromBaseId(table, parentFieldIdBase);
-		setInChangeAtomIdMap(table.rebasedNodeToParent, baseNodeId, rebasedFieldId);
+		setInChangeAtomIdMap(table.rebasedNodeToParent, baseNodeId, { field: rebasedFieldId });
 
 		const context = table.baseFieldToContext.get(baseFieldChange);
 		if (context !== undefined) {
 			// We've already processed this field.
-			// The new child node will be attached in rebaseFieldsWithUnattachedChild.
-			context.baseNodeIds.push(baseNodeId);
-			table.fieldsWithUnattachedChild.add(baseFieldChange);
+			// 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);
+			}
 			return;
 		}
 
-		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(
+		this.rebaseFieldWithoutNewChanges(
+			baseFieldChange,
+			parentFieldIdBase,
+			table,
 			rebasedFields,
 			rebasedNodes,
-			table,
-			rebasedField,
-			rebasedFieldId,
 			idAllocator,
 			metadata,
+			baseNodeId,
 		);
 	}
 
@@ -1298,7 +1544,7 @@ export class ModularChangeFamily
 				change2: baseChangeset,
 			} = this.normalizeFieldChanges(fieldChange, baseChange);
 
-			const manager = new RebaseManager(crossFieldTable, baseChange, fieldId);
+			const manager = new RebaseNodeManagerI(crossFieldTable, fieldId);
 
 			const rebasedField = changeHandler.rebaser.rebase(
 				fieldChangeset,
@@ -1307,6 +1553,7 @@ export class ModularChangeFamily
 				genId,
 				manager,
 				revisionMetadata,
+				crossFieldTable.rebaseVersion,
 			);
 
 			const rebasedFieldChange: FieldChange = {
@@ -1321,7 +1568,7 @@ export class ModularChangeFamily
 				newChange: fieldChange,
 				rebasedChange: rebasedFieldChange,
 				fieldId,
-				baseNodeIds: [],
+				baseNodeIds: newTupleBTree(),
 			});
 
 			crossFieldTable.rebasedFields.add(rebasedFieldChange);
@@ -1337,8 +1584,16 @@ export class ModularChangeFamily
 		crossFieldTable: RebaseTable,
 		revisionMetadata: RebaseRevisionMetadata,
 	): NodeChangeset {
-		const change = nodeChangeFromId(crossFieldTable.newChange.nodeChanges, newId);
-		const over = nodeChangeFromId(crossFieldTable.baseChange.nodeChanges, baseId);
+		const change = nodeChangeFromId(
+			crossFieldTable.newChange.nodeChanges,
+			crossFieldTable.newChange.nodeAliases,
+			newId,
+		);
+		const over = nodeChangeFromId(
+			crossFieldTable.baseChange.nodeChanges,
+			crossFieldTable.baseChange.nodeAliases,
+			baseId,
+		);
 
 		const baseMap: FieldChangeMap = over?.fieldChanges ?? new Map();
 
@@ -1354,7 +1609,7 @@ export class ModularChangeFamily
 					)
 				: change.fieldChanges;
 
-		const rebasedChange: NodeChangeset = {};
+		const rebasedChange: Mutable<NodeChangeset> = {};
 
 		if (fieldChanges !== undefined && fieldChanges.size > 0) {
 			rebasedChange.fieldChanges = fieldChanges;
@@ -1372,6 +1627,37 @@ 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,
@@ -1382,20 +1668,18 @@ export class ModularChangeFamily
 	): void {
 		for (const field of fields.values()) {
 			const handler = getChangeHandler(this.fieldKinds, field.fieldKind);
-			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;
+			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;
 				const outputAttachState =
 					parentOutputAttachState === NodeAttachState.Detached || isOutputDetached
 						? NodeAttachState.Detached
 						: NodeAttachState.Attached;
+
 				this.updateConstraintsForNode(
 					nodeId,
-					inputAttachState,
+					parentInputAttachState,
 					outputAttachState,
 					nodes,
 					constraintState,
@@ -1413,12 +1697,15 @@ export class ModularChangeFamily
 		constraintState: ConstraintState,
 		revertConstraintState: ConstraintState,
 	): void {
-		const node =
-			nodes.get([nodeId.revision, nodeId.localId]) ?? fail(0xb24 /* Unknown node ID */);
+		const node = getFromChangeAtomIdMap(nodes, nodeId) ?? fail(0xb24 /* Unknown node ID */);
+
+		const updatedNode: Mutable<NodeChangeset> = { ...node };
+		setInChangeAtomIdMap(nodes, nodeId, updatedNode);
+
 		if (node.nodeExistsConstraint !== undefined) {
 			const isNowViolated = inputAttachState === NodeAttachState.Detached;
 			if (node.nodeExistsConstraint.violated !== isNowViolated) {
-				node.nodeExistsConstraint = {
+				updatedNode.nodeExistsConstraint = {
 					...node.nodeExistsConstraint,
 					violated: isNowViolated,
 				};
@@ -1428,7 +1715,7 @@ export class ModularChangeFamily
 		if (node.nodeExistsConstraintOnRevert !== undefined) {
 			const isNowViolated = outputAttachState === NodeAttachState.Detached;
 			if (node.nodeExistsConstraintOnRevert.violated !== isNowViolated) {
-				node.nodeExistsConstraintOnRevert = {
+				updatedNode.nodeExistsConstraintOnRevert = {
 					...node.nodeExistsConstraintOnRevert,
 					violated: isNowViolated,
 				};
@@ -1450,7 +1737,13 @@ 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;
@@ -1461,10 +1754,48 @@ export class ModularChangeFamily
 			const handler = getChangeHandler(this.fieldKinds, fieldChange.fieldKind);
 
 			const prunedFieldChangeset = handler.rebaser.prune(fieldChange.change, (nodeId) =>
-				this.pruneNodeChange(nodeId, nodeMap),
+				this.pruneNodeChange(
+					nodeId,
+					nodeMap,
+					nodeToParent,
+					aliases,
+					roots,
+					fieldsWithRootMoves,
+					fieldsToRootChanges,
+				),
 			);
 
-			if (!handler.isEmpty(prunedFieldChangeset)) {
+			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) {
 				prunedChangeset.set(field, { ...fieldChange, change: brand(prunedFieldChangeset) });
 			}
 		}
@@ -1472,15 +1803,65 @@ 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,
-		nodeMap: ChangeAtomIdBTree<NodeChangeset>,
+		nodes: ChangeAtomIdBTree<NodeChangeset>,
+		nodeToParent: ChangeAtomIdBTree<NodeLocation>,
+		aliases: ChangeAtomIdBTree<NodeId>,
+		roots: RootNodeTable,
+		fieldsWithRootMoves: TupleBTree<FieldIdKey, boolean>,
+		fieldsToRootChanges: TupleBTree<FieldIdKey, ChangeAtomId[]>,
 	): NodeId | undefined {
-		const changeset = nodeChangeFromId(nodeMap, nodeId);
+		const changeset = nodeChangeFromId(nodes, aliases, nodeId);
 		const prunedFields =
-			changeset.fieldChanges !== undefined
-				? this.pruneFieldMap(changeset.fieldChanges, nodeMap)
-				: undefined;
+			changeset.fieldChanges === undefined
+				? undefined
+				: this.pruneFieldMap(
+						changeset.fieldChanges,
+						nodeId,
+						nodes,
+						nodeToParent,
+						aliases,
+						roots,
+						fieldsWithRootMoves,
+						fieldsToRootChanges,
+					);
 
 		const prunedChange = { ...changeset, fieldChanges: prunedFields };
 		if (prunedChange.fieldChanges === undefined) {
@@ -1488,103 +1869,92 @@ export class ModularChangeFamily
 		}
 
 		if (isEmptyNodeChangeset(prunedChange)) {
-			nodeMap.delete([nodeId.revision, nodeId.localId]);
+			const nodeIdKey: [RevisionTag | undefined, ChangesetLocalId] = [
+				nodeId.revision,
+				nodeId.localId,
+			];
+
+			// TODO: Shouldn't we also delete all aliases associated with this node?
+			nodes.delete(nodeIdKey);
+			nodeToParent.delete(nodeIdKey);
 			return undefined;
 		} else {
-			setInChangeAtomIdMap(nodeMap, nodeId, prunedChange);
+			setInChangeAtomIdMap(nodes, nodeId, prunedChange);
 			return nodeId;
 		}
 	}
 
+	public getRevisions(change: ModularChangeset): Set<RevisionTag | undefined> {
+		if (change.revisions === undefined || change.revisions.length === 0) {
+			return new Set([undefined]);
+		}
+		const aggregated: Set<RevisionTag | undefined> = new Set();
+		for (const revInfo of change.revisions) {
+			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,
-			oldRevisions,
-			newRevision,
+		const updatedFields = this.replaceFieldMapRevisions(change.fieldChanges, replacer);
+		const updatedNodes = replaceIdMapRevisions(change.nodeChanges, replacer, (nodeChangeset) =>
+			this.replaceNodeChangesetRevisions(nodeChangeset, 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<FieldId> = newTupleBTree();
-		for (const [[revision, id], fieldId] of change.nodeToParent.entries()) {
-			updatedNodeToParent.set(
-				[replaceRevision(revision, oldRevisions, newRevision), id],
-				replaceFieldIdRevision(
-					normalizeFieldId(fieldId, change.nodeAliases),
-					oldRevisions,
-					newRevision,
+		const updatedNodeToParent = replaceIdMapRevisions(
+			change.nodeToParent,
+			replacer,
+			(location) =>
+				replaceNodeLocationRevision(
+					normalizeNodeLocation(location, change.nodeAliases),
+					replacer,
 				),
-			);
-		}
+		);
 
 		const updated: Mutable<ModularChangeset> = {
 			...change,
 			fieldChanges: updatedFields,
 			nodeChanges: updatedNodes,
 			nodeToParent: updatedNodeToParent,
+			rootNodes: replaceRootTableRevision(change.rootNodes, replacer, change.nodeAliases),
 
 			// We've updated all references to old node IDs, so we no longer need an alias table.
 			nodeAliases: newTupleBTree(),
 			crossFieldKeys: replaceCrossFieldKeyTableRevisions(
 				change.crossFieldKeys,
-				oldRevisions,
-				newRevision,
+				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,
 			);
 		}
 
@@ -1593,15 +1963,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) });
 		}
@@ -1613,7 +1982,7 @@ export class ModularChangeFamily
 		fields: FieldChangeMap,
 		nodes: ChangeAtomIdBTree<NodeChangeset>,
 	): CrossFieldKeyTable {
-		const keys: CrossFieldKeyTable = newCrossFieldKeyTable();
+		const keys: CrossFieldKeyTable = newCrossFieldRangeTable();
 		this.populateCrossFieldKeyTableForFieldMap(keys, fields, undefined);
 		nodes.forEachPair(([revision, localId], node) => {
 			if (node.fieldChanges !== undefined) {
@@ -1643,9 +2012,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 {
@@ -1653,63 +2023,6 @@ export class ModularChangeFamily
 		return { fieldKind, change: brand(emptyChange) };
 	}
 
-	public validateChangeset(change: ModularChangeset): void {
-		let numNodes = this.validateFieldChanges(change, change.fieldChanges, undefined);
-
-		for (const [[revision, localId], node] of change.nodeChanges.entries()) {
-			if (node.fieldChanges === undefined) {
-				continue;
-			}
-
-			const nodeId: NodeId = { revision, localId };
-			const numChildren = this.validateFieldChanges(change, node.fieldChanges, nodeId);
-
-			numNodes += numChildren;
-		}
-
-		assert(
-			numNodes === change.nodeChanges.size,
-			0xa4d /* Node table contains unparented nodes */,
-		);
-	}
-
-	/**
-	 * 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,
-	): 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 = getParentFieldId(change, child);
-				assert(
-					areEqualFieldIds(parentFieldId, fieldId),
-					0xa4e /* Inconsistent node parentage */,
-				);
-				numChildren += 1;
-			}
-
-			for (const keyRange of handler.getCrossFieldKeys(fieldChange.change)) {
-				const fields = getFieldsForCrossFieldKey(change, 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 {
 		if (hasConflicts(change)) {
 			return this.muteChange(change);
@@ -1723,7 +2036,8 @@ export class ModularChangeFamily
 	private muteChange(change: ModularChangeset): ModularChangeset {
 		const muted: Mutable<ModularChangeset> = {
 			...change,
-			crossFieldKeys: newCrossFieldKeyTable(),
+			rootNodes: muteRootChanges(change.rootNodes),
+			crossFieldKeys: newCrossFieldRangeTable(),
 			fieldChanges: this.muteFieldChanges(change.fieldChanges),
 			nodeChanges: brand(change.nodeChanges.mapValues((v) => this.muteNodeChange(v))),
 		};
@@ -1757,25 +2071,20 @@ export class ModularChangeFamily
 
 function replaceCrossFieldKeyTableRevisions(
 	table: CrossFieldKeyTable,
-	oldRevisions: Set<RevisionTag | undefined>,
-	newRevision: RevisionTag | undefined,
+	replacer: RevisionReplacer,
 	nodeAliases: ChangeAtomIdBTree<NodeId>,
 ): CrossFieldKeyTable {
-	const updated: CrossFieldKeyTable = newCrossFieldKeyTable();
+	const updated: CrossFieldKeyTable = newCrossFieldRangeTable();
 	for (const entry of table.entries()) {
 		const key = entry.start;
-		const updatedKey: CrossFieldKey = {
-			target: key.target,
-			revision: replaceRevision(key.revision, oldRevisions, newRevision),
-			localId: key.localId,
-		};
+		const updatedKey: CrossFieldKey = replacer.getUpdatedAtomId(key);
 
 		const field = entry.value;
 		const normalizedFieldId = normalizeFieldId(field, nodeAliases);
 		const updatedNodeId =
-			normalizedFieldId.nodeId !== undefined
-				? replaceAtomRevisions(normalizedFieldId.nodeId, oldRevisions, newRevision)
-				: undefined;
+			normalizedFieldId.nodeId === undefined
+				? undefined
+				: replacer.getUpdatedAtomId(normalizedFieldId.nodeId);
 
 		const updatedValue: FieldId = {
 			...normalizedFieldId,
@@ -1788,22 +2097,15 @@ function replaceCrossFieldKeyTableRevisions(
 	return updated;
 }
 
-function replaceRevision(
-	revision: RevisionTag | undefined,
-	oldRevisions: Set<RevisionTag | undefined>,
-	newRevision: RevisionTag | undefined,
-): RevisionTag | undefined {
-	return oldRevisions.has(revision) ? newRevision : revision;
-}
-
 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;
@@ -1879,6 +2181,20 @@ 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 };
 }
 
@@ -1910,27 +2226,77 @@ export function* relevantRemovedRoots(
 	change: ModularChangeset,
 	fieldKinds: ReadonlyMap<FieldKindIdentifier, FlexFieldKind>,
 ): Iterable<DeltaDetachedNodeId> {
-	yield* relevantRemovedRootsFromFields(change.fieldChanges, change.nodeChanges, fieldKinds);
+	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);
+		}
+	}
 }
 
-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,
-				);
+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* handler.relevantRemovedRoots(fieldChange.change, delegate);
+		}
+	}
+}
+
+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);
+			}
+		}
 	}
 }
 
@@ -1990,20 +2356,25 @@ export function updateRefreshers(
 	const {
 		fieldChanges,
 		nodeChanges,
+		nodeToParent,
+		nodeAliases,
+		crossFieldKeys,
 		maxId,
 		revisions,
 		constraintViolationCount,
 		constraintViolationCountOnRevert,
 		builds,
 		destroys,
+		rootNodes,
 	} = change;
 
 	return makeModularChangeset({
 		fieldChanges,
 		nodeChanges,
-		nodeToParent: change.nodeToParent,
-		nodeAliases: change.nodeAliases,
-		crossFieldKeys: change.crossFieldKeys,
+		nodeToParent,
+		nodeAliases,
+		crossFieldKeys,
+		rootNodes,
 		maxId: maxId as number,
 		revisions,
 		constraintViolationCount,
@@ -2026,18 +2397,42 @@ 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;
 		}
@@ -2066,6 +2461,7 @@ export function intoDelta(
 	if (change.refreshers && change.refreshers.size > 0) {
 		rootDelta.refreshers = copyDetachedNodes(change.refreshers);
 	}
+
 	return rootDelta;
 }
 
@@ -2091,29 +2487,22 @@ 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 {
-			local: fieldChanges,
-			global: fieldGlobal,
-			rename: fieldRename,
-		} = getChangeHandler(fieldKinds, fieldChange.fieldKind).intoDelta(
+		const fieldDelta = getChangeHandler(fieldKinds, fieldChange.fieldKind).intoDelta(
 			fieldChange.change,
 			(childChange): DeltaFieldMap => {
-				const nodeChange = nodeChangeFromId(nodeChanges, childChange);
-				return deltaFromNodeChange(nodeChange, nodeChanges, fieldKinds, global, rename);
+				const nodeChange = nodeChangeFromId(nodeChanges, nodeAliases, childChange);
+				return deltaFromNodeChange(nodeChange, nodeChanges, nodeAliases, fieldKinds);
 			},
 		);
-		if (fieldChanges !== undefined && fieldChanges.length > 0) {
-			delta.set(field, fieldChanges);
+		if (fieldDelta !== undefined && fieldDelta.length > 0) {
+			delta.set(field, fieldDelta);
 		}
-		fieldGlobal?.forEach((c) => global.push(c));
-		fieldRename?.forEach((r) => rename.push(r));
 	}
 	return delta;
 }
@@ -2121,12 +2510,11 @@ 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, fieldKinds, global, rename);
+		return intoDeltaImpl(change.fieldChanges, nodeChanges, nodeAliases, fieldKinds);
 	}
 	// TODO: update the API to allow undefined to be returned here
 	return new Map();
@@ -2191,19 +2579,21 @@ export function getChangeHandler(
 	return getFieldKind(fieldKinds, kind).changeHandler;
 }
 
-// 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>;
-}
+interface InvertTable {
+	change: ModularChangeset;
 
-interface InvertTable extends CrossFieldTable<FieldChange> {
+	// Entries are keyed on attach ID
+	entries: CrossFieldMap<NodeId>;
 	originalFieldToContext: Map<FieldChange, InvertContext>;
-	invertedNodeToParent: ChangeAtomIdBTree<FieldId>;
+	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>;
 }
 
 interface InvertContext {
@@ -2211,7 +2601,11 @@ interface InvertContext {
 	invertedField: FieldChange;
 }
 
-interface RebaseTable extends CrossFieldTable<FieldChange> {
+interface RebaseTable {
+	readonly rebaseVersion: RebaseVersion;
+
+	// Entries are keyed on attach ID
+	readonly entries: CrossFieldMap<RebaseDetachedNodeEntry>;
 	readonly baseChange: ModularChangeset;
 	readonly newChange: ModularChangeset;
 
@@ -2220,10 +2614,13 @@ interface RebaseTable extends CrossFieldTable<FieldChange> {
 	 * 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<FieldId>;
-	readonly rebasedCrossFieldKeys: CrossFieldKeyTable;
+	readonly rebasedNodeToParent: ChangeAtomIdBTree<NodeLocation>;
+	readonly rebasedDetachLocations: ChangeAtomIdRangeMap<FieldId>;
+	readonly movedDetaches: ChangeAtomIdRangeMap<boolean>;
+	readonly rebasedRootNodes: RootNodeTable;
 
 	/**
 	 * List of unprocessed (newId, baseId) pairs encountered so far.
@@ -2237,7 +2634,7 @@ interface RebaseTable extends CrossFieldTable<FieldChange> {
 	readonly fieldsWithUnattachedChild: Set<FieldChange>;
 }
 
-type FieldIdKey = [RevisionTag | undefined, ChangesetLocalId | undefined, FieldKey];
+export type FieldIdKey = [RevisionTag | undefined, ChangesetLocalId | undefined, FieldKey];
 
 interface RebaseFieldContext {
 	baseChange: FieldChange;
@@ -2249,32 +2646,43 @@ 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: NodeId[];
+	baseNodeIds: ChangeAtomIdBTree<boolean>;
 }
 
 function newComposeTable(
 	baseChange: ModularChangeset,
 	newChange: ModularChangeset,
-	composedNodeToParent: ChangeAtomIdBTree<FieldId>,
+	composedRootNodes: RootNodeTable,
+	movedCrossFieldKeys: CrossFieldKeyTable,
+	removedCrossFieldKeys: CrossFieldRangeTable<boolean>,
+	pendingCompositions: PendingCompositions,
 ): ComposeTable {
 	return {
-		...newCrossFieldTable<FieldChange>(),
+		rebaseVersion: Math.max(
+			baseChange.rebaseVersion,
+			newChange.rebaseVersion,
+		) as RebaseVersion,
+		entries: newDetachedEntryMap(),
 		baseChange,
 		newChange,
 		fieldToContext: new Map(),
 		newFieldToBaseField: new Map(),
 		newToBaseNodeId: newTupleBTree(),
 		composedNodes: new Set(),
-		composedNodeToParent,
-		pendingCompositions: {
-			nodeIdsToCompose: [],
-			affectedBaseFields: newTupleBTree(),
-			affectedNewFields: newTupleBTree(),
-		},
+		movedNodeToParent: newTupleBTree(),
+		composedRootNodes,
+		movedCrossFieldKeys,
+		removedCrossFieldKeys,
+		renamesToDelete: newChangeAtomIdRangeMap(),
+		pendingCompositions,
 	};
 }
 
-interface ComposeTable extends CrossFieldTable<FieldChange> {
+interface ComposeTable {
+	readonly rebaseVersion: RebaseVersion;
+
+	// Entries are keyed on detach ID
+	readonly entries: ChangeAtomIdRangeMap<DetachedNodeEntry>;
 	readonly baseChange: ModularChangeset;
 	readonly newChange: ModularChangeset;
 
@@ -2285,7 +2693,11 @@ interface ComposeTable extends CrossFieldTable<FieldChange> {
 	readonly newFieldToBaseField: Map<FieldChange, FieldChange>;
 	readonly newToBaseNodeId: ChangeAtomIdBTree<NodeId>;
 	readonly composedNodes: Set<NodeChangeset>;
-	readonly composedNodeToParent: ChangeAtomIdBTree<FieldId>;
+	readonly movedNodeToParent: ChangeAtomIdBTree<NodeLocation>;
+	readonly composedRootNodes: RootNodeTable;
+	readonly movedCrossFieldKeys: CrossFieldKeyTable;
+	readonly removedCrossFieldKeys: CrossFieldRangeTable<boolean>;
+	readonly renamesToDelete: ChangeAtomIdRangeMap<boolean>;
 	readonly pendingCompositions: PendingCompositions;
 }
 
@@ -2300,11 +2712,6 @@ 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 {
@@ -2317,16 +2724,6 @@ 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;
 }
@@ -2337,342 +2734,771 @@ function newConstraintState(violationCount: number): ConstraintState {
 	};
 }
 
-abstract class CrossFieldManagerI<T> implements CrossFieldManager {
+class InvertNodeManagerI implements InvertNodeManager {
 	public constructor(
-		protected readonly crossFieldTable: CrossFieldTable<T>,
-		private readonly currentFieldKey: T,
-		protected readonly allowInval = true,
+		private readonly table: InvertTable,
+		private readonly fieldId: FieldId,
 	) {}
 
-	public set(
-		target: CrossFieldTarget,
-		revision: RevisionTag | undefined,
-		id: ChangesetLocalId,
+	public invertDetach(
+		detachId: ChangeAtomId,
 		count: number,
-		newValue: unknown,
-		invalidateDependents: boolean,
+		nodeChange: NodeId | undefined,
+		newAttachId: ChangeAtomId,
 	): void {
-		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);
-				}
+		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,
+			);
 
-				firstId = brand(firstId + dependentEntry.length);
+			if (attachFieldEntry.value === undefined) {
+				assignRootChange(
+					this.table.invertedRoots,
+					this.table.invertedNodeToParent,
+					attachEntry.value,
+					nodeChange,
+					this.fieldId,
+					this.table.change.rebaseVersion,
+				);
+			} else {
+				setInCrossFieldMap(this.table.entries, attachEntry.value, count, nodeChange);
+				this.table.invalidatedFields.add(
+					fieldChangeFromId(this.table.change, attachFieldEntry.value),
+				);
 			}
 		}
-		setInCrossFieldMap(this.getMap(target), revision, id, count, newValue);
-	}
 
-	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,
+		if (!areEqualChangeAtomIds(detachId, newAttachId)) {
+			for (const entry of doesChangeAttachNodes(
+				this.table.change.crossFieldKeys,
+				detachId,
 				count,
-				this.currentFieldKey,
-			);
+			)) {
+				if (!entry.value) {
+					this.table.attachToDetachId.set(newAttachId, count, detachId);
+					this.table.invertedRoots.detachLocations.set(detachId, count, this.fieldId);
+				}
+			}
 		}
-		return getFirstFromCrossFieldMap(this.getMap(target), revision, id, count);
 	}
 
-	public abstract onMoveIn(id: NodeId): void;
-
-	public abstract moveKey(
-		target: CrossFieldTarget,
-		revision: RevisionTag | undefined,
-		id: ChangesetLocalId,
+	public invertAttach(
+		attachId: ChangeAtomId,
 		count: number,
-	): void;
-
-	private getMap(target: CrossFieldTarget): CrossFieldMap<unknown> {
-		return target === CrossFieldTarget.Source
-			? this.crossFieldTable.srcTable
-			: this.crossFieldTable.dstTable;
-	}
+	): RangeQueryResult<DetachedNodeEntry> {
+		let countToProcess = count;
 
-	private getDependents(target: CrossFieldTarget): CrossFieldMap<T> {
-		return target === CrossFieldTarget.Source
-			? this.crossFieldTable.srcDependents
-			: this.crossFieldTable.dstDependents;
-	}
-}
+		const detachIdEntry = firstDetachIdFromAttachId(
+			this.table.change.rootNodes,
+			attachId,
+			countToProcess,
+		);
 
-class InvertManager extends CrossFieldManagerI<FieldChange> {
-	public constructor(
-		table: InvertTable,
-		field: FieldChange,
-		private readonly fieldId: FieldId,
-		allowInval = true,
-	) {
-		super(table, field, allowInval);
-	}
+		countToProcess = detachIdEntry.length;
 
-	public override onMoveIn(id: ChangeAtomId): void {
-		setInChangeAtomIdMap(this.table.invertedNodeToParent, id, this.fieldId);
-	}
+		const detachEntry = getFirstFieldForCrossFieldKey(
+			this.table.change,
+			{ target: CrossFieldTarget.Source, ...detachIdEntry.value },
+			countToProcess,
+		);
+		countToProcess = detachEntry.length;
+
+		let result: RangeQueryResult<DetachedNodeEntry>;
+		if (detachEntry.value === undefined) {
+			// 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 moveKey(
-		target: CrossFieldTarget,
-		revision: RevisionTag | undefined,
-		id: ChangesetLocalId,
-		count: number,
-	): void {
-		assert(false, 0x9c5 /* Keys should not be moved manually during invert */);
-	}
+			countToProcess = nodeIdEntry.length;
+			result = {
+				value: { nodeChange: nodeIdEntry.value, detachId: detachIdEntry.value },
+				length: countToProcess,
+			};
+		} else {
+			const moveEntry = this.table.entries.getFirst(attachId, countToProcess);
+			result = { ...moveEntry, value: { nodeChange: moveEntry.value } };
+		}
 
-	private get table(): InvertTable {
-		return this.crossFieldTable as InvertTable;
+		if (result.value?.nodeChange !== undefined) {
+			setInChangeAtomIdMap(this.table.invertedNodeToParent, result.value.nodeChange, {
+				field: this.fieldId,
+			});
+		}
+		return result;
 	}
 }
 
-class RebaseManager extends CrossFieldManagerI<FieldChange> {
+class RebaseNodeManagerI implements RebaseNodeManager {
 	public constructor(
-		table: RebaseTable,
-		currentField: FieldChange,
+		private readonly table: RebaseTable,
 		private readonly fieldId: FieldId,
-		allowInval = true,
-	) {
-		super(table, currentField, allowInval);
-	}
+		private readonly allowInval: boolean = true,
+	) {}
 
-	public override set(
-		target: CrossFieldTarget,
-		revision: RevisionTag | undefined,
-		id: ChangesetLocalId,
+	public getNewChangesForBaseAttach(
+		baseAttachId: ChangeAtomId,
 		count: number,
-		newValue: unknown,
-		invalidateDependents: boolean,
-	): void {
-		if (invalidateDependents && this.allowInval) {
-			const newFieldIds = getFieldsForCrossFieldKey(
-				this.table.newChange,
-				{
-					target,
-					revision,
-					localId: id,
-				},
-				count,
-			);
+	): RangeQueryResult<RebaseDetachedNodeEntry | undefined> {
+		let countToProcess = count;
 
-			assert(
-				newFieldIds.length === 0,
-				0x9c6 /* TODO: Modifying a cross-field key from the new changeset is currently unsupported */,
-			);
+		const detachEntry = firstDetachIdFromAttachId(
+			this.table.baseChange.rootNodes,
+			baseAttachId,
+			countToProcess,
+		);
 
-			const baseFieldIds = getFieldsForCrossFieldKey(
-				this.table.baseChange,
-				{
-					target,
-					revision,
-					localId: id,
-				},
-				count,
-			);
+		countToProcess = detachEntry.length;
 
-			assert(
-				baseFieldIds.length > 0,
-				0x9c7 /* Cross field key not registered in base or new change */,
+		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,
 			);
+		}
 
-			for (const baseFieldId of baseFieldIds) {
-				this.table.affectedBaseFields.set(
-					[baseFieldId.nodeId?.revision, baseFieldId.nodeId?.localId, baseFieldId.field],
-					true,
+		if (result.value?.nodeChange !== undefined) {
+			setInChangeAtomIdMap(this.table.rebasedNodeToParent, result.value.nodeChange, {
+				field: this.fieldId,
+			});
+		}
+
+		return result;
+	}
+
+	public rebaseOverDetach(
+		baseDetachId: ChangeAtomId,
+		count: number,
+		newDetachId: ChangeAtomId | undefined,
+		nodeChange: NodeId | undefined,
+		cellRename?: ChangeAtomId,
+	): 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;
+
+		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,
+			});
+
+			if (nodeChange !== undefined || newDetachId !== undefined) {
+				this.invalidateBaseFields([destinationField]);
+			}
+		}
+
+		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,
 				);
 			}
+
+			if (newDetachId !== undefined) {
+				addNodeRename(
+					this.table.rebasedRootNodes,
+					baseAttachId,
+					newDetachId,
+					countToProcess,
+					this.fieldId,
+				);
+			}
+		}
+
+		if (newDetachId !== undefined) {
+			this.table.movedDetaches.set(newDetachId, countToProcess, true);
+		}
+
+		if (countToProcess < count) {
+			const remainingCount = count - countToProcess;
+
+			const nextDetachId =
+				newDetachId === undefined
+					? undefined
+					: offsetChangeAtomId(newDetachId, countToProcess);
+
+			this.rebaseOverDetach(
+				offsetChangeAtomId(baseDetachId, countToProcess),
+				remainingCount,
+				nextDetachId,
+				nodeChange,
+			);
 		}
+	}
 
-		super.set(target, revision, id, count, newValue, invalidateDependents);
+	public addDetach(id: ChangeAtomId, count: number): void {
+		this.table.rebasedDetachLocations.set(id, count, this.fieldId);
 	}
 
-	public override onMoveIn(id: ChangeAtomId): void {
-		setInChangeAtomIdMap(this.table.rebasedNodeToParent, id, this.fieldId);
+	public removeDetach(id: ChangeAtomId, count: number): void {
+		this.table.movedDetaches.set(id, count, true);
 	}
 
-	public override moveKey(
-		target: CrossFieldTarget,
-		revision: RevisionTag | undefined,
-		id: ChangesetLocalId,
+	public doesBaseAttachNodes(
+		id: ChangeAtomId,
 		count: number,
-	): void {
-		this.table.rebasedCrossFieldKeys.set(
-			{ target, revision, localId: id },
-			count,
-			this.fieldId,
+	): 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 };
+	}
+
+	public getBaseRename(
+		id: ChangeAtomId,
+		count: number,
+	): RangeQueryResult<ChangeAtomId | undefined> {
+		return this.table.baseChange.rootNodes.oldToNewId.getFirst(id, count);
+	}
+
+	public getNewRenameForBaseRename(
+		baseRenameTo: ChangeAtomId,
+		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,
 		);
+
+		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);
 
-	private get table(): RebaseTable {
-		return this.crossFieldTable as RebaseTable;
+	if (nodeToParent !== undefined) {
+		setInChangeAtomIdMap(nodeToParent, nodeId, { root: detachId });
 	}
+
+	table.detachLocations.set(detachId, 1, detachLocation);
 }
 
-// TODO: Deduplicate this with RebaseTable
-class ComposeManager extends CrossFieldManagerI<FieldChange> {
+class ComposeNodeManagerI implements ComposeNodeManager {
 	public constructor(
-		table: ComposeTable,
-		currentField: FieldChange,
+		private readonly table: ComposeTable,
 		private readonly fieldId: FieldId,
-		allowInval = true,
-	) {
-		super(table, currentField, allowInval);
+		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 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,
+			};
+		} else {
+			// 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 };
+		}
+
+		// 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;
 	}
 
-	public override set(
-		target: CrossFieldTarget,
-		revision: RevisionTag | undefined,
-		id: ChangesetLocalId,
+	public composeAttachDetach(
+		baseAttachId: ChangeAtomId,
+		newDetachId: ChangeAtomId,
 		count: number,
-		newValue: unknown,
-		invalidateDependents: boolean,
 	): void {
-		if (invalidateDependents && this.allowInval) {
-			const newFieldIds = getFieldsForCrossFieldKey(
-				this.table.newChange,
-				{
-					target,
-					revision,
-					localId: id,
-				},
-				count,
+		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 (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,
+		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) {
+			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,
+			);
+		} else {
+			// 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,
 				);
+			}
 
-				assert(
-					baseFieldIds.length > 0,
-					0x9c8 /* Cross field key not registered in base or new change */,
+			this.table.movedCrossFieldKeys.set(
+				{ ...newDetachId, target: CrossFieldTarget.Source },
+				countToProcess,
+				baseDetachEntry.value,
+			);
+
+			this.invalidateBaseFields([baseDetachEntry.value]);
+		}
+
+		if (newAttachEntry.value === undefined) {
+			const newOutputDetachLocationEntry =
+				this.table.newChange.rootNodes.outputDetachLocations.getFirst(
+					newDetachId,
+					countToProcess,
 				);
 
-				for (const baseFieldId of baseFieldIds) {
-					this.table.pendingCompositions.affectedBaseFields.set(
-						[baseFieldId.nodeId?.revision, baseFieldId.nodeId?.localId, baseFieldId.field],
-						true,
-					);
-				}
-			}
+			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 });
 
-		super.set(target, revision, id, count, newValue, invalidateDependents);
+			if (newChanges !== undefined) {
+				this.invalidateBaseFields(detachFields);
+			}
+		} else {
+			const baseNodeId = getFromChangeAtomIdMap(
+				this.table.baseChange.rootNodes.nodeChanges,
+				baseDetachId,
+			);
+
+			if (baseNodeId === undefined) {
+				assignRootChange(
+					this.table.composedRootNodes,
+					this.table.movedNodeToParent,
+					baseDetachId,
+					newChanges,
+					this.fieldId,
+					this.table.rebaseVersion,
+				);
+			} else {
+				addNodesToCompose(this.table, baseNodeId, newChanges);
+			}
+		}
 	}
 
-	public override onMoveIn(id: ChangeAtomId): void {
-		setInChangeAtomIdMap(this.table.composedNodeToParent, id, this.fieldId);
+	private areSameNodes(
+		baseDetachId: ChangeAtomId,
+		newAttachId: ChangeAtomId,
+		count: number,
+	): RangeQueryResult<boolean> {
+		const renamedDetachEntry = firstAttachIdFromDetachId(
+			this.table.composedRootNodes,
+			baseDetachId,
+			count,
+		);
+
+		const isReattachOfSameNodes = areEqualChangeAtomIds(renamedDetachEntry.value, newAttachId);
+		return { ...renamedDetachEntry, value: isReattachOfSameNodes };
 	}
 
-	public override moveKey(
-		target: CrossFieldTarget,
-		revision: RevisionTag | undefined,
-		id: ChangesetLocalId,
+	public composeDetachAttach(
+		baseDetachId: ChangeAtomId,
+		newAttachId: ChangeAtomId,
 		count: number,
+		composeToPin: boolean,
 	): void {
-		throw new Error("Moving cross-field keys during compose is currently unsupported");
-	}
-
-	private get table(): ComposeTable {
-		return this.crossFieldTable as ComposeTable;
-	}
-}
-
-function makeModularChangeset(
-	props: {
-		fieldChanges?: FieldChangeMap;
-		nodeChanges?: ChangeAtomIdBTree<NodeChangeset>;
-		nodeToParent?: ChangeAtomIdBTree<FieldId>;
-		nodeAliases?: ChangeAtomIdBTree<NodeId>;
-		crossFieldKeys?: CrossFieldKeyTable;
-		maxId: number;
-		revisions?: readonly RevisionInfo[];
-		constraintViolationCount?: number;
-		constraintViolationCountOnRevert?: number;
-		builds?: ChangeAtomIdBTree<TreeChunk>;
-		destroys?: ChangeAtomIdBTree<number>;
-		refreshers?: ChangeAtomIdBTree<TreeChunk>;
-	} = {
-		maxId: -1,
-	},
-): ModularChangeset {
+		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,
+			);
+		}
+	}
+
+	private invalidateBaseFields(fields: FieldId[]): void {
+		if (this.allowInval) {
+			for (const fieldId of fields) {
+				this.table.pendingCompositions.affectedBaseFields.set(
+					fieldIdKeyFromFieldId(fieldId),
+					true,
+				);
+			}
+		}
+	}
+}
+
+function makeModularChangeset(props?: {
+	rebaseVersion?: RebaseVersion;
+	fieldChanges?: FieldChangeMap;
+	nodeChanges?: ChangeAtomIdBTree<NodeChangeset>;
+	rootNodes?: RootNodeTable;
+	nodeToParent?: ChangeAtomIdBTree<NodeLocation>;
+	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>;
+}): ModularChangeset {
+	const p = props ?? { maxId: -1 };
 	const changeset: Mutable<ModularChangeset> = {
-		fieldChanges: props.fieldChanges ?? new Map(),
-		nodeChanges: props.nodeChanges ?? newTupleBTree(),
-		nodeToParent: props.nodeToParent ?? newTupleBTree(),
-		nodeAliases: props.nodeAliases ?? newTupleBTree(),
-		crossFieldKeys: props.crossFieldKeys ?? newCrossFieldKeyTable(),
+		rebaseVersion: p.rebaseVersion ?? 1,
+		fieldChanges: p.fieldChanges ?? new Map(),
+		nodeChanges: p.nodeChanges ?? newTupleBTree(),
+		rootNodes: p.rootNodes ?? newRootTable(),
+		nodeToParent: p.nodeToParent ?? newTupleBTree(),
+		nodeAliases: p.nodeAliases ?? newTupleBTree(),
+		crossFieldKeys: p.crossFieldKeys ?? newCrossFieldRangeTable(),
 	};
 
-	if (props.revisions !== undefined && props.revisions.length > 0) {
-		changeset.revisions = props.revisions;
+	if (p.revisions !== undefined && p.revisions.length > 0) {
+		changeset.revisions = p.revisions;
 	}
-	if (props.maxId >= 0) {
-		changeset.maxId = brand(props.maxId);
+	if (p.maxId >= 0) {
+		changeset.maxId = brand(p.maxId);
 	}
-	if (props.constraintViolationCount !== undefined && props.constraintViolationCount > 0) {
-		changeset.constraintViolationCount = props.constraintViolationCount;
+	if (p.constraintViolationCount !== undefined && p.constraintViolationCount > 0) {
+		changeset.constraintViolationCount = p.constraintViolationCount;
 	}
 	if (
-		props.constraintViolationCountOnRevert !== undefined &&
-		props.constraintViolationCountOnRevert > 0
+		p.constraintViolationCountOnRevert !== undefined &&
+		p.constraintViolationCountOnRevert > 0
 	) {
-		changeset.constraintViolationCountOnRevert = props.constraintViolationCountOnRevert;
+		changeset.constraintViolationCountOnRevert = p.constraintViolationCountOnRevert;
+	}
+	if (p.noChangeConstraint !== undefined) {
+		changeset.noChangeConstraint = p.noChangeConstraint;
 	}
-	if (props.builds !== undefined && props.builds.size > 0) {
-		changeset.builds = props.builds;
+	if (p.noChangeConstraintOnRevert !== undefined) {
+		changeset.noChangeConstraintOnRevert = p.noChangeConstraintOnRevert;
 	}
-	if (props.destroys !== undefined && props.destroys.size > 0) {
-		changeset.destroys = props.destroys;
+	if (p.builds !== undefined && p.builds.size > 0) {
+		changeset.builds = p.builds;
 	}
-	if (props.refreshers !== undefined && props.refreshers.size > 0) {
-		changeset.refreshers = props.refreshers;
+	if (p.destroys !== undefined && p.destroys.size > 0) {
+		changeset.destroys = p.destroys;
 	}
+	if (p.refreshers !== undefined && p.refreshers.size > 0) {
+		changeset.refreshers = p.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();
+		this.codecOptions = codecOptions;
+	}
+
+	public isInTransaction(): boolean {
+		return this.transactionDepth > 0;
 	}
 
 	public override enterTransaction(): void {
@@ -2729,7 +3555,7 @@ export class ModularEditBuilder extends EditBuilder<ModularChangeset> {
 	 * @param revision - the revision of the change
 	 */
 	public submitChange(
-		field: FieldUpPath,
+		field: NormalizedFieldUpPath,
 		fieldKind: FieldKindIdentifier,
 		change: FieldChangeset,
 		revision: RevisionTag,
@@ -2743,7 +3569,8 @@ export class ModularEditBuilder extends EditBuilder<ModularChangeset> {
 			fieldChange: { fieldKind, change },
 			nodeChanges: newTupleBTree(),
 			nodeToParent: newTupleBTree(),
-			crossFieldKeys: newCrossFieldKeyTable(),
+			crossFieldKeys: newCrossFieldRangeTable(),
+			rootNodes: newRootTable(),
 			idAllocator: this.idAllocator,
 			localCrossFieldKeys,
 			revision,
@@ -2765,6 +3592,7 @@ export class ModularEditBuilder extends EditBuilder<ModularChangeset> {
 					? makeModularChangeset({
 							maxId: this.idAllocator.getMaxId(),
 							builds: change.builds,
+							rootNodes: renameTableFromRenameDescriptions(change.renames ?? []),
 							revisions: [{ revision: change.revision }],
 						})
 					: buildModularChangesetFromField({
@@ -2775,7 +3603,8 @@ export class ModularEditBuilder extends EditBuilder<ModularChangeset> {
 							},
 							nodeChanges: newTupleBTree(),
 							nodeToParent: newTupleBTree(),
-							crossFieldKeys: newCrossFieldKeyTable(),
+							crossFieldKeys: newCrossFieldRangeTable(),
+							rootNodes: newRootTable(),
 							idAllocator: this.idAllocator,
 							localCrossFieldKeys: getChangeHandler(
 								this.fieldKinds,
@@ -2785,7 +3614,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,
@@ -2802,7 +3631,7 @@ export class ModularEditBuilder extends EditBuilder<ModularChangeset> {
 		return brand(this.idAllocator.allocate(count));
 	}
 
-	public addNodeExistsConstraint(path: UpPath, revision: RevisionTag): void {
+	public addNodeExistsConstraint(path: NormalizedUpPath, revision: RevisionTag): void {
 		const nodeChange: NodeChangeset = {
 			nodeExistsConstraint: { violated: false },
 		};
@@ -2814,7 +3643,8 @@ export class ModularEditBuilder extends EditBuilder<ModularChangeset> {
 					nodeChange,
 					nodeChanges: newTupleBTree(),
 					nodeToParent: newTupleBTree(),
-					crossFieldKeys: newCrossFieldKeyTable(),
+					crossFieldKeys: newCrossFieldRangeTable(),
+					rootNodes: newRootTable(),
 					idAllocator: this.idAllocator,
 					revision,
 				}),
@@ -2823,7 +3653,7 @@ export class ModularEditBuilder extends EditBuilder<ModularChangeset> {
 		);
 	}
 
-	public addNodeExistsConstraintOnRevert(path: UpPath, revision: RevisionTag): void {
+	public addNodeExistsConstraintOnRevert(path: NormalizedUpPath, revision: RevisionTag): void {
 		const nodeChange: NodeChangeset = {
 			nodeExistsConstraintOnRevert: { violated: false },
 		};
@@ -2835,7 +3665,8 @@ export class ModularEditBuilder extends EditBuilder<ModularChangeset> {
 					nodeChange,
 					nodeChanges: newTupleBTree(),
 					nodeToParent: newTupleBTree(),
-					crossFieldKeys: newCrossFieldKeyTable(),
+					crossFieldKeys: newCrossFieldRangeTable(),
+					rootNodes: newRootTable(),
 					idAllocator: this.idAllocator,
 					revision,
 				}),
@@ -2843,14 +3674,45 @@ 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));
+	}
 }
 
-function buildModularChangesetFromField(props: {
-	path: FieldUpPath;
+export function buildModularChangesetFromField(props: {
+	path: NormalizedFieldUpPath;
 	fieldChange: FieldChange;
 	nodeChanges: ChangeAtomIdBTree<NodeChangeset>;
-	nodeToParent: ChangeAtomIdBTree<FieldId>;
+	nodeToParent: ChangeAtomIdBTree<NodeLocation>;
 	crossFieldKeys: CrossFieldKeyTable;
+	rootNodes: RootNodeTable;
 	localCrossFieldKeys?: CrossFieldKeyRange[];
 	revision: RevisionTag;
 	idAllocator?: IdAllocator;
@@ -2862,6 +3724,7 @@ function buildModularChangesetFromField(props: {
 		nodeChanges,
 		nodeToParent,
 		crossFieldKeys,
+		rootNodes,
 		idAllocator = idAllocatorFromMaxId(),
 		localCrossFieldKeys = [],
 		childId,
@@ -2870,14 +3733,17 @@ 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, { nodeId: undefined, field: path.field });
+			crossFieldKeys.set(key, count, field);
 		}
 
 		if (childId !== undefined) {
 			setInChangeAtomIdMap(nodeToParent, childId, {
-				nodeId: undefined,
-				field: path.field,
+				field: {
+					nodeId: undefined,
+					field: path.field,
+				},
 			});
 		}
 
@@ -2886,6 +3752,7 @@ function buildModularChangesetFromField(props: {
 			nodeChanges,
 			nodeToParent,
 			crossFieldKeys,
+			rootNodes,
 			maxId: idAllocator.getMaxId(),
 			revisions: [{ revision }],
 		});
@@ -2896,6 +3763,7 @@ 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 });
@@ -2903,8 +3771,7 @@ function buildModularChangesetFromField(props: {
 
 	if (childId !== undefined) {
 		setInChangeAtomIdMap(nodeToParent, childId, {
-			nodeId: parentId,
-			field: path.field,
+			field: fieldId,
 		});
 	}
 
@@ -2914,6 +3781,7 @@ function buildModularChangesetFromField(props: {
 		nodeChanges,
 		nodeToParent,
 		crossFieldKeys,
+		rootNodes,
 		idAllocator,
 		revision,
 		nodeId: parentId,
@@ -2921,41 +3789,62 @@ function buildModularChangesetFromField(props: {
 }
 
 function buildModularChangesetFromNode(props: {
-	path: UpPath;
+	path: NormalizedUpPath;
 	nodeChange: NodeChangeset;
 	nodeChanges: ChangeAtomIdBTree<NodeChangeset>;
-	nodeToParent: ChangeAtomIdBTree<FieldId>;
+	nodeToParent: ChangeAtomIdBTree<NodeLocation>;
 	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);
-	const fieldChangeset = genericFieldKind.changeHandler.editor.buildChildChanges([
-		[path.parentIndex, nodeId],
-	]);
-
-	const fieldChange: FieldChange = {
-		fieldKind: genericFieldKind.identifier,
-		change: fieldChangeset,
-	};
+	setInChangeAtomIdMap(nodeChanges, nodeId, nodeChange);
 
-	return buildModularChangesetFromField({
-		...props,
-		path: { parent: path.parent, field: path.parentField },
-		fieldChange,
-		localCrossFieldKeys: [],
-		childId: nodeId,
-	});
+	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,
+		};
+
+		return buildModularChangesetFromField({
+			...props,
+			path: { parent: path.parent, field: path.parentField },
+			fieldChange,
+			localCrossFieldKeys: [],
+			childId: nodeId,
+		});
+	}
 }
 
 export interface FieldEditDescription {
 	type: "field";
-	field: FieldUpPath;
+	field: NormalizedFieldUpPath;
 	fieldKind: FieldKindIdentifier;
 	change: FieldChangeset;
 	revision: RevisionTag;
@@ -2965,6 +3854,23 @@ 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;
@@ -2975,25 +3881,16 @@ 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 revisions = new Set<RevisionTag>();
-	const rolledBackRevisions: RevisionTag[] = [];
-	for (const info of revInfos) {
-		revisions.add(info.revision);
-		if (info.rollbackOf !== undefined) {
-			rolledBackRevisions.push(info.rollbackOf);
-		}
-	}
-
-	rolledBackRevisions.reverse();
-	for (const revision of rolledBackRevisions) {
-		if (!revisions.has(revision)) {
-			revInfos.push({ revision });
+		const infosToAdd = revisionInfoFromTaggedChange(taggedChange);
+		for (const info of infosToAdd) {
+			if (!revisions.has(info.revision)) {
+				revisions.add(info.revision);
+				revInfos.push(info);
+			}
 		}
 	}
 
@@ -3016,25 +3913,28 @@ function revisionInfoFromTaggedChange(
 	return revInfos;
 }
 
-function fieldChangeFromId(
-	fields: FieldChangeMap,
-	nodes: ChangeAtomIdBTree<NodeChangeset>,
-	id: FieldId,
-): FieldChange {
-	const fieldMap = fieldMapFromNodeId(fields, nodes, id.nodeId);
+function fieldChangeFromId(change: ModularChangeset, id: FieldId): FieldChange {
+	const fieldId = normalizeFieldId(id, change.nodeAliases);
+	const fieldMap = fieldMapFromNodeId(
+		change.fieldChanges,
+		change.nodeChanges,
+		change.nodeAliases,
+		fieldId.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, nodeId);
+	const node = nodeChangeFromId(nodes, aliases, nodeId);
 	assert(node.fieldChanges !== undefined, 0x9c9 /* Expected node to have field changes */);
 	return node.fieldChanges;
 }
@@ -3051,17 +3951,26 @@ function rebasedNodeIdFromBaseNodeId(table: RebaseTable, baseId: NodeId): NodeId
 	return getFromChangeAtomIdMap(table.baseToRebasedNodeId, baseId) ?? baseId;
 }
 
-function nodeChangeFromId(nodes: ChangeAtomIdBTree<NodeChangeset>, id: NodeId): NodeChangeset {
-	const node = getFromChangeAtomIdMap(nodes, id);
+function nodeChangeFromId(
+	nodes: ChangeAtomIdBTree<NodeChangeset>,
+	aliases: ChangeAtomIdBTree<NodeId>,
+	id: NodeId,
+): NodeChangeset {
+	const normalizedId = normalizeNodeId(id, aliases);
+	const node = getFromChangeAtomIdMap(nodes, normalizedId);
 	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) };
@@ -3070,28 +3979,39 @@ function cloneNodeChangeset(nodeChangeset: NodeChangeset): NodeChangeset {
 	return { ...nodeChangeset };
 }
 
-function replaceFieldIdRevision(
-	fieldId: FieldId,
-	oldRevisions: Set<RevisionTag | undefined>,
-	newRevision: RevisionTag | undefined,
-): FieldId {
+function replaceNodeLocationRevision(
+	location: NodeLocation,
+	replacer: RevisionReplacer,
+): NodeLocation {
+	return location.field === undefined
+		? { root: replacer.getUpdatedAtomId(location.root) }
+		: { field: replaceFieldIdRevision(location.field, replacer) };
+}
+
+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 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);
-}
+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 */);
 
-function getFieldsForCrossFieldKey(
+	if (location.field !== undefined) {
+		return { field: normalizeFieldId(location.field, changeset.nodeAliases) };
+	}
+
+	return location;
+}
+
+function getFieldsForCrossFieldKey(
 	changeset: ModularChangeset,
 	key: CrossFieldKey,
 	count: number,
@@ -3101,21 +4021,49 @@ 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
  */
-function normalizeNodeId(nodeId: NodeId, nodeAliases: ChangeAtomIdBTree<NodeId>): NodeId {
+export 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) {
@@ -3125,6 +4073,16 @@ function normalizeNodeId(nodeId: NodeId, nodeAliases: ChangeAtomIdBTree<NodeId>)
 		}
 
 		currentId = dealiased;
+
+		if (cycleProbeId !== undefined) {
+			cycleProbeId = getFromChangeAtomIdMap(nodeAliases, cycleProbeId);
+		}
+
+		if (cycleProbeId !== undefined) {
+			cycleProbeId = getFromChangeAtomIdMap(nodeAliases, cycleProbeId);
+		}
+
+		assert(!areEqualChangeAtomIdOpts(cycleProbeId, currentId), "Alias cycle detected");
 	}
 }
 
@@ -3135,22 +4093,936 @@ function hasConflicts(change: ModularChangeset): boolean {
 interface ModularChangesetContent {
 	fieldChanges: FieldChangeMap;
 	nodeChanges: ChangeAtomIdBTree<NodeChangeset>;
-	nodeToParent: ChangeAtomIdBTree<FieldId>;
+	nodeToParent: ChangeAtomIdBTree<NodeLocation>;
+	rootNodes: RootNodeTable;
 	nodeAliases: ChangeAtomIdBTree<NodeId>;
 	crossFieldKeys: CrossFieldKeyTable;
 }
 
-function getFromChangeAtomIdMap<T>(
-	map: ChangeAtomIdBTree<T>,
+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) {
+			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,
+			);
+		} else {
+			affectedBaseFields.set(fieldIdKeyFromFieldId(baseAttachEntry.value), true);
+			rebasedNodeToParent.delete(detachIdKey);
+		}
+	}
+
+	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) {
+		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,
+		);
+	} else {
+		// 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,
+		);
+	}
+
+	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,
+): readonly RevisionInfo[] {
+	if (
+		revisions1?.length === 1 &&
+		revisions2?.length === 1 &&
+		revisions1[0]?.revision === revisions2[0]?.revision
+	) {
+		// This is a special case where we are composing two changesets from the same transaction.
+		// We return one of the input arrays to avoid duplicating revision entries.
+		return revisions1;
+	}
+	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) {
+			const fieldId = getFieldsForCrossFieldKey(
+				change1,
+				{ ...detachId1, target: CrossFieldTarget.Source },
+				1,
+			)[0];
+
+			if (fieldId === undefined) {
+				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,
+				);
+			} else {
+				// 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 {
+			pendingCompositions.nodeIdsToCompose.push([nodeId1, nodeId2]);
+		}
+	}
+
+	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` 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,
+		);
+	} else {
+		// `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,
+		);
+	}
+
+	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,
-): T | undefined {
-	return map.get([id.revision, id.localId]);
+	count: number,
+): RangeQueryResultFragment<boolean>[] {
+	return table
+		.getAll2({ ...id, target: CrossFieldTarget.Destination }, count)
+		.map((entry) => ({ ...entry, value: entry.value !== undefined }));
 }
 
-function setInChangeAtomIdMap<T>(map: ChangeAtomIdBTree<T>, id: ChangeAtomId, value: T): void {
-	map.set([id.revision, id.localId], value);
+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 }));
 }
 
-function areEqualFieldIds(a: FieldId, b: FieldId): boolean {
-	return areEqualChangeAtomIdOpts(a.nodeId, b.nodeId) && a.field === b.field;
+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,
+	replacer: RevisionReplacer,
+	nodeAliases: ChangeAtomIdBTree<NodeId>,
+): RootNodeTable {
+	const oldToNewId = table.oldToNewId.mapEntries(
+		(id) => replacer.getUpdatedAtomId(id),
+		(id) => replacer.getUpdatedAtomId(id),
+	);
+
+	const newToOldId = table.newToOldId.mapEntries(
+		(id) => replacer.getUpdatedAtomId(id),
+		(id) => replacer.getUpdatedAtomId(id),
+	);
+
+	const nodeChanges: ChangeAtomIdBTree<NodeId> = replaceIdMapRevisions(
+		table.nodeChanges,
+		replacer,
+		(nodeId) => replacer.getUpdatedAtomId(normalizeNodeId(nodeId, nodeAliases)),
+	);
+
+	const detachLocations = table.detachLocations.mapEntries(
+		(id) => replacer.getUpdatedAtomId(id),
+		(fieldId) => replaceFieldIdRevision(normalizeFieldId(fieldId, nodeAliases), replacer),
+	);
+
+	const outputDetachLocations = table.outputDetachLocations.mapEntries(
+		(id) => replacer.getUpdatedAtomId(id),
+		(fieldId) => replaceFieldIdRevision(normalizeFieldId(fieldId, nodeAliases), replacer),
+	);
+
+	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
+		: { ...entry, detachId: offsetChangeAtomId(entry.detachId, count) };
+}
+
+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(),
+	};
+}
+
+export function validateChangeset(
+	change: ModularChangeset,
+	fieldKinds: ReadonlyMap<FieldKindIdentifier, FlexFieldKind>,
+): void {
+	const unreachableNodes: ChangeAtomIdBTree<NodeLocation> = brand(change.nodeToParent.clone());
+
+	const unreachableCFKs = change.crossFieldKeys.clone();
+
+	validateFieldChanges(
+		fieldKinds,
+		change,
+		change.fieldChanges,
+		undefined,
+		unreachableNodes,
+		unreachableCFKs,
+	);
+
+	for (const [[revision, localId], node] of change.nodeChanges.entries()) {
+		if (node.fieldChanges === undefined) {
+			continue;
+		}
+
+		const nodeId = normalizeNodeId({ revision, localId }, change.nodeAliases);
+		validateFieldChanges(
+			fieldKinds,
+			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 fieldChanges = nodeChangeFromId(
+			change.nodeChanges,
+			change.nodeAliases,
+			nodeId,
+		).fieldChanges;
+
+		if (fieldChanges !== undefined) {
+			validateFieldChanges(
+				fieldKinds,
+				change,
+				fieldChanges,
+				normalizedNodeId,
+				unreachableNodes,
+				unreachableCFKs,
+			);
+		}
+	}
+
+	assert(unreachableNodes.size === 0, "Unreachable nodes found");
+	assert(unreachableCFKs.entries().length === 0, "Unreachable cross-field keys found");
+}
+
+/**
+ * Asserts that each node has a correct entry in `change.nodeToParent`,
+ * and each cross field key has a correct entry in `change.crossFieldKeys`.
+ * @returns the number of children found.
+ */
+function validateFieldChanges(
+	fieldKinds: ReadonlyMap<FieldKindIdentifier, FlexFieldKind>,
+	change: ModularChangeset,
+	fieldChanges: FieldChangeMap,
+	nodeParent: NodeId | undefined,
+	unreachableNodes: ChangeAtomIdBTree<NodeLocation>,
+	unreachableCFKs: CrossFieldRangeTable<FieldId>,
+): void {
+	for (const [field, fieldChange] of fieldChanges.entries()) {
+		const fieldId = { nodeId: nodeParent, field };
+		const handler = getChangeHandler(fieldKinds, fieldChange.fieldKind);
+		for (const [child, _index] of handler.getNestedChanges(fieldChange.change)) {
+			const parentFieldId = getNodeParent(change, child);
+			assert(
+				parentFieldId.field !== undefined && areEqualFieldIds(parentFieldId.field, fieldId),
+				0xa4e /* Inconsistent node parentage */,
+			);
+
+			unreachableNodes.delete([child.revision, child.localId]);
+		}
+
+		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);
+		}
+	}
 }