@fluidframework/tree 2.74.0-370705 → 2.80.0

package/src/shared-tree/treeCheckout.ts

@@ -6,12 +6,16 @@
 import { assert, unreachableCase, fail } from "@fluidframework/core-utils/internal";
 import type { IFluidHandle, Listenable } from "@fluidframework/core-interfaces/internal";
 import { createEmitter } from "@fluid-internal/client-utils";
-import type { IIdCompressor } from "@fluidframework/id-compressor";
+import type { IIdCompressor, SessionId } from "@fluidframework/id-compressor";
 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,
@@ -20,7 +24,6 @@ import {
 	type AnchorSetRootEvents,
 	type ChangeFamily,
 	CommitKind,
-	type CommitMetadata,
 	type DeltaVisitor,
 	type DetachedFieldIndex,
 	type IEditableForest,
@@ -47,27 +50,21 @@ 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,
@@ -81,18 +78,13 @@ 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 IdBasedSharedTreeEditBuilder,
-	type ILocationBasedSharedTreeEditor,
-	type IIdBasedSharedTreeEditor,
-	LocationBasedSharedTreeEditBuilder,
-} from "./sharedTreeEditBuilder.js";
+import type { ISharedTreeEditor, SharedTreeEditBuilder } from "./sharedTreeEditBuilder.js";
 import type { IDisposable } from "@fluidframework/core-interfaces";
 import {
 	type ImplicitFieldSchema,
@@ -109,6 +101,7 @@ import {
 	type CustomTreeNode,
 } from "../simple-tree/index.js";
 import { getCheckout, SchematizingSimpleTreeView } from "./schematizingTreeView.js";
+import { isStableId } from "@fluidframework/id-compressor/internal";
 
 /**
  * Events for {@link ITreeCheckout}.
@@ -142,7 +135,7 @@ export interface CheckoutEvents {
 	 * @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: CommitMetadata, getRevertible?: RevertibleAlphaFactory): void;
+	changed(data: ChangeMetadata, getRevertible?: RevertibleAlphaFactory): void;
 
 	/**
 	 * Fired when a new branch is created from this checkout.
@@ -243,7 +236,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.
@@ -301,8 +294,8 @@ export function createTreeCheckout(
 	mintRevisionTag: () => RevisionTag,
 	revisionTagCodec: RevisionTagCodec,
 	args?: {
-		branch?: SharedTreeBranch<IdBasedSharedTreeEditBuilder, SharedTreeChange>;
-		changeFamily?: ChangeFamily<IdBasedSharedTreeEditBuilder, SharedTreeChange>;
+		branch?: SharedTreeBranch<SharedTreeEditBuilder, SharedTreeChange>;
+		changeFamily?: ChangeFamily<SharedTreeEditBuilder, SharedTreeChange>;
 		schema?: TreeStoredSchemaRepository;
 		forest?: IEditableForest;
 		fieldBatchCodec?: FieldBatchCodec;
@@ -311,21 +304,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,
 		);
@@ -389,7 +384,6 @@ export class TreeCheckout implements ITreeCheckoutFork {
 	public disposed = false;
 
 	private editLock: EditLock;
-	private readonly locator: Locator;
 
 	private readonly views = new Set<TreeView<ImplicitFieldSchema>>();
 
@@ -405,7 +399,7 @@ export class TreeCheckout implements ITreeCheckoutFork {
 	 */
 	private readonly revertibleCommitBranches = new Map<
 		RevisionTag,
-		SharedTreeBranch<IdBasedSharedTreeEditBuilder, SharedTreeChange>
+		SharedTreeBranch<SharedTreeEditBuilder, SharedTreeChange>
 	>();
 
 	/**
@@ -418,13 +412,10 @@ 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,
@@ -442,31 +433,6 @@ 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();
 	}
 
@@ -487,44 +453,34 @@ export class TreeCheckout implements ITreeCheckoutFork {
 	}
 
 	private createTransactionStack(
-		branch: SharedTreeBranch<IdBasedSharedTreeEditBuilder, SharedTreeChange>,
-	): SquashingTransactionStack<IdBasedSharedTreeEditBuilder, 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<SharedTreeEditBuilder, SharedTreeChange>,
+	): SquashingTransactionStack<SharedTreeEditBuilder, 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 {
@@ -585,7 +541,34 @@ export class TreeCheckout implements ITreeCheckoutFork {
 						};
 
 				let withinEventContext = true;
-				this.#events.emit("changed", { isLocal: true, kind }, getRevertible);
+
+				const metadata: ChangeMetadata = {
+					kind,
+					isLocal: true,
+					getChange: () => {
+						const context: ChangeEncodingContext = {
+							idCompressor: this.idCompressor,
+							originatorId: this.idCompressor.localSessionId,
+							revision,
+						};
+						const encodedChange = this.changeFamily.codecs
+							.resolve(4)
+							.json.encode(change, context);
+
+						assert(
+							commit.parent !== undefined,
+							0xca4 /* Expected applied commit to be parented */,
+						);
+						return {
+							version: 1,
+							revision,
+							originatorId: this.idCompressor.localSessionId,
+							change: encodedChange,
+						} satisfies SerializedChange;
+					},
+				};
+
+				this.#events.emit("changed", metadata, getRevertible);
 				withinEventContext = false;
 			}
 		} else if (this.isRemoteChangeEvent(event)) {
@@ -612,6 +595,28 @@ export class TreeCheckout implements ITreeCheckoutFork {
 		}
 	};
 
