@fluidframework/tree 2.115.0 → 2.116.0

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

@@ -12,7 +12,6 @@ import {
 	type RevisionInfo,
 	type RevisionTag,
 	type TaggedChange,
-	type TreeChunk,
 } from "../../core/index.js";
 import { brand, type Mutable, type RangeQueryResult } from "../../util/index.js";
 import {
@@ -33,12 +32,9 @@ import type { FlexFieldKind } from "./fieldKind.js";
 import { genericFieldKind } from "./genericFieldKind.js";
 import {
 	newCrossFieldKeyTable,
-	type CrossFieldKeyTable,
 	type FieldChange,
 	type FieldChangeMap,
-	type FieldId,
 	type ModularChangeset,
-	type NoChangeConstraint,
 	type NodeChangeset,
 	type NodeId,
 } from "./modularChangeTypes.js";
@@ -47,22 +43,17 @@ export function hasConflicts(change: ModularChangeset): boolean {
 	return (change.constraintViolationCount ?? 0) > 0;
 }
 
-export function makeModularChangeset(props?: {
-	fieldChanges?: FieldChangeMap;
-	nodeChanges?: ChangeAtomIdBTree<NodeChangeset>;
-	nodeToParent?: ChangeAtomIdBTree<FieldId>;
-	nodeAliases?: ChangeAtomIdBTree<NodeId>;
-	crossFieldKeys?: CrossFieldKeyTable;
-	maxId: number;
-	revisions?: readonly RevisionInfo[];
-	constraintViolationCount?: number;
-	noChangeConstraint?: NoChangeConstraint;
-	noChangeConstraintOnRevert?: NoChangeConstraint;
-	builds?: ChangeAtomIdBTree<TreeChunk>;
-	destroys?: ChangeAtomIdBTree<number>;
-	refreshers?: ChangeAtomIdBTree<TreeChunk>;
-}): ModularChangeset {
-	const p = props ?? { maxId: -1 };
+/**
+ * Creates a normalized changeset from the provided properties.
+ *
+ * Required changeset maps are initialized when omitted, and empty optional properties are not
+ * included in the returned changeset. `maxId` accepts an unbranded allocator ID; `undefined`
+ * indicates that the changeset contains no IDs.
+ */
+export function makeModularChangeset(
+	props: Partial<Omit<ModularChangeset, "maxId">> & { maxId?: number } = {},
+): ModularChangeset {
+	const p = props;
 	const changeset: Mutable<ModularChangeset> = {
 		fieldChanges: p.fieldChanges ?? new Map<FieldKey, FieldChange>(),
 		nodeChanges: p.nodeChanges ?? newChangeAtomIdBTree(),
@@ -74,7 +65,7 @@ export function makeModularChangeset(props?: {
 	if (p.revisions !== undefined && p.revisions.length > 0) {
 		changeset.revisions = p.revisions;
 	}
-	if (p.maxId >= 0) {
+	if (p.maxId !== undefined && p.maxId >= 0) {
 		changeset.maxId = brand(p.maxId);
 	}
 	if (p.constraintViolationCount !== undefined && p.constraintViolationCount > 0) {

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

@@ -38,6 +38,7 @@ import {
 	aboveRootPlaceholder,
 	combineVisitors,
 	deepCopyMapTree,
+	makeBreakingVisitor,
 	rootFieldKey,
 } from "../../core/index.js";
 import {
@@ -90,6 +91,7 @@ export class ObjectForest implements IEditableForest, WithBreakable {
 
 	readonly #roots: MutableMapTree;
 	public get roots(): MapTree {
+		this.breaker.use();
 		return this.#roots;
 	}
 
@@ -117,10 +119,12 @@ export class ObjectForest implements IEditableForest, WithBreakable {
 	}
 
 	public get isEmpty(): boolean {
+		this.breaker.use();
 		return this.roots.fields.size === 0;
 	}
 
 	public clone(schema: TreeStoredSchemaSubscription, breaker?: Breakable): ObjectForest {
+		this.breaker.use();
 		return new ObjectForest(
 			breaker ?? this.breaker,
 			schema,
@@ -131,6 +135,7 @@ export class ObjectForest implements IEditableForest, WithBreakable {
 	}
 
 	public chunkField(cursor: ITreeCursorSynchronous): TreeChunk[] {
+		this.breaker.use();
 		return chunkField(cursor, { idCompressor: undefined, policy: defaultChunkPolicy });
 	}
 
@@ -174,6 +179,7 @@ export class ObjectForest implements IEditableForest, WithBreakable {
 	}
 
 	public acquireVisitor(): DeltaVisitor {
+		this.breaker.use();
 		assert(
 			this.activeVisitor === undefined,
 			0x76c /* Must release existing visitor before acquiring another */,
@@ -228,10 +234,17 @@ export class ObjectForest implements IEditableForest, WithBreakable {
 			}
 			public destroy(detachedField: FieldKey, count: number): void {
 				preEdit();
+				const field = this.forest.#roots.fields.get(detachedField);
+				assert(field !== undefined, 0xd28 /* Destroyed field must exist */);
+				assert(field.length === count, 0xd29 /* Destroy count must match field length */);
 				this.forest.delete(detachedField);
 			}
 			public create(content: readonly ITreeCursorSynchronous[], destination: FieldKey): void {
 				preEdit();
+				assert(
+					!this.forest.#roots.fields.has(destination),
+					0xd2a /* Create destination must be a new empty field */,
+				);
 				this.forest.add(content, destination);
 				this.forest.#events.emit("afterRootFieldCreated", destination);
 			}
@@ -253,22 +266,24 @@ export class ObjectForest implements IEditableForest, WithBreakable {
 			 */
 			private attachEdit(source: FieldKey, count: number, destination: PlaceIndex): void {
 				assertNonNegativeSafeInteger(count);
-				if (count === 0) {
-					return;
-				}
 				const [parent, key] = cursor.getParent();
 				assert(
 					parent !== this.forest.roots || key !== source,
-					0x7b6 /* Attach source field must be different from current field */,
+					0xd2b /* Attach source field must be different from current field */,
 				);
-				const currentField = getOrCreateField(parent, key);
-				assertValidIndex(destination, currentField, true);
-				const sourceField = this.forest.#roots.fields.get(source) ?? [];
-				assert(sourceField !== undefined, 0x7b7 /* Attach source field must exist */);
+				const sourceField = this.forest.#roots.fields.get(source);
+				assert(sourceField !== undefined, 0xd2c /* Attach source field must exist */);
 				assert(
 					sourceField.length === count,
-					0x7b8 /* Attach must consume all nodes in source field */,
+					0xd2d /* Attach must consume all nodes in source field */,
+				);
+				const existingDestinationField = parent.fields.get(key) ?? [];
+				assert(
+					destination <= existingDestinationField.length,
+					0xd2e /* Attach destination must not exceed field length */,
 				);
+				assertValidIndex(destination, existingDestinationField, true);
+				const currentField = getOrCreateField(parent, key);
 				// TODO: this will fail for very large insertions due to argument limits.
 				currentField.splice(destination, 0, ...sourceField);
 				this.forest.delete(source);
@@ -284,10 +299,21 @@ export class ObjectForest implements IEditableForest, WithBreakable {
 				const [parent, key] = cursor.getParent();
 				assert(
 					destination === undefined || parent !== this.forest.roots || key !== destination,
-					0x7b9 /* Detach destination field must be different from current field */,
+					0xd2f /* Detach destination field must be different from current field */,
+				);
+				const currentField = parent.fields.get(key) ?? [];
+				assert(source.start <= source.end, 0xd30 /* Detach range start must not exceed end */);
+				assert(
+					source.end <= currentField.length,
+					0xd31 /* Detach range must not exceed field length */,
 				);
-				const currentField = getOrCreateField(parent, key);
 				assertValidRange(source, currentField);
+				if (destination !== undefined) {
+					assert(
+						!this.forest.#roots.fields.has(destination),
+						0xd32 /* Detach destination must be a new empty field */,
+					);
+				}
 				const content = currentField.splice(source.start, source.end - source.start);
 				if (destination !== undefined) {
 					this.forest.addFieldAsDetached(content, destination);
@@ -317,9 +343,12 @@ export class ObjectForest implements IEditableForest, WithBreakable {
 		for (const getVisitor of this.deltaVisitors) {
 			announcedVisitors.push(getVisitor());
 		}
-		const combinedVisitor = combineVisitors([forestVisitor, ...announcedVisitors]);
-		this.activeVisitor = combinedVisitor;
-		return combinedVisitor;
+		const visitor = combineVisitors([
+			makeBreakingVisitor(forestVisitor, this.breaker),
+			...announcedVisitors,
+		]);
+		this.activeVisitor = visitor;
+		return visitor;
 	}
 
 	public registerAnnouncedVisitor(visitor: () => AnnouncedVisitor): void {
@@ -354,6 +383,7 @@ export class ObjectForest implements IEditableForest, WithBreakable {
 	}
 
 	public allocateCursor(source?: string): Cursor {
+		this.breaker.use();
 		return new Cursor(this, source);
 	}
 
@@ -361,6 +391,7 @@ export class ObjectForest implements IEditableForest, WithBreakable {
 		destination: Anchor,
 		cursorToMove: ITreeSubscriptionCursor,
 	): TreeNavigationResult {
+		this.breaker.use();
 		const path = this.anchors.locate(destination);
 		if (path === undefined) {
 			return TreeNavigationResult.NotFound;
@@ -373,6 +404,7 @@ export class ObjectForest implements IEditableForest, WithBreakable {
 		destination: FieldAnchor,
 		cursorToMove: ITreeSubscriptionCursor,
 	): TreeNavigationResult {
+		this.breaker.use();
 		if (destination.parent === undefined) {
 			this.moveCursorToPath(undefined, cursorToMove);
 		} else {
@@ -389,6 +421,7 @@ export class ObjectForest implements IEditableForest, WithBreakable {
 		destination: UpPath | undefined,
 		cursorToMove: ITreeSubscriptionCursor,
 	): void {
+		this.breaker.use();
 		assert(
 			cursorToMove instanceof Cursor,
 			0x337 /* ObjectForest must only be given its own Cursor type */,
@@ -419,6 +452,7 @@ export class ObjectForest implements IEditableForest, WithBreakable {
 	}
 
 	public getCursorAboveDetachedFields(): ITreeCursorSynchronous {
+		this.breaker.use();
 		return cursorForMapTreeNode(this.roots);
 	}
 }

package/src/feature-libraries/schema-index/schemaSummarizer.ts

@@ -10,7 +10,7 @@ import { SummaryType } from "@fluidframework/driver-definitions";
 import type {
 	IExperimentalIncrementalSummaryContext,
 	ITelemetryContext,
-	MinimumVersionForCollab,
+	OldestSupportedClientVersion,
 } from "@fluidframework/runtime-definitions/internal";
 import type { SummaryTreeBuilder } from "@fluidframework/runtime-utils/internal";
 
@@ -57,7 +57,7 @@ const supportedVersions = new Set<SchemaSummaryFormatVersion>([
  * Returns the summary version to use as per the given minimum version for collab.
  */
 function minVersionToSchemaSummaryFormatVersion(
-	version: MinimumVersionForCollab,
+	version: OldestSupportedClientVersion,
 ): SchemaSummaryFormatVersion {
 	// Currently, version 2 is written which adds metadata blob to the summary.
 	return SchemaSummaryFormatVersion.v2;
@@ -76,7 +76,7 @@ export class SchemaSummarizer
 		private readonly schema: MutableTreeStoredSchema,
 		collabWindow: CollabWindow,
 		private readonly codec: IJsonCodec<TreeStoredSchema>,
-		minVersionForCollab: MinimumVersionForCollab,
+		minVersionForCollab: OldestSupportedClientVersion,
 	) {
 		super(
 			"Schema",

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

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { assert, unreachableCase } from "@fluidframework/core-utils/internal";
+import { assert, fail, unreachableCase } from "@fluidframework/core-utils/internal";
 
 import type { ChangeAtomId, RevisionMetadataSource, RevisionTag } from "../../core/index.js";
 import { type IdAllocator, type Mutable, brand } from "../../util/index.js";
@@ -252,7 +252,7 @@ function addMovedMarkEffect(mark: Mark, effect: Detach): Mark {
 	} else if (isTombstone(mark)) {
 		return { ...mark, ...effect };
 	}
-	assert(false, 0x818 /* Unexpected combination of mark effects at source and destination */);
+	fail(0x818 /* Unexpected combination of mark effects at source and destination */);
 }
 
 /**

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

@@ -278,7 +278,7 @@ export function compareCellPositionsUsingTombstones(
 			//
 			// The same scenario can arise in the context of compose (just consider composing `old'` and `new'` from
 			// the examples above) with the same resolution.
-			assert(false, 0x8a2 /* Invalid cell ordering scenario */);
+			fail(0x8a2 /* Invalid cell ordering scenario */);
 		}
 
 		// The absence of metadata for a cell with a defined revision means that the cell is from a revision that

package/src/packageVersion.ts

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

package/src/shared-tree/independentView.ts

@@ -9,10 +9,7 @@ import {
 	type IIdCompressor,
 	createIdCompressor,
 } from "@fluidframework/id-compressor/internal";
-import {
-	createChildLogger,
-	extractTelemetryLoggerExt,
-} from "@fluidframework/telemetry-utils/internal";
+import { createChildLogger } from "@fluidframework/telemetry-utils/internal";
 
 import type { CodecWriteOptions, ICodecOptions } from "../codec/index.js";
 import {
@@ -224,12 +221,10 @@ export function createIndependentTreeBeta<const TSchema extends ImplicitFieldSch
 export function createIndependentTreeAlpha<const TSchema extends ImplicitFieldSchema>(
 	options?: CreateIndependentTreeAlphaOptions,
 ): ViewableTree & Pick<ITreeAlpha, "exportVerbose" | "exportSimpleSchema"> {
-	const logger = extractTelemetryLoggerExt(
-		createChildLogger({
-			logger: options?.logger,
-			namespace: "independentView",
-		}),
-	);
+	const logger = createChildLogger({
+		logger: options?.logger,
+		namespace: "independentView",
+	});
 	const breaker = new Breakable("independentView", logger);
 	const idCompressor: IIdCompressor =
 		options?.idCompressor ?? options?.content?.idCompressor ?? createIdCompressor();
@@ -250,8 +245,6 @@ export function createIndependentTreeAlpha<const TSchema extends ImplicitFieldSc
 	const checkout = createTreeCheckout(idCompressor, mintRevisionTag, revisionTagCodec, {
 		forest,
 		schema: schemaRepository,
-		breaker,
-		logger,
 		codecOptions: options,
 	});
 

package/src/shared-tree/sharedTree.ts

@@ -7,13 +7,13 @@ import type { ErasedType, IFluidLoadable } from "@fluidframework/core-interfaces
 import { assert, fail } from "@fluidframework/core-utils/internal";
 import type { IChannelStorageService } from "@fluidframework/datastore-definitions/internal";
 import type { IIdCompressor, StableId } from "@fluidframework/id-compressor";
-import type { MinimumVersionForCollab } from "@fluidframework/runtime-definitions/internal";
+import type { OldestSupportedClientVersion } from "@fluidframework/runtime-definitions/internal";
 import type {
 	IChannelView,
 	IFluidSerializer,
 	SharedKernel,
 } from "@fluidframework/shared-object-base/internal";
-import { type TelemetryLoggerExt, UsageError } from "@fluidframework/telemetry-utils/internal";
+import { UsageError } from "@fluidframework/telemetry-utils/internal";
 
 import {
 	type CodecTree,
@@ -206,7 +206,6 @@ export class SharedTreeKernel
 		submitLocalMessage: (content: unknown, localOpMetadata?: unknown) => void,
 		lastSequenceNumber: () => number | undefined,
 		initialSequenceNumber: number,
-		private readonly logger: TelemetryLoggerExt | undefined,
 		idCompressor: IIdCompressor,
 		optionsParam: SharedTreeOptionsInternal,
 	) {
@@ -252,7 +251,7 @@ export class SharedTreeKernel
 			idCompressor,
 			healing:
 				options.healUnresolvableIdentifiersOnDecode === true
-					? { sharedObjectId: sharedObject.id, logger }
+					? { sharedObjectId: sharedObject.id, logger: breaker.logger }
 					: undefined,
 		});
 		const forestSummarizer = new ForestSummarizer(
@@ -305,7 +304,6 @@ export class SharedTreeKernel
 			sharedObject,
 			serializer,
 			submitLocalMessage,
-			logger,
 			[schemaSummarizer, forestSummarizer, removedRootsSummarizer],
 			changeFamily,
 			options,
@@ -324,8 +322,6 @@ export class SharedTreeKernel
 			fieldBatchCodec,
 			removedRoots,
 			chunkCompressionStrategy: options.treeEncodeType,
-			logger,
-			breaker: this.breaker,
 		});
 
 		this.registerSharedBranchForEditing("main", this.checkout);
@@ -546,14 +542,16 @@ export const changeFormatVersionForMessage = DependentFormatVersion.fromPairs<
 	[MessageFormatVersion.v6, SharedTreeChangeFormatVersion.v5],
 ]);
 
-function getCodecTreeForEditManagerFormat(clientVersion: MinimumVersionForCollab): CodecTree {
+function getCodecTreeForEditManagerFormat(
+	clientVersion: OldestSupportedClientVersion,
+): CodecTree {
 	const editManagerVersion = makeEditManagerCodecBuilder().getCodecTree(clientVersion).version;
 	const change = changeFormatVersionForEditManager.lookup(editManagerVersion);
 	const changeCodecTree = getCodecTreeForChangeFormat(change, clientVersion);
 	return getCodecTreeForEditManagerFormatWithChange(clientVersion, changeCodecTree);
 }
 
-function getCodecTreeForMessageFormat(clientVersion: MinimumVersionForCollab): CodecTree {
+function getCodecTreeForMessageFormat(clientVersion: OldestSupportedClientVersion): CodecTree {
 	const messageVersion = makeMessageCodecBuilder().getCodecTree(clientVersion).version;
 	assert(
 		messageVersion !== undefined,
@@ -565,7 +563,7 @@ function getCodecTreeForMessageFormat(clientVersion: MinimumVersionForCollab): C
 }
 
 export function getCodecTreeForSharedTreeFormat(
-	clientVersion: MinimumVersionForCollab,
+	clientVersion: OldestSupportedClientVersion,
 ): CodecTree {
 	const children: CodecTree[] = [];
 	children.push(forestCodecBuilder.getCodecTree(clientVersion));
@@ -665,6 +663,35 @@ export interface SharedTreeOptions
 	 * lifetime of the client, which increases memory usage over time and should be used with care.
 	 */
 	readonly retainHistory?: boolean;
+
+	/**
+	 * When `true`, validates that commits being submitted for the first time can be applied without errors to a view.
+	 * In the event that a commit cannot be applied, SharedTree will throw an error and will enter a "broken" state, preventing the offending commit (and any further commits) from being submitted.
+	 *
+	 * This can be enabled (at the cost of performance) to improve safety against document corruption in the event of a bug in the SharedTree code:
+	 * when the additional validation is enabled, a client will error instead of potentially corrupting the document.
+	 *
+	 * @defaultValue `false`
+	 *
+	 * @remarks
+	 * This validation is more expensive than {@link SharedTreeOptions.validateRebasedCommitsBeforeResubmission} because it is likely to be performed more often.
+	 * We recommend {@link ForestOptions.forest|configuring SharedTree} with the {@link ForestTypeOptimized|optimized forest implementation} to reduce its performance impact.
+	 */
+	readonly validateCommitsOnFirstSubmission?: boolean;
+
+	/**
+	 * When `true`, validates that the commits being resubmitted can be applied without errors to a view.
+	 * In the event that a commit cannot be applied, SharedTree will throw an error and will enter a "broken" state, preventing the offending commit (and any further commits) from being submitted.
+	 *
+	 * This can be enabled (at the cost of performance) to improve safety against document corruption in the event of a bug in the SharedTree code:
+	 * when the additional validation is enabled, a client will error instead of potentially corrupting the document.
+	 *
+	 * @defaultValue `false`
+	 *
+	 * @remarks
+	 * We recommend {@link ForestOptions.forest|configuring SharedTree} with the {@link ForestTypeOptimized|optimized forest implementation} to reduce the performance impact of this validation.
+	 */
+	readonly validateRebasedCommitsBeforeResubmission?: boolean;
 }
 
 export interface SharedTreeOptionsInternal
@@ -741,6 +768,7 @@ export const ForestTypeOptimized = toForestType(
 			makeTreeChunker(schema, defaultSchemaPolicy, shouldEncodeIncrementally),
 			undefined,
 			idCompressor,
+			breaker,
 		),
 );
 
@@ -767,6 +795,7 @@ export const ForestTypeExpensiveDebug = toForestType(
 				makeTreeChunker(schema, defaultSchemaPolicy, shouldEncodeIncrementally),
 				undefined,
 				idCompressor,
+				breaker,
 			),
 			buildForest(breaker, schema, undefined, true),
 		),
@@ -812,6 +841,8 @@ export const defaultSharedTreeOptions: Required<SharedTreeOptionsInternal> = {
 	writeVersionOverrides: new Map(),
 	allowPossiblyIncompatibleWriteVersionOverrides: false,
 	retainHistory: false,
+	validateCommitsOnFirstSubmission: false,
+	validateRebasedCommitsBeforeResubmission: false,
 };
 
 /**

package/src/shared-tree/sharedTreeChangeCodecs.ts

@@ -4,7 +4,7 @@
  */
 
 import { fail } from "@fluidframework/core-utils/internal";
-import type { MinimumVersionForCollab } from "@fluidframework/runtime-definitions/internal";
+import type { OldestSupportedClientVersion } from "@fluidframework/runtime-definitions/internal";
 
 import {
 	type CodecTree,
@@ -130,7 +130,7 @@ export const dependenciesForChangeFormat = new Map<
 
 export function getCodecTreeForChangeFormat(
 	version: SharedTreeChangeFormatVersion,
-	clientVersion: MinimumVersionForCollab,
+	clientVersion: OldestSupportedClientVersion,
 ): CodecTree {
 	const { modularChange } =
 		dependenciesForChangeFormat.get(version) ?? fail(0xc78 /* Unknown change format */);

package/src/shared-tree/sharedTreeChangeEnricher.ts

@@ -40,6 +40,10 @@ interface OwnedState {
 	readonly removedRoots: DetachedFieldIndex;
 }
 
+/**
+ * A helper for enriching `SharedTreeChange`s.
+ * It lazily forks the borrowed state (which it does not mutate) and lazily applies {@link enqueueChange|changes} to the forked state when {@link enrich|commit enrichment} requires access to detached root data.
+ */
 export class SharedTreeChangeEnricher {
 	/**
 	 * Queue of changes to be applied before querying for detached roots.
@@ -76,6 +80,13 @@ export class SharedTreeChangeEnricher {
 		};
 	}
 
+	/**
+	 * Enriches a change.
+	 * @param change - The change to enrich (not mutated)
+	 * @returns An enriched copy of the given `change`.
+	 * @remarks
+	 * Invoking this method will flush {@link enqueueChange|queued} changes if the enrichment process requires reading detached roots from the forest.
+	 */
 	public enrich(change: SharedTreeChange): SharedTreeChange {
 		this.onEnrichCommit?.();
 		return updateRefreshers(
@@ -104,13 +115,23 @@ export class SharedTreeChangeEnricher {
 		return undefined;
 	}
 
+	/**
+	 * Enqueues a change to be applied before reading detached root data during the next {@link enrich|enrichment}.
+	 * @param change - The change to apply or a function that returns the change to apply.
+	 * If a function is provided, it will be invoked during a future call to {@link enrich} (if at all).
+	 */
 	public enqueueChange(
 		change: TaggedChange<SharedTreeChange> | (() => TaggedChange<SharedTreeChange>),
 	): void {
 		this.changeQueue.push(typeof change === "function" ? change : () => change);
 	}
 
-	private purgeChangeQueue(): void {
+	/**
+	 * Flushes all {@link enqueueChange|queued} changes by applying the data changes to a forked forest and detached field index.
+	 * @remarks
+	 * This validates that the data changes are valid.
+	 */
+	public purgeChangeQueue(): void {
 		if (this.changeQueue.length === 0) {
 			return;
 		}
@@ -150,6 +171,9 @@ export class SharedTreeChangeEnricher {
 		this.changeQueue.length = 0;
 	}
 
+	/**
+	 * Dispose of this object and its resources.
+	 */
 	public [disposeSymbol](): void {
 		// TODO: in the future, forest and/or its AnchorSet may require disposal.
 	}

package/src/shared-tree/treeCheckout.ts

@@ -334,14 +334,11 @@ export function createTreeCheckout(
 		fieldBatchCodec?: FieldBatchCodec;
 		removedRoots?: DetachedFieldIndex;
 		chunkCompressionStrategy?: TreeCompressionStrategy;
-		logger?: TelemetryLoggerExt;
-		breaker?: Breakable;
 		codecOptions?: Partial<CodecWriteOptions>;
 	},
 ): TreeCheckout {
-	const breaker = args?.breaker ?? new Breakable("TreeCheckout", args?.logger);
 	const schema = args?.schema ?? new TreeStoredSchemaRepository();
-	const forest = args?.forest ?? buildForest(breaker, schema);
+	const forest = args?.forest ?? buildForest(new Breakable("TreeCheckout"), schema);
 	const defaultCodecOptions: CodecWriteOptions = {
 		jsonValidator: FormatValidatorNoOp,
 		minVersionForCollab: FluidClientVersion.v2_0,
@@ -380,8 +377,6 @@ export function createTreeCheckout(
 		revisionTagCodec,
 		idCompressor,
 		args?.removedRoots,
-		args?.logger,
-		breaker,
 	);
 }
 
@@ -489,6 +484,31 @@ export function assertValidConstraint(
 export class TreeCheckout implements ITreeCheckout {
 	public disposed = false;
 
+	/**
+	 * Logger for telemetry events related to this checkout.
+	 * @remarks
+	 * This logger is provided by the {@link Breakable} passed to the constructor, and may be `undefined` if no logger was provided.
+	 * See the explanation on {@link Breakable.logger} for why this pattern makes sense.
+	 */
+	private get logger(): TelemetryLoggerExt | undefined {
+		return this.breaker.logger;
+	}
+
+	/**
+	 * The breaker for this checkout.
+	 * @remarks
+	 * As the forest is part of the mutable state of the checkout,
+	 * we want to be broken if it is broken, so we use the forest's breaker as our own.
+	 *
+	 * This does mean that if something goes wrong in the checkout, we break the forest,
+	 * which is not strictly necessary, but may be desirable as if something is wrong with the checkout,
+	 * while the forest might be internally consistent, it likely doesn't contain the correct content
+	 * (since the checkout is keeping it up to date properly anymore).
+	 */
+	public get breaker(): Breakable {
+		return this.forest.breaker;
+	}
+
 	private editLock: EditLock;
 
 	/**
@@ -566,9 +586,6 @@ export class TreeCheckout implements ITreeCheckout {
 		private readonly revisionTagCodec: RevisionTagCodec,
 		private readonly idCompressor: IIdCompressor,
 		private readonly _removedRoots: DetachedFieldIndex = makeDetachedFieldIndex("repair"),
-		/** Optional logger for telemetry. */
-		private readonly logger?: TelemetryLoggerExt,
-		public readonly breaker: Breakable = new Breakable("TreeCheckout", logger),
 		public readonly disposeForksAfterTransaction = true,
 	) {
 		this.#transaction = this.createTransactionStack(branch);
@@ -1119,6 +1136,7 @@ export class TreeCheckout implements ITreeCheckout {
 		});
 	};
 
+	@breakingMethod
 	private withCombinedVisitor(fn: (visitor: DeltaVisitor) => void): void {
 		const anchorVisitor = this.forest.anchors.acquireVisitor();
 		const combinedVisitor = combineVisitors([this.forest.acquireVisitor(), anchorVisitor]);
@@ -1132,7 +1150,7 @@ export class TreeCheckout implements ITreeCheckout {
 			if (usageError !== undefined) {
 				throw new UsageError(usageError);
 			}
-			assert(false, 0x911 /* Invalid operation on a disposed TreeCheckout */);
+			fail(0x911 /* Invalid operation on a disposed TreeCheckout */);
 		}
 	}
 
@@ -1304,8 +1322,6 @@ export class TreeCheckout implements ITreeCheckout {
 			this.revisionTagCodec,
 			this.idCompressor,
 			this._removedRoots.clone(),
-			this.logger,
-			forkBreaker,
 		);
 		this.#events.emit("fork", checkout);
 		return checkout;
@@ -1704,6 +1720,7 @@ export class TreeCheckout implements ITreeCheckout {
 	public enrich(
 		context: GraphCommit<SharedTreeChange>,
 		changes: readonly TaggedChange<SharedTreeChange>[],
+		forceValidation: boolean,
 	): SharedTreeChange[] {
 		if (!hasSome(changes)) {
 			return [];
@@ -1734,13 +1751,25 @@ export class TreeCheckout implements ITreeCheckout {
 				return makeAnonChange(diff);
 			});
 		}
-		const enriched: SharedTreeChange[] = [];
+		const enrichedChanges: SharedTreeChange[] = [];
 		for (const change of changes) {
-			enriched.push(enricher.enrich(change.change));
-			enricher.enqueueChange(change);
+			const enrichedChange = enricher.enrich(change.change);
+			enrichedChanges.push(enrichedChange);
+			// We could either apply the original or the enriched change: either should allow subsequent changes to be enriched correctly.
+			// We choose to apply the enriched change in order to more closely replicate what a peer will experience (assuming no concurrent changes).
+			// This makes it more likely that we'll detect a bug in the enrichment logic.
+			// Note that enqueueing the change does not guarantee that it will be applied unless `forceValidation` is enabled.
+			enricher.enqueueChange(tagChange(enrichedChange, change.revision));
+		}
+		if (forceValidation) {
+			// Ensure that all changes can be applied successfully.
+			// This is useful for catching bugs in the enrichment logic and in the rebasing logic that may have been involved in producing the changes.
+			// Note that we cannot guarantee that the enriched change will be applied successfully even in the absence of concurrent changes,
+			// because the checkout state we are applying this enriched change to was derived from the state of the checkout, which may be different from that of a peer.
+			enricher.purgeChangeQueue();
 		}
 		enricher[disposeSymbol]();
-		return enriched;
+		return enrichedChanges;
 	}
 
 	public get mainBranch(): SharedTreeBranch<