@fluidframework/tree 2.0.0-rc.2.0.2 → 2.0.0-rc.3.0.0

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

@@ -3,22 +3,29 @@
  * Licensed under the MIT License.
  */
 
-import { assert } from "@fluidframework/core-utils";
+import { assert } from "@fluidframework/core-utils/internal";
 import { StableId } from "@fluidframework/id-compressor";
+
 import {
-	FieldKey,
-	TreeNavigationResult,
-	ITreeSubscriptionCursor,
 	CursorLocationType,
 	FieldAnchor,
-	inCursorNode,
+	FieldKey,
 	FieldUpPath,
-	keyAsDetachedField,
-	iterateCursorField,
-	isCursor,
 	ITreeCursorSynchronous,
+	ITreeSubscriptionCursor,
+	TreeNavigationResult,
+	inCursorNode,
+	isCursor,
+	iterateCursorField,
+	keyAsDetachedField,
 } from "../../core/index.js";
-import { FlexFieldKind } from "../modular-schema/index.js";
+import {
+	assertValidIndex,
+	assertValidRangeIndices,
+	brand,
+	disposeSymbol,
+	fail,
+} from "../../util/index.js";
 // TODO: stop depending on contextuallyTyped
 import { applyTypesFromContext, cursorFromContextualData } from "../contextuallyTyped.js";
 import {
@@ -27,34 +34,28 @@ import {
 	SequenceFieldEditBuilder,
 	ValueFieldEditBuilder,
 } from "../default-schema/index.js";
-import {
-	assertValidIndex,
-	assertValidRangeIndices,
-	brand,
-	disposeSymbol,
-	fail,
-} from "../../util/index.js";
-import { FlexAllowedTypes, FlexFieldSchema } from "../typed-schema/index.js";
-import { LocalNodeKey, StableNodeKey, nodeKeyTreeIdentifier } from "../node-key/index.js";
 import { cursorForMapTreeField } from "../mapTreeCursor.js";
+import { FlexFieldKind } from "../modular-schema/index.js";
+import { LocalNodeKey, StableNodeKey, nodeKeyTreeIdentifier } from "../node-key/index.js";
+import { FlexAllowedTypes, FlexFieldSchema } from "../typed-schema/index.js";
+
 import { Context } from "./context.js";
 import {
-	FlexibleNodeContent,
+	FlexTreeEntityKind,
+	FlexTreeField,
+	FlexTreeNode,
+	FlexTreeNodeKeyField,
 	FlexTreeOptionalField,
+	FlexTreeRequiredField,
 	FlexTreeSequenceField,
 	FlexTreeTypedField,
 	FlexTreeTypedNodeUnion,
 	FlexTreeUnboxNodeUnion,
-	FlexTreeField,
-	FlexTreeNode,
-	FlexTreeRequiredField,
-	TreeStatus,
-	FlexTreeNodeKeyField,
+	FlexibleNodeContent,
 	FlexibleNodeSubSequence,
-	FlexTreeEntityKind,
+	TreeStatus,
 	flexTreeMarker,
 } from "./flexTreeTypes.js";
-import { makeTree } from "./lazyNode.js";
 import {
 	LazyEntity,
 	anchorSymbol,
@@ -63,6 +64,7 @@ import {
 	isFreedSymbol,
 	tryMoveCursorToAnchorSymbol,
 } from "./lazyEntity.js";
+import { makeTree } from "./lazyNode.js";
 import { unboxedUnion } from "./unboxed.js";
 import { treeStatusFromAnchorCache, treeStatusFromDetachedField } from "./utilities.js";
 
@@ -103,17 +105,6 @@ export function makeField(
 		cursor,
 		fieldAnchor,
 	);
-
-	// Fields currently live as long as their parent does.
-	// For root fields, this means forever, but other cases can be cleaned up when their parent anchor is deleted.
-	if (fieldAnchor.parent !== undefined) {
-		const anchorNode =
-			context.forest.anchors.locate(fieldAnchor.parent) ??
-			fail("parent anchor node should always exist since field is under a node");
-		anchorNode.on("afterDestroy", () => {
-			field[disposeSymbol]();
-		});
-	}
 	return field;
 }
 
@@ -130,6 +121,12 @@ export abstract class LazyField<TKind extends FlexFieldKind, TTypes extends Flex
 	}
 	public readonly key: FieldKey;
 
