@fluidframework/tree 2.4.0-297385 → 2.4.0-299374

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

@@ -12,11 +12,7 @@ import { UsageError } from "@fluidframework/telemetry-utils/internal";
 import { isFluidHandle } from "@fluidframework/runtime-utils/internal";
 
 import type { TreeValue } from "../../core/index.js";
-import {
-	type NodeKeyManager,
-	type Unenforced,
-	isLazy,
-} from "../../feature-libraries/index.js";
+import type { NodeKeyManager } from "../../feature-libraries/index.js";
 import {
 	type RestrictiveStringRecord,
 	getOrCreate,
@@ -73,9 +69,11 @@ import type {
 	TreeArrayNodeUnsafe,
 	TreeMapNodeUnsafe,
 	TreeObjectNodeUnsafe,
-} from "../typesUnsafe.js";
+	Unenforced,
+} from "./typesUnsafe.js";
 import { createFieldSchemaUnsafe } from "./schemaFactoryRecursive.js";
 import { TreeNodeValid } from "../treeNodeValid.js";
+import { isLazy } from "../flexList.js";
 /**
  * Gets the leaf domain schema compatible with a given {@link TreeValue}.
  */

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

@@ -3,7 +3,6 @@
  * Licensed under the MIT License.
  */
 
-import type { Unenforced } from "../../feature-libraries/index.js";
 import type { RestrictiveStringRecord } from "../../util/index.js";
 import type { InsertableObjectFromSchemaRecord } from "../objectNode.js";
 
@@ -22,7 +21,7 @@ import type {
 	WithType,
 	TreeNode,
 } from "../core/index.js";
-import type { FieldSchemaUnsafe } from "../typesUnsafe.js";
+import type { FieldSchemaUnsafe, Unenforced } from "./typesUnsafe.js";
 
 export function createFieldSchemaUnsafe<
 	Kind extends FieldKind,

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

