@fluidframework/tree 2.12.0 → 2.20.0

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, makeDetachedNodeId, mapCursorField, replaceAtomRevisions, revisionMetadataSourceFromInfo, areEqualChangeAtomIds, areEqualChangeAtomIdOpts, tagChange, makeAnonChange, } from "../../core/index.js";
-import { brand, fail, idAllocatorFromMaxId, idAllocatorFromState, getOrAddInMapLazy, } from "../../util/index.js";
+import { EditBuilder, makeDetachedNodeId, mapCursorField, replaceAtomRevisions, revisionMetadataSourceFromInfo, areEqualChangeAtomIds, areEqualChangeAtomIdOpts, tagChange, makeAnonChange, newChangeAtomIdRangeMap, } from "../../core/index.js";
+import { brand, fail, idAllocatorFromMaxId, idAllocatorFromState, getOrAddInMapLazy, newTupleBTree, mergeTupleBTrees, RangeMap, } 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 } from "./genericFieldKind.js";
+import { newCrossFieldKeyTable, } from "./modularChangeTypes.js";
 /**
  * Implementation of ChangeFamily which delegates work in a given field to the appropriate FieldKind
  * as determined by the schema.
@@ -102,7 +102,7 @@ export class ModularChangeFamily {
                 nodeChanges: newTupleBTree(),
                 nodeToParent: newTupleBTree(),
                 nodeAliases: newTupleBTree(),
-                crossFieldKeys: newTupleBTree(),
+                crossFieldKeys: newCrossFieldKeyTable(),
             };
         }
         else if (hasConflicts(change1)) {
@@ -121,20 +121,20 @@ export class ModularChangeFamily {
         // 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 = brand(mergeBTrees(change1.nodeChanges, change2.nodeChanges));
-        const composedNodeToParent = brand(mergeBTrees(change1.nodeToParent, change2.nodeToParent));
-        const composedNodeAliases = brand(mergeBTrees(change1.nodeAliases, change2.nodeAliases));
+        const composedNodeChanges = brand(mergeTupleBTrees(change1.nodeChanges, change2.nodeChanges));
+        const composedNodeToParent = brand(mergeTupleBTrees(change1.nodeToParent, change2.nodeToParent));
+        const composedNodeAliases = brand(mergeTupleBTrees(change1.nodeAliases, change2.nodeAliases));
         const crossFieldTable = newComposeTable(change1, change2, composedNodeToParent);
         const composedFields = this.composeFieldMaps(change1.fieldChanges, change2.fieldChanges, undefined, genId, crossFieldTable, revisionMetadata);
         this.composeInvalidatedElements(crossFieldTable, composedFields, composedNodeChanges, composedNodeToParent, composedNodeAliases, genId, revisionMetadata);
         // Currently no field kinds require making changes to cross-field keys during composition, so we can just merge the two tables.
-        const composedCrossFieldKeys = mergeBTrees(change1.crossFieldKeys, change2.crossFieldKeys);
+        const composedCrossFieldKeys = RangeMap.union(change1.crossFieldKeys, change2.crossFieldKeys);
         return {
             fieldChanges: composedFields,
             nodeChanges: composedNodeChanges,
             nodeToParent: composedNodeToParent,
             nodeAliases: composedNodeAliases,
-            crossFieldKeys: brand(composedCrossFieldKeys),
+            crossFieldKeys: composedCrossFieldKeys,
         };
     }
     composeInvalidatedField(fieldChange, crossFieldTable, genId, revisionMetadata) {
@@ -300,7 +300,18 @@ export class ModularChangeFamily {
         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:
+        // change1: a changeset that impact the existence of a node
+        // change2: a node-exists constraint on that node.
+        // This is currently enforced by the fact that constraints which apply to the input context are included first in the composition.
+        // If that weren't the case, we would need to rebase the status of the constraint backward over the changes from change1.
         const nodeExistsConstraint = change1.nodeExistsConstraint ?? change2.nodeExistsConstraint;
+        // WARNING: this composition logic assumes that we never make compositions of the following form:
+        // change1: a node-exists-on-revert constraint on a node
+        // change2: a changeset that impacts the existence of that node
+        // This is currently enforced by the fact that constraints which apply to the revert are included last in the composition.
+        // If that weren't the case, we would need to rebase the status of the constraint forward over the changes from change2.
+        const nodeExistsConstraintOnRevert = change1.nodeExistsConstraintOnRevert ?? change2.nodeExistsConstraintOnRevert;
         const composedFieldChanges = this.composeFieldMaps(change1.fieldChanges, change2.fieldChanges, nodeId, genId, crossFieldTable, revisionMetadata);
         const composedNodeChange = {};
         if (composedFieldChanges.size > 0) {
@@ -309,6 +320,9 @@ export class ModularChangeFamily {
         if (nodeExistsConstraint !== undefined) {
             composedNodeChange.nodeExistsConstraint = nodeExistsConstraint;
         }
+        if (nodeExistsConstraintOnRevert !== undefined) {
+            composedNodeChange.nodeExistsConstraintOnRevert = nodeExistsConstraintOnRevert;
+        }
         return composedNodeChange;
     }
     /**
@@ -366,7 +380,8 @@ export class ModularChangeFamily {
             crossFieldKeys,
             maxId: genId.getMaxId(),
             revisions: revInfos,
-            constraintViolationCount: change.change.constraintViolationCount,
+            constraintViolationCount: change.change.constraintViolationCountOnRevert,
+            constraintViolationCountOnRevert: change.change.constraintViolationCount,
             destroys,
         });
     }
@@ -390,6 +405,17 @@ export class ModularChangeFamily {
     }
     invertNodeChange(change, id, isRollback, genId, crossFieldTable, revisionMetadata, revisionForInvert) {
         const inverse = {};
+        // If the node has a constraint, it should be inverted to a node-exist-on-revert constraint. This ensure that if
+        // the inverse is inverted again, the original input constraint will be restored.
+        if (change.nodeExistsConstraint !== undefined) {
+            inverse.nodeExistsConstraintOnRevert = change.nodeExistsConstraint;
+        }
+        // The node-exist-on-revert constraint of a node is the constraint that should apply when the a change is reverted.
+        // So, it should become the constraint in the inverse. If this constraint is violated when applying the inverse,
+        // it will be discarded.
+        if (change.nodeExistsConstraintOnRevert !== undefined) {
+            inverse.nodeExistsConstraint = change.nodeExistsConstraintOnRevert;
+        }
         if (change.fieldChanges !== undefined) {
             inverse.fieldChanges = this.invertFieldMap(change.fieldChanges, id, isRollback, genId, crossFieldTable, revisionMetadata, revisionForInvert);
         }
@@ -411,12 +437,11 @@ export class ModularChangeFamily {
             baseToRebasedNodeId: newTupleBTree(),
             rebasedFields: new Set(),
             rebasedNodeToParent: brand(change.nodeToParent.clone()),
-            rebasedCrossFieldKeys: brand(change.crossFieldKeys.clone()),
+            rebasedCrossFieldKeys: change.crossFieldKeys.clone(),
             nodeIdPairs: [],
             affectedBaseFields: newTupleBTree(),
             fieldsWithUnattachedChild: new Set(),
         };
-        const constraintState = newConstraintState(change.constraintViolationCount ?? 0);
         const getBaseRevisions = () => revisionInfoFromTaggedChange(over).map((info) => info.revision);
         const rebaseMetadata = {
             ...revisionMetadata,
@@ -424,9 +449,11 @@ export class ModularChangeFamily {
             getBaseRevisions,
         };
         const rebasedNodes = brand(change.nodeChanges.clone());
-        const rebasedFields = this.rebaseIntersectingFields(crossFieldTable, rebasedNodes, genId, constraintState, rebaseMetadata);
+        const rebasedFields = this.rebaseIntersectingFields(crossFieldTable, rebasedNodes, genId, rebaseMetadata);
         this.rebaseInvalidatedElements(rebasedFields, rebasedNodes, crossFieldTable, rebaseMetadata, genId);
-        this.updateConstraintsForFields(rebasedFields, NodeAttachState.Attached, constraintState, rebasedNodes);
+        const constraintState = newConstraintState(change.constraintViolationCount ?? 0);
+        const revertConstraintState = newConstraintState(change.constraintViolationCountOnRevert ?? 0);
+        this.updateConstraintsForFields(rebasedFields, NodeAttachState.Attached, NodeAttachState.Attached, constraintState, revertConstraintState, rebasedNodes);
         const rebased = makeModularChangeset({
             fieldChanges: this.pruneFieldMap(rebasedFields, rebasedNodes),
             nodeChanges: rebasedNodes,
@@ -436,6 +463,7 @@ export class ModularChangeFamily {
             maxId: idState.maxId,
             revisions: change.revisions,
             constraintViolationCount: constraintState.violationCount,
+            constraintViolationCountOnRevert: revertConstraintState.violationCount,
             builds: change.builds,
             destroys: change.destroys,
             refreshers: change.refreshers,
@@ -444,14 +472,14 @@ export class ModularChangeFamily {
     }
     // 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) {
+    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);
         // 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);
+            const rebasedNode = this.rebaseNodeChange(newId, baseId, genId, crossFieldTable, metadata);
             setInChangeAtomIdMap(rebasedNodes, newId, rebasedNode);
         }
         return rebasedFields;
@@ -626,7 +654,7 @@ export class ModularChangeFamily {
         }
         return rebasedFields;
     }
-    rebaseNodeChange(newId, baseId, genId, crossFieldTable, revisionMetadata, constraintState) {
+    rebaseNodeChange(newId, baseId, genId, crossFieldTable, revisionMetadata) {
         const change = nodeChangeFromId(crossFieldTable.newChange.nodeChanges, newId);
         const over = nodeChangeFromId(crossFieldTable.baseChange.nodeChanges, baseId);
         const baseMap = over?.fieldChanges ?? new Map();
@@ -640,25 +668,32 @@ export class ModularChangeFamily {
         if (change?.nodeExistsConstraint !== undefined) {
             rebasedChange.nodeExistsConstraint = change.nodeExistsConstraint;
         }
+        if (change?.nodeExistsConstraintOnRevert !== undefined) {
+            rebasedChange.nodeExistsConstraintOnRevert = change.nodeExistsConstraintOnRevert;
+        }
         setInChangeAtomIdMap(crossFieldTable.baseToRebasedNodeId, baseId, newId);
         return rebasedChange;
     }
-    updateConstraintsForFields(fields, parentAttachState, constraintState, nodes) {
+    updateConstraintsForFields(fields, parentInputAttachState, parentOutputAttachState, constraintState, revertConstraintState, nodes) {
         for (const field of fields.values()) {
             const handler = getChangeHandler(this.fieldKinds, field.fieldKind);
-            for (const [nodeId, index] of handler.getNestedChanges(field.change)) {
-                const isDetached = index === undefined;
-                const attachState = parentAttachState === NodeAttachState.Detached || isDetached
+            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, attachState, constraintState, nodes);
+                this.updateConstraintsForNode(nodeId, inputAttachState, outputAttachState, nodes, constraintState, revertConstraintState);
             }
         }
     }
-    updateConstraintsForNode(nodeId, attachState, constraintState, nodes) {
+    updateConstraintsForNode(nodeId, inputAttachState, outputAttachState, nodes, constraintState, revertConstraintState) {
         const node = nodes.get([nodeId.revision, nodeId.localId]) ?? fail("Unknown node ID");
         if (node.nodeExistsConstraint !== undefined) {
-            const isNowViolated = attachState === NodeAttachState.Detached;
+            const isNowViolated = inputAttachState === NodeAttachState.Detached;
             if (node.nodeExistsConstraint.violated !== isNowViolated) {
                 node.nodeExistsConstraint = {
                     ...node.nodeExistsConstraint,
@@ -667,8 +702,18 @@ export class ModularChangeFamily {
                 constraintState.violationCount += isNowViolated ? 1 : -1;
             }
         }
+        if (node.nodeExistsConstraintOnRevert !== undefined) {
+            const isNowViolated = outputAttachState === NodeAttachState.Detached;
+            if (node.nodeExistsConstraintOnRevert.violated !== isNowViolated) {
+                node.nodeExistsConstraintOnRevert = {
+                    ...node.nodeExistsConstraintOnRevert,
+                    violated: isNowViolated,
+                };
+                revertConstraintState.violationCount += isNowViolated ? 1 : -1;
+            }
+        }
         if (node.fieldChanges !== undefined) {
-            this.updateConstraintsForFields(node.fieldChanges, attachState, constraintState, nodes);
+            this.updateConstraintsForFields(node.fieldChanges, inputAttachState, outputAttachState, constraintState, revertConstraintState, nodes);
         }
     }
     pruneFieldMap(changeset, nodeMap) {
@@ -777,8 +822,8 @@ export class ModularChangeFamily {
     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 });
+            for (const { key, count } of keys) {
+                table.set(key, count, { nodeId: parent, field: fieldKey });
             }
         }
     }
@@ -817,7 +862,7 @@ export class ModularChangeFamily {
                 numChildren += 1;
             }
             for (const keyRange of handler.getCrossFieldKeys(fieldChange.change)) {
-                const fields = getFieldsForCrossFieldKey(change, keyRange);
+                const fields = getFieldsForCrossFieldKey(change, keyRange.key, keyRange.count);
                 assert(fields.length === 1 &&
                     fields[0] !== undefined &&
                     areEqualFieldIds(fields[0], fieldId), 0xa4f /* Inconsistent cross field keys */);
