@fluidframework/tree 2.63.0-359461 → 2.63.0-359962

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

@@ -10,7 +10,7 @@ export {
 	tryGetTreeNodeSchema,
 	type InnerNode,
 	tryDisposeTreeNode,
-	getOrCreateInnerNode,
+	getInnerNode,
 	treeNodeFromAnchor,
 	getSimpleNodeSchemaFromInnerNode,
 	SimpleContextSlot,
@@ -53,31 +53,33 @@ export {
 	isAnnotatedAllowedTypes,
 	isAnnotatedAllowedType,
 	normalizeAllowedTypes,
-	normalizeAnnotatedAllowedTypes,
+	normalizeAndEvaluateAnnotatedAllowedTypes,
 	normalizeToAnnotatedAllowedType,
-	unannotateImplicitAllowedTypes,
 	markSchemaMostDerived,
 	evaluateLazySchema,
 	createSchemaUpgrade,
-	type SchemaUpgrade,
+	AnnotatedAllowedTypesInternal,
+	normalizeAllowedTypesInternal,
 } from "./allowedTypes.js";
 export type {
 	AnnotatedAllowedType,
-	NormalizedAnnotatedAllowedTypes,
+	AllowedTypesFullEvaluated,
 	ImplicitAllowedTypes,
-	ImplicitAnnotatedAllowedTypes,
-	UnannotateImplicitAllowedTypes,
 	AllowedTypesMetadata,
 	AllowedTypes,
 	TreeNodeFromImplicitAllowedTypes,
 	InsertableTreeNodeFromImplicitAllowedTypes,
 	InsertableTreeNodeFromAllowedTypes,
 	Input,
-	UnannotateAllowedTypes,
-	UnannotateAllowedType,
 	UnannotateAllowedTypesList,
 	AllowedTypeMetadata,
 	AnnotatedAllowedTypes,
+	AnnotateAllowedTypesList,
+	SchemaUpgrade,
+	AllowedTypesFullInternal,
+	AllowedTypesFull,
+	AllowedTypesFullFromMixed,
+	NumberKeys,
 } from "./allowedTypes.js";
 export { walkAllowedTypes, walkNodeSchema, type SchemaVisitor } from "./walkSchema.js";
 export { Context, HydratedContext } from "./context.js";

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/treeNodeKernel.ts

@@ -17,14 +17,11 @@ import {
 	anchorSlot,
 	type AnchorEvents,
 	type AnchorNode,
-	type AnchorSet,
 	type FieldKey,
 	type TreeValue,
-	type UpPath,
 } from "../../core/index.js";
 import { getOrCreateHydratedFlexTreeNode } from "../../feature-libraries/index.js";
 import {
-	assertFlexTreeEntityNotFreed,
 	ContextSlot,
 	flexTreeSlot,
 	LazyEntity,
@@ -85,10 +82,8 @@ interface UnhydratedState {
 
 /** The {@link HydrationState} of a {@link TreeNodeKernel} after the kernel is hydrated */
 interface HydratedState {
-	/** The flex node for this kernel (lazy - undefined if it has not yet been demanded) */
-	innerNode?: FlexTreeNode;
-	/** The {@link AnchorNode} that this node is associated with. */
-	readonly anchorNode: AnchorNode;
+	/** The flex node for this kernel */
+	readonly innerNode: HydratedFlexTreeNode;
 	/** All {@link Off | event deregistration functions} that should be run when the kernel is disposed. */
 	readonly offAnchorNode: Set<Off>;
 }
@@ -98,7 +93,7 @@ type HydrationState = UnhydratedState | HydratedState;
 
 /** True if and only if the given {@link HydrationState} is post-hydration */
 function isHydrated(state: HydrationState): state is HydratedState {
-	return (state as Partial<HydratedState>).anchorNode !== undefined;
+	return state.innerNode.isHydrated();
 }
 
 /**
@@ -137,7 +132,7 @@ export class TreeNodeKernel {
 	 * Create a TreeNodeKernel which can be looked up with {@link getKernel}.
 	 *
 	 * @param initialContext - context from when this node was originally created. Only used when unhydrated.
-	 * @param innerNode - When unhydrated/raw or marinated the MapTreeNode. FlexTreeNode when cooked.
+	 * @param innerNode - When unhydrated the MapTreeNode. Otherwise HydratedFlexTreeNode.
 	 * @remarks
 	 * Exactly one kernel per TreeNode should be created.
 	 */
@@ -165,9 +160,7 @@ export class TreeNodeKernel {
 			this.#eventBuffer = new KernelEventBuffer(innerNode.events);
 		} else {
 			// Hydrated case
-			this.#hydrationState = this.createHydratedState(innerNode.anchorNode);
-			this.#hydrationState.innerNode = innerNode;
-
+			this.#hydrationState = this.createHydratedState(innerNode);
 			this.#eventBuffer = new KernelEventBuffer(innerNode.anchorNode.events);
 		}
 	}
@@ -176,7 +169,7 @@ export class TreeNodeKernel {
 		if (isHydrated(this.#hydrationState)) {
 			// This can't be cached on this.#hydrated during hydration since initial tree is hydrated before the context is cached on the anchorSet.
 			return (
-				this.#hydrationState?.anchorNode.anchorSet.slots.get(SimpleContextSlot) ??
+				this.#hydrationState.innerNode.anchorNode.anchorSet.slots.get(SimpleContextSlot) ??
 				fail(0xb40 /* missing simple-tree context */)
 			);
 		}
@@ -185,38 +178,33 @@ export class TreeNodeKernel {
 
 	/**
 	 * Transition from {@link Unhydrated} to hydrated.
-	 * Bi-directionally associates the given hydrated TreeNode to the anchor node at the provided path.
+	 * Bi-directionally associates the given hydrated TreeNode to the HydratedFlexTreeNode.
 	 * @remarks
 	 * Happens at most once for any given node.
 	 * Cleans up mappings to {@link UnhydratedFlexTreeNode} - it is assumed that they are no longer needed once this node has an anchor node.
 	 */
-	public hydrate(anchors: AnchorSet, path: UpPath): void {
+	public hydrate(inner: HydratedFlexTreeNode): void {
 		assert(!this.disposed, 0xa2a /* cannot hydrate a disposed node */);
 		assert(!isHydrated(this.#hydrationState), 0xa2b /* hydration should only happen once */);
 
-		const anchor = anchors.track(path);
-		const anchorNode =
-			anchors.locate(anchor) ?? fail(0xb42 /* Expected anchor node to be present */);
-
-		this.#hydrationState = this.createHydratedState(anchorNode);
-		this.#hydrationState.offAnchorNode.add(() => anchors.forget(anchor));
+		this.#hydrationState = this.createHydratedState(inner);
 
 		// Lazily migrate existing event listeners to the anchor node
-		this.#eventBuffer.migrateEventSource(anchorNode.events);
+		this.#eventBuffer.migrateEventSource(inner.anchorNode.events);
 	}
 
-	private createHydratedState(anchorNode: AnchorNode): HydratedState {
+	private createHydratedState(innerNode: HydratedFlexTreeNode): HydratedState {
 		assert(
-			!anchorNode.slots.has(simpleTreeNodeSlot),
+			!innerNode.anchorNode.slots.has(simpleTreeNodeSlot),
 			0x7f5 /* Cannot associate an flex node with multiple simple-tree nodes */,
 		);
-		anchorNode.slots.set(simpleTreeNodeSlot, this.node);
+		innerNode.anchorNode.slots.set(simpleTreeNodeSlot, this.node);
 		return {
-			anchorNode,
+			innerNode,
 			offAnchorNode: new Set([
-				anchorNode.events.on("afterDestroy", () => this.dispose()),
+				innerNode.anchorNode.events.on("afterDestroy", () => this.dispose()),
 				// TODO: this should be triggered on change even for unhydrated nodes.
-				anchorNode.events.on("childrenChanging", () => {
+				innerNode.anchorNode.events.on("childrenChanging", () => {
 					this.generationNumber += 1;
 				}),
 			]),
@@ -232,7 +220,7 @@ export class TreeNodeKernel {
 		}
 
 		// TODO: Replace this check with the proper check against the cursor state when the cursor becomes part of the kernel
-		const flex = this.#hydrationState.anchorNode.slots.get(flexTreeSlot);
+		const flex = this.#hydrationState.innerNode.anchorNode.slots.get(flexTreeSlot);
 		if (flex !== undefined) {
 			assert(flex instanceof LazyEntity, 0x9b4 /* Unexpected flex node implementation */);
 			if (flex.isFreed()) {
@@ -240,7 +228,7 @@ export class TreeNodeKernel {
 			}
 		}
 
-		return treeStatusFromAnchorCache(this.#hydrationState.anchorNode);
+		return treeStatusFromAnchorCache(this.#hydrationState.innerNode.anchorNode);
 	}
 
 	public get events(): Listenable<KernelEvents> {
@@ -264,7 +252,9 @@ export class TreeNodeKernel {
 	}
 
 	public get anchorNode(): AnchorNode | undefined {
-		return isHydrated(this.#hydrationState) ? this.#hydrationState.anchorNode : undefined;
+		return isHydrated(this.#hydrationState)
+			? this.#hydrationState.innerNode.anchorNode
+			: undefined;
 	}
 
 	/**
@@ -273,11 +263,10 @@ export class TreeNodeKernel {
 	 * For {@link Unhydrated} nodes, this returns the MapTreeNode.
 	 *
 	 * For hydrated nodes it returns a FlexTreeNode backed by the forest.
-	 * Note that for "marinated" nodes, this FlexTreeNode exists and returns it: it does not return the MapTreeNode which is the current InnerNode.
 	 *
 	 * @throws A {@link @fluidframework/telemetry-utils#UsageError} if the node has been deleted.
 	 */
-	public getOrCreateInnerNode(): InnerNode {
+	public getInnerNode(): InnerNode {
 		if (!isHydrated(this.#hydrationState)) {
 			debugAssert(
 				() =>
@@ -291,26 +280,6 @@ export class TreeNodeKernel {
 			throw new UsageError("Cannot access a deleted node.");
 		}
 
-		if (this.#hydrationState.innerNode === undefined) {
-			// Marinated case -> cooked
-			const anchorNode = this.#hydrationState.anchorNode;
-			// This TreeNode is bound to an anchor node, but it may or may not have an actual flex node yet
-			const flexNode = anchorNode.slots.get(flexTreeSlot);
-			if (flexNode !== undefined) {
-				// If the flex node already exists, use it...
-				this.#hydrationState.innerNode = flexNode;
-			} else {
-				// ...otherwise, the flex node must be created
-				const context =
-					anchorNode.anchorSet.slots.get(ContextSlot) ?? fail(0xb41 /* missing context */);
-				const cursor = context.checkout.forest.allocateCursor("getFlexNode");
-				context.checkout.forest.moveCursorToPath(anchorNode, cursor);
-				this.#hydrationState.innerNode = getOrCreateHydratedFlexTreeNode(context, cursor);
-				cursor.free();
-				assertFlexTreeEntityNotFreed(this.#hydrationState.innerNode);
-			}
-		}
-
 		return this.#hydrationState.innerNode;
 	}
 
@@ -553,10 +522,8 @@ class KernelEventBuffer implements Listenable<KernelEvents> {
 // #endregion
 
 /**
- * For "cooked" nodes this is a HydratedFlexTreeNode thats a projection of forest content.
+ * For hydrated nodes this is a HydratedFlexTreeNode thats a projection of forest content.
  * For {@link Unhydrated} nodes this is a UnhydratedFlexTreeNode.
- *
- * For "marinated" nodes, some code (ex: getOrCreateInnerNode) returns the FlexTreeNode thats a projection of forest content, and some code (ex: tryGetInnerNode) returns undefined.
  */
 export type InnerNode = FlexTreeNode;
 
@@ -621,13 +588,12 @@ export function getSimpleContextFromInnerNode(innerNode: InnerNode): Context {
  * For {@link Unhydrated} nodes, this returns the MapTreeNode.
  *
  * For hydrated nodes it returns a FlexTreeNode backed by the forest.
- * Note that for "marinated" nodes, this FlexTreeNode exists and returns it: it does not return the MapTreeNode which is the current InnerNode.
  *
  * @throws A {@link @fluidframework/telemetry-utils#UsageError} if the node has been deleted.
  */
-export function getOrCreateInnerNode(treeNode: TreeNode): InnerNode {
+export function getInnerNode(treeNode: TreeNode): InnerNode {
 	const kernel = getKernel(treeNode);
-	return kernel.getOrCreateInnerNode();
+	return kernel.getInnerNode();
 }
 
 /**

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/getTreeNodeForField.ts

@@ -40,7 +40,7 @@ export function tryGetTreeNodeForField(
 			return tryToUnboxLeaves(typedField);
 		}
 		case FieldKinds.identifier.identifier: {
-			// Identifier fields are just value fields that hold strings
+			// Identifier fields are just required fields that hold strings
 			return (field as FlexTreeRequiredField).content as string;
 		}