@@ -0,0 +1,126 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import type { ICodecOptions } from "../../codec/index.js";
+import { Compatibility, type TreeStoredSchema } from "../../core/index.js";
+import {
+	defaultSchemaPolicy,
+	encodeTreeSchema,
+	makeSchemaCodec,
+} from "../../feature-libraries/index.js";
+// eslint-disable-next-line import/no-internal-modules
+import type { Format } from "../../feature-libraries/schema-index/index.js";
+import type { JsonCompatible } from "../../util/index.js";
+import type { ImplicitFieldSchema } from "../schemaTypes.js";
+import { toStoredSchema } from "../toFlexSchema.js";
+import type { SchemaCompatibilityStatus } from "./tree.js";
+import { ViewSchema } from "./view.js";
+
+/**
+ * Dumps the "persisted" schema subset of the provided `schema` into a deterministic JSON-compatible, semi-human-readable, but unspecified format.
+ *
+ * @remarks
+ * This can be used to help inspect schema for debugging, and to save a snapshot of schema to help detect and review changes to an applications schema.
+ *
+ * This format may change across major versions of this package: such changes are considered breaking.
+ * Beyond that, no compatibility guarantee is provided for this format: it should never be relied upon to load data, it should only be used for comparing outputs from this function.
+ *
+ * This only includes the "persisted" subset of schema information, which means the portion which gets included in documents.
+ * It thus uses "persisted" keys, see {@link FieldProps.key}.
+ *
+ * If two schema have identical "persisted" schema, then they are considered {@link SchemaCompatibilityStatus.isEquivalent|equivalent}.
+ *
+ * See also {@link comparePersistedSchema}.
+ *
+ * @example
+ * An application could use this API to generate a `schema.json` file when it first releases,
+ * then test that the schema is sill compatible with documents from that version with a test like :
+ * ```typescript
+ * assert.deepEqual(extractPersistedSchema(MySchema), require("./schema.json"));
+ * ```
+ *
+ * @privateRemarks
+ * This currently uses the schema summary format, but that could be changed to something more human readable (particularly if the encoded format becomes less human readable).
+ * This intentionally does not leak the format types in the API.
+ *
+ * Public API surface uses "persisted" terminology while internally we use "stored".
+ * @alpha
+ */
+export function extractPersistedSchema(schema: ImplicitFieldSchema): JsonCompatible {
+	const stored = toStoredSchema(schema);
+	return encodeTreeSchema(stored);
+}
+
+/**
+ * Compares two schema extracted using {@link extractPersistedSchema}.
+ * Reports the same compatibility that {@link TreeView.compatibility} would report if
+ * opening a document that used the `persisted` schema and provided `view` to {@link ViewableTree.viewWith}.
+ *
+ * @param persisted - Schema persisted for a document. Typically persisted alongside the data and assumed to describe that data.
+ * @param view - Schema which would be used to view persisted content. Use {@link extractPersistedSchema} to convert the view schema into this format.
+ * @param options - {@link ICodecOptions} used when parsing the provided schema.
+ * @param canInitialize - Passed through to the return value unchanged and otherwise unused.
+ * @returns The {@link SchemaCompatibilityStatus} a {@link TreeView} would report for this combination of schema.
+ *
+ * @remarks
+ * This uses the persisted formats for schema, meaning it only includes data which impacts compatibility.
+ * It also uses the persisted format so that this API can be used in tests to compare against saved schema from previous versions of the application.
+ *
+ * @example
+ * An application could use {@link extractPersistedSchema} to generate a `schema.json` file for various versions of the app,
+ * then test that documents using those schema can be upgraded to work with the current schema using a test like:
+ * ```typescript
+ * assert(
+ * 	comparePersistedSchema(
+ * 		require("./schema.json"),
+ * 		extractPersistedSchema(MySchema),
+ * 		{ jsonValidator: typeboxValidator },
+ * 		false,
+ * 	).canUpgrade,
+ * );
+ * ```
+ * @alpha
+ */
+export function comparePersistedSchema(
+	persisted: JsonCompatible,
+	view: JsonCompatible,
+	options: ICodecOptions,
+	canInitialize: boolean,
+): SchemaCompatibilityStatus {
+	const schemaCodec = makeSchemaCodec(options);
+	const stored = schemaCodec.decode(persisted as Format);
+	const viewParsed = schemaCodec.decode(view as Format);
+	const viewSchema = new ViewSchema(defaultSchemaPolicy, {}, viewParsed);
+	return comparePersistedSchemaInternal(stored, viewSchema, canInitialize);
+}
+
+/**
+ * Compute compatibility for viewing a document with `stored` schema using `viewSchema`.
+ * `canInitialize` is passed through to the return value unchanged and otherwise unused.
+ */
+export function comparePersistedSchemaInternal(
+	stored: TreeStoredSchema,
+	viewSchema: ViewSchema,
+	canInitialize: boolean,
+): SchemaCompatibilityStatus {
+	const result = viewSchema.checkCompatibility(stored);
+
+	// TODO: AB#8121: Weaken this check to support viewing under additional circumstances.
+	// In the near term, this should support viewing documents with additional optional fields in their schema on object types.
+	// Longer-term (as demand arises), we could also add APIs to constructing view schema to allow for more flexibility
+	// (e.g. out-of-schema content handlers could allow support for viewing docs which have extra allowed types in a particular field)
+	const canView =
+		result.write === Compatibility.Compatible && result.read === Compatibility.Compatible;
+	const canUpgrade = result.read === Compatibility.Compatible;
+	const isEquivalent = canView && canUpgrade;
+	const compatibility: SchemaCompatibilityStatus = {
+		canView,
+		canUpgrade,
+		isEquivalent,
+		canInitialize,
+	};
+
+	return compatibility;
+}

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

@@ -11,11 +11,14 @@ import type { Listenable } from "../../events/index.js";
 
 import {
 	type ImplicitFieldSchema,
+	type InsertableField,
 	type InsertableTreeFieldFromImplicitField,
 	type TreeFieldFromImplicitField,
+	type TreeLeafValue,
+	type UnsafeUnknownSchema,
 	FieldKind,
 } from "../schemaTypes.js";
-import { NodeKind, type TreeNodeSchema } from "../core/index.js";
+import { NodeKind, type TreeNode, type TreeNodeSchema } from "../core/index.js";
 import { toStoredSchema } from "../toFlexSchema.js";
 import { LeafNodeSchema } from "../leafNodeSchema.js";
 import { assert } from "@fluidframework/core-utils/internal";
@@ -363,7 +366,7 @@ export function checkUnion(union: Iterable<TreeNodeSchema>, errors: string[]): v
  * Thus this design was chosen at the risk of apps blindly accessing `root` then breaking unexpectedly when the document is incompatible.
  * @sealed @public
  */
