@fluidframework/tree 2.81.0-374083 → 2.81.1

package/src/shared-tree/treeCheckout.ts

@@ -3,14 +3,17 @@
  * Licensed under the MIT License.
  */
 
-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 { IDisposable } from "@fluidframework/core-interfaces";
+import type { IFluidHandle, Listenable } from "@fluidframework/core-interfaces/internal";
+import { assert, unreachableCase, fail } from "@fluidframework/core-utils/internal";
 import type { IIdCompressor, SessionId } from "@fluidframework/id-compressor";
+import { isStableId } from "@fluidframework/id-compressor/internal";
 import {
 	UsageError,
 	type ITelemetryLoggerExt,
 } from "@fluidframework/telemetry-utils/internal";
+
 import {
 	FluidClientVersion,
 	FormatValidatorNoOp,
@@ -50,29 +53,23 @@ import {
 	type TreeNodeSchemaIdentifier,
 	type TreeNodeStoredSchema,
 	LeafNodeStoredSchema,
-	type ChangeAtomId,
-	offsetChangeAtomId,
 	diffHistories,
 	type ChangeMetadata,
 	type ChangeEncodingContext,
 	type ReadOnlyDetachedFieldIndex,
+	makeAnonChange,
+	type TaggedChange,
 } 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,
@@ -82,24 +79,6 @@ import {
 	type SharedTreeBranchChange,
 	type Transactor,
 } from "../shared-tree-core/index.js";
-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 { IDisposable } from "@fluidframework/core-interfaces";
 import {
 	type ImplicitFieldSchema,
 	type ReadSchema,
@@ -114,8 +93,20 @@ import {
 	type CustomTreeValue,
 	type CustomTreeNode,
 } from "../simple-tree/index.js";
+import {
+	Breakable,
+	disposeSymbol,
+	getOrCreate,
+	hasSome,
+	type JsonCompatibleReadOnly,
+	type WithBreakable,
+} from "../util/index.js";
+
 import { getCheckout, SchematizingSimpleTreeView } from "./schematizingTreeView.js";
-import { isStableId } from "@fluidframework/id-compressor/internal";
+import { SharedTreeChangeEnricher } from "./sharedTreeChangeEnricher.js";
+import { SharedTreeChangeFamily, hasSchemaChange } from "./sharedTreeChangeFamily.js";
+import type { SharedTreeChange } from "./sharedTreeChangeTypes.js";
+import type { ISharedTreeEditor, SharedTreeEditBuilder } from "./sharedTreeEditBuilder.js";
 
 /**
  * Events for {@link ITreeCheckout}.
@@ -248,7 +239,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.
@@ -306,8 +297,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;
@@ -396,7 +387,6 @@ export class TreeCheckout implements ITreeCheckoutFork {
 	public disposed = false;
 
 	private editLock: EditLock;
-	private readonly locator: Locator;
 
 	private readonly views = new Set<TreeView<ImplicitFieldSchema>>();
 
@@ -412,7 +402,7 @@ export class TreeCheckout implements ITreeCheckoutFork {
 	 */
 	private readonly revertibleCommitBranches = new Map<
 		RevisionTag,
-		SharedTreeBranch<IdBasedSharedTreeEditBuilder, SharedTreeChange>
+		SharedTreeBranch<SharedTreeEditBuilder, SharedTreeChange>
 	>();
 
 	/**
@@ -425,13 +415,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,
@@ -449,31 +436,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();
 	}
 
@@ -494,8 +456,8 @@ export class TreeCheckout implements ITreeCheckoutFork {
 	}
 
 	private createTransactionStack(
-		branch: SharedTreeBranch<IdBasedSharedTreeEditBuilder, SharedTreeChange>,
-	): SquashingTransactionStack<IdBasedSharedTreeEditBuilder, SharedTreeChange> {
+		branch: SharedTreeBranch<SharedTreeEditBuilder, SharedTreeChange>,
+	): SquashingTransactionStack<SharedTreeEditBuilder, SharedTreeChange> {
 		return new SquashingTransactionStack(branch, this.mintRevisionTag, () => {
 			const disposeForks = this.disposeForksAfterTransaction
 				? trackForksForDisposal(this)
@@ -833,9 +795,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 {
@@ -856,19 +818,18 @@ 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.",
 		);
-		this.editLock.checkUnlocked("Branching");
-
 		// Branching after an unfinished transaction would expose the application to a state where its invariants may be violated.
 		if (this.transaction.isInProgress()) {
 			throw new UsageError("A view cannot be forked while it has a pending transaction.");
 		}
 
+		this.editLock.checkUnlocked("Branching");
 		const anchors = new AnchorSet();
 		const branch = this.#transaction.activeBranch.fork();
 		const storedSchema = this.storedSchema.clone();
@@ -892,7 +853,7 @@ export class TreeCheckout implements ITreeCheckoutFork {
 	}
 
 	public switchBranch(
-		branch: SharedTreeBranch<IdBasedSharedTreeEditBuilder, SharedTreeChange>,
+		branch: SharedTreeBranch<SharedTreeEditBuilder, SharedTreeChange>,
 	): void {
 		// TODO: Dispose old branch, if necessary
 		assert(
@@ -1179,6 +1140,90 @@ export class TreeCheckout implements ITreeCheckoutFork {
 	}
 
 	// #endregion Commit Validation
+
+	// #region Enrichment
+
+	/**
+	 * Statistics about enrichment operations performed by this checkout.
+	 * Used for testing. May be used for telemetry in the future.
+	 * The performance cost of maintaining this information is negligible.
+	 */
+	private readonly enrichmentStats: {
+		batches: number;
+		diffs: number;
+		commitsEnriched: number;
+		refreshers: number;
+		forks: number;
+		applied: number;
+	} = { batches: 0, diffs: 0, commitsEnriched: 0, refreshers: 0, forks: 0, applied: 0 };
+
+	public resetEnrichmentStats(): void {
+		this.enrichmentStats.batches = 0;
+		this.enrichmentStats.diffs = 0;
+		this.enrichmentStats.commitsEnriched = 0;
+		this.enrichmentStats.refreshers = 0;
+		this.enrichmentStats.forks = 0;
+		this.enrichmentStats.applied = 0;
+	}
+
+	public getEnrichmentStats(): {
+		batches: number;
+		diffs: number;
+		commitsEnriched: number;
+		refreshers: number;
+		forks: number;
+		applied: number;
+	} {
+		return { ...this.enrichmentStats };
+	}
+
+	public enrich(
+		context: GraphCommit<SharedTreeChange>,
+		changes: readonly TaggedChange<SharedTreeChange>[],
+	): SharedTreeChange[] {
+		if (!hasSome(changes)) {
+			return [];
+		}
+		this.enrichmentStats.batches += 1;
+		const enricher = new SharedTreeChangeEnricher(
+			this.forest,
+			this._removedRoots,
+			this.storedSchema,
+			this.idCompressor,
+			() => (this.enrichmentStats.commitsEnriched += 1),
+			() => (this.enrichmentStats.refreshers += 1),
+			() => (this.enrichmentStats.forks += 1),
+			() => (this.enrichmentStats.applied += 1),
+		);
+		// This `lastCommitApplied` may be on the main branch or on a transaction branch.
+		// In either case, it is crucial that the state of the forest & detached field index reflects all changes up to and including this commit.
+		const lastCommitApplied = this.#transaction.activeBranch.getHead();
+		if (context !== lastCommitApplied) {
+			enricher.enqueueChange(() => {
+				this.enrichmentStats.diffs += 1;
+				const diff = diffHistories(
+					this.changeFamily.rebaser,
+					lastCommitApplied,
+					context,
+					this.mintRevisionTag,
+				);
+				return makeAnonChange(diff);
+			});
+		}
+		const enriched: SharedTreeChange[] = [];
+		for (const change of changes) {
+			enriched.push(enricher.enrich(change.change));
+			enricher.enqueueChange(change);
+		}
+		enricher[disposeSymbol]();
+		return enriched;
+	}
+
+	public get mainBranch(): SharedTreeBranch<SharedTreeEditBuilder, SharedTreeChange> {
+		return this.#transaction.branch;
+	}
+
+	// #endregion Enrichment
 }
 
 /**
@@ -1189,23 +1234,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 {
@@ -1213,10 +1254,6 @@ class EditLock {
 						checkLock();
 						valueField.set(...editArgs);
 					},
-					attach(...editArgs) {
-						checkLock();
-						valueField.attach(...editArgs);
-					},
 				};
 			},
 			optionalField(...fieldArgs) {
@@ -1226,14 +1263,6 @@ class EditLock {
 						checkLock();
 						optionalField.set(...editArgs);
 					},
-					attach(...editArgs) {
-						checkLock();
-						optionalField.attach(...editArgs);
-					},
-					clear(...editArgs) {
-						checkLock();
-						optionalField.clear(...editArgs);
-					},
 				};
 			},
 			sequenceField(...fieldArgs) {
@@ -1243,10 +1272,6 @@ class EditLock {
 						checkLock();
 						sequenceField.insert(...editArgs);
 					},
-					attach(...editArgs) {
-						checkLock();
-						sequenceField.attach(...editArgs);
-					},
 					remove(...editArgs) {
 						checkLock();
 						sequenceField.remove(...editArgs);

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

@@ -6,6 +6,10 @@
 import { createEmitter } from "@fluid-internal/client-utils";
 import type { Listenable } from "@fluidframework/core-interfaces";
 import { assert } from "@fluidframework/core-utils/internal";
+import type {
+	OpSpaceCompressedId,
+	SessionSpaceCompressedId,
+} from "@fluidframework/id-compressor";
 import { type TelemetryEventBatcher, measure } from "@fluidframework/telemetry-utils/internal";
 
 import {
@@ -22,13 +26,8 @@ import {
 	rebaseBranch,
 	tagRollbackInverse,
 	type RebaseStatsWithDuration,
-	type EditorOptions,
 } from "../core/index.js";
 import { hasSome, defineLazyCachedProperty } from "../util/index.js";
-import type {
-	OpSpaceCompressedId,
-	SessionSpaceCompressedId,
-} from "@fluidframework/id-compressor";
 
 export type BranchId = SessionSpaceCompressedId | "main";
 export type EncodedBranchId = OpSpaceCompressedId;
@@ -130,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);
@@ -205,8 +201,6 @@ export class SharedTreeBranch<TEditor extends ChangeFamilyEditor, TChange> {
 			this.changeFamily,
 			mintRevisionTag,
 			this.branchTrimmer,
-			undefined,
-			this.editorOptions,
 		);
 		this.#events.emit("fork", fork);
 		return fork;

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

@@ -5,105 +5,53 @@
 
 import { assert } from "@fluidframework/core-utils/internal";
 
-import { type ChangeRebaser, type GraphCommit, replaceChange } from "../core/index.js";
+import type { GraphCommit } from "../core/index.js";
+import { hasSome } from "../util/index.js";
 
-import type { SharedTreeBranchChange } from "./branch.js";
-import type { ChangeEnricherReadonlyCheckout } from "./changeEnricher.js";
-import { TransactionEnricher } from "./transactionEnricher.js";
+import type { ChangeEnricher } from "./changeEnricher.js";
 
 /**
  * Utility for enriching commits from a {@link Branch} before these commits are applied and submitted.
  */
 export class BranchCommitEnricher<TChange> {
-	readonly #transactionEnricher: TransactionEnricher<TChange>;
-	readonly #enricher: ChangeEnricherReadonlyCheckout<TChange>;
 	/**
-	 * Maps each local commit to the corresponding enriched commit.
+	 * Maps each local commit to the corresponding enriched change.
 	 * @remarks
-	 * Entries are added when the commits are {@link BranchCommitEnricher.processChange | processed during a change}.
-	 * Each entry is removed when it is {@link BranchCommitEnricher.enrich | retrieved}.
+	 * Entries are added when the commits are {@link BranchCommitEnricher.prepareChanges | prepared}.
+	 * Each entry is removed when it is {@link BranchCommitEnricher.retrieveChange | retrieved}.
 	 * In the event that an entry is not explicitly removed, it will eventually be {@link WeakMap | dropped from memory} along with the associated commit.
 	 */
-	readonly #preparedCommits: WeakMap<GraphCommit<TChange>, GraphCommit<TChange>> = new Map();
+	private readonly prepared: WeakMap<GraphCommit<TChange>, TChange> = new WeakMap();
 
-	/**
-	 * If defined, a top-level transaction has been {@link BranchCommitEnricher.commitTransaction | committed} since the last {@link BranchCommitEnricher.processChange | change has been processed}.
-	 * 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?: () => TChange;
-
-	public constructor(
-		rebaser: ChangeRebaser<TChange>,
-		enricher: ChangeEnricherReadonlyCheckout<TChange>,
-	) {
-		this.#enricher = enricher;
-		this.#transactionEnricher = new TransactionEnricher(rebaser, this.#enricher);
-	}
+	public constructor(private readonly enricher: ChangeEnricher<TChange>) {}
 
 	/**
-	 * Process the given change, preparing new commits for {@link BranchCommitEnricher.enrich | enrichment}.
-	 * @param change - The change to process.
+	 * Process the given commits for later {@link BranchCommitEnricher.retrieveChange | retrieval}.
+	 * @param commits - The commits to prepare.
 	 */
-	public processChange(change: SharedTreeBranchChange<TChange>): void {
-		if (change.type === "append") {
-			for (const newCommit of change.newCommits) {
-				const newChange =
-					this.#getOuterTransactionChange?.() ??
-					this.#enricher.updateChangeEnrichments(newCommit.change, newCommit.revision);
-
-				this.#preparedCommits.set(newCommit, replaceChange(newCommit, newChange));
+	public prepareChanges(commits: readonly GraphCommit<TChange>[]): void {
+		if (hasSome(commits)) {
+			const startingState = commits[0].parent;
+			assert(startingState !== undefined, 0xcc1 /* New commits must have a parent. */);
+			const enrichedCommits = this.enricher.enrich(startingState, commits);
+			for (const [index, commit] of commits.entries()) {
+				const enrichedCommit = enrichedCommits[index];
+				assert(enrichedCommit !== undefined, 0xcc2 /* Missing enriched commit. */);
+				this.prepared.set(commit, enrichedCommit);
 			}
 		}
-
-		this.#getOuterTransactionChange = undefined;
 	}
 
 	/**
-	 * Retrieves the enriched version of the given commit.
-	 * @param commit - A commit {@link BranchCommitEnricher.processChange | processed during the most recent change}.
+	 * Retrieves the enriched change for the given commit.
+	 * @param commit - A commit that was already {@link BranchCommitEnricher.prepareChanges | prepared}.
 	 * @remarks A commit can only be enriched once - subsequent calls to this method with the same commit will throw an error.
+	 * @returns The enriched change corresponding to the given `commit`.
 	 */
-	public enrich(commit: GraphCommit<TChange>): GraphCommit<TChange> {
-		const prepared = this.#preparedCommits.get(commit);
+	public retrieveChange(commit: GraphCommit<TChange>): TChange {
+		const prepared = this.prepared.get(commit);
 		assert(prepared !== undefined, 0x980 /* Unknown commit */);
-		this.#preparedCommits.delete(commit);
+		this.prepared.delete(commit);
 		return prepared;
 	}
-
-	/**
-	 * Notify the enricher that a new transaction has started.
-	 * @remarks This may be called multiple times without calling {@link BranchCommitEnricher.commitTransaction | commitTransaction}, producing "nested transactions".
-	 */
-	public startTransaction(): void {
-		this.#transactionEnricher.startTransaction();
-	}
-
-	/**
-	 * Commit the current transaction.
-	 * @remarks This should be called _before_ the corresponding transaction commit change is {@link BranchCommitEnricher.processChange | processed}.
-	 */
-	public commitTransaction(): void {
-		this.#getOuterTransactionChange = this.#transactionEnricher.commitTransaction();
-	}
-
-	/**
-	 * Notify the enricher that the current transaction has been aborted.
-	 * @remarks This will throw an error if there is no ongoing transaction.
-	 */
-	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/branchIdCodec.ts

@@ -8,6 +8,7 @@ import type {
 	OpSpaceCompressedId,
 	SessionId,
 } from "@fluidframework/id-compressor";
+
 import type { BranchId } from "./branch.js";
 
 export function encodeBranchId(

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

@@ -3,61 +3,17 @@
  * Licensed under the MIT License.
  */
 
-import type { RevisionTag } from "../core/index.js";
-import { disposeSymbol } from "../util/index.js";
+import type { GraphCommit, TaggedChange } from "../core/index.js";
 
 /**
- * A checkout that can be used by {@link SharedTreeCore} or {@link DefaultResubmitMachine} to enrich changes with refreshers.
- *
- * This is similar to a {@link TreeCheckout} in that it represents the state of the tree at a specific revision.
- * But unlike a `TreeCheckout`...
- * - It is not backed by a branch because the `CommitEnricher` that owns it controls which revision it should represent.
- * - The host application has no knowledge of it, so applying changes to it has no impact on the application.
- * - It need not maintain any state or indexes that do not play a role in enriching changes.
- *
- * See implementations for examples.
+ * Allows change to be enriched by using a {@link ChangeEnricherCheckout}.
  */
-export interface ChangeEnricherReadonlyCheckout<TChange> {
+export interface ChangeEnricher<TChange> {
 	/**
-	 * Updates the set of refreshers on a change.
-	 * @param change - the change to enrich. Not mutated.
-	 * @param revision - the revision associated with the change.
-	 * @returns the enriched change. Possibly the same as the one passed in.
+	 * Runs a batch of change enrichments.
+	 * @param context - The branch head after which the `changes` would apply.
+	 * @param changes - The changes to be enriched.
+	 * @returns The enriched changes.
 	 */
-	updateChangeEnrichments(change: TChange, revision: RevisionTag): TChange;
-
-	/**
-	 * Forks the checkout, creating a new checkout that represents the same state but can be mutated.
-	 */
-	fork(): ChangeEnricherMutableCheckout<TChange>;
-}
-
-/**
- * A {@link ChangeEnricherReadonlyCheckout} whose state can be controlled by a {@link CommitEnricher}.
- */
-export interface ChangeEnricherMutableCheckout<TChange>
-	extends ChangeEnricherReadonlyCheckout<TChange> {
-	/**
-	 * Applies a change to the tip state.
-	 * @param change - the change to apply. Not mutated.
-	 * @param revision - the revision associated with the change.
-	 * Can be undefined when the applied change is a rollback.
-	 */
-	applyTipChange(change: TChange, revision?: RevisionTag): void;
-
-	/**
-	 * Disposes of the enricher.
-	 */
-	[disposeSymbol](): void;
-}
-
-export class NoOpChangeEnricher<TChange> implements ChangeEnricherMutableCheckout<TChange> {
-	public applyTipChange(change: TChange, revision?: RevisionTag | undefined): void {}
-	public updateChangeEnrichments(change: TChange, revision: RevisionTag): TChange {
-		return change;
-	}
-	public fork(): ChangeEnricherMutableCheckout<TChange> {
-		return new NoOpChangeEnricher();
-	}
-	public [disposeSymbol](): void {}
+	enrich(context: GraphCommit<TChange>, changes: readonly TaggedChange<TChange>[]): TChange[];
 }