@fluidframework/tree 2.117.0 → 3.0.0

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

@@ -0,0 +1,245 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import type { NodeKind, TreeNode, WithType } from "../core/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 @beta
+ */
+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 TreeChangeEventsBeta.treeChanged} on array nodes.
+ *
+ * Extends {@link ArrayNodeRetainOp} with a {@link ArrayNodeTreeChangedRetainOp.subtreeChanged}
+ * flag that indicates whether any descendant of the retained element changed.
+ * @sealed @beta
+ */
+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 TreeChangeEventsBeta.treeChanged}.
+ * Extends {@link ArrayNodeDeltaOp}: retain ops carry a {@link ArrayNodeTreeChangedRetainOp.subtreeChanged}
+ * flag indicating whether any descendant of the retained element changed.
+ * @beta
+ */
+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 @beta
+ */
+export interface ArrayNodeInsertOp {
+	readonly type: "insert";
+	readonly count: number;
+}
+
+/**
+ * A `"remove"` op in an {@link ArrayNodeDeltaOp} sequence.
+ * Represents elements removed from the array.
+ * @sealed @beta
+ */
+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 @beta
+ */
+export type ArrayNodeDeltaOp = ArrayNodeRetainOp | ArrayNodeInsertOp | ArrayNodeRemoveOp;
+
+/**
+ * Data included for {@link TreeChangeEventsBeta.nodeChanged}.
+ * @sealed @beta
+ */
+export interface NodeChangedData<TNode extends TreeNode = TreeNode> {
+	/**
+	 * When the changed node is an object, map, or record node, this lists all the properties which changed.
+	 * @remarks
+	 * This only includes changes to the node itself (which would trigger {@link TreeChangeEvents.nodeChanged}).
+	 *
+	 * Not present when the {@link NodeKind} does not support this feature (currently just array nodes).
+	 *
+	 * When defined, the set should never be empty, since `nodeChanged` will only be triggered when there is a change, and for the supported node types, the only things that can change are properties.
+	 */
+	readonly changedProperties?: ReadonlySet<
+		// For Object nodes, strongly type with the property names from the schema:
+		TNode extends WithType<string, NodeKind.Object, infer TInfo>
+			? string & keyof TInfo
+			: string
+	>;
+
+	/**
+	 * When the changed node is an array node, the sequential operations describing what changed.
+	 * @remarks
+	 * Not present for non-array nodes. When present, the value may be `undefined` when the
+	 * document was updated in a way that required multiple internal change passes in a single
+	 * operation (for example, a data change combined with a schema upgrade).
+	 */
+	readonly delta?: readonly ArrayNodeDeltaOp[] | undefined;
+}
+
+/**
+ * Data included for {@link TreeChangeEventsBeta.nodeChanged} when the node is an object, map, or record node.
+ * @sealed @beta
+ */
+export interface NodeChangedDataProperties<TNode extends TreeNode = TreeNode>
+	extends NodeChangedData<TNode> {
+	/**
+	 * Lists all the properties which changed on the node.
+	 */
+	readonly changedProperties: ReadonlySet<
+		TNode extends WithType<string, NodeKind.Object, infer TInfo>
+			? string & keyof TInfo
+			: string
+	>;
+}
+
+/**
+ * Data carried by the {@link TreeChangeEventsBeta.nodeChanged} event for array nodes.
+ * @sealed @beta
+ */
+export interface NodeChangedDataDelta extends NodeChangedData {
+	/**
+	 * The sequential operations describing what changed in the array node.
+	 * @remarks
+	 * The value may be `undefined` when the document was updated in a way that required multiple
+	 * internal change passes in a single operation (for example, a data change combined with a
+	 * schema upgrade).
+	 *
+	 * See {@link ArrayNodeDeltaOp} for op semantics.
+	 */
+	readonly delta: readonly ArrayNodeDeltaOp[] | undefined;
+}
+
+/**
+ * Data carried by the {@link TreeChangeEventsBeta.treeChanged} event for array nodes.
+ * @remarks
+ * Extends {@link NodeChangedDataDelta}: the retain ops in the delta additionally carry a
+ * {@link ArrayNodeTreeChangedRetainOp.subtreeChanged} flag indicating whether any descendant
+ * of the retained element changed.
+ * @sealed @beta
+ */
+export interface NodeChangedDataTreeDelta {
+	/**
+	 * The sequential operations describing what changed in the array node,
+	 * including subtree-change information on retain ops.
+	 * @remarks
+	 * The value may be `undefined` when the document was updated in a way that required multiple
+	 * internal change passes in a single operation (for example, a data change combined with a
+	 * schema upgrade).
+	 *
+	 * See {@link ArrayNodeTreeChangedDeltaOp} for op semantics.
+	 */
+	readonly delta: readonly ArrayNodeTreeChangedDeltaOp[] | undefined;
+}
+
+/**
+ * Extensions to {@link TreeChangeEvents} which are not yet stable.
+ *
+ * @sealed @beta
+ */
+export interface TreeChangeEventsBeta<TNode extends TreeNode = TreeNode>
+	extends Omit<TreeChangeEvents, "nodeChanged" | "treeChanged"> {
+	/**
+	 * Emitted by a node after a batch of changes has been applied to the tree, if any of the changes affected the node.
+	 *
+	 * - Object nodes define a change as being when the value of one of its properties changes (i.e., the property's value is set, including when set to `undefined`).
+	 *
+	 * - Array nodes define a change as when an element is added, removed, moved or replaced.
+	 *
+	 * - Map nodes define a change as when an entry is added, updated, or removed.
+	 *
+	 * @remarks
+	 * This event is not emitted when:
+	 *
+	 * - Properties of a child node change. Notably, updates to an array node or a map node (like adding or removing
+	 * elements/entries) will emit this event on the array/map node itself, but not on the node that contains the
+	 * array/map node as one of its properties.
+	 *
+	 * - The node is moved to a different location in the tree or removed from the tree.
+	 * In this case the event is emitted on the _parent_ node, not the node itself.
+	 *
+	 * For remote edits, this event is not guaranteed to occur in the same order or quantity that it did in
+	 * the client that made the original edit.
+	 *
+	 * When the event is emitted, the tree is guaranteed to be in-schema.
+	 *
+	 * @privateRemarks
+	 * This event occurs whenever the apparent contents of the node instance change, regardless of what caused the change.
+	 * For example, it will fire when the local client reassigns a child, when part of a remote edit is applied to the
+	 * node, or when the node has to be updated due to resolution of a merge conflict
+	 * (for example a previously applied local change might be undone, then reapplied differently or not at all).
+	 *
+	 * TODO: define and document event ordering (ex: bottom up, with nodeChanged before treeChange on each level).
+	 *
+	 * This defines a property which is a function instead of using the method syntax to avoid function bi-variance issues with the input data to the callback.
+	 */
+	nodeChanged: (
+		data: TNode extends WithType<string, NodeKind.Array>
+			? NodeChangedDataDelta
+			: TNode extends WithType<string, NodeKind.Map | NodeKind.Object | NodeKind.Record>
+				? NodeChangedDataProperties<TNode>
+				: NodeChangedData<TNode>,
+	) => void;
+
+	/**
+	 * Emitted when something in the subtree rooted at this node changes.
+	 *
+	 * @remarks
+	 * For array nodes, the event data carries a {@link NodeChangedDataTreeDelta.delta | delta}
+	 * payload describing both shallow and deep changes. Retain operations use
+	 * {@link ArrayNodeTreeChangedRetainOp.subtreeChanged} to indicate whether an element's
+	 * descendants changed.
+	 *
+	 * For non-array nodes, this has the same signature as {@link TreeChangeEvents.treeChanged}.
+	 * @privateRemarks
+	 * This defines a property which is a function instead of using the method syntax to avoid function bi-variance issues with the input data to the callback.
+	 */
+	treeChanged: TNode extends WithType<string, NodeKind.Array>
+		? (data: NodeChangedDataTreeDelta) => void
+		: TreeChangeEvents["treeChanged"];
+}

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/toStored.ts

