@fluidframework/tree 2.70.0 → 2.72.0

package/src/feature-libraries/schema-edits/schemaChangeCodecs.ts

@@ -4,11 +4,12 @@
  */
 
 import { assert } from "@fluidframework/core-utils/internal";
+import type { MinimumVersionForCollab } from "@fluidframework/runtime-definitions/internal";
 
 import {
 	type CodecTree,
+	type CodecWriteOptions,
 	type ICodecFamily,
-	type ICodecOptions,
 	type IJsonCodec,
 	makeCodecFamily,
 	makeVersionDispatchingCodec,
@@ -18,32 +19,31 @@ import { getCodecTreeForSchemaFormat, makeSchemaCodec } from "../schema-index/in
 
 import { EncodedSchemaChange } from "./schemaChangeFormat.js";
 import type { SchemaChange } from "./schemaChangeTypes.js";
-import { SchemaVersion } from "../../core/index.js";
-import type { Brand } from "../../util/index.js";
+import { SchemaFormatVersion } from "../../core/index.js";
+import { brand } from "../../util/index.js";
 
 /**
  * Create a family of schema change codecs.
  * @param options - Specifies common codec options, including which `validator` to use.
  * @returns The composed codec family.
  */
-export function makeSchemaChangeCodecs(options: ICodecOptions): ICodecFamily<SchemaChange> {
+export function makeSchemaChangeCodecs(
+	options: CodecWriteOptions,
+): ICodecFamily<SchemaChange> {
 	return makeCodecFamily([
-		[SchemaVersion.v1, makeSchemaChangeCodecV1(options, SchemaVersion.v1)],
-		[SchemaVersion.v2, makeSchemaChangeCodecV1(options, SchemaVersion.v2)],
+		[SchemaFormatVersion.v1, makeSchemaChangeCodecV1(options, brand(SchemaFormatVersion.v1))],
+		[SchemaFormatVersion.v2, makeSchemaChangeCodecV1(options, brand(SchemaFormatVersion.v2))],
 	]);
 }
 
-export type SchemaChangeFormatVersion = Brand<
-	SchemaVersion.v1 | SchemaVersion.v2,
-	"SchemaChangeFormatVersion"
->;
 export function getCodecTreeForSchemaChangeFormat(
-	version: SchemaChangeFormatVersion,
+	version: SchemaFormatVersion,
+	clientVersion: MinimumVersionForCollab,
 ): CodecTree {
 	return {
 		name: "SchemaChange",
 		version,
-		children: [getCodecTreeForSchemaFormat(version)],
+		children: [getCodecTreeForSchemaFormat(clientVersion)],
 	};
 }
 
@@ -54,8 +54,8 @@ export function getCodecTreeForSchemaChangeFormat(
  * @returns The composed codec.
  */
 export function makeSchemaChangeCodec(
-	options: ICodecOptions,
-	writeVersion: SchemaVersion,
+	options: CodecWriteOptions,
+	writeVersion: SchemaFormatVersion,
 ): IJsonCodec<SchemaChange> {
 	const family = makeSchemaChangeCodecs(options);
 	return makeVersionDispatchingCodec(family, { ...options, writeVersion });
@@ -68,8 +68,8 @@ export function makeSchemaChangeCodec(
  * @returns The composed schema change codec.
  */
 function makeSchemaChangeCodecV1(
-	options: ICodecOptions,
-	schemaWriteVersion: SchemaVersion,
+	options: CodecWriteOptions,
+	schemaWriteVersion: SchemaFormatVersion,
 ): IJsonCodec<SchemaChange, EncodedSchemaChange> {
 	const schemaCodec = makeSchemaCodec(options, schemaWriteVersion);
 	const schemaChangeCodec: IJsonCodec<SchemaChange, EncodedSchemaChange> = {

package/src/feature-libraries/schema-index/codec.ts

@@ -7,6 +7,8 @@ import { fail, unreachableCase } from "@fluidframework/core-utils/internal";
 
 import {
 	type CodecTree,
+	type CodecWriteOptions,
+	FluidClientVersion,
 	type ICodecFamily,
 	type ICodecOptions,
 	type IJsonCodec,
@@ -15,7 +17,7 @@ import {
 	makeVersionedValidatedCodec,
 } from "../../codec/index.js";
 import {
-	SchemaVersion,
+	SchemaFormatVersion,
 	type TreeNodeSchemaIdentifier,
 	type TreeNodeStoredSchema,
 	type TreeStoredSchema,
@@ -31,35 +33,42 @@ import { Format as FormatV2 } from "./formatV2.js";
 import type { MinimumVersionForCollab } from "@fluidframework/runtime-definitions/internal";
 
 /**
- * Convert a MinimumVersionForCollab to a SchemaVersion.
+ * Convert a MinimumVersionForCollab to a SchemaFormatVersion.
  * @param clientVersion - The MinimumVersionForCollab to convert.
- * @returns The SchemaVersion that corresponds to the provided MinimumVersionForCollab.
+ * @returns The SchemaFormatVersion that corresponds to the provided MinimumVersionForCollab.
  */
 export function clientVersionToSchemaVersion(
 	clientVersion: MinimumVersionForCollab,
-): SchemaVersion {
-	// Only one version of the schema codec is currently supported.
-	return SchemaVersion.v1;
+): SchemaFormatVersion {
+	return clientVersion < FluidClientVersion.v2_43
+		? brand(SchemaFormatVersion.v1)
+		: brand(SchemaFormatVersion.v2);
 }
 
-export function getCodecTreeForSchemaFormat(version: SchemaVersion): CodecTree {
-	return { name: "Schema", version };
+export function getCodecTreeForSchemaFormat(
+	clientVersion: MinimumVersionForCollab,
+): CodecTree {
+	return { name: "Schema", version: clientVersionToSchemaVersion(clientVersion) };
 }
 
 /**
  * Create a schema codec.
- * @param options - Specifies common codec options, including which `validator` to use.
- * @param writeVersion - The schema write version.
+ * @param options - Specifies common codec options, including `minVersionForCollab` and which `validator` to use.
+ * @param writeVersionOverride - The schema version to write. If not provided, the version will be derived from `minVersionForCollab`.
  * @returns The composed codec.
  *
  * @privateRemarks We should consider using the Shared Tree format version instead as it may be more valuable for application authors than the schema version.
  */
 export function makeSchemaCodec(
-	options: ICodecOptions,
-	writeVersion: SchemaVersion,
+	options: CodecWriteOptions,
+	writeVersionOverride?: SchemaFormatVersion,
 ): IJsonCodec<TreeStoredSchema> {
 	const family = makeSchemaCodecs(options);
-	return makeVersionDispatchingCodec(family, { ...options, writeVersion });
+	return makeVersionDispatchingCodec(family, {
+		...options,
+		writeVersion:
+			writeVersionOverride ?? clientVersionToSchemaVersion(options.minVersionForCollab),
+	});
 }
 
 /**
@@ -69,8 +78,8 @@ export function makeSchemaCodec(
  */
 export function makeSchemaCodecs(options: ICodecOptions): ICodecFamily<TreeStoredSchema> {
 	return makeCodecFamily([
-		[SchemaVersion.v1, makeSchemaCodecV1(options)],
-		[SchemaVersion.v2, makeSchemaCodecV2(options)],
+		[SchemaFormatVersion.v1, makeSchemaCodecV1(options)],
+		[SchemaFormatVersion.v2, makeSchemaCodecV2(options)],
 	]);
 }
 
@@ -80,11 +89,14 @@ export function makeSchemaCodecs(options: ICodecOptions): ICodecFamily<TreeStore
  * @param version - The schema write version.
  * @returns The encoded schema.
  */
-export function encodeRepo(repo: TreeStoredSchema, version: SchemaVersion): JsonCompatible {
+export function encodeRepo(
+	repo: TreeStoredSchema,
+	version: SchemaFormatVersion,
+): JsonCompatible {
 	switch (version) {
-		case SchemaVersion.v1:
+		case SchemaFormatVersion.v1:
 			return encodeRepoV1(repo) as JsonCompatible;
-		case SchemaVersion.v2:
+		case SchemaFormatVersion.v2:
 			return encodeRepoV2(repo) as JsonCompatible;
 		default:
 			unreachableCase(version);
@@ -95,7 +107,7 @@ function encodeRepoV1(repo: TreeStoredSchema): FormatV1 {
 	const nodeSchema = encodeNodeSchema(repo, (schema) => schema.encodeV1());
 	const rootFieldSchema = encodeFieldSchemaV1(repo.rootFieldSchema);
 	return {
-		version: SchemaVersion.v1,
+		version: SchemaFormatVersion.v1,
 		nodes: nodeSchema,
 		root: rootFieldSchema,
 	};
@@ -105,7 +117,7 @@ function encodeRepoV2(repo: TreeStoredSchema): FormatV2 {
 	const nodeSchema = encodeNodeSchema(repo, (schema) => schema.encodeV2());
 	const rootFieldSchema = encodeFieldSchemaV2(repo.rootFieldSchema);
 	return {
-		version: SchemaVersion.v2,
+		version: SchemaFormatVersion.v2,
 		nodes: nodeSchema,
 		root: rootFieldSchema,
 	};
@@ -169,7 +181,7 @@ function decodeV2(f: FormatV2): TreeStoredSchema {
  * @returns The codec.
  */
 function makeSchemaCodecV1(options: ICodecOptions): IJsonCodec<TreeStoredSchema, FormatV1> {
-	return makeVersionedValidatedCodec(options, new Set([SchemaVersion.v1]), FormatV1, {
+	return makeVersionedValidatedCodec(options, new Set([SchemaFormatVersion.v1]), FormatV1, {
 		encode: (data: TreeStoredSchema) => encodeRepoV1(data),
 		decode: (data: FormatV1) => decodeV1(data),
 	});
@@ -181,7 +193,7 @@ function makeSchemaCodecV1(options: ICodecOptions): IJsonCodec<TreeStoredSchema,
  * @returns The codec.
  */
 function makeSchemaCodecV2(options: ICodecOptions): IJsonCodec<TreeStoredSchema, FormatV2> {
-	return makeVersionedValidatedCodec(options, new Set([SchemaVersion.v2]), FormatV2, {
+	return makeVersionedValidatedCodec(options, new Set([SchemaFormatVersion.v2]), FormatV2, {
 		encode: (data: TreeStoredSchema) => encodeRepoV2(data),
 		decode: (data: FormatV2) => decodeV2(data),
 	});

package/src/feature-libraries/schema-index/formatV1.ts

@@ -5,7 +5,7 @@
 
 import { type ObjectOptions, type Static, Type } from "@sinclair/typebox";
 
-import { SchemaVersion, schemaFormatV1 } from "../../core/index.js";
+import { SchemaFormatVersion, schemaFormatV1 } from "../../core/index.js";
 
 const noAdditionalProps: ObjectOptions = { additionalProperties: false };
 
@@ -21,7 +21,7 @@ const noAdditionalProps: ObjectOptions = { additionalProperties: false };
  */
 export const Format = Type.Object(
 	{
-		version: Type.Literal(SchemaVersion.v1),
+		version: Type.Literal(SchemaFormatVersion.v1),
 		nodes: Type.Record(Type.String(), schemaFormatV1.TreeNodeSchemaDataFormat),
 		root: schemaFormatV1.FieldSchemaFormat,
 	},

package/src/feature-libraries/schema-index/formatV2.ts

@@ -5,7 +5,7 @@
 
 import { type ObjectOptions, type Static, Type } from "@sinclair/typebox";
 
-import { SchemaVersion, schemaFormatV2 } from "../../core/index.js";
+import { SchemaFormatVersion, schemaFormatV2 } from "../../core/index.js";
 
 const noAdditionalProps: ObjectOptions = { additionalProperties: false };
 
@@ -21,7 +21,7 @@ const noAdditionalProps: ObjectOptions = { additionalProperties: false };
  */
 export const Format = Type.Object(
 	{
-		version: Type.Literal(SchemaVersion.v2),
+		version: Type.Literal(SchemaFormatVersion.v2),
 		nodes: Type.Record(Type.String(), schemaFormatV2.TreeNodeSchemaDataFormat),
 		root: schemaFormatV2.FieldSchemaFormat,
 	},

package/src/feature-libraries/schema-index/schemaSummarizer.ts

@@ -17,6 +17,7 @@ import { SummaryTreeBuilder } from "@fluidframework/runtime-utils/internal";
 import type { IJsonCodec } from "../../codec/index.js";
 import {
 	type MutableTreeStoredSchema,
+	type SchemaFormatVersion,
 	type TreeStoredSchema,
 	schemaDataIsEmpty,
 } from "../../core/index.js";
@@ -108,7 +109,7 @@ export class SchemaSummarizer implements Summarizable {
  */
 export function encodeTreeSchema(
 	schema: TreeStoredSchema,
-	writeVersion: number,
+	writeVersion: SchemaFormatVersion,
 ): JsonCompatible {
 	return encodeRepo(schema, writeVersion);
 }

package/src/index.ts

@@ -73,6 +73,8 @@ export {
 	type ObservationResults,
 	type TreeIdentifierUtils,
 	independentView,
+	createIndependentTreeBeta,
+	createIndependentTreeAlpha,
 	ForestTypeOptimized,
 	ForestTypeExpensiveDebug,
 	ForestTypeReference,
@@ -93,6 +95,7 @@ export {
 	type TreeViewEvents,
 	SchemaFactory,
 	SchemaFactoryBeta,
+	type SchemaStaticsBeta,
 	SchemaFactoryAlpha,
 	type ObjectSchemaOptionsAlpha,
 	type ObjectSchemaOptions,
@@ -179,7 +182,6 @@ export {
 	type AllowedTypeMetadata,
 	type AllowedTypesMetadata,
 	type UnannotateAllowedTypesList,
-	type SchemaStaticsAlpha,
 	type AnnotateAllowedTypesList,
 	type AllowedTypesFull,
 	type AllowedTypesFullFromMixed,
@@ -280,6 +282,9 @@ export {
 	type TreeParsingOptions,
 	type SchemaFactory_base,
 	type NumberKeys,
+	type SimpleAllowedTypeAttributes,
+	encodeSimpleSchema,
+	decodeSimpleSchema,
 } from "./simple-tree/index.js";
 export {
 	SharedTree,

package/src/packageVersion.ts

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

package/src/shared-tree/independentView.ts

@@ -10,13 +10,15 @@ import {
 	createIdCompressor,
 } from "@fluidframework/id-compressor/internal";
 
-import type { ICodecOptions } from "../codec/index.js";
 import {
-	type ITreeCursorSynchronous,
+	FluidClientVersion,
+	type CodecWriteOptions,
+	type ICodecOptions,
+} from "../codec/index.js";
+import {
 	type RevisionTag,
 	RevisionTagCodec,
-	SchemaVersion,
-	type TreeStoredSchema,
+	SchemaFormatVersion,
 	TreeStoredSchemaRepository,
 } from "../core/index.js";
 import {
@@ -28,17 +30,30 @@ import {
 	TreeCompressionStrategy,
 	defaultIncrementalEncodingPolicy,
 } from "../feature-libraries/index.js";
-// eslint-disable-next-line import/no-internal-modules
+// eslint-disable-next-line import-x/no-internal-modules
 import type { Format } from "../feature-libraries/schema-index/formatV1.js";
 import type {
 	TreeViewConfiguration,
 	ImplicitFieldSchema,
 	TreeViewAlpha,
+	ITreeAlpha,
+	ViewableTree,
+	TreeView,
+	ReadSchema,
+	VerboseTree,
+	SimpleTreeSchema,
 } from "../simple-tree/index.js";
-import { type JsonCompatibleReadOnly, type JsonCompatible, Breakable } from "../util/index.js";
+import {
+	type JsonCompatibleReadOnly,
+	type JsonCompatible,
+	Breakable,
+	oneFromIterable,
+	brand,
+} from "../util/index.js";
 import {
 	buildConfiguredForest,
 	defaultSharedTreeOptions,
+	exportSimpleSchema,
 	type ForestOptions,
 } from "./sharedTree.js";
 import { createTreeCheckout } from "./treeCheckout.js";
@@ -59,30 +74,9 @@ export function independentView<const TSchema extends ImplicitFieldSchema>(
 	config: TreeViewConfiguration<TSchema>,
 	options: ForestOptions & { idCompressor?: IIdCompressor | undefined },
 ): TreeViewAlpha<TSchema> {
-	const breaker = new Breakable("independentView");
-	const idCompressor: IIdCompressor = options.idCompressor ?? createIdCompressor();
-	const mintRevisionTag = (): RevisionTag => idCompressor.generateCompressedId();
-	const revisionTagCodec = new RevisionTagCodec(idCompressor);
-	const schema = new TreeStoredSchemaRepository();
-	const forest = buildConfiguredForest(
-		breaker,
-		options.forest ?? defaultSharedTreeOptions.forest,
-		schema,
-		idCompressor,
-		defaultIncrementalEncodingPolicy,
-	);
-	const checkout = createTreeCheckout(idCompressor, mintRevisionTag, revisionTagCodec, {
-		forest,
-		schema,
-		breaker,
-	});
-	const out: TreeViewAlpha<TSchema> = new SchematizingSimpleTreeView<TSchema>(
-		checkout,
-		config,
-		createNodeIdentifierManager(idCompressor),
-	);
-	return out;
+	return createIndependentTreeAlpha(options).viewWith(config) as TreeViewAlpha<TSchema>;
 }
+
 /**
  * Create an initialized {@link TreeView} that is not tied to any {@link ITree} instance.
  *
@@ -99,52 +93,101 @@ export function independentInitializedView<const TSchema extends ImplicitFieldSc
 	options: ForestOptions & ICodecOptions,
 	content: ViewContent,
 ): TreeViewAlpha<TSchema> {
-	const idCompressor: IIdCompressor = content.idCompressor;
-	const fieldBatchCodec = makeFieldBatchCodec(options, 1);
-	const schemaCodec = makeSchemaCodec(options, SchemaVersion.v1);
-
-	const schema = schemaCodec.decode(content.schema as Format);
-	const context: FieldBatchEncodingContext = {
-		encodeType: TreeCompressionStrategy.Compressed,
-		idCompressor,
-		originatorId: idCompressor.localSessionId, // Is this right? If so, why is is needed?
-		schema: { schema, policy: defaultSchemaPolicy },
-	};
-
-	const fieldCursors = fieldBatchCodec.decode(content.tree as JsonCompatibleReadOnly, context);
-	assert(fieldCursors.length === 1, 0xa5b /* must have exactly 1 field in batch */);
-
-	return independentInitializedViewInternal(
+	return createIndependentTreeAlpha({ ...options, content }).viewWith(
 		config,
-		options,
-		schema,
-		// Checked above.
-		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-		fieldCursors[0]!,
-		idCompressor,
-	);
+	) as TreeViewAlpha<TSchema>;
+}
+
+/**
+ * Create a {@link ViewableTree} that is not tied to any Fluid runtimes or services.
+ *
+ * @remarks
+ * Such a tree 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.
+ *
+ * @example
+ * ```typescript
+ * const tree = createIndependentTreeBeta();
+ *
+ * const stagedConfig = new TreeViewConfiguration({
+ * 	schema: SchemaFactoryAlpha.types([
+ * 		SchemaFactory.number,
+ * 		SchemaFactoryAlpha.staged(SchemaFactory.string),
+ * 	]),
+ * });
+ * const afterConfig = new TreeViewConfigurationAlpha({
+ * 	schema: [SchemaFactory.number, SchemaFactory.string],
+ * });
+ *
+ * // Initialize tree
+ * {
+ * 	const view = tree.viewWith(stagedConfig);
+ * 	view.initialize(1);
+ * 	view.dispose();
+ * }
+ *
+ * // Do schema upgrade
+ * {
+ * 	const view = tree.viewWith(afterConfig);
+ * 	view.upgradeSchema();
+ * 	view.root = "A";
+ * 	view.dispose();
+ * }
+ *
+ * // Can still view tree with staged schema
+ * {
+ * 	const view = tree.viewWith(stagedConfig);
+ * 	assert.equal(view.root, "A");
+ * 	view.dispose();
+ * }
+ * ```
+ * @privateRemarks
+ * Before stabilizing this as public, consider if we can instead just expose a better way to create regular Fluid service based SharedTrees for tests.
+ * Something like https://github.com/microsoft/FluidFramework/pull/25422 might be a better long term stable/public solution.
+ * @beta
+ */
+export function createIndependentTreeBeta<const TSchema extends ImplicitFieldSchema>(
+	options?: ForestOptions,
+): ViewableTree {
+	return createIndependentTreeAlpha<TSchema>(options);
 }
 
 /**
- * {@link independentInitializedView} but using internal types instead of persisted data formats.
+ * Alpha extensions to {@link createIndependentTreeBeta}.
+ *
+ * @param options - Configuration options for the independent tree.
+ * This can be used to create an uninitialized tree, or `content` can be provided to create an initialized tree.
+ * If content is provided, the idCompressor is a required part of it: otherwise it is optional and provided at the top level.
+ *
+ * @privateRemarks
+ * TODO: Support more of {@link ITreeAlpha}, including branching APIs to allow for merges.
+ * TODO: Better unify this logic with SharedTreeKernel and SharedTreeCore.
+ *
+ * Before further stabilizing: consider better ways to handle initialized vs uninitialized trees.
+ * Perhaps it would be better to not allow initialize here at all, but expose the ability to load compressed tree content and stored schema via ITree or TreeView?
+ * If keeping the option here, maybe a separate function of overload would be better? Or maybe flatten ViewContent inline to deduplicate the idCompressor options?
+ * @alpha
  */
-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);
+export function createIndependentTreeAlpha<const TSchema extends ImplicitFieldSchema>(
+	options?: ForestOptions &
+		(
+			| ({ idCompressor?: IIdCompressor | undefined } & { content?: undefined })
+			| (ICodecOptions & { content: ViewContent } & { idCompressor?: undefined })
+		),
+): ViewableTree & Pick<ITreeAlpha, "exportVerbose" | "exportSimpleSchema"> {
+	const breaker = new Breakable("independentView");
+	const idCompressor: IIdCompressor =
+		options?.idCompressor ?? options?.content?.idCompressor ?? createIdCompressor();
 	const mintRevisionTag = (): RevisionTag => idCompressor.generateCompressedId();
+	const revisionTagCodec = new RevisionTagCodec(idCompressor);
 
 	// 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,
+		options?.forest ?? defaultSharedTreeOptions.forest,
 		schemaRepository,
 		idCompressor,
 		defaultIncrementalEncodingPolicy,
@@ -156,18 +199,61 @@ export function independentInitializedViewInternal<const TSchema extends Implici
 		breaker,
 	});
 
-	initialize(
-		checkout,
-		schema,
-		initializerFromChunk(checkout, () =>
-			combineChunks(checkout.forest.chunkField(rootFieldCursor)),
-		),
-	);
-	return new SchematizingSimpleTreeView<TSchema>(
-		checkout,
-		config,
-		createNodeIdentifierManager(idCompressor),
-	);
+	if (options?.content !== undefined) {
+		// Any version can be passed down to `makeSchemaCodec` and `makeFieldBatchCodec` here.
+		// We only use the decode part, which always dispatches to the correct codec based on the version in the data, not `minVersionForCollab`.
+		const writeOptions: CodecWriteOptions = {
+			...options,
+			minVersionForCollab: FluidClientVersion.v2_0,
+		};
+		const schemaCodec = makeSchemaCodec(writeOptions, brand(SchemaFormatVersion.v1));
+		const fieldBatchCodec = makeFieldBatchCodec(writeOptions);
+		const newSchema = schemaCodec.decode(options.content.schema as Format);
+
+		const context: FieldBatchEncodingContext = {
+			encodeType: TreeCompressionStrategy.Compressed,
+			idCompressor,
+			originatorId: idCompressor.localSessionId, // Is this right? If so, why is is needed?
+			schema: { schema: newSchema, policy: defaultSchemaPolicy },
+		};
+		const fieldCursors = fieldBatchCodec.decode(
+			options.content.tree as JsonCompatibleReadOnly,
+			context,
+		);
+		assert(fieldCursors.length === 1, 0xa5b /* must have exactly 1 field in batch */);
+
+		const fieldCursor = oneFromIterable(fieldCursors);
+		assert(fieldCursor !== undefined, 0xc94 /* expected exactly one field in batch */);
+
+		initialize(
+			checkout,
+			newSchema,
+			initializerFromChunk(checkout, () =>
+				combineChunks(checkout.forest.chunkField(fieldCursor)),
+			),
+		);
+	}
+
+	return {
+		viewWith<TRoot extends ImplicitFieldSchema>(
+			config: TreeViewConfiguration<TRoot>,
+		): TreeView<TRoot> {
+			const out: TreeViewAlpha<TSchema> = new SchematizingSimpleTreeView<TSchema>(
+				checkout,
+				config as TreeViewConfiguration as TreeViewConfiguration<ReadSchema<TSchema>>,
+				createNodeIdentifierManager(idCompressor),
+			);
+			return out as unknown as TreeView<TRoot>;
+		},
+
+		exportVerbose(): VerboseTree | undefined {
+			return checkout.exportVerbose();
+		},
+
+		exportSimpleSchema(): SimpleTreeSchema {
+			return exportSimpleSchema(checkout.storedSchema);
+		},
+	};
 }
 
 /**

package/src/shared-tree/index.ts

@@ -39,6 +39,8 @@ export {
 
 export { SchematizingSimpleTreeView } from "./schematizingTreeView.js";
 
+export { initialize, initializerFromChunk } from "./schematizeTree.js";
+
 export type {
 	ISharedTreeEditor,
 	ISchemaEditor,
@@ -58,6 +60,8 @@ export {
 	independentInitializedView,
 	type ViewContent,
 	independentView,
+	createIndependentTreeBeta,
+	createIndependentTreeAlpha,
 } from "./independentView.js";
 
 export type { SharedTreeChange } from "./sharedTreeChangeTypes.js";