@fluidframework/tree 2.73.0 → 2.74.0-368706

package/src/feature-libraries/treeCompressionUtils.ts

@@ -20,23 +20,9 @@ export enum TreeCompressionStrategy {
 	 * Use this when debugging or testing and needing to inspect encoded tree content.
 	 */
 	Uncompressed = 1,
-}
-
-/**
- * A private extension of {@link TreeCompressionStrategy} for strategies that are not intended for public use just yet.
- */
-export enum TreeCompressionStrategyExtended {
 	/**
-	 * Optimized for encoded size, same as TreeCompressionStrategy.Compressed. It also enables incremental encoding
+	 * Optimized for encoded size, same as TreeCompressionStrategy.Compressed but it enables incremental encoding
 	 * of the data.
-	 * @remarks
-	 * TODO: AB#41865
-	 * This needs to be stabilized to allow opting into it.
-	 * It could possibly be made the default instead of {@link TreeCompressionStrategy.Compressed}.
 	 */
 	CompressedIncremental = 2,
 }
-
-export type TreeCompressionStrategyPrivate =
-	| TreeCompressionStrategy
-	| TreeCompressionStrategyExtended;

package/src/index.ts

@@ -52,6 +52,7 @@ export {
 	type TreeIndex,
 	type TreeIndexKey,
 	type TreeIndexNodes,
+	type IncrementalEncodingPolicy,
 } from "./feature-libraries/index.js";
 
 export {
@@ -184,6 +185,7 @@ export {
 	type AnnotateAllowedTypesList,
 	type AllowedTypesFull,
 	type AllowedTypesFullFromMixed,
+	type SchemaType,
 	// Beta APIs
 	TreeBeta,
 	type TreeChangeEventsBeta,
@@ -282,15 +284,18 @@ export {
 	type SchemaFactory_base,
 	type NumberKeys,
 	type SimpleAllowedTypeAttributes,
-	encodeSimpleSchema,
-	decodeSimpleSchema,
+	encodeSchemaCompatibilitySnapshot,
+	decodeSchemaCompatibilitySnapshot,
 	exportCompatibilitySchemaSnapshot,
 	importCompatibilitySchemaSnapshot,
 	checkCompatibility,
+	incrementalSummaryHint,
+	incrementalEncodingPolicyForAllowedTypes,
 } from "./simple-tree/index.js";
 export {
 	SharedTree,
 	configuredSharedTree,
+	configuredSharedTreeAlpha,
 	configuredSharedTreeBeta,
 	configuredSharedTreeBetaLegacy,
 } from "./treeFactory.js";

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/tree";
-export const pkgVersion = "2.73.0";
+export const pkgVersion = "2.74.0-368706";

package/src/shared-tree/independentView.ts

@@ -72,7 +72,7 @@ import { combineChunks } from "../feature-libraries/index.js";
  */
 export function independentView<const TSchema extends ImplicitFieldSchema>(
 	config: TreeViewConfiguration<TSchema>,
-	options: ForestOptions & { idCompressor?: IIdCompressor | undefined },
+	options?: ForestOptions & { idCompressor?: IIdCompressor | undefined },
 ): TreeViewAlpha<TSchema> {
 	return createIndependentTreeAlpha(options).viewWith(config) as TreeViewAlpha<TSchema>;
 }

package/src/shared-tree/index.ts

@@ -41,9 +41,10 @@ export { SchematizingSimpleTreeView } from "./schematizingTreeView.js";
 export { initialize, initializerFromChunk } from "./schematizeTree.js";
 
 export type {
-	ISharedTreeEditor,
+	IIdBasedSharedTreeEditor,
+	ILocationBasedSharedTreeEditor,
 	ISchemaEditor,
-	SharedTreeEditBuilder,
+	IdBasedSharedTreeEditBuilder,
 } from "./sharedTreeEditBuilder.js";
 
 export { Tree } from "./tree.js";

package/src/shared-tree/schematizeTree.ts

@@ -5,12 +5,19 @@
 
 import { assert } from "@fluidframework/core-utils/internal";
 
-import { type TreeStoredSchema, rootFieldKey, schemaDataIsEmpty } from "../core/index.js";
+import {
+	type ChangeAtomId,
+	type TreeStoredSchema,
+	rootFieldKey,
+	schemaDataIsEmpty,
+} from "../core/index.js";
 import {
 	FieldKinds,
 	allowsRepoSuperset,
 	defaultSchemaPolicy,
-	type IDefaultEditBuilder,
+	type DetachedRootIds,
+	type ILocationBasedDataEditor,
+	type DataEditor,
 	type TreeChunk,
 } from "../feature-libraries/index.js";
 
@@ -37,11 +44,11 @@ export function canInitialize(checkout: ITreeCheckout): boolean {
  * @privateRemarks
  * This takes in a checkout using a subset of the checkout interface to enable easier unit testing.
  */
-export function initialize(
+export function initialize<T>(
 	checkout: Pick<ITreeCheckout, "storedSchema" | "updateSchema">,
 	newSchema: TreeStoredSchema,
-	setInitialTree: () => void,
-): void {
+	setInitialTree: () => T,
+): T {
 	assert(
 		schemaDataIsEmpty(checkout.storedSchema),
 		0x743 /* cannot initialize after a schema is set */,
@@ -78,13 +85,15 @@ export function initialize(
 	);
 
 	checkout.updateSchema(intermediateSchema);
-	setInitialTree();
+	const result = setInitialTree();
 
 	// If intermediate schema is not final desired schema, update to the final schema:
 	if (intermediateSchema !== newSchema) {
 		// This makes the root more strict, so set allowNonSupersetSchema to true.
 		checkout.updateSchema(newSchema, true);
 	}
+
+	return result;
 }
 
 /**
@@ -99,7 +108,9 @@ export function initialize(
  */
 export function initializerFromChunk(
 	checkout: Pick<ITreeCheckout, "storedSchema"> & {
-		readonly editor: IDefaultEditBuilder;
+		readonly editor:
+			| ILocationBasedDataEditor
+			| DataEditor<TreeChunk, ChangeAtomId, DetachedRootIds>;
 	},
 	contentFactory: () => TreeChunk,
 ): () => void {
@@ -108,7 +119,9 @@ export function initializerFromChunk(
 
 function initializeFromChunk(
 	checkout: Pick<ITreeCheckout, "storedSchema"> & {
-		readonly editor: IDefaultEditBuilder;
+		readonly editor:
+			| ILocationBasedDataEditor
+			| DataEditor<TreeChunk, ChangeAtomId, DetachedRootIds>;
 	},
 	contentChunk: TreeChunk,
 ): void {

package/src/shared-tree/schematizingTreeView.ts

@@ -16,10 +16,8 @@ import { anchorSlot, rootFieldKey } from "../core/index.js";
 import {
 	type NodeIdentifierManager,
 	defaultSchemaPolicy,
-	cursorForMapTreeField,
 	TreeStatus,
 	Context,
-	combineChunks,
 	type FlexTreeOptionalField,
 	type FlexTreeUnknownUnboxed,
 	FieldKinds,
@@ -66,10 +64,11 @@ import {
 	type Breakable,
 	breakingClass,
 	disposeSymbol,
+	hasSingle,
 	type WithBreakable,
 } from "../util/index.js";
 
-import { canInitialize, initialize, initializerFromChunk } from "./schematizeTree.js";
+import { canInitialize, initialize } from "./schematizeTree.js";
 import type { ITreeCheckout, TreeCheckout } from "./treeCheckout.js";
 import type { TreeBranchAlpha } from "../simple-tree/index.js";
 
@@ -123,11 +122,6 @@ export class SchematizingSimpleTreeView<
 	 */
 	private midUpgrade = false;
 
-	/**
-	 * Hydration work deferred until Context has been created.
-	 */
-	private pendingHydration?: () => void;
-
 	private readonly rootFieldSchema: FieldSchema;
 	public readonly breaker: Breakable;
 
@@ -185,57 +179,54 @@ export class SchematizingSimpleTreeView<
 
 		this.runSchemaEdit(() => {
 			const schema = toInitialSchema(this.config.schema);
-			// This has to be the contextless version, since when "initialize" is called (right after this),
-			// it will do a schema change which would dispose of the current context (see inside `update`).
-			// Thus using the current context (if any) would hydrate nodes then
-			// immediately dispose them instead of having them actually be useable after initialize.
-			// For this to work,
-			// the hydration must be deferred until after the content is inserted into the tree and the final schema change is done (for required roots),
-			// but before any user event could could run.
-			const mapTree = prepareForInsertionContextless(
-				content as InsertableContent | undefined,
-				this.rootFieldSchema,
-				{
-					schema,
-					policy: defaultSchemaPolicy,
-				},
-				this,
-				schema.rootFieldSchema,
-				(batches, doHydration) => {
-					assert(
-						this.pendingHydration === undefined,
-						0xc74 /* pendingHydration already set */,
-					);
-					this.pendingHydration = () => {
-						assert(
-							batches.length <= 1,
-							0xc75 /* initialize should at most one hydration batch */,
-						);
-						for (const batch of batches) {
-							doHydration(batch, {
-								parent: undefined,
-								parentField: rootFieldKey,
-								parentIndex: 0,
-							});
-						}
-					};
-				},
-			);
-
 			this.checkout.transaction.start();
+			initialize(this.checkout, schema, () => {
+				const preparedContent = prepareForInsertionContextless(
+					content as InsertableContent | undefined,
+					this.rootFieldSchema,
+					{
+						schema,
+						policy: defaultSchemaPolicy,
+					},
+					this,
+					schema.rootFieldSchema,
+				);
 
-			initialize(
-				this.checkout,
-				schema,
-				initializerFromChunk(this.checkout, () => {
-					// This must be done after initial schema is set!
-					return combineChunks(
-						this.checkout.forest.chunkField(
-							cursorForMapTreeField(mapTree === undefined ? [] : [mapTree]),
-						),
-					);
-				}),
-			);
+				if (preparedContent.rootsLocations.length === 0) {
+					// If there's no content to attach, no work is needed
+					return undefined;
+				}
+
+				const field = { field: rootFieldKey, parent: undefined };
+				assert(
+					this.checkout.storedSchema.rootFieldSchema.kind === FieldKinds.optional.identifier,
+					"initializerFromChunk only supports optional roots",
+				);
+
+				assert(
+					hasSingle(preparedContent.rootsLocations) &&
+						preparedContent.rootsLocations[0].count === 1,
+					"Expected one root",
+				);
+				const fieldEditor = this.checkout.editor.optionalField(field);
+				fieldEditor.attach(preparedContent.rootsLocations[0].field, true);
+
+				return preparedContent;
+			})?.finalize([...this.getFlexTreeContext().root]);
+
+			// TODO:CM
+			// initialize(
+			// 	this.checkout,
+			// 	schema,
+			// 	initializerFromChunk(this.checkout, () => {
+			// 		// This must be done after initial schema is set!
+			// 		return combineChunks(
+			// 			this.checkout.forest.chunkField(
+			// 				cursorForMapTreeField(mapTree === undefined ? [] : [mapTree]),
+			// 			),
+			// 		);
+			// 	}),
+			// );
 			this.checkout.transaction.commit();
 		});
 	}
@@ -390,9 +381,7 @@ export class SchematizingSimpleTreeView<
 
 				// Track what the root was before to be able to detect changes.
 				// This uses the flex tree root to avoid demanding the simple-tree TreeNode when it might not be hydrated yet.
-				let lastRoot: FlexTreeUnknownUnboxed | undefined = (
-					this.flexTreeContext.root as FlexTreeOptionalField
-				).content;
+				let lastRoot: FlexTreeUnknownUnboxed | undefined = this.flexRoot.content;
 
 				this.flexTreeViewUnregisterCallbacks.add(
 					this.checkout.events.on("afterBatch", () => {
@@ -416,10 +405,6 @@ export class SchematizingSimpleTreeView<
 		);
 
 		if (!this.midUpgrade) {
-			assert(
-				this.pendingHydration === undefined,
-				0xc76 /* no nodes should be pending hydration when triggering events that could access nodes */,
-			);
 			this.events.emit("schemaChanged");
 			this.events.emit("rootChanged");
 		}
@@ -432,9 +417,6 @@ export class SchematizingSimpleTreeView<
 		} finally {
 			this.midUpgrade = false;
 		}
-		// Ensure hydration is flushed before events run which could access nodes.
-		this.pendingHydration?.();
-		this.pendingHydration = undefined;
 		this.events.emit("schemaChanged");
 		this.events.emit("rootChanged");
 	}
@@ -546,7 +528,7 @@ export function getCheckout(context: TreeBranch): TreeCheckout {
  * Adds constraints to a `checkout`'s pending transaction.
  *
  * @param checkout - The checkout's who's transaction will have the constraints added to it.
- * @param constraintsOnRevert - If true, use {@link ISharedTreeEditor.addNodeExistsConstraintOnRevert}.
+ * @param constraintsOnRevert - If true, use {@link IIdBasedSharedTreeEditor.addNodeExistsConstraintOnRevert}.
  * @param constraints - The constraints to add to the transaction.
  *
  * @see {@link RunTransactionParams.preconditions}.

package/src/shared-tree/sharedTree.ts

@@ -64,7 +64,6 @@ import {
 	makeSchemaCodec,
 	makeTreeChunker,
 	type IncrementalEncodingPolicy,
-	type TreeCompressionStrategyPrivate,
 } from "../feature-libraries/index.js";
 // eslint-disable-next-line import-x/no-internal-modules
 import type { FormatV1 } from "../feature-libraries/schema-index/index.js";
@@ -75,7 +74,7 @@ import {
 	type ClonableSchemaAndPolicy,
 	getCodecTreeForEditManagerFormatWithChange,
 	getCodecTreeForMessageFormatWithChange,
-	type SharedTreCoreOptionsInternal,
+	type SharedTreeCoreOptionsInternal,
 	MessageFormatVersion,
 	SharedTreeCore,
 	EditManagerFormatVersion,
@@ -98,13 +97,14 @@ import {
 	type ITreeAlpha,
 	type SimpleObjectFieldSchema,
 	type SimpleAllowedTypeAttributes,
+	type SchemaType,
 } from "../simple-tree/index.js";
 
 import { SchematizingSimpleTreeView } from "./schematizingTreeView.js";
 import { SharedTreeReadonlyChangeEnricher } from "./sharedTreeChangeEnricher.js";
 import { SharedTreeChangeFamily } from "./sharedTreeChangeFamily.js";
 import type { SharedTreeChange } from "./sharedTreeChangeTypes.js";
-import type { SharedTreeEditBuilder } from "./sharedTreeEditBuilder.js";
+import type { IdBasedSharedTreeEditBuilder } from "./sharedTreeEditBuilder.js";
 import { type TreeCheckout, type BranchableTree, createTreeCheckout } from "./treeCheckout.js";
 import {
 	brand,
@@ -182,7 +182,7 @@ export type SharedTreeKernelView = Omit<ITreePrivate, keyof (IChannelView & IFlu
  */
 @breakingClass
 export class SharedTreeKernel
-	extends SharedTreeCore<SharedTreeEditBuilder, SharedTreeChange>
+	extends SharedTreeCore<IdBasedSharedTreeEditBuilder, SharedTreeChange>
 	implements SharedKernel
 {
 	public readonly checkout: TreeCheckout;
@@ -241,6 +241,7 @@ export class SharedTreeKernel
 				getCurrentSeq: lastSequenceNumber,
 			},
 			schemaCodec,
+			options.minVersionForCollab,
 		);
 		const fieldBatchCodec = makeFieldBatchCodec(options);
 
@@ -263,7 +264,10 @@ export class SharedTreeKernel
 			initialSequenceNumber,
 			options.shouldEncodeIncrementally,
 		);
-		const removedRootsSummarizer = new DetachedFieldIndexSummarizer(removedRoots);
+		const removedRootsSummarizer = new DetachedFieldIndexSummarizer(
+			removedRoots,
+			options.minVersionForCollab,
+		);
 		const innerChangeFamily = new SharedTreeChangeFamily(
 			revisionTagCodec,
 			fieldBatchCodec,
@@ -466,7 +470,7 @@ export class SharedTreeKernel
 
 	public override applyStashedOp(
 		...args: Parameters<
-			SharedTreeCore<SharedTreeEditBuilder, SharedTreeChange>["applyStashedOp"]
+			SharedTreeCore<IdBasedSharedTreeEditBuilder, SharedTreeChange>["applyStashedOp"]
 		>
 	): void {
 		for (const checkout of this.checkouts.values()) {
@@ -504,7 +508,9 @@ export class SharedTreeKernel
 	public onDisconnect(): void {}
 }
 
-export function exportSimpleSchema(storedSchema: TreeStoredSchema): SimpleTreeSchema {
+export function exportSimpleSchema(
+	storedSchema: TreeStoredSchema,
+): SimpleTreeSchema<SchemaType.Stored> {
 	return {
 		root: exportSimpleFieldSchemaStored(storedSchema.rootFieldSchema),
 		definitions: new Map(
@@ -590,9 +596,13 @@ export const changeFormatVersionForEditManager = DependentFormatVersion.fromPair
 		brand<SharedTreeChangeFormatVersion>(4),
 	],
 	[
-		brand<EditManagerFormatVersion>(EditManagerFormatVersion.v5),
+		brand<EditManagerFormatVersion>(EditManagerFormatVersion.vSharedBranches),
 		brand<SharedTreeChangeFormatVersion>(4),
 	],
+	[
+		brand<EditManagerFormatVersion>(EditManagerFormatVersion.vDetachedRoots),
+		brand<SharedTreeChangeFormatVersion>(101),
+	],
 ]);
 
 /**
@@ -611,9 +621,13 @@ export const changeFormatVersionForMessage = DependentFormatVersion.fromPairs([
 		brand<SharedTreeChangeFormatVersion>(4),
 	],
 	[
-		brand<MessageFormatVersion>(MessageFormatVersion.v5),
+		brand<MessageFormatVersion>(MessageFormatVersion.vSharedBranches),
 		brand<SharedTreeChangeFormatVersion>(4),
 	],
+	[
+		brand<MessageFormatVersion>(MessageFormatVersion.vDetachedRoots),
+		brand<SharedTreeChangeFormatVersion>(101),
+	],
 ]);
 
 function getCodecTreeForEditManagerFormat(clientVersion: MinimumVersionForCollab): CodecTree {
@@ -656,26 +670,25 @@ export function getCodecTreeForSharedTreeFormat(
 export type SharedTreeOptionsBeta = ForestOptions;
 
 /**
- * Configuration options for SharedTree.
+ * Configuration options for SharedTree with alpha features.
  * @alpha @input
  */
 export interface SharedTreeOptions
-	extends Partial<CodecWriteOptions>,
-		Partial<SharedTreeFormatOptions>,
-		SharedTreeOptionsBeta {
+	extends SharedTreeOptionsBeta,
+		Partial<CodecWriteOptions>,
+		Partial<SharedTreeFormatOptions> {
 	/**
 	 * Experimental feature flag to enable shared branches.
 	 * This feature is not yet complete and should not be used in production.
 	 * Defaults to false.
 	 */
 	readonly enableSharedBranches?: boolean;
-}
-
-export interface SharedTreeOptionsInternal
-	extends Partial<SharedTreCoreOptionsInternal>,
-		Partial<ForestOptions>,
-		Partial<SharedTreeFormatOptionsInternal> {
-	disposeForksAfterTransaction?: boolean;
+	/**
+	 * Experimental feature flag to enable the ability to edit detached roots.
+	 * This feature is not yet complete and should not be used in production.
+	 * Defaults to false.
+	 */
+	readonly enableDetachedRootEditing?: boolean;
 	/**
 	 * Returns whether a node / field should be incrementally encoded.
 	 * @remarks
@@ -684,6 +697,12 @@ export interface SharedTreeOptionsInternal
 	shouldEncodeIncrementally?: IncrementalEncodingPolicy;
 }
 
+export interface SharedTreeOptionsInternal
+	extends SharedTreeOptions,
+		Partial<SharedTreeCoreOptionsInternal> {
+	disposeForksAfterTransaction?: boolean;
+}
+
 /**
  * Configuration options for SharedTree's internal tree storage.
  * @beta @input
@@ -707,11 +726,6 @@ export interface SharedTreeFormatOptions {
 	treeEncodeType: TreeCompressionStrategy;
 }
 
-export interface SharedTreeFormatOptionsInternal
-	extends Omit<SharedTreeFormatOptions, "treeEncodeType"> {
-	treeEncodeType: TreeCompressionStrategyPrivate;
-}
-
 /**
  * Used to distinguish between different forest types.
  * @remarks
@@ -814,6 +828,9 @@ export const defaultSharedTreeOptions: Required<SharedTreeOptionsInternal> = {
 	shouldEncodeIncrementally: defaultIncrementalEncodingPolicy,
 	editManagerFormatSelector: clientVersionToEditManagerFormatVersion,
 	messageFormatSelector: clientVersionToMessageFormatVersion,
+	enableSharedBranches: false,
+	enableDetachedRootEditing: false,
+	canMakeDetachedRootEdits: false,
 };
 
 /**
@@ -825,8 +842,8 @@ export const defaultSharedTreeOptions: Required<SharedTreeOptionsInternal> = {
  */
 function buildSimpleAllowedTypeAttributesForStoredSchema(
 	types: TreeTypeSet,
-): ReadonlyMap<string, SimpleAllowedTypeAttributes> {
-	const allowedTypesInfo = new Map<string, SimpleAllowedTypeAttributes>();
+): ReadonlyMap<string, SimpleAllowedTypeAttributes<SchemaType.Stored>> {
+	const allowedTypesInfo = new Map<string, SimpleAllowedTypeAttributes<SchemaType.Stored>>();
 	for (const type of types) {
 		// Stored schemas do not have staged upgrades
 		allowedTypesInfo.set(type, { isStaged: undefined });
@@ -834,7 +851,9 @@ function buildSimpleAllowedTypeAttributesForStoredSchema(
 	return allowedTypesInfo;
 }
 
-function exportSimpleFieldSchemaStored(schema: TreeFieldStoredSchema): SimpleFieldSchema {
+function exportSimpleFieldSchemaStored(
+	schema: TreeFieldStoredSchema,
+): SimpleFieldSchema<SchemaType.Stored> {
 	let kind: FieldKind;
 	switch (schema.kind) {
 		case FieldKinds.identifier.identifier:
@@ -868,7 +887,9 @@ function exportSimpleFieldSchemaStored(schema: TreeFieldStoredSchema): SimpleFie
  * Note on SimpleNodeSchema construction: In the persisted format `persistedMetadata` is just called `metadata` whereas the `metadata`
  * field on SimpleNodeSchema is not persisted.
  */
-function exportSimpleNodeSchemaStored(schema: TreeNodeStoredSchema): SimpleNodeSchema {
+function exportSimpleNodeSchemaStored(
+	schema: TreeNodeStoredSchema,
+): SimpleNodeSchema<SchemaType.Stored> {
 	const arrayTypes = tryStoredSchemaAsArray(schema);
 	if (arrayTypes !== undefined) {
 		return {
@@ -879,7 +900,7 @@ function exportSimpleNodeSchemaStored(schema: TreeNodeStoredSchema): SimpleNodeS
 		};
 	}
 	if (schema instanceof ObjectNodeStoredSchema) {
-		const fields = new Map<FieldKey, SimpleObjectFieldSchema>();
+		const fields = new Map<FieldKey, SimpleObjectFieldSchema<SchemaType.Stored>>();
 		for (const [storedKey, field] of schema.objectNodeFields) {
 			fields.set(storedKey, { ...exportSimpleFieldSchemaStored(field), storedKey });
 		}

package/src/shared-tree/sharedTreeChangeCodecs.ts

@@ -74,7 +74,10 @@ interface ChangeFormatDependencies {
 	readonly schemaChange: SchemaFormatVersion;
 }
 
-export type SharedTreeChangeFormatVersion = Brand<3 | 4, "SharedTreeChangeFormatVersion">;
+export type SharedTreeChangeFormatVersion = Brand<
+	3 | 4 | 101,
+	"SharedTreeChangeFormatVersion"
+>;
 
 /**
  * Defines for each SharedTree change format the corresponding dependent formats to use.
@@ -88,6 +91,7 @@ export const dependenciesForChangeFormat: Map<
 > = new Map([
 	[brand(3), { modularChange: brand(3), schemaChange: brand(SchemaFormatVersion.v1) }],
 	[brand(4), { modularChange: brand(4), schemaChange: brand(SchemaFormatVersion.v1) }],
+	[brand(101), { modularChange: brand(101), schemaChange: brand(SchemaFormatVersion.v1) }],
 ]);
 
 export function getCodecTreeForChangeFormat(

package/src/shared-tree/sharedTreeChangeEnricher.ts

@@ -9,6 +9,8 @@ import {
 	type DeltaDetachedNodeId,
 	type DetachedFieldIndex,
 	type IEditableForest,
+	type IForestSubscription,
+	type ReadOnlyDetachedFieldIndex,
 	type RevisionTag,
 	type TreeStoredSchemaRepository,
 	tagChange,
@@ -35,24 +37,25 @@ export class SharedTreeReadonlyChangeEnricher
 	implements ChangeEnricherReadonlyCheckout<SharedTreeChange>
 {
 	/**
-	 * @param forest - The state based on which to enrich changes.
-	 * Exclusively owned by the constructed instance.
+	 * @param borrowedForest - The state based on which to enrich changes.
+	 * Not owned by the constructed instance.
 	 * @param schema - The schema that corresponds to the forest.
-	 * @param removedRoots - The set of removed roots based on which to enrich changes.
-	 * Exclusively owned by the constructed instance.
+	 * @param borrowedRemovedRoots - The set of removed roots based on which to enrich changes.
+	 * Not owned by the constructed instance.
+	 * @param idCompressor - The id compressor to use when chunking trees.
 	 */
 	public constructor(
-		protected readonly forest: IEditableForest,
+		protected readonly borrowedForest: IForestSubscription,
 		private readonly schema: TreeStoredSchemaRepository,
-		protected readonly removedRoots: DetachedFieldIndex,
+		protected readonly borrowedRemovedRoots: ReadOnlyDetachedFieldIndex,
 		private readonly idCompressor?: IIdCompressor,
 	) {}
 
 	public fork(): ChangeEnricherMutableCheckout<SharedTreeChange> {
 		return new SharedTreeMutableChangeEnricher(
-			this.forest.clone(this.schema, new AnchorSet()),
+			this.borrowedForest.clone(this.schema, new AnchorSet()),
 			this.schema,
-			this.removedRoots.clone(),
+			this.borrowedRemovedRoots.clone(),
 		);
 	}
 
@@ -66,10 +69,10 @@ export class SharedTreeReadonlyChangeEnricher
 	}
 
 	private readonly getDetachedRoot = (id: DeltaDetachedNodeId): TreeChunk | undefined => {
-		const root = this.removedRoots.tryGetEntry(id);
+		const root = this.borrowedRemovedRoots.tryGetEntry(id);
 		if (root !== undefined) {
-			const cursor = this.forest.getCursorAboveDetachedFields();
-			const parentField = this.removedRoots.toFieldKey(root);
+			const cursor = this.borrowedForest.getCursorAboveDetachedFields();
+			const parentField = this.borrowedRemovedRoots.toFieldKey(root);
 			cursor.enterField(parentField);
 			cursor.enterNode(0);
 			return chunkTree(cursor, {
@@ -85,6 +88,23 @@ export class SharedTreeMutableChangeEnricher
 	extends SharedTreeReadonlyChangeEnricher
 	implements ChangeEnricherMutableCheckout<SharedTreeChange>
 {
+	/**
+	 * @param forest - The state based on which to enrich changes.
+	 * Owned by the constructed instance.
+	 * @param schema - The schema that corresponds to the forest.
+	 * @param removedRoots - The set of removed roots based on which to enrich changes.
+	 * Owned by the constructed instance.
+	 * @param idCompressor - The id compressor to use when chunking trees.
+	 */
+	public constructor(
+		private readonly forest: IEditableForest,
+		schema: TreeStoredSchemaRepository,
+		private readonly removedRoots: DetachedFieldIndex,
+		idCompressor?: IIdCompressor,
+	) {
+		super(forest, schema, removedRoots, idCompressor);
+	}
+
 	public applyTipChange(change: SharedTreeChange, revision?: RevisionTag): void {
 		for (const dataOrSchemaChange of change.changes) {
 			const type = dataOrSchemaChange.type;