@fluidframework/tree 2.43.0 → 2.50.0

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

@@ -3,7 +3,13 @@
  * Licensed under the MIT License.
  */
 
-import { assert, debugAssert, fail } from "@fluidframework/core-utils/internal";
+import {
+	assert,
+	debugAssert,
+	fail,
+	oob,
+	unreachableCase,
+} from "@fluidframework/core-utils/internal";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 
 import {
@@ -17,8 +23,16 @@ import {
 } from "../schemaTypes.js";
 import { NodeKind, type TreeNodeSchema } from "../core/index.js";
 import { toStoredSchema } from "../toStoredSchema.js";
-import { LeafNodeSchema } from "../leafNodeSchema.js";
-import { isObjectNodeSchema, type ObjectNodeSchema } from "../node-kinds/index.js";
+import {
+	isArrayNodeSchema,
+	isMapNodeSchema,
+	isObjectNodeSchema,
+	isRecordNodeSchema,
+	type ArrayNodeSchema,
+	type MapNodeSchema,
+	type ObjectNodeSchema,
+	type RecordNodeSchema,
+} from "../node-kinds/index.js";
 import { getOrCreate } from "../../util/index.js";
 import type { MakeNominal } from "../../util/index.js";
 import { walkFieldSchema } from "../walkFieldSchema.js";
@@ -293,10 +307,11 @@ export function checkUnion(
 	ambiguityErrors: string[],
 ): void {
 	const checked: Set<TreeNodeSchema> = new Set();
-	const maps: TreeNodeSchema[] = [];
-	const arrays: TreeNodeSchema[] = [];
-
+	const maps: MapNodeSchema[] = [];
+	const arrays: ArrayNodeSchema[] = [];
+	const records: RecordNodeSchema[] = [];
 	const objects: ObjectNodeSchema[] = [];
+
 	// Map from key to schema using that key
 	const allObjectKeys: Map<string, Set<TreeNodeSchema>> = new Map();
 
@@ -306,18 +321,37 @@ export function checkUnion(
 		}
 		checked.add(schema);
 
-		if (schema instanceof LeafNodeSchema) {
-			// nothing to do
-		} else if (isObjectNodeSchema(schema)) {
-			objects.push(schema);
-			for (const key of schema.fields.keys()) {
-				getOrCreate(allObjectKeys, key, () => new Set()).add(schema);
+		switch (schema.kind) {
+			case NodeKind.Leaf: {
+				// nothing to do
+				break;
+			}
+			case NodeKind.Object: {
+				assert(isObjectNodeSchema(schema), 0xbde /* Expected object schema. */);
+				objects.push(schema);
+				for (const key of schema.fields.keys()) {
+					getOrCreate(allObjectKeys, key, () => new Set()).add(schema);
+				}
+				break;
+			}
+			case NodeKind.Array: {
+				assert(isArrayNodeSchema(schema), 0xbdf /* Expected array schema. */);
+				arrays.push(schema);
+				break;
+			}
+			case NodeKind.Map: {
+				assert(isMapNodeSchema(schema), 0xbe0 /* Expected map schema. */);
+				maps.push(schema);
+				break;
+			}
+			case NodeKind.Record: {
+				assert(isRecordNodeSchema(schema), 0xbe1 /* Expected record schema. */);
+				records.push(schema);
+				break;
+			}
+			default: {
+				unreachableCase(schema.kind);
 			}
-		} else if (schema.kind === NodeKind.Array) {
-			arrays.push(schema);
-		} else {
-			assert(schema.kind === NodeKind.Map, 0x9e7 /* invalid schema */);
-			maps.push(schema);
 		}
 	}
 
@@ -338,15 +372,35 @@ export function checkUnion(
 		);
 	}
 
+	if (records.length > 1) {
+		ambiguityErrors.push(
+			`More than one kind of record allowed within union (${formatTypes(records)}). This would require type disambiguation which is not supported by records during import or export.`,
+		);
+	}
+
 	if (maps.length > 0 && arrays.length > 0) {
 		ambiguityErrors.push(
 			`Both a map and an array allowed within union (${formatTypes([...arrays, ...maps])}). Both can be implicitly constructed from iterables like arrays, which are ambiguous when the array is empty.`,
 		);
 	}
 
-	if (objects.length > 0 && maps.length > 0) {
+	const nodeKindListEntries = [];
+	if (objects.length > 0) {
+		nodeKindListEntries.push("objects");
+	}
+	if (maps.length > 0) {
+		nodeKindListEntries.push("maps");
+	}
+	if (records.length > 0) {
+		nodeKindListEntries.push("records");
+	}
+	if (nodeKindListEntries.length > 1) {
+		const nodeKindListString =
+			nodeKindListEntries.length === 2
+				? `${nodeKindListEntries[0] ?? oob()} and ${nodeKindListEntries[1] ?? oob()}`
+				: `${nodeKindListEntries.slice(0, -1).join(", ")}, and ${nodeKindListEntries[nodeKindListEntries.length - 1]}`;
 		ambiguityErrors.push(
-			`Both a object and a map allowed within union (${formatTypes([...objects, ...maps])}). Both can be constructed from objects and can be ambiguous.`,
+			`A combination of ${nodeKindListString} is allowed within union (${formatTypes([...objects, ...maps, ...records])}). These can be constructed from objects and can be ambiguous.`,
 		);
 	}
 

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

@@ -22,7 +22,7 @@ import {
 } from "../../core/index.js";
 import { FieldKinds, valueSchemaAllows } from "../../feature-libraries/index.js";
 import { cloneWithReplacements } from "../../util/index.js";
-import { NodeKind, type TreeNodeSchema } from "../core/index.js";
+import type { TreeNodeSchema } from "../core/index.js";
 import {
 	booleanSchema,
 	handleSchema,
@@ -30,7 +30,7 @@ import {
 	numberSchema,
 	stringSchema,
 } from "../leafNodeSchema.js";
-import { isObjectNodeSchema } from "../node-kinds/index.js";
+import { isArrayNodeSchema, isObjectNodeSchema } from "../node-kinds/index.js";
 import type { TreeLeafValue } from "../schemaTypes.js";
 
 /**
@@ -106,7 +106,7 @@ export function customFromCursor<TChild>(
 			return reader.value;
 		default: {
 			assert(reader.value === undefined, 0xa54 /* out of schema: unexpected value */);
-			if (nodeSchema.kind === NodeKind.Array) {
+			if (isArrayNodeSchema(nodeSchema)) {
 				const fields = inCursorField(reader, EmptyKey, () =>
 					mapCursorField(reader, () => childHandler(reader, options, schema)),
 				);

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

@@ -67,6 +67,8 @@ export {
 	type JsonTreeSchema,
 	type JsonFieldSchema,
 	type JsonLeafSchemaType,
+	type JsonRecordNodeSchema,
+	type JsonStringKeyPatternProperties,
 } from "./jsonSchema.js";
 export type { TreeSchemaEncodingOptions } from "./getJsonSchema.js";
 export { getJsonSchema } from "./getJsonSchema.js";
@@ -78,6 +80,7 @@ export type {
 	ArrayNodeCustomizableSchemaUnsafe,
 	MapNodeCustomizableSchemaUnsafe,
 	System_Unsafe,
+	TreeRecordNodeUnsafe,
 } from "./typesUnsafe.js";
 
 export {

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

@@ -116,6 +116,22 @@ export interface JsonArrayNodeSchema extends JsonNodeSchemaBase<NodeKind.Array,
 	readonly items: JsonFieldSchema;
 }
 
+/**
+ * Types allowed in map / record nodes.
+ *
+ * @see {@link https://json-schema.org/draft/2020-12/json-schema-core#name-patternproperties}.
+ *
+ * @sealed
+ * @alpha
+ */
+export interface JsonStringKeyPatternProperties {
+	/**
+	 * This format allows for any string key that can appear in tree schema in a way that is JSON schema compatible,
+	 * but restricts the value to the specified allowed types of the value to only those specified.
+	 */
+	"^.*$": JsonFieldSchema;
+}
+
 /**
  * JSON Schema for a map node.
  *
@@ -131,13 +147,23 @@ export interface JsonMapNodeSchema extends JsonNodeSchemaBase<NodeKind.Map, "obj
 	 * 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;
-	};
+	readonly patternProperties: JsonStringKeyPatternProperties;
+}
+
+/**
+ * JSON Schema for a record node.
+ *
+ * @see {@link https://json-schema.org/draft/2020-12/json-schema-core#name-instance-data-model}.
+ *
+ * @sealed
+ * @alpha
+ */
+export interface JsonRecordNodeSchema extends JsonNodeSchemaBase<NodeKind.Record, "object"> {
+	/**
+	 * Used to control the types of properties that can appear in the "object" representation of the record.
+	 * @see {@link https://json-schema.org/draft/2020-12/json-schema-core#name-patternproperties}.
+	 */
+	readonly patternProperties: JsonStringKeyPatternProperties;
 }
 
 /**
@@ -182,7 +208,8 @@ export type JsonNodeSchema =
 	| JsonLeafNodeSchema
 	| JsonMapNodeSchema
 	| JsonArrayNodeSchema
-	| JsonObjectNodeSchema;
+	| JsonObjectNodeSchema
+	| JsonRecordNodeSchema;
 
 /**
  *{@link https://json-schema.org/draft/2020-12/json-schema-core | JSON Schema} representation of a {@link FieldSchema}.

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

@@ -776,16 +776,8 @@ export class SchemaFactory<
 		if (allowedTypes === undefined) {
 			const types = nameOrAllowedTypes as (T & TreeNodeSchema) | readonly TreeNodeSchema[];
 			const fullName = structuralName("Map", types);
-			return this.getStructuralType(
-				fullName,
-				types,
-				() =>
-					this.namedMap(
-						fullName as TName,
-						nameOrAllowedTypes as T,
-						false,
-						true,
-					) as TreeNodeSchema,
+			return this.getStructuralType(fullName, types, () =>
+				this.namedMap(fullName, nameOrAllowedTypes as T, false, true),
 			) as TreeNodeSchemaBoth<
 				string,
 				NodeKind.Map,
@@ -796,7 +788,7 @@ export class SchemaFactory<
 				undefined
 			>;
 		}
-		// To actually have type safety, assign to the type this method should return before implicitly upcasting when returning.
+		// To actually have type safety, assign to the type this method should return before implicitly up-casting when returning.
 		const out: TreeNodeSchemaBoth<
 			string,
 			NodeKind.Map,
@@ -895,7 +887,7 @@ export class SchemaFactory<
 	 * ```
 	 * @privateRemarks
 	 * The name produced at the type level here is not as specific as it could be, however doing type level sorting and escaping is a real mess.
-	 * There are cases where not having this full type provided will be less than ideal since TypeScript's structural types.
+	 * There are cases where not having this full type provided will be less than ideal, since TypeScript's structural types will allow assignment between runtime incompatible types at compile time.
 	 * For example attempts to narrow unions of structural arrays by name won't work.
 	 * Planned future changes to move to a class based schema system as well as factor function based node construction should mostly avoid these issues,
 	 * though there may still be some problematic cases even after that work is done.
@@ -997,7 +989,7 @@ export class SchemaFactory<
 	 * @returns The structural {@link TreeNodeSchema} associated with the given name and types.
 	 * @throws `UsageError` if a schema structurally named schema with the same name is cached in `structuralTypes` but had different input types.
 	 */
-	private getStructuralType(
+	protected getStructuralType(
 		fullName: string,
 		types: TreeNodeSchema | readonly TreeNodeSchema[],
 		builder: () => TreeNodeSchema,

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

@@ -10,11 +10,16 @@ import {
 	mapSchema,
 	type ObjectNodeSchema,
 	objectSchema,
+	type RecordNodeCustomizableSchema,
+	type RecordNodeInsertableData,
+	recordSchema,
+	type TreeRecordNode,
 } from "../node-kinds/index.js";
 import {
 	defaultSchemaFactoryObjectOptions,
 	SchemaFactory,
 	schemaStatics,
+	structuralName,
 	type SchemaFactoryObjectOptions,
 	type ScopedSchemaName,
 } from "./schemaFactory.js";
@@ -26,11 +31,19 @@ import type {
 	NodeSchemaOptionsAlpha,
 } from "../schemaTypes.js";
 import type { RestrictiveStringRecord } from "../../util/index.js";
-import type { NodeKind, TreeNodeSchemaClass } from "../core/index.js";
+import type {
+	NodeKind,
+	TreeNodeSchema,
+	TreeNodeSchemaBoth,
+	TreeNodeSchemaClass,
+	TreeNodeSchemaNonClass,
+	WithType,
+} from "../core/index.js";
 import type {
 	ArrayNodeCustomizableSchemaUnsafe,
 	MapNodeCustomizableSchemaUnsafe,
 	System_Unsafe,
+	TreeRecordNodeUnsafe,
 } from "./typesUnsafe.js";
 import type { SimpleObjectNodeSchema } from "../simpleSchema.js";
 
@@ -307,6 +320,260 @@ export class SchemaFactoryAlpha<
 		>;
 	}
 
+	/**
+	 * Define a structurally typed {@link TreeNodeSchema} for a {@link (TreeRecordNode:interface)}.
+	 *
+	 * @param allowedTypes - The types that may appear in the record.
+	 *
+	 * @remarks
+	 * The identifier for this record is defined as a function of the provided types.
+	 * It is still scoped to this `SchemaFactory`, but multiple calls with the same arguments will return the same
+	 * schema object, providing somewhat structural typing.
+	 * This does not support recursive types.
+	 *
+	 * If using these structurally named records, other types in this schema builder should avoid names of the form `Record<${string}>`.
+	 *
+	 * @example
+	 * The returned schema should be used as a schema directly:
+	 * ```typescript
+	 * const MyRecord = factory.record(factory.number);
+	 * type MyRecord = NodeFromSchema<typeof Record>;
+	 * ```
+	 * Or inline:
+	 * ```typescript
+	 * factory.object("Foo", { myRecord: factory.record(factory.number) });
+	 * ```
+	 *
+	 * @privateRemarks
+	 * The name produced at the type-level here is not as specific as it could be; however, doing type-level sorting and escaping is a real mess.
+	 * There are cases where not having this full type provided will be less than ideal, since TypeScript's structural types will allow assignment between runtime incompatible types at compile time.
+	 * For example, attempts to narrow unions of structural records by name won't work.
+	 * Planned future changes to move to a class based schema system as well as factor function based node construction should mostly avoid these issues,
+	 * though there may still be some problematic cases even after that work is done.
+	 *
+	 * The return value is a class, but its type is intentionally not specific enough to indicate it is a class.
+	 * This prevents callers of this from sub-classing it, which is unlikely to work well (due to the ease of accidentally giving two different calls to this different subclasses)
+	 * when working with structural typing.
+	 *
+	 * {@label STRUCTURAL}
+	 */
+	public record<const T extends TreeNodeSchema | readonly TreeNodeSchema[]>(
+		allowedTypes: T,
+	): TreeNodeSchemaNonClass<
+		/* Name */ ScopedSchemaName<TScope, `Record<${string}>`>,
+		/* Kind */ NodeKind.Record,
+		/* TNode */ TreeRecordNode<T> &
+			WithType<ScopedSchemaName<TScope, `Record<${string}>`>, NodeKind.Record>,
+		/* TInsertable */ RecordNodeInsertableData<T>,
+		/* ImplicitlyConstructable */ true,
+		/* Info */ T,
+		/* TConstructorExtra */ undefined
+	>;
+	/**
+	 * Define (and add to this library) a {@link TreeNodeSchemaClass} for a {@link (TreeRecordNode:interface)}.
+	 *
+	 * @param name - Unique identifier for this schema within this factory's scope.
+	 * @param allowedTypes - The types that may appear in the record.
+	 *
+	 * @remarks
+	 * Like TypeScript `Record`s, record nodes have some potential pitfalls.
+	 * For example: TypeScript makes assumptions about built-in keys being present (e.g. `toString`, `hasOwnProperty`, etc.).
+	 * Since these are otherwise valid keys in a record, this can lead to unexpected behavior.
+	 * To prevent inconsistent behavior, these built-ins are hidden by record nodes.
+	 * This means that if you try to call these built-ins (e.g. `toString()`) on a record node, you will get an error.
+	 *
+	 * In most cases, it is probably preferable to use {@link SchemaFactory.(map:2)} instead.
+	 *
+	 * @example
+	 * ```typescript
+	 * class NamedRecord extends factory.record("name", factory.number) {}
+	 * ```
+	 *
+	 * {@label NAMED}
+	 */
+	public record<const Name extends TName, const T extends ImplicitAllowedTypes>(
+		name: Name,
+		allowedTypes: T,
+	): TreeNodeSchemaClass<
+		/* Name */ ScopedSchemaName<TScope, Name>,
+		/* Kind */ NodeKind.Record,
+		/* TNode */ TreeRecordNode<T> & WithType<ScopedSchemaName<TScope, Name>, NodeKind.Record>,
+		/* TInsertable */ RecordNodeInsertableData<T>,
+		/* ImplicitlyConstructable */ true,
+		/* Info */ T,
+		/* TConstructorExtra */ undefined
+	>;
+	/**
+	 * {@link SchemaFactory.array} implementation.
+	 *
+	 * @privateRemarks
+	 * This should return TreeNodeSchemaBoth: see note on "map" implementation for details.
+	 */
+	public record<const T extends ImplicitAllowedTypes>(
+		nameOrAllowedTypes: TName | ((T & TreeNodeSchema) | readonly TreeNodeSchema[]),
+		maybeAllowedTypes?: T,
+	): TreeNodeSchema<
+		/* Name */ ScopedSchemaName<TScope, string>,
+		/* Kind */ NodeKind.Record,
+		/* TNode */ TreeRecordNode<T>,
+		/* TInsertable */ RecordNodeInsertableData<T>,
+		/* ImplicitlyConstructable */ true,
+		/* Info */ T
+	> {
+		if (maybeAllowedTypes === undefined) {
+			const types = nameOrAllowedTypes as (T & TreeNodeSchema) | readonly TreeNodeSchema[];
+			const fullName = structuralName("Record", types);
+			return this.getStructuralType(fullName, types, () =>
+				this.namedRecord(
+					fullName,
+					nameOrAllowedTypes as T,
+					/* customizable */ false,
+					/* implicitlyConstructable */ true,
+				),
+			) as TreeNodeSchemaClass<
+				/* Name */ ScopedSchemaName<TScope, string>,
+				/* Kind */ NodeKind.Record,
+				/* TNode */ TreeRecordNode<T>,
+				/* TInsertable */ RecordNodeInsertableData<T>,
+				/* ImplicitlyConstructable */ true,
+				/* Info */ T,
+				/* TConstructorExtra */ undefined
+			>;
+		}
+		const out: TreeNodeSchemaBoth<
+			/* Name */ ScopedSchemaName<TScope, string>,
+			/* Kind */ NodeKind.Record,
+			/* TNode */ TreeRecordNode<T>,
+			/* TInsertable */ RecordNodeInsertableData<T>,
+			/* ImplicitlyConstructable */ true,
+			/* Info */ T,
+			/* TConstructorExtra */ undefined
+		> = this.namedRecord(
+			nameOrAllowedTypes as TName,
+			maybeAllowedTypes,
+			/* customizable */ true,
+			/* implicitlyConstructable */ true,
+		);
+		return out;
+	}
+
+	/**
+	 * Define a {@link TreeNodeSchema} for a {@link (TreeArrayNode:interface)}.
+	 *
+	 * @param name - Unique identifier for this schema within this factory's scope.
+	 *
+	 * @remarks
+	 * This is not intended to be used directly, use the overload of `array` which takes a name instead.
+	 * This is only public to work around a compiler limitation.
+	 */
+	private namedRecord<
+		Name extends TName | string,
+		const T extends ImplicitAllowedTypes,
+		const ImplicitlyConstructable extends boolean,
+	>(
+		name: Name,
+		allowedTypes: T,
+		customizable: boolean,
+		implicitlyConstructable: ImplicitlyConstructable,
+	): TreeNodeSchemaBoth<
+		/* Name */ ScopedSchemaName<TScope, Name>,
+		/* Kind */ NodeKind.Record,
+		/* TNode */ TreeRecordNode<T> &
+			WithType<ScopedSchemaName<TScope, string>, NodeKind.Record>,
+		/* TInsertable */ RecordNodeInsertableData<T>,
+		/* ImplicitlyConstructable */ ImplicitlyConstructable,
+		/* Info */ T,
+		/* TConstructorExtra */ undefined
+	> {
+		const record = recordSchema({
+			identifier: this.scoped2(name),
+			info: allowedTypes,
+			customizable,
+			implicitlyConstructable,
+		});
+
+		return record as TreeNodeSchemaBoth<
+			/* Name */ ScopedSchemaName<TScope, Name>,
+			/* Kind */ NodeKind.Record,
+			/* TNode */ TreeRecordNode<T> &
+				WithType<ScopedSchemaName<TScope, string>, NodeKind.Record>,
+			/* TInsertable */ RecordNodeInsertableData<T>,
+			/* ImplicitlyConstructable */ ImplicitlyConstructable,
+			/* Info */ T,
+			/* TConstructorExtra */ undefined
+		>;
+	}
+
+	/**
+	 * Define (and add to this library) a {@link TreeNodeSchemaClass} for a {@link (TreeRecordNode:interface)}.
+	 *
+	 * @param name - Unique identifier for this schema within this factory's scope.
+	 * @param allowedTypes - The types that may appear in the record.
+	 * @param options - Additional options for the schema.
+	 *
+	 * @example
+	 * ```typescript
+	 * class NamedRecord extends factory.recordAlpha("name", factory.number) {}
+	 * ```
+	 */
+	public recordAlpha<
+		const Name extends TName,
+		const T extends ImplicitAnnotatedAllowedTypes,
+		const TCustomMetadata = unknown,
+	>(
+		name: Name,
+		allowedTypes: T,
+		options?: NodeSchemaOptionsAlpha<TCustomMetadata>,
+	): RecordNodeCustomizableSchema<ScopedSchemaName<TScope, Name>, T, true, TCustomMetadata> {
+		return recordSchema({
+			identifier: this.scoped2(name),
+			info: allowedTypes,
+			customizable: true,
+			implicitlyConstructable: true,
+			metadata: options?.metadata,
+			persistedMetadata: options?.persistedMetadata,
+		});
+	}
+
+	/**
+	 * {@link SchemaFactoryAlpha.(record:2)} except tweaked to work better for recursive types.
+	 * Use with {@link ValidateRecursiveSchema} for improved type safety.
+	 * @remarks
+	 * This version of `SchemaFactory.record` uses the same workarounds as {@link SchemaFactory.objectRecursive}.
+	 * See {@link ValidateRecursiveSchema} for additional information about using recursive schema.
+	 */
+	// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+	public recordRecursive<
+		Name extends TName,
+		const T extends System_Unsafe.ImplicitAllowedTypesUnsafe,
+	>(name: Name, allowedTypes: T) {
+		const RecordSchema = this.namedRecord(
+			name,
+			allowedTypes as T & ImplicitAllowedTypes,
+			/* customizable */ true,
+			// Setting this to true seems to work ok currently, but not for other node kinds.
+			// Supporting this could be fragile and might break other future changes, so it's being kept as false for now.
+			/* implicitlyConstructable */ false,
+		);
+
+		return RecordSchema as TreeNodeSchemaClass<
+			/* Name */ ScopedSchemaName<TScope, Name>,
+			/* Kind */ NodeKind.Record,
+			/* TNode */ TreeRecordNodeUnsafe<T> &
+				WithType<ScopedSchemaName<TScope, Name>, NodeKind.Record>,
+			/* TInsertable */ {
+				// Ideally this would be
+				// RestrictiveStringRecord<InsertableTreeNodeFromImplicitAllowedTypesUnsafe<T>>,
+				// but doing so breaks recursive types.
+				// Instead we do a less nice version:
+				readonly [P in string]: System_Unsafe.InsertableTreeNodeFromImplicitAllowedTypesUnsafe<T>;
+			},
+			/* ImplicitlyConstructable */ false,
+			/* Info */ T,
+			/* TConstructorExtra */ undefined
+		>;
+	}
+
 	/**
 	 * Create a {@link SchemaFactory} with a {@link SchemaFactory.scope|scope} which is a combination of this factory's scope and the provided name.
 	 * @remarks

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

@@ -168,7 +168,7 @@ export type ValidateRecursiveSchemaTemplate<T extends TreeNodeSchema> = TreeNode
 	// Name: This validator places no restrictions on the name other than that it's a string (as required by TreeNodeSchemaClass).
 	string,
 	// NodeKind: These are the NodeKinds which currently can be used recursively.
-	NodeKind.Array | NodeKind.Map | NodeKind.Object,
+	NodeKind.Array | NodeKind.Map | NodeKind.Object | NodeKind.Record,
 	// TNode: The produced node API. This is pretty minimal validation: more could be added if similar to how TInsertable works below if needed.
 	TreeNode & WithType<T["identifier"], T["kind"]>,
 	// TInsertable: What can be passed to the constructor. This should be enough to catch most issues with incorrect schema.
@@ -183,6 +183,9 @@ export type ValidateRecursiveSchemaTemplate<T extends TreeNodeSchema> = TreeNode
 		[NodeKind.Map]: T["info"] extends ImplicitAllowedTypes
 			? Iterable<[string, InsertableTreeNodeFromImplicitAllowedTypes<T["info"]>]>
 			: unknown;
+		[NodeKind.Record]: {
+			readonly [P in string]: InsertableTreeNodeFromImplicitAllowedTypes<T>;
+		};
 		[NodeKind.Leaf]: unknown;
 	}[T["kind"]],
 	// ImplicitlyConstructable: recursive types are currently not implicitly constructable.
@@ -192,6 +195,7 @@ export type ValidateRecursiveSchemaTemplate<T extends TreeNodeSchema> = TreeNode
 		[NodeKind.Object]: RestrictiveStringRecord<ImplicitFieldSchema>;
 		[NodeKind.Array]: ImplicitAllowedTypes;
 		[NodeKind.Map]: ImplicitAllowedTypes;
+		[NodeKind.Record]: ImplicitAllowedTypes;
 		[NodeKind.Leaf]: unknown;
 	}[T["kind"]]
 >;

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

@@ -116,6 +116,12 @@ function generateNode(
 				generateAllowedTypes(schema.allowedTypesIdentifiers, context),
 				{ metadata: schema.metadata },
 			);
+		case NodeKind.Record:
+			return factory.recordAlpha(
+				id,
+				generateAllowedTypes(schema.allowedTypesIdentifiers, context),
+				{ metadata: schema.metadata },
+			);
 		case NodeKind.Leaf:
 			return (
 				SchemaFactoryAlpha.leaves.find((leaf) => leaf.identifier === id) ??