@fluidframework/tree 2.3.0-288113 → 2.3.1

package/src/feature-libraries/flex-tree/lazyField.ts

@@ -13,6 +13,7 @@ import {
 	type FieldUpPath,
 	type ITreeCursorSynchronous,
 	type ITreeSubscriptionCursor,
+	type TreeFieldStoredSchema,
 	type TreeNavigationResult,
 	inCursorNode,
 	iterateCursorField,
@@ -26,7 +27,7 @@ import {
 	type ValueFieldEditBuilder,
 } from "../default-schema/index.js";
 import type { FlexFieldKind } from "../modular-schema/index.js";
-import type { FlexAllowedTypes, FlexFieldSchema } from "../typed-schema/index.js";
+import type { FlexFieldSchema } from "../typed-schema/index.js";
 
 import type { Context } from "./context.js";
 import {
@@ -37,8 +38,7 @@ import {
 	type FlexTreeRequiredField,
 	type FlexTreeSequenceField,
 	type FlexTreeTypedField,
-	type FlexTreeTypedNodeUnion,
-	type FlexTreeUnboxNodeUnion,
+	type FlexTreeUnknownUnboxed,
 	TreeStatus,
 	flexTreeMarker,
 	flexTreeSlot,
@@ -52,7 +52,7 @@ import {
 	tryMoveCursorToAnchorSymbol,
 } from "./lazyEntity.js";
 import { type LazyTreeNode, makeTree } from "./lazyNode.js";
-import { unboxedUnion } from "./unboxed.js";
+import { unboxedFlexNode } from "./unboxed.js";
 import { indexForAt, treeStatusFromAnchorCache } from "./utilities.js";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 import { cursorForMapTreeField, cursorForMapTreeNode } from "../mapTreeCursor.js";
@@ -125,11 +125,8 @@ export function makeField(
 /**
  * Base type for fields implementing {@link FlexTreeField} using cursors.
  */
-export abstract class LazyField<
-		out TKind extends FlexFieldKind,
-		TTypes extends FlexAllowedTypes,
-	>
-	extends LazyEntity<FlexFieldSchema<TKind, TTypes>, FieldAnchor>
+export abstract class LazyField<out TKind extends FlexFieldKind>
+	extends LazyEntity<FlexFieldSchema<TKind>, FieldAnchor>
 	implements FlexTreeField
 {
 	public get [flexTreeMarker](): FlexTreeEntityKind.Field {
@@ -137,6 +134,10 @@ export abstract class LazyField<
 	}
 	public readonly key: FieldKey;
 
+	public get schema(): TreeFieldStoredSchema {
+		return this.flexSchema.stored;
+	}
+
 	/**
 	 * If this field ends its lifetime before the Anchor does, this needs to be invoked to avoid a double free
 	 * if/when the Anchor is destroyed.
@@ -145,7 +146,7 @@ export abstract class LazyField<
 
 	public constructor(
 		context: Context,
-		schema: FlexFieldSchema<TKind, TTypes>,
+		schema: FlexFieldSchema<TKind>,
 		cursor: ITreeSubscriptionCursor,
 		fieldAnchor: FieldAnchor,
 	) {
@@ -164,15 +165,13 @@ export abstract class LazyField<
 		}
 	}
 
-	public is<TSchema extends FlexFieldSchema>(
-		schema: TSchema,
-	): this is FlexTreeTypedField<TSchema> {
+	public is<TKind2 extends FlexFieldKind>(kind: TKind2): this is FlexTreeTypedField<TKind2> {
 		assert(
-			this.context.schema.policy.fieldKinds.get(schema.kind.identifier) === schema.kind,
-			0x77c /* Narrowing must be done to a kind that exists in this context */,
+			this.context.flexSchema.policy.fieldKinds.get(kind.identifier) === kind,
+			0xa26 /* Narrowing must be done to a kind that exists in this context */,
 		);
 
-		return this.schema.equals(schema);
+		return this.flexSchema.kind === (kind as unknown);
 	}
 
 	public get parent(): FlexTreeNode | undefined {
@@ -203,13 +202,13 @@ export abstract class LazyField<
 		return this[cursorSymbol].getFieldLength();
 	}
 
-	public atIndex(index: number): FlexTreeUnboxNodeUnion<TTypes> {
+	public atIndex(index: number): FlexTreeUnknownUnboxed {
 		return inCursorNode(this[cursorSymbol], index, (cursor) =>
-			unboxedUnion(this.context, this.schema, cursor),
+			unboxedFlexNode(this.context, cursor),
 		);
 	}
 
-	public boxedAt(index: number): FlexTreeTypedNodeUnion<TTypes> | undefined {
+	public boxedAt(index: number): FlexTreeNode | undefined {
 		const finalIndex = indexForAt(index, this.length);
 
 		if (finalIndex === undefined) {
@@ -218,23 +217,20 @@ export abstract class LazyField<
 
 		return inCursorNode(this[cursorSymbol], finalIndex, (cursor) =>
 			makeTree(this.context, cursor),
-		) as unknown as FlexTreeTypedNodeUnion<TTypes>;
+		);
 	}
 
-	public map<U>(callbackfn: (value: FlexTreeUnboxNodeUnion<TTypes>, index: number) => U): U[] {
+	public map<U>(callbackfn: (value: FlexTreeUnknownUnboxed, index: number) => U): U[] {
 		return Array.from(this, callbackfn);
 	}
 
-	public boxedIterator(): IterableIterator<FlexTreeTypedNodeUnion<TTypes>> {
-		return iterateCursorField(
-			this[cursorSymbol],
-			(cursor) => makeTree(this.context, cursor) as unknown as FlexTreeTypedNodeUnion<TTypes>,
-		);
+	public boxedIterator(): IterableIterator<FlexTreeNode> {
+		return iterateCursorField(this[cursorSymbol], (cursor) => makeTree(this.context, cursor));
 	}
 
-	public [Symbol.iterator](): IterableIterator<FlexTreeUnboxNodeUnion<TTypes>> {
+	public [Symbol.iterator](): IterableIterator<FlexTreeUnknownUnboxed> {
 		return iterateCursorField(this[cursorSymbol], (cursor) =>
-			unboxedUnion(this.context, this.schema, cursor),
+			unboxedFlexNode(this.context, cursor),
 		);
 	}
 
@@ -263,20 +259,20 @@ export abstract class LazyField<
 	}
 }
 
-export class LazySequence<TTypes extends FlexAllowedTypes>
-	extends LazyField<typeof FieldKinds.sequence, TTypes>
-	implements FlexTreeSequenceField<TTypes>
+export class LazySequence
+	extends LazyField<typeof FieldKinds.sequence>
+	implements FlexTreeSequenceField
 {
 	public constructor(
 		context: Context,
-		schema: FlexFieldSchema<typeof FieldKinds.sequence, TTypes>,
+		schema: FlexFieldSchema<typeof FieldKinds.sequence>,
 		cursor: ITreeSubscriptionCursor,
 		fieldAnchor: FieldAnchor,
 	) {
 		super(context, schema, cursor, fieldAnchor);
 	}
 
-	public at(index: number): FlexTreeUnboxNodeUnion<TTypes> | undefined {
+	public at(index: number): FlexTreeUnknownUnboxed | undefined {
 		const finalIndex = indexForAt(index, this.length);
 
 		if (finalIndex === undefined) {
@@ -284,10 +280,10 @@ export class LazySequence<TTypes extends FlexAllowedTypes>
 		}
 
 		return inCursorNode(this[cursorSymbol], finalIndex, (cursor) =>
-			unboxedUnion(this.context, this.schema, cursor),
+			unboxedFlexNode(this.context, cursor),
 		);
 	}
-	public get asArray(): readonly FlexTreeUnboxNodeUnion<TTypes>[] {
+	public get asArray(): readonly FlexTreeUnknownUnboxed[] {
 		return this.map((x) => x);
 	}
 
@@ -306,13 +302,13 @@ export class LazySequence<TTypes extends FlexAllowedTypes>
 	}
 }
 
-export class ReadonlyLazyValueField<TTypes extends FlexAllowedTypes>
-	extends LazyField<typeof FieldKinds.required, TTypes>
-	implements FlexTreeRequiredField<TTypes>
+export class ReadonlyLazyValueField
+	extends LazyField<typeof FieldKinds.required>
+	implements FlexTreeRequiredField
 {
 	public constructor(
 		context: Context,
-		schema: FlexFieldSchema<typeof FieldKinds.required, TTypes>,
+		schema: FlexFieldSchema<typeof FieldKinds.required>,
 		cursor: ITreeSubscriptionCursor,
 		fieldAnchor: FieldAnchor,
 	) {
@@ -325,18 +321,15 @@ export class ReadonlyLazyValueField<TTypes extends FlexAllowedTypes>
 		},
 	};
 
-	public get content(): FlexTreeUnboxNodeUnion<TTypes> {
+	public get content(): FlexTreeUnknownUnboxed {
 		return this.atIndex(0);
 	}
 }
 
-export class LazyValueField<TTypes extends FlexAllowedTypes>
-	extends ReadonlyLazyValueField<TTypes>
-	implements FlexTreeRequiredField<TTypes>
-{
+export class LazyValueField extends ReadonlyLazyValueField implements FlexTreeRequiredField {
 	public constructor(
 		context: Context,
-		schema: FlexFieldSchema<typeof FieldKinds.required, TTypes>,
+		schema: FlexFieldSchema<typeof FieldKinds.required>,
 		cursor: ITreeSubscriptionCursor,
 		fieldAnchor: FieldAnchor,
 	) {
@@ -355,32 +348,18 @@ export class LazyValueField<TTypes extends FlexAllowedTypes>
 		return fieldEditor;
 	}
 
-	public override get content(): FlexTreeUnboxNodeUnion<TTypes> {
+	public override get content(): FlexTreeUnknownUnboxed {
 		return this.atIndex(0);
 	}
 }
 
-export class LazyIdentifierField<TTypes extends FlexAllowedTypes>
-	extends ReadonlyLazyValueField<TTypes>
-	implements FlexTreeRequiredField<TTypes>
-{
-	public constructor(
-		context: Context,
-		schema: FlexFieldSchema<typeof FieldKinds.required, TTypes>,
-		cursor: ITreeSubscriptionCursor,
-		fieldAnchor: FieldAnchor,
-	) {
-		super(context, schema, cursor, fieldAnchor);
-	}
-}
-
-export class LazyOptionalField<TTypes extends FlexAllowedTypes>
-	extends LazyField<typeof FieldKinds.optional, TTypes>
-	implements FlexTreeOptionalField<TTypes>
+export class LazyOptionalField
+	extends LazyField<typeof FieldKinds.optional>
+	implements FlexTreeOptionalField
 {
 	public constructor(
 		context: Context,
-		schema: FlexFieldSchema<typeof FieldKinds.optional, TTypes>,
+		schema: FlexFieldSchema<typeof FieldKinds.optional>,
 		cursor: ITreeSubscriptionCursor,
 		fieldAnchor: FieldAnchor,
 	) {
@@ -402,33 +381,30 @@ export class LazyOptionalField<TTypes extends FlexAllowedTypes>
 		return fieldEditor;
 	}
 
-	public get content(): FlexTreeUnboxNodeUnion<TTypes> | undefined {
+	public get content(): FlexTreeUnknownUnboxed | undefined {
 		return this.length === 0 ? undefined : this.atIndex(0);
 	}
 }
 
-export class LazyForbiddenField<TTypes extends FlexAllowedTypes> extends LazyField<
-	typeof FieldKinds.forbidden,
-	TTypes
-> {}
+export class LazyForbiddenField extends LazyField<typeof FieldKinds.forbidden> {}
 
-type Builder = new <TTypes extends FlexAllowedTypes>(
+type Builder = new (
 	context: Context,
 	// Correct use of these builders requires the builder of the matching type to be used.
 	// Since this has to be done at runtime anyway, trying to use safer typing than `any` here (such as `never`, which is only slightly safer)
 	// does not seem worth it (ends up requiring type casts that are just as unsafe).
 	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	schema: FlexFieldSchema<any, TTypes>,
+	schema: FlexFieldSchema<any>,
 	cursor: ITreeSubscriptionCursor,
 	fieldAnchor: FieldAnchor,
-) => LazyField<FlexFieldKind, TTypes>;
+) => LazyField<FlexFieldKind>;
 
 const builderList: [FlexFieldKind, Builder][] = [
 	[FieldKinds.forbidden, LazyForbiddenField],
 	[FieldKinds.optional, LazyOptionalField],
 	[FieldKinds.sequence, LazySequence],
 	[FieldKinds.required, LazyValueField],
-	[FieldKinds.identifier, LazyIdentifierField],
+	[FieldKinds.identifier, LazyValueField],
 ];
 
 const kindToClass: ReadonlyMap<FlexFieldKind, Builder> = new Map(builderList);

package/src/feature-libraries/flex-tree/lazyNode.ts

@@ -13,35 +13,20 @@ import {
 	type ITreeSubscriptionCursor,
 	type TreeNavigationResult,
 	type TreeNodeSchemaIdentifier,
-	type TreeValue,
 	type Value,
 	inCursorField,
 	mapCursorFields,
 	rootFieldKey,
 } from "../../core/index.js";
-import { brand, disposeSymbol, fail } from "../../util/index.js";
+import { disposeSymbol, fail } from "../../util/index.js";
 import { FieldKinds } from "../default-schema/index.js";
-import {
-	Any,
-	FlexFieldSchema,
-	type FlexMapNodeSchema,
-	type FlexTreeNodeSchema,
-	type LeafNodeSchema,
-	schemaIsLeaf,
-	schemaIsMap,
-	schemaIsObjectNode,
-} from "../typed-schema/index.js";
+import { FlexFieldSchema, type FlexTreeNodeSchema } from "../typed-schema/index.js";
 
 import type { Context } from "./context.js";
 import {
 	FlexTreeEntityKind,
 	type FlexTreeField,
-	type FlexTreeLeafNode,
-	type FlexTreeMapNode,
 	type FlexTreeNode,
-	type FlexTreeTypedField,
-	type FlexTreeTypedNode,
-	type FlexTreeUnboxField,
 	flexTreeMarker,
 	flexTreeSlot,
 } from "./flexTreeTypes.js";
@@ -53,7 +38,6 @@ import {
 	tryMoveCursorToAnchorSymbol,
 } from "./lazyEntity.js";
 import { makeField } from "./lazyField.js";
-import { unboxedField } from "./unboxed.js";
 
 /**
  * @param cursor - This does not take ownership of this cursor: Node will fork it as needed.
@@ -70,8 +54,8 @@ export function makeTree(context: Context, cursor: ITreeSubscriptionCursor): Laz
 		assert(cached instanceof LazyTreeNode, 0x92c /* Expected LazyTreeNode */);
 		return cached as LazyTreeNode;
 	}
-	const schema = context.schema.nodeSchema.get(cursor.type) ?? fail("missing schema");
-	return buildSubclass(context, schema, cursor, anchorNode, anchor);
+	const schema = context.flexSchema.nodeSchema.get(cursor.type) ?? fail("missing schema");
+	return new LazyTreeNode(context, schema, cursor, anchorNode, anchor);
 }
 
 function cleanupTree(anchor: AnchorNode): void {
@@ -80,26 +64,6 @@ function cleanupTree(anchor: AnchorNode): void {
 	cached[disposeSymbol]();
 }
 
-function buildSubclass(
-	context: Context,
-	schema: FlexTreeNodeSchema,
-	cursor: ITreeSubscriptionCursor,
-	anchorNode: AnchorNode,
-	anchor: Anchor,
-): LazyTreeNode {
-	if (schemaIsMap(schema)) {
-		return new LazyMap(context, schema, cursor, anchorNode, anchor);
-	}
-	if (schemaIsLeaf(schema)) {
-		return new LazyLeaf(context, schema, cursor, anchorNode, anchor);
-	}
-	if (schemaIsObjectNode(schema)) {
-		return new LazyTreeNode(context, schema, cursor, anchorNode, anchor);
-	}
-	// TODO: there should be a common fallback that works for cases without a specialized implementation.
-	fail("unrecognized node kind");
-}
-
 /**
  * Lazy implementation of {@link FlexTreeNode}.
  */
@@ -110,10 +74,10 @@ export class LazyTreeNode<TSchema extends FlexTreeNodeSchema = FlexTreeNodeSchem
 	public get [flexTreeMarker](): FlexTreeEntityKind.Node {
 		return FlexTreeEntityKind.Node;
 	}
-	/**
-	 * Enumerable own property providing a more JS object friendly alternative to "schema".
-	 */
-	public readonly type: TreeNodeSchemaIdentifier;
+
+	public get schema(): TreeNodeSchemaIdentifier {
+		return this.flexSchema.name;
+	}
 
 	// Using JS private here prevents it from showing up as a enumerable own property, or conflicting with struct fields.
 	readonly #removeDeleteCallback: () => void;
@@ -131,21 +95,17 @@ export class LazyTreeNode<TSchema extends FlexTreeNodeSchema = FlexTreeNodeSchem
 		this.#removeDeleteCallback = anchorNode.on("afterDestroy", cleanupTree);
 
 		assert(
-			this.context.schema.nodeSchema.get(this.schema.name) !== undefined,
+			this.context.flexSchema.nodeSchema.get(this.flexSchema.name) !== undefined,
 			0x784 /* There is no explicit schema for this node type. Ensure that the type is correct and the schema for it was added to the TreeStoredSchema */,
 		);
-
-		this.type = schema.name;
 	}
 
-	public is<TSchemaInner extends FlexTreeNodeSchema>(
-		schema: TSchemaInner,
-	): this is FlexTreeTypedNode<TSchemaInner> {
+	public is(schema: FlexTreeNodeSchema): boolean {
 		assert(
-			this.context.schema.nodeSchema.get(schema.name) === schema,
+			this.context.flexSchema.nodeSchema.get(schema.name) === schema,
 			0x785 /* Narrowing must be done to a schema that exists in this context */,
 		);
-		return this.schema === (schema as unknown);
+		return this.flexSchema === (schema as unknown);
 	}
 
 	protected override [tryMoveCursorToAnchorSymbol](
@@ -168,7 +128,7 @@ export class LazyTreeNode<TSchema extends FlexTreeNodeSchema = FlexTreeNodeSchem
 	}
 
 	public tryGetField(fieldKey: FieldKey): FlexTreeField | undefined {
-		const schema = this.schema.getFieldSchema(fieldKey);
+		const schema = this.flexSchema.getFieldSchema(fieldKey);
 		return inCursorField(this[cursorSymbol], fieldKey, (cursor) => {
 			if (cursor.getFieldLength() === 0) {
 				return undefined;
@@ -178,12 +138,15 @@ export class LazyTreeNode<TSchema extends FlexTreeNodeSchema = FlexTreeNodeSchem
 	}
 
 	public getBoxed(key: FieldKey): FlexTreeField {
-		return getBoxedField(this, key, this.schema.getFieldSchema(key));
+		const fieldSchema = this.flexSchema.getFieldSchema(key);
+		return inCursorField(this[cursorSymbol], key, (cursor) => {
+			return makeField(this.context, fieldSchema, cursor);
+		});
 	}
 
 	public boxedIterator(): IterableIterator<FlexTreeField> {
 		return mapCursorFields(this[cursorSymbol], (cursor) =>
-			makeField(this.context, this.schema.getFieldSchema(cursor.getFieldKey()), cursor),
+			makeField(this.context, this.flexSchema.getFieldSchema(cursor.getFieldKey()), cursor),
 		).values();
 	}
 
@@ -202,11 +165,11 @@ export class LazyTreeNode<TSchema extends FlexTreeNodeSchema = FlexTreeNodeSchem
 			// Parent field is a detached sequence, and thus needs special handling for its schema.
 			// eslint-disable-next-line unicorn/prefer-ternary
 			if (key === rootFieldKey) {
-				fieldSchema = this.context.schema.rootFieldSchema;
+				fieldSchema = this.context.flexSchema.rootFieldSchema;
 			} else {
 				// All fields (in the flex tree API) have a schema.
 				// Since currently there is no known schema for detached field other than the special default root:
-				// give all other detached fields a schema of sequence of any.
+				// give all other detached fields a schema of sequence of anything.
 				// That schema is the only one that is safe since its the only field schema that allows any possible field content.
 				//
 				// TODO:
@@ -215,16 +178,18 @@ export class LazyTreeNode<TSchema extends FlexTreeNodeSchema = FlexTreeNodeSchem
 				// 2. Remove (and its inverse) start working on subsequences or fields contents (like everything in a sequence or optional field) and not just single nodes.
 				// 3. Possibly other unknown cases.
 				// Additionally this approach makes it possible for a user to take a FlexTree node, get its parent, check its schema, down cast based on that, then edit that detached field (ex: removing the node in it).
-				// This MIGHT work properly with existing merge resolution logic (it must keep client in sync and be unable to violate schema), but this either needs robust testing or to be explicitly banned (error before s3ending the op).
+				// This MIGHT work properly with existing merge resolution logic (it must keep client in sync and be unable to violate schema), but this either needs robust testing or to be explicitly banned (error before sending the op).
 				// Issues like replacing a node in the a removed sequenced then undoing the remove could easily violate schema if not everything works exactly right!
-				fieldSchema = FlexFieldSchema.create(FieldKinds.sequence, [Any]);
+				fieldSchema = FlexFieldSchema.create(FieldKinds.sequence, [
+					...this.context.flexSchema.nodeSchema.values(),
+				]);
 			}
 		} else {
 			cursor.exitField();
 			const parentType = cursor.type;
 			cursor.enterField(key);
 			const nodeSchema =
-				this.context.schema.nodeSchema.get(parentType) ??
+				this.context.flexSchema.nodeSchema.get(parentType) ??
 				fail("requested schema that does not exist");
 			fieldSchema = nodeSchema.getFieldSchema(key);
 		}
@@ -234,102 +199,8 @@ export class LazyTreeNode<TSchema extends FlexTreeNodeSchema = FlexTreeNodeSchem
 
 		return { parent: proxifiedField, index };
 	}
-}
-
-export class LazyMap<TSchema extends FlexMapNodeSchema>
-	extends LazyTreeNode<TSchema>
-	implements FlexTreeMapNode<TSchema>
-{
-	public constructor(
-		context: Context,
-		schema: TSchema,
-		cursor: ITreeSubscriptionCursor,
-		anchorNode: AnchorNode,
-		anchor: Anchor,
-	) {
-		super(context, schema, cursor, anchorNode, anchor);
-	}
 
 	public keys(): IterableIterator<FieldKey> {
 		return mapCursorFields(this[cursorSymbol], (cursor) => cursor.getFieldKey()).values();
 	}
-
-	public values(): IterableIterator<FlexTreeUnboxField<TSchema["info"], "notEmpty">> {
-		return mapCursorFields(
-			this[cursorSymbol],
-			(cursor) =>
-				unboxedField(this.context, this.schema.info, cursor) as FlexTreeUnboxField<
-					TSchema["info"],
-					"notEmpty"
-				>,
-		).values();
-	}
-
-	public entries(): IterableIterator<
-		[FieldKey, FlexTreeUnboxField<TSchema["info"], "notEmpty">]
-	> {
-		return mapCursorFields(this[cursorSymbol], (cursor) => {
-			const entry: [FieldKey, FlexTreeUnboxField<TSchema["info"], "notEmpty">] = [
-				cursor.getFieldKey(),
-				unboxedField(this.context, this.schema.info, cursor) as FlexTreeUnboxField<
-					TSchema["info"],
-					"notEmpty"
-				>,
-			];
-			return entry;
-		}).values();
-	}
-
-	public forEach(
-		callbackFn: (
-			value: FlexTreeUnboxField<TSchema["info"], "notEmpty">,
-			key: FieldKey,
-			map: FlexTreeMapNode<TSchema>,
-		) => void,
-		thisArg?: unknown,
-	): void {
-		const fn = thisArg !== undefined ? callbackFn.bind(thisArg) : callbackFn;
-		for (const [key, value] of this.entries()) {
-			fn(value, key, this);
-		}
-	}
-
-	public override getBoxed(key: string): FlexTreeTypedField<TSchema["info"]> {
-		return super.getBoxed(brand(key)) as FlexTreeTypedField<TSchema["info"]>;
-	}
-
-	public [Symbol.iterator](): IterableIterator<
-		[FieldKey, FlexTreeUnboxField<TSchema["info"], "notEmpty">]
-	> {
-		return this.entries();
-	}
-}
-
-export class LazyLeaf<TSchema extends LeafNodeSchema>
-	extends LazyTreeNode<TSchema>
-	implements FlexTreeLeafNode<TSchema>
-{
-	public constructor(
-		context: Context,
-		schema: TSchema,
-		cursor: ITreeSubscriptionCursor,
-		anchorNode: AnchorNode,
-		anchor: Anchor,
-	) {
-		super(context, schema, cursor, anchorNode, anchor);
-	}
-
-	public override get value(): TreeValue<TSchema["info"]> {
-		return super.value as TreeValue<TSchema["info"]>;
-	}
-}
-
-function getBoxedField(
-	objectNode: LazyTreeNode,
-	key: FieldKey,
-	fieldSchema: FlexFieldSchema,
-): FlexTreeField {
-	return inCursorField(objectNode[cursorSymbol], key, (cursor) => {
-		return makeField(objectNode.context, fieldSchema, cursor);
-	});
 }

package/src/feature-libraries/flex-tree/unboxed.ts

@@ -3,81 +3,22 @@
  * Licensed under the MIT License.
  */
 
-import { type ITreeSubscriptionCursor, inCursorNode } from "../../core/index.js";
-import { FieldKinds } from "../default-schema/index.js";
-import type { FlexFieldKind } from "../modular-schema/index.js";
-import {
-	type FlexAllowedTypes,
-	type FlexFieldSchema,
-	type FlexTreeNodeSchema,
-	schemaIsLeaf,
-} from "../typed-schema/index.js";
+import type { ITreeSubscriptionCursor } from "../../core/index.js";
 
 import type { Context } from "./context.js";
-import type {
-	FlexTreeNode,
-	FlexTreeUnboxField,
-	FlexTreeUnboxNode,
-	FlexTreeUnboxNodeUnion,
-} from "./flexTreeTypes.js";
-import { makeField } from "./lazyField.js";
+import type { FlexTreeUnknownUnboxed } from "./flexTreeTypes.js";
 import { makeTree } from "./lazyNode.js";
 
 /**
- * See {@link FlexTreeUnboxNode} for documentation on what unwrapping this performs.
+ * Returns the flex tree node, of the value if it has one.
  */
-export function unboxedTree<TSchema extends FlexTreeNodeSchema>(
+export function unboxedFlexNode(
 	context: Context,
-	schema: TSchema,
 	cursor: ITreeSubscriptionCursor,
-): FlexTreeUnboxNode<TSchema> {
-	if (schemaIsLeaf(schema)) {
-		return cursor.value as FlexTreeUnboxNode<TSchema>;
+): FlexTreeUnknownUnboxed {
+	const value = cursor.value;
+	if (value !== undefined) {
+		return value;
 	}
-
-	return makeTree(context, cursor) as FlexTreeNode as FlexTreeUnboxNode<TSchema>;
-}
-
-/**
- * See {@link FlexTreeUnboxNodeUnion} for documentation on what unwrapping this performs.
- */
-export function unboxedUnion<TTypes extends FlexAllowedTypes>(
-	context: Context,
-	schema: FlexFieldSchema<FlexFieldKind, TTypes>,
-	cursor: ITreeSubscriptionCursor,
-): FlexTreeUnboxNodeUnion<TTypes> {
-	const type = schema.monomorphicChildType;
-	if (type !== undefined) {
-		return unboxedTree(context, type, cursor) as FlexTreeUnboxNodeUnion<TTypes>;
-	}
-	return makeTree(context, cursor) as FlexTreeUnboxNodeUnion<TTypes>;
-}
-
-/**
- * @param context - the common context of the field.
- * @param schema - the TreeFieldStoredSchema of the field.
- * @param cursor - the cursor, which must point to the field being proxified.
- */
-export function unboxedField<TSchema extends FlexFieldSchema>(
-	context: Context,
-	schema: TSchema,
-	cursor: ITreeSubscriptionCursor,
-): FlexTreeUnboxField<TSchema> {
-	const kind = schema.kind;
-	if (kind === FieldKinds.required) {
-		return inCursorNode(cursor, 0, (innerCursor) =>
-			unboxedUnion(context, schema, innerCursor),
-		) as FlexTreeUnboxField<TSchema>;
-	}
-	if (kind === FieldKinds.optional) {
-		if (cursor.getFieldLength() === 0) {
-			return undefined as FlexTreeUnboxField<TSchema>;
-		}
-		return inCursorNode(cursor, 0, (innerCursor) =>
-			unboxedUnion(context, schema, innerCursor),
-		) as FlexTreeUnboxField<TSchema>;
-	}
-
-	// TODO: forbidden and nodeKey
-	return makeField(context, schema, cursor) as FlexTreeUnboxField<TSchema>;
+	return makeTree(context, cursor);
 }

package/src/feature-libraries/flex-tree/utilities.ts

@@ -78,16 +78,12 @@ export interface DetachedFieldCache {
  * Utility function to get a {@link SchemaAndPolicy} object from a {@link FlexTreeNode} or {@link FlexTreeField}.
  * @param nodeOrField - {@link FlexTreeNode} or {@link FlexTreeField} to get the schema and policy from.
  * @returns A {@link SchemaAndPolicy} object with the stored schema and policy from the node or field provided.
- * If the schema information is not available on the given node or field (e.g. because it is an unhydrated node), returns `undefined`.
+ * For {@link Unhydrated} nodes this schema may only describe the types allowed subtree for this particular entity.
  */
-export function getSchemaAndPolicy(nodeOrField: FlexTreeEntity): SchemaAndPolicy | undefined {
-	if (nodeOrField.context === undefined) {
-		return undefined;
-	}
-
+export function getSchemaAndPolicy(nodeOrField: FlexTreeEntity): SchemaAndPolicy {
 	return {
-		schema: nodeOrField.context.checkout.storedSchema,
-		policy: nodeOrField.context.schema.policy,
+		schema: nodeOrField.context.schema,
+		policy: nodeOrField.context.flexSchema.policy,
 	};
 }