@fluidframework/tree 2.63.0-359461 → 2.63.0-359734

package/src/feature-libraries/treeCursorUtils.ts

@@ -151,16 +151,14 @@ class StackCursor<TNode> extends SynchronousCursor implements CursorWithNode<TNo
 	}
 
 	public getFieldKey(): FieldKey {
-		debugAssert(() =>
-			this.mode === CursorLocationType.Fields ? true : "must be in fields mode",
-		);
+		debugAssert(() => this.mode === CursorLocationType.Fields || "must be in fields mode");
 		// index is kept inbounds as an invariant of the class.
 		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 		return (this.siblings as readonly FieldKey[])[this.index]!;
 	}
 
 	private getStackedFieldKey(height: number): FieldKey {
-		assert(height % 2 === 1, 0x3b8 /* must field height */);
+		debugAssert(() => height % 2 === 1 || "expected odd height when in field");
 		const siblingStack = this.siblingStack[height] ?? oob();
 		const indexStack = this.indexStack[height] ?? oob();
 		// index is kept inbounds as an invariant of the class.
@@ -169,7 +167,7 @@ class StackCursor<TNode> extends SynchronousCursor implements CursorWithNode<TNo
 	}
 
 	private getStackedNodeIndex(height: number): number {
-		// assert(height % 2 === 0, "must be node height");
+		debugAssert(() => height % 2 === 0 || "must be node height");
 		return this.indexStack[height] ?? oob();
 	}
 
