@fluidframework/tree 2.3.0-288113 → 2.4.0-294316

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

@@ -138,7 +138,10 @@ export class ForestSummarizer implements Summarizable {
 			const fieldChanges: [FieldKey, DeltaFieldChanges][] = [];
 			const build: DeltaDetachedNodeBuild[] = [];
 			for (const [fieldKey, field] of fields) {
-				const chunked = chunkField(field, defaultChunkPolicy);
+				const chunked = chunkField(field, {
+					policy: defaultChunkPolicy,
+					idCompressor: this.idCompressor,
+				});
 				const nodeCursors = chunked.flatMap((chunk) =>
 					mapCursorField(chunk.cursor(), (cursor) => cursor.fork()),
 				);

package/src/feature-libraries/index.ts

@@ -120,7 +120,6 @@ export {
 	type FlexAllowedTypes,
 	FlexFieldSchema,
 	type FlexTreeSchema,
-	Any,
 	type SchemaLibraryData,
 	type LazyTreeNodeSchema,
 	ViewSchema,
@@ -141,8 +140,6 @@ export {
 	type FlexListToUnion,
 	type ExtractItemType,
 	isLazy,
-	type NormalizeObjectNodeFields,
-	type NormalizeField as NormalizeFieldSchema,
 	type FlexObjectNodeFields,
 	intoStoredSchema,
 	intoStoredSchemaCollection,
@@ -150,19 +147,6 @@ export {
 	type FlexList,
 } from "./typed-schema/index.js";
 
-export {
-	SchemaBuilderBase,
-	type SchemaLibrary,
-	type FlexImplicitFieldSchema,
-	type NormalizeField,
-	type FlexImplicitAllowedTypes,
-	type NormalizeAllowedTypes,
-	type SchemaBuilderOptions,
-	normalizeAllowedTypes,
-	normalizeField,
-} from "./schemaBuilderBase.js";
-export { SchemaBuilderInternal } from "./schemaBuilder.js";
-
 export { mapRootChanges } from "./deltaUtils.js";
 
 export {
@@ -214,25 +198,17 @@ export {
 } from "./default-schema/index.js";
 
 export {
-	type AssignableFieldKinds,
-	type FlexibleFieldContent,
-	type FlexibleNodeContent,
-	type FlexTreeLeafNode,
-	type FlexTreeMapNode,
 	type FlexTreeOptionalField,
 	type FlexTreeRequiredField,
 	type FlexTreeSequenceField,
 	Skip,
-	type FlexTreeObjectNode,
 	type FlexTreeContext,
+	type FlexTreeHydratedContext,
 	type FlexTreeTypedField,
-	type FlexTreeTypedNode,
-	type FlexTreeTypedNodeUnion,
 	type FlexTreeEntity,
 	type FlexTreeField,
 	type FlexTreeNode,
 	getTreeContext,
-	type CheckTypesOverlap,
 	TreeStatus,
 	Context,
 	type FlexTreeNodeEvents,
@@ -240,9 +216,7 @@ export {
 	isFlexTreeNode,
 	ContextSlot,
 	// Internal
-	type FlexTreeUnboxField,
 	flexTreeMarker,
-	FlexTreeEntityKind,
 	assertFlexTreeEntityNotFreed,
 	flexTreeSlot,
 	getSchemaAndPolicy,
@@ -274,4 +248,5 @@ export {
 	isMapTreeSequenceField,
 	getOrCreateMapTreeNode,
 	tryGetMapTreeNode,
+	UnhydratedContext,
 } from "./flex-map-tree/index.js";

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

@@ -22,6 +22,10 @@ import type { FullSchemaPolicy } from "./fieldKind.js";
 import { withEditor } from "./fieldKindWithEditor.js";
 import { isNeverTree } from "./isNeverTree.js";
 
+// TODO:
+// The comparisons in this file seem redundant with those in discrepancies.ts.
+// Rather than both existing, one of which just returns boolean and the other which returns additional details, a simple comparison which returns everything needed should be used.
+
 /**
  * @returns true iff `superset` is a superset of `original`.
  *
@@ -153,12 +157,6 @@ export function allowsTreeSchemaIdentifierSuperset(
 	original: TreeTypeSet,
 	superset: TreeTypeSet,
 ): boolean {
-	if (superset === undefined) {
-		return true;
-	}
-	if (original === undefined) {
-		return false;
-	}
 	for (const originalType of original) {
 		if (!superset.has(originalType)) {
 			return false;

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

@@ -18,6 +18,10 @@ import {
 	type ValueSchema,
 } from "../../core/index.js";
 
+// TODO:
+// The comparisons in this file seem redundant with those in comparison.ts.
+// Rather than both existing, one of which just returns boolean and the other which returns additional details, a simple comparison which returns everything needed should be used.
+
 /**
  * @remarks
  *
@@ -298,22 +302,9 @@ function trackFieldDiscrepancies(
 		a: TreeTypeSet,
 		b: TreeTypeSet,
 	): [TreeNodeSchemaIdentifier[], TreeNodeSchemaIdentifier[]] => {
-		if (a === undefined && b === undefined) {
-			return [[], []];
-		}
-
-		if (a !== undefined && b !== undefined) {
-			const aDiff = [...a].filter((value) => !b.has(value));
-			const bDiff = [...b].filter((value) => !a.has(value));
-			return [aDiff, bDiff];
-		}
-
-		if (a !== undefined) {
-			return [[...a], []];
-		}
-
-		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-		return [[], [...b!]];
+		const aDiff = [...a].filter((value) => !b.has(value));
+		const bDiff = [...b].filter((value) => !a.has(value));
+		return [aDiff, bDiff];
 	};
 
 	const allowedTypesDiscrepancies = findSetDiscrepancies(view.types, stored.types);

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

@@ -382,7 +382,10 @@ function makeModularChangeCodec(
 		});
 		const getChunk = (index: number): TreeChunk => {
 			assert(index < chunks.length, 0x898 /* out of bounds index for build chunk */);
-			return chunkFieldSingle(chunks[index] ?? oob(), defaultChunkPolicy);
+			return chunkFieldSingle(chunks[index] ?? oob(), {
+				policy: defaultChunkPolicy,
+				idCompressor: context.idCompressor,
+			});
 		};
 
 		const map: ModularChangeset["builds"] = newTupleBTree();

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

@@ -38,6 +38,7 @@ import {
 	revisionMetadataSourceFromInfo,
 	areEqualChangeAtomIds,
 	type ChangeAtomId,
+	areEqualChangeAtomIdOpts,
 } from "../../core/index.js";
 import {
 	type IdAllocationState,
@@ -87,6 +88,7 @@ import type {
 	NodeId,
 	TupleBTree,
 } from "./modularChangeTypes.js";
+import type { IIdCompressor } from "@fluidframework/id-compressor";
 
 /**
  * Implementation of ChangeFamily which delegates work in a given field to the appropriate FieldKind
@@ -262,8 +264,6 @@ export class ModularChangeFamily
 		const genId: IdAllocator = idAllocatorFromState(idState);
 		const revisionMetadata: RevisionMetadataSource = revisionMetadataSourceFromInfo(revInfos);
 
-		const crossFieldTable = newComposeTable(change1, change2);
-
 		// We merge nodeChanges, nodeToParent, and nodeAliases from the two changesets.
 		// The merged tables will have correct entries for all nodes which are only referenced in one of the input changesets.
 		// During composeFieldMaps and composeInvalidatedElements we will find all nodes referenced in both input changesets
@@ -283,9 +283,12 @@ export class ModularChangeFamily
 			mergeBTrees(change1.nodeAliases, change2.nodeAliases),
 		);
 
+		const crossFieldTable = newComposeTable(change1, change2, composedNodeToParent);
+
 		const composedFields = this.composeFieldMaps(
 			change1.fieldChanges,
 			change2.fieldChanges,
+			undefined,
 			genId,
 			crossFieldTable,
 			revisionMetadata,
@@ -320,7 +323,7 @@ export class ModularChangeFamily
 	): void {
 		const context = crossFieldTable.fieldToContext.get(fieldChange);
 		assert(context !== undefined, 0x8cc /* Should have context for every invalidated field */);
-		const { change1: fieldChange1, change2: fieldChange2, composedChange } = context;
+		const { fieldId, change1: fieldChange1, change2: fieldChange2, composedChange } = context;
 
 		const rebaser = getChangeHandler(this.fieldKinds, composedChange.fieldKind).rebaser;
 		const composeNodes = (child1: NodeId | undefined, child2: NodeId | undefined): NodeId => {
@@ -341,7 +344,7 @@ export class ModularChangeFamily
 			fieldChange2,
 			composeNodes,
 			genId,
-			new ComposeManager(crossFieldTable, fieldChange, false),
+			new ComposeManager(crossFieldTable, fieldChange, fieldId, false),
 			revisionMetadata,
 		);
 		composedChange.change = brand(amendedChange);
@@ -469,7 +472,14 @@ export class ModularChangeFamily
 				? [fieldChange, emptyChange]
 				: [emptyChange, fieldChange];
 
-			const composedField = this.composeFieldChanges(change1, change2, genId, table, metadata);
+			const composedField = this.composeFieldChanges(
+				fieldId,
+				change1,
+				change2,
+				genId,
+				table,
+				metadata,
+			);
 
 			if (fieldId.nodeId === undefined) {
 				composedFields.set(fieldId.field, composedField);
@@ -498,6 +508,7 @@ export class ModularChangeFamily
 	private composeFieldMaps(
 		change1: FieldChangeMap | undefined,
 		change2: FieldChangeMap | undefined,
+		parentId: NodeId | undefined,
 		genId: IdAllocator,
 		crossFieldTable: ComposeTable,
 		revisionMetadata: RevisionMetadataSource,
@@ -508,10 +519,12 @@ export class ModularChangeFamily
 		}
 
 		for (const [field, fieldChange1] of change1) {
+			const fieldId: FieldId = { nodeId: parentId, field };
 			const fieldChange2 = change2.get(field);
 			const composedField =
 				fieldChange2 !== undefined
 					? this.composeFieldChanges(
+							fieldId,
 							fieldChange1,
 							fieldChange2,
 							genId,
@@ -544,6 +557,7 @@ export class ModularChangeFamily
 	 * Any composed `FieldChange` which is invalidated by new cross-field information will be added to `crossFieldTable.invalidatedFields`.
 	 */
 	private composeFieldChanges(
+		fieldId: FieldId,
 		change1: FieldChange,
 		change2: FieldChange,
 		idAllocator: IdAllocator,
@@ -557,7 +571,7 @@ export class ModularChangeFamily
 			change2: change2Normalized,
 		} = this.normalizeFieldChanges(change1, change2, idAllocator, revisionMetadata);
 
-		const manager = new ComposeManager(crossFieldTable, change1);
+		const manager = new ComposeManager(crossFieldTable, change1, fieldId);
 
 		const composedChange = changeHandler.rebaser.compose(
 			change1Normalized,
@@ -580,6 +594,7 @@ export class ModularChangeFamily
 		};
 
 		crossFieldTable.fieldToContext.set(change1, {
+			fieldId,
 			change1: change1Normalized,
 			change2: change2Normalized,
 			composedChange: composedField,
@@ -604,6 +619,7 @@ export class ModularChangeFamily
 		const nodeChangeset1 = nodeChangeFromId(nodeChanges1, id1);
 		const nodeChangeset2 = nodeChangeFromId(nodeChanges2, id2);
 		const composedNodeChangeset = this.composeNodeChanges(
+			id1,
 			nodeChangeset1,
 			nodeChangeset2,
 			idAllocator,
@@ -626,6 +642,7 @@ export class ModularChangeFamily
 	}
 
 	private composeNodeChanges(
+		nodeId: NodeId,
 		change1: NodeChangeset,
 		change2: NodeChangeset,
 		genId: IdAllocator,
@@ -637,6 +654,7 @@ export class ModularChangeFamily
 		const composedFieldChanges = this.composeFieldMaps(
 			change1.fieldChanges,
 			change2.fieldChanges,
+			nodeId,
 			genId,
 			crossFieldTable,
 			revisionMetadata,
@@ -673,7 +691,7 @@ export class ModularChangeFamily
 			0x89a /* Unexpected destroys in change to invert */,
 		);
 
-		if ((change.change.constraintViolationCount ?? 0) > 0) {
+		if (hasConflicts(change.change)) {
 			return makeModularChangeset(
 				undefined,
 				undefined,
@@ -827,6 +845,10 @@ export class ModularChangeFamily
 		over: TaggedChange<ModularChangeset>,
 		revisionMetadata: RevisionMetadataSource,
 	): ModularChangeset {
+		if (hasConflicts(over.change)) {
+			return taggedChange.change;
+		}
+
 		const change = taggedChange.change;
 		const maxId = Math.max(change.maxId ?? -1, over.change.maxId ?? -1);
 		const idState: IdAllocationState = { maxId };
@@ -882,7 +904,7 @@ export class ModularChangeFamily
 			rebasedNodes,
 		);
 
-		return makeModularChangeset(
+		const rebased = makeModularChangeset(
 			this.pruneFieldMap(rebasedFields, rebasedNodes),
 			rebasedNodes,
 			crossFieldTable.rebasedNodeToParent,
@@ -895,6 +917,8 @@ export class ModularChangeFamily
 			change.destroys,
 			change.refreshers,
 		);
+
+		return rebased;
 	}
 
 	// This performs a first pass on all fields which have both new and base changes.
@@ -1579,6 +1603,57 @@ export class ModularChangeFamily
 		const emptyChange = getChangeHandler(this.fieldKinds, fieldKind).createEmpty();
 		return { fieldKind, change: brand(emptyChange) };
 	}
+
+	public validateChangeset(change: ModularChangeset): void {
+		let numNodes = this.validateFieldChanges(change, change.fieldChanges, undefined);
+
+		for (const [[revision, localId], node] of change.nodeChanges.entries()) {
+			if (node.fieldChanges === undefined) {
+				continue;
+			}
+
+			const nodeId: NodeId = { revision, localId };
+			const numChildren = this.validateFieldChanges(change, node.fieldChanges, nodeId);
+
+			numNodes += numChildren;
+		}
+
+		assert(numNodes === change.nodeChanges.size, "Node table contains unparented nodes");
+	}
+
+	/**
+	 * Asserts that each child and cross field key in each field has a correct entry in
+	 * `nodeToParent` or `crossFieldKeyTable`.
+	 * @returns the number of children found.
+	 */
+	private validateFieldChanges(
+		change: ModularChangeset,
+		fieldChanges: FieldChangeMap,
+		nodeParent: NodeId | undefined,
+	): number {
+		let numChildren = 0;
+		for (const [field, fieldChange] of fieldChanges.entries()) {
+			const fieldId = { nodeId: nodeParent, field };
+			const handler = getChangeHandler(this.fieldKinds, fieldChange.fieldKind);
+			for (const [child, _index] of handler.getNestedChanges(fieldChange.change)) {
+				const parentFieldId = getParentFieldId(change, child);
+				assert(areEqualFieldIds(parentFieldId, fieldId), "Inconsistent node parentage");
+				numChildren += 1;
+			}
+
+			for (const keyRange of handler.getCrossFieldKeys(fieldChange.change)) {
+				const fields = getFieldsForCrossFieldKey(change, keyRange);
+				assert(
+					fields.length === 1 &&
+						fields[0] !== undefined &&
+						areEqualFieldIds(fields[0], fieldId),
+					"Inconsistent cross field keys",
+				);
+			}
+		}
+
+		return numChildren;
+	}
 }
 
 function replaceCrossFieldKeyTableRevisions(
@@ -1845,7 +1920,7 @@ export function intoDelta(
 	const idAllocator = MemoizedIdRangeAllocator.fromNextId();
 	const rootDelta: Mutable<DeltaRoot> = {};
 
-	if ((change.constraintViolationCount ?? 0) === 0) {
+	if (!hasConflicts(change)) {
 		// If there are no constraint violations, then tree changes apply.
 		const fieldDeltas = intoDeltaImpl(
 			change.fieldChanges,
@@ -2054,6 +2129,7 @@ interface RebaseFieldContext {
 function newComposeTable(
 	baseChange: ModularChangeset,
 	newChange: ModularChangeset,
+	composedNodeToParent: ChangeAtomIdBTree<FieldId>,
 ): ComposeTable {
 	return {
 		...newCrossFieldTable<FieldChange>(),
@@ -2063,6 +2139,7 @@ function newComposeTable(
 		newFieldToBaseField: new Map(),
 		newToBaseNodeId: newTupleBTree(),
 		composedNodes: new Set(),
+		composedNodeToParent,
 		pendingCompositions: {
 			nodeIdsToCompose: [],
 			affectedBaseFields: newTupleBTree(),
@@ -2082,6 +2159,7 @@ interface ComposeTable extends CrossFieldTable<FieldChange> {
 	readonly newFieldToBaseField: Map<FieldChange, FieldChange>;
 	readonly newToBaseNodeId: ChangeAtomIdBTree<NodeId>;
 	readonly composedNodes: Set<NodeChangeset>;
+	readonly composedNodeToParent: ChangeAtomIdBTree<FieldId>;
 	readonly pendingCompositions: PendingCompositions;
 }
 
@@ -2104,6 +2182,10 @@ interface PendingCompositions {
 }
 
 interface ComposeFieldContext {
+	/**
+	 * The field ID for this field in the composed changeset.
+	 */
+	fieldId: FieldId;
 	change1: FieldChangeset;
 	change2: FieldChangeset;
 	composedChange: FieldChange;
@@ -2319,7 +2401,12 @@ class RebaseManager extends CrossFieldManagerI<FieldChange> {
 
 // TODO: Deduplicate this with RebaseTable
 class ComposeManager extends CrossFieldManagerI<FieldChange> {
-	public constructor(table: ComposeTable, currentField: FieldChange, allowInval = true) {
+	public constructor(
+		table: ComposeTable,
+		currentField: FieldChange,
+		private readonly fieldId: FieldId,
+		allowInval = true,
+	) {
 		super(table, currentField, allowInval);
 	}
 
@@ -2372,15 +2459,16 @@ class ComposeManager extends CrossFieldManagerI<FieldChange> {
 	}
 
 	public override onMoveIn(id: ChangeAtomId): void {
-		throw new Error("Method not implemented.");
+		setInChangeAtomIdMap(this.table.composedNodeToParent, id, this.fieldId);
 	}
+
 	public override moveKey(
 		target: CrossFieldTarget,
 		revision: RevisionTag | undefined,
 		id: ChangesetLocalId,
 		count: number,
 	): void {
-		throw new Error("Method not implemented.");
+		throw new Error("Moving cross-field keys during compose is currently unsupported");
 	}
 
 	private get table(): ComposeTable {
@@ -2466,15 +2554,20 @@ export class ModularEditBuilder extends EditBuilder<ModularChangeset> {
 	public buildTrees(
 		firstId: ChangesetLocalId,
 		content: ITreeCursorSynchronous,
+		idCompressor?: IIdCompressor,
 	): GlobalEditDescription {
 		if (content.mode === CursorLocationType.Fields && content.getFieldLength() === 0) {
 			return { type: "global" };
 		}
 		const builds: ChangeAtomIdBTree<TreeChunk> = newTupleBTree();
+		const chunkCompressor = {
+			policy: defaultChunkPolicy,
+			idCompressor,
+		};
 		const chunk =
 			content.mode === CursorLocationType.Fields
-				? chunkFieldSingle(content, defaultChunkPolicy)
-				: chunkTree(content, defaultChunkPolicy);
+				? chunkFieldSingle(content, chunkCompressor)
+				: chunkTree(content, chunkCompressor);
 		builds.set([undefined, firstId], chunk);
 
 		return {
@@ -3012,3 +3105,7 @@ function getFromChangeAtomIdMap<T>(
 function setInChangeAtomIdMap<T>(map: ChangeAtomIdBTree<T>, id: ChangeAtomId, value: T): void {
 	map.set([id.revision, id.localId], value);
 }
+
+function areEqualFieldIds(a: FieldId, b: FieldId): boolean {
+	return areEqualChangeAtomIdOpts(a.nodeId, b.nodeId) && a.field === b.field;
+}

package/src/feature-libraries/sequence-field/compose.ts

@@ -576,6 +576,9 @@ export class ComposeQueue {
 	private dequeueBase(length: number = Infinity): ComposeMarks {
 		const baseMark = this.baseMarks.dequeueUpTo(length);
 		const movedChanges = getMovedChangesFromMark(this.moveEffects, baseMark);
+		if (movedChanges !== undefined) {
+			this.moveEffects.onMoveIn(movedChanges);
+		}
 
 		const newMark = createNoopMark(baseMark.count, movedChanges, getOutputCellId(baseMark));
 		return { baseMark, newMark };

package/src/feature-libraries/sequence-field/utils.ts

@@ -10,6 +10,7 @@ import {
 	type ChangesetLocalId,
 	type RevisionMetadataSource,
 	type RevisionTag,
+	areEqualChangeAtomIdOpts,
 	areEqualChangeAtomIds,
 	makeChangeAtomId,
 } from "../../core/index.js";
@@ -118,10 +119,7 @@ export function isActiveReattach(
 }
 
 export function areEqualCellIds(a: CellId | undefined, b: CellId | undefined): boolean {
-	if (a === undefined || b === undefined) {
-		return a === b;
-	}
-	return areEqualChangeAtomIds(a, b);
+	return areEqualChangeAtomIdOpts(a, b);
 }
 
 export function getInputCellId(mark: Mark): CellId | undefined {

package/src/feature-libraries/storedToViewSchema.ts

@@ -17,7 +17,6 @@ import { fail } from "../util/index.js";
 
 import { defaultSchemaPolicy } from "./default-schema/index.js";
 import {
-	Any,
 	type FlexAllowedTypes,
 	FlexFieldSchema,
 	type FlexMapFieldSchema,
@@ -42,7 +41,7 @@ export function treeSchemaFromStoredSchema(schema: TreeStoredSchema): FlexTreeSc
 		if (innerSchema instanceof LeafNodeStoredSchema) {
 			map.set(
 				identifier,
-				LeafNodeSchema.create({ name: "intoTypedSchema" }, identifier, innerSchema.leafValue),
+				new LeafNodeSchema({ name: "intoTypedSchema" }, identifier, innerSchema.leafValue),
 			);
 		} else if (innerSchema instanceof MapNodeStoredSchema) {
 			map.set(
@@ -93,9 +92,9 @@ export function fieldSchemaFromStoredSchema(
 	map: ReadonlyMap<TreeNodeSchemaIdentifier, FlexTreeNodeSchema>,
 ): FlexFieldSchema {
 	const kind = defaultSchemaPolicy.fieldKinds.get(schema.kind) ?? fail("missing field kind");
-	const types: FlexAllowedTypes =
-		schema.types === undefined
-			? [Any]
-			: Array.from(schema.types, (v) => () => map.get(v) ?? fail("missing schema"));
+	const types: FlexAllowedTypes = Array.from(
+		schema.types,
+		(v) => () => map.get(v) ?? fail("missing schema"),
+	);
 	return FlexFieldSchema.create(kind, types);
 }

package/src/feature-libraries/typed-schema/flexList.ts

@@ -45,7 +45,7 @@ export function markEager<T>(t: T): T {
  * To force a `"function"` item to be treated as an eager item, call `markEager` before putting it in the list.
  * This is necessary e.g. when the eager list items are function types and the lazy items are functions that _return_ function types.
  * `FlexList`s are processed by `normalizeFlexList` and `normalizeFlexListEager`.
- * @public
+ * @system @public
  */
 export type FlexList<Item = unknown> = readonly LazyItem<Item>[];
 
@@ -94,7 +94,7 @@ export type NormalizedLazyFlexList<Item> = (() => Item)[];
 
 /**
  * Get the `Item` type from a `LazyItem<Item>`.
- * @public
+ * @system @public
  */
 export type ExtractItemType<Item extends LazyItem> = Item extends () => infer Result
 	? Result
@@ -120,7 +120,7 @@ export type FlexListToNonLazyArray<List extends FlexList> =
 
 /**
  * Normalize FlexList type to a union.
- * @public
+ * @system @public
  */
 export type FlexListToUnion<TList extends FlexList> = ExtractItemType<TList[number]>;
 

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

@@ -6,7 +6,6 @@
 export {
 	type FlexTreeNodeSchema,
 	FlexFieldSchema,
-	Any,
 	allowedTypesToTypeSet,
 	type FlexAllowedTypes,
 	type LazyTreeNodeSchema,
@@ -23,8 +22,6 @@ export {
 	schemaIsLeaf,
 	schemaIsMap,
 	schemaIsObjectNode,
-	type NormalizeObjectNodeFields,
-	type NormalizeField,
 	intoStoredSchema,
 	allowedTypesSchemaSet,
 	intoStoredSchemaCollection,
@@ -47,4 +44,5 @@ export {
 	type NormalizeLazyItem,
 	type FlexListToUnion,
 	type ExtractItemType,
+	normalizeFlexListEager,
 } from "./flexList.js";

package/src/feature-libraries/typed-schema/schemaCollection.ts

@@ -22,7 +22,6 @@ import {
 	type FlexTreeNodeSchema,
 	LeafNodeSchema,
 	type SchemaCollection,
-	allowedTypesIsAny,
 } from "./typedTreeSchema.js";
 import type { Sourced } from "./view.js";
 
@@ -168,11 +167,11 @@ export function validateSchemaCollection(
 			validateField(
 				lintConfiguration,
 				collection,
-				tree.info,
+				tree.info as FlexFieldSchema,
 				() => `Map fields of "${identifier}" schema from library "${tree.builder.name}"`,
 				errors,
 			);
-			if ((tree.info.kind.multiplicity as Multiplicity) === Multiplicity.Single) {
+			if ((tree.info as FlexFieldSchema).kind.multiplicity === Multiplicity.Single) {
 				errors.push(
 					`Map fields of "${identifier}" schema from library "${tree.builder.name}" has kind with multiplicity "Single". This is invalid since it requires all possible field keys to have a value under them.`,
 				);
@@ -213,24 +212,23 @@ export function validateField(
 	errors: string[],
 ): void {
 	const types = field.allowedTypes;
-	if (!allowedTypesIsAny(types)) {
-		const normalizedTypes = normalizeFlexListEager(types);
-		for (const type of normalizedTypes) {
-			const referenced = collection.nodeSchema.get(type.name);
-			if (referenced === undefined) {
-				errors.push(
-					`${describeField()} references type "${type.name}" from library "${
-						type.builder.name
-					}" which is not defined. Perhaps another type was intended, or that library needs to be added.`,
-				);
-			}
-		}
-		if (types.length === 0 && lintConfiguration.rejectEmpty) {
+
+	const normalizedTypes = normalizeFlexListEager(types);
+	for (const type of normalizedTypes) {
+		const referenced = collection.nodeSchema.get(type.name);
+		if (referenced === undefined) {
 			errors.push(
-				`${describeField()} requires children to have a type from a set of zero types. This means the field must always be empty.`,
+				`${describeField()} references type "${type.name}" from library "${
+					type.builder.name
+				}" which is not defined. Perhaps another type was intended, or that library needs to be added.`,
 			);
 		}
 	}
+	if (types.length === 0 && lintConfiguration.rejectEmpty) {
+		errors.push(
+			`${describeField()} requires children to have a type from a set of zero types. This means the field must always be empty.`,
+		);
+	}
 
 	const kind = field.kind;
 	const kindFromPolicy = defaultSchemaPolicy.fieldKinds.get(kind.identifier);