@fluidframework/tree 2.90.0-378676 → 2.91.0

package/src/shared-tree/treeCheckout.ts

@@ -53,32 +53,25 @@ import {
 	type TreeNodeSchemaIdentifier,
 	type TreeNodeStoredSchema,
 	LeafNodeStoredSchema,
-	type ChangeAtomId,
-	offsetChangeAtomId,
 	diffHistories,
 	type ChangeMetadata,
+	type LabelTree,
+	type TransactionLabels,
 	type ChangeEncodingContext,
 	type ReadOnlyDetachedFieldIndex,
 	makeAnonChange,
 	type TaggedChange,
-	type EditorOptions,
 } from "../core/index.js";
 import {
-	type DetachedRootIds,
-	type DetachedRootLocation,
-	type DetachedRootsLocation,
 	type FieldBatchCodec,
-	type Locator,
 	type TreeCompressionStrategy,
 	allowsRepoSuperset,
 	buildForest,
-	changeAtomFromDetachedNodeId,
 	createNodeIdentifierManager,
 	defaultSchemaPolicy,
+	fieldBatchCodecBuilder,
 	intoDelta,
 	jsonableTreeFromCursor,
-	makeFieldBatchCodec,
-	nodeIdFromChangeAtom,
 } from "../feature-libraries/index.js";
 import {
 	SquashingTransactionStack,
@@ -107,7 +100,6 @@ import {
 	disposeSymbol,
 	getOrCreate,
 	hasSome,
-	makeArray,
 	type JsonCompatibleReadOnly,
 	type WithBreakable,
 } from "../util/index.js";
@@ -116,12 +108,37 @@ import { getCheckout, SchematizingSimpleTreeView } from "./schematizingTreeView.
 import { SharedTreeChangeEnricher } from "./sharedTreeChangeEnricher.js";
 import { SharedTreeChangeFamily, hasSchemaChange } from "./sharedTreeChangeFamily.js";
 import type { SharedTreeChange } from "./sharedTreeChangeTypes.js";
-import {
-	LocationBasedSharedTreeEditBuilder,
-	type IIdBasedSharedTreeEditor,
-	type ILocationBasedSharedTreeEditor,
-	type IdBasedSharedTreeEditBuilder,
-} from "./sharedTreeEditBuilder.js";
+import type { ISharedTreeEditor, SharedTreeEditBuilder } from "./sharedTreeEditBuilder.js";
+
+/**
+ * Yields all defined (non-`undefined`) labels from a {@link LabelTree}, depth-first.
+ */
+function* collectTreeLabels(node: LabelTree): IterableIterator<unknown> {
+	if (node.label !== undefined) {
+		yield node.label;
+	}
+	for (const child of node.sublabels) {
+		yield* collectTreeLabels(child);
+	}
+}
+
+/**
+ * Builds the labels set for a change event from the label tree.
+ * If the tree exists and contains at least one defined label, returns a set of all
+ * values with the tree attached. Otherwise returns an empty set.
+ */
+function buildLabelsSet(labelTreeNode: LabelTree | undefined): TransactionLabels {
+	const set: Set<unknown> & { tree?: LabelTree } = new Set<unknown>();
+	if (labelTreeNode !== undefined) {
+		for (const value of collectTreeLabels(labelTreeNode)) {
+			set.add(value);
+		}
+		if (set.size > 0) {
+			set.tree = labelTreeNode;
+		}
+	}
+	return set;
+}
 
 /**
  * Events for {@link ITreeCheckout}.
@@ -254,7 +271,7 @@ export interface ITreeCheckout extends AnchorLocator, ViewableTree, WithBreakabl
 	 * Used to edit the state of the tree. Edits will be immediately applied locally to the tree.
 	 * If there is no transaction currently ongoing, then the edits will be submitted to Fluid immediately as well.
 	 */
-	readonly editor: ILocationBasedSharedTreeEditor;
+	readonly editor: ISharedTreeEditor;
 
 	/**
 	 * A collection of functions for managing transactions.
@@ -311,10 +328,9 @@ export function createTreeCheckout(
 	idCompressor: IIdCompressor,
 	mintRevisionTag: () => RevisionTag,
 	revisionTagCodec: RevisionTagCodec,
-	editorOptions: EditorOptions,
 	args?: {
-		branch?: SharedTreeBranch<IdBasedSharedTreeEditBuilder, SharedTreeChange>;
-		changeFamily?: ChangeFamily<IdBasedSharedTreeEditBuilder, SharedTreeChange>;
+		branch?: SharedTreeBranch<SharedTreeEditBuilder, SharedTreeChange>;
+		changeFamily?: ChangeFamily<SharedTreeEditBuilder, SharedTreeChange>;
 		schema?: TreeStoredSchemaRepository;
 		forest?: IEditableForest;
 		fieldBatchCodec?: FieldBatchCodec;
@@ -338,7 +354,7 @@ export function createTreeCheckout(
 		args?.changeFamily ??
 		new SharedTreeChangeFamily(
 			revisionTagCodec,
-			args?.fieldBatchCodec ?? makeFieldBatchCodec(codecOptions),
+			args?.fieldBatchCodec ?? fieldBatchCodecBuilder.build(codecOptions),
 			codecOptions,
 			args?.chunkCompressionStrategy,
 			idCompressor,
@@ -366,7 +382,6 @@ export function createTreeCheckout(
 		mintRevisionTag,
 		revisionTagCodec,
 		idCompressor,
-		editorOptions,
 		args?.removedRoots,
 		args?.logger,
 		breaker,
@@ -404,15 +419,24 @@ export class TreeCheckout implements ITreeCheckoutFork {
 	public disposed = false;
 
 	private editLock: EditLock;
-	private readonly locator: Locator;
 
 	/**
-	 * User-defined label associated with the transaction whose commit is currently being produced for this checkout.
+	 * Root of the mutable label tree tracking transaction nesting.
 	 *
 	 * @remarks
-	 * This label is used to implement {@link TreeCheckout.runWithTransactionLabel}.
+	 * The label tree is always isomorphic to the actual transaction tree — every transaction
+	 * (whether labeled or not) gets its own node. To find the "current" (deepest open) node,
+	 * walk down the right side of the tree, stopping at {@link TreeCheckout.mostRecentlyClosedLabelNode}.
+	 *
+	 * Cleared by {@link TreeCheckout.runWithTransactionLabel} after the commit event is emitted.
+	 */
+	private labelTreeNode: LabelTree | undefined;
+
+	/**
+	 * Points to the most recently closed (committed) label node.
+	 * Used by {@link TreeCheckout.currentLabelNode} to stop descending past committed nodes.
 	 */
-	private transactionLabel?: unknown;
+	private mostRecentlyClosedLabelNode: LabelTree | undefined;
 
 	private readonly views = new Set<TreeView<ImplicitFieldSchema>>();
 
@@ -428,7 +452,7 @@ export class TreeCheckout implements ITreeCheckoutFork {
 	 */
 	private readonly revertibleCommitBranches = new Map<
 		RevisionTag,
-		SharedTreeBranch<IdBasedSharedTreeEditBuilder, SharedTreeChange>
+		SharedTreeBranch<SharedTreeEditBuilder, SharedTreeChange>
 	>();
 
 	/**
@@ -441,19 +465,15 @@ export class TreeCheckout implements ITreeCheckoutFork {
 	public events: Listenable<CheckoutEvents> = this.#events;
 
 	public constructor(
-		branch: SharedTreeBranch<IdBasedSharedTreeEditBuilder, SharedTreeChange>,
+		branch: SharedTreeBranch<SharedTreeEditBuilder, SharedTreeChange>,
 		/** True if and only if this checkout is for a branch which is persisted and shared with other clients. */
 		public readonly isSharedBranch: boolean,
-		private readonly changeFamily: ChangeFamily<
-			IdBasedSharedTreeEditBuilder,
-			SharedTreeChange
-		>,
+		private readonly changeFamily: ChangeFamily<SharedTreeEditBuilder, SharedTreeChange>,
 		public readonly storedSchema: TreeStoredSchemaRepository,
 		public readonly forest: IEditableForest,
 		private readonly mintRevisionTag: () => RevisionTag,
 		private readonly revisionTagCodec: RevisionTagCodec,
 		private readonly idCompressor: IIdCompressor,
-		public readonly editorOptions: EditorOptions,
 		private readonly _removedRoots: DetachedFieldIndex = makeDetachedFieldIndex(
 			"repair",
 			revisionTagCodec,
@@ -466,37 +486,85 @@ export class TreeCheckout implements ITreeCheckoutFork {
 	) {
 		this.#transaction = this.createTransactionStack(branch);
 		this.editLock = new EditLock(this.#transaction.activeBranchEditor);
-		this.locator = {
-			locationFromId: (id: ChangeAtomId): DetachedRootLocation => {
-				const rootId = this.removedRoots.getEntry(nodeIdFromChangeAtom(id));
-				return this.removedRoots.toFieldKey(rootId);
-			},
-			idFromLocation: (location: DetachedRootLocation): ChangeAtomId => {
-				const nodeId = this.removedRoots.fromFieldKey(location);
-				return changeAtomFromDetachedNodeId(nodeId);
-			},
-			locationsFromIdRanges: (ids: DetachedRootIds): DetachedRootsLocation => {
-				return ids.flatMap((id) => {
-					return makeArray(id.count, (offset) => {
-						const field = this.locator.locationFromId(offsetChangeAtomId(id.first, offset));
-						return { field, count: 1 };
-					});
-				});
-			},
-			idRangesFromLocations: (ids: DetachedRootsLocation): DetachedRootIds => {
-				return ids.map((id) => {
-					assert(id.count === 1, "Expected count of 1");
-					const first = this.locator.idFromLocation(id.field);
-					return { first, count: id.count };
-				});
-			},
-			isAttachable: (id: ChangeAtomId): boolean | undefined => {
-				return this.removedRoots.isAttachable(nodeIdFromChangeAtom(id));
-			},
-		};
 		this.registerForBranchEvents();
 	}
 
+	/**
+	 * Pushes a new label node for a transaction nesting level.
+	 *
+	 * @param label - The label for this transaction level.
+	 *
+	 * @remarks
+	 * Called at the start of each transaction (including nested ones).
+	 * Creates a new {@link LabelTree} node as a child of the current deepest node (if any),
+	 * or as the root if this is the outermost transaction.
+	 */
+	public pushLabelFrame(label: unknown): void {
+		const node: LabelTree = { label, sublabels: [] };
+		if (this.labelTreeNode === undefined) {
+			this.labelTreeNode = node;
+		} else {
+			const current = this.currentLabelNode();
+			assert(current !== undefined, 0xcdb /* Expected current label node to exist */);
+			current.sublabels.push(node);
+		}
+	}
+
+	/**
+	 * Returns the deepest open node on the right side of the label tree, which corresponds
+	 * to the current (most recently pushed, not yet committed or aborted) transaction.
+	 * Returns `undefined` when {@link TreeCheckout.labelTreeNode} is not set.
+	 */
+	private currentLabelNode(): LabelTree | undefined {
+		if (this.labelTreeNode === undefined) {
+			return undefined;
+		}
+		// Walk down the right spine of the tree. Only one closed node is ever reachable
+		// during this traversal, so a single pointer (mostRecentlyClosedLabelNode) suffices
+		// to stop descending past committed nodes.
+		let node: LabelTree = this.labelTreeNode;
+		while (node.sublabels.length > 0) {
+			const lastChild = node.sublabels[node.sublabels.length - 1];
+			assert(lastChild !== undefined, 0xcdc /* Expected label tree node to have children */);
+			if (lastChild === this.mostRecentlyClosedLabelNode) {
+				break;
+			}
+			node = lastChild;
+		}
+		return node;
+	}
+
+	/**
+	 * Pops the current label frame from the label tree.
+	 * @param aborted - If true, the node is removed from the tree (transaction was aborted).
+	 * If false, the node is kept in the tree but marked as closed (transaction was committed).
+	 */
+	public popLabelFrame(aborted: boolean): void {
+		const node = this.currentLabelNode();
+		if (node === undefined) {
+			return;
+		}
+
+		if (aborted) {
+			if (node === this.labelTreeNode) {
+				this.labelTreeNode = undefined;
+				this.mostRecentlyClosedLabelNode = undefined;
+			} else {
+				// Temporarily mark node as closed so currentLabelNode() returns its parent.
+				this.mostRecentlyClosedLabelNode = node;
+				const parent = this.currentLabelNode();
+				assert(parent !== undefined, 0xcdd /* Expected parent label node to exist */);
+				parent.sublabels.pop();
+				// Point to the parent's new last child (guaranteed closed if it exists),
+				// or undefined if the parent has no more children.
+				const newLastChild = parent.sublabels[parent.sublabels.length - 1];
+				this.mostRecentlyClosedLabelNode = newLastChild;
+			}
+		} else {
+			this.mostRecentlyClosedLabelNode = node;
+		}
+	}
+
 	/**
 	 * Helper method for {@link SchematizingSimpleTreeView.runTransaction} to properly clear transaction labels once the function completes.
 	 *
@@ -513,15 +581,16 @@ export class TreeCheckout implements ITreeCheckoutFork {
 		fn: (label?: TLabel) => TResult,
 		label: TLabel | undefined,
 	): TResult {
-		// If a transaction label is already set, nesting is occurring, so we should not override it.
-		if (this.transactionLabel !== undefined) {
-			return fn(this.transactionLabel as TLabel);
-		}
-		this.transactionLabel = label;
 		try {
-			return fn(this.transactionLabel as TLabel);
+			return fn(label);
 		} finally {
-			this.transactionLabel = undefined;
+			// Only clear the label tree when the outermost transaction has completed.
+			// Inner transactions' commits don't fire the "changed" event, so the label tree
+			// must remain intact until the outermost commit reads it.
+			if (this.transaction.size === 0) {
+				this.labelTreeNode = undefined;
+				this.mostRecentlyClosedLabelNode = undefined;
+			}
 		}
 	}
 
@@ -542,8 +611,8 @@ export class TreeCheckout implements ITreeCheckoutFork {
 	}
 
 	private createTransactionStack(
-		branch: SharedTreeBranch<IdBasedSharedTreeEditBuilder, SharedTreeChange>,
-	): SquashingTransactionStack<IdBasedSharedTreeEditBuilder, SharedTreeChange> {
+		branch: SharedTreeBranch<SharedTreeEditBuilder, SharedTreeChange>,
+	): SquashingTransactionStack<SharedTreeEditBuilder, SharedTreeChange> {
 		return new SquashingTransactionStack(branch, this.mintRevisionTag, () => {
 			const disposeForks = this.disposeForksAfterTransaction
 				? trackForksForDisposal(this)
@@ -564,7 +633,7 @@ export class TreeCheckout implements ITreeCheckoutFork {
 						if (viewUpdate !== undefined) {
 							this.applyChange(viewUpdate, newHead.revision);
 						}
-						if (!this.transaction.isInProgress()) {
+						if (this.transaction.size === 0) {
 							// The changes in a transaction squash commit have already applied to the checkout and are known to be valid, so we can validate the squash commit automatically.
 							this.validateCommit(newHead);
 						}
@@ -661,7 +730,8 @@ export class TreeCheckout implements ITreeCheckoutFork {
 						} satisfies SerializedChange;
 					},
 					getRevertible: (onDisposed) => getRevertible?.(onDisposed),
-					label: this.transactionLabel,
+					label: this.labelTreeNode?.label,
+					labels: buildLabelsSet(this.labelTreeNode),
 				};
 
 				this.#events.emit("changed", metadata, getRevertible);
@@ -672,6 +742,7 @@ export class TreeCheckout implements ITreeCheckoutFork {
 			this.#events.emit("changed", {
 				isLocal: false,
 				kind: CommitKind.Default,
+				labels: new Set<unknown>(),
 			});
 		}
 	};
@@ -715,7 +786,8 @@ export class TreeCheckout implements ITreeCheckoutFork {
 			revision,
 		};
 		const decodedChange = this.changeFamily.codecs.resolve(4).decode(change, context);
-		this.applyChange(decodedChange, revision);
+		// Apply the change to the branch, but _not_ the `activeBranch` - we do not support squashing serialized commits in a transaction.
+		this.#transaction.branch.apply(tagChange(decodedChange, revision));
 	}
 
 	// Revision is the revision of the commit, if any, which caused this change.
@@ -890,13 +962,9 @@ export class TreeCheckout implements ITreeCheckoutFork {
 		return this.forest.anchors.events;
 	}
 
-	public get editor(): ILocationBasedSharedTreeEditor {
+	public get editor(): ISharedTreeEditor {
 		this.checkNotDisposed();
-		return new LocationBasedSharedTreeEditBuilder(
-			this.editLock.editor,
-			this.locator,
-			this.editorOptions,
-		);
+		return this.editLock.editor;
 	}
 
 	public locate(anchor: Anchor): AnchorNode | undefined {
@@ -917,19 +985,18 @@ export class TreeCheckout implements ITreeCheckoutFork {
 	 * To avoid updating observers of the view state with intermediate results during a transaction,
 	 * use {@link ITreeCheckout#branch} and {@link ISharedTreeFork#merge}.
 	 */
-	#transaction: SquashingTransactionStack<IdBasedSharedTreeEditBuilder, SharedTreeChange>;
+	#transaction: SquashingTransactionStack<SharedTreeEditBuilder, SharedTreeChange>;
 
 	public branch(): TreeCheckout {
 		this.checkNotDisposed(
 			"The parent branch has already been disposed and can no longer create new branches.",
 		);
-		this.editLock.checkUnlocked("Branching");
-
 		// Branching after an unfinished transaction would expose the application to a state where its invariants may be violated.
-		if (this.transaction.isInProgress()) {
+		if (this.transaction.size > 0) {
 			throw new UsageError("A view cannot be forked while it has a pending transaction.");
 		}
 
+		this.editLock.checkUnlocked("Branching");
 		const anchors = new AnchorSet();
 		const branch = this.#transaction.activeBranch.fork();
 		const storedSchema = this.storedSchema.clone();
@@ -943,7 +1010,6 @@ export class TreeCheckout implements ITreeCheckoutFork {
 			this.mintRevisionTag,
 			this.revisionTagCodec,
 			this.idCompressor,
-			this.editorOptions,
 			this._removedRoots.clone(),
 			this.logger,
 			this.breaker,
@@ -954,11 +1020,11 @@ export class TreeCheckout implements ITreeCheckoutFork {
 	}
 
 	public switchBranch(
-		branch: SharedTreeBranch<IdBasedSharedTreeEditBuilder, SharedTreeChange>,
+		branch: SharedTreeBranch<SharedTreeEditBuilder, SharedTreeChange>,
 	): void {
 		// TODO: Dispose old branch, if necessary
 		assert(
-			!this.#transaction.isInProgress(),
+			this.#transaction.size === 0,
 			0xc55 /* Cannot switch branches during a transaction */,
 		);
 		const diff = diffHistories(
@@ -988,12 +1054,12 @@ export class TreeCheckout implements ITreeCheckoutFork {
 		);
 		this.editLock.checkUnlocked("Rebasing");
 
-		if (this.transaction.isInProgress()) {
+		if (this.transaction.size > 0) {
 			throw new UsageError(
 				"Views cannot be rebased onto a view that has a pending transaction.",
 			);
 		}
-		if (checkout.transaction.isInProgress()) {
+		if (checkout.transaction.size > 0) {
 			throw new UsageError("A view cannot be rebased while it has a pending transaction.");
 		}
 
@@ -1022,12 +1088,12 @@ export class TreeCheckout implements ITreeCheckoutFork {
 			"The source of the branch merge has been disposed and cannot be merged.",
 		);
 		this.editLock.checkUnlocked("Merging");
-		if (this.transaction.isInProgress()) {
+		if (this.transaction.size > 0) {
 			throw new UsageError(
 				"Views cannot be merged into a view while it has a pending transaction.",
 			);
 		}
-		if (checkout.transaction.isInProgress()) {
+		if (checkout.transaction.size > 0) {
 			throw new UsageError(
 				"Views with an open transaction cannot be merged into another view.",
 			);
@@ -1113,7 +1179,7 @@ export class TreeCheckout implements ITreeCheckoutFork {
 
 	private revertRevertible(revision: RevisionTag, kind: CommitKind): RevertMetrics {
 		this.editLock.checkUnlocked("Reverting a commit");
-		if (this.transaction.isInProgress()) {
+		if (this.transaction.size > 0) {
 			throw new UsageError("Undo is not yet supported during transactions.");
 		}
 
@@ -1320,7 +1386,7 @@ export class TreeCheckout implements ITreeCheckoutFork {
 		return enriched;
 	}
 
-	public get mainBranch(): SharedTreeBranch<IdBasedSharedTreeEditBuilder, SharedTreeChange> {
+	public get mainBranch(): SharedTreeBranch<SharedTreeEditBuilder, SharedTreeChange> {
 		return this.#transaction.branch;
 	}
 
@@ -1335,23 +1401,19 @@ class EditLock {
 	 * Edits the tree by calling the methods of the editor passed into the {@link EditLock} constructor.
 	 * @remarks Edits will throw an error if the lock is currently locked.
 	 */
-	public readonly editor: IIdBasedSharedTreeEditor;
+	public readonly editor: ISharedTreeEditor;
 	private locked = false;
 
 	/**
 	 * @param editor - an editor which will be used to create a new editor that is monitored to determine if any changes are happening to the tree.
 	 * Use {@link EditLock.editor} in place of the original editor to ensure that changes are monitored.
 	 */
-	public constructor(editor: IIdBasedSharedTreeEditor) {
+	public constructor(editor: ISharedTreeEditor) {
 		const checkLock = (): void => this.checkUnlocked("Editing the tree");
 		this.editor = {
 			get schema() {
 				return editor.schema;
 			},
-			buildRoots(unhydrated) {
-				checkLock();
-				return editor.buildRoots(unhydrated);
-			},
 			valueField(...fieldArgs) {
 				const valueField = editor.valueField(...fieldArgs);
 				return {
@@ -1359,10 +1421,6 @@ class EditLock {
 						checkLock();
 						valueField.set(...editArgs);
 					},
-					attach(...editArgs) {
-						checkLock();
-						valueField.attach(...editArgs);
-					},
 				};
 			},
 			optionalField(...fieldArgs) {
@@ -1372,14 +1430,6 @@ class EditLock {
 						checkLock();
 						optionalField.set(...editArgs);
 					},
-					attach(...editArgs) {
-						checkLock();
-						optionalField.attach(...editArgs);
-					},
-					clear(...editArgs) {
-						checkLock();
-						optionalField.clear(...editArgs);
-					},
 				};
 			},
 			sequenceField(...fieldArgs) {
@@ -1389,10 +1439,6 @@ class EditLock {
 						checkLock();
 						sequenceField.insert(...editArgs);
 					},
-					attach(...editArgs) {
-						checkLock();
-						sequenceField.attach(...editArgs);
-					},
 					remove(...editArgs) {
 						checkLock();
 						sequenceField.remove(...editArgs);

package/src/shared-tree/unhydratedTreeContext.ts

@@ -0,0 +1,87 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { UsageError } from "@fluidframework/telemetry-utils/internal";
+
+import type {
+	TreeContextAlpha,
+	TreeBranchAlpha,
+	RunTransactionParams,
+	TransactionResult,
+	TransactionResultExt,
+	WithValue,
+} from "../simple-tree/index.js";
+
+import { assertValidConstraint } from "./schematizingTreeView.js";
+
+/**
+ * A {@link TreeContextAlpha | tree context} that can be used for e.g. unhydrated nodes.
+ */
+export class UnhydratedTreeContext implements TreeContextAlpha {
+	public static instance = new UnhydratedTreeContext();
+	private transactionCount = 0;
+	private constructor() {}
+
+	public isBranch(): this is TreeBranchAlpha {
+		return false;
+	}
+
+	public runTransaction<TValue>(
+		t: () => WithValue<TValue>,
+		params?: RunTransactionParams,
+	): TransactionResultExt<TValue, TValue>;
+	public runTransaction(t: () => void, _params?: RunTransactionParams): TransactionResult;
+	public runTransaction(
+		t: () => WithValue<unknown> | void,
+		params?: RunTransactionParams,
+	): TransactionResultExt<unknown, unknown> | TransactionResult {
+		for (const constraint of params?.preconditions ?? []) {
+			assertValidConstraint(constraint, false);
+		}
+		this.transactionCount += 1;
+		try {
+			return UnhydratedTreeContext.wrapTransactionResult(t());
+		} finally {
+			this.transactionCount -= 1;
+		}
+	}
+
+	public runTransactionAsync<TValue>(
+		t: () => Promise<WithValue<TValue>>,
+		params?: RunTransactionParams,
+	): Promise<TransactionResultExt<TValue, TValue>>;
+	public runTransactionAsync(
+		t: () => Promise<void>,
+		params?: RunTransactionParams,
+	): Promise<TransactionResult>;
+	public async runTransactionAsync(
+		t: () => Promise<WithValue<unknown> | void>,
+		params?: RunTransactionParams,
+	): Promise<TransactionResultExt<unknown, unknown> | TransactionResult> {
+		if (this.transactionCount > 0) {
+			throw new UsageError(
+				"An asynchronous transaction cannot be started while another transaction is already in progress.",
+			);
+		}
+		for (const constraint of params?.preconditions ?? []) {
+			assertValidConstraint(constraint, false);
+		}
+		this.transactionCount += 1;
+		try {
+			return UnhydratedTreeContext.wrapTransactionResult(await t());
+		} finally {
+			this.transactionCount -= 1;
+		}
+	}
+
+	private static wrapTransactionResult<TValue>(
+		value: WithValue<TValue> | void,
+	): TransactionResultExt<TValue, TValue> | TransactionResult {
+		if (value?.value !== undefined) {
+			return { success: true, value: value.value };
+		}
+		return { success: true };
+	}
+}

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

@@ -26,7 +26,6 @@ import {
 	rebaseBranch,
 	tagRollbackInverse,
 	type RebaseStatsWithDuration,
-	type EditorOptions,
 } from "../core/index.js";
 import { hasSome, defineLazyCachedProperty } from "../util/index.js";
 
@@ -130,12 +129,9 @@ export class SharedTreeBranch<TEditor extends ChangeFamilyEditor, TChange> {
 		private readonly telemetryEventBatcher?: TelemetryEventBatcher<
 			keyof RebaseStatsWithDuration
 		>,
-		private readonly editorOptions?: EditorOptions,
 	) {
-		this.editor = this.changeFamily.buildEditor(
-			mintRevisionTag,
-			(change) => this.apply(change),
-			this.editorOptions,
+		this.editor = this.changeFamily.buildEditor(mintRevisionTag, (change) =>
+			this.apply(change),
 		);
 		this.unsubscribeBranchTrimmer = branchTrimmer?.on("ancestryTrimmed", (commit) => {
 			this.#events.emit("ancestryTrimmed", commit);
@@ -205,8 +201,6 @@ export class SharedTreeBranch<TEditor extends ChangeFamilyEditor, TChange> {
 			this.changeFamily,
 			mintRevisionTag,
 			this.branchTrimmer,
-			undefined,
-			this.editorOptions,
 		);
 		this.#events.emit("fork", fork);
 		return fork;