@fluidframework/tree 2.1.0-276985 → 2.1.0-281041

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

@@ -4,15 +4,15 @@
  */
 import { assert } from "@fluidframework/core-utils/internal";
 import { BTree } from "@tylerbu/sorted-btree-es6";
-import { EditBuilder, isEmptyFieldChanges, makeAnonChange, makeDetachedNodeId, mapCursorField, revisionMetadataSourceFromInfo, } from "../../core/index.js";
-import { addToNestedSet, brand, deleteFromNestedMap, fail, forEachInNestedMap, getOrAddInMap, idAllocatorFromMaxId, idAllocatorFromState, nestedMapFromFlatList, nestedMapToFlatList, nestedSetContains, populateNestedMap, setInNestedMap, tryGetFromNestedMap, } from "../../util/index.js";
+import { EditBuilder, isEmptyFieldChanges, makeAnonChange, makeDetachedNodeId, mapCursorField, replaceAtomRevisions, revisionMetadataSourceFromInfo, setInChangeAtomIdMap, areEqualChangeAtomIds, getFromChangeAtomIdMap, } from "../../core/index.js";
+import { brand, deleteFromNestedMap, fail, forEachInNestedMap, getOrAddInMap, idAllocatorFromMaxId, idAllocatorFromState, nestedMapFromFlatList, nestedMapToFlatList, populateNestedMap, setInNestedMap, tryGetFromNestedMap, } from "../../util/index.js";
 import { chunkFieldSingle, chunkTree, defaultChunkPolicy, } from "../chunked-forest/index.js";
 import { cursorForMapTreeNode, mapTreeFromCursor } from "../mapTreeCursor.js";
 import { MemoizedIdRangeAllocator } from "../memoizedIdRangeAllocator.js";
 import { CrossFieldTarget, getFirstFromCrossFieldMap, setInCrossFieldMap, } from "./crossFieldQueries.js";
 import { NodeAttachState, } from "./fieldChangeHandler.js";
 import { withEditor } from "./fieldKindWithEditor.js";
