@fluidframework/tree 2.1.1 → 2.2.1

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

@@ -8,7 +8,6 @@ export {
 	type FlexTreeNode,
 	type FlexTreeEntity,
 	type FlexTreeTypedField,
-	type FlexTreeFieldNode,
 	type FlexibleFieldContent,
 	type FlexibleNodeContent,
 	type FlexTreeLeafNode,

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

@@ -7,6 +7,7 @@ import { assert } from "@fluidframework/core-utils/internal";
 
 import {
 	CursorLocationType,
+	type ExclusiveMapTree,
 	type FieldAnchor,
 	type FieldKey,
 	type FieldUpPath,
@@ -14,26 +15,16 @@ import {
 	type ITreeSubscriptionCursor,
 	type TreeNavigationResult,
 	inCursorNode,
-	isCursor,
 	iterateCursorField,
 	rootFieldKey,
 } from "../../core/index.js";
-import {
-	assertValidIndex,
-	assertValidRangeIndices,
-	disposeSymbol,
-	fail,
-	getOrCreate,
-} from "../../util/index.js";
-// TODO: stop depending on contextuallyTyped
-import { applyTypesFromContext, cursorFromContextualData } from "../contextuallyTyped.js";
+import { disposeSymbol, fail, getOrCreate } from "../../util/index.js";
 import {
 	FieldKinds,
 	type OptionalFieldEditBuilder,
 	type SequenceFieldEditBuilder,
 	type ValueFieldEditBuilder,
 } from "../default-schema/index.js";
-import { cursorForMapTreeField } from "../mapTreeCursor.js";
 import type { FlexFieldKind } from "../modular-schema/index.js";
 import type { FlexAllowedTypes, FlexFieldSchema } from "../typed-schema/index.js";
 
@@ -48,8 +39,6 @@ import {
 	type FlexTreeTypedField,
 	type FlexTreeTypedNodeUnion,
 	type FlexTreeUnboxNodeUnion,
-	type FlexibleNodeContent,
-	type FlexibleNodeSubSequence,
 	TreeStatus,
 	flexTreeMarker,
 	flexTreeSlot,
@@ -66,6 +55,7 @@ import { type LazyTreeNode, makeTree } from "./lazyNode.js";
 import { unboxedUnion } from "./unboxed.js";
 import { indexForAt, treeStatusFromAnchorCache } from "./utilities.js";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
+import { cursorForMapTreeField, cursorForMapTreeNode } from "../mapTreeCursor.js";
 
 /**
  * Reuse fields.
@@ -133,8 +123,7 @@ export function makeField(
 }
 
 /**
- * A Proxy target, which together with a `fieldProxyHandler` implements a basic access to
- * the nodes of {@link EditableField} by means of the cursors.
+ * Base type for fields implementing {@link FlexTreeField} using cursors.
  */
 export abstract class LazyField<
 		out TKind extends FlexFieldKind,
@@ -308,150 +297,18 @@ export class LazySequence<TTypes extends FlexAllowedTypes>
 		return this.map((x) => x);
 	}
 
-	public sequenceEditor(): SequenceFieldEditBuilder {
-		const fieldPath = this.getFieldPathForEditing();
-		const fieldEditor = this.context.checkout.editor.sequenceField(fieldPath);
-		return fieldEditor;
-	}
-
-	public insertAt(index: number, value: FlexibleNodeSubSequence<TTypes>): void {
-		assertValidIndex(index, this, true);
-		const content: ITreeCursorSynchronous = isCursor(value)
-			? prepareFieldCursorForInsert(value)
-			: cursorForMapTreeField(
-					Array.from(value, (item) =>
-						applyTypesFromContext(this.context, this.schema.allowedTypeSet, item),
-					),
-				);
-
-		const fieldEditor = this.sequenceEditor();
-		fieldEditor.insert(index, content);
-	}
-
-	public insertAtStart(value: FlexibleNodeSubSequence<TTypes>): void {
-		this.insertAt(0, value);
-	}
-
-	public insertAtEnd(value: FlexibleNodeSubSequence<TTypes>): void {
-		this.insertAt(this.length, value);
-	}
-
-	public removeAt(index: number): void {
-		const fieldEditor = this.sequenceEditor();
-		fieldEditor.remove(index, 1);
-	}
-
-	public moveToStart(sourceIndex: number): void;
-	public moveToStart(
-		sourceIndex: number,
-		source: FlexTreeSequenceField<FlexAllowedTypes>,
-	): void;
-	public moveToStart(
-		sourceIndex: number,
-		source?: FlexTreeSequenceField<FlexAllowedTypes>,
-	): void {
-		this._moveRangeToIndex(0, sourceIndex, sourceIndex + 1, source);
-	}
-	public moveToEnd(sourceIndex: number): void;
-	public moveToEnd(sourceIndex: number, source: FlexTreeSequenceField<FlexAllowedTypes>): void;
-	public moveToEnd(
-		sourceIndex: number,
-		source?: FlexTreeSequenceField<FlexAllowedTypes>,
-	): void {
-		this._moveRangeToIndex(this.length, sourceIndex, sourceIndex + 1, source);
-	}
-	public moveToIndex(index: number, sourceIndex: number): void;
-	public moveToIndex(
-		index: number,
-		sourceIndex: number,
-		source: FlexTreeSequenceField<FlexAllowedTypes>,
-	): void;
-	public moveToIndex(
-		index: number,
-		sourceIndex: number,
-		source?: FlexTreeSequenceField<FlexAllowedTypes>,
-	): void {
-		this._moveRangeToIndex(index, sourceIndex, sourceIndex + 1, source);
-	}
-
-	public moveRangeToStart(sourceStart: number, sourceEnd: number): void;
-	public moveRangeToStart(
-		sourceStart: number,
-		sourceEnd: number,
-		source: FlexTreeSequenceField<FlexAllowedTypes>,
-	): void;
-	public moveRangeToStart(
-		sourceStart: number,
-		sourceEnd: number,
-		source?: FlexTreeSequenceField<FlexAllowedTypes>,
-	): void {
-		this._moveRangeToIndex(0, sourceStart, sourceEnd, source);
-	}
-
-	public moveRangeToEnd(sourceStart: number, sourceEnd: number): void;
-	public moveRangeToEnd(
-		sourceStart: number,
-		sourceEnd: number,
-		source: FlexTreeSequenceField<FlexAllowedTypes>,
-	): void;
-	public moveRangeToEnd(
-		sourceStart: number,
-		sourceEnd: number,
-		source?: FlexTreeSequenceField<FlexAllowedTypes>,
-	): void {
-		this._moveRangeToIndex(this.length, sourceStart, sourceEnd, source);
-	}
-
-	public moveRangeToIndex(index: number, sourceStart: number, sourceEnd: number): void;
-	public moveRangeToIndex(
-		index: number,
-		sourceStart: number,
-		sourceEnd: number,
-		source: FlexTreeSequenceField<FlexAllowedTypes>,
-	): void;
-	public moveRangeToIndex(
-		index: number,
-		sourceStart: number,
-		sourceEnd: number,
-		source?: FlexTreeSequenceField<FlexAllowedTypes>,
-	): void {
-		this._moveRangeToIndex(index, sourceStart, sourceEnd, source);
-	}
-
-	private _moveRangeToIndex(
-		index: number,
-		sourceStart: number,
-		sourceEnd: number,
-		source?: FlexTreeSequenceField<FlexAllowedTypes>,
-	): void {
-		const sourceField = source ?? this;
+	public editor: SequenceFieldEditBuilder<ExclusiveMapTree[]> = {
+		insert: (index, newContent) => {
+			this.sequenceEditor().insert(index, cursorForMapTreeField(newContent));
+		},
+		remove: (index, count) => {
+			this.sequenceEditor().remove(index, count);
+		},
+	};
 
-		// TODO: determine support for move across different sequence types
-		assert(
-			sourceField instanceof LazySequence,
-			0x7b1 /* Unsupported sequence implementation. */,
-		);
-		assertValidRangeIndices(sourceStart, sourceEnd, sourceField);
-		if (this.schema.types !== undefined && sourceField !== this) {
-			for (let i = sourceStart; i < sourceEnd; i++) {
-				const sourceNode =
-					sourceField.boxedAt(sourceStart) ?? fail("impossible out of bounds index");
-				if (!this.schema.types.has(sourceNode.schema.name)) {
-					throw new Error("Type in source sequence is not allowed in destination.");
-				}
-			}
-		}
-		const movedCount = sourceEnd - sourceStart;
-		assertValidIndex(index, this, true);
-		const sourceFieldPath = sourceField.getFieldPath();
-		const destinationFieldPath = this.getFieldPath();
-		this.context.checkout.editor.move(
-			sourceFieldPath,
-			sourceStart,
-			movedCount,
-			destinationFieldPath,
-			index,
-		);
+	private sequenceEditor(): SequenceFieldEditBuilder<ITreeCursorSynchronous> {
+		const fieldPath = this.getFieldPathForEditing();
+		return this.context.checkout.editor.sequenceField(fieldPath);
 	}
 }
 
@@ -468,13 +325,15 @@ export class ReadonlyLazyValueField<TTypes extends FlexAllowedTypes>
 		super(context, schema, cursor, fieldAnchor);
 	}
 
+	public editor: ValueFieldEditBuilder<ExclusiveMapTree> = {
+		set: (newContent) => {
+			assert(false, 0xa0c /* Unexpected set of readonly field */);
+		},
+	};
+
 	public get content(): FlexTreeUnboxNodeUnion<TTypes> {
 		return this.atIndex(0);
 	}
-
-	public set content(newContent: FlexibleNodeContent<TTypes>) {
-		fail("cannot set content in readonly field");
-	}
 }
 
 export class LazyValueField<TTypes extends FlexAllowedTypes>
