@fluidframework/tree 2.1.0-276985 → 2.1.0

package/src/core/tree/visitorUtils.ts

@@ -7,11 +7,12 @@ import { assert } from "@fluidframework/core-utils/internal";
 
 import type { ICodecOptions } from "../../codec/index.js";
 import { type IdAllocator, idAllocatorFromMaxId } from "../../util/index.js";
-import type { RevisionTagCodec } from "../rebase/index.js";
+import type { RevisionTag, RevisionTagCodec } from "../rebase/index.js";
 import type { FieldKey } from "../schema-stored/index.js";
 
 import type { ProtoNodes, Root } from "./delta.js";
-import { DetachedFieldIndex, type ForestRootId } from "./detachedFieldIndex.js";
+import { DetachedFieldIndex } from "./detachedFieldIndex.js";
+import type { ForestRootId } from "./detachedFieldIndexTypes.js";
 import type { PlaceIndex, Range } from "./pathTree.js";
 import { type DeltaVisitor, visitDelta } from "./visitDelta.js";
 import type { IIdCompressor } from "@fluidframework/id-compressor";
@@ -33,21 +34,23 @@ export function makeDetachedFieldIndex(
 
 export function applyDelta(
 	delta: Root,
+	latestRevision: RevisionTag | undefined,
 	deltaProcessor: { acquireVisitor: () => DeltaVisitor },
 	detachedFieldIndex: DetachedFieldIndex,
 ): void {
 	const visitor = deltaProcessor.acquireVisitor();
-	visitDelta(delta, visitor, detachedFieldIndex);
+	visitDelta(delta, visitor, detachedFieldIndex, latestRevision);
 	visitor.free();
 }
 
 export function announceDelta(
 	delta: Root,
+	latestRevision: RevisionTag | undefined,
 	deltaProcessor: { acquireVisitor: () => DeltaVisitor & AnnouncedVisitor },
 	detachedFieldIndex: DetachedFieldIndex,
 ): void {
 	const visitor = deltaProcessor.acquireVisitor();
-	visitDelta(delta, combineVisitors([visitor], [visitor]), detachedFieldIndex);
+	visitDelta(delta, combineVisitors([visitor], [visitor]), detachedFieldIndex, latestRevision);
 	visitor.free();
 }
 

package/src/events/events.ts

@@ -8,9 +8,11 @@ import { getOrCreate } from "../util/index.js";
 
 /**
  * Convert a union of types to an intersection of those types. Useful for `TransformEvents`.
+ * @privateRemarks
+ * First an always true extends clause is used (T extends T) to distribute T into to a union of types contravariant over each member of the T union.
+ * Then the constraint on the type parameter in this new context is inferred, giving the intersection.
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export type UnionToIntersection<T> = (T extends any ? (k: T) => unknown : never) extends (
+export type UnionToIntersection<T> = (T extends T ? (k: T) => unknown : never) extends (
 	k: infer U,
 ) => unknown
 	? U

package/src/feature-libraries/default-schema/defaultEditBuilder.ts

@@ -170,7 +170,7 @@ export class DefaultEditBuilder implements ChangeFamilyEditor, IDefaultEditBuild
 		family: ChangeFamily<ChangeFamilyEditor, DefaultChangeset>,
 		changeReceiver: (change: DefaultChangeset) => void,
 	) {
-		this.modularBuilder = new ModularEditBuilder(family, changeReceiver);
+		this.modularBuilder = new ModularEditBuilder(family, fieldKinds, changeReceiver);
 	}
 
 	public enterTransaction(): void {

package/src/feature-libraries/default-schema/defaultFieldKinds.ts

@@ -48,6 +48,7 @@ export const noChangeHandler: FieldChangeHandler<0> = {
 	isEmpty: (change: 0) => true,
 	getNestedChanges: (change: 0) => [],
 	createEmpty: () => 0,
+	getCrossFieldKeys: () => [],
 };
 
 export interface ValueFieldEditor extends FieldEditor<OptionalChangeset> {

package/src/feature-libraries/editableTreeBinder.ts

@@ -741,7 +741,7 @@ class AbstractDataBinder<
 		const visitor = getOrCreate(this.visitors, anchor, () => {
 			const newVisitor = this.visitorFactory(anchor);
 			this.unregisterHandles.add(
-				anchor.on("subtreeChanging", (upPath: UpPath) => {
+				anchor.anchorNode.on("subtreeChanging", (upPath: UpPath) => {
 					assert(newVisitor !== undefined, 0x6dc /* visitor expected to be defined */);
 					if (!this.visitorLocations.has(newVisitor)) {
 						this.visitorLocations.set(newVisitor, upPath);

package/src/feature-libraries/flex-map-tree/mapTreeNode.ts

@@ -14,7 +14,7 @@ import {
 	type TreeValue,
 	type Value,
 } from "../../core/index.js";
-import { brand, fail, getOrCreate, mapIterable } from "../../util/index.js";
+import { brand, fail, mapIterable } from "../../util/index.js";
 import {
 	type FlexTreeContext,
 	FlexTreeEntityKind,
@@ -23,7 +23,6 @@ import {
 	type FlexTreeLeafNode,
 	type FlexTreeMapNode,
 	type FlexTreeNode,
-	type FlexTreeNodeEvents,
 	type FlexTreeOptionalField,
 	type FlexTreeRequiredField,
 	type FlexTreeSequenceField,
@@ -34,7 +33,6 @@ import {
 	type FlexTreeUnboxNodeUnion,
 	type FlexibleFieldContent,
 	type FlexibleNodeSubSequence,
-	TreeStatus,
 	flexTreeMarker,
 	indexForAt,
 } from "../flex-tree/index.js";
@@ -54,7 +52,6 @@ import {
 import { type FlexImplicitAllowedTypes, normalizeAllowedTypes } from "../schemaBuilderBase.js";
 import type { FlexFieldKind } from "../modular-schema/index.js";
 import { FieldKinds, type SequenceFieldEditBuilder } from "../default-schema/index.js";
-import { ComposableEventEmitter, type Listenable, type Off } from "../../events/index.js";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 
 // #region Nodes
@@ -66,7 +63,6 @@ import { UsageError } from "@fluidframework/telemetry-utils/internal";
  */
 export interface MapTreeNode extends FlexTreeNode {
 	readonly mapTree: MapTree;
-	forwardEvents(to: Listenable<FlexTreeNodeEvents>): void;
 }
 
 /**
@@ -82,38 +78,6 @@ interface LocationInField {
 	readonly index: number;
 }
 
-/**
- * Allows events to be forwarded to another event emitter.
- * @remarks TODO: After the eventing library is simplified, find a way to support this pattern elegantly in the library.
- */
-class ForwardingEventEmitter extends ComposableEventEmitter<FlexTreeNodeEvents> {
-	// A map from deregistration functions produced by this class to deregistration functions of Listenables that have been forwarded to
-	private readonly forwardedOffs = new Map<Off, Off[]>();
-
-	public override on<K extends keyof FlexTreeNodeEvents>(
-		eventName: K,
-		listener: FlexTreeNodeEvents[K],
-	): Off {
-		const off = super.on(eventName, listener);
-		// Return a deregister function which...
-		return (): void => {
-			off(); // ...deregisters the event in this emitter,
-			// and also deregisters the event in any Listenable that it gets forwarded to
-			(this.forwardedOffs.get(off) ?? []).forEach((f) => f());
-		};
-	}
-
-	public forwardEvents(to: Listenable<FlexTreeNodeEvents>): void {
-		for (const [eventName, listeners] of this.listeners) {
-			for (const [off, listener] of listeners) {
-				// For every one of our listeners, make the same subscription in the Listenable that we're forwarding to,
-				// and then create a mapping from our deregistration function to theirs, so we can call it later if need be.
-				getOrCreate(this.forwardedOffs, off, () => []).push(to.on(eventName, listener));
-			}
-		}
-	}
-}
-
 /**
  * A readonly implementation of {@link FlexTreeNode} which wraps a {@link MapTree}.
  * @remarks Any methods that would mutate the node will fail,
@@ -123,10 +87,6 @@ class ForwardingEventEmitter extends ComposableEventEmitter<FlexTreeNodeEvents>
  */
 export class EagerMapTreeNode<TSchema extends FlexTreeNodeSchema> implements MapTreeNode {
 	public readonly [flexTreeMarker] = FlexTreeEntityKind.Node as const;
-	private readonly events = new ForwardingEventEmitter();
-	public forwardEvents(to: Listenable<FlexTreeNodeEvents>): void {
-		this.events.forwardEvents(to);
-	}
 
 	/**
 	 * Create a new MapTreeNode.
@@ -212,27 +172,10 @@ export class EagerMapTreeNode<TSchema extends FlexTreeNodeSchema> implements Map
 		);
 	}
 
-	public treeStatus(): TreeStatus {
-		return TreeStatus.New;
-	}
-
 	public get value(): Value {
 		return this.mapTree.value;
 	}
 
-	public on<K extends keyof FlexTreeNodeEvents>(
-		eventName: K,
-		listener: FlexTreeNodeEvents[K],
-	): () => void {
-		switch (eventName) {
-			case "nodeChanged":
-			case "treeChanged":
-				return this.events.on(eventName, listener);
-			default:
-				throw unsupportedUsageError(`Subscribing to ${eventName}`);
-		}
-	}
-
 	public get context(): FlexTreeContext {
 		// This API is relevant to `LazyTreeNode`s, but not `MapTreeNode`s.
 		// TODO: Refactor the FlexTreeNode interface so that stubbing this out isn't necessary.
@@ -282,16 +225,6 @@ export class EagerMapTreeFieldNode<TSchema extends FlexFieldNodeSchema>
 		return unboxedField(field, EmptyKey, this.mapTree, this);
 	}
 
-	public get boxedContent(): FlexTreeTypedField<TSchema["info"]> {
-		const field = this.mapTree.fields.get(EmptyKey) ?? [];
-		return getOrCreateField(
-			this,
-			EmptyKey,
-			field,
-			this.schema.info,
-		) as unknown as FlexTreeTypedField<TSchema["info"]>;
-	}
-
 	public override getBoxed(key: string): FlexTreeTypedField<TSchema["info"]> {
 		return super.getBoxed(key) as FlexTreeTypedField<TSchema["info"]>;
 	}
@@ -418,9 +351,6 @@ export const rootMapTreeField: MapTreeField<FlexAllowedTypes> = {
 	is<TSchema extends FlexFieldSchema>(schema: TSchema) {
 		return schema === (FlexFieldSchema.empty as FlexFieldSchema);
 	},
-	isSameAs(other: FlexTreeField): boolean {
-		return other === this;
-	},
 	boxedIterator(): IterableIterator<FlexTreeNode> {
 		return [].values();
 	},
@@ -431,9 +361,6 @@ export const rootMapTreeField: MapTreeField<FlexAllowedTypes> = {
 	get context(): FlexTreeContext {
 		return fail("MapTreeField does not implement context");
 	},
-	treeStatus(): TreeStatus {
-		return TreeStatus.New;
-	},
 	mapTrees: [],
 };
 
@@ -476,15 +403,6 @@ class MapTreeField<T extends FlexAllowedTypes> implements FlexTreeField {
 		return this.schema.equals(schema);
 	}
 
-	public isSameAs(other: FlexTreeField): boolean {
-		if (other.parent === this.parent && other.key === this.key) {
-			assert(other === this, 0x992 /* Expected field to be cached */);
-			return true;
-		}
-
-		return false;
-	}
-
 	public boxedIterator(): IterableIterator<FlexTreeTypedNodeUnion<T>> {
 		return this.mapTrees
 			.map(
@@ -514,10 +432,6 @@ class MapTreeField<T extends FlexAllowedTypes> implements FlexTreeField {
 	public get context(): FlexTreeContext {
 		return fail("MapTreeField does not implement context");
 	}
-
-	public treeStatus(): TreeStatus {
-		return TreeStatus.New;
-	}
 }
 
 class MapTreeRequiredField<T extends FlexAllowedTypes>
@@ -530,10 +444,6 @@ class MapTreeRequiredField<T extends FlexAllowedTypes>
 	public set content(_: FlexTreeUnboxNodeUnion<T>) {
 		throw unsupportedUsageError("Setting an optional field");
 	}
-
-	public get boxedContent(): FlexTreeTypedNodeUnion<T> {
-		return this.boxedAt(0) ?? fail("Required field must have exactly one node");
-	}
 }
 
 class MapTreeOptionalField<T extends FlexAllowedTypes>
@@ -548,10 +458,6 @@ class MapTreeOptionalField<T extends FlexAllowedTypes>
 	public set content(_: FlexTreeUnboxNodeUnion<T> | undefined) {
 		throw unsupportedUsageError("Setting an optional field");
 	}
-
-	public get boxedContent(): FlexTreeTypedNodeUnion<T> | undefined {
-		return this.boxedAt(0);
-	}
 }
 
 class MapTreeSequenceField<T extends FlexAllowedTypes>

package/src/feature-libraries/flex-tree/flexTreeTypes.ts

@@ -14,7 +14,6 @@ import {
 import type { Assume, FlattenKeys } from "../../util/index.js";
 import type { FieldKinds, SequenceFieldEditBuilder } from "../default-schema/index.js";
 import type { FlexFieldKind } from "../modular-schema/index.js";
-import type { LocalNodeKey, StableNodeKey } from "../node-key/index.js";
 import type {
 	AllowedTypesToFlexInsertableTree,
 	InsertableFlexField,
@@ -35,7 +34,6 @@ import type {
 } from "../typed-schema/index.js";
 
 import type { FlexTreeContext } from "./context.js";
-import type { FlexTreeNodeEvents } from "./treeEvents.js";
 
 /**
  * An anchor slot which records the {@link FlexTreeNode} associated with that anchor, if there is one.
@@ -99,14 +97,6 @@ export interface FlexTreeEntity<out TSchema = unknown> {
 	 */
 	readonly context: FlexTreeContext;
 
-	/**
-	 * Gets the {@link TreeStatus} of this tree.
-	 *
-	 * @remarks
-	 * For non-root fields, this is the status of the parent node, since fields do not have a separate lifetime.
-	 */
-	treeStatus(): TreeStatus;
-
 	/**
 	 * Iterate through all nodes/fields in this field/node.
 	 *
@@ -168,14 +158,6 @@ export interface FlexTreeNode extends FlexTreeEntity<FlexTreeNodeSchema> {
 	 */
 	readonly value?: TreeValue;
 
-	/**
-	 * {@inheritDoc ISubscribable#on}
-	 */
-	on<K extends keyof FlexTreeNodeEvents>(
-		eventName: K,
-		listener: FlexTreeNodeEvents[K],
-	): () => void;
-
 	/**
 	 * Gets a field of this node, if it is not empty.
 	 */
@@ -262,18 +244,6 @@ export interface FlexTreeField extends FlexTreeEntity<FlexFieldSchema> {
 
 	boxedIterator(): IterableIterator<FlexTreeNode>;
 
-	/**
-	 * Check if this field is the same as a different field.
-	 * This is defined to mean that both are in the same flex tree, and are the same field on the same node.
-	 * This is more than just a reference comparison because unlike FlexTree nodes, fields are not cached on anchors and can be duplicated.
-	 *
-	 * @privateRemarks
-	 * TODO:
-	 * If practical, cache TreeField instances so use of this method can be replaced with `===` to compare object identity.
-	 * Implementing this will require some care to preserve lazy-ness and work efficiently (without leaks) for empty fields, particularly on MapNodes.
-	 */
-	isSameAs(other: FlexTreeField): boolean;
-
 	/**
 	 * Gets a node of this field by its index without unboxing.
 	 * @param index - Zero-based index of the item to retrieve. Negative values are interpreted from the end of the sequence.
@@ -468,20 +438,8 @@ export interface FlexTreeFieldNode<in out TSchema extends FlexFieldNodeSchema>
 
 	/**
 	 * The content this field node wraps.
-	 * @remarks
-	 * This is a version of {@link FlexTreeFieldNode.boxedContent} but does unboxing.
-	 * Since field node are usually used to wrap fields which don't do unboxing (like {@link FlexTreeSequenceField})
 	 */
 	readonly content: FlexTreeUnboxField<TSchema["info"]>;
-	/**
-	 * The field this field node wraps.
-	 *
-	 * @remarks
-	 * Since field nodes are usually used to wrap fields which don't do unboxing (like {@link FlexTreeSequenceField}),
-	 * this is usually the same as {@link FlexTreeFieldNode.content}.
-	 * This is also the same as `[...this][0]`.
-	 */
-	readonly boxedContent: FlexTreeTypedField<TSchema["info"]>;
 }
 
 /**
@@ -507,11 +465,6 @@ export interface FlexTreeFieldNode<in out TSchema extends FlexFieldNodeSchema>
  */
 export interface FlexTreeObjectNode extends FlexTreeNode {
 	readonly schema: FlexObjectNodeSchema;
-
-	/**
-	 * {@link LocalNodeKey} that identifies this node.
-	 */
-	readonly localNodeKey?: LocalNodeKey;
 }
 
 /**
@@ -615,10 +568,8 @@ export const reservedObjectNodeFieldPropertyNames = [
 	"constructor",
 	"context",
 	"is",
-	"on",
 	"parentField",
 	"schema",
-	"treeStatus",
 	"tryGetField",
 	"type",
 	"value",
@@ -987,8 +938,6 @@ export interface FlexTreeRequiredField<in out TTypes extends FlexAllowedTypes>
 	extends FlexTreeField {
 	get content(): FlexTreeUnboxNodeUnion<TTypes>;
 	set content(content: FlexibleNodeContent<TTypes>);
-
-	readonly boxedContent: FlexTreeTypedNodeUnion<TTypes>;
 }
 
 /**
@@ -1009,17 +958,6 @@ export interface FlexTreeOptionalField<in out TTypes extends FlexAllowedTypes>
 	extends FlexTreeField {
 	get content(): FlexTreeUnboxNodeUnion<TTypes> | undefined;
 	set content(newContent: FlexibleNodeContent<TTypes> | undefined);
-
-	readonly boxedContent?: FlexTreeTypedNodeUnion<TTypes>;
-}
-
-/**
- * Field that contains an immutable {@link StableNodeKey} identifying this node.
- * @internal
- */
-export interface FlexTreeNodeKeyField extends FlexTreeField {
-	readonly localNodeKey: LocalNodeKey;
-	readonly stableNodeKey: StableNodeKey;
 }
 
 // #endregion

package/src/feature-libraries/flex-tree/index.ts

@@ -56,11 +56,16 @@ export type {
 	FlexTreeObjectNodeFields,
 	FlexTreeUnboxNode,
 	FlexTreeUnboxNodeUnion,
-	FlexTreeNodeKeyField,
 	IsArrayOfOne,
 	FlexibleNodeSubSequence,
 } from "./flexTreeTypes.js";
 
-export { assertFlexTreeEntityNotFreed } from "./lazyEntity.js";
+export {
+	assertFlexTreeEntityNotFreed,
+	isFreedSymbol,
+	LazyEntity,
+} from "./lazyEntity.js";
 
 export { getSchemaAndPolicy, indexForAt } from "./utilities.js";
+
+export { treeStatusFromAnchorCache } from "./utilities.js";

package/src/feature-libraries/flex-tree/lazyEntity.ts

@@ -16,7 +16,6 @@ import type { Context } from "./context.js";
 import {
 	type FlexTreeEntity,
 	type FlexTreeEntityKind,
-	type TreeStatus,
 	flexTreeMarker,
 } from "./flexTreeTypes.js";
 
@@ -65,8 +64,6 @@ export abstract class LazyEntity<TSchema = unknown, TAnchor = unknown>
 	public abstract boxedIterator(): IterableIterator<FlexTreeEntity>;
 	public abstract get [flexTreeMarker](): FlexTreeEntityKind;
 
-	public abstract treeStatus(): TreeStatus;
-
 	public [disposeSymbol](): void {
 		this.#lazyCursor.free();
 		this.context.withCursors.delete(this);

package/src/feature-libraries/flex-tree/lazyField.ts

@@ -16,7 +16,7 @@ import {
 	inCursorNode,
 	isCursor,
 	iterateCursorField,
-	keyAsDetachedField,
+	rootFieldKey,
 } from "../../core/index.js";
 import {
 	assertValidIndex,
@@ -64,11 +64,7 @@ import {
 } from "./lazyEntity.js";
 import { type LazyTreeNode, makeTree } from "./lazyNode.js";
 import { unboxedUnion } from "./unboxed.js";
-import {
-	indexForAt,
-	treeStatusFromAnchorCache,
-	treeStatusFromDetachedField,
-} from "./utilities.js";
+import { indexForAt, treeStatusFromAnchorCache } from "./utilities.js";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 
 /**
@@ -190,14 +186,6 @@ export abstract class LazyField<
 		return this.schema.equals(schema);
 	}
 
-	public isSameAs(other: FlexTreeField): boolean {
-		assert(
-			other.context === this.context,
-			0x77d /* Content from different flex trees should not be used together */,
-		);
-		return this.key === other.key && this.parent === other.parent;
-	}
-
 	public get parent(): FlexTreeNode | undefined {
 		if (this[anchorSymbol].parent === undefined) {
 			return undefined;
@@ -267,23 +255,6 @@ export abstract class LazyField<
 		);
 	}
 
-	public treeStatus(): TreeStatus {
-		if (this[isFreedSymbol]()) {
-			return TreeStatus.Deleted;
-		}
-		const fieldAnchor = this[anchorSymbol];
-		const parentAnchor = fieldAnchor.parent;
-		// If the parentAnchor is undefined it is a detached field.
-		if (parentAnchor === undefined) {
-			return treeStatusFromDetachedField(keyAsDetachedField(fieldAnchor.fieldKey));
-		}
-		const parentAnchorNode = this.context.checkout.forest.anchors.locate(parentAnchor);
-
-		// As the "parentAnchor === undefined" case is handled above, parentAnchorNode should exist.
-		assert(parentAnchorNode !== undefined, 0x77e /* parentAnchorNode must exist. */);
-		return treeStatusFromAnchorCache(parentAnchorNode);
-	}
-
 	public getFieldPath(): FieldUpPath {
 		return this[cursorSymbol].getFieldPath();
 	}
@@ -293,10 +264,19 @@ export abstract class LazyField<
 	 * This path is not valid to hold onto across edits: this must be recalled for each edit.
 	 */
 	public getFieldPathForEditing(): FieldUpPath {
-		if (this.treeStatus() !== TreeStatus.InDocument) {
-			throw new UsageError("Editing only allowed on fields with TreeStatus.InDocument status");
+		if (!this[isFreedSymbol]()) {
+			if (
+				// Only allow editing if we are the root document field...
+				(this.parent === undefined && this[anchorSymbol].fieldKey === rootFieldKey) ||
+				// ...or are under a node in the document
+				(this.parent !== undefined &&
+					treeStatusFromAnchorCache(this.parent.anchorNode) === TreeStatus.InDocument)
+			) {
+				return this.getFieldPath();
+			}
 		}
-		return this.getFieldPath();
+
+		throw new UsageError("Editing only allowed on fields with TreeStatus.InDocument status");
 	}
 }
 
@@ -444,7 +424,7 @@ export class LazySequence<TTypes extends FlexAllowedTypes>
 		sourceEnd: number,
 		source?: FlexTreeSequenceField<FlexAllowedTypes>,
 	): void {
-		const sourceField = source !== undefined ? (this.isSameAs(source) ? this : source) : this;
+		const sourceField = source ?? this;
 
 		// TODO: determine support for move across different sequence types
 		assert(
@@ -495,10 +475,6 @@ export class ReadonlyLazyValueField<TTypes extends FlexAllowedTypes>
 	public set content(newContent: FlexibleNodeContent<TTypes>) {
 		fail("cannot set content in readonly field");
 	}
-
-	public get boxedContent(): FlexTreeTypedNodeUnion<TTypes> {
-		return this.boxedAt(0) ?? fail("value node must have 1 item");
-	}
 }
 
 export class LazyValueField<TTypes extends FlexAllowedTypes>
@@ -532,10 +508,6 @@ export class LazyValueField<TTypes extends FlexAllowedTypes>
 		assert(content.length === 1, 0x780 /* value field content should normalize to one item */);
 		fieldEditor.set(content[0]);
 	}
-
-	public override get boxedContent(): FlexTreeTypedNodeUnion<TTypes> {
-		return this.boxedAt(0) ?? fail("value node must have 1 item");
-	}
 }
 
 export class LazyIdentifierField<TTypes extends FlexAllowedTypes>
@@ -589,10 +561,6 @@ export class LazyOptionalField<TTypes extends FlexAllowedTypes>
 		);
 		fieldEditor.set(content.length === 0 ? undefined : content[0], this.length === 0);
 	}
