@fluidframework/tree 2.2.0 → 2.3.0

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

@@ -4,17 +4,39 @@
  */
 
 import { assert } from "@fluidframework/core-utils/internal";
-import { createEmitter, type Listenable, type Off } from "../../events/index.js";
-import type { TreeChangeEvents, TreeNode, Unhydrated } from "./types.js";
-import type { AnchorNode } from "../../core/index.js";
 import {
+	createEmitter,
+	type HasListeners,
+	type IEmitter,
+	type Listenable,
+	type Off,
+} from "../../events/index.js";
+import type { TreeNode, Unhydrated } from "./types.js";
+import {
+	anchorSlot,
+	type AnchorEvents,
+	type AnchorNode,
+	type AnchorSet,
+	type UpPath,
+} from "../../core/index.js";
+import {
+	assertFlexTreeEntityNotFreed,
+	ContextSlot,
 	flexTreeSlot,
+	isFlexTreeNode,
 	isFreedSymbol,
+	isMapTreeNode,
 	LazyEntity,
 	TreeStatus,
 	treeStatusFromAnchorCache,
+	type FlexTreeNode,
+	type MapTreeNode,
 } from "../../feature-libraries/index.js";
 import type { TreeNodeSchema } from "./treeNodeSchema.js";
+import { fail } from "../../util/index.js";
+// TODO: decide how to deal with dependencies on flex-tree implementation.
+// eslint-disable-next-line import/no-internal-modules
+import { makeTree } from "../../feature-libraries/flex-tree/lazyNode.js";
 
 const treeNodeToKernel = new WeakMap<TreeNode, TreeNodeKernel>();
 
@@ -60,57 +82,138 @@ export function tryGetTreeNodeSchema(value: unknown): undefined | TreeNodeSchema
  * The kernel has the same lifetime as the node and spans both its unhydrated and hydrated states.
  * When hydration occurs, the kernel is notified via the {@link TreeNodeKernel.hydrate | hydrate} method.
  */
-export class TreeNodeKernel implements Listenable<TreeChangeEvents> {
+export class TreeNodeKernel implements Listenable<KernelEvents> {
+	private disposed = false;
+
+	/**
+	 * Generation number which is incremented any time we have an edit on the node.
+	 * Used during iteration to make sure there has been no edits that were concurrently made.
+	 * @remarks
+	 * This is updated monotonically by this class when edits are applied.
+	 * TODO: update this when applying edits to unhydrated trees.
+	 *
+	 * If TypeScript supported making this immutable from outside the class without making it readonly from inside, that would be used here,
+	 * but they only way to do that is add a separate public accessor and make it private, which was deemed not worth the boilerplate, runtime overhead and bundle size.
+	 */
+	public generationNumber: number = 0;
+
 	#hydrated?: {
 		anchorNode: AnchorNode;
-		offAnchorNode: Off;
+		offAnchorNode: Set<Off>;
 	};
-	#events = createEmitter<TreeChangeEvents>();
+
+	/**
+	 * Events registered before hydration.
+	 * @remarks
+	 * As an optimization these are allocated lazily as they are usually unused.
+	 */
+	#preHydrationEvents?: Listenable<KernelEvents> &
+		IEmitter<KernelEvents> &
+		HasListeners<KernelEvents>;
+
+	/**
+	 * Get the listener.
+	 * @remarks
+	 * If before hydration, allocates and uses `#preHydrationEvents`, otherwise the anchorNode.
+	 * This design avoids allocating `#preHydrationEvents` if unneeded.
+	 *
+	 * This design also avoids extra forwarding overhead for events from anchorNode and also
+	 * avoids registering for events that are unneeded.
+	 * This means optimizations like skipping processing data in subtrees where no subtreeChanged events are subscribed to would be able to work,
+	 * since this code does not unconditionally subscribe to those events (like a design simply forwarding all events would).
+	 */
+	get #events(): Listenable<KernelEvents> {
+		if (this.#hydrated === undefined) {
+			this.#preHydrationEvents ??= createEmitter<KernelEvents>();
+			return this.#preHydrationEvents;
+		} else {
+			return this.#hydrated.anchorNode;
+		}
+	}
 
 	/**
 	 * Create a TreeNodeKernel which can be looked up with {@link getKernel}.
+	 *
+	 * @param innerNode - When unhydrated/raw or marinated the MapTreeNode. FlexTreeNode when cooked.
 	 * @remarks
 	 * Exactly one kernel per TreeNode should be created.
 	 */
 	public constructor(
 		public readonly node: TreeNode,
 		public readonly schema: TreeNodeSchema,
+		private innerNode: InnerNode,
 	) {
 		assert(!treeNodeToKernel.has(node), 0xa1a /* only one kernel per node can be made */);
 		treeNodeToKernel.set(node, this);
+
+		if (isMapTreeNode(innerNode)) {
+			// Unhydrated case
+			mapTreeNodeToProxy.set(innerNode, node);
+		} else {
+			// Hydrated case
+			assert(
+				!innerNode.anchorNode.slots.has(proxySlot),
+				0x7f5 /* Cannot associate an flex node with multiple simple-tree nodes */,
+			);
+			this.hydrate(innerNode.anchorNode);
+		}
 	}
 
