@fluidframework/tree 2.74.0-365691 → 2.74.0-370705

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

@@ -4,7 +4,7 @@
  * Licensed under the MIT License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizeFieldId = exports.getParentFieldId = exports.ModularEditBuilder = exports.getChangeHandler = exports.getFieldKind = exports.rebaseRevisionMetadataFromInfo = exports.intoDelta = exports.updateRefreshers = exports.relevantRemovedRoots = exports.ModularChangeFamily = void 0;
+exports.addNodeRename = exports.getFirstAttachField = exports.getFirstDetachField = exports.cloneRootTable = exports.newRootTable = exports.normalizeNodeId = exports.normalizeFieldId = exports.getNodeParent = exports.buildModularChangesetFromField = exports.ModularEditBuilder = exports.getChangeHandler = exports.getFieldKind = exports.rebaseRevisionMetadataFromInfo = exports.intoDelta = exports.updateRefreshers = exports.getBuildIds = exports.relevantRemovedRoots = exports.ModularChangeFamily = void 0;
 const internal_1 = require("@fluidframework/core-utils/internal");
 const sorted_btree_es6_1 = require("@tylerbu/sorted-btree-es6");
 const index_js_1 = require("../../core/index.js");
@@ -67,18 +67,19 @@ 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 (0, index_js_2.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,
@@ -86,10 +87,14 @@ 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.
@@ -110,34 +115,50 @@ class ModularChangeFamily {
         const composedNodeChanges = (0, index_js_2.brand)((0, index_js_2.mergeTupleBTrees)(change1.nodeChanges, change2.nodeChanges));
         const composedNodeToParent = (0, index_js_2.brand)((0, index_js_2.mergeTupleBTrees)(change1.nodeToParent, change2.nodeToParent));
         const composedNodeAliases = (0, index_js_2.brand)((0, index_js_2.mergeTupleBTrees)(change1.nodeAliases, change2.nodeAliases));
-        const crossFieldTable = newComposeTable(change1, change2, composedNodeToParent);
+        const pendingCompositions = {
+            nodeIdsToCompose: [],
+            affectedBaseFields: (0, index_js_2.newTupleBTree)(),
+        };
+        const movedCrossFieldKeys = (0, modularChangeTypes_js_1.newCrossFieldRangeTable)();
+        const removedCrossFieldKeys = (0, modularChangeTypes_js_1.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 = index_js_2.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);
         (0, internal_1.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 ?? (0, internal_1.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 = (0, index_js_2.brand)(amendedChange);
     }
     /**
@@ -146,32 +167,23 @@ 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.
@@ -184,38 +196,36 @@ 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((0, modularChangeTypes_js_1.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));
+        (0, modularChangeTypes_js_1.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();
@@ -225,6 +235,14 @@ 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;
@@ -244,17 +262,16 @@ 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 ?? (0, internal_1.fail)(0xb23 /* Should not compose two undefined nodes */);
         }, idAllocator, manager, revisionMetadata);
