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

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

@@ -2,27 +2,25 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-import { assert } from "@fluidframework/core-utils";
-import { makeCodecFamily } from "../../codec/index.js";
-import { EditBuilder, tagChange, makeAnonChange, isEmptyFieldChanges, revisionMetadataSourceFromInfo, makeDetachedNodeId, emptyDelta, mapCursorField, } from "../../core/index.js";
-import { brand, deleteFromNestedMap, fail, forEachInNestedMap, getOrAddInMap, idAllocatorFromMaxId, idAllocatorFromState, populateNestedMap, setInNestedMap, tryGetFromNestedMap, } from "../../util/index.js";
-import { MemoizedIdRangeAllocator } from "../memoizedIdRangeAllocator.js";
-import { chunkFieldSingle, defaultChunkPolicy, chunkTree, } from "../chunked-forest/index.js";
+import { assert } from "@fluidframework/core-utils/internal";
+import { BTree } from "@tylerbu/sorted-btree-es6";
+import { EditBuilder, emptyDelta, isEmptyFieldChanges, makeAnonChange, makeDetachedNodeId, mapCursorField, revisionMetadataSourceFromInfo, tagChange, taggedAtomId, taggedOptAtomId, } from "../../core/index.js";
+import { addToNestedSet, brand, deleteFromNestedMap, fail, forEachInNestedMap, getOrAddInMap, idAllocatorFromMaxId, idAllocatorFromState, nestedSetContains, populateNestedMap, setInNestedMap, tryGetFromNestedMap, } from "../../util/index.js";
+import { chunkFieldSingle, chunkTree, defaultChunkPolicy, } from "../chunked-forest/index.js";
 import { cursorForMapTreeNode, mapTreeFromCursor } from "../mapTreeCursor.js";
+import { MemoizedIdRangeAllocator } from "../memoizedIdRangeAllocator.js";
 import { CrossFieldTarget, getFirstFromCrossFieldMap, setInCrossFieldMap, } from "./crossFieldQueries.js";
 import { NodeExistenceState, } from "./fieldChangeHandler.js";
 import { withEditor } from "./fieldKindWithEditor.js";
 import { convertGenericChange, genericFieldKind, newGenericChangeset } from "./genericFieldKind.js";
