@fluidframework/tree 2.33.2 → 2.40.0

package/src/shared-tree/{treeApiAlpha.ts → treeAlpha.ts}

@@ -34,8 +34,8 @@ import {
 	type VerboseTree,
 	toStoredSchema,
 	extractPersistedSchema,
-	TreeViewConfiguration,
 	type TreeBranch,
+	TreeViewConfigurationAlpha,
 } from "../simple-tree/index.js";
 import type { JsonCompatible } from "../util/index.js";
 import { noopValidator, type FluidClientVersion, type ICodecOptions } from "../codec/index.js";
@@ -52,12 +52,15 @@ import {
 } from "../feature-libraries/index.js";
 import { independentInitializedView, type ViewContent } from "./independentView.js";
 import { SchematizingSimpleTreeView, ViewSlot } from "./schematizingTreeView.js";
+import { currentVersion } from "../codec/index.js";
 
 /**
- * Extensions to {@link Tree} and {@link TreeBeta} which are not yet stable.
- * @sealed @alpha
+ * Extensions to {@link (Tree:interface)} and {@link (TreeBeta:interface)} which are not yet stable.
+ * @remarks
+ * Use via the {@link (TreeAlpha:variable)} singleton.
+ * @system @sealed @alpha
  */
-export const TreeAlpha: {
+export interface TreeAlpha {
 	/**
 	 * Retrieve the {@link TreeBranch | branch}, if any, for the given node.
 	 * @param node - The node to query
@@ -79,7 +82,7 @@ export const TreeAlpha: {
 	 * such as when `undefined` might be allowed (for an optional field), or when the type should be inferred from the data when more than one type is possible.
 	 *
 	 * Like with {@link TreeNodeSchemaClass}'s constructor, it's an error to provide an existing node to this API.
-	 * For that case, use {@link TreeBeta.clone}.
+	 * For that case, use {@link (TreeBeta:interface).clone}.
 	 * @privateRemarks
 	 * There should be a way to provide a source for defaulted identifiers, wither via this API or some way to add them to its output later.
 	 */
@@ -95,7 +98,7 @@ export const TreeAlpha: {
 	>;
 
 	/**
-	 * Less type safe version of {@link TreeAlpha.create}, suitable for importing data.
+	 * Less type safe version of {@link (TreeAlpha:interface).create}, suitable for importing data.
 	 * @remarks
 	 * Due to {@link ConciseTree} relying on type inference from the data, its use is somewhat limited.
 	 * This does not support {@link ConciseTree|ConciseTrees} with customized handle encodings or using persisted keys.
@@ -103,8 +106,8 @@ export const TreeAlpha: {
 	 *
 	 * When using this function,
 	 * it is recommend to ensure your schema is unambiguous with {@link ITreeConfigurationOptions.preventAmbiguity}.
-	 * If the schema is ambiguous, consider using {@link TreeAlpha.create} and {@link Unhydrated} nodes where needed,
-	 * or using {@link TreeAlpha.(importVerbose:1)} and specify all types.
+	 * If the schema is ambiguous, consider using {@link (TreeAlpha:interface).create} and {@link Unhydrated} nodes where needed,
+	 * or using {@link (TreeAlpha:interface).(importVerbose:1)} and specify all types.
 	 *
 	 * Documented (and thus recoverable) error handling/reporting for this is not yet implemented,
 	 * but for now most invalid inputs will throw a recoverable error.
@@ -123,7 +126,7 @@ export const TreeAlpha: {
 	/**
 	 * Construct tree content compatible with a field defined by the provided `schema`.
 	 * @param schema - The schema for what to construct. As this is an {@link ImplicitFieldSchema}, a {@link FieldSchema}, {@link TreeNodeSchema} or {@link AllowedTypes} array can be provided.
-	 * @param data - The data used to construct the field content. See {@link TreeAlpha.(exportVerbose:1)}.
+	 * @param data - The data used to construct the field content. See {@link (TreeAlpha:interface).(exportVerbose:1)}.
 	 */
 	importVerbose<const TSchema extends ImplicitFieldSchema>(
 		schema: TSchema,
@@ -149,7 +152,7 @@ export const TreeAlpha: {
 	 * Uses the {@link VerboseTree} format, with an explicit type on every node.
 	 *
 	 * @remarks
-	 * There are several cases this may be preferred to {@link TreeAlpha.(exportConcise:1)}:
+	 * There are several cases this may be preferred to {@link (TreeAlpha:interface).(exportConcise:1)}:
 	 *
 	 * 1. When not using {@link ITreeConfigurationOptions.preventAmbiguity} (or when using `useStableFieldKeys`), `exportConcise` can produce ambiguous data (the type may be unclear on some nodes).
 	 * `exportVerbose` will always be unambiguous and thus lossless.
@@ -182,11 +185,11 @@ export const TreeAlpha: {
 	): JsonCompatible<IFluidHandle>;
 
 	/**
-	 * Import data encoded by {@link TreeAlpha.exportCompressed}.
+	 * Import data encoded by {@link (TreeAlpha:interface).exportCompressed}.
 	 *
 	 * @param schema - Schema with which the data must be compatible. This compatibility is not verified and must be ensured by the caller.
-	 * @param compressedData - Data compressed by {@link TreeAlpha.exportCompressed}.
-	 * @param options - If {@link TreeAlpha.exportCompressed} was given an `idCompressor`, it must be provided here.
+	 * @param compressedData - Data compressed by {@link (TreeAlpha:interface).exportCompressed}.
+	 * @param options - If {@link (TreeAlpha:interface).exportCompressed} was given an `idCompressor`, it must be provided here.
 	 *
 	 * @remarks
 	 * If the data could have been encoded with a different schema, consider encoding the schema along side it using {@link extractPersistedSchema} and loading the data using {@link independentView}.
@@ -195,7 +198,9 @@ export const TreeAlpha: {
 	 * This API could be improved:
 	 *
 	 * 1. It could validate that the schema is compatible, and return or throw an error in the invalid case (maybe add a "try" version).
+	 *
 	 * 2. A "try" version of this could return an error if the data isn't in a supported format (as determined by version and/or JasonValidator).
+	 *
 	 * 3. Requiring the caller provide a JsonValidator isn't the most friendly API. It might be practical to provide a default.
 	 */
 	importCompressed<const TSchema extends ImplicitFieldSchema>(
@@ -203,7 +208,14 @@ export const TreeAlpha: {
 		compressedData: JsonCompatible<IFluidHandle>,
 		options: { idCompressor?: IIdCompressor } & ICodecOptions,
 	): Unhydrated<TreeFieldFromImplicitField<TSchema>>;
-} = {
+}
+
+/**
+ * Extensions to {@link (Tree:variable)} and {@link (TreeBeta:variable)} which are not yet stable.
+ * @see {@link (TreeAlpha:interface)}.
+ * @alpha
+ */
+export const TreeAlpha: TreeAlpha = {
 	branch(node: TreeNode): TreeBranch | undefined {
 		const kernel = getKernel(node);
 		if (!kernel.isHydrated()) {
@@ -302,12 +314,12 @@ export const TreeAlpha: {
 			idCompressor?: IIdCompressor;
 		} & ICodecOptions,
 	): Unhydrated<TreeFieldFromImplicitField<TSchema>> {
+		const config = new TreeViewConfigurationAlpha({ schema });
 		const content: ViewContent = {
-			schema: extractPersistedSchema(schema),
+			schema: extractPersistedSchema(config, currentVersion),
 			tree: compressedData,
 			idCompressor: options.idCompressor ?? createIdCompressor(),
 		};
-		const config = new TreeViewConfiguration({ schema });
 		const view = independentInitializedView(config, options, content);
 		return TreeBeta.clone<TSchema>(view.root);
 	},

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

@@ -47,7 +47,6 @@ export class BranchCommitEnricher<TChange> {
 	/**
 	 * Process the given change, preparing new commits for {@link BranchCommitEnricher.enrich | enrichment}.
 	 * @param change - The change to process.
-	 * @param isAttached - Whether or not the SharedTree is attached to the service.
 	 */
 	public processChange(change: SharedTreeBranchChange<TChange>): void {
 		if (change.type === "append") {

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

@@ -40,12 +40,15 @@ export class TransactionEnricher<TChange> {
 
 	/**
 	 * Commits the current transaction.
-	 * @returns If and only if the closed transaction was the outermost transaction, returns a function which can be used to compute the composed change for that transaction's commits.
+	 * @returns A function which can be used to compute the composed change for that transaction's commits. Undefined if the transaction is still ongoing or contained no committed changes.
 	 */
 	public commitTransaction(): ((revision: RevisionTag) => TChange) | undefined {
 		const commitsCommitted = this.#transactionScopesStart.pop();
 		assert(commitsCommitted !== undefined, 0x985 /* No transaction to commit */);
 		if (this.#transactionScopesStart.length === 0) {
+			if (this.#transactionCommits.length === 0) {
+				return undefined;
+			}
 			const transactionCommits = this.#transactionCommits;
 			this.#transactionCommits = [];
 			return (revision: RevisionTag) =>

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

@@ -21,7 +21,7 @@ import { getUnhydratedContext } from "../createContext.js";
  * @remarks
  * This is "concise" meaning that explicit type information is omitted.
  * If the schema is compatible with {@link ITreeConfigurationOptions.preventAmbiguity},
- * types will be lossless and compatible with {@link TreeAlpha.create} (unless the options are used to customize it).
+ * types will be lossless and compatible with {@link (TreeAlpha:interface).create} (unless the options are used to customize it).
  *
  * Every {@link TreeNode} is an array or object.
  * Any IFluidHandle values have been replaced by `THandle`.

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

@@ -0,0 +1,353 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { assert, fail } from "@fluidframework/core-utils/internal";
+import { UsageError } from "@fluidframework/telemetry-utils/internal";
+
+import {
+	type FieldSchemaAlpha,
+	type ImplicitFieldSchema,
+	FieldKind,
+	markSchemaMostDerived,
+	normalizeFieldSchema,
+} from "../schemaTypes.js";
+import { NodeKind, type TreeNodeSchema } from "../core/index.js";
+import { toStoredSchema } from "../toStoredSchema.js";
+import { LeafNodeSchema } from "../leafNodeSchema.js";
+import { isObjectNodeSchema, type ObjectNodeSchema } from "../objectNodeTypes.js";
+import { getOrCreate } from "../../util/index.js";
+import type { MakeNominal } from "../../util/index.js";
+import { walkFieldSchema } from "../walkFieldSchema.js";
+import type { SimpleNodeSchema, SimpleTreeSchema } from "../simpleSchema.js";
+
+/**
+ * Options when constructing a tree view.
+ * @public
+ */
+export interface ITreeConfigurationOptions {
+	/**
+	 * If `true`, the tree will validate new content against its stored schema at insertion time
+	 * and throw an error if the new content doesn't match the expected schema.
+	 *
+	 * @defaultValue `false`.
+	 *
+	 * @remarks Enabling schema validation has a performance penalty when inserting new content into the tree because
+	 * additional checks are done. Enable this option only in scenarios where you are ok with that operation being a
+	 * bit slower.
+	 */
+	enableSchemaValidation?: boolean;
+
+	/**
+	 * A flag used to opt into strict rules ensuring that the schema avoids cases which can make the type of nodes ambiguous when importing or exporting data.
+	 * @defaultValue `false`.
+	 *
+	 * @remarks
+	 * When this is true, it ensures that the compile time type safety for data when constructing nodes is sufficient to ensure that the runtime behavior will not give node data ambiguity errors.
+	 *
+	 * This ensures that the canonical JSON-like representation of all unions in the tree are lossless and unambiguous.
+	 * This canonical JSON-like representation consists of arrays, plain old JavaScript objects with string keys, booleans, numbers (excluding NaN, -0 and infinities), strings, null and {@link @fluidframework/core-interfaces#IFluidHandle}s.
+	 * It is compatible with the node creation APIs (such as schema class constructors) and is also compatible with JSON assuming any IFluidHandles get special handling (since they are not JSON compatible).
+	 * Currently these cases can cause ambiguity in a union:
+	 *
+	 * - More than one ArrayNode type: it's impossible to tell which array type is intended in the case of empty arrays (`[]`).
+	 *
+	 * - More than one MapNode type: it's impossible to tell which map type is intended in the case of an empty map (`{}`).
+	 *
+	 * - Both a MapNode and an ArrayNode: this case is not a problem for the canonical JSON representation, but is an issue when constructing from an Iterable, which is supported for both MapNode and ArrayNode.
+	 *
+	 * - Both a MapNode and an ObjectNode: when the input is valid for the ObjectNode, the current parser always considers it ambiguous with being a MapNode.
+	 *
+	 * - ObjectNodes which have fields (required or optional) which include all required fields of another ObjectNode: currently each ObjectNode is differentiated by the presence of its required fields.
+	 *
+	 * This check is conservative: some complex cases may error if the current simple algorithm cannot show no ambiguity is possible.
+	 * This check may become more permissive over time.
+	 *
+	 * @example Ambiguous schema (with `preventAmbiguity: false`), and how to disambiguate it using {@link Unhydrated} nodes:
+	 * ```typescript
+	 * const schemaFactory = new SchemaFactory("com.example");
+	 * class Feet extends schemaFactory.object("Feet", { length: schemaFactory.number }) {}
+	 * class Meters extends schemaFactory.object("Meters", { length: schemaFactory.number }) {}
+	 * const config = new TreeViewConfiguration({
+	 * 	// This combination of schema can lead to ambiguous cases and will error if `preventAmbiguity` is true.
+	 * 	schema: [Feet, Meters],
+	 * 	preventAmbiguity: false,
+	 * });
+	 * const view = tree.viewWith(config);
+	 * // This is invalid since it is ambiguous which type of node is being constructed:
+	 * // view.initialize({ length: 5 });
+	 * // To work, an explicit type can be provided by using an {@link Unhydrated} Node:
+	 * view.initialize(new Meters({ length: 5 }));
+	 * ```
+	 *
+	 * @example Schema disambiguated by adjusting field names, validated with `preventAmbiguity: true:`
+	 * ```typescript
+	 * const schemaFactory = new SchemaFactory("com.example");
+	 * class Feet extends schemaFactory.object("Feet", { length: schemaFactory.number }) {}
+	 * class Meters extends schemaFactory.object("Meters", {
+	 * 	// To avoid ambiguity when parsing unions of Feet and Meters, this renames the length field to "meters".
+	 * 	// To preserve compatibility with existing data from the ambiguous case,
+	 * 	// `{ key: "length" }` is set, so when persisted in the tree "length" is used as the field name.
+	 * 	meters: schemaFactory.required(schemaFactory.number, { key: "length" }),
+	 * }) {}
+	 * const config = new TreeViewConfiguration({
+	 * 	// This combination of schema is not ambiguous because `Feet` and `Meters` have different required keys.
+	 * 	schema: [Feet, Meters],
+	 * 	preventAmbiguity: true,
+	 * });
+	 * const view = tree.viewWith(config);
+	 * // This now works, since the field is sufficient to determine this is a `Meters` node.
+	 * view.initialize({ meters: 5 });
+	 * ```
+	 *
+	 * @privateRemarks
+	 * In the future, we can support lossless round tripping via the canonical JSON-like representation above when unambiguous.
+	 * This could be done via methods added to `Tree` to export and import such objects, which would give us a place to explicitly define the type of this representation.
+	 *
+	 * To make this more permissive in the future we can:
+	 *
+	 * - Make toMapTree more permissive (ex: allow disambiguation based on leaf type)
+	 * - Update this check to more tightly match toMapTree
+	 * - Add options to help schema authors disambiguate their types, such as "constant fields" which are not persisted, and always have a constant value.
+	 *
+	 * The above examples exist in executable form in this files tests, and should be updated there then copied back here.
+	 */
+	readonly preventAmbiguity?: boolean;
+}
+
+const defaultTreeConfigurationOptions: Required<ITreeConfigurationOptions> = {
+	enableSchemaValidation: false,
+	preventAmbiguity: false,
+};
+
+/**
+ * Property-bag configuration for {@link TreeViewConfiguration} construction.
+ * @public
+ */
+export interface ITreeViewConfiguration<
+	TSchema extends ImplicitFieldSchema = ImplicitFieldSchema,
+> extends ITreeConfigurationOptions {
+	/**
+	 * The schema which the application wants to view the tree with.
+	 */
+	readonly schema: TSchema;
+}
+
+/**
+ * Configuration for {@link ViewableTree.viewWith}.
+ * @sealed @public
+ */
+export class TreeViewConfiguration<
+	const TSchema extends ImplicitFieldSchema = ImplicitFieldSchema,
+> implements Required<ITreeViewConfiguration<TSchema>>
+{
+	protected _typeCheck!: MakeNominal;
+
+	/**
+	 * {@inheritDoc ITreeViewConfiguration.schema}
+	 */
+	public readonly schema: TSchema;
+
+	/**
+	 * {@inheritDoc ITreeConfigurationOptions.enableSchemaValidation}
+	 */
+	public readonly enableSchemaValidation: boolean;
+
+	/**
+	 * {@inheritDoc ITreeConfigurationOptions.preventAmbiguity}
+	 */
+	public readonly preventAmbiguity: boolean;
+
+	/**
+	 * Construct a new {@link TreeViewConfiguration}.
+	 *
+	 * @param props - Property bag of configuration options.
+	 *
+	 * @remarks
+	 * Performing this construction deeply validates the provided schema.
+	 * This means that when this constructor is called, all {@link LazyItem} {@link TreeNodeSchema} references will be evaluated (using {@link evaluateLazySchema}).
+	 * This means that the declarations for all transitively reachable {@link TreeNodeSchema} must be available at this time.
+	 *
+	 * For example, a schema reachable from this configuration cannot reference this configuration during its declaration,
+	 * since this would be a cyclic dependency that will cause an error when constructing this configuration.
+	 */
+	public constructor(props: ITreeViewConfiguration<TSchema>) {
+		const config = { ...defaultTreeConfigurationOptions, ...props };
+		this.schema = config.schema;
+		this.enableSchemaValidation = config.enableSchemaValidation;
+		this.preventAmbiguity = config.preventAmbiguity;
+
+		// Ambiguity errors are lower priority to report than invalid schema errors, so collect these in an array and report them all at once.
+		const ambiguityErrors: string[] = [];
+
+		walkFieldSchema(config.schema, {
+			// Ensure all reachable schema are marked as most derived.
+			// This ensures if multiple schema extending the same schema factory generated class are present (or have been constructed, or get constructed in the future),
+			// an error is reported.
+
+			node: (schema) => markSchemaMostDerived(schema, true),
+			allowedTypes(types): void {
+				if (config.preventAmbiguity) {
+					checkUnion(types, ambiguityErrors);
+				}
+			},
+		});
+
+		if (ambiguityErrors.length !== 0) {
+			// Duplicate errors are common since when two types conflict, both orders error:
+			const deduplicated = new Set(ambiguityErrors);
+			throw new UsageError(`Ambiguous schema found:\n${[...deduplicated].join("\n")}`);
+		}
+
+		// Eagerly perform this conversion to surface errors sooner.
+		toStoredSchema(config.schema);
+	}
+}
+
+/**
+ * {@link TreeViewConfiguration} extended with some alpha APIs.
+ * @sealed @alpha
+ */
+export class TreeViewConfigurationAlpha<
+		const TSchema extends ImplicitFieldSchema = ImplicitFieldSchema,
+	>
+	extends TreeViewConfiguration<TSchema>
+	implements TreeSchema
+{
+	/**
+	 * {@inheritDoc TreeSchema.root}
+	 */
+	public readonly root: FieldSchemaAlpha;
+	/**
+	 * {@inheritDoc TreeSchema.definitions}
+	 */
+	public readonly definitions: ReadonlyMap<string, SimpleNodeSchema & TreeNodeSchema>;
+
+	public constructor(props: ITreeViewConfiguration<TSchema>) {
+		super(props);
+		this.root = normalizeFieldSchema(props.schema);
+		const definitions = new Map<string, SimpleNodeSchema & TreeNodeSchema>();
+		walkFieldSchema(props.schema, {
+			node: (schema) =>
+				definitions.set(schema.identifier, schema as SimpleNodeSchema & TreeNodeSchema),
+		});
+		this.definitions = definitions;
+	}
+}
+
+/**
+ * {@link TreeViewConfigurationAlpha}
+ * @sealed @alpha
+ */
+export interface TreeSchema extends SimpleTreeSchema {
+	/**
+	 * {@inheritDoc SimpleTreeSchema.root}
+	 */
+	readonly root: FieldSchemaAlpha;
+
+	/**
+	 * {@inheritDoc SimpleTreeSchema.definitions}
+	 */
+	readonly definitions: ReadonlyMap<string, SimpleNodeSchema & TreeNodeSchema>;
+}
+
+/**
+ * Pretty print a set of types for use in error messages.
+ */
+function formatTypes(allowed: Iterable<TreeNodeSchema>): string {
+	// Use JSON.stringify to quote and escape identifiers.
+	// Don't just use a single array JSON.stringify since that omits spaces between items
+	return `[${Array.from(allowed, (s) => JSON.stringify(s.identifier)).join(", ")}]`;
+}
+
+/**
+ * Detect cases documented in {@link ITreeConfigurationOptions.preventAmbiguity}.
+ */
+export function checkUnion(union: Iterable<TreeNodeSchema>, errors: string[]): void {
+	const checked: Set<TreeNodeSchema> = new Set();
+	const maps: TreeNodeSchema[] = [];
+	const arrays: TreeNodeSchema[] = [];
+
+	const objects: ObjectNodeSchema[] = [];
+	// Map from key to schema using that key
+	const allObjectKeys: Map<string, Set<TreeNodeSchema>> = new Map();
+
+	for (const schema of union) {
+		if (checked.has(schema)) {
+			throw new UsageError(`Duplicate schema in allowed types: ${schema.identifier}`);
+		}
+		checked.add(schema);
+
+		if (schema instanceof LeafNodeSchema) {
+			// nothing to do
+		} else if (isObjectNodeSchema(schema)) {
+			objects.push(schema);
+			for (const key of schema.fields.keys()) {
+				getOrCreate(allObjectKeys, key, () => new Set()).add(schema);
+			}
+		} else if (schema.kind === NodeKind.Array) {
+			arrays.push(schema);
+		} else {
+			assert(schema.kind === NodeKind.Map, 0x9e7 /* invalid schema */);
+			maps.push(schema);
+		}
+	}
+
+	if (arrays.length > 1) {
+		errors.push(
+			`More than one kind of array allowed within union (${formatTypes(arrays)}). This would require type disambiguation which is not supported by arrays during import or export.`,
+		);
+	}
+
+	if (maps.length > 1) {
+		errors.push(
+			`More than one kind of map allowed within union (${formatTypes(maps)}). This would require type disambiguation which is not supported by maps during import or export.`,
+		);
+	}
+
+	if (maps.length > 0 && arrays.length > 0) {
+		errors.push(
+			`Both a map and an array allowed within union (${formatTypes([...arrays, ...maps])}). Both can be implicitly constructed from iterables like arrays, which are ambiguous when the array is empty.`,
+		);
+	}
+
+	if (objects.length > 0 && maps.length > 0) {
+		errors.push(
+			`Both a object and a map allowed within union (${formatTypes([...objects, ...maps])}). Both can be constructed from objects and can be ambiguous.`,
+		);
+	}
+
+	// Check for objects which fully overlap:
+	for (const schema of objects) {
+		// All objects which might be ambiguous relative to `schema`.
+		const possiblyAmbiguous = new Set(objects);
+
+		// A schema can't be ambiguous with itself
+		possiblyAmbiguous.delete(schema);
+
+		// For each field of schema, remove schema from possiblyAmbiguous that do not have that field
+		for (const [key, field] of schema.fields) {
+			if (field.kind === FieldKind.Required) {
+				const withKey = allObjectKeys.get(key) ?? fail(0xb35 /* missing schema */);
+				for (const candidate of possiblyAmbiguous) {
+					if (!withKey.has(candidate)) {
+						possiblyAmbiguous.delete(candidate);
+					}
+				}
+			}
+		}
+
+		if (possiblyAmbiguous.size > 0) {
+			// TODO: make this check more permissive.
+			// Allow using the type of the field to disambiguate, at least for leaf types.
+			// Add "constant" fields which can be used to disambiguate even more cases without adding persisted data: maybe make them optional in constructor?
+			// Consider separating unambiguous implicit construction format from constructor arguments at type level, allowing constructor to superset the implicit construction options (ex: optional constant fields).
+			// The policy here however must remain at least as conservative as shallowCompatibilityTest in src/simple-tree/toMapTree.ts.
+
+			errors.push(
+				`The required fields of ${JSON.stringify(schema.identifier)} are insufficient to differentiate it from the following types: ${formatTypes(possiblyAmbiguous)}. For objects to be considered unambiguous, each must have required fields that do not all occur on any other object in the union.`,
+			);
+		}
+	}
+}

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

@@ -7,7 +7,7 @@ import type { JsonTreeSchema } from "./jsonSchema.js";
 import type { ImplicitAllowedTypes } from "../schemaTypes.js";
 import { toJsonSchema } from "./simpleSchemaToJsonSchema.js";
 import type { TreeEncodingOptions } from "./customTree.js";
-import { TreeViewConfigurationAlpha } from "./tree.js";
+import { TreeViewConfigurationAlpha } from "./configuration.js";
 
 /**
  * Options for how to interpret or encode a tree when schema information is available.

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

@@ -3,33 +3,40 @@
  * Licensed under the MIT License.
  */
 
+export type {
+	TreeSchema,
+	ITreeViewConfiguration,
+	ITreeConfigurationOptions,
+} from "./configuration.js";
 export {
-	type ITree,
-	type TreeView,
-	type ViewableTree,
-	type TreeViewEvents,
 	TreeViewConfiguration,
 	TreeViewConfigurationAlpha,
-	type TreeSchema,
-	type ITreeViewConfiguration,
-	type SchemaCompatibilityStatus,
-	type ITreeConfigurationOptions,
-	type TreeViewAlpha,
-	type TreeBranch,
-	type TreeBranchEvents,
-	type ITreeAlpha,
-	asTreeViewAlpha,
+} from "./configuration.js";
+export type {
+	ITree,
+	TreeView,
+	ViewableTree,
+	TreeViewEvents,
+	SchemaCompatibilityStatus,
+	TreeViewAlpha,
+	TreeBranch,
+	TreeBranchEvents,
+	ITreeAlpha,
 } from "./tree.js";
+export { asTreeViewAlpha } from "./tree.js";
 export {
 	SchemaFactory,
 	type ScopedSchemaName,
 	type SchemaFactoryObjectOptions,
 	type SchemaStatics,
+	schemaStatics,
 } from "./schemaFactory.js";
 export { SchemaFactoryAlpha } from "./schemaFactoryAlpha.js";
 export type {
 	ValidateRecursiveSchema,
 	FixRecursiveArraySchema,
+	ValidateRecursiveSchemaTemplate,
+	FixRecursiveRecursionLimit,
 } from "./schemaFactoryRecursive.js";
 export { allowUnused } from "./schemaFactoryRecursive.js";
 export {
@@ -57,7 +64,7 @@ export {
 export type { TreeSchemaEncodingOptions } from "./getJsonSchema.js";
 export { getJsonSchema } from "./getJsonSchema.js";
 export { getSimpleSchema } from "./getSimpleSchema.js";
-export { ViewSchema } from "./view.js";
+export { SchemaCompatibilityTester } from "./schemaCompatibilityTester.js";
 export type {
 	Unenforced,
 	FieldSchemaAlphaUnsafe,
@@ -91,7 +98,7 @@ export {
 	replaceConciseTreeHandles,
 } from "./conciseTree.js";
 
-export { TreeBeta, type NodeChangedData, type TreeChangeEventsBeta } from "./treeApiBeta.js";
+export { TreeBeta, type NodeChangedData, type TreeChangeEventsBeta } from "./treeBeta.js";
 export { createSimpleTreeIndex, type SimpleTreeIndex } from "./simpleTreeIndex.js";
 export {
 	createIdentifierIndex,
@@ -119,6 +126,7 @@ export {
 
 export { generateSchemaFromSimpleSchema } from "./schemaFromSimple.js";
 export { toSimpleTreeSchema } from "./viewSchemaToSimpleSchema.js";
+export type { TreeChangeEvents } from "./treeChangeEvents.js";
 
 // Exporting the schema (RecursiveObject) to test that recursive types are working correctly.
 // These are `@internal` so they can't be included in the `InternalClassTreeTypes` due to https://github.com/microsoft/rushstack/issues/3639

package/src/simple-tree/api/{view.ts → schemaCompatibilityTester.ts}

@@ -22,37 +22,30 @@ import {
 	fieldRealizer,
 	comparePosetElements,
 } from "../../feature-libraries/index.js";
-import {
-	normalizeFieldSchema,
-	type FieldSchema,
-	type ImplicitFieldSchema,
-} from "../schemaTypes.js";
+import type { FieldSchema } from "../schemaTypes.js";
 import { toStoredSchema } from "../toStoredSchema.js";
 import type { SchemaCompatibilityStatus } from "./tree.js";
 
 /**
  * A collection of View information for schema, including policy.
+ * @remarks
+ * This contains everything needed to determine compatibility with a given stored schema.
  */
-export class ViewSchema {
+export class SchemaCompatibilityTester {
 	/**
 	 * Cached conversion of the view schema in the stored schema format.
 	 */
-	private readonly viewSchemaAsStored: TreeStoredSchema;
-	/**
-	 * Normalized view schema (implicitly allowed view schema types are converted to their canonical form).
-	 */
-	public readonly schema: FieldSchema;
+	public readonly viewSchemaAsStored: TreeStoredSchema;
 
 	/**
-	 * @param viewSchema - Schema for the root field of this view.
+	 * @param viewSchemaRoot - Schema for the root field.
 	 */
 	public constructor(
 		public readonly policy: FullSchemaPolicy,
 		public readonly adapters: Adapters,
-		viewSchema: ImplicitFieldSchema,
+		viewSchemaRoot: FieldSchema,
 	) {
-		this.schema = normalizeFieldSchema(viewSchema);
-		this.viewSchemaAsStored = toStoredSchema(this.schema);
+		this.viewSchemaAsStored = toStoredSchema(viewSchemaRoot);
 	}
 
 	/**