@fluidframework/tree 2.0.0-rc.2.0.2 → 2.0.0-rc.3.0.0

package/src/feature-libraries/default-schema/defaultFieldKinds.ts

@@ -4,30 +4,33 @@
  */
 
 import {
-	FieldKindIdentifier,
-	forbiddenFieldKindIdentifier,
 	ChangesetLocalId,
 	DeltaDetachedNodeId,
 	DeltaFieldChanges,
+	FieldKindIdentifier,
+	forbiddenFieldKindIdentifier,
+	Multiplicity,
 } from "../../core/index.js";
 import { fail } from "../../util/index.js";
 import {
-	FlexFieldKind,
-	allowsTreeSchemaIdentifierSuperset,
-	ToDelta,
 	FieldChangeHandler,
 	FieldEditor,
-	referenceFreeFieldChangeRebaser,
+	FieldKindConfiguration,
+	FieldKindConfigurationEntry,
 	FieldKindWithEditor,
+	FlexFieldKind,
+	ToDelta,
+	allowsTreeSchemaIdentifierSuperset,
+	referenceFreeFieldChangeRebaser,
 } from "../modular-schema/index.js";
-import { sequenceFieldChangeHandler } from "../sequence-field/index.js";
 import {
-	noChangeCodecFamily,
 	OptionalChangeset,
 	optionalChangeHandler,
 	optionalFieldEditor,
 } from "../optional-field/index.js";
-import { Multiplicity } from "../multiplicity.js";
+import { sequenceFieldChangeHandler } from "../sequence-field/index.js";
+
+import { noChangeCodecFamily } from "./noChangeCodecs.js";
 
 /**
  * ChangeHandler that only handles no-op / identity changes.
@@ -65,8 +68,7 @@ export const optional = new FieldKindWithEditor(
 	Multiplicity.Optional,
 	optionalChangeHandler,
 	(types, other) =>
-		(other.kind.identifier === sequence.identifier ||
-			other.kind.identifier === optionalIdentifier) &&
+		(other.kind === sequence.identifier || other.kind === optionalIdentifier) &&
 		allowsTreeSchemaIdentifierSuperset(types, other.types),
 	new Set([]),
 );
@@ -92,10 +94,10 @@ export const required = new FieldKindWithEditor(
 	Multiplicity.Single,
 	valueChangeHandler,
 	(types, other) =>
-		(other.kind.identifier === sequence.identifier ||
-			other.kind.identifier === requiredIdentifier ||
-			other.kind.identifier === optional.identifier ||
-			other.kind.identifier === nodeKey.identifier) &&
+		(other.kind === sequence.identifier ||
+			other.kind === requiredIdentifier ||
+			other.kind === optional.identifier ||
+			other.kind === nodeKey.identifier) &&
 		allowsTreeSchemaIdentifierSuperset(types, other.types),
 	new Set(),
 );
@@ -110,8 +112,7 @@ export const sequence = new FieldKindWithEditor(
 	Multiplicity.Sequence,
 	sequenceFieldChangeHandler,
 	(types, other) =>
-		other.kind.identifier === sequenceIdentifier &&
-		allowsTreeSchemaIdentifierSuperset(types, other.types),
+		other.kind === sequenceIdentifier && allowsTreeSchemaIdentifierSuperset(types, other.types),
 	// TODO: add normalizer/importers for handling ops from other kinds.
 	new Set([]),
 );
@@ -126,10 +127,28 @@ export const nodeKey = new FieldKindWithEditor(
 	Multiplicity.Single,
 	noChangeHandler,
 	(types, other) =>
-		(other.kind.identifier === sequence.identifier ||
-			other.kind.identifier === requiredIdentifier ||
-			other.kind.identifier === optional.identifier ||
-			other.kind.identifier === nodeKeyIdentifier) &&
+		(other.kind === sequence.identifier ||
+			other.kind === requiredIdentifier ||
+			other.kind === optional.identifier ||
+			other.kind === nodeKeyIdentifier) &&
+		allowsTreeSchemaIdentifierSuperset(types, other.types),
+	new Set(),
+);
+
+const identifierFieldIdentifier = "Identifier";
+
+/**
+ * Exactly one identifier.
+ */
+export const identifier = new FieldKindWithEditor(
+	identifierFieldIdentifier,
+	Multiplicity.Single,
+	noChangeHandler,
+	(types, other) =>
+		(other.kind === sequence.identifier ||
+			other.kind === requiredIdentifier ||
+			other.kind === optional.identifier ||
+			other.kind === identifierFieldIdentifier) &&
 		allowsTreeSchemaIdentifierSuperset(types, other.types),
 	new Set(),
 );
