@fluidframework/tree 2.23.0 → 2.30.0

package/src/feature-libraries/node-identifier/nodeIdentifierManager.ts

@@ -0,0 +1,95 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { assert } from "@fluidframework/core-utils/internal";
+import type { IIdCompressor } from "@fluidframework/id-compressor";
+import { assertIsStableId, isStableId } from "@fluidframework/id-compressor/internal";
+
+import { brand, extractFromOpaque } from "../../util/index.js";
+
+import type { LocalNodeIdentifier, StableNodeIdentifier } from "./nodeIdentifier.js";
+
+/**
+ * An object which handles the generation of node identifiers as well as conversion between their two types ({@link StableNodeIdentifier} and {@link LocalNodeIdentifier}).
+ */
+export interface NodeIdentifierManager {
+	/**
+	 * Generate a {@link StableNodeIdentifier}.
+	 */
+	generateLocalNodeIdentifier(): LocalNodeIdentifier;
+
+	/**
+	 * Convert the given {@link StableNodeIdentifier} into its {@link LocalNodeIdentifier} form.
+	 */
+	localizeNodeIdentifier(identifier: StableNodeIdentifier): LocalNodeIdentifier;
+
+	/**
+	 * Convert the given {@link LocalNodeIdentifier} into its {@link StableNodeIdentifier} form.
+	 */
+	stabilizeNodeIdentifier(identifier: LocalNodeIdentifier): StableNodeIdentifier;
+
+	/**
+	 * Attempts to recompress a {@link StableNodeIdentifier}.
+	 * @param identifier - The identifier that is attempted to recompress.
+	 * @returns The `{@link LocalNodeIdentifier}` associated with `identifier` or undefined if the identifier was not generated by any session known to this compressor.
+	 */
+	tryLocalizeNodeIdentifier(identifier: string): LocalNodeIdentifier | undefined;
+}
+
+/**
+ * Creates a {@link NodeIdentifierManager} from the given {@link IIdCompressor}.
+ * @param idCompressor - the compressor to use for identifier generation, compression, and decompression.
+ * If undefined, then attempts to generate or convert identifiers will throw an error.
+ */
+export function createNodeIdentifierManager(
+	idCompressor?: IIdCompressor | undefined,
+): NodeIdentifierManager {
+	return {
+		generateLocalNodeIdentifier: () => {
+			assert(
+				idCompressor !== undefined,
+				0x6e4 /* Runtime IdCompressor must be available to generate local node identifiers */,
+			);
+			return brand(idCompressor.generateCompressedId());
+		},
+
+		localizeNodeIdentifier: (identifier: StableNodeIdentifier) => {
+			assert(
+				idCompressor !== undefined,
+				0x6e5 /* Runtime IdCompressor must be available to convert node identifiers */,
+			);
+			return brand(idCompressor.recompress(identifier));
+		},
+
+		stabilizeNodeIdentifier: (identifier: LocalNodeIdentifier) => {
+			assert(
+				idCompressor !== undefined,
+				0x6e6 /* Runtime IdCompressor must be available to convert node identifiers */,
+			);
+			return brand(
+				// TODO: The assert below is required for type safety but is maybe slow
+				assertIsStableId(idCompressor.decompress(extractFromOpaque(identifier))),
+			);
+		},
+		tryLocalizeNodeIdentifier: (identifier: string) => {
+			assert(
+				idCompressor !== undefined,
+				0x6e9 /* Runtime IdCompressor must be available to convert node identifiers */,
+			);
+			if (isStableNodeIdentifier(identifier)) {
+				const compressedIdentifier = idCompressor.tryRecompress(identifier);
+				if (compressedIdentifier !== undefined) {
+					return brand(compressedIdentifier);
+				}
+			}
+		},
+	};
+}
+
+export function isStableNodeIdentifier(
+	identifier: string,
+): identifier is StableNodeIdentifier {
+	return isStableId(identifier);
+}

package/src/feature-libraries/object-forest/objectForest.ts

