@fluidframework/tree 2.33.2 → 2.40.0

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

@@ -4,13 +4,8 @@
  */
 
 import { assert } from "@fluidframework/core-utils/internal";
-import { UsageError } from "@fluidframework/telemetry-utils/internal";
 import type { ErasedType } from "@fluidframework/core-interfaces";
 
-import { NodeKind, type TreeNodeSchemaClass } from "./treeNodeSchema.js";
-// eslint-disable-next-line import/no-deprecated
-import { type WithType, typeNameSymbol, type typeSchemaSymbol } from "./withType.js";
-import { tryGetTreeNodeSchema } from "./treeNodeKernel.js";
 import { isFlexTreeNode, type FlexTreeNode } from "../../feature-libraries/index.js";
 
 /**
@@ -29,235 +24,6 @@ import { isFlexTreeNode, type FlexTreeNode } from "../../feature-libraries/index
  */
 export type Unhydrated<T> = T;
 
-/**
- * A collection of events that can be emitted by a {@link TreeNode}.
- *
- * @privateRemarks
- * TODO: add a way to subscribe to a specific field (for nodeChanged and treeChanged).
- * Probably have object node and map node specific APIs for this.
- *
- * TODO: ensure that subscription API for fields aligns with API for subscribing to the root.
- *
- * TODO: add more wider area (avoid needing tons of nodeChanged registration) events for use-cases other than treeChanged.
- * Some ideas:
- *
- * - treeChanged, but with some subtrees/fields/paths excluded
- * - helper to batch several nodeChanged calls to a treeChanged scope
- * - parent change (ex: registration on the parent field for a specific index: maybe allow it for a range. Ex: node event takes optional field and optional index range?)
- * - new content inserted into subtree. Either provide event for this and/or enough info to treeChanged to find and search the new sub-trees.
- * Add separate (non event related) API to efficiently scan tree for given set of types (using low level cursor and schema based filtering)
- * to allow efficiently searching for new content (and initial content) of a given type.
- *
- * @sealed @public
- */
-export interface TreeChangeEvents {
-	/**
-	 * Emitted by a node after a batch of changes has been applied to the tree, if any of the changes affected the node.
-	 *
-	 * - Object nodes define a change as being when the value of one of its properties changes (i.e., the property's value is set, including when set to `undefined`).
-	 *
-	 * - Array nodes define a change as when an element is added, removed, moved or replaced.
-	 *
-	 * - Map nodes define a change as when an entry is added, updated, or removed.
-	 *
-	 * @param unstable - Future versions of this API (such as the one in beta on TreeBeta) may use this argument to provide additional data to the event.
-	 * users of this event should ensure that they do not provide a listener callback which has an optional parameter in this position, since unexpected data might get provided to it.
-	 * This parameter exists to capture this fact in the type system.
-	 * Using an inline lambda expression as the listener callback is a good pattern to avoid cases like this were arguments are added from breaking due to optional arguments.
-	 *
-	 * @remarks
-	 * This event is not emitted when:
-	 *
-	 * - Properties of a child node change. Notably, updates to an array node or a map node (like adding or removing
-	 * elements/entries) will emit this event on the array/map node itself, but not on the node that contains the
-	 * array/map node as one of its properties.
-	 *
-	 * - The node is moved to a different location in the tree or removed from the tree.
-	 * In this case the event is emitted on the _parent_ node, not the node itself.
-	 *
-	 * For remote edits, this event is not guaranteed to occur in the same order or quantity that it did in
-	 * the client that made the original edit.
-	 *
-	 * When the event is emitted, the tree is guaranteed to be in-schema.
-	 *
-	 * @privateRemarks
-	 * This event occurs whenever the apparent contents of the node instance change, regardless of what caused the change.
-	 * For example, it will fire when the local client reassigns a child, when part of a remote edit is applied to the
-	 * node, or when the node has to be updated due to resolution of a merge conflict
-	 * (for example a previously applied local change might be undone, then reapplied differently or not at all).
-	 *
-	 * TODO: define and document event ordering (ex: bottom up, with nodeChanged before treeChange on each level).
-	 */
-	nodeChanged(unstable?: unknown): void;
-
-	/**
-	 * Emitted by a node after a batch of changes has been applied to the tree, when something changed anywhere in the
-	 * subtree rooted at it.
-	 *
-	 * @remarks
-	 * This event is not emitted when the node itself is moved to a different location in the tree or removed from the tree.
-	 * In that case it is emitted on the _parent_ node, not the node itself.
-	 *
-	 * The node itself is part of the subtree, so this event will be emitted even if the only changes are to the properties
-	 * of the node itself.
-	 *
-	 * For remote edits, this event is not guaranteed to occur in the same order or quantity that it did in
-	 * the client that made the original edit.
-	 *
-	 * When it is emitted, the tree is guaranteed to be in-schema.
-	 */
-	treeChanged(): void;
-}
-
-/**
- * A non-{@link NodeKind.Leaf|leaf} SharedTree node. Includes objects, arrays, and maps.
- *
- * @remarks
- * Base type which all nodes extend.
- *
- * This type can be used as a type to indicate/document values which should be tree nodes.
- * Runtime use of this class object (for example when used with `instanceof` or extending it), is not currently supported.
- *
- * There are three ways to get instances of TreeNode:
- *
- * 1. From a {@link TreeView} loading nodes from an existing document, or creating local copies of nodes inserted by a remote collaborator.
- * This case provides an {@link InternalTreeNode} to the constructor: subclasses must not modify how the constructor handles this case.
- * 2. Explicit construction of {@link Unhydrated} nodes using either {@link TreeNodeSchemaClass} as a constructor or {@link TreeNodeSchemaNonClass|TreeNodeSchemaNonClass.create}.
- * Either way the {@link TreeNodeSchema} produced must be produced using a {@link SchemaFactory}.
- * 3. Implicit construction: Several APIs which logically require an unhydrated TreeNode also allow passing in a value which could be used to explicitly construct the node instead.
- * These APIs internally call the constructor with the provided value, so it's really just a special case of the above option.
- * Note that when constructing nodes, sometimes implicit construction is not allowed
- * (either at runtime due to ambiguous types or at compile time due to TypeScript limitations):
- * in such cases, explicit construction must be used.
- *
- * @privateRemarks
- * This is a class not an interface to enable stricter type checking (see {@link TreeNode.#brand})
- * and some runtime enforcement of schema class policy (see the the validation in the constructor).
- * This class is however only `type` exported not value exported, preventing the class object from being used,
- * similar to how interfaces work.
- *
- * Not all node implementations include this in their prototype chain (some hide it with a proxy),
- * and thus cause the default/built in `instanceof` to return false despite our type checking and all other APIs treating them as TreeNodes.
- * This class provides a custom `Symbol.hasInstance` to fix `instanceof` for this class and all classes extending it.
- * For now the type-only export prevents use of `instanceof` on this class (but allows it in subclasses like schema classes).
- * @sealed @public
- */
-export abstract class TreeNode implements WithType {
-	/**
-	 * This is added to prevent TypeScript from implicitly allowing non-TreeNode types to be used as TreeNodes.
-	 * @remarks
-	 * This field forces TypeScript to use nominal instead of structural typing,
-	 * preventing compiler error messages and tools like "add missing properties"
-	 * from adding the [type] field as a solution when using a non-TreeNode object where a TreeNode is required.
-	 * Instead TreeNodes must be created through the appropriate APIs, see the documentation on {@link TreeNode} for details.
-	 *
-	 * @privateRemarks
-	 * This is a JavaScript private field, so is not accessible from outside this class.
-	 * This prevents it from having name collisions with object fields.
-	 * Since this is private, the type of this field is stripped in the d.ts file.
-	 * To get matching type checking within and from outside the package, the least informative type (`unknown`) is used.
-	 * To avoid this having any runtime impact, the field is uninitialized.
-	 *
-	 * Making this field optional results in different type checking within this project than outside of it, since the d.ts file drops the optional aspect of the field.
-	 * This is extra confusing since since the tests get in-project typing for intellisense and separate project checking at build time.
-	 * To avoid all this mess, this field is required, not optional.
-	 *
-	 * Another option would be to use a symbol (possibly as a private field).
-	 * That approach ran into some strange difficulties causing SchemaFactory to fail to compile, and was not investigated further.
-	 *
-	 * The [type] symbol provides a lot of the value this private brand does, but is not all of it:
-	 * someone could manually (or via Intellisense auto-implement completion, or in response to a type error)
-	 * make an object literal with the [type] field and pass it off as a node: this private brand prevents that.
-	 */
-	readonly #brand!: unknown;
-
-	/**
-	 * Adds a type symbol for stronger typing.
-	 * @privateRemarks
-	 * Subclasses provide more specific strings for this to get strong typing of otherwise type compatible nodes.
-	 * @deprecated Use {@link typeSchemaSymbol} instead.
-	 */
-	// eslint-disable-next-line import/no-deprecated
-	public abstract get [typeNameSymbol](): string;
-
-	/**
-	 * Adds a type symbol for stronger typing.
-	 * @privateRemarks
-	 * Subclasses provide more specific strings for this to get strong typing of otherwise type compatible nodes.
-	 */
-	public abstract get [typeSchemaSymbol](): TreeNodeSchemaClass;
-
-	/**
-	 * Provides `instanceof` support for testing if a value is a `TreeNode`.
-	 * @remarks
-	 * For more options, like including leaf values or narrowing to collections of schema, use `is` or `schema` from {@link TreeNodeApi}.
-	 * @privateRemarks
-	 * Due to type-only export, this functionality is not available outside the package.
-	 */
-	public static [Symbol.hasInstance](value: unknown): value is TreeNode;
-
-	/**
-	 * Provides `instanceof` support for all schema classes with public constructors.
-	 * @remarks
-	 * For more options, like including leaf values or narrowing to collections of schema, use `is` or `schema` from {@link TreeNodeApi}.
-	 * @privateRemarks
-	 * Despite type-only export, this functionality is available outside the package since it is inherited by subclasses.
-	 */
-	public static [Symbol.hasInstance]<
-		TSchema extends abstract new (
-			...args: any[]
-		) => TreeNode,
-	>(this: TSchema, value: unknown): value is InstanceType<TSchema>;
-
-	public static [Symbol.hasInstance](this: { prototype: object }, value: unknown): boolean {
-		const schema = tryGetTreeNodeSchema(value);
-
-		if (schema === undefined || schema.kind === NodeKind.Leaf) {
-			return false;
-		}
-
-		assert("prototype" in schema, 0x98a /* expected class based schema */);
-		return inPrototypeChain(schema.prototype, this.prototype);
-	}
-
-	/**
-	 * TreeNodes must extend schema classes created by SchemaFactory, and therefore this constructor should not be invoked directly by code outside this package.
-	 * @privateRemarks
-	 * `token` must be the {@link privateToken} value, which is not package exported.
-	 * This is used to detect invalid subclasses.
-	 *
-	 * All valid subclass should use {@link TreeNodeValid}, but this code doesn't directly reference it to avoid cyclic dependencies.
-	 */
-	protected constructor(token: unknown) {
-		if (token !== privateToken) {
-			throw new UsageError("TreeNodes must extend schema classes created by SchemaFactory");
-		}
-	}
-}
-
-/**
- * `token` to pass to {@link TreeNode}'s constructor used to detect invalid subclasses.
- */
-export const privateToken = {};
-
-/**
- * Check if the prototype derived's prototype chain contains `base`.
- * @param derived - prototype to check
- * @param base - prototype to search for
- * @returns true iff `base` is in the prototype chain starting at `derived`.
- */
-// eslint-disable-next-line @rushstack/no-new-null
-export function inPrototypeChain(derived: object | null, base: object): boolean {
-	let checking = derived;
-	while (checking !== null) {
-		if (base === checking) {
-			return true;
-		}
-		checking = Reflect.getPrototypeOf(checking);
-	}
-	return false;
-}
-
 /**
  * A node type internal to `@fluidframework/tree`.
  * @remarks

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

@@ -4,7 +4,7 @@
  */
 
 import type { NodeKind, TreeNodeSchemaClass } from "./treeNodeSchema.js";
