@fluidframework/tree 2.1.0-281041 → 2.2.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.newCrossFieldKeyTable = exports.getFieldsForCrossFieldKey = exports.getParentFieldId = exports.ModularEditBuilder = exports.getChangeHandler = exports.getFieldKind = exports.rebaseRevisionMetadataFromInfo = exports.intoDelta = exports.updateRefreshers = exports.relevantRemovedRoots = exports.ModularChangeFamily = void 0;
+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;
 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");
@@ -75,30 +75,26 @@ class ModularChangeFamily {
     compose(changes) {
         const { revInfos, maxId } = getRevInfoFromTaggedChanges(changes);
         const idState = { maxId };
-        return changes.reduce((change1, change2) => (0, index_js_1.makeAnonChange)(this.composePair(change1, change2, revInfos, idState)), (0, index_js_1.makeAnonChange)({
-            fieldChanges: new Map(),
-            nodeChanges: new Map(),
-            nodeToParent: new Map(),
-            nodeAliases: new Map(),
-            crossFieldKeys: newCrossFieldKeyTable(),
-        })).change;
+        if (changes.length === 0) {
+            return makeModularChangeset();
+        }
+        return changes
+            .map((change) => change.change)
+            .reduce((change1, change2) => this.composePair(change1, change2, revInfos, idState));
     }
     composePair(change1, change2, revInfos, idState) {
-        const { fieldChanges, nodeChanges, nodeToParent, nodeAliases, crossFieldKeys } = this.composeAllFields(change1.change, change2.change, revInfos, idState);
-        const { allBuilds, allDestroys, allRefreshers } = composeBuildsDestroysAndRefreshers([
-            change1,
-            change2,
-        ]);
-        return makeModularChangeset(this.pruneFieldMap(fieldChanges, nodeChanges), nodeChanges, nodeToParent, nodeAliases, crossFieldKeys, idState.maxId, revInfos, undefined, allBuilds, allDestroys, allRefreshers);
+        const { fieldChanges, nodeChanges, nodeToParent, nodeAliases, crossFieldKeys } = this.composeAllFields(change1, change2, revInfos, idState);
+        const { allBuilds, allDestroys, allRefreshers } = composeBuildsDestroysAndRefreshers(change1, change2);
+        return makeModularChangeset(fieldChanges, nodeChanges, nodeToParent, nodeAliases, crossFieldKeys, idState.maxId, revInfos, undefined, allBuilds, allDestroys, allRefreshers);
     }
     composeAllFields(change1, change2, revInfos, idState) {
         if (hasConflicts(change1) && hasConflicts(change2)) {
             return {
                 fieldChanges: new Map(),
-                nodeChanges: new Map(),
-                nodeToParent: new Map(),
-                nodeAliases: new Map(),
-                crossFieldKeys: newBTree(),
+                nodeChanges: newTupleBTree(),
+                nodeToParent: newTupleBTree(),
+                nodeAliases: newTupleBTree(),
+                crossFieldKeys: newTupleBTree(),
             };
         }
         else if (hasConflicts(change1)) {
@@ -112,17 +108,17 @@ class ModularChangeFamily {
         const crossFieldTable = newComposeTable(change1, change2);
         // We merge nodeChanges, nodeToParent, and nodeAliases from the two changesets.
         // The merged tables will have correct entries for all nodes which are only referenced in one of the input changesets.
-        // During composeFieldMaps and processInvalidatedElements we will find all nodes referenced in both input changesets
+        // During composeFieldMaps and composeInvalidatedElements we will find all nodes referenced in both input changesets
         // and adjust these tables as necessary.
         // Note that when merging these tables we may encounter key collisions and will arbitrarily drop values in that case.
         // A collision for a node ID means that that node is referenced in both changesets
         // (since we assume that if two changesets use the same node ID they are referring to the same node),
         // therefore all collisions will be addressed when processing the intersection of the changesets.
-        const composedNodeChanges = mergeNestedMaps(change1.nodeChanges, change2.nodeChanges);
-        const composedNodeToParent = mergeNestedMaps(change1.nodeToParent, change2.nodeToParent);
-        const composedNodeAliases = mergeNestedMaps(change1.nodeAliases, change2.nodeAliases);
+        const 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 composedFields = this.composeFieldMaps(change1.fieldChanges, change2.fieldChanges, genId, crossFieldTable, revisionMetadata);
-        this.processInvalidatedElements(crossFieldTable, composedFields, composedNodeChanges, composedNodeToParent, composedNodeAliases, genId, 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);
         return {
@@ -141,8 +137,8 @@ class ModularChangeFamily {
         const composeNodes = (child1, child2) => {
             if (child1 !== undefined &&
                 child2 !== undefined &&
-                (0, index_js_1.getFromChangeAtomIdMap)(crossFieldTable.newToBaseNodeId, child2) === undefined) {
-                (0, index_js_1.setInChangeAtomIdMap)(crossFieldTable.newToBaseNodeId, child2, child1);
+                getFromChangeAtomIdMap(crossFieldTable.newToBaseNodeId, child2) === undefined) {
+                setInChangeAtomIdMap(crossFieldTable.newToBaseNodeId, child2, child1);
                 crossFieldTable.pendingCompositions.nodeIdsToCompose.push([child1, child2]);
             }
             return child1 ?? child2 ?? (0, index_js_2.fail)("Should not compose two undefined nodes");
@@ -160,7 +156,7 @@ class ModularChangeFamily {
      *
      * Updating an element may invalidate further elements. This function runs until there is no more invalidation.
      */
-    processInvalidatedElements(table, composedFields, composedNodes, composedNodeToParent, nodeAliases, genId, metadata) {
+    composeInvalidatedElements(table, composedFields, composedNodes, composedNodeToParent, nodeAliases, genId, metadata) {
         const pending = table.pendingCompositions;
         while (table.invalidatedFields.size > 0 ||
             pending.nodeIdsToCompose.length > 0 ||
@@ -214,11 +210,11 @@ class ModularChangeFamily {
                 composedFields.set(fieldId.field, composedField);
                 continue;
             }
-            const nodeId = (0, index_js_1.getFromChangeAtomIdMap)(table.newToBaseNodeId, fieldId.nodeId) ?? fieldId.nodeId;
+            const nodeId = getFromChangeAtomIdMap(table.newToBaseNodeId, fieldId.nodeId) ?? fieldId.nodeId;
             let nodeChangeset = nodeChangeFromId(composedNodes, nodeId);
             if (!table.composedNodes.has(nodeChangeset)) {
                 nodeChangeset = cloneNodeChangeset(nodeChangeset);
-                (0, index_js_1.setInChangeAtomIdMap)(composedNodes, nodeId, nodeChangeset);
+                setInChangeAtomIdMap(composedNodes, nodeId, nodeChangeset);
             }
             if (nodeChangeset.fieldChanges === undefined) {
                 nodeChangeset.fieldChanges = new Map();
@@ -262,7 +258,7 @@ class ModularChangeFamily {
         const manager = new ComposeManager(crossFieldTable, change1);
         const composedChange = changeHandler.rebaser.compose(change1Normalized, change2Normalized, (child1, child2) => {
             if (child1 !== undefined && child2 !== undefined) {
-                (0, index_js_1.setInChangeAtomIdMap)(crossFieldTable.newToBaseNodeId, child2, child1);
+                setInChangeAtomIdMap(crossFieldTable.newToBaseNodeId, child2, child1);
                 crossFieldTable.pendingCompositions.nodeIdsToCompose.push([child1, child2]);
             }
             return child1 ?? child2 ?? (0, index_js_2.fail)("Should not compose two undefined nodes");
@@ -283,13 +279,13 @@ class ModularChangeFamily {
         const nodeChangeset1 = nodeChangeFromId(nodeChanges1, id1);
         const nodeChangeset2 = nodeChangeFromId(nodeChanges2, id2);
         const composedNodeChangeset = this.composeNodeChanges(nodeChangeset1, nodeChangeset2, idAllocator, crossFieldTable, revisionMetadata);
-        (0, index_js_1.setInChangeAtomIdMap)(composedNodes, id1, composedNodeChangeset);
+        setInChangeAtomIdMap(composedNodes, id1, composedNodeChangeset);
         if (!(0, index_js_1.areEqualChangeAtomIds)(id1, id2)) {
-            (0, index_js_2.deleteFromNestedMap)(composedNodes, id2.revision, id2.localId);
-            (0, index_js_2.deleteFromNestedMap)(composedNodeToParent, id2.revision, id2.localId);
-            (0, index_js_1.setInChangeAtomIdMap)(nodeAliases, id2, id1);
+            composedNodes.delete([id2.revision, id2.localId]);
+            composedNodeToParent.delete([id2.revision, id2.localId]);
+            setInChangeAtomIdMap(nodeAliases, id2, id1);
             // We need to delete id1 to avoid forming a cycle in case id1 already had an alias.
-            (0, index_js_2.deleteFromNestedMap)(nodeAliases, id1.revision, id1.localId);
+            nodeAliases.delete([id1.revision, id1.localId]);
         }
         crossFieldTable.composedNodes.add(composedNodeChangeset);
     }
@@ -312,27 +308,24 @@ class ModularChangeFamily {
      */
     invert(change, isRollback) {
         // Rollback changesets destroy the nodes created by the change being rolled back.
-        const destroys = isRollback
-            ? invertBuilds(change.change.builds, change.revision)
-            : undefined;
+        const destroys = isRollback ? invertBuilds(change.change.builds) : undefined;
         // Destroys only occur in rollback changesets, which are never inverted.
         (0, internal_1.assert)(change.change.destroys === undefined, 0x89a /* Unexpected destroys in change to invert */);
         if ((change.change.constraintViolationCount ?? 0) > 0) {
             return makeModularChangeset(undefined, undefined, undefined, undefined, undefined, change.change.maxId, [], undefined, undefined, destroys);
         }
         const genId = (0, index_js_2.idAllocatorFromMaxId)(change.change.maxId ?? -1);
-        const invertedNodeToParent = cloneNestedMap(change.change.nodeToParent);
         const crossFieldTable = {
             ...newCrossFieldTable(),
             originalFieldToContext: new Map(),
-            invertedNodeToParent,
+            invertedNodeToParent: (0, index_js_2.brand)(change.change.nodeToParent.clone()),
         };
         const { revInfos } = getRevInfoFromTaggedChanges([change]);
         const revisionMetadata = (0, index_js_1.revisionMetadataSourceFromInfo)(revInfos);
         const invertedFields = this.invertFieldMap(change.change.fieldChanges, undefined, isRollback, genId, crossFieldTable, revisionMetadata);
-        const invertedNodes = new Map();
-        (0, index_js_2.forEachInNestedMap)(change.change.nodeChanges, (nodeChangeset, revision, localId) => {
-            (0, index_js_2.setInNestedMap)(invertedNodes, revision, localId, this.invertNodeChange(nodeChangeset, { revision, localId }, isRollback, genId, crossFieldTable, revisionMetadata));
+        const invertedNodes = newTupleBTree();
+        change.change.nodeChanges.forEachPair(([revision, localId], nodeChangeset) => {
+            invertedNodes.set([revision, localId], this.invertNodeChange(nodeChangeset, { revision, localId }, isRollback, genId, crossFieldTable, revisionMetadata));
         });
         if (crossFieldTable.invalidatedFields.size > 0) {
             const fieldsToUpdate = crossFieldTable.invalidatedFields;
@@ -347,7 +340,7 @@ class ModularChangeFamily {
             }
         }
         const crossFieldKeys = this.makeCrossFieldKeyTable(invertedFields, invertedNodes);
-        return makeModularChangeset(invertedFields, invertedNodes, invertedNodeToParent, change.change.nodeAliases, crossFieldKeys, genId.getMaxId(), [], change.change.constraintViolationCount, undefined, destroys);
+        return makeModularChangeset(invertedFields, invertedNodes, crossFieldTable.invertedNodeToParent, change.change.nodeAliases, crossFieldKeys, genId.getMaxId(), [], change.change.constraintViolationCount, undefined, destroys);
     }
     invertFieldMap(changes, parentId, isRollback, genId, crossFieldTable, revisionMetadata) {
         const invertedFields = new Map();
@@ -384,47 +377,24 @@ class ModularChangeFamily {
             newChange: change,
             baseChange: over.change,
             baseFieldToContext: new Map(),
-            baseToRebasedNodeId: new Map(),
+            baseToRebasedNodeId: newTupleBTree(),
             rebasedFields: new Set(),
-            rebasedNodeToParent: cloneNestedMap(change.nodeToParent),
+            rebasedNodeToParent: (0, index_js_2.brand)(change.nodeToParent.clone()),
             rebasedCrossFieldKeys: (0, index_js_2.brand)(change.crossFieldKeys.clone()),
             nodeIdPairs: [],
-            affectedBaseFields: newBTree(),
+            affectedBaseFields: newTupleBTree(),
+            fieldsWithUnattachedChild: new Set(),
         };
-        let constraintState = newConstraintState(change.constraintViolationCount ?? 0);
+        const constraintState = newConstraintState(change.constraintViolationCount ?? 0);
         const getBaseRevisions = () => revisionInfoFromTaggedChange(over).map((info) => info.revision);
         const rebaseMetadata = {
             ...revisionMetadata,
             getRevisionToRebase: () => taggedChange.revision,
             getBaseRevisions,
         };
-        const rebasedNodes = cloneNestedMap(change.nodeChanges);
+        const rebasedNodes = (0, index_js_2.brand)(change.nodeChanges.clone());
         const rebasedFields = this.rebaseIntersectingFields(crossFieldTable, rebasedNodes, genId, constraintState, rebaseMetadata);
-        this.rebaseFieldsWithoutNewChanges(rebasedFields, rebasedNodes, crossFieldTable, genId, rebaseMetadata);
-        if (crossFieldTable.invalidatedFields.size > 0) {
-            const fieldsToUpdate = crossFieldTable.invalidatedFields;
-            crossFieldTable.invalidatedFields = new Set();
-            constraintState = newConstraintState(change.constraintViolationCount ?? 0);
-            for (const field of fieldsToUpdate) {
-                const context = crossFieldTable.baseFieldToContext.get(field);
-                (0, internal_1.assert)(context !== undefined, 0x852 /* Every field should have a context */);
-                const { changeHandler, change1: fieldChangeset, change2: baseChangeset, } = this.normalizeFieldChanges(context.newChange, context.baseChange, genId, revisionMetadata);
-                const rebaseChild = (curr, base) => {
-                    if (curr !== undefined) {
-                        return curr;
-                    }
-                    if (base !== undefined) {
-                        for (const id of context.baseNodeIds) {
-                            if ((0, index_js_1.areEqualChangeAtomIds)(base, id)) {
-                                return base;
-                            }
-                        }
-                    }
-                    return undefined;
-                };
-                context.rebasedChange.change = (0, index_js_2.brand)(changeHandler.rebaser.rebase(fieldChangeset, baseChangeset, rebaseChild, genId, new RebaseManager(crossFieldTable, field, context.fieldId), rebaseMetadata));
-            }
-        }
+        this.rebaseInvalidatedElements(rebasedFields, rebasedNodes, crossFieldTable, rebaseMetadata, genId);
         this.updateConstraintsForFields(rebasedFields, fieldChangeHandler_js_1.NodeAttachState.Attached, constraintState, rebasedNodes);
         return makeModularChangeset(this.pruneFieldMap(rebasedFields, rebasedNodes), rebasedNodes, crossFieldTable.rebasedNodeToParent, change.nodeAliases, crossFieldTable.rebasedCrossFieldKeys, idState.maxId, change.revisions, constraintState.violationCount, change.builds, change.destroys, change.refreshers);
     }
@@ -438,7 +408,7 @@ class ModularChangeFamily {
         // 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);
-            (0, index_js_1.setInChangeAtomIdMap)(rebasedNodes, newId, rebasedNode);
+            setInChangeAtomIdMap(rebasedNodes, newId, rebasedNode);
         }
         return rebasedFields;
     }
@@ -450,7 +420,7 @@ class ModularChangeFamily {
                 ? normalizeNodeId({ revision, localId }, baseChange.nodeAliases)
                 : undefined;
             const baseFieldChange = fieldMapFromNodeId(baseChange.fieldChanges, baseChange.nodeChanges, baseNodeId).get(fieldKey);
-            (0, internal_1.assert)(baseFieldChange !== undefined, "Cross field key registered for empty field");
+            (0, internal_1.assert)(baseFieldChange !== undefined, 0x9c2 /* Cross field key registered for empty field */);
             if (crossFieldTable.baseFieldToContext.has(baseFieldChange)) {
                 // This field has already been processed because there were changes to rebase.
                 continue;
@@ -458,7 +428,7 @@ class ModularChangeFamily {
             // This field has no changes in the new changeset, otherwise it would have been added to
             // `crossFieldTable.baseFieldToContext` when processing fields with both base and new changes.
             const rebaseChild = (child, baseChild, stateChange) => {
-                (0, internal_1.assert)(child === undefined, "There should be no new changes in this field");
+                (0, internal_1.assert)(child === undefined, 0x9c3 /* There should be no new changes in this field */);
                 return undefined;
             };
             const handler = getChangeHandler(this.fieldKinds, baseFieldChange.fieldKind);
@@ -487,39 +457,76 @@ class ModularChangeFamily {
             this.attachRebasedField(rebasedFields, rebasedNodes, crossFieldTable, rebasedFieldChange, fieldId, genId, metadata);
         }
     }
+    rebaseInvalidatedElements(rebasedFields, rebasedNodes, table, metadata, idAllocator) {
+        this.rebaseFieldsWithoutNewChanges(rebasedFields, rebasedNodes, table, idAllocator, metadata);
+        this.rebaseFieldsWithUnattachedChild(table, metadata, idAllocator);
+        this.rebaseInvalidatedFields(table, metadata, idAllocator);
+    }
+    rebaseInvalidatedFields(crossFieldTable, rebaseMetadata, genId) {
+        const fieldsToUpdate = crossFieldTable.invalidatedFields;
+        crossFieldTable.invalidatedFields = new Set();
+        for (const field of fieldsToUpdate) {
+            this.rebaseInvalidatedField(field, crossFieldTable, rebaseMetadata, genId);
+        }
+    }
+    rebaseFieldsWithUnattachedChild(table, metadata, idAllocator) {
+        for (const field of table.fieldsWithUnattachedChild) {
+            table.invalidatedFields.delete(field);
+            this.rebaseInvalidatedField(field, table, metadata, idAllocator, true);
+        }
+    }
+    rebaseInvalidatedField(baseField, crossFieldTable, rebaseMetadata, genId, allowInval = false) {
+        const context = crossFieldTable.baseFieldToContext.get(baseField);
+        (0, internal_1.assert)(context !== undefined, 0x852 /* Every field should have a context */);
+        const { changeHandler, change1: fieldChangeset, change2: baseChangeset, } = this.normalizeFieldChanges(context.newChange, context.baseChange, genId, rebaseMetadata);
+        const rebaseChild = (curr, base) => {
+            if (curr !== undefined) {
+                return curr;
+            }
+            if (base !== undefined) {
+                for (const id of context.baseNodeIds) {
+                    if ((0, index_js_1.areEqualChangeAtomIds)(base, id)) {
+                        return base;
+                    }
+                }
+            }
+            return undefined;
+        };
+        context.rebasedChange.change = (0, index_js_2.brand)(changeHandler.rebaser.rebase(fieldChangeset, baseChangeset, rebaseChild, genId, new RebaseManager(crossFieldTable, baseField, context.fieldId, allowInval), rebaseMetadata));
+    }
     attachRebasedField(rebasedFields, rebasedNodes, table, rebasedField, { nodeId, field: fieldKey }, idAllocator, metadata) {
         if (nodeId === undefined) {
             rebasedFields.set(fieldKey, rebasedField);
             return;
         }
-        const rebasedNode = (0, index_js_1.getFromChangeAtomIdMap)(rebasedNodes, nodeId);
+        const rebasedNode = getFromChangeAtomIdMap(rebasedNodes, nodeId);
         if (rebasedNode !== undefined) {
             if (rebasedNode.fieldChanges === undefined) {
                 rebasedNode.fieldChanges = new Map([[fieldKey, rebasedField]]);
                 return;
             }
-            (0, internal_1.assert)(!rebasedNode.fieldChanges.has(fieldKey), "Expected an empty field");
+            (0, internal_1.assert)(!rebasedNode.fieldChanges.has(fieldKey), 0x9c4 /* Expected an empty field */);
             rebasedNode.fieldChanges.set(fieldKey, rebasedField);
             return;
         }
         const newNode = {
             fieldChanges: new Map([[fieldKey, rebasedField]]),
         };
-        (0, index_js_1.setInChangeAtomIdMap)(rebasedNodes, nodeId, newNode);
-        (0, index_js_1.setInChangeAtomIdMap)(table.baseToRebasedNodeId, nodeId, nodeId);
+        setInChangeAtomIdMap(rebasedNodes, nodeId, newNode);
+        setInChangeAtomIdMap(table.baseToRebasedNodeId, nodeId, nodeId);
         const parentFieldId = getParentFieldId(table.baseChange, nodeId);
         this.attachRebasedNode(rebasedFields, rebasedNodes, table, nodeId, parentFieldId, idAllocator, metadata);
     }
     attachRebasedNode(rebasedFields, rebasedNodes, table, baseNodeId, parentFieldIdBase, idAllocator, metadata) {
         const baseFieldChange = fieldChangeFromId(table.baseChange.fieldChanges, table.baseChange.nodeChanges, parentFieldIdBase);
         const rebasedFieldId = rebasedFieldIdFromBaseId(table, parentFieldIdBase);
-        (0, index_js_1.setInChangeAtomIdMap)(table.rebasedNodeToParent, baseNodeId, rebasedFieldId);
+        setInChangeAtomIdMap(table.rebasedNodeToParent, baseNodeId, rebasedFieldId);
         const context = table.baseFieldToContext.get(baseFieldChange);
         if (context !== undefined) {
             // We've already processed this field.
-            // The new child node can be attached when processing invalidated fields.
+            // The new child node will be attached in rebaseFieldsWithUnattachedChild.
             context.baseNodeIds.push(baseNodeId);
-            table.invalidatedFields.add(baseFieldChange);
+            table.fieldsWithUnattachedChild.add(baseFieldChange);
             return;
         }
         const handler = getChangeHandler(this.fieldKinds, baseFieldChange.fieldKind);
@@ -589,7 +596,7 @@ class ModularChangeFamily {
         if (change?.nodeExistsConstraint !== undefined) {
             rebasedChange.nodeExistsConstraint = change.nodeExistsConstraint;
         }
-        (0, index_js_1.setInChangeAtomIdMap)(crossFieldTable.baseToRebasedNodeId, baseId, newId);
+        setInChangeAtomIdMap(crossFieldTable.baseToRebasedNodeId, baseId, newId);
         return rebasedChange;
     }
     updateConstraintsForFields(fields, parentAttachState, constraintState, nodes) {
@@ -605,7 +612,7 @@ class ModularChangeFamily {
         }
     }
     updateConstraintsForNode(nodeId, attachState, constraintState, nodes) {
-        const node = (0, index_js_2.tryGetFromNestedMap)(nodes, nodeId.revision, nodeId.localId) ?? (0, index_js_2.fail)("Unknown node ID");
+        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;
             if (node.nodeExistsConstraint.violated !== isNowViolated) {
@@ -644,11 +651,11 @@ class ModularChangeFamily {
             delete prunedChange.fieldChanges;
         }
         if (isEmptyNodeChangeset(prunedChange)) {
-            (0, index_js_2.deleteFromNestedMap)(nodeMap, nodeId.revision, nodeId.localId);
+            nodeMap.delete([nodeId.revision, nodeId.localId]);
             return undefined;
         }
         else {
-            (0, index_js_1.setInChangeAtomIdMap)(nodeMap, nodeId, prunedChange);
+            setInChangeAtomIdMap(nodeMap, nodeId, prunedChange);
             return nodeId;
         }
     }
@@ -657,23 +664,21 @@ class ModularChangeFamily {
             ? [undefined]
             : change.revisions.map((revInfo) => revInfo.revision));
         const updatedFields = this.replaceFieldMapRevisions(change.fieldChanges, oldRevisions, newRevision);
-        const updatedNodes = (0, index_js_2.nestedMapFromFlatList)((0, index_js_2.nestedMapToFlatList)(change.nodeChanges).map(([revision, id, nodeChangeset]) => [
-            replaceRevision(revision, oldRevisions, newRevision),
-            id,
-            this.replaceNodeChangesetRevisions(nodeChangeset, oldRevisions, newRevision),
-        ]));
-        const updatedNodeToParent = (0, index_js_2.nestedMapFromFlatList)((0, index_js_2.nestedMapToFlatList)(change.nodeToParent).map(([revision, id, fieldId]) => [
-            replaceRevision(revision, oldRevisions, newRevision),
-            id,
-            replaceFieldIdRevision(normalizeFieldId(fieldId, change.nodeAliases), oldRevisions, newRevision),
-        ]));
+        const updatedNodes = newTupleBTree();
+        for (const [[revision, id], nodeChangeset] of change.nodeChanges.entries()) {
+            updatedNodes.set([replaceRevision(revision, oldRevisions, newRevision), id], this.replaceNodeChangesetRevisions(nodeChangeset, oldRevisions, newRevision));
+        }
+        const updatedNodeToParent = newTupleBTree();
+        for (const [[revision, id], fieldId] of change.nodeToParent.entries()) {
+            updatedNodeToParent.set([replaceRevision(revision, oldRevisions, newRevision), id], replaceFieldIdRevision(normalizeFieldId(fieldId, change.nodeAliases), oldRevisions, newRevision));
+        }
         const updated = {
             ...change,
             fieldChanges: updatedFields,
             nodeChanges: updatedNodes,
             nodeToParent: updatedNodeToParent,
             // We've updated all references to old node IDs, so we no longer need an alias table.
-            nodeAliases: new Map(),
+            nodeAliases: newTupleBTree(),
             crossFieldKeys: replaceCrossFieldKeyTableRevisions(change.crossFieldKeys, oldRevisions, newRevision, change.nodeAliases),
         };
         if (change.builds !== undefined) {
@@ -715,7 +720,7 @@ class ModularChangeFamily {
     makeCrossFieldKeyTable(fields, nodes) {
         const keys = newCrossFieldKeyTable();
         this.populateCrossFieldKeyTableForFieldMap(keys, fields, undefined);
-        (0, index_js_2.forEachInNestedMap)(nodes, (node, revision, localId) => {
+        nodes.forEachPair(([revision, localId], node) => {
             if (node.fieldChanges !== undefined) {
                 this.populateCrossFieldKeyTableForFieldMap(keys, node.fieldChanges, {
                     revision,
@@ -744,7 +749,7 @@ class ModularChangeFamily {
 exports.ModularChangeFamily = ModularChangeFamily;
 ModularChangeFamily.emptyChange = makeModularChangeset();
 function replaceCrossFieldKeyTableRevisions(table, oldRevisions, newRevision, nodeAliases) {
-    const updated = newBTree();
+    const updated = newTupleBTree();
     table.forEachPair(([target, revision, id, count], field) => {
         const updatedKey = [
             target,
@@ -768,91 +773,51 @@ function replaceRevision(revision, oldRevisions, newRevision) {
     return oldRevisions.has(revision) ? newRevision : revision;
 }
 function replaceIdMapRevisions(map, oldRevisions, newRevision) {
-    return (0, index_js_2.nestedMapFromFlatList)((0, index_js_2.nestedMapToFlatList)(map).map(([revision, id, value]) => [
-        replaceRevision(revision, oldRevisions, newRevision),
-        id,
-        value,
-    ]));
+    const updated = newTupleBTree();
+    for (const [[revision, id], value] of map.entries()) {
+        updated.set([replaceRevision(revision, oldRevisions, newRevision), id], value);
+    }
+    return updated;
 }
-function composeBuildsDestroysAndRefreshers(changes) {
-    const allBuilds = new Map();
-    const allDestroys = new Map();
-    const allRefreshers = new Map();
-    for (const taggedChange of changes) {
-        const revision = revisionFromTaggedChange(taggedChange);
-        const change = taggedChange.change;
-        if (change.builds) {
-            for (const [revisionKey, innerMap] of change.builds) {
-                const setRevisionKey = revisionKey ?? revision;
-                const innerDstMap = (0, index_js_2.getOrAddInMap)(allBuilds, setRevisionKey, new Map());
-                for (const [id, chunk] of innerMap) {
-                    // Check for duplicate builds and prefer earlier ones.
-                    // This can happen in compositions of commits that needed to include detached tree refreshers (e.g., undos):
-                    // In that case, it's possible for the refreshers to contain different trees because the latter
-                    // refresher may already reflect the changes made by the commit that includes the earlier
-                    // refresher. This composition includes the changes made by the commit that includes the
-                    // earlier refresher, so we need to include the build for the earlier refresher, otherwise
-                    // the produced changeset will build a tree one which those changes have already been applied
-                    // and also try to apply the changes again, effectively applying them twice.
-                    // 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.
-                    if (!innerDstMap.has(id)) {
-                        // Check for earlier destroys that this build might cancel-out with.
-                        const destroyCount = (0, index_js_2.tryGetFromNestedMap)(allDestroys, setRevisionKey, id);
-                        if (destroyCount === undefined) {
-                            innerDstMap.set(id, chunk);
-                        }
-                        else {
-                            (0, internal_1.assert)(destroyCount === chunk.topLevelLength, 0x89b /* Expected build and destroy to have the same length */);
-                            (0, index_js_2.deleteFromNestedMap)(allDestroys, setRevisionKey, id);
-                        }
-                    }
-                }
-                if (innerDstMap.size === 0) {
-                    allBuilds.delete(setRevisionKey);
-                }
+function composeBuildsDestroysAndRefreshers(change1, change2) {
+    // Duplicate builds can happen in compositions of commits that needed to include detached tree refreshers (e.g., undos):
+    // In that case, it's possible for the refreshers to contain different trees because the latter
+    // refresher may already reflect the changes made by the commit that includes the earlier
+    // refresher. This composition includes the changes made by the commit that includes the
+    // earlier refresher, so we need to include the build for the earlier refresher, otherwise
+    // the produced changeset will build a tree one which those changes have already been applied
+    // and also try to apply the changes again, effectively applying them twice.
+    // 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));
+    if (change1.destroys !== undefined && change2.builds !== undefined) {
+        for (const [key, chunk] of change2.builds.entries()) {
+            const destroyCount = change1.destroys.get(key);
+            if (destroyCount !== undefined) {
+                (0, internal_1.assert)(destroyCount === chunk.topLevelLength, 0x89b /* Expected build and destroy to have the same length */);
+                allBuilds.delete(key);
+                allDestroys.delete(key);
             }
         }
-        if (change.destroys !== undefined) {
-            for (const [revisionKey, innerMap] of change.destroys) {
-                const setRevisionKey = revisionKey ?? revision;
-                const innerDstMap = (0, index_js_2.getOrAddInMap)(allDestroys, setRevisionKey, new Map());
-                for (const [id, count] of innerMap) {
-                    // Check for earlier builds that this destroy might cancel-out with.
-                    const chunk = (0, index_js_2.tryGetFromNestedMap)(allBuilds, setRevisionKey, id);
-                    if (chunk === undefined) {
-                        innerDstMap.set(id, count);
-                    }
-                    else {
-                        (0, internal_1.assert)(count === chunk.topLevelLength, 0x89c /* Expected build and destroy to have the same length */);
-                        (0, index_js_2.deleteFromNestedMap)(allBuilds, setRevisionKey, id);
-                    }
-                }
-                if (innerDstMap.size === 0) {
-                    allDestroys.delete(setRevisionKey);
-                }
+    }
+    if (change1.builds !== undefined && change2.destroys !== undefined) {
+        for (const [key, chunk] of change1.builds.entries()) {
+            const destroyCount = change2.destroys.get(key);
+            if (destroyCount !== undefined) {
+                (0, internal_1.assert)(destroyCount === chunk.topLevelLength, 0x9f0 /* Expected build and destroy to have the same length */);
+                allBuilds.delete(key);
+                allDestroys.delete(key);
             }
         }
-        // add all refreshers while preferring earlier ones
-        if (change.refreshers) {
-            (0, index_js_2.populateNestedMap)(change.refreshers, allRefreshers, false);
-        }
     }
     return { allBuilds, allDestroys, allRefreshers };
 }
-function invertBuilds(builds, fallbackRevision) {
+function invertBuilds(builds) {
     if (builds !== undefined) {
-        const destroys = new Map();
-        for (const [revision, innerBuildMap] of builds) {
-            const initializedRevision = revision ?? fallbackRevision;
-            const innerDestroyMap = new Map();
-            for (const [id, chunk] of innerBuildMap) {
-                innerDestroyMap.set(id, chunk.topLevelLength);
-            }
-            destroys.set(initializedRevision, innerDestroyMap);
-        }
-        return destroys;
+        return (0, index_js_2.brand)(builds.mapValues((chunk) => chunk.topLevelLength));
     }
     return undefined;
 }
@@ -899,14 +864,12 @@ function* relevantRemovedRootsFromFields(change, nodeChanges, fieldKinds) {
  * corresponding build or refresher.
  */
 function updateRefreshers(change, getDetachedNode, removedRoots, requireRefreshers = true) {
-    const refreshers = new Map();
+    const refreshers = newTupleBTree();
     const chunkLengths = new Map();
     if (change.builds !== undefined) {
-        for (const [major, buildsMap] of change.builds) {
-            const lengthTree = (0, index_js_2.getOrAddInMap)(chunkLengths, major, new sorted_btree_es6_1.BTree());
-            for (const [id, chunk] of buildsMap) {
-                lengthTree.set(id, chunk.topLevelLength);
-            }
+        for (const [[revision, id], chunk] of change.builds.entries()) {
+            const lengthTree = (0, index_js_2.getOrAddInMapLazy)(chunkLengths, revision, () => new sorted_btree_es6_1.BTree());
+            lengthTree.set(id, chunk.topLevelLength);
         }
     }
     for (const root of removedRoots) {
@@ -929,7 +892,7 @@ function updateRefreshers(change, getDetachedNode, removedRoots, requireRefreshe
             (0, internal_1.assert)(!requireRefreshers, 0x8cd /* detached node should exist */);
         }
         else {
-            (0, index_js_2.setInNestedMap)(refreshers, root.major, root.minor, node);
+            refreshers.set([root.major, (0, index_js_2.brand)(root.minor)], node);
         }
     }
     const { fieldChanges, nodeChanges, maxId, revisions, constraintViolationCount, builds, destroys, } = change;
@@ -957,12 +920,12 @@ function intoDelta(taggedChange, fieldKinds) {
     }
     if (change.destroys !== undefined && change.destroys.size > 0) {
         const destroys = [];
-        (0, index_js_2.forEachInNestedMap)(change.destroys, (count, major, minor) => {
+        for (const [[major, minor], count] of change.destroys.entries()) {
             destroys.push({
                 id: (0, index_js_1.makeDetachedNodeId)(major, minor),
                 count,
             });
-        });
+        }
         rootDelta.destroy = destroys;
     }
     if (change.refreshers && change.refreshers.size > 0) {
@@ -973,7 +936,7 @@ function intoDelta(taggedChange, fieldKinds) {
 exports.intoDelta = intoDelta;
 function copyDetachedNodes(detachedNodes) {
     const copiedDetachedNodes = [];
-    (0, index_js_2.forEachInNestedMap)(detachedNodes, (chunk, major, minor) => {
+    for (const [[major, minor], chunk] of detachedNodes.entries()) {
         if (chunk.topLevelLength > 0) {
             const trees = (0, index_js_1.mapCursorField)(chunk.cursor(), (c) => (0, mapTreeCursor_js_1.cursorForMapTreeNode)((0, mapTreeCursor_js_1.mapTreeFromCursor)(c)));
             copiedDetachedNodes.push({
@@ -981,7 +944,7 @@ function copyDetachedNodes(detachedNodes) {
                 trees,
             });
         }
-    });
+    }
     return copiedDetachedNodes.length > 0 ? copiedDetachedNodes : undefined;
 }
 /**
@@ -1008,7 +971,6 @@ function deltaFromNodeChange(change, nodeChanges, idAllocator, fieldKinds) {
     return new Map();
 }
 /**
- * @internal
  * @param revInfos - This should describe the revision being rebased and all revisions in the rebase path,
  * even if not part of the current base changeset.
  * For example, when rebasing change B from a local branch [A, B, C] over a branch [X, Y], the `revInfos` must include
@@ -1058,12 +1020,12 @@ function newComposeTable(baseChange, newChange) {
         newChange,
         fieldToContext: new Map(),
         newFieldToBaseField: new Map(),
-        newToBaseNodeId: new Map(),
+        newToBaseNodeId: newTupleBTree(),
         composedNodes: new Set(),
         pendingCompositions: {
             nodeIdsToCompose: [],
-            affectedBaseFields: newBTree(),
-            affectedNewFields: newBTree(),
+            affectedBaseFields: newTupleBTree(),
+            affectedNewFields: newTupleBTree(),
         },
     };
 }
@@ -1127,10 +1089,10 @@ class InvertManager extends CrossFieldManagerI {
         this.fieldId = fieldId;
     }
     onMoveIn(id) {
-        (0, index_js_1.setInChangeAtomIdMap)(this.table.invertedNodeToParent, id, this.fieldId);
+        setInChangeAtomIdMap(this.table.invertedNodeToParent, id, this.fieldId);
     }
     moveKey(target, revision, id, count) {
-        (0, internal_1.assert)(false, "Keys should not be moved manually during invert");
+        (0, internal_1.assert)(false, 0x9c5 /* Keys should not be moved manually during invert */);
     }
     get table() {
         return this.crossFieldTable;
@@ -1149,14 +1111,14 @@ class RebaseManager extends CrossFieldManagerI {
                 id,
                 count,
             ]);
-            (0, internal_1.assert)(newFieldIds.length === 0, "TODO: Modifying a cross-field key from the new changeset is currently unsupported");
+            (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, [
                 target,
                 revision,
                 id,
                 count,
             ]);
-            (0, internal_1.assert)(baseFieldIds.length > 0, "Cross field key not registered in base or new change");
+            (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);
             }
@@ -1164,7 +1126,7 @@ class RebaseManager extends CrossFieldManagerI {
         super.set(target, revision, id, count, newValue, invalidateDependents);
     }
     onMoveIn(id) {
-        (0, index_js_1.setInChangeAtomIdMap)(this.table.rebasedNodeToParent, id, this.fieldId);
+        setInChangeAtomIdMap(this.table.rebasedNodeToParent, id, this.fieldId);
     }
     moveKey(target, revision, id, count) {
         setInCrossFieldKeyTable(this.table.rebasedCrossFieldKeys, target, revision, id, count, this.fieldId);
@@ -1198,7 +1160,7 @@ class ComposeManager extends CrossFieldManagerI {
                     id,
                     count,
                 ]);
-                (0, internal_1.assert)(baseFieldIds.length > 0, "Cross field key not registered in base or new change");
+                (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);
                 }
@@ -1219,9 +1181,9 @@ class ComposeManager extends CrossFieldManagerI {
 function makeModularChangeset(fieldChanges = undefined, nodeChanges = undefined, nodeToParent = undefined, nodeAliases = undefined, crossFieldKeys = undefined, maxId = -1, revisions = undefined, constraintViolationCount = undefined, builds, destroys, refreshers) {
     const changeset = {
         fieldChanges: fieldChanges ?? new Map(),
-        nodeChanges: nodeChanges ?? new Map(),
-        nodeToParent: nodeToParent ?? new Map(),
-        nodeAliases: nodeAliases ?? new Map(),
+        nodeChanges: nodeChanges ?? newTupleBTree(),
+        nodeToParent: nodeToParent ?? newTupleBTree(),
+        nodeAliases: nodeAliases ?? newTupleBTree(),
         crossFieldKeys: crossFieldKeys ?? newCrossFieldKeyTable(),
     };
     if (revisions !== undefined && revisions.length > 0) {
@@ -1273,13 +1235,11 @@ class ModularEditBuilder extends index_js_1.EditBuilder {
         if (content.mode === 1 /* CursorLocationType.Fields */ && content.getFieldLength() === 0) {
             return { type: "global" };
         }
-        const builds = new Map();
-        const innerMap = new Map();
-        builds.set(undefined, innerMap);
+        const builds = newTupleBTree();
         const chunk = content.mode === 1 /* CursorLocationType.Fields */
             ? (0, index_js_3.chunkFieldSingle)(content, index_js_3.defaultChunkPolicy)
             : (0, index_js_3.chunkTree)(content, index_js_3.defaultChunkPolicy);
-        innerMap.set(firstId, chunk);
+        builds.set([undefined, firstId], chunk);
         return {
             type: "global",
             builds,
@@ -1294,7 +1254,7 @@ class ModularEditBuilder extends index_js_1.EditBuilder {
      */
     submitChange(field, fieldKind, change) {
         const crossFieldKeys = getChangeHandler(this.fieldKinds, fieldKind).getCrossFieldKeys(change);
-        const modularChange = buildModularChangesetFromField(field, { fieldKind, change }, new Map(), new Map(), newCrossFieldKeyTable(), this.idAllocator, crossFieldKeys);
+        const modularChange = buildModularChangesetFromField(field, { fieldKind, change }, newTupleBTree(), newTupleBTree(), newCrossFieldKeyTable(), this.idAllocator, crossFieldKeys);
         this.applyChange(modularChange);
     }
     submitChanges(changes) {
@@ -1307,7 +1267,7 @@ class ModularEditBuilder extends index_js_1.EditBuilder {
             : buildModularChangesetFromField(change.field, {
                 fieldKind: change.fieldKind,
                 change: change.change,
-            }, new Map(), new Map(), newCrossFieldKeyTable(), this.idAllocator, getChangeHandler(this.fieldKinds, change.fieldKind).getCrossFieldKeys(change.change))));
+            }, newTupleBTree(), newTupleBTree(), newCrossFieldKeyTable(), this.idAllocator, getChangeHandler(this.fieldKinds, change.fieldKind).getCrossFieldKeys(change.change))));
         const composedChange = this.changeFamily.rebaser.compose(changeMaps);
         const maxId = (0, index_js_2.brand)(this.idAllocator.getMaxId());
         if (maxId >= 0) {
@@ -1322,7 +1282,7 @@ class ModularEditBuilder extends index_js_1.EditBuilder {
         const nodeChange = {
             nodeExistsConstraint: { violated: false },
         };
-        this.applyChange(buildModularChangesetFromNode(path, nodeChange, new Map(), new Map(), newCrossFieldKeyTable(), this.idAllocator));
+        this.applyChange(buildModularChangesetFromNode(path, nodeChange, newTupleBTree(), newTupleBTree(), newCrossFieldKeyTable(), this.idAllocator));
     }
 }
 exports.ModularEditBuilder = ModularEditBuilder;
@@ -1333,7 +1293,7 @@ function buildModularChangesetFromField(path, fieldChange, nodeChanges, nodeToPa
             crossFieldKeys.set(key, { nodeId: undefined, field: path.field });
         }
         if (childId !== undefined) {
-            (0, index_js_1.setInChangeAtomIdMap)(nodeToParent, childId, {
+            setInChangeAtomIdMap(nodeToParent, childId, {
                 nodeId: undefined,
                 field: path.field,
             });
@@ -1348,7 +1308,7 @@ function buildModularChangesetFromField(path, fieldChange, nodeChanges, nodeToPa
         crossFieldKeys.set(key, { nodeId: parentId, field: path.field });
     }
     if (childId !== undefined) {
-        (0, index_js_1.setInChangeAtomIdMap)(nodeToParent, childId, {
+        setInChangeAtomIdMap(nodeToParent, childId, {
             nodeId: parentId,
             field: path.field,
         });
@@ -1356,7 +1316,7 @@ function buildModularChangesetFromField(path, fieldChange, nodeChanges, nodeToPa
     return buildModularChangesetFromNode(path.parent, nodeChangeset, nodeChanges, nodeToParent, crossFieldKeys, idAllocator, parentId);
 }
 function buildModularChangesetFromNode(path, nodeChange, nodeChanges, nodeToParent, crossFieldKeys, idAllocator, nodeId = { localId: (0, index_js_2.brand)(idAllocator.allocate()) }) {
-    (0, index_js_1.setInChangeAtomIdMap)(nodeChanges, nodeId, nodeChange);
+    setInChangeAtomIdMap(nodeChanges, nodeId, nodeChange);
     const fieldChangeset = genericFieldKind_js_1.genericFieldKind.changeHandler.editor.buildChildChange(path.parentIndex, nodeId);
     const fieldChange = {
         fieldKind: genericFieldKind_js_1.genericFieldKind.identifier,
@@ -1402,28 +1362,19 @@ function revisionInfoFromTaggedChange(taggedChange) {
     }
     return revInfos;
 }
-function revisionFromTaggedChange(change) {
-    return change.revision ?? revisionFromRevInfos(change.change.revisions);
-}
-function revisionFromRevInfos(revInfos) {
-    if (revInfos === undefined || revInfos.length !== 1) {
-        return undefined;
+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 revInfos[0].revision;
-}
-function mergeBTrees(tree1, tree2) {
-    const result = tree1.clone();
-    tree2.forEachPair((k, v) => {
-        result.set(k, v);
-    });
     return result;
 }
-function mergeNestedMaps(map1, map2) {
-    const merged = new Map();
-    (0, index_js_2.populateNestedMap)(map1, merged, true);
-    (0, index_js_2.populateNestedMap)(map2, merged, true);
-    return merged;
-}
 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");
@@ -1433,7 +1384,7 @@ function fieldMapFromNodeId(rootFieldMap, nodes, nodeId) {
         return rootFieldMap;
     }
     const node = nodeChangeFromId(nodes, nodeId);
-    (0, internal_1.assert)(node.fieldChanges !== undefined, "Expected node to have field changes");
+    (0, internal_1.assert)(node.fieldChanges !== undefined, 0x9c9 /* Expected node to have field changes */);
     return node.fieldChanges;
 }
 function rebasedFieldIdFromBaseId(table, baseId) {
@@ -1443,11 +1394,11 @@ function rebasedFieldIdFromBaseId(table, baseId) {
     return { ...baseId, nodeId: rebasedNodeIdFromBaseNodeId(table, baseId.nodeId) };
 }
 function rebasedNodeIdFromBaseNodeId(table, baseId) {
-    return (0, index_js_1.getFromChangeAtomIdMap)(table.baseToRebasedNodeId, baseId) ?? baseId;
+    return getFromChangeAtomIdMap(table.baseToRebasedNodeId, baseId) ?? baseId;
 }
 function nodeChangeFromId(nodes, id) {
-    const node = (0, index_js_1.getFromChangeAtomIdMap)(nodes, id);
-    (0, internal_1.assert)(node !== undefined, "Unknown node ID");
+    const node = getFromChangeAtomIdMap(nodes, id);
+    (0, internal_1.assert)(node !== undefined, 0x9ca /* Unknown node ID */);
     return node;
 }
 function fieldIdFromFieldIdKey([revision, localId, field]) {
@@ -1470,8 +1421,8 @@ function replaceFieldIdRevision(fieldId, oldRevisions, newRevision) {
     };
 }
 function getParentFieldId(changeset, nodeId) {
-    const parentId = (0, index_js_1.getFromChangeAtomIdMap)(changeset.nodeToParent, nodeId);
-    (0, internal_1.assert)(parentId !== undefined, "Parent field should be defined");
+    const parentId = getFromChangeAtomIdMap(changeset.nodeToParent, nodeId);
+    (0, internal_1.assert)(parentId !== undefined, 0x9cb /* Parent field should be defined */);
     return normalizeFieldId(parentId, changeset.nodeAliases);
 }
 exports.getParentFieldId = getParentFieldId;
@@ -1553,7 +1504,7 @@ function normalizeNodeId(nodeId, nodeAliases) {
     let currentId = nodeId;
     // eslint-disable-next-line no-constant-condition
     while (true) {
-        const dealiased = (0, index_js_1.getFromChangeAtomIdMap)(nodeAliases, currentId);
+        const dealiased = getFromChangeAtomIdMap(nodeAliases, currentId);
         if (dealiased === undefined) {
             return currentId;
         }
@@ -1564,12 +1515,13 @@ function hasConflicts(change) {
     return (change.constraintViolationCount ?? 0) > 0;
 }
 function newCrossFieldKeyTable() {
-    return newBTree();
+    return newTupleBTree();
 }
 exports.newCrossFieldKeyTable = newCrossFieldKeyTable;
-function newBTree() {
-    return (0, index_js_2.brand)(new sorted_btree_es6_1.BTree(undefined, compareTuples));
+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++) {
@@ -1577,7 +1529,15 @@ function compareTuples(arrayA, arrayB) {
         const a = arrayA[i];
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const b = arrayB[i];
-        if (a < b) {
+        // 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) {
@@ -1586,9 +1546,10 @@ function compareTuples(arrayA, arrayB) {
     }
     return 0;
 }
-function cloneNestedMap(map) {
-    const cloned = new Map();
-    (0, index_js_2.populateNestedMap)(map, cloned, true);
-    return cloned;
+function getFromChangeAtomIdMap(map, id) {
+    return map.get([id.revision, id.localId]);
+}
+function setInChangeAtomIdMap(map, id, value) {
+    map.set([id.revision, id.localId], value);
 }
 //# sourceMappingURL=modularChangeFamily.js.map