@fluidframework/tree 2.33.0-333010 → 2.33.0

package/src/core/tree/visitDelta.ts

@@ -10,13 +10,7 @@ import type { FieldKey } from "../schema-stored/index.js";
 
 import { mapCursorField, type ITreeCursorSynchronous } from "./cursor.js";
 import type * as Delta from "./delta.js";
-import {
-	areDetachedNodeIdsEqual,
-	isAttachMark,
-	isDetachMark,
-	isReplaceMark,
-	offsetDetachId,
-} from "./deltaUtil.js";
+import { areDetachedNodeIdsEqual, offsetDetachId } from "./deltaUtil.js";
 import type { DetachedFieldIndex } from "./detachedFieldIndex.js";
 import type { ForestRootId, Major, Minor } from "./detachedFieldIndexTypes.js";
 import type { NodeIndex, PlaceIndex, Range } from "./pathTree.js";
@@ -32,24 +26,11 @@ import type { RevisionTag, TreeChunk } from "../index.js";
  * 4. root destructions
  *
  * The core idea is that before content can be attached, it must first exist and be in a detached field.
- * The detach pass is therefore responsible for making sure that all roots that needs to be attached during the
- * attach pass are detached.
- * In practice, this means the detach pass must:
- * - Create all subtrees that need to be created
- * - Detach all moved nodes
- *
- * In addition to that, the detach pass also detaches nodes that need removing, with the exception of nodes that get
- * replaced. The reason for this exception is that we need to be able to communicate replaces as atomic operations.
- * In order to do that, we need to wait until we are sure that the content to attach is available as a detached root.
- * Replaces are therefore handled during the attach pass.
- * Note that this could theoretically lead to a situation where, in the attach pass, one replace wants to attach
- * a node that has yet to be detached by another replace. This does not occur in practice because we do not support
- * editing operations that would lead to this situation.
  *
  * While the detach pass ensures that nodes to be attached are in a detached state, it does not guarantee that they
- * reside in the correct detach field. That is the responsibility of the root transfers phase.
+ * reside in the correct detached field. That is the responsibility of the root transfers phase.
  *
- * The attach phase carries out attaches and replaces.
+ * The attach phase carries out attaches.
  *
  * After the attach phase, roots destruction is carried out.
  * This needs to happen last to allow modifications to detached roots to be applied before they are destroyed.
@@ -57,9 +38,6 @@ import type { RevisionTag, TreeChunk } from "../index.js";
  * The details of the delta visit algorithm can impact how/when events are emitted by the objects that own the visitors.
  * For example, as of 2024-03-27, the subtreeChanged event of an AnchorNode is emitted when exiting a node during a
  * delta visit, and thus the two-pass nature of the algorithm means the event fires twice for any given change.
- * This two-pass nature also means that the event may fire at a time where no change is visible in the tree. E.g.,
- * if a node is being replaced, when the event fires during the detach pass no change in the tree has happened so the
- * listener won't see any; then when it fires during the attach pass, the change will be visible in the event listener.
  */
 
 /**
@@ -233,7 +211,7 @@ function transferRoots(
 			const oldField = detachedFieldIndex.toFieldKey(oldRootId);
 			const newField = detachedFieldIndex.toFieldKey(newRootId);
 			visitor.enterField(oldField);
-			visitor.detach({ start: 0, end: 1 }, newField, newId);
+			visitor.detach({ start: 0, end: 1 }, newField, newId, false);
 			visitor.exitField(oldField);
 			detachedFieldIndex.deleteEntry(oldId);
 		}
@@ -285,22 +263,15 @@ export interface DeltaVisitor {
 	 * @param destination - The key for a new detached field.
 	 * A field with this key must not already exist.
 	 * @param id - The ID assigned to the first detached node as a result of the detach. The other nodes in the detached range are assigned subsequent IDs.
+	 * @param isReplaced - Whether the detached content will be replaced by a later attach.
+	 * This is not guaranteed to be true in all cases where it could be true,
+	 * but it is guaranteed to be true in all cases where a later attach is needed to keep the data compliant with the schema.
 	 */