-import { makeV0Codec } from "./modularChangeCodecs.js";
 /**
  * Implementation of ChangeFamily which delegates work in a given field to the appropriate FieldKind
  * as determined by the schema.
  */
 export class ModularChangeFamily {
-    constructor(fieldKinds, revisionTagCodec, fieldBatchCodec, codecOptions, chunkCompressionStrategy) {
+    constructor(fieldKinds, codecs) {
+        this.codecs = codecs;
         this.fieldKinds = fieldKinds;
-        this.latestCodec = makeV0Codec(fieldKinds, revisionTagCodec, fieldBatchCodec, codecOptions, chunkCompressionStrategy);
-        this.codecs = makeCodecFamily([[0, this.latestCodec]]);
     }
     get rebaser() {
         return this;
@@ -62,20 +60,28 @@ export class ModularChangeFamily {
         }
         // The cast is based on the `fieldKind` check above
         const genericChange = fieldChange.change;
-        const convertedChange = convertGenericChange(genericChange, handler, (child1, child2) => this.composeNodeChanges(child1, undefined, child2, undefined, genId, newComposeTable(), revisionMetadata), genId, revisionMetadata);
+        const convertedChange = convertGenericChange(genericChange, handler, (child1, child2) => {
+            assert(child1 === undefined || child2 === undefined, 0x92f /* Should not have two changesets to compose */);
+            return child1 ?? child2 ?? 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) => makeAnonChange(this.composePair(change1, change2, revInfos, idState)), makeAnonChange({ fieldChanges: new Map() })).change;
+        return activeChanges.reduce((change1, change2) => makeAnonChange(this.composePair(change1, change2, revInfos, idState)), makeAnonChange({ fieldChanges: new Map(), nodeChanges: new Map() })).change;
     }
     composePair(change1, change2, revInfos, idState) {
         const genId = idAllocatorFromState(idState);
         const revisionMetadata = 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();
@@ -84,23 +90,38 @@ export class ModularChangeFamily {
                 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 &&
+                        !nestedSetContains(crossFieldTable.nodeIds, child2.revision, child2.localId)) {
+                        const taggedId1 = child1 !== undefined
+                            ? tagChange(child1, fieldChange1.revision)
+                            : undefined;
+                        const taggedId2 = child2 !== undefined
+                            ? tagChange(child2, fieldChange2.revision)
+                            : undefined;
+                        crossFieldTable.nodeIdPairs.push([taggedId1, taggedId2]);
+                        if (child1 !== undefined && child2 !== undefined) {
+                            addToNestedSet(crossFieldTable.nodeIds, child2.revision, child2.localId);
+                        }
                     }
-                    return this.composeNodeChanges(node1, fieldChange1.revision, node2, fieldChange2.revision, genId, crossFieldTable, revisionMetadata);
+                    return (taggedOptAtomId(child1, fieldChange1.revision) ??
+                        taggedOptAtomId(child2, fieldChange2.revision) ??
+                        fail("Should not compose two undefined nodes"));
                 };
                 const amendedChange = rebaser.compose(fieldChange1, fieldChange2, composeNodes, genId, newCrossFieldManager(crossFieldTable, fieldChange, false), revisionMetadata);
                 composedChange.change = 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();
@@ -118,7 +139,21 @@ export class ModularChangeFamily {
             const manager = newCrossFieldManager(crossFieldTable, fieldChange1 ?? fieldChange2);
             const taggedChange1 = tagChange(normalizedFieldChange1 ?? fieldKind.changeHandler.createEmpty(), fieldChange1?.revision ?? revision1);
             const taggedChange2 = 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 composedChange = fieldKind.changeHandler.rebaser.compose(taggedChange1, taggedChange2, (child1, child2) => {
+                const taggedId1 = child1 !== undefined
+                    ? tagChange(child1, taggedChange1.revision)
+                    : undefined;
+                const taggedId2 = child2 !== undefined
+                    ? tagChange(child2, taggedChange2.revision)
+                    : undefined;
+                crossFieldTable.nodeIdPairs.push([taggedId1, taggedId2]);
+                if (child2 !== undefined) {
+                    addToNestedSet(crossFieldTable.nodeIds, child2.revision, child2.localId);
+                }
+                return (taggedOptAtomId(child1, revision1) ??
+                    taggedOptAtomId(child2, revision2) ??
+                    fail("Should not compose two undefined nodes"));
+            }, genId, manager, revisionMetadata);
             const composedField = {
                 fieldKind: fieldKind.identifier,
                 change: brand(composedChange),
@@ -134,6 +169,21 @@ export class ModularChangeFamily {
         }
         return composedFields;
     }
+    composeNodesById(nodeChanges1, nodeChanges2, composedNodeChanges, id1, revision1, id2, revision2, idAllocator, crossFieldTable, revisionMetadata) {
+        const nodeChangeset1 = id1 !== undefined
+            ? tryGetFromNestedMap(nodeChanges1, id1.revision, id1.localId) ??
+                fail("Unknown node ID")
+            : {};
+        const nodeChangeset2 = id2 !== undefined
+            ? tryGetFromNestedMap(nodeChanges2, id2.revision, id2.localId) ??
+                fail("Unknown node ID")
+            : {};
+        const composedNodeChangeset = this.composeNodeChanges(nodeChangeset1, revision1, nodeChangeset2, revision2, idAllocator, crossFieldTable, revisionMetadata);
+        const nodeId = taggedOptAtomId(id1, revision1) ??
+            taggedOptAtomId(id2, revision2) ??
+            fail("Should not compose two undefined node IDs");
+        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);
@@ -144,8 +194,6 @@ export class ModularChangeFamily {
         if (nodeExistsConstraint !== undefined) {
             composedNodeChange.nodeExistsConstraint = nodeExistsConstraint;
         }
-        const key = composeCacheKeyFromNodeChangesets(change1, change2);
-        crossFieldTable.nodeCache.set(key, composedNodeChange);
         return composedNodeChange;
     }
     /**
@@ -171,6 +219,12 @@ export class ModularChangeFamily {
         const { revInfos } = getRevInfoFromTaggedChanges([change]);
         const revisionMetadata = revisionMetadataSourceFromInfo(revInfos);
         const invertedFields = this.invertFieldMap(tagChange(change.change.fieldChanges, revisionFromTaggedChange(change)), isRollback, genId, crossFieldTable, revisionMetadata);
+        const invertedNodes = new Map();
+        forEachInNestedMap(change.change.nodeChanges, (nodeChangeset, revision, localId) => {
+            setInNestedMap(invertedNodes, revision, localId, this.invertNodeChange(
+            // TODO: This does not allow inheriting revision from parent
+            tagChange(nodeChangeset, change.revision), isRollback, genId, crossFieldTable, revisionMetadata));
+        });
         if (crossFieldTable.invalidatedFields.size > 0) {
             const fieldsToUpdate = crossFieldTable.invalidatedFields;
             crossFieldTable.invalidatedFields = new Set();
@@ -179,7 +233,7 @@ export class ModularChangeFamily {
                 const context = crossFieldTable.originalFieldToContext.get(fieldChange);
                 assert(context !== undefined, 0x851 /* Should have context for every invalidated field */);
                 const { invertedField, revision } = context;
-                const amendedChange = getChangeHandler(this.fieldKinds, fieldChange.fieldKind).rebaser.invert(tagChange(originalFieldChange, revision), (nodeChangeset) => nodeChangeset, isRollback, genId, newCrossFieldManager(crossFieldTable, fieldChange), revisionMetadata);
+                const amendedChange = getChangeHandler(this.fieldKinds, fieldChange.fieldKind).rebaser.invert(tagChange(originalFieldChange, revision), isRollback, genId, newCrossFieldManager(crossFieldTable, fieldChange), revisionMetadata);
                 invertedField.change = brand(amendedChange);
             }
         }
