@fluidframework/tree 2.10.0-306579 → 2.10.0-307060

package/src/feature-libraries/modular-schema/discrepancies.ts

@@ -27,45 +27,45 @@ import { brand } from "../../util/index.js";
 /**
  * @remarks
  *
- * 1. FieldIncompatibility
+ * 1. FieldDiscrepancy
  *
- * `FieldIncompatibility` represents the differences between two `TreeFieldStoredSchema` objects. It consists of
+ * `FieldDiscrepancy` represents the differences between two `TreeFieldStoredSchema` objects. It consists of
  * three types of incompatibilities:
  *
- * - FieldKindIncompatibility: Indicates the differences in `FieldKindIdentifier` between two `TreeFieldStoredSchema`
+ * - FieldKindDiscrepancy: Indicates the differences in `FieldKindIdentifier` between two `TreeFieldStoredSchema`
  * objects (e.g., optional, required, sequence, etc.).
- * - AllowedTypesIncompatibility: Indicates the differences in the allowed child types between the two schemas.
- * - ValueSchemaIncompatibility: Specifically indicates the differences in the `ValueSchema` of two
+ * - AllowedTypesDiscrepancy: Indicates the differences in the allowed child types between the two schemas.
+ * - ValueSchemaDiscrepancy: Specifically indicates the differences in the `ValueSchema` of two
  * `LeafNodeStoredSchema` objects.
  *
- * 2. NodeIncompatibility
+ * 2. NodeDiscrepancy
  *
- * `NodeIncompatibility` represents the differences between two `TreeNodeStoredSchema` objects and includes:
+ * `NodeDiscrepancy` represents the differences between two `TreeNodeStoredSchema` objects and includes:
  *
- * - NodeKindIncompatibility: Indicates the differences in the types of `TreeNodeStoredSchema` (currently supports
+ * - NodeKindDiscrepancy: Indicates the differences in the types of `TreeNodeStoredSchema` (currently supports
  * `ObjectNodeStoredSchema`, `MapNodeStoredSchema`, and `LeafNodeStoredSchema`).
- * - NodeFieldsIncompatibility: Indicates the `FieldIncompatibility` of `TreeFieldStoredSchema` within two
- * `TreeNodeStoredSchema`. It includes an array of `FieldIncompatibility` instances in the `differences` field.
+ * - NodeFieldsDiscrepancy: Indicates the `FieldDiscrepancy` of `TreeFieldStoredSchema` within two
+ * `TreeNodeStoredSchema`. It includes an array of `FieldDiscrepancy` instances in the `differences` field.
  *
  * When comparing two nodes for compatibility, it only makes sense to compare their fields if the nodes are of
  * the same kind (map, object, leaf).
  *
- * 3. Incompatibility
+ * 3. Discrepancy
  *
- * Incompatibility consists of both `NodeIncompatibility` and `FieldIncompatibility`, representing any kind of
- * schema differences. See {@link getAllowedContentIncompatibilities} for more details about how we process it
+ * Discrepancy consists of both `NodeDiscrepancy` and `FieldDiscrepancy`, representing any kind of
+ * schema differences. See {@link getAllowedContentDiscrepancies} for more details about how we process it
  * and the ordering.
  */
-export type Incompatibility = FieldIncompatibility | NodeIncompatibility;
+export type Discrepancy = FieldDiscrepancy | NodeDiscrepancy;
 
-export type NodeIncompatibility = NodeKindIncompatibility | NodeFieldsIncompatibility;
+export type NodeDiscrepancy = NodeKindDiscrepancy | NodeFieldsDiscrepancy;
 
-export type FieldIncompatibility =
-	| AllowedTypeIncompatibility
-	| FieldKindIncompatibility
-	| ValueSchemaIncompatibility;
+export type FieldDiscrepancy =
+	| AllowedTypeDiscrepancy
+	| FieldKindDiscrepancy
+	| ValueSchemaDiscrepancy;
 
