@fluidframework/tree 2.30.0 → 2.31.0

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

@@ -4,226 +4,121 @@
  */
 
 import { assert, unreachableCase } from "@fluidframework/core-utils/internal";
-import {
-	normalizeFieldSchema,
-	type FieldSchema,
-	type ImplicitAllowedTypes,
-	type ImplicitFieldSchema,
-} from "../schemaTypes.js";
+import { normalizeFieldSchema, type ImplicitFieldSchema } from "../schemaTypes.js";
 import type {
 	SimpleArrayNodeSchema,
-	SimpleFieldSchema,
 	SimpleLeafNodeSchema,
 	SimpleMapNodeSchema,
 	SimpleNodeSchema,
+	SimpleObjectFieldSchema,
 	SimpleObjectNodeSchema,
 	SimpleTreeSchema,
-} from "./simpleSchema.js";
-import type { ValueSchema } from "../../core/index.js";
-import { copyProperty, getOrCreate, type Mutable } from "../../util/index.js";
-import { isObjectNodeSchema, type ObjectNodeSchema } from "../objectNodeTypes.js";
-import { NodeKind, type TreeNodeSchema } from "../core/index.js";
+} from "../simpleSchema.js";
+import { ObjectNodeSchema } from "../objectNodeTypes.js";
+import { NodeKind } from "../core/index.js";
+import { walkFieldSchema } from "../walkFieldSchema.js";
+import { ArrayNodeSchema } from "../arrayNodeTypes.js";
+import { LeafNodeSchema } from "../leafNodeSchema.js";
+import { MapNodeSchema } from "../mapNodeTypes.js";
 
 /**
- * Converts a "view" schema to a "simple" schema representation.
+ * Converts an {@link ImplicitFieldSchema} to a "simple" schema representation.
+ *
+ * @param schema - The schema to convert
+ * @param copySchemaObjects - If true, TreeNodeSchema and FieldSchema are copied into plain JavaScript objects. Either way, custom metadata is referenced and not copied.
+ *
+ * @remarks
+ * Given that the Schema types used in {@link ImplicitFieldSchema} already implement the {@link SimpleNodeSchema} interfaces, there are limited use-cases for this function.
+ * One possible use-case is converting schema to a more serialization friendly format.
+ * This format however is not JSON compatible due to use of Maps and Sets,
+ * but it it does not rely on cyclic object references for handling recursive schema and instead uses the `definitions` map.
+ *
+ * @privateRemarks
+ * TODO: once SimpleTreeSchema is stable, {@link TreeViewConfiguration} could implement {@link SimpleTreeSchema} directly.
+ * That would provide the non-copying alternative that could expose the value type of the definitions map as {@link TreeNodeSchema}.
  */