@@ -190,7 +244,7 @@ export class ModularChangeFamily {
         // Destroys only occur in rollback changesets, which are never inverted.
         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 }))
@@ -201,7 +255,7 @@ export 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: brand(invertedChange),
@@ -229,6 +283,7 @@ export class ModularChangeFamily {
             ...newCrossFieldTable(),
             fieldToContext: new Map(),
             rebasedNodeCache: new Map(),
+            nodeIdPairs: [],
         };
         let constraintState = newConstraintState(change.constraintViolationCount ?? 0);
         const getBaseRevisions = () => revisionInfoFromTaggedChange(over).map((info) => info.revision);
@@ -237,6 +292,21 @@ export class ModularChangeFamily {
             getBaseRevisions,
         };
         const rebasedFields = this.rebaseFieldMap(change.fieldChanges, 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
+                ? tryGetFromNestedMap(change.nodeChanges, newId.revision, newId.localId)
+                : undefined;
+            const taggedBaseNodeChange = taggedBaseId !== undefined
+                ? tagChange(tryGetFromNestedMap(over.change.nodeChanges, taggedBaseId.change.revision, taggedBaseId.change.localId) ?? fail("Unknown node ID"), taggedBaseId.revision)
+                : makeAnonChange({});
+            const rebasedNode = this.rebaseNodeChange(newNodeChange, taggedBaseNodeChange, genId, crossFieldTable, () => true, rebaseMetadata, constraintState, existenceState);
+            if (rebasedNode !== undefined) {
+                const nodeId = newId ??
+                    taggedAtomId(taggedBaseId?.change ?? fail("Should not have two undefined IDs"), taggedBaseId?.revision);
+                setInNestedMap(rebasedNodes, nodeId.revision, nodeId.localId, rebasedNode);
+            }
+        }
         if (crossFieldTable.invalidatedFields.size > 0) {
             const fieldsToUpdate = crossFieldTable.invalidatedFields;
             crossFieldTable.invalidatedFields = new Set();
@@ -246,22 +316,10 @@ export class ModularChangeFamily {
                 const context = crossFieldTable.fieldToContext.get(field);
                 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, 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, tagChange(base, context.baseRevision), genId, crossFieldTable, () => true, rebaseMetadata, constraintState, existenceState);
-                }, genId, newCrossFieldManager(crossFieldTable, field), rebaseMetadata);
+                context.rebasedChange.change = fieldKind.changeHandler.rebaser.rebase(fieldChangeset, 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 = NodeExistenceState.Alive) {
         const rebasedFields = new Map();
@@ -278,7 +336,16 @@ export class ModularChangeFamily {
             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 ? 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.
+                    taggedAtomId(baseChild ?? 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,
@@ -304,7 +371,8 @@ export class ModularChangeFamily {
                 const manager = newCrossFieldManager(crossFieldTable, fieldChange);
                 const rebasedChangeset = fieldKind.changeHandler.rebaser.rebase(fieldChangeset, tagChange(baseChangeset, over.revision), (child, baseChild) => {
                     assert(baseChild === undefined, 0x5b6 /* This field should not have any base changes */);
-                    return this.rebaseNodeChange(child, tagChange(undefined, over.revision), genId, crossFieldTable, fieldFilter, revisionMetadata, constraintState, existenceState);
+                    crossFieldTable.nodeIdPairs.push([child, undefined, existenceState]);
+                    return child;
                 }, genId, manager, revisionMetadata, existenceState);
                 const rebasedFieldChange = {
                     fieldKind: fieldKind.identifier,
@@ -348,26 +416,35 @@ export 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: brand(prunedFieldChangeset) });
             }
         }
         return prunedChangeset.size > 0 ? prunedChangeset : undefined;
     }
