@fluidframework/tree 2.2.0 → 2.3.0

package/src/simple-tree/toMapTree.ts

@@ -25,7 +25,6 @@ import {
 import { brand, fail, isReadonlyArray, find } from "../util/index.js";
 
 import { nullSchema } from "./leafNodeSchema.js";
-import type { InsertableContent } from "./proxies.js";
 import {
 	type FieldSchema,
 	type ImplicitAllowedTypes,
@@ -38,10 +37,19 @@ import {
 	FieldKind,
 	type TreeLeafValue,
 } from "./schemaTypes.js";
-import { NodeKind, tryGetSimpleNodeSchema, type TreeNodeSchema } from "./core/index.js";
+import {
+	getKernel,
+	getSimpleNodeSchemaFromNode,
+	isTreeNode,
+	NodeKind,
+	type InnerNode,
+	type TreeNode,
+	type TreeNodeSchema,
+	type Unhydrated,
+} from "./core/index.js";
 import { SchemaValidationErrors, isNodeInSchema } from "../feature-libraries/index.js";
-import { tryGetInnerNode } from "./proxyBinding.js";
 import { isObjectNodeSchema } from "./objectNodeTypes.js";
+import type { IFluidHandle } from "@fluidframework/core-interfaces";
 
 /**
  * Module notes:
@@ -125,11 +133,14 @@ export function mapTreeFromNodeData(
 	// Add what defaults can be provided. If no `context` is providing, some defaults may still be missing.
 	addDefaultsToMapTree(mapTree, normalizedFieldSchema.allowedTypes, context);
 
-	// TODO:
-	// Since some defaults may still be missing, this can give false positives when context is undefined but schemaValidationPolicy is provided.
 	if (schemaValidationPolicy?.policy.validateSchema === true) {
-		const maybeError = isNodeInSchema(mapTree, schemaValidationPolicy);
-		inSchemaOrThrow(maybeError);
+		// TODO: BUG: AB#9131
+		// Since some defaults may still be missing, this can give false positives when context is undefined but schemaValidationPolicy is provided.
+		// For now disable this check when context is undefined:
+		if (context !== undefined) {
+			const maybeError = isNodeInSchema(mapTree, schemaValidationPolicy);
+			inSchemaOrThrow(maybeError);
+		}
 	}
 
 	return mapTree;
@@ -148,12 +159,10 @@ function nodeDataToMapTree(
 ): ExclusiveMapTree {
 	// A special cache path for processing unhydrated nodes.
 	// They already have the mapTree, so there is no need to recompute it.
-	const flexNode = tryGetInnerNode(data);
-	if (flexNode !== undefined) {
-		if (isMapTreeNode(flexNode)) {
-			if (
-				!allowedTypes.has(tryGetSimpleNodeSchema(flexNode.schema) ?? fail("missing schema"))
-			) {
+	const innerNode = tryGetInnerNode(data);
+	if (innerNode !== undefined) {
+		if (isMapTreeNode(innerNode)) {
+			if (!allowedTypes.has(getSimpleNodeSchemaFromNode(innerNode))) {
 				throw new UsageError("Invalid schema for this context.");
 			}
 			// TODO: mapTreeFromNodeData modifies the trees it gets to add defaults.
@@ -161,13 +170,15 @@ function nodeDataToMapTree(
 			// This is unnecessary and inefficient, but should be a no-op if all calls provide the same context (which they might not).
 			// A cleaner design (avoiding this cast) might be to apply defaults eagerly if they don't need a context, and lazily (when hydrating) if they do.
 			// This could avoid having to mutate the map tree to apply defaults, removing the need for this cast.
-			return flexNode.mapTree as ExclusiveMapTree;
+			return innerNode.mapTree as ExclusiveMapTree;
 		} else {
 			// The node is already hydrated, meaning that it already got inserted into the tree previously
 			throw new UsageError("A node may not be inserted into the tree more than once");
 		}
 	}
 
+	assert(!isTreeNode(data), 0xa23 /* data without an inner node cannot be TreeNode */);
+
 	const schema = getType(data, allowedTypes);
 
 	let result: ExclusiveMapTree;
@@ -208,7 +219,7 @@ export function inSchemaOrThrow(maybeError: SchemaValidationErrors): void {
  * Used to determine which fallback values may be appropriate.
  */
 function leafToMapTree(
-	data: InsertableContent,
+	data: FactoryContent,
 	schema: TreeNodeSchema,
 	allowedTypes: ReadonlySet<TreeNodeSchema>,
 ): ExclusiveMapTree {
@@ -310,7 +321,7 @@ function arrayChildToMapTree(
  * validation should happen. If it does, the input tree will be validated against this schema + policy, and an error will
  * be thrown if the tree does not conform to the schema. If undefined, no validation against the stored schema is done.
  */
-function arrayToMapTree(data: InsertableContent, schema: TreeNodeSchema): ExclusiveMapTree {
+function arrayToMapTree(data: FactoryContent, schema: TreeNodeSchema): ExclusiveMapTree {
 	assert(schema.kind === NodeKind.Array, 0x922 /* Expected an array schema. */);
 	if (!(typeof data === "object" && data !== null && Symbol.iterator in data)) {
 		throw new UsageError(`Input data is incompatible with Array schema: ${data}`);
@@ -339,7 +350,7 @@ function arrayToMapTree(data: InsertableContent, schema: TreeNodeSchema): Exclus
  * validation should happen. If it does, the input tree will be validated against this schema + policy, and an error will
  * be thrown if the tree does not conform to the schema. If undefined, no validation against the stored schema is done.
  */
-function mapToMapTree(data: InsertableContent, schema: TreeNodeSchema): ExclusiveMapTree {
+function mapToMapTree(data: FactoryContent, schema: TreeNodeSchema): ExclusiveMapTree {
 	assert(schema.kind === NodeKind.Map, 0x923 /* Expected a Map schema. */);
 	if (!(typeof data === "object" && data !== null)) {
 		throw new UsageError(`Input data is incompatible with Map schema: ${data}`);
@@ -381,9 +392,14 @@ function mapToMapTree(data: InsertableContent, schema: TreeNodeSchema): Exclusiv
  * @param data - The tree data to be transformed. Must be a Record-like object.
  * @param schema - The schema associated with the value.
  */
-function objectToMapTree(data: InsertableContent, schema: TreeNodeSchema): ExclusiveMapTree {
+function objectToMapTree(data: FactoryContent, schema: TreeNodeSchema): ExclusiveMapTree {
 	assert(isObjectNodeSchema(schema), 0x924 /* Expected an Object schema. */);
-	if (typeof data !== "object" || data === null) {
+	if (
+		typeof data !== "object" ||
+		data === null ||
+		Symbol.iterator in data ||
+		isFluidHandle(data)
+	) {
 		throw new UsageError(`Input data is incompatible with Object schema: ${data}`);
 	}
 
@@ -392,7 +408,7 @@ function objectToMapTree(data: InsertableContent, schema: TreeNodeSchema): Exclu
 	// Loop through field keys without data.
 	// This does NOT apply defaults.
 	for (const [key, fieldInfo] of schema.flexKeyMap) {
-		if (Object.hasOwnProperty.call(data, key)) {
+		if (checkFieldProperty(data, key)) {
 			const value = (data as Record<string, InsertableContent>)[key as string];
 			setFieldValue(fields, value, fieldInfo.schema, fieldInfo.storedKey);
 		}
@@ -404,6 +420,24 @@ function objectToMapTree(data: InsertableContent, schema: TreeNodeSchema): Exclu
 	};
 }
 
+/**
+ * Check {@link FactoryContentObject} for a property which could be store a field.
+ * @remarks
+ * The currently policy is to only consider own properties.
+ * See {@link InsertableObjectFromSchemaRecord} for where this policy is documented in the public API.
+ *
+ * Explicit undefined members are considered to exist, as long as they are own properties.
+ */
+function checkFieldProperty(
+	data: FactoryContentObject,
+	key: string | symbol,
+): data is {
+	readonly [P in string]: InsertableContent | undefined;
+} {
+	// This policy only allows own properties.
+	return Object.hasOwnProperty.call(data, key);
+}
+
 function setFieldValue(
 	fields: Map<FieldKey, readonly MapTree[]>,
 	fieldValue: InsertableContent | undefined,
@@ -419,10 +453,10 @@ function setFieldValue(
 }
 
 function getType(
-	data: InsertableContent,
+	data: FactoryContent,
 	allowedTypes: ReadonlySet<TreeNodeSchema>,
 ): TreeNodeSchema {
-	const possibleTypes = getPossibleTypes(allowedTypes, data as ContextuallyTypedNodeData);
+	const possibleTypes = getPossibleTypes(allowedTypes, data);
 	if (possibleTypes.length === 0) {
 		throw new UsageError(
 			`The provided data is incompatible with all of the types allowed by the schema. The set of allowed types is: ${JSON.stringify(
@@ -452,7 +486,7 @@ For class-based schema, this can be done by replacing an expression like "{foo:
  */
 export function getPossibleTypes(
 	allowedTypes: ReadonlySet<TreeNodeSchema>,
-	data: ContextuallyTypedNodeData,
+	data: FactoryContent,
 ): TreeNodeSchema[] {
 	let best = CompatibilityLevel.None;
 	const possibleTypes: TreeNodeSchema[] = [];
@@ -500,12 +534,9 @@ enum CompatibilityLevel {
  */
 function shallowCompatibilityTest(
 	schema: TreeNodeSchema,
-	data: ContextuallyTypedNodeData,
+	data: FactoryContent,
 ): CompatibilityLevel {
-	assert(
-		data !== undefined,
-		0x889 /* undefined cannot be used as contextually typed data. Use ContextuallyTypedFieldData. */,
-	);
+	assert(data !== undefined, 0x889 /* undefined cannot be used as FactoryContent. */);
 
 	if (isTreeValue(data)) {
 		return allowsValue(schema, data) ? CompatibilityLevel.Normal : CompatibilityLevel.None;
@@ -574,8 +605,14 @@ function shallowCompatibilityTest(
 
 	// If the schema has a required key which is not present in the input object, reject it.
 	for (const [fieldKey, fieldSchema] of schema.fields) {
-		if (data[fieldKey] === undefined && fieldSchema.requiresValue) {
-			return CompatibilityLevel.None;
+		if (fieldSchema.requiresValue) {
+			if (checkFieldProperty(data, fieldKey)) {
+				if (data[fieldKey] === undefined) {
+					return CompatibilityLevel.None;
+				}
+			} else {
+				return CompatibilityLevel.None;
+			}
 		}
 	}
 
@@ -589,54 +626,6 @@ function allowsValue(schema: TreeNodeSchema, value: TreeValue): boolean {
 	return false;
 }
 
-/**
- * Content of a tree which needs external schema information to interpret.
- *
- * This format is intended for concise authoring of tree literals when the schema is statically known.
- *
- * Once schema aware APIs are implemented, they can be used to provide schema specific subsets of this type.
- */
-export type ContextuallyTypedNodeData =
-	| ContextuallyTypedNodeDataObject
-	| number
-	| string
-	| boolean
-	// eslint-disable-next-line @rushstack/no-new-null
-	| null
-	| readonly ContextuallyTypedNodeData[]
-	| ReadonlyMap<string, ContextuallyTypedNodeData>
-	| Iterable<ContextuallyTypedNodeData>
-	| Iterable<[string, ContextuallyTypedNodeData]>;
-
-/**
- * Content of a field which needs external schema information to interpret.
- *
- * This format is intended for concise authoring of tree literals when the schema is statically known.
- *
- * Once schema aware APIs are implemented, they can be used to provide schema specific subsets of this type.
- */
-export type ContextuallyTypedFieldData = ContextuallyTypedNodeData | undefined;
-
-/**
- * Object case of {@link ContextuallyTypedNodeData}.
- */
-export interface ContextuallyTypedNodeDataObject {
-	/**
-	 * Fields of this node, indexed by their field keys.
-	 *
-	 * Allow explicit undefined for compatibility with FlexTree, and type-safety on read.
-	 */
-	// TODO: make sure explicit undefined is actually handled correctly.
-	[key: FieldKey]: ContextuallyTypedFieldData;
-
-	/**
-	 * Fields of this node, indexed by their field keys as strings.
-	 *
-	 * Allow unbranded field keys as a convenience for literals.
-	 */
-	[key: string]: ContextuallyTypedFieldData;
-}
-
 /**
  * Walk the given {@link ExclusiveMapTree} and deeply provide any field defaults for fields that are missing in the tree but present in the schema.
  * @param mapTree - The tree to populate with defaults. This is borrowed: no references to it are kept by this function.
@@ -714,8 +703,53 @@ function provideDefault(
 		if (isConstant(fieldProvider)) {
 			return fieldProvider();
 		} else {
-			// Leaving field empty despite it needing a default value since a context was required and non was provided.
+			// Leaving field empty despite it needing a default value since a context was required and none was provided.
 			// Caller better handle this case by providing the default at some other point in time when the context becomes known.
 		}
 	}
 }
+
+/**
+ * Retrieves the InnerNode associated with the given target via {@link setInnerNode}, if any.
+ * @remarks
+ * If `target` is a unhydrated node, returns its MapTreeNode.
+ * If `target` is a cooked node (or marinated but a FlexTreeNode exists) returns the FlexTreeNode.
+ * If the target is not a node, or a marinated node with no FlexTreeNode for its anchor, returns undefined.
+ */
+function tryGetInnerNode(target: unknown): InnerNode | undefined {
+	if (isTreeNode(target)) {
+		return getKernel(target).tryGetInnerNode();
+	}
+}
+
+/**
+ * Content which can be used to build a node.
+ * @remarks
+ * Can contain unhydrated nodes, but can not be an unhydrated node at the root.
+ */
+export type FactoryContent =
+	| IFluidHandle
+	| string
+	| number
+	| boolean
+	// eslint-disable-next-line @rushstack/no-new-null
+	| null
+	| Iterable<readonly [string, InsertableContent]>
+	| readonly InsertableContent[]
+	| FactoryContentObject;
+
+/**
+ * Record-like object which can be used to build some kinds of nodes.
+ * @remarks
+ * Can contain unhydrated nodes, but can not be an unhydrated node at the root.
+ *
+ * Supports object and map nodes.
+ */
+type FactoryContentObject = {
+	readonly [P in string]?: InsertableContent;
+};
+
+/**
+ * Content which can be inserted into a tree.
+ */
+export type InsertableContent = Unhydrated<TreeNode> | FactoryContent;

package/src/simple-tree/treeNodeValid.ts

@@ -7,7 +7,6 @@ import { assert } from "@fluidframework/core-utils/internal";
 
 import {
 	type TreeNodeSchema,
-	type TreeNodeSchemaClass,
 	NodeKind,
 	tryGetSimpleNodeSchema,
 	isTreeNode,
@@ -15,6 +14,8 @@ import {
 	privateToken,
 	TreeNode,
 	type InternalTreeNode,
+	typeSchemaSymbol,
+	type InnerNode,
 } from "./core/index.js";
 import {
 	type FlexTreeNode,
@@ -26,7 +27,6 @@ import { UsageError } from "@fluidframework/telemetry-utils/internal";
 import { fail } from "../util/index.js";
 
 import { getFlexSchema } from "./toFlexSchema.js";
-import { getOrCreateInnerNode, setInnerNode } from "./proxyBinding.js";
 
 /**
  * Class which all {@link TreeNode}s must extend.
@@ -150,17 +150,18 @@ export abstract class TreeNodeValid<TInput> extends TreeNode {
 			);
 		}
 
-		const node: FlexTreeNode = isFlexTreeNode(input)
-			? input
-			: schema.buildRawNode(this, input);
+		const node: InnerNode = isFlexTreeNode(input) ? input : schema.buildRawNode(this, input);
 		assert(
-			tryGetSimpleNodeSchema(node.schema) === schema,
+			tryGetSimpleNodeSchema(node.flexSchema) === schema,
 			0x83b /* building node with wrong schema */,
 		);
 
 		const result = schema.prepareInstance(this, node);
-		new TreeNodeKernel(result, schema);
-		setInnerNode(result, node);
+		// The TreeNodeKernel associates itself the TreeNode (result here, not node) so it can be looked up later via getKernel.
+		// If desired this could be put in a non-enumerable symbol property for lookup instead, but that gets messy going through proxies,
+		// so just relying on the WeakMap seems like the cleanest approach.
+		new TreeNodeKernel(result, schema, node);
+
 		return result;
 	}
 }
@@ -203,11 +204,7 @@ function inspectNodeFunction(
 	options?: unknown,
 	inspect?: unknown,
 ): unknown {
-	// TODO: replicated from tryGetSchema to avoid cycle.
-	// This case could be optimized, for example by placing the simple schema in a symbol on tree nodes.
-	const schema = tryGetSimpleNodeSchema(
-		getOrCreateInnerNode(this).schema,
-	) as TreeNodeSchemaClass;
+	const schema = this[typeSchemaSymbol];
 	const title = `${schema.name}: ${NodeKind[schema.kind]} Node (${schema.identifier})`;
 
 	if (depth < 2) {

package/src/simple-tree/typesUnsafe.ts

@@ -41,7 +41,7 @@ import type { TreeArrayNodeBase, TreeArrayNode } from "./arrayNode.js";
  * {@link Unenforced} version of `ObjectFromSchemaRecord`.
  * @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.
- * @public
+ * @system @public
  */
 export type ObjectFromSchemaRecordUnsafe<
 	T extends Unenforced<RestrictiveReadonlyRecord<string, ImplicitFieldSchema>>,
@@ -53,7 +53,7 @@ export type ObjectFromSchemaRecordUnsafe<
  * {@link Unenforced} version of {@link TreeObjectNode}.
  * @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.
- * @public
+ * @system @public
  */
 export type TreeObjectNodeUnsafe<
 	T extends Unenforced<RestrictiveReadonlyRecord<string, ImplicitFieldSchema>>,
@@ -64,7 +64,7 @@ export type TreeObjectNodeUnsafe<
  * {@link Unenforced} version of {@link TreeFieldFromImplicitField}.
  * @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.
- * @public
+ * @system @public
  */
 export type TreeFieldFromImplicitFieldUnsafe<TSchema extends Unenforced<ImplicitFieldSchema>> =
 	TSchema extends FieldSchemaUnsafe<infer Kind, infer Types>
@@ -77,7 +77,7 @@ export type TreeFieldFromImplicitFieldUnsafe<TSchema extends Unenforced<Implicit
  * {@link Unenforced} version of {@link TreeNodeFromImplicitAllowedTypes}.
  * @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.
- * @public
+ * @system @public
  */
 export type TreeNodeFromImplicitAllowedTypesUnsafe<
 	TSchema extends Unenforced<ImplicitAllowedTypes>,
@@ -93,7 +93,7 @@ export type TreeNodeFromImplicitAllowedTypesUnsafe<
  * {@link Unenforced} version of {@link InsertableTreeNodeFromImplicitAllowedTypes}.
  * @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.
- * @public
+ * @system @public
  */
 export type InsertableTreeNodeFromImplicitAllowedTypesUnsafe<
 	TSchema extends Unenforced<ImplicitAllowedTypes>,
@@ -105,7 +105,7 @@ export type InsertableTreeNodeFromImplicitAllowedTypesUnsafe<
  * {@link Unenforced} version of {@link InsertableTypedNode}.
  * @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.
- * @public
+ * @system @public
  */
 export type InsertableTypedNodeUnsafe<T extends Unenforced<TreeNodeSchema>> = [
 	| Unhydrated<NodeFromSchemaUnsafe<T>>
@@ -116,7 +116,7 @@ export type InsertableTypedNodeUnsafe<T extends Unenforced<TreeNodeSchema>> = [
  * {@link Unenforced} version of {@link NodeFromSchema}.
  * @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.
- * @public
+ * @system @public
  */
 export type NodeFromSchemaUnsafe<T extends Unenforced<TreeNodeSchema>> =
 	T extends TreeNodeSchema<string, NodeKind, infer TNode> ? TNode : never;
@@ -125,7 +125,7 @@ export type NodeFromSchemaUnsafe<T extends Unenforced<TreeNodeSchema>> =
  * {@link Unenforced} version of {@link InsertableTreeNodeFromImplicitAllowedTypes}.
  * @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.
- * @public
+ * @system @public
  */
 export type NodeBuilderDataUnsafe<T extends Unenforced<TreeNodeSchema>> =
 	T extends TreeNodeSchema<string, NodeKind, unknown, infer TBuild> ? TBuild : never;
@@ -134,7 +134,7 @@ export type NodeBuilderDataUnsafe<T extends Unenforced<TreeNodeSchema>> =
  * {@link Unenforced} version of {@link (TreeArrayNode:interface)}.
  * @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.
- * @sealed @public
+ * @system @sealed @public
  */
 export interface TreeArrayNodeUnsafe<TAllowedTypes extends Unenforced<ImplicitAllowedTypes>>
 	extends TreeArrayNodeBase<
@@ -147,7 +147,7 @@ export interface TreeArrayNodeUnsafe<TAllowedTypes extends Unenforced<ImplicitAl
  * {@link Unenforced} version of {@link TreeMapNode}.
  * @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.
- * @sealed @public
+ * @system @sealed @public
  */
 export interface TreeMapNodeUnsafe<T extends Unenforced<ImplicitAllowedTypes>>
 	extends ReadonlyMapInlined<string, T>,
@@ -213,7 +213,7 @@ export interface ReadonlyMapInlined<K, T extends Unenforced<ImplicitAllowedTypes
  * {@link Unenforced} version of `FieldHasDefault`.
  * @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.
- * @sealed @public
+ * @system @sealed @public
  */
 export type FieldHasDefaultUnsafe<T extends Unenforced<ImplicitFieldSchema>> =
 	T extends FieldSchemaUnsafe<
@@ -227,7 +227,7 @@ export type FieldHasDefaultUnsafe<T extends Unenforced<ImplicitFieldSchema>> =
  * {@link Unenforced} version of `InsertableObjectFromSchemaRecord`.
  * @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.
- * @public
+ * @system @public
  */
 export type InsertableObjectFromSchemaRecordUnsafe<
 	T extends Unenforced<RestrictiveReadonlyRecord<string, ImplicitFieldSchema>>,
@@ -248,7 +248,7 @@ export type InsertableObjectFromSchemaRecordUnsafe<
  * {@link Unenforced} version of {@link InsertableTreeFieldFromImplicitField}.
  * @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.
- * @public
+ * @system @public
  */
 export type InsertableTreeFieldFromImplicitFieldUnsafe<
 	TSchema extends Unenforced<ImplicitFieldSchema>,

package/src/simple-tree/walkSchema.ts

@@ -0,0 +1,81 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { assert } from "@fluidframework/core-utils/internal";
+import { type TreeNodeSchema, NodeKind } from "./core/index.js";
+import { LeafNodeSchema } from "./leafNodeSchema.js";
+import { isObjectNodeSchema } from "./objectNodeTypes.js";
+import {
+	type ImplicitAllowedTypes,
+	normalizeAllowedTypes,
+	type ImplicitFieldSchema,
+	normalizeFieldSchema,
+} from "./schemaTypes.js";
+
+export function walkNodeSchema(
+	schema: TreeNodeSchema,
+	visitor: SchemaVisitor,
+	visitedSet: Set<TreeNodeSchema>,
+): void {
+	if (visitedSet.has(schema)) {
+		return;
+	}
+	visitedSet.add(schema);
+	if (schema instanceof LeafNodeSchema) {
+		// nothing to do
+	} else if (isObjectNodeSchema(schema)) {
+		for (const field of schema.fields.values()) {
+			walkFieldSchema(field, visitor, visitedSet);
+		}
+	} else {
+		assert(
+			schema.kind === NodeKind.Array || schema.kind === NodeKind.Map,
+			0x9b3 /* invalid schema */,
+		);
+		const childTypes = schema.info as ImplicitAllowedTypes;
+		walkAllowedTypes(normalizeAllowedTypes(childTypes), visitor, visitedSet);
+	}
+	// This visit is done at the end so the traversal order is most inner types first.
+	// This was picked since when fixing errors,
+	// working from the inner types out to the types that use them will probably go better than the reverse.
+	// This does not however ensure all types referenced by a type are visited before it, since in recursive cases thats impossible.
+	visitor.node?.(schema);
+}
+
+export function walkFieldSchema(
+	schema: ImplicitFieldSchema,
+	visitor: SchemaVisitor,
+	visitedSet: Set<TreeNodeSchema> = new Set(),
+): void {
+	walkAllowedTypes(normalizeFieldSchema(schema).allowedTypeSet, visitor, visitedSet);
+}
+
+export function walkAllowedTypes(
+	allowedTypes: Iterable<TreeNodeSchema>,
+	visitor: SchemaVisitor,
+	visitedSet: Set<TreeNodeSchema>,
+): void {
+	for (const childType of allowedTypes) {
+		walkNodeSchema(childType, visitor, visitedSet);
+	}
+	visitor.allowedTypes?.(allowedTypes);
+}
+/**
+ * Callbacks for use in {@link walkFieldSchema} / {@link walkAllowedTypes} / {@link walkNodeSchema}.
+ */
+
+export interface SchemaVisitor {
+	/**
+	 * Called once for each node schema.
+	 */
+	node?: (schema: TreeNodeSchema) => void;
+	/**
+	 * Called once for each set of allowed types.
+	 * Includes implicit allowed types (when a single type was used instead of an array).
+	 *
+	 * This includes every field, but also the allowed types array for maps and arrays and the root if starting at {@link walkAllowedTypes}.
+	 */
+	allowedTypes?: (allowedTypes: Iterable<TreeNodeSchema>) => void;
+}

package/src/treeFactory.ts

@@ -56,7 +56,8 @@ export class TreeFactory implements IChannelFactory<ITree> {
 /**
  * SharedTree is a hierarchical data structure for collaboratively editing strongly typed JSON-like trees
  * of objects, arrays, and other data types.
- * @internal
+ * @legacy
+ * @alpha
  */
 export const SharedTree = configuredSharedTree({});
 

package/src/util/typeUtils.ts

@@ -10,7 +10,7 @@
 /**
  * Return a type thats equivalent to the input, but with different IntelliSense.
  * This tends to convert unions and intersections into objects.
- * @public
+ * @system @public
  */
 export type FlattenKeys<T> = [{ [Property in keyof T]: T[Property] }][_InlineTrick];
 
@@ -81,7 +81,7 @@ export type AllowOptional<T> = [
  *
  * This constant is defined to provide a way to find this documentation from types which use this pattern,
  * and to locate types which use this pattern in case they need updating for compiler changes.
- * @public
+ * @system @public
  */
 export type _InlineTrick = 0;
 

package/dist/core/revertible/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/revertible/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,KAAK,UAAU,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/core/revertible/index.js

@@ -1,10 +0,0 @@
-"use strict";
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RevertibleStatus = void 0;
-var revertible_js_1 = require("./revertible.js");
-Object.defineProperty(exports, "RevertibleStatus", { enumerable: true, get: function () { return revertible_js_1.RevertibleStatus; } });
-//# sourceMappingURL=index.js.map

package/dist/core/revertible/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/core/revertible/index.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,iDAAoE;AAA1C,iHAAA,gBAAgB,OAAA","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nexport { type Revertible, RevertibleStatus } from \"./revertible.js\";\n"]}

package/dist/core/revertible/revertible.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"revertible.d.ts","sourceRoot":"","sources":["../../../src/core/revertible/revertible.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;GAOG;AACH,MAAM,WAAW,UAAU;IAC1B;;OAEG;IACH,QAAQ,CAAC,MAAM,EAAE,gBAAgB,CAAC;IAElC;;OAEG;IACH,MAAM,IAAI,IAAI,CAAC;IACf;;;;;;OAMG;IACH,MAAM,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAAC;IAE/B;;OAEG;IACH,OAAO,IAAI,IAAI,CAAC;CAChB;AAED;;;;GAIG;AACH,oBAAY,gBAAgB;IAC3B,sCAAsC;IACtC,KAAK,IAAA;IACL,0EAA0E;IAC1E,QAAQ,IAAA;CACR"}

package/dist/core/revertible/revertible.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"revertible.js","sourceRoot":"","sources":["../../../src/core/revertible/revertible.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAmCH;;;;GAIG;AACH,IAAY,gBAKX;AALD,WAAY,gBAAgB;IAC3B,sCAAsC;IACtC,yDAAK,CAAA;IACL,0EAA0E;IAC1E,+DAAQ,CAAA;AACT,CAAC,EALW,gBAAgB,gCAAhB,gBAAgB,QAK3B","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\n/**\n * Allows reversion of a change made to SharedTree.\n *\n * @remarks\n * Applications wanting to implement undo/redo support might typically maintain two stacks of Revertibles, with optional eviction policy to free up memory.\n *\n * @sealed @public\n */\nexport interface Revertible {\n\t/**\n\t * The current status of the revertible.\n\t */\n\treadonly status: RevertibleStatus;\n\n\t/**\n\t * Reverts the associated change and disposes it.\n\t */\n\trevert(): void;\n\t/**\n\t * Reverts the associated change and optionally disposes it.\n\t *\n\t * @param dispose - If true, the revertible will be disposed after being reverted.\n\t * If false, the revertible will remain valid. This can be useful for scenarios where the revert may be dropped\n\t * due to merge conflicts, and one wants to attempt reverting again.\n\t */\n\trevert(dispose: boolean): void;\n\n\t/**\n\t * Disposes this revertible, allowing associated resources to be released.\n\t */\n\tdispose(): void;\n}\n\n/**\n * The status of a {@link Revertible}.\n *\n * @public\n */\nexport enum RevertibleStatus {\n\t/** The revertible can be reverted. */\n\tValid,\n\t/** The revertible has been disposed. Reverting it will have no effect. */\n\tDisposed,\n}\n"]}

package/dist/domains/index.d.ts

@@ -1,8 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-export { SchemaBuilder } from "./schemaBuilder.js";
-export { cursorToJsonObject, jsonArray, jsonObject, jsonRoot, jsonSchema, singleJsonCursor, typedJsonCursor, type TypedJsonCompatible, type TypedJsonCompatibleObject, } from "./json/index.js";
-export { leaf } from "./leafDomain.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/domains/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/domains/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EACN,kBAAkB,EAClB,SAAS,EACT,UAAU,EACV,QAAQ,EACR,UAAU,EACV,gBAAgB,EAChB,eAAe,EACf,KAAK,mBAAmB,EACxB,KAAK,yBAAyB,GAC9B,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/domains/index.js

@@ -1,20 +0,0 @@
-"use strict";
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.leaf = exports.typedJsonCursor = exports.singleJsonCursor = exports.jsonSchema = exports.jsonRoot = exports.jsonObject = exports.jsonArray = exports.cursorToJsonObject = exports.SchemaBuilder = void 0;
-var schemaBuilder_js_1 = require("./schemaBuilder.js");
-Object.defineProperty(exports, "SchemaBuilder", { enumerable: true, get: function () { return schemaBuilder_js_1.SchemaBuilder; } });
-var index_js_1 = require("./json/index.js");
-Object.defineProperty(exports, "cursorToJsonObject", { enumerable: true, get: function () { return index_js_1.cursorToJsonObject; } });
-Object.defineProperty(exports, "jsonArray", { enumerable: true, get: function () { return index_js_1.jsonArray; } });
-Object.defineProperty(exports, "jsonObject", { enumerable: true, get: function () { return index_js_1.jsonObject; } });
-Object.defineProperty(exports, "jsonRoot", { enumerable: true, get: function () { return index_js_1.jsonRoot; } });
-Object.defineProperty(exports, "jsonSchema", { enumerable: true, get: function () { return index_js_1.jsonSchema; } });
-Object.defineProperty(exports, "singleJsonCursor", { enumerable: true, get: function () { return index_js_1.singleJsonCursor; } });
-Object.defineProperty(exports, "typedJsonCursor", { enumerable: true, get: function () { return index_js_1.typedJsonCursor; } });
-var leafDomain_js_1 = require("./leafDomain.js");
-Object.defineProperty(exports, "leaf", { enumerable: true, get: function () { return leafDomain_js_1.leaf; } });
-//# sourceMappingURL=index.js.map