@fluidframework/tree 2.1.0-281041 → 2.2.0

package/src/core/tree/anchorSet.ts

@@ -3,6 +3,8 @@
  * Licensed under the MIT License.
  */
 
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+
 import { assert } from "@fluidframework/core-utils/internal";
 
 import { type Listenable, createEmitter } from "../../events/index.js";
@@ -36,7 +38,6 @@ import type { AnnouncedVisitor } from "./visitorUtils.js";
 /**
  * A way to refer to a particular tree location within an {@link AnchorSet}.
  * Associated with a ref count on the underlying {@link AnchorNode}.
- * @internal
  */
 export type Anchor = Brand<number, "rebaser.Anchor">;
 
@@ -47,7 +48,6 @@ const NeverAnchor: Anchor = brand(0);
 
 /**
  * Maps anchors (which must be ones this locator knows about) to paths.
- * @internal
  */
 export interface AnchorLocator {
 	/**
@@ -65,7 +65,6 @@ export interface AnchorLocator {
  * Stores arbitrary, user-defined data on an {@link Anchor}.
  * This data is preserved over the course of that anchor's lifetime.
  * @see {@link anchorSlot} for creation and an example use case.
- * @internal
  */
 export type AnchorSlot<TContent> = BrandedKey<Opaque<Brand<number, "AnchorSlot">>, TContent>;
 
@@ -77,8 +76,6 @@ export type AnchorSlot<TContent> = BrandedKey<Opaque<Brand<number, "AnchorSlot">
  * TODO:
  * - Include sub-deltas in events.
  * - Add more events.
- *
- * @internal
  */
 export interface AnchorEvents {
 	/**
@@ -196,8 +193,6 @@ export interface AnchorEvents {
  * - Design how events should be ordered.
  * - Include sub-deltas in events.
  * - Add more events.
- *
- * @internal
  */
 export interface AnchorSetRootEvents {
 	/**
@@ -213,7 +208,6 @@ export interface AnchorSetRootEvents {
 
 /**
  * Node in a tree of anchors.
- * @internal
  */
 export interface AnchorNode extends UpPath<AnchorNode>, Listenable<AnchorEvents> {
 	/**
@@ -263,7 +257,6 @@ export interface AnchorNode extends UpPath<AnchorNode>, Listenable<AnchorEvents>
  * 	anchor.slots.set(counterSlot, 1 + anchor.slots.get(counterSlot) ?? 0);
  * }
  * ```
- * @internal
  */
 export function anchorSlot<TContent>(): AnchorSlot<TContent> {
 	return brandedSlot<AnchorSlot<TContent>>();
@@ -279,7 +272,6 @@ export function anchorSlot<TContent>(): AnchorSlot<TContent> {
  * API surface to a small subset.
  *
  * @sealed
- * @internal
  */
 export class AnchorSet implements Listenable<AnchorSetRootEvents>, AnchorLocator {
 	private readonly events = createEmitter<AnchorSetRootEvents>();
@@ -334,6 +326,20 @@ export class AnchorSet implements Listenable<AnchorSetRootEvents>, AnchorLocator
 		return this.root.slots;
 	}
 
+	public *[Symbol.iterator](): IterableIterator<AnchorNode> {
+		const stack: PathNode[] = [];
+		let node: PathNode | undefined = this.root;
+		while (node !== undefined) {
+			yield node;
+			for (const [_, children] of node.children) {
+				for (const child of children) {
+					stack.push(child);
+				}
+			}
+			node = stack.pop();
+		}
+	}
+
 	public on<K extends keyof AnchorSetRootEvents>(
 		eventName: K,
 		listener: AnchorSetRootEvents[K],
@@ -482,7 +488,6 @@ export class AnchorSet implements Listenable<AnchorSetRootEvents>, AnchorLocator
 	private deepDelete(nodes: readonly PathNode[]): void {
 		const stack = [...nodes];
 		while (stack.length > 0) {
-			// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 			const node = stack.pop()!;
 			assert(node.status === Status.Alive, 0x408 /* PathNode must be alive */);
 			node.status = Status.Dangling;
@@ -516,27 +521,26 @@ export class AnchorSet implements Listenable<AnchorSetRootEvents>, AnchorLocator
 			let index = 0;
 			while (
 				index < sourceChildren.length &&
-				sourceChildren[index].parentIndex < startPath.parentIndex
+				sourceChildren[index]!.parentIndex < startPath.parentIndex
 			) {
 				numberBeforeDecouple++;
 				index++;
 			}
 			while (
 				index < sourceChildren.length &&
-				sourceChildren[index].parentIndex < startPath.parentIndex + count
+				sourceChildren[index]!.parentIndex < startPath.parentIndex + count
 			) {
 				numberToDecouple++;
 				index++;
 			}
 			while (index < sourceChildren.length) {
 				// Fix indexes in source after moved items (subtract count).
-				sourceChildren[index].parentIndex -= count;
+				sourceChildren[index]!.parentIndex -= count;
 				index++;
 			}
 			// Sever the parent -> child connections
 			nodes = sourceChildren.splice(numberBeforeDecouple, numberToDecouple);
 			if (sourceChildren.length === 0) {
-				// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 				sourceParent!.afterEmptyField(startPath.parentField);
 			}
 		}
@@ -605,12 +609,12 @@ export class AnchorSet implements Listenable<AnchorSetRootEvents>, AnchorLocator
 		count: number,
 	): number {
 		let index = 0;
-		while (index < field.length && field[index].parentIndex < fromParentIndex) {
+		while (index < field.length && field[index]!.parentIndex < fromParentIndex) {
 			index++;
 		}
 		const numberBeforeIncrease = index;
 		while (index < field.length) {
-			field[index].parentIndex += count;
+			field[index]!.parentIndex += count;
 			index++;
 		}
 

package/src/core/tree/cursor.ts

@@ -14,7 +14,6 @@ import type { TreeType, Value } from "./types.js";
  * A symbol for marking an object as an {@link ITreeCursor}.
  *
  * Useful when APIs want to take in tree data in multiple formats, including cursors.
- * @internal
  */
 export const CursorMarker: unique symbol = Symbol("CursorMarker");
 
@@ -35,8 +34,7 @@ export function isCursor(data: unknown): data is ITreeCursor {
 
 /**
  * A stateful low-level interface for reading tree data.
- * @internal
- *
+ * *
  * @remarks Cursor exists so that specialized data formats can be viewed through
  * a common abstraction. This allows performance optimizations to be done based
  * on data.
@@ -291,7 +289,6 @@ export interface ITreeCursor {
  * For example, if a node is being inserted in the 5th position in a field "Foo", you can update a path in that node's subtree to its new path by prefixing it with
  * `{ parent: theNodeAboveTheMovedNode, rootFieldOverride: Foo, indexOffset: 5 }`.
  * See {@link prefixPath} and {@link prefixFieldPath} for how to apply the prefix to the paths.
- * @internal
  */
 export interface PathRootPrefix {
 	/**
@@ -316,7 +313,6 @@ export interface PathRootPrefix {
 }
 
 /**
- * @internal
  */
 export const enum CursorLocationType {
 	/**
@@ -334,7 +330,6 @@ export const enum CursorLocationType {
 
 /**
  * {@link ITreeCursor} that is never pending.
- * @internal
  */
 export interface ITreeCursorSynchronous extends ITreeCursor {
 	readonly pending: false;

package/src/core/tree/delta.ts

@@ -69,7 +69,6 @@ import type { ITreeCursorSynchronous } from "./cursor.js";
 /**
  * Represents the change made to a document.
  * Immutable, therefore safe to retain for async processing.
- * @internal
  */
 export interface Root<TTree = ProtoNode> {
 	/**
@@ -108,7 +107,6 @@ export interface Root<TTree = ProtoNode> {
  * Ownership and lifetime of data referenced by this cursor is unclear,
  * so it is a poor abstraction for this use-case which needs to hold onto the data in a non-exclusive (readonly) way.
  * Cursors can be one supported way to input data, but aren't a good storage format.
- * @internal
  */
 export type ProtoNode = ITreeCursorSynchronous;
 
@@ -120,13 +118,11 @@ export type ProtoNode = ITreeCursorSynchronous;
  * Additionally, Cursors support sequences, so if using cursors, there are better ways to handle this than an array of cursors,
  * like using a cursor over all the content (starting in fields mode).
  * Long term something like TreeChunk should probably be used here.
- * @internal
  */
 export type ProtoNodes = readonly ProtoNode[];
 
 /**
  * Represents a change being made to a part of the document tree.
- * @internal
  */
 export interface Mark {
 	/**
@@ -156,7 +152,6 @@ export interface Mark {
 
 /**
  * A globally unique ID for a node in a detached field.
- * @internal
  */
 export interface DetachedNodeId {
 	readonly major?: RevisionTag;
@@ -164,13 +159,11 @@ export interface DetachedNodeId {
 }
 
 /**
- * @internal
  */
 export type FieldMap = ReadonlyMap<FieldKey, FieldChanges>;
 
 /**
  * Represents changes made to a detached node
- * @internal
  */
 export interface DetachedNodeChanges {
 	readonly id: DetachedNodeId;
@@ -182,7 +175,6 @@ export interface DetachedNodeChanges {
  *
  * Tree creation is idempotent: if a tree with the same ID already exists,
  * then this build is ignored in favor of the existing tree.
- * @internal
  */
 export interface DetachedNodeBuild<TTree = ProtoNode> {
 	readonly id: DetachedNodeId;
@@ -191,7 +183,6 @@ export interface DetachedNodeBuild<TTree = ProtoNode> {
 
 /**
  * Represents the destruction of detached nodes
- * @internal
  */
 export interface DetachedNodeDestruction {
 	readonly id: DetachedNodeId;
@@ -200,7 +191,6 @@ export interface DetachedNodeDestruction {
 
 /**
  * Represents a detached node being assigned a new `DetachedNodeId`.
- * @internal
  */
 export interface DetachedNodeRename {
 	readonly count: number;
@@ -210,7 +200,6 @@ export interface DetachedNodeRename {
 
 /**
  * Represents the changes to perform on a given field.
- * @internal
  */
 export interface FieldChanges {
 	/**

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

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { assert } from "@fluidframework/core-utils/internal";
+import { assert, oob } from "@fluidframework/core-utils/internal";
 
 import {
 	type ICodecOptions,
@@ -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,12 +79,16 @@ 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 firstRootRange = rootRanges[0] ?? oob();
 					const rootsForRevision: EncodedRootsForRevision = [
 						encodedRevision,
-						rootRanges[0][0],
-						rootRanges[0][1],
+						firstRootRange[0],
+						firstRootRange[1],
 					];
 					rootsForRevisions.push(rootsForRevision);
 				} else {
@@ -99,11 +106,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;