+	/**
+	 * Transition from {@link Unhydrated} to hydrated.
+	 * Bi-directionally associates the given hydrated TreeNode to the given anchor node.
+	 * @remarks
+	 * Happens at most once for any given node.
+	 * Cleans up mappings to {@link MapTreeNode} - it is assumed that they are no longer needed once the proxy has an anchor node.
+	 */
 	public hydrate(anchorNode: AnchorNode): void {
-		const offChildrenChanged = anchorNode.on("childrenChangedAfterBatch", () => {
-			this.#events.emit("nodeChanged");
-		});
+		assert(!this.disposed, 0xa2a /* cannot hydrate a disposed node */);
+		assert(this.#hydrated === undefined, 0xa2b /* hydration should only happen once */);
 
-		const offSubtreeChanged = anchorNode.on("subtreeChangedAfterBatch", () => {
-			this.#events.emit("treeChanged");
-		});
+		// If the this node is raw and thus has a MapTreeNode, forget it:
+		if (isMapTreeNode(this.innerNode)) {
+			mapTreeNodeToProxy.delete(this.innerNode);
+		}
 
-		const offAfterDestroy = anchorNode.on("afterDestroy", () => this.dispose());
+		// However, it's fine for an anchor node to rotate through different proxies when the content at that place in the tree is replaced.
+		anchorNode.slots.set(proxySlot, this.node);
 
 		this.#hydrated = {
 			anchorNode,
-			offAnchorNode: () => {
-				offChildrenChanged();
-				offSubtreeChanged();
-				offAfterDestroy();
-			},
+			offAnchorNode: new Set([
+				anchorNode.on("afterDestroy", () => this.dispose()),
+				// TODO: this should be triggered on change even for unhydrated nodes.
+				anchorNode.on("childrenChanging", () => {
+					this.generationNumber += 1;
+				}),
+			]),
 		};
-	}
 
