@fluidframework/tree 2.4.0-294316 → 2.4.0-297385

package/src/shared-tree-core/branch.ts

@@ -11,7 +11,6 @@ import {
 	type ChangeFamily,
 	type ChangeFamilyEditor,
 	CommitKind,
-	type CommitMetadata,
 	type GraphCommit,
 	type RevisionTag,
 	type TaggedChange,
@@ -19,7 +18,6 @@ import {
 	makeAnonChange,
 	mintCommit,
 	rebaseBranch,
-	tagChange,
 	tagRollbackInverse,
 	type RebaseStatsWithDuration,
 } from "../core/index.js";
@@ -46,6 +44,7 @@ import { fail } from "../util/index.js";
 export type SharedTreeBranchChange<TChange> =
 	| {
 			type: "append";
+			kind: CommitKind;
 			change: TaggedChange<TChange>;
 			newCommits: readonly GraphCommit<TChange>[];
 	  }
@@ -116,11 +115,6 @@ export interface SharedTreeBranchEvents<TEditor extends ChangeFamilyEditor, TCha
 	 */
 	afterChange(change: SharedTreeBranchChange<TChange>): void;
 
-	/**
-	 * {@inheritdoc TreeViewEvents.commitApplied}
-	 */
-	commitApplied(data: CommitMetadata): void;
-
 	/**
 	 * Fired when this branch forks
 	 * @param fork - the new branch that forked off of this branch
@@ -229,8 +223,8 @@ export class SharedTreeBranch<
 		>,
 	) {
 		super();
-		this.editor = this.changeFamily.buildEditor((change) =>
-			this.apply(change, mintRevisionTag()),
+		this.editor = this.changeFamily.buildEditor(mintRevisionTag, (change) =>
+			this.apply(change),
 		);
 		this.unsubscribeBranchTrimmer = branchTrimmer?.on("ancestryTrimmed", (commit) => {
 			this.emit("ancestryTrimmed", commit);
@@ -248,42 +242,35 @@ export class SharedTreeBranch<
 
 	/**
 	 * Apply a change to this branch.
-	 * @param change - the change to apply
-	 * @param revision - the revision of the new head commit of the branch that contains `change`
-	 * @param changeKind - the kind of change to apply
+	 * @param taggedChange - the change to apply
+	 * @param kind - the kind of change to apply
 	 * @returns the change that was applied and the new head commit of the branch
 	 */
 	public apply(
-		change: TChange,
-		revision: RevisionTag,
-		changeKind: CommitKind = CommitKind.Default,
+		taggedChange: TaggedChange<TChange>,
+		kind: CommitKind = CommitKind.Default,
 	): [change: TChange, newCommit: GraphCommit<TChange>] {
 		this.assertNotDisposed();
 
-		// TODO: This should not be necessary when receiving changes from other clients.
-		const changeWithRevision = this.changeFamily.rebaser.changeRevision(change, revision);
+		const revisionTag = taggedChange.revision;
+		assert(revisionTag !== undefined, "Revision tag must be provided");
 
 		const newHead = mintCommit(this.head, {
-			revision,
-			change: changeWithRevision,
+			revision: revisionTag,
+			change: taggedChange.change,
 		});
 
 		const changeEvent = {
 			type: "append",
-			change: tagChange(changeWithRevision, revision),
+			kind,
+			change: taggedChange,
 			newCommits: [newHead],
 		} as const;
 
 		this.emit("beforeChange", changeEvent);
 		this.head = newHead;
-
-		// If this is not part of a transaction, emit a commitApplied event
-		if (!this.isTransacting()) {
-			this.emit("commitApplied", { isLocal: true, kind: changeKind });
-		}
-
 		this.emit("afterChange", changeEvent);
-		return [changeWithRevision, newHead];
+		return [taggedChange.change, newHead];
 	}
 
 	/**
@@ -351,12 +338,6 @@ export class SharedTreeBranch<
 
 		this.emit("beforeChange", changeEvent);
 		this.head = newHead;
-
-		// If this transaction is not nested, emit a commitApplied event
-		if (!this.isTransacting()) {
-			this.emit("commitApplied", { isLocal: true, kind: CommitKind.Default });
-		}
-
 		this.emit("afterChange", changeEvent);
 		return [commits, newHead];
 	}
@@ -387,7 +368,7 @@ export class SharedTreeBranch<
 			const commit =
 				commits[i] ?? fail("This wont run because we are iterating through commits");
 			const inverse = this.changeFamily.rebaser.changeRevision(
-				this.changeFamily.rebaser.invert(commit, true),
+				this.changeFamily.rebaser.invert(commit, true, revision),
 				revision,
 				commit.revision,
 			);
@@ -442,14 +423,14 @@ export class SharedTreeBranch<
 
 	/**
 	 * Spawn a new branch that is based off of the current state of this branch.
-	 * Changes made to the new branch will not be applied to this branch until the new branch is merged back in.
-	 *
-	 * @remarks Forks created during a transaction will be disposed when the transaction ends.
+	 * @param commit - The commit to base the new branch off of. Defaults to the head of this branch.
+	 * @remarks Changes made to the new branch will not be applied to this branch until the new branch is {@link SharedTreeBranch.merge | merged} back in.
+	 * Forks created during a transaction will be disposed when the transaction ends.
 	 */
-	public fork(): SharedTreeBranch<TEditor, TChange> {
+	public fork(commit: GraphCommit<TChange> = this.head): SharedTreeBranch<TEditor, TChange> {
 		this.assertNotDisposed();
 		const fork = new SharedTreeBranch(
-			this.head,
+			commit,
 			this.changeFamily,
 			this.mintRevisionTag,
 			this.branchTrimmer,
@@ -501,9 +482,9 @@ export class SharedTreeBranch<
 			removedCommits: deletedSourceCommits,
 			newCommits,
 		} as const;
+
 		this.emit("beforeChange", changeEvent);
 		this.head = newSourceHead;
-
 		this.emit("afterChange", changeEvent);
 		return rebaseResult;
 	}
@@ -525,6 +506,10 @@ export class SharedTreeBranch<
 			0x597 /* Branch may not be merged while transaction is in progress */,
 		);
 
+		if (branch === this) {
+			return undefined;
+		}
+
 		// Rebase the given branch onto this branch
 		const rebaseResult = this.rebaseBranch(branch, this);
 		if (rebaseResult === undefined) {
@@ -537,6 +522,7 @@ export class SharedTreeBranch<
 		const taggedChange = makeAnonChange(change);
 		const changeEvent = {
 			type: "append",
+			kind: CommitKind.Default,
 			get change(): TaggedChange<TChange> {
 				return taggedChange;
 			},

package/src/shared-tree-core/defaultResubmitMachine.ts

@@ -4,7 +4,7 @@
  */
 
 import { assert, oob } from "@fluidframework/core-utils/internal";
-import type { ChangeRebaser, GraphCommit } from "../core/index.js";
+import type { GraphCommit, TaggedChange } from "../core/index.js";
 import { disposeSymbol } from "../util/index.js";
 import type { ChangeEnricherReadonlyCheckout, ResubmitMachine } from "./index.js";
 
@@ -36,9 +36,9 @@ export class DefaultResubmitMachine<TChange> implements ResubmitMachine<TChange>
 
 	public constructor(
 		/**
-		 * A function that can invert a change.
+		 * A function that can create a rollback for a given change.
 		 */
-		private readonly inverter: ChangeRebaser<TChange>["invert"],
+		private readonly makeRollback: (change: TaggedChange<TChange>) => TChange,
 		/**
 		 * Change enricher that represent the tip of the top-level local branch (i.e., the branch on which in-flight
 		 * commits are applied and automatically rebased).
@@ -75,7 +75,7 @@ export class DefaultResubmitMachine<TChange> implements ResubmitMachine<TChange>
 			// Roll back the checkout to the state before the oldest commit
 			for (let iCommit = toResubmit.length - 1; iCommit >= 0; iCommit -= 1) {
 				const commit = toResubmit[iCommit] ?? oob();
-				const rollback = this.inverter(commit, true);
+				const rollback = this.makeRollback(commit);
 				// WARNING: it's not currently possible to roll back past a schema change (see AB#7265).
 				// Either we have to make it possible to do so, or this logic will have to change to work
 				// forwards from an earlier fork instead of backwards.

package/src/shared-tree-core/editManager.ts

@@ -17,6 +17,7 @@ import {
 	mintCommit,
 	rebaseChange,
 	type RebaseStatsWithDuration,
+	tagChange,
 } from "../core/index.js";
 import { type Mutable, brand, fail, getOrCreate, mapIterable } from "../util/index.js";
 
@@ -642,7 +643,7 @@ export class EditManager<
 				...newChangeFullyRebased.telemetryProperties,
 			});
 
-			peerLocalBranch.apply(newCommit.change, newCommit.revision);
+			peerLocalBranch.apply(tagChange(newCommit.change, newCommit.revision));
 			this.pushCommitToTrunk(sequenceId, {
 				...newCommit,
 				change: newChangeFullyRebased.change,

package/src/shared-tree-core/sharedTreeCore.ts

@@ -32,6 +32,7 @@ import {
 	RevisionTagCodec,
 	type SchemaAndPolicy,
 	type SchemaPolicy,
+	type TaggedChange,
 	type TreeStoredSchemaRepository,
 } from "../core/index.js";
 import {
@@ -271,7 +272,8 @@ export class SharedTreeCore<TEditor extends ChangeFamilyEditor, TChange>
 		this.resubmitMachine =
 			resubmitMachine ??
 			new DefaultResubmitMachine(
-				changeFamily.rebaser.invert.bind(changeFamily.rebaser),
+				(change: TaggedChange<TChange>) =>
+					changeFamily.rebaser.invert(change, true, this.mintRevisionTag()),
 				changeEnricher,
 			);
 		this.commitEnricher = new BranchCommitEnricher(changeFamily.rebaser, changeEnricher);
@@ -446,7 +448,7 @@ export class SharedTreeCore<TEditor extends ChangeFamilyEditor, TChange>
 		const {
 			commit: { revision, change },
 		} = this.messageCodec.decode(content, { idCompressor: this.idCompressor });
-		this.editManager.localBranch.apply(change, revision);
+		this.editManager.localBranch.apply({ change, revision });
 	}
 
 	public override getGCData(fullGC?: boolean): IGarbageCollectionData {

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>;
 }