-export interface AllowedTypeIncompatibility {
+export interface AllowedTypeDiscrepancy {
 	identifier: string | undefined; // undefined indicates root field schema
 	mismatch: "allowedTypes";
 	/**
@@ -78,62 +78,60 @@ export interface AllowedTypeIncompatibility {
 	stored: string[];
 }
 
-export interface FieldKindIncompatibility {
+export interface FieldKindDiscrepancy {
 	identifier: string | undefined; // undefined indicates root field schema
 	mismatch: "fieldKind";
 	view: FieldKindIdentifier;
 	stored: FieldKindIdentifier;
 }
 
-export interface ValueSchemaIncompatibility {
+export interface ValueSchemaDiscrepancy {
 	identifier: string;
 	mismatch: "valueSchema";
 	view: ValueSchema | undefined;
 	stored: ValueSchema | undefined;
 }
 
-export interface NodeKindIncompatibility {
+export interface NodeKindDiscrepancy {
 	identifier: string;
 	mismatch: "nodeKind";
 	view: SchemaFactoryNodeKind | undefined;
 	stored: SchemaFactoryNodeKind | undefined;
 }
 
-export interface NodeFieldsIncompatibility {
+export interface NodeFieldsDiscrepancy {
 	identifier: string;
 	mismatch: "fields";
-	differences: FieldIncompatibility[];
+	differences: FieldDiscrepancy[];
 }
 
 type SchemaFactoryNodeKind = "object" | "leaf" | "map";
 
 /**
- * @remarks
+ * Finds and reports discrepancies between a view schema and a stored schema.
  *
  * The workflow for finding schema incompatibilities:
- * 1. Compare the two root schemas to identify any `FieldIncompatibility`.
+ * 1. Compare the two root schemas to identify any `FieldDiscrepancy`.
  *
  * 2. For each node schema in the `view`:
  * - Verify if the node schema exists in the stored. If it does, ensure that the `SchemaFactoryNodeKind` are
- * consistent. Otherwise this difference is treated as `NodeKindIncompatibility`
+ * consistent. Otherwise this difference is treated as `NodeKindDiscrepancy`
  * - If a node schema with the same identifier exists in both view and stored, and their `SchemaFactoryNodeKind`
- * are consistent, perform a exhaustive validation to identify all `FieldIncompatibility`.
+ * are consistent, perform a exhaustive validation to identify all `FieldDiscrepancy`.
  *
  * 3. For each node schema in the stored, verify if it exists in the view. The overlapping parts were already
  * addressed in the previous step.
  *
  * @returns the discrepancies between two TreeStoredSchema objects
  */
-export function getAllowedContentIncompatibilities(
+export function getAllowedContentDiscrepancies(
 	view: TreeStoredSchema,
 	stored: TreeStoredSchema,
-): Incompatibility[] {
-	const incompatibilities: Incompatibility[] = [];
+): Discrepancy[] {
+	const discrepancies: Discrepancy[] = [];
 
 	// check root schema discrepancies
-	incompatibilities.push(
-		...trackFieldDiscrepancies(view.rootFieldSchema, stored.rootFieldSchema),
-	);
+	discrepancies.push(...trackFieldDiscrepancies(view.rootFieldSchema, stored.rootFieldSchema));
 
 	// Verify the existence and type of a node schema given its identifier (key), then determine if
 	// an exhaustive search is necessary.
@@ -143,7 +141,7 @@ export function getAllowedContentIncompatibilities(
 
 		if (viewNodeSchema instanceof ObjectNodeStoredSchema) {
 			if (!stored.nodeSchema.has(key)) {
-				incompatibilities.push({
+				discrepancies.push({
 					identifier: key,
 					mismatch: "nodeKind",
 					view: "object",
@@ -156,27 +154,27 @@ export function getAllowedContentIncompatibilities(
 					0x9be /* The storedNodeSchema in stored.nodeSchema should not be undefined */,
 				);
 				if (storedNodeSchema instanceof MapNodeStoredSchema) {
-					incompatibilities.push({
+					discrepancies.push({
 						identifier: key,
 						mismatch: "nodeKind",
 						view: "object",
 						stored: "map",
-					} satisfies NodeKindIncompatibility);
+					} satisfies NodeKindDiscrepancy);
 				} else if (storedNodeSchema instanceof LeafNodeStoredSchema) {
-					incompatibilities.push({
+					discrepancies.push({
 						identifier: key,
 						mismatch: "nodeKind",
 						view: "object",
 						stored: "leaf",
-					} satisfies NodeKindIncompatibility);
+					} satisfies NodeKindDiscrepancy);
 				} else if (storedNodeSchema instanceof ObjectNodeStoredSchema) {
 					const differences = trackObjectNodeDiscrepancies(viewNodeSchema, storedNodeSchema);
 					if (differences.length > 0) {
-						incompatibilities.push({
+						discrepancies.push({
 							identifier: key,
 							mismatch: "fields",
 							differences,
-						} satisfies NodeFieldsIncompatibility);
+						} satisfies NodeFieldsDiscrepancy);
 					}
 				} else {
 					throwUnsupportedNodeType(storedNodeSchema.constructor.name);
@@ -184,12 +182,12 @@ export function getAllowedContentIncompatibilities(
 			}
 		} else if (viewNodeSchema instanceof MapNodeStoredSchema) {
 			if (!stored.nodeSchema.has(key)) {
-				incompatibilities.push({
+				discrepancies.push({
 					identifier: key,
 					mismatch: "nodeKind",
 					view: "map",
 					stored: undefined,
-				} satisfies NodeKindIncompatibility);
+				} satisfies NodeKindDiscrepancy);
 			} else {
 				const storedNodeSchema = stored.nodeSchema.get(key);
 				assert(
@@ -197,21 +195,21 @@ export function getAllowedContentIncompatibilities(
 					0x9bf /* The storedNodeSchema in stored.nodeSchema should not be undefined */,
 				);
 				if (storedNodeSchema instanceof ObjectNodeStoredSchema) {
-					incompatibilities.push({
+					discrepancies.push({
 						identifier: key,
 						mismatch: "nodeKind",
 						view: "map",
 						stored: "object",
-					} satisfies NodeKindIncompatibility);
+					} satisfies NodeKindDiscrepancy);
 				} else if (storedNodeSchema instanceof LeafNodeStoredSchema) {
-					incompatibilities.push({
+					discrepancies.push({
 						identifier: key,
 						mismatch: "nodeKind",
 						view: "map",
 						stored: "leaf",
-					} satisfies NodeKindIncompatibility);
+					} satisfies NodeKindDiscrepancy);
 				} else if (storedNodeSchema instanceof MapNodeStoredSchema) {
-					incompatibilities.push(
+					discrepancies.push(
 						...trackFieldDiscrepancies(
 							viewNodeSchema.mapFields,
 							storedNodeSchema.mapFields,
@@ -224,7 +222,7 @@ export function getAllowedContentIncompatibilities(
 			}
 		} else if (viewNodeSchema instanceof LeafNodeStoredSchema) {
 			if (!stored.nodeSchema.has(key)) {
-				incompatibilities.push({
+				discrepancies.push({
 					identifier: key,
 					mismatch: "nodeKind",
 					view: "leaf",
@@ -237,27 +235,27 @@ export function getAllowedContentIncompatibilities(
 					0x9c0 /* The storedNodeSchema in stored.nodeSchema should not be undefined */,
 				);
 				if (storedNodeSchema instanceof MapNodeStoredSchema) {
-					incompatibilities.push({
+					discrepancies.push({
 						identifier: key,
 						mismatch: "nodeKind",
 						view: "leaf",
 						stored: "map",
-					} satisfies NodeKindIncompatibility);
+					} satisfies NodeKindDiscrepancy);
 				} else if (storedNodeSchema instanceof ObjectNodeStoredSchema) {
-					incompatibilities.push({
+					discrepancies.push({
 						identifier: key,
 						mismatch: "nodeKind",
 						view: "leaf",
 						stored: "object",
-					} satisfies NodeKindIncompatibility);
+					} satisfies NodeKindDiscrepancy);
 				} else if (storedNodeSchema instanceof LeafNodeStoredSchema) {
 					if (viewNodeSchema.leafValue !== storedNodeSchema.leafValue) {
-						incompatibilities.push({
+						discrepancies.push({
 							identifier: key,
 							mismatch: "valueSchema",
 							view: viewNodeSchema.leafValue,
 							stored: storedNodeSchema.leafValue,
-						} satisfies ValueSchemaIncompatibility);
+						} satisfies ValueSchemaDiscrepancy);
 					}
 				} else {
 					throwUnsupportedNodeType(storedNodeSchema.constructor.name);
@@ -270,7 +268,7 @@ export function getAllowedContentIncompatibilities(
 
 	for (const [key, storedNodeSchema] of stored.nodeSchema) {
 		if (!viewNodeKeys.has(key)) {
-			incompatibilities.push({
+			discrepancies.push({
 				identifier: key,
 				mismatch: "nodeKind",
 				view: undefined,
@@ -280,11 +278,11 @@ export function getAllowedContentIncompatibilities(
 						: storedNodeSchema instanceof ObjectNodeStoredSchema
 							? "object"
 							: "leaf",
-			} satisfies NodeKindIncompatibility);
+			} satisfies NodeKindDiscrepancy);
 		}
 	}
 
-	return incompatibilities;
+	return discrepancies;
 }
 
 /**
@@ -296,8 +294,8 @@ function trackFieldDiscrepancies(
 	view: TreeFieldStoredSchema,
 	stored: TreeFieldStoredSchema,
 	keyOrRoot?: string,
-): FieldIncompatibility[] {
-	const differences: FieldIncompatibility[] = [];
+): FieldDiscrepancy[] {
+	const differences: FieldDiscrepancy[] = [];
 
 	// Only track the symmetric differences of two sets.
 	const findSetDiscrepancies = (
@@ -316,7 +314,7 @@ function trackFieldDiscrepancies(
 			mismatch: "allowedTypes",
 			view: allowedTypesDiscrepancies[0],
 			stored: allowedTypesDiscrepancies[1],
-		} satisfies AllowedTypeIncompatibility);
+		} satisfies AllowedTypeDiscrepancy);
 	}
 
 	if (view.kind !== stored.kind) {
@@ -325,7 +323,7 @@ function trackFieldDiscrepancies(
 			mismatch: "fieldKind",
 			view: view.kind,
 			stored: stored.kind,
-		} satisfies FieldKindIncompatibility);
+		} satisfies FieldKindDiscrepancy);
 	}
 
 	return differences;
@@ -334,8 +332,8 @@ function trackFieldDiscrepancies(
 function trackObjectNodeDiscrepancies(
 	view: ObjectNodeStoredSchema,
 	stored: ObjectNodeStoredSchema,
-): FieldIncompatibility[] {
-	const differences: FieldIncompatibility[] = [];
+): FieldDiscrepancy[] {
+	const differences: FieldDiscrepancy[] = [];
 	const viewFieldKeys = new Set<FieldKey>();
 	/**
 	 * Similar to the logic used for tracking discrepancies between two node schemas, we will identify
@@ -359,7 +357,7 @@ function trackObjectNodeDiscrepancies(
 				mismatch: "fieldKind",
 				view: fieldStoredSchema.kind,
 				stored: storedEmptyFieldSchema.kind,
-			} satisfies FieldKindIncompatibility);
+			} satisfies FieldKindDiscrepancy);
 		} else {
 			differences.push(
 				...trackFieldDiscrepancies(
@@ -382,7 +380,7 @@ function trackObjectNodeDiscrepancies(
 				mismatch: "fieldKind",
 				view: storedEmptyFieldSchema.kind,
 				stored: fieldStoredSchema.kind,
-			} satisfies FieldKindIncompatibility);
+			} satisfies FieldKindDiscrepancy);
 		}
 	}
 
@@ -407,12 +405,12 @@ function trackObjectNodeDiscrepancies(
  * validating internal fields.
  */
 export function isRepoSuperset(view: TreeStoredSchema, stored: TreeStoredSchema): boolean {
-	const incompatibilities = getAllowedContentIncompatibilities(view, stored);
+	const discrepancies = getAllowedContentDiscrepancies(view, stored);
 
-	for (const incompatibility of incompatibilities) {
-		switch (incompatibility.mismatch) {
+	for (const discrepancy of discrepancies) {
+		switch (discrepancy.mismatch) {
 			case "nodeKind": {
-				if (incompatibility.stored !== undefined) {
+				if (discrepancy.stored !== undefined) {
 					// It's fine for the view schema to know of a node type that the stored schema doesn't know about.
 					return false;
 				}
@@ -421,14 +419,14 @@ export function isRepoSuperset(view: TreeStoredSchema, stored: TreeStoredSchema)
 			case "valueSchema":
 			case "allowedTypes":
 			case "fieldKind": {
-				if (!validateFieldIncompatibility(incompatibility)) {
+				if (!validateFieldIncompatibility(discrepancy)) {
 					return false;
 				}
 				break;
 			}
 			case "fields": {
 				if (
-					incompatibility.differences.some(
+					discrepancy.differences.some(
 						(difference) => !validateFieldIncompatibility(difference),
 					)
 				) {
@@ -442,16 +440,16 @@ export function isRepoSuperset(view: TreeStoredSchema, stored: TreeStoredSchema)
 	return true;
 }
 
-function validateFieldIncompatibility(incompatibility: FieldIncompatibility): boolean {
-	switch (incompatibility.mismatch) {
+function validateFieldIncompatibility(discrepancy: FieldDiscrepancy): boolean {
+	switch (discrepancy.mismatch) {
 		case "allowedTypes": {
 			// Since we only track the symmetric difference between the allowed types in the view and
 			// stored schemas, it's sufficient to check if any extra allowed types still exist in the
 			// stored schema.
-			return incompatibility.stored.length === 0;
+			return discrepancy.stored.length === 0;
 		}
 		case "fieldKind": {
-			return posetLte(incompatibility.stored, incompatibility.view, fieldRealizer);
+			return posetLte(discrepancy.stored, discrepancy.view, fieldRealizer);
 		}
 		case "valueSchema": {
 			return false;

package/src/feature-libraries/modular-schema/index.ts

@@ -74,4 +74,7 @@ export type {
 	FieldKindConfiguration,
 	FieldKindConfigurationEntry,
 } from "./fieldKindConfiguration.js";
-export { getAllowedContentIncompatibilities, isRepoSuperset } from "./discrepancies.js";
+export {
+	getAllowedContentDiscrepancies,
+	isRepoSuperset,
+} from "./discrepancies.js";

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/tree";
-export const pkgVersion = "2.10.0-306579";
+export const pkgVersion = "2.10.0-307060";

package/src/shared-tree/treeApi.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { assert, unreachableCase } from "@fluidframework/core-utils/internal";
+import { unreachableCase } from "@fluidframework/core-utils/internal";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 
 import { TreeStatus } from "../feature-libraries/index.js";
@@ -464,10 +464,12 @@ function runTransactionInCheckout<TResult>(
 		switch (constraint.type) {
 			case "nodeInDocument": {
 				const node = getOrCreateInnerNode(constraint.node);
-				assert(
-					treeApi.status(constraint.node) === TreeStatus.InDocument,
-					0x90f /* Attempted to apply "nodeExists" constraint when building a transaction, but the node is not in the document. */,
-				);
+				const nodeStatus = treeApi.status(constraint.node);
+				if (nodeStatus !== TreeStatus.InDocument) {
+					throw new UsageError(
+						`Attempted to add a "nodeInDocument" constraint, but the node is not currently in the document. Node status: ${nodeStatus}`,
+					);
+				}
 				checkout.editor.addNodeExistsConstraint(node.anchorNode);
 				break;
 			}

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

@@ -73,8 +73,8 @@ export function singletonSchema<TScope extends string, TName extends string | nu
 /**
  * Converts an enum into a collection of schema which can be used in a union.
  * @remarks
- * Currently only supports `string` enums.
  * The string value of the enum is used as the name of the schema: callers must ensure that it is stable and unique.
+ * Numeric enums values have the value implicitly converted into a string.
  * Consider making a dedicated schema factory with a nested scope to avoid the enum members colliding with other schema.
  * @example
  * ```typescript
@@ -87,7 +87,7 @@ export function singletonSchema<TScope extends string, TName extends string | nu
  * // Define the schema for each member of the enum using a nested scope to group them together.
  * const ModeNodes = adaptEnum(new SchemaFactory(`${schemaFactory.scope}.Mode`), Mode);
  * // Defined the types of the nodes which correspond to this the schema.
- * type ModeNodes = NodeFromSchema<(typeof ModeNodes.schema)[number]>;
+ * type ModeNodes = TreeNodeFromImplicitAllowedTypes<(typeof ModeNodes.schema)>;
  * // An example schema which has an enum as a child.
  * class Parent extends schemaFactory.object("Parent", {
  * 	// adaptEnum's return value has a ".schema" property can be use as an `AllowedTypes` array allowing any of the members of the enum.
@@ -106,8 +106,6 @@ export function singletonSchema<TScope extends string, TName extends string | nu
  * }
  * ```
  * @privateRemarks
- * TODO:
- * Extend this to support numeric enums.
  * Maybe provide `SchemaFactory.nested` to ease creating nested scopes?
  * @see {@link enumFromStrings} for a similar function that works on arrays of strings instead of an enum.
  * @alpha
@@ -139,9 +137,12 @@ export function adaptEnum<
 
 	// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
 	const factoryOut = <TValue extends Values>(value: TValue) => {
-		return new out[inverse.get(value) ?? fail("missing enum value")]() as NodeFromSchema<
-			ReturnType<typeof singletonSchema<TScope, TValue>>
-		>;
+		return new out[
+			inverse.get(value) ?? fail("missing enum value")
+			// "extends unknown" is required here to handle when TValue is an union: each member of the union should be processed independently.
+		]() as TValue extends unknown
+			? NodeFromSchema<ReturnType<typeof singletonSchema<TScope, TValue>>>
+			: never;
 	};
 	const out = factoryOut as typeof factoryOut & TOut & { readonly schema: SchemaArray };
 	for (const [key, value] of Object.entries(members)) {
@@ -176,7 +177,7 @@ export function adaptEnum<
  * ```typescript
  * const schemaFactory = new SchemaFactory("com.myApp");
  * const Mode = enumFromStrings(schemaFactory, ["Fun", "Cool"]);
- * type Mode = NodeFromSchema<(typeof Mode.schema)[number]>;
+ * type Mode = TreeNodeFromImplicitAllowedTypes<typeof Mode.schema>;
  * const nodeFromString: Mode = Mode("Fun");
  * const nodeFromSchema: Mode = new Mode.Fun();
  *
@@ -198,21 +199,32 @@ export function enumFromStrings<
 		throw new UsageError("All members of enums must have distinct names");
 	}
 
-	type TOut = Record<
-		Members[number],
-		ReturnType<typeof singletonSchema<TScope, Members[number]>>
-	>;
-	// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
-	const factoryOut = <TValue extends Members[number]>(value: TValue) => {
-		return new out[value]() as NodeFromSchema<
-			ReturnType<typeof singletonSchema<TScope, TValue>>
+	type MembersUnion = Members[number];
+
+	// Get all keys of the Members tuple which are numeric strings as union of numbers:
+	type Indexes = Extract<keyof Members, `${number}`> extends `${infer N extends number}`
+		? N
+		: never;
+
+	type TOut = {
+		[Index in Indexes as Members[Index]]: ReturnType<
+			typeof singletonSchema<TScope, Members[Index] & string>
 		>;
 	};
 
-	type SchemaArray = UnionToTuple<TOut[Members[number]]>;
+	// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+	const factoryOut = <TValue extends MembersUnion>(value: TValue) => {
+		// "extends unknown" is required here to handle when TValue is an union: each member of the union should be processed independently.
+		return new recordOut[value]() as TValue extends unknown
+			? NodeFromSchema<ReturnType<typeof singletonSchema<TScope, TValue>>>
+			: never;
+	};
+
+	type SchemaArray = UnionToTuple<MembersUnion extends unknown ? TOut[MembersUnion] : never>;
 	const schemaArray: TreeNodeSchema[] = [];
 
 	const out = factoryOut as typeof factoryOut & TOut & { readonly schema: SchemaArray };
+	const recordOut = out as Record<MembersUnion, new () => unknown>;
 	for (const name of members) {
 		const schema = singletonSchema(factory, name);
 		schemaArray.push(schema);

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

@@ -804,6 +804,8 @@ export class SchemaFactory<
 			name,
 			allowedTypes as T & ImplicitAllowedTypes,
 			true,
+			// Setting this (implicitlyConstructable) to true seems to work ok currently, but not for other node kinds.
+			// Supporting this could be fragile and might break other future changes, so it's being kept as false for now.
 			false,
 		);
 
@@ -811,24 +813,29 @@ export class SchemaFactory<
 			ScopedSchemaName<TScope, Name>,
 			NodeKind.Map,
 			TreeMapNodeUnsafe<T> & WithType<ScopedSchemaName<TScope, Name>, NodeKind.Map>,
-			{
-				/**
-				 * Iterator for the iterable of content for this node.
-				 * @privateRemarks
-				 * Wrapping the constructor parameter for recursive arrays and maps in an inlined object type avoids (for unknown reasons)
-				 * the following compile error when declaring the recursive schema:
-				 * `Function implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions.`
-				 * To benefit from this without impacting the API, the definition of `Iterable` has been inlined as such an object.
-				 *
-				 * If this workaround is kept, ideally this comment would be deduplicated with the other instance of it.
-				 * Unfortunately attempts to do this failed to avoid the compile error this was introduced to solve.
-				 */
-				[Symbol.iterator](): Iterator<
-					[string, InsertableTreeNodeFromImplicitAllowedTypesUnsafe<T>]
-				>;
-			},
-			// Ideally this would be included, but doing so breaks recursive types.
-			// | RestrictiveStringRecord<InsertableTreeNodeFromImplicitAllowedTypesUnsafe<T>>,
+			| {
+					/**
+					 * Iterator for the iterable of content for this node.
+					 * @privateRemarks
+					 * Wrapping the constructor parameter for recursive arrays and maps in an inlined object type avoids (for unknown reasons)
+					 * the following compile error when declaring the recursive schema:
+					 * `Function implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions.`
+					 * To benefit from this without impacting the API, the definition of `Iterable` has been inlined as such an object.
+					 *
+					 * If this workaround is kept, ideally this comment would be deduplicated with the other instance of it.
+					 * Unfortunately attempts to do this failed to avoid the compile error this was introduced to solve.
+					 */
+					[Symbol.iterator](): Iterator<
+						[string, InsertableTreeNodeFromImplicitAllowedTypesUnsafe<T>]
+					>;
+			  }
+			// Ideally this would be
+			// RestrictiveStringRecord<InsertableTreeNodeFromImplicitAllowedTypesUnsafe<T>>,
+			// but doing so breaks recursive types.
+			// Instead we do a less nice version:
+			| {
+					readonly [P in string]: InsertableTreeNodeFromImplicitAllowedTypesUnsafe<T>;
+			  },
 			false,
 			T,
 			undefined

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

@@ -140,7 +140,7 @@ export type ValidateRecursiveSchema<
 				? Iterable<[string, InsertableTreeNodeFromImplicitAllowedTypes<T["info"]>]>
 				: unknown;
 		}[T["kind"]],
-		// ImplicitlyConstructable: recursive types are not implicitly constructable.
+		// ImplicitlyConstructable: recursive types are currently not implicitly constructable.
 		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.
 		{