@fluidframework/tree 2.4.0-299374 → 2.4.0

package/src/shared-tree/schematizingTreeView.ts

@@ -273,7 +273,7 @@ export class SchematizingSimpleTreeView<in out TRootSchema extends ImplicitField
 			this.view = view;
 			assert(
 				!this.checkout.forest.anchors.slots.has(SimpleContextSlot),
-				"extra simple tree context",
+				0xa47 /* extra simple tree context */,
 			);
 			this.checkout.forest.anchors.slots.set(
 				SimpleContextSlot,

package/src/shared-tree/sharedTree.ts

@@ -357,7 +357,7 @@ export function getBranch(view: TreeView<ImplicitFieldSchema>): TreeBranch;
 export function getBranch(treeOrView: ITree | TreeView<ImplicitFieldSchema>): TreeBranch {
 	assert(
 		treeOrView instanceof SharedTree || treeOrView instanceof SchematizingSimpleTreeView,
-		"Unsupported implementation",
+		0xa48 /* Unsupported implementation */,
 	);
 	const checkout: TreeCheckout = treeOrView.checkout;
 	// This cast is safe so long as TreeCheckout supports all the operations on the branch interface.

package/src/shared-tree/treeApi.ts

@@ -78,10 +78,7 @@ export interface RunTransaction {
 	 * If the transaction function throws an error then the transaction will be automatically rolled back (discarding any changes made to the tree so far) before the error is propagated up from this function.
 	 * If the transaction is rolled back, a corresponding change event will also be emitted for the rollback.
 	 */
-	// TODO: TreeView is invariant over the schema, so to accept any view, `any` is the only real option unless a non generic (or covariant) base type for view is introduced (which is planned).
-	// This use of any is actually type safe as it is only used as a constraint, and the actual strongly typed view (TView) is passed to the callback.
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	<TView extends TreeView<any>, TResult>(
+	<TView extends TreeView<ImplicitFieldSchema>, TResult>(
 		tree: TView,
 		transaction: (root: TView["root"]) => TResult,
 	): TResult;
@@ -126,9 +123,7 @@ export interface RunTransaction {
 	 * If the transaction function throws an error then the transaction will be automatically rolled back (discarding any changes made to the tree so far) before the error is propagated up from this function.
 	 * If the transaction is rolled back (whether by an error or by returning the {@link RunTransaction.rollback} | rollback value), a corresponding change event will also be emitted for the rollback.
 	 */
-	// See comment on previous overload about use of any here.
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	<TView extends TreeView<any>, TResult>(
+	<TView extends TreeView<ImplicitFieldSchema>, TResult>(
 		tree: TView,
 		transaction: (root: TView["root"]) => TResult | typeof rollback,
 	): TResult | typeof rollback;
@@ -166,9 +161,10 @@ export interface RunTransaction {
 	 * If the transaction function throws an error then the transaction will be automatically rolled back (discarding any changes made to the tree so far) before the error is propagated up from this function.
 	 * If the transaction is rolled back, a corresponding change event will also be emitted for the rollback.
 	 */
-	// See comment on previous overload about use of any here.
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	<TView extends TreeView<any>>(tree: TView, transaction: (root: TView["root"]) => void): void;
+	<TView extends TreeView<ImplicitFieldSchema>>(
+		tree: TView,
+		transaction: (root: TView["root"]) => void,
+	): void;
 	/**
 	 * Apply one or more edits to the tree as a single atomic unit.
 	 * @param node - The node that will be passed to `transaction`.
@@ -215,9 +211,7 @@ export interface RunTransaction {
 	 * If the transaction function throws an error then the transaction will be automatically rolled back (discarding any changes made to the tree so far) before the error is propagated up from this function.
 	 * If the transaction is rolled back, a corresponding change event will also be emitted for the rollback.
 	 */
-	// See comment on previous overload about use of any here.
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	<TView extends TreeView<any>, TResult>(
+	<TView extends TreeView<ImplicitFieldSchema>, TResult>(
 		tree: TView,
 		transaction: (root: TView["root"]) => TResult,
 		preconditions?: readonly TransactionConstraint[],
@@ -270,9 +264,7 @@ export interface RunTransaction {
 	 * If the transaction function throws an error then the transaction will be automatically rolled back (discarding any changes made to the tree so far) before the error is propagated up from this function.
 	 * If the transaction is rolled back (whether by an error or by returning the {@link RunTransaction.rollback} | rollback value), a corresponding change event will also be emitted for the rollback.
 	 */
-	// See comment on previous overload about use of any here.
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	<TView extends TreeView<any>, TResult>(
+	<TView extends TreeView<ImplicitFieldSchema>, TResult>(
 		tree: TView,
 		transaction: (root: TView["root"]) => TResult | typeof rollback,
 		preconditions?: readonly TransactionConstraint[],
@@ -321,9 +313,7 @@ export interface RunTransaction {
 	 * If the transaction function throws an error then the transaction will be automatically rolled back (discarding any changes made to the tree so far) before the error is propagated up from this function.
 	 * If the transaction is rolled back, a corresponding change event will also be emitted for the rollback.
 	 */
-	// See comment on previous overload about use of any here.
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	<TView extends TreeView<any>>(
+	<TView extends TreeView<ImplicitFieldSchema>>(
 		tree: TView,
 		transaction: (root: TView["root"]) => void,
 		preconditions?: readonly TransactionConstraint[],

package/src/shared-tree-core/branch.ts

@@ -253,7 +253,7 @@ export class SharedTreeBranch<
 		this.assertNotDisposed();
 
 		const revisionTag = taggedChange.revision;
-		assert(revisionTag !== undefined, "Revision tag must be provided");
+		assert(revisionTag !== undefined, 0xa49 /* Revision tag must be provided */);
 
 		const newHead = mintCommit(this.head, {
 			revision: revisionTag,

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

@@ -80,15 +80,15 @@ export function customFromCursorInner<TChild, THandle>(
 		case booleanSchema.identifier:
 		case nullSchema.identifier:
 		case stringSchema.identifier:
-			assert(reader.value !== undefined, "out of schema: missing value");
-			assert(!isFluidHandle(reader.value), "out of schema: unexpected FluidHandle");
+			assert(reader.value !== undefined, 0xa50 /* out of schema: missing value */);
+			assert(!isFluidHandle(reader.value), 0xa51 /* out of schema: unexpected FluidHandle */);
 			return reader.value;
 		case handleSchema.identifier:
-			assert(reader.value !== undefined, "out of schema: missing value");
-			assert(isFluidHandle(reader.value), "out of schema: expected FluidHandle");
+			assert(reader.value !== undefined, 0xa52 /* out of schema: missing value */);
+			assert(isFluidHandle(reader.value), 0xa53 /* out of schema: expected FluidHandle */);
 			return options.valueConverter(reader.value);
 		default: {
-			assert(reader.value === undefined, "out of schema: unexpected value");
+			assert(reader.value === undefined, 0xa54 /* out of schema: unexpected value */);
 			if (nodeSchema.kind === NodeKind.Array) {
 				const fields = inCursorField(reader, EmptyKey, () =>
 					mapCursorField(reader, () => childHandler(reader, options, schema)),

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

@@ -12,7 +12,6 @@ export {
 	type ITreeViewConfiguration,
 	type SchemaCompatibilityStatus,
 	type ITreeConfigurationOptions,
-	type TreeViewAlpha,
 } from "./tree.js";
 export { SchemaFactory, type ScopedSchemaName } from "./schemaFactory.js";
 export type {
@@ -63,10 +62,6 @@ export type {
 	NodeBuilderDataUnsafe,
 	NodeFromSchemaUnsafe,
 	ReadonlyMapInlined,
-	TreeNodeSchemaClassUnsafe,
-	TreeNodeSchemaUnsafe,
-	AllowedTypesUnsafe,
-	TreeNodeSchemaNonClassUnsafe,
 } from "./typesUnsafe.js";
 
 export type {

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

@@ -11,14 +11,11 @@ import type { Listenable } from "../../events/index.js";
 
 import {
 	type ImplicitFieldSchema,
-	type InsertableField,
 	type InsertableTreeFieldFromImplicitField,
 	type TreeFieldFromImplicitField,
-	type TreeLeafValue,
-	type UnsafeUnknownSchema,
 	FieldKind,
 } from "../schemaTypes.js";
-import { NodeKind, type TreeNode, type TreeNodeSchema } from "../core/index.js";
+import { NodeKind, type TreeNodeSchema } from "../core/index.js";
 import { toStoredSchema } from "../toFlexSchema.js";
 import { LeafNodeSchema } from "../leafNodeSchema.js";
 import { assert } from "@fluidframework/core-utils/internal";
@@ -366,7 +363,7 @@ export function checkUnion(union: Iterable<TreeNodeSchema>, errors: string[]): v
  * Thus this design was chosen at the risk of apps blindly accessing `root` then breaking unexpectedly when the document is incompatible.
  * @sealed @public
  */
-export interface TreeView<in out TSchema extends ImplicitFieldSchema> extends IDisposable {
+export interface TreeView<TSchema extends ImplicitFieldSchema> extends IDisposable {
 	/**
 	 * The current root of the tree.
 	 *
@@ -427,25 +424,6 @@ export interface TreeView<in out TSchema extends ImplicitFieldSchema> extends ID
 	readonly schema: TSchema;
 }
 
-/**
- * {@link TreeView} with proposed changes to the schema aware typing to allow use with `UnsafeUnknownSchema`.
- * @alpha
- */
-export interface TreeViewAlpha<
-	in out TSchema extends ImplicitFieldSchema | UnsafeUnknownSchema,
-> extends Omit<
-		TreeView<TSchema extends ImplicitFieldSchema ? TSchema : ImplicitFieldSchema>,
-		"root" | "initialize"
-	> {
-	get root(): TSchema extends ImplicitFieldSchema
-		? TreeFieldFromImplicitField<TSchema>
-		: TreeLeafValue | TreeNode;
-
-	set root(newRoot: InsertableField<TSchema>);
-
-	initialize(content: InsertableField<TSchema>): void;
-}
-
 /**
  * Information about a view schema's compatibility with the document's stored schema.
  *

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

@@ -3,8 +3,19 @@
  * Licensed under the MIT License.
  */
 
-import type { NodeKind, TreeChangeEvents, TreeNode, WithType } from "../core/index.js";
+import {
+	getKernel,
+	isTreeNode,
+	type NodeKind,
+	type TreeChangeEvents,
+	type TreeNode,
+	type Unhydrated,
+	type WithType,
+} from "../core/index.js";
+import type { ImplicitFieldSchema, TreeFieldFromImplicitField } from "../schemaTypes.js";
 import { treeNodeApi } from "./treeNodeApi.js";
+import { createFromCursor, cursorFromInsertable } from "./create.js";
+import type { ITreeCursorSynchronous } from "../../core/index.js";
 
 /**
  * Data included for {@link TreeChangeEventsBeta.nodeChanged}.
@@ -82,7 +93,7 @@ export interface TreeChangeEventsBeta<TNode extends TreeNode = TreeNode>
  * Extensions to {@link Tree} which are not yet stable.
  * @sealed @beta
  */
-export const TreeBeta = {
+export const TreeBeta: {
 	/**
 	 * Register an event listener on the given node.
 	 * @param node - The node whose events should be subscribed to.
@@ -91,6 +102,26 @@ export const TreeBeta = {
 	 * @returns A callback function which will deregister the event.
 	 * This callback should be called only once.
 	 */
+	on<K extends keyof TreeChangeEventsBeta<TNode>, TNode extends TreeNode>(
+		node: TNode,
+		eventName: K,
+		listener: NoInfer<TreeChangeEventsBeta<TNode>[K]>,
+	): () => void;
+
+	/**
+	 * Clones the persisted data associated with a node. Some key things to note:
+	 * - Local state, such as properties added to customized schema classes, will not be cloned. However, they will be
+	 * initialized to their default state just as if the node had been created via its constructor.
+	 * - Value node types (i.e., numbers, strings, booleans, nulls and Fluid handles) will be returned as is.
+	 * - The identifiers in the node's subtree will be preserved, i.e., they are not replaced with new values.
+	 *
+	 * @param node - The node to clone.
+	 * @returns A new unhydrated node with the same persisted data as the original node.
+	 */
+	clone<TSchema extends ImplicitFieldSchema>(
+		node: TreeFieldFromImplicitField<TSchema>,
+	): TreeFieldFromImplicitField<TSchema>;
+} = {
 	on<K extends keyof TreeChangeEventsBeta<TNode>, TNode extends TreeNode>(
 		node: TNode,
 		eventName: K,
@@ -98,4 +129,35 @@ export const TreeBeta = {
 	): () => void {
 		return treeNodeApi.on(node, eventName, listener);
 	},
-} as const;
+	clone<TSchema extends ImplicitFieldSchema>(
+		node: TreeFieldFromImplicitField<TSchema>,
+	): Unhydrated<TreeFieldFromImplicitField<TSchema>> {
+		/* The only non-TreeNode cases are {@link Value} (for an empty optional field) which can be returned as is. */
+		if (!isTreeNode(node)) {
+			return node;
+		}
+
+		const kernel = getKernel(node);
+		/*
+		 * For unhydrated nodes, we can create a cursor by calling `cursorFromInsertable` because the node
+		 * hasn't been inserted yet. We can then create a new node from the cursor.
+		 */
+		if (!kernel.isHydrated()) {
+			return createFromCursor(
+				kernel.schema,
+				cursorFromInsertable(kernel.schema, node),
+			) as Unhydrated<TreeFieldFromImplicitField<TSchema>>;
+		}
+
+		// For hydrated nodes, create a new cursor in the forest and then create a new node from the cursor.
+		const forest = kernel.context.flexContext.checkout.forest;
+		const cursor = forest.allocateCursor("tree.clone");
+		forest.moveCursorToPath(kernel.anchorNode, cursor);
+		const clonedNode = createFromCursor(
+			kernel.schema,
+			cursor as ITreeCursorSynchronous,
+		) as Unhydrated<TreeFieldFromImplicitField<TSchema>>;
+		cursor.free();
+		return clonedNode;
+	},
+};

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

@@ -6,24 +6,24 @@
 import type { RestrictiveStringRecord, _InlineTrick } from "../../util/index.js";
 
 import type {
+	AllowedTypes,
 	ApplyKind,
 	FieldKind,
 	FieldSchema,
 	ImplicitAllowedTypes,
 	ImplicitFieldSchema,
-	TreeLeafValue,
+	NodeFromSchema,
+	TreeNodeFromImplicitAllowedTypes,
 } from "../schemaTypes.js";
 import type {
 	NodeKind,
+	TreeNodeSchema,
 	WithType,
 	TreeNode,
 	Unhydrated,
-	InternalTreeNode,
-	TreeNodeSchema,
-	TreeNodeSchemaCore,
 } from "../core/index.js";
-import type { TreeArrayNodeBase } from "../arrayNode.js";
-import type { FlexListToUnion, LazyItem } from "../flexList.js";
+import type { TreeArrayNodeBase, TreeArrayNode } from "../arrayNode.js";
+import type { FlexListToUnion } from "../flexList.js";
 
 /*
  * TODO:
@@ -59,65 +59,6 @@ export type ObjectFromSchemaRecordUnsafe<
 	-readonly [Property in keyof T]: TreeFieldFromImplicitFieldUnsafe<T[Property]>;
 };
 
-/**
- * {@link Unenforced} version of {@link TreeNodeSchema}.
- * @remarks
- * Do note use this type directly: its only needed in the implementation of generic logic which define recursive schema, not when using recursive schema.
- * @system @public
- */
-export type TreeNodeSchemaUnsafe<
-	Name extends string = string,
-	Kind extends NodeKind = NodeKind,
-	TNode extends Unenforced<TreeNode | TreeLeafValue> = unknown,
-	TBuild = never,
-	ImplicitlyConstructable extends boolean = boolean,
-	Info = unknown,
-> =
-	| TreeNodeSchemaClassUnsafe<Name, Kind, TNode, TBuild, ImplicitlyConstructable, Info>
-	| TreeNodeSchemaNonClassUnsafe<Name, Kind, TNode, TBuild, ImplicitlyConstructable, Info>;
-
-/**
- * {@link Unenforced} version of {@link TreeNodeSchemaClass}.
- * @remarks
- * Do note use this type directly: its only needed in the implementation of generic logic which define recursive schema, not when using recursive schema.
- * @system @public
- */
-export interface TreeNodeSchemaClassUnsafe<
-	out Name extends string,
-	out Kind extends NodeKind,
-	// TODO: maybe this can be more specific (exclude leaves)
-	out TNode extends Unenforced<TreeNode | TreeLeafValue>,
-	in TInsertable = never,
-	out ImplicitlyConstructable extends boolean = boolean,
-	out Info = unknown,
-> extends TreeNodeSchemaCore<Name, Kind, ImplicitlyConstructable, Info> {
-	/**
-	 * Constructs an {@link Unhydrated} node with this schema.
-	 * @remarks
-	 * This constructor is also used internally to construct hydrated nodes with a different parameter type.
-	 * Therefore, overriding this constructor with different argument types is not type-safe and is not supported.
-	 * @sealed
-	 */
-	new (data: TInsertable | InternalTreeNode): Unhydrated<TNode>;
-}
-
-/**
- * {@link Unenforced} version of {@link TreeNodeSchemaNonClass}.
- * @remarks
- * Do note use this type directly: its only needed in the implementation of generic logic which define recursive schema, not when using recursive schema.
- * @system @public
- */
-export interface TreeNodeSchemaNonClassUnsafe<
-	out Name extends string,
-	out Kind extends NodeKind,
-	out TNode extends Unenforced<TreeNode | TreeLeafValue>,
-	in TInsertable = never,
-	out ImplicitlyConstructable extends boolean = boolean,
-	out Info = unknown,
-> extends TreeNodeSchemaCore<Name, Kind, ImplicitlyConstructable, Info> {
-	create(data: TInsertable): TNode;
-}
-
 /**
  * {@link Unenforced} version of {@link TreeObjectNode}.
  * @remarks
@@ -142,14 +83,6 @@ export type TreeFieldFromImplicitFieldUnsafe<TSchema extends Unenforced<Implicit
 			? TreeNodeFromImplicitAllowedTypesUnsafe<TSchema>
 			: unknown;
 
-/**
- * {@link Unenforced} version of {@link AllowedTypes}.
- * @remarks
- * Do note use this type directly: its only needed in the implementation of generic logic which define recursive schema, not when using recursive schema.
- * @system @public
- */
-export type AllowedTypesUnsafe = readonly LazyItem<TreeNodeSchemaUnsafe>[];
-
 /**
  * {@link Unenforced} version of {@link TreeNodeFromImplicitAllowedTypes}.
  * @remarks
@@ -158,11 +91,13 @@ export type AllowedTypesUnsafe = readonly LazyItem<TreeNodeSchemaUnsafe>[];
  */
 export type TreeNodeFromImplicitAllowedTypesUnsafe<
 	TSchema extends Unenforced<ImplicitAllowedTypes>,
-> = TSchema extends TreeNodeSchemaUnsafe
-	? NodeFromSchemaUnsafe<TSchema>
-	: TSchema extends AllowedTypesUnsafe
-		? NodeFromSchemaUnsafe<FlexListToUnion<TSchema>>
-		: unknown;
+> = TSchema extends ImplicitAllowedTypes
+	? TreeNodeFromImplicitAllowedTypes<TSchema>
+	: TSchema extends TreeNodeSchema
+		? NodeFromSchema<TSchema>
+		: TSchema extends AllowedTypes
+			? NodeFromSchema<FlexListToUnion<TSchema>>
+			: unknown;
 
 /**
  * {@link Unenforced} version of {@link InsertableTreeNodeFromImplicitAllowedTypes}.
@@ -172,7 +107,7 @@ export type TreeNodeFromImplicitAllowedTypesUnsafe<
  */
 export type InsertableTreeNodeFromImplicitAllowedTypesUnsafe<
 	TSchema extends Unenforced<ImplicitAllowedTypes>,
-> = TSchema extends AllowedTypesUnsafe
+> = TSchema extends AllowedTypes
 	? InsertableTypedNodeUnsafe<FlexListToUnion<TSchema>>
 	: InsertableTypedNodeUnsafe<TSchema>;
 
@@ -194,7 +129,7 @@ export type InsertableTypedNodeUnsafe<T extends Unenforced<TreeNodeSchema>> = [
  * @system @public
  */
 export type NodeFromSchemaUnsafe<T extends Unenforced<TreeNodeSchema>> =
-	T extends TreeNodeSchemaUnsafe<string, NodeKind, infer TNode> ? TNode : never;
+	T extends TreeNodeSchema<string, NodeKind, infer TNode> ? TNode : never;
 
 /**
  * {@link Unenforced} version of {@link InsertableTreeNodeFromImplicitAllowedTypes}.
@@ -203,7 +138,7 @@ export type NodeFromSchemaUnsafe<T extends Unenforced<TreeNodeSchema>> =
  * @system @public
  */
 export type NodeBuilderDataUnsafe<T extends Unenforced<TreeNodeSchema>> =
-	T extends TreeNodeSchemaUnsafe<string, NodeKind, unknown, infer TBuild> ? TBuild : never;
+	T extends TreeNodeSchema<string, NodeKind, unknown, infer TBuild> ? TBuild : never;
 
 /**
  * {@link Unenforced} version of {@link (TreeArrayNode:interface)}.
@@ -214,7 +149,8 @@ export type NodeBuilderDataUnsafe<T extends Unenforced<TreeNodeSchema>> =
 export interface TreeArrayNodeUnsafe<TAllowedTypes extends Unenforced<ImplicitAllowedTypes>>
 	extends TreeArrayNodeBase<
 		TreeNodeFromImplicitAllowedTypesUnsafe<TAllowedTypes>,
-		InsertableTreeNodeFromImplicitAllowedTypesUnsafe<TAllowedTypes>
+		InsertableTreeNodeFromImplicitAllowedTypesUnsafe<TAllowedTypes>,
+		TreeArrayNode
 	> {}
 
 /**

package/src/simple-tree/arrayNode.ts

@@ -18,7 +18,6 @@ import {
 	normalizeAllowedTypes,
 	type ImplicitAllowedTypes,
 	type InsertableTreeNodeFromImplicitAllowedTypes,
-	type TreeLeafValue,
 	type TreeNodeFromImplicitAllowedTypes,
 } from "./schemaTypes.js";
 import {
@@ -35,7 +34,6 @@ import {
 	type TreeNodeSchemaBoth,
 	getSimpleNodeSchemaFromInnerNode,
 	getOrCreateInnerNode,
-	type TreeNodeSchemaClass,
 } from "./core/index.js";
 import { type InsertableContent, mapTreeFromNodeData } from "./toMapTree.js";
 import { fail } from "../util/index.js";
@@ -47,19 +45,6 @@ import {
 import { TreeNodeValid, type MostDerivedData } from "./treeNodeValid.js";
 import { getUnhydratedContext } from "./createContext.js";
 
-/**
- * A covariant base type for {@link (TreeArrayNode:interface)}.
- *
- * This provides the readonly subset of TreeArrayNode functionality, and is used as the source interface for moves since that needs to be covariant.
- * @privateRemarks
- * Ideally this would just include `TreeNode, WithType<string, NodeKind.Array>` in the extends list but https://github.com/microsoft/TypeScript/issues/16936 prevents that from compiling.
- * As a workaround around for this TypeScript limitation, the conflicting type intersection is wrapped in `Awaited` (which has no effect on the type in this case) which allows it to compile.
- * @system @sealed @public
- */
-export interface ReadonlyArrayNode<out T = TreeNode | TreeLeafValue>
-	extends ReadonlyArray<T>,
-		Awaited<TreeNode & WithType<string, NodeKind.Array>> {}
-
 /**
  * A generic array type, used to defined types like {@link (TreeArrayNode:interface)}.
  *
@@ -68,8 +53,9 @@ export interface ReadonlyArrayNode<out T = TreeNode | TreeLeafValue>
  *
  * @system @sealed @public
  */
-export interface TreeArrayNodeBase<out T, in TNew, in TMoveFrom = ReadonlyArrayNode>
-	extends ReadonlyArrayNode<T> {
+export interface TreeArrayNodeBase<out T, in TNew, in TMoveFrom>
+	extends ReadonlyArray<T>,
+		TreeNode {
 	/**
 	 * Inserts new item(s) at a specified location.
 	 * @param index - The index at which to insert `value`.
@@ -380,7 +366,8 @@ export interface TreeArrayNode<
 	TAllowedTypes extends ImplicitAllowedTypes = ImplicitAllowedTypes,
 > extends TreeArrayNodeBase<
 		TreeNodeFromImplicitAllowedTypes<TAllowedTypes>,
-		InsertableTreeNodeFromImplicitAllowedTypes<TAllowedTypes>
+		InsertableTreeNodeFromImplicitAllowedTypes<TAllowedTypes>,
+		TreeArrayNode
 	> {}
 
 /**
@@ -430,7 +417,9 @@ export class IterableTreeArrayContent<T> implements Iterable<T> {
 /**
  * Given a array node proxy, returns its underlying LazySequence field.
  */
-function getSequenceField(arrayNode: ReadonlyArrayNode): FlexTreeSequenceField {
+function getSequenceField<TSimpleType extends ImplicitAllowedTypes>(
+	arrayNode: TreeArrayNode<TSimpleType>,
+): FlexTreeSequenceField {
 	return getOrCreateInnerNode(arrayNode).getBoxed(EmptyKey) as FlexTreeSequenceField;
 }
 
@@ -810,11 +799,6 @@ abstract class CustomArrayNodeBase<const T extends ImplicitAllowedTypes>
 	protected abstract get simpleSchema(): T;
 	protected abstract get allowedTypes(): ReadonlySet<TreeNodeSchema>;
 
-	public abstract override get [typeSchemaSymbol](): TreeNodeSchemaClass<
-		string,
-		NodeKind.Array
-	>;
-
 	public constructor(
 		input: Iterable<InsertableTreeNodeFromImplicitAllowedTypes<T>> | InternalTreeNode,
 	) {
@@ -917,13 +901,13 @@ abstract class CustomArrayNodeBase<const T extends ImplicitAllowedTypes>
 		}
 		field.editor.remove(removeStart, removeEnd - removeStart);
 	}
-	public moveToStart(sourceIndex: number, source?: ReadonlyArrayNode): void {
+	public moveToStart(sourceIndex: number, source?: TreeArrayNode): void {
 		const sourceArray = source ?? this;
 		const sourceField = getSequenceField(sourceArray);
 		validateIndex(sourceIndex, sourceField, "moveToStart");
 		this.moveRangeToIndex(0, sourceIndex, sourceIndex + 1, source);
 	}
-	public moveToEnd(sourceIndex: number, source?: ReadonlyArrayNode): void {
+	public moveToEnd(sourceIndex: number, source?: TreeArrayNode): void {
 		const sourceArray = source ?? this;
 		const sourceField = getSequenceField(sourceArray);
 		validateIndex(sourceIndex, sourceField, "moveToEnd");
@@ -932,7 +916,7 @@ abstract class CustomArrayNodeBase<const T extends ImplicitAllowedTypes>
 	public moveToIndex(
 		destinationGap: number,
 		sourceIndex: number,
-		source?: ReadonlyArrayNode,
+		source?: TreeArrayNode,
 	): void {
 		const sourceArray = source ?? this;
 		const sourceField = getSequenceField(sourceArray);
@@ -944,7 +928,7 @@ abstract class CustomArrayNodeBase<const T extends ImplicitAllowedTypes>
 	public moveRangeToStart(
 		sourceStart: number,
 		sourceEnd: number,
-		source?: ReadonlyArrayNode,
+		source?: TreeArrayNode,
 	): void {
 		validateIndexRange(
 			sourceStart,
@@ -954,11 +938,7 @@ abstract class CustomArrayNodeBase<const T extends ImplicitAllowedTypes>
 		);
 		this.moveRangeToIndex(0, sourceStart, sourceEnd, source);
 	}
-	public moveRangeToEnd(
-		sourceStart: number,
-		sourceEnd: number,
-		source?: ReadonlyArrayNode,
-	): void {
+	public moveRangeToEnd(sourceStart: number, sourceEnd: number, source?: TreeArrayNode): void {
 		validateIndexRange(
 			sourceStart,
 			sourceEnd,
@@ -971,7 +951,7 @@ abstract class CustomArrayNodeBase<const T extends ImplicitAllowedTypes>
 		destinationGap: number,
 		sourceStart: number,
 		sourceEnd: number,
-		source?: ReadonlyArrayNode,
+		source?: TreeArrayNode,
 	): void {
 		const destinationField = getSequenceField(this);
 		const destinationSchema = this.allowedTypes;

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

@@ -29,7 +29,7 @@ export function getSimpleContextFromInnerNode(innerNode: InnerNode): Context {
 	}
 
 	const context = innerNode.anchorNode.anchorSet.slots.get(SimpleContextSlot);
-	assert(context !== undefined, "missing simple tree context");
+	assert(context !== undefined, 0xa55 /* missing simple tree context */);
 
 	return context;
 }

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

@@ -29,7 +29,7 @@ import { fail } from "../../util/index.js";
 // TODO: decide how to deal with dependencies on flex-tree implementation.
 // eslint-disable-next-line import/no-internal-modules
 import { makeTree } from "../../feature-libraries/flex-tree/lazyNode.js";
-import { SimpleContextSlot, type Context } from "./context.js";
+import { SimpleContextSlot, type Context, type HydratedContext } from "./context.js";
 import { UnhydratedFlexTreeNode } from "./unhydratedFlexTree.js";
 
 const treeNodeToKernel = new WeakMap<TreeNode, TreeNodeKernel>();
@@ -267,6 +267,14 @@ export class TreeNodeKernel implements Listenable<KernelEvents> {
 		// TODO: go to the context and remove myself from withAnchors
 	}
 
+	public isHydrated(): this is { anchorNode: AnchorNode; context: HydratedContext } {
+		return isHydrated(this.#hydrationState);
+	}
+
+	public get anchorNode(): AnchorNode | undefined {
+		return isHydrated(this.#hydrationState) ? this.#hydrationState.anchorNode : undefined;
+	}
+
 	/**
 	 * Retrieves the flex node associated with the given target via {@link setInnerNode}.
 	 * @remarks
@@ -421,7 +429,7 @@ export function tryDisposeTreeNode(anchorNode: AnchorNode): void {
 export function getTreeNodeSchemaFromHydratedFlexNode(flexNode: FlexTreeNode): TreeNodeSchema {
 	assert(
 		flexNode.context.isHydrated(),
-		"getTreeNodeSchemaFromHydratedFlexNode only allows hydrated flex tree nodes",
+		0xa56 /* getTreeNodeSchemaFromHydratedFlexNode only allows hydrated flex tree nodes */,
 	);
 
 	const context =