@fluidframework/tree 2.1.0-281041 → 2.1.0

package/src/core/tree/visitorUtils.ts

@@ -7,11 +7,12 @@ import { assert } from "@fluidframework/core-utils/internal";
 
 import type { ICodecOptions } from "../../codec/index.js";
 import { type IdAllocator, idAllocatorFromMaxId } from "../../util/index.js";
-import type { RevisionTagCodec } from "../rebase/index.js";
+import type { RevisionTag, RevisionTagCodec } from "../rebase/index.js";
 import type { FieldKey } from "../schema-stored/index.js";
 
 import type { ProtoNodes, Root } from "./delta.js";
-import { DetachedFieldIndex, type ForestRootId } from "./detachedFieldIndex.js";
+import { DetachedFieldIndex } from "./detachedFieldIndex.js";
+import type { ForestRootId } from "./detachedFieldIndexTypes.js";
 import type { PlaceIndex, Range } from "./pathTree.js";
 import { type DeltaVisitor, visitDelta } from "./visitDelta.js";
 import type { IIdCompressor } from "@fluidframework/id-compressor";
@@ -33,21 +34,23 @@ export function makeDetachedFieldIndex(
 
 export function applyDelta(
 	delta: Root,
+	latestRevision: RevisionTag | undefined,
 	deltaProcessor: { acquireVisitor: () => DeltaVisitor },
 	detachedFieldIndex: DetachedFieldIndex,
 ): void {
 	const visitor = deltaProcessor.acquireVisitor();
-	visitDelta(delta, visitor, detachedFieldIndex);
+	visitDelta(delta, visitor, detachedFieldIndex, latestRevision);
 	visitor.free();
 }
 
 export function announceDelta(
 	delta: Root,
+	latestRevision: RevisionTag | undefined,
 	deltaProcessor: { acquireVisitor: () => DeltaVisitor & AnnouncedVisitor },
 	detachedFieldIndex: DetachedFieldIndex,
 ): void {
 	const visitor = deltaProcessor.acquireVisitor();
-	visitDelta(delta, combineVisitors([visitor], [visitor]), detachedFieldIndex);
+	visitDelta(delta, combineVisitors([visitor], [visitor]), detachedFieldIndex, latestRevision);
 	visitor.free();
 }
 

package/src/feature-libraries/editableTreeBinder.ts

@@ -741,7 +741,7 @@ class AbstractDataBinder<
 		const visitor = getOrCreate(this.visitors, anchor, () => {
 			const newVisitor = this.visitorFactory(anchor);
 			this.unregisterHandles.add(
-				anchor.on("subtreeChanging", (upPath: UpPath) => {
+				anchor.anchorNode.on("subtreeChanging", (upPath: UpPath) => {
 					assert(newVisitor !== undefined, 0x6dc /* visitor expected to be defined */);
 					if (!this.visitorLocations.has(newVisitor)) {
 						this.visitorLocations.set(newVisitor, upPath);

package/src/feature-libraries/flex-map-tree/mapTreeNode.ts

@@ -14,7 +14,7 @@ import {
 	type TreeValue,
 	type Value,
 } from "../../core/index.js";
-import { brand, fail, getOrCreate, mapIterable } from "../../util/index.js";
+import { brand, fail, mapIterable } from "../../util/index.js";
 import {
 	type FlexTreeContext,
 	FlexTreeEntityKind,
@@ -23,7 +23,6 @@ import {
 	type FlexTreeLeafNode,
 	type FlexTreeMapNode,
 	type FlexTreeNode,
-	type FlexTreeNodeEvents,
 	type FlexTreeOptionalField,
 	type FlexTreeRequiredField,
 	type FlexTreeSequenceField,
@@ -34,7 +33,6 @@ import {
 	type FlexTreeUnboxNodeUnion,
 	type FlexibleFieldContent,
 	type FlexibleNodeSubSequence,
-	TreeStatus,
 	flexTreeMarker,
 	indexForAt,
 } from "../flex-tree/index.js";
@@ -54,7 +52,6 @@ import {
 import { type FlexImplicitAllowedTypes, normalizeAllowedTypes } from "../schemaBuilderBase.js";
 import type { FlexFieldKind } from "../modular-schema/index.js";
 import { FieldKinds, type SequenceFieldEditBuilder } from "../default-schema/index.js";
-import { ComposableEventEmitter, type Listenable, type Off } from "../../events/index.js";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 
 // #region Nodes
@@ -66,7 +63,6 @@ import { UsageError } from "@fluidframework/telemetry-utils/internal";
  */
 export interface MapTreeNode extends FlexTreeNode {
 	readonly mapTree: MapTree;
-	forwardEvents(to: Listenable<FlexTreeNodeEvents>): void;
 }
 
 /**
@@ -82,38 +78,6 @@ interface LocationInField {
 	readonly index: number;
 }
 
-/**
- * Allows events to be forwarded to another event emitter.
- * @remarks TODO: After the eventing library is simplified, find a way to support this pattern elegantly in the library.
- */
-class ForwardingEventEmitter extends ComposableEventEmitter<FlexTreeNodeEvents> {
-	// A map from deregistration functions produced by this class to deregistration functions of Listenables that have been forwarded to
-	private readonly forwardedOffs = new Map<Off, Off[]>();
-
-	public override on<K extends keyof FlexTreeNodeEvents>(
-		eventName: K,
-		listener: FlexTreeNodeEvents[K],
-	): Off {
-		const off = super.on(eventName, listener);
-		// Return a deregister function which...
-		return (): void => {
-			off(); // ...deregisters the event in this emitter,
-			// and also deregisters the event in any Listenable that it gets forwarded to
-			(this.forwardedOffs.get(off) ?? []).forEach((f) => f());
-		};
-	}
-
-	public forwardEvents(to: Listenable<FlexTreeNodeEvents>): void {
-		for (const [eventName, listeners] of this.listeners) {
-			for (const [off, listener] of listeners) {
-				// For every one of our listeners, make the same subscription in the Listenable that we're forwarding to,
-				// and then create a mapping from our deregistration function to theirs, so we can call it later if need be.
-				getOrCreate(this.forwardedOffs, off, () => []).push(to.on(eventName, listener));
-			}
-		}
-	}
-}
-
 /**
  * A readonly implementation of {@link FlexTreeNode} which wraps a {@link MapTree}.
  * @remarks Any methods that would mutate the node will fail,
@@ -123,10 +87,6 @@ class ForwardingEventEmitter extends ComposableEventEmitter<FlexTreeNodeEvents>
  */
 export class EagerMapTreeNode<TSchema extends FlexTreeNodeSchema> implements MapTreeNode {
 	public readonly [flexTreeMarker] = FlexTreeEntityKind.Node as const;
-	private readonly events = new ForwardingEventEmitter();
-	public forwardEvents(to: Listenable<FlexTreeNodeEvents>): void {
-		this.events.forwardEvents(to);
-	}
 
 	/**
 	 * Create a new MapTreeNode.
@@ -212,27 +172,10 @@ export class EagerMapTreeNode<TSchema extends FlexTreeNodeSchema> implements Map
 		);
 	}
 
-	public treeStatus(): TreeStatus {
-		return TreeStatus.New;
-	}
-
 	public get value(): Value {
 		return this.mapTree.value;
 	}
 
-	public on<K extends keyof FlexTreeNodeEvents>(
-		eventName: K,
-		listener: FlexTreeNodeEvents[K],
-	): () => void {
-		switch (eventName) {
-			case "nodeChanged":
-			case "treeChanged":
-				return this.events.on(eventName, listener);
-			default:
-				throw unsupportedUsageError(`Subscribing to ${eventName}`);
-		}
-	}
-
 	public get context(): FlexTreeContext {
 		// This API is relevant to `LazyTreeNode`s, but not `MapTreeNode`s.
 		// TODO: Refactor the FlexTreeNode interface so that stubbing this out isn't necessary.
@@ -418,9 +361,6 @@ export const rootMapTreeField: MapTreeField<FlexAllowedTypes> = {
 	get context(): FlexTreeContext {
 		return fail("MapTreeField does not implement context");
 	},
-	treeStatus(): TreeStatus {
-		return TreeStatus.New;
-	},
 	mapTrees: [],
 };
 
@@ -492,10 +432,6 @@ class MapTreeField<T extends FlexAllowedTypes> implements FlexTreeField {
 	public get context(): FlexTreeContext {
 		return fail("MapTreeField does not implement context");
 	}
-
-	public treeStatus(): TreeStatus {
-		return TreeStatus.New;
-	}
 }
 
 class MapTreeRequiredField<T extends FlexAllowedTypes>

package/src/feature-libraries/flex-tree/flexTreeTypes.ts

@@ -34,7 +34,6 @@ import type {
 } from "../typed-schema/index.js";
 
 import type { FlexTreeContext } from "./context.js";
-import type { FlexTreeNodeEvents } from "./treeEvents.js";
 
 /**
  * An anchor slot which records the {@link FlexTreeNode} associated with that anchor, if there is one.
@@ -98,14 +97,6 @@ export interface FlexTreeEntity<out TSchema = unknown> {
 	 */
 	readonly context: FlexTreeContext;
 
-	/**
-	 * Gets the {@link TreeStatus} of this tree.
-	 *
-	 * @remarks
-	 * For non-root fields, this is the status of the parent node, since fields do not have a separate lifetime.
-	 */
-	treeStatus(): TreeStatus;
-
 	/**
 	 * Iterate through all nodes/fields in this field/node.
 	 *
@@ -167,14 +158,6 @@ export interface FlexTreeNode extends FlexTreeEntity<FlexTreeNodeSchema> {
 	 */
 	readonly value?: TreeValue;
 
-	/**
-	 * {@inheritDoc ISubscribable#on}
-	 */
-	on<K extends keyof FlexTreeNodeEvents>(
-		eventName: K,
-		listener: FlexTreeNodeEvents[K],
-	): () => void;
-
 	/**
 	 * Gets a field of this node, if it is not empty.
 	 */
@@ -585,10 +568,8 @@ export const reservedObjectNodeFieldPropertyNames = [
 	"constructor",
 	"context",
 	"is",
-	"on",
 	"parentField",
 	"schema",
-	"treeStatus",
 	"tryGetField",
 	"type",
 	"value",

package/src/feature-libraries/flex-tree/index.ts

@@ -60,6 +60,12 @@ export type {
 	FlexibleNodeSubSequence,
 } from "./flexTreeTypes.js";
 
-export { assertFlexTreeEntityNotFreed } from "./lazyEntity.js";
+export {
+	assertFlexTreeEntityNotFreed,
+	isFreedSymbol,
+	LazyEntity,
+} from "./lazyEntity.js";
 
 export { getSchemaAndPolicy, indexForAt } from "./utilities.js";
+
+export { treeStatusFromAnchorCache } from "./utilities.js";

package/src/feature-libraries/flex-tree/lazyEntity.ts

@@ -16,7 +16,6 @@ import type { Context } from "./context.js";
 import {
 	type FlexTreeEntity,
 	type FlexTreeEntityKind,
-	type TreeStatus,
 	flexTreeMarker,
 } from "./flexTreeTypes.js";
 
@@ -65,8 +64,6 @@ export abstract class LazyEntity<TSchema = unknown, TAnchor = unknown>
 	public abstract boxedIterator(): IterableIterator<FlexTreeEntity>;
 	public abstract get [flexTreeMarker](): FlexTreeEntityKind;
 
-	public abstract treeStatus(): TreeStatus;
-
 	public [disposeSymbol](): void {
 		this.#lazyCursor.free();
 		this.context.withCursors.delete(this);

package/src/feature-libraries/flex-tree/lazyField.ts

@@ -16,7 +16,7 @@ import {
 	inCursorNode,
 	isCursor,
 	iterateCursorField,
-	keyAsDetachedField,
+	rootFieldKey,
 } from "../../core/index.js";
 import {
 	assertValidIndex,
@@ -64,11 +64,7 @@ import {
 } from "./lazyEntity.js";
 import { type LazyTreeNode, makeTree } from "./lazyNode.js";
 import { unboxedUnion } from "./unboxed.js";
-import {
-	indexForAt,
-	treeStatusFromAnchorCache,
-	treeStatusFromDetachedField,
-} from "./utilities.js";
+import { indexForAt, treeStatusFromAnchorCache } from "./utilities.js";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 
 /**
@@ -259,23 +255,6 @@ export abstract class LazyField<
 		);
 	}
 
-	public treeStatus(): TreeStatus {
-		if (this[isFreedSymbol]()) {
-			return TreeStatus.Deleted;
-		}
-		const fieldAnchor = this[anchorSymbol];
-		const parentAnchor = fieldAnchor.parent;
-		// If the parentAnchor is undefined it is a detached field.
-		if (parentAnchor === undefined) {
-			return treeStatusFromDetachedField(keyAsDetachedField(fieldAnchor.fieldKey));
-		}
-		const parentAnchorNode = this.context.checkout.forest.anchors.locate(parentAnchor);
-
-		// As the "parentAnchor === undefined" case is handled above, parentAnchorNode should exist.
-		assert(parentAnchorNode !== undefined, 0x77e /* parentAnchorNode must exist. */);
-		return treeStatusFromAnchorCache(parentAnchorNode);
-	}
-
 	public getFieldPath(): FieldUpPath {
 		return this[cursorSymbol].getFieldPath();
 	}
@@ -285,10 +264,19 @@ export abstract class LazyField<
 	 * This path is not valid to hold onto across edits: this must be recalled for each edit.
 	 */
 	public getFieldPathForEditing(): FieldUpPath {
-		if (this.treeStatus() !== TreeStatus.InDocument) {
-			throw new UsageError("Editing only allowed on fields with TreeStatus.InDocument status");
+		if (!this[isFreedSymbol]()) {
+			if (
+				// Only allow editing if we are the root document field...
+				(this.parent === undefined && this[anchorSymbol].fieldKey === rootFieldKey) ||
+				// ...or are under a node in the document
+				(this.parent !== undefined &&
+					treeStatusFromAnchorCache(this.parent.anchorNode) === TreeStatus.InDocument)
+			) {
+				return this.getFieldPath();
+			}
 		}
-		return this.getFieldPath();
+
+		throw new UsageError("Editing only allowed on fields with TreeStatus.InDocument status");
 	}
 }
 

package/src/feature-libraries/flex-tree/lazyNode.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { assert, unreachableCase } from "@fluidframework/core-utils/internal";
+import { assert } from "@fluidframework/core-utils/internal";
 
 import {
 	type Anchor,
@@ -55,7 +55,6 @@ import {
 	type FlexibleFieldContent,
 	type FlexibleNodeContent,
 	type PropertyNameFromFieldKey,
-	TreeStatus,
 	flexTreeMarker,
 	flexTreeSlot,
 	reservedObjectNodeFieldPropertyNamePrefixes,
@@ -66,13 +65,10 @@ import {
 	anchorSymbol,
 	cursorSymbol,
 	forgetAnchorSymbol,
-	isFreedSymbol,
 	tryMoveCursorToAnchorSymbol,
 } from "./lazyEntity.js";
 import { makeField } from "./lazyField.js";
-import type { FlexTreeNodeEvents } from "./treeEvents.js";
 import { unboxedField } from "./unboxed.js";
-import { treeStatusFromAnchorCache } from "./utilities.js";
 
 /**
  * @param cursor - This does not take ownership of this cursor: Node will fork it as needed.
@@ -256,43 +252,6 @@ export abstract class LazyTreeNode<TSchema extends FlexTreeNodeSchema = FlexTree
 
 		return { parent: proxifiedField, index };
 	}
-
-	public override treeStatus(): TreeStatus {
-		if (this[isFreedSymbol]()) {
-			return TreeStatus.Deleted;
-		}
-		return treeStatusFromAnchorCache(this.anchorNode);
-	}
-
-	public on<K extends keyof FlexTreeNodeEvents>(
-		eventName: K,
-		listener: FlexTreeNodeEvents[K],
-	): () => void {
-		switch (eventName) {
-			case "changing": {
-				const unsubscribeFromChildrenChange = this.anchorNode.on(
-					"childrenChanging",
-					(anchorNode: AnchorNode) => listener(anchorNode),
-				);
-				return unsubscribeFromChildrenChange;
-			}
-			case "subtreeChanging": {
-				const unsubscribeFromSubtreeChange = this.anchorNode.on(
-					"subtreeChanging",
-					(anchorNode: AnchorNode) => listener(anchorNode),
-				);
-				return unsubscribeFromSubtreeChange;
-			}
-			case "nodeChanged": {
-				return this.anchorNode.on("childrenChangedAfterBatch", listener);
-			}
-			case "treeChanged": {
-				return this.anchorNode.on("subtreeChangedAfterBatch", listener);
-			}
-			default:
-				unreachableCase(eventName);
-		}
-	}
 }
 
 export class LazyMap<TSchema extends FlexMapNodeSchema>

package/src/feature-libraries/forest-summary/forestSummarizer.ts

@@ -158,6 +158,7 @@ export class ForestSummarizer implements Summarizable {
 			assert(this.forest.isEmpty, 0x797 /* forest must be empty */);
 			applyDelta(
 				{ build, fields: new Map(fieldChanges) },
+				undefined,
 				this.forest,
 				makeDetachedFieldIndex("init", this.revisionTagCodec, this.idCompressor),
 			);

package/src/feature-libraries/index.ts

@@ -280,6 +280,9 @@ export {
 	assertFlexTreeEntityNotFreed,
 	flexTreeSlot,
 	getSchemaAndPolicy,
+	isFreedSymbol,
+	LazyEntity,
+	treeStatusFromAnchorCache,
 } from "./flex-tree/index.js";
 
 export { treeSchemaFromStoredSchema } from "./storedToViewSchema.js";

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

@@ -147,7 +147,7 @@ export function getAllowedContentIncompatibilities(
 				const storedNodeSchema = stored.nodeSchema.get(key);
 				assert(
 					storedNodeSchema !== undefined,
-					"The storedNodeSchema in stored.nodeSchema should not be undefined",
+					0x9be /* The storedNodeSchema in stored.nodeSchema should not be undefined */,
 				);
 				if (storedNodeSchema instanceof MapNodeStoredSchema) {
 					incompatibilities.push({
@@ -188,7 +188,7 @@ export function getAllowedContentIncompatibilities(
 				const storedNodeSchema = stored.nodeSchema.get(key);
 				assert(
 					storedNodeSchema !== undefined,
-					"The storedNodeSchema in stored.nodeSchema should not be undefined",
+					0x9bf /* The storedNodeSchema in stored.nodeSchema should not be undefined */,
 				);
 				if (storedNodeSchema instanceof ObjectNodeStoredSchema) {
 					incompatibilities.push({
@@ -228,7 +228,7 @@ export function getAllowedContentIncompatibilities(
 				const storedNodeSchema = stored.nodeSchema.get(key);
 				assert(
 					storedNodeSchema !== undefined,
-					"The storedNodeSchema in stored.nodeSchema should not be undefined",
+					0x9c0 /* The storedNodeSchema in stored.nodeSchema should not be undefined */,
 				);
 				if (storedNodeSchema instanceof MapNodeStoredSchema) {
 					incompatibilities.push({

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

@@ -511,6 +511,6 @@ function getChangeHandler(
 	}
 
 	const handler = fieldKinds.get(fieldKind)?.kind.changeHandler;
-	assert(handler !== undefined, "Unknown field kind");
+	assert(handler !== undefined, 0x9c1 /* Unknown field kind */);
 	return handler;
 }

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

@@ -211,16 +211,12 @@ export class ModularChangeFamily
 		const { revInfos, maxId } = getRevInfoFromTaggedChanges(changes);
 		const idState: IdAllocationState = { maxId };
 
-		return changes.reduce(
-			(change1, change2) =>
-				makeAnonChange(this.composePair(change1, change2, revInfos, idState)),
-			makeAnonChange({
-				fieldChanges: new Map(),
-				nodeChanges: new Map(),
-				nodeToParent: new Map(),
-				nodeAliases: new Map(),
-				crossFieldKeys: newCrossFieldKeyTable(),
-			}),
+		if (changes.length === 0) {
+			return makeModularChangeset();
+		}
+
+		return changes.reduce((change1, change2) =>
+			makeAnonChange(this.composePair(change1, change2, revInfos, idState)),
 		).change;
 	}
 
@@ -1024,7 +1020,10 @@ export class ModularChangeFamily
 				baseNodeId,
 			).get(fieldKey);
 
-			assert(baseFieldChange !== undefined, "Cross field key registered for empty field");
+			assert(
+				baseFieldChange !== undefined,
+				0x9c2 /* Cross field key registered for empty field */,
+			);
 			if (crossFieldTable.baseFieldToContext.has(baseFieldChange)) {
 				// This field has already been processed because there were changes to rebase.
 				continue;
@@ -1037,7 +1036,7 @@ export class ModularChangeFamily
 				baseChild: NodeId | undefined,
 				stateChange: NodeAttachState | undefined,
 			): NodeId | undefined => {
-				assert(child === undefined, "There should be no new changes in this field");
+				assert(child === undefined, 0x9c3 /* There should be no new changes in this field */);
 				return undefined;
 			};
 
@@ -1109,7 +1108,7 @@ export class ModularChangeFamily
 				return;
 			}
 
-			assert(!rebasedNode.fieldChanges.has(fieldKey), "Expected an empty field");
+			assert(!rebasedNode.fieldChanges.has(fieldKey), 0x9c4 /* Expected an empty field */);
 			rebasedNode.fieldChanges.set(fieldKey, rebasedField);
 			return;
 		}
@@ -2233,7 +2232,7 @@ class InvertManager extends CrossFieldManagerI<FieldChange> {
 		id: ChangesetLocalId,
 		count: number,
 	): void {
-		assert(false, "Keys should not be moved manually during invert");
+		assert(false, 0x9c5 /* Keys should not be moved manually during invert */);
 	}
 
 	private get table(): InvertTable {
@@ -2269,7 +2268,7 @@ class RebaseManager extends CrossFieldManagerI<FieldChange> {
 
 			assert(
 				newFieldIds.length === 0,
-				"TODO: Modifying a cross-field key from the new changeset is currently unsupported",
+				0x9c6 /* TODO: Modifying a cross-field key from the new changeset is currently unsupported */,
 			);
 
 			const baseFieldIds = getFieldsForCrossFieldKey(this.table.baseChange, [
@@ -2279,7 +2278,10 @@ class RebaseManager extends CrossFieldManagerI<FieldChange> {
 				count,
 			]);
 
-			assert(baseFieldIds.length > 0, "Cross field key not registered in base or new change");
+			assert(
+				baseFieldIds.length > 0,
+				0x9c7 /* Cross field key not registered in base or new change */,
+			);
 
 			for (const baseFieldId of baseFieldIds) {
 				this.table.affectedBaseFields.set(
@@ -2356,7 +2358,7 @@ class ComposeManager extends CrossFieldManagerI<FieldChange> {
 
 				assert(
 					baseFieldIds.length > 0,
-					"Cross field key not registered in base or new change",
+					0x9c8 /* Cross field key not registered in base or new change */,
 				);
 
 				for (const baseFieldId of baseFieldIds) {
@@ -2798,7 +2800,7 @@ function fieldMapFromNodeId(
 	}
 
 	const node = nodeChangeFromId(nodes, nodeId);
-	assert(node.fieldChanges !== undefined, "Expected node to have field changes");
+	assert(node.fieldChanges !== undefined, 0x9c9 /* Expected node to have field changes */);
 	return node.fieldChanges;
 }
 
@@ -2816,7 +2818,7 @@ function rebasedNodeIdFromBaseNodeId(table: RebaseTable, baseId: NodeId): NodeId
 
 function nodeChangeFromId(nodes: ChangeAtomIdMap<NodeChangeset>, id: NodeId): NodeChangeset {
 	const node = getFromChangeAtomIdMap(nodes, id);
-	assert(node !== undefined, "Unknown node ID");
+	assert(node !== undefined, 0x9ca /* Unknown node ID */);
 	return node;
 }
 
@@ -2850,7 +2852,7 @@ function replaceFieldIdRevision(
 
 export function getParentFieldId(changeset: ModularChangeset, nodeId: NodeId): FieldId {
 	const parentId = getFromChangeAtomIdMap(changeset.nodeToParent, nodeId);
-	assert(parentId !== undefined, "Parent field should be defined");
+	assert(parentId !== undefined, 0x9cb /* Parent field should be defined */);
 	return normalizeFieldId(parentId, changeset.nodeAliases);
 }
 

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/packageVersion.ts

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

package/src/shared-tree/sharedTree.ts

@@ -193,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",
@@ -335,6 +337,7 @@ export class SharedTree
 
 	protected override async loadCore(services: IChannelStorageService): Promise<void> {
 		await super.loadCore(services);
+		this.checkout.setTipRevisionForLoadedData(this.trunkHeadRevision);
 		this._events.emit("afterBatch");
 	}
 }
@@ -423,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);