@fluidframework/tree 2.63.0-359461 → 2.63.0-359734

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

@@ -5,9 +5,9 @@
 
 import { brand } from "../../util/index.js";
 import {
-	normalizeAnnotatedAllowedTypes,
+	normalizeAndEvaluateAnnotatedAllowedTypes,
 	type AnnotatedAllowedType,
-	type ImplicitAnnotatedAllowedTypes,
+	type ImplicitAllowedTypes,
 	type SchemaUpgrade,
 } from "./allowedTypes.js";
 import type { TreeNodeSchemaIdentifier, TreeTypeSet } from "../../core/index.js";
@@ -42,16 +42,18 @@ export function allowedTypeFilter(
 }
 
 /**
- * Converts an ImplicitAnnotatedAllowedTypes to a stored schema.
+ * Converts an ImplicitAllowedTypes to a stored schema.
  * @param schema - The schema to convert.
  * @param options - The options to use for filtering.
  * @returns The converted stored schema.
  */
 export function convertAllowedTypes(
-	schema: ImplicitAnnotatedAllowedTypes,
+	schema: ImplicitAllowedTypes,
 	options: StoredSchemaGenerationOptions,
 ): TreeTypeSet {
-	const filtered: TreeNodeSchemaIdentifier[] = normalizeAnnotatedAllowedTypes(schema)
+	const filtered: TreeNodeSchemaIdentifier[] = normalizeAndEvaluateAnnotatedAllowedTypes(
+		schema,
+	)
 		.types.filter((allowedType) => allowedTypeFilter(allowedType, options))
 		.map((a) => brand(a.type.identifier));
 	return new Set(filtered);

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

@@ -29,7 +29,7 @@ import { markEager } from "./flexList.js";
  * 2. Explicit construction of {@link Unhydrated} nodes using either {@link TreeNodeSchemaClass} as a constructor or {@link TreeNodeSchemaNonClass|TreeNodeSchemaNonClass.create}.
  * Either way the {@link TreeNodeSchema} produced must be produced using a {@link SchemaFactory}.
  * There are also higher level APIs which wrap these, including {@link (TreeBeta:interface).create}, {@link (TreeBeta:interface).clone},
- * and import APIs like {@link (TreeAlpha:interface).importConcise}, {@link (TreeAlpha:interface).importVerbose}, and {@link (TreeAlpha:interface).importCompressed}.
+ * and import APIs like {@link (TreeBeta:interface).importConcise}, {@link (TreeAlpha:interface).importVerbose}, and {@link (TreeAlpha:interface).importCompressed}.
  *
  * 3. Implicit construction: Several APIs which logically require an unhydrated TreeNode also allow passing in a value which could be used to explicitly construct the node instead.
  * These APIs internally call the constructor with the provided value (typically behaving like {@link (TreeAlpha:interface).create}), so it's really just a special case of the above option.

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

@@ -10,10 +10,7 @@ import type { SimpleNodeSchemaBase } from "./simpleNodeSchemaBase.js";
 import type { TreeNode } from "./treeNode.js";
 import type { InternalTreeNode, Unhydrated } from "./types.js";
 import type { UnionToIntersection } from "../../util/index.js";
-import type {
-	ImplicitAnnotatedAllowedTypes,
-	NormalizedAnnotatedAllowedTypes,
-} from "./allowedTypes.js";
+import type { ImplicitAllowedTypes, AllowedTypesFullEvaluated } from "./allowedTypes.js";
 import type { Context } from "./context.js";
 import type { FieldKey, NodeData, TreeNodeStoredSchema } from "../../core/index.js";
 import type { UnhydratedFlexTreeField } from "./unhydratedFlexTree.js";
@@ -391,7 +388,7 @@ export interface TreeNodeSchemaPrivateData {
 	 * If this is stabilized, it will live alongside the childTypes property on {@link TreeNodeSchemaCore}.
 	 * @system
 	 */
-	readonly childAnnotatedAllowedTypes: readonly ImplicitAnnotatedAllowedTypes[];
+	readonly childAnnotatedAllowedTypes: readonly ImplicitAllowedTypes[];
 
 	/**
 	 * Idempotent initialization function that pre-caches data and can dereference lazy schema references.
@@ -425,7 +422,7 @@ export interface TreeNodeSchemaInitializedData {
 	 * If this is stabilized, it will live alongside the childTypes property on {@link TreeNodeSchemaCore}.
 	 * @system
 	 */
-	readonly childAnnotatedAllowedTypes: readonly NormalizedAnnotatedAllowedTypes[];
+	readonly childAnnotatedAllowedTypes: readonly AllowedTypesFullEvaluated[];
 
 	/**
 	 * A {@link Context} which can be used for unhydrated nodes of this schema.

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

@@ -25,7 +25,7 @@ import {
 } from "./treeNodeKernel.js";
 import type { InternalTreeNode } from "./types.js";
 import { typeSchemaSymbol } from "./withType.js";
-import type { ImplicitAnnotatedAllowedTypes } from "./allowedTypes.js";
+import type { ImplicitAllowedTypes } from "./allowedTypes.js";
 import type { SimpleNodeSchemaBase } from "./simpleNodeSchemaBase.js";
 
 /**
@@ -259,7 +259,7 @@ export function isClassBasedSchema(
  */
 export function createTreeNodeSchemaPrivateData(
 	schema: TreeNodeSchemaCore<string, NodeKind, boolean>,
-	childAnnotatedAllowedTypes: readonly ImplicitAnnotatedAllowedTypes[],
+	childAnnotatedAllowedTypes: readonly ImplicitAllowedTypes[],
 	toStored: TreeNodeSchemaPrivateData["toStored"],
 ): TreeNodeSchemaPrivateData {
 	const schemaValid = schemaAsTreeNodeValid(schema);

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

@@ -4,9 +4,9 @@
  */
 
 import {
-	normalizeAnnotatedAllowedTypes,
+	normalizeAndEvaluateAnnotatedAllowedTypes,
 	type AnnotatedAllowedType,
-	type NormalizedAnnotatedAllowedTypes,
+	type AllowedTypesFullEvaluated,
 } from "./allowedTypes.js";
 import { getTreeNodeSchemaPrivateData, type TreeNodeSchema } from "./treeNodeSchema.js";
 
@@ -32,7 +32,11 @@ export function walkNodeSchema(
 		getTreeNodeSchemaPrivateData(schema).childAnnotatedAllowedTypes;
 
 	for (const fieldAllowedTypes of annotatedAllowedTypes) {
-		walkAllowedTypes(normalizeAnnotatedAllowedTypes(fieldAllowedTypes), visitor, visitedSet);
+		walkAllowedTypes(
+			normalizeAndEvaluateAnnotatedAllowedTypes(fieldAllowedTypes),
+			visitor,
+			visitedSet,
+		);
 	}
 
 	// This visit is done at the end so the traversal order is most inner types first.
@@ -47,7 +51,7 @@ export function walkNodeSchema(
  * @internal
  */
 export function walkAllowedTypes(
-	annotatedAllowedTypes: NormalizedAnnotatedAllowedTypes,
+	annotatedAllowedTypes: AllowedTypesFullEvaluated,
 	visitor: SchemaVisitor,
 	visitedSet: Set<TreeNodeSchema> = new Set(),
 ): void {
@@ -77,7 +81,7 @@ export interface SchemaVisitor {
 	 *
 	 * After this is called {@link SchemaVisitor.allowedTypeFilter} is applied to each allowed type in the schema to determine which of them are walked into.
 	 */
-	allowedTypes?: (allowedTypes: NormalizedAnnotatedAllowedTypes) => void;
+	allowedTypes?: (allowedTypes: AllowedTypesFullEvaluated) => void;
 	/**
 	 * If true, will walk into this `allowedType`.
 	 * If false, the `allowedType` will not be walked into.

package/src/simple-tree/createContext.ts

@@ -9,7 +9,7 @@ import { getOrCreate } from "../util/index.js";
 import {
 	Context,
 	getTreeNodeSchemaPrivateData,
-	normalizeAnnotatedAllowedTypes,
+	normalizeAndEvaluateAnnotatedAllowedTypes,
 	UnhydratedContext,
 	type TreeNodeSchema,
 	type TreeNodeSchemaInitializedData,
@@ -34,7 +34,7 @@ export function getUnhydratedContext(schema: ImplicitFieldSchema): Context {
 		);
 		return new Context(
 			flexContext,
-			Context.schemaMapFromRootSchema(normalized.annotatedAllowedTypesNormalized),
+			Context.schemaMapFromRootSchema(normalized.allowedTypesFull.evaluate()),
 		);
 	});
 }
@@ -51,7 +51,7 @@ export function getTreeNodeSchemaInitializedData(
 		...handler,
 		context: getUnhydratedContext(schema),
 		childAnnotatedAllowedTypes: data.childAnnotatedAllowedTypes.map(
-			normalizeAnnotatedAllowedTypes,
+			normalizeAndEvaluateAnnotatedAllowedTypes,
 		),
 	};
 }

package/src/simple-tree/fieldSchema.ts

@@ -23,21 +23,13 @@ import type {
 	TreeNodeSchema,
 	TreeNode,
 	UnhydratedFlexTreeNode,
-	NormalizedAnnotatedAllowedTypes,
 	ImplicitAllowedTypes,
-	ImplicitAnnotatedAllowedTypes,
-	UnannotateImplicitAllowedTypes,
-	AllowedTypesMetadata,
 	TreeNodeFromImplicitAllowedTypes,
 	TreeLeafValue,
 	InsertableTreeNodeFromImplicitAllowedTypes,
+	AllowedTypesFull,
 } from "./core/index.js";
-import {
-	isAnnotatedAllowedTypes,
-	normalizeAllowedTypes,
-	normalizeAnnotatedAllowedTypes,
-	unannotateImplicitAllowedTypes,
-} from "./core/index.js";
+import { normalizeAllowedTypes } from "./core/index.js";
 
 import type { SimpleFieldSchema } from "./simpleSchema.js";
 import type { UnsafeUnknownSchema } from "./unsafeUnknownSchema.js";
@@ -81,10 +73,7 @@ export enum FieldKind {
  * If an explicit stored key was specified in the schema, it will be used.
  * Otherwise, the stored key is the same as the property key.
  */
-export function getStoredKey(
-	propertyKey: string,
-	fieldSchema: ImplicitAnnotatedFieldSchema,
-): FieldKey {
+export function getStoredKey(propertyKey: string, fieldSchema: ImplicitFieldSchema): FieldKey {
 	return brand(getExplicitStoredKey(fieldSchema) ?? propertyKey);
 }
 
@@ -92,9 +81,7 @@ export function getStoredKey(
  * Gets the {@link FieldProps.key | stored key} specified by the schema, if one was explicitly specified.
  * Otherwise, returns undefined.
  */
-export function getExplicitStoredKey(
-	fieldSchema: ImplicitAnnotatedFieldSchema,
-): string | undefined {
+export function getExplicitStoredKey(fieldSchema: ImplicitFieldSchema): string | undefined {
 	return fieldSchema instanceof FieldSchema ? fieldSchema.props?.key : undefined;
 }
 
@@ -286,30 +273,7 @@ export function createFieldSchema<
 	kind: Kind,
 	annotatedTypes: Types,
 	props?: FieldProps<TCustomMetadata>,
-): FieldSchemaAlpha<Kind, Types, TCustomMetadata>;
-
-/**
- * Package internal construction API that supports annotations for allowed types.
- */
-export function createFieldSchema<
-	Kind extends FieldKind,
-	Types extends ImplicitAnnotatedAllowedTypes,
-	TCustomMetadata = unknown,
->(
-	kind: Kind,
-	annotatedTypes: Types,
-	props?: FieldProps<TCustomMetadata>,
-): FieldSchemaAlpha<Kind, UnannotateImplicitAllowedTypes<Types>, TCustomMetadata>;
-
-export function createFieldSchema<
-	Kind extends FieldKind,
-	Types extends ImplicitAnnotatedAllowedTypes,
-	TCustomMetadata = unknown,
->(
-	kind: Kind,
-	annotatedTypes: Types,
-	props?: FieldProps<TCustomMetadata>,
-): FieldSchemaAlpha<Kind, UnannotateImplicitAllowedTypes<Types>, TCustomMetadata> {
+): FieldSchemaAlpha<Kind, Types, TCustomMetadata> {
 	return createFieldSchemaPrivate(kind, annotatedTypes, props);
 }
 
@@ -318,13 +282,13 @@ export function createFieldSchema<
  */
 let createFieldSchemaPrivate: <
 	Kind extends FieldKind,
-	Types extends ImplicitAnnotatedAllowedTypes,
+	Types extends ImplicitAllowedTypes,
 	TCustomMetadata,
 >(
 	kind: Kind,
 	annotatedTypes: Types,
 	props?: FieldProps<TCustomMetadata>,
-) => FieldSchemaAlpha<Kind, UnannotateImplicitAllowedTypes<Types>, TCustomMetadata>;
+) => FieldSchemaAlpha<Kind, Types, TCustomMetadata>;
 
 /**
  * All policy for a specific field,
@@ -400,7 +364,7 @@ export class FieldSchema<
 			throw new UsageError("FieldSchema is @sealed: sub-classing is not allowed.");
 		}
 
-		this.lazyTypes = new Lazy(() => normalizeAllowedTypes(this.allowedTypes));
+		this.lazyTypes = new Lazy(() => normalizeAllowedTypes(this.allowedTypes).evaluateSet());
 		// TODO: optional fields should (by default) get a default provider that returns undefined, removing the need to special case them here:
 		this.requiresValue =
 			this.props?.defaultProvider === undefined && this.kind !== FieldKind.Optional;
@@ -421,15 +385,8 @@ export class FieldSchemaAlpha<
 	extends FieldSchema<Kind, Types, TCustomMetadata>
 	implements SimpleFieldSchema
 {
-	private readonly lazyIdentifiers: Lazy<ReadonlySet<string>>;
-	private readonly lazyAnnotatedTypes: Lazy<NormalizedAnnotatedAllowedTypes>;
 	private readonly propsAlpha: FieldPropsAlpha<TCustomMetadata> | undefined;
 
-	/**
-	 * Metadata on the types of tree nodes allowed on this field.
-	 */
-	public readonly allowedTypesMetadata: AllowedTypesMetadata;
-
 	public get persistedMetadata(): JsonCompatibleReadOnlyObject | undefined {
 		return this.propsAlpha?.persistedMetadata;
 	}
@@ -437,61 +394,44 @@ export class FieldSchemaAlpha<
 	static {
 		createFieldSchemaPrivate = <
 			Kind2 extends FieldKind,
-			Types2 extends ImplicitAnnotatedAllowedTypes,
+			Types2 extends ImplicitAllowedTypes,
 			TCustomMetadata2,
 		>(
 			kind: Kind2,
 			annotatedAllowedTypes: Types2,
 			props?: FieldPropsAlpha<TCustomMetadata2>,
-		) =>
-			new FieldSchemaAlpha(
-				kind,
-				unannotateImplicitAllowedTypes(annotatedAllowedTypes),
-				annotatedAllowedTypes,
-				props,
-			);
+		) => new FieldSchemaAlpha(kind, annotatedAllowedTypes, props);
+	}
+
+	/**
+	 * {@link normalizeAllowedTypes|Normalized} version of {@link FieldSchema.allowedTypes}.
+	 */
+	public readonly allowedTypesFull: AllowedTypesFull;
+
+	public get allowedTypesIdentifiers(): ReadonlySet<string> {
+		return this.allowedTypesFull.evaluateIdentifiers();
 	}
 
 	protected constructor(
 		kind: Kind,
 		types: Types,
-		public readonly annotatedAllowedTypes: ImplicitAnnotatedAllowedTypes,
+
 		props?: FieldPropsAlpha<TCustomMetadata>,
 	) {
 		super(kind, types, props);
 
-		this.allowedTypesMetadata = isAnnotatedAllowedTypes(annotatedAllowedTypes)
-			? annotatedAllowedTypes.metadata
-			: {};
-		this.lazyAnnotatedTypes = new Lazy(() =>
-			normalizeAnnotatedAllowedTypes(annotatedAllowedTypes),
-		);
-		this.lazyIdentifiers = new Lazy(
-			() =>
-				new Set(this.annotatedAllowedTypesNormalized.types.map(({ type }) => type.identifier)),
-		);
+		const normalizedTypes = normalizeAllowedTypes(types);
+		this.allowedTypesFull = normalizedTypes;
 		this.propsAlpha = props;
 	}
-
-	public get allowedTypesIdentifiers(): ReadonlySet<string> {
-		return this.lazyIdentifiers.value;
-	}
-
-	/**
-	 * What types of tree nodes are allowed in this field and their annotations.
-	 * @remarks Counterpart to {@link FieldSchemaAlpha.annotatedAllowedTypes}, with any lazy definitions evaluated.
-	 */
-	public get annotatedAllowedTypesNormalized(): NormalizedAnnotatedAllowedTypes {
-		return this.lazyAnnotatedTypes.value;
-	}
 }
 
 /**
- * Normalizes a {@link ImplicitFieldSchema} or {@link ImplicitAnnotatedFieldSchema} to a {@link FieldSchema}.
+ * Normalizes a {@link ImplicitFieldSchema} or {@link ImplicitFieldSchema} to a {@link FieldSchema}.
  * @internal
  */
 export function normalizeFieldSchema(
-	schema: ImplicitFieldSchema | ImplicitAnnotatedFieldSchema,
+	schema: ImplicitFieldSchema | ImplicitFieldSchema,
 ): FieldSchemaAlpha {
 	return schema instanceof FieldSchema
 		? (schema as FieldSchemaAlpha)
@@ -618,20 +558,6 @@ function arePersistedMetadataEqual(
  */
 export type ImplicitFieldSchema = FieldSchema | ImplicitAllowedTypes;
 
-/**
- * {@link ImplicitFieldSchema} which supports {@link AnnotatedAllowedTypes | annotations} on the allowed types.
- * @alpha
- * @input
- */
-export type ImplicitAnnotatedFieldSchema = FieldSchema | ImplicitAnnotatedAllowedTypes;
-
-/**
- * Removes annotations from an annotated field schema.
- * @system @alpha
- */
-export type UnannotateImplicitFieldSchema<T extends ImplicitAnnotatedFieldSchema> =
-	T extends ImplicitAnnotatedAllowedTypes ? UnannotateImplicitAllowedTypes<T> : T;
-
 /**
  * Converts an `ImplicitFieldSchema` to a property type suitable for reading a field with this that schema.
  *

package/src/simple-tree/index.ts

@@ -9,7 +9,7 @@ export {
 	type WithType,
 	type TreeNodeSchema,
 	type AnnotatedAllowedType,
-	type NormalizedAnnotatedAllowedTypes,
+	type AllowedTypesFullEvaluated,
 	NodeKind,
 	type TreeNodeSchemaClass,
 	type TreeNodeSchemaNonClass,
@@ -38,12 +38,8 @@ export {
 	normalizeAllowedTypes,
 	type NodeSchemaMetadata,
 	type ImplicitAllowedTypes,
-	type ImplicitAnnotatedAllowedTypes,
-	type UnannotateImplicitAllowedTypes,
 	type AllowedTypesMetadata,
 	evaluateLazySchema,
-	type UnannotateAllowedTypes,
-	type UnannotateAllowedType,
 	type UnannotateAllowedTypesList,
 	type AllowedTypeMetadata,
 	type AnnotatedAllowedTypes,
@@ -57,6 +53,11 @@ export {
 	type SchemaVisitor,
 	type SimpleNodeSchemaBase,
 	withBufferedTreeEvents,
+	type AnnotateAllowedTypesList,
+	type AllowedTypesFull,
+	type AllowedTypesFullFromMixed,
+	AnnotatedAllowedTypesInternal,
+	type NumberKeys,
 } from "./core/index.js";
 export { walkFieldSchema } from "./walkFieldSchema.js";
 export type { UnsafeUnknownSchema, Insertable } from "./unsafeUnknownSchema.js";
@@ -73,7 +74,8 @@ export {
 	SchemaFactory,
 	SchemaFactoryBeta,
 	SchemaFactoryAlpha,
-	type SchemaFactoryObjectOptions,
+	type ObjectSchemaOptionsAlpha,
+	type ObjectSchemaOptions,
 	type ScopedSchemaName,
 	type ValidateRecursiveSchema,
 	type FixRecursiveArraySchema,
@@ -83,6 +85,9 @@ export {
 	treeNodeApi,
 	type TreeNodeApi,
 	type NodeChangedData,
+	borrowCursorFromTreeNodeOrValue,
+	exportConcise,
+	importConcise,
 	TreeBeta,
 	type TreeChangeEventsBeta,
 	type SimpleTreeIndex,
@@ -184,9 +189,7 @@ export type {
 } from "./simpleSchema.js";
 export {
 	type ImplicitFieldSchema,
-	type ImplicitAnnotatedFieldSchema,
 	type TreeFieldFromImplicitField,
-	type UnannotateImplicitFieldSchema,
 	FieldKind,
 	FieldSchema,
 	FieldSchemaAlpha,
@@ -226,7 +229,6 @@ export {
 	ObjectNodeSchema,
 	type ObjectNodeSchemaPrivate,
 	isObjectNodeSchema,
-	type InsertableObjectFromAnnotatedSchemaRecord,
 	type TreeObjectNode,
 	setField,
 	isRecordNodeSchema,
@@ -235,7 +237,6 @@ export {
 	type RecordNodePojoEmulationSchema,
 	RecordNodeSchema,
 	type TreeRecordNode,
-	type UnannotateSchemaRecord,
 } from "./node-kinds/index.js";
 export {
 	unhydratedFlexTreeFromInsertable,

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

@@ -32,14 +32,11 @@ import {
 	UnhydratedSequenceField,
 	getOrCreateNodeFromInnerUnboxedNode,
 	normalizeAllowedTypes,
-	unannotateImplicitAllowedTypes,
 	type ImplicitAllowedTypes,
-	type ImplicitAnnotatedAllowedTypes,
 	type InsertableTreeNodeFromImplicitAllowedTypes,
 	type NodeSchemaMetadata,
 	type TreeLeafValue,
 	type TreeNodeFromImplicitAllowedTypes,
-	type UnannotateImplicitAllowedTypes,
 	TreeNodeValid,
 	type MostDerivedData,
 	type TreeNodeSchemaInitializedData,
@@ -863,7 +860,7 @@ abstract class CustomArrayNodeBase<const T extends ImplicitAllowedTypes>
 
 	public static readonly kind = NodeKind.Array;
 
-	protected abstract get childSchema(): ImplicitAnnotatedAllowedTypes;
+	protected abstract get childSchema(): ImplicitAllowedTypes;
 	protected abstract get allowedTypes(): ReadonlySet<TreeNodeSchema>;
 
 	public abstract override get [typeSchemaSymbol](): TreeNodeSchemaClass<
@@ -1147,7 +1144,7 @@ abstract class CustomArrayNodeBase<const T extends ImplicitAllowedTypes>
 // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
 export function arraySchema<
 	TName extends string,
-	const T extends ImplicitAnnotatedAllowedTypes,
+	const T extends ImplicitAllowedTypes,
 	const ImplicitlyConstructable extends boolean,
 	const TCustomMetadata = unknown,
 >(
@@ -1167,18 +1164,16 @@ export function arraySchema<
 		ArrayNodePojoEmulationSchema<TName, T, ImplicitlyConstructable, TCustomMetadata> &
 		TreeNodeSchemaCorePrivate;
 
-	const unannotatedTypes = unannotateImplicitAllowedTypes(info);
-
-	const lazyChildTypes = new Lazy(() => normalizeAllowedTypes(unannotatedTypes));
+	const normalizedTypes = normalizeAllowedTypes(info);
 	const lazyAllowedTypesIdentifiers = new Lazy(
-		() => new Set([...lazyChildTypes.value].map((type) => type.identifier)),
+		() => new Set(normalizedTypes.evaluate().map((type) => type.identifier)),
 	);
 
 	let privateData: TreeNodeSchemaPrivateData | undefined;
 
 	// This class returns a proxy from its constructor to handle numeric indexing.
 	// Alternatively it could extend a normal class which gets tons of numeric properties added.
-	class Schema extends CustomArrayNodeBase<UnannotateImplicitAllowedTypes<T>> {
+	class Schema extends CustomArrayNodeBase<T> {
 		public static override prepareInstance<T2>(
 			this: typeof TreeNodeValid<T2>,
 			instance: TreeNodeValid<T2>,
@@ -1255,7 +1250,7 @@ export function arraySchema<
 		public static readonly implicitlyConstructable: ImplicitlyConstructable =
 			implicitlyConstructable;
 		public static get childTypes(): ReadonlySet<TreeNodeSchema> {
-			return lazyChildTypes.value;
+			return normalizedTypes.evaluateSet();
 		}
 		public static readonly metadata: NodeSchemaMetadata<TCustomMetadata> = metadata ?? {};
 		public static readonly persistedMetadata: JsonCompatibleReadOnlyObject | undefined =
@@ -1273,7 +1268,7 @@ export function arraySchema<
 			return info;
 		}
 		protected get allowedTypes(): ReadonlySet<TreeNodeSchema> {
-			return lazyChildTypes.value;
+			return normalizedTypes.evaluateSet();
 		}
 
 		public static get [privateDataSymbol](): TreeNodeSchemaPrivateData {
@@ -1370,10 +1365,10 @@ function arrayToFlexContent(data: FactoryContent, schema: ArrayNodeSchema): Flex
 		throw new UsageError(`Input data is incompatible with Array schema: ${data}`);
 	}
 
-	const allowedChildTypes = normalizeAllowedTypes(schema.info as ImplicitAllowedTypes);
+	const allowedChildTypes = normalizeAllowedTypes(schema.info);
 
 	const mappedData = Array.from(data, (child) =>
-		arrayChildToFlexTree(child, allowedChildTypes),
+		arrayChildToFlexTree(child, allowedChildTypes.evaluateSet()),
 	);
 
 	const context = getUnhydratedContext(schema).flexContext;

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

@@ -10,9 +10,8 @@ import type {
 	TreeNodeSchema,
 	TreeNodeSchemaNonClass,
 	WithType,
-	ImplicitAnnotatedAllowedTypes,
+	ImplicitAllowedTypes,
 	InsertableTreeNodeFromImplicitAllowedTypes,
-	UnannotateImplicitAllowedTypes,
 } from "../../core/index.js";
 
 import type { SimpleArrayNodeSchema } from "../../simpleSchema.js";
@@ -23,14 +22,14 @@ import type { SimpleArrayNodeSchema } from "../../simpleSchema.js";
  */
 export interface ArrayNodeCustomizableSchema<
 	out TName extends string = string,
-	in out T extends ImplicitAnnotatedAllowedTypes = ImplicitAnnotatedAllowedTypes,
+	in out T extends ImplicitAllowedTypes = ImplicitAllowedTypes,
 	out ImplicitlyConstructable extends boolean = true,
 	out TCustomMetadata = unknown,
 > extends TreeNodeSchemaClass<
 			TName,
 			NodeKind.Array,
-			TreeArrayNode<UnannotateImplicitAllowedTypes<T>> & WithType<TName, NodeKind.Array, T>,
-			Iterable<InsertableTreeNodeFromImplicitAllowedTypes<UnannotateImplicitAllowedTypes<T>>>,
+			TreeArrayNode<T> & WithType<TName, NodeKind.Array, T>,
+			Iterable<InsertableTreeNodeFromImplicitAllowedTypes<T>>,
 			ImplicitlyConstructable,
 			T,
 			undefined,
@@ -44,14 +43,14 @@ export interface ArrayNodeCustomizableSchema<
  */
 export interface ArrayNodePojoEmulationSchema<
 	out TName extends string = string,
-	in out T extends ImplicitAnnotatedAllowedTypes = ImplicitAnnotatedAllowedTypes,
+	in out T extends ImplicitAllowedTypes = ImplicitAllowedTypes,
 	out ImplicitlyConstructable extends boolean = true,
 	out TCustomMetadata = unknown,
 > extends TreeNodeSchemaNonClass<
 			TName,
 			NodeKind.Array,
-			TreeArrayNode<UnannotateImplicitAllowedTypes<T>> & WithType<TName, NodeKind.Array, T>,
-			Iterable<InsertableTreeNodeFromImplicitAllowedTypes<UnannotateImplicitAllowedTypes<T>>>,
+			TreeArrayNode<T> & WithType<TName, NodeKind.Array, T>,
+			Iterable<InsertableTreeNodeFromImplicitAllowedTypes<T>>,
 			ImplicitlyConstructable,
 			T,
 			undefined,

package/src/simple-tree/node-kinds/common.ts

@@ -12,7 +12,6 @@ import { brand } from "../../util/index.js";
 import {
 	createField,
 	type UnhydratedFlexTreeField,
-	unannotateImplicitAllowedTypes,
 	normalizeAllowedTypes,
 	type FlexContent,
 } from "../core/index.js";
@@ -35,7 +34,7 @@ export function recordLikeDataToFlexContent(
 	fieldsIterator: Iterable<readonly [string, InsertableContent]>,
 	schema: MapNodeSchema | RecordNodeSchema,
 ): FlexContent {
-	const allowedChildTypes = normalizeAllowedTypes(unannotateImplicitAllowedTypes(schema.info));
+	const allowedChildTypes = normalizeAllowedTypes(schema.info);
 	const context = getUnhydratedContext(schema).flexContext;
 
 	const transformedFields = new Map<FieldKey, UnhydratedFlexTreeField>();
@@ -45,7 +44,10 @@ export function recordLikeDataToFlexContent(
 
 		// Omit undefined values - an entry with an undefined value is equivalent to one that has been removed or omitted
 		if (value !== undefined) {
-			const child = unhydratedFlexTreeFromInsertableNode(value, allowedChildTypes);
+			const child = unhydratedFlexTreeFromInsertableNode(
+				value,
+				allowedChildTypes.evaluateSet(),
+			);
 			const field = createField(context, FieldKinds.optional.identifier, brand(key), [child]);
 			transformedFields.set(brand(key), field);
 		}

package/src/simple-tree/node-kinds/index.ts

@@ -27,7 +27,6 @@ export {
 
 export {
 	type FieldHasDefault,
-	type InsertableObjectFromAnnotatedSchemaRecord,
 	type InsertableObjectFromSchemaRecord,
 	isObjectNodeSchema,
 	type ObjectFromSchemaRecord,
@@ -37,7 +36,6 @@ export {
 	setField,
 	type TreeObjectNode,
 	type SimpleKeyMap,
-	type UnannotateSchemaRecord,
 } from "./object/index.js";
 
 export {