@fluidframework/tree 2.50.0 → 2.51.0

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

@@ -3,30 +3,26 @@
  * Licensed under the MIT License.
  */
 
-import { unreachableCase, fail } from "@fluidframework/core-utils/internal";
+import { assert, unreachableCase } from "@fluidframework/core-utils/internal";
 
+import type { TreeStoredSchema } from "../../core/index.js";
 import {
-	AdaptedViewSchema,
-	type TreeNodeStoredSchema,
-	type Adapters,
-	type TreeFieldStoredSchema,
-	type TreeNodeSchemaIdentifier,
-	type TreeStoredSchema,
-} from "../../core/index.js";
-import {
+	allowsRepoSuperset,
 	FieldKinds,
 	type FullSchemaPolicy,
-	type FieldDiscrepancy,
-	getAllowedContentDiscrepancies,
 	isNeverTree,
-	PosetComparisonResult,
-	fieldRealizer,
-	comparePosetElements,
 } from "../../feature-libraries/index.js";
-import type { FieldSchema } from "../schemaTypes.js";
-import { toStoredSchema } from "../toStoredSchema.js";
+import type { FieldSchema } from "../fieldSchema.js";
 
 import type { SchemaCompatibilityStatus } from "./tree.js";
+import {
+	comparePosetElements,
+	fieldRealizer,
+	getAllowedContentDiscrepancies,
+	PosetComparisonResult,
+	type FieldDiscrepancy,
+} from "../discrepancies.js";
+import { toStoredSchema } from "../toStoredSchema.js";
 
 /**
  * A collection of View information for schema, including policy.
@@ -34,21 +30,13 @@ import type { SchemaCompatibilityStatus } from "./tree.js";
  * This contains everything needed to determine compatibility with a given stored schema.
  */
 export class SchemaCompatibilityTester {
-	/**
-	 * Cached conversion of the view schema in the stored schema format.
-	 */
-	public readonly viewSchemaAsStored: TreeStoredSchema;
-
 	/**
 	 * @param viewSchemaRoot - Schema for the root field.
 	 */
 	public constructor(
 		public readonly policy: FullSchemaPolicy,
-		public readonly adapters: Adapters,
-		viewSchemaRoot: FieldSchema,
-	) {
-		this.viewSchemaAsStored = toStoredSchema(viewSchemaRoot);
-	}
+		public readonly viewSchemaRoot: FieldSchema,
+	) {}
 
 	/**
 	 * Determines the compatibility of a stored document
@@ -63,9 +51,6 @@ export class SchemaCompatibilityTester {
 	public checkCompatibility(
 		stored: TreeStoredSchema,
 	): Omit<SchemaCompatibilityStatus, "canInitialize"> {
-		// TODO: support adapters
-		// const adapted = this.adaptRepo(stored);
-
 		// View schema allows a subset of documents that stored schema does, and the discrepancies are allowed by policy
 		// determined by the view schema (i.e. objects with extra optional fields in the stored schema have opted into allowing this.
 		// In the future, this would also include things like:
@@ -92,16 +77,7 @@ export class SchemaCompatibilityTester {
 						canView = false;
 					}
 
-					if (
-						discrepancy.view.some(
-							(identifier) =>
-								!isNeverTree(
-									this.policy,
-									this.viewSchemaAsStored,
-									this.viewSchemaAsStored.nodeSchema.get(identifier),
-								),
-						)
-					) {
+					if (discrepancy.view.length > 0) {
 						// View schema has extra allowed types that the stored schema does not.
 						canView = false;
 					}
@@ -151,32 +127,24 @@ export class SchemaCompatibilityTester {
 			}
 		};
 
-		for (const discrepancy of getAllowedContentDiscrepancies(
-			this.viewSchemaAsStored,
-			stored,
-		)) {
+		for (const discrepancy of getAllowedContentDiscrepancies(this.viewSchemaRoot, stored)) {
 			if (!canView && !canUpgrade) {
 				break;
 			}
 
 			switch (discrepancy.mismatch) {
 				case "nodeKind": {
-					const viewNodeSchema = this.viewSchemaAsStored.nodeSchema.get(
-						discrepancy.identifier,
-					);
 					const storedNodeSchema = stored.nodeSchema.get(discrepancy.identifier);
 					// We conservatively do not allow node types to change.
 					// The only time this might be valid in the sense that the data canonically converts is converting an object node
 					// to a map node over the union of all the object fields' types.
 					if (discrepancy.stored === undefined) {
-						const viewIsNever =
-							viewNodeSchema !== undefined
-								? isNeverTree(this.policy, this.viewSchemaAsStored, viewNodeSchema)
-								: true;
-						if (!viewIsNever) {
-							// View schema has added a node type that the stored schema doesn't know about.
-							canView = false;
-						}
+						// View schema has added a node type that the stored schema doesn't know about.
+						// Note that all cases which trigger this should also trigger an AllowedTypeDiscrepancy (where the type is used).
+						// This means this case should be redundant and could be removed in the future if there is a reason to do so
+						// (like simplifying enablable type support).
+						// See the TODO in getAllowedContentDiscrepancies.
+						canView = false;
 					} else if (discrepancy.view === undefined) {
 						const storedIsNever =
 							storedNodeSchema !== undefined
@@ -184,22 +152,18 @@ export class SchemaCompatibilityTester {
 								: true;
 						if (!storedIsNever) {
 							// Stored schema has a node type that the view schema doesn't know about.
+							// The design of allowUnknownOptionalFields allows adding new optional content to types,
+							// and the new optional content can use new types.
+							// Therefore this case needs to be supported for viewing.
+							// However, it is not supported for upgrade as the stored document must be newer (or at least more general) than the view in this case.
+							// The fact that there might be removed trees with a root of this type which only appears in the stored schema is why this must set canUpgrade to false.
 							canUpgrade = false;
 						}
 					} else {
-						// Node type exists in both schemas but has changed. We conservatively never allow this.
-						const storedIsNever =
-							storedNodeSchema !== undefined
-								? isNeverTree(this.policy, stored, storedNodeSchema)
-								: true;
-						const viewIsNever =
-							viewNodeSchema !== undefined
-								? isNeverTree(this.policy, this.viewSchemaAsStored, viewNodeSchema)
-								: true;
-						if (!storedIsNever || !viewIsNever) {
-							canView = false;
-							canUpgrade = false;
-						}
+						// Node type exists in both schemas but kind has changed. We conservatively never allow this.
+						// See note above about cases where this could be allowed if needed.
+						canView = false;
+						canUpgrade = false;
 					}
 					break;
 				}
@@ -217,71 +181,17 @@ export class SchemaCompatibilityTester {
 			}
 		}
 
+		if (canUpgrade) {
+			assert(
+				allowsRepoSuperset(this.policy, stored, toStoredSchema(this.viewSchemaRoot)),
+				0xbf2 /* View schema must be a superset of the stored schema to allow upgrade */,
+			);
+		}
+
 		return {
 			canView,
 			canUpgrade,
 			isEquivalent: canView && canUpgrade,
 		};
 	}
