@fluidframework/tree 2.74.0 → 2.80.0

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

@@ -7,19 +7,24 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizeFieldId = exports.getParentFieldId = exports.ModularEditBuilder = exports.getChangeHandler = exports.getFieldKind = exports.rebaseRevisionMetadataFromInfo = exports.intoDelta = exports.updateRefreshers = exports.relevantRemovedRoots = exports.ModularChangeFamily = void 0;
 const internal_1 = require("@fluidframework/core-utils/internal");
 const sorted_btree_es6_1 = require("@tylerbu/sorted-btree-es6");
-const index_js_1 = require("../../core/index.js");
-const index_js_2 = require("../../util/index.js");
+const internal_2 = require("@fluidframework/telemetry-utils/internal");
+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 crossFieldQueries_js_1 = require("./crossFieldQueries.js");
 const fieldChangeHandler_js_1 = require("./fieldChangeHandler.js");
 const genericFieldKind_js_1 = require("./genericFieldKind.js");
 const modularChangeTypes_js_1 = require("./modularChangeTypes.js");
+const changeAtomIdBTree_js_1 = require("../changeAtomIdBTree.js");
+const semver_ts_1 = require("semver-ts");
 /**
  * Implementation of ChangeFamily which delegates work in a given field to the appropriate FieldKind
  * as determined by the schema.
  */
 class ModularChangeFamily {
-    constructor(fieldKinds, codecs) {
+    constructor(fieldKinds, codecs, codecOptions) {
         this.codecs = codecs;
+        this.codecOptions = codecOptions;
         this.fieldKinds = fieldKinds;
     }
     get rebaser() {
@@ -34,9 +39,9 @@ class ModularChangeFamily {
      */
     normalizeFieldChanges(change1, change2) {
         // TODO: Handle the case where changes have conflicting field kinds
-        const kind = change1.fieldKind !== genericFieldKind_js_1.genericFieldKind.identifier
-            ? change1.fieldKind
-            : change2.fieldKind;
+        const kind = change1.fieldKind === genericFieldKind_js_1.genericFieldKind.identifier
+            ? change2.fieldKind
+            : change1.fieldKind;
         if (kind === genericFieldKind_js_1.genericFieldKind.identifier) {
             // Both changes are generic
             return {
@@ -73,11 +78,14 @@ class ModularChangeFamily {
             return this.composePair(left, right, revInfos, idState);
         };
         const innerChanges = changes.map((change) => change.change);
-        return (0, index_js_2.balancedReduce)(innerChanges, pairwiseDelegate, makeModularChangeset);
+        return (0, index_js_3.balancedReduce)(innerChanges, pairwiseDelegate, makeModularChangeset);
     }
     composePair(change1, change2, revInfos, idState) {
         const { fieldChanges, nodeChanges, nodeToParent, nodeAliases, crossFieldKeys } = this.composeAllFields(change1, change2, revInfos, idState);
         const { allBuilds, allDestroys, allRefreshers } = composeBuildsDestroysAndRefreshers(change1, change2);
+        // The composed changeset has a "no change" constraint if either change has one
+        const noChangeConstraint = change1.noChangeConstraint ?? change2.noChangeConstraint;
+        const noChangeConstraintOnRevert = change1.noChangeConstraintOnRevert ?? change2.noChangeConstraintOnRevert;
         return makeModularChangeset({
             fieldChanges,
             nodeChanges,
@@ -86,6 +94,8 @@ class ModularChangeFamily {
             crossFieldKeys,
             maxId: idState.maxId,
             revisions: revInfos,
+            noChangeConstraint,
+            noChangeConstraintOnRevert,
             builds: allBuilds,
             destroys: allDestroys,
             refreshers: allRefreshers,
@@ -97,8 +107,8 @@ class ModularChangeFamily {
         // TODO: remove once AB#46104 is completed
         const change1 = this.getEffectiveChange(potentiallyConflictedChange1);
         const change2 = this.getEffectiveChange(potentiallyConflictedChange2);
-        const genId = (0, index_js_2.idAllocatorFromState)(idState);
-        const revisionMetadata = (0, index_js_1.revisionMetadataSourceFromInfo)(revInfos);
+        const genId = (0, index_js_3.idAllocatorFromState)(idState);
+        const revisionMetadata = (0, index_js_2.revisionMetadataSourceFromInfo)(revInfos);
         // We merge nodeChanges, nodeToParent, and nodeAliases from the two changesets.
         // The merged tables will have correct entries for all nodes which are only referenced in one of the input changesets.
         // During composeFieldMaps and composeInvalidatedElements we will find all nodes referenced in both input changesets
@@ -107,14 +117,14 @@ class ModularChangeFamily {
         // A collision for a node ID means that that node is referenced in both changesets
         // (since we assume that if two changesets use the same node ID they are referring to the same node),
         // therefore all collisions will be addressed when processing the intersection of the changesets.
-        const composedNodeChanges = (0, index_js_2.brand)((0, index_js_2.mergeTupleBTrees)(change1.nodeChanges, change2.nodeChanges));
-        const composedNodeToParent = (0, index_js_2.brand)((0, index_js_2.mergeTupleBTrees)(change1.nodeToParent, change2.nodeToParent));
-        const composedNodeAliases = (0, index_js_2.brand)((0, index_js_2.mergeTupleBTrees)(change1.nodeAliases, change2.nodeAliases));
+        const composedNodeChanges = (0, index_js_3.brand)((0, index_js_3.mergeTupleBTrees)(change1.nodeChanges, change2.nodeChanges));
+        const composedNodeToParent = (0, index_js_3.brand)((0, index_js_3.mergeTupleBTrees)(change1.nodeToParent, change2.nodeToParent));
+        const composedNodeAliases = (0, index_js_3.brand)((0, index_js_3.mergeTupleBTrees)(change1.nodeAliases, change2.nodeAliases));
         const crossFieldTable = newComposeTable(change1, change2, composedNodeToParent);
         const composedFields = this.composeFieldMaps(change1.fieldChanges, change2.fieldChanges, undefined, genId, crossFieldTable, revisionMetadata);
         this.composeInvalidatedElements(crossFieldTable, composedFields, composedNodeChanges, composedNodeToParent, composedNodeAliases, genId, revisionMetadata);
         // Currently no field kinds require making changes to cross-field keys during composition, so we can just merge the two tables.
-        const composedCrossFieldKeys = index_js_2.RangeMap.union(change1.crossFieldKeys, change2.crossFieldKeys);
+        const composedCrossFieldKeys = index_js_3.RangeMap.union(change1.crossFieldKeys, change2.crossFieldKeys);
         return {
             fieldChanges: composedFields,
             nodeChanges: composedNodeChanges,
@@ -131,14 +141,14 @@ class ModularChangeFamily {
         const composeNodes = (child1, child2) => {
             if (child1 !== undefined &&
                 child2 !== undefined &&
-                getFromChangeAtomIdMap(crossFieldTable.newToBaseNodeId, child2) === undefined) {
-                setInChangeAtomIdMap(crossFieldTable.newToBaseNodeId, child2, child1);
+                (0, changeAtomIdBTree_js_1.getFromChangeAtomIdMap)(crossFieldTable.newToBaseNodeId, child2) === undefined) {
+                (0, changeAtomIdBTree_js_1.setInChangeAtomIdMap)(crossFieldTable.newToBaseNodeId, child2, child1);
                 crossFieldTable.pendingCompositions.nodeIdsToCompose.push([child1, child2]);
             }
             return child1 ?? child2 ?? (0, internal_1.fail)(0xb22 /* Should not compose two undefined nodes */);
         };
         const amendedChange = rebaser.compose(fieldChange1, fieldChange2, composeNodes, genId, new ComposeManager(crossFieldTable, fieldChange, fieldId, false), revisionMetadata);
-        composedChange.change = (0, index_js_2.brand)(amendedChange);
+        composedChange.change = (0, index_js_3.brand)(amendedChange);
     }
     /**
      * Updates everything in the composed output which may no longer be valid.
@@ -204,11 +214,11 @@ class ModularChangeFamily {
                 composedFields.set(fieldId.field, composedField);
                 continue;
             }
-            const nodeId = getFromChangeAtomIdMap(table.newToBaseNodeId, fieldId.nodeId) ?? fieldId.nodeId;
+            const nodeId = (0, changeAtomIdBTree_js_1.getFromChangeAtomIdMap)(table.newToBaseNodeId, fieldId.nodeId) ?? fieldId.nodeId;
             let nodeChangeset = nodeChangeFromId(composedNodes, nodeId);
             if (!table.composedNodes.has(nodeChangeset)) {
                 nodeChangeset = cloneNodeChangeset(nodeChangeset);
-                setInChangeAtomIdMap(composedNodes, nodeId, nodeChangeset);
+                (0, changeAtomIdBTree_js_1.setInChangeAtomIdMap)(composedNodes, nodeId, nodeChangeset);
             }
             if (nodeChangeset.fieldChanges === undefined) {
                 nodeChangeset.fieldChanges = new Map();
@@ -225,9 +235,9 @@ class ModularChangeFamily {
         for (const [field, fieldChange1] of change1) {
             const fieldId = { nodeId: parentId, field };
             const fieldChange2 = change2.get(field);
-            const composedField = fieldChange2 !== undefined
-                ? this.composeFieldChanges(fieldId, fieldChange1, fieldChange2, genId, crossFieldTable, revisionMetadata)
-                : fieldChange1;
+            const composedField = fieldChange2 === undefined
+                ? fieldChange1
+                : this.composeFieldChanges(fieldId, fieldChange1, fieldChange2, genId, crossFieldTable, revisionMetadata);
             composedFields.set(field, composedField);
         }
         for (const [field, fieldChange2] of change2) {
@@ -253,14 +263,14 @@ class ModularChangeFamily {
         const manager = new ComposeManager(crossFieldTable, change1, fieldId);
         const composedChange = changeHandler.rebaser.compose(change1Normalized, change2Normalized, (child1, child2) => {
             if (child1 !== undefined && child2 !== undefined) {
-                setInChangeAtomIdMap(crossFieldTable.newToBaseNodeId, child2, child1);
+                (0, changeAtomIdBTree_js_1.setInChangeAtomIdMap)(crossFieldTable.newToBaseNodeId, child2, child1);
                 crossFieldTable.pendingCompositions.nodeIdsToCompose.push([child1, child2]);
             }
             return child1 ?? child2 ?? (0, internal_1.fail)(0xb23 /* Should not compose two undefined nodes */);
         }, idAllocator, manager, revisionMetadata);
         const composedField = {
             fieldKind,
-            change: (0, index_js_2.brand)(composedChange),
+            change: (0, index_js_3.brand)(composedChange),
         };
         crossFieldTable.fieldToContext.set(change1, {
             fieldId,
@@ -275,11 +285,11 @@ class ModularChangeFamily {
         const nodeChangeset1 = nodeChangeFromId(nodeChanges1, id1);
         const nodeChangeset2 = nodeChangeFromId(nodeChanges2, id2);
         const composedNodeChangeset = this.composeNodeChanges(id1, nodeChangeset1, nodeChangeset2, idAllocator, crossFieldTable, revisionMetadata);
-        setInChangeAtomIdMap(composedNodes, id1, composedNodeChangeset);
-        if (!(0, index_js_1.areEqualChangeAtomIds)(id1, id2)) {
+        (0, changeAtomIdBTree_js_1.setInChangeAtomIdMap)(composedNodes, id1, composedNodeChangeset);
+        if (!(0, index_js_2.areEqualChangeAtomIds)(id1, id2)) {
             composedNodes.delete([id2.revision, id2.localId]);
             composedNodeToParent.delete([id2.revision, id2.localId]);
-            setInChangeAtomIdMap(nodeAliases, id2, id1);
+            (0, changeAtomIdBTree_js_1.setInChangeAtomIdMap)(nodeAliases, id2, id1);
             // We need to delete id1 to avoid forming a cycle in case id1 already had an alias.
             nodeAliases.delete([id1.revision, id1.localId]);
         }
@@ -314,8 +324,8 @@ class ModularChangeFamily {
     /**
      * @param change - The change to invert.
      * @param isRollback - Whether the inverted change is meant to rollback a change on a branch as is the case when
-     * @param revisionForInvert - The revision for the invert changeset.
      * performing a sandwich rebase.
+     * @param revisionForInvert - The revision for the invert changeset.
      */
     invert(change, isRollback, revisionForInvert) {
         // Rollback changesets destroy the nodes created by the change being rolled back.
@@ -325,6 +335,8 @@ class ModularChangeFamily {
         const revInfos = isRollback
             ? [{ revision: revisionForInvert, rollbackOf: change.revision }]
             : [{ revision: revisionForInvert }];
+        const noChangeConstraint = change.change.noChangeConstraintOnRevert;
+        const noChangeConstraintOnRevert = change.change.noChangeConstraint;
         if (hasConflicts(change.change)) {
             return makeModularChangeset({
                 maxId: change.change.maxId,
@@ -332,16 +344,16 @@ class ModularChangeFamily {
                 destroys,
             });
         }
-        const genId = (0, index_js_2.idAllocatorFromMaxId)(change.change.maxId ?? -1);
+        const genId = (0, index_js_3.idAllocatorFromMaxId)(change.change.maxId ?? -1);
         const crossFieldTable = {
             ...newCrossFieldTable(),
             originalFieldToContext: new Map(),
-            invertedNodeToParent: (0, index_js_2.brand)(change.change.nodeToParent.clone()),
+            invertedNodeToParent: (0, index_js_3.brand)(change.change.nodeToParent.clone()),
         };
         const { revInfos: oldRevInfos } = getRevInfoFromTaggedChanges([change]);
-        const revisionMetadata = (0, index_js_1.revisionMetadataSourceFromInfo)(oldRevInfos);
+        const revisionMetadata = (0, index_js_2.revisionMetadataSourceFromInfo)(oldRevInfos);
         const invertedFields = this.invertFieldMap(change.change.fieldChanges, undefined, isRollback, genId, crossFieldTable, revisionMetadata, revisionForInvert);
-        const invertedNodes = (0, index_js_2.newTupleBTree)();
+        const invertedNodes = (0, index_js_3.newTupleBTree)();
         change.change.nodeChanges.forEachPair(([revision, localId], nodeChangeset) => {
             invertedNodes.set([revision, localId], this.invertNodeChange(nodeChangeset, { revision, localId }, isRollback, genId, crossFieldTable, revisionMetadata, revisionForInvert));
         });
@@ -354,7 +366,7 @@ class ModularChangeFamily {
                 (0, internal_1.assert)(context !== undefined, 0x851 /* Should have context for every invalidated field */);
                 const { invertedField, fieldId } = context;
                 const amendedChange = getChangeHandler(this.fieldKinds, fieldChange.fieldKind).rebaser.invert(originalFieldChange, isRollback, genId, revisionForInvert, new InvertManager(crossFieldTable, fieldChange, fieldId), revisionMetadata);
-                invertedField.change = (0, index_js_2.brand)(amendedChange);
+                invertedField.change = (0, index_js_3.brand)(amendedChange);
             }
         }
         const crossFieldKeys = this.makeCrossFieldKeyTable(invertedFields, invertedNodes);
@@ -368,6 +380,8 @@ class ModularChangeFamily {
             revisions: revInfos,
             constraintViolationCount: change.change.constraintViolationCountOnRevert,
             constraintViolationCountOnRevert: change.change.constraintViolationCount,
+            noChangeConstraint,
+            noChangeConstraintOnRevert,
             destroys,
         });
     }
@@ -379,7 +393,7 @@ class ModularChangeFamily {
             const invertedChange = getChangeHandler(this.fieldKinds, fieldChange.fieldKind).rebaser.invert(fieldChange.change, isRollback, genId, revisionForInvert, manager, revisionMetadata);
             const invertedFieldChange = {
                 ...fieldChange,
-                change: (0, index_js_2.brand)(invertedChange),
+                change: (0, index_js_3.brand)(invertedChange),
             };
             invertedFields.set(field, invertedFieldChange);
             crossFieldTable.originalFieldToContext.set(fieldChange, {
@@ -412,22 +426,22 @@ class ModularChangeFamily {
         // This means that we must rebase over a muted version of the conflicted changeset.
         // That is, a version that includes its declarations (e.g., new cells) but not its changes.
         // TODO: remove once AB#46104 is completed
-        const over = (0, index_js_1.mapTaggedChange)(potentiallyConflictedOver, this.getEffectiveChange(potentiallyConflictedOver.change));
+        const over = (0, index_js_2.mapTaggedChange)(potentiallyConflictedOver, this.getEffectiveChange(potentiallyConflictedOver.change));
         const change = taggedChange.change;
         const maxId = Math.max(change.maxId ?? -1, over.change.maxId ?? -1);
         const idState = { maxId };
-        const genId = (0, index_js_2.idAllocatorFromState)(idState);
+        const genId = (0, index_js_3.idAllocatorFromState)(idState);
         const crossFieldTable = {
             ...newCrossFieldTable(),
             newChange: change,
             baseChange: over.change,
             baseFieldToContext: new Map(),
-            baseToRebasedNodeId: (0, index_js_2.newTupleBTree)(),
+            baseToRebasedNodeId: (0, index_js_3.newTupleBTree)(),
             rebasedFields: new Set(),
-            rebasedNodeToParent: (0, index_js_2.brand)(change.nodeToParent.clone()),
+            rebasedNodeToParent: (0, index_js_3.brand)(change.nodeToParent.clone()),
             rebasedCrossFieldKeys: change.crossFieldKeys.clone(),
             nodeIdPairs: [],
-            affectedBaseFields: (0, index_js_2.newTupleBTree)(),
+            affectedBaseFields: (0, index_js_3.newTupleBTree)(),
             fieldsWithUnattachedChild: new Set(),
         };
         const getBaseRevisions = () => revisionInfoFromTaggedChange(over).map((info) => info.revision);
@@ -436,11 +450,16 @@ class ModularChangeFamily {
             getRevisionToRebase: () => taggedChange.revision,
             getBaseRevisions,
         };
-        const rebasedNodes = (0, index_js_2.brand)(change.nodeChanges.clone());
+        const rebasedNodes = (0, index_js_3.brand)(change.nodeChanges.clone());
         const rebasedFields = this.rebaseIntersectingFields(crossFieldTable, rebasedNodes, genId, rebaseMetadata);
         this.rebaseInvalidatedElements(rebasedFields, rebasedNodes, crossFieldTable, rebaseMetadata, genId);
         const constraintState = newConstraintState(change.constraintViolationCount ?? 0);
         const revertConstraintState = newConstraintState(change.constraintViolationCountOnRevert ?? 0);
+        let noChangeConstraint = change.noChangeConstraint;
+        if (noChangeConstraint !== undefined && !noChangeConstraint.violated) {
+            noChangeConstraint = { violated: true };
+            constraintState.violationCount += 1;
+        }
         this.updateConstraintsForFields(rebasedFields, fieldChangeHandler_js_1.NodeAttachState.Attached, fieldChangeHandler_js_1.NodeAttachState.Attached, constraintState, revertConstraintState, rebasedNodes);
         const rebased = makeModularChangeset({
             fieldChanges: this.pruneFieldMap(rebasedFields, rebasedNodes),
@@ -452,6 +471,8 @@ class ModularChangeFamily {
             revisions: change.revisions,
             constraintViolationCount: constraintState.violationCount,
             constraintViolationCountOnRevert: revertConstraintState.violationCount,
+            noChangeConstraint,
+            noChangeConstraintOnRevert: change.noChangeConstraintOnRevert,
             builds: change.builds,
             destroys: change.destroys,
             refreshers: change.refreshers,
@@ -468,7 +489,7 @@ class ModularChangeFamily {
         // Note that the call to `rebaseNodeChange` can add entries to `crossFieldTable.nodeIdPairs`.
         for (const [newId, baseId, _attachState] of crossFieldTable.nodeIdPairs) {
             const rebasedNode = this.rebaseNodeChange(newId, baseId, genId, crossFieldTable, metadata);
-            setInChangeAtomIdMap(rebasedNodes, newId, rebasedNode);
+            (0, changeAtomIdBTree_js_1.setInChangeAtomIdMap)(rebasedNodes, newId, rebasedNode);
         }
         return rebasedFields;
     }
@@ -476,9 +497,9 @@ class ModularChangeFamily {
     rebaseFieldsWithoutNewChanges(rebasedFields, rebasedNodes, crossFieldTable, genId, metadata) {
         const baseChange = crossFieldTable.baseChange;
         for (const [revision, localId, fieldKey] of crossFieldTable.affectedBaseFields.keys()) {
-            const baseNodeId = localId !== undefined
-                ? normalizeNodeId({ revision, localId }, baseChange.nodeAliases)
-                : undefined;
+            const baseNodeId = localId === undefined
+                ? undefined
+                : normalizeNodeId({ revision, localId }, baseChange.nodeAliases);
             const baseFieldChange = fieldMapFromNodeId(baseChange.fieldChanges, baseChange.nodeChanges, baseNodeId).get(fieldKey);
             (0, internal_1.assert)(baseFieldChange !== undefined, 0x9c2 /* Cross field key registered for empty field */);
             if (crossFieldTable.baseFieldToContext.has(baseFieldChange)) {
@@ -494,16 +515,16 @@ class ModularChangeFamily {
             const handler = getChangeHandler(this.fieldKinds, baseFieldChange.fieldKind);
             const fieldChange = {
                 ...baseFieldChange,
-                change: (0, index_js_2.brand)(handler.createEmpty()),
+                change: (0, index_js_3.brand)(handler.createEmpty()),
             };
-            const rebasedNodeId = baseNodeId !== undefined
-                ? rebasedNodeIdFromBaseNodeId(crossFieldTable, baseNodeId)
-                : undefined;
+            const rebasedNodeId = baseNodeId === undefined
+                ? undefined
+                : rebasedNodeIdFromBaseNodeId(crossFieldTable, baseNodeId);
             const fieldId = { nodeId: rebasedNodeId, field: fieldKey };
             const rebasedField = handler.rebaser.rebase(fieldChange.change, baseFieldChange.change, rebaseChild, genId, new RebaseManager(crossFieldTable, baseFieldChange, fieldId), metadata);
             const rebasedFieldChange = {
                 ...baseFieldChange,
-                change: (0, index_js_2.brand)(rebasedField),
+                change: (0, index_js_3.brand)(rebasedField),
             };
             // TODO: Deduplicate
             crossFieldTable.baseFieldToContext.set(baseFieldChange, {
@@ -545,21 +566,21 @@ class ModularChangeFamily {
             }
             if (base !== undefined) {
                 for (const id of context.baseNodeIds) {
-                    if ((0, index_js_1.areEqualChangeAtomIds)(base, id)) {
+                    if ((0, index_js_2.areEqualChangeAtomIds)(base, id)) {
                         return base;
                     }
                 }
             }
             return undefined;
         };
-        context.rebasedChange.change = (0, index_js_2.brand)(changeHandler.rebaser.rebase(fieldChangeset, baseChangeset, rebaseChild, genId, new RebaseManager(crossFieldTable, baseField, context.fieldId, allowInval), rebaseMetadata));
+        context.rebasedChange.change = (0, index_js_3.brand)(changeHandler.rebaser.rebase(fieldChangeset, baseChangeset, rebaseChild, genId, new RebaseManager(crossFieldTable, baseField, context.fieldId, allowInval), rebaseMetadata));
     }
     attachRebasedField(rebasedFields, rebasedNodes, table, rebasedField, { nodeId, field: fieldKey }, idAllocator, metadata) {
         if (nodeId === undefined) {
             rebasedFields.set(fieldKey, rebasedField);
             return;
         }
-        const rebasedNode = getFromChangeAtomIdMap(rebasedNodes, nodeId);
+        const rebasedNode = (0, changeAtomIdBTree_js_1.getFromChangeAtomIdMap)(rebasedNodes, nodeId);
         if (rebasedNode !== undefined) {
             if (rebasedNode.fieldChanges === undefined) {
                 rebasedNode.fieldChanges = new Map([[fieldKey, rebasedField]]);
@@ -572,15 +593,15 @@ class ModularChangeFamily {
         const newNode = {
             fieldChanges: new Map([[fieldKey, rebasedField]]),
         };
-        setInChangeAtomIdMap(rebasedNodes, nodeId, newNode);
-        setInChangeAtomIdMap(table.baseToRebasedNodeId, nodeId, nodeId);
+        (0, changeAtomIdBTree_js_1.setInChangeAtomIdMap)(rebasedNodes, nodeId, newNode);
+        (0, changeAtomIdBTree_js_1.setInChangeAtomIdMap)(table.baseToRebasedNodeId, nodeId, nodeId);
         const parentFieldId = getParentFieldId(table.baseChange, nodeId);
         this.attachRebasedNode(rebasedFields, rebasedNodes, table, nodeId, parentFieldId, idAllocator, metadata);
     }
     attachRebasedNode(rebasedFields, rebasedNodes, table, baseNodeId, parentFieldIdBase, idAllocator, metadata) {
         const baseFieldChange = fieldChangeFromId(table.baseChange.fieldChanges, table.baseChange.nodeChanges, parentFieldIdBase);
         const rebasedFieldId = rebasedFieldIdFromBaseId(table, parentFieldIdBase);
-        setInChangeAtomIdMap(table.rebasedNodeToParent, baseNodeId, rebasedFieldId);
+        (0, changeAtomIdBTree_js_1.setInChangeAtomIdMap)(table.rebasedNodeToParent, baseNodeId, rebasedFieldId);
         const context = table.baseFieldToContext.get(baseFieldChange);
         if (context !== undefined) {
             // We've already processed this field.
@@ -592,12 +613,12 @@ class ModularChangeFamily {
         const handler = getChangeHandler(this.fieldKinds, baseFieldChange.fieldKind);
         const fieldChange = {
             ...baseFieldChange,
-            change: (0, index_js_2.brand)(handler.createEmpty()),
+            change: (0, index_js_3.brand)(handler.createEmpty()),
         };
-        const rebasedChangeset = handler.rebaser.rebase(handler.createEmpty(), baseFieldChange.change, (_idNew, idBase) => idBase !== undefined && (0, index_js_1.areEqualChangeAtomIds)(idBase, baseNodeId)
+        const rebasedChangeset = handler.rebaser.rebase(handler.createEmpty(), baseFieldChange.change, (_idNew, idBase) => idBase !== undefined && (0, index_js_2.areEqualChangeAtomIds)(idBase, baseNodeId)
             ? baseNodeId
             : undefined, idAllocator, new RebaseManager(table, baseFieldChange, rebasedFieldId), metadata);
-        const rebasedField = { ...baseFieldChange, change: (0, index_js_2.brand)(rebasedChangeset) };
+        const rebasedField = { ...baseFieldChange, change: (0, index_js_3.brand)(rebasedChangeset) };
         table.rebasedFields.add(rebasedField);
         table.baseFieldToContext.set(baseFieldChange, {
             newChange: fieldChange,
@@ -628,7 +649,7 @@ class ModularChangeFamily {
             const rebasedField = changeHandler.rebaser.rebase(fieldChangeset, baseChangeset, rebaseChild, genId, manager, revisionMetadata);
             const rebasedFieldChange = {
                 fieldKind,
-                change: (0, index_js_2.brand)(rebasedField),
+                change: (0, index_js_3.brand)(rebasedField),
             };
             rebasedFields.set(field, rebasedFieldChange);
             crossFieldTable.baseFieldToContext.set(baseChange, {
@@ -659,7 +680,7 @@ class ModularChangeFamily {
         if (change?.nodeExistsConstraintOnRevert !== undefined) {
             rebasedChange.nodeExistsConstraintOnRevert = change.nodeExistsConstraintOnRevert;
         }
-        setInChangeAtomIdMap(crossFieldTable.baseToRebasedNodeId, baseId, newId);
+        (0, changeAtomIdBTree_js_1.setInChangeAtomIdMap)(crossFieldTable.baseToRebasedNodeId, baseId, newId);
         return rebasedChange;
     }
     updateConstraintsForFields(fields, parentInputAttachState, parentOutputAttachState, constraintState, revertConstraintState, nodes) {
@@ -713,16 +734,16 @@ class ModularChangeFamily {
             const handler = getChangeHandler(this.fieldKinds, fieldChange.fieldKind);
             const prunedFieldChangeset = handler.rebaser.prune(fieldChange.change, (nodeId) => this.pruneNodeChange(nodeId, nodeMap));
             if (!handler.isEmpty(prunedFieldChangeset)) {
-                prunedChangeset.set(field, { ...fieldChange, change: (0, index_js_2.brand)(prunedFieldChangeset) });
+                prunedChangeset.set(field, { ...fieldChange, change: (0, index_js_3.brand)(prunedFieldChangeset) });
             }
         }
         return prunedChangeset.size > 0 ? prunedChangeset : undefined;
     }
     pruneNodeChange(nodeId, nodeMap) {
         const changeset = nodeChangeFromId(nodeMap, nodeId);
-        const prunedFields = changeset.fieldChanges !== undefined
-            ? this.pruneFieldMap(changeset.fieldChanges, nodeMap)
-            : undefined;
+        const prunedFields = changeset.fieldChanges === undefined
+            ? undefined
+            : this.pruneFieldMap(changeset.fieldChanges, nodeMap);
         const prunedChange = { ...changeset, fieldChanges: prunedFields };
         if (prunedChange.fieldChanges === undefined) {
             delete prunedChange.fieldChanges;
@@ -732,65 +753,54 @@ class ModularChangeFamily {
             return undefined;
         }
         else {
-            setInChangeAtomIdMap(nodeMap, nodeId, prunedChange);
+            (0, changeAtomIdBTree_js_1.setInChangeAtomIdMap)(nodeMap, nodeId, prunedChange);
             return nodeId;
         }
     }
-    changeRevision(change, newRevision, rollbackOf) {
-        const oldRevisions = new Set(change.revisions === undefined || change.revisions.length === 0
-            ? [undefined]
-            : change.revisions.map((revInfo) => revInfo.revision));
-        const updatedFields = this.replaceFieldMapRevisions(change.fieldChanges, oldRevisions, newRevision);
-        const updatedNodes = (0, index_js_2.newTupleBTree)();
-        for (const [[revision, id], nodeChangeset] of change.nodeChanges.entries()) {
-            updatedNodes.set([replaceRevision(revision, oldRevisions, newRevision), id], this.replaceNodeChangesetRevisions(nodeChangeset, oldRevisions, newRevision));
-        }
-        const updatedNodeToParent = (0, index_js_2.newTupleBTree)();
-        for (const [[revision, id], fieldId] of change.nodeToParent.entries()) {
-            updatedNodeToParent.set([replaceRevision(revision, oldRevisions, newRevision), id], replaceFieldIdRevision(normalizeFieldId(fieldId, change.nodeAliases), oldRevisions, newRevision));
+    getRevisions(change) {
+        const aggregated = new Set();
+        for (const revInfo of change.revisions ?? [{ revision: undefined }]) {
+            aggregated.add(revInfo.revision);
         }
+        return aggregated;
+    }
+    changeRevision(change, replacer) {
+        const updatedFields = this.replaceFieldMapRevisions(change.fieldChanges, replacer);
+        const updatedNodes = replaceIdMapRevisions(change.nodeChanges, replacer, (nodeChangeset) => this.replaceNodeChangesetRevisions(nodeChangeset, replacer));
+        const updatedNodeToParent = replaceIdMapRevisions(change.nodeToParent, replacer, (fieldId) => replaceFieldIdRevision(normalizeFieldId(fieldId, change.nodeAliases), replacer));
         const updated = {
             ...change,
             fieldChanges: updatedFields,
             nodeChanges: updatedNodes,
             nodeToParent: updatedNodeToParent,
             // We've updated all references to old node IDs, so we no longer need an alias table.
-            nodeAliases: (0, index_js_2.newTupleBTree)(),
-            crossFieldKeys: replaceCrossFieldKeyTableRevisions(change.crossFieldKeys, oldRevisions, newRevision, change.nodeAliases),
+            nodeAliases: (0, index_js_3.newTupleBTree)(),
+            crossFieldKeys: replaceCrossFieldKeyTableRevisions(change.crossFieldKeys, replacer, change.nodeAliases),
         };
         if (change.builds !== undefined) {
-            updated.builds = replaceIdMapRevisions(change.builds, oldRevisions, newRevision);
+            updated.builds = replaceIdMapRevisions(change.builds, replacer);
         }
         if (change.destroys !== undefined) {
-            updated.destroys = replaceIdMapRevisions(change.destroys, oldRevisions, newRevision);
+            updated.destroys = replaceIdMapRevisions(change.destroys, replacer);
         }
         if (change.refreshers !== undefined) {
-            updated.refreshers = replaceIdMapRevisions(change.refreshers, oldRevisions, newRevision);
-        }
-        if (newRevision !== undefined) {
-            const revInfo = { revision: newRevision };
-            if (rollbackOf !== undefined) {
-                revInfo.rollbackOf = rollbackOf;
-            }
-            updated.revisions = [revInfo];
-        }
-        else {
-            delete updated.revisions;
+            updated.refreshers = replaceIdMapRevisions(change.refreshers, replacer);
         }
+        updated.revisions = [{ revision: replacer.updatedRevision }];
         return updated;
     }
-    replaceNodeChangesetRevisions(nodeChangeset, oldRevisions, newRevision) {
+    replaceNodeChangesetRevisions(nodeChangeset, replacer) {
         const updated = { ...nodeChangeset };
         if (nodeChangeset.fieldChanges !== undefined) {
-            updated.fieldChanges = this.replaceFieldMapRevisions(nodeChangeset.fieldChanges, oldRevisions, newRevision);
+            updated.fieldChanges = this.replaceFieldMapRevisions(nodeChangeset.fieldChanges, replacer);
         }
         return updated;
     }
-    replaceFieldMapRevisions(fields, oldRevisions, newRevision) {
+    replaceFieldMapRevisions(fields, replacer) {
         const updatedFields = new Map();
         for (const [field, fieldChange] of fields) {
-            const updatedFieldChange = getChangeHandler(this.fieldKinds, fieldChange.fieldKind).rebaser.replaceRevisions(fieldChange.change, oldRevisions, newRevision);
-            updatedFields.set(field, { ...fieldChange, change: (0, index_js_2.brand)(updatedFieldChange) });
+            const updatedFieldChange = getChangeHandler(this.fieldKinds, fieldChange.fieldKind).rebaser.replaceRevisions(fieldChange.change, replacer);
+            updatedFields.set(field, { ...fieldChange, change: (0, index_js_3.brand)(updatedFieldChange) });
         }
         return updatedFields;
     }
@@ -815,12 +825,12 @@ class ModularChangeFamily {
             }
         }
     }
-    buildEditor(changeReceiver) {
-        return new ModularEditBuilder(this, this.fieldKinds, changeReceiver);
+    buildEditor(mintRevisionTag, changeReceiver) {
+        return new ModularEditBuilder(this, this.fieldKinds, changeReceiver, this.codecOptions);
     }
     createEmptyFieldChange(fieldKind) {
         const emptyChange = getChangeHandler(this.fieldKinds, fieldKind).createEmpty();
-        return { fieldKind, change: (0, index_js_2.brand)(emptyChange) };
+        return { fieldKind, change: (0, index_js_3.brand)(emptyChange) };
     }
     validateChangeset(change) {
         let numNodes = this.validateFieldChanges(change, change.fieldChanges, undefined);
@@ -872,7 +882,7 @@ class ModularChangeFamily {
             ...change,
             crossFieldKeys: (0, modularChangeTypes_js_1.newCrossFieldKeyTable)(),
             fieldChanges: this.muteFieldChanges(change.fieldChanges),
-            nodeChanges: (0, index_js_2.brand)(change.nodeChanges.mapValues((v) => this.muteNodeChange(v))),
+            nodeChanges: (0, index_js_3.brand)(change.nodeChanges.mapValues((v) => this.muteNodeChange(v))),
         };
         return muted;
     }
@@ -892,26 +902,22 @@ class ModularChangeFamily {
         const handler = getChangeHandler(this.fieldKinds, change.fieldKind);
         return {
             fieldKind: change.fieldKind,
-            change: (0, index_js_2.brand)(handler.rebaser.mute(change.change)),
+            change: (0, index_js_3.brand)(handler.rebaser.mute(change.change)),
         };
     }
 }
 exports.ModularChangeFamily = ModularChangeFamily;
 ModularChangeFamily.emptyChange = makeModularChangeset();
-function replaceCrossFieldKeyTableRevisions(table, oldRevisions, newRevision, nodeAliases) {
+function replaceCrossFieldKeyTableRevisions(table, replacer, nodeAliases) {
     const updated = (0, modularChangeTypes_js_1.newCrossFieldKeyTable)();
     for (const entry of table.entries()) {
         const key = entry.start;
-        const updatedKey = {
-            target: key.target,
-            revision: replaceRevision(key.revision, oldRevisions, newRevision),
-            localId: key.localId,
-        };
+        const updatedKey = replacer.getUpdatedAtomId(key);
         const field = entry.value;
         const normalizedFieldId = normalizeFieldId(field, nodeAliases);
-        const updatedNodeId = normalizedFieldId.nodeId !== undefined
-            ? (0, index_js_1.replaceAtomRevisions)(normalizedFieldId.nodeId, oldRevisions, newRevision)
-            : undefined;
+        const updatedNodeId = normalizedFieldId.nodeId === undefined
+            ? undefined
+            : replacer.getUpdatedAtomId(normalizedFieldId.nodeId);
         const updatedValue = {
             ...normalizedFieldId,
             nodeId: updatedNodeId,
@@ -920,13 +926,11 @@ function replaceCrossFieldKeyTableRevisions(table, oldRevisions, newRevision, no
     }
     return updated;
 }
-function replaceRevision(revision, oldRevisions, newRevision) {
-    return oldRevisions.has(revision) ? newRevision : revision;
-}
-function replaceIdMapRevisions(map, oldRevisions, newRevision) {
-    const updated = (0, index_js_2.newTupleBTree)();
-    for (const [[revision, id], value] of map.entries()) {
-        updated.set([replaceRevision(revision, oldRevisions, newRevision), id], value);
+function replaceIdMapRevisions(map, replacer, valueMapper = (value) => value) {
+    const updated = (0, index_js_3.newTupleBTree)();
+    for (const [[revision, localId], value] of map.entries()) {
+        const newAtom = replacer.getUpdatedAtomId({ revision, localId });
+        updated.set([newAtom.revision, newAtom.localId], valueMapper(value));
     }
     return updated;
 }
@@ -941,9 +945,9 @@ function composeBuildsDestroysAndRefreshers(change1, change2) {
     // Note that it would in principle be possible to adopt the later build and exclude from the
     // composition all the changes already reflected on the tree, but that is not something we
     // care to support at this time.
-    const allBuilds = (0, index_js_2.brand)((0, index_js_2.mergeTupleBTrees)(change1.builds ?? (0, index_js_2.newTupleBTree)(), change2.builds ?? (0, index_js_2.newTupleBTree)(), true));
-    const allDestroys = (0, index_js_2.brand)((0, index_js_2.mergeTupleBTrees)(change1.destroys ?? (0, index_js_2.newTupleBTree)(), change2.destroys ?? (0, index_js_2.newTupleBTree)()));
-    const allRefreshers = (0, index_js_2.brand)((0, index_js_2.mergeTupleBTrees)(change1.refreshers ?? (0, index_js_2.newTupleBTree)(), change2.refreshers ?? (0, index_js_2.newTupleBTree)(), true));
+    const allBuilds = (0, index_js_3.brand)((0, index_js_3.mergeTupleBTrees)(change1.builds ?? (0, index_js_3.newTupleBTree)(), change2.builds ?? (0, index_js_3.newTupleBTree)(), true));
+    const allDestroys = (0, index_js_3.brand)((0, index_js_3.mergeTupleBTrees)(change1.destroys ?? (0, index_js_3.newTupleBTree)(), change2.destroys ?? (0, index_js_3.newTupleBTree)()));
+    const allRefreshers = (0, index_js_3.brand)((0, index_js_3.mergeTupleBTrees)(change1.refreshers ?? (0, index_js_3.newTupleBTree)(), change2.refreshers ?? (0, index_js_3.newTupleBTree)(), true));
     if (change1.destroys !== undefined && change2.builds !== undefined) {
         for (const [key, chunk] of change2.builds.entries()) {
             const destroyCount = change1.destroys.get(key);
@@ -968,7 +972,7 @@ function composeBuildsDestroysAndRefreshers(change1, change2) {
 }
 function invertBuilds(builds) {
     if (builds !== undefined) {
-        return (0, index_js_2.brand)(builds.mapValues((chunk) => chunk.topLevelLength));
+        return (0, index_js_3.brand)(builds.mapValues((chunk) => chunk.topLevelLength));
     }
     return undefined;
 }
@@ -1015,11 +1019,11 @@ function* relevantRemovedRootsFromFields(change, nodeChanges, fieldKinds) {
  * corresponding build or refresher.
  */
 function updateRefreshers(change, getDetachedNode, removedRoots, requireRefreshers = true) {
-    const refreshers = (0, index_js_2.newTupleBTree)();
+    const refreshers = (0, index_js_3.newTupleBTree)();
     const chunkLengths = new Map();
     if (change.builds !== undefined) {
         for (const [[revision, id], chunk] of change.builds.entries()) {
-            const lengthTree = (0, index_js_2.getOrCreate)(chunkLengths, revision, () => new sorted_btree_es6_1.BTree());
+            const lengthTree = (0, index_js_3.getOrCreate)(chunkLengths, revision, () => new sorted_btree_es6_1.BTree());
             lengthTree.set(id, chunk.topLevelLength);
         }
     }
@@ -1043,16 +1047,16 @@ function updateRefreshers(change, getDetachedNode, removedRoots, requireRefreshe
             (0, internal_1.assert)(!requireRefreshers, 0x8cd /* detached node should exist */);
         }
         else {
-            refreshers.set([root.major, (0, index_js_2.brand)(root.minor)], node);
+            refreshers.set([root.major, (0, index_js_3.brand)(root.minor)], node);
         }
     }
-    const { fieldChanges, nodeChanges, maxId, revisions, constraintViolationCount, constraintViolationCountOnRevert, builds, destroys, } = change;
+    const { fieldChanges, nodeChanges, nodeToParent, nodeAliases, crossFieldKeys, maxId, revisions, constraintViolationCount, constraintViolationCountOnRevert, builds, destroys, } = change;
     return makeModularChangeset({
         fieldChanges,
         nodeChanges,
-        nodeToParent: change.nodeToParent,
-        nodeAliases: change.nodeAliases,
-        crossFieldKeys: change.crossFieldKeys,
+        nodeToParent,
+        nodeAliases,
+        crossFieldKeys,
         maxId: maxId,
         revisions,
         constraintViolationCount,
@@ -1095,7 +1099,7 @@ function intoDelta(taggedChange, fieldKinds) {
         const destroys = [];
         for (const [[major, minor], count] of change.destroys.entries()) {
             destroys.push({
-                id: (0, index_js_1.makeDetachedNodeId)(major, minor),
+                id: (0, index_js_2.makeDetachedNodeId)(major, minor),
                 count,
             });
         }
@@ -1113,7 +1117,7 @@ function copyDetachedNodes(detachedNodes) {
         if (chunk.topLevelLength > 0) {
             chunk.referenceAdded();
             copiedDetachedNodes.push({
-                id: (0, index_js_1.makeDetachedNodeId)(major, minor),
+                id: (0, index_js_2.makeDetachedNodeId)(major, minor),
                 trees: chunk,
             });
         }
@@ -1166,7 +1170,7 @@ function rebaseRevisionMetadataFromInfo(revInfos, revisionToRebase, baseRevision
     }
     const getBaseRevisions = () => filteredRevisions;
     return {
-        ...(0, index_js_1.revisionMetadataSourceFromInfo)(revInfos),
+        ...(0, index_js_2.revisionMetadataSourceFromInfo)(revInfos),
         getRevisionToRebase: () => revisionToRebase,
         getBaseRevisions,
     };
@@ -1197,22 +1201,22 @@ function newComposeTable(baseChange, newChange, composedNodeToParent) {
         newChange,
         fieldToContext: new Map(),
         newFieldToBaseField: new Map(),
-        newToBaseNodeId: (0, index_js_2.newTupleBTree)(),
+        newToBaseNodeId: (0, index_js_3.newTupleBTree)(),
         composedNodes: new Set(),
         composedNodeToParent,
         pendingCompositions: {
             nodeIdsToCompose: [],
-            affectedBaseFields: (0, index_js_2.newTupleBTree)(),
-            affectedNewFields: (0, index_js_2.newTupleBTree)(),
+            affectedBaseFields: (0, index_js_3.newTupleBTree)(),
+            affectedNewFields: (0, index_js_3.newTupleBTree)(),
         },
     };
 }
 function newCrossFieldTable() {
     return {
-        srcTable: (0, index_js_1.newChangeAtomIdRangeMap)(),
-        dstTable: (0, index_js_1.newChangeAtomIdRangeMap)(),
-        srcDependents: (0, index_js_1.newChangeAtomIdRangeMap)(),
-        dstDependents: (0, index_js_1.newChangeAtomIdRangeMap)(),
+        srcTable: (0, index_js_2.newChangeAtomIdRangeMap)(),
+        dstTable: (0, index_js_2.newChangeAtomIdRangeMap)(),
+        srcDependents: (0, index_js_2.newChangeAtomIdRangeMap)(),
+        dstDependents: (0, index_js_2.newChangeAtomIdRangeMap)(),
         invalidatedFields: new Set(),
     };
 }
@@ -1236,7 +1240,7 @@ class CrossFieldManagerI {
                 if (dependentEntry.value !== undefined) {
                     this.crossFieldTable.invalidatedFields.add(dependentEntry.value);
                 }
-                firstId = (0, index_js_2.brand)(firstId + dependentEntry.length);
+                firstId = (0, index_js_3.brand)(firstId + dependentEntry.length);
             }
         }
         (0, crossFieldQueries_js_1.setInCrossFieldMap)(this.getMap(target), revision, id, count, newValue);
@@ -1267,7 +1271,7 @@ class InvertManager extends CrossFieldManagerI {
         this.fieldId = fieldId;
     }
     onMoveIn(id) {
-        setInChangeAtomIdMap(this.table.invertedNodeToParent, id, this.fieldId);
+        (0, changeAtomIdBTree_js_1.setInChangeAtomIdMap)(this.table.invertedNodeToParent, id, this.fieldId);
     }
     moveKey(target, revision, id, count) {
         (0, internal_1.assert)(false, 0x9c5 /* Keys should not be moved manually during invert */);
@@ -1302,7 +1306,7 @@ class RebaseManager extends CrossFieldManagerI {
         super.set(target, revision, id, count, newValue, invalidateDependents);
     }
     onMoveIn(id) {
-        setInChangeAtomIdMap(this.table.rebasedNodeToParent, id, this.fieldId);
+        (0, changeAtomIdBTree_js_1.setInChangeAtomIdMap)(this.table.rebasedNodeToParent, id, this.fieldId);
     }
     moveKey(target, revision, id, count) {
         this.table.rebasedCrossFieldKeys.set({ target, revision, localId: id }, count, this.fieldId);
@@ -1344,7 +1348,7 @@ class ComposeManager extends CrossFieldManagerI {
         super.set(target, revision, id, count, newValue, invalidateDependents);
     }
     onMoveIn(id) {
-        setInChangeAtomIdMap(this.table.composedNodeToParent, id, this.fieldId);
+        (0, changeAtomIdBTree_js_1.setInChangeAtomIdMap)(this.table.composedNodeToParent, id, this.fieldId);
     }
     moveKey(target, revision, id, count) {
         throw new Error("Moving cross-field keys during compose is currently unsupported");
@@ -1358,16 +1362,16 @@ function makeModularChangeset(props = {
 }) {
     const changeset = {
         fieldChanges: props.fieldChanges ?? new Map(),
-        nodeChanges: props.nodeChanges ?? (0, index_js_2.newTupleBTree)(),
-        nodeToParent: props.nodeToParent ?? (0, index_js_2.newTupleBTree)(),
-        nodeAliases: props.nodeAliases ?? (0, index_js_2.newTupleBTree)(),
+        nodeChanges: props.nodeChanges ?? (0, index_js_3.newTupleBTree)(),
+        nodeToParent: props.nodeToParent ?? (0, index_js_3.newTupleBTree)(),
+        nodeAliases: props.nodeAliases ?? (0, index_js_3.newTupleBTree)(),
         crossFieldKeys: props.crossFieldKeys ?? (0, modularChangeTypes_js_1.newCrossFieldKeyTable)(),
     };
     if (props.revisions !== undefined && props.revisions.length > 0) {
         changeset.revisions = props.revisions;
     }
     if (props.maxId >= 0) {
-        changeset.maxId = (0, index_js_2.brand)(props.maxId);
+        changeset.maxId = (0, index_js_3.brand)(props.maxId);
     }
     if (props.constraintViolationCount !== undefined && props.constraintViolationCount > 0) {
         changeset.constraintViolationCount = props.constraintViolationCount;
@@ -1376,6 +1380,12 @@ function makeModularChangeset(props = {
         props.constraintViolationCountOnRevert > 0) {
         changeset.constraintViolationCountOnRevert = props.constraintViolationCountOnRevert;
     }
+    if (props.noChangeConstraint !== undefined) {
+        changeset.noChangeConstraint = props.noChangeConstraint;
+    }
+    if (props.noChangeConstraintOnRevert !== undefined) {
+        changeset.noChangeConstraintOnRevert = props.noChangeConstraintOnRevert;
+    }
     if (props.builds !== undefined && props.builds.size > 0) {
         changeset.builds = props.builds;
     }
@@ -1387,24 +1397,25 @@ function makeModularChangeset(props = {
     }
     return changeset;
 }
-class ModularEditBuilder extends index_js_1.EditBuilder {
-    constructor(family, fieldKinds, changeReceiver) {
+class ModularEditBuilder extends index_js_2.EditBuilder {
+    constructor(family, fieldKinds, changeReceiver, codecOptions) {
         super(family, changeReceiver);
         this.fieldKinds = fieldKinds;
         this.transactionDepth = 0;
-        this.idAllocator = (0, index_js_2.idAllocatorFromMaxId)();
+        this.idAllocator = (0, index_js_3.idAllocatorFromMaxId)();
+        this.codecOptions = codecOptions;
     }
     enterTransaction() {
         this.transactionDepth += 1;
         if (this.transactionDepth === 1) {
-            this.idAllocator = (0, index_js_2.idAllocatorFromMaxId)();
+            this.idAllocator = (0, index_js_3.idAllocatorFromMaxId)();
         }
     }
     exitTransaction() {
         (0, internal_1.assert)(this.transactionDepth > 0, 0x5b9 /* Cannot exit inexistent transaction */);
         this.transactionDepth -= 1;
         if (this.transactionDepth === 0) {
-            this.idAllocator = (0, index_js_2.idAllocatorFromMaxId)();
+            this.idAllocator = (0, index_js_3.idAllocatorFromMaxId)();
         }
     }
     /**
@@ -1422,7 +1433,7 @@ class ModularEditBuilder extends index_js_1.EditBuilder {
         }
         // This content will be added to a GlobalEditDescription whose lifetime exceeds the scope of this function.
         content.referenceAdded();
-        const builds = (0, index_js_2.newTupleBTree)();
+        const builds = (0, index_js_3.newTupleBTree)();
         builds.set([revision, firstId], content);
         return {
             type: "global",
@@ -1442,24 +1453,24 @@ class ModularEditBuilder extends index_js_1.EditBuilder {
         const modularChange = buildModularChangesetFromField({
             path: field,
             fieldChange: { fieldKind, change },
-            nodeChanges: (0, index_js_2.newTupleBTree)(),
-            nodeToParent: (0, index_js_2.newTupleBTree)(),
+            nodeChanges: (0, index_js_3.newTupleBTree)(),
+            nodeToParent: (0, index_js_3.newTupleBTree)(),
             crossFieldKeys: (0, modularChangeTypes_js_1.newCrossFieldKeyTable)(),
             idAllocator: this.idAllocator,
             localCrossFieldKeys,
             revision,
         });
-        this.applyChange((0, index_js_1.tagChange)(modularChange, revision));
+        this.applyChange((0, index_js_2.tagChange)(modularChange, revision));
     }
     submitChanges(changes, revision) {
         const modularChange = this.buildChanges(changes);
-        this.applyChange((0, index_js_1.tagChange)(modularChange, revision));
+        this.applyChange((0, index_js_2.tagChange)(modularChange, revision));
     }
     buildChanges(changes) {
         const revisions = new Set();
         const changeMaps = changes.map((change) => {
             revisions.add(change.revision);
-            return (0, index_js_1.makeAnonChange)(change.type === "global"
+            return (0, index_js_2.makeAnonChange)(change.type === "global"
                 ? makeModularChangeset({
                     maxId: this.idAllocator.getMaxId(),
                     builds: change.builds,
@@ -1471,37 +1482,37 @@ class ModularEditBuilder extends index_js_1.EditBuilder {
                         fieldKind: change.fieldKind,
                         change: change.change,
                     },
-                    nodeChanges: (0, index_js_2.newTupleBTree)(),
-                    nodeToParent: (0, index_js_2.newTupleBTree)(),
+                    nodeChanges: (0, index_js_3.newTupleBTree)(),
+                    nodeToParent: (0, index_js_3.newTupleBTree)(),
                     crossFieldKeys: (0, modularChangeTypes_js_1.newCrossFieldKeyTable)(),
                     idAllocator: this.idAllocator,
                     localCrossFieldKeys: getChangeHandler(this.fieldKinds, change.fieldKind).getCrossFieldKeys(change.change),
                     revision: change.revision,
                 }));
         });
-        const revInfo = Array.from(revisions).map((revision) => ({ revision }));
+        const revInfo = [...revisions].map((revision) => ({ revision }));
         const composedChange = {
             ...this.changeFamily.rebaser.compose(changeMaps),
             revisions: revInfo,
         };
-        const maxId = (0, index_js_2.brand)(this.idAllocator.getMaxId());
+        const maxId = (0, index_js_3.brand)(this.idAllocator.getMaxId());
         if (maxId >= 0) {
             composedChange.maxId = maxId;
         }
         return composedChange;
     }
     generateId(count) {
-        return (0, index_js_2.brand)(this.idAllocator.allocate(count));
+        return (0, index_js_3.brand)(this.idAllocator.allocate(count));
     }
     addNodeExistsConstraint(path, revision) {
         const nodeChange = {
             nodeExistsConstraint: { violated: false },
         };
-        this.applyChange((0, index_js_1.tagChange)(buildModularChangesetFromNode({
+        this.applyChange((0, index_js_2.tagChange)(buildModularChangesetFromNode({
             path,
             nodeChange,
-            nodeChanges: (0, index_js_2.newTupleBTree)(),
-            nodeToParent: (0, index_js_2.newTupleBTree)(),
+            nodeChanges: (0, index_js_3.newTupleBTree)(),
+            nodeToParent: (0, index_js_3.newTupleBTree)(),
             crossFieldKeys: (0, modularChangeTypes_js_1.newCrossFieldKeyTable)(),
             idAllocator: this.idAllocator,
             revision,
@@ -1511,27 +1522,47 @@ class ModularEditBuilder extends index_js_1.EditBuilder {
         const nodeChange = {
             nodeExistsConstraintOnRevert: { violated: false },
         };
-        this.applyChange((0, index_js_1.tagChange)(buildModularChangesetFromNode({
+        this.applyChange((0, index_js_2.tagChange)(buildModularChangesetFromNode({
             path,
             nodeChange,
-            nodeChanges: (0, index_js_2.newTupleBTree)(),
-            nodeToParent: (0, index_js_2.newTupleBTree)(),
+            nodeChanges: (0, index_js_3.newTupleBTree)(),
+            nodeToParent: (0, index_js_3.newTupleBTree)(),
             crossFieldKeys: (0, modularChangeTypes_js_1.newCrossFieldKeyTable)(),
             idAllocator: this.idAllocator,
             revision,
         }), revision));
     }
+    addNoChangeConstraint(revision) {
+        if ((0, semver_ts_1.lt)(this.codecOptions.minVersionForCollab, index_js_1.FluidClientVersion.v2_80)) {
+            throw new internal_2.UsageError(`No change constraints require min client version of at least ${index_js_1.FluidClientVersion.v2_80}`);
+        }
+        const changeset = makeModularChangeset({
+            maxId: -1,
+            noChangeConstraint: { violated: false },
+        });
+        this.applyChange((0, index_js_2.tagChange)(changeset, revision));
+    }
+    addNoChangeConstraintOnRevert(revision) {
+        if ((0, semver_ts_1.lt)(this.codecOptions.minVersionForCollab, index_js_1.FluidClientVersion.v2_80)) {
+            throw new internal_2.UsageError(`No change constraints require min client version of at least ${index_js_1.FluidClientVersion.v2_80}`);
+        }
+        const changeset = makeModularChangeset({
+            maxId: -1,
+            noChangeConstraintOnRevert: { violated: false },
+        });
+        this.applyChange((0, index_js_2.tagChange)(changeset, revision));
+    }
 }
 exports.ModularEditBuilder = ModularEditBuilder;
 function buildModularChangesetFromField(props) {
-    const { path, fieldChange, nodeChanges, nodeToParent, crossFieldKeys, idAllocator = (0, index_js_2.idAllocatorFromMaxId)(), localCrossFieldKeys = [], childId, revision, } = props;
+    const { path, fieldChange, nodeChanges, nodeToParent, crossFieldKeys, idAllocator = (0, index_js_3.idAllocatorFromMaxId)(), localCrossFieldKeys = [], childId, revision, } = props;
     const fieldChanges = new Map([[path.field, fieldChange]]);
     if (path.parent === undefined) {
         for (const { key, count } of localCrossFieldKeys) {
             crossFieldKeys.set(key, count, { nodeId: undefined, field: path.field });
         }
         if (childId !== undefined) {
-            setInChangeAtomIdMap(nodeToParent, childId, {
+            (0, changeAtomIdBTree_js_1.setInChangeAtomIdMap)(nodeToParent, childId, {
                 nodeId: undefined,
                 field: path.field,
             });
@@ -1548,12 +1579,12 @@ function buildModularChangesetFromField(props) {
     const nodeChangeset = {
         fieldChanges,
     };
-    const parentId = { localId: (0, index_js_2.brand)(idAllocator.allocate()), revision };
+    const parentId = { localId: (0, index_js_3.brand)(idAllocator.allocate()), revision };
     for (const { key, count } of localCrossFieldKeys) {
         crossFieldKeys.set(key, count, { nodeId: parentId, field: path.field });
     }
     if (childId !== undefined) {
-        setInChangeAtomIdMap(nodeToParent, childId, {
+        (0, changeAtomIdBTree_js_1.setInChangeAtomIdMap)(nodeToParent, childId, {
             nodeId: parentId,
             field: path.field,
         });
@@ -1570,8 +1601,8 @@ function buildModularChangesetFromField(props) {
     });
 }
 function buildModularChangesetFromNode(props) {
-    const { path, nodeId = { localId: (0, index_js_2.brand)(props.idAllocator.allocate()), revision: props.revision }, } = props;
-    setInChangeAtomIdMap(props.nodeChanges, nodeId, props.nodeChange);
+    const { path, idAllocator, revision, nodeChanges, nodeChange, nodeId = { localId: (0, index_js_3.brand)(idAllocator.allocate()), revision }, } = props;
+    (0, changeAtomIdBTree_js_1.setInChangeAtomIdMap)(nodeChanges, nodeId, nodeChange);
     const fieldChangeset = genericFieldKind_js_1.genericFieldKind.changeHandler.editor.buildChildChanges([
         [path.parentIndex, nodeId],
     ]);
@@ -1590,15 +1621,20 @@ function buildModularChangesetFromNode(props) {
 function getRevInfoFromTaggedChanges(changes) {
     let maxId = -1;
     const revInfos = [];
+    const revisions = new Set();
     for (const taggedChange of changes) {
         const change = taggedChange.change;
         maxId = Math.max(change.maxId ?? -1, maxId);
-        revInfos.push(...revisionInfoFromTaggedChange(taggedChange));
+        const infosToAdd = revisionInfoFromTaggedChange(taggedChange);
+        for (const info of infosToAdd) {
+            if (!revisions.has(info.revision)) {
+                revisions.add(info.revision);
+                revInfos.push(info);
+            }
+        }
     }
-    const revisions = new Set();
     const rolledBackRevisions = [];
     for (const info of revInfos) {
-        revisions.add(info.revision);
         if (info.rollbackOf !== undefined) {
             rolledBackRevisions.push(info.rollbackOf);
         }
@@ -1609,7 +1645,7 @@ function getRevInfoFromTaggedChanges(changes) {
             revInfos.push({ revision });
         }
     }
-    return { maxId: (0, index_js_2.brand)(maxId), revInfos };
+    return { maxId: (0, index_js_3.brand)(maxId), revInfos };
 }
 function revisionInfoFromTaggedChange(taggedChange) {
     const revInfos = [];
@@ -1644,15 +1680,15 @@ function rebasedFieldIdFromBaseId(table, baseId) {
     return { ...baseId, nodeId: rebasedNodeIdFromBaseNodeId(table, baseId.nodeId) };
 }
 function rebasedNodeIdFromBaseNodeId(table, baseId) {
-    return getFromChangeAtomIdMap(table.baseToRebasedNodeId, baseId) ?? baseId;
+    return (0, changeAtomIdBTree_js_1.getFromChangeAtomIdMap)(table.baseToRebasedNodeId, baseId) ?? baseId;
 }
 function nodeChangeFromId(nodes, id) {
-    const node = getFromChangeAtomIdMap(nodes, id);
+    const node = (0, changeAtomIdBTree_js_1.getFromChangeAtomIdMap)(nodes, id);
     (0, internal_1.assert)(node !== undefined, 0x9ca /* Unknown node ID */);
     return node;
 }
 function fieldIdFromFieldIdKey([revision, localId, field]) {
-    const nodeId = localId !== undefined ? { revision, localId } : undefined;
+    const nodeId = localId === undefined ? undefined : { revision, localId };
     return { nodeId, field };
 }
 function cloneNodeChangeset(nodeChangeset) {
@@ -1661,17 +1697,17 @@ function cloneNodeChangeset(nodeChangeset) {
     }
     return { ...nodeChangeset };
 }
-function replaceFieldIdRevision(fieldId, oldRevisions, newRevision) {
+function replaceFieldIdRevision(fieldId, replacer) {
     if (fieldId.nodeId === undefined) {
         return fieldId;
     }
     return {
         ...fieldId,
-        nodeId: (0, index_js_1.replaceAtomRevisions)(fieldId.nodeId, oldRevisions, newRevision),
+        nodeId: replacer.getUpdatedAtomId(fieldId.nodeId),
     };
 }
 function getParentFieldId(changeset, nodeId) {
-    const parentId = getFromChangeAtomIdMap(changeset.nodeToParent, nodeId);
+    const parentId = (0, changeAtomIdBTree_js_1.getFromChangeAtomIdMap)(changeset.nodeToParent, nodeId);
     (0, internal_1.assert)(parentId !== undefined, 0x9cb /* Parent field should be defined */);
     return normalizeFieldId(parentId, changeset.nodeAliases);
 }
@@ -1683,9 +1719,9 @@ function getFieldsForCrossFieldKey(changeset, key, count) {
 }
 // This is only exported for use in test utilities.
 function normalizeFieldId(fieldId, nodeAliases) {
-    return fieldId.nodeId !== undefined
-        ? { ...fieldId, nodeId: normalizeNodeId(fieldId.nodeId, nodeAliases) }
-        : fieldId;
+    return fieldId.nodeId === undefined
+        ? fieldId
+        : { ...fieldId, nodeId: normalizeNodeId(fieldId.nodeId, nodeAliases) };
 }
 exports.normalizeFieldId = normalizeFieldId;
 /**
@@ -1695,7 +1731,7 @@ function normalizeNodeId(nodeId, nodeAliases) {
     let currentId = nodeId;
     // eslint-disable-next-line no-constant-condition
     while (true) {
-        const dealiased = getFromChangeAtomIdMap(nodeAliases, currentId);
+        const dealiased = (0, changeAtomIdBTree_js_1.getFromChangeAtomIdMap)(nodeAliases, currentId);
         if (dealiased === undefined) {
             return currentId;
         }
@@ -1705,13 +1741,7 @@ function normalizeNodeId(nodeId, nodeAliases) {
 function hasConflicts(change) {
     return (change.constraintViolationCount ?? 0) > 0;
 }
-function getFromChangeAtomIdMap(map, id) {
-    return map.get([id.revision, id.localId]);
-}
-function setInChangeAtomIdMap(map, id, value) {
-    map.set([id.revision, id.localId], value);
-}
 function areEqualFieldIds(a, b) {
-    return (0, index_js_1.areEqualChangeAtomIdOpts)(a.nodeId, b.nodeId) && a.field === b.field;
+    return (0, index_js_2.areEqualChangeAtomIdOpts)(a.nodeId, b.nodeId) && a.field === b.field;
 }
 //# sourceMappingURL=modularChangeFamily.js.map