@fluidframework/tree 2.10.0 → 2.11.0

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

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { assert, oob } from "@fluidframework/core-utils/internal";
+import { assert } from "@fluidframework/core-utils/internal";
 import { type TelemetryEventBatcher, measure } from "@fluidframework/telemetry-utils/internal";
 
 import {
@@ -21,10 +21,10 @@ import {
 	tagRollbackInverse,
 	type RebaseStatsWithDuration,
 } from "../core/index.js";
-import { createEmitter, type Listenable } from "../events/index.js";
+import type { Listenable } from "@fluidframework/core-interfaces";
+import { createEmitter } from "@fluid-internal/client-utils";
 
-import { TransactionStack } from "./transactionStack.js";
-import { fail } from "../util/index.js";
+import { hasSome } from "../util/index.js";
 
 /**
  * Describes a change to a `SharedTreeBranch`. Various operations can mutate the head of the branch;
@@ -46,12 +46,12 @@ export type SharedTreeBranchChange<TChange> =
 			type: "append";
 			kind: CommitKind;
 			change: TaggedChange<TChange>;
-			newCommits: readonly GraphCommit<TChange>[];
+			newCommits: readonly [GraphCommit<TChange>, ...GraphCommit<TChange>[]];
 	  }
 	| {
 			type: "remove";
 			change: TaggedChange<TChange> | undefined;
-			removedCommits: readonly GraphCommit<TChange>[];
+			removedCommits: readonly [GraphCommit<TChange>, ...GraphCommit<TChange>[]];
 	  }
 	| {
 			type: "replace";
@@ -125,34 +125,6 @@ export interface SharedTreeBranchEvents<TEditor extends ChangeFamilyEditor, TCha
 	 * Fired after this branch is disposed
 	 */
 	dispose(): void;
-
-	/**
-	 * Fired after a new transaction is started.
-	 * @param isOuterTransaction - true iff the transaction being started is the outermost transaction
-	 * as opposed to a nested transaction.
-	 */
-	transactionStarted(isOuterTransaction: boolean): void;
-
-	/**
-	 * Fired after the current transaction is aborted.
-	 * @param isOuterTransaction - true iff the transaction being aborted is the outermost transaction
-	 * as opposed to a nested transaction.
-	 */
-	transactionAborted(isOuterTransaction: boolean): void;
-
-	/**
-	 * Fired after the current transaction is completely rolled back.
-	 * @param isOuterTransaction - true iff the transaction being aborted is the outermost transaction
-	 * as opposed to a nested transaction.
-	 */
-	transactionRolledBack(isOuterTransaction: boolean): void;
-
-	/**
-	 * Fired after the current transaction is committed.
-	 * @param isOuterTransaction - true iff the transaction being committed is the outermost transaction
-	 * as opposed to a nested transaction.
-	 */
-	transactionCommitted(isOuterTransaction: boolean): void;
 }
 
 /**
@@ -179,30 +151,6 @@ export class SharedTreeBranch<TEditor extends ChangeFamilyEditor, TChange> {
 	readonly #events = createEmitter<SharedTreeBranchEvents<TEditor, TChange>>();
 	public readonly events: Listenable<SharedTreeBranchEvents<TEditor, TChange>> = this.#events;
 	public readonly editor: TEditor;
-	private readonly transactions = new TransactionStack();
-	/**
-	 * After pushing a starting revision to the transaction stack, this branch might be rebased
-	 * over commits which are children of that starting revision. When the transaction is committed,
-	 * those rebased-over commits should not be included in the transaction's squash commit, even though
-	 * they exist between the starting revision and the final commit within the transaction.
-	 *
-	 * Whenever `rebaseOnto` is called during a transaction, this map is augmented with an entry from the
-	 * original merge-base to the new merge-base.
-	 *
-	 * This state need only be retained for the lifetime of the transaction.
-	 *
-	 * TODO: This strategy might need to be revisited when adding better support for async transactions.
-	 * Since:
-	 *
-	 * 1. Transactionality is guaranteed primarily by squashing at commit time
-	 * 2. Branches may be rebased with an ongoing transaction
-	 *
-	 * a rebase operation might invalidate only a portion of a transaction's commits, thus defeating the
-	 * purpose of transactionality.
-	 *
-	 * AB#6483 and children items track this work.
-	 */
-	private readonly initialTransactionRevToRebasedRev = new Map<RevisionTag, RevisionTag>();
 	private disposed = false;
 	private readonly unsubscribeBranchTrimmer?: () => void;
 	/**
@@ -230,11 +178,12 @@ export class SharedTreeBranch<TEditor extends ChangeFamilyEditor, TChange> {
 	}
 
 	/**
-	 * Sets the head of this branch. Emits no change events.
+	 * Sets the head of this branch.
+	 * @remarks This is a "manual override" of sorts, for when the branch needs to be set to a certain state without going through the usual flow of edits.
+	 * This might be necessary as a performance optimization, or to prevent parts of the system updating incorrectly (this method emits no change events!).
 	 */
 	public setHead(head: GraphCommit<TChange>): void {
 		this.assertNotDisposed();
-		assert(!this.isTransacting(), 0x685 /* Cannot set head during a transaction */);
 		this.head = head;
 	}
 