@@ -167,15 +186,44 @@ export const forbidden = new FieldKindWithEditor(
 	Multiplicity.Forbidden,
 	noChangeHandler,
 	// All multiplicities other than Value support empty.
-	(types, other) => fieldKinds.get(other.kind.identifier)?.multiplicity !== Multiplicity.Single,
+	(types, other) => fieldKinds.get(other.kind)?.multiplicity !== Multiplicity.Single,
 	new Set(),
 );
 
+export const fieldKindConfigurations: ReadonlyMap<number, FieldKindConfiguration> = new Map([
+	[
+		1,
+		new Map<FieldKindIdentifier, FieldKindConfigurationEntry>([
+			[nodeKey.identifier, { kind: nodeKey, formatVersion: 1 }],
+			[required.identifier, { kind: required, formatVersion: 1 }],
+			[optional.identifier, { kind: optional, formatVersion: 1 }],
+			[sequence.identifier, { kind: sequence, formatVersion: 1 }],
+			[forbidden.identifier, { kind: forbidden, formatVersion: 1 }],
+			[identifier.identifier, { kind: identifier, formatVersion: 1 }],
+		]),
+	],
+	[
+		2,
+		new Map<FieldKindIdentifier, FieldKindConfigurationEntry>([
+			[nodeKey.identifier, { kind: nodeKey, formatVersion: 1 }],
+			[required.identifier, { kind: required, formatVersion: 2 }],
+			[optional.identifier, { kind: optional, formatVersion: 2 }],
+			[sequence.identifier, { kind: sequence, formatVersion: 1 }],
+			[forbidden.identifier, { kind: forbidden, formatVersion: 1 }],
+			[identifier.identifier, { kind: identifier, formatVersion: 1 }],
+		]),
+	],
+]);
+
 /**
- * Default field kinds by identifier
+ * All supported field kinds.
+ *
+ * @privateRemarks
+ * Before making a SharedTree format change which impacts which set of field kinds are allowed,
+ * code which uses this should be audited for compatibility considerations.
  */
 export const fieldKinds: ReadonlyMap<FieldKindIdentifier, FieldKindWithEditor> = new Map(
-	[required, optional, sequence, nodeKey, forbidden].map((s) => [s.identifier, s]),
+	[required, optional, sequence, nodeKey, identifier, forbidden].map((s) => [s.identifier, s]),
 );
 
 // Create named Aliases for nicer intellisense.
@@ -199,6 +247,10 @@ export interface Sequence extends FlexFieldKind<"Sequence", Multiplicity.Sequenc
  * @internal
  */
 export interface NodeKeyFieldKind extends FlexFieldKind<"NodeKey", Multiplicity.Single> {}
+/**
+ * @internal
+ */
+export interface Identifier extends FlexFieldKind<"Identifier", Multiplicity.Single> {}
 /**
  * @internal
  */
@@ -215,5 +267,6 @@ export const FieldKinds: {
 	readonly optional: Optional;
 	readonly sequence: Sequence;
 	readonly nodeKey: NodeKeyFieldKind;
+	readonly identifier: Identifier;
 	readonly forbidden: Forbidden;
-} = { required, optional, sequence, nodeKey, forbidden };
+} = { required, optional, sequence, nodeKey, identifier, forbidden };

package/src/feature-libraries/default-schema/defaultSchema.ts

