@fluidframework/tree 2.90.0-378676 → 2.91.0

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

@@ -7,13 +7,14 @@ import { fail } from "@fluidframework/core-utils/internal";
 
 import type { CodecTree } from "../../codec/index.js";
 import {
-	type DeltaFieldChanges,
+	type DeltaDetachedNodeId,
 	type FieldKindIdentifier,
 	forbiddenFieldKindIdentifier,
 	Multiplicity,
 } from "../../core/index.js";
 import { identifierFieldIdentifier } from "../fieldKindIdentifiers.js";
 import {
+	type FieldChangeDelta,
 	type FieldChangeHandler,
 	type FieldEditor,
 	type FieldKindConfiguration,
@@ -41,12 +42,12 @@ export const noChangeHandler: FieldChangeHandler<0> = {
 	}),
 	codecsFactory: () => noChangeCodecFamily,
 	editor: { buildChildChanges: () => fail(0xb0d /* Child changes not supported */) },
-	intoDelta: (change, deltaFromChild: ToDelta): DeltaFieldChanges => ({ marks: [] }),
+	intoDelta: (change, deltaFromChild: ToDelta): FieldChangeDelta => ({}),
+	relevantRemovedRoots: (change): Iterable<DeltaDetachedNodeId> => [],
 	isEmpty: (change: 0) => true,
 	getNestedChanges: (change: 0) => [],
 	createEmpty: () => 0,
 	getCrossFieldKeys: () => [],
-	getDetachCellIds: () => [],
 };
 
 /**
@@ -137,16 +138,6 @@ export const fieldKindConfigurations: ReadonlyMap<
 			[identifier.identifier, { kind: identifier, formatVersion: 1 }],
 		]),
 	],
-	[
-		ModularChangeFormatVersion.vDetachedRoots,
-		new Map<FieldKindIdentifier, FieldKindConfigurationEntry>([
-			[required.identifier, { kind: required, formatVersion: 2 }],
-			[optional.identifier, { kind: optional, formatVersion: 3 }],
-			[sequence.identifier, { kind: sequence, formatVersion: 2 }],
-			[forbidden.identifier, { kind: forbidden, formatVersion: 1 }],
-			[identifier.identifier, { kind: identifier, formatVersion: 1 }],
-		]),
-	],
 ]);
 
 export function getCodecTreeForModularChangeFormat(

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

@@ -13,25 +13,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,
 	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(

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(false);
-		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,
@@ -26,21 +27,18 @@ import { combineChunks } from "../chunked-forest/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,
@@ -54,7 +52,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";
 
 /**
@@ -232,28 +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();
-			}
-			// ...or are under a node in the document
-			if (this.parent !== undefined) {
-				const status = treeStatusFromAnchorCache(this.parent.anchorNode);
-				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 fields with TreeStatus.InDocument status");
 	}
 
-	protected getEditor(): DataEditor<
-		ITreeCursorSynchronous,
-		DetachedRootLocation,
-		DetachedRootsLocation
-	> {
+	protected getEditor(): IDefaultEditBuilder<ITreeCursorSynchronous> {
 		return new MappedEditBuilder(
 			this.context.checkout.editor,
 			(cursor: ITreeCursorSynchronous) =>
@@ -262,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);
@@ -281,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 {
@@ -331,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 ? 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;

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

@@ -22,8 +22,25 @@ import type { FlexTreeNode } from "./flexTreeTypes.js";
  * See {@link withObservation} and {@link currentObserver}.
  */
 export interface Observer {
+	/**
+	 * Arbitrary content in `node` subtree might be observed.
+	 */
+	observeNodeDeep(node: FlexTreeNode): void;
+	/**
+	 * Which fields exist (as non-empty) on `node` is being observed.
+	 * @remarks
+	 * The set of fields should be considered order independent.
+	 */
 	observeNodeFields(node: FlexTreeNode): void;
+	/**
+	 * The contents of the `key` field of `node` are being observed.
+	 * @remarks
+	 * Any (shallow) change to which children exist in this field, or in what order should invalidate this observation.
+	 */
 	observeNodeField(node: FlexTreeNode, key: FieldKey): void;
+	/**
+	 * The parent of `node` is being observed.
+	 */
 	observeParentOf(node: FlexTreeNode): void;
 }
 

package/src/feature-libraries/forest-summary/codec.ts

