@fluidframework/tree 2.23.0 → 2.31.0

package/src/feature-libraries/chunked-forest/chunkTree.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { assert, oob } from "@fluidframework/core-utils/internal";
+import { assert, debugAssert, oob, fail } from "@fluidframework/core-utils/internal";
 
 import {
 	CursorLocationType,
@@ -24,13 +24,13 @@ import {
 	type TreeChunk,
 	tryGetChunk,
 } from "../../core/index.js";
-import { fail, getOrCreate } from "../../util/index.js";
+import { getOrCreate } from "../../util/index.js";
 import type { FullSchemaPolicy } from "../modular-schema/index.js";
 
 import { BasicChunk } from "./basicChunk.js";
 import { SequenceChunk } from "./sequenceChunk.js";
 import { type FieldShape, TreeShape, UniformChunk } from "./uniformChunk.js";
-import { isStableNodeKey } from "../node-key/index.js";
+import { isStableNodeIdentifier } from "../node-identifier/index.js";
 import type { IIdCompressor } from "@fluidframework/id-compressor";
 
 export interface Disposable {
@@ -175,7 +175,9 @@ export function chunkField(
 ): TreeChunk[] {
 	const length = cursor.getFieldLength();
 	const started = cursor.firstNode();
-	assert(started, 0x57c /* field to chunk should have at least one node */);
+	debugAssert(
+		() => started === (length !== 0) || "only 0 length fields should not have nodes",
+	);
 	return chunkRange(cursor, policy, length, false);
 }
 
@@ -373,10 +375,12 @@ function newBasicChunkTree(
 }
 
 /**
- * @param cursor - cursor in nodes mode
+ * Chunk a portion of a field.
+ *
+ * @param cursor - cursor at the starting node in the field.
  * @param policy - heuristics to impact chunking
- * @param length - how many nodes to process (at the top level)
- * @param skipLastNavigation - if true, leaves the cursor at the last node instead of moving off of it.
+ * @param length - how many nodes to process (at the top level). When 0, the cursor is not moved, and may be at the end of the field (and thus in Fields mode)
+ * @param skipLastNavigation - if true, leaves the cursor at the last node instead of moving off of it. Invalid if length is 0.
  */
 export function chunkRange(
 	cursor: ITreeCursorSynchronous,
@@ -384,7 +388,14 @@ export function chunkRange(
 	length: number,
 	skipLastNavigation: boolean,
 ): TreeChunk[] {
-	assert(cursor.mode === CursorLocationType.Nodes, 0x57e /* should be in nodes */);
+	assert(
+		!(skipLastNavigation && length === 0),
+		0xb58 /* Cannot skip last navigation if length is 0 and thus last navigation already occurred. */,
+	);
+	assert(
+		(cursor.mode === CursorLocationType.Nodes) === length > 0,
+		0xb59 /* Should be in nodes mode if not past end */,
+	);
 	let output: TreeChunk[] = [];
 	let remaining = length;
 	while (remaining > 0) {
@@ -498,7 +509,7 @@ export function insertValues(
 		if (
 			typeof cursor.value === "string" &&
 			idCompressor !== undefined &&
-			isStableNodeKey(cursor.value)
+			isStableNodeIdentifier(cursor.value)
 		) {
 			values.push(idCompressor.tryRecompress(cursor.value) ?? cursor.value);
 		} else {

package/src/feature-libraries/chunked-forest/chunkedForest.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { assert, oob } from "@fluidframework/core-utils/internal";
+import { assert, oob, fail } from "@fluidframework/core-utils/internal";
 import type { Listenable } from "@fluidframework/core-interfaces";
 import { createEmitter } from "@fluid-internal/client-utils";
 
@@ -21,7 +21,6 @@ import {
 	type ITreeSubscriptionCursor,
 	ITreeSubscriptionCursorState,
 	type PlaceIndex,
-	type ProtoNodes,
 	type Range,
 	TreeNavigationResult,
 	type TreeStoredSchemaSubscription,
@@ -33,18 +32,18 @@ import {
 	rootFieldKey,
 	type ChunkedCursor,
 	type TreeChunk,
+	type DeltaDetachedNodeId,
 } from "../../core/index.js";
 import {
 	assertValidRange,
 	brand,
-	fail,
 	getLast,
 	getOrAddEmptyToMap,
 	hasSome,
 } from "../../util/index.js";
 
 import { BasicChunk, BasicChunkCursor, type SiblingsOrKey } from "./basicChunk.js";
-import { type IChunker, basicChunkTree, chunkTree } from "./chunkTree.js";
+import { type IChunker, basicChunkTree, chunkFieldSingle, chunkTree } from "./chunkTree.js";
 import type { IIdCompressor } from "@fluidframework/id-compressor";
 
 function makeRoot(): BasicChunk {
@@ -91,6 +90,10 @@ export class ChunkedForest implements IEditableForest {
 		return new ChunkedForest(this.roots, schema, this.chunker.clone(schema), anchors);
 	}
 
+	public chunkField(cursor: ITreeCursorSynchronous): TreeChunk {
+		return chunkFieldSingle(cursor, { idCompressor: this.idCompressor, policy: this.chunker });
+	}
+
 	public forgetAnchor(anchor: Anchor): void {
 		this.anchors.forget(anchor);
 	}
@@ -136,7 +139,7 @@ export class ChunkedForest implements IEditableForest {
 				this.forest.#events.emit("beforeChange");
 				this.forest.roots.fields.delete(detachedField);
 			},
-			create(content: ProtoNodes, destination: FieldKey): void {
+			create(content: readonly ITreeCursorSynchronous[], destination: FieldKey): void {
 				this.forest.#events.emit("beforeChange");
 				const chunks: TreeChunk[] = content.map((c) =>
 					chunkTree(c, {
@@ -150,7 +153,7 @@ export class ChunkedForest implements IEditableForest {
 			attach(source: FieldKey, count: number, destination: PlaceIndex): void {
 				this.attachEdit(source, count, destination);
 			},
-			detach(source: Range, destination: FieldKey): void {
+			detach(source: Range, destination: FieldKey, id: DeltaDetachedNodeId): void {
 				this.detachEdit(source, destination);
 			},
 			/**
@@ -210,6 +213,7 @@ export class ChunkedForest implements IEditableForest {
 				newContentSource: FieldKey,
 				range: Range,
 				oldContentDestination: FieldKey,
+				oldContentId: DeltaDetachedNodeId,
 			): void {
 				assert(
 					newContentSource !== oldContentDestination,

package/src/feature-libraries/chunked-forest/codec/README.md

@@ -8,8 +8,8 @@ Two main algorithms are used:
 
 -   Shape based encoding: Trees are split into "Shape" information and "Data".
     "Shape" can (but does not have to) contain information like type, which fields exist, and how many nodes are in them and the shapes of those nodes.
--   [Dictionary Coding](https://go-compression.github.io/algorithms/dictionary/) using `Counter` from [chunkCodexUtilities.ts](./chunkCodecUtilities.ts)
-    is applied to Identifiers (such a type names and field keys) and Shapes.
+-   [Dictionary Coding](https://go-compression.github.io/algorithms/dictionary/) using `Counter` from [chunkCodecUtilities.ts](./chunkCodecUtilities.ts)
+    is applied to Identifiers (such as type names and field keys) and Shapes.
 
 The main challenge is deciding what shapes to use: if too much information is captured in the shape, there will be more shapes which take up more space,
 but if too little information is captured in the shapes, the size of the encoded tree will be large.
@@ -20,7 +20,7 @@ A few implementations are included which make different choices here:
 -   [uncompressedEncode.ts](uncompressedEncode.ts): the simplest implementation, which captures nothing in the shape and does no Dictionary Coding of identifiers.
     This makes for more human readable data as well as a simple reference implementation.
 -   [compressedEncode.ts](compressedEncode.ts): some utilities for actual compressed encoding, but does not contain any advanced strategies (instead they must be provided to it via the `EncoderCache`)
--   [schemaBasedEncoding.ts](schemaBasedEncoding.ts): a strategy for compressedEncode using schema to infer commonly used shapes.
+-   [schemaBasedEncode.ts](schemaBasedEncode.ts): a strategy for compressedEncode using schema to infer commonly used shapes.
 
 ### Future Optimizations
 

package/src/feature-libraries/chunked-forest/codec/chunkEncodingGeneric.ts

@@ -3,8 +3,8 @@
  * Licensed under the MIT License.
  */
 
+import { fail } from "@fluidframework/core-utils/internal";
 import type { TreeValue } from "../../../core/index.js";
-import { fail } from "../../../util/index.js";
 import type { FluidSerializableReadOnly } from "../../valueUtilities.js";
 
 import {

package/src/feature-libraries/chunked-forest/codec/codecs.ts

@@ -17,7 +17,7 @@ import { TreeCompressionStrategy } from "../../treeCompressionUtils.js";
 import { decode } from "./chunkDecoding.js";
 import type { FieldBatch } from "./fieldBatch.js";
 import { EncodedFieldBatch, validVersions } from "./format.js";
-import { schemaCompressedEncode } from "./schemaBasedEncoding.js";
+import { schemaCompressedEncode } from "./schemaBasedEncode.js";
 import { uncompressedEncode } from "./uncompressedEncode.js";
 import type { IIdCompressor, SessionId } from "@fluidframework/id-compressor";
 

package/src/feature-libraries/chunked-forest/codec/compressedEncode.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { assert, unreachableCase } from "@fluidframework/core-utils/internal";
+import { assert, unreachableCase, fail } from "@fluidframework/core-utils/internal";
 
 import {
 	CursorLocationType,
@@ -15,7 +15,7 @@ import {
 	type Value,
 	forEachNode,
 } from "../../../core/index.js";
-import { fail, getOrCreate } from "../../../util/index.js";
+import { getOrCreate } from "../../../util/index.js";
 import type { FlexFieldKind } from "../../modular-schema/index.js";
 
 import type { Counter, DeduplicationTable } from "./chunkCodecUtilities.js";
@@ -37,7 +37,7 @@ import {
 import type { IIdCompressor } from "@fluidframework/id-compressor";
 
 /**
- * Encode data from `FieldBatch` in into an `EncodedChunk`.
+ * Encode data from `FieldBatch` into an `EncodedChunk`.
  *
  * Optimized for encoded size and encoding performance.
  *

package/src/feature-libraries/chunked-forest/codec/nodeShape.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { assert } from "@fluidframework/core-utils/internal";
+import { assert, fail } from "@fluidframework/core-utils/internal";
 
 import {
 	type FieldKey,
@@ -12,7 +12,7 @@ import {
 	forEachField,
 	type Value,
 } from "../../../core/index.js";
-import { brand, fail } from "../../../util/index.js";
+import { brand } from "../../../util/index.js";
 
 import type { Counter, DeduplicationTable } from "./chunkCodecUtilities.js";
 import { type BufferFormat, IdentifierToken, Shape } from "./chunkEncodingGeneric.js";

package/src/feature-libraries/chunked-forest/codec/{schemaBasedEncoding.ts → schemaBasedEncode.ts}

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { assert, unreachableCase } from "@fluidframework/core-utils/internal";
+import { assert, unreachableCase, fail } from "@fluidframework/core-utils/internal";
 
 import {
 	LeafNodeStoredSchema,
@@ -16,7 +16,6 @@ import {
 	Multiplicity,
 	identifierFieldKindIdentifier,
 } from "../../../core/index.js";
-import { fail } from "../../../util/index.js";
 import type { FullSchemaPolicy } from "../../modular-schema/index.js";
 
 import {

package/src/feature-libraries/chunked-forest/emptyChunk.ts

@@ -3,6 +3,7 @@
  * Licensed under the MIT License.
  */
 
+import { fail } from "@fluidframework/core-utils/internal";
 import {
 	CursorLocationType,
 	CursorMarker,
@@ -15,7 +16,6 @@ import {
 	cursorChunk,
 	dummyRoot,
 } from "../../core/index.js";
-import { fail } from "../../util/index.js";
 import { prefixFieldPath } from "../treeCursorUtils.js";
 
 /**

package/src/feature-libraries/chunked-forest/uniformChunk.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { assert, compareArrays, oob } from "@fluidframework/core-utils/internal";
+import { assert, compareArrays, oob, fail } from "@fluidframework/core-utils/internal";
 
 import {
 	CursorLocationType,
@@ -19,7 +19,7 @@ import {
 	cursorChunk,
 	dummyRoot,
 } from "../../core/index.js";
-import { ReferenceCountedBase, fail, hasSome } from "../../util/index.js";
+import { ReferenceCountedBase, hasSome } from "../../util/index.js";
 import { SynchronousCursor, prefixFieldPath, prefixPath } from "../treeCursorUtils.js";
 
 import type { SessionSpaceCompressedId, IIdCompressor } from "@fluidframework/id-compressor";
@@ -233,9 +233,10 @@ class OffsetShape {
 	/**
 	 * @param shape - the shape of each child in this field
 	 * @param topLevelLength - number of top level nodes in this sequence chunk (either field within a chunk, or top level chunk)
-	 * @param offset - number of nodes before this in the parent's subtree
+	 * @param offset - number of nodes before this in the parent's subtree. The nodes are considered in depth first pre order
+	 * traversal, so a parent is the first node in its subtree (before its children) with offset 0
 	 * @param key - field key
-	 * @param indexOfParentField - index of node with this shape
+	 * @param indexOfParentField - index to this shape in the parent's array of fields
 	 */
 	public constructor(
 		public readonly shape: TreeShape,

package/src/feature-libraries/default-schema/defaultEditBuilder.ts

@@ -13,13 +13,14 @@ import {
 	type ChangeFamily,
 	type ChangeFamilyEditor,
 	type ChangeRebaser,
-	CursorLocationType,
 	type DeltaDetachedNodeId,
 	type DeltaRoot,
 	type FieldUpPath,
-	type ITreeCursorSynchronous,
+	type NormalizedFieldUpPath,
+	type NormalizedUpPath,
 	type RevisionTag,
 	type TaggedChange,
+	type TreeChunk,
 	type UpPath,
 	compareFieldUpPaths,
 	topDownPath,
@@ -43,7 +44,6 @@ import {
 	sequence,
 	required as valueFieldKind,
 } from "./defaultFieldKinds.js";
-import type { IIdCompressor } from "@fluidframework/id-compressor";
 import type { CellId } from "../sequence-field/index.js";
 
 export type DefaultChangeset = ModularChangeset;
@@ -120,14 +120,14 @@ export function relevantRemovedRoots(change: ModularChangeset): Iterable<DeltaDe
  * If/when such a mechanism becomes available, an evaluation should be done to determine if any existing editing operations should be changed to leverage it
  * (Possibly by adding opt ins at the view schema layer).
  */
-export interface IDefaultEditBuilder {
+export interface IDefaultEditBuilder<TContent = TreeChunk> {
 	/**
 	 * @param field - the value field which is being edited under the parent node
 	 * @returns An object with methods to edit the given field of the given parent.
 	 * The returned object can be used (i.e., have its methods called) multiple times but its lifetime
 	 * is bounded by the lifetime of this edit builder.
 	 */
-	valueField(field: FieldUpPath): ValueFieldEditBuilder<ITreeCursorSynchronous>;
+	valueField(field: NormalizedFieldUpPath): ValueFieldEditBuilder<TContent>;
 
 	/**
 	 * @param field - the optional field which is being edited under the parent node
@@ -135,7 +135,7 @@ export interface IDefaultEditBuilder {
 	 * The returned object can be used (i.e., have its methods called) multiple times but its lifetime
 	 * is bounded by the lifetime of this edit builder.
 	 */
-	optionalField(field: FieldUpPath): OptionalFieldEditBuilder<ITreeCursorSynchronous>;
+	optionalField(field: NormalizedFieldUpPath): OptionalFieldEditBuilder<TContent>;
 
 	/**
 	 * @param field - the sequence field which is being edited under the parent node
@@ -144,7 +144,7 @@ export interface IDefaultEditBuilder {
 	 * The returned object can be used (i.e., have its methods called) multiple times but its lifetime
 	 * is bounded by the lifetime of this edit builder.
 	 */
-	sequenceField(field: FieldUpPath): SequenceFieldEditBuilder<ITreeCursorSynchronous>;
+	sequenceField(field: NormalizedFieldUpPath): SequenceFieldEditBuilder<TContent>;
 
 	/**
 	 * Moves a subsequence from one sequence field to another sequence field.
@@ -153,10 +153,10 @@ export interface IDefaultEditBuilder {
 	 * For example, `move(field, 0, 1, field, 2)` changes `[A, B, C]` to `[B, A, C]`.
 	 */
 	move(
-		sourceField: FieldUpPath,
+		sourceField: NormalizedFieldUpPath,
 		sourceIndex: number,
 		count: number,
-		destinationField: FieldUpPath,
+		destinationField: NormalizedFieldUpPath,
 		destinationIndex: number,
 	): void;
 
@@ -164,13 +164,13 @@ export interface IDefaultEditBuilder {
 	 * Add a constraint that the node at the given path must exist.
 	 * @param path - The path to the node that must exist.
 	 */
-	addNodeExistsConstraint(path: UpPath): void;
+	addNodeExistsConstraint(path: NormalizedUpPath): void;
 
 	/**
 	 * Add a constraint that the node at the given path must exist when reverting a change.
 	 * @param path - The path to the node that must exist when reverting a change.
 	 */
-	addNodeExistsConstraintOnRevert(path: UpPath): void;
+	addNodeExistsConstraintOnRevert(path: NormalizedUpPath): void;
 }
 
 /**
@@ -184,7 +184,6 @@ export class DefaultEditBuilder implements ChangeFamilyEditor, IDefaultEditBuild
 		family: ChangeFamily<ChangeFamilyEditor, DefaultChangeset>,
 		private readonly mintRevisionTag: () => RevisionTag,
 		changeReceiver: (change: TaggedChange<DefaultChangeset>) => void,
-		private readonly idCompressor?: IIdCompressor,
 	) {
 		this.modularBuilder = new ModularEditBuilder(family, fieldKinds, changeReceiver);
 	}
@@ -204,18 +203,13 @@ export class DefaultEditBuilder implements ChangeFamilyEditor, IDefaultEditBuild
 		this.modularBuilder.addNodeExistsConstraintOnRevert(path, this.mintRevisionTag());
 	}
 
-	public valueField(field: FieldUpPath): ValueFieldEditBuilder<ITreeCursorSynchronous> {
+	public valueField(field: FieldUpPath): ValueFieldEditBuilder<TreeChunk> {
 		return {
-			set: (newContent: ITreeCursorSynchronous): void => {
+			set: (newContent: TreeChunk): void => {
 				const revision = this.mintRevisionTag();
 				const fill: ChangeAtomId = { localId: this.modularBuilder.generateId(), revision };
 				const detach: ChangeAtomId = { localId: this.modularBuilder.generateId(), revision };
-				const build = this.modularBuilder.buildTrees(
-					fill.localId,
-					newContent,
-					revision,
-					this.idCompressor,
-				);
+				const build = this.modularBuilder.buildTrees(fill.localId, newContent, revision);
 				const change: FieldChangeset = brand(
 					valueFieldKind.changeHandler.editor.set({
 						fill,
@@ -235,21 +229,16 @@ export class DefaultEditBuilder implements ChangeFamilyEditor, IDefaultEditBuild
 		};
 	}
 
-	public optionalField(field: FieldUpPath): OptionalFieldEditBuilder<ITreeCursorSynchronous> {
+	public optionalField(field: FieldUpPath): OptionalFieldEditBuilder<TreeChunk> {
 		return {
-			set: (newContent: ITreeCursorSynchronous | undefined, wasEmpty: boolean): void => {
+			set: (newContent: TreeChunk | undefined, wasEmpty: boolean): void => {
 				const edits: EditDescription[] = [];
 				let optionalChange: OptionalChangeset;
 				const revision = this.mintRevisionTag();
 				const detach: ChangeAtomId = { localId: this.modularBuilder.generateId(), revision };
 				if (newContent !== undefined) {
 					const fill: ChangeAtomId = { localId: this.modularBuilder.generateId(), revision };
-					const build = this.modularBuilder.buildTrees(
-						fill.localId,
-						newContent,
-						revision,
-						this.idCompressor,
-					);
+					const build = this.modularBuilder.buildTrees(fill.localId, newContent, revision);
 					edits.push(build);
 
 					optionalChange = optional.changeHandler.editor.set(wasEmpty, {
@@ -381,23 +370,17 @@ export class DefaultEditBuilder implements ChangeFamilyEditor, IDefaultEditBuild
 		}
 	}
 
-	public sequenceField(field: FieldUpPath): SequenceFieldEditBuilder<ITreeCursorSynchronous> {
+	public sequenceField(field: FieldUpPath): SequenceFieldEditBuilder<TreeChunk> {
 		return {
-			insert: (index: number, content: ITreeCursorSynchronous): void => {
-				const length =
-					content.mode === CursorLocationType.Fields ? content.getFieldLength() : 1;
+			insert: (index: number, content: TreeChunk): void => {
+				const length = content.topLevelLength;
 				if (length === 0) {
 					return;
 				}
 
 				const revision = this.mintRevisionTag();
 				const firstId: CellId = { localId: this.modularBuilder.generateId(length), revision };
-				const build = this.modularBuilder.buildTrees(
-					firstId.localId,
-					content,
-					revision,
-					this.idCompressor,
-				);
+				const build = this.modularBuilder.buildTrees(firstId.localId, content, revision);
 				const change: FieldChangeset = brand(
 					sequence.changeHandler.editor.insert(index, length, firstId, revision),
 				);

package/src/feature-libraries/default-schema/defaultFieldKinds.ts

@@ -3,6 +3,7 @@
  * Licensed under the MIT License.
  */
 
+import { fail } from "@fluidframework/core-utils/internal";
 import {
 	type ChangeAtomId,
 	type DeltaDetachedNodeId,
@@ -10,7 +11,6 @@ import {
 	forbiddenFieldKindIdentifier,
 	Multiplicity,
 } from "../../core/index.js";
-import { fail } from "../../util/index.js";
 import {
 	type FieldChangeDelta,
 	type FieldChangeHandler,

package/src/feature-libraries/default-schema/index.ts

@@ -29,3 +29,5 @@ export {
 export { SchemaValidationErrors, isNodeInSchema, isFieldInSchema } from "./schemaChecker.js";
 
 export { defaultSchemaPolicy } from "./defaultSchema.js";
+
+export { MappedEditBuilder } from "./mappedEditBuilder.js";

package/src/feature-libraries/default-schema/mappedEditBuilder.ts

@@ -0,0 +1,68 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import type { NormalizedFieldUpPath, NormalizedUpPath } from "../../core/index.js";
+import type {
+	IDefaultEditBuilder,
+	OptionalFieldEditBuilder,
+	SequenceFieldEditBuilder,
+	ValueFieldEditBuilder,
+} from "./defaultEditBuilder.js";
+
+/**
+ * An IDefaultEditBuilder implementation based on another IDefaultEditBuilder that uses a different content type for insertions.
+ */
+export class MappedEditBuilder<TBase, TAdapted> implements IDefaultEditBuilder<TAdapted> {
+	public constructor(
+		private readonly baseBuilder: IDefaultEditBuilder<TBase>,
+		private readonly mapDelegate: (input: TAdapted) => TBase,
+	) {}
+	public valueField(field: NormalizedFieldUpPath): ValueFieldEditBuilder<TAdapted> {
+		const baseField = this.baseBuilder.valueField(field);
+		return {
+			set: (newContent: TAdapted): void => {
+				const mappedContent = this.mapDelegate(newContent);
+				baseField.set(mappedContent);
+			},
+		};
+	}
+	public optionalField(field: NormalizedFieldUpPath): OptionalFieldEditBuilder<TAdapted> {
+		const baseField = this.baseBuilder.optionalField(field);
+		return {
+			set: (newContent: TAdapted | undefined, wasEmpty: boolean): void => {
+				const mappedContent =
+					newContent === undefined ? undefined : this.mapDelegate(newContent);
+				baseField.set(mappedContent, wasEmpty);
+			},
+		};
+	}
+	public sequenceField(field: NormalizedFieldUpPath): SequenceFieldEditBuilder<TAdapted> {
+		const baseField = this.baseBuilder.sequenceField(field);
+		return {
+			insert: (index: number, content: TAdapted): void => {
+				const mappedContent = this.mapDelegate(content);
+				baseField.insert(index, mappedContent);
+			},
+			remove: (index: number, count: number): void => {
+				baseField.remove(index, count);
+			},
+		};
+	}
+	public move(
+		sourceField: NormalizedFieldUpPath,
+		sourceIndex: number,
+		count: number,
+		destinationField: NormalizedFieldUpPath,
+		destinationIndex: number,
+	): void {
+		this.baseBuilder.move(sourceField, sourceIndex, count, destinationField, destinationIndex);
+	}
+	public addNodeExistsConstraint(path: NormalizedUpPath): void {
+		this.baseBuilder.addNodeExistsConstraint(path);
+	}
+	public addNodeExistsConstraintOnRevert(path: NormalizedUpPath): void {
+		this.baseBuilder.addNodeExistsConstraintOnRevert(path);
+	}
+}

package/src/feature-libraries/default-schema/schemaChecker.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { unreachableCase } from "@fluidframework/core-utils/internal";
+import { unreachableCase, fail } from "@fluidframework/core-utils/internal";
 import {
 	type MapTree,
 	type TreeFieldStoredSchema,
@@ -14,7 +14,6 @@ import {
 	type SchemaAndPolicy,
 } from "../../core/index.js";
 import { allowsValue } from "../valueUtilities.js";
-import { fail } from "../../util/index.js";
 
 export const enum SchemaValidationErrors {
 	NoError,

package/src/feature-libraries/deltaUtils.ts

@@ -36,7 +36,7 @@ export function mapRootChanges<TIn, TOut>(
 	if (root.build !== undefined) {
 		out.build = root.build.map(({ id, trees }) => ({
 			id,
-			trees: trees.map(func),
+			trees: func(trees),
 		}));
 	}
 	if (root.global !== undefined) {

package/src/feature-libraries/flex-tree/context.ts

@@ -14,7 +14,7 @@ import {
 } from "../../core/index.js";
 import type { Listenable } from "@fluidframework/core-interfaces";
 import { type IDisposable, disposeSymbol } from "../../util/index.js";
-import type { NodeKeyManager } from "../node-key/index.js";
+import type { NodeIdentifierManager } from "../node-identifier/index.js";
 
 import type { FlexTreeField } from "./flexTreeTypes.js";
 import { type LazyEntity, prepareForEditSymbol } from "./lazyEntity.js";
@@ -56,7 +56,7 @@ export interface FlexTreeHydratedContext extends FlexTreeContext {
 	 */
 	get root(): FlexTreeField;
 
-	readonly nodeKeyManager: NodeKeyManager;
+	readonly nodeKeyManager: NodeIdentifierManager;
 
 	/**
 	 * The checkout object associated with this context.
@@ -90,7 +90,7 @@ export class Context implements FlexTreeHydratedContext, IDisposable {
 	public constructor(
 		public readonly schemaPolicy: SchemaPolicy,
 		public readonly checkout: ITreeCheckout,
-		public readonly nodeKeyManager: NodeKeyManager,
+		public readonly nodeKeyManager: NodeIdentifierManager,
 	) {
 		this.eventUnregister = [
 			this.checkout.forest.events.on("beforeChange", () => {
@@ -178,7 +178,7 @@ export class Context implements FlexTreeHydratedContext, IDisposable {
 export function getTreeContext(
 	schema: SchemaPolicy,
 	checkout: ITreeCheckout,
-	nodeKeyManager: NodeKeyManager,
+	nodeKeyManager: NodeIdentifierManager,
 ): Context {
 	return new Context(schema, checkout, nodeKeyManager);
 }

package/src/feature-libraries/flex-tree/flexTreeTypes.ts

@@ -8,8 +8,8 @@ import {
 	type ExclusiveMapTree,
 	type FieldKey,
 	type FieldKindIdentifier,
-	type FieldUpPath,
 	type ITreeCursorSynchronous,
+	type NormalizedFieldUpPath,
 	type TreeNodeSchemaIdentifier,
 	type TreeValue,
 	anchorSlot,
@@ -255,7 +255,7 @@ export interface FlexTreeField extends FlexTreeEntity {
 	/**
 	 * Gets the FieldUpPath of a field.
 	 */
-	getFieldPath(): FieldUpPath;
+	getFieldPath(): NormalizedFieldUpPath;
 
 	/**
 	 * Schema for this entity.