@fluidframework/tree 2.73.0 → 2.74.0-368706

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

@@ -4,12 +4,12 @@
  */
 import { assert, fail } from "@fluidframework/core-utils/internal";
 import { BTree } from "@tylerbu/sorted-btree-es6";
-import { EditBuilder, makeDetachedNodeId, replaceAtomRevisions, revisionMetadataSourceFromInfo, areEqualChangeAtomIds, areEqualChangeAtomIdOpts, tagChange, makeAnonChange, newChangeAtomIdRangeMap, mapTaggedChange, } from "../../core/index.js";
+import { EditBuilder, makeDetachedNodeId, replaceAtomRevisions, revisionMetadataSourceFromInfo, areEqualChangeAtomIds, areEqualChangeAtomIdOpts, tagChange, makeAnonChange, mapTaggedChange, newChangeAtomIdRangeMap, newChangeAtomIdTransform, offsetChangeAtomId, isDetachedUpPathRoot, subtractChangeAtomIds, makeChangeAtomId, } from "../../core/index.js";
 import { brand, idAllocatorFromMaxId, idAllocatorFromState, getOrCreate, newTupleBTree, mergeTupleBTrees, RangeMap, balancedReduce, } from "../../util/index.js";
-import { CrossFieldTarget, getFirstFromCrossFieldMap, setInCrossFieldMap, } from "./crossFieldQueries.js";
+import { CrossFieldTarget, setInCrossFieldMap, } from "./crossFieldQueries.js";
 import { NodeAttachState, } from "./fieldChangeHandler.js";
 import { convertGenericChange, genericFieldKind } from "./genericFieldKind.js";
-import { newCrossFieldKeyTable, } from "./modularChangeTypes.js";
+import { getFromChangeAtomIdMap, newCrossFieldRangeTable, rangeQueryChangeAtomIdMap, setInChangeAtomIdMap, } from "./modularChangeTypes.js";
 /**
  * Implementation of ChangeFamily which delegates work in a given field to the appropriate FieldKind
  * as determined by the schema.
@@ -64,18 +64,19 @@ export class ModularChangeFamily {
         return convertedChange;
     }
     compose(changes) {
-        const { revInfos, maxId } = getRevInfoFromTaggedChanges(changes);
+        const { maxId } = getRevInfoFromTaggedChanges(changes);
         const idState = { maxId };
         const pairwiseDelegate = (left, right) => {
-            return this.composePair(left, right, revInfos, idState);
+            return this.composePair(left, right, idState);
         };
         const innerChanges = changes.map((change) => change.change);
         return balancedReduce(innerChanges, pairwiseDelegate, makeModularChangeset);
     }
-    composePair(change1, change2, revInfos, idState) {
-        const { fieldChanges, nodeChanges, nodeToParent, nodeAliases, crossFieldKeys } = this.composeAllFields(change1, change2, revInfos, idState);
+    composePair(change1, change2, idState) {
+        const revInfos = composeRevInfos(change1.revisions, change2.revisions);
+        const { fieldChanges, nodeChanges, nodeToParent, nodeAliases, crossFieldKeys, rootNodes } = this.composeAllFields(change1, change2, revInfos, idState);
         const { allBuilds, allDestroys, allRefreshers } = composeBuildsDestroysAndRefreshers(change1, change2);
-        return makeModularChangeset({
+        const composed = makeModularChangeset({
             fieldChanges,
             nodeChanges,
             nodeToParent,
@@ -83,10 +84,14 @@ export class ModularChangeFamily {
             crossFieldKeys,
             maxId: idState.maxId,
             revisions: revInfos,
+            rootNodes,
             builds: allBuilds,
             destroys: allDestroys,
             refreshers: allRefreshers,
         });
+        // XXX: This is an expensive assert which should be disabled before merging.
+        this.validateChangeset(composed);
+        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.
@@ -107,34 +112,50 @@ 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 crossFieldTable = newComposeTable(change1, change2, composedNodeToParent);
+        const pendingCompositions = {
+            nodeIdsToCompose: [],
+            affectedBaseFields: newTupleBTree(),
+        };
+        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 composedFields = this.composeFieldMaps(change1.fieldChanges, change2.fieldChanges, undefined, genId, crossFieldTable, revisionMetadata);
         this.composeInvalidatedElements(crossFieldTable, composedFields, composedNodeChanges, composedNodeToParent, composedNodeAliases, genId, revisionMetadata);
-        // Currently no field kinds require making changes to cross-field keys during composition, so we can just merge the two tables.
-        const composedCrossFieldKeys = RangeMap.union(change1.crossFieldKeys, change2.crossFieldKeys);
+        for (const entry of crossFieldTable.renamesToDelete.entries()) {
+            deleteNodeRenameFrom(crossFieldTable.composedRootNodes, entry.start, entry.length);
+        }
+        for (const [nodeId, location] of crossFieldTable.movedNodeToParent.entries()) {
+            // Moved nodes are from change2.
+            // If there is a corresponding node in change1, then composedNodeToParent will already have the correct entry,
+            // because the location of the node is the same in change1 and the composed change
+            // (since they have the same input context).
+            if (crossFieldTable.newToBaseNodeId.get(nodeId) === undefined) {
+                composedNodeToParent.set(nodeId, location);
+            }
+        }
         return {
             fieldChanges: composedFields,
             nodeChanges: composedNodeChanges,
             nodeToParent: composedNodeToParent,
             nodeAliases: composedNodeAliases,
-            crossFieldKeys: composedCrossFieldKeys,
+            crossFieldKeys: composeCrossFieldKeyTables(change1.crossFieldKeys, change2.crossFieldKeys, crossFieldTable.movedCrossFieldKeys, crossFieldTable.removedCrossFieldKeys),
+            rootNodes: composedRoots,
         };
     }
     composeInvalidatedField(fieldChange, crossFieldTable, genId, revisionMetadata) {
         const context = crossFieldTable.fieldToContext.get(fieldChange);
         assert(context !== undefined, 0x8cc /* Should have context for every invalidated field */);
-        const { fieldId, change1: fieldChange1, change2: fieldChange2, composedChange } = context;
+        const { change1: fieldChange1, change2: fieldChange2, composedChange } = context;
+        crossFieldTable.pendingCompositions.affectedBaseFields.delete(fieldIdKeyFromFieldId(context.fieldId));
         const rebaser = getChangeHandler(this.fieldKinds, composedChange.fieldKind).rebaser;
         const composeNodes = (child1, child2) => {
-            if (child1 !== undefined &&
-                child2 !== undefined &&
-                getFromChangeAtomIdMap(crossFieldTable.newToBaseNodeId, child2) === undefined) {
-                setInChangeAtomIdMap(crossFieldTable.newToBaseNodeId, child2, child1);
-                crossFieldTable.pendingCompositions.nodeIdsToCompose.push([child1, child2]);
+            if (child1 !== undefined && child2 !== undefined) {
+                addNodesToCompose(crossFieldTable, child1, child2);
             }
             return child1 ?? child2 ?? fail(0xb22 /* Should not compose two undefined nodes */);
         };
-        const amendedChange = rebaser.compose(fieldChange1, fieldChange2, composeNodes, genId, new ComposeManager(crossFieldTable, fieldChange, fieldId, false), revisionMetadata);
+        const amendedChange = rebaser.compose(fieldChange1, fieldChange2, composeNodes, genId, new ComposeNodeManagerI(crossFieldTable, context.fieldId, false), revisionMetadata);
         composedChange.change = brand(amendedChange);
     }
     /**
@@ -143,32 +164,23 @@ export class ModularChangeFamily {
      * - discovering that two node changesets refer to the same node (`nodeIdsToCompose`)
      * - a previously composed field being invalidated by a cross field effect (`invalidatedFields`)
      * - a field which was copied directly from an input changeset being invalidated by a cross field effect
-     * (`affectedBaseFields` and `affectedNewFields`)
+     * (`affectedBaseFields`)
      *
      * Updating an element may invalidate further elements. This function runs until there is no more invalidation.
      */
     composeInvalidatedElements(table, composedFields, composedNodes, composedNodeToParent, nodeAliases, genId, metadata) {
         const pending = table.pendingCompositions;
-        while (table.invalidatedFields.size > 0 ||
-            pending.nodeIdsToCompose.length > 0 ||
-            pending.affectedBaseFields.length > 0 ||
-            pending.affectedNewFields.length > 0) {
-            // Note that the call to `composeNodesById` can add entries to `crossFieldTable.nodeIdPairs`.
-            for (const [id1, id2] of pending.nodeIdsToCompose) {
-                this.composeNodesById(table.baseChange.nodeChanges, table.newChange.nodeChanges, composedNodes, composedNodeToParent, nodeAliases, id1, id2, genId, table, metadata);
-            }
-            pending.nodeIdsToCompose.length = 0;
-            this.composeAffectedFields(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);
+        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);
         }
     }
