@fluidframework/tree 2.41.0-338186 → 2.41.0-338401

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/tree";
-export const pkgVersion = "2.41.0-338186";
+export const pkgVersion = "2.41.0-338401";

package/src/serializableDomainSchema.ts

@@ -4,6 +4,7 @@
  */
 
 import type { IFluidHandle } from "@fluidframework/core-interfaces";
+
 import {
 	SchemaFactory,
 	type FixRecursiveArraySchema,

package/src/shared-tree/treeAlpha.ts

@@ -36,6 +36,9 @@ import {
 	extractPersistedSchema,
 	type TreeBranch,
 	TreeViewConfigurationAlpha,
+	getStoredKey,
+	getPropertyKeyFromStoredKey,
+	treeNodeApi,
 	mapTreeFromNodeData,
 } from "../simple-tree/index.js";
 import type { JsonCompatible } from "../util/index.js";
@@ -50,6 +53,7 @@ import {
 	TreeCompressionStrategy,
 	type FieldBatch,
 	type FieldBatchEncodingContext,
+	fluidVersionToFieldBatchCodecWriteVersion,
 } from "../feature-libraries/index.js";
 import { independentInitializedView, type ViewContent } from "./independentView.js";
 import { SchematizingSimpleTreeView, ViewSlot } from "./schematizingTreeView.js";
@@ -207,6 +211,15 @@ export interface TreeAlpha {
 		compressedData: JsonCompatible<IFluidHandle>,
 		options: { idCompressor?: IIdCompressor } & ICodecOptions,
 	): Unhydrated<TreeFieldFromImplicitField<TSchema>>;
+
+	/**
+	 * The key of the given node under its parent.
+	 * @remarks
+	 * If `node` is an element in a {@link (TreeArrayNode:interface)}, this returns the index of `node` in the array node (a `number`).
+	 * If `node` is the root node, this returns undefined.
+	 * Otherwise, this returns the key of the field that it is under (a `string`).
+	 */
+	key2(node: TreeNode): string | number | undefined;
 }
 
 /**
@@ -307,7 +320,7 @@ export const TreeAlpha: TreeAlpha = {
 		},
 	): JsonCompatible<IFluidHandle> {
 		const schema = tryGetSchema(node) ?? fail(0xacf /* invalid input */);
-		const format = versionToFormat[options.oldestCompatibleClient];
+		const format = fluidVersionToFieldBatchCodecWriteVersion(options.oldestCompatibleClient);
 		const codec = makeFieldBatchCodec({ jsonValidator: noopValidator }, format);
 		const cursor = borrowFieldCursorFromTreeNodeOrValue(node);
 		const batch: FieldBatch = [cursor];
@@ -339,6 +352,21 @@ export const TreeAlpha: TreeAlpha = {
 		const view = independentInitializedView(config, options, content);
 		return TreeBeta.clone<TSchema>(view.root);
 	},
