@fluidframework/tree 2.1.1 → 2.2.1

package/src/simple-tree/getSimpleSchema.ts

@@ -0,0 +1,69 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { getOrCreate } from "../util/index.js";
+import type { TreeNodeSchema } from "./core/index.js";
+import type { ImplicitAllowedTypes } from "./schemaTypes.js";
+import type { SimpleTreeSchema } from "./simpleSchema.js";
+import { toSimpleTreeSchema } from "./viewSchemaToSimpleSchema.js";
+
+/**
+ * Cache in which the results of {@link getSimpleSchema} saved.
+ */
+const simpleSchemaCache = new WeakMap<TreeNodeSchema, SimpleTreeSchema>();
+
+/**
+ * Creates a simplified representation of the provided {@link TreeNodeSchema}.
+ *
+ * @remarks Caches the result on the input schema for future calls.
+ *
+ * @example
+ *
+ * A Shared Tree schema like the following:
+ *
+ * ```typescript
+ * class MyObject extends schemaFactory.object("MyObject", {
+ * 	foo: schemaFactory.number,
+ * 	bar: schemaFactory.optional(schemaFactory.string),
+ * });
+ * ```
+ *
+ * Will yield JSON Schema like the following:
+ *
+ * ```typescript
+ * {
+ * 	definitions: [
+ * 		["com.fluidframework.leaf.number", {
+ * 			kind: "leaf",
+ * 			type: "number",
+ * 		}],
+ * 		["com.fluidframework.leaf.string", {
+ * 			kind: "leaf",
+ * 			type: "string",
+ * 		}],
+ * 		["com.myapp.MyObject", {
+ * 			kind: "object",
+ * 			fields: {
+ * 				foo: {
+ * 					kind: "required",
+ * 					allowedTypes: ["com.fluidframework.leaf.number"]
+ * 				},
+ * 				bar: {
+ * 					kind: "optional",
+ * 					allowedTypes: ["com.fluidframework.leaf.string"]
+ * 				},
+ * 			},
+ * 		}],
+ * 	],
+ * 	allowedTypes: ["com.myapp.MyObject"],
+ * }
+ * ```
+ *
+ * @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 {
+	return getOrCreate(simpleSchemaCache, schema, () => toSimpleTreeSchema(schema));
+}

package/src/simple-tree/index.ts

@@ -3,6 +3,23 @@
  * Licensed under the MIT License.
  */
 
