@fluidframework/tree 2.3.1 → 2.4.0-297027

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

@@ -6,18 +6,15 @@
 import { assert } from "@fluidframework/core-utils/internal";
 
 import {
-	type FieldKey,
 	type ForestEvents,
-	type TreeFieldStoredSchema,
+	type SchemaPolicy,
 	type TreeStoredSchema,
 	anchorSlot,
 	moveToDetachedField,
 } from "../../core/index.js";
 import type { Listenable } from "../../events/index.js";
 import { type IDisposable, disposeSymbol } from "../../util/index.js";
-import type { FieldGenerator } from "../fieldGenerator.js";
 import type { NodeKeyManager } from "../node-key/index.js";
-import type { FlexTreeSchema } from "../typed-schema/index.js";
 
 import type { FlexTreeField } from "./flexTreeTypes.js";
 import { type LazyEntity, prepareForEditSymbol } from "./lazyEntity.js";
@@ -32,13 +29,12 @@ export interface FlexTreeContext {
 	 * Schema used within this context.
 	 * All data must conform to these schema.
 	 */
-	readonly flexSchema: FlexTreeSchema;
+	readonly schema: TreeStoredSchema;
 
 	/**
-	 * Schema used within this context.
-	 * All data must conform to these schema.
+	 * SchemaPolicy used within this context.
 	 */
-	readonly schema: TreeStoredSchema;
+	readonly schemaPolicy: SchemaPolicy;
 
 	/**
 	 * If true, this context is the canonical context instance for a given view,
@@ -91,7 +87,7 @@ export class Context implements FlexTreeHydratedContext, IDisposable {
 	 * @param nodeKeyManager - An object which handles node key generation and conversion
 	 */
 	public constructor(
-		public readonly flexSchema: FlexTreeSchema,
+		public readonly schemaPolicy: SchemaPolicy,
 		public readonly checkout: ITreeCheckout,
 		public readonly nodeKeyManager: NodeKeyManager,
 	) {
@@ -159,7 +155,7 @@ export class Context implements FlexTreeHydratedContext, IDisposable {
 		assert(this.disposed === false, 0x804 /* use after dispose */);
 		const cursor = this.checkout.forest.allocateCursor("root");
 		moveToDetachedField(this.checkout.forest, cursor);
-		const field = makeField(this, this.flexSchema.rootFieldSchema, cursor);
+		const field = makeField(this, this.schema.rootFieldSchema.kind, cursor);
 		cursor.free();
 		return field;
 	}
@@ -170,15 +166,6 @@ export class Context implements FlexTreeHydratedContext, IDisposable {
 	): () => void {
 		return this.checkout.forest.on(eventName, listener);
 	}
-
-	/**
-	 * FieldSource used to get a FieldGenerator to populate required fields during procedural contextual data generation.
-	 */
-	// TODO: Use this to automatically provide node keys where required.
-	public fieldSource?(
-		key: FieldKey,
-		schema: TreeFieldStoredSchema,
-	): undefined | FieldGenerator;
 }
 
 /**
@@ -191,7 +178,7 @@ export class Context implements FlexTreeHydratedContext, IDisposable {
  * This is necessary for supporting using this tree across edits to the forest, and not leaking memory.
  */
 export function getTreeContext(
-	schema: FlexTreeSchema,
+	schema: SchemaPolicy,
 	checkout: ITreeCheckout,
 	nodeKeyManager: NodeKeyManager,
 ): Context {

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

@@ -7,8 +7,8 @@ import {
 	type AnchorNode,
 	type ExclusiveMapTree,
 	type FieldKey,
+	type FieldKindIdentifier,
 	type FieldUpPath,
-	type TreeFieldStoredSchema,
 	type TreeNodeSchemaIdentifier,
 	type TreeValue,
 	anchorSlot,
@@ -20,7 +20,6 @@ import type {
 	OptionalFieldEditBuilder,
 } from "../default-schema/index.js";
 import type { FlexFieldKind } from "../modular-schema/index.js";
-import type { FlexTreeNodeSchema } from "../typed-schema/index.js";
 
 import type { FlexTreeContext } from "./context.js";
 
@@ -126,11 +125,7 @@ export enum TreeStatus {
  * the same {@link FlexTreeNode} instance will be used in the new location.
  * Similarly, edits applied to a node's sub-tree concurrently with the move of the node will still be applied to its subtree in its new location.
  *
- *
  * @remarks
- * Down-casting (via {@link FlexTreeNode#is}) is required to access Schema-Aware APIs, including editing.
- * All content in the tree is accessible without down-casting, but if the schema is known,
- * the schema aware API may be more ergonomic.
  * All editing is actually done via {@link FlexTreeField}s: the nodes are immutable other than that they contain mutable fields.
  */
 export interface FlexTreeNode extends FlexTreeEntity {
@@ -162,11 +157,6 @@ export interface FlexTreeNode extends FlexTreeEntity {
 	 */
 	readonly parentField: { readonly parent: FlexTreeField; readonly index: number };
 
-	/**
-	 * Type guard for narrowing / down-casting to a specific schema.
-	 */
-	is(schema: FlexTreeNodeSchema): boolean;
-
 	boxedIterator(): IterableIterator<FlexTreeField>;
 
 	/**
@@ -194,12 +184,6 @@ export interface FlexTreeNode extends FlexTreeEntity {
 	 * If well-formed, it must follow this schema.
 	 */
 	readonly schema: TreeNodeSchemaIdentifier;
-
-	/**
-	 * Schema for this entity.
-	 * If well-formed, it must follow this schema.
-	 */
-	readonly flexSchema: FlexTreeNodeSchema;
 }
 
 /**
@@ -268,7 +252,7 @@ export interface FlexTreeField extends FlexTreeEntity {
 	 * Schema for this entity.
 	 * If well-formed, it must follow this schema.
 	 */
-	readonly schema: TreeFieldStoredSchema;
+	readonly schema: FieldKindIdentifier;
 }
 
 // #region Field Kinds

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

@@ -43,15 +43,12 @@ export function assertFlexTreeEntityNotFreed(entity: FlexTreeEntity): void {
 /**
  * This is a base class for lazy (cursor based) UntypedEntity implementations, which uniformly handles cursors and anchors.
  */
-export abstract class LazyEntity<TSchema = unknown, TAnchor = unknown>
-	implements FlexTreeEntity, IDisposable
-{
+export abstract class LazyEntity<TAnchor = unknown> implements FlexTreeEntity, IDisposable {
 	readonly #lazyCursor: ITreeSubscriptionCursor;
 	public readonly [anchorSymbol]: TAnchor;
 
 	protected constructor(
 		public readonly context: Context,
-		public readonly flexSchema: TSchema,
 		cursor: ITreeSubscriptionCursor,
 		anchor: TAnchor,
 	) {

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

@@ -10,10 +10,10 @@ import {
 	type ExclusiveMapTree,
 	type FieldAnchor,
 	type FieldKey,
+	type FieldKindIdentifier,
 	type FieldUpPath,
 	type ITreeCursorSynchronous,
 	type ITreeSubscriptionCursor,
-	type TreeFieldStoredSchema,
 	type TreeNavigationResult,
 	inCursorNode,
 	iterateCursorField,
@@ -27,7 +27,6 @@ import {
 	type ValueFieldEditBuilder,
 } from "../default-schema/index.js";
 import type { FlexFieldKind } from "../modular-schema/index.js";
-import type { FlexFieldSchema } from "../typed-schema/index.js";
 
 import type { Context } from "./context.js";
 import {
@@ -75,7 +74,7 @@ const fieldCache: WeakMap<LazyTreeNode, Map<FieldKey, FlexTreeField>> = new Weak
 
 export function makeField(
 	context: Context,
-	schema: FlexFieldSchema,
+	schema: FieldKindIdentifier,
 	cursor: ITreeSubscriptionCursor,
 ): FlexTreeField {
 	const fieldAnchor = cursor.buildFieldAnchor();
@@ -83,7 +82,7 @@ export function makeField(
 
 	const makeFlexTreeField = (): FlexTreeField => {
 		usedAnchor = true;
-		const field = new (kindToClass.get(schema.kind) ?? fail("missing field implementation"))(
+		const field = new (kindToClass.get(schema) ?? fail("missing field implementation"))(
 			context,
 			schema,
 			cursor,
@@ -125,19 +124,12 @@ export function makeField(
 /**
  * Base type for fields implementing {@link FlexTreeField} using cursors.
  */
-export abstract class LazyField<out TKind extends FlexFieldKind>
-	extends LazyEntity<FlexFieldSchema<TKind>, FieldAnchor>
-	implements FlexTreeField
-{
+export abstract class LazyField extends LazyEntity<FieldAnchor> implements FlexTreeField {
 	public get [flexTreeMarker](): FlexTreeEntityKind.Field {
 		return FlexTreeEntityKind.Field;
 	}
 	public readonly key: FieldKey;
 
-	public get schema(): TreeFieldStoredSchema {
-		return this.flexSchema.stored;
-	}
-
 	/**
 	 * If this field ends its lifetime before the Anchor does, this needs to be invoked to avoid a double free
 	 * if/when the Anchor is destroyed.
@@ -146,11 +138,11 @@ export abstract class LazyField<out TKind extends FlexFieldKind>
 
 	public constructor(
 		context: Context,
-		schema: FlexFieldSchema<TKind>,
+		public readonly schema: FieldKindIdentifier,
 		cursor: ITreeSubscriptionCursor,
 		fieldAnchor: FieldAnchor,
 	) {
-		super(context, schema, cursor, fieldAnchor);
+		super(context, cursor, fieldAnchor);
 		assert(cursor.mode === CursorLocationType.Fields, 0x77b /* must be in fields mode */);
 		this.key = cursor.getFieldKey();
 		// Fields currently live as long as their parent does.
@@ -167,11 +159,11 @@ export abstract class LazyField<out TKind extends FlexFieldKind>
 
 	public is<TKind2 extends FlexFieldKind>(kind: TKind2): this is FlexTreeTypedField<TKind2> {
 		assert(
-			this.context.flexSchema.policy.fieldKinds.get(kind.identifier) === kind,
+			this.context.schemaPolicy.fieldKinds.get(kind.identifier) === kind,
 			0xa26 /* Narrowing must be done to a kind that exists in this context */,
 		);
 
-		return this.flexSchema.kind === (kind as unknown);
+		return this.schema === kind.identifier;
 	}
 
 	public get parent(): FlexTreeNode | undefined {
@@ -259,19 +251,7 @@ export abstract class LazyField<out TKind extends FlexFieldKind>
 	}
 }
 
-export class LazySequence
-	extends LazyField<typeof FieldKinds.sequence>
-	implements FlexTreeSequenceField
-{
-	public constructor(
-		context: Context,
-		schema: FlexFieldSchema<typeof FieldKinds.sequence>,
-		cursor: ITreeSubscriptionCursor,
-		fieldAnchor: FieldAnchor,
-	) {
-		super(context, schema, cursor, fieldAnchor);
-	}
-
+export class LazySequence extends LazyField implements FlexTreeSequenceField {
 	public at(index: number): FlexTreeUnknownUnboxed | undefined {
 		const finalIndex = indexForAt(index, this.length);
 
@@ -302,19 +282,7 @@ export class LazySequence
 	}
 }
 
-export class ReadonlyLazyValueField
-	extends LazyField<typeof FieldKinds.required>
-	implements FlexTreeRequiredField
-{
-	public constructor(
-		context: Context,
-		schema: FlexFieldSchema<typeof FieldKinds.required>,
-		cursor: ITreeSubscriptionCursor,
-		fieldAnchor: FieldAnchor,
-	) {
-		super(context, schema, cursor, fieldAnchor);
-	}
-
+export class ReadonlyLazyValueField extends LazyField implements FlexTreeRequiredField {
 	public editor: ValueFieldEditBuilder<ExclusiveMapTree> = {
 		set: (newContent) => {
 			assert(false, 0xa0c /* Unexpected set of readonly field */);
@@ -327,15 +295,6 @@ export class ReadonlyLazyValueField
 }
 
 export class LazyValueField extends ReadonlyLazyValueField implements FlexTreeRequiredField {
-	public constructor(
-		context: Context,
-		schema: FlexFieldSchema<typeof FieldKinds.required>,
-		cursor: ITreeSubscriptionCursor,
-		fieldAnchor: FieldAnchor,
-	) {
-		super(context, schema, cursor, fieldAnchor);
-	}
-
 	public override editor: ValueFieldEditBuilder<ExclusiveMapTree> = {
 		set: (newContent) => {
 			this.valueFieldEditor().set(cursorForMapTreeNode(newContent));
@@ -353,19 +312,7 @@ export class LazyValueField extends ReadonlyLazyValueField implements FlexTreeRe
 	}
 }
 
-export class LazyOptionalField
-	extends LazyField<typeof FieldKinds.optional>
-	implements FlexTreeOptionalField
-{
-	public constructor(
-		context: Context,
-		schema: FlexFieldSchema<typeof FieldKinds.optional>,
-		cursor: ITreeSubscriptionCursor,
-		fieldAnchor: FieldAnchor,
-	) {
-		super(context, schema, cursor, fieldAnchor);
-	}
-
+export class LazyOptionalField extends LazyField implements FlexTreeOptionalField {
 	public editor: OptionalFieldEditBuilder<ExclusiveMapTree> = {
 		set: (newContent, wasEmpty) => {
 			this.optionalEditor().set(
@@ -386,25 +333,22 @@ export class LazyOptionalField
 	}
 }
 
-export class LazyForbiddenField extends LazyField<typeof FieldKinds.forbidden> {}
+export class LazyForbiddenField extends LazyField {}
 
 type Builder = new (
 	context: Context,
 	// Correct use of these builders requires the builder of the matching type to be used.
-	// Since this has to be done at runtime anyway, trying to use safer typing than `any` here (such as `never`, which is only slightly safer)
-	// does not seem worth it (ends up requiring type casts that are just as unsafe).
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	schema: FlexFieldSchema<any>,
+	schema: FieldKindIdentifier,
 	cursor: ITreeSubscriptionCursor,
 	fieldAnchor: FieldAnchor,
-) => LazyField<FlexFieldKind>;
-
-const builderList: [FlexFieldKind, Builder][] = [
-	[FieldKinds.forbidden, LazyForbiddenField],
-	[FieldKinds.optional, LazyOptionalField],
-	[FieldKinds.sequence, LazySequence],
-	[FieldKinds.required, LazyValueField],
-	[FieldKinds.identifier, LazyValueField],
+) => LazyField;
+
+const builderList: [FieldKindIdentifier, Builder][] = [
+	[FieldKinds.forbidden.identifier, LazyForbiddenField],
+	[FieldKinds.optional.identifier, LazyOptionalField],
+	[FieldKinds.sequence.identifier, LazySequence],
+	[FieldKinds.required.identifier, LazyValueField],
+	[FieldKinds.identifier.identifier, LazyValueField],
 ];
 
-const kindToClass: ReadonlyMap<FlexFieldKind, Builder> = new Map(builderList);
+const kindToClass: ReadonlyMap<FieldKindIdentifier, Builder> = new Map(builderList);

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

@@ -10,9 +10,11 @@ import {
 	type AnchorNode,
 	CursorLocationType,
 	type FieldKey,
+	type FieldKindIdentifier,
 	type ITreeSubscriptionCursor,
 	type TreeNavigationResult,
 	type TreeNodeSchemaIdentifier,
+	type TreeNodeStoredSchema,
 	type Value,
 	inCursorField,
 	mapCursorFields,
@@ -20,7 +22,6 @@ import {
 } from "../../core/index.js";
 import { disposeSymbol, fail } from "../../util/index.js";
 import { FieldKinds } from "../default-schema/index.js";
-import { FlexFieldSchema, type FlexTreeNodeSchema } from "../typed-schema/index.js";
 
 import type { Context } from "./context.js";
 import {
@@ -52,10 +53,9 @@ export function makeTree(context: Context, cursor: ITreeSubscriptionCursor): Laz
 		context.checkout.forest.anchors.forget(anchor);
 		assert(cached.context === context, 0x782 /* contexts must match */);
 		assert(cached instanceof LazyTreeNode, 0x92c /* Expected LazyTreeNode */);
-		return cached as LazyTreeNode;
+		return cached;
 	}
-	const schema = context.flexSchema.nodeSchema.get(cursor.type) ?? fail("missing schema");
-	return new LazyTreeNode(context, schema, cursor, anchorNode, anchor);
+	return new LazyTreeNode(context, cursor.type, cursor, anchorNode, anchor);
 }
 
 function cleanupTree(anchor: AnchorNode): void {
@@ -67,45 +67,28 @@ function cleanupTree(anchor: AnchorNode): void {
 /**
  * Lazy implementation of {@link FlexTreeNode}.
  */
-export class LazyTreeNode<TSchema extends FlexTreeNodeSchema = FlexTreeNodeSchema>
-	extends LazyEntity<TSchema, Anchor>
-	implements FlexTreeNode
-{
+export class LazyTreeNode extends LazyEntity<Anchor> implements FlexTreeNode {
 	public get [flexTreeMarker](): FlexTreeEntityKind.Node {
 		return FlexTreeEntityKind.Node;
 	}
 
-	public get schema(): TreeNodeSchemaIdentifier {
-		return this.flexSchema.name;
-	}
-
 	// Using JS private here prevents it from showing up as a enumerable own property, or conflicting with struct fields.
 	readonly #removeDeleteCallback: () => void;
 
+	private readonly storedSchema: TreeNodeStoredSchema;
+
 	public constructor(
 		context: Context,
-		schema: TSchema,
+		public readonly schema: TreeNodeSchemaIdentifier,
 		cursor: ITreeSubscriptionCursor,
 		public readonly anchorNode: AnchorNode,
 		anchor: Anchor,
 	) {
-		super(context, schema, cursor, anchor);
+		super(context, cursor, anchor);
+		this.storedSchema = context.schema.nodeSchema.get(this.schema) ?? fail("missing schema");
 		assert(cursor.mode === CursorLocationType.Nodes, 0x783 /* must be in nodes mode */);
 		anchorNode.slots.set(flexTreeSlot, this);
 		this.#removeDeleteCallback = anchorNode.on("afterDestroy", cleanupTree);
-
-		assert(
-			this.context.flexSchema.nodeSchema.get(this.flexSchema.name) !== undefined,
-			0x784 /* There is no explicit schema for this node type. Ensure that the type is correct and the schema for it was added to the TreeStoredSchema */,
-		);
-	}
-
-	public is(schema: FlexTreeNodeSchema): boolean {
-		assert(
-			this.context.flexSchema.nodeSchema.get(schema.name) === schema,
-			0x785 /* Narrowing must be done to a schema that exists in this context */,
-		);
-		return this.flexSchema === (schema as unknown);
 	}
 
 	protected override [tryMoveCursorToAnchorSymbol](
@@ -128,25 +111,29 @@ export class LazyTreeNode<TSchema extends FlexTreeNodeSchema = FlexTreeNodeSchem
 	}
 
 	public tryGetField(fieldKey: FieldKey): FlexTreeField | undefined {
-		const schema = this.flexSchema.getFieldSchema(fieldKey);
+		const schema = this.storedSchema.getFieldSchema(fieldKey);
 		return inCursorField(this[cursorSymbol], fieldKey, (cursor) => {
 			if (cursor.getFieldLength() === 0) {
 				return undefined;
 			}
-			return makeField(this.context, schema, cursor);
+			return makeField(this.context, schema.kind, cursor);
 		});
 	}
 
 	public getBoxed(key: FieldKey): FlexTreeField {
-		const fieldSchema = this.flexSchema.getFieldSchema(key);
+		const fieldSchema = this.storedSchema.getFieldSchema(key);
 		return inCursorField(this[cursorSymbol], key, (cursor) => {
-			return makeField(this.context, fieldSchema, cursor);
+			return makeField(this.context, fieldSchema.kind, cursor);
 		});
 	}
 
 	public boxedIterator(): IterableIterator<FlexTreeField> {
 		return mapCursorFields(this[cursorSymbol], (cursor) =>
-			makeField(this.context, this.flexSchema.getFieldSchema(cursor.getFieldKey()), cursor),
+			makeField(
+				this.context,
+				this.storedSchema.getFieldSchema(cursor.getFieldKey()).kind,
+				cursor,
+			),
 		).values();
 	}
 
@@ -158,14 +145,14 @@ export class LazyTreeNode<TSchema extends FlexTreeNodeSchema = FlexTreeNodeSchem
 
 		cursor.exitNode();
 		assert(key === cursor.getFieldKey(), 0x787 /* mismatched keys */);
-		let fieldSchema: FlexFieldSchema;
+		let fieldSchema: FieldKindIdentifier;
 
 		// Check if the current node is in a detached sequence.
 		if (this.anchorNode.parent === undefined) {
 			// Parent field is a detached sequence, and thus needs special handling for its schema.
 			// eslint-disable-next-line unicorn/prefer-ternary
 			if (key === rootFieldKey) {
-				fieldSchema = this.context.flexSchema.rootFieldSchema;
+				fieldSchema = this.context.schema.rootFieldSchema.kind;
 			} else {
 				// All fields (in the flex tree API) have a schema.
 				// Since currently there is no known schema for detached field other than the special default root:
@@ -180,18 +167,16 @@ export class LazyTreeNode<TSchema extends FlexTreeNodeSchema = FlexTreeNodeSchem
 				// Additionally this approach makes it possible for a user to take a FlexTree node, get its parent, check its schema, down cast based on that, then edit that detached field (ex: removing the node in it).
 				// This MIGHT work properly with existing merge resolution logic (it must keep client in sync and be unable to violate schema), but this either needs robust testing or to be explicitly banned (error before sending the op).
 				// Issues like replacing a node in the a removed sequenced then undoing the remove could easily violate schema if not everything works exactly right!
-				fieldSchema = FlexFieldSchema.create(FieldKinds.sequence, [
-					...this.context.flexSchema.nodeSchema.values(),
-				]);
+				fieldSchema = FieldKinds.sequence.identifier;
 			}
 		} else {
 			cursor.exitField();
 			const parentType = cursor.type;
 			cursor.enterField(key);
 			const nodeSchema =
-				this.context.flexSchema.nodeSchema.get(parentType) ??
+				this.context.schema.nodeSchema.get(parentType) ??
 				fail("requested schema that does not exist");
-			fieldSchema = nodeSchema.getFieldSchema(key);
+			fieldSchema = nodeSchema.getFieldSchema(key).kind;
 		}
 
 		const proxifiedField = makeField(this.context, fieldSchema, cursor);

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

@@ -83,7 +83,7 @@ export interface DetachedFieldCache {
 export function getSchemaAndPolicy(nodeOrField: FlexTreeEntity): SchemaAndPolicy {
 	return {
 		schema: nodeOrField.context.schema,
-		policy: nodeOrField.context.flexSchema.policy,
+		policy: nodeOrField.context.schemaPolicy,
 	};
 }
 

package/src/feature-libraries/index.ts

@@ -4,48 +4,11 @@
  */
 
 export {
-	createDataBinderBuffering,
-	createDataBinderDirect,
-	createDataBinderInvalidating,
-	createBinderOptions,
-	createFlushableBinderOptions,
-	type DataBinder,
-	type BinderOptions,
-	type Flushable,
-	type FlushableBinderOptions,
-	type FlushableDataBinder,
-	type MatchPolicy,
-	type SubtreePolicy,
-	type BindSyntaxTree,
-	indexSymbol,
-	type BindPolicy,
-	type BindTree,
-	type BindTreeDefault,
 	type DownPath,
-	type BindPath,
-	type PathStep,
-	BindingType,
-	type BindingContextType,
-	type BindingContext,
-	type VisitorBindingContext,
-	type RemoveBindingContext,
-	type InsertBindingContext,
-	type BatchBindingContext,
-	type InvalidationBindingContext,
-	type OperationBinderEvents,
-	type InvalidationBinderEvents,
-	type CompareFunction,
-	type BinderEventsCompare,
-	type AnchorsCompare,
 	toDownPath,
-	comparePipeline,
-	compileSyntaxTree,
 } from "./editableTreeBinder.js";
-
 export { allowsValue, assertAllowedValue, isTreeValue } from "./valueUtilities.js";
 
-export type { FieldGenerator, TreeDataContext } from "./fieldGenerator.js";
-
 export { ForestSummarizer } from "./forest-summary/index.js";
 export {
 	cursorForMapTreeField,
@@ -113,37 +76,16 @@ export {
 	type FieldKindConfigurationEntry,
 	getAllowedContentIncompatibilities,
 	isRepoSuperset,
+	isNeverTree,
 } from "./modular-schema/index.js";
 
 export {
-	type FlexTreeNodeSchema,
-	type FlexAllowedTypes,
-	FlexFieldSchema,
-	type FlexTreeSchema,
-	type SchemaLibraryData,
-	type LazyTreeNodeSchema,
-	ViewSchema,
-	type SchemaLintConfiguration,
-	LeafNodeSchema,
-	FlexMapNodeSchema,
-	FlexObjectNodeSchema,
-	schemaIsLeaf,
-	schemaIsMap,
-	schemaIsObjectNode,
 	type Unenforced,
-	type AllowedTypeSet,
 	markEager,
-	type FlexMapFieldSchema,
-	type SchemaCollection,
-	TreeNodeSchemaBase,
 	type LazyItem,
 	type FlexListToUnion,
 	type ExtractItemType,
 	isLazy,
-	type FlexObjectNodeFields,
-	intoStoredSchema,
-	intoStoredSchemaCollection,
-	type NormalizeLazyItem,
 	type FlexList,
 } from "./typed-schema/index.js";
 
@@ -223,10 +165,10 @@ export {
 	isFreedSymbol,
 	LazyEntity,
 	treeStatusFromAnchorCache,
+	indexForAt,
+	FlexTreeEntityKind,
 } from "./flex-tree/index.js";
 
-export { treeSchemaFromStoredSchema } from "./storedToViewSchema.js";
-
 export { TreeCompressionStrategy } from "./treeCompressionUtils.js";
 
 export { valueSchemaAllows } from "./valueUtilities.js";
@@ -240,13 +182,3 @@ export {
 } from "./schema-edits/index.js";
 
 export { makeMitigatedChangeFamily } from "./mitigatedChangeFamily.js";
-
-export {
-	type MapTreeNode,
-	type MapTreeSequenceField,
-	isMapTreeNode,
-	isMapTreeSequenceField,
-	getOrCreateMapTreeNode,
-	tryGetMapTreeNode,
-	UnhydratedContext,
-} from "./flex-map-tree/index.js";