@fluidframework/tree 2.71.0 → 2.73.0

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

@@ -0,0 +1,361 @@
+/*!
+ * 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 { createSchemaUpgrade, NodeKind, SchemaUpgrade } 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) {
+		const isStaged = attributes.isStaged instanceof SchemaUpgrade ? true : attributes.isStaged;
+		encodedAllowedTypes[identifier] = { 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): SimpleAllowedTypeAttributes => {
+			const isStaged = value.isStaged === true ? createSchemaUpgrade() : value.isStaged;
+			return { isStaged };
+		},
+	);
+
+	return simpleAllowedTypes;
+}

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

@@ -0,0 +1,135 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import type { JsonCompatibleReadOnly } from "../../util/index.js";
+import { toStoredSchema } from "../toStoredSchema.js";
+import { TreeViewConfigurationAlpha, TreeViewConfiguration } from "./configuration.js";
+import { SchemaCompatibilityTester } from "./schemaCompatibilityTester.js";
+import { generateSchemaFromSimpleSchema } from "./schemaFromSimple.js";
+import { decodeSimpleSchema, encodeSimpleSchema } from "./simpleSchemaCodec.js";
+import type { SchemaCompatibilityStatus } from "./tree.js";
+import { toSimpleTreeSchema } from "./viewSchemaToSimpleSchema.js";
+
+/**
+ * Compute the compatibility of using `view` to {@link ViewableTree.viewWith | view a tree} who's {@link ITreeAlpha.exportSimpleSchema | stored schema} could be derived from `viewWhichCreatedStoredSchema` via either {@link TreeView.initialize} or {@link TreeView.upgradeSchema}.
+ *
+ * @remarks See {@link SchemaCompatibilityStatus} for details on the compatibility results.
+ *
+ * @example This example demonstrates checking the compatibility of a historical schema against a current schema.
+ * In this case, the historical schema is a Point2D object with x and y fields, while the current schema is a Point3D object
+ * that adds an optional z field.
+ *
+ * ```ts
+ * // This snapshot is assumed to be the same as Point3D, except missing `z`.
+ * const encodedSchema = JSON.parse(fs.readFileSync("PointSchema.json", "utf8"));
+ * const oldViewSchema = importCompatibilitySchemaSnapshot(encodedSchema);
+ *
+ * // Build the current view schema
+ * class Point3D extends factory.object("Point", {
+ * 	x: factory.number,
+ * 	y: factory.number,
+ *
+ * 	// The current schema has a new optional field that was not present on Point2D
+ * 	z: factory.optional(factory.number),
+ * }) {}
+ * const currentViewSchema = new TreeViewConfiguration({ schema: Point3D });
+ *
+ * // Check to see if the document created by the historical view schema can be opened with the current view schema
+ * const backwardsCompatibilityStatus = checkCompatibility(oldViewSchema, currentViewSchema);
+ *
+ * // z is not present in Point2D, so the schema must be upgraded
+ * assert.equal(backwardsCompatibilityStatus.canView, false);
+ *
+ * // The schema can be upgraded to add the new optional field
+ * assert.equal(backwardsCompatibilityStatus.canUpgrade, true);
+ *
+ * // Test what the old version of the application would do with a tree using the new schema:
+ * const forwardsCompatibilityStatus = checkCompatibility(currentViewSchema, oldViewSchema);
+ *
+ * // If the old schema set allowUnknownOptionalFields, this would be true, but since it did not,
+ * // this assert will fail, detecting the forwards compatibility break:
+ * // this means these two versions of the application cannot collaborate on content using these schema.
+ * assert.equal(forwardsCompatibilityStatus.canView, true);
+ * ```
+ *
+ * @param viewWhichCreatedStoredSchema - From which to derive the stored schema, as if it initialized or upgraded a tree via {@link TreeView}.
+ * @param view - The view being tested to see if it could view tree created or initialized using `viewWhichCreatedStoredSchema`.
+ * @returns The compatibility status.
+ *
+ * @alpha
+ */
+export function checkCompatibility(
+	viewWhichCreatedStoredSchema: TreeViewConfiguration,
+	view: TreeViewConfiguration,
+): Omit<SchemaCompatibilityStatus, "canInitialize"> {
+	const viewAsAlpha = new TreeViewConfigurationAlpha({ schema: view.schema });
+	const stored = toStoredSchema(viewWhichCreatedStoredSchema.schema, {
+		includeStaged: () => true,
+	});
+	const tester = new SchemaCompatibilityTester(viewAsAlpha);
+	return tester.checkCompatibility(stored);
+}
+
+/**
+ * Returns a JSON compatible representation of the tree schema for snapshot compatibility checking.
+ *
+ * Snapshots can be loaded by the same or newer package versions, but not necessarily older versions.
+ *
+ * @see {@link importCompatibilitySchemaSnapshot} which loads these snapshots.
+ *
+ * @param config - The schema to snapshot. Only the schema field of the `TreeViewConfiguration` is used.
+ * @returns The JSON representation of the schema.
+ *
+ * @example This example creates and persists a snapshot of a Point2D schema.
+ *
+ * ```ts
+ * const schemaFactory = new SchemaFactory("test");
+ * class Point2D extends schemaFactory.object("Point", {
+ * 	x: factory.number,
+ * 	y: factory.number,
+ * }) {}
+ * const viewSchema = new TreeViewConfiguration({ schema: Point2D });
+ * const encodedSchema = JSON.stringify(exportCompatibilitySchemaSnapshot(viewSchema));
+ * fs.writeFileSync("PointSchema.json", encodedSchema);
+ * ```
+ *
+ * @alpha
+ */
+export function exportCompatibilitySchemaSnapshot(
+	config: Pick<TreeViewConfiguration, "schema">,
+): JsonCompatibleReadOnly {
+	const simpleSchema = toSimpleTreeSchema(config.schema, true);
+	return encodeSimpleSchema(simpleSchema);
+}
+
+/**
+ * Parse the format exported by {@link exportCompatibilitySchemaSnapshot} into a schema.
+ *
+ * Can load snapshots created by the same or older package versions, but not necessarily newer versions.
+ *
+ * @see {@link exportCompatibilitySchemaSnapshot} which creates these snapshots.
+ *
+ * @param config - The JSON representation of the schema.
+ * @returns The schema. Only the schema field of the {@link TreeViewConfiguration} is populated.
+ * @throws Will throw a usage error if the encoded schema is not in the expected format.
+ *
+ * @example This example loads and parses a snapshot of a Point2D schema.
+ *
+ * ```ts;
+ * const oldViewSchema = importCompatibilitySchemaSnapshot(fs.readFileSync("PointSchema.json", "utf8"));
+ * ```
+ *
+ * @alpha
+ */
+export function importCompatibilitySchemaSnapshot(
+	config: JsonCompatibleReadOnly,
+): TreeViewConfiguration {
+	const simpleSchema = decodeSimpleSchema(config);
+	const viewSchema = generateSchemaFromSimpleSchema(simpleSchema);
+
+	// We construct a TreeViewConfiguration here with the default parameters. The default set of validation parameters are fine for
+	// a schema produced by `generateSchemaFromSimpleSchema`.
+	return new TreeViewConfiguration({ schema: viewSchema.root });
+}

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.
 	 *
@@ -577,7 +577,7 @@ export interface TreeViewEvents {
 /**
  * Retrieve the {@link TreeViewAlpha | alpha API} for a {@link TreeView}.
  * @alpha
- * @deprecated Use {@link asAlpha} instead.
+ * @deprecated Use {@link (asAlpha:1)} instead.
  * @privateRemarks Despite being deprecated, this function should be used within the tree package (outside of tests) rather than `asAlpha` in order to avoid circular import dependencies.
  */
 export function asTreeViewAlpha<TSchema extends ImplicitFieldSchema>(

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>>[],