@fluidframework/tree 2.1.0-276985 → 2.1.0

package/src/feature-libraries/modular-schema/modularChangeFormat.ts

@@ -130,6 +130,8 @@ export const EncodedModularChangeset = Type.Object(
 		maxId: Type.Optional(ChangesetLocalIdSchema),
 		changes: EncodedFieldChangeMap,
 		revisions: Type.ReadonlyOptional(Type.Array(EncodedRevisionInfo)),
+		// TODO#8574: separating `builds` and `refreshers` here means that we encode their `EncodedBuilds.trees` separately.
+		// This can lead to a less efficient wire representation because of duplicated schema/shape information.
 		builds: Type.Optional(EncodedBuilds),
 		refreshers: Type.Optional(EncodedBuilds),
 		/**

package/src/feature-libraries/modular-schema/modularChangeTypes.ts

@@ -3,6 +3,7 @@
  * Licensed under the MIT License.
  */
 
+import type { BTree } from "@tylerbu/sorted-btree-es6";
 import type {
 	ChangeAtomId,
 	ChangeAtomIdMap,
@@ -10,9 +11,11 @@ import type {
 	FieldKey,
 	FieldKindIdentifier,
 	RevisionInfo,
+	RevisionTag,
 } from "../../core/index.js";
 import type { Brand } from "../../util/index.js";
 import type { TreeChunk } from "../chunked-forest/index.js";
+import type { CrossFieldTarget } from "./crossFieldQueries.js";
 
 /**
  * @internal
@@ -30,13 +33,61 @@ export interface ModularChangeset extends HasFieldChanges {
 	 */
 	readonly revisions?: readonly RevisionInfo[];
 	readonly fieldChanges: FieldChangeMap;
+
+	/**
+	 * Maps from this changeset's canonical ID for a node (see comment on node aliases) to the changes for that node.
+	 */
 	readonly nodeChanges: ChangeAtomIdMap<NodeChangeset>;
+
+	/**
+	 * Maps from this changeset's canonical ID for a node to the ID for the field which contains that node.
+	 */
+	// TODO: Should this be merged with `nodeChanges`?
+	readonly nodeToParent: ChangeAtomIdMap<FieldId>;
+
+	/**
+	 * Maps from a node ID to another ID for the same node.
+	 * If a node ID used in this changeset has no entry in this table, then it is the canonical ID for that node.
+	 * The aliases form a set of trees, where the root of each tree is a canonical ID.
+	 *
+	 * When composing changesets with different canonical IDs for the same node,
+	 * one of those IDs becomes the canonical ID for the composition, while the other is added to this table as an alias.
+	 *
+	 * Node aliases are preserved when composing changesets so we can avoid having to find and update all changed node IDs
+	 * in the field IDs in nodeToParent and crossFieldKeys.
+	 */
+	readonly nodeAliases: ChangeAtomIdMap<NodeId>;
+	readonly crossFieldKeys: CrossFieldKeyTable;
 	readonly constraintViolationCount?: number;
 	readonly builds?: ChangeAtomIdMap<TreeChunk>;
 	readonly destroys?: ChangeAtomIdMap<number>;
 	readonly refreshers?: ChangeAtomIdMap<TreeChunk>;
 }
 
+export type TupleBTree<K, V> = Brand<BTree<K, V>, "TupleBTree">;
+export type CrossFieldKeyTable = TupleBTree<CrossFieldKeyRange, FieldId>;
+export type CrossFieldKeyRange = readonly [
+	CrossFieldTarget,
+	RevisionTag | undefined,
+	ChangesetLocalId,
+	/**
+	 * The length of this range.
+	 * TODO: This does not need to be part of the key and could be part of the value instead.
+	 */
+	number,
+];
+
+export type CrossFieldKey = readonly [
+	CrossFieldTarget,
+	RevisionTag | undefined,
+	ChangesetLocalId,
+];
+
+export interface FieldId {
+	readonly nodeId: NodeId | undefined;
+	readonly field: FieldKey;
+}
+
 /**
  * @internal
  */

package/src/feature-libraries/node-key/index.ts

@@ -10,7 +10,6 @@ export {
 	type StableNodeKey,
 	nodeKeyTreeIdentifier,
 } from "./nodeKey.js";
-export { NodeKeyIndex } from "./nodeKeyIndex.js";
 export {
 	createNodeKeyManager,
 	isStableNodeKey,

package/src/feature-libraries/object-forest/objectForest.ts

@@ -94,6 +94,7 @@ export class ObjectForest implements IEditableForest {
 
 	public constructor(
 		public readonly anchors: AnchorSet = new AnchorSet(),
+		public readonly additionalAsserts: boolean = false,
 		roots?: MapTree,
 	) {
 		this.#roots =
@@ -117,7 +118,7 @@ export class ObjectForest implements IEditableForest {
 	}
 
 	public clone(_: TreeStoredSchemaSubscription, anchors: AnchorSet): ObjectForest {
-		return new ObjectForest(anchors, this.roots);
+		return new ObjectForest(anchors, this.additionalAsserts, this.roots);
 	}
 
 	public forgetAnchor(anchor: Anchor): void {
@@ -554,6 +555,9 @@ class Cursor extends SynchronousCursor implements ITreeSubscriptionCursor {
 /**
  * @returns an implementation of {@link IEditableForest} with no data or schema.
  */
-export function buildForest(anchors?: AnchorSet): ObjectForest {
-	return new ObjectForest(anchors);
+export function buildForest(
+	anchors?: AnchorSet,
+	additionalAsserts: boolean = false,
+): ObjectForest {
+	return new ObjectForest(anchors, additionalAsserts);
 }

package/src/feature-libraries/optional-field/optionalField.ts

@@ -713,6 +713,7 @@ export const optionalChangeHandler: FieldChangeHandler<
 	getNestedChanges,
 
 	createEmpty: () => ({ moves: [], childChanges: [] }),
+	getCrossFieldKeys: (_change) => [],
 };
 
 function getNestedChanges(change: OptionalChangeset): [NodeId, number | undefined][] {

package/src/feature-libraries/sequence-field/index.ts

@@ -42,8 +42,6 @@ export { compose } from "./compose.js";
 export {
 	getInputLength,
 	isDetach,
-	newCrossFieldTable,
-	type CrossFieldTable,
 	cloneMark,
 	extractMarkEffect,
 } from "./utils.js";

package/src/feature-libraries/sequence-field/invert.ts

@@ -194,7 +194,6 @@ function invertMark(
 			return applyMovedChanges(invertedMark, mark.revision, crossFieldManager);
 		}
 		case "AttachAndDetach": {
-			// Which should get the child change? Don't want to invert twice
 			const attach: Mark = {
 				count: mark.count,
 				cellId: mark.cellId,
@@ -294,6 +293,7 @@ function applyMovedChanges(
 	}
 
 	if (entry.value !== undefined) {
+		manager.onMoveIn(entry.value);
 		return [withNodeChange<CellMark<MoveOut>, MoveOut>(mark, entry.value)];
 	}
 

package/src/feature-libraries/sequence-field/rebase.ts

@@ -270,6 +270,7 @@ function rebaseMark(
 			0x8dc /* Unexpected collision of new node changes */,
 		);
 		rebasedMark.changes = movedNodeChanges;
+		moveEffects.onMoveIn(movedNodeChanges);
 	}
 
 	return rebaseMarkIgnoreChild(rebasedMark, baseMark, moveEffects);
@@ -514,7 +515,12 @@ function getMovedEffect(
 ): MarkEffect | undefined {
 	const effect = getMoveEffect(moveEffects, CrossFieldTarget.Destination, revision, id, count);
 	assert(effect.length === count, 0x6f3 /* Expected effect to cover entire mark */);
-	return effect.value?.movedEffect;
+	const movedEffect = effect.value?.movedEffect;
+	if (movedEffect !== undefined && movedEffect.type === "MoveOut") {
+		moveEffects.moveKey(CrossFieldTarget.Source, movedEffect.revision, movedEffect.id, count);
+	}
+
+	return movedEffect;
 }
 
 function getMovedChangesFromBaseMark(

package/src/feature-libraries/sequence-field/sequenceFieldChangeHandler.ts

@@ -11,7 +11,7 @@ import { sequenceFieldChangeCodecFactory } from "./sequenceFieldCodecs.js";
 import { type SequenceFieldEditor, sequenceFieldEditor } from "./sequenceFieldEditor.js";
 import { sequenceFieldToDelta } from "./sequenceFieldToDelta.js";
 import type { Changeset } from "./types.js";
-import { createEmpty, getNestedChanges, isEmpty } from "./utils.js";
+import { createEmpty, getCrossFieldKeys, getNestedChanges, isEmpty } from "./utils.js";
 
 export type SequenceFieldChangeHandler = FieldChangeHandler<Changeset, SequenceFieldEditor>;
 
@@ -24,4 +24,5 @@ export const sequenceFieldChangeHandler: SequenceFieldChangeHandler = {
 	isEmpty,
 	getNestedChanges,
 	createEmpty,
+	getCrossFieldKeys,
 };

package/src/feature-libraries/sequence-field/utils.ts

@@ -13,20 +13,11 @@ import {
 	areEqualChangeAtomIds,
 	makeChangeAtomId,
 } from "../../core/index.js";
+import { type Mutable, brand, fail } from "../../util/index.js";
 import {
-	type Mutable,
-	type RangeMap,
-	brand,
-	fail,
-	getFromRangeMap,
-} from "../../util/index.js";
-import {
-	type CrossFieldManager,
-	type CrossFieldQuerySet,
 	CrossFieldTarget,
 	type NodeId,
-	addCrossFieldQuery,
-	setInCrossFieldMap,
+	type CrossFieldKeyRange,
 } from "../modular-schema/index.js";
 
 import type {
@@ -47,7 +38,6 @@ import {
 	type Insert,
 	type Mark,
 	type MarkEffect,
-	type MoveId,
 	type MoveIn,
 	type MoveOut,
 	type NoopMark,
@@ -708,79 +698,6 @@ function tryMergeEffects(
 	return undefined;
 }
 
-/**
- * @internal
- */
-export interface CrossFieldTable<T = unknown> extends CrossFieldManager<T> {
-	srcQueries: CrossFieldQuerySet;
-	dstQueries: CrossFieldQuerySet;
-	isInvalidated: boolean;
-	mapSrc: Map<RevisionTag | undefined, RangeMap<T>>;
-	mapDst: Map<RevisionTag | undefined, RangeMap<T>>;
-	reset: () => void;
-}
-
-/**
- * @internal
- */
-export function newCrossFieldTable<T = unknown>(): CrossFieldTable<T> {
-	const srcQueries: CrossFieldQuerySet = new Map();
-	const dstQueries: CrossFieldQuerySet = new Map();
-	const mapSrc: Map<RevisionTag | undefined, RangeMap<T>> = new Map();
-	const mapDst: Map<RevisionTag | undefined, RangeMap<T>> = new Map();
-
-	const getMap = (target: CrossFieldTarget): Map<RevisionTag | undefined, RangeMap<T>> =>
-		target === CrossFieldTarget.Source ? mapSrc : mapDst;
-
-	const getQueries = (target: CrossFieldTarget): CrossFieldQuerySet =>
-		target === CrossFieldTarget.Source ? srcQueries : dstQueries;
-
-	const table = {
-		srcQueries,
-		dstQueries,
-		isInvalidated: false,
-		mapSrc,
-		mapDst,
-
-		get: (
-			target: CrossFieldTarget,
-			revision: RevisionTag | undefined,
-			id: MoveId,
-			count: number,
-			addDependency: boolean,
-		) => {
-			if (addDependency) {
-				addCrossFieldQuery(getQueries(target), revision, id, count);
-			}
-			return getFromRangeMap(getMap(target).get(revision) ?? [], id, count);
-		},
-		set: (
-			target: CrossFieldTarget,
-			revision: RevisionTag | undefined,
-			id: MoveId,
-			count: number,
-			value: T,
-			invalidateDependents: boolean,
-		) => {
-			if (
-				invalidateDependents &&
-				getFromRangeMap(getQueries(target).get(revision) ?? [], id, count) !== undefined
-			) {
-				table.isInvalidated = true;
-			}
-			setInCrossFieldMap(getMap(target), revision, id, count, value);
-		},
-
-		reset: () => {
-			table.isInvalidated = false;
-			table.srcQueries.clear();
-			table.dstQueries.clear();
-		},
-	};
-
-	return table;
-}
-
 /**
  * Splits the `mark` into two marks such that the first returned mark has length `length`.
  * @param mark - The mark to split.
@@ -969,3 +886,38 @@ export function getEndpoint(effect: MoveMarkEffect): ChangeAtomId {
 			}
 		: { revision: effect.revision, localId: effect.id };
 }
+
+export function getCrossFieldKeys(change: Changeset): CrossFieldKeyRange[] {
+	const keys: CrossFieldKeyRange[] = [];
+	for (const mark of change) {
+		keys.push(...getCrossFieldKeysForMarkEffect(mark, mark.count));
+	}
+
+	return keys;
+}
+
+function getCrossFieldKeysForMarkEffect(
+	effect: MarkEffect,
+	count: number,
+): CrossFieldKeyRange[] {
+	switch (effect.type) {
+		case "Insert":
+			// An insert behaves like a move where the source and destination are at the same location.
+			// An insert can become a move when after rebasing.
+			return [
+				[CrossFieldTarget.Source, effect.revision, effect.id, count],
+				[CrossFieldTarget.Destination, effect.revision, effect.id, count],
+			];
+		case "MoveOut":
+			return [[CrossFieldTarget.Source, effect.revision, effect.id, count]];
+		case "MoveIn":
+			return [[CrossFieldTarget.Destination, effect.revision, effect.id, count]];
+		case "AttachAndDetach":
+			return [
+				...getCrossFieldKeysForMarkEffect(effect.attach, count),
+				...getCrossFieldKeysForMarkEffect(effect.detach, count),
+			];
+		default:
+			return [];
+	}
+}

package/src/feature-libraries/typed-schema/typedTreeSchema.ts

@@ -19,6 +19,7 @@ import {
 	type TreeStoredSchema,
 	type TreeTypeSet,
 	type ValueSchema,
+	identifierFieldKindIdentifier,
 } from "../../core/index.js";
 import {
 	type Assume,
@@ -28,6 +29,7 @@ import {
 	mapIterable,
 	oneFromSet,
 	type requireAssignableTo,
+	filterIterable,
 } from "../../util/index.js";
 import { FieldKinds } from "../default-schema/index.js";
 import type { FlexFieldKind, FullSchemaPolicy } from "../modular-schema/index.js";
@@ -154,6 +156,7 @@ export class FlexObjectNodeSchema<
 	const out Specification extends Unenforced<FlexObjectNodeFields> = FlexObjectNodeFields,
 > extends TreeNodeSchemaBase<Name, Specification> {
 	protected _typeCheck2?: MakeNominal;
+	public readonly identifierFieldKeys: readonly FieldKey[] = [];
 
 	public static create<
 		const Name extends string,
@@ -192,6 +195,13 @@ export class FlexObjectNodeSchema<
 	) {
 		const fields = mapIterable(objectNodeFields, ([k, v]) => [k, v.stored] as const);
 		super(builder, name, info, new ObjectNodeStoredSchema(new Map(fields)));
+		this.identifierFieldKeys = Array.from(
+			filterIterable(
+				objectNodeFields.entries(),
+				([k, f]) => f.kind.identifier === identifierFieldKindIdentifier,
+			),
+			([k]) => k,
+		);
 	}
 
 	public override getFieldSchema(field: FieldKey): FlexFieldSchema {

package/src/index.ts

@@ -358,7 +358,6 @@ export {
 	type FlexTreeUnboxField,
 	type FlexTreeUnboxNode,
 	type FlexTreeUnboxNodeUnion,
-	type FlexTreeNodeKeyField,
 	type IsArrayOfOne,
 	type FlexibleNodeSubSequence,
 	flexTreeMarker,

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/tree";
-export const pkgVersion = "2.1.0-276985";
+export const pkgVersion = "2.1.0";

package/src/shared-tree/schematizingTreeView.ts

@@ -39,7 +39,7 @@ import {
 	mapTreeFromNodeData,
 	prepareContentForHydration,
 } from "../simple-tree/index.js";
-import { disposeSymbol } from "../util/index.js";
+import { Breakable, breakingClass, disposeSymbol, type WithBreakable } from "../util/index.js";
 
 import { canInitialize, ensureSchema, initialize } from "./schematizeTree.js";
 import type { TreeCheckout } from "./treeCheckout.js";
@@ -48,8 +48,9 @@ import { CheckoutFlexTreeView } from "./treeView.js";
 /**
  * Implementation of TreeView wrapping a FlexTreeView.
  */
+@breakingClass
 export class SchematizingSimpleTreeView<in out TRootSchema extends ImplicitFieldSchema>
-	implements TreeView<TRootSchema>
+	implements TreeView<TRootSchema>, WithBreakable
 {
 	/**
 	 * The view is set to undefined when this object is disposed or the view schema does not support viewing the document's stored schema.
@@ -86,6 +87,7 @@ export class SchematizingSimpleTreeView<in out TRootSchema extends ImplicitField
 		public readonly checkout: TreeCheckout,
 		public readonly config: TreeViewConfiguration<TRootSchema>,
 		public readonly nodeKeyManager: NodeKeyManager,
+		public readonly breaker: Breakable = new Breakable("SchematizingSimpleTreeView"),
 	) {
 		const policy = {
 			...defaultSchemaPolicy,
@@ -306,6 +308,7 @@ export class SchematizingSimpleTreeView<in out TRootSchema extends ImplicitField
 	}
 
 	public get root(): TreeFieldFromImplicitField<TRootSchema> {
+		this.breaker.use();
 		if (!this.compatibility.canView) {
 			throw new UsageError(
 				"Document is out of schema. Check TreeView.compatibility before accessing TreeView.root.",
@@ -316,6 +319,7 @@ export class SchematizingSimpleTreeView<in out TRootSchema extends ImplicitField
 	}
 
 	public set root(newRoot: InsertableTreeFieldFromImplicitField<TRootSchema>) {
+		this.breaker.use();
 		if (!this.compatibility.canView) {
 			throw new UsageError(
 				"Document is out of schema. Check TreeView.compatibility before accessing TreeView.root.",

package/src/shared-tree/sharedTree.ts

@@ -64,6 +64,7 @@ import type { SharedTreeChange } from "./sharedTreeChangeTypes.js";
 import type { SharedTreeEditBuilder } from "./sharedTreeEditBuilder.js";
 import { type CheckoutEvents, type TreeCheckout, createTreeCheckout } from "./treeCheckout.js";
 import type { CheckoutFlexTreeView, FlexTreeView } from "./treeView.js";
+import { breakingClass, throwIfBroken } from "../util/index.js";
 
 /**
  * Copy of data from an {@link ISharedTree} at some point in time.
@@ -162,6 +163,7 @@ function getCodecVersions(formatVersion: number): ExplicitCodecVersions {
  *
  * TODO: detail compatibility requirements.
  */
+@breakingClass
 export class SharedTree
 	extends SharedTreeCore<SharedTreeEditBuilder, SharedTreeChange>
 	implements ISharedTree
@@ -191,7 +193,9 @@ export class SharedTree
 		const forest =
 			options.forest === ForestType.Optimized
 				? buildChunkedForest(makeTreeChunker(schema, defaultSchemaPolicy))
-				: buildForest();
+				: options.forest === ForestType.Reference
+					? buildForest()
+					: buildForest(undefined, true);
 		const revisionTagCodec = new RevisionTagCodec(runtime.idCompressor);
 		const removedRoots = makeDetachedFieldIndex(
 			"repair",
@@ -288,6 +292,7 @@ export class SharedTree
 		);
 	}
 
+	@throwIfBroken
 	public contentSnapshot(): SharedTreeContentSnapshot {
 		const cursor = this.checkout.forest.allocateCursor("contentSnapshot");
 		try {
@@ -326,11 +331,13 @@ export class SharedTree
 			this.checkout,
 			config,
 			createNodeKeyManager(this.runtime.idCompressor),
+			this.breaker,
 		);
 	}
 
 	protected override async loadCore(services: IChannelStorageService): Promise<void> {
 		await super.loadCore(services);
+		this.checkout.setTipRevisionForLoadedData(this.trunkHeadRevision);
 		this._events.emit("afterBatch");
 	}
 }
@@ -419,6 +426,10 @@ export enum ForestType {
 	 * The "ChunkedForest" forest type.
 	 */
 	Optimized = 1,
+	/**
+	 * The "ObjectForest" forest type with expensive asserts for debugging.
+	 */
+	Expensive = 2,
 }
 
 export const defaultSharedTreeOptions: Required<SharedTreeOptions> = {

package/src/shared-tree/sharedTreeChangeEnricher.ts

@@ -87,7 +87,7 @@ export class SharedTreeMutableChangeEnricher
 				case "data": {
 					const delta = intoDelta(tagChange(dataOrSchemaChange.innerChange, revision));
 					const visitor = this.forest.acquireVisitor();
-					visitDelta(delta, visitor, this.removedRoots);
+					visitDelta(delta, visitor, this.removedRoots, revision);
 					visitor.free();
 					break;
 				}

package/src/shared-tree/treeApi.ts

@@ -455,7 +455,7 @@ function runTransactionInCheckout<TResult>(
 			case "nodeInDocument": {
 				const node = getFlexNode(constraint.node);
 				assert(
-					node.treeStatus() === TreeStatus.InDocument,
+					treeApi.status(constraint.node) === TreeStatus.InDocument,
 					0x90f /* Attempted to apply "nodeExists" constraint when building a transaction, but the node is not in the document. */,
 				);
 				checkout.editor.addNodeExistsConstraint(node.anchorNode);

package/src/shared-tree/treeCheckout.ts

@@ -387,6 +387,11 @@ export class TreeCheckout implements ITreeCheckoutFork {
 		SharedTreeBranch<SharedTreeEditBuilder, SharedTreeChange>
 	>();
 
+	/**
+	 * copies of the removed roots used as snapshots for reverting to previous state when transactions are aborted
+	 */
+	private readonly removedRootsSnapshots: DetachedFieldIndex[] = [];
+
 	/**
 	 * The name of the telemetry event logged for calls to {@link TreeCheckout.revertRevertible}.
 	 * @privateRemarks Exposed for testing purposes.
@@ -405,7 +410,7 @@ export class TreeCheckout implements ITreeCheckoutFork {
 		private readonly mintRevisionTag: () => RevisionTag,
 		private readonly revisionTagCodec: RevisionTagCodec,
 		private readonly idCompressor: IIdCompressor,
-		private readonly removedRoots: DetachedFieldIndex = makeDetachedFieldIndex(
+		private removedRoots: DetachedFieldIndex = makeDetachedFieldIndex(
 			"repair",
 			revisionTagCodec,
 			idCompressor,
@@ -413,18 +418,38 @@ export class TreeCheckout implements ITreeCheckoutFork {
 		/** Optional logger for telemetry. */
 		private readonly logger?: ITelemetryLoggerExt,
 	) {
+		// when a transaction is started, take a snapshot of the current state of removed roots
+		branch.on("transactionStarted", () => {
+			this.removedRootsSnapshots.push(this.removedRoots.clone());
+		});
+		// when a transaction is committed, the latest snapshot of removed roots can be discarded
+		branch.on("transactionCommitted", () => {
+			this.removedRootsSnapshots.pop();
+		});
+		// after a transaction is rolled back, revert removed roots back to the latest snapshot
+		branch.on("transactionRolledBack", () => {
+			const snapshot = this.removedRootsSnapshots.pop();
+			assert(snapshot !== undefined, 0x9ae /* a snapshot for removed roots does not exist */);
+			this.removedRoots = snapshot;
+		});
+
 		// We subscribe to `beforeChange` rather than `afterChange` here because it's possible that the change is invalid WRT our forest.
 		// For example, a bug in the editor might produce a malformed change object and thus applying the change to the forest will throw an error.
 		// In such a case we will crash here, preventing the change from being added to the commit graph, and preventing `afterChange` from firing.
 		// One important consequence of this is that we will not submit the op containing the invalid change, since op submissions happens in response to `afterChange`.
 		branch.on("beforeChange", (event) => {
 			if (event.change !== undefined) {
+				const revision =
+					event.type === "replace"
+						? event.newCommits[event.newCommits.length - 1].revision
+						: event.change.revision;
+
 				// Conflicts due to schema will be empty and thus are not applied.
 				for (const change of event.change.change.changes) {
 					if (change.type === "data") {
-						const delta = intoDelta(tagChange(change.innerChange, event.change.revision));
+						const delta = intoDelta(tagChange(change.innerChange, revision));
 						this.withCombinedVisitor((visitor) => {
-							visitDelta(delta, visitor, this.removedRoots);
+							visitDelta(delta, visitor, this.removedRoots, revision);
 						});
 					} else if (change.type === "schema") {
 						// Schema changes from a current to a new schema are expected to be backwards compatible.
@@ -518,6 +543,24 @@ export class TreeCheckout implements ITreeCheckoutFork {
 			this.events.emit("commitApplied", data, getRevertible);
 			withinEventContext = false;
 		});
+
+		// When the branch is trimmed, we can garbage collect any repair data whose latest relevant revision is one of the
+		// trimmed revisions.
+		branch.on("ancestryTrimmed", (revisions) => {
+			this.withCombinedVisitor((visitor) => {
+				revisions.forEach((revision) => {
+					// get all the roots last created or used by the revision
+					const roots = this.removedRoots.getRootsLastTouchedByRevision(revision);
+
+					// get the detached field for the root and delete it from the removed roots
+					for (const root of roots) {
+						visitor.destroy(this.removedRoots.toFieldKey(root), 1);
+					}
+
+					this.removedRoots.deleteRootsLastTouchedByRevision(revision);
+				});
+			});
+		});
 	}
 
 	private withCombinedVisitor(fn: (visitor: DeltaVisitor) => void): void {
@@ -572,6 +615,10 @@ export class TreeCheckout implements ITreeCheckoutFork {
 
 	public rebase(view: TreeCheckout): void {
 		this.checkNotDisposed();
+		assert(
+			!view.transaction.inProgress(),
+			0x9af /* A view cannot be rebased while it has a pending transaction */,
+		);
 		view.branch.rebaseOnto(this.branch);
 	}
 
@@ -585,8 +632,8 @@ export class TreeCheckout implements ITreeCheckoutFork {
 	public merge(view: TreeCheckout, disposeView = true): void {
 		this.checkNotDisposed();
 		assert(
-			!this.transaction.inProgress() || disposeView,
-			0x710 /* A view that is merged into an in-progress transaction must be disposed */,
+			!this.transaction.inProgress(),
+			0x9b0 /* Views cannot be merged into a view while it has a pending transaction */,
 		);
 		while (view.transaction.inProgress()) {
 			view.transaction.commit();
@@ -625,6 +672,14 @@ export class TreeCheckout implements ITreeCheckoutFork {
 		return trees;
 	}
 
+	/**
+	 * This sets the tip revision as the latest relevant revision for any removed roots that are loaded from a summary.
+	 * This needs to be called right after loading {@link this.removedRoots} from a summary to allow loaded data to be garbage collected.
+	 */
+	public setTipRevisionForLoadedData(revision: RevisionTag): void {
+		this.removedRoots.setRevisionsForLoadedData(revision);
+	}
+
 	private purgeRevertibles(): void {
 		for (const revertible of this.revertibles) {
 			revertible.dispose();

package/src/shared-tree/treeView.ts

@@ -12,6 +12,7 @@ import {
 	type NodeKeyManager,
 	getTreeContext,
 } from "../feature-libraries/index.js";
+import { tryDisposeTreeNode } from "../simple-tree/index.js";
 import { type IDisposable, disposeSymbol } from "../util/index.js";
 
 import type { ITreeCheckout, ITreeCheckoutFork, TreeCheckout } from "./treeCheckout.js";
@@ -94,6 +95,10 @@ export class CheckoutFlexTreeView<
 	}
 
 	public [disposeSymbol](): void {
+		for (const anchorNode of this.checkout.forest.anchors) {
+			tryDisposeTreeNode(anchorNode);
+		}
+
 		this.context[disposeSymbol]();
 		this.onDispose?.();
 	}