@fluidframework/tree 2.1.0 → 2.3.0-288113

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

@@ -0,0 +1,89 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import type { NodeKind, TreeNodeSchemaClass } from "./treeNodeSchema.js";
+
+/**
+ * The type of a {@link TreeNode}.
+ * For more information about the type, use `Tree.schema(theNode)` instead.
+ * @remarks
+ * This symbol mainly exists on nodes to allow TypeScript to provide more accurate type checking.
+ * `Tree.is` and `Tree.schema` provide a superset of this information in more friendly ways.
+ *
+ * This symbol should not manually be added to objects as doing so allows the object to be invalidly used where nodes are expected.
+ * Instead construct a real node of the desired type using its constructor.
+ * @privateRemarks
+ * This prevents non-nodes from being accidentally used as nodes, as well as allows the type checker to distinguish different node types.
+ * @deprecated External code should use `Tree.schema(theNode)` for schema related runtime data access. For type narrowing, use `WithType` instead of the symbols directly.
+ * @system @public
+ */
+export const typeNameSymbol: unique symbol = Symbol("TreeNode Type");
+
+/**
+ * The type of a {@link TreeNode}.
+ * For more information about the type, use `Tree.schema(theNode)` instead.
+ * @remarks
+ * This symbol mainly exists on nodes to allow TypeScript to provide more accurate type checking.
+ * `Tree.is` and `Tree.schema` provide a superset of this information in more friendly ways.
+ *
+ * This symbol should not manually be added to objects as doing so allows the object to be invalidly used where specific nodes are expected.
+ * Instead construct a real node of the desired type using its constructor.
+ *
+ * This symbol should not be used directly for type narrowing. Instead use {@link WithType}.
+ * @privateRemarks
+ * This prevents non-nodes from being accidentally used as nodes and allows the type-checker to distinguish different node types.
+ * @system @public
+ */
+export const typeSchemaSymbol: unique symbol = Symbol("TreeNode Schema");
+
+/**
+ * Adds a type symbol to a type for stronger typing.
+ *
+ * @typeParam TName - Same as {@link TreeNodeSchema}'s "Name" parameter.
+ * @typeParam TKind - Same as {@link TreeNodeSchema}'s "Kind" parameter.
+ * @remarks
+ * Powers {@link TreeNode}'s strong typing setup.
+ * @example Narrow types for overloading based on NodeKind
+ * ```typescript
+ * function getKeys(node: TreeNode & WithType<string, NodeKind.Array>): number[];
+ * function getKeys(node: TreeNode & WithType<string, NodeKind.Map | NodeKind.Object>): string[];
+ * function getKeys(node: TreeNode): string[] | number[];
+ * function getKeys(node: TreeNode): string[] | number[] {
+ * 	const schema = Tree.schema(node);
+ * 	switch (schema.kind) {
+ * 		case NodeKind.Array: {
+ * 			const arrayNode = node as TreeArrayNode;
+ * 			const keys: number[] = [];
+ * 			for (let index = 0; index < arrayNode.length; index++) {
+ * 				keys.push(index);
+ * 			}
+ * 			return keys;
+ * 		}
+ * 		case NodeKind.Map:
+ * 			return [...(node as TreeMapNode).keys()];
+ * 		case NodeKind.Object:
+ * 			return Object.keys(node);
+ * 		default:
+ * 			throw new Error("Unsupported Kind");
+ * 	}
+ * }
+ * ```
+ * @sealed @public
+ */
+export interface WithType<
+	out TName extends string = string,
+	out TKind extends NodeKind = NodeKind,
+> {
+	/**
+	 * Type symbol, marking a type in a way to increase type safety via strong type checking.
+	 * @deprecated Use {@link typeSchemaSymbol} instead.
+	 */
+	get [typeNameSymbol](): TName;
+
+	/**
+	 * Type symbol, marking a type in a way to increase type safety via strong type checking.
+	 */
+	get [typeSchemaSymbol](): TreeNodeSchemaClass<TName, TKind>;
+}

package/src/simple-tree/getJsonSchema.ts

