@fluidframework/tree 2.40.0-336023 → 2.40.0

package/src/core/schema-stored/storedSchemaRepository.ts

@@ -9,7 +9,7 @@ import type { Listenable } from "@fluidframework/core-interfaces/internal";
 import { createEmitter } from "@fluid-internal/client-utils";
 import { compareStrings } from "../../util/index.js";
 
-import type { TreeNodeSchemaIdentifier } from "./format.js";
+import type { TreeNodeSchemaIdentifier } from "./formatV1.js";
 import {
 	type StoredSchemaCollection,
 	type TreeFieldStoredSchema,

package/src/core/schema-view/index.ts

@@ -7,5 +7,4 @@ export {
 	type Adapters,
 	type TreeAdapter,
 	AdaptedViewSchema,
-	AllowedUpdateType,
 } from "./view.js";

package/src/core/schema-view/view.ts

@@ -9,37 +9,6 @@ import type { TreeNodeSchemaIdentifier, TreeStoredSchema } from "../schema-store
  * APIs for applying `view schema` to documents.
  */
 
-/**
- * What kinds of updates to stored schema to permit.
- *
- * Bit flags enum.
- */
-export enum AllowedUpdateType {
-	/**
-	 * Do not update the stored schema to match view schema.
-	 */
-	None = 0,
-	/**
-	 * Update the stored schema as part of initializing an empty document.
-	 *
-	 * Includes "Initialize".
-	 */
-	// eslint-disable-next-line no-bitwise
-	Initialize = 1 << 0,
-	/**
-	 * Update the stored schema to match the view schema if the current document contents are compatible with the view schema.
-	 * TODO: support this option.
-	 */
-	// DataCompatible,
-	/**
-	 * Update the stored schema to match view schema if all possible documents based on the current stored schema would be compatible with the view schema.
-	 *
-	 * Includes "Initialize".
-	 */
-	// eslint-disable-next-line no-bitwise
-	SchemaCompatible = 1 << 1,
-}
-
 /**
  */
 export interface TreeAdapter {

package/src/core/tree/persistedTreeTextFormat.ts

@@ -5,7 +5,7 @@
 
 import { type Static, type TSchema, Type } from "@sinclair/typebox";
 
-import { schemaFormat } from "../schema-stored/index.js";
+import { schemaFormatV1 } from "../schema-stored/index.js";
 
 /**
  * This module contains persisted types for a simple, human-readable tree format.
@@ -58,7 +58,7 @@ const EncodedFieldMapObject = <Schema extends TSchema>(tChild: Schema) =>
 type EncodedNodeData = Static<typeof EncodedNodeData>;
 const EncodedNodeData = Type.Object({
 	value: Type.Optional(Type.Any()),
-	type: Type.Readonly(schemaFormat.TreeNodeSchemaIdentifierSchema),
+	type: Type.Readonly(schemaFormatV1.TreeNodeSchemaIdentifierSchema),
 });
 
 /**

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

@@ -6,14 +6,14 @@
 import { type Static, Type } from "@sinclair/typebox";
 
 import { Versioned } from "../../codec/index.js";
-import { schemaFormat } from "../../core/index.js";
+import { schemaFormatV1 } from "../../core/index.js";
 
 export const version = 1.0;
 
 export const Format = Type.Object(
 	{
 		version: Type.Literal(version),
-		keys: Type.Array(schemaFormat.FieldKeySchema),
+		keys: Type.Array(schemaFormatV1.FieldKeySchema),
 		fields: Versioned,
 	},
 	{ additionalProperties: false },

package/src/feature-libraries/index.ts

@@ -17,7 +17,13 @@ export {
 	mapTreeFieldFromCursor,
 } from "./mapTreeCursor.js";
 export { buildForest } from "./object-forest/index.js";
-export { SchemaSummarizer, encodeTreeSchema, makeSchemaCodec } from "./schema-index/index.js";
+export {
+	SchemaSummarizer,
+	encodeTreeSchema,
+	makeSchemaCodec,
+	makeSchemaCodecs,
+	SchemaCodecVersion,
+} from "./schema-index/index.js";
 export {
 	stackTreeNodeCursor,
 	type CursorAdapter,

package/src/feature-libraries/mapTreeCursor.ts

@@ -26,17 +26,17 @@ import {
 } from "./treeCursorUtils.js";
 
 /**
- * @returns An {@link ITreeCursorSynchronous} in nodes mode for a single {@link MapTree}.
+ * Returns an {@link ITreeCursorSynchronous} in nodes mode for a single {@link MapTree}.
  */
 export function cursorForMapTreeNode(root: MapTree): CursorWithNode<MapTree> {
 	return stackTreeNodeCursor(adapter, root);
 }
 
 /**
- * @returns an {@link ITreeCursorSynchronous} in fields mode for a MapTree field.
+ * Returns an {@link ITreeCursorSynchronous} in fields mode for a MapTree field.
  */
 export function cursorForMapTreeField(
-	root: MapTree[],
+	root: readonly MapTree[],
 	detachedField: DetachedField = rootField,
 ): CursorWithNode<MapTree> {
 	const key = detachedFieldAsKey(detachedField);

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

@@ -5,7 +5,7 @@
 
 import { type ObjectOptions, type Static, Type } from "@sinclair/typebox";
 
-import { type ChangesetLocalId, RevisionTagSchema, schemaFormat } from "../../core/index.js";
+import { type ChangesetLocalId, RevisionTagSchema, schemaFormatV1 } from "../../core/index.js";
 import {
 	type JsonCompatibleReadOnly,
 	JsonCompatibleReadOnlySchema,
@@ -27,8 +27,8 @@ export type EncodedChangeAtomId = Static<typeof EncodedChangeAtomId>;
 
 const EncodedFieldChange = Type.Object(
 	{
-		fieldKey: schemaFormat.FieldKeySchema,
-		fieldKind: schemaFormat.FieldKindIdentifierSchema,
+		fieldKey: schemaFormatV1.FieldKeySchema,
+		fieldKind: schemaFormatV1.FieldKindIdentifierSchema,
 		// Implementation note: node and field change encoding is mutually recursive.
 		// This field marks a boundary in that recursion to avoid constructing excessively complex
 		// recursive types. Encoded changes are validated at this boundary at runtime--see modularChangeCodecs.ts.

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

@@ -10,21 +10,50 @@ import {
 	type ICodecOptions,
 	type IJsonCodec,
 	makeCodecFamily,
+	makeVersionDispatchingCodec,
 	withSchemaValidation,
 } from "../../codec/index.js";
-import { makeSchemaCodec } from "../schema-index/index.js";
+import {
+	makeSchemaCodec,
+	SchemaCodecVersion,
+	type Format as FormatV1,
+} from "../schema-index/index.js";
 
 import { EncodedSchemaChange } from "./schemaChangeFormat.js";
 import type { SchemaChange } from "./schemaChangeTypes.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> {
-	return makeCodecFamily([[1, makeSchemaChangeCodec(options)]]);
+	return makeCodecFamily([[SchemaCodecVersion.v1, makeSchemaChangeCodecV1(options)]]);
+}
+
+/**
+ * Create a schema change codec.
+ * @param options - Specifies common codec options, including which `validator` to use.
+ * @param writeVersion - The schema change write version.
+ * @returns The composed codec.
+ */
+export function makeSchemaChangeCodec(
+	options: ICodecOptions,
+	writeVersion: SchemaCodecVersion,
+): IJsonCodec<SchemaChange> {
+	const family = makeSchemaChangeCodecs(options);
+	return makeVersionDispatchingCodec(family, { ...options, writeVersion });
 }
 
-function makeSchemaChangeCodec({
-	jsonValidator: validator,
-}: ICodecOptions): IJsonCodec<SchemaChange, EncodedSchemaChange> {
-	const schemaCodec = makeSchemaCodec({ jsonValidator: validator });
+/**
+ * Compose the v1 schema change codec.
+ * @param options - The codec options.
+ * @returns The composed schema change codec.
+ */
+function makeSchemaChangeCodecV1(
+	options: ICodecOptions,
+): IJsonCodec<SchemaChange, EncodedSchemaChange> {
+	const schemaCodec = makeSchemaCodec(options, SchemaCodecVersion.v1);
 	const schemaChangeCodec: IJsonCodec<SchemaChange, EncodedSchemaChange> = {
 		encode: (schemaChange) => {
 			assert(
@@ -32,8 +61,8 @@ function makeSchemaChangeCodec({
 				0x933 /* Inverse schema changes should never be transmitted */,
 			);
 			return {
-				new: schemaCodec.encode(schemaChange.schema.new),
-				old: schemaCodec.encode(schemaChange.schema.old),
+				new: schemaCodec.encode(schemaChange.schema.new) as FormatV1,
+				old: schemaCodec.encode(schemaChange.schema.old) as FormatV1,
 			};
 		},
 		decode: (encoded) => {
@@ -48,5 +77,5 @@ function makeSchemaChangeCodec({
 		encodedSchema: EncodedSchemaChange,
 	};
 
-	return withSchemaValidation(EncodedSchemaChange, schemaChangeCodec, validator);
+	return withSchemaValidation(EncodedSchemaChange, schemaChangeCodec, options.jsonValidator);
 }

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

@@ -4,12 +4,11 @@
  */
 
 import { type Static, Type } from "@sinclair/typebox";
-
-import { Format } from "../schema-index/index.js";
+import { Format as FormatV1 } from "../schema-index/index.js";
 
 export const EncodedSchemaChange = Type.Object({
-	new: Format,
-	old: Format,
+	new: FormatV1,
+	old: FormatV1,
 });
 
 export type EncodedSchemaChange = Static<typeof EncodedSchemaChange>;

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

@@ -3,10 +3,14 @@
  * Licensed under the MIT License.
  */
 
-import { fail } from "@fluidframework/core-utils/internal";
+import { fail, unreachableCase } from "@fluidframework/core-utils/internal";
 import {
+	type FluidClientVersion,
+	type ICodecFamily,
 	type ICodecOptions,
 	type IJsonCodec,
+	makeCodecFamily,
+	makeVersionDispatchingCodec,
 	makeVersionedValidatedCodec,
 } from "../../codec/index.js";
 import {
@@ -15,15 +19,77 @@ import {
 	type TreeStoredSchema,
 	decodeFieldSchema,
 	encodeFieldSchema,
-	schemaFormat,
+	schemaFormatV1,
 	storedSchemaDecodeDispatcher,
 } from "../../core/index.js";
-import { brand } from "../../util/index.js";
+import { brand, type JsonCompatible } from "../../util/index.js";
 
-import { Format } from "./format.js";
+import { Format as FormatV1 } from "./formatV1.js";
 
-export function encodeRepo(repo: TreeStoredSchema): Format {
-	const nodeSchema: Record<string, schemaFormat.TreeNodeSchemaDataFormat> =
+/**
+ * Versions for the codec that encodes an in-memory representation of a stored schema {@link TreeStoredSchema} into a persisted format (or decodes it in the opposite direction).
+ */
+export enum SchemaCodecVersion {
+	v1 = 1,
+}
+
+/**
+ * Convert a FluidClientVersion to a SchemaCodecVersion.
+ * @param clientVersion - The FluidClientVersion to convert.
+ * @returns The SchemaCodecVersion that corresponds to the provided FluidClientVersion.
+ */
+export function clientVersionToSchemaVersion(
+	clientVersion: FluidClientVersion,
+): SchemaCodecVersion {
+	// Only one version of the schema codec is currently supported.
+	return SchemaCodecVersion.v1;
+}
+
+/**
+ * Create a schema codec.
+ * @param options - Specifies common codec options, including which `validator` to use.
+ * @param writeVersion - The schema write version.
+ * @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: SchemaCodecVersion,
+): IJsonCodec<TreeStoredSchema> {
+	const family = makeSchemaCodecs(options);
+	return makeVersionDispatchingCodec(family, { ...options, writeVersion });
+}
+
+/**
+ * Create a family of schema codecs.
+ * @param options - Specifies common codec options, including which `validator` to use.
+ * @returns The composed codec family.
+ */
+export function makeSchemaCodecs(options: ICodecOptions): ICodecFamily<TreeStoredSchema> {
+	return makeCodecFamily([[SchemaCodecVersion.v1, makeSchemaCodecV1(options)]]);
+}
+
+/**
+ * Encode an in-memory TreeStoredSchema into the specified format version.
+ * @param repo - The in-memory schema.
+ * @param version - The schema write version.
+ * @returns The encoded schema.
+ */
+export function encodeRepo(
+	repo: TreeStoredSchema,
+	version: SchemaCodecVersion,
+): JsonCompatible {
+	switch (version) {
+		case SchemaCodecVersion.v1:
+			return encodeRepoV1(repo);
+		default:
+			unreachableCase(version);
+	}
+}
+
+function encodeRepoV1(repo: TreeStoredSchema): FormatV1 {
+	const nodeSchema: Record<string, schemaFormatV1.TreeNodeSchemaDataFormat> =
 		Object.create(null);
 	const rootFieldSchema = encodeFieldSchema(repo.rootFieldSchema);
 	for (const name of [...repo.nodeSchema.keys()].sort()) {
@@ -36,13 +102,13 @@ export function encodeRepo(repo: TreeStoredSchema): Format {
 		});
 	}
 	return {
-		version: schemaFormat.version,
+		version: schemaFormatV1.version,
 		nodes: nodeSchema,
 		root: rootFieldSchema,
 	};
 }
 
-function decode(f: Format): TreeStoredSchema {
+function decode(f: FormatV1): TreeStoredSchema {
 	const nodeSchema: Map<TreeNodeSchemaIdentifier, TreeNodeStoredSchema> = new Map();
 	for (const [key, schema] of Object.entries(f.nodes)) {
 		nodeSchema.set(brand(key), storedSchemaDecodeDispatcher.dispatch(schema));
@@ -55,10 +121,12 @@ function decode(f: Format): TreeStoredSchema {
 
 /**
  * Creates a codec which performs synchronous monolithic encoding of schema content.
+ * @param options - Specifies common codec options, including which `validator` to use.
+ * @returns The codec.
  */
-export function makeSchemaCodec(options: ICodecOptions): IJsonCodec<TreeStoredSchema, Format> {
-	return makeVersionedValidatedCodec(options, new Set([schemaFormat.version]), Format, {
-		encode: (data: TreeStoredSchema) => encodeRepo(data),
-		decode: (data: Format) => decode(data),
+function makeSchemaCodecV1(options: ICodecOptions): IJsonCodec<TreeStoredSchema, FormatV1> {
+	return makeVersionedValidatedCodec(options, new Set([schemaFormatV1.version]), FormatV1, {
+		encode: (data: TreeStoredSchema) => encodeRepoV1(data),
+		decode: (data: FormatV1) => decode(data),
 	});
 }

package/src/feature-libraries/schema-index/{format.ts → formatV1.ts}

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

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

@@ -4,5 +4,10 @@
  */
 
 export { SchemaSummarizer, encodeTreeSchema } from "./schemaSummarizer.js";
-export { makeSchemaCodec } from "./codec.js";
-export { Format } from "./format.js";
+export {
+	makeSchemaCodec,
+	makeSchemaCodecs,
+	SchemaCodecVersion,
+	clientVersionToSchemaVersion,
+} from "./codec.js";
+export { Format } from "./formatV1.js";

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

@@ -14,7 +14,7 @@ import type {
 } from "@fluidframework/runtime-definitions/internal";
 import { SummaryTreeBuilder } from "@fluidframework/runtime-utils/internal";
 
-import type { ICodecOptions, IJsonCodec } from "../../codec/index.js";
+import type { IJsonCodec } from "../../codec/index.js";
 import {
 	type MutableTreeStoredSchema,
 	type TreeStoredSchema,
@@ -27,8 +27,8 @@ import type {
 } from "../../shared-tree-core/index.js";
 import type { CollabWindow } from "../incrementalSummarizationUtils.js";
 
-import { encodeRepo, makeSchemaCodec } from "./codec.js";
-import type { Format } from "./format.js";
+import { encodeRepo } from "./codec.js";
+import type { JsonCompatible } from "../../util/index.js";
 
 const schemaStringKey = "SchemaString";
 /**
@@ -37,16 +37,13 @@ const schemaStringKey = "SchemaString";
 export class SchemaSummarizer implements Summarizable {
 	public readonly key = "Schema";
 
-	private readonly codec: IJsonCodec<TreeStoredSchema, Format>;
-
 	private schemaIndexLastChangedSeq: number | undefined;
 
 	public constructor(
 		private readonly schema: MutableTreeStoredSchema,
-		options: ICodecOptions,
 		collabWindow: CollabWindow,
+		private readonly codec: IJsonCodec<TreeStoredSchema>,
 	) {
-		this.codec = makeSchemaCodec(options);
 		this.schema.events.on("afterSchemaChange", () => {
 			// Invalidate the cache, as we need to regenerate the blob if the schema changes
 			// We are assuming that schema changes from remote ops are valid, as we are in a summarization context.
@@ -116,6 +113,9 @@ export class SchemaSummarizer implements Summarizable {
  * @remarks
  * This can be used to help inspect schema for debugging, and to save a snapshot of schema to help detect and review changes to an applications schema.
  */
-export function encodeTreeSchema(schema: TreeStoredSchema): Format {
-	return encodeRepo(schema);
+export function encodeTreeSchema(
+	schema: TreeStoredSchema,
+	writeVersion: number,
+): JsonCompatible {
+	return encodeRepo(schema, writeVersion);
 }

package/src/index.ts

@@ -254,6 +254,7 @@ export {
 	configuredSharedTree,
 } from "./treeFactory.js";
 export { SharedTreeAttributes, SharedTreeFactoryType } from "./sharedTreeAttributes.js";
+export { persistedToSimpleSchema } from "./shared-tree/index.js";
 
 export {
 	type ICodecOptions,

package/src/packageVersion.ts

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

package/src/shared-tree/independentView.ts

@@ -23,9 +23,10 @@ import {
 	defaultSchemaPolicy,
 	TreeCompressionStrategy,
 	initializeForest,
+	SchemaCodecVersion,
 } from "../feature-libraries/index.js";
 // eslint-disable-next-line import/no-internal-modules
-import type { Format } from "../feature-libraries/schema-index/format.js";
+import type { Format } from "../feature-libraries/schema-index/formatV1.js";
 import type {
 	TreeViewConfiguration,
 	ImplicitFieldSchema,
@@ -92,7 +93,7 @@ export function independentInitializedView<const TSchema extends ImplicitFieldSc
 	const revisionTagCodec = new RevisionTagCodec(idCompressor);
 
 	const fieldBatchCodec = makeFieldBatchCodec(options, 1);
-	const schemaCodec = makeSchemaCodec(options);
+	const schemaCodec = makeSchemaCodec(options, SchemaCodecVersion.v1);
 
 	const schema = new TreeStoredSchemaRepository(schemaCodec.decode(content.schema as Format));
 	const forest = buildConfiguredForest(

package/src/shared-tree/index.ts

@@ -21,6 +21,8 @@ export {
 	ForestTypeExpensiveDebug,
 	ForestTypeReference,
 	exportSimpleSchema,
+	type SharedTreeKernelView,
+	persistedToSimpleSchema,
 } from "./sharedTree.js";
 
 export {

package/src/shared-tree/schematizeTree.ts

@@ -6,7 +6,6 @@
 import { assert, unreachableCase, fail } from "@fluidframework/core-utils/internal";
 
 import {
-	AllowedUpdateType,
 	CursorLocationType,
 	type ITreeCursorSynchronous,
 	type TreeStoredSchema,
@@ -21,7 +20,6 @@ import {
 	mapTreeFromCursor,
 } from "../feature-libraries/index.js";
 import { isReadonlyArray } from "../util/index.js";
-
 import type { ITreeCheckout } from "./treeCheckout.js";
 import type { SchemaCompatibilityTester } from "../simple-tree/index.js";
 
@@ -98,10 +96,6 @@ export enum UpdateType {
 	 * Already compatible, no update needed.
 	 */
 	None,
-	/**
-	 * Empty: needs initializing.
-	 */
-	Initialize,
 	/**
 	 * Schema can be upgraded leaving tree as is.
 	 */
@@ -112,9 +106,11 @@ export enum UpdateType {
 	Incompatible,
 }
 
+/**
+ * Returns how compatible updating checkout's schema is with the viewSchema.
+ */
 export function evaluateUpdate(
 	viewSchema: SchemaCompatibilityTester,
-	allowedSchemaModifications: AllowedUpdateType,
 	checkout: ITreeCheckout,
 ): UpdateType {
 	const compatibility = viewSchema.checkCompatibility(checkout.storedSchema);
@@ -124,11 +120,6 @@ export function evaluateUpdate(
 		return UpdateType.None;
 	}
 
-	// eslint-disable-next-line no-bitwise
-	if (allowedSchemaModifications & AllowedUpdateType.Initialize && canInitialize(checkout)) {
-		return UpdateType.Initialize;
-	}
-
 	if (!compatibility.canUpgrade) {
 		// Existing stored schema permits trees which are incompatible with the view schema, so schema can not be updated
 		return UpdateType.Incompatible;
@@ -137,10 +128,7 @@ export function evaluateUpdate(
 	assert(!compatibility.canView, 0x8bd /* unexpected case */);
 	assert(compatibility.canUpgrade, 0x8be /* unexpected case */);
 
-	// eslint-disable-next-line no-bitwise
-	return allowedSchemaModifications & AllowedUpdateType.SchemaCompatible
-		? UpdateType.SchemaCompatible
-		: UpdateType.Incompatible;
+	return UpdateType.SchemaCompatible;
 }
 
 export function canInitialize(checkout: ITreeCheckout): boolean {
@@ -222,17 +210,9 @@ export function initialize(checkout: ITreeCheckout, treeContent: TreeStoredConte
  */
 export function ensureSchema(
 	viewSchema: SchemaCompatibilityTester,
-	allowedSchemaModifications: AllowedUpdateType,
 	checkout: ITreeCheckout,
-	treeContent: TreeStoredContent | undefined,
 ): boolean {
-	let possibleModifications = allowedSchemaModifications;
-	if (treeContent === undefined) {
-		// Clear bit for Initialize if initial tree is not provided.
-		// eslint-disable-next-line no-bitwise
-		possibleModifications &= ~AllowedUpdateType.Initialize;
-	}
-	const updatedNeeded = evaluateUpdate(viewSchema, possibleModifications, checkout);
+	const updatedNeeded = evaluateUpdate(viewSchema, checkout);
 	switch (updatedNeeded) {
 		case UpdateType.None: {
 			return true;
@@ -244,16 +224,6 @@ export function ensureSchema(
 			checkout.updateSchema(viewSchema.viewSchemaAsStored);
 			return true;
 		}
-		case UpdateType.Initialize: {
-			if (treeContent === undefined) {
-				return false;
-			}
-			// TODO:
-			// When this becomes a more proper out of schema adapter, editing should be made lazy.
-			// This will improve support for readonly documents, cross version collaboration and attribution.
-			initialize(checkout, treeContent);
-			return true;
-		}
 		default: {
 			unreachableCase(updatedNeeded);
 		}

package/src/shared-tree/schematizingTreeView.ts

@@ -12,7 +12,7 @@ import { createEmitter } from "@fluid-internal/client-utils";
 import { assert, unreachableCase } from "@fluidframework/core-utils/internal";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 
-import { AllowedUpdateType, anchorSlot, type SchemaPolicy } from "../core/index.js";
+import { anchorSlot, type SchemaPolicy } from "../core/index.js";
 import {
 	type NodeIdentifierManager,
 	defaultSchemaPolicy,
@@ -207,15 +207,7 @@ export class SchematizingSimpleTreeView<
 		}
 
 		this.runSchemaEdit(() => {
-			const result = ensureSchema(
-				this.viewSchema,
-				AllowedUpdateType.SchemaCompatible,
-				this.checkout,
-				{
-					schema: this.viewSchema.viewSchemaAsStored,
-					initialTree: undefined,
-				},
-			);
+			const result = ensureSchema(this.viewSchema, this.checkout);
 			assert(result, 0x8bf /* Schema upgrade should always work if canUpgrade is set. */);
 		});
 	}