@@ -182,12 +180,12 @@ class StackCursor<TNode> extends SynchronousCursor implements CursorWithNode<TNo
 	}
 
 	public getFieldLength(): number {
-		// assert(this.mode === CursorLocationType.Fields, "must be in fields mode");
+		debugAssert(() => this.mode === CursorLocationType.Fields || "must be in fields mode");
 		return this.getField().length;
 	}
 
 	public enterNode(index: number): void {
-		// assert(this.mode === CursorLocationType.Fields, "must be in fields mode");
+		debugAssert(() => this.mode === CursorLocationType.Fields || "must be in fields mode");
 		const siblings = this.getField();
 		if (!(index in siblings)) {
 			throw new UsageError(
@@ -274,7 +272,7 @@ class StackCursor<TNode> extends SynchronousCursor implements CursorWithNode<TNo
 	}
 
 	public enterField(key: FieldKey): void {
-		// assert(this.mode === CursorLocationType.Nodes, "must be in nodes mode");
+		debugAssert(() => this.mode === CursorLocationType.Nodes || "must be in nodes mode");
 		this.siblingStack.push(this.siblings);
 		this.indexStack.push(this.index);
 
@@ -303,7 +301,7 @@ class StackCursor<TNode> extends SynchronousCursor implements CursorWithNode<TNo
 	}
 
 	public firstField(): boolean {
-		// assert(this.mode === CursorLocationType.Nodes, "must be in nodes mode");
+		debugAssert(() => this.mode === CursorLocationType.Nodes || "must be in nodes mode");
 		const fields = this.adapter.keysFromNode(this.getNode());
 		if (fields.length === 0) {
 			return false;
@@ -317,7 +315,9 @@ class StackCursor<TNode> extends SynchronousCursor implements CursorWithNode<TNo
 	}
 
 	public seekNodes(offset: number): boolean {
-		// assert(this.mode === CursorLocationType.Nodes, "can only seekNodes when in Nodes");
+		debugAssert(
+			() => this.mode === CursorLocationType.Nodes || "can only seekNodes when in Nodes",
+		);
 		this.index += offset;
 		if (this.index in this.siblings) {
 			return true;
@@ -327,7 +327,9 @@ class StackCursor<TNode> extends SynchronousCursor implements CursorWithNode<TNo
 	}
 
 	public firstNode(): boolean {
-		// assert(this.mode === CursorLocationType.Fields, "firstNode only allowed in fields mode");
+		debugAssert(
+			() => this.mode === CursorLocationType.Fields || "firstNode only allowed in fields mode",
+		);
 		const nodes = this.getField();
 		if (nodes.length === 0) {
 			return false;
@@ -340,9 +342,8 @@ class StackCursor<TNode> extends SynchronousCursor implements CursorWithNode<TNo
 	}
 
 	public nextNode(): boolean {
-		assert(
-			this.mode === CursorLocationType.Nodes,
-			0x406 /* can only nextNode when in Nodes */,
+		debugAssert(
+			() => this.mode === CursorLocationType.Nodes || "can only nextNode when in Nodes",
 		);
 		this.index++;
 		if (this.index < (this.siblings as []).length) {
@@ -353,21 +354,31 @@ class StackCursor<TNode> extends SynchronousCursor implements CursorWithNode<TNo
 	}
 
 	public exitField(): void {
-		// assert(this.mode === CursorLocationType.Fields, "can only navigate up from field when in field");
+		debugAssert(
+			() =>
+				this.mode === CursorLocationType.Fields ||
+				"can only navigate up from field when in field",
+		);
 		this.siblings =
 			this.siblingStack.pop() ?? fail(0xac3 /* Unexpected siblingStack.length */);
 		this.index = this.indexStack.pop() ?? fail(0xac4 /* Unexpected indexStack.length */);
 	}
 
 	public exitNode(): void {
-		// assert(this.mode === CursorLocationType.Nodes, "can only navigate up from node when in node");
+		debugAssert(
+			() =>
+				this.mode === CursorLocationType.Nodes ||
+				"can only navigate up from node when in node",
+		);
 		this.siblings =
 			this.siblingStack.pop() ?? fail(0xac5 /* Unexpected siblingStack.length */);
 		this.index = this.indexStack.pop() ?? fail(0xac6 /* Unexpected indexStack.length */);
 	}
 
 	public getNode(): TNode {
-		// assert(this.mode === CursorLocationType.Nodes, "can only get node when in node");
+		debugAssert(
+			() => this.mode === CursorLocationType.Nodes || "can only get node when in node",
+		);
 		// Can not use `?? oob()` since null and undefined are valid values.
 		// index is kept inbounds as an invariant of the class.
 		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
@@ -375,7 +386,9 @@ class StackCursor<TNode> extends SynchronousCursor implements CursorWithNode<TNo
 	}
 
 	private getField(): Field<TNode> {
-		// assert(this.mode === CursorLocationType.Fields, "can only get field when in fields");
+		debugAssert(
+			() => this.mode === CursorLocationType.Fields || "can only get field when in fields",
+		);
 		const parent = this.getStackedNode(this.indexStack.length - 1);
 		const key: FieldKey = this.getFieldKey();
 		const field = this.adapter.getFieldFromNode(parent, key);
@@ -397,7 +410,9 @@ class StackCursor<TNode> extends SynchronousCursor implements CursorWithNode<TNo
 	}
 
 	public get fieldIndex(): number {
-		// assert(this.mode === CursorLocationType.Nodes, "can only node's index when in node");
+		debugAssert(
+			() => this.mode === CursorLocationType.Nodes || "can only node's index when in node",
+		);
 		return this.index;
 	}
 

package/src/index.ts

@@ -94,7 +94,8 @@ export {
 	SchemaFactory,
 	SchemaFactoryBeta,
 	SchemaFactoryAlpha,
-	type SchemaFactoryObjectOptions,
+	type ObjectSchemaOptionsAlpha,
+	type ObjectSchemaOptions,
 	type ImplicitFieldSchema,
 	type TreeFieldFromImplicitField,
 	type TreeChangeEvents,
@@ -163,21 +164,16 @@ export {
 	type FactoryContentObject,
 	type ReadableField,
 	type ReadSchema,
-	type ImplicitAnnotatedAllowedTypes,
-	type ImplicitAnnotatedFieldSchema,
 	type AnnotatedAllowedType,
 	type AnnotatedAllowedTypes,
-	type NormalizedAnnotatedAllowedTypes,
+	type AllowedTypesFullEvaluated,
 	type AllowedTypeMetadata,
 	type AllowedTypesMetadata,
-	type InsertableObjectFromAnnotatedSchemaRecord,
-	type UnannotateImplicitAllowedTypes,
-	type UnannotateAllowedTypes,
-	type UnannotateAllowedType,
 	type UnannotateAllowedTypesList,
-	type UnannotateImplicitFieldSchema,
-	type UnannotateSchemaRecord,
 	type SchemaStaticsAlpha,
+	type AnnotateAllowedTypesList,
+	type AllowedTypesFull,
+	type AllowedTypesFullFromMixed,
 	// Beta APIs
 	TreeBeta,
 	type TreeChangeEventsBeta,
@@ -273,6 +269,7 @@ export {
 	KeyEncodingOptions,
 	type TreeParsingOptions,
 	type SchemaFactory_base,
+	type NumberKeys,
 } from "./simple-tree/index.js";
 export {
 	SharedTree,

package/src/jsonDomainSchema.ts

@@ -37,7 +37,7 @@ const sf = new SchemaFactoryAlpha("com.fluidframework.json");
  *
  * 2. The order of fields on an object is not preserved. The resulting order is arbitrary.
  *
- * JSON data can be imported from JSON into this format using `JSON.parse` then {@link (TreeAlpha:interface).importConcise} with the {@link JsonAsTree.(Tree:variable)} schema.
+ * JSON data can be imported from JSON into this format using `JSON.parse` then {@link (TreeBeta:interface).importConcise} with the {@link JsonAsTree.(Tree:variable)} schema.
  *
  * @alpha
  */
@@ -63,7 +63,7 @@ export namespace JsonAsTree {
 	 * {@link AllowedTypes} for any content allowed in the {@link JsonAsTree} domain.
 	 * @example
 	 * ```typescript
-	 * const tree = TreeAlpha.importConcise(JsonAsTree.Union, { example: { nested: true }, value: 5 });
+	 * const tree = TreeBeta.importConcise(JsonAsTree.Union, { example: { nested: true }, value: 5 });
 	 * ```
 	 * @privateRemarks
 	 * The order here should not matter for any functionality related reasons.
@@ -95,7 +95,7 @@ export namespace JsonAsTree {
 	 * // Due to TypeScript restrictions on recursive types, the constructor and be somewhat limiting.
 	 * const fromArray = new JsonAsTreeObject([["a", 0]]);
 	 * // Using `importConcise` can work better for JSON data:
-	 * const imported = TreeAlpha.importConcise(JsonAsTree.Object, { a: 0 });
+	 * const imported = TreeBeta.importConcise(JsonAsTree.Object, { a: 0 });
 	 * // Node API is like a Map:
 	 * const value = imported.get("a");
 	 * ```
@@ -128,13 +128,13 @@ export namespace JsonAsTree {
 	/**
 	 * Arbitrary JSON array as a {@link TreeNode}.
 	 * @remarks
-	 * This can be imported using {@link (TreeAlpha:interface).importConcise}.
+	 * This can be imported using {@link (TreeBeta:interface).importConcise}.
 	 * @example
 	 * ```typescript
 	 * // Due to TypeScript restrictions on recursive types, the constructor can be somewhat limiting.
 	 * const usingConstructor = new JsonAsTree.Array(["a", 0, new JsonAsTree.Array([1])]);
 	 * // Using `importConcise` can work better for JSON data:
-	 * const imported = TreeAlpha.importConcise(JsonAsTree.Array, ["a", 0, [1]]);
+	 * const imported = TreeBeta.importConcise(JsonAsTree.Array, ["a", 0, [1]]);
 	 * // Node API is like an Array:
 	 * const inner: JsonAsTree.Tree = imported[2];
 	 * assert(Tree.is(inner, JsonAsTree.Array));

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/tree";
-export const pkgVersion = "2.63.0-359461";
+export const pkgVersion = "2.63.0-359734";

package/src/serializableDomainSchema.ts

@@ -23,14 +23,14 @@ const sf = new SchemaFactoryAlpha("com.fluidframework.serializable");
  * @remarks
  * Schema which replicate the Fluid Serializable data model with {@link TreeNode}s.
  *
- * Fluid Serializable data can be imported from the {@link FluidSerializableAsTree.Data|Fluid Serializable format} into this format using {@link (TreeAlpha:interface).importConcise} with the {@link FluidSerializableAsTree.(Tree:variable)} schema.
+ * Fluid Serializable data can be imported from the {@link FluidSerializableAsTree.Data|Fluid Serializable format} into this format using {@link (TreeBeta:interface).importConcise} with the {@link FluidSerializableAsTree.(Tree:variable)} schema.
  * @alpha
  */
 export namespace FluidSerializableAsTree {
 	/**
 	 * Data which can be serialized by Fluid.
 	 * @remarks
-	 * Can be encoded as a {@link FluidSerializableAsTree.(Tree:type)} using {@link (TreeAlpha:interface).importConcise}.
+	 * Can be encoded as a {@link FluidSerializableAsTree.(Tree:type)} using {@link (TreeBeta:interface).importConcise}.
 	 * @alpha
 	 */
 	export type Data = JsonCompatible<IFluidHandle>;
@@ -39,7 +39,7 @@ export namespace FluidSerializableAsTree {
 	 * {@link AllowedTypes} for any content allowed in the {@link FluidSerializableAsTree} domain.
 	 * @example
 	 * ```typescript
-	 * const tree = TreeAlpha.importConcise(FluidSerializableAsTree.Tree, { example: { nested: true }, value: 5 });
+	 * const tree = TreeBeta.importConcise(FluidSerializableAsTree.Tree, { example: { nested: true }, value: 5 });
 	 * ```
 	 * @alpha
 	 */
@@ -69,7 +69,7 @@ export namespace FluidSerializableAsTree {
 	 * // Due to TypeScript restrictions on recursive types, the constructor and be somewhat limiting.
 	 * const fromArray = new JsonAsTreeObject([["a", 0]]);
 	 * // Using `importConcise` can work better for Fluid Serializable data:
-	 * const imported = TreeAlpha.importConcise(FluidSerializableAsTree.Object, { a: 0 });
+	 * const imported = TreeBeta.importConcise(FluidSerializableAsTree.Object, { a: 0 });
 	 * // Node API is like a Map:
 	 * const value = imported.get("a");
 	 * ```
@@ -102,13 +102,13 @@ export namespace FluidSerializableAsTree {
 	/**
 	 * Arbitrary Fluid Serializable array as a {@link TreeNode}.
 	 * @remarks
-	 * This can be imported using {@link (TreeAlpha:interface).importConcise}.
+	 * This can be imported using {@link (TreeBeta:interface).importConcise}.
 	 * @example
 	 * ```typescript
 	 * // Due to TypeScript restrictions on recursive types, the constructor can be somewhat limiting.
 	 * const usingConstructor = new FluidSerializableAsTree.Array(["a", 0, new FluidSerializableAsTree.Array([1])]);
 	 * // Using `importConcise` can work better for Fluid Serializable data:
-	 * const imported = TreeAlpha.importConcise(FluidSerializableAsTree.Array, ["a", 0, [1]]);
+	 * const imported = TreeBeta.importConcise(FluidSerializableAsTree.Array, ["a", 0, [1]]);
 	 * // Node API is like an Array:
 	 * const inner: FluidSerializableAsTree.Tree = imported[2];
 	 * assert(Tree.is(inner, FluidSerializableAsTree.Array));

package/src/shared-tree/schematizingTreeView.ts

@@ -336,7 +336,7 @@ export class SchematizingSimpleTreeView<
 				new HydratedContext(
 					this.flexTreeContext,
 					HydratedContext.schemaMapFromRootSchema(
-						this.rootFieldSchema.annotatedAllowedTypesNormalized,
+						this.rootFieldSchema.allowedTypesFull.evaluate(),
 					),
 				),
 			);

package/src/shared-tree/treeAlpha.ts

@@ -29,8 +29,6 @@ import {
 	type TreeFieldFromImplicitField,
 	type TreeLeafValue,
 	type UnsafeUnknownSchema,
-	conciseFromCursor,
-	type ConciseTree,
 	applySchemaToParserOptions,
 	cursorFromVerbose,
 	verboseFromCursor,
@@ -56,6 +54,10 @@ import {
 	toUnhydratedSchema,
 	type TreeParsingOptions,
 	type NodeChangedData,
+	type ConciseTree,
+	importConcise,
+	exportConcise,
+	borrowCursorFromTreeNodeOrValue,
 } from "../simple-tree/index.js";
 import { brand, extractFromOpaque, type JsonCompatible } from "../util/index.js";
 import {
@@ -200,12 +202,12 @@ export interface TreeIdentifierUtils {
  * @remarks
  * Use via the {@link (TreeAlpha:variable)} singleton.
  *
- * The unhydrated node creation APIs in this interface do not support {@link SchemaFactoryObjectOptions.allowUnknownOptionalFields | unknown optional fields}.
+ * The unhydrated node creation APIs in this interface do not support {@link ObjectSchemaOptions.allowUnknownOptionalFields | unknown optional fields}.
  * This is because unknown optional fields still must have a schema: its just that the schema may come from the document's stored schema.
  * Unhydrated nodes created via this interface are not associated with any document, so there is nowhere for them to get schema for unknown optional fields.
  * Note that {@link (TreeBeta:interface).clone} can create an unhydrated node with unknown optional fields, as it uses the source node's stored schema (if any).
  *
- * Export APIs in this interface include {@link SchemaFactoryObjectOptions.allowUnknownOptionalFields | unknown optional fields}
+ * Export APIs in this interface include {@link ObjectSchemaOptions.allowUnknownOptionalFields | unknown optional fields}
  * if they are using {@link KeyEncodingOptions.allStoredKeys}.
  *
  * @privateRemarks
@@ -248,19 +250,7 @@ export interface TreeAlpha {
 	>;
 
 	/**
-	 * Less type safe version of {@link (TreeAlpha:interface).create}, suitable for importing data.
-	 * @remarks
-	 * Due to {@link ConciseTree} relying on type inference from the data, its use is somewhat limited.
-	 * This does not support {@link ConciseTree|ConciseTrees} with customized handle encodings or using persisted keys.
-	 * Use "compressed" or "verbose" formats for more flexibility.
-	 *
-	 * When using this function,
-	 * it is recommend to ensure your schema is unambiguous with {@link ITreeConfigurationOptions.preventAmbiguity}.
-	 * If the schema is ambiguous, consider using {@link (TreeAlpha:interface).create} and {@link Unhydrated} nodes where needed,
-	 * or using {@link (TreeAlpha:interface).(importVerbose:1)} and specify all types.
-	 *
-	 * Documented (and thus recoverable) error handling/reporting for this is not yet implemented,
-	 * but for now most invalid inputs will throw a recoverable error.
+	 * {@inheritDoc (TreeBeta:interface).importConcise}
 	 */
 	importConcise<const TSchema extends ImplicitFieldSchema | UnsafeUnknownSchema>(
 		schema: UnsafeUnknownSchema extends TSchema
@@ -273,13 +263,30 @@ export interface TreeAlpha {
 			: TreeNode | TreeLeafValue | undefined
 	>;
 
+	/**
+	 * {@inheritDoc (TreeBeta:interface).(exportConcise:1)}
+	 * @privateRemarks Note: this was retained on this interface because {@link (TreeAlpha:interface).importConcise} exists.
+	 * It should be removed if/when that is removed from this interface.
+	 */
+	exportConcise(node: TreeNode | TreeLeafValue, options?: TreeEncodingOptions): ConciseTree;
+
+	/**
+	 * {@inheritDoc (TreeBeta:interface).(exportConcise:2)}
+	 * @privateRemarks Note: this was retained on this interface because {@link (TreeAlpha:interface).importConcise} exists.
+	 * It should be removed if/when that is removed from this interface.
+	 */
+	exportConcise(
+		node: TreeNode | TreeLeafValue | undefined,
+		options?: TreeEncodingOptions,
+	): ConciseTree | undefined;
+
 	/**
 	 * Construct tree content compatible with a field defined by the provided `schema`.
 	 * @param schema - The schema for what to construct. As this is an {@link ImplicitFieldSchema}, a {@link FieldSchema}, {@link TreeNodeSchema} or {@link AllowedTypes} array can be provided.
 	 * @param data - The data used to construct the field content. See {@link (TreeAlpha:interface).(exportVerbose:1)}.
 	 * @remarks
 	 * This currently does not support input containing
-	 * {@link SchemaFactoryObjectOptions.allowUnknownOptionalFields| unknown optional fields} but does support
+	 * {@link ObjectSchemaOptions.allowUnknownOptionalFields| unknown optional fields} but does support
 	 * {@link SchemaStaticsAlpha.staged | staged} allowed types.
 	 * Non-empty default values for fields are currently not supported (must be provided in the input).
 	 * The content will be validated against the schema and an error will be thrown if out of schema.
@@ -290,25 +297,12 @@ export interface TreeAlpha {
 		options?: TreeParsingOptions,
 	): Unhydrated<TreeFieldFromImplicitField<TSchema>>;
 
-	/**
-	 * Copy a snapshot of the current version of a TreeNode into a {@link ConciseTree}.
-	 */
-	exportConcise(node: TreeNode | TreeLeafValue, options?: TreeEncodingOptions): ConciseTree;
-
-	/**
-	 * Copy a snapshot of the current version of a TreeNode into a {@link ConciseTree}, allowing undefined.
-	 */
-	exportConcise(
-		node: TreeNode | TreeLeafValue | undefined,
-		options?: TreeEncodingOptions,
-	): ConciseTree | undefined;
-
 	/**
 	 * Copy a snapshot of the current version of a TreeNode into a JSON compatible plain old JavaScript Object (except for {@link @fluidframework/core-interfaces#IFluidHandle|IFluidHandles}).
 	 * Uses the {@link VerboseTree} format, with an explicit type on every node.
 	 *
 	 * @remarks
-	 * There are several cases this may be preferred to {@link (TreeAlpha:interface).(exportConcise:1)}:
+	 * There are several cases this may be preferred to {@link (TreeBeta:interface).(exportConcise:1)}:
 	 *
 	 * 1. When not using {@link ITreeConfigurationOptions.preventAmbiguity} (or when using `useStableFieldKeys`), `exportConcise` can produce ambiguous data (the type may be unclear on some nodes).
 	 * `exportVerbose` will always be unambiguous and thus lossless.
@@ -385,7 +379,7 @@ export interface TreeAlpha {
 	/**
 	 * Gets the child of the given node with the given property key if a child exists under that key.
 	 *
-	 * @remarks {@link SchemaFactoryObjectOptions.allowUnknownOptionalFields | Unknown optional fields} of Object nodes will not be returned by this method.
+	 * @remarks {@link ObjectSchemaOptions.allowUnknownOptionalFields | Unknown optional fields} of Object nodes will not be returned by this method.
 	 *
 	 * @param node - The parent node whose child is being requested.
 	 * @param key - The property key under the node under which the child is being requested.
@@ -406,7 +400,7 @@ export interface TreeAlpha {
 	 *
 	 * Optional properties of Object nodes with no value are not included in the result.
 	 *
-	 * {@link SchemaFactoryObjectOptions.allowUnknownOptionalFields | Unknown optional fields} of Object nodes are not included in the result.
+	 * {@link ObjectSchemaOptions.allowUnknownOptionalFields | Unknown optional fields} of Object nodes are not included in the result.
 	 *
 	 * @param node - The node whose children are being requested.
 	 *
@@ -767,7 +761,7 @@ export const TreeAlpha: TreeAlpha = {
 		>;
 	},
 
-	importConcise<TSchema extends ImplicitFieldSchema | UnsafeUnknownSchema>(
+	importConcise<const TSchema extends ImplicitFieldSchema | UnsafeUnknownSchema>(
 		schema: UnsafeUnknownSchema extends TSchema
 			? ImplicitFieldSchema
 			: TSchema & ImplicitFieldSchema,
@@ -777,12 +771,11 @@ export const TreeAlpha: TreeAlpha = {
 			? TreeFieldFromImplicitField<TSchema>
 			: TreeNode | TreeLeafValue | undefined
 	> {
-		// `importConcise` does not need to support all the formats that `create` does.
-		// Perhaps it should error instead of hydrating nodes for example.
-		// For now however, it is a simple wrapper around `create`.
-		return this.create(schema, data as InsertableField<TSchema>);
+		return importConcise(schema, data);
 	},
 
+	exportConcise,
+
 	importVerbose<const TSchema extends ImplicitFieldSchema>(
 		schema: TSchema,
 		data: VerboseTree | undefined,
@@ -806,8 +799,6 @@ export const TreeAlpha: TreeAlpha = {
 		);
 	},
 
-	exportConcise,
-
 	exportVerbose(node: TreeNode | TreeLeafValue, options?: TreeEncodingOptions): VerboseTree {
 		if (isTreeValue(node)) {
 			return node;
@@ -1020,46 +1011,6 @@ export const TreeAlpha: TreeAlpha = {
 	},
 };
 
-function exportConcise(
-	node: TreeNode | TreeLeafValue,
-	options?: TreeEncodingOptions,
-): ConciseTree;
-
-function exportConcise(
-	node: TreeNode | TreeLeafValue | undefined,
-	options?: TreeEncodingOptions,
-): ConciseTree | undefined;
-
-function exportConcise(
-	node: TreeNode | TreeLeafValue | undefined,
-	options?: TreeEncodingOptions,
-): ConciseTree | undefined {
-	if (!isTreeNode(node)) {
-		return node;
-	}
-	const config: TreeEncodingOptions = { ...options };
-
-	const kernel = getKernel(node);
-	const cursor = borrowCursorFromTreeNodeOrValue(node);
-	return conciseFromCursor(cursor, kernel.context, config);
-}
-
-/**
- * Borrow a cursor from a node.
- * @remarks
- * The cursor must be put back to its original location before the node is used again.
- */
-function borrowCursorFromTreeNodeOrValue(
-	node: TreeNode | TreeLeafValue,
-): ITreeCursorSynchronous {
-	if (isTreeValue(node)) {
-		return cursorFromVerbose(node, {});
-	}
-	const kernel = getKernel(node);
-	const cursor = kernel.getOrCreateInnerNode().borrowCursor();
-	return cursor;
-}
-
 /**
  * Borrow a cursor from a field.
  * @remarks

package/src/simple-tree/api/conciseTree.ts

@@ -28,7 +28,7 @@ import {
  * @privateRemarks
  * This can store all possible simple trees,
  * but it can not store all possible trees representable by our internal representations like FlexTree and JsonableTree.
- * @alpha
+ * @beta
  */
 export type ConciseTree<THandle = IFluidHandle> =
 	| Exclude<TreeLeafValue, IFluidHandle>

package/src/simple-tree/api/configuration.ts

@@ -19,10 +19,9 @@ import {
 	normalizeFieldSchema,
 } from "../fieldSchema.js";
 import {
+	type AllowedTypesFullEvaluated,
 	NodeKind,
 	type TreeNodeSchema,
-	isAnnotatedAllowedType,
-	evaluateLazySchema,
 	markSchemaMostDerived,
 } from "../core/index.js";
 import {
@@ -165,9 +164,6 @@ export interface ITreeViewConfiguration<
 
 /**
  * Configuration for {@link ViewableTree.viewWith}.
- * @privateRemarks
- * When `ImplicitAnnotatedFieldSchema` is stabilized, TSchema should be updated to use it.
- * When doing this, the example for `staged` will need to be updated/simplified.
  * @sealed @public
  */
 export class TreeViewConfiguration<
@@ -235,9 +231,9 @@ export class TreeViewConfiguration<
 				debugAssert(() => !definitions.has(schema.identifier));
 				definitions.set(schema.identifier, schema as SimpleNodeSchema & TreeNodeSchema);
 			},
-			allowedTypes({ types }): void {
+			allowedTypes({ types }: AllowedTypesFullEvaluated): void {
 				checkUnion(
-					types.map((t) => evaluateLazySchema(isAnnotatedAllowedType(t) ? t.type : t)),
+					types.map((t) => t.type),
 					config.preventAmbiguity,
 					ambiguityErrors,
 				);

package/src/simple-tree/api/customTree.ts

@@ -35,7 +35,7 @@ import { isObjectNodeSchema } from "../node-kinds/index.js";
 
 /**
  * Options for how to interpret or encode a tree when schema information is available.
- * @alpha
+ * @beta
  * @input
  */
 export interface TreeEncodingOptions<TKeyOptions = KeyEncodingOptions> {
@@ -44,7 +44,7 @@ export interface TreeEncodingOptions<TKeyOptions = KeyEncodingOptions> {
 	 * @remarks
 	 * Has no effect on {@link NodeKind}s other than {@link NodeKind.Object}.
 	 *
-	 * {@link SchemaFactoryObjectOptions.allowUnknownOptionalFields|Unknown optional field} will be omitted when using property keys.
+	 * {@link ObjectSchemaOptions.allowUnknownOptionalFields|Unknown optional field} will be omitted when using property keys.
 	 * @defaultValue {@link KeyEncodingOptions.usePropertyKeys}.
 	 */
 	readonly keys?: TKeyOptions;
@@ -61,7 +61,7 @@ export type TreeParsingOptions = TreeEncodingOptions<
 
 /**
  * Options for how to encode keys in a tree.
- * @alpha
+ * @beta
  * @input
  */
 export enum KeyEncodingOptions {
@@ -69,21 +69,21 @@ export enum KeyEncodingOptions {
 	 * Use property keys.
 	 * @remarks
 	 * Supported for import and export.
-	 * {@link SchemaFactoryObjectOptions.allowUnknownOptionalFields|Unknown optional fields} will be omitted when using property keys.
+	 * {@link ObjectSchemaOptions.allowUnknownOptionalFields|Unknown optional fields} will be omitted when using property keys.
 	 */
 	usePropertyKeys = "usePropertyKeys",
 	/**
-	 * Use stored keys, and include {@link SchemaFactoryObjectOptions.allowUnknownOptionalFields|Unknown optional fields}.
+	 * Use stored keys, and include {@link ObjectSchemaOptions.allowUnknownOptionalFields|Unknown optional fields}.
 	 * @remarks
 	 * Currently only supported for export.
 	 */
 	allStoredKeys = "allStoredKeys",
 	/**
-	 * Use stored keys but do not include {@link SchemaFactoryObjectOptions.allowUnknownOptionalFields|Unknown optional fields}.
+	 * Use stored keys but do not include {@link ObjectSchemaOptions.allowUnknownOptionalFields | unknown optional fields}.
 	 * @remarks
 	 * Supported for import and export.
 	 * For export, this omits unknown optional fields.
-	 * For import, any unexpected fields are errors, regardless of {@link SchemaFactoryObjectOptions.allowUnknownOptionalFields}.
+	 * For import, any unexpected fields are errors, regardless of {@link ObjectSchemaOptions.allowUnknownOptionalFields}.
 	 */
 	knownStoredKeys = "knownStoredKeys",
 }

package/src/simple-tree/api/discrepancies.ts

@@ -24,7 +24,7 @@ import {
 import { brand } from "../../util/index.js";
 import {
 	NodeKind,
-	normalizeAnnotatedAllowedTypes,
+	normalizeAndEvaluateAnnotatedAllowedTypes,
 	type AnnotatedAllowedType,
 	type TreeNodeSchema,
 } from "../core/index.js";
@@ -237,7 +237,7 @@ function* getNodeDiscrepancies(
 			}
 
 			yield* getAllowedTypeDiscrepancies(
-				normalizeAnnotatedAllowedTypes(view.info).types,
+				normalizeAndEvaluateAnnotatedAllowedTypes(view.info).types,
 				arrayStoredSchema,
 				brand(view.identifier),
 				EmptyKey,
@@ -346,7 +346,7 @@ function* getFieldDiscrepancies(
 		0xbee /* all field schema should be FieldSchemaAlpha */,
 	);
 	yield* getAllowedTypeDiscrepancies(
-		view.annotatedAllowedTypesNormalized.types,
+		view.allowedTypesFull.evaluate().types,
 		stored.types,
 		identifier,
 		fieldKey,

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

@@ -28,7 +28,8 @@ export { type SchemaStatics, schemaStatics } from "./schemaStatics.js";
 export {
 	SchemaFactory,
 	type ScopedSchemaName,
-	type SchemaFactoryObjectOptions,
+	type ObjectSchemaOptionsAlpha,
+	type ObjectSchemaOptions,
 	type NodeSchemaOptions,
 	type NodeSchemaOptionsAlpha,
 	type SchemaFactory_base,
@@ -118,7 +119,14 @@ export {
 	replaceConciseTreeHandles,
 } from "./conciseTree.js";
 
-export { TreeBeta, type NodeChangedData, type TreeChangeEventsBeta } from "./treeBeta.js";
+export {
+	borrowCursorFromTreeNodeOrValue,
+	exportConcise,
+	importConcise,
+	type NodeChangedData,
+	TreeBeta,
+	type TreeChangeEventsBeta,
+} from "./treeBeta.js";
 export { createSimpleTreeIndex, type SimpleTreeIndex } from "./simpleTreeIndex.js";
 export {
 	createIdentifierIndex,