@fluidframework/tree 2.2.0 → 2.3.0-288113

package/src/feature-libraries/flex-tree/flexTreeTypes.ts

@@ -11,7 +11,7 @@ import {
 	type TreeValue,
 	anchorSlot,
 } from "../../core/index.js";
-import type { Assume, FlattenKeys } from "../../util/index.js";
+import type { Assume } from "../../util/index.js";
 import type {
 	FieldKinds,
 	SequenceFieldEditBuilder,
@@ -26,7 +26,6 @@ import type {
 	FlexList,
 	FlexListToUnion,
 	FlexMapNodeSchema,
-	FlexObjectNodeFields,
 	FlexObjectNodeSchema,
 	FlexTreeNodeSchema,
 	LazyItem,
@@ -309,33 +308,6 @@ export interface FlexTreeMapNode<in out TSchema extends FlexMapNodeSchema>
 	 */
 	entries(): IterableIterator<[FieldKey, FlexTreeUnboxField<TSchema["info"], "notEmpty">]>;
 
-	/**
-	 * Executes a provided function once per each key/value pair in the map.
-	 * @param callbackFn - The function to run for each map entry
-	 * @param thisArg - If present, `callbackFn` will be bound to `thisArg`
-	 *
-	 * @privateRemarks
-	 * TODO: This should run over fields in insertion order if we want to match the javascript foreach spec.
-	 */
-	forEach(
-		callbackFn: (
-			value: FlexTreeUnboxField<TSchema["info"], "notEmpty">,
-			key: FieldKey,
-			map: FlexTreeMapNode<TSchema>,
-		) => void,
-		// eslint-disable-next-line @typescript-eslint/no-explicit-any
-		thisArg?: any,
-	): void;
-
-	/**
-	 * Iterate through all fields in the map.
-	 *
-	 * @remarks
-	 * No mutations to the current view of the shared tree are permitted during iteration.
-	 * To iterate over the unboxed values of the map, use `Symbol.Iterator()`.
-	 */
-	boxedIterator(): IterableIterator<FlexTreeTypedField<TSchema["info"]>>;
-
 	[Symbol.iterator](): IterableIterator<
 		[FieldKey, FlexTreeUnboxField<TSchema["info"], "notEmpty">]
 	>;
@@ -348,7 +320,6 @@ export interface FlexTreeMapNode<in out TSchema extends FlexMapNodeSchema>
  *
  * @remarks
  * ObjectNodes require complex typing, and have been split into two parts for implementation purposes.
- * See {@link FlexTreeObjectNodeTyped} for the schema aware extensions to this that provide access to the fields.
  *
  * These "Objects" resemble "Structs" from a wide variety of programming languages
  * (Including Algol 68, C, Go, Rust, C# etc.).
@@ -380,138 +351,6 @@ export interface FlexTreeLeafNode<in out TSchema extends LeafNodeSchema> extends
 	readonly value: TreeValue<TSchema["info"]>;
 }
 
-/**
- * An {@link FlexTreeObjectNode} with schema aware accessors for its fields.
- *
- * @privateRemarks
- *
- * The corresponding implementation logic for this lives in `LazyTree.ts` under `buildStructClass`.
- * If you change the signature here, you will need to update that logic to match.
- */
-export type FlexTreeObjectNodeTyped<TSchema extends FlexObjectNodeSchema> =
-	FlexObjectNodeSchema extends TSchema
-		? FlexTreeObjectNode
-		: FlexTreeObjectNode & FlexTreeObjectNodeFields<TSchema["info"]>;
-
-/**
- * Properties to access an object node's fields. See {@link FlexTreeObjectNodeTyped}.
- *
- * @privateRemarks
- * TODO: Support custom field keys.
- */
-export type FlexTreeObjectNodeFields<TFields extends FlexObjectNodeFields> =
-	FlexTreeObjectNodeFieldsInner<
-		FlattenKeys<
-			{
-				// When the key does not need to be escaped, map it from the input TFields in a way that doesn't break navigate to declaration
-				[key in keyof TFields as key extends PropertyNameFromFieldKey<key & string>
-					? key
-					: never]: TFields[key];
-			} & {
-				[key in keyof TFields as key extends PropertyNameFromFieldKey<key & string>
-					? never
-					: PropertyNameFromFieldKey<key & string>]: TFields[key];
-			}
-		>
-	>;
-
-/**
- * Properties to access an object node's fields. See {@link FlexTreeObjectNodeTyped}.
- *
- * @privateRemarks
- * TODO: Do we keep assignment operator + "setFoo" methods, or just use methods?
- * Inconsistency in the API experience could confusing for consumers.
- */
-export type FlexTreeObjectNodeFieldsInner<TFields extends FlexObjectNodeFields> = FlattenKeys<
-	{
-		// boxed fields (TODO: maybe remove these when same as non-boxed version?)
-		readonly [key in keyof TFields as `boxed${Capitalize<key & string>}`]: FlexTreeTypedField<
-			TFields[key]
-		>;
-	} & {
-		// Add getter only (make property readonly) when the field is **not** of a kind that has a logical set operation.
-		// If we could map to getters and setters separately, we would preferably do that, but we can't.
-		// See https://github.com/microsoft/TypeScript/issues/43826 for more details on this limitation.
-		readonly [key in keyof TFields as TFields[key]["kind"] extends AssignableFieldKinds
-			? never
-			: key]: FlexTreeUnboxField<TFields[key]>;
-	} & {
-		// Add setter (make property writable) when the field is of a kind that has a logical set operation.
-		// If we could map to getters and setters separately, we would preferably do that, but we can't.
-		// See https://github.com/microsoft/TypeScript/issues/43826 for more details on this limitation.
-		-readonly [key in keyof TFields as TFields[key]["kind"] extends AssignableFieldKinds
-			? key
-			: never]: FlexTreeUnboxField<TFields[key]>;
-	} & {
-		// Setter method (when the field is of a kind that has a logical set operation).
-		readonly [key in keyof TFields as TFields[key]["kind"] extends AssignableFieldKinds
-			? `set${Capitalize<key & string>}`
-			: never]: (content: FlexibleNodeContent) => void;
-	}
->;
-
-/**
- * Reserved object node field property names to avoid collisions with the rest of the object node API.
- */
-export const reservedObjectNodeFieldPropertyNames = [
-	"anchorNode",
-	"constructor",
-	"context",
-	"is",
-	"parentField",
-	"schema",
-	"tryGetField",
-	"type",
-	"value",
-	"boxedIterator",
-	"iterator",
-	"getBoxed",
-] as const;
-
-/**
- * Reserved object node field property names prefixes.
- * These are reserved to avoid collisions with properties derived from field other field names.
- *
- * Field names starting with these must be followed by a lowercase letter, or be escaped.
- */
-export const reservedObjectNodeFieldPropertyNamePrefixes = [
-	"set",
-	"boxed",
-	"field",
-	"Field",
-] as const;
-
-/**
- * {@link reservedObjectNodeFieldPropertyNamePrefixes} as a type union.
- */
-export type ReservedObjectNodeFieldPropertyNames =
-	(typeof reservedObjectNodeFieldPropertyNames)[number];
-
-/**
- * {@link reservedObjectNodeFieldPropertyNamePrefixes} as a type union.
- */
-export type ReservedObjectNodeFieldPropertyNamePrefixes =
-	(typeof reservedObjectNodeFieldPropertyNamePrefixes)[number];
-
-/**
- * Convert an object node's field key into an escaped string usable as a property name.
- *
- * @privateRemarks
- * TODO:
- * Collisions are still possible.
- * For example fields named "foo" and "Foo" would both produce a setter "setFoo".
- * Consider naming schemes to avoid this, ensure that there is a good workaround for these cases.
- * Another approach would be to support custom field names (separate from keys),
- * and do the escaping (if needed) when creating the flex tree schema (both when manually creating them and when doing so automatically):
- * this would enable better intellisense for escaped fields, as well as allow the feature of custom field property names.
- */
-export type PropertyNameFromFieldKey<T extends string> =
-	T extends ReservedObjectNodeFieldPropertyNames
-		? `field${Capitalize<T>}`
-		: T extends `${ReservedObjectNodeFieldPropertyNamePrefixes}${Capitalize<string>}`
-			? `field${Capitalize<T>}`
-			: T;
-
 /**
  * Field kinds that allow value assignment.
  */
@@ -588,12 +427,6 @@ export interface FlexTreeSequenceField<in out TTypes extends FlexAllowedTypes>
 	 */
 	map<U>(callbackfn: (value: FlexTreeUnboxNodeUnion<TTypes>, index: number) => U): U[];
 
-	/**
-	 * Calls the provided callback function on each child of this sequence, and returns an array that contains the results.
-	 * @param callbackfn - A function that accepts the child and its index.
-	 */
-	mapBoxed<U>(callbackfn: (value: FlexTreeTypedNodeUnion<TTypes>, index: number) => U): U[];
-
 	readonly length: number;
 
 	/**
@@ -687,7 +520,7 @@ export type FlexTreeTypedNode<TSchema extends FlexTreeNodeSchema> =
 		: TSchema extends FlexMapNodeSchema
 			? FlexTreeMapNode<TSchema>
 			: TSchema extends FlexObjectNodeSchema
-				? FlexTreeObjectNodeTyped<TSchema>
+				? FlexTreeObjectNode
 				: FlexTreeNode;
 
 // #endregion
@@ -764,7 +597,7 @@ export type FlexTreeUnboxNode<TSchema extends FlexTreeNodeSchema> =
 		: TSchema extends FlexMapNodeSchema
 			? FlexTreeMapNode<TSchema>
 			: TSchema extends FlexObjectNodeSchema
-				? FlexTreeObjectNodeTyped<TSchema>
+				? FlexTreeObjectNode
 				: FlexTreeUnknownUnboxed;
 
 /**

package/src/feature-libraries/flex-tree/index.ts

@@ -16,7 +16,6 @@ export {
 	type FlexTreeRequiredField,
 	type FlexTreeSequenceField,
 	type FlexTreeObjectNode,
-	type FlexTreeObjectNodeTyped,
 	type AssignableFieldKinds,
 	type FlexTreeTypedNode,
 	type FlexTreeTypedNodeUnion,
@@ -27,12 +26,6 @@ export {
 	flexTreeMarker,
 	FlexTreeEntityKind,
 	isFlexTreeNode,
-	type PropertyNameFromFieldKey,
-	type ReservedObjectNodeFieldPropertyNames,
-	type ReservedObjectNodeFieldPropertyNamePrefixes,
-	reservedObjectNodeFieldPropertyNames,
-	reservedObjectNodeFieldPropertyNamePrefixes,
-	type FlexTreeObjectNodeFieldsInner,
 	flexTreeSlot,
 } from "./flexTreeTypes.js";
 
@@ -48,16 +41,7 @@ export { getTreeContext, type FlexTreeContext, Context, ContextSlot } from "./co
 
 export { type FlexTreeNodeEvents } from "./treeEvents.js";
 
-// Below here are things that are used by the above, but not part of the desired API surface.
-export type {
-	FlexTreeTypedFieldInner,
-	FlexTreeUnboxFieldInner,
-	FlexTreeObjectNodeFields,
-	FlexTreeUnboxNode,
-	FlexTreeUnboxNodeUnion,
-	IsArrayOfOne,
-	FlexibleNodeSubSequence,
-} from "./flexTreeTypes.js";
+export type { FlexTreeUnboxNodeUnion } from "./flexTreeTypes.js";
 
 export {
 	assertFlexTreeEntityNotFreed,

package/src/feature-libraries/flex-tree/lazyField.ts

@@ -225,12 +225,6 @@ export abstract class LazyField<
 		return Array.from(this, callbackfn);
 	}
 
-	public mapBoxed<U>(
-		callbackfn: (value: FlexTreeTypedNodeUnion<TTypes>, index: number) => U,
-	): U[] {
-		return Array.from(this.boxedIterator(), callbackfn);
-	}
-
 	public boxedIterator(): IterableIterator<FlexTreeTypedNodeUnion<TTypes>> {
 		return iterateCursorField(
 			this[cursorSymbol],

package/src/feature-libraries/flex-tree/lazyNode.ts

@@ -19,14 +19,12 @@ import {
 	mapCursorFields,
 	rootFieldKey,
 } from "../../core/index.js";
-import { brand, capitalize, disposeSymbol, fail, getOrCreate } from "../../util/index.js";
+import { brand, disposeSymbol, fail } from "../../util/index.js";
 import { FieldKinds } from "../default-schema/index.js";
 import {
 	Any,
-	type FlexAllowedTypes,
 	FlexFieldSchema,
 	type FlexMapNodeSchema,
-	type FlexObjectNodeSchema,
 	type FlexTreeNodeSchema,
 	type LeafNodeSchema,
 	schemaIsLeaf,
@@ -41,18 +39,11 @@ import {
 	type FlexTreeLeafNode,
 	type FlexTreeMapNode,
 	type FlexTreeNode,
-	type FlexTreeObjectNodeTyped,
-	type FlexTreeOptionalField,
-	type FlexTreeRequiredField,
 	type FlexTreeTypedField,
 	type FlexTreeTypedNode,
 	type FlexTreeUnboxField,
-	type FlexibleNodeContent,
-	type PropertyNameFromFieldKey,
 	flexTreeMarker,
 	flexTreeSlot,
-	reservedObjectNodeFieldPropertyNamePrefixes,
-	reservedObjectNodeFieldPropertyNames,
 } from "./flexTreeTypes.js";
 import {
 	LazyEntity,
@@ -103,7 +94,7 @@ function buildSubclass(
 		return new LazyLeaf(context, schema, cursor, anchorNode, anchor);
 	}
 	if (schemaIsObjectNode(schema)) {
-		return buildLazyObjectNode(context, schema, cursor, anchorNode, anchor);
+		return new LazyTreeNode(context, schema, cursor, anchorNode, anchor);
 	}
 	// TODO: there should be a common fallback that works for cases without a specialized implementation.
 	fail("unrecognized node kind");
@@ -112,7 +103,7 @@ function buildSubclass(
 /**
  * Lazy implementation of {@link FlexTreeNode}.
  */
-export abstract class LazyTreeNode<TSchema extends FlexTreeNodeSchema = FlexTreeNodeSchema>
+export class LazyTreeNode<TSchema extends FlexTreeNodeSchema = FlexTreeNodeSchema>
 	extends LazyEntity<TSchema, Anchor>
 	implements FlexTreeNode
 {
@@ -307,10 +298,6 @@ export class LazyMap<TSchema extends FlexMapNodeSchema>
 		return super.getBoxed(brand(key)) as FlexTreeTypedField<TSchema["info"]>;
 	}
 
-	public override boxedIterator(): IterableIterator<FlexTreeTypedField<TSchema["info"]>> {
-		return super.boxedIterator() as IterableIterator<FlexTreeTypedField<TSchema["info"]>>;
-	}
-
 	public [Symbol.iterator](): IterableIterator<
 		[FieldKey, FlexTreeUnboxField<TSchema["info"], "notEmpty">]
 	> {
@@ -337,54 +324,6 @@ export class LazyLeaf<TSchema extends LeafNodeSchema>
 	}
 }
 
-/**
- * {@link reservedObjectNodeFieldPropertyNames} but as a set.
- */
-export const reservedObjectNodeFieldPropertyNameSet: ReadonlySet<string> = new Set(
-	reservedObjectNodeFieldPropertyNames,
-);
-
-export function propertyNameFromFieldKey<T extends string>(
-	key: T,
-): PropertyNameFromFieldKey<T> {
-	if (reservedObjectNodeFieldPropertyNameSet.has(key)) {
-		return `field${capitalize(key)}` as PropertyNameFromFieldKey<T>;
-	}
-	for (const prefix of reservedObjectNodeFieldPropertyNamePrefixes) {
-		if (key.startsWith(prefix)) {
-			const afterPrefix = key.slice(prefix.length);
-			if (afterPrefix === capitalize(afterPrefix)) {
-				return `field${capitalize(key)}` as PropertyNameFromFieldKey<T>;
-			}
-		}
-	}
-	return key as PropertyNameFromFieldKey<T>;
-}
-
-export function buildLazyObjectNode<TSchema extends FlexObjectNodeSchema>(
-	context: Context,
-	schema: TSchema,
-	cursor: ITreeSubscriptionCursor,
-	anchorNode: AnchorNode,
-	anchor: Anchor,
-): LazyTreeNode<TSchema> & FlexTreeObjectNodeTyped<TSchema> {
-	const objectNodeClass = getOrCreate(cachedStructClasses, schema, () =>
-		buildStructClass(schema),
-	);
-	return new objectNodeClass(context, cursor, anchorNode, anchor) as LazyTreeNode<TSchema> &
-		FlexTreeObjectNodeTyped<TSchema>;
-}
-
-const cachedStructClasses = new WeakMap<
-	FlexObjectNodeSchema,
-	new (
-		context: Context,
-		cursor: ITreeSubscriptionCursor,
-		anchorNode: AnchorNode,
-		anchor: Anchor,
-	) => LazyTreeNode<FlexObjectNodeSchema>
->();
-
 function getBoxedField(
 	objectNode: LazyTreeNode,
 	key: FieldKey,
@@ -394,93 +333,3 @@ function getBoxedField(
 		return makeField(objectNode.context, fieldSchema, cursor);
 	});
 }