@@ -12,6 +12,7 @@ import {
 	AnchorSet,
 	type AnnouncedVisitor,
 	type CursorLocationType,
+	type DeltaDetachedNodeId,
 	type DeltaVisitor,
 	type DetachedField,
 	type FieldAnchor,
@@ -26,8 +27,8 @@ import {
 	type MapTree,
 	type PathRootPrefix,
 	type PlaceIndex,
-	type ProtoNodes,
 	type Range,
+	type TreeChunk,
 	TreeNavigationResult,
 	type TreeNodeSchemaIdentifier,
 	type TreeStoredSchemaSubscription,
@@ -46,6 +47,7 @@ import {
 } from "../../util/index.js";
 import { cursorForMapTreeNode, mapTreeFromCursor } from "../mapTreeCursor.js";
 import { type CursorWithNode, SynchronousCursor } from "../treeCursorUtils.js";
+import { chunkFieldSingle, defaultChunkPolicy } from "../chunked-forest/index.js";
 
 /** A `MapTree` with mutable fields */
 interface MutableMapTree extends MapTree {
@@ -107,6 +109,10 @@ export class ObjectForest implements IEditableForest {
 		return new ObjectForest(anchors, this.additionalAsserts, this.roots);
 	}
 
+	public chunkField(cursor: ITreeCursorSynchronous): TreeChunk {
+		return chunkFieldSingle(cursor, { idCompressor: undefined, policy: defaultChunkPolicy });
+	}
+
 	public forgetAnchor(anchor: Anchor): void {
 		this.anchors.forget(anchor);
 	}
@@ -163,7 +169,7 @@ export class ObjectForest implements IEditableForest {
 				preEdit();
 				this.forest.delete(detachedField);
 			}
-			public create(content: ProtoNodes, destination: FieldKey): void {
+			public create(content: readonly ITreeCursorSynchronous[], destination: FieldKey): void {
 				preEdit();
 				this.forest.add(content, destination);
 				this.forest.#events.emit("afterRootFieldCreated", destination);
@@ -172,7 +178,7 @@ export class ObjectForest implements IEditableForest {
 				preEdit();
 				this.attachEdit(source, count, destination);
 			}
-			public detach(source: Range, destination: FieldKey): void {
+			public detach(source: Range, destination: FieldKey, id: DeltaDetachedNodeId): void {
 				preEdit();
 				this.detachEdit(source, destination);
 			}
@@ -235,6 +241,7 @@ export class ObjectForest implements IEditableForest {
 				newContentSource: FieldKey,
 				range: Range,
 				oldContentDestination: FieldKey,
+				oldContentId: DeltaDetachedNodeId,
 			): void {
 				preEdit();
 				assert(

package/src/feature-libraries/treeCursorUtils.ts

@@ -182,7 +182,7 @@ class StackCursor<TNode> extends SynchronousCursor implements CursorWithNode<TNo
 		const siblings = this.getField();
 		if (!(index in siblings)) {
 			throw new UsageError(
-				"A child does not exist at the specified index, check the status of a node using `Tree.status()`.",
+				`A child does not exist at index '${index}' in field containing ${siblings.length} nodes.`,
 			);
 		}
 		this.siblingStack.push(this.siblings);

package/src/index.ts

@@ -216,6 +216,12 @@ export {
 	type TransactionResultSuccess,
 	type TransactionResultFailed,
 	rollback,
+	generateSchemaFromSimpleSchema,
+	evaluateLazySchema,
+	replaceConciseTreeHandles,
+	replaceHandles,
+	replaceVerboseTreeHandles,
+	type HandleConverter,
 } from "./simple-tree/index.js";
 export {
 	SharedTree,
@@ -233,15 +239,18 @@ export {
 export { noopValidator } from "./codec/index.js";
 export { typeboxValidator } from "./external-utilities/index.js";
 
-export {
-	type RestrictiveReadonlyRecord,
-	type RestrictiveStringRecord,
-	type MakeNominal,
-	type IsUnion,
-	type UnionToIntersection,
-	type UnionToTuple,
-	type PopUnion,
+export type {
+	RestrictiveReadonlyRecord,
+	RestrictiveStringRecord,
+	MakeNominal,
+	IsUnion,
+	UnionToIntersection,
+	UnionToTuple,
+	PopUnion,
+	JsonCompatible,
+	JsonCompatibleObject,
 } from "./util/index.js";
+export { cloneWithReplacements } from "./util/index.js";
 
 import * as InternalTypes from "./internalTypes.js";
 export {
@@ -257,7 +266,5 @@ export {
 // The inferred type of 'NodeMap' cannot be named without a reference to '../../node_modules/@fluidframework/tree/lib/internalTypes.js'. This is likely not portable. A type annotation is necessary.
 export type { MapNodeInsertableData } from "./simple-tree/index.js";
 
-export type { JsonCompatible, JsonCompatibleObject } from "./util/index.js";
-
 export { JsonAsTree } from "./jsonDomainSchema.js";
 export { FluidSerializableAsTree } from "./serializableDomainSchema.js";

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/tree";
-export const pkgVersion = "2.23.0";
+export const pkgVersion = "2.30.0";

package/src/shared-tree/checkoutFlexTreeView.ts

@@ -7,7 +7,7 @@ import { assert } from "@fluidframework/core-utils/internal";
 import {
 	type Context,
 	type FlexTreeField,
-	type NodeKeyManager,
+	type NodeIdentifierManager,
 	getTreeContext,
 	type FlexTreeHydratedContext,
 	type FullSchemaPolicy,
@@ -43,7 +43,7 @@ export class CheckoutFlexTreeView<out TCheckout extends ITreeCheckout = ITreeChe
 		 */
 		public readonly checkout: TCheckout,
 		public readonly schema: FullSchemaPolicy,
-		public readonly nodeKeyManager: NodeKeyManager,
+		public readonly nodeKeyManager: NodeIdentifierManager,
 		private readonly onDispose?: () => void,
 	) {
 		this.context = getTreeContext(schema, this.checkout, nodeKeyManager);

package/src/shared-tree/independentView.ts

@@ -14,19 +14,15 @@ import {
 	type RevisionTag,
 	RevisionTagCodec,
 	TreeStoredSchemaRepository,
-	initializeForest,
-	type ITreeCursorSynchronous,
-	mapCursorField,
 } from "../core/index.js";
 import {
-	createNodeKeyManager,
+	createNodeIdentifierManager,
 	makeFieldBatchCodec,
 	makeSchemaCodec,
 	type FieldBatchEncodingContext,
 	defaultSchemaPolicy,
-	chunkTree,
-	defaultChunkPolicy,
 	TreeCompressionStrategy,
+	initializeForest,
 } from "../feature-libraries/index.js";
 // eslint-disable-next-line import/no-internal-modules
 import type { Format } from "../feature-libraries/schema-index/format.js";
@@ -73,7 +69,7 @@ export function independentView<const TSchema extends ImplicitFieldSchema>(
 	const out: TreeViewAlpha<TSchema> = new SchematizingSimpleTreeView<TSchema>(
 		checkout,
 		config,
-		createNodeKeyManager(idCompressor),
+		createNodeIdentifierManager(idCompressor),
 	);
 	return out;
 }
@@ -116,9 +112,7 @@ export function independentInitializedView<const TSchema extends ImplicitFieldSc
 	assert(fieldCursors.length === 1, 0xa5b /* must have exactly 1 field in batch */);
 	// Checked above.
 	// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-	const cursors = fieldCursorToNodesCursors(fieldCursors[0]!);
-
-	initializeForest(forest, cursors, revisionTagCodec, idCompressor, false);
+	initializeForest(forest, fieldCursors[0]!, revisionTagCodec, idCompressor, false);
 
 	const checkout = createTreeCheckout(idCompressor, mintRevisionTag, revisionTagCodec, {
 		forest,
@@ -127,29 +121,11 @@ export function independentInitializedView<const TSchema extends ImplicitFieldSc
 	const out: TreeViewAlpha<TSchema> = new SchematizingSimpleTreeView<TSchema>(
 		checkout,
 		config,
-		createNodeKeyManager(idCompressor),
+		createNodeIdentifierManager(idCompressor),
 	);
 	return out;
 }
 
-function fieldCursorToNodesCursors(
-	fieldCursor: ITreeCursorSynchronous,
-): ITreeCursorSynchronous[] {
-	return mapCursorField(fieldCursor, copyNodeCursor);
-}
-
-/**
- * TODO: avoid needing this, or optimize it.
- */
-function copyNodeCursor(cursor: ITreeCursorSynchronous): ITreeCursorSynchronous {
-	const copy = chunkTree(cursor, {
-		policy: defaultChunkPolicy,
-		idCompressor: undefined,
-	}).cursor();
-	copy.enterNode(0);
-	return copy;
-}
-
 /**
  * The portion of SharedTree data typically persisted by the container.
  * Usable with {@link independentInitializedView} to create a {@link TreeView}

package/src/shared-tree/index.ts

@@ -21,6 +21,7 @@ export {
 	ForestTypeOptimized,
 	ForestTypeExpensiveDebug,
 	ForestTypeReference,
+	exportSimpleSchema,
 } from "./sharedTree.js";
 
 export {

package/src/shared-tree/schematizeTree.ts

@@ -180,6 +180,7 @@ export function initialize(checkout: ITreeCheckout, treeContent: TreeStoredConte
 		initializeContent(checkout, treeContent.schema, () => {
 			const field = { field: rootFieldKey, parent: undefined };
 			const content = normalizeNewFieldContent(treeContent.initialTree);
+			const contentChunk = checkout.forest.chunkField(content);
 
 			switch (checkout.storedSchema.rootFieldSchema.kind) {
 				case FieldKinds.optional.identifier: {
@@ -188,13 +189,13 @@ export function initialize(checkout: ITreeCheckout, treeContent: TreeStoredConte
 						content.getFieldLength() <= 1,
 						0x7f4 /* optional field content should normalize at most one item */,
 					);
-					fieldEditor.set(content.getFieldLength() === 0 ? undefined : content, true);
+					fieldEditor.set(contentChunk.topLevelLength === 0 ? undefined : contentChunk, true);
 					break;
 				}
 				case FieldKinds.sequence.identifier: {
 					const fieldEditor = checkout.editor.sequenceField(field);
 					// TODO: should do an idempotent edit here.
-					fieldEditor.insert(0, content);
+					fieldEditor.insert(0, contentChunk);
 					break;
 				}
 				default: {

package/src/shared-tree/schematizingTreeView.ts

@@ -14,7 +14,7 @@ import { UsageError } from "@fluidframework/telemetry-utils/internal";
 
 import { AllowedUpdateType, anchorSlot, type SchemaPolicy } from "../core/index.js";
 import {
-	type NodeKeyManager,
+	type NodeIdentifierManager,
 	defaultSchemaPolicy,
 	ContextSlot,
 	cursorForMapTreeNode,
@@ -117,7 +117,7 @@ export class SchematizingSimpleTreeView<
 	public constructor(
 		public readonly checkout: TreeCheckout,
 		public readonly config: TreeViewConfiguration<ReadSchema<TRootSchema>>,
-		public readonly nodeKeyManager: NodeKeyManager,
+		public readonly nodeKeyManager: NodeIdentifierManager,
 		private readonly onDispose?: () => void,
 	) {
 		this.breaker = checkout.breaker;
@@ -509,7 +509,7 @@ export function requireSchema(
 	checkout: ITreeCheckout,
 	viewSchema: ViewSchema,
 	onDispose: () => void,
-	nodeKeyManager: NodeKeyManager,
+	nodeKeyManager: NodeIdentifierManager,
 	schemaPolicy: FullSchemaPolicy,
 ): CheckoutFlexTreeView {
 	const slots = checkout.forest.anchors.slots;

package/src/shared-tree/sharedTree.ts

@@ -478,14 +478,7 @@ class SharedTreeKernel extends SharedTreeCore<SharedTreeEditBuilder, SharedTreeC
 	}
 
 	public exportSimpleSchema(): SimpleTreeSchema {
-		return {
-			...exportSimpleFieldSchemaStored(this.storedSchema.rootFieldSchema),
-			definitions: new Map(
-				[...this.storedSchema.nodeSchema].map(([key, schema]) => {
-					return [key, exportSimpleNodeSchemaStored(schema)];
-				}),
-			),
-		};
+		return exportSimpleSchema(this.storedSchema);
 	}
 
 	@throwIfBroken
@@ -572,6 +565,17 @@ class SharedTreeKernel extends SharedTreeCore<SharedTreeEditBuilder, SharedTreeC
 	public onDisconnect(): void {}
 }
 
+export function exportSimpleSchema(storedSchema: TreeStoredSchema): SimpleTreeSchema {
+	return {
+		...exportSimpleFieldSchemaStored(storedSchema.rootFieldSchema),
+		definitions: new Map(
+			[...storedSchema.nodeSchema].map(([key, schema]) => {
+				return [key, exportSimpleNodeSchemaStored(schema)];
+			}),
+		),
+	};
+}
+
 /**
  * Get a {@link BranchableTree} from a {@link ITree}.
  * @remarks The branch can be used for "version control"-style coordination of edits on the tree.
@@ -770,7 +774,7 @@ function verboseFromCursor(
 	const nodeSchema =
 		schema.get(reader.type) ?? fail(0xac9 /* missing schema for type in cursor */);
 	if (nodeSchema instanceof LeafNodeStoredSchema) {
-		return fields as CustomTreeValue<IFluidHandle>;
+		return fields as CustomTreeValue;
 	}
 
 	return {

package/src/shared-tree/sharedTreeChangeFamily.ts

@@ -87,7 +87,6 @@ export class SharedTreeChangeFamily
 			this.modularChangeFamily,
 			mintRevisionTag,
 			changeReceiver,
-			this.idCompressor,
 		);
 	}
 

package/src/shared-tree/sharedTreeEditBuilder.ts

@@ -3,7 +3,6 @@
  * Licensed under the MIT License.
  */
 
-import type { IIdCompressor } from "@fluidframework/id-compressor";
 import type {
 	ChangeFamilyEditor,
 	RevisionTag,
@@ -55,17 +54,12 @@ export class SharedTreeEditBuilder
 		modularChangeFamily: ModularChangeFamily,
 		mintRevisionTag: () => RevisionTag,
 		private readonly changeReceiver: (change: TaggedChange<SharedTreeChange>) => void,
-		idCompressor?: IIdCompressor,
 	) {
-		super(
-			modularChangeFamily,
-			mintRevisionTag,
-			(taggedChange) =>
-				changeReceiver({
-					...taggedChange,
-					change: { changes: [{ type: "data", innerChange: taggedChange.change }] },
-				}),
-			idCompressor,
+		super(modularChangeFamily, mintRevisionTag, (taggedChange) =>
+			changeReceiver({
+				...taggedChange,
+				change: { changes: [{ type: "data", innerChange: taggedChange.change }] },
+			}),
 		);
 
 		this.schema = {

package/src/shared-tree/treeApiAlpha.ts

@@ -32,7 +32,6 @@ import {
 	verboseFromCursor,
 	type ParseOptions,
 	type VerboseTree,
-	type VerboseTreeNode,
 	toStoredSchema,
 	type EncodeOptions,
 	extractPersistedSchema,
@@ -126,65 +125,24 @@ export const TreeAlpha: {
 	 * Construct tree content compatible with a field defined by the provided `schema`.
 	 * @param schema - The schema for what to construct. As this is an {@link ImplicitFieldSchema}, a {@link FieldSchema}, {@link TreeNodeSchema} or {@link AllowedTypes} array can be provided.
 	 * @param data - The data used to construct the field content. See {@link TreeAlpha.(exportVerbose:1)}.
-	 * @remarks
-	 * This overload requires that any {@link @fluidframework/core-interfaces#IFluidHandle|IFluidHandles} are encoded as actual {@link @fluidframework/core-interfaces#IFluidHandle|IFluidHandles} in the input.
 	 */
 	importVerbose<const TSchema extends ImplicitFieldSchema>(
 		schema: TSchema,
 		data: VerboseTree | undefined,
-		options?: Partial<ParseOptions<IFluidHandle>>,
-	): Unhydrated<TreeFieldFromImplicitField<TSchema>>;
-
-	/**
-	 * Construct tree content compatible with a field defined by the provided `schema`.
-	 * @param schema - The schema for what to construct. As this is an {@link ImplicitFieldSchema}, a {@link FieldSchema}, {@link TreeNodeSchema} or {@link AllowedTypes} array can be provided.
-	 * @param data - The data used to construct the field content. See {@link TreeAlpha.(exportVerbose:2)}.
-	 *
-	 * @typeparam THandle - How {@link @fluidframework/core-interfaces#IFluidHandle|IFluidHandles} in the input `data` are encoded.
-	 * A converter from this encoding to {@link @fluidframework/core-interfaces#IFluidHandle} is required in `options`.
-	 */
-	importVerbose<const TSchema extends ImplicitFieldSchema, THandle>(
-		schema: TSchema,
-		data: VerboseTree<THandle> | undefined,
-		options: ParseOptions<THandle>,
+		options?: Partial<ParseOptions>,
 	): Unhydrated<TreeFieldFromImplicitField<TSchema>>;
 
-	/**
-	 * Same as {@link TreeAlpha.(exportConcise:2)}, except leaves handles as is.
-	 */
-	exportConcise(
-		node: TreeNode | TreeLeafValue,
-		options?: Partial<EncodeOptions<IFluidHandle>>,
-	): ConciseTree;
-
 	/**
 	 * Copy a snapshot of the current version of a TreeNode into a {@link ConciseTree}.
-	 *
-	 * @typeparam THandle - How {@link @fluidframework/core-interfaces#IFluidHandle|IFluidHandles} in the output should be encoded.
-	 * A converter from from {@link @fluidframework/core-interfaces#IFluidHandle} to this format is required in `options`.
 	 */
-	exportConcise<THandle>(
-		node: TreeNode | TreeLeafValue,
-		options: EncodeOptions<THandle>,
-	): ConciseTree<THandle>;
+	exportConcise(node: TreeNode | TreeLeafValue, options?: EncodeOptions): ConciseTree;
 
 	/**
-	 * Same {@link TreeAlpha.(exportVerbose:2)} except leaves handles as is.
-	 */
-	exportVerbose(
-		node: TreeNode | TreeLeafValue,
-		options?: Partial<EncodeOptions<IFluidHandle>>,
-	): VerboseTree;
-
-	/**
-	 * Copy a snapshot of the current version of a TreeNode into a JSON compatible plain old JavaScript Object.
-	 * Verbose tree format, with explicit type on every node.
-	 *
-	 * @typeparam THandle - How {@link @fluidframework/core-interfaces#IFluidHandle|IFluidHandles} in the output should be encoded.
-	 * A converter from from {@link @fluidframework/core-interfaces#IFluidHandle} to this format is required in `options`.
+	 * Copy a snapshot of the current version of a TreeNode into a JSON compatible plain old JavaScript Object (except for {@link @fluidframework/core-interfaces#IFluidHandle|IFluidHandles}).
+	 * Uses the {@link VerboseTree} format, with an explicit type on every node.
 	 *
 	 * @remarks
-	 * There are several cases this may be preferred to {@link TreeAlpha.(exportConcise:2)}:
+	 * There are several cases this may be preferred to {@link TreeAlpha.exportConcise}:
 	 *
 	 * 1. When not using {@link ITreeConfigurationOptions.preventAmbiguity} (or when using `useStableFieldKeys`), `exportConcise` can produce ambiguous data (the type may be unclear on some nodes).
 	 * `exportVerbose` will always be unambiguous and thus lossless.
@@ -193,7 +151,7 @@ export const TreeAlpha: {
 	 *
 	 * 3. When easy access to the type is desired.
 	 */
-	exportVerbose<T>(node: TreeNode | TreeLeafValue, options: EncodeOptions<T>): VerboseTree<T>;
+	exportVerbose(node: TreeNode | TreeLeafValue, options?: EncodeOptions): VerboseTree;
 
 	/**
 	 * Export the content of the provided `tree` in a compressed JSON compatible format.
@@ -274,17 +232,12 @@ export const TreeAlpha: {
 		>;
 	},
 
-	importVerbose<const TSchema extends ImplicitFieldSchema, THandle>(
+	importVerbose<const TSchema extends ImplicitFieldSchema>(
 		schema: TSchema,
-		data: VerboseTree<THandle> | undefined,
-		options?: Partial<ParseOptions<THandle>>,
+		data: VerboseTree | undefined,
+		options?: ParseOptions,
 	): Unhydrated<TreeFieldFromImplicitField<TSchema>> {
-		const config: ParseOptions<THandle> = {
-			valueConverter: (input: VerboseTree<THandle>) => {
-				return input as TreeLeafValue | VerboseTreeNode<THandle>;
-			},
-			...options,
-		};
+		const config: ParseOptions = { ...options };
 		// Create a config which is standalone, and thus can be used without having to refer back to the schema.
 		const schemalessConfig = applySchemaToParserOptions(schema, config);
 		if (data === undefined) {
@@ -294,20 +247,12 @@ export const TreeAlpha: {
 			}
 			return undefined as Unhydrated<TreeFieldFromImplicitField<TSchema>>;
 		}
-		const cursor = cursorFromVerbose<THandle>(data, schemalessConfig);
+		const cursor = cursorFromVerbose(data, schemalessConfig);
 		return createFromCursor(schema, cursor);
 	},
 
-	exportConcise<T>(
-		node: TreeNode | TreeLeafValue,
-		options?: Partial<EncodeOptions<T>>,
-	): ConciseTree<T> {
-		const config: EncodeOptions<T> = {
-			valueConverter(handle: IFluidHandle): T {
-				return handle as T;
-			},
-			...options,
-		};
+	exportConcise(node: TreeNode | TreeLeafValue, options?: EncodeOptions): ConciseTree {
+		const config: EncodeOptions = { ...options };
 
 		const cursor = borrowCursorFromTreeNodeOrValue(node);
 		return conciseFromCursor(
@@ -317,16 +262,8 @@ export const TreeAlpha: {
 		);
 	},
 
-	exportVerbose<T>(
-		node: TreeNode | TreeLeafValue,
-		options?: Partial<EncodeOptions<T>>,
-	): VerboseTree<T> {
-		const config: EncodeOptions<T> = {
-			valueConverter(handle: IFluidHandle): T {
-				return handle as T;
-			},
-			...options,
-		};
+	exportVerbose(node: TreeNode | TreeLeafValue, options?: EncodeOptions): VerboseTree {
+		const config: EncodeOptions = { ...options };
 
 		const cursor = borrowCursorFromTreeNodeOrValue(node);
 		return verboseFromCursor(

package/src/shared-tree/treeCheckout.ts

@@ -47,7 +47,7 @@ import {
 	type FieldBatchCodec,
 	type TreeCompressionStrategy,
 	buildForest,
-	createNodeKeyManager,
+	createNodeIdentifierManager,
 	intoDelta,
 	jsonableTreeFromCursor,
 	makeFieldBatchCodec,
@@ -662,7 +662,7 @@ export class TreeCheckout implements ITreeCheckoutFork {
 		const view = new SchematizingSimpleTreeView(
 			this,
 			config,
-			createNodeKeyManager(this.idCompressor),
+			createNodeIdentifierManager(this.idCompressor),
 			() => {
 				this.views.delete(view);
 			},