@fluidframework/tree 2.1.0 → 2.3.0-288113

package/src/index.ts

@@ -6,253 +6,57 @@
 export {
 	EmptyKey,
 	type FieldKey,
-	type TreeType,
-	type Value,
 	type TreeValue,
-	AnchorSet,
-	type DetachedField,
-	type UpPath,
-	type Range,
-	type RangeUpPath,
-	type PlaceUpPath,
-	type DetachedRangeUpPath,
-	type DetachedPlaceUpPath,
-	type PlaceIndex,
-	type NodeIndex,
-	type FieldUpPath,
-	type Anchor,
-	type RootField,
-	type ChildCollection,
-	type ChildLocation,
-	type DeltaVisitor,
-	type AnnouncedVisitor,
 	type FieldMapObject,
 	type NodeData,
 	type GenericTreeNode,
 	type JsonableTree,
-	type ProtoNodes,
-	type DeltaRoot,
-	type DeltaProtoNode,
-	type DeltaMark,
-	type DeltaDetachedNodeId,
-	type DeltaFieldMap,
-	type DeltaDetachedNodeChanges,
-	type DeltaDetachedNodeBuild,
-	type DeltaDetachedNodeDestruction,
-	type DeltaDetachedNodeRename,
-	type DeltaFieldChanges,
-	type RevisionTag,
-	rootFieldKey,
-	rootField,
-	type ITreeCursor,
-	CursorLocationType,
-	type ITreeCursorSynchronous,
 	type GenericFieldsNode,
-	type AnchorLocator,
-	TreeNavigationResult,
-	type IEditableForest,
-	type IForestSubscription,
-	type TreeLocation,
-	type FieldLocation,
-	type ForestLocation,
-	type ITreeSubscriptionCursor,
-	ITreeSubscriptionCursorState,
 	type TreeNodeSchemaIdentifier,
 	type TreeFieldStoredSchema,
 	ValueSchema,
 	TreeNodeStoredSchema,
-	type TreeStoredSchemaSubscription,
 	type FieldKindIdentifier,
 	type TreeTypeSet,
 	type TreeStoredSchema,
-	type FieldAnchor,
-	type SchemaEvents,
-	type ChangesetLocalId,
-	type ForestEvents,
-	type PathRootPrefix,
-	type AnchorSlot,
-	type AnchorNode,
-	anchorSlot,
-	type UpPathDefault,
-	type AnchorEvents,
-	type AnchorSetRootEvents,
-	type FieldKindData,
-	AllowedUpdateType,
-	type PathVisitor,
-	type Adapters,
-	type TreeAdapter,
-	type MapTree,
 	type Revertible,
 	CommitKind,
 	RevertibleStatus,
 	type CommitMetadata,
-	forbiddenFieldKindIdentifier,
-	identifierFieldKindIdentifier,
 	type StoredSchemaCollection,
 	type ErasedTreeNodeSchemaDataFormat,
 	ObjectNodeStoredSchema,
 	MapNodeStoredSchema,
 	LeafNodeStoredSchema,
-	Multiplicity,
-	type SchemaPolicy,
 } from "./core/index.js";
-
-export {
-	type Brand,
-	type Opaque,
-	extractFromOpaque,
-	brand,
-	type ValueFromBranded,
-	type NameFromBranded,
-	type JsonCompatible,
-	type JsonCompatibleObject,
-	type NestedMap,
-	fail,
-	type IdAllocator,
-	TransactionResult,
-	type BrandedKey,
-	type BrandedMapSubset,
-	type RangeQueryResult,
-	type Named,
-	oneFromSet,
-	disposeSymbol,
-	type IDisposable,
-} from "./util/index.js";
+export { type Brand } from "./util/index.js";
 
 export {
 	type Listeners,
 	type IsListener,
 	type Listenable,
 	type Off,
+	// Alpha APIs for using event library to implement events externally.
+	// If stabilizing these APIs, they should probably move out of the tree package first.
 	createEmitter,
+	EventEmitter,
 	type IEmitter,
-	type NoListenersCallback,
 	type HasListeners,
+	type NoListenersCallback,
 } from "./events/index.js";
 
