@fluidframework/tree 2.0.0-rc.2.0.2 → 2.0.0-rc.3.0.0

package/src/core/tree/anchorSet.ts

@@ -3,32 +3,34 @@
  * Licensed under the MIT License.
  */
 
-import { assert } from "@fluidframework/core-utils";
-import { createEmitter, ISubscribable } from "../../events/index.js";
+import { assert } from "@fluidframework/core-utils/internal";
+
+import { ISubscribable, createEmitter } from "../../events/index.js";
 import {
-	brand,
 	Brand,
-	fail,
-	Opaque,
-	ReferenceCountedBase,
 	BrandedKey,
 	BrandedMapSubset,
+	Opaque,
+	ReferenceCountedBase,
+	brand,
 	brandedSlot,
+	fail,
 } from "../../util/index.js";
 import { FieldKey } from "../schema-stored/index.js";
+
+import * as Delta from "./delta.js";
 import {
 	DetachedPlaceUpPath,
 	DetachedRangeUpPath,
 	PlaceIndex,
-	UpPath,
-	Range,
 	PlaceUpPath,
+	Range,
 	RangeUpPath,
+	UpPath,
 } from "./pathTree.js";
-import { Value, EmptyKey } from "./types.js";
-import { PathVisitor } from "./visitPath.js";
+import { EmptyKey, Value } from "./types.js";
 import { DeltaVisitor } from "./visitDelta.js";
-import * as Delta from "./delta.js";
+import { PathVisitor } from "./visitPath.js";
 import { AnnouncedVisitor } from "./visitorUtils.js";
 
 /**
@@ -86,6 +88,11 @@ export interface AnchorEvents {
 	 * @remarks
 	 * When this happens depends entirely on how the anchorSet is used.
 	 * It's possible nodes removed from the tree will be kept indefinitely, and thus never trigger this event, or they may be discarded immediately.
+	 *
+	 * @privateRemarks
+	 * The specifics of the delta visit algorithm can impact the behavior of these events.
+	 * Refer to the privateRemarks of specific events and/or the documentation of the delta visit algorithm (as of
+	 * 2024-04-02, src/core/tree/visitDelta.ts) for more information.
 	 */
 	afterDestroy(anchor: AnchorNode): void;
 
@@ -105,22 +112,6 @@ export interface AnchorEvents {
 	 */
 	childrenChanged(anchor: AnchorNode): void;
 
-	/**
-	 * Before a change in this subtree happens.
-	 *
-	 * @remarks
-	 * Includes edits of child subtrees.
-	 */
-	beforeChange(anchor: AnchorNode): void;
-
-	/**
-	 * After a change in this subtree happened.
-	 *
-	 * @remarks
-	 * Includes edits of child subtrees.
-	 */
-	afterChange(anchor: AnchorNode): void;
-
 	/**
 	 * Something in this tree is changing.
 	 * The event can optionally return a {@link PathVisitor} to traverse the subtree.
@@ -129,6 +120,27 @@ export interface AnchorEvents {
 	 */
 	subtreeChanging(anchor: AnchorNode): PathVisitor | void;
 
+	/**
+	 * Emitted after the subtree rooted at `anchor` may have been changed.
+	 *
+	 * @remarks
+	 * While this event is always emitted in the presence of changes to the subtree,
+	 * it may also be emitted even though no changes have been made to the subtree.
+	 * It may be emitted multiple times within the application of a single edit or transaction.
+	 *
+	 * If this event is emitted by a node, it will later be emitted by all its ancestors up to the root as well, at
+	 * least once on each ancestor.
+	 *
+	 * @privateRemarks
+	 * The delta visit algorithm is complicated and it may fire this event multiple times for the same change to a node.
+	 * The change to the tree may not be visible until the event fires for the last time.
+	 * Refer to the documentation of the delta visit algorithm for more details.
+	 *
+	 * TODO: can we make it so this event is guaranteed to only fire once during the delta visit? Specifically when
+	 * changes to the tree did happen and are visible to the listener.
+	 */
+	subtreeChanged(anchor: AnchorNode): void;
+
 	/**
 	 * Value on this node is changing.
 	 */
@@ -170,6 +182,11 @@ export interface AnchorNode extends UpPath<AnchorNode>, ISubscribable<AnchorEven
 	 */
 	readonly slots: BrandedMapSubset<AnchorSlot<any>>;
 
+	/**
+	 * The set this anchor node is part of.
+	 */
+	readonly anchorSet: AnchorSet;
+
 	/**
 	 * Gets a child of this node.
 	 *
@@ -620,6 +637,7 @@ export class AnchorSet implements ISubscribable<AnchorSetRootEvents>, AnchorLoca
 			0x767 /* Must release existing visitor before acquiring another */,
 		);
 
