@fluidframework/tree 2.74.0 → 2.80.0

package/src/feature-libraries/modular-schema/modularChangeFamily.ts

@@ -5,8 +5,13 @@
 
 import { assert, fail } from "@fluidframework/core-utils/internal";
 import { BTree } from "@tylerbu/sorted-btree-es6";
+import { UsageError } from "@fluidframework/telemetry-utils/internal";
 
-import type { ICodecFamily } from "../../codec/index.js";
+import {
+	FluidClientVersion,
+	type CodecWriteOptions,
+	type ICodecFamily,
+} from "../../codec/index.js";
 import {
 	type ChangeEncodingContext,
 	type ChangeFamily,
@@ -29,7 +34,6 @@ import {
 	type TaggedChange,
 	type UpPath,
 	makeDetachedNodeId,
-	replaceAtomRevisions,
 	revisionMetadataSourceFromInfo,
 	areEqualChangeAtomIds,
 	type ChangeAtomId,
@@ -40,6 +44,7 @@ import {
 	type DeltaDetachedNodeChanges,
 	type DeltaDetachedNodeRename,
 	mapTaggedChange,
+	type RevisionReplacer,
 } from "../../core/index.js";
 import {
 	type IdAllocationState,
@@ -73,7 +78,6 @@ import {
 import { convertGenericChange, genericFieldKind } from "./genericFieldKind.js";
 import type { GenericChangeset } from "./genericFieldKindTypes.js";
 import {
-	type ChangeAtomIdBTree,
 	type CrossFieldKey,
 	type CrossFieldKeyRange,
 	type CrossFieldKeyTable,
@@ -83,10 +87,17 @@ import {
 	type FieldId,
 	type ModularChangeset,
 	newCrossFieldKeyTable,
+	type NoChangeConstraint,
 	type NodeChangeset,
 	type NodeId,
 } from "./modularChangeTypes.js";
 import type { FlexFieldKind } from "./fieldKind.js";
+import {
+	getFromChangeAtomIdMap,
+	setInChangeAtomIdMap,
+	type ChangeAtomIdBTree,
+} from "../changeAtomIdBTree.js";
+import { lt } from "semver-ts";
 
 /**
  * Implementation of ChangeFamily which delegates work in a given field to the appropriate FieldKind
@@ -104,6 +115,7 @@ export class ModularChangeFamily
 	public constructor(
 		fieldKinds: ReadonlyMap<FieldKindIdentifier, FlexFieldKind>,
 		public readonly codecs: ICodecFamily<ModularChangeset, ChangeEncodingContext>,
+		public readonly codecOptions: CodecWriteOptions,
 	) {
 		this.fieldKinds = fieldKinds;
 	}
@@ -130,9 +142,9 @@ export class ModularChangeFamily
 	} {
 		// TODO: Handle the case where changes have conflicting field kinds
 		const kind =
-			change1.fieldKind !== genericFieldKind.identifier
-				? change1.fieldKind
-				: change2.fieldKind;
+			change1.fieldKind === genericFieldKind.identifier
+				? change2.fieldKind
+				: change1.fieldKind;
 
 		if (kind === genericFieldKind.identifier) {
 			// Both changes are generic
@@ -199,6 +211,11 @@ export class ModularChangeFamily
 			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,
@@ -207,6 +224,8 @@ export class ModularChangeFamily
 			crossFieldKeys,
 			maxId: idState.maxId,
 			revisions: revInfos,
+			noChangeConstraint,
+			noChangeConstraintOnRevert,
 			builds: allBuilds,
 			destroys: allDestroys,
 			refreshers: allRefreshers,
@@ -489,16 +508,16 @@ export class ModularChangeFamily
 			const fieldId: FieldId = { nodeId: parentId, field };
 			const fieldChange2 = change2.get(field);
 			const composedField =
-				fieldChange2 !== undefined
-					? this.composeFieldChanges(
+				fieldChange2 === undefined
+					? fieldChange1
+					: this.composeFieldChanges(
 							fieldId,
 							fieldChange1,
 							fieldChange2,
 							genId,
 							crossFieldTable,
 							revisionMetadata,
-						)
-					: fieldChange1;
+						);
 
 			composedFields.set(field, composedField);
 		}
@@ -660,8 +679,8 @@ export 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.
 	 */
 	public invert(
 		change: TaggedChange<ModularChangeset>,
@@ -681,6 +700,9 @@ export class ModularChangeFamily
 			? [{ 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 as number,
@@ -764,6 +786,8 @@ export class ModularChangeFamily
 			revisions: revInfos,
 			constraintViolationCount: change.change.constraintViolationCountOnRevert,
 			constraintViolationCountOnRevert: change.change.constraintViolationCount,
+			noChangeConstraint,
+			noChangeConstraintOnRevert,
 			destroys,
 		});
 	}
@@ -911,6 +935,13 @@ export class ModularChangeFamily
 		const revertConstraintState = newConstraintState(
 			change.constraintViolationCountOnRevert ?? 0,
 		);
+
+		let noChangeConstraint = change.noChangeConstraint;
+		if (noChangeConstraint !== undefined && !noChangeConstraint.violated) {
+			noChangeConstraint = { violated: true };
+			constraintState.violationCount += 1;
+		}
+
 		this.updateConstraintsForFields(
 			rebasedFields,
 			NodeAttachState.Attached,
@@ -930,6 +961,8 @@ export class ModularChangeFamily
 			revisions: change.revisions,
 			constraintViolationCount: constraintState.violationCount,
 			constraintViolationCountOnRevert: revertConstraintState.violationCount,
+			noChangeConstraint,
+			noChangeConstraintOnRevert: change.noChangeConstraintOnRevert,
 			builds: change.builds,
 			destroys: change.destroys,
 			refreshers: change.refreshers,
@@ -985,9 +1018,9 @@ export class ModularChangeFamily
 		const baseChange = crossFieldTable.baseChange;
 		for (const [revision, localId, fieldKey] of crossFieldTable.affectedBaseFields.keys()) {
 			const baseNodeId =
-				localId !== undefined
-					? normalizeNodeId({ revision, localId }, baseChange.nodeAliases)
-					: undefined;
+				localId === undefined
+					? undefined
+					: normalizeNodeId({ revision, localId }, baseChange.nodeAliases);
 
 			const baseFieldChange = fieldMapFromNodeId(
 				baseChange.fieldChanges,
@@ -1022,9 +1055,9 @@ export class ModularChangeFamily
 			};
 
 			const rebasedNodeId =
-				baseNodeId !== undefined
-					? rebasedNodeIdFromBaseNodeId(crossFieldTable, baseNodeId)
-					: undefined;
+				baseNodeId === undefined
+					? undefined
+					: rebasedNodeIdFromBaseNodeId(crossFieldTable, baseNodeId);
 
 			const fieldId: FieldId = { nodeId: rebasedNodeId, field: fieldKey };
 			const rebasedField: unknown = handler.rebaser.rebase(
@@ -1478,9 +1511,9 @@ export class ModularChangeFamily
 	): NodeId | undefined {
 		const changeset = nodeChangeFromId(nodeMap, nodeId);
 		const prunedFields =
-			changeset.fieldChanges !== undefined
-				? this.pruneFieldMap(changeset.fieldChanges, nodeMap)
-				: undefined;
+			changeset.fieldChanges === undefined
+				? undefined
+				: this.pruneFieldMap(changeset.fieldChanges, nodeMap);
 
 		const prunedChange = { ...changeset, fieldChanges: prunedFields };
 		if (prunedChange.fieldChanges === undefined) {
@@ -1496,42 +1529,29 @@ export class ModularChangeFamily
 		}
 	}
 
+	public getRevisions(change: ModularChangeset): Set<RevisionTag | undefined> {
+		const aggregated: Set<RevisionTag | undefined> = new Set();
+		for (const revInfo of change.revisions ?? [{ revision: undefined }]) {
+			aggregated.add(revInfo.revision);
+		}
+		return aggregated;
+	}
+
 	public changeRevision(
 		change: ModularChangeset,
-		newRevision: RevisionTag | undefined,
-		rollbackOf?: RevisionTag,
+		replacer: RevisionReplacer,
 	): ModularChangeset {
-		const oldRevisions = new Set(
-			change.revisions === undefined || change.revisions.length === 0
-				? [undefined]
-				: change.revisions.map((revInfo) => revInfo.revision),
+		const updatedFields = this.replaceFieldMapRevisions(change.fieldChanges, replacer);
+		const updatedNodes = replaceIdMapRevisions(change.nodeChanges, replacer, (nodeChangeset) =>
+			this.replaceNodeChangesetRevisions(nodeChangeset, replacer),
 		);
-		const updatedFields = this.replaceFieldMapRevisions(
-			change.fieldChanges,
-			oldRevisions,
-			newRevision,
+		const updatedNodeToParent = replaceIdMapRevisions(
+			change.nodeToParent,
+			replacer,
+			(fieldId) =>
+				replaceFieldIdRevision(normalizeFieldId(fieldId, change.nodeAliases), replacer),
 		);
 
-		const updatedNodes: ChangeAtomIdBTree<NodeChangeset> = newTupleBTree();
-		for (const [[revision, id], nodeChangeset] of change.nodeChanges.entries()) {
-			updatedNodes.set(
-				[replaceRevision(revision, oldRevisions, newRevision), id],
-				this.replaceNodeChangesetRevisions(nodeChangeset, oldRevisions, newRevision),
-			);
-		}
-
-		const updatedNodeToParent: ChangeAtomIdBTree<FieldId> = newTupleBTree();
-		for (const [[revision, id], fieldId] of change.nodeToParent.entries()) {
-			updatedNodeToParent.set(
-				[replaceRevision(revision, oldRevisions, newRevision), id],
-				replaceFieldIdRevision(
-					normalizeFieldId(fieldId, change.nodeAliases),
-					oldRevisions,
-					newRevision,
-				),
-			);
-		}
-
 		const updated: Mutable<ModularChangeset> = {
 			...change,
 			fieldChanges: updatedFields,
@@ -1542,49 +1562,37 @@ export class ModularChangeFamily
 			nodeAliases: newTupleBTree(),
 			crossFieldKeys: replaceCrossFieldKeyTableRevisions(
 				change.crossFieldKeys,
-				oldRevisions,
-				newRevision,
+				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);
+			updated.refreshers = replaceIdMapRevisions(change.refreshers, replacer);
 		}
 
-		if (newRevision !== undefined) {
-			const revInfo: Mutable<RevisionInfo> = { revision: newRevision };
-			if (rollbackOf !== undefined) {
-				revInfo.rollbackOf = rollbackOf;
-			}
-
-			updated.revisions = [revInfo];
-		} else {
-			delete updated.revisions;
-		}
+		updated.revisions = [{ revision: replacer.updatedRevision }];
 
 		return updated;
 	}
 
 	private replaceNodeChangesetRevisions(
 		nodeChangeset: NodeChangeset,
-		oldRevisions: Set<RevisionTag | undefined>,
-		newRevision: RevisionTag | undefined,
+		replacer: RevisionReplacer,
 	): NodeChangeset {
 		const updated = { ...nodeChangeset };
 		if (nodeChangeset.fieldChanges !== undefined) {
 			updated.fieldChanges = this.replaceFieldMapRevisions(
 				nodeChangeset.fieldChanges,
-				oldRevisions,
-				newRevision,
+				replacer,
 			);
 		}
 
@@ -1593,15 +1601,14 @@ export class ModularChangeFamily
 
 	private replaceFieldMapRevisions(
 		fields: FieldChangeMap,
-		oldRevisions: Set<RevisionTag | undefined>,
-		newRevision: RevisionTag | undefined,
+		replacer: RevisionReplacer,
 	): FieldChangeMap {
 		const updatedFields: FieldChangeMap = new Map();
 		for (const [field, fieldChange] of fields) {
 			const updatedFieldChange = getChangeHandler(
 				this.fieldKinds,
 				fieldChange.fieldKind,
-			).rebaser.replaceRevisions(fieldChange.change, oldRevisions, newRevision);
+			).rebaser.replaceRevisions(fieldChange.change, replacer);
 
 			updatedFields.set(field, { ...fieldChange, change: brand(updatedFieldChange) });
 		}
@@ -1643,9 +1650,10 @@ export class ModularChangeFamily
 	}
 
 	public buildEditor(
+		mintRevisionTag: () => RevisionTag,
 		changeReceiver: (change: TaggedChange<ModularChangeset>) => void,
 	): ModularEditBuilder {
-		return new ModularEditBuilder(this, this.fieldKinds, changeReceiver);
+		return new ModularEditBuilder(this, this.fieldKinds, changeReceiver, this.codecOptions);
 	}
 
 	private createEmptyFieldChange(fieldKind: FieldKindIdentifier): FieldChange {
@@ -1757,25 +1765,20 @@ export class ModularChangeFamily
 
 function replaceCrossFieldKeyTableRevisions(
 	table: CrossFieldKeyTable,
-	oldRevisions: Set<RevisionTag | undefined>,
-	newRevision: RevisionTag | undefined,
+	replacer: RevisionReplacer,
 	nodeAliases: ChangeAtomIdBTree<NodeId>,
 ): CrossFieldKeyTable {
 	const updated: CrossFieldKeyTable = newCrossFieldKeyTable();
 	for (const entry of table.entries()) {
 		const key = entry.start;
-		const updatedKey: CrossFieldKey = {
-			target: key.target,
-			revision: replaceRevision(key.revision, oldRevisions, newRevision),
-			localId: key.localId,
-		};
+		const updatedKey: CrossFieldKey = replacer.getUpdatedAtomId(key);
 
 		const field = entry.value;
 		const normalizedFieldId = normalizeFieldId(field, nodeAliases);
 		const updatedNodeId =
-			normalizedFieldId.nodeId !== undefined
-				? replaceAtomRevisions(normalizedFieldId.nodeId, oldRevisions, newRevision)
-				: undefined;
+			normalizedFieldId.nodeId === undefined
+				? undefined
+				: replacer.getUpdatedAtomId(normalizedFieldId.nodeId);
 
 		const updatedValue: FieldId = {
 			...normalizedFieldId,
@@ -1788,22 +1791,15 @@ function replaceCrossFieldKeyTableRevisions(
 	return updated;
 }
 
-function replaceRevision(
-	revision: RevisionTag | undefined,
-	oldRevisions: Set<RevisionTag | undefined>,
-	newRevision: RevisionTag | undefined,
-): RevisionTag | undefined {
-	return oldRevisions.has(revision) ? newRevision : revision;
-}
-
 function replaceIdMapRevisions<T>(
 	map: ChangeAtomIdBTree<T>,
-	oldRevisions: Set<RevisionTag | undefined>,
-	newRevision: RevisionTag | undefined,
+	replacer: RevisionReplacer,
+	valueMapper: (value: T) => T = (value) => value,
 ): ChangeAtomIdBTree<T> {
 	const updated: ChangeAtomIdBTree<T> = newTupleBTree();
-	for (const [[revision, id], value] of map.entries()) {
-		updated.set([replaceRevision(revision, oldRevisions, newRevision), id], value);
+	for (const [[revision, localId], value] of map.entries()) {
+		const newAtom = replacer.getUpdatedAtomId({ revision, localId });
+		updated.set([newAtom.revision, newAtom.localId], valueMapper(value));
 	}
 
 	return updated;
@@ -1990,6 +1986,9 @@ export function updateRefreshers(
 	const {
 		fieldChanges,
 		nodeChanges,
+		nodeToParent,
+		nodeAliases,
+		crossFieldKeys,
 		maxId,
 		revisions,
 		constraintViolationCount,
@@ -2001,9 +2000,9 @@ export function updateRefreshers(
 	return makeModularChangeset({
 		fieldChanges,
 		nodeChanges,
-		nodeToParent: change.nodeToParent,
-		nodeAliases: change.nodeAliases,
-		crossFieldKeys: change.crossFieldKeys,
+		nodeToParent,
+		nodeAliases,
+		crossFieldKeys,
 		maxId: maxId as number,
 		revisions,
 		constraintViolationCount,
@@ -2620,6 +2619,8 @@ function makeModularChangeset(
 		revisions?: readonly RevisionInfo[];
 		constraintViolationCount?: number;
 		constraintViolationCountOnRevert?: number;
+		noChangeConstraint?: NoChangeConstraint;
+		noChangeConstraintOnRevert?: NoChangeConstraint;
 		builds?: ChangeAtomIdBTree<TreeChunk>;
 		destroys?: ChangeAtomIdBTree<number>;
 		refreshers?: ChangeAtomIdBTree<TreeChunk>;
@@ -2650,6 +2651,12 @@ function makeModularChangeset(
 	) {
 		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;
 	}
@@ -2665,14 +2672,17 @@ function makeModularChangeset(
 export class ModularEditBuilder extends EditBuilder<ModularChangeset> {
 	private transactionDepth: number = 0;
 	private idAllocator: IdAllocator;
+	private readonly codecOptions: CodecWriteOptions;
 
 	public constructor(
 		family: ChangeFamily<ChangeFamilyEditor, ModularChangeset>,
 		private readonly fieldKinds: ReadonlyMap<FieldKindIdentifier, FlexFieldKind>,
 		changeReceiver: (change: TaggedChange<ModularChangeset>) => void,
+		codecOptions: CodecWriteOptions,
 	) {
 		super(family, changeReceiver);
 		this.idAllocator = idAllocatorFromMaxId();
+		this.codecOptions = codecOptions;
 	}
 
 	public override enterTransaction(): void {
@@ -2785,7 +2795,7 @@ export class ModularEditBuilder extends EditBuilder<ModularChangeset> {
 						}),
 			);
 		});
-		const revInfo = Array.from(revisions).map((revision) => ({ revision }));
+		const revInfo = [...revisions].map((revision) => ({ revision }));
 		const composedChange: Mutable<ModularChangeset> = {
 			...this.changeFamily.rebaser.compose(changeMaps),
 			revisions: revInfo,
@@ -2843,6 +2853,36 @@ export class ModularEditBuilder extends EditBuilder<ModularChangeset> {
 			),
 		);
 	}
+
+	public addNoChangeConstraint(revision: RevisionTag): void {
+		if (lt(this.codecOptions.minVersionForCollab, FluidClientVersion.v2_80)) {
+			throw new UsageError(
+				`No change constraints require min client version of at least ${FluidClientVersion.v2_80}`,
+			);
+		}
+
+		const changeset = makeModularChangeset({
+			maxId: -1,
+			noChangeConstraint: { violated: false },
+		});
+
+		this.applyChange(tagChange(changeset, revision));
+	}
+
+	public addNoChangeConstraintOnRevert(revision: RevisionTag): void {
+		if (lt(this.codecOptions.minVersionForCollab, FluidClientVersion.v2_80)) {
+			throw new UsageError(
+				`No change constraints require min client version of at least ${FluidClientVersion.v2_80}`,
+			);
+		}
+
+		const changeset = makeModularChangeset({
+			maxId: -1,
+			noChangeConstraintOnRevert: { violated: false },
+		});
+
+		this.applyChange(tagChange(changeset, revision));
+	}
 }
 
 function buildModularChangesetFromField(props: {
@@ -2932,9 +2972,13 @@ function buildModularChangesetFromNode(props: {
 }): ModularChangeset {
 	const {
 		path,
-		nodeId = { localId: brand(props.idAllocator.allocate()), revision: props.revision },
+		idAllocator,
+		revision,
+		nodeChanges,
+		nodeChange,
+		nodeId = { localId: brand(idAllocator.allocate()), revision },
 	} = props;
-	setInChangeAtomIdMap(props.nodeChanges, nodeId, props.nodeChange);
+	setInChangeAtomIdMap(nodeChanges, nodeId, nodeChange);
 	const fieldChangeset = genericFieldKind.changeHandler.editor.buildChildChanges([
 		[path.parentIndex, nodeId],
 	]);
@@ -2975,16 +3019,21 @@ function getRevInfoFromTaggedChanges(changes: TaggedChange<ModularChangeset>[]):
 } {
 	let maxId = -1;
 	const revInfos: RevisionInfo[] = [];
+	const revisions = new Set<RevisionTag>();
 	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<RevisionTag>();
 	const rolledBackRevisions: RevisionTag[] = [];
 	for (const info of revInfos) {
-		revisions.add(info.revision);
 		if (info.rollbackOf !== undefined) {
 			rolledBackRevisions.push(info.rollbackOf);
 		}
@@ -3058,7 +3107,7 @@ function nodeChangeFromId(nodes: ChangeAtomIdBTree<NodeChangeset>, id: NodeId):
 }
 
 function fieldIdFromFieldIdKey([revision, localId, field]: FieldIdKey): FieldId {
-	const nodeId = localId !== undefined ? { revision, localId } : undefined;
+	const nodeId = localId === undefined ? undefined : { revision, localId };
 	return { nodeId, field };
 }
 
@@ -3070,18 +3119,14 @@ function cloneNodeChangeset(nodeChangeset: NodeChangeset): NodeChangeset {
 	return { ...nodeChangeset };
 }
 
-function replaceFieldIdRevision(
-	fieldId: FieldId,
-	oldRevisions: Set<RevisionTag | undefined>,
-	newRevision: RevisionTag | undefined,
-): FieldId {
+function replaceFieldIdRevision(fieldId: FieldId, replacer: RevisionReplacer): FieldId {
 	if (fieldId.nodeId === undefined) {
 		return fieldId;
 	}
 
 	return {
 		...fieldId,
-		nodeId: replaceAtomRevisions(fieldId.nodeId, oldRevisions, newRevision),
+		nodeId: replacer.getUpdatedAtomId(fieldId.nodeId),
 	};
 }
 
@@ -3106,9 +3151,9 @@ export function normalizeFieldId(
 	fieldId: FieldId,
 	nodeAliases: ChangeAtomIdBTree<NodeId>,
 ): FieldId {
-	return fieldId.nodeId !== undefined
-		? { ...fieldId, nodeId: normalizeNodeId(fieldId.nodeId, nodeAliases) }
-		: fieldId;
+	return fieldId.nodeId === undefined
+		? fieldId
+		: { ...fieldId, nodeId: normalizeNodeId(fieldId.nodeId, nodeAliases) };
 }
 
 /**
@@ -3140,17 +3185,6 @@ interface ModularChangesetContent {
 	crossFieldKeys: CrossFieldKeyTable;
 }
 
-function getFromChangeAtomIdMap<T>(
-	map: ChangeAtomIdBTree<T>,
-	id: ChangeAtomId,
-): T | undefined {
-	return map.get([id.revision, id.localId]);
-}
-
-function setInChangeAtomIdMap<T>(map: ChangeAtomIdBTree<T>, id: ChangeAtomId, value: T): void {
-	map.set([id.revision, id.localId], value);
-}
-
 function areEqualFieldIds(a: FieldId, b: FieldId): boolean {
 	return areEqualChangeAtomIdOpts(a.nodeId, b.nodeId) && a.field === b.field;
 }

package/src/feature-libraries/modular-schema/{modularChangeFormat.ts → modularChangeFormatV1.ts}

@@ -25,7 +25,7 @@ export const EncodedChangeAtomId = Type.Union([
 ]);
 export type EncodedChangeAtomId = Static<typeof EncodedChangeAtomId>;
 
-const EncodedFieldChange = Type.Object(
+export const EncodedFieldChange = Type.Object(
 	{
 		fieldKey: schemaFormatV1.FieldKeySchema,
 		fieldKind: schemaFormatV1.FieldKindIdentifierSchema,
@@ -44,7 +44,7 @@ export interface EncodedFieldChange extends Static<typeof EncodedFieldChange> {
 	change: JsonCompatibleReadOnly;
 }
 
-const EncodedFieldChangeMap = Type.Array(EncodedFieldChange);
+export const EncodedFieldChangeMap = Type.Array(EncodedFieldChange);
 
 /**
  * Format for encoding as json.
@@ -125,7 +125,7 @@ export const EncodedBuilds = Type.Object(
 
 export type EncodedBuilds = Static<typeof EncodedBuilds>;
 
-export const EncodedModularChangeset = Type.Object(
+export const EncodedModularChangesetV1 = Type.Object(
 	{
 		maxId: Type.Optional(ChangesetLocalIdSchema),
 		changes: EncodedFieldChangeMap,
@@ -142,4 +142,4 @@ export const EncodedModularChangeset = Type.Object(
 	noAdditionalProps,
 );
 
-export type EncodedModularChangeset = Static<typeof EncodedModularChangeset>;
+export type EncodedModularChangesetV1 = Static<typeof EncodedModularChangesetV1>;

package/src/feature-libraries/modular-schema/modularChangeFormatV2.ts

@@ -0,0 +1,34 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { type ObjectOptions, type Static, Type } from "@sinclair/typebox";
+
+import { EncodedModularChangesetV1 } from "./modularChangeFormatV1.js";
+
+const noAdditionalProps: ObjectOptions = { additionalProperties: false };
+
+const EncodedNoChangeConstraint = Type.Object(
+	{
+		violated: Type.Boolean(),
+	},
+	noAdditionalProps,
+);
+export type EncodedNoChangeConstraint = Static<typeof EncodedNoChangeConstraint>;
+
+export const EncodedModularChangesetV2 = Type.Composite(
+	[
+		EncodedModularChangesetV1,
+		Type.Object(
+			{
+				/** Global no change constraint that gets violated whenever the changeset is rebased */
+				noChangeConstraint: Type.Optional(EncodedNoChangeConstraint),
+			},
+			noAdditionalProps,
+		),
+	],
+	noAdditionalProps,
+);
+
+export type EncodedModularChangesetV2 = Static<typeof EncodedModularChangesetV2>;