@fluidframework/tree 2.12.0 → 2.20.0

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

@@ -4,18 +4,18 @@
  * Licensed under the MIT License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.newTupleBTree = exports.newCrossFieldKeyTable = exports.getFieldsForCrossFieldKey = exports.getParentFieldId = exports.ModularEditBuilder = exports.getChangeHandler = exports.getFieldKind = exports.rebaseRevisionMetadataFromInfo = exports.intoDelta = exports.updateRefreshers = exports.relevantRemovedRoots = exports.ModularChangeFamily = void 0;
+exports.normalizeFieldId = exports.getParentFieldId = exports.ModularEditBuilder = exports.getChangeHandler = exports.getFieldKind = exports.rebaseRevisionMetadataFromInfo = exports.intoDelta = exports.updateRefreshers = exports.relevantRemovedRoots = exports.ModularChangeFamily = void 0;
 const internal_1 = require("@fluidframework/core-utils/internal");
 const sorted_btree_es6_1 = require("@tylerbu/sorted-btree-es6");
 const index_js_1 = require("../../core/index.js");
 const index_js_2 = require("../../util/index.js");
 const index_js_3 = require("../chunked-forest/index.js");
 const mapTreeCursor_js_1 = require("../mapTreeCursor.js");
-const memoizedIdRangeAllocator_js_1 = require("../memoizedIdRangeAllocator.js");
 const crossFieldQueries_js_1 = require("./crossFieldQueries.js");
 const fieldChangeHandler_js_1 = require("./fieldChangeHandler.js");
 const fieldKindWithEditor_js_1 = require("./fieldKindWithEditor.js");
 const genericFieldKind_js_1 = require("./genericFieldKind.js");
