@fluidframework/tree 2.63.0-359734 → 2.63.0

package/src/simple-tree/api/typesUnsafe.ts

@@ -29,6 +29,8 @@ import type {
 	TreeLeafValue,
 	FlexListToUnion,
 	LazyItem,
+	AnnotatedAllowedType,
+	AnnotatedAllowedTypes,
 } from "../core/index.js";
 import type { TreeArrayNode } from "../node-kinds/index.js";
 import type { SimpleArrayNodeSchema, SimpleMapNodeSchema } from "../simpleSchema.js";
@@ -543,3 +545,82 @@ export interface TreeRecordNodeUnsafe<
 		[string, System_Unsafe.TreeNodeFromImplicitAllowedTypesUnsafe<TAllowedTypes>]
 	>;
 }
+
+/**
+ * {@link Unenforced} utility to remove {@link AnnotatedAllowedTypeUnsafe} wrappers.
+ * @remarks
+ * Do not use this type directly: it's only needed in the implementation of generic logic which define recursive schema, not when using recursive schema.
+ * @sealed
+ * @alpha
+ * @system
+ */
+export type UnannotateAllowedTypeUnsafe<
+	T extends Unenforced<
+		AnnotatedAllowedTypeUnsafe | LazyItem<System_Unsafe.TreeNodeSchemaUnsafe>
+	>,
+> = T extends AnnotatedAllowedTypeUnsafe<infer X> ? X : T;
+
+/**
+ * {@link Unenforced} version of {@link AnnotatedAllowedType}.
+ * @remarks
+ * Do not use this type directly: it's only needed in the implementation of generic logic which define recursive schema, not when using recursive schema.
+ * @system @sealed @alpha
+ */
+export interface AnnotatedAllowedTypeUnsafe<T = Unenforced<LazyItem<TreeNodeSchema>>>
+	extends AnnotatedAllowedType<T> {}
+
+/**
+ * {@link Unenforced} version of {@link AnnotatedAllowedTypes}.
+ * @remarks
+ * Do not use this type directly: it's only needed in the implementation of generic logic which define recursive schema, not when using recursive schema.
+ * @system @sealed @alpha
+ */
+export interface AnnotatedAllowedTypesUnsafe
+	extends AnnotatedAllowedTypes<LazyItem<System_Unsafe.TreeNodeSchemaUnsafe>> {}
+
+/**
+ * {@link Unenforced} version of {@link AllowedTypesFull}.
+ * @remarks
+ * Do not use this type directly: it's only needed in the implementation of generic logic which define recursive schema, not when using recursive schema.
+ * @system @sealed @alpha
+ */
+export type AllowedTypesFullUnsafe<
+	T extends readonly AnnotatedAllowedTypeUnsafe[] = readonly AnnotatedAllowedTypeUnsafe[],
+> = AnnotatedAllowedTypes<T> & UnannotateAllowedTypesListUnsafe<T>;
+
+/**
+ * {@link Unenforced} version of {@link AllowedTypesFullFromMixed}.
+ * @remarks
+ * Do not use this type directly: it's only needed in the implementation of generic logic which define recursive schema, not when using recursive schema.
+ * @system @sealed @alpha
+ */
+export type AllowedTypesFullFromMixedUnsafe<
+	T extends readonly Unenforced<AnnotatedAllowedType | LazyItem<TreeNodeSchema>>[],
+> = UnannotateAllowedTypesListUnsafe<T> &
+	AnnotatedAllowedTypes<AnnotateAllowedTypesListUnsafe<T>>;
+
+/**
+ * {@link Unenforced} version of {@link UnannotateAllowedTypesList}.
+ * @remarks
+ * Do not use this type directly: it's only needed in the implementation of generic logic which define recursive schema, not when using recursive schema.
+ * @system @sealed @alpha
+ */
+export type UnannotateAllowedTypesListUnsafe<
+	T extends readonly Unenforced<AnnotatedAllowedType | LazyItem<TreeNodeSchema>>[],
+> = {
+	readonly [I in keyof T]: T[I] extends { type: infer X } ? X : T[I];
+};
+
+/**
+ * {@link Unenforced} version of {@link AnnotateAllowedTypesList}.
+ * @remarks
+ * Do not use this type directly: it's only needed in the implementation of generic logic which define recursive schema, not when using recursive schema.
+ * @system @sealed @alpha
+ */
+export type AnnotateAllowedTypesListUnsafe<
+	T extends readonly Unenforced<AnnotatedAllowedType | LazyItem<TreeNodeSchema>>[],
+> = {
+	[I in keyof T]: T[I] extends AnnotatedAllowedTypeUnsafe
+		? T[I]
+		: AnnotatedAllowedTypeUnsafe<T[I]>;
+};

