@fluidframework/tree 2.51.0-347100 → 2.52.0

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

@@ -28,34 +28,36 @@ import { walkAllowedTypes } from "./walkSchema.js";
  * This design is the same as {@link FlexTreeContext} with its base type and {@link FlexTreeHydratedContext} extending it.
  */
 export class Context {
-	/**
-	 * All schema which could transitively be used under the associated node.
-	 * @remarks
-	 * While generally {@link TreeNodeSchema} are referenced as objects and thus do not need to be looked up by identifier,
-	 * there are a few cases (mainly constructing new TreeNodes from existing tree data) where such a lookup is useful.
-	 * Having this map in the context addresses this use-case.
-	 * @privateRemarks
-	 * This design mirrors how {@link FlexTreeSchema} are accessed off the {@link FlexTreeContext}, making the migration away from them simpler.
-	 */
-	public readonly schema: ReadonlyMap<TreeNodeSchemaIdentifier, TreeNodeSchema>;
-
-	/**
-	 * Builds the context.
-	 * @remarks
-	 * Since this walks the schema, it must not be invoked during schema declaration or schema forward references could fail to be resolved.
-	 */
-	public constructor(
+	public static schemaMapFromRootSchema(
 		rootSchema: NormalizedAnnotatedAllowedTypes,
-		public readonly flexContext: FlexTreeContext,
-	) {
+	): ReadonlyMap<TreeNodeSchemaIdentifier, TreeNodeSchema> {
 		const schema: Map<TreeNodeSchemaIdentifier, TreeNodeSchema> = new Map();
 		walkAllowedTypes(rootSchema, {
 			node(nodeSchema) {
 				schema.set(brand(nodeSchema.identifier), nodeSchema);
 			},
 		});
-		this.schema = schema;
+		return schema;
 	}
+
+	/**
+	 * Builds the context.
+	 * @remarks
+	 * Since this walks the schema, it must not be invoked during schema declaration or schema forward references could fail to be resolved.
+	 */
+	public constructor(
+		public readonly flexContext: FlexTreeContext,
+		/**
+		 * All schema which could transitively be used under the associated node.
+		 * @remarks
+		 * While generally {@link TreeNodeSchema} are referenced as objects and thus do not need to be looked up by identifier,
+		 * there are a few cases (mainly constructing new TreeNodes from existing tree data) where such a lookup is useful.
+		 * Having this map in the context addresses this use-case.
+		 * @privateRemarks
+		 * This design mirrors how {@link FlexTreeSchema} are accessed off the {@link FlexTreeContext}, making the migration away from them simpler.
+		 */
+		public readonly schema: ReadonlyMap<TreeNodeSchemaIdentifier, TreeNodeSchema>,
+	) {}
 }
 
 /**
@@ -64,9 +66,9 @@ export class Context {
  */
 export class HydratedContext extends Context {
 	public constructor(
-		rootSchema: NormalizedAnnotatedAllowedTypes,
 		public override readonly flexContext: FlexTreeHydratedContext,
+		schema: ReadonlyMap<TreeNodeSchemaIdentifier, TreeNodeSchema>,
 	) {
-		super(rootSchema, flexContext);
+		super(flexContext, schema);
 	}
 }

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

@@ -53,6 +53,7 @@ export {
 	isAnnotatedAllowedType,
 	normalizeAllowedTypes,
 	normalizeAnnotatedAllowedTypes,
+	normalizeToAnnotatedAllowedType,
 	unannotateImplicitAllowedTypes,
 	markSchemaMostDerived,
 	evaluateLazySchema,
@@ -76,7 +77,7 @@ export type {
 	AllowedTypeMetadata,
 	AnnotatedAllowedTypes,
 } from "./allowedTypes.js";
-export { walkAllowedTypes, type SchemaVisitor } from "./walkSchema.js";
+export { walkAllowedTypes, walkNodeSchema, type SchemaVisitor } from "./walkSchema.js";
 export { Context, HydratedContext } from "./context.js";
 export {
 	getOrCreateNodeFromInnerNode,

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

@@ -131,7 +131,7 @@ export class TreeNodeKernel {
 	/**
 	 * Create a TreeNodeKernel which can be looked up with {@link getKernel}.
 	 *
-	 * @param initialContext - context from when this node was originally crated.
+	 * @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.
 	 * @remarks
 	 * Exactly one kernel per TreeNode should be created.

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

@@ -10,7 +10,7 @@ import { type FlexTreeNode, isFlexTreeNode } from "../../feature-libraries/index
 
 import { markEager } from "./flexList.js";
 import { inPrototypeChain, privateToken, TreeNode } from "./treeNode.js";
-import type { UnhydratedFlexTreeNode } from "./unhydratedFlexTree.js";
+import { UnhydratedFlexTreeNode } from "./unhydratedFlexTree.js";
 import {
 	NodeKind,
 	type TreeNodeSchema,
@@ -193,10 +193,17 @@ export abstract class TreeNodeValid<TInput> extends TreeNode {
 		);
 
 		const result = schema.prepareInstance(this, node);
+		// For unhydrated nodes, grab the context from the `simpleContext` (which likely is from cache.oneTimeInitialized.context,
+		// but might be customized for better schema evolution support like unknown optional fields like in clone)
+		// For hydrated nodes, this context is unused, so using the default from cache.oneTimeInitialized.context is always fine.
+		const context =
+			node instanceof UnhydratedFlexTreeNode
+				? node.simpleContext
+				: cache.oneTimeInitialized.context;
 		// The TreeNodeKernel associates itself the TreeNode (result here, not node) so it can be looked up later via getKernel.
 		// If desired this could be put in a non-enumerable symbol property for lookup instead, but that gets messy going through proxies,
 		// so just relying on the WeakMap seems like the cleanest approach.
-		new TreeNodeKernel(result, schema, node, cache.oneTimeInitialized.context);
+		new TreeNodeKernel(result, schema, node, context);
 
 		return result;
 	}

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

@@ -11,6 +11,7 @@ import { getTreeNodeSchemaPrivateData, type TreeNodeSchema } from "./treeNodeSch
 
 /**
  * Traverses all {@link TreeNodeSchema} schema reachable from `schema`, applying the visitor pattern.
+ * @internal
  */
 export function walkNodeSchema(
 	schema: TreeNodeSchema,
@@ -42,6 +43,7 @@ export function walkNodeSchema(
 
 /**
  * Traverses all {@link TreeNodeSchema} schema reachable from `allowedTypes`, applying the visitor pattern.
+ * @internal
  */
 export function walkAllowedTypes(
 	annotatedAllowedTypes: NormalizedAnnotatedAllowedTypes,
@@ -56,6 +58,7 @@ export function walkAllowedTypes(
 
 /**
  * Callbacks for use in {@link walkFieldSchema} / {@link walkAllowedTypes} / {@link walkNodeSchema}.
+ * @internal
  */
 export interface SchemaVisitor {
 	/**

package/src/simple-tree/createContext.ts

@@ -21,13 +21,18 @@ const contextCache: WeakMap<ImplicitFieldSchema, Context> = new WeakMap();
 
 /**
  * Utility for creating {@link Context}s for unhydrated nodes.
+ * @remarks
+ * The resulting context will not allow any unknown optional fields.
  */
 export function getUnhydratedContext(schema: ImplicitFieldSchema): Context {
 	return getOrCreate(contextCache, schema, (s) => {
 		const normalized = normalizeFieldSchema(schema);
 
 		const flexContext = new UnhydratedContext(defaultSchemaPolicy, toStoredSchema(schema));
-		return new Context(normalized.annotatedAllowedTypesNormalized, flexContext);
+		return new Context(
+			flexContext,
+			Context.schemaMapFromRootSchema(normalized.annotatedAllowedTypesNormalized),
+		);
 	});
 }
 

package/src/simple-tree/fieldSchema.ts

@@ -488,6 +488,7 @@ export class FieldSchemaAlpha<
 
 /**
  * Normalizes a {@link ImplicitFieldSchema} or {@link ImplicitAnnotatedFieldSchema} to a {@link FieldSchema}.
+ * @internal
  */
 export function normalizeFieldSchema(
 	schema: ImplicitFieldSchema | ImplicitAnnotatedFieldSchema,

package/src/simple-tree/index.ts

@@ -54,7 +54,11 @@ export {
 	type FlexList,
 	type FlexListToUnion,
 	type ExtractItemType,
+	walkNodeSchema,
+	walkAllowedTypes,
+	type SchemaVisitor,
 } from "./core/index.js";
+export { walkFieldSchema } from "./walkFieldSchema.js";
 export type { UnsafeUnknownSchema, Insertable } from "./unsafeUnknownSchema.js";
 export {
 	type ITree,
@@ -178,7 +182,7 @@ export {
 	type UnannotateImplicitFieldSchema,
 	FieldKind,
 	FieldSchema,
-	type FieldSchemaAlpha,
+	FieldSchemaAlpha,
 	type InsertableTreeFieldFromImplicitField,
 	type DefaultProvider,
 	type FieldProps,
@@ -218,7 +222,6 @@ export {
 	type InsertableObjectFromAnnotatedSchemaRecord,
 	type TreeObjectNode,
 	setField,
-	createUnknownOptionalFieldPolicy,
 	isRecordNodeSchema,
 	type RecordNodeCustomizableSchema,
 	type RecordNodeInsertableData,
@@ -237,7 +240,7 @@ export {
 	prepareForInsertion,
 	prepareForInsertionContextless,
 } from "./prepareForInsertion.js";
-export { toStoredSchema, getStoredSchema } from "./toStoredSchema.js";
+export { toStoredSchema, getStoredSchema, convertFieldKind } from "./toStoredSchema.js";
 export {
 	numberSchema,
 	stringSchema,

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

@@ -848,15 +848,15 @@ type Insertable<T extends ImplicitAllowedTypes> = readonly (
 	| IterableTreeArrayContent<InsertableTreeNodeFromImplicitAllowedTypes<T>>
 )[];
 
-abstract class CustomArrayNodeBase<const T extends ImplicitAllowedTypes>
+abstract class CustomArrayNodeBase<const T extends ImplicitAnnotatedAllowedTypes>
 	extends TreeNodeWithArrayFeatures<
-		Iterable<InsertableTreeNodeFromImplicitAllowedTypes<T>>,
-		TreeNodeFromImplicitAllowedTypes<T>
+		Iterable<InsertableTreeNodeFromImplicitAllowedTypes<UnannotateImplicitAllowedTypes<T>>>,
+		TreeNodeFromImplicitAllowedTypes<UnannotateImplicitAllowedTypes<T>>
 	>
-	implements TreeArrayNode<T>
+	implements TreeArrayNode<UnannotateImplicitAllowedTypes<T>>
 {
 	// Indexing must be provided by subclass.
-	[k: number]: TreeNodeFromImplicitAllowedTypes<T>;
+	[k: number]: TreeNodeFromImplicitAllowedTypes<UnannotateImplicitAllowedTypes<T>>;
 
 	public static readonly kind = NodeKind.Array;
 
@@ -869,12 +869,16 @@ abstract class CustomArrayNodeBase<const T extends ImplicitAllowedTypes>
 	>;
 
 	public constructor(
-		input?: Iterable<InsertableTreeNodeFromImplicitAllowedTypes<T>> | InternalTreeNode,
+		input?:
+			| Iterable<InsertableTreeNodeFromImplicitAllowedTypes<UnannotateImplicitAllowedTypes<T>>>
+			| InternalTreeNode,
 	) {
 		super(input ?? []);
 	}
 
-	#mapTreesFromFieldData(value: Insertable<T>): FlexibleFieldContent {
+	#mapTreesFromFieldData(
+		value: Insertable<UnannotateImplicitAllowedTypes<T>>,
+	): FlexibleFieldContent {
 		const sequenceField = getSequenceField(this);
 		const content = value as readonly (
 			| InsertableContent
@@ -906,7 +910,9 @@ abstract class CustomArrayNodeBase<const T extends ImplicitAllowedTypes>
 		return fail(0xadb /* Proxy should intercept length */);
 	}
 
-	public [Symbol.iterator](): IterableIterator<TreeNodeFromImplicitAllowedTypes<T>> {
+	public [Symbol.iterator](): IterableIterator<
+		TreeNodeFromImplicitAllowedTypes<UnannotateImplicitAllowedTypes<T>>
+	> {
 		return this.values();
 	}
 
@@ -918,9 +924,9 @@ abstract class CustomArrayNodeBase<const T extends ImplicitAllowedTypes>
 	}
 
 	public at(
-		this: TreeArrayNode<T>,
+		this: TreeArrayNode<UnannotateImplicitAllowedTypes<T>>,
 		index: number,
-	): TreeNodeFromImplicitAllowedTypes<T> | undefined {
+	): TreeNodeFromImplicitAllowedTypes<UnannotateImplicitAllowedTypes<T>> | undefined {
 		const field = getSequenceField(this);
 		const val = field.boxedAt(index);
 
@@ -928,18 +934,23 @@ abstract class CustomArrayNodeBase<const T extends ImplicitAllowedTypes>
 			return val;
 		}
 
-		return getOrCreateNodeFromInnerNode(val) as TreeNodeFromImplicitAllowedTypes<T>;
+		return getOrCreateNodeFromInnerNode(val) as TreeNodeFromImplicitAllowedTypes<
+			UnannotateImplicitAllowedTypes<T>
+		>;
 	}
-	public insertAt(index: number, ...value: Insertable<T>): void {
+	public insertAt(
+		index: number,
+		...value: Insertable<UnannotateImplicitAllowedTypes<T>>
+	): void {
 		const field = getSequenceField(this);
 		validateIndex(index, field, "insertAt", true);
 		const content = this.#mapTreesFromFieldData(value);
 		field.editor.insert(index, content);
 	}
-	public insertAtStart(...value: Insertable<T>): void {
+	public insertAtStart(...value: Insertable<UnannotateImplicitAllowedTypes<T>>): void {
 		this.insertAt(0, ...value);
 	}
-	public insertAtEnd(...value: Insertable<T>): void {
+	public insertAtEnd(...value: Insertable<UnannotateImplicitAllowedTypes<T>>): void {
 		this.insertAt(this.length, ...value);
 	}
 	public removeAt(index: number): void {
@@ -1079,12 +1090,14 @@ abstract class CustomArrayNodeBase<const T extends ImplicitAllowedTypes>
 		}
 	}
 
-	public values(): IterableIterator<TreeNodeFromImplicitAllowedTypes<T>> {
+	public values(): IterableIterator<
+		TreeNodeFromImplicitAllowedTypes<UnannotateImplicitAllowedTypes<T>>
+	> {
 		return this.generateValues(getKernel(this).generationNumber);
 	}
 	private *generateValues(
 		initialLastUpdatedStamp: number,
-	): Generator<TreeNodeFromImplicitAllowedTypes<T>> {
+	): Generator<TreeNodeFromImplicitAllowedTypes<UnannotateImplicitAllowedTypes<T>>> {
 		const kernel = getKernel(this);
 		if (initialLastUpdatedStamp !== kernel.generationNumber) {
 			throw new UsageError(`Concurrent editing and iteration is not allowed.`);
@@ -1138,7 +1151,7 @@ export function arraySchema<
 
 	// 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>,
@@ -1229,8 +1242,8 @@ export function arraySchema<
 			return Schema.constructorCached?.constructor as unknown as Output;
 		}
 
-		protected get simpleSchema(): UnannotateImplicitAllowedTypes<T> {
-			return unannotatedTypes;
+		protected get simpleSchema(): T {
+			return info;
 		}
 		protected get allowedTypes(): ReadonlySet<TreeNodeSchema> {
 			return lazyChildTypes.value;

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

@@ -26,7 +26,6 @@ export {
 } from "./map/index.js";
 
 export {
-	createUnknownOptionalFieldPolicy,
 	type FieldHasDefault,
 	type InsertableObjectFromAnnotatedSchemaRecord,
 	type InsertableObjectFromSchemaRecord,
@@ -37,6 +36,7 @@ export {
 	objectSchema,
 	setField,
 	type TreeObjectNode,
+	type SimpleKeyMap,
 	type UnannotateSchemaRecord,
 } from "./object/index.js";
 

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

@@ -4,7 +4,6 @@
  */
 
 export {
-	createUnknownOptionalFieldPolicy,
 	type FieldHasDefault,
 	type InsertableObjectFromAnnotatedSchemaRecord,
 	type InsertableObjectFromSchemaRecord,
@@ -12,6 +11,7 @@ export {
 	objectSchema,
 	setField,
 	type TreeObjectNode,
+	type SimpleKeyMap,
 } from "./objectNode.js";
 export {
 	isObjectNodeSchema,

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

@@ -7,7 +7,7 @@ import { assert, Lazy, fail, debugAssert } from "@fluidframework/core-utils/inte
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 import { isFluidHandle } from "@fluidframework/runtime-utils/internal";
 
-import type { FieldKey, SchemaPolicy } from "../../../core/index.js";
+import type { FieldKey } from "../../../core/index.js";
 import {
 	FieldKinds,
 	isTreeValue,
@@ -55,12 +55,11 @@ import {
 	getUnhydratedContext,
 } from "../../createContext.js";
 import { tryGetTreeNodeForField } from "../../getTreeNodeForField.js";
-import {
-	isObjectNodeSchema,
-	type ObjectNodeSchema,
-	type ObjectNodeSchemaInternalData,
-	type ObjectNodeSchemaPrivate,
-	type UnannotateSchemaRecord,
+import type {
+	ObjectNodeSchema,
+	ObjectNodeSchemaInternalData,
+	ObjectNodeSchemaPrivate,
+	UnannotateSchemaRecord,
 } from "./objectNodeTypes.js";
 import { prepareForInsertion } from "../../prepareForInsertion.js";
 import {
@@ -224,8 +223,9 @@ function createFlexKeyMapping(
 ): SimpleKeyMap {
 	const keyMap: Map<string | symbol, { storedKey: FieldKey; schema: FieldSchema }> = new Map();
 	for (const [propertyKey, fieldSchema] of Object.entries(fields)) {
-		const storedKey = getStoredKey(propertyKey, fieldSchema);
-		keyMap.set(propertyKey, { storedKey, schema: normalizeFieldSchema(fieldSchema) });
+		const schema = normalizeFieldSchema(fieldSchema);
+		const storedKey = getStoredKey(propertyKey, schema);
+		keyMap.set(propertyKey, { storedKey, schema });
 	}
 
 	return keyMap;
@@ -649,24 +649,6 @@ function assertUniqueKeys<
 	}
 }
 
-/**
- * Creates a policy for allowing unknown optional fields on an object node which delegates to the policy defined
- * on the object node's internal schema data.
- */
-export function createUnknownOptionalFieldPolicy(
-	schema: ImplicitFieldSchema,
-): SchemaPolicy["allowUnknownOptionalFields"] {
-	const context = getUnhydratedContext(schema);
-	return (identifier) => {
-		const storedSchema = context.schema.get(identifier);
-		return (
-			storedSchema !== undefined &&
-			isObjectNodeSchema(storedSchema) &&
-			storedSchema.allowUnknownOptionalFields
-		);
-	};
-}
-
 /**
  * {@link TreeNodeSchemaInitializedData.toFlexContent} for Map nodes.
  *

package/src/simple-tree/prepareForInsertion.ts

@@ -19,8 +19,9 @@ import {
 	FieldKinds,
 	type FlexibleFieldContent,
 	type FlexibleNodeContent,
+	throwOutOfSchema,
 } from "../feature-libraries/index.js";
-import { normalizeFieldSchema, type ImplicitFieldSchema } from "./fieldSchema.js";
+import { normalizeFieldSchema, type ImplicitAnnotatedFieldSchema } from "./fieldSchema.js";
 import {
 	type InsertableContent,
 	unhydratedFlexTreeFromInsertable,
@@ -29,14 +30,22 @@ import { UsageError } from "@fluidframework/telemetry-utils/internal";
 import { brand } from "../util/index.js";
 import {
 	getKernel,
-	type ImplicitAllowedTypes,
+	type ImplicitAnnotatedAllowedTypes,
 	type TreeNode,
 	type UnhydratedFlexTreeNode,
 } from "./core/index.js";
 import { debugAssert, oob } from "@fluidframework/core-utils/internal";
-import { inSchemaOrThrow, isFieldInSchema } from "../feature-libraries/index.js";
+import { isFieldInSchema } from "../feature-libraries/index.js";
 import { convertField } from "./toStoredSchema.js";
 
+/**
+ * For now, schema validation for inserted content is always enabled.
+ * @remarks
+ * If this ends up being too much of a performance overhead, AND nothing depends on it (like staged allowed types likely will),
+ * this could be changed.
+ */
+const validateSchema = true;
+
 /**
  * Prepare content from a user for insertion into a tree.
  * @remarks
@@ -47,7 +56,7 @@ import { convertField } from "./toStoredSchema.js";
  */
 export function prepareForInsertion<TIn extends InsertableContent | undefined>(
 	data: TIn,
-	schema: ImplicitFieldSchema,
+	schema: ImplicitAnnotatedFieldSchema,
 	destinationContext: FlexTreeContext,
 ): TIn extends undefined ? undefined : FlexibleNodeContent {
 	return prepareForInsertionContextless(
@@ -73,7 +82,7 @@ export function prepareForInsertion<TIn extends InsertableContent | undefined>(
  */
 export function prepareArrayContentForInsertion(
 	data: readonly InsertableContent[],
-	schema: ImplicitAllowedTypes,
+	schema: ImplicitAnnotatedAllowedTypes,
 	destinationContext: FlexTreeContext,
 ): FlexibleFieldContent {
 	const mapTrees: UnhydratedFlexTreeNode[] = data.map((item) =>
@@ -107,7 +116,7 @@ export function prepareArrayContentForInsertion(
  */
 export function prepareForInsertionContextless<TIn extends InsertableContent | undefined>(
 	data: TIn,
-	schema: ImplicitFieldSchema,
+	schema: ImplicitAnnotatedFieldSchema,
 	schemaAndPolicy: SchemaAndPolicy,
 	hydratedData: FlexTreeHydratedContextMinimal | undefined,
 ): TIn extends undefined ? undefined : FlexibleNodeContent {
@@ -137,9 +146,8 @@ function validateAndPrepare(
 		// 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);
-		if (schemaAndPolicy.policy.validateSchema === true) {
-			const maybeError = isFieldInSchema(mapTrees, fieldSchema, schemaAndPolicy);
-			inSchemaOrThrow(maybeError);
+		if (validateSchema === true) {
+			isFieldInSchema(mapTrees, fieldSchema, schemaAndPolicy, throwOutOfSchema);
 		}
 	}
 }

package/src/simple-tree/toStoredSchema.ts

@@ -110,6 +110,9 @@ export const convertFieldKind: ReadonlyMap<FieldKind, FlexFieldKind> = new Map<
  * Converts a {@link TreeNodeSchema} into a {@link TreeNodeStoredSchema}.
  * @privateRemarks
  * TODO: Persist node metadata once schema FormatV2 is supported.
+ *
+ * TODO: AB#43548: Using a stored schema for unhydrated flex trees does not handle schema evolution features like "allowUnknownOptionalFields".
+ * Usage of this and the conversion which wrap it should be audited and reduced.
  */
 export function getStoredSchema(schema: SimpleNodeSchema): TreeNodeStoredSchema {
 	const kind = schema.kind;

package/src/simple-tree/unhydratedFlexTreeFromInsertable.ts

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

package/src/simple-tree/walkFieldSchema.ts

@@ -8,6 +8,7 @@ import { type ImplicitFieldSchema, normalizeFieldSchema } from "./fieldSchema.js
 
 /**
  * Traverses all {@link TreeNodeSchema} schema reachable from `schema`, applying the visitor pattern.
+ * @internal
  */
 export function walkFieldSchema(
 	schema: ImplicitFieldSchema,

package/dist/core/tree/detachedFieldIndexCodec.d.ts

@@ -1,11 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-import type { IIdCompressor } from "@fluidframework/id-compressor";
-import { type ICodecOptions, type IJsonCodec } from "../../codec/index.js";
-import type { RevisionTagCodec } from "../rebase/index.js";
-import { Format } from "./detachedFieldIndexFormat.js";
-import type { DetachedFieldSummaryData } from "./detachedFieldIndexTypes.js";
-export declare function makeDetachedNodeToFieldCodec(revisionTagCodec: RevisionTagCodec, options: ICodecOptions, idCompressor: IIdCompressor): IJsonCodec<DetachedFieldSummaryData, Format>;
-//# sourceMappingURL=detachedFieldIndexCodec.d.ts.map

package/dist/core/tree/detachedFieldIndexCodec.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"detachedFieldIndexCodec.d.ts","sourceRoot":"","sources":["../../../src/core/tree/detachedFieldIndexCodec.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAEnE,OAAO,EACN,KAAK,aAAa,EAClB,KAAK,UAAU,EAEf,MAAM,sBAAsB,CAAC;AAE9B,OAAO,KAAK,EAAsB,gBAAgB,EAAe,MAAM,oBAAoB,CAAC;AAE5F,OAAO,EAEN,MAAM,EAGN,MAAM,+BAA+B,CAAC;AACvC,OAAO,KAAK,EAEX,wBAAwB,EAExB,MAAM,8BAA8B,CAAC;AA6CtC,wBAAgB,4BAA4B,CAC3C,gBAAgB,EAAE,gBAAgB,EAClC,OAAO,EAAE,aAAa,EACtB,YAAY,EAAE,aAAa,GACzB,UAAU,CAAC,wBAAwB,EAAE,MAAM,CAAC,CAkD9C"}