@@ -4,89 +4,79 @@
  */
 
 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 } from "@sinclair/typebox";
+import { lowestMinVersionForCollab } from "@fluidframework/runtime-utils/internal";
 
 import {
-	type CodecTree,
+	ClientVersionDispatchingCodecBuilder,
+	type CodecAndSchema,
 	type CodecWriteOptions,
 	FluidClientVersion,
-	type IJsonCodec,
-	makeVersionedValidatedCodec,
 } from "../../codec/index.js";
 import type { FieldKey, ITreeCursorSynchronous } from "../../core/index.js";
-import { brand, type JsonCompatibleReadOnly } from "../../util/index.js";
-import type { FieldBatchCodec, FieldBatchEncodingContext } from "../chunked-forest/index.js";
+import {
+	fieldBatchCodecBuilder,
+	type FieldBatchEncodingContext,
+} from "../chunked-forest/index.js";
 
-import { ForestFormatVersion, validVersions, type Format } from "./formatCommon.js";
-import { FormatV1 } from "./formatV1.js";
-import { FormatV2 } from "./formatV2.js";
+import { ForestFormatVersion, FormatCommon } from "./formatCommon.js";
 
 /**
  * Uses field cursors
  */
 export type FieldSet = ReadonlyMap<FieldKey, ITreeCursorSynchronous>;
-export type ForestCodec = IJsonCodec<
-	FieldSet,
-	Format,
-	JsonCompatibleReadOnly,
-	FieldBatchEncodingContext
->;
+export type ForestCodec = ReturnType<typeof forestCodecBuilder.build>;
 
