@fluidframework/tree 2.4.0-299374 → 2.4.0-299707

package/src/index.ts

@@ -114,7 +114,6 @@ export {
 	type InsertableObjectFromSchemaRecordUnsafe,
 	type InsertableTreeFieldFromImplicitFieldUnsafe,
 	type FieldSchemaUnsafe,
-	type TreeNodeSchemaClassUnsafe,
 	// System types (not in Internal types for various reasons, like doc links or cannot be named errors).
 	type typeSchemaSymbol,
 	type TreeNodeSchemaNonClass,
@@ -126,13 +125,6 @@ export {
 	enumFromStrings,
 	singletonSchema,
 	typedObjectValues,
-	type UnsafeUnknownSchema,
-	type TreeViewAlpha,
-	type InsertableField,
-	type Insertable,
-	type InsertableContent,
-	type FactoryContent,
-	type FactoryContentObject,
 	// test recursive schema for checking that d.ts files handles schema correctly
 	test_RecursiveObject,
 	test_RecursiveObject_base,
@@ -159,7 +151,6 @@ export {
 	getJsonSchema,
 	type LazyItem,
 	type Unenforced,
-	type ReadonlyArrayNode,
 } from "./simple-tree/index.js";
 export {
 	SharedTree,

package/src/internalTypes.ts

@@ -33,9 +33,6 @@ export type {
 	NodeBuilderDataUnsafe,
 	NodeFromSchemaUnsafe,
 	ReadonlyMapInlined,
-	TreeNodeSchemaUnsafe,
-	AllowedTypesUnsafe,
-	TreeNodeSchemaNonClassUnsafe,
 } from "./simple-tree/index.js";
 export type { FlexList, FlexListToUnion, ExtractItemType } from "./simple-tree/index.js";
 

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/tree";
-export const pkgVersion = "2.4.0-299374";
+export const pkgVersion = "2.4.0-299707";

package/src/shared-tree/treeApi.ts

@@ -78,10 +78,7 @@ export interface RunTransaction {
 	 * If the transaction function throws an error then the transaction will be automatically rolled back (discarding any changes made to the tree so far) before the error is propagated up from this function.
 	 * If the transaction is rolled back, a corresponding change event will also be emitted for the rollback.
 	 */
-	// TODO: TreeView is invariant over the schema, so to accept any view, `any` is the only real option unless a non generic (or covariant) base type for view is introduced (which is planned).
-	// This use of any is actually type safe as it is only used as a constraint, and the actual strongly typed view (TView) is passed to the callback.
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	<TView extends TreeView<any>, TResult>(
+	<TView extends TreeView<ImplicitFieldSchema>, TResult>(
 		tree: TView,
 		transaction: (root: TView["root"]) => TResult,
 	): TResult;
@@ -126,9 +123,7 @@ export interface RunTransaction {
 	 * If the transaction function throws an error then the transaction will be automatically rolled back (discarding any changes made to the tree so far) before the error is propagated up from this function.
 	 * If the transaction is rolled back (whether by an error or by returning the {@link RunTransaction.rollback} | rollback value), a corresponding change event will also be emitted for the rollback.
 	 */
-	// See comment on previous overload about use of any here.
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	<TView extends TreeView<any>, TResult>(
+	<TView extends TreeView<ImplicitFieldSchema>, TResult>(
 		tree: TView,
 		transaction: (root: TView["root"]) => TResult | typeof rollback,
 	): TResult | typeof rollback;
@@ -166,9 +161,10 @@ export interface RunTransaction {
 	 * If the transaction function throws an error then the transaction will be automatically rolled back (discarding any changes made to the tree so far) before the error is propagated up from this function.
 	 * If the transaction is rolled back, a corresponding change event will also be emitted for the rollback.
 	 */
-	// See comment on previous overload about use of any here.
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	<TView extends TreeView<any>>(tree: TView, transaction: (root: TView["root"]) => void): void;
+	<TView extends TreeView<ImplicitFieldSchema>>(
+		tree: TView,
+		transaction: (root: TView["root"]) => void,
+	): void;
 	/**
 	 * Apply one or more edits to the tree as a single atomic unit.
 	 * @param node - The node that will be passed to `transaction`.
@@ -215,9 +211,7 @@ export interface RunTransaction {
 	 * If the transaction function throws an error then the transaction will be automatically rolled back (discarding any changes made to the tree so far) before the error is propagated up from this function.
 	 * If the transaction is rolled back, a corresponding change event will also be emitted for the rollback.
 	 */
-	// See comment on previous overload about use of any here.
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	<TView extends TreeView<any>, TResult>(
+	<TView extends TreeView<ImplicitFieldSchema>, TResult>(
 		tree: TView,
 		transaction: (root: TView["root"]) => TResult,
 		preconditions?: readonly TransactionConstraint[],
@@ -270,9 +264,7 @@ export interface RunTransaction {
 	 * If the transaction function throws an error then the transaction will be automatically rolled back (discarding any changes made to the tree so far) before the error is propagated up from this function.
 	 * If the transaction is rolled back (whether by an error or by returning the {@link RunTransaction.rollback} | rollback value), a corresponding change event will also be emitted for the rollback.
 	 */
-	// See comment on previous overload about use of any here.
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	<TView extends TreeView<any>, TResult>(
+	<TView extends TreeView<ImplicitFieldSchema>, TResult>(
 		tree: TView,
 		transaction: (root: TView["root"]) => TResult | typeof rollback,
 		preconditions?: readonly TransactionConstraint[],
@@ -321,9 +313,7 @@ export interface RunTransaction {
 	 * If the transaction function throws an error then the transaction will be automatically rolled back (discarding any changes made to the tree so far) before the error is propagated up from this function.
 	 * If the transaction is rolled back, a corresponding change event will also be emitted for the rollback.
 	 */
-	// See comment on previous overload about use of any here.
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	<TView extends TreeView<any>>(
+	<TView extends TreeView<ImplicitFieldSchema>>(
 		tree: TView,
 		transaction: (root: TView["root"]) => void,
 		preconditions?: readonly TransactionConstraint[],

package/src/simple-tree/api/index.ts

@@ -12,7 +12,6 @@ export {
 	type ITreeViewConfiguration,
 	type SchemaCompatibilityStatus,
 	type ITreeConfigurationOptions,
-	type TreeViewAlpha,
 } from "./tree.js";
 export { SchemaFactory, type ScopedSchemaName } from "./schemaFactory.js";
 export type {
@@ -63,10 +62,6 @@ export type {
 	NodeBuilderDataUnsafe,
 	NodeFromSchemaUnsafe,
 	ReadonlyMapInlined,
-	TreeNodeSchemaClassUnsafe,
-	TreeNodeSchemaUnsafe,
-	AllowedTypesUnsafe,
-	TreeNodeSchemaNonClassUnsafe,
 } from "./typesUnsafe.js";
 
 export type {

package/src/simple-tree/api/tree.ts

@@ -11,14 +11,11 @@ import type { Listenable } from "../../events/index.js";
 
 import {
 	type ImplicitFieldSchema,
-	type InsertableField,
 	type InsertableTreeFieldFromImplicitField,
 	type TreeFieldFromImplicitField,
-	type TreeLeafValue,
-	type UnsafeUnknownSchema,
 	FieldKind,
 } from "../schemaTypes.js";
-import { NodeKind, type TreeNode, type TreeNodeSchema } from "../core/index.js";
+import { NodeKind, type TreeNodeSchema } from "../core/index.js";
 import { toStoredSchema } from "../toFlexSchema.js";
 import { LeafNodeSchema } from "../leafNodeSchema.js";
 import { assert } from "@fluidframework/core-utils/internal";
@@ -366,7 +363,7 @@ export function checkUnion(union: Iterable<TreeNodeSchema>, errors: string[]): v
  * Thus this design was chosen at the risk of apps blindly accessing `root` then breaking unexpectedly when the document is incompatible.
  * @sealed @public
  */
-export interface TreeView<in out TSchema extends ImplicitFieldSchema> extends IDisposable {
+export interface TreeView<TSchema extends ImplicitFieldSchema> extends IDisposable {
 	/**
 	 * The current root of the tree.
 	 *
@@ -427,25 +424,6 @@ export interface TreeView<in out TSchema extends ImplicitFieldSchema> extends ID
 	readonly schema: TSchema;
 }
 
-/**
- * {@link TreeView} with proposed changes to the schema aware typing to allow use with `UnsafeUnknownSchema`.
- * @alpha
- */
-export interface TreeViewAlpha<
-	in out TSchema extends ImplicitFieldSchema | UnsafeUnknownSchema,
-> extends Omit<
-		TreeView<TSchema extends ImplicitFieldSchema ? TSchema : ImplicitFieldSchema>,
-		"root" | "initialize"
-	> {
-	get root(): TSchema extends ImplicitFieldSchema
-		? TreeFieldFromImplicitField<TSchema>
-		: TreeLeafValue | TreeNode;
-
-	set root(newRoot: InsertableField<TSchema>);
-
-	initialize(content: InsertableField<TSchema>): void;
-}
-
 /**
  * Information about a view schema's compatibility with the document's stored schema.
  *

package/src/simple-tree/api/typesUnsafe.ts

@@ -6,24 +6,24 @@
 import type { RestrictiveStringRecord, _InlineTrick } from "../../util/index.js";
 
 import type {
+	AllowedTypes,
 	ApplyKind,
 	FieldKind,
 	FieldSchema,
 	ImplicitAllowedTypes,
 	ImplicitFieldSchema,
-	TreeLeafValue,
+	NodeFromSchema,
+	TreeNodeFromImplicitAllowedTypes,
 } from "../schemaTypes.js";
 import type {
 	NodeKind,
+	TreeNodeSchema,
 	WithType,
 	TreeNode,
 	Unhydrated,
-	InternalTreeNode,
-	TreeNodeSchema,
-	TreeNodeSchemaCore,
 } from "../core/index.js";
-import type { TreeArrayNodeBase } from "../arrayNode.js";
-import type { FlexListToUnion, LazyItem } from "../flexList.js";
+import type { TreeArrayNodeBase, TreeArrayNode } from "../arrayNode.js";
+import type { FlexListToUnion } from "../flexList.js";
 
 /*
  * TODO:
@@ -59,65 +59,6 @@ export type ObjectFromSchemaRecordUnsafe<
 	-readonly [Property in keyof T]: TreeFieldFromImplicitFieldUnsafe<T[Property]>;
 };
 
-/**
- * {@link Unenforced} version of {@link TreeNodeSchema}.
- * @remarks
- * Do note use this type directly: its only needed in the implementation of generic logic which define recursive schema, not when using recursive schema.
- * @system @public
- */
-export type TreeNodeSchemaUnsafe<
-	Name extends string = string,
-	Kind extends NodeKind = NodeKind,
-	TNode extends Unenforced<TreeNode | TreeLeafValue> = unknown,
-	TBuild = never,
-	ImplicitlyConstructable extends boolean = boolean,
-	Info = unknown,
-> =
-	| TreeNodeSchemaClassUnsafe<Name, Kind, TNode, TBuild, ImplicitlyConstructable, Info>
-	| TreeNodeSchemaNonClassUnsafe<Name, Kind, TNode, TBuild, ImplicitlyConstructable, Info>;
-
-/**
- * {@link Unenforced} version of {@link TreeNodeSchemaClass}.
- * @remarks
- * Do note use this type directly: its only needed in the implementation of generic logic which define recursive schema, not when using recursive schema.
- * @system @public
- */
-export interface TreeNodeSchemaClassUnsafe<
-	out Name extends string,
-	out Kind extends NodeKind,
-	// TODO: maybe this can be more specific (exclude leaves)
-	out TNode extends Unenforced<TreeNode | TreeLeafValue>,
-	in TInsertable = never,
-	out ImplicitlyConstructable extends boolean = boolean,
-	out Info = unknown,
-> extends TreeNodeSchemaCore<Name, Kind, ImplicitlyConstructable, Info> {
-	/**
-	 * Constructs an {@link Unhydrated} node with this schema.
-	 * @remarks
-	 * This constructor is also used internally to construct hydrated nodes with a different parameter type.
-	 * Therefore, overriding this constructor with different argument types is not type-safe and is not supported.
-	 * @sealed
-	 */
-	new (data: TInsertable | InternalTreeNode): Unhydrated<TNode>;
-}
-
-/**
- * {@link Unenforced} version of {@link TreeNodeSchemaNonClass}.
- * @remarks
- * Do note use this type directly: its only needed in the implementation of generic logic which define recursive schema, not when using recursive schema.
- * @system @public
- */
-export interface TreeNodeSchemaNonClassUnsafe<
-	out Name extends string,
-	out Kind extends NodeKind,
-	out TNode extends Unenforced<TreeNode | TreeLeafValue>,
-	in TInsertable = never,
-	out ImplicitlyConstructable extends boolean = boolean,
-	out Info = unknown,
-> extends TreeNodeSchemaCore<Name, Kind, ImplicitlyConstructable, Info> {
-	create(data: TInsertable): TNode;
-}
-
 /**
  * {@link Unenforced} version of {@link TreeObjectNode}.
  * @remarks
@@ -142,14 +83,6 @@ export type TreeFieldFromImplicitFieldUnsafe<TSchema extends Unenforced<Implicit
 			? TreeNodeFromImplicitAllowedTypesUnsafe<TSchema>
 			: unknown;
 
-/**
- * {@link Unenforced} version of {@link AllowedTypes}.
- * @remarks
- * Do note use this type directly: its only needed in the implementation of generic logic which define recursive schema, not when using recursive schema.
- * @system @public
- */
-export type AllowedTypesUnsafe = readonly LazyItem<TreeNodeSchemaUnsafe>[];
-
 /**
  * {@link Unenforced} version of {@link TreeNodeFromImplicitAllowedTypes}.
  * @remarks
@@ -158,11 +91,13 @@ export type AllowedTypesUnsafe = readonly LazyItem<TreeNodeSchemaUnsafe>[];
  */
 export type TreeNodeFromImplicitAllowedTypesUnsafe<
 	TSchema extends Unenforced<ImplicitAllowedTypes>,
-> = TSchema extends TreeNodeSchemaUnsafe
-	? NodeFromSchemaUnsafe<TSchema>
-	: TSchema extends AllowedTypesUnsafe
-		? NodeFromSchemaUnsafe<FlexListToUnion<TSchema>>
-		: unknown;
+> = TSchema extends ImplicitAllowedTypes
+	? TreeNodeFromImplicitAllowedTypes<TSchema>
+	: TSchema extends TreeNodeSchema
+		? NodeFromSchema<TSchema>
+		: TSchema extends AllowedTypes
+			? NodeFromSchema<FlexListToUnion<TSchema>>
+			: unknown;
 
 /**
  * {@link Unenforced} version of {@link InsertableTreeNodeFromImplicitAllowedTypes}.
@@ -172,7 +107,7 @@ export type TreeNodeFromImplicitAllowedTypesUnsafe<
  */
 export type InsertableTreeNodeFromImplicitAllowedTypesUnsafe<
 	TSchema extends Unenforced<ImplicitAllowedTypes>,
-> = TSchema extends AllowedTypesUnsafe
+> = TSchema extends AllowedTypes
 	? InsertableTypedNodeUnsafe<FlexListToUnion<TSchema>>
 	: InsertableTypedNodeUnsafe<TSchema>;
 
@@ -194,7 +129,7 @@ export type InsertableTypedNodeUnsafe<T extends Unenforced<TreeNodeSchema>> = [
  * @system @public
  */
 export type NodeFromSchemaUnsafe<T extends Unenforced<TreeNodeSchema>> =
-	T extends TreeNodeSchemaUnsafe<string, NodeKind, infer TNode> ? TNode : never;
+	T extends TreeNodeSchema<string, NodeKind, infer TNode> ? TNode : never;
 
 /**
  * {@link Unenforced} version of {@link InsertableTreeNodeFromImplicitAllowedTypes}.
@@ -203,7 +138,7 @@ export type NodeFromSchemaUnsafe<T extends Unenforced<TreeNodeSchema>> =
  * @system @public
  */
 export type NodeBuilderDataUnsafe<T extends Unenforced<TreeNodeSchema>> =
-	T extends TreeNodeSchemaUnsafe<string, NodeKind, unknown, infer TBuild> ? TBuild : never;
+	T extends TreeNodeSchema<string, NodeKind, unknown, infer TBuild> ? TBuild : never;
 
 /**
  * {@link Unenforced} version of {@link (TreeArrayNode:interface)}.
@@ -214,7 +149,8 @@ export type NodeBuilderDataUnsafe<T extends Unenforced<TreeNodeSchema>> =
 export interface TreeArrayNodeUnsafe<TAllowedTypes extends Unenforced<ImplicitAllowedTypes>>
 	extends TreeArrayNodeBase<
 		TreeNodeFromImplicitAllowedTypesUnsafe<TAllowedTypes>,
-		InsertableTreeNodeFromImplicitAllowedTypesUnsafe<TAllowedTypes>
+		InsertableTreeNodeFromImplicitAllowedTypesUnsafe<TAllowedTypes>,
+		TreeArrayNode
 	> {}
 
 /**

package/src/simple-tree/arrayNode.ts

@@ -18,7 +18,6 @@ import {
 	normalizeAllowedTypes,
 	type ImplicitAllowedTypes,
 	type InsertableTreeNodeFromImplicitAllowedTypes,
-	type TreeLeafValue,
 	type TreeNodeFromImplicitAllowedTypes,
 } from "./schemaTypes.js";
 import {
@@ -35,7 +34,6 @@ import {
 	type TreeNodeSchemaBoth,
 	getSimpleNodeSchemaFromInnerNode,
 	getOrCreateInnerNode,
-	type TreeNodeSchemaClass,
 } from "./core/index.js";
 import { type InsertableContent, mapTreeFromNodeData } from "./toMapTree.js";
 import { fail } from "../util/index.js";
@@ -47,19 +45,6 @@ import {
 import { TreeNodeValid, type MostDerivedData } from "./treeNodeValid.js";
 import { getUnhydratedContext } from "./createContext.js";
 
-/**
- * A covariant base type for {@link (TreeArrayNode:interface)}.
- *
- * This provides the readonly subset of TreeArrayNode functionality, and is used as the source interface for moves since that needs to be covariant.
- * @privateRemarks
- * Ideally this would just include `TreeNode, WithType<string, NodeKind.Array>` in the extends list but https://github.com/microsoft/TypeScript/issues/16936 prevents that from compiling.
- * As a workaround around for this TypeScript limitation, the conflicting type intersection is wrapped in `Awaited` (which has no effect on the type in this case) which allows it to compile.
- * @system @sealed @public
- */
-export interface ReadonlyArrayNode<out T = TreeNode | TreeLeafValue>
-	extends ReadonlyArray<T>,
-		Awaited<TreeNode & WithType<string, NodeKind.Array>> {}
-
 /**
  * A generic array type, used to defined types like {@link (TreeArrayNode:interface)}.
  *
@@ -68,8 +53,9 @@ export interface ReadonlyArrayNode<out T = TreeNode | TreeLeafValue>
  *
  * @system @sealed @public
  */
-export interface TreeArrayNodeBase<out T, in TNew, in TMoveFrom = ReadonlyArrayNode>
-	extends ReadonlyArrayNode<T> {
+export interface TreeArrayNodeBase<out T, in TNew, in TMoveFrom>
+	extends ReadonlyArray<T>,
+		TreeNode {
 	/**
 	 * Inserts new item(s) at a specified location.
 	 * @param index - The index at which to insert `value`.
@@ -380,7 +366,8 @@ export interface TreeArrayNode<
 	TAllowedTypes extends ImplicitAllowedTypes = ImplicitAllowedTypes,
 > extends TreeArrayNodeBase<
 		TreeNodeFromImplicitAllowedTypes<TAllowedTypes>,
-		InsertableTreeNodeFromImplicitAllowedTypes<TAllowedTypes>
+		InsertableTreeNodeFromImplicitAllowedTypes<TAllowedTypes>,
+		TreeArrayNode
 	> {}
 
 /**
@@ -430,7 +417,9 @@ export class IterableTreeArrayContent<T> implements Iterable<T> {
 /**
  * Given a array node proxy, returns its underlying LazySequence field.
  */
-function getSequenceField(arrayNode: ReadonlyArrayNode): FlexTreeSequenceField {
+function getSequenceField<TSimpleType extends ImplicitAllowedTypes>(
+	arrayNode: TreeArrayNode<TSimpleType>,
+): FlexTreeSequenceField {
 	return getOrCreateInnerNode(arrayNode).getBoxed(EmptyKey) as FlexTreeSequenceField;
 }
 
@@ -810,11 +799,6 @@ abstract class CustomArrayNodeBase<const T extends ImplicitAllowedTypes>
 	protected abstract get simpleSchema(): T;
 	protected abstract get allowedTypes(): ReadonlySet<TreeNodeSchema>;
 
-	public abstract override get [typeSchemaSymbol](): TreeNodeSchemaClass<
-		string,
-		NodeKind.Array
-	>;
-
 	public constructor(
 		input: Iterable<InsertableTreeNodeFromImplicitAllowedTypes<T>> | InternalTreeNode,
 	) {
@@ -917,13 +901,13 @@ abstract class CustomArrayNodeBase<const T extends ImplicitAllowedTypes>
 		}
 		field.editor.remove(removeStart, removeEnd - removeStart);
 	}
-	public moveToStart(sourceIndex: number, source?: ReadonlyArrayNode): void {
+	public moveToStart(sourceIndex: number, source?: TreeArrayNode): void {
 		const sourceArray = source ?? this;
 		const sourceField = getSequenceField(sourceArray);
 		validateIndex(sourceIndex, sourceField, "moveToStart");
 		this.moveRangeToIndex(0, sourceIndex, sourceIndex + 1, source);
 	}
-	public moveToEnd(sourceIndex: number, source?: ReadonlyArrayNode): void {
+	public moveToEnd(sourceIndex: number, source?: TreeArrayNode): void {
 		const sourceArray = source ?? this;
 		const sourceField = getSequenceField(sourceArray);
 		validateIndex(sourceIndex, sourceField, "moveToEnd");
@@ -932,7 +916,7 @@ abstract class CustomArrayNodeBase<const T extends ImplicitAllowedTypes>
 	public moveToIndex(
 		destinationGap: number,
 		sourceIndex: number,
-		source?: ReadonlyArrayNode,
+		source?: TreeArrayNode,
 	): void {
 		const sourceArray = source ?? this;
 		const sourceField = getSequenceField(sourceArray);
@@ -944,7 +928,7 @@ abstract class CustomArrayNodeBase<const T extends ImplicitAllowedTypes>
 	public moveRangeToStart(
 		sourceStart: number,
 		sourceEnd: number,
-		source?: ReadonlyArrayNode,
+		source?: TreeArrayNode,
 	): void {
 		validateIndexRange(
 			sourceStart,
@@ -954,11 +938,7 @@ abstract class CustomArrayNodeBase<const T extends ImplicitAllowedTypes>
 		);
 		this.moveRangeToIndex(0, sourceStart, sourceEnd, source);
 	}
-	public moveRangeToEnd(
-		sourceStart: number,
-		sourceEnd: number,
-		source?: ReadonlyArrayNode,
-	): void {
+	public moveRangeToEnd(sourceStart: number, sourceEnd: number, source?: TreeArrayNode): void {
 		validateIndexRange(
 			sourceStart,
 			sourceEnd,
@@ -971,7 +951,7 @@ abstract class CustomArrayNodeBase<const T extends ImplicitAllowedTypes>
 		destinationGap: number,
 		sourceStart: number,
 		sourceEnd: number,
-		source?: ReadonlyArrayNode,
+		source?: TreeArrayNode,
 	): void {
 		const destinationField = getSequenceField(this);
 		const destinationSchema = this.allowedTypes;

package/src/simple-tree/core/treeNodeSchema.ts

@@ -3,8 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import type { TreeLeafValue } from "../schemaTypes.js";
-import type { InternalTreeNode, TreeNode, Unhydrated } from "./types.js";
+import type { InternalTreeNode, Unhydrated } from "./types.js";
 
 /**
  * Schema for a tree node.
@@ -20,7 +19,7 @@ import type { InternalTreeNode, TreeNode, Unhydrated } from "./types.js";
 export type TreeNodeSchema<
 	Name extends string = string,
 	Kind extends NodeKind = NodeKind,
-	TNode extends TreeNode | TreeLeafValue = TreeNode | TreeLeafValue,
+	TNode = unknown,
 	TBuild = never,
 	ImplicitlyConstructable extends boolean = boolean,
 	Info = unknown,
@@ -39,7 +38,7 @@ export type TreeNodeSchema<
 export interface TreeNodeSchemaNonClass<
 	out Name extends string = string,
 	out Kind extends NodeKind = NodeKind,
-	out TNode extends TreeNode | TreeLeafValue = TreeNode | TreeLeafValue,
+	out TNode = unknown,
 	in TInsertable = never,
 	out ImplicitlyConstructable extends boolean = boolean,
 	out Info = unknown,
@@ -95,8 +94,7 @@ export interface TreeNodeSchemaNonClass<
 export interface TreeNodeSchemaClass<
 	out Name extends string = string,
 	out Kind extends NodeKind = NodeKind,
-	// TODO: maybe this can be more specific (exclude leaves)
-	out TNode extends TreeNode | TreeLeafValue = TreeNode | TreeLeafValue,
+	out TNode = unknown,
 	in TInsertable = never,
 	out ImplicitlyConstructable extends boolean = boolean,
 	out Info = unknown,
@@ -117,7 +115,7 @@ export interface TreeNodeSchemaClass<
 export type TreeNodeSchemaBoth<
 	Name extends string = string,
 	Kind extends NodeKind = NodeKind,
-	TNode extends TreeNode = TreeNode,
+	TNode = unknown,
 	TInsertable = never,
 	ImplicitlyConstructable extends boolean = boolean,
 	Info = unknown,

package/src/simple-tree/core/withType.ts

@@ -3,9 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import type { TreeLeafValue } from "../schemaTypes.js";
 import type { NodeKind, TreeNodeSchemaClass } from "./treeNodeSchema.js";
-import type { TreeNode } from "./types.js";
 
 /**
  * The type of a {@link TreeNode}.
@@ -89,12 +87,5 @@ export interface WithType<
 	/**
 	 * Type symbol, marking a type in a way to increase type safety via strong type checking.
 	 */
-	get [typeSchemaSymbol](): TreeNodeSchemaClass<
-		TName,
-		TKind,
-		TreeNode | TreeLeafValue,
-		never,
-		boolean,
-		TInfo
-	>;
+	get [typeSchemaSymbol](): TreeNodeSchemaClass<TName, TKind, unknown, never, boolean, TInfo>;
 }

package/src/simple-tree/index.ts

@@ -92,11 +92,6 @@ export {
 	type NodeBuilderDataUnsafe,
 	type NodeFromSchemaUnsafe,
 	type ReadonlyMapInlined,
-	type TreeNodeSchemaClassUnsafe,
-	type TreeNodeSchemaUnsafe,
-	type AllowedTypesUnsafe,
-	type TreeNodeSchemaNonClassUnsafe,
-	type TreeViewAlpha,
 } from "./api/index.js";
 export {
 	type NodeFromSchema,
@@ -118,9 +113,6 @@ export {
 	normalizeFieldSchema,
 	type ApplyKind,
 	type FieldSchemaMetadata,
-	type InsertableField,
-	type Insertable,
-	type UnsafeUnknownSchema,
 } from "./schemaTypes.js";
 export {
 	getTreeNodeForField,
@@ -130,7 +122,6 @@ export {
 	TreeArrayNode,
 	IterableTreeArrayContent,
 	type TreeArrayNodeBase,
-	type ReadonlyArrayNode,
 } from "./arrayNode.js";
 export {
 	type FieldHasDefault,
@@ -140,12 +131,7 @@ export {
 	setField,
 } from "./objectNode.js";
 export type { TreeMapNode, MapNodeInsertableData } from "./mapNode.js";
-export {
-	mapTreeFromNodeData,
-	type InsertableContent,
-	type FactoryContent,
-	type FactoryContentObject,
-} from "./toMapTree.js";
+export { mapTreeFromNodeData, type InsertableContent } from "./toMapTree.js";
 export { toStoredSchema, getStoredSchema } from "./toFlexSchema.js";
 export {
 	numberSchema,