@fluidframework/tree 2.90.0-378676 → 2.91.0

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

@@ -28,10 +28,12 @@ import {
 	EditBuilder,
 	type FieldKey,
 	type FieldKindIdentifier,
+	type FieldUpPath,
 	type RevisionInfo,
 	type RevisionMetadataSource,
 	type RevisionTag,
 	type TaggedChange,
+	type UpPath,
 	makeDetachedNodeId,
 	revisionMetadataSourceFromInfo,
 	areEqualChangeAtomIds,
@@ -39,18 +41,10 @@ import {
 	areEqualChangeAtomIdOpts,
 	tagChange,
 	makeAnonChange,
+	newChangeAtomIdRangeMap,
 	type DeltaDetachedNodeChanges,
 	type DeltaDetachedNodeRename,
 	mapTaggedChange,
-	newChangeAtomIdRangeMap,
-	newChangeAtomIdTransform,
-	type ChangeAtomIdRangeMap,
-	offsetChangeAtomId,
-	type NormalizedUpPath,
-	type NormalizedFieldUpPath,
-	isDetachedUpPathRoot,
-	subtractChangeAtomIds,
-	makeChangeAtomId,
 	type RevisionReplacer,
 	comparePartialRevisions,
 	comparePartialChangesetLocalIds,
@@ -68,15 +62,12 @@ import {
 	type TupleBTree,
 	RangeMap,
 	balancedReduce,
+	newTupleBTree,
 	compareStrings,
 	createTupleComparator,
-	type RangeQueryEntry,
-	type RangeQueryResultFragment,
-	newTupleBTree,
 } from "../../util/index.js";
 import {
 	getFromChangeAtomIdMap,
-	rangeQueryChangeAtomIdMap,
 	newChangeAtomIdBTree,
 	setInChangeAtomIdMap,
 	type ChangeAtomIdBTree,
@@ -84,13 +75,10 @@ import {
 import type { TreeChunk } from "../chunked-forest/index.js";
 
 import {
-	type ComposeNodeManager,
+	type CrossFieldManager,
 	type CrossFieldMap,
-	NodeMoveType,
-	type DetachedNodeEntry,
-	type InvertNodeManager,
-	type RebaseDetachedNodeEntry,
-	type RebaseNodeManager,
+	CrossFieldTarget,
+	getFirstFromCrossFieldMap,
 	setInCrossFieldMap,
 } from "./crossFieldQueries.js";
 import {
@@ -105,20 +93,15 @@ import {
 	type CrossFieldKey,
 	type CrossFieldKeyRange,
 	type CrossFieldKeyTable,
-	type CrossFieldRangeTable,
 	type FieldChange,
 	type FieldChangeMap,
 	type FieldChangeset,
 	type FieldId,
 	type ModularChangeset,
-	type ModularEditorOptions,
-	newCrossFieldRangeTable,
+	newCrossFieldKeyTable,
 	type NoChangeConstraint,
 	type NodeChangeset,
 	type NodeId,
-	type NodeLocation,
-	type RebaseVersion,
-	type RootNodeTable,
 } from "./modularChangeTypes.js";
 
 /**
@@ -205,14 +188,14 @@ export class ModularChangeFamily
 	}
 
 	public compose(changes: TaggedChange<ModularChangeset>[]): ModularChangeset {
-		const { maxId } = getRevInfoFromTaggedChanges(changes);
+		const { revInfos, maxId } = getRevInfoFromTaggedChanges(changes);
 		const idState: IdAllocationState = { maxId };
 
 		const pairwiseDelegate = (
 			left: ModularChangeset,
 			right: ModularChangeset,
 		): ModularChangeset => {
-			return this.composePair(left, right, idState);
+			return this.composePair(left, right, revInfos, idState);
 		};
 
 		const innerChanges = changes.map((change) => change.change);
@@ -222,11 +205,10 @@ export class ModularChangeFamily
 	private composePair(
 		change1: ModularChangeset,
 		change2: ModularChangeset,
+		revInfos: RevisionInfo[],
 		idState: IdAllocationState,
 	): ModularChangeset {
-		const revInfos = composeRevInfos(change1.revisions, change2.revisions);
-
-		const { fieldChanges, nodeChanges, nodeToParent, nodeAliases, crossFieldKeys, rootNodes } =
+		const { fieldChanges, nodeChanges, nodeToParent, nodeAliases, crossFieldKeys } =
 			this.composeAllFields(change1, change2, revInfos, idState);
 
 		const { allBuilds, allDestroys, allRefreshers } = composeBuildsDestroysAndRefreshers(
@@ -239,8 +221,7 @@ export class ModularChangeFamily
 		const noChangeConstraintOnRevert =
 			change1.noChangeConstraintOnRevert ?? change2.noChangeConstraintOnRevert;
 
-		const composed = makeModularChangeset({
-			rebaseVersion: Math.max(change1.rebaseVersion, change2.rebaseVersion) as RebaseVersion,
+		return makeModularChangeset({
 			fieldChanges,
 			nodeChanges,
 			nodeToParent,
@@ -248,23 +229,18 @@ export class ModularChangeFamily
 			crossFieldKeys,
 			maxId: idState.maxId,
 			revisions: revInfos,
-			rootNodes,
+			noChangeConstraint,
+			noChangeConstraintOnRevert,
 			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: readonly RevisionInfo[],
+		revInfos: RevisionInfo[],
 		idState: IdAllocationState,
 	): ModularChangesetContent {
 		// Our current cell ordering scheme in sequences depends on being able to rebase over a change with conflicts.
@@ -288,38 +264,14 @@ export class ModularChangeFamily
 			mergeTupleBTrees(change1.nodeChanges, change2.nodeChanges),
 		);
 
-		const composedNodeToParent: ChangeAtomIdBTree<NodeLocation> = brand(
+		const composedNodeToParent: ChangeAtomIdBTree<FieldId> = brand(
 			mergeTupleBTrees(change1.nodeToParent, change2.nodeToParent),
 		);
 		const composedNodeAliases: ChangeAtomIdBTree<NodeId> = brand(
 			mergeTupleBTrees(change1.nodeAliases, change2.nodeAliases),
 		);
 
-		const pendingCompositions: PendingCompositions = {
-			nodeIdsToCompose: [],
-			affectedBaseFields: newFieldIdKeyBTree(),
-		};
-
-		const movedCrossFieldKeys: CrossFieldKeyTable = newCrossFieldRangeTable();
-		const removedCrossFieldKeys: CrossFieldRangeTable<boolean> = newCrossFieldRangeTable();
-
-		const composedRoots = composeRootTables(
-			change1,
-			change2,
-			composedNodeToParent,
-			movedCrossFieldKeys,
-			removedCrossFieldKeys,
-			pendingCompositions,
-		);
-
-		const crossFieldTable = newComposeTable(
-			change1,
-			change2,
-			composedRoots,
-			movedCrossFieldKeys,
-			removedCrossFieldKeys,
-			pendingCompositions,
-		);
+		const crossFieldTable = newComposeTable(change1, change2, composedNodeToParent);
 
 		const composedFields = this.composeFieldMaps(
 			change1.fieldChanges,
@@ -340,32 +292,17 @@ export class ModularChangeFamily
 			revisionMetadata,
 		);
 
-		for (const entry of crossFieldTable.renamesToDelete.entries()) {
-			deleteNodeRenameFrom(crossFieldTable.composedRootNodes, entry.start, entry.length);
-		}
-
-		for (const [nodeId, location] of crossFieldTable.movedNodeToParent.entries()) {
-			// Moved nodes are from change2.
-			// If there is a corresponding node in change1, then composedNodeToParent will already have the correct entry,
-			// because the location of the node is the same in change1 and the composed change
-			// (since they have the same input context).
-			if (crossFieldTable.newToBaseNodeId.get(nodeId) === undefined) {
-				composedNodeToParent.set(nodeId, location);
-			}
-		}
-
+		// Currently no field kinds require making changes to cross-field keys during composition, so we can just merge the two tables.
+		const composedCrossFieldKeys = RangeMap.union(
+			change1.crossFieldKeys,
+			change2.crossFieldKeys,
+		);
 		return {
 			fieldChanges: composedFields,
 			nodeChanges: composedNodeChanges,
 			nodeToParent: composedNodeToParent,
 			nodeAliases: composedNodeAliases,
-			crossFieldKeys: composeCrossFieldKeyTables(
-				change1.crossFieldKeys,
-				change2.crossFieldKeys,
-				crossFieldTable.movedCrossFieldKeys,
-				crossFieldTable.removedCrossFieldKeys,
-			),
-			rootNodes: composedRoots,
+			crossFieldKeys: composedCrossFieldKeys,
 		};
 	}
 
@@ -377,16 +314,17 @@ export class ModularChangeFamily
 	): void {
 		const context = crossFieldTable.fieldToContext.get(fieldChange);
 		assert(context !== undefined, 0x8cc /* Should have context for every invalidated field */);
-		const { change1: fieldChange1, change2: fieldChange2, composedChange } = context;
-
-		crossFieldTable.pendingCompositions.affectedBaseFields.delete(
-			fieldIdKeyFromFieldId(context.fieldId),
-		);
+		const { fieldId, change1: fieldChange1, change2: fieldChange2, composedChange } = context;
 
 		const rebaser = getChangeHandler(this.fieldKinds, composedChange.fieldKind).rebaser;
 		const composeNodes = (child1: NodeId | undefined, child2: NodeId | undefined): NodeId => {
-			if (child1 !== undefined && child2 !== undefined) {
-				addNodesToCompose(crossFieldTable, child1, child2);
+			if (
+				child1 !== undefined &&
+				child2 !== undefined &&
+				getFromChangeAtomIdMap(crossFieldTable.newToBaseNodeId, child2) === undefined
+			) {
+				setInChangeAtomIdMap(crossFieldTable.newToBaseNodeId, child2, child1);
+				crossFieldTable.pendingCompositions.nodeIdsToCompose.push([child1, child2]);
 			}
 
 			return child1 ?? child2 ?? fail(0xb22 /* Should not compose two undefined nodes */);
@@ -397,7 +335,7 @@ export class ModularChangeFamily
 			fieldChange2,
 			composeNodes,
 			genId,
-			new ComposeNodeManagerI(crossFieldTable, context.fieldId, false),
+			new ComposeManager(crossFieldTable, fieldChange, fieldId, false),
 			revisionMetadata,
 		);
 		composedChange.change = brand(amendedChange);
@@ -409,7 +347,7 @@ export class ModularChangeFamily
 	 * - discovering that two node changesets refer to the same node (`nodeIdsToCompose`)
 	 * - a previously composed field being invalidated by a cross field effect (`invalidatedFields`)
 	 * - a field which was copied directly from an input changeset being invalidated by a cross field effect
-	 * (`affectedBaseFields`)
+	 * (`affectedBaseFields` and `affectedNewFields`)
 	 *
 	 * Updating an element may invalidate further elements. This function runs until there is no more invalidation.
 	 */
@@ -417,59 +355,72 @@ export class ModularChangeFamily
 		table: ComposeTable,
 		composedFields: FieldChangeMap,
 		composedNodes: ChangeAtomIdBTree<NodeChangeset>,
-		composedNodeToParent: ChangeAtomIdBTree<NodeLocation>,
+		composedNodeToParent: ChangeAtomIdBTree<FieldId>,
 		nodeAliases: ChangeAtomIdBTree<NodeId>,
 		genId: IdAllocator,
 		metadata: RevisionMetadataSource,
 	): void {
 		const pending = table.pendingCompositions;
-		while (pending.nodeIdsToCompose.length > 0 || pending.affectedBaseFields.length > 0) {
-			this.processPendingNodeCompositions(
+		while (
+			table.invalidatedFields.size > 0 ||
+			pending.nodeIdsToCompose.length > 0 ||
+			pending.affectedBaseFields.length > 0 ||
+			pending.affectedNewFields.length > 0
+		) {
+			// Note that the call to `composeNodesById` can add entries to `crossFieldTable.nodeIdPairs`.
+			for (const [id1, id2] of pending.nodeIdsToCompose) {
+				this.composeNodesById(
+					table.baseChange.nodeChanges,
+					table.newChange.nodeChanges,
+					composedNodes,
+					composedNodeToParent,
+					nodeAliases,
+					id1,
+					id2,
+					genId,
+					table,
+					metadata,
+				);
+			}
+
+			pending.nodeIdsToCompose.length = 0;
+
+			this.composeAffectedFields(
 				table,
+				table.baseChange,
+				true,
+				pending.affectedBaseFields,
+				composedFields,
 				composedNodes,
-				composedNodeToParent,
-				nodeAliases,
 				genId,
 				metadata,
 			);
 
 			this.composeAffectedFields(
 				table,
-				table.baseChange,
-				pending.affectedBaseFields,
+				table.newChange,
+				false,
+				pending.affectedNewFields,
 				composedFields,
 				composedNodes,
 				genId,
 				metadata,
 			);
+
+			this.processInvalidatedCompositions(table, genId, metadata);
 		}
 	}
 
-	private processPendingNodeCompositions(
+	private processInvalidatedCompositions(
 		table: ComposeTable,
-		composedNodes: ChangeAtomIdBTree<NodeChangeset>,
-		composedNodeToParent: ChangeAtomIdBTree<NodeLocation>,
-		nodeAliases: ChangeAtomIdBTree<NodeId>,
 		genId: IdAllocator,
 		metadata: RevisionMetadataSource,
 	): void {
-		// Note that the call to `composeNodesById` can add entries to `crossFieldTable.nodeIdPairs`.
-		for (const [id1, id2] of table.pendingCompositions.nodeIdsToCompose) {
-			this.composeNodesById(
-				table.baseChange,
-				table.newChange,
-				composedNodes,
-				composedNodeToParent,
-				nodeAliases,
-				id1,
-				id2,
-				genId,
-				table,
-				metadata,
-			);
+		const fieldsToUpdate = table.invalidatedFields;
+		table.invalidatedFields = new Set();
+		for (const fieldChange of fieldsToUpdate) {
+			this.composeInvalidatedField(fieldChange, table, genId, metadata);
 		}
-
-		table.pendingCompositions.nodeIdsToCompose.length = 0;
 	}
 
 	/**
@@ -486,77 +437,64 @@ export class ModularChangeFamily
 	private composeAffectedFields(
 		table: ComposeTable,
 		change: ModularChangeset,
+		areBaseFields: boolean,
 		affectedFields: BTree<FieldIdKey, true>,
 		composedFields: FieldChangeMap,
 		composedNodes: ChangeAtomIdBTree<NodeChangeset>,
 		genId: IdAllocator,
 		metadata: RevisionMetadataSource,
 	): void {
-		const fieldsToProcess = affectedFields.clone();
-		affectedFields.clear();
-
-		for (const fieldIdKey of fieldsToProcess.keys()) {
-			const fieldId = fieldIdFromFieldIdKey(fieldIdKey);
-			const fieldChange = fieldChangeFromId(change, fieldId);
+		for (const fieldIdKey of affectedFields.keys()) {
+			const fieldId = normalizeFieldId(fieldIdFromFieldIdKey(fieldIdKey), change.nodeAliases);
+			const fieldChange = fieldChangeFromId(change.fieldChanges, change.nodeChanges, fieldId);
 
 			if (
 				table.fieldToContext.has(fieldChange) ||
 				table.newFieldToBaseField.has(fieldChange)
 			) {
-				this.composeInvalidatedField(fieldChange, table, genId, metadata);
-			} else {
-				this.composeFieldWithNoNewChange(
-					table,
-					fieldChange,
-					fieldId,
-					composedFields,
-					composedNodes,
-					genId,
-					metadata,
-				);
+				// This function handles fields which were not part of the intersection of the two changesets but which need to be updated anyway.
+				// If we've already processed this field then either it is up to date
+				// or there is pending inval which will be handled in processInvalidatedCompositions.
+				continue;
 			}
-		}
-	}
 
-	private composeFieldWithNoNewChange(
-		table: ComposeTable,
-		baseFieldChange: FieldChange,
-		fieldId: FieldId,
-		composedFields: FieldChangeMap,
-		composedNodes: ChangeAtomIdBTree<NodeChangeset>,
-		genId: IdAllocator,
-		metadata: RevisionMetadataSource,
-	): void {
-		const emptyChange = this.createEmptyFieldChange(baseFieldChange.fieldKind);
+			const emptyChange = this.createEmptyFieldChange(fieldChange.fieldKind);
+			const [change1, change2] = areBaseFields
+				? [fieldChange, emptyChange]
+				: [emptyChange, fieldChange];
 
-		const composedField = this.composeFieldChanges(
-			fieldId,
-			baseFieldChange,
-			emptyChange,
-			genId,
-			table,
-			metadata,
-		);
+			const composedField = this.composeFieldChanges(
+				fieldId,
+				change1,
+				change2,
+				genId,
+				table,
+				metadata,
+			);
 
-		if (fieldId.nodeId === undefined) {
-			composedFields.set(fieldId.field, composedField);
-			return;
-		}
+			if (fieldId.nodeId === undefined) {
+				composedFields.set(fieldId.field, composedField);
+				continue;
+			}
 
-		const nodeId = normalizeNodeId(
-			getFromChangeAtomIdMap(table.newToBaseNodeId, fieldId.nodeId) ?? fieldId.nodeId,
-			table.baseChange.nodeAliases,
-		);
+			const nodeId =
+				getFromChangeAtomIdMap(table.newToBaseNodeId, fieldId.nodeId) ?? fieldId.nodeId;
 
-		// We clone the node changeset before mutating it, as it may be from one of the input changesets.
-		const nodeChangeset: Mutable<NodeChangeset> = cloneNodeChangeset(
-			nodeChangeFromId(composedNodes, table.baseChange.nodeAliases, nodeId),
-		);
-		setInChangeAtomIdMap(composedNodes, nodeId, nodeChangeset);
+			let nodeChangeset = nodeChangeFromId(composedNodes, nodeId);
+			if (!table.composedNodes.has(nodeChangeset)) {
+				nodeChangeset = cloneNodeChangeset(nodeChangeset);
+				setInChangeAtomIdMap(composedNodes, nodeId, nodeChangeset);
+			}
 
-		nodeChangeset.fieldChanges ??= new Map();
+			// eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing -- using ??= could change behavior if value is falsy
+			if (nodeChangeset.fieldChanges === undefined) {
+				nodeChangeset.fieldChanges = new Map();
+			}
+
+			nodeChangeset.fieldChanges.set(fieldId.field, composedField);
+		}
 
-		nodeChangeset.fieldChanges.set(fieldId.field, composedField);
+		affectedFields.clear();
 	}
 
 	private composeFieldMaps(
@@ -575,18 +513,6 @@ 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
 					? fieldChange1
@@ -618,7 +544,7 @@ export class ModularChangeFamily
 	 * will be added to `crossFieldTable.pendingCompositions.nodeIdsToCompose`.
 	 *
 	 * Any fields which had cross-field information sent to them as part of this field composition
-	 * will be added to `affectedBaseFields` in `crossFieldTable.pendingCompositions`.
+	 * will be added to either `affectedBaseFields` or `affectedNewFields` in `crossFieldTable.pendingCompositions`.
 	 *
 	 * Any composed `FieldChange` which is invalidated by new cross-field information will be added to `crossFieldTable.invalidatedFields`.
 	 */
@@ -637,14 +563,15 @@ export class ModularChangeFamily
 			change2: change2Normalized,
 		} = this.normalizeFieldChanges(change1, change2);
 
-		const manager = new ComposeNodeManagerI(crossFieldTable, fieldId);
+		const manager = new ComposeManager(crossFieldTable, change1, fieldId);
 
 		const composedChange = changeHandler.rebaser.compose(
 			change1Normalized,
 			change2Normalized,
 			(child1, child2) => {
 				if (child1 !== undefined && child2 !== undefined) {
-					addNodesToCompose(crossFieldTable, child1, child2);
+					setInChangeAtomIdMap(crossFieldTable.newToBaseNodeId, child2, child1);
+					crossFieldTable.pendingCompositions.nodeIdsToCompose.push([child1, child2]);
 				}
 				return child1 ?? child2 ?? fail(0xb23 /* Should not compose two undefined nodes */);
 			},
@@ -670,19 +597,19 @@ export class ModularChangeFamily
 	}
 
 	private composeNodesById(
-		change1: ModularChangeset,
-		change2: ModularChangeset,
+		nodeChanges1: ChangeAtomIdBTree<NodeChangeset>,
+		nodeChanges2: ChangeAtomIdBTree<NodeChangeset>,
 		composedNodes: ChangeAtomIdBTree<NodeChangeset>,
-		composedNodeToParent: ChangeAtomIdBTree<NodeLocation>,
-		composedAliases: ChangeAtomIdBTree<NodeId>,
+		composedNodeToParent: ChangeAtomIdBTree<FieldId>,
+		nodeAliases: ChangeAtomIdBTree<NodeId>,
 		id1: NodeId,
 		id2: NodeId,
 		idAllocator: IdAllocator,
 		crossFieldTable: ComposeTable,
 		revisionMetadata: RevisionMetadataSource,
 	): void {
-		const nodeChangeset1 = nodeChangeFromId(change1.nodeChanges, change1.nodeAliases, id1);
-		const nodeChangeset2 = nodeChangeFromId(change2.nodeChanges, change2.nodeAliases, id2);
+		const nodeChangeset1 = nodeChangeFromId(nodeChanges1, id1);
+		const nodeChangeset2 = nodeChangeFromId(nodeChanges2, id2);
 		const composedNodeChangeset = this.composeNodeChanges(
 			id1,
 			nodeChangeset1,
@@ -697,11 +624,13 @@ export class ModularChangeFamily
 		if (!areEqualChangeAtomIds(id1, id2)) {
 			composedNodes.delete([id2.revision, id2.localId]);
 			composedNodeToParent.delete([id2.revision, id2.localId]);
-			setInChangeAtomIdMap(composedAliases, id2, id1);
+			setInChangeAtomIdMap(nodeAliases, id2, id1);
 
 			// We need to delete id1 to avoid forming a cycle in case id1 already had an alias.
-			composedAliases.delete([id1.revision, id1.localId]);
+			nodeAliases.delete([id1.revision, id1.localId]);
 		}
+
+		crossFieldTable.composedNodes.add(composedNodeChangeset);
 	}
 
 	private composeNodeChanges(
@@ -736,7 +665,7 @@ export class ModularChangeFamily
 			revisionMetadata,
 		);
 
-		const composedNodeChange: Mutable<NodeChangeset> = {};
+		const composedNodeChange: NodeChangeset = {};
 
 		if (composedFieldChanges.size > 0) {
 			composedNodeChange.fieldChanges = composedFieldChanges;
@@ -782,7 +711,6 @@ export class ModularChangeFamily
 
 		if (hasConflicts(change.change)) {
 			return makeModularChangeset({
-				rebaseVersion: change.change.rebaseVersion,
 				maxId: change.change.maxId as number,
 				revisions: revInfos,
 				destroys,
@@ -791,20 +719,10 @@ export class ModularChangeFamily
 
 		const genId: IdAllocator = idAllocatorFromMaxId(change.change.maxId ?? -1);
 
-		const invertedNodeToParent: ChangeAtomIdBTree<NodeLocation> = brand(
-			change.change.nodeToParent.clone(),
-		);
-
 		const crossFieldTable: InvertTable = {
-			change: change.change,
-			isRollback,
-			entries: newChangeAtomIdRangeMap(),
+			...newCrossFieldTable<FieldChange>(),
 			originalFieldToContext: new Map(),
-			invertRevision: revisionForInvert,
-			invertedNodeToParent,
-			invalidatedFields: new Set(),
-			invertedRoots: invertRootTable(change.change, invertedNodeToParent, isRollback),
-			attachToDetachId: newChangeAtomIdTransform(),
+			invertedNodeToParent: brand(change.change.nodeToParent.clone()),
 		};
 		const { revInfos: oldRevInfos } = getRevInfoFromTaggedChanges([change]);
 		const revisionMetadata = revisionMetadataSourceFromInfo(oldRevInfos);
@@ -845,7 +763,7 @@ export class ModularChangeFamily
 					context !== undefined,
 					0x851 /* Should have context for every invalidated field */,
 				);
-				const { invertedField } = context;
+				const { invertedField, fieldId } = context;
 
 				const amendedChange = getChangeHandler(
 					this.fieldKinds,
@@ -855,7 +773,7 @@ export class ModularChangeFamily
 					isRollback,
 					genId,
 					revisionForInvert,
-					new InvertNodeManagerI(crossFieldTable, context.fieldId),
+					new InvertManager(crossFieldTable, fieldChange, fieldId),
 					revisionMetadata,
 				);
 				invertedField.change = brand(amendedChange);
@@ -864,14 +782,10 @@ export class ModularChangeFamily
 
 		const crossFieldKeys = this.makeCrossFieldKeyTable(invertedFields, invertedNodes);
 
-		this.processInvertRenames(crossFieldTable);
-
 		return makeModularChangeset({
-			rebaseVersion: change.change.rebaseVersion,
 			fieldChanges: invertedFields,
 			nodeChanges: invertedNodes,
 			nodeToParent: crossFieldTable.invertedNodeToParent,
-			rootNodes: crossFieldTable.invertedRoots,
 			nodeAliases: change.change.nodeAliases,
 			crossFieldKeys,
 			maxId: genId.getMaxId(),
@@ -897,7 +811,7 @@ export class ModularChangeFamily
 
 		for (const [field, fieldChange] of changes) {
 			const fieldId = { nodeId: parentId, field };
-			const manager = new InvertNodeManagerI(crossFieldTable, fieldId);
+			const manager = new InvertManager(crossFieldTable, fieldChange, fieldId);
 			const invertedChange = getChangeHandler(
 				this.fieldKinds,
 				fieldChange.fieldKind,
@@ -934,7 +848,7 @@ export class ModularChangeFamily
 		revisionMetadata: RevisionMetadataSource,
 		revisionForInvert: RevisionTag,
 	): NodeChangeset {
-		const inverse: Mutable<NodeChangeset> = {};
+		const inverse: NodeChangeset = {};
 
 		// If the node has a constraint, it should be inverted to a node-exist-on-revert constraint. This ensure that if
 		// the inverse is inverted again, the original input constraint will be restored.
@@ -964,17 +878,6 @@ export class ModularChangeFamily
 		return inverse;
 	}
 
-	private processInvertRenames(table: InvertTable): void {
-		for (const {
-			start: newAttachId,
-			value: originalDetachId,
-			length,
-		} of table.attachToDetachId.entries()) {
-			// Note that the detach location is already set in `invertDetach`.
-			addNodeRename(table.invertedRoots, originalDetachId, newAttachId, length, undefined);
-		}
-	}
-
 	public rebase(
 		taggedChange: TaggedChange<ModularChangeset>,
 		potentiallyConflictedOver: TaggedChange<ModularChangeset>,
@@ -994,41 +897,17 @@ export class ModularChangeFamily
 		const idState: IdAllocationState = { maxId };
 		const genId: IdAllocator = idAllocatorFromState(idState);
 
-		const affectedBaseFields: TupleBTree<FieldIdKey, boolean> = newFieldIdKeyBTree();
-		const nodesToRebase: [newChangeset: NodeId, baseChangeset: NodeId][] = [];
-
-		const rebasedNodeToParent: ChangeAtomIdBTree<NodeLocation> = brand(
-			change.nodeToParent.clone(),
-		);
-
-		const rebaseVersion = Math.max(
-			change.rebaseVersion,
-			over.change.rebaseVersion,
-		) as RebaseVersion;
-
-		const rebasedRootNodes = rebaseRoots(
-			change,
-			over.change,
-			affectedBaseFields,
-			nodesToRebase,
-			rebasedNodeToParent,
-			rebaseVersion,
-		);
 		const crossFieldTable: RebaseTable = {
-			rebaseVersion,
-			entries: newDetachedEntryMap(),
+			...newCrossFieldTable<FieldChange>(),
 			newChange: change,
 			baseChange: over.change,
 			baseFieldToContext: new Map(),
-			baseRoots: over.change.rootNodes,
-			rebasedRootNodes,
 			baseToRebasedNodeId: newChangeAtomIdBTree(),
 			rebasedFields: new Set(),
-			rebasedNodeToParent,
-			rebasedDetachLocations: newChangeAtomIdRangeMap(),
-			movedDetaches: newChangeAtomIdRangeMap(),
+			rebasedNodeToParent: brand(change.nodeToParent.clone()),
+			rebasedCrossFieldKeys: change.crossFieldKeys.clone(),
 			nodeIdPairs: [],
-			affectedBaseFields,
+			affectedBaseFields: newFieldIdKeyBTree(),
 			fieldsWithUnattachedChild: new Set(),
 		};
 
@@ -1044,14 +923,13 @@ export class ModularChangeFamily
 		const rebasedNodes: ChangeAtomIdBTree<NodeChangeset> = brand(change.nodeChanges.clone());
 
 		const rebasedFields = this.rebaseIntersectingFields(
-			nodesToRebase,
 			crossFieldTable,
 			rebasedNodes,
 			genId,
 			rebaseMetadata,
 		);
 
-		this.rebaseInvalidatedFields(
+		this.rebaseInvalidatedElements(
 			rebasedFields,
 			rebasedNodes,
 			crossFieldTable,
@@ -1059,8 +937,6 @@ export class ModularChangeFamily
 			genId,
 		);
 
-		fixupRebasedDetachLocations(crossFieldTable);
-
 		const constraintState = newConstraintState(change.constraintViolationCount ?? 0);
 		const revertConstraintState = newConstraintState(
 			change.constraintViolationCountOnRevert ?? 0,
@@ -1072,52 +948,21 @@ export class ModularChangeFamily
 			constraintState.violationCount += 1;
 		}
 
-		this.updateConstraints(
+		this.updateConstraintsForFields(
 			rebasedFields,
-			rebasedNodes,
-			rebasedRootNodes,
+			NodeAttachState.Attached,
+			NodeAttachState.Attached,
 			constraintState,
 			revertConstraintState,
-		);
-
-		const fieldsWithRootMoves = getFieldsWithRootMoves(
-			crossFieldTable.rebasedRootNodes,
-			change.nodeAliases,
-		);
-
-		const fieldToRootChanges = getFieldToRootChanges(
-			crossFieldTable.rebasedRootNodes,
-			change.nodeAliases,
+			rebasedNodes,
 		);
 
 		const rebased = makeModularChangeset({
-			fieldChanges: this.pruneFieldMap(
-				rebasedFields,
-				undefined,
-				rebasedNodes,
-				crossFieldTable.rebasedNodeToParent,
-				change.nodeAliases,
-				crossFieldTable.rebasedRootNodes,
-				fieldsWithRootMoves,
-				fieldToRootChanges,
-			),
+			fieldChanges: this.pruneFieldMap(rebasedFields, rebasedNodes),
 			nodeChanges: rebasedNodes,
 			nodeToParent: crossFieldTable.rebasedNodeToParent,
-			rootNodes: this.pruneRoots(
-				crossFieldTable.rebasedRootNodes,
-				rebasedNodes,
-				crossFieldTable.rebasedNodeToParent,
-				change.nodeAliases,
-				fieldsWithRootMoves,
-				fieldToRootChanges,
-			),
-			// TODO: Do we need to include aliases for node changesets added during rebasing?
 			nodeAliases: change.nodeAliases,
-			crossFieldKeys: rebaseCrossFieldKeys(
-				change.crossFieldKeys,
-				crossFieldTable.movedDetaches,
-				crossFieldTable.rebasedDetachLocations,
-			),
+			crossFieldKeys: crossFieldTable.rebasedCrossFieldKeys,
 			maxId: idState.maxId,
 			revisions: change.revisions,
 			constraintViolationCount: constraintState.violationCount,
@@ -1127,18 +972,14 @@ export class ModularChangeFamily
 			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,
@@ -1155,18 +996,6 @@ export class ModularChangeFamily
 			metadata,
 		);
 
-		for (const [newChildChange, baseChildChange] of rootChanges) {
-			const rebasedNode = this.rebaseNodeChange(
-				newChildChange,
-				baseChildChange,
-				genId,
-				crossFieldTable,
-				metadata,
-			);
-
-			setInChangeAtomIdMap(rebasedNodes, newChildChange, rebasedNode);
-		}
-
 		// This loop processes all fields which have both base and new changes.
 		// Note that the call to `rebaseNodeChange` can add entries to `crossFieldTable.nodeIdPairs`.
 		for (const [newId, baseId, _attachState] of crossFieldTable.nodeIdPairs) {
@@ -1184,150 +1013,137 @@ export class ModularChangeFamily
 		return rebasedFields;
 	}
 
-	private rebaseFieldWithoutNewChanges(
-		baseFieldChange: FieldChange,
-		baseFieldId: FieldId,
-		crossFieldTable: RebaseTable,
+	// This processes fields which have no new changes but have been invalidated by another field.
+	private rebaseFieldsWithoutNewChanges(
 		rebasedFields: FieldChangeMap,
 		rebasedNodes: ChangeAtomIdBTree<NodeChangeset>,
+		crossFieldTable: RebaseTable,
 		genId: IdAllocator,
 		metadata: RebaseRevisionMetadata,
-
-		/**
-		 * The ID of a node in `baseFieldChange` which should be included in the rebased field change.
-		 */
-		baseNodeId?: NodeId,
 	): void {
-		// This field has no changes in the new changeset, otherwise it would have been added to
-		// `crossFieldTable.baseFieldToContext` when processing fields with both base and new changes.
-		const rebaseChild = (
-			child: NodeId | undefined,
-			baseChild: NodeId | undefined,
-			stateChange: NodeAttachState | undefined,
-		): NodeId | undefined => {
-			assert(child === undefined, 0x9c3 /* There should be no new changes in this field */);
-			if (baseChild === undefined || baseNodeId === undefined) {
-				return undefined;
-			}
+		const baseChange = crossFieldTable.baseChange;
+		for (const [revision, localId, fieldKey] of crossFieldTable.affectedBaseFields.keys()) {
+			const baseNodeId =
+				localId === undefined
+					? undefined
+					: normalizeNodeId({ revision, localId }, baseChange.nodeAliases);
 
-			return areEqualChangeAtomIds(
-				normalizeNodeId(baseChild, crossFieldTable.baseChange.nodeAliases),
+			const baseFieldChange = fieldMapFromNodeId(
+				baseChange.fieldChanges,
+				baseChange.nodeChanges,
 				baseNodeId,
-			)
-				? baseNodeId
-				: undefined;
-		};
+			).get(fieldKey);
 
-		const handler = getChangeHandler(this.fieldKinds, baseFieldChange.fieldKind);
-		const fieldChange: FieldChange = {
-			...baseFieldChange,
-			change: brand(handler.createEmpty()),
-		};
+			assert(
+				baseFieldChange !== undefined,
+				0x9c2 /* Cross field key registered for empty field */,
+			);
+			if (crossFieldTable.baseFieldToContext.has(baseFieldChange)) {
+				// This field has already been processed because there were changes to rebase.
+				continue;
+			}
 
-		const rebasedNodeId =
-			baseFieldId.nodeId === undefined
-				? undefined
-				: rebasedNodeIdFromBaseNodeId(crossFieldTable, baseFieldId.nodeId);
+			// 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 handler = getChangeHandler(this.fieldKinds, baseFieldChange.fieldKind);
+			const fieldChange: FieldChange = {
+				...baseFieldChange,
+				change: brand(handler.createEmpty()),
+			};
 
-		const fieldId: FieldId = { nodeId: rebasedNodeId, field: baseFieldId.field };
+			const rebasedNodeId =
+				baseNodeId === undefined
+					? undefined
+					: rebasedNodeIdFromBaseNodeId(crossFieldTable, baseNodeId);
 
-		const rebasedField: unknown = handler.rebaser.rebase(
-			fieldChange.change,
-			baseFieldChange.change,
-			rebaseChild,
-			genId,
-			new RebaseNodeManagerI(crossFieldTable, fieldId),
-			metadata,
-			crossFieldTable.rebaseVersion,
-		);
+			const fieldId: FieldId = { nodeId: rebasedNodeId, field: fieldKey };
+			const rebasedField: unknown = handler.rebaser.rebase(
+				fieldChange.change,
+				baseFieldChange.change,
+				noNewChangesRebaseChild,
+				genId,
+				new RebaseManager(crossFieldTable, baseFieldChange, fieldId),
+				metadata,
+			);
 
-		const rebasedFieldChange: FieldChange = {
-			...baseFieldChange,
-			change: brand(rebasedField),
-		};
+			const rebasedFieldChange: FieldChange = {
+				...baseFieldChange,
+				change: brand(rebasedField),
+			};
 
-		const context: RebaseFieldContext = {
-			newChange: fieldChange,
-			baseChange: baseFieldChange,
-			rebasedChange: rebasedFieldChange,
-			fieldId,
-			baseNodeIds: newChangeAtomIdBTree(),
-		};
+			// TODO: Deduplicate
+			crossFieldTable.baseFieldToContext.set(baseFieldChange, {
+				newChange: fieldChange,
+				baseChange: baseFieldChange,
+				rebasedChange: rebasedFieldChange,
+				fieldId,
+				baseNodeIds: [],
+			});
+			crossFieldTable.rebasedFields.add(rebasedFieldChange);
 
-		if (baseNodeId !== undefined) {
-			setInChangeAtomIdMap(context.baseNodeIds, baseNodeId, true);
+			this.attachRebasedField(
+				rebasedFields,
+				rebasedNodes,
+				crossFieldTable,
+				rebasedFieldChange,
+				fieldId,
+				genId,
+				metadata,
+			);
 		}
+	}
 
-		crossFieldTable.baseFieldToContext.set(baseFieldChange, context);
-
-		crossFieldTable.rebasedFields.add(rebasedFieldChange);
-
-		this.attachRebasedField(
+	private rebaseInvalidatedElements(
+		rebasedFields: FieldChangeMap,
+		rebasedNodes: ChangeAtomIdBTree<NodeChangeset>,
+		table: RebaseTable,
+		metadata: RebaseRevisionMetadata,
+		idAllocator: IdAllocator,
+	): void {
+		this.rebaseFieldsWithoutNewChanges(
 			rebasedFields,
 			rebasedNodes,
-			crossFieldTable,
-			rebasedFieldChange,
-			fieldId,
-			genId,
+			table,
+			idAllocator,
 			metadata,
 		);
+
+		this.rebaseFieldsWithUnattachedChild(table, metadata, idAllocator);
+		this.rebaseInvalidatedFields(table, metadata, idAllocator);
 	}
 
 	private rebaseInvalidatedFields(
-		rebasedFields: FieldChangeMap,
-		rebasedNodes: ChangeAtomIdBTree<NodeChangeset>,
 		crossFieldTable: RebaseTable,
 		rebaseMetadata: RebaseRevisionMetadata,
 		genId: IdAllocator,
 	): void {
-		while (crossFieldTable.affectedBaseFields.size > 0) {
-			const baseFields = crossFieldTable.affectedBaseFields.clone();
-			crossFieldTable.affectedBaseFields.clear();
-
-			for (const baseFieldIdKey of baseFields.keys()) {
-				const baseFieldId = normalizeFieldId(
-					fieldIdFromFieldIdKey(baseFieldIdKey),
-					crossFieldTable.baseChange.nodeAliases,
-				);
-
-				const baseField = fieldChangeFromId(crossFieldTable.baseChange, baseFieldId);
-
-				assert(
-					baseField !== undefined,
-					0x9c2 /* Cross field key registered for empty field */,
-				);
+		const fieldsToUpdate = crossFieldTable.invalidatedFields;
+		crossFieldTable.invalidatedFields = new Set();
+		for (const field of fieldsToUpdate) {
+			this.rebaseInvalidatedField(field, crossFieldTable, rebaseMetadata, genId);
+		}
+	}
 
-				const context = crossFieldTable.baseFieldToContext.get(baseField);
-				if (context === undefined) {
-					this.rebaseFieldWithoutNewChanges(
-						baseField,
-						baseFieldId,
-						crossFieldTable,
-						rebasedFields,
-						rebasedNodes,
-						genId,
-						rebaseMetadata,
-					);
-				} else {
-					this.rebaseInvalidatedField(
-						baseField,
-						crossFieldTable,
-						context,
-						rebaseMetadata,
-						genId,
-					);
-				}
-			}
+	private rebaseFieldsWithUnattachedChild(
+		table: RebaseTable,
+		metadata: RebaseRevisionMetadata,
+		idAllocator: IdAllocator,
+	): void {
+		for (const field of table.fieldsWithUnattachedChild) {
+			table.invalidatedFields.delete(field);
+			this.rebaseInvalidatedField(field, table, metadata, idAllocator, true);
 		}
 	}
 
 	private rebaseInvalidatedField(
 		baseField: FieldChange,
 		crossFieldTable: RebaseTable,
-		context: RebaseFieldContext,
 		rebaseMetadata: RebaseRevisionMetadata,
 		genId: IdAllocator,
+		allowInval = false,
 	): void {
+		const context = crossFieldTable.baseFieldToContext.get(baseField);
+		assert(context !== undefined, 0x852 /* Every field should have a context */);
 		const {
 			changeHandler,
 			change1: fieldChangeset,
@@ -1342,28 +1158,25 @@ export class ModularChangeFamily
 				return curr;
 			}
 
-			if (base !== undefined && getFromChangeAtomIdMap(context.baseNodeIds, base) === true) {
-				return base;
+			if (base !== undefined) {
+				for (const id of context.baseNodeIds) {
+					if (areEqualChangeAtomIds(base, id)) {
+						return base;
+					}
+				}
 			}
 
 			return undefined;
 		};
 
-		let allowInval = false;
-		if (crossFieldTable.fieldsWithUnattachedChild.has(baseField)) {
-			crossFieldTable.fieldsWithUnattachedChild.delete(baseField);
-			allowInval = true;
-		}
-
 		context.rebasedChange.change = brand(
 			changeHandler.rebaser.rebase(
 				fieldChangeset,
 				baseChangeset,
 				rebaseChild,
 				genId,
-				new RebaseNodeManagerI(crossFieldTable, context.fieldId, allowInval),
+				new RebaseManager(crossFieldTable, baseField, context.fieldId, allowInval),
 				rebaseMetadata,
-				crossFieldTable.rebaseVersion,
 			),
 		);
 	}
@@ -1383,19 +1196,13 @@ export class ModularChangeFamily
 		}
 		const rebasedNode = getFromChangeAtomIdMap(rebasedNodes, nodeId);
 		if (rebasedNode !== undefined) {
-			const updatedRebasedNode: Mutable<NodeChangeset> = cloneNodeChangeset(rebasedNode);
-			setInChangeAtomIdMap(rebasedNodes, nodeId, updatedRebasedNode);
-
-			if (updatedRebasedNode.fieldChanges === undefined) {
-				updatedRebasedNode.fieldChanges = new Map([[fieldKey, rebasedField]]);
+			if (rebasedNode.fieldChanges === undefined) {
+				rebasedNode.fieldChanges = new Map([[fieldKey, rebasedField]]);
 				return;
 			}
 
-			assert(
-				!updatedRebasedNode.fieldChanges.has(fieldKey),
-				0x9c4 /* Expected an empty field */,
-			);
-			updatedRebasedNode.fieldChanges.set(fieldKey, rebasedField);
+			assert(!rebasedNode.fieldChanges.has(fieldKey), 0x9c4 /* Expected an empty field */);
+			rebasedNode.fieldChanges.set(fieldKey, rebasedField);
 			return;
 		}
 
@@ -1406,14 +1213,14 @@ export class ModularChangeFamily
 		setInChangeAtomIdMap(rebasedNodes, nodeId, newNode);
 		setInChangeAtomIdMap(table.baseToRebasedNodeId, nodeId, nodeId);
 
-		const parentBase = getNodeParent(table.baseChange, nodeId);
+		const parentFieldId = getParentFieldId(table.baseChange, nodeId);
 
 		this.attachRebasedNode(
 			rebasedFields,
 			rebasedNodes,
 			table,
 			nodeId,
-			parentBase,
+			parentFieldId,
 			idAllocator,
 			metadata,
 		);
@@ -1424,100 +1231,65 @@ export class ModularChangeFamily
 		rebasedNodes: ChangeAtomIdBTree<NodeChangeset>,
 		table: RebaseTable,
 		baseNodeId: NodeId,
-		parentBase: NodeLocation,
+		parentFieldIdBase: FieldId,
 		idAllocator: IdAllocator,
 		metadata: RebaseRevisionMetadata,
 	): void {
-		if (parentBase.root !== undefined) {
-			const renamedRoot = firstAttachIdFromDetachId(
-				table.baseChange.rootNodes,
-				parentBase.root,
-				1,
-			).value;
-
-			const attachField = table.baseChange.crossFieldKeys.getFirst(
-				{ ...renamedRoot, target: NodeMoveType.Attach },
-				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 baseFieldChange = fieldChangeFromId(
+			table.baseChange.fieldChanges,
+			table.baseChange.nodeChanges,
+			parentFieldIdBase,
+		);
 
 		const rebasedFieldId = rebasedFieldIdFromBaseId(table, parentFieldIdBase);
-		setInChangeAtomIdMap(table.rebasedNodeToParent, baseNodeId, { field: rebasedFieldId });
+		setInChangeAtomIdMap(table.rebasedNodeToParent, baseNodeId, rebasedFieldId);
 
 		const context = table.baseFieldToContext.get(baseFieldChange);
 		if (context !== undefined) {
 			// We've already processed this field.
-			// The new child node will be attached in the next pass.
-			// Note that adding to `fieldsWithUnattachedChild` allows that field to generate new invalidations,
-			// so to avoid invalidation cycles we make sure we only add to it once per new unattached child.
-			// This is done by checking whether `context.baseNodeIds` already contained `baseNodeId`.
-			if (setInChangeAtomIdMap(context.baseNodeIds, baseNodeId, true)) {
-				table.fieldsWithUnattachedChild.add(baseFieldChange);
-				table.affectedBaseFields.set(fieldIdKeyFromFieldId(parentFieldIdBase), true);
-			}
+			// The new child node will be attached in rebaseFieldsWithUnattachedChild.
+			context.baseNodeIds.push(baseNodeId);
+			table.fieldsWithUnattachedChild.add(baseFieldChange);
 			return;
 		}
 
-		this.rebaseFieldWithoutNewChanges(
-			baseFieldChange,
-			parentFieldIdBase,
-			table,
+		const handler = getChangeHandler(this.fieldKinds, baseFieldChange.fieldKind);
+
+		const fieldChange: FieldChange = {
+			...baseFieldChange,
+			change: brand(handler.createEmpty()),
+		};
+
+		const rebasedChangeset = handler.rebaser.rebase(
+			handler.createEmpty(),
+			baseFieldChange.change,
+			(_idNew, idBase) =>
+				idBase !== undefined && areEqualChangeAtomIds(idBase, baseNodeId)
+					? baseNodeId
+					: undefined,
+			idAllocator,
+			new RebaseManager(table, baseFieldChange, rebasedFieldId),
+			metadata,
+		);
+
+		const rebasedField: FieldChange = { ...baseFieldChange, change: brand(rebasedChangeset) };
+		table.rebasedFields.add(rebasedField);
+		table.baseFieldToContext.set(baseFieldChange, {
+			newChange: fieldChange,
+			baseChange: baseFieldChange,
+			rebasedChange: rebasedField,
+			fieldId: rebasedFieldId,
+			baseNodeIds: [],
+		});
+
+		this.attachRebasedField(
 			rebasedFields,
 			rebasedNodes,
+			table,
+			rebasedField,
+			rebasedFieldId,
 			idAllocator,
 			metadata,
-			baseNodeId,
 		);
 	}
 
@@ -1556,7 +1328,7 @@ export class ModularChangeFamily
 				change2: baseChangeset,
 			} = this.normalizeFieldChanges(fieldChange, baseChange);
 
-			const manager = new RebaseNodeManagerI(crossFieldTable, fieldId);
+			const manager = new RebaseManager(crossFieldTable, baseChange, fieldId);
 
 			const rebasedField = changeHandler.rebaser.rebase(
 				fieldChangeset,
@@ -1565,7 +1337,6 @@ export class ModularChangeFamily
 				genId,
 				manager,
 				revisionMetadata,
-				crossFieldTable.rebaseVersion,
 			);
 
 			const rebasedFieldChange: FieldChange = {
@@ -1580,7 +1351,7 @@ export class ModularChangeFamily
 				newChange: fieldChange,
 				rebasedChange: rebasedFieldChange,
 				fieldId,
-				baseNodeIds: newChangeAtomIdBTree(),
+				baseNodeIds: [],
 			});
 
 			crossFieldTable.rebasedFields.add(rebasedFieldChange);
@@ -1596,16 +1367,8 @@ export class ModularChangeFamily
 		crossFieldTable: RebaseTable,
 		revisionMetadata: RebaseRevisionMetadata,
 	): NodeChangeset {
-		const change = nodeChangeFromId(
-			crossFieldTable.newChange.nodeChanges,
-			crossFieldTable.newChange.nodeAliases,
-			newId,
-		);
-		const over = nodeChangeFromId(
-			crossFieldTable.baseChange.nodeChanges,
-			crossFieldTable.baseChange.nodeAliases,
-			baseId,
-		);
+		const change = nodeChangeFromId(crossFieldTable.newChange.nodeChanges, newId);
+		const over = nodeChangeFromId(crossFieldTable.baseChange.nodeChanges, baseId);
 
 		const baseMap: FieldChangeMap = over?.fieldChanges ?? new Map<FieldKey, FieldChange>();
 
@@ -1621,7 +1384,7 @@ export class ModularChangeFamily
 					)
 				: change.fieldChanges;
 
-		const rebasedChange: Mutable<NodeChangeset> = {};
+		const rebasedChange: NodeChangeset = {};
 
 		if (fieldChanges !== undefined && fieldChanges.size > 0) {
 			rebasedChange.fieldChanges = fieldChanges;
@@ -1639,37 +1402,6 @@ export class ModularChangeFamily
 		return rebasedChange;
 	}
 
-	private updateConstraints(
-		rebasedFields: FieldChangeMap,
-		rebasedNodes: ChangeAtomIdBTree<NodeChangeset>,
-		rebasedRoots: RootNodeTable,
-		constraintState: ConstraintState,
-		revertConstraintState: ConstraintState,
-	): void {
-		this.updateConstraintsForFields(
-			rebasedFields,
-			NodeAttachState.Attached,
-			NodeAttachState.Attached,
-			constraintState,
-			revertConstraintState,
-			rebasedNodes,
-		);
-
-		for (const [_detachId, nodeId] of rebasedRoots.nodeChanges.entries()) {
-			// XXX: This is incorrect if the rebased changeset attaches the node.
-			// Efficiently computing whether the changeset attaches the node would require maintaining a mapping from node ID to attach ID.
-			const detachedInOutput = true;
-			this.updateConstraintsForNode(
-				nodeId,
-				NodeAttachState.Detached,
-				detachedInOutput ? NodeAttachState.Detached : NodeAttachState.Attached,
-				rebasedNodes,
-				constraintState,
-				revertConstraintState,
-			);
-		}
-	}
-
 	private updateConstraintsForFields(
 		fields: FieldChangeMap,
 		parentInputAttachState: NodeAttachState,
@@ -1680,18 +1412,20 @@ export class ModularChangeFamily
 	): void {
 		for (const field of fields.values()) {
 			const handler = getChangeHandler(this.fieldKinds, field.fieldKind);
-			for (const [nodeId] of handler.getNestedChanges(field.change)) {
-				// XXX: This is incorrect if the rebased changeset detaches this node.
-				// Efficiently computing whether the changeset detaches the node would require maintaining a mapping from node ID to detach ID.
-				const isOutputDetached = false;
+			for (const [nodeId, inputIndex, outputIndex] of handler.getNestedChanges(field.change)) {
+				const isInputDetached = inputIndex === undefined;
+				const inputAttachState =
+					parentInputAttachState === NodeAttachState.Detached || isInputDetached
+						? NodeAttachState.Detached
+						: NodeAttachState.Attached;
+				const isOutputDetached = outputIndex === undefined;
 				const outputAttachState =
 					parentOutputAttachState === NodeAttachState.Detached || isOutputDetached
 						? NodeAttachState.Detached
 						: NodeAttachState.Attached;
-
 				this.updateConstraintsForNode(
 					nodeId,
-					parentInputAttachState,
+					inputAttachState,
 					outputAttachState,
 					nodes,
 					constraintState,
@@ -1709,15 +1443,12 @@ export class ModularChangeFamily
 		constraintState: ConstraintState,
 		revertConstraintState: ConstraintState,
 	): void {
-		const node = getFromChangeAtomIdMap(nodes, nodeId) ?? fail(0xb24 /* Unknown node ID */);
-
-		const updatedNode: Mutable<NodeChangeset> = { ...node };
-		setInChangeAtomIdMap(nodes, nodeId, updatedNode);
-
+		const node =
+			nodes.get([nodeId.revision, nodeId.localId]) ?? fail(0xb24 /* Unknown node ID */);
 		if (node.nodeExistsConstraint !== undefined) {
 			const isNowViolated = inputAttachState === NodeAttachState.Detached;
 			if (node.nodeExistsConstraint.violated !== isNowViolated) {
-				updatedNode.nodeExistsConstraint = {
+				node.nodeExistsConstraint = {
 					...node.nodeExistsConstraint,
 					violated: isNowViolated,
 				};
@@ -1727,7 +1458,7 @@ export class ModularChangeFamily
 		if (node.nodeExistsConstraintOnRevert !== undefined) {
 			const isNowViolated = outputAttachState === NodeAttachState.Detached;
 			if (node.nodeExistsConstraintOnRevert.violated !== isNowViolated) {
-				updatedNode.nodeExistsConstraintOnRevert = {
+				node.nodeExistsConstraintOnRevert = {
 					...node.nodeExistsConstraintOnRevert,
 					violated: isNowViolated,
 				};
@@ -1749,13 +1480,7 @@ export class ModularChangeFamily
 
 	private pruneFieldMap(
 		changeset: FieldChangeMap | undefined,
-		parentId: NodeId | undefined,
 		nodeMap: ChangeAtomIdBTree<NodeChangeset>,
-		nodeToParent: ChangeAtomIdBTree<NodeLocation>,
-		aliases: ChangeAtomIdBTree<NodeId>,
-		roots: RootNodeTable,
-		fieldsWithRootMoves: TupleBTree<FieldIdKey, boolean>,
-		fieldsToRootChanges: TupleBTree<FieldIdKey, ChangeAtomId[]>,
 	): FieldChangeMap | undefined {
 		if (changeset === undefined) {
 			return undefined;
@@ -1766,48 +1491,10 @@ export class ModularChangeFamily
 			const handler = getChangeHandler(this.fieldKinds, fieldChange.fieldKind);
 
 			const prunedFieldChangeset = handler.rebaser.prune(fieldChange.change, (nodeId) =>
-				this.pruneNodeChange(
-					nodeId,
-					nodeMap,
-					nodeToParent,
-					aliases,
-					roots,
-					fieldsWithRootMoves,
-					fieldsToRootChanges,
-				),
+				this.pruneNodeChange(nodeId, nodeMap),
 			);
 
-			const fieldId: FieldId = { nodeId: parentId, field };
-			const fieldIdKey = fieldIdKeyFromFieldId(fieldId);
-			const rootsWithChanges = fieldsToRootChanges.get(fieldIdKey) ?? [];
-			let hasRootWithNodeChange = false;
-			for (const rootId of rootsWithChanges) {
-				const nodeId =
-					getFromChangeAtomIdMap(roots.nodeChanges, rootId) ?? fail("No root change found");
-
-				const isRootChangeEmpty =
-					this.pruneNodeChange(
-						nodeId,
-						nodeMap,
-						nodeToParent,
-						aliases,
-						roots,
-						fieldsWithRootMoves,
-						fieldsToRootChanges,
-					) === undefined;
-
-				if (isRootChangeEmpty) {
-					roots.nodeChanges.delete([rootId.revision, rootId.localId]);
-					tryRemoveDetachLocation(roots, rootId, 1);
-				} else {
-					hasRootWithNodeChange = true;
-				}
-			}
-
-			const hasRootChanges =
-				hasRootWithNodeChange || fieldsWithRootMoves.get(fieldIdKey) === true;
-
-			if (!handler.isEmpty(prunedFieldChangeset) || hasRootChanges) {
+			if (!handler.isEmpty(prunedFieldChangeset)) {
 				prunedChangeset.set(field, { ...fieldChange, change: brand(prunedFieldChangeset) });
 			}
 		}
@@ -1815,65 +1502,15 @@ export class ModularChangeFamily
 		return prunedChangeset.size > 0 ? prunedChangeset : undefined;
 	}
 
-	private pruneRoots(
-		roots: RootNodeTable,
-		nodeMap: ChangeAtomIdBTree<NodeChangeset>,
-		nodeToParent: ChangeAtomIdBTree<NodeLocation>,
-		aliases: ChangeAtomIdBTree<NodeId>,
-		fieldsWithRootMoves: TupleBTree<FieldIdKey, boolean>,
-		fieldsToRootChanges: TupleBTree<FieldIdKey, ChangeAtomId[]>,
-	): RootNodeTable {
-		const pruned: RootNodeTable = { ...roots, nodeChanges: newChangeAtomIdBTree() };
-		for (const [rootIdKey, nodeId] of roots.nodeChanges.entries()) {
-			const rootId: ChangeAtomId = { revision: rootIdKey[0], localId: rootIdKey[1] };
-			const hasDetachLocation = roots.detachLocations.getFirst(rootId, 1).value !== undefined;
-
-			// If the root has a detach location it should be pruned by recursion when pruning the field it was detached from.
-			const prunedId = hasDetachLocation
-				? nodeId
-				: this.pruneNodeChange(
-						nodeId,
-						nodeMap,
-						nodeToParent,
-						aliases,
-						roots,
-						fieldsWithRootMoves,
-						fieldsToRootChanges,
-					);
-
-			if (prunedId !== undefined) {
-				pruned.nodeChanges.set(rootIdKey, prunedId);
-			}
-
-			tryRemoveDetachLocation(pruned, rootId, 1);
-		}
-
-		return pruned;
-	}
-
 	private pruneNodeChange(
 		nodeId: NodeId,
-		nodes: ChangeAtomIdBTree<NodeChangeset>,
-		nodeToParent: ChangeAtomIdBTree<NodeLocation>,
-		aliases: ChangeAtomIdBTree<NodeId>,
-		roots: RootNodeTable,
-		fieldsWithRootMoves: TupleBTree<FieldIdKey, boolean>,
-		fieldsToRootChanges: TupleBTree<FieldIdKey, ChangeAtomId[]>,
+		nodeMap: ChangeAtomIdBTree<NodeChangeset>,
 	): NodeId | undefined {
-		const changeset = nodeChangeFromId(nodes, aliases, nodeId);
+		const changeset = nodeChangeFromId(nodeMap, nodeId);
 		const prunedFields =
 			changeset.fieldChanges === undefined
 				? undefined
-				: this.pruneFieldMap(
-						changeset.fieldChanges,
-						nodeId,
-						nodes,
-						nodeToParent,
-						aliases,
-						roots,
-						fieldsWithRootMoves,
-						fieldsToRootChanges,
-					);
+				: this.pruneFieldMap(changeset.fieldChanges, nodeMap);
 
 		const prunedChange = { ...changeset, fieldChanges: prunedFields };
 		if (prunedChange.fieldChanges === undefined) {
@@ -1881,17 +1518,10 @@ export class ModularChangeFamily
 		}
 
 		if (isEmptyNodeChangeset(prunedChange)) {
-			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);
+			nodeMap.delete([nodeId.revision, nodeId.localId]);
 			return undefined;
 		} else {
-			setInChangeAtomIdMap(nodes, nodeId, prunedChange);
+			setInChangeAtomIdMap(nodeMap, nodeId, prunedChange);
 			return nodeId;
 		}
 	}
@@ -1918,11 +1548,8 @@ export class ModularChangeFamily
 		const updatedNodeToParent = replaceIdMapRevisions(
 			change.nodeToParent,
 			replacer,
-			(location) =>
-				replaceNodeLocationRevision(
-					normalizeNodeLocation(location, change.nodeAliases),
-					replacer,
-				),
+			(fieldId) =>
+				replaceFieldIdRevision(normalizeFieldId(fieldId, change.nodeAliases), replacer),
 		);
 
 		const updated: Mutable<ModularChangeset> = {
@@ -1930,7 +1557,6 @@ export class ModularChangeFamily
 			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: newChangeAtomIdBTree(),
@@ -1994,7 +1620,7 @@ export class ModularChangeFamily
 		fields: FieldChangeMap,
 		nodes: ChangeAtomIdBTree<NodeChangeset>,
 	): CrossFieldKeyTable {
-		const keys: CrossFieldKeyTable = newCrossFieldRangeTable();
+		const keys: CrossFieldKeyTable = newCrossFieldKeyTable();
 		this.populateCrossFieldKeyTableForFieldMap(keys, fields, undefined);
 		nodes.forEachPair(([revision, localId], node) => {
 			if (node.fieldChanges !== undefined) {
@@ -2026,15 +1652,8 @@ export class ModularChangeFamily
 	public buildEditor(
 		mintRevisionTag: () => RevisionTag,
 		changeReceiver: (change: TaggedChange<ModularChangeset>) => void,
-		editorOptions?: ModularEditorOptions,
 	): ModularEditBuilder {
-		return new ModularEditBuilder(
-			this,
-			this.fieldKinds,
-			changeReceiver,
-			this.codecOptions,
-			editorOptions,
-		);
+		return new ModularEditBuilder(this, this.fieldKinds, changeReceiver, this.codecOptions);
 	}
 
 	private createEmptyFieldChange(fieldKind: FieldKindIdentifier): FieldChange {
@@ -2042,6 +1661,63 @@ 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);
@@ -2055,8 +1731,7 @@ export class ModularChangeFamily
 	private muteChange(change: ModularChangeset): ModularChangeset {
 		const muted: Mutable<ModularChangeset> = {
 			...change,
-			rootNodes: muteRootChanges(change.rootNodes),
-			crossFieldKeys: newCrossFieldRangeTable(),
+			crossFieldKeys: newCrossFieldKeyTable(),
 			fieldChanges: this.muteFieldChanges(change.fieldChanges),
 			nodeChanges: brand(change.nodeChanges.mapValues((v) => this.muteNodeChange(v))),
 		};
@@ -2093,7 +1768,7 @@ function replaceCrossFieldKeyTableRevisions(
 	replacer: RevisionReplacer,
 	nodeAliases: ChangeAtomIdBTree<NodeId>,
 ): CrossFieldKeyTable {
-	const updated: CrossFieldKeyTable = newCrossFieldRangeTable();
+	const updated: CrossFieldKeyTable = newCrossFieldKeyTable();
 	for (const entry of table.entries()) {
 		const key = entry.start;
 		const updatedKey: CrossFieldKey = replacer.getUpdatedAtomId(key, entry.length);
@@ -2203,20 +1878,6 @@ function composeBuildsDestroysAndRefreshers(
 		}
 	}
 
-	// It's possible to have a build and a refresher for the same root because an attach operation need not be performed in the same changeset as the corresponding build.
-	if (change1.builds !== undefined && change2.refreshers !== undefined) {
-		for (const [key, chunk] of change2.refreshers.entries()) {
-			assert(chunk.topLevelLength === 1, "Expected refresher chunk to have length 1");
-			const match = change1.builds.getPairOrNextLower(key);
-			if (match !== undefined) {
-				const [buildKey, buildChunk] = match;
-				if (buildKey[0] === key[0] && buildKey[1] + buildChunk.topLevelLength > key[1]) {
-					allRefreshers.delete(key);
-				}
-			}
-		}
-	}
-
 	return { allBuilds, allDestroys, allRefreshers };
 }
 
@@ -2248,69 +1909,30 @@ export function* relevantRemovedRoots(
 	change: ModularChangeset,
 	fieldKinds: ReadonlyMap<FieldKindIdentifier, FlexFieldKind>,
 ): Iterable<DeltaDetachedNodeId> {
-	const rootIds: ChangeAtomIdRangeMap<boolean> = newChangeAtomIdRangeMap();
-	addAttachesToSet(change, rootIds);
-	addRenamesToSet(change, rootIds);
-
-	for (const [[revision, localId]] of change.rootNodes.nodeChanges.entries()) {
-		rootIds.set({ revision, localId }, 1, true);
-	}
-
-	for (const entry of rootIds.entries()) {
-		for (let offset = 0; offset < entry.length; offset++) {
-			const detachId = offsetChangeAtomId(entry.start, offset);
-			yield makeDetachedNodeId(detachId.revision, detachId.localId);
-		}
-	}
+	yield* relevantRemovedRootsFromFields(change.fieldChanges, change.nodeChanges, fieldKinds);
 }
 
-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 !== NodeMoveType.Attach) {
-			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: NodeMoveType.Detach },
-				detachIdEntry.length,
-			)) {
-				if (detachEntry.value === undefined) {
-					rootIds.set(
-						offsetChangeAtomId(detachId, detachEntry.offset),
-						detachEntry.length,
-						true,
-					);
-				}
-			}
-		}
+function* relevantRemovedRootsFromNode(
+	node: NodeId,
+	nodeChanges: ChangeAtomIdBTree<NodeChangeset>,
+	fieldKinds: ReadonlyMap<FieldKindIdentifier, FlexFieldKind>,
+): Iterable<DeltaDetachedNodeId> {
+	const nodeChangeset = nodeChangeFromId(nodeChanges, node);
+	if (nodeChangeset.fieldChanges !== undefined) {
+		yield* relevantRemovedRootsFromFields(nodeChangeset.fieldChanges, nodeChanges, fieldKinds);
 	}
 }
 
-function addRenamesToSet(
-	change: ModularChangeset,
-	rootIds: ChangeAtomIdRangeMap<boolean>,
-): void {
-	for (const renameEntry of change.rootNodes.oldToNewId.entries()) {
-		for (const detachEntry of change.crossFieldKeys.getAll2(
-			{ ...renameEntry.start, target: NodeMoveType.Detach },
-			renameEntry.length,
-		)) {
-			// We only want to include renames of nodes which are detached in the input context of the changeset.
-			// So if there is a detach for the node, the rename is not relevant.
-			if (detachEntry.value === undefined) {
-				rootIds.set(renameEntry.start, renameEntry.length, true);
-			}
-		}
+function* relevantRemovedRootsFromFields(
+	change: FieldChangeMap,
+	nodeChanges: ChangeAtomIdBTree<NodeChangeset>,
+	fieldKinds: ReadonlyMap<FieldKindIdentifier, FlexFieldKind>,
+): Iterable<DeltaDetachedNodeId> {
+	const delegate = (node: NodeId): Iterable<DeltaDetachedNodeId> =>
+		relevantRemovedRootsFromNode(node, nodeChanges, fieldKinds);
+	for (const [_, fieldChange] of change) {
+		const handler = getChangeHandler(fieldKinds, fieldChange.fieldKind);
+		yield* handler.relevantRemovedRoots(fieldChange.change, delegate);
 	}
 }
 
@@ -2368,7 +1990,6 @@ export function updateRefreshers(
 	}
 
 	const {
-		rebaseVersion,
 		fieldChanges,
 		nodeChanges,
 		nodeToParent,
@@ -2380,17 +2001,14 @@ export function updateRefreshers(
 		constraintViolationCountOnRevert,
 		builds,
 		destroys,
-		rootNodes,
 	} = change;
 
 	return makeModularChangeset({
-		rebaseVersion,
 		fieldChanges,
 		nodeChanges,
 		nodeToParent,
 		nodeAliases,
 		crossFieldKeys,
-		rootNodes,
 		maxId: maxId as number,
 		revisions,
 		constraintViolationCount,
@@ -2413,42 +2031,18 @@ export function intoDelta(
 ): DeltaRoot {
 	const change = taggedChange.change;
 	const rootDelta: Mutable<DeltaRoot> = {};
+	const global: DeltaDetachedNodeChanges[] = [];
+	const rename: DeltaDetachedNodeRename[] = [];
 
 	if (!hasConflicts(change)) {
 		// If there are no constraint violations, then tree changes apply.
 		const fieldDeltas = intoDeltaImpl(
 			change.fieldChanges,
 			change.nodeChanges,
-			change.nodeAliases,
 			fieldKinds,
+			global,
+			rename,
 		);
-
-		const global: DeltaDetachedNodeChanges[] = [];
-		for (const [[major, minor], nodeId] of change.rootNodes.nodeChanges.entries()) {
-			global.push({
-				id: { major, minor },
-				fields: deltaFromNodeChange(
-					nodeChangeFromId(change.nodeChanges, change.nodeAliases, nodeId),
-					change.nodeChanges,
-					change.nodeAliases,
-					fieldKinds,
-				),
-			});
-		}
-
-		const rename: DeltaDetachedNodeRename[] = [];
-		for (const {
-			start: oldId,
-			value: newId,
-			length,
-		} of change.rootNodes.oldToNewId.entries()) {
-			rename.push({
-				count: length,
-				oldId: makeDetachedNodeId(oldId.revision, oldId.localId),
-				newId: makeDetachedNodeId(newId.revision, newId.localId),
-			});
-		}
-
 		if (fieldDeltas.size > 0) {
 			rootDelta.fields = fieldDeltas;
 		}
@@ -2477,7 +2071,6 @@ export function intoDelta(
 	if (change.refreshers && change.refreshers.size > 0) {
 		rootDelta.refreshers = copyDetachedNodes(change.refreshers);
 	}
-
 	return rootDelta;
 }
 
@@ -2503,21 +2096,32 @@ function copyDetachedNodes(
 function intoDeltaImpl(
 	change: FieldChangeMap,
 	nodeChanges: ChangeAtomIdBTree<NodeChangeset>,
-	nodeAliases: ChangeAtomIdBTree<NodeId>,
 	fieldKinds: ReadonlyMap<FieldKindIdentifier, FlexFieldKind>,
+	global: DeltaDetachedNodeChanges[],
+	rename: DeltaDetachedNodeRename[],
 ): Map<FieldKey, DeltaFieldChanges> {
 	const delta: Map<FieldKey, DeltaFieldChanges> = new Map();
 
 	for (const [field, fieldChange] of change) {
-		const fieldDelta = getChangeHandler(fieldKinds, fieldChange.fieldKind).intoDelta(
+		const {
+			local: fieldChanges,
+			global: fieldGlobal,
+			rename: fieldRename,
+		} = getChangeHandler(fieldKinds, fieldChange.fieldKind).intoDelta(
 			fieldChange.change,
 			(childChange): DeltaFieldMap => {
-				const nodeChange = nodeChangeFromId(nodeChanges, nodeAliases, childChange);
-				return deltaFromNodeChange(nodeChange, nodeChanges, nodeAliases, fieldKinds);
+				const nodeChange = nodeChangeFromId(nodeChanges, childChange);
+				return deltaFromNodeChange(nodeChange, nodeChanges, fieldKinds, global, rename);
 			},
 		);
-		if (fieldDelta !== undefined && fieldDelta.marks.length > 0) {
-			delta.set(field, fieldDelta);
+		if (fieldChanges !== undefined && fieldChanges.marks.length > 0) {
+			delta.set(field, fieldChanges);
+		}
+		for (const c of fieldGlobal ?? []) {
+			global.push(c);
+		}
+		for (const r of fieldRename ?? []) {
+			rename.push(r);
 		}
 	}
 	return delta;
@@ -2526,11 +2130,12 @@ function intoDeltaImpl(
 function deltaFromNodeChange(
 	change: NodeChangeset,
 	nodeChanges: ChangeAtomIdBTree<NodeChangeset>,
-	nodeAliases: ChangeAtomIdBTree<NodeId>,
 	fieldKinds: ReadonlyMap<FieldKindIdentifier, FlexFieldKind>,
+	global: DeltaDetachedNodeChanges[],
+	rename: DeltaDetachedNodeRename[],
 ): DeltaFieldMap {
 	if (change.fieldChanges !== undefined) {
-		return intoDeltaImpl(change.fieldChanges, nodeChanges, nodeAliases, fieldKinds);
+		return intoDeltaImpl(change.fieldChanges, nodeChanges, fieldKinds, global, rename);
 	}
 	// TODO: update the API to allow undefined to be returned here
 	return new Map();
@@ -2595,22 +2200,19 @@ export function getChangeHandler(
 	return getFieldKind(fieldKinds, kind).changeHandler;
 }
 
-interface InvertTable {
-	change: ModularChangeset;
-	isRollback: boolean;
+// TODO: TFieldData could instead just be a numeric ID generated by the CrossFieldTable
+// The CrossFieldTable could have a generic field ID to context table
+interface CrossFieldTable<TFieldData> {
+	srcTable: CrossFieldMap<unknown>;
+	dstTable: CrossFieldMap<unknown>;
+	srcDependents: CrossFieldMap<TFieldData>;
+	dstDependents: CrossFieldMap<TFieldData>;
+	invalidatedFields: Set<TFieldData>;
+}
 
-	// Entries are keyed on attach ID
-	entries: CrossFieldMap<NodeId>;
+interface InvertTable extends CrossFieldTable<FieldChange> {
 	originalFieldToContext: Map<FieldChange, InvertContext>;
-	invertedNodeToParent: ChangeAtomIdBTree<NodeLocation>;
-	invertRevision: RevisionTag;
-	invalidatedFields: Set<FieldChange>;
-	invertedRoots: RootNodeTable;
-
-	/**
-	 * Maps from attach ID in the inverted changeset to the corresponding detach ID in the base changeset.
-	 */
-	attachToDetachId: ChangeAtomIdRangeMap<ChangeAtomId>;
+	invertedNodeToParent: ChangeAtomIdBTree<FieldId>;
 }
 
 interface InvertContext {
@@ -2618,11 +2220,7 @@ interface InvertContext {
 	invertedField: FieldChange;
 }
 
-interface RebaseTable {
-	readonly rebaseVersion: RebaseVersion;
-
-	// Entries are keyed on attach ID
-	readonly entries: CrossFieldMap<RebaseDetachedNodeEntry>;
+interface RebaseTable extends CrossFieldTable<FieldChange> {
 	readonly baseChange: ModularChangeset;
 	readonly newChange: ModularChangeset;
 
@@ -2631,13 +2229,10 @@ interface RebaseTable {
 	 * to the context for the field.
 	 */
 	readonly baseFieldToContext: Map<FieldChange, RebaseFieldContext>;
-	readonly baseRoots: RootNodeTable;
 	readonly baseToRebasedNodeId: ChangeAtomIdBTree<NodeId>;
 	readonly rebasedFields: Set<FieldChange>;
-	readonly rebasedNodeToParent: ChangeAtomIdBTree<NodeLocation>;
-	readonly rebasedDetachLocations: ChangeAtomIdRangeMap<FieldId>;
-	readonly movedDetaches: ChangeAtomIdRangeMap<boolean>;
-	readonly rebasedRootNodes: RootNodeTable;
+	readonly rebasedNodeToParent: ChangeAtomIdBTree<FieldId>;
+	readonly rebasedCrossFieldKeys: CrossFieldKeyTable;
 
 	/**
 	 * List of unprocessed (newId, baseId) pairs encountered so far.
@@ -2651,11 +2246,7 @@ interface RebaseTable {
 	readonly fieldsWithUnattachedChild: Set<FieldChange>;
 }
 
-export type FieldIdKey = readonly [
-	RevisionTag | undefined,
-	ChangesetLocalId | undefined,
-	FieldKey,
-];
+type FieldIdKey = readonly [RevisionTag | undefined, ChangesetLocalId | undefined, FieldKey];
 
 interface RebaseFieldContext {
 	baseChange: FieldChange;
@@ -2667,43 +2258,32 @@ interface RebaseFieldContext {
 	 * The set of node IDs in the base changeset which should be included in the rebased field,
 	 * even if there is no corresponding node changeset in the new change.
 	 */
-	baseNodeIds: ChangeAtomIdBTree<boolean>;
+	baseNodeIds: NodeId[];
 }
 
 function newComposeTable(
 	baseChange: ModularChangeset,
 	newChange: ModularChangeset,
-	composedRootNodes: RootNodeTable,
-	movedCrossFieldKeys: CrossFieldKeyTable,
-	removedCrossFieldKeys: CrossFieldRangeTable<boolean>,
-	pendingCompositions: PendingCompositions,
+	composedNodeToParent: ChangeAtomIdBTree<FieldId>,
 ): ComposeTable {
 	return {
-		rebaseVersion: Math.max(
-			baseChange.rebaseVersion,
-			newChange.rebaseVersion,
-		) as RebaseVersion,
-		entries: newDetachedEntryMap(),
+		...newCrossFieldTable<FieldChange>(),
 		baseChange,
 		newChange,
 		fieldToContext: new Map(),
 		newFieldToBaseField: new Map(),
 		newToBaseNodeId: newChangeAtomIdBTree(),
 		composedNodes: new Set(),
-		movedNodeToParent: newChangeAtomIdBTree(),
-		composedRootNodes,
-		movedCrossFieldKeys,
-		removedCrossFieldKeys,
-		renamesToDelete: newChangeAtomIdRangeMap(),
-		pendingCompositions,
+		composedNodeToParent,
+		pendingCompositions: {
+			nodeIdsToCompose: [],
+			affectedBaseFields: newFieldIdKeyBTree(),
+			affectedNewFields: newFieldIdKeyBTree(),
+		},
 	};
 }
 
-interface ComposeTable {
-	readonly rebaseVersion: RebaseVersion;
-
-	// Entries are keyed on detach ID
-	readonly entries: ChangeAtomIdRangeMap<DetachedNodeEntry>;
+interface ComposeTable extends CrossFieldTable<FieldChange> {
 	readonly baseChange: ModularChangeset;
 	readonly newChange: ModularChangeset;
 
@@ -2714,11 +2294,7 @@ interface ComposeTable {
 	readonly newFieldToBaseField: Map<FieldChange, FieldChange>;
 	readonly newToBaseNodeId: ChangeAtomIdBTree<NodeId>;
 	readonly composedNodes: Set<NodeChangeset>;
-	readonly movedNodeToParent: ChangeAtomIdBTree<NodeLocation>;
-	readonly composedRootNodes: RootNodeTable;
-	readonly movedCrossFieldKeys: CrossFieldKeyTable;
-	readonly removedCrossFieldKeys: CrossFieldRangeTable<boolean>;
-	readonly renamesToDelete: ChangeAtomIdRangeMap<boolean>;
+	readonly composedNodeToParent: ChangeAtomIdBTree<FieldId>;
 	readonly pendingCompositions: PendingCompositions;
 }
 
@@ -2733,6 +2309,11 @@ interface PendingCompositions {
 	 * The set of fields in the base changeset which have been affected by a cross field effect.
 	 */
 	readonly affectedBaseFields: BTree<FieldIdKey, true>;
+
+	/**
+	 * The set of fields in the new changeset which have been affected by a cross field effect.
+	 */
+	readonly affectedNewFields: BTree<FieldIdKey, true>;
 }
 
 interface ComposeFieldContext {
@@ -2745,6 +2326,16 @@ interface ComposeFieldContext {
 	composedChange: FieldChange;
 }
 
+function newCrossFieldTable<T>(): CrossFieldTable<T> {
+	return {
+		srcTable: newChangeAtomIdRangeMap(),
+		dstTable: newChangeAtomIdRangeMap(),
+		srcDependents: newChangeAtomIdRangeMap(),
+		dstDependents: newChangeAtomIdRangeMap(),
+		invalidatedFields: new Set(),
+	};
+}
+
 interface ConstraintState {
 	violationCount: number;
 }
@@ -2755,687 +2346,282 @@ function newConstraintState(violationCount: number): ConstraintState {
 	};
 }
 
-class InvertNodeManagerI implements InvertNodeManager {
+abstract class CrossFieldManagerI<T> implements CrossFieldManager {
 	public constructor(
-		private readonly table: InvertTable,
-		private readonly fieldId: FieldId,
+		protected readonly crossFieldTable: CrossFieldTable<T>,
+		private readonly currentFieldKey: T,
+		protected readonly allowInval = true,
 	) {}
 
-	public invertDetach(
-		detachId: ChangeAtomId,
+	public set(
+		target: CrossFieldTarget,
+		revision: RevisionTag | undefined,
+		id: ChangesetLocalId,
 		count: number,
-		nodeChange: NodeId | undefined,
-		newAttachId: ChangeAtomId,
+		newValue: unknown,
+		invalidateDependents: boolean,
 	): void {
-		if (nodeChange !== undefined) {
-			assert(count === 1, "A node change should only affect one node");
-
-			const attachEntry = firstAttachIdFromDetachId(
-				this.table.change.rootNodes,
-				detachId,
-				count,
-			);
-
-			const attachFieldEntry = this.table.change.crossFieldKeys.getFirst(
-				{ target: NodeMoveType.Attach, ...attachEntry.value },
-				count,
-			);
-
-			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),
+		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 (!areEqualChangeAtomIds(detachId, newAttachId)) {
-			for (const entry of doesChangeAttachNodes(
-				this.table.change.crossFieldKeys,
-				detachId,
-				count,
-			)) {
-				if (!entry.value) {
-					this.table.attachToDetachId.set(newAttachId, count, detachId);
-					this.table.invertedRoots.detachLocations.set(detachId, count, this.fieldId);
+				if (dependentEntry.value !== undefined) {
+					this.crossFieldTable.invalidatedFields.add(dependentEntry.value);
 				}
+
+				firstId = brand(firstId + dependentEntry.length);
 			}
 		}
+		setInCrossFieldMap(this.getMap(target), revision, id, count, newValue);
 	}
 
-	public invertAttach(
-		attachId: ChangeAtomId,
+	public get(
+		target: CrossFieldTarget,
+		revision: RevisionTag | undefined,
+		id: ChangesetLocalId,
 		count: number,
-	): RangeQueryResult<DetachedNodeEntry> {
-		let countToProcess = count;
-
-		const detachIdEntry = firstDetachIdFromAttachId(
-			this.table.change.rootNodes,
-			attachId,
-			countToProcess,
-		);
-
-		countToProcess = detachIdEntry.length;
-
-		const detachEntry = getFirstFieldForCrossFieldKey(
-			this.table.change,
-			{ target: NodeMoveType.Detach, ...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,
+		addDependency: boolean,
+	): RangeQueryResult<unknown> {
+		if (addDependency) {
+			// We assume that if there is already an entry for this ID it is because
+			// a field handler has called compose on the same node multiple times.
+			// In this case we only want to update the latest version, so we overwrite the dependency.
+			setInCrossFieldMap(
+				this.getDependents(target),
+				revision,
+				id,
+				count,
+				this.currentFieldKey,
 			);
-			countToProcess = nodeIdEntry.length;
+		}
+		return getFirstFromCrossFieldMap(this.getMap(target), revision, id, count);
+	}
 
-			const detachLocationEntry = this.table.change.rootNodes.detachLocations.getFirst(
-				detachIdEntry.value,
-				countToProcess,
-			);
-			countToProcess = detachLocationEntry.length;
+	public abstract onMoveIn(id: NodeId): void;
 
-			if (
-				this.table.isRollback &&
-				detachLocationEntry.value !== undefined &&
-				!areEqualFieldIds(
-					normalizeFieldId(detachLocationEntry.value, this.table.change.nodeAliases),
-					this.fieldId,
-				)
-			) {
-				// These nodes are detached in the input context of the original change,
-				// and the change attaches these nodes in a different location from their detach location.
-				// The rollback change should send them back to that prior detach location.
-				this.table.invertedRoots.outputDetachLocations.set(
-					detachIdEntry.value,
-					countToProcess,
-					detachLocationEntry.value,
-				);
-			}
+	public abstract moveKey(
+		target: CrossFieldTarget,
+		revision: RevisionTag | undefined,
+		id: ChangesetLocalId,
+		count: number,
+	): void;
 
-			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 getMap(target: CrossFieldTarget): CrossFieldMap<unknown> {
+		return target === CrossFieldTarget.Source
+			? this.crossFieldTable.srcTable
+			: this.crossFieldTable.dstTable;
+	}
 
-		if (result.value?.nodeChange !== undefined) {
-			setInChangeAtomIdMap(this.table.invertedNodeToParent, result.value.nodeChange, {
-				field: this.fieldId,
-			});
-		}
-		return result;
+	private getDependents(target: CrossFieldTarget): CrossFieldMap<T> {
+		return target === CrossFieldTarget.Source
+			? this.crossFieldTable.srcDependents
+			: this.crossFieldTable.dstDependents;
 	}
 }
 
-class RebaseNodeManagerI implements RebaseNodeManager {
+class InvertManager extends CrossFieldManagerI<FieldChange> {
 	public constructor(
-		private readonly table: RebaseTable,
+		table: InvertTable,
+		field: FieldChange,
 		private readonly fieldId: FieldId,
-		private readonly allowInval: boolean = true,
-	) {}
-
-	public getNewChangesForBaseAttach(
-		baseAttachId: ChangeAtomId,
-		count: number,
-	): RangeQueryResult<RebaseDetachedNodeEntry | undefined> {
-		let countToProcess = count;
+		allowInval = true,
+	) {
+		super(table, field, allowInval);
+	}
 
-		const detachEntry = firstDetachIdFromAttachId(
-			this.table.baseChange.rootNodes,
-			baseAttachId,
-			countToProcess,
-		);
+	public override onMoveIn(id: ChangeAtomId): void {
+		setInChangeAtomIdMap(this.table.invertedNodeToParent, id, this.fieldId);
+	}
 
-		countToProcess = detachEntry.length;
+	public override moveKey(
+		target: CrossFieldTarget,
+		revision: RevisionTag | undefined,
+		id: ChangesetLocalId,
+		count: number,
+	): void {
+		assert(false, 0x9c5 /* Keys should not be moved manually during invert */);
+	}
 
-		const nodeEntry = rangeQueryChangeAtomIdMap(
-			this.table.newChange.rootNodes.nodeChanges,
-			detachEntry.value,
-			countToProcess,
-		);
+	private get table(): InvertTable {
+		return this.crossFieldTable as InvertTable;
+	}
+}
 
-		countToProcess = nodeEntry.length;
-		const newNodeId = nodeEntry.value;
+class RebaseManager extends CrossFieldManagerI<FieldChange> {
+	public constructor(
+		table: RebaseTable,
+		currentField: FieldChange,
+		private readonly fieldId: FieldId,
+		allowInval = true,
+	) {
+		super(table, currentField, allowInval);
+	}
 
-		const newRenameEntry = this.table.newChange.rootNodes.oldToNewId.getFirst(
-			detachEntry.value,
-			countToProcess,
-		);
+	public override set(
+		target: CrossFieldTarget,
+		revision: RevisionTag | undefined,
+		id: ChangesetLocalId,
+		count: number,
+		newValue: unknown,
+		invalidateDependents: boolean,
+	): void {
+		if (invalidateDependents && this.allowInval) {
+			const newFieldIds = getFieldsForCrossFieldKey(
+				this.table.newChange,
+				{
+					target,
+					revision,
+					localId: id,
+				},
+				count,
+			);
 
-		countToProcess = newRenameEntry.length;
+			assert(
+				newFieldIds.length === 0,
+				0x9c6 /* TODO: Modifying a cross-field key from the new changeset is currently unsupported */,
+			);
 
-		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);
-		}
+			const baseFieldIds = getFieldsForCrossFieldKey(
+				this.table.baseChange,
+				{
+					target,
+					revision,
+					localId: id,
+				},
+				count,
+			);
 
-		// 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,
+			assert(
+				baseFieldIds.length > 0,
+				0x9c7 /* Cross field key not registered in base or new change */,
 			);
-		}
 
-		if (result.value?.nodeChange !== undefined) {
-			setInChangeAtomIdMap(this.table.rebasedNodeToParent, result.value.nodeChange, {
-				field: this.fieldId,
-			});
+			for (const baseFieldId of baseFieldIds) {
+				this.table.affectedBaseFields.set(
+					[baseFieldId.nodeId?.revision, baseFieldId.nodeId?.localId, baseFieldId.field],
+					true,
+				);
+			}
 		}
 
-		return result;
+		super.set(target, revision, id, count, newValue, invalidateDependents);
+	}
+
+	public override onMoveIn(id: ChangeAtomId): void {
+		setInChangeAtomIdMap(this.table.rebasedNodeToParent, id, this.fieldId);
 	}
 
-	public rebaseOverDetach(
-		baseDetachId: ChangeAtomId,
+	public override moveKey(
+		target: CrossFieldTarget,
+		revision: RevisionTag | undefined,
+		id: ChangesetLocalId,
 		count: number,
-		newDetachId: ChangeAtomId | undefined,
-		nodeChange: NodeId | undefined,
-		cellRename?: ChangeAtomId,
 	): void {
-		let countToProcess = count;
-		const attachIdEntry = firstAttachIdFromDetachId(
-			this.table.baseRoots,
-			baseDetachId,
-			countToProcess,
+		this.table.rebasedCrossFieldKeys.set(
+			{ target, revision, localId: id },
+			count,
+			this.fieldId,
 		);
-		const baseAttachId = attachIdEntry.value;
-		countToProcess = attachIdEntry.length;
+	}
 
-		const attachFieldEntry = getFirstFieldForCrossFieldKey(
-			this.table.baseChange,
-			{ ...baseAttachId, target: NodeMoveType.Attach },
-			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,
-			);
-		}
-	}
-
-	public addDetach(id: ChangeAtomId, count: number): void {
-		this.table.rebasedDetachLocations.set(id, count, this.fieldId);
-	}
-
-	public removeDetach(id: ChangeAtomId, count: number): void {
-		this.table.movedDetaches.set(id, count, true);
-	}
-
-	public doesBaseAttachNodes(
-		id: ChangeAtomId,
-		count: number,
-	): RangeQueryEntry<ChangeAtomId, boolean> {
-		let countToProcess = count;
-		const attachEntry = getFirstAttachField(
-			this.table.baseChange.crossFieldKeys,
-			id,
-			countToProcess,
-		);
-
-		countToProcess = attachEntry.length;
-		return { start: id, value: attachEntry.value !== undefined, length: countToProcess };
-	}
-
-	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);
-			}
-		}
+	private get table(): RebaseTable {
+		return this.crossFieldTable as RebaseTable;
 	}
 }
 
-function assignRootChange(
-	table: RootNodeTable,
-	nodeToParent: ChangeAtomIdBTree<NodeLocation>,
-	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);
-	setInChangeAtomIdMap(nodeToParent, nodeId, { root: detachId });
-
-	table.detachLocations.set(detachId, 1, detachLocation);
-}
-
-class ComposeNodeManagerI implements ComposeNodeManager {
+// TODO: Deduplicate this with RebaseTable
+class ComposeManager extends CrossFieldManagerI<FieldChange> {
 	public constructor(
-		private readonly table: ComposeTable,
+		table: ComposeTable,
+		currentField: FieldChange,
 		private readonly fieldId: FieldId,
-		private readonly allowInval: boolean = true,
-	) {}
-
-	public getNewChangesForBaseDetach(
-		baseDetachId: ChangeAtomId,
-		count: number,
-	): RangeQueryResult<DetachedNodeEntry | undefined> {
-		let countToProcess = count;
-
-		const baseAttachEntry = getFirstFieldForCrossFieldKey(
-			this.table.baseChange,
-			{ target: NodeMoveType.Attach, ...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;
+		allowInval = true,
+	) {
+		super(table, currentField, allowInval);
 	}
 
-	public composeAttachDetach(
-		baseAttachId: ChangeAtomId,
-		newDetachId: ChangeAtomId,
+	public override set(
+		target: CrossFieldTarget,
+		revision: RevisionTag | undefined,
+		id: ChangesetLocalId,
 		count: number,
+		newValue: unknown,
+		invalidateDependents: boolean,
 	): void {
-		let countToProcess = count;
-
-		const newAttachEntry = getFirstAttachField(
-			this.table.newChange.crossFieldKeys,
-			newDetachId,
-			countToProcess,
-		);
-
-		countToProcess = newAttachEntry.length;
-
-		// Both changes can have the same ID if they came from inverse changesets.
-		// If the new detach is part of a move,
-		// then both input changesets contain the attach cross-field key for this ID.
-		// The new attach may still exist in the composed changeset so we do not remove it here.
-		// The new attach will typically cancel with a base detach,
-		// in which case the cross-field key will be removed in `composeDetachAttach`.
-		const hasNewAttachWithBaseAttachId =
-			areEqualChangeAtomIds(baseAttachId, newDetachId) && newAttachEntry.value !== undefined;
-
-		if (!hasNewAttachWithBaseAttachId) {
-			this.table.removedCrossFieldKeys.set(
-				{ ...baseAttachId, target: NodeMoveType.Attach },
-				countToProcess,
-				true,
-			);
-		}
-
-		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: NodeMoveType.Detach },
-				countToProcess,
-				true,
+		if (invalidateDependents && this.allowInval) {
+			const newFieldIds = getFieldsForCrossFieldKey(
+				this.table.newChange,
+				{
+					target,
+					revision,
+					localId: id,
+				},
+				count,
 			);
-		} 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: NodeMoveType.Detach },
-					countToProcess,
-					true,
+			if (newFieldIds.length > 0) {
+				for (const newFieldId of newFieldIds) {
+					this.table.pendingCompositions.affectedNewFields.set(
+						[newFieldId.nodeId?.revision, newFieldId.nodeId?.localId, newFieldId.field],
+						true,
+					);
+				}
+			} else {
+				const baseFieldIds = getFieldsForCrossFieldKey(
+					this.table.baseChange,
+					{
+						target,
+						revision,
+						localId: id,
+					},
+					count,
 				);
-			}
-
-			this.table.movedCrossFieldKeys.set(
-				{ ...newDetachId, target: NodeMoveType.Detach },
-				countToProcess,
-				baseDetachEntry.value,
-			);
-
-			this.invalidateBaseFields([baseDetachEntry.value]);
-		}
 
-		if (newAttachEntry.value === undefined) {
-			const newOutputDetachLocationEntry =
-				this.table.newChange.rootNodes.outputDetachLocations.getFirst(
-					newDetachId,
-					countToProcess,
+				assert(
+					baseFieldIds.length > 0,
+					0x9c8 /* Cross field key not registered in base or new change */,
 				);
 
-			countToProcess = newOutputDetachLocationEntry.length;
-
-			this.table.composedRootNodes.outputDetachLocations.set(
-				newDetachId,
-				countToProcess,
-				newOutputDetachLocationEntry.value ?? this.fieldId,
-			);
+				for (const baseFieldId of baseFieldIds) {
+					this.table.pendingCompositions.affectedBaseFields.set(
+						[baseFieldId.nodeId?.revision, baseFieldId.nodeId?.localId, baseFieldId.field],
+						true,
+					);
+				}
+			}
 		}
 
-		if (countToProcess < count) {
-			const remainingCount = count - countToProcess;
-			this.composeAttachDetach(
-				offsetChangeAtomId(baseAttachId, countToProcess),
-				offsetChangeAtomId(newDetachId, countToProcess),
-				remainingCount,
-			);
-		}
+		super.set(target, revision, id, count, newValue, invalidateDependents);
 	}
 
-	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: NodeMoveType.Detach,
-			},
-			1,
-		);
-
-		if (detachFields.length > 0) {
-			// The base attach is part of a move in the base changeset.
-			const prevEntry = this.table.entries.getFirst(baseDetachId, 1).value ?? {};
-			this.table.entries.set(baseDetachId, 1, { ...prevEntry, nodeChange: newChanges });
-
-			if (newChanges !== undefined) {
-				this.invalidateBaseFields(detachFields);
-			}
-		} else {
-			const baseNodeId = getFromChangeAtomIdMap(
-				this.table.baseChange.rootNodes.nodeChanges,
-				baseDetachId,
-			);
-
-			if (baseNodeId === undefined) {
-				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);
 	}
 
-	public composeDetachAttach(
-		baseDetachId: ChangeAtomId,
-		newAttachId: ChangeAtomId,
+	public override moveKey(
+		target: CrossFieldTarget,
+		revision: RevisionTag | undefined,
+		id: ChangesetLocalId,
 		count: number,
-		composeToPin: boolean,
 	): void {
-		if (composeToPin) {
-			this.table.movedCrossFieldKeys.set(
-				{ target: NodeMoveType.Detach, ...newAttachId },
-				count,
-				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: NodeMoveType.Detach, ...baseDetachId },
-					count,
-					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: NodeMoveType.Attach, ...newAttachId },
-				count,
-				this.fieldId,
-			);
-		} else {
-			this.table.removedCrossFieldKeys.set(
-				{ target: NodeMoveType.Detach, ...baseDetachId },
-				count,
-				true,
-			);
-
-			this.table.removedCrossFieldKeys.set(
-				{ target: NodeMoveType.Attach, ...newAttachId },
-				count,
-				true,
-			);
-		}
+		throw new Error("Moving cross-field keys during compose is currently unsupported");
 	}
 
-	private invalidateBaseFields(fields: FieldId[]): void {
-		if (this.allowInval) {
-			for (const fieldId of fields) {
-				this.table.pendingCompositions.affectedBaseFields.set(
-					fieldIdKeyFromFieldId(fieldId),
-					true,
-				);
-			}
-		}
+	private get table(): ComposeTable {
+		return this.crossFieldTable as ComposeTable;
 	}
 }
 
 function makeModularChangeset(props?: {
-	rebaseVersion: RebaseVersion;
 	fieldChanges?: FieldChangeMap;
 	nodeChanges?: ChangeAtomIdBTree<NodeChangeset>;
-	rootNodes?: RootNodeTable;
-	nodeToParent?: ChangeAtomIdBTree<NodeLocation>;
+	nodeToParent?: ChangeAtomIdBTree<FieldId>;
 	nodeAliases?: ChangeAtomIdBTree<NodeId>;
 	crossFieldKeys?: CrossFieldKeyTable;
 	maxId: number;
@@ -3448,15 +2634,13 @@ function makeModularChangeset(props?: {
 	destroys?: ChangeAtomIdBTree<number>;
 	refreshers?: ChangeAtomIdBTree<TreeChunk>;
 }): ModularChangeset {
-	const p = props ?? { maxId: -1, rebaseVersion: 1 };
+	const p = props ?? { maxId: -1 };
 	const changeset: Mutable<ModularChangeset> = {
-		rebaseVersion: p.rebaseVersion,
 		fieldChanges: p.fieldChanges ?? new Map<FieldKey, FieldChange>(),
 		nodeChanges: p.nodeChanges ?? newChangeAtomIdBTree(),
-		rootNodes: p.rootNodes ?? newRootTable(),
 		nodeToParent: p.nodeToParent ?? newChangeAtomIdBTree(),
 		nodeAliases: p.nodeAliases ?? newChangeAtomIdBTree(),
-		crossFieldKeys: p.crossFieldKeys ?? newCrossFieldRangeTable(),
+		crossFieldKeys: p.crossFieldKeys ?? newCrossFieldKeyTable(),
 	};
 
 	if (p.revisions !== undefined && p.revisions.length > 0) {
@@ -3489,7 +2673,6 @@ function makeModularChangeset(props?: {
 	if (p.refreshers !== undefined && p.refreshers.size > 0) {
 		changeset.refreshers = p.refreshers;
 	}
-
 	return changeset;
 }
 
@@ -3497,26 +2680,16 @@ export class ModularEditBuilder extends EditBuilder<ModularChangeset> {
 	private transactionDepth: number = 0;
 	private idAllocator: IdAllocator;
 	private readonly codecOptions: CodecWriteOptions;
-	public readonly rebaseVersion: RebaseVersion;
 
 	public constructor(
 		family: ChangeFamily<ChangeFamilyEditor, ModularChangeset>,
 		private readonly fieldKinds: ReadonlyMap<FieldKindIdentifier, FlexFieldKind>,
 		changeReceiver: (change: TaggedChange<ModularChangeset>) => void,
 		codecOptions: CodecWriteOptions,
-		editorOptions?: ModularEditorOptions,
 	) {
 		super(family, changeReceiver);
 		this.idAllocator = idAllocatorFromMaxId();
 		this.codecOptions = codecOptions;
-		// TODO: make this dependent on the CodecWriteOptions once there is an FF version that supports RebaseVersion 2
-		this.rebaseVersion =
-			editorOptions?.rebaseVersionOverride ??
-			(editorOptions?.enableDetachedRootEditing === true ? 2 : 1);
-	}
-
-	public isInTransaction(): boolean {
-		return this.transactionDepth > 0;
 	}
 
 	public override enterTransaction(): void {
@@ -3573,7 +2746,7 @@ export class ModularEditBuilder extends EditBuilder<ModularChangeset> {
 	 * @param revision - the revision of the change
 	 */
 	public submitChange(
-		field: NormalizedFieldUpPath,
+		field: FieldUpPath,
 		fieldKind: FieldKindIdentifier,
 		change: FieldChangeset,
 		revision: RevisionTag,
@@ -3583,13 +2756,11 @@ export class ModularEditBuilder extends EditBuilder<ModularChangeset> {
 		);
 
 		const modularChange = buildModularChangesetFromField({
-			rebaseVersion: this.rebaseVersion,
 			path: field,
 			fieldChange: { fieldKind, change },
 			nodeChanges: newChangeAtomIdBTree(),
 			nodeToParent: newChangeAtomIdBTree(),
-			crossFieldKeys: newCrossFieldRangeTable(),
-			rootNodes: newRootTable(),
+			crossFieldKeys: newCrossFieldKeyTable(),
 			idAllocator: this.idAllocator,
 			localCrossFieldKeys,
 			revision,
@@ -3609,14 +2780,11 @@ export class ModularEditBuilder extends EditBuilder<ModularChangeset> {
 			return makeAnonChange(
 				change.type === "global"
 					? makeModularChangeset({
-							rebaseVersion: this.rebaseVersion,
 							maxId: this.idAllocator.getMaxId(),
 							builds: change.builds,
-							rootNodes: renameTableFromRenameDescriptions(change.renames ?? []),
 							revisions: [{ revision: change.revision }],
 						})
 					: buildModularChangesetFromField({
-							rebaseVersion: this.rebaseVersion,
 							path: change.field,
 							fieldChange: {
 								fieldKind: change.fieldKind,
@@ -3624,8 +2792,7 @@ export class ModularEditBuilder extends EditBuilder<ModularChangeset> {
 							},
 							nodeChanges: newChangeAtomIdBTree(),
 							nodeToParent: newChangeAtomIdBTree(),
-							crossFieldKeys: newCrossFieldRangeTable(),
-							rootNodes: newRootTable(),
+							crossFieldKeys: newCrossFieldKeyTable(),
 							idAllocator: this.idAllocator,
 							localCrossFieldKeys: getChangeHandler(
 								this.fieldKinds,
@@ -3652,7 +2819,7 @@ export class ModularEditBuilder extends EditBuilder<ModularChangeset> {
 		return brand(this.idAllocator.allocate(count));
 	}
 
-	public addNodeExistsConstraint(path: NormalizedUpPath, revision: RevisionTag): void {
+	public addNodeExistsConstraint(path: UpPath, revision: RevisionTag): void {
 		const nodeChange: NodeChangeset = {
 			nodeExistsConstraint: { violated: false },
 		};
@@ -3660,13 +2827,11 @@ export class ModularEditBuilder extends EditBuilder<ModularChangeset> {
 		this.applyChange(
 			tagChange(
 				buildModularChangesetFromNode({
-					rebaseVersion: this.rebaseVersion,
 					path,
 					nodeChange,
 					nodeChanges: newChangeAtomIdBTree(),
 					nodeToParent: newChangeAtomIdBTree(),
-					crossFieldKeys: newCrossFieldRangeTable(),
-					rootNodes: newRootTable(),
+					crossFieldKeys: newCrossFieldKeyTable(),
 					idAllocator: this.idAllocator,
 					revision,
 				}),
@@ -3675,7 +2840,7 @@ export class ModularEditBuilder extends EditBuilder<ModularChangeset> {
 		);
 	}
 
-	public addNodeExistsConstraintOnRevert(path: NormalizedUpPath, revision: RevisionTag): void {
+	public addNodeExistsConstraintOnRevert(path: UpPath, revision: RevisionTag): void {
 		const nodeChange: NodeChangeset = {
 			nodeExistsConstraintOnRevert: { violated: false },
 		};
@@ -3683,13 +2848,11 @@ export class ModularEditBuilder extends EditBuilder<ModularChangeset> {
 		this.applyChange(
 			tagChange(
 				buildModularChangesetFromNode({
-					rebaseVersion: this.rebaseVersion,
 					path,
 					nodeChange,
 					nodeChanges: newChangeAtomIdBTree(),
 					nodeToParent: newChangeAtomIdBTree(),
-					crossFieldKeys: newCrossFieldRangeTable(),
-					rootNodes: newRootTable(),
+					crossFieldKeys: newCrossFieldKeyTable(),
 					idAllocator: this.idAllocator,
 					revision,
 				}),
@@ -3706,7 +2869,6 @@ export class ModularEditBuilder extends EditBuilder<ModularChangeset> {
 		}
 
 		const changeset = makeModularChangeset({
-			rebaseVersion: this.rebaseVersion,
 			maxId: -1,
 			noChangeConstraint: { violated: false },
 		});
@@ -3722,7 +2884,6 @@ export class ModularEditBuilder extends EditBuilder<ModularChangeset> {
 		}
 
 		const changeset = makeModularChangeset({
-			rebaseVersion: this.rebaseVersion,
 			maxId: -1,
 			noChangeConstraintOnRevert: { violated: false },
 		});
@@ -3731,27 +2892,23 @@ export class ModularEditBuilder extends EditBuilder<ModularChangeset> {
 	}
 }
 
-export function buildModularChangesetFromField(props: {
-	rebaseVersion: RebaseVersion;
-	path: NormalizedFieldUpPath;
+function buildModularChangesetFromField(props: {
+	path: FieldUpPath;
 	fieldChange: FieldChange;
 	nodeChanges: ChangeAtomIdBTree<NodeChangeset>;
-	nodeToParent: ChangeAtomIdBTree<NodeLocation>;
+	nodeToParent: ChangeAtomIdBTree<FieldId>;
 	crossFieldKeys: CrossFieldKeyTable;
-	rootNodes: RootNodeTable;
 	localCrossFieldKeys?: CrossFieldKeyRange[];
 	revision: RevisionTag;
 	idAllocator?: IdAllocator;
 	childId?: NodeId;
 }): ModularChangeset {
 	const {
-		rebaseVersion,
 		path,
 		fieldChange,
 		nodeChanges,
 		nodeToParent,
 		crossFieldKeys,
-		rootNodes,
 		idAllocator = idAllocatorFromMaxId(),
 		localCrossFieldKeys = [],
 		childId,
@@ -3760,27 +2917,22 @@ export function buildModularChangesetFromField(props: {
 	const fieldChanges: FieldChangeMap = new Map([[path.field, fieldChange]]);
 
 	if (path.parent === undefined) {
-		const field = { nodeId: undefined, field: path.field };
 		for (const { key, count } of localCrossFieldKeys) {
-			crossFieldKeys.set(key, count, field);
+			crossFieldKeys.set(key, count, { nodeId: undefined, field: path.field });
 		}
 
 		if (childId !== undefined) {
 			setInChangeAtomIdMap(nodeToParent, childId, {
-				field: {
-					nodeId: undefined,
-					field: path.field,
-				},
+				nodeId: undefined,
+				field: path.field,
 			});
 		}
 
 		return makeModularChangeset({
-			rebaseVersion,
 			fieldChanges,
 			nodeChanges,
 			nodeToParent,
 			crossFieldKeys,
-			rootNodes,
 			maxId: idAllocator.getMaxId(),
 			revisions: [{ revision }],
 		});
@@ -3791,7 +2943,6 @@ export function buildModularChangesetFromField(props: {
 	};
 
 	const parentId: NodeId = { localId: brand(idAllocator.allocate()), revision };
-	const fieldId = { nodeId: parentId, field: path.field };
 
 	for (const { key, count } of localCrossFieldKeys) {
 		crossFieldKeys.set(key, count, { nodeId: parentId, field: path.field });
@@ -3799,18 +2950,17 @@ export function buildModularChangesetFromField(props: {
 
 	if (childId !== undefined) {
 		setInChangeAtomIdMap(nodeToParent, childId, {
-			field: fieldId,
+			nodeId: parentId,
+			field: path.field,
 		});
 	}
 
 	return buildModularChangesetFromNode({
-		rebaseVersion,
 		path: path.parent,
 		nodeChange: nodeChangeset,
 		nodeChanges,
 		nodeToParent,
 		crossFieldKeys,
-		rootNodes,
 		idAllocator,
 		revision,
 		nodeId: parentId,
@@ -3818,13 +2968,11 @@ export function buildModularChangesetFromField(props: {
 }
 
 function buildModularChangesetFromNode(props: {
-	rebaseVersion: RebaseVersion;
-	path: NormalizedUpPath;
+	path: UpPath;
 	nodeChange: NodeChangeset;
 	nodeChanges: ChangeAtomIdBTree<NodeChangeset>;
-	nodeToParent: ChangeAtomIdBTree<NodeLocation>;
+	nodeToParent: ChangeAtomIdBTree<FieldId>;
 	crossFieldKeys: CrossFieldKeyTable;
-	rootNodes: RootNodeTable;
 	idAllocator: IdAllocator;
 	revision: RevisionTag;
 	nodeId?: NodeId;
@@ -3838,44 +2986,27 @@ function buildModularChangesetFromNode(props: {
 		nodeId = { localId: brand(idAllocator.allocate()), revision },
 	} = props;
 	setInChangeAtomIdMap(nodeChanges, nodeId, nodeChange);
+	const fieldChangeset = genericFieldKind.changeHandler.editor.buildChildChanges([
+		[path.parentIndex, nodeId],
+	]);
 
-	if (isDetachedUpPathRoot(path)) {
-		props.rootNodes.nodeChanges.set(
-			[path.detachedNodeId.major, brand(path.detachedNodeId.minor)],
-			nodeId,
-		);
-		return makeModularChangeset({
-			rebaseVersion: props.rebaseVersion,
-			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,
-		};
+	const fieldChange: FieldChange = {
+		fieldKind: genericFieldKind.identifier,
+		change: fieldChangeset,
+	};
 
-		return buildModularChangesetFromField({
-			...props,
-			path: { parent: path.parent, field: path.parentField },
-			fieldChange,
-			localCrossFieldKeys: [],
-			childId: nodeId,
-		});
-	}
+	return buildModularChangesetFromField({
+		...props,
+		path: { parent: path.parent, field: path.parentField },
+		fieldChange,
+		localCrossFieldKeys: [],
+		childId: nodeId,
+	});
 }
 
 export interface FieldEditDescription {
 	type: "field";
-	field: NormalizedFieldUpPath;
+	field: FieldUpPath;
 	fieldKind: FieldKindIdentifier;
 	change: FieldChangeset;
 	revision: RevisionTag;
@@ -3885,23 +3016,6 @@ export interface GlobalEditDescription {
 	type: "global";
 	revision: RevisionTag;
 	builds?: ChangeAtomIdBTree<TreeChunk>;
-	renames?: RenameDescription[];
-}
-
-export interface RenameDescription {
-	count: number;
-	oldId: ChangeAtomId;
-	newId: ChangeAtomId;
-	detachLocation: FieldId | undefined;
-}
-
-function renameTableFromRenameDescriptions(renames: RenameDescription[]): RootNodeTable {
-	const table = newRootTable();
-	for (const rename of renames) {
-		addNodeRename(table, rename.oldId, rename.newId, rename.count, rename.detachLocation);
-	}
-
-	return table;
 }
 
 export type EditDescription = FieldEditDescription | GlobalEditDescription;
@@ -3925,6 +3039,20 @@ function getRevInfoFromTaggedChanges(changes: TaggedChange<ModularChangeset>[]):
 		}
 	}
 
+	const rolledBackRevisions: RevisionTag[] = [];
+	for (const info of revInfos) {
+		if (info.rollbackOf !== undefined) {
+			rolledBackRevisions.push(info.rollbackOf);
+		}
+	}
+
+	rolledBackRevisions.reverse();
+	for (const revision of rolledBackRevisions) {
+		if (!revisions.has(revision)) {
+			revInfos.push({ revision });
+		}
+	}
+
 	return { maxId: brand(maxId), revInfos };
 }
 
@@ -3944,28 +3072,25 @@ function revisionInfoFromTaggedChange(
 	return revInfos;
 }
 
-function fieldChangeFromId(change: ModularChangeset, id: FieldId): FieldChange {
-	const fieldId = normalizeFieldId(id, change.nodeAliases);
-	const fieldMap = fieldMapFromNodeId(
-		change.fieldChanges,
-		change.nodeChanges,
-		change.nodeAliases,
-		fieldId.nodeId,
-	);
+function fieldChangeFromId(
+	fields: FieldChangeMap,
+	nodes: ChangeAtomIdBTree<NodeChangeset>,
+	id: FieldId,
+): FieldChange {
+	const fieldMap = fieldMapFromNodeId(fields, nodes, id.nodeId);
 	return fieldMap.get(id.field) ?? fail(0xb25 /* No field exists for the given ID */);
 }
 
 function fieldMapFromNodeId(
 	rootFieldMap: FieldChangeMap,
 	nodes: ChangeAtomIdBTree<NodeChangeset>,
-	aliases: ChangeAtomIdBTree<NodeId>,
 	nodeId: NodeId | undefined,
 ): FieldChangeMap {
 	if (nodeId === undefined) {
 		return rootFieldMap;
 	}
 
-	const node = nodeChangeFromId(nodes, aliases, nodeId);
+	const node = nodeChangeFromId(nodes, nodeId);
 	assert(node.fieldChanges !== undefined, 0x9c9 /* Expected node to have field changes */);
 	return node.fieldChanges;
 }
@@ -3982,13 +3107,8 @@ function rebasedNodeIdFromBaseNodeId(table: RebaseTable, baseId: NodeId): NodeId
 	return getFromChangeAtomIdMap(table.baseToRebasedNodeId, baseId) ?? baseId;
 }
 
-function nodeChangeFromId(
-	nodes: ChangeAtomIdBTree<NodeChangeset>,
-	aliases: ChangeAtomIdBTree<NodeId>,
-	id: NodeId,
-): NodeChangeset {
-	const normalizedId = normalizeNodeId(id, aliases);
-	const node = getFromChangeAtomIdMap(nodes, normalizedId);
+function nodeChangeFromId(nodes: ChangeAtomIdBTree<NodeChangeset>, id: NodeId): NodeChangeset {
+	const node = getFromChangeAtomIdMap(nodes, id);
 	assert(node !== undefined, 0x9ca /* Unknown node ID */);
 	return node;
 }
@@ -3998,10 +3118,6 @@ function fieldIdFromFieldIdKey([revision, localId, field]: FieldIdKey): FieldId
 	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) };
@@ -4010,15 +3126,6 @@ function cloneNodeChangeset(nodeChangeset: NodeChangeset): NodeChangeset {
 	return { ...nodeChangeset };
 }
 
-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;
@@ -4030,16 +3137,10 @@ function replaceFieldIdRevision(fieldId: FieldId, replacer: RevisionReplacer): F
 	};
 }
 
-export function getNodeParent(changeset: ModularChangeset, nodeId: NodeId): NodeLocation {
-	const normalizedNodeId = normalizeNodeId(nodeId, changeset.nodeAliases);
-	const location = getFromChangeAtomIdMap(changeset.nodeToParent, normalizedNodeId);
-	assert(location !== undefined, 0x9cb /* Parent field should be defined */);
-
-	if (location.field !== undefined) {
-		return { field: normalizeFieldId(location.field, changeset.nodeAliases) };
-	}
-
-	return location;
+export function getParentFieldId(changeset: ModularChangeset, nodeId: NodeId): FieldId {
+	const parentId = getFromChangeAtomIdMap(changeset.nodeToParent, nodeId);
+	assert(parentId !== undefined, 0x9cb /* Parent field should be defined */);
+	return normalizeFieldId(parentId, changeset.nodeAliases);
 }
 
 function getFieldsForCrossFieldKey(
@@ -4047,33 +3148,14 @@ function getFieldsForCrossFieldKey(
 	key: CrossFieldKey,
 	count: number,
 ): FieldId[] {
-	return changeset.crossFieldKeys
-		.getAll(key, count)
-		.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) };
+	const fieldIds: FieldId[] = [];
+	for (const { value: fieldId } of changeset.crossFieldKeys.getAll(key, count)) {
+		if (fieldId !== undefined) {
+			fieldIds.push(normalizeFieldId(fieldId, changeset.nodeAliases));
+		}
 	}
 
-	return location;
+	return fieldIds;
 }
 
 // This is only exported for use in test utilities.
@@ -4089,12 +3171,8 @@ export function normalizeFieldId(
 /**
  * @returns The canonical form of nodeId, according to nodeAliases
  */
-export function normalizeNodeId(
-	nodeId: NodeId,
-	nodeAliases: ChangeAtomIdBTree<NodeId>,
-): NodeId {
+function normalizeNodeId(nodeId: NodeId, nodeAliases: ChangeAtomIdBTree<NodeId>): NodeId {
 	let currentId = nodeId;
-	let cycleProbeId: NodeId | undefined = nodeId;
 
 	// eslint-disable-next-line no-constant-condition
 	while (true) {
@@ -4104,16 +3182,6 @@ export function normalizeNodeId(
 		}
 
 		currentId = dealiased;
-
-		if (cycleProbeId !== undefined) {
-			cycleProbeId = getFromChangeAtomIdMap(nodeAliases, cycleProbeId);
-		}
-
-		if (cycleProbeId !== undefined) {
-			cycleProbeId = getFromChangeAtomIdMap(nodeAliases, cycleProbeId);
-		}
-
-		assert(!areEqualChangeAtomIdOpts(cycleProbeId, currentId), "Alias cycle detected");
 	}
 }
 
@@ -4121,11 +3189,23 @@ function hasConflicts(change: ModularChangeset): boolean {
 	return (change.constraintViolationCount ?? 0) > 0;
 }
 
+/**
+ * A rebaseChild callback for fields with no new changes.
+ * Asserts that there are no new changes and returns undefined.
+ */
+function noNewChangesRebaseChild(
+	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;
+}
+
 interface ModularChangesetContent {
 	fieldChanges: FieldChangeMap;
 	nodeChanges: ChangeAtomIdBTree<NodeChangeset>;
-	nodeToParent: ChangeAtomIdBTree<NodeLocation>;
-	rootNodes: RootNodeTable;
+	nodeToParent: ChangeAtomIdBTree<FieldId>;
 	nodeAliases: ChangeAtomIdBTree<NodeId>;
 	crossFieldKeys: CrossFieldKeyTable;
 }
@@ -4134,1028 +3214,7 @@ 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: NodeMoveType.Detach }, entry.length);
-	}
-
-	for (const entry of newDetachLocations.entries()) {
-		rebasedTable.set(
-			{ ...entry.start, target: NodeMoveType.Detach },
-			entry.length,
-			entry.value,
-		);
-	}
-
-	return rebasedTable;
-}
-
-export function newRootTable(): RootNodeTable {
-	return {
-		newToOldId: newChangeAtomIdTransform(),
-		oldToNewId: newChangeAtomIdTransform(),
-		nodeChanges: newChangeAtomIdBTree(),
-		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: NodeMoveType.Attach, ...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: NodeMoveType.Attach,
-		},
-		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: NodeMoveType.Detach },
-				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: NodeMoveType.Detach },
-				countToProcess,
-				true,
-			);
-		}
-
-		movedCrossFieldKeys.set(
-			{ ...newId, target: NodeMoveType.Detach },
-			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,
-	invertedNodeToParent: ChangeAtomIdBTree<NodeLocation>,
-	isRollback: boolean,
-): RootNodeTable {
-	const invertedRoots: RootNodeTable = newRootTable();
-
-	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);
-		}
-	}
-
-	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: NodeMoveType.Attach }, 1)
-				.value === undefined
-		) {
-			assignRootChange(
-				invertedRoots,
-				invertedNodeToParent,
-				renamedId,
-				nodeId,
-				change.rootNodes.detachLocations.getFirst(detachId, 1).value,
-				change.rebaseVersion,
-			);
-		}
-	}
-
-	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 outputDetachEntry = change.rootNodes.outputDetachLocations.getFirst(
-		newId,
-		countProcessed,
-	);
-	countProcessed = outputDetachEntry.length;
-
-	const inputDetachEntry = change.rootNodes.detachLocations.getFirst(oldId, countProcessed);
-	countProcessed = inputDetachEntry.length;
-
-	const attachEntry = getFirstAttachField(change.crossFieldKeys, newId, countProcessed);
-	countProcessed = attachEntry.length;
-	if (attachEntry.value === undefined) {
-		addNodeRename(
-			invertedRoots,
-			newId,
-			oldId,
-			countProcessed,
-			outputDetachEntry.value ?? inputDetachEntry.value,
-		);
-
-		// The original change moves the detached node, so the inverse should also record a move back to the original location.
-		if (outputDetachEntry.value !== undefined && inputDetachEntry.value !== undefined) {
-			invertedRoots.outputDetachLocations.set(oldId, countProcessed, inputDetachEntry.value);
-		}
-	}
-
-	if (countProcessed < length) {
-		invertRename(
-			change,
-			invertedRoots,
-			offsetChangeAtomId(oldId, countProcessed),
-			offsetChangeAtomId(newId, countProcessed),
-			length - countProcessed,
-		);
-	}
-}
-
-function doesChangeAttachNodes(
-	table: CrossFieldKeyTable,
-	id: ChangeAtomId,
-	count: number,
-): RangeQueryResultFragment<boolean>[] {
-	return table
-		.getAll2({ ...id, target: NodeMoveType.Attach }, count)
-		.map((entry) => ({ ...entry, value: entry.value !== undefined }));
-}
-
-function doesChangeDetachNodes(
-	table: CrossFieldKeyTable,
-	id: ChangeAtomId,
-	count: number,
-): RangeQueryResultFragment<boolean>[] {
-	return table
-		.getAll2({ ...id, target: NodeMoveType.Detach }, count)
-		.map((entry) => ({ ...entry, value: entry.value !== undefined }));
-}
-
-export function getFirstDetachField(
-	table: CrossFieldKeyTable,
-	id: ChangeAtomId,
-	count: number,
-): RangeQueryResult<FieldId | undefined> {
-	return table.getFirst({ target: NodeMoveType.Detach, ...id }, count);
-}
-
-export function getFirstAttachField(
-	table: CrossFieldKeyTable,
-	id: ChangeAtomId,
-	count: number,
-): RangeQueryResult<FieldId | undefined> {
-	return table.getFirst({ target: NodeMoveType.Attach, ...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> = newFieldIdKeyBTree();
-	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[]> = newFieldIdKeyBTree();
-	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,
-			);
-		}
-	}
-
-	if (!containsRollbacks(change)) {
-		for (const entry of change.crossFieldKeys.entries()) {
-			if (entry.start.target !== NodeMoveType.Attach) {
-				continue;
-			}
-
-			validateAttach(change, entry.start, entry.length);
-		}
-	}
-
-	assert(unreachableNodes.size === 0, "Unreachable nodes found");
-	assert(unreachableCFKs.entries().length === 0, "Unreachable cross-field keys found");
-}
-
-function containsRollbacks(change: ModularChangeset): boolean {
-	if (change.revisions === undefined) {
-		return false;
-	}
-
-	for (const revInfo of change.revisions) {
-		if (revInfo.rollbackOf !== undefined) {
-			return true;
-		}
-	}
-	return false;
-}
-
-function validateAttach(
-	changeset: ModularChangeset,
-	attachId: ChangeAtomId,
-	count: number,
-): void {
-	let countProcessed = count;
-	const buildEntry = hasBuildForIdRange(changeset.builds, attachId, count);
-	countProcessed = buildEntry.length;
-
-	const detachEntry = changeset.crossFieldKeys.getFirst(
-		{ ...attachId, target: NodeMoveType.Detach },
-		countProcessed,
-	);
-	countProcessed = detachEntry.length;
-
-	const renameEntry = changeset.rootNodes.newToOldId.getFirst(attachId, countProcessed);
-	countProcessed = renameEntry.length;
-
-	// assert(
-	// 	buildEntry.value || detachEntry.value !== undefined || renameEntry.value !== undefined,
-	// 	"No build, detach, or rename found for attach",
-	// );
-
-	if (countProcessed < count) {
-		validateAttach(
-			changeset,
-			offsetChangeAtomId(attachId, countProcessed),
-			count - countProcessed,
-		);
-	}
-}
-
-function hasBuildForIdRange(
-	builds: ChangeAtomIdBTree<TreeChunk> | undefined,
-	id: ChangeAtomId,
-	count: number,
-): RangeQueryResult<boolean> {
-	if (builds === undefined) {
-		return { value: false, length: count };
-	}
-
-	const prevBuildEntry = builds.nextLowerPair([id.revision, id.localId]);
-
-	if (prevBuildEntry !== undefined) {
-		const prevBuildKey: ChangeAtomId = {
-			revision: prevBuildEntry[0][0],
-			localId: prevBuildEntry[0][1],
-		};
-
-		const prevBuildLength = prevBuildEntry[1].topLevelLength;
-		const lastLocalId = prevBuildKey.localId + prevBuildLength - 1;
-		if (prevBuildKey.revision === id.revision && lastLocalId >= id.localId) {
-			return { value: true, length: Math.min(count, lastLocalId - id.localId + 1) };
-		}
-	}
-
-	const buildEntry = rangeQueryChangeAtomIdMap(builds, id, count);
-	const length =
-		buildEntry.value === undefined ? buildEntry.length : buildEntry.value.topLevelLength;
-
-	const hasBuild = buildEntry.value !== undefined;
-	return { value: hasBuild, length };
-}
-
-/**
- * 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);
-		}
-	}
-}
-
-export function newFieldIdKeyBTree<V>(): TupleBTree<FieldIdKey, V> {
+function newFieldIdKeyBTree<V>(): TupleBTree<FieldIdKey, V> {
 	return newTupleBTree(compareFieldIdKeys);
 }