-import { convertGenericChange, genericFieldKind, newGenericChangeset, } from "./genericFieldKind.js";
+import { convertGenericChange, genericFieldKind } from "./genericFieldKind.js";
 /**
  * Implementation of ChangeFamily which delegates work in a given field to the appropriate FieldKind
  * as determined by the schema.
@@ -34,27 +34,30 @@ export class ModularChangeFamily {
      */
     normalizeFieldChanges(change1, change2, genId, revisionMetadata) {
         // TODO: Handle the case where changes have conflicting field kinds
-        const kind = change1 !== undefined && change1.fieldKind !== genericFieldKind.identifier
+        const kind = change1.fieldKind !== genericFieldKind.identifier
             ? change1.fieldKind
-            : change2?.fieldKind ?? genericFieldKind.identifier;
+            : change2.fieldKind;
         if (kind === genericFieldKind.identifier) {
-            // All the changes are generic
+            // Both changes are generic
             return {
-                fieldKind: genericFieldKind,
-                change1: change1?.change,
-                change2: change2?.change,
+                fieldKind: genericFieldKind.identifier,
+                changeHandler: genericFieldKind.changeHandler,
+                change1: change1.change,
+                change2: change2.change,
             };
         }
         const fieldKind = getFieldKind(this.fieldKinds, kind);
-        const handler = fieldKind.changeHandler;
-        const normalizedChange1 = this.normalizeFieldChange(change1, handler, genId, revisionMetadata);
-        const normalizedChange2 = this.normalizeFieldChange(change2, handler, genId, revisionMetadata);
-        return { fieldKind, change1: normalizedChange1, change2: normalizedChange2 };
+        const changeHandler = fieldKind.changeHandler;
+        const normalizedChange1 = this.normalizeFieldChange(change1, changeHandler, genId, revisionMetadata);
+        const normalizedChange2 = this.normalizeFieldChange(change2, changeHandler, genId, revisionMetadata);
+        return {
+            fieldKind: kind,
+            changeHandler,
+            change1: normalizedChange1,
+            change2: normalizedChange2,
+        };
     }
     normalizeFieldChange(fieldChange, handler, genId, revisionMetadata) {
-        if (fieldChange === undefined) {
-            return undefined;
-        }
         if (fieldChange.fieldKind !== genericFieldKind.identifier) {
             return fieldChange.change;
         }
@@ -69,105 +72,227 @@ export class ModularChangeFamily {
     compose(changes) {
         const { revInfos, maxId } = getRevInfoFromTaggedChanges(changes);
         const idState = { maxId };
-        return changes.reduce((change1, change2) => makeAnonChange(this.composePair(change1, change2, revInfos, idState)), makeAnonChange({ fieldChanges: new Map(), nodeChanges: new Map() })).change;
+        return changes.reduce((change1, change2) => makeAnonChange(this.composePair(change1, change2, revInfos, idState)), makeAnonChange({
+            fieldChanges: new Map(),
+            nodeChanges: new Map(),
+            nodeToParent: new Map(),
+            nodeAliases: new Map(),
+            crossFieldKeys: newCrossFieldKeyTable(),
+        })).change;
     }
     composePair(change1, change2, revInfos, idState) {
-        const genId = idAllocatorFromState(idState);
-        const revisionMetadata = revisionMetadataSourceFromInfo(revInfos);
-        const crossFieldTable = newComposeTable();
-        const composedFields = this.composeFieldMaps(getActiveFieldChanges(change1.change), getActiveFieldChanges(change2.change), genId, crossFieldTable, revisionMetadata);
-        const composedNodeChanges = new Map();
-        for (const [id1, id2] of crossFieldTable.nodeIdPairs) {
-            this.composeNodesById(change1.change.nodeChanges, change2.change.nodeChanges, composedNodeChanges, id1, id2, genId, crossFieldTable, revisionMetadata);
-        }
-        crossFieldTable.nodeIdPairs.length = 0;
-        while (crossFieldTable.invalidatedFields.size > 0) {
-            const fieldsToUpdate = crossFieldTable.invalidatedFields;
-            crossFieldTable.invalidatedFields = new Set();
-            for (const fieldChange of fieldsToUpdate) {
-                const context = crossFieldTable.fieldToContext.get(fieldChange);
-                assert(context !== undefined, 0x8cc /* Should have context for every invalidated field */);
-                const { change1: fieldChange1, change2: fieldChange2, composedChange } = context;
-                const rebaser = getChangeHandler(this.fieldKinds, composedChange.fieldKind).rebaser;
-                const composeNodes = (child1, child2) => {
-                    if (child2 !== undefined &&
-                        !nestedSetContains(crossFieldTable.nodeIds, child2.revision, child2.localId)) {
-                        crossFieldTable.nodeIdPairs.push([child1, child2]);
-                        if (child1 !== undefined && child2 !== undefined) {
-                            addToNestedSet(crossFieldTable.nodeIds, child2.revision, child2.localId);
-                        }
-                    }
-                    return child1 ?? child2 ?? fail("Should not compose two undefined nodes");
-                };
-                const amendedChange = rebaser.compose(fieldChange1, fieldChange2, composeNodes, genId, newCrossFieldManager(crossFieldTable, fieldChange, false), revisionMetadata);
-                composedChange.change = brand(amendedChange);
-                // Process any newly discovered nodes.
-                for (const [taggedId1, taggedId2] of crossFieldTable.nodeIdPairs) {
-                    this.composeNodesById(change1.change.nodeChanges, change2.change.nodeChanges, composedNodeChanges, taggedId1, taggedId2, genId, crossFieldTable, revisionMetadata);
-                }
-                crossFieldTable.nodeIdPairs.length = 0;
-            }
-        }
+        const { fieldChanges, nodeChanges, nodeToParent, nodeAliases, crossFieldKeys } = this.composeAllFields(change1.change, change2.change, revInfos, idState);
         const { allBuilds, allDestroys, allRefreshers } = composeBuildsDestroysAndRefreshers([
             change1,
             change2,
         ]);
-        return makeModularChangeset(this.pruneFieldMap(composedFields, composedNodeChanges), composedNodeChanges, idState.maxId, revInfos, undefined, allBuilds, allDestroys, allRefreshers);
+        return makeModularChangeset(this.pruneFieldMap(fieldChanges, nodeChanges), nodeChanges, nodeToParent, nodeAliases, crossFieldKeys, idState.maxId, revInfos, undefined, allBuilds, allDestroys, allRefreshers);
+    }
+    composeAllFields(change1, change2, revInfos, idState) {
+        if (hasConflicts(change1) && hasConflicts(change2)) {
+            return {
+                fieldChanges: new Map(),
+                nodeChanges: new Map(),
+                nodeToParent: new Map(),
+                nodeAliases: new Map(),
+                crossFieldKeys: newBTree(),
+            };
+        }
+        else if (hasConflicts(change1)) {
+            return change2;
+        }
+        else if (hasConflicts(change2)) {
+            return change1;
+        }
+        const genId = idAllocatorFromState(idState);
+        const revisionMetadata = revisionMetadataSourceFromInfo(revInfos);
+        const crossFieldTable = newComposeTable(change1, change2);
+        // We merge nodeChanges, nodeToParent, and nodeAliases from the two changesets.
+        // The merged tables will have correct entries for all nodes which are only referenced in one of the input changesets.
+        // During composeFieldMaps and processInvalidatedElements we will find all nodes referenced in both input changesets
+        // and adjust these tables as necessary.
+        // Note that when merging these tables we may encounter key collisions and will arbitrarily drop values in that case.
+        // A collision for a node ID means that that node is referenced in both changesets
+        // (since we assume that if two changesets use the same node ID they are referring to the same node),
+        // therefore all collisions will be addressed when processing the intersection of the changesets.
+        const composedNodeChanges = mergeNestedMaps(change1.nodeChanges, change2.nodeChanges);
+        const composedNodeToParent = mergeNestedMaps(change1.nodeToParent, change2.nodeToParent);
+        const composedNodeAliases = mergeNestedMaps(change1.nodeAliases, change2.nodeAliases);
+        const composedFields = this.composeFieldMaps(change1.fieldChanges, change2.fieldChanges, genId, crossFieldTable, revisionMetadata);
+        this.processInvalidatedElements(crossFieldTable, composedFields, composedNodeChanges, composedNodeToParent, composedNodeAliases, genId, revisionMetadata);
+        // Currently no field kinds require making changes to cross-field keys during composition, so we can just merge the two tables.
+        const composedCrossFieldKeys = mergeBTrees(change1.crossFieldKeys, change2.crossFieldKeys);
+        return {
+            fieldChanges: composedFields,
+            nodeChanges: composedNodeChanges,
+            nodeToParent: composedNodeToParent,
+            nodeAliases: composedNodeAliases,
+            crossFieldKeys: brand(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;
+        const rebaser = getChangeHandler(this.fieldKinds, composedChange.fieldKind).rebaser;
+        const composeNodes = (child1, child2) => {
+            if (child1 !== undefined &&
+                child2 !== undefined &&
+                getFromChangeAtomIdMap(crossFieldTable.newToBaseNodeId, child2) === undefined) {
+                setInChangeAtomIdMap(crossFieldTable.newToBaseNodeId, child2, child1);
+                crossFieldTable.pendingCompositions.nodeIdsToCompose.push([child1, child2]);
+            }
+            return child1 ?? child2 ?? fail("Should not compose two undefined nodes");
+        };
+        const amendedChange = rebaser.compose(fieldChange1, fieldChange2, composeNodes, genId, new ComposeManager(crossFieldTable, fieldChange, false), revisionMetadata);
+        composedChange.change = brand(amendedChange);
+    }
+    /**
+     * Updates everything in the composed output which may no longer be valid.
+     * This could be due to
+     * - discovering that two node changesets refer to the same node (`nodeIdsToCompose`)
+     * - a previously composed field being invalidated by a cross field effect (`invalidatedFields`)
+     * - a field which was copied directly from an input changeset being invalidated by a cross field effect
+     * (`affectedBaseFields` and `affectedNewFields`)
+     *
+     * Updating an element may invalidate further elements. This function runs until there is no more invalidation.
+     */
+    processInvalidatedElements(table, composedFields, composedNodes, composedNodeToParent, nodeAliases, genId, metadata) {
+        const pending = table.pendingCompositions;
+        while (table.invalidatedFields.size > 0 ||
+            pending.nodeIdsToCompose.length > 0 ||
+            pending.affectedBaseFields.length > 0 ||
+            pending.affectedNewFields.length > 0) {
+            // Note that the call to `composeNodesById` can add entries to `crossFieldTable.nodeIdPairs`.
+            for (const [id1, id2] of pending.nodeIdsToCompose) {
+                this.composeNodesById(table.baseChange.nodeChanges, table.newChange.nodeChanges, composedNodes, composedNodeToParent, nodeAliases, id1, id2, genId, table, metadata);
+            }
+            pending.nodeIdsToCompose.length = 0;
+            this.composeAffectedFields(table, table.baseChange, true, pending.affectedBaseFields, composedFields, composedNodes, genId, metadata);
+            this.composeAffectedFields(table, table.newChange, false, pending.affectedNewFields, composedFields, composedNodes, genId, metadata);
+            this.processInvalidatedCompositions(table, genId, metadata);
+        }
+    }
+    processInvalidatedCompositions(table, genId, metadata) {
+        const fieldsToUpdate = table.invalidatedFields;
+        table.invalidatedFields = new Set();
+        for (const fieldChange of fieldsToUpdate) {
+            this.composeInvalidatedField(fieldChange, table, genId, metadata);
+        }
+    }
+    /**
+     * Ensures that each field in `affectedFields` has been updated in the composition output.
+     * Any field which has already been composed is ignored.
+     * All other fields are optimistically assumed to not have any changes in the other input changeset.
+     *
+     * @param change - The changeset which contains the affected fields.
+     * This should be one of the two changesets being composed.
+     * @param areBaseFields - Whether the affected fields are part of the base changeset.
+     * If not, they are assumed to be part of the new changeset.
+     * @param affectedFields - The set of fields to process.
+     */
+    composeAffectedFields(table, change, areBaseFields, affectedFields, composedFields, composedNodes, genId, metadata) {
+        for (const fieldIdKey of affectedFields.keys()) {
+            const fieldId = normalizeFieldId(fieldIdFromFieldIdKey(fieldIdKey), change.nodeAliases);
+            const fieldChange = fieldChangeFromId(change.fieldChanges, change.nodeChanges, fieldId);
+            if (table.fieldToContext.has(fieldChange) ||
+                table.newFieldToBaseField.has(fieldChange)) {
+                // This function handles fields which were not part of the intersection of the two changesets but which need to be updated anyway.
+                // If we've already processed this field then either it is up to date
+                // or there is pending inval which will be handled in processInvalidatedCompositions.
+                continue;
+            }
+            const emptyChange = this.createEmptyFieldChange(fieldChange.fieldKind);
+            const [change1, change2] = areBaseFields
+                ? [fieldChange, emptyChange]
+                : [emptyChange, fieldChange];
+            const composedField = this.composeFieldChanges(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);
+        }
+        affectedFields.clear();
     }
     composeFieldMaps(change1, change2, genId, crossFieldTable, revisionMetadata) {
         const composedFields = new Map();
-        const fields = new Set();
-        for (const field of change1?.keys() ?? []) {
-            fields.add(field);
-        }
-        for (const field of change2?.keys() ?? []) {
-            fields.add(field);
-        }
-        for (const field of fields) {
-            const fieldChange1 = change1?.get(field);
-            const fieldChange2 = change2?.get(field);
-            const { fieldKind, change1: normalizedFieldChange1, change2: normalizedFieldChange2, } = this.normalizeFieldChanges(fieldChange1, fieldChange2, genId, revisionMetadata);
-            const manager = newCrossFieldManager(crossFieldTable, fieldChange1 ?? fieldChange2);
-            const change1Normalized = normalizedFieldChange1 ?? fieldKind.changeHandler.createEmpty();
-            const change2Normalized = normalizedFieldChange2 ?? fieldKind.changeHandler.createEmpty();
-            const composedChange = fieldKind.changeHandler.rebaser.compose(change1Normalized, change2Normalized, (child1, child2) => {
-                crossFieldTable.nodeIdPairs.push([child1, child2]);
-                if (child2 !== undefined) {
-                    addToNestedSet(crossFieldTable.nodeIds, child2.revision, child2.localId);
-                }
-                return child1 ?? child2 ?? fail("Should not compose two undefined nodes");
-            }, genId, manager, revisionMetadata);
-            const composedField = {
-                fieldKind: fieldKind.identifier,
-                change: brand(composedChange),
-            };
-            const fieldKey = fieldChange1 ?? fieldChange2 ?? fail("At least one field should have changes");
-            crossFieldTable.fieldToContext.set(fieldKey, {
-                change1: change1Normalized,
-                change2: change2Normalized,
-                composedChange: composedField,
-            });
-            // TODO: Could optimize by checking that composedField is non-empty
+        if (change1 === undefined || change2 === undefined) {
+            return change1 ?? change2 ?? composedFields;
+        }
+        for (const [field, fieldChange1] of change1) {
+            const fieldChange2 = change2.get(field);
+            const composedField = fieldChange2 !== undefined
+                ? this.composeFieldChanges(fieldChange1, fieldChange2, genId, crossFieldTable, revisionMetadata)
+                : fieldChange1;
             composedFields.set(field, composedField);
         }
+        for (const [field, fieldChange2] of change2) {
+            if (change1 === undefined || !change1.has(field)) {
+                composedFields.set(field, fieldChange2);
+            }
+        }
         return composedFields;
     }
-    composeNodesById(nodeChanges1, nodeChanges2, composedNodeChanges, id1, id2, idAllocator, crossFieldTable, revisionMetadata) {
-        const nodeChangeset1 = id1 !== undefined
-            ? tryGetFromNestedMap(nodeChanges1, id1.revision, id1.localId) ??
-                fail("Unknown node ID")
-            : {};
-        const nodeChangeset2 = id2 !== undefined
-            ? tryGetFromNestedMap(nodeChanges2, id2.revision, id2.localId) ??
-                fail("Unknown node ID")
-            : {};
+    /**
+     * Returns the composition of the two input fields.
+     *
+     * Any nodes in this field which were modified by both changesets
+     * will be added to `crossFieldTable.pendingCompositions.nodeIdsToCompose`.
+     *
+     * Any fields which had cross-field information sent to them as part of this field composition
+     * will be added to either `affectedBaseFields` or `affectedNewFields` in `crossFieldTable.pendingCompositions`.
+     *
+     * Any composed `FieldChange` which is invalidated by new cross-field information will be added to `crossFieldTable.invalidatedFields`.
+     */
+    composeFieldChanges(change1, change2, idAllocator, crossFieldTable, revisionMetadata) {
+        const { fieldKind, changeHandler, change1: change1Normalized, change2: change2Normalized, } = this.normalizeFieldChanges(change1, change2, idAllocator, revisionMetadata);
+        const manager = new ComposeManager(crossFieldTable, change1);
+        const composedChange = changeHandler.rebaser.compose(change1Normalized, change2Normalized, (child1, child2) => {
+            if (child1 !== undefined && child2 !== undefined) {
+                setInChangeAtomIdMap(crossFieldTable.newToBaseNodeId, child2, child1);
+                crossFieldTable.pendingCompositions.nodeIdsToCompose.push([child1, child2]);
+            }
+            return child1 ?? child2 ?? fail("Should not compose two undefined nodes");
+        }, idAllocator, manager, revisionMetadata);
+        const composedField = {
+            fieldKind,
+            change: brand(composedChange),
+        };
+        crossFieldTable.fieldToContext.set(change1, {
+            change1: change1Normalized,
+            change2: change2Normalized,
+            composedChange: composedField,
+        });
+        crossFieldTable.newFieldToBaseField.set(change2, change1);
+        return composedField;
+    }
+    composeNodesById(nodeChanges1, nodeChanges2, composedNodes, composedNodeToParent, nodeAliases, id1, id2, idAllocator, crossFieldTable, revisionMetadata) {
+        const nodeChangeset1 = nodeChangeFromId(nodeChanges1, id1);
+        const nodeChangeset2 = nodeChangeFromId(nodeChanges2, id2);
         const composedNodeChangeset = this.composeNodeChanges(nodeChangeset1, nodeChangeset2, idAllocator, crossFieldTable, revisionMetadata);
-        const nodeId = id1 ?? id2 ?? fail("Should not compose two undefined node IDs");
-        setInNestedMap(composedNodeChanges, nodeId.revision, nodeId.localId, composedNodeChangeset);
+        setInChangeAtomIdMap(composedNodes, id1, composedNodeChangeset);
+        if (!areEqualChangeAtomIds(id1, id2)) {
+            deleteFromNestedMap(composedNodes, id2.revision, id2.localId);
+            deleteFromNestedMap(composedNodeToParent, id2.revision, id2.localId);
+            setInChangeAtomIdMap(nodeAliases, id2, id1);
+            // We need to delete id1 to avoid forming a cycle in case id1 already had an alias.
+            deleteFromNestedMap(nodeAliases, id1.revision, id1.localId);
+        }
+        crossFieldTable.composedNodes.add(composedNodeChangeset);
     }
     composeNodeChanges(change1, change2, genId, crossFieldTable, revisionMetadata) {
-        const nodeExistsConstraint = change1?.nodeExistsConstraint ?? change2?.nodeExistsConstraint;
-        const composedFieldChanges = this.composeFieldMaps(change1?.fieldChanges, change2?.fieldChanges, genId, crossFieldTable, revisionMetadata);
+        const nodeExistsConstraint = change1.nodeExistsConstraint ?? change2.nodeExistsConstraint;
+        const composedFieldChanges = this.composeFieldMaps(change1.fieldChanges, change2.fieldChanges, genId, crossFieldTable, revisionMetadata);
         const composedNodeChange = {};
         if (composedFieldChanges.size > 0) {
             composedNodeChange.fieldChanges = composedFieldChanges;
@@ -190,23 +315,21 @@ export class ModularChangeFamily {
         // Destroys only occur in rollback changesets, which are never inverted.
         assert(change.change.destroys === undefined, 0x89a /* Unexpected destroys in change to invert */);
         if ((change.change.constraintViolationCount ?? 0) > 0) {
-            return makeModularChangeset(undefined, undefined, change.change.maxId, [], undefined, undefined, destroys);
+            return makeModularChangeset(undefined, undefined, undefined, undefined, undefined, change.change.maxId, [], undefined, undefined, destroys);
         }
-        const idState = { maxId: change.change.maxId ?? -1 };
-        // This idState is used for the whole of the IdAllocator's lifetime, which allows
-        // this function to read the updated idState.maxId after more IDs are allocated.
-        // TODO: add a getMax function to IdAllocator to make for a clearer contract.
-        const genId = idAllocatorFromState(idState);
+        const genId = idAllocatorFromMaxId(change.change.maxId ?? -1);
+        const invertedNodeToParent = cloneNestedMap(change.change.nodeToParent);
         const crossFieldTable = {
             ...newCrossFieldTable(),
             originalFieldToContext: new Map(),
+            invertedNodeToParent,
         };
         const { revInfos } = getRevInfoFromTaggedChanges([change]);
         const revisionMetadata = revisionMetadataSourceFromInfo(revInfos);
-        const invertedFields = this.invertFieldMap(change.change.fieldChanges, isRollback, genId, crossFieldTable, revisionMetadata);
+        const invertedFields = this.invertFieldMap(change.change.fieldChanges, undefined, isRollback, genId, crossFieldTable, revisionMetadata);
         const invertedNodes = new Map();
         forEachInNestedMap(change.change.nodeChanges, (nodeChangeset, revision, localId) => {
-            setInNestedMap(invertedNodes, revision, localId, this.invertNodeChange(nodeChangeset, isRollback, genId, crossFieldTable, revisionMetadata));
+            setInNestedMap(invertedNodes, revision, localId, this.invertNodeChange(nodeChangeset, { revision, localId }, isRollback, genId, crossFieldTable, revisionMetadata));
         });
         if (crossFieldTable.invalidatedFields.size > 0) {
             const fieldsToUpdate = crossFieldTable.invalidatedFields;
@@ -215,17 +338,19 @@ 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, newCrossFieldManager(crossFieldTable, fieldChange), revisionMetadata);
+                const { invertedField, fieldId } = context;
+                const amendedChange = getChangeHandler(this.fieldKinds, fieldChange.fieldKind).rebaser.invert(originalFieldChange, isRollback, genId, new InvertManager(crossFieldTable, fieldChange, fieldId), revisionMetadata);
                 invertedField.change = brand(amendedChange);
             }
         }
-        return makeModularChangeset(invertedFields, invertedNodes, idState.maxId, [], change.change.constraintViolationCount, undefined, destroys);
+        const crossFieldKeys = this.makeCrossFieldKeyTable(invertedFields, invertedNodes);
+        return makeModularChangeset(invertedFields, invertedNodes, invertedNodeToParent, change.change.nodeAliases, crossFieldKeys, genId.getMaxId(), [], change.change.constraintViolationCount, undefined, destroys);
     }
-    invertFieldMap(changes, isRollback, genId, crossFieldTable, revisionMetadata) {
+    invertFieldMap(changes, parentId, isRollback, genId, crossFieldTable, revisionMetadata) {
         const invertedFields = new Map();
         for (const [field, fieldChange] of changes) {
-            const manager = newCrossFieldManager(crossFieldTable, fieldChange);
+            const fieldId = { nodeId: parentId, field };
+            const manager = new InvertManager(crossFieldTable, fieldChange, fieldId);
             const invertedChange = getChangeHandler(this.fieldKinds, fieldChange.fieldKind).rebaser.invert(fieldChange.change, isRollback, genId, manager, revisionMetadata);
             const invertedFieldChange = {
                 ...fieldChange,
@@ -233,15 +358,16 @@ export class ModularChangeFamily {
             };
             invertedFields.set(field, invertedFieldChange);
             crossFieldTable.originalFieldToContext.set(fieldChange, {
+                fieldId,
                 invertedField: invertedFieldChange,
             });
         }
         return invertedFields;
     }
-    invertNodeChange(change, isRollback, genId, crossFieldTable, revisionMetadata) {
+    invertNodeChange(change, id, isRollback, genId, crossFieldTable, revisionMetadata) {
         const inverse = {};
         if (change.fieldChanges !== undefined) {
-            inverse.fieldChanges = this.invertFieldMap(change.fieldChanges, isRollback, genId, crossFieldTable, revisionMetadata);
+            inverse.fieldChanges = this.invertFieldMap(change.fieldChanges, id, isRollback, genId, crossFieldTable, revisionMetadata);
         }
         return inverse;
     }
@@ -252,9 +378,15 @@ export class ModularChangeFamily {
         const genId = idAllocatorFromState(idState);
         const crossFieldTable = {
             ...newCrossFieldTable(),
-            fieldToContext: new Map(),
-            rebasedNodeCache: new Map(),
+            newChange: change,
+            baseChange: over.change,
+            baseFieldToContext: new Map(),
+            baseToRebasedNodeId: new Map(),
+            rebasedFields: new Set(),
+            rebasedNodeToParent: cloneNestedMap(change.nodeToParent),
+            rebasedCrossFieldKeys: brand(change.crossFieldKeys.clone()),
             nodeIdPairs: [],
+            affectedBaseFields: newBTree(),
         };
         let constraintState = newConstraintState(change.constraintViolationCount ?? 0);
         const getBaseRevisions = () => revisionInfoFromTaggedChange(over).map((info) => info.revision);
@@ -263,108 +395,198 @@ export class ModularChangeFamily {
             getRevisionToRebase: () => taggedChange.revision,
             getBaseRevisions,
         };
-        const rebasedFields = this.rebaseFieldMap(change.fieldChanges, over.change.fieldChanges, genId, crossFieldTable, rebaseMetadata);
-        const rebasedNodes = new Map();
-        for (const [newId, baseId] of crossFieldTable.nodeIdPairs) {
-            const newNodeChange = newId !== undefined
-                ? tryGetFromNestedMap(change.nodeChanges, newId.revision, newId.localId)
-                : undefined;
-            const baseNodeChange = baseId !== undefined
-                ? tryGetFromNestedMap(over.change.nodeChanges, baseId.revision, baseId.localId) ??
-                    fail("Unknown node ID")
-                : {};
-            const rebasedNode = this.rebaseNodeChange(newNodeChange, baseNodeChange, genId, crossFieldTable, rebaseMetadata);
-            if (rebasedNode !== undefined) {
-                const nodeId = newId ?? baseId ?? fail("Should not have two undefined IDs");
-                setInNestedMap(rebasedNodes, nodeId.revision, nodeId.localId, rebasedNode);
-            }
-        }
+        const rebasedNodes = cloneNestedMap(change.nodeChanges);
+        const rebasedFields = this.rebaseIntersectingFields(crossFieldTable, rebasedNodes, genId, constraintState, rebaseMetadata);
+        this.rebaseFieldsWithoutNewChanges(rebasedFields, rebasedNodes, crossFieldTable, genId, rebaseMetadata);
         if (crossFieldTable.invalidatedFields.size > 0) {
             const fieldsToUpdate = crossFieldTable.invalidatedFields;
             crossFieldTable.invalidatedFields = new Set();
             constraintState = newConstraintState(change.constraintViolationCount ?? 0);
             for (const field of fieldsToUpdate) {
-                // TODO: Should we copy the context table out before this loop?
-                const context = crossFieldTable.fieldToContext.get(field);
+                const context = crossFieldTable.baseFieldToContext.get(field);
                 assert(context !== undefined, 0x852 /* Every field should have a context */);
-                const { fieldKind, change1: fieldChangeset, change2: baseChangeset, } = this.normalizeFieldChanges(context.newChange, context.baseChange, genId, revisionMetadata);
-                context.rebasedChange.change = fieldKind.changeHandler.rebaser.rebase(fieldChangeset, baseChangeset, (curr, base, existenceState) => curr ?? base, genId, newCrossFieldManager(crossFieldTable, field), rebaseMetadata);
+                const { changeHandler, change1: fieldChangeset, change2: baseChangeset, } = this.normalizeFieldChanges(context.newChange, context.baseChange, genId, revisionMetadata);
+                const rebaseChild = (curr, base) => {
+                    if (curr !== undefined) {
+                        return curr;
+                    }
+                    if (base !== undefined) {
+                        for (const id of context.baseNodeIds) {
+                            if (areEqualChangeAtomIds(base, id)) {
+                                return base;
+                            }
+                        }
+                    }
+                    return undefined;
+                };
+                context.rebasedChange.change = brand(changeHandler.rebaser.rebase(fieldChangeset, baseChangeset, rebaseChild, genId, new RebaseManager(crossFieldTable, field, context.fieldId), rebaseMetadata));
             }
         }
         this.updateConstraintsForFields(rebasedFields, NodeAttachState.Attached, constraintState, rebasedNodes);
-        return makeModularChangeset(this.pruneFieldMap(rebasedFields, rebasedNodes), rebasedNodes, idState.maxId, change.revisions, constraintState.violationCount, change.builds, change.destroys, change.refreshers);
+        return makeModularChangeset(this.pruneFieldMap(rebasedFields, rebasedNodes), rebasedNodes, crossFieldTable.rebasedNodeToParent, change.nodeAliases, crossFieldTable.rebasedCrossFieldKeys, idState.maxId, change.revisions, constraintState.violationCount, change.builds, change.destroys, change.refreshers);
     }
-    rebaseFieldMap(change, over, genId, crossFieldTable, revisionMetadata) {
-        const rebasedFields = new Map();
-        // Rebase fields contained in the base changeset
-        for (const [field, baseChanges] of over) {
-            const fieldChange = change.get(field) ?? {
-                fieldKind: genericFieldKind.identifier,
-                change: brand(newGenericChangeset()),
+    // This performs a first pass on all fields which have both new and base changes.
+    // TODO: Can we also handle additional passes in this method?
+    rebaseIntersectingFields(crossFieldTable, rebasedNodes, genId, constraintState, metadata) {
+        const change = crossFieldTable.newChange;
+        const baseChange = crossFieldTable.baseChange;
+        const rebasedFields = this.rebaseFieldMap(change.fieldChanges, baseChange.fieldChanges, undefined, genId, crossFieldTable, metadata);
+        // This loop processes all fields which have both base and new changes.
+        // Note that the call to `rebaseNodeChange` can add entries to `crossFieldTable.nodeIdPairs`.
+        for (const [newId, baseId, _attachState] of crossFieldTable.nodeIdPairs) {
+            const rebasedNode = this.rebaseNodeChange(newId, baseId, genId, crossFieldTable, metadata, constraintState);
+            setInChangeAtomIdMap(rebasedNodes, newId, rebasedNode);
+        }
+        return rebasedFields;
+    }
+    // This processes fields which have no new changes but have been invalidated by another field.
+    rebaseFieldsWithoutNewChanges(rebasedFields, rebasedNodes, crossFieldTable, genId, metadata) {
+        const baseChange = crossFieldTable.baseChange;
+        for (const [revision, localId, fieldKey] of crossFieldTable.affectedBaseFields.keys()) {
+            const baseNodeId = localId !== undefined
+                ? normalizeNodeId({ revision, localId }, baseChange.nodeAliases)
+                : undefined;
+            const baseFieldChange = fieldMapFromNodeId(baseChange.fieldChanges, baseChange.nodeChanges, baseNodeId).get(fieldKey);
+            assert(baseFieldChange !== undefined, "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, "There should be no new changes in this field");
+                return undefined;
             };
-            const { fieldKind, change1: fieldChangeset, change2: baseChangeset, } = this.normalizeFieldChanges(fieldChange, baseChanges, genId, revisionMetadata);
-            const manager = newCrossFieldManager(crossFieldTable, fieldChange);
-            const rebaseChild = (child, baseChild, _attachState) => {
-                crossFieldTable.nodeIdPairs.push([child, baseChild]);
-                return (child ??
-                    // The fact `child` is undefined means that the changeset to rebase does not include changes for
-                    // this node or its descendants. However, it's possible that it will after rebasing.
-                    // In that case, we will need a NodeId to represent these changes under in the rebased changeset.
-                    // We adopt `baseChild` for this purpose.
-                    baseChild ??
-                    fail("Should not have two undefined node IDs"));
+            const handler = getChangeHandler(this.fieldKinds, baseFieldChange.fieldKind);
+            const fieldChange = {
+                ...baseFieldChange,
+                change: brand(handler.createEmpty()),
             };
-            const rebasedField = fieldKind.changeHandler.rebaser.rebase(fieldChangeset, baseChangeset, rebaseChild, genId, manager, revisionMetadata);
+            const rebasedNodeId = baseNodeId !== undefined
+                ? rebasedNodeIdFromBaseNodeId(crossFieldTable, baseNodeId)
+                : undefined;
+            const fieldId = { nodeId: rebasedNodeId, field: fieldKey };
+            const rebasedField = handler.rebaser.rebase(fieldChange.change, baseFieldChange.change, rebaseChild, genId, new RebaseManager(crossFieldTable, baseFieldChange, fieldId), metadata);
             const rebasedFieldChange = {
-                fieldKind: fieldKind.identifier,
+                ...baseFieldChange,
                 change: brand(rebasedField),
             };
-            rebasedFields.set(field, rebasedFieldChange);
-            crossFieldTable.fieldToContext.set(fieldChange, {
-                baseChange: baseChanges,
+            // 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);
+        }
+    }
+    attachRebasedField(rebasedFields, rebasedNodes, table, rebasedField, { nodeId, field: fieldKey }, idAllocator, metadata) {
+        if (nodeId === undefined) {
+            rebasedFields.set(fieldKey, rebasedField);
+            return;
+        }
+        const rebasedNode = getFromChangeAtomIdMap(rebasedNodes, nodeId);
+        if (rebasedNode !== undefined) {
+            if (rebasedNode.fieldChanges === undefined) {
+                rebasedNode.fieldChanges = new Map([[fieldKey, rebasedField]]);
+                return;
+            }
+            assert(!rebasedNode.fieldChanges.has(fieldKey), "Expected an empty field");
+            rebasedNode.fieldChanges.set(fieldKey, rebasedField);
+            return;
+        }
+        const newNode = {
+            fieldChanges: new Map([[fieldKey, rebasedField]]),
+        };
+        setInChangeAtomIdMap(rebasedNodes, nodeId, newNode);
+        setInChangeAtomIdMap(table.baseToRebasedNodeId, nodeId, nodeId);
+        const parentFieldId = getParentFieldId(table.baseChange, nodeId);
+        this.attachRebasedNode(rebasedFields, rebasedNodes, table, nodeId, parentFieldId, idAllocator, metadata);
+    }
+    attachRebasedNode(rebasedFields, rebasedNodes, table, baseNodeId, parentFieldIdBase, idAllocator, metadata) {
+        const baseFieldChange = fieldChangeFromId(table.baseChange.fieldChanges, table.baseChange.nodeChanges, parentFieldIdBase);
+        const rebasedFieldId = rebasedFieldIdFromBaseId(table, parentFieldIdBase);
+        setInChangeAtomIdMap(table.rebasedNodeToParent, baseNodeId, rebasedFieldId);
+        const context = table.baseFieldToContext.get(baseFieldChange);
+        if (context !== undefined) {
+            // We've already processed this field.
+            // The new child node can be attached when processing invalidated fields.
+            context.baseNodeIds.push(baseNodeId);
+            table.invalidatedFields.add(baseFieldChange);
+            return;
         }
-        // Rebase the fields of the new changeset which don't have a corresponding base field.
+        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();
+        const rebaseChild = (child, baseChild, stateChange) => {
+            if (child !== undefined && baseChild !== undefined) {
+                crossFieldTable.nodeIdPairs.push([child, baseChild, stateChange]);
+            }
+            return child;
+        };
         for (const [field, fieldChange] of change) {
-            if (!over?.has(field)) {
-                const baseChanges = {
-                    fieldKind: genericFieldKind.identifier,
-                    change: brand(newGenericChangeset()),
-                };
-                const { fieldKind, change1: fieldChangeset, change2: baseChangeset, } = this.normalizeFieldChanges(fieldChange, baseChanges, genId, revisionMetadata);
-                // TODO: Don't we need to add an entry in the context table?
-                const manager = newCrossFieldManager(crossFieldTable, fieldChange);
-                const rebasedChangeset = fieldKind.changeHandler.rebaser.rebase(fieldChangeset, baseChangeset, (child, baseChild) => {
-                    assert(baseChild === undefined, 0x5b6 /* This field should not have any base changes */);
-                    crossFieldTable.nodeIdPairs.push([child, undefined]);
-                    return child;
-                }, genId, manager, revisionMetadata);
-                const rebasedFieldChange = {
-                    fieldKind: fieldKind.identifier,
-                    change: brand(rebasedChangeset),
-                };
-                rebasedFields.set(field, rebasedFieldChange);
+            const fieldId = { nodeId: parentId, field };
+            const baseChange = over.get(field);
+            if (baseChange === undefined) {
+                rebasedFields.set(field, fieldChange);
+                continue;
             }
+            const { fieldKind, changeHandler, change1: fieldChangeset, change2: baseChangeset, } = this.normalizeFieldChanges(fieldChange, baseChange, genId, revisionMetadata);
+            const manager = new RebaseManager(crossFieldTable, baseChange, fieldId);
+            const rebasedField = changeHandler.rebaser.rebase(fieldChangeset, baseChangeset, rebaseChild, genId, manager, revisionMetadata);
+            const rebasedFieldChange = {
+                fieldKind,
+                change: brand(rebasedField),
+            };
+            rebasedFields.set(field, rebasedFieldChange);
+            crossFieldTable.baseFieldToContext.set(baseChange, {
+                baseChange,
+                newChange: fieldChange,
+                rebasedChange: rebasedFieldChange,
+                fieldId,
+                baseNodeIds: [],
+            });
+            crossFieldTable.rebasedFields.add(rebasedFieldChange);
         }
         return rebasedFields;
     }
-    rebaseNodeChange(change, over, genId, crossFieldTable, revisionMetadata) {
-        const key = change ?? over;
-        if (key === undefined) {
-            return undefined;
-        }
+    rebaseNodeChange(newId, baseId, genId, crossFieldTable, revisionMetadata, constraintState) {
+        const change = nodeChangeFromId(crossFieldTable.newChange.nodeChanges, newId);
+        const over = nodeChangeFromId(crossFieldTable.baseChange.nodeChanges, baseId);
         const baseMap = over?.fieldChanges ?? new Map();
-        const fieldChanges = this.rebaseFieldMap(change?.fieldChanges ?? new Map(), baseMap, genId, crossFieldTable, revisionMetadata);
+        const fieldChanges = change.fieldChanges !== undefined && over.fieldChanges !== undefined
+            ? this.rebaseFieldMap(change?.fieldChanges ?? new Map(), baseMap, newId, genId, crossFieldTable, revisionMetadata)
+            : change.fieldChanges;
         const rebasedChange = {};
-        if (fieldChanges.size > 0) {
+        if (fieldChanges !== undefined && fieldChanges.size > 0) {
             rebasedChange.fieldChanges = fieldChanges;
         }
         if (change?.nodeExistsConstraint !== undefined) {
             rebasedChange.nodeExistsConstraint = change.nodeExistsConstraint;
         }
-        crossFieldTable.rebasedNodeCache.set(key, rebasedChange);
+        setInChangeAtomIdMap(crossFieldTable.baseToRebasedNodeId, baseId, newId);
         return rebasedChange;
     }
     updateConstraintsForFields(fields, parentAttachState, constraintState, nodes) {
@@ -396,6 +618,9 @@ export class ModularChangeFamily {
         }
     }
     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);
@@ -407,8 +632,7 @@ export class ModularChangeFamily {
         return prunedChangeset.size > 0 ? prunedChangeset : undefined;
     }
     pruneNodeChange(nodeId, nodeMap) {
-        const changeset = tryGetFromNestedMap(nodeMap, nodeId.revision, nodeId.localId);
-        assert(changeset !== undefined, 0x930 /* Unknown node ID */);
+        const changeset = nodeChangeFromId(nodeMap, nodeId);
         const prunedFields = changeset.fieldChanges !== undefined
             ? this.pruneFieldMap(changeset.fieldChanges, nodeMap)
             : undefined;
@@ -421,7 +645,7 @@ export class ModularChangeFamily {
             return undefined;
         }
         else {
-            setInNestedMap(nodeMap, nodeId.revision, nodeId.localId, prunedChange);
+            setInChangeAtomIdMap(nodeMap, nodeId, prunedChange);
             return nodeId;
         }
     }
@@ -435,10 +659,19 @@ export class ModularChangeFamily {
             id,
             this.replaceNodeChangesetRevisions(nodeChangeset, oldRevisions, newRevision),
         ]));
+        const updatedNodeToParent = nestedMapFromFlatList(nestedMapToFlatList(change.nodeToParent).map(([revision, id, fieldId]) => [
+            replaceRevision(revision, oldRevisions, newRevision),
+            id,
+            replaceFieldIdRevision(normalizeFieldId(fieldId, change.nodeAliases), oldRevisions, newRevision),
+        ]));
         const updated = {
             ...change,
             fieldChanges: updatedFields,
             nodeChanges: updatedNodes,
+            nodeToParent: updatedNodeToParent,
+            // We've updated all references to old node IDs, so we no longer need an alias table.
+            nodeAliases: new Map(),
+            crossFieldKeys: replaceCrossFieldKeyTableRevisions(change.crossFieldKeys, oldRevisions, newRevision, change.nodeAliases),
         };
         if (change.builds !== undefined) {
             updated.builds = replaceIdMapRevisions(change.builds, oldRevisions, newRevision);
@@ -471,16 +704,62 @@ export class ModularChangeFamily {
     replaceFieldMapRevisions(fields, oldRevisions, newRevision) {
         const updatedFields = new Map();
         for (const [field, fieldChange] of fields) {
-            const updatedFieldChange = getFieldKind(this.fieldKinds, fieldChange.fieldKind).changeHandler.rebaser.replaceRevisions(fieldChange.change, oldRevisions, newRevision);
-            updatedFields.set(field, { ...fieldChange, change: updatedFieldChange });
+            const updatedFieldChange = getChangeHandler(this.fieldKinds, fieldChange.fieldKind).rebaser.replaceRevisions(fieldChange.change, oldRevisions, newRevision);
+            updatedFields.set(field, { ...fieldChange, change: brand(updatedFieldChange) });
         }
         return updatedFields;
     }
+    makeCrossFieldKeyTable(fields, nodes) {
+        const keys = newCrossFieldKeyTable();
+        this.populateCrossFieldKeyTableForFieldMap(keys, fields, undefined);
+        forEachInNestedMap(nodes, (node, revision, localId) => {
+            if (node.fieldChanges !== undefined) {
+                this.populateCrossFieldKeyTableForFieldMap(keys, node.fieldChanges, {
+                    revision,
+                    localId,
+                });
+            }
+        });
+        return keys;
+    }
+    populateCrossFieldKeyTableForFieldMap(table, fields, parent) {
+        for (const [fieldKey, fieldChange] of fields) {
+            const keys = getChangeHandler(this.fieldKinds, fieldChange.fieldKind).getCrossFieldKeys(fieldChange.change);
+            for (const key of keys) {
+                table.set(key, { nodeId: parent, field: fieldKey });
+            }
+        }
+    }
     buildEditor(changeReceiver) {
-        return new ModularEditBuilder(this, changeReceiver);
+        return new ModularEditBuilder(this, this.fieldKinds, changeReceiver);
+    }
+    createEmptyFieldChange(fieldKind) {
+        const emptyChange = getChangeHandler(this.fieldKinds, fieldKind).createEmpty();
+        return { fieldKind, change: brand(emptyChange) };
     }
 }
 ModularChangeFamily.emptyChange = makeModularChangeset();
+function replaceCrossFieldKeyTableRevisions(table, oldRevisions, newRevision, nodeAliases) {
+    const updated = newBTree();
+    table.forEachPair(([target, revision, id, count], field) => {
+        const updatedKey = [
+            target,
+            replaceRevision(revision, oldRevisions, newRevision),
+            id,
+            count,
+        ];
+        const normalizedFieldId = normalizeFieldId(field, nodeAliases);
+        const updatedNodeId = normalizedFieldId.nodeId !== undefined
+            ? replaceAtomRevisions(normalizedFieldId.nodeId, oldRevisions, newRevision)
+            : undefined;
+        const updatedValue = {
+            ...normalizedFieldId,
+            nodeId: updatedNodeId,
+        };
+        updated.set(updatedKey, updatedValue);
+    });
+    return updated;
+}
 function replaceRevision(revision, oldRevisions, newRevision) {
     return oldRevisions.has(revision) ? newRevision : revision;
 }
@@ -595,8 +874,7 @@ function* relevantRemovedRootsFromFields(change, nodeChanges, fieldKinds) {
     for (const [_, fieldChange] of change) {
         const handler = getChangeHandler(fieldKinds, fieldChange.fieldKind);
         const delegate = function* (node) {
-            const nodeChangeset = tryGetFromNestedMap(nodeChanges, node.revision, node.localId);
-            assert(nodeChangeset !== undefined, 0x931 /* Unknown node ID */);
+            const nodeChangeset = nodeChangeFromId(nodeChanges, node);
             if (nodeChangeset.fieldChanges !== undefined) {
                 yield* relevantRemovedRootsFromFields(nodeChangeset.fieldChanges, nodeChanges, fieldKinds);
             }
@@ -650,7 +928,7 @@ export function updateRefreshers(change, getDetachedNode, removedRoots, requireR
         }
     }
     const { fieldChanges, nodeChanges, maxId, revisions, constraintViolationCount, builds, destroys, } = change;
-    return makeModularChangeset(fieldChanges, nodeChanges, maxId, revisions, constraintViolationCount, builds, destroys, refreshers);
+    return makeModularChangeset(fieldChanges, nodeChanges, change.nodeToParent, change.nodeAliases, change.crossFieldKeys, maxId, revisions, constraintViolationCount, builds, destroys, refreshers);
 }
 /**
  * @param change - The change to convert into a delta.
@@ -706,8 +984,7 @@ function intoDeltaImpl(change, nodeChanges, idAllocator, fieldKinds) {
     const delta = new Map();
     for (const [field, fieldChange] of change) {
         const deltaField = getChangeHandler(fieldKinds, fieldChange.fieldKind).intoDelta(fieldChange.change, (childChange) => {
-            const nodeChange = tryGetFromNestedMap(nodeChanges, childChange.revision, childChange.localId);
-            assert(nodeChange !== undefined, 0x932 /* Unknown node ID */);
+            const nodeChange = nodeChangeFromId(nodeChanges, childChange);
             return deltaFromNodeChange(nodeChange, nodeChanges, idAllocator, fieldKinds);
         }, idAllocator);
         if (!isEmptyFieldChanges(deltaField)) {
@@ -764,12 +1041,20 @@ export function getFieldKind(fieldKinds, kind) {
 export function getChangeHandler(fieldKinds, kind) {
     return getFieldKind(fieldKinds, kind).changeHandler;
 }
-function newComposeTable() {
+function newComposeTable(baseChange, newChange) {
     return {
         ...newCrossFieldTable(),
+        baseChange,
+        newChange,
         fieldToContext: new Map(),
-        nodeIds: new Map(),
-        nodeIdPairs: [],
+        newFieldToBaseField: new Map(),
+        newToBaseNodeId: new Map(),
+        composedNodes: new Set(),
+        pendingCompositions: {
+            nodeIdsToCompose: [],
+            affectedBaseFields: newBTree(),
+            affectedNewFields: newBTree(),
+        },
     };
 }
 function newCrossFieldTable() {
@@ -786,43 +1071,148 @@ function newConstraintState(violationCount) {
         violationCount,
     };
 }
-function newCrossFieldManager(crossFieldTable, currentFieldKey, allowInval = true) {
-    const getMap = (target) => target === CrossFieldTarget.Source ? crossFieldTable.srcTable : crossFieldTable.dstTable;
-    const getDependents = (target) => target === CrossFieldTarget.Source
-        ? crossFieldTable.srcDependents
-        : crossFieldTable.dstDependents;
-    const manager = {
-        table: crossFieldTable,
-        set: (target, revision, id, count, newValue, invalidateDependents) => {
-            if (invalidateDependents && allowInval) {
-                const lastChangedId = id + count - 1;
-                let firstId = id;
-                while (firstId <= lastChangedId) {
-                    const dependentEntry = getFirstFromCrossFieldMap(getDependents(target), revision, firstId, lastChangedId - firstId + 1);
-                    if (dependentEntry.value !== undefined) {
-                        crossFieldTable.invalidatedFields.add(dependentEntry.value);
-                    }
-                    firstId = brand(firstId + dependentEntry.length);
+class CrossFieldManagerI {
+    constructor(crossFieldTable, currentFieldKey, allowInval = true) {
+        this.crossFieldTable = crossFieldTable;
+        this.currentFieldKey = currentFieldKey;
+        this.allowInval = allowInval;
+    }
+    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(getMap(target), revision, id, count, newValue);
-        },
-        get: (target, revision, id, count, addDependency) => {
-            if (addDependency) {
-                // We assume that if there is already an entry for this ID it is because
-                // a field handler has called compose on the same node multiple times.
-                // In this case we only want to update the latest version, so we overwrite the dependency.
-                setInCrossFieldMap(getDependents(target), revision, id, count, currentFieldKey);
+        }
+        setInCrossFieldMap(this.getMap(target), revision, id, count, newValue);
+    }
+    get(target, revision, id, count, addDependency) {
+        if (addDependency) {
+            // We assume that if there is already an entry for this ID it is because
+            // a field handler has called compose on the same node multiple times.
+            // In this case we only want to update the latest version, so we overwrite the dependency.
+            setInCrossFieldMap(this.getDependents(target), revision, id, count, this.currentFieldKey);
+        }
+        return getFirstFromCrossFieldMap(this.getMap(target), revision, id, count);
+    }
+    getMap(target) {
+        return target === CrossFieldTarget.Source
+            ? this.crossFieldTable.srcTable
+            : this.crossFieldTable.dstTable;
+    }
+    getDependents(target) {
+        return target === CrossFieldTarget.Source
+            ? this.crossFieldTable.srcDependents
+            : this.crossFieldTable.dstDependents;
+    }
+}
+class InvertManager extends CrossFieldManagerI {
+    constructor(table, field, fieldId, allowInval = true) {
+        super(table, field, allowInval);
+        this.fieldId = fieldId;
+    }
+    onMoveIn(id) {
+        setInChangeAtomIdMap(this.table.invertedNodeToParent, id, this.fieldId);
+    }
+    moveKey(target, revision, id, count) {
+        assert(false, "Keys should not be moved manually during invert");
+    }
+    get table() {
+        return this.crossFieldTable;
+    }
+}
+class RebaseManager 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,
+                id,
+                count,
+            ]);
+            assert(newFieldIds.length === 0, "TODO: Modifying a cross-field key from the new changeset is currently unsupported");
+            const baseFieldIds = getFieldsForCrossFieldKey(this.table.baseChange, [
+                target,
+                revision,
+                id,
+                count,
+            ]);
+            assert(baseFieldIds.length > 0, "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);
             }
-            return getFirstFromCrossFieldMap(getMap(target), revision, id, count);
-        },
-    };
-    return manager;
+        }
+        super.set(target, revision, id, count, newValue, invalidateDependents);
+    }
+    onMoveIn(id) {
+        setInChangeAtomIdMap(this.table.rebasedNodeToParent, id, this.fieldId);
+    }
+    moveKey(target, revision, id, count) {
+        setInCrossFieldKeyTable(this.table.rebasedCrossFieldKeys, target, revision, id, count, this.fieldId);
+    }
+    get table() {
+        return this.crossFieldTable;
+    }
+}
+// TODO: Deduplicate this with RebaseTable
+class ComposeManager extends CrossFieldManagerI {
+    constructor(table, currentField, allowInval = true) {
+        super(table, currentField, allowInval);
+    }
+    set(target, revision, id, count, newValue, invalidateDependents) {
+        if (invalidateDependents && this.allowInval) {
+            const newFieldIds = getFieldsForCrossFieldKey(this.table.newChange, [
+                target,
+                revision,
+                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 {
+                const baseFieldIds = getFieldsForCrossFieldKey(this.table.baseChange, [
+                    target,
+                    revision,
+                    id,
+                    count,
+                ]);
+                assert(baseFieldIds.length > 0, "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);
+    }
+    onMoveIn(id) {
+        throw new Error("Method not implemented.");
+    }
+    moveKey(target, revision, id, count) {
+        throw new Error("Method not implemented.");
+    }
+    get table() {
+        return this.crossFieldTable;
+    }
 }
-function makeModularChangeset(fieldChanges = undefined, nodeChanges = undefined, maxId = -1, revisions = undefined, constraintViolationCount = undefined, builds, destroys, refreshers) {
+function makeModularChangeset(fieldChanges = undefined, nodeChanges = undefined, nodeToParent = undefined, nodeAliases = undefined, crossFieldKeys = undefined, maxId = -1, revisions = undefined, constraintViolationCount = undefined, builds, destroys, refreshers) {
     const changeset = {
         fieldChanges: fieldChanges ?? new Map(),
         nodeChanges: nodeChanges ?? new Map(),
+        nodeToParent: nodeToParent ?? new Map(),
+        nodeAliases: nodeAliases ?? new Map(),
+        crossFieldKeys: crossFieldKeys ?? newCrossFieldKeyTable(),
     };
     if (revisions !== undefined && revisions.length > 0) {
         changeset.revisions = revisions;
@@ -845,8 +1235,9 @@ function makeModularChangeset(fieldChanges = undefined, nodeChanges = undefined,
     return changeset;
 }
 export class ModularEditBuilder extends EditBuilder {
-    constructor(family, changeReceiver) {
+    constructor(family, fieldKinds, changeReceiver) {
         super(family, changeReceiver);
+        this.fieldKinds = fieldKinds;
         this.transactionDepth = 0;
         this.idAllocator = idAllocatorFromMaxId();
     }
@@ -892,7 +1283,8 @@ export class ModularEditBuilder extends EditBuilder {
      * @param maxId - the highest `ChangesetLocalId` used in this change
      */
     submitChange(field, fieldKind, change) {
-        const modularChange = buildModularChangesetFromField(field, { fieldKind, change }, new Map(), this.idAllocator);
+        const crossFieldKeys = getChangeHandler(this.fieldKinds, fieldKind).getCrossFieldKeys(change);
+        const modularChange = buildModularChangesetFromField(field, { fieldKind, change }, new Map(), new Map(), newCrossFieldKeyTable(), this.idAllocator, crossFieldKeys);
         this.applyChange(modularChange);
     }
     submitChanges(changes) {
@@ -901,11 +1293,11 @@ export class ModularEditBuilder extends EditBuilder {
     }
     buildChanges(changes) {
         const changeMaps = changes.map((change) => makeAnonChange(change.type === "global"
-            ? makeModularChangeset(undefined, undefined, this.idAllocator.getMaxId(), undefined, undefined, change.builds)
+            ? makeModularChangeset(undefined, undefined, undefined, undefined, undefined, this.idAllocator.getMaxId(), undefined, undefined, change.builds)
             : buildModularChangesetFromField(change.field, {
                 fieldKind: change.fieldKind,
                 change: change.change,
-            }, new Map(), this.idAllocator)));
+            }, new Map(), new Map(), newCrossFieldKeyTable(), this.idAllocator, getChangeHandler(this.fieldKinds, change.fieldKind).getCrossFieldKeys(change.change))));
         const composedChange = this.changeFamily.rebaser.compose(changeMaps);
         const maxId = brand(this.idAllocator.getMaxId());
         if (maxId >= 0) {
@@ -920,28 +1312,46 @@ export class ModularEditBuilder extends EditBuilder {
         const nodeChange = {
             nodeExistsConstraint: { violated: false },
         };
-        this.applyChange(buildModularChangesetFromNode(path, nodeChange, new Map(), this.idAllocator));
+        this.applyChange(buildModularChangesetFromNode(path, nodeChange, new Map(), new Map(), newCrossFieldKeyTable(), this.idAllocator));
     }
 }
-function buildModularChangesetFromField(path, fieldChange, nodeChanges, idAllocator = idAllocatorFromMaxId()) {
+function buildModularChangesetFromField(path, fieldChange, nodeChanges, nodeToParent, crossFieldKeys, idAllocator = idAllocatorFromMaxId(), localCrossFieldKeys = [], childId = undefined) {
     const fieldChanges = new Map([[path.field, fieldChange]]);
     if (path.parent === undefined) {
-        return makeModularChangeset(fieldChanges, nodeChanges, idAllocator.getMaxId());
+        for (const key of localCrossFieldKeys) {
+            crossFieldKeys.set(key, { nodeId: undefined, field: path.field });
+        }
+        if (childId !== undefined) {
+            setInChangeAtomIdMap(nodeToParent, childId, {
+                nodeId: undefined,
+                field: path.field,
+            });
+        }
+        return makeModularChangeset(fieldChanges, nodeChanges, nodeToParent, undefined, crossFieldKeys, idAllocator.getMaxId());
     }
     const nodeChangeset = {
         fieldChanges,
     };
-    return buildModularChangesetFromNode(path.parent, nodeChangeset, nodeChanges, idAllocator);
+    const parentId = { localId: brand(idAllocator.allocate()) };
+    for (const key of localCrossFieldKeys) {
+        crossFieldKeys.set(key, { nodeId: parentId, field: path.field });
+    }
+    if (childId !== undefined) {
+        setInChangeAtomIdMap(nodeToParent, childId, {
+            nodeId: parentId,
+            field: path.field,
+        });
+    }
+    return buildModularChangesetFromNode(path.parent, nodeChangeset, nodeChanges, nodeToParent, crossFieldKeys, idAllocator, parentId);
 }
-function buildModularChangesetFromNode(path, nodeChange, nodeChanges, idAllocator) {
-    const nodeId = { localId: brand(idAllocator.allocate()) };
-    setInNestedMap(nodeChanges, nodeId.revision, nodeId.localId, nodeChange);
+function buildModularChangesetFromNode(path, nodeChange, nodeChanges, nodeToParent, crossFieldKeys, idAllocator, nodeId = { localId: brand(idAllocator.allocate()) }) {
+    setInChangeAtomIdMap(nodeChanges, nodeId, nodeChange);
     const fieldChangeset = genericFieldKind.changeHandler.editor.buildChildChange(path.parentIndex, nodeId);
     const fieldChange = {
         fieldKind: genericFieldKind.identifier,
         change: fieldChangeset,
     };
-    return buildModularChangesetFromField({ parent: path.parent, field: path.parentField }, fieldChange, nodeChanges, idAllocator);
+    return buildModularChangesetFromField({ parent: path.parent, field: path.parentField }, fieldChange, nodeChanges, nodeToParent, crossFieldKeys, idAllocator, [], nodeId);
 }
 function getRevInfoFromTaggedChanges(changes) {
     let maxId = -1;
@@ -990,9 +1400,181 @@ function revisionFromRevInfos(revInfos) {
     }
     return revInfos[0].revision;
 }
-function getActiveFieldChanges(changes) {
-    return (changes.constraintViolationCount ?? 0) === 0
-        ? changes.fieldChanges
-        : new Map();
+function mergeBTrees(tree1, tree2) {
+    const result = tree1.clone();
+    tree2.forEachPair((k, v) => {
+        result.set(k, v);
+    });
+    return result;
+}
+function mergeNestedMaps(map1, map2) {
+    const merged = new Map();
+    populateNestedMap(map1, merged, true);
+    populateNestedMap(map2, merged, true);
+    return merged;
+}
+function fieldChangeFromId(fields, nodes, id) {
+    const fieldMap = fieldMapFromNodeId(fields, nodes, id.nodeId);
+    return fieldMap.get(id.field) ?? fail("No field exists for the given ID");
+}
+function fieldMapFromNodeId(rootFieldMap, nodes, nodeId) {
+    if (nodeId === undefined) {
+        return rootFieldMap;
+    }
+    const node = nodeChangeFromId(nodes, nodeId);
+    assert(node.fieldChanges !== undefined, "Expected node to have field changes");
+    return node.fieldChanges;
+}
+function rebasedFieldIdFromBaseId(table, baseId) {
+    if (baseId.nodeId === undefined) {
+        return baseId;
+    }
+    return { ...baseId, nodeId: rebasedNodeIdFromBaseNodeId(table, baseId.nodeId) };
+}
+function rebasedNodeIdFromBaseNodeId(table, baseId) {
+    return getFromChangeAtomIdMap(table.baseToRebasedNodeId, baseId) ?? baseId;
+}
+function nodeChangeFromId(nodes, id) {
+    const node = getFromChangeAtomIdMap(nodes, id);
+    assert(node !== undefined, "Unknown node ID");
+    return node;
+}
+function fieldIdFromFieldIdKey([revision, localId, field]) {
+    const nodeId = localId !== undefined ? { revision, localId } : undefined;
+    return { nodeId, field };
+}
+function cloneNodeChangeset(nodeChangeset) {
+    if (nodeChangeset.fieldChanges !== undefined) {
+        return { ...nodeChangeset, fieldChanges: new Map(nodeChangeset.fieldChanges) };
+    }
+    return { ...nodeChangeset };
+}
+function replaceFieldIdRevision(fieldId, oldRevisions, newRevision) {
+    if (fieldId.nodeId === undefined) {
+        return fieldId;
+    }
+    return {
+        ...fieldId,
+        nodeId: replaceAtomRevisions(fieldId.nodeId, oldRevisions, newRevision),
+    };
+}
+export function getParentFieldId(changeset, nodeId) {
+    const parentId = getFromChangeAtomIdMap(changeset.nodeToParent, nodeId);
+    assert(parentId !== undefined, "Parent field should be defined");
+    return normalizeFieldId(parentId, changeset.nodeAliases);
+}
+export function getFieldsForCrossFieldKey(changeset, [target, revision, id, count]) {
+    let firstLocalId = id;
+    const lastLocalId = id + count - 1;
+    const fields = [];
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        const entry = getFirstIntersectingCrossFieldEntry(changeset.crossFieldKeys, [
+            target,
+            revision,
+            brand(firstLocalId),
+            count,
+        ]);
+        if (entry === undefined) {
+            return fields;
+        }
+        const [[_target, _revision, entryId, entryCount], fieldId] = entry;
+        fields.push(normalizeFieldId(fieldId, changeset.nodeAliases));
+        const entryLastId = entryId + entryCount - 1;
+        if (entryLastId >= lastLocalId) {
+            return fields;
+        }
+        firstLocalId = entryLastId + 1;
+    }
+}
+function getFirstIntersectingCrossFieldEntry(table, [target, revision, id, count]) {
+    const entry = table.nextLowerPair([target, revision, id, Infinity]);
+    if (entry === undefined) {
+        return undefined;
+    }
+    const [entryTarget, entryRevision, entryId, entryCount] = entry[0];
+    if (entryTarget !== target || entryRevision !== revision) {
+        return undefined;
+    }
+    const lastQueryId = id + count - 1;
+    const entryLastId = entryId + entryCount - 1;
+    if (entryId > lastQueryId || entryLastId < id) {
+        return undefined;
+    }
+    return entry;
+}
+function setInCrossFieldKeyTable(table, target, revision, id, count, value) {
+    let entry = getFirstIntersectingCrossFieldEntry(table, [target, revision, id, count]);
+    const lastQueryId = id + count - 1;
+    while (entry !== undefined) {
+        const [entryKey, entryValue] = entry;
+        table.delete(entryKey);
+        const [_target, _revision, entryId, entryCount] = entryKey;
+        if (entryId < id) {
+            table.set([target, revision, entryId, id - entryId], entryValue);
+        }
+        const lastEntryId = entryId + entryCount - 1;
+        if (lastEntryId > lastQueryId) {
+            table.set([target, revision, brand(lastQueryId + 1), lastEntryId - lastQueryId], entryValue);
+            break;
+        }
+        const nextId = brand(lastEntryId + 1);
+        entry = getFirstIntersectingCrossFieldEntry(table, [
+            target,
+            revision,
+            nextId,
+            lastQueryId - nextId + 1,
+        ]);
+    }
+    table.set([target, revision, id, count], value);
+}
+function normalizeFieldId(fieldId, nodeAliases) {
+    return fieldId.nodeId !== undefined
+        ? { ...fieldId, nodeId: normalizeNodeId(fieldId.nodeId, nodeAliases) }
+        : fieldId;
+}
+/**
+ * @returns The canonical form of nodeId, according to nodeAliases
+ */
+function normalizeNodeId(nodeId, nodeAliases) {
+    let currentId = nodeId;
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        const dealiased = getFromChangeAtomIdMap(nodeAliases, currentId);
+        if (dealiased === undefined) {
+            return currentId;
+        }
+        currentId = dealiased;
+    }
+}
+function hasConflicts(change) {
+    return (change.constraintViolationCount ?? 0) > 0;
+}
+export function newCrossFieldKeyTable() {
+    return newBTree();
+}
+function newBTree() {
+    return brand(new BTree(undefined, compareTuples));
+}
+// This assumes that the arrays are the same length.
+function compareTuples(arrayA, arrayB) {
+    for (let i = 0; i < arrayA.length; i++) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const a = arrayA[i];
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const b = arrayB[i];
+        if (a < b) {
+            return -1;
+        }
+        else if (a > b) {
+            return 1;
+        }
+    }
+    return 0;
+}
+function cloneNestedMap(map) {
+    const cloned = new Map();
+    populateNestedMap(map, cloned, true);
+    return cloned;
 }
 //# sourceMappingURL=modularChangeFamily.js.map