@fluidframework/tree 2.41.0-338401 → 2.42.0

package/src/feature-libraries/flex-tree/lazyNode.ts

@@ -28,7 +28,7 @@ import type { Context } from "./context.js";
 import {
 	FlexTreeEntityKind,
 	type FlexTreeField,
-	type FlexTreeNode,
+	type HydratedFlexTreeNode,
 	flexTreeMarker,
 	flexTreeSlot,
 } from "./flexTreeTypes.js";
@@ -63,7 +63,7 @@ function cleanupTree(anchor: AnchorNode): void {
 /**
  * Lazy implementation of {@link FlexTreeNode}.
  */
-export class LazyTreeNode extends LazyEntity<Anchor> implements FlexTreeNode {
+export class LazyTreeNode extends LazyEntity<Anchor> implements HydratedFlexTreeNode {
 	public get [flexTreeMarker](): FlexTreeEntityKind.Node {
 		return FlexTreeEntityKind.Node;
 	}
@@ -88,6 +88,10 @@ export class LazyTreeNode extends LazyEntity<Anchor> implements FlexTreeNode {
 		this.#removeDeleteCallback = anchorNode.events.on("afterDestroy", cleanupTree);
 	}
 
+	public isHydrated(): this is HydratedFlexTreeNode {
+		return true;
+	}
+
 	public borrowCursor(): ITreeCursorSynchronous {
 		return this.cursor as ITreeCursorSynchronous;
 	}

package/src/feature-libraries/flex-tree/utilities.ts

@@ -11,8 +11,8 @@ import {
 	rootField,
 	type SchemaAndPolicy,
 } from "../../core/index.js";
-import type { FlexTreeContext } from "./context.js";
 
+import type { FlexTreeContext } from "./context.js";
 import { TreeStatus } from "./flexTreeTypes.js";
 /**
  * Checks the detached field and returns the TreeStatus based on whether or not the detached field is a root field.

package/src/feature-libraries/forest-summary/forestSummarizer.ts

@@ -6,13 +6,14 @@
 import { bufferToString } from "@fluid-internal/client-utils";
 import { assert } from "@fluidframework/core-utils/internal";
 import type { IChannelStorageService } from "@fluidframework/datastore-definitions/internal";
+import type { IIdCompressor } from "@fluidframework/id-compressor";
 import type {
 	ISummaryTreeWithStats,
 	ITelemetryContext,
 } from "@fluidframework/runtime-definitions/internal";
 import { createSingleBlobSummary } from "@fluidframework/shared-object-base/internal";
 
-import { type ICodecOptions, noopValidator } from "../../codec/index.js";
+import type { CodecWriteOptions } from "../../codec/index.js";
 import {
 	type DeltaDetachedNodeBuild,
 	type DeltaFieldChanges,
@@ -38,7 +39,6 @@ import type { FieldBatchCodec, FieldBatchEncodingContext } from "../chunked-fore
 
 import { type ForestCodec, makeForestSummarizerCodec } from "./codec.js";
 import type { Format } from "./format.js";
-import type { IIdCompressor } from "@fluidframework/id-compressor";
 /**
  * The storage key for the blob in the summary containing tree data
  */
@@ -60,9 +60,10 @@ export class ForestSummarizer implements Summarizable {
 		private readonly revisionTagCodec: RevisionTagCodec,
 		fieldBatchCodec: FieldBatchCodec,
 		private readonly encoderContext: FieldBatchEncodingContext,
-		options: ICodecOptions = { jsonValidator: noopValidator },
+		options: CodecWriteOptions,
 		private readonly idCompressor: IIdCompressor,
 	) {
+		// TODO: this should take in CodecWriteOptions, and use it to pick the write version.
 		this.codec = makeForestSummarizerCodec(options, fieldBatchCodec);
 	}
 

package/src/feature-libraries/index.ts

@@ -15,6 +15,11 @@ export {
 	cursorForMapTreeNode,
 	mapTreeFromCursor,
 	mapTreeFieldFromCursor,
+	type MinimalMapTreeNodeView,
+	mapTreeFieldsWithField,
+	mapTreeWithField,
+	type MapTreeFieldViewGeneric,
+	type MapTreeNodeViewGeneric,
 } from "./mapTreeCursor.js";
 export { buildForest } from "./object-forest/index.js";
 export {
@@ -22,7 +27,6 @@ export {
 	encodeTreeSchema,
 	makeSchemaCodec,
 	makeSchemaCodecs,
-	SchemaCodecVersion,
 } from "./schema-index/index.js";
 export {
 	stackTreeNodeCursor,
@@ -143,7 +147,7 @@ export {
 	fieldKindConfigurations,
 	intoDelta,
 	relevantRemovedRoots,
-	SchemaValidationErrors,
+	SchemaValidationError,
 	isNodeInSchema,
 	isFieldInSchema,
 	inSchemaOrThrow,
@@ -175,6 +179,10 @@ export {
 	treeStatusFromAnchorCache,
 	indexForAt,
 	FlexTreeEntityKind,
+	type FlexibleNodeContent,
+	type FlexibleFieldContent,
+	type FlexTreeHydratedContextMinimal,
+	type HydratedFlexTreeNode,
 } from "./flex-tree/index.js";
 
 export { TreeCompressionStrategy } from "./treeCompressionUtils.js";

package/src/feature-libraries/indexing/anchorTreeIndex.ts

@@ -4,7 +4,7 @@
  */
 
 import { assert, fail } from "@fluidframework/core-utils/internal";
-import { disposeSymbol, getOrCreate } from "../../util/index.js";
+
 import {
 	type Anchor,
 	type AnchorNode,
@@ -24,9 +24,11 @@ import {
 	TreeNavigationResult,
 	type ITreeCursorSynchronous,
 } from "../../core/index.js";
-import type { TreeIndex, TreeIndexKey, TreeIndexNodes } from "./types.js";
+import { disposeSymbol, getOrCreate } from "../../util/index.js";
 import { TreeStatus } from "../flex-tree/index.js";
 
+import type { TreeIndex, TreeIndexKey, TreeIndexNodes } from "./types.js";
+
 /**
  * A function that gets the value to index a node on, must be pure and functional.
  * The given cursor should point to the node that will be indexed.

package/src/feature-libraries/mapTreeCursor.ts

@@ -12,49 +12,136 @@ import {
 	type FieldKey,
 	type ITreeCursor,
 	type MapTree,
+	type NodeData,
 	aboveRootPlaceholder,
 	detachedFieldAsKey,
 	mapCursorField,
 	rootField,
+	rootFieldKey,
 } from "../core/index.js";
 
 import {
 	type CursorAdapter,
 	type CursorWithNode,
+	type Field,
 	stackTreeFieldCursor,
 	stackTreeNodeCursor,
 } from "./treeCursorUtils.js";
+import type { requireAssignableTo } from "../util/index.js";
+
+/**
+ * A generic variant of {@link MapTree} that can be used to strongly type trees implementing a MapTree-like API.
+ * @remarks
+ * Due to how TypeScript handles recursive generic types, explicitly named extension interfaces work best for parameterizing this, and a default type parameter can't be provided.
+ * @see {@link MinimalMapTreeNodeView} for a minimal configuration of this interface.
+ */
+export interface MapTreeNodeViewGeneric<TNode> extends NodeData {
+	/**
+	 * The non-empty fields on this node.
+	 * @remarks
+	 * This is the subset of map needed to view the tree.
+	 * Theoretically `Symbol.iterator` and "keys" are redundant.
+	 */
+	readonly fields: Pick<
+		Map<FieldKey, MapTreeFieldViewGeneric<TNode>>,
+		typeof Symbol.iterator | "get"
+	>;
+}
+
+/**
+ * A field in {@link MapTreeNodeViewGeneric}.
+ */
+export type MapTreeFieldViewGeneric<TNode> = Pick<
+	readonly TNode[],
+	typeof Symbol.iterator | "length"
+>;
+
+/**
+ * Like {@link MapTree} but with the minimal properties needed for reading.
+ */
+export interface MinimalMapTreeNodeView
+	extends MapTreeNodeViewGeneric<MinimalMapTreeNodeView> {}
+
+{
+	// Check that these interfaces are subsets of MapTree as intended:
+	type _check1 = requireAssignableTo<MapTree, MinimalMapTreeNodeView>;
+	type _check2 = requireAssignableTo<MapTree, MapTreeNodeViewGeneric<MapTree>>;
+}
 
 /**
  * Returns an {@link ITreeCursorSynchronous} in nodes mode for a single {@link MapTree}.
  */
-export function cursorForMapTreeNode(root: MapTree): CursorWithNode<MapTree> {
-	return stackTreeNodeCursor(adapter, root);
+export function cursorForMapTreeNode<T extends MapTreeNodeViewGeneric<T>>(
+	root: T,
+): CursorWithNode<T> {
+	// There doesn't seem to be a clean way to get TypeScript to type check this without casting
+	// without declaring the adapter inside this generic function and needlessly recreating it on every call.
+	const adapterTyped = adapter as CursorAdapter<MapTreeNodeViewGeneric<T>> as CursorAdapter<T>;
+	return stackTreeNodeCursor(adapterTyped, root);
+}
+
+/**
+ * Creates an {@link ExclusiveMapTree} with a single field and no value.
+ * @remarks
+ * This handles ensuring the field is omitted if empty, and defaults to making the node above the root.
+ */
+export function mapTreeWithField(
+	children: ExclusiveMapTree[],
+	key = rootFieldKey,
+	type = aboveRootPlaceholder,
+): ExclusiveMapTree {
+	return {
+		type,
+		fields: mapTreeFieldsWithField(children, key),
+	};
+}
+
+/**
+ * Creates a Map suitable for use as {@link MapTree.fields} with a single field.
+ * @remarks
+ * This handles ensuring the field is omitted if empty.
+ */
+export function mapTreeFieldsWithField<T extends readonly unknown[]>(
+	children: T,
+	key: FieldKey,
+): Map<FieldKey, T> {
+	return new Map(children.length === 0 ? [] : [[key, children]]);
 }
 
 /**
  * Returns an {@link ITreeCursorSynchronous} in fields mode for a MapTree field.
  */
-export function cursorForMapTreeField(
-	root: readonly MapTree[],
+export function cursorForMapTreeField<T extends MapTreeNodeViewGeneric<T>>(
+	root: readonly T[],
 	detachedField: DetachedField = rootField,
-): CursorWithNode<MapTree> {
+): CursorWithNode<T> {
 	const key = detachedFieldAsKey(detachedField);
-	return stackTreeFieldCursor(
-		adapter,
-		{
-			type: aboveRootPlaceholder,
-			fields: new Map([[key, root]]),
-		},
-		detachedField,
-	);
+	const adapterTyped = adapter as unknown as CursorAdapter<T>;
+	const dummyRoot: MapTreeNodeViewGeneric<T> = {
+		type: aboveRootPlaceholder,
+		fields: mapTreeFieldsWithField(root, key),
+	};
+	return stackTreeFieldCursor(adapterTyped, dummyRoot as T, detachedField);
 }
 
-const adapter: CursorAdapter<MapTree> = {
+const adapter: CursorAdapter<MinimalMapTreeNodeView> = {
 	value: (node) => node.value,
 	type: (node) => node.type,
-	keysFromNode: (node) => [...node.fields.keys()], // TODO: don't convert this to array here.
-	getFieldFromNode: (node, key) => node.fields.get(key) ?? [],
+	keysFromNode: (node) => Array.from(node.fields, ([key, field]) => key),
+	getFieldFromNode: (node, key): Field<MinimalMapTreeNodeView> => {
+		const field = node.fields.get(key) as
+			| MinimalMapTreeNodeView[]
+			| Iterable<MinimalMapTreeNodeView>
+			| undefined;
+		if (field === undefined) {
+			return [];
+		}
+		if (Array.isArray(field)) {
+			return field as readonly MinimalMapTreeNodeView[];
+		}
+		// TODO: this copy could be avoided by using Array.at instead of indexing in `Field`, but that requires ES2022.
+		return [...field] as readonly MinimalMapTreeNodeView[];
+	},
 };
 
 /**

package/src/feature-libraries/modular-schema/crossFieldQueries.ts

@@ -10,6 +10,7 @@ import type {
 	RevisionTag,
 } from "../../core/index.js";
 import type { RangeQueryResult } from "../../util/index.js";
+
 import type { NodeId } from "./modularChangeTypes.js";
 
 export type CrossFieldMap<T> = ChangeAtomIdRangeMap<T>;

package/src/feature-libraries/modular-schema/fieldChangeHandler.ts

@@ -18,8 +18,8 @@ import type {
 import type { IdAllocator, Invariant } from "../../util/index.js";
 
 import type { CrossFieldManager } from "./crossFieldQueries.js";
-import type { CrossFieldKeyRange, NodeId } from "./modularChangeTypes.js";
 import type { EncodedNodeChangeset } from "./modularChangeFormat.js";
+import type { CrossFieldKeyRange, NodeId } from "./modularChangeTypes.js";
 
 export type NestedChangesIndices = [
 	NodeId,

package/src/feature-libraries/modular-schema/fieldKindWithEditor.ts

@@ -66,7 +66,7 @@ export class FieldKindWithEditor<
 	}
 
 	/**
-	 * @returns true iff `superset` permits a (non-strict) superset of the subtrees
+	 * Returns true if and only if `superset` permits a (non-strict) superset of the subtrees
 	 * allowed by field made from `this` and `originalTypes`.
 	 */
 	public allowsFieldSuperset(

package/src/feature-libraries/modular-schema/genericFieldKind.ts

@@ -3,6 +3,9 @@
  * Licensed under the MIT License.
  */
 
+import { assert } from "@fluidframework/core-utils/internal";
+import { BTree } from "@tylerbu/sorted-btree-es6";
+
 import {
 	type DeltaDetachedNodeId,
 	type DeltaMark,
@@ -10,7 +13,7 @@ import {
 	type RevisionTag,
 	replaceAtomRevisions,
 } from "../../core/index.js";
-import { assert } from "@fluidframework/core-utils/internal";
+
 import type {
 	FieldChangeDelta,
 	FieldChangeHandler,
@@ -25,7 +28,6 @@ import { FieldKindWithEditor } from "./fieldKindWithEditor.js";
 import { makeGenericChangeCodec } from "./genericFieldKindCodecs.js";
 import { newGenericChangeset, type GenericChangeset } from "./genericFieldKindTypes.js";
 import type { NodeId } from "./modularChangeTypes.js";
-import { BTree } from "@tylerbu/sorted-btree-es6";
 
 /**
  * {@link FieldChangeHandler} implementation for {@link GenericChangeset}.

package/src/feature-libraries/modular-schema/genericFieldKindCodecs.ts

@@ -4,6 +4,7 @@
  */
 
 import { type ICodecFamily, type IJsonCodec, makeCodecFamily } from "../../codec/index.js";
+
 import type { FieldChangeEncodingContext } from "./fieldChangeHandler.js";
 import { EncodedGenericChangeset } from "./genericFieldKindFormat.js";
 import { newGenericChangeset, type GenericChangeset } from "./genericFieldKindTypes.js";

package/src/feature-libraries/modular-schema/genericFieldKindTypes.ts

@@ -4,6 +4,7 @@
  */
 
 import { BTree } from "@tylerbu/sorted-btree-es6";
+
 import type { NodeId } from "./modularChangeTypes.js";
 
 /**

package/src/feature-libraries/modular-schema/isNeverTree.ts

@@ -17,8 +17,6 @@ import {
 
 import type { FullSchemaPolicy } from "./fieldKind.js";
 
-/**
- */
 export function isNeverField(
 	policy: FullSchemaPolicy,
 	originalData: TreeStoredSchema,

package/src/feature-libraries/modular-schema/modularChangeCodecs.ts

@@ -41,6 +41,7 @@ import {
 } from "../chunked-forest/index.js";
 import { TreeCompressionStrategy } from "../treeCompressionUtils.js";
 
+import type { FieldChangeEncodingContext, FieldChangeHandler } from "./fieldChangeHandler.js";
 import type {
 	FieldKindConfiguration,
 	FieldKindConfigurationEntry,
@@ -65,7 +66,6 @@ import {
 	type NodeChangeset,
 	type NodeId,
 } from "./modularChangeTypes.js";
-import type { FieldChangeEncodingContext, FieldChangeHandler } from "./fieldChangeHandler.js";
 
 export function makeModularChangeCodecFamily(
 	fieldKindConfigurations: ReadonlyMap<number, FieldKindConfiguration>,
@@ -76,7 +76,7 @@ export function makeModularChangeCodecFamily(
 		ChangeEncodingContext
 	>,
 	fieldsCodec: FieldBatchCodec,
-	{ jsonValidator: validator }: ICodecOptions,
+	codecOptions: ICodecOptions,
 	chunkCompressionStrategy: TreeCompressionStrategy = TreeCompressionStrategy.Compressed,
 ): ICodecFamily<ModularChangeset, ChangeEncodingContext> {
 	return makeCodecFamily(
@@ -86,7 +86,7 @@ export function makeModularChangeCodecFamily(
 				fieldKinds,
 				revisionTagCodec,
 				fieldsCodec,
-				{ jsonValidator: validator },
+				codecOptions,
 				chunkCompressionStrategy,
 			),
 		]),
@@ -116,7 +116,7 @@ function makeModularChangeCodec(
 		ChangeEncodingContext
 	>,
 	fieldsCodec: FieldBatchCodec,
-	{ jsonValidator: validator }: ICodecOptions,
+	codecOptions: ICodecOptions,
 	chunkCompressionStrategy: TreeCompressionStrategy = TreeCompressionStrategy.Compressed,
 ): ModularChangeCodec {
 	// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
@@ -125,7 +125,7 @@ function makeModularChangeCodec(
 		return {
 			codec,
 			compiledSchema: codec.json.encodedSchema
-				? validator.compile(codec.json.encodedSchema)
+				? codecOptions.jsonValidator.compile(codec.json.encodedSchema)
 				: undefined,
 		};
 	};
@@ -519,7 +519,11 @@ function makeModularChangeCodec(
 		},
 	};
 
-	return withSchemaValidation(EncodedModularChangeset, modularChangeCodec, validator);
+	return withSchemaValidation(
+		EncodedModularChangeset,
+		modularChangeCodec,
+		codecOptions.jsonValidator,
+	);
 }
 
 function getChangeHandler(

package/src/feature-libraries/modular-schema/modularChangeFamily.ts

@@ -2651,6 +2651,8 @@ export class ModularEditBuilder extends EditBuilder<ModularChangeset> {
 	}
 
 	/**
+	 * Builds a new tree to use in an edit.
+	 *
 	 * @param firstId - The ID to associate with the first node
 	 * @param content - The node(s) to build.
 	 * @param revision - The revision to use for the build.

package/src/feature-libraries/modular-schema/modularChangeTypes.ts

@@ -14,6 +14,7 @@ import {
 } from "../../core/index.js";
 import { brand, RangeMap, type Brand, type TupleBTree } from "../../util/index.js";
 import type { TreeChunk } from "../chunked-forest/index.js";
+
 import type { CrossFieldTarget } from "./crossFieldQueries.js";
 
 /**

package/src/feature-libraries/node-identifier/mockNodeIdentifierManager.ts

@@ -6,12 +6,15 @@
 import { assert, fail } from "@fluidframework/core-utils/internal";
 import type { SessionSpaceCompressedId, StableId } from "@fluidframework/id-compressor";
 import { assertIsStableId } from "@fluidframework/id-compressor/internal";
+import { UsageError } from "@fluidframework/telemetry-utils/internal";
+
+import { brand, extractFromOpaque } from "../../util/index.js";
+
 import type { LocalNodeIdentifier, StableNodeIdentifier } from "./nodeIdentifier.js";
 import {
 	isStableNodeIdentifier,
 	type NodeIdentifierManager,
 } from "./nodeIdentifierManager.js";
-import { brand, extractFromOpaque } from "../../util/index.js";
 
 /**
  * Mock {@link NodeIdentifierManager} that generates deterministic {@link StableNodeIdentifier}s and {@link LocalNodeIdentifier}s.
@@ -50,10 +53,13 @@ export class MockNodeIdentifierManager implements NodeIdentifierManager {
 	}
 
 	public getId(offset: number): StableId {
-		assert(offset >= 0, 0x6e7 /* UUID offset may not be negative */);
 		assert(offset < 281_474_976_710_656, 0x6e8 /* UUID offset must be at most 16^12 */);
-		return assertIsStableId(
-			`a110ca7e-add1-4000-8000-${Math.round(offset).toString(16).padStart(12, "0")}`,
-		);
+		if (offset >= 0 && offset < this.count) {
+			return assertIsStableId(
+				`a110ca7e-add1-4000-8000-${Math.round(offset).toString(16).padStart(12, "0")}`,
+			);
+		} else {
+			throw new UsageError("Local ID offset out of bounds");
+		}
 	}
 }

package/src/feature-libraries/object-forest/objectForest.ts

@@ -3,9 +3,9 @@
  * Licensed under the MIT License.
  */
 
-import { assert, fail } from "@fluidframework/core-utils/internal";
 import { createEmitter } from "@fluid-internal/client-utils";
 import type { Listenable } from "@fluidframework/core-interfaces";
+import { assert, fail } from "@fluidframework/core-utils/internal";
 
 import {
 	type Anchor,
@@ -29,6 +29,7 @@ import {
 	type PlaceIndex,
 	type Range,
 	type TreeChunk,
+	type TreeFieldStoredSchema,
 	TreeNavigationResult,
 	type TreeNodeSchemaIdentifier,
 	type TreeStoredSchemaSubscription,
@@ -37,16 +38,26 @@ import {
 	aboveRootPlaceholder,
 	combineVisitors,
 	deepCopyMapTree,
+	rootFieldKey,
 } from "../../core/index.js";
 import {
 	assertNonNegativeSafeInteger,
 	assertValidIndex,
 	assertValidRange,
 	brand,
+	breakingMethod,
+	type Breakable,
+	type WithBreakable,
 } from "../../util/index.js";
+import { chunkFieldSingle, defaultChunkPolicy } from "../chunked-forest/index.js";
 import { cursorForMapTreeNode, mapTreeFromCursor } from "../mapTreeCursor.js";
 import { type CursorWithNode, SynchronousCursor } from "../treeCursorUtils.js";
-import { chunkFieldSingle, defaultChunkPolicy } from "../chunked-forest/index.js";
+import {
+	defaultSchemaPolicy,
+	FieldKinds,
+	inSchemaOrThrow,
+	isFieldInSchema,
+} from "../default-schema/index.js";
 
 /** A `MapTree` with mutable fields */
 interface MutableMapTree extends MapTree {
@@ -71,7 +82,7 @@ function getOrCreateField(mapTree: MutableMapTree, key: FieldKey): MutableMapTre
  * This implementation focuses on correctness and simplicity, not performance.
  * It does not use compressed chunks: instead nodes are implemented using objects.
  */
-export class ObjectForest implements IEditableForest {
+export class ObjectForest implements IEditableForest, WithBreakable {
 	private activeVisitor?: DeltaVisitor;
 
 	// All cursors that are in the "Current" state. Must be empty when editing.
@@ -87,6 +98,11 @@ export class ObjectForest implements IEditableForest {
 	}
 
 	public constructor(
+		public readonly breaker: Breakable,
+		/**
+		 * If provided, may be used for validation, but otherwise unused.
+		 */
+		public readonly schema: TreeStoredSchemaSubscription | undefined,
 		public readonly anchors: AnchorSet = new AnchorSet(),
 		public readonly additionalAsserts: boolean = false,
 		roots?: MapTree,
@@ -98,14 +114,18 @@ export class ObjectForest implements IEditableForest {
 						type: aboveRootPlaceholder,
 						fields: new Map(),
 					};
+
+		if (additionalAsserts) {
+			this.checkSchema();
+		}
 	}
 
 	public get isEmpty(): boolean {
 		return this.roots.fields.size === 0;
 	}
 
-	public clone(_: TreeStoredSchemaSubscription, anchors: AnchorSet): ObjectForest {
-		return new ObjectForest(anchors, this.additionalAsserts, this.roots);
+	public clone(schema: TreeStoredSchemaSubscription, anchors: AnchorSet): ObjectForest {
+		return new ObjectForest(this.breaker, schema, anchors, this.additionalAsserts, this.roots);
 	}
 
 	public chunkField(cursor: ITreeCursorSynchronous): TreeChunk {
@@ -116,6 +136,34 @@ export class ObjectForest implements IEditableForest {
 		this.anchors.forget(anchor);
 	}
 
+	/**
+	 * Throw (and break) if content does not match schema.
+	 */
+	@breakingMethod
+	public checkSchema(): void {
+		const schema = this.schema;
+		if (schema !== undefined) {
+			const roots = new Set([...this.roots.fields.keys(), rootFieldKey]);
+			for (const key of roots) {
+				const documentRoot = this.roots.fields.get(key) ?? [];
+				const fieldSchema: TreeFieldStoredSchema =
+					key === rootFieldKey
+						? schema.rootFieldSchema
+						: // TODO: someday we should have schema for detached fields, and use that instead of generating one here.
+							{
+								// Some detached fields may have multiple nodes, so we must treat them as sequences:
+								kind: FieldKinds.sequence.identifier,
+								types: new Set(documentRoot.map((node) => node.type)),
+							};
+				const maybeError = isFieldInSchema(documentRoot, fieldSchema, {
+					schema,
+					policy: defaultSchemaPolicy,
+				});
+				inSchemaOrThrow(maybeError);
+			}
+		}
+	}
+
 	public acquireVisitor(): DeltaVisitor {
 		assert(
 			this.activeVisitor === undefined,
@@ -163,6 +211,11 @@ export class ObjectForest implements IEditableForest {
 					0x76d /* Multiple free calls for same visitor */,
 				);
 				this.forest.activeVisitor = undefined;
+				if (this.forest.additionalAsserts) {
+					// Schema validation:
+					// When doing "additionalAsserts", validate the content against the schema after every batch of edits.
+					this.forest.checkSchema();
+				}
 			}
 			public destroy(detachedField: FieldKey, count: number): void {
 				preEdit();
@@ -542,11 +595,16 @@ class Cursor extends SynchronousCursor implements ITreeSubscriptionCursor {
 // When other forest implementations are created (ex: optimized ones),
 // this function should likely be moved and updated to (at least conditionally) use them.
 /**
- * @returns an implementation of {@link IEditableForest} with no data or schema.
+ * Returns an implementation of {@link IEditableForest} with no content.
+ * @privateRemarks
+ * TODO:
+ * refactor to remove this function, and instead place `ForestTypeReference` and `ForestTypeExpensiveDebug` here as a better way to encapsulate ObjectForest.
  */
 export function buildForest(
+	breaker: Breakable,
+	schema?: TreeStoredSchemaSubscription,
 	anchors?: AnchorSet,
 	additionalAsserts: boolean = false,
 ): ObjectForest {
-	return new ObjectForest(anchors, additionalAsserts);
+	return new ObjectForest(breaker, schema, anchors, additionalAsserts);
 }