@fluidframework/tree 2.74.0-365691 → 2.74.0-368706

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

@@ -5,7 +5,7 @@
 
 import { createEmitter } from "@fluid-internal/client-utils";
 import type { HasListeners, Listenable } from "@fluidframework/core-interfaces/internal";
-import { assert, oob, fail } from "@fluidframework/core-utils/internal";
+import { assert, oob, fail, debugAssert } from "@fluidframework/core-utils/internal";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 
 import {
@@ -38,16 +38,16 @@ import {
 	type FlexTreeHydratedContext,
 	type FlexFieldKind,
 	FieldKinds,
-	type SequenceFieldEditBuilder,
 	cursorForMapTreeNode,
-	type OptionalFieldEditBuilder,
-	type ValueFieldEditBuilder,
-	type FlexibleNodeContent,
+	type SequenceFieldEditor,
+	type RequiredFieldEditor,
 	type FlexTreeHydratedContextMinimal,
 	type FlexibleFieldContent,
 	type MapTreeFieldViewGeneric,
 	type MapTreeNodeViewGeneric,
 	type HydratedFlexTreeNode,
+	type FlexibleNodeContent,
+	type OptionalFieldEditor,
 	cursorForMapTreeField,
 	type MinimalFieldMap,
 	currentObserver,
@@ -59,7 +59,7 @@ import type { ContextualFieldProvider } from "../fieldSchema.js";
 import type { TreeNode } from "./treeNode.js";
 
 interface UnhydratedTreeSequenceFieldEditBuilder
-	extends SequenceFieldEditBuilder<FlexibleFieldContent, UnhydratedFlexTreeNode[]> {}
+	extends SequenceFieldEditor<FlexibleFieldContent, readonly FlexTreeNode[]> {}
 
 type UnhydratedFlexTreeNodeEvents = Pick<
 	AnchorEvents,
@@ -73,7 +73,7 @@ type LocationInField = FlexTreeNode["parentField"];
  * The {@link Unhydrated} implementation of {@link FlexTreeNode}.
  */
 export class UnhydratedFlexTreeNode
-	implements FlexTreeNode, MapTreeNodeViewGeneric<UnhydratedFlexTreeNode>
+	implements FlexTreeNode, MapTreeNodeViewGeneric<FlexTreeNode>
 {
 	public isHydrated(): this is HydratedFlexTreeNode {
 		return false;
@@ -226,7 +226,7 @@ export class UnhydratedFlexTreeNode
 	}
 
 	public borrowCursor(): ITreeCursorSynchronous {
-		return cursorForMapTreeNode<MapTreeNodeViewGeneric<UnhydratedFlexTreeNode>>(this);
+		return cursorForMapTreeNode<MapTreeNodeViewGeneric<FlexTreeNode>>(this);
 	}
 
 	public tryGetField(key: FieldKey): UnhydratedFlexTreeField | undefined {
@@ -300,6 +300,11 @@ export class UnhydratedContext implements FlexTreeContext {
 	public isHydrated(): this is FlexTreeHydratedContext {
 		return false;
 	}
+
+	public runInTransaction(fn: () => void): void {
+		debugAssert(() => !this.isDisposed() || "Disposed");
+		fn();
+	}
 }
 
 // #region Fields
@@ -327,7 +332,7 @@ const unparentedLocation: LocationInField = {
  * The {@link Unhydrated} implementation of {@link FlexTreeField}.
  */
 export class UnhydratedFlexTreeField
-	implements FlexTreeField, MapTreeFieldViewGeneric<UnhydratedFlexTreeNode>
+	implements FlexTreeField, MapTreeFieldViewGeneric<FlexTreeNode>
 {
 	public [flexTreeMarker] = FlexTreeEntityKind.Field as const;
 
@@ -344,21 +349,23 @@ export class UnhydratedFlexTreeField
 		 * See {@link fillPendingDefaults}.
 		 * Note that any fields using a {@link ConstantFieldProvider} should be evaluated before constructing the UnhydratedFlexTreeField.
 		 */
-		private lazyChildren: UnhydratedFlexTreeNode[] | ContextualFieldProvider,
+		private lazyChildren: FlexTreeNode[] | ContextualFieldProvider,
 	) {
 		// When this field is created (which only happens one time, because it is cached), all the children become parented for the first time.
 		// "Adopt" each child by updating its parent information to point to this field.
 		if (Array.isArray(lazyChildren)) {
 			for (const [i, child] of lazyChildren.entries()) {
-				child.adoptBy(this, i);
+				if (child instanceof UnhydratedFlexTreeNode) {
+					child.adoptBy(this, i);
+				} else {
+					// TODO: hook up events from hydrated to unhydrated nodes.
+				}
 			}
 		}
 	}
 
 	public borrowCursor(): ITreeCursorSynchronous {
-		return cursorForMapTreeField<MapTreeNodeViewGeneric<UnhydratedFlexTreeNode>>(
-			this.children,
-		);
+		return cursorForMapTreeField<MapTreeNodeViewGeneric<FlexTreeNode>>(this.children);
 	}
 
 	private getPendingDefault(): ContextualFieldProvider | undefined {
@@ -386,13 +393,13 @@ export class UnhydratedFlexTreeField
 		return this.getPendingDefault() !== undefined;
 	}
 
-	public get children(): UnhydratedFlexTreeNode[] {
+	public get children(): FlexTreeNode[] {
 		const provider = this.getPendingDefault();
 		if (provider) {
 			const content = provider("UseGlobalContext");
 			this.lazyChildren = content;
 		}
-		return this.lazyChildren as UnhydratedFlexTreeNode[];
+		return this.lazyChildren as FlexTreeNode[];
 	}
 
 	public get length(): number {
@@ -412,7 +419,7 @@ export class UnhydratedFlexTreeField
 		return m;
 	}
 
-	public [Symbol.iterator](): IterableIterator<UnhydratedFlexTreeNode> {
+	public [Symbol.iterator](): IterableIterator<FlexTreeNode> {
 		return this.children[Symbol.iterator]();
 	}
 
@@ -424,19 +431,17 @@ export class UnhydratedFlexTreeField
 	 * @remarks All edits to the field (i.e. mutations of the field's MapTrees) should be directed through this function.
 	 * This function ensures that the parent MapTree has no empty fields (which is an invariant of `MapTree`) after the mutation.
 	 */
-	protected edit(
-		edit: (mapTrees: UnhydratedFlexTreeNode[]) => void | UnhydratedFlexTreeNode[],
-	): void {
+	protected edit(edit: (mapTrees: FlexTreeNode[]) => void | FlexTreeNode[]): void {
 		// Clear parents for all old map trees.
 		for (const tree of this.children) {
-			tree.adoptBy(undefined);
+			orphan(tree);
 		}
 
 		this.lazyChildren = edit(this.children) ?? this.children;
 
 		// Set parents for all new map trees.
 		for (const [index, tree] of this.children.entries()) {
-			tree.adoptBy(this, index);
+			adoptNode(this, tree, index);
 		}
 
 		this.parent?.emitChangedEvent(this.key);
@@ -447,7 +452,7 @@ export class UnhydratedFlexTreeField
 	}
 
 	/** Unboxes leaf nodes to their values */
-	protected unboxed(index: number): TreeValue | UnhydratedFlexTreeNode {
+	protected unboxed(index: number): TreeValue | FlexTreeNode {
 		const child = this.children[index] ?? oob();
 		const value = child.value;
 		if (value !== undefined) {
@@ -457,6 +462,22 @@ export class UnhydratedFlexTreeField
 	}
 }
 
+function adoptNode(parent: UnhydratedFlexTreeField, node: FlexTreeNode, index: number): void {
+	if (node instanceof UnhydratedFlexTreeNode) {
+		node.adoptBy(parent, index);
+	} else {
+		// TODO: handle parenting for hydrated nodes.
+	}
+}
+
+function orphan(node: FlexTreeNode): void {
+	if (node instanceof UnhydratedFlexTreeNode) {
+		node.adoptBy(undefined);
+	} else {
+		// TODO: handle unparenting for hydrated nodes.
+	}
+}
+
 /**
  * The {@link Unhydrated} implementation of {@link FlexTreeOptionalField}.
  */
@@ -464,8 +485,9 @@ export class UnhydratedOptionalField
 	extends UnhydratedFlexTreeField
 	implements FlexTreeOptionalField
 {
-	public readonly editor = {
+	public readonly editor: OptionalFieldEditor<FlexibleNodeContent, FlexTreeNode> = {
 		set: (newContent: FlexibleNodeContent | undefined): void => {
+			// If the new content is a UnhydratedFlexTreeNode, it needs to have its parent pointer updated
 			if (newContent !== undefined) {
 				assert(
 					newContent instanceof UnhydratedFlexTreeNode,
@@ -481,8 +503,13 @@ export class UnhydratedOptionalField
 				}
 			});
 		},
-	} satisfies OptionalFieldEditBuilder<FlexibleNodeContent> &
-		ValueFieldEditBuilder<FlexibleNodeContent>;
+		clear: (): void => {
+			this.editor.set(undefined, true /* <- dummy wasEmpty argument */);
+		},
+		attach: (content): void => {
+			this.editor.set(content, true /* <- dummy wasEmpty argument */);
+		},
+	};
 
 	public get content(): FlexTreeUnknownUnboxed | undefined {
 		const value = this.children[0];
@@ -494,17 +521,34 @@ export class UnhydratedOptionalField
 	}
 }
 
-class UnhydratedRequiredField
-	extends UnhydratedOptionalField
+export class UnhydratedRequiredField
+	extends UnhydratedFlexTreeField
 	implements FlexTreeRequiredField
 {
-	public override get content(): FlexTreeUnknownUnboxed {
+	public readonly editor: RequiredFieldEditor<FlexibleNodeContent, FlexTreeNode> = {
+		set: (newContent: FlexibleNodeContent): void => {
+			assert(
+				newContent instanceof UnhydratedFlexTreeNode,
+				0xbb7 /* Expected unhydrated node */,
+			);
+
+			this.edit((mapTrees) => {
+				mapTrees[0] = newContent;
+			});
+		},
+		attach: (content): void => {
+			this.editor.set(content);
+		},
+	};
+
+	public get content(): FlexTreeUnknownUnboxed {
+		const value = this.children[0];
 		// This cannot use ?? since null is a legal value here.
 		assert(
-			super.content !== undefined,
+			value !== undefined,
 			0xa57 /* Expected EagerMapTree required field to have a value */,
 		);
-		return super.content;
+		return this.unboxed(0);
 	}
 }
 
@@ -515,13 +559,17 @@ export class UnhydratedSequenceField
 	extends UnhydratedFlexTreeField
 	implements FlexTreeSequenceField
 {
-	public readonly editor = {
+	public readonly editor: SequenceFieldEditor<
+		readonly FlexibleNodeContent[],
+		readonly FlexTreeNode[],
+		FlexTreeNode[]
+	> = {
 		insert: (index, newContent): void => {
 			for (const c of newContent) {
 				assert(c !== undefined, 0xa0a /* Unexpected sparse array content */);
-				assert(c instanceof UnhydratedFlexTreeNode, 0xbb8 /* Expected unhydrated node */);
+				// TODO: ensure somewhere checks for not already having parents
 			}
-			const newContentChecked = newContent as readonly UnhydratedFlexTreeNode[];
+			const newContentChecked: readonly FlexTreeNode[] = newContent;
 			this.edit((mapTrees) => {
 				if (newContent.length < 1000) {
 					// For "smallish arrays" (`1000` is not empirically derived), the `splice` function is appropriate...
@@ -532,17 +580,20 @@ export class UnhydratedSequenceField
 				}
 			});
 		},
-		remove: (index, count): UnhydratedFlexTreeNode[] => {
+		remove: (index, count): FlexTreeNode[] => {
 			for (let i = index; i < index + count; i++) {
 				const c = this.children[i];
 				assert(c !== undefined, 0xa0b /* Unexpected sparse array */);
 			}
-			let removed: UnhydratedFlexTreeNode[] | undefined;
+			let removed: FlexTreeNode[] | undefined;
 			this.edit((mapTrees) => {
 				removed = mapTrees.splice(index, count);
 			});
 			return removed ?? fail(0xb4a /* Expected removed to be set by edit */);
 		},
+		attach: (index, content: readonly FlexTreeNode[]): void => {
+			this.editor.insert(index, content);
+		},
 	} satisfies UnhydratedTreeSequenceFieldEditBuilder;
 
 	public at(index: number): FlexTreeUnknownUnboxed | undefined {

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

@@ -7,6 +7,7 @@ import {
 	normalizeAndEvaluateAnnotatedAllowedTypes,
 	type AnnotatedAllowedType,
 	type AllowedTypesFullEvaluated,
+	markSchemaMostDerived,
 } from "./allowedTypes.js";
 import { getTreeNodeSchemaPrivateData, type TreeNodeSchema } from "./treeNodeSchema.js";
 
@@ -25,6 +26,11 @@ export function walkNodeSchema(
 
 	visitedSet.add(schema);
 
+	// Ensure all reachable schema are marked as most derived.
+	// This ensures if multiple schema extending the same schema factory generated class are present (or have had instances of them constructed, or get instances of them constructed in the future),
+	// an error is reported.
+	markSchemaMostDerived(schema, false);
+
 	// Since walkNodeSchema is used in the implementation of TreeNodeSchemaPrivateData.idempotentInitialize,
 	// Avoid depending on it here to avoid circular dependencies for recursive schema.
 	// Instead normalize/evaluate the allowed types as needed.

package/src/simple-tree/createContext.ts

@@ -3,6 +3,7 @@
  * Licensed under the MIT License.
  */
 
+import { assert } from "@fluidframework/core-utils/internal";
 import { defaultSchemaPolicy } from "../feature-libraries/index.js";
 import { getOrCreate } from "../util/index.js";
 
@@ -18,24 +19,38 @@ import { toStoredSchema, toUnhydratedSchema } from "./toStoredSchema.js";
 
 const contextCache: WeakMap<ImplicitFieldSchema, Context> = new WeakMap();
 
+/**
+ * See note in {@link getUnhydratedContext}.
+ */
+let getUnhydratedContextIsRunning = false;
+
 /**
  * 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);
+	// Due to caching, calling this reentrantly can cause issues.
+	// Due to recursive schema, and generally lots of lazy initialization code depending on this, bugs with this going reentrant are not uncommon.
+	// To make debugging such cases much easier, we assert that this is not called reentrantly.
+	assert(!getUnhydratedContextIsRunning, "getUnhydratedContext should not be reentrant");
+	getUnhydratedContextIsRunning = true;
+	try {
+		return getOrCreate(contextCache, schema, (s) => {
+			const normalized = normalizeFieldSchema(schema);
 
-		const flexContext = new UnhydratedContext(
-			defaultSchemaPolicy,
-			toStoredSchema(schema, toUnhydratedSchema),
-		);
-		return new Context(
-			flexContext,
-			Context.schemaMapFromRootSchema(normalized.allowedTypesFull.evaluate()),
-		);
-	});
+			const flexContext = new UnhydratedContext(
+				defaultSchemaPolicy,
+				toStoredSchema(schema, toUnhydratedSchema),
+			);
+			return new Context(
+				flexContext,
+				Context.schemaMapFromRootSchema(normalized.allowedTypesFull.evaluate()),
+			);
+		});
+	} finally {
+		getUnhydratedContextIsRunning = false;
+	}
 }
 
 /**

package/src/simple-tree/fieldSchema.ts

@@ -8,7 +8,10 @@ import { Lazy } from "@fluidframework/core-utils/internal";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 
 import type { FieldKey } from "../core/index.js";
-import type { FlexTreeHydratedContextMinimal } from "../feature-libraries/index.js";
+import type {
+	FlexTreeHydratedContextMinimal,
+	FlexTreeNode,
+} from "../feature-libraries/index.js";
 import {
 	type MakeNominal,
 	brand,
@@ -22,7 +25,6 @@ import {
 import type {
 	TreeNodeSchema,
 	TreeNode,
-	UnhydratedFlexTreeNode,
 	ImplicitAllowedTypes,
 	TreeNodeFromImplicitAllowedTypes,
 	TreeLeafValue,
@@ -31,7 +33,11 @@ import type {
 } from "./core/index.js";
 import { AnnotatedAllowedTypesInternal, normalizeAllowedTypes } from "./core/index.js";
 
-import type { SimpleAllowedTypeAttributes, SimpleFieldSchema } from "./simpleSchema.js";
+import type {
+	SchemaType,
+	SimpleAllowedTypeAttributes,
+	SimpleFieldSchema,
+} from "./simpleSchema.js";
 import type { UnsafeUnknownSchema } from "./unsafeUnknownSchema.js";
 import type { InsertableContent } from "./unhydratedFlexTreeFromInsertable.js";
 
@@ -186,11 +192,11 @@ export interface FieldPropsAlpha<TCustomMetadata = unknown>
  */
 export type ContextualFieldProvider = (
 	context: FlexTreeHydratedContextMinimal | "UseGlobalContext",
-) => UnhydratedFlexTreeNode[];
+) => FlexTreeNode[];
 /**
  * A {@link FieldProvider} which can produce its content in a vacuum.
  */
-export type ConstantFieldProvider = () => UnhydratedFlexTreeNode[];
+export type ConstantFieldProvider = () => FlexTreeNode[];
 /**
  * A function which produces content for a field every time that it is called.
  */
@@ -383,7 +389,7 @@ export class FieldSchemaAlpha<
 		TCustomMetadata = unknown,
 	>
 	extends FieldSchema<Kind, Types, TCustomMetadata>
-	implements SimpleFieldSchema
+	implements SimpleFieldSchema<SchemaType.View>
 {
 	private readonly propsAlpha: FieldPropsAlpha<TCustomMetadata> | undefined;
 
@@ -412,7 +418,10 @@ export class FieldSchemaAlpha<
 		return this.allowedTypesFull.evaluateIdentifiers();
 	}
 
-	public get simpleAllowedTypes(): ReadonlyMap<string, SimpleAllowedTypeAttributes> {
+	public get simpleAllowedTypes(): ReadonlyMap<
+		string,
+		SimpleAllowedTypeAttributes<SchemaType.View>
+	> {
 		return AnnotatedAllowedTypesInternal.evaluateSimpleAllowedTypes(this.allowedTypesFull);
 	}
 

package/src/simple-tree/index.ts

@@ -75,6 +75,7 @@ export {
 	type SchemaCompatibilityStatus,
 	type ITreeConfigurationOptions,
 	SchemaFactory,
+	scoped,
 	SchemaFactoryBeta,
 	type SchemaStaticsBeta,
 	SchemaFactoryAlpha,
@@ -176,7 +177,6 @@ export {
 	allowUnused,
 	type FieldSchemaAlphaUnsafe,
 	getIdentifierFromNode,
-	type TreeSchema,
 	type ValidateRecursiveSchemaTemplate,
 	type FixRecursiveRecursionLimit,
 	schemaStatics,
@@ -188,6 +188,11 @@ export {
 	incrementalSummaryHint,
 	incrementalEncodingPolicyForAllowedTypes,
 	type SchemaFactory_base,
+	encodeSchemaCompatibilitySnapshot,
+	decodeSchemaCompatibilitySnapshot,
+	exportCompatibilitySchemaSnapshot,
+	importCompatibilitySchemaSnapshot,
+	checkCompatibility,
 } from "./api/index.js";
 export type {
 	SimpleTreeSchema,
@@ -201,6 +206,7 @@ export type {
 	SimpleObjectFieldSchema,
 	SimpleRecordNodeSchema,
 	SimpleAllowedTypeAttributes,
+	SchemaType,
 } from "./simpleSchema.js";
 export {
 	type ImplicitFieldSchema,
@@ -243,6 +249,7 @@ export {
 	type ObjectFromSchemaRecord,
 	ObjectNodeSchema,
 	type ObjectNodeSchemaPrivate,
+	objectSchema,
 	isObjectNodeSchema,
 	type TreeObjectNode,
 	setField,
@@ -254,7 +261,7 @@ export {
 	type TreeRecordNode,
 } from "./node-kinds/index.js";
 export {
-	unhydratedFlexTreeFromInsertable,
+	flexTreeFromInsertable as unhydratedFlexTreeFromInsertable,
 	type InsertableContent,
 	type FactoryContent,
 	type FactoryContentObject,
@@ -262,14 +269,13 @@ export {
 export {
 	prepareForInsertion,
 	prepareForInsertionContextless,
+	type PreparedContent,
 } from "./prepareForInsertion.js";
 export {
 	toStoredSchema,
-	getStoredSchema,
 	convertFieldKind,
 	toUpgradeSchema,
 	toInitialSchema,
-	convertField,
 	toUnhydratedSchema,
 	restrictiveStoredSchemaGenerationOptions,
 	permissiveStoredSchemaGenerationOptions,
@@ -282,10 +288,5 @@ export {
 	nullSchema,
 } from "./leafNodeSchema.js";
 export type { LeafSchema } from "./leafNodeSchema.js";
-export {
-	encodeSimpleSchema,
-	decodeSimpleSchema,
-	exportCompatibilitySchemaSnapshot,
-	importCompatibilitySchemaSnapshot,
-	checkCompatibility,
-} from "./api/index.js";
+export { getUnhydratedContext } from "./createContext.js";
+export { type TreeSchema, createTreeSchema } from "./treeSchema.js";

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

@@ -50,9 +50,9 @@ import {
 } from "../../core/index.js";
 import {
 	type FactoryContent,
+	flexTreeFromInsertableNode,
 	type InsertableContent,
 	unhydratedFlexTreeFromInsertable,
-	unhydratedFlexTreeFromInsertableNode,
 } from "../../unhydratedFlexTreeFromInsertable.js";
 import { prepareArrayContentForInsertion } from "../../prepareForInsertion.js";
 import {
@@ -72,7 +72,7 @@ import {
 	type JsonCompatibleReadOnlyObject,
 } from "../../../util/index.js";
 import { nullSchema } from "../../leafNodeSchema.js";
-import type { SimpleAllowedTypeAttributes } from "../../simpleSchema.js";
+import type { SchemaType, SimpleAllowedTypeAttributes } from "../../simpleSchema.js";
 
 /**
  * A covariant base type for {@link (TreeArrayNode:interface)}.
@@ -956,8 +956,10 @@ abstract class CustomArrayNodeBase<const T extends ImplicitAllowedTypes>
 	public insertAt(index: number, ...value: Insertable<T>): void {
 		const field = getSequenceField(this);
 		validateIndex(index, field, "TreeArrayNode.insertAt", true);
-		const content = this.#mapTreesFromFieldData(value);
-		field.editor.insert(index, content);
+		field.context.runInTransaction(() => {
+			const content = this.#mapTreesFromFieldData(value);
+			field.editor.attach(index, content);
+		});
 	}
 	public insertAtStart(...value: Insertable<T>): void {
 		this.insertAt(0, ...value);
@@ -1218,7 +1220,10 @@ export function arraySchema<
 			return lazyAllowedTypesIdentifiers.value;
 		}
 
-		public static get simpleAllowedTypes(): ReadonlyMap<string, SimpleAllowedTypeAttributes> {
+		public static get simpleAllowedTypes(): ReadonlyMap<
+			string,
+			SimpleAllowedTypeAttributes<SchemaType.View>
+		> {
 			return lazySimpleAllowedTypes.value;
 		}
 
@@ -1305,7 +1310,7 @@ export function arraySchema<
 function arrayChildToFlexTree(
 	child: InsertableContent,
 	allowedTypes: ReadonlySet<TreeNodeSchema>,
-): UnhydratedFlexTreeNode {
+): FlexTreeNode {
 	// We do not support undefined sequence entries.
 	// If we encounter an undefined entry, use null instead if supported by the schema, otherwise throw.
 	let childWithFallback = child;
@@ -1316,7 +1321,7 @@ function arrayChildToFlexTree(
 			throw new TypeError(`Received unsupported array entry value: ${child}.`);
 		}
 	}
-	return unhydratedFlexTreeFromInsertableNode(childWithFallback, allowedTypes);
+	return flexTreeFromInsertableNode(childWithFallback, allowedTypes);
 }
 
 /**

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

@@ -14,7 +14,7 @@ import type {
 	InsertableTreeNodeFromImplicitAllowedTypes,
 } from "../../core/index.js";
 
-import type { SimpleArrayNodeSchema } from "../../simpleSchema.js";
+import type { SchemaType, SimpleArrayNodeSchema } from "../../simpleSchema.js";
 
 /**
  * A schema for customizable {@link (TreeArrayNode:interface)}s.
@@ -35,7 +35,7 @@ export interface ArrayNodeCustomizableSchema<
 			undefined,
 			TCustomMetadata
 		>,
-		SimpleArrayNodeSchema<TCustomMetadata> {}
+		SimpleArrayNodeSchema<SchemaType.View, TCustomMetadata> {}
 
 /**
  * A schema for POJO emulation mode {@link (TreeArrayNode:interface)}s.
@@ -56,7 +56,7 @@ export interface ArrayNodePojoEmulationSchema<
 			undefined,
 			TCustomMetadata
 		>,
-		SimpleArrayNodeSchema<TCustomMetadata> {}
+		SimpleArrayNodeSchema<SchemaType.View, TCustomMetadata> {}
 
 /**
  * A schema for {@link (TreeArrayNode:interface)}s.

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

@@ -17,7 +17,7 @@ import {
 } from "../core/index.js";
 import { getUnhydratedContext } from "../createContext.js";
 import {
-	unhydratedFlexTreeFromInsertableNode,
+	flexTreeFromInsertableNode,
 	type InsertableContent,
 } from "../unhydratedFlexTreeFromInsertable.js";
 import type { MapNodeSchema } from "./map/index.js";
@@ -44,10 +44,7 @@ export function recordLikeDataToFlexContent(
 
 		// Omit undefined values - an entry with an undefined value is equivalent to one that has been removed or omitted
 		if (value !== undefined) {
-			const child = unhydratedFlexTreeFromInsertableNode(
-				value,
-				allowedChildTypes.evaluateSet(),
-			);
+			const child = flexTreeFromInsertableNode(value, allowedChildTypes.evaluateSet());
 			const field = createField(context, FieldKinds.optional.identifier, brand(key), [child]);
 			transformedFields.set(brand(key), field);
 		}

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

@@ -11,7 +11,7 @@ import {
 	type FlexibleNodeContent,
 	type FlexTreeNode,
 	type FlexTreeOptionalField,
-	type OptionalFieldEditBuilder,
+	type OptionalFieldEditor,
 } from "../../../feature-libraries/index.js";
 import { tryGetTreeNodeForField } from "../../getTreeNodeForField.js";
 import { createFieldSchema, FieldKind } from "../../fieldSchema.js";
@@ -65,7 +65,7 @@ import type {
 import { recordLikeDataToFlexContent } from "../common.js";
 import { MapNodeStoredSchema } from "../../../core/index.js";
 import type { NodeSchemaOptionsAlpha } from "../../api/index.js";
-import type { SimpleAllowedTypeAttributes } from "../../simpleSchema.js";
+import type { SchemaType, SimpleAllowedTypeAttributes } from "../../simpleSchema.js";
 
 /**
  * A map of string keys to tree objects.
@@ -177,14 +177,14 @@ abstract class CustomMapNodeBase<const T extends ImplicitAllowedTypes> extends T
 		return getInnerNode(this);
 	}
 
-	private editor(key: string): OptionalFieldEditBuilder<FlexibleNodeContent> {
+	private editor(key: string): OptionalFieldEditor<FlexibleNodeContent, FlexTreeNode> {
 		const field = this.innerNode.getBoxed(brand(key)) as FlexTreeOptionalField;
 		return field.editor;
 	}
 
 	public delete(key: string): void {
 		const field = this.innerNode.getBoxed(brand(key));
-		this.editor(key).set(undefined, field.length === 0);
+		this.editor(key).clear(field.length === 0);
 	}
 	public *entries(): IterableIterator<[string, TreeNodeFromImplicitAllowedTypes<T>]> {
 		const node = this.innerNode;
@@ -227,7 +227,7 @@ abstract class CustomMapNodeBase<const T extends ImplicitAllowedTypes> extends T
 
 		const field = node.getBoxed(brand(key));
 
-		this.editor(key).set(mapTree, field.length === 0);
+		this.editor(key).attach(mapTree, field.length === 0);
 		return this;
 	}
 	public get size(): number {
@@ -306,7 +306,10 @@ export function mapSchema<
 			return lazyAllowedTypesIdentifiers.value;
 		}
 
-		public static get simpleAllowedTypes(): ReadonlyMap<string, SimpleAllowedTypeAttributes> {
+		public static get simpleAllowedTypes(): ReadonlyMap<
+			string,
+			SimpleAllowedTypeAttributes<SchemaType.View>
+		> {
 			return lazySimpleAllowedTypes.value;
 		}