@fluidframework/tree 2.1.0 → 2.2.0

package/src/core/forest/forest.ts

@@ -33,7 +33,6 @@ import type { IEditableForest } from "./editableForest.js";
  * Events for {@link IForestSubscription}.
  *
  * TODO: consider having before and after events per subtree instead while applying anchor (and this just shows what happens at the root).
- * @internal
  */
 export interface ForestEvents {
 	/**
@@ -58,7 +57,6 @@ export interface ForestEvents {
  * Not invalidated when schema changes.
  *
  * When invalidating, all outstanding cursors must be freed or cleared.
- * @internal
  */
 export interface IForestSubscription extends Listenable<ForestEvents> {
 	/**
@@ -162,7 +160,6 @@ export function moveToDetachedField(
 /**
  * Anchor to a field.
  * This is structurally based on the parent, so it will move only as the parent moves.
- * @internal
  */
 export interface FieldAnchor {
 	/**
@@ -175,7 +172,6 @@ export interface FieldAnchor {
 
 /**
  * ITreeCursor supporting IForestSubscription and its changes over time.
- * @internal
  */
 export interface ITreeSubscriptionCursor extends ITreeCursor {
 	/**
@@ -226,7 +222,6 @@ export interface ITreeSubscriptionCursor extends ITreeCursor {
 }
 
 /**
- * @internal
  */
 export enum ITreeSubscriptionCursorState {
 	/**
@@ -244,7 +239,6 @@ export enum ITreeSubscriptionCursorState {
 }
 
 /**
- * @internal
  */
 export const enum TreeNavigationResult {
 	/**

package/src/core/index.ts

@@ -96,6 +96,8 @@ export {
 	type DeltaDetachedNodeDestruction,
 	type DeltaDetachedNodeRename,
 	type DeltaFieldChanges,
+	type ExclusiveMapTree,
+	deepCopyMapTree,
 } from "./tree/index.js";
 
 export {
@@ -190,8 +192,6 @@ export {
 	taggedOptAtomId,
 	offsetChangeAtomId,
 	replaceAtomRevisions,
-	getFromChangeAtomIdMap,
-	setInChangeAtomIdMap,
 	replaceChange,
 	type RebaseStats,
 	type RebaseStatsWithDuration,

package/src/core/rebase/changeRebaser.ts

@@ -92,7 +92,6 @@ export interface ChangeRebaser<TChangeset> {
 }
 
 /**
- * @internal
  */
 export interface TaggedChange<TChangeset, TTag = RevisionTag | undefined> {
 	readonly revision: TTag;
@@ -120,12 +119,10 @@ export function mapTaggedChange<TIn, TOut>(
  * being produced.
  *
  * During rebase, the indices of the base changes are all lower than the indices of the change being rebased.
- * @internal
  */
 export type RevisionIndexer = (tag: RevisionTag) => number | undefined;
 
 /**
- * @internal
  */
 export interface RevisionMetadataSource {
 	readonly getIndex: RevisionIndexer;
@@ -134,7 +131,6 @@ export interface RevisionMetadataSource {
 }
 
 /**
- * @internal
  */
 export interface RevisionInfo {
 	readonly revision: RevisionTag;

package/src/core/rebase/index.ts

@@ -23,8 +23,6 @@ export {
 	taggedOptAtomId,
 	offsetChangeAtomId,
 	replaceAtomRevisions,
-	getFromChangeAtomIdMap,
-	setInChangeAtomIdMap,
 	replaceChange,
 } from "./types.js";
 export { RevisionTagCodec } from "./revisionTagCodec.js";

package/src/core/rebase/types.ts

@@ -17,8 +17,6 @@ import {
 	brand,
 	brandedNumberType,
 	brandedStringType,
-	setInNestedMap,
-	tryGetFromNestedMap,
 } from "../../util/index.js";
 import type { TaggedChange } from "./changeRebaser.js";
 
@@ -33,7 +31,6 @@ export const SessionIdSchema = brandedStringType<SessionId>();
  *
  * The constant 'root' is reserved for the trunk base: minting a SessionSpaceCompressedId is not
  * possible on readonly clients. These clients generally don't need ids, but  must be done at tree initialization time.
- * @internal
  */
 export type RevisionTag = SessionSpaceCompressedId | "root";
 export type EncodedRevisionTag = Brand<OpSpaceCompressedId, "EncodedRevisionTag"> | "root";
@@ -46,14 +43,12 @@ export const RevisionTagSchema = Type.Union([
  * An ID which is unique within a revision of a `ModularChangeset`.
  * A `ModularChangeset` which is a composition of multiple revisions may contain duplicate `ChangesetLocalId`s,
  * but they are unique when qualified by the revision of the change they are used in.
- * @internal
  */
 export type ChangesetLocalId = Brand<number, "ChangesetLocalId">;
 
 /**
  * A globally unique ID for an atom of change, or a node associated with the atom of change.
- * @internal
- *
+ * *
  * @privateRemarks
  * TODO: Rename this to be more general.
  */
@@ -72,27 +67,10 @@ export interface ChangeAtomId {
 export type EncodedChangeAtomId = [ChangesetLocalId, EncodedRevisionTag] | ChangesetLocalId;
 
 /**
- * @internal
  */
 export type ChangeAtomIdMap<T> = NestedMap<RevisionTag | undefined, ChangesetLocalId, T>;
 
-export function getFromChangeAtomIdMap<T>(
-	map: ChangeAtomIdMap<T>,
-	id: ChangeAtomId,
-): T | undefined {
-	return tryGetFromNestedMap(map, id.revision, id.localId);
-}
-
-export function setInChangeAtomIdMap<T>(
-	map: ChangeAtomIdMap<T>,
-	id: ChangeAtomId,
-	value: T,
-): void {
-	setInNestedMap(map, id.revision, id.localId, value);
-}
-
 /**
- * @internal
  */
 export type ChangeAtomIdRangeMap<T> = Map<RevisionTag | undefined, RangeMap<T>>;
 

package/src/core/rebase/utils.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 { Mutable } from "../../util/index.js";
 
@@ -204,11 +204,13 @@ export function rebaseBranch<TChange>(
 	if (targetCommitIndex === -1) {
 		// If the targetCommit is not in the target path, then it is either disjoint from `target` or it is behind/at
 		// the commit where source and target diverge (ancestor), in which case there is nothing more to rebase
-		// TODO: Ideally, this would be an "assertExpensive"
-		assert(
-			findCommonAncestor(targetCommit, targetHead) !== undefined,
-			0x676 /* target commit is not in target branch */,
-		);
+		// TODO: Ideally, this would be an "assertExpensive". It is commented out because it causes O(N²) behavior when
+		// processing N inbound commits from the same client whose ref seq# is not advancing (which is a common case).
+		// N can be large when the client is sending a burst of changes (potentially on reconnection).
+		// assert(
+		// 	findCommonAncestor(targetCommit, targetHead) !== undefined,
+		// 	0x676 /* target commit is not in target branch */,
+		// );
 		return {
 			newSourceHead: sourceHead,
 			sourceChange: undefined,
@@ -228,8 +230,7 @@ export function rebaseBranch<TChange>(
 	const sourceSet = new Set(sourcePath.map((r) => r.revision));
 	let newBaseIndex = targetCommitIndex;
 
-	for (let i = 0; i < targetPath.length; i += 1) {
-		const { revision } = targetPath[i];
+	for (const [i, { revision }] of targetPath.entries()) {
 		if (sourceSet.has(revision)) {
 			sourceSet.delete(revision);
 			newBaseIndex = Math.max(newBaseIndex, i);
@@ -239,7 +240,7 @@ export function rebaseBranch<TChange>(
 	}
 
 	/** The commit on the target branch that the new source branch branches off of (i.e. the new common ancestor) */
-	const newBase = targetPath[newBaseIndex];
+	const newBase = targetPath[newBaseIndex] ?? oob();
 	// Figure out how much of the trunk to start rebasing over.
 	const targetCommits = targetPath.slice(0, newBaseIndex + 1);
 	const deletedSourceCommits = [...sourcePath];
@@ -249,7 +250,9 @@ export function rebaseBranch<TChange>(
 	const targetRebasePath = [...targetCommits];
 	const minLength = Math.min(sourcePath.length, targetRebasePath.length);
 	for (let i = 0; i < minLength; i++) {
-		if (sourcePath[0].revision === targetRebasePath[0].revision) {
+		const firstSourcePath = sourcePath[0] ?? oob();
+		const firstTargetRebasePath = targetRebasePath[0] ?? oob();
+		if (firstSourcePath.revision === firstTargetRebasePath.revision) {
 			sourcePath.shift();
 			targetRebasePath.shift();
 		}
@@ -371,7 +374,6 @@ export function rebaseChange<TChange>(
 }
 
 /**
- * @internal
  */
 export function revisionMetadataSourceFromInfo(
 	revInfos: readonly RevisionInfo[],

package/src/core/schema-stored/multiplicity.ts

@@ -7,7 +7,6 @@
  * Describes how a particular field functions.
  *
  * This determine its reading and editing APIs, multiplicity, and what merge resolution policies it will use.
- * @internal
  */
 export enum Multiplicity {
 	/**

package/src/core/schema-stored/schema.ts

@@ -65,8 +65,6 @@ export type TreeTypeSet = ReadonlySet<TreeNodeSchemaIdentifier> | undefined;
  *
  * @remarks
  * Enough info about a field kind to know if a given tree is is schema.
- *
- * @internal
  */
 export interface FieldKindData {
 	readonly identifier: FieldKindIdentifier;
@@ -83,7 +81,6 @@ export interface SchemaAndPolicy {
 
 /**
  * Extra data needed to interpret schema.
- * @internal
  */
 export interface SchemaPolicy {
 	/**
@@ -122,8 +119,6 @@ export interface TreeFieldStoredSchema {
  * This mainly show up in:
  * 1. The root default field for documents.
  * 2. The schema used for out of schema fields (which thus must be empty/not exist) on object and leaf nodes.
- *
- * @internal
  */
 export const forbiddenFieldKindIdentifier = "Forbidden";
 
@@ -140,8 +135,6 @@ export const storedEmptyFieldSchema: TreeFieldStoredSchema = {
 
 /**
  * Identifier used for the FieldKind for fields of type identifier.
- *
- * @internal
  */
 export const identifierFieldKindIdentifier = "Identifier";
 

package/src/core/schema-stored/storedSchemaRepository.ts

@@ -21,7 +21,6 @@ import {
  * Events for {@link TreeStoredSchemaSubscription}.
  *
  * TODO: consider having before and after events per subtree instead while applying anchor (and this just shows what happens at the root).
- * @internal
  */
 export interface SchemaEvents {
 	/**
@@ -37,7 +36,6 @@ export interface SchemaEvents {
 
 /**
  * A collection of stored schema that fires events in response to changes.
- * @internal
  */
 export interface TreeStoredSchemaSubscription
 	extends Listenable<SchemaEvents>,
@@ -45,7 +43,6 @@ export interface TreeStoredSchemaSubscription
 
 /**
  * Mutable collection of stored schema.
- * @internal
  */
 export interface MutableTreeStoredSchema extends TreeStoredSchemaSubscription {
 	/**

package/src/core/schema-view/view.ts

@@ -24,7 +24,6 @@ export enum Compatibility {
  * What kinds of updates to stored schema to permit.
  *
  * Bit flags enum.
- * @internal
  */
 export enum AllowedUpdateType {
 	/**
@@ -53,7 +52,6 @@ export enum AllowedUpdateType {
 }
 
 /**
- * @internal
  */
 export interface TreeAdapter {
 	readonly output: TreeNodeSchemaIdentifier;
@@ -68,7 +66,6 @@ export interface TreeAdapter {
  *
  * TODO: Support more kinds of adapters
  * TODO: support efficient lookup of adapters
- * @internal
  */
 export interface Adapters {
 	readonly tree?: readonly TreeAdapter[];

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>();
@@ -496,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;
@@ -530,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);
 			}
 		}
@@ -619,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/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,
@@ -84,10 +84,11 @@ export function makeDetachedNodeToFieldCodec(
 					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 {

package/src/core/tree/detachedFieldIndexTypes.ts

@@ -18,7 +18,6 @@ export interface DetachedFieldSummaryData {
  * 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">;
 

package/src/core/tree/index.ts

@@ -43,7 +43,7 @@ export type {
 	DetachedNodeRename as DeltaDetachedNodeRename,
 	FieldChanges as DeltaFieldChanges,
 } from "./delta.js";
-export type { MapTree } from "./mapTree.js";
+export { type MapTree, type ExclusiveMapTree, deepCopyMapTree } from "./mapTree.js";
 export {
 	clonePath,
 	topDownPath,

package/src/core/tree/mapTree.ts

@@ -8,14 +8,55 @@ import type { FieldKey } from "../schema-stored/index.js";
 import type { NodeData } from "./types.js";
 
 /**
- * This modules provides a simple in memory tree format.
+ * This module provides a simple in-memory tree format.
  */
 
 /**
- * Simple in memory tree representation based on Maps.
- * MapTrees should not store empty fields.
- * @internal
+ * Simple in-memory tree representation based on Maps.
+ * @remarks MapTrees should not store empty fields.
  */
 export interface MapTree extends NodeData {
 	readonly fields: ReadonlyMap<FieldKey, readonly MapTree[]>;
 }
+
+/**
+ * A {@link MapTree} which is owned by a single reference, and therefore allowed to be mutated.
+ *
+ * @remarks
+ * To ensure unexpected mutations, this object should have a single owner/context.
+ * Though this type does implement MapTree, it should not be used as a MapTree while it can possibly be mutated.
+ * If it is shared to other contexts, it should first be upcast to a {@link MapTree} and further mutations should be avoided.
+ */
+export interface ExclusiveMapTree extends NodeData, MapTree {
+	fields: Map<FieldKey, ExclusiveMapTree[]>;
+}
+
+/**
+ * Returns a deep copy of the given {@link MapTree}.
+ * @privateRemarks This is implemented iteratively (rather than recursively, which is much simpler)
+ * to avoid the possibility of a stack overflow for very deep trees.
+ */
+export function deepCopyMapTree(mapTree: MapTree): ExclusiveMapTree {
+	type Next = [fields: ExclusiveMapTree["fields"], sourceFields: MapTree["fields"]];
+	const rootFields: ExclusiveMapTree["fields"] = new Map();
+	const nexts: Next[] = [[rootFields, mapTree.fields]];
+	for (let next = nexts.pop(); next !== undefined; next = nexts.pop()) {
+		const [fields, sourceFields] = next;
+		for (const [key, field] of sourceFields) {
+			if (field.length > 0) {
+				const newField: ExclusiveMapTree[] = [];
+				for (const child of field) {
+					const childClone: ExclusiveMapTree = { ...child, fields: new Map() };
+					newField.push(childClone);
+					nexts.push([childClone.fields, child.fields]);
+				}
+				fields.set(key, newField);
+			}
+		}
+	}
+
+	return {
+		...mapTree,
+		fields: rootFields,
+	};
+}