-    pruneNodeChange(changeset) {
+    pruneNodeChange(nodeId, nodeMap) {
+        const changeset = tryGetFromNestedMap(nodeMap, nodeId.revision, nodeId.localId);
+        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)) {
+            deleteFromNestedMap(nodeMap, nodeId.revision, nodeId.localId);
+            return undefined;
+        }
+        else {
+            setInNestedMap(nodeMap, nodeId.revision, nodeId.localId, prunedChange);
+            return nodeId;
+        }
     }
     buildEditor(changeReceiver) {
         return new ModularEditBuilder(this, changeReceiver);
@@ -472,15 +549,17 @@ function invertBuilds(builds, fallbackRevision) {
  * @param fieldKinds - The field kinds to delegate to.
  */
 export function* relevantRemovedRoots({ change, revision }, fieldKinds) {
-    yield* relevantRemovedRootsFromFields(change.fieldChanges, revision, fieldKinds);
+    yield* relevantRemovedRootsFromFields(change.fieldChanges, revision, change.nodeChanges, fieldKinds);
 }
-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 = tryGetFromNestedMap(nodeChanges, node.revision, node.localId);
+            assert(nodeChangeset !== undefined, 0x931 /* Unknown node ID */);
+            if (nodeChangeset.fieldChanges !== undefined) {
+                yield* relevantRemovedRootsFromFields(nodeChangeset.fieldChanges, fieldRevision, nodeChanges, fieldKinds);
             }
         };
         yield* handler.relevantRemovedRoots(tagChange(fieldChange.change, fieldRevision), delegate);
@@ -496,22 +575,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}.
  */
