@fluidframework/tree 2.50.0-345060 → 2.51.0-347100

package/src/shared-tree-core/sharedTreeCore.ts

@@ -397,14 +397,12 @@ export class SharedTreeCore<TEditor extends ChangeFamilyEditor, TChange>
 		} = this.messageCodec.decode(this.serializer.decode(content), {
 			idCompressor: this.idCompressor,
 		});
-		const [commit] = this.editManager.findLocalCommit(revision);
 		// If a resubmit phase is not already in progress, then this must be the first commit of a new resubmit phase.
 		if (this.resubmitMachine.isInResubmitPhase === false) {
-			const toResubmit = this.editManager.getLocalCommits();
-			assert(
-				commit === toResubmit[0],
-				0x95d /* Resubmit phase should start with the oldest local commit */,
-			);
+			const localCommits = this.editManager.getLocalCommits();
+			const revisionIndex = localCommits.findIndex((c) => c.revision === revision);
+			assert(revisionIndex >= 0, 0xbdb /* revision must exist in local commits */);
+			const toResubmit = localCommits.slice(revisionIndex);
 			this.resubmitMachine.prepareForResubmit(toResubmit);
 		}
 		assert(
@@ -418,6 +416,20 @@ export class SharedTreeCore<TEditor extends ChangeFamilyEditor, TChange>
 		const enrichedCommit = this.resubmitMachine.peekNextCommit();
 		this.submitCommit(enrichedCommit, localOpMetadata, true);
 	}
