@fluidframework/tree 2.63.0-359461 → 2.63.0-359962

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

@@ -15,15 +15,12 @@ import {
 	typeNameSymbol,
 	typeSchemaSymbol,
 	type UnhydratedFlexTreeNode,
-	getOrCreateInnerNode,
+	getInnerNode,
 	getKernel,
 	type InternalTreeNode,
 	type NodeSchemaMetadata,
-	type ImplicitAnnotatedAllowedTypes,
-	type UnannotateImplicitAllowedTypes,
 	type ImplicitAllowedTypes,
 	normalizeAllowedTypes,
-	unannotateImplicitAllowedTypes,
 	type TreeNodeFromImplicitAllowedTypes,
 	TreeNodeValid,
 	type MostDerivedData,
@@ -108,7 +105,7 @@ function createRecordNodeProxy(
 			}
 
 			if (typeof key === "string") {
-				const innerNode = getOrCreateInnerNode(receiver);
+				const innerNode = getInnerNode(receiver);
 				const field = innerNode.tryGetField(brand(key));
 				if (field !== undefined) {
 					return tryGetTreeNodeForField(field);
@@ -122,7 +119,7 @@ function createRecordNodeProxy(
 				return false;
 			}
 
-			const innerNode = getOrCreateInnerNode(receiver);
+			const innerNode = getInnerNode(receiver);
 			const field = innerNode.getBoxed(brand(key)) as FlexTreeOptionalField;
 			const kernel = getKernel(receiver);
 			const innerSchema = innerNode.context.schema.nodeSchema.get(brand(schema.identifier));
@@ -146,13 +143,13 @@ function createRecordNodeProxy(
 				return false;
 			}
 
-			const innerNode = getOrCreateInnerNode(proxy);
+			const innerNode = getInnerNode(proxy);
 			const childField = innerNode.tryGetField(brand(key));
 
 			return childField !== undefined;
 		},
 		ownKeys: (target) => {
-			const innerNode = getOrCreateInnerNode(proxy);
+			const innerNode = getInnerNode(proxy);
 			return [...innerNode.keys()];
 		},
 		getOwnPropertyDescriptor: (target, key) => {
@@ -160,7 +157,7 @@ function createRecordNodeProxy(
 				return undefined;
 			}
 
-			const innerNode = getOrCreateInnerNode(proxy);
+			const innerNode = getInnerNode(proxy);
 			const field = innerNode.tryGetField(brand(key));
 
 			if (field === undefined) {
@@ -182,7 +179,7 @@ function createRecordNodeProxy(
 				return false;
 			}
 
-			const innerNode = getOrCreateInnerNode(proxy);
+			const innerNode = getInnerNode(proxy);
 			const field = innerNode.tryGetField(brand(key)) as FlexTreeOptionalField | undefined;
 			if (field !== undefined) {
 				field.editor.set(undefined, field.length === 0);
@@ -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

@@ -7,7 +7,6 @@ import type {
 	SchemaAndPolicy,
 	IForestSubscription,
 	UpPath,
-	NodeIndex,
 	FieldKey,
 	DetachedField,
 	TreeFieldStoredSchema,
@@ -21,21 +20,25 @@ import {
 	type FlexibleFieldContent,
 	type FlexibleNodeContent,
 	throwOutOfSchema,
+	flexTreeSlot,
+	ContextSlot,
+	getOrCreateHydratedFlexTreeNode,
+	assertFlexTreeEntityNotFreed,
 } from "../feature-libraries/index.js";
-import type { ImplicitAnnotatedFieldSchema } from "./fieldSchema.js";
+import type { ImplicitFieldSchema } from "./fieldSchema.js";
 import {
 	type InsertableContent,
 	unhydratedFlexTreeFromInsertable,
 } from "./unhydratedFlexTreeFromInsertable.js";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
-import { brand } from "../util/index.js";
+import { brand, type Mutable } from "../util/index.js";
 import {
 	getKernel,
-	type ImplicitAnnotatedAllowedTypes,
+	type ImplicitAllowedTypes,
 	type TreeNode,
 	type UnhydratedFlexTreeNode,
 } from "./core/index.js";
-import { debugAssert, oob } from "@fluidframework/core-utils/internal";
+import { debugAssert, fail, oob } from "@fluidframework/core-utils/internal";
 import { isFieldInSchema } from "../feature-libraries/index.js";
 
 /**
@@ -56,7 +59,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 +87,7 @@ export function prepareForInsertion<TIn extends InsertableContent | undefined>(
  */
 export function prepareArrayContentForInsertion(
 	data: readonly InsertableContent[],
-	schema: ImplicitAnnotatedAllowedTypes,
+	schema: ImplicitAllowedTypes,
 	destinationContext: FlexTreeContext,
 	destinationSchema: TreeTypeSet,
 ): FlexibleFieldContent {
@@ -117,15 +120,22 @@ export function prepareArrayContentForInsertion(
  */
 export function prepareForInsertionContextless<TIn extends InsertableContent | undefined>(
 	data: TIn,
-	schema: ImplicitAnnotatedFieldSchema,
+	schema: ImplicitFieldSchema,
 	schemaAndPolicy: SchemaAndPolicy,
 	hydratedData: FlexTreeHydratedContextMinimal | undefined,
 	destinationSchema: TreeFieldStoredSchema,
+	scheduleHydrationOverride?: HydrationScheduler,
 ): TIn extends undefined ? undefined : FlexibleNodeContent {
 	const mapTree = unhydratedFlexTreeFromInsertable(data, schema);
 
 	const contentArray = mapTree === undefined ? [] : [mapTree];
-	validateAndPrepare(schemaAndPolicy, hydratedData, destinationSchema, contentArray);
+	validateAndPrepare(
+		schemaAndPolicy,
+		hydratedData,
+		destinationSchema,
+		contentArray,
+		scheduleHydrationOverride,
+	);
 
 	return mapTree;
 }
@@ -141,12 +151,19 @@ function validateAndPrepare(
 	hydratedData: FlexTreeHydratedContextMinimal | undefined,
 	fieldSchema: TreeFieldStoredSchema,
 	mapTrees: readonly UnhydratedFlexTreeNode[],
+	scheduleHydrationOverride?: HydrationScheduler,
 ): void {
 	if (hydratedData !== undefined) {
 		// Run `prepareContentForHydration` before walking the tree in `isFieldInSchema`.
 		// This ensures that when `isFieldInSchema` requests identifiers (or any other contextual defaults),
 		// they were already creating used the more specific context we have access to from `hydratedData`.
-		prepareContentForHydration(mapTrees, hydratedData.checkout.forest, hydratedData);
+		prepareContentForHydration(
+			mapTrees,
+			scheduleHydrationOverride ??
+				((batch, doHydration) =>
+					scheduleHydration(batch, hydratedData.checkout.forest, doHydration)),
+			hydratedData,
+		);
 		// TODO: AB#45723
 		// Now that staged schema rely on this validation, its a bit odd we don't do it for insertion into unhydrated contexts.
 		// We can't simply enable it for them however due to contextual default fields which would not have been created yet (see comment above).
@@ -157,15 +174,6 @@ function validateAndPrepare(
 	}
 }
 
-/**
- * An {@link UpPath} that is just index zero in a {@link DetachedField} which can be modified at a later time.
- */
-interface Root extends UpPath {
-	readonly parent: undefined;
-	parentField: DetachedField & FieldKey;
-	readonly parentIndex: NodeIndex & 0;
-}
-
 /**
  * The path from the included node to the root of the content tree it was inserted as part of.
  */
@@ -181,7 +189,7 @@ interface LocatedNodesBatch {
 	/**
 	 * UpPath shared by all {@link RelativeNodePath}s in this batch corresponding to the root of the inserted content.
 	 */
-	readonly rootPath: Root;
+	readonly rootPath: Mutable<UpPath>;
 	readonly paths: RelativeNodePath[];
 }
 
@@ -204,7 +212,7 @@ const placeholderKey: DetachedField & FieldKey = brand("placeholder" as const);
  */
 export function prepareContentForHydration(
 	content: readonly UnhydratedFlexTreeNode[],
-	forest: IForestSubscription,
+	scheduler: HydrationScheduler,
 	context: FlexTreeHydratedContextMinimal,
 ): void {
 	const batches: LocatedNodesBatch[] = [];
@@ -228,7 +236,8 @@ export function prepareContentForHydration(
 		);
 	}
 
-	scheduleHydration(batches, forest);
+	const doHydration = hydrator(batches, context.checkout.forest);
+	scheduler(batches, doHydration);
 }
 
 function walkMapTree(
@@ -270,6 +279,23 @@ function walkMapTree(
 	}
 }
 
+/**
+ * A function which can schedule hydration of batches of nodes to occur at a later time (which must be after they have been inserted into the tree).
+ */
+type HydrationScheduler = (
+	locatedNodes: readonly LocatedNodesBatch[],
+	/**
+	 * Does the actual hydration. Should be called for each index in `locatedNodes` once the corresponding content has been inserted into the tree.
+	 */
+	doHydration: Hydrator,
+) => void;
+
+/**
+ * Does the actual hydration.
+ * The provided `attachPath` is the path the content is currently under (where it was attached in the tree).
+ */
+type Hydrator = (batch: LocatedNodesBatch, attachPath: UpPath) => void;
+
 /**
  * Register events which will hydrate batches of nodes when they are inserted.
  * The next edits to forest must be their insertions, in order, or data corruption can occur.
@@ -280,22 +306,58 @@ function walkMapTree(
 function scheduleHydration(
 	locatedNodes: readonly LocatedNodesBatch[],
 	forest: IForestSubscription,
+	doHydration: Hydrator,
 ): void {
 	// Only subscribe to the event if there is at least one TreeNode tree to hydrate - this is not the case when inserting an empty array [].
 	if (locatedNodes.length > 0) {
 		// Creating a new array emits one event per element in the array, so listen to the event once for each element
-		let i = 0;
+		let index = 0;
 		const off = forest.events.on("afterRootFieldCreated", (fieldKey) => {
 			// Indexing is safe here because of the length check above. This assumes the array has not been modified which should be the case.
-			const batch = locatedNodes[i] ?? oob();
-			debugAssert(() => batch.rootPath.parentField === placeholderKey);
-			batch.rootPath.parentField = brand(fieldKey);
-			for (const { path, node } of batch.paths) {
-				getKernel(node).hydrate(forest.anchors, path);
-			}
-			if (++i === locatedNodes.length) {
+			const batch = locatedNodes[index] ?? oob();
+			doHydration(batch, { parent: undefined, parentField: fieldKey, parentIndex: 0 });
+			if (++index === locatedNodes.length) {
 				off();
 			}
 		});
 	}
 }
+
+/**
+ * Implementation of {@link Hydrator}.
+ */
+function hydrator(
+	locatedNodes: readonly LocatedNodesBatch[],
+	forest: IForestSubscription,
+): (batch: LocatedNodesBatch, attachedPath: UpPath) => void {
+	return (batch: LocatedNodesBatch, attachedPath: UpPath) => {
+		const context = forest.anchors.slots.get(ContextSlot) ?? fail(0xb41 /* missing context */);
+
+		// Modify paths in batch to point to correct location:
+		debugAssert(() => batch.rootPath.parentField === placeholderKey);
+		batch.rootPath.parentField = attachedPath.parentField;
+		batch.rootPath.parent = attachedPath.parent;
+		batch.rootPath.parentIndex = attachedPath.parentIndex;
+
+		// To hydrate a TreeNode, it must be associated with a HydratedFlexTreeNode.
+		// Find or create one as necessary.
+		for (const { path, node } of batch.paths) {
+			const anchor = forest.anchors.track(path);
+			const anchorNode = forest.anchors.locate(anchor) ?? fail("missing anchor");
+
+			let flexNode = anchorNode.slots.get(flexTreeSlot);
+			if (flexNode === undefined) {
+				// the flex node must be created
+				const cursor = forest.allocateCursor("getFlexNode");
+				forest.moveCursorToPath(anchorNode, cursor);
+
+				flexNode = getOrCreateHydratedFlexTreeNode(context, cursor);
+				cursor.free();
+				assertFlexTreeEntityNotFreed(flexNode);
+			}
+
+			getKernel(node).hydrate(flexNode);
+			forest.anchors.forget(anchor);
+		}
+	};
+}

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,
 	);