-import type { TreeNode } from "./types.js";
+import type { TreeNode } from "./treeNode.js";
 
 /**
  * The type of a {@link TreeNode}.

package/src/simple-tree/index.ts

@@ -12,7 +12,6 @@ export {
 	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,
@@ -81,7 +80,7 @@ export {
 	comparePersistedSchema,
 	type ConciseTree,
 	comparePersistedSchemaInternal,
-	ViewSchema,
+	SchemaCompatibilityTester,
 	type Unenforced,
 	type System_Unsafe,
 	type ArrayNodeCustomizableSchemaUnsafe,
@@ -120,6 +119,10 @@ export {
 	allowUnused,
 	type FieldSchemaAlphaUnsafe,
 	type TreeSchema,
+	type ValidateRecursiveSchemaTemplate,
+	type FixRecursiveRecursionLimit,
+	schemaStatics,
+	type TreeChangeEvents,
 } from "./api/index.js";
 export type {
 	SimpleTreeSchema,
@@ -135,13 +138,26 @@ export type {
 export {
 	type NodeFromSchema,
 	isTreeNodeSchemaClass,
+	type AnnotatedAllowedType,
+	type AnnotatedAllowedTypes,
 	type ImplicitFieldSchema,
+	type ImplicitAnnotatedFieldSchema,
 	type TreeFieldFromImplicitField,
 	type ImplicitAllowedTypes,
+	type ImplicitAnnotatedAllowedTypes,
+	type UnannotateImplicitAllowedTypes,
+	type UnannotateAllowedTypes,
+	type UnannotateAllowedType,
+	type UnannotateAllowedTypesList,
+	type UnannotateAllowedTypeOrLazyItem,
+	type UnannotateImplicitFieldSchema,
+	type UnannotateSchemaRecord,
 	type TreeNodeFromImplicitAllowedTypes,
 	type InsertableTreeNodeFromImplicitAllowedTypes,
 	type TreeLeafValue,
 	type AllowedTypes,
+	type AllowedTypeMetadata,
+	type AllowedTypesMetadata,
 	FieldKind,
 	FieldSchema,
 	type FieldSchemaAlpha,
@@ -191,6 +207,7 @@ export {
 	type FieldHasDefault,
 	type InsertableObjectFromSchemaRecord,
 	type ObjectFromSchemaRecord,
+	type InsertableObjectFromAnnotatedSchemaRecord,
 	type TreeObjectNode,
 	setField,
 	createUnknownOptionalFieldPolicy,

package/src/simple-tree/mapNode.ts

@@ -15,10 +15,13 @@ import {
 	createFieldSchema,
 	FieldKind,
 	normalizeAllowedTypes,
+	unannotateImplicitAllowedTypes,
 	type ImplicitAllowedTypes,
+	type ImplicitAnnotatedAllowedTypes,
 	type InsertableTreeNodeFromImplicitAllowedTypes,
 	type NodeSchemaMetadata,
 	type TreeNodeFromImplicitAllowedTypes,
+	type UnannotateImplicitAllowedTypes,
 } from "./schemaTypes.js";
 import {
 	getKernel,
@@ -233,7 +236,7 @@ abstract class CustomMapNodeBase<const T extends ImplicitAllowedTypes> extends T
 // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
 export function mapSchema<
 	TName extends string,
-	const T extends ImplicitAllowedTypes,
+	const T extends ImplicitAnnotatedAllowedTypes,
 	const ImplicitlyConstructable extends boolean,
 	const TCustomMetadata = unknown,
 >(
@@ -243,14 +246,19 @@ export function mapSchema<
 	useMapPrototype: boolean,
 	metadata?: NodeSchemaMetadata<TCustomMetadata>,
 ) {
-	const lazyChildTypes = new Lazy(() => normalizeAllowedTypes(info));
+	const lazyChildTypes = new Lazy(() =>
+		normalizeAllowedTypes(unannotateImplicitAllowedTypes(info)),
+	);
 	const lazyAllowedTypesIdentifiers = new Lazy(
 		() => new Set([...lazyChildTypes.value].map((type) => type.identifier)),
 	);
 
 	let unhydratedContext: Context;
 
-	class Schema extends CustomMapNodeBase<T> implements TreeMapNode<T> {
+	class Schema
+		extends CustomMapNodeBase<UnannotateImplicitAllowedTypes<T>>
+		implements TreeMapNode<UnannotateImplicitAllowedTypes<T>>
+	{
 		public static override prepareInstance<T2>(
 			this: typeof TreeNodeValid<T2>,
 			instance: TreeNodeValid<T2>,

package/src/simple-tree/mapNodeTypes.ts

@@ -4,7 +4,10 @@
  */
 
 import type { MapNodeInsertableData, TreeMapNode } from "./mapNode.js";
