@fluidframework/tree 2.81.0-374083 → 2.81.1

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

@@ -3,85 +3,68 @@
  * 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 type { ChangeAtomIdBTree } from "../changeAtomIdBTree.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,
-	normalizeFieldId,
-	validateChangeset,
-	type FieldIdKey,
-} from "./modularChangeFamily.js";
+	type EncodedBuilds,
+	type EncodedBuildsArray,
+	type EncodedFieldChange,
+	type EncodedFieldChangeMap,
+	EncodedModularChangesetV1,
+	type EncodedNodeChangeset,
+	type EncodedRevisionInfo,
+} from "./modularChangeFormatV1.js";
 import {
-	newCrossFieldRangeTable,
-	type CrossFieldKeyTable,
-	type FieldChangeMap,
 	type FieldChangeset,
+	newCrossFieldKeyTable,
+	type FieldChangeMap,
 	type FieldId,
 	type ModularChangeset,
 	type NodeChangeset,
 	type NodeId,
-	type NodeLocation,
-	type RootNodeTable,
 } from "./modularChangeTypes.js";
-import type {
-	EncodedBuilds,
-	EncodedBuildsArray,
-	EncodedFieldChange,
-	EncodedFieldChangeMap,
-	EncodedNodeChangeset,
-	EncodedRevisionInfo,
-} from "./modularChangeFormatV1.js";
-import { EncodedModularChangesetV1 } from "./modularChangeFormatV1.js";
-import type { FieldChangeEncodingContext, FieldChangeHandler } from "./fieldChangeHandler.js";
-import { genericFieldKind } from "./genericFieldKind.js";
-import type { TAnySchema } from "@sinclair/typebox";
-import { setInChangeAtomIdMap, type ChangeAtomIdBTree } from "../changeAtomIdBTree.js";
-import type { FlexFieldKind } from "./fieldKind.js";
 
 type ModularChangeCodec = IJsonCodec<
 	ModularChangeset,
@@ -97,13 +80,6 @@ type FieldCodec = IMultiFormatCodec<
 	FieldChangeEncodingContext
 >;
 
-interface FieldRootChanges {
-	readonly nodeChanges: ChangeAtomIdBTree<NodeId>;
-	readonly renames: ChangeAtomIdRangeMap<ChangeAtomId>;
-}
-
-type FieldRootMap = TupleBTree<FieldIdKey, FieldRootChanges>;
-
 type FieldChangesetCodecs = Map<
 	FieldKindIdentifier,
 	{
@@ -112,64 +88,42 @@ type FieldChangesetCodecs = Map<
 	}
 >;
 
-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,
-		};
-	};
+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;
+}
 
-	/**
-	 * 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 encodeFieldChangesForJson(
+	change: FieldChangeMap,
+	context: ChangeEncodingContext,
+	nodeChanges: ChangeAtomIdBTree<NodeChangeset>,
+	fieldChangesetCodecs: FieldChangesetCodecs,
+): EncodedFieldChangeMap {
+	const fieldContext: FieldChangeEncodingContext = {
+		baseContext: context,
 
-	// eslint-disable-next-line unicorn/no-array-for-each -- Map.forEach with (value, key) signature; codec initialization
-	fieldKinds.forEach((entry, identifier) => {
-		fieldChangesetCodecs.set(identifier, getMapEntry(entry));
-	});
+		encodeNode: (nodeId: NodeId): EncodedNodeChangeset => {
+			const node = nodeChanges.get([nodeId.revision, nodeId.localId]);
+			assert(node !== undefined, 0x92e /* Unknown node ID */);
+			return encodeNodeChangesForJson(node, fieldContext, fieldChangesetCodecs);
+		},
 
-	return fieldChangesetCodecs;
+		decodeNode: () => fail(0xb1e /* Should not decode nodes during field encoding */),
+	};
+
+	return encodeFieldChangesForJsonI(change, fieldContext, fieldChangesetCodecs);
 }
 