@@ -271,19 +288,18 @@ 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);
+        (0, modularChangeTypes_js_1.setInChangeAtomIdMap)(composedNodes, id1, composedNodeChangeset);
         if (!(0, index_js_1.areEqualChangeAtomIds)(id1, id2)) {
             composedNodes.delete([id2.revision, id2.localId]);
             composedNodeToParent.delete([id2.revision, id2.localId]);
-            setInChangeAtomIdMap(nodeAliases, id2, id1);
+            (0, modularChangeTypes_js_1.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:
@@ -334,9 +350,14 @@ class ModularChangeFamily {
         }
         const genId = (0, index_js_2.idAllocatorFromMaxId)(change.change.maxId ?? -1);
         const crossFieldTable = {
-            ...newCrossFieldTable(),
+            change: change.change,
+            entries: (0, index_js_1.newChangeAtomIdRangeMap)(),
             originalFieldToContext: new Map(),
+            invertRevision: revisionForInvert,
             invertedNodeToParent: (0, index_js_2.brand)(change.change.nodeToParent.clone()),
+            invalidatedFields: new Set(),
+            invertedRoots: invertRootTable(change.change, isRollback),
+            attachToDetachId: (0, index_js_1.newChangeAtomIdTransform)(),
         };
         const { revInfos: oldRevInfos } = getRevInfoFromTaggedChanges([change]);
         const revisionMetadata = (0, index_js_1.revisionMetadataSourceFromInfo)(oldRevInfos);
@@ -352,16 +373,18 @@ class ModularChangeFamily {
                 const originalFieldChange = fieldChange.change;
                 const context = crossFieldTable.originalFieldToContext.get(fieldChange);
                 (0, internal_1.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 = (0, index_js_2.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(),
@@ -375,7 +398,7 @@ 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,
@@ -407,6 +430,12 @@ 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.
@@ -417,17 +446,26 @@ class ModularChangeFamily {
         const maxId = Math.max(change.maxId ?? -1, over.change.maxId ?? -1);
         const idState = { maxId };
         const genId = (0, index_js_2.idAllocatorFromState)(idState);
+        const affectedBaseFields = (0, index_js_2.newTupleBTree)();
+        const nodesToRebase = [];
+        const rebasedNodeToParent = (0, index_js_2.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: (0, index_js_2.newTupleBTree)(),
             rebasedFields: new Set(),
-            rebasedNodeToParent: (0, index_js_2.brand)(change.nodeToParent.clone()),
-            rebasedCrossFieldKeys: change.crossFieldKeys.clone(),
+            rebasedNodeToParent,
+            rebasedDetachLocations: (0, index_js_1.newChangeAtomIdRangeMap)(),
+            movedDetaches: (0, index_js_1.newChangeAtomIdRangeMap)(),
             nodeIdPairs: [],
-            affectedBaseFields: (0, index_js_2.newTupleBTree)(),
+            affectedBaseFields,
             fieldsWithUnattachedChild: new Set(),
         };
         const getBaseRevisions = () => revisionInfoFromTaggedChange(over).map((info) => info.revision);
@@ -437,17 +475,22 @@ class ModularChangeFamily {
             getBaseRevisions,
         };
         const rebasedNodes = (0, index_js_2.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, fieldChangeHandler_js_1.NodeAttachState.Attached, fieldChangeHandler_js_1.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,
@@ -455,158 +498,177 @@ 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);
+            (0, modularChangeTypes_js_1.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) {
             const rebasedNode = this.rebaseNodeChange(newId, baseId, genId, crossFieldTable, metadata);
-            setInChangeAtomIdMap(rebasedNodes, newId, rebasedNode);
+            (0, modularChangeTypes_js_1.setInChangeAtomIdMap)(rebasedNodes, newId, rebasedNode);
         }
         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);
-            (0, internal_1.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) => {
-                (0, internal_1.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) => {
+            (0, internal_1.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: (0, index_js_2.brand)(handler.createEmpty()),
-            };
-            const rebasedNodeId = baseNodeId !== undefined
-                ? rebasedNodeIdFromBaseNodeId(crossFieldTable, baseNodeId)
+            }
+            return (0, index_js_1.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: (0, index_js_2.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: (0, index_js_2.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: (0, index_js_2.brand)(rebasedField),
+        };
+        const context = {
+            newChange: fieldChange,
+            baseChange: baseFieldChange,
+            rebasedChange: rebasedFieldChange,
+            fieldId,
+            baseNodeIds: (0, index_js_2.newTupleBTree)(),
+        };
+        if (baseNodeId !== undefined) {
+            (0, modularChangeTypes_js_1.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);
+                (0, internal_1.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);
-        (0, internal_1.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 ((0, index_js_1.areEqualChangeAtomIds)(base, id)) {
-                        return base;
-                    }
-                }
+            if (base !== undefined && (0, modularChangeTypes_js_1.getFromChangeAtomIdMap)(context.baseNodeIds, base) === true) {
+                return base;
             }
             return undefined;
         };
-        context.rebasedChange.change = (0, index_js_2.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 = (0, index_js_2.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) {
             rebasedFields.set(fieldKey, rebasedField);
             return;
         }
-        const rebasedNode = getFromChangeAtomIdMap(rebasedNodes, nodeId);
+        const rebasedNode = (0, modularChangeTypes_js_1.getFromChangeAtomIdMap)(rebasedNodes, nodeId);
         if (rebasedNode !== undefined) {
-            if (rebasedNode.fieldChanges === undefined) {
-                rebasedNode.fieldChanges = new Map([[fieldKey, rebasedField]]);
+            const updatedRebasedNode = cloneNodeChangeset(rebasedNode);
+            (0, modularChangeTypes_js_1.setInChangeAtomIdMap)(rebasedNodes, nodeId, updatedRebasedNode);
+            if (updatedRebasedNode.fieldChanges === undefined) {
+                updatedRebasedNode.fieldChanges = new Map([[fieldKey, rebasedField]]);
                 return;
             }
-            (0, internal_1.assert)(!rebasedNode.fieldChanges.has(fieldKey), 0x9c4 /* Expected an empty field */);
-            rebasedNode.fieldChanges.set(fieldKey, rebasedField);
+            (0, internal_1.assert)(!updatedRebasedNode.fieldChanges.has(fieldKey), 0x9c4 /* Expected an empty field */);
+            updatedRebasedNode.fieldChanges.set(fieldKey, rebasedField);
             return;
         }
         const newNode = {
             fieldChanges: new Map([[fieldKey, rebasedField]]),
         };
-        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);
+        (0, modularChangeTypes_js_1.setInChangeAtomIdMap)(rebasedNodes, nodeId, newNode);
+        (0, modularChangeTypes_js_1.setInChangeAtomIdMap)(table.baseToRebasedNodeId, nodeId, nodeId);
+        const parentBase = getNodeParent(table.baseChange, nodeId);
+        this.attachRebasedNode(rebasedFields, rebasedNodes, table, nodeId, parentBase, idAllocator, metadata);
+    }
+    attachRebasedNode(rebasedFields, rebasedNodes, table, baseNodeId, parentBase, idAllocator, metadata) {
+        if (parentBase.root !== undefined) {
+            const renamedRoot = firstAttachIdFromDetachId(table.baseChange.rootNodes, parentBase.root, 1).value;
+            const attachField = table.baseChange.crossFieldKeys.getFirst({ ...renamedRoot, target: crossFieldQueries_js_1.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);
+        (0, modularChangeTypes_js_1.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 ((0, modularChangeTypes_js_1.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: (0, index_js_2.brand)(handler.createEmpty()),
-        };
-        const rebasedChangeset = handler.rebaser.rebase(handler.createEmpty(), baseFieldChange.change, (_idNew, idBase) => idBase !== undefined && (0, index_js_1.areEqualChangeAtomIds)(idBase, baseNodeId)
-            ? baseNodeId
-            : undefined, idAllocator, new RebaseManager(table, baseFieldChange, rebasedFieldId), metadata);
-        const rebasedField = { ...baseFieldChange, change: (0, index_js_2.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();
@@ -624,8 +686,8 @@ 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: (0, index_js_2.brand)(rebasedField),
@@ -636,15 +698,15 @@ class ModularChangeFamily {
                 newChange: fieldChange,
                 rebasedChange: rebasedFieldChange,
                 fieldId,
-                baseNodeIds: [],
+                baseNodeIds: (0, index_js_2.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,31 +721,40 @@ class ModularChangeFamily {
         if (change?.nodeExistsConstraintOnRevert !== undefined) {
             rebasedChange.nodeExistsConstraintOnRevert = change.nodeExistsConstraintOnRevert;
         }
-        setInChangeAtomIdMap(crossFieldTable.baseToRebasedNodeId, baseId, newId);
+        (0, modularChangeTypes_js_1.setInChangeAtomIdMap)(crossFieldTable.baseToRebasedNodeId, baseId, newId);
         return rebasedChange;
     }
+    updateConstraints(rebasedFields, rebasedNodes, rebasedRoots, constraintState, revertConstraintState) {
+        this.updateConstraintsForFields(rebasedFields, fieldChangeHandler_js_1.NodeAttachState.Attached, fieldChangeHandler_js_1.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, fieldChangeHandler_js_1.NodeAttachState.Detached, detachedInOutput ? fieldChangeHandler_js_1.NodeAttachState.Detached : fieldChangeHandler_js_1.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 === fieldChangeHandler_js_1.NodeAttachState.Detached || isInputDetached
-                    ? fieldChangeHandler_js_1.NodeAttachState.Detached
-                    : fieldChangeHandler_js_1.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 === fieldChangeHandler_js_1.NodeAttachState.Detached || isOutputDetached
                     ? fieldChangeHandler_js_1.NodeAttachState.Detached
                     : fieldChangeHandler_js_1.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]) ?? (0, internal_1.fail)(0xb24 /* Unknown node ID */);
+        const node = (0, modularChangeTypes_js_1.getFromChangeAtomIdMap)(nodes, nodeId) ?? (0, internal_1.fail)(0xb24 /* Unknown node ID */);
+        const updatedNode = { ...node };
+        (0, modularChangeTypes_js_1.setInChangeAtomIdMap)(nodes, nodeId, updatedNode);
         if (node.nodeExistsConstraint !== undefined) {
             const isNowViolated = inputAttachState === fieldChangeHandler_js_1.NodeAttachState.Detached;
             if (node.nodeExistsConstraint.violated !== isNowViolated) {
-                node.nodeExistsConstraint = {
+                updatedNode.nodeExistsConstraint = {
                     ...node.nodeExistsConstraint,
                     violated: isNowViolated,
                 };
@@ -693,7 +764,7 @@ class ModularChangeFamily {
         if (node.nodeExistsConstraintOnRevert !== undefined) {
             const isNowViolated = outputAttachState === fieldChangeHandler_js_1.NodeAttachState.Detached;
             if (node.nodeExistsConstraintOnRevert.violated !== isNowViolated) {
-                node.nodeExistsConstraintOnRevert = {
+                updatedNode.nodeExistsConstraintOnRevert = {
                     ...node.nodeExistsConstraintOnRevert,
                     violated: isNowViolated,
                 };
@@ -704,35 +775,70 @@ 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 = (0, modularChangeTypes_js_1.getFromChangeAtomIdMap)(roots.nodeChanges, rootId) ?? (0, internal_1.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: (0, index_js_2.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: (0, index_js_2.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);
+            (0, modularChangeTypes_js_1.setInChangeAtomIdMap)(nodes, nodeId, prunedChange);
             return nodeId;
         }
     }
@@ -746,17 +852,18 @@ class ModularChangeFamily {
             updatedNodes.set([replaceRevision(revision, oldRevisions, newRevision), id], this.replaceNodeChangesetRevisions(nodeChangeset, oldRevisions, newRevision));
         }
         const updatedNodeToParent = (0, index_js_2.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: (0, index_js_2.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);
@@ -795,7 +902,7 @@ class ModularChangeFamily {
         return updatedFields;
     }
     makeCrossFieldKeyTable(fields, nodes) {
-        const keys = (0, modularChangeTypes_js_1.newCrossFieldKeyTable)();
+        const keys = (0, modularChangeTypes_js_1.newCrossFieldRangeTable)();
         this.populateCrossFieldKeyTableForFieldMap(keys, fields, undefined);
         nodes.forEachPair(([revision, localId], node) => {
             if (node.fieldChanges !== undefined) {
@@ -823,40 +930,53 @@ class ModularChangeFamily {
         return { fieldKind, change: (0, index_js_2.brand)(emptyChange) };
     }
     validateChangeset(change) {
-        let numNodes = this.validateFieldChanges(change, change.fieldChanges, undefined);
+        const unreachableNodes = (0, index_js_2.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);
+            (0, internal_1.assert)((0, index_js_1.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);
+            }
         }
-        (0, internal_1.assert)(numNodes === change.nodeChanges.size, 0xa4d /* Node table contains unparented nodes */);
+        (0, internal_1.assert)(unreachableNodes.size === 0, "Unreachable nodes found");
+        (0, internal_1.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);
-                (0, internal_1.assert)(areEqualFieldIds(parentFieldId, fieldId), 0xa4e /* Inconsistent node parentage */);
-                numChildren += 1;
+                const parentFieldId = getNodeParent(change, child);
+                (0, internal_1.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);
-                (0, internal_1.assert)(fields.length === 1 &&
-                    fields[0] !== undefined &&
-                    areEqualFieldIds(fields[0], fieldId), 0xa4f /* Inconsistent cross field keys */);
+                (0, internal_1.assert)(fields.length > 0, "Unregistered cross-field key");
+                for (const fieldFromLookup of fields) {
+                    (0, internal_1.assert)(areEqualFieldIds(fieldFromLookup, fieldId), 0xa4f /* Inconsistent cross field keys */);
+                }
+                unreachableCFKs.delete(keyRange.key, keyRange.count);
             }
         }
-        return numChildren;
     }
     getEffectiveChange(change) {
         if (hasConflicts(change)) {
@@ -870,7 +990,8 @@ class ModularChangeFamily {
     muteChange(change) {
         const muted = {
             ...change,
-            crossFieldKeys: (0, modularChangeTypes_js_1.newCrossFieldKeyTable)(),
+            rootNodes: muteRootChanges(change.rootNodes),
+            crossFieldKeys: (0, modularChangeTypes_js_1.newCrossFieldRangeTable)(),
             fieldChanges: this.muteFieldChanges(change.fieldChanges),
             nodeChanges: (0, index_js_2.brand)(change.nodeChanges.mapValues((v) => this.muteNodeChange(v))),
         };
@@ -898,27 +1019,12 @@ class ModularChangeFamily {
 }
 exports.ModularChangeFamily = ModularChangeFamily;
 ModularChangeFamily.emptyChange = makeModularChangeset();
-function replaceCrossFieldKeyTableRevisions(table, oldRevisions, newRevision, nodeAliases) {
-    const updated = (0, modularChangeTypes_js_1.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
-            ? (0, index_js_1.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;
@@ -964,6 +1070,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()) {
+            (0, internal_1.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) {
@@ -988,19 +1107,53 @@ function invertBuilds(builds) {
  * @param fieldKinds - The field kinds to delegate to.
  */
 function* relevantRemovedRoots(change, fieldKinds) {
-    yield* relevantRemovedRootsFromFields(change.fieldChanges, change.nodeChanges, fieldKinds);
+    const rootIds = (0, index_js_1.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 = (0, index_js_1.offsetChangeAtomId)(entry.start, offset);
+            yield (0, index_js_1.makeDetachedNodeId)(detachId.revision, detachId.localId);
+        }
+    }
 }
 exports.relevantRemovedRoots = relevantRemovedRoots;
-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);
+function* getBuildIds(change) {
+    if (change.builds !== undefined) {
+        for (const [[revision, localId]] of change.builds.entries()) {
+            yield (0, index_js_1.makeDetachedNodeId)(revision, localId);
+        }
+    }
+}
+exports.getBuildIds = getBuildIds;
+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 !== crossFieldQueries_js_1.CrossFieldTarget.Destination) {
+            continue;
+        }
+        for (const detachIdEntry of change.rootNodes.newToOldId.getAll2(entry.start, entry.length)) {
+            const detachId = detachIdEntry.value ?? (0, index_js_1.offsetChangeAtomId)(entry.start, detachIdEntry.offset);
+            for (const detachEntry of change.crossFieldKeys.getAll2({ ...detachId, target: crossFieldQueries_js_1.CrossFieldTarget.Source }, detachIdEntry.length)) {
+                if (detachEntry.value === undefined) {
+                    rootIds.set((0, index_js_1.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: crossFieldQueries_js_1.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);
+            }
+        }
     }
 }
 /**
@@ -1052,6 +1205,7 @@ function updateRefreshers(change, getDetachedNode, removedRoots, requireRefreshe
         nodeChanges,
         nodeToParent: change.nodeToParent,
         nodeAliases: change.nodeAliases,
+        rootNodes: change.rootNodes,
         crossFieldKeys: change.crossFieldKeys,
         maxId: maxId,
         revisions,
@@ -1072,11 +1226,24 @@ exports.updateRefreshers = updateRefreshers;
 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: (0, index_js_1.makeDetachedNodeId)(oldId.revision, oldId.localId),
+                newId: (0, index_js_1.makeDetachedNodeId)(newId.revision, newId.localId),
+            });
+        }
         if (fieldDeltas.size > 0) {
             rootDelta.fields = fieldDeltas;
         }
@@ -1123,24 +1290,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();
@@ -1190,30 +1355,22 @@ function getChangeHandler(fieldKinds, kind) {
     return getFieldKind(fieldKinds, kind).changeHandler;
 }
 exports.getChangeHandler = getChangeHandler;
-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: (0, index_js_2.newTupleBTree)(),
         composedNodes: new Set(),
-        composedNodeToParent,
-        pendingCompositions: {
-            nodeIdsToCompose: [],
-            affectedBaseFields: (0, index_js_2.newTupleBTree)(),
-            affectedNewFields: (0, index_js_2.newTupleBTree)(),
-        },
-    };
-}
-function newCrossFieldTable() {
-    return {
-        srcTable: (0, index_js_1.newChangeAtomIdRangeMap)(),
-        dstTable: (0, index_js_1.newChangeAtomIdRangeMap)(),
-        srcDependents: (0, index_js_1.newChangeAtomIdRangeMap)(),
-        dstDependents: (0, index_js_1.newChangeAtomIdRangeMap)(),
-        invalidatedFields: new Set(),
+        movedNodeToParent: (0, index_js_2.newTupleBTree)(),
+        composedRootNodes,
+        movedCrossFieldKeys,
+        removedCrossFieldKeys,
+        renamesToDelete: (0, index_js_1.newChangeAtomIdRangeMap)(),
+        pendingCompositions,
     };
 }
 function newConstraintState(violationCount) {
@@ -1221,147 +1378,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 = (0, crossFieldQueries_js_1.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) {
+            (0, internal_1.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: crossFieldQueries_js_1.CrossFieldTarget.Destination, ...attachEntry.value }, count);
+            if (attachFieldEntry.value !== undefined) {
+                (0, crossFieldQueries_js_1.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 (!(0, index_js_1.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 = (0, index_js_2.brand)(firstId + dependentEntry.length);
             }
         }
-        (0, crossFieldQueries_js_1.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.
-            (0, crossFieldQueries_js_1.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: crossFieldQueries_js_1.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 (0, crossFieldQueries_js_1.getFirstFromCrossFieldMap)(this.getMap(target), revision, id, count);
-    }
-    getMap(target) {
-        return target === crossFieldQueries_js_1.CrossFieldTarget.Source
-            ? this.crossFieldTable.srcTable
-            : this.crossFieldTable.dstTable;
-    }
-    getDependents(target) {
-        return target === crossFieldQueries_js_1.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) {
-        (0, internal_1.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 = (0, modularChangeTypes_js_1.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) {
+            (0, modularChangeTypes_js_1.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);
-            (0, internal_1.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);
-            (0, internal_1.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 = (0, modularChangeTypes_js_1.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) {
+            (0, modularChangeTypes_js_1.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: crossFieldQueries_js_1.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.
+            (0, crossFieldQueries_js_1.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
+                ? (0, index_js_1.offsetChangeAtomId)(newDetachId, countToProcess)
+                : undefined;
+            this.rebaseOverDetach((0, index_js_1.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) {
+    (0, internal_1.assert)(rebaseVersion >= 2 || detachLocation !== undefined, "All root changes need a detach location to support compatibility with older client versions");
+    (0, modularChangeTypes_js_1.setInChangeAtomIdMap)(table.nodeChanges, detachId, nodeId);
+    if (nodeToParent !== undefined) {
+        (0, modularChangeTypes_js_1.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: crossFieldQueries_js_1.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 = (0, modularChangeTypes_js_1.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) {
+            (0, modularChangeTypes_js_1.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 = (0, index_js_1.areEqualChangeAtomIds)(baseAttachId, newDetachId) && newAttachEntry.value !== undefined;
+        if (!hasNewAttachWithBaseAttachId) {
+            this.table.removedCrossFieldKeys.set({ ...baseAttachId, target: crossFieldQueries_js_1.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 (!(0, index_js_1.areEqualChangeAtomIds)(baseAttachId, newDetachId)) {
+                this.table.removedCrossFieldKeys.set({ ...baseAttachId, target: crossFieldQueries_js_1.CrossFieldTarget.Source }, countToProcess, true);
+            }
+            this.table.movedCrossFieldKeys.set({ ...newDetachId, target: crossFieldQueries_js_1.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: crossFieldQueries_js_1.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((0, index_js_1.offsetChangeAtomId)(baseAttachId, countToProcess), (0, index_js_1.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: crossFieldQueries_js_1.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 = (0, modularChangeTypes_js_1.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);
-                (0, internal_1.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 = (0, index_js_1.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: crossFieldQueries_js_1.CrossFieldTarget.Source, ...newAttachId }, countToProcess, this.fieldId);
+            if (!(0, index_js_1.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: crossFieldQueries_js_1.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: crossFieldQueries_js_1.CrossFieldTarget.Destination, ...newAttachId }, countToProcess, this.fieldId);
+        }
+        else {
+            this.table.removedCrossFieldKeys.set({ target: crossFieldQueries_js_1.CrossFieldTarget.Source, ...baseDetachId }, countToProcess, true);
+            this.table.removedCrossFieldKeys.set({ target: crossFieldQueries_js_1.CrossFieldTarget.Destination, ...newAttachId }, countToProcess, true);
+        }
+        if (countToProcess < count) {
+            this.composeAttachDetach((0, index_js_1.offsetChangeAtomId)(baseDetachId, countToProcess), (0, index_js_1.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 ?? (0, index_js_2.newTupleBTree)(),
+        rootNodes: props.rootNodes ?? newRootTable(),
         nodeToParent: props.nodeToParent ?? (0, index_js_2.newTupleBTree)(),
         nodeAliases: props.nodeAliases ?? (0, index_js_2.newTupleBTree)(),
-        crossFieldKeys: props.crossFieldKeys ?? (0, modularChangeTypes_js_1.newCrossFieldKeyTable)(),
+        crossFieldKeys: props.crossFieldKeys ?? (0, modularChangeTypes_js_1.newCrossFieldRangeTable)(),
     };
     if (props.revisions !== undefined && props.revisions.length > 0) {
         changeset.revisions = props.revisions;
@@ -1394,6 +1758,9 @@ class ModularEditBuilder extends index_js_1.EditBuilder {
         this.transactionDepth = 0;
         this.idAllocator = (0, index_js_2.idAllocatorFromMaxId)();
     }
+    isInTransaction() {
+        return this.transactionDepth > 0;
+    }
     enterTransaction() {
         this.transactionDepth += 1;
         if (this.transactionDepth === 1) {
@@ -1444,7 +1811,8 @@ class ModularEditBuilder extends index_js_1.EditBuilder {
             fieldChange: { fieldKind, change },
             nodeChanges: (0, index_js_2.newTupleBTree)(),
             nodeToParent: (0, index_js_2.newTupleBTree)(),
-            crossFieldKeys: (0, modularChangeTypes_js_1.newCrossFieldKeyTable)(),
+            crossFieldKeys: (0, modularChangeTypes_js_1.newCrossFieldRangeTable)(),
+            rootNodes: newRootTable(),
             idAllocator: this.idAllocator,
             localCrossFieldKeys,
             revision,
@@ -1463,6 +1831,7 @@ class ModularEditBuilder extends index_js_1.EditBuilder {
                 ? makeModularChangeset({
                     maxId: this.idAllocator.getMaxId(),
                     builds: change.builds,
+                    rootNodes: renameTableFromRenameDescriptions(change.renames ?? []),
                     revisions: [{ revision: change.revision }],
                 })
                 : buildModularChangesetFromField({
@@ -1473,7 +1842,8 @@ class ModularEditBuilder extends index_js_1.EditBuilder {
                     },
                     nodeChanges: (0, index_js_2.newTupleBTree)(),
                     nodeToParent: (0, index_js_2.newTupleBTree)(),
-                    crossFieldKeys: (0, modularChangeTypes_js_1.newCrossFieldKeyTable)(),
+                    crossFieldKeys: (0, modularChangeTypes_js_1.newCrossFieldRangeTable)(),
+                    rootNodes: newRootTable(),
                     idAllocator: this.idAllocator,
                     localCrossFieldKeys: getChangeHandler(this.fieldKinds, change.fieldKind).getCrossFieldKeys(change.change),
                     revision: change.revision,
@@ -1502,7 +1872,8 @@ class ModularEditBuilder extends index_js_1.EditBuilder {
             nodeChange,
             nodeChanges: (0, index_js_2.newTupleBTree)(),
             nodeToParent: (0, index_js_2.newTupleBTree)(),
-            crossFieldKeys: (0, modularChangeTypes_js_1.newCrossFieldKeyTable)(),
+            crossFieldKeys: (0, modularChangeTypes_js_1.newCrossFieldRangeTable)(),
+            rootNodes: newRootTable(),
             idAllocator: this.idAllocator,
             revision,
         }), revision));
@@ -1516,7 +1887,8 @@ class ModularEditBuilder extends index_js_1.EditBuilder {
             nodeChange,
             nodeChanges: (0, index_js_2.newTupleBTree)(),
             nodeToParent: (0, index_js_2.newTupleBTree)(),
-            crossFieldKeys: (0, modularChangeTypes_js_1.newCrossFieldKeyTable)(),
+            crossFieldKeys: (0, modularChangeTypes_js_1.newCrossFieldRangeTable)(),
+            rootNodes: newRootTable(),
             idAllocator: this.idAllocator,
             revision,
         }), revision));
@@ -1524,16 +1896,19 @@ class ModularEditBuilder extends index_js_1.EditBuilder {
 }
 exports.ModularEditBuilder = ModularEditBuilder;
 function buildModularChangesetFromField(props) {
-    const { path, fieldChange, nodeChanges, nodeToParent, crossFieldKeys, idAllocator = (0, index_js_2.idAllocatorFromMaxId)(), localCrossFieldKeys = [], childId, revision, } = props;
+    const { path, fieldChange, nodeChanges, nodeToParent, crossFieldKeys, rootNodes, idAllocator = (0, index_js_2.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,
+            (0, modularChangeTypes_js_1.setInChangeAtomIdMap)(nodeToParent, childId, {
+                field: {
+                    nodeId: undefined,
+                    field: path.field,
+                },
             });
         }
         return makeModularChangeset({
@@ -1541,6 +1916,7 @@ function buildModularChangesetFromField(props) {
             nodeChanges,
             nodeToParent,
             crossFieldKeys,
+            rootNodes,
             maxId: idAllocator.getMaxId(),
             revisions: [{ revision }],
         });
@@ -1549,13 +1925,13 @@ function buildModularChangesetFromField(props) {
         fieldChanges,
     };
     const parentId = { localId: (0, index_js_2.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,
+        (0, modularChangeTypes_js_1.setInChangeAtomIdMap)(nodeToParent, childId, {
+            field: fieldId,
         });
     }
     return buildModularChangesetFromNode({
@@ -1564,28 +1940,50 @@ function buildModularChangesetFromField(props) {
         nodeChanges,
         nodeToParent,
         crossFieldKeys,
+        rootNodes,
         idAllocator,
         revision,
         nodeId: parentId,
     });
 }
+exports.buildModularChangesetFromField = buildModularChangesetFromField;
 function buildModularChangesetFromNode(props) {
     const { path, nodeId = { localId: (0, index_js_2.brand)(props.idAllocator.allocate()), revision: props.revision }, } = props;
-    setInChangeAtomIdMap(props.nodeChanges, nodeId, props.nodeChange);
-    const fieldChangeset = genericFieldKind_js_1.genericFieldKind.changeHandler.editor.buildChildChanges([
-        [path.parentIndex, nodeId],
-    ]);
-    const fieldChange = {
-        fieldKind: genericFieldKind_js_1.genericFieldKind.identifier,
-        change: fieldChangeset,
-    };
-    return buildModularChangesetFromField({
-        ...props,
-        path: { parent: path.parent, field: path.parentField },
-        fieldChange,
-        localCrossFieldKeys: [],
-        childId: nodeId,
-    });
+    (0, modularChangeTypes_js_1.setInChangeAtomIdMap)(props.nodeChanges, nodeId, props.nodeChange);
+    if ((0, index_js_1.isDetachedUpPathRoot)(path)) {
+        props.rootNodes.nodeChanges.set([path.detachedNodeId.major, (0, index_js_2.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_js_1.genericFieldKind.changeHandler.editor.buildChildChanges([
+            [path.parentIndex, nodeId],
+        ]);
+        const fieldChange = {
+            fieldKind: genericFieldKind_js_1.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;
@@ -1595,20 +1993,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: (0, index_js_2.brand)(maxId), revInfos };
 }
 function revisionInfoFromTaggedChange(taggedChange) {
@@ -1625,15 +2009,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) ?? (0, internal_1.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);
     (0, internal_1.assert)(node.fieldChanges !== undefined, 0x9c9 /* Expected node to have field changes */);
     return node.fieldChanges;
 }
@@ -1644,10 +2029,11 @@ function rebasedFieldIdFromBaseId(table, baseId) {
     return { ...baseId, nodeId: rebasedNodeIdFromBaseNodeId(table, baseId.nodeId) };
 }
 function rebasedNodeIdFromBaseNodeId(table, baseId) {
-    return getFromChangeAtomIdMap(table.baseToRebasedNodeId, baseId) ?? baseId;
+    return (0, modularChangeTypes_js_1.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 = (0, modularChangeTypes_js_1.getFromChangeAtomIdMap)(nodes, normalizedId);
     (0, internal_1.assert)(node !== undefined, 0x9ca /* Unknown node ID */);
     return node;
 }
@@ -1655,12 +2041,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: (0, index_js_1.replaceAtomRevisions)(location.root, oldRevisions, newRevision) };
+}
 function replaceFieldIdRevision(fieldId, oldRevisions, newRevision) {
     if (fieldId.nodeId === undefined) {
         return fieldId;
@@ -1670,17 +2064,34 @@ function replaceFieldIdRevision(fieldId, oldRevisions, newRevision) {
         nodeId: (0, index_js_1.replaceAtomRevisions)(fieldId.nodeId, oldRevisions, newRevision),
     };
 }
-function getParentFieldId(changeset, nodeId) {
-    const parentId = getFromChangeAtomIdMap(changeset.nodeToParent, nodeId);
-    (0, internal_1.assert)(parentId !== undefined, 0x9cb /* Parent field should be defined */);
-    return normalizeFieldId(parentId, changeset.nodeAliases);
+function getNodeParent(changeset, nodeId) {
+    const normalizedNodeId = normalizeNodeId(nodeId, changeset.nodeAliases);
+    const location = (0, modularChangeTypes_js_1.getFromChangeAtomIdMap)(changeset.nodeToParent, normalizedNodeId);
+    (0, internal_1.assert)(location !== undefined, 0x9cb /* Parent field should be defined */);
+    if (location.field !== undefined) {
+        return { field: normalizeFieldId(location.field, changeset.nodeAliases) };
+    }
+    return location;
 }
-exports.getParentFieldId = getParentFieldId;
+exports.getNodeParent = getNodeParent;
 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.
 function normalizeFieldId(fieldId, nodeAliases) {
     return fieldId.nodeId !== undefined
@@ -1693,25 +2104,455 @@ exports.normalizeFieldId = normalizeFieldId;
  */
 function normalizeNodeId(nodeId, nodeAliases) {
     let currentId = nodeId;
+    let cycleProbeId = nodeId;
     // eslint-disable-next-line no-constant-condition
     while (true) {
-        const dealiased = getFromChangeAtomIdMap(nodeAliases, currentId);
+        const dealiased = (0, modularChangeTypes_js_1.getFromChangeAtomIdMap)(nodeAliases, currentId);
         if (dealiased === undefined) {
             return currentId;
         }
         currentId = dealiased;
+        if (cycleProbeId !== undefined) {
+            cycleProbeId = (0, modularChangeTypes_js_1.getFromChangeAtomIdMap)(nodeAliases, cycleProbeId);
+        }
+        if (cycleProbeId !== undefined) {
+            cycleProbeId = (0, modularChangeTypes_js_1.getFromChangeAtomIdMap)(nodeAliases, cycleProbeId);
+        }
+        (0, internal_1.assert)(!(0, index_js_1.areEqualChangeAtomIdOpts)(cycleProbeId, currentId), "Alias cycle detected");
     }
 }
+exports.normalizeNodeId = normalizeNodeId;
 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 (0, index_js_1.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: crossFieldQueries_js_1.CrossFieldTarget.Source }, entry.length);
+    }
+    for (const entry of newDetachLocations.entries()) {
+        rebasedTable.set({ ...entry.start, target: crossFieldQueries_js_1.CrossFieldTarget.Source }, entry.length, entry.value);
+    }
+    return rebasedTable;
+}
+function newRootTable() {
+    return {
+        newToOldId: (0, index_js_1.newChangeAtomIdTransform)(),
+        oldToNewId: (0, index_js_1.newChangeAtomIdTransform)(),
+        nodeChanges: (0, index_js_2.newTupleBTree)(),
+        detachLocations: (0, index_js_1.newChangeAtomIdRangeMap)(),
+        outputDetachLocations: (0, index_js_1.newChangeAtomIdRangeMap)(),
+    };
+}
+exports.newRootTable = newRootTable;
+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 = (0, index_js_1.makeChangeAtomId)(detachIdKey[1], detachIdKey[0]);
+        const attachId = firstAttachIdFromDetachId(base.rootNodes, detachId, 1).value;
+        const baseAttachEntry = base.crossFieldKeys.getFirst({ target: crossFieldQueries_js_1.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: crossFieldQueries_js_1.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: (0, index_js_1.offsetChangeAtomId)(renameEntry.start, count),
+            value: (0, index_js_1.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 = (0, modularChangeTypes_js_1.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 ((0, modularChangeTypes_js_1.getFromChangeAtomIdMap)(table.newToBaseNodeId, normalizedId2) === undefined) {
+        (0, modularChangeTypes_js_1.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 = index_js_2.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 = (0, modularChangeTypes_js_1.getFromChangeAtomIdMap)(change1.rootNodes.nodeChanges, detachId1);
+        if (nodeId1 !== undefined) {
+            pendingCompositions.nodeIdsToCompose.push([nodeId1, nodeId2]);
+        }
+        else {
+            const fieldId = getFieldsForCrossFieldKey(change1, { ...detachId1, target: crossFieldQueries_js_1.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((0, index_js_1.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 (!(0, index_js_1.areEqualChangeAtomIds)(oldId, newId)) {
+            // `change1`'s detach will be replaced by `change2`'s detach, so we update the cross-field keys.
+            removedCrossFieldKeys.set({ ...oldId, target: crossFieldQueries_js_1.CrossFieldTarget.Source }, countToProcess, true);
+        }
+        movedCrossFieldKeys.set({ ...newId, target: crossFieldQueries_js_1.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, (0, index_js_1.offsetChangeAtomId)(oldId, countToProcess), (0, index_js_1.offsetChangeAtomId)(newId, countToProcess), count - countToProcess, movedCrossFieldKeys, removedCrossFieldKeys, pendingCompositions);
+    }
+}
+function cloneRootTable(table) {
+    return {
+        oldToNewId: table.oldToNewId.clone(),
+        newToOldId: table.newToOldId.clone(),
+        nodeChanges: (0, index_js_2.brand)(table.nodeChanges.clone()),
+        detachLocations: table.detachLocations.clone(),
+        outputDetachLocations: table.outputDetachLocations.clone(),
+    };
+}
+exports.cloneRootTable = cloneRootTable;
+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: crossFieldQueries_js_1.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)) {
+        (0, internal_1.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, (0, index_js_1.offsetChangeAtomId)(oldId, countProcessed), (0, index_js_1.offsetChangeAtomId)(newId, countProcessed), length - countProcessed);
+    }
+}
+function doesChangeAttachNodes(table, id, count) {
+    return table
+        .getAll2({ ...id, target: crossFieldQueries_js_1.CrossFieldTarget.Destination }, count)
+        .map((entry) => ({ ...entry, value: entry.value !== undefined }));
+}
+function doesChangeDetachNodes(table, id, count) {
+    return table
+        .getAll2({ ...id, target: crossFieldQueries_js_1.CrossFieldTarget.Source }, count)
+        .map((entry) => ({ ...entry, value: entry.value !== undefined }));
+}
+function getFirstDetachField(table, id, count) {
+    return table.getFirst({ target: crossFieldQueries_js_1.CrossFieldTarget.Source, ...id }, count);
+}
+exports.getFirstDetachField = getFirstDetachField;
+function getFirstAttachField(table, id, count) {
+    return table.getFirst({ target: crossFieldQueries_js_1.CrossFieldTarget.Destination, ...id }, count);
+}
+exports.getFirstAttachField = getFirstAttachField;
+function addNodeRename(table, oldId, newId, count, detachLocation) {
+    if ((0, index_js_1.areEqualChangeAtomIds)(oldId, newId)) {
+        return;
+    }
+    for (const entry of table.oldToNewId.getAll2(oldId, count)) {
+        (0, internal_1.assert)(entry.value === undefined ||
+            (0, index_js_1.areEqualChangeAtomIds)(entry.value, (0, index_js_1.offsetChangeAtomId)(newId, entry.offset)), "Rename collision detected");
+    }
+    for (const entry of table.newToOldId.getAll2(newId, count)) {
+        (0, internal_1.assert)(entry.value === undefined ||
+            (0, index_js_1.areEqualChangeAtomIds)(entry.value, (0, index_js_1.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);
+    }
+}
+exports.addNodeRename = addNodeRename;
+/**
+ * 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, (0, index_js_1.offsetChangeAtomId)(oldId, countToProcess), (0, index_js_1.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 = (0, modularChangeTypes_js_1.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, (0, index_js_1.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) => (0, index_js_1.replaceAtomRevisions)(id, oldRevisions, newRevision), (id) => (0, index_js_1.replaceAtomRevisions)(id, oldRevisions, newRevision));
+    const newToOldId = table.newToOldId.mapEntries((id) => (0, index_js_1.replaceAtomRevisions)(id, oldRevisions, newRevision), (id) => (0, index_js_1.replaceAtomRevisions)(id, oldRevisions, newRevision));
+    const nodeChanges = (0, index_js_2.newTupleBTree)([...table.nodeChanges.entries()].map(([[revision, id], nodeId]) => [
+        [oldRevisions.has(revision) ? newRevision : revision, id],
+        (0, index_js_1.replaceAtomRevisions)(normalizeNodeId(nodeId, nodeAliases), oldRevisions, newRevision),
+    ]));
+    const detachLocations = table.detachLocations.mapEntries((id) => (0, index_js_1.replaceAtomRevisions)(id, oldRevisions, newRevision), (fieldId) => replaceFieldIdRevision(normalizeFieldId(fieldId, nodeAliases), oldRevisions, newRevision));
+    const outputDetachLocations = table.outputDetachLocations.mapEntries((id) => (0, index_js_1.replaceAtomRevisions)(id, oldRevisions, newRevision), (fieldId) => replaceFieldIdRevision(normalizeFieldId(fieldId, nodeAliases), oldRevisions, newRevision));
+    return { oldToNewId, newToOldId, nodeChanges, detachLocations, outputDetachLocations };
+}
+function newDetachedEntryMap() {
+    return new index_js_2.RangeMap(index_js_1.offsetChangeAtomId, index_js_1.subtractChangeAtomIds, offsetDetachedNodeEntry);
+}
+function offsetDetachedNodeEntry(entry, count) {
+    (0, internal_1.assert)(count <= 1 || entry.nodeChange === undefined, "Cannot split an entry with a node change");
+    return entry.detachId !== undefined
+        ? { ...entry, detachId: (0, index_js_1.offsetChangeAtomId)(entry.detachId, count) }
+        : entry;
+}
+function getFieldsWithRootMoves(roots, nodeAliases) {
+    const fields = (0, index_js_2.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 = (0, index_js_2.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: (0, index_js_1.newChangeAtomIdTransform)(),
+        newToOldId: (0, index_js_1.newChangeAtomIdTransform)(),
+        nodeChanges: (0, index_js_2.brand)(roots.nodeChanges.clone()),
+        detachLocations: roots.detachLocations.clone(),
+        outputDetachLocations: (0, index_js_1.newChangeAtomIdRangeMap)(),
+    };
+}
 //# sourceMappingURL=modularChangeFamily.js.map