+const modularChangeTypes_js_1 = require("./modularChangeTypes.js");
 /**
  * Implementation of ChangeFamily which delegates work in a given field to the appropriate FieldKind
  * as determined by the schema.
@@ -102,10 +102,10 @@ class ModularChangeFamily {
         if (hasConflicts(change1) && hasConflicts(change2)) {
             return {
                 fieldChanges: new Map(),
-                nodeChanges: newTupleBTree(),
-                nodeToParent: newTupleBTree(),
-                nodeAliases: newTupleBTree(),
-                crossFieldKeys: newTupleBTree(),
+                nodeChanges: (0, index_js_2.newTupleBTree)(),
+                nodeToParent: (0, index_js_2.newTupleBTree)(),
+                nodeAliases: (0, index_js_2.newTupleBTree)(),
+                crossFieldKeys: (0, modularChangeTypes_js_1.newCrossFieldKeyTable)(),
             };
         }
         else if (hasConflicts(change1)) {
@@ -124,20 +124,20 @@ 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 = (0, index_js_2.brand)(mergeBTrees(change1.nodeChanges, change2.nodeChanges));
-        const composedNodeToParent = (0, index_js_2.brand)(mergeBTrees(change1.nodeToParent, change2.nodeToParent));
-        const composedNodeAliases = (0, index_js_2.brand)(mergeBTrees(change1.nodeAliases, change2.nodeAliases));
+        const composedNodeChanges = (0, index_js_2.brand)((0, index_js_2.mergeTupleBTrees)(change1.nodeChanges, change2.nodeChanges));
+        const composedNodeToParent = (0, index_js_2.brand)((0, index_js_2.mergeTupleBTrees)(change1.nodeToParent, change2.nodeToParent));
+        const composedNodeAliases = (0, index_js_2.brand)((0, index_js_2.mergeTupleBTrees)(change1.nodeAliases, change2.nodeAliases));
         const crossFieldTable = newComposeTable(change1, change2, composedNodeToParent);
         const 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 = index_js_2.RangeMap.union(change1.crossFieldKeys, change2.crossFieldKeys);
         return {
             fieldChanges: composedFields,
             nodeChanges: composedNodeChanges,
             nodeToParent: composedNodeToParent,
             nodeAliases: composedNodeAliases,
-            crossFieldKeys: (0, index_js_2.brand)(composedCrossFieldKeys),
+            crossFieldKeys: composedCrossFieldKeys,
         };
     }
     composeInvalidatedField(fieldChange, crossFieldTable, genId, revisionMetadata) {
@@ -303,7 +303,18 @@ 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) {
@@ -312,6 +323,9 @@ class ModularChangeFamily {
         if (nodeExistsConstraint !== undefined) {
             composedNodeChange.nodeExistsConstraint = nodeExistsConstraint;
         }
+        if (nodeExistsConstraintOnRevert !== undefined) {
+            composedNodeChange.nodeExistsConstraintOnRevert = nodeExistsConstraintOnRevert;
+        }
         return composedNodeChange;
     }
     /**
@@ -344,7 +358,7 @@ class ModularChangeFamily {
         const { revInfos: oldRevInfos } = getRevInfoFromTaggedChanges([change]);
         const revisionMetadata = (0, index_js_1.revisionMetadataSourceFromInfo)(oldRevInfos);
         const invertedFields = this.invertFieldMap(change.change.fieldChanges, undefined, isRollback, genId, crossFieldTable, revisionMetadata, revisionForInvert);
-        const invertedNodes = newTupleBTree();
+        const invertedNodes = (0, index_js_2.newTupleBTree)();
         change.change.nodeChanges.forEachPair(([revision, localId], nodeChangeset) => {
             invertedNodes.set([revision, localId], this.invertNodeChange(nodeChangeset, { revision, localId }, isRollback, genId, crossFieldTable, revisionMetadata, revisionForInvert));
         });
@@ -369,7 +383,8 @@ class ModularChangeFamily {
             crossFieldKeys,
             maxId: genId.getMaxId(),
             revisions: revInfos,
-            constraintViolationCount: change.change.constraintViolationCount,
+            constraintViolationCount: change.change.constraintViolationCountOnRevert,
+            constraintViolationCountOnRevert: change.change.constraintViolationCount,
             destroys,
         });
     }
@@ -393,6 +408,17 @@ 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,15 +437,14 @@ class ModularChangeFamily {
             newChange: change,
             baseChange: over.change,
             baseFieldToContext: new Map(),
-            baseToRebasedNodeId: newTupleBTree(),
+            baseToRebasedNodeId: (0, index_js_2.newTupleBTree)(),
             rebasedFields: new Set(),
             rebasedNodeToParent: (0, index_js_2.brand)(change.nodeToParent.clone()),
-            rebasedCrossFieldKeys: (0, index_js_2.brand)(change.crossFieldKeys.clone()),
+            rebasedCrossFieldKeys: change.crossFieldKeys.clone(),
             nodeIdPairs: [],
-            affectedBaseFields: newTupleBTree(),
+            affectedBaseFields: (0, index_js_2.newTupleBTree)(),
             fieldsWithUnattachedChild: new Set(),
         };
-        const constraintState = newConstraintState(change.constraintViolationCount ?? 0);
         const getBaseRevisions = () => revisionInfoFromTaggedChange(over).map((info) => info.revision);
         const rebaseMetadata = {
             ...revisionMetadata,
@@ -427,9 +452,11 @@ class ModularChangeFamily {
             getBaseRevisions,
         };
         const rebasedNodes = (0, index_js_2.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, fieldChangeHandler_js_1.NodeAttachState.Attached, constraintState, rebasedNodes);
+        const constraintState = newConstraintState(change.constraintViolationCount ?? 0);
+        const revertConstraintState = newConstraintState(change.constraintViolationCountOnRevert ?? 0);
+        this.updateConstraintsForFields(rebasedFields, fieldChangeHandler_js_1.NodeAttachState.Attached, fieldChangeHandler_js_1.NodeAttachState.Attached, constraintState, revertConstraintState, rebasedNodes);
         const rebased = makeModularChangeset({
             fieldChanges: this.pruneFieldMap(rebasedFields, rebasedNodes),
             nodeChanges: rebasedNodes,
@@ -439,6 +466,7 @@ class ModularChangeFamily {
             maxId: idState.maxId,
             revisions: change.revisions,
             constraintViolationCount: constraintState.violationCount,
+            constraintViolationCountOnRevert: revertConstraintState.violationCount,
             builds: change.builds,
             destroys: change.destroys,
             refreshers: change.refreshers,
@@ -447,14 +475,14 @@ 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;
@@ -629,7 +657,7 @@ 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();
@@ -643,25 +671,32 @@ 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 === fieldChangeHandler_js_1.NodeAttachState.Detached || isDetached
+            for (const [nodeId, inputIndex, outputIndex] of handler.getNestedChanges(field.change)) {
+                const isInputDetached = inputIndex === undefined;
+                const inputAttachState = parentInputAttachState === fieldChangeHandler_js_1.NodeAttachState.Detached || isInputDetached
                     ? fieldChangeHandler_js_1.NodeAttachState.Detached
                     : fieldChangeHandler_js_1.NodeAttachState.Attached;
-                this.updateConstraintsForNode(nodeId, attachState, constraintState, nodes);
+                const isOutputDetached = outputIndex === undefined;
+                const outputAttachState = parentOutputAttachState === fieldChangeHandler_js_1.NodeAttachState.Detached || isOutputDetached
+                    ? fieldChangeHandler_js_1.NodeAttachState.Detached
+                    : fieldChangeHandler_js_1.NodeAttachState.Attached;
+                this.updateConstraintsForNode(nodeId, inputAttachState, outputAttachState, nodes, constraintState, revertConstraintState);
             }
         }
     }
-    updateConstraintsForNode(nodeId, attachState, constraintState, nodes) {
+    updateConstraintsForNode(nodeId, inputAttachState, outputAttachState, nodes, constraintState, revertConstraintState) {
         const node = nodes.get([nodeId.revision, nodeId.localId]) ?? (0, index_js_2.fail)("Unknown node ID");
         if (node.nodeExistsConstraint !== undefined) {
-            const isNowViolated = attachState === fieldChangeHandler_js_1.NodeAttachState.Detached;
+            const isNowViolated = inputAttachState === fieldChangeHandler_js_1.NodeAttachState.Detached;
             if (node.nodeExistsConstraint.violated !== isNowViolated) {
                 node.nodeExistsConstraint = {
                     ...node.nodeExistsConstraint,
@@ -670,8 +705,18 @@ class ModularChangeFamily {
                 constraintState.violationCount += isNowViolated ? 1 : -1;
             }
         }
+        if (node.nodeExistsConstraintOnRevert !== undefined) {
+            const isNowViolated = outputAttachState === fieldChangeHandler_js_1.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) {
@@ -711,11 +756,11 @@ class ModularChangeFamily {
             ? [undefined]
             : change.revisions.map((revInfo) => revInfo.revision));
         const updatedFields = this.replaceFieldMapRevisions(change.fieldChanges, oldRevisions, newRevision);
-        const updatedNodes = newTupleBTree();
+        const updatedNodes = (0, index_js_2.newTupleBTree)();
         for (const [[revision, id], nodeChangeset] of change.nodeChanges.entries()) {
             updatedNodes.set([replaceRevision(revision, oldRevisions, newRevision), id], this.replaceNodeChangesetRevisions(nodeChangeset, oldRevisions, newRevision));
         }
-        const updatedNodeToParent = newTupleBTree();
+        const updatedNodeToParent = (0, index_js_2.newTupleBTree)();
         for (const [[revision, id], fieldId] of change.nodeToParent.entries()) {
             updatedNodeToParent.set([replaceRevision(revision, oldRevisions, newRevision), id], replaceFieldIdRevision(normalizeFieldId(fieldId, change.nodeAliases), oldRevisions, newRevision));
         }
@@ -725,7 +770,7 @@ class ModularChangeFamily {
             nodeChanges: updatedNodes,
             nodeToParent: updatedNodeToParent,
             // We've updated all references to old node IDs, so we no longer need an alias table.
-            nodeAliases: newTupleBTree(),
+            nodeAliases: (0, index_js_2.newTupleBTree)(),
             crossFieldKeys: replaceCrossFieldKeyTableRevisions(change.crossFieldKeys, oldRevisions, newRevision, change.nodeAliases),
         };
         if (change.builds !== undefined) {
@@ -765,7 +810,7 @@ class ModularChangeFamily {
         return updatedFields;
     }
     makeCrossFieldKeyTable(fields, nodes) {
-        const keys = newCrossFieldKeyTable();
+        const keys = (0, modularChangeTypes_js_1.newCrossFieldKeyTable)();
         this.populateCrossFieldKeyTableForFieldMap(keys, fields, undefined);
         nodes.forEachPair(([revision, localId], node) => {
             if (node.fieldChanges !== undefined) {
@@ -780,8 +825,8 @@ 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 });
             }
         }
     }
@@ -820,7 +865,7 @@ 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);
                 (0, internal_1.assert)(fields.length === 1 &&
                     fields[0] !== undefined &&
                     areEqualFieldIds(fields[0], fieldId), 0xa4f /* Inconsistent cross field keys */);
