@fluidframework/tree 2.3.1 → 2.4.0-297027

package/src/simple-tree/{walkSchema.ts → core/walkSchema.ts}

@@ -3,17 +3,11 @@
  * Licensed under the MIT License.
  */
 
-import { assert } from "@fluidframework/core-utils/internal";
-import { type TreeNodeSchema, NodeKind } from "./core/index.js";
-import { LeafNodeSchema } from "./leafNodeSchema.js";
-import { isObjectNodeSchema } from "./objectNodeTypes.js";
-import {
-	type ImplicitAllowedTypes,
-	normalizeAllowedTypes,
-	type ImplicitFieldSchema,
-	normalizeFieldSchema,
-} from "./schemaTypes.js";
+import type { TreeNodeSchema } from "./treeNodeSchema.js";
 
+/**
+ * Traverses all {@link TreeNodeSchema} schema reachable from `schema`, applying the visitor pattern.
+ */
 export function walkNodeSchema(
 	schema: TreeNodeSchema,
 	visitor: SchemaVisitor,
@@ -23,20 +17,9 @@ export function walkNodeSchema(
 		return;
 	}
 	visitedSet.add(schema);
-	if (schema instanceof LeafNodeSchema) {
-		// nothing to do
-	} else if (isObjectNodeSchema(schema)) {
-		for (const field of schema.fields.values()) {
-			walkFieldSchema(field, visitor, visitedSet);
-		}
-	} else {
-		assert(
-			schema.kind === NodeKind.Array || schema.kind === NodeKind.Map,
-			0x9b3 /* invalid schema */,
-		);
-		const childTypes = schema.info as ImplicitAllowedTypes;
-		walkAllowedTypes(normalizeAllowedTypes(childTypes), visitor, visitedSet);
-	}
+
+	walkAllowedTypes(schema.childTypes, visitor, visitedSet);
+
 	// This visit is done at the end so the traversal order is most inner types first.
 	// This was picked since when fixing errors,
 	// working from the inner types out to the types that use them will probably go better than the reverse.
@@ -44,28 +27,23 @@ export function walkNodeSchema(
 	visitor.node?.(schema);
 }
 
-export function walkFieldSchema(
-	schema: ImplicitFieldSchema,
-	visitor: SchemaVisitor,
-	visitedSet: Set<TreeNodeSchema> = new Set(),
-): void {
-	walkAllowedTypes(normalizeFieldSchema(schema).allowedTypeSet, visitor, visitedSet);
-}
-
+/**
+ * Traverses all {@link TreeNodeSchema} schema reachable from `allowedTypes`, applying the visitor pattern.
+ */
 export function walkAllowedTypes(
 	allowedTypes: Iterable<TreeNodeSchema>,
 	visitor: SchemaVisitor,
-	visitedSet: Set<TreeNodeSchema>,
+	visitedSet: Set<TreeNodeSchema> = new Set(),
 ): void {
 	for (const childType of allowedTypes) {
 		walkNodeSchema(childType, visitor, visitedSet);
 	}
 	visitor.allowedTypes?.(allowedTypes);
 }
+
 /**
  * Callbacks for use in {@link walkFieldSchema} / {@link walkAllowedTypes} / {@link walkNodeSchema}.
  */
-
 export interface SchemaVisitor {
 	/**
 	 * Called once for each node schema.

package/src/simple-tree/createContext.ts

@@ -0,0 +1,24 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { defaultSchemaPolicy } from "../feature-libraries/index.js";
+import { getOrCreate } from "../util/index.js";
+import { Context, UnhydratedContext } from "./core/index.js";
+import { normalizeFieldSchema, type ImplicitFieldSchema } from "./schemaTypes.js";
+import { toStoredSchema } from "./toFlexSchema.js";
+
+const contextCache: WeakMap<ImplicitFieldSchema, Context> = new WeakMap();
+
+/**
+ * Utility for creating {@link Context}s for unhydrated nodes.
+ */
+export function getUnhydratedContext(schema: ImplicitFieldSchema): Context {
+	return getOrCreate(contextCache, schema, (s) => {
+		const normalized = normalizeFieldSchema(schema);
+
+		const flexContext = new UnhydratedContext(defaultSchemaPolicy, toStoredSchema(schema));
+		return new Context(normalized.allowedTypeSet, flexContext);
+	});
+}

package/src/simple-tree/index.ts

@@ -20,10 +20,13 @@ export {
 	type InternalTreeNode,
 	isTreeNode,
 	tryDisposeTreeNode,
+	HydratedContext,
+	SimpleContextSlot,
 } from "./core/index.js";
 export {
 	type ITree,
 	type TreeView,
+	type ViewableTree,
 	type TreeViewEvents,
 	TreeViewConfiguration,
 	type ITreeViewConfiguration,
@@ -64,6 +67,7 @@ export {
 	type JsonLeafSchemaType,
 	getJsonSchema,
 	getSimpleSchema,
+	ViewSchema,
 } from "./api/index.js";
 export {
 	type NodeFromSchema,
@@ -84,9 +88,9 @@ export {
 	type FieldProps,
 	normalizeFieldSchema,
 	type ApplyKind,
+	type FieldSchemaMetadata,
 } from "./schemaTypes.js";
 export { getOrCreateInnerNode } from "./proxyBinding.js";
-export { toFlexSchema } from "./toFlexSchema.js";
 export type {
 	FieldHasDefaultUnsafe,
 	ObjectFromSchemaRecordUnsafe,
@@ -123,7 +127,7 @@ export {
 } from "./objectNode.js";
 export type { TreeMapNode, MapNodeInsertableData } from "./mapNode.js";
 export { mapTreeFromNodeData, type InsertableContent } from "./toMapTree.js";
-export { toStoredSchema, getStoredSchema, getFlexSchema } from "./toFlexSchema.js";
+export { toStoredSchema, getStoredSchema } from "./toFlexSchema.js";
 export {
 	numberSchema,
 	stringSchema,

package/src/simple-tree/leafNodeSchema.ts

@@ -7,17 +7,11 @@ import { assert } from "@fluidframework/core-utils/internal";
 
 import { type TreeValue, ValueSchema } from "../core/index.js";
 import {
-	LeafNodeSchema as FlexLeafNodeSchema,
 	type FlexTreeNode,
 	isFlexTreeNode,
 	valueSchemaAllows,
 } from "../feature-libraries/index.js";
-import {
-	setFlexSchemaFromClassSchema,
-	NodeKind,
-	type TreeNodeSchema,
-	type TreeNodeSchemaNonClass,
-} from "./core/index.js";
+import { NodeKind, type TreeNodeSchema, type TreeNodeSchemaNonClass } from "./core/index.js";
 
 /**
  * Instances of this class are schema for leaf nodes.
@@ -35,6 +29,8 @@ export class LeafNodeSchema<Name extends string, const T extends ValueSchema>
 	public readonly kind = NodeKind.Leaf;
 	public readonly info: T;
 	public readonly implicitlyConstructable = true as const;
+	public readonly childTypes: ReadonlySet<TreeNodeSchema> = new Set();
+
 	public create(data: TreeValue<T> | FlexTreeNode): TreeValue<T> {
 		if (isFlexTreeNode(data)) {
 			const value = data.value;
@@ -45,8 +41,6 @@ export class LeafNodeSchema<Name extends string, const T extends ValueSchema>
 	}
 
 	public constructor(name: Name, t: T) {
-		const schema: FlexLeafNodeSchema = new FlexLeafNodeSchema({ name: "makeLeaf" }, name, t);
-		setFlexSchemaFromClassSchema(this, schema);
 		this.identifier = name;
 		this.info = t;
 	}

package/src/simple-tree/mapNode.ts

@@ -3,14 +3,11 @@
  * Licensed under the MIT License.
  */
 
+import { Lazy } from "@fluidframework/core-utils/internal";
 import {
-	type FlexMapNodeSchema,
 	type FlexTreeNode,
 	type FlexTreeOptionalField,
-	type MapTreeNode,
 	type OptionalFieldEditBuilder,
-	UnhydratedContext,
-	getOrCreateMapTreeNode,
 	getSchemaAndPolicy,
 } from "../feature-libraries/index.js";
 import { getTreeNodeForField, prepareContentForHydration } from "./proxies.js";
@@ -18,6 +15,7 @@ import { getOrCreateInnerNode } from "./proxyBinding.js";
 import {
 	createFieldSchema,
 	FieldKind,
+	normalizeAllowedTypes,
 	type ImplicitAllowedTypes,
 	type InsertableTreeNodeFromImplicitAllowedTypes,
 	type TreeNodeFromImplicitAllowedTypes,
@@ -26,23 +24,25 @@ import {
 	getKernel,
 	type InnerNode,
 	NodeKind,
-	type TreeNodeSchemaClass,
+	type TreeNodeSchemaBoth,
 	type TreeNodeSchema,
 	type WithType,
 	// eslint-disable-next-line import/no-deprecated
 	typeNameSymbol,
 	type TreeNode,
 	typeSchemaSymbol,
+	type Context,
+	UnhydratedFlexTreeNode,
 } from "./core/index.js";
 import {
 	mapTreeFromNodeData,
 	type FactoryContent,
 	type InsertableContent,
 } from "./toMapTree.js";
-import { getFlexSchema, toFlexSchema } from "./toFlexSchema.js";
-import { brand, count, type RestrictiveReadonlyRecord } from "../util/index.js";
+import { brand, count, type RestrictiveStringRecord } from "../util/index.js";
 import { TreeNodeValid, type MostDerivedData } from "./treeNodeValid.js";
 import type { ExclusiveMapTree } from "../core/index.js";
+import { getUnhydratedContext } from "./createContext.js";
 
 /**
  * A map of string keys to tree objects.
@@ -233,8 +233,9 @@ export function mapSchema<
 	implicitlyConstructable: ImplicitlyConstructable,
 	useMapPrototype: boolean,
 ) {
-	let flexSchema: FlexMapNodeSchema;
-	let unhydratedContext: UnhydratedContext;
+	const lazyChildTypes = new Lazy(() => normalizeAllowedTypes(info));
+
+	let unhydratedContext: Context;
 
 	class Schema extends CustomMapNodeBase<T> implements TreeMapNode<T> {
 		public static override prepareInstance<T2>(
@@ -252,26 +253,28 @@ export function mapSchema<
 			this: typeof TreeNodeValid<T2>,
 			instance: TreeNodeValid<T2>,
 			input: T2,
-		): MapTreeNode {
-			return getOrCreateMapTreeNode(
+		): UnhydratedFlexTreeNode {
+			return UnhydratedFlexTreeNode.getOrCreate(
 				unhydratedContext,
-				flexSchema,
 				mapTreeFromNodeData(input as FactoryContent, this as unknown as ImplicitAllowedTypes),
 			);
 		}
 
 		protected static override constructorCached: MostDerivedData | undefined = undefined;
 
-		protected static override oneTimeSetup<T2>(this: typeof TreeNodeValid<T2>): void {
+		protected static override oneTimeSetup<T2>(this: typeof TreeNodeValid<T2>): Context {
 			const schema = this as unknown as TreeNodeSchema;
-			flexSchema = getFlexSchema(schema) as FlexMapNodeSchema;
-			unhydratedContext = new UnhydratedContext(toFlexSchema(schema));
+			unhydratedContext = getUnhydratedContext(schema);
+			return unhydratedContext;
 		}
 
 		public static readonly identifier = identifier;
 		public static readonly info = info;
 		public static readonly implicitlyConstructable: ImplicitlyConstructable =
 			implicitlyConstructable;
+		public static get childTypes(): ReadonlySet<TreeNodeSchema> {
+			return lazyChildTypes.value;
+		}
 
 		// eslint-disable-next-line import/no-deprecated
 		public get [typeNameSymbol](): TName {
@@ -281,7 +284,7 @@ export function mapSchema<
 			return Schema.constructorCached?.constructor as unknown as typeof schemaErased;
 		}
 	}
-	const schemaErased: TreeNodeSchemaClass<
+	const schemaErased: TreeNodeSchemaBoth<
 		TName,
 		NodeKind.Map,
 		TreeMapNode<T> & WithType<TName, NodeKind.Map>,
@@ -298,4 +301,4 @@ export function mapSchema<
  */
 export type MapNodeInsertableData<T extends ImplicitAllowedTypes> =
 	| Iterable<readonly [string, InsertableTreeNodeFromImplicitAllowedTypes<T>]>
-	| RestrictiveReadonlyRecord<string, InsertableTreeNodeFromImplicitAllowedTypes<T>>;
+	| RestrictiveStringRecord<InsertableTreeNodeFromImplicitAllowedTypes<T>>;

package/src/simple-tree/objectNode.ts

@@ -3,22 +3,17 @@
  * Licensed under the MIT License.
  */
 
-import { assert } from "@fluidframework/core-utils/internal";
+import { assert, Lazy } from "@fluidframework/core-utils/internal";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 
 import type { FieldKey } from "../core/index.js";
 import {
 	FieldKinds,
-	type FlexObjectNodeSchema,
 	type FlexTreeField,
 	type FlexTreeNode,
 	type FlexTreeOptionalField,
 	type FlexTreeRequiredField,
-	getOrCreateMapTreeNode,
 	getSchemaAndPolicy,
-	isMapTreeNode,
-	type MapTreeNode,
-	UnhydratedContext,
 } from "../feature-libraries/index.js";
 import { getTreeNodeForField, prepareContentForHydration } from "./proxies.js";
 import { getOrCreateInnerNode } from "./proxyBinding.js";
@@ -42,21 +37,23 @@ import {
 	typeSchemaSymbol,
 	type InternalTreeNode,
 	type TreeNode,
+	type Context,
+	UnhydratedFlexTreeNode,
 } from "./core/index.js";
 import { mapTreeFromNodeData, type InsertableContent } from "./toMapTree.js";
-import { type RestrictiveReadonlyRecord, fail, type FlattenKeys } from "../util/index.js";
-import { getFlexSchema, toFlexSchema } from "./toFlexSchema.js";
+import { type RestrictiveStringRecord, fail, type FlattenKeys } from "../util/index.js";
 import type { ObjectNodeSchema, ObjectNodeSchemaInternalData } from "./objectNodeTypes.js";
 import { TreeNodeValid, type MostDerivedData } from "./treeNodeValid.js";
+import { getUnhydratedContext } from "./createContext.js";
 
 /**
  * Helper used to produce types for object nodes.
  * @system @public
  */
-export type ObjectFromSchemaRecord<
-	T extends RestrictiveReadonlyRecord<string, ImplicitFieldSchema>,
-> = {
-	-readonly [Property in keyof T]: TreeFieldFromImplicitField<T[Property]>;
+export type ObjectFromSchemaRecord<T extends RestrictiveStringRecord<ImplicitFieldSchema>> = {
+	-readonly [Property in keyof T]: Property extends string
+		? TreeFieldFromImplicitField<T[Property]>
+		: unknown;
 };
 
 /**
@@ -71,7 +68,7 @@ export type ObjectFromSchemaRecord<
  * @public
  */
 export type TreeObjectNode<
-	T extends RestrictiveReadonlyRecord<string, ImplicitFieldSchema>,
+	T extends RestrictiveStringRecord<ImplicitFieldSchema>,
 	TypeName extends string = string,
 > = TreeNode & ObjectFromSchemaRecord<T> & WithType<TypeName, NodeKind.Object, T>;
 
@@ -106,15 +103,17 @@ export type FieldHasDefault<T extends ImplicitFieldSchema> = T extends FieldSche
  * @system @public
  */
 export type InsertableObjectFromSchemaRecord<
-	T extends RestrictiveReadonlyRecord<string, ImplicitFieldSchema>,
+	T extends RestrictiveStringRecord<ImplicitFieldSchema>,
 > = FlattenKeys<
 	{
-		readonly [Property in keyof T]?: InsertableTreeFieldFromImplicitField<T[Property]>;
+		readonly [Property in keyof T]?: InsertableTreeFieldFromImplicitField<
+			T[Property] & string
+		>;
 	} & {
 		// Field does not have a known default, make it required:
-		readonly [Property in keyof T as FieldHasDefault<T[Property]> extends false
+		readonly [Property in keyof T as FieldHasDefault<T[Property] & string> extends false
 			? Property
-			: never]: InsertableTreeFieldFromImplicitField<T[Property]>;
+			: never]: InsertableTreeFieldFromImplicitField<T[Property] & string>;
 	}
 >;
 
@@ -152,7 +151,7 @@ function createFlexKeyMapping(fields: Record<string, ImplicitFieldSchema>): Simp
  * If not provided `{}` is used for the target.
  */
 function createProxyHandler(
-	flexKeyMap: SimpleKeyMap,
+	schema: ObjectNodeSchema & ObjectNodeSchemaInternalData,
 	allowAdditionalProperties: boolean,
 ): ProxyHandler<TreeNode> {
 	// To satisfy 'deepEquals' level scrutiny, the target of the proxy must be an object with the same
@@ -166,7 +165,7 @@ function createProxyHandler(
 	// a dispatch object to see if it improves performance.
 	const handler: ProxyHandler<TreeNode> = {
 		get(target, propertyKey, proxy): unknown {
-			const fieldInfo = flexKeyMap.get(propertyKey);
+			const fieldInfo = schema.flexKeyMap.get(propertyKey);
 
 			if (fieldInfo !== undefined) {
 				const flexNode = getOrCreateInnerNode(proxy);
@@ -179,7 +178,10 @@ function createProxyHandler(
 				// Check if the user is trying to read an identifier field of an unhydrated node, but the identifier is not present.
 				// This means the identifier is an "auto-generated identifier", because otherwise it would have been supplied by the user at construction time and would have been successfully read just above.
 				// In this case, it is categorically impossible to provide an identifier (auto-generated identifiers can't be created until hydration/insertion time), so we emit an error.
-				if (fieldInfo.schema.kind === FieldKind.Identifier && isMapTreeNode(flexNode)) {
+				if (
+					fieldInfo.schema.kind === FieldKind.Identifier &&
+					flexNode instanceof UnhydratedFlexTreeNode
+				) {
 					throw new UsageError(
 						"An automatically generated node identifier may not be queried until the node is inserted into the tree",
 					);
@@ -188,11 +190,20 @@ function createProxyHandler(
 				return undefined;
 			}
 
+			// POJO mode objects don't have TreeNode's build in members on their targets, so special case them:
+			if (propertyKey === typeSchemaSymbol) {
+				return schema;
+			}
+			// eslint-disable-next-line import/no-deprecated
+			if (propertyKey === typeNameSymbol) {
+				return schema.identifier;
+			}
+
 			// Pass the proxy as the receiver here, so that any methods on the prototype receive `proxy` as `this`.
 			return Reflect.get(target, propertyKey, proxy);
 		},
 		set(target, propertyKey, value: InsertableContent | undefined, proxy) {
-			const fieldInfo = flexKeyMap.get(propertyKey);
+			const fieldInfo = schema.flexKeyMap.get(propertyKey);
 			if (fieldInfo === undefined) {
 				// Pass the proxy as the receiver here, so that setters on the prototype receive `proxy` as `this`.
 				return allowAdditionalProperties
@@ -215,18 +226,18 @@ function createProxyHandler(
 		},
 		has: (target, propertyKey) => {
 			return (
-				flexKeyMap.has(propertyKey) ||
+				schema.flexKeyMap.has(propertyKey) ||
 				(allowAdditionalProperties ? Reflect.has(target, propertyKey) : false)
 			);
 		},
 		ownKeys: (target) => {
 			return [
-				...flexKeyMap.keys(),
+				...schema.flexKeyMap.keys(),
 				...(allowAdditionalProperties ? Reflect.ownKeys(target) : []),
 			];
 		},
 		getOwnPropertyDescriptor: (target, propertyKey) => {
-			const fieldInfo = flexKeyMap.get(propertyKey);
+			const fieldInfo = schema.flexKeyMap.get(propertyKey);
 
 			if (fieldInfo === undefined) {
 				return allowAdditionalProperties
@@ -272,7 +283,7 @@ export function setField(
 		prepareContentForHydration(mapTree, field.context.checkout.forest);
 	}
 
-	switch (field.schema.kind) {
+	switch (field.schema) {
 		case FieldKinds.required.identifier: {
 			assert(mapTree !== undefined, 0xa04 /* Cannot set a required field to undefined */);
 			const typedField = field as FlexTreeRequiredField;
@@ -291,7 +302,7 @@ export function setField(
 }
 
 abstract class CustomObjectNodeBase<
-	const T extends RestrictiveReadonlyRecord<string, ImplicitFieldSchema>,
+	const T extends RestrictiveStringRecord<ImplicitFieldSchema>,
 > extends TreeNodeValid<InsertableObjectFromSchemaRecord<T>> {
 	public static readonly kind = NodeKind.Object;
 }
@@ -304,7 +315,7 @@ abstract class CustomObjectNodeBase<
  */
 export function objectSchema<
 	TName extends string,
-	const T extends RestrictiveReadonlyRecord<string, ImplicitFieldSchema>,
+	const T extends RestrictiveStringRecord<ImplicitFieldSchema>,
 	const ImplicitlyConstructable extends boolean,
 >(
 	identifier: TName,
@@ -318,10 +329,20 @@ export function objectSchema<
 	// Performance optimization: cache property key => stored key and schema.
 	const flexKeyMap: SimpleKeyMap = createFlexKeyMapping(info);
 
+	const identifierFieldKeys: FieldKey[] = [];
+	for (const item of flexKeyMap.values()) {
+		if (item.schema.kind === FieldKind.Identifier) {
+			identifierFieldKeys.push(item.storedKey);
+		}
+	}
+
+	const lazyChildTypes = new Lazy(
+		() => new Set(Array.from(flexKeyMap.values(), (f) => [...f.schema.allowedTypeSet]).flat()),
+	);
+
 	let handler: ProxyHandler<object>;
 	let customizable: boolean;
-	let flexSchema: FlexObjectNodeSchema;
-	let unhydratedContext: UnhydratedContext;
+	let unhydratedContext: Context;
 
 	class CustomObjectNode extends CustomObjectNodeBase<T> {
 		public static readonly fields: ReadonlyMap<string, FieldSchema> = new Map(
@@ -337,6 +358,7 @@ export function objectSchema<
 				key as string,
 			]),
 		);
+		public static readonly identifierFieldKeys: readonly FieldKey[] = identifierFieldKeys;
 
 		public static override prepareInstance<T2>(
 			this: typeof TreeNodeValid<T2>,
@@ -372,23 +394,21 @@ export function objectSchema<
 			this: typeof TreeNodeValid<T2>,
 			instance: TreeNodeValid<T2>,
 			input: T2,
-		): MapTreeNode {
-			return getOrCreateMapTreeNode(
+		): UnhydratedFlexTreeNode {
+			return UnhydratedFlexTreeNode.getOrCreate(
 				unhydratedContext,
-				flexSchema,
 				mapTreeFromNodeData(input as object, this as unknown as ImplicitAllowedTypes),
 			);
 		}
 
 		protected static override constructorCached: MostDerivedData | undefined = undefined;
 
-		protected static override oneTimeSetup<T2>(this: typeof TreeNodeValid<T2>): void {
+		protected static override oneTimeSetup<T2>(this: typeof TreeNodeValid<T2>): Context {
 			// One time initialization that required knowing the most derived type (from this.constructor) and thus has to be lazy.
 			customizable = (this as unknown) !== CustomObjectNode;
-			handler = createProxyHandler(flexKeyMap, customizable);
-			const schema = this as unknown as TreeNodeSchema;
-			flexSchema = getFlexSchema(schema) as FlexObjectNodeSchema;
-			unhydratedContext = new UnhydratedContext(toFlexSchema(schema));
+			const schema = this as unknown as ObjectNodeSchema & ObjectNodeSchemaInternalData;
+			handler = createProxyHandler(schema, customizable);
+			unhydratedContext = getUnhydratedContext(schema);
 
 			// First run, do extra validation.
 			// TODO: provide a way for TreeConfiguration to trigger this same validation to ensure it gets run early.
@@ -414,12 +434,17 @@ export function objectSchema<
 					prototype = Reflect.getPrototypeOf(prototype) as object;
 				}
 			}
+
+			return unhydratedContext;
 		}
 
 		public static readonly identifier = identifier;
 		public static readonly info = info;
 		public static readonly implicitlyConstructable: ImplicitlyConstructable =
 			implicitlyConstructable;
+		public static get childTypes(): ReadonlySet<TreeNodeSchema> {
+			return lazyChildTypes.value;
+		}
 
 		// eslint-disable-next-line import/no-deprecated
 		public get [typeNameSymbol](): TName {
@@ -445,7 +470,7 @@ const targetToProxy: WeakMap<object, TreeNode> = new WeakMap();
  */
 function assertUniqueKeys<
 	const Name extends number | string,
-	const Fields extends RestrictiveReadonlyRecord<string, ImplicitFieldSchema>,
+	const Fields extends RestrictiveStringRecord<ImplicitFieldSchema>,
 >(schemaName: Name, fields: Fields): void {
 	// Verify that there are no duplicates among the explicitly specified stored keys.
 	const explicitStoredKeys = new Set<string>();

package/src/simple-tree/objectNodeTypes.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import type { RestrictiveReadonlyRecord } from "../util/index.js";
+import type { RestrictiveStringRecord } from "../util/index.js";
 import type {
 	TreeObjectNode,
 	InsertableObjectFromSchemaRecord,
@@ -20,10 +20,8 @@ import type { FieldKey } from "../core/index.js";
  */
 export interface ObjectNodeSchema<
 	TName extends string = string,
-	T extends RestrictiveReadonlyRecord<string, ImplicitFieldSchema> = RestrictiveReadonlyRecord<
-		string,
-		ImplicitFieldSchema
-	>,
+	T extends
+		RestrictiveStringRecord<ImplicitFieldSchema> = RestrictiveStringRecord<ImplicitFieldSchema>,
 	ImplicitlyConstructable extends boolean = boolean,
 > extends TreeNodeSchemaClass<
 		TName,
@@ -52,6 +50,11 @@ export interface ObjectNodeSchemaInternalData {
 	 * Lookup the property keys from the stored keys.
 	 */
 	readonly storedKeyToPropertyKey: ReadonlyMap<FieldKey, string>;
+
+	/**
+	 * Stored keys which hold identifiers.
+	 */
+	readonly identifierFieldKeys: readonly FieldKey[];
 }
 
 export const ObjectNodeSchema = {

package/src/simple-tree/proxies.ts

@@ -16,8 +16,6 @@ import {
 import {
 	FieldKinds,
 	type FlexTreeField,
-	type FlexTreeNode,
-	tryGetMapTreeNode,
 	isFlexTreeNode,
 	type FlexTreeRequiredField,
 	type FlexTreeOptionalField,
@@ -25,10 +23,10 @@ import {
 import { type Mutable, fail, isReadonlyArray } from "../util/index.js";
 import {
 	getKernel,
-	tryGetCachedTreeNode,
 	type TreeNode,
-	getSimpleNodeSchemaFromNode,
-	type InternalTreeNode,
+	tryGetTreeNodeFromMapNode,
+	getOrCreateNodeFromInnerNode,
+	tryUnhydratedFlexTreeNode,
 } from "./core/index.js";
 
 /**
@@ -40,10 +38,10 @@ export function getTreeNodeForField(field: FlexTreeField): TreeNode | TreeValue
 	): TreeNode | TreeValue | undefined {
 		const maybeContent = flexField.content;
 		return isFlexTreeNode(maybeContent)
-			? getOrCreateNodeFromFlexTreeNode(maybeContent)
+			? getOrCreateNodeFromInnerNode(maybeContent)
 			: maybeContent;
 	}
-	switch (field.schema.kind) {
+	switch (field.schema) {
 		case FieldKinds.required.identifier: {
 			const typedField = field as FlexTreeRequiredField;
 			return tryToUnboxLeaves(typedField);
@@ -62,22 +60,6 @@ export function getTreeNodeForField(field: FlexTreeField): TreeNode | TreeValue
 	}
 }
 
-export function getOrCreateNodeFromFlexTreeNode(flexNode: FlexTreeNode): TreeNode | TreeValue {
-	const cachedProxy = tryGetCachedTreeNode(flexNode);
-	if (cachedProxy !== undefined) {
-		return cachedProxy;
-	}
-
-	const classSchema = getSimpleNodeSchemaFromNode(flexNode);
-	const node = flexNode as unknown as InternalTreeNode;
-	// eslint-disable-next-line unicorn/prefer-ternary
-	if (typeof classSchema === "function") {
-		return new classSchema(node) as TreeNode;
-	} else {
-		return (classSchema as { create(data: FlexTreeNode): TreeValue }).create(flexNode);
-	}
-}
-
 // #region Content insertion and proxy binding
 
 /** The path of a proxy, relative to the root of the content tree that the proxy belongs to */
@@ -152,7 +134,7 @@ function walkMapTree(
 	path: UpPath,
 	onVisitTreeNode: (path: UpPath, treeNode: TreeNode) => void,
 ): void {
-	if (tryGetMapTreeNode(mapTree)?.parentField.parent.parent !== undefined) {
+	if (tryUnhydratedFlexTreeNode(mapTree)?.parentField.parent.parent !== undefined) {
 		throw new UsageError(
 			"Attempted to insert a node which is already under a parent. If this is desired, remove the node from its parent before inserting it elsewhere.",
 		);
@@ -162,9 +144,9 @@ function walkMapTree(
 	const nexts: Next[] = [];
 	for (let next: Next | undefined = [path, mapTree]; next !== undefined; next = nexts.pop()) {
 		const [p, m] = next;
-		const mapTreeNode = tryGetMapTreeNode(m);
+		const mapTreeNode = tryUnhydratedFlexTreeNode(m);
 		if (mapTreeNode !== undefined) {
-			const treeNode = tryGetCachedTreeNode(mapTreeNode);
+			const treeNode = tryGetTreeNodeFromMapNode(mapTreeNode);
 			if (treeNode !== undefined) {
 				onVisitTreeNode(p, treeNode);
 			}