@fluidframework/tree 2.90.0 → 2.91.0

package/{dist/legacy.d.ts → src/entrypoints/legacy.ts}

@@ -9,10 +9,6 @@
  */
 
 export {
-	// #region Unrestricted APIs
-	InternalTypes,
-	// #endregion
-	 
 	// #region @public APIs
 	AllowedTypes, 
 	CommitKind, 
@@ -32,6 +28,7 @@ export {
 	InsertableTreeNodeFromImplicitAllowedTypes, 
 	InsertableTypedNode, 
 	InternalTreeNode, 
+	InternalTypes, 
 	IsListener, 
 	IsUnion, 
 	IterableTreeArrayContent, 
@@ -156,4 +153,4 @@ export {
 	SharedTreeFactoryType, 
 	configuredSharedTreeBetaLegacy
 	// #endregion
-} from "./index.js";
+} from "../index.js";

package/{lib/public.d.ts → src/entrypoints/public.ts}

@@ -9,10 +9,6 @@
  */
 
 export {
-	// #region Unrestricted APIs
-	InternalTypes,
-	// #endregion
-	 
 	// #region @public APIs
 	AllowedTypes, 
 	CommitKind, 
@@ -32,6 +28,7 @@ export {
 	InsertableTreeNodeFromImplicitAllowedTypes, 
 	InsertableTypedNode, 
 	InternalTreeNode, 
+	InternalTypes, 
 	IsListener, 
 	IsUnion, 
 	IterableTreeArrayContent, 
@@ -91,4 +88,4 @@ export {
 	rollback, 
 	typeSchemaSymbol
 	// #endregion
-} from "./index.js";
+} from "../index.js";

package/src/feature-libraries/modular-schema/crossFieldQueries.ts

@@ -3,12 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import type {
-	ChangeAtomId,
-	ChangeAtomIdRangeMap,
-	ChangesetLocalId,
-	RevisionTag,
-} from "../../core/index.js";
+import type { ChangeAtomIdRangeMap, ChangesetLocalId, RevisionTag } from "../../core/index.js";
 import type { RangeQueryResult } from "../../util/index.js";
 
 import type { NodeId } from "./modularChangeTypes.js";
@@ -40,7 +35,7 @@ export function getFirstFromCrossFieldMap<T>(
 	revision: RevisionTag | undefined,
 	id: ChangesetLocalId,
 	count: number,
-): RangeQueryResult<ChangeAtomId, T> {
+): RangeQueryResult<T | undefined> {
 	return map.getFirst({ revision, localId: id }, count);
 }
 
@@ -64,7 +59,7 @@ export interface CrossFieldManager<T = unknown> {
 		id: ChangesetLocalId,
 		count: number,
 		addDependency: boolean,
-	): RangeQueryResult<ChangeAtomId, T>;
+	): RangeQueryResult<T | undefined>;
 
 	/**
 	 * Sets the range of keys to `newValue`.

package/src/feature-libraries/modular-schema/defaultRevisionReplacer.ts

@@ -60,14 +60,13 @@ export class DefaultRevisionReplacer implements RevisionReplacer {
 				const prior = this.updatedLocalIds.getFirst(remainderStart, remainderCount);
 				if (prior.value === undefined) {
 					const defaultOutputId = continuingOutputId ?? remainderStart.localId;
-					const newLocalId =
-						this.localIds.getAll(defaultOutputId, prior.length).length > 0
-							? // Some of the IDs in this range have already been used in the scope of the updated revision.
-								// We need to allocate new local IDs.
-								brand<ChangesetLocalId>(this.maxSeen + 1)
-							: // This change atom ID uses a local ID that has not yet been used in the scope of the updated revision.
-								// We reuse it as is to minimize the number of IDs that need to be updated.
-								defaultOutputId;
+					const newLocalId = this.areAllUnallocated(defaultOutputId, prior.length)
+						? // This change atom ID uses a local ID that has not yet been used in the scope of the updated revision.
+							// We reuse it as is to minimize the number of IDs that need to be updated.
+							defaultOutputId
+						: // Some of the IDs in this range have already been used in the scope of the updated revision.
+							// We need to allocate new local IDs.
+							brand<ChangesetLocalId>(this.maxSeen + 1);
 
 					this.maxSeen = brand(Math.max(this.maxSeen, newLocalId + prior.length - 1));
 					this.localIds.set(newLocalId, prior.length, true);
@@ -93,4 +92,13 @@ export class DefaultRevisionReplacer implements RevisionReplacer {
 		}
 		return id;
 	}
+
+	private areAllUnallocated(id: ChangesetLocalId, count: number): boolean {
+		for (const entry of this.localIds.getAll(id, count)) {
+			if (entry.value !== undefined) {
+				return false;
+			}
+		}
+		return true;
+	}
 }

package/src/feature-libraries/modular-schema/modularChangeFamily.ts

@@ -2387,7 +2387,7 @@ abstract class CrossFieldManagerI<T> implements CrossFieldManager {
 		id: ChangesetLocalId,
 		count: number,
 		addDependency: boolean,
-	): RangeQueryResult<ChangeAtomId, unknown> {
+	): RangeQueryResult<unknown> {
 		if (addDependency) {
 			// We assume that if there is already an entry for this ID it is because
 			// a field handler has called compose on the same node multiple times.
@@ -3148,9 +3148,14 @@ function getFieldsForCrossFieldKey(
 	key: CrossFieldKey,
 	count: number,
 ): FieldId[] {
-	return changeset.crossFieldKeys
-		.getAll(key, count)
-		.map(({ value: fieldId }) => normalizeFieldId(fieldId, changeset.nodeAliases));
+	const fieldIds: FieldId[] = [];
+	for (const { value: fieldId } of changeset.crossFieldKeys.getAll(key, count)) {
+		if (fieldId !== undefined) {
+			fieldIds.push(normalizeFieldId(fieldId, changeset.nodeAliases));
+		}
+	}
+
+	return fieldIds;
 }
 
 // This is only exported for use in test utilities.

package/src/feature-libraries/sequence-field/moveEffectTable.ts

@@ -101,7 +101,7 @@ export function getMoveEffect(
 	id: MoveId,
 	count: number,
 	addDependency: boolean = true,
-): RangeQueryResult<ChangeAtomId, MoveEffect> {
+): RangeQueryResult<MoveEffect | undefined> {
 	const result = moveEffects.get(target, revision, id, count, addDependency);
 	return result.value === undefined
 		? result

package/src/index.ts

@@ -3,6 +3,9 @@
  * Licensed under the MIT License.
  */
 
+// For the time being, if exports are changed, additional files under entrypoints need updated.
+// Run `pnpm generate:entrypoint-sources` to update them.
+
 export {
 	ValueSchema,
 	type Revertible,
@@ -122,6 +125,7 @@ export {
 	NodeKind,
 	type TreeObjectNode,
 	ObjectNodeSchema,
+	type ObjectNodeSchemaWorkaround,
 	type TreeNodeFromImplicitAllowedTypes,
 	type TreeNodeSchemaClass,
 	type SchemaCompatibilityStatus,
@@ -144,6 +148,8 @@ export {
 	type AllowedTypes,
 	type System_Unsafe,
 	type FieldSchemaAlphaUnsafe,
+	type FieldHasDefaultAlphaUnsafe,
+	type InsertableObjectFromSchemaRecordAlphaUnsafe,
 	type ArrayNodeCustomizableSchemaUnsafe,
 	type MapNodeCustomizableSchemaUnsafe,
 	type TreeRecordNodeUnsafe,
@@ -192,6 +198,10 @@ export {
 	type AllowedTypesFull,
 	type AllowedTypesFullFromMixed,
 	type SchemaType,
+	type SchemaStaticsAlpha,
+	type NodeProvider,
+	type InsertableObjectFromSchemaRecordAlpha,
+	type FieldHasDefaultAlpha,
 	// Beta APIs
 	TreeBeta,
 	type TreeChangeEventsBeta,
@@ -303,6 +313,9 @@ export {
 	incrementalEncodingPolicyForAllowedTypes,
 	eraseSchemaDetails,
 	eraseSchemaDetailsSubclassable,
+	type ErasedSchema,
+	type ErasedNode,
+	type ErasedSchemaSubclassable,
 	type SnapshotSchemaCompatibilityOptions,
 	type ArrayPlaceAnchor,
 	createArrayInsertionAnchor,
@@ -359,6 +372,12 @@ import * as InternalTypes from "./internalTypes.js";
 /**
  * Contains types used by the API, but which serve mechanical purposes and do not represent semantic concepts.
  * They are used internally to implement API aspects, but are not intended for use by external consumers.
+ *
+ * @public
+ * @system
+ *
+ * @privateRemarks These TS-Docs are not recognized by API-Extractor, but the
+ * support level tag is recognized by flub entrypoint generation.
  */
 // eslint-disable-next-line unicorn/prefer-export-from -- fixing requires `export * as` (breaks API-Extractor)
 export { InternalTypes };

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/tree";
-export const pkgVersion = "2.90.0";
+export const pkgVersion = "2.91.0";

package/src/shared-tree/treeCheckout.ts

@@ -786,7 +786,8 @@ export class TreeCheckout implements ITreeCheckoutFork {
 			revision,
 		};
 		const decodedChange = this.changeFamily.codecs.resolve(4).decode(change, context);
-		this.applyChange(decodedChange, revision);
+		// Apply the change to the branch, but _not_ the `activeBranch` - we do not support squashing serialized commits in a transaction.
+		this.#transaction.branch.apply(tagChange(decodedChange, revision));
 	}
 
 	// Revision is the revision of the commit, if any, which caused this change.

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

@@ -121,3 +121,63 @@ export function eraseSchemaDetailsSubclassable<TNode, ExtraSchemaProperties = un
 	> {
 	return (schema) => schema as never;
 }
+
+/**
+ * The type of an erased schema.
+ * @remarks
+ * Provides an {@link https://www.typescriptlang.org/tsconfig/#isolatedDeclarations | isolatedDeclarations}
+ * compatible way to explicitly type the return value from {@link eraseSchemaDetails}.
+ * @example
+ * ```typescript
+ * export const Square: SquareSchema & ErasedSchema<Square> = eraseSchemaDetails<Square, SquareSchema>()(SquareInternal);
+ * export type Square = ErasedNode<SquareNode, "com.example.Demo">;
+ * ```
+ * @alpha
+ */
+export type ErasedSchema<NodeType extends TreeNode> = TreeNodeSchema<
+	NodeType extends WithType<infer Identifier> ? Identifier : string,
+	NodeKind,
+	NodeType,
+	never,
+	false
+>;
+
+/**
+ * The type of an erased schema's node.
+ * @remarks
+ * Provides a way to concisely and explicitly type the node type for a schema returned from {@link eraseSchemaDetails}.
+ * @example
+ * ```typescript
+ * export const Square: SquareSchema & ErasedSchema<Square> = eraseSchemaDetails<Square, SquareSchema>()(SquareInternal);
+ * export type Square = ErasedNode<SquareNode, "com.example.Demo">;
+ * ```
+ * @alpha
+ */
+export type ErasedNode<TExtra, Identifier extends string> = TExtra &
+	TreeNode &
+	WithType<Identifier>;
+
+/**
+ * The type of a subclassable erased schema.
+ * @remarks
+ * Provides an {@link https://www.typescriptlang.org/tsconfig/#isolatedDeclarations | isolatedDeclarations}
+ * compatible way to explicitly type the return value from {@link eraseSchemaDetailsSubclassable}.
+ * @example
+ * ```typescript
+ * export const SquareSubclassable: SquareSchema &
+ * 	ErasedSchemaSubclassable<SquareNode, "com.example.Demo"> = eraseSchemaDetailsSubclassable<
+ * 	Square,
+ * 	SquareSchema
+ * >()(SquareInternal);
+ *
+ * class SquareSubclass extends SquareSubclassable {}
+ * ```
+ * @alpha
+ */
+export type ErasedSchemaSubclassable<TExtra, Identifier extends string> = TreeNodeSchemaClass<
+	Identifier,
+	NodeKind,
+	ErasedNode<TExtra, Identifier>,
+	never,
+	false
+>;

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

@@ -38,11 +38,20 @@ export {
 	type SchemaFactory_base,
 } from "./schemaFactory.js";
 export { SchemaFactoryBeta, type SchemaStaticsBeta } from "./schemaFactoryBeta.js";
-export { SchemaFactoryAlpha } from "./schemaFactoryAlpha.js";
+export {
+	SchemaFactoryAlpha,
+	type SchemaStaticsAlpha,
+	type NodeProvider,
+} from "./schemaFactoryAlpha.js";
 export {
 	eraseSchemaDetails,
 	eraseSchemaDetailsSubclassable,
 } from "./eraseSchemaDetails.js";
+export type {
+	ErasedSchema,
+	ErasedNode,
+	ErasedSchemaSubclassable,
+} from "./eraseSchemaDetails.js";
 export type {
 	ValidateRecursiveSchema,
 	FixRecursiveArraySchema,
@@ -105,6 +114,8 @@ export type {
 	AllowedTypesFullFromMixedUnsafe,
 	UnannotateAllowedTypesListUnsafe,
 	AnnotateAllowedTypesListUnsafe,
+	FieldHasDefaultAlphaUnsafe,
+	InsertableObjectFromSchemaRecordAlphaUnsafe,
 } from "./typesUnsafe.js";
 
 export {

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

@@ -403,7 +403,14 @@ export class SchemaFactory<
 	> {
 		return objectSchema(scoped(this, name), fields, true, {
 			...defaultSchemaFactoryObjectOptions,
-		});
+		}) as TreeNodeSchemaClass<
+			ScopedSchemaName<TScope, Name>,
+			NodeKind.Object,
+			TreeObjectNode<T, ScopedSchemaName<TScope, Name>>,
+			object & InsertableObjectFromSchemaRecord<T>,
+			true,
+			T
+		>;
 	}
 
 	/**

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

@@ -4,20 +4,27 @@
  */
 
 import type { RestrictiveStringRecord } from "../../util/index.js";
-import type {
-	NodeKind,
-	TreeNodeSchemaClass,
-	ImplicitAllowedTypes,
-	WithType,
+import {
+	type NodeKind,
+	type TreeNodeSchemaClass,
+	type ImplicitAllowedTypes,
+	type WithType,
+	normalizeAllowedTypes,
+	isTreeNode,
 } from "../core/index.js";
-import type { ImplicitFieldSchema } from "../fieldSchema.js";
 // These imports prevent a large number of type references in the API reports from showing up as *_2.
 /* eslint-disable unused-imports/no-unused-imports, @typescript-eslint/no-unused-vars, import-x/no-duplicates */
-import type {
-	FieldProps,
-	FieldSchemaAlpha,
-	FieldPropsAlpha,
-	FieldKind,
+import {
+	type FieldProps,
+	type FieldSchemaAlpha,
+	type FieldPropsAlpha,
+	type FieldKind,
+	type ImplicitFieldSchema,
+	type InsertableTreeFieldFromImplicitField,
+	type FieldSchema,
+	getDefaultProvider,
+	createFieldSchema,
+	type DefaultProvider,
 } from "../fieldSchema.js";
 import type { LeafSchema } from "../leafNodeSchema.js";
 import {
@@ -26,12 +33,14 @@ import {
 	type MapNodeCustomizableSchema,
 	mapSchema,
 	type ObjectNodeSchema,
+	type ObjectNodeSchemaWorkaround,
 	objectSchema,
 	type RecordNodeCustomizableSchema,
 	recordSchema,
 } from "../node-kinds/index.js";
 import type { SchemaType, SimpleObjectNodeSchema } from "../simpleSchema.js";
 import type { SimpleLeafNodeSchema } from "../simpleSchema.js";
+import { unhydratedFlexTreeFromInsertableNode } from "../unhydratedFlexTreeFromInsertable.js";
 
 import {
 	defaultSchemaFactoryObjectOptions,
@@ -42,15 +51,185 @@ import {
 } from "./schemaFactory.js";
 import { SchemaFactoryBeta } from "./schemaFactoryBeta.js";
 import { schemaStatics } from "./schemaStatics.js";
+import { TreeBeta } from "./treeBeta.js";
 import type {
 	ArrayNodeCustomizableSchemaUnsafe,
+	FieldSchemaAlphaUnsafe,
+	InsertableObjectFromSchemaRecordAlphaUnsafe,
 	MapNodeCustomizableSchemaUnsafe,
 	System_Unsafe,
 	TreeRecordNodeUnsafe,
+	Unenforced,
 } from "./typesUnsafe.js";
-import type { FieldSchemaAlphaUnsafe } from "./typesUnsafe.js";
 /* eslint-enable unused-imports/no-unused-imports, @typescript-eslint/no-unused-vars, import-x/no-duplicates */
 
+/**
+ * A provider for values in tree nodes.
+ *
+ * @remarks
+ * This type represents two ways to provide node values:
+ *
+ * 1. **A value**: Provide any value directly (number, string, object, array, etc.). When a value is provided,
+ * the data is copied for each use to ensure independence between instances. The value must be of an allowed type for the field.
+ *
+ * 2. **A generator function**: A function that returns a value. The function is called each time a default is needed,
+ * allowing for dynamic defaults or explicit control over value creation. The return value must be of an allowed type for the field.
+ *
+ * Values should be preferred over generator functions when possible, as they are simpler and more efficient.
+ * Generator functions should be used when the default value needs to be dynamic or when it is not possible to provide a value directly.
+ *
+ * @example
+ * ```typescript
+ * // Provide a value directly
+ * factory.withDefault(factory.required(factory.string), "default")
+ * factory.withDefault(factory.optional(Person), new Person({ name: "Guest" }))
+ *
+ * // Use a generator function
+ * factory.withDefault(factory.required(factory.string), () => crypto.randomUUID())
+ * factory.withDefault(factory.optional(Person), () => new Person({ name: "Guest" }))
+ * ```
+ *
+ * @alpha @sealed
+ */
+export type NodeProvider<T> = T | (() => T);
+
+/**
+ * Stateless APIs exposed via {@link SchemaFactoryBeta} as both instance properties and as statics.
+ * @see {@link SchemaStatics} for why this is useful.
+ * @system @sealed @alpha
+ */
+export interface SchemaStaticsAlpha {
+	/**
+	 * Creates a field schema with a default value. Fields with defaults (whether required or optional) are recognized by the type system as optional in constructors,
+	 * allowing them to be omitted when creating new nodes.
+	 *
+	 * @param fieldSchema - The field schema to add a default to (e.g., `factory.required(factory.string)` or `factory.optional(factory.number)`)
+	 * @param defaultValue - A {@link NodeProvider} specifying the default value.
+	 *
+	 * @example
+	 * ```typescript
+	 * const MySchema = factory.objectAlpha("MyObject", {
+	 *     // Provide values directly
+	 *     name: factory.withDefault(factory.required(factory.string), "untitled"),
+	 *     count: factory.withDefault(factory.required(factory.number), 0),
+	 *     metadata: factory.withDefault(factory.optional(Metadata), new Metadata({ version: 1 })),
+	 *
+	 *     // Use generator functions for dynamic values
+	 *     timestamp: factory.withDefault(factory.required(factory.number), () => Date.now()),
+	 *     id: factory.withDefault(factory.required(factory.string), () => crypto.randomUUID()),
+	 * });
+	 *
+	 * const obj1 = new MySchema({}); // All defaults applied
+	 * const obj2 = new MySchema({ name: "custom" }); // name="custom", other defaults applied
+	 * ```
+	 *
+	 * @privateRemarks
+	 * This function wraps an existing field schema and adds a default value provider to it.
+	 * The default value will be used when constructing nodes if the field is not explicitly provided or set to `undefined`.
+	 *
+	 * Defaults are evaluated eagerly during node construction, unlike identifier defaults which require context.
+	 */
+	readonly withDefault: <
+		Kind extends FieldKind,
+		Types extends ImplicitAllowedTypes,
+		TCustomMetadata = unknown,
+	>(
+		fieldSchema: FieldSchema<Kind, Types, TCustomMetadata>,
+		defaultValue: NodeProvider<InsertableTreeFieldFromImplicitField<FieldSchema<Kind, Types>>>,
+	) => FieldSchemaAlpha<
+		Kind,
+		Types,
+		TCustomMetadata,
+		FieldPropsAlpha<TCustomMetadata> & { defaultProvider: DefaultProvider }
+	>;
+	/**
+	 * {@link SchemaStaticsAlpha.withDefault} except tweaked to work better for recursive types.
+	 * Use with {@link ValidateRecursiveSchema} for improved type safety.
+	 * @remarks
+	 * This version of {@link SchemaStaticsAlpha.withDefault} has fewer type constraints to work around TypeScript limitations, see {@link Unenforced}.
+	 * See {@link ValidateRecursiveSchema} for additional information about using recursive schema.
+	 */
+	withDefaultRecursive: <
+		Kind extends FieldKind,
+		Types extends System_Unsafe.ImplicitAllowedTypesUnsafe,
+		TCustomMetadata = unknown,
+	>(
+		fieldSchema: System_Unsafe.FieldSchemaUnsafe<Kind, Types, TCustomMetadata>,
+		defaultValue: Unenforced<
+			NodeProvider<
+				System_Unsafe.InsertableTreeFieldFromImplicitFieldUnsafe<
+					System_Unsafe.FieldSchemaUnsafe<Kind, Types>
+				>
+			>
+		>,
+	) => FieldSchemaAlphaUnsafe<
+		Kind,
+		Types,
+		TCustomMetadata,
+		FieldPropsAlpha<TCustomMetadata> & { defaultProvider: DefaultProvider }
+	>;
+}
+
+const withDefault = <
+	Kind extends FieldKind,
+	Types extends ImplicitAllowedTypes,
+	TCustomMetadata = unknown,
+>(
+	fieldSchema: FieldSchema<Kind, Types, TCustomMetadata>,
+	defaultValue: NodeProvider<InsertableTreeFieldFromImplicitField<FieldSchema<Kind, Types>>>,
+): FieldSchemaAlpha<
+	Kind,
+	Types,
+	TCustomMetadata,
+	FieldPropsAlpha<TCustomMetadata> & { defaultProvider: DefaultProvider }
+> => {
+	const typedFieldSchema = fieldSchema as FieldSchemaAlpha<Kind, Types, TCustomMetadata>;
+
+	// create the default provider function, it is called eagerly during node construction
+	const defaultProvider = getDefaultProvider(() => {
+		// Resolve the value: if it's a function, call it; otherwise use it directly
+		let insertableValue =
+			typeof defaultValue === "function" ? (defaultValue as () => unknown)() : defaultValue;
+
+		// If the value is an already-constructed TreeNode (e.g., from a generator function that
+		// returns the same instance repeatedly), clone it to ensure each use gets a fresh instance.
+		// This prevents multi-parenting errors.
+		if (isTreeNode(insertableValue)) {
+			// eslint-disable-next-line @typescript-eslint/no-explicit-any
+			insertableValue = TreeBeta.clone(insertableValue as any);
+		}
+
+		// For optional fields with an undefined default, return an empty array (no value).
+		if (insertableValue === undefined) {
+			return [];
+		}
+
+		// Convert the insertable value to an unhydrated flex tree.
+		// For insertable data, this creates a fresh tree structure.
+		const allowedTypeSet = normalizeAllowedTypes(typedFieldSchema.allowedTypes).evaluateSet();
+		// eslint-disable-next-line @typescript-eslint/no-explicit-any
+		return [unhydratedFlexTreeFromInsertableNode(insertableValue as any, allowedTypeSet)];
+	});
+
+	// create a new field schema with the default provider
+	const propsWithDefault = {
+		...typedFieldSchema.props,
+		defaultProvider,
+	};
+
+	return createFieldSchema(
+		typedFieldSchema.kind,
+		typedFieldSchema.allowedTypes,
+		propsWithDefault,
+	);
+};
+
+const schemaStaticsAlpha: SchemaStaticsAlpha = {
+	withDefault,
+
+	withDefaultRecursive: withDefault as SchemaStaticsAlpha["withDefaultRecursive"],
+};
+
 /**
  * {@link SchemaFactory} with additional alpha APIs.
  *
@@ -79,19 +258,7 @@ export class SchemaFactoryAlpha<
 		name: Name,
 		fields: T,
 		options?: ObjectSchemaOptionsAlpha<TCustomMetadata>,
-	): ObjectNodeSchema<ScopedSchemaName<TScope, Name>, T, true, 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.
-		 * @privateRemarks
-		 * The specific issue here is non-empty POJO mode object schema not being assignable to `ObjectNodeSchema`,
-		 * See the above link and the tests in objectNode.spec.ts which reference it.
-		 * @system
-		 */
-		readonly createFromInsertable: unknown;
-	} {
+	): ObjectNodeSchemaWorkaround<ScopedSchemaName<TScope, Name>, T, true, TCustomMetadata> {
 		return objectSchema(scoped<TScope, TName, Name>(this, name), fields, true, {
 			...defaultSchemaFactoryObjectOptions,
 			...options,
@@ -154,6 +321,56 @@ export class SchemaFactoryAlpha<
 			>;
 	}
 
+	/**
+	 * Alpha version of {@link SchemaFactory.objectRecursive} that supports field defaults via {@link SchemaStaticsAlpha.withDefaultRecursive}.
+	 * Use with {@link ValidateRecursiveSchema} for improved type safety.
+	 * @remarks
+	 * Use this instead of {@link SchemaFactory.objectRecursive} when fields use {@link SchemaStaticsAlpha.withDefaultRecursive}.
+	 * See {@link ValidateRecursiveSchema} for additional information about using recursive schema.
+	 */
+	public objectRecursiveAlpha<
+		const Name extends TName,
+		const T extends RestrictiveStringRecord<System_Unsafe.ImplicitFieldSchemaUnsafe>,
+		const TCustomMetadata = unknown,
+	>(
+		name: Name,
+		t: T,
+		options?: ObjectSchemaOptionsAlpha<TCustomMetadata>,
+	): TreeNodeSchemaClass<
+		ScopedSchemaName<TScope, Name>,
+		NodeKind.Object,
+		System_Unsafe.TreeObjectNodeUnsafe<T, ScopedSchemaName<TScope, Name>>,
+		object & InsertableObjectFromSchemaRecordAlphaUnsafe<T>,
+		false,
+		T,
+		never,
+		TCustomMetadata
+	> &
+		SimpleObjectNodeSchema<SchemaType.View, TCustomMetadata> &
+		Pick<ObjectNodeSchema, "fields"> {
+		type TScopedName = ScopedSchemaName<TScope, Name>;
+		return this.objectAlpha(
+			name,
+			t as T & RestrictiveStringRecord<ImplicitFieldSchema>,
+			options,
+		) as unknown as TreeNodeSchemaClass<
+			TScopedName,
+			NodeKind.Object,
+			System_Unsafe.TreeObjectNodeUnsafe<T, TScopedName>,
+			object & InsertableObjectFromSchemaRecordAlphaUnsafe<T>,
+			false,
+			T,
+			never,
+			TCustomMetadata
+		> &
+			ObjectNodeSchema<
+				ScopedSchemaName<TScope, Name>,
+				RestrictiveStringRecord<ImplicitFieldSchema>,
+				false,
+				TCustomMetadata
+			>;
+	}
+
 	/**
 	 * {@inheritDoc SchemaStatics.leaves}
 	 */
@@ -209,6 +426,26 @@ export class SchemaFactoryAlpha<
 	 */
 	public override readonly requiredRecursive = schemaStatics.requiredRecursive;
 
+	/**
+	 * {@inheritdoc SchemaStaticsAlpha.withDefault}
+	 */
+	public readonly withDefault = schemaStaticsAlpha.withDefault;
+
+	/**
+	 * {@inheritdoc SchemaStaticsAlpha.withDefault}
+	 */
+	public static readonly withDefault = schemaStaticsAlpha.withDefault;
+
+	/**
+	 * {@inheritdoc SchemaStaticsAlpha.withDefault}
+	 */
+	public readonly withDefaultRecursive = schemaStaticsAlpha.withDefaultRecursive;
+
+	/**
+	 * {@inheritdoc SchemaStaticsAlpha.withDefault}
+	 */
+	public static readonly withDefaultRecursive = schemaStaticsAlpha.withDefaultRecursive;
+
 	/**
 	 * Define a {@link TreeNodeSchema} for a {@link TreeMapNode}.
 	 *