@fluidframework/tree 2.11.0 → 2.13.0

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

@@ -24,80 +24,34 @@ import {
 import type { Listenable } from "@fluidframework/core-interfaces";
 import { createEmitter } from "@fluid-internal/client-utils";
 
-import { hasSome } from "../util/index.js";
+import { hasSome, defineLazyCachedProperty } from "../util/index.js";
 
 /**
- * Describes a change to a `SharedTreeBranch`. Various operations can mutate the head of the branch;
- * this change format describes each in terms of the "removed commits" (all commits which were present
- * on the branch before the operation but are no longer present after) and the "new commits" (all
- * commits which are present on the branch after the operation that were not present before). Each of
- * the following event types also provides a `change` which contains the net change to the branch
- * (or is undefined if there was no net change):
+ * Describes a change to a `SharedTreeBranch`. Each of the following event types provides a `change` which contains the net change to the branch (or is undefined if there was no net change):
  * * Append - when one or more commits are appended to the head of the branch, for example via
  * a change applied by the branch's editor, or as a result of merging another branch into this one
- * * Remove - when one or more commits are removed from the head of the branch. This occurs
- * when a transaction is aborted and all commits pending in that transaction are removed.
- * * Replace - when an operation simultaneously removes and appends commits. For example, when this
- * branch is rebased and some commits are removed and replaced with rebased versions, or when a
- * transaction completes and all pending commits are replaced with a single squash commit.
+ * * Remove - when one or more commits are removed from the head of the branch.
+ * * Rebase - when a rebase operation adds commits from another branch and replaces existing commits with their rebased versions.
  */
 export type SharedTreeBranchChange<TChange> =
 	| {
 			type: "append";
 			kind: CommitKind;
 			change: TaggedChange<TChange>;
+			/** The commits appended to the head of the branch by this operation */
 			newCommits: readonly [GraphCommit<TChange>, ...GraphCommit<TChange>[]];
 	  }
 	| {
 			type: "remove";
-			change: TaggedChange<TChange> | undefined;
+			change: TaggedChange<TChange>;
+			/** The commits removed from the head of the branch by this operation */
 			removedCommits: readonly [GraphCommit<TChange>, ...GraphCommit<TChange>[]];
 	  }
 	| {
-			type: "replace";
+			type: "rebase";
 			change: TaggedChange<TChange> | undefined;
-			removedCommits: readonly GraphCommit<TChange>[];
-			newCommits: readonly GraphCommit<TChange>[];
 	  };
 
-/**
- * Returns the operation that caused the given {@link SharedTreeBranchChange}.
- */
-export function getChangeReplaceType(
-	change: SharedTreeBranchChange<unknown> & { type: "replace" },
-): "transactionCommit" | "rebase" {
-	// The "replace" variant of the change event is emitted by two operations: committing a transaction and doing a rebase.
-	// Committing a transaction will always remove one or more commits (the commits that were squashed),
-	// and will add exactly one new commit (the squash commit).
-	if (change.removedCommits.length === 0 || change.newCommits.length !== 1) {
-		return "rebase";
-	}
-
-	// There is only one case in which a rebase both removes commits and adds exactly one new commit.
-	// This occurs when there is exactly one divergent, but equivalent, commit on each branch:
-	//
-	// A ─ B (branch X)	  -- rebase Y onto X -->   A ─ B (branch X)
-	// └─ B' (branch Y)                                └─ (branch Y)
-	//
-	// B' is removed and replaced by B because both have the same revision.
-	assert(
-		change.removedCommits[0] !== undefined,
-		0x9e4 /* This wont run due to the length check above */,
-	);
-	assert(
-		change.newCommits[0] !== undefined,
-		0x9e5 /* This wont run because a replace operation always has new commits */,
-	);
-	if (
-		change.removedCommits.length === 1 &&
-		change.removedCommits[0].revision === change.newCommits[0].revision
-	) {
-		return "rebase";
-	}
-
-	return "transactionCommit";
-}
-
 /**
  * The events emitted by a `SharedTreeBranch`
  */
@@ -189,35 +143,31 @@ export class SharedTreeBranch<TEditor extends ChangeFamilyEditor, TChange> {
 
 	/**
 	 * Apply a change to this branch.
-	 * @param taggedChange - the change to apply
+	 * @param change - the change to apply
 	 * @param kind - the kind of change to apply
 	 * @returns the change that was applied and the new head commit of the branch
 	 */
-	public apply(
-		taggedChange: TaggedChange<TChange>,
-		kind: CommitKind = CommitKind.Default,
-	): [change: TChange, newCommit: GraphCommit<TChange>] {
+	public apply(change: TaggedChange<TChange>, kind: CommitKind = CommitKind.Default): void {
 		this.assertNotDisposed();
 
-		const revisionTag = taggedChange.revision;
+		const revisionTag = change.revision;
 		assert(revisionTag !== undefined, 0xa49 /* Revision tag must be provided */);
 
 		const newHead = mintCommit(this.head, {
 			revision: revisionTag,
-			change: taggedChange.change,
+			change: change.change,
 		});
 
 		const changeEvent = {
 			type: "append",
 			kind,
-			change: taggedChange,
+			change,
 			newCommits: [newHead],
 		} as const;
 
 		this.#events.emit("beforeChange", changeEvent);
 		this.head = newHead;
 		this.#events.emit("afterChange", changeEvent);
-		return [taggedChange.change, newHead];
 	}
 
 	/**
@@ -256,13 +206,13 @@ export class SharedTreeBranch<TEditor extends ChangeFamilyEditor, TChange> {
 	public rebaseOnto(
 		branch: SharedTreeBranch<TEditor, TChange>,
 		upTo = branch.getHead(),
-	): BranchRebaseResult<TChange> | undefined {
+	): void {
 		this.assertNotDisposed();
 
 		// Rebase this branch onto the given branch
 		const rebaseResult = this.rebaseBranch(this, branch, upTo);
 		if (rebaseResult === undefined) {
-			return undefined;
+			return;
 		}
 
 		// The net change to this branch is provided by the `rebaseBranch` API
@@ -272,7 +222,7 @@ export class SharedTreeBranch<TEditor extends ChangeFamilyEditor, TChange> {
 
 		const newCommits = targetCommits.concat(sourceCommits);
 		const changeEvent = {
-			type: "replace",
+			type: "rebase",
 			get change() {
 				const change = rebaseResult.sourceChange;
 				return change === undefined ? undefined : makeAnonChange(change);
@@ -284,7 +234,6 @@ export class SharedTreeBranch<TEditor extends ChangeFamilyEditor, TChange> {
 		this.#events.emit("beforeChange", changeEvent);
 		this.head = newSourceHead;
 		this.#events.emit("afterChange", changeEvent);
-		return rebaseResult;
 	}
 
 	/**
@@ -292,11 +241,9 @@ export class SharedTreeBranch<TEditor extends ChangeFamilyEditor, TChange> {
 	 * @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>[]] {
+	public removeAfter(commit: GraphCommit<TChange>): void {
 		if (commit === this.head) {
-			return [undefined, []];
+			return;
 		}
 
 		const removedCommits: GraphCommit<TChange>[] = [];
@@ -329,43 +276,6 @@ export class SharedTreeBranch<TEditor extends ChangeFamilyEditor, TChange> {
 		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;
 	}
 
 	/**
@@ -375,9 +285,7 @@ export class SharedTreeBranch<TEditor extends ChangeFamilyEditor, TChange> {
 	 * @returns the net change to this branch and the commits that were added to this branch by the merge,
 	 * or undefined if nothing changed
 	 */
-	public merge(
-		branch: SharedTreeBranch<TEditor, TChange>,
-	): [change: TChange, newCommits: GraphCommit<TChange>[]] | undefined {
+	public merge(branch: SharedTreeBranch<TEditor, TChange>): void {
 		this.assertNotDisposed();
 		branch.assertNotDisposed();
 
@@ -394,21 +302,20 @@ 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 = {
-			type: "append",
-			kind: CommitKind.Default,
-			get change(): TaggedChange<TChange> {
-				return taggedChange;
-			},
-			newCommits: sourceCommits,
-		} as const;
+		const { rebaser } = this.changeFamily;
+		const changeEvent = defineLazyCachedProperty(
+			{
+				type: "append",
+				kind: CommitKind.Default,
+				newCommits: sourceCommits,
+			} as const,
+			"change",
+			() => makeAnonChange(rebaser.compose(sourceCommits)),
+		);
 
 		this.#events.emit("beforeChange", changeEvent);
 		this.head = rebaseResult.newSourceHead;
 		this.#events.emit("afterChange", changeEvent);
-		return [change, sourceCommits];
 	}
 
 	/** Rebase `branchHead` onto `onto`, but return undefined if nothing changed */

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

@@ -12,7 +12,7 @@ import {
 } from "../core/index.js";
 import type { ChangeEnricherReadonlyCheckout } from "./changeEnricher.js";
 import { TransactionEnricher } from "./transactionEnricher.js";
-import { getChangeReplaceType, type SharedTreeBranchChange } from "./branch.js";
+import type { SharedTreeBranchChange } from "./branch.js";
 
 /**
  * Utility for enriching commits from a {@link Branch} before these commits are applied and submitted.
@@ -50,26 +50,13 @@ export class BranchCommitEnricher<TChange> {
 	 * @param isAttached - Whether or not the SharedTree is attached to the service.
 	 */
 	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);
+		if (change.type === "append") {
+			for (const newCommit of change.newCommits) {
+				const newChange =
+					this.#getOuterTransactionChange?.(newCommit.revision) ??
+					this.#enricher.updateChangeEnrichments(newCommit.change, newCommit.revision);
 
-					this.#preparedCommits.set(newCommit, replaceChange(newCommit, newChange));
-				}
+				this.#preparedCommits.set(newCommit, replaceChange(newCommit, newChange));
 			}
 		}
 
@@ -111,4 +98,16 @@ export class BranchCommitEnricher<TChange> {
 	public abortTransaction(): void {
 		this.#transactionEnricher.abortTransaction();
 	}
+
+	/**
+	 * Add new transaction commits to the current transaction.
+	 * @param newCommits - The new commits to add.
+	 * @remarks This will throw an error if there is no ongoing transaction.
+	 */
+	public addTransactionCommits(newCommits: Iterable<GraphCommit<TChange>>): void {
+		assert(this.#transactionEnricher.isTransacting(), 0xa97 /* Not in transaction */);
+		for (const commit of newCommits) {
+			this.#transactionEnricher.addTransactionStep(commit);
+		}
+	}
 }

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

@@ -22,12 +22,7 @@ import {
 } from "../core/index.js";
 import { type Mutable, brand, fail, getOrCreate, mapIterable } from "../util/index.js";
 
-import {
-	SharedTreeBranch,
-	type BranchTrimmingEvents,
-	getChangeReplaceType,
-	onForkTransitive,
-} from "./branch.js";
+import { SharedTreeBranch, type BranchTrimmingEvents, onForkTransitive } from "./branch.js";
 import type {
 	Commit,
 	SeqNumber,
@@ -224,12 +219,12 @@ export class EditManager<
 		this.trackBranch(branch);
 		// Whenever the branch is rebased, update our record of its base trunk commit
 		const offBeforeRebase = branch.events.on("beforeChange", (args) => {
-			if (args.type === "replace" && getChangeReplaceType(args) === "rebase") {
+			if (args.type === "rebase") {
 				this.untrackBranch(branch);
 			}
 		});
 		const offAfterRebase = branch.events.on("afterChange", (args) => {
-			if (args.type === "replace" && getChangeReplaceType(args) === "rebase") {
+			if (args.type === "rebase") {
 				this.trackBranch(branch);
 				this.trimTrunk();
 			}

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

@@ -8,7 +8,6 @@ export {
 	SharedTreeBranch,
 	type SharedTreeBranchChange,
 	type SharedTreeBranchEvents,
-	getChangeReplaceType,
 } from "./branch.js";
 
 export {
@@ -16,6 +15,7 @@ export {
 	type Transactor,
 	type TransactionEvents,
 	TransactionStack,
+	SquashingTransactionStack,
 	type OnPush,
 	type OnPop,
 } from "./transaction.js";
@@ -26,6 +26,7 @@ export {
 	type Summarizable,
 	type SummaryElementParser,
 	type SummaryElementStringifier,
+	type ClonableSchemaAndPolicy,
 } from "./sharedTreeCore.js";
 
 export type { ResubmitMachine } from "./resubmitMachine.js";

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

@@ -45,7 +45,7 @@ import {
 	breakingClass,
 } from "../util/index.js";
 
-import { getChangeReplaceType, type SharedTreeBranch } from "./branch.js";
+import type { SharedTreeBranch } from "./branch.js";
 import { EditManager, minimumPossibleSequenceNumber } from "./editManager.js";
 import { makeEditManagerCodec } from "./editManagerCodecs.js";
 import type { SeqNumber } from "./editManagerFormat.js";
@@ -97,13 +97,6 @@ export class SharedTreeCore<TEditor extends ChangeFamilyEditor, TChange>
 		return this.getLocalBranch().editor;
 	}
 
-	/**
-	 * Gets the revision at the head of the trunk.
-	 */
-	protected get trunkHeadRevision(): RevisionTag {
-		return this.editManager.getTrunkHead().revision;
-	}
-
 	/**
 	 * Used to encode/decode messages sent to/received from the Fluid runtime.
 	 *
@@ -189,14 +182,9 @@ export class SharedTreeCore<TEditor extends ChangeFamilyEditor, TChange>
 				// Commit enrichment is only necessary for changes that will be submitted as ops, and changes issued while detached are not submitted.
 				this.commitEnricher.processChange(change);
 			}
-		});
-		this.editManager.localBranch.events.on("afterChange", (change) => {
-			if (
-				change.type === "append" ||
-				(change.type === "replace" && getChangeReplaceType(change) === "transactionCommit")
-			) {
+			if (change.type === "append") {
 				for (const commit of change.newCommits) {
-					this.submitCommit(commit, this.schemaAndPolicy);
+					this.submitCommit(commit, this.schemaAndPolicy, false);
 				}
 			}
 		});
@@ -269,6 +257,10 @@ export class SharedTreeCore<TEditor extends ChangeFamilyEditor, TChange>
 	}
 
 	protected async loadCore(services: IChannelStorageService): Promise<void> {
+		assert(
+			this.editManager.localBranch.getHead() === this.editManager.getTrunkHead(),
+			0xaaa /* All local changes should be applied to the trunk before loading from summary */,
+		);
 		const [editManagerSummarizer, ...summarizables] = this.summarizables;
 		const loadEditManager = this.loadSummarizable(editManagerSummarizer, services);
 		const loadSummarizables = summarizables.map(async (s) =>
@@ -316,7 +308,7 @@ export class SharedTreeCore<TEditor extends ChangeFamilyEditor, TChange>
 	protected submitCommit(
 		commit: GraphCommit<TChange>,
 		schemaAndPolicy: ClonableSchemaAndPolicy,
-		isResubmit = false,
+		isResubmit: boolean,
 	): void {
 		assert(
 			this.isAttached() === (this.detachedRevision === undefined),
@@ -380,9 +372,6 @@ export class SharedTreeCore<TEditor extends ChangeFamilyEditor, TChange>
 		this.editManager.advanceMinimumSequenceNumber(brand(message.minimumSequenceNumber));
 	}
 
-	/**
-	 * @returns the head commit of the root local branch
-	 */
 	protected getLocalBranch(): SharedTreeBranch<TEditor, TChange> {
 		return this.editManager.localBranch;
 	}

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

@@ -3,9 +3,18 @@
  * Licensed under the MIT License.
  */
 
+import { assert, unreachableCase } from "@fluidframework/core-utils/internal";
 import { createEmitter } from "@fluid-internal/client-utils";
 import type { IDisposable, Listenable } from "@fluidframework/core-interfaces";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
+import {
+	findAncestor,
+	type ChangeFamilyEditor,
+	type GraphCommit,
+	type TaggedChange,
+} from "../core/index.js";
+import type { SharedTreeBranch, SharedTreeBranchEvents } from "./branch.js";
+import { getOrCreate } from "../util/index.js";
 
 /**
  * Describes the result of a transaction.
@@ -163,3 +172,139 @@ export class TransactionStack implements Transactor, IDisposable {
 		}
 	}
 }
+
+/**
+ * An implementation of {@link Transactor} that {@link TransactionStack | uses a stack} and a {@link SharedTreeBranch | branch} to manage transactions.
+ * @remarks Given a branch, this class will fork the branch when a transaction begins and squash the forked branch back into the original branch when the transaction ends.
+ * This class provides conveniences for interacting with the {@link SquashingTransactionStack.activeBranch | active branch} in a way that is stable across transaction boundaries.
+ * For example, see {@link SquashingTransactionStack.activeBranchEditor | activeBranchEditor} and {@link SquashingTransactionStack.activeBranchEvents | activeBranchEvents}.
+ */
+export class SquashingTransactionStack<
+	TEditor extends ChangeFamilyEditor,
+	TChange,
+> extends TransactionStack {
+	public readonly branch: SharedTreeBranch<TEditor, TChange>;
+	#transactionBranch?: SharedTreeBranch<TEditor, TChange>;
+
+	/**
+	 * An editor for whichever branch is currently the {@link SquashingTransactionStack.activeBranch | active branch}.
+	 * @remarks This editor can safely be held on to across transaction boundaries, as it will properly delegate to the correct branch.
+	 * In contrast, it is not safe to hold onto e.g. `activeBranch.editor` across transaction boundaries, since the active branch may change.
+	 */
+	public readonly activeBranchEditor = new Proxy<TEditor>({} as unknown as TEditor, {
+		get: (_, p, receiver) => {
+			return Reflect.get(this.activeBranch.editor, p, receiver);
+		},
+	});
+
+	/**
+	 * Get the "active branch" for this transactor - either the transaction branch if a transaction is in progress, or the original branch otherwise.
+	 */
+	public get activeBranch(): SharedTreeBranch<TEditor, TChange> {
+		return this.#transactionBranch ?? this.branch;
+	}
+
+	/**
+	 * Provides events for changes in the {@link SquashingTransactionStack.activeBranch | active branch}.
+	 * @remarks When the active branch changes, the listeners for these events will automatically be transferred to the new active branch.
+	 * In contrast, binding an event to the {@link SquashingTransactionStack.activeBranch | active branch} directly will not automatically transfer the listener when the active branch changes.
+	 */
+	public get activeBranchEvents(): Listenable<SharedTreeBranchEvents<TEditor, TChange>> {
+		const off = (
+			eventName: keyof SharedTreeBranchEvents<TEditor, TChange>,
+			listener: SharedTreeBranchEvents<TEditor, TChange>[typeof eventName],
+		): void => {
+			this.activeBranch.events.off(eventName, listener);
+			const listeners = this.#activeBranchEvents.get(eventName);
+			if (listeners?.delete(listener) === true && listeners.size === 0) {
+				this.#activeBranchEvents.delete(eventName);
+			}
+		};
+
+		return {
+			on: (eventName, listener) => {
+				const listeners = getOrCreate(this.#activeBranchEvents, eventName, () => new Set());
+				listeners.add(listener);
+				this.activeBranch.events.on(eventName, listener);
+				return () => off(eventName, listener);
+			},
+			off,
+		};
+	}
+	readonly #activeBranchEvents = new Map<
+		keyof SharedTreeBranchEvents<TEditor, TChange>,
+		Set<
+			SharedTreeBranchEvents<TEditor, TChange>[keyof SharedTreeBranchEvents<TEditor, TChange>]
+		>
+	>();
+
+	/**
+	 * Construct a new {@link SquashingTransactionStack}.
+	 * @param branch - The {@link SquashingTransactionStack.branch | branch} that will be forked off of when a transaction begins.
+	 * @param squash - Called once when the outer-most transaction is committed to produce a single squashed change from the transaction's commits.
+	 * The change will be applied to the original {@link SquashingTransactionStack.branch | branch}.
+	 * @param onPush - {@link OnPush | A function} that will be called when a transaction is pushed to the {@link TransactionStack | stack}.
+	 */
+	public constructor(
+		branch: SharedTreeBranch<TEditor, TChange>,
+		squash: (commits: GraphCommit<TChange>[]) => TaggedChange<TChange>,
+		onPush?: OnPush,
+	) {
+		super(() => {
+			// Keep track of the commit that each transaction was on when it started
+			// TODO:#8603: This may need to be computed differently if we allow rebasing during a transaction.
+			const startHead = this.activeBranch.getHead();
+			const onPop = onPush?.();
+			const transactionBranch = this.#transactionBranch ?? this.branch.fork();
+			this.setTransactionBranch(transactionBranch);
+			transactionBranch.editor.enterTransaction();
+			return (result) => {
+				assert(this.#transactionBranch !== undefined, 0xa98 /* Expected transaction branch */);
+				this.#transactionBranch.editor.exitTransaction();
+				switch (result) {
+					case TransactionResult.Abort:
+						// When a transaction is aborted, roll back all the transaction's changes on the current branch
+						this.#transactionBranch.removeAfter(startHead);
+						break;
+					case TransactionResult.Commit:
+						// If this was the outermost transaction closing...
+						if (!this.isInProgress()) {
+							if (this.#transactionBranch.getHead() !== startHead) {
+								// ...squash all the new commits on the transaction branch into a new commit on the original branch
+								const removedCommits: GraphCommit<TChange>[] = [];
+								findAncestor(
+									[this.#transactionBranch.getHead(), removedCommits],
+									(c) => c === startHead,
+								);
+								branch.apply(squash(removedCommits));
+							}
+						}
+						break;
+					default:
+						unreachableCase(result);
+				}
+				if (!this.isInProgress()) {
+					this.#transactionBranch.dispose();
+					this.setTransactionBranch(undefined);
+				}
+				onPop?.(result);
+			};
+		});
+
+		this.branch = branch;
+	}
+
+	/** Updates the transaction branch (and therefore the active branch) and rebinds the branch events. */
+	private setTransactionBranch(
+		transactionBranch: SharedTreeBranch<TEditor, TChange> | undefined,
+	): void {
+		const oldActiveBranch = this.activeBranch;
+		this.#transactionBranch = transactionBranch;
+		for (const [eventName, listeners] of this.#activeBranchEvents) {
+			for (const listener of listeners) {
+				oldActiveBranch.events.off(eventName, listener);
+				this.activeBranch.events.on(eventName, listener);
+			}
+		}
+	}
+}

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

@@ -8,7 +8,7 @@ import type { IFluidHandle } from "@fluidframework/core-interfaces";
 import type { ITreeCursor } from "../../core/index.js";
 import type { TreeLeafValue, ImplicitAllowedTypes } from "../schemaTypes.js";
 import type { TreeNodeSchema } from "../core/index.js";
-import { customFromCursorInner, type EncodeOptions } from "./customTree.js";
+import { customFromCursor, type EncodeOptions } from "./customTree.js";
 import { getUnhydratedContext } from "../createContext.js";
 
 /**
@@ -55,5 +55,5 @@ function conciseFromCursorInner<TCustom>(
 	options: Required<EncodeOptions<TCustom>>,
 	schema: ReadonlyMap<string, TreeNodeSchema>,
 ): ConciseTree<TCustom> {
-	return customFromCursorInner(reader, options, schema, conciseFromCursorInner);
+	return customFromCursor(reader, options, schema, conciseFromCursorInner);
 }

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

@@ -32,6 +32,7 @@ import { isFieldInSchema } from "../../feature-libraries/index.js";
 import { toStoredSchema } from "../toStoredSchema.js";
 import { inSchemaOrThrow, mapTreeFromNodeData } from "../toMapTree.js";
 import { getUnhydratedContext } from "../createContext.js";
+import { createUnknownOptionalFieldPolicy } from "../objectNode.js";
 
 /**
  * Construct tree content that is compatible with the field defined by the provided `schema`.
@@ -122,7 +123,10 @@ export function createFromCursor<const TSchema extends ImplicitFieldSchema>(
 	const flexSchema = context.flexContext.schema;
 
 	const schemaValidationPolicy: SchemaAndPolicy = {
-		policy: defaultSchemaPolicy,
+		policy: {
+			...defaultSchemaPolicy,
+			allowUnknownOptionalFields: createUnknownOptionalFieldPolicy(schema),
+		},
 		schema: context.flexContext.schema,
 	};