-export interface TreeView<TSchema extends ImplicitFieldSchema> extends IDisposable {
+export interface TreeView<in out TSchema extends ImplicitFieldSchema> extends IDisposable {
 	/**
 	 * The current root of the tree.
 	 *
@@ -424,6 +427,25 @@ export interface TreeView<TSchema extends ImplicitFieldSchema> extends IDisposab
 	readonly schema: TSchema;
 }
 
+/**
+ * {@link TreeView} with proposed changes to the schema aware typing to allow use with `UnsafeUnknownSchema`.
+ * @alpha
+ */
+export interface TreeViewAlpha<
+	in out TSchema extends ImplicitFieldSchema | UnsafeUnknownSchema,
+> extends Omit<
+		TreeView<TSchema extends ImplicitFieldSchema ? TSchema : ImplicitFieldSchema>,
+		"root" | "initialize"
+	> {
+	get root(): TSchema extends ImplicitFieldSchema
+		? TreeFieldFromImplicitField<TSchema>
+		: TreeLeafValue | TreeNode;
+
+	set root(newRoot: InsertableField<TSchema>);
+
+	initialize(content: InsertableField<TSchema>): void;
+}
+
 /**
  * Information about a view schema's compatibility with the document's stored schema.
  *

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

@@ -6,15 +6,8 @@
 import { assert, oob } from "@fluidframework/core-utils/internal";
 
 import { EmptyKey, rootFieldKey } from "../../core/index.js";
-import {
-	type LazyItem,
-	type TreeStatus,
-	isLazy,
-	isTreeValue,
-	FieldKinds,
-} from "../../feature-libraries/index.js";
+import { type TreeStatus, isTreeValue, FieldKinds } from "../../feature-libraries/index.js";
 import { fail, extractFromOpaque, isReadonlyArray } from "../../util/index.js";
-import { getOrCreateInnerNode } from "../proxyBinding.js";
 import {
 	type TreeLeafValue,
 	type ImplicitFieldSchema,
@@ -43,8 +36,10 @@ import {
 	getOrCreateNodeFromInnerNode,
 	UnhydratedFlexTreeNode,
 	typeSchemaSymbol,
+	getOrCreateInnerNode,
 } from "../core/index.js";
 import { isObjectNodeSchema } from "../objectNodeTypes.js";
+import { isLazy, type LazyItem } from "../flexList.js";
 
 /**
  * Provides various functions for analyzing {@link TreeNode}s.

package/src/simple-tree/{typesUnsafe.ts → api/typesUnsafe.ts}

@@ -3,27 +3,27 @@
  * Licensed under the MIT License.
  */
 
-import type { FlexListToUnion, Unenforced } from "../feature-libraries/index.js";
-import type { RestrictiveStringRecord, _InlineTrick } from "../util/index.js";
+import type { RestrictiveStringRecord, _InlineTrick } from "../../util/index.js";
 
 import type {
-	AllowedTypes,
 	ApplyKind,
 	FieldKind,
 	FieldSchema,
 	ImplicitAllowedTypes,
 	ImplicitFieldSchema,
-	NodeFromSchema,
-	TreeNodeFromImplicitAllowedTypes,
-} from "./schemaTypes.js";
+	TreeLeafValue,
+} from "../schemaTypes.js";
 import type {
 	NodeKind,
-	TreeNodeSchema,
 	WithType,
 	TreeNode,
 	Unhydrated,
-} from "./core/index.js";
-import type { TreeArrayNodeBase, TreeArrayNode } from "./arrayNode.js";
+	InternalTreeNode,
+	TreeNodeSchema,
+	TreeNodeSchemaCore,
+} from "../core/index.js";
+import type { TreeArrayNodeBase } from "../arrayNode.js";
+import type { FlexListToUnion, LazyItem } from "../flexList.js";
 
 /*
  * TODO:
@@ -37,6 +37,16 @@ import type { TreeArrayNodeBase, TreeArrayNode } from "./arrayNode.js";
  */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
