@fluidframework/tree 2.74.0 → 2.81.0-374083

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

@@ -23,6 +23,12 @@ export const rollback = Symbol("SharedTree Transaction Rollback");
  */
 export type TransactionConstraint = NodeInDocumentConstraint; // TODO: Add more constraint types here
 
+/**
+ * Type for alpha version {@link TransactionConstraint | constraint}s
+ * @sealed @alpha
+ */
+export type TransactionConstraintAlpha = TransactionConstraint | NoChangeConstraint; // TODO: Add more constraint types here
+
 /**
  * A transaction {@link TransactionConstraint | constraint} which requires that the given node exists in the tree.
  * @remarks The node must be in the document (its {@link TreeStatus | status} must be {@link TreeStatus.InDocument | InDocument}) to qualify as "existing".
@@ -33,6 +39,15 @@ export interface NodeInDocumentConstraint {
 	readonly node: TreeNode;
 }
 
+/**
+ * A {@link TransactionConstraintAlpha | constraint} which requires that, for this transaction to apply, the document must be in the same state immediately before the transaction is applied as it was before the transaction was authored.
+ * When used as a revert precondition it requires that, for the revert to apply, the document must be in the same state immediately before the revert is applied as it was after the transaction was applied.
+ * @alpha
+ */
+export interface NoChangeConstraint {
+	readonly type: "noChange";
+}
+
 /**
  * The status of the transaction callback in the {@link RunTransaction | RunTransaction} API.
  * @alpha
@@ -52,13 +67,13 @@ export type TransactionCallbackStatus<TSuccessValue, TFailureValue> = (
 	  }
 ) & {
 	/**
-	 * An optional list of {@link TransactionConstraint | constraints} that will be checked when the commit corresponding
+	 * An optional list of {@link TransactionConstraintAlpha | constraints} that will be checked when the commit corresponding
 	 * to this transaction is reverted. If any of these constraints are not met when the revert is being applied either
 	 * locally or on remote clients, the revert will be ignored.
 	 * These constraints must also be met at the time they are first introduced. If they are not met after the transaction
 	 * callback returns, then `runTransaction` (which invokes the transaction callback) will throw a `UsageError`.
 	 */
-	preconditionsOnRevert?: readonly TransactionConstraint[];
+	preconditionsOnRevert?: readonly TransactionConstraintAlpha[];
 };
 
 /**
@@ -117,10 +132,10 @@ export type TransactionResult =
  */
 export interface RunTransactionParams {
 	/**
-	 * An optional list of {@link TransactionConstraint | constraints} that are checked just before the transaction begins.
+	 * An optional list of {@link TransactionConstraintAlpha | constraints} that are checked just before the transaction begins.
 	 * If any of the constraints are not met when `runTransaction` is called, an error will be thrown.
 	 * If any of the constraints are not met after the transaction has been ordered by the service, it will be rolled back on
 	 * this client and ignored by all other clients.
 	 */
-	readonly preconditions?: readonly TransactionConstraint[];
+	readonly preconditions?: readonly TransactionConstraintAlpha[];
 }

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

@@ -340,8 +340,10 @@ export interface TreeView<in out TSchema extends ImplicitFieldSchema> extends ID
 
 	/**
 	 * Description of the current compatibility status between the view schema and stored schema.
-	 *
+	 * @remarks
 	 * {@link TreeViewEvents.schemaChanged} is fired when the compatibility status changes.
+	 * See {@link https://fluidframework.com/docs/data-structures/tree/schema-evolution/ | schema-evolution} for more guidance on how to change schema while maintaining compatibility.
+	 * Use {@link checkSchemaCompatibilitySnapshots} to write tests to validate that this compatibility behaves as desired across schema changes.
 	 */
 	readonly compatibility: SchemaCompatibilityStatus;
 

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