-
-	/**
-	 * Compute a schema that `original` could be viewed as using adapters as needed.
-	 *
-	 * TODO: have a way for callers to get invalidated on schema updates.
-	 */
-	public adaptRepo(stored: TreeStoredSchema): AdaptedViewSchema {
-		// Sanity check on adapters:
-		// it's probably a bug if they use the never types,
-		// since there never is a reason to have a never type as an adapter input,
-		// and its impossible for an adapter to be correctly implemented if its output type is never
-		// (unless its input is also never).
-
-		for (const adapter of this.adapters?.tree ?? []) {
-			if (
-				isNeverTree(
-					this.policy,
-					this.viewSchemaAsStored,
-					this.viewSchemaAsStored.nodeSchema.get(adapter.output),
-				)
-			) {
-				fail(0xb3d /* tree adapter for stored adapter.output should not be never */);
-			}
-		}
-
-		const adapted = {
-			rootFieldSchema: this.adaptField(stored.rootFieldSchema),
-			nodeSchema: new Map<TreeNodeSchemaIdentifier, TreeNodeStoredSchema>(),
-		};
-
-		for (const [key, schema] of stored.nodeSchema) {
-			const adapatedTree = this.adaptTree(schema);
-			adapted.nodeSchema.set(key, adapatedTree);
-		}
-
-		// TODO: subset these adapters to the ones that were needed/used.
-		return new AdaptedViewSchema(this.adapters, adapted);
-	}
-
-	/**
-	 * Adapt original such that it allows member types which can be adapted to its specified types.
-	 */
-	private adaptField(original: TreeFieldStoredSchema): TreeFieldStoredSchema {
-		if (original.types !== undefined) {
-			const types: Set<TreeNodeSchemaIdentifier> = new Set(original.types);
-			for (const treeAdapter of this.adapters?.tree ?? []) {
-				if (types.has(treeAdapter.input)) {
-					types.delete(treeAdapter.input);
-					types.add(treeAdapter.output);
-				}
-			}
-
-			return { kind: original.kind, types, persistedMetadata: undefined };
-		}
-		return original;
-	}
-
-	private adaptTree(original: TreeNodeStoredSchema): TreeNodeStoredSchema {
-		// TODO: support adapters like missing field adapters.
-		return original;
-	}
 }

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

