@fluidframework/tree 2.63.0-359286 → 2.63.0-359734

package/src/simple-tree/node-kinds/map/mapNode.ts

@@ -30,13 +30,10 @@ import {
 	type InternalTreeNode,
 	type UnhydratedFlexTreeNode,
 	normalizeAllowedTypes,
-	unannotateImplicitAllowedTypes,
 	type ImplicitAllowedTypes,
-	type ImplicitAnnotatedAllowedTypes,
 	type InsertableTreeNodeFromImplicitAllowedTypes,
 	type NodeSchemaMetadata,
 	type TreeNodeFromImplicitAllowedTypes,
-	type UnannotateImplicitAllowedTypes,
 	TreeNodeValid,
 	type MostDerivedData,
 	type TreeNodeSchemaInitializedData,
@@ -263,7 +260,7 @@ abstract class CustomMapNodeBase<const T extends ImplicitAllowedTypes> extends T
 // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
 export function mapSchema<
 	TName extends string,
-	const T extends ImplicitAnnotatedAllowedTypes,
+	const T extends ImplicitAllowedTypes,
 	const ImplicitlyConstructable extends boolean,
 	const TCustomMetadata = unknown,
 >(
@@ -274,19 +271,14 @@ export function mapSchema<
 	metadata?: NodeSchemaMetadata<TCustomMetadata>,
 	persistedMetadata?: JsonCompatibleReadOnlyObject | undefined,
 ) {
-	const lazyChildTypes = new Lazy(() =>
-		normalizeAllowedTypes(unannotateImplicitAllowedTypes(info)),
-	);
+	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;
 
-	class Schema
-		extends CustomMapNodeBase<UnannotateImplicitAllowedTypes<T>>
-		implements TreeMapNode<UnannotateImplicitAllowedTypes<T>>
-	{
+	class Schema extends CustomMapNodeBase<T> implements TreeMapNode<T> {
 		public static override prepareInstance<T2>(
 			this: typeof TreeNodeValid<T2>,
 			instance: TreeNodeValid<T2>,
@@ -325,7 +317,7 @@ export function mapSchema<
 		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 =

package/src/simple-tree/node-kinds/map/mapNodeTypes.ts

@@ -10,8 +10,7 @@ import type {
 	TreeNodeSchema,
 	TreeNodeSchemaNonClass,
 	WithType,
-	ImplicitAnnotatedAllowedTypes,
-	UnannotateImplicitAllowedTypes,
+	ImplicitAllowedTypes,
 } from "../../core/index.js";
 
 import type { SimpleMapNodeSchema } from "../../simpleSchema.js";
@@ -22,14 +21,14 @@ import type { SimpleMapNodeSchema } from "../../simpleSchema.js";
  */
 export interface MapNodeCustomizableSchema<
 	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.Map,
-			TreeMapNode<UnannotateImplicitAllowedTypes<T>> & WithType<TName, NodeKind.Map, T>,
-			MapNodeInsertableData<UnannotateImplicitAllowedTypes<T>>,
+			TreeMapNode<T> & WithType<TName, NodeKind.Map, T>,
+			MapNodeInsertableData<T>,
 			ImplicitlyConstructable,
 			T,
 			undefined,
@@ -43,14 +42,14 @@ export interface MapNodeCustomizableSchema<
  */
 export interface MapNodePojoEmulationSchema<
 	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.Map,
-			TreeMapNode<UnannotateImplicitAllowedTypes<T>> & WithType<TName, NodeKind.Map, T>,
-			MapNodeInsertableData<UnannotateImplicitAllowedTypes<T>>,
+			TreeMapNode<T> & WithType<TName, NodeKind.Map, T>,
+			MapNodeInsertableData<T>,
 			ImplicitlyConstructable,
 			T,
 			undefined,

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

@@ -5,7 +5,6 @@
 
 export {
 	type FieldHasDefault,
-	type InsertableObjectFromAnnotatedSchemaRecord,
 	type InsertableObjectFromSchemaRecord,
 	type ObjectFromSchemaRecord,
 	objectSchema,
@@ -17,5 +16,4 @@ export {
 	isObjectNodeSchema,
 	ObjectNodeSchema,
 	type ObjectNodeSchemaPrivate,
-	type UnannotateSchemaRecord,
 } from "./objectNodeTypes.js";

package/src/simple-tree/node-kinds/object/objectNode.ts

@@ -41,8 +41,6 @@ import {
 	getOrCreateInnerNode,
 	type NodeSchemaMetadata,
 	type ImplicitAllowedTypes,
-	type ImplicitAnnotatedAllowedTypes,
-	unannotateImplicitAllowedTypes,
 	TreeNodeValid,
 	type MostDerivedData,
 	type TreeNodeSchemaInitializedData,
@@ -63,7 +61,6 @@ import type {
 	ObjectNodeSchema,
 	ObjectNodeSchemaInternalData,
 	ObjectNodeSchemaPrivate,
-	UnannotateSchemaRecord,
 } from "./objectNodeTypes.js";
 import { prepareForInsertion } from "../../prepareForInsertion.js";
 import {
@@ -72,11 +69,10 @@ import {
 	getExplicitStoredKey,
 	type TreeFieldFromImplicitField,
 	type InsertableTreeFieldFromImplicitField,
-	FieldSchema,
+	type FieldSchema,
 	FieldSchemaAlpha,
 	normalizeFieldSchema,
 	FieldKind,
-	type ImplicitAnnotatedFieldSchema,
 	type FieldProps,
 	type ContextualFieldProvider,
 	extractFieldProvider,
@@ -194,18 +190,6 @@ export type InsertableObjectFromSchemaRecord<
 			}
 		>;
 
-/**
- * Helper used to remove annotations from a schema record and produce insertable objects,
- *
- * @privateRemarks
- * This calls {@link InsertableObjectFromSchemaRecord} in order to produce the insertable objects.
- *
- * @system @alpha
- */
-export type InsertableObjectFromAnnotatedSchemaRecord<
-	T extends RestrictiveStringRecord<ImplicitAnnotatedFieldSchema>,
-> = InsertableObjectFromSchemaRecord<UnannotateSchemaRecord<T>>;
-
 /**
  * Maps from simple field keys ("property" keys) to information about the field.
  *
@@ -222,9 +206,7 @@ export type SimpleKeyMap = ReadonlyMap<
 /**
  * Caches the mappings from property keys to stored keys for the provided object field schemas in {@link simpleKeyToFlexKeyCache}.
  */
-function createFlexKeyMapping(
-	fields: Record<string, ImplicitAnnotatedFieldSchema>,
-): SimpleKeyMap {
+function createFlexKeyMapping(fields: Record<string, ImplicitFieldSchema>): SimpleKeyMap {
 	const keyMap: Map<string | symbol, { storedKey: FieldKey; schema: FieldSchema }> = new Map();
 	for (const [propertyKey, fieldSchema] of Object.entries(fields)) {
 		const schema = normalizeFieldSchema(fieldSchema);
@@ -404,10 +386,9 @@ export class ObjectFieldSchema<
 	public constructor(
 		kind: Kind,
 		allowedTypes: Types,
-		annotatedTypes: ImplicitAnnotatedAllowedTypes,
 		props: FieldProps<TCustomMetadata> & { readonly key: string },
 	) {
-		super(kind, allowedTypes, annotatedTypes, props);
+		super(kind, allowedTypes, props);
 		this.storedKey = props.key;
 	}
 }
@@ -427,7 +408,7 @@ abstract class CustomObjectNodeBase<
  */
 export function objectSchema<
 	TName extends string,
-	const T extends RestrictiveStringRecord<ImplicitAnnotatedFieldSchema>,
+	const T extends RestrictiveStringRecord<ImplicitFieldSchema>,
 	const ImplicitlyConstructable extends boolean,
 	const TCustomMetadata = unknown,
 >(
@@ -466,22 +447,17 @@ export function objectSchema<
 	let handler: ProxyHandler<object>;
 	let customizable: boolean;
 
-	class CustomObjectNode extends CustomObjectNodeBase<UnannotateSchemaRecord<T>> {
+	class CustomObjectNode extends CustomObjectNodeBase<T> {
 		public static readonly fields: ReadonlyMap<
 			string,
 			FieldSchemaAlpha & SimpleObjectFieldSchema
 		> = new Map(
 			Array.from(flexKeyMap, ([key, value]) => [
 				key as string,
-				new ObjectFieldSchema(
-					value.schema.kind,
-					value.schema.allowedTypes,
-					(value.schema as FieldSchemaAlpha).annotatedAllowedTypes,
-					{
-						...value.schema.props,
-						key: getStoredKey(key as string, value.schema),
-					},
-				),
+				new ObjectFieldSchema(value.schema.kind, value.schema.allowedTypes, {
+					...value.schema.props,
+					key: getStoredKey(key as string, value.schema),
+				}),
 			]),
 		);
 		public static readonly flexKeyMap: SimpleKeyMap = flexKeyMap;
@@ -602,7 +578,7 @@ export function objectSchema<
 				this,
 				Array.from(
 					flexKeyMap.values(),
-					({ schema }) => normalizeFieldSchema(schema).annotatedAllowedTypes,
+					({ schema }) => normalizeFieldSchema(schema).allowedTypes,
 				),
 				(storedOptions) => {
 					const fields: Map<FieldKey, TreeFieldStoredSchema> = new Map();
@@ -623,25 +599,11 @@ export function objectSchema<
 	}
 	type Output = typeof CustomObjectNode &
 		(new (
-			input: InsertableObjectFromAnnotatedSchemaRecord<T> | InternalTreeNode,
-		) => TreeObjectNode<UnannotateSchemaRecord<T>, TName>);
+			input: InsertableObjectFromSchemaRecord<T> | InternalTreeNode,
+		) => TreeObjectNode<T, TName>);
 	return CustomObjectNode as Output;
 }
 
-/**
- * Removes annotations from a schema record.
- */
-export function unannotateSchemaRecord<
-	Schema extends RestrictiveStringRecord<ImplicitAnnotatedFieldSchema>,
->(schemaRecord: Schema): UnannotateSchemaRecord<Schema> {
-	return Object.fromEntries(
-		Object.entries(schemaRecord).map(([key, schema]) => [
-			key,
-			schema instanceof FieldSchema ? schema : unannotateImplicitAllowedTypes(schema),
-		]),
-	) as UnannotateSchemaRecord<Schema>;
-}
-
 const targetToProxy: WeakMap<object, TreeNode> = new WeakMap();
 
 /**
@@ -651,7 +613,7 @@ const targetToProxy: WeakMap<object, TreeNode> = new WeakMap();
  */
 function assertUniqueKeys<
 	const Name extends number | string,
-	const Fields extends RestrictiveStringRecord<ImplicitAnnotatedFieldSchema>,
+	const Fields extends RestrictiveStringRecord<ImplicitFieldSchema>,
 >(schemaName: Name, fields: Fields): void {
 	// Verify that there are no duplicates among the explicitly specified stored keys.
 	const explicitStoredKeys = new Set<string>();

package/src/simple-tree/node-kinds/object/objectNodeTypes.ts

@@ -7,13 +7,9 @@ import type { RestrictiveStringRecord } from "../../../util/index.js";
 import type {
 	TreeObjectNode,
 	SimpleKeyMap,
-	InsertableObjectFromAnnotatedSchemaRecord,
+	InsertableObjectFromSchemaRecord,
 } from "./objectNode.js";
-import type {
-	FieldSchemaAlpha,
-	ImplicitAnnotatedFieldSchema,
-	UnannotateImplicitFieldSchema,
-} from "../../fieldSchema.js";
+import type { FieldSchemaAlpha, ImplicitFieldSchema } from "../../fieldSchema.js";
 import {
 	NodeKind,
 	type TreeNodeSchemaClass,
@@ -31,14 +27,14 @@ import type { SimpleObjectFieldSchema, SimpleObjectNodeSchema } from "../../simp
 export interface ObjectNodeSchema<
 	out TName extends string = string,
 	in out T extends
-		RestrictiveStringRecord<ImplicitAnnotatedFieldSchema> = RestrictiveStringRecord<ImplicitAnnotatedFieldSchema>,
+		RestrictiveStringRecord<ImplicitFieldSchema> = RestrictiveStringRecord<ImplicitFieldSchema>,
 	ImplicitlyConstructable extends boolean = boolean,
 	out TCustomMetadata = unknown,
 > extends TreeNodeSchemaClass<
 			TName,
 			NodeKind.Object,
-			TreeObjectNode<UnannotateSchemaRecord<T>, TName>,
-			InsertableObjectFromAnnotatedSchemaRecord<T>,
+			TreeObjectNode<T, TName>,
+			InsertableObjectFromSchemaRecord<T>,
 			ImplicitlyConstructable,
 			T,
 			never,
@@ -51,16 +47,6 @@ export interface ObjectNodeSchema<
 	readonly fields: ReadonlyMap<string, FieldSchemaAlpha & SimpleObjectFieldSchema>;
 }
 
-/**
- * Removes annotations from field schemas in a schema record.
- * @system @alpha
- */
-export type UnannotateSchemaRecord<
-	T extends RestrictiveStringRecord<ImplicitAnnotatedFieldSchema>,
-> = {
-	readonly [P in Extract<keyof T, string>]: UnannotateImplicitFieldSchema<T[P]>;
-};
-
 /**
  * Extra data provided on all {@link ObjectNodeSchema} that is not included in the (soon possibly public) ObjectNodeSchema type.
  */

package/src/simple-tree/node-kinds/record/recordNode.ts

@@ -19,11 +19,8 @@ import {
 	getKernel,
 	type InternalTreeNode,
 	type NodeSchemaMetadata,
-	type ImplicitAnnotatedAllowedTypes,
-	type UnannotateImplicitAllowedTypes,
 	type ImplicitAllowedTypes,
 	normalizeAllowedTypes,
-	unannotateImplicitAllowedTypes,
 	type TreeNodeFromImplicitAllowedTypes,
 	TreeNodeValid,
 	type MostDerivedData,
@@ -212,7 +209,7 @@ abstract class CustomRecordNodeBase<
  */
 export interface RecordSchemaOptions<
 	TName extends string,
-	TAllowedTypes extends ImplicitAnnotatedAllowedTypes,
+	TAllowedTypes extends ImplicitAllowedTypes,
 	TImplicitlyConstructable extends boolean,
 	TCustomMetadata = unknown,
 > {
@@ -250,7 +247,7 @@ export interface RecordSchemaOptions<
 // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
 export function recordSchema<
 	TName extends string,
-	const TAllowedTypes extends ImplicitAnnotatedAllowedTypes,
+	const TAllowedTypes extends ImplicitAllowedTypes,
 	const TImplicitlyConstructable extends boolean,
 	const TCustomMetadata = unknown,
 >(
@@ -261,8 +258,6 @@ export function recordSchema<
 		TCustomMetadata
 	>,
 ) {
-	type TUnannotatedAllowedTypes = UnannotateImplicitAllowedTypes<TAllowedTypes>;
-
 	const {
 		identifier,
 		info,
@@ -272,23 +267,21 @@ export function recordSchema<
 		persistedMetadata,
 	} = options;
 
-	const lazyChildTypes = new Lazy(() =>
-		normalizeAllowedTypes(unannotateImplicitAllowedTypes(info)),
-	);
+	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;
 
 	class Schema
-		extends CustomRecordNodeBase<TUnannotatedAllowedTypes>
-		implements TreeRecordNode<TUnannotatedAllowedTypes>
+		extends CustomRecordNodeBase<TAllowedTypes>
+		implements TreeRecordNode<TAllowedTypes>
 	{
 		/**
 		 * Record-like index signature for the node.
 		 */
-		[key: string]: TreeNodeFromImplicitAllowedTypes<TUnannotatedAllowedTypes>;
+		[key: string]: TreeNodeFromImplicitAllowedTypes<TAllowedTypes>;
 
 		public static override prepareInstance<T2>(
 			this: typeof TreeNodeValid<T2>,
@@ -374,7 +367,7 @@ export function recordSchema<
 		public static readonly implicitlyConstructable: TImplicitlyConstructable =
 			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 =
@@ -389,7 +382,7 @@ export function recordSchema<
 		}
 
 		public [Symbol.iterator](): IterableIterator<
-			[string, TreeNodeFromImplicitAllowedTypes<TUnannotatedAllowedTypes>]
+			[string, TreeNodeFromImplicitAllowedTypes<TAllowedTypes>]
 		> {
 			return recordIterator(this);
 		}

package/src/simple-tree/node-kinds/record/recordNodeTypes.ts

@@ -11,10 +11,8 @@ import type {
 	WithType,
 	TreeNode,
 	ImplicitAllowedTypes,
-	ImplicitAnnotatedAllowedTypes,
 	InsertableTreeNodeFromImplicitAllowedTypes,
 	TreeNodeFromImplicitAllowedTypes,
-	UnannotateImplicitAllowedTypes,
 } from "../../core/index.js";
 
 import type { SimpleRecordNodeSchema } from "../../simpleSchema.js";
@@ -56,15 +54,14 @@ export type RecordNodeInsertableData<T extends ImplicitAllowedTypes> = Restricti
  */
 export interface RecordNodeCustomizableSchema<
 	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<
 			/* Name */ TName,
 			/* Kind */ NodeKind.Record,
-			/* TNode */ TreeRecordNode<UnannotateImplicitAllowedTypes<T>> &
-				WithType<TName, NodeKind.Record, T>,
-			/* TInsertable */ RecordNodeInsertableData<UnannotateImplicitAllowedTypes<T>>,
+			/* TNode */ TreeRecordNode<T> & WithType<TName, NodeKind.Record, T>,
+			/* TInsertable */ RecordNodeInsertableData<T>,
 			/* ImplicitlyConstructable */ ImplicitlyConstructable,
 			/* Info */ T,
 			/* TConstructorExtra */ never,
@@ -78,15 +75,14 @@ export interface RecordNodeCustomizableSchema<
  */
 export interface RecordNodePojoEmulationSchema<
 	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<
 			/* Name */ TName,
 			/* Kind */ NodeKind.Record,
-			/* TNode */ TreeRecordNode<UnannotateImplicitAllowedTypes<T>> &
-				WithType<TName, NodeKind.Record, T>,
-			/* TInsertable */ RecordNodeInsertableData<UnannotateImplicitAllowedTypes<T>>,
+			/* TNode */ TreeRecordNode<T> & WithType<TName, NodeKind.Record, T>,
+			/* TInsertable */ RecordNodeInsertableData<T>,
 			/* ImplicitlyConstructable */ ImplicitlyConstructable,
 			/* Info */ T,
 			/* TConstructorExtra */ never,
@@ -104,7 +100,7 @@ export interface RecordNodePojoEmulationSchema<
  */
 export type RecordNodeSchema<
 	TName extends string = string,
-	T extends ImplicitAnnotatedAllowedTypes = ImplicitAnnotatedAllowedTypes,
+	T extends ImplicitAllowedTypes = ImplicitAllowedTypes,
 	ImplicitlyConstructable extends boolean = true,
 	TCustomMetadata = unknown,
 > =

package/src/simple-tree/prepareForInsertion.ts

@@ -22,7 +22,7 @@ import {
 	type FlexibleNodeContent,
 	throwOutOfSchema,
 } from "../feature-libraries/index.js";
-import type { ImplicitAnnotatedFieldSchema } from "./fieldSchema.js";
+import type { ImplicitFieldSchema } from "./fieldSchema.js";
 import {
 	type InsertableContent,
 	unhydratedFlexTreeFromInsertable,
@@ -31,7 +31,7 @@ import { UsageError } from "@fluidframework/telemetry-utils/internal";
 import { brand } from "../util/index.js";
 import {
 	getKernel,
-	type ImplicitAnnotatedAllowedTypes,
+	type ImplicitAllowedTypes,
 	type TreeNode,
 	type UnhydratedFlexTreeNode,
 } from "./core/index.js";
@@ -56,7 +56,7 @@ const validateSchema = true;
  */
 export function prepareForInsertion<TIn extends InsertableContent | undefined>(
 	data: TIn,
-	schema: ImplicitAnnotatedFieldSchema,
+	schema: ImplicitFieldSchema,
 	destinationContext: FlexTreeContext,
 	destinationSchema: TreeFieldStoredSchema,
 ): TIn extends undefined ? undefined : FlexibleNodeContent {
@@ -84,7 +84,7 @@ export function prepareForInsertion<TIn extends InsertableContent | undefined>(
  */
 export function prepareArrayContentForInsertion(
 	data: readonly InsertableContent[],
-	schema: ImplicitAnnotatedAllowedTypes,
+	schema: ImplicitAllowedTypes,
 	destinationContext: FlexTreeContext,
 	destinationSchema: TreeTypeSet,
 ): FlexibleFieldContent {
@@ -117,7 +117,7 @@ export function prepareArrayContentForInsertion(
  */
 export function prepareForInsertionContextless<TIn extends InsertableContent | undefined>(
 	data: TIn,
-	schema: ImplicitAnnotatedFieldSchema,
+	schema: ImplicitFieldSchema,
 	schemaAndPolicy: SchemaAndPolicy,
 	hydratedData: FlexTreeHydratedContextMinimal | undefined,
 	destinationSchema: TreeFieldStoredSchema,

package/src/simple-tree/toStoredSchema.ts

@@ -35,7 +35,6 @@ import {
 	FieldKind,
 	FieldSchemaAlpha,
 	normalizeFieldSchema,
-	type ImplicitAnnotatedFieldSchema,
 	type ImplicitFieldSchema,
 } from "./fieldSchema.js";
 import type { SimpleFieldSchema, SimpleNodeSchema } from "./simpleSchema.js";
@@ -55,23 +54,23 @@ export const permissiveStoredSchemaGenerationOptions: StoredSchemaGenerationOpti
 };
 
 /**
- * Converts a {@link ImplicitAnnotatedFieldSchema} into a {@link TreeStoredSchema} for use in schema upgrades.
+ * Converts a {@link ImplicitFieldSchema} into a {@link TreeStoredSchema} for use in schema upgrades.
  *
  * TODO: once upgrades are more flexible, this should take in more options, including the old schema and specific upgrades to enable.
  */
-export function toUpgradeSchema(root: ImplicitAnnotatedFieldSchema): TreeStoredSchema {
+export function toUpgradeSchema(root: ImplicitFieldSchema): TreeStoredSchema {
 	return toStoredSchema(root, restrictiveStoredSchemaGenerationOptions);
 }
 
 /**
- * Converts a {@link ImplicitAnnotatedFieldSchema} into a {@link TreeStoredSchema} for use as initial document schema.
+ * Converts a {@link ImplicitFieldSchema} into a {@link TreeStoredSchema} for use as initial document schema.
  */
-export function toInitialSchema(root: ImplicitAnnotatedFieldSchema): TreeStoredSchema {
+export function toInitialSchema(root: ImplicitFieldSchema): TreeStoredSchema {
 	return toStoredSchema(root, restrictiveStoredSchemaGenerationOptions);
 }
 
 /**
- * Converts a {@link ImplicitAnnotatedFieldSchema} into a {@link TreeStoredSchema} to used for unhydrated nodes.
+ * Converts a {@link ImplicitFieldSchema} into a {@link TreeStoredSchema} to used for unhydrated nodes.
  * @remarks
  * This allows as much as possible, relying on further validation when inserting the content.
  *
@@ -80,7 +79,7 @@ export function toInitialSchema(root: ImplicitAnnotatedFieldSchema): TreeStoredS
 export const toUnhydratedSchema = permissiveStoredSchemaGenerationOptions;
 
 /**
- * Converts a {@link ImplicitAnnotatedFieldSchema} into a {@link TreeStoredSchema}.
+ * Converts a {@link ImplicitFieldSchema} into a {@link TreeStoredSchema}.
  *
  * @privateRemarks
  * TODO:#38722 When runtime schema upgrades are implemented, this will need to be updated to check if
@@ -90,7 +89,7 @@ export const toUnhydratedSchema = permissiveStoredSchemaGenerationOptions;
  * Throws a `UsageError` if multiple schemas are encountered with the same identifier.
  */
 export function toStoredSchema(
-	root: ImplicitAnnotatedFieldSchema,
+	root: ImplicitFieldSchema,
 	options: StoredSchemaGenerationOptions,
 ): TreeStoredSchema {
 	const cache = getOrCreate(viewToStoredCache, options, () => new WeakMap());
@@ -138,7 +137,7 @@ export function convertField(
 	let types: TreeTypeSet;
 	// eslint-disable-next-line unicorn/prefer-ternary
 	if (schema instanceof FieldSchemaAlpha) {
-		types = convertAllowedTypes(schema.annotatedAllowedTypesNormalized, options);
+		types = convertAllowedTypes(schema.allowedTypes, options);
 	} else {
 		types = schema.allowedTypesIdentifiers as TreeTypeSet;
 	}

package/src/simple-tree/unhydratedFlexTreeFromInsertable.ts

@@ -9,11 +9,7 @@ import { assert } from "@fluidframework/core-utils/internal";
 
 import { hasSingle } from "../util/index.js";
 
-import {
-	normalizeFieldSchema,
-	FieldKind,
-	type ImplicitAnnotatedFieldSchema,
-} from "./fieldSchema.js";
+import { normalizeFieldSchema, FieldKind, type ImplicitFieldSchema } from "./fieldSchema.js";
 import {
 	CompatibilityLevel,
 	getKernel,
@@ -54,7 +50,7 @@ import { getUnhydratedContext } from "./createContext.js";
  */
 export function unhydratedFlexTreeFromInsertable<TIn extends InsertableContent | undefined>(
 	data: TIn,
-	allowedTypes: ImplicitAnnotatedFieldSchema,
+	allowedTypes: ImplicitFieldSchema,
 ): TIn extends undefined ? undefined : UnhydratedFlexTreeNode {
 	const normalizedFieldSchema = normalizeFieldSchema(allowedTypes);
 

package/src/simple-tree/unsafeUnknownSchema.ts

@@ -17,8 +17,8 @@ import type { InsertableContent } from "./unhydratedFlexTreeFromInsertable.js";
  * {@inheritdoc (UnsafeUnknownSchema:type)}
  * @alpha
  */
-
 export const UnsafeUnknownSchema: unique symbol = Symbol("UnsafeUnknownSchema");
+
 /**
  * A special type which can be provided to some APIs as the schema type parameter when schema cannot easily be provided at compile time and an unsafe (instead of disabled) editing API is desired.
  * @remarks
@@ -37,8 +37,8 @@ export const UnsafeUnknownSchema: unique symbol = Symbol("UnsafeUnknownSchema");
  * This is currently only type exported from the package: the symbol is just used as a way to get a named type.
  * @alpha
  */
-
 export type UnsafeUnknownSchema = typeof UnsafeUnknownSchema;
+
 /**
  * Content which could be inserted into a tree.
  *
@@ -47,7 +47,6 @@ export type UnsafeUnknownSchema = typeof UnsafeUnknownSchema;
  * Extended version of {@link InsertableTreeNodeFromImplicitAllowedTypes} that also allows {@link (UnsafeUnknownSchema:type)}.
  * @alpha
  */
-
 export type Insertable<TSchema extends ImplicitAllowedTypes | UnsafeUnknownSchema> =
 	TSchema extends ImplicitAllowedTypes
 		? InsertableTreeNodeFromImplicitAllowedTypes<TSchema>

package/src/simple-tree/walkFieldSchema.ts

@@ -16,7 +16,7 @@ export function walkFieldSchema(
 	visitedSet: Set<TreeNodeSchema> = new Set(),
 ): void {
 	walkAllowedTypes(
-		normalizeFieldSchema(schema).annotatedAllowedTypesNormalized,
+		normalizeFieldSchema(schema).allowedTypesFull.evaluate(),
 		visitor,
 		visitedSet,
 	);