-
-function buildStructClass<TSchema extends FlexObjectNodeSchema>(
-	schema: TSchema,
-): new (
-	context: Context,
-	cursor: ITreeSubscriptionCursor,
-	anchorNode: AnchorNode,
-	anchor: Anchor,
-) => LazyTreeNode<TSchema> {
-	const propertyDescriptorMap: PropertyDescriptorMap = {};
-
-	for (const [key, fieldSchema] of schema.objectNodeFields) {
-		const escapedKey = propertyNameFromFieldKey(key);
-		let setter: ((newContent: FlexibleNodeContent) => void) | undefined;
-		switch (fieldSchema.kind) {
-			case FieldKinds.optional: {
-				setter = function (
-					this: CustomStruct,
-					newContent: FlexibleNodeContent | undefined,
-				): void {
-					const field = getBoxedField(
-						this,
-						key,
-						fieldSchema,
-					) as FlexTreeOptionalField<FlexAllowedTypes>;
-					field.editor.set(newContent, field.length === 0);
-				};
-				break;
-			}
-			case FieldKinds.required: {
-				setter = function (this: CustomStruct, newContent: FlexibleNodeContent): void {
-					const field = getBoxedField(
-						this,
-						key,
-						fieldSchema,
-					) as FlexTreeRequiredField<FlexAllowedTypes>;
-					field.editor.set(newContent);
-				};
-				break;
-			}
-			default:
-				setter = undefined;
-				break;
-		}
-
-		// Create getter and setter (when appropriate) for property
-		propertyDescriptorMap[escapedKey] = {
-			enumerable: true,
-			get(this: CustomStruct): unknown {
-				return inCursorField(this[cursorSymbol], key, (cursor) =>
-					unboxedField(this.context, fieldSchema, cursor),
-				);
-			},
-			set: setter,
-		};
-
-		// Create set method for property (when appropriate)
-		if (setter !== undefined) {
-			propertyDescriptorMap[`set${capitalize(escapedKey)}`] = {
-				enumerable: false,
-				get(this: CustomStruct) {
-					return setter;
-				},
-			};
-		}
-
-		propertyDescriptorMap[`boxed${capitalize(escapedKey)}`] = {
-			enumerable: false,
-			get(this: CustomStruct) {
-				return getBoxedField(this, key, fieldSchema);
-			},
-		};
-	}
-
-	// This must implement `StructTyped<TSchema>`, but TypeScript can't constrain it to do so.
-	class CustomStruct extends LazyTreeNode<TSchema> {
-		public constructor(
-			context: Context,
-			cursor: ITreeSubscriptionCursor,
-			anchorNode: AnchorNode,
-			anchor: Anchor,
-		) {
-			super(context, schema, cursor, anchorNode, anchor);
-		}
-	}
-
-	Object.defineProperties(CustomStruct.prototype, propertyDescriptorMap);
-
-	return CustomStruct;
-}

