@fluidframework/tree 2.63.0-359461 → 2.63.0-359962

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,
@@ -21,7 +21,7 @@ export {
 	tryDisposeTreeNode,
 	HydratedContext,
 	SimpleContextSlot,
-	getOrCreateInnerNode,
+	getInnerNode,
 	getOrCreateNodeFromInnerNode,
 	getOrCreateNodeFromInnerUnboxedNode,
 	getKernel,
@@ -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,
@@ -122,6 +127,13 @@ export {
 	type ArrayNodeCustomizableSchemaUnsafe,
 	type MapNodeCustomizableSchemaUnsafe,
 	type TreeRecordNodeUnsafe,
+	type UnannotateAllowedTypeUnsafe,
+	type AnnotatedAllowedTypeUnsafe,
+	type AnnotatedAllowedTypesUnsafe,
+	type AllowedTypesFullUnsafe,
+	type AllowedTypesFullFromMixedUnsafe,
+	type UnannotateAllowedTypesListUnsafe,
+	type AnnotateAllowedTypesListUnsafe,
 	type TreeViewAlpha,
 	type TreeBranch,
 	type TreeBranchEvents,
@@ -184,9 +196,7 @@ export type {
 } from "./simpleSchema.js";
 export {
 	type ImplicitFieldSchema,
-	type ImplicitAnnotatedFieldSchema,
 	type TreeFieldFromImplicitField,
-	type UnannotateImplicitFieldSchema,
 	FieldKind,
 	FieldSchema,
 	FieldSchemaAlpha,
@@ -226,7 +236,6 @@ export {
 	ObjectNodeSchema,
 	type ObjectNodeSchemaPrivate,
 	isObjectNodeSchema,
-	type InsertableObjectFromAnnotatedSchemaRecord,
 	type TreeObjectNode,
 	setField,
 	isRecordNodeSchema,
@@ -235,7 +244,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

@@ -25,21 +25,18 @@ import {
 	typeSchemaSymbol,
 	getOrCreateNodeFromInnerNode,
 	getSimpleNodeSchemaFromInnerNode,
-	getOrCreateInnerNode,
+	getInnerNode,
 	type TreeNodeSchemaClass,
 	getKernel,
 	type UnhydratedFlexTreeNode,
 	UnhydratedSequenceField,
 	getOrCreateNodeFromInnerUnboxedNode,
 	normalizeAllowedTypes,
-	unannotateImplicitAllowedTypes,
 	type ImplicitAllowedTypes,
-	type ImplicitAnnotatedAllowedTypes,
 	type InsertableTreeNodeFromImplicitAllowedTypes,
 	type NodeSchemaMetadata,
 	type TreeLeafValue,
 	type TreeNodeFromImplicitAllowedTypes,
-	type UnannotateImplicitAllowedTypes,
 	TreeNodeValid,
 	type MostDerivedData,
 	type TreeNodeSchemaInitializedData,
@@ -480,7 +477,7 @@ export class IterableTreeArrayContent<T> implements Iterable<T> {
  * Given a array node proxy, returns its underlying LazySequence field.
  */
 function getSequenceField(arrayNode: ReadonlyArrayNode): FlexTreeSequenceField {
-	return getOrCreateInnerNode(arrayNode).getBoxed(EmptyKey) as FlexTreeSequenceField;
+	return getInnerNode(arrayNode).getBoxed(EmptyKey) as FlexTreeSequenceField;
 }
 
 // For compatibility, we are initially implement 'readonly T[]' by applying the Array.prototype methods
@@ -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<
@@ -889,7 +886,7 @@ abstract class CustomArrayNodeBase<const T extends ImplicitAllowedTypes>
 		);
 
 		const kernel = getKernel(this);
-		const flexContext = kernel.getOrCreateInnerNode().context;
+		const flexContext = kernel.getInnerNode().context;
 		assert(
 			flexContext === kernel.context.flexContext,
 			0xc14 /* Expected flexContext to match */,
@@ -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 {

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

@@ -26,17 +26,14 @@ import {
 	typeNameSymbol,
 	type TreeNode,
 	typeSchemaSymbol,
-	getOrCreateInnerNode,
+	getInnerNode,
 	type InternalTreeNode,
 	type UnhydratedFlexTreeNode,
 	normalizeAllowedTypes,
-	unannotateImplicitAllowedTypes,
 	type ImplicitAllowedTypes,
-	type ImplicitAnnotatedAllowedTypes,
 	type InsertableTreeNodeFromImplicitAllowedTypes,
 	type NodeSchemaMetadata,
 	type TreeNodeFromImplicitAllowedTypes,
-	type UnannotateImplicitAllowedTypes,
 	TreeNodeValid,
 	type MostDerivedData,
 	type TreeNodeSchemaInitializedData,
@@ -176,7 +173,7 @@ abstract class CustomMapNodeBase<const T extends ImplicitAllowedTypes> extends T
 	}
 
 	private get innerNode(): InnerNode {
-		return getOrCreateInnerNode(this);
+		return getInnerNode(this);
 	}
 
 	private editor(key: string): OptionalFieldEditBuilder<FlexibleNodeContent> {
@@ -245,7 +242,7 @@ abstract class CustomMapNodeBase<const T extends ImplicitAllowedTypes> extends T
 		callbackFn: (value: TreeNodeFromImplicitAllowedTypes<T>, key: string, map: TThis) => void,
 		thisArg?: unknown,
 	): void {
-		for (const field of getOrCreateInnerNode(this)) {
+		for (const field of getInnerNode(this)) {
 			const node = tryGetTreeNodeForField(field) as TreeNodeFromImplicitAllowedTypes<T>;
 			callbackFn.call(thisArg, node, field.key, this);
 		}
@@ -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

@@ -38,11 +38,9 @@ import {
 	type InternalTreeNode,
 	type TreeNode,
 	type UnhydratedFlexTreeNode,
-	getOrCreateInnerNode,
+	getInnerNode,
 	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);
@@ -261,7 +243,7 @@ function createProxyHandler(
 		get(target, propertyKey, proxy): unknown {
 			const fieldInfo = schema.flexKeyMap.get(propertyKey);
 			if (fieldInfo !== undefined) {
-				const flexNode = getOrCreateInnerNode(proxy);
+				const flexNode = getInnerNode(proxy);
 				debugAssert(() => !flexNode.context.isDisposed() || "FlexTreeNode is disposed");
 				const field = flexNode.tryGetField(fieldInfo.storedKey);
 				if (field !== undefined) {
@@ -292,7 +274,7 @@ function createProxyHandler(
 					: false;
 			}
 
-			const innerNode = getOrCreateInnerNode(proxy);
+			const innerNode = getInnerNode(proxy);
 
 			const innerSchema = innerNode.context.schema.nodeSchema.get(brand(schema.identifier));
 			assert(
@@ -339,7 +321,7 @@ function createProxyHandler(
 			// If a refactoring is done to associated flex tree data with the target not the proxy, this extra map could be removed,
 			// and the design would be more compatible with proxyless nodes.
 			const proxy = targetToProxy.get(target) ?? fail(0xadd /* missing proxy */);
-			const field = getOrCreateInnerNode(proxy).tryGetField(fieldInfo.storedKey);
+			const field = getInnerNode(proxy).tryGetField(fieldInfo.storedKey);
 
 			const p: PropertyDescriptor = {
 				value: field === undefined ? undefined : tryGetTreeNodeForField(field),
@@ -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.
  */