@fluidframework/tree 2.4.0-294316 → 2.4.0-297027

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

@@ -7,7 +7,6 @@ import type { IFluidHandle } from "@fluidframework/core-interfaces";
 import { assert } from "@fluidframework/core-utils/internal";
 
 import type { ITreeCursorSynchronous, SchemaAndPolicy } from "../../core/index.js";
-import { fail } from "../../util/index.js";
 import type {
 	TreeLeafValue,
 	ImplicitFieldSchema,
@@ -16,19 +15,20 @@ import type {
 	FieldSchema,
 	FieldKind,
 } from "../schemaTypes.js";
-import type { Unhydrated } from "../core/index.js";
+import {
+	getOrCreateNodeFromInnerNode,
+	UnhydratedFlexTreeNode,
+	type Unhydrated,
+} from "../core/index.js";
 import {
 	cursorForMapTreeNode,
 	defaultSchemaPolicy,
 	FieldKinds,
-	intoStoredSchema,
 	mapTreeFromCursor,
-	UnhydratedContext,
 	type NodeKeyManager,
 } from "../../feature-libraries/index.js";
-import { getOrCreateNodeFromFlexTreeNode } from "../proxies.js";
-import { getOrCreateMapTreeNode, isFieldInSchema } from "../../feature-libraries/index.js";
-import { toFlexSchema } from "../toFlexSchema.js";
+import { isFieldInSchema } from "../../feature-libraries/index.js";
+import { toStoredSchema } from "../toFlexSchema.js";
 import { inSchemaOrThrow, mapTreeFromNodeData, type InsertableContent } from "../toMapTree.js";
 import {
 	applySchemaToParserOptions,
@@ -37,6 +37,7 @@ import {
 	type VerboseTree,
 	type VerboseTreeNode,
 } from "./verboseTree.js";
+import { getUnhydratedContext } from "../createContext.js";
 
 /**
  * Construct tree content that is compatible with the field defined by the provided `schema`.
@@ -78,11 +79,11 @@ export function cursorFromInsertable<TSchema extends ImplicitFieldSchema>(
 ):
 	| ITreeCursorSynchronous
 	| (TSchema extends FieldSchema<FieldKind.Optional> ? undefined : never) {
-	const flexSchema = toFlexSchema(schema);
+	const storedSchema = toStoredSchema(schema);
 	const schemaValidationPolicy: SchemaAndPolicy = {
 		policy: defaultSchemaPolicy,
 		// TODO: optimize: This isn't the most efficient operation since its not cached, and has to convert all the schema.
-		schema: intoStoredSchema(flexSchema),
+		schema: storedSchema,
 	};
 
 	const mapTree = mapTreeFromNodeData(
@@ -93,7 +94,7 @@ export function cursorFromInsertable<TSchema extends ImplicitFieldSchema>(
 	);
 	if (mapTree === undefined) {
 		assert(
-			flexSchema.rootFieldSchema.kind === FieldKinds.optional,
+			storedSchema.rootFieldSchema.kind === FieldKinds.optional.identifier,
 			0xa10 /* missing non-optional field */,
 		);
 		return undefined as TSchema extends FieldSchema<FieldKind.Optional> ? undefined : never;
@@ -149,17 +150,17 @@ export function createFromCursor<TSchema extends ImplicitFieldSchema>(
 	cursor: ITreeCursorSynchronous | undefined,
 ): Unhydrated<TreeFieldFromImplicitField<TSchema>> {
 	const mapTrees = cursor === undefined ? [] : [mapTreeFromCursor(cursor)];
-	const flexSchema = toFlexSchema(schema);
+	const context = getUnhydratedContext(schema);
+	const flexSchema = context.flexContext.schema;
 
 	const schemaValidationPolicy: SchemaAndPolicy = {
 		policy: defaultSchemaPolicy,
-		// TODO: optimize: This isn't the most efficient operation since its not cached, and has to convert all the schema.
-		schema: intoStoredSchema(flexSchema),
+		schema: context.flexContext.schema,
 	};
 
 	const maybeError = isFieldInSchema(
 		mapTrees,
-		flexSchema.rootFieldSchema.stored,
+		flexSchema.rootFieldSchema,
 		schemaValidationPolicy,
 	);
 	inSchemaOrThrow(maybeError);
@@ -171,14 +172,11 @@ export function createFromCursor<TSchema extends ImplicitFieldSchema>(
 	// Length asserted above, so this is safe. This assert is done instead of checking for undefined after indexing to ensure a length greater than 1 also errors.
 	// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 	const mapTree = mapTrees[0]!;
-	const rootSchema = flexSchema.nodeSchema.get(mapTree.type) ?? fail("missing schema");
-	const mapTreeNode = getOrCreateMapTreeNode(
-		new UnhydratedContext(flexSchema),
-		rootSchema,
+	const mapTreeNode = UnhydratedFlexTreeNode.getOrCreate(
+		getUnhydratedContext(schema),
 		mapTree,
 	);
 
-	// TODO: ensure this works for InnerNodes to create unhydrated nodes
-	const result = getOrCreateNodeFromFlexTreeNode(mapTreeNode);
+	const result = getOrCreateNodeFromInnerNode(mapTreeNode);
 	return result as Unhydrated<TreeFieldFromImplicitField<TSchema>>;
 }

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

@@ -4,7 +4,7 @@
  */
 
 import type { JsonTreeSchema } from "./jsonSchema.js";
-import type { ImplicitAllowedTypes } from "../schemaTypes.js";
+import type { ImplicitFieldSchema } from "../schemaTypes.js";
 import { toJsonSchema } from "./simpleSchemaToJsonSchema.js";
 import { getSimpleSchema } from "./getSimpleSchema.js";
 import { getOrCreate } from "../../util/index.js";
@@ -53,7 +53,7 @@ const jsonSchemaCache = new WeakMap<TreeNodeSchema, JsonTreeSchema>();
  * 			"required": ["foo"],
  * 		},
  * 	},
- * 	"anyOf": [ { "$ref": "#/$defs/com.myapp.MyObject" } ],
+ * 	"$ref": "#/$defs/com.myapp.MyObject",
  * }
  * ```
  *
@@ -62,7 +62,7 @@ const jsonSchemaCache = new WeakMap<TreeNodeSchema, JsonTreeSchema>();
  *
  * @alpha
  */
-export function getJsonSchema(schema: ImplicitAllowedTypes): JsonTreeSchema {
+export function getJsonSchema(schema: ImplicitFieldSchema): JsonTreeSchema {
 	return getOrCreate(jsonSchemaCache, schema, () => {
 		const simpleSchema = getSimpleSchema(schema);
 		return toJsonSchema(simpleSchema);

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

@@ -5,7 +5,7 @@
 
 import { getOrCreate } from "../../util/index.js";
 import type { TreeNodeSchema } from "../core/index.js";
-import type { ImplicitAllowedTypes } from "../schemaTypes.js";
+import type { ImplicitFieldSchema } from "../schemaTypes.js";
 import type { SimpleTreeSchema } from "./simpleSchema.js";
 import { toSimpleTreeSchema } from "./viewSchemaToSimpleSchema.js";
 
@@ -64,6 +64,6 @@ const simpleSchemaCache = new WeakMap<TreeNodeSchema, SimpleTreeSchema>();
  * @privateRemarks In the future, we may wish to move this to a more discoverable API location.
  * For now, while still an experimental API, it is surfaced as a free function.
  */
-export function getSimpleSchema(schema: ImplicitAllowedTypes): SimpleTreeSchema {
+export function getSimpleSchema(schema: ImplicitFieldSchema): SimpleTreeSchema {
 	return getOrCreate(simpleSchemaCache, schema, () => toSimpleTreeSchema(schema));
 }

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

@@ -6,6 +6,7 @@
 export {
 	type ITree,
 	type TreeView,
+	type ViewableTree,
 	type TreeViewEvents,
 	TreeViewConfiguration,
 	type ITreeViewConfiguration,
@@ -44,6 +45,7 @@ export {
 } from "./jsonSchema.js";
 export { getJsonSchema } from "./getJsonSchema.js";
 export { getSimpleSchema } from "./getSimpleSchema.js";
+export { ViewSchema } from "./view.js";
 
 export { TreeBeta, type NodeChangedData, type TreeChangeEventsBeta } from "./treeApiBeta.js";
 

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

@@ -18,7 +18,7 @@ import {
 	isLazy,
 } from "../../feature-libraries/index.js";
 import {
-	type RestrictiveReadonlyRecord,
+	type RestrictiveStringRecord,
 	getOrCreate,
 	isReadonlyArray,
 } from "../../util/index.js";
@@ -48,6 +48,8 @@ import type {
 	WithType,
 	TreeNodeSchema,
 	TreeNodeSchemaClass,
+	TreeNodeSchemaNonClass,
+	TreeNodeSchemaBoth,
 } from "../core/index.js";
 import { type TreeArrayNode, arraySchema } from "../arrayNode.js";
 import {
@@ -291,7 +293,7 @@ export class SchemaFactory<
 	 */
 	public object<
 		const Name extends TName,
-		const T extends RestrictiveReadonlyRecord<string, ImplicitFieldSchema>,
+		const T extends RestrictiveStringRecord<ImplicitFieldSchema>,
 	>(
 		name: Name,
 		fields: T,
@@ -331,7 +333,7 @@ export class SchemaFactory<
 	 */
 	public map<const T extends TreeNodeSchema | readonly TreeNodeSchema[]>(
 		allowedTypes: T,
-	): TreeNodeSchema<
+	): TreeNodeSchemaNonClass<
 		ScopedSchemaName<TScope, `Map<${string}>`>,
 		NodeKind.Map,
 		TreeMapNode<T> & WithType<ScopedSchemaName<TScope, `Map<${string}>`>, NodeKind.Map>,
@@ -362,6 +364,12 @@ export class SchemaFactory<
 		T
 	>;
 
+	/**
+	 * @privateRemarks
+	 * This should return `TreeNodeSchemaBoth`, however TypeScript gives an error if one of the overloads implicitly up-casts the return type of the implementation.
+	 * 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>(
 		nameOrAllowedTypes: TName | ((T & TreeNodeSchema) | readonly TreeNodeSchema[]),
 		allowedTypes?: T,
@@ -379,7 +387,7 @@ export class SchemaFactory<
 						false,
 						true,
 					) as TreeNodeSchema,
-			) as TreeNodeSchemaClass<
+			) as TreeNodeSchemaBoth<
 				string,
 				NodeKind.Map,
 				TreeMapNode<T>,
@@ -388,7 +396,16 @@ export class SchemaFactory<
 				T
 			>;
 		}
-		return this.namedMap(nameOrAllowedTypes as TName, allowedTypes, true, true);
+		// To actually have type safety, assign to the type this method should return before implicitly upcasting when returning.
+		const out: TreeNodeSchemaBoth<
+			string,
+			NodeKind.Map,
+			TreeMapNode<T>,
+			MapNodeInsertableData<T>,
+			true,
+			T
+		> = this.namedMap(nameOrAllowedTypes as TName, allowedTypes, true, true);
+		return out;
 	}
 
 	/**
@@ -405,7 +422,7 @@ export class SchemaFactory<
 		allowedTypes: T,
 		customizable: boolean,
 		implicitlyConstructable: ImplicitlyConstructable,
-	): TreeNodeSchemaClass<
+	): TreeNodeSchemaBoth<
 		ScopedSchemaName<TScope, Name>,
 		NodeKind.Map,
 		TreeMapNode<T> & WithType<ScopedSchemaName<TScope, Name>, NodeKind.Map>,
@@ -457,7 +474,7 @@ export class SchemaFactory<
 	 */
 	public array<const T extends TreeNodeSchema | readonly TreeNodeSchema[]>(
 		allowedTypes: T,
-	): TreeNodeSchema<
+	): TreeNodeSchemaNonClass<
 		ScopedSchemaName<TScope, `Array<${string}>`>,
 		NodeKind.Array,
 		TreeArrayNode<T> & WithType<ScopedSchemaName<TScope, `Array<${string}>`>, NodeKind.Array>,
@@ -490,6 +507,10 @@ export class SchemaFactory<
 		T
 	>;
 
+	/**
+	 * @privateRemarks
+	 * This should return TreeNodeSchemaBoth: see note on "map" implementation for details.
+	 */
 	public array<const T extends ImplicitAllowedTypes>(
 		nameOrAllowedTypes: TName | ((T & TreeNodeSchema) | readonly TreeNodeSchema[]),
 		allowedTypes?: T,
@@ -515,7 +536,15 @@ export class SchemaFactory<
 				T
 			>;
 		}
-		return this.namedArray(nameOrAllowedTypes as TName, allowedTypes, true, true);
+		const out: TreeNodeSchemaBoth<
+			ScopedSchemaName<TScope, string>,
+			NodeKind.Array,
+			TreeArrayNode<T>,
+			Iterable<InsertableTreeNodeFromImplicitAllowedTypes<T>>,
+			true,
+			T
+		> = this.namedArray(nameOrAllowedTypes as TName, allowedTypes, true, true);
+		return out;
 	}
 
 	/**
@@ -536,7 +565,7 @@ export class SchemaFactory<
 		allowedTypes: T,
 		customizable: boolean,
 		implicitlyConstructable: ImplicitlyConstructable,
-	): TreeNodeSchemaClass<
+	): TreeNodeSchemaBoth<
 		ScopedSchemaName<TScope, Name>,
 		NodeKind.Array,
 		TreeArrayNode<T> & WithType<ScopedSchemaName<TScope, string>, NodeKind.Array>,
@@ -662,12 +691,12 @@ export class SchemaFactory<
 	// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
 	public objectRecursive<
 		const Name extends TName,
-		const T extends Unenforced<RestrictiveReadonlyRecord<string, ImplicitFieldSchema>>,
+		const T extends Unenforced<RestrictiveStringRecord<ImplicitFieldSchema>>,
 	>(name: Name, t: T) {
 		type TScopedName = ScopedSchemaName<TScope, Name>;
 		return this.object(
 			name,
-			t as T & RestrictiveReadonlyRecord<string, ImplicitFieldSchema>,
+			t as T & RestrictiveStringRecord<ImplicitFieldSchema>,
 		) as unknown as TreeNodeSchemaClass<
 			TScopedName,
 			NodeKind.Object,
@@ -760,7 +789,7 @@ export class SchemaFactory<
 				>;
 			},
 			// Ideally this would be included, but doing so breaks recursive types.
-			// | RestrictiveReadonlyRecord<string, InsertableTreeNodeFromImplicitAllowedTypesUnsafe<T>>,
+			// | RestrictiveStringRecord<InsertableTreeNodeFromImplicitAllowedTypesUnsafe<T>>,
 			false,
 			T
 		>;

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

@@ -4,7 +4,7 @@
  */
 
 import type { Unenforced } from "../../feature-libraries/index.js";
-import type { RestrictiveReadonlyRecord } from "../../util/index.js";
+import type { RestrictiveStringRecord } from "../../util/index.js";
 import type { InsertableObjectFromSchemaRecord } from "../objectNode.js";
 
 import {
@@ -131,10 +131,7 @@ export type ValidateRecursiveSchema<
 		// TInsertable: What can be passed to the constructor. This should be enough to catch most issues with incorrect schema.
 		// These match whats defined in the recursive methods on `SchemaFactory` except they do not use `Unenforced`.
 		{
-			[NodeKind.Object]: T["info"] extends RestrictiveReadonlyRecord<
-				string,
-				ImplicitFieldSchema
-			>
+			[NodeKind.Object]: T["info"] extends RestrictiveStringRecord<ImplicitFieldSchema>
 				? InsertableObjectFromSchemaRecord<T["info"]>
 				: unknown;
 			[NodeKind.Array]: T["info"] extends ImplicitAllowedTypes
@@ -148,7 +145,7 @@ export type ValidateRecursiveSchema<
 		false,
 		// Info: What's passed to the method to create the schema. Constraining these here should be about as effective as if the actual constraints existed on the actual method itself.
 		{
-			[NodeKind.Object]: RestrictiveReadonlyRecord<string, ImplicitFieldSchema>;
+			[NodeKind.Object]: RestrictiveStringRecord<ImplicitFieldSchema>;
 			[NodeKind.Array]: ImplicitAllowedTypes;
 			[NodeKind.Map]: ImplicitAllowedTypes;
 		}[T["kind"]]

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

@@ -99,7 +99,7 @@ export type SimpleNodeSchema =
  */
 export interface SimpleFieldSchema {
 	/**
-	 * The kind of object field.
+	 * The kind of tree field.
 	 */
 	readonly kind: FieldKind;
 
@@ -120,24 +120,29 @@ export interface SimpleFieldSchema {
 /**
  * A simplified representation of a schema for a tree.
  *
- * @remarks Contains the complete set of schema {@link SimpleTreeSchema.definitions} required to resolve references
- * by schema identifier.
+ * @remarks Contains the complete set of schema {@link SimpleTreeSchema.definitions} required to resolve references,
+ * which are represented inline with identifiers.
  *
  * @sealed
  */
-export interface SimpleTreeSchema {
+export interface SimpleTreeSchema extends SimpleFieldSchema {
 	/**
-	 * The complete set of node schema definitions recursively referenced by the tree's {@link SimpleTreeSchema.allowedTypes}.
-	 *
-	 * @remarks the keys are the schemas' {@link TreeNodeSchemaCore.identifier | identifiers}.
+	 * The kind of tree field representing the root of the tree.
 	 */
-	readonly definitions: ReadonlyMap<string, SimpleNodeSchema>;
+	readonly kind: FieldKind;
 
 	/**
-	 * The types allowed under the root of the tree.
+	 * The types allowed under the tree root.
 	 *
 	 * @remarks Refers to the types by identifier.
-	 * {@link SimpleTreeSchema.definitions} can be used to resolve these identifiers to their associated schema definition.
+	 * Can be resolved via {@link SimpleTreeSchema.definitions}.
 	 */
 	readonly allowedTypes: ReadonlySet<string>;
+
+	/**
+	 * The complete set of node schema definitions recursively referenced by the tree's {@link SimpleTreeSchema.allowedTypes}.
+	 *
+	 * @remarks the keys are the schemas' {@link TreeNodeSchemaCore.identifier | identifiers}.
+	 */
+	readonly definitions: ReadonlyMap<string, SimpleNodeSchema>;
 }

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

@@ -16,21 +16,19 @@ import {
 	FieldKind,
 } from "../schemaTypes.js";
 import { NodeKind, type TreeNodeSchema } from "../core/index.js";
-import { toFlexSchema } from "../toFlexSchema.js";
+import { toStoredSchema } from "../toFlexSchema.js";
 import { LeafNodeSchema } from "../leafNodeSchema.js";
 import { assert } from "@fluidframework/core-utils/internal";
 import { isObjectNodeSchema, type ObjectNodeSchema } from "../objectNodeTypes.js";
 import { markSchemaMostDerived } from "./schemaFactory.js";
 import { fail, getOrCreate } from "../../util/index.js";
 import type { MakeNominal } from "../../util/index.js";
-import { walkFieldSchema } from "../walkSchema.js";
+import { walkFieldSchema } from "../walkFieldSchema.js";
 /**
- * Channel for a Fluid Tree DDS.
- * @remarks
- * Allows storing and collaboratively editing schema-aware hierarchial data.
- * @sealed @public
+ * A tree from which a {@link TreeView} can be created.
+ * @system @sealed @public
  */
-export interface ITree extends IFluidLoadable {
+export interface ViewableTree {
 	/**
 	 * Returns a {@link TreeView} using the provided schema.
 	 * If the stored schema is compatible with the view schema specified by `config`,
@@ -68,6 +66,14 @@ export interface ITree extends IFluidLoadable {
 	): TreeView<TRoot>;
 }
 
+/**
+ * Channel for a Fluid Tree DDS.
+ * @remarks
+ * Allows storing and collaboratively editing schema-aware hierarchial data.
+ * @sealed @public
+ */
+export interface ITree extends ViewableTree, IFluidLoadable {}
+
 /**
  * Options when constructing a tree view.
  * @public
@@ -181,7 +187,7 @@ export interface ITreeViewConfiguration<
 }
 
 /**
- * Configuration for {@link ITree.viewWith}.
+ * Configuration for {@link ViewableTree.viewWith}.
  * @sealed @public
  */
 export class TreeViewConfiguration<TSchema extends ImplicitFieldSchema = ImplicitFieldSchema>
@@ -236,7 +242,7 @@ export class TreeViewConfiguration<TSchema extends ImplicitFieldSchema = Implici
 		}
 
 		// Eagerly perform this conversion to surface errors sooner.
-		toFlexSchema(config.schema);
+		toStoredSchema(config.schema);
 	}
 }
 

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

@@ -11,13 +11,9 @@ import {
 	type TreeStatus,
 	isLazy,
 	isTreeValue,
-	FlexObjectNodeSchema,
-	isMapTreeNode,
 	FieldKinds,
 } from "../../feature-libraries/index.js";
 import { fail, extractFromOpaque, isReadonlyArray } from "../../util/index.js";
-
-import { getOrCreateNodeFromFlexTreeNode } from "../proxies.js";
 import { getOrCreateInnerNode } from "../proxyBinding.js";
 import {
 	type TreeLeafValue,
@@ -44,6 +40,9 @@ import {
 	type TreeNode,
 	type TreeChangeEvents,
 	tryGetTreeNodeSchema,
+	getOrCreateNodeFromInnerNode,
+	UnhydratedFlexTreeNode,
+	typeSchemaSymbol,
 } from "../core/index.js";
 import { isObjectNodeSchema } from "../objectNodeTypes.js";
 
@@ -141,7 +140,7 @@ export const treeNodeApi: TreeNodeApi = {
 			return undefined;
 		}
 
-		const output = getOrCreateNodeFromFlexTreeNode(editNode);
+		const output = getOrCreateNodeFromInnerNode(editNode);
 		assert(
 			!isTreeValue(output),
 			0x87f /* Parent can't be a leaf, so it should be a node not a value */,
@@ -231,17 +230,20 @@ export const treeNodeApi: TreeNodeApi = {
 		return tryGetSchema(node) ?? fail("Not a tree node");
 	},
 	shortId(node: TreeNode): number | string | undefined {
+		const schema = node[typeSchemaSymbol];
+		if (!isObjectNodeSchema(schema)) {
+			return undefined;
+		}
+
 		const flexNode = getOrCreateInnerNode(node);
-		const flexSchema = flexNode.flexSchema;
-		const identifierFieldKeys =
-			flexSchema instanceof FlexObjectNodeSchema ? flexSchema.identifierFieldKeys : [];
+		const identifierFieldKeys = schema.identifierFieldKeys;
 
 		switch (identifierFieldKeys.length) {
 			case 0:
 				return undefined;
 			case 1: {
 				const identifier = flexNode.tryGetField(identifierFieldKeys[0] ?? oob())?.boxedAt(0);
-				if (isMapTreeNode(flexNode)) {
+				if (flexNode instanceof UnhydratedFlexTreeNode) {
 					if (identifier === undefined) {
 						throw new UsageError(
 							"Tree.shortId cannot access default identifiers on unhydrated nodes",
@@ -303,7 +305,7 @@ function getStoredKey(node: TreeNode): string | number {
 	// Note: the flex domain strictly works with "stored keys", and knows nothing about the developer-facing
 	// "property keys".
 	const parentField = getOrCreateInnerNode(node).parentField;
-	if (parentField.parent.schema.kind === FieldKinds.sequence.identifier) {
+	if (parentField.parent.schema === FieldKinds.sequence.identifier) {
 		// The parent of `node` is an array node
 		assert(
 			parentField.parent.key === EmptyKey,

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

@@ -25,7 +25,7 @@ import type {
 	ImplicitFieldSchema,
 	ImplicitAllowedTypes,
 } from "../schemaTypes.js";
-import { getSimpleNodeSchema, NodeKind, type TreeNodeSchema } from "../core/index.js";
+import { NodeKind, type TreeNodeSchema } from "../core/index.js";
 import {
 	isTreeValue,
 	stackTreeFieldCursor,
@@ -39,9 +39,9 @@ import {
 	numberSchema,
 	stringSchema,
 } from "../leafNodeSchema.js";
-import { toFlexSchema } from "../toFlexSchema.js";
 import { isObjectNodeSchema } from "../objectNodeTypes.js";
-import { walkFieldSchema } from "../walkSchema.js";
+import { walkFieldSchema } from "../walkFieldSchema.js";
+import { getUnhydratedContext } from "../createContext.js";
 
 /**
  * Verbose encoding of a {@link TreeNode} or {@link TreeValue}.
@@ -174,9 +174,7 @@ export function applySchemaToParserOptions<TCustom>(
 		...options,
 	};
 
-	// TODO: should provide a way to look up schema by name efficiently without converting to flex tree schema and back.
-	// Maybe cache identifier->schema map on simple tree schema lazily.
-	const flexSchema = toFlexSchema(schema);
+	const context = getUnhydratedContext(schema);
 
 	return {
 		valueConverter: config.valueConverter,
@@ -185,9 +183,7 @@ export function applySchemaToParserOptions<TCustom>(
 			: {
 					encode: (type, key: FieldKey): string => {
 						// translate stored key into property key.
-						const flexNodeSchema =
-							flexSchema.nodeSchema.get(brand(type)) ?? fail("missing schema");
-						const simpleNodeSchema = getSimpleNodeSchema(flexNodeSchema);
+						const simpleNodeSchema = context.schema.get(brand(type)) ?? fail("missing schema");
 						if (isObjectNodeSchema(simpleNodeSchema)) {
 							const propertyKey = simpleNodeSchema.storedKeyToPropertyKey.get(key);
 							if (propertyKey !== undefined) {
@@ -208,9 +204,7 @@ export function applySchemaToParserOptions<TCustom>(
 						return key;
 					},
 					parse: (type, inputKey): FieldKey => {
-						const flexNodeSchema =
-							flexSchema.nodeSchema.get(brand(type)) ?? fail("missing schema");
-						const simpleNodeSchema = getSimpleNodeSchema(flexNodeSchema);
+						const simpleNodeSchema = context.schema.get(brand(type)) ?? fail("missing schema");
 						if (isObjectNodeSchema(simpleNodeSchema)) {
 							const info =
 								simpleNodeSchema.flexKeyMap.get(inputKey) ?? fail("missing field info");

package/src/{feature-libraries/typed-schema → simple-tree/api}/view.ts

@@ -12,24 +12,24 @@ import {
 	type TreeNodeStoredSchema,
 	type TreeStoredSchema,
 } from "../../core/index.js";
-import { type Named, fail } from "../../util/index.js";
+import { fail } from "../../util/index.js";
 import {
 	type FullSchemaPolicy,
 	allowsRepoSuperset,
 	isNeverTree,
-} from "../modular-schema/index.js";
+} from "../../feature-libraries/index.js";
 
 /**
  * A collection of View information for schema, including policy.
  */
 export class ViewSchema {
 	/**
-	 * @param storedSchema - Cached conversion of view schema into a stored schema.
+	 * @param schema - Cached conversion of view schema in the stored schema format.
 	 */
 	public constructor(
 		public readonly policy: FullSchemaPolicy,
 		public readonly adapters: Adapters,
-		public readonly storedSchema: TreeStoredSchema,
+		public readonly schema: TreeStoredSchema,
 	) {}
 
 	/**
@@ -50,7 +50,7 @@ export class ViewSchema {
 		// TODO: support adapters
 		// const adapted = this.adaptRepo(stored);
 
-		const read = allowsRepoSuperset(this.policy, stored, this.storedSchema)
+		const read = allowsRepoSuperset(this.policy, stored, this.schema)
 			? Compatibility.Compatible
 			: // TODO: support adapters
 				// : allowsRepoSuperset(this.policy, adapted.adaptedForViewSchema, this.storedSchema)
@@ -58,7 +58,7 @@ export class ViewSchema {
 				Compatibility.Incompatible;
 		// TODO: Extract subset of adapters that are valid to use on stored
 		// TODO: separate adapters from schema updates
-		const write = allowsRepoSuperset(this.policy, this.storedSchema, stored)
+		const write = allowsRepoSuperset(this.policy, this.schema, stored)
 			? Compatibility.Compatible
 			: // TODO: support adapters
 				// : allowsRepoSuperset(this.policy, this.storedSchema, adapted.adaptedForViewSchema)
@@ -74,7 +74,7 @@ export class ViewSchema {
 		let writeAllowingStoredSchemaUpdates =
 			// TODO: This should consider just the updates needed
 			// (ex: when view covers a subset of stored after stored has a update to that subset).
-			allowsRepoSuperset(this.policy, stored, this.storedSchema)
+			allowsRepoSuperset(this.policy, stored, this.schema)
 				? Compatibility.Compatible
 				: // TODO: this assumes adapters can translate in both directions. In general this will not be true.
 					// TODO: this also assumes that schema updates to the adapted repo would translate to
@@ -98,18 +98,12 @@ export class ViewSchema {
 	 */
 	public adaptRepo(stored: TreeStoredSchema): AdaptedViewSchema {
 		// Sanity check on adapters:
-		// it's probably a bug it they use the never types,
+		// it's probably a bug if they use the never types,
 		// since there never is a reason to have a never type as an adapter input,
 		// and its impossible for an adapter to be correctly implemented if its output type is never
 		// (unless its input is also never).
 		for (const adapter of this.adapters?.tree ?? []) {
-			if (
-				isNeverTree(
-					this.policy,
-					this.storedSchema,
-					this.storedSchema.nodeSchema.get(adapter.output),
-				)
-			) {
+			if (isNeverTree(this.policy, this.schema, this.schema.nodeSchema.get(adapter.output))) {
 				fail("tree adapter for stored adapter.output should not be never");
 			}
 		}
@@ -151,10 +145,3 @@ export class ViewSchema {
 		return original;
 	}
 }
-
-/**
- * Record where a schema came from for error reporting purposes.
- */
-export interface Sourced {
-	readonly builder: Named<string>;
-}