@@ -490,7 +349,13 @@ export class LazyValueField<TTypes extends FlexAllowedTypes>
 		super(context, schema, cursor, fieldAnchor);
 	}
 
-	private valueFieldEditor(): ValueFieldEditBuilder {
+	public override editor: ValueFieldEditBuilder<ExclusiveMapTree> = {
+		set: (newContent) => {
+			this.valueFieldEditor().set(cursorForMapTreeNode(newContent));
+		},
+	};
+
+	private valueFieldEditor(): ValueFieldEditBuilder<ITreeCursorSynchronous> {
 		const fieldPath = this.getFieldPathForEditing();
 		const fieldEditor = this.context.checkout.editor.valueField(fieldPath);
 		return fieldEditor;
@@ -499,15 +364,6 @@ export class LazyValueField<TTypes extends FlexAllowedTypes>
 	public override get content(): FlexTreeUnboxNodeUnion<TTypes> {
 		return this.atIndex(0);
 	}
-
-	public override set content(newContent: FlexibleNodeContent<TTypes>) {
-		const content: ITreeCursorSynchronous[] = isCursor(newContent)
-			? prepareNodeCursorForInsert(newContent)
-			: [cursorFromContextualData(this.context, this.schema.allowedTypeSet, newContent)];
-		const fieldEditor = this.valueFieldEditor();
-		assert(content.length === 1, 0x780 /* value field content should normalize to one item */);
-		fieldEditor.set(content[0]);
-	}
 }
 
 export class LazyIdentifierField<TTypes extends FlexAllowedTypes>
@@ -537,7 +393,16 @@ export class LazyOptionalField<TTypes extends FlexAllowedTypes>
 		super(context, schema, cursor, fieldAnchor);
 	}
 
