@fluidframework/tree 2.0.0-rc.2.0.2 → 2.0.0-rc.3.0.0

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

@@ -5,27 +5,25 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ModularEditBuilder = exports.getChangeHandler = exports.getFieldKind = exports.rebaseRevisionMetadataFromInfo = exports.intoDelta = exports.updateRefreshers = exports.relevantRemovedRoots = exports.ModularChangeFamily = void 0;
-const core_utils_1 = require("@fluidframework/core-utils");
-const index_js_1 = require("../../codec/index.js");
-const index_js_2 = require("../../core/index.js");
-const index_js_3 = require("../../util/index.js");
-const memoizedIdRangeAllocator_js_1 = require("../memoizedIdRangeAllocator.js");
-const index_js_4 = require("../chunked-forest/index.js");
+const internal_1 = require("@fluidframework/core-utils/internal");
+const sorted_btree_es6_1 = require("@tylerbu/sorted-btree-es6");
+const index_js_1 = require("../../core/index.js");
+const index_js_2 = require("../../util/index.js");
+const index_js_3 = require("../chunked-forest/index.js");
 const mapTreeCursor_js_1 = require("../mapTreeCursor.js");
+const memoizedIdRangeAllocator_js_1 = require("../memoizedIdRangeAllocator.js");
 const crossFieldQueries_js_1 = require("./crossFieldQueries.js");
 const fieldChangeHandler_js_1 = require("./fieldChangeHandler.js");
 const fieldKindWithEditor_js_1 = require("./fieldKindWithEditor.js");
 const genericFieldKind_js_1 = require("./genericFieldKind.js");
