@fluidframework/tree 2.1.0-281041 → 2.2.0

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

@@ -4,8 +4,8 @@
  */
 import { assert } from "@fluidframework/core-utils/internal";
 import { BTree } from "@tylerbu/sorted-btree-es6";
-import { EditBuilder, isEmptyFieldChanges, makeAnonChange, makeDetachedNodeId, mapCursorField, replaceAtomRevisions, revisionMetadataSourceFromInfo, setInChangeAtomIdMap, areEqualChangeAtomIds, getFromChangeAtomIdMap, } from "../../core/index.js";
-import { brand, deleteFromNestedMap, fail, forEachInNestedMap, getOrAddInMap, idAllocatorFromMaxId, idAllocatorFromState, nestedMapFromFlatList, nestedMapToFlatList, populateNestedMap, setInNestedMap, tryGetFromNestedMap, } from "../../util/index.js";
+import { EditBuilder, isEmptyFieldChanges, makeAnonChange, makeDetachedNodeId, mapCursorField, replaceAtomRevisions, revisionMetadataSourceFromInfo, areEqualChangeAtomIds, } from "../../core/index.js";
+import { brand, fail, idAllocatorFromMaxId, idAllocatorFromState, getOrAddInMapLazy, } from "../../util/index.js";
 import { chunkFieldSingle, chunkTree, defaultChunkPolicy, } from "../chunked-forest/index.js";
 import { cursorForMapTreeNode, mapTreeFromCursor } from "../mapTreeCursor.js";
 import { MemoizedIdRangeAllocator } from "../memoizedIdRangeAllocator.js";
@@ -72,30 +72,26 @@ export class ModularChangeFamily {
     compose(changes) {
         const { revInfos, maxId } = getRevInfoFromTaggedChanges(changes);
         const idState = { maxId };
-        return changes.reduce((change1, change2) => makeAnonChange(this.composePair(change1, change2, revInfos, idState)), makeAnonChange({
-            fieldChanges: new Map(),
-            nodeChanges: new Map(),
-            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)) {
@@ -109,17 +105,17 @@ export 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 = brand(mergeBTrees(change1.nodeChanges, change2.nodeChanges));
+        const composedNodeToParent = brand(mergeBTrees(change1.nodeToParent, change2.nodeToParent));
+        const composedNodeAliases = 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 {
@@ -157,7 +153,7 @@ export 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 ||
@@ -282,11 +278,11 @@ export class ModularChangeFamily {
         const composedNodeChangeset = this.composeNodeChanges(nodeChangeset1, nodeChangeset2, idAllocator, crossFieldTable, revisionMetadata);
         setInChangeAtomIdMap(composedNodes, id1, composedNodeChangeset);
         if (!areEqualChangeAtomIds(id1, id2)) {
-            deleteFromNestedMap(composedNodes, id2.revision, id2.localId);
-            deleteFromNestedMap(composedNodeToParent, id2.revision, id2.localId);
+            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.
-            deleteFromNestedMap(nodeAliases, id1.revision, id1.localId);
+            nodeAliases.delete([id1.revision, id1.localId]);
         }
         crossFieldTable.composedNodes.add(composedNodeChangeset);
     }
@@ -309,27 +305,24 @@ export 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.
         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 = idAllocatorFromMaxId(change.change.maxId ?? -1);
-        const invertedNodeToParent = cloneNestedMap(change.change.nodeToParent);
         const crossFieldTable = {
             ...newCrossFieldTable(),
             originalFieldToContext: new Map(),
-            invertedNodeToParent,
+            invertedNodeToParent: brand(change.change.nodeToParent.clone()),
         };
         const { revInfos } = getRevInfoFromTaggedChanges([change]);
         const revisionMetadata = revisionMetadataSourceFromInfo(revInfos);
         const invertedFields = this.invertFieldMap(change.change.fieldChanges, undefined, isRollback, genId, crossFieldTable, revisionMetadata);
-        const invertedNodes = new Map();
-        forEachInNestedMap(change.change.nodeChanges, (nodeChangeset, revision, localId) => {
-            setInNestedMap(invertedNodes, revision, localId, this.invertNodeChange(nodeChangeset, { 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;
@@ -344,7 +337,7 @@ export 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();
@@ -381,47 +374,24 @@ export class ModularChangeFamily {
             newChange: change,
             baseChange: over.change,
             baseFieldToContext: new Map(),
-            baseToRebasedNodeId: new Map(),
+            baseToRebasedNodeId: newTupleBTree(),
             rebasedFields: new Set(),
-            rebasedNodeToParent: cloneNestedMap(change.nodeToParent),
+            rebasedNodeToParent: brand(change.nodeToParent.clone()),
             rebasedCrossFieldKeys: 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 = 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);
-                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 (areEqualChangeAtomIds(base, id)) {
-                                return base;
-                            }
-                        }
-                    }
-                    return undefined;
-                };
-                context.rebasedChange.change = brand(changeHandler.rebaser.rebase(fieldChangeset, baseChangeset, rebaseChild, genId, new RebaseManager(crossFieldTable, field, context.fieldId), rebaseMetadata));
-            }
-        }
+        this.rebaseInvalidatedElements(rebasedFields, rebasedNodes, crossFieldTable, rebaseMetadata, genId);
         this.updateConstraintsForFields(rebasedFields, 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);
     }
@@ -447,7 +417,7 @@ export class ModularChangeFamily {
                 ? normalizeNodeId({ revision, localId }, baseChange.nodeAliases)
                 : undefined;
             const baseFieldChange = fieldMapFromNodeId(baseChange.fieldChanges, baseChange.nodeChanges, baseNodeId).get(fieldKey);
-            assert(baseFieldChange !== undefined, "Cross field key registered for empty field");
+            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;
@@ -455,7 +425,7 @@ export 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) => {
-                assert(child === undefined, "There should be no new changes in this field");
+                assert(child === undefined, 0x9c3 /* There should be no new changes in this field */);
                 return undefined;
             };
             const handler = getChangeHandler(this.fieldKinds, baseFieldChange.fieldKind);
@@ -484,6 +454,43 @@ export 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);
+        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 (areEqualChangeAtomIds(base, id)) {
+                        return base;
+                    }
+                }
+            }
+            return undefined;
+        };
+        context.rebasedChange.change = 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);
@@ -495,7 +502,7 @@ export class ModularChangeFamily {
                 rebasedNode.fieldChanges = new Map([[fieldKey, rebasedField]]);
                 return;
             }
