@fluidframework/tree 2.74.0-370705 → 2.80.0

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

@@ -4,19 +4,24 @@
  */
 import { assert, fail } from "@fluidframework/core-utils/internal";
 import { BTree } from "@tylerbu/sorted-btree-es6";
-import { EditBuilder, makeDetachedNodeId, replaceAtomRevisions, revisionMetadataSourceFromInfo, areEqualChangeAtomIds, areEqualChangeAtomIdOpts, tagChange, makeAnonChange, mapTaggedChange, newChangeAtomIdRangeMap, newChangeAtomIdTransform, offsetChangeAtomId, isDetachedUpPathRoot, subtractChangeAtomIds, makeChangeAtomId, } from "../../core/index.js";
+import { UsageError } from "@fluidframework/telemetry-utils/internal";
+import { FluidClientVersion, } from "../../codec/index.js";
+import { EditBuilder, makeDetachedNodeId, revisionMetadataSourceFromInfo, areEqualChangeAtomIds, areEqualChangeAtomIdOpts, tagChange, makeAnonChange, newChangeAtomIdRangeMap, mapTaggedChange, } from "../../core/index.js";
 import { brand, idAllocatorFromMaxId, idAllocatorFromState, getOrCreate, newTupleBTree, mergeTupleBTrees, RangeMap, balancedReduce, } from "../../util/index.js";
-import { CrossFieldTarget, setInCrossFieldMap, } from "./crossFieldQueries.js";
+import { CrossFieldTarget, getFirstFromCrossFieldMap, setInCrossFieldMap, } from "./crossFieldQueries.js";
 import { NodeAttachState, } from "./fieldChangeHandler.js";
 import { convertGenericChange, genericFieldKind } from "./genericFieldKind.js";
