@fluidframework/tree 2.71.0 → 2.72.0

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

@@ -0,0 +1,360 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { objectToMap, type JsonCompatibleReadOnly } from "../../util/index.js";
+import { unreachableCase, transformMapValues } from "@fluidframework/core-utils/internal";
+import type {
+	SimpleAllowedTypeAttributes,
+	SimpleArrayNodeSchema,
+	SimpleFieldSchema,
+	SimpleLeafNodeSchema,
+	SimpleMapNodeSchema,
+	SimpleNodeSchema,
+	SimpleObjectFieldSchema,
+	SimpleObjectNodeSchema,
+	SimpleRecordNodeSchema,
+	SimpleTreeSchema,
+} from "../simpleSchema.js";
+import { NodeKind } from "../core/index.js";
+import type { FieldKind } from "../fieldSchema.js";
+import type { ValueSchema } from "../../core/index.js";
+import { UsageError } from "@fluidframework/telemetry-utils/internal";
+import * as Format from "../simpleSchemaFormatV1.js";
+import {
+	DiscriminatedUnionDispatcher,
+	extractJsonValidator,
+	FormatValidatorNoOp,
+	type FormatValidator,
+} from "../../codec/index.js";
+
+/**
+ * Encodes a simple schema (view or stored) into a serializable format.
+ * @remarks The JSON-compatible schema returned from this method is only intended for use in snapshots/comparisons of schemas.
+ * It is not possible to reconstruct a full schema (including metadata and persistedMetadata) from the encoded format.
+ * @param treeSchema - The tree schema to convert.
+ * @returns A serializable representation of the schema.
+ *
+ * @alpha
+ */
+export function encodeSimpleSchema(simpleSchema: SimpleTreeSchema): JsonCompatibleReadOnly {
+	// Convert types to serializable forms
+	const encodedDefinitions: Format.SimpleSchemaDefinitionsFormat = {};
+
+	for (const [identifier, schema] of simpleSchema.definitions) {
+		const encodedDefinition = encodeNodeSchema(schema);
+		encodedDefinitions[identifier] = encodedDefinition;
+	}
+
+	const encodedSchema: Format.SimpleTreeSchemaFormat = {
+		version: Format.SimpleSchemaFormatVersion.v1,
+		root: encodeField(simpleSchema.root),
+		definitions: encodedDefinitions,
+	};
+
+	return encodedSchema;
+}
+
+/**
+ * Decodes a JSON-compatible schema into a simple schema.
+ * @param encodedSchema - The encoded schema to decode.
+ * @param validator - The format validator to use to validate the encoded schema.
+ * @returns A decoded simple schema.
+ * @throws Will throw a usage error if the encoded schema is not in the expected format.
+ *
+ * @alpha
+ */
+export function decodeSimpleSchema(
+	encodedSchema: JsonCompatibleReadOnly,
+	validator?: FormatValidator,
+): SimpleTreeSchema {
+	const effectiveValidator = validator ?? FormatValidatorNoOp;
+	const compiledValidator = extractJsonValidator(effectiveValidator).compile(
+		Format.SimpleTreeSchemaFormat,
+	);
+	if (!compiledValidator.check(encodedSchema)) {
+		throw new UsageError(
+			"The provided simple schema is not valid according to the schema format.",
+		);
+	}
+
+	return {
+		root: decodeSimpleFieldSchema(encodedSchema.root),
+		definitions: new Map(
+			transformMapValues(objectToMap(encodedSchema.definitions), (value, key) => {
+				return decodeNodeSchema(value);
+			}),
+		),
+	};
+}
+
+/**
+ * Encodes a node schema to a serializable object.
+ * @param schema - The node schema to convert.
+ * @returns A serializable representation of the node schema.
+ */
+function encodeNodeSchema(schema: SimpleNodeSchema): Format.SimpleNodeSchemaUnionFormat {
+	const kind = schema.kind;
+	switch (kind) {
+		case NodeKind.Leaf:
+			return { leaf: encodeLeafNode(schema) };
+		case NodeKind.Array:
+			return { array: encodeContainerNode(schema) };
+		case NodeKind.Map:
+			return { map: encodeContainerNode(schema) };
+		case NodeKind.Record:
+			return { record: encodeContainerNode(schema) };
+		case NodeKind.Object:
+			return { object: encodeObjectNode(schema) };
+		default: {
+			unreachableCase(kind);
+		}
+	}
+}
+
+/**
+ * Encodes a leaf node schema to a serializable object.
+ * @param schema - The leaf node schema to convert.
+ * @returns A serializable representation of the leaf node schema.
+ */
+function encodeLeafNode(schema: SimpleLeafNodeSchema): Format.SimpleLeafNodeSchemaFormat {
+	return {
+		kind: schema.kind,
+		leafKind: schema.leafKind,
+	};
+}
+
+/**
+ * Encodes a container node schema (a simple schema that is a Map, Array, or Record) to a serializable object.
+ * @param schema - The container node schema to convert.
+ * @returns A serializable representation of the container node schema. Includes the `kind` for disambiguation between different
+ * container kinds.
+ */
+function encodeContainerNode(
+	schema: SimpleArrayNodeSchema | SimpleMapNodeSchema | SimpleRecordNodeSchema,
+):
+	| Format.SimpleArrayNodeSchemaFormat
+	| Format.SimpleMapNodeSchemaFormat
+	| Format.SimpleRecordNodeSchemaFormat {
+	return {
+		kind: schema.kind,
+		simpleAllowedTypes: encodeSimpleAllowedTypes(schema.simpleAllowedTypes),
+	};
+}
+
+/**
+ * Encodes a simple allowed types map to a serializable object. Needed because JSON serialization does not support Maps.
+ * @param simpleAllowedTypes - The simple allowed types map to convert.
+ * @returns A serializable representation of the simple allowed types.
+ */
+function encodeSimpleAllowedTypes(
+	simpleAllowedTypes: ReadonlyMap<string, SimpleAllowedTypeAttributes>,
+): Format.SimpleAllowedTypesFormat {
+	const encodedAllowedTypes: Format.SimpleAllowedTypesFormat = {};
+	for (const [identifier, attributes] of simpleAllowedTypes) {
+		encodedAllowedTypes[identifier] = {
+			isStaged: attributes.isStaged,
+		};
+	}
+	return encodedAllowedTypes;
+}
+
+/**
+ * Encodes an object node schema to a serializable object.
+ * @param schema - The object node schema to convert.
+ * @returns A serializable representation of the object node schema.
+ */
+function encodeObjectNode(
+	schema: SimpleObjectNodeSchema,
+): Format.SimpleObjectNodeSchemaFormat {
+	const encodedFields: Format.SimpleObjectFieldSchemasFormat = {};
+	for (const [fieldKey, fieldSchema] of schema.fields) {
+		encodedFields[fieldKey] = encodeObjectField(fieldSchema);
+	}
+
+	return {
+		kind: schema.kind,
+		fields: encodedFields,
+		allowUnknownOptionalFields: schema.allowUnknownOptionalFields,
+	};
+}
+
+/**
+ * Encodes an object field schema to a serializable object.
+ * @param fieldSchema - The object field schema to convert.
+ * @returns A serializable representation of the object field schema.
+ */
+function encodeObjectField(
+	fieldSchema: SimpleObjectFieldSchema,
+): Format.SimpleObjectFieldSchemaFormat {
+	const encodedField = encodeField(fieldSchema);
+	return { ...encodedField, storedKey: fieldSchema.storedKey };
+}
+
+/**
+ * Encodes a field schema to a serializable object.
+ * @param fieldSchema - The field schema to convert.
+ * @returns A serializable representation of the field schema.
+ */
+function encodeField(fieldSchema: SimpleFieldSchema): Format.SimpleFieldSchemaFormat {
+	return {
+		kind: fieldSchema.kind,
+		simpleAllowedTypes: encodeSimpleAllowedTypes(fieldSchema.simpleAllowedTypes),
+	};
+}
+
+const decodeNodeSchemaDispatcher: DiscriminatedUnionDispatcher<
+	Format.SimpleNodeSchemaUnionFormat,
+	[],
+	| SimpleLeafNodeSchema
+	| SimpleArrayNodeSchema
+	| SimpleMapNodeSchema
+	| SimpleRecordNodeSchema
+	| SimpleObjectNodeSchema
+> = new DiscriminatedUnionDispatcher({
+	leaf: decodeLeafNode,
+	array: decodeContainerNode,
+	map: decodeContainerNode,
+	record: decodeContainerNode,
+	object: decodeObjectNode,
+});
+
+/**
+ * Decodes a node schema from a JSON-compatible object.
+ * @param encodedNodeSchema - The encoded node schema to decode.
+ * @returns The decoded node schema.
+ */
+function decodeNodeSchema(
+	encodedNodeSchema: Format.SimpleNodeSchemaUnionFormat,
+):
+	| SimpleLeafNodeSchema
+	| SimpleArrayNodeSchema
+	| SimpleMapNodeSchema
+	| SimpleRecordNodeSchema
+	| SimpleObjectNodeSchema {
+	return decodeNodeSchemaDispatcher.dispatch(encodedNodeSchema);
+}
+
+/**
+ * Decodes a container node schema (array, map, record) from a JSON-compatible object.
+ * @param encodedContainerSchema - The encoded schema to decode.
+ * @returns The decoded container node schema.
+ */
+function decodeContainerNode(
+	encodedContainerSchema:
+		| Format.SimpleArrayNodeSchemaFormat
+		| Format.SimpleMapNodeSchemaFormat
+		| Format.SimpleRecordNodeSchemaFormat,
+): SimpleArrayNodeSchema | SimpleMapNodeSchema | SimpleRecordNodeSchema {
+	return {
+		kind: encodedContainerSchema.kind as NodeKind.Array | NodeKind.Map | NodeKind.Record,
+		simpleAllowedTypes: decodeSimpleAllowedTypes(encodedContainerSchema.simpleAllowedTypes),
+		// We cannot encode persistedMetadata or metadata, so we explicitly set them to empty values.
+		persistedMetadata: undefined,
+		metadata: {},
+	};
+}
+
+/**
+ * Decodes a leaf node schema from a JSON-compatible object.
+ * @param encodedLeafSchema - The encoded leaf node schema.
+ * @returns The decoded leaf node schema.
+ */
+function decodeLeafNode(
+	encodedLeafSchema: Format.SimpleLeafNodeSchemaFormat,
+): SimpleLeafNodeSchema {
+	return {
+		kind: NodeKind.Leaf,
+		leafKind: encodedLeafSchema.leafKind as ValueSchema,
+		// We cannot encode persistedMetadata or metadata, so we explicitly set them to empty values.
+		persistedMetadata: undefined,
+		metadata: {},
+	};
+}
+
+/**
+ * Decodes a object node schema from a JSON-compatible object.
+ * @param encodedObjectSchema - The encoded object node schema.
+ * @returns The decoded object node schema.
+ */
+function decodeObjectNode(
+	encodedObjectSchema: Format.SimpleObjectNodeSchemaFormat,
+): SimpleObjectNodeSchema {
+	return {
+		kind: NodeKind.Object,
+		fields: decodeObjectFields(encodedObjectSchema.fields),
+		// It is possible for allowUnknownOptionalFields to be undefined. This happens when serializing a Simple Schema derived
+		// from a stored schema.
+		allowUnknownOptionalFields: encodedObjectSchema.allowUnknownOptionalFields,
+		// We cannot encode persistedMetadata or metadata, so we explicitly set them to empty values when decoding.
+		persistedMetadata: undefined,
+		metadata: {},
+	};
+}
+
+/**
+ * Decodes a map of object fields from a JSON-compatible object.
+ * @param encodedFields - The encoded fields.
+ * @returns A map of the decoded object fields.
+ */
+function decodeObjectFields(
+	encodedFields: Format.SimpleObjectFieldSchemasFormat,
+): ReadonlyMap<string, SimpleObjectFieldSchema> {
+	const fields = new Map<string, SimpleObjectFieldSchema>();
+	for (const [fieldKey, fieldSchema] of Object.entries(encodedFields)) {
+		fields.set(fieldKey, decodeObjectField(fieldSchema));
+	}
+	return fields;
+}
+
+/**
+ * Decodes a {@link SimpleObjectFieldSchema} from a JSON-compatible object.
+ * @param encodedField - The encoded field schema.
+ * @returns The decoded simple object field schema.
+ */
+function decodeObjectField(
+	encodedField: Format.SimpleObjectFieldSchemaFormat,
+): SimpleObjectFieldSchema {
+	const baseField = decodeSimpleFieldSchema(encodedField);
+	return {
+		...baseField,
+		storedKey: encodedField.storedKey,
+	};
+}
+
+/**
+ * Decodes a {@link SimpleFieldSchema} from a JSON-compatible object.
+ * @param encodedField - The encoded field schema.
+ * @returns The decoded simple field schema.
+ */
+function decodeSimpleFieldSchema(
+	encodedField: Format.SimpleFieldSchemaFormat,
+): SimpleFieldSchema {
+	return {
+		kind: encodedField.kind as FieldKind,
+		simpleAllowedTypes: decodeSimpleAllowedTypes(encodedField.simpleAllowedTypes),
+		// We cannot encode persistedMetadata or metadata, so we explicitly set them to empty values when decoding.
+		persistedMetadata: undefined,
+		metadata: {},
+	};
+}
+
+/**
+ * Decodes a simple allowed types map from a JSON-compatible object.
+ * @param encodedAllowedTypes - The encoded simple allowed types.
+ * @returns A map of the decoded simple allowed types.
+ */
+function decodeSimpleAllowedTypes(
+	encodedAllowedTypes: Format.SimpleAllowedTypesFormat,
+): ReadonlyMap<string, SimpleAllowedTypeAttributes> {
+	const untypedMap = objectToMap(encodedAllowedTypes);
+
+	const simpleAllowedTypes = transformMapValues(untypedMap, (value) => {
+		return {
+			isStaged: value.isStaged,
+		} satisfies SimpleAllowedTypeAttributes;
+	});
+
+	return simpleAllowedTypes;
+}

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

