@fluidframework/tree 2.90.0-378676 → 2.90.0

package/src/feature-libraries/sequence-field/sequenceFieldCodecV2.ts

@@ -11,20 +11,16 @@ import {
 	type DiscriminatedUnionLibrary,
 	type IJsonCodec,
 } from "../../codec/index.js";
-import {
-	areEqualChangeAtomIds,
-	type ChangeAtomId,
-	type ChangeEncodingContext,
-	type ChangesetLocalId,
-	type EncodedRevisionTag,
-	type RevisionTag,
+import type {
+	ChangeEncodingContext,
+	ChangesetLocalId,
+	EncodedRevisionTag,
+	RevisionTag,
 } from "../../core/index.js";
 import { type JsonCompatibleReadOnly, type Mutable, brand } from "../../util/index.js";
-import { getFromChangeAtomIdMap, rangeQueryChangeAtomIdMap } from "../changeAtomIdBTree.js";
 import { makeChangeAtomIdCodec } from "../changeAtomIdCodec.js";
 import {
 	EncodedNodeChangeset,
-	type EncodedChangeAtomId,
 	type FieldChangeEncodingContext,
 } from "../modular-schema/index.js";
 
@@ -32,15 +28,19 @@ import { Changeset as ChangesetSchema, type Encoded } from "./formatV2.js";
 import type { SequenceCodecHelpers } from "./helperTypes.js";
 import {
 	type Attach,
-	type CellMark,
+	type AttachAndDetach,
 	type Changeset,
 	type Detach,
+	type Insert,
 	type Mark,
 	type MarkEffect,
+	type MoveIn,
+	type MoveOut,
 	NoopMarkType,
+	type Remove,
 	type Rename,
 } from "./types.js";
-import { getAttachedRootId, getDetachedRootId, isNoopMark, splitMark } from "./utils.js";
+import { isNoopMark, normalizeCellRename } from "./utils.js";
 
 export function makeV2CodecHelpers(
 	revisionTagCodec: IJsonCodec<
@@ -49,8 +49,108 @@ export function makeV2CodecHelpers(
 		EncodedRevisionTag,
 		ChangeEncodingContext
 	>,
-): SequenceCodecHelpers {
+): SequenceCodecHelpers<MarkEffect, Encoded.MarkEffect> {
 	const changeAtomIdCodec = makeChangeAtomIdCodec(revisionTagCodec);
+	const markEffectCodec: IJsonCodec<
+		MarkEffect,
+		Encoded.MarkEffect,
+		Encoded.MarkEffect,
+		ChangeEncodingContext
+	> = {
+		encode(effect: MarkEffect, context: ChangeEncodingContext): Encoded.MarkEffect {
+			function encodeRevision(
+				revision: RevisionTag | undefined,
+			): EncodedRevisionTag | undefined {
+				if (revision === undefined || revision === context.revision) {
+					return undefined;
+				}
+
+				return revisionTagCodec.encode(revision, context);
+			}
+
+			const type = effect.type;
+			switch (type) {
+				case "MoveIn": {
+					return {
+						moveIn: {
+							revision: encodeRevision(effect.revision),
+							finalEndpoint:
+								effect.finalEndpoint === undefined
+									? undefined
+									: changeAtomIdCodec.encode(effect.finalEndpoint, context),
+							id: effect.id,
+						},
+					};
+				}
+				case "Insert": {
+					return {
+						insert: {
+							revision: encodeRevision(effect.revision),
+							id: effect.id,
+						},
+					};
+				}
+				case "Remove": {
+					return {
+						remove: {
+							revision: encodeRevision(effect.revision),
+							idOverride:
+								effect.idOverride === undefined
+									? undefined
+									: changeAtomIdCodec.encode(effect.idOverride, context),
+							id: effect.id,
+						},
+					};
+				}
+				case "MoveOut": {
+					return {
+						moveOut: {
+							revision: encodeRevision(effect.revision),
+							finalEndpoint:
+								effect.finalEndpoint === undefined
+									? undefined
+									: changeAtomIdCodec.encode(effect.finalEndpoint, context),
+							idOverride:
+								effect.idOverride === undefined
+									? undefined
+									: changeAtomIdCodec.encode(effect.idOverride, context),
+							id: effect.id,
+						},
+					};
+				}
+				case "AttachAndDetach": {
+					return {
+						attachAndDetach: {
+							attach: markEffectCodec.encode(effect.attach, context) as Encoded.Attach,
+							detach: markEffectCodec.encode(effect.detach, context) as Encoded.Detach,
+						},
+					};
+				}
+				case "Rename": {
+					// In documents generated by clients on release >=2.2 (i.e., running the code from the PR that added this comment),
+					// renames are encoded as AttachAndDetach with a special id.
+					// This ensures forward-compatibility of clients on release <=2.1 with documents/ops generated by clients on release >=2.2.
+					return markEffectCodec.encode(
+						{
+							type: "AttachAndDetach",
+							attach: { type: "MoveIn", id: renameLocalId },
+							detach: { type: "MoveOut", id: renameLocalId, idOverride: effect.idOverride },
+						},
+						context,
+					);
+				}
+				case NoopMarkType: {
+					fail(0xb2c /* Mark type: NoopMarkType should not be encoded. */);
+				}
+				default: {
+					unreachableCase(type);
+				}
+			}
+		},
+		decode(encoded: Encoded.MarkEffect, context: ChangeEncodingContext): MarkEffect {
+			return decoderDispatcher.dispatch(encoded, context);
+		},
+	};
 
 	function decodeRevision(
 		encodedRevision: EncodedRevisionTag | undefined,
@@ -64,307 +164,102 @@ export function makeV2CodecHelpers(
 		return revisionTagCodec.decode(encodedRevision, context);
 	}
 
-	const decoderLibrary = makeMarkEffectDecoder(changeAtomIdCodec, decodeRevision);
-
-	const decoderDispatcher = new DiscriminatedUnionDispatcher<
-		Encoded.MarkEffect,
-		/* args */ [
-			count: number,
-			cellId: ChangeAtomId | undefined,
-			context: FieldChangeEncodingContext,
-		],
-		MarkEffect
-	>(decoderLibrary);
-
-	return {
-		changeAtomIdCodec,
-		decoderLibrary,
-
-		encodeMarkEffect(mark: Mark, context: FieldChangeEncodingContext): Encoded.MarkEffect {
-			return encodeMarkEffectV2(
-				mark,
-				context,
-				(revision) =>
-					encodeRevisionWithContext(revision, context.baseContext, revisionTagCodec),
-				changeAtomIdCodec,
-			);
-		},
-
-		decodeRevision: (
-			encoded: EncodedRevisionTag | undefined,
-			context: ChangeEncodingContext,
-		): RevisionTag =>
-			encoded === undefined
-				? (context.revision ?? fail("Expected a default revision"))
-				: revisionTagCodec.decode(encoded, context),
-
-		decodeMarkEffect: (
-			encoded: Encoded.MarkEffect,
-			count: number,
-			cellId: ChangeAtomId | undefined,
-			context: FieldChangeEncodingContext,
-		): MarkEffect => {
-			return decoderDispatcher.dispatch(encoded, count, cellId, context);
-		},
-	};
-}
-
-export type DecodeMarkEffect = (
-	encoded: Encoded.MarkEffect,
-	count: number,
-	cellId: ChangeAtomId | undefined,
-	context: FieldChangeEncodingContext,
-) => MarkEffect;
-
-export function decodeSequenceChangeset(
-	changeset: Encoded.Changeset<NodeChangeSchema>,
-	context: FieldChangeEncodingContext,
-	changeAtomIdCodec: IJsonCodec<
-		ChangeAtomId,
-		EncodedChangeAtomId,
-		EncodedChangeAtomId,
-		ChangeEncodingContext
-	>,
-	decodeMarkEffect: DecodeMarkEffect,
-): Changeset {
-	const marks: Changeset = [];
-	for (const mark of changeset) {
-		const decodedMark: Mark = {
-			count: mark.count,
-		};
-
-		if (mark.cellId !== undefined) {
-			decodedMark.cellId = changeAtomIdCodec.decode(mark.cellId, context.baseContext);
-		}
-
-		if (mark.effect !== undefined) {
-			Object.assign(
-				decodedMark,
-				decodeMarkEffect(mark.effect, mark.count, decodedMark.cellId, context),
-			);
-		}
-
-		if (mark.changes !== undefined) {
-			if (decodedMark.cellId === undefined) {
-				decodedMark.changes = context.decodeNode(mark.changes);
-			} else {
-				context.decodeRootNodeChange(decodedMark.cellId, mark.changes);
-			}
-		}
-
-		marks.push(decodedMark);
-	}
-	return marks;
-}
-
-function makeMarkEffectDecoder(
-	changeAtomIdCodec: IJsonCodec<
-		ChangeAtomId,
-		EncodedChangeAtomId,
-		EncodedChangeAtomId,
-		ChangeEncodingContext
-	>,
-	decodeRevision: (
-		revision: EncodedRevisionTag | undefined,
-		context: ChangeEncodingContext,
-	) => RevisionTag,
-): DiscriminatedUnionLibrary<
-	Encoded.MarkEffect,
-	/* args */ [
-		count: number,
-		cellId: ChangeAtomId | undefined,
-		context: FieldChangeEncodingContext,
-	],
-	MarkEffect
-> {
-	function decodeMoveIn(encoded: Encoded.MoveIn, context: FieldChangeEncodingContext): Attach {
-		const { id, revision } = encoded;
-		const mark: Attach = {
-			type: "Attach",
-			id,
-			revision: decodeRevision(revision, context.baseContext),
-		};
-
-		return mark;
-	}
-
 	const decoderLibrary: DiscriminatedUnionLibrary<
 		Encoded.MarkEffect,
-		/* args */ [
-			count: number,
-			cellId: ChangeAtomId | undefined,
-			context: FieldChangeEncodingContext,
-		],
+		/* args */ [context: ChangeEncodingContext],
 		MarkEffect
 	> = {
-		moveIn(
-			encoded: Encoded.MoveIn,
-			count: number,
-			cellId: ChangeAtomId | undefined,
-			context: FieldChangeEncodingContext,
-		): Attach {
-			return decodeMoveIn(encoded, context);
-		},
-		insert(
-			encoded: Encoded.Insert,
-			count: number,
-			cellId: ChangeAtomId | undefined,
-			context: FieldChangeEncodingContext,
-		): Attach {
-			const { id, revision } = encoded;
-			const mark: Attach = {
-				type: "Attach",
+		moveIn(encoded: Encoded.MoveIn, context: ChangeEncodingContext): MoveIn {
+			const { id, finalEndpoint, revision } = encoded;
+			const mark: MoveIn = {
+				type: "MoveIn",
 				id,
 			};
 
-			mark.revision = decodeRevision(revision, context.baseContext);
-
-			const attachId = getAttachedRootId(mark);
-			if (cellId !== undefined && !areEqualChangeAtomIds(cellId, attachId)) {
-				context.decodeRootRename(cellId, attachId, count);
+			mark.revision = decodeRevision(revision, context);
+			if (finalEndpoint !== undefined) {
+				mark.finalEndpoint = changeAtomIdCodec.decode(finalEndpoint, context);
 			}
+			return mark;
+		},
+		insert(encoded: Encoded.Insert, context: ChangeEncodingContext): Insert {
+			const { id, revision } = encoded;
+			const mark: Insert = {
+				type: "Insert",
+				id,
+			};
 
+			mark.revision = decodeRevision(revision, context);
 			return mark;
 		},
-		remove(
-			encoded: Encoded.Remove,
-			count: number,
-			cellId: ChangeAtomId | undefined,
-			context: FieldChangeEncodingContext,
-		): Detach | Rename {
+		remove(encoded: Encoded.Remove, context: ChangeEncodingContext): Remove {
 			const { id, revision, idOverride } = encoded;
-
-			const cellRename =
-				idOverride === undefined
-					? undefined
-					: changeAtomIdCodec.decode(idOverride, context.baseContext);
-
-			return decodeDetach(
-				cellId,
-				count,
-				decodeRevision(revision, context.baseContext),
+			const mark: Mutable<Remove> = {
+				type: "Remove",
 				id,
-				cellRename,
-				undefined,
-				context,
-			);
+			};
+
+			mark.revision = decodeRevision(revision, context);
+			if (idOverride !== undefined) {
+				mark.idOverride = changeAtomIdCodec.decode(idOverride, context);
+			}
+			return mark;
 		},
-		moveOut(
-			encoded: Encoded.MoveOut,
-			count: number,
-			cellId: ChangeAtomId | undefined,
-			context: FieldChangeEncodingContext,
-		): Detach | Rename {
-			const { id, idOverride, revision, finalEndpoint } = encoded;
-			const cellRename =
-				idOverride === undefined
-					? undefined
-					: changeAtomIdCodec.decode(idOverride, context.baseContext);
+		moveOut(encoded: Encoded.MoveOut, context: ChangeEncodingContext): MoveOut {
+			const { id, finalEndpoint, idOverride, revision } = encoded;
+			const mark: Mutable<MoveOut> = {
+				type: "MoveOut",
+				id,
+			};
 
-			const decodedRevision = decodeRevision(revision, context.baseContext);
+			mark.revision = decodeRevision(revision, context);
 			if (finalEndpoint !== undefined) {
-				const decodedEndpoint = changeAtomIdCodec.decode(finalEndpoint, context.baseContext);
-				return decodeDetach(
-					cellId,
-					count,
-					decodedEndpoint.revision ?? fail("Revision should be defined"),
-					decodedEndpoint.localId,
-					cellRename,
-					{ revision: decodedRevision, localId: id },
-					context,
-				);
+				mark.finalEndpoint = changeAtomIdCodec.decode(finalEndpoint, context);
+			}
+			if (idOverride !== undefined) {
+				mark.idOverride = changeAtomIdCodec.decode(idOverride, context);
 			}
 
-			return decodeDetach(cellId, count, decodedRevision, id, cellRename, undefined, context);
+			return mark;
 		},
 		attachAndDetach(
 			encoded: Encoded.AttachAndDetach,
-			count: number,
-			cellId: ChangeAtomId | undefined,
-			context: FieldChangeEncodingContext,
-		): Rename {
+			context: ChangeEncodingContext,
+		): AttachAndDetach | Rename {
+			const attach = decoderDispatcher.dispatch(encoded.attach, context) as Attach;
+			const detach = decoderDispatcher.dispatch(encoded.detach, context) as Detach;
 			// In documents generated by clients on release >=2.2 (i.e., running the code from the PR that added this comment),
 			// renames are encoded as AttachAndDetach with a special id.
 			// This ensures forward-compatibility of clients on release <=2.1 with documents/ops generated by clients on release >=2.2.
-			const encodedRenameId = tryGetEncodedCellRenameFromAttachAndDetach(encoded);
-			if (encodedRenameId !== undefined) {
+			if (attach.id === renameLocalId) {
+				assert(detach.idOverride !== undefined, 0x9f8 /* Rename must have idOverride */);
 				return {
 					type: "Rename",
-					idOverride: changeAtomIdCodec.decode(encodedRenameId, context.baseContext),
+					idOverride: detach.idOverride,
 				};
 			}
-
-			assert(
-				encoded.detach.remove !== undefined,
-				"Attach and detach should always contains a remove",
-			);
-
-			const detachId: ChangeAtomId =
-				encoded.detach.remove.idOverride === undefined
-					? {
-							revision: decodeRevision(encoded.detach.remove.revision, context.baseContext),
-							localId: encoded.detach.remove.id,
-						}
-					: changeAtomIdCodec.decode(encoded.detach.remove.idOverride, context.baseContext);
-
-			assert(cellId !== undefined, "Attach and detach should target an empty cell");
-			if (encoded.attach.moveIn === undefined) {
-				context.decodeRootRename(cellId, detachId, count);
-			} else {
-				context.decodeMoveAndDetach(detachId, count);
-			}
-
 			return {
-				type: "Rename",
-				idOverride: detachId,
+				type: "AttachAndDetach",
+				attach,
+				detach,
 			};
 		},
 	};
 
-	return decoderLibrary;
-}
-
-function decodeDetach(
-	cellId: ChangeAtomId | undefined,
-	count: number,
-	revision: RevisionTag,
-	localId: ChangesetLocalId,
-	cellRename: ChangeAtomId | undefined,
-	detachCellId: ChangeAtomId | undefined,
-	context: FieldChangeEncodingContext,
-): Detach | Rename {
-	const detachId: ChangeAtomId = { revision, localId };
-	if (cellId !== undefined) {
-		context.decodeRootRename(cellId, detachId, count);
-		return {
-			type: "Rename",
-			idOverride: cellRename ?? detachCellId ?? detachId,
-		};
-	}
+	const decoderDispatcher = new DiscriminatedUnionDispatcher<
+		Encoded.MarkEffect,
+		/* args */ [context: ChangeEncodingContext],
+		MarkEffect
+	>(decoderLibrary);
 
-	const mark: Mutable<Detach> = {
-		type: "Detach",
-		revision,
-		id: localId,
+	return {
+		changeAtomIdCodec,
+		markEffectCodec,
+		decoderLibrary,
+		decodeRevision,
 	};
-
-	if (cellRename !== undefined) {
-		mark.cellRename = cellRename;
-	}
-
-	if (detachCellId !== undefined) {
-		mark.detachCellId = detachCellId;
-	}
-
-	return mark;
 }
 
-/**
- * If we want to make the node change aspect of this codec more type-safe, we could adjust generics
- * to be in terms of the schema rather than the concrete type of the node change.
- */
-type NodeChangeSchema = TAnySchema;
-
 export function makeV2Codec(
 	revisionTagCodec: IJsonCodec<
 		RevisionTag,
@@ -378,421 +273,78 @@ export function makeV2Codec(
 	JsonCompatibleReadOnly,
 	FieldChangeEncodingContext
 > {
-	const { decodeMarkEffect, changeAtomIdCodec } = makeV2CodecHelpers(revisionTagCodec);
+	const { markEffectCodec, changeAtomIdCodec } = makeV2CodecHelpers(revisionTagCodec);
+	/**
+	 * If we want to make the node change aspect of this codec more type-safe, we could adjust generics
+	 * to be in terms of the schema rather than the concrete type of the node change.
+	 */
+	type NodeChangeSchema = TAnySchema;
 
 	return {
 		encode: (
 			changeset: Changeset,
 			context: FieldChangeEncodingContext,
-		): JsonCompatibleReadOnly & Encoded.Changeset<NodeChangeSchema> =>
-			encodeSequenceChangeset(
-				changeset,
-				context,
-				(revision) =>
-					encodeRevisionWithContext(revision, context.baseContext, revisionTagCodec),
-				changeAtomIdCodec,
-				encodeMarkEffectV2,
-			),
+		): JsonCompatibleReadOnly & Encoded.Changeset<NodeChangeSchema> => {
+			const jsonMarks: Encoded.Changeset<NodeChangeSchema> = [];
+			for (const mark of changeset) {
+				const encodedMark: Encoded.Mark<NodeChangeSchema> = {
+					count: mark.count,
+				};
+				if (!isNoopMark(mark)) {
+					encodedMark.effect = markEffectCodec.encode(mark, context.baseContext);
+				}
+				if (mark.cellId !== undefined) {
+					encodedMark.cellId = changeAtomIdCodec.encode(mark.cellId, context.baseContext);
+				}
+				if (mark.changes !== undefined) {
+					encodedMark.changes = context.encodeNode(mark.changes);
+				}
+				jsonMarks.push(encodedMark);
+			}
+			return jsonMarks;
+		},
 		decode: (
 			changeset: Encoded.Changeset<NodeChangeSchema>,
 			context: FieldChangeEncodingContext,
-		): Changeset =>
-			decodeSequenceChangeset(changeset, context, changeAtomIdCodec, decodeMarkEffect),
-		encodedSchema: ChangesetSchema(EncodedNodeChangeset),
-	};
-}
-
-export function encodeSequenceChangeset(
-	changeset: Changeset,
-	context: FieldChangeEncodingContext,
-	encodeRevision: (revision: RevisionTag | undefined) => EncodedRevisionTag | undefined,
-	changeAtomIdCodec: IJsonCodec<
-		ChangeAtomId,
-		EncodedChangeAtomId,
-		EncodedChangeAtomId,
-		ChangeEncodingContext
-	>,
-	encodeMarkEffect: EncodeMarkEffect,
-): JsonCompatibleReadOnly & Encoded.Changeset<NodeChangeSchema> {
-	const jsonMarks: Encoded.Changeset<NodeChangeSchema> = [];
-	for (const mark of changeset) {
-		jsonMarks.push(
-			...encodeMark(mark, context, encodeRevision, changeAtomIdCodec, encodeMarkEffect),
-		);
-	}
-	return jsonMarks;
-}
-
-function encodeMark(
-	mark: Mark,
-	context: FieldChangeEncodingContext,
-	encodeRevision: (revision: RevisionTag | undefined) => EncodedRevisionTag | undefined,
-	changeAtomIdCodec: IJsonCodec<
-		ChangeAtomId,
-		EncodedChangeAtomId,
-		EncodedChangeAtomId,
-		ChangeEncodingContext
-	>,
-	encodeMarkEffect: EncodeMarkEffect,
-): Encoded.Mark<TAnySchema>[] {
-	const splitLength = getLengthToSplitMark(mark, context);
-	if (splitLength < mark.count) {
-		const [mark1, mark2] = splitMark(mark, splitLength);
-		return [
-			encodeSplitMark(mark1, context, encodeRevision, changeAtomIdCodec, encodeMarkEffect),
-			...encodeMark(mark2, context, encodeRevision, changeAtomIdCodec, encodeMarkEffect),
-		];
-	}
-
-	return [encodeSplitMark(mark, context, encodeRevision, changeAtomIdCodec, encodeMarkEffect)];
-}
-
-function encodeRename(
-	mark: CellMark<Rename>,
-	context: FieldChangeEncodingContext,
-	changeAtomIdCodec: IJsonCodec<
-		ChangeAtomId,
-		EncodedChangeAtomId,
-		EncodedChangeAtomId,
-		ChangeEncodingContext
-	>,
-	encodeRevision: (revision: RevisionTag | undefined) => EncodedRevisionTag | undefined,
-): Encoded.MarkEffect {
-	assert(mark.cellId !== undefined, "Rename should target empty cell");
-
-	const inputDetachId = context.getInputRootId(mark.idOverride, mark.count).value;
-	const isMoveInAndDetach =
-		!context.isAttachId(mark.idOverride, mark.count).value &&
-		(context.isDetachId(mark.idOverride, mark.count).value ||
-			(inputDetachId !== undefined && !areEqualChangeAtomIds(inputDetachId, mark.cellId)));
-
-	if (isMoveInAndDetach) {
-		// These cells are the final detach location of moved nodes.
-		const encodedRevision = encodeRevision(mark.idOverride.revision);
-		const endpoint = context.getCellIdForMove(mark.idOverride, mark.count).value;
-		const encodedEndpoint =
-			endpoint === undefined
-				? undefined
-				: changeAtomIdCodec.encode(endpoint, context.baseContext);
-
-		return {
-			attachAndDetach: {
-				attach: {
-					moveIn: {
-						revision: encodedRevision,
-						id: mark.idOverride.localId,
-						finalEndpoint: encodedEndpoint,
-					},
-				},
-				detach: {
-					remove: {
-						revision: encodedRevision,
-						id: mark.idOverride.localId,
-					},
-				},
-			},
-		};
-	}
-
-	const renamedRootId = context.rootRenames.getFirst(mark.cellId, mark.count).value;
-	const isMoveOutAndAttach =
-		renamedRootId !== undefined && context.isAttachId(renamedRootId, mark.count).value;
-
-	const isRenameOfRoot = renamedRootId !== undefined;
-
-	// If we are renaming a root, but the output ID is not `mark.idOverride`,
-	// then we must be moving the node to another cell.
-	// If it were left in this cell, the root's output ID would not match the cell's output ID.
-	const isMoveOutAndDetach =
-		isRenameOfRoot && !areEqualChangeAtomIds(renamedRootId, mark.idOverride);
-
-	if (isMoveOutAndAttach || isMoveOutAndDetach) {
-		// This mark represents a move of a node which was detached from this cell.
-		// The root will be either be reattached with `moveId`,
-		// or left detached in another cell, with `moveId` as its output root ID.
-		// In the latter case, the other endpoint will be encoded as
-		// attach and detach (move-in and remove), where both the move-in and the remove
-		// use `moveId` as their ID.
-		// In either of these cases, we need this mark's `finalEndpoint` to be `moveId`.
-		// We can omit the final endpoint if it is the same as the move-out ID.
-		const encodedEndpoint = areEqualChangeAtomIds(mark.idOverride, renamedRootId)
-			? undefined
-			: changeAtomIdCodec.encode(renamedRootId, context.baseContext);
-
-		return {
-			moveOut: {
-				revision: encodeRevision(mark.idOverride.revision),
-				id: mark.idOverride.localId,
-				finalEndpoint: encodedEndpoint,
-			},
-		};
-	}
-
-	if (renamedRootId !== undefined) {
-		return {
-			remove: {
-				revision: encodeRevision(renamedRootId.revision),
-				id: renamedRootId.localId,
-			},
-		};
-	}
-
-	// In documents generated by clients on release >=2.2 (i.e., running the code from the PR that added this comment),
-	// renames are encoded as AttachAndDetach with a special id.
-	// This ensures forward-compatibility of clients on release <=2.1 with documents/ops generated by clients on release >=2.2.
-	return {
-		attachAndDetach: {
-			attach: { insert: { id: renameLocalId } },
-			detach: {
-				remove: {
-					id: renameLocalId,
-					idOverride: changeAtomIdCodec.encode(mark.idOverride, context.baseContext),
-				},
-			},
-		},
-	};
-}
-
-function getLengthToSplitMark(mark: Mark, context: FieldChangeEncodingContext): number {
-	let count: number =
-		mark.cellId === undefined
-			? mark.count
-			: rangeQueryChangeAtomIdMap(context.rootNodeChanges, mark.cellId, mark.count).length;
-
-	if (mark.cellId !== undefined) {
-		count = context.getInputRootId(mark.cellId, count).length;
-	}
-
-	switch (mark.type) {
-		case "Attach": {
-			const attachId = getAttachedRootId(mark);
-			count = context.isDetachId(attachId, count).length;
-			count = context.getCellIdForMove(attachId, count).length;
-			break;
-		}
-		case "Detach": {
-			count = context.isAttachId(getDetachedRootId(mark), count).length;
-			break;
-		}
-		case "Rename": {
-			count = context.getInputRootId(mark.idOverride, count).length;
-			count = context.isAttachId(mark.idOverride, count).length;
-			count = context.isDetachId(mark.idOverride, count).length;
-			count = context.getCellIdForMove(mark.idOverride, count).length;
-			const cellId = mark.cellId ?? fail("Rename should have cell ID");
-			const renameEntry = context.rootRenames.getFirst(cellId, count);
-			count = renameEntry.length;
-			count = context.isAttachId(renameEntry.value ?? cellId, count).length;
-			break;
-		}
-		default: {
-			break;
-		}
-	}
-
-	return count;
-}
-
-function encodeSplitMark(
-	mark: Mark,
-	context: FieldChangeEncodingContext,
-	encodeRevision: (revision: RevisionTag | undefined) => EncodedRevisionTag | undefined,
-	changeAtomIdCodec: IJsonCodec<
-		ChangeAtomId,
-		EncodedChangeAtomId,
-		EncodedChangeAtomId,
-		ChangeEncodingContext
-	>,
-	encodeMarkEffect: EncodeMarkEffect,
-): Encoded.Mark<TAnySchema> {
-	const encodedMark: Encoded.Mark<TAnySchema> = {
-		count: mark.count,
-	};
-	if (!isNoopMark(mark)) {
-		encodedMark.effect = encodeMarkEffect(mark, context, encodeRevision, changeAtomIdCodec);
-	}
-	if (mark.cellId !== undefined) {
-		assert(mark.changes === undefined, "Empty cells should not have node changes");
-		encodedMark.cellId = changeAtomIdCodec.encode(mark.cellId, context.baseContext);
-		const nodeId = getFromChangeAtomIdMap(context.rootNodeChanges, mark.cellId);
-		if (nodeId !== undefined) {
-			encodedMark.changes = context.encodeNode(nodeId);
-		}
-	} else if (mark.changes !== undefined) {
-		encodedMark.changes = context.encodeNode(mark.changes);
-	}
-
-	return encodedMark;
-}
-
-type EncodeMarkEffect = (
-	mark: Mark,
-	context: FieldChangeEncodingContext,
-	encodeRevision: (revision: RevisionTag | undefined) => EncodedRevisionTag | undefined,
-	changeAtomIdCodec: IJsonCodec<
-		ChangeAtomId,
-		EncodedChangeAtomId,
-		EncodedChangeAtomId,
-		ChangeEncodingContext
-	>,
-) => Encoded.MarkEffect;
-
-function encodeMarkEffectV2(
-	mark: Mark,
-	context: FieldChangeEncodingContext,
-	encodeRevision: (revision: RevisionTag | undefined) => EncodedRevisionTag | undefined,
-	changeAtomIdCodec: IJsonCodec<
-		ChangeAtomId,
-		EncodedChangeAtomId,
-		EncodedChangeAtomId,
-		ChangeEncodingContext
-	>,
-): Encoded.MarkEffect {
-	const type = mark.type;
-	switch (type) {
-		case "Attach": {
-			const attachId = getAttachedRootId(mark);
-			const isMove = context.isDetachId(attachId, 1).value;
-
-			// If the input context ID for these nodes is not the cell ID,
-			// then these nodes are being moved from the location at which they were last detached.
-			const inputId = context.getInputRootId(attachId, mark.count).value ?? attachId;
-			const isInitialAttachLocation =
-				mark.cellId === undefined || areEqualChangeAtomIds(mark.cellId, inputId);
-
-			if (!isMove && isInitialAttachLocation) {
-				return {
-					insert: {
-						revision: encodeRevision(mark.revision),
-						id: mark.id,
-					},
+		): Changeset => {
+			const marks: Changeset = [];
+			for (const mark of changeset) {
+				const decodedMark: Mark = {
+					count: mark.count,
 				};
-			}
 
-			const detachCellId = context.getCellIdForMove(attachId, mark.count).value;
-			const encodedEndpoint =
-				detachCellId === undefined
-					? undefined
-					: changeAtomIdCodec.encode(detachCellId, context.baseContext);
-
-			return {
-				moveIn: {
-					revision: encodeRevision(mark.revision),
-					id: mark.id,
-					finalEndpoint: encodedEndpoint,
-				},
-			};
-		}
-		case "Detach": {
-			const encodedIdOverride =
-				mark.cellRename === undefined
-					? undefined
-					: changeAtomIdCodec.encode(mark.cellRename, context.baseContext);
-
-			const detachId = getDetachedRootId(mark);
-			const isMove = context.isAttachId(detachId, 1).value;
-
-			const outputCellId = mark.cellRename ?? mark.detachCellId ?? detachId;
-
-			// If the final detach location for the nodes were here,
-			// then the output cell ID would be the same as the detach ID.
-			// So if the cell ID is different from the detach ID, the nodes must have been moved.
-			const isFinalDetachLocation = areEqualChangeAtomIds(detachId, outputCellId);
-
-			const isMoveOrDetachedMove = isMove || !isFinalDetachLocation;
-			if (mark.detachCellId !== undefined) {
-				assert(
-					isMoveOrDetachedMove,
-					"Only detaches representing a move out should specify a detach cell ID",
-				);
-
-				return {
-					moveOut: {
-						revision: encodeRevision(mark.detachCellId.revision),
-						id: mark.detachCellId.localId,
-						idOverride: encodedIdOverride,
-						finalEndpoint: changeAtomIdCodec.encode(
-							{ revision: mark.revision, localId: mark.id },
-							context.baseContext,
-						),
-					},
-				};
+				if (mark.effect !== undefined) {
+					Object.assign(decodedMark, markEffectCodec.decode(mark.effect, context.baseContext));
+				}
+				if (mark.cellId !== undefined) {
+					decodedMark.cellId = changeAtomIdCodec.decode(mark.cellId, context.baseContext);
+				}
+				// Type deduction wrongly narrows the type of `decodedMark` to `NoopMark & HasMarkFields`.
+				// We declare a new casted copy of `decodedMark` to recover the correct type.
+				let decodedMark2 = decodedMark as Mark;
+				if (decodedMark2.cellId !== undefined && decodedMark2.type === "AttachAndDetach") {
+					// In documents generated by clients on release <=2.1 (i.e., not running the code from the PR that added this comment),
+					// rename-like AttachAndDetach marks are not normalized to Rename marks thus requiring this normalization step.
+					// This ensures backward compatibility with documents generated by clients on release <=2.1.
+					decodedMark2 = normalizeCellRename(
+						decodedMark2.cellId,
+						decodedMark2.count,
+						decodedMark2.attach,
+						decodedMark2.detach,
+					);
+				}
+				if (mark.changes !== undefined) {
+					decodedMark2.changes = context.decodeNode(mark.changes);
+				}
+				marks.push(decodedMark2);
 			}
-
-			const encodedRevision = encodeRevision(mark.revision);
-			return isMoveOrDetachedMove
-				? {
-						moveOut: {
-							revision: encodedRevision,
-							id: mark.id,
-							idOverride: encodedIdOverride,
-						},
-					}
-				: {
-						remove: {
-							revision: encodedRevision,
-							idOverride: encodedIdOverride,
-							id: mark.id,
-						},
-					};
-		}
-		case "Rename": {
-			return encodeRename(mark, context, changeAtomIdCodec, encodeRevision);
-		}
-		case NoopMarkType: {
-			fail(0xb2c /* Mark type: NoopMarkType should not be encoded. */);
-		}
-		default: {
-			unreachableCase(type);
-		}
-	}
-}
-
-export function encodeRevisionWithContext(
-	revision: RevisionTag | undefined,
-	context: ChangeEncodingContext,
-	revisionTagCodec: IJsonCodec<
-		RevisionTag,
-		EncodedRevisionTag,
-		EncodedRevisionTag,
-		ChangeEncodingContext
-	>,
-): EncodedRevisionTag | undefined {
-	return revision === undefined || revision === context.revision
-		? undefined
-		: revisionTagCodec.encode(revision, context);
+			return marks;
+		},
+		encodedSchema: ChangesetSchema(EncodedNodeChangeset),
+	};
 }
 
 /**
  * Arbitrary ID that is used to indicate a Rename effect.
  */
 const renameLocalId: ChangesetLocalId = brand(-1);
-
-/**
- * If the encoded mark effect represents a simple cell rename (with no effect on root nodes),
- * returns the encoded form of the ID the cell is being renamed to,
- * and otherwise returns undefined.
- */
-export function tryGetEncodedCellRename(
-	encoded: Encoded.MarkEffect,
-): EncodedChangeAtomId | undefined {
-	const attachAndDetach = encoded.attachAndDetach;
-	if (attachAndDetach === undefined) {
-		return undefined;
-	}
-}
-
-function tryGetEncodedCellRenameFromAttachAndDetach(
-	encoded: Encoded.AttachAndDetach,
-): EncodedChangeAtomId | undefined {
-	// In documents generated by clients on release >=2.2 (i.e., running the code from the PR that added this comment),
-	// renames are encoded as AttachAndDetach with a special id.
-	// This ensures forward-compatibility of clients on release <=2.1 with documents/ops generated by clients on release >=2.2.
-	if (encoded.attach.insert?.id === renameLocalId) {
-		assert(
-			encoded.detach.remove?.idOverride !== undefined,
-			0x9f8 /* Rename must have idOverride */,
-		);
-		return encoded.detach.remove.idOverride;
-	}
-}