@@ -0,0 +1,70 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import type { JsonTreeSchema } from "./jsonSchema.js";
+import type { ImplicitAllowedTypes } from "./schemaTypes.js";
+import { toJsonSchema } from "./simpleSchemaToJsonSchema.js";
+import { getSimpleSchema } from "./getSimpleSchema.js";
+import { getOrCreate } from "../util/index.js";
+import type { TreeNodeSchema } from "./core/index.js";
+
+/**
+ * Cache in which the results of {@link getJsonSchema} are saved.
+ */
+const jsonSchemaCache = new WeakMap<TreeNodeSchema, JsonTreeSchema>();
+
+/**
+ * Creates a {@link https://json-schema.org/ | JSON Schema} representation of the provided {@link TreeNodeSchema}.
+ *
+ * @remarks
+ * Useful when communicating the schema to external libraries or services.
+ * Caches the result for future calls.
+ *
+ * @example
+ *
+ * A Shared Tree schema like the following:
+ *
+ * ```typescript
+ * class MyObject extends schemaFactory.object("MyObject", {
+ * 	foo: schemaFactory.number,
+ * 	bar: schemaFactory.optional(schemaFactory.string),
+ * });
+ * ```
+ *
+ * Will yield JSON Schema like the following:
+ *
+ * ```json
+ * {
+ * 	"$defs": {
+ * 		"com.fluidframework.leaf.string": {
+ * 			"type": "string",
+ * 		},
+ * 		"com.fluidframework.leaf.number": {
+ * 			"type": "number",
+ * 		},
+ * 		"com.myapp.MyObject": {
+ * 			"type": "object",
+ * 			"properties": {
+ * 				"foo": { "$ref": "com.fluidframework.leaf.number" },
+ * 				"bar": { "$ref": "com.fluidframework.leaf.string" },
+ * 			},
+ * 			"required": ["foo"],
+ * 		},
+ * 	},
+ * 	"anyOf": [ { "$ref": "#/$defs/com.myapp.MyObject" } ],
+ * }
+ * ```
+ *
+ * @privateRemarks In the future, we may wish to move this to a more discoverable API location.
+ * For now, while still an experimental API, it is surfaced as a free function.
+ *
+ * @alpha
+ */
+export function getJsonSchema(schema: ImplicitAllowedTypes): JsonTreeSchema {
+	return getOrCreate(jsonSchemaCache, schema, () => {
+		const simpleSchema = getSimpleSchema(schema);
+		return toJsonSchema(simpleSchema);
+	});
+}

package/src/simple-tree/getSimpleFieldSchema.ts

@@ -0,0 +1,36 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import type { FlexFieldSchema } from "../feature-libraries/index.js";
+import {
+	type ImplicitFieldSchema,
+	type FieldSchema,
+	normalizeFieldSchema,
+} from "./schemaTypes.js";
+
+/**
+ * A symbol for storing {@link FieldSchema}s on a {@link FlexFieldSchema}.
+ */
+const simpleFieldSchemaSymbol: unique symbol = Symbol(`simpleFieldSchema`);
+
+/**
+ * Gets the {@link FieldSchema} which corresponds with the provided {@link FlexFieldSchema | flexSchema}.
+ * Caches the result on the provided `flexSchema` for future access.
+ * @param flexSchema - The flex schema on which the result will be cached.
+ * @param implicitSimpleSchema - The allowed types from which the `FieldSchema` will be derived.
+ */
+export function getSimpleFieldSchema(
+	flexSchema: FlexFieldSchema,
+	implicitSimpleSchema: ImplicitFieldSchema,
+): FieldSchema {
+	if (simpleFieldSchemaSymbol in flexSchema) {
+		return flexSchema[simpleFieldSchemaSymbol] as FieldSchema;
+	}
+
+	const fieldSchema = normalizeFieldSchema(implicitSimpleSchema);
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	(flexSchema as any)[simpleFieldSchemaSymbol] = fieldSchema;
+	return fieldSchema;
+}

package/src/simple-tree/getSimpleSchema.ts

