@fluidframework/tree 2.2.0 → 2.3.0

package/src/shared-tree/checkoutFlexTreeView.ts

@@ -0,0 +1,89 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { assert } from "@fluidframework/core-utils/internal";
+import {
+	type Context,
+	type FlexTreeField,
+	type FlexTreeSchema,
+	type NodeKeyManager,
+	getTreeContext,
+	type FlexTreeHydratedContext,
+} from "../feature-libraries/index.js";
+import { tryDisposeTreeNode } from "../simple-tree/index.js";
+import { disposeSymbol } from "../util/index.js";
+
+import type { ITreeCheckout, ITreeCheckoutFork } from "./treeCheckout.js";
+
+/**
+ * An editable view of a (version control style) branch of a shared tree.
+ */
+export class CheckoutFlexTreeView<out TCheckout extends ITreeCheckout = ITreeCheckout> {
+	/**
+	 * Context for controlling the FlexTree nodes produced from {@link FlexTreeView.flexTree}.
+	 *
+	 * @remarks
+	 * This is an owning reference: disposing of this view disposes its context.
+	 */
+	public readonly context: Context;
+
+	/**
+	 * Get a typed view of the tree content using the flex-tree API.
+	 */
+	public readonly flexTree: FlexTreeField;
+
+	public constructor(
+		/**
+		 * Access non-view schema specific aspects of this branch.
+		 *
+		 * @remarks
+		 * This is a non-owning reference: disposing of this view does not impact the branch.
+		 */
+		public readonly checkout: TCheckout,
+		public readonly schema: FlexTreeSchema,
+		public readonly nodeKeyManager: NodeKeyManager,
+		private readonly onDispose?: () => void,
+	) {
+		this.context = getTreeContext(schema, this.checkout, nodeKeyManager);
+		contextToTreeViewMap.set(this.context, this);
+		this.flexTree = this.context.root;
+	}
+
+	public [disposeSymbol](): void {
+		for (const anchorNode of this.checkout.forest.anchors) {
+			tryDisposeTreeNode(anchorNode);
+		}
+
+		this.context[disposeSymbol]();
+		this.onDispose?.();
+	}
+
+	/**
+	 * Spawn a new view which is based off of the current state of this view.
+	 * Any mutations of the new view will not apply to this view until the new view is merged back into this view via `merge()`.
+	 */
+	public fork(): CheckoutFlexTreeView<ITreeCheckout & ITreeCheckoutFork> {
+		const branch = this.checkout.fork();
+		return new CheckoutFlexTreeView(branch, this.schema, this.nodeKeyManager);
+	}
+}
+
+/**
+ * Maps the context of every {@link CheckoutFlexTreeView} to the view.
+ * In practice, this allows the view or checkout to be obtained from a flex node by first getting the context from the flex node and then using this map.
+ */
+const contextToTreeViewMap = new WeakMap<FlexTreeHydratedContext, CheckoutFlexTreeView>();
+
+/**
+ * Retrieve the {@link CheckoutFlexTreeView | view} for the given {@link FlexTreeHydratedContext | context}.
+ * @remarks Every {@link CheckoutFlexTreeView} is associated with its context upon creation.
+ */
+export function getCheckoutFlexTreeView(
+	context: FlexTreeHydratedContext,
+): CheckoutFlexTreeView {
+	const view = contextToTreeViewMap.get(context);
+	assert(view !== undefined, 0xa41 /* Expected view to be registered for context */);
+	return view;
+}

package/src/shared-tree/index.ts

@@ -22,23 +22,18 @@ export {
 	type CheckoutEvents,
 	type ITransaction,
 	type ITreeCheckoutFork,
-	type RevertibleFactory,
 } from "./treeCheckout.js";
 
 export {
 	type SchematizeConfiguration,
 	type TreeContent,
+	type TreeStoredContent,
 	type InitializeAndSchematizeConfiguration,
 	type SchemaConfiguration,
 	buildTreeConfiguration,
 } from "./schematizeTree.js";
 
-export {
-	type FlexTreeView,
-	CheckoutFlexTreeView,
-	type ITreeViewFork,
-	type FlexTreeViewGeneric,
-} from "./treeView.js";
+export { CheckoutFlexTreeView } from "./checkoutFlexTreeView.js";
 
 export type { ISharedTreeEditor, ISchemaEditor } from "./sharedTreeEditBuilder.js";
 

package/src/shared-tree/schematizeTree.ts