-            assert(!rebasedNode.fieldChanges.has(fieldKey), "Expected an empty field");
+            assert(!rebasedNode.fieldChanges.has(fieldKey), 0x9c4 /* Expected an empty field */);
             rebasedNode.fieldChanges.set(fieldKey, rebasedField);
             return;
         }
@@ -514,9 +521,9 @@ export class ModularChangeFamily {
         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);
@@ -602,7 +609,7 @@ export class ModularChangeFamily {
         }
     }
     updateConstraintsForNode(nodeId, attachState, constraintState, nodes) {
-        const node = tryGetFromNestedMap(nodes, nodeId.revision, nodeId.localId) ?? fail("Unknown node ID");
+        const node = nodes.get([nodeId.revision, nodeId.localId]) ?? fail("Unknown node ID");
         if (node.nodeExistsConstraint !== undefined) {
             const isNowViolated = attachState === NodeAttachState.Detached;
             if (node.nodeExistsConstraint.violated !== isNowViolated) {
@@ -641,7 +648,7 @@ export class ModularChangeFamily {
             delete prunedChange.fieldChanges;
         }
         if (isEmptyNodeChangeset(prunedChange)) {
-            deleteFromNestedMap(nodeMap, nodeId.revision, nodeId.localId);
+            nodeMap.delete([nodeId.revision, nodeId.localId]);
             return undefined;
         }
         else {
@@ -654,23 +661,21 @@ export class ModularChangeFamily {
             ? [undefined]
             : change.revisions.map((revInfo) => revInfo.revision));
         const updatedFields = this.replaceFieldMapRevisions(change.fieldChanges, oldRevisions, newRevision);
-        const updatedNodes = nestedMapFromFlatList(nestedMapToFlatList(change.nodeChanges).map(([revision, id, nodeChangeset]) => [
-            replaceRevision(revision, oldRevisions, newRevision),
-            id,
-            this.replaceNodeChangesetRevisions(nodeChangeset, oldRevisions, newRevision),
-        ]));
-        const updatedNodeToParent = nestedMapFromFlatList(nestedMapToFlatList(change.nodeToParent).map(([revision, id, fieldId]) => [
-            replaceRevision(revision, oldRevisions, newRevision),
-            id,
-            replaceFieldIdRevision(normalizeFieldId(fieldId, change.nodeAliases), oldRevisions, newRevision),
-        ]));
+        const 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) {
@@ -712,7 +717,7 @@ export class ModularChangeFamily {
     makeCrossFieldKeyTable(fields, nodes) {
         const keys = newCrossFieldKeyTable();
         this.populateCrossFieldKeyTableForFieldMap(keys, fields, undefined);
-        forEachInNestedMap(nodes, (node, revision, localId) => {
+        nodes.forEachPair(([revision, localId], node) => {
             if (node.fieldChanges !== undefined) {
                 this.populateCrossFieldKeyTableForFieldMap(keys, node.fieldChanges, {
                     revision,
@@ -740,7 +745,7 @@ export class 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,
@@ -764,91 +769,51 @@ function replaceRevision(revision, oldRevisions, newRevision) {
     return oldRevisions.has(revision) ? newRevision : revision;
 }
 function replaceIdMapRevisions(map, oldRevisions, newRevision) {
-    return nestedMapFromFlatList(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 = 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 = tryGetFromNestedMap(allDestroys, setRevisionKey, id);
-                        if (destroyCount === undefined) {
-                            innerDstMap.set(id, chunk);
-                        }
-                        else {
-                            assert(destroyCount === chunk.topLevelLength, 0x89b /* Expected build and destroy to have the same length */);
-                            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 = brand(mergeBTrees(change1.builds ?? newTupleBTree(), change2.builds ?? newTupleBTree(), true));
+    const allDestroys = brand(mergeBTrees(change1.destroys ?? newTupleBTree(), change2.destroys ?? newTupleBTree()));
+    const allRefreshers = brand(mergeBTrees(change1.refreshers ?? newTupleBTree(), change2.refreshers ?? newTupleBTree(), true));
+    if (change1.destroys !== undefined && change2.builds !== undefined) {
+        for (const [key, chunk] of change2.builds.entries()) {
+            const destroyCount = change1.destroys.get(key);
+            if (destroyCount !== undefined) {
+                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 = getOrAddInMap(allDestroys, setRevisionKey, new Map());
-                for (const [id, count] of innerMap) {
-                    // Check for earlier builds that this destroy might cancel-out with.
-                    const chunk = tryGetFromNestedMap(allBuilds, setRevisionKey, id);
-                    if (chunk === undefined) {
-                        innerDstMap.set(id, count);
-                    }
-                    else {
-                        assert(count === chunk.topLevelLength, 0x89c /* Expected build and destroy to have the same length */);
-                        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) {
+                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) {
-            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 brand(builds.mapValues((chunk) => chunk.topLevelLength));
     }
     return undefined;
 }
@@ -894,14 +859,12 @@ function* relevantRemovedRootsFromFields(change, nodeChanges, fieldKinds) {
  * corresponding build or refresher.
  */
 export 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 = getOrAddInMap(chunkLengths, major, new BTree());
-            for (const [id, chunk] of buildsMap) {
-                lengthTree.set(id, chunk.topLevelLength);
-            }
+        for (const [[revision, id], chunk] of change.builds.entries()) {
+            const lengthTree = getOrAddInMapLazy(chunkLengths, revision, () => new BTree());
+            lengthTree.set(id, chunk.topLevelLength);
         }
     }
     for (const root of removedRoots) {
@@ -924,7 +887,7 @@ export function updateRefreshers(change, getDetachedNode, removedRoots, requireR
             assert(!requireRefreshers, 0x8cd /* detached node should exist */);
         }
         else {
-            setInNestedMap(refreshers, root.major, root.minor, node);
+            refreshers.set([root.major, brand(root.minor)], node);
         }
     }
     const { fieldChanges, nodeChanges, maxId, revisions, constraintViolationCount, builds, destroys, } = change;
@@ -951,12 +914,12 @@ export function intoDelta(taggedChange, fieldKinds) {
     }
     if (change.destroys !== undefined && change.destroys.size > 0) {
         const destroys = [];
-        forEachInNestedMap(change.destroys, (count, major, minor) => {
+        for (const [[major, minor], count] of change.destroys.entries()) {
             destroys.push({
                 id: makeDetachedNodeId(major, minor),
                 count,
             });
-        });
+        }
         rootDelta.destroy = destroys;
     }
     if (change.refreshers && change.refreshers.size > 0) {
@@ -966,7 +929,7 @@ export function intoDelta(taggedChange, fieldKinds) {
 }
 function copyDetachedNodes(detachedNodes) {
     const copiedDetachedNodes = [];
-    forEachInNestedMap(detachedNodes, (chunk, major, minor) => {
+    for (const [[major, minor], chunk] of detachedNodes.entries()) {
         if (chunk.topLevelLength > 0) {
             const trees = mapCursorField(chunk.cursor(), (c) => cursorForMapTreeNode(mapTreeFromCursor(c)));
             copiedDetachedNodes.push({
@@ -974,7 +937,7 @@ function copyDetachedNodes(detachedNodes) {
                 trees,
             });
         }
-    });
+    }
     return copiedDetachedNodes.length > 0 ? copiedDetachedNodes : undefined;
 }
 /**
@@ -1001,7 +964,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
@@ -1048,12 +1010,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(),
         },
     };
 }
@@ -1120,7 +1082,7 @@ class InvertManager extends CrossFieldManagerI {
         setInChangeAtomIdMap(this.table.invertedNodeToParent, id, this.fieldId);
     }
     moveKey(target, revision, id, count) {
-        assert(false, "Keys should not be moved manually during invert");
+        assert(false, 0x9c5 /* Keys should not be moved manually during invert */);
     }
     get table() {
         return this.crossFieldTable;
@@ -1139,14 +1101,14 @@ class RebaseManager extends CrossFieldManagerI {
                 id,
                 count,
             ]);
-            assert(newFieldIds.length === 0, "TODO: Modifying a cross-field key from the new changeset is currently unsupported");
+            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,
             ]);
-            assert(baseFieldIds.length > 0, "Cross field key not registered in base or new change");
+            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);
             }
@@ -1188,7 +1150,7 @@ class ComposeManager extends CrossFieldManagerI {
                     id,
                     count,
                 ]);
-                assert(baseFieldIds.length > 0, "Cross field key not registered in base or new change");
+                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);
                 }
@@ -1209,9 +1171,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) {
@@ -1263,13 +1225,11 @@ export class ModularEditBuilder extends 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 */
             ? chunkFieldSingle(content, defaultChunkPolicy)
             : chunkTree(content, defaultChunkPolicy);
-        innerMap.set(firstId, chunk);
+        builds.set([undefined, firstId], chunk);
         return {
             type: "global",
             builds,
@@ -1284,7 +1244,7 @@ export class ModularEditBuilder extends 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) {
@@ -1297,7 +1257,7 @@ export class ModularEditBuilder extends 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 = brand(this.idAllocator.getMaxId());
         if (maxId >= 0) {
@@ -1312,7 +1272,7 @@ export class ModularEditBuilder extends 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));
     }
 }
 function buildModularChangesetFromField(path, fieldChange, nodeChanges, nodeToParent, crossFieldKeys, idAllocator = idAllocatorFromMaxId(), localCrossFieldKeys = [], childId = undefined) {
@@ -1391,28 +1351,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 ? brand(tree2.clone()) : newTupleBTree();
+    }
+    const result = brand(tree1.clone());
+    if (tree2 === undefined) {
+        return result;
+    }
+    for (const [key, value] of tree2.entries()) {
+        result.set(key, value, !preferLeft);
     }
-    return 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();
-    populateNestedMap(map1, merged, true);
-    populateNestedMap(map2, merged, true);
-    return merged;
-}
 function fieldChangeFromId(fields, nodes, id) {
     const fieldMap = fieldMapFromNodeId(fields, nodes, id.nodeId);
     return fieldMap.get(id.field) ?? fail("No field exists for the given ID");
@@ -1422,7 +1373,7 @@ function fieldMapFromNodeId(rootFieldMap, nodes, nodeId) {
         return rootFieldMap;
     }
     const node = nodeChangeFromId(nodes, nodeId);
-    assert(node.fieldChanges !== undefined, "Expected node to have field changes");
+    assert(node.fieldChanges !== undefined, 0x9c9 /* Expected node to have field changes */);
     return node.fieldChanges;
 }
 function rebasedFieldIdFromBaseId(table, baseId) {
@@ -1436,7 +1387,7 @@ function rebasedNodeIdFromBaseNodeId(table, baseId) {
 }
 function nodeChangeFromId(nodes, id) {
     const node = getFromChangeAtomIdMap(nodes, id);
-    assert(node !== undefined, "Unknown node ID");
+    assert(node !== undefined, 0x9ca /* Unknown node ID */);
     return node;
 }
 function fieldIdFromFieldIdKey([revision, localId, field]) {
@@ -1460,7 +1411,7 @@ function replaceFieldIdRevision(fieldId, oldRevisions, newRevision) {
 }
 export function getParentFieldId(changeset, nodeId) {
     const parentId = getFromChangeAtomIdMap(changeset.nodeToParent, nodeId);
-    assert(parentId !== undefined, "Parent field should be defined");
+    assert(parentId !== undefined, 0x9cb /* Parent field should be defined */);
     return normalizeFieldId(parentId, changeset.nodeAliases);
 }
 export function getFieldsForCrossFieldKey(changeset, [target, revision, id, count]) {
@@ -1551,10 +1502,10 @@ function hasConflicts(change) {
     return (change.constraintViolationCount ?? 0) > 0;
 }
 export function newCrossFieldKeyTable() {
-    return newBTree();
+    return newTupleBTree();
 }
-function newBTree() {
-    return brand(new BTree(undefined, compareTuples));
+export function newTupleBTree(entries) {
+    return brand(new BTree(entries, compareTuples));
 }
 // This assumes that the arrays are the same length.
 function compareTuples(arrayA, arrayB) {
@@ -1563,7 +1514,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) {
@@ -1572,9 +1531,10 @@ function compareTuples(arrayA, arrayB) {
     }
     return 0;
 }
-function cloneNestedMap(map) {
-    const cloned = new Map();
-    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