@fluidframework/tree 2.41.0-338186 → 2.41.0

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

@@ -3,9 +3,10 @@
  * Licensed under the MIT License.
  */
 
-import { assert, oob, fail } from "@fluidframework/core-utils/internal";
-import type { Listenable } from "@fluidframework/core-interfaces";
 import { createEmitter } from "@fluid-internal/client-utils";
+import type { Listenable } from "@fluidframework/core-interfaces";
+import { assert, oob, fail } from "@fluidframework/core-utils/internal";
+import type { IIdCompressor } from "@fluidframework/id-compressor";
 
 import {
 	type Anchor,
@@ -44,7 +45,6 @@ import {
 
 import { BasicChunk, BasicChunkCursor, type SiblingsOrKey } from "./basicChunk.js";
 import { type IChunker, basicChunkTree, chunkFieldSingle, chunkTree } from "./chunkTree.js";
-import type { IIdCompressor } from "@fluidframework/id-compressor";
 
 function makeRoot(): BasicChunk {
 	return new BasicChunk(aboveRootPlaceholder, new Map());
@@ -468,7 +468,7 @@ class Cursor extends BasicChunkCursor implements ITreeSubscriptionCursor {
 }
 
 /**
- * @returns an implementation of {@link IEditableForest} with no data or schema.
+ * Creates an implementation of {@link IEditableForest} with no data or schema.
  */
 export function buildChunkedForest(
 	chunker: IChunker,

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

@@ -4,6 +4,11 @@
  */
 
 import { assert, unreachableCase, oob } from "@fluidframework/core-utils/internal";
+import type {
+	IIdCompressor,
+	OpSpaceCompressedId,
+	SessionId,
+} from "@fluidframework/id-compressor";
 
 import { DiscriminatedUnionDispatcher } from "../../../codec/index.js";
 import type {
@@ -42,11 +47,6 @@ import {
 	type EncodedValueShape,
 	SpecialField,
 } from "./format.js";
-import type {
-	IIdCompressor,
-	OpSpaceCompressedId,
-	SessionId,
-} from "@fluidframework/id-compressor";
 
 export interface IdDecodingContext {
 	idCompressor: IIdCompressor;

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

@@ -6,8 +6,8 @@
 import { assert } from "@fluidframework/core-utils/internal";
 
 import type { DiscriminatedUnionDispatcher } from "../../../codec/index.js";
-import type { BrandedType } from "../../../util/index.js";
 import type { TreeChunk } from "../../../core/index.js";
+import type { BrandedType } from "../../../util/index.js";
 
 import {
 	type ChunkDecoder,
@@ -15,8 +15,8 @@ import {
 	getChecked,
 	readStream,
 } from "./chunkCodecUtilities.js";
-import type { EncodedFieldBatchGeneric, IdentifierOrIndex } from "./formatGeneric.js";
 import type { IdDecodingContext } from "./chunkDecoding.js";
+import type { EncodedFieldBatchGeneric, IdentifierOrIndex } from "./formatGeneric.js";
 
 /**
  * General purpose shape based tree decoder which gets its support for specific shapes from the caller.

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

@@ -4,6 +4,7 @@
  */
 
 import { fail } from "@fluidframework/core-utils/internal";
+
 import type { TreeValue } from "../../../core/index.js";
 import type { FluidSerializableReadOnly } from "../../valueUtilities.js";
 

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

@@ -4,8 +4,10 @@
  */
 
 import { assert, unreachableCase } from "@fluidframework/core-utils/internal";
+import type { IIdCompressor, SessionId } from "@fluidframework/id-compressor";
 
 import {
+	type FluidClientVersion,
 	type ICodecOptions,
 	type IJsonCodec,
 	makeVersionedValidatedCodec,
@@ -19,7 +21,6 @@ import type { FieldBatch } from "./fieldBatch.js";
 import { EncodedFieldBatch, validVersions } from "./format.js";
 import { schemaCompressedEncode } from "./schemaBasedEncode.js";
 import { uncompressedEncode } from "./uncompressedEncode.js";
-import type { IIdCompressor, SessionId } from "@fluidframework/id-compressor";
 
 export interface FieldBatchEncodingContext {
 	readonly encodeType: TreeCompressionStrategy;
@@ -38,6 +39,18 @@ export type FieldBatchCodec = IJsonCodec<
 	FieldBatchEncodingContext
 >;
 
+/**
+ * Get the write version for {@link makeFieldBatchCodec} based on the `oldestCompatibleClient` version.
+ * @privateRemarks
+ * TODO: makeFieldBatchCodec (and makeVersionDispatchingCodec transitively) should bake in this versionToFormat logic and the resulting codec can then support use with FluidClientVersion directly.
+ */
+export function fluidVersionToFieldBatchCodecWriteVersion(
+	oldestCompatibleClient: FluidClientVersion,
+): number {
+	// There is currently on only 1 version.
+	return 1;
+}
+
 export function makeFieldBatchCodec(
 	options: ICodecOptions,
 	writeVersion: number,
@@ -51,6 +64,7 @@ export function makeFieldBatchCodec(
 		0x935 /* Invalid write version for FieldBatch codec */,
 	);
 
+	// TODO: use makeVersionDispatchingCodec to support adding more versions in the future.
 	return makeVersionedValidatedCodec(options, validVersions, EncodedFieldBatch, {
 		encode: (data: FieldBatch, context: FieldBatchEncodingContext): EncodedFieldBatch => {
 			for (const cursor of data) {

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

@@ -4,6 +4,7 @@
  */
 
 import { assert, unreachableCase, fail } from "@fluidframework/core-utils/internal";
+import type { IIdCompressor } from "@fluidframework/id-compressor";
 
 import {
 	CursorLocationType,
@@ -34,7 +35,6 @@ import {
 	SpecialField,
 	version,
 } from "./format.js";
-import type { IIdCompressor } from "@fluidframework/id-compressor";
 
 /**
  * Encode data from `FieldBatch` into an `EncodedChunk`.

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

@@ -9,4 +9,5 @@ export {
 	type FieldBatchCodec,
 	makeFieldBatchCodec,
 	type FieldBatchEncodingContext,
+	fluidVersionToFieldBatchCodecWriteVersion,
 } from "./codecs.js";

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

@@ -4,6 +4,7 @@
  */
 
 import { assert, fail } from "@fluidframework/core-utils/internal";
+import { isStableId } from "@fluidframework/id-compressor/internal";
 
 import {
 	type FieldKey,
@@ -24,7 +25,6 @@ import {
 	encodeValue,
 } from "./compressedEncode.js";
 import type { EncodedChunkShape, EncodedFieldShape, EncodedValueShape } from "./format.js";
-import { isStableId } from "@fluidframework/id-compressor/internal";
 
 export class NodeShape extends Shape<EncodedChunkShape> implements NodeEncoder {
 	/**

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

@@ -4,6 +4,7 @@
  */
 
 import { assert, unreachableCase, fail } from "@fluidframework/core-utils/internal";
+import type { IIdCompressor } from "@fluidframework/id-compressor";
 
 import {
 	LeafNodeStoredSchema,
@@ -31,7 +32,6 @@ import {
 import type { FieldBatch } from "./fieldBatch.js";
 import { type EncodedFieldBatch, type EncodedValueShape, SpecialField } from "./format.js";
 import { NodeShape } from "./nodeShape.js";
-import type { IIdCompressor } from "@fluidframework/id-compressor";
 
 /**
  * Encode data from `fieldBatch` in into an `EncodedChunk`.

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

@@ -4,6 +4,7 @@
  */
 
 import { fail } from "@fluidframework/core-utils/internal";
+
 import {
 	CursorLocationType,
 	CursorMarker,

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

@@ -20,4 +20,5 @@ export {
 	type FieldBatchCodec,
 	makeFieldBatchCodec,
 	type FieldBatchEncodingContext,
+	fluidVersionToFieldBatchCodecWriteVersion,
 } from "./codec/index.js";

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

@@ -3,10 +3,10 @@
  * Licensed under the MIT License.
  */
 
+import { type ChunkedCursor, type TreeChunk, dummyRoot } from "../../core/index.js";
 import { ReferenceCountedBase } from "../../util/index.js";
 
 import { BasicChunkCursor } from "./basicChunk.js";
-import { type ChunkedCursor, type TreeChunk, dummyRoot } from "../../core/index.js";
 
 /**
  * General purpose multi-node sequence chunk.

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

@@ -4,6 +4,8 @@
  */
 
 import { assert, compareArrays, oob, fail } from "@fluidframework/core-utils/internal";
+import type { SessionSpaceCompressedId, IIdCompressor } from "@fluidframework/id-compressor";
+import { UsageError } from "@fluidframework/telemetry-utils/internal";
 
 import {
 	CursorLocationType,
@@ -22,9 +24,6 @@ import {
 import { ReferenceCountedBase, hasSome } from "../../util/index.js";
 import { SynchronousCursor, prefixFieldPath, prefixPath } from "../treeCursorUtils.js";
 
-import type { SessionSpaceCompressedId, IIdCompressor } from "@fluidframework/id-compressor";
-import { UsageError } from "@fluidframework/telemetry-utils/internal";
-
 /**
  * Create a tree chunk with ref count 1.
  *

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

@@ -37,6 +37,7 @@ import {
 	relevantRemovedRoots as relevantModularRemovedRoots,
 } from "../modular-schema/index.js";
 import type { OptionalChangeset } from "../optional-field/index.js";
+import type { CellId } from "../sequence-field/index.js";
 
 import {
 	fieldKinds,
@@ -44,7 +45,6 @@ import {
 	sequence,
 	required as valueFieldKind,
 } from "./defaultFieldKinds.js";
-import type { CellId } from "../sequence-field/index.js";
 
 export type DefaultChangeset = ModularChangeset;
 
@@ -452,7 +452,7 @@ export interface SequenceFieldEditBuilder<TContent> {
 }
 
 /**
- * @returns The number of path elements that both paths share, starting at index 0.
+ * Gets the number of path elements that both paths share, starting at index 0.
  */
 function getSharedPrefixLength(pathA: readonly UpPath[], pathB: readonly UpPath[]): number {
 	const minDepth = Math.min(pathA.length, pathB.length);

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

@@ -4,6 +4,7 @@
  */
 
 import { fail } from "@fluidframework/core-utils/internal";
+
 import {
 	type ChangeAtomId,
 	type DeltaDetachedNodeId,

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

@@ -26,7 +26,12 @@ export {
 	relevantRemovedRoots,
 } from "./defaultEditBuilder.js";
 
-export { SchemaValidationErrors, isNodeInSchema, isFieldInSchema } from "./schemaChecker.js";
+export {
+	SchemaValidationError,
+	isNodeInSchema,
+	isFieldInSchema,
+	inSchemaOrThrow,
+} from "./schemaChecker.js";
 
 export { defaultSchemaPolicy } from "./defaultSchema.js";
 

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

@@ -4,6 +4,7 @@
  */
 
 import type { NormalizedFieldUpPath, NormalizedUpPath } from "../../core/index.js";
+
 import type {
 	IDefaultEditBuilder,
 	OptionalFieldEditBuilder,

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

@@ -4,6 +4,8 @@
  */
 
 import { unreachableCase, fail } from "@fluidframework/core-utils/internal";
+import { UsageError } from "@fluidframework/telemetry-utils/internal";
+
 import {
 	type MapTree,
 	type TreeFieldStoredSchema,
@@ -15,17 +17,28 @@ import {
 } from "../../core/index.js";
 import { allowsValue } from "../valueUtilities.js";
 
-export const enum SchemaValidationErrors {
-	NoError,
+export enum SchemaValidationError {
 	Field_KindNotInSchemaPolicy,
-	Field_IncorrectMultiplicity,
+	Field_MissingRequiredChild,
+	Field_MultipleChildrenNotAllowed,
+	Field_ChildInForbiddenField,
 	Field_NodeTypeNotAllowed,
 	LeafNode_InvalidValue,
 	LeafNode_FieldsNotAllowed,
 	ObjectNode_FieldNotInSchema,
 	NonLeafNode_ValueNotAllowed,
 	Node_MissingSchema,
-	UnknownError,
+}
+
+/**
+ * Throws a UsageError if maybeError indicates a tree is out of schema.
+ */
+export function inSchemaOrThrow(maybeError: SchemaValidationError | undefined): void {
+	if (maybeError !== undefined) {
+		throw new UsageError(
+			`Tree does not conform to schema: ${SchemaValidationError[maybeError]}`,
+		);
+	}
 }
 
 /**
@@ -34,57 +47,57 @@ export const enum SchemaValidationErrors {
 export function isNodeInSchema(
 	node: MapTree,
 	schemaAndPolicy: SchemaAndPolicy,
-): SchemaValidationErrors {
+): SchemaValidationError | undefined {
 	// Validate the schema declared by the node exists
 	const schema = schemaAndPolicy.schema.nodeSchema.get(node.type);
 	if (schema === undefined) {
-		return SchemaValidationErrors.Node_MissingSchema;
+		return SchemaValidationError.Node_MissingSchema;
 	}
 
 	// Validate the node is well formed according to its schema
 
 	if (schema instanceof LeafNodeStoredSchema) {
 		if (node.fields.size !== 0) {
-			return SchemaValidationErrors.LeafNode_FieldsNotAllowed;
+			return SchemaValidationError.LeafNode_FieldsNotAllowed;
 		}
 		if (!allowsValue(schema.leafValue, node.value)) {
-			return SchemaValidationErrors.LeafNode_InvalidValue;
+			return SchemaValidationError.LeafNode_InvalidValue;
 		}
-	} else if (schema instanceof ObjectNodeStoredSchema) {
+	} else {
 		if (node.value !== undefined) {
-			return SchemaValidationErrors.NonLeafNode_ValueNotAllowed;
+			return SchemaValidationError.NonLeafNode_ValueNotAllowed;
 		}
-		const uncheckedFieldsFromNode = new Set(node.fields.keys());
-		for (const [fieldKey, fieldSchema] of schema.objectNodeFields) {
-			const nodeField = node.fields.get(fieldKey) ?? [];
-			const fieldInSchemaResult = isFieldInSchema(nodeField, fieldSchema, schemaAndPolicy);
-			if (fieldInSchemaResult !== SchemaValidationErrors.NoError) {
-				return fieldInSchemaResult;
+
+		if (schema instanceof ObjectNodeStoredSchema) {
+			const uncheckedFieldsFromNode = new Set(node.fields.keys());
+			for (const [fieldKey, fieldSchema] of schema.objectNodeFields) {
+				const nodeField = node.fields.get(fieldKey) ?? [];
+				const fieldInSchemaResult = isFieldInSchema(nodeField, fieldSchema, schemaAndPolicy);
+				if (fieldInSchemaResult !== undefined) {
+					return fieldInSchemaResult;
+				}
+				uncheckedFieldsFromNode.delete(fieldKey);
 			}
-			uncheckedFieldsFromNode.delete(fieldKey);
-		}
-		// The node has fields that we did not check as part of looking at every field defined in the node's schema
-		if (
-			uncheckedFieldsFromNode.size !== 0 &&
-			!schemaAndPolicy.policy.allowUnknownOptionalFields(node.type)
-		) {
-			return SchemaValidationErrors.ObjectNode_FieldNotInSchema;
-		}
-	} else if (schema instanceof MapNodeStoredSchema) {
-		if (node.value !== undefined) {
-			return SchemaValidationErrors.NonLeafNode_ValueNotAllowed;
-		}
-		for (const field of node.fields.values()) {
-			const fieldInSchemaResult = isFieldInSchema(field, schema.mapFields, schemaAndPolicy);
-			if (fieldInSchemaResult !== SchemaValidationErrors.NoError) {
-				return fieldInSchemaResult;
+			// The node has fields that we did not check as part of looking at every field defined in the node's schema
+			if (
+				uncheckedFieldsFromNode.size !== 0 &&
+				!schemaAndPolicy.policy.allowUnknownOptionalFields(node.type)
+			) {
+				return SchemaValidationError.ObjectNode_FieldNotInSchema;
 			}
+		} else if (schema instanceof MapNodeStoredSchema) {
+			for (const field of node.fields.values()) {
+				const fieldInSchemaResult = isFieldInSchema(field, schema.mapFields, schemaAndPolicy);
+				if (fieldInSchemaResult !== undefined) {
+					return fieldInSchemaResult;
+				}
+			}
+		} else {
+			fail(0xb0e /* Unknown TreeNodeStoredSchema type */);
 		}
-	} else {
-		fail(0xb0e /* Unknown TreeNodeStoredSchema type */);
 	}
 
-	return SchemaValidationErrors.NoError;
+	return undefined;
 }
 
 /**
@@ -94,32 +107,35 @@ export function isFieldInSchema(
 	childNodes: readonly MapTree[],
 	schema: TreeFieldStoredSchema,
 	schemaAndPolicy: SchemaAndPolicy,
-): SchemaValidationErrors {
+): SchemaValidationError | undefined {
 	// Validate that the field kind is handled by the schema policy
 	const kind = schemaAndPolicy.policy.fieldKinds.get(schema.kind);
 	if (kind === undefined) {
-		return SchemaValidationErrors.Field_KindNotInSchemaPolicy;
+		return SchemaValidationError.Field_KindNotInSchemaPolicy;
 	}
 
 	// Validate that the field doesn't contain more nodes than its type supports
-	if (!compliesWithMultiplicity(childNodes.length, kind.multiplicity)) {
-		return SchemaValidationErrors.Field_IncorrectMultiplicity;
+	{
+		const multiplicityCheck = compliesWithMultiplicity(childNodes.length, kind.multiplicity);
+		if (multiplicityCheck !== undefined) {
+			return multiplicityCheck;
+		}
 	}
 
 	for (const node of childNodes) {
 		// Validate the type declared by the node is allowed in this field
 		if (schema.types !== undefined && !schema.types.has(node.type)) {
-			return SchemaValidationErrors.Field_NodeTypeNotAllowed;
+			return SchemaValidationError.Field_NodeTypeNotAllowed;
 		}
 
 		// Validate the node complies with the type it declares to be.
 		const nodeInSchemaResult = isNodeInSchema(node, schemaAndPolicy);
-		if (nodeInSchemaResult !== SchemaValidationErrors.NoError) {
+		if (nodeInSchemaResult !== undefined) {
 			return nodeInSchemaResult;
 		}
 	}
 
-	return SchemaValidationErrors.NoError;
+	return undefined;
 }
 
 /**
@@ -131,16 +147,26 @@ export function isFieldInSchema(
 export function compliesWithMultiplicity(
 	numberOfItems: number,
 	multiplicity: Multiplicity,
-): boolean {
+): SchemaValidationError | undefined {
 	switch (multiplicity) {
 		case Multiplicity.Single:
-			return numberOfItems === 1;
+			if (numberOfItems < 1) {
+				return SchemaValidationError.Field_MissingRequiredChild;
+			} else if (numberOfItems > 1) {
+				return SchemaValidationError.Field_MultipleChildrenNotAllowed;
+			} else {
+				return undefined;
+			}
 		case Multiplicity.Optional:
-			return numberOfItems <= 1;
+			return numberOfItems > 1
+				? SchemaValidationError.Field_MultipleChildrenNotAllowed
+				: undefined;
 		case Multiplicity.Sequence:
-			return true;
+			return undefined;
 		case Multiplicity.Forbidden:
-			return numberOfItems === 0;
+			return numberOfItems === 0
+				? undefined
+				: SchemaValidationError.Field_ChildInForbiddenField;
 		default:
 			unreachableCase(multiplicity);
 	}

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

@@ -3,23 +3,26 @@
  * Licensed under the MIT License.
  */
 
+import type { Listenable } from "@fluidframework/core-interfaces";
 import { assert, debugAssert } from "@fluidframework/core-utils/internal";
 
 import {
+	type DetachedField,
+	type FieldKindIdentifier,
 	type ForestEvents,
 	type SchemaPolicy,
 	type TreeStoredSchema,
 	anchorSlot,
 	moveToDetachedField,
+	rootField,
 } from "../../core/index.js";
-import type { Listenable } from "@fluidframework/core-interfaces";
+import type { ITreeCheckout } from "../../shared-tree/index.js";
 import { type IDisposable, disposeSymbol } from "../../util/index.js";
 import type { NodeIdentifierManager } from "../node-identifier/index.js";
 
 import type { FlexTreeField } from "./flexTreeTypes.js";
 import type { LazyEntity } from "./lazyEntity.js";
 import { makeField } from "./lazyField.js";
-import type { ITreeCheckout } from "../../shared-tree/index.js";
 
 /**
  * Context for FlexTrees.
@@ -82,6 +85,8 @@ export const ContextSlot = anchorSlot<Context>();
  *
  * A {@link FlexTreeContext} which is used to manage the cursors and anchors within the FlexTrees:
  * This is necessary for supporting using this tree across edits to the forest, and not leaking memory.
+ *
+ * This context and the trees it produces observe the kinds of fields from the schema
  */
 export class Context implements FlexTreeHydratedContext, IDisposable {
 	public readonly withCursors: Set<LazyEntity> = new Set();
@@ -159,6 +164,7 @@ export class Context implements FlexTreeHydratedContext, IDisposable {
 
 	/**
 	 * Release any cursors and anchors held by tree entities created in this context.
+	 * @remarks
 	 * Ensures the cashed references to those entities on the Anchors are also cleared.
 	 * The tree entities are invalid to use after this, but the context may still be used
 	 * to create new trees starting from the root.
@@ -172,17 +178,32 @@ export class Context implements FlexTreeHydratedContext, IDisposable {
 		assert(this.withAnchors.size === 0, 0x775 /* free should remove all anchors */);
 	}
 
+	/**
+	 * Gets the root field of the tree.
+	 * @remarks
+	 * This is a cached value: it should not be disposed by the accessor.
+	 * Like all other fields from this context, it will become invalid to use after {@link clear} is called or the {@link disposeSymbol} method is called.
+	 */
 	public get root(): FlexTreeField {
 		assert(this.disposed === false, 0x804 /* use after dispose */);
-		if (this.lazyRootCache !== undefined) {
-			return this.lazyRootCache;
-		}
+
+		this.lazyRootCache ??= this.detachedField(rootField, this.schema.rootFieldSchema.kind);
+		return this.lazyRootCache;
+	}
+
+	/**
+	 * Returns a new {@link FlexTreeField} that will live as long as the caller allows up to the next call to {@link clear} or disposal of the context.
+	 * @remarks
+	 * Due to limited support for detached fields, not all operations are supported.
+	 * Additionally if the detached field's content is deleted, the field will become out of schema if it is required: it must not be used after that point.
+	 */
+	public detachedField(key: DetachedField, schema: FieldKindIdentifier): FlexTreeField {
+		assert(this.disposed === false, 0xb9c /* use after dispose */);
 
 		const cursor = this.checkout.forest.allocateCursor("root");
-		moveToDetachedField(this.checkout.forest, cursor);
-		const field = makeField(this, this.schema.rootFieldSchema.kind, cursor);
+		moveToDetachedField(this.checkout.forest, cursor, key);
+		const field = makeField(this, schema, cursor);
 		cursor.free();
-		this.lazyRootCache = field;
 		return field;
 	}
 

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

@@ -119,8 +119,9 @@ export enum TreeStatus {
 	 *
 	 * - Transactions do not work: transactions apply to a single {@link TreeView}, and `New` nodes are not part of one.
 	 *
-	 * - `Tree.shortId` (when the identifier was explicitly specified and thus works at all) will just return the full identifier as a string,
-	 * but might return a compressed form as a number once hydrated.
+	 * - Automatically generated {@link SchemaFactory.identifier | identifiers} will be less compressible if read.
+	 *
+	 * - {@link TreeIdentifierUtils.getShort} and {@link TreeNodeApi.shortId | Tree.shortId} cannot return their short identifiers.
 	 */
 	New = 3,
 }

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

@@ -30,6 +30,7 @@ import {
 	type SequenceFieldEditBuilder,
 	type ValueFieldEditBuilder,
 } from "../default-schema/index.js";
+import { cursorForMapTreeField } from "../mapTreeCursor.js";
 import type { FlexFieldKind } from "../modular-schema/index.js";
 
 import type { Context } from "./context.js";
@@ -49,7 +50,6 @@ import {
 import { LazyEntity } from "./lazyEntity.js";
 import { type LazyTreeNode, makeTree } from "./lazyNode.js";
 import { indexForAt, treeStatusFromAnchorCache } from "./utilities.js";
-import { cursorForMapTreeField } from "../mapTreeCursor.js";
 
 /**
  * Reuse fields.

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

@@ -11,8 +11,8 @@ import {
 	rootField,
 	type SchemaAndPolicy,
 } from "../../core/index.js";
-import type { FlexTreeContext } from "./context.js";
 
+import type { FlexTreeContext } from "./context.js";
 import { TreeStatus } from "./flexTreeTypes.js";
 /**
  * Checks the detached field and returns the TreeStatus based on whether or not the detached field is a root field.

package/src/feature-libraries/forest-summary/forestSummarizer.ts

@@ -6,6 +6,7 @@
 import { bufferToString } from "@fluid-internal/client-utils";
 import { assert } from "@fluidframework/core-utils/internal";
 import type { IChannelStorageService } from "@fluidframework/datastore-definitions/internal";
+import type { IIdCompressor } from "@fluidframework/id-compressor";
 import type {
 	ISummaryTreeWithStats,
 	ITelemetryContext,
@@ -38,7 +39,6 @@ import type { FieldBatchCodec, FieldBatchEncodingContext } from "../chunked-fore
 
 import { type ForestCodec, makeForestSummarizerCodec } from "./codec.js";
 import type { Format } from "./format.js";
-import type { IIdCompressor } from "@fluidframework/id-compressor";
 /**
  * The storage key for the blob in the summary containing tree data
  */