+		const referencedPathNodes: PathNode[] = [];
 		const visitor = {
 			anchorSet: this,
 			// Run `withNode` on anchorNode for parent if there is such an anchorNode.
@@ -634,27 +652,12 @@ export class AnchorSet implements ISubscribable<AnchorSetRootEvents>, AnchorLoca
 					// Delta traversal should early out in this case because no work is needed (and all move outs are known to not contain anchors).
 					this.parent = this.anchorSet.internalizePath(this.parent);
 					if (this.parent instanceof PathNode) {
+						this.parent.addRef();
+						referencedPathNodes.push(this.parent);
 						withNode(this.parent);
 					}
 				}
 			},
-			// Run `withNode` on every node from the current `this.parent` to the root.
-			// Should only be called when in a field.
-			withParentNodeUpToRoot(withNode: (anchorNode: PathNode) => void) {
-				assert(
-					this.parentField !== undefined,
-					0x7cd /* Must be in a field to call withNodeUpToRoot */,
-				);
-				// This function gets called when we attach a node to the root field, in which case there is no parent.
-				// It's expected this will do nothing in that case.
-				let currentParent: UpPath | undefined = this.parent;
-				while (currentParent !== undefined) {
-					if (currentParent instanceof PathNode) {
-						withNode(currentParent);
-					}
-					currentParent = currentParent.parent;
-				}
-			},
 			// Lookup table for path visitors collected from {@link AnchorEvents.visitSubtreeChanging} emitted events.
 			// The key is the path of the node that the visitor is registered on. The code ensures that the path visitor visits only the appropriate subtrees
 			// by maintaining the mapping only during time between the {@link DeltaVisitor.enterNode} and {@link DeltaVisitor.exitNode} calls for a given anchorNode.
@@ -666,6 +669,9 @@ export class AnchorSet implements ISubscribable<AnchorSetRootEvents>, AnchorLoca
 					this.anchorSet.activeVisitor !== undefined,
 					0x768 /* Multiple free calls for same visitor */,
 				);
+				for (const node of referencedPathNodes) {
+					node.removeRef();
+				}
 				this.anchorSet.activeVisitor = undefined;
 			},
 			notifyChildrenChanging(): void {
@@ -695,9 +701,6 @@ export class AnchorSet implements ISubscribable<AnchorSetRootEvents>, AnchorLoca
 					start: 0,
 					end: count,
 				});
