@fluidframework/tree 2.1.0-274160 → 2.1.0-276985

package/src/shared-tree/schematizingTreeView.ts

@@ -20,19 +20,18 @@ import {
 	defaultSchemaPolicy,
 	ContextSlot,
 	cursorForMapTreeNode,
+	type FlexTreeSchema,
 } from "../feature-libraries/index.js";
 import {
 	type FieldSchema,
 	type ImplicitFieldSchema,
 	type SchemaCompatibilityStatus,
 	type InsertableTreeFieldFromImplicitField,
-	// eslint-disable-next-line import/no-deprecated
-	type TreeConfiguration,
 	type TreeFieldFromImplicitField,
 	type TreeView,
 	type TreeViewEvents,
 	getProxyForField,
-	toFlexConfig,
+	toFlexSchema,
 	setField,
 	normalizeFieldSchema,
 	type InsertableContent,
@@ -42,12 +41,7 @@ import {
 } from "../simple-tree/index.js";
 import { disposeSymbol } from "../util/index.js";
 
-import {
-	type TreeContent,
-	canInitialize,
-	ensureSchema,
-	initialize,
-} from "./schematizeTree.js";
+import { canInitialize, ensureSchema, initialize } from "./schematizeTree.js";
 import type { TreeCheckout } from "./treeCheckout.js";
 import { CheckoutFlexTreeView } from "./treeView.js";
 
@@ -68,7 +62,7 @@ export class SchematizingSimpleTreeView<in out TRootSchema extends ImplicitField
 	 * Undefined iff uninitialized or disposed.
 	 */
 	private currentCompatibility: SchemaCompatibilityStatus | undefined;
-	private readonly flexConfig: TreeContent;
+	private readonly flexSchema: FlexTreeSchema;
 	public readonly events: Listenable<TreeViewEvents> &
 		IEmitter<TreeViewEvents> &
 		HasListeners<TreeViewEvents> = createEmitter();
@@ -90,8 +84,7 @@ export class SchematizingSimpleTreeView<in out TRootSchema extends ImplicitField
 
 	public constructor(
 		public readonly checkout: TreeCheckout,
-		public readonly config: // eslint-disable-next-line import/no-deprecated
-		TreeConfiguration<TRootSchema> | TreeViewConfiguration<TRootSchema>,
+		public readonly config: TreeViewConfiguration<TRootSchema>,
 		public readonly nodeKeyManager: NodeKeyManager,
 	) {
 		const policy = {
@@ -99,11 +92,9 @@ export class SchematizingSimpleTreeView<in out TRootSchema extends ImplicitField
 			validateSchema: config.enableSchemaValidation,
 		};
 		this.rootFieldSchema = normalizeFieldSchema(config.schema);
-		this.flexConfig = toFlexConfig(config, nodeKeyManager, {
-			schema: checkout.storedSchema,
-			policy,
-		});
-		this.viewSchema = new ViewSchema(policy, {}, this.flexConfig.schema);
+		this.flexSchema = toFlexSchema(config.schema);
+
+		this.viewSchema = new ViewSchema(policy, {}, this.flexSchema);
 		// This must be initialized before `update` can be called.
 		this.currentCompatibility = {
 			canView: false,
@@ -144,7 +135,7 @@ export class SchematizingSimpleTreeView<in out TRootSchema extends ImplicitField
 
 			prepareContentForHydration(mapTree, this.checkout.forest);
 			initialize(this.checkout, {
-				schema: this.flexConfig.schema,
+				schema: this.flexSchema,
 				initialTree: mapTree === undefined ? undefined : cursorForMapTreeNode(mapTree),
 			});
 		});
@@ -168,10 +159,12 @@ export class SchematizingSimpleTreeView<in out TRootSchema extends ImplicitField
 		this.runSchemaEdit(() => {
 			const result = ensureSchema(
 				this.viewSchema,
-				// eslint-disable-next-line no-bitwise
-				AllowedUpdateType.SchemaCompatible | AllowedUpdateType.Initialize,
+				AllowedUpdateType.SchemaCompatible,
 				this.checkout,
-				this.flexConfig,
+				{
+					schema: this.flexSchema,
+					initialTree: undefined,
+				},
 			);
 			assert(result, 0x8bf /* Schema upgrade should always work if canUpgrade is set. */);
 		});

package/src/shared-tree/sharedTree.ts

@@ -53,9 +53,6 @@ import {
 import type {
 	ITree,
 	ImplicitFieldSchema,
-	// eslint-disable-next-line import/no-deprecated
-	TreeConfiguration,
-	TreeView,
 	TreeViewConfiguration,
 } from "../simple-tree/index.js";
 
@@ -322,25 +319,9 @@ export class SharedTree
 		);
 	}
 