+/**
+ * A placeholder to use in {@link https://www.typescriptlang.org/docs/handbook/2/generics.html#generic-constraints | extends constraints} when using the real type breaks compilation of some recursive types due to {@link https://github.com/microsoft/TypeScript/issues/55758 | a design limitation of TypeScript}.
+ *
+ * These extends constraints only serve as documentation:
+ * to avoid breaking compilation, this type has to not actually enforce anything, and thus is just `unknown`.
+ * Therefore the type safety is the responsibility of the user of the API.
+ * @public
+ */
+export type Unenforced<_DesiredExtendsConstraint> = unknown;
+
 /**
  * {@link Unenforced} version of `ObjectFromSchemaRecord`.
  * @remarks
@@ -49,6 +59,65 @@ export type ObjectFromSchemaRecordUnsafe<
 	-readonly [Property in keyof T]: TreeFieldFromImplicitFieldUnsafe<T[Property]>;
 };
 
+/**
+ * {@link Unenforced} version of {@link TreeNodeSchema}.
+ * @remarks
+ * Do note use this type directly: its only needed in the implementation of generic logic which define recursive schema, not when using recursive schema.
+ * @system @public
+ */
+export type TreeNodeSchemaUnsafe<
+	Name extends string = string,
+	Kind extends NodeKind = NodeKind,
+	TNode extends Unenforced<TreeNode | TreeLeafValue> = unknown,
+	TBuild = never,
+	ImplicitlyConstructable extends boolean = boolean,
+	Info = unknown,
+> =
+	| TreeNodeSchemaClassUnsafe<Name, Kind, TNode, TBuild, ImplicitlyConstructable, Info>
+	| TreeNodeSchemaNonClassUnsafe<Name, Kind, TNode, TBuild, ImplicitlyConstructable, Info>;
+
+/**
+ * {@link Unenforced} version of {@link TreeNodeSchemaClass}.
+ * @remarks
+ * Do note use this type directly: its only needed in the implementation of generic logic which define recursive schema, not when using recursive schema.
+ * @system @public
+ */
+export interface TreeNodeSchemaClassUnsafe<
+	out Name extends string,
+	out Kind extends NodeKind,
+	// TODO: maybe this can be more specific (exclude leaves)
+	out TNode extends Unenforced<TreeNode | TreeLeafValue>,
+	in TInsertable = never,
+	out ImplicitlyConstructable extends boolean = boolean,
+	out Info = unknown,
+> extends TreeNodeSchemaCore<Name, Kind, ImplicitlyConstructable, Info> {
+	/**
+	 * Constructs an {@link Unhydrated} node with this schema.
+	 * @remarks
+	 * This constructor is also used internally to construct hydrated nodes with a different parameter type.
+	 * Therefore, overriding this constructor with different argument types is not type-safe and is not supported.
+	 * @sealed
+	 */
+	new (data: TInsertable | InternalTreeNode): Unhydrated<TNode>;
+}
+
+/**
+ * {@link Unenforced} version of {@link TreeNodeSchemaNonClass}.
+ * @remarks
+ * Do note use this type directly: its only needed in the implementation of generic logic which define recursive schema, not when using recursive schema.
+ * @system @public
+ */
+export interface TreeNodeSchemaNonClassUnsafe<
+	out Name extends string,
+	out Kind extends NodeKind,
+	out TNode extends Unenforced<TreeNode | TreeLeafValue>,
+	in TInsertable = never,
+	out ImplicitlyConstructable extends boolean = boolean,
+	out Info = unknown,
+> extends TreeNodeSchemaCore<Name, Kind, ImplicitlyConstructable, Info> {
+	create(data: TInsertable): TNode;
+}
+
 /**
  * {@link Unenforced} version of {@link TreeObjectNode}.
  * @remarks
@@ -73,6 +142,14 @@ export type TreeFieldFromImplicitFieldUnsafe<TSchema extends Unenforced<Implicit
 			? TreeNodeFromImplicitAllowedTypesUnsafe<TSchema>
 			: unknown;
 
+/**
+ * {@link Unenforced} version of {@link AllowedTypes}.
+ * @remarks
+ * Do note use this type directly: its only needed in the implementation of generic logic which define recursive schema, not when using recursive schema.
+ * @system @public
+ */
+export type AllowedTypesUnsafe = readonly LazyItem<TreeNodeSchemaUnsafe>[];
+
 /**
  * {@link Unenforced} version of {@link TreeNodeFromImplicitAllowedTypes}.
  * @remarks
@@ -81,13 +158,11 @@ export type TreeFieldFromImplicitFieldUnsafe<TSchema extends Unenforced<Implicit
  */
 export type TreeNodeFromImplicitAllowedTypesUnsafe<
 	TSchema extends Unenforced<ImplicitAllowedTypes>,
