@fluidframework/tree 2.118.0 → 3.0.0

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

@@ -39,90 +39,11 @@ import {
 import { isArrayNodeSchema, isObjectNodeSchema } from "../node-kinds/index.js";
 
 import type { TreeChangeEvents } from "./treeChangeEvents.js";
-
-/**
- * A `"retain"` op in an {@link ArrayNodeDeltaOp} sequence.
- * Represents elements that were neither inserted into nor removed from the array.
- * @sealed @alpha
- */
-export interface ArrayNodeRetainOp {
-	readonly type: "retain";
-	readonly count: number;
-}
-
-/**
- * A `"retain"` op in an {@link ArrayNodeTreeChangedDeltaOp} sequence, used in
- * {@link NodeChangedDataTreeDelta} payloads delivered to
- * {@link TreeChangeEventsAlpha.treeChanged} on array nodes.
- *
- * Extends {@link ArrayNodeRetainOp} with a {@link ArrayNodeTreeChangedRetainOp.subtreeChanged}
- * flag that indicates whether any descendant of the retained element changed.
- * @sealed @alpha
- */
-export interface ArrayNodeTreeChangedRetainOp extends ArrayNodeRetainOp {
-	/**
-	 * Whether any descendant of this retained element changed.
-	 * `true` if the element's subtree changed; `false` if nothing changed within it.
-	 * @remarks
-	 * Subscribe to `nodeChanged` or `treeChanged` on the element node itself for details.
-	 */
-	readonly subtreeChanged: boolean;
-}
-
-/**
- * A single operation in an array-node delta delivered by {@link TreeChangeEventsAlpha.treeChanged}.
- * Extends {@link ArrayNodeDeltaOp}: retain ops carry a {@link ArrayNodeTreeChangedRetainOp.subtreeChanged}
- * flag indicating whether any descendant of the retained element changed.
- * @alpha
- */
-export type ArrayNodeTreeChangedDeltaOp =
-	| ArrayNodeTreeChangedRetainOp
-	| ArrayNodeInsertOp
-	| ArrayNodeRemoveOp;
-
-/**
- * An `"insert"` op in an {@link ArrayNodeDeltaOp} sequence.
- * Represents elements added to the array.
- * Read the new element values from the current tree at the positions described by this op.
- * @sealed @alpha
- */
-export interface ArrayNodeInsertOp {
-	readonly type: "insert";
-	readonly count: number;
-}
-
-/**
- * A `"remove"` op in an {@link ArrayNodeDeltaOp} sequence.
- * Represents elements removed from the array.
- * @sealed @alpha
- */
-export interface ArrayNodeRemoveOp {
-	readonly type: "remove";
-	readonly count: number;
-}
-
-/**
- * A single operation in an array node change delta. Used to efficiently sync an external
- * representation of an array (e.g. a text editor or virtual list) with tree changes without
- * needing to snapshot the old state or diff the entire array. Each op describes a contiguous run
- * of positions in the array before the change. For inserts, read the new element values from the
- * current tree at those positions.
- *
- * @remarks
- * There is no dedicated `"move"` op. Moves are represented as `"remove"` + `"insert"`.
- * When an element is moved within the same array it appears
- * as a `"remove"` at the source position followed by an `"insert"` at the destination position.
- * When an element is moved across two different arrays, the source array's delta contains a
- * `"remove"` and the destination array's delta contains an `"insert"` — they cannot be
- * correlated without additional bookkeeping on the caller's side.
- *
- * The operations cover the complete array: trailing elements that were not changed are included
- * in a final `"retain"` op. Applying every operation therefore consumes the entire pre-edit array
- * and produces the entire post-edit array.
- *
- * @sealed @alpha
- */
-export type ArrayNodeDeltaOp = ArrayNodeRetainOp | ArrayNodeInsertOp | ArrayNodeRemoveOp;
+import type {
+	ArrayNodeInsertOp,
+	ArrayNodeRemoveOp,
+	ArrayNodeRetainOp,
+} from "./treeChangeEventsBeta.js";
 
 /**
  * Provides various functions for analyzing {@link TreeNode}s.
@@ -284,7 +205,7 @@ export const treeNodeApi: TreeNodeApi = {
 						const marks = fieldMarks.get(EmptyKey);
 						// nodeChanged fires only for shallow changes (insert, remove, move).
 						// Deep changes (e.g. a property of an element changed) are
-						// surfaced via TreeChangeEventsAlpha.treeChanged with a delta payload instead.
+						// surfaced via TreeChangeEventsBeta.treeChanged with a delta payload instead.
 						// When marks are undefined (marks could not be composed across multiple
 						// internal passes), we conservatively fire nodeChanged rather than silently
 						// dropping the event, even though the underlying change may have been

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

@@ -3,6 +3,7 @@
  * Licensed under the MIT License.
  */
 
+import type { FluidIterableIterator, FluidReadonlyMap } from "@fluidframework/core-interfaces";
 import type {
 	IsUnion,
 	RestrictiveStringRecord,
@@ -350,34 +351,35 @@ export namespace System_Unsafe {
 	 */
 	export interface ReadonlyMapInlined<K, T extends ImplicitAllowedTypesUnsafe> {
 		/** Returns an iterable of entries in the map. */
-		[Symbol.iterator](): IterableIterator<[K, TreeNodeFromImplicitAllowedTypesUnsafe<T>]>;
+		[Symbol.iterator](): FluidIterableIterator<[K, TreeNodeFromImplicitAllowedTypesUnsafe<T>]>;
 
 		/**
 		 * Returns an iterable of key, value pairs for every entry in the map.
 		 */
-		entries(): IterableIterator<[K, TreeNodeFromImplicitAllowedTypesUnsafe<T>]>;
+		entries(): FluidIterableIterator<[K, TreeNodeFromImplicitAllowedTypesUnsafe<T>]>;
 
 		/**
 		 * Returns an iterable of keys in the map
 		 */
-		keys(): IterableIterator<K>;
+		keys(): FluidIterableIterator<K>;
 
 		/**
 		 * Returns an iterable of values in the map
 		 */
-		values(): IterableIterator<TreeNodeFromImplicitAllowedTypesUnsafe<T>>;
+		values(): FluidIterableIterator<TreeNodeFromImplicitAllowedTypesUnsafe<T>>;
 
 		forEach(
 			callbackfn: (
 				value: TreeNodeFromImplicitAllowedTypesUnsafe<T>,
 				key: K,
-				map: ReadonlyMap<K, TreeNodeFromImplicitAllowedTypesUnsafe<T>>,
+				map: FluidReadonlyMap<K, TreeNodeFromImplicitAllowedTypesUnsafe<T>>,
 			) => void,
 			thisArg?: any,
 		): void;
 		get(key: K): TreeNodeFromImplicitAllowedTypesUnsafe<T> | undefined;
 		has(key: K): boolean;
 		readonly size: number;
+		readonly [Symbol.toStringTag]: string;
 	}
 
 	/**
@@ -593,7 +595,7 @@ export interface TreeRecordNodeUnsafe<
 	TAllowedTypes extends System_Unsafe.ImplicitAllowedTypesUnsafe,
 > extends Record<string, System_Unsafe.TreeNodeFromImplicitAllowedTypesUnsafe<TAllowedTypes>>,
 		TreeNode {
-	[Symbol.iterator](): IterableIterator<
+	[Symbol.iterator](): FluidIterableIterator<
 		[string, System_Unsafe.TreeNodeFromImplicitAllowedTypesUnsafe<TAllowedTypes>]
 	>;
 }

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

@@ -18,7 +18,7 @@ export {
 } from "./treeNodeKernel.js";
 export {
 	type WithType,
-	typeNameSymbol,
+	schemaIdentifierBrand,
 	typeSchemaSymbol,
 	contentSchemaSymbol,
 } from "./withType.js";

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

@@ -9,12 +9,7 @@ import { UsageError } from "@fluidframework/telemetry-utils/internal";
 import { markEager } from "./flexList.js";
 import { tryGetTreeNodeSchema } from "./treeNodeKernel.js";
 import { NodeKind, type TreeNodeSchemaClass } from "./treeNodeSchema.js";
-import type {
-	WithType,
-	// eslint-disable-next-line import-x/no-deprecated -- Required to implement the deprecated typeNameSymbol API.
-	typeNameSymbol,
-	typeSchemaSymbol,
-} from "./withType.js";
+import type { WithType, schemaIdentifierBrand, typeSchemaSymbol } from "./withType.js";
 
 /**
  * A non-{@link NodeKind.Leaf|leaf} SharedTree node. Includes objects, arrays, and maps.
@@ -80,12 +75,10 @@ export abstract class TreeNode implements WithType {
 	readonly #brand!: unknown;
 
 	/**
-	 * Adds a schema identifier brand for stronger and more efficient type checking.
+	 * Adds a `schemaIdentifierBrand` for stronger and more efficient type checking.
 	 * @privateRemarks Subclasses provide more specific values to distinguish otherwise type-compatible nodes.
-	 * @deprecated Use {@link typeSchemaSymbol} instead.
 	 */
-	// eslint-disable-next-line import-x/no-deprecated -- Required to implement the deprecated typeNameSymbol API.
-	public abstract get [typeNameSymbol](): string;
+	public abstract get [schemaIdentifierBrand](): string;
 
 	/**
 	 * {@inheritDoc typeSchemaSymbol}

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

@@ -3,8 +3,7 @@
  * Licensed under the MIT License.
  */
 
-// Used by doc links:
-// eslint-disable-next-line @typescript-eslint/no-unused-vars, unused-imports/no-unused-imports
+// eslint-disable-next-line @typescript-eslint/no-unused-vars, unused-imports/no-unused-imports -- Imported only for documentation links.
 import type { TreeAlpha } from "../../shared-tree/index.js";
 
 import type { TreeNode } from "./treeNode.js";
@@ -12,23 +11,22 @@ import type { NodeKind, TreeNodeSchemaClass } from "./treeNodeSchema.js";
 
 /**
  * An internal brand to improve compiler performance.
- * For more information about the type, use `Tree.schema(theNode)` instead.
+ * For more information about the type, use {@link TreeNodeApi.schema | Tree.schema(theNode)} instead.
  * @remarks
- * `Tree.is` and `Tree.schema` provide a superset of this information in more friendly ways.
+ * {@link TreeNodeApi.is | Tree.is} and {@link TreeNodeApi.schema | Tree.schema} provide a superset of this information in more friendly ways.
  * @privateRemarks
  * The identifier of a {@link TreeNode}'s schema.
  * This allows the type checker to distinguish different node types more efficiently than via {@link typeSchemaSymbol}.
- * @deprecated External code should use `Tree.schema(theNode)` for schema related runtime data access. For type narrowing, use {@link WithType} instead of the symbols directly.
  * @system @public
  */
-export const typeNameSymbol: unique symbol = Symbol("TreeNode Type");
+export const schemaIdentifierBrand: unique symbol = Symbol("TreeNode Schema Identifier Brand");
 
 /**
  * The type of a {@link TreeNode}.
- * For more information about the type, use `Tree.schema(theNode)` instead.
+ * For more information about the type, use {@link TreeNodeApi.schema | Tree.schema(theNode)} instead.
  * @remarks
  * This symbol mainly exists on nodes to allow TypeScript to provide more accurate type checking.
- * `Tree.is` and `Tree.schema` provide a superset of this information in more friendly ways.
+ * {@link TreeNodeApi.is | Tree.is} and {@link TreeNodeApi.schema | Tree.schema} provide a superset of this information in more friendly ways.
  *
  * This symbol should not manually be added to objects as doing so allows the object to be invalidly used where specific nodes are expected.
  * Instead construct a real node of the desired type using its constructor.
@@ -111,7 +109,7 @@ export interface WithType<
 	/**
 	 * Type symbol, marking a type in a way to increase type safety via strong type checking.
 	 *
-	 * Use `Tree.schema(theNode)` for schema related runtime data access. For type narrowing, use `WithType` instead of the symbols directly.
+	 * Use {@link TreeNodeApi.schema | Tree.schema(theNode)} for schema related runtime data access. For type narrowing, use {@link WithType} instead of the symbols directly.
 	 * @remarks
 	 * This should be redundant with {@link typeSchemaSymbol}, but is kept for improved compiler performance.
 	 * If we just rely on {@link typeSchemaSymbol}, the compiler has to work much harder to distinguish schema in unions,
@@ -119,9 +117,8 @@ export interface WithType<
 	 *
 	 * This property is not intended for any use other than helping the compiler distinguish schema types,
 	 * and should not be referenced in any code other than internal to the tree package.
-	 * @deprecated Use {@link typeSchemaSymbol} instead.
 	 */
-	get [typeNameSymbol](): TName;
+	get [schemaIdentifierBrand](): TName;
 
 	/**
 	 * Type symbol, marking a type in a way to increase type safety via strong type checking.

package/src/simple-tree/index.ts

@@ -4,7 +4,7 @@
  */
 
 export {
-	typeNameSymbol,
+	schemaIdentifierBrand,
 	typeSchemaSymbol,
 	contentSchemaSymbol,
 	type WithType,
@@ -104,16 +104,11 @@ export {
 	type ArrayNodeTreeChangedDeltaOp,
 	type ArrayNodeTreeChangedRetainOp,
 	type NodeChangedData,
-	type NodeChangedDataAlpha,
 	type NodeChangedDataDelta,
 	type NodeChangedDataProperties,
 	type NodeChangedDataTreeDelta,
-	borrowCursorFromTreeNodeOrValue,
-	exportConcise,
-	importConcise,
-	TreeBeta,
+	cloneTree,
 	type TreeChangeEventsBeta,
-	type TreeChangeEventsAlpha,
 	type IdentifierIndex,
 	createTreeIndex,
 	createIdentifierIndex,
@@ -171,6 +166,7 @@ export {
 	type TreeBranchEvents,
 	type TreeBranchCommitMetadata,
 	type TreeBranchHistory,
+	type TreeContextBeta,
 	getPropertyKeyFromStoredKey,
 	getStoredKey,
 	tryGetSchema,

package/src/simple-tree/node-kinds/array/arrayNode.ts

@@ -3,6 +3,10 @@
  * Licensed under the MIT License.
  */
 
+import type {
+	FluidIterableIterator,
+	FluidReadonlyArray,
+} from "@fluidframework/core-interfaces";
 import { Lazy, oob, fail, assert, clamp } from "@fluidframework/core-utils/internal";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 
@@ -23,8 +27,7 @@ import type { NodeSchemaOptionsAlpha, System_Unsafe } from "../../api/index.js";
 import {
 	CompatibilityLevel,
 	type WithType,
-	// eslint-disable-next-line import-x/no-deprecated -- Required to implement the deprecated typeNameSymbol API.
-	typeNameSymbol,
+	schemaIdentifierBrand,
 	NodeKind,
 	type TreeNode,
 	type InternalTreeNode,
@@ -84,7 +87,7 @@ import type {
  * @system @sealed @public
  */
 export interface ReadonlyArrayNode<out T = TreeNode | TreeLeafValue>
-	extends ReadonlyArray<T>,
+	extends FluidReadonlyArray<T>,
 		Awaited<TreeNode & WithType<string, NodeKind.Array>> {}
 
 /**
@@ -463,7 +466,7 @@ export interface TreeArrayNode<
 	/**
 	 * Returns a custom IterableIterator which throws usage errors if concurrent editing and iteration occurs.
 	 */
-	values(): IterableIterator<T>;
+	values(): FluidIterableIterator<T>;
 }
 
 /**
@@ -737,15 +740,15 @@ const TreeNodeWithArrayFeatures = (() => {
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 declare abstract class NodeWithArrayFeatures<Input, T>
 	extends TreeNodeValid<Input>
-	implements Pick<readonly T[], (typeof arrayPrototypeKeys)[number]>
+	implements Pick<FluidReadonlyArray<T>, (typeof arrayPrototypeKeys)[number]>
 {
 	concat(...items: ConcatArray<T>[]): T[];
 	concat(...items: (T | ConcatArray<T>)[]): T[];
-	entries(): IterableIterator<[number, T]>;
+	entries(): FluidIterableIterator<[number, T]>;
 	every<S extends T>(
 		predicate: (value: T, index: number, array: readonly T[]) => value is S,
 		thisArg?: any,
-	): this is readonly S[];
+	): this is FluidReadonlyArray<S>;
 	every(
 		predicate: (value: T, index: number, array: readonly T[]) => unknown,
 		thisArg?: any,
@@ -782,7 +785,7 @@ declare abstract class NodeWithArrayFeatures<Input, T>
 	includes(searchElement: T, fromIndex?: number | undefined): boolean;
 	indexOf(searchElement: T, fromIndex?: number | undefined): number;
 	join(separator?: string | undefined): string;
-	keys(): IterableIterator<number>;
+	keys(): FluidIterableIterator<number>;
 	lastIndexOf(searchElement: T, fromIndex?: number | undefined): number;
 	map<U>(callbackfn: (value: T, index: number, array: readonly T[]) => U, thisArg?: any): U[];
 	reduce(
@@ -1100,7 +1103,7 @@ abstract class CustomArrayNodeBase<const T extends ImplicitAllowedTypes>
 		return fail(0xadb /* Proxy should intercept length */);
 	}
 
-	public [Symbol.iterator](): IterableIterator<TreeNodeFromImplicitAllowedTypes<T>> {
+	public [Symbol.iterator](): FluidIterableIterator<TreeNodeFromImplicitAllowedTypes<T>> {
 		return this.values();
 	}
 
@@ -1398,7 +1401,7 @@ abstract class CustomArrayNodeBase<const T extends ImplicitAllowedTypes>
 		}
 	}
 
-	public values(): IterableIterator<TreeNodeFromImplicitAllowedTypes<T>> {
+	public values(): FluidIterableIterator<TreeNodeFromImplicitAllowedTypes<T>> {
 		return this.generateValues(getKernel(this).generationNumber);
 	}
 	private *generateValues(
@@ -1549,8 +1552,7 @@ export function arraySchema<
 		public static readonly persistedMetadata: JsonCompatibleReadOnlyObject | undefined =
 			persistedMetadata;
 
-		// eslint-disable-next-line import-x/no-deprecated -- Required to implement the deprecated typeNameSymbol API.
-		public get [typeNameSymbol](): TName {
+		public get [schemaIdentifierBrand](): TName {
 			return identifier;
 		}
 		public get [typeSchemaSymbol](): Output {

package/src/simple-tree/node-kinds/map/mapNode.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import type { FluidReadonlyMap } from "@fluidframework/core-interfaces/internal";
+import type { FluidIterableIterator, FluidReadonlyMap } from "@fluidframework/core-interfaces";
 import { assert, Lazy } from "@fluidframework/core-utils/internal";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 
@@ -33,8 +33,7 @@ import {
 	type InnerNode,
 	NodeKind,
 	type TreeNodeSchema,
-	// eslint-disable-next-line import-x/no-deprecated -- Required to implement the deprecated typeNameSymbol API.
-	typeNameSymbol,
+	schemaIdentifierBrand,
 	type TreeNode,
 	typeSchemaSymbol,
 	getInnerNode,
@@ -82,7 +81,7 @@ import type {
  * @sealed @public
  */
 export interface TreeMapNode<T extends ImplicitAllowedTypes = ImplicitAllowedTypes>
-	extends ReadonlyMap<string, TreeNodeFromImplicitAllowedTypes<T>>,
+	extends FluidReadonlyMap<string, TreeNodeFromImplicitAllowedTypes<T>>,
 		TreeNode {
 	/**
 	 * Adds or updates an entry in the map with a specified `key` and a `value`.
@@ -118,8 +117,7 @@ export interface TreeMapNode<T extends ImplicitAllowedTypes = ImplicitAllowedTyp
 	 * Note: no guarantees are made regarding the order of the keys returned.
 	 * If your usage scenario depends on consistent ordering, you will need to sort these yourself.
 	 */
-	keys(): IterableIterator<string>;
-
+	keys(): FluidIterableIterator<string>;
 	/**
 	 * Returns an iterable of values in the map.
 	 *
@@ -127,7 +125,7 @@ export interface TreeMapNode<T extends ImplicitAllowedTypes = ImplicitAllowedTyp
 	 * Note: no guarantees are made regarding the order of the values returned.
 	 * If your usage scenario depends on consistent ordering, you will need to sort these yourself.
 	 */
-	values(): IterableIterator<TreeNodeFromImplicitAllowedTypes<T>>;
+	values(): FluidIterableIterator<TreeNodeFromImplicitAllowedTypes<T>>;
 
 	/**
 	 * Returns an iterable of key, value pairs for every entry in the map.
@@ -136,7 +134,7 @@ export interface TreeMapNode<T extends ImplicitAllowedTypes = ImplicitAllowedTyp
 	 * Note: no guarantees are made regarding the order of the entries returned.
 	 * If your usage scenario depends on consistent ordering, you will need to sort these yourself.
 	 */
-	entries(): IterableIterator<[string, TreeNodeFromImplicitAllowedTypes<T>]>;
+	entries(): FluidIterableIterator<[string, TreeNodeFromImplicitAllowedTypes<T>]>;
 
 	/**
 	 * Executes the provided function once per each key/value pair in this map.
@@ -149,7 +147,7 @@ export interface TreeMapNode<T extends ImplicitAllowedTypes = ImplicitAllowedTyp
 		callbackfn: (
 			value: TreeNodeFromImplicitAllowedTypes<T>,
 			key: string,
-			map: ReadonlyMap<string, TreeNodeFromImplicitAllowedTypes<T>>,
+			map: FluidReadonlyMap<string, TreeNodeFromImplicitAllowedTypes<T>>,
 		) => void,
 		// Typing inherited from `ReadonlyMap`.
 		// eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -309,7 +307,9 @@ abstract class CustomMapNodeBase<const T extends ImplicitAllowedTypes> extends T
 		super(input ?? []);
 	}
 
-	public [Symbol.iterator](): IterableIterator<[string, TreeNodeFromImplicitAllowedTypes<T>]> {
+	public [Symbol.iterator](): FluidIterableIterator<
+		[string, TreeNodeFromImplicitAllowedTypes<T>]
+	> {
 		return this.entries();
 	}
 
@@ -326,7 +326,7 @@ abstract class CustomMapNodeBase<const T extends ImplicitAllowedTypes> extends T
 		const field = this.innerNode.getBoxed(brand(key));
 		this.editor(key).set(undefined, field.length === 0);
 	}
-	public *entries(): IterableIterator<[string, TreeNodeFromImplicitAllowedTypes<T>]> {
+	public *entries(): FluidIterableIterator<[string, TreeNodeFromImplicitAllowedTypes<T>]> {
 		const node = this.innerNode;
 		for (const key of node.keys()) {
 			yield [
@@ -343,7 +343,7 @@ abstract class CustomMapNodeBase<const T extends ImplicitAllowedTypes> extends T
 	public has(key: string): boolean {
 		return this.innerNode.tryGetField(brand(key)) !== undefined;
 	}
-	public *keys(): IterableIterator<string> {
+	public *keys(): Generator<string, void, undefined> {
 		const node = this.innerNode;
 		yield* node.keys();
 	}
@@ -395,7 +395,7 @@ abstract class CustomMapNodeBase<const T extends ImplicitAllowedTypes> extends T
 	public get size(): number {
 		return count(this.innerNode.keys());
 	}
-	public *values(): IterableIterator<TreeNodeFromImplicitAllowedTypes<T>> {
+	public *values(): FluidIterableIterator<TreeNodeFromImplicitAllowedTypes<T>> {
 		for (const [, value] of this.entries()) {
 			yield value;
 		}
@@ -506,8 +506,7 @@ export function mapSchema<
 		public static readonly persistedMetadata: JsonCompatibleReadOnlyObject | undefined =
 			persistedMetadata;
 
-		// eslint-disable-next-line import-x/no-deprecated -- Required to implement the deprecated typeNameSymbol API.
-		public get [typeNameSymbol](): TName {
+		public get [schemaIdentifierBrand](): TName {
 			return identifier;
 		}
 		public get [typeSchemaSymbol](): typeof schemaErased {

package/src/simple-tree/node-kinds/object/objectNode.ts

@@ -32,8 +32,7 @@ import {
 	type TreeNodeSchema,
 	NodeKind,
 	type WithType,
-	// eslint-disable-next-line import-x/no-deprecated -- Required to handle the deprecated typeNameSymbol API.
-	typeNameSymbol,
+	schemaIdentifierBrand,
 	typeSchemaSymbol,
 	type InternalTreeNode,
 	type TreeNode,
@@ -335,8 +334,7 @@ function createProxyHandler(
 			if (propertyKey === typeSchemaSymbol) {
 				return schema;
 			}
-			// eslint-disable-next-line import-x/no-deprecated -- Required to handle the deprecated typeNameSymbol API.
-			if (propertyKey === typeNameSymbol) {
+			if (propertyKey === schemaIdentifierBrand) {
 				return schema.identifier;
 			}
 
@@ -633,8 +631,7 @@ export function objectSchema<
 		public static readonly persistedMetadata: JsonCompatibleReadOnlyObject | undefined =
 			nodeOptions.persistedMetadata;
 
-		// eslint-disable-next-line import-x/no-deprecated -- Required to implement the deprecated typeNameSymbol API.
-		public get [typeNameSymbol](): TName {
+		public get [schemaIdentifierBrand](): TName {
 			return identifier;
 		}
 		public get [typeSchemaSymbol](): Output {

package/src/simple-tree/node-kinds/record/recordNode.ts

@@ -3,6 +3,7 @@
  * Licensed under the MIT License.
  */
 
+import type { FluidIterableIterator } from "@fluidframework/core-interfaces";
 import { assert, Lazy } from "@fluidframework/core-utils/internal";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 
@@ -17,8 +18,7 @@ import type { NodeSchemaOptionsAlpha } from "../../api/index.js";
 import {
 	type TreeNodeSchema,
 	NodeKind,
-	// eslint-disable-next-line import-x/no-deprecated -- Required to handle the deprecated typeNameSymbol API.
-	typeNameSymbol,
+	schemaIdentifierBrand,
 	typeSchemaSymbol,
 	type UnhydratedFlexTreeNode,
 	getInnerNode,
@@ -78,8 +78,7 @@ function createRecordNodeProxy(
 					case typeSchemaSymbol: {
 						return schema;
 					}
-					// eslint-disable-next-line import-x/no-deprecated -- Required to handle the deprecated typeNameSymbol API.
-					case typeNameSymbol: {
+					case schemaIdentifierBrand: {
 						return schema.identifier;
 					}
 					case Symbol.iterator: {
@@ -370,15 +369,14 @@ export function recordSchema<
 		public static readonly persistedMetadata: JsonCompatibleReadOnlyObject | undefined =
 			persistedMetadata;
 
-		// eslint-disable-next-line import-x/no-deprecated -- Required to implement the deprecated typeNameSymbol API.
-		public get [typeNameSymbol](): TName {
+		public get [schemaIdentifierBrand](): TName {
 			return identifier;
 		}
 		public get [typeSchemaSymbol](): Output {
 			return Schema.constructorCached?.constructor as unknown as Output;
 		}
 
-		public [Symbol.iterator](): IterableIterator<
+		public [Symbol.iterator](): FluidIterableIterator<
 			[string, TreeNodeFromImplicitAllowedTypes<TAllowedTypes>]
 		> {
 			return recordIterator(this);
@@ -412,7 +410,7 @@ export function recordSchema<
 
 function* recordIterator<TAllowedTypes extends ImplicitAllowedTypes>(
 	record: TreeRecordNode<TAllowedTypes>,
-): IterableIterator<[string, TreeNodeFromImplicitAllowedTypes<TAllowedTypes>]> {
+): FluidIterableIterator<[string, TreeNodeFromImplicitAllowedTypes<TAllowedTypes>]> {
 	for (const [key, value] of Object.entries(record)) {
 		yield [key, value];
 	}

package/src/simple-tree/node-kinds/record/recordNodeTypes.ts

@@ -3,6 +3,7 @@
  * Licensed under the MIT License.
  */
 
+import type { FluidIterableIterator } from "@fluidframework/core-interfaces";
 import type { RestrictiveStringRecord } from "../../../util/index.js";
 import { NodeKind } from "../../core/index.js";
 import type {
@@ -50,7 +51,7 @@ export interface TreeRecordNode<
 	/**
 	 * Allows the record's entries to be iterated over, including in contexts like `for...of` loops.
 	 */
-	[Symbol.iterator](): IterableIterator<
+	[Symbol.iterator](): FluidIterableIterator<
 		[string, TreeNodeFromImplicitAllowedTypes<TAllowedTypes>]
 	>;
 }