@@ -4,15 +4,15 @@
  */
 
 import type { MinimumVersionForCollab } from "@fluidframework/runtime-definitions/internal";
-import type { ICodecOptions } from "../../codec/index.js";
-import { SchemaVersion } from "../../core/index.js";
+import { FluidClientVersion, type ICodecOptions } from "../../codec/index.js";
+import { SchemaFormatVersion } from "../../core/index.js";
 import { encodeTreeSchema, makeSchemaCodec } from "../../feature-libraries/index.js";
 import {
 	clientVersionToSchemaVersion,
 	type FormatV1,
-	// eslint-disable-next-line import/no-internal-modules
+	// eslint-disable-next-line import-x/no-internal-modules
 } from "../../feature-libraries/schema-index/index.js";
-import type { JsonCompatible } from "../../util/index.js";
+import { brand, type JsonCompatible } from "../../util/index.js";
 import type { SchemaUpgrade } from "../core/index.js";
 import { normalizeFieldSchema, type ImplicitFieldSchema } from "../fieldSchema.js";
 import { toStoredSchema } from "../toStoredSchema.js";
@@ -100,7 +100,10 @@ export function comparePersistedSchema(
 ): Omit<SchemaCompatibilityStatus, "canInitialize"> {
 	// Any version can be passed down to makeSchemaCodec here.
 	// We only use the decode part, which always dispatches to the correct codec based on the version in the data, not the version passed to `makeSchemaCodec`.
-	const schemaCodec = makeSchemaCodec(options, SchemaVersion.v1);
+	const schemaCodec = makeSchemaCodec(
+		{ ...options, minVersionForCollab: FluidClientVersion.v2_0 },
+		brand(SchemaFormatVersion.v1),
+	);
 	const stored = schemaCodec.decode(persisted as FormatV1);
 	const config = new TreeViewConfigurationAlpha({
 		schema: normalizeFieldSchema(view),

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

@@ -431,7 +431,7 @@ export interface SchemaCompatibilityStatus {
 	 *
 	 * Note that other content in the stored schema that does not impact document compatibility, like {@link NodeSchemaOptionsAlpha.persistedMetadata}, does not affect this field.
 	 *
-	 * For the computation of this equivalence, {@link SchemaStaticsAlpha.staged | staged} schemas are not included.
+	 * For the computation of this equivalence, {@link SchemaStaticsBeta.staged | staged} schemas are not included.
 	 * If there are any unknown optional fields, even if allowed by {@link ObjectSchemaOptions.allowUnknownOptionalFields}, `isEquivalent` will be false.
 	 */
 	readonly isEquivalent: boolean;
@@ -445,7 +445,7 @@ export interface SchemaCompatibilityStatus {
 	 *
 	 * - An object node with {@link ObjectSchemaOptions.allowUnknownOptionalFields} to set to true that has additional optional fields in the stored schema beyond those mentioned in its view schema.
 	 *
-	 * - An additional type allowed at a location in the stored schema where it is {@link SchemaStaticsAlpha.staged | staged} in the view schema.
+	 * - An additional type allowed at a location in the stored schema where it is {@link SchemaStaticsBeta.staged | staged} in the view schema.
 	 *
 	 * In these cases `canUpgrade` and `isEquivalent` will be false.
 	 *

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

@@ -551,7 +551,7 @@ export interface TreeRecordNodeUnsafe<
  * @remarks
  * Do not use this type directly: it's only needed in the implementation of generic logic which define recursive schema, not when using recursive schema.
  * @sealed
- * @alpha
+ * @beta
  * @system
  */
 export type UnannotateAllowedTypeUnsafe<
@@ -564,7 +564,7 @@ export type UnannotateAllowedTypeUnsafe<
  * {@link Unenforced} version of {@link AnnotatedAllowedType}.
  * @remarks
  * Do not use this type directly: it's only needed in the implementation of generic logic which define recursive schema, not when using recursive schema.
- * @system @sealed @alpha
+ * @system @sealed @beta
  */
 export interface AnnotatedAllowedTypeUnsafe<T = Unenforced<LazyItem<TreeNodeSchema>>>
 	extends AnnotatedAllowedType<T> {}
@@ -573,7 +573,7 @@ export interface AnnotatedAllowedTypeUnsafe<T = Unenforced<LazyItem<TreeNodeSche
  * {@link Unenforced} version of {@link AnnotatedAllowedTypes}.
  * @remarks
  * Do not use this type directly: it's only needed in the implementation of generic logic which define recursive schema, not when using recursive schema.
- * @system @sealed @alpha
+ * @system @sealed @beta
  */
 export interface AnnotatedAllowedTypesUnsafe
 	extends AnnotatedAllowedTypes<LazyItem<System_Unsafe.TreeNodeSchemaUnsafe>> {}
@@ -592,7 +592,7 @@ export type AllowedTypesFullUnsafe<
  * {@link Unenforced} version of {@link AllowedTypesFullFromMixed}.
  * @remarks
  * Do not use this type directly: it's only needed in the implementation of generic logic which define recursive schema, not when using recursive schema.
- * @system @sealed @alpha
+ * @system @sealed @beta
  */
 export type AllowedTypesFullFromMixedUnsafe<
 	T extends readonly Unenforced<AnnotatedAllowedType | LazyItem<TreeNodeSchema>>[],
@@ -603,7 +603,7 @@ export type AllowedTypesFullFromMixedUnsafe<
  * {@link Unenforced} version of {@link UnannotateAllowedTypesList}.
  * @remarks
  * Do not use this type directly: it's only needed in the implementation of generic logic which define recursive schema, not when using recursive schema.
- * @system @sealed @alpha
+ * @system @sealed @beta
  */
 export type UnannotateAllowedTypesListUnsafe<
 	T extends readonly Unenforced<AnnotatedAllowedType | LazyItem<TreeNodeSchema>>[],
@@ -615,7 +615,7 @@ export type UnannotateAllowedTypesListUnsafe<
  * {@link Unenforced} version of {@link AnnotateAllowedTypesList}.
  * @remarks
  * Do not use this type directly: it's only needed in the implementation of generic logic which define recursive schema, not when using recursive schema.
- * @system @sealed @alpha
+ * @system @sealed @beta
  */
 export type AnnotateAllowedTypesListUnsafe<
 	T extends readonly Unenforced<AnnotatedAllowedType | LazyItem<TreeNodeSchema>>[],

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

@@ -6,7 +6,6 @@
 import { assert, unreachableCase } from "@fluidframework/core-utils/internal";
 import { normalizeFieldSchema, type ImplicitFieldSchema } from "../fieldSchema.js";
 import type {
-	SimpleAllowedTypeAttributes,
 	SimpleArrayNodeSchema,
 	SimpleFieldSchema,
 	SimpleLeafNodeSchema,
@@ -32,7 +31,6 @@ import { LeafNodeSchema } from "../leafNodeSchema.js";
  *
  * @param schema - The schema to convert
  * @param copySchemaObjects - If true, TreeNodeSchema and FieldSchema are copied into plain JavaScript objects. Either way, custom metadata is referenced and not copied.
- * @param isViewSchema - If true (default), properties used by view schema but not part of stored schema (for example, `isStaged` on allowed types) are preserved in the output.
  *
  * @remarks
  * Given that the Schema types used in {@link ImplicitFieldSchema} already implement the {@link SimpleNodeSchema} interfaces, there are limited use-cases for this function.
@@ -47,7 +45,6 @@ import { LeafNodeSchema } from "../leafNodeSchema.js";
 export function toSimpleTreeSchema(
 	schema: ImplicitFieldSchema,
 	copySchemaObjects: boolean,
-	isViewSchema: boolean = true,
 ): SimpleTreeSchema {
 	const normalizedSchema = normalizeFieldSchema(schema);
 	const definitions = new Map<string, SimpleNodeSchema>();
@@ -62,9 +59,7 @@ export function toSimpleTreeSchema(
 					nodeSchema instanceof RecordNodeSchema,
 				0xb60 /* Invalid schema */,
 			);
-			const outSchema = copySchemaObjects
-				? copySimpleNodeSchema(nodeSchema, isViewSchema)
-				: nodeSchema;
+			const outSchema = copySchemaObjects ? copySimpleNodeSchema(nodeSchema) : nodeSchema;
 			definitions.set(nodeSchema.identifier, outSchema);
 		},
 	});
@@ -72,10 +67,7 @@ export function toSimpleTreeSchema(
 	return {
 		root: copySchemaObjects
 			? ({
-					simpleAllowedTypes: normalizeSimpleAllowedTypes(
-						normalizedSchema.simpleAllowedTypes,
-						isViewSchema,
-					),
+					simpleAllowedTypes: normalizedSchema.simpleAllowedTypes,
 					kind: normalizedSchema.kind,
 					metadata: normalizedSchema.metadata,
 					persistedMetadata: normalizedSchema.persistedMetadata,
@@ -85,36 +77,12 @@ export function toSimpleTreeSchema(
 	};
 }
 
-/**
- * Normalizes the {@link SimpleAllowedTypeAttributes} by either preserving or omitting view-specific schema properties.
- * @param simpleAllowedTypes - The simple allowed types to normalize.
- * @param isViewSchema - If true, properties used by view schema but not part of stored schema (for example, `isStaged` on allowed types) are preserved in the output.
- * @returns The normalized simple allowed types.
- */
-function normalizeSimpleAllowedTypes(
-	simpleAllowedTypes: ReadonlyMap<string, SimpleAllowedTypeAttributes>,
-	isViewSchema: boolean,
-): ReadonlyMap<string, SimpleAllowedTypeAttributes> {
-	if (isViewSchema) {
-		return simpleAllowedTypes;
-	} else {
-		const normalized = new Map<string, SimpleAllowedTypeAttributes>();
-		for (const [identifier, attributes] of simpleAllowedTypes.entries()) {
-			normalized.set(identifier, { ...attributes, isStaged: undefined });
-		}
-		return normalized;
-	}
-}
-
 /**
  * Copies a {@link SimpleNodeSchema} into a new plain JavaScript object.
  *
  * @remarks Caches the result on the input schema for future calls.
  */
-function copySimpleNodeSchema(
-	schema: SimpleNodeSchema,
-	isViewSchema: boolean,
-): SimpleNodeSchema {
+export function copySimpleNodeSchema(schema: SimpleNodeSchema): SimpleNodeSchema {
 	const kind = schema.kind;
 	switch (kind) {
 		case NodeKind.Leaf:
@@ -122,9 +90,9 @@ function copySimpleNodeSchema(
 		case NodeKind.Array:
 		case NodeKind.Map:
 		case NodeKind.Record:
-			return copySimpleSchemaWithAllowedTypes(schema, isViewSchema);
+			return copySimpleSchemaWithAllowedTypes(schema);
 		case NodeKind.Object:
-			return copySimpleObjectSchema(schema, isViewSchema);
+			return copySimpleObjectSchema(schema);
 		default:
 			unreachableCase(kind);
 	}
@@ -141,36 +109,101 @@ function copySimpleLeafSchema(schema: SimpleLeafNodeSchema): SimpleLeafNodeSchem
 
 function copySimpleSchemaWithAllowedTypes(
 	schema: SimpleMapNodeSchema | SimpleArrayNodeSchema | SimpleRecordNodeSchema,
-	isViewSchema: boolean,
 ): SimpleMapNodeSchema | SimpleArrayNodeSchema | SimpleRecordNodeSchema {
 	return {
 		kind: schema.kind,
-		simpleAllowedTypes: normalizeSimpleAllowedTypes(schema.simpleAllowedTypes, isViewSchema),
+		simpleAllowedTypes: schema.simpleAllowedTypes,
 		metadata: schema.metadata,
 		persistedMetadata: schema.persistedMetadata,
 	};
 }
 
-function copySimpleObjectSchema(
-	schema: SimpleObjectNodeSchema,
-	isViewSchema: boolean,
-): SimpleObjectNodeSchema {
+function copySimpleObjectSchema(schema: SimpleObjectNodeSchema): SimpleObjectNodeSchema {
 	const fields: Map<string, SimpleObjectFieldSchema> = new Map();
 	for (const [propertyKey, field] of schema.fields) {
 		// field already is a SimpleObjectFieldSchema, but copy the subset of the properties needed by this interface to get a clean simple object.
-		fields.set(propertyKey, {
+		const simpleField = {
 			kind: field.kind,
-			simpleAllowedTypes: normalizeSimpleAllowedTypes(field.simpleAllowedTypes, isViewSchema),
+			simpleAllowedTypes: field.simpleAllowedTypes,
 			metadata: field.metadata,
 			persistedMetadata: field.persistedMetadata,
 			storedKey: field.storedKey,
-		});
+		};
+
+		fields.set(propertyKey, simpleField);
 	}
 
-	return {
+	const simpleObject = {
 		kind: NodeKind.Object,
 		fields,
 		metadata: schema.metadata,
 		persistedMetadata: schema.persistedMetadata,
+		allowUnknownOptionalFields: schema.allowUnknownOptionalFields,
+	} satisfies SimpleObjectNodeSchema;
+
+	return simpleObject;
+}
+
+/**
+ * Creates a copy of a SimpleTreeSchema without metadata fields. This is useful for comparing deserialized view schemas with in-memory schemas.
+ * metadata and persistedMetadata are not relevant for schema compatibility checks and are not serialized by the Simple Schema serializer.
+ * @see {@link simpleSchemaSerializer.ts} for the serialization logic.
+ *
+ * @param schema - The SimpleTreeSchema to remove fields from.
+ * @param fieldsToRemove - An object specifying which fields to remove.
+ * @returns A new SimpleTreeSchema without the specified fields.
+ */
+export function copySimpleTreeSchemaWithoutMetadata(
+	schema: SimpleTreeSchema,
+): SimpleTreeSchema {
+	const definitions = new Map<string, SimpleNodeSchema>();
+
+	for (const [identifier, nodeSchema] of schema.definitions.entries()) {
+		const kind = nodeSchema.kind;
+		switch (kind) {
+			case NodeKind.Array:
+			case NodeKind.Map:
+			case NodeKind.Record:
+			case NodeKind.Leaf: {
+				const outputNodeSchema = {
+					...nodeSchema,
+					metadata: {},
+					persistedMetadata: undefined,
+				};
+				definitions.set(identifier, outputNodeSchema);
+				break;
+			}
+			case NodeKind.Object: {
+				const outputFields = new Map<string, SimpleObjectFieldSchema>();
+				for (const [propertyKey, fieldSchema] of nodeSchema.fields.entries()) {
+					const outputField: SimpleObjectFieldSchema = {
+						...fieldSchema,
+						metadata: {},
+						persistedMetadata: undefined,
+					};
+					outputFields.set(propertyKey, outputField);
+				}
+				const outputNodeSchema = {
+					...nodeSchema,
+					metadata: {},
+					persistedMetadata: undefined,
+					fields: outputFields,
+				};
+				definitions.set(identifier, outputNodeSchema);
+				break;
+			}
+			default:
+				unreachableCase(kind);
+		}
+	}
+
+	return {
+		root: {
+			kind: schema.root.kind,
+			simpleAllowedTypes: schema.root.simpleAllowedTypes,
+			metadata: {},
+			persistedMetadata: undefined,
+		},
+		definitions,
 	};
 }

package/src/simple-tree/core/allowedTypes.ts

@@ -57,7 +57,7 @@ export type AllowedTypes = readonly LazyItem<TreeNodeSchema>[];
 /**
  * Stores annotations for an individual allowed type.
  * @remarks
- * Create using APIs on {@link SchemaFactoryAlpha}, like {@link SchemaStaticsAlpha.staged}.
+ * Create using APIs on {@link SchemaStaticsBeta}, like {@link SchemaStaticsBeta.staged}.
  * @privateRemarks
  * Since this is sealed, users are not supposed to create instances of it directly.
  * Making it extend ErasedType could enforce that.
@@ -412,7 +412,7 @@ export interface AllowedTypeMetadata {
 	readonly custom?: unknown;
 
 	/**
-	 * If defined, indicates that an allowed type is {@link SchemaStaticsAlpha.staged | staged}.
+	 * If defined, indicates that an allowed type is {@link SchemaStaticsBeta.staged | staged}.
 	 */
 	readonly stagedSchemaUpgrade?: SchemaUpgrade;
 }
@@ -425,7 +425,7 @@ export let createSchemaUpgrade: () => SchemaUpgrade;
 /**
  * Unique token used to upgrade schemas and determine if a particular upgrade has been completed.
  * @remarks
- * Create using {@link SchemaStaticsAlpha.staged}.
+ * Create using {@link SchemaStaticsBeta.staged}.
  * @privateRemarks
  * TODO:#38722 implement runtime schema upgrades.
  * Until then, the class purely behaves mostly as a placeholder.