-function encodeFieldChangesForJson(
+export function encodeFieldChangesForJsonI(
 	change: FieldChangeMap,
-	parentId: NodeId | undefined,
-	fieldToRoots: FieldRootMap,
-	context: ChangeEncodingContext,
-	encodeNode: NodeEncoder,
-	getInputRootId: ChangeAtomMappingQuery,
-	isAttachId: ChangeAtomIdRangeQuery,
-	isDetachId: ChangeAtomIdRangeQuery,
+	context: FieldChangeEncodingContext,
 	fieldChangesetCodecs: FieldChangesetCodecs,
 ): EncodedFieldChangeMap {
 	const encodedFields: EncodedFieldChangeMap = [];
@@ -179,25 +133,7 @@ function encodeFieldChangesForJson(
 			fieldChange.fieldKind,
 			fieldChangesetCodecs,
 		);
-		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"),
-		};
-
-		const encodedChange = codec.json.encode(fieldChange.change, fieldContext);
+		const encodedChange = codec.json.encode(fieldChange.change, context);
 		if (compiledSchema !== undefined && !compiledSchema.check(encodedChange)) {
 			fail(0xb1f /* Encoded change didn't pass schema validation. */);
 		}
@@ -215,24 +151,9 @@ function encodeFieldChangesForJson(
 	return encodedFields;
 }
 
-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 encodeNodeChangesForJson(
+export function encodeNodeChangesForJson(
 	change: NodeChangeset,
-	id: NodeId,
-	fieldToRoots: FieldRootMap,
-	context: ChangeEncodingContext,
-	encodeNode: NodeEncoder,
-	getInputRootId: ChangeAtomMappingQuery,
-	isAttachId: ChangeAtomIdRangeQuery,
-	isDetachId: ChangeAtomIdRangeQuery,
+	context: FieldChangeEncodingContext,
 	fieldChangesetCodecs: FieldChangesetCodecs,
 ): EncodedNodeChangeset {
 	const encodedChange: EncodedNodeChangeset = {};
@@ -240,15 +161,9 @@ function encodeNodeChangesForJson(
 	const { fieldChanges, nodeExistsConstraint } = change;
 
 	if (fieldChanges !== undefined) {
-		encodedChange.fieldChanges = encodeFieldChangesForJson(
+		encodedChange.fieldChanges = encodeFieldChangesForJsonI(
 			fieldChanges,
-			id,
-			fieldToRoots,
 			context,
-			encodeNode,
-			getInputRootId,
-			isAttachId,
-			isDetachId,
 			fieldChangesetCodecs,
 		);
 	}
@@ -260,25 +175,11 @@ function encodeNodeChangesForJson(
 	return encodedChange;
 }
 
-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;
-}
-
-function decodeFieldChangesFromJson(
+export function decodeFieldChangesFromJson(
 	encodedChange: EncodedFieldChangeMap,
 	parentId: NodeId | undefined,
-	decodedCrossFieldKeys: CrossFieldKeyTable,
-	decodedRootTable: RootNodeTable,
+	decoded: ModularChangeset,
 	context: ChangeEncodingContext,
-	decodeNode: NodeDecoder,
 	idAllocator: IdAllocator,
 	fieldKinds: FieldKindConfiguration,
 	fieldChangesetCodecs: FieldChangesetCodecs,
@@ -300,39 +201,29 @@ function decodeFieldChangesFromJson(
 
 		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 }),
+				const nodeId: NodeId = {
+					revision: context.revision,
+					localId: brand(idAllocator.allocate()),
+				};
+
+				const node = decodeNodeChangesetFromJson(
+					encodedNode,
+					nodeId,
+					decoded,
+					context,
+					idAllocator,
+					fieldKinds,
+					fieldChangesetCodecs,
 				);
-				decodedRootTable.detachLocations.set(detachId, 1, fieldId);
-			},
 
-			decodeRootRename: (oldId, newId, count): void => {
-				addNodeRename(decodedRootTable, oldId, newId, count, fieldId);
+				decoded.nodeChanges.set([nodeId.revision, nodeId.localId], node);
+				decoded.nodeToParent.set([nodeId.revision, nodeId.localId], fieldId);
+				return nodeId;
 			},
-
-			decodeMoveAndDetach: (detachId, count): void => {
-				decodedRootTable.outputDetachLocations.set(detachId, count, fieldId);
-			},
-
-			generateId: (): ChangeAtomId => ({
-				revision: context.revision,
-				localId: brand(idAllocator.allocate()),
-			}),
 		};
 
 		const fieldChangeset = codec.json.decode(field.change, fieldContext);
@@ -342,7 +233,7 @@ function decodeFieldChangesFromJson(
 		);
 
 		for (const { key, count } of crossFieldKeys) {
-			decodedCrossFieldKeys.set(key, count, fieldId);
+			decoded.crossFieldKeys.set(key, count, fieldId);
 		}
 
 		const fieldKey: FieldKey = brand<FieldKey>(field.fieldKey);
@@ -356,28 +247,24 @@ function decodeFieldChangesFromJson(
 	return decodedFields;
 }
 
-function decodeNodeChangesetFromJson(
+export function decodeNodeChangesetFromJson(
 	encodedChange: EncodedNodeChangeset,
 	id: NodeId,
-	decodedCrossFieldKeys: CrossFieldKeyTable,
-	decodedRootTable: RootNodeTable,
+	decoded: ModularChangeset,
 	context: ChangeEncodingContext,
-	decodeNode: NodeDecoder,
 	idAllocator: IdAllocator,
 	fieldKinds: FieldKindConfiguration,
 	fieldChangesetCodecs: FieldChangesetCodecs,
 ): NodeChangeset {
-	const decodedChange: Mutable<NodeChangeset> = {};
+	const decodedChange: NodeChangeset = {};
 	const { fieldChanges, nodeExistsConstraint } = encodedChange;
 
 	if (fieldChanges !== undefined) {
 		decodedChange.fieldChanges = decodeFieldChangesFromJson(
 			fieldChanges,
 			id,
-			decodedCrossFieldKeys,
-			decodedRootTable,
+			decoded,
 			context,
-			decodeNode,
 			idAllocator,
 			fieldKinds,
 			fieldChangesetCodecs,
@@ -391,7 +278,64 @@ function decodeNodeChangesetFromJson(
 	return decodedChange;
 }
 
-function decodeDetachedNodes(
+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;
+	}
+
+	const treesToEncode: ITreeCursorSynchronous[] = [];
+	const buildsArray: EncodedBuildsArray = [];
+
+	let buildsForRevision:
+		| [[ChangesetLocalId, number][], EncodedRevisionTag]
+		| [[ChangesetLocalId, number][]]
+		| undefined;
+
+	for (const [[revision, id], chunk] of detachedNodes.entries()) {
+		const encodedRevision = encodeRevisionOpt(revisionTagCodec, revision, context);
+
+		if (buildsForRevision === undefined || buildsForRevision[1] !== encodedRevision) {
+			if (buildsForRevision !== undefined) {
+				buildsArray.push(buildsForRevision);
+			}
+
+			buildsForRevision = encodedRevision === undefined ? [[]] : [[], encodedRevision];
+		}
+
+		treesToEncode.push(chunk.cursor());
+		const treeIndexInBatch = treesToEncode.length - 1;
+		buildsForRevision?.[0].push([id, treeIndexInBatch]);
+	}
+
+	if (buildsForRevision !== undefined) {
+		buildsArray.push(buildsForRevision);
+	}
+
+	return buildsArray.length === 0
+		? undefined
+		: {
+				builds: buildsArray,
+				trees: fieldsCodec.encode(treesToEncode, {
+					encodeType: chunkCompressionStrategy,
+					schema: context.schema,
+					originatorId: context.originatorId,
+					idCompressor: context.idCompressor,
+				}),
+			};
+}
+
+export function decodeDetachedNodes(
 	encoded: EncodedBuilds | undefined,
 	context: ChangeEncodingContext,
 	revisionTagCodec: IJsonCodec<
@@ -440,7 +384,45 @@ function decodeDetachedNodes(
 	return map;
 }
 
-function decodeRevisionInfos(
+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 */,
+		);
+
+		return undefined;
+	}
+
+	const encodedRevisions = [];
+	for (const revision of revisions) {
+		const encodedRevision: Mutable<EncodedRevisionInfo> = {
+			revision: revisionTagCodec.encode(revision.revision, context),
+		};
+
+		if (revision.rollbackOf !== undefined) {
+			encodedRevision.rollbackOf = revisionTagCodec.encode(revision.rollbackOf, context);
+		}
+
+		encodedRevisions.push(encodedRevision);
+	}
+
+	return encodedRevisions;
+}
+
+export function decodeRevisionInfos(
 	revisions: readonly EncodedRevisionInfo[] | undefined,
 	context: ChangeEncodingContext,
 	revisionTagCodec: IJsonCodec<
@@ -470,58 +452,16 @@ function decodeRevisionInfos(
 	return decodedRevisions;
 }
 
-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 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(
-		EncodedModularChangesetV1,
-		modularChangeCodec,
-		codecOptions.jsonValidator,
-	);
-}
-
-export function encodeChange(
-	change: ModularChangeset,
-	context: ChangeEncodingContext,
-	fieldChangesetCodecs: FieldChangesetCodecs,
+export function encodeChange(
+	change: ModularChangeset,
+	context: ChangeEncodingContext,
+	fieldChangesetCodecs: Map<
+		FieldKindIdentifier,
+		{
+			compiledSchema?: SchemaValidationFunction<TAnySchema>;
+			codec: FieldCodec;
+		}
+	>,
 	revisionTagCodec: IJsonCodec<
 		RevisionTag,
 		EncodedRevisionTag,
@@ -531,49 +471,9 @@ export function encodeChange(
 	fieldsCodec: FieldBatchCodec,
 	chunkCompressionStrategy: TreeCompressionStrategy,
 ): EncodedModularChangesetV1 {
-	const fieldToRoots = getFieldToRoots(change.rootNodes, change.nodeAliases);
-	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);
-	};
-
-	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,
-			fieldChangesetCodecs,
-		);
-	};
-
 	// Destroys only exist in rollback changesets, which are never sent.
 	assert(change.destroys === undefined, 0x899 /* Unexpected changeset with destroys */);
-	const encoded: EncodedModularChangesetV1 = {
+	return {
 		maxId: change.maxId,
 		revisions:
 			change.revisions === undefined
@@ -581,13 +481,8 @@ export function encodeChange(
 				: encodeRevisionInfos(change.revisions, context, revisionTagCodec),
 		changes: encodeFieldChangesForJson(
 			change.fieldChanges,
-			undefined,
-			fieldToRoots,
 			context,
-			encodeNode,
-			getInputRootId,
-			isAttachId,
-			isDetachId,
+			change.nodeChanges,
 			fieldChangesetCodecs,
 		),
 		builds: encodeDetachedNodes(
@@ -606,183 +501,6 @@ export function encodeChange(
 		),
 		violations: change.constraintViolationCount,
 	};
-
-	return encoded;
-}
-
-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 */,
-		);
-
-		return undefined;
-	}
-
-	const encodedRevisions = [];
-	for (const revision of revisions) {
-		const encodedRevision: Mutable<EncodedRevisionInfo> = {
-			revision: revisionTagCodec.encode(revision.revision, context),
-		};
-
-		if (revision.rollbackOf !== undefined) {
-			encodedRevision.rollbackOf = revisionTagCodec.encode(revision.rollbackOf, context);
-		}
-
-		encodedRevisions.push(encodedRevision);
-	}
-
-	return encodedRevisions;
-}
-
-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;
-	}
-
-	const treesToEncode: ITreeCursorSynchronous[] = [];
-	const buildsArray: EncodedBuildsArray = [];
-
-	let buildsForRevision:
-		| [[ChangesetLocalId, number][], EncodedRevisionTag]
-		| [[ChangesetLocalId, number][]]
-		| undefined;
-
-	for (const [[revision, id], chunk] of detachedNodes.entries()) {
-		const encodedRevision = encodeRevisionOpt(revisionTagCodec, revision, context);
-
-		if (buildsForRevision === undefined || buildsForRevision[1] !== encodedRevision) {
-			if (buildsForRevision !== undefined) {
-				buildsArray.push(buildsForRevision);
-			}
-
-			buildsForRevision = encodedRevision === undefined ? [[]] : [[], encodedRevision];
-		}
-
-		treesToEncode.push(chunk.cursor());
-		const treeIndexInBatch = treesToEncode.length - 1;
-		buildsForRevision?.[0].push([id, treeIndexInBatch]);
-	}
-
-	if (buildsForRevision !== undefined) {
-		buildsArray.push(buildsForRevision);
-	}
-
-	return buildsArray.length === 0
-		? undefined
-		: {
-				builds: buildsArray,
-				trees: fieldsCodec.encode(treesToEncode, {
-					encodeType: chunkCompressionStrategy,
-					schema: context.schema,
-					originatorId: context.originatorId,
-					idCompressor: context.idCompressor,
-				}),
-			};
-}
-
-function getChangeHandler(
-	fieldKinds: FieldKindConfiguration,
-	fieldKind: FieldKindIdentifier,
-): FieldChangeHandler<unknown> {
-	if (fieldKind === genericFieldKind.identifier) {
-		return genericFieldKind.changeHandler;
-	}
-
-	const handler = fieldKinds.get(fieldKind)?.kind.changeHandler;
-	assert(handler !== undefined, 0x9c1 /* Unknown field kind */);
-	return handler;
-}
-
-function encodeRevisionOpt(
-	revisionCodec: IJsonCodec<
-		RevisionTag,
-		EncodedRevisionTag,
-		EncodedRevisionTag,
-		ChangeEncodingContext
-	>,
-	revision: RevisionTag | undefined,
-	context: ChangeEncodingContext,
-): EncodedRevisionTag | undefined {
-	if (revision === undefined) {
-		return undefined;
-	}
-
-	return revision === context.revision ? undefined : revisionCodec.encode(revision, context);
-}
-
-function getFieldToRoots(
-	rootTable: RootNodeTable,
-	aliases: ChangeAtomIdBTree<NodeId>,
-): 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) {
-			fail("Untracked root change");
-		} else {
-			setInChangeAtomIdMap(
-				getOrAddInFieldRootMap(fieldToRoots, normalizeFieldId(fieldId, aliases)).nodeChanges,
-				detachId,
-				nodeId,
-			);
-		}
-	}
-
-	for (const entry of rootTable.oldToNewId.entries()) {
-		const fieldId = rootTable.detachLocations.getFirst(entry.start, 1).value;
-		if (fieldId === undefined) {
-			fail("Untracked root change");
-		} else {
-			getOrAddInFieldRootMap(fieldToRoots, normalizeFieldId(fieldId, aliases)).renames.set(
-				entry.start,
-				entry.length,
-				entry.value,
-			);
-		}
-	}
-
-	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;
 }
 
 export function decodeChange(
@@ -805,62 +523,24 @@ export function decodeChange(
 	fieldsCodec: FieldBatchCodec,
 	chunkCompressionStrategy: TreeCompressionStrategy,
 ): Mutable<ModularChangeset> {
-	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()),
-		};
-
-		const node = decodeNodeChangesetFromJson(
-			encodedNode,
-			nodeId,
-			crossFieldKeys,
-			rootNodes,
-			context,
-			decodeNode,
-			idAllocator,
-			fieldKinds,
-			fieldChangesetCodecs,
-		);
-
-		nodeChanges.set([nodeId.revision, nodeId.localId], node);
-
-		if (fieldId !== undefined) {
-			nodeToParent.set([nodeId.revision, nodeId.localId], fieldId);
-		}
-
-		return nodeId;
-	};
-
 	const decoded: Mutable<ModularChangeset> = {
-		rebaseVersion: 1,
-		fieldChanges: decodeFieldChangesFromJson(
-			encodedChange.changes,
-			undefined,
-			crossFieldKeys,
-			rootNodes,
-			context,
-			decodeNode,
-			idAllocator,
-			fieldKinds,
-			fieldChangesetCodecs,
-		),
-		nodeChanges,
-		rootNodes,
-		nodeToParent,
+		fieldChanges: new Map(),
+		nodeChanges: newTupleBTree(),
+		nodeToParent: newTupleBTree(),
 		nodeAliases: newTupleBTree(),
-		crossFieldKeys,
+		crossFieldKeys: newCrossFieldKeyTable(),
 	};
 