-const modularChangeCodecs_js_1 = require("./modularChangeCodecs.js");
 /**
  * Implementation of ChangeFamily which delegates work in a given field to the appropriate FieldKind
  * as determined by the schema.
  */
 class ModularChangeFamily {
-    constructor(fieldKinds, revisionTagCodec, fieldBatchCodec, codecOptions, chunkCompressionStrategy) {
+    constructor(fieldKinds, codecs) {
+        this.codecs = codecs;
         this.fieldKinds = fieldKinds;
-        this.latestCodec = (0, modularChangeCodecs_js_1.makeV0Codec)(fieldKinds, revisionTagCodec, fieldBatchCodec, codecOptions, chunkCompressionStrategy);
-        this.codecs = (0, index_js_1.makeCodecFamily)([[0, this.latestCodec]]);
     }
     get rebaser() {
         return this;
@@ -65,45 +63,68 @@ class ModularChangeFamily {
         }
         // The cast is based on the `fieldKind` check above
         const genericChange = fieldChange.change;
-        const convertedChange = (0, genericFieldKind_js_1.convertGenericChange)(genericChange, handler, (child1, child2) => this.composeNodeChanges(child1, undefined, child2, undefined, genId, newComposeTable(), revisionMetadata), genId, revisionMetadata);
+        const convertedChange = (0, genericFieldKind_js_1.convertGenericChange)(genericChange, handler, (child1, child2) => {
+            (0, internal_1.assert)(child1 === undefined || child2 === undefined, 0x92f /* Should not have two changesets to compose */);
+            return child1 ?? child2 ?? (0, index_js_2.fail)("Should not compose two undefined node IDs");
+        }, genId, revisionMetadata);
         return convertedChange;
     }
     compose(changes) {
         const activeChanges = changes.filter((change) => (change.change.constraintViolationCount ?? 0) === 0);
         const { revInfos, maxId } = getRevInfoFromTaggedChanges(changes);
         const idState = { maxId };
-        return activeChanges.reduce((change1, change2) => (0, index_js_2.makeAnonChange)(this.composePair(change1, change2, revInfos, idState)), (0, index_js_2.makeAnonChange)({ fieldChanges: new Map() })).change;
+        return activeChanges.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() })).change;
     }
     composePair(change1, change2, revInfos, idState) {
-        const genId = (0, index_js_3.idAllocatorFromState)(idState);
-        const revisionMetadata = (0, index_js_2.revisionMetadataSourceFromInfo)(revInfos);
+        const genId = (0, index_js_2.idAllocatorFromState)(idState);
+        const revisionMetadata = (0, index_js_1.revisionMetadataSourceFromInfo)(revInfos);
         const crossFieldTable = newComposeTable();
         const composedFields = this.composeFieldMaps(change1.change.fieldChanges, change1.revision, change2.change.fieldChanges, change2.revision, genId, crossFieldTable, revisionMetadata);
+        const composedNodeChanges = new Map();
+        for (const [taggedId1, taggedId2] of crossFieldTable.nodeIdPairs) {
+            this.composeNodesById(change1.change.nodeChanges, change2.change.nodeChanges, composedNodeChanges, taggedId1?.change, taggedId1?.revision, taggedId2?.change, taggedId2?.revision, genId, crossFieldTable, revisionMetadata);
+        }
+        crossFieldTable.nodeIdPairs.length = 0;
         while (crossFieldTable.invalidatedFields.size > 0) {
             const fieldsToUpdate = crossFieldTable.invalidatedFields;
             crossFieldTable.invalidatedFields = new Set();
             for (const fieldChange of fieldsToUpdate) {
                 const context = crossFieldTable.fieldToContext.get(fieldChange);
-                (0, core_utils_1.assert)(context !== undefined, 0x8cc /* Should have context for every invalidated field */);
+                (0, internal_1.assert)(context !== undefined, 0x8cc /* Should have context for every invalidated field */);
                 const { change1: fieldChange1, change2: fieldChange2, composedChange } = context;
                 const rebaser = getChangeHandler(this.fieldKinds, fieldChange.fieldKind).rebaser;
-                const composeNodes = (node1, node2) => {
-                    const key = composeCacheKeyFromNodeChangesets(node1, node2);
-                    const cachedResult = crossFieldTable.nodeCache.get(key);
-                    if (cachedResult !== undefined) {
-                        return cachedResult;
+                const composeNodes = (child1, child2) => {
+                    if (child2 !== undefined &&
+                        !(0, index_js_2.nestedSetContains)(crossFieldTable.nodeIds, child2.revision, child2.localId)) {
+                        const taggedId1 = child1 !== undefined
+                            ? (0, index_js_1.tagChange)(child1, fieldChange1.revision)
+                            : undefined;
+                        const taggedId2 = child2 !== undefined
+                            ? (0, index_js_1.tagChange)(child2, fieldChange2.revision)
+                            : undefined;
+                        crossFieldTable.nodeIdPairs.push([taggedId1, taggedId2]);
+                        if (child1 !== undefined && child2 !== undefined) {
+                            (0, index_js_2.addToNestedSet)(crossFieldTable.nodeIds, child2.revision, child2.localId);
+                        }
                     }
-                    return this.composeNodeChanges(node1, fieldChange1.revision, node2, fieldChange2.revision, genId, crossFieldTable, revisionMetadata);
+                    return ((0, index_js_1.taggedOptAtomId)(child1, fieldChange1.revision) ??
+                        (0, index_js_1.taggedOptAtomId)(child2, fieldChange2.revision) ??
+                        (0, index_js_2.fail)("Should not compose two undefined nodes"));
                 };
                 const amendedChange = rebaser.compose(fieldChange1, fieldChange2, composeNodes, genId, newCrossFieldManager(crossFieldTable, fieldChange, false), revisionMetadata);
-                composedChange.change = (0, index_js_3.brand)(amendedChange);
+                composedChange.change = (0, index_js_2.brand)(amendedChange);
+                // Process any newly discovered nodes.
+                for (const [taggedId1, taggedId2] of crossFieldTable.nodeIdPairs) {
+                    this.composeNodesById(change1.change.nodeChanges, change2.change.nodeChanges, composedNodeChanges, taggedId1?.change, taggedId1?.revision, taggedId2?.change, taggedId2?.revision, genId, crossFieldTable, revisionMetadata);
+                }
+                crossFieldTable.nodeIdPairs.length = 0;
             }
         }
         const { allBuilds, allDestroys, allRefreshers } = composeBuildsDestroysAndRefreshers([
             change1,
             change2,
         ]);
-        return makeModularChangeset(this.pruneFieldMap(composedFields), idState.maxId, revInfos, undefined, allBuilds, allDestroys, allRefreshers);
+        return makeModularChangeset(this.pruneFieldMap(composedFields, composedNodeChanges), composedNodeChanges, idState.maxId, revInfos, undefined, allBuilds, allDestroys, allRefreshers);
     }
     composeFieldMaps(change1, revision1, change2, revision2, genId, crossFieldTable, revisionMetadata) {
         const composedFields = new Map();
@@ -119,14 +140,28 @@ class ModularChangeFamily {
             const fieldChange2 = change2?.get(field);
             const { fieldKind, change1: normalizedFieldChange1, change2: normalizedFieldChange2, } = this.normalizeFieldChanges(fieldChange1, fieldChange2, genId, revisionMetadata);
             const manager = newCrossFieldManager(crossFieldTable, fieldChange1 ?? fieldChange2);
-            const taggedChange1 = (0, index_js_2.tagChange)(normalizedFieldChange1 ?? fieldKind.changeHandler.createEmpty(), fieldChange1?.revision ?? revision1);
-            const taggedChange2 = (0, index_js_2.tagChange)(normalizedFieldChange2 ?? fieldKind.changeHandler.createEmpty(), fieldChange2?.revision ?? revision2);
-            const composedChange = fieldKind.changeHandler.rebaser.compose(taggedChange1, taggedChange2, (child1, child2) => this.composeNodeChanges(child1, revision1, child2, revision2, genId, crossFieldTable, revisionMetadata), genId, manager, revisionMetadata);
+            const taggedChange1 = (0, index_js_1.tagChange)(normalizedFieldChange1 ?? fieldKind.changeHandler.createEmpty(), fieldChange1?.revision ?? revision1);
+            const taggedChange2 = (0, index_js_1.tagChange)(normalizedFieldChange2 ?? fieldKind.changeHandler.createEmpty(), fieldChange2?.revision ?? revision2);
+            const composedChange = fieldKind.changeHandler.rebaser.compose(taggedChange1, taggedChange2, (child1, child2) => {
+                const taggedId1 = child1 !== undefined
+                    ? (0, index_js_1.tagChange)(child1, taggedChange1.revision)
+                    : undefined;
+                const taggedId2 = child2 !== undefined
+                    ? (0, index_js_1.tagChange)(child2, taggedChange2.revision)
+                    : undefined;
+                crossFieldTable.nodeIdPairs.push([taggedId1, taggedId2]);
+                if (child2 !== undefined) {
+                    (0, index_js_2.addToNestedSet)(crossFieldTable.nodeIds, child2.revision, child2.localId);
+                }
+                return ((0, index_js_1.taggedOptAtomId)(child1, revision1) ??
+                    (0, index_js_1.taggedOptAtomId)(child2, revision2) ??
+                    (0, index_js_2.fail)("Should not compose two undefined nodes"));
+            }, genId, manager, revisionMetadata);
             const composedField = {
                 fieldKind: fieldKind.identifier,
-                change: (0, index_js_3.brand)(composedChange),
+                change: (0, index_js_2.brand)(composedChange),
             };
-            const fieldKey = fieldChange1 ?? fieldChange2 ?? (0, index_js_3.fail)("At least one field should have changes");
+            const fieldKey = fieldChange1 ?? fieldChange2 ?? (0, index_js_2.fail)("At least one field should have changes");
             crossFieldTable.fieldToContext.set(fieldKey, {
                 change1: taggedChange1,
                 change2: taggedChange2,
@@ -137,6 +172,21 @@ class ModularChangeFamily {
         }
         return composedFields;
     }
+    composeNodesById(nodeChanges1, nodeChanges2, composedNodeChanges, id1, revision1, id2, revision2, idAllocator, crossFieldTable, revisionMetadata) {
+        const nodeChangeset1 = id1 !== undefined
+            ? (0, index_js_2.tryGetFromNestedMap)(nodeChanges1, id1.revision, id1.localId) ??
+                (0, index_js_2.fail)("Unknown node ID")
+            : {};
+        const nodeChangeset2 = id2 !== undefined
+            ? (0, index_js_2.tryGetFromNestedMap)(nodeChanges2, id2.revision, id2.localId) ??
+                (0, index_js_2.fail)("Unknown node ID")
+            : {};
+        const composedNodeChangeset = this.composeNodeChanges(nodeChangeset1, revision1, nodeChangeset2, revision2, idAllocator, crossFieldTable, revisionMetadata);
+        const nodeId = (0, index_js_1.taggedOptAtomId)(id1, revision1) ??
+            (0, index_js_1.taggedOptAtomId)(id2, revision2) ??
+            (0, index_js_2.fail)("Should not compose two undefined node IDs");
+        (0, index_js_2.setInNestedMap)(composedNodeChanges, nodeId.revision, nodeId.localId, composedNodeChangeset);
+    }
     composeNodeChanges(change1, revision1, change2, revision2, genId, crossFieldTable, revisionMetadata) {
         const nodeExistsConstraint = change1?.nodeExistsConstraint ?? change2?.nodeExistsConstraint;
         const composedFieldChanges = this.composeFieldMaps(change1?.fieldChanges, revision1, change2?.fieldChanges, revision2, genId, crossFieldTable, revisionMetadata);
@@ -147,8 +197,6 @@ class ModularChangeFamily {
         if (nodeExistsConstraint !== undefined) {
             composedNodeChange.nodeExistsConstraint = nodeExistsConstraint;
         }
-        const key = composeCacheKeyFromNodeChangesets(change1, change2);
-        crossFieldTable.nodeCache.set(key, composedNodeChange);
         return composedNodeChange;
     }
     /**
@@ -166,24 +214,30 @@ class ModularChangeFamily {
         // This idState is used for the whole of the IdAllocator's lifetime, which allows
         // this function to read the updated idState.maxId after more IDs are allocated.
         // TODO: add a getMax function to IdAllocator to make for a clearer contract.
-        const genId = (0, index_js_3.idAllocatorFromState)(idState);
+        const genId = (0, index_js_2.idAllocatorFromState)(idState);
         const crossFieldTable = {
             ...newCrossFieldTable(),
             originalFieldToContext: new Map(),
         };
         const { revInfos } = getRevInfoFromTaggedChanges([change]);
-        const revisionMetadata = (0, index_js_2.revisionMetadataSourceFromInfo)(revInfos);
-        const invertedFields = this.invertFieldMap((0, index_js_2.tagChange)(change.change.fieldChanges, revisionFromTaggedChange(change)), isRollback, genId, crossFieldTable, revisionMetadata);
+        const revisionMetadata = (0, index_js_1.revisionMetadataSourceFromInfo)(revInfos);
+        const invertedFields = this.invertFieldMap((0, index_js_1.tagChange)(change.change.fieldChanges, revisionFromTaggedChange(change)), 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(
+            // TODO: This does not allow inheriting revision from parent
+            (0, index_js_1.tagChange)(nodeChangeset, change.revision), isRollback, genId, crossFieldTable, revisionMetadata));
+        });
         if (crossFieldTable.invalidatedFields.size > 0) {
             const fieldsToUpdate = crossFieldTable.invalidatedFields;
             crossFieldTable.invalidatedFields = new Set();
             for (const fieldChange of fieldsToUpdate) {
                 const originalFieldChange = fieldChange.change;
                 const context = crossFieldTable.originalFieldToContext.get(fieldChange);
-                (0, core_utils_1.assert)(context !== undefined, 0x851 /* Should have context for every invalidated field */);
+                (0, internal_1.assert)(context !== undefined, 0x851 /* Should have context for every invalidated field */);
                 const { invertedField, revision } = context;
-                const amendedChange = getChangeHandler(this.fieldKinds, fieldChange.fieldKind).rebaser.invert((0, index_js_2.tagChange)(originalFieldChange, revision), (nodeChangeset) => nodeChangeset, isRollback, genId, newCrossFieldManager(crossFieldTable, fieldChange), revisionMetadata);
-                invertedField.change = (0, index_js_3.brand)(amendedChange);
+                const amendedChange = getChangeHandler(this.fieldKinds, fieldChange.fieldKind).rebaser.invert((0, index_js_1.tagChange)(originalFieldChange, revision), isRollback, genId, newCrossFieldManager(crossFieldTable, fieldChange), revisionMetadata);
+                invertedField.change = (0, index_js_2.brand)(amendedChange);
             }
         }
         // Rollback changesets destroy the nodes created by the change being rolled back.
@@ -191,9 +245,9 @@ class ModularChangeFamily {
             ? invertBuilds(change.change.builds, change.revision)
             : undefined;
         // Destroys only occur in rollback changesets, which are never inverted.
-        (0, core_utils_1.assert)(change.change.destroys === undefined, 0x89a /* Unexpected destroys in change to invert */);
+        (0, internal_1.assert)(change.change.destroys === undefined, 0x89a /* Unexpected destroys in change to invert */);
         const revInfo = change.change.revisions;
-        return makeModularChangeset(invertedFields, idState.maxId, revInfo === undefined
+        return makeModularChangeset(invertedFields, invertedNodes, idState.maxId, revInfo === undefined
             ? undefined
             : (isRollback
                 ? revInfo.map(({ revision }) => ({ revision, rollbackOf: revision }))
@@ -204,10 +258,10 @@ class ModularChangeFamily {
         for (const [field, fieldChange] of changes.change) {
             const { revision } = fieldChange.revision !== undefined ? fieldChange : changes;
             const manager = newCrossFieldManager(crossFieldTable, fieldChange);
-            const invertedChange = getChangeHandler(this.fieldKinds, fieldChange.fieldKind).rebaser.invert({ revision, change: fieldChange.change }, (childChanges) => this.invertNodeChange({ revision, change: childChanges }, isRollback, genId, crossFieldTable, revisionMetadata), isRollback, genId, manager, revisionMetadata);
+            const invertedChange = getChangeHandler(this.fieldKinds, fieldChange.fieldKind).rebaser.invert({ revision, change: fieldChange.change }, isRollback, genId, manager, revisionMetadata);
             const invertedFieldChange = {
                 ...fieldChange,
-                change: (0, index_js_3.brand)(invertedChange),
+                change: (0, index_js_2.brand)(invertedChange),
             };
             invertedFields.set(field, invertedFieldChange);
             crossFieldTable.originalFieldToContext.set(fieldChange, {
@@ -227,11 +281,12 @@ class ModularChangeFamily {
     rebase(change, over, revisionMetadata) {
         const maxId = Math.max(change.maxId ?? -1, over.change.maxId ?? -1);
         const idState = { maxId };
-        const genId = (0, index_js_3.idAllocatorFromState)(idState);
+        const genId = (0, index_js_2.idAllocatorFromState)(idState);
         const crossFieldTable = {
             ...newCrossFieldTable(),
             fieldToContext: new Map(),
             rebasedNodeCache: new Map(),
+            nodeIdPairs: [],
         };
         let constraintState = newConstraintState(change.constraintViolationCount ?? 0);
         const getBaseRevisions = () => revisionInfoFromTaggedChange(over).map((info) => info.revision);
@@ -239,7 +294,22 @@ class ModularChangeFamily {
             ...revisionMetadata,
             getBaseRevisions,
         };
-        const rebasedFields = this.rebaseFieldMap(change.fieldChanges, (0, index_js_2.tagChange)(over.change.fieldChanges, revisionFromTaggedChange(over)), genId, crossFieldTable, () => true, rebaseMetadata, constraintState);
+        const rebasedFields = this.rebaseFieldMap(change.fieldChanges, (0, index_js_1.tagChange)(over.change.fieldChanges, revisionFromTaggedChange(over)), genId, crossFieldTable, () => true, rebaseMetadata, constraintState);
+        const rebasedNodes = new Map();
+        for (const [newId, taggedBaseId, existenceState] of crossFieldTable.nodeIdPairs) {
+            const newNodeChange = newId !== undefined
+                ? (0, index_js_2.tryGetFromNestedMap)(change.nodeChanges, newId.revision, newId.localId)
+                : undefined;
+            const taggedBaseNodeChange = taggedBaseId !== undefined
+                ? (0, index_js_1.tagChange)((0, index_js_2.tryGetFromNestedMap)(over.change.nodeChanges, taggedBaseId.change.revision, taggedBaseId.change.localId) ?? (0, index_js_2.fail)("Unknown node ID"), taggedBaseId.revision)
+                : (0, index_js_1.makeAnonChange)({});
+            const rebasedNode = this.rebaseNodeChange(newNodeChange, taggedBaseNodeChange, genId, crossFieldTable, () => true, rebaseMetadata, constraintState, existenceState);
+            if (rebasedNode !== undefined) {
+                const nodeId = newId ??
+                    (0, index_js_1.taggedAtomId)(taggedBaseId?.change ?? (0, index_js_2.fail)("Should not have two undefined IDs"), taggedBaseId?.revision);
+                (0, index_js_2.setInNestedMap)(rebasedNodes, nodeId.revision, nodeId.localId, rebasedNode);
+            }
+        }
         if (crossFieldTable.invalidatedFields.size > 0) {
             const fieldsToUpdate = crossFieldTable.invalidatedFields;
             crossFieldTable.invalidatedFields = new Set();
@@ -247,24 +317,12 @@ class ModularChangeFamily {
             for (const field of fieldsToUpdate) {
                 // TODO: Should we copy the context table out before this loop?
                 const context = crossFieldTable.fieldToContext.get(field);
-                (0, core_utils_1.assert)(context !== undefined, 0x852 /* Every field should have a context */);
+                (0, internal_1.assert)(context !== undefined, 0x852 /* Every field should have a context */);
                 const { fieldKind, change1: fieldChangeset, change2: baseChangeset, } = this.normalizeFieldChanges(context.newChange, context.baseChange, genId, revisionMetadata);
-                context.rebasedChange.change = fieldKind.changeHandler.rebaser.rebase(fieldChangeset, (0, index_js_2.tagChange)(baseChangeset, context.baseRevision), (curr, base, existenceState) => {
-                    const key = curr ?? base;
-                    if (key === undefined) {
-                        return undefined;
-                    }
-                    const prior = crossFieldTable.rebasedNodeCache.get(key);
-                    if (prior !== undefined) {
-                        return prior;
-                    }
-                    // This is needed when the first rebase pass results in node changes from the rebased
-                    // changeset being moved to a different location.
-                    return this.rebaseNodeChange(curr, (0, index_js_2.tagChange)(base, context.baseRevision), genId, crossFieldTable, () => true, rebaseMetadata, constraintState, existenceState);
-                }, genId, newCrossFieldManager(crossFieldTable, field), rebaseMetadata);
+                context.rebasedChange.change = fieldKind.changeHandler.rebaser.rebase(fieldChangeset, (0, index_js_1.tagChange)(baseChangeset, context.baseRevision), (curr, base, existenceState) => curr, genId, newCrossFieldManager(crossFieldTable, field), rebaseMetadata);
             }
         }
-        return makeModularChangeset(this.pruneFieldMap(rebasedFields), idState.maxId, change.revisions, constraintState.violationCount, change.builds, change.destroys, change.refreshers);
+        return makeModularChangeset(this.pruneFieldMap(rebasedFields, rebasedNodes), rebasedNodes, idState.maxId, change.revisions, constraintState.violationCount, change.builds, change.destroys, change.refreshers);
     }
     rebaseFieldMap(change, over, genId, crossFieldTable, fieldFilter, revisionMetadata, constraintState, existenceState = fieldChangeHandler_js_1.NodeExistenceState.Alive) {
         const rebasedFields = new Map();
@@ -275,17 +333,26 @@ class ModularChangeFamily {
             }
             const fieldChange = change.get(field) ?? {
                 fieldKind: genericFieldKind_js_1.genericFieldKind.identifier,
-                change: (0, index_js_3.brand)((0, genericFieldKind_js_1.newGenericChangeset)()),
+                change: (0, index_js_2.brand)((0, genericFieldKind_js_1.newGenericChangeset)()),
             };
             const { fieldKind, change1: fieldChangeset, change2: baseChangeset, } = this.normalizeFieldChanges(fieldChange, baseChanges, genId, revisionMetadata);
             const { revision } = over;
             const taggedBaseChange = { revision, change: baseChangeset };
             const manager = newCrossFieldManager(crossFieldTable, fieldChange);
-            const rebaseChild = (child, baseChild, stateChange) => this.rebaseNodeChange(child, { revision, change: baseChild }, genId, crossFieldTable, fieldFilter, revisionMetadata, constraintState, stateChange);
+            const rebaseChild = (child, baseChild, stateChange) => {
+                const taggedBase = baseChild !== undefined ? (0, index_js_1.tagChange)(baseChild, over.revision) : undefined;
+                crossFieldTable.nodeIdPairs.push([child, taggedBase, stateChange]);
+                return (child ??
+                    // The fact `child` is undefined means that the changeset to rebase does not include changes for
+                    // this node or its descendants. However, it's possible that it will after rebasing.
+                    // In that case, we will need a NodeId to represent these changes under in the rebased changeset.
+                    // We adopt `baseChild` for this purpose.
+                    (0, index_js_1.taggedAtomId)(baseChild ?? (0, index_js_2.fail)("Should not have two undefined node IDs"), over.revision));
+            };
             const rebasedField = fieldKind.changeHandler.rebaser.rebase(fieldChangeset, taggedBaseChange, rebaseChild, genId, manager, revisionMetadata);
             const rebasedFieldChange = {
                 fieldKind: fieldKind.identifier,
-                change: (0, index_js_3.brand)(rebasedField),
+                change: (0, index_js_2.brand)(rebasedField),
             };
             rebasedFields.set(field, rebasedFieldChange);
             crossFieldTable.fieldToContext.set(fieldChange, {
@@ -300,18 +367,19 @@ class ModularChangeFamily {
             if (!over.change?.has(field)) {
                 const baseChanges = {
                     fieldKind: genericFieldKind_js_1.genericFieldKind.identifier,
-                    change: (0, index_js_3.brand)((0, genericFieldKind_js_1.newGenericChangeset)()),
+                    change: (0, index_js_2.brand)((0, genericFieldKind_js_1.newGenericChangeset)()),
                 };
                 const { fieldKind, change1: fieldChangeset, change2: baseChangeset, } = this.normalizeFieldChanges(fieldChange, baseChanges, genId, revisionMetadata);
                 // TODO: Don't we need to add an entry in the context table?
                 const manager = newCrossFieldManager(crossFieldTable, fieldChange);
-                const rebasedChangeset = fieldKind.changeHandler.rebaser.rebase(fieldChangeset, (0, index_js_2.tagChange)(baseChangeset, over.revision), (child, baseChild) => {
-                    (0, core_utils_1.assert)(baseChild === undefined, 0x5b6 /* This field should not have any base changes */);
-                    return this.rebaseNodeChange(child, (0, index_js_2.tagChange)(undefined, over.revision), genId, crossFieldTable, fieldFilter, revisionMetadata, constraintState, existenceState);
+                const rebasedChangeset = fieldKind.changeHandler.rebaser.rebase(fieldChangeset, (0, index_js_1.tagChange)(baseChangeset, over.revision), (child, baseChild) => {
+                    (0, internal_1.assert)(baseChild === undefined, 0x5b6 /* This field should not have any base changes */);
+                    crossFieldTable.nodeIdPairs.push([child, undefined, existenceState]);
+                    return child;
                 }, genId, manager, revisionMetadata, existenceState);
                 const rebasedFieldChange = {
                     fieldKind: fieldKind.identifier,
-                    change: (0, index_js_3.brand)(rebasedChangeset),
+                    change: (0, index_js_2.brand)(rebasedChangeset),
                 };
                 rebasedFields.set(field, rebasedFieldChange);
             }
@@ -328,7 +396,7 @@ class ModularChangeFamily {
                 ...over,
                 change: over.change.fieldChanges,
             }
-            : (0, index_js_2.tagChange)(new Map(), over.revision);
+            : (0, index_js_1.tagChange)(new Map(), over.revision);
         const fieldChanges = this.rebaseFieldMap(change?.fieldChanges ?? new Map(), baseMap, genId, crossFieldTable, fieldFilter, revisionMetadata, constraintState, existenceState);
         const rebasedChange = {};
         if (fieldChanges.size > 0) {
@@ -351,26 +419,35 @@ class ModularChangeFamily {
         crossFieldTable.rebasedNodeCache.set(key, rebasedChange);
         return rebasedChange;
     }
-    pruneFieldMap(changeset) {
+    pruneFieldMap(changeset, nodeMap) {
         const prunedChangeset = new Map();
         for (const [field, fieldChange] of changeset) {
             const handler = getChangeHandler(this.fieldKinds, fieldChange.fieldKind);
-            const prunedFieldChangeset = handler.rebaser.prune(fieldChange.change, (node) => this.pruneNodeChange(node));
+            const prunedFieldChangeset = handler.rebaser.prune(fieldChange.change, (nodeId) => this.pruneNodeChange(nodeId, nodeMap));
             if (!handler.isEmpty(prunedFieldChangeset)) {
-                prunedChangeset.set(field, { ...fieldChange, change: (0, index_js_3.brand)(prunedFieldChangeset) });
+                prunedChangeset.set(field, { ...fieldChange, change: (0, index_js_2.brand)(prunedFieldChangeset) });
             }
         }
         return prunedChangeset.size > 0 ? prunedChangeset : undefined;
     }
-    pruneNodeChange(changeset) {
+    pruneNodeChange(nodeId, nodeMap) {
+        const changeset = (0, index_js_2.tryGetFromNestedMap)(nodeMap, nodeId.revision, nodeId.localId);
+        (0, internal_1.assert)(changeset !== undefined, 0x930 /* Unknown node ID */);
         const prunedFields = changeset.fieldChanges !== undefined
-            ? this.pruneFieldMap(changeset.fieldChanges)
+            ? this.pruneFieldMap(changeset.fieldChanges, nodeMap)
             : undefined;
         const prunedChange = { ...changeset, fieldChanges: prunedFields };
         if (prunedChange.fieldChanges === undefined) {
             delete prunedChange.fieldChanges;
         }
-        return isEmptyNodeChangeset(prunedChange) ? undefined : prunedChange;
+        if (isEmptyNodeChangeset(prunedChange)) {
+            (0, index_js_2.deleteFromNestedMap)(nodeMap, nodeId.revision, nodeId.localId);
+            return undefined;
+        }
+        else {
+            (0, index_js_2.setInNestedMap)(nodeMap, nodeId.revision, nodeId.localId, prunedChange);
+            return nodeId;
+        }
     }
     buildEditor(changeReceiver) {
         return new ModularEditBuilder(this, changeReceiver);
@@ -388,7 +465,7 @@ function composeBuildsDestroysAndRefreshers(changes) {
         if (change.builds) {
             for (const [revisionKey, innerMap] of change.builds) {
                 const setRevisionKey = revisionKey ?? revision;
-                const innerDstMap = (0, index_js_3.getOrAddInMap)(allBuilds, setRevisionKey, new Map());
+                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 repair data refreshers (e.g., undos):
@@ -403,13 +480,13 @@ function composeBuildsDestroysAndRefreshers(changes) {
                     // 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_3.tryGetFromNestedMap)(allDestroys, setRevisionKey, id);
+                        const destroyCount = (0, index_js_2.tryGetFromNestedMap)(allDestroys, setRevisionKey, id);
                         if (destroyCount === undefined) {
                             innerDstMap.set(id, chunk);
                         }
                         else {
-                            (0, core_utils_1.assert)(destroyCount === chunk.topLevelLength, 0x89b /* Expected build and destroy to have the same length */);
-                            (0, index_js_3.deleteFromNestedMap)(allDestroys, setRevisionKey, id);
+                            (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);
                         }
                     }
                 }
@@ -421,16 +498,16 @@ function composeBuildsDestroysAndRefreshers(changes) {
         if (change.destroys !== undefined) {
             for (const [revisionKey, innerMap] of change.destroys) {
                 const setRevisionKey = revisionKey ?? revision;
-                const innerDstMap = (0, index_js_3.getOrAddInMap)(allDestroys, setRevisionKey, new Map());
+                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_3.tryGetFromNestedMap)(allBuilds, setRevisionKey, id);
+                    const chunk = (0, index_js_2.tryGetFromNestedMap)(allBuilds, setRevisionKey, id);
                     if (chunk === undefined) {
                         innerDstMap.set(id, count);
                     }
                     else {
-                        (0, core_utils_1.assert)(count === chunk.topLevelLength, 0x89c /* Expected build and destroy to have the same length */);
-                        (0, index_js_3.deleteFromNestedMap)(allBuilds, setRevisionKey, id);
+                        (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) {
@@ -440,7 +517,7 @@ function composeBuildsDestroysAndRefreshers(changes) {
         }
         // add all refreshers while preferring earlier ones
         if (change.refreshers) {
-            (0, index_js_3.populateNestedMap)(change.refreshers, allRefreshers, false);
+            (0, index_js_2.populateNestedMap)(change.refreshers, allRefreshers, false);
         }
     }
     return { allBuilds, allDestroys, allRefreshers };
@@ -476,19 +553,21 @@ function invertBuilds(builds, fallbackRevision) {
  * @param fieldKinds - The field kinds to delegate to.
  */
 function* relevantRemovedRoots({ change, revision }, fieldKinds) {
-    yield* relevantRemovedRootsFromFields(change.fieldChanges, revision, fieldKinds);
+    yield* relevantRemovedRootsFromFields(change.fieldChanges, revision, change.nodeChanges, fieldKinds);
 }
 exports.relevantRemovedRoots = relevantRemovedRoots;
-function* relevantRemovedRootsFromFields(change, revision, fieldKinds) {
+function* relevantRemovedRootsFromFields(change, revision, nodeChanges, fieldKinds) {
     for (const [_, fieldChange] of change) {
         const fieldRevision = fieldChange.revision ?? revision;
         const handler = getChangeHandler(fieldKinds, fieldChange.fieldKind);
         const delegate = function* (node) {
-            if (node.fieldChanges !== undefined) {
-                yield* relevantRemovedRootsFromFields(node.fieldChanges, fieldRevision, fieldKinds);
+            const nodeChangeset = (0, index_js_2.tryGetFromNestedMap)(nodeChanges, node.revision, node.localId);
+            (0, internal_1.assert)(nodeChangeset !== undefined, 0x931 /* Unknown node ID */);
+            if (nodeChangeset.fieldChanges !== undefined) {
+                yield* relevantRemovedRootsFromFields(nodeChangeset.fieldChanges, fieldRevision, nodeChanges, fieldKinds);
             }
         };
-        yield* handler.relevantRemovedRoots((0, index_js_2.tagChange)(fieldChange.change, fieldRevision), delegate);
+        yield* handler.relevantRemovedRoots((0, index_js_1.tagChange)(fieldChange.change, fieldRevision), delegate);
     }
 }
 /**
@@ -501,22 +580,39 @@ function* relevantRemovedRootsFromFields(change, revision, fieldKinds) {
  * @param removedRoots - The set of removed roots that should be in memory for the given change to be applied.
  * Can be retrieved by calling {@link relevantRemovedRoots}.
  */
-function updateRefreshers(change, getDetachedNode, removedRoots) {
+function updateRefreshers({ change, revision }, getDetachedNode, removedRoots) {
     const refreshers = new Map();
+    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 root of removedRoots) {
-        if (change.change.builds !== undefined) {
-            // if the root exists in the original builds map, it does not need to be added as a refresher
-            const original = (0, index_js_3.tryGetFromNestedMap)(change.change.builds, root.major, root.minor);
-            if (original !== undefined) {
-                continue;
+        if (change.builds !== undefined) {
+            const major = root.major === revision ? undefined : root.major;
+            const lengthTree = chunkLengths.get(major);
+            if (lengthTree !== undefined) {
+                const lengthPair = lengthTree.getPairOrNextLower(root.minor);
+                if (lengthPair !== undefined) {
+                    const [firstMinor, length] = lengthPair;
+                    // if the root minor is within the length of the minor of the retrieved pair
+                    // then there's no need to check for the detached node
+                    if (root.minor < firstMinor + length) {
+                        continue;
+                    }
+                }
             }
         }
         const node = getDetachedNode(root);
-        (0, core_utils_1.assert)(node !== undefined, 0x8cd /* detached node should exist */);
-        (0, index_js_3.setInNestedMap)(refreshers, root.major, root.minor, node);
+        (0, internal_1.assert)(node !== undefined, 0x8cd /* detached node should exist */);
+        (0, index_js_2.setInNestedMap)(refreshers, root.major, root.minor, node);
     }
-    const { fieldChanges, maxId, revisions, constraintViolationCount, builds, destroys } = change.change;
-    return makeModularChangeset(fieldChanges, maxId, revisions, constraintViolationCount, builds, destroys, refreshers);
+    const { fieldChanges, nodeChanges, maxId, revisions, constraintViolationCount, builds, destroys, } = change;
+    return makeModularChangeset(fieldChanges, nodeChanges, maxId, revisions, constraintViolationCount, builds, destroys, refreshers);
 }
 exports.updateRefreshers = updateRefreshers;
 /**
@@ -527,12 +623,12 @@ function intoDelta(taggedChange, fieldKinds) {
     const change = taggedChange.change;
     // Return an empty delta for changes with constraint violations
     if ((change.constraintViolationCount ?? 0) > 0) {
-        return index_js_2.emptyDelta;
+        return index_js_1.emptyDelta;
     }
     const revision = revisionFromTaggedChange(taggedChange);
     const idAllocator = memoizedIdRangeAllocator_js_1.MemoizedIdRangeAllocator.fromNextId();
     const rootDelta = {};
-    const fieldDeltas = intoDeltaImpl(change.fieldChanges, revision, idAllocator, fieldKinds);
+    const fieldDeltas = intoDeltaImpl(change.fieldChanges, revision, change.nodeChanges, idAllocator, fieldKinds);
     if (fieldDeltas.size > 0) {
         rootDelta.fields = fieldDeltas;
     }
@@ -541,9 +637,9 @@ function intoDelta(taggedChange, fieldKinds) {
     }
     if (change.destroys !== undefined && change.destroys.size > 0) {
         const destroys = [];
-        (0, index_js_3.forEachInNestedMap)(change.destroys, (count, major, minor) => {
+        (0, index_js_2.forEachInNestedMap)(change.destroys, (count, major, minor) => {
             destroys.push({
-                id: (0, index_js_2.makeDetachedNodeId)(major ?? revision, minor),
+                id: (0, index_js_1.makeDetachedNodeId)(major ?? revision, minor),
                 count,
             });
         });
@@ -557,11 +653,11 @@ function intoDelta(taggedChange, fieldKinds) {
 exports.intoDelta = intoDelta;
 function copyDetachedNodes(detachedNodes, revision) {
     const copiedDetachedNodes = [];
-    (0, index_js_3.forEachInNestedMap)(detachedNodes, (chunk, major, minor) => {
+    (0, index_js_2.forEachInNestedMap)(detachedNodes, (chunk, major, minor) => {
         if (chunk.topLevelLength > 0) {
-            const trees = (0, index_js_2.mapCursorField)(chunk.cursor(), (c) => (0, mapTreeCursor_js_1.cursorForMapTreeNode)((0, mapTreeCursor_js_1.mapTreeFromCursor)(c)));
+            const trees = (0, index_js_1.mapCursorField)(chunk.cursor(), (c) => (0, mapTreeCursor_js_1.cursorForMapTreeNode)((0, mapTreeCursor_js_1.mapTreeFromCursor)(c)));
             copiedDetachedNodes.push({
-                id: (0, index_js_2.makeDetachedNodeId)(major ?? revision, minor),
+                id: (0, index_js_1.makeDetachedNodeId)(major ?? revision, minor),
                 trees,
             });
         }
@@ -574,20 +670,24 @@ function copyDetachedNodes(detachedNodes, revision) {
  * @param path - The path of the node being altered by the change as defined by the input context.
  * Undefined for the root and for nodes that do not exist in the input context.
  */
-function intoDeltaImpl(change, revision, idAllocator, fieldKinds) {
+function intoDeltaImpl(change, revision, nodeChanges, idAllocator, fieldKinds) {
     const delta = new Map();
     for (const [field, fieldChange] of change) {
         const fieldRevision = fieldChange.revision ?? revision;
-        const deltaField = getChangeHandler(fieldKinds, fieldChange.fieldKind).intoDelta((0, index_js_2.tagChange)(fieldChange.change, fieldRevision), (childChange) => deltaFromNodeChange((0, index_js_2.tagChange)(childChange, fieldRevision), idAllocator, fieldKinds), idAllocator);
-        if (!(0, index_js_2.isEmptyFieldChanges)(deltaField)) {
+        const deltaField = getChangeHandler(fieldKinds, fieldChange.fieldKind).intoDelta((0, index_js_1.tagChange)(fieldChange.change, fieldRevision), (childChange) => {
+            const nodeChange = (0, index_js_2.tryGetFromNestedMap)(nodeChanges, childChange.revision, childChange.localId);
+            (0, internal_1.assert)(nodeChange !== undefined, 0x932 /* Unknown node ID */);
+            return deltaFromNodeChange((0, index_js_1.tagChange)(nodeChange, fieldRevision), nodeChanges, idAllocator, fieldKinds);
+        }, idAllocator);
+        if (!(0, index_js_1.isEmptyFieldChanges)(deltaField)) {
             delta.set(field, deltaField);
         }
     }
     return delta;
 }
-function deltaFromNodeChange({ change, revision }, idAllocator, fieldKinds) {
+function deltaFromNodeChange({ change, revision }, nodeChanges, idAllocator, fieldKinds) {
     if (change.fieldChanges !== undefined) {
-        return intoDeltaImpl(change.fieldChanges, revision, idAllocator, fieldKinds);
+        return intoDeltaImpl(change.fieldChanges, revision, nodeChanges, idAllocator, fieldKinds);
     }
     // TODO: update the API to allow undefined to be returned here
     return new Map();
@@ -612,7 +712,7 @@ function rebaseRevisionMetadataFromInfo(revInfos, baseRevisions) {
     }
     const getBaseRevisions = () => filteredRevisions;
     return {
-        ...(0, index_js_2.revisionMetadataSourceFromInfo)(revInfos),
+        ...(0, index_js_1.revisionMetadataSourceFromInfo)(revInfos),
         getBaseRevisions,
     };
 }
@@ -625,7 +725,7 @@ function getFieldKind(fieldKinds, kind) {
         return genericFieldKind_js_1.genericFieldKind;
     }
     const fieldKind = fieldKinds.get(kind);
-    (0, core_utils_1.assert)(fieldKind !== undefined, 0x3ad /* Unknown field kind */);
+    (0, internal_1.assert)(fieldKind !== undefined, 0x3ad /* Unknown field kind */);
     return (0, fieldKindWithEditor_js_1.withEditor)(fieldKind);
 }
 exports.getFieldKind = getFieldKind;
@@ -637,7 +737,8 @@ function newComposeTable() {
     return {
         ...newCrossFieldTable(),
         fieldToContext: new Map(),
-        nodeCache: new Map(),
+        nodeIds: new Map(),
+        nodeIdPairs: [],
     };
 }
 function newCrossFieldTable() {
@@ -649,14 +750,6 @@ function newCrossFieldTable() {
         invalidatedFields: new Set(),
     };
 }
-function composeCacheKeyFromNodeChangesets(change1, change2) {
-    // Note that it is important that the key is `change2 ?? change1` and not `change1 ?? change2`.
-    // If the first changeset moves this node, the change handler may not have seen the second changeset's
-    // changes for this node on its first pass.
-    // In that case we will have cached an entry the call to `compose(change1, undefined)`, and we must make sure
-    // not to reuse the cached entry if a subsequent pass calls `compose(change1, change2)`.
-    return change2 ?? change1 ?? (0, index_js_3.fail)("Should not compose two undefined changesets");
-}
 function newConstraintState(violationCount) {
     return {
         violationCount,
@@ -678,7 +771,7 @@ function newCrossFieldManager(crossFieldTable, currentFieldKey, allowInval = tru
                     if (dependentEntry.value !== undefined) {
                         crossFieldTable.invalidatedFields.add(dependentEntry.value);
                     }
-                    firstId = (0, index_js_3.brand)(firstId + dependentEntry.length);
+                    firstId = (0, index_js_2.brand)(firstId + dependentEntry.length);
                 }
             }
             (0, crossFieldQueries_js_1.setInCrossFieldMap)(getMap(target), revision, id, count, newValue);
@@ -695,13 +788,16 @@ function newCrossFieldManager(crossFieldTable, currentFieldKey, allowInval = tru
     };
     return manager;
 }
-function makeModularChangeset(changes = undefined, maxId = -1, revisions = undefined, constraintViolationCount = undefined, builds, destroys, refreshers) {
-    const changeset = { fieldChanges: changes ?? new Map() };
+function makeModularChangeset(fieldChanges = undefined, nodeChanges = undefined, maxId = -1, revisions = undefined, constraintViolationCount = undefined, builds, destroys, refreshers) {
+    const changeset = {
+        fieldChanges: fieldChanges ?? new Map(),
+        nodeChanges: nodeChanges ?? new Map(),
+    };
     if (revisions !== undefined && revisions.length > 0) {
         changeset.revisions = revisions;
     }
     if (maxId >= 0) {
-        changeset.maxId = (0, index_js_3.brand)(maxId);
+        changeset.maxId = (0, index_js_2.brand)(maxId);
     }
     if (constraintViolationCount !== undefined && constraintViolationCount > 0) {
         changeset.constraintViolationCount = constraintViolationCount;
@@ -717,23 +813,23 @@ function makeModularChangeset(changes = undefined, maxId = -1, revisions = undef
     }
     return changeset;
 }
-class ModularEditBuilder extends index_js_2.EditBuilder {
+class ModularEditBuilder extends index_js_1.EditBuilder {
     constructor(family, changeReceiver) {
         super(family, changeReceiver);
         this.transactionDepth = 0;
-        this.idAllocator = (0, index_js_3.idAllocatorFromMaxId)();
+        this.idAllocator = (0, index_js_2.idAllocatorFromMaxId)();
     }
     enterTransaction() {
         this.transactionDepth += 1;
         if (this.transactionDepth === 1) {
-            this.idAllocator = (0, index_js_3.idAllocatorFromMaxId)();
+            this.idAllocator = (0, index_js_2.idAllocatorFromMaxId)();
         }
     }
     exitTransaction() {
-        (0, core_utils_1.assert)(this.transactionDepth > 0, 0x5b9 /* Cannot exit inexistent transaction */);
+        (0, internal_1.assert)(this.transactionDepth > 0, 0x5b9 /* Cannot exit inexistent transaction */);
         this.transactionDepth -= 1;
         if (this.transactionDepth === 0) {
-            this.idAllocator = (0, index_js_3.idAllocatorFromMaxId)();
+            this.idAllocator = (0, index_js_2.idAllocatorFromMaxId)();
         }
     }
     /**
@@ -749,8 +845,8 @@ class ModularEditBuilder extends index_js_2.EditBuilder {
         const innerMap = new Map();
         builds.set(undefined, innerMap);
         const chunk = content.mode === 1 /* CursorLocationType.Fields */
-            ? (0, index_js_4.chunkFieldSingle)(content, index_js_4.defaultChunkPolicy)
-            : (0, index_js_4.chunkTree)(content, index_js_4.defaultChunkPolicy);
+            ? (0, index_js_3.chunkFieldSingle)(content, index_js_3.defaultChunkPolicy)
+            : (0, index_js_3.chunkTree)(content, index_js_3.defaultChunkPolicy);
         innerMap.set(firstId, chunk);
         return {
             type: "global",
@@ -764,63 +860,59 @@ class ModularEditBuilder extends index_js_2.EditBuilder {
      * @param change - the change to the field
      * @param maxId - the highest `ChangesetLocalId` used in this change
      */
-    submitChange(field, fieldKind, change, maxId = (0, index_js_3.brand)(-1)) {
-        const modularChange = this.buildChange(field, fieldKind, change, maxId);
+    submitChange(field, fieldKind, change) {
+        const modularChange = buildModularChangesetFromField(field, { fieldKind, change }, new Map(), this.idAllocator);
         this.applyChange(modularChange);
     }
-    /**
-     * Adds a change to the edit builder
-     * @param field - the field which is being edited
-     * @param fieldKind - the kind of the field
-     * @param change - the change to the field
-     * @param maxId - the highest `ChangesetLocalId` used in this change
-     */
-    buildChange(field, fieldKind, change, maxId = (0, index_js_3.brand)(-1)) {
-        const changeMap = this.buildChangeMap(field, fieldKind, change);
-        return makeModularChangeset(changeMap, maxId);
-    }
-    submitChanges(changes, maxId = (0, index_js_3.brand)(-1)) {
-        const modularChange = this.buildChanges(changes, maxId);
+    submitChanges(changes) {
+        const modularChange = this.buildChanges(changes);
         this.applyChange(modularChange);
     }
-    buildChanges(changes, maxId = (0, index_js_3.brand)(-1)) {
-        const changeMaps = changes.map((change) => (0, index_js_2.makeAnonChange)(change.type === "global"
-            ? makeModularChangeset(undefined, undefined, undefined, undefined, change.builds)
-            : makeModularChangeset(this.buildChangeMap(change.field, change.fieldKind, change.change))));
+    buildChanges(changes) {
+        const changeMaps = changes.map((change) => (0, index_js_1.makeAnonChange)(change.type === "global"
+            ? makeModularChangeset(undefined, undefined, this.idAllocator.getMaxId(), undefined, undefined, change.builds)
+            : buildModularChangesetFromField(change.field, {
+                fieldKind: change.fieldKind,
+                change: change.change,
+            }, new Map(), this.idAllocator)));
         const composedChange = this.changeFamily.rebaser.compose(changeMaps);
+        const maxId = (0, index_js_2.brand)(this.idAllocator.getMaxId());
         if (maxId >= 0) {
             composedChange.maxId = maxId;
         }
         return composedChange;
     }
     generateId(count) {
-        return (0, index_js_3.brand)(this.idAllocator.allocate(count));
-    }
-    buildChangeMap(field, fieldKind, change) {
-        let fieldChangeMap = new Map([[field.field, { fieldKind, change }]]);
-        let remainingPath = field.parent;
-        while (remainingPath !== undefined) {
-            const nodeChange = { fieldChanges: fieldChangeMap };
-            const fieldChange = genericFieldKind_js_1.genericFieldKind.changeHandler.editor.buildChildChange(remainingPath.parentIndex, nodeChange);
-            fieldChangeMap = new Map([
-                [
-                    remainingPath.parentField,
-                    { fieldKind: genericFieldKind_js_1.genericFieldKind.identifier, change: (0, index_js_3.brand)(fieldChange) },
-                ],
-            ]);
-            remainingPath = remainingPath.parent;
-        }
-        return fieldChangeMap;
+        return (0, index_js_2.brand)(this.idAllocator.allocate(count));
     }
     addNodeExistsConstraint(path) {
         const nodeChange = {
             nodeExistsConstraint: { violated: false },
         };
-        const fieldChange = genericFieldKind_js_1.genericFieldKind.changeHandler.editor.buildChildChange(path.parentIndex, nodeChange);
-        this.submitChange({ parent: path.parent, field: path.parentField }, genericFieldKind_js_1.genericFieldKind.identifier, (0, index_js_3.brand)(fieldChange));
+        this.applyChange(buildModularChangesetFromNode(path, nodeChange, new Map(), this.idAllocator));
     }
 }
 exports.ModularEditBuilder = ModularEditBuilder;
+function buildModularChangesetFromField(path, fieldChange, nodeChanges, idAllocator = (0, index_js_2.idAllocatorFromMaxId)()) {
+    const fieldChanges = new Map([[path.field, fieldChange]]);
+    if (path.parent === undefined) {
+        return makeModularChangeset(fieldChanges, nodeChanges, idAllocator.getMaxId());
+    }
+    const nodeChangeset = {
+        fieldChanges,
+    };
+    return buildModularChangesetFromNode(path.parent, nodeChangeset, nodeChanges, idAllocator);
+}
+function buildModularChangesetFromNode(path, nodeChange, nodeChanges, idAllocator) {
+    const nodeId = { localId: (0, index_js_2.brand)(idAllocator.allocate()) };
+    (0, index_js_2.setInNestedMap)(nodeChanges, nodeId.revision, nodeId.localId, nodeChange);
+    const fieldChangeset = genericFieldKind_js_1.genericFieldKind.changeHandler.editor.buildChildChange(path.parentIndex, nodeId);
+    const fieldChange = {
+        fieldKind: genericFieldKind_js_1.genericFieldKind.identifier,
+        change: fieldChangeset,
+    };
+    return buildModularChangesetFromField({ parent: path.parent, field: path.parentField }, fieldChange, nodeChanges, idAllocator);
+}
 function getRevInfoFromTaggedChanges(changes) {
     let maxId = -1;
     const revInfos = [];
@@ -843,7 +935,7 @@ function getRevInfoFromTaggedChanges(changes) {
             revInfos.push({ revision });
         }
     }
-    return { maxId: (0, index_js_3.brand)(maxId), revInfos };
+    return { maxId: (0, index_js_2.brand)(maxId), revInfos };
 }
 function revisionInfoFromTaggedChange(taggedChange) {
     const revInfos = [];