@fluidframework/tree 2.41.0 → 2.43.0-343119

package/src/feature-libraries/mapTreeCursor.ts

@@ -12,49 +12,145 @@ import {
 	type FieldKey,
 	type ITreeCursor,
 	type MapTree,
+	type NodeData,
 	aboveRootPlaceholder,
 	detachedFieldAsKey,
 	mapCursorField,
 	rootField,
+	rootFieldKey,
 } from "../core/index.js";
 
 import {
 	type CursorAdapter,
 	type CursorWithNode,
+	type Field,
 	stackTreeFieldCursor,
 	stackTreeNodeCursor,
 } from "./treeCursorUtils.js";
+import type { requireAssignableTo } from "../util/index.js";
+
+/**
+ * A generic variant of {@link MapTree} that can be used to strongly type trees implementing a MapTree-like API.
+ * @remarks
+ * Due to how TypeScript handles recursive generic types, explicitly named extension interfaces work best for parameterizing this, and a default type parameter can't be provided.
+ * @see {@link MinimalMapTreeNodeView} for a minimal configuration of this interface.
+ */
+export interface MapTreeNodeViewGeneric<TNode> extends NodeData {
+	/**
+	 * The non-empty fields on this node.
+	 * @remarks
+	 * This is the subset of map needed to view the tree.
+	 * Theoretically `Symbol.iterator` and "keys" are redundant.
+	 */
+	readonly fields: MinimalFieldMap<MapTreeFieldViewGeneric<TNode>>;
+}
+
+/**
+ * A minimal map for the fields of a {@link MapTreeNodeViewGeneric}.
+ * @remarks
+ * Subset of map, so can be implemented by `Map<FieldKey, TField>`.
+ */
+export interface MinimalFieldMap<TField> {
+	[Symbol.iterator]: () => Iterator<[FieldKey, TField]>;
+	get: (key: FieldKey) => TField | undefined;
+}
+
+/**
+ * A field in {@link MapTreeNodeViewGeneric}.
+ * @remarks
+ * Subset of array, so can be implemented by `TNode[]`.
+ */
+export interface MapTreeFieldViewGeneric<TNode> {
+	readonly [Symbol.iterator]: () => Iterator<TNode>;
+	readonly length: number;
+}
+
+/**
+ * Like {@link MapTree} but with the minimal properties needed for reading.
+ */
+export interface MinimalMapTreeNodeView
+	extends MapTreeNodeViewGeneric<MinimalMapTreeNodeView> {}
+
+{
+	// Check that these interfaces are subsets of MapTree as intended:
+	type _check1 = requireAssignableTo<MapTree, MinimalMapTreeNodeView>;
+	type _check2 = requireAssignableTo<MapTree, MapTreeNodeViewGeneric<MapTree>>;
+}
 
 /**
  * Returns an {@link ITreeCursorSynchronous} in nodes mode for a single {@link MapTree}.
  */