package/src/simple-tree/core/TreeNodeBinding.md

@@ -8,9 +8,7 @@ Here is an example:
 function addPoint(curve: Curve, x: number, y: number): Point {
 	const point = new Point({ x: 3, y: 3 });
 	curve.points.insertAtEnd(point);
-	// After insertion, `point` can be queried:
-	assert(point.x === 3);
-	// In fact, `point` is the same simple-tree node object that you would get from reading it off of its new parent in the tree:
+	// `point` is the same simple-tree node object that you would get from reading it off of its new parent in the tree:
 	assert(point === curve.points[curve.points.length - 1]);
 	// So, to read the content that was just inserted, the original object can be used and there is no need to read via the parent:
 	return point;
@@ -22,83 +20,29 @@ function addPoint(curve: Curve, x: number, y: number): Point {
 
 This feature is supported by doing some bookkeeping to ensure that the simple-tree objects,
 flex tree nodes and anchor nodes in the tree get associated and disassociated at the right times.
-There are three states that a node simple-tree node can be in: "raw", "marinated" and "cooked".
+There are three states that a node simple-tree node can be in: "Unhydrated", "hydrating" and "Hydrated".
 
-Note from the public API perspective, `Unhydrated` nodes are "raw", and hydrated nodes are either "marinated" or "cooked".
+### Unhydrated Nodes
 
-### Raw Proxies
-
-A newly created simple-tree node, a.k.a. a **raw** simple-tree node. A raw simple-tree node is produced by invoking the schema-provided constructor for a node:
-
-```ts
-const rawPoint = new Point({ x: 3, y: 3 });
-```
-
-Such a simple-tree node will be raw until it is inserted into the tree and becomes "marinated" (see below).
-As raw nodes can be read or mutated.
-
-### Marinated Proxies
-
-Proxies become **marinated** as soon as they are inserted into the tree.
-
-This happens whether proxies are inserted directly, as the root of the content subtree...
+A newly created simple-tree node, a.k.a. an **unhydrated** simple-tree node. An unhydrated simple-tree node is produced by invoking the schema-provided constructor for a node:
 
 ```ts
-// Upon insertion, `rawPoint` transitions from "raw" to the next state, "marinated"
-app.graph.curves[0].insertAtEnd(rawPoint);
+const unhydratedPoint = new Point({ x: 3, y: 3 });
 ```
 
-...or proxies are inserted indirectly, making up some arbitrary portion of the content subtree.
+Such a simple-tree node will be unhydrated until it is inserted into the tree and becomes "hydrated" (see below).
+Unhydrated nodes can be read or mutated just like hydrated ones.
 
-```ts
-// Upon insertion, `rawPoint` transitions from "raw" to the next state, "marinated"
-app.graph = {
-	curves: [
-		[new Point({ x: 10, y: 10 }), new Point({ x: 20, y: 20 })],
-		[new Point({ x: 2, y: 2 }), rawPoint, new Point({ x: 4, y: 4 })],
-	],
-};
-```
+### Hydrating Nodes
 
-A marinated simple-tree node, by definition, is bound bi-directionally to an `AnchorNode`.
-When insertion occurs, an `AnchorNode` will be created (if not already present) for the location of the new content.
-The simple-tree node for that content will then be mapped to the `AnchorNode` (via its kernel) and the `AnchorNode` will be mapped to the simple-tree node.
-Note that the `AnchorNode` may not yet have a `FlexTreeNode` associated with it - that happens when the node becomes "cooked" (see below).
+Between insertion edit and the change callback which updates the node to "Hydrated" (see [prepareForInsertion.ts](../prepareForInsertion.ts)),
+the node is in a poorly defined "hydrating" state and should not be interacted with.
 
-### Cooked Proxies
+### Hydrated Nodes
 
-A simple-tree node is fully cooked when it finally associates itself with a `FlexTreeNode`.
-This happens lazily on demand, if/when a marinated simple-tree node is read or mutated (by the local client).
+A simple-tree node is fully hydrated when it is associated with a `HydratedFlexTreeNode`.
 
 ```ts
-const point = new Point({ x: 3, y: 3 }); // `point` is raw
-curves.points.insertAtEnd(point); // `point` becomes marinated
-const x = point.x; // `point` becomes cooked in order to support the read of `x`
+const point = new Point({ x: 3, y: 3 }); // `point` is unhydrated
+curves.points.insertAtEnd(point); // `point` becomes hydrated
 ```
-
-This laziness prevents the simple-tree node tree from generating unnecessary `FlexTreeNodes`.
-
-Cooking a marinated simple-tree node works as follows:
-
-1. Get the `AnchorNode` associated with the marinated simple-tree node.
-2. Get or create a `FlexTreeNode` for the anchor.
-3. This will cause the `FlexTreeNode` to be generated which corresponds to the simple-tree node.
-
-### Mappings
-
-```mermaid
-graph LR;
-    AnchorNode(AnchorNode)<-->|Cooked and sometimes when Marinated|FlexTreeNode(FlexTreeNode)
-    AnchorNode<--->|Marinated or Cooked|TreeNode(TreeNode)-.->|Raw|RawTreeNode(RawTreeNode)
-    linkStyle 0 stroke:#0f0
-    linkStyle 1 stroke:#00f
-    linkStyle 2 stroke:#f00
-```
-
-Note that it is possible for the `Cooked` mappings between an `AnchorNode` and a `FlexTreeNode` to exist regardless of whether there is also a simple-tree node yet created for that node.
-In that case, when that simple-tree node is created it will immediately be given its `Marinated` mappings and therefore already be cooked.
-
-`RawTreeNode`s, which implement the `FlexTreeNode` interface (or at least, as of 2024-03-21, pretend to), are substitutes for the true `FlexTreeNode`s that don't yet exist for a raw node.
-The `Raw` mapping is removed when a simple-tree node is marinated, and the `RawTreeNode` is forgotten.
-
-See [proxyBinding.ts](./proxyBinding.ts) for more details.

package/src/simple-tree/core/allowedTypes.ts

@@ -539,7 +539,10 @@ export function normalizeAllowedTypesInternal(
 	return getOrCreate(cachedNormalize, type, () => {
 		// Due to more specific internal type, the above does not narrow sufficiently, so more narrowing is needed.
 		// It is possible this will give a false error if a TreeNodeSchema which matches this check is used.
-		assert(!("types" in type && "metadata" in type), "invalid AnnotatedAllowedTypes");
+		assert(
+			!("types" in type && "metadata" in type),
+			0xc7d /* invalid AnnotatedAllowedTypes */,
+		);
 
 		const annotatedTypes: AnnotatedAllowedType[] = (isReadonlyArray(type) ? type : [type]).map(
 			normalizeToAnnotatedAllowedType,

package/src/simple-tree/core/index.ts

@@ -10,7 +10,7 @@ export {
 	tryGetTreeNodeSchema,
 	type InnerNode,
 	tryDisposeTreeNode,
-	getOrCreateInnerNode,
+	getInnerNode,
 	treeNodeFromAnchor,
 	getSimpleNodeSchemaFromInnerNode,
 	SimpleContextSlot,

package/src/simple-tree/core/treeNodeKernel.ts

@@ -17,14 +17,11 @@ import {
 	anchorSlot,
 	type AnchorEvents,
 	type AnchorNode,
-	type AnchorSet,
 	type FieldKey,
 	type TreeValue,
-	type UpPath,
 } from "../../core/index.js";
 import { getOrCreateHydratedFlexTreeNode } from "../../feature-libraries/index.js";
 import {
-	assertFlexTreeEntityNotFreed,
 	ContextSlot,
 	flexTreeSlot,
 	LazyEntity,
@@ -85,10 +82,8 @@ interface UnhydratedState {
 
 /** The {@link HydrationState} of a {@link TreeNodeKernel} after the kernel is hydrated */
 interface HydratedState {
-	/** The flex node for this kernel (lazy - undefined if it has not yet been demanded) */
-	innerNode?: FlexTreeNode;
-	/** The {@link AnchorNode} that this node is associated with. */
-	readonly anchorNode: AnchorNode;
+	/** The flex node for this kernel */
+	readonly innerNode: HydratedFlexTreeNode;
 	/** All {@link Off | event deregistration functions} that should be run when the kernel is disposed. */
 	readonly offAnchorNode: Set<Off>;
 }
@@ -98,7 +93,7 @@ type HydrationState = UnhydratedState | HydratedState;
 
 /** True if and only if the given {@link HydrationState} is post-hydration */
 function isHydrated(state: HydrationState): state is HydratedState {
-	return (state as Partial<HydratedState>).anchorNode !== undefined;
+	return state.innerNode.isHydrated();
 }
 
 /**
@@ -137,7 +132,7 @@ export class TreeNodeKernel {
 	 * Create a TreeNodeKernel which can be looked up with {@link getKernel}.
 	 *
 	 * @param initialContext - context from when this node was originally created. Only used when unhydrated.
-	 * @param innerNode - When unhydrated/raw or marinated the MapTreeNode. FlexTreeNode when cooked.
+	 * @param innerNode - When unhydrated the MapTreeNode. Otherwise HydratedFlexTreeNode.
 	 * @remarks
 	 * Exactly one kernel per TreeNode should be created.
 	 */
@@ -165,9 +160,7 @@ export class TreeNodeKernel {
 			this.#eventBuffer = new KernelEventBuffer(innerNode.events);
 		} else {
 			// Hydrated case
-			this.#hydrationState = this.createHydratedState(innerNode.anchorNode);
-			this.#hydrationState.innerNode = innerNode;
-
+			this.#hydrationState = this.createHydratedState(innerNode);
 			this.#eventBuffer = new KernelEventBuffer(innerNode.anchorNode.events);
 		}
 	}
@@ -176,7 +169,7 @@ export class TreeNodeKernel {
 		if (isHydrated(this.#hydrationState)) {
 			// This can't be cached on this.#hydrated during hydration since initial tree is hydrated before the context is cached on the anchorSet.
 			return (
-				this.#hydrationState?.anchorNode.anchorSet.slots.get(SimpleContextSlot) ??
+				this.#hydrationState.innerNode.anchorNode.anchorSet.slots.get(SimpleContextSlot) ??
 				fail(0xb40 /* missing simple-tree context */)
 			);
 		}
@@ -185,38 +178,33 @@ export class TreeNodeKernel {
 
 	/**
 	 * Transition from {@link Unhydrated} to hydrated.
-	 * Bi-directionally associates the given hydrated TreeNode to the anchor node at the provided path.
+	 * Bi-directionally associates the given hydrated TreeNode to the HydratedFlexTreeNode.
 	 * @remarks
 	 * Happens at most once for any given node.
 	 * Cleans up mappings to {@link UnhydratedFlexTreeNode} - it is assumed that they are no longer needed once this node has an anchor node.
 	 */
-	public hydrate(anchors: AnchorSet, path: UpPath): void {
+	public hydrate(inner: HydratedFlexTreeNode): void {
 		assert(!this.disposed, 0xa2a /* cannot hydrate a disposed node */);
 		assert(!isHydrated(this.#hydrationState), 0xa2b /* hydration should only happen once */);
 
-		const anchor = anchors.track(path);
-		const anchorNode =
-			anchors.locate(anchor) ?? fail(0xb42 /* Expected anchor node to be present */);
-
-		this.#hydrationState = this.createHydratedState(anchorNode);
-		this.#hydrationState.offAnchorNode.add(() => anchors.forget(anchor));
+		this.#hydrationState = this.createHydratedState(inner);
 
 		// Lazily migrate existing event listeners to the anchor node
-		this.#eventBuffer.migrateEventSource(anchorNode.events);
+		this.#eventBuffer.migrateEventSource(inner.anchorNode.events);
 	}
 
-	private createHydratedState(anchorNode: AnchorNode): HydratedState {
+	private createHydratedState(innerNode: HydratedFlexTreeNode): HydratedState {
 		assert(
-			!anchorNode.slots.has(simpleTreeNodeSlot),
+			!innerNode.anchorNode.slots.has(simpleTreeNodeSlot),
 			0x7f5 /* Cannot associate an flex node with multiple simple-tree nodes */,
 		);
-		anchorNode.slots.set(simpleTreeNodeSlot, this.node);
+		innerNode.anchorNode.slots.set(simpleTreeNodeSlot, this.node);
 		return {
-			anchorNode,
+			innerNode,
 			offAnchorNode: new Set([
-				anchorNode.events.on("afterDestroy", () => this.dispose()),
+				innerNode.anchorNode.events.on("afterDestroy", () => this.dispose()),
 				// TODO: this should be triggered on change even for unhydrated nodes.
-				anchorNode.events.on("childrenChanging", () => {
+				innerNode.anchorNode.events.on("childrenChanging", () => {
 					this.generationNumber += 1;
 				}),
 			]),
@@ -232,7 +220,7 @@ export class TreeNodeKernel {
 		}
 
 		// TODO: Replace this check with the proper check against the cursor state when the cursor becomes part of the kernel
-		const flex = this.#hydrationState.anchorNode.slots.get(flexTreeSlot);
+		const flex = this.#hydrationState.innerNode.anchorNode.slots.get(flexTreeSlot);
 		if (flex !== undefined) {
 			assert(flex instanceof LazyEntity, 0x9b4 /* Unexpected flex node implementation */);
 			if (flex.isFreed()) {
@@ -240,7 +228,7 @@ export class TreeNodeKernel {
 			}
 		}
 
-		return treeStatusFromAnchorCache(this.#hydrationState.anchorNode);
+		return treeStatusFromAnchorCache(this.#hydrationState.innerNode.anchorNode);
 	}
 
 	public get events(): Listenable<KernelEvents> {
@@ -264,7 +252,9 @@ export class TreeNodeKernel {
 	}
 
 	public get anchorNode(): AnchorNode | undefined {
-		return isHydrated(this.#hydrationState) ? this.#hydrationState.anchorNode : undefined;
+		return isHydrated(this.#hydrationState)
+			? this.#hydrationState.innerNode.anchorNode
+			: undefined;
 	}
 
 	/**
@@ -273,11 +263,10 @@ export class TreeNodeKernel {
 	 * For {@link Unhydrated} nodes, this returns the MapTreeNode.
 	 *
 	 * For hydrated nodes it returns a FlexTreeNode backed by the forest.
-	 * Note that for "marinated" nodes, this FlexTreeNode exists and returns it: it does not return the MapTreeNode which is the current InnerNode.
 	 *
 	 * @throws A {@link @fluidframework/telemetry-utils#UsageError} if the node has been deleted.
 	 */
-	public getOrCreateInnerNode(): InnerNode {
+	public getInnerNode(): InnerNode {
 		if (!isHydrated(this.#hydrationState)) {
 			debugAssert(
 				() =>
@@ -291,26 +280,6 @@ export class TreeNodeKernel {
 			throw new UsageError("Cannot access a deleted node.");
 		}
 
-		if (this.#hydrationState.innerNode === undefined) {
-			// Marinated case -> cooked
-			const anchorNode = this.#hydrationState.anchorNode;
-			// This TreeNode is bound to an anchor node, but it may or may not have an actual flex node yet
-			const flexNode = anchorNode.slots.get(flexTreeSlot);
-			if (flexNode !== undefined) {
-				// If the flex node already exists, use it...
-				this.#hydrationState.innerNode = flexNode;
-			} else {
-				// ...otherwise, the flex node must be created
-				const context =
-					anchorNode.anchorSet.slots.get(ContextSlot) ?? fail(0xb41 /* missing context */);
-				const cursor = context.checkout.forest.allocateCursor("getFlexNode");
-				context.checkout.forest.moveCursorToPath(anchorNode, cursor);
-				this.#hydrationState.innerNode = getOrCreateHydratedFlexTreeNode(context, cursor);
-				cursor.free();
-				assertFlexTreeEntityNotFreed(this.#hydrationState.innerNode);
-			}
-		}
-
 		return this.#hydrationState.innerNode;
 	}
 
@@ -553,10 +522,8 @@ class KernelEventBuffer implements Listenable<KernelEvents> {
 // #endregion
 
 /**
- * For "cooked" nodes this is a HydratedFlexTreeNode thats a projection of forest content.
+ * For hydrated nodes this is a HydratedFlexTreeNode thats a projection of forest content.
  * For {@link Unhydrated} nodes this is a UnhydratedFlexTreeNode.
- *
- * For "marinated" nodes, some code (ex: getOrCreateInnerNode) returns the FlexTreeNode thats a projection of forest content, and some code (ex: tryGetInnerNode) returns undefined.
  */
 export type InnerNode = FlexTreeNode;
 
@@ -621,13 +588,12 @@ export function getSimpleContextFromInnerNode(innerNode: InnerNode): Context {
  * For {@link Unhydrated} nodes, this returns the MapTreeNode.
  *
  * For hydrated nodes it returns a FlexTreeNode backed by the forest.
- * Note that for "marinated" nodes, this FlexTreeNode exists and returns it: it does not return the MapTreeNode which is the current InnerNode.
  *
  * @throws A {@link @fluidframework/telemetry-utils#UsageError} if the node has been deleted.
  */
-export function getOrCreateInnerNode(treeNode: TreeNode): InnerNode {
+export function getInnerNode(treeNode: TreeNode): InnerNode {
 	const kernel = getKernel(treeNode);
-	return kernel.getOrCreateInnerNode();
+	return kernel.getInnerNode();
 }
 
 /**

package/src/simple-tree/getTreeNodeForField.ts

@@ -40,7 +40,7 @@ export function tryGetTreeNodeForField(
 			return tryToUnboxLeaves(typedField);
 		}
 		case FieldKinds.identifier.identifier: {
-			// Identifier fields are just value fields that hold strings
+			// Identifier fields are just required fields that hold strings
 			return (field as FlexTreeRequiredField).content as string;
 		}
 

package/src/simple-tree/index.ts

@@ -21,7 +21,7 @@ export {
 	tryDisposeTreeNode,
 	HydratedContext,
 	SimpleContextSlot,
-	getOrCreateInnerNode,
+	getInnerNode,
 	getOrCreateNodeFromInnerNode,
 	getOrCreateNodeFromInnerUnboxedNode,
 	getKernel,
@@ -127,6 +127,13 @@ export {
 	type ArrayNodeCustomizableSchemaUnsafe,
 	type MapNodeCustomizableSchemaUnsafe,
 	type TreeRecordNodeUnsafe,
+	type UnannotateAllowedTypeUnsafe,
+	type AnnotatedAllowedTypeUnsafe,
+	type AnnotatedAllowedTypesUnsafe,
+	type AllowedTypesFullUnsafe,
+	type AllowedTypesFullFromMixedUnsafe,
+	type UnannotateAllowedTypesListUnsafe,
+	type AnnotateAllowedTypesListUnsafe,
 	type TreeViewAlpha,
 	type TreeBranch,
 	type TreeBranchEvents,

package/src/simple-tree/node-kinds/array/arrayNode.ts

@@ -25,7 +25,7 @@ import {
 	typeSchemaSymbol,
 	getOrCreateNodeFromInnerNode,
 	getSimpleNodeSchemaFromInnerNode,
-	getOrCreateInnerNode,
+	getInnerNode,
 	type TreeNodeSchemaClass,
 	getKernel,
 	type UnhydratedFlexTreeNode,
@@ -477,7 +477,7 @@ export class IterableTreeArrayContent<T> implements Iterable<T> {
  * Given a array node proxy, returns its underlying LazySequence field.
  */
 function getSequenceField(arrayNode: ReadonlyArrayNode): FlexTreeSequenceField {
-	return getOrCreateInnerNode(arrayNode).getBoxed(EmptyKey) as FlexTreeSequenceField;
+	return getInnerNode(arrayNode).getBoxed(EmptyKey) as FlexTreeSequenceField;
 }
 
 // For compatibility, we are initially implement 'readonly T[]' by applying the Array.prototype methods
@@ -886,7 +886,7 @@ abstract class CustomArrayNodeBase<const T extends ImplicitAllowedTypes>
 		);
 
 		const kernel = getKernel(this);
-		const flexContext = kernel.getOrCreateInnerNode().context;
+		const flexContext = kernel.getInnerNode().context;
 		assert(
 			flexContext === kernel.context.flexContext,
 			0xc14 /* Expected flexContext to match */,

package/src/simple-tree/node-kinds/map/mapNode.ts

@@ -26,7 +26,7 @@ import {
 	typeNameSymbol,
 	type TreeNode,
 	typeSchemaSymbol,
-	getOrCreateInnerNode,
+	getInnerNode,
 	type InternalTreeNode,
 	type UnhydratedFlexTreeNode,
 	normalizeAllowedTypes,
@@ -173,7 +173,7 @@ abstract class CustomMapNodeBase<const T extends ImplicitAllowedTypes> extends T
 	}
 
 	private get innerNode(): InnerNode {
-		return getOrCreateInnerNode(this);
+		return getInnerNode(this);
 	}
 
 	private editor(key: string): OptionalFieldEditBuilder<FlexibleNodeContent> {
@@ -242,7 +242,7 @@ abstract class CustomMapNodeBase<const T extends ImplicitAllowedTypes> extends T
 		callbackFn: (value: TreeNodeFromImplicitAllowedTypes<T>, key: string, map: TThis) => void,
 		thisArg?: unknown,
 	): void {
-		for (const field of getOrCreateInnerNode(this)) {
+		for (const field of getInnerNode(this)) {
 			const node = tryGetTreeNodeForField(field) as TreeNodeFromImplicitAllowedTypes<T>;
 			callbackFn.call(thisArg, node, field.key, this);
 		}

package/src/simple-tree/node-kinds/object/objectNode.ts

@@ -38,7 +38,7 @@ import {
 	type InternalTreeNode,
 	type TreeNode,
 	type UnhydratedFlexTreeNode,
-	getOrCreateInnerNode,
+	getInnerNode,
 	type NodeSchemaMetadata,
 	type ImplicitAllowedTypes,
 	TreeNodeValid,
@@ -243,7 +243,7 @@ function createProxyHandler(
 		get(target, propertyKey, proxy): unknown {
 			const fieldInfo = schema.flexKeyMap.get(propertyKey);
 			if (fieldInfo !== undefined) {
-				const flexNode = getOrCreateInnerNode(proxy);
+				const flexNode = getInnerNode(proxy);
 				debugAssert(() => !flexNode.context.isDisposed() || "FlexTreeNode is disposed");
 				const field = flexNode.tryGetField(fieldInfo.storedKey);
 				if (field !== undefined) {
@@ -274,7 +274,7 @@ function createProxyHandler(
 					: false;
 			}
 
-			const innerNode = getOrCreateInnerNode(proxy);
+			const innerNode = getInnerNode(proxy);
 
 			const innerSchema = innerNode.context.schema.nodeSchema.get(brand(schema.identifier));
 			assert(
@@ -321,7 +321,7 @@ function createProxyHandler(
 			// If a refactoring is done to associated flex tree data with the target not the proxy, this extra map could be removed,
 			// and the design would be more compatible with proxyless nodes.
 			const proxy = targetToProxy.get(target) ?? fail(0xadd /* missing proxy */);
-			const field = getOrCreateInnerNode(proxy).tryGetField(fieldInfo.storedKey);
+			const field = getInnerNode(proxy).tryGetField(fieldInfo.storedKey);
 
 			const p: PropertyDescriptor = {
 				value: field === undefined ? undefined : tryGetTreeNodeForField(field),

package/src/simple-tree/node-kinds/record/recordNode.ts

@@ -15,7 +15,7 @@ import {
 	typeNameSymbol,
 	typeSchemaSymbol,
 	type UnhydratedFlexTreeNode,
-	getOrCreateInnerNode,
+	getInnerNode,
 	getKernel,
 	type InternalTreeNode,
 	type NodeSchemaMetadata,
@@ -105,7 +105,7 @@ function createRecordNodeProxy(
 			}
 
 			if (typeof key === "string") {
-				const innerNode = getOrCreateInnerNode(receiver);
+				const innerNode = getInnerNode(receiver);
 				const field = innerNode.tryGetField(brand(key));
 				if (field !== undefined) {
 					return tryGetTreeNodeForField(field);
@@ -119,7 +119,7 @@ function createRecordNodeProxy(
 				return false;
 			}
 
-			const innerNode = getOrCreateInnerNode(receiver);
+			const innerNode = getInnerNode(receiver);
 			const field = innerNode.getBoxed(brand(key)) as FlexTreeOptionalField;
 			const kernel = getKernel(receiver);
 			const innerSchema = innerNode.context.schema.nodeSchema.get(brand(schema.identifier));
@@ -143,13 +143,13 @@ function createRecordNodeProxy(
 				return false;
 			}
 
-			const innerNode = getOrCreateInnerNode(proxy);
+			const innerNode = getInnerNode(proxy);
 			const childField = innerNode.tryGetField(brand(key));
 
 			return childField !== undefined;
 		},
 		ownKeys: (target) => {
-			const innerNode = getOrCreateInnerNode(proxy);
+			const innerNode = getInnerNode(proxy);
 			return [...innerNode.keys()];
 		},
 		getOwnPropertyDescriptor: (target, key) => {
@@ -157,7 +157,7 @@ function createRecordNodeProxy(
 				return undefined;
 			}
 
-			const innerNode = getOrCreateInnerNode(proxy);
+			const innerNode = getInnerNode(proxy);
 			const field = innerNode.tryGetField(brand(key));
 
 			if (field === undefined) {
@@ -179,7 +179,7 @@ function createRecordNodeProxy(
 				return false;
 			}
 
-			const innerNode = getOrCreateInnerNode(proxy);
+			const innerNode = getInnerNode(proxy);
 			const field = innerNode.tryGetField(brand(key)) as FlexTreeOptionalField | undefined;
 			if (field !== undefined) {
 				field.editor.set(undefined, field.length === 0);