-				this.withParentNodeUpToRoot((p) => {
-					p.events.emit("beforeChange", p);
-				});
 				for (const visitors of this.pathVisitors.values()) {
 					for (const pathVisitor of visitors) {
 						pathVisitor.beforeAttach(sourcePath, destinationPath);
@@ -718,9 +721,6 @@ export class AnchorSet implements ISubscribable<AnchorSetRootEvents>, AnchorLoca
 					field: this.parentField,
 					...destination,
 				};
-				this.withParentNodeUpToRoot((p) => {
-					p.events.emit("afterChange", p);
-				});
 				for (const visitors of this.pathVisitors.values()) {
 					for (const pathVisitor of visitors) {
 						pathVisitor.afterAttach(sourcePath, destinationPath);
@@ -763,9 +763,6 @@ export class AnchorSet implements ISubscribable<AnchorSetRootEvents>, AnchorLoca
 					field: destination,
 					index: 0,
 				});
-				this.withParentNodeUpToRoot((p) => {
-					p.events.emit("beforeChange", p);
-				});
 				for (const visitors of this.pathVisitors.values()) {
 					for (const pathVisitor of visitors) {
 						pathVisitor.beforeDetach(sourcePath, destinationPath);
@@ -787,9 +784,6 @@ export class AnchorSet implements ISubscribable<AnchorSetRootEvents>, AnchorLoca
 					start: 0,
 					end: count,
 				});
-				this.withParentNodeUpToRoot((p) => {
-					p.events.emit("afterChange", p);
-				});
 				for (const visitors of this.pathVisitors.values()) {
 					for (const pathVisitor of visitors) {
 						pathVisitor.afterDetach(sourcePath, destinationPath);
@@ -837,9 +831,6 @@ export class AnchorSet implements ISubscribable<AnchorSetRootEvents>, AnchorLoca
 					field: destination,
 					index: 0,
 				});
-				this.withParentNodeUpToRoot((p) => {
-					p.events.emit("beforeChange", p);
-				});
 				for (const visitors of this.pathVisitors.values()) {
 					for (const pathVisitor of visitors) {
 						pathVisitor.beforeReplace(
@@ -873,9 +864,6 @@ export class AnchorSet implements ISubscribable<AnchorSetRootEvents>, AnchorLoca
 					start: 0,
 					end: newContent.end - newContent.start,
 				});
-				this.withParentNodeUpToRoot((p) => {
-					p.events.emit("afterChange", p);
-				});
 				for (const visitors of this.pathVisitors.values()) {
 					for (const pathVisitor of visitors) {
 						pathVisitor.afterReplace(
@@ -965,6 +953,7 @@ export class AnchorSet implements ISubscribable<AnchorSetRootEvents>, AnchorLoca
 			exitNode(index: number): void {
 				assert(this.parent !== undefined, 0x3ac /* Must have parent node */);
 				this.maybeWithNode((p) => {
+					p.events.emit("subtreeChanged", p);
 					// Remove subtree path visitors added at this node if there are any
 					this.pathVisitors.delete(p);
 				});
@@ -1141,7 +1130,7 @@ class PathNode extends ReferenceCountedBase implements UpPath<PathNode>, AnchorN
 
 	// Called when refcount is set to 0.
 	// Node may be kept alive by children or events after this point.
-	protected dispose(): void {
+	protected onUnreferenced(): void {
 		this.considerDispose();
 	}
 

package/src/core/tree/cursor.ts

@@ -3,8 +3,10 @@
  * Licensed under the MIT License.
  */
 
-import { assert } from "@fluidframework/core-utils";
+import { assert } from "@fluidframework/core-utils/internal";
+
 import { FieldKey } from "../schema-stored/index.js";
+
 import { FieldUpPath, UpPath } from "./pathTree.js";
 import { TreeType, Value } from "./types.js";
 

package/src/core/tree/delta.ts

@@ -5,6 +5,7 @@
 
 import { RevisionTag } from "../rebase/index.js";
 import { FieldKey } from "../schema-stored/index.js";
+
 import { ITreeCursorSynchronous } from "./cursor.js";
 
 /**

package/src/core/tree/deltaUtil.ts

@@ -5,8 +5,9 @@
 
 import { Mutable } from "../../util/index.js";
 import { FieldKey } from "../schema-stored/index.js";
+
 import { ITreeCursorSynchronous } from "./cursor.js";
-import { Root, DetachedNodeId, FieldChanges, Mark } from "./delta.js";
+import { DetachedNodeId, FieldChanges, Mark, Root } from "./delta.js";
 import { rootFieldKey } from "./types.js";
 
 export const emptyDelta: Root<never> = {};

package/src/core/tree/detachedFieldIndex.ts

@@ -3,7 +3,9 @@
  * Licensed under the MIT License.
  */
 
-import { assert } from "@fluidframework/core-utils";
+import { assert } from "@fluidframework/core-utils/internal";
+
+import { ICodecOptions, IJsonCodec, noopValidator } from "../../codec/index.js";
 import {
 	Brand,
 	IdAllocator,
@@ -16,13 +18,13 @@ import {
 	setInNestedMap,
 	tryGetFromNestedMap,
 } from "../../util/index.js";
-import { FieldKey } from "../schema-stored/index.js";
-import { ICodecOptions, IJsonCodec, noopValidator } from "../../codec/index.js";
 import { RevisionTagCodec } from "../rebase/index.js";
+import { FieldKey } from "../schema-stored/index.js";
+
 import * as Delta from "./delta.js";
-import { DetachedFieldSummaryData, Major, Minor } from "./detachedFieldIndexTypes.js";
 import { makeDetachedNodeToFieldCodec } from "./detachedFieldIndexCodec.js";
 import { Format } from "./detachedFieldIndexFormat.js";
+import { DetachedFieldSummaryData, Major, Minor } from "./detachedFieldIndexTypes.js";
 
 /**
  * ID used to create a detached field key for a removed subtree.

package/src/core/tree/detachedFieldIndexCodec.ts

@@ -3,9 +3,12 @@
  * Licensed under the MIT License.
  */
 
-import { assert } from "@fluidframework/core-utils";
+import { assert } from "@fluidframework/core-utils/internal";
+
 import { ICodecOptions, IJsonCodec, makeVersionedValidatedCodec } from "../../codec/index.js";
 import { EncodedRevisionTag, RevisionTagCodec } from "../rebase/index.js";
+
+import { ForestRootId } from "./detachedFieldIndex.js";
 import {
 	EncodedRootsForRevision,
 	Format,
@@ -13,7 +16,6 @@ import {
 	version,
 } from "./detachedFieldIndexFormat.js";
 import { DetachedFieldSummaryData, Major } from "./detachedFieldIndexTypes.js";
-import { ForestRootId } from "./detachedFieldIndex.js";
 
 class MajorCodec implements IJsonCodec<Major> {
 	public constructor(

package/src/core/tree/detachedFieldIndexFormat.ts

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

package/src/core/tree/detachedFieldIndexTypes.ts

@@ -5,6 +5,7 @@
 
 import { NestedMap } from "../../util/index.js";
 import { RevisionTag } from "../rebase/index.js";
+
 import { ForestRootId } from "./detachedFieldIndex.js";
 
 export type Major = RevisionTag | undefined;

package/src/core/tree/mapTree.ts

@@ -4,6 +4,7 @@
  */
 
 import { FieldKey } from "../schema-stored/index.js";
+
 import { NodeData } from "./types.js";
 
 /**

package/src/core/tree/pathTree.ts

@@ -5,6 +5,7 @@
 
 import { Brand } from "../../util/index.js";
 import { FieldKey } from "../schema-stored/index.js";
+
 import { DetachedField, keyAsDetachedField } from "./types.js";
 
 /**

package/src/core/tree/persistedTreeTextFormat.ts

@@ -4,6 +4,7 @@
  */
 
 import { Static, TSchema, Type } from "@sinclair/typebox";
+
 import { schemaFormat } from "../schema-stored/index.js";
 
 /**

package/src/core/tree/sparseTree.ts

@@ -3,9 +3,11 @@
  * Licensed under the MIT License.
  */
 
-import { assert } from "@fluidframework/core-utils";
+import { assert } from "@fluidframework/core-utils/internal";
+
 import { FieldKey } from "../schema-stored/index.js";
-import { topDownPath, UpPath } from "./pathTree.js";
+
+import { UpPath, topDownPath } from "./pathTree.js";
 
 /**
  * Sparse Tree of nodes.

package/src/core/tree/treeTextFormat.ts

@@ -4,6 +4,7 @@
  */
 
 import { FieldKey } from "../schema-stored/index.js";
+
 import { NodeData } from "./types.js";
 
 /**

package/src/core/tree/types.ts

@@ -4,8 +4,9 @@
  */
 
 import { IFluidHandle } from "@fluidframework/core-interfaces";
+
+import { Brand, Opaque, _InlineTrick, brand, extractFromOpaque } from "../../util/index.js";
 import { FieldKey, TreeNodeSchemaIdentifier, ValueSchema } from "../schema-stored/index.js";
-import { _InlineTrick, brand, Brand, extractFromOpaque, Opaque } from "../../util/index.js";
 
 /**
  * @internal

package/src/core/tree/visitDelta.ts

@@ -2,12 +2,15 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-import { assert } from "@fluidframework/core-utils";
 
+import { assert } from "@fluidframework/core-utils/internal";
+
+import { NestedMap, setInNestedMap, tryGetFromNestedMap } from "../../util/index.js";
 import { FieldKey } from "../schema-stored/index.js";
+
+import { ITreeCursorSynchronous } from "./cursor.js";
 import * as Delta from "./delta.js";
-import { NodeIndex, PlaceIndex, Range } from "./pathTree.js";
-import { ForestRootId, DetachedFieldIndex } from "./detachedFieldIndex.js";
+import { ProtoNodes } from "./delta.js";
 import {
 	areDetachedNodeIdsEqual,
 	isAttachMark,
@@ -15,7 +18,9 @@ import {
 	isReplaceMark,
 	offsetDetachId,
 } from "./deltaUtil.js";
-import { ProtoNodes } from "./delta.js";
+import { DetachedFieldIndex, ForestRootId } from "./detachedFieldIndex.js";
+import { Major, Minor } from "./detachedFieldIndexTypes.js";
+import { NodeIndex, PlaceIndex, Range } from "./pathTree.js";
 
 /**
  * Implementation notes:
@@ -48,6 +53,13 @@ import { ProtoNodes } from "./delta.js";
  *
  * After the attach phase, roots destruction is carried out.
  * This needs to happen last to allow modifications to detached roots to be applied before they are destroyed.
+ *
+ * The details of the delta visit algorithm can impact how/when events are emitted by the objects that own the visitors.
+ * For example, as of 2024-03-27, the subtreecChanged event of an AnchorNode is emitted when exiting a node during a
+ * delta visit, and thus the two-pass nature of the algorithm means the event fires twice for any given change.
+ * This two-pass nature also means that the event may fire at a time where no change is visible in the tree. E.g.,
+ * if a node is being replaced, when the event fires during the detach pass no change in the tree has happened so the
+ * listener won't see any; then when it fires during the attach pass, the change will be visible in the event listener.
  */
 
 /**
@@ -69,8 +81,16 @@ export function visitDelta(
 	const attachPassRoots: Map<ForestRootId, Delta.FieldMap> = new Map();
 	const rootTransfers: Delta.DetachedNodeRename[] = [];
 	const rootDestructions: Delta.DetachedNodeDestruction[] = [];
+	const refreshers: NestedMap<Major, Minor, ITreeCursorSynchronous> = new Map();
+	delta.refreshers?.forEach(({ id: { major, minor }, trees }) => {
+		for (let i = 0; i < trees.length; i += 1) {
+			const offsettedId = minor + i;
+			setInNestedMap(refreshers, major, offsettedId, trees[i]);
+		}
+	});
 	const detachConfig: PassConfig = {
 		func: detachPass,
+		refreshers,
 		detachedFieldIndex,
 		detachPassRoots,
 		attachPassRoots,
@@ -83,6 +103,7 @@ export function visitDelta(
 	transferRoots(rootTransfers, attachPassRoots, detachedFieldIndex, visitor);
 	const attachConfig: PassConfig = {
 		func: attachPass,
+		refreshers,
 		detachedFieldIndex,
 		detachPassRoots,
 		attachPassRoots,
@@ -288,7 +309,11 @@ export interface DeltaVisitor {
 interface PassConfig {
 	readonly func: Pass;
 	readonly detachedFieldIndex: DetachedFieldIndex;
-
+	/**
+	 * A mapping between forest root id and trees that represent refresher data. Each entry is only
+	 * created in the forest once needed.
+	 */
+	readonly refreshers: NestedMap<Major, Minor, ITreeCursorSynchronous>;
 	/**
 	 * Nested changes on roots that need to be visited as part of the detach pass.
 	 * Each entry is removed when its associated changes are visited.
@@ -358,7 +383,13 @@ function visitNode(
 function detachPass(delta: Delta.FieldChanges, visitor: DeltaVisitor, config: PassConfig): void {
 	if (delta.global !== undefined) {
 		for (const { id, fields } of delta.global) {
-			const root = config.detachedFieldIndex.getEntry(id);
+			let root = config.detachedFieldIndex.tryGetEntry(id);
+			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);
+				root = config.detachedFieldIndex.getEntry(id);
+			}
 			config.detachPassRoots.set(root, fields);
 			config.attachPassRoots.set(root, fields);
 		}
@@ -395,6 +426,22 @@ function detachPass(delta: Delta.FieldChanges, visitor: DeltaVisitor, config: Pa
 	}
 }
 
+function buildTrees(
+	id: Delta.DetachedNodeId,
+	trees: readonly ITreeCursorSynchronous[],
+	config: PassConfig,
+	visitor: DeltaVisitor,
+) {
+	for (let i = 0; i < trees.length; i += 1) {
+		const offsettedId = offsetDetachId(id, i);
+		let root = config.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);
+		visitor.create([trees[i]], field);
+	}
+}
+
 function processBuilds(
 	builds: readonly Delta.DetachedNodeBuild[] | undefined,
 	config: PassConfig,
@@ -402,17 +449,7 @@ function processBuilds(
 ) {
 	if (builds !== undefined) {
 		for (const { id, trees } of builds) {
-			for (let i = 0; i < trees.length; i += 1) {
-				const offsettedId = offsetDetachId(id, i);
-				let root = config.detachedFieldIndex.tryGetEntry(offsettedId);
-				// Tree building is idempotent. We can therefore ignore build instructions for trees that already exist.
-				// The idempotence is leveraged by undo/redo as well as sandwich rebasing.
-				if (root === undefined) {
-					root = config.detachedFieldIndex.createEntry(offsettedId);
-					const field = config.detachedFieldIndex.toFieldKey(root);
-					visitor.create([trees[i]], field);
-				}
-			}
+			buildTrees(id, trees, config, visitor);
 		}
 	}
 }
@@ -440,7 +477,17 @@ function attachPass(delta: Delta.FieldChanges, visitor: DeltaVisitor, config: Pa
 				for (let i = 0; i < mark.count; i += 1) {
 					// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 					const offsetAttachId = offsetDetachId(mark.attach!, i);
-					const sourceRoot = config.detachedFieldIndex.getEntry(offsetAttachId);
+					let sourceRoot = config.detachedFieldIndex.tryGetEntry(offsetAttachId);
+					if (sourceRoot === undefined) {
+						const tree = tryGetFromNestedMap(
+							config.refreshers,
+							offsetAttachId.major,
+							offsetAttachId.minor,
+						);
+						assert(tree !== undefined, 0x92a /* refresher data not found */);
+						buildTrees(offsetAttachId, [tree], config, visitor);
+						sourceRoot = config.detachedFieldIndex.getEntry(offsetAttachId);
+					}
 					const sourceField = config.detachedFieldIndex.toFieldKey(sourceRoot);
 					const offsetIndex = index + i;
 					if (isReplaceMark(mark)) {

package/src/core/tree/visitPath.ts

@@ -2,6 +2,8 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
+
+import { ProtoNodes } from "./delta.js";
 import {
 	DetachedPlaceUpPath,
 	DetachedRangeUpPath,
@@ -9,7 +11,6 @@ import {
 	RangeUpPath,
 	UpPath,
 } from "./pathTree.js";
-import { ProtoNodes } from "./delta.js";
 
 /**
  * Delta visitor for the path tree.

package/src/core/tree/visitorUtils.ts

@@ -3,15 +3,17 @@
  * Licensed under the MIT License.
  */
 
-import { assert } from "@fluidframework/core-utils";
+import { assert } from "@fluidframework/core-utils/internal";
+
+import { ICodecOptions } from "../../codec/index.js";
 import { IdAllocator, idAllocatorFromMaxId } from "../../util/index.js";
-import { FieldKey } from "../schema-stored/index.js";
 import { RevisionTagCodec } from "../rebase/index.js";
-import { ICodecOptions } from "../../codec/index.js";
+import { FieldKey } from "../schema-stored/index.js";
+
+import { ProtoNodes, Root } from "./delta.js";
+import { DetachedFieldIndex, ForestRootId } from "./detachedFieldIndex.js";
 import { PlaceIndex, Range } from "./pathTree.js";
-import { ForestRootId, DetachedFieldIndex } from "./detachedFieldIndex.js";
 import { DeltaVisitor, visitDelta } from "./visitDelta.js";
-import { ProtoNodes, Root } from "./delta.js";
 
 export function makeDetachedFieldIndex(
 	prefix: string = "Temp",

package/src/domains/json/jsonCursor.ts

@@ -3,22 +3,24 @@
  * Licensed under the MIT License.
  */
 
-import { assert } from "@fluidframework/core-utils";
+import { assert } from "@fluidframework/core-utils/internal";
+
 import {
-	ITreeCursor,
 	EmptyKey,
 	FieldKey,
+	ITreeCursor,
+	ITreeCursorSynchronous,
 	mapCursorField,
 	mapCursorFields,
-	ITreeCursorSynchronous,
 } from "../../core/index.js";
-import { JsonCompatible } from "../../util/index.js";
 import {
 	CursorAdapter,
 	isFluidHandle,
 	stackTreeNodeCursor,
 } from "../../feature-libraries/index.js";
+import { JsonCompatible } from "../../util/index.js";
 import { leaf } from "../leafDomain.js";
+
 import { jsonArray, jsonObject } from "./jsonDomainSchema.js";
 
 const adapter: CursorAdapter<JsonCompatible> = {

package/src/domains/json/jsonDomainSchema.ts

@@ -9,10 +9,9 @@
 // API-Extractor issue: https://github.com/microsoft/rushstack/issues/4507
 // eslint-disable-next-line @typescript-eslint/no-unused-vars, unused-imports/no-unused-imports
 import { ValueSchema } from "../../core/index.js";
-
 import {
-	FlexAllowedTypes,
 	FieldKinds,
+	FlexAllowedTypes,
 	FlexFieldSchema,
 	SchemaBuilderInternal,
 } from "../../feature-libraries/index.js";

package/src/domains/leafDomain.ts

@@ -3,8 +3,8 @@
  * Licensed under the MIT License.
  */
 
-import { SchemaBuilderInternal } from "../feature-libraries/index.js";
 import { ValueSchema } from "../core/index.js";
+import { SchemaBuilderInternal } from "../feature-libraries/index.js";
 
 /**
  * Names in this domain follow https://en.wikipedia.org/wiki/Reverse_domain_name_notation