+	/**
+	 * If this field ends its lifetime before the Anchor does, this needs to be invoked to avoid a double free
+	 * if/when the Anchor is destroyed.
+	 */
+	private readonly offAfterDestroy?: () => void;
+
 	public constructor(
 		context: Context,
 		schema: FlexFieldSchema<TKind, TTypes>,
@@ -139,6 +136,16 @@ export abstract class LazyField<TKind extends FlexFieldKind, TTypes extends Flex
 		super(context, schema, cursor, fieldAnchor);
 		assert(cursor.mode === CursorLocationType.Fields, 0x77b /* must be in fields mode */);
 		this.key = cursor.getFieldKey();
+		// Fields currently live as long as their parent does.
+		// For root fields, this means forever, but other cases can be cleaned up when their parent anchor is deleted.
+		if (fieldAnchor.parent !== undefined) {
+			const anchorNode =
+				context.forest.anchors.locate(fieldAnchor.parent) ??
+				fail("parent anchor node should always exist since field is under a node");
+			this.offAfterDestroy = anchorNode.on("afterDestroy", () => {
+				this[disposeSymbol]();
+			});
+		}
 	}
 
 	public is<TSchema extends FlexFieldSchema>(
@@ -155,7 +162,7 @@ export abstract class LazyField<TKind extends FlexFieldKind, TTypes extends Flex
 	public isSameAs(other: FlexTreeField): boolean {
 		assert(
 			other.context === this.context,
-			0x77d /* Content from different editable trees should not be used together */,
+			0x77d /* Content from different flex trees should not be used together */,
 		);
 		return this.key === other.key && this.parent === other.parent;
 	}
@@ -173,15 +180,15 @@ export abstract class LazyField<TKind extends FlexFieldKind, TTypes extends Flex
 	}
 
 	protected override [tryMoveCursorToAnchorSymbol](
-		anchor: FieldAnchor,
 		cursor: ITreeSubscriptionCursor,
 	): TreeNavigationResult {
-		return this.context.forest.tryMoveCursorToField(anchor, cursor);
+		return this.context.forest.tryMoveCursorToField(this[anchorSymbol], cursor);
 	}
 
-	protected override [forgetAnchorSymbol](anchor: FieldAnchor): void {
-		if (anchor.parent === undefined) return;
-		this.context.forest.anchors.forget(anchor.parent);
+	protected override [forgetAnchorSymbol](): void {
+		this.offAfterDestroy?.();
+		if (this[anchorSymbol].parent === undefined) return;
+		this.context.forest.anchors.forget(this[anchorSymbol].parent);
 	}
 
 	public get length(): number {
@@ -441,7 +448,7 @@ export class LazySequence<TTypes extends FlexAllowedTypes>
 	}
 }
 
-export class LazyValueField<TTypes extends FlexAllowedTypes>
+export class ReadonlyLazyValueField<TTypes extends FlexAllowedTypes>
 	extends LazyField<typeof FieldKinds.required, TTypes>
 	implements FlexTreeRequiredField<TTypes>
 {
@@ -454,17 +461,43 @@ export class LazyValueField<TTypes extends FlexAllowedTypes>
 		super(context, schema, cursor, fieldAnchor);
 	}
 