@@ -203,8 +203,9 @@ export const treeNodeApi: TreeNodeApi = {
 			case "treeChanged": {
 				return kernel.events.on("subtreeChangedAfterBatch", () => listener({}));
 			}
-			default:
+			default: {
 				throw new UsageError(`No event named ${JSON.stringify(eventName)}.`);
+			}
 		}
 	},
 	status(node: TreeNode): TreeStatus {
@@ -238,12 +239,15 @@ export const treeNodeApi: TreeNodeApi = {
  */
 export function tryGetSchema(value: unknown): undefined | TreeNodeSchema {
 	switch (typeof value) {
-		case "string":
+		case "string": {
 			return stringSchema;
-		case "number":
+		}
+		case "number": {
 			return numberSchema;
-		case "boolean":
+		}
+		case "boolean": {
 			return booleanSchema;
+		}
 		case "object": {
 			if (isTreeNode(value)) {
 				// TODO: This case could be optimized, for example by placing the simple schema in a symbol on tree nodes.
@@ -256,8 +260,9 @@ export function tryGetSchema(value: unknown): undefined | TreeNodeSchema {
 				return handleSchema;
 			}
 		}
-		default:
+		default: {
 			return undefined;
+		}
 	}
 }
 
@@ -310,8 +315,9 @@ export function getIdentifierFromNode(
 	const identifierFieldKeys = schema.identifierFieldKeys;
 
 	switch (identifierFieldKeys.length) {
-		case 0:
+		case 0: {
 			return undefined;
+		}
 		case 1: {
 			const key = identifierFieldKeys[0] ?? oob();
 			const identifierField = flexNode.tryGetField(key);
@@ -325,9 +331,9 @@ export function getIdentifierFromNode(
 					if (context.isHydrated()) {
 						const localNodeKey =
 							context.nodeKeyManager.tryLocalizeNodeIdentifier(identifierValue);
-						return localNodeKey !== undefined
-							? extractFromOpaque(localNodeKey)
-							: identifierValue;
+						return localNodeKey === undefined
+							? identifierValue
+							: extractFromOpaque(localNodeKey);
 					} else {
 						return identifierValue;
 					}
@@ -336,7 +342,7 @@ export function getIdentifierFromNode(
 					if (context.isHydrated()) {
 						const localNodeKey =
 							context.nodeKeyManager.tryLocalizeNodeIdentifier(identifierValue);
-						return localNodeKey !== undefined ? extractFromOpaque(localNodeKey) : undefined;
+						return localNodeKey === undefined ? undefined : extractFromOpaque(localNodeKey);
 					} else {
 						return undefined;
 					}
@@ -344,14 +350,16 @@ export function getIdentifierFromNode(
 				case "uncompressed": {
 					return identifierValue;
 				}
-				default:
+				default: {
 					unreachableCase(compression);
+				}
 			}
 		}
-		default:
+		default: {
 			throw new UsageError(
-				"shortId() may not be called on a node with more than one identifier. Consider converting extraneous identifier fields to string fields.",
+				"The node has more than one identifier. Retrieve identifiers individually via their fields instead.",
 			);
+		}
 	}
 }
 

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

@@ -127,9 +127,8 @@ export function applySchemaToParserOptions(
 
 	return {
 		keyConverter:
-			config.keys !== KeyEncodingOptions.usePropertyKeys
-				? undefined
-				: {
+			config.keys === KeyEncodingOptions.usePropertyKeys
+				? {
 						encode: (type, key: FieldKey): string => {
 							// translate stored key into property key.
 							const simpleNodeSchema =
@@ -167,7 +166,8 @@ export function applySchemaToParserOptions(
 							}
 							return brand(inputKey);
 						},
-					},
+					}
+				: undefined,
 	};
 }
 
@@ -206,13 +206,16 @@ function verboseTreeAdapter(options: SchemalessParseOptions): CursorAdapter<Verb
 		},
 		type: (node: VerboseTree) => {
 			switch (typeof node) {
-				case "number":
+				case "number": {
 					return brand(numberSchema.identifier);
-				case "string":
+				}
+				case "string": {
 					return brand(stringSchema.identifier);
-				case "boolean":
+				}
+				case "boolean": {
 					return brand(booleanSchema.identifier);
-				default:
+				}
+				default: {
 					if (node === null) {
 						return brand(nullSchema.identifier);
 					}
@@ -220,6 +223,7 @@ function verboseTreeAdapter(options: SchemalessParseOptions): CursorAdapter<Verb
 						return brand(handleSchema.identifier);
 					}
 					return brand(node.type);
+				}
 			}
 		},
 		keysFromNode: (node: VerboseTree): readonly FieldKey[] => {
@@ -242,8 +246,9 @@ function verboseTreeAdapter(options: SchemalessParseOptions): CursorAdapter<Verb
 					}
 					return inputKeys.map((k) => converter.parse(node.type, k));
 				}
-				default:
+				default: {
 					return [];
+				}
 			}
 		},
 		getFieldFromNode: (node: VerboseTree, key: FieldKey): readonly VerboseTree[] => {

package/src/simple-tree/core/treeNodeKernel.ts

@@ -393,7 +393,9 @@ class KernelEventBuffer implements Listenable<KernelEvents> {
 		newSource: Listenable<KernelEvents> & HasListeners<KernelEvents>,
 	): void {
 		// Unsubscribe from the old source
-		this.#disposeSourceListeners.forEach((off) => off());
+		for (const off of this.#disposeSourceListeners.values()) {
+			off();
+		}
 		this.#disposeSourceListeners.clear();
 
 		this.#eventSource = newSource;
@@ -448,13 +450,16 @@ class KernelEventBuffer implements Listenable<KernelEvents> {
 	): void {
 		this.#assertNotDisposed();
 		switch (eventName) {
-			case "childrenChangedAfterBatch":
+			case "childrenChangedAfterBatch": {
 				assert(arg !== undefined, 0xc50 /* childrenChangedAfterBatch should have arg */);
 				return this.#handleChildrenChangedAfterBatch(arg.changedFields);
-			case "subtreeChangedAfterBatch":
+			}
+			case "subtreeChangedAfterBatch": {
 				return this.#handleSubtreeChangedAfterBatch();
-			default:
+			}
+			default: {
 				unreachableCase(eventName);
+			}
 		}
 	}
 
@@ -510,7 +515,9 @@ class KernelEventBuffer implements Listenable<KernelEvents> {
 		);
 
 		this.#disposeOnFlushListener();
-		this.#disposeSourceListeners.forEach((off) => off());
+		for (const off of this.#disposeSourceListeners.values()) {
+			off();
+		}
 		this.#disposeSourceListeners.clear();
 
 		this.#childrenChangedBuffer.clear();

package/src/simple-tree/core/unhydratedFlexTree.ts

@@ -5,7 +5,7 @@
 
 import { createEmitter } from "@fluid-internal/client-utils";
 import type { HasListeners, Listenable } from "@fluidframework/core-interfaces/internal";
-import { assert, oob, fail } from "@fluidframework/core-utils/internal";
+import { assert, oob, fail, debugAssert } from "@fluidframework/core-utils/internal";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 
 import {
@@ -38,16 +38,16 @@ import {
 	type FlexTreeHydratedContext,
 	type FlexFieldKind,
 	FieldKinds,
-	type SequenceFieldEditBuilder,
 	cursorForMapTreeNode,
-	type OptionalFieldEditBuilder,
-	type ValueFieldEditBuilder,
-	type FlexibleNodeContent,
+	type SequenceFieldEditor,
+	type RequiredFieldEditor,
 	type FlexTreeHydratedContextMinimal,
 	type FlexibleFieldContent,
 	type MapTreeFieldViewGeneric,
 	type MapTreeNodeViewGeneric,
 	type HydratedFlexTreeNode,
+	type FlexibleNodeContent,
+	type OptionalFieldEditor,
 	cursorForMapTreeField,
 	type MinimalFieldMap,
 	currentObserver,
@@ -59,7 +59,7 @@ import type { ContextualFieldProvider } from "../fieldSchema.js";
 import type { TreeNode } from "./treeNode.js";
 
 interface UnhydratedTreeSequenceFieldEditBuilder
-	extends SequenceFieldEditBuilder<FlexibleFieldContent, UnhydratedFlexTreeNode[]> {}
+	extends SequenceFieldEditor<FlexibleFieldContent, readonly FlexTreeNode[]> {}
 
 type UnhydratedFlexTreeNodeEvents = Pick<
 	AnchorEvents,
@@ -73,7 +73,7 @@ type LocationInField = FlexTreeNode["parentField"];
  * The {@link Unhydrated} implementation of {@link FlexTreeNode}.
  */
 export class UnhydratedFlexTreeNode
-	implements FlexTreeNode, MapTreeNodeViewGeneric<UnhydratedFlexTreeNode>
+	implements FlexTreeNode, MapTreeNodeViewGeneric<FlexTreeNode>
 {
 	public isHydrated(): this is HydratedFlexTreeNode {
 		return false;
@@ -187,7 +187,13 @@ export class UnhydratedFlexTreeNode
 	public adoptBy(parent: undefined): void;
 	public adoptBy(parent: UnhydratedFlexTreeField, index: number): void;
 	public adoptBy(parent: UnhydratedFlexTreeField | undefined, index?: number): void {
-		if (parent !== undefined) {
+		if (parent === undefined) {
+			assert(
+				this.location !== unparentedLocation,
+				0xa09 /* Node may not be un-adopted if it does not have a parent */,
+			);
+			this.location = unparentedLocation;
+		} else {
 			assert(index !== undefined, 0xa08 /* Expected index */);
 			if (this.location !== unparentedLocation) {
 				throw new UsageError("A node may not be in more than one place in the tree");
@@ -207,12 +213,6 @@ export class UnhydratedFlexTreeNode
 				unhydratedNode = parentNode;
 			}
 			this.location = { parent, index };
-		} else {
-			assert(
-				this.location !== unparentedLocation,
-				0xa09 /* Node may not be un-adopted if it does not have a parent */,
-			);
-			this.location = unparentedLocation;
 		}
 	}
 
@@ -226,7 +226,7 @@ export class UnhydratedFlexTreeNode
 	}
 
 	public borrowCursor(): ITreeCursorSynchronous {
-		return cursorForMapTreeNode<MapTreeNodeViewGeneric<UnhydratedFlexTreeNode>>(this);
+		return cursorForMapTreeNode<MapTreeNodeViewGeneric<FlexTreeNode>>(this);
 	}
 
 	public tryGetField(key: FieldKey): UnhydratedFlexTreeField | undefined {
@@ -300,6 +300,11 @@ export class UnhydratedContext implements FlexTreeContext {
 	public isHydrated(): this is FlexTreeHydratedContext {
 		return false;
 	}
+
+	public runInTransaction(fn: () => void): void {
+		debugAssert(() => !this.isDisposed() || "Disposed");
+		fn();
+	}
 }
 
 // #region Fields
@@ -327,7 +332,7 @@ const unparentedLocation: LocationInField = {
  * The {@link Unhydrated} implementation of {@link FlexTreeField}.
  */
 export class UnhydratedFlexTreeField
-	implements FlexTreeField, MapTreeFieldViewGeneric<UnhydratedFlexTreeNode>
+	implements FlexTreeField, MapTreeFieldViewGeneric<FlexTreeNode>
 {
 	public [flexTreeMarker] = FlexTreeEntityKind.Field as const;
 
@@ -344,25 +349,27 @@ export class UnhydratedFlexTreeField
 		 * See {@link fillPendingDefaults}.
 		 * Note that any fields using a {@link ConstantFieldProvider} should be evaluated before constructing the UnhydratedFlexTreeField.
 		 */
-		private lazyChildren: UnhydratedFlexTreeNode[] | ContextualFieldProvider,
+		private lazyChildren: FlexTreeNode[] | ContextualFieldProvider,
 	) {
 		// When this field is created (which only happens one time, because it is cached), all the children become parented for the first time.
 		// "Adopt" each child by updating its parent information to point to this field.
 		if (Array.isArray(lazyChildren)) {
 			for (const [i, child] of lazyChildren.entries()) {
-				child.adoptBy(this, i);
+				if (child instanceof UnhydratedFlexTreeNode) {
+					child.adoptBy(this, i);
+				} else {
+					// TODO: hook up events from hydrated to unhydrated nodes.
+				}
 			}
 		}
 	}
 
 	public borrowCursor(): ITreeCursorSynchronous {
-		return cursorForMapTreeField<MapTreeNodeViewGeneric<UnhydratedFlexTreeNode>>(
-			this.children,
-		);
+		return cursorForMapTreeField<MapTreeNodeViewGeneric<FlexTreeNode>>(this.children);
 	}
 
 	private getPendingDefault(): ContextualFieldProvider | undefined {
-		return !Array.isArray(this.lazyChildren) ? this.lazyChildren : undefined;
+		return Array.isArray(this.lazyChildren) ? undefined : this.lazyChildren;
 	}
 
 	/**
@@ -386,13 +393,13 @@ export class UnhydratedFlexTreeField
 		return this.getPendingDefault() !== undefined;
 	}
 
-	public get children(): UnhydratedFlexTreeNode[] {
+	public get children(): FlexTreeNode[] {
 		const provider = this.getPendingDefault();
 		if (provider) {
 			const content = provider("UseGlobalContext");
 			this.lazyChildren = content;
 		}
-		return this.lazyChildren as UnhydratedFlexTreeNode[];
+		return this.lazyChildren as FlexTreeNode[];
 	}
 
 	public get length(): number {
@@ -412,7 +419,7 @@ export class UnhydratedFlexTreeField
 		return m;
 	}
 
-	public [Symbol.iterator](): IterableIterator<UnhydratedFlexTreeNode> {
+	public [Symbol.iterator](): IterableIterator<FlexTreeNode> {
 		return this.children[Symbol.iterator]();
 	}
 
@@ -424,19 +431,17 @@ export class UnhydratedFlexTreeField
 	 * @remarks All edits to the field (i.e. mutations of the field's MapTrees) should be directed through this function.
 	 * This function ensures that the parent MapTree has no empty fields (which is an invariant of `MapTree`) after the mutation.
 	 */
-	protected edit(
-		edit: (mapTrees: UnhydratedFlexTreeNode[]) => void | UnhydratedFlexTreeNode[],
-	): void {
+	protected edit(edit: (mapTrees: FlexTreeNode[]) => void | FlexTreeNode[]): void {
 		// Clear parents for all old map trees.
 		for (const tree of this.children) {
-			tree.adoptBy(undefined);
+			orphan(tree);
 		}
 
 		this.lazyChildren = edit(this.children) ?? this.children;
 
 		// Set parents for all new map trees.
 		for (const [index, tree] of this.children.entries()) {
-			tree.adoptBy(this, index);
+			adoptNode(this, tree, index);
 		}
 
 		this.parent?.emitChangedEvent(this.key);
@@ -447,7 +452,7 @@ export class UnhydratedFlexTreeField
 	}
 
 	/** Unboxes leaf nodes to their values */
-	protected unboxed(index: number): TreeValue | UnhydratedFlexTreeNode {
+	protected unboxed(index: number): TreeValue | FlexTreeNode {
 		const child = this.children[index] ?? oob();
 		const value = child.value;
 		if (value !== undefined) {
@@ -457,6 +462,22 @@ export class UnhydratedFlexTreeField
 	}
 }
 
+function adoptNode(parent: UnhydratedFlexTreeField, node: FlexTreeNode, index: number): void {
+	if (node instanceof UnhydratedFlexTreeNode) {
+		node.adoptBy(parent, index);
+	} else {
+		// TODO: handle parenting for hydrated nodes.
+	}
+}
+
+function orphan(node: FlexTreeNode): void {
+	if (node instanceof UnhydratedFlexTreeNode) {
+		node.adoptBy(undefined);
+	} else {
+		// TODO: handle unparenting for hydrated nodes.
+	}
+}
+
 /**
  * The {@link Unhydrated} implementation of {@link FlexTreeOptionalField}.
  */
@@ -464,8 +485,9 @@ export class UnhydratedOptionalField
 	extends UnhydratedFlexTreeField
 	implements FlexTreeOptionalField
 {
-	public readonly editor = {
+	public readonly editor: OptionalFieldEditor<FlexibleNodeContent, FlexTreeNode> = {
 		set: (newContent: FlexibleNodeContent | undefined): void => {
+			// If the new content is a UnhydratedFlexTreeNode, it needs to have its parent pointer updated
 			if (newContent !== undefined) {
 				assert(
 					newContent instanceof UnhydratedFlexTreeNode,
@@ -474,15 +496,20 @@ export class UnhydratedOptionalField
 			}
 
 			this.edit((mapTrees) => {
-				if (newContent !== undefined) {
-					mapTrees[0] = newContent;
-				} else {
+				if (newContent === undefined) {
 					mapTrees.length = 0;
+				} else {
+					mapTrees[0] = newContent;
 				}
 			});
 		},
-	} satisfies OptionalFieldEditBuilder<FlexibleNodeContent> &
-		ValueFieldEditBuilder<FlexibleNodeContent>;
+		clear: (): void => {
+			this.editor.set(undefined, true /* <- dummy wasEmpty argument */);
+		},
+		attach: (content): void => {
+			this.editor.set(content, true /* <- dummy wasEmpty argument */);
+		},
+	};
 
 	public get content(): FlexTreeUnknownUnboxed | undefined {
 		const value = this.children[0];
@@ -494,17 +521,34 @@ export class UnhydratedOptionalField
 	}
 }
 
-class UnhydratedRequiredField
-	extends UnhydratedOptionalField
+export class UnhydratedRequiredField
+	extends UnhydratedFlexTreeField
 	implements FlexTreeRequiredField
 {
-	public override get content(): FlexTreeUnknownUnboxed {
+	public readonly editor: RequiredFieldEditor<FlexibleNodeContent, FlexTreeNode> = {
+		set: (newContent: FlexibleNodeContent): void => {
+			assert(
+				newContent instanceof UnhydratedFlexTreeNode,
+				0xbb7 /* Expected unhydrated node */,
+			);
+
+			this.edit((mapTrees) => {
+				mapTrees[0] = newContent;
+			});
+		},
+		attach: (content): void => {
+			this.editor.set(content);
+		},
+	};
+
+	public get content(): FlexTreeUnknownUnboxed {
+		const value = this.children[0];
 		// This cannot use ?? since null is a legal value here.
 		assert(
-			super.content !== undefined,
+			value !== undefined,
 			0xa57 /* Expected EagerMapTree required field to have a value */,
 		);
-		return super.content;
+		return this.unboxed(0);
 	}
 }
 
@@ -515,34 +559,41 @@ export class UnhydratedSequenceField
 	extends UnhydratedFlexTreeField
 	implements FlexTreeSequenceField
 {
-	public readonly editor = {
+	public readonly editor: SequenceFieldEditor<
+		readonly FlexibleNodeContent[],
+		readonly FlexTreeNode[],
+		FlexTreeNode[]
+	> = {
 		insert: (index, newContent): void => {
 			for (const c of newContent) {
 				assert(c !== undefined, 0xa0a /* Unexpected sparse array content */);
-				assert(c instanceof UnhydratedFlexTreeNode, 0xbb8 /* Expected unhydrated node */);
+				// TODO: ensure somewhere checks for not already having parents
 			}
-			const newContentChecked = newContent as readonly UnhydratedFlexTreeNode[];
+			const newContentChecked: readonly FlexTreeNode[] = newContent;
 			this.edit((mapTrees) => {
 				if (newContent.length < 1000) {
 					// For "smallish arrays" (`1000` is not empirically derived), the `splice` function is appropriate...
 					mapTrees.splice(index, 0, ...newContentChecked);
 				} else {
 					// ...but we avoid using `splice` + spread for very large input arrays since there is a limit on how many elements can be spread (too many will overflow the stack).
-					return mapTrees.slice(0, index).concat(newContentChecked, mapTrees.slice(index));
+					return [...mapTrees.slice(0, index), ...newContentChecked, ...mapTrees.slice(index)];
 				}
 			});
 		},
-		remove: (index, count): UnhydratedFlexTreeNode[] => {
+		remove: (index, count): FlexTreeNode[] => {
 			for (let i = index; i < index + count; i++) {
 				const c = this.children[i];
 				assert(c !== undefined, 0xa0b /* Unexpected sparse array */);
 			}
-			let removed: UnhydratedFlexTreeNode[] | undefined;
+			let removed: FlexTreeNode[] | undefined;
 			this.edit((mapTrees) => {
 				removed = mapTrees.splice(index, count);
 			});
 			return removed ?? fail(0xb4a /* Expected removed to be set by edit */);
 		},
+		attach: (index, content: readonly FlexTreeNode[]): void => {
+			this.editor.insert(index, content);
+		},
 	} satisfies UnhydratedTreeSequenceFieldEditBuilder;
 
 	public at(index: number): FlexTreeUnknownUnboxed | undefined {
@@ -565,17 +616,22 @@ export function createField(
 ): UnhydratedFlexTreeField {
 	switch (args[1]) {
 		case FieldKinds.required.identifier:
-		case FieldKinds.identifier.identifier:
+		case FieldKinds.identifier.identifier: {
 			return new UnhydratedRequiredField(...args);
-		case FieldKinds.optional.identifier:
+		}
+		case FieldKinds.optional.identifier: {
 			return new UnhydratedOptionalField(...args);
-		case FieldKinds.sequence.identifier:
+		}
+		case FieldKinds.sequence.identifier: {
 			return new UnhydratedSequenceField(...args);
-		case FieldKinds.forbidden.identifier:
+		}
+		case FieldKinds.forbidden.identifier: {
 			// TODO: this seems to used by unknown optional fields. They should probably use "optional" not "Forbidden" schema.
 			return new UnhydratedFlexTreeField(...args);
-		default:
+		}
+		default: {
 			return fail(0xb9d /* unsupported field kind */);
+		}
 	}
 }
 

package/src/simple-tree/fieldSchema.ts

@@ -8,7 +8,10 @@ import { Lazy } from "@fluidframework/core-utils/internal";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 
 import type { FieldKey } from "../core/index.js";
-import type { FlexTreeHydratedContextMinimal } from "../feature-libraries/index.js";
+import type {
+	FlexTreeHydratedContextMinimal,
+	FlexTreeNode,
+} from "../feature-libraries/index.js";
 import {
 	type MakeNominal,
 	brand,
@@ -22,7 +25,6 @@ import {
 import type {
 	TreeNodeSchema,
 	TreeNode,
-	UnhydratedFlexTreeNode,
 	ImplicitAllowedTypes,
 	TreeNodeFromImplicitAllowedTypes,
 	TreeLeafValue,
@@ -190,11 +192,11 @@ export interface FieldPropsAlpha<TCustomMetadata = unknown>
  */
 export type ContextualFieldProvider = (
 	context: FlexTreeHydratedContextMinimal | "UseGlobalContext",
-) => UnhydratedFlexTreeNode[];
+) => FlexTreeNode[];
 /**
  * A {@link FieldProvider} which can produce its content in a vacuum.
  */
-export type ConstantFieldProvider = () => UnhydratedFlexTreeNode[];
+export type ConstantFieldProvider = () => FlexTreeNode[];
 /**
  * A function which produces content for a field every time that it is called.
  */

package/src/simple-tree/getTreeNodeForField.ts

@@ -44,7 +44,8 @@ export function tryGetTreeNodeForField(
 			return (field as FlexTreeRequiredField).content as string;
 		}
 
-		default:
+		default: {
 			fail(0xadf /* invalid field kind */);
+		}
 	}
 }