-export function updateRefreshers(change, getDetachedNode, removedRoots) {
+export 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 = getOrAddInMap(chunkLengths, major, new 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 = 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);
         assert(node !== undefined, 0x8cd /* detached node should exist */);
         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);
 }
 /**
  * @param change - The change to convert into a delta.
@@ -526,7 +622,7 @@ export function intoDelta(taggedChange, fieldKinds) {
     const revision = revisionFromTaggedChange(taggedChange);
     const idAllocator = 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;
     }
@@ -567,20 +663,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(tagChange(fieldChange.change, fieldRevision), (childChange) => deltaFromNodeChange(tagChange(childChange, fieldRevision), idAllocator, fieldKinds), idAllocator);
+        const deltaField = getChangeHandler(fieldKinds, fieldChange.fieldKind).intoDelta(tagChange(fieldChange.change, fieldRevision), (childChange) => {
+            const nodeChange = tryGetFromNestedMap(nodeChanges, childChange.revision, childChange.localId);
+            assert(nodeChange !== undefined, 0x932 /* Unknown node ID */);
+            return deltaFromNodeChange(tagChange(nodeChange, fieldRevision), nodeChanges, idAllocator, fieldKinds);
+        }, idAllocator);
         if (!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();
@@ -627,7 +727,8 @@ function newComposeTable() {
     return {
         ...newCrossFieldTable(),
         fieldToContext: new Map(),
-        nodeCache: new Map(),
+        nodeIds: new Map(),
+        nodeIdPairs: [],
     };
 }
 function newCrossFieldTable() {
@@ -639,14 +740,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 ?? fail("Should not compose two undefined changesets");
-}
 function newConstraintState(violationCount) {
     return {
         violationCount,
@@ -685,8 +778,11 @@ 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;
     }
@@ -754,30 +850,23 @@ export class ModularEditBuilder extends EditBuilder {
      * @param change - the change to the field
      * @param maxId - the highest `ChangesetLocalId` used in this change
      */
-    submitChange(field, fieldKind, change, maxId = 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 = brand(-1)) {
-        const changeMap = this.buildChangeMap(field, fieldKind, change);
-        return makeModularChangeset(changeMap, maxId);
-    }
-    submitChanges(changes, maxId = brand(-1)) {
-        const modularChange = this.buildChanges(changes, maxId);
+    submitChanges(changes) {
+        const modularChange = this.buildChanges(changes);
         this.applyChange(modularChange);
     }
-    buildChanges(changes, maxId = brand(-1)) {
+    buildChanges(changes) {
         const changeMaps = changes.map((change) => makeAnonChange(change.type === "global"
-            ? makeModularChangeset(undefined, undefined, undefined, undefined, change.builds)
-            : makeModularChangeset(this.buildChangeMap(change.field, change.fieldKind, change.change))));
+            ? 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 = brand(this.idAllocator.getMaxId());
         if (maxId >= 0) {
             composedChange.maxId = maxId;
         }
@@ -786,30 +875,33 @@ export class ModularEditBuilder extends EditBuilder {
     generateId(count) {
         return 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.changeHandler.editor.buildChildChange(remainingPath.parentIndex, nodeChange);
-            fieldChangeMap = new Map([
-                [
-                    remainingPath.parentField,
-                    { fieldKind: genericFieldKind.identifier, change: brand(fieldChange) },
-                ],
-            ]);
-            remainingPath = remainingPath.parent;
-        }
-        return fieldChangeMap;
-    }
     addNodeExistsConstraint(path) {
         const nodeChange = {
             nodeExistsConstraint: { violated: false },
         };
-        const fieldChange = genericFieldKind.changeHandler.editor.buildChildChange(path.parentIndex, nodeChange);
-        this.submitChange({ parent: path.parent, field: path.parentField }, genericFieldKind.identifier, brand(fieldChange));
+        this.applyChange(buildModularChangesetFromNode(path, nodeChange, new Map(), this.idAllocator));
     }
 }
+function buildModularChangesetFromField(path, fieldChange, nodeChanges, idAllocator = 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: brand(idAllocator.allocate()) };
+    setInNestedMap(nodeChanges, nodeId.revision, nodeId.localId, nodeChange);
+    const fieldChangeset = genericFieldKind.changeHandler.editor.buildChildChange(path.parentIndex, nodeId);
+    const fieldChange = {
+        fieldKind: genericFieldKind.identifier,
+        change: fieldChangeset,
+    };
+    return buildModularChangesetFromField({ parent: path.parent, field: path.parentField }, fieldChange, nodeChanges, idAllocator);
+}
 function getRevInfoFromTaggedChanges(changes) {
     let maxId = -1;
     const revInfos = [];