@@ -0,0 +1,69 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { getOrCreate } from "../util/index.js";
+import type { TreeNodeSchema } from "./core/index.js";
+import type { ImplicitAllowedTypes } from "./schemaTypes.js";
+import type { SimpleTreeSchema } from "./simpleSchema.js";
+import { toSimpleTreeSchema } from "./viewSchemaToSimpleSchema.js";
+
+/**
+ * Cache in which the results of {@link getSimpleSchema} saved.
+ */
+const simpleSchemaCache = new WeakMap<TreeNodeSchema, SimpleTreeSchema>();
+
+/**
+ * Creates a simplified representation of the provided {@link TreeNodeSchema}.
+ *
+ * @remarks Caches the result on the input schema for future calls.
+ *
+ * @example
+ *
+ * A Shared Tree schema like the following:
+ *
+ * ```typescript
+ * class MyObject extends schemaFactory.object("MyObject", {
+ * 	foo: schemaFactory.number,
+ * 	bar: schemaFactory.optional(schemaFactory.string),
+ * });
+ * ```
+ *
+ * Will yield JSON Schema like the following:
+ *
+ * ```typescript
+ * {
+ * 	definitions: [
+ * 		["com.fluidframework.leaf.number", {
+ * 			kind: "leaf",
+ * 			type: "number",
+ * 		}],
+ * 		["com.fluidframework.leaf.string", {
+ * 			kind: "leaf",
+ * 			type: "string",
+ * 		}],
+ * 		["com.myapp.MyObject", {
+ * 			kind: "object",
+ * 			fields: {
+ * 				foo: {
+ * 					kind: "required",
+ * 					allowedTypes: ["com.fluidframework.leaf.number"]
+ * 				},
+ * 				bar: {
+ * 					kind: "optional",
+ * 					allowedTypes: ["com.fluidframework.leaf.string"]
+ * 				},
+ * 			},
+ * 		}],
+ * 	],
+ * 	allowedTypes: ["com.myapp.MyObject"],
+ * }
+ * ```
+ *
+ * @privateRemarks In the future, we may wish to move this to a more discoverable API location.
+ * For now, while still an experimental API, it is surfaced as a free function.
+ */
+export function getSimpleSchema(schema: ImplicitAllowedTypes): SimpleTreeSchema {
+	return getOrCreate(simpleSchemaCache, schema, () => toSimpleTreeSchema(schema));
+}

package/src/simple-tree/index.ts

@@ -3,6 +3,24 @@
  * Licensed under the MIT License.
  */
 
