@fluidframework/tree 2.74.0 → 2.81.0-374083

package/src/shared-tree/treeCheckout.ts

@@ -11,7 +11,11 @@ import {
 	UsageError,
 	type ITelemetryLoggerExt,
 } from "@fluidframework/telemetry-utils/internal";
-import { FluidClientVersion, FormatValidatorNoOp } from "../codec/index.js";
+import {
+	FluidClientVersion,
+	FormatValidatorNoOp,
+	type CodecWriteOptions,
+} from "../codec/index.js";
 import {
 	type Anchor,
 	type AnchorLocator,
@@ -46,21 +50,29 @@ import {
 	type TreeNodeSchemaIdentifier,
 	type TreeNodeStoredSchema,
 	LeafNodeStoredSchema,
+	type ChangeAtomId,
+	offsetChangeAtomId,
 	diffHistories,
 	type ChangeMetadata,
 	type ChangeEncodingContext,
 	type ReadOnlyDetachedFieldIndex,
 } from "../core/index.js";
 import {
+	type DetachedRootIds,
+	type DetachedRootLocation,
+	type DetachedRootsLocation,
 	type FieldBatchCodec,
+	type Locator,
 	type TreeCompressionStrategy,
 	allowsRepoSuperset,
 	buildForest,
+	changeAtomFromDetachedNodeId,
 	createNodeIdentifierManager,
 	defaultSchemaPolicy,
 	intoDelta,
 	jsonableTreeFromCursor,
 	makeFieldBatchCodec,
+	nodeIdFromChangeAtom,
 } from "../feature-libraries/index.js";
 import {
 	SquashingTransactionStack,
@@ -74,13 +86,19 @@ import {
 	Breakable,
 	disposeSymbol,
 	getOrCreate,
+	makeArray,
 	type JsonCompatibleReadOnly,
 	type WithBreakable,
 } from "../util/index.js";
 
 import { SharedTreeChangeFamily, hasSchemaChange } from "./sharedTreeChangeFamily.js";
 import type { SharedTreeChange } from "./sharedTreeChangeTypes.js";
-import type { ISharedTreeEditor, SharedTreeEditBuilder } from "./sharedTreeEditBuilder.js";
+import {
+	type IdBasedSharedTreeEditBuilder,
+	type ILocationBasedSharedTreeEditor,
+	type IIdBasedSharedTreeEditor,
+	LocationBasedSharedTreeEditBuilder,
+} from "./sharedTreeEditBuilder.js";
 import type { IDisposable } from "@fluidframework/core-interfaces";
 import {
 	type ImplicitFieldSchema,
@@ -128,8 +146,6 @@ export interface CheckoutEvents {
 	 * can use to filter on changes they care about e.g. local vs remote changes.
 	 *
 	 * @param data - information about the change
-	 * @param getRevertible - a function provided that allows users to get a revertible for the change. If not provided,
-	 * this change is not revertible.
 	 */
 	changed(data: ChangeMetadata, getRevertible?: RevertibleAlphaFactory): void;
 
@@ -232,7 +248,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: ISharedTreeEditor;
+	readonly editor: ILocationBasedSharedTreeEditor;
 
 	/**
 	 * A collection of functions for managing transactions.
@@ -290,8 +306,8 @@ export function createTreeCheckout(
 	mintRevisionTag: () => RevisionTag,
 	revisionTagCodec: RevisionTagCodec,
 	args?: {
-		branch?: SharedTreeBranch<SharedTreeEditBuilder, SharedTreeChange>;
-		changeFamily?: ChangeFamily<SharedTreeEditBuilder, SharedTreeChange>;
+		branch?: SharedTreeBranch<IdBasedSharedTreeEditBuilder, SharedTreeChange>;
+		changeFamily?: ChangeFamily<IdBasedSharedTreeEditBuilder, SharedTreeChange>;
 		schema?: TreeStoredSchemaRepository;
 		forest?: IEditableForest;
 		fieldBatchCodec?: FieldBatchCodec;
@@ -300,21 +316,23 @@ export function createTreeCheckout(
 		logger?: ITelemetryLoggerExt;
 		breaker?: Breakable;
 		disposeForksAfterTransaction?: boolean;
+		codecOptions?: Partial<CodecWriteOptions>;
 	},
 ): TreeCheckout {
 	const breaker = args?.breaker ?? new Breakable("TreeCheckout");
 	const schema = args?.schema ?? new TreeStoredSchemaRepository();
 	const forest = args?.forest ?? buildForest(breaker, schema);
-	const defaultCodecOptions = {
+	const defaultCodecOptions: CodecWriteOptions = {
 		jsonValidator: FormatValidatorNoOp,
 		minVersionForCollab: FluidClientVersion.v2_0,
 	};
+	const codecOptions: CodecWriteOptions = { ...defaultCodecOptions, ...args?.codecOptions };
 	const changeFamily =
 		args?.changeFamily ??
 		new SharedTreeChangeFamily(
 			revisionTagCodec,
-			args?.fieldBatchCodec ?? makeFieldBatchCodec(defaultCodecOptions),
-			defaultCodecOptions,
+			args?.fieldBatchCodec ?? makeFieldBatchCodec(codecOptions),
+			codecOptions,
 			args?.chunkCompressionStrategy,
 			idCompressor,
 		);
@@ -378,6 +396,7 @@ export class TreeCheckout implements ITreeCheckoutFork {
 	public disposed = false;
 
 	private editLock: EditLock;
+	private readonly locator: Locator;
 
 	private readonly views = new Set<TreeView<ImplicitFieldSchema>>();
 
@@ -393,7 +412,7 @@ export class TreeCheckout implements ITreeCheckoutFork {
 	 */
 	private readonly revertibleCommitBranches = new Map<
 		RevisionTag,
-		SharedTreeBranch<SharedTreeEditBuilder, SharedTreeChange>
+		SharedTreeBranch<IdBasedSharedTreeEditBuilder, SharedTreeChange>
 	>();
 
 	/**
@@ -406,10 +425,13 @@ export class TreeCheckout implements ITreeCheckoutFork {
 	public events: Listenable<CheckoutEvents> = this.#events;
 
 	public constructor(
-		branch: SharedTreeBranch<SharedTreeEditBuilder, SharedTreeChange>,
+		branch: SharedTreeBranch<IdBasedSharedTreeEditBuilder, 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<SharedTreeEditBuilder, SharedTreeChange>,
+		private readonly changeFamily: ChangeFamily<
+			IdBasedSharedTreeEditBuilder,
+			SharedTreeChange
+		>,
 		public readonly storedSchema: TreeStoredSchemaRepository,
 		public readonly forest: IEditableForest,
 		private readonly mintRevisionTag: () => RevisionTag,
@@ -427,6 +449,31 @@ 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 };
+				});
+			},
+		};
 		this.registerForBranchEvents();
 	}
 
@@ -447,44 +494,34 @@ export class TreeCheckout implements ITreeCheckoutFork {
 	}
 
 	private createTransactionStack(
-		branch: SharedTreeBranch<SharedTreeEditBuilder, SharedTreeChange>,
-	): SquashingTransactionStack<SharedTreeEditBuilder, SharedTreeChange> {
-		return new SquashingTransactionStack(
-			branch,
-			(commits) => {
-				const revision = this.mintRevisionTag();
-				for (const transactionStep of commits) {
-					this._removedRoots.updateMajor(transactionStep.revision, revision);
-				}
-
-				const squashedChange = this.changeFamily.rebaser.compose(commits);
-				const change = this.changeFamily.rebaser.changeRevision(squashedChange, revision);
-				return tagChange(change, revision);
-			},
-			() => {
-				const disposeForks = this.disposeForksAfterTransaction
-					? trackForksForDisposal(this)
-					: undefined;
-				// When each transaction is started, make a restorable checkpoint of the current state of removed roots
-				const restoreRemovedRoots = this._removedRoots.createCheckpoint();
-				return (result) => {
-					switch (result) {
-						case TransactionResult.Abort:
-							restoreRemovedRoots();
-							break;
-						case TransactionResult.Commit:
-							if (!this.transaction.isInProgress()) {
-								// 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(this.#transaction.branch.getHead());
-							}
-							break;
-						default:
-							unreachableCase(result);
+		branch: SharedTreeBranch<IdBasedSharedTreeEditBuilder, SharedTreeChange>,
+	): SquashingTransactionStack<IdBasedSharedTreeEditBuilder, SharedTreeChange> {
+		return new SquashingTransactionStack(branch, this.mintRevisionTag, () => {
+			const disposeForks = this.disposeForksAfterTransaction
+				? trackForksForDisposal(this)
+				: undefined;
+			// When each transaction is started, make a restorable checkpoint of the current state of removed roots
+			const restoreRemovedRoots = this._removedRoots.createCheckpoint();
+			return (result) => {
+				switch (result) {
+					case TransactionResult.Abort: {
+						restoreRemovedRoots();
+						break;
 					}
-					disposeForks?.();
-				};
-			},
-		);
+					case TransactionResult.Commit: {
+						if (!this.transaction.isInProgress()) {
+							// 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(this.#transaction.branch.getHead());
+						}
+						break;
+					}
+					default: {
+						unreachableCase(result);
+					}
+				}
+				disposeForks?.();
+			};
+		});
 	}
 
 	public exportVerbose(): VerboseTree | undefined {
@@ -570,6 +607,7 @@ export class TreeCheckout implements ITreeCheckoutFork {
 							change: encodedChange,
 						} satisfies SerializedChange;
 					},
+					getRevertible: (onDisposed) => getRevertible?.(onDisposed),
 				};
 
 				this.#events.emit("changed", metadata, getRevertible);
@@ -595,7 +633,9 @@ export class TreeCheckout implements ITreeCheckoutFork {
 		this.#events.emit("afterBatch");
 		this.editLock.unlock();
 		if (event.type === "append") {
-			event.newCommits.forEach((commit) => this.validateCommit(commit));
+			for (const commit of event.newCommits) {
+				this.validateCommit(commit);
+			}
 		}
 	};
 
@@ -657,7 +697,7 @@ export class TreeCheckout implements ITreeCheckoutFork {
 		// When the branch is trimmed, we can garbage collect any repair data whose latest relevant revision is one of the
 		// trimmed revisions.
 		this.withCombinedVisitor((visitor) => {
-			revisions.forEach((revision) => {
+			for (const revision of revisions) {
 				// get all the roots last created or used by the revision
 				const roots = this._removedRoots.getRootsLastTouchedByRevision(revision);
 
@@ -667,7 +707,7 @@ export class TreeCheckout implements ITreeCheckoutFork {
 				}
 
 				this._removedRoots.deleteRootsLastTouchedByRevision(revision);
-			});
+			}
 		});
 	};
 
@@ -793,9 +833,9 @@ export class TreeCheckout implements ITreeCheckoutFork {
 		return this.forest.anchors.events;
 	}
 
-	public get editor(): ISharedTreeEditor {
+	public get editor(): ILocationBasedSharedTreeEditor {
 		this.checkNotDisposed();
-		return this.editLock.editor;
+		return new LocationBasedSharedTreeEditBuilder(this.editLock.editor, this.locator);
 	}
 
 	public locate(anchor: Anchor): AnchorNode | undefined {
@@ -816,13 +856,19 @@ 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<SharedTreeEditBuilder, SharedTreeChange>;
+	#transaction: SquashingTransactionStack<IdBasedSharedTreeEditBuilder, 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()) {
+			throw new UsageError("A view cannot be forked while it has a pending transaction.");
+		}
+
 		const anchors = new AnchorSet();
 		const branch = this.#transaction.activeBranch.fork();
 		const storedSchema = this.storedSchema.clone();
@@ -846,7 +892,7 @@ export class TreeCheckout implements ITreeCheckoutFork {
 	}
 
 	public switchBranch(
-		branch: SharedTreeBranch<SharedTreeEditBuilder, SharedTreeChange>,
+		branch: SharedTreeBranch<IdBasedSharedTreeEditBuilder, SharedTreeChange>,
 	): void {
 		// TODO: Dispose old branch, if necessary
 		assert(
@@ -879,10 +925,16 @@ export class TreeCheckout implements ITreeCheckoutFork {
 			"The source of the branch rebase has been disposed and cannot be rebased.",
 		);
 		this.editLock.checkUnlocked("Rebasing");
-		assert(
-			!checkout.transaction.isInProgress(),
-			0x9af /* A view cannot be rebased while it has a pending transaction */,
-		);
+
+		if (this.transaction.isInProgress()) {
+			throw new UsageError(
+				"Views cannot be rebased onto a view that has a pending transaction.",
+			);
+		}
+		if (checkout.transaction.isInProgress()) {
+			throw new UsageError("A view cannot be rebased while it has a pending transaction.");
+		}
+
 		assert(
 			!checkout.isSharedBranch,
 			0xa5d /* Shared branches cannot be rebased onto another branch. */,
@@ -908,12 +960,15 @@ export class TreeCheckout implements ITreeCheckoutFork {
 			"The source of the branch merge has been disposed and cannot be merged.",
 		);
 		this.editLock.checkUnlocked("Merging");
-		assert(
-			!this.transaction.isInProgress(),
-			0x9b0 /* Views cannot be merged into a view while it has a pending transaction */,
-		);
-		while (checkout.transaction.isInProgress()) {
-			checkout.transaction.commit();
+		if (this.transaction.isInProgress()) {
+			throw new UsageError(
+				"Views cannot be merged into a view while it has a pending transaction.",
+			);
+		}
+		if (checkout.transaction.isInProgress()) {
+			throw new UsageError(
+				"Views with an open transaction cannot be merged into another view.",
+			);
 		}
 		this.#transaction.activeBranch.merge(checkout.#transaction.activeBranch);
 		if (disposeMerged && !checkout.isSharedBranch) {
@@ -962,7 +1017,7 @@ export class TreeCheckout implements ITreeCheckoutFork {
 			const tree = jsonableTreeFromCursor(cursor);
 			// This method is used for tree consistency comparison.
 			const { major, minor } = id;
-			const finalizedMajor = major !== undefined ? this.revisionTagCodec.encode(major) : major;
+			const finalizedMajor = major === undefined ? major : this.revisionTagCodec.encode(major);
 			trees.push([finalizedMajor, minor, tree]);
 		}
 		cursor.free();
@@ -1116,7 +1171,9 @@ export class TreeCheckout implements ITreeCheckoutFork {
 	private validateCommit(commit: GraphCommit<SharedTreeChange>): void {
 		const validated = getOrCreate(this.#validatedCommits, commit, () => []);
 		if (validated !== true) {
-			validated.forEach((fn) => fn(commit));
+			for (const fn of validated) {
+				fn(commit);
+			}
 			this.#validatedCommits.set(commit, true);
 		}
 	}
@@ -1132,19 +1189,23 @@ 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: ISharedTreeEditor;
+	public readonly editor: IIdBasedSharedTreeEditor;
 	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: ISharedTreeEditor) {
+	public constructor(editor: IIdBasedSharedTreeEditor) {
 		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 {
@@ -1152,6 +1213,10 @@ class EditLock {
 						checkLock();
 						valueField.set(...editArgs);
 					},
+					attach(...editArgs) {
+						checkLock();
+						valueField.attach(...editArgs);
+					},
 				};
 			},
 			optionalField(...fieldArgs) {
@@ -1161,6 +1226,14 @@ class EditLock {
 						checkLock();
 						optionalField.set(...editArgs);
 					},
+					attach(...editArgs) {
+						checkLock();
+						optionalField.attach(...editArgs);
+					},
+					clear(...editArgs) {
+						checkLock();
+						optionalField.clear(...editArgs);
+					},
 				};
 			},
 			sequenceField(...fieldArgs) {
@@ -1170,6 +1243,10 @@ class EditLock {
 						checkLock();
 						sequenceField.insert(...editArgs);
 					},
+					attach(...editArgs) {
+						checkLock();
+						sequenceField.attach(...editArgs);
+					},
 					remove(...editArgs) {
 						checkLock();
 						sequenceField.remove(...editArgs);
@@ -1186,6 +1263,12 @@ class EditLock {
 			addNodeExistsConstraintOnRevert(path) {
 				editor.addNodeExistsConstraintOnRevert(path);
 			},
+			addNoChangeConstraint() {
+				editor.addNoChangeConstraint();
+			},
+			addNoChangeConstraintOnRevert() {
+				editor.addNoChangeConstraintOnRevert();
+			},
 		};
 	}
 
@@ -1244,8 +1327,12 @@ function trackForksForDisposal(checkout: TreeCheckout): () => void {
 	let disposed = false;
 	return () => {
 		assert(!disposed, 0xaa9 /* Forks may only be disposed once */);
-		forks.forEach((fork) => fork.dispose());
-		onDisposeUnSubscribes.forEach((unsubscribe) => unsubscribe());
+		for (const fork of forks) {
+			fork.dispose();
+		}
+		for (const unsubscribe of onDisposeUnSubscribes) {
+			unsubscribe();
+		}
 		onForkUnSubscribe();
 		disposed = true;
 	};

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

@@ -22,6 +22,7 @@ import {
 	rebaseBranch,
 	tagRollbackInverse,
 	type RebaseStatsWithDuration,
+	type EditorOptions,
 } from "../core/index.js";
 import { hasSome, defineLazyCachedProperty } from "../util/index.js";
 import type {
@@ -117,6 +118,7 @@ export class SharedTreeBranch<TEditor extends ChangeFamilyEditor, TChange> {
 	 * Construct a new branch.
 	 * @param head - the head of the branch
 	 * @param changeFamily - determines the set of changes that this branch can commit
+	 * @param mintRevisionTag - used to generate a `RevisionTag` for each change.
 	 * @param branchTrimmer - an optional event emitter that informs the branch it has been trimmed. If this is not supplied, then the branch must
 	 * never be trimmed. See {@link BranchTrimmingEvents} for details on trimming.
 	 */
@@ -128,9 +130,12 @@ 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.editor = this.changeFamily.buildEditor(
+			mintRevisionTag,
+			(change) => this.apply(change),
+			this.editorOptions,
 		);
 		this.unsubscribeBranchTrimmer = branchTrimmer?.on("ancestryTrimmed", (commit) => {
 			this.#events.emit("ancestryTrimmed", commit);
@@ -186,16 +191,22 @@ export class SharedTreeBranch<TEditor extends ChangeFamilyEditor, TChange> {
 	/**
 	 * 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.
+	 * @param mintRevisionTag - used to generate a `RevisionTag` for each change.
 	 * @remarks Changes made to the new branch will not be applied to this branch until the new branch is {@link SharedTreeBranch.merge | merged} back in.
 	 * Forks created during a transaction will be disposed when the transaction ends.
 	 */
-	public fork(commit: GraphCommit<TChange> = this.head): SharedTreeBranch<TEditor, TChange> {
+	public fork(
+		commit: GraphCommit<TChange> = this.head,
+		mintRevisionTag: () => RevisionTag = this.mintRevisionTag,
+	): SharedTreeBranch<TEditor, TChange> {
 		this.assertNotDisposed();
 		const fork = new SharedTreeBranch(
 			commit,
 			this.changeFamily,
-			this.mintRevisionTag,
+			mintRevisionTag,
 			this.branchTrimmer,
+			undefined,
+			this.editorOptions,
 		);
 		this.#events.emit("fork", fork);
 		return fork;
@@ -226,7 +237,7 @@ export class SharedTreeBranch<TEditor extends ChangeFamilyEditor, TChange> {
 		const { deletedSourceCommits, targetCommits, sourceCommits } = commits;
 		assert(hasSome(targetCommits), 0xa83 /* Expected commit(s) for a non no-op rebase */);
 
-		const newCommits = targetCommits.concat(sourceCommits);
+		const newCommits = [...targetCommits, ...sourceCommits];
 		const changeEvent = {
 			type: "rebase",
 			get change() {
@@ -395,5 +406,9 @@ export function onForkTransitive<T extends { events: Listenable<{ fork(t: T): vo
 			onFork(fork);
 		}),
 	);
-	return () => offs.forEach((off) => off());
+	return () => {
+		for (const off of offs) {
+			off();
+		}
+	};
 }

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

@@ -5,12 +5,7 @@
 
 import { assert } from "@fluidframework/core-utils/internal";
 
-import {
-	type ChangeRebaser,
-	type GraphCommit,
-	replaceChange,
-	type RevisionTag,
-} from "../core/index.js";
+import { type ChangeRebaser, type GraphCommit, replaceChange } from "../core/index.js";
 
 import type { SharedTreeBranchChange } from "./branch.js";
 import type { ChangeEnricherReadonlyCheckout } from "./changeEnricher.js";
@@ -36,7 +31,7 @@ export class BranchCommitEnricher<TChange> {
 	 * 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;
+	#getOuterTransactionChange?: () => TChange;
 
 	public constructor(
 		rebaser: ChangeRebaser<TChange>,
@@ -54,7 +49,7 @@ export class BranchCommitEnricher<TChange> {
 		if (change.type === "append") {
 			for (const newCommit of change.newCommits) {
 				const newChange =
-					this.#getOuterTransactionChange?.(newCommit.revision) ??
+					this.#getOuterTransactionChange?.() ??
 					this.#enricher.updateChangeEnrichments(newCommit.change, newCommit.revision);
 
 				this.#preparedCommits.set(newCommit, replaceChange(newCommit, newChange));