+
+	key2(node: TreeNode): string | number | undefined {
+		// If the parent is undefined, then this node is under the root field,
+		const parent = treeNodeApi.parent(node);
+		if (parent === undefined) {
+			return undefined;
+		}
+
+		// The flex-domain strictly operates in terms of "stored keys".
+		// To find the associated developer-facing "property key", we need to look up the field associated with
+		// the stored key from the flex-domain, and get property key its simple-domain counterpart was created with.
+		const storedKey = getStoredKey(node);
+		const parentSchema = treeNodeApi.schema(parent);
+		return getPropertyKeyFromStoredKey(parentSchema, storedKey);
+	},
 };
 
 function exportConcise(
@@ -390,10 +418,3 @@ function borrowFieldCursorFromTreeNodeOrValue(
 	const mapTree = mapTreeFromCursor(cursor);
 	return cursorForMapTreeField([mapTree]);
 }
-
-const versionToFormat = {
-	v2_0: 1,
-	v2_1: 1,
-	v2_2: 1,
-	v2_3: 1,
-};

package/src/sharedTreeAttributes.ts

@@ -4,6 +4,7 @@
  */
 
 import type { IChannelAttributes } from "@fluidframework/datastore-definitions/internal";
+
 import { pkgVersion } from "./packageVersion.js";
 
 /**

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

@@ -28,11 +28,12 @@ import {
 import {
 	cursorForMapTreeNode,
 	defaultSchemaPolicy,
+	inSchemaOrThrow,
 	mapTreeFromCursor,
 	type NodeIdentifierManager,
 } from "../../feature-libraries/index.js";
 import { isFieldInSchema } from "../../feature-libraries/index.js";
-import { inSchemaOrThrow, mapTreeFromNodeData } from "../toMapTree.js";
+import { mapTreeFromNodeData } from "../toMapTree.js";
 import { getUnhydratedContext } from "../createContext.js";
 import { createUnknownOptionalFieldPolicy } from "../objectNode.js";
 

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

@@ -44,7 +44,13 @@ export {
 	enumFromStrings,
 	singletonSchema,
 } from "./schemaCreationUtilities.js";
-export { treeNodeApi, type TreeNodeApi, tryGetSchema } from "./treeNodeApi.js";
+export {
+	treeNodeApi,
+	type TreeNodeApi,
+	tryGetSchema,
+	getStoredKey,
+	getPropertyKeyFromStoredKey,
+} from "./treeNodeApi.js";
 export {
 	createFromInsertable,
 	cursorFromInsertable,

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

@@ -288,7 +288,7 @@ export function tryGetSchema(value: unknown): undefined | TreeNodeSchema {
 /**
  * Gets the stored key with which the provided node is associated in the parent.
  */
-function getStoredKey(node: TreeNode): string | number {
+export function getStoredKey(node: TreeNode): string | number {
 	// Note: the flex domain strictly works with "stored keys", and knows nothing about the developer-facing
 	// "property keys".
 	const parentField = getOrCreateInnerNode(node).parentField;
@@ -309,7 +309,7 @@ function getStoredKey(node: TreeNode): string | number {
 /**
  * Given a node schema, gets the property key corresponding with the provided {@link FieldProps.key | stored key}.
  */
-function getPropertyKeyFromStoredKey(
+export function getPropertyKeyFromStoredKey(
 	schema: TreeNodeSchema,
 	storedKey: string | number,
 ): string | number {

package/src/simple-tree/arrayNode.ts

@@ -39,7 +39,7 @@ import {
 	type TreeNodeSchemaClass,
 } from "./core/index.js";
 import { type InsertableContent, mapTreeFromNodeData } from "./toMapTree.js";
-import { prepareArrayForInsertion } from "./prepareForInsertion.js";
+import { prepareArrayContentForInsertion } from "./prepareForInsertion.js";
 import {
 	getKernel,
 	UnhydratedFlexTreeNode,
@@ -862,7 +862,7 @@ abstract class CustomArrayNodeBase<const T extends ImplicitAllowedTypes>
 		const contentArray = content.flatMap((c): InsertableContent[] =>
 			c instanceof IterableTreeArrayContent ? Array.from(c) : [c],
 		);
-		const mapTrees = prepareArrayForInsertion(
+		const mapTrees = prepareArrayContentForInsertion(
 			contentArray,
 			this.simpleSchema,
 			sequenceField.context,

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

@@ -7,7 +7,7 @@ import type { TreeValue } from "../../core/index.js";
 import {
 	type InnerNode,
 	unhydratedFlexTreeNodeToTreeNode,
-	proxySlot,
+	simpleTreeNodeSlot,
 	createTreeNodeFromInner,
 } from "./treeNodeKernel.js";
 import type { TreeNode } from "./treeNode.js";
@@ -23,7 +23,7 @@ export function getOrCreateNodeFromInnerNode(flexNode: InnerNode): TreeNode | Tr
 	const cached =
 		flexNode instanceof UnhydratedFlexTreeNode
 			? unhydratedFlexTreeNodeToTreeNode.get(flexNode)
-			: flexNode.anchorNode.slots.get(proxySlot);
+			: flexNode.anchorNode.slots.get(simpleTreeNodeSlot);
 
 	if (cached !== undefined) {
 		return cached;

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

@@ -175,12 +175,7 @@ export class TreeNodeKernel {
 			};
 		} else {
 			// Hydrated case
-			const { anchorNode } = innerNode;
-			assert(
-				!anchorNode.slots.has(proxySlot),
-				0x7f5 /* Cannot associate an flex node with multiple simple-tree nodes */,
-			);
-			this.#hydrationState = this.createHydratedState(anchorNode);
+			this.#hydrationState = this.createHydratedState(innerNode.anchorNode);
 		}
 	}
 
@@ -197,16 +192,22 @@ export class TreeNodeKernel {
 
 	/**
 	 * Transition from {@link Unhydrated} to hydrated.
-	 * Bi-directionally associates the given hydrated TreeNode to the given anchor node.
+	 * Bi-directionally associates the given hydrated TreeNode to the anchor node at the provided path.
 	 * @remarks
 	 * Happens at most once for any given node.
-	 * Cleans up mappings to {@link UnhydratedFlexTreeNode} - it is assumed that they are no longer needed once the proxy has an anchor node.
+	 * Cleans up mappings to {@link UnhydratedFlexTreeNode} - it is assumed that they are no longer needed once this node has an anchor node.
 	 */
-	private hydrate(anchorNode: AnchorNode): void {
+	public hydrate(anchors: AnchorSet, path: UpPath): void {
 		assert(!this.disposed, 0xa2a /* cannot hydrate a disposed node */);
 		assert(!isHydrated(this.#hydrationState), 0xa2b /* hydration should only happen once */);
 		unhydratedFlexTreeNodeToTreeNodeInternal.delete(this.#hydrationState.innerNode);
+
+		const anchor = anchors.track(path);
+		const anchorNode =
+			anchors.locate(anchor) ?? fail(0xb42 /* Expected anchor node to be present */);
+
 		this.#hydrationState = this.createHydratedState(anchorNode);
+		this.#hydrationState.offAnchorNode.add(() => anchors.forget(anchor));
 
 		// If needed, register forwarding emitters for events from before hydration
 		if (this.#unhydratedEvents.evaluated) {
@@ -224,7 +225,11 @@ export class TreeNodeKernel {
 	}
 
 	private createHydratedState(anchorNode: AnchorNode): HydratedState {
-		anchorNode.slots.set(proxySlot, this.node);
+		assert(
+			!anchorNode.slots.has(simpleTreeNodeSlot),
+			0x7f5 /* Cannot associate an flex node with multiple simple-tree nodes */,
+		);
+		anchorNode.slots.set(simpleTreeNodeSlot, this.node);
 		return {
 			anchorNode,
 			offAnchorNode: new Set([
@@ -265,6 +270,7 @@ export class TreeNodeKernel {
 	}
 
 	public dispose(): void {
+		debugAssert(() => !this.disposed || "Cannot dispose a disposed node");
 		this.disposed = true;
 		if (isHydrated(this.#hydrationState)) {
 			for (const off of this.#hydrationState.offAnchorNode) {
@@ -305,7 +311,7 @@ export class TreeNodeKernel {
 		if (this.#hydrationState.innerNode === undefined) {
 			// Marinated case -> cooked
 			const anchorNode = this.#hydrationState.anchorNode;
-			// The proxy is bound to an anchor node, but it may or may not have an actual flex node yet
+			// This TreeNode is bound to an anchor node, but it may or may not have an actual flex node yet
 			const flexNode = anchorNode.slots.get(flexTreeSlot);
 			if (flexNode !== undefined) {
 				// If the flex node already exists, use it...
@@ -318,8 +324,6 @@ export class TreeNodeKernel {
 				context.checkout.forest.moveCursorToPath(anchorNode, cursor);
 				this.#hydrationState.innerNode = makeTree(context, cursor);
 				cursor.free();
-				// Calling this is a performance improvement, however, do this only after demand to avoid momentarily having no anchors to anchorNode
-				anchorForgetters?.get(this.node)?.();
 				if (!allowDeleted) {
 					assertFlexTreeEntityNotFreed(this.#hydrationState.innerNode);
 				}
@@ -335,35 +339,6 @@ export class TreeNodeKernel {
 		return this.#hydrationState.innerNode;
 	}
 
-	/**
-	 * Creates an anchor node and associates it with the given proxy.
-	 * @privateRemarks
-	 * Use `forgetters` to cleanup the anchor allocated by this function once the anchor is no longer needed.
-	 * In practice, this happens when either the anchor node is destroyed, or another anchor to the same node is created by a new flex node.
-	 *
-	 * The FlexTreeNode holds a reference to the same anchor, and has a lifetime at least as long as the simple-tree,
-	 * so this would be unnecessary except for the case of "marinated" nodes, which have an anchor,
-	 * but might not have a FlexTreeNode.
-	 * Handling this case is an optimization assuming that this extra anchor reference is cheaper than eagerly creating FlexTreeNodes.
-	 */
-	public anchorProxy(anchors: AnchorSet, path: UpPath): AnchorNode {
-		assert(!anchorForgetters.has(this.node), 0x91c /* Proxy anchor should not be set twice */);
-		const anchor = anchors.track(path);
-		const anchorNode =
-			anchors.locate(anchor) ?? fail(0xb42 /* Expected anchor node to be present */);
-		this.hydrate(anchorNode);
-		const forget = (): void => {
-			if (anchors.locate(anchor)) {
-				anchors.forget(anchor);
-			}
-			anchorForgetters.delete(this.node);
-			off();
-		};
-		anchorForgetters.set(this.node, forget);
-		const off = anchorNode.events.on("afterDestroy", forget);
-		return anchorNode;
-	}
-
 	/**
 	 * Retrieves the InnerNode associated with the given target via {@link setInnerNode}, if any.
 	 * @remarks
@@ -383,11 +358,6 @@ export class TreeNodeKernel {
 	}
 }
 
-/**
- * Used by {@link anchorProxy} as an optimization to ensure that only one anchor is remembered at a time for a given anchor node
- */
-const anchorForgetters = new WeakMap<TreeNode, () => void>();
-
 const kernelEvents = ["childrenChangedAfterBatch", "subtreeChangedAfterBatch"] as const;
 
 type KernelEvents = Pick<AnchorEvents, (typeof kernelEvents)[number]>;
@@ -423,22 +393,22 @@ export const unhydratedFlexTreeNodeToTreeNode =
 	>;
 
 /**
- * An anchor slot which associates an anchor with its corresponding TreeNode, if there is one.
+ * An anchor slot which associates an anchor with its corresponding {@link TreeNode}, if there is one.
  * @remarks
  * For this to work, we have to require that there is at most a single view using a given AnchorSet.
  * FlexTree already has this assumption, and we also assume there is a single simple-tree per FlexTree, so this is valid.
  */
-export const proxySlot = anchorSlot<TreeNode>();
+export const simpleTreeNodeSlot = anchorSlot<TreeNode>();
 
 /**
  * Dispose a TreeNode (if any) for an existing anchor without disposing the anchor.
  */
 export function tryDisposeTreeNode(anchorNode: AnchorNode): void {
-	const treeNode = anchorNode.slots.get(proxySlot);
+	const treeNode = anchorNode.slots.get(simpleTreeNodeSlot);
 	if (treeNode !== undefined) {
 		const kernel = getKernel(treeNode);
 		kernel.dispose();
-		anchorNode.slots.delete(proxySlot);
+		anchorNode.slots.delete(simpleTreeNodeSlot);
 	}
 }
 
@@ -483,7 +453,6 @@ export function getOrCreateInnerNode(treeNode: TreeNode, allowDeleted = false):
  * Gets a flex node from an anchor node
  */
 function flexNodeFromAnchor(anchorNode: AnchorNode): FlexTreeNode {
-	// the proxy is bound to an anchor node, but it may or may not have an actual flex node yet
 	const flexNode = anchorNode.slots.get(flexTreeSlot);
 	if (flexNode !== undefined) {
 		return flexNode; // If it does have a flex node, return it...
@@ -501,7 +470,7 @@ function flexNodeFromAnchor(anchorNode: AnchorNode): FlexTreeNode {
  * Gets a tree node from an anchor node
  */
 export function treeNodeFromAnchor(anchorNode: AnchorNode): TreeNode | TreeValue {
-	const cached = anchorNode.slots.get(proxySlot);
+	const cached = anchorNode.slots.get(simpleTreeNodeSlot);
 	if (cached !== undefined) {
 		return cached;
 	}

package/src/simple-tree/index.ts

@@ -88,6 +88,8 @@ export {
 	type TreeBranch,
 	type TreeBranchEvents,
 	tryGetSchema,
+	getStoredKey,
+	getPropertyKeyFromStoredKey,
 	applySchemaToParserOptions,
 	cursorFromVerbose,
 	verboseFromCursor,
@@ -184,7 +186,7 @@ export {
 	type NodeSchemaMetadata,
 	evaluateLazySchema,
 } from "./schemaTypes.js";
-export { getTreeNodeForField } from "./proxies.js";
+export { getTreeNodeForField } from "./getTreeNodeForField.js";
 export {
 	TreeArrayNode,
 	IterableTreeArrayContent,

package/src/simple-tree/mapNode.ts

@@ -9,7 +9,7 @@ import type {
 	FlexTreeOptionalField,
 	OptionalFieldEditBuilder,
 } from "../feature-libraries/index.js";
-import { getTreeNodeForField } from "./proxies.js";
+import { getTreeNodeForField } from "./getTreeNodeForField.js";
 import {
 	createFieldSchema,
 	FieldKind,

package/src/simple-tree/objectNode.ts

@@ -14,7 +14,7 @@ import {
 	type FlexTreeOptionalField,
 	type FlexTreeRequiredField,
 } from "../feature-libraries/index.js";
-import { getTreeNodeForField } from "./proxies.js";
+import { getTreeNodeForField } from "./getTreeNodeForField.js";
 import {
 	type ImplicitFieldSchema,
 	getStoredKey,

package/src/simple-tree/prepareForInsertion.ts

@@ -12,13 +12,19 @@ import type {
 	NodeIndex,
 	FieldKey,
 	DetachedField,
+	TreeFieldStoredSchema,
 } from "../core/index.js";
 import {
 	type FlexTreeContext,
 	getSchemaAndPolicy,
 	type FlexTreeHydratedContext,
+	FieldKinds,
 } from "../feature-libraries/index.js";
-import type { ImplicitAllowedTypes, ImplicitFieldSchema } from "./schemaTypes.js";
+import {
+	normalizeFieldSchema,
+	type ImplicitAllowedTypes,
+	type ImplicitFieldSchema,
+} from "./schemaTypes.js";
 import { type InsertableContent, mapTreeFromNodeData } from "./toMapTree.js";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 import { brand } from "../util/index.js";
@@ -28,12 +34,17 @@ import {
 	tryUnhydratedFlexTreeNode,
 	unhydratedFlexTreeNodeToTreeNode,
 } from "./core/index.js";
-import { debugAssert } from "@fluidframework/core-utils/internal";
+import { debugAssert, oob } from "@fluidframework/core-utils/internal";
+import { inSchemaOrThrow, isFieldInSchema } from "../feature-libraries/index.js";
+import { convertField } from "./toStoredSchema.js";
 
 /**
  * Prepare content from a user for insertion into a tree.
  * @remarks
  * This validates and converts the input, and if necessary invokes {@link prepareContentForHydration}.
+ *
+ * The next edit made to `destinationContext`'s forest must be the creation of a detached field containing this content,
+ * (Triggering {@link ForestEvents.afterRootFieldCreated}) otherwise hydration will break.
  */
 export function prepareForInsertion<TIn extends InsertableContent | undefined>(
 	data: TIn,
@@ -50,13 +61,18 @@ export function prepareForInsertion<TIn extends InsertableContent | undefined>(
 
 /**
  * {@link prepareForInsertion} but batched for array content.
+ * @remarks
+ * This is for inserting items into an array, not a inserting a {@link TreeArrayNode} (that would use {@link prepareForInsertion}).
+ *
+ * The next edits made to `destinationContext`'s forest must be the creation of a detached field.
+ * One edit for each item in `data`, in order.
+ *
  * @privateRemarks
- * TODO:
- * Experimentally it was determined that making separate calls to prepareContentForHydration for each array item did not work.
- * This should be understood and fixed or have the factors that cause it clearly documented.
- * If fixed, this function should be removed, and arrays can just map over prepareForInsertion.
+ * This has to be done as a single operation for all items in data
+ * (as opposed to mapping {@link prepareForInsertion} over the array)
+ * due to how the eventing in prepareContentForHydration works.
  */
-export function prepareArrayForInsertion(
+export function prepareArrayContentForInsertion(
 	data: readonly InsertableContent[],
 	schema: ImplicitAllowedTypes,
 	destinationContext: FlexTreeContext,
@@ -66,19 +82,27 @@ export function prepareArrayForInsertion(
 			item,
 			schema,
 			destinationContext.isHydrated() ? destinationContext.nodeKeyManager : undefined,
-			getSchemaAndPolicy(destinationContext),
 		),
 	);
 
-	if (destinationContext.isHydrated()) {
-		prepareContentForHydration(mapTrees, destinationContext.checkout.forest);
-	}
+	const fieldSchema = convertField(normalizeFieldSchema(schema));
+
+	validateAndPrepare(
+		getSchemaAndPolicy(destinationContext),
+		destinationContext.isHydrated() ? destinationContext : undefined,
+		{ kind: FieldKinds.sequence.identifier, types: fieldSchema.types },
+		mapTrees,
+	);
 
 	return mapTrees;
 }
 
 /**
  * Split out from {@link prepareForInsertion} as to allow use without a context.
+ *
+ * @param hydratedData - If specified, the `mapTrees` will be prepared for hydration into this context.
+ * `undefined` when `mapTrees` are being inserted into an {@link Unhydrated} tree.
+ *
  * @remarks
  * Adding this entry point is a workaround for initialize not currently having a context.
  */
@@ -88,20 +112,36 @@ export function prepareForInsertionContextless<TIn extends InsertableContent | u
 	schemaAndPolicy: SchemaAndPolicy,
 	hydratedData: Pick<FlexTreeHydratedContext, "checkout" | "nodeKeyManager"> | undefined,
 ): TIn extends undefined ? undefined : ExclusiveMapTree {
-	const mapTree = mapTreeFromNodeData(
-		data,
-		schema,
-		hydratedData?.nodeKeyManager,
-		schemaAndPolicy,
-	);
+	const mapTree = mapTreeFromNodeData(data, schema, hydratedData?.nodeKeyManager);
 
-	if (mapTree !== undefined && hydratedData !== undefined) {
-		prepareContentForHydration([mapTree], hydratedData.checkout.forest);
-	}
+	const contentArray = mapTree === undefined ? [] : [mapTree];
+	const fieldSchema = convertField(normalizeFieldSchema(schema));
+	validateAndPrepare(schemaAndPolicy, hydratedData, fieldSchema, contentArray);
 
 	return mapTree as TIn extends undefined ? undefined : ExclusiveMapTree;
 }
 
+/**
+ * If hydrating, do a final validation against the schema and prepare the content for hydration.
+ *
+ * @param hydratedData - If specified, the `mapTrees` will be prepared for hydration into this context.
+ * `undefined` when `mapTrees` are being inserted into an {@link Unhydrated} tree.
+ */
+function validateAndPrepare(
+	schemaAndPolicy: SchemaAndPolicy,
+	hydratedData: Pick<FlexTreeHydratedContext, "checkout" | "nodeKeyManager"> | undefined,
+	fieldSchema: TreeFieldStoredSchema,
+	mapTrees: ExclusiveMapTree[],
+): void {
+	if (hydratedData !== undefined) {
+		if (schemaAndPolicy.policy.validateSchema === true) {
+			const maybeError = isFieldInSchema(mapTrees, fieldSchema, schemaAndPolicy);
+			inSchemaOrThrow(maybeError);
+		}
+		prepareContentForHydration(mapTrees, hydratedData.checkout.forest);
+	}
+}
+
 /**
  * An {@link UpPath} that is just index zero in a {@link DetachedField} which can be modified at a later time.
  */
@@ -164,7 +204,7 @@ function prepareContentForHydration(
 		});
 	}
 
-	bindTreeNodes(batches, forest);
+	scheduleHydration(batches, forest);
 }
 
 function walkMapTree(
@@ -206,12 +246,13 @@ function walkMapTree(
 }
 
 /**
- * Register a collection of nodes with the forest so that they can be hydrated.
+ * Register events which will hydrate batches of nodes when they are inserted.
+ * The next edits to forest must be their insertions, in order, or data corruption can occur.
  * @param locatedNodes - the nodes to register with the forest.
  * Each index in this array expects its content to be added and produce its own `afterRootFieldCreated` event.
  * If array subsequence insertion is optimized to produce a single event, this will not work correctly as is, and will need to be modified to take in a single {@link LocatedNodesBatch}.
  */
-function bindTreeNodes(
+function scheduleHydration(
 	locatedNodes: readonly LocatedNodesBatch[],
 	forest: IForestSubscription,
 ): void {
@@ -220,13 +261,12 @@ function bindTreeNodes(
 		// Creating a new array emits one event per element in the array, so listen to the event once for each element
 		let i = 0;
 		const off = forest.events.on("afterRootFieldCreated", (fieldKey) => {
-			// Non null asserting here because of the length check above
-			// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-			const batch = locatedNodes[i]!;
+			// Indexing is safe here because of the length check above. This assumes the array has not been modified which should be the case.
+			const batch = locatedNodes[i] ?? oob();
 			debugAssert(() => batch.rootPath.parentField === placeholderKey);
 			batch.rootPath.parentField = brand(fieldKey);
 			for (const { path, node } of batch.paths) {
-				getKernel(node).anchorProxy(forest.anchors, path);
+				getKernel(node).hydrate(forest.anchors, path);
 			}
 			if (++i === locatedNodes.length) {
 				off();

package/src/simple-tree/toMapTree.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { assert, fail } from "@fluidframework/core-utils/internal";
+import { assert, fail, unreachableCase } from "@fluidframework/core-utils/internal";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 import { isFluidHandle } from "@fluidframework/runtime-utils/internal";
 
@@ -13,7 +13,6 @@ import {
 	type MapTree,
 	type TreeValue,
 	type ValueSchema,
-	type SchemaAndPolicy,
 	type ExclusiveMapTree,
 } from "../core/index.js";
 import {
@@ -47,7 +46,6 @@ import {
 	type Unhydrated,
 	UnhydratedFlexTreeNode,
 } from "./core/index.js";
-import { SchemaValidationErrors, isNodeInSchema } from "../feature-libraries/index.js";
 import { isObjectNodeSchema } from "./objectNodeTypes.js";
 import type { IFluidHandle } from "@fluidframework/core-interfaces";
 
@@ -105,19 +103,16 @@ export function mapTreeFromNodeData(
 	data: InsertableContent,
 	allowedTypes: ImplicitAllowedTypes,
 	context?: NodeIdentifierManager,
-	schemaValidationPolicy?: SchemaAndPolicy,
 ): ExclusiveMapTree;
 export function mapTreeFromNodeData(
 	data: InsertableContent | undefined,
 	allowedTypes: ImplicitFieldSchema,
 	context?: NodeIdentifierManager,
-	schemaValidationPolicy?: SchemaAndPolicy,
 ): ExclusiveMapTree | undefined;
 export function mapTreeFromNodeData(
 	data: InsertableContent | undefined,
 	allowedTypes: ImplicitFieldSchema,
 	context?: NodeIdentifierManager,
-	schemaValidationPolicy?: SchemaAndPolicy,
 ): ExclusiveMapTree | undefined {
 	const normalizedFieldSchema = normalizeFieldSchema(allowedTypes);
 
@@ -133,16 +128,6 @@ export function mapTreeFromNodeData(
 	// Add what defaults can be provided. If no `context` is providing, some defaults may still be missing.
 	addDefaultsToMapTree(mapTree, normalizedFieldSchema.allowedTypes, context);
 
-	if (schemaValidationPolicy?.policy.validateSchema === true) {
-		// TODO: BUG: AB#9131
-		// Since some defaults may still be missing, this can give false positives when context is undefined but schemaValidationPolicy is provided.
-		// For now disable this check when context is undefined:
-		if (context !== undefined) {
-			const maybeError = isNodeInSchema(mapTree, schemaValidationPolicy);
-			inSchemaOrThrow(maybeError);
-		}
-	}
-
 	return mapTree;
 }
 
@@ -196,21 +181,12 @@ function nodeDataToMapTree(
 			result = objectToMapTree(data, schema);
 			break;
 		default:
-			fail(0xae0 /* Unrecognized schema kind */);
+			unreachableCase(schema.kind);
 	}
 
 	return result;
 }
 
-/**
- * Throws a UsageError if maybeError indicates a tree is out of schema.
- */
-export function inSchemaOrThrow(maybeError: SchemaValidationErrors): void {
-	if (maybeError !== SchemaValidationErrors.NoError) {
-		throw new UsageError("Tree does not conform to schema.");
-	}
-}
-
 /**
  * Transforms data under a Leaf schema.
  * @param data - The tree data to be transformed. Must be a {@link TreeValue}.