@fluidframework/tree 2.50.0 → 2.51.0

package/src/simple-tree/node-kinds/map/mapNode.ts

@@ -4,27 +4,19 @@
  */
 
 import { Lazy } from "@fluidframework/core-utils/internal";
-import type {
-	FlexibleNodeContent,
-	FlexTreeNode,
-	FlexTreeOptionalField,
-	OptionalFieldEditBuilder,
+import { UsageError } from "@fluidframework/telemetry-utils/internal";
+
+import {
+	isTreeValue,
+	type FlexibleNodeContent,
+	type FlexTreeNode,
+	type FlexTreeOptionalField,
+	type OptionalFieldEditBuilder,
 } from "../../../feature-libraries/index.js";
 import { tryGetTreeNodeForField } from "../../getTreeNodeForField.js";
+import { createFieldSchema, FieldKind } from "../../fieldSchema.js";
 import {
-	createFieldSchema,
-	FieldKind,
-	normalizeAllowedTypes,
-	normalizeAnnotatedAllowedTypes,
-	unannotateImplicitAllowedTypes,
-	type ImplicitAllowedTypes,
-	type ImplicitAnnotatedAllowedTypes,
-	type InsertableTreeNodeFromImplicitAllowedTypes,
-	type NodeSchemaMetadata,
-	type TreeNodeFromImplicitAllowedTypes,
-	type UnannotateImplicitAllowedTypes,
-} from "../../schemaTypes.js";
-import {
+	CompatibilityLevel,
 	getKernel,
 	type InnerNode,
 	NodeKind,
@@ -33,11 +25,25 @@ import {
 	typeNameSymbol,
 	type TreeNode,
 	typeSchemaSymbol,
-	type Context,
 	getOrCreateInnerNode,
 	type InternalTreeNode,
 	type UnhydratedFlexTreeNode,
-	type NormalizedAnnotatedAllowedTypes,
+	normalizeAllowedTypes,
+	unannotateImplicitAllowedTypes,
+	type ImplicitAllowedTypes,
+	type ImplicitAnnotatedAllowedTypes,
+	type InsertableTreeNodeFromImplicitAllowedTypes,
+	type NodeSchemaMetadata,
+	type TreeNodeFromImplicitAllowedTypes,
+	type UnannotateImplicitAllowedTypes,
+	TreeNodeValid,
+	type MostDerivedData,
+	type TreeNodeSchemaInitializedData,
+	type TreeNodeSchemaCorePrivate,
+	privateDataSymbol,
+	createTreeNodeSchemaPrivateData,
+	type FlexContent,
+	type TreeNodeSchemaPrivateData,
 } from "../../core/index.js";
 import {
 	unhydratedFlexTreeFromInsertable,
@@ -48,12 +54,17 @@ import { prepareForInsertion } from "../../prepareForInsertion.js";
 import {
 	brand,
 	count,
+	isReadonlyArray,
 	type JsonCompatibleReadOnlyObject,
 	type RestrictiveStringRecord,
 } from "../../../util/index.js";
-import { TreeNodeValid, type MostDerivedData } from "../../treeNodeValid.js";
-import { getUnhydratedContext } from "../../createContext.js";
-import type { MapNodeCustomizableSchema, MapNodePojoEmulationSchema } from "./mapNodeTypes.js";
+import { getTreeNodeSchemaInitializedData } from "../../createContext.js";
+import type {
+	MapNodeCustomizableSchema,
+	MapNodePojoEmulationSchema,
+	MapNodeSchema,
+} from "./mapNodeTypes.js";
+import { recordLikeDataToFlexContent } from "../common.js";
 
 /**
  * A map of string keys to tree objects.
@@ -254,12 +265,11 @@ export function mapSchema<
 	const lazyChildTypes = new Lazy(() =>
 		normalizeAllowedTypes(unannotateImplicitAllowedTypes(info)),
 	);
-	const lazyAnnotatedTypes = new Lazy(() => [normalizeAnnotatedAllowedTypes(info)]);
 	const lazyAllowedTypesIdentifiers = new Lazy(
 		() => new Set([...lazyChildTypes.value].map((type) => type.identifier)),
 	);
 
-	let unhydratedContext: Context;
+	let privateData: TreeNodeSchemaPrivateData | undefined;
 
 	class Schema
 		extends CustomMapNodeBase<UnannotateImplicitAllowedTypes<T>>
@@ -290,10 +300,12 @@ export function mapSchema<
 
 		protected static override constructorCached: MostDerivedData | undefined = undefined;
 
-		protected static override oneTimeSetup<T2>(this: typeof TreeNodeValid<T2>): Context {
-			const schema = this as unknown as TreeNodeSchema;
-			unhydratedContext = getUnhydratedContext(schema);
-			return unhydratedContext;
+		protected static override oneTimeSetup(): TreeNodeSchemaInitializedData {
+			const schema = this as MapNodeSchema;
+			return getTreeNodeSchemaInitializedData(this, {
+				shallowCompatibilityTest,
+				toFlexContent: (data: FactoryContent): FlexContent => mapToFlexContent(data, schema),
+			});
 		}
 
 		public static readonly identifier = identifier;
@@ -303,9 +315,6 @@ export function mapSchema<
 		public static get childTypes(): ReadonlySet<TreeNodeSchema> {
 			return lazyChildTypes.value;
 		}
-		public static get childAnnotatedAllowedTypes(): readonly NormalizedAnnotatedAllowedTypes[] {
-			return lazyAnnotatedTypes.value;
-		}
 		public static readonly metadata: NodeSchemaMetadata<TCustomMetadata> = metadata ?? {};
 		public static readonly persistedMetadata: JsonCompatibleReadOnlyObject | undefined =
 			persistedMetadata;
@@ -317,6 +326,10 @@ export function mapSchema<
 		public get [typeSchemaSymbol](): typeof schemaErased {
 			return Schema.constructorCached?.constructor as unknown as typeof schemaErased;
 		}
+
+		public static get [privateDataSymbol](): TreeNodeSchemaPrivateData {
+			return (privateData ??= createTreeNodeSchemaPrivateData(this, [info]));
+		}
 	}
 	const schemaErased: MapNodeCustomizableSchema<
 		TName,
@@ -324,7 +337,8 @@ export function mapSchema<
 		ImplicitlyConstructable,
 		TCustomMetadata
 	> &
-		MapNodePojoEmulationSchema<TName, T, ImplicitlyConstructable, TCustomMetadata> = Schema;
+		MapNodePojoEmulationSchema<TName, T, ImplicitlyConstructable, TCustomMetadata> &
+		TreeNodeSchemaCorePrivate = Schema;
 	return schemaErased;
 }
 
@@ -335,3 +349,47 @@ export function mapSchema<
 export type MapNodeInsertableData<T extends ImplicitAllowedTypes> =
 	| Iterable<readonly [string, InsertableTreeNodeFromImplicitAllowedTypes<T>]>
 	| RestrictiveStringRecord<InsertableTreeNodeFromImplicitAllowedTypes<T>>;
+
+/**
+ * {@link TreeNodeSchemaInitializedData.shallowCompatibilityTest} for Map nodes.
+ */
+function shallowCompatibilityTest(data: FactoryContent): CompatibilityLevel {
+	if (isTreeValue(data)) {
+		return CompatibilityLevel.None;
+	}
+
+	if (isReadonlyArray(data)) {
+		// Arrays are iterable, so type checking does allow constructing a MapNode from an array if the array's type is key values pairs for the map.
+		return CompatibilityLevel.Low;
+	}
+
+	if (Symbol.iterator in data) {
+		return CompatibilityLevel.Normal;
+	}
+
+	// When not unioned with an ObjectNode, allow objects to be used to create maps.
+	return CompatibilityLevel.Low;
+}
+
+/**
+ * {@link TreeNodeSchemaInitializedData.toFlexContent} for Map nodes.
+ *
+ * Transforms data under a Map schema.
+ * @param data - The tree data to be transformed. Must be an iterable or Record like object.
+ * @param schema - The schema to comply with.
+ */
+function mapToFlexContent(data: FactoryContent, schema: MapNodeSchema): FlexContent {
+	if (!(typeof data === "object" && data !== null)) {
+		throw new UsageError(`Input data is incompatible with Map schema: ${data}`);
+	}
+
+	const fieldsIterator = (
+		Symbol.iterator in data
+			? // Support iterables of key value pairs (including Map objects)
+				data
+			: // Support record objects for JSON style Map data
+				Object.entries(data)
+	) as Iterable<readonly [string, InsertableContent]>;
+
+	return recordLikeDataToFlexContent(fieldsIterator, schema);
+}

package/src/simple-tree/node-kinds/map/mapNodeTypes.ts

@@ -4,16 +4,14 @@
  */
 
 import type { MapNodeInsertableData, TreeMapNode } from "./mapNode.js";
+import { NodeKind } from "../../core/index.js";
 import type {
+	TreeNodeSchemaClass,
+	TreeNodeSchema,
+	TreeNodeSchemaNonClass,
+	WithType,
 	ImplicitAnnotatedAllowedTypes,
 	UnannotateImplicitAllowedTypes,
-} from "../../schemaTypes.js";
-import {
-	NodeKind,
-	type TreeNodeSchemaClass,
-	type TreeNodeSchema,
-	type TreeNodeSchemaNonClass,
-	type WithType,
 } from "../../core/index.js";
 
 import type { SimpleMapNodeSchema } from "../../simpleSchema.js";

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

@@ -12,9 +12,11 @@ export {
 	objectSchema,
 	setField,
 	type TreeObjectNode,
+	type SimpleKeyMap,
 } from "./objectNode.js";
 export {
 	isObjectNodeSchema,
 	ObjectNodeSchema,
 	type ObjectNodeSchemaPrivate,
+	type UnannotateSchemaRecord,
 } from "./objectNodeTypes.js";

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

@@ -5,10 +5,12 @@
 
 import { assert, Lazy, fail, debugAssert } from "@fluidframework/core-utils/internal";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
+import { isFluidHandle } from "@fluidframework/runtime-utils/internal";
 
 import type { FieldKey, SchemaPolicy } from "../../../core/index.js";
 import {
 	FieldKinds,
+	isTreeValue,
 	type FlexTreeField,
 	type FlexTreeNode,
 	type FlexTreeOptionalField,
@@ -19,8 +21,10 @@ import type {
 	FlattenKeys,
 	JsonCompatibleReadOnlyObject,
 } from "../../../util/index.js";
+import { brand } from "../../../util/index.js";
 
 import {
+	CompatibilityLevel,
 	type TreeNodeSchema,
 	NodeKind,
 	type WithType,
@@ -29,18 +33,34 @@ import {
 	typeSchemaSymbol,
 	type InternalTreeNode,
 	type TreeNode,
-	type Context,
 	type UnhydratedFlexTreeNode,
 	getOrCreateInnerNode,
-	type NormalizedAnnotatedAllowedTypes,
+	type NodeSchemaMetadata,
+	type ImplicitAllowedTypes,
+	type ImplicitAnnotatedAllowedTypes,
+	unannotateImplicitAllowedTypes,
+	TreeNodeValid,
+	type MostDerivedData,
+	type TreeNodeSchemaInitializedData,
+	privateDataSymbol,
+	createTreeNodeSchemaPrivateData,
+	type FlexContent,
+	type UnhydratedFlexTreeField,
+	createField,
+	type TreeNodeSchemaCorePrivate,
+	type TreeNodeSchemaPrivateData,
 } from "../../core/index.js";
-import { getUnhydratedContext } from "../../createContext.js";
+import {
+	getTreeNodeSchemaInitializedData,
+	getUnhydratedContext,
+} from "../../createContext.js";
 import { tryGetTreeNodeForField } from "../../getTreeNodeForField.js";
 import {
 	isObjectNodeSchema,
 	type ObjectNodeSchema,
 	type ObjectNodeSchemaInternalData,
 	type ObjectNodeSchemaPrivate,
+	type UnannotateSchemaRecord,
 } from "./objectNodeTypes.js";
 import { prepareForInsertion } from "../../prepareForInsertion.js";
 import {
@@ -49,21 +69,25 @@ import {
 	getExplicitStoredKey,
 	type TreeFieldFromImplicitField,
 	type InsertableTreeFieldFromImplicitField,
-	type FieldSchema,
+	FieldSchema,
+	FieldSchemaAlpha,
 	normalizeFieldSchema,
 	FieldKind,
-	type NodeSchemaMetadata,
-	type FieldSchemaAlpha,
-	ObjectFieldSchema,
 	type ImplicitAnnotatedFieldSchema,
-	type UnannotateSchemaRecord,
-} from "../../schemaTypes.js";
+	type FieldProps,
+	type ContextualFieldProvider,
+	extractFieldProvider,
+	isConstant,
+} from "../../fieldSchema.js";
 import type { SimpleObjectFieldSchema } from "../../simpleSchema.js";
 import {
 	unhydratedFlexTreeFromInsertable,
+	unhydratedFlexTreeFromInsertableNode,
+	type FactoryContent,
+	type FactoryContentObject,
 	type InsertableContent,
 } from "../../unhydratedFlexTreeFromInsertable.js";
-import { TreeNodeValid, type MostDerivedData } from "../../treeNodeValid.js";
+import { convertFieldKind } from "../../toStoredSchema.js";
 
 /**
  * Generates the properties for an ObjectNode from its field schema object.
@@ -170,7 +194,7 @@ export type InsertableObjectFromSchemaRecord<
 /**
  * Helper used to remove annotations from a schema record and produce insertable objects,
  *
- * @privateremarks
+ * @privateRemarks
  * This calls {@link InsertableObjectFromSchemaRecord} in order to produce the insertable objects.
  *
  * @system @alpha
@@ -345,6 +369,30 @@ export function setField(
 	}
 }
 
+/**
+ * {@link FieldSchemaAlpha} including {@link SimpleObjectFieldSchema}.
+ */
+export class ObjectFieldSchema<
+		Kind extends FieldKind,
+		Types extends ImplicitAllowedTypes,
+		TCustomMetadata = unknown,
+	>
+	extends FieldSchemaAlpha<Kind, Types, TCustomMetadata>
+	implements SimpleObjectFieldSchema
+{
+	public readonly storedKey: string;
+
+	public constructor(
+		kind: Kind,
+		allowedTypes: Types,
+		annotatedTypes: ImplicitAnnotatedAllowedTypes,
+		props: FieldProps<TCustomMetadata> & { readonly key: string },
+	) {
+		super(kind, allowedTypes, annotatedTypes, props);
+		this.storedKey = props.key;
+	}
+}
+
 abstract class CustomObjectNodeBase<
 	const T extends RestrictiveStringRecord<ImplicitFieldSchema>,
 > extends TreeNodeValid<InsertableObjectFromSchemaRecord<T>> {
@@ -371,7 +419,8 @@ export function objectSchema<
 	metadata?: NodeSchemaMetadata<TCustomMetadata>,
 	persistedMetadata?: JsonCompatibleReadOnlyObject | undefined,
 ): ObjectNodeSchema<TName, T, ImplicitlyConstructable, TCustomMetadata> &
-	ObjectNodeSchemaInternalData {
+	ObjectNodeSchemaInternalData &
+	TreeNodeSchemaCorePrivate {
 	// Field set can't be modified after this since derived data is stored in maps.
 	Object.freeze(info);
 
@@ -392,16 +441,11 @@ export function objectSchema<
 	const lazyChildTypes = new Lazy(
 		() => new Set(Array.from(flexKeyMap.values(), (f) => [...f.schema.allowedTypeSet]).flat()),
 	);
-	const lazyAnnotatedTypes = new Lazy(() =>
-		Array.from(
-			flexKeyMap.values(),
-			({ schema }) => normalizeFieldSchema(schema).annotatedAllowedTypesNormalized,
-		),
-	);
+
+	let privateData: TreeNodeSchemaPrivateData | undefined;
 
 	let handler: ProxyHandler<object>;
 	let customizable: boolean;
-	let unhydratedContext: Context;
 
 	class CustomObjectNode extends CustomObjectNodeBase<UnannotateSchemaRecord<T>> {
 		public static readonly fields: ReadonlyMap<
@@ -474,12 +518,11 @@ export function objectSchema<
 
 		protected static override constructorCached: MostDerivedData | undefined = undefined;
 
-		protected static override oneTimeSetup<T2>(this: typeof TreeNodeValid<T2>): Context {
+		protected static override oneTimeSetup(): TreeNodeSchemaInitializedData {
 			// One time initialization that required knowing the most derived type (from this.constructor) and thus has to be lazy.
 			customizable = (this as unknown) !== CustomObjectNode;
 			const schema = this as unknown as ObjectNodeSchemaPrivate;
 			handler = createProxyHandler(schema, customizable);
-			unhydratedContext = getUnhydratedContext(schema);
 
 			// First run, do extra validation.
 			// TODO: provide a way for TreeConfiguration to trigger this same validation to ensure it gets run early.
@@ -506,7 +549,14 @@ export function objectSchema<
 				}
 			}
 
-			return unhydratedContext;
+			return getTreeNodeSchemaInitializedData(schema, {
+				shallowCompatibilityTest: (data: FactoryContent): CompatibilityLevel =>
+					shallowCompatibilityTest(data, schema),
+				toFlexContent: (
+					data: FactoryContent,
+					allowedTypes: ReadonlySet<TreeNodeSchema>,
+				): FlexContent => objectToFlexContent(data, schema),
+			});
 		}
 
 		public static readonly identifier = identifier;
@@ -516,9 +566,6 @@ export function objectSchema<
 		public static get childTypes(): ReadonlySet<TreeNodeSchema> {
 			return lazyChildTypes.value;
 		}
-		public static get childAnnotatedAllowedTypes(): readonly NormalizedAnnotatedAllowedTypes[] {
-			return lazyAnnotatedTypes.value;
-		}
 		public static readonly metadata: NodeSchemaMetadata<TCustomMetadata> = metadata ?? {};
 		public static readonly persistedMetadata: JsonCompatibleReadOnlyObject | undefined =
 			persistedMetadata;
@@ -530,6 +577,16 @@ export function objectSchema<
 		public get [typeSchemaSymbol](): Output {
 			return CustomObjectNode.constructorCached?.constructor as unknown as Output;
 		}
+
+		public static get [privateDataSymbol](): TreeNodeSchemaPrivateData {
+			return (privateData ??= createTreeNodeSchemaPrivateData(
+				this,
+				Array.from(
+					flexKeyMap.values(),
+					({ schema }) => normalizeFieldSchema(schema).annotatedAllowedTypes,
+				),
+			));
+		}
 	}
 	type Output = typeof CustomObjectNode &
 		(new (
@@ -538,6 +595,20 @@ export function objectSchema<
 	return CustomObjectNode as Output;
 }
 
+/**
+ * Removes annotations from a schema record.
+ */
+export function unannotateSchemaRecord<
+	Schema extends RestrictiveStringRecord<ImplicitAnnotatedFieldSchema>,
+>(schemaRecord: Schema): UnannotateSchemaRecord<Schema> {
+	return Object.fromEntries(
+		Object.entries(schemaRecord).map(([key, schema]) => [
+			key,
+			schema instanceof FieldSchema ? schema : unannotateImplicitAllowedTypes(schema),
+		]),
+	) as UnannotateSchemaRecord<Schema>;
+}
+
 const targetToProxy: WeakMap<object, TreeNode> = new WeakMap();
 
 /**
@@ -595,3 +666,112 @@ export function createUnknownOptionalFieldPolicy(
 		);
 	};
 }
+
+/**
+ * {@link TreeNodeSchemaInitializedData.toFlexContent} for Map nodes.
+ *
+ * Transforms data under an Object schema.
+ * @param data - The tree data to be transformed. Must be a Record-like object.
+ * @param schema - The schema to comply with.
+ */
+function objectToFlexContent(
+	data: FactoryContent,
+	schema: TreeNodeSchema & ObjectNodeSchemaInternalData,
+): FlexContent {
+	if (
+		typeof data !== "object" ||
+		data === null ||
+		Symbol.iterator in data ||
+		isFluidHandle(data)
+	) {
+		throw new UsageError(`Input data is incompatible with Object schema: ${data}`);
+	}
+
+	const fields = new Map<FieldKey, UnhydratedFlexTreeField>();
+	const context = getUnhydratedContext(schema).flexContext;
+
+	for (const [key, fieldInfo] of schema.flexKeyMap) {
+		const value = getFieldProperty(data, key);
+
+		let children: UnhydratedFlexTreeNode[] | ContextualFieldProvider;
+		if (value === undefined) {
+			const defaultProvider =
+				fieldInfo.schema.props?.defaultProvider ??
+				fail(0xbb1 /* missing field has no default provider */);
+			const fieldProvider = extractFieldProvider(defaultProvider);
+			children = isConstant(fieldProvider) ? fieldProvider() : fieldProvider;
+		} else {
+			children = [
+				unhydratedFlexTreeFromInsertableNode(value, fieldInfo.schema.allowedTypeSet),
+			];
+		}
+
+		const kind =
+			convertFieldKind.get(fieldInfo.schema.kind) ?? fail(0xbb2 /* Invalid field kind */);
+		fields.set(
+			fieldInfo.storedKey,
+			createField(context, kind.identifier, fieldInfo.storedKey, children),
+		);
+	}
+
+	return [{ type: brand(schema.identifier) }, fields];
+}
+
+/**
+ * {@link TreeNodeSchemaInitializedData.shallowCompatibilityTest} for Object nodes.
+ */
+function shallowCompatibilityTest(
+	data: FactoryContent,
+	schema: ObjectNodeSchema & ObjectNodeSchemaInternalData,
+): CompatibilityLevel {
+	if (isTreeValue(data)) {
+		return CompatibilityLevel.None;
+	}
+
+	if (Symbol.iterator in data) {
+		return CompatibilityLevel.None;
+	}
+
+	// TODO: Improve type inference by making this logic more thorough. Handle at least:
+	// * Types which are strict subsets of other types in the same polymorphic union
+	// * Types which have the same keys but different types for those keys in the polymorphic union
+	// * Types which have the same required fields but different optional fields and enough of those optional fields are populated to disambiguate
+
+	// TODO#7441: Consider allowing data to be inserted which has keys that are extraneous/unknown to the schema (those keys are ignored)
+
+	// If the schema has a required key which is not present in the input object, reject it.
+	for (const [fieldKey, fieldSchema] of schema.fields) {
+		if (fieldSchema.requiresValue) {
+			if (getFieldProperty(data, fieldKey) === undefined) {
+				return CompatibilityLevel.None;
+			}
+		}
+	}
+
+	return CompatibilityLevel.Normal;
+}
+
+/**
+ * Check {@link FactoryContentObject} for a property which could be store a field.
+ *
+ * @returns If the property exists, return its value. Otherwise, returns undefined.
+ * @remarks
+ * The currently policy is to only consider own properties.
+ * See {@link InsertableObjectFromSchemaRecord} for where this policy is documented in the public API.
+ *
+ * Explicit undefined values are treated the same as missing properties to allow explicit use of undefined with defaulted identifiers.
+ *
+ * @privateRemarks
+ * If we ever want to have an optional field which defaults to something other than undefined, this will need changes.
+ * It would need to adjusting the handling of explicit undefined in contexts where undefined is allowed, and a default provider also exists.
+ */
+function getFieldProperty(
+	data: FactoryContentObject,
+	key: string | symbol,
+): InsertableContent | undefined {
+	// This policy only allows own properties.
+	if (Object.hasOwnProperty.call(data, key)) {
+		return (data as Record<string, InsertableContent>)[key as string];
+	}
+	return undefined;
+}

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

@@ -12,9 +12,14 @@ import type {
 import type {
 	FieldSchemaAlpha,
 	ImplicitAnnotatedFieldSchema,
-	UnannotateSchemaRecord,
-} from "../../schemaTypes.js";
-import { NodeKind, type TreeNodeSchemaClass, type TreeNodeSchema } from "../../core/index.js";
+	UnannotateImplicitFieldSchema,
+} from "../../fieldSchema.js";
+import {
+	NodeKind,
+	type TreeNodeSchemaClass,
+	type TreeNodeSchema,
+	type TreeNodeSchemaCorePrivate,
+} from "../../core/index.js";
 import type { FieldKey } from "../../../core/index.js";
 import type { SimpleObjectFieldSchema, SimpleObjectNodeSchema } from "../../simpleSchema.js";
 
@@ -46,10 +51,20 @@ export interface ObjectNodeSchema<
 	readonly fields: ReadonlyMap<string, FieldSchemaAlpha & SimpleObjectFieldSchema>;
 }
 
+/**
+ * Removes annotations from field schemas in a schema record.
+ * @system @alpha
+ */
+export type UnannotateSchemaRecord<
+	T extends RestrictiveStringRecord<ImplicitAnnotatedFieldSchema>,
+> = {
+	readonly [P in Extract<keyof T, string>]: UnannotateImplicitFieldSchema<T[P]>;
+};
+
 /**
  * Extra data provided on all {@link ObjectNodeSchema} that is not included in the (soon possibly public) ObjectNodeSchema type.
  */
-export interface ObjectNodeSchemaInternalData {
+export interface ObjectNodeSchemaInternalData extends TreeNodeSchemaCorePrivate {
 	/**
 	 * {@inheritdoc SimpleKeyMap}
 	 */
@@ -86,7 +101,9 @@ export const ObjectNodeSchema = {
 /**
  * {@link ObjectNodeSchema} with data that is not part of the package-exported API surface.
  */
-export type ObjectNodeSchemaPrivate = ObjectNodeSchema & ObjectNodeSchemaInternalData;
+export type ObjectNodeSchemaPrivate = ObjectNodeSchema &
+	ObjectNodeSchemaInternalData &
+	TreeNodeSchemaCorePrivate;
 
 export function isObjectNodeSchema(schema: TreeNodeSchema): schema is ObjectNodeSchemaPrivate {
 	return schema.kind === NodeKind.Object;