@fluidframework/tree 2.81.1 → 2.82.0

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

@@ -9,13 +9,17 @@ import { assert, unreachableCase } from "@fluidframework/core-utils/internal";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 
 import {
+	diffHistories,
 	findAncestor,
+	findCommonAncestor,
+	mintCommit,
+	rebaseBranch,
 	tagChange,
 	type ChangeFamilyEditor,
 	type GraphCommit,
 	type RevisionTag,
 } from "../core/index.js";
-import { getLast, getOrCreate, hasSome } from "../util/index.js";
+import { getLast, getOrCreate } from "../util/index.js";
 
 import type { SharedTreeBranch, SharedTreeBranchEvents } from "./branch.js";
 
@@ -42,6 +46,8 @@ export interface Transactor {
 	 * Start a new transaction.
 	 * If a transaction is already in progress when this new transaction starts, then this transaction will be "nested" inside of it,
 	 * i.e. the outer transaction will still be in progress after this new transaction is committed or aborted.
+	 * @param isAsync - Whether the transaction is asynchronous.
+	 * An error will be thrown if an asynchronous transaction is started while a synchronous transaction is in progress.
 	 *
 	 * @remarks Asynchronous transactions are not supported on the root checkout,
 	 * since it is always kept up-to-date with the latest remote edits and the results of this rebasing (which might invalidate
@@ -55,7 +61,7 @@ export interface Transactor {
 	 * @privateRemarks There is currently no enforcement that asynchronous transactions don't happen on the root checkout.
 	 * AB#6488 tracks adding some enforcement to make it more clear to application authors that this is not supported.
 	 */
-	start(): void;
+	start(isAsync: boolean): void;
 	/**
 	 * Close this transaction by squashing its edits and committing them as a single edit.
 	 * If this is the root checkout and there are no ongoing transactions remaining, the squashed edit will be submitted to Fluid.
@@ -126,12 +132,22 @@ export type OnPush = () => Callbacks | void;
  */
 export type OnPop = (result: TransactionResult) => void;
 
+/**
+ * A frame in the transaction stack.
+ */
+interface TransactionStackFrame {
+	/** The callbacks provided when this transaction frame was pushed onto the stack. */
+	readonly callbacks: Callbacks;
+	/** Whether this transaction frame is asynchronous. */
+	readonly isAsync: boolean;
+}
+
 /**
  * An implementation of {@link Transactor} that uses a stack to manage transactions.
  * @remarks Using a stack allows transactions to nest - i.e. an inner transaction may be started while an outer transaction is already in progress.
  */
 export class TransactionStack implements Transactor, IDisposable {
-	readonly #stack: Callbacks[] = [];
+	readonly #stack: TransactionStackFrame[] = [];
 	readonly #onPush?: OnPush;
 
 	readonly #events = createEmitter<TransactionEvents>();
@@ -157,11 +173,20 @@ export class TransactionStack implements Transactor, IDisposable {
 		return this.#stack.length > 0;
 	}
 
-	public start(): void {
+	public start(isAsync: boolean): void {
 		this.ensureNotDisposed();
-		const onPushCurrent = hasSome(this.#stack) ? getLast(this.#stack).onPush : this.#onPush;
+		const last = getLast(this.#stack);
+		if (last !== undefined && !last.isAsync && isAsync) {
+			throw new UsageError(
+				"An asynchronous transaction cannot be started while a synchronous transaction is in progress.",
+			);
+		}
+		const onPushCurrent = last === undefined ? this.#onPush : last.callbacks.onPush;
 		const { onPush, onPop } = onPushCurrent?.() ?? {};
-		this.#stack.push({ onPop, onPush: onPush ?? onPushCurrent });
+		this.#stack.push({
+			callbacks: { onPop, onPush: onPush ?? onPushCurrent },
+			isAsync,
+		});
 		this.#events.emit("started");
 	}
 
@@ -171,7 +196,7 @@ export class TransactionStack implements Transactor, IDisposable {
 			throw new UsageError("No transaction to commit");
 		}
 		this.#events.emit("committing");
-		this.#stack.pop()?.onPop?.(TransactionResult.Commit);
+		this.#stack.pop()?.callbacks.onPop?.(TransactionResult.Commit);
 	}
 
 	public abort(): void {
@@ -180,7 +205,7 @@ export class TransactionStack implements Transactor, IDisposable {
 			throw new UsageError("No transaction to abort");
 		}
 		this.#events.emit("aborting");
-		this.#stack.pop()?.onPop?.(TransactionResult.Abort);
+		this.#stack.pop()?.callbacks.onPop?.(TransactionResult.Abort);
 	}
 
 	public dispose(): void {
@@ -198,6 +223,19 @@ export class TransactionStack implements Transactor, IDisposable {
 	}
 }
 
+/**
+ * A function that will be called when a transaction is popped from the {@link SquashingTransactionStack | stack}.
+ * @remarks This function runs just after the transaction ends, so if this is the end of an outermost (not nested) transaction then {@link Transactor.isInProgress} will be false during its execution.
+ * @param result - The result of the transaction.
+ * @param viewUpdate - The change that needs to be applied to the view to keep it up-to-date with the branch after the transaction ends.
+ * This is needed in asynchronous transactions where new commits have been added to the branch while the transaction was in progress.
+ * This will be `undefined` if no such change is necessary.
+ */
+export type OnPopWithViewUpdate<TChange> = (
+	result: TransactionResult,
+	viewUpdate: TChange | undefined,
+) => void;
+
 /**
  * An implementation of {@link Transactor} that {@link TransactionStack | uses a stack} and a {@link SharedTreeBranch | branch} to manage transactions.
  * @remarks Given a branch, this class will fork the branch when a transaction begins and squash the forked branch back into the original branch when the transaction ends.
@@ -270,14 +308,14 @@ export class SquashingTransactionStack<
 	public constructor(
 		public readonly branch: SharedTreeBranch<TEditor, TChange>,
 		mintRevisionTag: () => RevisionTag,
-		onPush?: () => OnPop | void,
+		onPush?: () => OnPopWithViewUpdate<TChange> | void,
 	) {
 		super(
 			// Invoked when an outer transaction starts
 			(): Callbacks => {
 				// Keep track of the commit that each transaction was on when it started
-				// TODO:#8603: This may need to be computed differently if we allow rebasing during a transaction.
 				const startHead = this.activeBranch.getHead();
+				const rebaser = this.branch.changeFamily.rebaser;
 				const outerOnPop = onPush?.();
 				let transactionRevision: RevisionTag | undefined;
 				const transactionBranch = this.branch.fork(
@@ -287,33 +325,97 @@ export class SquashingTransactionStack<
 				);
 				this.setTransactionBranch(transactionBranch);
 				transactionBranch.editor.enterTransaction();
+
 				// Invoked when an outer transaction ends
 				const onOuterTransactionPop: OnPop = (result) => {
 					assert(!this.isInProgress(), 0xcae /* The outer transaction should be ending */);
 					transactionBranch.editor.exitTransaction();
+
+					const sourcePath: GraphCommit<TChange>[] = [];
+					const targetPath: GraphCommit<TChange>[] = [];
+					const ancestor = findCommonAncestor(
+						[startHead, sourcePath],
+						[branch.getHead(), targetPath],
+					);
+					assert(ancestor !== undefined, 0xcce /* branches must be related */);
+
+					const transactionSteps: GraphCommit<TChange>[] = [];
+					findAncestor(
+						[transactionBranch.getHead(), transactionSteps],
+						(c) => c === startHead,
+					);
+
+					let viewUpdate: TChange | undefined;
 					switch (result) {
 						case TransactionResult.Abort: {
-							// When a transaction is aborted, roll back all the transaction's changes on the current branch
+							// When a transaction is aborted, roll back all the transaction's changes on the current branch.
+							// It is important that this happens before and separately from updating the view because the `TreeCheckout` needs to
+							// revert some internal (state to match what it was before the transaction began) before applying the view update (if any).
 							transactionBranch.removeAfter(startHead);
+							// If changes were made on `branch` since the transaction began, the view will need to be updated to reflect those changes.
+							if (targetPath.length > 0) {
+								viewUpdate = diffHistories(
+									rebaser,
+									startHead,
+									this.branch.getHead(),
+									mintRevisionTag,
+								);
+							}
 							break;
 						}
 						case TransactionResult.Commit: {
-							// ...squash all the new commits on the transaction branch into a new commit on the original branch
-							const removedCommits: GraphCommit<TChange>[] = [];
-							findAncestor(
-								[transactionBranch.getHead(), removedCommits],
-								(c) => c === startHead,
-							);
-							if (removedCommits.length > 0) {
-								for (const commit of removedCommits) {
+							if (transactionSteps.length > 0) {
+								assert(
+									transactionRevision !== undefined,
+									0xccf /* Expected transaction revision in the presence of transaction steps */,
+								);
+								for (const commit of transactionSteps) {
 									assert(
 										commit.revision === transactionRevision,
 										0xcaf /* Unexpected commit in transaction */,
 									);
 								}
-								const squash = this.branch.changeFamily.rebaser.compose(removedCommits);
-								this.branch.apply(tagChange(squash, transactionRevision));
+								// Squash all the new commits on the transaction branch into a new commit on the original branch
+								const squash = rebaser.compose(transactionSteps);
+
+								if (targetPath.length === 0) {
+									// No changes were made on the original branch since the transaction began
+									// The transaction commit can be applied directly
+									this.branch.apply(tagChange(squash, transactionRevision));
+									// The view is already up-to-date so there's nothing more to do
+								} else {
+									// Some changes were made on `branch` since the transaction began
+									const unrebasedHead = mintCommit(startHead, {
+										change: squash,
+										revision: transactionRevision,
+									});
+									// We need to rebase the transaction commit on top of the new changes
+									const rebased = rebaseBranch(
+										mintRevisionTag,
+										rebaser,
+										unrebasedHead,
+										branch.getHead(),
+									);
+									assert(
+										rebased.newSourceHead.revision === transactionRevision,
+										0xcd0 /* The transaction commit should be rebased to the tip */,
+									);
+									this.branch.apply(rebased.newSourceHead);
+									viewUpdate = rebased.sourceChange;
+								}
+							} else {
+								if (targetPath.length > 0) {
+									// Changes were made on `branch` since the transaction began.
+									// The view will need to be updated to reflect those changes.
+									viewUpdate = diffHistories(
+										rebaser,
+										startHead,
+										this.branch.getHead(),
+										mintRevisionTag,
+									);
+								}
 							}
+
 							break;
 						}
 						default: {
@@ -322,7 +424,7 @@ export class SquashingTransactionStack<
 					}
 					transactionBranch.dispose();
 					this.setTransactionBranch(undefined);
-					outerOnPop?.(result);
+					outerOnPop?.(result, viewUpdate);
 				};
 				// Invoked when a nested transaction begins
 				const onNestedTransactionPush: OnPush = () => {
@@ -346,7 +448,7 @@ export class SquashingTransactionStack<
 									unreachableCase(result);
 								}
 							}
-							nestedOuterOnPop?.(result);
+							nestedOuterOnPop?.(result, undefined);
 						},
 					};
 				};

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

@@ -99,11 +99,12 @@ export abstract class VersionedSummarizer<TVersion extends number> implements Su
 	): Promise<void> {
 		let version: TVersion | undefined;
 		if (await services.contains(summarizablesMetadataKey)) {
-			const metadata = await readAndParseSnapshotBlob<SharedTreeSummarizableMetadata>(
+			const metadata = (await readAndParseSnapshotBlob(
 				summarizablesMetadataKey,
 				services,
 				(contents) => parse(contents),
-			);
+				// TODO: this type cast should use a codec to validate the data instead of just type casting.
+			)) as SharedTreeSummarizableMetadata;
 			version = metadata.version as TVersion;
 			if (!this.supportedVersions.has(version)) {
 				throw new UsageError(`Cannot read version ${version} of shared tree summary.`);

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

@@ -53,6 +53,7 @@ export {
 	adaptEnum,
 	enumFromStrings,
 	singletonSchema,
+	createCustomizedFluidFrameworkScopedFactory,
 } from "./schemaCreationUtilities.js";
 export {
 	getIdentifierFromNode,

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

@@ -17,6 +17,7 @@ import type {
 } from "../core/index.js";
 
 import type { SchemaFactory, ScopedSchemaName } from "./schemaFactory.js";
+import { SchemaFactoryBeta } from "./schemaFactoryBeta.js";
 
 /*
  * This file does two things:
@@ -247,9 +248,8 @@ export function enumFromStrings<
 	type MembersUnion = Members[number];
 
 	// Get all keys of the Members tuple which are numeric strings as union of numbers:
-	type Indexes = Extract<keyof Members, `${number}`> extends `${infer N extends number}`
-		? N
-		: never;
+	type Indexes =
+		Extract<keyof Members, `${number}`> extends `${infer N extends number}` ? N : never;
 
 	type TOut = {
 		[Index in Indexes as Members[Index]]: ReturnType<
@@ -298,11 +298,11 @@ function _enumFromStrings2<TScope extends string, const Members extends readonly
 	factory: SchemaFactory<TScope>,
 	members: Members,
 ) {
-	const enumObject: {
+	const enumObject = Object.create(null) as {
 		[key in keyof Members as Members[key] extends string
 			? Members[key]
 			: string]: Members[key] extends string ? Members[key] : string;
-	} = Object.create(null);
+	};
 	for (const name of members) {
 		Object.defineProperty(enumObject, name, {
 			enumerable: true,
@@ -314,3 +314,33 @@ function _enumFromStrings2<TScope extends string, const Members extends readonly
 
 	return adaptEnum(factory, enumObject);
 }
+
+function createCustomizedScopedFactory<
+	TUserScope extends string,
+	TCreatorDomain extends string,
+>(
+	inputSchemaFactory: SchemaFactoryBeta<TUserScope>,
+	creatorDomain: TCreatorDomain,
+): SchemaFactoryBeta<`${TCreatorDomain}<${TUserScope}>`> {
+	return new SchemaFactoryBeta(`${creatorDomain}<${inputSchemaFactory.scope}>`);
+}
+
+/**
+ * Declare a SchemaFactory for use in cases where the Fluid Framework's code creates the schema and owns its schema compatibility (and thus scope)
+ * but it is parameterized by user provided data, the `TUserScope`.
+ * @remarks
+ * This should allow future logic in {@link generateSchemaFromSimpleSchema} to recognize these schema as ones defined by Fluid Framework,
+ * and special case them to provide better APIs and maintain data invariants.
+ */
+export function createCustomizedFluidFrameworkScopedFactory<
+	TUserScope extends string,
+	TCreatorDomain extends string,
+>(
+	inputSchemaFactory: SchemaFactoryBeta<TUserScope>,
+	fluidDomainSuffix: TCreatorDomain,
+): SchemaFactoryBeta<`com.fluidframework.${TCreatorDomain}<${TUserScope}>`> {
+	return createCustomizedScopedFactory(
+		inputSchemaFactory,
+		`com.fluidframework.${fluidDomainSuffix}` as const,
+	);
+}

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

@@ -149,7 +149,7 @@ export function createSimpleTreeIndex<
 	isKeyValid: (key: TreeIndexKey) => key is TKey,
 	indexableSchema?: readonly TreeNodeSchema[],
 ): SimpleTreeIndex<TKey, TValue> {
-	const indexableSchemaMap = new Map();
+	const indexableSchemaMap = new Map<string, TreeNodeSchema>();
 	if (indexableSchema === undefined) {
 		walkFieldSchema(view.schema, {
 			node: (schemus) => indexableSchemaMap.set(schemus.identifier, schemus),

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

@@ -138,4 +138,14 @@ export interface RunTransactionParams {
 	 * this client and ignored by all other clients.
 	 */
 	readonly preconditions?: readonly TransactionConstraintAlpha[];
+	/**
+	 * A label for this transaction that allows it to be correlated with later edits (e.g. for controlling undo/redo grouping).
+	 *
+	 * @remarks
+	 * This label is associated with the commit produced by this transaction, and is surfaced through the
+	 * `label` property of {@link ChangeMetadata} in the `commitApplied` or `changed` event.
+	 *
+	 * If there is a nested transaction, only the outermost transaction label will be used.
+	 */
+	readonly label?: unknown;
 }

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

@@ -6,8 +6,8 @@
 import type { IFluidLoadable, IDisposable, Listenable } from "@fluidframework/core-interfaces";
 
 import type {
-	CommitMetadata,
 	ChangeMetadata,
+	CommitMetadata,
 	RevertibleAlphaFactory,
 	RevertibleFactory,
 } from "../../core/index.js";
@@ -211,7 +211,7 @@ export interface TreeBranchAlpha extends TreeBranch {
 	fork(): TreeBranchAlpha;
 
 	/**
-	 * Run a transaction which applies one or more edits to the tree as a single atomic unit.
+	 * Run a synchronous transaction which applies one or more edits to the tree as a single atomic unit.
 	 * @param transaction - The function to run as the body of the transaction.
 	 * It should return a status object of {@link TransactionCallbackStatus | TransactionCallbackStatus } type.
 	 * It includes a "rollback" property which may be returned as true at any point during the transaction. This will
@@ -236,19 +236,20 @@ export interface TreeBranchAlpha extends TreeBranch {
 	 * If the transaction is rolled back, a corresponding change event will also be emitted for the rollback.
 	 *
 	 * Nested transactions:
-	 * This API can be called from within the transaction callback of another runTransaction call. That will have slightly different behavior:
+	 * This API can be called from within the transaction callback of another `runTransaction` or `runTransactionAsync` call. That will have slightly different behavior:
 	 *
 	 * - If the inner transaction fails, only the inner transaction will be rolled back and the outer transaction will continue.
 	 * - Constraints will apply to the outermost transaction. Constraints are applied per commit and there will be one commit generated
 	 * for the outermost transaction which includes all inner transactions.
 	 * - Undo will undo the outermost transaction and all inner transactions.
+	 * - If a label is provided in the params, only the label for the outermost transaction will be used. All other labels will be ignored.
 	 */
 	runTransaction<TSuccessValue, TFailureValue>(
 		transaction: () => TransactionCallbackStatus<TSuccessValue, TFailureValue>,
 		params?: RunTransactionParams,
 	): TransactionResultExt<TSuccessValue, TFailureValue>;
 	/**
-	 * Run a transaction which applies one or more edits to the tree as a single atomic unit.
+	 * Run a synchronous transaction which applies one or more edits to the tree as a single atomic unit.
 	 * @param transaction - The function to run as the body of the transaction. It may return the following:
 	 *
 	 * - Nothing to indicate that the body of the transaction has successfully run.
@@ -273,7 +274,7 @@ export interface TreeBranchAlpha extends TreeBranch {
 	 * If the transaction is rolled back, a corresponding change event will also be emitted for the rollback.
 	 *
 	 * Nested transactions:
-	 * This API can be called from within the transaction callback of another runTransaction call. That will have slightly different behavior:
+	 * This API can be called from within the transaction callback of another `runTransaction` or `runTransactionAsync` call. That will have slightly different behavior:
 	 *
 	 * - If the inner transaction fails, only the inner transaction will be rolled back and the outer transaction will continue.
 	 * - Constraints will apply to the outermost transaction. Constraints are applied per commit and there will be one commit generated
@@ -285,6 +286,87 @@ export interface TreeBranchAlpha extends TreeBranch {
 		params?: RunTransactionParams,
 	): TransactionResult;
 
+	/**
+	 * Run an asynchronous transaction which applies one or more edits to the tree as a single atomic unit.
+	 * @param transaction - The function to run as the body of the transaction.
+	 * It should return a promise that resolves to a status object of {@link TransactionCallbackStatus | TransactionCallbackStatus } type.
+	 * It includes a "rollback" property which may be returned as true at any point during the transaction. This will
+	 * abort the transaction and discard any changes it made so far.
+	 * "rollback" can be set to false or left undefined to indicate that the body of the transaction has successfully run.
+	 * @param params - The optional parameters for the transaction. It includes the constraints that will be checked before the transaction begins.
+	 * @returns A promise that resolves to a result object of {@link TransactionResultExt | TransactionResultExt} type. It includes the following:
+	 *
+	 * - A "success" flag indicating whether the transaction was successful or not.
+	 * - The success or failure value as returned by the transaction function.
+	 *
+	 * The promise will reject if the constraints are not met or something unexpected happens.
+	 *
+	 * @remarks
+	 * As with synchronous transactions, using an asynchronous transaction has the following consequences:
+	 * - All of the changes in the transaction are treated as a unit, therefore no other changes (either from this client or from a remote client) can be interleaved with the transaction changes.
+	 * - If reverted (e.g. via an "undo" operation), all the changes in the transaction are reverted together.
+	 * - The internal data representation of a transaction with many changes is generally smaller and more efficient than that of the changes when separate.
+	 *
+	 * Unlike with synchronous transactions, using an asynchronous transaction has the following consequences:
+	 * - It is possible that other changes (either from this client by merging a branch or from a remote client) may be applied to the branch while this transaction is in progress.
+	 * These other changes will be not be reflected on the branch until after this transaction completes,
+	 * at which point the transaction changes will be applied after these other changes.
+	 *
+	 * Local change events will be emitted for each change as the transaction is being applied.
+	 * If the transaction is rolled back, a corresponding change event will also be emitted for the rollback.
+	 *
+	 * Nested transactions:
+	 * This API can be called from within the transaction callback of another `runTransactionAsync` call. That will have slightly different behavior:
+	 *
+	 * - If the inner transaction fails, only the inner transaction will be rolled back and the outer transaction will continue.
+	 * - Constraints will apply to the outermost transaction. Constraints are applied per commit and there will be one commit generated
+	 * for the outermost transaction which includes all inner transactions.
+	 * - Undo will undo the outermost transaction and all inner transactions.
+	 */
+	runTransactionAsync<TSuccessValue, TFailureValue>(
+		transaction: () => Promise<TransactionCallbackStatus<TSuccessValue, TFailureValue>>,
+		params?: RunTransactionParams,
+	): Promise<TransactionResultExt<TSuccessValue, TFailureValue>>;
+	/**
+	 * Run an asynchronous transaction which applies one or more edits to the tree as a single atomic unit.
+	 * @param transaction - The function to run as the body of the transaction. It must return a promise that can resolve to any of the following:
+	 *
+	 * - Nothing to indicate that the body of the transaction has successfully run.
+	 * - A status object of {@link VoidTransactionCallbackStatus | VoidTransactionCallbackStatus } type. It includes a "rollback" property which
+	 * may be returned as true at any point during the transaction. This will abort the transaction and discard any changes it made so
+	 * far. "rollback" can be set to false or left undefined to indicate that the body of the transaction has successfully run.
+	 *
+	 * @param params - The optional parameters for the transaction. It includes the constraints that will be checked before the transaction begins.
+	 * @returns A promise that resolves to a result object of {@link TransactionResult | TransactionResult} type. It includes a "success" flag indicating whether the
+	 * transaction was successful or not. The promise will reject if the constraints are not met or something unexpected happens.
+	 *
+	 * @remarks
+	 * As with synchronous transactions, using an asynchronous transaction has the following consequences:
+	 * - All of the changes in the transaction are treated as a unit, therefore no other changes (either from this client or from a remote client) can be interleaved with the transaction changes.
+	 * - If reverted (e.g. via an "undo" operation), all the changes in the transaction are reverted together.
+	 * - The internal data representation of a transaction with many changes is generally smaller and more efficient than that of the changes when separate.
+	 *
+	 * Unlike with synchronous transactions, using an asynchronous transaction has the following consequences:
+	 * - It is possible that other changes (either from this client by merging a branch or from a remote client) may be applied to the branch while this transaction is in progress.
+	 * These other changes will be not be reflected on the branch until after this transaction completes,
+	 * at which point the transaction changes will be applied after these other changes.
+	 *
+	 * Local change events will be emitted for each change as the transaction is being applied.
+	 * If the transaction is rolled back, a corresponding change event will also be emitted for the rollback.
+	 *
+	 * Nested transactions:
+	 * This API can be called from within the transaction callback of another `runTransactionAsync` call. That will have slightly different behavior:
+	 *
+	 * - If the inner transaction fails, only the inner transaction will be rolled back and the outer transaction will continue.
+	 * - Constraints will apply to the outermost transaction. Constraints are applied per commit and there will be one commit generated
+	 * for the outermost transaction which includes all inner transactions.
+	 * - Undo will undo the outermost transaction and all inner transactions.
+	 */
+	runTransactionAsync(
+		transaction: () => Promise<VoidTransactionCallbackStatus | void>,
+		params?: RunTransactionParams,
+	): Promise<TransactionResult>;
+
 	/**
 	 * Apply a serialized change to this branch.
 	 * @param change - the change to apply.
@@ -544,7 +626,7 @@ export interface TreeBranchEvents extends Omit<TreeViewEvents, "commitApplied">
 	 * @param getRevertible - a function provided that allows users to get a revertible for the commit that was applied. If not provided,
 	 * this commit is not revertible.
 	 */
-	commitApplied(data: CommitMetadata, getRevertible?: RevertibleAlphaFactory): void;
+	commitApplied(data: ChangeMetadata, getRevertible?: RevertibleAlphaFactory): void;
 }
 
 /**

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

@@ -575,15 +575,12 @@ export function isTreeNodeSchemaClass<
  * If a schema is both TreeNodeSchemaClass and TreeNodeSchemaNonClass, prefer TreeNodeSchemaClass since that includes subclasses properly.
  * @public
  */
-export type NodeFromSchema<T extends TreeNodeSchema> = T extends TreeNodeSchemaClass<
-	string,
-	NodeKind,
-	infer TNode
->
-	? TNode
-	: T extends TreeNodeSchemaNonClass<string, NodeKind, infer TNode>
+export type NodeFromSchema<T extends TreeNodeSchema> =
+	T extends TreeNodeSchemaClass<string, NodeKind, infer TNode>
 		? TNode
-		: never;
+		: T extends TreeNodeSchemaNonClass<string, NodeKind, infer TNode>
+			? TNode
+			: never;
 
 /**
  * Data which can be used as a node to be inserted.

package/src/simple-tree/index.ts

@@ -200,6 +200,7 @@ export {
 	checkSchemaCompatibilitySnapshots,
 	type SnapshotFileSystem,
 	type SchemaCompatibilitySnapshotsOptions,
+	createCustomizedFluidFrameworkScopedFactory,
 } from "./api/index.js";
 export type {
 	SimpleTreeSchema,
@@ -266,6 +267,8 @@ export {
 	type RecordNodePojoEmulationSchema,
 	RecordNodeSchema,
 	type TreeRecordNode,
+	type ArrayPlaceAnchor,
+	createArrayInsertionAnchor,
 } from "./node-kinds/index.js";
 export {
 	unhydratedFlexTreeFromInsertable,

package/src/simple-tree/leafNodeSchema.ts

@@ -7,7 +7,7 @@ import { assert } from "@fluidframework/core-utils/internal";
 import { isFluidHandle } from "@fluidframework/runtime-utils/internal";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 
-import { type TreeValue, ValueSchema } from "../core/index.js";
+import { type FieldKey, type TreeValue, ValueSchema } from "../core/index.js";
 import {
 	type FlexTreeNode,
 	isFlexTreeNode,
@@ -28,6 +28,7 @@ import {
 	type TreeNodeSchemaInitializedData,
 	CompatibilityLevel,
 	type FlexContent,
+	type UnhydratedFlexTreeField,
 } from "./core/index.js";
 import { getTreeNodeSchemaInitializedData } from "./createContext.js";
 import type { SimpleLeafNodeSchema } from "./simpleSchema.js";
@@ -185,7 +186,7 @@ export function leafToFlexContent(
 			value: mappedValue,
 			type: brand(mappedSchema.identifier),
 		},
-		new Map(),
+		new Map<FieldKey, UnhydratedFlexTreeField>(),
 	];
 
 	return result;