-	private optionalEditor(): OptionalFieldEditBuilder {
+	public editor: OptionalFieldEditBuilder<ExclusiveMapTree> = {
+		set: (newContent, wasEmpty) => {
+			this.optionalEditor().set(
+				newContent !== undefined ? cursorForMapTreeNode(newContent) : newContent,
+				wasEmpty,
+			);
+		},
+	};
+
+	private optionalEditor(): OptionalFieldEditBuilder<ITreeCursorSynchronous> {
 		const fieldPath = this.getFieldPathForEditing();
 		const fieldEditor = this.context.checkout.editor.optionalField(fieldPath);
 		return fieldEditor;
@@ -546,21 +411,6 @@ export class LazyOptionalField<TTypes extends FlexAllowedTypes>
 	public get content(): FlexTreeUnboxNodeUnion<TTypes> | undefined {
 		return this.length === 0 ? undefined : this.atIndex(0);
 	}
-
-	public set content(newContent: FlexibleNodeContent<TTypes> | undefined) {
-		const content: ITreeCursorSynchronous[] =
-			newContent === undefined
-				? []
-				: isCursor(newContent)
-					? prepareNodeCursorForInsert(newContent)
-					: [cursorFromContextualData(this.context, this.schema.allowedTypeSet, newContent)];
-		const fieldEditor = this.optionalEditor();
-		assert(
-			content.length <= 1,
-			0x781 /* optional field content should normalize at most one item */,
-		);
-		fieldEditor.set(content.length === 0 ? undefined : content[0], this.length === 0);
-	}
 }
 
 export class LazyForbiddenField<TTypes extends FlexAllowedTypes> extends LazyField<
@@ -588,23 +438,3 @@ const builderList: [FlexFieldKind, Builder][] = [
 ];
 
 const kindToClass: ReadonlyMap<FlexFieldKind, Builder> = new Map(builderList);
-
-/**
- * Prepare a fields cursor (holding a sequence of nodes) for inserting.
- */
-function prepareFieldCursorForInsert(cursor: ITreeCursorSynchronous): ITreeCursorSynchronous {
-	// TODO: optionally validate content against schema.
-
-	assert(cursor.mode === CursorLocationType.Fields, 0x8cb /* should be in fields mode */);
-	return cursor;
-}
-
-/**
- * Prepare a node cursor (holding a single node) for inserting.
- */
-function prepareNodeCursorForInsert(cursor: ITreeCursorSynchronous): ITreeCursorSynchronous[] {
-	// TODO: optionally validate content against schema.
-
-	assert(cursor.mode === CursorLocationType.Nodes, 0x805 /* should be in nodes mode */);
-	return [cursor];
-}

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

@@ -9,14 +9,12 @@ import {
 	type Anchor,
 	type AnchorNode,
 	CursorLocationType,
-	EmptyKey,
 	type FieldKey,
 	type ITreeSubscriptionCursor,
 	type TreeNavigationResult,
 	type TreeNodeSchemaIdentifier,
 	type TreeValue,
 	type Value,
-	forEachField,
 	inCursorField,
 	mapCursorFields,
 	rootFieldKey,
@@ -26,13 +24,11 @@ import { FieldKinds } from "../default-schema/index.js";
 import {
 	Any,
 	type FlexAllowedTypes,
-	type FlexFieldNodeSchema,
 	FlexFieldSchema,
 	type FlexMapNodeSchema,
 	type FlexObjectNodeSchema,
 	type FlexTreeNodeSchema,
 	type LeafNodeSchema,
-	schemaIsFieldNode,
 	schemaIsLeaf,
 	schemaIsMap,
 	schemaIsObjectNode,
@@ -42,7 +38,6 @@ import type { Context } from "./context.js";
 import {
 	FlexTreeEntityKind,
 	type FlexTreeField,
-	type FlexTreeFieldNode,
 	type FlexTreeLeafNode,
 	type FlexTreeMapNode,
 	type FlexTreeNode,
@@ -52,7 +47,6 @@ import {
 	type FlexTreeTypedField,
 	type FlexTreeTypedNode,
 	type FlexTreeUnboxField,
-	type FlexibleFieldContent,
 	type FlexibleNodeContent,
 	type PropertyNameFromFieldKey,
 	flexTreeMarker,
@@ -108,9 +102,6 @@ function buildSubclass(
 	if (schemaIsLeaf(schema)) {
 		return new LazyLeaf(context, schema, cursor, anchorNode, anchor);
 	}
-	if (schemaIsFieldNode(schema)) {
-		return new LazyFieldNode(context, schema, cursor, anchorNode, anchor);
-	}
 	if (schemaIsObjectNode(schema)) {
 		return buildLazyObjectNode(context, schema, cursor, anchorNode, anchor);
 	}
@@ -268,12 +259,6 @@ export class LazyMap<TSchema extends FlexMapNodeSchema>
 		super(context, schema, cursor, anchorNode, anchor);
 	}
 
-	public get size(): number {
-		let fieldCount = 0;
-		forEachField(this[cursorSymbol], () => (fieldCount += 1));
-		return fieldCount;
-	}
-
 	public keys(): IterableIterator<FieldKey> {
 		return mapCursorFields(this[cursorSymbol], (cursor) => cursor.getFieldKey()).values();
 	}
@@ -318,42 +303,10 @@ export class LazyMap<TSchema extends FlexMapNodeSchema>
 		}
 	}
 
-	public has(key: string): boolean {
-		return this.tryGetField(brand(key)) !== undefined;
-	}
-
-	public get(key: string): FlexTreeUnboxField<TSchema["info"]> {
-		return inCursorField(this[cursorSymbol], brand(key), (cursor) =>
-			unboxedField(this.context, this.schema.info, cursor),
-		) as FlexTreeUnboxField<TSchema["info"]>;
-	}
-
 	public override getBoxed(key: string): FlexTreeTypedField<TSchema["info"]> {
 		return super.getBoxed(brand(key)) as FlexTreeTypedField<TSchema["info"]>;
 	}
 
-	public set(key: string, content: FlexibleFieldContent<TSchema["info"]> | undefined): void {
-		const field = this.getBoxed(key);
-		const fieldSchema = this.schema.info;
-
-		if (fieldSchema.kind === FieldKinds.optional) {
-			const optionalField = field as FlexTreeOptionalField<FlexAllowedTypes>;
-			optionalField.content = content;
-		} else {
-			assert(fieldSchema.kind === FieldKinds.sequence, 0x807 /* Unexpected map field kind */);
-
-			// TODO: implement setting of sequence fields once we have defined clear merged semantics for doing so.
-			// For now, we will throw an error, since the public API does not currently expose a way to do this anyways.
-			throw new Error("Setting of sequence values in maps is not yet supported.");
-		}
-	}
-
-	public delete(key: FieldKey): void {
-		// Since all keys implicitly exist under a Map node, and we represent "no value" with `undefined`,
-		// "deleting" a key/value pair is the same as setting the value to `undefined`.
-		this.set(key, undefined);
-	}
-
 	public override boxedIterator(): IterableIterator<FlexTreeTypedField<TSchema["info"]>> {
 		return super.boxedIterator() as IterableIterator<FlexTreeTypedField<TSchema["info"]>>;
 	}
@@ -384,17 +337,6 @@ export class LazyLeaf<TSchema extends LeafNodeSchema>
 	}
 }
 
-export class LazyFieldNode<TSchema extends FlexFieldNodeSchema>
-	extends LazyTreeNode<TSchema>
-	implements FlexTreeFieldNode<TSchema>
-{
-	public get content(): FlexTreeUnboxField<TSchema["info"]> {
-		return inCursorField(this[cursorSymbol], EmptyKey, (cursor) =>
-			unboxedField(this.context, this.schema.info, cursor),
-		) as FlexTreeUnboxField<TSchema["info"]>;
-	}
-}
-
 /**
  * {@link reservedObjectNodeFieldPropertyNames} but as a set.
  */
@@ -465,33 +407,30 @@ function buildStructClass<TSchema extends FlexObjectNodeSchema>(
 
 	for (const [key, fieldSchema] of schema.objectNodeFields) {
 		const escapedKey = propertyNameFromFieldKey(key);
-		let setter: ((newContent: FlexibleNodeContent<FlexAllowedTypes>) => void) | undefined;
+		let setter: ((newContent: FlexibleNodeContent) => void) | undefined;
 		switch (fieldSchema.kind) {
 			case FieldKinds.optional: {
 				setter = function (
 					this: CustomStruct,
-					newContent: FlexibleNodeContent<FlexAllowedTypes> | undefined,
+					newContent: FlexibleNodeContent | undefined,
 				): void {
 					const field = getBoxedField(
 						this,
 						key,
 						fieldSchema,
 					) as FlexTreeOptionalField<FlexAllowedTypes>;
-					field.content = newContent;
+					field.editor.set(newContent, field.length === 0);
 				};
 				break;
 			}
 			case FieldKinds.required: {
-				setter = function (
-					this: CustomStruct,
-					newContent: FlexibleNodeContent<FlexAllowedTypes>,
-				): void {
+				setter = function (this: CustomStruct, newContent: FlexibleNodeContent): void {
 					const field = getBoxedField(
 						this,
 						key,
 						fieldSchema,
 					) as FlexTreeRequiredField<FlexAllowedTypes>;
-					field.content = newContent;
+					field.editor.set(newContent);
 				};
 				break;
 			}

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

@@ -28,8 +28,6 @@ import type { PathVisitor, UpPath } from "../../core/index.js";
  * - Add more events.
  * - Have some events (or a way to defer events) until the tree can be read.
  * - Consider removing this and just using AnchorEvents and simple-tree's events (and extending them as needed).
- *
- * @internal
  */
 export interface FlexTreeNodeEvents {
 	/**

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

@@ -78,8 +78,13 @@ export interface DetachedFieldCache {
  * Utility function to get a {@link SchemaAndPolicy} object from a {@link FlexTreeNode} or {@link FlexTreeField}.
  * @param nodeOrField - {@link FlexTreeNode} or {@link FlexTreeField} to get the schema and policy from.
  * @returns A {@link SchemaAndPolicy} object with the stored schema and policy from the node or field provided.
+ * If the schema information is not available on the given node or field (e.g. because it is an unhydrated node), returns `undefined`.
  */
-export function getSchemaAndPolicy(nodeOrField: FlexTreeEntity): SchemaAndPolicy {
+export function getSchemaAndPolicy(nodeOrField: FlexTreeEntity): SchemaAndPolicy | undefined {
+	if (nodeOrField.context === undefined) {
+		return undefined;
+	}
+
 	return {
 		schema: nodeOrField.context.checkout.storedSchema,
 		policy: nodeOrField.context.schema.policy,

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

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { assert } from "@fluidframework/core-utils/internal";
+import { assert, oob } from "@fluidframework/core-utils/internal";
 
 import {
 	type ICodecOptions,
@@ -40,8 +40,8 @@ export function makeForestSummarizerCodec(
 			const out: Map<FieldKey, ITreeCursorSynchronous> = new Map();
 			const fields = inner.decode(data.fields, context);
 			assert(data.keys.length === fields.length, 0x891 /* mismatched lengths */);
-			for (let index = 0; index < fields.length; index++) {
-				out.set(data.keys[index], fields[index]);
+			for (const [index, field] of fields.entries()) {
+				out.set(data.keys[index] ?? oob(), field);
 			}
 			return out;
 		},

package/src/feature-libraries/index.ts

@@ -41,26 +41,6 @@ export {
 	comparePipeline,
 	compileSyntaxTree,
 } from "./editableTreeBinder.js";
-export {
-	typeNameSymbol,
-	valueSymbol,
-	type ContextuallyTypedNodeDataObject,
-	type ContextuallyTypedNodeData,
-	type MarkedArrayLike,
-	isContextuallyTypedNodeDataObject,
-	getFieldKind,
-	type ArrayLikeMut,
-	cursorFromContextualData,
-	cursorsFromContextualData,
-	type ContextuallyTypedFieldData,
-	cursorForTypedData,
-	cursorForTypedTreeData,
-	cursorsForTypedFieldData,
-	normalizeNewFieldContent,
-	type NewFieldContent,
-	getPossibleTypes,
-	getAllowedTypes,
-} from "./contextuallyTyped.js";
 
 export { allowsValue, assertAllowedValue, isTreeValue } from "./valueUtilities.js";
 
@@ -71,6 +51,7 @@ export {
 	cursorForMapTreeField,
 	cursorForMapTreeNode,
 	mapTreeFromCursor,
+	mapTreeFieldFromCursor,
 } from "./mapTreeCursor.js";
 export { MemoizedIdRangeAllocator, type IdRange } from "./memoizedIdRangeAllocator.js";
 export { buildForest } from "./object-forest/index.js";
@@ -131,6 +112,7 @@ export {
 	type FieldKindConfiguration,
 	type FieldKindConfigurationEntry,
 	getAllowedContentIncompatibilities,
+	isRepoSuperset,
 } from "./modular-schema/index.js";
 
 export {
@@ -143,11 +125,9 @@ export {
 	type LazyTreeNodeSchema,
 	ViewSchema,
 	type SchemaLintConfiguration,
-	FlexFieldNodeSchema,
 	LeafNodeSchema,
 	FlexMapNodeSchema,
 	FlexObjectNodeSchema,
-	schemaIsFieldNode,
 	schemaIsLeaf,
 	schemaIsMap,
 	schemaIsObjectNode,
@@ -230,11 +210,11 @@ export {
 	relevantRemovedRoots,
 	SchemaValidationErrors,
 	isNodeInSchema,
+	isFieldInSchema,
 } from "./default-schema/index.js";
 
 export {
 	type AssignableFieldKinds,
-	type FlexTreeFieldNode,
 	type FlexibleFieldContent,
 	type FlexibleNodeContent,
 	type FlexTreeLeafNode,
@@ -291,18 +271,6 @@ export { TreeCompressionStrategy } from "./treeCompressionUtils.js";
 
 export { valueSchemaAllows } from "./valueUtilities.js";
 
-export type {
-	InsertableFlexNode,
-	InsertableFlexField,
-	AllowedTypesToFlexInsertableTree,
-	ApplyMultiplicity,
-	// Internal
-	CollectOptions,
-	TypedFields,
-	UnbrandedName,
-	EmptyObject,
-} from "./schema-aware/index.js";
-
 export { DetachedFieldIndexSummarizer } from "./detachedFieldIndexSummarizer.js";
 
 export {
@@ -315,7 +283,9 @@ export { makeMitigatedChangeFamily } from "./mitigatedChangeFamily.js";
 
 export {
 	type MapTreeNode,
+	type MapTreeSequenceField,
 	isMapTreeNode,
+	isMapTreeSequenceField,
 	getOrCreateMapTreeNode,
 	tryGetMapTreeNode,
 } from "./flex-map-tree/index.js";

package/src/feature-libraries/mapTreeCursor.ts

@@ -8,6 +8,7 @@ import { assert } from "@fluidframework/core-utils/internal";
 import {
 	CursorLocationType,
 	type DetachedField,
+	type ExclusiveMapTree,
 	type FieldKey,
 	type ITreeCursor,
 	type MapTree,
@@ -59,15 +60,15 @@ const adapter: CursorAdapter<MapTree> = {
 /**
  * Extract a MapTree from the contents of the given ITreeCursor's current node.
  */
-export function mapTreeFromCursor(cursor: ITreeCursor): MapTree {
+export function mapTreeFromCursor(cursor: ITreeCursor): ExclusiveMapTree {
 	assert(cursor.mode === CursorLocationType.Nodes, 0x3b7 /* must start at node */);
-	const fields: Map<FieldKey, MapTree[]> = new Map();
+	const fields: Map<FieldKey, ExclusiveMapTree[]> = new Map();
 	for (let inField = cursor.firstField(); inField; inField = cursor.nextField()) {
-		const field: MapTree[] = mapCursorField(cursor, mapTreeFromCursor);
+		const field: ExclusiveMapTree[] = mapCursorField(cursor, mapTreeFromCursor);
 		fields.set(cursor.getFieldKey(), field);
 	}
 
-	const node: MapTree = {
+	const node: ExclusiveMapTree = {
 		type: cursor.type,
 		value: cursor.value,
 		fields,
@@ -75,3 +76,11 @@ export function mapTreeFromCursor(cursor: ITreeCursor): MapTree {
 
 	return node;
 }
+
+/**
+ * Extract an array of MapTrees (a field) from the contents of the given ITreeCursor's current field.
+ */
+export function mapTreeFieldFromCursor(cursor: ITreeCursor): ExclusiveMapTree[] {
+	assert(cursor.mode === CursorLocationType.Fields, 0xa03 /* must start at field */);
+	return mapCursorField(cursor, mapTreeFromCursor);
+}