@fluidframework/tree 2.90.0 → 2.91.0

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

@@ -263,7 +263,16 @@ export class SchemaFactoryBeta<
 		return objectSchema(scoped<TScope, TName, Name>(this, name), fields, true, {
 			...defaultSchemaFactoryObjectOptions,
 			...options,
-		});
+		}) as TreeNodeSchemaClass<
+			ScopedSchemaName<TScope, Name>,
+			NodeKind.Object,
+			TreeObjectNode<T, ScopedSchemaName<TScope, Name>>,
+			object & InsertableObjectFromSchemaRecord<T>,
+			true,
+			T,
+			never,
+			TCustomMetadata
+		>;
 	}
 
 	public override objectRecursive<

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

@@ -6,13 +6,15 @@
 import type { IFluidHandle } from "@fluidframework/core-interfaces";
 
 import type { ImplicitAllowedTypes } from "../core/index.js";
-import { FieldKind, getDefaultProvider, createFieldSchema } from "../fieldSchema.js";
-import type {
-	FieldProps,
-	FieldSchema,
-	DefaultProvider,
-	FieldPropsAlpha,
-	FieldSchemaAlpha,
+import {
+	FieldKind,
+	getDefaultProvider,
+	createFieldSchema,
+	type FieldProps,
+	type DefaultProvider,
+	type FieldPropsAlpha,
+	type FieldSchema,
+	type FieldSchemaAlpha,
 } from "../fieldSchema.js";
 import type { LeafSchema } from "../leafNodeSchema.js";
 import {
@@ -180,7 +182,12 @@ export const schemaStaticsStable = {
 	optional: <const T extends ImplicitAllowedTypes, const TCustomMetadata = unknown>(
 		t: T,
 		props?: Omit<FieldPropsAlpha<TCustomMetadata>, "defaultProvider">,
-	): FieldSchemaAlpha<FieldKind.Optional, T, TCustomMetadata> => {
+	): FieldSchemaAlpha<
+		FieldKind.Optional,
+		T,
+		TCustomMetadata,
+		FieldPropsAlpha<TCustomMetadata>
+	> => {
 		return createFieldSchema(FieldKind.Optional, t, {
 			defaultProvider: defaultOptionalProvider,
 			...props,
@@ -190,8 +197,13 @@ export const schemaStaticsStable = {
 	required: <const T extends ImplicitAllowedTypes, const TCustomMetadata = unknown>(
 		t: T,
 		props?: Omit<FieldPropsAlpha<TCustomMetadata>, "defaultProvider">,
-	): FieldSchemaAlpha<FieldKind.Required, T, TCustomMetadata> => {
-		return createFieldSchema(FieldKind.Required, t, props);
+	): FieldSchemaAlpha<
+		FieldKind.Required,
+		T,
+		TCustomMetadata,
+		FieldPropsAlpha<TCustomMetadata>
+	> => {
+		return createFieldSchema(FieldKind.Required, t, { defaultProvider: undefined, ...props });
 	},
 
 	optionalRecursive: <
@@ -200,7 +212,12 @@ export const schemaStaticsStable = {
 	>(
 		t: T,
 		props?: Omit<FieldPropsAlpha<TCustomMetadata>, "defaultProvider">,
-	): FieldSchemaAlphaUnsafe<FieldKind.Optional, T, TCustomMetadata> => {
+	): FieldSchemaAlphaUnsafe<
+		FieldKind.Optional,
+		T,
+		TCustomMetadata,
+		FieldPropsAlpha<TCustomMetadata>
+	> => {
 		return createFieldSchemaUnsafe(FieldKind.Optional, t, {
 			defaultProvider: defaultOptionalProvider,
 			...props,
@@ -213,8 +230,16 @@ export const schemaStaticsStable = {
 	>(
 		t: T,
 		props?: Omit<FieldPropsAlpha<TCustomMetadata>, "defaultProvider">,
-	): FieldSchemaAlphaUnsafe<FieldKind.Required, T, TCustomMetadata> => {
-		return createFieldSchemaUnsafe(FieldKind.Required, t, props);
+	): FieldSchemaAlphaUnsafe<
+		FieldKind.Required,
+		T,
+		TCustomMetadata,
+		FieldPropsAlpha<TCustomMetadata>
+	> => {
+		return createFieldSchemaUnsafe(FieldKind.Required, t, {
+			defaultProvider: undefined,
+			...props,
+		});
 	},
 } as const satisfies SchemaStatics;
 
@@ -225,14 +250,37 @@ export const schemaStatics = {
 	...schemaStaticsStable,
 	identifier: <const TCustomMetadata = unknown>(
 		props?: Omit<FieldProps<TCustomMetadata>, "defaultProvider">,
-	): FieldSchemaAlpha<FieldKind.Identifier, typeof stringSchema, TCustomMetadata> => {
-		return createFieldSchema(FieldKind.Identifier, stringSchema, props);
+	): FieldSchemaAlpha<
+		FieldKind.Identifier,
+		typeof stringSchema,
+		TCustomMetadata,
+		FieldPropsAlpha<TCustomMetadata>
+	> => {
+		return createFieldSchema(FieldKind.Identifier, stringSchema, {
+			defaultProvider: undefined,
+			...props,
+		});
 	},
 } as const;
 
 /**
  * {@link Unenforced} version of {@link createFieldSchema}.
  */
+function createFieldSchemaUnsafe<
+	Kind extends FieldKind,
+	Types extends System_Unsafe.ImplicitAllowedTypesUnsafe,
+	TCustomMetadata = unknown,
+>(kind: Kind, allowedTypes: Types): FieldSchemaAlphaUnsafe<Kind, Types, TCustomMetadata>;
+function createFieldSchemaUnsafe<
+	Kind extends FieldKind,
+	Types extends System_Unsafe.ImplicitAllowedTypesUnsafe,
+	TCustomMetadata = unknown,
+	TProps extends FieldProps<TCustomMetadata> = FieldProps<TCustomMetadata>,
+>(
+	kind: Kind,
+	allowedTypes: Types,
+	props: TProps,
+): FieldSchemaAlphaUnsafe<Kind, Types, TCustomMetadata, TProps>;
 function createFieldSchemaUnsafe<
 	Kind extends FieldKind,
 	Types extends System_Unsafe.ImplicitAllowedTypesUnsafe,
@@ -241,11 +289,21 @@ function createFieldSchemaUnsafe<
 	kind: Kind,
 	allowedTypes: Types,
 	props?: FieldProps<TCustomMetadata>,
-): FieldSchemaAlphaUnsafe<Kind, Types, TCustomMetadata> {
+): FieldSchemaAlphaUnsafe<
+	Kind,
+	Types,
+	TCustomMetadata,
+	FieldProps<TCustomMetadata> | undefined
+> {
 	// At runtime, we still want this to be a FieldSchema instance, but we can't satisfy its extends clause, so just return it as an FieldSchemaUnsafe
-	return createFieldSchema(
-		kind,
-		allowedTypes as ImplicitAllowedTypes & Types,
-		props,
-	) as FieldSchemaAlphaUnsafe<Kind, Types, TCustomMetadata>;
+	const schema =
+		props === undefined
+			? createFieldSchema(kind, allowedTypes as ImplicitAllowedTypes & Types)
+			: createFieldSchema(kind, allowedTypes as ImplicitAllowedTypes & Types, props);
+	return schema as FieldSchemaAlphaUnsafe<
+		Kind,
+		Types,
+		TCustomMetadata,
+		FieldProps<TCustomMetadata> | undefined
+	>;
 }

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

@@ -27,9 +27,11 @@ import type {
 import type {
 	ApplyKind,
 	ApplyKindInput,
+	DefaultProvider,
 	FieldKind,
 	FieldSchema,
 	FieldSchemaAlpha,
+	FieldPropsAlpha,
 } from "../fieldSchema.js";
 import type { TreeArrayNode } from "../node-kinds/index.js";
 import type {
@@ -465,7 +467,8 @@ export interface FieldSchemaAlphaUnsafe<
 	out Kind extends FieldKind,
 	out Types extends System_Unsafe.ImplicitAllowedTypesUnsafe,
 	out TCustomMetadata = unknown,
-> extends FieldSchemaAlpha<Kind, any, TCustomMetadata>,
+	out TProps extends FieldPropsAlpha<TCustomMetadata> | undefined = undefined,
+> extends FieldSchemaAlpha<Kind, any, TCustomMetadata, TProps>,
 		System_Unsafe.FieldSchemaUnsafe<Kind, Types, TCustomMetadata> {
 	/**
 	 * {@inheritDoc FieldSchema.allowedTypes}
@@ -475,6 +478,51 @@ export interface FieldSchemaAlphaUnsafe<
 
 /* eslint-enable @typescript-eslint/no-explicit-any */
 
+/**
+ * {@link Unenforced} version of {@link FieldHasDefaultAlpha}.
+ * @remarks
+ * Do not use this type directly: it's only needed in the implementation of generic logic which define recursive schema, not when using recursive schema.
+ * @system @sealed @alpha
+ */
+export type FieldHasDefaultAlphaUnsafe<T extends System_Unsafe.ImplicitFieldSchemaUnsafe> =
+	T extends FieldSchemaAlphaUnsafe<
+		infer Kind,
+		System_Unsafe.ImplicitAllowedTypesUnsafe,
+		unknown,
+		infer TProps
+	>
+		? Kind extends FieldKind.Optional | FieldKind.Identifier
+			? true
+			: TProps extends { defaultProvider: DefaultProvider }
+				? true
+				: false
+		: System_Unsafe.FieldHasDefaultUnsafe<T>;
+
+/**
+ * {@link Unenforced} version of {@link InsertableObjectFromSchemaRecordAlpha}.
+ * @see {@link System_Unsafe.InsertableObjectFromSchemaRecordUnsafe}
+ * @remarks
+ * Do not use this type directly: it's only needed in the implementation of generic logic which define recursive schema, not when using recursive schema.
+ * @system @alpha
+ */
+export type InsertableObjectFromSchemaRecordAlphaUnsafe<
+	T extends RestrictiveStringRecord<System_Unsafe.ImplicitFieldSchemaUnsafe>,
+> = {
+	// Field does not have a known default, make it required:
+	readonly [Property in keyof T as FieldHasDefaultAlphaUnsafe<
+		T[Property & string]
+	> extends false
+		? Property
+		: never]: System_Unsafe.InsertableTreeFieldFromImplicitFieldUnsafe<T[Property & string]>;
+} & {
+	// Field has a known default, make it optional:
+	readonly [Property in keyof T as FieldHasDefaultAlphaUnsafe<
+		T[Property & string]
+	> extends true
+		? Property
+		: never]?: System_Unsafe.InsertableTreeFieldFromImplicitFieldUnsafe<T[Property & string]>;
+};
+
 /**
  * {@link Unenforced} version of {@link ArrayNodeCustomizableSchema}s.
  * @remarks

package/src/simple-tree/fieldSchema.ts

@@ -268,6 +268,21 @@ export interface FieldSchemaMetadataAlpha<TCustomMetadata = unknown>
 /**
  * Package internal construction API.
  */
+export function createFieldSchema<
+	Kind extends FieldKind,
+	Types extends ImplicitAllowedTypes,
+	TCustomMetadata = unknown,
+>(kind: Kind, annotatedTypes: Types): FieldSchemaAlpha<Kind, Types, TCustomMetadata>;
+export function createFieldSchema<
+	Kind extends FieldKind,
+	Types extends ImplicitAllowedTypes,
+	TCustomMetadata = unknown,
+	TProps extends FieldProps<TCustomMetadata> = FieldProps<TCustomMetadata>,
+>(
+	kind: Kind,
+	annotatedTypes: Types,
+	props: TProps,
+): FieldSchemaAlpha<Kind, Types, TCustomMetadata, TProps>;
 export function createFieldSchema<
 	Kind extends FieldKind,
 	Types extends ImplicitAllowedTypes,
@@ -276,7 +291,7 @@ export function createFieldSchema<
 	kind: Kind,
 	annotatedTypes: Types,
 	props?: FieldProps<TCustomMetadata>,
-): FieldSchemaAlpha<Kind, Types, TCustomMetadata> {
+): FieldSchemaAlpha<Kind, Types, TCustomMetadata, FieldProps<TCustomMetadata> | undefined> {
 	return createFieldSchemaPrivate(kind, annotatedTypes, props);
 }
 
@@ -291,7 +306,7 @@ let createFieldSchemaPrivate: <
 	kind: Kind,
 	annotatedTypes: Types,
 	props?: FieldProps<TCustomMetadata>,
-) => FieldSchemaAlpha<Kind, Types, TCustomMetadata>;
+) => FieldSchemaAlpha<Kind, Types, TCustomMetadata, FieldProps<TCustomMetadata> | undefined>;
 
 /**
  * All policy for a specific field,
@@ -384,11 +399,14 @@ export class FieldSchemaAlpha<
 		Kind extends FieldKind = FieldKind,
 		Types extends ImplicitAllowedTypes = ImplicitAllowedTypes,
 		TCustomMetadata = unknown,
+		TProps extends FieldPropsAlpha<TCustomMetadata> | undefined =
+			| FieldPropsAlpha<TCustomMetadata>
+			| undefined,
 	>
 	extends FieldSchema<Kind, Types, TCustomMetadata>
 	implements SimpleFieldSchema<SchemaType.View>
 {
-	private readonly propsAlpha: FieldPropsAlpha<TCustomMetadata> | undefined;
+	private readonly propsAlpha: TProps;
 
 	public get persistedMetadata(): JsonCompatibleReadOnlyObject | undefined {
 		return this.propsAlpha?.persistedMetadata;
@@ -403,7 +421,13 @@ export class FieldSchemaAlpha<
 			kind: Kind2,
 			annotatedAllowedTypes: Types2,
 			props?: FieldPropsAlpha<TCustomMetadata2>,
-		) => new FieldSchemaAlpha(kind, annotatedAllowedTypes, props);
+		) =>
+			// TCustomMetadata2 requires type assertion due to limitations with dependent type parameters
+			new FieldSchemaAlpha(kind, annotatedAllowedTypes, props) as unknown as FieldSchemaAlpha<
+				Kind2,
+				Types2,
+				TCustomMetadata2
+			>;
 	}
 
 	/**
@@ -432,7 +456,7 @@ export class FieldSchemaAlpha<
 
 		const normalizedTypes = normalizeAllowedTypes(types);
 		this.allowedTypesFull = normalizedTypes;
-		this.propsAlpha = props;
+		this.propsAlpha = props as TProps;
 	}
 }
 

package/src/simple-tree/index.ts

@@ -79,6 +79,8 @@ export {
 	SchemaFactoryBeta,
 	type SchemaStaticsBeta,
 	SchemaFactoryAlpha,
+	type SchemaStaticsAlpha,
+	type NodeProvider,
 	type ObjectSchemaOptionsAlpha,
 	type ObjectSchemaOptions,
 	type ScopedSchemaName,
@@ -139,6 +141,8 @@ export {
 	type AllowedTypesFullFromMixedUnsafe,
 	type UnannotateAllowedTypesListUnsafe,
 	type AnnotateAllowedTypesListUnsafe,
+	type FieldHasDefaultAlphaUnsafe,
+	type InsertableObjectFromSchemaRecordAlphaUnsafe,
 	type TreeViewAlpha,
 	type TreeViewBeta,
 	type TreeBranch,
@@ -197,6 +201,9 @@ export {
 	checkCompatibility,
 	eraseSchemaDetails,
 	eraseSchemaDetailsSubclassable,
+	type ErasedSchema,
+	type ErasedNode,
+	type ErasedSchemaSubclassable,
 	snapshotSchemaCompatibility,
 	type SnapshotFileSystem,
 	type SnapshotSchemaCompatibilityOptions,
@@ -255,9 +262,12 @@ export {
 	type TreeMapNode,
 	type MapNodeInsertableData,
 	type FieldHasDefault,
+	type FieldHasDefaultAlpha,
 	type InsertableObjectFromSchemaRecord,
+	type InsertableObjectFromSchemaRecordAlpha,
 	type ObjectFromSchemaRecord,
 	ObjectNodeSchema,
+	type ObjectNodeSchemaWorkaround,
 	type ObjectNodeSchemaPrivate,
 	objectSchema,
 	isObjectNodeSchema,

package/src/simple-tree/node-kinds/index.ts

@@ -29,10 +29,13 @@ export {
 
 export {
 	type FieldHasDefault,
+	type FieldHasDefaultAlpha,
 	type InsertableObjectFromSchemaRecord,
+	type InsertableObjectFromSchemaRecordAlpha,
 	isObjectNodeSchema,
 	type ObjectFromSchemaRecord,
 	ObjectNodeSchema,
+	type ObjectNodeSchemaWorkaround,
 	type ObjectNodeSchemaPrivate,
 	objectSchema,
 	setField,

package/src/simple-tree/node-kinds/object/index.ts

@@ -5,7 +5,9 @@
 
 export {
 	type FieldHasDefault,
+	type FieldHasDefaultAlpha,
 	type InsertableObjectFromSchemaRecord,
+	type InsertableObjectFromSchemaRecordAlpha,
 	type ObjectFromSchemaRecord,
 	objectSchema,
 	setField,
@@ -15,5 +17,6 @@ export {
 export {
 	isObjectNodeSchema,
 	ObjectNodeSchema,
+	type ObjectNodeSchemaWorkaround,
 	type ObjectNodeSchemaPrivate,
 } from "./objectNodeTypes.js";

package/src/simple-tree/node-kinds/object/objectNode.ts

@@ -70,6 +70,7 @@ import {
 	type ContextualFieldProvider,
 	extractFieldProvider,
 	isConstant,
+	type DefaultProvider,
 } from "../../fieldSchema.js";
 import { tryGetTreeNodeForField } from "../../getTreeNodeForField.js";
 import { prepareForInsertion } from "../../prepareForInsertion.js";
@@ -99,8 +100,7 @@ import type {
  */
 export type ObjectFromSchemaRecord<T extends RestrictiveStringRecord<ImplicitFieldSchema>> =
 	RestrictiveStringRecord<ImplicitFieldSchema> extends T
-		? // eslint-disable-next-line @typescript-eslint/no-empty-object-type
-			{}
+		? {}
 		: {
 				-readonly [Property in keyof T]: Property extends string
 					? TreeFieldFromImplicitField<T[Property]>
@@ -149,8 +149,11 @@ export type TreeObjectNode<
  * @remarks Yields `false` when unknown.
  *
  * @privateRemarks
- * TODO: Account for field schemas with default value providers.
- * For now, this only captures field kinds that we know always have defaults - optional fields and identifier fields.
+ * This checks for:
+ * 1. Optional fields (which have an implicit undefined default)
+ * 2. Identifier fields (which have auto-generated defaults)
+ *
+ * Note that this cannot tell if required fields have defaults. Use `FieldHasDefaultAlpha` for alpha schemas if you need to check for required field defaults.
  *
  * @system @public
  */
@@ -160,6 +163,33 @@ export type FieldHasDefault<T extends ImplicitFieldSchema> = [T] extends [
 	? true
 	: false;
 
+/**
+ * Type utility for determining if an implicit field schema is known to have a default value.
+ * Supports alpha field schemas with explicit default providers.
+ *
+ * @remarks Yields `false` when unknown.
+ *
+ * @privateRemarks
+ * This checks for:
+ * 1. Fields with explicit default providers (computed from the props type)
+ * 2. Optional fields (which have an implicit undefined default)
+ * 3. Identifier fields (which have auto-generated defaults)
+ *
+ * @system @alpha
+ */
+export type FieldHasDefaultAlpha<T extends ImplicitFieldSchema> =
+	// Extract Kind and TProps from FieldSchemaAlpha and compute whether it has a default
+	[T] extends [FieldSchemaAlpha<infer Kind, infer _Types, infer _Meta, infer TProps>]
+		? // Optional and Identifier kinds always have defaults
+			Kind extends FieldKind.Optional | FieldKind.Identifier
+			? true
+			: // Check if props has defaultProvider
+				TProps extends { defaultProvider: DefaultProvider }
+				? true
+				: false
+		: // Fallback to base FieldHasDefault for non-Alpha schemas
+			FieldHasDefault<T>;
+
 /**
  * Helper used to produce types for:
  *
@@ -209,6 +239,35 @@ export type InsertableObjectFromSchemaRecord<
 				}
 			>;
 
+/**
+ * Alpha version of InsertableObjectFromSchemaRecord that supports field defaults.
+ *
+ * @system @alpha
+ */
+export type InsertableObjectFromSchemaRecordAlpha<
+	T extends RestrictiveStringRecord<ImplicitFieldSchema>,
+> =
+	RestrictiveStringRecord<ImplicitFieldSchema> extends T
+		? { arbitraryKey: "arbitraryValue" } extends T
+			? // {} case
+				Record<string, never>
+			: // RestrictiveStringRecord<ImplicitFieldSchema> case
+				never
+		: FlattenKeys<
+				{
+					readonly [Property in keyof T]?: InsertableTreeFieldFromImplicitField<
+						T[Property & string]
+					>;
+				} & {
+					// Field does not have a known default, make it required:
+					readonly [Property in keyof T as FieldHasDefaultAlpha<
+						T[Property & string]
+					> extends false
+						? Property
+						: never]: InsertableTreeFieldFromImplicitField<T[Property & string]>;
+				}
+			>;
+
 /**
  * Maps from simple field keys ("property" keys) to information about the field.
  *
@@ -387,17 +446,16 @@ export class ObjectFieldSchema<
 		Kind extends FieldKind,
 		Types extends ImplicitAllowedTypes,
 		TCustomMetadata = unknown,
+		TProps extends FieldProps<TCustomMetadata> & {
+			readonly key: string;
+		} = FieldProps<TCustomMetadata> & { readonly key: string },
 	>
-	extends FieldSchemaAlpha<Kind, Types, TCustomMetadata>
+	extends FieldSchemaAlpha<Kind, Types, TCustomMetadata, TProps>
 	implements SimpleObjectFieldSchema
 {
 	public readonly storedKey: string;
 
-	public constructor(
-		kind: Kind,
-		allowedTypes: Types,
-		props: FieldProps<TCustomMetadata> & { readonly key: string },
-	) {
+	public constructor(kind: Kind, allowedTypes: Types, props: TProps) {
 		super(kind, allowedTypes, props);
 		this.storedKey = props.key;
 	}
@@ -592,7 +650,7 @@ export function objectSchema<
 	}
 	type Output = typeof CustomObjectNode &
 		(new (
-			input: InsertableObjectFromSchemaRecord<T> | InternalTreeNode,
+			input: InsertableObjectFromSchemaRecordAlpha<T> | InternalTreeNode,
 		) => TreeObjectNode<T, TName>);
 	return CustomObjectNode as Output;
 }

package/src/simple-tree/node-kinds/object/objectNodeTypes.ts

@@ -21,9 +21,40 @@ import type {
 import type {
 	TreeObjectNode,
 	SimpleKeyMap,
-	InsertableObjectFromSchemaRecord,
+	InsertableObjectFromSchemaRecordAlpha,
 } from "./objectNode.js";
 
+/**
+ * {@link (ObjectNodeSchema:interface)} with a workaround to avoid a specific known TypeScript issue which causes it to not be assignable to itself in some cases.
+ * @remarks
+ * If dealing with a schema whose inferred type includes this workaround (because it was produced by a schema factory API which uses it),
+ * if you need to explicitly state that type (for example when using {@link https://www.typescriptlang.org/tsconfig/#isolatedDeclarations | isolatedDeclarations}), it is best to keep this workaround.
+ * No other case should need to refer to this workaround type directly.
+ * See {@link ObjectNodeSchemaWorkaround.createFromInsertable} for details.
+ * @sealed
+ * @alpha
+ */
+export type ObjectNodeSchemaWorkaround<
+	TName extends string = string,
+	T extends
+		RestrictiveStringRecord<ImplicitFieldSchema> = RestrictiveStringRecord<ImplicitFieldSchema>,
+	ImplicitlyConstructable extends boolean = boolean,
+	TCustomMetadata = unknown,
+> = ObjectNodeSchema<TName, T, ImplicitlyConstructable, TCustomMetadata> & {
+	/**
+	 * Typing checking workaround: not for for actual use.
+	 * @remarks
+	 * This API collides with {@link TreeNodeSchemaCore.createFromInsertable} to disable a type checking optimization which produces different and undesired results.
+	 * See {@link https://github.com/microsoft/TypeScript/issues/59049#issuecomment-2773459693} for more details.
+	 *
+	 * The specific issue here is non-empty POJO mode object schema not being assignable to `ObjectNodeSchema`,
+	 * @privateRemarks
+	 * See the above link and the tests in objectNode.spec.ts which reference it.
+	 * @system
+	 */
+	readonly createFromInsertable: unknown;
+};
+
 /**
  * A schema for {@link TreeObjectNode}s.
  * @sealed
@@ -39,7 +70,7 @@ export interface ObjectNodeSchema<
 			TName,
 			NodeKind.Object,
 			TreeObjectNode<T, TName>,
-			InsertableObjectFromSchemaRecord<T>,
+			object & InsertableObjectFromSchemaRecordAlpha<T>,
 			ImplicitlyConstructable,
 			T,
 			never,