+export {
+	typeNameSymbol,
+	typeSchemaSymbol,
+	type WithType,
+	type TreeNodeSchema,
+	NodeKind,
+	type TreeNodeSchemaClass,
+	type TreeNodeSchemaNonClass,
+	type TreeNodeSchemaCore,
+	type TreeChangeEvents,
+	// TreeNode is only type exported, which prevents use of the class object for unsupported use-cases like direct sub-classing and instanceof.
+	// See docs on TreeNode for more details.
+	type TreeNode,
+	type Unhydrated,
+	type InternalTreeNode,
+	isTreeNode,
+} from "./core/index.js";
 export {
 	type ITree,
 	type TreeView,
@@ -11,22 +28,32 @@ export {
 	type ITreeViewConfiguration,
 	type SchemaCompatibilityStatus,
 	type ITreeConfigurationOptions,
-} from "./tree.js";
+	SchemaFactory,
+	type ScopedSchemaName,
+	type ValidateRecursiveSchema,
+	type FixRecursiveArraySchema,
+	adaptEnum,
+	enumFromStrings,
+	singletonSchema,
+	typedObjectValues,
+	type EmptyObject,
+	test_RecursiveObject,
+	test_RecursiveObject_base,
+	test_RecursiveObjectPojoMode,
+	treeNodeApi,
+	type TreeNodeApi,
+	cursorFromInsertable,
+	createFromInsertable,
+} from "./api/index.js";
 export {
-	type TreeNodeSchema,
 	type NodeFromSchema,
-	NodeKind,
-	type TreeNodeSchemaClass,
-	type TreeNodeSchemaNonClass,
-	type TreeNodeSchemaCore,
+	isTreeNodeSchemaClass,
 	type ImplicitFieldSchema,
 	type TreeFieldFromImplicitField,
 	type ImplicitAllowedTypes,
 	type TreeNodeFromImplicitAllowedTypes,
 	type InsertableTreeNodeFromImplicitAllowedTypes,
 	type TreeLeafValue,
-	typeNameSymbol,
-	type WithType,
 	type AllowedTypes,
 	FieldKind,
 	FieldSchema,
@@ -38,10 +65,8 @@ export {
 	normalizeFieldSchema,
 	type ApplyKind,
 } from "./schemaTypes.js";
-export { SchemaFactory, type ScopedSchemaName } from "./schemaFactory.js";
-export { getFlexNode, tryDisposeTreeNode } from "./proxyBinding.js";
-export { treeNodeApi, type TreeNodeApi } from "./treeNodeApi.js";
-export { toFlexSchema, cursorFromUnhydratedRoot } from "./toFlexSchema.js";
+export { getOrCreateInnerNode, tryDisposeTreeNode } from "./proxyBinding.js";
+export { toFlexSchema } from "./toFlexSchema.js";
 export type {
 	FieldHasDefaultUnsafe,
 	ObjectFromSchemaRecordUnsafe,
@@ -57,32 +82,14 @@ export type {
 	InsertableTypedNodeUnsafe,
 	NodeBuilderDataUnsafe,
 	NodeFromSchemaUnsafe,
+	ReadonlyMapInlined,
 } from "./typesUnsafe.js";
-export type { ValidateRecursiveSchema } from "./schemaFactoryRecursive.js";
 export {
-	getProxyForField,
+	getTreeNodeForField,
 	type InsertableContent,
 	prepareContentForHydration,
 } from "./proxies.js";
 
-export {
-	adaptEnum,
-	enumFromStrings,
-	singletonSchema,
-	typedObjectValues,
-} from "./schemaCreationUtilities.js";
-
-// Exporting the schema (RecursiveObject) to test that recursive types are working correctly.
-// These are `@internal` so they can't be included in the `InternalClassTreeTypes` due to https://github.com/microsoft/rushstack/issues/3639
-export {
-	RecursiveObject as test_RecursiveObject,
-	base as test_RecursiveObject_base,
-	RecursiveObjectPojoMode as test_RecursiveObjectPojoMode,
-} from "./testRecursiveDomain.js";
-
-// TreeNode is only type exported, which prevents use of the class object for unsupported use-cases like direct sub-classing and instancof.
-// See docs on TreeNode for more details.
-export type { TreeChangeEvents, TreeNode, Unhydrated, InternalTreeNode } from "./types.js";
 export {
 	TreeArrayNode,
 	IterableTreeArrayContent,
@@ -95,5 +102,23 @@ export {
 	type TreeObjectNode,
 	setField,
 } from "./objectNode.js";
-export type { TreeMapNode } from "./mapNode.js";
+export type { TreeMapNode, MapNodeInsertableData } from "./mapNode.js";
 export { mapTreeFromNodeData } from "./toMapTree.js";
+export type { SimpleTreeSchema } from "./simpleSchema.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";

package/src/simple-tree/jsonSchema.ts

@@ -0,0 +1,230 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import type { NodeKind } from "./core/index.js";
+
+/**
+ * The fully-qualified {@link TreeNodeSchemaCore.identifier}.
+ * @alpha
+ */
+export type JsonSchemaId = string;
+
+/**
+ * Reference string pointing to a definition in the schema.
+ * Should be the fully-qualified {@link TreeNodeSchemaCore.identifier}.
+ * @remarks Of the form `#/$defs/<schema-identifier>`, where the `schema-identifier` is the fully-qualified {@link TreeNodeSchemaCore.identifier}.
+ * @example Schema `com.myapp.foo` would be referenced via `#/$defs/com.myapp.foo`.
+ * @alpha
+ */
+export type JsonRefPath = `#/$defs/${JsonSchemaId}`;
+
+/**
+ * JSON entity type.
+ * @see {@link https://json-schema.org/draft/2020-12/json-schema-core#name-instance-data-model}.
+ * @alpha
+ */
+export type JsonSchemaType = "object" | "array" | JsonLeafSchemaType;
+
+/**
+ * JSON primitive types.
+ * @see {@link https://json-schema.org/draft/2020-12/json-schema-core#name-instance-data-model}.
+ * @alpha
+ */
+export type JsonLeafSchemaType = "string" | "number" | "boolean" | "null";
+
+/**
+ * Base interface for node schemas represented in {@link https://json-schema.org/draft/2020-12/json-schema-core | JSON Schema} format.
+ *
+ * @sealed
+ * @alpha
+ */
+export interface JsonNodeSchemaBase<
+	TNodeKind extends NodeKind,
+	TJsonSchemaType extends JsonSchemaType,
+> {
+	/**
+	 * Kind of {@link TreeNodeSchema} this JSON Schema entry represents.
+	 *
+	 * @remarks There is not a 1:1 mapping between {@link TreeNodeSchema} types and JSON Schema types.
+	 * This is used to disambiguate the type of {@link TreeNodeSchema} this JSON Schema maps to.
+	 *
+	 * Note: This property name is not a part of the JSON Schema spec. This is a Fluid-specific extension.
+	 */
+	readonly _treeNodeSchemaKind: TNodeKind;
+
+	/**
+	 * {@inheritDoc JsonSchemaType}
+	 */
+	readonly type: TJsonSchemaType;
+}
+
+/**
+ * JSON Schema for an object node.
+ *
+ * @see {@link https://json-schema.org/draft/2020-12/json-schema-core#name-instance-data-model}.
+ *
+ * @sealed
+ * @alpha
+ */
+export interface JsonObjectNodeSchema extends JsonNodeSchemaBase<NodeKind.Object, "object"> {
+	/**
+	 * Object fields.
+	 * @remarks Required fields should have a corresponding entry in {@link JsonObjectNodeSchema.required}.
+	 * @see {@link https://json-schema.org/draft/2020-12/json-schema-core#name-properties}.
+	 */
+	readonly properties: Record<string, JsonFieldSchema>;
+
+	/**
+	 * List of keys for required fields.
+	 *
+	 * @remarks
+	 * Optional fields should not be included in this list.
+	 * Each key specified must have an entry in {@link JsonObjectNodeSchema.properties}.
+	 */
+	readonly required?: string[];
+
+	/**
+	 * Whether or not additional properties (properties not specified by the schema) are allowed in objects of this type.
+	 * @see {@link https://json-schema.org/draft/2020-12/json-schema-core#name-additionalproperties}.
+	 */
+	readonly additionalProperties?: boolean;
+}
+
+/**
+ * JSON Schema for an array node.
+ *
+ * @see {@link https://json-schema.org/draft/2020-12/json-schema-core#name-instance-data-model}.
+ *
+ * @sealed
+ * @alpha
+ */
+export interface JsonArrayNodeSchema extends JsonNodeSchemaBase<NodeKind.Array, "array"> {
+	/**
+	 * The kinds of items allowed under the array.
+	 * @remarks Always represented via references to {@link JsonTreeSchema.$defs}.
+	 *
+	 * @see {@link https://json-schema.org/draft/2020-12/json-schema-core#name-items}.
+	 */
+	readonly items: {
+		/**
+		 * The kinds of items allowed under the array.
+		 * @remarks Always represented via references to {@link JsonTreeSchema.$defs}.
+		 * @see {@link https://json-schema.org/draft/2020-12/json-schema-core#name-anyof}.
+		 */
+		anyOf: JsonSchemaRef[];
+	};
+}
+
+/**
+ * JSON Schema for a map node.
+ *
+ * @remarks Special case for map nodes, which do not have a native JSON schema corollary.
+ *
+ * @see {@link https://json-schema.org/draft/2020-12/json-schema-core#name-instance-data-model}.
+ *
+ * @sealed
+ * @alpha
+ */
+export interface JsonMapNodeSchema extends JsonNodeSchemaBase<NodeKind.Map, "object"> {
+	/**
+	 * Used to control the types of properties that can appear in the "object" representation of the map.
+	 * @see {@link https://json-schema.org/draft/2020-12/json-schema-core#name-patternproperties}.
+	 */
+	readonly patternProperties: {
+		/**
+		 * Types allowed in the map.
+		 * @remarks This format allows for any (JSON-compliant) key, but restricts the allowed types to only those specified.
+		 */
+		"^.*$": JsonFieldSchema;
+	};
+}
+
+/**
+ * JSON Schema for a leaf node.
+ *
+ * @see {@link https://json-schema.org/draft/2020-12/json-schema-core#name-instance-data-model}.
+ *
+ * @sealed
+ * @alpha
+ */
+export interface JsonLeafNodeSchema
+	extends JsonNodeSchemaBase<NodeKind.Leaf, JsonLeafSchemaType> {
+	/**
+	 * Primitive type.
+	 * @see {@link https://json-schema.org/draft/2020-12/json-schema-core#name-instance-data-model}.
+	 */
+	readonly type: JsonLeafSchemaType;
+}
+
+/**
+ * Type entry containing a reference to a definition in the schema.
+ *
+ * @see {@link https://json-schema.org/draft/2020-12/json-schema-core#name-schema-references}.
+ *
+ * @sealed
+ * @alpha
+ */
+export interface JsonSchemaRef {
+	/**
+	 * Reference to a definition in the schema.
+	 * @see {@link https://json-schema.org/draft/2020-12/json-schema-core#name-direct-references-with-ref}.
+	 */
+	$ref: JsonRefPath;
+}
+
+/**
+ * {@link https://json-schema.org/draft/2020-12/json-schema-core | JSON Schema} representation of a {@link TreeNodeSchema}.
+ *
+ * @alpha
+ */
+export type JsonNodeSchema =
+	| JsonLeafNodeSchema
+	| JsonMapNodeSchema
+	| JsonArrayNodeSchema
+	| JsonObjectNodeSchema;
+
+/**
+ *{@link https://json-schema.org/draft/2020-12/json-schema-core | JSON Schema} representation of a {@link FieldSchema}.
+ *
+ * @sealed
+ * @alpha
+ */
+export interface JsonFieldSchema {
+	/**
+	 * The kinds of items allowed under the field.
+	 * @remarks Always represented via references to {@link JsonTreeSchema.$defs}.
+	 * @see {@link https://json-schema.org/draft/2020-12/json-schema-core#name-anyof}.
+	 */
+	readonly anyOf: JsonSchemaRef[];
+}
+
+/**
+ * {@link https://json-schema.org/draft/2020-12/json-schema-core | JSON Schema} representation of a tree schema.
+ *
+ * @remarks
+ * Includes the complete set of definitions reachable from the "root" schema.
+ *
+ * Note: This representation only uses a limited subset of supported JSON Schema features.
+ * It is scoped to a format that can be used to sufficiently represent supported SharedTree schema.
+ *
+ * Also note that this schema format contains Fluid-specific extensions, such as the {@link JsonNodeSchemaBase._treeNodeSchemaKind}
+ * property, meaning that it is not a *strict* subset.
+ * When using these schemas with validation tools (for example, {@link https://ajv.js.org/}), you will need to opt out
+ * of *strict* validation to ensure extra properties are allowed.
+ *
+ * @privateRemarks
+ * Extending JSON Schema is permitted by the spec.
+ * See {@link https://json-schema.org/draft/2020-12/json-schema-core#name-extending-json-schema}.
+ *
+ * @sealed
+ * @alpha
+ */
+export interface JsonTreeSchema extends JsonFieldSchema {
+	/**
+	 * The set of definitions reachable from this schema's root.
+	 * @see {@link https://json-schema.org/draft/2020-12/json-schema-core#name-schema-re-use-with-defs}
+	 */
+	readonly $defs: Record<JsonSchemaId, JsonNodeSchema>;
+}

package/src/simple-tree/leafNodeSchema.ts

@@ -13,9 +13,12 @@ import {
 	isFlexTreeNode,
 	valueSchemaAllows,
 } from "../feature-libraries/index.js";
-
-import { setFlexSchemaFromClassSchema } from "./schemaCaching.js";
-import { NodeKind, type TreeNodeSchema, type TreeNodeSchemaNonClass } from "./schemaTypes.js";
+import {
+	setFlexSchemaFromClassSchema,
+	NodeKind,
+	type TreeNodeSchema,
+	type TreeNodeSchemaNonClass,
+} from "./core/index.js";
 
 type UnbrandedName<T extends FlexLeafNodeSchema> = T["name"] extends TreeNodeSchemaIdentifier<
 	infer Name extends string

package/src/simple-tree/mapNode.ts

@@ -3,38 +3,42 @@
  * Licensed under the MIT License.
  */
 
-import type { TreeNodeSchemaIdentifier } from "../core/index.js";
 import {
 	type FlexMapNodeSchema,
 	type FlexTreeNode,
 	type MapTreeNode,
-	cursorForMapTreeNode,
 	getOrCreateMapTreeNode,
 	getSchemaAndPolicy,
-	isMapTreeNode,
 } from "../feature-libraries/index.js";
 import {
+	type FactoryContent,
 	type InsertableContent,
-	getProxyForField,
-	markContentType,
+	getTreeNodeForField,
 	prepareContentForHydration,
 } from "./proxies.js";
-import { getFlexNode } from "./proxyBinding.js";
-import { getSimpleNodeSchema } from "./schemaCaching.js";
+import { getOrCreateInnerNode } from "./proxyBinding.js";
+import { getSimpleNodeSchema } from "./core/index.js";
 import {
-	NodeKind,
+	createFieldSchema,
+	FieldKind,
 	type ImplicitAllowedTypes,
 	type InsertableTreeNodeFromImplicitAllowedTypes,
+	type TreeNodeFromImplicitAllowedTypes,
+} from "./schemaTypes.js";
+import {
+	NodeKind,
 	type TreeNodeSchemaClass,
-	type WithType,
 	type TreeNodeSchema,
-	type TreeNodeFromImplicitAllowedTypes,
+	type WithType,
+	// eslint-disable-next-line import/no-deprecated
 	typeNameSymbol,
-} from "./schemaTypes.js";
+	type TreeNode,
+	typeSchemaSymbol,
+} from "./core/index.js";
 import { mapTreeFromNodeData } from "./toMapTree.js";
-import { type MostDerivedData, type TreeNode, TreeNodeValid } from "./types.js";
 import { getFlexSchema } from "./toFlexSchema.js";
-import { UsageError } from "@fluidframework/telemetry-utils/internal";
+import { brand, count, type RestrictiveReadonlyRecord } from "../util/index.js";
+import { TreeNodeValid, type MostDerivedData } from "./treeNodeValid.js";
 
 /**
  * A map of string keys to tree objects.
@@ -127,7 +131,7 @@ const handler: ProxyHandler<TreeMapNode> = {
 };
 
 abstract class CustomMapNodeBase<const T extends ImplicitAllowedTypes> extends TreeNodeValid<
-	Iterable<[string, InsertableTreeNodeFromImplicitAllowedTypes<T>]>
+	MapNodeInsertableData<T>
 > {
 	public static readonly kind = NodeKind.Map;
 
@@ -135,53 +139,50 @@ abstract class CustomMapNodeBase<const T extends ImplicitAllowedTypes> extends T
 		return this.entries();
 	}
 	public delete(key: string): void {
-		const node = getFlexNode(this);
-		if (isMapTreeNode(node)) {
-			throw new UsageError(`A map cannot be mutated before being inserted into the tree`);
-		}
-
-		node.delete(key);
+		const field = getOrCreateInnerNode(this).getBoxed(key);
+		field.editor.set(undefined, field.length === 0);
 	}
 	public *entries(): IterableIterator<[string, TreeNodeFromImplicitAllowedTypes<T>]> {
-		const node = getFlexNode(this);
+		const node = getOrCreateInnerNode(this);
 		for (const key of node.keys()) {
-			yield [key, getProxyForField(node.getBoxed(key)) as TreeNodeFromImplicitAllowedTypes<T>];
+			yield [
+				key,
+				getTreeNodeForField(node.getBoxed(key)) as TreeNodeFromImplicitAllowedTypes<T>,
+			];
 		}
 	}
 	public get(key: string): TreeNodeFromImplicitAllowedTypes<T> {
-		const node = getFlexNode(this);
+		const node = getOrCreateInnerNode(this);
 		const field = node.getBoxed(key);
-		return getProxyForField(field) as TreeNodeFromImplicitAllowedTypes<T>;
+		return getTreeNodeForField(field) as TreeNodeFromImplicitAllowedTypes<T>;
 	}
 	public has(key: string): boolean {
-		const node = getFlexNode(this);
-		return node.has(key);
+		return getOrCreateInnerNode(this).tryGetField(brand(key)) !== undefined;
 	}
 	public keys(): IterableIterator<string> {
-		const node = getFlexNode(this);
+		const node = getOrCreateInnerNode(this);
 		return node.keys();
 	}
 	public set(key: string, value: InsertableTreeNodeFromImplicitAllowedTypes<T>): TreeMapNode {
-		const node = getFlexNode(this);
-		if (isMapTreeNode(node)) {
-			throw new UsageError(`A map cannot be mutated before being inserted into the tree`);
-		}
-
+		const node = getOrCreateInnerNode(this);
 		const classSchema = getSimpleNodeSchema(node.schema);
 		const mapTree = mapTreeFromNodeData(
-			value as InsertableContent,
-			classSchema.info as ImplicitAllowedTypes,
-			node.context.nodeKeyManager,
+			value as InsertableContent | undefined,
+			createFieldSchema(FieldKind.Optional, classSchema.info as ImplicitAllowedTypes),
+			node.context?.nodeKeyManager,
 			getSchemaAndPolicy(node),
 		);
 
-		prepareContentForHydration(mapTree, node.context.checkout.forest);
-		const cursor = mapTree !== undefined ? cursorForMapTreeNode(mapTree) : undefined;
-		node.set(key, cursor);
+		const field = node.getBoxed(key);
+		if (node.context !== undefined) {
+			prepareContentForHydration(mapTree, node.context.checkout.forest);
+		}
+
+		field.editor.set(mapTree, field.length === 0);
 		return this;
 	}
 	public get size(): number {
-		return getFlexNode(this).size;
+		return count(getOrCreateInnerNode(this).keys());
 	}
 	public *values(): IterableIterator<TreeNodeFromImplicitAllowedTypes<T>> {
 		for (const [, value] of this.entries()) {
@@ -193,8 +194,8 @@ abstract class CustomMapNodeBase<const T extends ImplicitAllowedTypes> extends T
 		callbackFn: (value: TreeNodeFromImplicitAllowedTypes<T>, key: string, map: TThis) => void,
 		thisArg?: unknown,
 	): void {
-		for (const field of getFlexNode(this).boxedIterator()) {
-			const node = getProxyForField(field) as TreeNodeFromImplicitAllowedTypes<T>;
+		for (const field of getOrCreateInnerNode(this).boxedIterator()) {
+			const node = getTreeNodeForField(field) as TreeNodeFromImplicitAllowedTypes<T>;
 			callbackFn.call(thisArg, node, field.key, this);
 		}
 	}
@@ -239,10 +240,7 @@ export function mapSchema<
 		): MapTreeNode {
 			return getOrCreateMapTreeNode(
 				flexSchema,
-				mapTreeFromNodeData(
-					copyContent(flexSchema.name, input as Iterable<[string, InsertableContent]>),
-					this as unknown as ImplicitAllowedTypes,
-				),
+				mapTreeFromNodeData(input as FactoryContent, this as unknown as ImplicitAllowedTypes),
 			);
 		}
 
@@ -257,26 +255,29 @@ export function mapSchema<
 		public static readonly implicitlyConstructable: ImplicitlyConstructable =
 			implicitlyConstructable;
 
+		// eslint-disable-next-line import/no-deprecated
 		public get [typeNameSymbol](): TName {
 			return identifier;
 		}
+		public get [typeSchemaSymbol](): typeof schemaErased {
+			return schema.constructorCached?.constructor as unknown as typeof schemaErased;
+		}
 	}
 	const schemaErased: TreeNodeSchemaClass<
 		TName,
 		NodeKind.Map,
-		TreeMapNode<T> & WithType<TName>,
-		Iterable<[string, InsertableTreeNodeFromImplicitAllowedTypes<T>]>,
+		TreeMapNode<T> & WithType<TName, NodeKind.Map>,
+		MapNodeInsertableData<T>,
 		ImplicitlyConstructable,
 		T
 	> = schema;
 	return schemaErased;
 }
 
-function copyContent<T>(
-	typeName: TreeNodeSchemaIdentifier,
-	content: Iterable<[string, T]>,
-): Map<string, T> {
-	const copy = new Map(content);
-	markContentType(typeName, copy);
-	return copy;
-}
+/**
+ * Content which can be used to construct a Map node, explicitly or implicitly.
+ * @system @public
+ */
+export type MapNodeInsertableData<T extends ImplicitAllowedTypes> =
+	| Iterable<readonly [string, InsertableTreeNodeFromImplicitAllowedTypes<T>]>
+	| RestrictiveReadonlyRecord<string, InsertableTreeNodeFromImplicitAllowedTypes<T>>;