@@ -22,7 +22,6 @@ import {
 	allowsRepoSuperset,
 	cursorForMapTreeField,
 	defaultSchemaPolicy,
-	intoStoredSchema,
 	mapTreeFromCursor,
 } from "../feature-libraries/index.js";
 import { fail, isReadonlyArray } from "../util/index.js";
@@ -46,7 +45,7 @@ export function initializeContent(
 		storedSchema: ITreeCheckout["storedSchema"];
 		updateSchema: ITreeCheckout["updateSchema"];
 	},
-	newSchema: FlexTreeSchema,
+	newSchema: TreeStoredSchema,
 	setInitialTree: () => void,
 ): void {
 	assert(
@@ -54,8 +53,7 @@ export function initializeContent(
 		0x743 /* cannot initialize after a schema is set */,
 	);
 
-	const schema = intoStoredSchema(newSchema);
-	const rootSchema = schema.rootFieldSchema;
+	const rootSchema = newSchema.rootFieldSchema;
 	const rootKind = rootSchema.kind;
 
 	// To keep the data in schema during the update, first define a schema that tolerates the current (empty) tree as well as the final (initial) tree.
@@ -65,12 +63,12 @@ export function initializeContent(
 		rootKind === FieldKinds.optional.identifier
 	) {
 		// These kinds are known to tolerate empty, so use the schema as is:
-		incrementalSchemaUpdate = schema;
+		incrementalSchemaUpdate = newSchema;
 	} else {
 		assert(rootKind === FieldKinds.required.identifier, 0x5c8 /* Unexpected kind */);
 		// Replace value kind with optional kind in root field schema:
 		incrementalSchemaUpdate = {
-			nodeSchema: schema.nodeSchema,
+			nodeSchema: newSchema.nodeSchema,
 			rootFieldSchema: {
 				kind: FieldKinds.optional.identifier,
 				types: rootSchema.types,
@@ -84,7 +82,7 @@ export function initializeContent(
 	// 	"Incremental Schema update should support the existing empty tree",
 	// );
 	assert(
-		allowsRepoSuperset(defaultSchemaPolicy, schema, incrementalSchemaUpdate),
+		allowsRepoSuperset(defaultSchemaPolicy, newSchema, incrementalSchemaUpdate),
 		0x5c9 /* Incremental Schema during update should be a allow a superset of the final schema */,
 	);
 	// Update to intermediate schema
@@ -93,8 +91,8 @@ export function initializeContent(
 	setInitialTree();
 
 	// If intermediate schema is not final desired schema, update to the final schema:
-	if (incrementalSchemaUpdate !== schema) {
-		schemaRepository.updateSchema(schema);
+	if (incrementalSchemaUpdate !== newSchema) {
+		schemaRepository.updateSchema(newSchema);
 	}
 }
 
@@ -182,7 +180,7 @@ function normalizeNewFieldContent(
  * If the proposed schema (from `treeContent`) is not compatible with the emptry tree, this function handles using an intermediate schema
  * which supports the empty tree as well as the final tree content.
  */
-export function initialize(checkout: ITreeCheckout, treeContent: TreeContent): void {
+export function initialize(checkout: ITreeCheckout, treeContent: TreeStoredContent): void {
 	checkout.transaction.start();
 	try {
 		initializeContent(checkout, treeContent.schema, () => {
@@ -231,7 +229,7 @@ export function ensureSchema(
 	viewSchema: ViewSchema,
 	allowedSchemaModifications: AllowedUpdateType,
 	checkout: ITreeCheckout,
-	treeContent: TreeContent | undefined,
+	treeContent: TreeStoredContent | undefined,
 ): boolean {
 	let possibleModifications = allowedSchemaModifications;
 	if (treeContent === undefined) {
@@ -248,7 +246,7 @@ export function ensureSchema(
 			return false;
 		}
 		case UpdateType.SchemaCompatible: {
-			checkout.updateSchema(intoStoredSchema(viewSchema.schema));
+			checkout.updateSchema(viewSchema.storedSchema);
 			return true;
 		}
 		case UpdateType.Initialize: {
@@ -289,6 +287,19 @@ export interface TreeContent<TRoot extends FlexFieldSchema = FlexFieldSchema>
 	readonly initialTree: readonly ITreeCursorSynchronous[] | ITreeCursorSynchronous | undefined;
 }
 
+/**
+ * Content that can populate a `SharedTree`.
+ */
+export interface TreeStoredContent {
+	readonly schema: TreeStoredSchema;
+
+	/**
+	 * Default tree content to initialize the tree with iff the tree is uninitialized
+	 * (meaning it does not even have any schema set at all).
+	 */
+	readonly initialTree: readonly ITreeCursorSynchronous[] | ITreeCursorSynchronous | undefined;
+}
+
 /**
  * Options used to schematize a `SharedTree`.
  */

package/src/shared-tree/schematizingTreeView.ts

@@ -6,7 +6,7 @@
 import { assert } from "@fluidframework/core-utils/internal";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 
-import { AllowedUpdateType, Compatibility } from "../core/index.js";
+import { AllowedUpdateType, anchorSlot, Compatibility } from "../core/index.js";
 import {
 	type HasListeners,
 	type IEmitter,
@@ -14,13 +14,13 @@ import {
 	createEmitter,
 } from "../events/index.js";
 import {
-	type FlexFieldSchema,
 	type NodeKeyManager,
 	ViewSchema,
 	defaultSchemaPolicy,
 	ContextSlot,
 	cursorForMapTreeNode,
 	type FlexTreeSchema,
+	intoStoredSchema,
 } from "../feature-libraries/index.js";
 import {
 	type FieldSchema,
@@ -43,7 +43,12 @@ import { Breakable, breakingClass, disposeSymbol, type WithBreakable } from "../
 
 import { canInitialize, ensureSchema, initialize } from "./schematizeTree.js";
 import type { ITreeCheckout } from "./treeCheckout.js";
-import { CheckoutFlexTreeView } from "./treeView.js";
+import { CheckoutFlexTreeView } from "./checkoutFlexTreeView.js";
+/**
+ * Creating multiple tree views from the same checkout is not supported. This slot is used to detect if one already
+ * exists and error if creating a second.
+ */
+export const ViewSlot = anchorSlot<TreeView<ImplicitFieldSchema>>();
 
 /**
  * Implementation of TreeView wrapping a FlexTreeView.
@@ -57,7 +62,7 @@ export class SchematizingSimpleTreeView<in out TRootSchema extends ImplicitField
 	 *
 	 * The view schema may be incompatible with the stored schema. Use `compatibility` to check.
 	 */
-	private view: CheckoutFlexTreeView<FlexFieldSchema> | undefined;
+	private view: CheckoutFlexTreeView | undefined;
 
 	/**
 	 * Undefined iff uninitialized or disposed.
@@ -89,6 +94,11 @@ export class SchematizingSimpleTreeView<in out TRootSchema extends ImplicitField
 		public readonly nodeKeyManager: NodeKeyManager,
 		public readonly breaker: Breakable = new Breakable("SchematizingSimpleTreeView"),
 	) {
+		if (checkout.forest.anchors.slots.has(ViewSlot)) {
+			throw new UsageError("Cannot create a second tree view from the same checkout");
+		}
+		checkout.forest.anchors.slots.set(ViewSlot, this);
+
 		const policy = {
 			...defaultSchemaPolicy,
 			validateSchema: config.enableSchemaValidation,
@@ -96,7 +106,7 @@ export class SchematizingSimpleTreeView<in out TRootSchema extends ImplicitField
 		this.rootFieldSchema = normalizeFieldSchema(config.schema);
 		this.flexSchema = toFlexSchema(config.schema);
 
-		this.viewSchema = new ViewSchema(policy, {}, this.flexSchema);
+		this.viewSchema = new ViewSchema(policy, {}, intoStoredSchema(this.flexSchema));
 		// This must be initialized before `update` can be called.
 		this.currentCompatibility = {
 			canView: false,
@@ -137,7 +147,7 @@ export class SchematizingSimpleTreeView<in out TRootSchema extends ImplicitField
 
 			prepareContentForHydration(mapTree, this.checkout.forest);
 			initialize(this.checkout, {
-				schema: this.flexSchema,
+				schema: this.viewSchema.storedSchema,
 				initialTree: mapTree === undefined ? undefined : cursorForMapTreeNode(mapTree),
 			});
 		});
@@ -164,7 +174,7 @@ export class SchematizingSimpleTreeView<in out TRootSchema extends ImplicitField
 				AllowedUpdateType.SchemaCompatible,
 				this.checkout,
 				{
-					schema: this.flexSchema,
+					schema: this.viewSchema.storedSchema,
 					initialTree: undefined,
 				},
 			);
@@ -175,7 +185,7 @@ export class SchematizingSimpleTreeView<in out TRootSchema extends ImplicitField
 	/**
 	 * Gets the view. Throws when disposed.
 	 */
-	public getView(): CheckoutFlexTreeView<FlexFieldSchema> {
+	public getView(): CheckoutFlexTreeView {
 		this.ensureUndisposed();
 		assert(this.view !== undefined, 0x8c0 /* unexpected getViewOrError */);
 		return this.view;
@@ -252,12 +262,21 @@ export class SchematizingSimpleTreeView<in out TRootSchema extends ImplicitField
 				}
 			};
 
-			this.view = requireSchema(
+			const view = requireSchema(
 				this.checkout,
 				this.viewSchema,
 				onViewDispose,
 				this.nodeKeyManager,
+				this.flexSchema,
 			);
+			this.view = view;
+
+			const unregister = this.checkout.storedSchema.on("afterSchemaChange", () => {
+				unregister();
+				this.unregisterCallbacks.delete(unregister);
+				view[disposeSymbol]();
+			});
+			this.unregisterCallbacks.add(unregister);
 		} else {
 			this.view = undefined;
 
@@ -304,6 +323,7 @@ export class SchematizingSimpleTreeView<in out TRootSchema extends ImplicitField
 	public dispose(): void {
 		this.disposed = true;
 		this.disposeView();
+		this.checkout.forest.anchors.slots.delete(ViewSlot);
 		this.currentCompatibility = undefined;
 	}
 
@@ -334,12 +354,13 @@ export class SchematizingSimpleTreeView<in out TRootSchema extends ImplicitField
  * Creates a view that self-disposes whenenever the stored schema changes.
  * This may only be called when the schema is already known to be compatible (typically via ensureSchema).
  */
-export function requireSchema<TRoot extends FlexFieldSchema>(
+export function requireSchema(
 	checkout: ITreeCheckout,
-	viewSchema: ViewSchema<TRoot>,
+	viewSchema: ViewSchema,
 	onDispose: () => void,
 	nodeKeyManager: NodeKeyManager,
-): CheckoutFlexTreeView<TRoot> {
+	flexTreeSchema: FlexTreeSchema,
+): CheckoutFlexTreeView {
 	const slots = checkout.forest.anchors.slots;
 	assert(!slots.has(ContextSlot), 0x8c2 /* Cannot create second view from checkout */);
 
@@ -352,18 +373,7 @@ export function requireSchema<TRoot extends FlexFieldSchema>(
 		);
 	}
 
-	const view = new CheckoutFlexTreeView(
-		checkout,
-		viewSchema.schema,
-		nodeKeyManager,
-		onDispose,
-	);
+	const view = new CheckoutFlexTreeView(checkout, flexTreeSchema, nodeKeyManager, onDispose);
 	assert(slots.has(ContextSlot), 0x90d /* Context should be tracked in slot */);
-
-	const unregister = checkout.storedSchema.on("afterSchemaChange", () => {
-		unregister();
-		view[disposeSymbol]();
-	});
-
 	return view;
 }

package/src/shared-tree/sharedTree.ts

@@ -178,7 +178,11 @@ export class SharedTree
 		const schema = new TreeStoredSchemaRepository();
 		const forest =
 			options.forest === ForestType.Optimized
-				? buildChunkedForest(makeTreeChunker(schema, defaultSchemaPolicy))
+				? buildChunkedForest(
+						makeTreeChunker(schema, defaultSchemaPolicy),
+						undefined,
+						runtime.idCompressor,
+					)
 				: options.forest === ForestType.Reference
 					? buildForest()
 					: buildForest(undefined, true);
@@ -217,6 +221,7 @@ export class SharedTree
 			fieldBatchCodec,
 			options,
 			options.treeEncodeType,
+			runtime.idCompressor,
 		);
 		const changeFamily = makeMitigatedChangeFamily(
 			innerChangeFamily,

package/src/shared-tree/sharedTreeChangeEnricher.ts

@@ -29,6 +29,7 @@ import type {
 	ChangeEnricherMutableCheckout,
 	ChangeEnricherReadonlyCheckout,
 } from "../shared-tree-core/index.js";
+import type { IIdCompressor } from "@fluidframework/id-compressor";
 
 export class SharedTreeReadonlyChangeEnricher
 	implements ChangeEnricherReadonlyCheckout<SharedTreeChange>
@@ -44,6 +45,7 @@ export class SharedTreeReadonlyChangeEnricher
 		protected readonly forest: IEditableForest,
 		private readonly schema: TreeStoredSchemaRepository,
 		protected readonly removedRoots: DetachedFieldIndex,
+		private readonly idCompressor?: IIdCompressor,
 	) {}
 
 	public fork(): ChangeEnricherMutableCheckout<SharedTreeChange> {
@@ -70,7 +72,10 @@ export class SharedTreeReadonlyChangeEnricher
 			const parentField = this.removedRoots.toFieldKey(root);
 			cursor.enterField(parentField);
 			cursor.enterNode(0);
-			return chunkTree(cursor, defaultChunkPolicy);
+			return chunkTree(cursor, {
+				policy: defaultChunkPolicy,
+				idCompressor: this.idCompressor,
+			});
 		}
 		return undefined;
 	};

package/src/shared-tree/sharedTreeChangeFamily.ts

@@ -38,6 +38,7 @@ import {
 import { makeSharedTreeChangeCodecFamily } from "./sharedTreeChangeCodecs.js";
 import type { SharedTreeChange } from "./sharedTreeChangeTypes.js";
 import { SharedTreeEditBuilder } from "./sharedTreeEditBuilder.js";
+import type { IIdCompressor } from "@fluidframework/id-compressor";
 
 /**
  * Implementation of {@link ChangeFamily} that combines edits to fields and schema changes.
@@ -61,6 +62,7 @@ export class SharedTreeChangeFamily
 		fieldBatchCodec: FieldBatchCodec,
 		codecOptions: ICodecOptions,
 		chunkCompressionStrategy?: TreeCompressionStrategy,
+		private readonly idCompressor?: IIdCompressor,
 	) {
 		const modularChangeCodec = makeModularChangeCodecFamily(
 			fieldKindConfigurations,
@@ -79,7 +81,11 @@ export class SharedTreeChangeFamily
 	public buildEditor(
 		changeReceiver: (change: SharedTreeChange) => void,
 	): SharedTreeEditBuilder {
-		return new SharedTreeEditBuilder(this.modularChangeFamily, changeReceiver);
+		return new SharedTreeEditBuilder(
+			this.modularChangeFamily,
+			changeReceiver,
+			this.idCompressor,
+		);
 	}
 
 	public compose(changes: TaggedChange<SharedTreeChange>[]): SharedTreeChange {

package/src/shared-tree/sharedTreeEditBuilder.ts

@@ -3,6 +3,7 @@
  * Licensed under the MIT License.
  */
 
+import type { IIdCompressor } from "@fluidframework/id-compressor";
 import type { ChangeFamilyEditor, TreeStoredSchema } from "../core/index.js";
 import {
 	DefaultEditBuilder,
@@ -48,11 +49,15 @@ export class SharedTreeEditBuilder
 	public constructor(
 		modularChangeFamily: ModularChangeFamily,
 		private readonly changeReceiver: (change: SharedTreeChange) => void,
+		idCompressor?: IIdCompressor,
 	) {
-		super(modularChangeFamily, (change) =>
-			changeReceiver({
-				changes: [{ type: "data", innerChange: change }],
-			}),
+		super(
+			modularChangeFamily,
+			(change) =>
+				changeReceiver({
+					changes: [{ type: "data", innerChange: change }],
+				}),
+			idCompressor,
 		);
 
 		this.schema = {

package/src/shared-tree/treeApi.ts

@@ -4,8 +4,9 @@
  */
 
 import { assert, unreachableCase } from "@fluidframework/core-utils/internal";
+import { UsageError } from "@fluidframework/telemetry-utils/internal";
 
-import { Context, TreeStatus } from "../feature-libraries/index.js";
+import { TreeStatus } from "../feature-libraries/index.js";
 import {
 	type ImplicitFieldSchema,
 	type TreeNode,
@@ -14,11 +15,10 @@ import {
 	getOrCreateInnerNode,
 	treeNodeApi,
 } from "../simple-tree/index.js";
-import { fail } from "../util/index.js";
 
 import { SchematizingSimpleTreeView } from "./schematizingTreeView.js";
 import type { ITreeCheckout } from "./treeCheckout.js";
-import { contextToTreeView } from "./treeView.js";
+import { getCheckoutFlexTreeView } from "./checkoutFlexTreeView.js";
 
 /**
  * A special object that signifies when a SharedTree {@link RunTransaction | transaction} should "roll back".
@@ -324,9 +324,7 @@ export interface RunTransaction {
  * Provides various functions for interacting with {@link TreeNode}s.
  * @remarks
  * This type should only be used via the public `Tree` export.
- * @privateRemarks
- * Due to limitations of API-Extractor link resolution, this type can't be moved into internalTypes but should be considered just an implementation detail of the `Tree` export.
- * @sealed @public
+ * @system @sealed @public
  */
 export interface TreeApi extends TreeNodeApi {
 	/**
@@ -436,10 +434,12 @@ export function runTransaction<
 		const node = treeOrNode as TNode;
 		const t = transaction as (node: TNode) => TResult | typeof rollback;
 		const context = getOrCreateInnerNode(node).context;
-		assert(context instanceof Context, 0x901 /* Unsupported context */);
-		const treeView =
-			contextToTreeView.get(context) ?? fail("Expected view to be registered for context");
-
+		if (context.isHydrated() === false) {
+			throw new UsageError(
+				"Transactions cannot be run on Unhydrated nodes. Transactions apply to a TreeView and Unhydrated nodes are not part of a TreeView.",
+			);
+		}
+		const treeView = getCheckoutFlexTreeView(context);
 		return runTransactionInCheckout(treeView.checkout, () => t(node), preconditions);
 	}
 }

package/src/shared-tree/treeCheckout.ts

@@ -35,8 +35,10 @@ import {
 	makeAnonChange,
 	makeDetachedFieldIndex,
 	rebaseChange,
+	rootFieldKey,
 	tagChange,
 	visitDelta,
+	type RevertibleFactory,
 } from "../core/index.js";
 import {
 	type HasListeners,
@@ -87,21 +89,6 @@ export interface CheckoutEvents {
 	commitApplied(data: CommitMetadata, getRevertible?: RevertibleFactory): void;
 }
 
-/**
- * Factory for creating a {@link Revertible}.
- * Will error if invoked outside the scope of the `commitApplied` event that provides it, or if invoked multiple times.
- *
- * @param onRevertibleDisposed - A callback that will be invoked when the `Revertible` generated by this factory is disposed.
- * This happens when the `Revertible` is disposed manually, or when the `TreeView` that the `Revertible` belongs to is disposed,
- * whichever happens first.
- * This is typically used to clean up any resources associated with the `Revertible` in the host application.
- *
- * @sealed @public
- */
-export type RevertibleFactory = (
-	onRevertibleDisposed?: (revertible: Revertible) => void,
-) => Revertible;
-
 /**
  * Provides a means for interacting with a SharedTree.
  * This includes reading data from the tree and running transactions to mutate the tree.
@@ -237,6 +224,7 @@ export function createTreeCheckout(
 				makeFieldBatchCodec(defaultCodecOptions, defaultFieldBatchVersion),
 			{ jsonValidator: noopValidator },
 			args?.chunkCompressionStrategy,
+			idCompressor,
 		);
 	const branch =
 		args?.branch ??
@@ -656,6 +644,7 @@ export class TreeCheckout implements ITreeCheckoutFork {
 	}
 
 	public getRemovedRoots(): [string | number | undefined, number, JsonableTree][] {
+		this.assertNoUntrackedRoots();
 		const trees: [string | number | undefined, number, JsonableTree][] = [];
 		const cursor = this.forest.allocateCursor("getRemovedRoots");
 		for (const { id, root } of this.removedRoots.entries()) {
@@ -739,6 +728,28 @@ export class TreeCheckout implements ITreeCheckoutFork {
 
 		return { age: revertAge };
 	}
+
+	private assertNoUntrackedRoots(): void {
+		const cursor = this.forest.getCursorAboveDetachedFields();
+		const rootFields = new Set([rootFieldKey]);
+		for (const { root } of this.removedRoots.entries()) {
+			rootFields.add(this.removedRoots.toFieldKey(root));
+		}
+
+		if (!cursor.firstField()) {
+			return;
+		}
+
+		do {
+			const field = cursor.getFieldKey();
+			assert(
+				rootFields.has(field),
+				0xa22 /* Forest has a root field which is unknown to the detached field index */,
+			);
+
+			rootFields.delete(field);
+		} while (cursor.nextField());
+	}
 }
 
 /**

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

@@ -387,7 +387,7 @@ export class SharedTreeBranch<
 			const commit =
 				commits[i] ?? fail("This wont run because we are iterating through commits");
 			const inverse = this.changeFamily.rebaser.changeRevision(
-				this.changeFamily.rebaser.invert(commit, false),
+				this.changeFamily.rebaser.invert(commit, true),
 				revision,
 				commit.revision,
 			);