@fluidframework/tree 2.23.0 → 2.31.0

package/src/shared-tree/sharedTree.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { assert } from "@fluidframework/core-utils/internal";
+import { assert, fail } from "@fluidframework/core-utils/internal";
 import type {
 	ErasedType,
 	IFluidHandle,
@@ -35,6 +35,7 @@ import type { ISequencedDocumentMessage } from "@fluidframework/driver-definitio
 
 import { type ICodecOptions, noopValidator } from "../codec/index.js";
 import {
+	type FieldKey,
 	type GraphCommit,
 	type IEditableForest,
 	type ITreeCursor,
@@ -93,6 +94,7 @@ import {
 	type CustomTreeNode,
 	type CustomTreeValue,
 	type ITreeAlpha,
+	type SimpleObjectFieldSchema,
 } from "../simple-tree/index.js";
 
 import { SchematizingSimpleTreeView } from "./schematizingTreeView.js";
@@ -101,7 +103,7 @@ import { SharedTreeChangeFamily } from "./sharedTreeChangeFamily.js";
 import type { SharedTreeChange } from "./sharedTreeChangeTypes.js";
 import type { SharedTreeEditBuilder } from "./sharedTreeEditBuilder.js";
 import { type TreeCheckout, type BranchableTree, createTreeCheckout } from "./treeCheckout.js";
-import { Breakable, breakingClass, fail, throwIfBroken } from "../util/index.js";
+import { Breakable, breakingClass, throwIfBroken } from "../util/index.js";
 
 /**
  * Copy of data from an {@link ITreePrivate} at some point in time.
@@ -478,14 +480,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 +567,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 +776,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 {
@@ -798,30 +804,34 @@ function exportSimpleFieldSchemaStored(schema: TreeFieldStoredSchema): SimpleFie
 		default:
 			fail(0xaca /* invalid field kind */);
 	}