-    processInvalidatedCompositions(table, genId, metadata) {
-        const fieldsToUpdate = table.invalidatedFields;
-        table.invalidatedFields = new Set();
-        for (const fieldChange of fieldsToUpdate) {
-            this.composeInvalidatedField(fieldChange, 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);
         }
+        table.pendingCompositions.nodeIdsToCompose.length = 0;
     }
     /**
      * Ensures that each field in `affectedFields` has been updated in the composition output.
@@ -181,38 +193,36 @@ 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, 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);
+    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);
             if (table.fieldToContext.has(fieldChange) ||
                 table.newFieldToBaseField.has(fieldChange)) {
-                // This function handles fields which were not part of the intersection of the two changesets but which need to be updated anyway.
-                // If we've already processed this field then either it is up to date
-                // or there is pending inval which will be handled in processInvalidatedCompositions.
-                continue;
+                this.composeInvalidatedField(fieldChange, table, genId, metadata);
             }
-            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);
-            }
-            if (nodeChangeset.fieldChanges === undefined) {
-                nodeChangeset.fieldChanges = new Map();
+            else {
+                this.composeFieldWithNoNewChange(table, fieldChange, fieldId, composedFields, composedNodes, genId, metadata);
             }
-            nodeChangeset.fieldChanges.set(fieldId.field, composedField);
         }
-        affectedFields.clear();
+    }
+    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);
+        if (nodeChangeset.fieldChanges === undefined) {
+            nodeChangeset.fieldChanges = new Map();
+        }
+        nodeChangeset.fieldChanges.set(fieldId.field, composedField);
     }
     composeFieldMaps(change1, change2, parentId, genId, crossFieldTable, revisionMetadata) {
         const composedFields = new Map();
@@ -222,6 +232,14 @@ 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
                 ? this.composeFieldChanges(fieldId, fieldChange1, fieldChange2, genId, crossFieldTable, revisionMetadata)
                 : fieldChange1;
@@ -241,17 +259,16 @@ export class ModularChangeFamily {
      * will be added to `crossFieldTable.pendingCompositions.nodeIdsToCompose`.
      *
      * Any fields which had cross-field information sent to them as part of this field composition
-     * will be added to either `affectedBaseFields` or `affectedNewFields` in `crossFieldTable.pendingCompositions`.
+     * will be added to `affectedBaseFields` in `crossFieldTable.pendingCompositions`.
      *
      * Any composed `FieldChange` which is invalidated by new cross-field information will be added to `crossFieldTable.invalidatedFields`.
      */
     composeFieldChanges(fieldId, change1, change2, idAllocator, crossFieldTable, revisionMetadata) {
         const { fieldKind, changeHandler, change1: change1Normalized, change2: change2Normalized, } = this.normalizeFieldChanges(change1, change2);
-        const manager = new ComposeManager(crossFieldTable, change1, fieldId);
+        const manager = new ComposeNodeManagerI(crossFieldTable, fieldId);
         const composedChange = changeHandler.rebaser.compose(change1Normalized, change2Normalized, (child1, child2) => {
             if (child1 !== undefined && child2 !== undefined) {
-                setInChangeAtomIdMap(crossFieldTable.newToBaseNodeId, child2, child1);
-                crossFieldTable.pendingCompositions.nodeIdsToCompose.push([child1, child2]);
+                addNodesToCompose(crossFieldTable, child1, child2);
             }
             return child1 ?? child2 ?? fail(0xb23 /* Should not compose two undefined nodes */);
         }, idAllocator, manager, revisionMetadata);
@@ -268,19 +285,18 @@ export class ModularChangeFamily {
         crossFieldTable.newFieldToBaseField.set(change2, change1);
         return composedField;
     }
-    composeNodesById(nodeChanges1, nodeChanges2, composedNodes, composedNodeToParent, nodeAliases, id1, id2, idAllocator, crossFieldTable, revisionMetadata) {
-        const nodeChangeset1 = nodeChangeFromId(nodeChanges1, id1);
-        const nodeChangeset2 = nodeChangeFromId(nodeChanges2, id2);
+    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);
         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(nodeAliases, id2, id1);
+            setInChangeAtomIdMap(composedAliases, id2, id1);
             // We need to delete id1 to avoid forming a cycle in case id1 already had an alias.
-            nodeAliases.delete([id1.revision, id1.localId]);
+            composedAliases.delete([id1.revision, id1.localId]);
         }
-        crossFieldTable.composedNodes.add(composedNodeChangeset);
     }
     composeNodeChanges(nodeId, change1, change2, genId, crossFieldTable, revisionMetadata) {
         // WARNING: this composition logic assumes that we never make compositions of the following form:
@@ -331,9 +347,14 @@ export class ModularChangeFamily {
         }
         const genId = idAllocatorFromMaxId(change.change.maxId ?? -1);
         const crossFieldTable = {
-            ...newCrossFieldTable(),
+            change: change.change,
+            entries: newChangeAtomIdRangeMap(),
             originalFieldToContext: new Map(),
+            invertRevision: revisionForInvert,
             invertedNodeToParent: brand(change.change.nodeToParent.clone()),
+            invalidatedFields: new Set(),
+            invertedRoots: invertRootTable(change.change, isRollback),
+            attachToDetachId: newChangeAtomIdTransform(),
         };
         const { revInfos: oldRevInfos } = getRevInfoFromTaggedChanges([change]);
         const revisionMetadata = revisionMetadataSourceFromInfo(oldRevInfos);
@@ -349,16 +370,18 @@ 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, fieldId } = context;
-                const amendedChange = getChangeHandler(this.fieldKinds, fieldChange.fieldKind).rebaser.invert(originalFieldChange, isRollback, genId, revisionForInvert, new InvertManager(crossFieldTable, fieldChange, fieldId), revisionMetadata);
+                const { invertedField } = context;
+                const amendedChange = getChangeHandler(this.fieldKinds, fieldChange.fieldKind).rebaser.invert(originalFieldChange, isRollback, genId, revisionForInvert, new InvertNodeManagerI(crossFieldTable, context.fieldId), revisionMetadata);
                 invertedField.change = brand(amendedChange);
             }
         }
         const crossFieldKeys = this.makeCrossFieldKeyTable(invertedFields, invertedNodes);
+        this.processInvertRenames(crossFieldTable);
         return makeModularChangeset({
             fieldChanges: invertedFields,
             nodeChanges: invertedNodes,
             nodeToParent: crossFieldTable.invertedNodeToParent,
+            rootNodes: crossFieldTable.invertedRoots,
             nodeAliases: change.change.nodeAliases,
             crossFieldKeys,
             maxId: genId.getMaxId(),
@@ -372,7 +395,7 @@ export class ModularChangeFamily {
         const invertedFields = new Map();
         for (const [field, fieldChange] of changes) {
             const fieldId = { nodeId: parentId, field };
-            const manager = new InvertManager(crossFieldTable, fieldChange, fieldId);
+            const manager = new InvertNodeManagerI(crossFieldTable, fieldId);
             const invertedChange = getChangeHandler(this.fieldKinds, fieldChange.fieldKind).rebaser.invert(fieldChange.change, isRollback, genId, revisionForInvert, manager, revisionMetadata);
             const invertedFieldChange = {
                 ...fieldChange,
@@ -404,6 +427,12 @@ 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.
@@ -414,17 +443,26 @@ export class ModularChangeFamily {
         const maxId = Math.max(change.maxId ?? -1, over.change.maxId ?? -1);
         const idState = { maxId };
         const genId = idAllocatorFromState(idState);
+        const affectedBaseFields = newTupleBTree();
+        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 = {
-            ...newCrossFieldTable(),
+            rebaseVersion,
+            entries: newDetachedEntryMap(),
             newChange: change,
             baseChange: over.change,
             baseFieldToContext: new Map(),
+            baseRoots: over.change.rootNodes,
+            rebasedRootNodes,
             baseToRebasedNodeId: newTupleBTree(),
             rebasedFields: new Set(),
-            rebasedNodeToParent: brand(change.nodeToParent.clone()),
-            rebasedCrossFieldKeys: change.crossFieldKeys.clone(),
+            rebasedNodeToParent,
+            rebasedDetachLocations: newChangeAtomIdRangeMap(),
+            movedDetaches: newChangeAtomIdRangeMap(),
             nodeIdPairs: [],
-            affectedBaseFields: newTupleBTree(),
+            affectedBaseFields,
             fieldsWithUnattachedChild: new Set(),
         };
         const getBaseRevisions = () => revisionInfoFromTaggedChange(over).map((info) => info.revision);
@@ -434,17 +472,22 @@ export class ModularChangeFamily {
             getBaseRevisions,
         };
         const rebasedNodes = brand(change.nodeChanges.clone());
-        const rebasedFields = this.rebaseIntersectingFields(crossFieldTable, rebasedNodes, genId, rebaseMetadata);
-        this.rebaseInvalidatedElements(rebasedFields, rebasedNodes, crossFieldTable, rebaseMetadata, genId);
+        const rebasedFields = this.rebaseIntersectingFields(nodesToRebase, crossFieldTable, rebasedNodes, genId, rebaseMetadata);
+        this.rebaseInvalidatedFields(rebasedFields, rebasedNodes, crossFieldTable, rebaseMetadata, genId);
+        fixupRebasedDetachLocations(crossFieldTable);
         const constraintState = newConstraintState(change.constraintViolationCount ?? 0);
         const revertConstraintState = newConstraintState(change.constraintViolationCountOnRevert ?? 0);
-        this.updateConstraintsForFields(rebasedFields, NodeAttachState.Attached, NodeAttachState.Attached, constraintState, revertConstraintState, rebasedNodes);
+        this.updateConstraints(rebasedFields, rebasedNodes, rebasedRootNodes, constraintState, revertConstraintState);
+        const fieldsWithRootMoves = getFieldsWithRootMoves(crossFieldTable.rebasedRootNodes, change.nodeAliases);
+        const fieldToRootChanges = getFieldToRootChanges(crossFieldTable.rebasedRootNodes, change.nodeAliases);
         const rebased = makeModularChangeset({
-            fieldChanges: this.pruneFieldMap(rebasedFields, rebasedNodes),
+            fieldChanges: this.pruneFieldMap(rebasedFields, undefined, rebasedNodes, crossFieldTable.rebasedNodeToParent, change.nodeAliases, crossFieldTable.rebasedRootNodes, fieldsWithRootMoves, fieldToRootChanges),
             nodeChanges: rebasedNodes,
             nodeToParent: crossFieldTable.rebasedNodeToParent,
+            rootNodes: this.pruneRoots(crossFieldTable.rebasedRootNodes, rebasedNodes, crossFieldTable.rebasedNodeToParent, change.nodeAliases, fieldsWithRootMoves, fieldToRootChanges),
+            // TODO: Do we need to include aliases for node changesets added during rebasing?
             nodeAliases: change.nodeAliases,
-            crossFieldKeys: crossFieldTable.rebasedCrossFieldKeys,
+            crossFieldKeys: rebaseCrossFieldKeys(change.crossFieldKeys, crossFieldTable.movedDetaches, crossFieldTable.rebasedDetachLocations),
             maxId: idState.maxId,
             revisions: change.revisions,
             constraintViolationCount: constraintState.violationCount,
@@ -452,15 +495,22 @@ 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.
+        this.validateChangeset(rebased);
         return rebased;
     }
     // This performs a first pass on all fields which have both new and base changes.
     // TODO: Can we also handle additional passes in this method?
-    rebaseIntersectingFields(crossFieldTable, rebasedNodes, genId, metadata) {
+    rebaseIntersectingFields(rootChanges, 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) {
@@ -469,87 +519,85 @@ export class ModularChangeFamily {
         }
         return rebasedFields;
     }
-    // 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
-                ? normalizeNodeId({ revision, localId }, baseChange.nodeAliases)
-                : undefined;
-            const baseFieldChange = fieldMapFromNodeId(baseChange.fieldChanges, baseChange.nodeChanges, baseNodeId).get(fieldKey);
-            assert(baseFieldChange !== undefined, 0x9c2 /* Cross field key registered for empty field */);
-            if (crossFieldTable.baseFieldToContext.has(baseFieldChange)) {
-                // This field has already been processed because there were changes to rebase.
-                continue;
-            }
-            // 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 */);
+    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;
-            };
-            const handler = getChangeHandler(this.fieldKinds, baseFieldChange.fieldKind);
-            const fieldChange = {
-                ...baseFieldChange,
-                change: brand(handler.createEmpty()),
-            };
-            const rebasedNodeId = baseNodeId !== undefined
-                ? rebasedNodeIdFromBaseNodeId(crossFieldTable, baseNodeId)
+            }
+            return areEqualChangeAtomIds(normalizeNodeId(baseChild, crossFieldTable.baseChange.nodeAliases), baseNodeId)
+                ? baseNodeId
                 : undefined;
-            const fieldId = { nodeId: rebasedNodeId, field: fieldKey };
-            const rebasedField = handler.rebaser.rebase(fieldChange.change, baseFieldChange.change, rebaseChild, 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);
+        };
+        const handler = getChangeHandler(this.fieldKinds, baseFieldChange.fieldKind);
+        const fieldChange = {
+            ...baseFieldChange,
+            change: brand(handler.createEmpty()),
+        };
+        const rebasedNodeId = baseFieldId.nodeId !== undefined
+            ? rebasedNodeIdFromBaseNodeId(crossFieldTable, baseFieldId.nodeId)
+            : undefined;
+        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: newTupleBTree(),
+        };
+        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);
+                }
+            }
         }
     }