-	public dehydrate(): void {
-		this.#hydrated?.offAnchorNode?.();
-		this.#hydrated = undefined;
+		// If needed, register forwarding emitters for events from before hydration
+		if (this.#preHydrationEvents !== undefined) {
+			for (const eventName of kernelEvents) {
+				if (this.#preHydrationEvents.hasListeners(eventName)) {
+					this.#hydrated.offAnchorNode.add(
+						// Argument is forwarded between matching events, so the type should be correct.
+						// eslint-disable-next-line @typescript-eslint/no-explicit-any
+						anchorNode.on(eventName, (arg: any) =>
+							this.#preHydrationEvents?.emit(eventName, arg),
+						),
+					);
+				}
+			}
+		}
 	}
 
 	public isHydrated(): boolean {
+		assert(!this.disposed, 0xa2c /* cannot use a disposed node */);
 		return this.#hydrated !== undefined;
 	}
 
 	public getStatus(): TreeStatus {
+		if (this.disposed) {
+			return TreeStatus.Deleted;
+		}
 		if (this.#hydrated?.anchorNode === undefined) {
 			return TreeStatus.New;
 		}
@@ -127,15 +230,164 @@ export class TreeNodeKernel implements Listenable<TreeChangeEvents> {
 		return treeStatusFromAnchorCache(this.#hydrated.anchorNode);
 	}
 
-	public on<K extends keyof TreeChangeEvents>(
-		eventName: K,
-		listener: TreeChangeEvents[K],
-	): Off {
+	public on<K extends keyof KernelEvents>(eventName: K, listener: KernelEvents[K]): Off {
 		return this.#events.on(eventName, listener);
 	}
 
 	public dispose(): void {
-		this.dehydrate();
+		this.disposed = true;
+		for (const off of this.#hydrated?.offAnchorNode ?? []) {
+			off();
+		}
 		// TODO: go to the context and remove myself from withAnchors
 	}
+
+	/**
+	 * Retrieves the flex node associated with the given target via {@link setInnerNode}.
+	 * @remarks
+	 * For {@link Unhydrated} nodes, this returns the MapTreeNode.
+	 *
+	 * For hydrated nodes it returns a FlexTreeNode backed by the forest.
+	 * Note that for "marinated" nodes, this FlexTreeNode exists and returns it: it does not return the MapTreeNode which is the current InnerNode.
+	 */
+	public getOrCreateInnerNode(allowFreed = false): InnerNode {
+		if (!isMapTreeNode(this.innerNode)) {
+			// Cooked case
+			return this.innerNode;
+		}
+
+		if (this.#hydrated === undefined) {
+			// Unhydrated case
+			return this.innerNode;
+		}
+
+		// Marinated case -> cooked
+		const anchorNode = this.#hydrated.anchorNode;
+		// The proxy is bound to an anchor node, but it may or may not have an actual flex node yet
+		const flexNode = anchorNode.slots.get(flexTreeSlot);
+		if (flexNode !== undefined) {
+			this.innerNode = flexNode;
+			return flexNode; // If it does have a flex node, return it...
+		} // ...otherwise, the flex node must be created
+		const context = anchorNode.anchorSet.slots.get(ContextSlot) ?? fail("missing context");
+		const cursor = context.checkout.forest.allocateCursor("getFlexNode");
+		context.checkout.forest.moveCursorToPath(anchorNode, cursor);
+		const newFlexNode = makeTree(context, cursor);
+		cursor.free();
+		this.innerNode = newFlexNode;
+		// Calling this is a performance improvement, however, do this only after demand to avoid momentarily having no anchors to anchorNode
+		anchorForgetters?.get(this.node)?.();
+		if (!allowFreed) {
+			assertFlexTreeEntityNotFreed(newFlexNode);
+		}
+		return newFlexNode;
+	}
+
+	/**
+	 * Creates an anchor node and associates it with the given proxy.
+	 * @privateRemarks
+	 * Use `forgetters` to cleanup the anchor allocated by this function once the anchor is no longer needed.
+	 * In practice, this happens when either the anchor node is destroyed, or another anchor to the same node is created by a new flex node.
+	 *
+	 * The FlexTreeNode holds a reference to the same anchor, and has a lifetime at least as long as the simple-tree,
+	 * so this would be unnecessary except for the case of "marinated" nodes, which have an anchor,
+	 * but might not have a FlexTreeNode.
+	 * Handling this case is an optimization assuming that this extra anchor reference is cheaper than eagerly creating FlexTreeNodes.
+	 */
+	public anchorProxy(anchors: AnchorSet, path: UpPath): AnchorNode {
+		assert(!anchorForgetters.has(this.node), 0x91c /* Proxy anchor should not be set twice */);
+		const anchor = anchors.track(path);
+		const anchorNode = anchors.locate(anchor) ?? fail("Expected anchor node to be present");
+		this.hydrate(anchorNode);
+		const forget = (): void => {
+			if (anchors.locate(anchor)) {
+				anchors.forget(anchor);
+			}
+			anchorForgetters.delete(this.node);
+			off();
+		};
+		anchorForgetters.set(this.node, forget);
+		const off = anchorNode.on("afterDestroy", forget);
+		return anchorNode;
+	}
+
+	/**
+	 * 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.
+	 */
+	public tryGetInnerNode(): InnerNode | undefined {
+		if (isFlexTreeNode(this.innerNode)) {
+			// Cooked case
+			return this.innerNode;
+		}
+
+		if (this.#hydrated === undefined) {
+			// Unhydrated case
+			return this.innerNode;
+		}
+
+		// Marinated case -> cooked
+		const anchorNode = this.#hydrated.anchorNode;
+		// The proxy is bound to an anchor node, but it may or may not have an actual flex node yet
+		return anchorNode.slots.get(flexTreeSlot);
+	}
+}
+
+/**
+ * Used by {@link anchorProxy} as an optimization to ensure that only one anchor is remembered at a time for a given anchor node
+ */
+const anchorForgetters = new WeakMap<TreeNode, () => void>();
+
+const kernelEvents = ["childrenChangedAfterBatch", "subtreeChangedAfterBatch"] as const;
+
+type KernelEvents = Pick<AnchorEvents, (typeof kernelEvents)[number]>;
+
+/**
+ * For "cooked" nodes this is a FlexTreeNode thats a projection of forest content.
+ * For {@link Unhydrated} nodes this is a MapTreeNode.
+ * For "marinated" nodes, some code (ex: getOrCreateInnerNode) returns the FlexTreeNode thats a projection of forest content, and some code (ex: tryGetInnerNode) returns undefined.
+ *
+ * @remarks
+ * Currently MapTreeNode extends FlexTreeNode, and most code which can work with either just uses FlexTreeNode.
+ * TODO: Code should be migrating toward using this type to distinguish to two use-cases.
+ *
+ * TODO: The inconsistent handling of "marinated" cases should be cleaned up.
+ * Maybe getOrCreateInnerNode should cook marinated nodes so they have a proper InnerNode?
+ */
+export type InnerNode = FlexTreeNode | MapTreeNode;
+
+/**
+ * {@inheritdoc proxyToMapTreeNode}
+ */
+const mapTreeNodeToProxy = new WeakMap<MapTreeNode, TreeNode>();
+
+/**
+ * An anchor slot which associates an anchor with its corresponding TreeNode, if there is one.
+ * @remarks
+ * For this to work, we have to require that there is at most a single view using a given AnchorSet.
+ * FlexTree already has this assumption, and we also assume there is a single simple-tree per FlexTree, so this is valid.
+ */
+const proxySlot = anchorSlot<TreeNode>();
+
+/**
+ * Retrieves the proxy associated with the given flex node via {@link setInnerNode}, if any.
+ */
+export function tryGetCachedTreeNode(flexNode: InnerNode): TreeNode | undefined {
+	if (isMapTreeNode(flexNode)) {
+		// Unhydrated case
+		return mapTreeNodeToProxy.get(flexNode);
+	}
+	// Hydrated case
+	return flexNode.anchorNode.slots.get(proxySlot);
+}
+
+export function tryDisposeTreeNode(anchorNode: AnchorNode): void {
+	const treeNode = anchorNode.slots.get(proxySlot);
+	if (treeNode !== undefined) {
+		const kernel = getKernel(treeNode);
+		kernel.dispose();
+	}
 }

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

@@ -33,7 +33,7 @@ export type TreeNodeSchema<
  * This is used for schema which cannot have their instances constructed using constructors, like leaf schema.
  * @privateRemarks
  * Non-class based schema can have issues with recursive types due to https://github.com/microsoft/TypeScript/issues/55832.
- * @sealed @public
+ * @system @sealed @public
  */
 export interface TreeNodeSchemaNonClass<
 	out Name extends string = string,

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

@@ -20,6 +20,11 @@ import { isFlexTreeNode, type FlexTreeNode } from "../../feature-libraries/index
  *
  * Since un-hydrated nodes become hydrated when inserted, strong typing can't be used to distinguish them.
  * This no-op wrapper is used instead.
+ * @remarks
+ * Nodes which are Unhydrated report {@link TreeStatus}.new from `Tree.status(node)`.
+ * @privateRemarks
+ * TODO: Linking tree status is failing in intellisense and linking directly to its .new item is failing in API extractor as well.
+ * WOuld be nice to have a working link here.
  * @public
  */
 export type Unhydrated<T> = T;
@@ -27,6 +32,11 @@ export type Unhydrated<T> = T;
 /**
  * A collection of events that can be emitted by a {@link TreeNode}.
  *
+ * @remarks
+ * Currently, events can be subscribed to for {@link Unhydrated} nodes, however no events will be triggered for the nodes until after they are hydrated.
+ * This is considered a known issue, and should be fixed in future versions.
+ * Do not rely on the fact that editing unhydrated nodes does not trigger their events.
+ *
  * @privateRemarks
  * TODO: add a way to subscribe to a specific field (for nodeChanged and treeChanged).
  * Probably have object node and map node specific APIs for this.
@@ -47,15 +57,18 @@ export type Unhydrated<T> = T;
  */
 export interface TreeChangeEvents {
 	/**
-	 * Emitted by a node after a batch of changes has been applied to the tree, if a change affected the node, where a
-	 * change is:
+	 * Emitted by a node after a batch of changes has been applied to the tree, if any of the changes affected the node.
 	 *
-	 * - For an object node, when the value of one of its properties changes (i.e., the property's value is set
-	 * to something else, including `undefined`).
+	 * - Object nodes define a change as being when the value of one of its properties changes (i.e., the property's value is set, including when set to `undefined`).
 	 *
-	 * - For an array node, when an element is added, removed, or moved.
+	 * - Array nodes define a change as when an element is added, removed, moved or replaced.
 	 *
-	 * - For a map node, when an entry is added, updated, or removed.
+	 * - Map nodes define a change as when an entry is added, updated, or removed.
+	 *
+	 * @param unstable - Future versions of this API (such as the one in beta on TreeBeta) may use this argument to provide additional data to the event.
+	 * users of this event should ensure that they do not provide a listener callback which has an optional parameter in this position, since unexpected data might get provided to it.
+	 * This parameter exists to capture this fact in the type system.
+	 * Using an inline lambda expression as the listener callback is a good pattern to avoid cases like this were arguments are added from breaking due to optional arguments.
 	 *
 	 * @remarks
 	 * This event is not emitted when:
@@ -70,15 +83,17 @@ export interface TreeChangeEvents {
 	 * For remote edits, this event is not guaranteed to occur in the same order or quantity that it did in
 	 * the client that made the original edit.
 	 *
-	 * When it is emitted, the tree is guaranteed to be in-schema.
+	 * When the event is emitted, the tree is guaranteed to be in-schema.
 	 *
 	 * @privateRemarks
 	 * This event occurs whenever the apparent contents of the node instance change, regardless of what caused the change.
 	 * For example, it will fire when the local client reassigns a child, when part of a remote edit is applied to the
 	 * node, or when the node has to be updated due to resolution of a merge conflict
 	 * (for example a previously applied local change might be undone, then reapplied differently or not at all).
+	 *
+	 * TODO: define and document event ordering (ex: bottom up, with nodeChanged before treeChange on each level).
 	 */
-	nodeChanged(): void;
+	nodeChanged(unstable?: unknown): void;
 
 	/**
 	 * Emitted by a node after a batch of changes has been applied to the tree, when something changed anywhere in the

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

@@ -43,6 +43,7 @@ export const typeSchemaSymbol: unique symbol = Symbol("TreeNode Schema");
  *
  * @typeParam TName - Same as {@link TreeNodeSchema}'s "Name" parameter.
  * @typeParam TKind - Same as {@link TreeNodeSchema}'s "Kind" parameter.
+ * @typeParam TInfo - Same as {@link TreeNodeSchema}'s "Info" parameter: format depends on the Kind.
  * @remarks
  * Powers {@link TreeNode}'s strong typing setup.
  * @example Narrow types for overloading based on NodeKind
@@ -75,6 +76,7 @@ export const typeSchemaSymbol: unique symbol = Symbol("TreeNode Schema");
 export interface WithType<
 	out TName extends string = string,
 	out TKind extends NodeKind = NodeKind,
+	out TInfo = unknown,
 > {
 	/**
 	 * Type symbol, marking a type in a way to increase type safety via strong type checking.
@@ -85,5 +87,5 @@ export interface WithType<
 	/**
 	 * Type symbol, marking a type in a way to increase type safety via strong type checking.
 	 */
-	get [typeSchemaSymbol](): TreeNodeSchemaClass<TName, TKind>;
+	get [typeSchemaSymbol](): TreeNodeSchemaClass<TName, TKind, unknown, never, boolean, TInfo>;
 }

package/src/simple-tree/index.ts

@@ -19,6 +19,7 @@ export {
 	type Unhydrated,
 	type InternalTreeNode,
 	isTreeNode,
+	tryDisposeTreeNode,
 } from "./core/index.js";
 export {
 	type ITree,
@@ -44,6 +45,25 @@ export {
 	type TreeNodeApi,
 	cursorFromInsertable,
 	createFromInsertable,
+	type NodeChangedData,
+	TreeBeta,
+	type TreeChangeEventsBeta,
+	type SimpleTreeSchema,
+	type JsonSchemaId,
+	type JsonSchemaType,
+	type JsonObjectNodeSchema,
+	type JsonArrayNodeSchema,
+	type JsonMapNodeSchema,
+	type JsonLeafNodeSchema,
+	type JsonSchemaRef,
+	type JsonRefPath,
+	type JsonNodeSchema,
+	type JsonNodeSchemaBase,
+	type JsonTreeSchema,
+	type JsonFieldSchema,
+	type JsonLeafSchemaType,
+	getJsonSchema,
+	getSimpleSchema,
 } from "./api/index.js";
 export {
 	type NodeFromSchema,
@@ -65,7 +85,7 @@ export {
 	normalizeFieldSchema,
 	type ApplyKind,
 } from "./schemaTypes.js";
-export { getOrCreateInnerNode, tryDisposeTreeNode } from "./proxyBinding.js";
+export { getOrCreateInnerNode } from "./proxyBinding.js";
 export { toFlexSchema } from "./toFlexSchema.js";
 export type {
 	FieldHasDefaultUnsafe,
@@ -86,7 +106,6 @@ export type {
 } from "./typesUnsafe.js";
 export {
 	getTreeNodeForField,
-	type InsertableContent,
 	prepareContentForHydration,
 } from "./proxies.js";
 
@@ -103,22 +122,12 @@ export {
 	setField,
 } from "./objectNode.js";
 export type { TreeMapNode, MapNodeInsertableData } from "./mapNode.js";
-export { mapTreeFromNodeData } from "./toMapTree.js";
-export type { SimpleTreeSchema } from "./simpleSchema.js";
+export { mapTreeFromNodeData, type InsertableContent } from "./toMapTree.js";
+export { toStoredSchema, getStoredSchema, getFlexSchema } from "./toFlexSchema.js";
 export {
-	type JsonSchemaId,
-	type JsonSchemaType,
-	type JsonObjectNodeSchema,
-	type JsonArrayNodeSchema,
-	type JsonMapNodeSchema,
-	type JsonLeafNodeSchema,
-	type JsonSchemaRef,
-	type JsonRefPath,
-	type JsonNodeSchema,
-	type JsonNodeSchemaBase,
-	type JsonTreeSchema,
-	type JsonFieldSchema,
-	type JsonLeafSchemaType,
-} from "./jsonSchema.js";
-export { getJsonSchema } from "./getJsonSchema.js";
-export { getSimpleSchema } from "./getSimpleSchema.js";
+	numberSchema,
+	stringSchema,
+	booleanSchema,
+	handleSchema,
+	nullSchema,
+} from "./leafNodeSchema.js";

package/src/simple-tree/leafNodeSchema.ts

@@ -5,10 +5,9 @@
 
 import { assert } from "@fluidframework/core-utils/internal";
 
-import type { TreeNodeSchemaIdentifier, TreeValue } from "../core/index.js";
-import { leaf } from "../domains/index.js";
+import { type TreeValue, ValueSchema } from "../core/index.js";
 import {
-	type LeafNodeSchema as FlexLeafNodeSchema,
+	LeafNodeSchema as FlexLeafNodeSchema,
 	type FlexTreeNode,
 	isFlexTreeNode,
 	valueSchemaAllows,
@@ -20,12 +19,6 @@ import {
 	type TreeNodeSchemaNonClass,
 } from "./core/index.js";
 
-type UnbrandedName<T extends FlexLeafNodeSchema> = T["name"] extends TreeNodeSchemaIdentifier<
-	infer Name extends string
->
-	? Name
-	: T["name"];
-
 /**
  * Instances of this class are schema for leaf nodes.
  * @remarks
@@ -35,14 +28,14 @@ type UnbrandedName<T extends FlexLeafNodeSchema> = T["name"] extends TreeNodeSch
  * @privateRemarks
  * This class refers to the underlying flex tree schema in its constructor, so this class can't be included in the package API.
  */
-export class LeafNodeSchema<T extends FlexLeafNodeSchema>
-	implements TreeNodeSchemaNonClass<UnbrandedName<T>, NodeKind.Leaf, TreeValue<T["info"]>>
+export class LeafNodeSchema<Name extends string, const T extends ValueSchema>
+	implements TreeNodeSchemaNonClass<Name, NodeKind.Leaf, TreeValue<T>, TreeValue<T>>
 {
-	public readonly identifier: UnbrandedName<T>;
+	public readonly identifier: Name;
 	public readonly kind = NodeKind.Leaf;
-	public readonly info: T["info"];
+	public readonly info: T;
 	public readonly implicitlyConstructable = true as const;
-	public create(data: TreeValue<T["info"]> | FlexTreeNode): TreeValue<T["info"]> {
+	public create(data: TreeValue<T> | FlexTreeNode): TreeValue<T> {
 		if (isFlexTreeNode(data)) {
 			const value = data.value;
 			assert(valueSchemaAllows(this.info, value), 0x916 /* invalid value */);
@@ -51,30 +44,33 @@ export class LeafNodeSchema<T extends FlexLeafNodeSchema>
 		return data;
 	}
 
-	public constructor(schema: T) {
+	public constructor(name: Name, t: T) {
+		const schema: FlexLeafNodeSchema = new FlexLeafNodeSchema({ name: "makeLeaf" }, name, t);
 		setFlexSchemaFromClassSchema(this, schema);
-		this.identifier = schema.name as UnbrandedName<T>;
-		this.info = schema.info;
+		this.identifier = name;
+		this.info = t;
 	}
 }
 
 /**
  * Wrapper around LeafNodeSchema's constructor that provides the return type that is desired in the package public API.
  */
-function makeLeaf<T extends FlexLeafNodeSchema>(
-	schema: T,
+function makeLeaf<Name extends string, const T extends ValueSchema>(
+	name: Name,
+	t: T,
 ): TreeNodeSchema<
-	UnbrandedName<T>,
+	`com.fluidframework.leaf.${Name}`,
 	NodeKind.Leaf,
-	TreeValue<T["info"]>,
-	TreeValue<T["info"]>
+	TreeValue<T>,
+	TreeValue<T>
 > {
-	return new LeafNodeSchema(schema);
+	// Names in this domain follow https://en.wikipedia.org/wiki/Reverse_domain_name_notation
+	return new LeafNodeSchema(`com.fluidframework.leaf.${name}`, t);
 }
 
 // Leaf schema shared between all SchemaFactory instances.
-export const stringSchema = makeLeaf(leaf.string);
-export const numberSchema = makeLeaf(leaf.number);
-export const booleanSchema = makeLeaf(leaf.boolean);
-export const nullSchema = makeLeaf(leaf.null);
-export const handleSchema = makeLeaf(leaf.handle);
+export const stringSchema = makeLeaf("string", ValueSchema.String);
+export const numberSchema = makeLeaf("number", ValueSchema.Number);
+export const booleanSchema = makeLeaf("boolean", ValueSchema.Boolean);
+export const nullSchema = makeLeaf("null", ValueSchema.Null);
+export const handleSchema = makeLeaf("handle", ValueSchema.FluidHandle);