@fluidframework/tree 2.70.0-360374 → 2.70.0-361092

package/src/feature-libraries/forest-summary/incrementalSummaryBuilder.ts

@@ -58,6 +58,31 @@ export const ForestSummaryTrackingState = {
 export type ForestSummaryTrackingState =
 	(typeof ForestSummaryTrackingState)[keyof typeof ForestSummaryTrackingState];
 
+/**
+ * The properties of a chunk tracked during the loading process.
+ * These are used to identify a chunk when it is decoded and recreate the tracking state
+ * as it was when the summary that the client is loading from was generated.
+ *
+ * An encoded chunk, paired with a location it can be reused / reloaded from.
+ * @remarks
+ * This identifies a location in a specific summary where `encodedContents` was loaded from.
+ *
+ * When summarizing, Fluid always ensures the summary that the summary client is allowed to reuse content from
+ * is the one it loaded from, so tracking this on load is sufficient for now:
+ * there is no need to track the equivalent data when summarizing.
+ */
+interface ChunkLoadProperties {
+	/**
+	 * The encoded contents of the chunk.
+	 */
+	readonly encodedContents: EncodedFieldBatch;
+	/**
+	 * The path for this chunk's contents in the summary tree relative to the forest's summary tree.
+	 * This path is used to generate a summary handle for the chunk if it doesn't change between summaries.
+	 */
+	readonly summaryPath: string;
+}
+
 /**
  * The properties of a chunk that is tracked for every summary.
  * If a chunk doesn't change between summaries,
@@ -255,12 +280,17 @@ export class ForestIncrementalSummaryBuilder implements IncrementalEncoderDecode
 	 * A map of chunk reference IDs to their encoded contents. This is typically used during the loading of the
 	 * forest to retrieve the contents of the chunks that were summarized incrementally.
 	 */
-	private readonly encodedChunkContentsMap: Map<string, EncodedFieldBatch> = new Map();
+	/**
+	 * A map of chunk reference IDs to their {@link ChunkLoadProperties}.
+	 * This is used during the loading of the forest to track each chunk that is retrieved and decoded.
+	 */
+	private readonly loadedChunksMap: Map<string, ChunkLoadProperties> = new Map();
 
 	public constructor(
 		private readonly enableIncrementalSummary: boolean,
 		private readonly getChunkAtCursor: (cursor: ITreeCursorSynchronous) => TreeChunk,
 		public readonly shouldEncodeIncrementally: IncrementalEncodingPolicy,
+		private readonly initialSequenceNumber: number,
 	) {}
 
 	/**
@@ -297,7 +327,15 @@ export class ForestIncrementalSummaryBuilder implements IncrementalEncoderDecode
 					);
 				}
 				const chunkContents = await readAndParseChunk<EncodedFieldBatch>(chunkContentsPath);
-				this.encodedChunkContentsMap.set(chunkReferenceId, chunkContents);
+				this.loadedChunksMap.set(chunkReferenceId, {
+					encodedContents: chunkContents,
+					summaryPath: chunkSubTreePath,
+				});
+
+				const chunkReferenceIdNumber = Number(chunkReferenceId);
+				this.nextReferenceId = brand(
+					Math.max(this.nextReferenceId, chunkReferenceIdNumber + 1),
+				);
 
 				// Recursively download the contents of chunks in this chunk's sub tree.
 				await downloadChunkContentsInTree(chunkSnapshotTree, `${chunkSubTreePath}/`);
@@ -361,6 +399,10 @@ export class ForestIncrementalSummaryBuilder implements IncrementalEncoderDecode
 		let chunkReferenceId: ChunkReferenceId;
 		let chunkProperties: ChunkSummaryProperties;
 
+		// An additional ref-count must be added to these chunks representing a reference from the summary tree to the chunk.
+		// This will ensure that the blob's content never change and thus the reference stays accurate: instead of modifying it,
+		// a copy will be created without the blob reference.
+		// The "getChunkAtCursor" adds this additional ref-count.
 		const chunk = this.getChunkAtCursor(cursor);
 
 		// Try and get the properties of the chunk from the latest successful summary.
@@ -486,17 +528,27 @@ export class ForestIncrementalSummaryBuilder implements IncrementalEncoderDecode
 	}
 
 	/**
-	 * Called to get the encoded contents of an incremental chunk with the given reference ID.
-	 * This is typically used when loading the forest to retrieve the contents of incremental chunks.
-	 * @param referenceId - The reference ID of the chunk to retrieve.
-	 * @returns The encoded contents of the chunk.
+	 * {@link IncrementalEncoder.decodeIncrementalChunk}
 	 */
-	public getEncodedIncrementalChunk(referenceId: ChunkReferenceId): EncodedFieldBatch {
-		const chunkEncodedContents = this.encodedChunkContentsMap.get(`${referenceId}`);
-		assert(
-			chunkEncodedContents !== undefined,
-			0xc26 /* Incremental chunk contents not found */,
-		);
-		return chunkEncodedContents;
+	public decodeIncrementalChunk(
+		referenceId: ChunkReferenceId,
+		chunkDecoder: (encoded: EncodedFieldBatch) => TreeChunk,
+	): TreeChunk {
+		const ChunkLoadProperties = this.loadedChunksMap.get(`${referenceId}`);
+		assert(ChunkLoadProperties !== undefined, "Encoded incremental chunk not found");
+		const chunk = chunkDecoder(ChunkLoadProperties.encodedContents);
+
+		// Account for the reference about to be added in `chunkTrackingPropertiesMap`
+		// to ensure that no other users of this chunk think they have unique ownership.
+		// This prevents prevent whoever this chunk is returned to from modifying it in-place.
+		chunk.referenceAdded();
+		// Track the decoded chunk. This will recreate the tracking state when the summary that this client
+		// is loaded from was generated. This is needed to ensure that incremental summaries work correctly
+		// when a new client starts to summarize.
+		setInNestedMap(this.chunkTrackingPropertiesMap, this.initialSequenceNumber, chunk, {
+			referenceId,
+			summaryPath: ChunkLoadProperties.summaryPath,
+		});
+		return chunk;
 	}
 }

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/tree";
-export const pkgVersion = "2.70.0-360374";
+export const pkgVersion = "2.70.0-361092";

package/src/serializableDomainSchema.ts

@@ -7,14 +7,14 @@ import type { IFluidHandle } from "@fluidframework/core-interfaces";
 
 import {
 	SchemaFactory,
-	SchemaFactoryAlpha,
+	SchemaFactoryBeta,
 	type FixRecursiveArraySchema,
 	type TreeNodeFromImplicitAllowedTypes,
 	type ValidateRecursiveSchema,
 } from "./simple-tree/index.js";
 import type { JsonCompatible } from "./util/index.js";
 
-const sf = new SchemaFactoryAlpha("com.fluidframework.serializable");
+const sf = new SchemaFactoryBeta("com.fluidframework.serializable");
 
 /**
  * Utilities for storing {@link FluidSerializableAsTree.Data|Fluid Serializable data} in {@link TreeNode}s.
@@ -24,14 +24,14 @@ const sf = new SchemaFactoryAlpha("com.fluidframework.serializable");
  * Schema which replicate the Fluid Serializable data model with {@link TreeNode}s.
  *
  * Fluid Serializable data can be imported from the {@link FluidSerializableAsTree.Data|Fluid Serializable format} into this format using {@link (TreeBeta:interface).importConcise} with the {@link FluidSerializableAsTree.(Tree:variable)} schema.
- * @alpha
+ * @beta
  */
 export namespace FluidSerializableAsTree {
 	/**
 	 * Data which can be serialized by Fluid.
 	 * @remarks
 	 * Can be encoded as a {@link FluidSerializableAsTree.(Tree:type)} using {@link (TreeBeta:interface).importConcise}.
-	 * @alpha
+	 * @beta
 	 */
 	export type Data = JsonCompatible<IFluidHandle>;
 
@@ -41,7 +41,7 @@ export namespace FluidSerializableAsTree {
 	 * ```typescript
 	 * const tree = TreeBeta.importConcise(FluidSerializableAsTree.Tree, { example: { nested: true }, value: 5 });
 	 * ```
-	 * @alpha
+	 * @beta
 	 */
 	export const Tree = [
 		() => FluidSerializableObject,
@@ -50,13 +50,13 @@ export namespace FluidSerializableAsTree {
 	] as const;
 
 	/**
-	 * @alpha
+	 * @beta
 	 */
 	export type Tree = TreeNodeFromImplicitAllowedTypes<typeof Tree>;
 
 	/**
 	 * Do not use. Exists only as a workaround for {@link https://github.com/microsoft/TypeScript/issues/59550} and {@link https://github.com/microsoft/rushstack/issues/4429}.
-	 * @system @alpha
+	 * @system @beta
 	 */
 	export const _APIExtractorWorkaroundObjectBase = sf.recordRecursive("object", Tree);
 
@@ -75,7 +75,7 @@ export namespace FluidSerializableAsTree {
 	 * ```
 	 * @privateRemarks
 	 * Due to https://github.com/microsoft/TypeScript/issues/61270 this can't be named `Object`.
-	 * @sealed @alpha
+	 * @sealed @beta
 	 */
 	export class FluidSerializableObject extends _APIExtractorWorkaroundObjectBase {}
 	{
@@ -87,7 +87,7 @@ export namespace FluidSerializableAsTree {
 	 * @privateRemarks
 	 * In the past this this had to reference the base type (_APIExtractorWorkaroundArrayBase).
 	 * Testing for this in examples/utils/import-testing now shows it has to reference FluidSerializableAsTree.Array instead.
-	 * @system @alpha
+	 * @system @beta
 	 */
 	export declare type _RecursiveArrayWorkaroundJsonArray = FixRecursiveArraySchema<
 		typeof Array
@@ -95,7 +95,7 @@ export namespace FluidSerializableAsTree {
 
 	/**
 	 * Do not use. Exists only as a workaround for {@link https://github.com/microsoft/TypeScript/issues/59550} and {@link https://github.com/microsoft/rushstack/issues/4429}.
-	 * @system @alpha
+	 * @system @beta
 	 */
 	export const _APIExtractorWorkaroundArrayBase = sf.arrayRecursive("array", Tree);
 
@@ -114,7 +114,7 @@ export namespace FluidSerializableAsTree {
 	 * assert(Tree.is(inner, FluidSerializableAsTree.Array));
 	 * const leaf = inner[0];
 	 * ```
-	 * @sealed @alpha
+	 * @sealed @beta
 	 */
 	export class Array extends _APIExtractorWorkaroundArrayBase {}
 	{

package/src/shared-tree/sharedTree.ts

@@ -299,6 +299,7 @@ export class SharedTreeKernel
 		serializer: IFluidSerializer,
 		submitLocalMessage: (content: unknown, localOpMetadata?: unknown) => void,
 		lastSequenceNumber: () => number | undefined,
+		initialSequenceNumber: number,
 		private readonly logger: ITelemetryLoggerExt | undefined,
 		idCompressor: IIdCompressor,
 		optionsParam: SharedTreeOptionsInternal,
@@ -346,6 +347,7 @@ export class SharedTreeKernel
 			encoderContext,
 			options,
 			idCompressor,
+			initialSequenceNumber,
 			options.shouldEncodeIncrementally,
 		);
 		const removedRootsSummarizer = new DetachedFieldIndexSummarizer(removedRoots);

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

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { assert, unreachableCase } from "@fluidframework/core-utils/internal";
+import { assert, debugAssert, unreachableCase } from "@fluidframework/core-utils/internal";
 import { isFluidHandle } from "@fluidframework/runtime-utils/internal";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 
@@ -164,7 +164,7 @@ export interface ObjectSchemaOptionsAlpha<TCustomMetadata = unknown>
  * @remarks Omits parameters that are not relevant for common use cases.
  */
 export const defaultSchemaFactoryObjectOptions: Required<
-	Omit<ObjectSchemaOptionsAlpha, "metadata" | "persistedMetadata">
+	Pick<ObjectSchemaOptions, "allowUnknownOptionalFields">
 > = {
 	allowUnknownOptionalFields: false,
 };
@@ -397,12 +397,9 @@ export class SchemaFactory<
 		true,
 		T
 	> {
-		return objectSchema(
-			scoped(this, name),
-			fields,
-			true,
-			defaultSchemaFactoryObjectOptions.allowUnknownOptionalFields,
-		);
+		return objectSchema(scoped(this, name), fields, true, {
+			...defaultSchemaFactoryObjectOptions,
+		});
 	}
 
 	/**
@@ -474,15 +471,17 @@ export class SchemaFactory<
 	 * This seems like a TypeScript bug getting variance backwards for overload return types since it's erroring when the relation between the overload
 	 * and the implementation is type safe, and forcing an unsafe typing instead.
 	 */
-	public map<const T extends ImplicitAllowedTypes>(
+	public map<const T extends ImplicitAllowedTypes, const TCustomMetadata = unknown>(
 		nameOrAllowedTypes: TName | ((T & TreeNodeSchema) | readonly TreeNodeSchema[]),
 		allowedTypes?: T,
+		options?: NodeSchemaOptions<TCustomMetadata>,
 	): TreeNodeSchema<string, NodeKind.Map, TreeMapNode<T>, MapNodeInsertableData<T>, true, T> {
 		if (allowedTypes === undefined) {
 			const types = nameOrAllowedTypes as (T & TreeNodeSchema) | readonly TreeNodeSchema[];
 			const fullName = structuralName("Map", types);
+			debugAssert(() => options === undefined || "No options for structural types");
 			return this.getStructuralType(fullName, types, () =>
-				this.namedMap(fullName, nameOrAllowedTypes as T, false, true),
+				this.namedMap(fullName, nameOrAllowedTypes as T, false, true, {}),
 			) as TreeNodeSchemaBoth<
 				string,
 				NodeKind.Map,
@@ -490,7 +489,8 @@ export class SchemaFactory<
 				MapNodeInsertableData<T>,
 				true,
 				T,
-				undefined
+				undefined,
+				TCustomMetadata
 			>;
 		}
 		// To actually have type safety, assign to the type this method should return before implicitly up-casting when returning.
@@ -501,8 +501,9 @@ export class SchemaFactory<
 			MapNodeInsertableData<T>,
 			true,
 			T,
-			undefined
-		> = this.namedMap(nameOrAllowedTypes as TName, allowedTypes, true, true);
+			undefined,
+			TCustomMetadata
+		> = this.namedMap(nameOrAllowedTypes as TName, allowedTypes, true, true, options ?? {});
 		return out;
 	}
 
@@ -515,11 +516,13 @@ export class SchemaFactory<
 		Name extends TName | string,
 		const T extends ImplicitAllowedTypes,
 		const ImplicitlyConstructable extends boolean,
+		const TCustomMetadata = unknown,
 	>(
 		name: Name,
 		allowedTypes: T,
 		customizable: boolean,
 		implicitlyConstructable: ImplicitlyConstructable,
+		options: NodeSchemaOptionsAlpha<TCustomMetadata>,
 	): TreeNodeSchemaBoth<
 		ScopedSchemaName<TScope, Name>,
 		NodeKind.Map,
@@ -527,7 +530,8 @@ export class SchemaFactory<
 		MapNodeInsertableData<T>,
 		ImplicitlyConstructable,
 		T,
-		undefined
+		undefined,
+		TCustomMetadata
 	> {
 		return mapSchema(
 			scoped(this, name),
@@ -535,7 +539,7 @@ export class SchemaFactory<
 			implicitlyConstructable,
 			// The current policy is customizable nodes don't get fake prototypes.
 			!customizable,
-			undefined,
+			options ?? {},
 		);
 	}
 
@@ -618,22 +622,25 @@ export class SchemaFactory<
 	 * @privateRemarks
 	 * This should return TreeNodeSchemaBoth: see note on "map" implementation for details.
 	 */
-	public array<const T extends ImplicitAllowedTypes>(
+	public array<const T extends ImplicitAllowedTypes, const TCustomMetadata = unknown>(
 		nameOrAllowedTypes: TName | ((T & TreeNodeSchema) | readonly TreeNodeSchema[]),
 		allowedTypes?: T,
+		options?: NodeSchemaOptions<TCustomMetadata>,
 	): TreeNodeSchema<
 		ScopedSchemaName<TScope, string>,
 		NodeKind.Array,
 		TreeArrayNode<T>,
 		Iterable<InsertableTreeNodeFromImplicitAllowedTypes<T>>,
 		true,
-		T
+		T,
+		TCustomMetadata
 	> {
 		if (allowedTypes === undefined) {
 			const types = nameOrAllowedTypes as (T & TreeNodeSchema) | readonly TreeNodeSchema[];
 			const fullName = structuralName("Array", types);
+			debugAssert(() => options === undefined || "No options for structural types");
 			return this.getStructuralType(fullName, types, () =>
-				this.namedArray(fullName, nameOrAllowedTypes as T, false, true),
+				this.namedArray(fullName, nameOrAllowedTypes as T, false, true, {}),
 			) as TreeNodeSchemaClass<
 				ScopedSchemaName<TScope, string>,
 				NodeKind.Array,
@@ -641,9 +648,11 @@ export class SchemaFactory<
 				Iterable<InsertableTreeNodeFromImplicitAllowedTypes<T>>,
 				true,
 				T,
-				undefined
+				undefined,
+				TCustomMetadata
 			>;
 		}
+
 		const out: TreeNodeSchemaBoth<
 			ScopedSchemaName<TScope, string>,
 			NodeKind.Array,
@@ -651,8 +660,9 @@ export class SchemaFactory<
 			Iterable<InsertableTreeNodeFromImplicitAllowedTypes<T>>,
 			true,
 			T,
-			undefined
-		> = this.namedArray(nameOrAllowedTypes as TName, allowedTypes, true, true);
+			undefined,
+			TCustomMetadata
+		> = this.namedArray(nameOrAllowedTypes as TName, allowedTypes, true, true, options ?? {});
 		return out;
 	}
 
@@ -698,11 +708,13 @@ export class SchemaFactory<
 		Name extends TName | string,
 		const T extends ImplicitAllowedTypes,
 		const ImplicitlyConstructable extends boolean,
+		const TCustomMetadata = unknown,
 	>(
 		name: Name,
 		allowedTypes: T,
 		customizable: boolean,
 		implicitlyConstructable: ImplicitlyConstructable,
+		options: NodeSchemaOptionsAlpha<TCustomMetadata>,
 	): TreeNodeSchemaBoth<
 		ScopedSchemaName<TScope, Name>,
 		NodeKind.Array,
@@ -710,13 +722,15 @@ export class SchemaFactory<
 		Iterable<InsertableTreeNodeFromImplicitAllowedTypes<T>>,
 		ImplicitlyConstructable,
 		T,
-		undefined
+		undefined,
+		TCustomMetadata
 	> {
 		return arraySchema(
 			scoped(this, name),
 			allowedTypes,
 			implicitlyConstructable,
 			customizable,
+			options,
 		);
 	}
 
@@ -822,6 +836,7 @@ export class SchemaFactory<
 			allowedTypes as T & ImplicitAllowedTypes,
 			true,
 			false,
+			{},
 		);
 
 		return RecursiveArray as TreeNodeSchemaClass<
@@ -870,6 +885,7 @@ export class SchemaFactory<
 			// Setting this (implicitlyConstructable) to true seems to work ok currently, but not for other node kinds.
 			// Supporting this could be fragile and might break other future changes, so it's being kept as false for now.
 			false,
+			{},
 		);
 
 		return MapSchema as TreeNodeSchemaClass<

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

@@ -218,15 +218,10 @@ export class SchemaFactoryAlpha<
 		 */
 		readonly createFromInsertable: unknown;
 	} {
-		return objectSchema(
-			scoped<TScope, TName, Name>(this, name),
-			fields,
-			true,
-			options?.allowUnknownOptionalFields ??
-				defaultSchemaFactoryObjectOptions.allowUnknownOptionalFields,
-			options?.metadata,
-			options?.persistedMetadata,
-		);
+		return objectSchema(scoped<TScope, TName, Name>(this, name), fields, true, {
+			...defaultSchemaFactoryObjectOptions,
+			...(options ?? {}),
+		});
 	}
 
 	/**
@@ -408,8 +403,7 @@ export class SchemaFactoryAlpha<
 			allowedTypes,
 			true,
 			true,
-			options?.metadata,
-			options?.persistedMetadata,
+			options,
 		);
 	}
 
@@ -459,8 +453,7 @@ export class SchemaFactoryAlpha<
 			allowedTypes,
 			true,
 			true,
-			options?.metadata,
-			options?.persistedMetadata,
+			options ?? {},
 		);
 	}
 
@@ -510,8 +503,7 @@ export class SchemaFactoryAlpha<
 			info: allowedTypes,
 			customizable: true,
 			implicitlyConstructable: true,
-			metadata: options?.metadata,
-			persistedMetadata: options?.persistedMetadata,
+			nodeOptions: options,
 		});
 	}
 
@@ -535,8 +527,7 @@ export class SchemaFactoryAlpha<
 			// Setting this to true seems to work ok currently, but not for other node kinds.
 			// Supporting this could be fragile and might break other future changes, so it's being kept as false for now.
 			implicitlyConstructable: false,
-			metadata: options?.metadata,
-			persistedMetadata: options?.persistedMetadata,
+			nodeOptions: options,
 		});
 
 		return RecordSchema as TreeNodeSchemaClass<

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

@@ -90,14 +90,10 @@ export class SchemaFactoryBeta<
 		true,
 		T
 	> {
-		return objectSchema(
-			scoped<TScope, TName, Name>(this, name),
-			fields,
-			true,
-			options?.allowUnknownOptionalFields ??
-				defaultSchemaFactoryObjectOptions.allowUnknownOptionalFields,
-			options?.metadata,
-		);
+		return objectSchema(scoped<TScope, TName, Name>(this, name), fields, true, {
+			...defaultSchemaFactoryObjectOptions,
+			...(options ?? {}),
+		});
 	}
 
 	public override objectRecursive<
@@ -192,6 +188,7 @@ export class SchemaFactoryBeta<
 	 *
 	 * @param name - Unique identifier for this schema within this factory's scope.
 	 * @param allowedTypes - The types that may appear in the record.
+	 * @param options - Additional options for the schema.
 	 *
 	 * @remarks
 	 * The underlying data format for `Record` nodes is the same as that for `Map` nodes.
@@ -211,9 +208,14 @@ export class SchemaFactoryBeta<
 	 *
 	 * {@label NAMED}
 	 */
-	public record<const Name extends TName, const T extends ImplicitAllowedTypes>(
+	public record<
+		const Name extends TName,
+		const T extends ImplicitAllowedTypes,
+		const TCustomMetadata = unknown,
+	>(
 		name: Name,
 		allowedTypes: T,
+		options?: NodeSchemaOptions<TCustomMetadata>,
 	): TreeNodeSchemaClass<
 		/* Name */ ScopedSchemaName<TScope, Name>,
 		/* Kind */ NodeKind.Record,
@@ -221,7 +223,8 @@ export class SchemaFactoryBeta<
 		/* TInsertable */ RecordNodeInsertableData<T>,
 		/* ImplicitlyConstructable */ true,
 		/* Info */ T,
-		/* TConstructorExtra */ undefined
+		/* TConstructorExtra */ undefined,
+		/* TCustomMetadata */ TCustomMetadata
 	>;
 
 	/**
@@ -233,6 +236,7 @@ export class SchemaFactoryBeta<
 	public record<const T extends ImplicitAllowedTypes>(
 		nameOrAllowedTypes: TName | ((T & TreeNodeSchema) | readonly TreeNodeSchema[]),
 		maybeAllowedTypes?: T,
+		options?: NodeSchemaOptions,
 	): TreeNodeSchema<
 		/* Name */ ScopedSchemaName<TScope, string>,
 		/* Kind */ NodeKind.Record,
@@ -274,6 +278,7 @@ export class SchemaFactoryBeta<
 			maybeAllowedTypes,
 			/* customizable */ true,
 			/* implicitlyConstructable */ true,
+			options,
 		);
 		return out;
 	}
@@ -307,24 +312,13 @@ export class SchemaFactoryBeta<
 		/* Info */ T,
 		/* TConstructorExtra */ undefined
 	> {
-		const record = recordSchema({
+		return recordSchema({
 			identifier: scoped<TScope, TName, Name>(this, name),
 			info: allowedTypes,
 			customizable,
 			implicitlyConstructable,
-			metadata: options?.metadata,
+			nodeOptions: options,
 		});
-
-		return record as TreeNodeSchemaBoth<
-			/* Name */ ScopedSchemaName<TScope, Name>,
-			/* Kind */ NodeKind.Record,
-			/* TNode */ TreeRecordNode<T> &
-				WithType<ScopedSchemaName<TScope, string>, NodeKind.Record>,
-			/* TInsertable */ RecordNodeInsertableData<T>,
-			/* ImplicitlyConstructable */ ImplicitlyConstructable,
-			/* Info */ T,
-			/* TConstructorExtra */ undefined
-		>;
 	}
 
 	/**

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

@@ -283,6 +283,6 @@ export function allowUnused<T>(t?: T): void {}
  * }
  * ```
  *
- * @alpha
+ * @beta
  */
 export type FixRecursiveArraySchema<T> = T extends TreeNodeSchema ? undefined : undefined;

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

@@ -253,32 +253,20 @@ export class AnnotatedAllowedTypesInternal<
 		return this.lazyEvaluate.value.identifiers;
 	}
 
-	public static override [Symbol.hasInstance]<
-		TThis extends
-			| (abstract new (
-					...args: unknown[]
-			  ) => object)
-			| typeof AnnotatedAllowedTypesInternal,
-	>(
+	public static override [Symbol.hasInstance]<TThis extends { prototype: object }>(
 		this: TThis,
-		value: ErasedBaseType | InstanceTypeRelaxed<TThis> | ImplicitAllowedTypes,
+		value: unknown,
 	): value is InstanceTypeRelaxed<TThis> & AnnotatedAllowedTypesInternal & AllowedTypesFull {
-		return Object.prototype.isPrototypeOf.call(this.prototype, value);
+		return ErasedTypeImplementation[Symbol.hasInstance].call(this, value);
 	}
 
-	public static override narrow<
-		TThis extends
-			| (abstract new (
-					...args: unknown[]
-			  ) => object)
-			| typeof AnnotatedAllowedTypesInternal,
-	>(
+	public static override narrow<TThis extends { prototype: object }>(
 		this: TThis,
 		value: ErasedBaseType | InstanceTypeRelaxed<TThis> | ImplicitAllowedTypes,
 	): asserts value is InstanceTypeRelaxed<TThis> &
 		AnnotatedAllowedTypesInternal &
 		AllowedTypesFull {
-		if (!Object.prototype.isPrototypeOf.call(this.prototype, value)) {
+		if (!ErasedTypeImplementation[Symbol.hasInstance].call(this, value)) {
 			throw new TypeError("Invalid AnnotatedAllowedTypes instance");
 		}
 	}

package/src/simple-tree/node-kinds/array/arrayNode.ts

@@ -59,7 +59,7 @@ import {
 	getTreeNodeSchemaInitializedData,
 	getUnhydratedContext,
 } from "../../createContext.js";
-import type { System_Unsafe } from "../../api/index.js";
+import type { NodeSchemaOptionsAlpha, System_Unsafe } from "../../api/index.js";
 import type {
 	ArrayNodeCustomizableSchema,
 	ArrayNodePojoEmulationSchema,
@@ -1152,8 +1152,7 @@ export function arraySchema<
 	info: T,
 	implicitlyConstructable: ImplicitlyConstructable,
 	customizable: boolean,
-	metadata?: NodeSchemaMetadata<TCustomMetadata>,
-	persistedMetadata?: JsonCompatibleReadOnlyObject | undefined,
+	nodeOptions: NodeSchemaOptionsAlpha<TCustomMetadata>,
 ) {
 	type Output = ArrayNodeCustomizableSchema<
 		TName,
@@ -1164,6 +1163,7 @@ export function arraySchema<
 		ArrayNodePojoEmulationSchema<TName, T, ImplicitlyConstructable, TCustomMetadata> &
 		TreeNodeSchemaCorePrivate;
 
+	const persistedMetadata = nodeOptions?.persistedMetadata;
 	const normalizedTypes = normalizeAllowedTypes(info);
 	const lazyAllowedTypesIdentifiers = new Lazy(
 		() => new Set(normalizedTypes.evaluate().map((type) => type.identifier)),
@@ -1252,7 +1252,8 @@ export function arraySchema<
 		public static get childTypes(): ReadonlySet<TreeNodeSchema> {
 			return normalizedTypes.evaluateSet();
 		}
-		public static readonly metadata: NodeSchemaMetadata<TCustomMetadata> = metadata ?? {};
+		public static readonly metadata: NodeSchemaMetadata<TCustomMetadata> =
+			nodeOptions.metadata ?? {};
 		public static readonly persistedMetadata: JsonCompatibleReadOnlyObject | undefined =
 			persistedMetadata;