@fluidframework/tree 2.74.0 → 2.80.0

package/src/feature-libraries/chunked-forest/codec/chunkDecoding.ts

@@ -177,12 +177,15 @@ export function deaggregateChunks(chunk: TreeChunk): TreeChunk[] {
 export function aggregateChunks(input: TreeChunk[]): TreeChunk {
 	const chunks = input.flatMap(deaggregateChunks);
 	switch (chunks.length) {
-		case 0:
+		case 0: {
 			return emptyChunk;
-		case 1:
+		}
+		case 1: {
 			return chunks[0] ?? oob();
-		default:
+		}
+		default: {
 			return new SequenceChunk(chunks);
+		}
 	}
 }
 
@@ -336,7 +339,7 @@ export class NodeDecoder implements ChunkDecoder {
 			// consider keeping array chunks here if they are longer than some threshold.
 			const chunks = deaggregateChunks(data);
 
-			if (chunks.length !== 0) {
+			if (chunks.length > 0) {
 				fields.set(key, chunks);
 			}
 		}

package/src/feature-libraries/chunked-forest/codec/codecs.ts

@@ -159,18 +159,21 @@ export function makeFieldBatchCodec(options: CodecWriteOptions): FieldBatchCodec
 		| typeof schemaCompressedEncodeV2;
 	let encodedFieldBatchType: typeof EncodedFieldBatchV1 | typeof EncodedFieldBatchV2;
 	switch (writeVersion) {
-		case unbrand(FieldBatchFormatVersion.v1):
+		case unbrand(FieldBatchFormatVersion.v1): {
 			uncompressedEncodeFn = uncompressedEncodeV1;
 			schemaCompressedEncodeFn = schemaCompressedEncodeV1;
 			encodedFieldBatchType = EncodedFieldBatchV1;
 			break;
-		case unbrand(FieldBatchFormatVersion.v2):
+		}
+		case unbrand(FieldBatchFormatVersion.v2): {
 			uncompressedEncodeFn = uncompressedEncodeV2;
 			schemaCompressedEncodeFn = schemaCompressedEncodeV2;
 			encodedFieldBatchType = EncodedFieldBatchV2;
 			break;
-		default:
+		}
+		default: {
 			unreachableCase(writeVersion);
+		}
 	}
 
 	return makeVersionedValidatedCodec(options, validVersions, encodedFieldBatchType, {
@@ -184,19 +187,25 @@ export function makeFieldBatchCodec(options: CodecWriteOptions): FieldBatchCodec
 			let encoded: EncodedFieldBatch;
 			let incrementalEncoder: IncrementalEncoder | undefined;
 			switch (context.encodeType) {
-				case TreeCompressionStrategy.Uncompressed:
+				case TreeCompressionStrategy.Uncompressed: {
 					encoded = uncompressedEncodeFn(data);
 					break;
-				case TreeCompressionStrategy.CompressedIncremental:
+				}
+				case TreeCompressionStrategy.CompressedIncremental: {
 					assert(
 						writeVersion >= FieldBatchFormatVersion.v2,
 						0xca0 /* Unsupported FieldBatchFormatVersion for incremental encoding; must be v2 or higher */,
 					);
 					// Incremental encoding is only supported for CompressedIncremental.
 					incrementalEncoder = context.incrementalEncoderDecoder;
-				case TreeCompressionStrategy.Compressed:
+				}
+				// fallthrough
+				case TreeCompressionStrategy.Compressed: {
 					// eslint-disable-next-line unicorn/prefer-ternary
-					if (context.schema !== undefined) {
+					if (context.schema === undefined) {
+						// TODO: consider enabling a somewhat compressed but not schema accelerated encode.
+						encoded = uncompressedEncodeFn(data);
+					} else {
 						encoded = schemaCompressedEncodeFn(
 							context.schema.schema,
 							context.schema.policy,
@@ -204,14 +213,13 @@ export function makeFieldBatchCodec(options: CodecWriteOptions): FieldBatchCodec
 							context.idCompressor,
 							incrementalEncoder,
 						);
-					} else {
-						// TODO: consider enabling a somewhat compressed but not schema accelerated encode.
-						encoded = uncompressedEncodeFn(data);
 					}
 
 					break;
-				default:
+				}
+				default: {
 					unreachableCase(context.encodeType);
+				}
 			}
 
 			// TODO: consider checking input data was in schema.

package/src/feature-libraries/chunked-forest/codec/compressedEncode.ts

@@ -484,10 +484,10 @@ export function encodeValue(
 	outputBuffer: BufferFormat,
 ): void {
 	if (shape === undefined) {
-		if (value !== undefined) {
-			outputBuffer.push(true, value);
-		} else {
+		if (value === undefined) {
 			outputBuffer.push(false);
+		} else {
+			outputBuffer.push(true, value);
 		}
 	} else {
 		if (shape === true) {

package/src/feature-libraries/chunked-forest/codec/schemaBasedEncode.ts

@@ -143,7 +143,7 @@ export function getFieldEncoder(
 	const kind = context.fieldShapes.get(field.kind) ?? fail(0xb52 /* missing FieldKind */);
 	const type = oneFromIterable(field.types);
 	const nodeEncoder =
-		type !== undefined ? nodeBuilder.nodeEncoderFromSchema(type) : anyNodeEncoder;
+		type === undefined ? anyNodeEncoder : nodeBuilder.nodeEncoderFromSchema(type);
 	if (kind.multiplicity === Multiplicity.Single) {
 		if (field.kind === identifierFieldKindIdentifier) {
 			assert(type !== undefined, 0x999 /* field type must be defined in identifier field */);
@@ -227,16 +227,20 @@ export function getNodeEncoder(
 
 function valueShapeFromSchema(schema: ValueSchema | undefined): undefined | EncodedValueShape {
 	switch (schema) {
-		case undefined:
+		case undefined: {
 			return false;
+		}
 		case ValueSchema.Number:
 		case ValueSchema.String:
 		case ValueSchema.Boolean:
-		case ValueSchema.FluidHandle:
+		case ValueSchema.FluidHandle: {
 			return true;
-		case ValueSchema.Null:
+		}
+		case ValueSchema.Null: {
 			return [null];
-		default:
+		}
+		default: {
 			unreachableCase(schema);
+		}
 	}
 }

package/src/feature-libraries/chunked-forest/uniformChunk.ts

@@ -66,7 +66,7 @@ export class UniformChunk extends ReferenceCountedBase implements TreeChunk {
 	}
 
 	public clone(): UniformChunk {
-		return new UniformChunk(this.shape, this.values.slice());
+		return new UniformChunk(this.shape, [...this.values]);
 	}
 
 	public cursor(): Cursor {

package/src/feature-libraries/default-schema/defaultEditBuilder.ts

@@ -6,7 +6,7 @@
 import { assert, oob } from "@fluidframework/core-utils/internal";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 
-import type { ICodecFamily } from "../../codec/index.js";
+import type { CodecWriteOptions, ICodecFamily } from "../../codec/index.js";
 import {
 	type ChangeAtomId,
 	type ChangeEncodingContext,
@@ -58,8 +58,11 @@ export class DefaultChangeFamily
 {
 	private readonly modularFamily: ModularChangeFamily;
 
-	public constructor(codecs: ICodecFamily<ModularChangeset, ChangeEncodingContext>) {
-		this.modularFamily = new ModularChangeFamily(fieldKinds, codecs);
+	public constructor(
+		codecs: ICodecFamily<ModularChangeset, ChangeEncodingContext>,
+		codecOptions: CodecWriteOptions,
+	) {
+		this.modularFamily = new ModularChangeFamily(fieldKinds, codecs, codecOptions);
 	}
 
 	public get rebaser(): ChangeRebaser<DefaultChangeset> {
@@ -74,7 +77,12 @@ export class DefaultChangeFamily
 		mintRevisionTag: () => RevisionTag,
 		changeReceiver: (change: TaggedChange<DefaultChangeset>) => void,
 	): DefaultEditBuilder {
-		return new DefaultEditBuilder(this, mintRevisionTag, changeReceiver);
+		return new DefaultEditBuilder(
+			this,
+			mintRevisionTag,
+			changeReceiver,
+			this.modularFamily.codecOptions,
+		);
 	}
 }
 
@@ -161,16 +169,26 @@ export interface IDefaultEditBuilder<TContent = TreeChunk> {
 	): void;
 
 	/**
-	 * Add a constraint that the node at the given path must exist.
+	 * Add a constraint that, for this change to apply, the node at the given path must exist immediately before the change is applied.
 	 * @param path - The path to the node that must exist.
 	 */
 	addNodeExistsConstraint(path: NormalizedUpPath): void;
 
 	/**
-	 * Add a constraint that the node at the given path must exist when reverting a change.
+	 * Add a constraint that, for the revert of this change to apply, the node at the given path must exist immediately before the revert is applied.
 	 * @param path - The path to the node that must exist when reverting a change.
 	 */
 	addNodeExistsConstraintOnRevert(path: NormalizedUpPath): void;
+
+	/**
+	 * Add a constraint that, for this change to apply, the document must be in the same state immediately before this change is applied as it was before this change was authored.
+	 */
+	addNoChangeConstraint(): void;
+
+	/**
+	 * Add a constraint that, for the revert of this change to apply, the document must be in the same state immediately before the revert is applied as it was after this change was applied.
+	 */
+	addNoChangeConstraintOnRevert(): void;
 }
 
 /**
@@ -184,8 +202,14 @@ export class DefaultEditBuilder implements ChangeFamilyEditor, IDefaultEditBuild
 		family: ChangeFamily<ChangeFamilyEditor, DefaultChangeset>,
 		private readonly mintRevisionTag: () => RevisionTag,
 		changeReceiver: (change: TaggedChange<DefaultChangeset>) => void,
+		codecOptions: CodecWriteOptions,
 	) {
-		this.modularBuilder = new ModularEditBuilder(family, fieldKinds, changeReceiver);
+		this.modularBuilder = new ModularEditBuilder(
+			family,
+			fieldKinds,
+			changeReceiver,
+			codecOptions,
+		);
 	}
 
 	public enterTransaction(): void {
@@ -203,6 +227,14 @@ export class DefaultEditBuilder implements ChangeFamilyEditor, IDefaultEditBuild
 		this.modularBuilder.addNodeExistsConstraintOnRevert(path, this.mintRevisionTag());
 	}
 
+	public addNoChangeConstraint(): void {
+		this.modularBuilder.addNoChangeConstraint(this.mintRevisionTag());
+	}
+
+	public addNoChangeConstraintOnRevert(): void {
+		this.modularBuilder.addNoChangeConstraintOnRevert(this.mintRevisionTag());
+	}
+
 	public valueField(field: FieldUpPath): ValueFieldEditBuilder<TreeChunk> {
 		return {
 			set: (newContent: TreeChunk): void => {
@@ -245,7 +277,9 @@ export class DefaultEditBuilder implements ChangeFamilyEditor, IDefaultEditBuild
 				let optionalChange: OptionalChangeset;
 				const revision = this.mintRevisionTag();
 				const detach: ChangeAtomId = { localId: this.modularBuilder.generateId(), revision };
-				if (newContent !== undefined) {
+				if (newContent === undefined) {
+					optionalChange = optional.changeHandler.editor.clear(wasEmpty, detach);
+				} else {
 					const fill: ChangeAtomId = { localId: this.modularBuilder.generateId(), revision };
 					const build = this.modularBuilder.buildTrees(fill.localId, newContent, revision);
 					edits.push(build);
@@ -254,8 +288,6 @@ export class DefaultEditBuilder implements ChangeFamilyEditor, IDefaultEditBuild
 						fill,
 						detach,
 					});
-				} else {
-					optionalChange = optional.changeHandler.editor.clear(wasEmpty, detach);
 				}
 
 				const change: FieldChangeset = brand(optionalChange);
@@ -464,13 +496,12 @@ function getSharedPrefixLength(pathA: readonly UpPath[], pathB: readonly UpPath[
 	while (sharedDepth < minDepth) {
 		const detachStep = pathA[sharedDepth] ?? oob();
 		const attachStep = pathB[sharedDepth] ?? oob();
-		if (detachStep !== attachStep) {
-			if (
-				detachStep.parentField !== attachStep.parentField ||
-				detachStep.parentIndex !== attachStep.parentIndex
-			) {
-				break;
-			}
+		if (
+			detachStep !== attachStep &&
+			(detachStep.parentField !== attachStep.parentField ||
+				detachStep.parentIndex !== attachStep.parentIndex)
+		) {
+			break;
 		}
 		sharedDepth += 1;
 	}

package/src/feature-libraries/default-schema/defaultFieldKinds.ts

@@ -202,15 +202,25 @@ export const fieldKindConfigurations: ReadonlyMap<
 			[identifier.identifier, { kind: identifier, formatVersion: 1 }],
 		]),
 	],
+	[
+		brand(5),
+		new Map<FieldKindIdentifier, FieldKindConfigurationEntry>([
+			[required.identifier, { kind: required, formatVersion: 2 }],
+			[optional.identifier, { kind: optional, formatVersion: 2 }],
+			[sequence.identifier, { kind: sequence, formatVersion: 3 }],
+			[forbidden.identifier, { kind: forbidden, formatVersion: 1 }],
+			[identifier.identifier, { kind: identifier, formatVersion: 1 }],
+		]),
+	],
 ]);
 
-export type ModularChangeFormatVersion = Brand<3 | 4, "ModularChangeFormatVersion">;
+export type ModularChangeFormatVersion = Brand<3 | 4 | 5, "ModularChangeFormatVersion">;
 export function getCodecTreeForModularChangeFormat(
 	version: ModularChangeFormatVersion,
 ): CodecTree {
 	const dependencies =
 		fieldKindConfigurations.get(version) ?? fail(0xc7c /* Unknown modular change format */);
-	const children: CodecTree[] = Array.from(dependencies.entries()).map(
+	const children: CodecTree[] = [...dependencies.entries()].map(
 		([key, { formatVersion }]) => ({
 			name: `FieldKind:${key}`,
 			version: formatVersion,

package/src/feature-libraries/default-schema/mappedEditBuilder.ts

@@ -66,4 +66,10 @@ export class MappedEditBuilder<TBase, TAdapted> implements IDefaultEditBuilder<T
 	public addNodeExistsConstraintOnRevert(path: NormalizedUpPath): void {
 		this.baseBuilder.addNodeExistsConstraintOnRevert(path);
 	}
+	public addNoChangeConstraint(): void {
+		this.baseBuilder.addNoChangeConstraint();
+	}
+	public addNoChangeConstraintOnRevert(): void {
+		this.baseBuilder.addNoChangeConstraintOnRevert();
+	}
 }

package/src/feature-libraries/flex-tree/lazyField.ts

@@ -230,16 +230,15 @@ export abstract class LazyField extends LazyEntity<FieldAnchor> implements FlexT
 	 * This path is not valid to hold onto across edits: this must be recalled for each edit.
 	 */
 	public getFieldPathForEditing(): NormalizedFieldUpPath {
-		if (!this.isFreed()) {
-			if (
-				// Only allow editing if we are the root document field...
-				(this.parent === undefined && this.anchor.fieldKey === rootFieldKey) ||
+		if (
+			!this.isFreed() &&
+			// Only allow editing if we are the root document field...
+			((this.parent === undefined && this.anchor.fieldKey === rootFieldKey) ||
 				// ...or are under a node in the document
 				(this.parent !== undefined &&
-					treeStatusFromAnchorCache(this.parent.anchorNode) === TreeStatus.InDocument)
-			) {
-				return this.getFieldPath();
-			}
+					treeStatusFromAnchorCache(this.parent.anchorNode) === TreeStatus.InDocument))
+		) {
+			return this.getFieldPath();
 		}
 
 		throw new UsageError("Editing only allowed on fields with TreeStatus.InDocument status");
@@ -305,7 +304,7 @@ export class LazyOptionalField extends LazyField implements FlexTreeOptionalFiel
 	public editor: OptionalFieldEditBuilder<ExclusiveMapTree> = {
 		set: (newContent, wasEmpty) => {
 			this.optionalEditor().set(
-				newContent !== undefined ? cursorForMapTreeField([newContent]) : newContent,
+				newContent === undefined ? newContent : cursorForMapTreeField([newContent]),
 				wasEmpty,
 			);
 		},
@@ -359,16 +358,16 @@ export function unboxedFlexNode(
 	// This avoids O(depth) related costs from getOrCreateHydratedFlexTreeNode in the cached case.
 	const anchor = fieldAnchor.parent;
 	let child: AnchorNode | undefined;
-	if (anchor !== undefined) {
-		const anchorNode = context.checkout.forest.anchors.locate(anchor);
-		assert(anchorNode !== undefined, 0xa4c /* missing anchor */);
-		child = anchorNode.childIfAnchored(fieldAnchor.fieldKey, cursor.fieldIndex);
-	} else {
+	if (anchor === undefined) {
 		child = context.checkout.forest.anchors.find({
 			parent: undefined,
 			parentField: fieldAnchor.fieldKey,
 			parentIndex: cursor.fieldIndex,
 		});
+	} else {
+		const anchorNode = context.checkout.forest.anchors.locate(anchor);
+		assert(anchorNode !== undefined, 0xa4c /* missing anchor */);
+		child = anchorNode.childIfAnchored(fieldAnchor.fieldKey, cursor.fieldIndex);
 	}
 
 	if (child !== undefined) {

package/src/feature-libraries/index.ts

@@ -29,11 +29,8 @@ export {
 export { buildForest } from "./object-forest/index.js";
 export {
 	SchemaSummarizer,
-	encodeTreeSchema,
 	makeSchemaCodec,
-	makeSchemaCodecs,
-	getCodecTreeForSchemaFormat,
-	clientVersionToSchemaVersion,
+	schemaCodecBuilder,
 } from "./schema-index/index.js";
 export {
 	stackTreeNodeCursor,
@@ -83,13 +80,15 @@ export {
 	type NodeExistsConstraint,
 	ModularChangeFamily,
 	type RelevantRemovedRootsFromChild,
-	EncodedModularChangeset,
+	EncodedModularChangesetV1,
+	EncodedModularChangesetV2,
 	updateRefreshers,
 	type NodeId,
 	type FieldChangeEncodingContext,
 	type FieldKindConfiguration,
 	type FieldKindConfigurationEntry,
 	isNeverTree,
+	DefaultRevisionReplacer,
 } from "./modular-schema/index.js";
 
 export { mapRootChanges } from "./deltaUtils.js";
@@ -213,3 +212,9 @@ export {
 	type TreeIndexKey,
 	type TreeIndexNodes,
 } from "./indexing/index.js";
+
+export {
+	type ChangeAtomIdBTree,
+	getFromChangeAtomIdMap,
+	setInChangeAtomIdMap,
+} from "./changeAtomIdBTree.js";

package/src/feature-libraries/indexing/anchorTreeIndex.ts

@@ -394,12 +394,12 @@ export class AnchorTreeIndex<TKey extends TreeIndexKey, TValue>
 	 * Given a cursor in field mode, indexes all nodes under the field and then indexes all nodes up the spine.
 	 */
 	private indexSpine(cursor: ITreeSubscriptionCursor): void {
-		if (keyAsDetachedField(cursor.getFieldKey()) !== rootField) {
-			cursor.exitField();
-			cursor.exitNode();
-		} else {
+		if (keyAsDetachedField(cursor.getFieldKey()) === rootField) {
 			// return early if we're already at the root field
 			return;
+		} else {
+			cursor.exitField();
+			cursor.exitNode();
 		}
 
 		// walk up the spine and index nodes until we reach the root
@@ -470,5 +470,5 @@ function filterNodes(
  * Checks that an array is of the type {@link TreeIndexNodes} and has at least one element.
  */
 export function hasElement<T>(array: readonly T[]): array is TreeIndexNodes<T> {
-	return array.length >= 1;
+	return array.length > 0;
 }

package/src/feature-libraries/mitigatedChangeFamily.ts

@@ -8,6 +8,7 @@ import type {
 	ChangeFamilyEditor,
 	ChangeRebaser,
 	RevisionMetadataSource,
+	RevisionReplacer,
 	RevisionTag,
 	TaggedChange,
 } from "../core/index.js";
@@ -75,11 +76,15 @@ export function makeMitigatedRebaser<TChange>(
 		): TChange => {
 			return withFallback(() => unmitigatedRebaser.rebase(change, over, revisionMetadata));
 		},
-		changeRevision: (
-			change: TChange,
-			newRevision: RevisionTag | undefined,
-			rollbackOf?: RevisionTag,
-		): TChange =>
-			withFallback(() => unmitigatedRebaser.changeRevision(change, newRevision, rollbackOf)),
+		getRevisions: (change: TChange): Set<RevisionTag | undefined> => {
+			try {
+				return unmitigatedRebaser.getRevisions(change);
+			} catch (error: unknown) {
+				onError(error);
+				return new Set();
+			}
+		},
+		changeRevision: (change: TChange, replacer: RevisionReplacer): TChange =>
+			withFallback(() => unmitigatedRebaser.changeRevision(change, replacer)),
 	};
 }

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

@@ -144,10 +144,8 @@ export function allowsFieldSuperset(
 	superset: TreeFieldStoredSchema,
 	monotonicOnly: boolean = true,
 ): boolean {
-	if (!monotonicOnly) {
-		if (isNeverField(policy, originalData, original)) {
-			return true;
-		}
+	if (!monotonicOnly && isNeverField(policy, originalData, original)) {
+		return true;
 	}
 
 	if (!allowsTreeSchemaIdentifierSuperset(original.types, superset.types)) {
@@ -239,15 +237,20 @@ export function allowsMultiplicitySuperset(
 	}
 
 	switch (superset) {
-		case Multiplicity.Forbidden:
+		case Multiplicity.Forbidden: {
 			return false;
-		case Multiplicity.Optional:
+		}
+		case Multiplicity.Optional: {
 			return original === Multiplicity.Single || original === Multiplicity.Forbidden;
-		case Multiplicity.Single:
+		}
+		case Multiplicity.Single: {
 			return false;
-		case Multiplicity.Sequence:
+		}
+		case Multiplicity.Sequence: {
 			return true;
-		default:
+		}
+		default: {
 			return unreachableCase(superset);
+		}
 	}
 }

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

@@ -0,0 +1,70 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import type {
+	ChangeAtomId,
+	ChangesetLocalId,
+	RevisionReplacer,
+	RevisionTag,
+} from "../../core/index.js";
+import { brand, brandConst, newTupleBTree, type Mutable } from "../../util/index.js";
+import {
+	getFromChangeAtomIdMap,
+	setInChangeAtomIdMap,
+	type ChangeAtomIdBTree,
+} from "../changeAtomIdBTree.js";
+
+export class DefaultRevisionReplacer implements RevisionReplacer {
+	/**
+	 * Mapping from (obsolete revision tag, original local id) to the updated local id.
+	 */
+	private readonly updatedLocalIds: ChangeAtomIdBTree<ChangesetLocalId> = newTupleBTree();
+	/**
+	 * The set of local IDs already used in the scope of the updated revision.
+	 */
+	private readonly localIds: Set<ChangesetLocalId> = new Set();
+	/**
+	 * The maximum local ID seen so far in the scope of the updated revision.
+	 */
+	private maxSeen: ChangesetLocalId = brandConst(-1)();
+
+	public constructor(
+		public readonly updatedRevision: RevisionTag,
+		private readonly obsoleteRevisions: Set<RevisionTag | undefined>,
+	) {}
+
+	public isObsolete(revision: RevisionTag | undefined): boolean {
+		return this.obsoleteRevisions.has(revision);
+	}
+
+	public getUpdatedAtomId<T extends ChangeAtomId>(id: T): T {
+		if (this.isObsolete(id.revision)) {
+			const updated: Mutable<T> = { ...id, revision: this.updatedRevision };
+			const prior: ChangesetLocalId | undefined = getFromChangeAtomIdMap(
+				this.updatedLocalIds,
+				id,
+			);
+			if (prior === undefined) {
+				let localId: ChangesetLocalId;
+				if (this.localIds.has(id.localId)) {
+					this.maxSeen = brand(this.maxSeen + 1);
+					localId = this.maxSeen;
+				} else {
+					// This change atom ID uses a local ID that has not yet been used in the scope of the updated revision.
+					// We reuse it as is to minimize the number of IDs that need to be updated.
+					localId = id.localId;
+					this.maxSeen = brand(Math.max(this.maxSeen, localId));
+					this.localIds.add(id.localId);
+				}
+				setInChangeAtomIdMap(this.updatedLocalIds, id, localId);
+				updated.localId = localId;
+			} else {
+				updated.localId = prior;
+			}
+			return updated;
+		}
+		return id;
+	}
+}

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

@@ -13,12 +13,13 @@ import type {
 	DeltaFieldMap,
 	EncodedRevisionTag,
 	RevisionMetadataSource,
+	RevisionReplacer,
 	RevisionTag,
 } from "../../core/index.js";
 import type { IdAllocator, Invariant } from "../../util/index.js";
 
 import type { CrossFieldManager } from "./crossFieldQueries.js";
-import type { EncodedNodeChangeset } from "./modularChangeFormat.js";
+import type { EncodedNodeChangeset } from "./modularChangeFormatV1.js";
 import type { CrossFieldKeyRange, NodeId } from "./modularChangeTypes.js";
 
 export type NestedChangesIndices = [
@@ -164,11 +165,7 @@ export interface FieldChangeRebaser<TChangeset> {
 	 */
 	prune(change: TChangeset, pruneChild: NodeChangePruner): TChangeset;
 
-	replaceRevisions(
-		change: TChangeset,
-		oldRevisions: Set<RevisionTag | undefined>,
-		newRevisions: RevisionTag | undefined,
-	): TChangeset;
+	replaceRevisions(change: TChangeset, replacer: RevisionReplacer): TChangeset;
 
 	/**
 	 * Returns a copy of the given changeset with the same declarations (e.g., new cells) but no actual changes.

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

@@ -11,8 +11,7 @@ import {
 	type DeltaMark,
 	type FieldKindIdentifier,
 	Multiplicity,
-	type RevisionTag,
-	replaceAtomRevisions,
+	type RevisionReplacer,
 } from "../../core/index.js";
 
 import type {
@@ -46,7 +45,7 @@ export const genericChangeHandler: FieldChangeHandler<GenericChangeset> = {
 	codecsFactory: makeGenericChangeCodec,
 	editor: {
 		buildChildChanges(changes: Iterable<[number, NodeId]>): GenericChangeset {
-			return newGenericChangeset(Array.from(changes));
+			return newGenericChangeset([...changes]);
 		},
 	},
 	intoDelta: (change: GenericChangeset, deltaFromChild: ToDelta): FieldChangeDelta => {
@@ -78,7 +77,7 @@ function compose(
 	const composed = change1.clone();
 	for (const [index, id2] of change2.entries()) {
 		const id1 = composed.get(index);
-		const idComposed = id1 !== undefined ? composeChildren(id1, id2) : id2;
+		const idComposed = id1 === undefined ? id2 : composeChildren(id1, id2);
 		composed.set(index, idComposed);
 	}
 
@@ -157,10 +156,9 @@ function pruneGenericChange(
 
 function replaceRevisions(
 	changeset: GenericChangeset,
-	oldRevisions: Set<RevisionTag | undefined>,
-	newRevision: RevisionTag | undefined,
+	replacer: RevisionReplacer,
 ): GenericChangeset {
-	return changeset.mapValues((node) => replaceAtomRevisions(node, oldRevisions, newRevision));
+	return changeset.mapValues((node) => replacer.getUpdatedAtomId(node));
 }
 
 /**

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

@@ -8,7 +8,7 @@ import { type ICodecFamily, type IJsonCodec, makeCodecFamily } from "../../codec
 import type { FieldChangeEncodingContext } from "./fieldChangeHandler.js";
 import { EncodedGenericChangeset } from "./genericFieldKindFormat.js";
 import { newGenericChangeset, type GenericChangeset } from "./genericFieldKindTypes.js";
-import { EncodedNodeChangeset } from "./modularChangeFormat.js";
+import { EncodedNodeChangeset } from "./modularChangeFormatV1.js";
 
 export function makeGenericChangeCodec(): ICodecFamily<
 	GenericChangeset,