@@ -278,147 +227,6 @@ export class SharedTreeBranch<TEditor extends ChangeFamilyEditor, TChange> {
 		return this.head;
 	}
 
-	/**
-	 * Begin a transaction on this branch. If the transaction is committed via {@link commitTransaction},
-	 * all commits made since this call will be squashed into a single head commit.
-	 */
-	public startTransaction(): void {
-		this.assertNotDisposed();
-		const forks = new Set<SharedTreeBranch<TEditor, TChange>>();
-		const onDisposeUnSubscribes: (() => void)[] = [];
-		const onForkUnSubscribe = onForkTransitive(this, (fork) => {
-			forks.add(fork);
-			onDisposeUnSubscribes.push(fork.events.on("dispose", () => forks.delete(fork)));
-		});
-		this.transactions.push(this.head.revision, () => {
-			forks.forEach((fork) => fork.dispose());
-			onDisposeUnSubscribes.forEach((unsubscribe) => unsubscribe());
-			onForkUnSubscribe();
-		});
-		this.editor.enterTransaction();
-		this.#events.emit("transactionStarted", this.transactions.size === 1);
-	}
-
-	/**
-	 * Commit the current transaction. There must be a transaction in progress that was begun via {@link startTransaction}.
-	 * If there are commits in the current transaction, they will be squashed into a new single head commit.
-	 * @returns the commits that were squashed and the new squash commit if a squash occurred, otherwise `undefined`.
-	 * @remarks If the transaction had no changes applied during its lifetime, then no squash occurs (i.e. this method is a no-op).
-	 * Even if the transaction contained only one change, it will still be replaced with an (equivalent) squash change.
-	 */
-	public commitTransaction():
-		| [squashedCommits: GraphCommit<TChange>[], newCommit: GraphCommit<TChange>]
-		| undefined {
-		this.assertNotDisposed();
-		const [startCommit, commits] = this.popTransaction();
-		this.editor.exitTransaction();
-
-		this.#events.emit("transactionCommitted", this.transactions.size === 0);
-		if (commits.length === 0) {
-			return undefined;
-		}
-
-		// Squash the changes and make the squash commit the new head of this branch
-		const squashedChange = this.changeFamily.rebaser.compose(commits);
-		const revision = this.mintRevisionTag();
-
-		const newHead = mintCommit(startCommit, {
-			revision,
-			change: this.changeFamily.rebaser.changeRevision(squashedChange, revision),
-		});
-
-		const changeEvent = {
-			type: "replace",
-			change: undefined,
-			removedCommits: commits,
-			newCommits: [newHead],
-		} as const;
-
-		this.#events.emit("beforeChange", changeEvent);
-		this.head = newHead;
-		this.#events.emit("afterChange", changeEvent);
-		return [commits, newHead];
-	}
-
-	/**
-	 * Cancel the current transaction. There must be a transaction in progress that was begun via
-	 * {@link startTransaction}. All commits made during the transaction will be removed.
-	 * @returns the change to this branch resulting in the removal of the commits, and a list of the
-	 * commits that were removed.
-	 */
-	public abortTransaction(): [
-		change: TChange | undefined,
-		abortedCommits: GraphCommit<TChange>[],
-	] {
-		this.assertNotDisposed();
-		const [startCommit, commits] = this.popTransaction();
-		this.editor.exitTransaction();
-
-		this.#events.emit("transactionAborted", this.transactions.size === 0);
-		if (commits.length === 0) {
-			this.#events.emit("transactionRolledBack", this.transactions.size === 0);
-			return [undefined, []];
-		}
-
-		const inverses: TaggedChange<TChange>[] = [];
-		for (let i = commits.length - 1; i >= 0; i--) {
-			const revision = this.mintRevisionTag();
-			const commit =
-				commits[i] ?? fail("This wont run because we are iterating through commits");
-			const inverse = this.changeFamily.rebaser.changeRevision(
-				this.changeFamily.rebaser.invert(commit, true, revision),
-				revision,
-				commit.revision,
-			);
-
-			inverses.push(tagRollbackInverse(inverse, revision, commit.revision));
-		}
-		const change =
-			inverses.length > 0 ? this.changeFamily.rebaser.compose(inverses) : undefined;
-
-		const changeEvent = {
-			type: "remove",
-			change: change === undefined ? undefined : makeAnonChange(change),
-			removedCommits: commits,
-		} as const;
-
-		this.#events.emit("beforeChange", changeEvent);
-		this.head = startCommit;
-		this.#events.emit("afterChange", changeEvent);
-		this.#events.emit("transactionRolledBack", this.transactions.size === 0);
-		return [change, commits];
-	}
-
-	/**
-	 * True iff this branch is in the middle of a transaction that was begin via {@link startTransaction}
-	 */
-	public isTransacting(): boolean {
-		return this.transactions.size !== 0;
-	}
-
-	private popTransaction(): [GraphCommit<TChange>, GraphCommit<TChange>[]] {
-		const { startRevision: startRevisionOriginal } = this.transactions.pop();
-		let startRevision = startRevisionOriginal;
-		while (this.initialTransactionRevToRebasedRev.has(startRevision)) {
-			startRevision = this.initialTransactionRevToRebasedRev.get(startRevision) ?? oob();
-		}
-
-		if (!this.isTransacting()) {
-			this.initialTransactionRevToRebasedRev.clear();
-		}
-
-		const commits: GraphCommit<TChange>[] = [];
-		const startCommit = findAncestor(
-			[this.head, commits],
-			(c) => c.revision === startRevision,
-		);
-		assert(
-			startCommit !== undefined,
-			0x593 /* Expected branch to be ahead of transaction start revision */,
-		);
-		return [startCommit, commits];
-	}
-
 	/**
 	 * Spawn a new branch that is based off of the current state of this branch.
 	 * @param commit - The commit to base the new branch off of. Defaults to the head of this branch.
@@ -460,17 +268,9 @@ export class SharedTreeBranch<TEditor extends ChangeFamilyEditor, TChange> {
 		// The net change to this branch is provided by the `rebaseBranch` API
 		const { newSourceHead, commits } = rebaseResult;
 		const { deletedSourceCommits, targetCommits, sourceCommits } = commits;
+		assert(hasSome(targetCommits), 0xa83 /* Expected commit(s) for a non no-op rebase */);
 
 		const newCommits = targetCommits.concat(sourceCommits);
