@fluidframework/tree 2.1.1 → 2.2.1

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

@@ -6,7 +6,6 @@
 import type { BTree } from "@tylerbu/sorted-btree-es6";
 import type {
 	ChangeAtomId,
-	ChangeAtomIdMap,
 	ChangesetLocalId,
 	FieldKey,
 	FieldKindIdentifier,
@@ -18,7 +17,6 @@ import type { TreeChunk } from "../chunked-forest/index.js";
 import type { CrossFieldTarget } from "./crossFieldQueries.js";
 
 /**
- * @internal
  */
 export interface ModularChangeset extends HasFieldChanges {
 	/**
@@ -37,13 +35,13 @@ export interface ModularChangeset extends HasFieldChanges {
 	/**
 	 * Maps from this changeset's canonical ID for a node (see comment on node aliases) to the changes for that node.
 	 */
-	readonly nodeChanges: ChangeAtomIdMap<NodeChangeset>;
+	readonly nodeChanges: ChangeAtomIdBTree<NodeChangeset>;
 
 	/**
 	 * Maps from this changeset's canonical ID for a node to the ID for the field which contains that node.
 	 */
 	// TODO: Should this be merged with `nodeChanges`?
-	readonly nodeToParent: ChangeAtomIdMap<FieldId>;
+	readonly nodeToParent: ChangeAtomIdBTree<FieldId>;
 
 	/**
 	 * Maps from a node ID to another ID for the same node.
@@ -56,15 +54,16 @@ export interface ModularChangeset extends HasFieldChanges {
 	 * Node aliases are preserved when composing changesets so we can avoid having to find and update all changed node IDs
 	 * in the field IDs in nodeToParent and crossFieldKeys.
 	 */
-	readonly nodeAliases: ChangeAtomIdMap<NodeId>;
+	readonly nodeAliases: ChangeAtomIdBTree<NodeId>;
 	readonly crossFieldKeys: CrossFieldKeyTable;
 	readonly constraintViolationCount?: number;
-	readonly builds?: ChangeAtomIdMap<TreeChunk>;
-	readonly destroys?: ChangeAtomIdMap<number>;
-	readonly refreshers?: ChangeAtomIdMap<TreeChunk>;
+	readonly builds?: ChangeAtomIdBTree<TreeChunk>;
+	readonly destroys?: ChangeAtomIdBTree<number>;
+	readonly refreshers?: ChangeAtomIdBTree<TreeChunk>;
 }
 
 export type TupleBTree<K, V> = Brand<BTree<K, V>, "TupleBTree">;
+export type ChangeAtomIdBTree<V> = TupleBTree<[RevisionTag | undefined, ChangesetLocalId], V>;
 export type CrossFieldKeyTable = TupleBTree<CrossFieldKeyRange, FieldId>;
 export type CrossFieldKeyRange = readonly [
 	CrossFieldTarget,
@@ -89,7 +88,6 @@ export interface FieldId {
 }
 
 /**
- * @internal
  */
 export interface NodeExistsConstraint {
 	violated: boolean;
@@ -97,7 +95,6 @@ export interface NodeExistsConstraint {
 
 /**
  * Changeset for a subtree rooted at a specific node.
- * @internal
  */
 export interface NodeChangeset extends HasFieldChanges {
 	nodeExistsConstraint?: NodeExistsConstraint;
@@ -106,19 +103,16 @@ export interface NodeChangeset extends HasFieldChanges {
 export type NodeId = ChangeAtomId;
 
 /**
- * @internal
  */
 export interface HasFieldChanges {
 	fieldChanges?: FieldChangeMap;
 }
 
 /**
- * @internal
  */
 export type FieldChangeMap = Map<FieldKey, FieldChange>;
 
 /**
- * @internal
  */
 export interface FieldChange {
 	fieldKind: FieldKindIdentifier;
@@ -126,6 +120,5 @@ export interface FieldChange {
 }
 
 /**
- * @internal
  */
 export type FieldChangeset = Brand<unknown, "FieldChangeset">;

package/src/feature-libraries/node-key/nodeKey.ts

@@ -15,7 +15,6 @@ import { type Brand, type Opaque, brand } from "../../util/index.js";
  * However, they are otherwise preferential to use over {@link StableNodeKey}s as they are much smaller.
  * For example, they are more efficient than {@link StableNodeKey}s when used as keys in a map.
  * {@link LocalNodeKey}s may be compared or equated via {@link compareLocalNodeKeys}.
- * @internal
  */
 export interface LocalNodeKey
 	extends Opaque<Brand<SessionSpaceCompressedId, "Local Node Key">> {}
@@ -24,7 +23,6 @@ export interface LocalNodeKey
  * A UUID which identifies a node in the tree.
  * This key is universally unique and stable forever; therefore it is safe to persist as data in a SharedTree or other DDS/database.
  * When not persisted or serialized, it is preferable to use a {@link LocalNodeKey} instead for better performance.
- * @internal
  */
 export type StableNodeKey = Brand<StableId, "Stable Node Key">;
 
@@ -34,7 +32,6 @@ export type StableNodeKey = Brand<StableId, "Stable Node Key">;
  * @param a - the first key to compare
  * @param b - the second key to compare
  * @returns `0` if `a` and `b` are the same key, otherwise `-1` if `a` is ordered before `b` or `1` if `a` is ordered after `b`.
- * @internal
  */
 export function compareLocalNodeKeys(a: LocalNodeKey, b: LocalNodeKey): -1 | 0 | 1 {
 	return a === b ? 0 : a > b ? 1 : -1;
@@ -42,7 +39,6 @@ export function compareLocalNodeKeys(a: LocalNodeKey, b: LocalNodeKey): -1 | 0 |
 
 /**
  * The TreeNodeSchemaIdentifier for node keys.
- * @internal
  * @privateRemarks TODO: Come up with a unified and collision-resistant naming schema for types defined by the system.
  * For now, we'll use `__` to reduce the change of collision, since this is what other internal properties use in Fluid.
  */

package/src/feature-libraries/node-key/nodeKeyManager.ts

@@ -13,7 +13,6 @@ import type { LocalNodeKey, StableNodeKey } from "./nodeKey.js";
 
 /**
  * An object which handles the generation of node keys as well as conversion between their two types ({@link StableNodeKey} and {@link LocalNodeKey}).
- * @internal
  */
 export interface NodeKeyManager {
 	/**

package/src/feature-libraries/object-forest/objectForest.ts

@@ -31,6 +31,7 @@ import {
 	type UpPath,
 	type Value,
 	aboveRootPlaceholder,
+	deepCopyMapTree,
 } from "../../core/index.js";
 import { createEmitter } from "../../events/index.js";
 import {
@@ -39,7 +40,6 @@ import {
 	assertValidRange,
 	brand,
 	fail,
-	mapIterable,
 } from "../../util/index.js";
 import { cursorForMapTreeNode, mapTreeFromCursor } from "../mapTreeCursor.js";
 import { type CursorWithNode, SynchronousCursor } from "../treeCursorUtils.js";
@@ -61,18 +61,6 @@ function getOrCreateField(mapTree: MutableMapTree, key: FieldKey): MutableMapTre
 	return newField;
 }
 
-function deepCopyMapTree(mapTree: MapTree): MutableMapTree {
-	return {
-		...mapTree,
-		fields: new Map(
-			mapIterable(mapTree.fields.entries(), ([key, field]) => [
-				key,
-				field.map(deepCopyMapTree),
-			]),
-		),
-	};
-}
-
 /**
  * Reference implementation of IEditableForest.
  *

package/src/feature-libraries/schemaBuilderBase.ts

@@ -17,7 +17,6 @@ import type { FlexFieldKind } from "./modular-schema/index.js";
 import {
 	Any,
 	type FlexAllowedTypes,
-	FlexFieldNodeSchema,
 	FlexFieldSchema,
 	type FlexList,
 	type FlexMapFieldSchema,
@@ -36,7 +35,6 @@ import {
 
 /**
  * Configuration for a SchemaBuilder.
- * @internal
  */
 export interface SchemaBuilderOptions<TScope extends string = string> {
 	/**
@@ -74,8 +72,7 @@ export interface SchemaBuilderOptions<TScope extends string = string> {
 
 /**
  * Builds schema libraries, and the schema within them.
- * @internal
- *
+ * *
  * @privateRemarks
  * This class does not directly depend on any specific field kinds,
  * or bake in any defaults that might have compatibility implications.
@@ -269,46 +266,6 @@ export class SchemaBuilderBase<
 		>;
 	}
 
-	/**
-	 * Define (and add to this library) a {@link FlexFieldNodeSchema}.
-	 *
-	 * The name must be unique among all TreeNodeSchema in the the document schema.
-	 *
-	 * @privateRemarks
-	 * TODO: Write and link document outlining field vs node data model and the separation of concerns related to that.
-	 * TODO: Maybe find a better name for this.
-	 */
-	public fieldNode<Name extends TName, const T extends FlexImplicitFieldSchema>(
-		name: Name,
-		fieldSchema: T,
-	): FlexFieldNodeSchema<`${TScope}.${Name}`, NormalizeField<T, TDefaultKind>> {
-		const schema = FlexFieldNodeSchema.create(
-			this,
-			this.scoped(name),
-			this.normalizeField(fieldSchema),
-		);
-		this.addNodeSchema(schema);
-		return schema;
-	}
-
-	/**
-	 * Same as `fieldNode` but with less type safety and works for recursive objects.
-	 * Reduced type safety is a side effect of a workaround for a TypeScript limitation.
-	 *
-	 * See {@link Unenforced} for details.
-	 *
-	 * TODO: Make this work with ImplicitFieldSchema.
-	 */
-	public fieldNodeRecursive<
-		Name extends TName,
-		const T extends Unenforced<FlexImplicitFieldSchema>,
-	>(name: Name, t: T): FlexFieldNodeSchema<`${TScope}.${Name}`, T> {
-		return this.fieldNode(name, t as FlexImplicitFieldSchema) as FlexFieldNodeSchema<
-			`${TScope}.${Name}`,
-			T
-		>;
-	}
-
 	/**
 	 * Define a {@link FlexFieldSchema}.
 	 *
@@ -361,7 +318,6 @@ export class SchemaBuilderBase<
 /**
  * Schema information collected by a SchemaBuilder, including referenced libraries.
  * Can be aggregated into other libraries by adding to their builders.
- * @internal
  */
 export interface SchemaLibrary extends SchemaCollection {
 	/**
@@ -372,13 +328,11 @@ export interface SchemaLibrary extends SchemaCollection {
 
 /**
  * Generalized version of AllowedTypes allowing for more concise expressions in some cases.
- * @internal
  */
 export type FlexImplicitAllowedTypes = FlexAllowedTypes | FlexTreeNodeSchema | Any;
 
 /**
  * Normalizes an {@link FlexImplicitAllowedTypes} into  {@link FlexAllowedTypes}.
- * @internal
  */
 export type NormalizeAllowedTypes<TSchema extends FlexImplicitAllowedTypes> =
 	TSchema extends FlexTreeNodeSchema
@@ -405,7 +359,6 @@ export function normalizeAllowedTypes<TSchema extends FlexImplicitAllowedTypes>(
 
 /**
  * Normalizes an {@link FlexImplicitFieldSchema} into a {@link FlexFieldSchema}.
- * @internal
  */
 export type NormalizeField<
 	TSchema extends FlexImplicitFieldSchema,
@@ -436,6 +389,5 @@ export function normalizeField<
 
 /**
  * Type that when combined with a default {@link FlexFieldKind} can be normalized into a {@link FlexFieldSchema}.
- * @internal
  */
 export type FlexImplicitFieldSchema = FlexFieldSchema | FlexImplicitAllowedTypes;

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

@@ -62,6 +62,7 @@ import {
 	isImpactfulCellRename,
 	isNewAttach,
 	isNoopMark,
+	isRename,
 	markEmptiesCells,
 	markFillsCells,
 	markHasCellEffect,
@@ -179,8 +180,36 @@ function composeMarksIgnoreChild(
 	newMark: Mark,
 	moveEffects: MoveEffectTable,
 ): Mark {
+	if (isNoopMark(baseMark)) {
+		return newMark;
+	} else if (isNoopMark(newMark)) {
+		return baseMark;
+	}
+
+	if (isRename(baseMark) && isRename(newMark)) {
+		return { ...baseMark, idOverride: newMark.idOverride };
+	} else if (isRename(baseMark)) {
+		assert(
+			isAttach(newMark) || isAttachAndDetachEffect(newMark),
+			0x9f1 /* Unexpected mark type */,
+		);
+		return { ...newMark, cellId: baseMark.cellId };
+	} else if (isRename(newMark)) {
+		assert(
+			isDetach(baseMark) || isAttachAndDetachEffect(baseMark),
+			0x9f2 /* Unexpected mark type */,
+		);
+		return isDetach(baseMark)
+			? { ...baseMark, idOverride: newMark.idOverride }
+			: { ...baseMark, detach: { ...baseMark.detach, idOverride: newMark.idOverride } };
+	}
+
 	if (isImpactfulCellRename(newMark)) {
 		const newAttachAndDetach = asAttachAndDetach(newMark);
+		assert(
+			newAttachAndDetach.cellId !== undefined,
+			0x9f3 /* Impactful cell rename must target empty cell */,
+		);
 		const newDetachRevision = newAttachAndDetach.detach.revision;
 		if (markEmptiesCells(baseMark)) {
 			// baseMark is a detach which cancels with the attach portion of the AttachAndDetach,
@@ -241,6 +270,10 @@ function composeMarksIgnoreChild(
 		}
 
 		if (isImpactfulCellRename(baseMark)) {
+			assert(
+				baseMark.cellId !== undefined,
+				0x9f4 /* Impactful cell rename must target empty cell */,
+			);
 			const baseAttachAndDetach = asAttachAndDetach(baseMark);
 			const newOutputId = getOutputCellId(newAttachAndDetach);
 
@@ -256,16 +289,15 @@ function composeMarksIgnoreChild(
 				finalDetach.revision = detachRevision;
 			}
 
-			return normalizeCellRename({
-				type: "AttachAndDetach",
-				cellId: baseMark.cellId,
-				count: baseMark.count,
-				attach: originalAttach,
-				detach: finalDetach,
-			});
+			return normalizeCellRename(baseMark.cellId, baseMark.count, originalAttach, finalDetach);
 		}
 
-		return normalizeCellRename(newAttachAndDetach);
+		return normalizeCellRename(
+			newAttachAndDetach.cellId,
+			newAttachAndDetach.count,
+			newAttachAndDetach.attach,
+			newAttachAndDetach.detach,
+		);
 	}
 	if (isImpactfulCellRename(baseMark)) {
 		const baseAttachAndDetach = asAttachAndDetach(baseMark);
@@ -324,11 +356,6 @@ function composeMarksIgnoreChild(
 	}
 
 	if (!markHasCellEffect(baseMark) && !markHasCellEffect(newMark)) {
-		if (isNoopMark(baseMark)) {
-			return newMark;
-		} else if (isNoopMark(newMark)) {
-			return baseMark;
-		}
 		return createNoopMark(newMark.count, undefined, getInputCellId(baseMark));
 	} else if (!markHasCellEffect(baseMark)) {
 		return newMark;
@@ -407,13 +434,7 @@ function composeMarksIgnoreChild(
 			// The output and input cell IDs are the same, so this mark has no effect.
 			return { count: baseMark.count, cellId: baseMark.cellId };
 		}
-		return normalizeCellRename({
-			type: "AttachAndDetach",
-			cellId: baseMark.cellId,
-			count: baseMark.count,
-			attach,
-			detach,
-		});
+		return normalizeCellRename(baseMark.cellId, baseMark.count, attach, detach);
 	} else {
 		const length = baseMark.count;
 		return createNoopMark(length, undefined);

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

@@ -18,7 +18,7 @@ const HasMoveId = Type.Object({ id: MoveId });
 
 const IdRange = Type.Tuple([ChangesetLocalIdSchema, CellCount]);
 
-const CellId = EncodedChangeAtomId;
+export const CellId = EncodedChangeAtomId;
 
 const HasRevisionTag = Type.Object({ revision: Type.Optional(RevisionTagSchema) });
 
@@ -70,7 +70,7 @@ const AttachAndDetach = Type.Object({
 	detach: Detach,
 });
 
-const MarkEffect = Type.Object(
+export const MarkEffect = Type.Object(
 	{
 		// Note: `noop` is encoded by omitting `effect` from the encoded cell mark, so is not included here.
 		insert: Type.Optional(Insert),
@@ -82,7 +82,7 @@ const MarkEffect = Type.Object(
 	unionOptions,
 );
 
-const CellMark = <TMark extends TSchema, TNodeChange extends TSchema>(
+export const CellMark = <TMark extends TSchema, TNodeChange extends TSchema>(
 	tMark: TMark,
 	tNodeChange: TNodeChange,
 	// Return type is intentionally derived.

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

@@ -0,0 +1,65 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { type ObjectOptions, type Static, type TSchema, Type } from "@sinclair/typebox";
+
+import { unionOptions } from "../../codec/index.js";
+import {
+	CellId,
+	CellMark,
+	type Encoded as EncodedV2,
+	MarkEffect as MarkEffectV2,
+} from "./formatV2.js";
+
+const noAdditionalProps: ObjectOptions = { additionalProperties: false };
+
+const Rename = Type.Object(
+	{
+		idOverride: CellId,
+	},
+	noAdditionalProps,
+);
+
+const MarkEffect = Type.Composite(
+	[MarkEffectV2, Type.Object({ rename: Type.Optional(Rename) })],
+	unionOptions,
+);
+
+// Return type is intentionally derived.
+// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+const Mark = <Schema extends TSchema>(tNodeChange: Schema) =>
+	CellMark(MarkEffect, tNodeChange);
+
+// Return type is intentionally derived.
+// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+export const Changeset = <Schema extends TSchema>(tNodeChange: Schema) =>
+	Type.Array(Mark(tNodeChange));
+
+/**
+ * @privateRemarks - Many of these names are currently used in the sequence-field types. Putting them in a namespace makes codec code more readable.
+ */
+export namespace Encoded {
+	export type CellCount = EncodedV2.CellCount;
+
+	export type MoveId = EncodedV2.MoveId;
+	export type IdRange = EncodedV2.IdRange;
+	export type CellId = EncodedV2.CellId;
+	export type Insert = EncodedV2.Insert;
+	export type MoveIn = EncodedV2.MoveIn;
+	export type Remove = EncodedV2.Remove;
+	export type MoveOut = EncodedV2.MoveOut;
+	export type Attach = EncodedV2.Attach;
+	export type Detach = EncodedV2.Detach;
+	export type AttachAndDetach = EncodedV2.AttachAndDetach;
+	export type CellMark<
+		Schema extends TSchema,
+		TNodeChange extends TSchema,
+	> = EncodedV2.CellMark<Schema, TNodeChange>;
+
+	export type Rename = Static<typeof Rename>;
+	export type MarkEffect = Static<typeof MarkEffect>;
+	export type Mark<Schema extends TSchema> = Static<ReturnType<typeof Mark<Schema>>>;
+	export type Changeset<Schema extends TSchema> = Static<ReturnType<typeof Changeset<Schema>>>;
+}

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

@@ -3,6 +3,15 @@
  * Licensed under the MIT License.
  */
 
+import type { DiscriminatedUnionLibrary, IJsonCodec } from "../../codec/index.js";
+import type {
+	ChangeAtomId,
+	ChangeEncodingContext,
+	EncodedRevisionTag,
+	RevisionTag,
+} from "../../core/index.js";
+import type { EncodedChangeAtomId } from "../modular-schema/index.js";
+
 import type {
 	AttachAndDetach,
 	CellId,
@@ -25,3 +34,27 @@ export type EmptyOutputCellMark = CellMark<Detach | AttachAndDetach>;
 export type MoveMarkEffect = MoveOut | MoveIn;
 export type DetachOfRemovedNodes = Detach & { cellId: CellId };
 export type CellRename = AttachAndDetach | DetachOfRemovedNodes;
+
+export interface SequenceCodecHelpers<TDecodedMarkEffect, TEncodedMarkEffect extends object> {
+	readonly changeAtomIdCodec: IJsonCodec<
+		ChangeAtomId,
+		EncodedChangeAtomId,
+		EncodedChangeAtomId,
+		ChangeEncodingContext
+	>;
+	readonly markEffectCodec: IJsonCodec<
+		TDecodedMarkEffect,
+		TEncodedMarkEffect,
+		TEncodedMarkEffect,
+		ChangeEncodingContext
+	>;
+	readonly decoderLibrary: DiscriminatedUnionLibrary<
+		TEncodedMarkEffect,
+		/* args */ [context: ChangeEncodingContext],
+		TDecodedMarkEffect
+	>;
+	readonly decodeRevision: (
+		encodedRevision: EncodedRevisionTag | undefined,
+		context: ChangeEncodingContext,
+	) => RevisionTag;
+}

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

@@ -22,6 +22,7 @@ export type {
 	HasMarkFields,
 	CellMark,
 	AttachAndDetach,
+	Rename,
 } from "./types.js";
 export { DetachIdOverrideType } from "./formatV1.js";
 export {

package/src/feature-libraries/sequence-field/invert.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 { RevisionTag } from "../../core/index.js";
 import { type IdAllocator, type Mutable, fail } from "../../util/index.js";
@@ -27,6 +27,7 @@ import {
 	type NoopMark,
 	NoopMarkType,
 	type Remove,
+	type Rename,
 } from "./types.js";
 import {
 	extractMarkEffect,
@@ -88,6 +89,21 @@ function invertMark(
 		case NoopMarkType: {
 			return [mark];
 		}
+		case "Rename": {
+			const inputId = getInputCellId(mark);
+			assert(inputId !== undefined, 0x9f5 /* Rename mark must have cell ID */);
+			const inverse: Mutable<CellMark<Rename>> = {
+				type: "Rename",
+				count: mark.count,
+				cellId: mark.idOverride,
+				// Unlike a remove or move-out, which follow a node, there is no way for this mark to assign the original input cell ID to another cell.
+				// This means it should be safe to always restore the input cell ID (as opposed to only doing it on rollbacks).
+				// Despite that, we still only do it on rollback for the sake of consistency: once a cell has been assigned an ID,
+				// the only way for that cell to be assigned that ID again is if it is rolled back to that state.
+				idOverride: isRollback ? inputId : { localId: inputId.localId },
+			};
+			return [withNodeChange(inverse, mark.changes)];
+		}
 		case "Remove": {
 			assert(mark.revision !== undefined, 0x5a1 /* Unable to revert to undefined revision */);
 			const outputId = getOutputCellId(mark);
@@ -221,7 +237,7 @@ function invertMark(
 				0x80d /* Only expected MoveIn marks to be split when inverting */,
 			);
 
-			let detachInverse = detachInverses[0];
+			let detachInverse = detachInverses[0] ?? oob();
 			assert(isAttach(detachInverse), 0x80e /* Inverse of a detach should be an attach */);
 
 			const inverses: Mark[] = [];
@@ -243,28 +259,22 @@ function invertMark(
 					continue;
 				}
 				assert(isDetach(attachInverse), 0x810 /* Inverse of an attach should be a detach */);
-
-				const inverted: Mark = {
-					type: "AttachAndDetach",
-					count: attachInverse.count,
-					attach: extractMarkEffect(detachInverseCurr),
-					detach: extractMarkEffect(attachInverse),
-				};
-
-				if (detachInverseCurr.cellId !== undefined) {
-					inverted.cellId = detachInverseCurr.cellId;
-				}
-
-				if (detachInverseCurr.changes !== undefined) {
-					inverted.changes = detachInverseCurr.changes;
+				assert(detachInverseCurr.cellId !== undefined, 0x9f6 /* Expected empty cell */);
+				const inverted = normalizeCellRename(
+					detachInverseCurr.cellId,
+					attachInverse.count,
+					extractMarkEffect(detachInverseCurr),
+					extractMarkEffect(attachInverse),
+				);
+				if (detachInverse.changes !== undefined) {
+					inverted.changes = detachInverse.changes;
 				}
 
 				if (attachInverse.changes !== undefined) {
 					assert(inverted.changes === undefined, 0x811 /* Unexpected node changes */);
 					inverted.changes = attachInverse.changes;
 				}
-
-				inverses.push(normalizeCellRename(inverted));
+				inverses.push(inverted);
 			}
 
 			return inverses;

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

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { assert } from "@fluidframework/core-utils/internal";
+import { assert, oob } from "@fluidframework/core-utils/internal";
 import { type MoveEffectTable, splitMarkForMoveEffects } from "./moveEffectTable.js";
 import type { Mark } from "./types.js";
 import { splitMark } from "./utils.js";
@@ -37,7 +37,7 @@ export class MarkQueue {
 
 		const splitMarks = splitMarkForMoveEffects(mark, this.moveEffects);
 		for (let i = splitMarks.length - 1; i > 0; i--) {
-			this.stack.push(splitMarks[i]);
+			this.stack.push(splitMarks[i] ?? oob());
 		}
 		return splitMarks[0];
 	}

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

@@ -14,7 +14,7 @@ import {
 } from "../modular-schema/index.js";
 
 import type { MoveMarkEffect } from "./helperTypes.js";
-import type { CellMark, Mark, MarkEffect, MoveId, MoveIn, MoveOut } from "./types.js";
+import type { CellMark, Detach, Mark, MarkEffect, MoveId, MoveIn, MoveOut } from "./types.js";
 import { isAttachAndDetachEffect, splitMark, splitMarkEffect } from "./utils.js";
 
 export type MoveEffectTable = CrossFieldManager<MoveEffect>;
@@ -33,7 +33,7 @@ export interface MoveEffect {
 	 * Only used during rebasing.
 	 * An effect from changeset being rebased which should be moved to the same position as this mark.
 	 */
-	movedEffect?: MarkEffect;
+	movedEffect?: Detach;
 
 	/**
 	 * Rebased changes for a node which has been moved to the position of this mark.