-export function cursorForMapTreeNode(root: MapTree): CursorWithNode<MapTree> {
-	return stackTreeNodeCursor(adapter, root);
+export function cursorForMapTreeNode<T extends MapTreeNodeViewGeneric<T>>(
+	root: T,
+): CursorWithNode<T> {
+	// There doesn't seem to be a clean way to get TypeScript to type check this without casting
+	// without declaring the adapter inside this generic function and needlessly recreating it on every call.
+	const adapterTyped = adapter as CursorAdapter<MapTreeNodeViewGeneric<T>> as CursorAdapter<T>;
+	return stackTreeNodeCursor(adapterTyped, root);
+}
+
+/**
+ * Creates an {@link ExclusiveMapTree} with a single field and no value.
+ * @remarks
+ * This handles ensuring the field is omitted if empty, and defaults to making the node above the root.
+ */
+export function mapTreeWithField(
+	children: ExclusiveMapTree[],
+	key = rootFieldKey,
+	type = aboveRootPlaceholder,
+): ExclusiveMapTree {
+	return {
+		type,
+		fields: mapTreeFieldsWithField(children, key),
+	};
+}
+
+/**
+ * Creates a Map suitable for use as {@link MapTree.fields} with a single field.
+ * @remarks
+ * This handles ensuring the field is omitted if empty.
+ */
+export function mapTreeFieldsWithField<T extends readonly unknown[]>(
+	children: T,
+	key: FieldKey,
+): Map<FieldKey, T> {
+	return new Map(children.length === 0 ? [] : [[key, children]]);
 }
 
 /**
  * Returns an {@link ITreeCursorSynchronous} in fields mode for a MapTree field.
  */
-export function cursorForMapTreeField(
-	root: readonly MapTree[],
+export function cursorForMapTreeField<T extends MapTreeNodeViewGeneric<T>>(
+	root: readonly T[],
 	detachedField: DetachedField = rootField,
-): CursorWithNode<MapTree> {
+): CursorWithNode<T> {
 	const key = detachedFieldAsKey(detachedField);
-	return stackTreeFieldCursor(
-		adapter,
-		{
-			type: aboveRootPlaceholder,
-			fields: new Map([[key, root]]),
-		},
-		detachedField,
-	);
+	const adapterTyped = adapter as unknown as CursorAdapter<T>;
+	const dummyRoot: MapTreeNodeViewGeneric<T> = {
+		type: aboveRootPlaceholder,
+		fields: mapTreeFieldsWithField(root, key),
+	};
+	return stackTreeFieldCursor(adapterTyped, dummyRoot as T, detachedField);
 }
 
-const adapter: CursorAdapter<MapTree> = {
+const adapter: CursorAdapter<MinimalMapTreeNodeView> = {
 	value: (node) => node.value,
 	type: (node) => node.type,
-	keysFromNode: (node) => [...node.fields.keys()], // TODO: don't convert this to array here.
-	getFieldFromNode: (node, key) => node.fields.get(key) ?? [],
+	keysFromNode: (node) => Array.from(node.fields, ([key, field]) => key),
+	getFieldFromNode: (node, key): Field<MinimalMapTreeNodeView> => {
+		const field = node.fields.get(key) as
+			| MinimalMapTreeNodeView[]
+			| Iterable<MinimalMapTreeNodeView>
+			| undefined;
+		if (field === undefined) {
+			return [];
+		}
+		if (Array.isArray(field)) {
+			return field as readonly MinimalMapTreeNodeView[];
+		}
+		// TODO: this copy could be avoided by using Array.at instead of indexing in `Field`, but that requires ES2022.
+		return [...field] as readonly MinimalMapTreeNodeView[];
+	},
 };
 
 /**

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

@@ -79,6 +79,8 @@ export class FieldKindWithEditor<
 			isNeverField(policy, originalData, {
 				kind: this.identifier,
 				types: originalTypes,
+				// Metadata is not used for this check.
+				persistedMetadata: undefined,
 			})
 		) {
 			return true;

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

@@ -76,7 +76,7 @@ export function makeModularChangeCodecFamily(
 		ChangeEncodingContext
 	>,
 	fieldsCodec: FieldBatchCodec,
-	{ jsonValidator: validator }: ICodecOptions,
+	codecOptions: ICodecOptions,
 	chunkCompressionStrategy: TreeCompressionStrategy = TreeCompressionStrategy.Compressed,
 ): ICodecFamily<ModularChangeset, ChangeEncodingContext> {
 	return makeCodecFamily(
@@ -86,7 +86,7 @@ export function makeModularChangeCodecFamily(
 				fieldKinds,
 				revisionTagCodec,
 				fieldsCodec,
-				{ jsonValidator: validator },
+				codecOptions,
 				chunkCompressionStrategy,
 			),
 		]),
@@ -116,7 +116,7 @@ function makeModularChangeCodec(
 		ChangeEncodingContext
 	>,
 	fieldsCodec: FieldBatchCodec,
-	{ jsonValidator: validator }: ICodecOptions,
+	codecOptions: ICodecOptions,
 	chunkCompressionStrategy: TreeCompressionStrategy = TreeCompressionStrategy.Compressed,
 ): ModularChangeCodec {
 	// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
@@ -125,7 +125,7 @@ function makeModularChangeCodec(
 		return {
 			codec,
 			compiledSchema: codec.json.encodedSchema
-				? validator.compile(codec.json.encodedSchema)
+				? codecOptions.jsonValidator.compile(codec.json.encodedSchema)
 				: undefined,
 		};
 	};
@@ -519,7 +519,11 @@ function makeModularChangeCodec(
 		},
 	};
 
-	return withSchemaValidation(EncodedModularChangeset, modularChangeCodec, validator);
+	return withSchemaValidation(
+		EncodedModularChangeset,
+		modularChangeCodec,
+		codecOptions.jsonValidator,
+	);
 }
 
 function getChangeHandler(

package/src/feature-libraries/object-forest/objectForest.ts

@@ -154,6 +154,9 @@ export class ObjectForest implements IEditableForest, WithBreakable {
 								// Some detached fields may have multiple nodes, so we must treat them as sequences:
 								kind: FieldKinds.sequence.identifier,
 								types: new Set(documentRoot.map((node) => node.type)),
+
+								// Metadata is not used for schema checks
+								persistedMetadata: undefined,
 							};
 				const maybeError = isFieldInSchema(documentRoot, fieldSchema, {
 					schema,

package/src/feature-libraries/schema-edits/schemaChangeCodecs.ts

@@ -13,7 +13,7 @@ import {
 	makeVersionDispatchingCodec,
 	withSchemaValidation,
 } from "../../codec/index.js";
-import { makeSchemaCodec, type Format as FormatV1 } from "../schema-index/index.js";
+import { makeSchemaCodec } from "../schema-index/index.js";
 
 import { EncodedSchemaChange } from "./schemaChangeFormat.js";
 import type { SchemaChange } from "./schemaChangeTypes.js";
@@ -25,7 +25,10 @@ import { SchemaVersion } from "../../core/index.js";
  * @returns The composed codec family.
  */
 export function makeSchemaChangeCodecs(options: ICodecOptions): ICodecFamily<SchemaChange> {
-	return makeCodecFamily([[SchemaVersion.v1, makeSchemaChangeCodecV1(options)]]);
+	return makeCodecFamily([
+		[SchemaVersion.v1, makeSchemaChangeCodecV1(options, SchemaVersion.v1)],
+		[SchemaVersion.v2, makeSchemaChangeCodecV1(options, SchemaVersion.v2)],
+	]);
 }
 
 /**
@@ -43,14 +46,16 @@ export function makeSchemaChangeCodec(
 }
 
 /**
- * Compose the v1 schema change codec.
+ * Compose the change codec using mostly v1 logic.
  * @param options - The codec options.
+ * @param schemaWriteVersion - The schema write version.
  * @returns The composed schema change codec.
  */
 function makeSchemaChangeCodecV1(
 	options: ICodecOptions,
+	schemaWriteVersion: SchemaVersion,
 ): IJsonCodec<SchemaChange, EncodedSchemaChange> {
-	const schemaCodec = makeSchemaCodec(options, SchemaVersion.v1);
+	const schemaCodec = makeSchemaCodec(options, schemaWriteVersion);
 	const schemaChangeCodec: IJsonCodec<SchemaChange, EncodedSchemaChange> = {
 		encode: (schemaChange) => {
 			assert(
@@ -58,8 +63,8 @@ function makeSchemaChangeCodecV1(
 				0x933 /* Inverse schema changes should never be transmitted */,
 			);
 			return {
-				new: schemaCodec.encode(schemaChange.schema.new) as FormatV1,
-				old: schemaCodec.encode(schemaChange.schema.old) as FormatV1,
+				new: schemaCodec.encode(schemaChange.schema.new),
+				old: schemaCodec.encode(schemaChange.schema.old),
 			};
 		},
 		decode: (encoded) => {

package/src/feature-libraries/schema-edits/schemaChangeFormat.ts

@@ -4,11 +4,11 @@
  */
 
 import { type Static, Type } from "@sinclair/typebox";
-import { Format as FormatV1 } from "../schema-index/index.js";
+import { JsonCompatibleReadOnlySchema } from "../../util/index.js";
 
 export const EncodedSchemaChange = Type.Object({
-	new: FormatV1,
-	old: FormatV1,
+	new: JsonCompatibleReadOnlySchema,
+	old: JsonCompatibleReadOnlySchema,
 });
 
 export type EncodedSchemaChange = Static<typeof EncodedSchemaChange>;

package/src/feature-libraries/schema-index/codec.ts

@@ -20,13 +20,14 @@ import {
 	type TreeNodeStoredSchema,
 	type TreeStoredSchema,
 	decodeFieldSchema,
-	encodeFieldSchema,
-	type schemaFormatV1,
+	encodeFieldSchemaV1,
+	encodeFieldSchemaV2,
 	storedSchemaDecodeDispatcher,
 } from "../../core/index.js";
 import { brand, type JsonCompatible } from "../../util/index.js";
 
 import { Format as FormatV1 } from "./formatV1.js";
+import { Format as FormatV2 } from "./formatV2.js";
 
 /**
  * Convert a FluidClientVersion to a SchemaVersion.
@@ -62,7 +63,10 @@ export function makeSchemaCodec(
  * @returns The composed codec family.
  */
 export function makeSchemaCodecs(options: ICodecOptions): ICodecFamily<TreeStoredSchema> {
-	return makeCodecFamily([[SchemaVersion.v1, makeSchemaCodecV1(options)]]);
+	return makeCodecFamily([
+		[SchemaVersion.v1, makeSchemaCodecV1(options)],
+		[SchemaVersion.v2, makeSchemaCodecV2(options)],
+	]);
 }
 
 /**
@@ -74,36 +78,79 @@ export function makeSchemaCodecs(options: ICodecOptions): ICodecFamily<TreeStore
 export function encodeRepo(repo: TreeStoredSchema, version: SchemaVersion): JsonCompatible {
 	switch (version) {
 		case SchemaVersion.v1:
-			return encodeRepoV1(repo);
+			return encodeRepoV1(repo) as JsonCompatible;
+		case SchemaVersion.v2:
+			return encodeRepoV2(repo) as JsonCompatible;
 		default:
 			unreachableCase(version);
 	}
 }
 
 function encodeRepoV1(repo: TreeStoredSchema): FormatV1 {
-	const nodeSchema: Record<string, schemaFormatV1.TreeNodeSchemaDataFormat> =
-		Object.create(null);
-	const rootFieldSchema = encodeFieldSchema(repo.rootFieldSchema);
+	const nodeSchema = encodeNodeSchema(repo, (schema) => schema.encodeV1());
+	const rootFieldSchema = encodeFieldSchemaV1(repo.rootFieldSchema);
+	return {
+		version: SchemaVersion.v1,
+		nodes: nodeSchema,
+		root: rootFieldSchema,
+	};
+}
+
+function encodeRepoV2(repo: TreeStoredSchema): FormatV2 {
+	const nodeSchema = encodeNodeSchema(repo, (schema) => schema.encodeV2());
+	const rootFieldSchema = encodeFieldSchemaV2(repo.rootFieldSchema);
+	return {
+		version: SchemaVersion.v2,
+		nodes: nodeSchema,
+		root: rootFieldSchema,
+	};
+}
+
+/**
+ * Shared logic for encoding node schemas.
+ * @param repo - The stored schema to encode.
+ * @param encodeValue - A function which encodes a single node schema.
+ * @returns The encoded node schema.
+ */
+function encodeNodeSchema<TFormat>(
+	repo: TreeStoredSchema,
+	encodeValue: (schema: TreeNodeStoredSchema) => TFormat,
+): Record<string, TFormat> {
+	const nodeSchema: Record<string, TFormat> = Object.create(null);
 	for (const name of [...repo.nodeSchema.keys()].sort()) {
 		const schema = repo.nodeSchema.get(name) ?? fail(0xb28 /* missing schema */);
 		Object.defineProperty(nodeSchema, name, {
 			enumerable: true,
 			configurable: true,
 			writable: true,
-			value: schema.encode(),
+			value: encodeValue(schema),
 		});
 	}
+
+	return nodeSchema;
+}
+
+function decodeV1(f: FormatV1): TreeStoredSchema {
+	const nodeSchema: Map<TreeNodeSchemaIdentifier, TreeNodeStoredSchema> = new Map();
+	for (const [key, schema] of Object.entries(f.nodes)) {
+		const storedSchemaDecoder = storedSchemaDecodeDispatcher.dispatch(schema);
+
+		// No metadata in v1, so pass undefined
+		nodeSchema.set(brand(key), storedSchemaDecoder(undefined));
+	}
 	return {
-		version: SchemaVersion.v1,
-		nodes: nodeSchema,
-		root: rootFieldSchema,
+		rootFieldSchema: decodeFieldSchema(f.root),
+		nodeSchema,
 	};
 }
 
-function decode(f: FormatV1): TreeStoredSchema {
+function decodeV2(f: FormatV2): TreeStoredSchema {
 	const nodeSchema: Map<TreeNodeSchemaIdentifier, TreeNodeStoredSchema> = new Map();
 	for (const [key, schema] of Object.entries(f.nodes)) {
-		nodeSchema.set(brand(key), storedSchemaDecodeDispatcher.dispatch(schema));
+		const storedSchemaDecoder = storedSchemaDecodeDispatcher.dispatch(schema.kind);
+
+		// Pass in the node metadata
+		nodeSchema.set(brand(key), storedSchemaDecoder(schema.metadata));
 	}
 	return {
 		rootFieldSchema: decodeFieldSchema(f.root),
@@ -119,6 +166,18 @@ function decode(f: FormatV1): TreeStoredSchema {
 function makeSchemaCodecV1(options: ICodecOptions): IJsonCodec<TreeStoredSchema, FormatV1> {
 	return makeVersionedValidatedCodec(options, new Set([SchemaVersion.v1]), FormatV1, {
 		encode: (data: TreeStoredSchema) => encodeRepoV1(data),
-		decode: (data: FormatV1) => decode(data),
+		decode: (data: FormatV1) => decodeV1(data),
+	});
+}
+
+/**
+ * Creates a codec which performs synchronous monolithic encoding of schema content.
+ * @param options - Specifies common codec options, including which `validator` to use.
+ * @returns The codec.
+ */
+function makeSchemaCodecV2(options: ICodecOptions): IJsonCodec<TreeStoredSchema, FormatV2> {
+	return makeVersionedValidatedCodec(options, new Set([SchemaVersion.v2]), FormatV2, {
+		encode: (data: TreeStoredSchema) => encodeRepoV2(data),
+		decode: (data: FormatV2) => decodeV2(data),
 	});
 }

package/src/feature-libraries/schema-index/formatV2.ts

@@ -0,0 +1,30 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { type ObjectOptions, type Static, Type } from "@sinclair/typebox";
+
+import { SchemaVersion, schemaFormatV2 } from "../../core/index.js";
+
+const noAdditionalProps: ObjectOptions = { additionalProperties: false };
+
+/**
+ * Format for encoding as json.
+ *
+ * For consistency all lists are sorted and undefined values are omitted.
+ *
+ * This chooses to use lists of named objects instead of maps:
+ * this choice is somewhat arbitrary, but avoids user data being used as object keys,
+ * which can sometimes be an issue (for example handling that for "__proto__" can require care).
+ * It also makes it simpler to determinately sort by keys.
+ */
+export const Format = Type.Object(
+	{
+		version: Type.Literal(SchemaVersion.v2),
+		nodes: Type.Record(Type.String(), schemaFormatV2.TreeNodeSchemaDataFormat),
+		root: schemaFormatV2.FieldSchemaFormat,
+	},
+	noAdditionalProps,
+);
+export type Format = Static<typeof Format>;

package/src/feature-libraries/schema-index/index.ts

@@ -9,4 +9,5 @@ export {
 	makeSchemaCodecs,
 	clientVersionToSchemaVersion,
 } from "./codec.js";
-export { Format } from "./formatV1.js";
+export { Format as FormatV1 } from "./formatV1.js";
+export { Format as FormatV2 } from "./formatV2.js";

package/src/feature-libraries/schema-index/schemaSummarizer.ts

@@ -51,15 +51,18 @@ export class SchemaSummarizer implements Summarizable {
 		});
 	}
 
-	public getAttachSummary(
-		stringify: SummaryElementStringifier,
-		fullTree?: boolean,
-		trackState?: boolean,
-		telemetryContext?: ITelemetryContext,
-		incrementalSummaryContext?: IExperimentalIncrementalSummaryContext | undefined,
-	): ISummaryTreeWithStats {
+	public summarize(props: {
+		stringify: SummaryElementStringifier;
+		fullTree?: boolean;
+		trackState?: boolean;
+		telemetryContext?: ITelemetryContext;
+		incrementalSummaryContext?: IExperimentalIncrementalSummaryContext;
+	}): ISummaryTreeWithStats {
+		const incrementalSummaryContext = props.incrementalSummaryContext;
 		const builder = new SummaryTreeBuilder();
+		const fullTree = props.fullTree ?? false;
 		if (
+			!fullTree &&
 			incrementalSummaryContext !== undefined &&
 			this.schemaIndexLastChangedSeq !== undefined &&
 			incrementalSummaryContext.latestSummarySequenceNumber >= this.schemaIndexLastChangedSeq
@@ -67,7 +70,7 @@ export class SchemaSummarizer implements Summarizable {
 			builder.addHandle(
 				schemaStringKey,
 				SummaryType.Blob,
-				`${incrementalSummaryContext.summaryPath}/indexes/${this.key}/${schemaStringKey}`,
+				`${incrementalSummaryContext.summaryPath}/${schemaStringKey}`,
 			);
 		} else {
 			const dataString = JSON.stringify(this.codec.encode(this.schema));
@@ -76,16 +79,6 @@ export class SchemaSummarizer implements Summarizable {
 		return builder.getSummaryTree();
 	}
 
-	public async summarize(
-		stringify: SummaryElementStringifier,
-		fullTree?: boolean,
-		trackState?: boolean,
-		telemetryContext?: ITelemetryContext,
-		incrementalSummaryContext?: IExperimentalIncrementalSummaryContext | undefined,
-	): Promise<ISummaryTreeWithStats> {
-		throw new Error("Method not implemented.");
-	}
-
 	public async load(
 		services: IChannelStorageService,
 		parse: SummaryElementParser,

package/src/feature-libraries/treeCursorUtils.ts

@@ -72,6 +72,11 @@ export function stackTreeFieldCursor<TNode>(
 	return cursor;
 }
 
+/**
+ * The representation of a field used by {@link CursorAdapter}.
+ */
+export type Field<TNode> = Pick<readonly TNode[], typeof Symbol.iterator | "length" | number>;
+
 /**
  * Provides functionality to allow a {@link stackTreeNodeCursor} and {@link stackTreeFieldCursor} to implement cursors.
  */
@@ -91,10 +96,10 @@ export interface CursorAdapter<TNode> {
 	/**
 	 * @returns the child nodes for the given node and key.
 	 */
-	getFieldFromNode(node: TNode, key: FieldKey): readonly TNode[];
+	getFieldFromNode(node: TNode, key: FieldKey): Field<TNode>;
 }
 
-type SiblingsOrKey<TNode> = readonly TNode[] | readonly FieldKey[];
+type SiblingsOrKey<TNode> = Field<TNode> | readonly FieldKey[];
 
 /**
  * A class that satisfies part of the ITreeCursorSynchronous implementation.
@@ -122,7 +127,7 @@ export abstract class SynchronousCursor {
  * 2. Support for cursors which are field cursors at the root.
  */
 class StackCursor<TNode> extends SynchronousCursor implements CursorWithNode<TNode> {
-	public readonly [CursorMarker] = true;
+	public override readonly [CursorMarker] = true;
 	/**
 	 * Might start at special root where fields are detached sequences.
 	 *
@@ -149,14 +154,18 @@ class StackCursor<TNode> extends SynchronousCursor implements CursorWithNode<TNo
 		debugAssert(() =>
 			this.mode === CursorLocationType.Fields ? true : "must be in fields mode",
 		);
-		return this.siblings[this.index] as FieldKey;
+		// index is kept inbounds as an invariant of the class.
+		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+		return (this.siblings as readonly FieldKey[])[this.index]!;
 	}
 
 	private getStackedFieldKey(height: number): FieldKey {
 		assert(height % 2 === 1, 0x3b8 /* must field height */);
 		const siblingStack = this.siblingStack[height] ?? oob();
 		const indexStack = this.indexStack[height] ?? oob();
-		return siblingStack[indexStack] as FieldKey;
+		// index is kept inbounds as an invariant of the class.
+		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+		return (siblingStack as readonly FieldKey[])[indexStack]!;
 	}
 
 	private getStackedNodeIndex(height: number): number {
@@ -166,9 +175,10 @@ class StackCursor<TNode> extends SynchronousCursor implements CursorWithNode<TNo
 
 	private getStackedNode(height: number): TNode {
 		const index = this.getStackedNodeIndex(height);
-		// Test is failing when using `?? oob()` here.
+		// Can not use `?? oob()` since null and undefined are valid values.
+		// index is kept inbounds as an invariant of the class.
 		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-		return (this.siblingStack[height] as readonly TNode[])[index]!;
+		return (this.siblingStack[height] as Field<TNode>)[index]!;
 	}
 
 	public getFieldLength(): number {
@@ -358,12 +368,13 @@ class StackCursor<TNode> extends SynchronousCursor implements CursorWithNode<TNo
 
 	public getNode(): TNode {
 		// assert(this.mode === CursorLocationType.Nodes, "can only get node when in node");
-		// Test is failing when using `?? oob()` here.
+		// Can not use `?? oob()` since null and undefined are valid values.
+		// index is kept inbounds as an invariant of the class.
 		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-		return (this.siblings as TNode[])[this.index]!;
+		return (this.siblings as Field<TNode>)[this.index]!;
 	}
 
-	private getField(): readonly TNode[] {
+	private getField(): Field<TNode> {
 		// assert(this.mode === CursorLocationType.Fields, "can only get field when in fields");
 		const parent = this.getStackedNode(this.indexStack.length - 1);
 		const key: FieldKey = this.getFieldKey();

package/src/index.ts

@@ -113,6 +113,7 @@ export {
 	type TreeNodeSchemaClass,
 	type SchemaCompatibilityStatus,
 	type FieldProps,
+	type FieldPropsAlpha,
 	type InternalTreeNode,
 	type WithType,
 	type NodeChangedData,
@@ -198,6 +199,7 @@ export {
 	type LazyItem,
 	type Unenforced,
 	type SimpleNodeSchemaBase,
+	type SimpleNodeSchemaBaseAlpha,
 	type SimpleTreeSchema,
 	type SimpleNodeSchema,
 	type SimpleFieldSchema,
@@ -215,6 +217,7 @@ export {
 	type TreeBranchEvents,
 	asTreeViewAlpha,
 	type NodeSchemaOptions,
+	type NodeSchemaOptionsAlpha,
 	type NodeSchemaMetadata,
 	type SchemaStatics,
 	type ITreeAlpha,
@@ -255,6 +258,7 @@ export { persistedToSimpleSchema } from "./shared-tree/index.js";
 
 export {
 	type ICodecOptions,
+	type CodecWriteOptions,
 	type JsonValidator,
 	type SchemaValidationFunction,
 	FluidClientVersion,
@@ -281,6 +285,8 @@ export type {
 	PopUnion,
 	JsonCompatible,
 	JsonCompatibleObject,
+	JsonCompatibleReadOnly,
+	JsonCompatibleReadOnlyObject,
 } from "./util/index.js";
 export { cloneWithReplacements } from "./util/index.js";
 

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/tree";
-export const pkgVersion = "2.41.0";
+export const pkgVersion = "2.43.0-343119";

package/src/shared-tree/schematizeTree.ts

@@ -68,6 +68,7 @@ export function initializeContent(
 			rootFieldSchema: {
 				kind: FieldKinds.optional.identifier,
 				types: rootSchema.types,
+				persistedMetadata: rootSchema.persistedMetadata,
 			},
 		};
 	}