-	public schematize<TRoot extends ImplicitFieldSchema>(
-		// eslint-disable-next-line import/no-deprecated
-		config: TreeConfiguration<TRoot>,
-	): TreeView<TRoot> {
-		const view = new SchematizingSimpleTreeView(
-			this.checkout,
-			config,
-			createNodeKeyManager(this.runtime.idCompressor),
-		);
-		// As a subjective API design choice, we initialize the tree here if it is not already initialized.
-		if (view.compatibility.canInitialize === true) {
-			view.initialize(config.initialTree());
-		}
-		return view;
-	}
-
 	public viewWith<TRoot extends ImplicitFieldSchema>(
 		config: TreeViewConfiguration<TRoot>,
-	): TreeView<TRoot> {
+	): SchematizingSimpleTreeView<TRoot> {
 		return new SchematizingSimpleTreeView(
 			this.checkout,
 			config,

package/src/shared-tree/treeApi.ts

@@ -17,7 +17,7 @@ import {
 import { fail } from "../util/index.js";
 
 import { SchematizingSimpleTreeView } from "./schematizingTreeView.js";
-import type { TreeCheckout } from "./treeCheckout.js";
+import type { ITreeCheckout } from "./treeCheckout.js";
 import { contextToTreeView } from "./treeView.js";
 
 /**
@@ -445,7 +445,7 @@ export function runTransaction<
 }
 
 function runTransactionInCheckout<TResult>(
-	checkout: TreeCheckout,
+	checkout: ITreeCheckout,
 	transaction: () => TResult | typeof rollback,
 	preconditions: readonly TransactionConstraint[],
 ): TResult | typeof rollback {

package/src/shared-tree/treeView.ts

@@ -17,14 +17,12 @@ import { type IDisposable, disposeSymbol } from "../util/index.js";
 import type { ITreeCheckout, ITreeCheckoutFork, TreeCheckout } from "./treeCheckout.js";
 
 /**
- * An editable view of a (version control style) branch of a shared tree.
+ * The portion of {@link FlexTreeView} that does not depend on the schema's type.
  * @privateRemarks
- * TODO:
- * 1. Once ISharedTreeView is renamed this can become ISharedTreeView.
- * 2. This object should be combined with or accessible from the TreeContext to allow easy access to thinks like branching.
+ * Since {@link FlexTreeView}'s schema is invariant, `FlexTreeView<FlexFieldSchema>` does not cover this use case.
  * @internal
  */
-export interface FlexTreeView<in out TRoot extends FlexFieldSchema> extends IDisposable {
+export interface FlexTreeViewGeneric extends IDisposable {
 	/**
 	 * Context for controlling the FlexTree nodes produced from {@link FlexTreeView.flexTree}.
 	 *
@@ -40,7 +38,17 @@ export interface FlexTreeView<in out TRoot extends FlexFieldSchema> extends IDis
 	 * This is a non-owning reference: disposing of this view does not impact the branch.
 	 */
 	readonly checkout: ITreeCheckout;
+}
 
+/**
+ * An editable view of a (version control style) branch of a shared tree.
+ * @privateRemarks
+ * TODO:
+ * If schema aware APIs are removed from flex tree, this can be combined with {@link FlexTreeViewGeneric}.
+ * @internal
+ */
+export interface FlexTreeView<in out TRoot extends FlexFieldSchema>
+	extends FlexTreeViewGeneric {
 	/**
 	 * Get a typed view of the tree content using the flex-tree API.
 	 */
@@ -100,6 +108,4 @@ export class CheckoutFlexTreeView<
  * Maps the context of every {@link CheckoutFlexTreeView} to the view.
  * In practice, this allows the view or checkout to be obtained from a flex node by first getting the context from the flex node and then using this map.
  */
-// TODO: use something other than `any`
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export const contextToTreeView = new WeakMap<Context, CheckoutFlexTreeView<any>>();
+export const contextToTreeView = new WeakMap<Context, FlexTreeViewGeneric>();

package/src/simple-tree/arrayNode.ts

@@ -774,22 +774,27 @@ abstract class CustomArrayNodeBase<const T extends ImplicitAllowedTypes>
 	}
 	public moveToStart(sourceIndex: number, source?: TreeArrayNode): void {
 		const sourceArray = source ?? this;
-		const field = getSequenceField(sourceArray);
-		validateIndex(sourceIndex, field, "moveToStart");
+		const sourceField = getSequenceField(sourceArray);
+		validateIndex(sourceIndex, sourceField, "moveToStart");
 		this.moveRangeToIndex(0, sourceIndex, sourceIndex + 1, source);
 	}
 	public moveToEnd(sourceIndex: number, source?: TreeArrayNode): void {
 		const sourceArray = source ?? this;
-		const field = getSequenceField(sourceArray);
-		validateIndex(sourceIndex, field, "moveToEnd");
+		const sourceField = getSequenceField(sourceArray);
+		validateIndex(sourceIndex, sourceField, "moveToEnd");
 		this.moveRangeToIndex(this.length, sourceIndex, sourceIndex + 1, source);
 	}
-	public moveToIndex(index: number, sourceIndex: number, source?: TreeArrayNode): void {
+	public moveToIndex(
+		destinationIndex: number,
+		sourceIndex: number,
+		source?: TreeArrayNode,
+	): void {
 		const sourceArray = source ?? this;
-		const field = getSequenceField(sourceArray);
-		validateIndex(index, field, "moveToIndex", true);
-		validateIndex(sourceIndex, field, "moveToIndex");
-		this.moveRangeToIndex(index, sourceIndex, sourceIndex + 1, source);
+		const sourceField = getSequenceField(sourceArray);
+		const destinationField = getSequenceField(this);
+		validateIndex(destinationIndex, destinationField, "moveToIndex", true);
+		validateIndex(sourceIndex, sourceField, "moveToIndex");
+		this.moveRangeToIndex(destinationIndex, sourceIndex, sourceIndex + 1, source);
 	}
 	public moveRangeToStart(
 		sourceStart: number,
@@ -814,41 +819,40 @@ abstract class CustomArrayNodeBase<const T extends ImplicitAllowedTypes>
 		this.moveRangeToIndex(this.length, sourceStart, sourceEnd, source);
 	}
 	public moveRangeToIndex(
-		index: number,
+		destinationIndex: number,
 		sourceStart: number,
 		sourceEnd: number,
 		source?: TreeArrayNode,
 	): void {
-		const field = getSequenceField(this);
-		validateIndex(index, field, "moveRangeToIndex", true);
-		validateIndexRange(sourceStart, sourceEnd, source ?? field, "moveRangeToIndex");
+		const destinationField = getSequenceField(this);
+		validateIndex(destinationIndex, destinationField, "moveRangeToIndex", true);
+		validateIndexRange(sourceStart, sourceEnd, source ?? destinationField, "moveRangeToIndex");
 		const sourceField =
 			source !== undefined
-				? field.isSameAs(getSequenceField(source))
-					? field
+				? destinationField.isSameAs(getSequenceField(source))
+					? destinationField
 					: getSequenceField(source)
-				: field;
+				: destinationField;
 
 		// TODO: determine support for move across different sequence types
-		if (field.schema.types !== undefined && sourceField !== field) {
+		if (destinationField.schema.types !== undefined && sourceField !== destinationField) {
 			for (let i = sourceStart; i < sourceEnd; i++) {
-				const sourceNode =
-					sourceField.boxedAt(sourceStart) ?? fail("impossible out of bounds index");
-				if (!field.schema.types.has(sourceNode.schema.name)) {
-					throw new Error("Type in source sequence is not allowed in destination.");
+				const sourceNode = sourceField.boxedAt(i) ?? fail("impossible out of bounds index");
+				if (!destinationField.schema.types.has(sourceNode.schema.name)) {
+					throw new UsageError("Type in source sequence is not allowed in destination.");
 				}
 			}
 		}
 		const movedCount = sourceEnd - sourceStart;
 		const sourceFieldPath = sourceField.getFieldPath();
 
-		const destinationFieldPath = field.getFieldPath();
-		field.context.checkout.editor.move(
+		const destinationFieldPath = destinationField.getFieldPath();
+		destinationField.context.checkout.editor.move(
 			sourceFieldPath,
 			sourceStart,
 			movedCount,
 			destinationFieldPath,
-			index,
+			destinationIndex,
 		);
 	}
 }

package/src/simple-tree/index.ts

@@ -7,7 +7,6 @@ export {
 	type ITree,
 	type TreeView,
 	type TreeViewEvents,
-	TreeConfiguration,
 	TreeViewConfiguration,
 	type ITreeViewConfiguration,
 	type SchemaCompatibilityStatus,
@@ -42,7 +41,7 @@ export {
 export { SchemaFactory, type ScopedSchemaName } from "./schemaFactory.js";
 export { getFlexNode } from "./proxyBinding.js";
 export { treeNodeApi, type TreeNodeApi, type TreeChangeEvents } from "./treeNodeApi.js";
-export { toFlexConfig, cursorFromUnhydratedRoot } from "./toFlexSchema.js";
+export { toFlexSchema, cursorFromUnhydratedRoot } from "./toFlexSchema.js";
 export type {
 	FieldHasDefaultUnsafe,
 	ObjectFromSchemaRecordUnsafe,

package/src/simple-tree/objectNode.ts

@@ -200,6 +200,12 @@ function createProxyHandler(
 			setField(flexNode.getBoxed(fieldInfo.storedKey), fieldInfo.schema, value);
 			return true;
 		},
+		deleteProperty(target, viewKey): boolean {
+			// TODO: supporting delete when it makes sense (custom local fields, and optional field) could be added as a feature in the future.
+			throw new UsageError(
+				`Object nodes do not support the delete operator. Optional fields can be assigned to undefined instead.`,
+			);
+		},
 		has: (target, viewKey) => {
 			return (
 				flexKeyMap.has(viewKey) ||

package/src/simple-tree/proxies.ts

@@ -25,6 +25,7 @@ import {
 	type MapTreeNode,
 	tryGetMapTreeNode,
 	typeNameSymbol,
+	isFlexTreeNode,
 } from "../feature-libraries/index.js";
 import { type Mutable, fail, isReadonlyArray } from "../util/index.js";
 
@@ -55,27 +56,28 @@ export function isTreeNode(candidate: unknown): candidate is TreeNode | Unhydrat
  * Retrieve the associated proxy for the given field.
  * */
 export function getProxyForField(field: FlexTreeField): TreeNode | TreeValue | undefined {
+	function tryToUnboxLeaves(
+		flexField: FlexTreeTypedField<
+			FlexFieldSchema<typeof FieldKinds.required | typeof FieldKinds.optional>
+		>,
+	): TreeNode | TreeValue | undefined {
+		const maybeUnboxedContent = flexField.content;
+		return isFlexTreeNode(maybeUnboxedContent)
+			? getOrCreateNodeProxy(maybeUnboxedContent)
+			: maybeUnboxedContent;
+	}
 	switch (field.schema.kind) {
 		case FieldKinds.required: {
-			const asValue = field as FlexTreeTypedField<FlexFieldSchema<typeof FieldKinds.required>>;
-
-			// TODO: Ideally, we would return leaves without first boxing them.  However, this is not
-			//       as simple as calling '.content' since this skips the node and returns the FieldNode's
-			//       inner field.
-			return getOrCreateNodeProxy(asValue.boxedContent);
+			const typedField = field as FlexTreeTypedField<
+				FlexFieldSchema<typeof FieldKinds.required>
+			>;
+			return tryToUnboxLeaves(typedField);
 		}
 		case FieldKinds.optional: {
-			const asValue = field as FlexTreeTypedField<FlexFieldSchema<typeof FieldKinds.optional>>;
-
-			// TODO: Ideally, we would return leaves without first boxing them.  However, this is not
-			//       as simple as calling '.content' since this skips the node and returns the FieldNode's
-			//       inner field.
-
-			const maybeContent = asValue.boxedContent;
-
-			// Normally, empty fields are unreachable due to the behavior of 'tryGetField'.  However, the
-			// root field is a special case where the field is always present (even if empty).
-			return maybeContent === undefined ? undefined : getOrCreateNodeProxy(maybeContent);
+			const typedField = field as FlexTreeTypedField<
+				FlexFieldSchema<typeof FieldKinds.optional>
+			>;
+			return tryToUnboxLeaves(typedField);
 		}
 		// TODO: Remove if/when 'FieldNode' is removed.
 		case FieldKinds.sequence: {
@@ -84,9 +86,9 @@ export function getProxyForField(field: FlexTreeField): TreeNode | TreeValue | u
 			fail("'sequence' field is unexpected.");
 		}
 		case FieldKinds.identifier: {
-			const identifier = field.boxedAt(0);
-			assert(identifier !== undefined, 0x91a /* identifier must exist */);
-			return getOrCreateNodeProxy(identifier);
+			// Identifier fields are just value fields that hold strings
+			return (field as FlexTreeTypedField<FlexFieldSchema<typeof FieldKinds.required>>)
+				.content as string;
 		}
 
 		default:

package/src/simple-tree/schemaFactory.ts

@@ -10,13 +10,7 @@ import { assert, unreachableCase } from "@fluidframework/core-utils/internal";
 import type { IFluidHandle as _dummyImport } from "@fluidframework/core-interfaces";
 
 import type { TreeValue } from "../core/index.js";
-import {
-	type FlexTreeNode,
-	type NodeKeyManager,
-	type Unenforced,
-	isFlexTreeNode,
-	isLazy,
-} from "../feature-libraries/index.js";
+import { type NodeKeyManager, type Unenforced, isLazy } from "../feature-libraries/index.js";
 import {
 	type RestrictiveReadonlyRecord,
 	getOrCreate,
@@ -170,6 +164,14 @@ export class SchemaFactory<
 	private readonly structuralTypes: Map<string, TreeNodeSchema> = new Map();
 
 	/**
+	 * Construct a SchemaFactory with a given scope.
+	 * @remarks
+	 * There are no restrictions on mixing schema from different schema factories:
+	 * this is encouraged when a single schema references schema from different libraries.
+	 * If each library exporting schema picks its own globally unique scope for its SchemaFactory,
+	 * then all schema an application might depend on, directly or transitively,
+	 * will end up with a unique fully qualified name which is required to refer to it in persisted data and errors.
+	 *
 	 * @param scope - Prefix appended to the identifiers of all {@link TreeNodeSchema} produced by this builder.
 	 * Use of [Reverse domain name notation](https://en.wikipedia.org/wiki/Reverse_domain_name_notation) or a UUIDv4 is recommended to avoid collisions.
 	 * You may opt out of using a scope by passing `undefined`, but note that this increases the risk of collisions.
@@ -641,26 +643,12 @@ export class SchemaFactory<
 		const Name extends TName,
 		const T extends Unenforced<ImplicitAllowedTypes>,
 	>(name: Name, allowedTypes: T) {
-		class RecursiveArray extends this.namedArray(
+		const RecursiveArray = this.namedArray(
 			name,
 			allowedTypes as T & ImplicitAllowedTypes,
 			true,
 			false,
-		) {
-			public constructor(
-				data:
-					| Iterable<InsertableTreeNodeFromImplicitAllowedTypes<T & ImplicitAllowedTypes>>
-					| FlexTreeNode,
-			) {
-				if (isFlexTreeNode(data)) {
-					// TODO: use something other than `any`
-					// eslint-disable-next-line @typescript-eslint/no-explicit-any
-					super(data as any);
-				} else {
-					super(data);
-				}
-			}
-		}
+		);
 
 		return RecursiveArray as TreeNodeSchemaClass<
 			ScopedSchemaName<TScope, Name>,
@@ -697,28 +685,12 @@ export class SchemaFactory<
 		name: Name,
 		allowedTypes: T,
 	) {
-		class MapSchema extends this.namedMap(
+		const MapSchema = this.namedMap(
 			name,
 			allowedTypes as T & ImplicitAllowedTypes,
 			true,
 			false,
-		) {
-			public constructor(
-				data:
-					| Iterable<
-							[string, InsertableTreeNodeFromImplicitAllowedTypes<T & ImplicitAllowedTypes>]
-					  >
-					| FlexTreeNode,
-			) {
-				if (isFlexTreeNode(data)) {
-					// TODO: use something other than `any`
-					// eslint-disable-next-line @typescript-eslint/no-explicit-any
-					super(data as any);
-				} else {
-					super(new Map(data));
-				}
-			}
-		}
+		);
 
 		return MapSchema as TreeNodeSchemaClass<
 			ScopedSchemaName<TScope, Name>,

package/src/simple-tree/toFlexSchema.ts

@@ -27,7 +27,6 @@ import {
 	schemaIsLeaf,
 } from "../feature-libraries/index.js";
 import { normalizeFlexListEager } from "../feature-libraries/typed-schema/flexList.js";
-import type { TreeContent } from "../shared-tree/index.js";
 import { brand, fail, isReadonlyArray, mapIterable } from "../util/index.js";
 
 import type { InsertableContent } from "./proxies.js";
@@ -48,8 +47,6 @@ import {
 	getStoredKey,
 } from "./schemaTypes.js";
 import { cursorFromNodeData } from "./toMapTree.js";
-// eslint-disable-next-line import/no-deprecated
-import { TreeConfiguration, type TreeViewConfiguration } from "./tree.js";
 
 /**
  * Returns a cursor (in nodes mode) for the root node.
@@ -77,50 +74,6 @@ export function cursorFromUnhydratedRoot(
 	);
 }
 
-/* eslint-disable import/no-deprecated */
-function isTreeConfiguration(
-	config: TreeViewConfiguration | TreeConfiguration,
-): config is TreeConfiguration {
-	return config instanceof TreeConfiguration;
-}
-/* eslint-enable import/no-deprecated */
-
-/**
- * Generates a configuration object (schema + initial tree) for a FlexTree.
- * @param config - Configuration for how to {@link ITree.schematize|schematize} a tree.
- * @param nodeKeyManager - See {@link NodeKeyManager}.
- * @param schemaValidationPolicy - Stored schema and policy for the tree. If the policy specifies
- * `{@link SchemaPolicy.validateSchema} === true`, new content inserted into the tree will be validated using this
- * object.
- * @returns A configuration object for a FlexTree.
- *
- * @privateremarks
- * I wrote these docs without a ton of context, they can probably be improved.
- */
-export function toFlexConfig(
-	// eslint-disable-next-line import/no-deprecated
-	config: TreeViewConfiguration | TreeConfiguration,
-	nodeKeyManager: NodeKeyManager,
-	schemaValidationPolicy: SchemaAndPolicy | undefined = undefined,
-): TreeContent {
-	const unhydrated = isTreeConfiguration(config) ? config.initialTree() : undefined;
-	const initialTree =
-		unhydrated === undefined
-			? undefined
-			: [
-					cursorFromUnhydratedRoot(
-						config.schema,
-						unhydrated,
-						nodeKeyManager,
-						schemaValidationPolicy,
-					),
-				];
-	return {
-		schema: toFlexSchema(config.schema),
-		initialTree,
-	};
-}
-
 interface SchemaInfo {
 	toFlex: () => FlexTreeNodeSchema;
 	original: TreeNodeSchema;

package/src/simple-tree/tree.ts

@@ -133,43 +133,6 @@ export class TreeViewConfiguration<TSchema extends ImplicitFieldSchema = Implici
 	}
 }
 
-/**
- * Configuration for how to {@link ITree.schematize | schematize} a tree.
- * @sealed @public
- * @deprecated Please migrate to use {@link TreeViewConfiguration} with {@link ITree.viewWith} instead.
- */
-export class TreeConfiguration<TSchema extends ImplicitFieldSchema = ImplicitFieldSchema> {
-	/**
-	 * 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.
-	 */
-	public readonly enableSchemaValidation: boolean;
-
-	/**
-	 * @param schema - The schema which the application wants to view the tree with.
-	 * @param initialTree - A function that returns the default tree content to initialize the tree with iff the tree is uninitialized
-	 * (meaning it does not even have any schema set at all).
-	 * If `initialTree` returns any actual node instances, they should be recreated each time `initialTree` runs.
-	 * This is because if the config is used a second time any nodes that were not recreated could error since nodes cannot be inserted into the tree multiple times.
-	 * @param options - Additional options that can be specified when {@link ITree.schematize | schematizing } a tree.
-	 */
-	public constructor(
-		public readonly schema: TSchema,
-		public readonly initialTree: () => InsertableTreeFieldFromImplicitField<TSchema>,
-		options?: ITreeConfigurationOptions,
-	) {
-		this.enableSchemaValidation =
-			options?.enableSchemaValidation ??
-			defaultTreeConfigurationOptions.enableSchemaValidation;
-	}
-}
-
 /**
  * An editable view of a (version control style) branch of a shared tree based on some schema.
  *

package/src/treeFactory.ts

@@ -56,7 +56,7 @@ export class TreeFactory implements IChannelFactory<ITree> {
 /**
  * SharedTree is a hierarchical data structure for collaboratively editing strongly typed JSON-like trees
  * of objects, arrays, and other data types.
- * @alpha
+ * @internal
  */
 export const SharedTree = configuredSharedTree({});
 

package/src/util/brandedMap.ts

@@ -3,11 +3,16 @@
  * Licensed under the MIT License.
  */
 
+import type { Brand } from "./brand.js";
+import type { Opaque } from "./opaque.js";
 import type { Invariant } from "./typeCheck.js";
 import { getOrCreate } from "./utils.js";
 
 /**
  * Key in a {@link BrandedMapSubset}.
+ * @remarks
+ * Due to the `TContent` type parameter being invariant (which it has to be since keys are used to both read and write data),
+ * generic collections end up needing to constrain their key's `TContent` to `any`.
  * @internal
  */
 export type BrandedKey<TKey, TContent> = TKey & Invariant<TContent>;
@@ -49,16 +54,15 @@ export interface BrandedMapSubset<K extends BrandedKey<unknown, any>> {
 
 /**
  * Version of {@link getOrCreate} with better typing for {@link BrandedMapSubset}.
+ * @privateRemarks
+ * Only infers type from key to avoid inferring `any` from map's key.
  */
-export function getOrCreateSlotContent<
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	M extends BrandedMapSubset<BrandedKey<unknown, any>>,
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	K extends BrandedKey<unknown, any>,
->(map: M, key: K, defaultValue: (key: K) => BrandedKeyContent<K>): BrandedKeyContent<K> {
-	const result: BrandedKeyContent<K> = getOrCreate(map, key, defaultValue);
-	// eslint-disable-next-line @typescript-eslint/no-unsafe-return
-	return result;
+export function getOrCreateSlotContent<K, V>(
+	map: NoInfer<BrandedMapSubset<BrandedKey<K, V>>>,
+	key: BrandedKey<K, V>,
+	defaultValue: NoInfer<(key: BrandedKey<K, V>) => V>,
+): V {
+	return getOrCreate<BrandedKey<K, V>, V>(map, key, defaultValue);
 }
 
 /**
@@ -72,7 +76,10 @@ let slotCounter = 0;
  * Define a strongly typed slot in which data can be stored in a {@link BrandedMapSubset}.
  * @internal
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function brandedSlot<TSlot extends BrandedKey<any, any>>(): TSlot {
+export function brandedSlot<
+	// See note on BrandedKey.
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	TSlot extends BrandedKey<number | Opaque<Brand<number, string>>, any>,
+>(): TSlot {
 	return slotCounter++ as TSlot;
 }