@fluidframework/tree 2.74.0-370705 → 2.80.0

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, debugAssert } from "@fluidframework/core-utils/internal";
+import { assert, oob, fail } 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 SequenceFieldEditor,
-	type RequiredFieldEditor,
+	type OptionalFieldEditBuilder,
+	type ValueFieldEditBuilder,
+	type FlexibleNodeContent,
 	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 SequenceFieldEditor<FlexibleFieldContent, readonly FlexTreeNode[]> {}
+	extends SequenceFieldEditBuilder<FlexibleFieldContent, UnhydratedFlexTreeNode[]> {}
 
 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<FlexTreeNode>
+	implements FlexTreeNode, MapTreeNodeViewGeneric<UnhydratedFlexTreeNode>
 {
 	public isHydrated(): this is HydratedFlexTreeNode {
 		return false;
@@ -187,7 +187,13 @@ export class UnhydratedFlexTreeNode
 	public adoptBy(parent: undefined): void;
 	public adoptBy(parent: UnhydratedFlexTreeField, index: number): void;
 	public adoptBy(parent: UnhydratedFlexTreeField | undefined, index?: number): void {
-		if (parent !== undefined) {
+		if (parent === undefined) {
+			assert(
+				this.location !== unparentedLocation,
+				0xa09 /* Node may not be un-adopted if it does not have a parent */,
+			);
+			this.location = unparentedLocation;
+		} else {
 			assert(index !== undefined, 0xa08 /* Expected index */);
 			if (this.location !== unparentedLocation) {
 				throw new UsageError("A node may not be in more than one place in the tree");
@@ -207,12 +213,6 @@ export class UnhydratedFlexTreeNode
 				unhydratedNode = parentNode;
 			}
 			this.location = { parent, index };
-		} else {
-			assert(
-				this.location !== unparentedLocation,
-				0xa09 /* Node may not be un-adopted if it does not have a parent */,
-			);
-			this.location = unparentedLocation;
 		}
 	}
 
@@ -226,7 +226,7 @@ export class UnhydratedFlexTreeNode
 	}
 
 	public borrowCursor(): ITreeCursorSynchronous {
-		return cursorForMapTreeNode<MapTreeNodeViewGeneric<FlexTreeNode>>(this);
+		return cursorForMapTreeNode<MapTreeNodeViewGeneric<UnhydratedFlexTreeNode>>(this);
 	}
 
 	public tryGetField(key: FieldKey): UnhydratedFlexTreeField | undefined {
@@ -300,11 +300,6 @@ export class UnhydratedContext implements FlexTreeContext {
 	public isHydrated(): this is FlexTreeHydratedContext {
 		return false;
 	}
-
-	public runInTransaction(fn: () => void): void {
-		debugAssert(() => !this.isDisposed() || "Disposed");
-		fn();
-	}
 }
 
 // #region Fields
@@ -332,7 +327,7 @@ const unparentedLocation: LocationInField = {
  * The {@link Unhydrated} implementation of {@link FlexTreeField}.
  */
 export class UnhydratedFlexTreeField
-	implements FlexTreeField, MapTreeFieldViewGeneric<FlexTreeNode>
+	implements FlexTreeField, MapTreeFieldViewGeneric<UnhydratedFlexTreeNode>
 {
 	public [flexTreeMarker] = FlexTreeEntityKind.Field as const;
 
@@ -349,27 +344,25 @@ export class UnhydratedFlexTreeField
 		 * See {@link fillPendingDefaults}.
 		 * Note that any fields using a {@link ConstantFieldProvider} should be evaluated before constructing the UnhydratedFlexTreeField.
 		 */
-		private lazyChildren: FlexTreeNode[] | ContextualFieldProvider,
+		private lazyChildren: UnhydratedFlexTreeNode[] | 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()) {
-				if (child instanceof UnhydratedFlexTreeNode) {
-					child.adoptBy(this, i);
-				} else {
-					// TODO: hook up events from hydrated to unhydrated nodes.
-				}
+				child.adoptBy(this, i);
 			}
 		}
 	}
 
 	public borrowCursor(): ITreeCursorSynchronous {
-		return cursorForMapTreeField<MapTreeNodeViewGeneric<FlexTreeNode>>(this.children);
+		return cursorForMapTreeField<MapTreeNodeViewGeneric<UnhydratedFlexTreeNode>>(
+			this.children,
+		);
 	}
 
 	private getPendingDefault(): ContextualFieldProvider | undefined {
-		return !Array.isArray(this.lazyChildren) ? this.lazyChildren : undefined;
+		return Array.isArray(this.lazyChildren) ? undefined : this.lazyChildren;
 	}
 
 	/**
@@ -393,13 +386,13 @@ export class UnhydratedFlexTreeField
 		return this.getPendingDefault() !== undefined;
 	}
 
-	public get children(): FlexTreeNode[] {
+	public get children(): UnhydratedFlexTreeNode[] {
 		const provider = this.getPendingDefault();
 		if (provider) {
 			const content = provider("UseGlobalContext");
 			this.lazyChildren = content;
 		}
-		return this.lazyChildren as FlexTreeNode[];
+		return this.lazyChildren as UnhydratedFlexTreeNode[];
 	}
 
 	public get length(): number {
@@ -419,7 +412,7 @@ export class UnhydratedFlexTreeField
 		return m;
 	}
 
-	public [Symbol.iterator](): IterableIterator<FlexTreeNode> {
+	public [Symbol.iterator](): IterableIterator<UnhydratedFlexTreeNode> {
 		return this.children[Symbol.iterator]();
 	}
 
@@ -431,17 +424,19 @@ 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: FlexTreeNode[]) => void | FlexTreeNode[]): void {
+	protected edit(
+		edit: (mapTrees: UnhydratedFlexTreeNode[]) => void | UnhydratedFlexTreeNode[],
+	): void {
 		// Clear parents for all old map trees.
 		for (const tree of this.children) {
-			orphan(tree);
+			tree.adoptBy(undefined);
 		}
 
 		this.lazyChildren = edit(this.children) ?? this.children;
 
 		// Set parents for all new map trees.
 		for (const [index, tree] of this.children.entries()) {
-			adoptNode(this, tree, index);
+			tree.adoptBy(this, index);
 		}
 
 		this.parent?.emitChangedEvent(this.key);
@@ -452,7 +447,7 @@ export class UnhydratedFlexTreeField
 	}
 
 	/** Unboxes leaf nodes to their values */
-	protected unboxed(index: number): TreeValue | FlexTreeNode {
+	protected unboxed(index: number): TreeValue | UnhydratedFlexTreeNode {
 		const child = this.children[index] ?? oob();
 		const value = child.value;
 		if (value !== undefined) {
@@ -462,22 +457,6 @@ 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}.
  */
@@ -485,9 +464,8 @@ export class UnhydratedOptionalField
 	extends UnhydratedFlexTreeField
 	implements FlexTreeOptionalField
 {
-	public readonly editor: OptionalFieldEditor<FlexibleNodeContent, FlexTreeNode> = {
+	public readonly editor = {
 		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,
@@ -496,20 +474,15 @@ export class UnhydratedOptionalField
 			}
 
 			this.edit((mapTrees) => {
-				if (newContent !== undefined) {
-					mapTrees[0] = newContent;
-				} else {
+				if (newContent === undefined) {
 					mapTrees.length = 0;
+				} else {
+					mapTrees[0] = newContent;
 				}
 			});
 		},
-		clear: (): void => {
-			this.editor.set(undefined, true /* <- dummy wasEmpty argument */);
-		},
-		attach: (content): void => {
-			this.editor.set(content, true /* <- dummy wasEmpty argument */);
-		},
-	};
+	} satisfies OptionalFieldEditBuilder<FlexibleNodeContent> &
+		ValueFieldEditBuilder<FlexibleNodeContent>;
 
 	public get content(): FlexTreeUnknownUnboxed | undefined {
 		const value = this.children[0];
@@ -521,34 +494,17 @@ export class UnhydratedOptionalField
 	}
 }
 
-export class UnhydratedRequiredField
-	extends UnhydratedFlexTreeField
+class UnhydratedRequiredField
+	extends UnhydratedOptionalField
 	implements FlexTreeRequiredField
 {
-	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];
+	public override get content(): FlexTreeUnknownUnboxed {
 		// This cannot use ?? since null is a legal value here.
 		assert(
-			value !== undefined,
+			super.content !== undefined,
 			0xa57 /* Expected EagerMapTree required field to have a value */,
 		);
-		return this.unboxed(0);
+		return super.content;
 	}
 }
 
@@ -559,41 +515,34 @@ export class UnhydratedSequenceField
 	extends UnhydratedFlexTreeField
 	implements FlexTreeSequenceField
 {
-	public readonly editor: SequenceFieldEditor<
-		readonly FlexibleNodeContent[],
-		readonly FlexTreeNode[],
-		FlexTreeNode[]
-	> = {
+	public readonly editor = {
 		insert: (index, newContent): void => {
 			for (const c of newContent) {
 				assert(c !== undefined, 0xa0a /* Unexpected sparse array content */);
-				// TODO: ensure somewhere checks for not already having parents
+				assert(c instanceof UnhydratedFlexTreeNode, 0xbb8 /* Expected unhydrated node */);
 			}
-			const newContentChecked: readonly FlexTreeNode[] = newContent;
+			const newContentChecked = newContent as readonly UnhydratedFlexTreeNode[];
 			this.edit((mapTrees) => {
 				if (newContent.length < 1000) {
 					// For "smallish arrays" (`1000` is not empirically derived), the `splice` function is appropriate...
 					mapTrees.splice(index, 0, ...newContentChecked);
 				} else {
 					// ...but we avoid using `splice` + spread for very large input arrays since there is a limit on how many elements can be spread (too many will overflow the stack).
-					return mapTrees.slice(0, index).concat(newContentChecked, mapTrees.slice(index));
+					return [...mapTrees.slice(0, index), ...newContentChecked, ...mapTrees.slice(index)];
 				}
 			});
 		},
-		remove: (index, count): FlexTreeNode[] => {
+		remove: (index, count): UnhydratedFlexTreeNode[] => {
 			for (let i = index; i < index + count; i++) {
 				const c = this.children[i];
 				assert(c !== undefined, 0xa0b /* Unexpected sparse array */);
 			}
-			let removed: FlexTreeNode[] | undefined;
+			let removed: UnhydratedFlexTreeNode[] | 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 {
@@ -616,17 +565,22 @@ export function createField(
 ): UnhydratedFlexTreeField {
 	switch (args[1]) {
 		case FieldKinds.required.identifier:
-		case FieldKinds.identifier.identifier:
+		case FieldKinds.identifier.identifier: {
 			return new UnhydratedRequiredField(...args);
-		case FieldKinds.optional.identifier:
+		}
+		case FieldKinds.optional.identifier: {
 			return new UnhydratedOptionalField(...args);
-		case FieldKinds.sequence.identifier:
+		}
+		case FieldKinds.sequence.identifier: {
 			return new UnhydratedSequenceField(...args);
-		case FieldKinds.forbidden.identifier:
+		}
+		case FieldKinds.forbidden.identifier: {
 			// TODO: this seems to used by unknown optional fields. They should probably use "optional" not "Forbidden" schema.
 			return new UnhydratedFlexTreeField(...args);
-		default:
+		}
+		default: {
 			return fail(0xb9d /* unsupported field kind */);
+		}
 	}
 }
 

package/src/simple-tree/createContext.ts

@@ -33,7 +33,10 @@ export function getUnhydratedContext(schema: ImplicitFieldSchema): Context {
 	// 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");
+	assert(
+		!getUnhydratedContextIsRunning,
+		0xca7 /* getUnhydratedContext should not be reentrant */,
+	);
 	getUnhydratedContextIsRunning = true;
 	try {
 		return getOrCreate(contextCache, schema, (s) => {

package/src/simple-tree/fieldSchema.ts

@@ -8,10 +8,7 @@ import { Lazy } from "@fluidframework/core-utils/internal";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 
 import type { FieldKey } from "../core/index.js";
-import type {
-	FlexTreeHydratedContextMinimal,
-	FlexTreeNode,
-} from "../feature-libraries/index.js";
+import type { FlexTreeHydratedContextMinimal } from "../feature-libraries/index.js";
 import {
 	type MakeNominal,
 	brand,
@@ -25,6 +22,7 @@ import {
 import type {
 	TreeNodeSchema,
 	TreeNode,
+	UnhydratedFlexTreeNode,
 	ImplicitAllowedTypes,
 	TreeNodeFromImplicitAllowedTypes,
 	TreeLeafValue,
@@ -192,11 +190,11 @@ export interface FieldPropsAlpha<TCustomMetadata = unknown>
  */
 export type ContextualFieldProvider = (
 	context: FlexTreeHydratedContextMinimal | "UseGlobalContext",
-) => FlexTreeNode[];
+) => UnhydratedFlexTreeNode[];
 /**
  * A {@link FieldProvider} which can produce its content in a vacuum.
  */
-export type ConstantFieldProvider = () => FlexTreeNode[];
+export type ConstantFieldProvider = () => UnhydratedFlexTreeNode[];
 /**
  * A function which produces content for a field every time that it is called.
  */

package/src/simple-tree/getTreeNodeForField.ts

@@ -44,7 +44,8 @@ export function tryGetTreeNodeForField(
 			return (field as FlexTreeRequiredField).content as string;
 		}
 
-		default:
+		default: {
 			fail(0xadf /* invalid field kind */);
+		}
 	}
 }

package/src/simple-tree/index.ts

@@ -160,7 +160,9 @@ export {
 	type SchemaStatics,
 	type ITreeAlpha,
 	type TransactionConstraint,
+	type TransactionConstraintAlpha,
 	type NodeInDocumentConstraint,
+	type NoChangeConstraint,
 	type RunTransactionParams,
 	type VoidTransactionCallbackStatus,
 	type TransactionCallbackStatus,
@@ -193,6 +195,8 @@ export {
 	exportCompatibilitySchemaSnapshot,
 	importCompatibilitySchemaSnapshot,
 	checkCompatibility,
+	eraseSchemaDetails,
+	eraseSchemaDetailsSubclassable,
 } from "./api/index.js";
 export type {
 	SimpleTreeSchema,
@@ -261,7 +265,7 @@ export {
 	type TreeRecordNode,
 } from "./node-kinds/index.js";
 export {
-	flexTreeFromInsertable as unhydratedFlexTreeFromInsertable,
+	unhydratedFlexTreeFromInsertable,
 	type InsertableContent,
 	type FactoryContent,
 	type FactoryContentObject,
@@ -269,7 +273,6 @@ export {
 export {
 	prepareForInsertion,
 	prepareForInsertionContextless,
-	type PreparedContent,
 } from "./prepareForInsertion.js";
 export {
 	toStoredSchema,

package/src/simple-tree/leafNodeSchema.ts

@@ -207,7 +207,9 @@ function mapValueWithFallbacks(
 				// Our serialized data format does not support -0.
 				// Map such input to +0.
 				return 0;
-			} else if (!Number.isFinite(value)) {
+			} else if (Number.isFinite(value)) {
+				return value;
+			} else {
 				// Our serialized data format does not support NaN nor +/-∞.
 				// If the schema supports `null`, fall back to that. Otherwise, throw.
 				// This is intended to match JSON's behavior for such values.
@@ -216,22 +218,23 @@ function mapValueWithFallbacks(
 				} else {
 					throw new UsageError(`Received unsupported numeric value: ${value}.`);
 				}
-			} else {
-				return value;
 			}
 		}
 		case "string":
 		// TODO:
 		// This should detect invalid strings. Something like @stdlib/regexp-utf16-unpaired-surrogate could be used to do this.
 		// See SchemaFactory.string for details.
-		case "boolean":
+		case "boolean": {
 			return value;
+		}
 		case "object": {
 			if (value === null || isFluidHandle(value)) {
 				return value;
 			}
 		}
-		default:
+		// fallthrough
+		default: {
 			throw new UsageError(`Received unsupported leaf value: ${value}.`);
+		}
 	}
 }

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 {
@@ -888,7 +888,7 @@ abstract class CustomArrayNodeBase<const T extends ImplicitAllowedTypes>
 		)[];
 
 		const contentArray = content.flatMap((c): InsertableContent[] =>
-			c instanceof IterableTreeArrayContent ? Array.from(c) : [c],
+			c instanceof IterableTreeArrayContent ? [...c] : [c],
 		);
 
 		const kernel = getKernel(this);
@@ -918,7 +918,7 @@ abstract class CustomArrayNodeBase<const T extends ImplicitAllowedTypes>
 
 	public toJSON(): unknown {
 		// This override causes the class instance to `JSON.stringify` as `[a, b]` rather than `{0: a, 1: b}`.
-		return Array.from(this as unknown as TreeArrayNode);
+		return [...(this as unknown as TreeArrayNode)];
 	}
 
 	// Instances of this class are used as the dispatch object for the proxy,
@@ -956,10 +956,8 @@ 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);
-		field.context.runInTransaction(() => {
-			const content = this.#mapTreesFromFieldData(value);
-			field.editor.attach(index, content);
-		});
+		const content = this.#mapTreesFromFieldData(value);
+		field.editor.insert(index, content);
 	}
 	public insertAtStart(...value: Insertable<T>): void {
 		this.insertAt(0, ...value);
@@ -974,14 +972,14 @@ abstract class CustomArrayNodeBase<const T extends ImplicitAllowedTypes>
 	}
 	public removeRange(start?: number, end?: number): void {
 		const field = getSequenceField(this);
-		const { length } = field;
+		const { length, editor } = field;
 		const removeStart = start ?? 0;
 		validateIndex(removeStart, field, "TreeArrayNode.removeRange", true);
 
 		const removeEnd = Math.min(length, end ?? length);
 		validateIndexRange(removeStart, removeEnd, field, "TreeArrayNode.removeRange");
 
-		field.editor.remove(removeStart, removeEnd - removeStart);
+		editor.remove(removeStart, removeEnd - removeStart);
 	}
 	public moveToStart(sourceIndex: number, source?: ReadonlyArrayNode): void {
 		const sourceArray = source ?? this;
@@ -1046,7 +1044,7 @@ abstract class CustomArrayNodeBase<const T extends ImplicitAllowedTypes>
 			kernel.context.flexContext.schema.nodeSchema.get(brand(kernel.schema.identifier)) ??
 			fail(0xc16 /* missing schema for array node */)
 		).getFieldSchema(EmptyKey).types;
-		const sourceField = source !== undefined ? getSequenceField(source) : destinationField;
+		const sourceField = source === undefined ? destinationField : getSequenceField(source);
 
 		validateIndex(destinationGap, destinationField, "TreeArrayNode.moveRangeToIndex", true);
 		validateIndexRange(
@@ -1076,7 +1074,24 @@ abstract class CustomArrayNodeBase<const T extends ImplicitAllowedTypes>
 		}
 
 		const movedCount = sourceEnd - sourceStart;
-		if (!destinationField.context.isHydrated()) {
+		if (destinationField.context.isHydrated()) {
+			if (!sourceField.context.isHydrated()) {
+				throw new UsageError(
+					"Cannot move elements from an unhydrated array to a hydrated array.",
+				);
+			}
+			if (sourceField.context !== destinationField.context) {
+				throw new UsageError("Cannot move elements between two different TreeViews.");
+			}
+
+			destinationField.context.checkout.editor.move(
+				sourceField.getFieldPath(),
+				sourceStart,
+				movedCount,
+				destinationField.getFieldPath(),
+				destinationGap,
+			);
+		} else {
 			if (!(sourceField instanceof UnhydratedSequenceField)) {
 				throw new UsageError(
 					"Cannot move elements from a hydrated array to an unhydrated array.",
@@ -1107,23 +1122,6 @@ abstract class CustomArrayNodeBase<const T extends ImplicitAllowedTypes>
 					);
 				}
 			});
-		} else {
-			if (!sourceField.context.isHydrated()) {
-				throw new UsageError(
-					"Cannot move elements from an unhydrated array to a hydrated array.",
-				);
-			}
-			if (sourceField.context !== destinationField.context) {
-				throw new UsageError("Cannot move elements between two different TreeViews.");
-			}
-
-			destinationField.context.checkout.editor.move(
-				sourceField.getFieldPath(),
-				sourceStart,
-				movedCount,
-				destinationField.getFieldPath(),
-				destinationGap,
-			);
 		}
 	}
 
@@ -1310,7 +1308,7 @@ export function arraySchema<
 function arrayChildToFlexTree(
 	child: InsertableContent,
 	allowedTypes: ReadonlySet<TreeNodeSchema>,
-): FlexTreeNode {
+): UnhydratedFlexTreeNode {
 	// 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;
@@ -1321,7 +1319,7 @@ function arrayChildToFlexTree(
 			throw new TypeError(`Received unsupported array entry value: ${child}.`);
 		}
 	}
-	return flexTreeFromInsertableNode(childWithFallback, allowedTypes);
+	return unhydratedFlexTreeFromInsertableNode(childWithFallback, allowedTypes);
 }
 
 /**

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

@@ -17,7 +17,7 @@ import {
 } from "../core/index.js";
 import { getUnhydratedContext } from "../createContext.js";
 import {
-	flexTreeFromInsertableNode,
+	unhydratedFlexTreeFromInsertableNode,
 	type InsertableContent,
 } from "../unhydratedFlexTreeFromInsertable.js";
 import type { MapNodeSchema } from "./map/index.js";
@@ -44,7 +44,10 @@ 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 = flexTreeFromInsertableNode(value, allowedChildTypes.evaluateSet());
+			const child = unhydratedFlexTreeFromInsertableNode(
+				value,
+				allowedChildTypes.evaluateSet(),
+			);
 			const field = createField(context, FieldKinds.optional.identifier, brand(key), [child]);
 			transformedFields.set(brand(key), field);
 		}