@@ -4,6 +4,7 @@
  */
 
 import { FullSchemaPolicy } from "../modular-schema/index.js";
+
 import { fieldKinds } from "./defaultFieldKinds.js";
 
 /**

package/src/feature-libraries/default-schema/index.ts

@@ -9,8 +9,10 @@ export {
 	Optional,
 	Sequence,
 	NodeKeyFieldKind,
+	Identifier,
 	Forbidden,
 	fieldKinds,
+	fieldKindConfigurations,
 } from "./defaultFieldKinds.js";
 
 export {

package/src/feature-libraries/default-schema/noChangeCodecs.ts

@@ -0,0 +1,12 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { ICodecFamily, makeCodecFamily, unitCodec } from "../../codec/index.js";
+import { FieldChangeEncodingContext } from "../index.js";
+
+export const noChangeCodecFamily: ICodecFamily<0, FieldChangeEncodingContext> = makeCodecFamily<
+	0,
+	FieldChangeEncodingContext
+>([[1, unitCodec]]);

package/src/feature-libraries/detachedFieldIndexSummarizer.ts

@@ -3,14 +3,15 @@
  * Licensed under the MIT License.
  */
 
+import { bufferToString } from "@fluid-internal/client-utils";
+import { IChannelStorageService } from "@fluidframework/datastore-definitions";
 import {
 	IGarbageCollectionData,
 	ISummaryTreeWithStats,
 	ITelemetryContext,
 } from "@fluidframework/runtime-definitions";