+	decoded.fieldChanges = decodeFieldChangesFromJson(
+		encodedChange.changes,
+		undefined,
+		decoded,
+		context,
+		idAllocatorFromMaxId(encodedChange.maxId),
+		fieldKinds,
+		fieldChangesetCodecs,
+	);
+
 	if (encodedChange.builds !== undefined) {
 		decoded.builds = decodeDetachedNodes(
 			encodedChange.builds,
@@ -895,18 +575,131 @@ export function decodeChange(
 	if (encodedChange.maxId !== undefined) {
 		decoded.maxId = encodedChange.maxId;
 	}
-
-	// XXX: This is an expensive assert which should be removed before merging.
-	validateChangeset(decoded, fieldKindsFromConfiguration(fieldKinds));
 	return decoded;
 }
 
-function fieldKindsFromConfiguration(
-	configuration: FieldKindConfiguration,
-): ReadonlyMap<FieldKindIdentifier, FlexFieldKind> {
-	const map = new Map();
-	for (const [id, entry] of configuration.entries()) {
-		map.set(id, entry.kind);
+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,
+		};
+	};
+
+	/**
+	 * 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 }),
+		],
+	]);
+
+	// eslint-disable-next-line unicorn/no-array-for-each -- Map.forEach with (value, key) signature; codec initialization
+	fieldKinds.forEach((entry, identifier) => {
+		fieldChangesetCodecs.set(identifier, getMapEntry(entry));
+	});
+
+	return fieldChangesetCodecs;
+}
+
+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 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(
+		EncodedModularChangesetV1,
+		modularChangeCodec,
+		codecOptions.jsonValidator,
+	);
+}
+
+function getChangeHandler(
+	fieldKinds: FieldKindConfiguration,
+	fieldKind: FieldKindIdentifier,
+): FieldChangeHandler<unknown> {
+	if (fieldKind === genericFieldKind.identifier) {
+		return genericFieldKind.changeHandler;
 	}
-	return map;
+
+	const handler = fieldKinds.get(fieldKind)?.kind.changeHandler;
+	assert(handler !== undefined, 0x9c1 /* Unknown field kind */);
+	return handler;
+}
+
+function encodeRevisionOpt(
+	revisionCodec: IJsonCodec<
+		RevisionTag,
+		EncodedRevisionTag,
+		EncodedRevisionTag,
+		ChangeEncodingContext
+	>,
+	revision: RevisionTag | undefined,
+	context: ChangeEncodingContext,
+): EncodedRevisionTag | undefined {
+	if (revision === undefined) {
+		return undefined;
+	}
+
+	return revision === context.revision ? undefined : revisionCodec.encode(revision, context);
 }