-export { leaf } from "./domains/index.js";
-
 export {
-	FlexFieldKind,
-	isNeverField,
-	type FullSchemaPolicy,
-	valueSymbol,
-	type ContextuallyTypedNodeDataObject,
-	type ContextuallyTypedNodeData,
-	type MarkedArrayLike,
-	isContextuallyTypedNodeDataObject,
-	defaultSchemaPolicy,
-	jsonableTreeFromCursor,
-	type StableNodeKey,
-	type LocalNodeKey,
-	compareLocalNodeKeys,
-	type IDefaultEditBuilder,
-	type ValueFieldEditBuilder,
-	type OptionalFieldEditBuilder,
-	type SequenceFieldEditBuilder,
-	prefixPath,
-	prefixFieldPath,
-	cursorForJsonableTreeNode,
-	stackTreeNodeCursor,
-	type CursorAdapter,
-	type CursorWithNode,
-	type FlexTreeNodeEvents,
-	type ArrayLikeMut,
-	FieldKinds,
-	type ContextuallyTypedFieldData,
-	cursorFromContextualData,
-	type FlexAllowedTypes,
-	type FlexTreeNodeSchema,
-	type FlexTreeSchema,
-	type SchemaLibrary,
-	type SchemaLibraryData,
-	FlexFieldSchema,
-	Any,
-	type NewFieldContent,
-	type NodeExistsConstraint,
-	cursorForTypedTreeData,
-	type LazyTreeNodeSchema,
-	type FieldGenerator,
-	type TreeDataContext,
-	type SchemaLintConfiguration,
+	type LazyItem,
 	TreeStatus,
-	type FlexTreeFieldNode,
-	type FlexibleFieldContent,
-	type FlexibleNodeContent,
-	type FlexTreeLeafNode,
-	type FlexTreeMapNode,
-	type FlexTreeOptionalField,
-	type FlexTreeRequiredField,
-	type FlexTreeSequenceField,
-	type FlexTreeObjectNode,
-	type FlexTreeObjectNodeTyped,
-	type AssignableFieldKinds,
-	type FlexTreeContext,
-	type FlexTreeTypedField,
-	type FlexTreeTypedNode,
-	type FlexTreeTypedNodeUnion,
-	type FlexTreeEntity,
-	type FlexTreeField,
-	type FlexTreeNode,
-	TreeNodeSchemaBase,
-	FlexFieldNodeSchema,
-	LeafNodeSchema,
-	FlexMapNodeSchema,
-	FlexObjectNodeSchema,
-	type CheckTypesOverlap,
-	SchemaBuilderBase,
-	type FlexImplicitFieldSchema,
-	type FlexImplicitAllowedTypes,
 	type Unenforced,
-	schemaIsFieldNode,
-	schemaIsLeaf,
-	schemaIsMap,
-	schemaIsObjectNode,
-	type AllowedTypeSet,
-	type SchemaBuilderOptions,
-	type SchemaCollection,
 	TreeCompressionStrategy,
-	treeSchemaFromStoredSchema,
-	encodeTreeSchema,
-	stackTreeFieldCursor,
-	type FlexTreeUnknownUnboxed,
-	type InsertableFlexNode,
-	type InsertableFlexField,
-	type AllowedTypesToFlexInsertableTree,
-	type ApplyMultiplicity,
-	type NormalizeObjectNodeFields,
-	type NormalizeFieldSchema,
-	type FlexObjectNodeFields,
-	type FlexMapFieldSchema,
-	type LazyItem,
-	type PropertyNameFromFieldKey,
-	type ReservedObjectNodeFieldPropertyNames,
-	type ReservedObjectNodeFieldPropertyNamePrefixes,
-	reservedObjectNodeFieldPropertyNames,
-	reservedObjectNodeFieldPropertyNamePrefixes,
-	type FlexTreeObjectNodeFieldsInner,
 } from "./feature-libraries/index.js";
 
 export {
 	type ISharedTree,
-	type ITreeCheckout,
-	type ITransaction,
-	runSynchronous,
 	type SharedTreeOptions,
-	type ITreeCheckoutFork,
-	type CheckoutEvents,
-	type SchematizeConfiguration,
-	type TreeContent,
-	type InitializeAndSchematizeConfiguration,
-	type SchemaConfiguration,
 	ForestType,
 	type SharedTreeContentSnapshot,
-	type FlexTreeView,
-	type FlexTreeViewGeneric,
-	type ITreeViewFork,
-	buildTreeConfiguration,
-	type ISharedTreeEditor,
-	type ISchemaEditor,
 	type RevertibleFactory,
 	type SharedTreeFormatOptions,
 	SharedTreeFormatVersion,
@@ -295,6 +99,8 @@ export {
 	type SchemaCompatibilityStatus,
 	type FieldProps,
 	type InternalTreeNode,
+	type WithType,
+	type NodeChangedData,
 	// Types not really intended for public use, but used in links.
 	// Can not be moved to internalTypes since doing so causes app code to throw errors like:
 	// Error: src/simple-tree/objectNode.ts:72:1 - (ae-unresolved-link) The @link reference could not be resolved: The package "@fluidframework/tree" does not have an export "TreeNodeApi"
@@ -304,7 +110,6 @@ export {
 	// Can not be moved to internalTypes since doing so causes app code to throw errors like:
 	// error TS2742: The inferred type of 'Inventory' cannot be named without a reference to '../node_modules/@fluidframework/tree/lib/internalTypes.js'. This is likely not portable. A type annotation is necessary.
 	type AllowedTypes,
-	type WithType,
 	type TreeObjectNodeUnsafe,
 	type InsertableTreeNodeFromImplicitAllowedTypesUnsafe,
 	type TreeArrayNodeUnsafe,
@@ -312,17 +117,36 @@ export {
 	type InsertableObjectFromSchemaRecordUnsafe,
 	type InsertableTreeFieldFromImplicitFieldUnsafe,
 	type FieldSchemaUnsafe,
+	// System types (not in Internal types for various reasons, like doc links or cannot be named errors).
+	type typeSchemaSymbol,
 	// Recursive Schema APIs
 	type ValidateRecursiveSchema,
+	type FixRecursiveArraySchema,
 	// experimental @internal APIs:
 	adaptEnum,
 	enumFromStrings,
 	singletonSchema,
 	typedObjectValues,
+	type EmptyObject,
 	// test recursive schema for checking that d.ts files handles schema correctly
 	test_RecursiveObject,
 	test_RecursiveObject_base,
 	test_RecursiveObjectPojoMode,
+	// Back to normal types
+	type JsonTreeSchema,
+	type JsonSchemaId,
+	type JsonNodeSchema,
+	type JsonNodeSchemaBase,
+	type JsonLeafNodeSchema,
+	type JsonMapNodeSchema,
+	type JsonArrayNodeSchema,
+	type JsonObjectNodeSchema,
+	type JsonFieldSchema,
+	type JsonSchemaRef,
+	type JsonRefPath,
+	type JsonSchemaType,
+	type JsonLeafSchemaType,
+	getJsonSchema,
 } from "./simple-tree/index.js";
 export { SharedTree, configuredSharedTree } from "./treeFactory.js";
 
@@ -330,52 +154,13 @@ export type { ICodecOptions, JsonValidator, SchemaValidationFunction } from "./c
 export { noopValidator } from "./codec/index.js";
 export { typeboxValidator } from "./external-utilities/index.js";
 
-// TODO: When previously tagged '@internal', these types could not be included in `InternalClassTreeTypes` due to https://github.com/microsoft/rushstack/issues/3639
 export {
-	type Invariant,
-	type Contravariant,
 	type Covariant,
 	BrandedType,
-	type ExtractFromOpaque,
-	type Assume,
-	type AllowOptional,
-	type RequiredFields,
-	type OptionalFields,
-	type _RecursiveTrick,
-	type AllowOptionalNotFlattened,
-	type isAny,
-	type BrandedKeyContent,
 	type RestrictiveReadonlyRecord,
 	type MakeNominal,
 } from "./util/index.js";
 
-export {
-	type NormalizeField,
-	type NormalizeAllowedTypes,
-	type FlexTreeTypedFieldInner,
-	type FlexTreeUnboxFieldInner,
-	type FlexTreeObjectNodeFields,
-	type FlexTreeUnboxField,
-	type FlexTreeUnboxNode,
-	type FlexTreeUnboxNodeUnion,
-	type IsArrayOfOne,
-	type FlexibleNodeSubSequence,
-	flexTreeMarker,
-	FlexTreeEntityKind,
-	type NodeKeyManager,
-	type CollectOptions,
-	type TypedFields,
-	type UnbrandedName,
-	type EmptyObject,
-	// These field kind types really only need to show up via FieldKinds.name, and not as top level names in the package.
-	// These names also are collision prone.
-	type Required,
-	type Optional,
-	type Identifier,
-	type Forbidden,
-	type Sequence,
-} from "./feature-libraries/index.js";
-
 import * as InternalTypes from "./internalTypes.js";
 export {
 	/**
@@ -384,3 +169,8 @@ export {
 	 */
 	InternalTypes,
 };
+
+// Internal/System types:
+// These would be put in `internalTypes` except doing so tents to cause errors like:
+// The inferred type of 'NodeMap' cannot be named without a reference to '../../node_modules/@fluidframework/tree/lib/internalTypes.js'. This is likely not portable. A type annotation is necessary.
+export type { MapNodeInsertableData } from "./simple-tree/index.js";

package/src/internalTypes.ts

@@ -33,6 +33,7 @@ export type {
 	InsertableTypedNodeUnsafe,
 	NodeBuilderDataUnsafe,
 	NodeFromSchemaUnsafe,
+	ReadonlyMapInlined,
 } from "./simple-tree/index.js";
 export type { FlexList, FlexListToUnion, ExtractItemType } from "./feature-libraries/index.js";
 

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/tree";
-export const pkgVersion = "2.1.0";
+export const pkgVersion = "2.3.0-288113";

package/src/shared-tree/schematizeTree.ts

@@ -8,6 +8,7 @@ import { assert, unreachableCase } from "@fluidframework/core-utils/internal";
 import {
 	AllowedUpdateType,
 	Compatibility,
+	CursorLocationType,
 	type ITreeCursorSynchronous,
 	type TreeStoredSchema,
 	rootFieldKey,
@@ -17,14 +18,14 @@ import {
 	FieldKinds,
 	type FlexFieldSchema,
 	type FlexTreeSchema,
-	type InsertableFlexField,
 	type ViewSchema,
 	allowsRepoSuperset,
+	cursorForMapTreeField,
 	defaultSchemaPolicy,
 	intoStoredSchema,
-	normalizeNewFieldContent,
+	mapTreeFromCursor,
 } from "../feature-libraries/index.js";
-import { fail } from "../util/index.js";
+import { fail, isReadonlyArray } from "../util/index.js";
 
 import type { ITreeCheckout } from "./treeCheckout.js";
 
@@ -155,6 +156,24 @@ export function canInitialize(checkout: ITreeCheckout): boolean {
 	return checkout.forest.isEmpty && schemaDataIsEmpty(checkout.storedSchema);
 }
 
+function normalizeNewFieldContent(
+	content: readonly ITreeCursorSynchronous[] | ITreeCursorSynchronous | undefined,
+): ITreeCursorSynchronous {
+	if (content === undefined) {
+		return cursorForMapTreeField([]);
+	}
+
+	if (isReadonlyArray(content)) {
+		return cursorForMapTreeField(content.map((c) => mapTreeFromCursor(c)));
+	}
+
+	if (content.mode === CursorLocationType.Fields) {
+		return content;
+	}
+
+	return cursorForMapTreeField([mapTreeFromCursor(content)]);
+}
+
 /**
  * Initialize a checkout with a schema and tree content.
  * This function should only be called when the tree is uninitialized (no schema or content).
@@ -168,11 +187,8 @@ export function initialize(checkout: ITreeCheckout, treeContent: TreeContent): v
 	try {
 		initializeContent(checkout, treeContent.schema, () => {
 			const field = { field: rootFieldKey, parent: undefined };
-			const content = normalizeNewFieldContent(
-				{ schema: treeContent.schema },
-				treeContent.schema.rootFieldSchema,
-				treeContent.initialTree,
-			);
+			const content = normalizeNewFieldContent(treeContent.initialTree);
+
 			switch (checkout.storedSchema.rootFieldSchema.kind) {
 				case FieldKinds.optional.identifier: {
 					const fieldEditor = checkout.editor.optionalField(field);
@@ -253,8 +269,6 @@ export function ensureSchema(
 
 /**
  * View Schema for a `SharedTree`.
- *
- * @internal
  */
 export interface SchemaConfiguration<TRoot extends FlexFieldSchema = FlexFieldSchema> {
 	/**
@@ -265,8 +279,6 @@ export interface SchemaConfiguration<TRoot extends FlexFieldSchema = FlexFieldSc
 
 /**
  * Content that can populate a `SharedTree`.
- *
- * @internal
  */
 export interface TreeContent<TRoot extends FlexFieldSchema = FlexFieldSchema>
 	extends SchemaConfiguration<TRoot> {
@@ -274,16 +286,11 @@ export interface TreeContent<TRoot extends FlexFieldSchema = FlexFieldSchema>
 	 * Default tree content to initialize the tree with iff the tree is uninitialized
 	 * (meaning it does not even have any schema set at all).
 	 */
-	readonly initialTree:
-		| InsertableFlexField<TRoot>
-		| readonly ITreeCursorSynchronous[]
-		| ITreeCursorSynchronous;
+	readonly initialTree: readonly ITreeCursorSynchronous[] | ITreeCursorSynchronous | undefined;
 }
 
 /**
  * Options used to schematize a `SharedTree`.
- *
- * @internal
  */
 export interface SchematizeConfiguration<TRoot extends FlexFieldSchema = FlexFieldSchema>
 	extends SchemaConfiguration<TRoot> {
@@ -295,8 +302,6 @@ export interface SchematizeConfiguration<TRoot extends FlexFieldSchema = FlexFie
 
 /**
  * Options used to initialize (if needed) and schematize a `SharedTree`.
- *
- * @internal
  */
 export interface InitializeAndSchematizeConfiguration<
 	TRoot extends FlexFieldSchema = FlexFieldSchema,
@@ -307,7 +312,6 @@ export interface InitializeAndSchematizeConfiguration<
  * Options used to initialize (if needed) and schematize a `SharedTree`.
  * @remarks
  * Using this builder improves type safety and error quality over just constructing the configuration as a object.
- * @internal
  */
 export function buildTreeConfiguration<T extends FlexFieldSchema>(
 	config: InitializeAndSchematizeConfiguration<T>,

package/src/shared-tree/schematizingTreeView.ts

@@ -30,7 +30,7 @@ import {
 	type TreeFieldFromImplicitField,
 	type TreeView,
 	type TreeViewEvents,
-	getProxyForField,
+	getTreeNodeForField,
 	toFlexSchema,
 	setField,
 	normalizeFieldSchema,
@@ -42,7 +42,7 @@ import {
 import { Breakable, breakingClass, disposeSymbol, type WithBreakable } from "../util/index.js";
 
 import { canInitialize, ensureSchema, initialize } from "./schematizeTree.js";
-import type { TreeCheckout } from "./treeCheckout.js";
+import type { ITreeCheckout } from "./treeCheckout.js";
 import { CheckoutFlexTreeView } from "./treeView.js";
 
 /**
@@ -84,7 +84,7 @@ export class SchematizingSimpleTreeView<in out TRootSchema extends ImplicitField
 	private readonly rootFieldSchema: FieldSchema;
 
 	public constructor(
-		public readonly checkout: TreeCheckout,
+		public readonly checkout: ITreeCheckout,
 		public readonly config: TreeViewConfiguration<TRootSchema>,
 		public readonly nodeKeyManager: NodeKeyManager,
 		public readonly breaker: Breakable = new Breakable("SchematizingSimpleTreeView"),
@@ -124,7 +124,7 @@ export class SchematizingSimpleTreeView<in out TRootSchema extends ImplicitField
 		this.runSchemaEdit(() => {
 			const mapTree = mapTreeFromNodeData(
 				content as InsertableContent,
-				this.rootFieldSchema.allowedTypes,
+				this.rootFieldSchema,
 				this.nodeKeyManager,
 				{
 					schema: this.checkout.storedSchema,
@@ -315,7 +315,7 @@ export class SchematizingSimpleTreeView<in out TRootSchema extends ImplicitField
 			);
 		}
 		const view = this.getView();
-		return getProxyForField(view.flexTree) as TreeFieldFromImplicitField<TRootSchema>;
+		return getTreeNodeForField(view.flexTree) as TreeFieldFromImplicitField<TRootSchema>;
 	}
 
 	public set root(newRoot: InsertableTreeFieldFromImplicitField<TRootSchema>) {
@@ -335,7 +335,7 @@ export class SchematizingSimpleTreeView<in out TRootSchema extends ImplicitField
  * This may only be called when the schema is already known to be compatible (typically via ensureSchema).
  */
 export function requireSchema<TRoot extends FlexFieldSchema>(
-	checkout: TreeCheckout,
+	checkout: ITreeCheckout,
 	viewSchema: ViewSchema<TRoot>,
 	onDispose: () => void,
 	nodeKeyManager: NodeKeyManager,

package/src/shared-tree/sharedTree.ts

@@ -31,11 +31,9 @@ import {
 } from "../events/index.js";
 import {
 	DetachedFieldIndexSummarizer,
-	type FlexFieldSchema,
 	ForestSummarizer,
 	SchemaSummarizer,
 	TreeCompressionStrategy,
-	ViewSchema,
 	buildChunkedForest,
 	buildForest,
 	createNodeKeyManager,
@@ -56,14 +54,12 @@ import type {
 	TreeViewConfiguration,
 } from "../simple-tree/index.js";
 
-import { type InitializeAndSchematizeConfiguration, ensureSchema } from "./schematizeTree.js";
-import { SchematizingSimpleTreeView, requireSchema } from "./schematizingTreeView.js";
+import { SchematizingSimpleTreeView } from "./schematizingTreeView.js";
 import { SharedTreeReadonlyChangeEnricher } from "./sharedTreeChangeEnricher.js";
 import { SharedTreeChangeFamily } from "./sharedTreeChangeFamily.js";
 import type { SharedTreeChange } from "./sharedTreeChangeTypes.js";
 import type { SharedTreeEditBuilder } from "./sharedTreeEditBuilder.js";
 import { type CheckoutEvents, type TreeCheckout, createTreeCheckout } from "./treeCheckout.js";
-import type { CheckoutFlexTreeView, FlexTreeView } from "./treeView.js";
 import { breakingClass, throwIfBroken } from "../util/index.js";
 
 /**
@@ -82,20 +78,17 @@ export interface SharedTreeContentSnapshot {
 	 */
 	readonly schema: TreeStoredSchema;
 	/**
-	 * All {@link TreeStatus#InDocument} content.
+	 * All {@link TreeStatus.InDocument} content.
 	 */
 	readonly tree: JsonableTree[];
 	/**
-	 * All {@link TreeStatus#Removed} content.
+	 * All {@link TreeStatus.Removed} content.
 	 */
 	readonly removed: [string | number | undefined, number, JsonableTree][];
 }
 
 /**
- * Collaboratively editable tree distributed data-structure,
- * powered by {@link @fluidframework/shared-object-base#ISharedObject}.
- *
- * See [the README](../../README.md) for details.
+ * {@link ITree} extended with some non-public APIs.
  * @internal
  */
 export interface ISharedTree extends ISharedObject, ITree {
@@ -107,17 +100,6 @@ export interface ISharedTree extends ISharedObject, ITree {
 	 * This does not include everything that is included in a tree summary, since information about how to merge future edits is omitted.
 	 */
 	contentSnapshot(): SharedTreeContentSnapshot;
-
-	/**
-	 * Like {@link ITree.viewWith}, but uses the flex-tree schema system and exposes the tree as a flex-tree.
-	 *
-	 * Returned view is disposed when the stored schema becomes incompatible with the view schema.
-	 * Undefined is returned if the stored data could not be made compatible with the view schema.
-	 */
-	schematizeFlexTree<TRoot extends FlexFieldSchema>(
-		config: InitializeAndSchematizeConfiguration<TRoot>,
-		onDispose: () => void,
-	): FlexTreeView<TRoot> | undefined;
 }
 
 /**
@@ -150,6 +132,10 @@ const formatVersionToTopLevelCodecVersions = new Map<number, ExplicitCodecVersio
 		3,
 		{ forest: 1, schema: 1, detachedFieldIndex: 1, editManager: 3, message: 3, fieldBatch: 1 },
 	],
+	[
+		4,
+		{ forest: 1, schema: 1, detachedFieldIndex: 1, editManager: 4, message: 4, fieldBatch: 1 },
+	],
 ]);
 
 function getCodecVersions(formatVersion: number): ExplicitCodecVersions {
@@ -307,23 +293,6 @@ export class SharedTree
 		}
 	}
 
-	public schematizeFlexTree<TRoot extends FlexFieldSchema>(
-		config: InitializeAndSchematizeConfiguration<TRoot>,
-		onDispose: () => void,
-	): CheckoutFlexTreeView<TRoot> | undefined {
-		const viewSchema = new ViewSchema(defaultSchemaPolicy, {}, config.schema);
-		if (!ensureSchema(viewSchema, config.allowedSchemaModifications, this.checkout, config)) {
-			return undefined;
-		}
-
-		return requireSchema(
-			this.checkout,
-			viewSchema,
-			onDispose,
-			createNodeKeyManager(this.runtime.idCompressor),
-		);
-	}
-
 	public viewWith<TRoot extends ImplicitFieldSchema>(
 		config: TreeViewConfiguration<TRoot>,
 	): SchematizingSimpleTreeView<TRoot> {

package/src/shared-tree/sharedTreeChangeCodecs.ts

@@ -56,6 +56,14 @@ export function makeSharedTreeChangeCodecFamily(
 				options,
 			),
 		],
+		[
+			4,
+			makeSharedTreeChangeCodec(
+				modularChangeCodecFamily.resolve(4).json,
+				schemaChangeCodecs.resolve(1).json,
+				options,
+			),
+		],
 	]);
 }
 

package/src/shared-tree/sharedTreeChangeFamily.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { assert } from "@fluidframework/core-utils/internal";
+import { assert, oob } from "@fluidframework/core-utils/internal";
 
 import type { ICodecFamily, ICodecOptions } from "../codec/index.js";
 import {
@@ -173,8 +173,8 @@ export class SharedTreeChangeFamily
 			0x884 /* SharedTreeChange should have exactly one inner change if no schema change is present. */,
 		);
 
-		const dataChangeIntention = change.change.changes[0];
-		const dataChangeOver = over.change.changes[0];
+		const dataChangeIntention = change.change.changes[0] ?? oob();
+		const dataChangeOver = over.change.changes[0] ?? oob();
 		assert(
 			dataChangeIntention.type === "data" && dataChangeOver.type === "data",
 			0x885 /* Data change should be present. */,