package/src/feature-libraries/index.ts

@@ -224,7 +224,6 @@ export {
 	type FlexTreeSequenceField,
 	Skip,
 	type FlexTreeObjectNode,
-	type FlexTreeObjectNodeTyped,
 	type FlexTreeContext,
 	type FlexTreeTypedField,
 	type FlexTreeTypedNode,
@@ -241,22 +240,9 @@ export {
 	isFlexTreeNode,
 	ContextSlot,
 	// Internal
-	type FlexTreeTypedFieldInner,
-	type FlexTreeUnboxFieldInner,
-	type FlexTreeObjectNodeFields,
 	type FlexTreeUnboxField,
-	type FlexTreeUnboxNode,
-	type FlexTreeUnboxNodeUnion,
-	type IsArrayOfOne,
-	type FlexibleNodeSubSequence,
 	flexTreeMarker,
 	FlexTreeEntityKind,
-	type PropertyNameFromFieldKey,
-	type ReservedObjectNodeFieldPropertyNames,
-	type ReservedObjectNodeFieldPropertyNamePrefixes,
-	reservedObjectNodeFieldPropertyNames,
-	reservedObjectNodeFieldPropertyNamePrefixes,
-	type FlexTreeObjectNodeFieldsInner,
 	assertFlexTreeEntityNotFreed,
 	flexTreeSlot,
 	getSchemaAndPolicy,

package/src/index.ts

@@ -36,6 +36,13 @@ export {
 	type IsListener,
 	type Listenable,
 	type Off,
+	// Alpha APIs for using event library to implement events externally.
+	// If stabilizing these APIs, they should probably move out of the tree package first.
+	createEmitter,
+	EventEmitter,
+	type IEmitter,
+	type HasListeners,
+	type NoListenersCallback,
 } from "./events/index.js";
 
 export {
@@ -93,6 +100,7 @@ export {
 	type FieldProps,
 	type InternalTreeNode,
 	type WithType,
+	type NodeChangedData,
 	// Types not really intended for public use, but used in links.
 	// Can not be moved to internalTypes since doing so causes app code to throw errors like:
 	// Error: src/simple-tree/objectNode.ts:72:1 - (ae-unresolved-link) The @link reference could not be resolved: The package "@fluidframework/tree" does not have an export "TreeNodeApi"

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/tree";
-export const pkgVersion = "2.2.0";
+export const pkgVersion = "2.3.0-288113";

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

@@ -44,6 +44,7 @@ import {
 	type TreeChangeEvents,
 	tryGetTreeNodeSchema,
 } from "../core/index.js";
+import { isObjectNodeSchema } from "../objectNodeTypes.js";
 
 /**
  * Provides various functions for analyzing {@link TreeNode}s.
@@ -98,10 +99,10 @@ export interface TreeNodeApi {
 	 * @returns A callback function which will deregister the event.
 	 * This callback should be called only once.
 	 */
-	on<K extends keyof TreeChangeEvents>(
-		node: TreeNode,
+	on<K extends keyof TreeChangeEvents<TNode>, TNode extends TreeNode>(
+		node: TNode,
 		eventName: K,
-		listener: TreeChangeEvents[K],
+		listener: TreeChangeEvents<TNode>[K],
 	): () => void;
 
 	/**
@@ -167,7 +168,38 @@ export const treeNodeApi: TreeNodeApi = {
 		eventName: K,
 		listener: TreeChangeEvents[K],
 	): Off {
-		return getKernel(node).on(eventName, listener);
+		const kernel = getKernel(node);
+		switch (eventName) {
+			case "nodeChanged": {
+				const nodeSchema = kernel.schema;
+				if (isObjectNodeSchema(nodeSchema)) {
+					return kernel.on("childrenChangedAfterBatch", ({ changedFields }) => {
+						const changedProperties = new Set(
+							Array.from(
+								changedFields,
+								(field) =>
+									nodeSchema.storedKeyToPropertyKey.get(field) ??
+									fail(`Could not find stored key '${field}' in schema.`),
+							),
+						);
+						listener({ changedProperties });
+					});
+				} else if (nodeSchema.kind === NodeKind.Array) {
+					return kernel.on("childrenChangedAfterBatch", () => {
+						listener({ changedProperties: undefined });
+					});
+				} else {
+					return kernel.on("childrenChangedAfterBatch", ({ changedFields }) => {
+						listener({ changedProperties: changedFields });
+					});
+				}
+			}
+			case "treeChanged": {
+				return kernel.on("subtreeChangedAfterBatch", () => listener({}));
+			}
+			default:
+				throw new UsageError(`No event named ${JSON.stringify(eventName)}.`);
+		}
 	},
 	status(node: TreeNode): TreeStatus {
 		return getKernel(node).getStatus();
@@ -245,7 +277,7 @@ export function tryGetSchema(value: unknown): undefined | TreeNodeSchema {
 			return booleanSchema;
 		case "object": {
 			if (isTreeNode(value)) {
-				// This case could be optimized, for example by placing the simple schema in a symbol on tree nodes.
+				// TODO: This case could be optimized, for example by placing the simple schema in a symbol on tree nodes.
 				return tryGetTreeNodeSchema(value);
 			}
 			if (value === null) {

package/src/simple-tree/arrayNode.ts

@@ -670,19 +670,10 @@ abstract class CustomArrayNodeBase<const T extends ImplicitAllowedTypes>
 
 	protected abstract get simpleSchema(): T;
 
-	/**
-	 * Generation number which is incremented any time we have an edit on the node.
-	 * Used during iteration to make sure there has been no edits that were concurrently made.
-	 */
-	#generationNumber: number = 0;
-
 	public constructor(
 		input: Iterable<InsertableTreeNodeFromImplicitAllowedTypes<T>> | InternalTreeNode,
 	) {
 		super(input);
-		getKernel(this).on("nodeChanged", () => {
-			this.#generationNumber += 1;
-		});
 	}
 
 	#mapTreesFromFieldData(value: Insertable<T>): ExclusiveMapTree[] {
@@ -884,17 +875,17 @@ abstract class CustomArrayNodeBase<const T extends ImplicitAllowedTypes>
 	}
 
 	public values(): IterableIterator<TreeNodeFromImplicitAllowedTypes<T>> {
-		return this.generateValues(this.#generationNumber);
+		return this.generateValues(getKernel(this).generationNumber);
 	}
 	private *generateValues(
 		initialLastUpdatedStamp: number,
 	): Generator<TreeNodeFromImplicitAllowedTypes<T>> {
-		if (initialLastUpdatedStamp !== this.#generationNumber) {
+		if (initialLastUpdatedStamp !== getKernel(this).generationNumber) {
 			throw new UsageError(`Concurrent editing and iteration is not allowed.`);
 		}
 		for (let i = 0; i < this.length; i++) {
 			yield this.at(i) ?? fail("Index is out of bounds");
-			if (initialLastUpdatedStamp !== this.#generationNumber) {
+			if (initialLastUpdatedStamp !== getKernel(this).generationNumber) {
 				throw new UsageError(`Concurrent editing and iteration is not allowed.`);
 			}
 		}

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

@@ -17,6 +17,7 @@ export {
 	inPrototypeChain,
 	type InternalTreeNode,
 	privateToken,
+	type NodeChangedData,
 } from "./types.js";
 export {
 	type TreeNodeSchema,