@fluidframework/tree 2.90.0-378676 → 2.90.0

package/lib/feature-libraries/modular-schema/modularChangeFamily.js

@@ -7,13 +7,13 @@ import { UsageError } from "@fluidframework/telemetry-utils/internal";
 import { BTree } from "@tylerbu/sorted-btree-es6";
 import { lt } from "semver-ts";
 import { FluidClientVersion, } from "../../codec/index.js";
-import { EditBuilder, makeDetachedNodeId, revisionMetadataSourceFromInfo, areEqualChangeAtomIds, areEqualChangeAtomIdOpts, tagChange, makeAnonChange, mapTaggedChange, newChangeAtomIdRangeMap, newChangeAtomIdTransform, offsetChangeAtomId, isDetachedUpPathRoot, subtractChangeAtomIds, makeChangeAtomId, comparePartialRevisions, comparePartialChangesetLocalIds, } from "../../core/index.js";
-import { brand, idAllocatorFromMaxId, idAllocatorFromState, getOrCreate, mergeTupleBTrees, RangeMap, balancedReduce, compareStrings, createTupleComparator, newTupleBTree, } from "../../util/index.js";
-import { getFromChangeAtomIdMap, rangeQueryChangeAtomIdMap, newChangeAtomIdBTree, setInChangeAtomIdMap, } from "../changeAtomIdBTree.js";
-import { NodeMoveType, setInCrossFieldMap, } from "./crossFieldQueries.js";
+import { EditBuilder, makeDetachedNodeId, revisionMetadataSourceFromInfo, areEqualChangeAtomIds, areEqualChangeAtomIdOpts, tagChange, makeAnonChange, newChangeAtomIdRangeMap, mapTaggedChange, comparePartialRevisions, comparePartialChangesetLocalIds, } from "../../core/index.js";
+import { brand, idAllocatorFromMaxId, idAllocatorFromState, getOrCreate, mergeTupleBTrees, RangeMap, balancedReduce, newTupleBTree, compareStrings, createTupleComparator, } from "../../util/index.js";
+import { getFromChangeAtomIdMap, newChangeAtomIdBTree, setInChangeAtomIdMap, } from "../changeAtomIdBTree.js";
+import { CrossFieldTarget, getFirstFromCrossFieldMap, setInCrossFieldMap, } from "./crossFieldQueries.js";
 import { NodeAttachState, } from "./fieldChangeHandler.js";
 import { convertGenericChange, genericFieldKind } from "./genericFieldKind.js";
-import { newCrossFieldRangeTable, } from "./modularChangeTypes.js";
+import { newCrossFieldKeyTable, } from "./modularChangeTypes.js";
 /**
  * Implementation of ChangeFamily which delegates work in a given field to the appropriate FieldKind
  * as determined by the schema.
@@ -69,23 +69,21 @@ export class ModularChangeFamily {
         return convertedChange;
     }
     compose(changes) {
-        const { maxId } = getRevInfoFromTaggedChanges(changes);
+        const { revInfos, maxId } = getRevInfoFromTaggedChanges(changes);
         const idState = { maxId };
         const pairwiseDelegate = (left, right) => {
-            return this.composePair(left, right, idState);
+            return this.composePair(left, right, revInfos, idState);
         };
         const innerChanges = changes.map((change) => change.change);
         return balancedReduce(innerChanges, pairwiseDelegate, makeModularChangeset);
     }
-    composePair(change1, change2, idState) {
-        const revInfos = composeRevInfos(change1.revisions, change2.revisions);
-        const { fieldChanges, nodeChanges, nodeToParent, nodeAliases, crossFieldKeys, rootNodes } = this.composeAllFields(change1, change2, revInfos, idState);
+    composePair(change1, change2, revInfos, idState) {
+        const { fieldChanges, nodeChanges, nodeToParent, nodeAliases, crossFieldKeys } = this.composeAllFields(change1, change2, revInfos, idState);
         const { allBuilds, allDestroys, allRefreshers } = composeBuildsDestroysAndRefreshers(change1, change2);
         // The composed changeset has a "no change" constraint if either change has one
         const noChangeConstraint = change1.noChangeConstraint ?? change2.noChangeConstraint;
         const noChangeConstraintOnRevert = change1.noChangeConstraintOnRevert ?? change2.noChangeConstraintOnRevert;
-        const composed = makeModularChangeset({
-            rebaseVersion: Math.max(change1.rebaseVersion, change2.rebaseVersion),
+        return makeModularChangeset({
             fieldChanges,
             nodeChanges,
             nodeToParent,
@@ -93,16 +91,12 @@ 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;
     }
     composeAllFields(potentiallyConflictedChange1, potentiallyConflictedChange2, revInfos, idState) {
         // Our current cell ordering scheme in sequences depends on being able to rebase over a change with conflicts.
@@ -123,50 +117,34 @@ export class ModularChangeFamily {
         const composedNodeChanges = brand(mergeTupleBTrees(change1.nodeChanges, change2.nodeChanges));
         const composedNodeToParent = brand(mergeTupleBTrees(change1.nodeToParent, change2.nodeToParent));
         const composedNodeAliases = brand(mergeTupleBTrees(change1.nodeAliases, change2.nodeAliases));
-        const pendingCompositions = {
-            nodeIdsToCompose: [],
-            affectedBaseFields: newFieldIdKeyBTree(),
-        };
-        const movedCrossFieldKeys = newCrossFieldRangeTable();
-        const removedCrossFieldKeys = 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, change2.fieldChanges, undefined, genId, crossFieldTable, revisionMetadata);
         this.composeInvalidatedElements(crossFieldTable, composedFields, composedNodeChanges, composedNodeToParent, composedNodeAliases, genId, 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,
         };
     }
     composeInvalidatedField(fieldChange, crossFieldTable, genId, revisionMetadata) {
         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, child2) => {
-            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 */);
         };
-        const amendedChange = rebaser.compose(fieldChange1, fieldChange2, composeNodes, genId, new ComposeNodeManagerI(crossFieldTable, context.fieldId, false), revisionMetadata);
+        const amendedChange = rebaser.compose(fieldChange1, fieldChange2, composeNodes, genId, new ComposeManager(crossFieldTable, fieldChange, fieldId, false), revisionMetadata);
         composedChange.change = brand(amendedChange);
     }
     /**
@@ -175,23 +153,32 @@ 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.
      */
     composeInvalidatedElements(table, composedFields, composedNodes, composedNodeToParent, nodeAliases, genId, metadata) {
         const pending = table.pendingCompositions;
-        while (pending.nodeIdsToCompose.length > 0 || pending.affectedBaseFields.length > 0) {
-            this.processPendingNodeCompositions(table, composedNodes, composedNodeToParent, nodeAliases, genId, metadata);
-            this.composeAffectedFields(table, table.baseChange, pending.affectedBaseFields, composedFields, composedNodes, genId, metadata);
+        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, genId, metadata);
+            this.composeAffectedFields(table, table.newChange, false, pending.affectedNewFields, composedFields, composedNodes, genId, metadata);
+            this.processInvalidatedCompositions(table, genId, metadata);
         }
     }
