@fluidframework/tree 2.23.0-323641 → 2.23.0-325054

package/src/feature-libraries/chunked-forest/emptyChunk.ts

@@ -52,10 +52,10 @@ export const emptyCursor: ChunkedCursor = {
 	mode: CursorLocationType.Fields,
 	[cursorChunk]: emptyChunk,
 	nextField(): boolean {
-		fail("cannot navigate above root");
+		fail(0xafb /* cannot navigate above root */);
 	},
 	exitField(): void {
-		fail("cannot navigate above root");
+		fail(0xafc /* cannot navigate above root */);
 	},
 	skipPendingFields(): boolean {
 		return true;
@@ -70,43 +70,43 @@ export const emptyCursor: ChunkedCursor = {
 		return false;
 	},
 	enterNode(childIndex: number): void {
-		fail("empty cursor has no nodes");
+		fail(0xafd /* empty cursor has no nodes */);
 	},
 	getFieldPath(prefix?: PathRootPrefix): FieldUpPath {
 		return prefixFieldPath(prefix, emptyPath);
 	},
 	getPath(): UpPath | undefined {
-		fail("empty cursor has no nodes");
+		fail(0xafe /* empty cursor has no nodes */);
 	},
 	get fieldIndex(): never {
-		return fail("empty cursor has no nodes");
+		return fail(0xaff /* empty cursor has no nodes */);
 	},
 	get chunkStart(): never {
-		return fail("empty cursor has no nodes");
+		return fail(0xb00 /* empty cursor has no nodes */);
 	},
 	get chunkLength(): never {
-		return fail("empty cursor has no nodes");
+		return fail(0xb01 /* empty cursor has no nodes */);
 	},
 	seekNodes(offset: number): boolean {
-		fail("empty cursor has no nodes");
+		fail(0xb02 /* empty cursor has no nodes */);
 	},
 	nextNode(): boolean {
-		fail("empty cursor has no nodes");
+		fail(0xb03 /* empty cursor has no nodes */);
 	},
 	exitNode(): void {
-		fail("empty cursor has no nodes");
+		fail(0xb04 /* empty cursor has no nodes */);
 	},
 	firstField(): boolean {
-		fail("empty cursor has no nodes");
+		fail(0xb05 /* empty cursor has no nodes */);
 	},
 	enterField(key: FieldKey): void {
-		fail("empty cursor has no nodes");
+		fail(0xb06 /* empty cursor has no nodes */);
 	},
 	get type(): never {
-		return fail("empty cursor has no nodes");
+		return fail(0xb07 /* empty cursor has no nodes */);
 	},
 	get value(): never {
-		return fail("empty cursor has no nodes");
+		return fail(0xb08 /* empty cursor has no nodes */);
 	},
 	atChunkRoot(): boolean {
 		return true;

package/src/feature-libraries/chunked-forest/uniformChunk.ts

@@ -382,7 +382,7 @@ class Cursor extends SynchronousCursor implements ChunkedCursor {
 	}
 
 	public getFieldKey(): FieldKey {
-		return this.fieldKey ?? fail("not in a field");
+		return this.fieldKey ?? fail(0xb09 /* not in a field */);
 	}
 
 	public getFieldLength(): number {
@@ -510,11 +510,13 @@ class Cursor extends SynchronousCursor implements ChunkedCursor {
 	public exitNode(): void {
 		const info = this.nodeInfo(CursorLocationType.Nodes);
 		this.indexOfField =
-			info.indexOfParentField ?? fail("navigation up to root field not yet supported"); // TODO;
+			info.indexOfParentField ??
+			fail(0xb0a /* navigation up to root field not yet supported */); // TODO;
 		this.fieldKey = info.parentField;
 		this.mode = CursorLocationType.Fields;
 		this.moveToPosition(
-			info.indexOfParentPosition ?? fail("navigation up to root field not yet supported"),
+			info.indexOfParentPosition ??
+				fail(0xb0b /* navigation up to root field not yet supported */),
 		); // TODO
 	}
 
@@ -536,7 +538,7 @@ class Cursor extends SynchronousCursor implements ChunkedCursor {
 		this.indexOfField =
 			fieldInfo === undefined
 				? fieldMap.size
-				: (fieldInfo.indexOfParentField ?? fail("children should have parents"));
+				: (fieldInfo.indexOfParentField ?? fail(0xb0c /* children should have parents */));
 		this.fieldKey = key;
 		this.mode = CursorLocationType.Fields;
 	}

package/src/feature-libraries/default-schema/defaultFieldKinds.ts

@@ -42,7 +42,7 @@ export const noChangeHandler: FieldChangeHandler<0> = {
 		rebase: (change: 0, over: 0) => 0,
 	}),
 	codecsFactory: () => noChangeCodecFamily,
-	editor: { buildChildChanges: () => fail("Child changes not supported") },
+	editor: { buildChildChanges: () => fail(0xb0d /* Child changes not supported */) },
 	intoDelta: (change, deltaFromChild: ToDelta): FieldChangeDelta => ({}),
 	relevantRemovedRoots: (change): Iterable<DeltaDetachedNodeId> => [],
 	isEmpty: (change: 0) => true,

package/src/feature-libraries/default-schema/schemaChecker.ts

@@ -90,7 +90,7 @@ export function isNodeInSchema(
 			}
 		}
 	} else {
-		fail("Unknown TreeNodeStoredSchema type");
+		fail(0xb0e /* Unknown TreeNodeStoredSchema type */);
 	}
 
 	return SchemaValidationErrors.NoError;

package/src/feature-libraries/flex-tree/lazyField.ts

@@ -82,12 +82,9 @@ export function makeField(
 
 	const makeFlexTreeField = (): FlexTreeField => {
 		usedAnchor = true;
-		const field = new (kindToClass.get(schema) ?? fail("missing field implementation"))(
-			context,
-			schema,
-			cursor,
-			fieldAnchor,
-		);
+		const field = new (
+			kindToClass.get(schema) ?? fail(0xb0f /* missing field implementation */)
+		)(context, schema, cursor, fieldAnchor);
 		return field;
 	};
 
@@ -97,7 +94,8 @@ export function makeField(
 
 	// For the common case (all but roots), cache field associated with its node's anchor and field key.
 	const anchorNode =
-		context.checkout.forest.anchors.locate(fieldAnchor.parent) ?? fail("missing anchor");
+		context.checkout.forest.anchors.locate(fieldAnchor.parent) ??
+		fail(0xb10 /* missing anchor */);
 
 	// Since anchor-set could be reused across a flex tree context getting disposed, key off the flex tree node not the anchor.
 	const cacheKey = anchorNode.slots.get(flexTreeSlot);
@@ -150,7 +148,7 @@ export abstract class LazyField extends LazyEntity<FieldAnchor> implements FlexT
 		if (fieldAnchor.parent !== undefined) {
 			const anchorNode =
 				context.checkout.forest.anchors.locate(fieldAnchor.parent) ??
-				fail("parent anchor node should always exist since field is under a node");
+				fail(0xb11 /* parent anchor node should always exist since field is under a node */);
 			this.offAfterDestroy = anchorNode.events.on("afterDestroy", () => {
 				this[disposeSymbol]();
 			});

package/src/feature-libraries/flex-tree/lazyNode.ts

@@ -48,7 +48,7 @@ export function makeTree(context: Context, cursor: ITreeSubscriptionCursor): Laz
 	const anchor = cursor.buildAnchor();
 	const anchorNode =
 		context.checkout.forest.anchors.locate(anchor) ??
-		fail("cursor should point to a node that is not the root of the AnchorSet");
+		fail(0xb12 /* cursor should point to a node that is not the root of the AnchorSet */);
 	const cached = anchorNode.slots.get(flexTreeSlot);
 	if (cached !== undefined) {
 		context.checkout.forest.anchors.forget(anchor);
@@ -60,7 +60,8 @@ export function makeTree(context: Context, cursor: ITreeSubscriptionCursor): Laz
 }
 
 function cleanupTree(anchor: AnchorNode): void {
-	const cached = anchor.slots.get(flexTreeSlot) ?? fail("tree should only be cleaned up once");
+	const cached =
+		anchor.slots.get(flexTreeSlot) ?? fail(0xb13 /* tree should only be cleaned up once */);
 	assert(cached instanceof LazyTreeNode, 0x92d /* Expected LazyTreeNode */);
 	cached[disposeSymbol]();
 }
@@ -86,7 +87,8 @@ export class LazyTreeNode extends LazyEntity<Anchor> implements FlexTreeNode {
 		anchor: Anchor,
 	) {
 		super(context, cursor, anchor);
-		this.storedSchema = context.schema.nodeSchema.get(this.schema) ?? fail("missing schema");
+		this.storedSchema =
+			context.schema.nodeSchema.get(this.schema) ?? fail(0xb14 /* missing schema */);
 		assert(cursor.mode === CursorLocationType.Nodes, 0x783 /* must be in nodes mode */);
 		anchorNode.slots.set(flexTreeSlot, this);
 		this.#removeDeleteCallback = anchorNode.events.on("afterDestroy", cleanupTree);
@@ -180,7 +182,7 @@ export class LazyTreeNode extends LazyEntity<Anchor> implements FlexTreeNode {
 			cursor.enterField(key);
 			const nodeSchema =
 				this.context.schema.nodeSchema.get(parentType) ??
-				fail("requested schema that does not exist");
+				fail(0xb15 /* requested schema that does not exist */);
 			fieldSchema = nodeSchema.getFieldSchema(key).kind;
 		}
 

package/src/feature-libraries/indexing/anchorTreeIndex.ts

@@ -359,7 +359,8 @@ export class AnchorTreeIndex<TKey extends TreeIndexKey, TValue>
 				throw new Error("key finder should be pure and functional");
 			}
 			const anchor = nodeCursor.buildAnchor();
-			const anchorNode = this.forest.anchors.locate(anchor) ?? fail("expected anchor node");
+			const anchorNode =
+				this.forest.anchors.locate(anchor) ?? fail(0xb16 /* expected anchor node */);
 
 			// check if this anchor node already exists in the index
 			const existingKey = this.nodeToKey.get(anchorNode);

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

@@ -104,7 +104,8 @@ export function allowsTreeSuperset(
 			allowsFieldSuperset(
 				policy,
 				originalData,
-				original.objectNodeFields.get(originalField) ?? fail("missing expected field"),
+				original.objectNodeFields.get(originalField) ??
+					fail(0xb17 /* missing expected field */),
 				normalizeField(undefined),
 			),
 		bExtra: (supersetField) =>
@@ -112,14 +113,15 @@ export function allowsTreeSuperset(
 				policy,
 				originalData,
 				normalizeField(undefined),
-				superset.objectNodeFields.get(supersetField) ?? fail("missing expected field"),
+				superset.objectNodeFields.get(supersetField) ??
+					fail(0xb18 /* missing expected field */),
 			),
 		same: (sameField) =>
 			allowsFieldSuperset(
 				policy,
 				originalData,
-				original.objectNodeFields.get(sameField) ?? fail("missing expected field"),
-				superset.objectNodeFields.get(sameField) ?? fail("missing expected field"),
+				original.objectNodeFields.get(sameField) ?? fail(0xb19 /* missing expected field */),
+				superset.objectNodeFields.get(sameField) ?? fail(0xb1a /* missing expected field */),
 			),
 	});
 }
@@ -148,7 +150,7 @@ export function allowsFieldSuperset(
 	superset: TreeFieldStoredSchema,
 ): boolean {
 	return withEditor(
-		policy.fieldKinds.get(original.kind) ?? fail("missing kind"),
+		policy.fieldKinds.get(original.kind) ?? fail(0xb1b /* missing kind */),
 	).allowsFieldSuperset(policy, originalData, original.types, superset);
 }
 

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

@@ -35,8 +35,8 @@ export function isNeverFieldRecursive(
 	parentTypeStack: Set<TreeNodeStoredSchema>,
 ): boolean {
 	if (
-		(policy.fieldKinds.get(field.kind) ?? fail("missing field kind")).multiplicity ===
-			Multiplicity.Single &&
+		(policy.fieldKinds.get(field.kind) ?? fail(0xb1c /* missing field kind */))
+			.multiplicity === Multiplicity.Single &&
 		field.types !== undefined
 	) {
 		for (const type of field.types) {
@@ -94,8 +94,10 @@ export function isNeverTreeRecursive(
 		parentTypeStack.add(treeNode);
 		if (treeNode instanceof MapNodeStoredSchema) {
 			return (
-				(policy.fieldKinds.get(treeNode.mapFields.kind) ?? fail("missing field kind"))
-					.multiplicity === Multiplicity.Single
+				(
+					policy.fieldKinds.get(treeNode.mapFields.kind) ??
+					fail(0xb1d /* missing field kind */)
+				).multiplicity === Multiplicity.Single
 			);
 		} else if (treeNode instanceof ObjectNodeStoredSchema) {
 			for (const field of treeNode.objectNodeFields.values()) {

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

@@ -177,7 +177,7 @@ function makeModularChangeCodec(
 				return encodeNodeChangesForJson(node, fieldContext);
 			},
 
-			decodeNode: () => fail("Should not decode nodes during field encoding"),
+			decodeNode: () => fail(0xb1e /* Should not decode nodes during field encoding */),
 		};
 
 		return encodeFieldChangesForJsonI(change, fieldContext);
@@ -193,7 +193,7 @@ function makeModularChangeCodec(
 			const { codec, compiledSchema } = getFieldChangesetCodec(fieldChange.fieldKind);
 			const encodedChange = codec.json.encode(fieldChange.change, context);
 			if (compiledSchema !== undefined && !compiledSchema.check(encodedChange)) {
-				fail("Encoded change didn't pass schema validation.");
+				fail(0xb1f /* Encoded change didn't pass schema validation. */);
 			}
 
 			const fieldKey: FieldKey = field;
@@ -238,7 +238,7 @@ function makeModularChangeCodec(
 		for (const field of encodedChange) {
 			const { codec, compiledSchema } = getFieldChangesetCodec(field.fieldKind);
 			if (compiledSchema !== undefined && !compiledSchema.check(field.change)) {
-				fail("Encoded change didn't pass schema validation.");
+				fail(0xb20 /* Encoded change didn't pass schema validation. */);
 			}
 
 			const fieldId: FieldId = {
@@ -249,7 +249,7 @@ function makeModularChangeCodec(
 			const fieldContext: FieldChangeEncodingContext = {
 				baseContext: context,
 
-				encodeNode: () => fail("Should not encode nodes during field decoding"),
+				encodeNode: () => fail(0xb21 /* Should not encode nodes during field decoding */),
 
 				decodeNode: (encodedNode: EncodedNodeChangeset): NodeId => {
 					const nodeId: NodeId = {

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

@@ -52,7 +52,7 @@ import {
 	idAllocatorFromMaxId,
 	idAllocatorFromState,
 	type RangeQueryResult,
-	getOrAddInMapLazy,
+	getOrCreate,
 	newTupleBTree,
 	mergeTupleBTrees,
 	type TupleBTree,
@@ -321,7 +321,7 @@ export class ModularChangeFamily
 				crossFieldTable.pendingCompositions.nodeIdsToCompose.push([child1, child2]);
 			}
 
-			return child1 ?? child2 ?? fail("Should not compose two undefined nodes");
+			return child1 ?? child2 ?? fail(0xb22 /* Should not compose two undefined nodes */);
 		};
 
 		const amendedChange = rebaser.compose(
@@ -566,7 +566,7 @@ export class ModularChangeFamily
 					setInChangeAtomIdMap(crossFieldTable.newToBaseNodeId, child2, child1);
 					crossFieldTable.pendingCompositions.nodeIdsToCompose.push([child1, child2]);
 				}
-				return child1 ?? child2 ?? fail("Should not compose two undefined nodes");
+				return child1 ?? child2 ?? fail(0xb23 /* Should not compose two undefined nodes */);
 			},
 			idAllocator,
 			manager,
@@ -1426,7 +1426,8 @@ export class ModularChangeFamily
 		constraintState: ConstraintState,
 		revertConstraintState: ConstraintState,
 	): void {
-		const node = nodes.get([nodeId.revision, nodeId.localId]) ?? fail("Unknown node ID");
+		const node =
+			nodes.get([nodeId.revision, nodeId.localId]) ?? fail(0xb24 /* Unknown node ID */);
 		if (node.nodeExistsConstraint !== undefined) {
 			const isNowViolated = inputAttachState === NodeAttachState.Detached;
 			if (node.nodeExistsConstraint.violated !== isNowViolated) {
@@ -1924,7 +1925,7 @@ export function updateRefreshers(
 
 	if (change.builds !== undefined) {
 		for (const [[revision, id], chunk] of change.builds.entries()) {
-			const lengthTree = getOrAddInMapLazy(chunkLengths, revision, () => new BTree());
+			const lengthTree = getOrCreate(chunkLengths, revision, () => new BTree());
 			lengthTree.set(id, chunk.topLevelLength);
 		}
 	}
@@ -3002,7 +3003,7 @@ function fieldChangeFromId(
 	id: FieldId,
 ): FieldChange {
 	const fieldMap = fieldMapFromNodeId(fields, nodes, id.nodeId);
-	return fieldMap.get(id.field) ?? fail("No field exists for the given ID");
+	return fieldMap.get(id.field) ?? fail(0xb25 /* No field exists for the given ID */);
 }
 
 function fieldMapFromNodeId(

package/src/feature-libraries/node-key/mockNodeKeyManager.ts

@@ -27,7 +27,7 @@ export class MockNodeKeyManager implements NodeKeyManager {
 	}
 
 	public localizeNodeKey(key: StableNodeKey): LocalNodeKey {
-		return this.tryLocalizeNodeKey(key) ?? fail("Key is not compressible");
+		return this.tryLocalizeNodeKey(key) ?? fail(0xb26 /* Key is not compressible */);
 	}
 
 	public stabilizeNodeKey(key: LocalNodeKey): StableNodeKey {

package/src/feature-libraries/object-forest/objectForest.ts

@@ -439,7 +439,7 @@ class Cursor extends SynchronousCursor implements ITreeSubscriptionCursor {
 	}
 	public getPath(prefix?: PathRootPrefix): UpPath {
 		assert(this.innerCursor !== undefined, 0x436 /* Cursor must be current to be used */);
-		return this.innerCursor.getPath(prefix) ?? fail("no path when at root");
+		return this.innerCursor.getPath(prefix) ?? fail(0xb27 /* no path when at root */);
 	}
 	public get fieldIndex(): number {
 		assert(this.innerCursor !== undefined, 0x437 /* Cursor must be current to be used */);

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

@@ -27,7 +27,7 @@ export function encodeRepo(repo: TreeStoredSchema): Format {
 		Object.create(null);
 	const rootFieldSchema = encodeFieldSchema(repo.rootFieldSchema);
 	for (const name of [...repo.nodeSchema.keys()].sort()) {
-		const schema = repo.nodeSchema.get(name) ?? fail("missing schema");
+		const schema = repo.nodeSchema.get(name) ?? fail(0xb28 /* missing schema */);
 		Object.defineProperty(nodeSchema, name, {
 			enumerable: true,
 			configurable: true,

package/src/feature-libraries/sequence-field/compose.ts

@@ -540,7 +540,7 @@ export class ComposeQueue {
 			return this.dequeueBase();
 		} else if (areOutputCellsEmpty(baseMark) && areInputCellsEmpty(newMark)) {
 			const baseCellId: ChangeAtomId =
-				getOutputCellId(baseMark) ?? fail("Expected defined output ID");
+				getOutputCellId(baseMark) ?? fail(0xb29 /* Expected defined output ID */);
 
 			if (markEmptiesCells(baseMark) && baseCellId.revision === undefined) {
 				// The base revision should always be defined except when squashing changes into a transaction.

package/src/feature-libraries/sequence-field/invert.ts

@@ -176,7 +176,7 @@ function invertMark(
 			}
 
 			const cellId = getDetachOutputCellId(mark) ?? {
-				revision: mark.revision ?? fail("Revision must be defined"),
+				revision: mark.revision ?? fail(0xb2a /* Revision must be defined */),
 				localId: mark.id,
 			};
 

package/src/feature-libraries/sequence-field/sequenceFieldCodecV1.ts

@@ -145,7 +145,7 @@ export function makeV1Codec(
 						context,
 					);
 				case NoopMarkType:
-					fail("Mark type: NoopMarkType should not be encoded.");
+					fail(0xb2b /* Mark type: NoopMarkType should not be encoded. */);
 				default:
 					unreachableCase(type);
 			}

package/src/feature-libraries/sequence-field/sequenceFieldCodecV2.ts

@@ -132,7 +132,7 @@ export function makeV2CodecHelpers(
 						context,
 					);
 				case NoopMarkType:
-					fail("Mark type: NoopMarkType should not be encoded.");
+					fail(0xb2c /* Mark type: NoopMarkType should not be encoded. */);
 				default:
 					unreachableCase(type);
 			}

package/src/feature-libraries/sequence-field/utils.ts

@@ -747,7 +747,7 @@ export function splitMark<TMark extends Mark>(mark: TMark, length: number): [TMa
 	const markLength = mark.count;
 	const remainder = markLength - length;
 	if (length < 1 || remainder < 1) {
-		fail("Unable to split mark due to lengths");
+		fail(0xb2d /* Unable to split mark due to lengths */);
 	}
 
 	const [effect1, effect2] = splitMarkEffect(mark, length);

package/src/feature-libraries/treeCursorUtils.ts

@@ -345,14 +345,16 @@ class StackCursor<TNode> extends SynchronousCursor implements CursorWithNode<TNo
 
 	public exitField(): void {
 		// assert(this.mode === CursorLocationType.Fields, "can only navigate up from field when in field");
-		this.siblings = this.siblingStack.pop() ?? fail("Unexpected siblingStack.length");
-		this.index = this.indexStack.pop() ?? fail("Unexpected indexStack.length");
+		this.siblings =
+			this.siblingStack.pop() ?? fail(0xac3 /* Unexpected siblingStack.length */);
+		this.index = this.indexStack.pop() ?? fail(0xac4 /* Unexpected indexStack.length */);
 	}
 
 	public exitNode(): void {
 		// assert(this.mode === CursorLocationType.Nodes, "can only navigate up from node when in node");
-		this.siblings = this.siblingStack.pop() ?? fail("Unexpected siblingStack.length");
-		this.index = this.indexStack.pop() ?? fail("Unexpected indexStack.length");
+		this.siblings =
+			this.siblingStack.pop() ?? fail(0xac5 /* Unexpected siblingStack.length */);
+		this.index = this.indexStack.pop() ?? fail(0xac6 /* Unexpected indexStack.length */);
 	}
 
 	public getNode(): TNode {

package/src/index.ts

@@ -73,7 +73,6 @@ export {
 	ForestTypeOptimized,
 	ForestTypeExpensiveDebug,
 	ForestTypeReference,
-	type IChannelView,
 } from "./shared-tree/index.js";
 
 export {
@@ -205,6 +204,23 @@ export {
 	asTreeViewAlpha,
 	type NodeSchemaOptions,
 	type NodeSchemaMetadata,
+	type AssignableTreeFieldFromImplicitField,
+	type ApplyKindAssignment,
+	type DefaultTreeNodeFromImplicitAllowedTypes,
+	type Customizer,
+	type GetTypes,
+	type StrictTypes,
+	type CustomTypes,
+	type CustomizedSchemaTyping,
+	CustomizedTyping,
+	type DefaultInsertableTreeNodeFromImplicitAllowedTypes,
+	customizeSchemaTyping,
+	type GetTypesUnsafe,
+	type DefaultInsertableTreeNodeFromImplicitAllowedTypesUnsafe,
+	type DefaultTreeNodeFromImplicitAllowedTypesUnsafe,
+	type StrictTypesUnsafe,
+	type AssignableTreeFieldFromImplicitFieldUnsafe,
+	type SchemaUnionToIntersection,
 	type schemaStatics,
 	type ITreeAlpha,
 	type TransactionConstraint,
@@ -217,6 +233,8 @@ export {
 	type TransactionResultSuccess,
 	type TransactionResultFailed,
 	rollback,
+	evaluateLazySchema,
+	Component,
 } from "./simple-tree/index.js";
 export {
 	SharedTree,
@@ -259,3 +277,6 @@ export {
 export type { MapNodeInsertableData } from "./simple-tree/index.js";
 
 export type { JsonCompatible, JsonCompatibleObject } from "./util/index.js";
+
+export { JsonAsTree } from "./jsonDomainSchema.js";
+export { FluidSerializableAsTree } from "./serializableDomainSchema.js";

package/src/jsonDomainSchema.ts

@@ -0,0 +1,129 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import {
+	SchemaFactory,
+	type AllowedTypes,
+	type FixRecursiveArraySchema,
+	type TreeNodeFromImplicitAllowedTypes,
+	type ValidateRecursiveSchema,
+} from "./simple-tree/index.js";
+
+const sf = new SchemaFactory("com.fluidframework.json");
+
+/**
+ * Utilities for storing JSON data in {@link TreeNode}s.
+ * @remarks
+ * Schema which replicate the JSON data model with {@link TreeNode}s.
+ *
+ * This allows JSON to be losslessly round-tripped through a tree with the following limitations:
+ *
+ * 1. Only information that would be preserved by JSON.parse is preserved. This means (among other things) that numbers are limited to JavasScript's numeric precision.
+ *
+ * 2. The order of fields on an object is not preserved. The resulting order is arbitrary.
+ *
+ * JSON data can be imported from JSON into this format using `JSON.parse` then {@link TreeAlpha.importConcise} with the {@link JsonAsTree.(Tree:variable)} schema.
+ *
+ * @alpha
+ */
+export namespace JsonAsTree {
+	/**
+	 * {@link AllowedTypes} for primitives types allowed in JSON.
+	 * @alpha
+	 */
+	export const Primitive = [
+		sf.null,
+		sf.boolean,
+		sf.number,
+		sf.string,
+	] as const satisfies AllowedTypes;
+
+	/**
+	 * @alpha
+	 */
+	export type Primitive = TreeNodeFromImplicitAllowedTypes<typeof Primitive>;
+
+	/**
+	 * {@link AllowedTypes} for any content allowed in the {@link JsonAsTree} domain.
+	 * @example
+	 * ```typescript
+	 * const tree = TreeAlpha.importConcise(JsonAsTree.Union, { example: { nested: true }, value: 5 });
+	 * ```
+	 * @alpha
+	 */
+	export const Tree = [() => JsonObject, () => Array, ...Primitive] as const;
+
+	/**
+	 * @alpha
+	 */
+	export type Tree = TreeNodeFromImplicitAllowedTypes<typeof Tree>;
+
+	/**
+	 * Do not use. Exists only as a workaround for {@link https://github.com/microsoft/TypeScript/issues/59550} and {@link https://github.com/microsoft/rushstack/issues/4429}.
+	 * @system @alpha
+	 */
+	export const _APIExtractorWorkaroundObjectBase = sf.mapRecursive("object", Tree);
+
+	/**
+	 * Arbitrary JSON object as a {@link TreeNode}.
+	 * @remarks
+	 * API of the tree node is more aligned with an es6 map than a JS object using its properties like a map.
+	 * @example
+	 * ```typescript
+	 * // Due to TypeScript restrictions on recursive types, the constructor and be somewhat limiting.
+	 * const fromArray = new JsonAsTreeObject([["a", 0]]);
+	 * // Using `importConcise` can work better for JSON data:
+	 * const imported = TreeAlpha.importConcise(JsonAsTree.Object, { a: 0 });
+	 * // Node API is like a Map:
+	 * const value = imported.get("a");
+	 * ```
+	 * @privateRemarks
+	 * Due to https://github.com/microsoft/TypeScript/issues/61270 this can't be named `Object`.
+	 * @sealed @alpha
+	 */
+	export class JsonObject extends _APIExtractorWorkaroundObjectBase {}
+	{
+		type _check = ValidateRecursiveSchema<typeof JsonObject>;
+	}
+
+	/**
+	 * D.ts bug workaround, see {@link FixRecursiveArraySchema}.
+	 * @privateRemarks
+	 * In the past this this had to reference the base type (_APIExtractorWorkaroundArrayBase).
+	 * Testing for this in examples/utils/import-testing now shows it has to reference JsonAsTree.Array instead.
+	 * @system @alpha
+	 */
+	export declare type _RecursiveArrayWorkaroundJsonArray = FixRecursiveArraySchema<
+		typeof Array
+	>;
+
+	/**
+	 * Do not use. Exists only as a workaround for {@link https://github.com/microsoft/TypeScript/issues/59550} and {@link https://github.com/microsoft/rushstack/issues/4429}.
+	 * @system @alpha
+	 */
+	export const _APIExtractorWorkaroundArrayBase = sf.arrayRecursive("array", Tree);
+
+	/**
+	 * Arbitrary JSON array as a {@link TreeNode}.
+	 * @remarks
+	 * This can be imported using {@link TreeAlpha.importConcise}.
+	 * @example
+	 * ```typescript
+	 * // Due to TypeScript restrictions on recursive types, the constructor can be somewhat limiting.
+	 * const usingConstructor = new JsonAsTree.Array(["a", 0, new JsonAsTree.Array([1])]);
+	 * // Using `importConcise` can work better for JSON data:
+	 * const imported = TreeAlpha.importConcise(JsonAsTree.Array, ["a", 0, [1]]);
+	 * // Node API is like an Array:
+	 * const inner: JsonAsTree.Tree = imported[2];
+	 * assert(Tree.is(inner, JsonAsTree.Array));
+	 * const leaf = inner[0];
+	 * ```
+	 * @sealed @alpha
+	 */
+	export class Array extends _APIExtractorWorkaroundArrayBase {}
+	{
+		type _check = ValidateRecursiveSchema<typeof Array>;
+	}
+}

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/tree";
-export const pkgVersion = "2.23.0-323641";
+export const pkgVersion = "2.23.0-325054";