+	public get content(): FlexTreeUnboxNodeUnion<TTypes> {
+		return this.atIndex(0);
+	}
+
+	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>
+	extends ReadonlyLazyValueField<TTypes>
+	implements FlexTreeRequiredField<TTypes>
+{
+	public constructor(
+		context: Context,
+		schema: FlexFieldSchema<typeof FieldKinds.required, TTypes>,
+		cursor: ITreeSubscriptionCursor,
+		fieldAnchor: FieldAnchor,
+	) {
+		super(context, schema, cursor, fieldAnchor);
+	}
+
 	private valueFieldEditor(): ValueFieldEditBuilder {
 		const fieldPath = this.getFieldPathForEditing();
 		const fieldEditor = this.context.editor.valueField(fieldPath);
 		return fieldEditor;
 	}
 
-	public get content(): FlexTreeUnboxNodeUnion<TTypes> {
+	public override get content(): FlexTreeUnboxNodeUnion<TTypes> {
 		return this.atIndex(0);
 	}
 
-	public set content(newContent: FlexibleNodeContent<TTypes>) {
+	public override set content(newContent: FlexibleNodeContent<TTypes>) {
 		const content: ITreeCursorSynchronous[] = isCursor(newContent)
 			? prepareNodeCursorForInsert(newContent)
 			: [cursorFromContextualData(this.context, this.schema.allowedTypeSet, newContent)];
@@ -473,11 +506,25 @@ export class LazyValueField<TTypes extends FlexAllowedTypes>
 		fieldEditor.set(content[0]);
 	}
 
-	public get boxedContent(): FlexTreeTypedNodeUnion<TTypes> {
+	public override get boxedContent(): FlexTreeTypedNodeUnion<TTypes> {
 		return this.boxedAt(0) ?? fail("value node must have 1 item");
 	}
 }
 
+export class LazyIdentifierField<TTypes extends FlexAllowedTypes>
+	extends ReadonlyLazyValueField<TTypes>
+	implements FlexTreeRequiredField<TTypes>
+{
+	public constructor(
+		context: Context,
+		schema: FlexFieldSchema<typeof FieldKinds.required, TTypes>,
+		cursor: ITreeSubscriptionCursor,
+		fieldAnchor: FieldAnchor,
+	) {
+		super(context, schema, cursor, fieldAnchor);
+	}
+}
+
 export class LazyOptionalField<TTypes extends FlexAllowedTypes>
 	extends LazyField<typeof FieldKinds.optional, TTypes>
 	implements FlexTreeOptionalField<TTypes>
@@ -569,6 +616,7 @@ const builderList: [FlexFieldKind, Builder][] = [
 	[FieldKinds.optional, LazyOptionalField],
 	[FieldKinds.sequence, LazySequence],
 	[FieldKinds.required, LazyValueField],
+	[FieldKinds.identifier, LazyIdentifierField],
 ];
 
 const kindToClass: ReadonlyMap<FlexFieldKind, Builder> = new Map(builderList);

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

@@ -3,99 +3,104 @@
  * Licensed under the MIT License.
  */
 
-import { assert, unreachableCase } from "@fluidframework/core-utils";
+import { assert, unreachableCase } from "@fluidframework/core-utils/internal";
+
 import {
-	Value,
 	Anchor,
-	FieldKey,
-	TreeNavigationResult,
-	ITreeSubscriptionCursor,
-	mapCursorFields,
-	CursorLocationType,
-	anchorSlot,
 	AnchorNode,
-	inCursorField,
-	rootFieldKey,
+	CursorLocationType,
 	EmptyKey,
+	FieldKey,
+	ITreeSubscriptionCursor,
+	TreeNavigationResult,
 	TreeNodeSchemaIdentifier,
-	forEachField,
 	TreeValue,
+	Value,
+	forEachField,
+	inCursorField,
+	mapCursorFields,
+	rootFieldKey,
 } from "../../core/index.js";
 import { brand, capitalize, disposeSymbol, fail, getOrCreate } from "../../util/index.js";
+import { FieldKinds } from "../default-schema/index.js";
+import { LocalNodeKey } from "../node-key/index.js";
 import {
+	Any,
+	FlexAllowedTypes,
+	FlexFieldNodeSchema,
 	FlexFieldSchema,
-	FlexTreeNodeSchema,
 	FlexMapNodeSchema,
+	FlexObjectNodeSchema,
+	FlexTreeNodeSchema,
+	LeafNodeSchema,
 	schemaIsFieldNode,
 	schemaIsLeaf,
 	schemaIsMap,
 	schemaIsObjectNode,
-	FlexFieldNodeSchema,
-	LeafNodeSchema,
-	FlexObjectNodeSchema,
-	Any,
-	FlexAllowedTypes,
 } from "../typed-schema/index.js";
-import { FieldKinds } from "../default-schema/index.js";
-import { LocalNodeKey } from "../node-key/index.js";
-import { EditableTreeEvents, TreeEvent } from "./treeEvents.js";
+
 import { Context } from "./context.js";
 import {
+	FlexTreeEntityKind,
+	FlexTreeField,
 	FlexTreeFieldNode,
 	FlexTreeLeafNode,
 	FlexTreeMapNode,
+	FlexTreeNode,
 	FlexTreeObjectNode,
 	FlexTreeObjectNodeTyped,
+	FlexTreeOptionalField,
+	FlexTreeRequiredField,
 	FlexTreeTypedField,
 	FlexTreeTypedNode,
 	FlexTreeUnboxField,
-	FlexTreeField,
-	FlexTreeNode,
-	TreeStatus,
-	FlexTreeRequiredField,
-	FlexTreeOptionalField,
 	FlexibleFieldContent,
 	FlexibleNodeContent,
-	onNextChange,
-	FlexTreeEntityKind,
-	flexTreeMarker,
 	PropertyNameFromFieldKey,
+	TreeStatus,
+	flexTreeMarker,
+	flexTreeSlot,
 	reservedObjectNodeFieldPropertyNamePrefixes,
 	reservedObjectNodeFieldPropertyNames,
 } from "./flexTreeTypes.js";
-import { LazyNodeKeyField, makeField } from "./lazyField.js";
 import {
 	LazyEntity,
+	anchorSymbol,
 	cursorSymbol,
 	forgetAnchorSymbol,
 	isFreedSymbol,
 	tryMoveCursorToAnchorSymbol,
 } from "./lazyEntity.js";
+import { LazyNodeKeyField, makeField } from "./lazyField.js";
+import { FlexTreeNodeEvents } from "./treeEvents.js";
 import { unboxedField } from "./unboxed.js";
 import { treeStatusFromAnchorCache } from "./utilities.js";
 
-const lazyTreeSlot = anchorSlot<LazyTreeNode>();
-
+/**
+ * @param cursor - This does not take ownership of this cursor: Node will fork it as needed.
+ */
 export function makeTree(context: Context, cursor: ITreeSubscriptionCursor): LazyTreeNode {
 	const anchor = cursor.buildAnchor();
 	const anchorNode =
 		context.forest.anchors.locate(anchor) ??
 		fail("cursor should point to a node that is not the root of the AnchorSet");
-	const cached = anchorNode.slots.get(lazyTreeSlot);
+	const cached = anchorNode.slots.get(flexTreeSlot);
 	if (cached !== undefined) {
 		context.forest.anchors.forget(anchor);
 		assert(cached.context === context, 0x782 /* contexts must match */);
-		return cached;
+		assert(cached instanceof LazyTreeNode, 0x92c /* Expected LazyTreeNode */);
+		return cached as LazyTreeNode;
 	}
 	const schema = context.schema.nodeSchema.get(cursor.type) ?? fail("missing schema");
 	const output = buildSubclass(context, schema, cursor, anchorNode, anchor);
-	anchorNode.slots.set(lazyTreeSlot, output);
+	anchorNode.slots.set(flexTreeSlot, output);
 	anchorNode.on("afterDestroy", cleanupTree);
 	return output;
 }
 
 function cleanupTree(anchor: AnchorNode): void {
-	const cached = anchor.slots.get(lazyTreeSlot) ?? fail("tree should only be cleaned up once");
+	const cached = anchor.slots.get(flexTreeSlot) ?? fail("tree should only be cleaned up once");
+	assert(cached instanceof LazyTreeNode, 0x92d /* Expected LazyTreeNode */);
 	cached[disposeSymbol]();
 }
 
@@ -140,22 +145,16 @@ export abstract class LazyTreeNode<TSchema extends FlexTreeNodeSchema = FlexTree
 	// Using JS private here prevents it from showing up as a enumerable own property, or conflicting with struct fields.
 	readonly #removeDeleteCallback: () => void;
 
-	readonly #anchorNode: AnchorNode;
-
-	#removeNextChangeCallback: (() => void) | undefined;
-
 	public constructor(
 		context: Context,
 		schema: TSchema,
 		cursor: ITreeSubscriptionCursor,
-		anchorNode: AnchorNode,
+		public readonly anchorNode: AnchorNode,
 		anchor: Anchor,
 	) {
 		super(context, schema, cursor, anchor);
-		this.#anchorNode = anchorNode;
 		assert(cursor.mode === CursorLocationType.Nodes, 0x783 /* must be in nodes mode */);
-
-		anchorNode.slots.set(lazyTreeSlot, this);
+		anchorNode.slots.set(flexTreeSlot, this);
 		this.#removeDeleteCallback = anchorNode.on("afterDestroy", cleanupTree);
 
 		assert(
@@ -163,9 +162,6 @@ export abstract class LazyTreeNode<TSchema extends FlexTreeNodeSchema = FlexTree
 			0x784 /* There is no explicit schema for this node type. Ensure that the type is correct and the schema for it was added to the TreeStoredSchema */,
 		);
 
-		// Setup JS Object API:
-		// makePrivatePropertyNotEnumerable(this, "removeDeleteCallback");
-		// makePrivatePropertyNotEnumerable(this, "anchorNode");
 		this.type = schema.name;
 	}
 
@@ -180,19 +176,18 @@ export abstract class LazyTreeNode<TSchema extends FlexTreeNodeSchema = FlexTree
 	}
 
 	protected override [tryMoveCursorToAnchorSymbol](
-		anchor: Anchor,
 		cursor: ITreeSubscriptionCursor,
 	): TreeNavigationResult {
-		return this.context.forest.tryMoveCursorToNode(anchor, cursor);
+		return this.context.forest.tryMoveCursorToNode(this[anchorSymbol], cursor);
 	}
 
-	protected override [forgetAnchorSymbol](anchor: Anchor): void {
+	protected override [forgetAnchorSymbol](): void {
 		// This type unconditionally has an anchor, so `forgetAnchor` is always called and cleanup can be done here:
 		// After this point this node will not be usable,
 		// so remove it from the anchor incase a different context (or the same context later) uses this AnchorSet.
-		this.#anchorNode.slots.delete(lazyTreeSlot);
+		this.anchorNode.slots.delete(flexTreeSlot);
 		this.#removeDeleteCallback();
-		this.context.forest.anchors.forget(anchor);
+		this.context.forest.anchors.forget(this[anchorSymbol]);
 	}
 
 	public get value(): Value {
@@ -209,6 +204,10 @@ export abstract class LazyTreeNode<TSchema extends FlexTreeNodeSchema = FlexTree
 		});
 	}
 
+	public getBoxed(key: FieldKey): FlexTreeField {
+		return getBoxedField(this, key, this.schema.getFieldSchema(key));
+	}
+
 	public boxedIterator(): IterableIterator<FlexTreeField> {
 		return mapCursorFields(this[cursorSymbol], (cursor) =>
 			makeField(this.context, this.schema.getFieldSchema(cursor.getFieldKey()), cursor),
@@ -217,22 +216,22 @@ export abstract class LazyTreeNode<TSchema extends FlexTreeNodeSchema = FlexTree
 
 	public get parentField(): { readonly parent: FlexTreeField; readonly index: number } {
 		const cursor = this[cursorSymbol];
-		const index = this.#anchorNode.parentIndex;
+		const index = this.anchorNode.parentIndex;
 		assert(cursor.fieldIndex === index, 0x786 /* mismatched indexes */);
-		const key = this.#anchorNode.parentField;
+		const key = this.anchorNode.parentField;
 
 		cursor.exitNode();
 		assert(key === cursor.getFieldKey(), 0x787 /* mismatched keys */);
 		let fieldSchema: FlexFieldSchema;
 
 		// Check if the current node is in a detached sequence.
-		if (this.#anchorNode.parent === undefined) {
+		if (this.anchorNode.parent === undefined) {
 			// Parent field is a detached sequence, and thus needs special handling for its schema.
 			// eslint-disable-next-line unicorn/prefer-ternary
 			if (key === rootFieldKey) {
 				fieldSchema = this.context.schema.rootFieldSchema;
 			} else {
-				// All fields (in the editable tree API) have a schema.
+				// All fields (in the flex tree API) have a schema.
 				// Since currently there is no known schema for detached field other than the special default root:
 				// give all other detached fields a schema of sequence of any.
 				// That schema is the only one that is safe since its the only field schema that allows any possible field content.
@@ -242,7 +241,7 @@ export abstract class LazyTreeNode<TSchema extends FlexTreeNodeSchema = FlexTree
 				// 1. Editing APIs start exposing user created detached sequences.
 				// 2. Remove (and its inverse) start working on subsequences or fields contents (like everything in a sequence or optional field) and not just single nodes.
 				// 3. Possibly other unknown cases.
-				// Additionally this approach makes it possible for a user to take an EditableTree node, get its parent, check its schema, down cast based on that, then edit that detached field (ex: removing the node in it).
+				// Additionally this approach makes it possible for a user to take a FlexTree node, get its parent, check its schema, down cast based on that, then edit that detached field (ex: removing the node in it).
 				// This MIGHT work properly with existing merge resolution logic (it must keep client in sync and be unable to violate schema), but this either needs robust testing or to be explicitly banned (error before s3ending the op).
 				// Issues like replacing a node in the a removed sequenced then undoing the remove could easily violate schema if not everything works exactly right!
 				fieldSchema = FlexFieldSchema.create(FieldKinds.sequence, [Any]);
@@ -267,95 +266,32 @@ export abstract class LazyTreeNode<TSchema extends FlexTreeNodeSchema = FlexTree
 		if (this[isFreedSymbol]()) {
 			return TreeStatus.Deleted;
 		}
-		return treeStatusFromAnchorCache(this.context.forest.anchors, this.#anchorNode);
+		return treeStatusFromAnchorCache(this.context.forest.anchors, this.anchorNode);
 	}
 
-	public on<K extends keyof EditableTreeEvents>(
+	public on<K extends keyof FlexTreeNodeEvents>(
 		eventName: K,
-		listener: EditableTreeEvents[K],
+		listener: FlexTreeNodeEvents[K],
 	): () => void {
 		switch (eventName) {
 			case "changing": {
-				const unsubscribeFromChildrenChange = this.#anchorNode.on(
+				const unsubscribeFromChildrenChange = this.anchorNode.on(
 					"childrenChanging",
-					(anchorNode: AnchorNode) =>
-						// Ugly casting workaround because I can't figure out how to make TS understand that in this case block
-						// the listener argument only needs to be an AnchorNode. Should go away if/when we make the listener signature
-						// for changing and subtreeChanging match the one for beforeChange and afterChange.
-						listener(anchorNode as unknown as AnchorNode & TreeEvent),
+					(anchorNode: AnchorNode) => listener(anchorNode),
 				);
 				return unsubscribeFromChildrenChange;
 			}
 			case "subtreeChanging": {
-				const unsubscribeFromSubtreeChange = this.#anchorNode.on(
+				const unsubscribeFromSubtreeChange = this.anchorNode.on(
 					"subtreeChanging",
-					(anchorNode: AnchorNode) =>
-						// Ugly casting workaround because I can't figure out how to make TS understand that in this case block
-						// the listener argument only needs to be an AnchorNode. Should go away if/when we make the listener signature
-						// for changing and subtreeChanging match the one for beforeChange and afterChange.
-						listener(anchorNode as unknown as AnchorNode & TreeEvent),
+					(anchorNode: AnchorNode) => listener(anchorNode),
 				);
 				return unsubscribeFromSubtreeChange;
 			}
-			case "beforeChange": {
-				const unsubscribeFromChildrenBeforeChange = this.#anchorNode.on(
-					"beforeChange",
-					(anchorNode: AnchorNode) => {
-						const treeNode = anchorNode.slots.get(lazyTreeSlot);
-						assert(
-							treeNode !== undefined,
-							0x7d3 /* tree node not found in anchor node slots */,
-						);
-						// Ugly casting workaround because I can't figure out how to make TS understand that in this case block
-						// the listener argument only needs to be a TreeEvent. Should go away if/when we make the listener signature
-						// for changing and subtreeChanging match the one for beforeChange and afterChange.
-						listener({ target: treeNode } as unknown as AnchorNode & TreeEvent);
-					},
-				);
-				return unsubscribeFromChildrenBeforeChange;
-			}
-			case "afterChange": {
-				const unsubscribeFromChildrenAfterChange = this.#anchorNode.on(
-					"afterChange",
-					(anchorNode: AnchorNode) => {
-						const treeNode = anchorNode.slots.get(lazyTreeSlot);
-						assert(
-							treeNode !== undefined,
-							0x7d4 /* tree node not found in anchor node slots */,
-						);
-						// Ugly casting workaround because I can't figure out how to make TS understand that in this case block
-						// the listener argument only needs to be a TreeEvent. Should go away if/when we make the listener signature
-						// for changing and subtreeChanging match the one for beforeChange and afterChange.
-						listener({ target: treeNode } as unknown as AnchorNode & TreeEvent);
-					},
-				);
-				return unsubscribeFromChildrenAfterChange;
-			}
 			default:
 				unreachableCase(eventName);
 		}
 	}
-
-	public [onNextChange](fn: (node: FlexTreeNode) => void): () => void {
-		assert(
-			this.#removeNextChangeCallback === undefined,
-			0x806 /* Only one subscriber may listen to next tree node change at a time */,
-		);
-		this.#removeNextChangeCallback = this.#anchorNode.on("childrenChanged", () => {
-			this.#removeNextChangeCallback?.();
-			this.#removeNextChangeCallback = undefined;
-			fn(this);
-		});
-		const removeNextChangeCallback = this.#removeNextChangeCallback;
-		return () => {
-			// Only reset our saved callback if it's the one we closed over in the first place.
-			// It will be different if this is being called after a subsequent registration.
-			if (this.#removeNextChangeCallback === removeNextChangeCallback) {
-				this.#removeNextChangeCallback();
-				this.#removeNextChangeCallback = undefined;
-			}
-		};
-	}
 }
 
 export class LazyMap<TSchema extends FlexMapNodeSchema>
@@ -432,10 +368,8 @@ export class LazyMap<TSchema extends FlexMapNodeSchema>
 		) as FlexTreeUnboxField<TSchema["info"]>;
 	}
 
-	public getBoxed(key: string): FlexTreeTypedField<TSchema["info"]> {
-		return inCursorField(this[cursorSymbol], brand(key), (cursor) =>
-			makeField(this.context, this.schema.info, cursor),
-		) as FlexTreeTypedField<TSchema["info"]>;
+	public override getBoxed(key: string): FlexTreeTypedField<TSchema["info"]> {
+		return super.getBoxed(brand(key)) as FlexTreeTypedField<TSchema["info"]>;
 	}
 
 	public set(key: string, content: FlexibleFieldContent<TSchema["info"]> | undefined): void {
@@ -584,7 +518,7 @@ const cachedStructClasses = new WeakMap<
 	) => LazyObjectNode<FlexObjectNodeSchema>
 >();
 
-export function getBoxedField(
+function getBoxedField(
 	objectNode: LazyTreeNode,
 	key: FieldKey,
 	fieldSchema: FlexFieldSchema,

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

@@ -4,6 +4,7 @@
  */
 
 import { LocalNodeKey, NodeKeyIndex, NodeKeyManager, StableNodeKey } from "../node-key/index.js";
+
 import { FlexTreeObjectNode } from "./flexTreeTypes.js";
 
 /**