-> = TSchema extends ImplicitAllowedTypes
-	? TreeNodeFromImplicitAllowedTypes<TSchema>
-	: TSchema extends TreeNodeSchema
-		? NodeFromSchema<TSchema>
-		: TSchema extends AllowedTypes
-			? NodeFromSchema<FlexListToUnion<TSchema>>
-			: unknown;
+> = TSchema extends TreeNodeSchemaUnsafe
+	? NodeFromSchemaUnsafe<TSchema>
+	: TSchema extends AllowedTypesUnsafe
+		? NodeFromSchemaUnsafe<FlexListToUnion<TSchema>>
+		: unknown;
 
 /**
  * {@link Unenforced} version of {@link InsertableTreeNodeFromImplicitAllowedTypes}.
@@ -97,7 +172,7 @@ export type TreeNodeFromImplicitAllowedTypesUnsafe<
  */
 export type InsertableTreeNodeFromImplicitAllowedTypesUnsafe<
 	TSchema extends Unenforced<ImplicitAllowedTypes>,
-> = TSchema extends AllowedTypes
+> = TSchema extends AllowedTypesUnsafe
 	? InsertableTypedNodeUnsafe<FlexListToUnion<TSchema>>
 	: InsertableTypedNodeUnsafe<TSchema>;
 
