@fluidframework/tree 2.13.0 → 2.20.0

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

@@ -4,7 +4,7 @@
  * 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");
@@ -15,6 +15,7 @@ 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.
@@ -101,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)) {
@@ -123,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) {
@@ -357,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));
         });
@@ -436,12 +437,12 @@ 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 getBaseRevisions = () => revisionInfoFromTaggedChange(over).map((info) => info.revision);
@@ -755,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));
         }
@@ -769,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) {
@@ -809,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) {
@@ -824,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 });
             }
         }
     }
@@ -864,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 */);
@@ -876,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)
@@ -892,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);
     }
@@ -917,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);
@@ -991,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()) {
@@ -1040,18 +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 rootDelta = {};
+    const global = [];
+    const rename = [];
     if (!hasConflicts(change)) {
         // If there are no constraint violations, then tree changes apply.
-        const fieldDeltas = intoDeltaImpl(change.fieldChanges, change.nodeChanges, fieldKinds);
+        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) {
@@ -1089,22 +1101,24 @@ function copyDetachedNodes(detachedNodes) {
 /**
  * @param change - The change to convert into a delta.
  */
-function intoDeltaImpl(change, nodeChanges, 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, fieldKinds);
+            return deltaFromNodeChange(nodeChange, nodeChanges, fieldKinds, global, rename);
         });
-        if (!(0, index_js_1.isEmptyFieldChanges)(deltaField)) {
-            delta.set(field, deltaField);
+        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, fieldKinds) {
+function deltaFromNodeChange(change, nodeChanges, fieldKinds, global, rename) {
     if (change.fieldChanges !== undefined) {
-        return intoDeltaImpl(change.fieldChanges, nodeChanges, fieldKinds);
+        return intoDeltaImpl(change.fieldChanges, nodeChanges, fieldKinds, global, rename);
     }
     // TODO: update the API to allow undefined to be returned here
     return new Map();
@@ -1161,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(),
     };
 }
@@ -1247,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);
@@ -1271,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;
@@ -1285,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);
@@ -1326,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;
@@ -1385,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,
@@ -1412,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,
@@ -1441,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,
@@ -1470,9 +1480,9 @@ 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));
@@ -1484,9 +1494,9 @@ 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));
@@ -1497,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, {
@@ -1519,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, {
@@ -1593,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");
@@ -1657,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
  */
@@ -1745,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]);
 }