@fluidframework/tree 2.51.0 → 2.52.0

package/src/index.ts

@@ -114,6 +114,7 @@ export {
 	type SchemaCompatibilityStatus,
 	type FieldProps,
 	type FieldPropsAlpha,
+	normalizeFieldSchema,
 	type InternalTreeNode,
 	type WithType,
 	type NodeChangedData,
@@ -214,6 +215,10 @@ export {
 	type SimpleObjectFieldSchema,
 	type SimpleRecordNodeSchema,
 	normalizeAllowedTypes,
+	walkFieldSchema,
+	walkNodeSchema,
+	walkAllowedTypes,
+	type SchemaVisitor,
 	getSimpleSchema,
 	type ReadonlyArrayNode,
 	type InsertableTreeNodeFromAllowedTypes,

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/tree";
-export const pkgVersion = "2.51.0";
+export const pkgVersion = "2.52.0";

package/src/shared-tree/independentView.ts

@@ -12,9 +12,11 @@ import {
 
 import type { ICodecOptions } from "../codec/index.js";
 import {
+	type ITreeCursorSynchronous,
 	type RevisionTag,
 	RevisionTagCodec,
 	SchemaVersion,
+	type TreeStoredSchema,
 	TreeStoredSchemaRepository,
 } from "../core/index.js";
 import {
@@ -24,7 +26,6 @@ import {
 	type FieldBatchEncodingContext,
 	defaultSchemaPolicy,
 	TreeCompressionStrategy,
-	initializeForest,
 } from "../feature-libraries/index.js";
 // eslint-disable-next-line import/no-internal-modules
 import type { Format } from "../feature-libraries/schema-index/formatV1.js";
@@ -41,6 +42,7 @@ import {
 } from "./sharedTree.js";
 import { createTreeCheckout } from "./treeCheckout.js";
 import { SchematizingSimpleTreeView } from "./schematizingTreeView.js";
+import { initialize } from "./schematizeTree.js";
 
 /**
  * Create an uninitialized {@link TreeView} that is not tied to any {@link ITree} instance.
@@ -85,6 +87,8 @@ export function independentView<const TSchema extends ImplicitFieldSchema>(
  * Such a view can never experience collaboration or be persisted to to a Fluid Container.
  *
  * This can be useful for testing, as well as use-cases like working on local files instead of documents stored in some Fluid service.
+ * @privateRemarks
+ * TODO: Providing an API which generates a {@link ViewableTree} extended with export options from {@link ITreeAlpha} and maybe even branching APIs would likely be better that just exposing a {@link TreeViewAlpha}.
  * @alpha
  */
 export function independentInitializedView<const TSchema extends ImplicitFieldSchema>(
@@ -92,22 +96,11 @@ export function independentInitializedView<const TSchema extends ImplicitFieldSc
 	options: ForestOptions & ICodecOptions,
 	content: ViewContent,
 ): TreeViewAlpha<TSchema> {
-	const breaker = new Breakable("independentInitializedView");
 	const idCompressor: IIdCompressor = content.idCompressor;
-	const mintRevisionTag = (): RevisionTag => idCompressor.generateCompressedId();
-	const revisionTagCodec = new RevisionTagCodec(idCompressor);
-
 	const fieldBatchCodec = makeFieldBatchCodec(options, 1);
 	const schemaCodec = makeSchemaCodec(options, SchemaVersion.v1);
 
-	const schema = new TreeStoredSchemaRepository(schemaCodec.decode(content.schema as Format));
-	const forest = buildConfiguredForest(
-		breaker,
-		options.forest ?? defaultSharedTreeOptions.forest,
-		schema,
-		idCompressor,
-	);
-
+	const schema = schemaCodec.decode(content.schema as Format);
 	const context: FieldBatchEncodingContext = {
 		encodeType: TreeCompressionStrategy.Compressed,
 		idCompressor,
@@ -117,21 +110,54 @@ export function independentInitializedView<const TSchema extends ImplicitFieldSc
 
 	const fieldCursors = fieldBatchCodec.decode(content.tree as JsonCompatibleReadOnly, context);
 	assert(fieldCursors.length === 1, 0xa5b /* must have exactly 1 field in batch */);
-	// Checked above.
-	// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-	initializeForest(forest, fieldCursors[0]!, revisionTagCodec, idCompressor, false);
+
+	return independentInitializedViewInternal(
+		config,
+		options,
+		schema,
+		// Checked above.
+		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+		fieldCursors[0]!,
+		idCompressor,
+	);
+}
+
+/**
+ * {@link independentInitializedView} but using internal types instead of persisted data formats.
+ */
+export function independentInitializedViewInternal<const TSchema extends ImplicitFieldSchema>(
+	config: TreeViewConfiguration<TSchema>,
+	options: ForestOptions & ICodecOptions,
+	schema: TreeStoredSchema,
+	rootFieldCursor: ITreeCursorSynchronous,
+	idCompressor: IIdCompressor,
+): SchematizingSimpleTreeView<TSchema> {
+	const breaker = new Breakable("independentInitializedView");
+	const revisionTagCodec = new RevisionTagCodec(idCompressor);
+	const mintRevisionTag = (): RevisionTag => idCompressor.generateCompressedId();
+
+	// To ensure the forest is in schema when constructed, start it with an empty schema and set the schema repository content later.
+	const schemaRepository = new TreeStoredSchemaRepository();
+
+	const forest = buildConfiguredForest(
+		breaker,
+		options.forest ?? defaultSharedTreeOptions.forest,
+		schemaRepository,
+		idCompressor,
+	);
 
 	const checkout = createTreeCheckout(idCompressor, mintRevisionTag, revisionTagCodec, {
 		forest,
-		schema,
+		schema: schemaRepository,
 		breaker,
 	});
-	const out: TreeViewAlpha<TSchema> = new SchematizingSimpleTreeView<TSchema>(
+
+	initialize(checkout, { schema, initialTree: rootFieldCursor });
+	return new SchematizingSimpleTreeView<TSchema>(
 		checkout,
 		config,
 		createNodeIdentifierManager(idCompressor),
 	);
-	return out;
 }
 
 /**

package/src/shared-tree/schematizeTree.ts

@@ -219,7 +219,7 @@ export function ensureSchema(
 			return false;
 		}
 		case UpdateType.SchemaCompatible: {
-			checkout.updateSchema(toStoredSchema(viewSchema.viewSchemaRoot));
+			checkout.updateSchema(toStoredSchema(viewSchema.viewSchema.root));
 			return true;
 		}
 		default: {

package/src/shared-tree/schematizingTreeView.ts

@@ -12,7 +12,7 @@ import type {
 import { assert, unreachableCase } from "@fluidframework/core-utils/internal";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 
-import { anchorSlot, type SchemaPolicy } from "../core/index.js";
+import { anchorSlot } from "../core/index.js";
 import {
 	type NodeIdentifierManager,
 	defaultSchemaPolicy,
@@ -49,11 +49,12 @@ import {
 	HydratedContext,
 	SimpleContextSlot,
 	areImplicitFieldSchemaEqual,
-	createUnknownOptionalFieldPolicy,
 	prepareForInsertionContextless,
 	type FieldSchema,
 	toStoredSchema,
 	tryDisposeTreeNode,
+	FieldSchemaAlpha,
+	TreeViewConfigurationAlpha,
 } from "../simple-tree/index.js";
 import {
 	type Breakable,
@@ -90,7 +91,6 @@ export class SchematizingSimpleTreeView<
 	 * Undefined iff uninitialized or disposed.
 	 */
 	private currentCompatibility: SchemaCompatibilityStatus | undefined;
-	private readonly schemaPolicy: SchemaPolicy;
 	public readonly events: Listenable<TreeViewEvents & TreeBranchEvents> &
 		IEmitter<TreeViewEvents & TreeBranchEvents> &
 		HasListeners<TreeViewEvents & TreeBranchEvents> = createEmitter();
@@ -132,13 +132,10 @@ export class SchematizingSimpleTreeView<
 		checkout.forest.anchors.slots.set(ViewSlot, this);
 
 		this.rootFieldSchema = normalizeFieldSchema(config.schema);
-		this.schemaPolicy = {
-			...defaultSchemaPolicy,
-			validateSchema: config.enableSchemaValidation,
-			allowUnknownOptionalFields: createUnknownOptionalFieldPolicy(this.rootFieldSchema),
-		};
 
-		this.viewSchema = new SchemaCompatibilityTester(this.schemaPolicy, this.rootFieldSchema);
+		const configAlpha = new TreeViewConfigurationAlpha({ schema: config.schema });
+
+		this.viewSchema = new SchemaCompatibilityTester(configAlpha);
 		// This must be initialized before `update` can be called.
 		this.currentCompatibility = {
 			canView: false,
@@ -175,13 +172,13 @@ export class SchematizingSimpleTreeView<
 		}
 
 		this.runSchemaEdit(() => {
-			const schema = toStoredSchema(this.viewSchema.viewSchemaRoot);
+			const schema = toStoredSchema(this.config.schema);
 			const mapTree = prepareForInsertionContextless(
 				content as InsertableContent | undefined,
 				this.rootFieldSchema,
 				{
 					schema,
-					policy: this.schemaPolicy,
+					policy: defaultSchemaPolicy,
 				},
 				this,
 			);
@@ -316,16 +313,22 @@ export class SchematizingSimpleTreeView<
 
 		if (compatibility.canView) {
 			this.flexTreeContext = new Context(
-				this.schemaPolicy,
+				defaultSchemaPolicy,
 				this.checkout,
 				this.nodeKeyManager,
 			);
 			assert(!slots.has(SimpleContextSlot), 0xa47 /* extra simple tree context */);
+			assert(
+				this.rootFieldSchema instanceof FieldSchemaAlpha,
+				0xbfa /* all field schema should be FieldSchemaAlpha */,
+			);
 			slots.set(
 				SimpleContextSlot,
 				new HydratedContext(
-					normalizeFieldSchema(this.rootFieldSchema).annotatedAllowedTypesNormalized,
 					this.flexTreeContext,
+					HydratedContext.schemaMapFromRootSchema(
+						this.rootFieldSchema.annotatedAllowedTypesNormalized,
+					),
 				),
 			);
 

package/src/shared-tree/sharedTree.ts

@@ -3,11 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import type {
-	ErasedType,
-	IFluidHandle,
-	IFluidLoadable,
-} from "@fluidframework/core-interfaces/internal";
+import type { ErasedType, IFluidLoadable } from "@fluidframework/core-interfaces/internal";
 import { assert, fail } from "@fluidframework/core-utils/internal";
 import type { IChannelStorageService } from "@fluidframework/datastore-definitions/internal";
 import type { IIdCompressor } from "@fluidframework/id-compressor";
@@ -31,7 +27,6 @@ import {
 	type FieldKey,
 	type GraphCommit,
 	type IEditableForest,
-	type ITreeCursor,
 	type JsonableTree,
 	LeafNodeStoredSchema,
 	MapNodeStoredSchema,
@@ -40,7 +35,6 @@ import {
 	SchemaVersion,
 	type TaggedChange,
 	type TreeFieldStoredSchema,
-	type TreeNodeSchemaIdentifier,
 	type TreeNodeStoredSchema,
 	type TreeStoredSchema,
 	TreeStoredSchemaRepository,
@@ -85,10 +79,7 @@ import {
 	type VerboseTree,
 	tryStoredSchemaAsArray,
 	type SimpleNodeSchema,
-	customFromCursorStored,
 	FieldKind,
-	type CustomTreeNode,
-	type CustomTreeValue,
 	type ITreeAlpha,
 	type SimpleObjectFieldSchema,
 } from "../simple-tree/index.js";
@@ -382,21 +373,7 @@ export class SharedTreeKernel
 	}
 
 	public exportVerbose(): VerboseTree | undefined {
-		const cursor = this.checkout.forest.allocateCursor("contentSnapshot");
-		try {
-			moveToDetachedField(this.checkout.forest, cursor);
-			const length = cursor.getFieldLength();
-			if (length === 0) {
-				return undefined;
-			} else if (length === 1) {
-				cursor.enterNode(0);
-				return verboseFromCursor(cursor, this.storedSchema.nodeSchema);
-			} else {
-				fail(0xac8 /* Invalid document root length */);
-			}
-		} finally {
-			cursor.free();
-		}
+		return this.checkout.exportVerbose();
 	}
 
 	public exportSimpleSchema(): SimpleTreeSchema {
@@ -723,23 +700,6 @@ export const defaultSharedTreeOptions: Required<SharedTreeOptionsInternal> = {
 	disposeForksAfterTransaction: true,
 };
 
-function verboseFromCursor(
-	reader: ITreeCursor,
-	schema: ReadonlyMap<TreeNodeSchemaIdentifier, TreeNodeStoredSchema>,
-): VerboseTree {
-	const fields = customFromCursorStored(reader, schema, verboseFromCursor);
-	const nodeSchema =
-		schema.get(reader.type) ?? fail(0xac9 /* missing schema for type in cursor */);
-	if (nodeSchema instanceof LeafNodeStoredSchema) {
-		return fields as CustomTreeValue;
-	}
-
-	return {
-		type: reader.type,
-		fields: fields as CustomTreeNode<IFluidHandle>,
-	};
-}
-
 function exportSimpleFieldSchemaStored(schema: TreeFieldStoredSchema): SimpleFieldSchema {
 	let kind: FieldKind;
 	switch (schema.kind) {

package/src/shared-tree/treeAlpha.ts

@@ -51,6 +51,7 @@ import {
 	NodeKind,
 	tryGetTreeNodeForField,
 	isObjectNodeSchema,
+	isTreeNode,
 } from "../simple-tree/index.js";
 import { brand, extractFromOpaque, type JsonCompatible } from "../util/index.js";
 import {
@@ -191,11 +192,19 @@ export interface TreeIdentifierUtils {
  * Extensions to {@link (Tree:interface)} and {@link (TreeBeta:interface)} which are not yet stable.
  * @remarks
  * Use via the {@link (TreeAlpha:variable)} singleton.
+ *
+ * The unhydrated node creation APIs in this interface do not support {@link SchemaFactoryObjectOptions.allowUnknownOptionalFields | unknown optional fields}.
+ * This is because unknown optional fields still must have a schema: its just that the schema may come from the document's stored schema.
+ * Unhydrated nodes created via this interface are not associated with any document, so there is nowhere for them to get schema for unknown optional fields.
+ * Note that {@link (TreeBeta:interface).clone} can create an unhydrated node with unknown optional fields, as it uses the source node's stored schema (if any).
+ *
+ * Export APIs in this interface include {@link SchemaFactoryObjectOptions.allowUnknownOptionalFields | unknown optional fields}
+ * if they are using {@link TreeEncodingOptions.useStoredKeys | stored keys}.
+ *
  * @privateRemarks
- * TODO: AB#43548:
- * How all the create and all the import and export APIs handle unknown optional fields needs to be figured out, tested and documented.
- * This will need to be extended/generalized to cover other future schema evolution options as well once they exist.
- * See also TreeBeta.clone with a similar issue.
+ * TODO:
+ * There should be a way to provide a source for defaulted identifiers for unhydrated node creation, either via these APIs or some way to add them to its output later.
+ * If an option were added to these APIs, it could also be used to enable unknown optional fields.
  *
  * @system @sealed @alpha
  */
@@ -219,8 +228,6 @@ export interface TreeAlpha {
 	 * When providing a {@link TreeNodeSchemaClass}, this is the same as invoking its constructor except that an unhydrated node can also be provided.
 	 * This function exists as a generalization that can be used in other cases as well,
 	 * such as when `undefined` might be allowed (for an optional field), or when the type should be inferred from the data when more than one type is possible.
-	 * @privateRemarks
-	 * TODO: AB#43548: There should be a way to provide a source for defaulted identifiers, either via this API or some way to add them to its output later.
 	 */
 	create<const TSchema extends ImplicitFieldSchema | UnsafeUnknownSchema>(
 		schema: UnsafeUnknownSchema extends TSchema
@@ -263,6 +270,14 @@ export interface TreeAlpha {
 	 * Construct tree content compatible with a field defined by the provided `schema`.
 	 * @param schema - The schema for what to construct. As this is an {@link ImplicitFieldSchema}, a {@link FieldSchema}, {@link TreeNodeSchema} or {@link AllowedTypes} array can be provided.
 	 * @param data - The data used to construct the field content. See {@link (TreeAlpha:interface).(exportVerbose:1)}.
+	 * @remarks
+	 * This currently does not support input containing {@link SchemaFactoryObjectOptions.allowUnknownOptionalFields| unknown optional fields}.
+	 * @privateRemarks
+	 * See TODOs in {@link TreeEncodingOptions}.
+	 *
+	 * TODO: clarify how this handles out of schema data.
+	 * Does it robustly validate? How do you use it with schema evolution features like staged allowed types and allowUnknownOptionalFields? Which errors are deferred until insertion/hydration?
+	 * Ensure whatever policy is chosen is documented, enforces, tested and applied consistently to all import code paths.
 	 */
 	importVerbose<const TSchema extends ImplicitFieldSchema>(
 		schema: TSchema,
@@ -484,14 +499,14 @@ export const TreeAlpha: TreeAlpha = {
 	exportConcise,
 
 	exportVerbose(node: TreeNode | TreeLeafValue, options?: TreeEncodingOptions): VerboseTree {
+		if (isTreeValue(node)) {
+			return node;
+		}
 		const config: TreeEncodingOptions = { ...options };
 
 		const cursor = borrowCursorFromTreeNodeOrValue(node);
-		return verboseFromCursor(
-			cursor,
-			tryGetSchema(node) ?? fail(0xace /* invalid input */),
-			config,
-		);
+		const kernel = getKernel(node);
+		return verboseFromCursor(cursor, kernel.context, config);
 	},
 
 	exportCompressed(
@@ -701,17 +716,14 @@ function exportConcise(
 	node: TreeNode | TreeLeafValue | undefined,
 	options?: TreeEncodingOptions,
 ): ConciseTree | undefined {
-	if (node === undefined) {
-		return undefined;
+	if (!isTreeNode(node)) {
+		return node;
 	}
 	const config: TreeEncodingOptions = { ...options };
 
+	const kernel = getKernel(node);
 	const cursor = borrowCursorFromTreeNodeOrValue(node);
-	return conciseFromCursor(
-		cursor,
-		tryGetSchema(node) ?? fail(0xacd /* invalid input */),
-		config,
-	);
+	return conciseFromCursor(cursor, kernel.context, config);
 }
 
 /**

package/src/shared-tree/treeCheckout.ts

@@ -4,7 +4,7 @@
  */
 
 import { assert, unreachableCase, fail } from "@fluidframework/core-utils/internal";
-import type { Listenable } from "@fluidframework/core-interfaces/internal";
+import type { IFluidHandle, Listenable } from "@fluidframework/core-interfaces/internal";
 import { createEmitter } from "@fluid-internal/client-utils";
 import type { IIdCompressor } from "@fluidframework/id-compressor";
 import {
@@ -42,6 +42,11 @@ import {
 	type RevertibleAlpha,
 	type GraphCommit,
 	isAncestor,
+	moveToDetachedField,
+	type ITreeCursor,
+	type TreeNodeSchemaIdentifier,
+	type TreeNodeStoredSchema,
+	LeafNodeStoredSchema,
 } from "../core/index.js";
 import {
 	type FieldBatchCodec,
@@ -68,15 +73,19 @@ import { SharedTreeChangeFamily, hasSchemaChange } from "./sharedTreeChangeFamil
 import type { SharedTreeChange } from "./sharedTreeChangeTypes.js";
 import type { ISharedTreeEditor, SharedTreeEditBuilder } from "./sharedTreeEditBuilder.js";
 import type { IDisposable } from "@fluidframework/core-interfaces";
-import type {
-	ImplicitFieldSchema,
-	ReadSchema,
-	TreeView,
-	TreeViewConfiguration,
-	UnsafeUnknownSchema,
-	ViewableTree,
-	TreeBranch,
-	TreeChangeEvents,
+import {
+	type ImplicitFieldSchema,
+	type ReadSchema,
+	type TreeView,
+	type TreeViewConfiguration,
+	type UnsafeUnknownSchema,
+	type ViewableTree,
+	type TreeBranch,
+	type TreeChangeEvents,
+	type VerboseTree,
+	customFromCursorStored,
+	type CustomTreeValue,
+	type CustomTreeNode,
 } from "../simple-tree/index.js";
 import { getCheckout, SchematizingSimpleTreeView } from "./schematizingTreeView.js";
 
@@ -495,6 +504,24 @@ export class TreeCheckout implements ITreeCheckoutFork {
 		this.#transaction.activeBranchEvents.on("ancestryTrimmed", this.onAncestryTrimmed);
 	}
 
+	public exportVerbose(): VerboseTree | undefined {
+		const cursor = this.forest.allocateCursor("contentSnapshot");
+		try {
+			moveToDetachedField(this.forest, cursor);
+			const length = cursor.getFieldLength();
+			if (length === 0) {
+				return undefined;
+			} else if (length === 1) {
+				cursor.enterNode(0);
+				return verboseFromCursor(cursor, this.storedSchema.nodeSchema);
+			} else {
+				fail(0xac8 /* Invalid document root length */);
+			}
+		} finally {
+			cursor.free();
+		}
+	}
+
 	private readonly onAfterChange = (event: SharedTreeBranchChange<SharedTreeChange>): void => {
 		this.editLock.lock();
 		this.#events.emit("beforeBatch", event);
@@ -1110,3 +1137,20 @@ function trackForksForDisposal(checkout: TreeCheckout): () => void {
 		disposed = true;
 	};
 }
+
+function verboseFromCursor(
+	reader: ITreeCursor,
+	schema: ReadonlyMap<TreeNodeSchemaIdentifier, TreeNodeStoredSchema>,
+): VerboseTree {
+	const fields = customFromCursorStored(reader, schema, verboseFromCursor);
+	const nodeSchema =
+		schema.get(reader.type) ?? fail(0xac9 /* missing schema for type in cursor */);
+	if (nodeSchema instanceof LeafNodeStoredSchema) {
+		return fields as CustomTreeValue;
+	}
+
+	return {
+		type: reader.type,
+		fields: fields as CustomTreeNode<IFluidHandle>,
+	};
+}

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

@@ -251,12 +251,7 @@ export class SharedTreeBranch<TEditor extends ChangeFamilyEditor, TChange> {
 			// TODO: Pull this side effect out if/when more diverse ancestry walking helpers are available
 			if (c !== commit) {
 				const revision = this.mintRevisionTag();
-				const inverse = this.changeFamily.rebaser.changeRevision(
-					this.changeFamily.rebaser.invert(c, true, revision),
-					revision,
-					c.revision,
-				);
-
+				const inverse = this.changeFamily.rebaser.invert(c, true, revision);
 				inverses.push(tagRollbackInverse(inverse, revision, c.revision));
 				return false;
 			}

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

@@ -5,9 +5,8 @@
 
 import type { IFluidHandle } from "@fluidframework/core-interfaces";
 
-import type { ITreeCursor } from "../../core/index.js";
-import type { TreeNodeSchema, TreeLeafValue, ImplicitAllowedTypes } from "../core/index.js";
-import { getUnhydratedContext } from "../createContext.js";
+import type { ITreeCursor, TreeNodeStoredSchema } from "../../core/index.js";
+import type { TreeNodeSchema, TreeLeafValue, Context } from "../core/index.js";
 
 import {
 	customFromCursor,
@@ -43,7 +42,7 @@ export type ConciseTree<THandle = IFluidHandle> =
  */
 export function conciseFromCursor(
 	reader: ITreeCursor,
-	rootSchema: ImplicitAllowedTypes,
+	context: Context,
 	options: TreeEncodingOptions,
 ): ConciseTree {
 	const config: Required<TreeEncodingOptions> = {
@@ -51,16 +50,19 @@ export function conciseFromCursor(
 		...options,
 	};
 
-	const schemaMap = getUnhydratedContext(rootSchema).schema;
-	return conciseFromCursorInner(reader, config, schemaMap);
+	const storedSchemaMap = context.flexContext.schema.nodeSchema;
+	const schemaMap = context.schema;
+
+	return conciseFromCursorInner(reader, config, storedSchemaMap, schemaMap);
 }
 
 function conciseFromCursorInner(
 	reader: ITreeCursor,
 	options: Required<TreeEncodingOptions>,
+	storedSchema: ReadonlyMap<string, TreeNodeStoredSchema>,
 	schema: ReadonlyMap<string, TreeNodeSchema>,
 ): ConciseTree {
-	return customFromCursor(reader, options, schema, conciseFromCursorInner);
+	return customFromCursor(reader, options, storedSchema, schema, conciseFromCursorInner);
 }
 
 /**

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

@@ -47,14 +47,20 @@ import type { SimpleNodeSchema, SimpleTreeSchema } from "../simpleSchema.js";
  */
 export interface ITreeConfigurationOptions {
 	/**
-	 * If `true`, the tree will validate new content against its stored schema at insertion time
+	 * If `true`, the tree will perform additional validation of content against its stored schema
 	 * and throw an error if the new content doesn't match the expected schema.
 	 *
 	 * @defaultValue `false`.
 	 *
-	 * @remarks Enabling schema validation has a performance penalty when inserting new content into the tree because
+	 * @remarks
+	 * Currently most cases already have some schema validation, so this is mainly for additional validation which may be useful when debugging issues,
+	 * working with untyped APIs, or when the small performance overhead is a non-issue.
+	 *
+	 * Enabling schema validation has a performance penalty when inserting new content into the tree because
 	 * additional checks are done. Enable this option only in scenarios where you are ok with that operation being a
 	 * bit slower.
+	 *
+	 * For additional validation in more cases, see {@link ForestTypeExpensiveDebug}.
 	 */
 	enableSchemaValidation?: boolean;