@fluidframework/tree 2.2.0 → 2.3.0

package/src/simple-tree/mapNode.ts

@@ -6,18 +6,15 @@
 import {
 	type FlexMapNodeSchema,
 	type FlexTreeNode,
+	type FlexTreeOptionalField,
 	type MapTreeNode,
+	type OptionalFieldEditBuilder,
+	UnhydratedContext,
 	getOrCreateMapTreeNode,
 	getSchemaAndPolicy,
 } from "../feature-libraries/index.js";
-import {
-	type FactoryContent,
-	type InsertableContent,
-	getTreeNodeForField,
-	prepareContentForHydration,
-} from "./proxies.js";
+import { getTreeNodeForField, prepareContentForHydration } from "./proxies.js";
 import { getOrCreateInnerNode } from "./proxyBinding.js";
-import { getSimpleNodeSchema } from "./core/index.js";
 import {
 	createFieldSchema,
 	FieldKind,
@@ -26,6 +23,8 @@ import {
 	type TreeNodeFromImplicitAllowedTypes,
 } from "./schemaTypes.js";
 import {
+	getKernel,
+	type InnerNode,
 	NodeKind,
 	type TreeNodeSchemaClass,
 	type TreeNodeSchema,
@@ -35,10 +34,15 @@ import {
 	type TreeNode,
 	typeSchemaSymbol,
 } from "./core/index.js";
-import { mapTreeFromNodeData } from "./toMapTree.js";
-import { getFlexSchema } from "./toFlexSchema.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 { TreeNodeValid, type MostDerivedData } from "./treeNodeValid.js";
+import type { ExclusiveMapTree } from "../core/index.js";
 
 /**
  * A map of string keys to tree objects.
@@ -138,12 +142,22 @@ abstract class CustomMapNodeBase<const T extends ImplicitAllowedTypes> extends T
 	public [Symbol.iterator](): IterableIterator<[string, TreeNodeFromImplicitAllowedTypes<T>]> {
 		return this.entries();
 	}
+
+	private get innerNode(): InnerNode {
+		return getOrCreateInnerNode(this);
+	}
+
+	private editor(key: string): OptionalFieldEditBuilder<ExclusiveMapTree> {
+		const field = this.innerNode.getBoxed(brand(key)) as FlexTreeOptionalField;
+		return field.editor;
+	}
+
 	public delete(key: string): void {
-		const field = getOrCreateInnerNode(this).getBoxed(key);
-		field.editor.set(undefined, field.length === 0);
+		const field = this.innerNode.getBoxed(brand(key));
+		this.editor(key).set(undefined, field.length === 0);
 	}
 	public *entries(): IterableIterator<[string, TreeNodeFromImplicitAllowedTypes<T>]> {
-		const node = getOrCreateInnerNode(this);
+		const node = this.innerNode;
 		for (const key of node.keys()) {
 			yield [
 				key,
@@ -152,37 +166,37 @@ abstract class CustomMapNodeBase<const T extends ImplicitAllowedTypes> extends T
 		}
 	}
 	public get(key: string): TreeNodeFromImplicitAllowedTypes<T> {
-		const node = getOrCreateInnerNode(this);
-		const field = node.getBoxed(key);
+		const node = this.innerNode;
+		const field = node.getBoxed(brand(key));
 		return getTreeNodeForField(field) as TreeNodeFromImplicitAllowedTypes<T>;
 	}
 	public has(key: string): boolean {
-		return getOrCreateInnerNode(this).tryGetField(brand(key)) !== undefined;
+		return this.innerNode.tryGetField(brand(key)) !== undefined;
 	}
 	public keys(): IterableIterator<string> {
-		const node = getOrCreateInnerNode(this);
+		const node = this.innerNode;
 		return node.keys();
 	}
 	public set(key: string, value: InsertableTreeNodeFromImplicitAllowedTypes<T>): TreeMapNode {
-		const node = getOrCreateInnerNode(this);
-		const classSchema = getSimpleNodeSchema(node.schema);
+		const kernel = getKernel(this);
+		const node = this.innerNode;
 		const mapTree = mapTreeFromNodeData(
 			value as InsertableContent | undefined,
-			createFieldSchema(FieldKind.Optional, classSchema.info as ImplicitAllowedTypes),
-			node.context?.nodeKeyManager,
+			createFieldSchema(FieldKind.Optional, kernel.schema.info as ImplicitAllowedTypes),
+			node.context.isHydrated() ? node.context.nodeKeyManager : undefined,
 			getSchemaAndPolicy(node),
 		);
 
-		const field = node.getBoxed(key);
-		if (node.context !== undefined) {
+		const field = node.getBoxed(brand(key));
+		if (node.context.isHydrated()) {
 			prepareContentForHydration(mapTree, node.context.checkout.forest);
 		}
 
-		field.editor.set(mapTree, field.length === 0);
+		this.editor(key).set(mapTree, field.length === 0);
 		return this;
 	}
 	public get size(): number {
-		return count(getOrCreateInnerNode(this).keys());
+		return count(this.innerNode.keys());
 	}
 	public *values(): IterableIterator<TreeNodeFromImplicitAllowedTypes<T>> {
 		for (const [, value] of this.entries()) {
@@ -220,15 +234,16 @@ export function mapSchema<
 	useMapPrototype: boolean,
 ) {
 	let flexSchema: FlexMapNodeSchema;
+	let unhydratedContext: UnhydratedContext;
 
-	class schema extends CustomMapNodeBase<T> implements TreeMapNode<T> {
+	class Schema extends CustomMapNodeBase<T> implements TreeMapNode<T> {
 		public static override prepareInstance<T2>(
 			this: typeof TreeNodeValid<T2>,
 			instance: TreeNodeValid<T2>,
 			flexNode: FlexTreeNode,
 		): TreeNodeValid<T2> {
 			if (useMapPrototype) {
-				return new Proxy<schema>(instance as schema, handler);
+				return new Proxy<Schema>(instance as Schema, handler);
 			}
 			return instance;
 		}
@@ -239,6 +254,7 @@ export function mapSchema<
 			input: T2,
 		): MapTreeNode {
 			return getOrCreateMapTreeNode(
+				unhydratedContext,
 				flexSchema,
 				mapTreeFromNodeData(input as FactoryContent, this as unknown as ImplicitAllowedTypes),
 			);
@@ -247,7 +263,9 @@ export function mapSchema<
 		protected static override constructorCached: MostDerivedData | undefined = undefined;
 
 		protected static override oneTimeSetup<T2>(this: typeof TreeNodeValid<T2>): void {
-			flexSchema = getFlexSchema(this as unknown as TreeNodeSchema) as FlexMapNodeSchema;
+			const schema = this as unknown as TreeNodeSchema;
+			flexSchema = getFlexSchema(schema) as FlexMapNodeSchema;
+			unhydratedContext = new UnhydratedContext(toFlexSchema(schema));
 		}
 
 		public static readonly identifier = identifier;
@@ -260,7 +278,7 @@ export function mapSchema<
 			return identifier;
 		}
 		public get [typeSchemaSymbol](): typeof schemaErased {
-			return schema.constructorCached?.constructor as unknown as typeof schemaErased;
+			return Schema.constructorCached?.constructor as unknown as typeof schemaErased;
 		}
 	}
 	const schemaErased: TreeNodeSchemaClass<
@@ -270,7 +288,7 @@ export function mapSchema<
 		MapNodeInsertableData<T>,
 		ImplicitlyConstructable,
 		T
-	> = schema;
+	> = Schema;
 	return schemaErased;
 }
 

package/src/simple-tree/objectNode.ts

@@ -9,7 +9,6 @@ import { UsageError } from "@fluidframework/telemetry-utils/internal";
 import type { FieldKey } from "../core/index.js";
 import {
 	FieldKinds,
-	type FlexAllowedTypes,
 	type FlexObjectNodeSchema,
 	type FlexTreeField,
 	type FlexTreeNode,
@@ -19,12 +18,9 @@ import {
 	getSchemaAndPolicy,
 	isMapTreeNode,
 	type MapTreeNode,
+	UnhydratedContext,
 } from "../feature-libraries/index.js";
-import {
-	type InsertableContent,
-	getTreeNodeForField,
-	prepareContentForHydration,
-} from "./proxies.js";
+import { getTreeNodeForField, prepareContentForHydration } from "./proxies.js";
 import { getOrCreateInnerNode } from "./proxyBinding.js";
 import {
 	type ImplicitFieldSchema,
@@ -47,15 +43,15 @@ import {
 	type InternalTreeNode,
 	type TreeNode,
 } from "./core/index.js";
-import { mapTreeFromNodeData } from "./toMapTree.js";
+import { mapTreeFromNodeData, type InsertableContent } from "./toMapTree.js";
 import { type RestrictiveReadonlyRecord, fail, type FlattenKeys } from "../util/index.js";
-import { getFlexSchema } from "./toFlexSchema.js";
+import { getFlexSchema, toFlexSchema } from "./toFlexSchema.js";
 import type { ObjectNodeSchema, ObjectNodeSchemaInternalData } from "./objectNodeTypes.js";
 import { TreeNodeValid, type MostDerivedData } from "./treeNodeValid.js";
 
 /**
  * Helper used to produce types for object nodes.
- * @public
+ * @system @public
  */
 export type ObjectFromSchemaRecord<
 	T extends RestrictiveReadonlyRecord<string, ImplicitFieldSchema>,
@@ -77,7 +73,7 @@ export type ObjectFromSchemaRecord<
 export type TreeObjectNode<
 	T extends RestrictiveReadonlyRecord<string, ImplicitFieldSchema>,
 	TypeName extends string = string,
-> = TreeNode & ObjectFromSchemaRecord<T> & WithType<TypeName, NodeKind.Object>;
+> = TreeNode & ObjectFromSchemaRecord<T> & WithType<TypeName, NodeKind.Object, T>;
 
 /**
  * Type utility for determining whether or not an implicit field schema has a default value.
@@ -86,7 +82,7 @@ export type TreeObjectNode<
  * TODO: Account for field schemas with default value providers.
  * For now, this only captures field kinds that we know always have defaults - optional fields and identifier fields.
  *
- * @public
+ * @system @public
  */
 export type FieldHasDefault<T extends ImplicitFieldSchema> = T extends FieldSchema<
 	FieldKind.Optional | FieldKind.Identifier
@@ -98,6 +94,8 @@ export type FieldHasDefault<T extends ImplicitFieldSchema> = T extends FieldSche
  * Helper used to produce types for:
  *
  * 1. Insertable content which can be used to construct an object node.
+ * In this case, only own properties are considered.
+ * This reduces the risk of incorrectly interpreting data at the cost of occasionally requiring users to convert data into a compatible format.
  *
  * 2. Insertable content which is an unhydrated object node.
  *
@@ -105,7 +103,7 @@ export type FieldHasDefault<T extends ImplicitFieldSchema> = T extends FieldSche
  *
  * @privateRemarks TODO: consider separating these cases into different types.
  *
- * @public
+ * @system @public
  */
 export type InsertableObjectFromSchemaRecord<
 	T extends RestrictiveReadonlyRecord<string, ImplicitFieldSchema>,
@@ -121,10 +119,10 @@ export type InsertableObjectFromSchemaRecord<
 >;
 
 /**
- * Maps from simple field keys ("view" keys) to information about the field.
+ * Maps from simple field keys ("property" keys) to information about the field.
  *
  * @remarks
- * A missing entry for a given view key indicates that no such field exists.
+ * A missing entry for a given property key indicates that no such field exists.
  * Keys with symbols are currently never used, but allowed to make lookups on non-field things
  * (returning undefined) easier.
  */
@@ -134,13 +132,13 @@ export type SimpleKeyMap = ReadonlyMap<
 >;
 
 /**
- * Caches the mappings from view keys to stored keys for the provided object field schemas in {@link simpleKeyToFlexKeyCache}.
+ * Caches the mappings from property keys to stored keys for the provided object field schemas in {@link simpleKeyToFlexKeyCache}.
  */
 function createFlexKeyMapping(fields: Record<string, ImplicitFieldSchema>): SimpleKeyMap {
 	const keyMap: Map<string | symbol, { storedKey: FieldKey; schema: FieldSchema }> = new Map();
-	for (const [viewKey, fieldSchema] of Object.entries(fields)) {
-		const storedKey = getStoredKey(viewKey, fieldSchema);
-		keyMap.set(viewKey, { storedKey, schema: normalizeFieldSchema(fieldSchema) });
+	for (const [propertyKey, fieldSchema] of Object.entries(fields)) {
+		const storedKey = getStoredKey(propertyKey, fieldSchema);
+		keyMap.set(propertyKey, { storedKey, schema: normalizeFieldSchema(fieldSchema) });
 	}
 
 	return keyMap;
@@ -167,8 +165,8 @@ function createProxyHandler(
 	// TODO: Although the target is an object literal, it's still worthwhile to try experimenting with
 	// a dispatch object to see if it improves performance.
 	const handler: ProxyHandler<TreeNode> = {
-		get(target, viewKey, proxy): unknown {
-			const fieldInfo = flexKeyMap.get(viewKey);
+		get(target, propertyKey, proxy): unknown {
+			const fieldInfo = flexKeyMap.get(propertyKey);
 
 			if (fieldInfo !== undefined) {
 				const flexNode = getOrCreateInnerNode(proxy);
@@ -177,6 +175,7 @@ function createProxyHandler(
 					return getTreeNodeForField(field);
 				}
 
+				// TODO: this special case logic should move to the inner node (who's schema claims it has an identifier), rather than here, after we already read undefined out of a required field.
 				// 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.
@@ -190,13 +189,15 @@ function createProxyHandler(
 			}
 
 			// Pass the proxy as the receiver here, so that any methods on the prototype receive `proxy` as `this`.
-			return Reflect.get(target, viewKey, proxy);
+			return Reflect.get(target, propertyKey, proxy);
 		},
-		set(target, viewKey, value: InsertableContent | undefined, proxy) {
-			const fieldInfo = flexKeyMap.get(viewKey);
+		set(target, propertyKey, value: InsertableContent | undefined, proxy) {
+			const fieldInfo = 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 ? Reflect.set(target, viewKey, value, proxy) : false;
+				return allowAdditionalProperties
+					? Reflect.set(target, propertyKey, value, proxy)
+					: false;
 			}
 
 			setField(
@@ -206,16 +207,16 @@ function createProxyHandler(
 			);
 			return true;
 		},
-		deleteProperty(target, viewKey): boolean {
+		deleteProperty(target, propertyKey): boolean {
 			// TODO: supporting delete when it makes sense (custom local fields, and optional field) could be added as a feature in the future.
 			throw new UsageError(
 				`Object nodes do not support the delete operator. Optional fields can be assigned to undefined instead.`,
 			);
 		},
-		has: (target, viewKey) => {
+		has: (target, propertyKey) => {
 			return (
-				flexKeyMap.has(viewKey) ||
-				(allowAdditionalProperties ? Reflect.has(target, viewKey) : false)
+				flexKeyMap.has(propertyKey) ||
+				(allowAdditionalProperties ? Reflect.has(target, propertyKey) : false)
 			);
 		},
 		ownKeys: (target) => {
@@ -224,12 +225,12 @@ function createProxyHandler(
 				...(allowAdditionalProperties ? Reflect.ownKeys(target) : []),
 			];
 		},
-		getOwnPropertyDescriptor: (target, viewKey) => {
-			const fieldInfo = flexKeyMap.get(viewKey);
+		getOwnPropertyDescriptor: (target, propertyKey) => {
+			const fieldInfo = flexKeyMap.get(propertyKey);
 
 			if (fieldInfo === undefined) {
 				return allowAdditionalProperties
-					? Reflect.getOwnPropertyDescriptor(target, viewKey)
+					? Reflect.getOwnPropertyDescriptor(target, propertyKey)
 					: undefined;
 			}
 
@@ -263,23 +264,23 @@ export function setField(
 	const mapTree = mapTreeFromNodeData(
 		value,
 		simpleFieldSchema,
-		field.context?.nodeKeyManager,
+		field.context.isHydrated() ? field.context.nodeKeyManager : undefined,
 		getSchemaAndPolicy(field),
 	);
 
-	if (field.context !== undefined) {
+	if (field.context.isHydrated()) {
 		prepareContentForHydration(mapTree, field.context.checkout.forest);
 	}
 
 	switch (field.schema.kind) {
-		case FieldKinds.required: {
+		case FieldKinds.required.identifier: {
 			assert(mapTree !== undefined, 0xa04 /* Cannot set a required field to undefined */);
-			const typedField = field as FlexTreeRequiredField<FlexAllowedTypes>;
+			const typedField = field as FlexTreeRequiredField;
 			typedField.editor.set(mapTree);
 			break;
 		}
-		case FieldKinds.optional: {
-			const typedField = field as FlexTreeOptionalField<FlexAllowedTypes>;
+		case FieldKinds.optional.identifier: {
+			const typedField = field as FlexTreeOptionalField;
 			typedField.editor.set(mapTree, typedField.length === 0);
 			break;
 		}
@@ -310,16 +311,17 @@ export function objectSchema<
 	info: T,
 	implicitlyConstructable: ImplicitlyConstructable,
 ): ObjectNodeSchema<TName, T, ImplicitlyConstructable> & ObjectNodeSchemaInternalData {
-	// Ensure no collisions between final set of view keys, and final set of stored keys (including those
-	// implicitly derived from view keys)
+	// Ensure no collisions between final set of property keys, and final set of stored keys (including those
+	// implicitly derived from property keys)
 	assertUniqueKeys(identifier, info);
 
-	// Performance optimization: cache view key => stored key and schema.
+	// Performance optimization: cache property key => stored key and schema.
 	const flexKeyMap: SimpleKeyMap = createFlexKeyMapping(info);
 
 	let handler: ProxyHandler<object>;
 	let customizable: boolean;
 	let flexSchema: FlexObjectNodeSchema;
+	let unhydratedContext: UnhydratedContext;
 
 	class CustomObjectNode extends CustomObjectNodeBase<T> {
 		public static readonly fields: ReadonlyMap<string, FieldSchema> = new Map(
@@ -372,6 +374,7 @@ export function objectSchema<
 			input: T2,
 		): MapTreeNode {
 			return getOrCreateMapTreeNode(
+				unhydratedContext,
 				flexSchema,
 				mapTreeFromNodeData(input as object, this as unknown as ImplicitAllowedTypes),
 			);
@@ -383,7 +386,9 @@ export function objectSchema<
 			// 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);
-			flexSchema = getFlexSchema(this as unknown as TreeNodeSchema) as FlexObjectNodeSchema;
+			const schema = this as unknown as TreeNodeSchema;
+			flexSchema = getFlexSchema(schema) as FlexObjectNodeSchema;
+			unhydratedContext = new UnhydratedContext(toFlexSchema(schema));
 
 			// First run, do extra validation.
 			// TODO: provide a way for TreeConfiguration to trigger this same validation to ensure it gets run early.
@@ -434,8 +439,8 @@ export function objectSchema<
 const targetToProxy: WeakMap<object, TreeNode> = new WeakMap();
 
 /**
- * Ensures that the set of view keys in the schema is unique.
- * Also ensure that the final set of stored keys (including those implicitly derived from view keys) is unique.
+ * Ensures that the set of property keys in the schema is unique.
+ * Also ensure that the final set of stored keys (including those implicitly derived from property keys) is unique.
  * @throws Throws a `UsageError` if either of the key uniqueness invariants is violated.
  */
 function assertUniqueKeys<
@@ -458,10 +463,10 @@ function assertUniqueKeys<
 	}
 
 	// Verify that there are no duplicates among the derived
-	// (including those implicitly derived from view keys) stored keys.
+	// (including those implicitly derived from property keys) stored keys.
 	const derivedStoredKeys = new Set<string>();
-	for (const [viewKey, schema] of Object.entries(fields)) {
-		const storedKey = getStoredKey(viewKey, schema);
+	for (const [propertyKey, schema] of Object.entries(fields)) {
+		const storedKey = getStoredKey(propertyKey, schema);
 		if (derivedStoredKeys.has(storedKey)) {
 			throw new UsageError(
 				`Stored key "${storedKey}" in schema "${schemaName}" conflicts with a property key of the same name, which is not overridden by a stored key. The final set of stored keys in an object schema must be unique.`,

package/src/simple-tree/proxies.ts

@@ -3,9 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import type { IFluidHandle } from "@fluidframework/core-interfaces";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
-import { assert } from "@fluidframework/core-utils/internal";
 
 import {
 	EmptyKey,
@@ -17,26 +15,28 @@ import {
 
 import {
 	FieldKinds,
-	type FlexFieldSchema,
 	type FlexTreeField,
 	type FlexTreeNode,
-	type FlexTreeTypedField,
 	tryGetMapTreeNode,
 	isFlexTreeNode,
+	type FlexTreeRequiredField,
+	type FlexTreeOptionalField,
 } from "../feature-libraries/index.js";
 import { type Mutable, fail, isReadonlyArray } from "../util/index.js";
-
-import { anchorProxy, tryGetCachedTreeNode } from "./proxyBinding.js";
-import { tryGetSimpleNodeSchema, type TreeNode, type Unhydrated } from "./core/index.js";
+import {
+	getKernel,
+	tryGetCachedTreeNode,
+	type TreeNode,
+	getSimpleNodeSchemaFromNode,
+	type InternalTreeNode,
+} from "./core/index.js";
 
 /**
  * Retrieve the associated {@link TreeNode} for the given field's content.
  */
 export function getTreeNodeForField(field: FlexTreeField): TreeNode | TreeValue | undefined {
 	function tryToUnboxLeaves(
-		flexField: FlexTreeTypedField<
-			FlexFieldSchema<typeof FieldKinds.required | typeof FieldKinds.optional>
-		>,
+		flexField: FlexTreeOptionalField | FlexTreeRequiredField,
 	): TreeNode | TreeValue | undefined {
 		const maybeContent = flexField.content;
 		return isFlexTreeNode(maybeContent)
@@ -44,22 +44,17 @@ export function getTreeNodeForField(field: FlexTreeField): TreeNode | TreeValue
 			: maybeContent;
 	}
 	switch (field.schema.kind) {
-		case FieldKinds.required: {
-			const typedField = field as FlexTreeTypedField<
-				FlexFieldSchema<typeof FieldKinds.required>
-			>;
+		case FieldKinds.required.identifier: {
+			const typedField = field as FlexTreeRequiredField;
 			return tryToUnboxLeaves(typedField);
 		}
-		case FieldKinds.optional: {
-			const typedField = field as FlexTreeTypedField<
-				FlexFieldSchema<typeof FieldKinds.optional>
-			>;
+		case FieldKinds.optional.identifier: {
+			const typedField = field as FlexTreeOptionalField;
 			return tryToUnboxLeaves(typedField);
 		}
-		case FieldKinds.identifier: {
+		case FieldKinds.identifier.identifier: {
 			// Identifier fields are just value fields that hold strings
-			return (field as FlexTreeTypedField<FlexFieldSchema<typeof FieldKinds.required>>)
-				.content as string;
+			return (field as FlexTreeRequiredField).content as string;
 		}
 
 		default:
@@ -73,14 +68,13 @@ export function getOrCreateNodeFromFlexTreeNode(flexNode: FlexTreeNode): TreeNod
 		return cachedProxy;
 	}
 
-	const schema = flexNode.schema;
-	const classSchema = tryGetSimpleNodeSchema(schema);
-	assert(classSchema !== undefined, 0x91b /* node without schema */);
+	const classSchema = getSimpleNodeSchemaFromNode(flexNode);
+	const node = flexNode as unknown as InternalTreeNode;
+	// eslint-disable-next-line unicorn/prefer-ternary
 	if (typeof classSchema === "function") {
-		const simpleSchema = classSchema as unknown as new (dummy: FlexTreeNode) => TreeNode;
-		return new simpleSchema(flexNode);
+		return new classSchema(node) as TreeNode;
 	} else {
-		return (classSchema as { create(data: FlexTreeNode): TreeNode }).create(flexNode);
+		return (classSchema as { create(data: FlexTreeNode): TreeValue }).create(flexNode);
 	}
 }
 
@@ -203,7 +197,7 @@ function bindProxies(proxies: RootedProxyPaths[], forest: IForestSubscription):
 			// Non null asserting here because of the length check above
 			// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 			for (const { path, proxy } of proxies[i]!.proxyPaths) {
-				anchorProxy(forest.anchors, path, proxy);
+				getKernel(proxy).anchorProxy(forest.anchors, path);
 			}
 			if (++i === proxies.length) {
 				off();
@@ -213,26 +207,3 @@ function bindProxies(proxies: RootedProxyPaths[], forest: IForestSubscription):
 }
 
 // #endregion Content insertion and proxy binding
-
-/**
- * Content which can be used to build a node.
- * @remarks
- * Can contain unhydrated nodes, but can not be an unhydrated node at the root.
- */
-export type FactoryContent =
-	| IFluidHandle
-	| string
-	| number
-	| boolean
-	// eslint-disable-next-line @rushstack/no-new-null
-	| null
-	| Iterable<readonly [string, InsertableContent]>
-	| readonly InsertableContent[]
-	| {
-			readonly [P in string]?: InsertableContent;
-	  };
-
-/**
- * Content which can be inserted into a tree.
- */
-export type InsertableContent = Unhydrated<TreeNode> | FactoryContent;