-	return { kind, allowedTypes: schema.types };
+	return { kind, allowedTypesIdentifiers: schema.types, metadata: {} };
 }
 
 function exportSimpleNodeSchemaStored(schema: TreeNodeStoredSchema): SimpleNodeSchema {
 	const arrayTypes = tryStoredSchemaAsArray(schema);
 	if (arrayTypes !== undefined) {
-		return { kind: NodeKind.Array, allowedTypes: arrayTypes };
+		return { kind: NodeKind.Array, allowedTypesIdentifiers: arrayTypes, metadata: {} };
 	}
 	if (schema instanceof ObjectNodeStoredSchema) {
-		const fields: Record<string, SimpleFieldSchema> = {};
-		for (const [key, field] of schema.objectNodeFields) {
-			fields[key] = exportSimpleFieldSchemaStored(field);
+		const fields = new Map<FieldKey, SimpleObjectFieldSchema>();
+		for (const [storedKey, field] of schema.objectNodeFields) {
+			fields.set(storedKey, { ...exportSimpleFieldSchemaStored(field), storedKey });
 		}
-		return { kind: NodeKind.Object, fields };
+		return { kind: NodeKind.Object, fields, metadata: {} };
 	}
 	if (schema instanceof MapNodeStoredSchema) {
 		assert(
 			schema.mapFields.kind === FieldKinds.optional.identifier,
 			0xa95 /* Invalid map schema */,
 		);
-		return { kind: NodeKind.Map, allowedTypes: schema.mapFields.types };
+		return {
+			kind: NodeKind.Map,
+			allowedTypesIdentifiers: schema.mapFields.types,
+			metadata: {},
+		};
 	}
 	if (schema instanceof LeafNodeStoredSchema) {
-		return { kind: NodeKind.Leaf, leafKind: schema.leafValue };
+		return { kind: NodeKind.Leaf, leafKind: schema.leafValue, metadata: {} };
 	}
 	fail(0xacb /* invalid schema kind */);
 }

package/src/shared-tree/sharedTreeChangeFamily.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { assert } from "@fluidframework/core-utils/internal";
+import { assert, fail } from "@fluidframework/core-utils/internal";
 
 import type { ICodecFamily, ICodecOptions } from "../codec/index.js";
 import {
@@ -31,7 +31,6 @@ import {
 	type Mutable,
 	type NestedSet,
 	addToNestedSet,
-	fail,
 	hasSingle,
 	nestedSetContains,
 } from "../util/index.js";
@@ -87,7 +86,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

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { assert } from "@fluidframework/core-utils/internal";
+import { assert, fail } from "@fluidframework/core-utils/internal";
 import { createIdCompressor } from "@fluidframework/id-compressor/internal";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 import type { IFluidHandle } from "@fluidframework/core-interfaces";
@@ -32,14 +32,13 @@ import {
 	verboseFromCursor,
 	type ParseOptions,
 	type VerboseTree,
-	type VerboseTreeNode,
 	toStoredSchema,
 	type EncodeOptions,
 	extractPersistedSchema,
 	TreeViewConfiguration,
 	type TreeBranch,
 } from "../simple-tree/index.js";
-import { fail, type JsonCompatible } from "../util/index.js";
+import type { JsonCompatible } from "../util/index.js";
 import { noopValidator, type FluidClientVersion, type ICodecOptions } from "../codec/index.js";
 import type { ITreeCursorSynchronous } from "../core/index.js";
 import {
@@ -126,65 +125,32 @@ 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.
+	 * Copy a snapshot of the current version of a TreeNode into a {@link ConciseTree}, allowing undefined.
 	 */
-	exportVerbose(
-		node: TreeNode | TreeLeafValue,
-		options?: Partial<EncodeOptions<IFluidHandle>>,
-	): VerboseTree;
+	exportConcise(
+		node: TreeNode | TreeLeafValue | undefined,
+		options?: EncodeOptions,
+	): ConciseTree | undefined;
 
 	/**
-	 * 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)}:
 	 *
 	 * 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 +159,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 +240,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,39 +255,14 @@ 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,
 
-		const cursor = borrowCursorFromTreeNodeOrValue(node);
-		return conciseFromCursor(
-			cursor,
-			tryGetSchema(node) ?? fail(0xacd /* invalid input */),
-			config,
-		);
-	},
-
-	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(
@@ -378,6 +314,30 @@ export const TreeAlpha: {
 	},
 };
 