+export {
+	typeNameSymbol,
+	typeSchemaSymbol,
+	type WithType,
+	type TreeNodeSchema,
+	NodeKind,
+	type TreeNodeSchemaClass,
+	type TreeNodeSchemaNonClass,
+	type TreeNodeSchemaCore,
+	type TreeChangeEvents,
+	// TreeNode is only type exported, which prevents use of the class object for unsupported use-cases like direct sub-classing and instanceof.
+	// See docs on TreeNode for more details.
+	type TreeNode,
+	type Unhydrated,
+	type InternalTreeNode,
+	isTreeNode,
+	type NodeChangedData,
+} from "./core/index.js";
 export {
 	type ITree,
 	type TreeView,
@@ -11,22 +29,32 @@ export {
 	type ITreeViewConfiguration,
 	type SchemaCompatibilityStatus,
 	type ITreeConfigurationOptions,
-} from "./tree.js";
+	SchemaFactory,
+	type ScopedSchemaName,
+	type ValidateRecursiveSchema,
+	type FixRecursiveArraySchema,
+	adaptEnum,
+	enumFromStrings,
+	singletonSchema,
+	typedObjectValues,
+	type EmptyObject,
+	test_RecursiveObject,
+	test_RecursiveObject_base,
+	test_RecursiveObjectPojoMode,
+	treeNodeApi,
+	type TreeNodeApi,
+	cursorFromInsertable,
+	createFromInsertable,
+} from "./api/index.js";
 export {
-	type TreeNodeSchema,
 	type NodeFromSchema,
-	NodeKind,
-	type TreeNodeSchemaClass,
-	type TreeNodeSchemaNonClass,
-	type TreeNodeSchemaCore,
+	isTreeNodeSchemaClass,
 	type ImplicitFieldSchema,
 	type TreeFieldFromImplicitField,
 	type ImplicitAllowedTypes,
 	type TreeNodeFromImplicitAllowedTypes,
 	type InsertableTreeNodeFromImplicitAllowedTypes,
 	type TreeLeafValue,
-	typeNameSymbol,
-	type WithType,
 	type AllowedTypes,
 	FieldKind,
 	FieldSchema,
@@ -38,10 +66,8 @@ export {
 	normalizeFieldSchema,
 	type ApplyKind,
 } from "./schemaTypes.js";
-export { SchemaFactory, type ScopedSchemaName } from "./schemaFactory.js";
-export { getFlexNode, tryDisposeTreeNode } from "./proxyBinding.js";
-export { treeNodeApi, type TreeNodeApi } from "./treeNodeApi.js";
-export { toFlexSchema, cursorFromUnhydratedRoot } from "./toFlexSchema.js";
+export { getOrCreateInnerNode, tryDisposeTreeNode } from "./proxyBinding.js";
+export { toFlexSchema } from "./toFlexSchema.js";
 export type {
 	FieldHasDefaultUnsafe,
 	ObjectFromSchemaRecordUnsafe,
@@ -57,32 +83,14 @@ export type {
 	InsertableTypedNodeUnsafe,
 	NodeBuilderDataUnsafe,
 	NodeFromSchemaUnsafe,
+	ReadonlyMapInlined,
 } from "./typesUnsafe.js";
-export type { ValidateRecursiveSchema } from "./schemaFactoryRecursive.js";
 export {
-	getProxyForField,
+	getTreeNodeForField,
 	type InsertableContent,
 	prepareContentForHydration,
 } from "./proxies.js";
 
-export {
-	adaptEnum,
-	enumFromStrings,
-	singletonSchema,
-	typedObjectValues,
-} from "./schemaCreationUtilities.js";
-
-// Exporting the schema (RecursiveObject) to test that recursive types are working correctly.
-// These are `@internal` so they can't be included in the `InternalClassTreeTypes` due to https://github.com/microsoft/rushstack/issues/3639
-export {
-	RecursiveObject as test_RecursiveObject,
-	base as test_RecursiveObject_base,
-	RecursiveObjectPojoMode as test_RecursiveObjectPojoMode,
-} from "./testRecursiveDomain.js";
-
-// TreeNode is only type exported, which prevents use of the class object for unsupported use-cases like direct sub-classing and instancof.
-// See docs on TreeNode for more details.
-export type { TreeChangeEvents, TreeNode, Unhydrated, InternalTreeNode } from "./types.js";
 export {
 	TreeArrayNode,
 	IterableTreeArrayContent,
@@ -95,5 +103,23 @@ export {
 	type TreeObjectNode,
 	setField,
 } from "./objectNode.js";
-export type { TreeMapNode } from "./mapNode.js";
+export type { TreeMapNode, MapNodeInsertableData } from "./mapNode.js";
 export { mapTreeFromNodeData } from "./toMapTree.js";
+export type { SimpleTreeSchema } from "./simpleSchema.js";
+export {
+	type JsonSchemaId,
+	type JsonSchemaType,
+	type JsonObjectNodeSchema,
+	type JsonArrayNodeSchema,
+	type JsonMapNodeSchema,
+	type JsonLeafNodeSchema,
+	type JsonSchemaRef,
+	type JsonRefPath,
+	type JsonNodeSchema,
+	type JsonNodeSchemaBase,
+	type JsonTreeSchema,
+	type JsonFieldSchema,
+	type JsonLeafSchemaType,
+} from "./jsonSchema.js";
+export { getJsonSchema } from "./getJsonSchema.js";
+export { getSimpleSchema } from "./getSimpleSchema.js";

package/src/simple-tree/jsonSchema.ts

@@ -0,0 +1,230 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import type { NodeKind } from "./core/index.js";
+
+/**
+ * The fully-qualified {@link TreeNodeSchemaCore.identifier}.
+ * @alpha
+ */
+export type JsonSchemaId = string;
+
+/**
+ * Reference string pointing to a definition in the schema.
+ * Should be the fully-qualified {@link TreeNodeSchemaCore.identifier}.
+ * @remarks Of the form `#/$defs/<schema-identifier>`, where the `schema-identifier` is the fully-qualified {@link TreeNodeSchemaCore.identifier}.
+ * @example Schema `com.myapp.foo` would be referenced via `#/$defs/com.myapp.foo`.
+ * @alpha
+ */
+export type JsonRefPath = `#/$defs/${JsonSchemaId}`;
+
+/**
+ * JSON entity type.
+ * @see {@link https://json-schema.org/draft/2020-12/json-schema-core#name-instance-data-model}.
+ * @alpha
+ */
+export type JsonSchemaType = "object" | "array" | JsonLeafSchemaType;
+
+/**
+ * JSON primitive types.
+ * @see {@link https://json-schema.org/draft/2020-12/json-schema-core#name-instance-data-model}.
+ * @alpha
+ */
+export type JsonLeafSchemaType = "string" | "number" | "boolean" | "null";
+
+/**
+ * Base interface for node schemas represented in {@link https://json-schema.org/draft/2020-12/json-schema-core | JSON Schema} format.
+ *
+ * @sealed
+ * @alpha
+ */
+export interface JsonNodeSchemaBase<
+	TNodeKind extends NodeKind,
+	TJsonSchemaType extends JsonSchemaType,
+> {
+	/**
+	 * Kind of {@link TreeNodeSchema} this JSON Schema entry represents.
+	 *
+	 * @remarks There is not a 1:1 mapping between {@link TreeNodeSchema} types and JSON Schema types.
+	 * This is used to disambiguate the type of {@link TreeNodeSchema} this JSON Schema maps to.
+	 *
+	 * Note: This property name is not a part of the JSON Schema spec. This is a Fluid-specific extension.
+	 */
+	readonly _treeNodeSchemaKind: TNodeKind;
+
+	/**
+	 * {@inheritDoc JsonSchemaType}
+	 */
+	readonly type: TJsonSchemaType;
+}
+
+/**
+ * JSON Schema for an object node.
+ *
+ * @see {@link https://json-schema.org/draft/2020-12/json-schema-core#name-instance-data-model}.
+ *
+ * @sealed
+ * @alpha
+ */
+export interface JsonObjectNodeSchema extends JsonNodeSchemaBase<NodeKind.Object, "object"> {
+	/**
+	 * Object fields.
+	 * @remarks Required fields should have a corresponding entry in {@link JsonObjectNodeSchema.required}.
+	 * @see {@link https://json-schema.org/draft/2020-12/json-schema-core#name-properties}.
+	 */
+	readonly properties: Record<string, JsonFieldSchema>;
+
+	/**
+	 * List of keys for required fields.
+	 *
+	 * @remarks
+	 * Optional fields should not be included in this list.
+	 * Each key specified must have an entry in {@link JsonObjectNodeSchema.properties}.
+	 */
+	readonly required?: string[];
+
+	/**
+	 * Whether or not additional properties (properties not specified by the schema) are allowed in objects of this type.
+	 * @see {@link https://json-schema.org/draft/2020-12/json-schema-core#name-additionalproperties}.
+	 */
+	readonly additionalProperties?: boolean;
+}
+
+/**
+ * JSON Schema for an array node.
+ *
+ * @see {@link https://json-schema.org/draft/2020-12/json-schema-core#name-instance-data-model}.
+ *
+ * @sealed
+ * @alpha
+ */
+export interface JsonArrayNodeSchema extends JsonNodeSchemaBase<NodeKind.Array, "array"> {
+	/**
+	 * The kinds of items allowed under the array.
+	 * @remarks Always represented via references to {@link JsonTreeSchema.$defs}.
+	 *
+	 * @see {@link https://json-schema.org/draft/2020-12/json-schema-core#name-items}.
+	 */
+	readonly items: {
+		/**
+		 * The kinds of items allowed under the array.
+		 * @remarks Always represented via references to {@link JsonTreeSchema.$defs}.
+		 * @see {@link https://json-schema.org/draft/2020-12/json-schema-core#name-anyof}.
+		 */
+		anyOf: JsonSchemaRef[];
+	};
+}
+
+/**
+ * JSON Schema for a map node.
+ *
+ * @remarks Special case for map nodes, which do not have a native JSON schema corollary.
+ *
+ * @see {@link https://json-schema.org/draft/2020-12/json-schema-core#name-instance-data-model}.
+ *
+ * @sealed
+ * @alpha
+ */
+export interface JsonMapNodeSchema extends JsonNodeSchemaBase<NodeKind.Map, "object"> {
+	/**
+	 * Used to control the types of properties that can appear in the "object" representation of the map.
+	 * @see {@link https://json-schema.org/draft/2020-12/json-schema-core#name-patternproperties}.
+	 */
+	readonly patternProperties: {
+		/**
+		 * Types allowed in the map.
+		 * @remarks This format allows for any (JSON-compliant) key, but restricts the allowed types to only those specified.
+		 */
+		"^.*$": JsonFieldSchema;
+	};
+}
+
+/**
+ * JSON Schema for a leaf node.
+ *
+ * @see {@link https://json-schema.org/draft/2020-12/json-schema-core#name-instance-data-model}.
+ *
+ * @sealed
+ * @alpha
+ */
+export interface JsonLeafNodeSchema
+	extends JsonNodeSchemaBase<NodeKind.Leaf, JsonLeafSchemaType> {
+	/**
+	 * Primitive type.
+	 * @see {@link https://json-schema.org/draft/2020-12/json-schema-core#name-instance-data-model}.
+	 */
+	readonly type: JsonLeafSchemaType;
+}
+
+/**
+ * Type entry containing a reference to a definition in the schema.
+ *
+ * @see {@link https://json-schema.org/draft/2020-12/json-schema-core#name-schema-references}.
+ *
+ * @sealed
+ * @alpha
+ */
+export interface JsonSchemaRef {
+	/**
+	 * Reference to a definition in the schema.
+	 * @see {@link https://json-schema.org/draft/2020-12/json-schema-core#name-direct-references-with-ref}.
+	 */
+	$ref: JsonRefPath;
+}
+
+/**
+ * {@link https://json-schema.org/draft/2020-12/json-schema-core | JSON Schema} representation of a {@link TreeNodeSchema}.
+ *
+ * @alpha
+ */
+export type JsonNodeSchema =
+	| JsonLeafNodeSchema
+	| JsonMapNodeSchema
+	| JsonArrayNodeSchema
+	| JsonObjectNodeSchema;
+
+/**
+ *{@link https://json-schema.org/draft/2020-12/json-schema-core | JSON Schema} representation of a {@link FieldSchema}.
+ *
+ * @sealed
+ * @alpha
+ */
+export interface JsonFieldSchema {
+	/**
+	 * The kinds of items allowed under the field.
+	 * @remarks Always represented via references to {@link JsonTreeSchema.$defs}.
+	 * @see {@link https://json-schema.org/draft/2020-12/json-schema-core#name-anyof}.
+	 */
+	readonly anyOf: JsonSchemaRef[];
+}
+
+/**
+ * {@link https://json-schema.org/draft/2020-12/json-schema-core | JSON Schema} representation of a tree schema.
+ *
+ * @remarks
+ * Includes the complete set of definitions reachable from the "root" schema.
+ *
+ * Note: This representation only uses a limited subset of supported JSON Schema features.
+ * It is scoped to a format that can be used to sufficiently represent supported SharedTree schema.
+ *
+ * Also note that this schema format contains Fluid-specific extensions, such as the {@link JsonNodeSchemaBase._treeNodeSchemaKind}
+ * property, meaning that it is not a *strict* subset.
+ * When using these schemas with validation tools (for example, {@link https://ajv.js.org/}), you will need to opt out
+ * of *strict* validation to ensure extra properties are allowed.
+ *
+ * @privateRemarks
+ * Extending JSON Schema is permitted by the spec.
+ * See {@link https://json-schema.org/draft/2020-12/json-schema-core#name-extending-json-schema}.
+ *
+ * @sealed
+ * @alpha
+ */
+export interface JsonTreeSchema extends JsonFieldSchema {
+	/**
+	 * The set of definitions reachable from this schema's root.
+	 * @see {@link https://json-schema.org/draft/2020-12/json-schema-core#name-schema-re-use-with-defs}
+	 */
+	readonly $defs: Record<JsonSchemaId, JsonNodeSchema>;
+}

package/src/simple-tree/leafNodeSchema.ts

@@ -13,9 +13,12 @@ import {
 	isFlexTreeNode,
 	valueSchemaAllows,
 } from "../feature-libraries/index.js";
-
-import { setFlexSchemaFromClassSchema } from "./schemaCaching.js";
-import { NodeKind, type TreeNodeSchema, type TreeNodeSchemaNonClass } from "./schemaTypes.js";
+import {
+	setFlexSchemaFromClassSchema,
+	NodeKind,
+	type TreeNodeSchema,
+	type TreeNodeSchemaNonClass,
+} from "./core/index.js";
 
 type UnbrandedName<T extends FlexLeafNodeSchema> = T["name"] extends TreeNodeSchemaIdentifier<
 	infer Name extends string