@fluidframework/tree 2.41.0-338186 → 2.41.0

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

@@ -5,6 +5,7 @@
 
 import type { ImplicitFieldSchema } from "../schemaTypes.js";
 import type { SimpleTreeSchema } from "../simpleSchema.js";
+
 import { toSimpleTreeSchema } from "./viewSchemaToSimpleSchema.js";
 
 /**

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

@@ -7,7 +7,7 @@ import { UsageError } from "@fluidframework/telemetry-utils/internal";
 import type { TreeIndexKey } from "../../feature-libraries/index.js";
 import { FieldKind, type ImplicitFieldSchema } from "../schemaTypes.js";
 import type { TreeNode } from "../core/index.js";
-import { ObjectNodeSchema } from "../objectNodeTypes.js";
+import { ObjectNodeSchema } from "../node-kinds/index.js";
 import type { TreeView } from "./tree.js";
 import { walkFieldSchema } from "../walkFieldSchema.js";
 import { createSimpleTreeIndex, type SimpleTreeIndex } from "./simpleTreeIndex.js";

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

@@ -44,10 +44,15 @@ export {
 	enumFromStrings,
 	singletonSchema,
 } from "./schemaCreationUtilities.js";
-export { treeNodeApi, type TreeNodeApi, tryGetSchema } from "./treeNodeApi.js";
 export {
-	createFromInsertable,
-	cursorFromInsertable,
+	treeNodeApi,
+	type TreeNodeApi,
+	tryGetSchema,
+	getStoredKey,
+	getPropertyKeyFromStoredKey,
+	getIdentifierFromNode,
+} from "./treeNodeApi.js";
+export {
 	createFromCursor,
 	createFromMapTree,
 } from "./create.js";
@@ -131,11 +136,3 @@ export {
 export { generateSchemaFromSimpleSchema } from "./schemaFromSimple.js";
 export { toSimpleTreeSchema } from "./viewSchemaToSimpleSchema.js";
 export type { TreeChangeEvents } from "./treeChangeEvents.js";
-
-// Exporting the schema (RecursiveObject) to test that recursive types are working correctly.
-// These are `@internal` so they can't be included in the `InternalClassTreeTypes` due to https://github.com/microsoft/rushstack/issues/3639
-export {
-	RecursiveObject as test_RecursiveObject,
-	base as test_RecursiveObject_base,
-	RecursiveObjectPojoMode as test_RecursiveObjectPojoMode,
-} from "./testRecursiveDomain.js";

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

@@ -4,6 +4,7 @@
  */
 
 import { unreachableCase, fail } from "@fluidframework/core-utils/internal";