+	/**
+	 * Applies the given serialized change (as was produced via a `"changed"` event of another checkout) to this checkout.
+	 */
+	public applySerializedChange(serializedChange: JsonCompatibleReadOnly): void {
+		if (!isSerializedChange(serializedChange)) {
+			throw new UsageError(`Cannot apply change. Invalid serialized change format.`);
+		}
+		const { revision, originatorId, change } = serializedChange;
+		if (originatorId !== this.idCompressor.localSessionId) {
+			throw new UsageError(
+				`Cannot apply change. A serialized changed must be applied to the same SharedTree as it was created from.`,
+			);
+		}
+		const context: ChangeEncodingContext = {
+			idCompressor: this.idCompressor,
+			originatorId: this.idCompressor.localSessionId,
+			revision,
+		};
+		const decodedChange = this.changeFamily.codecs.resolve(4).json.decode(change, context);
+		this.applyChange(decodedChange, revision);
+	}
+
 	// Revision is the revision of the commit, if any, which caused this change.
 	private applyChange(change: SharedTreeChange, revision?: RevisionTag): void {
 		// Conflicts due to schema will be empty and thus are not applied.
@@ -784,9 +789,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);
+		return this.editLock.editor;
 	}
 
 	public locate(anchor: Anchor): AnchorNode | undefined {
@@ -807,12 +812,17 @@ 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.",
 		);
+		// 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.");
+		}
+
 		this.editLock.checkUnlocked("Branching");
 		const anchors = new AnchorSet();
 		const branch = this.#transaction.activeBranch.fork();
@@ -837,7 +847,7 @@ export class TreeCheckout implements ITreeCheckoutFork {
 	}
 
 	public switchBranch(
-		branch: SharedTreeBranch<IdBasedSharedTreeEditBuilder, SharedTreeChange>,
+		branch: SharedTreeBranch<SharedTreeEditBuilder, SharedTreeChange>,
 	): void {
 		// TODO: Dispose old branch, if necessary
 		assert(
@@ -870,10 +880,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. */,
@@ -899,12 +915,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) {
@@ -953,7 +972,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();
@@ -1123,23 +1142,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 {
@@ -1147,10 +1162,6 @@ class EditLock {
 						checkLock();
 						valueField.set(...editArgs);
 					},
-					attach(...editArgs) {
-						checkLock();
-						valueField.attach(...editArgs);
-					},
 				};
 			},
 			optionalField(...fieldArgs) {
@@ -1160,14 +1171,6 @@ class EditLock {
 						checkLock();
 						optionalField.set(...editArgs);
 					},
-					attach(...editArgs) {
-						checkLock();
-						optionalField.attach(...editArgs);
-					},
-					clear(...editArgs) {
-						checkLock();
-						optionalField.clear(...editArgs);
-					},
 				};
 			},
 			sequenceField(...fieldArgs) {
@@ -1177,10 +1180,6 @@ class EditLock {
 						checkLock();
 						sequenceField.insert(...editArgs);
 					},
-					attach(...editArgs) {
-						checkLock();
-						sequenceField.attach(...editArgs);
-					},
 					remove(...editArgs) {
 						checkLock();
 						sequenceField.remove(...editArgs);
@@ -1197,6 +1196,12 @@ class EditLock {
 			addNodeExistsConstraintOnRevert(path) {
 				editor.addNodeExistsConstraintOnRevert(path);
 			},
+			addNoChangeConstraint() {
+				editor.addNoChangeConstraint();
+			},
+			addNoChangeConstraintOnRevert() {
+				editor.addNoChangeConstraintOnRevert();
+			},
 		};
 	}
 
@@ -1278,3 +1283,24 @@ function verboseFromCursor(
 		fields: fields as CustomTreeNode<IFluidHandle>,
 	};
 }
+
+interface SerializedChange {
+	version: 1;
+	revision: RevisionTag;
+	change: JsonCompatibleReadOnly;
+	originatorId: SessionId;
+}
+
+function isSerializedChange(value: unknown): value is SerializedChange {
+	if (typeof value !== "object" || value === null) {
+		return false;
+	}
+	const change = value as Partial<SerializedChange>;
+	return (
+		change.version === 1 &&
+		(change.revision === "root" || typeof change.revision === "number") &&
+		typeof change.originatorId === "string" &&
+		isStableId(change.originatorId) &&
+		change.change !== undefined
+	);
+}

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

@@ -22,7 +22,6 @@ import {
 	rebaseBranch,
 	tagRollbackInverse,
 	type RebaseStatsWithDuration,
-	type EditorOptions,
 } from "../core/index.js";
 import { hasSome, defineLazyCachedProperty } from "../util/index.js";
 import type {
@@ -118,6 +117,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.
 	 */
@@ -129,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);
@@ -190,18 +187,20 @@ 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;
@@ -232,7 +231,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() {

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));