-	detach(source: Range, destination: FieldKey, id: Delta.DetachedNodeId): void;
-	/**
-	 * Replaces a range of nodes in the current field by transferring them out to a new detached field
-	 * and transferring in all the nodes from an existing detached field in their place.
-	 * The number of nodes being detached must match the number of nodes being attached.
-	 * @param newContentSource - The detached field to transfer the new nodes from.
-	 * @param range - The bounds of the range of nodes to replace.
-	 * @param oldContentDestination - The key for a new detached field to transfer the old nodes to.
-	 * @param oldContentId - The ID assigned to the first replaced node as a result of the replace. The other nodes in the replaced range are assigned subsequent IDs.
-	 */
-	replace(
-		newContentSource: FieldKey,
-		range: Range,
-		oldContentDestination: FieldKey,
-		oldContentId: Delta.DetachedNodeId,
+	detach(
+		source: Range,
+		destination: FieldKey,
+		id: Delta.DetachedNodeId,
+		isReplaced: boolean,
 	): void;
 
 	/**
@@ -417,13 +388,8 @@ function visitNode(
 
 /**
  * Performs the following:
- * - Performs all root creations
- * - Collects all roots that may need a detach pass
  * - Collects all roots that may need an attach pass
- * - Collects all relocates
- * - Collects all destructions
- * - Executes detaches (bottom-up) provided they are not part of a replace
- * (because we want to wait until we are sure content to attach is available as a root)
+ * - Executes detaches (bottom-up)
  */
 function detachPass(
 	fieldChanges: Delta.FieldChanges,
@@ -439,18 +405,18 @@ function detachPass(
 			);
 			visitNode(index, mark.fields, visitor, config);
 		}
-		if (isDetachMark(mark)) {
+		if (mark.detach !== undefined) {
 			for (let i = 0; i < mark.count; i += 1) {
-				// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-				const id = offsetDetachId(mark.detach!, i);
+				const id = offsetDetachId(mark.detach, i);
 				const root = config.detachedFieldIndex.createEntry(id, config.latestRevision);
 				if (mark.fields !== undefined) {
 					config.attachPassRoots.set(root, mark.fields);
 				}
 				const field = config.detachedFieldIndex.toFieldKey(root);
-				visitor.detach({ start: index, end: index + 1 }, field, id);
+				visitor.detach({ start: index, end: index + 1 }, field, id, mark.attach !== undefined);
 			}
-		} else if (!isAttachMark(mark)) {
+		}
+		if (mark.detach === undefined && mark.attach === undefined) {
 			index += mark.count;
 		}
 	}
@@ -534,8 +500,6 @@ function collectDestroys(
 /**
  * Preforms the following:
  * - Executes attaches (top-down) applying nested changes on the attached nodes
- * - Executes replaces (top-down) applying nested changes on the attached nodes
- * - Collects detached roots (from replaces) that need an attach pass
  */
 function attachPass(
 	fieldChanges: Delta.FieldChanges,
@@ -544,10 +508,9 @@ function attachPass(
 ): void {
 	let index = 0;
 	for (const mark of fieldChanges) {
-		if (isAttachMark(mark) || isReplaceMark(mark)) {
+		if (mark.attach !== undefined) {
 			for (let i = 0; i < mark.count; i += 1) {
-				// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-				const offsetAttachId = offsetDetachId(mark.attach!, i);
+				const offsetAttachId = offsetDetachId(mark.attach, i);
 				let sourceRoot = config.detachedFieldIndex.tryGetEntry(offsetAttachId);
 				if (sourceRoot === undefined) {
 					const tree = tryGetFromNestedMap(
@@ -567,28 +530,7 @@ function attachPass(
 				}
 				const sourceField = config.detachedFieldIndex.toFieldKey(sourceRoot);
 				const offsetIndex = index + i;
-				if (isReplaceMark(mark)) {
-					// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-					const destinationId = offsetDetachId(mark.detach!, i);
-					const rootDestination = config.detachedFieldIndex.createEntry(
-						destinationId,
-						config.latestRevision,
-					);
-					const destinationField = config.detachedFieldIndex.toFieldKey(rootDestination);
-					visitor.replace(
-						sourceField,
-						{ start: offsetIndex, end: offsetIndex + 1 },
-						destinationField,
-						destinationId,
-					);
-					// We may need to do a second pass on the detached nodes
-					if (mark.fields !== undefined) {
-						config.attachPassRoots.set(rootDestination, mark.fields);
-					}
-				} else {
-					// This a simple attach
-					visitor.attach(sourceField, 1, offsetIndex);
-				}
+				visitor.attach(sourceField, 1, offsetIndex);
 				config.detachedFieldIndex.deleteEntry(offsetAttachId);
 				const fields = config.attachPassRoots.get(sourceRoot);
 				if (fields !== undefined) {
@@ -596,10 +538,11 @@ function attachPass(
 					visitNode(offsetIndex, fields, visitor, config);
 				}
 			}
-		} else if (!isDetachMark(mark) && mark.fields !== undefined) {
+		}
+		if (mark.detach === undefined && mark.fields !== undefined) {
 			visitNode(index, mark.fields, visitor, config);
 		}
-		if (!isDetachMark(mark)) {
+		if (mark.detach === undefined || mark.attach !== undefined) {
 			index += mark.count;
 		}
 	}

package/src/core/tree/visitorUtils.ts

@@ -3,8 +3,6 @@
  * Licensed under the MIT License.
  */
 
-import { assert } from "@fluidframework/core-utils/internal";
-
 import type { ICodecOptions } from "../../codec/index.js";
 import { type IdAllocator, idAllocatorFromMaxId } from "../../util/index.js";
 import type { RevisionTag, RevisionTagCodec } from "../rebase/index.js";
@@ -51,41 +49,46 @@ export function announceDelta(
 	detachedFieldIndex: DetachedFieldIndex,
 ): void {
 	const visitor = deltaProcessor.acquireVisitor();
-	visitDelta(delta, combineVisitors([visitor], [visitor]), detachedFieldIndex, latestRevision);
+	visitDelta(delta, combineVisitors([visitor]), detachedFieldIndex, latestRevision);
 	visitor.free();
 }
 
+export interface CombinedVisitor extends DeltaVisitor {
+	readonly type: "Combined";
+
+	readonly visitors: readonly CombinableVisitor[];
+}
+
+export type CombinableVisitor =
+	| (DeltaVisitor & { type?: never })
+	| AnnouncedVisitor
+	| CombinedVisitor;
+
 /**
+ * Combines multiple visitors into a single visitor.
  * @param visitors - The returned visitor invokes the corresponding events for all these visitors, in order.
- * @param announcedVisitors - Subset of `visitors` to also call {@link AnnouncedVisitor} methods on.
- * This must be a subset of `visitors`: if not the visitor will not have its path correctly set when the events are triggered.
- * When `visitors` are making changes to data, `announcedVisitors` can be used to get extra events before or after all the changes from all the visitors have been made.
- * This can, for example, enable visitors to have access to the tree in these extra events despite multiple separate visitors updating different tree related data-structures.
  * @returns a DeltaVisitor combining all `visitors`.
  */
-export function combineVisitors(
-	visitors: readonly DeltaVisitor[],
-	announcedVisitors: readonly AnnouncedVisitor[] = [],
-): DeltaVisitor {
-	{
-		const set = new Set(visitors);
-		for (const item of announcedVisitors) {
-			assert(set.has(item), 0x8c8 /* AnnouncedVisitor would not get traversed */);
-		}
-	}
+export function combineVisitors(visitors: readonly CombinableVisitor[]): CombinedVisitor {
+	const allVisitors = visitors.flatMap((v) => (v.type === "Combined" ? v.visitors : [v]));
+	const announcedVisitors = allVisitors.filter(
+		(v): v is AnnouncedVisitor => v.type === "Announced",
+	);
 	return {
+		type: "Combined",
+		visitors: allVisitors,
 		free: () => visitors.forEach((v) => v.free()),
 		create: (...args) => {
-			visitors.forEach((v) => v.create(...args));
+			allVisitors.forEach((v) => v.create(...args));
 			announcedVisitors.forEach((v) => v.afterCreate(...args));
 		},
 		destroy: (...args) => {
 			announcedVisitors.forEach((v) => v.beforeDestroy(...args));
-			visitors.forEach((v) => v.destroy(...args));
+			allVisitors.forEach((v) => v.destroy(...args));
 		},
 		attach: (source: FieldKey, count: number, destination: PlaceIndex) => {
 			announcedVisitors.forEach((v) => v.beforeAttach(source, count, destination));
-			visitors.forEach((v) => v.attach(source, count, destination));
+			allVisitors.forEach((v) => v.attach(source, count, destination));
 			announcedVisitors.forEach((v) =>
 				v.afterAttach(source, {
 					start: destination,
@@ -93,33 +96,22 @@ export function combineVisitors(
 				}),
 			);
 		},
-		detach: (source: Range, destination: FieldKey, id: DetachedNodeId) => {
-			announcedVisitors.forEach((v) => v.beforeDetach(source, destination));
-			visitors.forEach((v) => v.detach(source, destination, id));
-			announcedVisitors.forEach((v) =>
-				v.afterDetach(source.start, source.end - source.start, destination),
-			);
-		},
-		replace: (
-			newContent: FieldKey,
-			oldContent: Range,
-			oldContentDestination: FieldKey,
-			oldContentId: DetachedNodeId,
+		detach: (
+			source: Range,
+			destination: FieldKey,
+			id: DetachedNodeId,
+			isReplaced: boolean,
 		) => {
+			announcedVisitors.forEach((v) => v.beforeDetach(source, destination, isReplaced));
+			allVisitors.forEach((v) => v.detach(source, destination, id, isReplaced));
 			announcedVisitors.forEach((v) =>
-				v.beforeReplace(newContent, oldContent, oldContentDestination),
-			);
-			visitors.forEach((v) =>
-				v.replace(newContent, oldContent, oldContentDestination, oldContentId),
-			);
-			announcedVisitors.forEach((v) =>
-				v.afterReplace(newContent, oldContent, oldContentDestination),
+				v.afterDetach(source.start, source.end - source.start, destination, isReplaced),
 			);
 		},
-		enterNode: (...args) => visitors.forEach((v) => v.enterNode(...args)),
-		exitNode: (...args) => visitors.forEach((v) => v.exitNode(...args)),
-		enterField: (...args) => visitors.forEach((v) => v.enterField(...args)),
-		exitField: (...args) => visitors.forEach((v) => v.exitField(...args)),
+		enterNode: (...args) => allVisitors.forEach((v) => v.enterNode(...args)),
+		exitNode: (...args) => allVisitors.forEach((v) => v.exitNode(...args)),
+		enterField: (...args) => allVisitors.forEach((v) => v.enterField(...args)),
+		exitField: (...args) => allVisitors.forEach((v) => v.exitField(...args)),
 	};
 }
 
@@ -128,6 +120,7 @@ export function combineVisitors(
  * Must be freed after use.
  */
 export interface AnnouncedVisitor extends DeltaVisitor {
+	readonly type: "Announced";
 	/**
 	 * A hook that is called after all nodes have been created.
 	 */
@@ -135,14 +128,13 @@ export interface AnnouncedVisitor extends DeltaVisitor {
 	beforeDestroy(field: FieldKey, count: number): void;
 	beforeAttach(source: FieldKey, count: number, destination: PlaceIndex): void;
 	afterAttach(source: FieldKey, destination: Range): void;
-	beforeDetach(source: Range, destination: FieldKey): void;
-	afterDetach(source: PlaceIndex, count: number, destination: FieldKey): void;
-	beforeReplace(
-		newContent: FieldKey,
-		oldContent: Range,
-		oldContentDestination: FieldKey,
+	beforeDetach(source: Range, destination: FieldKey, isReplaced: boolean): void;
+	afterDetach(
+		source: PlaceIndex,
+		count: number,
+		destination: FieldKey,
+		isReplaced: boolean,
 	): void;
-	afterReplace(newContentSource: FieldKey, newContent: Range, oldContent: FieldKey): void;
 }
 
 /**
@@ -154,6 +146,7 @@ export function createAnnouncedVisitor(
 ): AnnouncedVisitor {
 	const noOp = (): void => {};
 	return {
+		type: "Announced",
 		free: visitorFunctions.free ?? noOp,
 		create: visitorFunctions.create ?? noOp,
 		afterCreate: visitorFunctions.afterCreate ?? noOp,
@@ -165,9 +158,6 @@ export function createAnnouncedVisitor(
 		beforeDetach: visitorFunctions.beforeDetach ?? noOp,
 		detach: visitorFunctions.detach ?? noOp,
 		afterDetach: visitorFunctions.afterDetach ?? noOp,
-		beforeReplace: visitorFunctions.beforeReplace ?? noOp,
-		replace: visitorFunctions.replace ?? noOp,
-		afterReplace: visitorFunctions.afterReplace ?? noOp,
 		enterNode: visitorFunctions.enterNode ?? noOp,
 		exitNode: visitorFunctions.exitNode ?? noOp,
 		enterField: visitorFunctions.enterField ?? noOp,

package/src/feature-libraries/chunked-forest/chunkedForest.ts

@@ -183,6 +183,12 @@ export class ChunkedForest implements IEditableForest {
 			 * If not specified, the detached range is destroyed.
 			 */
 			detachEdit(source: Range, destination: FieldKey | undefined): void {
+				// TODO: optimize this to perform in-place replace in uniform chunks when attach edits bring the chunk back to its original shape.
+				// This should result in 3 cases:
+				// 1. In-place update of uniform chunk. No allocations, no ref count changes, no new TreeChunks.
+				// 2. Uniform chunk is shared: copy it (and parent path as needed), and update the copy.
+				// 3. Fallback to detach then attach (Which will copy parents and convert to basic chunks as needed).
+
 				this.forest.#events.emit("beforeChange");
 				const parent = this.getParent();
 				const sourceField = parent.mutableChunk.fields.get(parent.key) ?? [];
@@ -209,24 +215,6 @@ export class ChunkedForest implements IEditableForest {
 					parent.mutableChunk.fields.delete(parent.key);
 				}
 			},
-			replace(
-				newContentSource: FieldKey,
-				range: Range,
-				oldContentDestination: FieldKey,
-				oldContentId: DeltaDetachedNodeId,
-			): void {
-				assert(
-					newContentSource !== oldContentDestination,
-					0x7b0 /* Replace detached source field and detached destination field must be different */,
-				);
-				// TODO: optimize this to: perform in-place replace in uniform chunks when possible.
-				// This should result in 3 cases:
-				// 1. In-place update of uniform chunk. No allocations, no ref count changes, no new TreeChunks.
-				// 2. Uniform chunk is shared: copy it (and parent path as needed), and update the copy.
-				// 3. Fallback to detach then attach (Which will copy parents and convert to basic chunks as needed).
-				this.detachEdit(range, oldContentDestination);
-				this.attachEdit(newContentSource, range.end - range.start, range.start);
-			},
 			enterNode(index: number): void {
 				assert(this.mutableChunk === undefined, 0x535 /* should be in field */);
 				const parent = this.getParent();
@@ -289,10 +277,7 @@ export class ChunkedForest implements IEditableForest {
 
 		const announcedVisitors: AnnouncedVisitor[] = [];
 		this.deltaVisitors.forEach((getVisitor) => announcedVisitors.push(getVisitor()));
-		const combinedVisitor = combineVisitors(
-			[forestVisitor, ...announcedVisitors],
-			announcedVisitors,
-		);
+		const combinedVisitor = combineVisitors([forestVisitor, ...announcedVisitors]);
 		this.activeVisitor = combinedVisitor;
 		return combinedVisitor;
 	}

package/src/feature-libraries/chunked-forest/codec/compressedEncode.ts

@@ -66,7 +66,7 @@ export type Shape = ShapeGeneric<EncodedChunkShape>;
  */
 export interface KeyedFieldEncoder {
 	readonly key: FieldKey;
-	readonly shape: FieldEncoder;
+	readonly encoder: FieldEncoder;
 }
 
 /**

package/src/feature-libraries/chunked-forest/codec/nodeShape.ts

@@ -27,17 +27,35 @@ import type { EncodedChunkShape, EncodedFieldShape, EncodedValueShape } from "./
 import { isStableId } from "@fluidframework/id-compressor/internal";
 
 export class NodeShape extends Shape<EncodedChunkShape> implements NodeEncoder {
-	// TODO: Ensure uniform chunks, encoding and identifier generation sort fields the same.
-	private readonly explicitKeys: Set<FieldKey>;
+	/**
+	 * Set of keys for fields that are encoded using {@link NodeShape.specializedFieldEncoders}.
+	 * TODO: Ensure uniform chunks, encoding and identifier generation sort fields the same.
+	 */
+	private readonly specializedFieldKeys: Set<FieldKey>;
 
 	public constructor(
 		public readonly type: undefined | TreeNodeSchemaIdentifier,
 		public readonly value: EncodedValueShape,
-		public readonly fields: readonly KeyedFieldEncoder[],
-		public readonly extraLocal: undefined | FieldEncoder,
+		/**
+		 * Encoders for a specific set of fields, by key, in the order they will be encoded.
+		 * These are fields for which specialized encoding is provided as an optimization.
+		 * Using these for a given field instead of falling back to {@link NodeShape.specializedFieldEncoders} is often more efficient:
+		 * this avoids the need to explicitly include the key and shape in the encoded data for each node instance.
+		 * Instead, this information is here, and thus is encoded only once as part of the node shape.
+		 * These encoders will be used, even if the field they apply to is empty (which can add overhead for fields which are usually empty).
+		 *
+		 * Any fields not included here will be encoded using {@link NodeShape.otherFieldsEncoder}.
+		 * If {@link NodeShape.otherFieldsEncoder} is undefined, then this must handle all non-empty fields.
+		 */
+		public readonly specializedFieldEncoders: readonly KeyedFieldEncoder[],
+		/**
+		 * Encoder for all other fields that are not in {@link NodeShape.specializedFieldEncoders}. These fields must
+		 * be encoded after the specialized fields.
+		 */
+		public readonly otherFieldsEncoder: undefined | FieldEncoder,
 	) {
 		super();
-		this.explicitKeys = new Set(this.fields.map((f) => f.key));
+		this.specializedFieldKeys = new Set(this.specializedFieldEncoders.map((f) => f.key));
 	}
 
 	private getValueToEncode(cursor: ITreeCursorSynchronous, cache: EncoderCache): Value {
@@ -64,28 +82,28 @@ export class NodeShape extends Shape<EncodedChunkShape> implements NodeEncoder {
 			assert(cursor.type === this.type, 0x741 /* type must match shape */);
 		}
 		encodeValue(this.getValueToEncode(cursor, cache), this.value, outputBuffer);
-		for (const field of this.fields) {
-			cursor.enterField(brand(field.key));
-			field.shape.encodeField(cursor, cache, outputBuffer);
+		for (const fieldEncoder of this.specializedFieldEncoders) {
+			cursor.enterField(brand(fieldEncoder.key));
+			fieldEncoder.encoder.encodeField(cursor, cache, outputBuffer);
 			cursor.exitField();
 		}
 
-		const localBuffer: BufferFormat<EncodedChunkShape> = [];
+		const otherFieldsBuffer: BufferFormat<EncodedChunkShape> = [];
 
 		forEachField(cursor, () => {
 			const key = cursor.getFieldKey();
-			if (!this.explicitKeys.has(key)) {
+			if (!this.specializedFieldKeys.has(key)) {
 				assert(
-					this.extraLocal !== undefined,
+					this.otherFieldsEncoder !== undefined,
 					0x742 /* had extra local fields when shape does not support them */,
 				);
-				localBuffer.push(new IdentifierToken(key));
-				this.extraLocal.encodeField(cursor, cache, localBuffer);
+				otherFieldsBuffer.push(new IdentifierToken(key));
+				this.otherFieldsEncoder.encodeField(cursor, cache, otherFieldsBuffer);
 			}
 		});
 
-		if (this.extraLocal !== undefined) {
-			outputBuffer.push(localBuffer);
+		if (this.otherFieldsEncoder !== undefined) {
+			outputBuffer.push(otherFieldsBuffer);
 		}
 	}
 
@@ -97,8 +115,8 @@ export class NodeShape extends Shape<EncodedChunkShape> implements NodeEncoder {
 			c: {
 				type: encodeOptionalIdentifier(this.type, identifiers),
 				value: this.value,
-				fields: encodeFieldShapes(this.fields, identifiers, shapes),
-				extraFields: encodeOptionalFieldShape(this.extraLocal, shapes),
+				fields: encodeFieldShapes(this.specializedFieldEncoders, identifiers, shapes),
+				extraFields: encodeOptionalFieldShape(this.otherFieldsEncoder, shapes),
 			},
 		};
 	}
@@ -111,13 +129,13 @@ export class NodeShape extends Shape<EncodedChunkShape> implements NodeEncoder {
 			identifiers.add(this.type);
 		}
 
-		for (const field of this.fields) {
-			identifiers.add(field.key);
-			shapes(field.shape.shape);
+		for (const fieldEncoder of this.specializedFieldEncoders) {
+			identifiers.add(fieldEncoder.key);
+			shapes(fieldEncoder.encoder.shape);
 		}
 
-		if (this.extraLocal !== undefined) {
-			shapes(this.extraLocal.shape);
+		if (this.otherFieldsEncoder !== undefined) {
+			shapes(this.otherFieldsEncoder.shape);
 		}
 	}
 
@@ -127,18 +145,18 @@ export class NodeShape extends Shape<EncodedChunkShape> implements NodeEncoder {
 }
 
 export function encodeFieldShapes(
-	fields: readonly KeyedFieldEncoder[],
+	fieldEncoders: readonly KeyedFieldEncoder[],
 	identifiers: DeduplicationTable<string>,
 	shapes: DeduplicationTable<Shape<EncodedChunkShape>>,
 ): EncodedFieldShape[] | undefined {
-	if (fields.length === 0) {
+	if (fieldEncoders.length === 0) {
 		return undefined;
 	}
-	return fields.map((field) => [
+	return fieldEncoders.map((fieldEncoder) => [
 		// key
-		encodeIdentifier(field.key, identifiers),
+		encodeIdentifier(fieldEncoder.key, identifiers),
 		// shape
-		shapes.valueToIndex.get(field.shape.shape) ?? fail(0xb50 /* missing shape */),
+		shapes.valueToIndex.get(fieldEncoder.encoder.shape) ?? fail(0xb50 /* missing shape */),
 	]);
 }
 

package/src/feature-libraries/chunked-forest/codec/schemaBasedEncode.ts

@@ -122,7 +122,7 @@ export function treeShaper(
 
 		const objectNodeFields: KeyedFieldEncoder[] = [];
 		for (const [key, field] of schema.objectNodeFields ?? []) {
-			objectNodeFields.push({ key, shape: fieldHandler.shapeFromField(field) });
+			objectNodeFields.push({ key, encoder: fieldHandler.shapeFromField(field) });
 		}
 
 		const shape = new NodeShape(schemaName, false, objectNodeFields, undefined);

package/src/feature-libraries/indexing/anchorTreeIndex.ts

@@ -139,27 +139,14 @@ export class AnchorTreeIndex<TKey extends TreeIndexKey, TValue>
 				assert(parent !== undefined, 0xa99 /* must have a parent */);
 				this.reIndexSpine(parent);
 			},
-			afterDetach: () => {
-				assert(parent !== undefined, 0xa9a /* must have a parent */);
-				this.reIndexSpine(parent);
-			},
-			// when a replace happens, the keys of previously indexed nodes could be changed so we must re-index them
-			afterReplace: () => {
-				assert(parent !== undefined, 0xa8b /* must have a parent */);
-				const cursor = this.forest.allocateCursor();
-				this.forest.moveCursorToPath(parent, cursor);
-				assert(
-					cursor.mode === CursorLocationType.Nodes,
-					0xa8c /* replace should happen in a node */,
-				);
-				cursor.exitNode();
-				this.indexField(cursor);
-				if (!this.isShallowIndex) {
-					// we must also re-index the spine if the key finders allow for any value under a subtree to be the key
-					// this means that a replace can cause the key for any node up its spine to be changed
-					this.indexSpine(cursor);
+			afterDetach: (_source, _count_, _destination, isReplaced) => {
+				if (isReplaced) {
+					// If the node will be replaced, we defer re-indexing until the corresponding attach event.
+					// This has performance benefits but is also required to avoid experiencing the error case where the field that is used as the indexing key is empty.
+				} else {
+					assert(parent !== undefined, 0xa9a /* must have a parent */);
+					this.reIndexSpine(parent);
 				}
-				cursor.clear();
 			},
 			// the methods below are used to keep track of the path that has been traversed by the visitor
 			// this is required so that cursors can be moved to the correct location when index updates are required
@@ -315,17 +302,19 @@ export class AnchorTreeIndex<TKey extends TreeIndexKey, TValue>
 	 * Checks if the spine needs to be re-indexed and if so, re-indexes it starting from the given path.
 	 */
 	private reIndexSpine(path: UpPath): void {
+		const cursor = this.forest.allocateCursor();
+		this.forest.moveCursorToPath(path, cursor);
+		assert(
+			cursor.mode === CursorLocationType.Nodes,
+			0xa9b /* attach should happen in a node */,
+		);
+		cursor.exitNode();
+		// TODO ADO:36390 avoid re-indexing the whole field when not necessary
+		this.indexField(cursor);
 		if (!this.isShallowIndex) {
-			const cursor = this.forest.allocateCursor();
-			this.forest.moveCursorToPath(path, cursor);
-			assert(
-				cursor.mode === CursorLocationType.Nodes,
-				0xa9b /* attach should happen in a node */,
-			);
-			cursor.exitNode();
 			this.indexSpine(cursor);
-			cursor.clear();
 		}
+		cursor.clear();
 	}
 
 	private checkNotDisposed(errorMessage?: string): void {

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

@@ -236,20 +236,6 @@ export class ObjectForest implements IEditableForest {
 					parent.fields.delete(key);
 				}
 			}
-			public replace(
-				newContentSource: FieldKey,
-				range: Range,
-				oldContentDestination: FieldKey,
-				oldContentId: DeltaDetachedNodeId,
-			): void {
-				preEdit();
-				assert(
-					newContentSource !== oldContentDestination,
-					0x7ba /* Replace detached source field and detached destination field must be different */,
-				);
-				this.detachEdit(range, oldContentDestination);
-				this.attachEdit(newContentSource, range.end - range.start, range.start);
-			}
 			public enterNode(index: number): void {
 				cursor.enterNode(index);
 			}
@@ -267,10 +253,7 @@ export class ObjectForest implements IEditableForest {
 		const forestVisitor = new Visitor(this);
 		const announcedVisitors: AnnouncedVisitor[] = [];
 		this.deltaVisitors.forEach((getVisitor) => announcedVisitors.push(getVisitor()));
-		const combinedVisitor = combineVisitors(
-			[forestVisitor, ...announcedVisitors],
-			announcedVisitors,
-		);
+		const combinedVisitor = combineVisitors([forestVisitor, ...announcedVisitors]);
 		this.activeVisitor = combinedVisitor;
 		return combinedVisitor;
 	}