-    processPendingNodeCompositions(table, composedNodes, composedNodeToParent, nodeAliases, genId, metadata) {
-        // Note that the call to `composeNodesById` can add entries to `crossFieldTable.nodeIdPairs`.
-        for (const [id1, id2] of table.pendingCompositions.nodeIdsToCompose) {
-            this.composeNodesById(table.baseChange, table.newChange, composedNodes, composedNodeToParent, nodeAliases, id1, id2, genId, table, metadata);
+    processInvalidatedCompositions(table, genId, 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;
     }
     /**
      * Ensures that each field in `affectedFields` has been updated in the composition output.
@@ -204,34 +191,39 @@ export class ModularChangeFamily {
      * If not, they are assumed to be part of the new changeset.
      * @param affectedFields - The set of fields to process.
      */
-    composeAffectedFields(table, change, affectedFields, composedFields, composedNodes, genId, metadata) {
-        const fieldsToProcess = affectedFields.clone();
-        affectedFields.clear();
-        for (const fieldIdKey of fieldsToProcess.keys()) {
-            const fieldId = fieldIdFromFieldIdKey(fieldIdKey);
-            const fieldChange = fieldChangeFromId(change, fieldId);
+    composeAffectedFields(table, change, areBaseFields, affectedFields, composedFields, composedNodes, genId, metadata) {
+        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);
+                // 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;
             }
-            else {
-                this.composeFieldWithNoNewChange(table, fieldChange, fieldId, composedFields, composedNodes, genId, metadata);
+            const emptyChange = this.createEmptyFieldChange(fieldChange.fieldKind);
+            const [change1, change2] = areBaseFields
+                ? [fieldChange, emptyChange]
+                : [emptyChange, fieldChange];
+            const composedField = this.composeFieldChanges(fieldId, change1, change2, genId, table, metadata);
+            if (fieldId.nodeId === undefined) {
+                composedFields.set(fieldId.field, composedField);
+                continue;
             }
+            const nodeId = getFromChangeAtomIdMap(table.newToBaseNodeId, fieldId.nodeId) ?? fieldId.nodeId;
+            let nodeChangeset = nodeChangeFromId(composedNodes, nodeId);
+            if (!table.composedNodes.has(nodeChangeset)) {
+                nodeChangeset = cloneNodeChangeset(nodeChangeset);
+                setInChangeAtomIdMap(composedNodes, nodeId, nodeChangeset);
+            }
+            // 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);
         }
-    }
-    composeFieldWithNoNewChange(table, baseFieldChange, fieldId, composedFields, composedNodes, genId, metadata) {
-        const emptyChange = this.createEmptyFieldChange(baseFieldChange.fieldKind);
-        const composedField = this.composeFieldChanges(fieldId, baseFieldChange, emptyChange, genId, table, metadata);
-        if (fieldId.nodeId === undefined) {
-            composedFields.set(fieldId.field, composedField);
-            return;
-        }
-        const nodeId = normalizeNodeId(getFromChangeAtomIdMap(table.newToBaseNodeId, fieldId.nodeId) ?? fieldId.nodeId, table.baseChange.nodeAliases);
-        // We clone the node changeset before mutating it, as it may be from one of the input changesets.
-        const nodeChangeset = cloneNodeChangeset(nodeChangeFromId(composedNodes, table.baseChange.nodeAliases, nodeId));
-        setInChangeAtomIdMap(composedNodes, nodeId, nodeChangeset);
-        nodeChangeset.fieldChanges ??= new Map();
-        nodeChangeset.fieldChanges.set(fieldId.field, composedField);
+        affectedFields.clear();
     }
     composeFieldMaps(change1, change2, parentId, genId, crossFieldTable, revisionMetadata) {
         const composedFields = new Map();
@@ -241,14 +233,6 @@ export class ModularChangeFamily {
         for (const [field, fieldChange1] of change1) {
             const 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
                 : this.composeFieldChanges(fieldId, fieldChange1, fieldChange2, genId, crossFieldTable, revisionMetadata);
@@ -268,16 +252,17 @@ 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`.
      */
     composeFieldChanges(fieldId, change1, change2, idAllocator, crossFieldTable, revisionMetadata) {
         const { fieldKind, changeHandler, change1: change1Normalized, 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 */);
         }, idAllocator, manager, revisionMetadata);
@@ -294,18 +279,19 @@ export class ModularChangeFamily {
         crossFieldTable.newFieldToBaseField.set(change2, change1);
         return composedField;
     }
-    composeNodesById(change1, change2, composedNodes, composedNodeToParent, composedAliases, id1, id2, idAllocator, crossFieldTable, revisionMetadata) {
-        const nodeChangeset1 = nodeChangeFromId(change1.nodeChanges, change1.nodeAliases, id1);
-        const nodeChangeset2 = nodeChangeFromId(change2.nodeChanges, change2.nodeAliases, id2);
+    composeNodesById(nodeChanges1, nodeChanges2, composedNodes, composedNodeToParent, nodeAliases, id1, id2, idAllocator, crossFieldTable, revisionMetadata) {
+        const nodeChangeset1 = nodeChangeFromId(nodeChanges1, id1);
+        const nodeChangeset2 = nodeChangeFromId(nodeChanges2, id2);
         const composedNodeChangeset = this.composeNodeChanges(id1, nodeChangeset1, nodeChangeset2, idAllocator, crossFieldTable, revisionMetadata);
         setInChangeAtomIdMap(composedNodes, id1, composedNodeChangeset);
         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);
     }
     composeNodeChanges(nodeId, change1, change2, genId, crossFieldTable, revisionMetadata) {
         // WARNING: this composition logic assumes that we never make compositions of the following form:
@@ -351,24 +337,16 @@ export class ModularChangeFamily {
         const noChangeConstraintOnRevert = change.change.noChangeConstraint;
         if (hasConflicts(change.change)) {
             return makeModularChangeset({
-                rebaseVersion: change.change.rebaseVersion,
                 maxId: change.change.maxId,
                 revisions: revInfos,
                 destroys,
             });
         }
         const genId = idAllocatorFromMaxId(change.change.maxId ?? -1);
-        const invertedNodeToParent = brand(change.change.nodeToParent.clone());
         const crossFieldTable = {
-            change: change.change,
-            isRollback,
-            entries: newChangeAtomIdRangeMap(),
+            ...newCrossFieldTable(),
             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);
@@ -384,19 +362,16 @@ export class ModularChangeFamily {
                 const originalFieldChange = fieldChange.change;
                 const context = crossFieldTable.originalFieldToContext.get(fieldChange);
                 assert(context !== undefined, 0x851 /* Should have context for every invalidated field */);
-                const { invertedField } = context;
-                const amendedChange = getChangeHandler(this.fieldKinds, fieldChange.fieldKind).rebaser.invert(originalFieldChange, isRollback, genId, revisionForInvert, new InvertNodeManagerI(crossFieldTable, context.fieldId), revisionMetadata);
+                const { invertedField, fieldId } = context;
+                const amendedChange = getChangeHandler(this.fieldKinds, fieldChange.fieldKind).rebaser.invert(originalFieldChange, isRollback, genId, revisionForInvert, new InvertManager(crossFieldTable, fieldChange, fieldId), revisionMetadata);
                 invertedField.change = brand(amendedChange);
             }
         }
         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(),
@@ -412,7 +387,7 @@ export class ModularChangeFamily {
         const invertedFields = new Map();
         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).rebaser.invert(fieldChange.change, isRollback, genId, revisionForInvert, manager, revisionMetadata);
             const invertedFieldChange = {
                 ...fieldChange,
@@ -444,12 +419,6 @@ export class ModularChangeFamily {
         }
         return inverse;
     }
-    processInvertRenames(table) {
-        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);
-        }
-    }
     rebase(taggedChange, potentiallyConflictedOver, revisionMetadata) {
         // Our current cell ordering scheme in sequences depends on being able to rebase over a change with conflicts.
         // This means that we must rebase over a muted version of the conflicted changeset.
@@ -460,26 +429,17 @@ export class ModularChangeFamily {
         const maxId = Math.max(change.maxId ?? -1, over.change.maxId ?? -1);
         const idState = { maxId };
         const genId = idAllocatorFromState(idState);
-        const affectedBaseFields = newFieldIdKeyBTree();
-        const nodesToRebase = [];
-        const rebasedNodeToParent = brand(change.nodeToParent.clone());
-        const rebaseVersion = Math.max(change.rebaseVersion, over.change.rebaseVersion);
-        const rebasedRootNodes = rebaseRoots(change, over.change, affectedBaseFields, nodesToRebase, rebasedNodeToParent, rebaseVersion);
         const crossFieldTable = {
-            rebaseVersion,
-            entries: newDetachedEntryMap(),
+            ...newCrossFieldTable(),
             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(),
         };
         const getBaseRevisions = () => revisionInfoFromTaggedChange(over).map((info) => info.revision);
@@ -489,9 +449,8 @@ export class ModularChangeFamily {
             getBaseRevisions,
         };
         const rebasedNodes = brand(change.nodeChanges.clone());
-        const rebasedFields = this.rebaseIntersectingFields(nodesToRebase, crossFieldTable, rebasedNodes, genId, rebaseMetadata);
-        this.rebaseInvalidatedFields(rebasedFields, rebasedNodes, crossFieldTable, rebaseMetadata, genId);
-        fixupRebasedDetachLocations(crossFieldTable);
+        const rebasedFields = this.rebaseIntersectingFields(crossFieldTable, rebasedNodes, genId, rebaseMetadata);
+        this.rebaseInvalidatedElements(rebasedFields, rebasedNodes, crossFieldTable, rebaseMetadata, genId);
         const constraintState = newConstraintState(change.constraintViolationCount ?? 0);
         const revertConstraintState = newConstraintState(change.constraintViolationCountOnRevert ?? 0);
         let noChangeConstraint = change.noChangeConstraint;
@@ -499,17 +458,13 @@ export class ModularChangeFamily {
             noChangeConstraint = { violated: true };
             constraintState.violationCount += 1;
         }
-        this.updateConstraints(rebasedFields, rebasedNodes, rebasedRootNodes, constraintState, revertConstraintState);
-        const fieldsWithRootMoves = getFieldsWithRootMoves(crossFieldTable.rebasedRootNodes, change.nodeAliases);
-        const fieldToRootChanges = getFieldToRootChanges(crossFieldTable.rebasedRootNodes, change.nodeAliases);
+        this.updateConstraintsForFields(rebasedFields, NodeAttachState.Attached, NodeAttachState.Attached, constraintState, revertConstraintState, 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,
@@ -519,22 +474,15 @@ 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?
-    rebaseIntersectingFields(rootChanges, crossFieldTable, rebasedNodes, genId, metadata) {
+    rebaseIntersectingFields(crossFieldTable, rebasedNodes, genId, metadata) {
         const change = crossFieldTable.newChange;
         const baseChange = crossFieldTable.baseChange;
         const rebasedFields = this.rebaseFieldMap(change.fieldChanges, baseChange.fieldChanges, undefined, genId, crossFieldTable, 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) {
@@ -543,85 +491,83 @@ export class ModularChangeFamily {
         }
         return rebasedFields;
     }
-    rebaseFieldWithoutNewChanges(baseFieldChange, baseFieldId, crossFieldTable, rebasedFields, rebasedNodes, genId, metadata, 
-    /**
-     * The ID of a node in `baseFieldChange` which should be included in the rebased field change.
-     */
-    baseNodeId) {
-        // 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, baseChild, stateChange) => {
-            assert(child === undefined, 0x9c3 /* There should be no new changes in this field */);
-            if (baseChild === undefined || baseNodeId === undefined) {
-                return undefined;
-            }
-            return areEqualChangeAtomIds(normalizeNodeId(baseChild, crossFieldTable.baseChange.nodeAliases), baseNodeId)
-                ? baseNodeId
-                : undefined;
-        };
-        const handler = getChangeHandler(this.fieldKinds, baseFieldChange.fieldKind);
-        const fieldChange = {
-            ...baseFieldChange,
-            change: brand(handler.createEmpty()),
-        };
-        const rebasedNodeId = baseFieldId.nodeId === undefined
-            ? undefined
-            : rebasedNodeIdFromBaseNodeId(crossFieldTable, baseFieldId.nodeId);
-        const fieldId = { nodeId: rebasedNodeId, field: baseFieldId.field };
-        const rebasedField = handler.rebaser.rebase(fieldChange.change, baseFieldChange.change, rebaseChild, genId, new RebaseNodeManagerI(crossFieldTable, fieldId), metadata, crossFieldTable.rebaseVersion);
-        const rebasedFieldChange = {
-            ...baseFieldChange,
-            change: brand(rebasedField),
-        };
-        const context = {
-            newChange: fieldChange,
-            baseChange: baseFieldChange,
-            rebasedChange: rebasedFieldChange,
-            fieldId,
-            baseNodeIds: newChangeAtomIdBTree(),
-        };
-        if (baseNodeId !== undefined) {
-            setInChangeAtomIdMap(context.baseNodeIds, baseNodeId, true);
-        }
-        crossFieldTable.baseFieldToContext.set(baseFieldChange, context);
-        crossFieldTable.rebasedFields.add(rebasedFieldChange);
-        this.attachRebasedField(rebasedFields, rebasedNodes, crossFieldTable, rebasedFieldChange, fieldId, genId, metadata);
-    }
-    rebaseInvalidatedFields(rebasedFields, rebasedNodes, crossFieldTable, rebaseMetadata, genId) {
-        while (crossFieldTable.affectedBaseFields.size > 0) {
-            const baseFields = crossFieldTable.affectedBaseFields.clone();
-            crossFieldTable.affectedBaseFields.clear();
-            for (const baseFieldIdKey of baseFields.keys()) {
-                const baseFieldId = normalizeFieldId(fieldIdFromFieldIdKey(baseFieldIdKey), crossFieldTable.baseChange.nodeAliases);
-                const baseField = fieldChangeFromId(crossFieldTable.baseChange, baseFieldId);
-                assert(baseField !== undefined, 0x9c2 /* Cross field key registered for empty field */);
-                const context = crossFieldTable.baseFieldToContext.get(baseField);
-                if (context === undefined) {
-                    this.rebaseFieldWithoutNewChanges(baseField, baseFieldId, crossFieldTable, rebasedFields, rebasedNodes, genId, rebaseMetadata);
-                }
-                else {
-                    this.rebaseInvalidatedField(baseField, crossFieldTable, context, rebaseMetadata, genId);
-                }
+    // This processes fields which have no new changes but have been invalidated by another field.
+    rebaseFieldsWithoutNewChanges(rebasedFields, rebasedNodes, crossFieldTable, genId, metadata) {
+        const baseChange = crossFieldTable.baseChange;
+        for (const [revision, localId, fieldKey] of crossFieldTable.affectedBaseFields.keys()) {
+            const baseNodeId = localId === undefined
+                ? undefined
+                : normalizeNodeId({ revision, localId }, baseChange.nodeAliases);
+            const baseFieldChange = fieldMapFromNodeId(baseChange.fieldChanges, baseChange.nodeChanges, baseNodeId).get(fieldKey);
+            assert(baseFieldChange !== undefined, 0x9c2 /* Cross field key registered for empty field */);
+            if (crossFieldTable.baseFieldToContext.has(baseFieldChange)) {
+                // This field has already been processed because there were changes to rebase.
+                continue;
             }
+            // 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 = {
+                ...baseFieldChange,
+                change: brand(handler.createEmpty()),
+            };
+            const rebasedNodeId = baseNodeId === undefined
+                ? undefined
+                : rebasedNodeIdFromBaseNodeId(crossFieldTable, baseNodeId);
+            const fieldId = { nodeId: rebasedNodeId, field: fieldKey };
+            const rebasedField = handler.rebaser.rebase(fieldChange.change, baseFieldChange.change, noNewChangesRebaseChild, genId, new RebaseManager(crossFieldTable, baseFieldChange, fieldId), metadata);
+            const rebasedFieldChange = {
+                ...baseFieldChange,
+                change: brand(rebasedField),
+            };
+            // TODO: Deduplicate
+            crossFieldTable.baseFieldToContext.set(baseFieldChange, {
+                newChange: fieldChange,
+                baseChange: baseFieldChange,
+                rebasedChange: rebasedFieldChange,
+                fieldId,
+                baseNodeIds: [],
+            });
+            crossFieldTable.rebasedFields.add(rebasedFieldChange);
+            this.attachRebasedField(rebasedFields, rebasedNodes, crossFieldTable, rebasedFieldChange, fieldId, genId, metadata);
+        }
+    }
+    rebaseInvalidatedElements(rebasedFields, rebasedNodes, table, metadata, idAllocator) {
+        this.rebaseFieldsWithoutNewChanges(rebasedFields, rebasedNodes, table, idAllocator, metadata);
+        this.rebaseFieldsWithUnattachedChild(table, metadata, idAllocator);
+        this.rebaseInvalidatedFields(table, metadata, idAllocator);
+    }
+    rebaseInvalidatedFields(crossFieldTable, rebaseMetadata, genId) {
+        const fieldsToUpdate = crossFieldTable.invalidatedFields;
+        crossFieldTable.invalidatedFields = new Set();
+        for (const field of fieldsToUpdate) {
+            this.rebaseInvalidatedField(field, crossFieldTable, rebaseMetadata, genId);
+        }
+    }
+    rebaseFieldsWithUnattachedChild(table, metadata, idAllocator) {
+        for (const field of table.fieldsWithUnattachedChild) {
+            table.invalidatedFields.delete(field);
+            this.rebaseInvalidatedField(field, table, metadata, idAllocator, true);
         }
     }
-    rebaseInvalidatedField(baseField, crossFieldTable, context, rebaseMetadata, genId) {
+    rebaseInvalidatedField(baseField, crossFieldTable, rebaseMetadata, genId, allowInval = false) {
+        const context = crossFieldTable.baseFieldToContext.get(baseField);
+        assert(context !== undefined, 0x852 /* Every field should have a context */);
         const { changeHandler, change1: fieldChangeset, change2: baseChangeset, } = this.normalizeFieldChanges(context.newChange, context.baseChange);
         const rebaseChild = (curr, base) => {
             if (curr !== undefined) {
                 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), rebaseMetadata, crossFieldTable.rebaseVersion));
+        context.rebasedChange.change = brand(changeHandler.rebaser.rebase(fieldChangeset, baseChangeset, rebaseChild, genId, new RebaseManager(crossFieldTable, baseField, context.fieldId, allowInval), rebaseMetadata));
     }
     attachRebasedField(rebasedFields, rebasedNodes, table, rebasedField, { nodeId, field: fieldKey }, idAllocator, metadata) {
         if (nodeId === undefined) {
@@ -630,14 +576,12 @@ export class ModularChangeFamily {
         }
         const rebasedNode = getFromChangeAtomIdMap(rebasedNodes, nodeId);
         if (rebasedNode !== undefined) {
-            const updatedRebasedNode = 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;
         }
         const newNode = {
@@ -645,51 +589,39 @@ export class ModularChangeFamily {
         };
         setInChangeAtomIdMap(rebasedNodes, nodeId, newNode);
         setInChangeAtomIdMap(table.baseToRebasedNodeId, nodeId, nodeId);
-        const parentBase = getNodeParent(table.baseChange, nodeId);
-        this.attachRebasedNode(rebasedFields, rebasedNodes, table, nodeId, parentBase, idAllocator, metadata);
-    }
-    attachRebasedNode(rebasedFields, rebasedNodes, table, baseNodeId, parentBase, idAllocator, metadata) {
-        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 = 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 parentFieldId = getParentFieldId(table.baseChange, nodeId);
+        this.attachRebasedNode(rebasedFields, rebasedNodes, table, nodeId, parentFieldId, idAllocator, metadata);
+    }
+    attachRebasedNode(rebasedFields, rebasedNodes, table, baseNodeId, parentFieldIdBase, idAllocator, metadata) {
+        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, rebasedFields, rebasedNodes, idAllocator, metadata, baseNodeId);
+        const handler = getChangeHandler(this.fieldKinds, baseFieldChange.fieldKind);
+        const 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 = { ...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);
     }
     rebaseFieldMap(change, over, parentId, genId, crossFieldTable, revisionMetadata) {
         const rebasedFields = new Map();
@@ -707,8 +639,8 @@ export class ModularChangeFamily {
                 continue;
             }
             const { fieldKind, changeHandler, change1: fieldChangeset, change2: baseChangeset, } = this.normalizeFieldChanges(fieldChange, baseChange);
-            const manager = new RebaseNodeManagerI(crossFieldTable, fieldId);
-            const rebasedField = changeHandler.rebaser.rebase(fieldChangeset, baseChangeset, rebaseChild, genId, manager, revisionMetadata, crossFieldTable.rebaseVersion);
+            const manager = new RebaseManager(crossFieldTable, baseChange, fieldId);
+            const rebasedField = changeHandler.rebaser.rebase(fieldChangeset, baseChangeset, rebaseChild, genId, manager, revisionMetadata);
             const rebasedFieldChange = {
                 fieldKind,
                 change: brand(rebasedField),
@@ -719,15 +651,15 @@ export class ModularChangeFamily {
                 newChange: fieldChange,
                 rebasedChange: rebasedFieldChange,
                 fieldId,
-                baseNodeIds: newChangeAtomIdBTree(),
+                baseNodeIds: [],
             });
             crossFieldTable.rebasedFields.add(rebasedFieldChange);
         }
         return rebasedFields;
     }
     rebaseNodeChange(newId, baseId, genId, crossFieldTable, revisionMetadata) {
-        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 = over?.fieldChanges ?? new Map();
         const fieldChanges = change.fieldChanges !== undefined && over.fieldChanges !== undefined
             ? this.rebaseFieldMap(change?.fieldChanges ?? new Map(), baseMap, newId, genId, crossFieldTable, revisionMetadata)
@@ -745,37 +677,28 @@ export class ModularChangeFamily {
         setInChangeAtomIdMap(crossFieldTable.baseToRebasedNodeId, baseId, newId);
         return rebasedChange;
     }
-    updateConstraints(rebasedFields, rebasedNodes, rebasedRoots, constraintState, revertConstraintState) {
-        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);
-        }
-    }
     updateConstraintsForFields(fields, parentInputAttachState, parentOutputAttachState, constraintState, revertConstraintState, nodes) {
         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, outputAttachState, nodes, constraintState, revertConstraintState);
+                this.updateConstraintsForNode(nodeId, inputAttachState, outputAttachState, nodes, constraintState, revertConstraintState);
             }
         }
     }
     updateConstraintsForNode(nodeId, inputAttachState, outputAttachState, nodes, constraintState, revertConstraintState) {
-        const node = getFromChangeAtomIdMap(nodes, nodeId) ?? fail(0xb24 /* Unknown node ID */);
-        const updatedNode = { ...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,
                 };
@@ -785,7 +708,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,
                 };
@@ -796,73 +719,35 @@ export class ModularChangeFamily {
             this.updateConstraintsForFields(node.fieldChanges, inputAttachState, outputAttachState, constraintState, revertConstraintState, nodes);
         }
     }
-    pruneFieldMap(changeset, parentId, nodeMap, nodeToParent, aliases, roots, fieldsWithRootMoves, fieldsToRootChanges) {
+    pruneFieldMap(changeset, nodeMap) {
         if (changeset === undefined) {
             return undefined;
         }
         const prunedChangeset = new Map();
         for (const [field, fieldChange] of changeset) {
             const handler = getChangeHandler(this.fieldKinds, fieldChange.fieldKind);
-            const prunedFieldChangeset = handler.rebaser.prune(fieldChange.change, (nodeId) => this.pruneNodeChange(nodeId, nodeMap, nodeToParent, aliases, roots, fieldsWithRootMoves, fieldsToRootChanges));
-            const 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) {
+            const prunedFieldChangeset = handler.rebaser.prune(fieldChange.change, (nodeId) => this.pruneNodeChange(nodeId, nodeMap));
+            if (!handler.isEmpty(prunedFieldChangeset)) {
                 prunedChangeset.set(field, { ...fieldChange, change: brand(prunedFieldChangeset) });
             }
         }
         return prunedChangeset.size > 0 ? prunedChangeset : undefined;
     }
-    pruneRoots(roots, nodeMap, nodeToParent, aliases, fieldsWithRootMoves, fieldsToRootChanges) {
-        const pruned = { ...roots, nodeChanges: newChangeAtomIdBTree() };
-        for (const [rootIdKey, nodeId] of roots.nodeChanges.entries()) {
-            const rootId = { 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;
-    }
-    pruneNodeChange(nodeId, nodes, nodeToParent, aliases, roots, fieldsWithRootMoves, fieldsToRootChanges) {
-        const changeset = nodeChangeFromId(nodes, aliases, nodeId);
+    pruneNodeChange(nodeId, nodeMap) {
+        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) {
             delete prunedChange.fieldChanges;
         }
         if (isEmptyNodeChangeset(prunedChange)) {
-            const nodeIdKey = [
-                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;
         }
     }
@@ -879,13 +764,12 @@ export class ModularChangeFamily {
     changeRevision(change, replacer) {
         const updatedFields = this.replaceFieldMapRevisions(change.fieldChanges, replacer);
         const updatedNodes = replaceIdMapRevisions(change.nodeChanges, replacer, (nodeChangeset) => this.replaceNodeChangesetRevisions(nodeChangeset, replacer));
-        const updatedNodeToParent = replaceIdMapRevisions(change.nodeToParent, replacer, (location) => replaceNodeLocationRevision(normalizeNodeLocation(location, change.nodeAliases), replacer));
+        const updatedNodeToParent = replaceIdMapRevisions(change.nodeToParent, replacer, (fieldId) => replaceFieldIdRevision(normalizeFieldId(fieldId, change.nodeAliases), replacer));
         const updated = {
             ...change,
             fieldChanges: updatedFields,
             nodeChanges: updatedNodes,
             nodeToParent: updatedNodeToParent,
-            rootNodes: replaceRootTableRevision(change.rootNodes, replacer, change.nodeAliases),
             // We've updated all references to old node IDs, so we no longer need an alias table.
             nodeAliases: newChangeAtomIdBTree(),
             crossFieldKeys: replaceCrossFieldKeyTableRevisions(change.crossFieldKeys, replacer, change.nodeAliases),
@@ -918,7 +802,7 @@ export class ModularChangeFamily {
         return updatedFields;
     }
     makeCrossFieldKeyTable(fields, nodes) {
-        const keys = newCrossFieldRangeTable();
+        const keys = newCrossFieldKeyTable();
         this.populateCrossFieldKeyTableForFieldMap(keys, fields, undefined);
         nodes.forEachPair(([revision, localId], node) => {
             if (node.fieldChanges !== undefined) {
@@ -938,13 +822,49 @@ export class ModularChangeFamily {
             }
         }
     }
-    buildEditor(mintRevisionTag, changeReceiver, editorOptions) {
-        return new ModularEditBuilder(this, this.fieldKinds, changeReceiver, this.codecOptions, editorOptions);
+    buildEditor(mintRevisionTag, changeReceiver) {
+        return new ModularEditBuilder(this, this.fieldKinds, changeReceiver, this.codecOptions);
     }
     createEmptyFieldChange(fieldKind) {
         const emptyChange = getChangeHandler(this.fieldKinds, fieldKind).createEmpty();
         return { fieldKind, change: brand(emptyChange) };
     }
+    validateChangeset(change) {
+        let numNodes = this.validateFieldChanges(change, change.fieldChanges, undefined);
+        for (const [[revision, localId], node] of change.nodeChanges.entries()) {
+            if (node.fieldChanges === undefined) {
+                continue;
+            }
+            const 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.
+     */
+    validateFieldChanges(change, fieldChanges, nodeParent) {
+        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;
+    }
     getEffectiveChange(change) {
         if (hasConflicts(change)) {
             return this.muteChange(change);
@@ -957,8 +877,7 @@ export class ModularChangeFamily {
     muteChange(change) {
         const muted = {
             ...change,
-            rootNodes: muteRootChanges(change.rootNodes),
-            crossFieldKeys: newCrossFieldRangeTable(),
+            crossFieldKeys: newCrossFieldKeyTable(),
             fieldChanges: this.muteFieldChanges(change.fieldChanges),
             nodeChanges: brand(change.nodeChanges.mapValues((v) => this.muteNodeChange(v))),
         };
@@ -986,7 +905,7 @@ export class ModularChangeFamily {
 }
 ModularChangeFamily.emptyChange = makeModularChangeset();
 function replaceCrossFieldKeyTableRevisions(table, replacer, nodeAliases) {
-    const updated = newCrossFieldRangeTable();
+    const updated = newCrossFieldKeyTable();
     for (const entry of table.entries()) {
         const key = entry.start;
         const updatedKey = replacer.getUpdatedAtomId(key, entry.length);
@@ -1045,19 +964,6 @@ function composeBuildsDestroysAndRefreshers(change1, change2) {
             }
         }
     }
-    // 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 };
 }
 function invertBuilds(builds) {
@@ -1082,44 +988,19 @@ function invertBuilds(builds) {
  * @param fieldKinds - The field kinds to delegate to.
  */
 export function* relevantRemovedRoots(change, fieldKinds) {
-    const rootIds = 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, rootIds) {
-    // 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, nodeChanges, fieldKinds) {
+    const nodeChangeset = nodeChangeFromId(nodeChanges, node);
+    if (nodeChangeset.fieldChanges !== undefined) {
+        yield* relevantRemovedRootsFromFields(nodeChangeset.fieldChanges, nodeChanges, fieldKinds);
     }
 }
-function addRenamesToSet(change, rootIds) {
-    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, nodeChanges, fieldKinds) {
+    const delegate = (node) => relevantRemovedRootsFromNode(node, nodeChanges, fieldKinds);
+    for (const [_, fieldChange] of change) {
+        const handler = getChangeHandler(fieldKinds, fieldChange.fieldKind);
+        yield* handler.relevantRemovedRoots(fieldChange.change, delegate);
     }
 }
 /**
@@ -1165,15 +1046,13 @@ export function updateRefreshers(change, getDetachedNode, removedRoots, requireR
             refreshers.set([root.major, brand(root.minor)], node);
         }
     }
-    const { rebaseVersion, fieldChanges, nodeChanges, nodeToParent, nodeAliases, crossFieldKeys, maxId, revisions, constraintViolationCount, constraintViolationCountOnRevert, builds, destroys, rootNodes, } = change;
+    const { fieldChanges, nodeChanges, nodeToParent, nodeAliases, crossFieldKeys, maxId, revisions, constraintViolationCount, constraintViolationCountOnRevert, builds, destroys, } = change;
     return makeModularChangeset({
-        rebaseVersion,
         fieldChanges,
         nodeChanges,
         nodeToParent,
         nodeAliases,
         crossFieldKeys,
-        rootNodes,
         maxId: maxId,
         revisions,
         constraintViolationCount,
@@ -1192,24 +1071,11 @@ export function updateRefreshers(change, getDetachedNode, removedRoots, requireR
 export function intoDelta(taggedChange, fieldKinds) {
     const change = taggedChange.change;
     const rootDelta = {};
+    const global = [];
+    const rename = [];
     if (!hasConflicts(change)) {
         // If there are no constraint violations, then tree changes apply.
-        const fieldDeltas = intoDeltaImpl(change.fieldChanges, change.nodeChanges, change.nodeAliases, fieldKinds);
-        const global = [];
-        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 = [];
-        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),
-            });
-        }
+        const fieldDeltas = intoDeltaImpl(change.fieldChanges, change.nodeChanges, fieldKinds, global, rename);
         if (fieldDeltas.size > 0) {
             rootDelta.fields = fieldDeltas;
         }
@@ -1255,22 +1121,28 @@ function copyDetachedNodes(detachedNodes) {
 /**
  * @param change - The change to convert into a delta.
  */
-function intoDeltaImpl(change, nodeChanges, nodeAliases, fieldKinds) {
+function intoDeltaImpl(change, nodeChanges, fieldKinds, global, rename) {
     const delta = new Map();
     for (const [field, fieldChange] of change) {
-        const fieldDelta = getChangeHandler(fieldKinds, fieldChange.fieldKind).intoDelta(fieldChange.change, (childChange) => {
-            const nodeChange = nodeChangeFromId(nodeChanges, nodeAliases, childChange);
-            return deltaFromNodeChange(nodeChange, nodeChanges, nodeAliases, fieldKinds);
+        const { local: fieldChanges, global: fieldGlobal, rename: fieldRename, } = getChangeHandler(fieldKinds, fieldChange.fieldKind).intoDelta(fieldChange.change, (childChange) => {
+            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;
 }
-function deltaFromNodeChange(change, nodeChanges, nodeAliases, fieldKinds) {
+function deltaFromNodeChange(change, nodeChanges, fieldKinds, global, rename) {
     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();
@@ -1317,22 +1189,30 @@ export function getFieldKind(fieldKinds, kind) {
 export function getChangeHandler(fieldKinds, kind) {
     return getFieldKind(fieldKinds, kind).changeHandler;
 }
-function newComposeTable(baseChange, newChange, composedRootNodes, movedCrossFieldKeys, removedCrossFieldKeys, pendingCompositions) {
+function newComposeTable(baseChange, newChange, composedNodeToParent) {
     return {
-        rebaseVersion: Math.max(baseChange.rebaseVersion, newChange.rebaseVersion),
-        entries: newDetachedEntryMap(),
+        ...newCrossFieldTable(),
         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(),
+        },
+    };
+}
+function newCrossFieldTable() {
+    return {
+        srcTable: newChangeAtomIdRangeMap(),
+        dstTable: newChangeAtomIdRangeMap(),
+        srcDependents: newChangeAtomIdRangeMap(),
+        dstDependents: newChangeAtomIdRangeMap(),
+        invalidatedFields: new Set(),
     };
 }
 function newConstraintState(violationCount) {
@@ -1340,348 +1220,146 @@ function newConstraintState(violationCount) {
         violationCount,
     };
 }
-class InvertNodeManagerI {
-    constructor(table, fieldId) {
-        this.table = table;
-        this.fieldId = fieldId;
+class CrossFieldManagerI {
+    constructor(crossFieldTable, currentFieldKey, allowInval = true) {
+        this.crossFieldTable = crossFieldTable;
+        this.currentFieldKey = currentFieldKey;
+        this.allowInval = allowInval;
     }
-    invertDetach(detachId, count, nodeChange, newAttachId) {
-        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 (!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);
+    set(target, revision, id, count, newValue, invalidateDependents) {
+        if (invalidateDependents && this.allowInval) {
+            const lastChangedId = id + count - 1;
+            let firstId = id;
+            while (firstId <= lastChangedId) {
+                const dependentEntry = getFirstFromCrossFieldMap(this.getDependents(target), revision, firstId, lastChangedId - firstId + 1);
+                if (dependentEntry.value !== undefined) {
+                    this.crossFieldTable.invalidatedFields.add(dependentEntry.value);
                 }
+                firstId = brand(firstId + dependentEntry.length);
             }
         }
+        setInCrossFieldMap(this.getMap(target), revision, id, count, newValue);
     }
-    invertAttach(attachId, count) {
-        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;
-        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);
-            countToProcess = nodeIdEntry.length;
-            const detachLocationEntry = this.table.change.rootNodes.detachLocations.getFirst(detachIdEntry.value, countToProcess);
-            countToProcess = detachLocationEntry.length;
-            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);
-            }
-            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 } };
-        }
-        if (result.value?.nodeChange !== undefined) {
-            setInChangeAtomIdMap(this.table.invertedNodeToParent, result.value.nodeChange, {
-                field: this.fieldId,
-            });
+    get(target, revision, id, count, addDependency) {
+        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);
         }
-        return result;
+        return getFirstFromCrossFieldMap(this.getMap(target), revision, id, count);
+    }
+    getMap(target) {
+        return target === CrossFieldTarget.Source
+            ? this.crossFieldTable.srcTable
+            : this.crossFieldTable.dstTable;
+    }
+    getDependents(target) {
+        return target === CrossFieldTarget.Source
+            ? this.crossFieldTable.srcDependents
+            : this.crossFieldTable.dstDependents;
     }
 }
-class RebaseNodeManagerI {
-    constructor(table, fieldId, allowInval = true) {
-        this.table = table;
+class InvertManager extends CrossFieldManagerI {
+    constructor(table, field, fieldId, allowInval = true) {
+        super(table, field, allowInval);
         this.fieldId = fieldId;
-        this.allowInval = allowInval;
     }
-    getNewChangesForBaseAttach(baseAttachId, count) {
-        let countToProcess = count;
-        const detachEntry = firstDetachIdFromAttachId(this.table.baseChange.rootNodes, baseAttachId, countToProcess);
-        countToProcess = detachEntry.length;
-        const nodeEntry = rangeQueryChangeAtomIdMap(this.table.newChange.rootNodes.nodeChanges, detachEntry.value, countToProcess);
-        countToProcess = nodeEntry.length;
-        const newNodeId = nodeEntry.value;
-        const newRenameEntry = this.table.newChange.rootNodes.oldToNewId.getFirst(detachEntry.value, countToProcess);
-        countToProcess = newRenameEntry.length;
-        let result;
-        // eslint-disable-next-line unicorn/prefer-ternary
-        if (newNodeId !== undefined || newRenameEntry.value !== undefined) {
-            result = {
-                ...newRenameEntry,
-                value: { detachId: newRenameEntry.value, nodeChange: newNodeId },
-            };
-        }
-        else {
-            // This handles the case where the base changeset has moved these nodes,
-            // meaning they were attached in the input context of the base changeset.
-            result = this.table.entries.getFirst(baseAttachId, countToProcess);
-        }
-        // TODO: Consider moving these two checks into a separate method so that this function has no side effects.
-        if (result.value?.detachId !== undefined) {
-            this.table.rebasedDetachLocations.set(result.value.detachId, result.length, this.fieldId);
-        }
-        if (result.value?.nodeChange !== undefined) {
-            setInChangeAtomIdMap(this.table.rebasedNodeToParent, result.value.nodeChange, {
-                field: this.fieldId,
-            });
-        }
-        return result;
-    }
-    rebaseOverDetach(baseDetachId, count, newDetachId, nodeChange, cellRename) {
-        let countToProcess = count;
-        const attachIdEntry = firstAttachIdFromDetachId(this.table.baseRoots, baseDetachId, countToProcess);
-        const baseAttachId = attachIdEntry.value;
-        countToProcess = attachIdEntry.length;
-        const attachFieldEntry = getFirstFieldForCrossFieldKey(this.table.baseChange, { ...baseAttachId, target: 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);
-        }
-    }
-    addDetach(id, count) {
-        this.table.rebasedDetachLocations.set(id, count, this.fieldId);
-    }
-    removeDetach(id, count) {
-        this.table.movedDetaches.set(id, count, true);
-    }
-    doesBaseAttachNodes(id, count) {
-        let countToProcess = count;
-        const attachEntry = getFirstAttachField(this.table.baseChange.crossFieldKeys, id, countToProcess);
-        countToProcess = attachEntry.length;
-        return { start: id, value: attachEntry.value !== undefined, length: countToProcess };
-    }
-    getBaseRename(id, count) {
-        return this.table.baseChange.rootNodes.oldToNewId.getFirst(id, count);
-    }
-    getNewRenameForBaseRename(baseRenameTo, count) {
-        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);
-    }
-    invalidateBaseFields(fields) {
-        if (this.allowInval) {
-            for (const fieldId of fields) {
-                this.table.affectedBaseFields.set(fieldIdKeyFromFieldId(fieldId), true);
-            }
-        }
+    onMoveIn(id) {
+        setInChangeAtomIdMap(this.table.invertedNodeToParent, id, this.fieldId);
+    }
+    moveKey(target, revision, id, count) {
+        assert(false, 0x9c5 /* Keys should not be moved manually during invert */);
+    }
+    get table() {
+        return this.crossFieldTable;
     }
 }
-function assignRootChange(table, nodeToParent, detachId, nodeId, detachLocation, rebaseVersion) {
-    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 {
-    constructor(table, fieldId, allowInval = true) {
-        this.table = table;
+class RebaseManager extends CrossFieldManagerI {
+    constructor(table, currentField, fieldId, allowInval = true) {
+        super(table, currentField, allowInval);
         this.fieldId = fieldId;
-        this.allowInval = allowInval;
     }
-    getNewChangesForBaseDetach(baseDetachId, count) {
-        let countToProcess = count;
-        const baseAttachEntry = getFirstFieldForCrossFieldKey(this.table.baseChange, { target: NodeMoveType.Attach, ...baseDetachId }, countToProcess);
-        countToProcess = baseAttachEntry.length;
-        let result;
-        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;
-    }
-    composeAttachDetach(baseAttachId, newDetachId, count) {
-        let countToProcess = count;
-        const newAttachEntry = getFirstAttachField(this.table.newChange.crossFieldKeys, newDetachId, countToProcess);
-        countToProcess = newAttachEntry.length;
-        // Both changes can have the same ID if they came from inverse changesets.
-        // If the new detach is part of a move,
-        // then both input changesets contain the attach cross-field key for this ID.
-        // The new attach may still exist in the composed changeset so we do not remove it here.
-        // The new attach will typically cancel with a base detach,
-        // in which case the cross-field key will be removed in `composeDetachAttach`.
-        const hasNewAttachWithBaseAttachId = areEqualChangeAtomIds(baseAttachId, newDetachId) && newAttachEntry.value !== undefined;
-        if (!hasNewAttachWithBaseAttachId) {
-            this.table.removedCrossFieldKeys.set({ ...baseAttachId, target: 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);
-        }
-        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);
-            }
-            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);
-            countToProcess = newOutputDetachLocationEntry.length;
-            this.table.composedRootNodes.outputDetachLocations.set(newDetachId, countToProcess, newOutputDetachLocationEntry.value ?? this.fieldId);
-        }
-        if (countToProcess < count) {
-            const remainingCount = count - countToProcess;
-            this.composeAttachDetach(offsetChangeAtomId(baseAttachId, countToProcess), offsetChangeAtomId(newDetachId, countToProcess), remainingCount);
-        }
-    }
-    sendNewChangesToBaseSourceLocation(baseAttachId, newChanges) {
-        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);
+    set(target, revision, id, count, newValue, invalidateDependents) {
+        if (invalidateDependents && this.allowInval) {
+            const newFieldIds = getFieldsForCrossFieldKey(this.table.newChange, {
+                target,
+                revision,
+                localId: id,
+            }, count);
+            assert(newFieldIds.length === 0, 0x9c6 /* TODO: Modifying a cross-field key from the new changeset is currently unsupported */);
+            const baseFieldIds = getFieldsForCrossFieldKey(this.table.baseChange, {
+                target,
+                revision,
+                localId: id,
+            }, count);
+            assert(baseFieldIds.length > 0, 0x9c7 /* Cross field key not registered in base or new change */);
+            for (const baseFieldId of baseFieldIds) {
+                this.table.affectedBaseFields.set([baseFieldId.nodeId?.revision, baseFieldId.nodeId?.localId, baseFieldId.field], true);
             }
         }
-        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);
+        super.set(target, revision, id, count, newValue, invalidateDependents);
+    }
+    onMoveIn(id) {
+        setInChangeAtomIdMap(this.table.rebasedNodeToParent, id, this.fieldId);
+    }
+    moveKey(target, revision, id, count) {
+        this.table.rebasedCrossFieldKeys.set({ target, revision, localId: id }, count, this.fieldId);
+    }
+    get table() {
+        return this.crossFieldTable;
+    }
+}
+// TODO: Deduplicate this with RebaseTable
+class ComposeManager extends CrossFieldManagerI {
+    constructor(table, currentField, fieldId, allowInval = true) {
+        super(table, currentField, allowInval);
+        this.fieldId = fieldId;
+    }
+    set(target, revision, id, count, newValue, invalidateDependents) {
+        if (invalidateDependents && this.allowInval) {
+            const newFieldIds = getFieldsForCrossFieldKey(this.table.newChange, {
+                target,
+                revision,
+                localId: id,
+            }, count);
+            if (newFieldIds.length > 0) {
+                for (const newFieldId of newFieldIds) {
+                    this.table.pendingCompositions.affectedNewFields.set([newFieldId.nodeId?.revision, newFieldId.nodeId?.localId, newFieldId.field], true);
+                }
             }
             else {
-                addNodesToCompose(this.table, baseNodeId, newChanges);
+                const baseFieldIds = getFieldsForCrossFieldKey(this.table.baseChange, {
+                    target,
+                    revision,
+                    localId: id,
+                }, count);
+                assert(baseFieldIds.length > 0, 0x9c8 /* Cross field key not registered in base or new change */);
+                for (const baseFieldId of baseFieldIds) {
+                    this.table.pendingCompositions.affectedBaseFields.set([baseFieldId.nodeId?.revision, baseFieldId.nodeId?.localId, baseFieldId.field], true);
+                }
             }
         }
+        super.set(target, revision, id, count, newValue, invalidateDependents);
     }
-    composeDetachAttach(baseDetachId, newAttachId, count, composeToPin) {
-        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);
-        }
+    onMoveIn(id) {
+        setInChangeAtomIdMap(this.table.composedNodeToParent, id, this.fieldId);
     }
-    invalidateBaseFields(fields) {
-        if (this.allowInval) {
-            for (const fieldId of fields) {
-                this.table.pendingCompositions.affectedBaseFields.set(fieldIdKeyFromFieldId(fieldId), true);
-            }
-        }
+    moveKey(target, revision, id, count) {
+        throw new Error("Moving cross-field keys during compose is currently unsupported");
+    }
+    get table() {
+        return this.crossFieldTable;
     }
 }
 function makeModularChangeset(props) {
-    const p = props ?? { maxId: -1, rebaseVersion: 1 };
+    const p = props ?? { maxId: -1 };
     const changeset = {
-        rebaseVersion: p.rebaseVersion,
         fieldChanges: p.fieldChanges ?? new Map(),
         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) {
         changeset.revisions = p.revisions;
@@ -1714,19 +1392,12 @@ function makeModularChangeset(props) {
     return changeset;
 }
 export class ModularEditBuilder extends EditBuilder {
-    constructor(family, fieldKinds, changeReceiver, codecOptions, editorOptions) {
+    constructor(family, fieldKinds, changeReceiver, codecOptions) {
         super(family, changeReceiver);
         this.fieldKinds = fieldKinds;
         this.transactionDepth = 0;
         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);
-    }
-    isInTransaction() {
-        return this.transactionDepth > 0;
     }
     enterTransaction() {
         this.transactionDepth += 1;
@@ -1774,13 +1445,11 @@ export class ModularEditBuilder extends EditBuilder {
     submitChange(field, fieldKind, change, revision) {
         const localCrossFieldKeys = getChangeHandler(this.fieldKinds, fieldKind).getCrossFieldKeys(change);
         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,
@@ -1797,14 +1466,11 @@ export class ModularEditBuilder extends EditBuilder {
             revisions.add(change.revision);
             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,
@@ -1812,8 +1478,7 @@ export class ModularEditBuilder extends EditBuilder {
                     },
                     nodeChanges: newChangeAtomIdBTree(),
                     nodeToParent: newChangeAtomIdBTree(),
-                    crossFieldKeys: newCrossFieldRangeTable(),
-                    rootNodes: newRootTable(),
+                    crossFieldKeys: newCrossFieldKeyTable(),
                     idAllocator: this.idAllocator,
                     localCrossFieldKeys: getChangeHandler(this.fieldKinds, change.fieldKind).getCrossFieldKeys(change.change),
                     revision: change.revision,
@@ -1838,13 +1503,11 @@ export class ModularEditBuilder extends EditBuilder {
             nodeExistsConstraint: { violated: false },
         };
         this.applyChange(tagChange(buildModularChangesetFromNode({
-            rebaseVersion: this.rebaseVersion,
             path,
             nodeChange,
             nodeChanges: newChangeAtomIdBTree(),
             nodeToParent: newChangeAtomIdBTree(),
-            crossFieldKeys: newCrossFieldRangeTable(),
-            rootNodes: newRootTable(),
+            crossFieldKeys: newCrossFieldKeyTable(),
             idAllocator: this.idAllocator,
             revision,
         }), revision));
@@ -1854,13 +1517,11 @@ export class ModularEditBuilder extends EditBuilder {
             nodeExistsConstraintOnRevert: { violated: false },
         };
         this.applyChange(tagChange(buildModularChangesetFromNode({
-            rebaseVersion: this.rebaseVersion,
             path,
             nodeChange,
             nodeChanges: newChangeAtomIdBTree(),
             nodeToParent: newChangeAtomIdBTree(),
-            crossFieldKeys: newCrossFieldRangeTable(),
-            rootNodes: newRootTable(),
+            crossFieldKeys: newCrossFieldKeyTable(),
             idAllocator: this.idAllocator,
             revision,
         }), revision));
@@ -1870,7 +1531,6 @@ export class ModularEditBuilder extends EditBuilder {
             throw new UsageError(`No change constraints require min client version of at least ${FluidClientVersion.v2_80}`);
         }
         const changeset = makeModularChangeset({
-            rebaseVersion: this.rebaseVersion,
             maxId: -1,
             noChangeConstraint: { violated: false },
         });
@@ -1881,36 +1541,30 @@ export class ModularEditBuilder extends EditBuilder {
             throw new UsageError(`No change constraints require min client version of at least ${FluidClientVersion.v2_80}`);
         }
         const changeset = makeModularChangeset({
-            rebaseVersion: this.rebaseVersion,
             maxId: -1,
             noChangeConstraintOnRevert: { violated: false },
         });
         this.applyChange(tagChange(changeset, revision));
     }
 }
-export function buildModularChangesetFromField(props) {
-    const { rebaseVersion, path, fieldChange, nodeChanges, nodeToParent, crossFieldKeys, rootNodes, idAllocator = idAllocatorFromMaxId(), localCrossFieldKeys = [], childId, revision, } = props;
+function buildModularChangesetFromField(props) {
+    const { path, fieldChange, nodeChanges, nodeToParent, crossFieldKeys, idAllocator = idAllocatorFromMaxId(), localCrossFieldKeys = [], childId, revision, } = props;
     const fieldChanges = 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 }],
         });
@@ -1919,23 +1573,21 @@ export function buildModularChangesetFromField(props) {
         fieldChanges,
     };
     const parentId = { 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 });
     }
     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,
@@ -1944,41 +1596,20 @@ export function buildModularChangesetFromField(props) {
 function buildModularChangesetFromNode(props) {
     const { path, idAllocator, revision, nodeChanges, nodeChange, nodeId = { localId: brand(idAllocator.allocate()), revision }, } = props;
     setInChangeAtomIdMap(nodeChanges, nodeId, nodeChange);
-    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 = {
-            fieldKind: genericFieldKind.identifier,
-            change: fieldChangeset,
-        };
-        return buildModularChangesetFromField({
-            ...props,
-            path: { parent: path.parent, field: path.parentField },
-            fieldChange,
-            localCrossFieldKeys: [],
-            childId: nodeId,
-        });
-    }
-}
-function renameTableFromRenameDescriptions(renames) {
-    const table = newRootTable();
-    for (const rename of renames) {
-        addNodeRename(table, rename.oldId, rename.newId, rename.count, rename.detachLocation);
-    }
-    return table;
+    const fieldChangeset = genericFieldKind.changeHandler.editor.buildChildChanges([
+        [path.parentIndex, nodeId],
+    ]);
+    const fieldChange = {
+        fieldKind: genericFieldKind.identifier,
+        change: fieldChangeset,
+    };
+    return buildModularChangesetFromField({
+        ...props,
+        path: { parent: path.parent, field: path.parentField },
+        fieldChange,
+        localCrossFieldKeys: [],
+        childId: nodeId,
+    });
 }
 function getRevInfoFromTaggedChanges(changes) {
     let maxId = -1;
@@ -1995,6 +1626,18 @@ function getRevInfoFromTaggedChanges(changes) {
             }
         }
     }
+    const rolledBackRevisions = [];
+    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 };
 }
 function revisionInfoFromTaggedChange(taggedChange) {
@@ -2011,16 +1654,15 @@ function revisionInfoFromTaggedChange(taggedChange) {
     }
     return revInfos;
 }
-function fieldChangeFromId(change, id) {
-    const fieldId = normalizeFieldId(id, change.nodeAliases);
-    const fieldMap = fieldMapFromNodeId(change.fieldChanges, change.nodeChanges, change.nodeAliases, fieldId.nodeId);
+function fieldChangeFromId(fields, nodes, id) {
+    const fieldMap = fieldMapFromNodeId(fields, nodes, id.nodeId);
     return fieldMap.get(id.field) ?? fail(0xb25 /* No field exists for the given ID */);
 }
-function fieldMapFromNodeId(rootFieldMap, nodes, aliases, nodeId) {
+function fieldMapFromNodeId(rootFieldMap, nodes, nodeId) {
     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;
 }
@@ -2033,9 +1675,8 @@ function rebasedFieldIdFromBaseId(table, baseId) {
 function rebasedNodeIdFromBaseNodeId(table, baseId) {
     return getFromChangeAtomIdMap(table.baseToRebasedNodeId, baseId) ?? baseId;
 }
-function nodeChangeFromId(nodes, aliases, id) {
-    const normalizedId = normalizeNodeId(id, aliases);
-    const node = getFromChangeAtomIdMap(nodes, normalizedId);
+function nodeChangeFromId(nodes, id) {
+    const node = getFromChangeAtomIdMap(nodes, id);
     assert(node !== undefined, 0x9ca /* Unknown node ID */);
     return node;
 }
@@ -2043,20 +1684,12 @@ function fieldIdFromFieldIdKey([revision, localId, field]) {
     const nodeId = localId === undefined ? undefined : { revision, localId };
     return { nodeId, field };
 }
-function fieldIdKeyFromFieldId(fieldId) {
-    return [fieldId.nodeId?.revision, fieldId.nodeId?.localId, fieldId.field];
-}
 function cloneNodeChangeset(nodeChangeset) {
     if (nodeChangeset.fieldChanges !== undefined) {
         return { ...nodeChangeset, fieldChanges: new Map(nodeChangeset.fieldChanges) };
     }
     return { ...nodeChangeset };
 }
-function replaceNodeLocationRevision(location, replacer) {
-    return location.field === undefined
-        ? { root: replacer.getUpdatedAtomId(location.root) }
-        : { field: replaceFieldIdRevision(location.field, replacer) };
-}
 function replaceFieldIdRevision(fieldId, replacer) {
     if (fieldId.nodeId === undefined) {
         return fieldId;
@@ -2066,33 +1699,16 @@ function replaceFieldIdRevision(fieldId, replacer) {
         nodeId: replacer.getUpdatedAtomId(fieldId.nodeId),
     };
 }
-export function getNodeParent(changeset, nodeId) {
-    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, nodeId) {
+    const parentId = getFromChangeAtomIdMap(changeset.nodeToParent, nodeId);
+    assert(parentId !== undefined, 0x9cb /* Parent field should be defined */);
+    return normalizeFieldId(parentId, changeset.nodeAliases);
 }
 function getFieldsForCrossFieldKey(changeset, key, count) {
     return changeset.crossFieldKeys
         .getAll(key, count)
         .map(({ value: fieldId }) => normalizeFieldId(fieldId, changeset.nodeAliases));
 }
-function getFirstFieldForCrossFieldKey(changeset, key, count) {
-    const result = changeset.crossFieldKeys.getFirst(key, count);
-    if (result.value === undefined) {
-        return result;
-    }
-    return { ...result, value: normalizeFieldId(result.value, changeset.nodeAliases) };
-}
-function normalizeNodeLocation(location, nodeAliases) {
-    if (location.field !== undefined) {
-        return { field: normalizeFieldId(location.field, nodeAliases) };
-    }
-    return location;
-}
 // This is only exported for use in test utilities.
 export function normalizeFieldId(fieldId, nodeAliases) {
     return fieldId.nodeId === undefined
@@ -2102,9 +1718,8 @@ export function normalizeFieldId(fieldId, nodeAliases) {
 /**
  * @returns The canonical form of nodeId, according to nodeAliases
  */
-export function normalizeNodeId(nodeId, nodeAliases) {
+function normalizeNodeId(nodeId, nodeAliases) {
     let currentId = nodeId;
-    let cycleProbeId = nodeId;
     // eslint-disable-next-line no-constant-condition
     while (true) {
         const dealiased = getFromChangeAtomIdMap(nodeAliases, currentId);
@@ -2112,557 +1727,23 @@ export function normalizeNodeId(nodeId, nodeAliases) {
             return currentId;
         }
         currentId = dealiased;
-        if (cycleProbeId !== undefined) {
-            cycleProbeId = getFromChangeAtomIdMap(nodeAliases, cycleProbeId);
-        }
-        if (cycleProbeId !== undefined) {
-            cycleProbeId = getFromChangeAtomIdMap(nodeAliases, cycleProbeId);
-        }
-        assert(!areEqualChangeAtomIdOpts(cycleProbeId, currentId), "Alias cycle detected");
     }
 }
 function hasConflicts(change) {
     return (change.constraintViolationCount ?? 0) > 0;
 }
-function areEqualFieldIds(a, b) {
-    return areEqualChangeAtomIdOpts(a.nodeId, b.nodeId) && a.field === b.field;
-}
-function firstAttachIdFromDetachId(roots, detachId, count) {
-    const result = roots.oldToNewId.getFirst(detachId, count);
-    return { ...result, value: result.value ?? detachId };
-}
-function firstDetachIdFromAttachId(roots, attachId, count) {
-    const result = roots.newToOldId.getFirst(attachId, count);
-    return { ...result, start: attachId, value: result.value ?? attachId };
-}
-function rebaseCrossFieldKeys(sourceTable, movedDetaches, newDetachLocations) {
-    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() {
-    return {
-        newToOldId: newChangeAtomIdTransform(),
-        oldToNewId: newChangeAtomIdTransform(),
-        nodeChanges: newChangeAtomIdBTree(),
-        detachLocations: newChangeAtomIdRangeMap(),
-        outputDetachLocations: newChangeAtomIdRangeMap(),
-    };
-}
-function rebaseRoots(change, base, affectedBaseFields, nodesToRebase, rebasedNodeToParent, rebaseVersion) {
-    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, rebasedRoots, renameEntry, base, affectedBaseFields) {
-    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.
+ * A rebaseChild callback for fields with no new changes.
+ * Asserts that there are no new changes and returns undefined.
  */
-function fixupRebasedDetachLocations(table) {
-    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, id1, id2) {
-    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, revisions2) {
-    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 = [...(revisions1 ?? []), ...(revisions2 ?? [])];
-    return result;
-}
-function composeCrossFieldKeyTables(table1, table2, movedCrossFieldKeys, removedCrossFieldKeys) {
-    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, change2, composedNodeToParent, movedCrossFieldKeys, removedCrossFieldKeys, pendingCompositions) {
-    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));
-            }
-            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, count, detachLocation, change2, composedTable) {
-    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, change2, mergedTable, oldId, newId, count, movedCrossFieldKeys, removedCrossFieldKeys, pendingCompositions) {
-    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) {
-    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, invertedNodeToParent, isRollback) {
-    const invertedRoots = 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 = { 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, invertedRoots, oldId, newId, length) {
-    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, id, count) {
-    return table
-        .getAll2({ ...id, target: NodeMoveType.Attach }, count)
-        .map((entry) => ({ ...entry, value: entry.value !== undefined }));
-}
-function doesChangeDetachNodes(table, id, count) {
-    return table
-        .getAll2({ ...id, target: NodeMoveType.Detach }, count)
-        .map((entry) => ({ ...entry, value: entry.value !== undefined }));
-}
-export function getFirstDetachField(table, id, count) {
-    return table.getFirst({ target: NodeMoveType.Detach, ...id }, count);
-}
-export function getFirstAttachField(table, id, count) {
-    return table.getFirst({ target: NodeMoveType.Attach, ...id }, count);
-}
-export function addNodeRename(table, oldId, newId, count, detachLocation) {
-    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, id, count) {
-    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, id, count) {
-    for (const entry of roots.newToOldId.getAll(id, count)) {
-        deleteNodeRenameEntry(roots, entry.value, entry.start, entry.length);
-    }
-}
-function appendNodeRename(composedTable, oldId, newId, count, change1Table, detachLocation) {
-    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, rootId, count) {
-    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, oldId, newId, count) {
-    roots.oldToNewId.delete(oldId, count);
-    roots.newToOldId.delete(newId, count);
-}
-function replaceRootTableRevision(table, replacer, nodeAliases) {
-    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 = 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() {
-    return new RangeMap(offsetChangeAtomId, subtractChangeAtomIds, offsetDetachedNodeEntry);
-}
-function offsetDetachedNodeEntry(entry, count) {
-    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, nodeAliases) {
-    const fields = 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, nodeAliases) {
-    const fields = newFieldIdKeyBTree();
-    for (const rootIdKey of roots.nodeChanges.keys()) {
-        const rootId = { 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) {
-    return {
-        oldToNewId: newChangeAtomIdTransform(),
-        newToOldId: newChangeAtomIdTransform(),
-        nodeChanges: brand(roots.nodeChanges.clone()),
-        detachLocations: roots.detachLocations.clone(),
-        outputDetachLocations: newChangeAtomIdRangeMap(),
-    };
-}
-export function validateChangeset(change, fieldKinds) {
-    const unreachableNodes = 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 = { 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) {
-    if (change.revisions === undefined) {
-        return false;
-    }
-    for (const revInfo of change.revisions) {
-        if (revInfo.rollbackOf !== undefined) {
-            return true;
-        }
-    }
-    return false;
-}
-function validateAttach(changeset, attachId, count) {
-    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, id, count) {
-    if (builds === undefined) {
-        return { value: false, length: count };
-    }
-    const prevBuildEntry = builds.nextLowerPair([id.revision, id.localId]);
-    if (prevBuildEntry !== undefined) {
-        const prevBuildKey = {
-            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 };
+function noNewChangesRebaseChild(child, _baseChild, _stateChange) {
+    assert(child === undefined, 0x9c3 /* There should be no new changes in this field */);
+    return undefined;
 }
-/**
- * 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, change, fieldChanges, nodeParent, unreachableNodes, unreachableCFKs) {
-    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);
-        }
-    }
+function areEqualFieldIds(a, b) {
+    return areEqualChangeAtomIdOpts(a.nodeId, b.nodeId) && a.field === b.field;
 }
-export function newFieldIdKeyBTree() {
+function newFieldIdKeyBTree() {
     return newTupleBTree(compareFieldIdKeys);
 }
 const compareFieldIdKeys = createTupleComparator([