+
 import {
 	AdaptedViewSchema,
 	type TreeNodeStoredSchema,
@@ -24,6 +25,7 @@ import {
 } from "../../feature-libraries/index.js";
 import type { FieldSchema } from "../schemaTypes.js";
 import { toStoredSchema } from "../toStoredSchema.js";
+
 import type { SchemaCompatibilityStatus } from "./tree.js";
 
 /**

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

@@ -3,21 +3,29 @@
  * Licensed under the MIT License.
  */
 
-import { assert, unreachableCase } from "@fluidframework/core-utils/internal";
 import type { IFluidHandle } from "@fluidframework/core-interfaces";
+import { assert, unreachableCase } from "@fluidframework/core-utils/internal";
 import { isFluidHandle } from "@fluidframework/runtime-utils/internal";
 
 import type { TreeValue } from "../../core/index.js";
 import type { NodeIdentifierManager } from "../../feature-libraries/index.js";
+// This import is required for intellisense in @link doc comments on mouseover in VSCode.
+// eslint-disable-next-line unused-imports/no-unused-imports, @typescript-eslint/no-unused-vars
+import type { TreeAlpha } from "../../shared-tree/index.js";
 import {
 	type RestrictiveStringRecord,
 	getOrCreate,
 	isReadonlyArray,
 } from "../../util/index.js";
-// This import is required for intellisense in @link doc comments on mouseover in VSCode.
-// eslint-disable-next-line unused-imports/no-unused-imports, @typescript-eslint/no-unused-vars
-import type { TreeAlpha } from "../../shared-tree/index.js";
-
+import type {
+	NodeKind,
+	WithType,
+	TreeNodeSchema,
+	TreeNodeSchemaClass,
+	TreeNodeSchemaNonClass,
+	TreeNodeSchemaBoth,
+} from "../core/index.js";
+import { isLazy } from "../flexList.js";
 import {
 	booleanSchema,
 	handleSchema,
@@ -26,6 +34,16 @@ import {
 	stringSchema,
 	type LeafSchema,
 } from "../leafNodeSchema.js";
+import {
+	arraySchema,
+	type MapNodeInsertableData,
+	mapSchema,
+	objectSchema,
+	type TreeArrayNode,
+	type InsertableObjectFromSchemaRecord,
+	type TreeMapNode,
+	type TreeObjectNode,
+} from "../node-kinds/index.js";
 import {
 	FieldKind,
 	type FieldSchema,
@@ -43,24 +61,9 @@ import {
 	type UnannotateImplicitAllowedTypes,
 	type UnannotateSchemaRecord,
 } from "../schemaTypes.js";
-import type {
-	NodeKind,
-	WithType,
-	TreeNodeSchema,
-	TreeNodeSchemaClass,
-	TreeNodeSchemaNonClass,
-	TreeNodeSchemaBoth,
-} from "../core/index.js";
-import { type TreeArrayNode, arraySchema } from "../arrayNode.js";
-import {
-	type InsertableObjectFromSchemaRecord,
-	type TreeObjectNode,
-	objectSchema,
-} from "../objectNode.js";
-import { type MapNodeInsertableData, type TreeMapNode, mapSchema } from "../mapNode.js";
-import type { System_Unsafe, FieldSchemaAlphaUnsafe } from "./typesUnsafe.js";
+
 import { createFieldSchemaUnsafe } from "./schemaFactoryRecursive.js";
-import { isLazy } from "../flexList.js";
+import type { System_Unsafe, FieldSchemaAlphaUnsafe } from "./typesUnsafe.js";
 
 /**
  * Gets the leaf domain schema compatible with a given {@link TreeValue}.
@@ -1072,10 +1075,12 @@ export class SchemaFactory<
 	 * - It is a UUID which will not collide with other generated UUIDs.
 	 *
 	 * - It is compressed to a space-efficient representation when stored in the document.
+	 * Reading the identifier before inserting the node into a tree prevents the identifier from being stored in its compressed form,
+	 * resulting in a larger storage footprint.
 	 *
 	 * - A compressed form of the identifier can be accessed at runtime via the {@link TreeNodeApi.shortId|Tree.shortId()} API.
 	 *
-	 * - It will error if read (and will not be present in the object's iterable properties) before the node has been inserted into a tree.
+	 * - It will not be present in the object's iterable properties until explicitly read or until having been inserted into a tree.
 	 *
 	 * However, a user may alternatively supply their own string as the identifier if desired (for example, if importing identifiers from another system).
 	 * In that case, if the user requires it to be unique, it is up to them to ensure uniqueness.

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

@@ -3,6 +3,14 @@
  * Licensed under the MIT License.
  */
 
+import {
+	type ArrayNodeCustomizableSchema,
+	arraySchema,
+	type MapNodeCustomizableSchema,
+	mapSchema,
+	type ObjectNodeSchema,
+	objectSchema,
+} from "../node-kinds/index.js";
 import {
 	defaultSchemaFactoryObjectOptions,
 	SchemaFactory,
@@ -17,7 +25,6 @@ import type {
 	ImplicitFieldSchema,
 	NodeSchemaOptions,
 } from "../schemaTypes.js";
-import { objectSchema } from "../objectNode.js";
 import type { RestrictiveStringRecord } from "../../util/index.js";
 import type { NodeKind, TreeNodeSchemaClass } from "../core/index.js";
 import type {
@@ -25,12 +32,7 @@ import type {
 	MapNodeCustomizableSchemaUnsafe,
 	System_Unsafe,
 } from "./typesUnsafe.js";
-import { mapSchema } from "../mapNode.js";
-import { arraySchema } from "../arrayNode.js";
-import type { ObjectNodeSchema } from "../objectNodeTypes.js";
 import type { SimpleObjectNodeSchema } from "../simpleSchema.js";
-import type { ArrayNodeCustomizableSchema } from "../arrayNodeTypes.js";
-import type { MapNodeCustomizableSchema } from "../mapNodeTypes.js";
 
 /**
  * {@link SchemaFactory} with additional alpha APIs.

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

@@ -4,8 +4,8 @@
  */
 
 import type { RestrictiveStringRecord } from "../../util/index.js";
-import type { InsertableObjectFromSchemaRecord } from "../objectNode.js";
-
+import type { NodeKind, TreeNodeSchema, WithType, TreeNode } from "../core/index.js";
+import type { InsertableObjectFromSchemaRecord } from "../node-kinds/index.js";
 import {
 	type FieldKind,
 	type FieldProps,
@@ -14,7 +14,7 @@ import {
 	type ImplicitFieldSchema,
 	type InsertableTreeNodeFromImplicitAllowedTypes,
 } from "../schemaTypes.js";
-import type { NodeKind, TreeNodeSchema, WithType, TreeNode } from "../core/index.js";
+
 import type { FieldSchemaAlphaUnsafe, System_Unsafe } from "./typesUnsafe.js";
 
 export function createFieldSchemaUnsafe<

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

@@ -4,6 +4,7 @@
  */
 
 import { unreachableCase, fail } from "@fluidframework/core-utils/internal";
+
 import { NodeKind, type TreeNodeSchema } from "../core/index.js";
 import {
 	type FieldSchema,
@@ -17,8 +18,9 @@ import type {
 	SimpleNodeSchema,
 	SimpleTreeSchema,
 } from "../simpleSchema.js";
-import { SchemaFactoryAlpha } from "./schemaFactoryAlpha.js";
+
 import type { TreeSchema } from "./configuration.js";
+import { SchemaFactoryAlpha } from "./schemaFactoryAlpha.js";
 
 const factory = new SchemaFactoryAlpha(undefined);
 

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

@@ -28,9 +28,7 @@ import type {
 import { NodeKind, type TreeNodeSchema } from "../core/index.js";
 import type { TreeSchema } from "./configuration.js";
 import type { TreeSchemaEncodingOptions } from "./getJsonSchema.js";
-import { ObjectNodeSchema } from "../objectNodeTypes.js";
-import { ArrayNodeSchema } from "../arrayNodeTypes.js";
-import { MapNodeSchema } from "../mapNodeTypes.js";
+import { ArrayNodeSchema, MapNodeSchema, ObjectNodeSchema } from "../node-kinds/index.js";
 import { LeafNodeSchema } from "../leafNodeSchema.js";
 
 /**

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

@@ -4,11 +4,11 @@
  */
 
 import type { FluidClientVersion, ICodecOptions } from "../../codec/index.js";
+import { SchemaVersion } from "../../core/index.js";
 import {
 	defaultSchemaPolicy,
 	encodeTreeSchema,
 	makeSchemaCodec,
-	SchemaCodecVersion,
 } from "../../feature-libraries/index.js";
 import {
 	clientVersionToSchemaVersion,
@@ -17,10 +17,11 @@ import {
 } from "../../feature-libraries/schema-index/index.js";
 import type { JsonCompatible } from "../../util/index.js";
 import { normalizeFieldSchema, type ImplicitFieldSchema } from "../schemaTypes.js";
+import type { SimpleTreeSchema } from "../simpleSchema.js";
 import { simpleToStoredSchema } from "../toStoredSchema.js";
-import type { SchemaCompatibilityStatus } from "./tree.js";
+
 import { SchemaCompatibilityTester } from "./schemaCompatibilityTester.js";
-import type { SimpleTreeSchema } from "../simpleSchema.js";
+import type { SchemaCompatibilityStatus } from "./tree.js";
 
 /**
  * Dumps the "persisted" schema subset of the provided `schema` into a deterministic JSON-compatible, semi-human-readable format.
@@ -98,7 +99,7 @@ export function comparePersistedSchema(
 ): Omit<SchemaCompatibilityStatus, "canInitialize"> {
 	// Any version can be passed down to makeSchemaCodec here.
 	// We only use the decode part, which always dispatches to the correct codec based on the version in the data, not the version passed to `makeSchemaCodec`.
-	const schemaCodec = makeSchemaCodec(options, SchemaCodecVersion.v1);
+	const schemaCodec = makeSchemaCodec(options, SchemaVersion.v1);
 	const stored = schemaCodec.decode(persisted as Format);
 	const viewSchema = new SchemaCompatibilityTester(
 		defaultSchemaPolicy,

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

@@ -10,13 +10,11 @@ import type {
 	RevertibleAlphaFactory,
 	RevertibleFactory,
 } from "../../core/index.js";
-
 import type {
 	// This is referenced by doc comments.
 	// eslint-disable-next-line @typescript-eslint/no-unused-vars, unused-imports/no-unused-imports
 	TreeAlpha,
 } from "../../shared-tree/index.js";
-
 import type {
 	ImplicitFieldSchema,
 	InsertableField,
@@ -26,8 +24,9 @@ import type {
 	TreeFieldFromImplicitField,
 	UnsafeUnknownSchema,
 } from "../schemaTypes.js";
-import type { VerboseTree } from "./verboseTree.js";
 import type { SimpleTreeSchema } from "../simpleSchema.js";
+
+import type { TreeViewConfiguration } from "./configuration.js";
 import type {
 	RunTransactionParams,
 	TransactionCallbackStatus,
@@ -35,7 +34,7 @@ import type {
 	TransactionResultExt,
 	VoidTransactionCallbackStatus,
 } from "./transactionTypes.js";
-import type { TreeViewConfiguration } from "./configuration.js";
+import type { VerboseTree } from "./verboseTree.js";
 
 /**
  * A tree from which a {@link TreeView} can be created.

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

@@ -11,10 +11,11 @@ import {
 	type Unhydrated,
 	type WithType,
 } from "../core/index.js";
-import { treeNodeApi } from "./treeNodeApi.js";
-import { createFromCursor } from "./create.js";
 import type { ImplicitFieldSchema, TreeFieldFromImplicitField } from "../schemaTypes.js";
+
+import { createFromCursor } from "./create.js";
 import type { TreeChangeEvents } from "./treeChangeEvents.js";
+import { treeNodeApi } from "./treeNodeApi.js";
 
 // Tests for this file are grouped with those for treeNodeApi.ts as that is where this functionality will eventually land,
 // and where most of the actual implementation is for much of it.

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

@@ -38,8 +38,8 @@ import {
 	typeSchemaSymbol,
 	getOrCreateInnerNode,
 } from "../core/index.js";
-import { isObjectNodeSchema } from "../objectNodeTypes.js";
 import type { TreeChangeEvents } from "./treeChangeEvents.js";
+import { lazilyAllocateIdentifier, isObjectNodeSchema } from "../node-kinds/index.js";
 
 /**
  * Provides various functions for analyzing {@link TreeNode}s.
@@ -108,9 +108,9 @@ export interface TreeNodeApi {
 	/**
 	 * Returns the {@link SchemaFactory.identifier | identifier} of the given node in the most compressed form possible.
 	 * @remarks
-	 * If the node's identifier is a valid UUID that was automatically generated by the SharedTree, then this will return a process-unique integer corresponding to that identifier.
-	 * Note that the node must already have been inserted into the tree in order to retrieve a generated UUID (or shortId will error).
+	 * If the node is {@link Unhydrated | hydrated}  and its identifier is a valid UUID that was automatically generated by the SharedTree it is part of (or something else using the same {@link @fluidframework/id-compressor#IIdCompressor}), then this will return a process-unique integer corresponding to that identifier.
 	 * This is useful for performance-sensitive scenarios involving many nodes with identifiers that need to be compactly retained in memory or used for efficient lookup.
+	 * Note that automatically generated identifiers that were accessed before the node was hydrated will return the generated UUID, not the process-unique integer.
 	 *
 	 * If the node's identifier is any other user-provided string, then this will return that string.
 	 *
@@ -118,7 +118,7 @@ export interface TreeNodeApi {
 	 *
 	 * If the node has more than one identifier, then this will throw an error.
 	 *
-	 * The returned integer must not be serialized or preserved outside of the current process.
+	 * The returned integer should not be serialized or preserved outside of the current process.
 	 * Its lifetime is that of the current in-memory instance of the FF container for this client, and it is not guaranteed to be unique or stable outside of that context.
 	 * The same node's identifier may, for example, be different across multiple sessions for the same client and document, or different across two clients in the same session.
 	 */
@@ -217,42 +217,7 @@ export const treeNodeApi: TreeNodeApi = {
 		return tryGetSchema(node) ?? fail(0xb37 /* Not a tree node */);
 	},
 	shortId(node: TreeNode): number | string | undefined {
-		const schema = node[typeSchemaSymbol];
-		if (!isObjectNodeSchema(schema)) {
-			return undefined;
-		}
-
-		const flexNode = getOrCreateInnerNode(node);
-		const identifierFieldKeys = schema.identifierFieldKeys;
-
-		switch (identifierFieldKeys.length) {
-			case 0:
-				return undefined;
-			case 1: {
-				const identifier = flexNode.tryGetField(identifierFieldKeys[0] ?? oob())?.boxedAt(0);
-				if (flexNode instanceof UnhydratedFlexTreeNode) {
-					if (identifier === undefined) {
-						throw new UsageError(
-							"Tree.shortId cannot access default identifiers on unhydrated nodes",
-						);
-					}
-					return identifier.value as string;
-				}
-				assert(
-					identifier?.context.isHydrated() === true,
-					0xa27 /* Expected hydrated identifier */,
-				);
-				const identifierValue = identifier.value as string;
-
-				const localNodeKey =
-					identifier.context.nodeKeyManager.tryLocalizeNodeIdentifier(identifierValue);
-				return localNodeKey !== undefined ? extractFromOpaque(localNodeKey) : identifierValue;
-			}
-			default:
-				throw new UsageError(
-					"shortId() may not be called on a node with more than one identifier. Consider converting extraneous identifier fields to string fields.",
-				);
-		}
+		return getIdentifierFromNode(node, "preferCompressed");
 	},
 };
 
@@ -285,10 +250,94 @@ export function tryGetSchema(value: unknown): undefined | TreeNodeSchema {
 	}
 }
 
+/**
+ * Gets the identifier from a node.
+ *
+ * @param node - {@link TreeNode} where you want to extract the identifier from.
+ * @param compression - string value to determine what type of identifier you want to retrieve.
+ *
+ * @remarks
+ * If the node does not contain an identifier field, it returns undefined.
+ *
+ * If `compression` is set to `compressed`:
+ *
+ * - If the node contains a compressible identifier known by the id compressor, the compressed identifier is returned.
+ *
+ * - If the node contains an identifier, but is not compressible or unknown by the id compressor, `undefined` is returned.
+ *
+ * If `compression` is set to `preferCompressed`:
+ *
+ * - If the node contains a compressible identifier known by the id compressor, the compressed identifier is returned.
+ *
+ * - If the node contains an identifier, but is not compressible or unknown by the id compressor, the uncompressed identifier is returned.
+ *
+ * If `compression` is set to `uncompressed`:
+ * - If the node contains an identifier field, the uncompressed identifier is returned.
+ */
+export function getIdentifierFromNode(
+	node: TreeNode,
+	compression: "preferCompressed",
+): number | string | undefined;
+export function getIdentifierFromNode(
+	node: TreeNode,
+	compression: "compressed",
+): number | undefined;
+export function getIdentifierFromNode(
+	node: TreeNode,
+	compression: "uncompressed",
+): string | undefined;
+export function getIdentifierFromNode(
+	node: TreeNode,
+	compression: "preferCompressed" | "compressed" | "uncompressed",
+): number | string | undefined {
+	const schema = node[typeSchemaSymbol];
+	if (!isObjectNodeSchema(schema)) {
+		return undefined;
+	}
+
+	const flexNode = getOrCreateInnerNode(node);
+	const identifierFieldKeys = schema.identifierFieldKeys;
+
+	switch (identifierFieldKeys.length) {
+		case 0:
+			return undefined;
+		case 1: {
+			const key = identifierFieldKeys[0] ?? oob();
+			const identifier = flexNode.tryGetField(key)?.boxedAt(0);
+			if (flexNode instanceof UnhydratedFlexTreeNode) {
+				if (identifier === undefined) {
+					return lazilyAllocateIdentifier(flexNode, key);
+				}
+				return identifier.value as string;
+			}
+			assert(
+				identifier?.context.isHydrated() === true,
+				0xa27 /* Expected hydrated identifier */,
+			);
+			const identifierValue = identifier.value as string;
+
+			if (compression === "preferCompressed") {
+				const localNodeKey =
+					identifier.context.nodeKeyManager.tryLocalizeNodeIdentifier(identifierValue);
+				return localNodeKey !== undefined ? extractFromOpaque(localNodeKey) : identifierValue;
+			} else if (compression === "compressed") {
+				const localNodeKey =
+					identifier.context.nodeKeyManager.tryLocalizeNodeIdentifier(identifierValue);
+				return localNodeKey !== undefined ? extractFromOpaque(localNodeKey) : undefined;
+			}
+			return identifierValue;
+		}
+		default:
+			throw new UsageError(
+				"shortId() may not be called on a node with more than one identifier. Consider converting extraneous identifier fields to string fields.",
+			);
+	}
+}
+
 /**
  * Gets the stored key with which the provided node is associated in the parent.
  */
-function getStoredKey(node: TreeNode): string | number {
+export function getStoredKey(node: TreeNode): string | number {
 	// Note: the flex domain strictly works with "stored keys", and knows nothing about the developer-facing
 	// "property keys".
 	const parentField = getOrCreateInnerNode(node).parentField;
@@ -309,7 +358,7 @@ function getStoredKey(node: TreeNode): string | number {
 /**
  * Given a node schema, gets the property key corresponding with the provided {@link FieldProps.key | stored key}.
  */
-function getPropertyKeyFromStoredKey(
+export function getPropertyKeyFromStoredKey(
 	schema: TreeNodeSchema,
 	storedKey: string | number,
 ): string | number {

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

@@ -28,7 +28,7 @@ import type {
 	TreeNodeSchemaCore,
 	TreeNodeSchemaClass,
 } from "../core/index.js";
-import type { TreeArrayNode } from "../arrayNode.js";
+import type { TreeArrayNode } from "../node-kinds/index.js";
 import type { FlexListToUnion, LazyItem } from "../flexList.js";
 import type { SimpleArrayNodeSchema, SimpleMapNodeSchema } from "../simpleSchema.js";
 

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

@@ -36,7 +36,7 @@ import {
 	numberSchema,
 	stringSchema,
 } from "../leafNodeSchema.js";
-import { isObjectNodeSchema } from "../objectNodeTypes.js";
+import { isObjectNodeSchema } from "../node-kinds/index.js";
 import {
 	customFromCursor,
 	replaceHandles,

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

@@ -15,12 +15,10 @@ import type {
 	SimpleObjectNodeSchema,
 	SimpleTreeSchema,
 } from "../simpleSchema.js";
-import { ObjectNodeSchema } from "../objectNodeTypes.js";
 import { NodeKind } from "../core/index.js";
+import { ArrayNodeSchema, MapNodeSchema, ObjectNodeSchema } from "../node-kinds/index.js";
 import { walkFieldSchema } from "../walkFieldSchema.js";
-import { ArrayNodeSchema } from "../arrayNodeTypes.js";
 import { LeafNodeSchema } from "../leafNodeSchema.js";
-import { MapNodeSchema } from "../mapNodeTypes.js";
 
 /**
  * Converts an {@link ImplicitFieldSchema} to a "simple" schema representation.

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

@@ -9,6 +9,7 @@ import type {
 	FlexTreeHydratedContext,
 } from "../../feature-libraries/index.js";
 import { brand } from "../../util/index.js";
+
 import type { TreeNodeSchema } from "./treeNodeSchema.js";
 import { walkAllowedTypes } from "./walkSchema.js";
 

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

@@ -4,13 +4,14 @@
  */
 
 import type { TreeValue } from "../../core/index.js";
+
+import type { TreeNode } from "./treeNode.js";
 import {
 	type InnerNode,
 	unhydratedFlexTreeNodeToTreeNode,
-	proxySlot,
+	simpleTreeNodeSlot,
 	createTreeNodeFromInner,
 } from "./treeNodeKernel.js";
-import type { TreeNode } from "./treeNode.js";
 import { UnhydratedFlexTreeNode } from "./unhydratedFlexTree.js";
 
 /**
@@ -23,7 +24,7 @@ export function getOrCreateNodeFromInnerNode(flexNode: InnerNode): TreeNode | Tr
 	const cached =
 		flexNode instanceof UnhydratedFlexTreeNode
 			? unhydratedFlexTreeNodeToTreeNode.get(flexNode)
-			: flexNode.anchorNode.slots.get(proxySlot);
+			: flexNode.anchorNode.slots.get(simpleTreeNodeSlot);
 
 	if (cached !== undefined) {
 		return cached;

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

@@ -6,10 +6,10 @@
 import { assert } from "@fluidframework/core-utils/internal";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 
+import { tryGetTreeNodeSchema } from "./treeNodeKernel.js";
 import { NodeKind, type TreeNodeSchemaClass } from "./treeNodeSchema.js";
 // eslint-disable-next-line import/no-deprecated
 import { type WithType, typeNameSymbol, type typeSchemaSymbol } from "./withType.js";
-import { tryGetTreeNodeSchema } from "./treeNodeKernel.js";
 
 /**
  * A non-{@link NodeKind.Leaf|leaf} SharedTree node. Includes objects, arrays, and maps.