+	public rollback(content: JsonCompatibleReadOnly, localOpMetadata: unknown): void {
+		// Empty context object is passed in, as our decode function is schema-agnostic.
+		const {
+			commit: { revision },
+		} = this.messageCodec.decode(this.serializer.decode(content), {
+			idCompressor: this.idCompressor,
+		});
+		const [commit] = this.editManager.findLocalCommit(revision);
+		const { parent } = commit;
+		assert(parent !== undefined, 0xbdc /* must have parent */);
+		const [precedingCommit] = this.editManager.findLocalCommit(parent.revision);
+		this.editManager.localBranch.removeAfter(precedingCommit);
+		this.resubmitMachine.onCommitRollback(commit);
+	}
 
 	public applyStashedOp(content: JsonCompatibleReadOnly): void {
 		// Empty context object is passed in, as our decode function is schema-agnostic.

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

@@ -6,9 +6,8 @@
 import type { IFluidHandle } from "@fluidframework/core-interfaces";
 
 import type { ITreeCursor } from "../../core/index.js";
-import type { TreeNodeSchema } from "../core/index.js";
+import type { TreeNodeSchema, TreeLeafValue, ImplicitAllowedTypes } from "../core/index.js";
 import { getUnhydratedContext } from "../createContext.js";
-import type { TreeLeafValue, ImplicitAllowedTypes } from "../schemaTypes.js";
 
 import {
 	customFromCursor,

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

@@ -15,13 +15,16 @@ import { UsageError } from "@fluidframework/telemetry-utils/internal";
 import {
 	type FieldSchemaAlpha,
 	type ImplicitFieldSchema,
-	evaluateLazySchema,
 	FieldKind,
+	normalizeFieldSchema,
+} from "../fieldSchema.js";
+import {
+	NodeKind,
+	type TreeNodeSchema,
 	isAnnotatedAllowedType,
+	evaluateLazySchema,
 	markSchemaMostDerived,
-	normalizeFieldSchema,
-} from "../schemaTypes.js";
-import { NodeKind, type TreeNodeSchema } from "../core/index.js";
+} from "../core/index.js";
 import { toStoredSchema } from "../toStoredSchema.js";
 import {
 	isArrayNodeSchema,
@@ -327,7 +330,7 @@ export function checkUnion(
 				break;
 			}
 			case NodeKind.Object: {
-				assert(isObjectNodeSchema(schema), "Expected object schema.");
+				assert(isObjectNodeSchema(schema), 0xbde /* Expected object schema. */);
 				objects.push(schema);
 				for (const key of schema.fields.keys()) {
 					getOrCreate(allObjectKeys, key, () => new Set()).add(schema);
@@ -335,17 +338,17 @@ export function checkUnion(
 				break;
 			}
 			case NodeKind.Array: {
-				assert(isArrayNodeSchema(schema), "Expected array schema.");
+				assert(isArrayNodeSchema(schema), 0xbdf /* Expected array schema. */);
 				arrays.push(schema);
 				break;
 			}
 			case NodeKind.Map: {
-				assert(isMapNodeSchema(schema), "Expected map schema.");
+				assert(isMapNodeSchema(schema), 0xbe0 /* Expected map schema. */);
 				maps.push(schema);
 				break;
 			}
 			case NodeKind.Record: {
-				assert(isRecordNodeSchema(schema), "Expected record schema.");
+				assert(isRecordNodeSchema(schema), 0xbe1 /* Expected record schema. */);
 				records.push(schema);
 				break;
 			}

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

@@ -12,7 +12,7 @@ import {
 	type ITreeCursorSynchronous,
 	type SchemaAndPolicy,
 } from "../../core/index.js";
-import type { ImplicitFieldSchema, TreeFieldFromImplicitField } from "../schemaTypes.js";
+import type { ImplicitFieldSchema, TreeFieldFromImplicitField } from "../fieldSchema.js";
 import {
 	type Context,
 	getOrCreateNodeFromInnerNode,
@@ -37,6 +37,8 @@ import { unknownTypeError } from "./customTree.js";
  * @remarks
  * Does not support defaults.
  * Validates the field is in schema.
+ *
+ * TODO: AB#43548: How this handles unknown optional fields needs to be figured out, tested and documented.
  */
 export function createFromCursor<const TSchema extends ImplicitFieldSchema>(
 	schema: TSchema,

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

@@ -22,7 +22,7 @@ import {
 } from "../../core/index.js";
 import { FieldKinds, valueSchemaAllows } from "../../feature-libraries/index.js";
 import { cloneWithReplacements } from "../../util/index.js";
-import type { TreeNodeSchema } from "../core/index.js";
+import type { TreeNodeSchema, TreeLeafValue } from "../core/index.js";
 import {
 	booleanSchema,
 	handleSchema,
@@ -31,7 +31,6 @@ import {
 	stringSchema,
 } from "../leafNodeSchema.js";
 import { isArrayNodeSchema, isObjectNodeSchema } from "../node-kinds/index.js";
-import type { TreeLeafValue } from "../schemaTypes.js";
 
 /**
  * Options for how to interpret or encode a tree when schema information is available.

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

@@ -4,7 +4,7 @@
  */
 
 import type { JsonTreeSchema } from "./jsonSchema.js";
-import type { ImplicitAllowedTypes } from "../schemaTypes.js";
+import type { ImplicitAllowedTypes } from "../core/index.js";
 import { toJsonSchema } from "./simpleSchemaToJsonSchema.js";
 import type { TreeEncodingOptions } from "./customTree.js";
 import { TreeViewConfigurationAlpha } from "./configuration.js";

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

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import type { ImplicitFieldSchema } from "../schemaTypes.js";
+import type { ImplicitFieldSchema } from "../fieldSchema.js";
 import type { SimpleTreeSchema } from "../simpleSchema.js";
 
 import { toSimpleTreeSchema } from "./viewSchemaToSimpleSchema.js";

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

@@ -5,7 +5,7 @@
 
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 import type { TreeIndexKey } from "../../feature-libraries/index.js";
-import { FieldKind, type ImplicitFieldSchema } from "../schemaTypes.js";
+import { FieldKind, type ImplicitFieldSchema } from "../fieldSchema.js";
 import type { TreeNode } from "../core/index.js";
 import { ObjectNodeSchema } from "../node-kinds/index.js";
 import type { TreeView } from "./tree.js";

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

@@ -30,6 +30,8 @@ export {
 	type SchemaFactoryObjectOptions,
 	type SchemaStatics,
 	schemaStatics,
+	type NodeSchemaOptions,
+	type NodeSchemaOptionsAlpha,
 } from "./schemaFactory.js";
 export { SchemaFactoryAlpha } from "./schemaFactoryAlpha.js";
 export type {

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

@@ -23,7 +23,7 @@ import {
 	fieldRealizer,
 	comparePosetElements,
 } from "../../feature-libraries/index.js";
-import type { FieldSchema } from "../schemaTypes.js";
+import type { FieldSchema } from "../fieldSchema.js";
 import { toStoredSchema } from "../toStoredSchema.js";
 
 import type { SchemaCompatibilityStatus } from "./tree.js";

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,35 @@ 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", "expected reverse mapping and thus a string value");
+		assert(
+			Number.parseFloat(key).toString() === key,
+			"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";
 

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,

package/src/simple-tree/core/README.md

@@ -8,4 +8,4 @@ This specifically does not contain any logic specific to field kinds or node kin
 ## Status
 
 More content should be moved into this directory as its disentangled from node kind specific logic.
-`proxyBinding.ts` is a good candidate to work toward moving here to.
+