-import { createSingleBlobSummary } from "@fluidframework/shared-object-base";
-import { IChannelStorageService } from "@fluidframework/datastore-definitions";
-import { bufferToString } from "@fluid-internal/client-utils";
+import { createSingleBlobSummary } from "@fluidframework/shared-object-base/internal";
+
 import { DetachedFieldIndex } from "../core/index.js";
 import {
 	Summarizable,

package/src/feature-libraries/editableTreeBinder.ts

@@ -3,7 +3,8 @@
  * Licensed under the MIT License.
  */
 
-import { assert } from "@fluidframework/core-utils";
+import { assert } from "@fluidframework/core-utils/internal";
+
 import {
 	DetachedPlaceUpPath,
 	DetachedRangeUpPath,
@@ -17,6 +18,7 @@ import {
 } from "../core/index.js";
 import { Events, ISubscribable } from "../events/index.js";
 import { brand, getOrCreate } from "../util/index.js";
+
 import { FlexTreeNode } from "./flex-tree/index.js";
 
 // TODO:

package/src/feature-libraries/fieldGenerator.ts

@@ -3,7 +3,8 @@
  * Licensed under the MIT License.
  */
 
-import { FieldKey, TreeFieldStoredSchema, MapTree } from "../core/index.js";
+import { FieldKey, MapTree, TreeFieldStoredSchema } from "../core/index.js";
+
 import { FlexTreeSchema } from "./typed-schema/index.js";
 
 /**

package/src/feature-libraries/flex-tree/README.md

@@ -1,6 +1,6 @@
-# editable-tree
+# flex-tree
 
-Editable Tree is a simple API for accessing a Forest's data.
+Flex Tree (previously Editable Tree) is a simple API for accessing a Forest's data.
 
 The entry point is `getTreeContext` which provides a root `TreeField` which allows reading and writing nodes of the Forest.
 

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

@@ -3,23 +3,26 @@
  * Licensed under the MIT License.
  */
 
-import { assert } from "@fluidframework/core-utils";
+import { assert } from "@fluidframework/core-utils/internal";
+
 import {
-	moveToDetachedField,
-	ForestEvents,
-	TreeFieldStoredSchema,
 	FieldKey,
+	ForestEvents,
 	IForestSubscription,
+	TreeFieldStoredSchema,
+	anchorSlot,
+	moveToDetachedField,
 } from "../../core/index.js";
 import { ISubscribable } from "../../events/index.js";
+import { IDisposable, disposeSymbol } from "../../util/index.js";
 import { IDefaultEditBuilder } from "../default-schema/index.js";
-import { NodeKeyIndex, NodeKeyManager } from "../node-key/index.js";
 import { FieldGenerator } from "../fieldGenerator.js";
+import { NodeKeyIndex, NodeKeyManager } from "../node-key/index.js";
 import { FlexTreeSchema } from "../typed-schema/index.js";
-import { disposeSymbol, IDisposable } from "../../util/index.js";
+
 import { FlexTreeField } from "./flexTreeTypes.js";
-import { makeField } from "./lazyField.js";
 import { LazyEntity, prepareForEditSymbol } from "./lazyEntity.js";
+import { makeField } from "./lazyField.js";
 import { NodeKeys, SimpleNodeKeys } from "./nodeKeys.js";
 
 /**
@@ -44,8 +47,22 @@ export interface FlexTreeContext extends ISubscribable<ForestEvents> {
 	// - branching APIs
 
 	readonly nodeKeys: NodeKeys;
+
+	/**
+	 * The forest containing the tree data associated with this context
+	 */
+	readonly forest: IForestSubscription;
 }
 
+/**
+ * Creating multiple flex tree contexts for the same branch, and thus with the same underlying AnchorSet does not work due to how TreeNode caching works.
+ * This slot is used to detect if one already exists and error if creating a second.
+ *
+ * TODO:
+ * 1. API docs need to reflect this limitation or the limitation has to be removed.
+ */
+export const ContextSlot = anchorSlot<Context>();
+
 /**
  * Implementation of `FlexTreeContext`.
  *
@@ -77,6 +94,12 @@ export class Context implements FlexTreeContext, IDisposable {
 				this.prepareForEdit();
 			}),
 		];
+
+		assert(
+			!this.forest.anchors.slots.has(ContextSlot),
+			0x92b /* Cannot create second flex-tree from checkout */,
+		);
+		this.forest.anchors.slots.set(ContextSlot, this);
 	}
 
 	/**
@@ -99,6 +122,9 @@ export class Context implements FlexTreeContext, IDisposable {
 			unregister();
 		}
 		this.eventUnregister.length = 0;
+
+		const deleted = this.forest.anchors.slots.delete(ContextSlot);
+		assert(deleted, 0x8c4 /* unexpected dispose */);
 	}
 
 	/**
@@ -143,7 +169,7 @@ export class Context implements FlexTreeContext, IDisposable {
  * @param nodeKeyManager - an object which handles node key generation and conversion.
  * @param nodeKeyFieldKey - an optional field key under which node keys are stored in this tree.
  * If present, clients may query the {@link LocalNodeKey} of a node directly via the {@link localNodeKeySymbol}.
- * @returns {@link EditableTreeContext} which is used to manage the cursors and anchors within the EditableTrees:
+ * @returns {@link FlexTreeContext} which is used to manage the cursors and anchors within the FlexTrees:
  * This is necessary for supporting using this tree across edits to the forest, and not leaking memory.
  */
 export function getTreeContext(

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

@@ -3,28 +3,41 @@
  * Licensed under the MIT License.
  */
 
-import { AllowedTypesToFlexInsertableTree, InsertableFlexField } from "../schema-aware/index.js";
-import { FieldKey, ITreeCursorSynchronous, TreeValue } from "../../core/index.js";
+import {
+	AnchorNode,
+	FieldKey,
+	ITreeCursorSynchronous,
+	TreeValue,
+	anchorSlot,
+} from "../../core/index.js";
 import { Assume, FlattenKeys } from "../../util/index.js";
+import { FieldKinds } from "../default-schema/index.js";
+import { FlexFieldKind } from "../modular-schema/index.js";
 import { LocalNodeKey, StableNodeKey } from "../node-key/index.js";
+import { AllowedTypesToFlexInsertableTree, InsertableFlexField } from "../schema-aware/index.js";
 import {
-	FlexFieldSchema,
-	LazyItem,
-	FlexTreeNodeSchema,
+	Any,
 	FlexAllowedTypes,
 	FlexFieldNodeSchema,
-	LeafNodeSchema,
+	FlexFieldSchema,
+	FlexList,
+	FlexListToUnion,
 	FlexMapNodeSchema,
-	FlexObjectNodeSchema,
-	Any,
 	FlexObjectNodeFields,
-	FlexListToUnion,
-	FlexList,
+	FlexObjectNodeSchema,
+	FlexTreeNodeSchema,
+	LazyItem,
+	LeafNodeSchema,
 } from "../typed-schema/index.js";
-import { FieldKinds } from "../default-schema/index.js";
-import { FlexFieldKind } from "../modular-schema/index.js";
-import { EditableTreeEvents } from "./treeEvents.js";
+
 import { FlexTreeContext } from "./context.js";
+import { FlexTreeNodeEvents } from "./treeEvents.js";
+
+/**
+ * An anchor slot which records the {@link FlexTreeNode} associated with that anchor, if there is one.
+ * @remarks This always points to a "real" {@link FlexTreeNode} (i.e. a `LazyTreeNode`), never to a "raw" node.
+ */
+export const flexTreeSlot = anchorSlot<FlexTreeNode>();
 
 /**
  * Indicates that an object is a flex tree.
@@ -78,7 +91,7 @@ export interface FlexTreeEntity<out TSchema = unknown> {
 	readonly schema: TSchema;
 
 	/**
-	 * A common context of a "forest" of EditableTrees.
+	 * A common context of a "forest" of FlexTrees.
 	 */
 	readonly context: FlexTreeContext;
 
@@ -120,12 +133,6 @@ export enum TreeStatus {
 	Deleted = 2,
 }
 
-/**
- * {@inheritdoc TreeNode.[onNextChange]}
- * @internal
- */
-export const onNextChange = Symbol("onNextChange");
-
 /**
  * Generic tree node API.
  *
@@ -155,9 +162,9 @@ export interface FlexTreeNode extends FlexTreeEntity<FlexTreeNodeSchema> {
 	/**
 	 * {@inheritDoc ISubscribable#on}
 	 */
-	on<K extends keyof EditableTreeEvents>(
+	on<K extends keyof FlexTreeNodeEvents>(
 		eventName: K,
-		listener: EditableTreeEvents[K],
+		listener: FlexTreeNodeEvents[K],
 	): () => void;
 
 	/**
@@ -165,6 +172,17 @@ export interface FlexTreeNode extends FlexTreeEntity<FlexTreeNodeSchema> {
 	 */
 	tryGetField(key: FieldKey): undefined | FlexTreeField;
 
+	/**
+	 * Get the field for `key`.
+	 * @param key - which entry to look up.
+	 *
+	 * @remarks
+	 * All fields implicitly exist, so `getBoxed` can be called with any key and will always return a field.
+	 * Even if the field is empty, it will still be returned, and can be edited to insert content if allowed by the field kind.
+	 * See {@link FlexTreeNode.tryGetField} for a variant that does not allocate afield in the empty case.
+	 */
+	getBoxed(key: FieldKey): FlexTreeField;
+
 	/**
 	 * The field this tree is in, and the index within that field.
 	 */
@@ -178,21 +196,14 @@ export interface FlexTreeNode extends FlexTreeEntity<FlexTreeNodeSchema> {
 	boxedIterator(): IterableIterator<FlexTreeField>;
 
 	/**
-	 * Subscribe to the next change that affects this node's children.
-	 * @returns a function which will deregister the registered event.
-	 * It has no effect if the event was already deregistered.
+	 * The anchor node associated with this node
+	 *
 	 * @remarks
-	 * The given function will be run the next time that this node's direct children change.
-	 * It will only be run once, and thereafter automatically deregistered.
-	 * It does not run in response to changes beneath this node's direct children.
-	 * This event fires after the tree has been mutated but before {@link EditableTreeEvents.afterChange}.
-	 * Only one subscriber may register to this event at the same time.
-	 * @privateRemarks
-	 * This event allows the proxy-based API that is built on top of the editable tree to maintain invariants
-	 * around "hydrating" proxies that were created with schema-provided factory functions.
-	 * It is not a public API and thus the symbol for this property is not exported.
+	 * The ref count keeping this alive is owned by the FlexTreeNode:
+	 * if holding onto this anchor for longer than the FlexTreeNode might be alive,
+	 * a separate Anchor (and thus ref count) must be allocated to keep it alive.
 	 */
-	[onNextChange](fn: (node: FlexTreeNode) => void): () => void;
+	readonly anchorNode: AnchorNode;
 }
 
 /**
@@ -239,8 +250,8 @@ export interface FlexTreeField extends FlexTreeEntity<FlexFieldSchema> {
 
 	/**
 	 * Check if this field is the same as a different field.
-	 * This is defined to mean that both are in the same editable tree, and are the same field on the same node.
-	 * This is more than just a reference comparison because unlike EditableTree nodes, fields are not cached on anchors and can be duplicated.
+	 * This is defined to mean that both are in the same flex tree, and are the same field on the same node.
+	 * This is more than just a reference comparison because unlike FlexTree nodes, fields are not cached on anchors and can be duplicated.
 	 *
 	 * @privateRemarks
 	 * TODO:
@@ -248,6 +259,18 @@ export interface FlexTreeField extends FlexTreeEntity<FlexFieldSchema> {
 	 * Implementing this will require some care to preserve lazy-ness and work efficiently (without leaks) for empty fields, particularly on MapNodes.
 	 */
 	isSameAs(other: FlexTreeField): boolean;
+
+	/**
+	 * Gets a node of this field by its index without unboxing.
+	 * @param index - Zero-based index of the item to retrieve. Negative values are interpreted from the end of the sequence.
+	 *
+	 * @returns The element in the sequence matching the given index. Always returns undefined if index \< -sequence.length
+	 * or index \>= sequence.length.
+	 *
+	 * @remarks
+	 * Semantics match {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/at | Array.at}.
+	 */
+	boxedAt(index: number): FlexTreeNode | undefined;
 }
 
 // #region Node Kinds
@@ -566,6 +589,7 @@ export type FlexTreeObjectNodeFieldsInner<TFields extends FlexObjectNodeFields>
  * @internal
  */
 export const reservedObjectNodeFieldPropertyNames = [
+	"anchorNode",
 	"constructor",
 	"context",
 	"is",
@@ -579,6 +603,7 @@ export const reservedObjectNodeFieldPropertyNames = [
 	"localNodeKey",
 	"boxedIterator",
 	"iterator",
+	"getBoxed",
 ] as const;
 
 /**
@@ -715,14 +740,7 @@ export interface FlexTreeSequenceField<in out TTypes extends FlexAllowedTypes>
 	at(index: number): FlexTreeUnboxNodeUnion<TTypes> | undefined;
 
 	/**
-	 * Gets a node of this field by its index without unboxing.
-	 * @param index - Zero-based index of the item to retrieve. Negative values are interpreted from the end of the sequence.
-	 *
-	 * @returns The element in the sequence matching the given index. Always returns undefined if index \< -sequence.length
-	 * or index \>= array.length.
-	 *
-	 * @remarks
-	 * Semantics match {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/at | Array.at}.
+	 * {@inheritdoc FlexTreeField.boxedAt}
 	 */
 	boxedAt(index: number): FlexTreeTypedNodeUnion<TTypes> | undefined;
 

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

@@ -23,7 +23,6 @@ export {
 	FlexTreeTypedNodeUnion,
 	CheckTypesOverlap,
 	TreeStatus,
-	onNextChange,
 	FlexTreeUnknownUnboxed,
 	FlexTreeUnboxField,
 	flexTreeMarker,
@@ -35,6 +34,7 @@ export {
 	reservedObjectNodeFieldPropertyNames,
 	reservedObjectNodeFieldPropertyNamePrefixes,
 	FlexTreeObjectNodeFieldsInner,
+	flexTreeSlot,
 } from "./flexTreeTypes.js";
 
 export {
@@ -45,9 +45,9 @@ export {
 	visitIterableTreeWithState,
 } from "./navigation.js";
 
-export { getTreeContext, FlexTreeContext, Context } from "./context.js";
+export { getTreeContext, FlexTreeContext, Context, ContextSlot } from "./context.js";
 
-export { TreeEvent, EditableTreeEvents } from "./treeEvents.js";
+export { FlexTreeNodeEvents } from "./treeEvents.js";
 
 // Below here are things that are used by the above, but not part of the desired API surface.
 export {

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

@@ -3,35 +3,26 @@
  * Licensed under the MIT License.
  */
 
-import { assert } from "@fluidframework/core-utils";
+import { assert } from "@fluidframework/core-utils/internal";
+
 import {
-	TreeNavigationResult,
 	ITreeSubscriptionCursor,
 	ITreeSubscriptionCursorState,
+	TreeNavigationResult,
 } from "../../core/index.js";
-import { disposeSymbol, IDisposable } from "../../util/index.js";
+import { IDisposable, disposeSymbol } from "../../util/index.js";
+
 import { Context } from "./context.js";
 import { FlexTreeEntity, FlexTreeEntityKind, TreeStatus, flexTreeMarker } from "./flexTreeTypes.js";
 
-/**
- * Like {@link makePropertyNotEnumerable}, but less type safe so it works on private properties.
- */
-export function makePrivatePropertyNotEnumerable(
-	target: object,
-	key: string | symbol | number,
-): void {
-	assert(
-		Object.getOwnPropertyDescriptor(target, key)?.enumerable === true,
-		0x777 /* missing property or not enumerable */,
-	);
-	Object.defineProperty(target, key, { enumerable: false });
-}
-
 export const prepareForEditSymbol = Symbol("prepareForEdit");
 export const isFreedSymbol = Symbol("isFreed");
 export const tryMoveCursorToAnchorSymbol = Symbol("tryMoveCursorToAnchor");
 export const forgetAnchorSymbol = Symbol("forgetAnchor");
 export const cursorSymbol = Symbol("cursor");
+/**
+ * Symbol used to access the (generic) anchor of a {@link LazyEntity}.
+ */
 export const anchorSymbol = Symbol("anchor");
 
 /**
@@ -74,7 +65,7 @@ export abstract class LazyEntity<TSchema = unknown, TAnchor = unknown>
 	public [disposeSymbol](): void {
 		this.#lazyCursor.free();
 		this.context.withCursors.delete(this);
-		this[forgetAnchorSymbol](this[anchorSymbol]);
+		this[forgetAnchorSymbol]();
 		this.context.withAnchors.delete(this);
 	}
 
@@ -95,12 +86,12 @@ export abstract class LazyEntity<TSchema = unknown, TAnchor = unknown>
 			);
 			assert(
 				this[anchorSymbol] !== undefined,
-				0x779 /* EditableTree should have an anchor if it does not have a cursor */,
+				0x779 /* FlexTree should have an anchor if it does not have a cursor */,
 			);
-			const result = this[tryMoveCursorToAnchorSymbol](this[anchorSymbol], this.#lazyCursor);
+			const result = this[tryMoveCursorToAnchorSymbol](this.#lazyCursor);
 			assert(
 				result === TreeNavigationResult.Ok,
-				0x77a /* It is invalid to access an EditableTree node which no longer exists */,
+				0x77a /* It is invalid to access a FlexTree node which no longer exists */,
 			);
 			this.context.withCursors.add(this);
 		}
@@ -108,14 +99,13 @@ export abstract class LazyEntity<TSchema = unknown, TAnchor = unknown>
 	}
 
 	protected abstract [tryMoveCursorToAnchorSymbol](
-		anchor: TAnchor,
 		cursor: ITreeSubscriptionCursor,
 	): TreeNavigationResult;
 
 	/**
 	 * Called when disposing of this target, iff it has an anchor.
 	 */
-	protected abstract [forgetAnchorSymbol](anchor: TAnchor): void;
+	protected abstract [forgetAnchorSymbol](): void;
 }
 
 /**