@fluidframework/tree 2.74.0-370705 → 2.80.0

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

@@ -7,12 +7,13 @@ import { fail } from "@fluidframework/core-utils/internal";
 
 import {
 	type ChangeAtomId,
-	type DeltaFieldChanges,
+	type DeltaDetachedNodeId,
 	type FieldKindIdentifier,
 	forbiddenFieldKindIdentifier,
 	Multiplicity,
 } from "../../core/index.js";
 import {
+	type FieldChangeDelta,
 	type FieldChangeHandler,
 	type FieldEditor,
 	type FieldKindConfiguration,
@@ -49,7 +50,8 @@ export const noChangeHandler: FieldChangeHandler<0> = {
 	}),
 	codecsFactory: () => noChangeCodecFamily,
 	editor: { buildChildChanges: () => fail(0xb0d /* Child changes not supported */) },
-	intoDelta: (change, deltaFromChild: ToDelta): DeltaFieldChanges => [],
+	intoDelta: (change, deltaFromChild: ToDelta): FieldChangeDelta => ({}),
+	relevantRemovedRoots: (change): Iterable<DeltaDetachedNodeId> => [],
 	isEmpty: (change: 0) => true,
 	getNestedChanges: (change: 0) => [],
 	createEmpty: () => 0,
@@ -201,24 +203,24 @@ export const fieldKindConfigurations: ReadonlyMap<
 		]),
 	],
 	[
-		brand(101), // Detached roots
+		brand(5),
 		new Map<FieldKindIdentifier, FieldKindConfigurationEntry>([
 			[required.identifier, { kind: required, formatVersion: 2 }],
-			[optional.identifier, { kind: optional, formatVersion: 3 }],
-			[sequence.identifier, { kind: sequence, 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 | 101, "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/index.ts

@@ -19,26 +19,14 @@ export {
 
 export {
 	type DefaultChangeset,
-	type DetachedRootIds,
-	type DetachedRootIdRange,
 	DefaultChangeFamily,
-	type IdBasedChangeFamilyDataEditor,
-	DefaultIdBasedDataEditor,
-	type DataEditor,
-	type RequiredFieldEditor,
-	type OptionalFieldEditor,
-	type SequenceFieldEditor,
+	DefaultEditBuilder,
+	type IDefaultEditBuilder,
+	type ValueFieldEditBuilder,
+	type OptionalFieldEditBuilder,
+	type SequenceFieldEditBuilder,
 	intoDelta,
-	getBuildsIds,
 	relevantRemovedRoots,
 } from "./defaultEditBuilder.js";
 
-export {
-	type DetachedRootLocation,
-	type DetachedRootsLocation,
-	type Locator,
-	LocationBasedDataEditor,
-	type ILocationBasedDataEditor,
-} from "./locationBasedEditBuilder.js";
-
 export { MappedEditBuilder } from "./mappedEditBuilder.js";

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

@@ -6,45 +6,30 @@
 import type { NormalizedFieldUpPath, NormalizedUpPath } from "../../core/index.js";
 
 import type {
-	DataEditor,
-	OptionalFieldEditor,
-	SequenceFieldEditor,
-	RequiredFieldEditor,
+	IDefaultEditBuilder,
+	OptionalFieldEditBuilder,
+	SequenceFieldEditBuilder,
+	ValueFieldEditBuilder,
 } from "./defaultEditBuilder.js";
 
 /**
  * An IDefaultEditBuilder implementation based on another IDefaultEditBuilder that uses a different content type for insertions.
  */
-export class MappedEditBuilder<TBase, TAdapted, TDetachedRoot, TDetachedRoots>
-	implements DataEditor<TAdapted, TDetachedRoot, TDetachedRoots>
-{
+export class MappedEditBuilder<TBase, TAdapted> implements IDefaultEditBuilder<TAdapted> {
 	public constructor(
-		private readonly baseBuilder: DataEditor<TBase, TDetachedRoot, TDetachedRoots>,
+		private readonly baseBuilder: IDefaultEditBuilder<TBase>,
 		private readonly mapDelegate: (input: TAdapted) => TBase,
 	) {}
-
-	public buildRoots(content: TAdapted): TDetachedRoots {
-		return this.baseBuilder.buildRoots(this.mapDelegate(content));
-	}
-
-	public valueField(
-		field: NormalizedFieldUpPath,
-	): RequiredFieldEditor<TAdapted, TDetachedRoot> {
+	public valueField(field: NormalizedFieldUpPath): ValueFieldEditBuilder<TAdapted> {
 		const baseField = this.baseBuilder.valueField(field);
 		return {
 			set: (newContent: TAdapted): void => {
 				const mappedContent = this.mapDelegate(newContent);
 				baseField.set(mappedContent);
 			},
-			attach: (content: TDetachedRoot): void => {
-				baseField.attach(content);
-			},
 		};
 	}
-
-	public optionalField(
-		field: NormalizedFieldUpPath,
-	): OptionalFieldEditor<TAdapted, TDetachedRoot> {
+	public optionalField(field: NormalizedFieldUpPath): OptionalFieldEditBuilder<TAdapted> {
 		const baseField = this.baseBuilder.optionalField(field);
 		return {
 			set: (newContent: TAdapted | undefined, wasEmpty: boolean): void => {
@@ -52,17 +37,9 @@ export class MappedEditBuilder<TBase, TAdapted, TDetachedRoot, TDetachedRoots>
 					newContent === undefined ? undefined : this.mapDelegate(newContent);
 				baseField.set(mappedContent, wasEmpty);
 			},
-			attach: (content, wasEmpty: boolean): void => {
-				baseField.attach(content, wasEmpty);
-			},
-			clear(wasEmpty: boolean): void {
-				baseField.clear(wasEmpty);
-			},
 		};
 	}
-	public sequenceField(
-		field: NormalizedFieldUpPath,
-	): SequenceFieldEditor<TAdapted, TDetachedRoots> {
+	public sequenceField(field: NormalizedFieldUpPath): SequenceFieldEditBuilder<TAdapted> {
 		const baseField = this.baseBuilder.sequenceField(field);
 		return {
 			insert: (index: number, content: TAdapted): void => {
@@ -72,9 +49,6 @@ export class MappedEditBuilder<TBase, TAdapted, TDetachedRoot, TDetachedRoots>
 			remove: (index: number, count: number): void => {
 				baseField.remove(index, count);
 			},
-			attach: (index: number, detachedContent: TDetachedRoots): void => {
-				baseField.attach(index, detachedContent);
-			},
 		};
 	}
 	public move(
@@ -92,4 +66,10 @@ export class MappedEditBuilder<TBase, TAdapted, TDetachedRoot, TDetachedRoots>
 	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/deltaUtils.ts

@@ -7,19 +7,14 @@ import {
 	type ChangeAtomId,
 	type DeltaDetachedNodeId,
 	type DeltaRoot,
-	makeChangeAtomId,
 	makeDetachedNodeId,
 } from "../core/index.js";
-import { brand, type Mutable } from "../util/index.js";
+import type { Mutable } from "../util/index.js";
 
 export function nodeIdFromChangeAtom(changeAtom: ChangeAtomId): DeltaDetachedNodeId {
 	return makeDetachedNodeId(changeAtom.revision, changeAtom.localId);
 }
 
-export function changeAtomFromDetachedNodeId(changeAtom: DeltaDetachedNodeId): ChangeAtomId {
-	return makeChangeAtomId(brand(changeAtom.minor), changeAtom.major);
-}
-
 /**
  * Converts a `Delta.Root` whose tree content is represented with by `TIn` instances
  * into a `Delta.Root`whose tree content is represented with by `TOut` instances.

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

@@ -51,8 +51,6 @@ export interface FlexTreeContext {
 	 * If true, none of the nodes in this context can be used.
 	 */
 	isDisposed(): boolean;
-
-	runInTransaction(fn: () => void): void;
 }
 
 /**
@@ -68,14 +66,6 @@ export interface FlexTreeHydratedContextMinimal {
 	 * The checkout object associated with this context.
 	 */
 	readonly checkout: ITreeCheckout;
-
-	/**
-	 * Returns a new {@link FlexTreeField} that will live as long as the caller allows up to the next call to {@link clear} or disposal of the context.
-	 * @remarks
-	 * Due to limited support for detached fields, not all operations are supported.
-	 * Additionally if the detached field's content is deleted, the field will become out of schema if it is required: it must not be used after that point.
-	 */
-	detachedField?(key: DetachedField, schema: FieldKindIdentifier): FlexTreeField;
 }
 
 /**
@@ -162,13 +152,6 @@ export class Context implements FlexTreeHydratedContext, IDisposable {
 		return this.checkout.storedSchema;
 	}
 
-	public runInTransaction(fn: () => void): void {
-		debugAssert(() => !this.disposed || "Disposed");
-		this.checkout.transaction.start();
-		fn();
-		this.checkout.transaction.commit();
-	}
-
 	/**
 	 * Called before editing.
 	 * Clears all cursors so editing can proceed.

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

@@ -14,14 +14,15 @@ import {
 } from "../../core/index.js";
 import type {
 	FieldKinds,
-	SequenceFieldEditor,
-	RequiredFieldEditor,
-	OptionalFieldEditor,
+	SequenceFieldEditBuilder,
+	ValueFieldEditBuilder,
+	OptionalFieldEditBuilder,
 } from "../default-schema/index.js";
 import type {
 	MapTreeFieldViewGeneric,
 	MapTreeNodeViewGeneric,
 	MinimalFieldMap,
+	MinimalMapTreeNodeView,
 } from "../mapTreeCursor.js";
 import type { FlexFieldKind } from "../modular-schema/index.js";
 
@@ -308,7 +309,7 @@ export type FlexibleFieldContent = readonly FlexibleNodeContent[];
 /**
  * Tree for inserting as a node.
  */
-export type FlexibleNodeContent = FlexTreeNode;
+export type FlexibleNodeContent = MinimalMapTreeNodeView;
 
 /**
  * {@link FlexTreeField} that stores a sequence of children.
@@ -353,7 +354,7 @@ export interface FlexTreeSequenceField extends FlexTreeField {
 	/**
 	 * Get an editor for this sequence.
 	 */
-	readonly editor: SequenceFieldEditor<FlexibleFieldContent, readonly FlexTreeNode[]>;
+	readonly editor: SequenceFieldEditBuilder<FlexibleFieldContent>;
 }
 
 /**
@@ -365,7 +366,7 @@ export interface FlexTreeSequenceField extends FlexTreeField {
 export interface FlexTreeRequiredField extends FlexTreeField {
 	get content(): FlexTreeUnknownUnboxed;
 
-	readonly editor: RequiredFieldEditor<FlexibleNodeContent, FlexTreeNode>;
+	readonly editor: ValueFieldEditBuilder<FlexibleNodeContent>;
 }
 
 /**
@@ -384,7 +385,7 @@ export interface FlexTreeRequiredField extends FlexTreeField {
 export interface FlexTreeOptionalField extends FlexTreeField {
 	get content(): FlexTreeUnknownUnboxed | undefined;
 
-	readonly editor: OptionalFieldEditor<FlexibleNodeContent, FlexTreeNode>;
+	readonly editor: OptionalFieldEditBuilder<FlexibleNodeContent>;
 }
 
 // #endregion

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

@@ -9,6 +9,7 @@ import { UsageError } from "@fluidframework/telemetry-utils/internal";
 import {
 	type AnchorNode,
 	CursorLocationType,
+	type ExclusiveMapTree,
 	type FieldAnchor,
 	type FieldKey,
 	type FieldKindIdentifier,
@@ -25,21 +26,18 @@ import { disposeSymbol, getOrCreate } from "../../util/index.js";
 import {
 	FieldKinds,
 	MappedEditBuilder,
-	type SequenceFieldEditor,
-	type RequiredFieldEditor,
-	type DataEditor,
-	type OptionalFieldEditor,
-	type DetachedRootLocation,
-	type DetachedRootsLocation,
+	type IDefaultEditBuilder,
+	type OptionalFieldEditBuilder,
+	type SequenceFieldEditBuilder,
+	type ValueFieldEditBuilder,
 } from "../default-schema/index.js";
-import { cursorForMapTreeField, type MinimalMapTreeNodeView } from "../mapTreeCursor.js";
+import { cursorForMapTreeField } from "../mapTreeCursor.js";
 import type { FlexFieldKind } from "../modular-schema/index.js";
 
 import type { Context } from "./context.js";
 import {
 	FlexTreeEntityKind,
 	type FlexTreeField,
-	type FlexTreeNode,
 	type FlexTreeOptionalField,
 	type FlexTreeRequiredField,
 	type FlexTreeSequenceField,
@@ -53,7 +51,7 @@ import {
 	flexTreeSlot,
 } from "./flexTreeTypes.js";
 import { LazyEntity } from "./lazyEntity.js";
-import { LazyTreeNode, getOrCreateHydratedFlexTreeNode } from "./lazyNode.js";
+import { type LazyTreeNode, getOrCreateHydratedFlexTreeNode } from "./lazyNode.js";
 import { indexForAt, treeStatusFromAnchorCache } from "./utilities.js";
 import { combineChunks } from "../chunked-forest/index.js";
 
@@ -232,30 +230,21 @@ 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 (
+			!this.isFreed() &&
 			// Only allow editing if we are the root document field...
-			if (this.parent === undefined && this.anchor.fieldKey === rootFieldKey) {
-				return this.getFieldPath();
-			}
-			if (this.parent !== undefined) {
-				const status = treeStatusFromAnchorCache(this.parent.anchorNode);
-				// ...or are under a node that is hydrated and not deleted
-				if (status === TreeStatus.InDocument || status === TreeStatus.Removed) {
-					return this.getFieldPath();
-				}
-			}
+			((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();
 		}
 
-		throw new UsageError(
-			"Editing only allowed on the root field or on fields under nodes with TreeStatus.InDocument or TreeStatus.Removed status",
-		);
+		throw new UsageError("Editing only allowed on fields with TreeStatus.InDocument status");
 	}
 
-	protected getEditor(): DataEditor<
-		ITreeCursorSynchronous,
-		DetachedRootLocation,
-		DetachedRootsLocation
-	> {
+	protected getEditor(): IDefaultEditBuilder<ITreeCursorSynchronous> {
 		return new MappedEditBuilder(
 			this.context.checkout.editor,
 			(cursor: ITreeCursorSynchronous) =>
@@ -264,11 +253,6 @@ export abstract class LazyField extends LazyEntity<FieldAnchor> implements FlexT
 	}
 }
 
-function fieldFromNode(node: FlexTreeNode): FieldKey {
-	assert(node instanceof LazyTreeNode, "Invalid tree type");
-	return node.anchorNode.parentField;
-}
-
 export class LazySequence extends LazyField implements FlexTreeSequenceField {
 	public at(index: number): FlexTreeUnknownUnboxed | undefined {
 		const finalIndex = indexForAt(index, this.length);
@@ -283,48 +267,32 @@ export class LazySequence extends LazyField implements FlexTreeSequenceField {
 		return this.map((x) => x);
 	}
 
-	public editor: SequenceFieldEditor<FlexibleFieldContent, readonly FlexTreeNode[]> = {
+	public editor: SequenceFieldEditBuilder<FlexibleFieldContent> = {
 		insert: (index, newContent) => {
 			this.sequenceEditor().insert(index, cursorForMapTreeField(newContent));
 		},
 		remove: (index, count) => {
 			this.sequenceEditor().remove(index, count);
 		},
-		attach: (index, content) => {
-			const contentLocations: DetachedRootsLocation = content.map((node) => ({
-				field: fieldFromNode(node),
-				count: 1,
-			}));
-			this.sequenceEditor().attach(index, contentLocations);
-		},
 	};
 
-	private sequenceEditor(): SequenceFieldEditor<
-		ITreeCursorSynchronous,
-		DetachedRootsLocation
-	> {
+	private sequenceEditor(): SequenceFieldEditBuilder<ITreeCursorSynchronous> {
 		const fieldPath = this.getFieldPathForEditing();
 		return this.getEditor().sequenceField(fieldPath);
 	}
 }
 
 export class LazyValueField extends LazyField implements FlexTreeRequiredField {
-	public editor: RequiredFieldEditor<FlexibleNodeContent, FlexTreeNode> = {
+	public editor: ValueFieldEditBuilder<FlexibleNodeContent> = {
 		set: (newContent) => {
 			this.valueFieldEditor().set(cursorForMapTreeField([newContent]));
 		},
-		attach: (content) => {
-			const root = fieldFromNode(content);
-			this.valueFieldEditor().attach(root);
-		},
 	};
 
-	private valueFieldEditor(): RequiredFieldEditor<
-		ITreeCursorSynchronous,
-		DetachedRootLocation
-	> {
+	private valueFieldEditor(): ValueFieldEditBuilder<ITreeCursorSynchronous> {
 		const fieldPath = this.getFieldPathForEditing();
-		return this.getEditor().valueField(fieldPath);
+		const fieldEditor = this.getEditor().valueField(fieldPath);
+		return fieldEditor;
 	}
 
 	public get content(): FlexTreeUnknownUnboxed {
@@ -333,27 +301,16 @@ export class LazyValueField extends LazyField implements FlexTreeRequiredField {
 }
 
 export class LazyOptionalField extends LazyField implements FlexTreeOptionalField {
-	public editor: OptionalFieldEditor<MinimalMapTreeNodeView, FlexTreeNode> = {
+	public editor: OptionalFieldEditBuilder<ExclusiveMapTree> = {
 		set: (newContent, wasEmpty) => {
 			this.optionalEditor().set(
-				newContent !== undefined ? cursorForMapTreeField([newContent]) : newContent,
+				newContent === undefined ? newContent : cursorForMapTreeField([newContent]),
 				wasEmpty,
 			);
 		},
-		attach: (content, wasEmpty) => {
-			if (content === undefined) {
-				this.optionalEditor().clear(wasEmpty);
-			} else {
-				const root = fieldFromNode(content);
-				this.optionalEditor().attach(root, wasEmpty);
-			}
-		},
-		clear: (wasEmpty) => {
-			this.optionalEditor().clear(wasEmpty);
-		},
 	};
 
-	private optionalEditor(): OptionalFieldEditor<ITreeCursorSynchronous, DetachedRootLocation> {
+	private optionalEditor(): OptionalFieldEditBuilder<ITreeCursorSynchronous> {
 		const fieldPath = this.getFieldPathForEditing();
 		const fieldEditor = this.getEditor().optionalField(fieldPath);
 		return fieldEditor;
@@ -401,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/forest-summary/codec.ts

@@ -5,35 +5,49 @@
 
 import { assert, oob } from "@fluidframework/core-utils/internal";
 import type { MinimumVersionForCollab } from "@fluidframework/runtime-definitions/internal";
+import {
+	getConfigForMinVersionForCollab,
+	lowestMinVersionForCollab,
+} from "@fluidframework/runtime-utils/internal";
 
 import {
 	type CodecTree,
 	type CodecWriteOptions,
+	FluidClientVersion,
 	type IJsonCodec,
 	makeVersionedValidatedCodec,
 } from "../../codec/index.js";
 import type { FieldKey, ITreeCursorSynchronous } from "../../core/index.js";
 import type { FieldBatchCodec, FieldBatchEncodingContext } from "../chunked-forest/index.js";
 
-import { FormatV1, ForestFormatVersion } from "./format.js";
+import {
+	ForestFormatVersion,
+	validVersions,
+	type Format,
+	FormatCommon,
+} from "./formatCommon.js";
 import { brand } from "../../util/index.js";
 
 /**
  * Uses field cursors
  */
 export type FieldSet = ReadonlyMap<FieldKey, ITreeCursorSynchronous>;
-export type ForestCodec = IJsonCodec<FieldSet, FormatV1, FormatV1, FieldBatchEncodingContext>;
+export type ForestCodec = IJsonCodec<FieldSet, Format, Format, FieldBatchEncodingContext>;
 
 /**
  * Convert a MinimumVersionForCollab to a ForestFormatVersion.
  * @param clientVersion - The MinimumVersionForCollab to convert.
  * @returns The ForestFormatVersion that corresponds to the provided MinimumVersionForCollab.
  */
-function clientVersionToForestSummaryFormatVersion(
+export function clientVersionToForestFormatVersion(
 	clientVersion: MinimumVersionForCollab,
 ): ForestFormatVersion {
-	// Currently, forest summary codec only writes in version 1.
-	return brand(ForestFormatVersion.v1);
+	return brand(
+		getConfigForMinVersionForCollab(clientVersion, {
+			[lowestMinVersionForCollab]: ForestFormatVersion.v1,
+			[FluidClientVersion.v2_74]: ForestFormatVersion.v2,
+		}),
+	);
 }
 
 export function makeForestSummarizerCodec(
@@ -41,12 +55,10 @@ export function makeForestSummarizerCodec(
 	fieldBatchCodec: FieldBatchCodec,
 ): ForestCodec {
 	const inner = fieldBatchCodec;
-	// TODO: AB#41865
-	// This needs to be updated to support multiple versions.
-	// The second version will be used to enable incremental summarization.
-	const writeVersion = clientVersionToForestSummaryFormatVersion(options.minVersionForCollab);
-	return makeVersionedValidatedCodec(options, new Set([ForestFormatVersion.v1]), FormatV1, {
-		encode: (data: FieldSet, context: FieldBatchEncodingContext): FormatV1 => {
+	const writeVersion = clientVersionToForestFormatVersion(options.minVersionForCollab);
+	const formatSchema = FormatCommon(writeVersion);
+	return makeVersionedValidatedCodec(options, validVersions, formatSchema, {
+		encode: (data: FieldSet, context: FieldBatchEncodingContext): Format => {
 			const keys: FieldKey[] = [];
 			const fields: ITreeCursorSynchronous[] = [];
 			for (const [key, value] of data) {
@@ -55,7 +67,7 @@ export function makeForestSummarizerCodec(
 			}
 			return { keys, fields: inner.encode(fields, context), version: writeVersion };
 		},
-		decode: (data: FormatV1, context: FieldBatchEncodingContext): FieldSet => {
+		decode: (data: Format, context: FieldBatchEncodingContext): FieldSet => {
 			const out: Map<FieldKey, ITreeCursorSynchronous> = new Map();
 			const fields = inner.decode(data.fields, context);
 			assert(data.keys.length === fields.length, 0x891 /* mismatched lengths */);
@@ -70,5 +82,5 @@ export function makeForestSummarizerCodec(
 export function getCodecTreeForForestFormat(
 	clientVersion: MinimumVersionForCollab,
 ): CodecTree {
-	return { name: "Forest", version: clientVersionToForestSummaryFormatVersion(clientVersion) };
+	return { name: "Forest", version: clientVersionToForestFormatVersion(clientVersion) };
 }