-import type { ImplicitAllowedTypes } from "./schemaTypes.js";
+import type {
+	ImplicitAnnotatedAllowedTypes,
+	UnannotateImplicitAllowedTypes,
+} from "./schemaTypes.js";
 import {
 	NodeKind,
 	type TreeNodeSchemaClass,
@@ -21,14 +24,14 @@ import type { SimpleMapNodeSchema } from "./simpleSchema.js";
  */
 export interface MapNodeCustomizableSchema<
 	out TName extends string = string,
-	in out T extends ImplicitAllowedTypes = ImplicitAllowedTypes,
+	in out T extends ImplicitAnnotatedAllowedTypes = ImplicitAnnotatedAllowedTypes,
 	out ImplicitlyConstructable extends boolean = true,
 	out TCustomMetadata = unknown,
 > extends TreeNodeSchemaClass<
 			TName,
 			NodeKind.Map,
-			TreeMapNode<T> & WithType<TName, NodeKind.Map, T>,
-			MapNodeInsertableData<T>,
+			TreeMapNode<UnannotateImplicitAllowedTypes<T>> & WithType<TName, NodeKind.Map, T>,
+			MapNodeInsertableData<UnannotateImplicitAllowedTypes<T>>,
 			ImplicitlyConstructable,
 			T,
 			undefined,
@@ -42,14 +45,14 @@ export interface MapNodeCustomizableSchema<
  */
 export interface MapNodePojoEmulationSchema<
 	out TName extends string = string,
-	in out T extends ImplicitAllowedTypes = ImplicitAllowedTypes,
+	in out T extends ImplicitAnnotatedAllowedTypes = ImplicitAnnotatedAllowedTypes,
 	out ImplicitlyConstructable extends boolean = true,
 	out TCustomMetadata = unknown,
 > extends TreeNodeSchemaNonClass<
 			TName,
 			NodeKind.Map,
-			TreeMapNode<T> & WithType<TName, NodeKind.Map, T>,
-			MapNodeInsertableData<T>,
+			TreeMapNode<UnannotateImplicitAllowedTypes<T>> & WithType<TName, NodeKind.Map, T>,
+			MapNodeInsertableData<UnannotateImplicitAllowedTypes<T>>,
 			ImplicitlyConstructable,
 			T,
 			undefined,

package/src/simple-tree/objectNode.ts

@@ -29,6 +29,9 @@ import {
 	type NodeSchemaMetadata,
 	type FieldSchemaAlpha,
 	ObjectFieldSchema,
+	type ImplicitAnnotatedFieldSchema,
+	unannotateSchemaRecord,
+	type UnannotateSchemaRecord,
 } from "./schemaTypes.js";
 import {
 	type TreeNodeSchema,
@@ -59,7 +62,7 @@ import type { SimpleObjectFieldSchema } from "./simpleSchema.js";
  * @remarks
  * Due to {@link https://github.com/microsoft/TypeScript/issues/43826}, we can't enable implicit construction of {@link TreeNode|TreeNodes} for setters.
  * Therefore code assigning to these fields must explicitly construct nodes using the schema's constructor or create method,
- * or using some other method like {@link TreeAlpha.create}.
+ * or using some other method like {@link (TreeAlpha:interface).create}.
  * @system @public
  */
 export type ObjectFromSchemaRecord<T extends RestrictiveStringRecord<ImplicitFieldSchema>> =
@@ -92,7 +95,9 @@ export type TreeObjectNode<
 > = TreeNode & ObjectFromSchemaRecord<T> & WithType<TypeName, NodeKind.Object, T>;
 
 /**
- * Type utility for determining whether or not an implicit field schema has a default value.
+ * Type utility for determining if an implicit field schema is known to have a default value.
+ *
+ * @remarks Yields `false` when unknown.
  *
  * @privateRemarks
  * TODO: Account for field schemas with default value providers.
@@ -100,9 +105,9 @@ export type TreeObjectNode<
  *
  * @system @public
  */
-export type FieldHasDefault<T extends ImplicitFieldSchema> = T extends FieldSchema<
-	FieldKind.Optional | FieldKind.Identifier
->
+export type FieldHasDefault<T extends ImplicitFieldSchema> = [T] extends [
+	FieldSchema<FieldKind.Optional | FieldKind.Identifier>,
+]
 	? true
 	: false;
 
@@ -154,6 +159,18 @@ export type InsertableObjectFromSchemaRecord<
 			}
 		>;
 
+/**
+ * Helper used to remove annotations from a schema record and produce insertable objects,
+ *
+ * @privateremarks
+ * This calls {@link InsertableObjectFromSchemaRecord} in order to produce the insertable objects.
+ *
+ * @system @alpha
+ */
+export type InsertableObjectFromAnnotatedSchemaRecord<
+	T extends RestrictiveStringRecord<ImplicitAnnotatedFieldSchema>,
+> = InsertableObjectFromSchemaRecord<UnannotateSchemaRecord<T>>;
+
 /**
  * Maps from simple field keys ("property" keys) to information about the field.
  *
@@ -354,7 +371,7 @@ abstract class CustomObjectNodeBase<
  */
 export function objectSchema<
 	TName extends string,
-	const T extends RestrictiveStringRecord<ImplicitFieldSchema>,
+	const T extends RestrictiveStringRecord<ImplicitAnnotatedFieldSchema>,
 	const ImplicitlyConstructable extends boolean,
 	const TCustomMetadata = unknown,
 >(
@@ -368,12 +385,14 @@ export function objectSchema<
 	// Field set can't be modified after this since derived data is stored in maps.
 	Object.freeze(info);
 
+	const unannotatedInfo = unannotateSchemaRecord(info);
+
 	// Ensure no collisions between final set of property keys, and final set of stored keys (including those
 	// implicitly derived from property keys)
-	assertUniqueKeys(identifier, info);
+	assertUniqueKeys(identifier, unannotatedInfo);
 
 	// Performance optimization: cache property key => stored key and schema.
-	const flexKeyMap: SimpleKeyMap = createFlexKeyMapping(info);
+	const flexKeyMap: SimpleKeyMap = createFlexKeyMapping(unannotatedInfo);
 
 	const identifierFieldKeys: FieldKey[] = [];
 	for (const item of flexKeyMap.values()) {
@@ -390,17 +409,22 @@ export function objectSchema<
 	let customizable: boolean;
 	let unhydratedContext: Context;
 
-	class CustomObjectNode extends CustomObjectNodeBase<T> {
+	class CustomObjectNode extends CustomObjectNodeBase<UnannotateSchemaRecord<T>> {
 		public static readonly fields: ReadonlyMap<
 			string,
 			FieldSchemaAlpha & SimpleObjectFieldSchema
 		> = new Map(
 			Array.from(flexKeyMap, ([key, value]) => [
 				key as string,
-				new ObjectFieldSchema(value.schema.kind, value.schema.allowedTypes, {
-					...value.schema.props,
-					key: getStoredKey(key as string, value.schema),
-				}),
+				new ObjectFieldSchema(
+					value.schema.kind,
+					value.schema.allowedTypes,
+					(value.schema as FieldSchemaAlpha).annotatedAllowedTypes,
+					{
+						...value.schema.props,
+						key: getStoredKey(key as string, value.schema),
+					},
+				),
 			]),
 		);
 		public static readonly flexKeyMap: SimpleKeyMap = flexKeyMap;
@@ -513,8 +537,8 @@ export function objectSchema<
 	}
 	type Output = typeof CustomObjectNode &
 		(new (
-			input: InsertableObjectFromSchemaRecord<T> | InternalTreeNode,
-		) => TreeObjectNode<T, TName>);
+			input: InsertableObjectFromAnnotatedSchemaRecord<T> | InternalTreeNode,
+		) => TreeObjectNode<UnannotateSchemaRecord<T>, TName>);
 	return CustomObjectNode as Output;
 }
 

package/src/simple-tree/objectNodeTypes.ts

@@ -6,10 +6,14 @@
 import type { RestrictiveStringRecord } from "../util/index.js";
 import type {
 	TreeObjectNode,
-	InsertableObjectFromSchemaRecord,
 	SimpleKeyMap,
+	InsertableObjectFromAnnotatedSchemaRecord,
 } from "./objectNode.js";
-import type { ImplicitFieldSchema, FieldSchemaAlpha } from "./schemaTypes.js";
+import type {
+	FieldSchemaAlpha,
+	ImplicitAnnotatedFieldSchema,
+	UnannotateSchemaRecord,
+} from "./schemaTypes.js";
 import { NodeKind, type TreeNodeSchemaClass, type TreeNodeSchema } from "./core/index.js";
 import type { FieldKey } from "../core/index.js";
 import type { SimpleObjectFieldSchema, SimpleObjectNodeSchema } from "./simpleSchema.js";
@@ -22,14 +26,14 @@ import type { SimpleObjectFieldSchema, SimpleObjectNodeSchema } from "./simpleSc
 export interface ObjectNodeSchema<
 	out TName extends string = string,
 	in out T extends
-		RestrictiveStringRecord<ImplicitFieldSchema> = RestrictiveStringRecord<ImplicitFieldSchema>,
+		RestrictiveStringRecord<ImplicitAnnotatedFieldSchema> = RestrictiveStringRecord<ImplicitAnnotatedFieldSchema>,
 	ImplicitlyConstructable extends boolean = boolean,
 	out TCustomMetadata = unknown,
 > extends TreeNodeSchemaClass<
 			TName,
 			NodeKind.Object,
-			TreeObjectNode<T, TName>,
-			InsertableObjectFromSchemaRecord<T>,
+			TreeObjectNode<UnannotateSchemaRecord<T>, TName>,
+			InsertableObjectFromAnnotatedSchemaRecord<T>,
 			ImplicitlyConstructable,
 			T,
 			never,