-/**
- * Convert a MinimumVersionForCollab to a ForestFormatVersion.
- * @param clientVersion - The MinimumVersionForCollab to convert.
- * @returns The ForestFormatVersion that corresponds to the provided MinimumVersionForCollab.
- */
-export function clientVersionToForestFormatVersion(
-	clientVersion: MinimumVersionForCollab,
-): ForestFormatVersion {
-	return brand(
-		getConfigForMinVersionForCollab(clientVersion, {
-			[lowestMinVersionForCollab]: ForestFormatVersion.v1,
-			[FluidClientVersion.v2_74]: ForestFormatVersion.v2,
-		}),
-	);
-}
-
-export function makeForestSummarizerCodec(
+function makeForestSummarizerCodec(
 	options: CodecWriteOptions,
-	fieldBatchCodec: FieldBatchCodec,
-): ForestCodec {
-	const inner = fieldBatchCodec;
-	const writeVersion = clientVersionToForestFormatVersion(options.minVersionForCollab);
-	const formatSchema = Type.Union([FormatV1, FormatV2]);
-	// Both the encode and decode logic here support both v1 and v2, as does `validVersions` and `formatSchema`.
-	// This makes this use of makeVersionedValidatedCodec atypical as it is a single call being used to make a codec that supports all versions,
-	// instead of one call per version, then using another utility to select between them based on version.
-	return makeVersionedValidatedCodec(options, validVersions, formatSchema, {
-		encode: (data: FieldSet, context: FieldBatchEncodingContext): Format => {
+	version: ForestFormatVersion,
+): CodecAndSchema<FieldSet, FieldBatchEncodingContext> {
+	// Performance: Since multiple places (including multiple versions of this codec) use the field batch codec,
+	// we may end up with multiple copies of it, including compiling its format validation multiple times.
+	// This is not ideal, but is not too bad as it is a small fixed number of copies and thus should not be too expensive.
+	// If this becomes problematic a cache could be added for options to codec instances somewhere.
+	const fieldBatchCodec = fieldBatchCodecBuilder.build(options);
+	const formatSchema = FormatCommon;
+	return {
+		encode: (data: FieldSet, context: FieldBatchEncodingContext): FormatCommon => {
 			const keys: FieldKey[] = [];
 			const fields: ITreeCursorSynchronous[] = [];
 			for (const [key, value] of data) {
 				keys.push(key);
 				fields.push(value);
 			}
-			return { keys, fields: inner.encode(fields, context), version: writeVersion };
+			return {
+				keys,
+				fields: fieldBatchCodec.encode(fields, context),
+				version,
+			};
 		},
-		decode: (data: Format, context: FieldBatchEncodingContext): FieldSet => {
+		decode: (data: FormatCommon, context: FieldBatchEncodingContext): FieldSet => {
 			const out: Map<FieldKey, ITreeCursorSynchronous> = new Map();
-			const fields = inner.decode(data.fields, context);
+			const fields = fieldBatchCodec.decode(data.fields, context);
 			assert(data.keys.length === fields.length, 0x891 /* mismatched lengths */);
 			for (const [index, field] of fields.entries()) {
 				out.set(data.keys[index] ?? oob(), field);
 			}
 			return out;
 		},
-	});
+		schema: formatSchema,
+	};
 }
 
-export function getCodecTreeForForestFormat(
-	clientVersion: MinimumVersionForCollab,
-): CodecTree {
-	return { name: "Forest", version: clientVersionToForestFormatVersion(clientVersion) };
-}
+/**
+ * {@link ClientVersionDispatchingCodecBuilder} for forest summarizer codecs.
+ */
+export const forestCodecBuilder = ClientVersionDispatchingCodecBuilder.build("Forest", [
+	{
+		minVersionForCollab: lowestMinVersionForCollab,
+		formatVersion: ForestFormatVersion.v1,
+		codec: (options: CodecWriteOptions) =>
+			makeForestSummarizerCodec(options, ForestFormatVersion.v1),
+	},
+	{
+		minVersionForCollab: FluidClientVersion.v2_74,
+		formatVersion: ForestFormatVersion.v2,
+		codec: (options: CodecWriteOptions) =>
+			makeForestSummarizerCodec(options, ForestFormatVersion.v2),
+	},
+]);

package/src/feature-libraries/forest-summary/forestSummarizer.ts

@@ -41,18 +41,12 @@ import {
 import { chunkFieldSingle, defaultChunkPolicy } from "../chunked-forest/chunkTree.js";
 import {
 	defaultIncrementalEncodingPolicy,
-	type FieldBatchCodec,
 	type FieldBatchEncodingContext,
 	type IncrementalEncodingPolicy,
 } from "../chunked-forest/index.js";
 import { TreeCompressionStrategy } from "../treeCompressionUtils.js";
 
-import {
-	clientVersionToForestFormatVersion,
-	type ForestCodec,
-	makeForestSummarizerCodec,
-} from "./codec.js";
-import { ForestFormatVersion } from "./formatCommon.js";
+import { forestCodecBuilder, type ForestCodec } from "./codec.js";
 import {
 	ForestIncrementalSummaryBehavior,
 	ForestIncrementalSummaryBuilder,
@@ -85,7 +79,6 @@ export class ForestSummarizer
 	public constructor(
 		private readonly forest: IEditableForest,
 		private readonly revisionTagCodec: RevisionTagCodec,
-		fieldBatchCodec: FieldBatchCodec,
 		private readonly encoderContext: FieldBatchEncodingContext,
 		options: CodecWriteOptions,
 		private readonly idCompressor: IIdCompressor,
@@ -99,11 +92,8 @@ export class ForestSummarizer
 			true /* supportPreVersioningFormat */,
 		);
 
-		this.codec = makeForestSummarizerCodec(options, fieldBatchCodec);
+		this.codec = forestCodecBuilder.build(options);
 
-		const forestFormatWriteVersion = clientVersionToForestFormatVersion(
-			options.minVersionForCollab,
-		);
 		const summaryFormatWriteVersion = minVersionToForestSummaryFormatVersion(
 			options.minVersionForCollab,
 		);
@@ -111,9 +101,10 @@ export class ForestSummarizer
 			summaryFormatWriteVersion,
 		);
 
-		// Incremental summary is supported from ForestFormatVersion.v2 and ForestSummaryFormatVersion.v3 onwards.
+		// Incremental summary is supported in ForestSummaryFormatVersion.v3 onwards.
+		// Note that even in versions that support it, it is possible that the
+		// FieldBatchCodec will not use incremental encoding (for example if using its v1 formats which does not support it).
 		const enableIncrementalSummary =
-			forestFormatWriteVersion >= ForestFormatVersion.v2 &&
 			summaryFormatWriteVersion >= ForestSummaryFormatVersion.v3 &&
 			encoderContext.encodeType === TreeCompressionStrategy.CompressedIncremental;
 		this.incrementalSummaryBuilder = new ForestIncrementalSummaryBuilder(