@@ -4,11 +4,11 @@
  */
 
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
-import { fail } from "@fluidframework/core-utils/internal";
+import { assert, fail } from "@fluidframework/core-utils/internal";
 
 import type { SchemaFactory, ScopedSchemaName } from "./schemaFactory.js";
-import type { NodeFromSchema } from "../schemaTypes.js";
 import type {
+	NodeFromSchema,
 	InternalTreeNode,
 	NodeKind,
 	TreeNode,
@@ -47,6 +47,12 @@ export function singletonSchema<TScope extends string, TName extends string | nu
 		public get value(): TName {
 			return name;
 		}
+
+		public static override toString(): string {
+			return `SingletonSchema(${name})`;
+		}
+
+		public static [Symbol.toStringTag] = `SingletonSchema(${name})`;
 	}
 
 	type SingletonNodeType = TreeNode & { readonly value: TName };
@@ -71,10 +77,16 @@ export function singletonSchema<TScope extends string, TName extends string | nu
 
 /**
  * Converts an enum into a collection of schema which can be used in a union.
+ *
+ * @typeParam TScope - The scope of the provided factory.
+ * There is a known issue where if a factory is provided that is typed as a {@link SchemaFactoryAlpha}, and its scope contains a "." character,
+ * the inferred type for the scope will end up as a union of the scope up to the first "." character and the scope as it should be.
+ * This can be mitigated by explicitly providing the TScope type parameter or by typing the provided factory as a {@link SchemaFactory} instead of a {@link SchemaFactoryAlpha}.
+ *
  * @remarks
  * The string value of the enum is used as the name of the schema: callers must ensure that it is stable and unique.
  * Numeric enums values have the value implicitly converted into a string.
- * Consider making a dedicated schema factory with a nested scope to avoid the enum members colliding with other schema.
+ * Consider making a dedicated schema factory with a nested scope (for example using {@link SchemaFactoryAlpha.scopedFactory}) to avoid the enum members colliding with other schema.
  * @example
  * ```typescript
  * const schemaFactory = new SchemaFactory("com.myApp");
@@ -105,7 +117,8 @@ export function singletonSchema<TScope extends string, TName extends string | nu
  * }
  * ```
  * @privateRemarks
- * Maybe provide `SchemaFactory.nested` to ease creating nested scopes?
+ * TODO: AB#43345: see TScope known issue above, and other references to this work item.
+ *
  * @see {@link enumFromStrings} for a similar function that works on arrays of strings instead of an enum.
  * @beta
  */
@@ -144,7 +157,7 @@ export function adaptEnum<
 			: never;
 	};
 	const out = factoryOut as typeof factoryOut & TOut & { readonly schema: SchemaArray };
