@fluidframework/tree 2.1.0-276985 → 2.1.0

package/src/core/tree/detachedFieldIndex.ts

@@ -7,43 +7,66 @@ import { assert } from "@fluidframework/core-utils/internal";
 
 import { type ICodecOptions, type IJsonCodec, noopValidator } from "../../codec/index.js";
 import {
-	type Brand,
 	type IdAllocator,
 	type JsonCompatibleReadOnly,
 	type NestedMap,
 	brand,
 	deleteFromNestedMap,
+	forEachInNestedMap,
 	idAllocatorFromMaxId,
 	populateNestedMap,
 	setInNestedMap,
 	tryGetFromNestedMap,
 } 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 * as Delta from "./delta.js";
 import { makeDetachedNodeToFieldCodec } from "./detachedFieldIndexCodec.js";
 import type { Format } from "./detachedFieldIndexFormat.js";
-import type { DetachedFieldSummaryData, Major, Minor } from "./detachedFieldIndexTypes.js";
+import type {
+	DetachedField,
+	DetachedFieldSummaryData,
+	ForestRootId,
+	Major,
+	Minor,
+} from "./detachedFieldIndexTypes.js";
 import type { IIdCompressor } from "@fluidframework/id-compressor";
 
-/**
- * ID used to create a detached field key for a removed subtree.
- *
- * TODO: Move to Forest once forests can support multiple roots.
- * @internal
- */
-export type ForestRootId = Brand<number, "tree.ForestRootId">;
-
 /**
  * The tree index records detached field IDs and associates them with a change atom ID.
  */
 export class DetachedFieldIndex {
-	// TODO: don't store the field key in the index, it can be derived from the root ID
-	private detachedNodeToField: NestedMap<Major, Minor, ForestRootId> = new Map();
+	/**
+	 * A mapping from detached node ids to detached fields.
+	 */
+	private detachedNodeToField: NestedMap<Major, Minor, DetachedField> = new Map();
+	/**
+	 * A map from revisions to all detached fields for which the revision is the latest relevant revision.
+	 * See {@link DetachedField.latestRelevantRevision}.
+	 *
+	 * @remarks
+	 * undefined revisions are tolerated but any roots not associated with a revision must be disposed manually
+	 */
+	private latestRelevantRevisionToFields: NestedMap<
+		RevisionTag | undefined,
+		ForestRootId,
+		Delta.DetachedNodeId
+	> = new Map();
+
 	private readonly codec: IJsonCodec<DetachedFieldSummaryData, Format>;
 	private readonly options: ICodecOptions;
 
+	/**
+	 * The process for loading `DetachedFieldIndex` data from a summary is split into two steps:
+	 * 1. Call {@link loadData}
+	 * 2. Call {@link setRevisionsForLoadedData}
+	 *
+	 * This flag is only set to `false` after calling `loadData` and is set back to `true` after calling `setRevisionsForLoadedData`.
+	 * This helps ensure that `setRevisionsForLoadedData` is only called after `loadData` and only called once.
+	 */
+	private isFullyLoaded = true;
+
 	/**
 	 * @param name - A name for the index, used as a prefix for the generated field keys.
 	 * @param rootIdAllocator - An ID allocator used to generate unique field keys.
@@ -68,18 +91,31 @@ export class DetachedFieldIndex {
 			this.options,
 		);
 		populateNestedMap(this.detachedNodeToField, clone.detachedNodeToField, true);
+		populateNestedMap(
+			this.latestRelevantRevisionToFields,
+			clone.latestRelevantRevisionToFields,
+			true,
+		);
 		return clone;
 	}
 
-	public *entries(): Generator<{ root: ForestRootId } & { id: Delta.DetachedNodeId }> {
+	public *entries(): Generator<
+		{ root: ForestRootId; latestRelevantRevision?: RevisionTag } & {
+			id: Delta.DetachedNodeId;
+		}
+	> {
 		for (const [major, innerMap] of this.detachedNodeToField) {
 			if (major !== undefined) {
-				for (const [minor, entry] of innerMap) {
-					yield { id: { major, minor }, root: entry };
+				for (const [minor, { root, latestRelevantRevision }] of innerMap) {
+					yield latestRelevantRevision !== undefined
+						? { id: { major, minor }, root, latestRelevantRevision }
+						: { id: { major, minor }, root };
 				}
 			} else {
-				for (const [minor, entry] of innerMap) {
-					yield { id: { minor }, root: entry };
+				for (const [minor, { root, latestRelevantRevision }] of innerMap) {
+					yield latestRelevantRevision !== undefined
+						? { id: { minor }, root, latestRelevantRevision }
+						: { id: { minor }, root };
 				}
 			}
 		}
@@ -90,22 +126,61 @@ export class DetachedFieldIndex {
 	 */
 	public purge(): void {
 		this.detachedNodeToField.clear();
+		this.latestRelevantRevisionToFields.clear();
 	}
 
 	public updateMajor(current: Major, updated: Major): void {
-		const innerCurrent = this.detachedNodeToField.get(current);
-		if (innerCurrent !== undefined) {
-			this.detachedNodeToField.delete(current);
-			const innerUpdated = this.detachedNodeToField.get(updated);
-			if (innerUpdated === undefined) {
-				this.detachedNodeToField.set(updated, innerCurrent);
-			} else {
+		// Update latestRelevantRevision information corresponding to `current`
+		{
+			const inner = this.latestRelevantRevisionToFields.get(current);
+			if (inner !== undefined) {
+				for (const nodeId of inner.values()) {
+					const entry = tryGetFromNestedMap(
+						this.detachedNodeToField,
+						nodeId.major,
+						nodeId.minor,
+					);
+					assert(
+						entry !== undefined,
+						0x9b8 /* Inconsistent data: missing detached node entry */,
+					);
+					setInNestedMap(this.detachedNodeToField, nodeId.major, nodeId.minor, {
+						...entry,
+						latestRelevantRevision: updated,
+					});
+				}
+				this.latestRelevantRevisionToFields.delete(current);
+				this.latestRelevantRevisionToFields.set(updated, inner);
+			}
+		}
+
+		// Update the major keys corresponding to `current`
+		{
+			const innerCurrent = this.detachedNodeToField.get(current);
+			if (innerCurrent !== undefined) {
+				this.detachedNodeToField.delete(current);
+				const innerUpdated = this.detachedNodeToField.get(updated);
+				if (innerUpdated === undefined) {
+					this.detachedNodeToField.set(updated, innerCurrent);
+				} else {
+					for (const [minor, entry] of innerCurrent) {
+						assert(
+							innerUpdated.get(minor) === undefined,
+							0x7a9 /* Collision during index update */,
+						);
+						innerUpdated.set(minor, entry);
+					}
+				}
+
 				for (const [minor, entry] of innerCurrent) {
+					const entryInLatest = this.latestRelevantRevisionToFields.get(
+						entry.latestRelevantRevision,
+					);
 					assert(
-						innerUpdated.get(minor) === undefined,
-						0x7a9 /* Collision during index update */,
+						entryInLatest !== undefined,
+						0x9b9 /* Inconsistent data: missing node entry in latestRelevantRevision */,
 					);
-					innerUpdated.set(minor, entry);
+					entryInLatest.set(entry.root, { major: updated, minor });
 				}
 			}
 		}
@@ -124,7 +199,7 @@ export class DetachedFieldIndex {
 	 * Returns undefined if no such id is known to the index.
 	 */
 	public tryGetEntry(id: Delta.DetachedNodeId): ForestRootId | undefined {
-		return tryGetFromNestedMap(this.detachedNodeToField, id.major, id.minor);
+		return tryGetFromNestedMap(this.detachedNodeToField, id.major, id.minor)?.root;
 	}
 
 	/**
@@ -137,15 +212,60 @@ export class DetachedFieldIndex {
 		return key;
 	}
 
+	/**
+	 * Returns the detached root IDs for all the trees that were detached or last modified by the given revision.
+	 */
+	public *getRootsLastTouchedByRevision(revision: RevisionTag): Iterable<ForestRootId> {
+		const roots = this.latestRelevantRevisionToFields.get(revision);
+		if (roots !== undefined) {
+			yield* roots.keys();
+		}
+	}
+
+	/**
+	 * Removes the detached roots for all the trees that were detached or last modified by the given revision.
+	 */
+	public deleteRootsLastTouchedByRevision(revision: RevisionTag): void {
+		const entries = this.latestRelevantRevisionToFields.get(revision);
+		if (entries === undefined) {
+			return;
+		}
+
+		this.latestRelevantRevisionToFields.delete(revision);
+		for (const detachedNodeId of entries.values()) {
+			const found = deleteFromNestedMap(
+				this.detachedNodeToField,
+				detachedNodeId.major,
+				detachedNodeId.minor,
+			);
+			assert(found, 0x9ba /* Unable to delete unknown entry */);
+		}
+	}
+
 	public deleteEntry(nodeId: Delta.DetachedNodeId): void {
-		const found = deleteFromNestedMap(this.detachedNodeToField, nodeId.major, nodeId.minor);
-		assert(found, 0x7ab /* Unable to delete unknown entry */);
+		const entry = tryGetFromNestedMap(this.detachedNodeToField, nodeId.major, nodeId.minor);
+		assert(entry !== undefined, 0x9bb /* Unable to delete unknown entry */);
+		deleteFromNestedMap(this.detachedNodeToField, nodeId.major, nodeId.minor);
+		deleteFromNestedMap(
+			this.latestRelevantRevisionToFields,
+			entry.latestRelevantRevision,
+			entry.root,
+		);
 	}
 
 	/**
 	 * Associates the DetachedNodeId with a field key and creates an entry for it in the index.
+	 * @param nodeId - The ID of the detached node.
+	 * @param revision - The revision that last detached the root.
+	 * See {@link DetachedField.latestRelevantRevision} for details.
+	 * @param count - The number of entries to create. These entries will have consecutive minor IDs.
+	 * @returns The atomic ID that the `DetachedFieldIndex` uses to uniquely identify the first root.
 	 */
-	public createEntry(nodeId?: Delta.DetachedNodeId, count: number = 1): ForestRootId {
+	public createEntry(
+		nodeId?: Delta.DetachedNodeId,
+		revision?: RevisionTag,
+		count: number = 1,
+	): ForestRootId {
 		const root = this.rootIdAllocator.allocate(count);
 		if (nodeId !== undefined) {
 			for (let i = 0; i < count; i++) {
@@ -154,17 +274,46 @@ export class DetachedFieldIndex {
 						undefined,
 					0x7ce /* Detached node ID already exists in index */,
 				);
-				setInNestedMap(this.detachedNodeToField, nodeId.major, nodeId.minor + i, root + i);
+				setInNestedMap(this.detachedNodeToField, nodeId.major, nodeId.minor + i, {
+					root: brand<ForestRootId>(root + i),
+					latestRelevantRevision: revision,
+				});
+				setInNestedMap(this.latestRelevantRevisionToFields, revision, root, nodeId);
 			}
 		}
 		return root;
 	}
 
+	/**
+	 * Updates the latest revision that is relevant to the provided root
+	 */
+	public updateLatestRevision(
+		id: Delta.DetachedNodeId,
+		revision: RevisionTag | undefined,
+	): void {
+		const fieldEntry = tryGetFromNestedMap(this.detachedNodeToField, id.major, id.minor);
+		assert(
+			fieldEntry !== undefined,
+			0x9bc /* detached node id does not exist in the detached field index */,
+		);
+		const { root, latestRelevantRevision: previousRevision } = fieldEntry;
+
+		// remove this root from the set of roots for the previous latest revision
+		deleteFromNestedMap(this.latestRelevantRevisionToFields, previousRevision, root);
+
+		// add this root to the set of roots for the new latest revision
+		setInNestedMap(this.latestRelevantRevisionToFields, revision, root, id);
+		setInNestedMap(this.detachedNodeToField, id.major, id.minor, {
+			root,
+			latestRelevantRevision: revision,
+		});
+	}
+
 	public encode(): JsonCompatibleReadOnly {
 		return this.codec.encode({
 			data: this.detachedNodeToField,
 			maxId: this.rootIdAllocator.getMaxId(),
-		}) as JsonCompatibleReadOnly;
+		});
 	}
 
 	/**
@@ -176,6 +325,39 @@ export class DetachedFieldIndex {
 		this.rootIdAllocator = idAllocatorFromMaxId(
 			detachedFieldIndex.maxId,
 		) as IdAllocator<ForestRootId>;
-		this.detachedNodeToField = detachedFieldIndex.data;
+
+		this.detachedNodeToField = new Map();
+		this.latestRelevantRevisionToFields = new Map();
+		this.isFullyLoaded = false;
+		const rootMap = new Map<ForestRootId, Delta.DetachedNodeId>();
+		forEachInNestedMap(detachedFieldIndex.data, ({ root }, major, minor) => {
+			rootMap.set(root, { major, minor });
+		});
+
+		this.latestRelevantRevisionToFields.set(undefined, rootMap);
+	}
+
+	/**
+	 * Sets the latest relevant revision for any roots that have an undefined latest relevant revision.
+	 * This occurs when the detached field index is loaded from a summary and can only be called once after
+	 * the summary has been loaded.
+	 */
+	public setRevisionsForLoadedData(latestRevision: RevisionTag): void {
+		assert(
+			!this.isFullyLoaded,
+			0x9bd /* revisions should only be set once using this function after loading data from a summary */,
+		);
+
+		const newDetachedNodeToField = new Map();
+		const rootMap = new Map();
+		forEachInNestedMap(this.detachedNodeToField, ({ root }, major, minor) => {
+			setInNestedMap(newDetachedNodeToField, major, minor, { root, latestRevision });
+			rootMap.set(root, { major, minor });
+		});
+
+		this.detachedNodeToField = newDetachedNodeToField;
+		this.latestRelevantRevisionToFields.delete(undefined);
+		this.latestRelevantRevisionToFields.set(latestRevision, rootMap);
+		this.isFullyLoaded = true;
 	}
 }

package/src/core/tree/detachedFieldIndexCodec.ts

@@ -12,14 +12,17 @@ import {
 } from "../../codec/index.js";
 import type { EncodedRevisionTag, RevisionTagCodec, RevisionTag } from "../rebase/index.js";
 
-import type { ForestRootId } from "./detachedFieldIndex.js";
 import {
 	type EncodedRootsForRevision,
 	Format,
 	type RootRanges,
 	version,
 } from "./detachedFieldIndexFormat.js";
-import type { DetachedFieldSummaryData, Major } from "./detachedFieldIndexTypes.js";
+import type {
+	DetachedField,
+	DetachedFieldSummaryData,
+	Major,
+} from "./detachedFieldIndexTypes.js";
 import type { IIdCompressor } from "@fluidframework/id-compressor";
 
 class MajorCodec implements IJsonCodec<Major> {
@@ -76,7 +79,10 @@ export function makeDetachedNodeToFieldCodec(
 			const rootsForRevisions: EncodedRootsForRevision[] = [];
 			for (const [major, innerMap] of data.data) {
 				const encodedRevision = majorCodec.encode(major);
-				const rootRanges: RootRanges = [...innerMap];
+				const rootRanges: RootRanges = [];
+				for (const [minor, detachedField] of innerMap) {
+					rootRanges.push([minor, detachedField.root]);
+				}
 				if (rootRanges.length === 1) {
 					const rootsForRevision: EncodedRootsForRevision = [
 						encodedRevision,
@@ -99,11 +105,14 @@ export function makeDetachedNodeToFieldCodec(
 		decode: (parsed: Format): DetachedFieldSummaryData => {
 			const map = new Map();
 			for (const rootsForRevision of parsed.data) {
-				const innerMap = new Map<number, ForestRootId>(
-					rootsForRevision.length === 2
-						? rootsForRevision[1]
-						: [[rootsForRevision[1], rootsForRevision[2]]],
-				);
+				const innerMap = new Map<number, DetachedField>();
+				if (rootsForRevision.length === 2) {
+					for (const [minor, root] of rootsForRevision[1]) {
+						innerMap.set(minor, { root });
+					}
+				} else {
+					innerMap.set(rootsForRevision[1], { root: rootsForRevision[2] });
+				}
 				map.set(majorCodec.decode(rootsForRevision[0]), innerMap);
 			}
 			return {

package/src/core/tree/detachedFieldIndexFormat.ts

@@ -8,7 +8,7 @@ import { type Static, Type } from "@sinclair/typebox";
 import { brandedNumberType } from "../../util/index.js";
 import { RevisionTagSchema } from "../rebase/index.js";
 
-import type { ForestRootId } from "./detachedFieldIndex.js";
+import type { ForestRootId } from "./detachedFieldIndexTypes.js";
 
 export const version = 1.0;
 

package/src/core/tree/detachedFieldIndexTypes.ts

@@ -3,15 +3,51 @@
  * Licensed under the MIT License.
  */
 
-import type { NestedMap } from "../../util/index.js";
+import type { Brand, ReadonlyNestedMap } from "../../util/index.js";
 import type { RevisionTag } from "../rebase/index.js";
 
-import type { ForestRootId } from "./detachedFieldIndex.js";
-
 export type Major = RevisionTag | undefined;
 export type Minor = number;
 
 export interface DetachedFieldSummaryData {
-	data: NestedMap<Major, Minor, ForestRootId>;
-	maxId: ForestRootId;
+	readonly data: ReadonlyNestedMap<Major, Minor, DetachedField>;
+	readonly maxId: ForestRootId;
+}
+
+/**
+ * ID used to create a detached field key for a removed subtree.
+ *
+ * TODO: Move to Forest once forests can support multiple roots.
+ * @internal
+ */
+export type ForestRootId = Brand<number, "tree.ForestRootId">;
+
+/**
+ * A field that is detached from the main document tree.
+ */
+export interface DetachedField {
+	/**
+	 * The atomic ID that the `DetachedFieldIndex` uses to uniquely identify the first (and only) root in the field.
+	 * This ID is scoped to the specific `DetachedFieldIndex` from witch this object was retrieved.
+	 *
+	 * The current implementation only supports a single root per field.
+	 * This will be changed in the future for performance reasons.
+	 */
+	readonly root: ForestRootId;
+	/**
+	 * The revision that last detached the root node or modified its contents (including its descendant's contents).
+	 *
+	 * Once this revision is trimmed from the ancestry on which a `TreeCheckout` is moored,
+	 * the contents of the associated subtree (and the very fact of its past existence) can be erased.
+	 *
+	 * @remarks
+	 * undefined revisions are tolerated but any roots not associated with a revision must be disposed manually.
+	 * Current usages of undefined are:
+	 * - When loading a {@link DetachedFieldIndex} from a snapshot,
+	 * until {@link DetachedFieldIndex.setRevisionsForLoadedData} is called.
+	 * - When applying a rollback changeset.
+	 * This only occurs within the context of {@link DefaultResubmitMachine} whose repair data is GC-ed when its
+	 * `DetachedField` and `Forest` are GC-ed.
+	 */
+	readonly latestRelevantRevision?: RevisionTag;
 }

package/src/core/tree/index.ts

@@ -110,4 +110,5 @@ export {
 	emptyDelta,
 } from "./deltaUtil.js";
 
-export { DetachedFieldIndex, type ForestRootId } from "./detachedFieldIndex.js";
+export { DetachedFieldIndex } from "./detachedFieldIndex.js";
+export { type ForestRootId } from "./detachedFieldIndexTypes.js";

package/src/core/tree/visitDelta.ts

@@ -9,6 +9,7 @@ import { type NestedMap, setInNestedMap, tryGetFromNestedMap } from "../../util/
 import type { FieldKey } from "../schema-stored/index.js";
 
 import type { ITreeCursorSynchronous } from "./cursor.js";
+// eslint-disable-next-line import/no-duplicates
 import type * as Delta from "./delta.js";
 // Since ProtoNodes is reexported, import it directly to avoid forcing Delta to be reexported.
 // eslint-disable-next-line import/no-duplicates
@@ -20,9 +21,10 @@ import {
 	isReplaceMark,
 	offsetDetachId,
 } from "./deltaUtil.js";
-import type { DetachedFieldIndex, ForestRootId } from "./detachedFieldIndex.js";
-import type { Major, Minor } from "./detachedFieldIndexTypes.js";
+import type { DetachedFieldIndex } from "./detachedFieldIndex.js";
+import type { ForestRootId, Major, Minor } from "./detachedFieldIndexTypes.js";
 import type { NodeIndex, PlaceIndex, Range } from "./pathTree.js";
+import type { RevisionTag } from "../index.js";
 
 /**
  * Implementation notes:
@@ -73,11 +75,13 @@ import type { NodeIndex, PlaceIndex, Range } from "./pathTree.js";
  * @param delta - The delta to be crawled.
  * @param visitor - The object to notify of the changes encountered.
  * @param detachedFieldIndex - Index responsible for keeping track of the existing detached fields.
+ * @param latestRevision - The latest revision tag associated with this delta.
  */
 export function visitDelta(
 	delta: Delta.Root,
 	visitor: DeltaVisitor,
 	detachedFieldIndex: DetachedFieldIndex,
+	latestRevision: RevisionTag | undefined,
 ): void {
 	const detachPassRoots: Map<ForestRootId, Delta.FieldMap> = new Map();
 	const attachPassRoots: Map<ForestRootId, Delta.FieldMap> = new Map();
@@ -92,6 +96,7 @@ export function visitDelta(
 	});
 	const detachConfig: PassConfig = {
 		func: detachPass,
+		latestRevision,
 		refreshers,
 		detachedFieldIndex,
 		detachPassRoots,
@@ -102,9 +107,17 @@ export function visitDelta(
 	processBuilds(delta.build, detachConfig, visitor);
 	visitFieldMarks(delta.fields, visitor, detachConfig);
 	fixedPointVisitOfRoots(visitor, detachPassRoots, detachConfig);
-	transferRoots(rootTransfers, attachPassRoots, detachedFieldIndex, visitor);
+	transferRoots(
+		rootTransfers,
+		attachPassRoots,
+		detachedFieldIndex,
+		visitor,
+		refreshers,
+		latestRevision,
+	);
 	const attachConfig: PassConfig = {
 		func: attachPass,
+		latestRevision,
 		refreshers,
 		detachedFieldIndex,
 		detachPassRoots,
@@ -153,6 +166,10 @@ function fixedPointVisitOfRoots(
 
 /**
  * Transfers roots from one detached field to another.
+ * This occurs in the following circumstances:
+ * - A changeset moves then removes a node
+ * - A changeset restores then moves a node
+ * - A changeset restores then removes a node
  * TODO#5481: update the DetachedFieldIndex instead of moving the nodes around.
  *
  * @param rootTransfers - The transfers to perform.
@@ -165,6 +182,8 @@ function transferRoots(
 	mapToUpdate: Map<ForestRootId, unknown>,
 	detachedFieldIndex: DetachedFieldIndex,
 	visitor: DeltaVisitor,
+	refreshers: NestedMap<Major, Minor, ITreeCursorSynchronous>,
+	revision?: RevisionTag,
 ): void {
 	type AtomizedNodeRename = Omit<Delta.DetachedNodeRename, "count">;
 	let nextBatch = rootTransfers.flatMap(({ oldId, newId, count }) => {
@@ -185,7 +204,14 @@ function transferRoots(
 		const delayed: AtomizedNodeRename[] = [];
 		const priorSize = nextBatch.length;
 		for (const { oldId, newId } of nextBatch) {
-			const oldRootId = detachedFieldIndex.tryGetEntry(oldId);
+			let oldRootId = detachedFieldIndex.tryGetEntry(oldId);
+			if (oldRootId === undefined) {
+				const tree = tryGetFromNestedMap(refreshers, oldId.major, oldId.minor);
+				if (tree !== undefined) {
+					buildTrees(oldId, [tree], detachedFieldIndex, revision, visitor);
+					oldRootId = detachedFieldIndex.getEntry(oldId);
+				}
+			}
 			if (oldRootId === undefined) {
 				// The source field is not populated.
 				// This can happen when another rename needs to be performed first.
@@ -199,7 +225,7 @@ function transferRoots(
 				delayed.push({ oldId, newId });
 				continue;
 			}
-			newRootId = detachedFieldIndex.createEntry(newId);
+			newRootId = detachedFieldIndex.createEntry(newId, revision);
 			const fields = mapToUpdate.get(oldRootId);
 			if (fields !== undefined) {
 				mapToUpdate.delete(oldRootId);
@@ -310,6 +336,13 @@ export interface DeltaVisitor {
 
 interface PassConfig {
 	readonly func: Pass;
+
+	/**
+	 * The latest revision tag associated with the given delta. This is used to keep track
+	 * of when repair data should be garbage collected.
+	 */
+	readonly latestRevision: RevisionTag | undefined;
+
 	readonly detachedFieldIndex: DetachedFieldIndex;
 	/**
 	 * A mapping between forest root id and trees that represent refresher data. Each entry is only
@@ -393,9 +426,11 @@ function detachPass(
 			if (root === undefined) {
 				const tree = tryGetFromNestedMap(config.refreshers, id.major, id.minor);
 				assert(tree !== undefined, 0x928 /* refresher data not found */);
-				buildTrees(id, [tree], config, visitor);
+				buildTrees(id, [tree], config.detachedFieldIndex, config.latestRevision, visitor);
 				root = config.detachedFieldIndex.getEntry(id);
 			}
+			// the revision is updated for any refresher data included in the delta that is used
+			config.detachedFieldIndex.updateLatestRevision(id, config.latestRevision);
 			config.detachPassRoots.set(root, fields);
 			config.attachPassRoots.set(root, fields);
 		}
@@ -415,10 +450,9 @@ function detachPass(
 			}
 			if (isDetachMark(mark)) {
 				for (let i = 0; i < mark.count; i += 1) {
-					const root = config.detachedFieldIndex.createEntry(
-						// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-						offsetDetachId(mark.detach!, i),
-					);
+					// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+					const id = offsetDetachId(mark.detach!, i);
+					const root = config.detachedFieldIndex.createEntry(id, config.latestRevision);
 					if (mark.fields !== undefined) {
 						config.attachPassRoots.set(root, mark.fields);
 					}
@@ -435,15 +469,16 @@ function detachPass(
 function buildTrees(
 	id: Delta.DetachedNodeId,
 	trees: readonly ITreeCursorSynchronous[],
-	config: PassConfig,
+	detachedFieldIndex: DetachedFieldIndex,
+	latestRevision: RevisionTag | undefined,
 	visitor: DeltaVisitor,
 ): void {
 	for (let i = 0; i < trees.length; i += 1) {
 		const offsettedId = offsetDetachId(id, i);
-		let root = config.detachedFieldIndex.tryGetEntry(offsettedId);
+		let root = detachedFieldIndex.tryGetEntry(offsettedId);
 		assert(root === undefined, 0x929 /* Unable to build tree that already exists */);
-		root = config.detachedFieldIndex.createEntry(offsettedId);
-		const field = config.detachedFieldIndex.toFieldKey(root);
+		root = detachedFieldIndex.createEntry(offsettedId, latestRevision);
+		const field = detachedFieldIndex.toFieldKey(root);
 		visitor.create([trees[i]], field);
 	}
 }
@@ -455,7 +490,7 @@ function processBuilds(
 ): void {
 	if (builds !== undefined) {
 		for (const { id, trees } of builds) {
-			buildTrees(id, trees, config, visitor);
+			buildTrees(id, trees, config.detachedFieldIndex, config.latestRevision, visitor);
 		}
 	}
 }
@@ -495,7 +530,13 @@ function attachPass(
 							offsetAttachId.minor,
 						);
 						assert(tree !== undefined, 0x92a /* refresher data not found */);
-						buildTrees(offsetAttachId, [tree], config, visitor);
+						buildTrees(
+							offsetAttachId,
+							[tree],
+							config.detachedFieldIndex,
+							config.latestRevision,
+							visitor,
+						);
 						sourceRoot = config.detachedFieldIndex.getEntry(offsetAttachId);
 					}
 					const sourceField = config.detachedFieldIndex.toFieldKey(sourceRoot);
@@ -504,6 +545,7 @@ function attachPass(
 						const rootDestination = config.detachedFieldIndex.createEntry(
 							// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 							offsetDetachId(mark.detach!, i),
+							config.latestRevision,
 						);
 						const destinationField = config.detachedFieldIndex.toFieldKey(rootDestination);
 						visitor.replace(