+function exportConcise(node: TreeNode | TreeLeafValue, options?: EncodeOptions): ConciseTree;
+
+function exportConcise(
+	node: TreeNode | TreeLeafValue | undefined,
+	options?: EncodeOptions,
+): ConciseTree | undefined;
+
+function exportConcise(
+	node: TreeNode | TreeLeafValue | undefined,
+	options?: EncodeOptions,
+): ConciseTree | undefined {
+	if (node === undefined) {
+		return undefined;
+	}
+	const config: EncodeOptions = { ...options };
+
+	const cursor = borrowCursorFromTreeNodeOrValue(node);
+	return conciseFromCursor(
+		cursor,
+		tryGetSchema(node) ?? fail(0xacd /* invalid input */),
+		config,
+	);
+}
+
 function borrowCursorFromTreeNodeOrValue(
 	node: TreeNode | TreeLeafValue,
 ): ITreeCursorSynchronous {

package/src/shared-tree/treeCheckout.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { assert, unreachableCase } from "@fluidframework/core-utils/internal";
+import { assert, unreachableCase, fail } from "@fluidframework/core-utils/internal";
 import type { Listenable } from "@fluidframework/core-interfaces/internal";
 import { createEmitter } from "@fluid-internal/client-utils";
 import type { IIdCompressor } from "@fluidframework/id-compressor";
@@ -47,7 +47,7 @@ import {
 	type FieldBatchCodec,
 	type TreeCompressionStrategy,
 	buildForest,
-	createNodeKeyManager,
+	createNodeIdentifierManager,
 	intoDelta,
 	jsonableTreeFromCursor,
 	makeFieldBatchCodec,
@@ -60,13 +60,7 @@ import {
 	type SharedTreeBranchChange,
 	type Transactor,
 } from "../shared-tree-core/index.js";
-import {
-	Breakable,
-	disposeSymbol,
-	fail,
-	getOrCreate,
-	type WithBreakable,
-} from "../util/index.js";
+import { Breakable, disposeSymbol, getOrCreate, type WithBreakable } from "../util/index.js";
 
 import { SharedTreeChangeFamily, hasSchemaChange } from "./sharedTreeChangeFamily.js";
 import type { SharedTreeChange } from "./sharedTreeChangeTypes.js";
@@ -662,7 +656,7 @@ export class TreeCheckout implements ITreeCheckoutFork {
 		const view = new SchematizingSimpleTreeView(
 			this,
 			config,
-			createNodeKeyManager(this.idCompressor),
+			createNodeIdentifierManager(this.idCompressor),
 			() => {
 				this.views.delete(view);
 			},

package/src/shared-tree-core/branch.ts

@@ -282,10 +282,11 @@ export class SharedTreeBranch<TEditor extends ChangeFamilyEditor, TChange> {
 	 * Apply all the divergent changes on the given branch to this branch.
 	 *
 	 * @param branch - the branch to merge into this branch
-	 * @returns the net change to this branch and the commits that were added to this branch by the merge,
-	 * or undefined if nothing changed
+	 * @returns the commits that were added to this branch by the merge, or undefined if nothing changed
 	 */
-	public merge(branch: SharedTreeBranch<TEditor, TChange>): void {
+	public merge(
+		branch: SharedTreeBranch<TEditor, TChange>,
+	): { sourceCommits: GraphCommit<TChange>[] } | undefined {
 		this.assertNotDisposed();
 		branch.assertNotDisposed();
 
@@ -316,6 +317,7 @@ export class SharedTreeBranch<TEditor extends ChangeFamilyEditor, TChange> {
 		this.#events.emit("beforeChange", changeEvent);
 		this.head = rebaseResult.newSourceHead;
 		this.#events.emit("afterChange", changeEvent);
+		return { sourceCommits };
 	}
 
 	/** Rebase `branchHead` onto `onto`, but return undefined if nothing changed */

package/src/shared-tree-core/editManager.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { assert } from "@fluidframework/core-utils/internal";
+import { assert, fail } from "@fluidframework/core-utils/internal";
 import { createEmitter } from "@fluid-internal/client-utils";
 import type { SessionId } from "@fluidframework/id-compressor";
 import { BTree } from "@tylerbu/sorted-btree-es6";
@@ -16,11 +16,10 @@ import {
 	findAncestor,
 	findCommonAncestor,
 	mintCommit,
-	rebaseChange,
 	type RebaseStatsWithDuration,
 	tagChange,
 } from "../core/index.js";
-import { type Mutable, brand, fail, getOrCreate, mapIterable } from "../util/index.js";
+import { type Mutable, brand, getOrCreate, mapIterable } from "../util/index.js";
 
 import { SharedTreeBranch, type BranchTrimmingEvents, onForkTransitive } from "./branch.js";
 import type {
@@ -39,7 +38,6 @@ import {
 } from "./sequenceIdUtils.js";
 import {
 	TelemetryEventBatcher,
-	measure,
 	type ITelemetryLoggerExt,
 } from "@fluidframework/telemetry-utils/internal";
 
@@ -706,51 +704,45 @@ export class EditManager<
 		}
 
 		// Remote changes, i.e., changes from remote clients are applied in three steps.
-		for (const newCommit of newCommits) {
-			// Step 1 - Recreate the peer remote client's local environment.
-			// Get the revision that the remote change is based on
-			const [, baseRevisionInTrunk] = this.getClosestTrunkCommit(referenceSequenceNumber);
-			// Rebase that peer local branch over the part of the trunk up to the base revision
-			// This will be a no-op if the sending client has not advanced since the last time we received an edit from it
-			const peerLocalBranch = getOrCreate(
-				this.peerLocalBranches,
-				sessionId,
-				() =>
-					new SharedTreeBranch(baseRevisionInTrunk, this.changeFamily, this.mintRevisionTag),
-			);
-			peerLocalBranch.rebaseOnto(this.trunk, baseRevisionInTrunk);
+		// Step 1 - Recreate the peer remote client's local environment.
+		// Get the revision that the remote change is based on and rebase that peer local branch over the part of the
+		// trunk up to the base revision. This will be a no-op if the sending client has not advanced since the last
+		// time we received an edit from it
+		const [, baseRevisionInTrunk] = this.getClosestTrunkCommit(referenceSequenceNumber);
+		const peerLocalBranch = getOrCreate(
+			this.peerLocalBranches,
+			sessionId,
+			() => new SharedTreeBranch(baseRevisionInTrunk, this.changeFamily, this.mintRevisionTag),
+		);
+		peerLocalBranch.rebaseOnto(this.trunk, baseRevisionInTrunk);
 
-			// Step 2 - Append the change to the peer branch. Rebase the change to the tip of the trunk.
-			if (peerLocalBranch.getHead() === this.trunk.getHead()) {
-				// If the branch is fully caught up and empty after being rebased, then push to the trunk directly
+		// Step 2 - Append the changes to the peer branch and rebase the changes to the tip of the trunk.
+		if (peerLocalBranch.getHead() === this.trunk.getHead()) {
+			// If the peer local branch is fully caught up and empty (no changes relative to the trunk) after being
+			// rebased, then push changes to the trunk directly and update the peer branch to the trunk's head.
+			for (const newCommit of newCommits) {
 				this.pushCommitToTrunk(nextSequenceId, { ...newCommit, sessionId });
-				peerLocalBranch.setHead(this.trunk.getHead());
-			} else {
-				// Otherwise, rebase the change over the trunk and append it, and append the original change to the peer branch.
-				const { duration, output: newChangeFullyRebased } = measure(() =>
-					rebaseChange(
-						this.changeFamily.rebaser,
-						newCommit,
-						peerLocalBranch.getHead(),
-						this.trunk.getHead(),
-						this.mintRevisionTag,
-					),
-				);
-
-				this.telemetryEventBatcher?.accumulateAndLog({
-					duration,
-					...newChangeFullyRebased.telemetryProperties,
-				});
-
+				nextSequenceId = getNextSequenceId(nextSequenceId);
+			}
+			peerLocalBranch.setHead(this.trunk.getHead());
+		} else {
+			// Otherwise, push the changes to the peer local branch and merge the branch into the trunk.
+			for (const newCommit of newCommits) {
 				peerLocalBranch.apply(tagChange(newCommit.change, newCommit.revision));
-				this.pushCommitToTrunk(nextSequenceId, {
-					...newCommit,
-					sessionId,
-					change: newChangeFullyRebased.change,
-				});
 			}
-
-			nextSequenceId = getNextSequenceId(nextSequenceId);
+			const result = this.trunk.merge(peerLocalBranch);
+			if (result !== undefined) {
+				// If the merge resulted in any changes to the trunk, update the sequence map and trunk metadata
+				// with the rebased commits.
+				for (const sourceCommit of result.sourceCommits) {
+					this.sequenceMap.set(nextSequenceId, sourceCommit);
+					this.trunkMetadata.set(sourceCommit.revision, {
+						sequenceId: nextSequenceId,
+						sessionId,
+					});
+					nextSequenceId = getNextSequenceId(nextSequenceId);
+				}
+			}
 		}
 
 		// Step 3 - Rebase the local branch over the updated trunk.

package/src/sharedTreeAttributes.ts

@@ -0,0 +1,25 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import type { IChannelAttributes } from "@fluidframework/datastore-definitions/internal";
+import { pkgVersion } from "./packageVersion.js";
+
+/**
+ * {@inheritDoc @fluidframework/shared-object-base#ISharedObjectFactory."type"}
+ * @alpha
+ * @legacy
+ */
+export const SharedTreeFactoryType = "https://graph.microsoft.com/types/tree";
+
+/**
+ * {@inheritDoc @fluidframework/shared-object-base#ISharedObjectFactory.attributes}
+ * @alpha
+ * @legacy
+ */
+export const SharedTreeAttributes: IChannelAttributes = {
+	type: SharedTreeFactoryType,
+	snapshotFormatVersion: "0.0.0",
+	packageVersion: pkgVersion,
+};

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

@@ -8,7 +8,12 @@ import type { IFluidHandle } from "@fluidframework/core-interfaces";
 import type { ITreeCursor } from "../../core/index.js";
 import type { TreeLeafValue, ImplicitAllowedTypes } from "../schemaTypes.js";
 import type { TreeNodeSchema } from "../core/index.js";
-import { customFromCursor, type EncodeOptions } from "./customTree.js";
+import {
+	customFromCursor,
+	replaceHandles,
+	type EncodeOptions,
+	type HandleConverter,
+} from "./customTree.js";
 import { getUnhydratedContext } from "../createContext.js";
 
 /**
@@ -36,12 +41,12 @@ export type ConciseTree<THandle = IFluidHandle> =
 /**
  * Used to read a node cursor as a ConciseTree.
  */
-export function conciseFromCursor<TCustom>(
+export function conciseFromCursor(
 	reader: ITreeCursor,
 	rootSchema: ImplicitAllowedTypes,
-	options: EncodeOptions<TCustom>,
-): ConciseTree<TCustom> {
-	const config: Required<EncodeOptions<TCustom>> = {
+	options: EncodeOptions,
+): ConciseTree {
+	const config: Required<EncodeOptions> = {
 		useStoredKeys: false,
 		...options,
 	};
@@ -50,10 +55,22 @@ export function conciseFromCursor<TCustom>(
 	return conciseFromCursorInner(reader, config, schemaMap);
 }
 
-function conciseFromCursorInner<TCustom>(
+function conciseFromCursorInner(
 	reader: ITreeCursor,
-	options: Required<EncodeOptions<TCustom>>,
+	options: Required<EncodeOptions>,
 	schema: ReadonlyMap<string, TreeNodeSchema>,
-): ConciseTree<TCustom> {
+): ConciseTree {
 	return customFromCursor(reader, options, schema, conciseFromCursorInner);
 }
+
+/**
+ * Clones tree, replacing any handles.
+ * @remarks A strongly typed version of {@link replaceHandles}.
+ * @alpha
+ */
+export function replaceConciseTreeHandles<T>(
+	tree: ConciseTree,
+	replacer: HandleConverter<T>,
+): ConciseTree<T> {
+	return replaceHandles(tree, replacer) as ConciseTree<T>;
+}

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

@@ -26,7 +26,7 @@ import {
 	defaultSchemaPolicy,
 	FieldKinds,
 	mapTreeFromCursor,
-	type NodeKeyManager,
+	type NodeIdentifierManager,
 } from "../../feature-libraries/index.js";
 import { isFieldInSchema } from "../../feature-libraries/index.js";
 import { toStoredSchema } from "../toStoredSchema.js";
@@ -53,7 +53,7 @@ export function createFromInsertable<
 		? ImplicitFieldSchema
 		: TSchema & ImplicitFieldSchema,
 	data: InsertableField<TSchema>,
-	context?: NodeKeyManager | undefined,
+	context?: NodeIdentifierManager | undefined,
 ): Unhydrated<
 	TSchema extends ImplicitFieldSchema
 		? TreeFieldFromImplicitField<TSchema>
@@ -84,7 +84,7 @@ export function cursorFromInsertable<
 		? ImplicitFieldSchema
 		: TSchema & ImplicitFieldSchema,
 	data: InsertableField<TSchema>,
-	context?: NodeKeyManager | undefined,
+	context?: NodeIdentifierManager | undefined,
 ):
 	| ITreeCursorSynchronous
 	| (TSchema extends FieldSchema<FieldKind.Optional> ? undefined : never) {