@fluidframework/tree 2.3.0-288113 → 2.3.1

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

@@ -138,7 +138,10 @@ export class ForestSummarizer implements Summarizable {
 			const fieldChanges: [FieldKey, DeltaFieldChanges][] = [];
 			const build: DeltaDetachedNodeBuild[] = [];
 			for (const [fieldKey, field] of fields) {
-				const chunked = chunkField(field, defaultChunkPolicy);
+				const chunked = chunkField(field, {
+					policy: defaultChunkPolicy,
+					idCompressor: this.idCompressor,
+				});
 				const nodeCursors = chunked.flatMap((chunk) =>
 					mapCursorField(chunk.cursor(), (cursor) => cursor.fork()),
 				);

package/src/feature-libraries/index.ts

@@ -120,7 +120,6 @@ export {
 	type FlexAllowedTypes,
 	FlexFieldSchema,
 	type FlexTreeSchema,
-	Any,
 	type SchemaLibraryData,
 	type LazyTreeNodeSchema,
 	ViewSchema,
@@ -141,8 +140,6 @@ export {
 	type FlexListToUnion,
 	type ExtractItemType,
 	isLazy,
-	type NormalizeObjectNodeFields,
-	type NormalizeField as NormalizeFieldSchema,
 	type FlexObjectNodeFields,
 	intoStoredSchema,
 	intoStoredSchemaCollection,
@@ -150,19 +147,6 @@ export {
 	type FlexList,
 } from "./typed-schema/index.js";
 
-export {
-	SchemaBuilderBase,
-	type SchemaLibrary,
-	type FlexImplicitFieldSchema,
-	type NormalizeField,
-	type FlexImplicitAllowedTypes,
-	type NormalizeAllowedTypes,
-	type SchemaBuilderOptions,
-	normalizeAllowedTypes,
-	normalizeField,
-} from "./schemaBuilderBase.js";
-export { SchemaBuilderInternal } from "./schemaBuilder.js";
-
 export { mapRootChanges } from "./deltaUtils.js";
 
 export {
@@ -214,25 +198,17 @@ export {
 } from "./default-schema/index.js";
 
 export {
-	type AssignableFieldKinds,
-	type FlexibleFieldContent,
-	type FlexibleNodeContent,
-	type FlexTreeLeafNode,
-	type FlexTreeMapNode,
 	type FlexTreeOptionalField,
 	type FlexTreeRequiredField,
 	type FlexTreeSequenceField,
 	Skip,
-	type FlexTreeObjectNode,
 	type FlexTreeContext,
+	type FlexTreeHydratedContext,
 	type FlexTreeTypedField,
-	type FlexTreeTypedNode,
-	type FlexTreeTypedNodeUnion,
 	type FlexTreeEntity,
 	type FlexTreeField,
 	type FlexTreeNode,
 	getTreeContext,
-	type CheckTypesOverlap,
 	TreeStatus,
 	Context,
 	type FlexTreeNodeEvents,
@@ -240,9 +216,7 @@ export {
 	isFlexTreeNode,
 	ContextSlot,
 	// Internal
-	type FlexTreeUnboxField,
 	flexTreeMarker,
-	FlexTreeEntityKind,
 	assertFlexTreeEntityNotFreed,
 	flexTreeSlot,
 	getSchemaAndPolicy,
@@ -274,4 +248,5 @@ export {
 	isMapTreeSequenceField,
 	getOrCreateMapTreeNode,
 	tryGetMapTreeNode,
+	UnhydratedContext,
 } from "./flex-map-tree/index.js";

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

@@ -22,6 +22,10 @@ import type { FullSchemaPolicy } from "./fieldKind.js";
 import { withEditor } from "./fieldKindWithEditor.js";
 import { isNeverTree } from "./isNeverTree.js";
 
+// TODO:
+// The comparisons in this file seem redundant with those in discrepancies.ts.
+// Rather than both existing, one of which just returns boolean and the other which returns additional details, a simple comparison which returns everything needed should be used.
+
 /**
  * @returns true iff `superset` is a superset of `original`.
  *
@@ -153,12 +157,6 @@ export function allowsTreeSchemaIdentifierSuperset(
 	original: TreeTypeSet,
 	superset: TreeTypeSet,
 ): boolean {
-	if (superset === undefined) {
-		return true;
-	}
-	if (original === undefined) {
-		return false;
-	}
 	for (const originalType of original) {
 		if (!superset.has(originalType)) {
 			return false;

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

@@ -18,6 +18,10 @@ import {
 	type ValueSchema,
 } from "../../core/index.js";
 
+// TODO:
+// The comparisons in this file seem redundant with those in comparison.ts.
+// Rather than both existing, one of which just returns boolean and the other which returns additional details, a simple comparison which returns everything needed should be used.
+
 /**
  * @remarks
  *
@@ -298,22 +302,9 @@ function trackFieldDiscrepancies(
 		a: TreeTypeSet,
 		b: TreeTypeSet,
 	): [TreeNodeSchemaIdentifier[], TreeNodeSchemaIdentifier[]] => {
-		if (a === undefined && b === undefined) {
-			return [[], []];
-		}
-
-		if (a !== undefined && b !== undefined) {
-			const aDiff = [...a].filter((value) => !b.has(value));
-			const bDiff = [...b].filter((value) => !a.has(value));
-			return [aDiff, bDiff];
-		}
-
-		if (a !== undefined) {
-			return [[...a], []];
-		}
-
-		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-		return [[], [...b!]];
+		const aDiff = [...a].filter((value) => !b.has(value));
+		const bDiff = [...b].filter((value) => !a.has(value));
+		return [aDiff, bDiff];
 	};
 
 	const allowedTypesDiscrepancies = findSetDiscrepancies(view.types, stored.types);

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

@@ -382,7 +382,10 @@ function makeModularChangeCodec(
 		});
 		const getChunk = (index: number): TreeChunk => {
 			assert(index < chunks.length, 0x898 /* out of bounds index for build chunk */);
-			return chunkFieldSingle(chunks[index] ?? oob(), defaultChunkPolicy);
+			return chunkFieldSingle(chunks[index] ?? oob(), {
+				policy: defaultChunkPolicy,
+				idCompressor: context.idCompressor,
+			});
 		};
 
 		const map: ModularChangeset["builds"] = newTupleBTree();

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

@@ -87,6 +87,7 @@ import type {
 	NodeId,
 	TupleBTree,
 } from "./modularChangeTypes.js";
+import type { IIdCompressor } from "@fluidframework/id-compressor";
 
 /**
  * Implementation of ChangeFamily which delegates work in a given field to the appropriate FieldKind
@@ -673,7 +674,7 @@ export class ModularChangeFamily
 			0x89a /* Unexpected destroys in change to invert */,
 		);
 
-		if ((change.change.constraintViolationCount ?? 0) > 0) {
+		if (hasConflicts(change.change)) {
 			return makeModularChangeset(
 				undefined,
 				undefined,
@@ -827,6 +828,10 @@ export class ModularChangeFamily
 		over: TaggedChange<ModularChangeset>,
 		revisionMetadata: RevisionMetadataSource,
 	): ModularChangeset {
+		if (hasConflicts(over.change)) {
+			return taggedChange.change;
+		}
+
 		const change = taggedChange.change;
 		const maxId = Math.max(change.maxId ?? -1, over.change.maxId ?? -1);
 		const idState: IdAllocationState = { maxId };
@@ -1845,7 +1850,7 @@ export function intoDelta(
 	const idAllocator = MemoizedIdRangeAllocator.fromNextId();
 	const rootDelta: Mutable<DeltaRoot> = {};
 
-	if ((change.constraintViolationCount ?? 0) === 0) {
+	if (!hasConflicts(change)) {
 		// If there are no constraint violations, then tree changes apply.
 		const fieldDeltas = intoDeltaImpl(
 			change.fieldChanges,
@@ -2466,15 +2471,20 @@ export class ModularEditBuilder extends EditBuilder<ModularChangeset> {
 	public buildTrees(
 		firstId: ChangesetLocalId,
 		content: ITreeCursorSynchronous,
+		idCompressor?: IIdCompressor,
 	): GlobalEditDescription {
 		if (content.mode === CursorLocationType.Fields && content.getFieldLength() === 0) {
 			return { type: "global" };
 		}
 		const builds: ChangeAtomIdBTree<TreeChunk> = newTupleBTree();
+		const chunkCompressor = {
+			policy: defaultChunkPolicy,
+			idCompressor,
+		};
 		const chunk =
 			content.mode === CursorLocationType.Fields
-				? chunkFieldSingle(content, defaultChunkPolicy)
-				: chunkTree(content, defaultChunkPolicy);
+				? chunkFieldSingle(content, chunkCompressor)
+				: chunkTree(content, chunkCompressor);
 		builds.set([undefined, firstId], chunk);
 
 		return {

package/src/feature-libraries/storedToViewSchema.ts

@@ -17,7 +17,6 @@ import { fail } from "../util/index.js";
 
 import { defaultSchemaPolicy } from "./default-schema/index.js";
 import {
-	Any,
 	type FlexAllowedTypes,
 	FlexFieldSchema,
 	type FlexMapFieldSchema,
@@ -42,7 +41,7 @@ export function treeSchemaFromStoredSchema(schema: TreeStoredSchema): FlexTreeSc
 		if (innerSchema instanceof LeafNodeStoredSchema) {
 			map.set(
 				identifier,
-				LeafNodeSchema.create({ name: "intoTypedSchema" }, identifier, innerSchema.leafValue),
+				new LeafNodeSchema({ name: "intoTypedSchema" }, identifier, innerSchema.leafValue),
 			);
 		} else if (innerSchema instanceof MapNodeStoredSchema) {
 			map.set(
@@ -93,9 +92,9 @@ export function fieldSchemaFromStoredSchema(
 	map: ReadonlyMap<TreeNodeSchemaIdentifier, FlexTreeNodeSchema>,
 ): FlexFieldSchema {
 	const kind = defaultSchemaPolicy.fieldKinds.get(schema.kind) ?? fail("missing field kind");
-	const types: FlexAllowedTypes =
-		schema.types === undefined
-			? [Any]
-			: Array.from(schema.types, (v) => () => map.get(v) ?? fail("missing schema"));
+	const types: FlexAllowedTypes = Array.from(
+		schema.types,
+		(v) => () => map.get(v) ?? fail("missing schema"),
+	);
 	return FlexFieldSchema.create(kind, types);
 }

package/src/feature-libraries/typed-schema/flexList.ts

@@ -45,7 +45,7 @@ export function markEager<T>(t: T): T {
  * To force a `"function"` item to be treated as an eager item, call `markEager` before putting it in the list.
  * This is necessary e.g. when the eager list items are function types and the lazy items are functions that _return_ function types.
  * `FlexList`s are processed by `normalizeFlexList` and `normalizeFlexListEager`.
- * @public
+ * @system @public
  */
 export type FlexList<Item = unknown> = readonly LazyItem<Item>[];
 
@@ -94,7 +94,7 @@ export type NormalizedLazyFlexList<Item> = (() => Item)[];
 
 /**
  * Get the `Item` type from a `LazyItem<Item>`.
- * @public
+ * @system @public
  */
 export type ExtractItemType<Item extends LazyItem> = Item extends () => infer Result
 	? Result
@@ -120,7 +120,7 @@ export type FlexListToNonLazyArray<List extends FlexList> =
 
 /**
  * Normalize FlexList type to a union.
- * @public
+ * @system @public
  */
 export type FlexListToUnion<TList extends FlexList> = ExtractItemType<TList[number]>;
 

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

@@ -6,7 +6,6 @@
 export {
 	type FlexTreeNodeSchema,
 	FlexFieldSchema,
-	Any,
 	allowedTypesToTypeSet,
 	type FlexAllowedTypes,
 	type LazyTreeNodeSchema,
@@ -23,8 +22,6 @@ export {
 	schemaIsLeaf,
 	schemaIsMap,
 	schemaIsObjectNode,
-	type NormalizeObjectNodeFields,
-	type NormalizeField,
 	intoStoredSchema,
 	allowedTypesSchemaSet,
 	intoStoredSchemaCollection,
@@ -47,4 +44,5 @@ export {
 	type NormalizeLazyItem,
 	type FlexListToUnion,
 	type ExtractItemType,
+	normalizeFlexListEager,
 } from "./flexList.js";

package/src/feature-libraries/typed-schema/schemaCollection.ts

@@ -22,7 +22,6 @@ import {
 	type FlexTreeNodeSchema,
 	LeafNodeSchema,
 	type SchemaCollection,
-	allowedTypesIsAny,
 } from "./typedTreeSchema.js";
 import type { Sourced } from "./view.js";
 
@@ -168,11 +167,11 @@ export function validateSchemaCollection(
 			validateField(
 				lintConfiguration,
 				collection,
-				tree.info,
+				tree.info as FlexFieldSchema,
 				() => `Map fields of "${identifier}" schema from library "${tree.builder.name}"`,
 				errors,
 			);
-			if ((tree.info.kind.multiplicity as Multiplicity) === Multiplicity.Single) {
+			if ((tree.info as FlexFieldSchema).kind.multiplicity === Multiplicity.Single) {
 				errors.push(
 					`Map fields of "${identifier}" schema from library "${tree.builder.name}" has kind with multiplicity "Single". This is invalid since it requires all possible field keys to have a value under them.`,
 				);
@@ -213,24 +212,23 @@ export function validateField(
 	errors: string[],
 ): void {
 	const types = field.allowedTypes;
-	if (!allowedTypesIsAny(types)) {
-		const normalizedTypes = normalizeFlexListEager(types);
-		for (const type of normalizedTypes) {
-			const referenced = collection.nodeSchema.get(type.name);
-			if (referenced === undefined) {
-				errors.push(
-					`${describeField()} references type "${type.name}" from library "${
-						type.builder.name
-					}" which is not defined. Perhaps another type was intended, or that library needs to be added.`,
-				);
-			}
-		}
-		if (types.length === 0 && lintConfiguration.rejectEmpty) {
+
+	const normalizedTypes = normalizeFlexListEager(types);
+	for (const type of normalizedTypes) {
+		const referenced = collection.nodeSchema.get(type.name);
+		if (referenced === undefined) {
 			errors.push(
-				`${describeField()} requires children to have a type from a set of zero types. This means the field must always be empty.`,
+				`${describeField()} references type "${type.name}" from library "${
+					type.builder.name
+				}" which is not defined. Perhaps another type was intended, or that library needs to be added.`,
 			);
 		}
 	}
+	if (types.length === 0 && lintConfiguration.rejectEmpty) {
+		errors.push(
+			`${describeField()} requires children to have a type from a set of zero types. This means the field must always be empty.`,
+		);
+	}
 
 	const kind = field.kind;
 	const kindFromPolicy = defaultSchemaPolicy.fieldKinds.get(kind.identifier);

package/src/feature-libraries/typed-schema/typedTreeSchema.ts

@@ -21,7 +21,6 @@ import {
 	identifierFieldKindIdentifier,
 } from "../../core/index.js";
 import {
-	type Assume,
 	type MakeNominal,
 	type Named,
 	compareSets,
@@ -29,6 +28,7 @@ import {
 	oneFromSet,
 	type requireAssignableTo,
 	filterIterable,
+	brand,
 } from "../../util/index.js";
 import { FieldKinds } from "../default-schema/index.js";
 import type { FlexFieldKind, FullSchemaPolicy } from "../modular-schema/index.js";
@@ -42,12 +42,6 @@ export interface FlexObjectNodeFields {
 	readonly [key: string]: FlexFieldSchema;
 }
 
-/**
- */
-export type NormalizeObjectNodeFields<T extends FlexObjectNodeFields> = {
-	readonly [Property in keyof T]: NormalizeField<T[Property]>;
-};
-
 /**
  * A placeholder to use in {@link https://www.typescriptlang.org/docs/handbook/2/generics.html#generic-constraints | extends constraints} when using the real type breaks compilation of some recursive types due to {@link https://github.com/microsoft/TypeScript/issues/55758 | a design limitation of TypeScript}.
  *
@@ -67,14 +61,11 @@ export type Unenforced<_DesiredExtendsConstraint> = unknown;
  * This can not be enforced using TypeScript since doing so breaks recursive type support.
  * See note on SchemaBuilder.fieldRecursive.
  */
-export abstract class TreeNodeSchemaBase<
-	const out Name extends string = string,
-	const out Specification = unknown,
-> {
+export abstract class TreeNodeSchemaBase<const out Specification = unknown> {
 	protected _typeCheck!: MakeNominal;
 	protected constructor(
 		public readonly builder: Named<string>,
-		public readonly name: TreeNodeSchemaIdentifier<Name>,
+		public readonly name: TreeNodeSchemaIdentifier,
 		public readonly info: Specification,
 		public readonly stored: TreeNodeStoredSchema,
 	) {}
@@ -83,23 +74,17 @@ export abstract class TreeNodeSchemaBase<
 
 /**
  */
-export class FlexMapNodeSchema<
-	const out Name extends string = string,
-	const out Specification extends Unenforced<FlexMapFieldSchema> = FlexMapFieldSchema,
-> extends TreeNodeSchemaBase<Name, Specification> {
+export class FlexMapNodeSchema extends TreeNodeSchemaBase {
 	public get mapFields(): FlexMapFieldSchema {
 		return this.info as FlexMapFieldSchema;
 	}
 
 	protected _typeCheck2?: MakeNominal;
-	public static create<
-		const Name extends string,
-		const Specification extends FlexMapFieldSchema,
-	>(
+	public static create<const Name extends string>(
 		builder: Named<string>,
 		name: TreeNodeSchemaIdentifier<Name>,
-		specification: Specification,
-	): FlexMapNodeSchema<Name, Specification> {
+		specification: FlexMapFieldSchema,
+	): FlexMapNodeSchema {
 		return new FlexMapNodeSchema(
 			builder,
 			name,
@@ -115,26 +100,10 @@ export class FlexMapNodeSchema<
 
 /**
  */
-export class LeafNodeSchema<
-	const out Name extends string = string,
-	const out Specification extends Unenforced<ValueSchema> = ValueSchema,
-> extends TreeNodeSchemaBase<Name, Specification> {
-	public get leafValue(): ValueSchema {
-		return this.info as ValueSchema;
-	}
-
+export class LeafNodeSchema extends TreeNodeSchemaBase<ValueSchema> {
 	protected _typeCheck2?: MakeNominal;
-	public static create<const Name extends string, const Specification extends ValueSchema>(
-		builder: Named<string>,
-		name: TreeNodeSchemaIdentifier<Name>,
-		specification: Specification,
-	): LeafNodeSchema<Name, Specification> {
-		return new LeafNodeSchema(
-			builder,
-			name,
-			specification,
-			new LeafNodeStoredSchema(specification),
-		);
+	public constructor(builder: Named<string>, name: string, specification: ValueSchema) {
+		super(builder, brand(name), specification, new LeafNodeStoredSchema(specification));
 	}
 
 	public override getFieldSchema(field: FieldKey): FlexFieldSchema {
@@ -144,28 +113,18 @@ export class LeafNodeSchema<
 
 /**
  */
-export class FlexObjectNodeSchema<
-	const out Name extends string = string,
-	const out Specification extends Unenforced<FlexObjectNodeFields> = FlexObjectNodeFields,
-> extends TreeNodeSchemaBase<Name, Specification> {
+export class FlexObjectNodeSchema extends TreeNodeSchemaBase {
 	protected _typeCheck2?: MakeNominal;
 	public readonly identifierFieldKeys: readonly FieldKey[] = [];
 
-	public static create<
-		const Name extends string,
-		const Specification extends FlexObjectNodeFields,
-	>(
+	public static create(
 		builder: Named<string>,
-		name: TreeNodeSchemaIdentifier<Name>,
-		specification: Specification,
-	): FlexObjectNodeSchema<Name, Specification> {
-		const objectNodeFieldsObject: NormalizeObjectNodeFields<Specification> =
-			normalizeStructFields<Specification>(specification);
-		const objectNodeFields: ObjectToMap<
-			NormalizeObjectNodeFields<Specification>,
-			FieldKey,
-			FlexFieldSchema
-		> = objectToMapTyped(objectNodeFieldsObject);
+		name: TreeNodeSchemaIdentifier,
+		specification: FlexObjectNodeFields,
+	): FlexObjectNodeSchema {
+		const objectNodeFieldsObject = normalizeStructFields(specification);
+		const objectNodeFields: ObjectToMap<FlexObjectNodeFields, FieldKey, FlexFieldSchema> =
+			objectToMapTyped(objectNodeFieldsObject);
 		return new FlexObjectNodeSchema(
 			builder,
 			name,
@@ -177,11 +136,9 @@ export class FlexObjectNodeSchema<
 
 	private constructor(
 		builder: Named<string>,
-		name: TreeNodeSchemaIdentifier<Name>,
-		info: Specification,
-		public readonly objectNodeFieldsObject: NormalizeObjectNodeFields<
-			Assume<Specification, FlexObjectNodeFields>
-		>,
+		name: TreeNodeSchemaIdentifier,
+		info: FlexObjectNodeFields,
+		public readonly objectNodeFieldsObject: FlexObjectNodeFields,
 		// Allows reading fields through the normal map.
 		// Stricter typing caused Specification to no longer be covariant, so has been removed.
 		public readonly objectNodeFields: ReadonlyMap<FieldKey, FlexFieldSchema>,
@@ -211,16 +168,9 @@ export class FlexObjectNodeSchema<
  */
 export type FlexTreeNodeSchema = TreeNodeSchemaBase;
 
-/**
- * Convert FieldSchemaSpecification | undefined into TreeFieldSchema.
- */
-export type NormalizeField<T extends FlexFieldSchema | undefined> = T extends FlexFieldSchema
-	? T
-	: FlexFieldSchema<typeof FieldKinds.forbidden, []>;
-
 function normalizeStructFields<T extends FlexObjectNodeFields>(
 	fields: T,
-): NormalizeObjectNodeFields<T> {
+): FlexObjectNodeFields {
 	const out: Record<string, FlexFieldSchema> = {};
 	// eslint-disable-next-line no-restricted-syntax
 	for (const key in fields) {
@@ -229,27 +179,18 @@ function normalizeStructFields<T extends FlexObjectNodeFields>(
 			out[key] = normalizeField(element);
 		}
 	}
-	return out as NormalizeObjectNodeFields<T>;
+	return out;
 }
 
-function normalizeField<T extends FlexFieldSchema | undefined>(t: T): NormalizeField<T> {
+function normalizeField(t: FlexFieldSchema | undefined): FlexFieldSchema {
 	if (t === undefined) {
-		return FlexFieldSchema.empty as unknown as NormalizeField<T>;
+		return FlexFieldSchema.empty;
 	}
 
 	assert(t instanceof FlexFieldSchema, 0x6ae /* invalid TreeFieldSchema */);
-	return t as NormalizeField<T>;
+	return t;
 }
 
-/**
- * Allow any node (as long as it meets the schema for its own type).
- */
-export const Any = "Any" as const;
-/**
- * Allow any node (as long as it meets the schema for its own type).
- */
-export type Any = typeof Any;
-
 /**
  * Tree type, but can be wrapped in a function to allow referring to types before they are declared.
  * This makes recursive and co-recursive types possible.
@@ -258,17 +199,8 @@ export type LazyTreeNodeSchema = FlexTreeNodeSchema | (() => FlexTreeNodeSchema)
 
 /**
  * Types for use in fields.
- *
- * "Any" is boxed in an array to allow use as variadic parameter.
  */
-export type FlexAllowedTypes = readonly [Any] | readonly LazyItem<FlexTreeNodeSchema>[];
-
-/**
- * Checks if an {@link FlexAllowedTypes} is {@link (Any:type)}.
- */
-export function allowedTypesIsAny(t: FlexAllowedTypes): t is readonly [Any] {
-	return t.length === 1 && t[0] === Any;
-}
+export type FlexAllowedTypes = readonly LazyItem<FlexTreeNodeSchema>[];
 
 /**
  * Subset of TreeFieldSchema thats legal in maps.
@@ -292,10 +224,7 @@ export type FlexMapFieldSchema = FlexFieldSchema<
  *
  * @sealed
  */
-export class FlexFieldSchema<
-	out TKind extends FlexFieldKind = FlexFieldKind,
-	const out TTypes extends Unenforced<FlexAllowedTypes> = FlexAllowedTypes,
-> {
+export class FlexFieldSchema<out TKind extends FlexFieldKind = FlexFieldKind> {
 	/**
 	 * Schema for a field which must always be empty.
 	 */
@@ -306,23 +235,10 @@ export class FlexFieldSchema<
 	 * @privateRemarks
 	 * Alias for the constructor, but with extends clause for the `Types` parameter that {@link FlexFieldSchema} can not have (due to recursive type issues).
 	 */
-	public static create<TKind extends FlexFieldKind, const Types extends FlexAllowedTypes>(
+	public static create<TKind extends FlexFieldKind>(
 		kind: TKind,
-		allowedTypes: Types,
-	): FlexFieldSchema<TKind, Types> {
-		return new FlexFieldSchema(kind, allowedTypes);
-	}
-
-	/**
-	 * Constructs a TreeFieldSchema, but missing the extends clause which breaks most recursive types.
-	 * @remarks
-	 * `Types` here must extend `AllowedTypes`, but this cannot be enforced with an "extends" clause: see {@link Unenforced} for details.
-	 * Prefer {@link FlexFieldSchema.create} when possible.
-	 */
-	public static createUnsafe<
-		TKind extends FlexFieldKind,
-		const Types extends Unenforced<FlexAllowedTypes>,
-	>(kind: TKind, allowedTypes: Types): FlexFieldSchema<TKind, Types> {
+		allowedTypes: FlexAllowedTypes,
+	): FlexFieldSchema<TKind> {
 		return new FlexFieldSchema(kind, allowedTypes);
 	}
 
@@ -344,14 +260,12 @@ export class FlexFieldSchema<
 	 */
 	private constructor(
 		public readonly kind: TKind,
-		public readonly allowedTypes: TTypes,
+		public readonly allowedTypes: FlexAllowedTypes,
 	) {
 		// Since this class can't have the desired extends clause, do some extra runtime validation:
 		assert(Array.isArray(allowedTypes), 0x7bc /* Invalid allowedTypes */);
 		for (const allowedType of allowedTypes) {
-			if (allowedType === Any) {
-				assert(allowedTypes.length === 1, 0x7bd /* Invalid Any in allowedTypes */);
-			} else if (typeof allowedType !== "function") {
+			if (typeof allowedType !== "function") {
 				assert(
 					allowedType instanceof TreeNodeSchemaBase,
 					0x7be /* Invalid entry in allowedTypes */,
@@ -365,7 +279,7 @@ export class FlexFieldSchema<
 			return {
 				names: allowedTypesToTypeSet(input),
 				schema,
-				monomorphicChildType: schema !== Any ? oneFromSet(schema) : undefined,
+				monomorphicChildType: oneFromSet(schema),
 			};
 		});
 
@@ -444,15 +358,12 @@ export class FlexFieldSchema<
  * See {@link TreeTypeSet} for a stored-schema compatible version using the {@link TreeNodeSchemaIdentifier}.
  * See {@link FlexAllowedTypes} for a compile time optimized version.
  */
-export type AllowedTypeSet = Any | ReadonlySet<FlexTreeNodeSchema>;
+export type AllowedTypeSet = ReadonlySet<FlexTreeNodeSchema>;
 
 /**
  * Convert {@link FlexAllowedTypes} to {@link TreeTypeSet}.
  */
 export function allowedTypesSchemaSet(t: FlexAllowedTypes): AllowedTypeSet {
-	if (allowedTypesIsAny(t)) {
-		return Any;
-	}
 	const list: FlexTreeNodeSchema[] = t.map((value: LazyItem<FlexTreeNodeSchema>) => {
 		if (typeof value === "function") {
 			return value();
@@ -467,9 +378,6 @@ export function allowedTypesSchemaSet(t: FlexAllowedTypes): AllowedTypeSet {
  */
 export function allowedTypesToTypeSet(t: FlexAllowedTypes): TreeTypeSet {
 	const list = allowedTypesSchemaSet(t);
-	if (list === Any) {
-		return undefined;
-	}
 	const names = Array.from(list, (type) => {
 		assert(type instanceof TreeNodeSchemaBase, 0x7bf /* invalid allowed type */);
 		return type.name;