@fluidframework/tree 2.1.1 → 2.2.1

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

@@ -6,7 +6,7 @@
 import { assert, unreachableCase } from "@fluidframework/core-utils/internal";
 
 import type { ChangeAtomId, RevisionMetadataSource, RevisionTag } from "../../core/index.js";
-import { type IdAllocator, brand } from "../../util/index.js";
+import { type IdAllocator, type Mutable, brand } from "../../util/index.js";
 import {
 	type CrossFieldManager,
 	CrossFieldTarget,
@@ -31,6 +31,7 @@ import {
 	type CellId,
 	type CellMark,
 	type Changeset,
+	type Detach,
 	type Mark,
 	type MarkEffect,
 	type MarkList,
@@ -54,6 +55,7 @@ import {
 	isAttachAndDetachEffect,
 	isDetach,
 	isNewAttach,
+	isRename,
 	isTombstone,
 	markEmptiesCells,
 	markFillsCells,
@@ -236,9 +238,11 @@ class RebaseQueue {
  * and `effect` is an effect from the same changeset whose target has been moved by the base changeset.
  * @returns a mark which has the composite effect of `mark` and `effect`.
  */
-function addMovedMarkEffect(mark: Mark, effect: MarkEffect): Mark {
+function addMovedMarkEffect(mark: Mark, effect: Detach): Mark {
 	if (isMoveIn(mark) && isMoveOut(effect)) {
 		return { ...mark, type: "Insert" };
+	} else if (isRename(mark) && isMoveOut(effect)) {
+		return { ...effect, count: mark.count, idOverride: mark.idOverride };
 	} else if (isAttachAndDetachEffect(mark) && isMoveIn(mark.attach) && isMoveOut(effect)) {
 		return { ...mark.detach, count: mark.count };
 	} else if (isTombstone(mark)) {
@@ -321,10 +325,6 @@ function rebaseMarkIgnoreChild(
 			baseMark.cellId !== undefined,
 			0x81a /* AttachAndDetach mark should target an empty cell */,
 		);
-		if (isMoveIn(baseMark.attach) && isMoveOut(baseMark.detach)) {
-			// Orphaned moves are effectively cell renames.
-			return withCellId(currMark, getDetachOutputCellId(baseMark.detach));
-		}
 		const halfRebasedMark = rebaseMarkIgnoreChild(
 			currMark,
 			{ ...baseMark.attach, cellId: cloneCellId(baseMark.cellId), count: baseMark.count },
@@ -335,6 +335,8 @@ function rebaseMarkIgnoreChild(
 			{ ...baseMark.detach, count: baseMark.count },
 			moveEffects,
 		);
+	} else if (isRename(baseMark)) {
+		return withCellId(currMark, getDetachOutputCellId(baseMark));
 	} else {
 		rebasedMark = currMark;
 	}
@@ -347,16 +349,29 @@ function rebaseMarkIgnoreChild(
  */
 function separateEffectsForMove(mark: MarkEffect): {
 	remains?: MarkEffect;
-	follows?: MarkEffect;
+	follows?: Detach;
 } {
 	const type = mark.type;
 	switch (type) {
 		case "Remove":
-		case "MoveOut":
+		case "MoveOut": {
+			// There are two scenarios that lead to a Detach mark having an idOverride:
+			// 1. The detach is a rollback (the idOverride the original id that the cell had in the input context of the attach being rolled back).
+			// 2. The detach has been composed with a Rename (the idOverride is the cell id in the output context of the rename).
+			// Since rollbacks are never rebased, we can safely assume that the idOverride is due to a Rename (scenario #2).
+			// While the detach must follow the node that it targets, the rename must remain in place because it targets the cell.
+			if (mark.idOverride !== undefined) {
+				const remains: MarkEffect = { type: "Rename", idOverride: mark.idOverride };
+				const follows: Mutable<MarkEffect> = { ...mark };
+				delete follows.idOverride;
+				return { remains, follows };
+			}
 			return { follows: mark };
+		}
 		case "AttachAndDetach":
 			return { follows: mark.detach, remains: mark.attach };
 		case "MoveIn":
+		case "Rename":
 			return { remains: mark };
 		case NoopMarkType:
 			return {};
@@ -382,7 +397,7 @@ function separateEffectsForMove(mark: MarkEffect): {
 
 // TODO: Reduce the duplication between this and other MoveEffect helpers
 function sendEffectToDest(
-	markEffect: MarkEffect,
+	markEffect: Detach,
 	moveEffects: MoveEffectTable,
 	{ revision, localId: id }: ChangeAtomId,
 	count: number,
@@ -488,7 +503,7 @@ function withCellId<TMark extends Mark>(mark: TMark, cellId: CellId | undefined)
 function getMovedEffectFromBaseMark(
 	moveEffects: MoveEffectTable,
 	baseMark: Mark,
-): MarkEffect | undefined {
+): Detach | undefined {
 	if (isMoveIn(baseMark)) {
 		return getMovedEffect(moveEffects, baseMark.revision, baseMark.id, baseMark.count);
 	} else if (isAttachAndDetachEffect(baseMark) && isMoveIn(baseMark.attach)) {
@@ -512,14 +527,16 @@ function getMovedEffect(
 	revision: RevisionTag | undefined,
 	id: MoveId,
 	count: number,
-): MarkEffect | undefined {
+): Detach | undefined {
 	const effect = getMoveEffect(moveEffects, CrossFieldTarget.Destination, revision, id, count);
 	assert(effect.length === count, 0x6f3 /* Expected effect to cover entire mark */);
 	const movedEffect = effect.value?.movedEffect;
-	if (movedEffect !== undefined && movedEffect.type === "MoveOut") {
+	if (movedEffect === undefined) {
+		return undefined;
+	}
+	if (isMoveOut(movedEffect)) {
 		moveEffects.moveKey(CrossFieldTarget.Source, movedEffect.revision, movedEffect.id, count);
 	}
-
 	return movedEffect;
 }
 

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

@@ -8,13 +8,16 @@ import { type RevisionTag, replaceAtomRevisions } from "../../core/index.js";
 import { MarkListFactory } from "./markListFactory.js";
 import {
 	type Changeset,
+	type Detach,
 	type HasMoveFields,
 	type HasRevisionTag,
 	type Mark,
 	type MarkEffect,
 	NoopMarkType,
+	type Rename,
 } from "./types.js";
 import type { MoveMarkEffect } from "./helperTypes.js";
+import { isDetach, isRename } from "./utils.js";
 
 export function replaceRevisions(
 	changeset: Changeset,
@@ -48,12 +51,17 @@ function updateMark(
 }
 
 function updateEffect<TMark extends MarkEffect>(
-	mark: TMark,
+	input: TMark,
 	revisionsToReplace: Set<RevisionTag | undefined>,
 	newRevision: RevisionTag | undefined,
 ): TMark {
+	const mark =
+		isDetach(input) || isRename(input)
+			? updateIdOverride(input, revisionsToReplace, newRevision)
+			: input;
 	const type = mark.type;
 	switch (type) {
+		case "Rename":
 		case NoopMarkType:
 			return mark;
 		case "AttachAndDetach":
@@ -78,13 +86,29 @@ function updateEffect<TMark extends MarkEffect>(
 	}
 }
 
+function updateIdOverride<TEffect extends Detach | Rename>(
+	effect: TEffect,
+	revisionsToReplace: Set<RevisionTag | undefined>,
+	newRevision: RevisionTag | undefined,
+): TEffect {
+	if (effect.idOverride !== undefined) {
+		const idOverride = replaceAtomRevisions(
+			effect.idOverride,
+			revisionsToReplace,
+			newRevision,
+		);
+		return { ...effect, idOverride };
+	} else {
+		return effect;
+	}
+}
+
 function updateMoveEffect<TEffect extends HasMoveFields>(
 	effect: TEffect,
 	revisionsToReplace: Set<RevisionTag | undefined>,
 	newRevision: RevisionTag | undefined,
 ): TEffect {
-	return effect.finalEndpoint !== undefined &&
-		revisionsToReplace.has(effect.finalEndpoint.revision)
+	return effect.finalEndpoint !== undefined
 		? updateRevision(
 				{
 					...effect,

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

@@ -9,10 +9,11 @@ import type { TAnySchema } from "@sinclair/typebox";
 import { DiscriminatedUnionDispatcher, type IJsonCodec } from "../../codec/index.js";
 import type {
 	ChangeEncodingContext,
+	ChangesetLocalId,
 	EncodedRevisionTag,
 	RevisionTag,
 } from "../../core/index.js";
-import { type JsonCompatibleReadOnly, type Mutable, fail } from "../../util/index.js";
+import { type JsonCompatibleReadOnly, type Mutable, brand, fail } from "../../util/index.js";
 import { makeChangeAtomIdCodec } from "../changeAtomIdCodec.js";
 
 import {
@@ -33,8 +34,9 @@ import {
 	type MoveOut,
 	NoopMarkType,
 	type Remove,
+	type Rename,
 } from "./types.js";
-import { isNoopMark } from "./utils.js";
+import { isNoopMark, normalizeCellRename } from "./utils.js";
 import type { FieldChangeEncodingContext } from "../index.js";
 import { EncodedNodeChangeset } from "../modular-schema/index.js";
 
@@ -130,6 +132,18 @@ export function makeV1Codec(
 							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(`Mark type: ${type} should not be encoded.`);
 				default:
@@ -214,11 +228,23 @@ export function makeV1Codec(
 		attachAndDetach(
 			encoded: Encoded.AttachAndDetach,
 			context: ChangeEncodingContext,
-		): AttachAndDetach {
+		): AttachAndDetach | Rename {
+			const attach = decoderLibrary.dispatch(encoded.attach, context) as Attach;
+			const detach = decoderLibrary.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.
+			if (attach.id === renameLocalId) {
+				assert(detach.idOverride !== undefined, 0x9f7 /* Rename must have idOverride */);
+				return {
+					type: "Rename",
+					idOverride: detach.idOverride,
+				};
+			}
 			return {
 				type: "AttachAndDetach",
-				attach: decoderLibrary.dispatch(encoded.attach, context) as Attach,
-				detach: decoderLibrary.dispatch(encoded.detach, context) as Detach,
+				attach,
+				detach,
 			};
 		},
 	});
@@ -285,13 +311,32 @@ export function makeV1Codec(
 				if (mark.cellId !== undefined) {
 					decodedMark.cellId = cellIdCodec.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) {
-					decodedMark.changes = context.decodeNode(mark.changes);
+					decodedMark2.changes = context.decodeNode(mark.changes);
 				}
-				marks.push(decodedMark);
+				marks.push(decodedMark2);
 			}
 			return marks;
 		},
 		encodedSchema: ChangesetSchema(EncodedNodeChangeset),
 	};
 }
+
+/**
+ * Arbitrary ID that is used to indicate a Rename effect.
+ */
+const renameLocalId: ChangesetLocalId = brand(-1);

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

@@ -6,13 +6,18 @@
 import { assert, unreachableCase } from "@fluidframework/core-utils/internal";
 import type { TAnySchema } from "@sinclair/typebox";
 
-import { DiscriminatedUnionDispatcher, type IJsonCodec } from "../../codec/index.js";
+import {
+	DiscriminatedUnionDispatcher,
+	type DiscriminatedUnionLibrary,
+	type IJsonCodec,
+} from "../../codec/index.js";
 import type {
 	ChangeEncodingContext,
+	ChangesetLocalId,
 	EncodedRevisionTag,
 	RevisionTag,
 } from "../../core/index.js";
-import { type JsonCompatibleReadOnly, type Mutable, fail } from "../../util/index.js";
+import { type JsonCompatibleReadOnly, type Mutable, brand, fail } from "../../util/index.js";
 import { makeChangeAtomIdCodec } from "../changeAtomIdCodec.js";
 
 import { Changeset as ChangesetSchema, type Encoded } from "./formatV2.js";
@@ -28,24 +33,21 @@ import {
 	type MoveOut,
 	NoopMarkType,
 	type Remove,
+	type Rename,
 } from "./types.js";
-import { isNoopMark } from "./utils.js";
+import { isNoopMark, normalizeCellRename } from "./utils.js";
 import type { FieldChangeEncodingContext } from "../index.js";
 import { EncodedNodeChangeset } from "../modular-schema/index.js";
+import type { SequenceCodecHelpers } from "./helperTypes.js";
 
-export function makeV2Codec(
+export function makeV2CodecHelpers(
 	revisionTagCodec: IJsonCodec<
 		RevisionTag,
 		EncodedRevisionTag,
 		EncodedRevisionTag,
 		ChangeEncodingContext
 	>,
-): IJsonCodec<
-	Changeset,
-	JsonCompatibleReadOnly,
-	JsonCompatibleReadOnly,
-	FieldChangeEncodingContext
-> {
+): SequenceCodecHelpers<MarkEffect, Encoded.MarkEffect> {
 	const changeAtomIdCodec = makeChangeAtomIdCodec(revisionTagCodec);
 	const markEffectCodec: IJsonCodec<
 		MarkEffect,
@@ -117,6 +119,18 @@ export function makeV2Codec(
 							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(`Mark type: ${type} should not be encoded.`);
 				default:
@@ -124,7 +138,7 @@ export function makeV2Codec(
 			}
 		},
 		decode(encoded: Encoded.MarkEffect, context: ChangeEncodingContext): MarkEffect {
-			return decoderLibrary.dispatch(encoded, context);
+			return decoderDispatcher.dispatch(encoded, context);
 		},
 	};
 
@@ -140,11 +154,11 @@ export function makeV2Codec(
 		return revisionTagCodec.decode(encodedRevision, context);
 	}
 
-	const decoderLibrary = new DiscriminatedUnionDispatcher<
+	const decoderLibrary: DiscriminatedUnionLibrary<
 		Encoded.MarkEffect,
 		/* args */ [context: ChangeEncodingContext],
 		MarkEffect
-	>({
+	> = {
 		moveIn(encoded: Encoded.MoveIn, context: ChangeEncodingContext): MoveIn {
 			const { id, finalEndpoint, revision } = encoded;
 			const mark: MoveIn = {
@@ -201,15 +215,55 @@ export function makeV2Codec(
 		attachAndDetach(
 			encoded: Encoded.AttachAndDetach,
 			context: ChangeEncodingContext,
-		): AttachAndDetach {
+		): 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.
+			if (attach.id === renameLocalId) {
+				assert(detach.idOverride !== undefined, 0x9f8 /* Rename must have idOverride */);
+				return {
+					type: "Rename",
+					idOverride: detach.idOverride,
+				};
+			}
 			return {
 				type: "AttachAndDetach",
-				attach: decoderLibrary.dispatch(encoded.attach, context) as Attach,
-				detach: decoderLibrary.dispatch(encoded.detach, context) as Detach,
+				attach,
+				detach,
 			};
 		},
-	});
+	};
 
+	const decoderDispatcher = new DiscriminatedUnionDispatcher<
+		Encoded.MarkEffect,
+		/* args */ [context: ChangeEncodingContext],
+		MarkEffect
+	>(decoderLibrary);
+
+	return {
+		changeAtomIdCodec,
+		markEffectCodec,
+		decoderLibrary,
+		decodeRevision,
+	};
+}
+
+export function makeV2Codec(
+	revisionTagCodec: IJsonCodec<
+		RevisionTag,
+		EncodedRevisionTag,
+		EncodedRevisionTag,
+		ChangeEncodingContext
+	>,
+): IJsonCodec<
+	Changeset,
+	JsonCompatibleReadOnly,
+	JsonCompatibleReadOnly,
+	FieldChangeEncodingContext
+> {
+	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.
@@ -255,13 +309,32 @@ export function makeV2Codec(
 				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) {
-					decodedMark.changes = context.decodeNode(mark.changes);
+					decodedMark2.changes = context.decodeNode(mark.changes);
 				}
-				marks.push(decodedMark);
+				marks.push(decodedMark2);
 			}
 			return marks;
 		},
 		encodedSchema: ChangesetSchema(EncodedNodeChangeset),
 	};
 }
+
+/**
+ * Arbitrary ID that is used to indicate a Rename effect.
+ */
+const renameLocalId: ChangesetLocalId = brand(-1);

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

@@ -0,0 +1,134 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import type { TAnySchema } from "@sinclair/typebox";
+
+import { DiscriminatedUnionDispatcher, type IJsonCodec } from "../../codec/index.js";
+import type {
+	ChangeEncodingContext,
+	EncodedRevisionTag,
+	RevisionTag,
+} from "../../core/index.js";
+import type { JsonCompatibleReadOnly } from "../../util/index.js";
+
+import { Changeset as ChangesetSchema, type Encoded } from "./formatV3.js";
+import type { Changeset, Mark, MarkEffect, Rename } from "./types.js";
+import { isNoopMark } from "./utils.js";
+import type { FieldChangeEncodingContext } from "../index.js";
+import { EncodedNodeChangeset } from "../modular-schema/index.js";
+import { makeV2CodecHelpers } from "./sequenceFieldCodecV2.js";
+
+export function makeV3Codec(
+	revisionTagCodec: IJsonCodec<
+		RevisionTag,
+		EncodedRevisionTag,
+		EncodedRevisionTag,
+		ChangeEncodingContext
+	>,
+): IJsonCodec<
+	Changeset,
+	JsonCompatibleReadOnly,
+	JsonCompatibleReadOnly,
+	FieldChangeEncodingContext
+> {
+	const {
+		changeAtomIdCodec: atomIdCodec,
+		markEffectCodec: markEffectV2Codec,
+		decoderLibrary: decoderLibraryV2,
+	} = makeV2CodecHelpers(revisionTagCodec);
+
+	const markEffectCodec: IJsonCodec<
+		MarkEffect,
+		Encoded.MarkEffect,
+		Encoded.MarkEffect,
+		ChangeEncodingContext
+	> = {
+		encode(effect: MarkEffect, context: ChangeEncodingContext): Encoded.MarkEffect {
+			const type = effect.type;
+			switch (type) {
+				case "Rename":
+					return {
+						rename: {
+							idOverride: atomIdCodec.encode(effect.idOverride, context),
+						},
+					};
+				default:
+					return markEffectV2Codec.encode(effect, context);
+			}
+		},
+		decode(encoded: Encoded.MarkEffect, context: ChangeEncodingContext): MarkEffect {
+			return decoderLibrary.dispatch(encoded, context);
+		},
+	};
+
+	const decoderLibrary = new DiscriminatedUnionDispatcher<
+		Encoded.MarkEffect,
+		/* args */ [context: ChangeEncodingContext],
+		MarkEffect
+	>({
+		...decoderLibraryV2,
+		rename(encoded: Encoded.Rename, context: ChangeEncodingContext): Rename {
+			return {
+				type: "Rename",
+				idOverride: atomIdCodec.decode(encoded.idOverride, context),
+			};
+		},
+	});
+
+	/**
+	 * 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> => {
+			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 = atomIdCodec.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 => {
+			const marks: Changeset = [];
+			for (const mark of changeset) {
+				const decodedMark: Mark = {
+					count: mark.count,
+				};
+
+				if (mark.effect !== undefined) {
+					Object.assign(decodedMark, markEffectCodec.decode(mark.effect, context.baseContext));
+				}
+				if (mark.cellId !== undefined) {
+					decodedMark.cellId = atomIdCodec.decode(mark.cellId, context.baseContext);
+				}
+				if (mark.changes !== undefined) {
+					decodedMark.changes = context.decodeNode(mark.changes);
+				}
+				marks.push(decodedMark);
+			}
+			return marks;
+		},
+		encodedSchema: ChangesetSchema(EncodedNodeChangeset),
+	};
+}

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

@@ -14,6 +14,7 @@ import type { Changeset, MarkList } from "./types.js";
 import type { FieldChangeEncodingContext } from "../index.js";
 import { makeV1Codec } from "./sequenceFieldCodecV1.js";
 import { makeV2Codec } from "./sequenceFieldCodecV2.js";
+import { makeV3Codec } from "./sequenceFieldCodecV3.js";
 
 export const sequenceFieldChangeCodecFactory = (
 	revisionTagCodec: IJsonCodec<
@@ -26,4 +27,5 @@ export const sequenceFieldChangeCodecFactory = (
 	makeCodecFamily<Changeset, FieldChangeEncodingContext>([
 		[1, makeV1Codec(revisionTagCodec)],
 		[2, makeV2Codec(revisionTagCodec)],
+		[3, makeV3Codec(revisionTagCodec)],
 	]);

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

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { assert, unreachableCase } from "@fluidframework/core-utils/internal";
+import { assert, unreachableCase, oob } from "@fluidframework/core-utils/internal";
 
 import {
 	type DeltaDetachedNodeChanges,
@@ -164,6 +164,12 @@ export function sequenceFieldToDelta(
 						local.push(deltaMark);
 					}
 					break;
+				case "Rename":
+					assert(
+						mark.cellId !== undefined,
+						0x9f9 /* Renames should only target empty cells */,
+					);
+					break;
 				default:
 					unreachableCase(type);
 			}
@@ -171,7 +177,7 @@ export function sequenceFieldToDelta(
 	}
 	// Remove trailing no-op marks
 	while (local.length > 0) {
-		const lastMark = local[local.length - 1];
+		const lastMark = local[local.length - 1] ?? oob();
 		if (
 			lastMark.attach !== undefined ||
 			lastMark.detach !== undefined ||