@fluidframework/tree 2.41.0-338401 → 2.41.0

package/src/core/rebase/utils.ts

@@ -372,8 +372,6 @@ export function rebaseChange<TChange>(
 	};
 }
 
-/**
- */
 export function revisionMetadataSourceFromInfo(
 	revInfos: readonly RevisionInfo[],
 ): RevisionMetadataSource {
@@ -440,19 +438,21 @@ function rollbackFromCommit<TChange>(
 	mintRevisionTag: () => RevisionTag,
 	cache?: boolean,
 ): TaggedChange<TChange, RevisionTag> {
-	const rollback = Rollback.get(commit);
-	if (rollback !== undefined) {
-		return rollback;
+	const cachedRollback = Rollback.get(commit);
+	if (cachedRollback !== undefined) {
+		return cachedRollback;
 	}
 	const tag = mintRevisionTag();
-	const untagged = changeRebaser.invert(commit, true, tag);
-	const deeplyTaggedRollback = changeRebaser.changeRevision(untagged, tag, commit.revision);
-	const fullyTaggedRollback = tagRollbackInverse(deeplyTaggedRollback, tag, commit.revision);
+	const rollback = tagRollbackInverse(
+		changeRebaser.invert(commit, true, tag),
+		tag,
+		commit.revision,
+	);
 
 	if (cache === true) {
-		Rollback.set(commit, fullyTaggedRollback);
+		Rollback.set(commit, rollback);
 	}
-	return fullyTaggedRollback;
+	return rollback;
 }
 
 /**

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

@@ -8,8 +8,6 @@ import { type ObjectOptions, type Static, Type } from "@sinclair/typebox";
 import { unionOptions } from "../../codec/index.js";
 import { type Brand, brandedStringType } from "../../util/index.js";
 
-export const version = 1 as const;
-
 /**
  * Key (aka Name or Label) for a field which is scoped to a specific TreeNodeStoredSchema.
  *

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

@@ -22,6 +22,7 @@ export {
 	storedSchemaDecodeDispatcher,
 	type SchemaAndPolicy,
 	type SchemaPolicy,
+	SchemaVersion,
 } from "./schema.js";
 export {
 	type TreeStoredSchemaSubscription,

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

@@ -18,6 +18,13 @@ import {
 } from "./formatV1.js";
 import type { Multiplicity } from "./multiplicity.js";
 
+/**
+ * The format version for the schema.
+ */
+export enum SchemaVersion {
+	v1 = 1,
+}
+
 /**
  * Schema for what {@link TreeLeafValue} is allowed on a Leaf node.
  * @privateRemarks

package/src/core/tree/anchorSet.ts

@@ -1075,7 +1075,8 @@ class PathNode extends ReferenceCountedBase implements AnchorNode {
 	}
 
 	/**
-	 * @returns true iff this PathNode is the special root node that sits above all the detached fields.
+	 * Whether or not this `PathNode` is the special root node that sits above all the detached fields.
+	 * @remarks
 	 * In this case, the fields are detached sequences.
 	 * Note that the special root node should never appear in an UpPath
 	 * since UpPaths represent this root as `undefined`.

package/src/core/tree/pathTree.ts

@@ -177,7 +177,8 @@ export type NodeIndex = number;
 export type PlaceIndex = number;
 
 /**
- * @returns the number of nodes above this one.
+ * Gets the number of nodes above this one.
+ * @remarks
  * Zero when the path's parent is undefined, meaning the path represents a node in a detached field.
  * Runs in O(depth) time.
  */
@@ -192,14 +193,14 @@ export function getDepth(path: UpPath): number {
 }
 
 /**
- * @returns a deep copy of the provided path as simple javascript objects.
- * This is safe to hold onto and use deep object comparisons on.
+ * Creates deep copy of the provided path as simple JavaScript object.
+ * @remarks This is safe to hold onto and use deep object comparisons on.
  */
 export function clonePath(path: UpPath): UpPath;
 
 /**
- * @returns a deep copy of the provided path as simple javascript objects.
- * This is safe to hold onto and use deep object comparisons on.
+ * Creates a deep copy of the provided path as simple JavaScript object.
+ * @remarks This is safe to hold onto and use deep object comparisons on.
  */
 export function clonePath(path: UpPath | undefined): UpPath | undefined;
 
@@ -215,8 +216,8 @@ export function clonePath(path: UpPath | undefined): UpPath | undefined {
 }
 
 /**
- * @returns The elements of the given `path`, ordered from root-most to child-most.
- * These elements are unchanged and therefore still point "up".
+ * Gets the elements of the given `path`, ordered from root-most to child-most.
+ * @remarks These elements are unchanged and therefore still point "up".
  */
 export function topDownPath(path: UpPath | undefined): UpPath[] {
 	const out: UpPath[] = [];
@@ -230,8 +231,8 @@ export function topDownPath(path: UpPath | undefined): UpPath[] {
 }
 
 /**
- * @returns true iff `a` and `b` describe the same path.
- *
+ * Returns true if and only if `a` and `b` describe the same path.
+ * @remarks
  * Note that for mutable paths (as used in `AnchorSet`), this equality may change over time: this only checks if the two paths are currently the same.
  */
 export function compareUpPaths(a: UpPath | undefined, b: UpPath | undefined): boolean {
@@ -249,8 +250,8 @@ export function compareUpPaths(a: UpPath | undefined, b: UpPath | undefined): bo
 }
 
 /**
- * @returns true iff `a` and `b` describe the same field path.
- *
+ * Returns true if and only if `a` and `b` describe the same field path.
+ * @remarks
  * Note that for mutable paths (as used in `AnchorSet`), this equality may change over time: this only checks if the two paths are currently the same.
  */
 export function compareFieldUpPaths(a: FieldUpPath, b: FieldUpPath): boolean {

package/src/core/tree/treeTextFormat.ts

@@ -140,7 +140,7 @@ export function setGenericTreeField<T>(
 }
 
 /**
- * @returns keys for fields of `tree`.
+ * Returns keys for fields of `tree`.
  */
 export function genericTreeKeys<T>(tree: GenericFieldsNode<T>): readonly FieldKey[] {
 	const fields = tree.fields;

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

@@ -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/default-schema/defaultEditBuilder.ts

@@ -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/index.ts

@@ -27,7 +27,7 @@ export {
 } from "./defaultEditBuilder.js";
 
 export {
-	SchemaValidationErrors,
+	SchemaValidationError,
 	isNodeInSchema,
 	isFieldInSchema,
 	inSchemaOrThrow,

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

@@ -4,6 +4,7 @@
  */
 
 import { unreachableCase, fail } from "@fluidframework/core-utils/internal";
+import { UsageError } from "@fluidframework/telemetry-utils/internal";
 
 import {
 	type MapTree,
@@ -15,27 +16,28 @@ import {
 	type SchemaAndPolicy,
 } from "../../core/index.js";
 import { allowsValue } from "../valueUtilities.js";
-import { UsageError } from "@fluidframework/telemetry-utils/internal";
 
-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: SchemaValidationErrors): void {
-	if (maybeError !== SchemaValidationErrors.NoError) {
-		throw new UsageError("Tree does not conform to schema.");
+export function inSchemaOrThrow(maybeError: SchemaValidationError | undefined): void {
+	if (maybeError !== undefined) {
+		throw new UsageError(
+			`Tree does not conform to schema: ${SchemaValidationError[maybeError]}`,
+		);
 	}
 }
 
@@ -45,25 +47,25 @@ export function inSchemaOrThrow(maybeError: SchemaValidationErrors): void {
 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 (node.value !== undefined) {
-			return SchemaValidationErrors.NonLeafNode_ValueNotAllowed;
+			return SchemaValidationError.NonLeafNode_ValueNotAllowed;
 		}
 
 		if (schema instanceof ObjectNodeStoredSchema) {
@@ -71,7 +73,7 @@ export function isNodeInSchema(
 			for (const [fieldKey, fieldSchema] of schema.objectNodeFields) {
 				const nodeField = node.fields.get(fieldKey) ?? [];
 				const fieldInSchemaResult = isFieldInSchema(nodeField, fieldSchema, schemaAndPolicy);
-				if (fieldInSchemaResult !== SchemaValidationErrors.NoError) {
+				if (fieldInSchemaResult !== undefined) {
 					return fieldInSchemaResult;
 				}
 				uncheckedFieldsFromNode.delete(fieldKey);
@@ -81,12 +83,12 @@ export function isNodeInSchema(
 				uncheckedFieldsFromNode.size !== 0 &&
 				!schemaAndPolicy.policy.allowUnknownOptionalFields(node.type)
 			) {
-				return SchemaValidationErrors.ObjectNode_FieldNotInSchema;
+				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 !== SchemaValidationErrors.NoError) {
+				if (fieldInSchemaResult !== undefined) {
 					return fieldInSchemaResult;
 				}
 			}
@@ -95,7 +97,7 @@ export function isNodeInSchema(
 		}
 	}
 
-	return SchemaValidationErrors.NoError;
+	return undefined;
 }
 
 /**
@@ -105,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;
 }
 
 /**
@@ -142,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
  */

package/src/feature-libraries/index.ts

@@ -22,7 +22,6 @@ export {
 	encodeTreeSchema,
 	makeSchemaCodec,
 	makeSchemaCodecs,
-	SchemaCodecVersion,
 } from "./schema-index/index.js";
 export {
 	stackTreeNodeCursor,
@@ -143,7 +142,7 @@ export {
 	fieldKindConfigurations,
 	intoDelta,
 	relevantRemovedRoots,
-	SchemaValidationErrors,
+	SchemaValidationError,
 	isNodeInSchema,
 	isFieldInSchema,
 	inSchemaOrThrow,

package/src/feature-libraries/indexing/anchorTreeIndex.ts

@@ -4,7 +4,7 @@
  */
 
 import { assert, fail } from "@fluidframework/core-utils/internal";
-import { disposeSymbol, getOrCreate } from "../../util/index.js";
+
 import {
 	type Anchor,
 	type AnchorNode,
@@ -24,9 +24,11 @@ import {
 	TreeNavigationResult,
 	type ITreeCursorSynchronous,
 } from "../../core/index.js";
-import type { TreeIndex, TreeIndexKey, TreeIndexNodes } from "./types.js";
+import { disposeSymbol, getOrCreate } from "../../util/index.js";
 import { TreeStatus } from "../flex-tree/index.js";
 
+import type { TreeIndex, TreeIndexKey, TreeIndexNodes } from "./types.js";
+
 /**
  * A function that gets the value to index a node on, must be pure and functional.
  * The given cursor should point to the node that will be indexed.

package/src/feature-libraries/modular-schema/crossFieldQueries.ts

@@ -10,6 +10,7 @@ import type {
 	RevisionTag,
 } from "../../core/index.js";
 import type { RangeQueryResult } from "../../util/index.js";
+
 import type { NodeId } from "./modularChangeTypes.js";
 
 export type CrossFieldMap<T> = ChangeAtomIdRangeMap<T>;

package/src/feature-libraries/modular-schema/fieldChangeHandler.ts

@@ -18,8 +18,8 @@ import type {
 import type { IdAllocator, Invariant } from "../../util/index.js";
 
 import type { CrossFieldManager } from "./crossFieldQueries.js";
-import type { CrossFieldKeyRange, NodeId } from "./modularChangeTypes.js";
 import type { EncodedNodeChangeset } from "./modularChangeFormat.js";
+import type { CrossFieldKeyRange, NodeId } from "./modularChangeTypes.js";
 
 export type NestedChangesIndices = [
 	NodeId,

package/src/feature-libraries/modular-schema/fieldKindWithEditor.ts

@@ -66,7 +66,7 @@ export class FieldKindWithEditor<
 	}
 
 	/**
-	 * @returns true iff `superset` permits a (non-strict) superset of the subtrees
+	 * Returns true if and only if `superset` permits a (non-strict) superset of the subtrees
 	 * allowed by field made from `this` and `originalTypes`.
 	 */
 	public allowsFieldSuperset(

package/src/feature-libraries/modular-schema/genericFieldKind.ts

@@ -3,6 +3,9 @@
  * Licensed under the MIT License.
  */
 
+import { assert } from "@fluidframework/core-utils/internal";
+import { BTree } from "@tylerbu/sorted-btree-es6";
+
 import {
 	type DeltaDetachedNodeId,
 	type DeltaMark,
@@ -10,7 +13,7 @@ import {
 	type RevisionTag,
 	replaceAtomRevisions,
 } from "../../core/index.js";
-import { assert } from "@fluidframework/core-utils/internal";
+
 import type {
 	FieldChangeDelta,
 	FieldChangeHandler,
@@ -25,7 +28,6 @@ import { FieldKindWithEditor } from "./fieldKindWithEditor.js";
 import { makeGenericChangeCodec } from "./genericFieldKindCodecs.js";
 import { newGenericChangeset, type GenericChangeset } from "./genericFieldKindTypes.js";
 import type { NodeId } from "./modularChangeTypes.js";
-import { BTree } from "@tylerbu/sorted-btree-es6";
 
 /**
  * {@link FieldChangeHandler} implementation for {@link GenericChangeset}.

package/src/feature-libraries/modular-schema/genericFieldKindCodecs.ts

@@ -4,6 +4,7 @@
  */
 
 import { type ICodecFamily, type IJsonCodec, makeCodecFamily } from "../../codec/index.js";
+
 import type { FieldChangeEncodingContext } from "./fieldChangeHandler.js";
 import { EncodedGenericChangeset } from "./genericFieldKindFormat.js";
 import { newGenericChangeset, type GenericChangeset } from "./genericFieldKindTypes.js";

package/src/feature-libraries/modular-schema/genericFieldKindTypes.ts

@@ -4,6 +4,7 @@
  */
 
 import { BTree } from "@tylerbu/sorted-btree-es6";
+
 import type { NodeId } from "./modularChangeTypes.js";
 
 /**

package/src/feature-libraries/modular-schema/isNeverTree.ts

@@ -17,8 +17,6 @@ import {
 
 import type { FullSchemaPolicy } from "./fieldKind.js";
 
-/**
- */
 export function isNeverField(
 	policy: FullSchemaPolicy,
 	originalData: TreeStoredSchema,

package/src/feature-libraries/modular-schema/modularChangeCodecs.ts

@@ -41,6 +41,7 @@ import {
 } from "../chunked-forest/index.js";
 import { TreeCompressionStrategy } from "../treeCompressionUtils.js";
 
+import type { FieldChangeEncodingContext, FieldChangeHandler } from "./fieldChangeHandler.js";
 import type {
 	FieldKindConfiguration,
 	FieldKindConfigurationEntry,
@@ -65,7 +66,6 @@ import {
 	type NodeChangeset,
 	type NodeId,
 } from "./modularChangeTypes.js";
-import type { FieldChangeEncodingContext, FieldChangeHandler } from "./fieldChangeHandler.js";
 
 export function makeModularChangeCodecFamily(
 	fieldKindConfigurations: ReadonlyMap<number, FieldKindConfiguration>,

package/src/feature-libraries/modular-schema/modularChangeFamily.ts

@@ -2651,6 +2651,8 @@ export class ModularEditBuilder extends EditBuilder<ModularChangeset> {
 	}
 
 	/**
+	 * Builds a new tree to use in an edit.
+	 *
 	 * @param firstId - The ID to associate with the first node
 	 * @param content - The node(s) to build.
 	 * @param revision - The revision to use for the build.