-    rebaseInvalidatedField(baseField, crossFieldTable, rebaseMetadata, genId, allowInval = false) {
-        const context = crossFieldTable.baseFieldToContext.get(baseField);
-        assert(context !== undefined, 0x852 /* Every field should have a context */);
+    rebaseInvalidatedField(baseField, crossFieldTable, context, rebaseMetadata, genId) {
         const { changeHandler, change1: fieldChangeset, change2: baseChangeset, } = this.normalizeFieldChanges(context.newChange, context.baseChange);
         const rebaseChild = (curr, base) => {
             if (curr !== undefined) {
                 return curr;
             }
-            if (base !== undefined) {
-                for (const id of context.baseNodeIds) {
-                    if (areEqualChangeAtomIds(base, id)) {
-                        return base;
-                    }
-                }
+            if (base !== undefined && getFromChangeAtomIdMap(context.baseNodeIds, base) === true) {
+                return base;
             }
             return undefined;
         };
-        context.rebasedChange.change = brand(changeHandler.rebaser.rebase(fieldChangeset, baseChangeset, rebaseChild, genId, new RebaseManager(crossFieldTable, baseField, context.fieldId, allowInval), rebaseMetadata));
+        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));
     }
     attachRebasedField(rebasedFields, rebasedNodes, table, rebasedField, { nodeId, field: fieldKey }, idAllocator, metadata) {
         if (nodeId === undefined) {
@@ -558,12 +606,14 @@ export class ModularChangeFamily {
         }
         const rebasedNode = getFromChangeAtomIdMap(rebasedNodes, nodeId);
         if (rebasedNode !== undefined) {
-            if (rebasedNode.fieldChanges === undefined) {
-                rebasedNode.fieldChanges = new Map([[fieldKey, rebasedField]]);
+            const updatedRebasedNode = cloneNodeChangeset(rebasedNode);
+            setInChangeAtomIdMap(rebasedNodes, nodeId, updatedRebasedNode);
+            if (updatedRebasedNode.fieldChanges === undefined) {
+                updatedRebasedNode.fieldChanges = new Map([[fieldKey, rebasedField]]);
                 return;
             }
-            assert(!rebasedNode.fieldChanges.has(fieldKey), 0x9c4 /* Expected an empty field */);
-            rebasedNode.fieldChanges.set(fieldKey, rebasedField);
+            assert(!updatedRebasedNode.fieldChanges.has(fieldKey), 0x9c4 /* Expected an empty field */);
+            updatedRebasedNode.fieldChanges.set(fieldKey, rebasedField);
             return;
         }
         const newNode = {
@@ -571,39 +621,51 @@ export class ModularChangeFamily {
         };
         setInChangeAtomIdMap(rebasedNodes, nodeId, newNode);
         setInChangeAtomIdMap(table.baseToRebasedNodeId, nodeId, nodeId);
-        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 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: CrossFieldTarget.Destination }, 1).value;
+            if (attachField !== undefined) {
+                // The base change inserts this node into `attachField`, so the rebased change should represent this node there.
+                const normalizedAttachField = normalizeFieldId(attachField, table.baseChange.nodeAliases);
+                const entry = table.entries.getFirst(renamedRoot, 1).value ?? {};
+                table.entries.set(renamedRoot, 1, { ...entry, nodeChange: baseNodeId });
+                table.affectedBaseFields.set(fieldIdKeyFromFieldId(normalizedAttachField), true);
+                this.attachRebasedNode(rebasedFields, rebasedNodes, table, baseNodeId, { field: normalizedAttachField }, idAllocator, metadata);
+            }
+            else {
+                const baseDetachLocation = table.baseChange.rootNodes.detachLocations.getFirst(parentBase.root, 1).value;
+                assignRootChange(table.rebasedRootNodes, table.rebasedNodeToParent, renamedRoot, baseNodeId, baseDetachLocation, table.rebaseVersion);
+                // We need to make sure the rebased changeset includes the detach location,
+                // so we add that field to `affectedBaseFields` unless it's already been processed.
+                if (baseDetachLocation !== undefined &&
+                    !table.baseFieldToContext.has(fieldChangeFromId(table.baseChange, baseDetachLocation))) {
+                    table.affectedBaseFields.set(fieldIdKeyFromFieldId(baseDetachLocation), true);
+                }
+            }
+            return;
+        }
+        const parentFieldIdBase = parentBase.field;
+        const baseFieldChange = fieldChangeFromId(table.baseChange, parentFieldIdBase);
         const rebasedFieldId = rebasedFieldIdFromBaseId(table, parentFieldIdBase);
-        setInChangeAtomIdMap(table.rebasedNodeToParent, baseNodeId, rebasedFieldId);
+        setInChangeAtomIdMap(table.rebasedNodeToParent, baseNodeId, { field: rebasedFieldId });
         const context = table.baseFieldToContext.get(baseFieldChange);
         if (context !== undefined) {
             // We've already processed this field.
-            // The new child node will be attached in rebaseFieldsWithUnattachedChild.
-            context.baseNodeIds.push(baseNodeId);
-            table.fieldsWithUnattachedChild.add(baseFieldChange);
+            // The new child node will be attached in the next pass.
+            // Note that adding to `fieldsWithUnattachedChild` allows that field to generate new invalidations,
+            // so to avoid invalidation cycles we make sure we only add to it once per new unattached child.
+            // This is done by checking whether `context.baseNodeIds` already contained `baseNodeId`.
+            if (setInChangeAtomIdMap(context.baseNodeIds, baseNodeId, true)) {
+                table.fieldsWithUnattachedChild.add(baseFieldChange);
+                table.affectedBaseFields.set(fieldIdKeyFromFieldId(parentFieldIdBase), true);
+            }
             return;
         }
-        const handler = getChangeHandler(this.fieldKinds, baseFieldChange.fieldKind);
-        const fieldChange = {
-            ...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);
+        this.rebaseFieldWithoutNewChanges(baseFieldChange, parentFieldIdBase, table, rebasedFields, rebasedNodes, idAllocator, metadata, baseNodeId);
     }
     rebaseFieldMap(change, over, parentId, genId, crossFieldTable, revisionMetadata) {
         const rebasedFields = new Map();
@@ -621,8 +683,8 @@ export class ModularChangeFamily {
                 continue;
             }
             const { fieldKind, changeHandler, change1: fieldChangeset, change2: baseChangeset, } = this.normalizeFieldChanges(fieldChange, baseChange);
-            const manager = new RebaseManager(crossFieldTable, baseChange, fieldId);
-            const rebasedField = changeHandler.rebaser.rebase(fieldChangeset, baseChangeset, rebaseChild, genId, manager, revisionMetadata);
+            const manager = new RebaseNodeManagerI(crossFieldTable, fieldId);
+            const rebasedField = changeHandler.rebaser.rebase(fieldChangeset, baseChangeset, rebaseChild, genId, manager, revisionMetadata, crossFieldTable.rebaseVersion);
             const rebasedFieldChange = {
                 fieldKind,
                 change: brand(rebasedField),
@@ -633,15 +695,15 @@ export class ModularChangeFamily {
                 newChange: fieldChange,
                 rebasedChange: rebasedFieldChange,
                 fieldId,
-                baseNodeIds: [],
+                baseNodeIds: newTupleBTree(),
             });
             crossFieldTable.rebasedFields.add(rebasedFieldChange);
         }
         return rebasedFields;
     }
     rebaseNodeChange(newId, baseId, genId, crossFieldTable, revisionMetadata) {
-        const change = nodeChangeFromId(crossFieldTable.newChange.nodeChanges, newId);
-        const over = nodeChangeFromId(crossFieldTable.baseChange.nodeChanges, baseId);
+        const change = nodeChangeFromId(crossFieldTable.newChange.nodeChanges, crossFieldTable.newChange.nodeAliases, newId);
+        const over = nodeChangeFromId(crossFieldTable.baseChange.nodeChanges, crossFieldTable.baseChange.nodeAliases, baseId);
         const baseMap = over?.fieldChanges ?? new Map();
         const fieldChanges = change.fieldChanges !== undefined && over.fieldChanges !== undefined
             ? this.rebaseFieldMap(change?.fieldChanges ?? new Map(), baseMap, newId, genId, crossFieldTable, revisionMetadata)
@@ -659,28 +721,37 @@ 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, inputIndex, outputIndex] of handler.getNestedChanges(field.change)) {
-                const isInputDetached = inputIndex === undefined;
-                const inputAttachState = parentInputAttachState === NodeAttachState.Detached || isInputDetached
-                    ? NodeAttachState.Detached
-                    : NodeAttachState.Attached;
-                const isOutputDetached = outputIndex === undefined;
+            for (const [nodeId] of handler.getNestedChanges(field.change)) {
+                // XXX: This is incorrect if the rebased changeset detaches this node.
+                // Efficiently computing whether the changeset detaches the node would require maintaining a mapping from node ID to detach ID.
+                const isOutputDetached = false;
                 const outputAttachState = parentOutputAttachState === NodeAttachState.Detached || isOutputDetached
                     ? NodeAttachState.Detached
                     : NodeAttachState.Attached;
-                this.updateConstraintsForNode(nodeId, inputAttachState, outputAttachState, nodes, constraintState, revertConstraintState);
+                this.updateConstraintsForNode(nodeId, parentInputAttachState, outputAttachState, nodes, constraintState, revertConstraintState);
             }
         }
     }
     updateConstraintsForNode(nodeId, inputAttachState, outputAttachState, nodes, constraintState, revertConstraintState) {
-        const node = nodes.get([nodeId.revision, nodeId.localId]) ?? fail(0xb24 /* Unknown node ID */);
+        const node = getFromChangeAtomIdMap(nodes, nodeId) ?? fail(0xb24 /* Unknown node ID */);
+        const updatedNode = { ...node };
+        setInChangeAtomIdMap(nodes, nodeId, updatedNode);
         if (node.nodeExistsConstraint !== undefined) {
             const isNowViolated = inputAttachState === NodeAttachState.Detached;
             if (node.nodeExistsConstraint.violated !== isNowViolated) {
-                node.nodeExistsConstraint = {
+                updatedNode.nodeExistsConstraint = {
                     ...node.nodeExistsConstraint,
                     violated: isNowViolated,
                 };
@@ -690,7 +761,7 @@ export class ModularChangeFamily {
         if (node.nodeExistsConstraintOnRevert !== undefined) {
             const isNowViolated = outputAttachState === NodeAttachState.Detached;
             if (node.nodeExistsConstraintOnRevert.violated !== isNowViolated) {
-                node.nodeExistsConstraintOnRevert = {
+                updatedNode.nodeExistsConstraintOnRevert = {
                     ...node.nodeExistsConstraintOnRevert,
                     violated: isNowViolated,
                 };
@@ -701,35 +772,70 @@ export class ModularChangeFamily {
             this.updateConstraintsForFields(node.fieldChanges, inputAttachState, outputAttachState, constraintState, revertConstraintState, nodes);
         }
     }
-    pruneFieldMap(changeset, nodeMap) {
+    pruneFieldMap(changeset, parentId, nodeMap, nodeToParent, aliases, roots, fieldsWithRootMoves, fieldsToRootChanges) {
         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));
-            if (!handler.isEmpty(prunedFieldChangeset)) {
+            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) {
                 prunedChangeset.set(field, { ...fieldChange, change: brand(prunedFieldChangeset) });
             }
         }
         return prunedChangeset.size > 0 ? prunedChangeset : undefined;
     }
-    pruneNodeChange(nodeId, nodeMap) {
-        const changeset = nodeChangeFromId(nodeMap, nodeId);
+    pruneRoots(roots, nodeMap, nodeToParent, aliases, fieldsWithRootMoves, fieldsToRootChanges) {
+        const pruned = { ...roots, nodeChanges: newTupleBTree() };
+        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);
         const prunedFields = changeset.fieldChanges !== undefined
-            ? this.pruneFieldMap(changeset.fieldChanges, nodeMap)
+            ? this.pruneFieldMap(changeset.fieldChanges, nodeId, nodes, nodeToParent, aliases, roots, fieldsWithRootMoves, fieldsToRootChanges)
             : undefined;
         const prunedChange = { ...changeset, fieldChanges: prunedFields };
         if (prunedChange.fieldChanges === undefined) {
             delete prunedChange.fieldChanges;
         }
         if (isEmptyNodeChangeset(prunedChange)) {
-            nodeMap.delete([nodeId.revision, nodeId.localId]);
+            const nodeIdKey = [nodeId.revision, nodeId.localId];
+            // TODO: Shouldn't we also delete all aliases associated with this node?
+            nodes.delete(nodeIdKey);
+            nodeToParent.delete(nodeIdKey);
             return undefined;
         }
         else {
-            setInChangeAtomIdMap(nodeMap, nodeId, prunedChange);
+            setInChangeAtomIdMap(nodes, nodeId, prunedChange);
             return nodeId;
         }
     }
@@ -743,17 +849,18 @@ export class ModularChangeFamily {
             updatedNodes.set([replaceRevision(revision, oldRevisions, newRevision), id], this.replaceNodeChangesetRevisions(nodeChangeset, oldRevisions, newRevision));
         }
         const updatedNodeToParent = newTupleBTree();
-        for (const [[revision, id], fieldId] of change.nodeToParent.entries()) {
-            updatedNodeToParent.set([replaceRevision(revision, oldRevisions, newRevision), id], replaceFieldIdRevision(normalizeFieldId(fieldId, change.nodeAliases), oldRevisions, newRevision));
+        for (const [[revision, id], location] of change.nodeToParent.entries()) {
+            updatedNodeToParent.set([replaceRevision(revision, oldRevisions, newRevision), id], replaceNodeLocationRevision(normalizeNodeLocation(location, change.nodeAliases), oldRevisions, newRevision));
         }
         const updated = {
             ...change,
             fieldChanges: updatedFields,
             nodeChanges: updatedNodes,
             nodeToParent: updatedNodeToParent,
+            rootNodes: replaceRootTableRevision(change.rootNodes, oldRevisions, newRevision, change.nodeAliases),
             // We've updated all references to old node IDs, so we no longer need an alias table.
             nodeAliases: newTupleBTree(),
-            crossFieldKeys: replaceCrossFieldKeyTableRevisions(change.crossFieldKeys, oldRevisions, newRevision, change.nodeAliases),
+            crossFieldKeys: change.crossFieldKeys.mapEntries((key) => replaceCrossFieldKeyRevision(key, oldRevisions, newRevision), (id) => replaceFieldIdRevision(normalizeFieldId(id, change.nodeAliases), oldRevisions, newRevision)),
         };
         if (change.builds !== undefined) {
             updated.builds = replaceIdMapRevisions(change.builds, oldRevisions, newRevision);
@@ -792,7 +899,7 @@ export class ModularChangeFamily {
         return updatedFields;
     }
     makeCrossFieldKeyTable(fields, nodes) {
-        const keys = newCrossFieldKeyTable();
+        const keys = newCrossFieldRangeTable();
         this.populateCrossFieldKeyTableForFieldMap(keys, fields, undefined);
         nodes.forEachPair(([revision, localId], node) => {
             if (node.fieldChanges !== undefined) {
@@ -820,40 +927,53 @@ export class ModularChangeFamily {
         return { fieldKind, change: brand(emptyChange) };
     }
     validateChangeset(change) {
-        let numNodes = this.validateFieldChanges(change, change.fieldChanges, undefined);
+        const unreachableNodes = brand(change.nodeToParent.clone());
+        const unreachableCFKs = change.crossFieldKeys.clone();
+        this.validateFieldChanges(change, change.fieldChanges, undefined, unreachableNodes, unreachableCFKs);
         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;
+            const nodeId = normalizeNodeId({ revision, localId }, change.nodeAliases);
+            this.validateFieldChanges(change, node.fieldChanges, nodeId, unreachableNodes, unreachableCFKs);
+        }
+        for (const [detachIdKey, nodeId] of change.rootNodes.nodeChanges.entries()) {
+            const detachId = { 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) {
+                this.validateFieldChanges(change, fieldChanges, normalizedNodeId, unreachableNodes, unreachableCFKs);
+            }
         }
-        assert(numNodes === change.nodeChanges.size, 0xa4d /* Node table contains unparented nodes */);
+        assert(unreachableNodes.size === 0, "Unreachable nodes found");
+        assert(unreachableCFKs.entries().length === 0, "Unreachable cross-field keys found");
     }
     /**
-     * Asserts that each child and cross field key in each field has a correct entry in
-     * `nodeToParent` or `crossFieldKeyTable`.
+     * 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.
      */
-    validateFieldChanges(change, fieldChanges, nodeParent) {
-        let numChildren = 0;
+    validateFieldChanges(change, fieldChanges, nodeParent, unreachableNodes, unreachableCFKs) {
         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;
+                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 === 1 &&
-                    fields[0] !== undefined &&
-                    areEqualFieldIds(fields[0], fieldId), 0xa4f /* Inconsistent cross field keys */);
+                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);
             }
         }
-        return numChildren;
     }
     getEffectiveChange(change) {
         if (hasConflicts(change)) {
@@ -867,7 +987,8 @@ export class ModularChangeFamily {
     muteChange(change) {
         const muted = {
             ...change,
-            crossFieldKeys: newCrossFieldKeyTable(),
+            rootNodes: muteRootChanges(change.rootNodes),
+            crossFieldKeys: newCrossFieldRangeTable(),
             fieldChanges: this.muteFieldChanges(change.fieldChanges),
             nodeChanges: brand(change.nodeChanges.mapValues((v) => this.muteNodeChange(v))),
         };
@@ -894,27 +1015,12 @@ export class ModularChangeFamily {
     }
 }
 ModularChangeFamily.emptyChange = makeModularChangeset();
-function replaceCrossFieldKeyTableRevisions(table, oldRevisions, newRevision, nodeAliases) {
-    const updated = newCrossFieldKeyTable();
-    for (const entry of table.entries()) {
-        const key = entry.start;
-        const updatedKey = {
-            target: key.target,
-            revision: replaceRevision(key.revision, oldRevisions, newRevision),
-            localId: key.localId,
-        };
-        const field = entry.value;
-        const normalizedFieldId = normalizeFieldId(field, nodeAliases);
-        const updatedNodeId = normalizedFieldId.nodeId !== undefined
-            ? replaceAtomRevisions(normalizedFieldId.nodeId, oldRevisions, newRevision)
-            : undefined;
-        const updatedValue = {
-            ...normalizedFieldId,
-            nodeId: updatedNodeId,
-        };
-        updated.set(updatedKey, entry.length, updatedValue);
-    }
-    return updated;
+function replaceCrossFieldKeyRevision(key, oldRevisions, newRevision) {
+    return {
+        target: key.target,
+        revision: replaceRevision(key.revision, oldRevisions, newRevision),
+        localId: key.localId,
+    };
 }
 function replaceRevision(revision, oldRevisions, newRevision) {
     return oldRevisions.has(revision) ? newRevision : revision;
@@ -960,6 +1066,19 @@ 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) {
@@ -984,18 +1103,44 @@ function invertBuilds(builds) {
  * @param fieldKinds - The field kinds to delegate to.
  */
 export function* relevantRemovedRoots(change, fieldKinds) {
-    yield* relevantRemovedRootsFromFields(change.fieldChanges, change.nodeChanges, fieldKinds);
-}
-function* relevantRemovedRootsFromFields(change, nodeChanges, fieldKinds) {
-    for (const [_, fieldChange] of change) {
-        const handler = getChangeHandler(fieldKinds, fieldChange.fieldKind);
-        const delegate = function* (node) {
-            const nodeChangeset = nodeChangeFromId(nodeChanges, node);
-            if (nodeChangeset.fieldChanges !== undefined) {
-                yield* relevantRemovedRootsFromFields(nodeChangeset.fieldChanges, nodeChanges, 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);
+        }
+    }
+}
+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 !== CrossFieldTarget.Destination) {
+            continue;
+        }
+        for (const detachIdEntry of change.rootNodes.newToOldId.getAll2(entry.start, entry.length)) {
+            const detachId = detachIdEntry.value ?? offsetChangeAtomId(entry.start, detachIdEntry.offset);
+            for (const detachEntry of change.crossFieldKeys.getAll2({ ...detachId, target: CrossFieldTarget.Source }, detachIdEntry.length)) {
+                if (detachEntry.value === undefined) {
+                    rootIds.set(offsetChangeAtomId(detachId, detachEntry.offset), detachEntry.length, true);
+                }
             }
-        };
-        yield* handler.relevantRemovedRoots(fieldChange.change, delegate);
+        }
+    }
+}
+function addRenamesToSet(change, rootIds) {
+    for (const renameEntry of change.rootNodes.oldToNewId.entries()) {
+        for (const detachEntry of change.crossFieldKeys.getAll2({ ...renameEntry.start, target: CrossFieldTarget.Source }, renameEntry.length)) {
+            // We only want to include renames of nodes which are detached in the input context of the changeset.
+            // So if there is a detach for the node, the rename is not relevant.
+            if (detachEntry.value === undefined) {
+                rootIds.set(renameEntry.start, renameEntry.length, true);
+            }
+        }
     }
 }
 /**
@@ -1047,6 +1192,7 @@ export function updateRefreshers(change, getDetachedNode, removedRoots, requireR
         nodeChanges,
         nodeToParent: change.nodeToParent,
         nodeAliases: change.nodeAliases,
+        rootNodes: change.rootNodes,
         crossFieldKeys: change.crossFieldKeys,
         maxId: maxId,
         revisions,
@@ -1066,11 +1212,24 @@ 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, fieldKinds, global, rename);
+        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),
+            });
+        }
         if (fieldDeltas.size > 0) {
             rootDelta.fields = fieldDeltas;
         }
@@ -1116,24 +1275,22 @@ function copyDetachedNodes(detachedNodes) {
 /**
  * @param change - The change to convert into a delta.
  */
-function intoDeltaImpl(change, nodeChanges, fieldKinds, global, rename) {
+function intoDeltaImpl(change, nodeChanges, nodeAliases, fieldKinds) {
     const delta = new Map();
     for (const [field, fieldChange] of change) {
-        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);
+        const fieldDelta = getChangeHandler(fieldKinds, fieldChange.fieldKind).intoDelta(fieldChange.change, (childChange) => {
+            const nodeChange = nodeChangeFromId(nodeChanges, nodeAliases, childChange);
+            return deltaFromNodeChange(nodeChange, nodeChanges, nodeAliases, fieldKinds);
         });
-        if (fieldChanges !== undefined && fieldChanges.length > 0) {
-            delta.set(field, fieldChanges);
+        if (fieldDelta !== undefined && fieldDelta.length > 0) {
+            delta.set(field, fieldDelta);
         }
-        fieldGlobal?.forEach((c) => global.push(c));
-        fieldRename?.forEach((r) => rename.push(r));
     }
     return delta;
 }
-function deltaFromNodeChange(change, nodeChanges, fieldKinds, global, rename) {
+function deltaFromNodeChange(change, nodeChanges, nodeAliases, fieldKinds) {
     if (change.fieldChanges !== undefined) {
-        return intoDeltaImpl(change.fieldChanges, nodeChanges, fieldKinds, global, rename);
+        return intoDeltaImpl(change.fieldChanges, nodeChanges, nodeAliases, fieldKinds);
     }
     // TODO: update the API to allow undefined to be returned here
     return new Map();
@@ -1180,30 +1337,22 @@ export function getFieldKind(fieldKinds, kind) {
 export function getChangeHandler(fieldKinds, kind) {
     return getFieldKind(fieldKinds, kind).changeHandler;
 }
-function newComposeTable(baseChange, newChange, composedNodeToParent) {
+function newComposeTable(baseChange, newChange, composedRootNodes, movedCrossFieldKeys, removedCrossFieldKeys, pendingCompositions) {
     return {
-        ...newCrossFieldTable(),
+        rebaseVersion: Math.max(baseChange.rebaseVersion, newChange.rebaseVersion),
+        entries: newDetachedEntryMap(),
         baseChange,
         newChange,
         fieldToContext: new Map(),
         newFieldToBaseField: new Map(),
         newToBaseNodeId: newTupleBTree(),
         composedNodes: new Set(),
-        composedNodeToParent,
-        pendingCompositions: {
-            nodeIdsToCompose: [],
-            affectedBaseFields: newTupleBTree(),
-            affectedNewFields: newTupleBTree(),
-        },
-    };
-}
-function newCrossFieldTable() {
-    return {
-        srcTable: newChangeAtomIdRangeMap(),
-        dstTable: newChangeAtomIdRangeMap(),
-        srcDependents: newChangeAtomIdRangeMap(),
-        dstDependents: newChangeAtomIdRangeMap(),
-        invalidatedFields: new Set(),
+        movedNodeToParent: newTupleBTree(),
+        composedRootNodes,
+        movedCrossFieldKeys,
+        removedCrossFieldKeys,
+        renamesToDelete: newChangeAtomIdRangeMap(),
+        pendingCompositions,
     };
 }
 function newConstraintState(violationCount) {
@@ -1211,147 +1360,354 @@ function newConstraintState(violationCount) {
         violationCount,
     };
 }
-class CrossFieldManagerI {
-    constructor(crossFieldTable, currentFieldKey, allowInval = true) {
-        this.crossFieldTable = crossFieldTable;
-        this.currentFieldKey = currentFieldKey;
-        this.allowInval = allowInval;
+class InvertNodeManagerI {
+    constructor(table, fieldId) {
+        this.table = table;
+        this.fieldId = 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);
+    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: CrossFieldTarget.Destination, ...attachEntry.value }, count);
+            if (attachFieldEntry.value !== undefined) {
+                setInCrossFieldMap(this.table.entries, attachEntry.value, count, nodeChange);
+                this.table.invalidatedFields.add(fieldChangeFromId(this.table.change, attachFieldEntry.value));
+            }
+            else {
+                assignRootChange(this.table.invertedRoots, this.table.invertedNodeToParent, attachEntry.value, nodeChange, this.fieldId, this.table.change.rebaseVersion);
+            }
+        }
+        if (!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);
                 }
-                firstId = brand(firstId + dependentEntry.length);
             }
         }
-        setInCrossFieldMap(this.getMap(target), revision, id, count, newValue);
     }
-    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);
+    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: CrossFieldTarget.Source, ...detachIdEntry.value }, countToProcess);
+        countToProcess = detachEntry.length;
+        let result;
+        if (detachEntry.value !== undefined) {
+            const moveEntry = this.table.entries.getFirst(attachId, countToProcess);
+            result = { ...moveEntry, value: { nodeChange: moveEntry.value } };
         }
-        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 InvertManager extends CrossFieldManagerI {
-    constructor(table, field, fieldId, allowInval = true) {
-        super(table, field, allowInval);
-        this.fieldId = fieldId;
-    }
-    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;
+        else {
+            // 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;
+            result = {
+                value: { nodeChange: nodeIdEntry.value, detachId: detachIdEntry.value },
+                length: countToProcess,
+            };
+        }
+        if (result.value?.nodeChange !== undefined) {
+            setInChangeAtomIdMap(this.table.invertedNodeToParent, result.value.nodeChange, {
+                field: this.fieldId,
+            });
+        }
+        return result;
     }
 }
-class RebaseManager extends CrossFieldManagerI {
-    constructor(table, currentField, fieldId, allowInval = true) {
-        super(table, currentField, allowInval);
+class RebaseNodeManagerI {
+    constructor(table, fieldId, allowInval = true) {
+        this.table = table;
         this.fieldId = fieldId;
+        this.allowInval = allowInval;
     }
-    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);
+    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: CrossFieldTarget.Destination }, countToProcess);
+        countToProcess = attachFieldEntry.length;
+        const detachedMoveEntry = this.table.baseChange.rootNodes.outputDetachLocations.getFirst(baseDetachId, countToProcess);
+        countToProcess = detachedMoveEntry.length;
+        const destinationField = attachFieldEntry.value ?? detachedMoveEntry.value;
+        if (destinationField !== undefined) {
+            // The base detach is part of a move (or move of detach location) in the base changeset.
+            setInCrossFieldMap(this.table.entries, baseAttachId, countToProcess, {
+                nodeChange,
+                detachId: newDetachId,
+                cellRename,
+            });
+            if (nodeChange !== undefined || newDetachId !== undefined) {
+                this.invalidateBaseFields([destinationField]);
+            }
+        }
+        if (attachFieldEntry.value === undefined) {
+            // These nodes are detached in the output context of the base changeset.
+            if (nodeChange !== undefined) {
+                assignRootChange(this.table.rebasedRootNodes, this.table.rebasedNodeToParent, baseAttachId, nodeChange, this.fieldId, this.table.rebaseVersion);
+            }
+            if (newDetachId !== undefined) {
+                addNodeRename(this.table.rebasedRootNodes, baseAttachId, newDetachId, countToProcess, this.fieldId);
+            }
+        }
+        if (newDetachId !== undefined) {
+            this.table.movedDetaches.set(newDetachId, countToProcess, true);
+        }
+        if (countToProcess < count) {
+            const remainingCount = count - countToProcess;
+            const nextDetachId = newDetachId !== undefined
+                ? offsetChangeAtomId(newDetachId, countToProcess)
+                : undefined;
+            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);
             }
         }
-        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;
+}
+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);
+    if (nodeToParent !== undefined) {
+        setInChangeAtomIdMap(nodeToParent, nodeId, { root: detachId });
     }
+    table.detachLocations.set(detachId, 1, detachLocation);
 }
-// TODO: Deduplicate this with RebaseTable
-class ComposeManager extends CrossFieldManagerI {
-    constructor(table, currentField, fieldId, allowInval = true) {
-        super(table, currentField, allowInval);
+class ComposeNodeManagerI {
+    constructor(table, fieldId, allowInval = true) {
+        this.table = table;
         this.fieldId = fieldId;
+        this.allowInval = allowInval;
     }
-    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);
-                }
+    getNewChangesForBaseDetach(baseDetachId, count) {
+        let countToProcess = count;
+        const baseAttachEntry = getFirstFieldForCrossFieldKey(this.table.baseChange, { target: CrossFieldTarget.Destination, ...baseDetachId }, countToProcess);
+        countToProcess = baseAttachEntry.length;
+        let result;
+        if (baseAttachEntry.value !== undefined) {
+            // The base detach was part of a move.
+            // We check if we've previously seen a node change at the move destination.
+            const entry = this.table.entries.getFirst(baseDetachId, countToProcess);
+            result = { value: entry.value, length: entry.length };
+        }
+        else {
+            // The detached nodes are still detached in the new change's input context.
+            const rootEntry = rangeQueryChangeAtomIdMap(this.table.newChange.rootNodes.nodeChanges, baseDetachId, countToProcess);
+            countToProcess = rootEntry.length;
+            const newRenameEntry = this.table.newChange.rootNodes.oldToNewId.getFirst(baseDetachId, countToProcess);
+            countToProcess = newRenameEntry.length;
+            result = {
+                value: { nodeChange: rootEntry.value, detachId: newRenameEntry.value },
+                length: countToProcess,
+            };
+        }
+        // TODO: Consider moving this to a separate method so that this method can be side-effect free.
+        if (result.value?.nodeChange !== undefined) {
+            setInChangeAtomIdMap(this.table.movedNodeToParent, result.value.nodeChange, {
+                field: this.fieldId,
+            });
+        }
+        return result;
+    }
+    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: CrossFieldTarget.Destination }, 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) {
+            // The base change moves these nodes.
+            const prevEntry = this.table.entries.getFirst(baseAttachId, baseDetachEntry.length).value ?? {};
+            this.table.entries.set(baseAttachId, baseDetachEntry.length, {
+                ...prevEntry,
+                detachId: newDetachId,
+            });
+            // The new detach will replace the base detach, so we remove the key for the base detach, unless they have the same ID.
+            if (!areEqualChangeAtomIds(baseAttachId, newDetachId)) {
+                this.table.removedCrossFieldKeys.set({ ...baseAttachId, target: CrossFieldTarget.Source }, countToProcess, true);
+            }
+            this.table.movedCrossFieldKeys.set({ ...newDetachId, target: CrossFieldTarget.Source }, countToProcess, baseDetachEntry.value);
+            this.invalidateBaseFields([baseDetachEntry.value]);
+        }
+        else {
+            const baseDetachLocationEntry = this.table.baseChange.rootNodes.detachLocations.getFirst(baseDetachId, countToProcess);
+            countToProcess = baseDetachLocationEntry.length;
+            // These nodes were detached in the base change's input context,
+            // so the net effect of the two changes is a rename.
+            appendNodeRename(this.table.composedRootNodes, baseAttachId, newDetachId, baseDetachEntry.length, this.table.baseChange.rootNodes, baseDetachLocationEntry.value ?? this.fieldId);
+            this.table.removedCrossFieldKeys.set({ ...newDetachId, target: CrossFieldTarget.Source }, countToProcess, true);
+        }
+        if (newAttachEntry.value === undefined) {
+            const newOutputDetachLocationEntry = this.table.newChange.rootNodes.outputDetachLocations.getFirst(newDetachId, countToProcess);
+            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: CrossFieldTarget.Source,
+        }, 1);
+        if (detachFields.length > 0) {
+            // The base attach is part of a move in the base changeset.
+            const prevEntry = this.table.entries.getFirst(baseDetachId, 1).value ?? {};
+            this.table.entries.set(baseDetachId, 1, { ...prevEntry, nodeChange: newChanges });
+            if (newChanges !== undefined) {
+                this.invalidateBaseFields(detachFields);
+            }
+        }
+        else {
+            const baseNodeId = getFromChangeAtomIdMap(this.table.baseChange.rootNodes.nodeChanges, baseDetachId);
+            if (baseNodeId !== undefined) {
+                addNodesToCompose(this.table, baseNodeId, newChanges);
             }
             else {
-                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);
-                }
+                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.composedNodeToParent, id, this.fieldId);
     }
