@fluidframework/tree 2.74.0-370705 → 2.80.0

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

@@ -3,645 +3,670 @@
  * Licensed under the MIT License.
  */
 
-import { assert, fail, oob } from "@fluidframework/core-utils/internal";
+import { assert, oob, fail } from "@fluidframework/core-utils/internal";
+import type { TAnySchema } from "@sinclair/typebox";
+
 import {
-	extractJsonValidator,
-	withSchemaValidation,
 	type ICodecOptions,
 	type IJsonCodec,
 	type IMultiFormatCodec,
 	type SchemaValidationFunction,
+	extractJsonValidator,
+	withSchemaValidation,
 } from "../../codec/index.js";
-import {
-	newChangeAtomIdTransform,
-	type ChangeAtomId,
-	type ChangeAtomIdRangeMap,
-	type ChangeEncodingContext,
-	type ChangesetLocalId,
-	type EncodedRevisionTag,
-	type FieldKey,
-	type FieldKindIdentifier,
-	type ITreeCursorSynchronous,
-	type RevisionInfo,
-	type RevisionTag,
+import type {
+	ChangeEncodingContext,
+	ChangesetLocalId,
+	EncodedRevisionTag,
+	FieldKey,
+	FieldKindIdentifier,
+	ITreeCursorSynchronous,
+	RevisionInfo,
+	RevisionTag,
 } from "../../core/index.js";
 import {
-	brand,
-	idAllocatorFromMaxId,
-	newTupleBTree,
 	type IdAllocator,
 	type JsonCompatibleReadOnly,
 	type Mutable,
-	type RangeQueryEntry,
-	type RangeQueryResult,
-	type TupleBTree,
+	brand,
+	idAllocatorFromMaxId,
+	newTupleBTree,
 } from "../../util/index.js";
 import {
-	chunkFieldSingle,
-	defaultChunkPolicy,
 	type FieldBatchCodec,
 	type TreeChunk,
+	chunkFieldSingle,
+	defaultChunkPolicy,
 } from "../chunked-forest/index.js";
 import { TreeCompressionStrategy } from "../treeCompressionUtils.js";
+
+import type { FieldChangeEncodingContext, FieldChangeHandler } from "./fieldChangeHandler.js";
 import type {
 	FieldKindConfiguration,
 	FieldKindConfigurationEntry,
 } from "./fieldKindConfiguration.js";
+import { genericFieldKind } from "./genericFieldKind.js";
 import {
-	addNodeRename,
-	getFirstAttachField,
-	getFirstDetachField,
-	newRootTable,
-	type FieldIdKey,
-} from "./modularChangeFamily.js";
-import {
-	newCrossFieldRangeTable,
-	setInChangeAtomIdMap,
-	type ChangeAtomIdBTree,
-	type CrossFieldKeyTable,
-	type FieldChangeMap,
-	type FieldChangeset,
-	type FieldId,
-	type ModularChangeset,
-	type NodeChangeset,
-	type NodeId,
-	type NodeLocation,
-	type RootNodeTable,
-} from "./modularChangeTypes.js";
-import {
-	EncodedModularChangeset,
 	type EncodedBuilds,
 	type EncodedBuildsArray,
 	type EncodedFieldChange,
 	type EncodedFieldChangeMap,
+	EncodedModularChangesetV1,
 	type EncodedNodeChangeset,
 	type EncodedRevisionInfo,
 } from "./modularChangeFormatV1.js";
-import type { FieldChangeEncodingContext, FieldChangeHandler } from "./fieldChangeHandler.js";
-import { genericFieldKind } from "./genericFieldKind.js";
-import type { TAnySchema } from "@sinclair/typebox";
+import {
+	type FieldChangeset,
+	newCrossFieldKeyTable,
+	type FieldChangeMap,
+	type FieldId,
+	type ModularChangeset,
+	type NodeChangeset,
+	type NodeId,
+} from "./modularChangeTypes.js";
+import type { ChangeAtomIdBTree } from "../changeAtomIdBTree.js";
 
-export type ModularChangeCodec = IJsonCodec<
+type ModularChangeCodec = IJsonCodec<
 	ModularChangeset,
-	EncodedModularChangeset,
-	EncodedModularChangeset,
+	EncodedModularChangesetV1,
+	EncodedModularChangesetV1,
 	ChangeEncodingContext
 >;
 
-export type FieldCodec = IMultiFormatCodec<
+type FieldCodec = IMultiFormatCodec<
 	FieldChangeset,
 	JsonCompatibleReadOnly,
 	JsonCompatibleReadOnly,
 	FieldChangeEncodingContext
 >;
 
-export function makeModularChangeCodecV1(
-	fieldKinds: FieldKindConfiguration,
-	revisionTagCodec: IJsonCodec<
-		RevisionTag,
-		EncodedRevisionTag,
-		EncodedRevisionTag,
-		ChangeEncodingContext
-	>,
-	fieldsCodec: FieldBatchCodec,
-	codecOptions: ICodecOptions,
-	chunkCompressionStrategy: TreeCompressionStrategy = TreeCompressionStrategy.Compressed,
-): ModularChangeCodec {
-	// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
-	const getMapEntry = ({ kind, formatVersion }: FieldKindConfigurationEntry) => {
-		const codec = kind.changeHandler.codecsFactory(revisionTagCodec).resolve(formatVersion);
-		return {
-			codec,
-			compiledSchema: codec.json.encodedSchema
-				? extractJsonValidator(codecOptions.jsonValidator).compile(codec.json.encodedSchema)
-				: undefined,
-		};
-	};
+type FieldChangesetCodecs = Map<
+	FieldKindIdentifier,
+	{
+		compiledSchema?: SchemaValidationFunction<TAnySchema>;
+		codec: FieldCodec;
+	}
+>;
 
-	/**
-	 * The codec version for the generic field kind.
-	 */
-	const genericFieldKindFormatVersion = 1;
-	const fieldChangesetCodecs: Map<
-		FieldKindIdentifier,
-		{
-			compiledSchema?: SchemaValidationFunction<TAnySchema>;
-			codec: FieldCodec;
-		}
-	> = new Map([
-		[
-			genericFieldKind.identifier,
-			getMapEntry({ kind: genericFieldKind, formatVersion: genericFieldKindFormatVersion }),
-		],
-	]);
+export function getFieldChangesetCodec(
+	fieldKind: FieldKindIdentifier,
+	fieldChangesetCodecs: FieldChangesetCodecs,
+): {
+	compiledSchema?: SchemaValidationFunction<TAnySchema>;
+	codec: FieldCodec;
+} {
+	const entry = fieldChangesetCodecs.get(fieldKind);
+	assert(entry !== undefined, 0x5ea /* Tried to encode unsupported fieldKind */);
+	return entry;
+}
 
-	fieldKinds.forEach((entry, identifier) => {
-		fieldChangesetCodecs.set(identifier, getMapEntry(entry));
-	});
+export function encodeFieldChangesForJson(
+	change: FieldChangeMap,
+	context: ChangeEncodingContext,
+	nodeChanges: ChangeAtomIdBTree<NodeChangeset>,
+	fieldChangesetCodecs: FieldChangesetCodecs,
+): EncodedFieldChangeMap {
+	const fieldContext: FieldChangeEncodingContext = {
+		baseContext: context,
+
+		encodeNode: (nodeId: NodeId): EncodedNodeChangeset => {
+			const node = nodeChanges.get([nodeId.revision, nodeId.localId]);
+			assert(node !== undefined, 0x92e /* Unknown node ID */);
+			return encodeNodeChangesForJson(node, fieldContext, fieldChangesetCodecs);
+		},
 
-	const getFieldChangesetCodec = (
-		fieldKind: FieldKindIdentifier,
-	): {
-		compiledSchema?: SchemaValidationFunction<TAnySchema>;
-		codec: FieldCodec;
-	} => {
-		const entry = fieldChangesetCodecs.get(fieldKind);
-		assert(entry !== undefined, 0x5ea /* Tried to encode unsupported fieldKind */);
-		return entry;
+		decodeNode: () => fail(0xb1e /* Should not decode nodes during field encoding */),
 	};
 
-	function encodeFieldChangesForJson(
-		change: FieldChangeMap,
-		parentId: NodeId | undefined,
-		fieldToRoots: FieldRootMap,
-		context: ChangeEncodingContext,
-		encodeNode: NodeEncoder,
-		getInputRootId: ChangeAtomMappingQuery,
-		isAttachId: ChangeAtomIdRangeQuery,
-		isDetachId: ChangeAtomIdRangeQuery,
-	): EncodedFieldChangeMap {
-		const encodedFields: EncodedFieldChangeMap = [];
-
-		for (const [field, fieldChange] of change) {
-			const { codec, compiledSchema } = getFieldChangesetCodec(fieldChange.fieldKind);
-			const rootChanges = fieldToRoots.get([parentId?.revision, parentId?.localId, field]);
-
-			const fieldContext: FieldChangeEncodingContext = {
-				baseContext: context,
-				rootNodeChanges: rootChanges?.nodeChanges ?? newTupleBTree(),
-				rootRenames: rootChanges?.renames ?? newChangeAtomIdTransform(),
-
-				encodeNode,
-				getInputRootId,
-				isAttachId,
-				isDetachId,
-				decodeNode: () => fail(0xb1e /* Should not decode nodes during field encoding */),
-				decodeRootNodeChange: () => fail("Should not be called during encoding"),
-				decodeRootRename: () => fail("Should not be called during encoding"),
-				decodeMoveAndDetach: () => fail("Should not be called during encoding"),
-				generateId: () => fail("Should not be called during encoding"),
-			};
+	return encodeFieldChangesForJsonI(change, fieldContext, fieldChangesetCodecs);
+}
 
-			const encodedChange = codec.json.encode(fieldChange.change, fieldContext);
-			if (compiledSchema !== undefined && !compiledSchema.check(encodedChange)) {
-				fail(0xb1f /* Encoded change didn't pass schema validation. */);
-			}
+export function encodeFieldChangesForJsonI(
+	change: FieldChangeMap,
+	context: FieldChangeEncodingContext,
+	fieldChangesetCodecs: FieldChangesetCodecs,
+): EncodedFieldChangeMap {
+	const encodedFields: EncodedFieldChangeMap = [];
+
+	for (const [field, fieldChange] of change) {
+		const { codec, compiledSchema } = getFieldChangesetCodec(
+			fieldChange.fieldKind,
+			fieldChangesetCodecs,
+		);
+		const encodedChange = codec.json.encode(fieldChange.change, context);
+		if (compiledSchema !== undefined && !compiledSchema.check(encodedChange)) {
+			fail(0xb1f /* Encoded change didn't pass schema validation. */);
+		}
 
-			const fieldKey: FieldKey = field;
-			const encodedField: EncodedFieldChange = {
-				fieldKey,
-				fieldKind: fieldChange.fieldKind,
-				change: encodedChange,
-			};
+		const fieldKey: FieldKey = field;
+		const encodedField: EncodedFieldChange = {
+			fieldKey,
+			fieldKind: fieldChange.fieldKind,
+			change: encodedChange,
+		};
 
-			encodedFields.push(encodedField);
-		}
+		encodedFields.push(encodedField);
+	}
+
+	return encodedFields;
+}
 
-		return encodedFields;
+export function encodeNodeChangesForJson(
+	change: NodeChangeset,
+	context: FieldChangeEncodingContext,
+	fieldChangesetCodecs: FieldChangesetCodecs,
+): EncodedNodeChangeset {
+	const encodedChange: EncodedNodeChangeset = {};
+	// Note: revert constraints are ignored for now because they would only be needed if we supported reverting changes made by peers.
+	const { fieldChanges, nodeExistsConstraint } = change;
+
+	if (fieldChanges !== undefined) {
+		encodedChange.fieldChanges = encodeFieldChangesForJsonI(
+			fieldChanges,
+			context,
+			fieldChangesetCodecs,
+		);
 	}
 
-	function encodeNodeChangesForJson(
-		change: NodeChangeset,
-		id: NodeId,
-		fieldToRoots: FieldRootMap,
-		context: ChangeEncodingContext,
-		encodeNode: NodeEncoder,
-		getInputRootId: ChangeAtomMappingQuery,
-		isAttachId: ChangeAtomIdRangeQuery,
-		isDetachId: ChangeAtomIdRangeQuery,
-	): EncodedNodeChangeset {
-		const encodedChange: EncodedNodeChangeset = {};
-		// Note: revert constraints are ignored for now because they would only be needed if we supported reverting changes made by peers.
-		const { fieldChanges, nodeExistsConstraint } = change;
-
-		if (fieldChanges !== undefined) {
-			encodedChange.fieldChanges = encodeFieldChangesForJson(
-				fieldChanges,
-				id,
-				fieldToRoots,
-				context,
-				encodeNode,
-				getInputRootId,
-				isAttachId,
-				isDetachId,
-			);
-		}
+	if (nodeExistsConstraint !== undefined) {
+		encodedChange.nodeExistsConstraint = nodeExistsConstraint;
+	}
+
+	return encodedChange;
+}
 
-		if (nodeExistsConstraint !== undefined) {
-			encodedChange.nodeExistsConstraint = nodeExistsConstraint;
+export function decodeFieldChangesFromJson(
+	encodedChange: EncodedFieldChangeMap,
+	parentId: NodeId | undefined,
+	decoded: ModularChangeset,
+	context: ChangeEncodingContext,
+	idAllocator: IdAllocator,
+	fieldKinds: FieldKindConfiguration,
+	fieldChangesetCodecs: FieldChangesetCodecs,
+): FieldChangeMap {
+	const decodedFields: FieldChangeMap = new Map();
+	for (const field of encodedChange) {
+		const { codec, compiledSchema } = getFieldChangesetCodec(
+			field.fieldKind,
+			fieldChangesetCodecs,
+		);
+		if (compiledSchema !== undefined && !compiledSchema.check(field.change)) {
+			fail(0xb20 /* Encoded change didn't pass schema validation. */);
 		}
 
-		return encodedChange;
-	}
+		const fieldId: FieldId = {
+			nodeId: parentId,
+			field: field.fieldKey,
+		};
 
-	function decodeFieldChangesFromJson(
-		encodedChange: EncodedFieldChangeMap,
-		parentId: NodeId | undefined,
-		decodedCrossFieldKeys: CrossFieldKeyTable,
-		decodedRootTable: RootNodeTable,
-		context: ChangeEncodingContext,
-		decodeNode: NodeDecoder,
-		idAllocator: IdAllocator,
-	): FieldChangeMap {
-		const decodedFields: FieldChangeMap = new Map();
-		for (const field of encodedChange) {
-			const { codec, compiledSchema } = getFieldChangesetCodec(field.fieldKind);
-			if (compiledSchema !== undefined && !compiledSchema.check(field.change)) {
-				fail(0xb20 /* Encoded change didn't pass schema validation. */);
-			}
+		const fieldContext: FieldChangeEncodingContext = {
+			baseContext: context,
 
-			const fieldId: FieldId = {
-				nodeId: parentId,
-				field: field.fieldKey,
-			};
+			encodeNode: () => fail(0xb21 /* Should not encode nodes during field decoding */),
 
-			const fieldContext: FieldChangeEncodingContext = {
-				baseContext: context,
-				rootNodeChanges: newTupleBTree(),
-				rootRenames: newChangeAtomIdTransform(),
-
-				encodeNode: () => fail(0xb21 /* Should not encode nodes during field decoding */),
-				getInputRootId: () => fail("Should not query during decoding"),
-				isAttachId: () => fail("Should not query during decoding"),
-				isDetachId: () => fail("Should not query during decoding"),
-
-				decodeNode: (encodedNode: EncodedNodeChangeset): NodeId => {
-					return decodeNode(encodedNode, { field: fieldId });
-				},
-
-				decodeRootNodeChange: (detachId, encodedNode): void => {
-					setInChangeAtomIdMap(
-						decodedRootTable.nodeChanges,
-						detachId,
-						decodeNode(encodedNode, { root: detachId }),
-					);
-					decodedRootTable.detachLocations.set(detachId, 1, fieldId);
-				},
-
-				decodeRootRename: (oldId, newId, count): void => {
-					addNodeRename(decodedRootTable, oldId, newId, count, fieldId);
-				},
-
-				decodeMoveAndDetach: (detachId, count): void => {
-					decodedRootTable.outputDetachLocations.set(detachId, count, fieldId);
-				},
-
-				generateId: (): ChangeAtomId => ({
+			decodeNode: (encodedNode: EncodedNodeChangeset): NodeId => {
+				const nodeId: NodeId = {
 					revision: context.revision,
 					localId: brand(idAllocator.allocate()),
-				}),
-			};
+				};
 
-			const fieldChangeset = codec.json.decode(field.change, fieldContext);
+				const node = decodeNodeChangesetFromJson(
+					encodedNode,
+					nodeId,
+					decoded,
+					context,
+					idAllocator,
+					fieldKinds,
+					fieldChangesetCodecs,
+				);
 
-			const crossFieldKeys = getChangeHandler(fieldKinds, field.fieldKind).getCrossFieldKeys(
-				fieldChangeset,
-			);
+				decoded.nodeChanges.set([nodeId.revision, nodeId.localId], node);
+				decoded.nodeToParent.set([nodeId.revision, nodeId.localId], fieldId);
+				return nodeId;
+			},
+		};
 
-			for (const { key, count } of crossFieldKeys) {
-				decodedCrossFieldKeys.set(key, count, fieldId);
-			}
+		const fieldChangeset = codec.json.decode(field.change, fieldContext);
 
-			const fieldKey: FieldKey = brand<FieldKey>(field.fieldKey);
+		const crossFieldKeys = getChangeHandler(fieldKinds, field.fieldKind).getCrossFieldKeys(
+			fieldChangeset,
+		);
 
-			decodedFields.set(fieldKey, {
-				fieldKind: field.fieldKind,
-				change: brand(fieldChangeset),
-			});
+		for (const { key, count } of crossFieldKeys) {
+			decoded.crossFieldKeys.set(key, count, fieldId);
 		}
 
-		return decodedFields;
+		const fieldKey: FieldKey = brand<FieldKey>(field.fieldKey);
+
+		decodedFields.set(fieldKey, {
+			fieldKind: field.fieldKind,
+			change: brand(fieldChangeset),
+		});
 	}
 
-	function decodeNodeChangesetFromJson(
-		encodedChange: EncodedNodeChangeset,
-		id: NodeId,
-		decodedCrossFieldKeys: CrossFieldKeyTable,
-		decodedRootTable: RootNodeTable,
-		context: ChangeEncodingContext,
-		decodeNode: NodeDecoder,
-		idAllocator: IdAllocator,
-	): NodeChangeset {
-		const decodedChange: Mutable<NodeChangeset> = {};
-		const { fieldChanges, nodeExistsConstraint } = encodedChange;
-
-		if (fieldChanges !== undefined) {
-			decodedChange.fieldChanges = decodeFieldChangesFromJson(
-				fieldChanges,
-				id,
-				decodedCrossFieldKeys,
-				decodedRootTable,
-				context,
-				decodeNode,
-				idAllocator,
-			);
-		}
+	return decodedFields;
+}
 
-		if (nodeExistsConstraint !== undefined) {
-			decodedChange.nodeExistsConstraint = nodeExistsConstraint;
-		}
+export function decodeNodeChangesetFromJson(
+	encodedChange: EncodedNodeChangeset,
+	id: NodeId,
+	decoded: ModularChangeset,
+	context: ChangeEncodingContext,
+	idAllocator: IdAllocator,
+	fieldKinds: FieldKindConfiguration,
+	fieldChangesetCodecs: FieldChangesetCodecs,
+): NodeChangeset {
+	const decodedChange: NodeChangeset = {};
+	const { fieldChanges, nodeExistsConstraint } = encodedChange;
+
+	if (fieldChanges !== undefined) {
+		decodedChange.fieldChanges = decodeFieldChangesFromJson(
+			fieldChanges,
+			id,
+			decoded,
+			context,
+			idAllocator,
+			fieldKinds,
+			fieldChangesetCodecs,
+		);
+	}
 
-		return decodedChange;
+	if (nodeExistsConstraint !== undefined) {
+		decodedChange.nodeExistsConstraint = nodeExistsConstraint;
 	}
 
-	function encodeDetachedNodes(
-		detachedNodes: ChangeAtomIdBTree<TreeChunk> | undefined,
-		context: ChangeEncodingContext,
-	): EncodedBuilds | undefined {
-		if (detachedNodes === undefined) {
-			return undefined;
-		}
+	return decodedChange;
+}
 
-		const treesToEncode: ITreeCursorSynchronous[] = [];
-		const buildsArray: EncodedBuildsArray = [];
+export function encodeDetachedNodes(
+	detachedNodes: ChangeAtomIdBTree<TreeChunk> | undefined,
+	context: ChangeEncodingContext,
+	revisionTagCodec: IJsonCodec<
+		RevisionTag,
+		EncodedRevisionTag,
+		EncodedRevisionTag,
+		ChangeEncodingContext
+	>,
+	fieldsCodec: FieldBatchCodec,
+	chunkCompressionStrategy: TreeCompressionStrategy,
+): EncodedBuilds | undefined {
+	if (detachedNodes === undefined) {
+		return undefined;
+	}
 
-		let buildsForRevision:
-			| [[ChangesetLocalId, number][], EncodedRevisionTag]
-			| [[ChangesetLocalId, number][]]
-			| undefined;
+	const treesToEncode: ITreeCursorSynchronous[] = [];
+	const buildsArray: EncodedBuildsArray = [];
 
-		for (const [[revision, id], chunk] of detachedNodes.entries()) {
-			const encodedRevision = encodeRevisionOpt(revisionTagCodec, revision, context);
+	let buildsForRevision:
+		| [[ChangesetLocalId, number][], EncodedRevisionTag]
+		| [[ChangesetLocalId, number][]]
+		| undefined;
 
-			if (buildsForRevision === undefined || buildsForRevision[1] !== encodedRevision) {
-				if (buildsForRevision !== undefined) {
-					buildsArray.push(buildsForRevision);
-				}
+	for (const [[revision, id], chunk] of detachedNodes.entries()) {
+		const encodedRevision = encodeRevisionOpt(revisionTagCodec, revision, context);
 
-				buildsForRevision = encodedRevision !== undefined ? [[], encodedRevision] : [[]];
+		if (buildsForRevision === undefined || buildsForRevision[1] !== encodedRevision) {
+			if (buildsForRevision !== undefined) {
+				buildsArray.push(buildsForRevision);
 			}
 
-			treesToEncode.push(chunk.cursor());
-			const treeIndexInBatch = treesToEncode.length - 1;
-			buildsForRevision?.[0].push([id, treeIndexInBatch]);
+			buildsForRevision = encodedRevision === undefined ? [[]] : [[], encodedRevision];
 		}
 
-		if (buildsForRevision !== undefined) {
-			buildsArray.push(buildsForRevision);
-		}
+		treesToEncode.push(chunk.cursor());
+		const treeIndexInBatch = treesToEncode.length - 1;
+		buildsForRevision?.[0].push([id, treeIndexInBatch]);
+	}
 
-		return buildsArray.length === 0
-			? undefined
-			: {
-					builds: buildsArray,
-					trees: fieldsCodec.encode(treesToEncode, {
-						encodeType: chunkCompressionStrategy,
-						schema: context.schema,
-						originatorId: context.originatorId,
-						idCompressor: context.idCompressor,
-					}),
-				};
+	if (buildsForRevision !== undefined) {
+		buildsArray.push(buildsForRevision);
 	}
 
-	function decodeDetachedNodes(
-		encoded: EncodedBuilds | undefined,
-		context: ChangeEncodingContext,
-	): ChangeAtomIdBTree<TreeChunk> | undefined {
-		if (encoded === undefined || encoded.builds.length === 0) {
-			return undefined;
-		}
+	return buildsArray.length === 0
+		? undefined
+		: {
+				builds: buildsArray,
+				trees: fieldsCodec.encode(treesToEncode, {
+					encodeType: chunkCompressionStrategy,
+					schema: context.schema,
+					originatorId: context.originatorId,
+					idCompressor: context.idCompressor,
+				}),
+			};
+}
 
-		const chunks = fieldsCodec.decode(encoded.trees, {
-			encodeType: chunkCompressionStrategy,
-			originatorId: context.originatorId,
+export function decodeDetachedNodes(
+	encoded: EncodedBuilds | undefined,
+	context: ChangeEncodingContext,
+	revisionTagCodec: IJsonCodec<
+		RevisionTag,
+		EncodedRevisionTag,
+		EncodedRevisionTag,
+		ChangeEncodingContext
+	>,
+	fieldsCodec: FieldBatchCodec,
+	chunkCompressionStrategy: TreeCompressionStrategy,
+): ChangeAtomIdBTree<TreeChunk> | undefined {
+	if (encoded === undefined || encoded.builds.length === 0) {
+		return undefined;
+	}
+
+	const chunks = fieldsCodec.decode(encoded.trees, {
+		encodeType: chunkCompressionStrategy,
+		originatorId: context.originatorId,
+		idCompressor: context.idCompressor,
+	});
+	const getChunk = (index: number): TreeChunk => {
+		assert(index < chunks.length, 0x898 /* out of bounds index for build chunk */);
+		return chunkFieldSingle(chunks[index] ?? oob(), {
+			policy: defaultChunkPolicy,
 			idCompressor: context.idCompressor,
 		});
-		const getChunk = (index: number): TreeChunk => {
-			assert(index < chunks.length, 0x898 /* out of bounds index for build chunk */);
-			return chunkFieldSingle(chunks[index] ?? oob(), {
-				policy: defaultChunkPolicy,
-				idCompressor: context.idCompressor,
-			});
-		};
+	};
 
-		const map: ModularChangeset["builds"] = newTupleBTree();
-		encoded.builds.forEach((build) => {
-			// EncodedRevisionTag cannot be an array so this ensures that we can isolate the tuple
-			const revision =
-				build[1] === undefined ? context.revision : revisionTagCodec.decode(build[1], context);
+	const map: ModularChangeset["builds"] = newTupleBTree();
+	encoded.builds.forEach((build) => {
+		// EncodedRevisionTag cannot be an array so this ensures that we can isolate the tuple
+		const revision =
+			build[1] === undefined ? context.revision : revisionTagCodec.decode(build[1], context);
 
-			const decodedChunks: [ChangesetLocalId, TreeChunk][] = build[0].map(([i, n]) => [
-				i,
-				getChunk(n),
-			]);
+		const decodedChunks: [ChangesetLocalId, TreeChunk][] = build[0].map(([i, n]) => [
+			i,
+			getChunk(n),
+		]);
 
-			for (const [id, chunk] of decodedChunks) {
-				map.set([revision, id], chunk);
-			}
-		});
+		for (const [id, chunk] of decodedChunks) {
+			map.set([revision, id], chunk);
+		}
+	});
 
-		return map;
-	}
+	return map;
+}
 
-	type ChangeAtomMappingQuery = (
-		id: ChangeAtomId,
-		count: number,
-	) => RangeQueryResult<ChangeAtomId | undefined>;
-
-	type ChangeAtomIdRangeQuery = (id: ChangeAtomId, count: number) => RangeQueryResult<boolean>;
-	type NodeEncoder = (nodeId: NodeId) => EncodedNodeChangeset;
-	type NodeDecoder = (encoded: EncodedNodeChangeset, fieldId: NodeLocation) => NodeId;
-
-	function encodeRevisionInfos(
-		revisions: readonly RevisionInfo[],
-		context: ChangeEncodingContext,
-	): EncodedRevisionInfo[] | undefined {
-		if (context.revision !== undefined) {
-			assert(
-				revisions.length === 1 &&
-					revisions[0] !== undefined &&
-					revisions[0].revision === context.revision &&
-					revisions[0].rollbackOf === undefined,
-				0x964 /* A tagged change should only contain the tagged revision */,
-			);
-
-			return undefined;
-		}
+export function encodeRevisionInfos(
+	revisions: readonly RevisionInfo[],
+	context: ChangeEncodingContext,
+	revisionTagCodec: IJsonCodec<
+		RevisionTag,
+		EncodedRevisionTag,
+		EncodedRevisionTag,
+		ChangeEncodingContext
+	>,
+): EncodedRevisionInfo[] | undefined {
+	if (context.revision !== undefined) {
+		assert(
+			revisions.length === 1 &&
+				revisions[0] !== undefined &&
+				revisions[0].revision === context.revision &&
+				revisions[0].rollbackOf === undefined,
+			0x964 /* A tagged change should only contain the tagged revision */,
+		);
 
-		const encodedRevisions = [];
-		for (const revision of revisions) {
-			const encodedRevision: Mutable<EncodedRevisionInfo> = {
-				revision: revisionTagCodec.encode(revision.revision, context),
-			};
+		return undefined;
+	}
 
-			if (revision.rollbackOf !== undefined) {
-				encodedRevision.rollbackOf = revisionTagCodec.encode(revision.rollbackOf, context);
-			}
+	const encodedRevisions = [];
+	for (const revision of revisions) {
+		const encodedRevision: Mutable<EncodedRevisionInfo> = {
+			revision: revisionTagCodec.encode(revision.revision, context),
+		};
 
-			encodedRevisions.push(encodedRevision);
+		if (revision.rollbackOf !== undefined) {
+			encodedRevision.rollbackOf = revisionTagCodec.encode(revision.rollbackOf, context);
 		}
 
-		return encodedRevisions;
+		encodedRevisions.push(encodedRevision);
 	}
 
-	function decodeRevisionInfos(
-		revisions: readonly EncodedRevisionInfo[] | undefined,
-		context: ChangeEncodingContext,
-	): RevisionInfo[] | undefined {
-		if (revisions === undefined) {
-			return context.revision !== undefined ? [{ revision: context.revision }] : undefined;
-		}
+	return encodedRevisions;
+}
 
-		const decodedRevisions = [];
-		for (const revision of revisions) {
-			const decodedRevision: Mutable<RevisionInfo> = {
-				revision: revisionTagCodec.decode(revision.revision, context),
-			};
+export function decodeRevisionInfos(
+	revisions: readonly EncodedRevisionInfo[] | undefined,
+	context: ChangeEncodingContext,
+	revisionTagCodec: IJsonCodec<
+		RevisionTag,
+		EncodedRevisionTag,
+		EncodedRevisionTag,
+		ChangeEncodingContext
+	>,
+): RevisionInfo[] | undefined {
+	if (revisions === undefined) {
+		return context.revision === undefined ? undefined : [{ revision: context.revision }];
+	}
 
-			if (revision.rollbackOf !== undefined) {
-				decodedRevision.rollbackOf = revisionTagCodec.decode(revision.rollbackOf, context);
-			}
+	const decodedRevisions = [];
+	for (const revision of revisions) {
+		const decodedRevision: Mutable<RevisionInfo> = {
+			revision: revisionTagCodec.decode(revision.revision, context),
+		};
 
-			decodedRevisions.push(decodedRevision);
+		if (revision.rollbackOf !== undefined) {
+			decodedRevision.rollbackOf = revisionTagCodec.decode(revision.rollbackOf, context);
 		}
 
-		return decodedRevisions;
+		decodedRevisions.push(decodedRevision);
 	}
 
-	const modularChangeCodec: ModularChangeCodec = {
-		encode: (change, context) => {
-			const fieldToRoots = getFieldToRoots(change.rootNodes);
-			const isAttachId = (id: ChangeAtomId, count: number): RangeQueryResult<boolean> => {
-				const attachEntry = getFirstAttachField(change.crossFieldKeys, id, count);
-				return { ...attachEntry, value: attachEntry.value !== undefined };
-			};
-
-			const isDetachId = (
-				id: ChangeAtomId,
-				count: number,
-			): RangeQueryEntry<ChangeAtomId, boolean> => {
-				const detachEntry = getFirstDetachField(change.crossFieldKeys, id, count);
-				const renameEntry = change.rootNodes.oldToNewId.getFirst(id, detachEntry.length);
-				const isDetach = (detachEntry.value ?? renameEntry.value) !== undefined;
-				return { start: id, value: isDetach, length: renameEntry.length };
-			};
-
-			const getInputRootId = (
-				id: ChangeAtomId,
-				count: number,
-			): RangeQueryResult<ChangeAtomId | undefined> => {
-				return change.rootNodes.newToOldId.getFirst(id, count);
-			};
+	return decodedRevisions;
+}
 
-			const encodeNode = (nodeId: NodeId): EncodedNodeChangeset => {
-				// TODO: Handle node aliasing.
-				const node = change.nodeChanges.get([nodeId.revision, nodeId.localId]);
-				assert(node !== undefined, 0x92e /* Unknown node ID */);
-				return encodeNodeChangesForJson(
-					node,
-					nodeId,
-					fieldToRoots,
-					context,
-					encodeNode,
-					getInputRootId,
-					isAttachId,
-					isDetachId,
-				);
-			};
+export function encodeChange(
+	change: ModularChangeset,
+	context: ChangeEncodingContext,
+	fieldChangesetCodecs: Map<
+		FieldKindIdentifier,
+		{
+			compiledSchema?: SchemaValidationFunction<TAnySchema>;
+			codec: FieldCodec;
+		}
+	>,
+	revisionTagCodec: IJsonCodec<
+		RevisionTag,
+		EncodedRevisionTag,
+		EncodedRevisionTag,
+		ChangeEncodingContext
+	>,
+	fieldsCodec: FieldBatchCodec,
+	chunkCompressionStrategy: TreeCompressionStrategy,
+): EncodedModularChangesetV1 {
+	// Destroys only exist in rollback changesets, which are never sent.
+	assert(change.destroys === undefined, 0x899 /* Unexpected changeset with destroys */);
+	return {
+		maxId: change.maxId,
+		revisions:
+			change.revisions === undefined
+				? undefined
+				: encodeRevisionInfos(change.revisions, context, revisionTagCodec),
+		changes: encodeFieldChangesForJson(
+			change.fieldChanges,
+			context,
+			change.nodeChanges,
+			fieldChangesetCodecs,
+		),
+		builds: encodeDetachedNodes(
+			change.builds,
+			context,
+			revisionTagCodec,
+			fieldsCodec,
+			chunkCompressionStrategy,
+		),
+		refreshers: encodeDetachedNodes(
+			change.refreshers,
+			context,
+			revisionTagCodec,
+			fieldsCodec,
+			chunkCompressionStrategy,
+		),
+		violations: change.constraintViolationCount,
+	};
+}
 
-			// Destroys only exist in rollback changesets, which are never sent.
-			assert(change.destroys === undefined, 0x899 /* Unexpected changeset with destroys */);
-			const encoded: EncodedModularChangeset = {
-				maxId: change.maxId,
-				revisions:
-					change.revisions === undefined
-						? undefined
-						: encodeRevisionInfos(change.revisions, context),
-				changes: encodeFieldChangesForJson(
-					change.fieldChanges,
-					undefined,
-					fieldToRoots,
-					context,
-					encodeNode,
-					getInputRootId,
-					isAttachId,
-					isDetachId,
-				),
-				builds: encodeDetachedNodes(change.builds, context),
-				refreshers: encodeDetachedNodes(change.refreshers, context),
-				violations: change.constraintViolationCount,
-			};
+export function decodeChange(
+	encodedChange: EncodedModularChangesetV1,
+	context: ChangeEncodingContext,
+	fieldKinds: FieldKindConfiguration,
+	fieldChangesetCodecs: Map<
+		FieldKindIdentifier,
+		{
+			compiledSchema?: SchemaValidationFunction<TAnySchema>;
+			codec: FieldCodec;
+		}
+	>,
+	revisionTagCodec: IJsonCodec<
+		RevisionTag,
+		EncodedRevisionTag,
+		EncodedRevisionTag,
+		ChangeEncodingContext
+	>,
+	fieldsCodec: FieldBatchCodec,
+	chunkCompressionStrategy: TreeCompressionStrategy,
+): Mutable<ModularChangeset> {
+	const decoded: Mutable<ModularChangeset> = {
+		fieldChanges: new Map(),
+		nodeChanges: newTupleBTree(),
+		nodeToParent: newTupleBTree(),
+		nodeAliases: newTupleBTree(),
+		crossFieldKeys: newCrossFieldKeyTable(),
+	};
 
-			return encoded;
-		},
+	decoded.fieldChanges = decodeFieldChangesFromJson(
+		encodedChange.changes,
+		undefined,
+		decoded,
+		context,
+		idAllocatorFromMaxId(encodedChange.maxId),
+		fieldKinds,
+		fieldChangesetCodecs,
+	);
 
-		decode: (encodedChange: EncodedModularChangeset, context) => {
-			const idAllocator = idAllocatorFromMaxId(encodedChange.maxId);
-			const nodeChanges: ChangeAtomIdBTree<NodeChangeset> = newTupleBTree();
-			const nodeToParent: ChangeAtomIdBTree<NodeLocation> = newTupleBTree();
-			const crossFieldKeys: CrossFieldKeyTable = newCrossFieldRangeTable();
-			const rootNodes = newRootTable();
-
-			const decodeNode: NodeDecoder = (
-				encodedNode: EncodedNodeChangeset,
-				fieldId: NodeLocation,
-			): NodeId => {
-				const nodeId: NodeId = {
-					revision: context.revision,
-					localId: brand(idAllocator.allocate()),
-				};
+	if (encodedChange.builds !== undefined) {
+		decoded.builds = decodeDetachedNodes(
+			encodedChange.builds,
+			context,
+			revisionTagCodec,
+			fieldsCodec,
+			chunkCompressionStrategy,
+		);
+	}
+	if (encodedChange.refreshers !== undefined) {
+		decoded.refreshers = decodeDetachedNodes(
+			encodedChange.refreshers,
+			context,
+			revisionTagCodec,
+			fieldsCodec,
+			chunkCompressionStrategy,
+		);
+	}
 
-				const node = decodeNodeChangesetFromJson(
-					encodedNode,
-					nodeId,
-					crossFieldKeys,
-					rootNodes,
-					context,
-					decodeNode,
-					idAllocator,
-				);
+	if (encodedChange.violations !== undefined) {
+		decoded.constraintViolationCount = encodedChange.violations;
+	}
 
-				nodeChanges.set([nodeId.revision, nodeId.localId], node);
+	const decodedRevInfos = decodeRevisionInfos(
+		encodedChange.revisions,
+		context,
+		revisionTagCodec,
+	);
+	if (decodedRevInfos !== undefined) {
+		decoded.revisions = decodedRevInfos;
+	}
+	if (encodedChange.maxId !== undefined) {
+		decoded.maxId = encodedChange.maxId;
+	}
+	return decoded;
+}
 
-				if (fieldId !== undefined) {
-					nodeToParent.set([nodeId.revision, nodeId.localId], fieldId);
-				}
+export function getFieldChangesetCodecs(
+	fieldKinds: FieldKindConfiguration,
+	revisionTagCodec: IJsonCodec<
+		RevisionTag,
+		EncodedRevisionTag,
+		EncodedRevisionTag,
+		ChangeEncodingContext
+	>,
+	codecOptions: ICodecOptions,
+): Map<
+	FieldKindIdentifier,
+	{ compiledSchema?: SchemaValidationFunction<TAnySchema>; codec: FieldCodec }
+> {
+	// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+	const getMapEntry = ({ kind, formatVersion }: FieldKindConfigurationEntry) => {
+		const codec = kind.changeHandler.codecsFactory(revisionTagCodec).resolve(formatVersion);
+		return {
+			codec,
+			compiledSchema: codec.json.encodedSchema
+				? extractJsonValidator(codecOptions.jsonValidator).compile(codec.json.encodedSchema)
+				: undefined,
+		};
+	};
 
-				return nodeId;
-			};
+	/**
+	 * The codec version for the generic field kind.
+	 */
+	const genericFieldKindFormatVersion = 1;
+	const fieldChangesetCodecs: Map<
+		FieldKindIdentifier,
+		{
+			compiledSchema?: SchemaValidationFunction<TAnySchema>;
+			codec: FieldCodec;
+		}
+	> = new Map([
+		[
+			genericFieldKind.identifier,
+			getMapEntry({ kind: genericFieldKind, formatVersion: genericFieldKindFormatVersion }),
+		],
+	]);
 
-			const decoded: Mutable<ModularChangeset> = {
-				rebaseVersion: 1,
-				fieldChanges: decodeFieldChangesFromJson(
-					encodedChange.changes,
-					undefined,
-					crossFieldKeys,
-					rootNodes,
-					context,
-					decodeNode,
-					idAllocator,
-				),
-				nodeChanges,
-				rootNodes,
-				nodeToParent,
-				nodeAliases: newTupleBTree(),
-				crossFieldKeys,
-			};
+	fieldKinds.forEach((entry, identifier) => {
+		fieldChangesetCodecs.set(identifier, getMapEntry(entry));
+	});
 
-			if (encodedChange.builds !== undefined) {
-				decoded.builds = decodeDetachedNodes(encodedChange.builds, context);
-			}
-			if (encodedChange.refreshers !== undefined) {
-				decoded.refreshers = decodeDetachedNodes(encodedChange.refreshers, context);
-			}
+	return fieldChangesetCodecs;
+}
 
-			if (encodedChange.violations !== undefined) {
-				decoded.constraintViolationCount = encodedChange.violations;
-			}
+export function makeModularChangeCodecV1(
+	fieldKinds: FieldKindConfiguration,
+	revisionTagCodec: IJsonCodec<
+		RevisionTag,
+		EncodedRevisionTag,
+		EncodedRevisionTag,
+		ChangeEncodingContext
+	>,
+	fieldsCodec: FieldBatchCodec,
+	codecOptions: ICodecOptions,
+	chunkCompressionStrategy: TreeCompressionStrategy = TreeCompressionStrategy.Compressed,
+): ModularChangeCodec {
+	const fieldChangesetCodecs = getFieldChangesetCodecs(
+		fieldKinds,
+		revisionTagCodec,
+		codecOptions,
+	);
 
-			const decodedRevInfos = decodeRevisionInfos(encodedChange.revisions, context);
-			if (decodedRevInfos !== undefined) {
-				decoded.revisions = decodedRevInfos;
-			}
-			if (encodedChange.maxId !== undefined) {
-				decoded.maxId = encodedChange.maxId;
-			}
-			return decoded;
-		},
+	const modularChangeCodec: ModularChangeCodec = {
+		encode: (change, context) =>
+			encodeChange(
+				change,
+				context,
+				fieldChangesetCodecs,
+				revisionTagCodec,
+				fieldsCodec,
+				chunkCompressionStrategy,
+			),
+		decode: (encodedChange, context) =>
+			decodeChange(
+				encodedChange,
+				context,
+				fieldKinds,
+				fieldChangesetCodecs,
+				revisionTagCodec,
+				fieldsCodec,
+				chunkCompressionStrategy,
+			),
 	};
 
 	return withSchemaValidation(
-		EncodedModularChangeset,
+		EncodedModularChangesetV1,
 		modularChangeCodec,
 		codecOptions.jsonValidator,
 	);
@@ -676,57 +701,3 @@ function encodeRevisionOpt(
 
 	return revision === context.revision ? undefined : revisionCodec.encode(revision, context);
 }
-
-function getFieldToRoots(rootTable: RootNodeTable): FieldRootMap {
-	const fieldToRoots: FieldRootMap = newTupleBTree();
-	for (const [[revision, localId], nodeId] of rootTable.nodeChanges.entries()) {
-		const detachId: ChangeAtomId = { revision, localId };
-		const fieldId = rootTable.detachLocations.getFirst(detachId, 1).value;
-		if (fieldId !== undefined) {
-			setInChangeAtomIdMap(
-				getOrAddInFieldRootMap(fieldToRoots, fieldId).nodeChanges,
-				detachId,
-				nodeId,
-			);
-		} else {
-			fail("Untracked root change");
-		}
-	}
-
-	for (const entry of rootTable.oldToNewId.entries()) {
-		const fieldId = rootTable.detachLocations.getFirst(entry.start, 1).value;
-		if (fieldId !== undefined) {
-			getOrAddInFieldRootMap(fieldToRoots, fieldId).renames.set(
-				entry.start,
-				entry.length,
-				entry.value,
-			);
-		} else {
-			fail("Untracked root change");
-		}
-	}
-
-	return fieldToRoots;
-}
-
-function getOrAddInFieldRootMap(map: FieldRootMap, fieldId: FieldId): FieldRootChanges {
-	const key: FieldIdKey = [fieldId.nodeId?.revision, fieldId.nodeId?.localId, fieldId.field];
-	const rootChanges = map.get(key);
-	if (rootChanges !== undefined) {
-		return rootChanges;
-	}
-
-	const newRootChanges: FieldRootChanges = {
-		nodeChanges: newTupleBTree(),
-		renames: newChangeAtomIdTransform(),
-	};
-	map.set(key, newRootChanges);
-	return newRootChanges;
-}
-
-type FieldRootMap = TupleBTree<FieldIdKey, FieldRootChanges>;
-
-interface FieldRootChanges {
-	readonly nodeChanges: ChangeAtomIdBTree<NodeId>;
-	readonly renames: ChangeAtomIdRangeMap<ChangeAtomId>;
-}