@fluidframework/tree 2.32.0 → 2.33.0

package/src/core/schema-stored/schema.ts

@@ -4,7 +4,6 @@
  */
 
 import { fail } from "@fluidframework/core-utils/internal";
-import type { ErasedType } from "@fluidframework/core-interfaces";
 import { DiscriminatedUnionDispatcher } from "../../codec/index.js";
 import { type MakeNominal, brand, invertMap } from "../../util/index.js";
 import {
@@ -148,24 +147,6 @@ export const storedEmptyFieldSchema: TreeFieldStoredSchema = {
  */
 export const identifierFieldKindIdentifier = "Identifier";
 
-/**
- * Opaque type erased handle to the encoded representation of the contents of a stored schema.
- */
-export interface ErasedTreeNodeSchemaDataFormat
-	extends ErasedType<"TreeNodeSchemaDataFormat"> {}
-
-function toErasedTreeNodeSchemaDataFormat(
-	data: TreeNodeSchemaDataFormat,
-): ErasedTreeNodeSchemaDataFormat {
-	return data as unknown as ErasedTreeNodeSchemaDataFormat;
-}
-
-export function toTreeNodeSchemaDataFormat(
-	data: ErasedTreeNodeSchemaDataFormat,
-): TreeNodeSchemaDataFormat {
-	return data as unknown as TreeNodeSchemaDataFormat;
-}
-
 /**
  */
 export abstract class TreeNodeStoredSchema {
@@ -177,7 +158,7 @@ export abstract class TreeNodeStoredSchema {
 	 * This is uses an opaque type to avoid leaking these types out of the package,
 	 * and is runtime validated by the codec.
 	 */
-	public abstract encode(): ErasedTreeNodeSchemaDataFormat;
+	public abstract encode(): TreeNodeSchemaDataFormat;
 
 	/**
 	 * Returns the schema for the provided field.
@@ -202,7 +183,7 @@ export class ObjectNodeStoredSchema extends TreeNodeStoredSchema {
 		super();
 	}
 
-	public override encode(): ErasedTreeNodeSchemaDataFormat {
+	public override encode(): TreeNodeSchemaDataFormat {
 		const fieldsObject: Record<string, FieldSchemaFormat> = Object.create(null);
 		// Sort fields to ensure output is identical for for equivalent schema (since field order is not considered significant).
 		// This makes comparing schema easier, and ensures chunk reuse for schema summaries isn't needlessly broken.
@@ -216,9 +197,9 @@ export class ObjectNodeStoredSchema extends TreeNodeStoredSchema {
 				),
 			});
 		}
-		return toErasedTreeNodeSchemaDataFormat({
+		return {
 			object: fieldsObject,
-		});
+		};
 	}
 
 	public override getFieldSchema(field: FieldKey): TreeFieldStoredSchema {
@@ -241,10 +222,10 @@ export class MapNodeStoredSchema extends TreeNodeStoredSchema {
 		super();
 	}
 
-	public override encode(): ErasedTreeNodeSchemaDataFormat {
-		return toErasedTreeNodeSchemaDataFormat({
+	public override encode(): TreeNodeSchemaDataFormat {
+		return {
 			map: encodeFieldSchema(this.mapFields),
-		});
+		};
 	}
 
 	public override getFieldSchema(field: FieldKey): TreeFieldStoredSchema {
@@ -271,10 +252,10 @@ export class LeafNodeStoredSchema extends TreeNodeStoredSchema {
 		super();
 	}
 
-	public override encode(): ErasedTreeNodeSchemaDataFormat {
-		return toErasedTreeNodeSchemaDataFormat({
+	public override encode(): TreeNodeSchemaDataFormat {
+		return {
 			leaf: encodeValueSchema(this.leafValue),
-		});
+		};
 	}
 
 	public override getFieldSchema(field: FieldKey): TreeFieldStoredSchema {

package/src/core/tree/anchorSet.ts

@@ -730,25 +730,32 @@ export class AnchorSet implements AnchorLocator {
 			 */
 			bufferedEvents: [] as BufferedEvent[],
 
-			// 'currentDepth' and 'depthThresholdForSubtreeChanged' serve to keep track of when do we need to emit
-			// subtreeChangedAfterBatch events.
-			// The algorithm works as follows:
-			// - Initialize both to 0.
-			// - As we walk the tree from the root towards the leaves, when we enter a node increment currentDepth by 1.
-			// - When we edit a node, set depthThresholdForSubtreeChanged = currentDepth.
-			//   Intuitively, depthThresholdForSubtreeChanged means "as you walk the tree towards the root, when you exit a
-			//   node at this depth you should emit a subtreeChangedAfterBatch event".
-			// - When we exit a node, if d === currentDepth then emit a subtreeChangedAfterBatch and decrement d by 1.
-			//   Then decrement currentDepth unconditionally.
-			// Note that the event will be emitted when exiting a node that was edited (depthThresholdForSubtreeChanged will
-			// have been set to the current depth when the edit happened), it will be emitted when exiting a node that is the
-			// parent of a node that already emitted the event (because both depthThresholdForSubtreeChanged and currentDepth
-			// get decremented when exiting a node so they stay in sync), and if we're already emitting the event but start
-			// walking the tree back towards the leaves in a path where no edits happen, currentDepth will be increased again
-			// as we walk that path, depthThresholdForSubtreeChanged will not, and thus no event will be emitted when walking
-			// back up that path, until we get back to the depth where we were already emitting the event, and will continue
-			// emitting it on the way to the root.
+			/**
+			 * 'currentDepth' and 'depthThresholdForSubtreeChanged' serve to keep track of when do we need to emit
+			 * subtreeChangedAfterBatch events.
+			 * The algorithm works as follows:
+			 *
+			 * - Initialize both to 0.
+			 * - As we walk the tree from the root towards the leaves, when we enter a node increment currentDepth by 1.
+			 * - When we edit a node, set depthThresholdForSubtreeChanged = currentDepth.
+			 * Intuitively, depthThresholdForSubtreeChanged means "as you walk the tree towards the root, when you exit a
+			 * node at this depth you should emit a subtreeChangedAfterBatch event".
+			 * - When we exit a node, if d === currentDepth then emit a subtreeChangedAfterBatch and decrement d by 1.
+			 * Then decrement currentDepth unconditionally.
+			 *
+			 * Note that the event will be emitted when exiting a node that was edited (depthThresholdForSubtreeChanged will
+			 * have been set to the current depth when the edit happened), it will be emitted when exiting a node that is the
+			 * parent of a node that already emitted the event (because both depthThresholdForSubtreeChanged and currentDepth
+			 * get decremented when exiting a node so they stay in sync), and if we're already emitting the event but start
+			 * walking the tree back towards the leaves in a path where no edits happen, currentDepth will be increased again
+			 * as we walk that path, depthThresholdForSubtreeChanged will not, and thus no event will be emitted when walking
+			 * back up that path, until we get back to the depth where we were already emitting the event, and will continue
+			 * emitting it on the way to the root.
+			 */
 			currentDepth: 0,
+			/**
+			 * See {@link visitor.currentDepth}.
+			 */
 			depthThresholdForSubtreeChanged: 0,
 
 			free() {
@@ -909,16 +916,17 @@ export class AnchorSet implements AnchorLocator {
 			},
 			exitNode(index: number): void {
 				assert(this.parent !== undefined, 0x3ac /* Must have parent node */);
-				this.maybeWithNode((p) => {
-					p.events.emit("subtreeChanged", p);
-					if (this.depthThresholdForSubtreeChanged === this.currentDepth) {
+				if (this.depthThresholdForSubtreeChanged === this.currentDepth) {
+					this.maybeWithNode((p) => {
+						p.events.emit("subtreeChanged", p);
+
 						this.bufferedEvents.push({
 							node: p,
 							event: "subtreeChangedAfterBatch",
 						});
-						this.depthThresholdForSubtreeChanged--;
-					}
-				});
+					});
+					this.depthThresholdForSubtreeChanged--;
+				}
 				const parent = this.parent;
 				this.parentField = parent.parentField;
 				this.parent = parent.parent;

package/src/core/tree/deltaUtil.ts

@@ -7,23 +7,11 @@ import type { Mutable } from "../../util/index.js";
 import type { FieldKey } from "../schema-stored/index.js";
 import type { TreeChunk } from "./chunk.js";
 
-import type { DetachedNodeId, FieldChanges, Mark, Root } from "./delta.js";
+import type { DetachedNodeId, FieldChanges, Root } from "./delta.js";
 import { rootFieldKey } from "./types.js";
 
 export const emptyDelta: Root = {};
 
-export function isAttachMark(mark: Mark): boolean {
-	return mark.attach !== undefined && mark.detach === undefined;
-}
-
-export function isDetachMark(mark: Mark): boolean {
-	return mark.detach !== undefined && mark.attach === undefined;
-}
-
-export function isReplaceMark(mark: Mark): boolean {
-	return mark.detach !== undefined && mark.attach !== undefined;
-}
-
 export function deltaForRootInitialization(content: TreeChunk): Root {
 	if (content.topLevelLength === 0) {
 		return emptyDelta;

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;
 }
 
 /**