@@ -119,7 +194,7 @@ export type InsertableTypedNodeUnsafe<T extends Unenforced<TreeNodeSchema>> = [
  * @system @public
  */
 export type NodeFromSchemaUnsafe<T extends Unenforced<TreeNodeSchema>> =
-	T extends TreeNodeSchema<string, NodeKind, infer TNode> ? TNode : never;
+	T extends TreeNodeSchemaUnsafe<string, NodeKind, infer TNode> ? TNode : never;
 
 /**
  * {@link Unenforced} version of {@link InsertableTreeNodeFromImplicitAllowedTypes}.
@@ -128,7 +203,7 @@ export type NodeFromSchemaUnsafe<T extends Unenforced<TreeNodeSchema>> =
  * @system @public
  */
 export type NodeBuilderDataUnsafe<T extends Unenforced<TreeNodeSchema>> =
-	T extends TreeNodeSchema<string, NodeKind, unknown, infer TBuild> ? TBuild : never;
+	T extends TreeNodeSchemaUnsafe<string, NodeKind, unknown, infer TBuild> ? TBuild : never;
 
 /**
  * {@link Unenforced} version of {@link (TreeArrayNode:interface)}.
@@ -139,8 +214,7 @@ export type NodeBuilderDataUnsafe<T extends Unenforced<TreeNodeSchema>> =
 export interface TreeArrayNodeUnsafe<TAllowedTypes extends Unenforced<ImplicitAllowedTypes>>
 	extends TreeArrayNodeBase<
 		TreeNodeFromImplicitAllowedTypesUnsafe<TAllowedTypes>,
-		InsertableTreeNodeFromImplicitAllowedTypesUnsafe<TAllowedTypes>,
-		TreeArrayNode
+		InsertableTreeNodeFromImplicitAllowedTypesUnsafe<TAllowedTypes>
 	> {}
 
 /**

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

@@ -10,10 +10,7 @@ import { assert } from "@fluidframework/core-utils/internal";
 import {
 	aboveRootPlaceholder,
 	EmptyKey,
-	forEachField,
-	inCursorField,
 	keyAsDetachedField,
-	mapCursorField,
 	type FieldKey,
 	type ITreeCursor,
 	type ITreeCursorSynchronous,
@@ -40,16 +37,22 @@ import {
 	stringSchema,
 } from "../leafNodeSchema.js";
 import { isObjectNodeSchema } from "../objectNodeTypes.js";
-import { walkFieldSchema } from "../walkFieldSchema.js";
+import {
+	customFromCursorInner,
+	type CustomTreeNode,
+	type CustomTreeValue,
+	type EncodeOptions,
+} from "./customTree.js";
 import { getUnhydratedContext } from "../createContext.js";
 
 /**
- * Verbose encoding of a {@link TreeNode} or {@link TreeValue}.
+ * Verbose encoding of a {@link TreeNode} or {@link TreeLeafValue}.
  * @remarks
  * This is verbose meaning that every {@link TreeNode} is a {@link VerboseTreeNode}.
  * Any IFluidHandle values have been replaced by `THandle`.
  * @privateRemarks
- * This can store all possible simple trees, but it can not store all possible trees representable by our internal representations like FlexTree and JsonableTree.
+ * This can store all possible simple trees,
+ * but it can not store all possible trees representable by our internal representations like FlexTree and JsonableTree.
  */
 export type VerboseTree<THandle = IFluidHandle> =
 	| VerboseTreeNode<THandle>
@@ -77,7 +80,8 @@ export type VerboseTree<THandle = IFluidHandle> =
  * This format allows for all simple-tree compatible trees to be represented.
  *
  * Unlike `JsonableTree`, leaf nodes are not boxed into node objects, and instead have their schema inferred from the value.
- * Additionally, sequence fields can only occur on a node that has a single sequence field (with the empty key) replicating the behavior of simple-tree ArrayNodes.
+ * Additionally, sequence fields can only occur on a node that has a single sequence field (with the empty key)
+ * replicating the behavior of simple-tree ArrayNodes.
  */
 export interface VerboseTreeNode<THandle = IFluidHandle> {
 	/**
@@ -144,24 +148,6 @@ export interface SchemalessParseOptions<TCustom> {
 	};
 }
 
-/**
- * Options for how to interpret a `VerboseTree<TCustom>` without relying on schema.
- */
-export interface EncodeOptions<TCustom> {
-	/**
-	 * Fixup custom input formats.
-	 * @remarks
-	 * See note on {@link ParseOptions.valueConverter}.
-	 */
-	valueConverter(data: IFluidHandle): TCustom;
-	/**
-	 * If true, interpret the input keys of object nodes as stored keys.
-	 * If false, interpret them as property keys.
-	 * @defaultValue false.
-	 */
-	readonly useStoredKeys?: boolean;
-}
-
 /**
  * Use info from `schema` to convert `options` to {@link SchemalessParseOptions}.
  */
@@ -345,12 +331,7 @@ export function verboseFromCursor<TCustom>(
 		...options,
 	};
 
-	const schemaMap = new Map<string, TreeNodeSchema>();
-	walkFieldSchema(rootSchema, {
-		node(schema) {
-			schemaMap.set(schema.identifier, schema);
-		},
-	});
+	const schemaMap = getUnhydratedContext(rootSchema).schema;
 
 	return verboseFromCursorInner(reader, config, schemaMap);
 }
@@ -360,50 +341,14 @@ function verboseFromCursorInner<TCustom>(
 	options: Required<EncodeOptions<TCustom>>,
 	schema: ReadonlyMap<string, TreeNodeSchema>,
 ): VerboseTree<TCustom> {
-	const type = reader.type;
-	const nodeSchema = schema.get(type) ?? fail("missing schema for type in cursor");
-
-	switch (type) {
-		case numberSchema.identifier:
-		case booleanSchema.identifier:
-		case nullSchema.identifier:
-		case stringSchema.identifier:
-			assert(reader.value !== undefined, 0xa14 /* out of schema: missing value */);
-			assert(!isFluidHandle(reader.value), 0xa15 /* out of schema: unexpected FluidHandle */);
-			return reader.value;
-		case handleSchema.identifier:
-			assert(reader.value !== undefined, 0xa16 /* out of schema: missing value */);
-			assert(isFluidHandle(reader.value), 0xa17 /* out of schema: unexpected FluidHandle */);
-			return options.valueConverter(reader.value);
-		default: {
-			assert(reader.value === undefined, 0xa18 /* out of schema: unexpected value */);
-			if (nodeSchema.kind === NodeKind.Array) {
-				const fields = inCursorField(reader, EmptyKey, () =>
-					mapCursorField(reader, () => verboseFromCursorInner(reader, options, schema)),
-				);
-				return { type, fields };
-			} else {
-				const fields: Record<string, VerboseTree<TCustom>> = {};
-				forEachField(reader, () => {
-					const children = mapCursorField(reader, () =>
-						verboseFromCursorInner(reader, options, schema),
-					);
-					if (children.length === 1) {
-						const storedKey = reader.getFieldKey();
-						const key =
-							isObjectNodeSchema(nodeSchema) && !options.useStoredKeys
-								? nodeSchema.storedKeyToPropertyKey.get(storedKey) ??
-									fail("missing property key")
-								: storedKey;
-						// Length is checked above.
-						// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-						fields[key] = children[0]!;
-					} else {
-						assert(children.length === 0, 0xa19 /* invalid children number */);
-					}
-				});
-				return { type, fields };
-			}
-		}
+	const fields = customFromCursorInner(reader, options, schema, verboseFromCursorInner);
+	const nodeSchema = schema.get(reader.type) ?? fail("missing schema for type in cursor");
+	if (nodeSchema.kind === NodeKind.Leaf) {
+		return fields as CustomTreeValue<TCustom>;
 	}
+
+	return {
+		type: reader.type,
+		fields: fields as CustomTreeNode<TCustom>,
+	};
 }