@@ -828,14 +873,15 @@ export class ModularChangeFamily {
 }
 ModularChangeFamily.emptyChange = makeModularChangeset();
 function replaceCrossFieldKeyTableRevisions(table, oldRevisions, newRevision, nodeAliases) {
-    const updated = newTupleBTree();
-    table.forEachPair(([target, revision, id, count], field) => {
-        const updatedKey = [
-            target,
-            replaceRevision(revision, oldRevisions, newRevision),
-            id,
-            count,
-        ];
+    const updated = newCrossFieldKeyTable();
+    for (const entry of table.entries()) {
+        const key = entry.start;
+        const updatedKey = {
+            target: key.target,
+            revision: replaceRevision(key.revision, oldRevisions, newRevision),
+            localId: key.localId,
+        };
+        const field = entry.value;
         const normalizedFieldId = normalizeFieldId(field, nodeAliases);
         const updatedNodeId = normalizedFieldId.nodeId !== undefined
             ? replaceAtomRevisions(normalizedFieldId.nodeId, oldRevisions, newRevision)
@@ -844,8 +890,8 @@ function replaceCrossFieldKeyTableRevisions(table, oldRevisions, newRevision, no
             ...normalizedFieldId,
             nodeId: updatedNodeId,
         };
-        updated.set(updatedKey, updatedValue);
-    });
+        updated.set(updatedKey, entry.length, updatedValue);
+    }
     return updated;
 }
 function replaceRevision(revision, oldRevisions, newRevision) {
@@ -869,9 +915,9 @@ function composeBuildsDestroysAndRefreshers(change1, change2) {
     // Note that it would in principle be possible to adopt the later build and exclude from the
     // composition all the changes already reflected on the tree, but that is not something we
     // care to support at this time.
-    const allBuilds = brand(mergeBTrees(change1.builds ?? newTupleBTree(), change2.builds ?? newTupleBTree(), true));
-    const allDestroys = brand(mergeBTrees(change1.destroys ?? newTupleBTree(), change2.destroys ?? newTupleBTree()));
-    const allRefreshers = brand(mergeBTrees(change1.refreshers ?? newTupleBTree(), change2.refreshers ?? newTupleBTree(), true));
+    const allBuilds = brand(mergeTupleBTrees(change1.builds ?? newTupleBTree(), change2.builds ?? newTupleBTree(), true));
+    const allDestroys = brand(mergeTupleBTrees(change1.destroys ?? newTupleBTree(), change2.destroys ?? newTupleBTree()));
+    const allRefreshers = brand(mergeTupleBTrees(change1.refreshers ?? newTupleBTree(), change2.refreshers ?? newTupleBTree(), true));
     if (change1.destroys !== undefined && change2.builds !== undefined) {
         for (const [key, chunk] of change2.builds.entries()) {
             const destroyCount = change1.destroys.get(key);
@@ -973,7 +1019,7 @@ export function updateRefreshers(change, getDetachedNode, removedRoots, requireR
             refreshers.set([root.major, brand(root.minor)], node);
         }
     }
-    const { fieldChanges, nodeChanges, maxId, revisions, constraintViolationCount, builds, destroys, } = change;
+    const { fieldChanges, nodeChanges, maxId, revisions, constraintViolationCount, constraintViolationCountOnRevert, builds, destroys, } = change;
     return makeModularChangeset({
         fieldChanges,
         nodeChanges,
@@ -983,25 +1029,35 @@ export function updateRefreshers(change, getDetachedNode, removedRoots, requireR
         maxId: maxId,
         revisions,
         constraintViolationCount,
+        constraintViolationCountOnRevert,
         builds,
         destroys,
         refreshers,
     });
 }
 /**
+ * Converts a change into the delta format.
+ *
  * @param change - The change to convert into a delta.
  * @param fieldKinds - The field kinds to delegate to.
  */
 export function intoDelta(taggedChange, fieldKinds) {
     const change = taggedChange.change;
-    const idAllocator = MemoizedIdRangeAllocator.fromNextId();
     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, idAllocator, fieldKinds);
+        const fieldDeltas = intoDeltaImpl(change.fieldChanges, change.nodeChanges, fieldKinds, global, rename);
         if (fieldDeltas.size > 0) {
             rootDelta.fields = fieldDeltas;
         }
+        if (global.length > 0) {
+            rootDelta.global = global;
+        }
+        if (rename.length > 0) {
+            rootDelta.rename = rename;
+        }
     }
     // Constraint violations should not prevent nodes from being built
     if (change.builds && change.builds.size > 0) {
@@ -1038,22 +1094,24 @@ function copyDetachedNodes(detachedNodes) {
 /**
  * @param change - The change to convert into a delta.
  */
-function intoDeltaImpl(change, nodeChanges, idAllocator, fieldKinds) {
+function intoDeltaImpl(change, nodeChanges, fieldKinds, global, rename) {
     const delta = new Map();
     for (const [field, fieldChange] of change) {
-        const deltaField = getChangeHandler(fieldKinds, fieldChange.fieldKind).intoDelta(fieldChange.change, (childChange) => {
+        const { local: fieldChanges, global: fieldGlobal, rename: fieldRename, } = getChangeHandler(fieldKinds, fieldChange.fieldKind).intoDelta(fieldChange.change, (childChange) => {
             const nodeChange = nodeChangeFromId(nodeChanges, childChange);
-            return deltaFromNodeChange(nodeChange, nodeChanges, idAllocator, fieldKinds);
-        }, idAllocator);
-        if (!isEmptyFieldChanges(deltaField)) {
-            delta.set(field, deltaField);
+            return deltaFromNodeChange(nodeChange, nodeChanges, fieldKinds, global, rename);
+        });
+        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, idAllocator, fieldKinds) {
+function deltaFromNodeChange(change, nodeChanges, fieldKinds, global, rename) {
     if (change.fieldChanges !== undefined) {
-        return intoDeltaImpl(change.fieldChanges, nodeChanges, idAllocator, fieldKinds);
+        return intoDeltaImpl(change.fieldChanges, nodeChanges, fieldKinds, global, rename);
     }
     // TODO: update the API to allow undefined to be returned here
     return new Map();
@@ -1085,7 +1143,9 @@ export function rebaseRevisionMetadataFromInfo(revInfos, revisionToRebase, baseR
     };
 }
 function isEmptyNodeChangeset(change) {
-    return change.fieldChanges === undefined && change.nodeExistsConstraint === undefined;
+    return (change.fieldChanges === undefined &&
+        change.nodeExistsConstraint === undefined &&
+        change.nodeExistsConstraintOnRevert === undefined);
 }
 export function getFieldKind(fieldKinds, kind) {
     if (kind === genericFieldKind.identifier) {
@@ -1117,10 +1177,10 @@ function newComposeTable(baseChange, newChange, composedNodeToParent) {
 }
 function newCrossFieldTable() {
     return {
-        srcTable: new Map(),
-        dstTable: new Map(),
-        srcDependents: new Map(),
-        dstDependents: new Map(),
+        srcTable: newChangeAtomIdRangeMap(),
+        dstTable: newChangeAtomIdRangeMap(),
+        srcDependents: newChangeAtomIdRangeMap(),
+        dstDependents: newChangeAtomIdRangeMap(),
         invalidatedFields: new Set(),
     };
 }
@@ -1191,19 +1251,17 @@ class RebaseManager extends CrossFieldManagerI {
     }
     set(target, revision, id, count, newValue, invalidateDependents) {
         if (invalidateDependents && this.allowInval) {
-            const newFieldIds = getFieldsForCrossFieldKey(this.table.newChange, [
+            const newFieldIds = getFieldsForCrossFieldKey(this.table.newChange, {
                 target,
                 revision,
-                id,
-                count,
-            ]);
+                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, [
+            const baseFieldIds = getFieldsForCrossFieldKey(this.table.baseChange, {
                 target,
                 revision,
-                id,
-                count,
-            ]);
+                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);
@@ -1215,7 +1273,7 @@ class RebaseManager extends CrossFieldManagerI {
         setInChangeAtomIdMap(this.table.rebasedNodeToParent, id, this.fieldId);
     }
     moveKey(target, revision, id, count) {
-        setInCrossFieldKeyTable(this.table.rebasedCrossFieldKeys, target, revision, id, count, this.fieldId);
+        this.table.rebasedCrossFieldKeys.set({ target, revision, localId: id }, count, this.fieldId);
     }
     get table() {
         return this.crossFieldTable;
@@ -1229,24 +1287,22 @@ class ComposeManager extends CrossFieldManagerI {
     }
     set(target, revision, id, count, newValue, invalidateDependents) {
         if (invalidateDependents && this.allowInval) {
-            const newFieldIds = getFieldsForCrossFieldKey(this.table.newChange, [
+            const newFieldIds = getFieldsForCrossFieldKey(this.table.newChange, {
                 target,
                 revision,
-                id,
-                count,
-            ]);
+                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 {
-                const baseFieldIds = getFieldsForCrossFieldKey(this.table.baseChange, [
+                const baseFieldIds = getFieldsForCrossFieldKey(this.table.baseChange, {
                     target,
                     revision,
-                    id,
-                    count,
-                ]);
+                    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);
@@ -1284,6 +1340,10 @@ function makeModularChangeset(props = {
     if (props.constraintViolationCount !== undefined && props.constraintViolationCount > 0) {
         changeset.constraintViolationCount = props.constraintViolationCount;
     }
+    if (props.constraintViolationCountOnRevert !== undefined &&
+        props.constraintViolationCountOnRevert > 0) {
+        changeset.constraintViolationCountOnRevert = props.constraintViolationCountOnRevert;
+    }
     if (props.builds !== undefined && props.builds.size > 0) {
         changeset.builds = props.builds;
     }
@@ -1417,13 +1477,27 @@ export class ModularEditBuilder extends EditBuilder {
             revision,
         }), revision));
     }
+    addNodeExistsConstraintOnRevert(path, revision) {
+        const nodeChange = {
+            nodeExistsConstraintOnRevert: { violated: false },
+        };
+        this.applyChange(tagChange(buildModularChangesetFromNode({
+            path,
+            nodeChange,
+            nodeChanges: newTupleBTree(),
+            nodeToParent: newTupleBTree(),
+            crossFieldKeys: newCrossFieldKeyTable(),
+            idAllocator: this.idAllocator,
+            revision,
+        }), revision));
+    }
 }
 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) {
-        for (const key of localCrossFieldKeys) {
-            crossFieldKeys.set(key, { nodeId: undefined, field: path.field });
+        for (const { key, count } of localCrossFieldKeys) {
+            crossFieldKeys.set(key, count, { nodeId: undefined, field: path.field });
         }
         if (childId !== undefined) {
             setInChangeAtomIdMap(nodeToParent, childId, {
@@ -1444,8 +1518,8 @@ function buildModularChangesetFromField(props) {
         fieldChanges,
     };
     const parentId = { localId: brand(idAllocator.allocate()), revision };
-    for (const key of localCrossFieldKeys) {
-        crossFieldKeys.set(key, { 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, {
@@ -1518,19 +1592,6 @@ function revisionInfoFromTaggedChange(taggedChange) {
     }
     return revInfos;
 }
-function mergeBTrees(tree1, tree2, preferLeft = true) {
-    if (tree1 === undefined) {
-        return tree2 !== undefined ? brand(tree2.clone()) : newTupleBTree();
-    }
-    const result = brand(tree1.clone());
-    if (tree2 === undefined) {
-        return result;
-    }
-    for (const [key, value] of tree2.entries()) {
-        result.set(key, value, !preferLeft);
-    }
-    return result;
-}
 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");
@@ -1581,72 +1642,13 @@ export function getParentFieldId(changeset, nodeId) {
     assert(parentId !== undefined, 0x9cb /* 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, Number.POSITIVE_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 getFieldsForCrossFieldKey(changeset, key, count) {
+    return changeset.crossFieldKeys
+        .getAll(key, count)
+        .map(({ value: fieldId }) => normalizeFieldId(fieldId, changeset.nodeAliases));
 }
-function normalizeFieldId(fieldId, nodeAliases) {
+// 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;
@@ -1668,36 +1670,6 @@ function normalizeNodeId(nodeId, nodeAliases) {
 function hasConflicts(change) {
     return (change.constraintViolationCount ?? 0) > 0;
 }
-export function newCrossFieldKeyTable() {
-    return newTupleBTree();
-}
-export function newTupleBTree(entries) {
-    return brand(new BTree(entries, 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];
-        // Less-than and greater-than always return false if either value is undefined,
-        // so we handle undefined separately, treating it as less than all other values.
-        if (a === undefined && b !== undefined) {
-            return -1;
-        }
-        else if (b === undefined && a !== undefined) {
-            return 1;
-        }
-        else if (a < b) {
-            return -1;
-        }
-        else if (a > b) {
-            return 1;
-        }
-    }
-    return 0;
-}
 function getFromChangeAtomIdMap(map, id) {
     return map.get([id.revision, id.localId]);
 }