-    moveKey(target, revision, id, count) {
-        throw new Error("Moving cross-field keys during compose is currently unsupported");
+    areSameNodes(baseDetachId, newAttachId, count) {
+        const renamedDetachEntry = firstAttachIdFromDetachId(this.table.composedRootNodes, baseDetachId, count);
+        const isReattachOfSameNodes = areEqualChangeAtomIds(renamedDetachEntry.value, newAttachId);
+        return { ...renamedDetachEntry, value: isReattachOfSameNodes };
+    }
+    composeDetachAttach(baseDetachId, newAttachId, count, composeToPin) {
+        const areSameEntry = this.areSameNodes(baseDetachId, newAttachId, count);
+        const countToProcess = areSameEntry.length;
+        if (areSameEntry.value) {
+            // These nodes have been moved back to their original location, so the composed changeset should not have any renames for them.
+            // Note that deleting the rename from `this.table.composedRootNodes` would change the result of this method
+            // if it were rerun due to the field being invalidated, so we instead record that the rename should be deleted later.
+            this.table.renamesToDelete.set(baseDetachId, countToProcess, true);
+        }
+        if (composeToPin) {
+            this.table.movedCrossFieldKeys.set({ target: CrossFieldTarget.Source, ...newAttachId }, countToProcess, this.fieldId);
+            if (!areEqualChangeAtomIds(baseDetachId, newAttachId)) {
+                // The pin will have `newAttachId` as both its detach and attach ID.
+                // So we remove `baseDetachId` unless that is equal to the pin's detach ID.
+                this.table.removedCrossFieldKeys.set({ target: CrossFieldTarget.Source, ...baseDetachId }, countToProcess, true);
+            }
+            // Note that while change2 should already have this key, change1 may have a rollback for the same ID in a different location.
+            // In that case, change1's attach should be canceled out by a detach from change2.
+            // Here we make sure that the composed change has the correct location (this field) for the attach ID.
+            this.table.movedCrossFieldKeys.set({ target: CrossFieldTarget.Destination, ...newAttachId }, countToProcess, this.fieldId);
+        }
+        else {
+            this.table.removedCrossFieldKeys.set({ target: CrossFieldTarget.Source, ...baseDetachId }, countToProcess, true);
+            this.table.removedCrossFieldKeys.set({ target: CrossFieldTarget.Destination, ...newAttachId }, countToProcess, true);
+        }
+        if (countToProcess < count) {
+            this.composeAttachDetach(offsetChangeAtomId(baseDetachId, countToProcess), offsetChangeAtomId(newAttachId, countToProcess), count - countToProcess);
+        }
     }
-    get table() {
-        return this.crossFieldTable;
+    invalidateBaseFields(fields) {
+        if (this.allowInval) {
+            for (const fieldId of fields) {
+                this.table.pendingCompositions.affectedBaseFields.set(fieldIdKeyFromFieldId(fieldId), true);
+            }
+        }
     }
 }
 function makeModularChangeset(props = {
     maxId: -1,
 }) {
     const changeset = {
+        rebaseVersion: props.rebaseVersion ?? 1,
         fieldChanges: props.fieldChanges ?? new Map(),
         nodeChanges: props.nodeChanges ?? newTupleBTree(),
+        rootNodes: props.rootNodes ?? newRootTable(),
         nodeToParent: props.nodeToParent ?? newTupleBTree(),
         nodeAliases: props.nodeAliases ?? newTupleBTree(),
-        crossFieldKeys: props.crossFieldKeys ?? newCrossFieldKeyTable(),
+        crossFieldKeys: props.crossFieldKeys ?? newCrossFieldRangeTable(),
     };
     if (props.revisions !== undefined && props.revisions.length > 0) {
         changeset.revisions = props.revisions;
@@ -1384,6 +1740,9 @@ export class ModularEditBuilder extends EditBuilder {
         this.transactionDepth = 0;
         this.idAllocator = idAllocatorFromMaxId();
     }
+    isInTransaction() {
+        return this.transactionDepth > 0;
+    }
     enterTransaction() {
         this.transactionDepth += 1;
         if (this.transactionDepth === 1) {
@@ -1434,7 +1793,8 @@ export class ModularEditBuilder extends EditBuilder {
             fieldChange: { fieldKind, change },
             nodeChanges: newTupleBTree(),
             nodeToParent: newTupleBTree(),
-            crossFieldKeys: newCrossFieldKeyTable(),
+            crossFieldKeys: newCrossFieldRangeTable(),
+            rootNodes: newRootTable(),
             idAllocator: this.idAllocator,
             localCrossFieldKeys,
             revision,
@@ -1453,6 +1813,7 @@ export class ModularEditBuilder extends EditBuilder {
                 ? makeModularChangeset({
                     maxId: this.idAllocator.getMaxId(),
                     builds: change.builds,
+                    rootNodes: renameTableFromRenameDescriptions(change.renames ?? []),
                     revisions: [{ revision: change.revision }],
                 })
                 : buildModularChangesetFromField({
@@ -1463,7 +1824,8 @@ export class ModularEditBuilder extends EditBuilder {
                     },
                     nodeChanges: newTupleBTree(),
                     nodeToParent: newTupleBTree(),
-                    crossFieldKeys: newCrossFieldKeyTable(),
+                    crossFieldKeys: newCrossFieldRangeTable(),
+                    rootNodes: newRootTable(),
                     idAllocator: this.idAllocator,
                     localCrossFieldKeys: getChangeHandler(this.fieldKinds, change.fieldKind).getCrossFieldKeys(change.change),
                     revision: change.revision,
@@ -1492,7 +1854,8 @@ export class ModularEditBuilder extends EditBuilder {
             nodeChange,
             nodeChanges: newTupleBTree(),
             nodeToParent: newTupleBTree(),
-            crossFieldKeys: newCrossFieldKeyTable(),
+            crossFieldKeys: newCrossFieldRangeTable(),
+            rootNodes: newRootTable(),
             idAllocator: this.idAllocator,
             revision,
         }), revision));
@@ -1506,23 +1869,27 @@ export class ModularEditBuilder extends EditBuilder {
             nodeChange,
             nodeChanges: newTupleBTree(),
             nodeToParent: newTupleBTree(),
-            crossFieldKeys: newCrossFieldKeyTable(),
+            crossFieldKeys: newCrossFieldRangeTable(),
+            rootNodes: newRootTable(),
             idAllocator: this.idAllocator,
             revision,
         }), revision));
     }
 }
-function buildModularChangesetFromField(props) {
-    const { path, fieldChange, nodeChanges, nodeToParent, crossFieldKeys, idAllocator = idAllocatorFromMaxId(), localCrossFieldKeys = [], childId, revision, } = props;
+export function buildModularChangesetFromField(props) {
+    const { path, fieldChange, nodeChanges, nodeToParent, crossFieldKeys, rootNodes, 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, { nodeId: undefined, field: path.field });
+            crossFieldKeys.set(key, count, field);
         }
         if (childId !== undefined) {
             setInChangeAtomIdMap(nodeToParent, childId, {
-                nodeId: undefined,
-                field: path.field,
+                field: {
+                    nodeId: undefined,
+                    field: path.field,
+                },
             });
         }
         return makeModularChangeset({
@@ -1530,6 +1897,7 @@ function buildModularChangesetFromField(props) {
             nodeChanges,
             nodeToParent,
             crossFieldKeys,
+            rootNodes,
             maxId: idAllocator.getMaxId(),
             revisions: [{ revision }],
         });
@@ -1538,13 +1906,13 @@ 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, {
-            nodeId: parentId,
-            field: path.field,
+            field: fieldId,
         });
     }
     return buildModularChangesetFromNode({
@@ -1553,6 +1921,7 @@ function buildModularChangesetFromField(props) {
         nodeChanges,
         nodeToParent,
         crossFieldKeys,
+        rootNodes,
         idAllocator,
         revision,
         nodeId: parentId,
@@ -1561,20 +1930,40 @@ function buildModularChangesetFromField(props) {
 function buildModularChangesetFromNode(props) {
     const { path, nodeId = { localId: brand(props.idAllocator.allocate()), revision: props.revision }, } = props;
     setInChangeAtomIdMap(props.nodeChanges, nodeId, props.nodeChange);
-    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,
-    });
+    if (isDetachedUpPathRoot(path)) {
+        props.rootNodes.nodeChanges.set([path.detachedNodeId.major, brand(path.detachedNodeId.minor)], nodeId);
+        return makeModularChangeset({
+            rootNodes: props.rootNodes,
+            nodeChanges: props.nodeChanges,
+            nodeToParent: props.nodeToParent,
+            crossFieldKeys: props.crossFieldKeys,
+            maxId: props.idAllocator.getMaxId(),
+            revisions: [{ revision: props.revision }],
+        });
+    }
+    else {
+        const fieldChangeset = genericFieldKind.changeHandler.editor.buildChildChanges([
+            [path.parentIndex, nodeId],
+        ]);
+        const fieldChange = {
+            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;
 }
 function getRevInfoFromTaggedChanges(changes) {
     let maxId = -1;
@@ -1584,20 +1973,6 @@ function getRevInfoFromTaggedChanges(changes) {
         maxId = Math.max(change.maxId ?? -1, maxId);
         revInfos.push(...revisionInfoFromTaggedChange(taggedChange));
     }
-    const revisions = new Set();
-    const rolledBackRevisions = [];
-    for (const info of revInfos) {
-        revisions.add(info.revision);
-        if (info.rollbackOf !== undefined) {
-            rolledBackRevisions.push(info.rollbackOf);
-        }
-    }
-    rolledBackRevisions.reverse();
-    for (const revision of rolledBackRevisions) {
-        if (!revisions.has(revision)) {
-            revInfos.push({ revision });
-        }
-    }
     return { maxId: brand(maxId), revInfos };
 }
 function revisionInfoFromTaggedChange(taggedChange) {
@@ -1614,15 +1989,16 @@ function revisionInfoFromTaggedChange(taggedChange) {
     }
     return revInfos;
 }
-function fieldChangeFromId(fields, nodes, id) {
-    const fieldMap = fieldMapFromNodeId(fields, nodes, id.nodeId);
+function fieldChangeFromId(change, id) {
+    const fieldId = normalizeFieldId(id, change.nodeAliases);
+    const fieldMap = fieldMapFromNodeId(change.fieldChanges, change.nodeChanges, change.nodeAliases, fieldId.nodeId);
     return fieldMap.get(id.field) ?? fail(0xb25 /* No field exists for the given ID */);
 }
-function fieldMapFromNodeId(rootFieldMap, nodes, nodeId) {
+function fieldMapFromNodeId(rootFieldMap, nodes, aliases, nodeId) {
     if (nodeId === undefined) {
         return rootFieldMap;
     }
-    const node = nodeChangeFromId(nodes, nodeId);
+    const node = nodeChangeFromId(nodes, aliases, nodeId);
     assert(node.fieldChanges !== undefined, 0x9c9 /* Expected node to have field changes */);
     return node.fieldChanges;
 }
@@ -1635,8 +2011,9 @@ function rebasedFieldIdFromBaseId(table, baseId) {
 function rebasedNodeIdFromBaseNodeId(table, baseId) {
     return getFromChangeAtomIdMap(table.baseToRebasedNodeId, baseId) ?? baseId;
 }
-function nodeChangeFromId(nodes, id) {
-    const node = getFromChangeAtomIdMap(nodes, id);
+function nodeChangeFromId(nodes, aliases, id) {
+    const normalizedId = normalizeNodeId(id, aliases);
+    const node = getFromChangeAtomIdMap(nodes, normalizedId);
     assert(node !== undefined, 0x9ca /* Unknown node ID */);
     return node;
 }
@@ -1644,12 +2021,20 @@ function fieldIdFromFieldIdKey([revision, localId, field]) {
     const nodeId = localId !== undefined ? { revision, localId } : undefined;
     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, oldRevisions, newRevision) {
+    return location.field !== undefined
+        ? { field: replaceFieldIdRevision(location.field, oldRevisions, newRevision) }
+        : { root: replaceAtomRevisions(location.root, oldRevisions, newRevision) };
+}
 function replaceFieldIdRevision(fieldId, oldRevisions, newRevision) {
     if (fieldId.nodeId === undefined) {
         return fieldId;
@@ -1659,16 +2044,33 @@ function replaceFieldIdRevision(fieldId, oldRevisions, newRevision) {
         nodeId: replaceAtomRevisions(fieldId.nodeId, oldRevisions, newRevision),
     };
 }
-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);
+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;
 }
 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
@@ -1678,8 +2080,9 @@ export function normalizeFieldId(fieldId, nodeAliases) {
 /**
  * @returns The canonical form of nodeId, according to nodeAliases
  */
-function normalizeNodeId(nodeId, nodeAliases) {
+export function normalizeNodeId(nodeId, nodeAliases) {
     let currentId = nodeId;
+    let cycleProbeId = nodeId;
     // eslint-disable-next-line no-constant-condition
     while (true) {
         const dealiased = getFromChangeAtomIdMap(nodeAliases, currentId);
@@ -1687,18 +2090,441 @@ 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 getFromChangeAtomIdMap(map, id) {
-    return map.get([id.revision, id.localId]);
-}
-function setInChangeAtomIdMap(map, id, value) {
-    map.set([id.revision, id.localId], value);
-}
 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: CrossFieldTarget.Source }, entry.length);
+    }
+    for (const entry of newDetachLocations.entries()) {
+        rebasedTable.set({ ...entry.start, target: CrossFieldTarget.Source }, entry.length, entry.value);
+    }
+    return rebasedTable;
+}
+export function newRootTable() {
+    return {
+        newToOldId: newChangeAtomIdTransform(),
+        oldToNewId: newChangeAtomIdTransform(),
+        nodeChanges: newTupleBTree(),
+        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: CrossFieldTarget.Destination, ...attachId }, 1);
+        if (baseAttachEntry.value !== undefined) {
+            affectedBaseFields.set(fieldIdKeyFromFieldId(baseAttachEntry.value), true);
+            rebasedNodeToParent.delete(detachIdKey);
+        }
+        else {
+            const renamedDetachId = firstAttachIdFromDetachId(base.rootNodes, detachId, 1).value;
+            const baseOutputDetachLocation = base.rootNodes.outputDetachLocations.getFirst(renamedDetachId, 1).value;
+            if (baseOutputDetachLocation !== undefined) {
+                affectedBaseFields.set(fieldIdKeyFromFieldId(baseOutputDetachLocation), true);
+            }
+            const detachLocation = baseOutputDetachLocation ??
+                change.rootNodes.detachLocations.getFirst(detachId, 1).value;
+            // Note that `baseOutputDetachLocation` may contain a node ID from the base changeset.
+            // We will replace the detach location entry with the node ID from the rebased changeset in `fixupRebasedDetachLocations`
+            assignRootChange(rebasedRoots, rebasedNodeToParent, renamedDetachId, nodeId, detachLocation, rebaseVersion);
+        }
+    }
+    for (const entry of change.rootNodes.outputDetachLocations.entries()) {
+        rebasedRoots.outputDetachLocations.set(entry.start, entry.length, entry.value);
+    }
+    return rebasedRoots;
+}
+function rebaseRename(newRoots, 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: CrossFieldTarget.Destination,
+    }, count);
+    count = baseAttachEntry.length;
+    if (baseAttachEntry.value !== undefined) {
+        // This rename represents an intention to detach these nodes.
+        // The rebased change should have a detach in the field where the base change attaches the nodes,
+        // so we need to ensure that field is processed.
+        affectedBaseFields.set(fieldIdKeyFromFieldId(normalizeFieldId(baseAttachEntry.value, base.nodeAliases)), true);
+    }
+    else {
+        const baseOutputDetachLocation = base.rootNodes.outputDetachLocations.getFirst(baseRenameEntry.value, 1).value;
+        if (baseOutputDetachLocation !== undefined) {
+            affectedBaseFields.set(fieldIdKeyFromFieldId(baseOutputDetachLocation), true);
+        }
+        const detachEntry = newRoots.detachLocations.getFirst(renameEntry.start, count);
+        count = detachEntry.length;
+        const detachLocation = baseOutputDetachLocation ?? detachEntry.value;
+        // Note that `baseOutputDetachLocation` may contain a node ID from the base changeset.
+        // We will replace the detach location entry with the node ID from the rebased changeset in `fixupRebasedDetachLocations`
+        addNodeRename(rebasedRoots, baseRenameEntry.value, renameEntry.value, count, detachLocation);
+    }
+    const countRemaining = renameEntry.length - count;
+    if (countRemaining > 0) {
+        rebaseRename(newRoots, rebasedRoots, {
+            start: offsetChangeAtomId(renameEntry.start, count),
+            value: offsetChangeAtomId(renameEntry.value, count),
+            length: countRemaining,
+        }, base, affectedBaseFields);
+    }
+}
+/**
+ * For each root detach location, replaces any node ID from the base changeset
+ * with the corresponding ID in the new changeset.
+ */
+function fixupRebasedDetachLocations(table) {
+    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) {
+    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) {
+            pendingCompositions.nodeIdsToCompose.push([nodeId1, nodeId2]);
+        }
+        else {
+            const fieldId = getFieldsForCrossFieldKey(change1, { ...detachId1, target: CrossFieldTarget.Source }, 1)[0];
+            if (fieldId !== undefined) {
+                // In this case, this node is attached in the input context of change1,
+                // and is represented in detachFieldId.
+                pendingCompositions.affectedBaseFields.set([fieldId.nodeId?.revision, fieldId.nodeId?.localId, fieldId.field], true);
+            }
+            else {
+                assignRootChange(composedTable, composedNodeToParent, detachId1, nodeId2, change1.rootNodes.detachLocations.getFirst(detachId1, 1).value ??
+                    change2.rootNodes.detachLocations.getFirst(detachId2, 1).value, Math.max(change1.rebaseVersion, change2.rebaseVersion));
+            }
+        }
+    }
+    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` detached these nodes,
+        // so we invalidate the detach location so that the detach's ID can be replaced with the new ID.
+        pendingCompositions.affectedBaseFields.set(fieldIdKeyFromFieldId(detachEntry.value), true);
+        if (!areEqualChangeAtomIds(oldId, newId)) {
+            // `change1`'s detach will be replaced by `change2`'s detach, so we update the cross-field keys.
+            removedCrossFieldKeys.set({ ...oldId, target: CrossFieldTarget.Source }, countToProcess, true);
+        }
+        movedCrossFieldKeys.set({ ...newId, target: CrossFieldTarget.Source }, countToProcess, detachEntry.value);
+    }
+    else {
+        // `change1` may also have a rename to `renameEntry.value`, in which case it must refer to a different node.
+        // That node must have been attached by `change1` and detached by `change2`.
+        // The final rename for that node will be created in `composeAttachDetach`.
+        // We delete any such rename for now to avoid colliding with the rename currently being processed.
+        deleteNodeRenameTo(mergedTable, newId, countToProcess);
+        // The nodes were detached before `change`, so we append this rename.
+        appendNodeRename(mergedTable, oldId, newId, countToProcess, change1.rootNodes, change2.rootNodes.detachLocations.getFirst(oldId, countToProcess).value);
+    }
+    if (countToProcess < count) {
+        composeRename(change1, change2, mergedTable, offsetChangeAtomId(oldId, countToProcess), offsetChangeAtomId(newId, countToProcess), count - countToProcess, movedCrossFieldKeys, removedCrossFieldKeys, pendingCompositions);
+    }
+}
+export function cloneRootTable(table) {
+    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, isRollback) {
+    const invertedRoots = newRootTable();
+    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: CrossFieldTarget.Destination }, 1)
+            .value === undefined) {
+            assignRootChange(invertedRoots, undefined, renamedId, nodeId, change.rootNodes.detachLocations.getFirst(detachId, 1).value, change.rebaseVersion);
+        }
+    }
+    if (isRollback) {
+        // We only invert renames of nodes which are not attached or detached by this changeset.
+        // When we invert an attach we will create a detach which incorporates the rename.
+        for (const { start: oldId, value: newId, length, } of change.rootNodes.oldToNewId.entries()) {
+            invertRename(change, invertedRoots, oldId, newId, length);
+        }
+    }
+    return invertedRoots;
+}
+function invertRename(change, 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 attachEntry = getFirstAttachField(change.crossFieldKeys, newId, countProcessed);
+    countProcessed = attachEntry.length;
+    if (attachEntry.value === undefined) {
+        const outputDetachEntry = change.rootNodes.outputDetachLocations.getFirst(newId, countProcessed);
+        countProcessed = outputDetachEntry.length;
+        const inputDetachEntry = change.rootNodes.detachLocations.getFirst(oldId, countProcessed);
+        countProcessed = inputDetachEntry.length;
+        addNodeRename(invertedRoots, newId, oldId, countProcessed, outputDetachEntry.value ?? inputDetachEntry.value);
+    }
+    if (countProcessed < length) {
+        invertRename(change, invertedRoots, offsetChangeAtomId(oldId, countProcessed), offsetChangeAtomId(newId, countProcessed), length - countProcessed);
+    }
+}
+function doesChangeAttachNodes(table, id, count) {
+    return table
+        .getAll2({ ...id, target: CrossFieldTarget.Destination }, count)
+        .map((entry) => ({ ...entry, value: entry.value !== undefined }));
+}
+function doesChangeDetachNodes(table, id, count) {
+    return table
+        .getAll2({ ...id, target: CrossFieldTarget.Source }, count)
+        .map((entry) => ({ ...entry, value: entry.value !== undefined }));
+}
+export function getFirstDetachField(table, id, count) {
+    return table.getFirst({ target: CrossFieldTarget.Source, ...id }, count);
+}
+export function getFirstAttachField(table, id, count) {
+    return table.getFirst({ target: CrossFieldTarget.Destination, ...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, oldRevisions, newRevision, nodeAliases) {
+    const oldToNewId = table.oldToNewId.mapEntries((id) => replaceAtomRevisions(id, oldRevisions, newRevision), (id) => replaceAtomRevisions(id, oldRevisions, newRevision));
+    const newToOldId = table.newToOldId.mapEntries((id) => replaceAtomRevisions(id, oldRevisions, newRevision), (id) => replaceAtomRevisions(id, oldRevisions, newRevision));
+    const nodeChanges = newTupleBTree([...table.nodeChanges.entries()].map(([[revision, id], nodeId]) => [
+        [oldRevisions.has(revision) ? newRevision : revision, id],
+        replaceAtomRevisions(normalizeNodeId(nodeId, nodeAliases), oldRevisions, newRevision),
+    ]));
+    const detachLocations = table.detachLocations.mapEntries((id) => replaceAtomRevisions(id, oldRevisions, newRevision), (fieldId) => replaceFieldIdRevision(normalizeFieldId(fieldId, nodeAliases), oldRevisions, newRevision));
+    const outputDetachLocations = table.outputDetachLocations.mapEntries((id) => replaceAtomRevisions(id, oldRevisions, newRevision), (fieldId) => replaceFieldIdRevision(normalizeFieldId(fieldId, nodeAliases), oldRevisions, newRevision));
+    return { oldToNewId, newToOldId, nodeChanges, detachLocations, outputDetachLocations };
+}
+function newDetachedEntryMap() {
+    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, detachId: offsetChangeAtomId(entry.detachId, count) }
+        : entry;
+}
+function getFieldsWithRootMoves(roots, nodeAliases) {
+    const fields = newTupleBTree();
+    for (const { start: rootId, value: fieldId, length } of roots.detachLocations.entries()) {
+        let isRootMoved = false;
+        for (const renameEntry of roots.oldToNewId.getAll2(rootId, length)) {
+            if (renameEntry.value !== undefined) {
+                isRootMoved = true;
+            }
+        }
+        for (const outputDetachEntry of roots.outputDetachLocations.getAll2(rootId, length)) {
+            if (outputDetachEntry.value !== undefined) {
+                isRootMoved = true;
+            }
+        }
+        if (isRootMoved) {
+            fields.set(fieldIdKeyFromFieldId(normalizeFieldId(fieldId, nodeAliases)), true);
+        }
+    }
+    return fields;
+}
+function getFieldToRootChanges(roots, nodeAliases) {
+    const fields = newTupleBTree();
+    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(),
+    };
+}
 //# sourceMappingURL=modularChangeFamily.js.map