-import { getFromChangeAtomIdMap, newCrossFieldRangeTable, rangeQueryChangeAtomIdMap, setInChangeAtomIdMap, } from "./modularChangeTypes.js";
+import { newCrossFieldKeyTable, } from "./modularChangeTypes.js";
+import { getFromChangeAtomIdMap, setInChangeAtomIdMap, } from "../changeAtomIdBTree.js";
+import { lt } from "semver-ts";
 /**
  * Implementation of ChangeFamily which delegates work in a given field to the appropriate FieldKind
  * as determined by the schema.
  */
 export class ModularChangeFamily {
-    constructor(fieldKinds, codecs) {
+    constructor(fieldKinds, codecs, codecOptions) {
         this.codecs = codecs;
+        this.codecOptions = codecOptions;
         this.fieldKinds = fieldKinds;
     }
     get rebaser() {
@@ -31,9 +36,9 @@ export class ModularChangeFamily {
      */
     normalizeFieldChanges(change1, change2) {
         // TODO: Handle the case where changes have conflicting field kinds
-        const kind = change1.fieldKind !== genericFieldKind.identifier
-            ? change1.fieldKind
-            : change2.fieldKind;
+        const kind = change1.fieldKind === genericFieldKind.identifier
+            ? change2.fieldKind
+            : change1.fieldKind;
         if (kind === genericFieldKind.identifier) {
             // Both changes are generic
             return {
@@ -64,19 +69,21 @@ export class ModularChangeFamily {
         return convertedChange;
     }
     compose(changes) {
-        const { maxId } = getRevInfoFromTaggedChanges(changes);
+        const { revInfos, maxId } = getRevInfoFromTaggedChanges(changes);
         const idState = { maxId };
         const pairwiseDelegate = (left, right) => {
-            return this.composePair(left, right, idState);
+            return this.composePair(left, right, revInfos, idState);
         };
         const innerChanges = changes.map((change) => change.change);
         return balancedReduce(innerChanges, pairwiseDelegate, makeModularChangeset);
     }
-    composePair(change1, change2, idState) {
-        const revInfos = composeRevInfos(change1.revisions, change2.revisions);
-        const { fieldChanges, nodeChanges, nodeToParent, nodeAliases, crossFieldKeys, rootNodes } = this.composeAllFields(change1, change2, revInfos, idState);
+    composePair(change1, change2, revInfos, idState) {
+        const { fieldChanges, nodeChanges, nodeToParent, nodeAliases, crossFieldKeys } = this.composeAllFields(change1, change2, revInfos, idState);
         const { allBuilds, allDestroys, allRefreshers } = composeBuildsDestroysAndRefreshers(change1, change2);
-        const composed = makeModularChangeset({
+        // The composed changeset has a "no change" constraint if either change has one
+        const noChangeConstraint = change1.noChangeConstraint ?? change2.noChangeConstraint;
+        const noChangeConstraintOnRevert = change1.noChangeConstraintOnRevert ?? change2.noChangeConstraintOnRevert;
+        return makeModularChangeset({
             fieldChanges,
             nodeChanges,
             nodeToParent,
@@ -84,14 +91,12 @@ export class ModularChangeFamily {
             crossFieldKeys,
             maxId: idState.maxId,
             revisions: revInfos,
-            rootNodes,
+            noChangeConstraint,
+            noChangeConstraintOnRevert,
             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.
@@ -112,50 +117,34 @@ export class ModularChangeFamily {
         const composedNodeChanges = brand(mergeTupleBTrees(change1.nodeChanges, change2.nodeChanges));
         const composedNodeToParent = brand(mergeTupleBTrees(change1.nodeToParent, change2.nodeToParent));
         const composedNodeAliases = brand(mergeTupleBTrees(change1.nodeAliases, change2.nodeAliases));
-        const pendingCompositions = {
-            nodeIdsToCompose: [],
-            affectedBaseFields: newTupleBTree(),
-        };
-        const movedCrossFieldKeys = newCrossFieldRangeTable();
-        const removedCrossFieldKeys = newCrossFieldRangeTable();
-        const composedRoots = composeRootTables(change1, change2, composedNodeToParent, movedCrossFieldKeys, removedCrossFieldKeys, pendingCompositions);
-        const crossFieldTable = newComposeTable(change1, change2, composedRoots, movedCrossFieldKeys, removedCrossFieldKeys, pendingCompositions);
+        const crossFieldTable = newComposeTable(change1, change2, composedNodeToParent);
         const composedFields = this.composeFieldMaps(change1.fieldChanges, change2.fieldChanges, undefined, genId, crossFieldTable, revisionMetadata);
         this.composeInvalidatedElements(crossFieldTable, composedFields, composedNodeChanges, composedNodeToParent, composedNodeAliases, genId, revisionMetadata);
-        for (const entry of crossFieldTable.renamesToDelete.entries()) {
-            deleteNodeRenameFrom(crossFieldTable.composedRootNodes, entry.start, entry.length);
-        }
-        for (const [nodeId, location] of crossFieldTable.movedNodeToParent.entries()) {
-            // Moved nodes are from change2.
-            // If there is a corresponding node in change1, then composedNodeToParent will already have the correct entry,
-            // because the location of the node is the same in change1 and the composed change
-            // (since they have the same input context).
-            if (crossFieldTable.newToBaseNodeId.get(nodeId) === undefined) {
-                composedNodeToParent.set(nodeId, location);
-            }
-        }
+        // Currently no field kinds require making changes to cross-field keys during composition, so we can just merge the two tables.
+        const composedCrossFieldKeys = RangeMap.union(change1.crossFieldKeys, change2.crossFieldKeys);
         return {
             fieldChanges: composedFields,
             nodeChanges: composedNodeChanges,
             nodeToParent: composedNodeToParent,
             nodeAliases: composedNodeAliases,
-            crossFieldKeys: composeCrossFieldKeyTables(change1.crossFieldKeys, change2.crossFieldKeys, crossFieldTable.movedCrossFieldKeys, crossFieldTable.removedCrossFieldKeys),
-            rootNodes: composedRoots,
+            crossFieldKeys: composedCrossFieldKeys,
         };
     }
     composeInvalidatedField(fieldChange, crossFieldTable, genId, revisionMetadata) {
         const context = crossFieldTable.fieldToContext.get(fieldChange);
         assert(context !== undefined, 0x8cc /* Should have context for every invalidated field */);
-        const { change1: fieldChange1, change2: fieldChange2, composedChange } = context;
-        crossFieldTable.pendingCompositions.affectedBaseFields.delete(fieldIdKeyFromFieldId(context.fieldId));
+        const { fieldId, change1: fieldChange1, change2: fieldChange2, composedChange } = context;
         const rebaser = getChangeHandler(this.fieldKinds, composedChange.fieldKind).rebaser;
         const composeNodes = (child1, child2) => {
-            if (child1 !== undefined && child2 !== undefined) {
-                addNodesToCompose(crossFieldTable, child1, child2);
+            if (child1 !== undefined &&
+                child2 !== undefined &&
+                getFromChangeAtomIdMap(crossFieldTable.newToBaseNodeId, child2) === undefined) {
+                setInChangeAtomIdMap(crossFieldTable.newToBaseNodeId, child2, child1);
+                crossFieldTable.pendingCompositions.nodeIdsToCompose.push([child1, child2]);
             }
             return child1 ?? child2 ?? fail(0xb22 /* Should not compose two undefined nodes */);
         };
-        const amendedChange = rebaser.compose(fieldChange1, fieldChange2, composeNodes, genId, new ComposeNodeManagerI(crossFieldTable, context.fieldId, false), revisionMetadata);
+        const amendedChange = rebaser.compose(fieldChange1, fieldChange2, composeNodes, genId, new ComposeManager(crossFieldTable, fieldChange, fieldId, false), revisionMetadata);
         composedChange.change = brand(amendedChange);
     }
     /**
@@ -164,23 +153,32 @@ export class ModularChangeFamily {
      * - discovering that two node changesets refer to the same node (`nodeIdsToCompose`)
      * - a previously composed field being invalidated by a cross field effect (`invalidatedFields`)
      * - a field which was copied directly from an input changeset being invalidated by a cross field effect
-     * (`affectedBaseFields`)
+     * (`affectedBaseFields` and `affectedNewFields`)
      *
      * Updating an element may invalidate further elements. This function runs until there is no more invalidation.
      */
     composeInvalidatedElements(table, composedFields, composedNodes, composedNodeToParent, nodeAliases, genId, metadata) {
         const pending = table.pendingCompositions;
-        while (pending.nodeIdsToCompose.length > 0 || pending.affectedBaseFields.length > 0) {
-            this.processPendingNodeCompositions(table, composedNodes, composedNodeToParent, nodeAliases, genId, metadata);
-            this.composeAffectedFields(table, table.baseChange, pending.affectedBaseFields, composedFields, composedNodes, genId, metadata);
+        while (table.invalidatedFields.size > 0 ||
+            pending.nodeIdsToCompose.length > 0 ||
+            pending.affectedBaseFields.length > 0 ||
+            pending.affectedNewFields.length > 0) {
+            // Note that the call to `composeNodesById` can add entries to `crossFieldTable.nodeIdPairs`.
+            for (const [id1, id2] of pending.nodeIdsToCompose) {
+                this.composeNodesById(table.baseChange.nodeChanges, table.newChange.nodeChanges, composedNodes, composedNodeToParent, nodeAliases, id1, id2, genId, table, metadata);
+            }
+            pending.nodeIdsToCompose.length = 0;
+            this.composeAffectedFields(table, table.baseChange, true, pending.affectedBaseFields, composedFields, composedNodes, genId, metadata);
+            this.composeAffectedFields(table, table.newChange, false, pending.affectedNewFields, composedFields, composedNodes, genId, metadata);
+            this.processInvalidatedCompositions(table, genId, metadata);
         }
     }
-    processPendingNodeCompositions(table, composedNodes, composedNodeToParent, nodeAliases, genId, metadata) {
-        // Note that the call to `composeNodesById` can add entries to `crossFieldTable.nodeIdPairs`.
-        for (const [id1, id2] of table.pendingCompositions.nodeIdsToCompose) {
-            this.composeNodesById(table.baseChange, table.newChange, composedNodes, composedNodeToParent, nodeAliases, id1, id2, genId, table, metadata);
+    processInvalidatedCompositions(table, genId, metadata) {
+        const fieldsToUpdate = table.invalidatedFields;
+        table.invalidatedFields = new Set();
+        for (const fieldChange of fieldsToUpdate) {
+            this.composeInvalidatedField(fieldChange, table, genId, metadata);
         }
-        table.pendingCompositions.nodeIdsToCompose.length = 0;
     }
     /**
      * Ensures that each field in `affectedFields` has been updated in the composition output.
@@ -193,36 +191,38 @@ export class ModularChangeFamily {
      * If not, they are assumed to be part of the new changeset.
      * @param affectedFields - The set of fields to process.
      */
-    composeAffectedFields(table, change, affectedFields, composedFields, composedNodes, genId, metadata) {
-        const fieldsToProcess = affectedFields.clone();
-        affectedFields.clear();
-        for (const fieldIdKey of fieldsToProcess.keys()) {
-            const fieldId = fieldIdFromFieldIdKey(fieldIdKey);
-            const fieldChange = fieldChangeFromId(change, fieldId);
+    composeAffectedFields(table, change, areBaseFields, affectedFields, composedFields, composedNodes, genId, metadata) {
+        for (const fieldIdKey of affectedFields.keys()) {
+            const fieldId = normalizeFieldId(fieldIdFromFieldIdKey(fieldIdKey), change.nodeAliases);
+            const fieldChange = fieldChangeFromId(change.fieldChanges, change.nodeChanges, fieldId);
             if (table.fieldToContext.has(fieldChange) ||
                 table.newFieldToBaseField.has(fieldChange)) {
-                this.composeInvalidatedField(fieldChange, table, genId, metadata);
+                // This function handles fields which were not part of the intersection of the two changesets but which need to be updated anyway.
+                // If we've already processed this field then either it is up to date
+                // or there is pending inval which will be handled in processInvalidatedCompositions.
+                continue;
             }
-            else {
-                this.composeFieldWithNoNewChange(table, fieldChange, fieldId, composedFields, composedNodes, genId, metadata);
+            const emptyChange = this.createEmptyFieldChange(fieldChange.fieldKind);
+            const [change1, change2] = areBaseFields
+                ? [fieldChange, emptyChange]
+                : [emptyChange, fieldChange];
+            const composedField = this.composeFieldChanges(fieldId, change1, change2, genId, table, metadata);
+            if (fieldId.nodeId === undefined) {
+                composedFields.set(fieldId.field, composedField);
+                continue;
             }
+            const nodeId = getFromChangeAtomIdMap(table.newToBaseNodeId, fieldId.nodeId) ?? fieldId.nodeId;
+            let nodeChangeset = nodeChangeFromId(composedNodes, nodeId);
+            if (!table.composedNodes.has(nodeChangeset)) {
+                nodeChangeset = cloneNodeChangeset(nodeChangeset);
+                setInChangeAtomIdMap(composedNodes, nodeId, nodeChangeset);
+            }
+            if (nodeChangeset.fieldChanges === undefined) {
+                nodeChangeset.fieldChanges = new Map();
+            }
+            nodeChangeset.fieldChanges.set(fieldId.field, composedField);
         }
-    }
-    composeFieldWithNoNewChange(table, baseFieldChange, fieldId, composedFields, composedNodes, genId, metadata) {
-        const emptyChange = this.createEmptyFieldChange(baseFieldChange.fieldKind);
-        const composedField = this.composeFieldChanges(fieldId, baseFieldChange, emptyChange, genId, table, metadata);
-        if (fieldId.nodeId === undefined) {
-            composedFields.set(fieldId.field, composedField);
-            return;
-        }
-        const nodeId = normalizeNodeId(getFromChangeAtomIdMap(table.newToBaseNodeId, fieldId.nodeId) ?? fieldId.nodeId, table.baseChange.nodeAliases);
-        // We clone the node changeset before mutating it, as it may be from one of the input changesets.
-        const nodeChangeset = cloneNodeChangeset(nodeChangeFromId(composedNodes, table.baseChange.nodeAliases, nodeId));
-        setInChangeAtomIdMap(composedNodes, nodeId, nodeChangeset);
-        if (nodeChangeset.fieldChanges === undefined) {
-            nodeChangeset.fieldChanges = new Map();
-        }
-        nodeChangeset.fieldChanges.set(fieldId.field, composedField);
+        affectedFields.clear();
     }
     composeFieldMaps(change1, change2, parentId, genId, crossFieldTable, revisionMetadata) {
         const composedFields = new Map();
@@ -232,17 +232,9 @@ export class ModularChangeFamily {
         for (const [field, fieldChange1] of change1) {
             const fieldId = { nodeId: parentId, field };
             const fieldChange2 = change2.get(field);
-            const cachedComposedFieldChange = crossFieldTable.fieldToContext.get(fieldChange1)?.composedChange;
-            if (fieldChange2 === undefined && cachedComposedFieldChange !== undefined) {
-                // This can happen if the field was previous processed in `composeFieldWithNoNewChange`.
-                // If `change2` does not have a change for this field, then without this check we would
-                // lose the composed field change and instead simply have `change1`'s change.
-                composedFields.set(field, cachedComposedFieldChange);
-                continue;
-            }
-            const composedField = fieldChange2 !== undefined
-                ? this.composeFieldChanges(fieldId, fieldChange1, fieldChange2, genId, crossFieldTable, revisionMetadata)
-                : fieldChange1;
+            const composedField = fieldChange2 === undefined
+                ? fieldChange1
+                : this.composeFieldChanges(fieldId, fieldChange1, fieldChange2, genId, crossFieldTable, revisionMetadata);
             composedFields.set(field, composedField);
         }
         for (const [field, fieldChange2] of change2) {
@@ -259,16 +251,17 @@ export class ModularChangeFamily {
      * will be added to `crossFieldTable.pendingCompositions.nodeIdsToCompose`.
      *
      * Any fields which had cross-field information sent to them as part of this field composition
-     * will be added to `affectedBaseFields` in `crossFieldTable.pendingCompositions`.
+     * will be added to either `affectedBaseFields` or `affectedNewFields` in `crossFieldTable.pendingCompositions`.
      *
      * Any composed `FieldChange` which is invalidated by new cross-field information will be added to `crossFieldTable.invalidatedFields`.
      */
     composeFieldChanges(fieldId, change1, change2, idAllocator, crossFieldTable, revisionMetadata) {
         const { fieldKind, changeHandler, change1: change1Normalized, change2: change2Normalized, } = this.normalizeFieldChanges(change1, change2);
-        const manager = new ComposeNodeManagerI(crossFieldTable, fieldId);
+        const manager = new ComposeManager(crossFieldTable, change1, fieldId);
         const composedChange = changeHandler.rebaser.compose(change1Normalized, change2Normalized, (child1, child2) => {
             if (child1 !== undefined && child2 !== undefined) {
-                addNodesToCompose(crossFieldTable, child1, child2);
+                setInChangeAtomIdMap(crossFieldTable.newToBaseNodeId, child2, child1);
+                crossFieldTable.pendingCompositions.nodeIdsToCompose.push([child1, child2]);
             }
             return child1 ?? child2 ?? fail(0xb23 /* Should not compose two undefined nodes */);
         }, idAllocator, manager, revisionMetadata);
@@ -285,18 +278,19 @@ export class ModularChangeFamily {
         crossFieldTable.newFieldToBaseField.set(change2, change1);
         return composedField;
     }
-    composeNodesById(change1, change2, composedNodes, composedNodeToParent, composedAliases, id1, id2, idAllocator, crossFieldTable, revisionMetadata) {
-        const nodeChangeset1 = nodeChangeFromId(change1.nodeChanges, change1.nodeAliases, id1);
-        const nodeChangeset2 = nodeChangeFromId(change2.nodeChanges, change2.nodeAliases, id2);
+    composeNodesById(nodeChanges1, nodeChanges2, composedNodes, composedNodeToParent, nodeAliases, id1, id2, idAllocator, crossFieldTable, revisionMetadata) {
+        const nodeChangeset1 = nodeChangeFromId(nodeChanges1, id1);
+        const nodeChangeset2 = nodeChangeFromId(nodeChanges2, id2);
         const composedNodeChangeset = this.composeNodeChanges(id1, nodeChangeset1, nodeChangeset2, idAllocator, crossFieldTable, revisionMetadata);
         setInChangeAtomIdMap(composedNodes, id1, composedNodeChangeset);
         if (!areEqualChangeAtomIds(id1, id2)) {
             composedNodes.delete([id2.revision, id2.localId]);
             composedNodeToParent.delete([id2.revision, id2.localId]);
-            setInChangeAtomIdMap(composedAliases, id2, id1);
+            setInChangeAtomIdMap(nodeAliases, id2, id1);
             // We need to delete id1 to avoid forming a cycle in case id1 already had an alias.
-            composedAliases.delete([id1.revision, id1.localId]);
+            nodeAliases.delete([id1.revision, id1.localId]);
         }
+        crossFieldTable.composedNodes.add(composedNodeChangeset);
     }
     composeNodeChanges(nodeId, change1, change2, genId, crossFieldTable, revisionMetadata) {
         // WARNING: this composition logic assumes that we never make compositions of the following form:
@@ -327,8 +321,8 @@ export class ModularChangeFamily {
     /**
      * @param change - The change to invert.
      * @param isRollback - Whether the inverted change is meant to rollback a change on a branch as is the case when
-     * @param revisionForInvert - The revision for the invert changeset.
      * performing a sandwich rebase.
+     * @param revisionForInvert - The revision for the invert changeset.
      */
     invert(change, isRollback, revisionForInvert) {
         // Rollback changesets destroy the nodes created by the change being rolled back.
@@ -338,6 +332,8 @@ export class ModularChangeFamily {
         const revInfos = isRollback
             ? [{ revision: revisionForInvert, rollbackOf: change.revision }]
             : [{ revision: revisionForInvert }];
+        const noChangeConstraint = change.change.noChangeConstraintOnRevert;
+        const noChangeConstraintOnRevert = change.change.noChangeConstraint;
         if (hasConflicts(change.change)) {
             return makeModularChangeset({
                 maxId: change.change.maxId,
@@ -347,14 +343,9 @@ export class ModularChangeFamily {
         }
         const genId = idAllocatorFromMaxId(change.change.maxId ?? -1);
         const crossFieldTable = {
-            change: change.change,
-            entries: newChangeAtomIdRangeMap(),
+            ...newCrossFieldTable(),
             originalFieldToContext: new Map(),
-            invertRevision: revisionForInvert,
             invertedNodeToParent: brand(change.change.nodeToParent.clone()),
-            invalidatedFields: new Set(),
-            invertedRoots: invertRootTable(change.change, isRollback),
-            attachToDetachId: newChangeAtomIdTransform(),
         };
         const { revInfos: oldRevInfos } = getRevInfoFromTaggedChanges([change]);
         const revisionMetadata = revisionMetadataSourceFromInfo(oldRevInfos);
@@ -370,24 +361,24 @@ export class ModularChangeFamily {
                 const originalFieldChange = fieldChange.change;
                 const context = crossFieldTable.originalFieldToContext.get(fieldChange);
                 assert(context !== undefined, 0x851 /* Should have context for every invalidated field */);
-                const { invertedField } = context;
-                const amendedChange = getChangeHandler(this.fieldKinds, fieldChange.fieldKind).rebaser.invert(originalFieldChange, isRollback, genId, revisionForInvert, new InvertNodeManagerI(crossFieldTable, context.fieldId), revisionMetadata);
+                const { invertedField, fieldId } = context;
+                const amendedChange = getChangeHandler(this.fieldKinds, fieldChange.fieldKind).rebaser.invert(originalFieldChange, isRollback, genId, revisionForInvert, new InvertManager(crossFieldTable, fieldChange, fieldId), revisionMetadata);
                 invertedField.change = brand(amendedChange);
             }
         }
         const crossFieldKeys = this.makeCrossFieldKeyTable(invertedFields, invertedNodes);
-        this.processInvertRenames(crossFieldTable);
         return makeModularChangeset({
             fieldChanges: invertedFields,
             nodeChanges: invertedNodes,
             nodeToParent: crossFieldTable.invertedNodeToParent,
-            rootNodes: crossFieldTable.invertedRoots,
             nodeAliases: change.change.nodeAliases,
             crossFieldKeys,
             maxId: genId.getMaxId(),
             revisions: revInfos,
             constraintViolationCount: change.change.constraintViolationCountOnRevert,
             constraintViolationCountOnRevert: change.change.constraintViolationCount,
+            noChangeConstraint,
+            noChangeConstraintOnRevert,
             destroys,
         });
     }
@@ -395,7 +386,7 @@ export class ModularChangeFamily {
         const invertedFields = new Map();
         for (const [field, fieldChange] of changes) {
             const fieldId = { nodeId: parentId, field };
-            const manager = new InvertNodeManagerI(crossFieldTable, fieldId);
+            const manager = new InvertManager(crossFieldTable, fieldChange, fieldId);
             const invertedChange = getChangeHandler(this.fieldKinds, fieldChange.fieldKind).rebaser.invert(fieldChange.change, isRollback, genId, revisionForInvert, manager, revisionMetadata);
             const invertedFieldChange = {
                 ...fieldChange,
@@ -427,12 +418,6 @@ export class ModularChangeFamily {
         }
         return inverse;
     }
-    processInvertRenames(table) {
-        for (const { start: newAttachId, value: originalDetachId, length, } of table.attachToDetachId.entries()) {
-            // Note that the detach location is already set in `invertDetach`.
-            addNodeRename(table.invertedRoots, originalDetachId, newAttachId, length, undefined);
-        }
-    }
     rebase(taggedChange, potentiallyConflictedOver, revisionMetadata) {
         // Our current cell ordering scheme in sequences depends on being able to rebase over a change with conflicts.
         // This means that we must rebase over a muted version of the conflicted changeset.
@@ -443,26 +428,17 @@ export class ModularChangeFamily {
         const maxId = Math.max(change.maxId ?? -1, over.change.maxId ?? -1);
         const idState = { maxId };
         const genId = idAllocatorFromState(idState);
-        const affectedBaseFields = newTupleBTree();
-        const nodesToRebase = [];
-        const rebasedNodeToParent = brand(change.nodeToParent.clone());
-        const rebaseVersion = Math.max(change.rebaseVersion, over.change.rebaseVersion);
-        const rebasedRootNodes = rebaseRoots(change, over.change, affectedBaseFields, nodesToRebase, rebasedNodeToParent, rebaseVersion);
         const crossFieldTable = {
-            rebaseVersion,
-            entries: newDetachedEntryMap(),
+            ...newCrossFieldTable(),
             newChange: change,
             baseChange: over.change,
             baseFieldToContext: new Map(),
-            baseRoots: over.change.rootNodes,
-            rebasedRootNodes,
             baseToRebasedNodeId: newTupleBTree(),
             rebasedFields: new Set(),
-            rebasedNodeToParent,
-            rebasedDetachLocations: newChangeAtomIdRangeMap(),
-            movedDetaches: newChangeAtomIdRangeMap(),
+            rebasedNodeToParent: brand(change.nodeToParent.clone()),
+            rebasedCrossFieldKeys: change.crossFieldKeys.clone(),
             nodeIdPairs: [],
-            affectedBaseFields,
+            affectedBaseFields: newTupleBTree(),
             fieldsWithUnattachedChild: new Set(),
         };
         const getBaseRevisions = () => revisionInfoFromTaggedChange(over).map((info) => info.revision);
@@ -472,45 +448,40 @@ export class ModularChangeFamily {
             getBaseRevisions,
         };
         const rebasedNodes = brand(change.nodeChanges.clone());
-        const rebasedFields = this.rebaseIntersectingFields(nodesToRebase, crossFieldTable, rebasedNodes, genId, rebaseMetadata);
-        this.rebaseInvalidatedFields(rebasedFields, rebasedNodes, crossFieldTable, rebaseMetadata, genId);
-        fixupRebasedDetachLocations(crossFieldTable);
+        const rebasedFields = this.rebaseIntersectingFields(crossFieldTable, rebasedNodes, genId, rebaseMetadata);
+        this.rebaseInvalidatedElements(rebasedFields, rebasedNodes, crossFieldTable, rebaseMetadata, genId);
         const constraintState = newConstraintState(change.constraintViolationCount ?? 0);
         const revertConstraintState = newConstraintState(change.constraintViolationCountOnRevert ?? 0);
-        this.updateConstraints(rebasedFields, rebasedNodes, rebasedRootNodes, constraintState, revertConstraintState);
-        const fieldsWithRootMoves = getFieldsWithRootMoves(crossFieldTable.rebasedRootNodes, change.nodeAliases);
-        const fieldToRootChanges = getFieldToRootChanges(crossFieldTable.rebasedRootNodes, change.nodeAliases);
+        let noChangeConstraint = change.noChangeConstraint;
+        if (noChangeConstraint !== undefined && !noChangeConstraint.violated) {
+            noChangeConstraint = { violated: true };
+            constraintState.violationCount += 1;
+        }
+        this.updateConstraintsForFields(rebasedFields, NodeAttachState.Attached, NodeAttachState.Attached, constraintState, revertConstraintState, rebasedNodes);
         const rebased = makeModularChangeset({
-            fieldChanges: this.pruneFieldMap(rebasedFields, undefined, rebasedNodes, crossFieldTable.rebasedNodeToParent, change.nodeAliases, crossFieldTable.rebasedRootNodes, fieldsWithRootMoves, fieldToRootChanges),
+            fieldChanges: this.pruneFieldMap(rebasedFields, rebasedNodes),
             nodeChanges: rebasedNodes,
             nodeToParent: crossFieldTable.rebasedNodeToParent,
-            rootNodes: this.pruneRoots(crossFieldTable.rebasedRootNodes, rebasedNodes, crossFieldTable.rebasedNodeToParent, change.nodeAliases, fieldsWithRootMoves, fieldToRootChanges),
-            // TODO: Do we need to include aliases for node changesets added during rebasing?
             nodeAliases: change.nodeAliases,
-            crossFieldKeys: rebaseCrossFieldKeys(change.crossFieldKeys, crossFieldTable.movedDetaches, crossFieldTable.rebasedDetachLocations),
+            crossFieldKeys: crossFieldTable.rebasedCrossFieldKeys,
             maxId: idState.maxId,
             revisions: change.revisions,
             constraintViolationCount: constraintState.violationCount,
             constraintViolationCountOnRevert: revertConstraintState.violationCount,
+            noChangeConstraint,
+            noChangeConstraintOnRevert: change.noChangeConstraintOnRevert,
             builds: change.builds,
             destroys: change.destroys,
             refreshers: change.refreshers,
-            rebaseVersion,
         });
-        // XXX: This is an expensive assert which should be disabled before merging.
-        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(rootChanges, crossFieldTable, rebasedNodes, genId, metadata) {
+    rebaseIntersectingFields(crossFieldTable, rebasedNodes, genId, metadata) {
         const change = crossFieldTable.newChange;
         const baseChange = crossFieldTable.baseChange;
         const rebasedFields = this.rebaseFieldMap(change.fieldChanges, baseChange.fieldChanges, undefined, genId, crossFieldTable, metadata);
-        for (const [newChildChange, baseChildChange] of rootChanges) {
-            const rebasedNode = this.rebaseNodeChange(newChildChange, baseChildChange, genId, crossFieldTable, metadata);
-            setInChangeAtomIdMap(rebasedNodes, newChildChange, rebasedNode);
-        }
         // This loop processes all fields which have both base and new changes.
         // Note that the call to `rebaseNodeChange` can add entries to `crossFieldTable.nodeIdPairs`.
         for (const [newId, baseId, _attachState] of crossFieldTable.nodeIdPairs) {
@@ -519,85 +490,87 @@ export class ModularChangeFamily {
         }
         return rebasedFields;
     }
-    rebaseFieldWithoutNewChanges(baseFieldChange, baseFieldId, crossFieldTable, rebasedFields, rebasedNodes, genId, metadata, 
-    /**
-     * The ID of a node in `baseFieldChange` which should be included in the rebased field change.
-     */
-    baseNodeId) {
-        // This field has no changes in the new changeset, otherwise it would have been added to
-        // `crossFieldTable.baseFieldToContext` when processing fields with both base and new changes.
-        const rebaseChild = (child, baseChild, stateChange) => {
-            assert(child === undefined, 0x9c3 /* There should be no new changes in this field */);
-            if (baseChild === undefined || baseNodeId === undefined) {
-                return undefined;
-            }
-            return areEqualChangeAtomIds(normalizeNodeId(baseChild, crossFieldTable.baseChange.nodeAliases), baseNodeId)
-                ? baseNodeId
-                : undefined;
-        };
-        const handler = getChangeHandler(this.fieldKinds, baseFieldChange.fieldKind);
-        const fieldChange = {
-            ...baseFieldChange,
-            change: brand(handler.createEmpty()),
-        };
-        const rebasedNodeId = baseFieldId.nodeId !== undefined
-            ? rebasedNodeIdFromBaseNodeId(crossFieldTable, baseFieldId.nodeId)
-            : undefined;
-        const fieldId = { nodeId: rebasedNodeId, field: baseFieldId.field };
-        const rebasedField = handler.rebaser.rebase(fieldChange.change, baseFieldChange.change, rebaseChild, genId, new RebaseNodeManagerI(crossFieldTable, fieldId), metadata, crossFieldTable.rebaseVersion);
-        const rebasedFieldChange = {
-            ...baseFieldChange,
-            change: brand(rebasedField),
-        };
-        const context = {
-            newChange: fieldChange,
-            baseChange: baseFieldChange,
-            rebasedChange: rebasedFieldChange,
-            fieldId,
-            baseNodeIds: newTupleBTree(),
-        };
-        if (baseNodeId !== undefined) {
-            setInChangeAtomIdMap(context.baseNodeIds, baseNodeId, true);
-        }
-        crossFieldTable.baseFieldToContext.set(baseFieldChange, context);
-        crossFieldTable.rebasedFields.add(rebasedFieldChange);
-        this.attachRebasedField(rebasedFields, rebasedNodes, crossFieldTable, rebasedFieldChange, fieldId, genId, metadata);
-    }
-    rebaseInvalidatedFields(rebasedFields, rebasedNodes, crossFieldTable, rebaseMetadata, genId) {
-        while (crossFieldTable.affectedBaseFields.size > 0) {
-            const baseFields = crossFieldTable.affectedBaseFields.clone();
-            crossFieldTable.affectedBaseFields.clear();
-            for (const baseFieldIdKey of baseFields.keys()) {
-                const baseFieldId = normalizeFieldId(fieldIdFromFieldIdKey(baseFieldIdKey), crossFieldTable.baseChange.nodeAliases);
-                const baseField = fieldChangeFromId(crossFieldTable.baseChange, baseFieldId);
-                assert(baseField !== undefined, 0x9c2 /* Cross field key registered for empty field */);
-                const context = crossFieldTable.baseFieldToContext.get(baseField);
-                if (context === undefined) {
-                    this.rebaseFieldWithoutNewChanges(baseField, baseFieldId, crossFieldTable, rebasedFields, rebasedNodes, genId, rebaseMetadata);
-                }
-                else {
-                    this.rebaseInvalidatedField(baseField, crossFieldTable, context, rebaseMetadata, genId);
-                }
+    // This processes fields which have no new changes but have been invalidated by another field.
+    rebaseFieldsWithoutNewChanges(rebasedFields, rebasedNodes, crossFieldTable, genId, metadata) {
+        const baseChange = crossFieldTable.baseChange;
+        for (const [revision, localId, fieldKey] of crossFieldTable.affectedBaseFields.keys()) {
+            const baseNodeId = localId === undefined
+                ? undefined
+                : normalizeNodeId({ revision, localId }, baseChange.nodeAliases);
+            const baseFieldChange = fieldMapFromNodeId(baseChange.fieldChanges, baseChange.nodeChanges, baseNodeId).get(fieldKey);
+            assert(baseFieldChange !== undefined, 0x9c2 /* Cross field key registered for empty field */);
+            if (crossFieldTable.baseFieldToContext.has(baseFieldChange)) {
+                // This field has already been processed because there were changes to rebase.
+                continue;
             }
+            // This field has no changes in the new changeset, otherwise it would have been added to
+            // `crossFieldTable.baseFieldToContext` when processing fields with both base and new changes.
+            const rebaseChild = (child, baseChild, stateChange) => {
+                assert(child === undefined, 0x9c3 /* There should be no new changes in this field */);
+                return undefined;
+            };
+            const handler = getChangeHandler(this.fieldKinds, baseFieldChange.fieldKind);
+            const fieldChange = {
+                ...baseFieldChange,
+                change: brand(handler.createEmpty()),
+            };
+            const rebasedNodeId = baseNodeId === undefined
+                ? undefined
+                : rebasedNodeIdFromBaseNodeId(crossFieldTable, baseNodeId);
+            const fieldId = { nodeId: rebasedNodeId, field: fieldKey };
+            const rebasedField = handler.rebaser.rebase(fieldChange.change, baseFieldChange.change, rebaseChild, genId, new RebaseManager(crossFieldTable, baseFieldChange, fieldId), metadata);
+            const rebasedFieldChange = {
+                ...baseFieldChange,
+                change: brand(rebasedField),
+            };
+            // TODO: Deduplicate
+            crossFieldTable.baseFieldToContext.set(baseFieldChange, {
+                newChange: fieldChange,
+                baseChange: baseFieldChange,
+                rebasedChange: rebasedFieldChange,
+                fieldId,
+                baseNodeIds: [],
+            });
+            crossFieldTable.rebasedFields.add(rebasedFieldChange);
+            this.attachRebasedField(rebasedFields, rebasedNodes, crossFieldTable, rebasedFieldChange, fieldId, genId, metadata);
         }
     }
-    rebaseInvalidatedField(baseField, crossFieldTable, context, rebaseMetadata, genId) {
+    rebaseInvalidatedElements(rebasedFields, rebasedNodes, table, metadata, idAllocator) {
+        this.rebaseFieldsWithoutNewChanges(rebasedFields, rebasedNodes, table, idAllocator, metadata);
+        this.rebaseFieldsWithUnattachedChild(table, metadata, idAllocator);
+        this.rebaseInvalidatedFields(table, metadata, idAllocator);
+    }
+    rebaseInvalidatedFields(crossFieldTable, rebaseMetadata, genId) {
+        const fieldsToUpdate = crossFieldTable.invalidatedFields;
+        crossFieldTable.invalidatedFields = new Set();
+        for (const field of fieldsToUpdate) {
+            this.rebaseInvalidatedField(field, crossFieldTable, rebaseMetadata, genId);
+        }
+    }
+    rebaseFieldsWithUnattachedChild(table, metadata, idAllocator) {
+        for (const field of table.fieldsWithUnattachedChild) {
+            table.invalidatedFields.delete(field);
+            this.rebaseInvalidatedField(field, table, metadata, idAllocator, true);
+        }
+    }
+    rebaseInvalidatedField(baseField, crossFieldTable, rebaseMetadata, genId, allowInval = false) {
+        const context = crossFieldTable.baseFieldToContext.get(baseField);
+        assert(context !== undefined, 0x852 /* Every field should have a context */);
         const { changeHandler, change1: fieldChangeset, change2: baseChangeset, } = this.normalizeFieldChanges(context.newChange, context.baseChange);
         const rebaseChild = (curr, base) => {
             if (curr !== undefined) {
                 return curr;
             }
-            if (base !== undefined && getFromChangeAtomIdMap(context.baseNodeIds, base) === true) {
-                return base;
+            if (base !== undefined) {
+                for (const id of context.baseNodeIds) {
+                    if (areEqualChangeAtomIds(base, id)) {
+                        return base;
+                    }
+                }
             }
             return undefined;
         };
-        let allowInval = false;
-        if (crossFieldTable.fieldsWithUnattachedChild.has(baseField)) {
-            crossFieldTable.fieldsWithUnattachedChild.delete(baseField);
-            allowInval = true;
-        }
-        context.rebasedChange.change = brand(changeHandler.rebaser.rebase(fieldChangeset, baseChangeset, rebaseChild, genId, new RebaseNodeManagerI(crossFieldTable, context.fieldId, allowInval), rebaseMetadata, crossFieldTable.rebaseVersion));
+        context.rebasedChange.change = brand(changeHandler.rebaser.rebase(fieldChangeset, baseChangeset, rebaseChild, genId, new RebaseManager(crossFieldTable, baseField, context.fieldId, allowInval), rebaseMetadata));
     }
     attachRebasedField(rebasedFields, rebasedNodes, table, rebasedField, { nodeId, field: fieldKey }, idAllocator, metadata) {
         if (nodeId === undefined) {
@@ -606,14 +579,12 @@ export class ModularChangeFamily {
         }
         const rebasedNode = getFromChangeAtomIdMap(rebasedNodes, nodeId);
         if (rebasedNode !== undefined) {
-            const updatedRebasedNode = cloneNodeChangeset(rebasedNode);
-            setInChangeAtomIdMap(rebasedNodes, nodeId, updatedRebasedNode);
-            if (updatedRebasedNode.fieldChanges === undefined) {
-                updatedRebasedNode.fieldChanges = new Map([[fieldKey, rebasedField]]);
+            if (rebasedNode.fieldChanges === undefined) {
+                rebasedNode.fieldChanges = new Map([[fieldKey, rebasedField]]);
                 return;
             }
-            assert(!updatedRebasedNode.fieldChanges.has(fieldKey), 0x9c4 /* Expected an empty field */);
-            updatedRebasedNode.fieldChanges.set(fieldKey, rebasedField);
+            assert(!rebasedNode.fieldChanges.has(fieldKey), 0x9c4 /* Expected an empty field */);
+            rebasedNode.fieldChanges.set(fieldKey, rebasedField);
             return;
         }
         const newNode = {
@@ -621,51 +592,39 @@ export class ModularChangeFamily {
         };
         setInChangeAtomIdMap(rebasedNodes, nodeId, newNode);
         setInChangeAtomIdMap(table.baseToRebasedNodeId, nodeId, nodeId);
-        const parentBase = getNodeParent(table.baseChange, nodeId);
-        this.attachRebasedNode(rebasedFields, rebasedNodes, table, nodeId, parentBase, idAllocator, metadata);
-    }
-    attachRebasedNode(rebasedFields, rebasedNodes, table, baseNodeId, parentBase, idAllocator, metadata) {
-        if (parentBase.root !== undefined) {
-            const renamedRoot = firstAttachIdFromDetachId(table.baseChange.rootNodes, parentBase.root, 1).value;
-            const attachField = table.baseChange.crossFieldKeys.getFirst({ ...renamedRoot, target: 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 parentFieldId = getParentFieldId(table.baseChange, nodeId);
+        this.attachRebasedNode(rebasedFields, rebasedNodes, table, nodeId, parentFieldId, idAllocator, metadata);
+    }
+    attachRebasedNode(rebasedFields, rebasedNodes, table, baseNodeId, parentFieldIdBase, idAllocator, metadata) {
+        const baseFieldChange = fieldChangeFromId(table.baseChange.fieldChanges, table.baseChange.nodeChanges, parentFieldIdBase);
         const rebasedFieldId = rebasedFieldIdFromBaseId(table, parentFieldIdBase);
-        setInChangeAtomIdMap(table.rebasedNodeToParent, baseNodeId, { field: rebasedFieldId });
+        setInChangeAtomIdMap(table.rebasedNodeToParent, baseNodeId, rebasedFieldId);
         const context = table.baseFieldToContext.get(baseFieldChange);
         if (context !== undefined) {
             // We've already processed this field.
-            // The new child node will be attached in the next pass.
-            // Note that adding to `fieldsWithUnattachedChild` allows that field to generate new invalidations,
-            // so to avoid invalidation cycles we make sure we only add to it once per new unattached child.
-            // This is done by checking whether `context.baseNodeIds` already contained `baseNodeId`.
-            if (setInChangeAtomIdMap(context.baseNodeIds, baseNodeId, true)) {
-                table.fieldsWithUnattachedChild.add(baseFieldChange);
-                table.affectedBaseFields.set(fieldIdKeyFromFieldId(parentFieldIdBase), true);
-            }
+            // The new child node will be attached in rebaseFieldsWithUnattachedChild.
+            context.baseNodeIds.push(baseNodeId);
+            table.fieldsWithUnattachedChild.add(baseFieldChange);
             return;
         }
-        this.rebaseFieldWithoutNewChanges(baseFieldChange, parentFieldIdBase, table, rebasedFields, rebasedNodes, idAllocator, metadata, baseNodeId);
+        const handler = getChangeHandler(this.fieldKinds, baseFieldChange.fieldKind);
+        const fieldChange = {
+            ...baseFieldChange,
+            change: brand(handler.createEmpty()),
+        };
+        const rebasedChangeset = handler.rebaser.rebase(handler.createEmpty(), baseFieldChange.change, (_idNew, idBase) => idBase !== undefined && areEqualChangeAtomIds(idBase, baseNodeId)
+            ? baseNodeId
+            : undefined, idAllocator, new RebaseManager(table, baseFieldChange, rebasedFieldId), metadata);
+        const rebasedField = { ...baseFieldChange, change: brand(rebasedChangeset) };
+        table.rebasedFields.add(rebasedField);
+        table.baseFieldToContext.set(baseFieldChange, {
+            newChange: fieldChange,
+            baseChange: baseFieldChange,
+            rebasedChange: rebasedField,
+            fieldId: rebasedFieldId,
+            baseNodeIds: [],
+        });
+        this.attachRebasedField(rebasedFields, rebasedNodes, table, rebasedField, rebasedFieldId, idAllocator, metadata);
     }
     rebaseFieldMap(change, over, parentId, genId, crossFieldTable, revisionMetadata) {
         const rebasedFields = new Map();
@@ -683,8 +642,8 @@ export class ModularChangeFamily {
                 continue;
             }
             const { fieldKind, changeHandler, change1: fieldChangeset, change2: baseChangeset, } = this.normalizeFieldChanges(fieldChange, baseChange);
-            const manager = new RebaseNodeManagerI(crossFieldTable, fieldId);
-            const rebasedField = changeHandler.rebaser.rebase(fieldChangeset, baseChangeset, rebaseChild, genId, manager, revisionMetadata, crossFieldTable.rebaseVersion);
+            const manager = new RebaseManager(crossFieldTable, baseChange, fieldId);
+            const rebasedField = changeHandler.rebaser.rebase(fieldChangeset, baseChangeset, rebaseChild, genId, manager, revisionMetadata);
             const rebasedFieldChange = {
                 fieldKind,
                 change: brand(rebasedField),
@@ -695,15 +654,15 @@ export class ModularChangeFamily {
                 newChange: fieldChange,
                 rebasedChange: rebasedFieldChange,
                 fieldId,
-                baseNodeIds: newTupleBTree(),
+                baseNodeIds: [],
             });
             crossFieldTable.rebasedFields.add(rebasedFieldChange);
         }
         return rebasedFields;
     }
     rebaseNodeChange(newId, baseId, genId, crossFieldTable, revisionMetadata) {
-        const change = nodeChangeFromId(crossFieldTable.newChange.nodeChanges, crossFieldTable.newChange.nodeAliases, newId);
-        const over = nodeChangeFromId(crossFieldTable.baseChange.nodeChanges, crossFieldTable.baseChange.nodeAliases, baseId);
+        const change = nodeChangeFromId(crossFieldTable.newChange.nodeChanges, newId);
+        const over = nodeChangeFromId(crossFieldTable.baseChange.nodeChanges, baseId);
         const baseMap = over?.fieldChanges ?? new Map();
         const fieldChanges = change.fieldChanges !== undefined && over.fieldChanges !== undefined
             ? this.rebaseFieldMap(change?.fieldChanges ?? new Map(), baseMap, newId, genId, crossFieldTable, revisionMetadata)
@@ -721,37 +680,28 @@ export class ModularChangeFamily {
         setInChangeAtomIdMap(crossFieldTable.baseToRebasedNodeId, baseId, newId);
         return rebasedChange;
     }
-    updateConstraints(rebasedFields, rebasedNodes, rebasedRoots, constraintState, revertConstraintState) {
-        this.updateConstraintsForFields(rebasedFields, NodeAttachState.Attached, NodeAttachState.Attached, constraintState, revertConstraintState, rebasedNodes);
-        for (const [_detachId, nodeId] of rebasedRoots.nodeChanges.entries()) {
-            // XXX: This is incorrect if the rebased changeset attaches the node.
-            // Efficiently computing whether the changeset attaches the node would require maintaining a mapping from node ID to attach ID.
-            const detachedInOutput = true;
-            this.updateConstraintsForNode(nodeId, NodeAttachState.Detached, detachedInOutput ? NodeAttachState.Detached : NodeAttachState.Attached, rebasedNodes, constraintState, revertConstraintState);
-        }
-    }
     updateConstraintsForFields(fields, parentInputAttachState, parentOutputAttachState, constraintState, revertConstraintState, nodes) {
         for (const field of fields.values()) {
             const handler = getChangeHandler(this.fieldKinds, field.fieldKind);
-            for (const [nodeId] of handler.getNestedChanges(field.change)) {
-                // XXX: This is incorrect if the rebased changeset detaches this node.
-                // Efficiently computing whether the changeset detaches the node would require maintaining a mapping from node ID to detach ID.
-                const isOutputDetached = false;
+            for (const [nodeId, inputIndex, outputIndex] of handler.getNestedChanges(field.change)) {
+                const isInputDetached = inputIndex === undefined;
+                const inputAttachState = parentInputAttachState === NodeAttachState.Detached || isInputDetached
+                    ? NodeAttachState.Detached
+                    : NodeAttachState.Attached;
+                const isOutputDetached = outputIndex === undefined;
                 const outputAttachState = parentOutputAttachState === NodeAttachState.Detached || isOutputDetached
                     ? NodeAttachState.Detached
                     : NodeAttachState.Attached;
-                this.updateConstraintsForNode(nodeId, parentInputAttachState, outputAttachState, nodes, constraintState, revertConstraintState);
+                this.updateConstraintsForNode(nodeId, inputAttachState, outputAttachState, nodes, constraintState, revertConstraintState);
             }
         }
     }
     updateConstraintsForNode(nodeId, inputAttachState, outputAttachState, nodes, constraintState, revertConstraintState) {
-        const node = getFromChangeAtomIdMap(nodes, nodeId) ?? fail(0xb24 /* Unknown node ID */);
-        const updatedNode = { ...node };
-        setInChangeAtomIdMap(nodes, nodeId, updatedNode);
+        const node = nodes.get([nodeId.revision, nodeId.localId]) ?? fail(0xb24 /* Unknown node ID */);
         if (node.nodeExistsConstraint !== undefined) {
             const isNowViolated = inputAttachState === NodeAttachState.Detached;
             if (node.nodeExistsConstraint.violated !== isNowViolated) {
-                updatedNode.nodeExistsConstraint = {
+                node.nodeExistsConstraint = {
                     ...node.nodeExistsConstraint,
                     violated: isNowViolated,
                 };
@@ -761,7 +711,7 @@ export class ModularChangeFamily {
         if (node.nodeExistsConstraintOnRevert !== undefined) {
             const isNowViolated = outputAttachState === NodeAttachState.Detached;
             if (node.nodeExistsConstraintOnRevert.violated !== isNowViolated) {
-                updatedNode.nodeExistsConstraintOnRevert = {
+                node.nodeExistsConstraintOnRevert = {
                     ...node.nodeExistsConstraintOnRevert,
                     violated: isNowViolated,
                 };
@@ -772,134 +722,87 @@ export class ModularChangeFamily {
             this.updateConstraintsForFields(node.fieldChanges, inputAttachState, outputAttachState, constraintState, revertConstraintState, nodes);
         }
     }
-    pruneFieldMap(changeset, parentId, nodeMap, nodeToParent, aliases, roots, fieldsWithRootMoves, fieldsToRootChanges) {
+    pruneFieldMap(changeset, nodeMap) {
         if (changeset === undefined) {
             return undefined;
         }
         const prunedChangeset = new Map();
         for (const [field, fieldChange] of changeset) {
             const handler = getChangeHandler(this.fieldKinds, fieldChange.fieldKind);
-            const prunedFieldChangeset = handler.rebaser.prune(fieldChange.change, (nodeId) => this.pruneNodeChange(nodeId, nodeMap, nodeToParent, aliases, roots, fieldsWithRootMoves, fieldsToRootChanges));
-            const fieldId = { nodeId: parentId, field };
-            const fieldIdKey = fieldIdKeyFromFieldId(fieldId);
-            const rootsWithChanges = fieldsToRootChanges.get(fieldIdKey) ?? [];
-            let hasRootWithNodeChange = false;
-            for (const rootId of rootsWithChanges) {
-                const nodeId = getFromChangeAtomIdMap(roots.nodeChanges, rootId) ?? fail("No root change found");
-                const isRootChangeEmpty = this.pruneNodeChange(nodeId, nodeMap, nodeToParent, aliases, roots, fieldsWithRootMoves, fieldsToRootChanges) === undefined;
-                if (isRootChangeEmpty) {
-                    roots.nodeChanges.delete([rootId.revision, rootId.localId]);
-                    tryRemoveDetachLocation(roots, rootId, 1);
-                }
-                else {
-                    hasRootWithNodeChange = true;
-                }
-            }
-            const hasRootChanges = hasRootWithNodeChange || fieldsWithRootMoves.get(fieldIdKey) === true;
-            if (!handler.isEmpty(prunedFieldChangeset) || hasRootChanges) {
+            const prunedFieldChangeset = handler.rebaser.prune(fieldChange.change, (nodeId) => this.pruneNodeChange(nodeId, nodeMap));
+            if (!handler.isEmpty(prunedFieldChangeset)) {
                 prunedChangeset.set(field, { ...fieldChange, change: brand(prunedFieldChangeset) });
             }
         }
         return prunedChangeset.size > 0 ? prunedChangeset : undefined;
     }
-    pruneRoots(roots, nodeMap, nodeToParent, aliases, fieldsWithRootMoves, fieldsToRootChanges) {
-        const pruned = { ...roots, nodeChanges: 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, nodeId, nodes, nodeToParent, aliases, roots, fieldsWithRootMoves, fieldsToRootChanges)
-            : undefined;
+    pruneNodeChange(nodeId, nodeMap) {
+        const changeset = nodeChangeFromId(nodeMap, nodeId);
+        const prunedFields = changeset.fieldChanges === undefined
+            ? undefined
+            : this.pruneFieldMap(changeset.fieldChanges, nodeMap);
         const prunedChange = { ...changeset, fieldChanges: prunedFields };
         if (prunedChange.fieldChanges === undefined) {
             delete prunedChange.fieldChanges;
         }
         if (isEmptyNodeChangeset(prunedChange)) {
-            const nodeIdKey = [nodeId.revision, nodeId.localId];
-            // TODO: Shouldn't we also delete all aliases associated with this node?
-            nodes.delete(nodeIdKey);
-            nodeToParent.delete(nodeIdKey);
+            nodeMap.delete([nodeId.revision, nodeId.localId]);
             return undefined;
         }
         else {
-            setInChangeAtomIdMap(nodes, nodeId, prunedChange);
+            setInChangeAtomIdMap(nodeMap, nodeId, prunedChange);
             return nodeId;
         }
     }
-    changeRevision(change, newRevision, rollbackOf) {
-        const oldRevisions = new Set(change.revisions === undefined || change.revisions.length === 0
-            ? [undefined]
-            : change.revisions.map((revInfo) => revInfo.revision));
-        const updatedFields = this.replaceFieldMapRevisions(change.fieldChanges, oldRevisions, newRevision);
-        const updatedNodes = newTupleBTree();
-        for (const [[revision, id], nodeChangeset] of change.nodeChanges.entries()) {
-            updatedNodes.set([replaceRevision(revision, oldRevisions, newRevision), id], this.replaceNodeChangesetRevisions(nodeChangeset, oldRevisions, newRevision));
-        }
-        const updatedNodeToParent = newTupleBTree();
-        for (const [[revision, id], location] of change.nodeToParent.entries()) {
-            updatedNodeToParent.set([replaceRevision(revision, oldRevisions, newRevision), id], replaceNodeLocationRevision(normalizeNodeLocation(location, change.nodeAliases), oldRevisions, newRevision));
+    getRevisions(change) {
+        const aggregated = new Set();
+        for (const revInfo of change.revisions ?? [{ revision: undefined }]) {
+            aggregated.add(revInfo.revision);
         }
+        return aggregated;
+    }
+    changeRevision(change, replacer) {
+        const updatedFields = this.replaceFieldMapRevisions(change.fieldChanges, replacer);
+        const updatedNodes = replaceIdMapRevisions(change.nodeChanges, replacer, (nodeChangeset) => this.replaceNodeChangesetRevisions(nodeChangeset, replacer));
+        const updatedNodeToParent = replaceIdMapRevisions(change.nodeToParent, replacer, (fieldId) => replaceFieldIdRevision(normalizeFieldId(fieldId, change.nodeAliases), replacer));
         const updated = {
             ...change,
             fieldChanges: updatedFields,
             nodeChanges: updatedNodes,
             nodeToParent: updatedNodeToParent,
-            rootNodes: replaceRootTableRevision(change.rootNodes, oldRevisions, newRevision, change.nodeAliases),
             // We've updated all references to old node IDs, so we no longer need an alias table.
             nodeAliases: newTupleBTree(),
-            crossFieldKeys: change.crossFieldKeys.mapEntries((key) => replaceCrossFieldKeyRevision(key, oldRevisions, newRevision), (id) => replaceFieldIdRevision(normalizeFieldId(id, change.nodeAliases), oldRevisions, newRevision)),
+            crossFieldKeys: replaceCrossFieldKeyTableRevisions(change.crossFieldKeys, replacer, change.nodeAliases),
         };
         if (change.builds !== undefined) {
-            updated.builds = replaceIdMapRevisions(change.builds, oldRevisions, newRevision);
+            updated.builds = replaceIdMapRevisions(change.builds, replacer);
         }
         if (change.destroys !== undefined) {
-            updated.destroys = replaceIdMapRevisions(change.destroys, oldRevisions, newRevision);
+            updated.destroys = replaceIdMapRevisions(change.destroys, replacer);
         }
         if (change.refreshers !== undefined) {
-            updated.refreshers = replaceIdMapRevisions(change.refreshers, oldRevisions, newRevision);
-        }
-        if (newRevision !== undefined) {
-            const revInfo = { revision: newRevision };
-            if (rollbackOf !== undefined) {
-                revInfo.rollbackOf = rollbackOf;
-            }
-            updated.revisions = [revInfo];
-        }
-        else {
-            delete updated.revisions;
+            updated.refreshers = replaceIdMapRevisions(change.refreshers, replacer);
         }
+        updated.revisions = [{ revision: replacer.updatedRevision }];
         return updated;
     }
-    replaceNodeChangesetRevisions(nodeChangeset, oldRevisions, newRevision) {
+    replaceNodeChangesetRevisions(nodeChangeset, replacer) {
         const updated = { ...nodeChangeset };
         if (nodeChangeset.fieldChanges !== undefined) {
-            updated.fieldChanges = this.replaceFieldMapRevisions(nodeChangeset.fieldChanges, oldRevisions, newRevision);
+            updated.fieldChanges = this.replaceFieldMapRevisions(nodeChangeset.fieldChanges, replacer);
         }
         return updated;
     }
-    replaceFieldMapRevisions(fields, oldRevisions, newRevision) {
+    replaceFieldMapRevisions(fields, replacer) {
         const updatedFields = new Map();
         for (const [field, fieldChange] of fields) {
-            const updatedFieldChange = getChangeHandler(this.fieldKinds, fieldChange.fieldKind).rebaser.replaceRevisions(fieldChange.change, oldRevisions, newRevision);
+            const updatedFieldChange = getChangeHandler(this.fieldKinds, fieldChange.fieldKind).rebaser.replaceRevisions(fieldChange.change, replacer);
             updatedFields.set(field, { ...fieldChange, change: brand(updatedFieldChange) });
         }
         return updatedFields;
     }
     makeCrossFieldKeyTable(fields, nodes) {
-        const keys = newCrossFieldRangeTable();
+        const keys = newCrossFieldKeyTable();
         this.populateCrossFieldKeyTableForFieldMap(keys, fields, undefined);
         nodes.forEachPair(([revision, localId], node) => {
             if (node.fieldChanges !== undefined) {
@@ -919,61 +822,48 @@ export class ModularChangeFamily {
             }
         }
     }
-    buildEditor(changeReceiver) {
-        return new ModularEditBuilder(this, this.fieldKinds, changeReceiver);
+    buildEditor(mintRevisionTag, changeReceiver) {
+        return new ModularEditBuilder(this, this.fieldKinds, changeReceiver, this.codecOptions);
     }
     createEmptyFieldChange(fieldKind) {
         const emptyChange = getChangeHandler(this.fieldKinds, fieldKind).createEmpty();
         return { fieldKind, change: brand(emptyChange) };
     }
     validateChangeset(change) {
-        const unreachableNodes = brand(change.nodeToParent.clone());
-        const unreachableCFKs = change.crossFieldKeys.clone();
-        this.validateFieldChanges(change, change.fieldChanges, undefined, unreachableNodes, unreachableCFKs);
+        let numNodes = this.validateFieldChanges(change, change.fieldChanges, undefined);
         for (const [[revision, localId], node] of change.nodeChanges.entries()) {
             if (node.fieldChanges === undefined) {
                 continue;
             }
-            const nodeId = normalizeNodeId({ revision, localId }, change.nodeAliases);
-            this.validateFieldChanges(change, node.fieldChanges, nodeId, unreachableNodes, unreachableCFKs);
-        }
-        for (const [detachIdKey, nodeId] of change.rootNodes.nodeChanges.entries()) {
-            const detachId = { revision: detachIdKey[0], localId: detachIdKey[1] };
-            const location = getNodeParent(change, nodeId);
-            assert(areEqualChangeAtomIdOpts(location.root, detachId), "Inconsistent node location");
-            const normalizedNodeId = normalizeNodeId(nodeId, change.nodeAliases);
-            unreachableNodes.delete([normalizedNodeId.revision, normalizedNodeId.localId]);
-            const fieldChanges = nodeChangeFromId(change.nodeChanges, change.nodeAliases, nodeId).fieldChanges;
-            if (fieldChanges !== undefined) {
-                this.validateFieldChanges(change, fieldChanges, normalizedNodeId, unreachableNodes, unreachableCFKs);
-            }
+            const nodeId = { revision, localId };
+            const numChildren = this.validateFieldChanges(change, node.fieldChanges, nodeId);
+            numNodes += numChildren;
         }
-        assert(unreachableNodes.size === 0, "Unreachable nodes found");
-        assert(unreachableCFKs.entries().length === 0, "Unreachable cross-field keys found");
+        assert(numNodes === change.nodeChanges.size, 0xa4d /* Node table contains unparented nodes */);
     }
     /**
-     * Asserts that each node has a correct entry in `change.nodeToParent`,
-     * and each cross field key has a correct entry in `change.crossFieldKeys`.
+     * Asserts that each child and cross field key in each field has a correct entry in
+     * `nodeToParent` or `crossFieldKeyTable`.
      * @returns the number of children found.
      */
-    validateFieldChanges(change, fieldChanges, nodeParent, unreachableNodes, unreachableCFKs) {
+    validateFieldChanges(change, fieldChanges, nodeParent) {
+        let numChildren = 0;
         for (const [field, fieldChange] of fieldChanges.entries()) {
             const fieldId = { nodeId: nodeParent, field };
             const handler = getChangeHandler(this.fieldKinds, fieldChange.fieldKind);
             for (const [child, _index] of handler.getNestedChanges(fieldChange.change)) {
-                const parentFieldId = getNodeParent(change, child);
-                assert(parentFieldId.field !== undefined && areEqualFieldIds(parentFieldId.field, fieldId), 0xa4e /* Inconsistent node parentage */);
-                unreachableNodes.delete([child.revision, child.localId]);
+                const parentFieldId = getParentFieldId(change, child);
+                assert(areEqualFieldIds(parentFieldId, fieldId), 0xa4e /* Inconsistent node parentage */);
+                numChildren += 1;
             }
             for (const keyRange of handler.getCrossFieldKeys(fieldChange.change)) {
                 const fields = getFieldsForCrossFieldKey(change, keyRange.key, keyRange.count);
-                assert(fields.length > 0, "Unregistered cross-field key");
-                for (const fieldFromLookup of fields) {
-                    assert(areEqualFieldIds(fieldFromLookup, fieldId), 0xa4f /* Inconsistent cross field keys */);
-                }
-                unreachableCFKs.delete(keyRange.key, keyRange.count);
+                assert(fields.length === 1 &&
+                    fields[0] !== undefined &&
+                    areEqualFieldIds(fields[0], fieldId), 0xa4f /* Inconsistent cross field keys */);
             }
         }
+        return numChildren;
     }
     getEffectiveChange(change) {
         if (hasConflicts(change)) {
@@ -987,8 +877,7 @@ export class ModularChangeFamily {
     muteChange(change) {
         const muted = {
             ...change,
-            rootNodes: muteRootChanges(change.rootNodes),
-            crossFieldKeys: newCrossFieldRangeTable(),
+            crossFieldKeys: newCrossFieldKeyTable(),
             fieldChanges: this.muteFieldChanges(change.fieldChanges),
             nodeChanges: brand(change.nodeChanges.mapValues((v) => this.muteNodeChange(v))),
         };
@@ -1015,20 +904,29 @@ export class ModularChangeFamily {
     }
 }
 ModularChangeFamily.emptyChange = makeModularChangeset();
-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;
+function replaceCrossFieldKeyTableRevisions(table, replacer, nodeAliases) {
+    const updated = newCrossFieldKeyTable();
+    for (const entry of table.entries()) {
+        const key = entry.start;
+        const updatedKey = replacer.getUpdatedAtomId(key);
+        const field = entry.value;
+        const normalizedFieldId = normalizeFieldId(field, nodeAliases);
+        const updatedNodeId = normalizedFieldId.nodeId === undefined
+            ? undefined
+            : replacer.getUpdatedAtomId(normalizedFieldId.nodeId);
+        const updatedValue = {
+            ...normalizedFieldId,
+            nodeId: updatedNodeId,
+        };
+        updated.set(updatedKey, entry.length, updatedValue);
+    }
+    return updated;
 }
-function replaceIdMapRevisions(map, oldRevisions, newRevision) {
+function replaceIdMapRevisions(map, replacer, valueMapper = (value) => value) {
     const updated = newTupleBTree();
-    for (const [[revision, id], value] of map.entries()) {
-        updated.set([replaceRevision(revision, oldRevisions, newRevision), id], value);
+    for (const [[revision, localId], value] of map.entries()) {
+        const newAtom = replacer.getUpdatedAtomId({ revision, localId });
+        updated.set([newAtom.revision, newAtom.localId], valueMapper(value));
     }
     return updated;
 }
@@ -1066,19 +964,6 @@ function composeBuildsDestroysAndRefreshers(change1, change2) {
             }
         }
     }
-    // It's possible to have a build and a refresher for the same root because an attach operation need not be performed in the same changeset as the corresponding build.
-    if (change1.builds !== undefined && change2.refreshers !== undefined) {
-        for (const [key, chunk] of change2.refreshers.entries()) {
-            assert(chunk.topLevelLength === 1, "Expected refresher chunk to have length 1");
-            const match = change1.builds.getPairOrNextLower(key);
-            if (match !== undefined) {
-                const [buildKey, buildChunk] = match;
-                if (buildKey[0] === key[0] && buildKey[1] + buildChunk.topLevelLength > key[1]) {
-                    allRefreshers.delete(key);
-                }
-            }
-        }
-    }
     return { allBuilds, allDestroys, allRefreshers };
 }
 function invertBuilds(builds) {
@@ -1103,51 +988,18 @@ function invertBuilds(builds) {
  * @param fieldKinds - The field kinds to delegate to.
  */
 export function* relevantRemovedRoots(change, fieldKinds) {
-    const rootIds = newChangeAtomIdRangeMap();
-    addAttachesToSet(change, rootIds);
-    addRenamesToSet(change, rootIds);
-    for (const [[revision, localId]] of change.rootNodes.nodeChanges.entries()) {
-        rootIds.set({ revision, localId }, 1, true);
-    }
-    for (const entry of rootIds.entries()) {
-        for (let offset = 0; offset < entry.length; offset++) {
-            const detachId = offsetChangeAtomId(entry.start, offset);
-            yield makeDetachedNodeId(detachId.revision, detachId.localId);
-        }
-    }
-}
-export function* getBuildIds(change) {
-    if (change.builds !== undefined) {
-        for (const [[revision, localId]] of change.builds.entries()) {
-            yield makeDetachedNodeId(revision, localId);
-        }
-    }
-}
-function addAttachesToSet(change, rootIds) {
-    // This includes each attach which does not have a corresponding detach.
-    for (const entry of change.crossFieldKeys.entries()) {
-        if (entry.start.target !== CrossFieldTarget.Destination) {
-            continue;
-        }
-        for (const detachIdEntry of change.rootNodes.newToOldId.getAll2(entry.start, entry.length)) {
-            const detachId = detachIdEntry.value ?? offsetChangeAtomId(entry.start, detachIdEntry.offset);
-            for (const detachEntry of change.crossFieldKeys.getAll2({ ...detachId, target: CrossFieldTarget.Source }, detachIdEntry.length)) {
-                if (detachEntry.value === undefined) {
-                    rootIds.set(offsetChangeAtomId(detachId, detachEntry.offset), detachEntry.length, true);
-                }
-            }
-        }
-    }
-}
-function addRenamesToSet(change, rootIds) {
-    for (const renameEntry of change.rootNodes.oldToNewId.entries()) {
-        for (const detachEntry of change.crossFieldKeys.getAll2({ ...renameEntry.start, target: CrossFieldTarget.Source }, renameEntry.length)) {
-            // We only want to include renames of nodes which are detached in the input context of the changeset.
-            // So if there is a detach for the node, the rename is not relevant.
-            if (detachEntry.value === undefined) {
-                rootIds.set(renameEntry.start, renameEntry.length, true);
+    yield* relevantRemovedRootsFromFields(change.fieldChanges, change.nodeChanges, fieldKinds);
+}
+function* relevantRemovedRootsFromFields(change, nodeChanges, fieldKinds) {
+    for (const [_, fieldChange] of change) {
+        const handler = getChangeHandler(fieldKinds, fieldChange.fieldKind);
+        const delegate = function* (node) {
+            const nodeChangeset = nodeChangeFromId(nodeChanges, node);
+            if (nodeChangeset.fieldChanges !== undefined) {
+                yield* relevantRemovedRootsFromFields(nodeChangeset.fieldChanges, nodeChanges, fieldKinds);
             }
-        }
+        };
+        yield* handler.relevantRemovedRoots(fieldChange.change, delegate);
     }
 }
 /**
@@ -1193,14 +1045,13 @@ export function updateRefreshers(change, getDetachedNode, removedRoots, requireR
             refreshers.set([root.major, brand(root.minor)], node);
         }
     }
-    const { fieldChanges, nodeChanges, maxId, revisions, constraintViolationCount, constraintViolationCountOnRevert, builds, destroys, } = change;
+    const { fieldChanges, nodeChanges, nodeToParent, nodeAliases, crossFieldKeys, maxId, revisions, constraintViolationCount, constraintViolationCountOnRevert, builds, destroys, } = change;
     return makeModularChangeset({
         fieldChanges,
         nodeChanges,
-        nodeToParent: change.nodeToParent,
-        nodeAliases: change.nodeAliases,
-        rootNodes: change.rootNodes,
-        crossFieldKeys: change.crossFieldKeys,
+        nodeToParent,
+        nodeAliases,
+        crossFieldKeys,
         maxId: maxId,
         revisions,
         constraintViolationCount,
@@ -1219,24 +1070,11 @@ export function updateRefreshers(change, getDetachedNode, removedRoots, requireR
 export function intoDelta(taggedChange, fieldKinds) {
     const change = taggedChange.change;
     const rootDelta = {};
+    const global = [];
+    const rename = [];
     if (!hasConflicts(change)) {
         // If there are no constraint violations, then tree changes apply.
-        const fieldDeltas = intoDeltaImpl(change.fieldChanges, change.nodeChanges, change.nodeAliases, fieldKinds);
-        const global = [];
-        for (const [[major, minor], nodeId] of change.rootNodes.nodeChanges.entries()) {
-            global.push({
-                id: { major, minor },
-                fields: deltaFromNodeChange(nodeChangeFromId(change.nodeChanges, change.nodeAliases, nodeId), change.nodeChanges, change.nodeAliases, fieldKinds),
-            });
-        }
-        const rename = [];
-        for (const { start: oldId, value: newId, length, } of change.rootNodes.oldToNewId.entries()) {
-            rename.push({
-                count: length,
-                oldId: makeDetachedNodeId(oldId.revision, oldId.localId),
-                newId: makeDetachedNodeId(newId.revision, newId.localId),
-            });
-        }
+        const fieldDeltas = intoDeltaImpl(change.fieldChanges, change.nodeChanges, fieldKinds, global, rename);
         if (fieldDeltas.size > 0) {
             rootDelta.fields = fieldDeltas;
         }
@@ -1282,22 +1120,24 @@ function copyDetachedNodes(detachedNodes) {
 /**
  * @param change - The change to convert into a delta.
  */
-function intoDeltaImpl(change, nodeChanges, nodeAliases, fieldKinds) {
+function intoDeltaImpl(change, nodeChanges, fieldKinds, global, rename) {
     const delta = new Map();
     for (const [field, fieldChange] of change) {
-        const fieldDelta = getChangeHandler(fieldKinds, fieldChange.fieldKind).intoDelta(fieldChange.change, (childChange) => {
-            const nodeChange = nodeChangeFromId(nodeChanges, nodeAliases, childChange);
-            return deltaFromNodeChange(nodeChange, nodeChanges, nodeAliases, fieldKinds);
+        const { local: fieldChanges, global: fieldGlobal, rename: fieldRename, } = getChangeHandler(fieldKinds, fieldChange.fieldKind).intoDelta(fieldChange.change, (childChange) => {
+            const nodeChange = nodeChangeFromId(nodeChanges, childChange);
+            return deltaFromNodeChange(nodeChange, nodeChanges, fieldKinds, global, rename);
         });
-        if (fieldDelta !== undefined && fieldDelta.length > 0) {
-            delta.set(field, fieldDelta);
+        if (fieldChanges !== undefined && fieldChanges.length > 0) {
+            delta.set(field, fieldChanges);
         }
+        fieldGlobal?.forEach((c) => global.push(c));
+        fieldRename?.forEach((r) => rename.push(r));
     }
     return delta;
 }
-function deltaFromNodeChange(change, nodeChanges, nodeAliases, fieldKinds) {
+function deltaFromNodeChange(change, nodeChanges, fieldKinds, global, rename) {
     if (change.fieldChanges !== undefined) {
-        return intoDeltaImpl(change.fieldChanges, nodeChanges, nodeAliases, fieldKinds);
+        return intoDeltaImpl(change.fieldChanges, nodeChanges, fieldKinds, global, rename);
     }
     // TODO: update the API to allow undefined to be returned here
     return new Map();
@@ -1344,22 +1184,30 @@ export function getFieldKind(fieldKinds, kind) {
 export function getChangeHandler(fieldKinds, kind) {
     return getFieldKind(fieldKinds, kind).changeHandler;
 }
-function newComposeTable(baseChange, newChange, composedRootNodes, movedCrossFieldKeys, removedCrossFieldKeys, pendingCompositions) {
+function newComposeTable(baseChange, newChange, composedNodeToParent) {
     return {
-        rebaseVersion: Math.max(baseChange.rebaseVersion, newChange.rebaseVersion),
-        entries: newDetachedEntryMap(),
+        ...newCrossFieldTable(),
         baseChange,
         newChange,
         fieldToContext: new Map(),
         newFieldToBaseField: new Map(),
         newToBaseNodeId: newTupleBTree(),
         composedNodes: new Set(),
-        movedNodeToParent: newTupleBTree(),
-        composedRootNodes,
-        movedCrossFieldKeys,
-        removedCrossFieldKeys,
-        renamesToDelete: newChangeAtomIdRangeMap(),
-        pendingCompositions,
+        composedNodeToParent,
+        pendingCompositions: {
+            nodeIdsToCompose: [],
+            affectedBaseFields: newTupleBTree(),
+            affectedNewFields: newTupleBTree(),
+        },
+    };
+}
+function newCrossFieldTable() {
+    return {
+        srcTable: newChangeAtomIdRangeMap(),
+        dstTable: newChangeAtomIdRangeMap(),
+        srcDependents: newChangeAtomIdRangeMap(),
+        dstDependents: newChangeAtomIdRangeMap(),
+        invalidatedFields: new Set(),
     };
 }
 function newConstraintState(violationCount) {
@@ -1367,354 +1215,147 @@ function newConstraintState(violationCount) {
         violationCount,
     };
 }
-class InvertNodeManagerI {
-    constructor(table, fieldId) {
-        this.table = table;
-        this.fieldId = fieldId;
+class CrossFieldManagerI {
+    constructor(crossFieldTable, currentFieldKey, allowInval = true) {
+        this.crossFieldTable = crossFieldTable;
+        this.currentFieldKey = currentFieldKey;
+        this.allowInval = allowInval;
     }
-    invertDetach(detachId, count, nodeChange, newAttachId) {
-        if (nodeChange !== undefined) {
-            assert(count === 1, "A node change should only affect one node");
-            const attachEntry = firstAttachIdFromDetachId(this.table.change.rootNodes, detachId, count);
-            const attachFieldEntry = this.table.change.crossFieldKeys.getFirst({ target: CrossFieldTarget.Destination, ...attachEntry.value }, count);
-            if (attachFieldEntry.value !== undefined) {
-                setInCrossFieldMap(this.table.entries, attachEntry.value, count, nodeChange);
-                this.table.invalidatedFields.add(fieldChangeFromId(this.table.change, attachFieldEntry.value));
-            }
-            else {
-                assignRootChange(this.table.invertedRoots, this.table.invertedNodeToParent, attachEntry.value, nodeChange, this.fieldId, this.table.change.rebaseVersion);
-            }
-        }
-        if (!areEqualChangeAtomIds(detachId, newAttachId)) {
-            for (const entry of doesChangeAttachNodes(this.table.change.crossFieldKeys, detachId, count)) {
-                if (!entry.value) {
-                    this.table.attachToDetachId.set(newAttachId, count, detachId);
-                    this.table.invertedRoots.detachLocations.set(detachId, count, this.fieldId);
+    set(target, revision, id, count, newValue, invalidateDependents) {
+        if (invalidateDependents && this.allowInval) {
+            const lastChangedId = id + count - 1;
+            let firstId = id;
+            while (firstId <= lastChangedId) {
+                const dependentEntry = getFirstFromCrossFieldMap(this.getDependents(target), revision, firstId, lastChangedId - firstId + 1);
+                if (dependentEntry.value !== undefined) {
+                    this.crossFieldTable.invalidatedFields.add(dependentEntry.value);
                 }
+                firstId = brand(firstId + dependentEntry.length);
             }
         }
+        setInCrossFieldMap(this.getMap(target), revision, id, count, newValue);
     }
-    invertAttach(attachId, count) {
-        let countToProcess = count;
-        const detachIdEntry = firstDetachIdFromAttachId(this.table.change.rootNodes, attachId, countToProcess);
-        countToProcess = detachIdEntry.length;
-        const detachEntry = getFirstFieldForCrossFieldKey(this.table.change, { target: 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 } };
-        }
-        else {
-            // This node is detached in the input context of the original change.
-            const nodeIdEntry = rangeQueryChangeAtomIdMap(this.table.change.rootNodes.nodeChanges, detachIdEntry.value, countToProcess);
-            countToProcess = nodeIdEntry.length;
-            result = {
-                value: { nodeChange: nodeIdEntry.value, detachId: detachIdEntry.value },
-                length: countToProcess,
-            };
-        }
-        if (result.value?.nodeChange !== undefined) {
-            setInChangeAtomIdMap(this.table.invertedNodeToParent, result.value.nodeChange, {
-                field: this.fieldId,
-            });
+    get(target, revision, id, count, addDependency) {
+        if (addDependency) {
+            // We assume that if there is already an entry for this ID it is because
+            // a field handler has called compose on the same node multiple times.
+            // In this case we only want to update the latest version, so we overwrite the dependency.
+            setInCrossFieldMap(this.getDependents(target), revision, id, count, this.currentFieldKey);
         }
-        return result;
+        return getFirstFromCrossFieldMap(this.getMap(target), revision, id, count);
+    }
+    getMap(target) {
+        return target === CrossFieldTarget.Source
+            ? this.crossFieldTable.srcTable
+            : this.crossFieldTable.dstTable;
+    }
+    getDependents(target) {
+        return target === CrossFieldTarget.Source
+            ? this.crossFieldTable.srcDependents
+            : this.crossFieldTable.dstDependents;
     }
 }
-class RebaseNodeManagerI {
-    constructor(table, fieldId, allowInval = true) {
-        this.table = table;
+class InvertManager extends CrossFieldManagerI {
+    constructor(table, field, fieldId, allowInval = true) {
+        super(table, field, allowInval);
         this.fieldId = fieldId;
-        this.allowInval = allowInval;
     }
-    getNewChangesForBaseAttach(baseAttachId, count) {
-        let countToProcess = count;
-        const detachEntry = firstDetachIdFromAttachId(this.table.baseChange.rootNodes, baseAttachId, countToProcess);
-        countToProcess = detachEntry.length;
-        const nodeEntry = rangeQueryChangeAtomIdMap(this.table.newChange.rootNodes.nodeChanges, detachEntry.value, countToProcess);
-        countToProcess = nodeEntry.length;
-        const newNodeId = nodeEntry.value;
-        const newRenameEntry = this.table.newChange.rootNodes.oldToNewId.getFirst(detachEntry.value, countToProcess);
-        countToProcess = newRenameEntry.length;
-        let result;
-        // eslint-disable-next-line unicorn/prefer-ternary
-        if (newNodeId !== undefined || newRenameEntry.value !== undefined) {
-            result = {
-                ...newRenameEntry,
-                value: { detachId: newRenameEntry.value, nodeChange: newNodeId },
-            };
-        }
-        else {
-            // This handles the case where the base changeset has moved these nodes,
-            // meaning they were attached in the input context of the base changeset.
-            result = this.table.entries.getFirst(baseAttachId, countToProcess);
-        }
-        // TODO: Consider moving these two checks into a separate method so that this function has no side effects.
-        if (result.value?.detachId !== undefined) {
-            this.table.rebasedDetachLocations.set(result.value.detachId, result.length, this.fieldId);
-        }
-        if (result.value?.nodeChange !== undefined) {
-            setInChangeAtomIdMap(this.table.rebasedNodeToParent, result.value.nodeChange, {
-                field: this.fieldId,
-            });
-        }
-        return result;
-    }
-    rebaseOverDetach(baseDetachId, count, newDetachId, nodeChange, cellRename) {
-        let countToProcess = count;
-        const attachIdEntry = firstAttachIdFromDetachId(this.table.baseRoots, baseDetachId, countToProcess);
-        const baseAttachId = attachIdEntry.value;
-        countToProcess = attachIdEntry.length;
-        const attachFieldEntry = getFirstFieldForCrossFieldKey(this.table.baseChange, { ...baseAttachId, target: CrossFieldTarget.Destination }, countToProcess);
-        countToProcess = attachFieldEntry.length;
-        const detachedMoveEntry = this.table.baseChange.rootNodes.outputDetachLocations.getFirst(baseDetachId, countToProcess);
-        countToProcess = detachedMoveEntry.length;
-        const destinationField = attachFieldEntry.value ?? detachedMoveEntry.value;
-        if (destinationField !== undefined) {
-            // The base detach is part of a move (or move of detach location) in the base changeset.
-            setInCrossFieldMap(this.table.entries, baseAttachId, countToProcess, {
-                nodeChange,
-                detachId: newDetachId,
-                cellRename,
-            });
-            if (nodeChange !== undefined || newDetachId !== undefined) {
-                this.invalidateBaseFields([destinationField]);
-            }
-        }
-        if (attachFieldEntry.value === undefined) {
-            // These nodes are detached in the output context of the base changeset.
-            if (nodeChange !== undefined) {
-                assignRootChange(this.table.rebasedRootNodes, this.table.rebasedNodeToParent, baseAttachId, nodeChange, this.fieldId, this.table.rebaseVersion);
-            }
-            if (newDetachId !== undefined) {
-                addNodeRename(this.table.rebasedRootNodes, baseAttachId, newDetachId, countToProcess, this.fieldId);
-            }
-        }
-        if (newDetachId !== undefined) {
-            this.table.movedDetaches.set(newDetachId, countToProcess, true);
-        }
-        if (countToProcess < count) {
-            const remainingCount = count - countToProcess;
-            const nextDetachId = newDetachId !== undefined
-                ? offsetChangeAtomId(newDetachId, countToProcess)
-                : undefined;
-            this.rebaseOverDetach(offsetChangeAtomId(baseDetachId, countToProcess), remainingCount, nextDetachId, nodeChange);
-        }
-    }
-    addDetach(id, count) {
-        this.table.rebasedDetachLocations.set(id, count, this.fieldId);
-    }
-    removeDetach(id, count) {
-        this.table.movedDetaches.set(id, count, true);
-    }
-    doesBaseAttachNodes(id, count) {
-        let countToProcess = count;
-        const attachEntry = getFirstAttachField(this.table.baseChange.crossFieldKeys, id, countToProcess);
-        countToProcess = attachEntry.length;
-        return { start: id, value: attachEntry.value !== undefined, length: countToProcess };
-    }
-    getBaseRename(id, count) {
-        return this.table.baseChange.rootNodes.oldToNewId.getFirst(id, count);
-    }
-    getNewRenameForBaseRename(baseRenameTo, count) {
-        let countToProcess = count;
-        const inputEntry = firstDetachIdFromAttachId(this.table.baseChange.rootNodes, baseRenameTo, countToProcess);
-        const attachEntry = getFirstAttachField(this.table.baseChange.crossFieldKeys, baseRenameTo, countToProcess);
-        countToProcess = attachEntry.length;
-        if (attachEntry.value !== undefined) {
-            // These nodes are attached in the output context of the base changeset.
-            return { value: undefined, length: countToProcess };
-        }
-        countToProcess = inputEntry.length;
-        const inputId = inputEntry.value;
-        const moveEntry = this.table.entries.getFirst(inputId, countToProcess);
-        countToProcess = moveEntry.length;
-        if (moveEntry.value !== undefined) {
-            return { ...moveEntry, value: moveEntry.value.cellRename ?? moveEntry.value.detachId };
-        }
-        return this.table.newChange.rootNodes.oldToNewId.getFirst(inputId, countToProcess);
-    }
-    invalidateBaseFields(fields) {
-        if (this.allowInval) {
-            for (const fieldId of fields) {
-                this.table.affectedBaseFields.set(fieldIdKeyFromFieldId(fieldId), true);
-            }
-        }
+    onMoveIn(id) {
+        setInChangeAtomIdMap(this.table.invertedNodeToParent, id, this.fieldId);
     }
-}
-function assignRootChange(table, nodeToParent, detachId, nodeId, detachLocation, rebaseVersion) {
-    assert(rebaseVersion >= 2 || detachLocation !== undefined, "All root changes need a detach location to support compatibility with older client versions");
-    setInChangeAtomIdMap(table.nodeChanges, detachId, nodeId);
-    if (nodeToParent !== undefined) {
-        setInChangeAtomIdMap(nodeToParent, nodeId, { root: detachId });
+    moveKey(target, revision, id, count) {
+        assert(false, 0x9c5 /* Keys should not be moved manually during invert */);
+    }
+    get table() {
+        return this.crossFieldTable;
     }
-    table.detachLocations.set(detachId, 1, detachLocation);
 }
-class ComposeNodeManagerI {
-    constructor(table, fieldId, allowInval = true) {
-        this.table = table;
+class RebaseManager extends CrossFieldManagerI {
+    constructor(table, currentField, fieldId, allowInval = true) {
+        super(table, currentField, allowInval);
         this.fieldId = fieldId;
-        this.allowInval = allowInval;
     }
-    getNewChangesForBaseDetach(baseDetachId, count) {
-        let countToProcess = count;
-        const baseAttachEntry = getFirstFieldForCrossFieldKey(this.table.baseChange, { target: CrossFieldTarget.Destination, ...baseDetachId }, countToProcess);
-        countToProcess = baseAttachEntry.length;
-        let result;
-        if (baseAttachEntry.value !== undefined) {
-            // The base detach was part of a move.
-            // We check if we've previously seen a node change at the move destination.
-            const entry = this.table.entries.getFirst(baseDetachId, countToProcess);
-            result = { value: entry.value, length: entry.length };
-        }
-        else {
-            // The detached nodes are still detached in the new change's input context.
-            const rootEntry = rangeQueryChangeAtomIdMap(this.table.newChange.rootNodes.nodeChanges, baseDetachId, countToProcess);
-            countToProcess = rootEntry.length;
-            const newRenameEntry = this.table.newChange.rootNodes.oldToNewId.getFirst(baseDetachId, countToProcess);
-            countToProcess = newRenameEntry.length;
-            result = {
-                value: { nodeChange: rootEntry.value, detachId: newRenameEntry.value },
-                length: countToProcess,
-            };
-        }
-        // TODO: Consider moving this to a separate method so that this method can be side-effect free.
-        if (result.value?.nodeChange !== undefined) {
-            setInChangeAtomIdMap(this.table.movedNodeToParent, result.value.nodeChange, {
-                field: this.fieldId,
-            });
-        }
-        return result;
-    }
-    composeAttachDetach(baseAttachId, newDetachId, count) {
-        let countToProcess = count;
-        const newAttachEntry = getFirstAttachField(this.table.newChange.crossFieldKeys, newDetachId, countToProcess);
-        countToProcess = newAttachEntry.length;
-        // Both changes can have the same ID if they came from inverse changesets.
-        // If the new detach is part of a move,
-        // then both input changesets contain the attach cross-field key for this ID.
-        // The new attach may still exist in the composed changeset so we do not remove it here.
-        // The new attach will typically cancel with a base detach,
-        // in which case the cross-field key will be removed in `composeDetachAttach`.
-        const hasNewAttachWithBaseAttachId = areEqualChangeAtomIds(baseAttachId, newDetachId) && newAttachEntry.value !== undefined;
-        if (!hasNewAttachWithBaseAttachId) {
-            this.table.removedCrossFieldKeys.set({ ...baseAttachId, target: CrossFieldTarget.Destination }, countToProcess, true);
-        }
-        const baseDetachEntry = getFirstDetachField(this.table.baseChange.crossFieldKeys, baseAttachId, countToProcess);
-        countToProcess = baseDetachEntry.length;
-        const baseRootIdEntry = firstDetachIdFromAttachId(this.table.baseChange.rootNodes, baseAttachId, countToProcess);
-        countToProcess = baseRootIdEntry.length;
-        const baseDetachId = baseRootIdEntry.value;
-        if (baseDetachEntry.value !== undefined) {
-            // The base change moves these nodes.
-            const prevEntry = this.table.entries.getFirst(baseAttachId, baseDetachEntry.length).value ?? {};
-            this.table.entries.set(baseAttachId, baseDetachEntry.length, {
-                ...prevEntry,
-                detachId: newDetachId,
-            });
-            // The new detach will replace the base detach, so we remove the key for the base detach, unless they have the same ID.
-            if (!areEqualChangeAtomIds(baseAttachId, newDetachId)) {
-                this.table.removedCrossFieldKeys.set({ ...baseAttachId, target: CrossFieldTarget.Source }, countToProcess, true);
+    set(target, revision, id, count, newValue, invalidateDependents) {
+        if (invalidateDependents && this.allowInval) {
+            const newFieldIds = getFieldsForCrossFieldKey(this.table.newChange, {
+                target,
+                revision,
+                localId: id,
+            }, count);
+            assert(newFieldIds.length === 0, 0x9c6 /* TODO: Modifying a cross-field key from the new changeset is currently unsupported */);
+            const baseFieldIds = getFieldsForCrossFieldKey(this.table.baseChange, {
+                target,
+                revision,
+                localId: id,
+            }, count);
+            assert(baseFieldIds.length > 0, 0x9c7 /* Cross field key not registered in base or new change */);
+            for (const baseFieldId of baseFieldIds) {
+                this.table.affectedBaseFields.set([baseFieldId.nodeId?.revision, baseFieldId.nodeId?.localId, baseFieldId.field], true);
             }
-            this.table.movedCrossFieldKeys.set({ ...newDetachId, target: CrossFieldTarget.Source }, countToProcess, baseDetachEntry.value);
-            this.invalidateBaseFields([baseDetachEntry.value]);
         }
-        else {
-            const baseDetachLocationEntry = this.table.baseChange.rootNodes.detachLocations.getFirst(baseDetachId, countToProcess);
-            countToProcess = baseDetachLocationEntry.length;
-            // These nodes were detached in the base change's input context,
-            // so the net effect of the two changes is a rename.
-            appendNodeRename(this.table.composedRootNodes, baseAttachId, newDetachId, baseDetachEntry.length, this.table.baseChange.rootNodes, baseDetachLocationEntry.value ?? this.fieldId);
-            this.table.removedCrossFieldKeys.set({ ...newDetachId, target: CrossFieldTarget.Source }, countToProcess, true);
-        }
-        if (newAttachEntry.value === undefined) {
-            const newOutputDetachLocationEntry = this.table.newChange.rootNodes.outputDetachLocations.getFirst(newDetachId, countToProcess);
-            countToProcess = newOutputDetachLocationEntry.length;
-            this.table.composedRootNodes.outputDetachLocations.set(newDetachId, countToProcess, newOutputDetachLocationEntry.value ?? this.fieldId);
-        }
-        if (countToProcess < count) {
-            const remainingCount = count - countToProcess;
-            this.composeAttachDetach(offsetChangeAtomId(baseAttachId, countToProcess), offsetChangeAtomId(newDetachId, countToProcess), remainingCount);
-        }
-    }
-    sendNewChangesToBaseSourceLocation(baseAttachId, newChanges) {
-        const { value: baseDetachId } = firstDetachIdFromAttachId(this.table.baseChange.rootNodes, baseAttachId, 1);
-        const detachFields = getFieldsForCrossFieldKey(this.table.baseChange, {
-            ...baseDetachId,
-            target: CrossFieldTarget.Source,
-        }, 1);
-        if (detachFields.length > 0) {
-            // The base attach is part of a move in the base changeset.
-            const prevEntry = this.table.entries.getFirst(baseDetachId, 1).value ?? {};
-            this.table.entries.set(baseDetachId, 1, { ...prevEntry, nodeChange: newChanges });
-            if (newChanges !== undefined) {
-                this.invalidateBaseFields(detachFields);
-            }
-        }
-        else {
-            const baseNodeId = getFromChangeAtomIdMap(this.table.baseChange.rootNodes.nodeChanges, baseDetachId);
-            if (baseNodeId !== undefined) {
-                addNodesToCompose(this.table, baseNodeId, newChanges);
+        super.set(target, revision, id, count, newValue, invalidateDependents);
+    }
+    onMoveIn(id) {
+        setInChangeAtomIdMap(this.table.rebasedNodeToParent, id, this.fieldId);
+    }
+    moveKey(target, revision, id, count) {
+        this.table.rebasedCrossFieldKeys.set({ target, revision, localId: id }, count, this.fieldId);
+    }
+    get table() {
+        return this.crossFieldTable;
+    }
+}
+// TODO: Deduplicate this with RebaseTable
+class ComposeManager extends CrossFieldManagerI {
+    constructor(table, currentField, fieldId, allowInval = true) {
+        super(table, currentField, allowInval);
+        this.fieldId = fieldId;
+    }
+    set(target, revision, id, count, newValue, invalidateDependents) {
+        if (invalidateDependents && this.allowInval) {
+            const newFieldIds = getFieldsForCrossFieldKey(this.table.newChange, {
+                target,
+                revision,
+                localId: id,
+            }, count);
+            if (newFieldIds.length > 0) {
+                for (const newFieldId of newFieldIds) {
+                    this.table.pendingCompositions.affectedNewFields.set([newFieldId.nodeId?.revision, newFieldId.nodeId?.localId, newFieldId.field], true);
+                }
             }
             else {
-                assignRootChange(this.table.composedRootNodes, this.table.movedNodeToParent, baseDetachId, newChanges, this.fieldId, this.table.rebaseVersion);
+                const baseFieldIds = getFieldsForCrossFieldKey(this.table.baseChange, {
+                    target,
+                    revision,
+                    localId: id,
+                }, count);
+                assert(baseFieldIds.length > 0, 0x9c8 /* Cross field key not registered in base or new change */);
+                for (const baseFieldId of baseFieldIds) {
+                    this.table.pendingCompositions.affectedBaseFields.set([baseFieldId.nodeId?.revision, baseFieldId.nodeId?.localId, baseFieldId.field], true);
+                }
             }
         }
+        super.set(target, revision, id, count, newValue, invalidateDependents);
     }
-    areSameNodes(baseDetachId, newAttachId, count) {
-        const renamedDetachEntry = firstAttachIdFromDetachId(this.table.composedRootNodes, baseDetachId, count);
-        const isReattachOfSameNodes = areEqualChangeAtomIds(renamedDetachEntry.value, newAttachId);
-        return { ...renamedDetachEntry, value: isReattachOfSameNodes };
-    }
-    composeDetachAttach(baseDetachId, newAttachId, count, composeToPin) {
-        const areSameEntry = this.areSameNodes(baseDetachId, newAttachId, count);
-        const countToProcess = areSameEntry.length;
-        if (areSameEntry.value) {
-            // These nodes have been moved back to their original location, so the composed changeset should not have any renames for them.
-            // Note that deleting the rename from `this.table.composedRootNodes` would change the result of this method
-            // if it were rerun due to the field being invalidated, so we instead record that the rename should be deleted later.
-            this.table.renamesToDelete.set(baseDetachId, countToProcess, true);
-        }
-        if (composeToPin) {
-            this.table.movedCrossFieldKeys.set({ target: CrossFieldTarget.Source, ...newAttachId }, countToProcess, this.fieldId);
-            if (!areEqualChangeAtomIds(baseDetachId, newAttachId)) {
-                // The pin will have `newAttachId` as both its detach and attach ID.
-                // So we remove `baseDetachId` unless that is equal to the pin's detach ID.
-                this.table.removedCrossFieldKeys.set({ target: CrossFieldTarget.Source, ...baseDetachId }, countToProcess, true);
-            }
-            // Note that while change2 should already have this key, change1 may have a rollback for the same ID in a different location.
-            // In that case, change1's attach should be canceled out by a detach from change2.
-            // Here we make sure that the composed change has the correct location (this field) for the attach ID.
-            this.table.movedCrossFieldKeys.set({ target: CrossFieldTarget.Destination, ...newAttachId }, countToProcess, this.fieldId);
-        }
-        else {
-            this.table.removedCrossFieldKeys.set({ target: CrossFieldTarget.Source, ...baseDetachId }, countToProcess, true);
-            this.table.removedCrossFieldKeys.set({ target: CrossFieldTarget.Destination, ...newAttachId }, countToProcess, true);
-        }
-        if (countToProcess < count) {
-            this.composeAttachDetach(offsetChangeAtomId(baseDetachId, countToProcess), offsetChangeAtomId(newAttachId, countToProcess), count - countToProcess);
-        }
+    onMoveIn(id) {
+        setInChangeAtomIdMap(this.table.composedNodeToParent, id, this.fieldId);
     }
-    invalidateBaseFields(fields) {
-        if (this.allowInval) {
-            for (const fieldId of fields) {
-                this.table.pendingCompositions.affectedBaseFields.set(fieldIdKeyFromFieldId(fieldId), true);
-            }
-        }
+    moveKey(target, revision, id, count) {
+        throw new Error("Moving cross-field keys during compose is currently unsupported");
+    }
+    get table() {
+        return this.crossFieldTable;
     }
 }
 function makeModularChangeset(props = {
     maxId: -1,
 }) {
     const changeset = {
-        rebaseVersion: props.rebaseVersion ?? 1,
         fieldChanges: props.fieldChanges ?? new Map(),
         nodeChanges: props.nodeChanges ?? newTupleBTree(),
-        rootNodes: props.rootNodes ?? newRootTable(),
         nodeToParent: props.nodeToParent ?? newTupleBTree(),
         nodeAliases: props.nodeAliases ?? newTupleBTree(),
-        crossFieldKeys: props.crossFieldKeys ?? newCrossFieldRangeTable(),
+        crossFieldKeys: props.crossFieldKeys ?? newCrossFieldKeyTable(),
     };
     if (props.revisions !== undefined && props.revisions.length > 0) {
         changeset.revisions = props.revisions;
@@ -1729,6 +1370,12 @@ function makeModularChangeset(props = {
         props.constraintViolationCountOnRevert > 0) {
         changeset.constraintViolationCountOnRevert = props.constraintViolationCountOnRevert;
     }
+    if (props.noChangeConstraint !== undefined) {
+        changeset.noChangeConstraint = props.noChangeConstraint;
+    }
+    if (props.noChangeConstraintOnRevert !== undefined) {
+        changeset.noChangeConstraintOnRevert = props.noChangeConstraintOnRevert;
+    }
     if (props.builds !== undefined && props.builds.size > 0) {
         changeset.builds = props.builds;
     }
@@ -1741,14 +1388,12 @@ function makeModularChangeset(props = {
     return changeset;
 }
 export class ModularEditBuilder extends EditBuilder {
-    constructor(family, fieldKinds, changeReceiver) {
+    constructor(family, fieldKinds, changeReceiver, codecOptions) {
         super(family, changeReceiver);
         this.fieldKinds = fieldKinds;
         this.transactionDepth = 0;
         this.idAllocator = idAllocatorFromMaxId();
-    }
-    isInTransaction() {
-        return this.transactionDepth > 0;
+        this.codecOptions = codecOptions;
     }
     enterTransaction() {
         this.transactionDepth += 1;
@@ -1800,8 +1445,7 @@ export class ModularEditBuilder extends EditBuilder {
             fieldChange: { fieldKind, change },
             nodeChanges: newTupleBTree(),
             nodeToParent: newTupleBTree(),
-            crossFieldKeys: newCrossFieldRangeTable(),
-            rootNodes: newRootTable(),
+            crossFieldKeys: newCrossFieldKeyTable(),
             idAllocator: this.idAllocator,
             localCrossFieldKeys,
             revision,
@@ -1820,7 +1464,6 @@ export class ModularEditBuilder extends EditBuilder {
                 ? makeModularChangeset({
                     maxId: this.idAllocator.getMaxId(),
                     builds: change.builds,
-                    rootNodes: renameTableFromRenameDescriptions(change.renames ?? []),
                     revisions: [{ revision: change.revision }],
                 })
                 : buildModularChangesetFromField({
@@ -1831,14 +1474,13 @@ export class ModularEditBuilder extends EditBuilder {
                     },
                     nodeChanges: newTupleBTree(),
                     nodeToParent: newTupleBTree(),
-                    crossFieldKeys: newCrossFieldRangeTable(),
-                    rootNodes: newRootTable(),
+                    crossFieldKeys: newCrossFieldKeyTable(),
                     idAllocator: this.idAllocator,
                     localCrossFieldKeys: getChangeHandler(this.fieldKinds, change.fieldKind).getCrossFieldKeys(change.change),
                     revision: change.revision,
                 }));
         });
-        const revInfo = Array.from(revisions).map((revision) => ({ revision }));
+        const revInfo = [...revisions].map((revision) => ({ revision }));
         const composedChange = {
             ...this.changeFamily.rebaser.compose(changeMaps),
             revisions: revInfo,
@@ -1861,8 +1503,7 @@ export class ModularEditBuilder extends EditBuilder {
             nodeChange,
             nodeChanges: newTupleBTree(),
             nodeToParent: newTupleBTree(),
-            crossFieldKeys: newCrossFieldRangeTable(),
-            rootNodes: newRootTable(),
+            crossFieldKeys: newCrossFieldKeyTable(),
             idAllocator: this.idAllocator,
             revision,
         }), revision));
@@ -1876,27 +1517,43 @@ export class ModularEditBuilder extends EditBuilder {
             nodeChange,
             nodeChanges: newTupleBTree(),
             nodeToParent: newTupleBTree(),
-            crossFieldKeys: newCrossFieldRangeTable(),
-            rootNodes: newRootTable(),
+            crossFieldKeys: newCrossFieldKeyTable(),
             idAllocator: this.idAllocator,
             revision,
         }), revision));
     }
+    addNoChangeConstraint(revision) {
+        if (lt(this.codecOptions.minVersionForCollab, FluidClientVersion.v2_80)) {
+            throw new UsageError(`No change constraints require min client version of at least ${FluidClientVersion.v2_80}`);
+        }
+        const changeset = makeModularChangeset({
+            maxId: -1,
+            noChangeConstraint: { violated: false },
+        });
+        this.applyChange(tagChange(changeset, revision));
+    }
+    addNoChangeConstraintOnRevert(revision) {
+        if (lt(this.codecOptions.minVersionForCollab, FluidClientVersion.v2_80)) {
+            throw new UsageError(`No change constraints require min client version of at least ${FluidClientVersion.v2_80}`);
+        }
+        const changeset = makeModularChangeset({
+            maxId: -1,
+            noChangeConstraintOnRevert: { violated: false },
+        });
+        this.applyChange(tagChange(changeset, revision));
+    }
 }
-export function buildModularChangesetFromField(props) {
-    const { path, fieldChange, nodeChanges, nodeToParent, crossFieldKeys, rootNodes, idAllocator = idAllocatorFromMaxId(), localCrossFieldKeys = [], childId, revision, } = props;
+function buildModularChangesetFromField(props) {
+    const { path, fieldChange, nodeChanges, nodeToParent, crossFieldKeys, idAllocator = idAllocatorFromMaxId(), localCrossFieldKeys = [], childId, revision, } = props;
     const fieldChanges = new Map([[path.field, fieldChange]]);
     if (path.parent === undefined) {
-        const field = { nodeId: undefined, field: path.field };
         for (const { key, count } of localCrossFieldKeys) {
-            crossFieldKeys.set(key, count, field);
+            crossFieldKeys.set(key, count, { nodeId: undefined, field: path.field });
         }
         if (childId !== undefined) {
             setInChangeAtomIdMap(nodeToParent, childId, {
-                field: {
-                    nodeId: undefined,
-                    field: path.field,
-                },
+                nodeId: undefined,
+                field: path.field,
             });
         }
         return makeModularChangeset({
@@ -1904,7 +1561,6 @@ export function buildModularChangesetFromField(props) {
             nodeChanges,
             nodeToParent,
             crossFieldKeys,
-            rootNodes,
             maxId: idAllocator.getMaxId(),
             revisions: [{ revision }],
         });
@@ -1913,13 +1569,13 @@ export function buildModularChangesetFromField(props) {
         fieldChanges,
     };
     const parentId = { localId: brand(idAllocator.allocate()), revision };
-    const fieldId = { nodeId: parentId, field: path.field };
     for (const { key, count } of localCrossFieldKeys) {
         crossFieldKeys.set(key, count, { nodeId: parentId, field: path.field });
     }
     if (childId !== undefined) {
         setInChangeAtomIdMap(nodeToParent, childId, {
-            field: fieldId,
+            nodeId: parentId,
+            field: path.field,
         });
     }
     return buildModularChangesetFromNode({
@@ -1928,57 +1584,55 @@ export function buildModularChangesetFromField(props) {
         nodeChanges,
         nodeToParent,
         crossFieldKeys,
-        rootNodes,
         idAllocator,
         revision,
         nodeId: parentId,
     });
 }
 function buildModularChangesetFromNode(props) {
-    const { path, nodeId = { localId: brand(props.idAllocator.allocate()), revision: props.revision }, } = props;
-    setInChangeAtomIdMap(props.nodeChanges, nodeId, props.nodeChange);
-    if (isDetachedUpPathRoot(path)) {
-        props.rootNodes.nodeChanges.set([path.detachedNodeId.major, brand(path.detachedNodeId.minor)], nodeId);
-        return makeModularChangeset({
-            rootNodes: props.rootNodes,
-            nodeChanges: props.nodeChanges,
-            nodeToParent: props.nodeToParent,
-            crossFieldKeys: props.crossFieldKeys,
-            maxId: props.idAllocator.getMaxId(),
-            revisions: [{ revision: props.revision }],
-        });
-    }
-    else {
-        const fieldChangeset = genericFieldKind.changeHandler.editor.buildChildChanges([
-            [path.parentIndex, nodeId],
-        ]);
-        const fieldChange = {
-            fieldKind: genericFieldKind.identifier,
-            change: fieldChangeset,
-        };
-        return buildModularChangesetFromField({
-            ...props,
-            path: { parent: path.parent, field: path.parentField },
-            fieldChange,
-            localCrossFieldKeys: [],
-            childId: nodeId,
-        });
-    }
-}
-function renameTableFromRenameDescriptions(renames) {
-    const table = newRootTable();
-    for (const rename of renames) {
-        addNodeRename(table, rename.oldId, rename.newId, rename.count, rename.detachLocation);
-    }
-    return table;
+    const { path, idAllocator, revision, nodeChanges, nodeChange, nodeId = { localId: brand(idAllocator.allocate()), revision }, } = props;
+    setInChangeAtomIdMap(nodeChanges, nodeId, nodeChange);
+    const fieldChangeset = genericFieldKind.changeHandler.editor.buildChildChanges([
+        [path.parentIndex, nodeId],
+    ]);
+    const fieldChange = {
+        fieldKind: genericFieldKind.identifier,
+        change: fieldChangeset,
+    };
+    return buildModularChangesetFromField({
+        ...props,
+        path: { parent: path.parent, field: path.parentField },
+        fieldChange,
+        localCrossFieldKeys: [],
+        childId: nodeId,
+    });
 }
 function getRevInfoFromTaggedChanges(changes) {
     let maxId = -1;
     const revInfos = [];
+    const revisions = new Set();
     for (const taggedChange of changes) {
         const change = taggedChange.change;
         maxId = Math.max(change.maxId ?? -1, maxId);
-        revInfos.push(...revisionInfoFromTaggedChange(taggedChange));
+        const infosToAdd = revisionInfoFromTaggedChange(taggedChange);
+        for (const info of infosToAdd) {
+            if (!revisions.has(info.revision)) {
+                revisions.add(info.revision);
+                revInfos.push(info);
+            }
+        }
+    }
+    const rolledBackRevisions = [];
+    for (const info of revInfos) {
+        if (info.rollbackOf !== undefined) {
+            rolledBackRevisions.push(info.rollbackOf);
+        }
+    }
+    rolledBackRevisions.reverse();
+    for (const revision of rolledBackRevisions) {
+        if (!revisions.has(revision)) {
+            revInfos.push({ revision });
+        }
     }
     return { maxId: brand(maxId), revInfos };
 }
@@ -1996,16 +1650,15 @@ function revisionInfoFromTaggedChange(taggedChange) {
     }
     return revInfos;
 }
-function fieldChangeFromId(change, id) {
-    const fieldId = normalizeFieldId(id, change.nodeAliases);
-    const fieldMap = fieldMapFromNodeId(change.fieldChanges, change.nodeChanges, change.nodeAliases, fieldId.nodeId);
+function fieldChangeFromId(fields, nodes, id) {
+    const fieldMap = fieldMapFromNodeId(fields, nodes, id.nodeId);
     return fieldMap.get(id.field) ?? fail(0xb25 /* No field exists for the given ID */);
 }
-function fieldMapFromNodeId(rootFieldMap, nodes, aliases, nodeId) {
+function fieldMapFromNodeId(rootFieldMap, nodes, nodeId) {
     if (nodeId === undefined) {
         return rootFieldMap;
     }
-    const node = nodeChangeFromId(nodes, aliases, nodeId);
+    const node = nodeChangeFromId(nodes, nodeId);
     assert(node.fieldChanges !== undefined, 0x9c9 /* Expected node to have field changes */);
     return node.fieldChanges;
 }
@@ -2018,78 +1671,51 @@ function rebasedFieldIdFromBaseId(table, baseId) {
 function rebasedNodeIdFromBaseNodeId(table, baseId) {
     return getFromChangeAtomIdMap(table.baseToRebasedNodeId, baseId) ?? baseId;
 }
-function nodeChangeFromId(nodes, aliases, id) {
-    const normalizedId = normalizeNodeId(id, aliases);
-    const node = getFromChangeAtomIdMap(nodes, normalizedId);
+function nodeChangeFromId(nodes, id) {
+    const node = getFromChangeAtomIdMap(nodes, id);
     assert(node !== undefined, 0x9ca /* Unknown node ID */);
     return node;
 }
 function fieldIdFromFieldIdKey([revision, localId, field]) {
-    const nodeId = localId !== undefined ? { revision, localId } : undefined;
+    const nodeId = localId === undefined ? undefined : { revision, localId };
     return { nodeId, field };
 }
-function fieldIdKeyFromFieldId(fieldId) {
-    return [fieldId.nodeId?.revision, fieldId.nodeId?.localId, fieldId.field];
-}
 function cloneNodeChangeset(nodeChangeset) {
     if (nodeChangeset.fieldChanges !== undefined) {
         return { ...nodeChangeset, fieldChanges: new Map(nodeChangeset.fieldChanges) };
     }
     return { ...nodeChangeset };
 }
-function replaceNodeLocationRevision(location, oldRevisions, newRevision) {
-    return location.field !== undefined
-        ? { field: replaceFieldIdRevision(location.field, oldRevisions, newRevision) }
-        : { root: replaceAtomRevisions(location.root, oldRevisions, newRevision) };
-}
-function replaceFieldIdRevision(fieldId, oldRevisions, newRevision) {
+function replaceFieldIdRevision(fieldId, replacer) {
     if (fieldId.nodeId === undefined) {
         return fieldId;
     }
     return {
         ...fieldId,
-        nodeId: replaceAtomRevisions(fieldId.nodeId, oldRevisions, newRevision),
+        nodeId: replacer.getUpdatedAtomId(fieldId.nodeId),
     };
 }
-export function getNodeParent(changeset, nodeId) {
-    const normalizedNodeId = normalizeNodeId(nodeId, changeset.nodeAliases);
-    const location = getFromChangeAtomIdMap(changeset.nodeToParent, normalizedNodeId);
-    assert(location !== undefined, 0x9cb /* Parent field should be defined */);
-    if (location.field !== undefined) {
-        return { field: normalizeFieldId(location.field, changeset.nodeAliases) };
-    }
-    return location;
+export function getParentFieldId(changeset, nodeId) {
+    const parentId = getFromChangeAtomIdMap(changeset.nodeToParent, nodeId);
+    assert(parentId !== undefined, 0x9cb /* Parent field should be defined */);
+    return normalizeFieldId(parentId, changeset.nodeAliases);
 }
 function getFieldsForCrossFieldKey(changeset, key, count) {
     return changeset.crossFieldKeys
         .getAll(key, count)
         .map(({ value: fieldId }) => normalizeFieldId(fieldId, changeset.nodeAliases));
 }
-function getFirstFieldForCrossFieldKey(changeset, key, count) {
-    const result = changeset.crossFieldKeys.getFirst(key, count);
-    if (result.value === undefined) {
-        return result;
-    }
-    return { ...result, value: normalizeFieldId(result.value, changeset.nodeAliases) };
-}
-function normalizeNodeLocation(location, nodeAliases) {
-    if (location.field !== undefined) {
-        return { field: normalizeFieldId(location.field, nodeAliases) };
-    }
-    return location;
-}
 // This is only exported for use in test utilities.
 export function normalizeFieldId(fieldId, nodeAliases) {
-    return fieldId.nodeId !== undefined
-        ? { ...fieldId, nodeId: normalizeNodeId(fieldId.nodeId, nodeAliases) }
-        : fieldId;
+    return fieldId.nodeId === undefined
+        ? fieldId
+        : { ...fieldId, nodeId: normalizeNodeId(fieldId.nodeId, nodeAliases) };
 }
 /**
  * @returns The canonical form of nodeId, according to nodeAliases
  */
-export function normalizeNodeId(nodeId, nodeAliases) {
+function normalizeNodeId(nodeId, nodeAliases) {
     let currentId = nodeId;
-    let cycleProbeId = nodeId;
     // eslint-disable-next-line no-constant-condition
     while (true) {
         const dealiased = getFromChangeAtomIdMap(nodeAliases, currentId);
@@ -2097,13 +1723,6 @@ export function normalizeNodeId(nodeId, nodeAliases) {
             return currentId;
         }
         currentId = dealiased;
-        if (cycleProbeId !== undefined) {
-            cycleProbeId = getFromChangeAtomIdMap(nodeAliases, cycleProbeId);
-        }
-        if (cycleProbeId !== undefined) {
-            cycleProbeId = getFromChangeAtomIdMap(nodeAliases, cycleProbeId);
-        }
-        assert(!areEqualChangeAtomIdOpts(cycleProbeId, currentId), "Alias cycle detected");
     }
 }
 function hasConflicts(change) {
@@ -2112,426 +1731,4 @@ function hasConflicts(change) {
 function areEqualFieldIds(a, b) {
     return areEqualChangeAtomIdOpts(a.nodeId, b.nodeId) && a.field === b.field;
 }
-function firstAttachIdFromDetachId(roots, detachId, count) {
-    const result = roots.oldToNewId.getFirst(detachId, count);
-    return { ...result, value: result.value ?? detachId };
-}
-function firstDetachIdFromAttachId(roots, attachId, count) {
-    const result = roots.newToOldId.getFirst(attachId, count);
-    return { ...result, start: attachId, value: result.value ?? attachId };
-}
-function rebaseCrossFieldKeys(sourceTable, movedDetaches, newDetachLocations) {
-    const rebasedTable = sourceTable.clone();
-    for (const entry of movedDetaches.entries()) {
-        rebasedTable.delete({ ...entry.start, target: CrossFieldTarget.Source }, entry.length);
-    }
-    for (const entry of newDetachLocations.entries()) {
-        rebasedTable.set({ ...entry.start, target: CrossFieldTarget.Source }, entry.length, entry.value);
-    }
-    return rebasedTable;
-}
-export function newRootTable() {
-    return {
-        newToOldId: newChangeAtomIdTransform(),
-        oldToNewId: newChangeAtomIdTransform(),
-        nodeChanges: newTupleBTree(),
-        detachLocations: newChangeAtomIdRangeMap(),
-        outputDetachLocations: newChangeAtomIdRangeMap(),
-    };
-}
-function rebaseRoots(change, base, affectedBaseFields, nodesToRebase, rebasedNodeToParent, rebaseVersion) {
-    const rebasedRoots = newRootTable();
-    for (const renameEntry of change.rootNodes.oldToNewId.entries()) {
-        rebaseRename(change.rootNodes, rebasedRoots, renameEntry, base, affectedBaseFields);
-    }
-    for (const [detachIdKey, nodeId] of change.rootNodes.nodeChanges.entries()) {
-        const changes = base.rootNodes.nodeChanges.get(detachIdKey);
-        if (changes !== undefined) {
-            nodesToRebase.push([nodeId, changes]);
-        }
-        const detachId = makeChangeAtomId(detachIdKey[1], detachIdKey[0]);
-        const attachId = firstAttachIdFromDetachId(base.rootNodes, detachId, 1).value;
-        const baseAttachEntry = base.crossFieldKeys.getFirst({ target: CrossFieldTarget.Destination, ...attachId }, 1);
-        if (baseAttachEntry.value !== undefined) {
-            affectedBaseFields.set(fieldIdKeyFromFieldId(baseAttachEntry.value), true);
-            rebasedNodeToParent.delete(detachIdKey);
-        }
-        else {
-            const renamedDetachId = firstAttachIdFromDetachId(base.rootNodes, detachId, 1).value;
-            const baseOutputDetachLocation = base.rootNodes.outputDetachLocations.getFirst(renamedDetachId, 1).value;
-            if (baseOutputDetachLocation !== undefined) {
-                affectedBaseFields.set(fieldIdKeyFromFieldId(baseOutputDetachLocation), true);
-            }
-            const detachLocation = baseOutputDetachLocation ??
-                change.rootNodes.detachLocations.getFirst(detachId, 1).value;
-            // Note that `baseOutputDetachLocation` may contain a node ID from the base changeset.
-            // We will replace the detach location entry with the node ID from the rebased changeset in `fixupRebasedDetachLocations`
-            assignRootChange(rebasedRoots, rebasedNodeToParent, renamedDetachId, nodeId, detachLocation, rebaseVersion);
-        }
-    }
-    for (const entry of change.rootNodes.outputDetachLocations.entries()) {
-        rebasedRoots.outputDetachLocations.set(entry.start, entry.length, entry.value);
-    }
-    return rebasedRoots;
-}
-function rebaseRename(newRoots, rebasedRoots, renameEntry, base, affectedBaseFields) {
-    let count = renameEntry.length;
-    const baseRenameEntry = firstAttachIdFromDetachId(base.rootNodes, renameEntry.start, count);
-    count = baseRenameEntry.length;
-    const baseAttachEntry = base.crossFieldKeys.getFirst({
-        ...baseRenameEntry.value,
-        target: CrossFieldTarget.Destination,
-    }, count);
-    count = baseAttachEntry.length;
-    if (baseAttachEntry.value !== undefined) {
-        // This rename represents an intention to detach these nodes.
-        // The rebased change should have a detach in the field where the base change attaches the nodes,
-        // so we need to ensure that field is processed.
-        affectedBaseFields.set(fieldIdKeyFromFieldId(normalizeFieldId(baseAttachEntry.value, base.nodeAliases)), true);
-    }
-    else {
-        const baseOutputDetachLocation = base.rootNodes.outputDetachLocations.getFirst(baseRenameEntry.value, 1).value;
-        if (baseOutputDetachLocation !== undefined) {
-            affectedBaseFields.set(fieldIdKeyFromFieldId(baseOutputDetachLocation), true);
-        }
-        const detachEntry = newRoots.detachLocations.getFirst(renameEntry.start, count);
-        count = detachEntry.length;
-        const detachLocation = baseOutputDetachLocation ?? detachEntry.value;
-        // Note that `baseOutputDetachLocation` may contain a node ID from the base changeset.
-        // We will replace the detach location entry with the node ID from the rebased changeset in `fixupRebasedDetachLocations`
-        addNodeRename(rebasedRoots, baseRenameEntry.value, renameEntry.value, count, detachLocation);
-    }
-    const countRemaining = renameEntry.length - count;
-    if (countRemaining > 0) {
-        rebaseRename(newRoots, rebasedRoots, {
-            start: offsetChangeAtomId(renameEntry.start, count),
-            value: offsetChangeAtomId(renameEntry.value, count),
-            length: countRemaining,
-        }, base, affectedBaseFields);
-    }
-}
-/**
- * For each root detach location, replaces any node ID from the base changeset
- * with the corresponding ID in the new changeset.
- */
-function fixupRebasedDetachLocations(table) {
-    for (const { start, length, value: detachLocation, } of table.rebasedRootNodes.detachLocations.entries()) {
-        const normalizedDetachLocation = normalizeFieldId(detachLocation, table.baseChange.nodeAliases);
-        if (normalizedDetachLocation.nodeId !== undefined) {
-            const rebasedNodeId = getFromChangeAtomIdMap(table.baseToRebasedNodeId, normalizedDetachLocation.nodeId);
-            if (rebasedNodeId !== undefined) {
-                table.rebasedRootNodes.detachLocations.set(start, length, {
-                    ...normalizedDetachLocation,
-                    nodeId: rebasedNodeId,
-                });
-            }
-        }
-    }
-}
-function addNodesToCompose(table, id1, id2) {
-    const normalizedId1 = normalizeNodeId(id1, table.baseChange.nodeAliases);
-    const normalizedId2 = normalizeNodeId(id2, table.newChange.nodeAliases);
-    if (getFromChangeAtomIdMap(table.newToBaseNodeId, normalizedId2) === undefined) {
-        setInChangeAtomIdMap(table.newToBaseNodeId, normalizedId2, normalizedId1);
-        table.pendingCompositions.nodeIdsToCompose.push([normalizedId1, normalizedId2]);
-    }
-}
-function composeRevInfos(revisions1, revisions2) {
-    const result = [...(revisions1 ?? []), ...(revisions2 ?? [])];
-    return result;
-}
-function composeCrossFieldKeyTables(table1, table2, movedCrossFieldKeys, removedCrossFieldKeys) {
-    const composedTable = RangeMap.union(table1, table2);
-    for (const entry of movedCrossFieldKeys.entries()) {
-        composedTable.set(entry.start, entry.length, entry.value);
-    }
-    for (const entry of removedCrossFieldKeys.entries()) {
-        composedTable.delete(entry.start, entry.length);
-    }
-    return composedTable;
-}
-function composeRootTables(change1, change2, composedNodeToParent, movedCrossFieldKeys, removedCrossFieldKeys, pendingCompositions) {
-    const composedTable = cloneRootTable(change1.rootNodes);
-    for (const renameEntry of change2.rootNodes.oldToNewId.entries()) {
-        composeRename(change1, change2, composedTable, renameEntry.start, renameEntry.value, renameEntry.length, movedCrossFieldKeys, removedCrossFieldKeys, pendingCompositions);
-    }
-    for (const [[revision2, id2], nodeId2] of change2.rootNodes.nodeChanges.entries()) {
-        const detachId2 = { revision: revision2, localId: id2 };
-        const detachId1 = firstDetachIdFromAttachId(change1.rootNodes, detachId2, 1).value;
-        const nodeId1 = getFromChangeAtomIdMap(change1.rootNodes.nodeChanges, detachId1);
-        if (nodeId1 !== undefined) {
-            pendingCompositions.nodeIdsToCompose.push([nodeId1, nodeId2]);
-        }
-        else {
-            const fieldId = getFieldsForCrossFieldKey(change1, { ...detachId1, target: CrossFieldTarget.Source }, 1)[0];
-            if (fieldId !== undefined) {
-                // In this case, this node is attached in the input context of change1,
-                // and is represented in detachFieldId.
-                pendingCompositions.affectedBaseFields.set([fieldId.nodeId?.revision, fieldId.nodeId?.localId, fieldId.field], true);
-            }
-            else {
-                assignRootChange(composedTable, composedNodeToParent, detachId1, nodeId2, change1.rootNodes.detachLocations.getFirst(detachId1, 1).value ??
-                    change2.rootNodes.detachLocations.getFirst(detachId2, 1).value, Math.max(change1.rebaseVersion, change2.rebaseVersion));
-            }
-        }
-    }
-    for (const outputDetachEntry of change1.rootNodes.outputDetachLocations.entries()) {
-        composeOutputDetachLocation(outputDetachEntry.start, outputDetachEntry.length, outputDetachEntry.value, change2, composedTable);
-    }
-    for (const entry of change2.rootNodes.outputDetachLocations.entries()) {
-        composedTable.outputDetachLocations.set(entry.start, entry.length, entry.value);
-    }
-    return composedTable;
-}
-function composeOutputDetachLocation(outputDetachId1, count, detachLocation, change2, composedTable) {
-    let countToProcess = count;
-    const renameEntry = firstAttachIdFromDetachId(change2.rootNodes, outputDetachId1, countToProcess);
-    countToProcess = renameEntry.length;
-    const attachEntry = getFirstAttachField(change2.crossFieldKeys, renameEntry.value, countToProcess);
-    countToProcess = attachEntry.length;
-    composedTable.outputDetachLocations.delete(outputDetachId1, countToProcess);
-    if (attachEntry.value === undefined) {
-        // We update the key for the detach location to the renamed ID of the root in the composed output context.
-        composedTable.outputDetachLocations.set(renameEntry.value, countToProcess, detachLocation);
-    }
-    else {
-        // These nodes are attached by `change2` and thus attached in the composed output context,
-        // so there should be no output detach location.
-    }
-    const countRemaining = count - countToProcess;
-    if (countRemaining > 0) {
-        composeOutputDetachLocation(offsetChangeAtomId(outputDetachId1, countToProcess), countRemaining, detachLocation, change2, composedTable);
-    }
-}
-function composeRename(change1, change2, mergedTable, oldId, newId, count, movedCrossFieldKeys, removedCrossFieldKeys, pendingCompositions) {
-    let countToProcess = count;
-    const detachEntry = getFirstDetachField(change1.crossFieldKeys, oldId, countToProcess);
-    countToProcess = detachEntry.length;
-    if (detachEntry.value !== undefined) {
-        // `change1` detached these nodes,
-        // so we invalidate the detach location so that the detach's ID can be replaced with the new ID.
-        pendingCompositions.affectedBaseFields.set(fieldIdKeyFromFieldId(detachEntry.value), true);
-        if (!areEqualChangeAtomIds(oldId, newId)) {
-            // `change1`'s detach will be replaced by `change2`'s detach, so we update the cross-field keys.
-            removedCrossFieldKeys.set({ ...oldId, target: CrossFieldTarget.Source }, countToProcess, true);
-        }
-        movedCrossFieldKeys.set({ ...newId, target: CrossFieldTarget.Source }, countToProcess, detachEntry.value);
-    }
-    else {
-        // `change1` may also have a rename to `renameEntry.value`, in which case it must refer to a different node.
-        // That node must have been attached by `change1` and detached by `change2`.
-        // The final rename for that node will be created in `composeAttachDetach`.
-        // We delete any such rename for now to avoid colliding with the rename currently being processed.
-        deleteNodeRenameTo(mergedTable, newId, countToProcess);
-        // The nodes were detached before `change`, so we append this rename.
-        appendNodeRename(mergedTable, oldId, newId, countToProcess, change1.rootNodes, change2.rootNodes.detachLocations.getFirst(oldId, countToProcess).value);
-    }
-    if (countToProcess < count) {
-        composeRename(change1, change2, mergedTable, offsetChangeAtomId(oldId, countToProcess), offsetChangeAtomId(newId, countToProcess), count - countToProcess, movedCrossFieldKeys, removedCrossFieldKeys, pendingCompositions);
-    }
-}
-export function cloneRootTable(table) {
-    return {
-        oldToNewId: table.oldToNewId.clone(),
-        newToOldId: table.newToOldId.clone(),
-        nodeChanges: brand(table.nodeChanges.clone()),
-        detachLocations: table.detachLocations.clone(),
-        outputDetachLocations: table.outputDetachLocations.clone(),
-    };
-}
-function invertRootTable(change, isRollback) {
-    const invertedRoots = newRootTable();
-    for (const [[revision, localId], nodeId] of change.rootNodes.nodeChanges.entries()) {
-        const detachId = { revision, localId };
-        const renamedId = firstAttachIdFromDetachId(change.rootNodes, detachId, 1).value;
-        // This checks whether `change` attaches this node.
-        // If it does, the node is not detached in the input context of the inverse, and so should not be included in the root table.
-        if (change.crossFieldKeys.getFirst({ ...renamedId, target: CrossFieldTarget.Destination }, 1)
-            .value === undefined) {
-            assignRootChange(invertedRoots, undefined, renamedId, nodeId, change.rootNodes.detachLocations.getFirst(detachId, 1).value, change.rebaseVersion);
-        }
-    }
-    if (isRollback) {
-        // We only invert renames of nodes which are not attached or detached by this changeset.
-        // When we invert an attach we will create a detach which incorporates the rename.
-        for (const { start: oldId, value: newId, length, } of change.rootNodes.oldToNewId.entries()) {
-            invertRename(change, invertedRoots, oldId, newId, length);
-        }
-    }
-    return invertedRoots;
-}
-function invertRename(change, invertedRoots, oldId, newId, length) {
-    for (const detachEntry of doesChangeDetachNodes(change.crossFieldKeys, newId, length)) {
-        assert(!detachEntry.value, "A changeset should not have a rename and detach for the same node.");
-    }
-    let countProcessed = length;
-    const attachEntry = getFirstAttachField(change.crossFieldKeys, newId, countProcessed);
-    countProcessed = attachEntry.length;
-    if (attachEntry.value === undefined) {
-        const outputDetachEntry = change.rootNodes.outputDetachLocations.getFirst(newId, countProcessed);
-        countProcessed = outputDetachEntry.length;
-        const inputDetachEntry = change.rootNodes.detachLocations.getFirst(oldId, countProcessed);
-        countProcessed = inputDetachEntry.length;
-        addNodeRename(invertedRoots, newId, oldId, countProcessed, outputDetachEntry.value ?? inputDetachEntry.value);
-    }
-    if (countProcessed < length) {
-        invertRename(change, invertedRoots, offsetChangeAtomId(oldId, countProcessed), offsetChangeAtomId(newId, countProcessed), length - countProcessed);
-    }
-}
-function doesChangeAttachNodes(table, id, count) {
-    return table
-        .getAll2({ ...id, target: CrossFieldTarget.Destination }, count)
-        .map((entry) => ({ ...entry, value: entry.value !== undefined }));
-}
-function doesChangeDetachNodes(table, id, count) {
-    return table
-        .getAll2({ ...id, target: CrossFieldTarget.Source }, count)
-        .map((entry) => ({ ...entry, value: entry.value !== undefined }));
-}
-export function getFirstDetachField(table, id, count) {
-    return table.getFirst({ target: CrossFieldTarget.Source, ...id }, count);
-}
-export function getFirstAttachField(table, id, count) {
-    return table.getFirst({ target: CrossFieldTarget.Destination, ...id }, count);
-}
-export function addNodeRename(table, oldId, newId, count, detachLocation) {
-    if (areEqualChangeAtomIds(oldId, newId)) {
-        return;
-    }
-    for (const entry of table.oldToNewId.getAll2(oldId, count)) {
-        assert(entry.value === undefined ||
-            areEqualChangeAtomIds(entry.value, offsetChangeAtomId(newId, entry.offset)), "Rename collision detected");
-    }
-    for (const entry of table.newToOldId.getAll2(newId, count)) {
-        assert(entry.value === undefined ||
-            areEqualChangeAtomIds(entry.value, offsetChangeAtomId(oldId, entry.offset)), "Rename collision detected");
-    }
-    table.oldToNewId.set(oldId, count, newId);
-    table.newToOldId.set(newId, count, oldId);
-    if (detachLocation !== undefined) {
-        table.detachLocations.set(oldId, count, detachLocation);
-    }
-}
-/**
- * Deletes any renames from `id`.
- */
-function deleteNodeRenameFrom(roots, id, count) {
-    for (const entry of roots.oldToNewId.getAll(id, count)) {
-        deleteNodeRenameEntry(roots, entry.start, entry.value, entry.length);
-    }
-}
-/**
- * Deletes any renames to `id`.
- */
-function deleteNodeRenameTo(roots, id, count) {
-    for (const entry of roots.newToOldId.getAll(id, count)) {
-        deleteNodeRenameEntry(roots, entry.value, entry.start, entry.length);
-    }
-}
-function appendNodeRename(composedTable, oldId, newId, count, change1Table, detachLocation) {
-    let countToProcess = count;
-    const rename1Entry = change1Table.newToOldId.getFirst(oldId, countToProcess);
-    countToProcess = rename1Entry.length;
-    if (rename1Entry.value !== undefined) {
-        deleteNodeRenameFrom(composedTable, rename1Entry.value, countToProcess);
-    }
-    addNodeRename(composedTable, rename1Entry.value ?? oldId, newId, countToProcess, detachLocation);
-    tryRemoveDetachLocation(composedTable, newId, countToProcess);
-    if (countToProcess < count) {
-        const countRemaining = count - countToProcess;
-        appendNodeRename(composedTable, offsetChangeAtomId(oldId, countToProcess), offsetChangeAtomId(newId, countToProcess), countRemaining, change1Table, detachLocation);
-    }
-}
-function tryRemoveDetachLocation(roots, rootId, count) {
-    let countProcessed = count;
-    const renameEntry = roots.oldToNewId.getFirst(rootId, countProcessed);
-    countProcessed = renameEntry.length;
-    const outputDetachEntry = roots.outputDetachLocations.getFirst(rootId, countProcessed);
-    countProcessed = outputDetachEntry.length;
-    const nodeChangeEntry = rangeQueryChangeAtomIdMap(roots.nodeChanges, rootId, countProcessed);
-    countProcessed = nodeChangeEntry.length;
-    if (nodeChangeEntry.value === undefined &&
-        renameEntry.value === undefined &&
-        outputDetachEntry.value === undefined) {
-        roots.detachLocations.delete(rootId, countProcessed);
-    }
-    const countRemaining = count - countProcessed;
-    if (countRemaining > 0) {
-        tryRemoveDetachLocation(roots, offsetChangeAtomId(rootId, countProcessed), countRemaining);
-    }
-}
-/**
- * Deletes the entry renaming the ID range of length `count` from `oldId` to `newId`.
- * This function assumes that such an entry exists.
- */
-function deleteNodeRenameEntry(roots, oldId, newId, count) {
-    roots.oldToNewId.delete(oldId, count);
-    roots.newToOldId.delete(newId, count);
-}
-function replaceRootTableRevision(table, oldRevisions, newRevision, nodeAliases) {
-    const oldToNewId = table.oldToNewId.mapEntries((id) => replaceAtomRevisions(id, oldRevisions, newRevision), (id) => replaceAtomRevisions(id, oldRevisions, newRevision));
-    const newToOldId = table.newToOldId.mapEntries((id) => replaceAtomRevisions(id, oldRevisions, newRevision), (id) => replaceAtomRevisions(id, oldRevisions, newRevision));
-    const nodeChanges = newTupleBTree([...table.nodeChanges.entries()].map(([[revision, id], nodeId]) => [
-        [oldRevisions.has(revision) ? newRevision : revision, id],
-        replaceAtomRevisions(normalizeNodeId(nodeId, nodeAliases), oldRevisions, newRevision),
-    ]));
-    const detachLocations = table.detachLocations.mapEntries((id) => replaceAtomRevisions(id, oldRevisions, newRevision), (fieldId) => replaceFieldIdRevision(normalizeFieldId(fieldId, nodeAliases), oldRevisions, newRevision));
-    const outputDetachLocations = table.outputDetachLocations.mapEntries((id) => replaceAtomRevisions(id, oldRevisions, newRevision), (fieldId) => replaceFieldIdRevision(normalizeFieldId(fieldId, nodeAliases), oldRevisions, newRevision));
-    return { oldToNewId, newToOldId, nodeChanges, detachLocations, outputDetachLocations };
-}
-function newDetachedEntryMap() {
-    return new RangeMap(offsetChangeAtomId, subtractChangeAtomIds, offsetDetachedNodeEntry);
-}
-function offsetDetachedNodeEntry(entry, count) {
-    assert(count <= 1 || entry.nodeChange === undefined, "Cannot split an entry with a node change");
-    return entry.detachId !== undefined
-        ? { ...entry, detachId: offsetChangeAtomId(entry.detachId, count) }
-        : entry;
-}
-function getFieldsWithRootMoves(roots, nodeAliases) {
-    const fields = newTupleBTree();
-    for (const { start: rootId, value: fieldId, length } of roots.detachLocations.entries()) {
-        let isRootMoved = false;
-        for (const renameEntry of roots.oldToNewId.getAll2(rootId, length)) {
-            if (renameEntry.value !== undefined) {
-                isRootMoved = true;
-            }
-        }
-        for (const outputDetachEntry of roots.outputDetachLocations.getAll2(rootId, length)) {
-            if (outputDetachEntry.value !== undefined) {
-                isRootMoved = true;
-            }
-        }
-        if (isRootMoved) {
-            fields.set(fieldIdKeyFromFieldId(normalizeFieldId(fieldId, nodeAliases)), true);
-        }
-    }
-    return fields;
-}
-function getFieldToRootChanges(roots, nodeAliases) {
-    const fields = newTupleBTree();
-    for (const rootIdKey of roots.nodeChanges.keys()) {
-        const rootId = { revision: rootIdKey[0], localId: rootIdKey[1] };
-        const detachLocation = roots.detachLocations.getFirst(rootId, 1).value;
-        if (detachLocation !== undefined) {
-            const fieldIdKey = fieldIdKeyFromFieldId(normalizeFieldId(detachLocation, nodeAliases));
-            let rootsInField = fields.get(fieldIdKey);
-            if (rootsInField === undefined) {
-                rootsInField = [];
-                fields.set(fieldIdKey, rootsInField);
-            }
-            rootsInField.push(rootId);
-        }
-    }
-    return fields;
-}
-function muteRootChanges(roots) {
-    return {
-        oldToNewId: newChangeAtomIdTransform(),
-        newToOldId: newChangeAtomIdTransform(),
-        nodeChanges: brand(roots.nodeChanges.clone()),
-        detachLocations: roots.detachLocations.clone(),
-        outputDetachLocations: newChangeAtomIdRangeMap(),
-    };
-}
 //# sourceMappingURL=modularChangeFamily.js.map