-		if (this.isTransacting()) {
-			const firstCommit = targetCommits[0] ?? oob();
-			const lastCommit = targetCommits[targetCommits.length - 1] ?? oob();
-			const src = firstCommit.parent?.revision;
-			const dst = lastCommit.revision;
-			if (src !== undefined && dst !== undefined) {
-				this.initialTransactionRevToRebasedRev.set(src, dst);
-			}
-		}
 		const changeEvent = {
 			type: "replace",
 			get change() {
@@ -487,6 +287,87 @@ export class SharedTreeBranch<TEditor extends ChangeFamilyEditor, TChange> {
 		return rebaseResult;
 	}
 
+	/**
+	 * Remove a range of commits from this branch.
+	 * @param commit - All commits after (but not including) this commit will be removed.
+	 * @returns The net change to this branch and the commits that were removed from this branch.
+	 */
+	public removeAfter(
+		commit: GraphCommit<TChange>,
+	): [change: TaggedChange<TChange> | undefined, removedCommits: GraphCommit<TChange>[]] {
+		if (commit === this.head) {
+			return [undefined, []];
+		}
+
+		const removedCommits: GraphCommit<TChange>[] = [];
+		const inverses: TaggedChange<TChange>[] = [];
+		findAncestor([this.head, removedCommits], (c) => {
+			// TODO: Pull this side effect out if/when more diverse ancestry walking helpers are available
+			if (c !== commit) {
+				const revision = this.mintRevisionTag();
+				const inverse = this.changeFamily.rebaser.changeRevision(
+					this.changeFamily.rebaser.invert(c, true, revision),
+					revision,
+					c.revision,
+				);
+
+				inverses.push(tagRollbackInverse(inverse, revision, c.revision));
+				return false;
+			}
+
+			return true;
+		});
+		assert(hasSome(removedCommits), 0xa84 /* Commit must be in the branch's ancestry */);
+
+		const change = makeAnonChange(this.changeFamily.rebaser.compose(inverses));
+		const changeEvent = {
+			type: "remove",
+			change,
+			removedCommits,
+		} as const;
+
+		this.#events.emit("beforeChange", changeEvent);
+		this.head = commit;
+		this.#events.emit("afterChange", changeEvent);
+		return [change, removedCommits];
+	}
+
+	/**
+	 * Replace a range of commits on this branch with a single commit composed of equivalent changes.
+	 * @param commit - All commits after (but not including) this commit will be squashed.
+	 * @returns The commits that were squashed and removed from this branch.
+	 * @remarks The commits after `commit` will be removed from this branch, and the squash commit will become the new head of this branch.
+	 * The change event emitted by this operation will have a `change` property that is undefined, since no net change occurred.
+	 */
+	public squashAfter(commit: GraphCommit<TChange>): GraphCommit<TChange>[] {
+		if (commit === this.head) {
+			return [];
+		}
+
+		const removedCommits: GraphCommit<TChange>[] = [];
+		findAncestor([this.head, removedCommits], (c) => c === commit);
+		assert(hasSome(removedCommits), 0xa85 /* Commit must be in the branch's ancestry */);
+
+		const squashedChange = this.changeFamily.rebaser.compose(removedCommits);
+		const revision = this.mintRevisionTag();
+		const newHead = mintCommit(commit, {
+			revision,
+			change: this.changeFamily.rebaser.changeRevision(squashedChange, revision),
+		});
+
+		const changeEvent = {
+			type: "replace",
+			change: undefined,
+			removedCommits,
+			newCommits: [newHead],
+		} as const;
+
+		this.#events.emit("beforeChange", changeEvent);
+		this.head = newHead;
+		this.#events.emit("afterChange", changeEvent);
+		return removedCommits;
+	}
+
 	/**
 	 * Apply all the divergent changes on the given branch to this branch.
 	 *
@@ -499,10 +380,6 @@ export class SharedTreeBranch<TEditor extends ChangeFamilyEditor, TChange> {
 	): [change: TChange, newCommits: GraphCommit<TChange>[]] | undefined {
 		this.assertNotDisposed();
 		branch.assertNotDisposed();
-		assert(
-			!branch.isTransacting(),
-			0x597 /* Branch may not be merged while transaction is in progress */,
-		);
 
 		if (branch === this) {
 			return undefined;
@@ -516,6 +393,7 @@ export class SharedTreeBranch<TEditor extends ChangeFamilyEditor, TChange> {
 
 		// Compute the net change to this branch
 		const sourceCommits = rebaseResult.commits.sourceCommits;
+		assert(hasSome(sourceCommits), 0xa86 /* Expected source commits in non no-op merge */);
 		const change = this.changeFamily.rebaser.compose(sourceCommits);
 		const taggedChange = makeAnonChange(change);
 		const changeEvent = {
@@ -576,10 +454,6 @@ export class SharedTreeBranch<TEditor extends ChangeFamilyEditor, TChange> {
 			return;
 		}
 
-		while (this.isTransacting()) {
-			this.abortTransaction();
-		}
-
 		this.unsubscribeBranchTrimmer?.();
 
 		this.disposed = true;
@@ -600,8 +474,7 @@ export class SharedTreeBranch<TEditor extends ChangeFamilyEditor, TChange> {
  * The deregister function has undefined behavior if called more than once.
  */
 // Branches are invariant over TChange
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function onForkTransitive<T extends SharedTreeBranch<ChangeFamilyEditor, any>>(
+export function onForkTransitive<T extends { events: Listenable<{ fork(t: T): void }> }>(
 	branch: T,
 	onFork: (fork: T) => void,
 ): () => void {

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

@@ -4,106 +4,111 @@
  */
 
 import { assert } from "@fluidframework/core-utils/internal";
-import { type ChangeRebaser, type GraphCommit, replaceChange } from "../core/index.js";
+import {
+	type ChangeRebaser,
+	type GraphCommit,
+	replaceChange,
+	type RevisionTag,
+} from "../core/index.js";
 import type { ChangeEnricherReadonlyCheckout } from "./changeEnricher.js";
 import { TransactionEnricher } from "./transactionEnricher.js";
+import { getChangeReplaceType, type SharedTreeBranchChange } from "./branch.js";
 
 /**
  * Utility for enriching commits from a {@link Branch} before these commits are applied and submitted.
  */
 export class BranchCommitEnricher<TChange> {
-	private readonly transactionEnricher: TransactionEnricher<TChange>;
-	private readonly enricher: ChangeEnricherReadonlyCheckout<TChange>;
+	readonly #transactionEnricher: TransactionEnricher<TChange>;
+	readonly #enricher: ChangeEnricherReadonlyCheckout<TChange>;
 	/**
 	 * Maps each local commit to the corresponding enriched commit.
-	 * Entries are added when the commits are prepared (before being applied and submitted).
-	 * Entries are removed when the commits are retrieved for submission (after being applied).
-	 * It's possible an entry will linger in the map indefinitely if it is never retrieved for submission.
-	 * This would happen if applying a commit were to fail and the commit were not retrieved/purged after the failure.
+	 * @remarks
+	 * Entries are added when the commits are {@link BranchCommitEnricher.processChange | processed during a change}.
+	 * Each entry is removed when it is {@link BranchCommitEnricher.enrich | retrieved}.
+	 * In the event that an entry is not explicitly removed, it will eventually be {@link WeakMap | dropped from memory} along with the associated commit.
 	 */
-	private readonly preparedCommits: Map<GraphCommit<TChange>, GraphCommit<TChange>> =
-		new Map();
+	readonly #preparedCommits: WeakMap<GraphCommit<TChange>, GraphCommit<TChange>> = new Map();
+
+	/**
+	 * If defined, a top-level transaction has been {@link BranchCommitEnricher.commitTransaction | committed} since the last {@link BranchCommitEnricher.processChange | change has been processed}.
+	 * Calling this function will compute the composition of that transaction's commits.
+	 * @remarks This function will be reset to undefined after each {@link BranchCommitEnricher.processChange | change is processed}.
+	 */
+	#getOuterTransactionChange?: (revision: RevisionTag) => TChange;
 
 	public constructor(
 		rebaser: ChangeRebaser<TChange>,
 		enricher: ChangeEnricherReadonlyCheckout<TChange>,
 	) {
-		this.enricher = enricher;
-		this.transactionEnricher = new TransactionEnricher(rebaser, this.enricher);
+		this.#enricher = enricher;
+		this.#transactionEnricher = new TransactionEnricher(rebaser, this.#enricher);
 	}
 
 	/**
-	 * @returns The number of commits that have been prepared but not yet retrieved.
+	 * Process the given change, preparing new commits for {@link BranchCommitEnricher.enrich | enrichment}.
+	 * @param change - The change to process.
+	 * @param isAttached - Whether or not the SharedTree is attached to the service.
 	 */
-	public get preparedCommitsCount(): number {
-		return this.preparedCommits.size;
-	}
-
-	public startNewTransaction(): void {
-		this.transactionEnricher.startNewTransaction();
-	}
+	public processChange(change: SharedTreeBranchChange<TChange>): void {
+		if (this.#transactionEnricher.isTransacting()) {
+			if (change.type === "append") {
+				for (const commit of change.newCommits) {
+					// We do not submit ops for changes that are part of a transaction.
+					// But we need to enrich the commits that will be sent if the transaction is committed.
+					this.#transactionEnricher.addTransactionStep(commit);
+				}
+			}
+		} else {
+			if (
+				change.type === "append" ||
+				(change.type === "replace" && getChangeReplaceType(change) === "transactionCommit")
+			) {
+				for (const newCommit of change.newCommits) {
+					const newChange =
+						this.#getOuterTransactionChange?.(newCommit.revision) ??
+						this.#enricher.updateChangeEnrichments(newCommit.change, newCommit.revision);
 
-	public commitCurrentTransaction(): void {
-		this.transactionEnricher.commitCurrentTransaction();
-	}
+					this.#preparedCommits.set(newCommit, replaceChange(newCommit, newChange));
+				}
+			}
+		}
 
-	public abortCurrentTransaction(): void {
-		this.transactionEnricher.abortCurrentTransaction();
+		this.#getOuterTransactionChange = undefined;
 	}
 
 	/**
-	 * Adds a commit to the enricher.
-	 * @param commit - A commit that is part of a transaction.
+	 * Retrieves the enriched version of the given commit.
+	 * @param commit - A commit {@link BranchCommitEnricher.processChange | processed during the most recent change}.
+	 * @remarks A commit can only be enriched once - subsequent calls to this method with the same commit will throw an error.
 	 */
-	public ingestTransactionCommit(commit: GraphCommit<TChange>): void {
-		// We do not submit ops for changes that are part of a transaction.
-		// But we need to enrich the commits that will be sent if the transaction is committed.
-		this.transactionEnricher.addTransactionStep(commit);
+	public enrich(commit: GraphCommit<TChange>): GraphCommit<TChange> {
+		const prepared = this.#preparedCommits.get(commit);
+		assert(prepared !== undefined, 0x980 /* Unknown commit */);
+		this.#preparedCommits.delete(commit);
+		return prepared;
 	}
 
 	/**
-	 * Prepares an enriched commit for later submission (see {@link BranchCommitEnricher.getPreparedCommit}).
-	 * @param commit - The commit to prepare an enriched version of.
-	 * @param concludesOuterTransaction - Whether the commit concludes an outer transaction.
-	 *
-	 * Each call to this method must be followed by a call to {@link BranchCommitEnricher.getPreparedCommit} or
-	 * {@link BranchCommitEnricher.purgePreparedCommits}. Failing to do so will result in a memory leak.
+	 * Notify the enricher that a new transaction has started.
+	 * @remarks This may be called multiple times without calling {@link BranchCommitEnricher.commitTransaction | commitTransaction}, producing "nested transactions".
 	 */
-	public prepareCommit(
-		commit: GraphCommit<TChange>,
-		concludesOuterTransaction: boolean,
-	): void {
-		let enrichedChange: TChange;
-		if (concludesOuterTransaction) {
-			assert(
-				this.transactionEnricher !== undefined,
-				0x97f /* Unexpected transaction commit without transaction steps */,
-			);
-			enrichedChange = this.transactionEnricher.getComposedChange(commit.revision);
-		} else {
-			enrichedChange = this.enricher.updateChangeEnrichments(commit.change, commit.revision);
-		}
-		this.preparedCommits.set(commit, replaceChange(commit, enrichedChange));
+	public startTransaction(): void {
+		this.#transactionEnricher.startTransaction();
 	}
 
 	/**
-	 * @param commit - A commit previously passed to {@link BranchCommitEnricher.prepareCommit}.
-	 * @returns The enriched commit corresponds to the given commit.
+	 * Commit the current transaction.
+	 * @remarks This should be called _before_ the corresponding transaction commit change is {@link BranchCommitEnricher.processChange | processed}.
 	 */
-	public getPreparedCommit(commit: GraphCommit<TChange>): GraphCommit<TChange> {
-		const prepared = this.preparedCommits.get(commit);
-		assert(prepared !== undefined, 0x980 /* Unknown commit */);
-		this.preparedCommits.delete(commit);
-		return prepared;
+	public commitTransaction(): void {
+		this.#getOuterTransactionChange = this.#transactionEnricher.commitTransaction();
 	}
 
 	/**
-	 * Purges all commits that have been prepared but not been retrieved.
-	 * This should be called to avoid memory leaks if the prepared commits are no longer needed.
-	 *
-	 * Does not affect ingested transaction commits.
+	 * Notify the enricher that the current transaction has been aborted.
+	 * @remarks This will throw an error if there is no ongoing transaction.
 	 */
-	public purgePreparedCommits(): void {
-		this.preparedCommits.clear();
+	public abortTransaction(): void {
+		this.#transactionEnricher.abortTransaction();
 	}
 }

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

@@ -5,7 +5,7 @@
 
 import { assert, oob } from "@fluidframework/core-utils/internal";
 import type { GraphCommit, TaggedChange } from "../core/index.js";
-import { disposeSymbol } from "../util/index.js";
+import { disposeSymbol, hasSome } from "../util/index.js";
 import type { ChangeEnricherReadonlyCheckout, ResubmitMachine } from "./index.js";
 
 /**
@@ -114,7 +114,8 @@ export class DefaultResubmitMachine<TChange> implements ResubmitMachine<TChange>
 			this.isInResubmitPhase,
 			0x982 /* No available commit to resubmit outside of resubmit phase */,
 		);
-		return this.resubmitQueue[0] ?? oob();
+		assert(hasSome(this.resubmitQueue), 0xa87 /* Expected resubmit queue to be non-empty */);
+		return this.resubmitQueue[0];
 	}
 
 	public get isInResubmitPhase(): boolean {

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

@@ -4,6 +4,7 @@
  */
 
 import { assert } 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";
 
@@ -41,7 +42,6 @@ import {
 	minSequenceId,
 	sequenceIdComparator,
 } from "./sequenceIdUtils.js";
-import { createEmitter } from "../events/index.js";
 import {
 	TelemetryEventBatcher,
 	measure,

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

@@ -11,6 +11,15 @@ export {
 	getChangeReplaceType,
 } from "./branch.js";
 
+export {
+	TransactionResult,
+	type Transactor,
+	type TransactionEvents,
+	TransactionStack,
+	type OnPush,
+	type OnPop,
+} from "./transaction.js";
+
 export {
 	type ExplicitCoreCodecVersions,
 	SharedTreeCore,
@@ -28,8 +37,6 @@ export {
 	NoOpChangeEnricher,
 } from "./changeEnricher.js";
 
-export { TransactionStack } from "./transactionStack.js";
-
 export { makeEditManagerCodec } from "./editManagerCodecs.js";
 export { EditManagerSummarizer } from "./editManagerSummarizer.js";
 export {