-	for (const [key, value] of Object.entries(members)) {
+	for (const [key, value] of enumEntries(members)) {
 		const schema = singletonSchema(factory, value);
 		schemaArray.push(schema);
 		Object.defineProperty(out, key, {
@@ -165,6 +178,38 @@ export function adaptEnum<
 	return out;
 }
 
+/**
+ * Returns en "entries" (like Object.entries) for an enum object, omitting the
+ * {@link https://www.typescriptlang.org/docs/handbook/enums.html#reverse-mappings|reverse mappings}
+ */
+export function enumEntries(
+	enumObject: Record<string, string | number>,
+): [string, string | number][] {
+	// Skip reverse mapping for numeric entries.
+	// For numeric entries, TypeScript defines an additional property keyed with the number implicitly converted to a string.
+	// Note TypeScript can overwrite its own enum entries in some edge cases (see https://github.com/microsoft/TypeScript/issues/48956), so it's not possible to handle all cases correctly.
+	return Object.entries(enumObject).filter(([key, value]) => {
+		// All reverse mapping must also have a inverse mapping (the regular forward mapping) to a number:
+		const inverse = enumObject[value];
+		if (typeof inverse !== "number") {
+			// Known not to be a reverse mapping, so keep it.
+			return true;
+		}
+		// At this point, it is expected that all remaining cases are reverse mappings,
+		// but do some asserts to ensure that the above logic is sufficient.
+		assert(
+			typeof value === "string",
+			0xbe4 /* expected reverse mapping and thus a string value */,
+		);
+		assert(
+			Number.parseFloat(key).toString() === key,
+			0xbe5 /* expected reverse mapping and thus a key that is a normalized number */,
+		);
+		// Discard the reverse mapping.
+		return false;
+	});
+}
+
 /**
  * Converts an array of distinct strings into a collection of schema which can be used like an enum style union.
  * @remarks

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

@@ -13,11 +13,13 @@ import type { TreeValue } from "../../core/index.js";
 // eslint-disable-next-line unused-imports/no-unused-imports, @typescript-eslint/no-unused-vars
 import type { TreeAlpha } from "../../shared-tree/index.js";
 import {
+	type JsonCompatibleReadOnlyObject,
 	type RestrictiveStringRecord,
 	compareSets,
 	getOrCreate,
 	isReadonlyArray,
 } from "../../util/index.js";
+import { normalizeAllowedTypes, markSchemaMostDerived, isLazy } from "../core/index.js";
 import type {
 	NodeKind,
 	WithType,
@@ -26,8 +28,12 @@ import type {
 	TreeNodeSchemaNonClass,
 	TreeNodeSchemaBoth,
 	UnhydratedFlexTreeNode,
+	NodeSchemaMetadata,
+	ImplicitAnnotatedAllowedTypes,
+	UnannotateImplicitAllowedTypes,
+	ImplicitAllowedTypes,
+	InsertableTreeNodeFromImplicitAllowedTypes,
 } from "../core/index.js";
-import { isLazy } from "../flexList.js";
 import {
 	booleanSchema,
 	handleSchema,
@@ -45,26 +51,19 @@ import {
 	type InsertableObjectFromSchemaRecord,
 	type TreeMapNode,
 	type TreeObjectNode,
+	type UnannotateSchemaRecord,
 } from "../node-kinds/index.js";
 import {
 	FieldKind,
 	type FieldSchema,
-	type ImplicitAllowedTypes,
 	type ImplicitFieldSchema,
-	type InsertableTreeNodeFromImplicitAllowedTypes,
 	type FieldProps,
 	createFieldSchema,
 	type DefaultProvider,
 	getDefaultProvider,
-	markSchemaMostDerived,
 	type FieldSchemaAlpha,
-	type ImplicitAnnotatedAllowedTypes,
-	type UnannotateImplicitAllowedTypes,
-	type UnannotateSchemaRecord,
-	type NodeSchemaOptionsAlpha,
-	normalizeAllowedTypes,
 	type FieldPropsAlpha,
-} from "../schemaTypes.js";
+} from "../fieldSchema.js";
 
 import { createFieldSchemaUnsafe } from "./schemaFactoryRecursive.js";
 import type { System_Unsafe, FieldSchemaAlphaUnsafe } from "./typesUnsafe.js";
@@ -1312,3 +1311,39 @@ export function structuralName<const T extends string>(
  * Using this is only better than creating fully random V4 UUIDs because it reduces the entropy making it possible for things like text compression to work slightly better.
  */
 const globalIdentifierAllocator: IIdCompressor = createIdCompressor();
+
+/**
+ * Additional information to provide to Node Schema creation.
+ *
+ * @typeParam TCustomMetadata - Custom metadata properties to associate with the Node Schema.
+ * See {@link NodeSchemaMetadata.custom}.
+ *
+ * @sealed
+ * @public
+ */
+export interface NodeSchemaOptions<out TCustomMetadata = unknown> {
+	/**
+	 * Optional metadata to associate with the Node Schema.
+	 *
+	 * @remarks
+	 * Note: this metadata is not persisted nor made part of the collaborative state; it is strictly client-local.
+	 * Different clients in the same collaborative session may see different metadata for the same field.
+	 */
+	readonly metadata?: NodeSchemaMetadata<TCustomMetadata> | undefined;
+}
+
+/**
+ * Additional information to provide to Node Schema creation. Includes fields for alpha features.
+ *
+ * @typeParam TCustomMetadata - Custom metadata properties to associate with the Node Schema.
+ * See {@link NodeSchemaMetadata.custom}.
+ *
+ * @alpha
+ */
+export interface NodeSchemaOptionsAlpha<out TCustomMetadata = unknown>
+	extends NodeSchemaOptions<TCustomMetadata> {
+	/**
+	 * The persisted metadata for this schema element.
+	 */
+	readonly persistedMetadata?: JsonCompatibleReadOnlyObject | undefined;
+}

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

@@ -20,16 +20,11 @@ import {
 	SchemaFactory,
 	schemaStatics,
 	structuralName,
+	type NodeSchemaOptionsAlpha,
 	type SchemaFactoryObjectOptions,
 	type ScopedSchemaName,
 } from "./schemaFactory.js";
-import type {
-	ImplicitAllowedTypes,
-	ImplicitAnnotatedAllowedTypes,
-	ImplicitAnnotatedFieldSchema,
-	ImplicitFieldSchema,
-	NodeSchemaOptionsAlpha,
-} from "../schemaTypes.js";
+import type { ImplicitAnnotatedFieldSchema, ImplicitFieldSchema } from "../fieldSchema.js";
 import type { RestrictiveStringRecord } from "../../util/index.js";
 import type {
 	NodeKind,
@@ -38,6 +33,8 @@ import type {
 	TreeNodeSchemaClass,
 	TreeNodeSchemaNonClass,
 	WithType,
+	ImplicitAllowedTypes,
+	ImplicitAnnotatedAllowedTypes,
 } from "../core/index.js";
 import type {
 	ArrayNodeCustomizableSchemaUnsafe,

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

@@ -4,16 +4,21 @@
  */
 
 import type { RestrictiveStringRecord } from "../../util/index.js";
-import type { NodeKind, TreeNodeSchema, WithType, TreeNode } from "../core/index.js";
+import type {
+	NodeKind,
+	TreeNodeSchema,
+	WithType,
+	TreeNode,
+	ImplicitAllowedTypes,
+	InsertableTreeNodeFromImplicitAllowedTypes,
+} from "../core/index.js";
 import type { InsertableObjectFromSchemaRecord } from "../node-kinds/index.js";
 import {
 	type FieldKind,
 	type FieldProps,
 	createFieldSchema,
-	type ImplicitAllowedTypes,
 	type ImplicitFieldSchema,
-	type InsertableTreeNodeFromImplicitAllowedTypes,
-} from "../schemaTypes.js";
+} from "../fieldSchema.js";
 
 import type { FieldSchemaAlphaUnsafe, System_Unsafe } from "./typesUnsafe.js";
 

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

@@ -5,14 +5,13 @@
 
 import { unreachableCase, fail } from "@fluidframework/core-utils/internal";
 
-import { NodeKind, type TreeNodeSchema } from "../core/index.js";
+import { NodeKind, type TreeNodeSchema, type AllowedTypes } from "../core/index.js";
 import {
 	type FieldSchema,
-	type AllowedTypes,
 	type FieldSchemaAlpha,
 	FieldKind,
 	type FieldProps,
-} from "../schemaTypes.js";
+} from "../fieldSchema.js";
 import type {
 	SimpleFieldSchema,
 	SimpleNodeSchema,

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

@@ -20,7 +20,7 @@ import type {
 	JsonLeafSchemaType,
 	JsonRecordNodeSchema,
 } from "./jsonSchema.js";
-import { FieldKind } from "../schemaTypes.js";
+import { FieldKind } from "../fieldSchema.js";
 import type {
 	SimpleArrayNodeSchema,
 	SimpleLeafNodeSchema,

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

@@ -20,8 +20,13 @@ import {
 	type KeyFinder,
 } from "../../feature-libraries/index.js";
 import { brand } from "../../util/index.js";
-import type { ImplicitFieldSchema, NodeFromSchema } from "../schemaTypes.js";
-import { treeNodeFromAnchor, type TreeNode, type TreeNodeSchema } from "../core/index.js";
+import type { ImplicitFieldSchema } from "../fieldSchema.js";
+import {
+	treeNodeFromAnchor,
+	type TreeNode,
+	type TreeNodeSchema,
+	type NodeFromSchema,
+} from "../core/index.js";
 import { treeNodeApi } from "./treeNodeApi.js";
 import type { TreeView } from "./tree.js";
 import { walkFieldSchema } from "../walkFieldSchema.js";
@@ -180,7 +185,7 @@ export function createSimpleTreeIndex<
 				};
 
 	const index = new AnchorTreeIndex<TKey, TValue>(
-		(view as SchematizingSimpleTreeView<TFieldSchema>).getView().checkout.forest,
+		(view as SchematizingSimpleTreeView<TFieldSchema>).checkout.forest,
 		schemaIndexer,
 		(anchorNodes) => {
 			const simpleTreeNodes: TreeNode[] = [];

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

@@ -16,7 +16,7 @@ import {
 	// eslint-disable-next-line import/no-internal-modules
 } from "../../feature-libraries/schema-index/index.js";
 import type { JsonCompatible } from "../../util/index.js";
-import { normalizeFieldSchema, type ImplicitFieldSchema } from "../schemaTypes.js";
+import { normalizeFieldSchema, type ImplicitFieldSchema } from "../fieldSchema.js";
 import type { SimpleTreeSchema } from "../simpleSchema.js";
 import { simpleToStoredSchema } from "../toStoredSchema.js";
 
@@ -103,7 +103,6 @@ export function comparePersistedSchema(
 	const stored = schemaCodec.decode(persisted as FormatV1);
 	const viewSchema = new SchemaCompatibilityTester(
 		defaultSchemaPolicy,
-		{},
 		normalizeFieldSchema(view),
 	);
 	return viewSchema.checkCompatibility(stored);

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

@@ -22,8 +22,8 @@ import type {
 	ReadableField,
 	ReadSchema,
 	TreeFieldFromImplicitField,
-	UnsafeUnknownSchema,
-} from "../schemaTypes.js";
+} from "../fieldSchema.js";
+import type { UnsafeUnknownSchema } from "../unsafeUnknownSchema.js";
 import type { SimpleTreeSchema } from "../simpleSchema.js";
 
 import type { TreeViewConfiguration } from "./configuration.js";

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

@@ -11,7 +11,7 @@ import {
 	type Unhydrated,
 	type WithType,
 } from "../core/index.js";
-import type { ImplicitFieldSchema, TreeFieldFromImplicitField } from "../schemaTypes.js";
+import type { ImplicitFieldSchema, TreeFieldFromImplicitField } from "../fieldSchema.js";
 
 import { createFromCursor } from "./create.js";
 import type { TreeChangeEvents } from "./treeChangeEvents.js";
@@ -127,6 +127,9 @@ export interface TreeBeta {
 	 * - Value node types (i.e., numbers, strings, booleans, nulls and Fluid handles) will be returned as is.
 	 *
 	 * - The identifiers in the node's subtree will be preserved, i.e., they are not replaced with new values.
+	 *
+	 * @privateRemarks
+	 * TODO: AB#43548: How this handles unknown optional fields needs to be figured out, tested and documented.
 	 */
 	clone<const TSchema extends ImplicitFieldSchema>(
 		node: TreeFieldFromImplicitField<TSchema>,

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

@@ -8,14 +8,7 @@ import { assert, oob, fail, unreachableCase } from "@fluidframework/core-utils/i
 import { EmptyKey, rootFieldKey } from "../../core/index.js";
 import { type TreeStatus, isTreeValue, FieldKinds } from "../../feature-libraries/index.js";
 import { extractFromOpaque } from "../../util/index.js";
-import {
-	type TreeLeafValue,
-	type ImplicitFieldSchema,
-	FieldSchema,
-	type ImplicitAllowedTypes,
-	type TreeNodeFromImplicitAllowedTypes,
-	normalizeAllowedTypes,
-} from "../schemaTypes.js";
+import { type ImplicitFieldSchema, FieldSchema } from "../fieldSchema.js";
 import {
 	booleanSchema,
 	handleSchema,
@@ -36,6 +29,10 @@ import {
 	getOrCreateNodeFromInnerNode,
 	typeSchemaSymbol,
 	getOrCreateInnerNode,
+	type TreeLeafValue,
+	type ImplicitAllowedTypes,
+	type TreeNodeFromImplicitAllowedTypes,
+	normalizeAllowedTypes,
 } from "../core/index.js";
 import type { TreeChangeEvents } from "./treeChangeEvents.js";
 import { isArrayNodeSchema, isObjectNodeSchema } from "../node-kinds/index.js";

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

@@ -15,9 +15,7 @@ import type {
 	FieldKind,
 	FieldSchema,
 	FieldSchemaAlpha,
-	ImplicitAllowedTypes,
-	TreeLeafValue,
-} from "../schemaTypes.js";
+} from "../fieldSchema.js";
 import type {
 	NodeKind,
 	WithType,
@@ -27,9 +25,12 @@ import type {
 	TreeNodeSchema,
 	TreeNodeSchemaCore,
 	TreeNodeSchemaClass,
+	ImplicitAllowedTypes,
+	TreeLeafValue,
+	FlexListToUnion,
+	LazyItem,
 } from "../core/index.js";
 import type { TreeArrayNode } from "../node-kinds/index.js";
-import type { FlexListToUnion, LazyItem } from "../flexList.js";
 import type { SimpleArrayNodeSchema, SimpleMapNodeSchema } from "../simpleSchema.js";
 
 /*

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

@@ -17,12 +17,9 @@ import {
 	type ITreeCursorSynchronous,
 } from "../../core/index.js";
 import { brand } from "../../util/index.js";
-import type {
-	TreeLeafValue,
-	ImplicitFieldSchema,
-	ImplicitAllowedTypes,
-} from "../schemaTypes.js";
-import { NodeKind, type TreeNodeSchema } from "../core/index.js";
+import type { ImplicitFieldSchema } from "../fieldSchema.js";
+import { NodeKind } from "../core/index.js";
+import type { TreeNodeSchema, ImplicitAllowedTypes, TreeLeafValue } from "../core/index.js";
 import {
 	isTreeValue,
 	stackTreeFieldCursor,

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

@@ -4,7 +4,7 @@
  */
 
 import { assert, unreachableCase } from "@fluidframework/core-utils/internal";
-import { normalizeFieldSchema, type ImplicitFieldSchema } from "../schemaTypes.js";
+import { normalizeFieldSchema, type ImplicitFieldSchema } from "../fieldSchema.js";
 import type {
 	SimpleArrayNodeSchema,
 	SimpleFieldSchema,