-export function toSimpleTreeSchema(schema: ImplicitFieldSchema): SimpleTreeSchema {
+export function toSimpleTreeSchema(
+	schema: ImplicitFieldSchema,
+	copySchemaObjects: boolean,
+): SimpleTreeSchema {
 	const normalizedSchema = normalizeFieldSchema(schema);
-
-	const allowedTypes = allowedTypesFromFieldSchema(normalizedSchema);
-
 	const definitions = new Map<string, SimpleNodeSchema>();
-	populateSchemaDefinitionsForField(normalizedSchema, definitions);
+	walkFieldSchema(normalizedSchema, {
+		node: (nodeSchema) => {
+			// The set of node kinds is extensible, but the typing of SimpleNodeSchema is not, so we need to check that the schema is one of the known kinds.
+			assert(
+				nodeSchema instanceof ArrayNodeSchema ||
+					nodeSchema instanceof MapNodeSchema ||
+					nodeSchema instanceof LeafNodeSchema ||
+					nodeSchema instanceof ObjectNodeSchema,
+				0xb60 /* Invalid schema */,
+			);
+			const outSchema = copySchemaObjects ? copySimpleNodeSchema(nodeSchema) : nodeSchema;
+			definitions.set(nodeSchema.identifier, outSchema);
+		},
+	});
 
-	const output: Mutable<SimpleTreeSchema> = {
+	return {
 		kind: normalizedSchema.kind,
-		allowedTypes,
+		allowedTypesIdentifiers: normalizedSchema.allowedTypesIdentifiers,
 		definitions,
+		metadata: normalizedSchema.metadata,
 	};
-
-	copyProperty(normalizedSchema, "metadata", output);
-	return output;
 }
 
 /**
- * Cache in which the results of {@link toSimpleNodeSchema} are saved.
- */
-const simpleNodeSchemaCache = new WeakMap<TreeNodeSchema, SimpleNodeSchema>();
-
-/**
- * Creates a {@link SimpleNodeSchema} from a {@link TreeNodeSchema}.
+ * Copies a {@link SimpleNodeSchema} into a new plain JavaScript object.
  *
  * @remarks Caches the result on the input schema for future calls.
  */
-function toSimpleNodeSchema(schema: TreeNodeSchema): SimpleNodeSchema {
-	return getOrCreate(simpleNodeSchemaCache, schema, () => {
-		const kind = schema.kind;
-		switch (kind) {
-			case NodeKind.Leaf: {
-				return leafSchemaToSimpleSchema(schema);
-			}
-			case NodeKind.Map: {
-				return mapSchemaToSimpleSchema(schema);
-			}
-			case NodeKind.Array: {
-				return arraySchemaToSimpleSchema(schema);
-			}
-			case NodeKind.Object: {
-				assert(isObjectNodeSchema(schema), 0xa06 /* Expected object schema */);
-				return objectSchemaToSimpleSchema(schema);
-			}
-			default: {
-				unreachableCase(kind);
-			}
-		}
-	});
+function copySimpleNodeSchema(schema: SimpleNodeSchema): SimpleNodeSchema {
+	const kind = schema.kind;
+	switch (kind) {
+		case NodeKind.Leaf:
+			return copySimpleLeafSchema(schema);
+		case NodeKind.Array:
+		case NodeKind.Map:
+			return copySimpleMapOrArraySchema(schema);
+		case NodeKind.Object:
+			return copySimpleObjectSchema(schema);
+		default:
+			unreachableCase(kind);
+	}
 }
 
-// TODO: Use a stronger type for leaf schemas once one is available (see object schema handler for an example).
-function leafSchemaToSimpleSchema(schema: TreeNodeSchema): SimpleLeafNodeSchema {
+function copySimpleLeafSchema(schema: SimpleLeafNodeSchema): SimpleLeafNodeSchema {
 	return {
 		kind: NodeKind.Leaf,
-		leafKind: schema.info as ValueSchema,
+		leafKind: schema.leafKind,
+		metadata: schema.metadata,
 	};
 }
 
-// TODO: Use a stronger type for array schemas once one is available (see object schema handler for an example).
-function arraySchemaToSimpleSchema(schema: TreeNodeSchema): SimpleArrayNodeSchema {
-	const fieldSchema = normalizeFieldSchema(schema.info as ImplicitAllowedTypes);
-	const allowedTypes = allowedTypesFromFieldSchema(fieldSchema);
-	const output: Mutable<SimpleArrayNodeSchema> = {
-		kind: NodeKind.Array,
-		allowedTypes,
+function copySimpleMapOrArraySchema(
+	schema: SimpleMapNodeSchema | SimpleArrayNodeSchema,
+): SimpleMapNodeSchema | SimpleArrayNodeSchema {
+	return {
+		kind: schema.kind,
+		allowedTypesIdentifiers: schema.allowedTypesIdentifiers,
+		metadata: schema.metadata,
 	};
-
-	copyProperty(schema, "metadata", output);
-
-	return output;
 }
 
-// TODO: Use a stronger type for map schemas once one is available (see object schema handler for an example).
-function mapSchemaToSimpleSchema(schema: TreeNodeSchema): SimpleMapNodeSchema {
-	const fieldSchema = normalizeFieldSchema(schema.info as ImplicitAllowedTypes);
-	const allowedTypes = allowedTypesFromFieldSchema(fieldSchema);
-	const output: Mutable<SimpleMapNodeSchema> = {
-		kind: NodeKind.Map,
-		allowedTypes,
-	};
-
-	copyProperty(schema, "metadata", output);
-
-	return output;
-}
-
-function objectSchemaToSimpleSchema(schema: ObjectNodeSchema): SimpleObjectNodeSchema {
-	const fields: Record<string, SimpleFieldSchema> = {};
-	for (const [key, field] of schema.fields) {
-		fields[key] = fieldSchemaToSimpleSchema(field);
+function copySimpleObjectSchema(schema: SimpleObjectNodeSchema): SimpleObjectNodeSchema {
+	const fields: Map<string, SimpleObjectFieldSchema> = new Map();
+	for (const [propertyKey, field] of schema.fields) {
+		// field already is a SimpleObjectFieldSchema, but copy the subset of the properties needed by this interface to get a clean simple object.
+		fields.set(propertyKey, {
+			kind: field.kind,
+			allowedTypesIdentifiers: field.allowedTypesIdentifiers,
+			metadata: field.metadata,
+			storedKey: field.storedKey,
+		});
 	}
 
-	const output: Mutable<SimpleObjectNodeSchema> = {
+	return {
 		kind: NodeKind.Object,
 		fields,
+		metadata: schema.metadata,
 	};
-
-	copyProperty(schema, "metadata", output);
-
-	return output;
-}
-
-/**
- * Private symbol under which the results of {@link toSimpleNodeSchema} are cached on an input {@link TreeNodeSchema}.
- */
-const simpleFieldSchemaCacheSymbol = Symbol("simpleFieldSchemaCache");
-
-function fieldSchemaToSimpleSchema(schema: FieldSchema): SimpleFieldSchema {
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	if ((schema as any)[simpleFieldSchemaCacheSymbol] !== undefined) {
-		// eslint-disable-next-line @typescript-eslint/no-explicit-any
-		return (schema as any)[simpleFieldSchemaCacheSymbol] as SimpleFieldSchema;
-	}
-
-	const allowedTypes = allowedTypesFromFieldSchema(schema);
-	const result: Mutable<SimpleFieldSchema> = {
-		kind: schema.kind,
-		allowedTypes,
-	};
-
-	copyProperty(schema, "metadata", result);
-
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	(schema as any)[simpleFieldSchemaCacheSymbol] = result;
-
-	return result;
-}
-
-function allowedTypesFromFieldSchema(schema: FieldSchema): Set<string> {
-	const allowedTypes = new Set<string>();
-	for (const type of schema.allowedTypeSet) {
-		allowedTypes.add(type.identifier);
-	}
-	return allowedTypes;
-}
-
-/**
- * Recursively populates `definitions` by walking the input field schema tree.
- */
-function populateSchemaDefinitionsForField(
-	schema: FieldSchema,
-	definitions: Map<string, SimpleNodeSchema>,
-): void {
-	for (const child of schema.allowedTypeSet) {
-		populateSchemaDefinitionsForNode(child, definitions);
-	}
-}
-
-/**
- * Recursively populates `definitions` by walking the input node schema tree.
- */
-function populateSchemaDefinitionsForNode(
-	schema: TreeNodeSchema,
-	definitions: Map<string, SimpleNodeSchema>,
-): void {
-	if (definitions.has(schema.identifier)) {
-		// If the definition has already been populated, no need to recurse.
-		return;
-	}
-
-	// Populate definition for this schema
-	definitions.set(schema.identifier, toSimpleNodeSchema(schema));
-
-	// Recurse into children to populate definitions for them
-	const kind = schema.kind;
-	switch (kind) {
-		case NodeKind.Leaf: {
-			// Leaf node, so no need to recurse
-			break;
-		}
-		case NodeKind.Map: {
-			// TODO: Utilize a map schema type-guard once one exists (see object case for an example).
-
-			// Recursively populate definitions for allowed map children
-			const fieldSchema = normalizeFieldSchema(schema.info as ImplicitAllowedTypes);
-			populateSchemaDefinitionsForField(fieldSchema, definitions);
-			break;
-		}
-		case NodeKind.Array: {
-			// TODO: Utilize an array schema type-guard once one exists (see object case for an example).
-
-			// Recursively populate definitions for allowed map children
-			const fieldSchema = normalizeFieldSchema(schema.info as ImplicitAllowedTypes);
-			populateSchemaDefinitionsForField(fieldSchema, definitions);
-			break;
-		}
-		case NodeKind.Object: {
-			assert(isObjectNodeSchema(schema), 0xa07 /* Expected object schema */);
-			for (const [, field] of schema.fields) {
-				populateSchemaDefinitionsForField(field, definitions);
-			}
-			break;
-		}
-		default: {
-			unreachableCase(kind);
-		}
-	}
 }

package/src/simple-tree/arrayNode.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { Lazy, oob } from "@fluidframework/core-utils/internal";
+import { Lazy, oob, fail } from "@fluidframework/core-utils/internal";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 
 import { EmptyKey, type ExclusiveMapTree } from "../core/index.js";
@@ -33,13 +33,11 @@ import {
 	typeSchemaSymbol,
 	type Context,
 	getOrCreateNodeFromInnerNode,
-	type TreeNodeSchemaBoth,
 	getSimpleNodeSchemaFromInnerNode,
 	getOrCreateInnerNode,
 	type TreeNodeSchemaClass,
 } from "./core/index.js";
 import { type InsertableContent, mapTreeFromNodeData } from "./toMapTree.js";
-import { fail } from "../util/index.js";
 import {
 	getKernel,
 	UnhydratedFlexTreeNode,
@@ -47,7 +45,11 @@ import {
 } from "./core/index.js";
 import { TreeNodeValid, type MostDerivedData } from "./treeNodeValid.js";
 import { getUnhydratedContext } from "./createContext.js";
-import type { Unenforced } from "./api/index.js";
+import type { ImplicitAllowedTypesUnsafe } from "./api/index.js";
+import type {
+	ArrayNodeCustomizableSchema,
+	ArrayNodePojoEmulationSchema,
+} from "./arrayNodeTypes.js";
 
 /**
  * A covariant base type for {@link (TreeArrayNode:interface)}.
@@ -73,7 +75,7 @@ export interface ReadonlyArrayNode<out T = TreeNode | TreeLeafValue>
  * @sealed @public
  */
 export interface TreeArrayNode<
-	TAllowedTypes extends Unenforced<ImplicitAllowedTypes> = ImplicitAllowedTypes,
+	TAllowedTypes extends ImplicitAllowedTypesUnsafe = ImplicitAllowedTypes,
 	out T = [TAllowedTypes] extends [ImplicitAllowedTypes]
 		? TreeNodeFromImplicitAllowedTypes<TAllowedTypes>
 		: TreeNodeFromImplicitAllowedTypes<ImplicitAllowedTypes>,
@@ -668,6 +670,7 @@ export function asIndex(key: string | symbol, exclusiveMax: number): number | un
 }
 
 /**
+ * Create a proxy which implements the {@link TreeArrayNode} API.
  * @param allowAdditionalProperties - If true, setting of unexpected properties will be forwarded to the target object.
  * Otherwise setting of unexpected properties will error.
  * @param proxyTarget - Target object of the proxy. Must provide an own `length` value property
@@ -1071,18 +1074,18 @@ export function arraySchema<
 	customizable: boolean,
 	metadata?: NodeSchemaMetadata<TCustomMetadata>,
 ) {
-	type Output = TreeNodeSchemaBoth<
+	type Output = ArrayNodeCustomizableSchema<
 		TName,
-		NodeKind.Array,
-		TreeArrayNode<T> & WithType<TName, NodeKind.Array>,
-		Iterable<InsertableTreeNodeFromImplicitAllowedTypes<T>>,
-		ImplicitlyConstructable,
 		T,
-		undefined,
+		ImplicitlyConstructable,
 		TCustomMetadata
-	>;
+	> &
+		ArrayNodePojoEmulationSchema<TName, T, ImplicitlyConstructable, TCustomMetadata>;
 
 	const lazyChildTypes = new Lazy(() => normalizeAllowedTypes(info));
+	const lazyAllowedTypesIdentifiers = new Lazy(
+		() => new Set([...lazyChildTypes.value].map((type) => type.identifier)),
+	);
 
 	let unhydratedContext: Context;
 
@@ -1120,6 +1123,10 @@ export function arraySchema<
 			);
 		}
 
+		public static get allowedTypesIdentifiers(): ReadonlySet<string> {
+			return lazyAllowedTypesIdentifiers.value;
+		}
+
 		protected static override constructorCached: MostDerivedData | undefined = undefined;
 
 		protected static override oneTimeSetup<T2>(this: typeof TreeNodeValid<T2>): Context {
@@ -1161,8 +1168,7 @@ export function arraySchema<
 		public static get childTypes(): ReadonlySet<TreeNodeSchema> {
 			return lazyChildTypes.value;
 		}
-		public static readonly metadata: NodeSchemaMetadata<TCustomMetadata> | undefined =
-			metadata;
+		public static readonly metadata: NodeSchemaMetadata<TCustomMetadata> = metadata ?? {};
 
 		// eslint-disable-next-line import/no-deprecated
 		public get [typeNameSymbol](): TName {

package/src/simple-tree/arrayNodeTypes.ts

@@ -0,0 +1,93 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import type { TreeArrayNode } from "./arrayNode.js";
+import type {
+	ImplicitAllowedTypes,
+	InsertableTreeNodeFromImplicitAllowedTypes,
+} from "./schemaTypes.js";
+import {
+	NodeKind,
+	type TreeNodeSchemaClass,
+	type TreeNodeSchema,
+	type TreeNodeSchemaNonClass,
+	type WithType,
+} from "./core/index.js";
+
+import type { SimpleArrayNodeSchema } from "./simpleSchema.js";
+
+/**
+ * A schema for customizable {@link (TreeArrayNode:interface)}s.
+ * @system @sealed @alpha
+ */
+export interface ArrayNodeCustomizableSchema<
+	out TName extends string = string,
+	in out T extends ImplicitAllowedTypes = ImplicitAllowedTypes,
+	out ImplicitlyConstructable extends boolean = true,
+	out TCustomMetadata = unknown,
+> extends TreeNodeSchemaClass<
+			TName,
+			NodeKind.Array,
+			TreeArrayNode<T> & WithType<TName, NodeKind.Array, T>,
+			Iterable<InsertableTreeNodeFromImplicitAllowedTypes<T>>,
+			ImplicitlyConstructable,
+			T,
+			undefined,
+			TCustomMetadata
+		>,
+		SimpleArrayNodeSchema<TCustomMetadata> {}
+
+/**
+ * A schema for POJO emulation mode {@link (TreeArrayNode:interface)}s.
+ * @system @sealed @alpha
+ */
+export interface ArrayNodePojoEmulationSchema<
+	out TName extends string = string,
+	in out T extends ImplicitAllowedTypes = ImplicitAllowedTypes,
+	out ImplicitlyConstructable extends boolean = true,
+	out TCustomMetadata = unknown,
+> extends TreeNodeSchemaNonClass<
+			TName,
+			NodeKind.Array,
+			TreeArrayNode<T> & WithType<TName, NodeKind.Array, T>,
+			Iterable<InsertableTreeNodeFromImplicitAllowedTypes<T>>,
+			ImplicitlyConstructable,
+			T,
+			undefined,
+			TCustomMetadata
+		>,
+		SimpleArrayNodeSchema<TCustomMetadata> {}
+
+/**
+ * A schema for {@link (TreeArrayNode:interface)}s.
+ * @privateRemarks
+ * This could have generic arguments added and forwarded.
+ * The expected use-cases for this don't need them however, and if they did want an argument it would probably be the allowed types;
+ * perhaps if moving to an order independent way to pass generic arguments, adding support for them here would make sense.
+ * @alpha
+ */
+export type ArrayNodeSchema = ArrayNodeCustomizableSchema | ArrayNodePojoEmulationSchema;
+
+/**
+ * @alpha
+ */
+export const ArrayNodeSchema = {
+	/**
+	 * instanceof-based narrowing support for ArrayNodeSchema in Javascript and TypeScript 5.3 or newer.
+	 */
+	[Symbol.hasInstance](value: TreeNodeSchema): value is ArrayNodeSchema {
+		return isArrayNodeSchema(value);
+	},
+} as const;
+
+/**
+ * Narrows a {@link (TreeNodeSchema:interface)} to an {@link (ArrayNodeSchema:interface)}.
+ * @privateRemarks
+ * If at some point we want to have internal only APIs for ArrayNodeSchema (like done for objects),
+ * this can include those since its not the public facing API.
+ */
+export function isArrayNodeSchema(schema: TreeNodeSchema): schema is ArrayNodeSchema {
+	return schema.kind === NodeKind.Array;
+}

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

@@ -4,15 +4,13 @@
  */
 
 import type { TreeValue } from "../../core/index.js";
-import type { FlexTreeNode } from "../../feature-libraries/index.js";
-import { fail } from "../../util/index.js";
 import {
 	type InnerNode,
 	unhydratedFlexTreeNodeToTreeNode,
 	proxySlot,
+	createTreeNodeFromInner,
 } from "./treeNodeKernel.js";
-import { getSimpleNodeSchemaFromInnerNode } from "./schemaCaching.js";
-import type { TreeNode, InternalTreeNode } from "./types.js";
+import type { TreeNode } from "./types.js";
 import { UnhydratedFlexTreeNode } from "./unhydratedFlexTree.js";
 
 /**
@@ -31,13 +29,5 @@ export function getOrCreateNodeFromInnerNode(flexNode: InnerNode): TreeNode | Tr
 		return cached;
 	}
 
-	const classSchema =
-		getSimpleNodeSchemaFromInnerNode(flexNode) ?? fail(0xb3e /* Missing schema */);
-	const node = flexNode as unknown as InternalTreeNode;
-	// eslint-disable-next-line unicorn/prefer-ternary
-	if (typeof classSchema === "function") {
-		return new classSchema(node);
-	} else {
-		return (classSchema as { create(data: FlexTreeNode): TreeValue }).create(flexNode);
-	}
+	return createTreeNodeFromInner(flexNode);
 }

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

@@ -13,6 +13,7 @@ export {
 	unhydratedFlexTreeNodeToTreeNode,
 	getOrCreateInnerNode,
 	treeNodeFromAnchor,
+	getSimpleNodeSchemaFromInnerNode,
 } from "./treeNodeKernel.js";
 export { type WithType, typeNameSymbol, typeSchemaSymbol } from "./withType.js";
 export {
@@ -31,7 +32,6 @@ export {
 	type TreeNodeSchemaCore,
 	type TreeNodeSchemaBoth,
 } from "./treeNodeSchema.js";
-export { getSimpleNodeSchemaFromInnerNode } from "./schemaCaching.js";
 export { walkAllowedTypes, type SchemaVisitor } from "./walkSchema.js";
 export { Context, HydratedContext, SimpleContextSlot } from "./context.js";
 export { getOrCreateNodeFromInnerNode } from "./getOrCreateNode.js";

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

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { assert, Lazy } from "@fluidframework/core-utils/internal";
+import { assert, Lazy, fail } from "@fluidframework/core-utils/internal";
 import { createEmitter } from "@fluid-internal/client-utils";
 import type { Listenable, Off } from "@fluidframework/core-interfaces";
 import type { InternalTreeNode, TreeNode, Unhydrated } from "./types.js";
@@ -26,7 +26,6 @@ import {
 	type FlexTreeNode,
 } from "../../feature-libraries/index.js";
 import type { TreeNodeSchema } from "./treeNodeSchema.js";
-import { fail } from "../../util/index.js";
 // TODO: decide how to deal with dependencies on flex-tree implementation.
 // eslint-disable-next-line import/no-internal-modules
 import { makeTree } from "../../feature-libraries/flex-tree/lazyNode.js";
@@ -423,22 +422,25 @@ export function tryDisposeTreeNode(anchorNode: AnchorNode): void {
 }
 
 /**
- * Lookup a TreeNodeSchema from a Hydrated FlexTreeNode.
- * @privateRemarks
- * This provides a way to access simple tree schema from the flex tree without depending on {@link FlexTreeSchema} which is in the process of being removed.
- * This is currently limited to hydrated nodes: this limitation will have to be fixed before {@link FlexTreeSchema} can be fully removed.
+ * Gets the {@link TreeNodeSchema} for the {@link InnerNode}.
  */
-export function getTreeNodeSchemaFromHydratedFlexNode(flexNode: FlexTreeNode): TreeNodeSchema {
-	assert(
-		flexNode.context.isHydrated(),
-		0xa56 /* getTreeNodeSchemaFromHydratedFlexNode only allows hydrated flex tree nodes */,
-	);
+export function getSimpleNodeSchemaFromInnerNode(innerNode: InnerNode): TreeNodeSchema {
+	const context: Context = getSimpleContextFromInnerNode(innerNode);
+	return context.schema.get(innerNode.schema) ?? fail(0xb3f /* missing schema from context */);
+}
 
-	const context =
-		flexNode.anchorNode.anchorSet.slots.get(SimpleContextSlot) ??
-		fail(0xb43 /* Missing SimpleContextSlot */);
+/**
+ * Gets the {@link Context} for the {@link InnerNode}.
+ */
+export function getSimpleContextFromInnerNode(innerNode: InnerNode): Context {
+	if (innerNode instanceof UnhydratedFlexTreeNode) {
+		return innerNode.simpleContext;
+	}
+
+	const context = innerNode.anchorNode.anchorSet.slots.get(SimpleContextSlot);
+	assert(context !== undefined, 0xa55 /* missing simple tree context */);
 
-	return context.schema.get(flexNode.schema) ?? fail(0xb44 /* Missing schema */);
+	return context;
 }
 
 /**
@@ -482,8 +484,20 @@ export function treeNodeFromAnchor(anchorNode: AnchorNode): TreeNode | TreeValue
 	}
 
 	const flexNode = flexNodeFromAnchor(anchorNode);
-	const classSchema = getTreeNodeSchemaFromHydratedFlexNode(flexNode);
+	return createTreeNodeFromInner(flexNode);
+}
+
+/**
+ * Constructs a TreeNode from an InnerNode.
+ * @remarks
+ * This does not do caching or validation: caller must ensure duplicate nodes for a given inner node are not created, and that the inner node is valid.
+ */
+export function createTreeNodeFromInner(innerNode: InnerNode): TreeNode | TreeValue {
+	const classSchema = getSimpleNodeSchemaFromInnerNode(innerNode);
+	const internal = innerNode as unknown as InternalTreeNode;
 	return typeof classSchema === "function"
-		? new classSchema(flexNode as unknown as InternalTreeNode)
-		: (classSchema as { create(data: FlexTreeNode): TreeValue }).create(flexNode);
+		? new classSchema(internal)
+		: (classSchema as { create(data: InternalTreeNode): TreeNode | TreeValue }).create(
+				internal,
+			);
 }