@@ -832,14 +877,15 @@ class ModularChangeFamily {
 exports.ModularChangeFamily = 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 = (0, modularChangeTypes_js_1.newCrossFieldKeyTable)();
+    for (const entry of table.entries()) {
+        const key = entry.start;
+        const updatedKey = {
+            target: key.target,
+            revision: replaceRevision(key.revision, oldRevisions, newRevision),
+            localId: key.localId,
+        };
+        const field = entry.value;
         const normalizedFieldId = normalizeFieldId(field, nodeAliases);
         const updatedNodeId = normalizedFieldId.nodeId !== undefined
             ? (0, index_js_1.replaceAtomRevisions)(normalizedFieldId.nodeId, oldRevisions, newRevision)
@@ -848,15 +894,15 @@ 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) {
     return oldRevisions.has(revision) ? newRevision : revision;
 }
 function replaceIdMapRevisions(map, oldRevisions, newRevision) {
-    const updated = newTupleBTree();
+    const updated = (0, index_js_2.newTupleBTree)();
     for (const [[revision, id], value] of map.entries()) {
         updated.set([replaceRevision(revision, oldRevisions, newRevision), id], value);
     }
@@ -873,9 +919,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 = (0, index_js_2.brand)(mergeBTrees(change1.builds ?? newTupleBTree(), change2.builds ?? newTupleBTree(), true));
-    const allDestroys = (0, index_js_2.brand)(mergeBTrees(change1.destroys ?? newTupleBTree(), change2.destroys ?? newTupleBTree()));
-    const allRefreshers = (0, index_js_2.brand)(mergeBTrees(change1.refreshers ?? newTupleBTree(), change2.refreshers ?? newTupleBTree(), true));
+    const allBuilds = (0, index_js_2.brand)((0, index_js_2.mergeTupleBTrees)(change1.builds ?? (0, index_js_2.newTupleBTree)(), change2.builds ?? (0, index_js_2.newTupleBTree)(), true));
+    const allDestroys = (0, index_js_2.brand)((0, index_js_2.mergeTupleBTrees)(change1.destroys ?? (0, index_js_2.newTupleBTree)(), change2.destroys ?? (0, index_js_2.newTupleBTree)()));
+    const allRefreshers = (0, index_js_2.brand)((0, index_js_2.mergeTupleBTrees)(change1.refreshers ?? (0, index_js_2.newTupleBTree)(), change2.refreshers ?? (0, index_js_2.newTupleBTree)(), true));
     if (change1.destroys !== undefined && change2.builds !== undefined) {
         for (const [key, chunk] of change2.builds.entries()) {
             const destroyCount = change1.destroys.get(key);
@@ -947,7 +993,7 @@ function* relevantRemovedRootsFromFields(change, nodeChanges, fieldKinds) {
  * corresponding build or refresher.
  */
 function updateRefreshers(change, getDetachedNode, removedRoots, requireRefreshers = true) {
-    const refreshers = newTupleBTree();
+    const refreshers = (0, index_js_2.newTupleBTree)();
     const chunkLengths = new Map();
     if (change.builds !== undefined) {
         for (const [[revision, id], chunk] of change.builds.entries()) {
@@ -978,7 +1024,7 @@ function updateRefreshers(change, getDetachedNode, removedRoots, requireRefreshe
             refreshers.set([root.major, (0, index_js_2.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,
@@ -988,6 +1034,7 @@ function updateRefreshers(change, getDetachedNode, removedRoots, requireRefreshe
         maxId: maxId,
         revisions,
         constraintViolationCount,
+        constraintViolationCountOnRevert,
         builds,
         destroys,
         refreshers,
@@ -995,19 +1042,28 @@ function updateRefreshers(change, getDetachedNode, removedRoots, requireRefreshe
 }
 exports.updateRefreshers = updateRefreshers;
 /**
+ * Converts a change into the delta format.
+ *
  * @param change - The change to convert into a delta.
  * @param fieldKinds - The field kinds to delegate to.
  */
 function intoDelta(taggedChange, fieldKinds) {
     const change = taggedChange.change;
-    const idAllocator = memoizedIdRangeAllocator_js_1.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) {
@@ -1045,22 +1101,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 (!(0, index_js_1.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();
@@ -1093,7 +1151,9 @@ function rebaseRevisionMetadataFromInfo(revInfos, revisionToRebase, baseRevision
 }
 exports.rebaseRevisionMetadataFromInfo = rebaseRevisionMetadataFromInfo;
 function isEmptyNodeChangeset(change) {
-    return change.fieldChanges === undefined && change.nodeExistsConstraint === undefined;
+    return (change.fieldChanges === undefined &&
+        change.nodeExistsConstraint === undefined &&
+        change.nodeExistsConstraintOnRevert === undefined);
 }
 function getFieldKind(fieldKinds, kind) {
     if (kind === genericFieldKind_js_1.genericFieldKind.identifier) {
@@ -1115,22 +1175,22 @@ function newComposeTable(baseChange, newChange, composedNodeToParent) {
         newChange,
         fieldToContext: new Map(),
         newFieldToBaseField: new Map(),
-        newToBaseNodeId: newTupleBTree(),
+        newToBaseNodeId: (0, index_js_2.newTupleBTree)(),
         composedNodes: new Set(),
         composedNodeToParent,
         pendingCompositions: {
             nodeIdsToCompose: [],
-            affectedBaseFields: newTupleBTree(),
-            affectedNewFields: newTupleBTree(),
+            affectedBaseFields: (0, index_js_2.newTupleBTree)(),
+            affectedNewFields: (0, index_js_2.newTupleBTree)(),
         },
     };
 }
 function newCrossFieldTable() {
     return {
-        srcTable: new Map(),
-        dstTable: new Map(),
-        srcDependents: new Map(),
-        dstDependents: new Map(),
+        srcTable: (0, index_js_1.newChangeAtomIdRangeMap)(),
+        dstTable: (0, index_js_1.newChangeAtomIdRangeMap)(),
+        srcDependents: (0, index_js_1.newChangeAtomIdRangeMap)(),
+        dstDependents: (0, index_js_1.newChangeAtomIdRangeMap)(),
         invalidatedFields: new Set(),
     };
 }
@@ -1201,19 +1261,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);
             (0, internal_1.assert)(newFieldIds.length === 0, 0x9c6 /* TODO: Modifying a cross-field key from the new changeset is currently unsupported */);
-            const baseFieldIds = getFieldsForCrossFieldKey(this.table.baseChange, [
+            const baseFieldIds = getFieldsForCrossFieldKey(this.table.baseChange, {
                 target,
                 revision,
-                id,
-                count,
-            ]);
+                localId: id,
+            }, count);
             (0, internal_1.assert)(baseFieldIds.length > 0, 0x9c7 /* Cross field key not registered in base or new change */);
             for (const baseFieldId of baseFieldIds) {
                 this.table.affectedBaseFields.set([baseFieldId.nodeId?.revision, baseFieldId.nodeId?.localId, baseFieldId.field], true);
@@ -1225,7 +1283,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;
@@ -1239,24 +1297,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);
                 (0, internal_1.assert)(baseFieldIds.length > 0, 0x9c8 /* Cross field key not registered in base or new change */);
                 for (const baseFieldId of baseFieldIds) {
                     this.table.pendingCompositions.affectedBaseFields.set([baseFieldId.nodeId?.revision, baseFieldId.nodeId?.localId, baseFieldId.field], true);
@@ -1280,10 +1336,10 @@ function makeModularChangeset(props = {
 }) {
     const changeset = {
         fieldChanges: props.fieldChanges ?? new Map(),
-        nodeChanges: props.nodeChanges ?? newTupleBTree(),
-        nodeToParent: props.nodeToParent ?? newTupleBTree(),
-        nodeAliases: props.nodeAliases ?? newTupleBTree(),
-        crossFieldKeys: props.crossFieldKeys ?? newCrossFieldKeyTable(),
+        nodeChanges: props.nodeChanges ?? (0, index_js_2.newTupleBTree)(),
+        nodeToParent: props.nodeToParent ?? (0, index_js_2.newTupleBTree)(),
+        nodeAliases: props.nodeAliases ?? (0, index_js_2.newTupleBTree)(),
+        crossFieldKeys: props.crossFieldKeys ?? (0, modularChangeTypes_js_1.newCrossFieldKeyTable)(),
     };
     if (props.revisions !== undefined && props.revisions.length > 0) {
         changeset.revisions = props.revisions;
@@ -1294,6 +1350,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;
     }
@@ -1335,7 +1395,7 @@ class ModularEditBuilder extends index_js_1.EditBuilder {
         if (content.mode === 1 /* CursorLocationType.Fields */ && content.getFieldLength() === 0) {
             return { type: "global", revision };
         }
-        const builds = newTupleBTree();
+        const builds = (0, index_js_2.newTupleBTree)();
         const chunkCompressor = {
             policy: index_js_3.defaultChunkPolicy,
             idCompressor,
@@ -1362,9 +1422,9 @@ class ModularEditBuilder extends index_js_1.EditBuilder {
         const modularChange = buildModularChangesetFromField({
             path: field,
             fieldChange: { fieldKind, change },
-            nodeChanges: newTupleBTree(),
-            nodeToParent: newTupleBTree(),
-            crossFieldKeys: newCrossFieldKeyTable(),
+            nodeChanges: (0, index_js_2.newTupleBTree)(),
+            nodeToParent: (0, index_js_2.newTupleBTree)(),
+            crossFieldKeys: (0, modularChangeTypes_js_1.newCrossFieldKeyTable)(),
             idAllocator: this.idAllocator,
             localCrossFieldKeys,
             revision,
@@ -1391,9 +1451,9 @@ class ModularEditBuilder extends index_js_1.EditBuilder {
                         fieldKind: change.fieldKind,
                         change: change.change,
                     },
-                    nodeChanges: newTupleBTree(),
-                    nodeToParent: newTupleBTree(),
-                    crossFieldKeys: newCrossFieldKeyTable(),
+                    nodeChanges: (0, index_js_2.newTupleBTree)(),
+                    nodeToParent: (0, index_js_2.newTupleBTree)(),
+                    crossFieldKeys: (0, modularChangeTypes_js_1.newCrossFieldKeyTable)(),
                     idAllocator: this.idAllocator,
                     localCrossFieldKeys: getChangeHandler(this.fieldKinds, change.fieldKind).getCrossFieldKeys(change.change),
                     revision: change.revision,
@@ -1420,9 +1480,23 @@ class ModularEditBuilder extends index_js_1.EditBuilder {
         this.applyChange((0, index_js_1.tagChange)(buildModularChangesetFromNode({
             path,
             nodeChange,
-            nodeChanges: newTupleBTree(),
-            nodeToParent: newTupleBTree(),
-            crossFieldKeys: newCrossFieldKeyTable(),
+            nodeChanges: (0, index_js_2.newTupleBTree)(),
+            nodeToParent: (0, index_js_2.newTupleBTree)(),
+            crossFieldKeys: (0, modularChangeTypes_js_1.newCrossFieldKeyTable)(),
+            idAllocator: this.idAllocator,
+            revision,
+        }), revision));
+    }
+    addNodeExistsConstraintOnRevert(path, revision) {
+        const nodeChange = {
+            nodeExistsConstraintOnRevert: { violated: false },
+        };
+        this.applyChange((0, index_js_1.tagChange)(buildModularChangesetFromNode({
+            path,
+            nodeChange,
+            nodeChanges: (0, index_js_2.newTupleBTree)(),
+            nodeToParent: (0, index_js_2.newTupleBTree)(),
+            crossFieldKeys: (0, modularChangeTypes_js_1.newCrossFieldKeyTable)(),
             idAllocator: this.idAllocator,
             revision,
         }), revision));
@@ -1433,8 +1507,8 @@ function buildModularChangesetFromField(props) {
     const { path, fieldChange, nodeChanges, nodeToParent, crossFieldKeys, idAllocator = (0, index_js_2.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, {
@@ -1455,8 +1529,8 @@ function buildModularChangesetFromField(props) {
         fieldChanges,
     };
     const parentId = { localId: (0, index_js_2.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, {
@@ -1529,19 +1603,6 @@ function revisionInfoFromTaggedChange(taggedChange) {
     }
     return revInfos;
 }
-function mergeBTrees(tree1, tree2, preferLeft = true) {
-    if (tree1 === undefined) {
-        return tree2 !== undefined ? (0, index_js_2.brand)(tree2.clone()) : newTupleBTree();
-    }
-    const result = (0, index_js_2.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) ?? (0, index_js_2.fail)("No field exists for the given ID");
@@ -1593,77 +1654,18 @@ function getParentFieldId(changeset, nodeId) {
     return normalizeFieldId(parentId, changeset.nodeAliases);
 }
 exports.getParentFieldId = getParentFieldId;
-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,
-            (0, index_js_2.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;
-    }
-}
-exports.getFieldsForCrossFieldKey = getFieldsForCrossFieldKey;
-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, (0, index_js_2.brand)(lastQueryId + 1), lastEntryId - lastQueryId], entryValue);
-            break;
-        }
-        const nextId = (0, index_js_2.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));
 }
+// This is only exported for use in test utilities.
 function normalizeFieldId(fieldId, nodeAliases) {
     return fieldId.nodeId !== undefined
         ? { ...fieldId, nodeId: normalizeNodeId(fieldId.nodeId, nodeAliases) }
         : fieldId;
 }
+exports.normalizeFieldId = normalizeFieldId;
 /**
  * @returns The canonical form of nodeId, according to nodeAliases
  */
@@ -1681,38 +1683,6 @@ function normalizeNodeId(nodeId, nodeAliases) {
 function hasConflicts(change) {
     return (change.constraintViolationCount ?? 0) > 0;
 }
-function newCrossFieldKeyTable() {
-    return newTupleBTree();
-}
-exports.newCrossFieldKeyTable = newCrossFieldKeyTable;
-function newTupleBTree(entries) {
-    return (0, index_js_2.brand)(new sorted_btree_es6_1.BTree(entries, compareTuples));
-}
-exports.newTupleBTree = newTupleBTree;
-// 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]);
 }