-
-	public get boxedContent(): FlexTreeTypedNodeUnion<TTypes> | undefined {
-		return this.length === 0 ? undefined : this.boxedAt(0);
-	}
 }
 
 export class LazyForbiddenField<TTypes extends FlexAllowedTypes> extends LazyField<

package/src/feature-libraries/flex-tree/lazyNode.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { assert, unreachableCase } from "@fluidframework/core-utils/internal";
+import { assert } from "@fluidframework/core-utils/internal";
 
 import {
 	type Anchor,
@@ -55,7 +55,6 @@ import {
 	type FlexibleFieldContent,
 	type FlexibleNodeContent,
 	type PropertyNameFromFieldKey,
-	TreeStatus,
 	flexTreeMarker,
 	flexTreeSlot,
 	reservedObjectNodeFieldPropertyNamePrefixes,
@@ -66,13 +65,10 @@ import {
 	anchorSymbol,
 	cursorSymbol,
 	forgetAnchorSymbol,
-	isFreedSymbol,
 	tryMoveCursorToAnchorSymbol,
 } from "./lazyEntity.js";
 import { makeField } from "./lazyField.js";
-import type { FlexTreeNodeEvents } from "./treeEvents.js";
 import { unboxedField } from "./unboxed.js";
-import { treeStatusFromAnchorCache } from "./utilities.js";
 
 /**
  * @param cursor - This does not take ownership of this cursor: Node will fork it as needed.
@@ -256,43 +252,6 @@ export abstract class LazyTreeNode<TSchema extends FlexTreeNodeSchema = FlexTree
 
 		return { parent: proxifiedField, index };
 	}
-
-	public override treeStatus(): TreeStatus {
-		if (this[isFreedSymbol]()) {
-			return TreeStatus.Deleted;
-		}
-		return treeStatusFromAnchorCache(this.anchorNode);
-	}
-
-	public on<K extends keyof FlexTreeNodeEvents>(
-		eventName: K,
-		listener: FlexTreeNodeEvents[K],
-	): () => void {
-		switch (eventName) {
-			case "changing": {
-				const unsubscribeFromChildrenChange = this.anchorNode.on(
-					"childrenChanging",
-					(anchorNode: AnchorNode) => listener(anchorNode),
-				);
-				return unsubscribeFromChildrenChange;
-			}
-			case "subtreeChanging": {
-				const unsubscribeFromSubtreeChange = this.anchorNode.on(
-					"subtreeChanging",
-					(anchorNode: AnchorNode) => listener(anchorNode),
-				);
-				return unsubscribeFromSubtreeChange;
-			}
-			case "nodeChanged": {
-				return this.anchorNode.on("childrenChangedAfterBatch", listener);
-			}
-			case "treeChanged": {
-				return this.anchorNode.on("subtreeChangedAfterBatch", listener);
-			}
-			default:
-				unreachableCase(eventName);
-		}
-	}
 }
 
 export class LazyMap<TSchema extends FlexMapNodeSchema>
@@ -434,12 +393,6 @@ export class LazyFieldNode<TSchema extends FlexFieldNodeSchema>
 			unboxedField(this.context, this.schema.info, cursor),
 		) as FlexTreeUnboxField<TSchema["info"]>;
 	}
-
-	public get boxedContent(): FlexTreeTypedField<TSchema["info"]> {
-		return inCursorField(this[cursorSymbol], EmptyKey, (cursor) =>
-			makeField(this.context, this.schema.info, cursor),
-		) as FlexTreeTypedField<TSchema["info"]>;
-	}
 }
 
 /**

package/src/feature-libraries/forest-summary/forestSummarizer.ts

@@ -158,6 +158,7 @@ export class ForestSummarizer implements Summarizable {
 			assert(this.forest.isEmpty, 0x797 /* forest must be empty */);
 			applyDelta(
 				{ build, fields: new Map(fieldChanges) },
+				undefined,
 				this.forest,
 				makeDetachedFieldIndex("init", this.revisionTagCodec, this.idCompressor),
 			);