@@ -11,6 +11,14 @@ import type { SchemaUpgrade } from "./allowedTypes.js";
  * @alpha
  */
 export interface StagedSchemaUpgradePolicy {
+	/**
+	 * Whether schema upgrades should include staged upgrades that are already enabled in the
+	 * document's stored schema.
+	 *
+	 * @defaultValue `true`
+	 */
+	readonly includeAlreadyEnabledUpgrades?: boolean;
+
 	/**
 	 * Determines whether to include staged allowed types in the resulting stored schema.
 	 * @remarks

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/treeNodeValid.ts

@@ -4,7 +4,7 @@
  */
 
 import { assert, fail } from "@fluidframework/core-utils/internal";
-import { UsageError } from "@fluidframework/telemetry-utils/internal";
+import { tagSchemaArtifacts, UsageError } from "@fluidframework/telemetry-utils/internal";
 
 import { type FlexTreeNode, isFlexTreeNode } from "../../feature-libraries/index.js";
 
@@ -135,6 +135,7 @@ export abstract class TreeNodeValid<TInput> extends TreeNode {
 			}) which derived from the same SchemaFactory generated class (${JSON.stringify(
 				this.identifier,
 			)}). This is invalid.`,
+			tagSchemaArtifacts({ schemaIdentifier: this.identifier }),
 		);
 	}
 
@@ -237,6 +238,7 @@ export function schemaAsTreeNodeValid(
 			`Schema for ${JSON.stringify(
 				schema.identifier,
 			)} does not extend a SchemaFactory generated class. This is invalid.`,
+			tagSchemaArtifacts({ schemaIdentifier: schema.identifier }),
 		);
 	}
 

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,
@@ -77,6 +77,8 @@ export {
 	type ITreeViewConfiguration,
 	type ITreeViewConfigurationAlpha,
 	type SchemaCompatibilityStatus,
+	type SchemaCompatibilityStatusBeta,
+	type SchemaDiscrepancy,
 	type ITreeConfigurationOptions,
 	SchemaFactory,
 	scoped,
@@ -102,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,
@@ -137,6 +134,7 @@ export {
 	type TreeSchemaEncodingOptions,
 	getJsonSchema,
 	getSimpleSchema,
+	type StagedUpgradeStatus,
 	type VerboseTreeNode,
 	type TreeEncodingOptions,
 	type VerboseTree,
@@ -144,6 +142,7 @@ export {
 	comparePersistedSchema,
 	type ConciseTree,
 	checkSchemaCompatibility,
+	getSchemaIncompatibilityDetails,
 	type Unenforced,
 	type System_Unsafe,
 	type ArrayNodeCustomizableSchemaUnsafe,
@@ -167,6 +166,7 @@ export {
 	type TreeBranchEvents,
 	type TreeBranchCommitMetadata,
 	type TreeBranchHistory,
+	type TreeContextBeta,
 	getPropertyKeyFromStoredKey,
 	getStoredKey,
 	tryGetSchema,