@fluidframework/tree 2.74.0-370705 → 2.80.0

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

@@ -10,11 +10,12 @@ import { UsageError } from "@fluidframework/telemetry-utils/internal";
 
 import {
 	findAncestor,
+	tagChange,
 	type ChangeFamilyEditor,
 	type GraphCommit,
-	type TaggedChange,
+	type RevisionTag,
 } from "../core/index.js";
-import { getOrCreate } from "../util/index.js";
+import { getLast, getOrCreate, hasSome } from "../util/index.js";
 
 import type { SharedTreeBranch, SharedTreeBranchEvents } from "./branch.js";
 
@@ -92,12 +93,32 @@ export interface TransactionEvents {
 	committing(): void;
 }
 
+/**
+ * Callbacks for transaction lifecycle events.
+ */
+export interface Callbacks {
+	/**
+	 * Called when the current transaction is popped from the {@link TransactionStack | stack}.
+	 */
+	readonly onPop?: OnPop;
+	/**
+	 * Called when a nested transaction is pushed onto the {@link TransactionStack | stack}.
+	 * @remarks
+	 * Transactions may be arbitrarily nested (by {@link TransactionStack.start | start}ing a transaction within a transaction that is already in progress).
+	 * The `OnPush` callback for an (outer) transaction may optionally return another `OnPush` callback that is associated with any nested (inner) transaction(s).
+	 * In that case, the inner `OnPush` will be called when those inner transactions are pushed and the outer `OnPush` will not be called.
+	 * Put another way, a transaction always results in a call to exactly one `OnPush` callback - whichever is closest to the transaction.
+	 * The event "bubbles up" to (and no further past) its first registered callback.
+	 */
+	readonly onPush?: OnPush;
+}
+
 /**
  * A function that will be called when a transaction is pushed to the {@link TransactionStack | stack}.
- * @remarks This function may return {@link OnPop | its complement} - another function that will be called when the transaction is popped from the stack.
+ * @remarks This function may return other functions that will be called when the transaction is popped from the stack or a nested transaction is pushed onto the stack.
  * This function runs just before the transaction begins, so if this is the beginning of an outermost (not nested) transaction then {@link Transactor.isInProgress} will be false during its execution.
  */
-export type OnPush = () => OnPop | void;
+export type OnPush = () => Callbacks | void;
 
 /**
  * A function that will be called when a transaction is popped from the {@link TransactionStack | stack}.
@@ -110,8 +131,8 @@ export type OnPop = (result: TransactionResult) => void;
  * @remarks Using a stack allows transactions to nest - i.e. an inner transaction may be started while an outer transaction is already in progress.
  */
 export class TransactionStack implements Transactor, IDisposable {
-	readonly #stack: (OnPop | void)[] = [];
-	readonly #onPush?: () => OnPop | void;
+	readonly #stack: Callbacks[] = [];
+	readonly #onPush?: OnPush;
 
 	readonly #events = createEmitter<TransactionEvents>();
 	public get events(): Listenable<TransactionEvents> {
@@ -127,7 +148,7 @@ export class TransactionStack implements Transactor, IDisposable {
 	 * Construct a new {@link TransactionStack}.
 	 * @param onPush - A {@link OnPush | function} that will be called when a transaction begins.
 	 */
-	public constructor(onPush?: () => OnPop | void) {
+	public constructor(onPush?: OnPush) {
 		this.#onPush = onPush;
 	}
 
@@ -138,7 +159,9 @@ export class TransactionStack implements Transactor, IDisposable {
 
 	public start(): void {
 		this.ensureNotDisposed();
-		this.#stack.push(this.#onPush?.());
+		const onPushCurrent = hasSome(this.#stack) ? getLast(this.#stack).onPush : this.#onPush;
+		const { onPush, onPop } = onPushCurrent?.() ?? {};
+		this.#stack.push({ onPop, onPush: onPush ?? onPushCurrent });
 		this.#events.emit("started");
 	}
 
@@ -148,7 +171,7 @@ export class TransactionStack implements Transactor, IDisposable {
 			throw new UsageError("No transaction to commit");
 		}
 		this.#events.emit("committing");
-		this.#stack.pop()?.(TransactionResult.Commit);
+		this.#stack.pop()?.onPop?.(TransactionResult.Commit);
 	}
 
 	public abort(): void {
@@ -157,7 +180,7 @@ export class TransactionStack implements Transactor, IDisposable {
 			throw new UsageError("No transaction to abort");
 		}
 		this.#events.emit("aborting");
-		this.#stack.pop()?.(TransactionResult.Abort);
+		this.#stack.pop()?.onPop?.(TransactionResult.Abort);
 	}
 
 	public dispose(): void {
@@ -185,7 +208,6 @@ export class SquashingTransactionStack<
 	TEditor extends ChangeFamilyEditor,
 	TChange,
 > extends TransactionStack {
-	public readonly branch: SharedTreeBranch<TEditor, TChange>;
 	#transactionBranch?: SharedTreeBranch<TEditor, TChange>;
 
 	/**
@@ -243,57 +265,94 @@ export class SquashingTransactionStack<
 	/**
 	 * Construct a new {@link SquashingTransactionStack}.
 	 * @param branch - The {@link SquashingTransactionStack.branch | branch} that will be forked off of when a transaction begins.
-	 * @param squash - Called once when the outer-most transaction is committed to produce a single squashed change from the transaction's commits.
-	 * The change will be applied to the original {@link SquashingTransactionStack.branch | branch}.
-	 * @param onPush - {@link OnPush | A function} that will be called when a transaction is pushed to the {@link TransactionStack | stack}.
+	 * @param onPush - A function that will be called when a transaction is pushed to the {@link TransactionStack | stack}.
 	 */
 	public constructor(
-		branch: SharedTreeBranch<TEditor, TChange>,
-		squash: (commits: GraphCommit<TChange>[]) => TaggedChange<TChange>,
-		onPush?: OnPush,
+		public readonly branch: SharedTreeBranch<TEditor, TChange>,
+		mintRevisionTag: () => RevisionTag,
+		onPush?: () => OnPop | void,
 	) {
-		super(() => {
-			// Keep track of the commit that each transaction was on when it started
-			// TODO:#8603: This may need to be computed differently if we allow rebasing during a transaction.
-			const startHead = this.activeBranch.getHead();
-			const onPop = onPush?.();
-			const transactionBranch = this.#transactionBranch ?? this.branch.fork();
-			this.setTransactionBranch(transactionBranch);
-			transactionBranch.editor.enterTransaction();
-			return (result) => {
-				assert(this.#transactionBranch !== undefined, 0xa98 /* Expected transaction branch */);
-				this.#transactionBranch.editor.exitTransaction();
-				switch (result) {
-					case TransactionResult.Abort:
-						// When a transaction is aborted, roll back all the transaction's changes on the current branch
-						this.#transactionBranch.removeAfter(startHead);
-						break;
-					case TransactionResult.Commit:
-						// If this was the outermost transaction closing...
-						if (!this.isInProgress()) {
-							if (this.#transactionBranch.getHead() !== startHead) {
-								// ...squash all the new commits on the transaction branch into a new commit on the original branch
-								const removedCommits: GraphCommit<TChange>[] = [];
-								findAncestor(
-									[this.#transactionBranch.getHead(), removedCommits],
-									(c) => c === startHead,
-								);
-								branch.apply(squash(removedCommits));
+		super(
+			// Invoked when an outer transaction starts
+			(): Callbacks => {
+				// Keep track of the commit that each transaction was on when it started
+				// TODO:#8603: This may need to be computed differently if we allow rebasing during a transaction.
+				const startHead = this.activeBranch.getHead();
+				const outerOnPop = onPush?.();
+				let transactionRevision: RevisionTag | undefined;
+				const transactionBranch = this.branch.fork(
+					startHead,
+					// Lazily mint the revision tag for the transaction when it is first needed
+					() => (transactionRevision ??= mintRevisionTag()),
+				);
+				this.setTransactionBranch(transactionBranch);
+				transactionBranch.editor.enterTransaction();
+				// Invoked when an outer transaction ends
+				const onOuterTransactionPop: OnPop = (result) => {
+					assert(!this.isInProgress(), 0xcae /* The outer transaction should be ending */);
+					transactionBranch.editor.exitTransaction();
+					switch (result) {
+						case TransactionResult.Abort: {
+							// When a transaction is aborted, roll back all the transaction's changes on the current branch
+							transactionBranch.removeAfter(startHead);
+							break;
+						}
+						case TransactionResult.Commit: {
+							// ...squash all the new commits on the transaction branch into a new commit on the original branch
+							const removedCommits: GraphCommit<TChange>[] = [];
+							findAncestor(
+								[transactionBranch.getHead(), removedCommits],
+								(c) => c === startHead,
+							);
+							if (removedCommits.length > 0) {
+								for (const commit of removedCommits) {
+									assert(
+										commit.revision === transactionRevision,
+										0xcaf /* Unexpected commit in transaction */,
+									);
+								}
+								const squash = this.branch.changeFamily.rebaser.compose(removedCommits);
+								this.branch.apply(tagChange(squash, transactionRevision));
 							}
+							break;
+						}
+						default: {
+							unreachableCase(result);
 						}
-						break;
-					default:
-						unreachableCase(result);
-				}
-				if (!this.isInProgress()) {
-					this.#transactionBranch.dispose();
+					}
+					transactionBranch.dispose();
 					this.setTransactionBranch(undefined);
-				}
-				onPop?.(result);
-			};
-		});
-
-		this.branch = branch;
+					outerOnPop?.(result);
+				};
+				// Invoked when a nested transaction begins
+				const onNestedTransactionPush: OnPush = () => {
+					const nestedStartHead = this.activeBranch.getHead();
+					const nestedOuterOnPop = onPush?.();
+					transactionBranch.editor.enterTransaction();
+					return {
+						// Invoked when a nested transaction ends
+						onPop: (result) => {
+							transactionBranch.editor.exitTransaction();
+							switch (result) {
+								case TransactionResult.Abort: {
+									// When a transaction is aborted, roll back all the transaction's changes on the current branch
+									transactionBranch.removeAfter(nestedStartHead);
+									break;
+								}
+								case TransactionResult.Commit: {
+									break;
+								}
+								default: {
+									unreachableCase(result);
+								}
+							}
+							nestedOuterOnPop?.(result);
+						},
+					};
+				};
+				return { onPop: onOuterTransactionPop, onPush: onNestedTransactionPush };
+			},
+		);
 	}
 
 	/** Updates the transaction branch (and therefore the active branch) and rebinds the branch events. */

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

@@ -5,7 +5,7 @@
 
 import { assert } from "@fluidframework/core-utils/internal";
 
-import type { ChangeRebaser, GraphCommit, RevisionTag } from "../core/index.js";
+import type { ChangeRebaser, GraphCommit } from "../core/index.js";
 
 import type { ChangeEnricherReadonlyCheckout } from "./changeEnricher.js";
 
@@ -33,7 +33,7 @@ export class TransactionEnricher<TChange> {
 	}
 
 	public isTransacting(): boolean {
-		return this.#transactionScopesStart.length !== 0;
+		return this.#transactionScopesStart.length > 0;
 	}
 
 	public startTransaction(): void {
@@ -44,7 +44,7 @@ export class TransactionEnricher<TChange> {
 	 * Commits the current transaction.
 	 * @returns A function which can be used to compute the composed change for that transaction's commits. Undefined if the transaction is still ongoing or contained no committed changes.
 	 */
-	public commitTransaction(): ((revision: RevisionTag) => TChange) | undefined {
+	public commitTransaction(): (() => TChange) | undefined {
 		const commitsCommitted = this.#transactionScopesStart.pop();
 		assert(commitsCommitted !== undefined, 0x985 /* No transaction to commit */);
 		if (this.#transactionScopesStart.length === 0) {
@@ -53,8 +53,7 @@ export class TransactionEnricher<TChange> {
 			}
 			const transactionCommits = this.#transactionCommits;
 			this.#transactionCommits = [];
-			return (revision: RevisionTag) =>
-				this.#rebaser.changeRevision(this.#rebaser.compose(transactionCommits), revision);
+			return () => this.#rebaser.compose(transactionCommits);
 		}
 	}
 
@@ -66,7 +65,7 @@ export class TransactionEnricher<TChange> {
 
 	public addTransactionStep(commit: GraphCommit<TChange>): void {
 		assert(
-			this.#transactionScopesStart.length !== 0,
+			this.#transactionScopesStart.length > 0,
 			0x987 /* No transaction to add a step to */,
 		);
 		const change = this.#enricher.updateChangeEnrichments(commit.change, commit.revision);

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

@@ -44,7 +44,8 @@ export abstract class VersionedSummarizer<TVersion extends number> implements Su
 	) {
 		assert(
 			this.supportedVersions.has(this.writeVersion),
-			`Write version ${this.writeVersion} must be supported.`,
+			0xca6 /* Unsupported write version requested. */,
+			() => `Write version ${this.writeVersion} requested but not supported with key ${key}.`,
 		);
 	}
 
@@ -67,6 +68,11 @@ export abstract class VersionedSummarizer<TVersion extends number> implements Su
 	protected abstract loadInternal(
 		services: IChannelStorageService,
 		parse: SummaryElementParser,
+		/**
+		 * The format version of the summary being loaded, or undefined if this is pre-versioning format,
+		 * i.e., the summary has no version metadata.
+		 */
+		version: TVersion | undefined,
 	): Promise<void>;
 
 	public summarize(props: {
@@ -89,19 +95,20 @@ export abstract class VersionedSummarizer<TVersion extends number> implements Su
 		services: IChannelStorageService,
 		parse: SummaryElementParser,
 	): Promise<void> {
+		let version: TVersion | undefined;
 		if (await services.contains(summarizablesMetadataKey)) {
 			const metadata = await readAndParseSnapshotBlob<SharedTreeSummarizableMetadata>(
 				summarizablesMetadataKey,
 				services,
 				(contents) => parse(contents),
 			);
-			const version = metadata.version as TVersion;
+			version = metadata.version as TVersion;
 			if (!this.supportedVersions.has(version)) {
 				throw new UsageError(`Cannot read version ${version} of shared tree summary.`);
 			}
 		} else if (!this.supportPreVersioningFormat) {
 			throw new UsageError(`Cannot read summary without versioning for shared tree summary.`);
 		}
-		await this.loadInternal(services, parse);
+		await this.loadInternal(services, parse, version);
 	}
 }

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

@@ -222,7 +222,7 @@ export class TreeViewConfiguration<
 			},
 		});
 
-		if (ambiguityErrors.length !== 0) {
+		if (ambiguityErrors.length > 0) {
 			// Duplicate errors are common since when two types conflict, both orders error:
 			const deduplicated = new Set(ambiguityErrors);
 			throw new UsageError(`Ambiguous schema found:\n${[...deduplicated].join("\n")}`);

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

@@ -148,26 +148,23 @@ export function customFromCursor<TChild>(
 		case numberSchema.identifier:
 		case booleanSchema.identifier:
 		case nullSchema.identifier:
-		case stringSchema.identifier:
+		case stringSchema.identifier: {
 			assert(reader.value !== undefined, 0xa50 /* out of schema: missing value */);
 			assert(!isFluidHandle(reader.value), 0xa51 /* out of schema: unexpected FluidHandle */);
 			return reader.value;
-		case handleSchema.identifier:
+		}
+		case handleSchema.identifier: {
 			assert(reader.value !== undefined, 0xa52 /* out of schema: missing value */);
 			assert(isFluidHandle(reader.value), 0xa53 /* out of schema: expected FluidHandle */);
 			return reader.value;
+		}
 		default: {
 			assert(reader.value === undefined, 0xa54 /* out of schema: unexpected value */);
 			const nodeSchema =
 				storedSchema.get(type) ?? fail(0xb2e /* missing schema for type in cursor */);
 			const arrayTypes = tryStoredSchemaAsArray(nodeSchema);
 
-			if (arrayTypes !== undefined) {
-				const fields = inCursorField(reader, EmptyKey, () =>
-					mapCursorField(reader, () => childHandler(reader, options, storedSchema, schema)),
-				);
-				return fields;
-			} else {
+			if (arrayTypes === undefined) {
 				const fields: Record<string, TChild> = {};
 				forEachField(reader, () => {
 					assert(reader.getFieldLength() === 1, 0xa19 /* invalid children number */);
@@ -183,6 +180,11 @@ export function customFromCursor<TChild>(
 					reader.exitNode();
 				});
 				return fields;
+			} else {
+				const fields = inCursorField(reader, EmptyKey, () =>
+					mapCursorField(reader, () => childHandler(reader, options, storedSchema, schema)),
+				);
+				return fields;
 			}
 		}
 	}
@@ -209,11 +211,12 @@ function getKeyFromOptions(
 	schema: ReadonlyMap<string, TreeNodeSchema>,
 ): string | undefined {
 	switch (options) {
-		case KeyEncodingOptions.allStoredKeys:
+		case KeyEncodingOptions.allStoredKeys: {
 			// Since this case might be inside of an unknown optional field,
 			// it must not depend on there being a view schema.
 			// Fortunately, its possible to implement this case without one.
 			return storedKey;
+		}
 		case KeyEncodingOptions.usePropertyKeys:
 		case KeyEncodingOptions.knownStoredKeys: {
 			// Both these cases avoid traversing into unknown optional fields,
@@ -236,8 +239,9 @@ function getKeyFromOptions(
 				return storedKey;
 			}
 		}
-		default:
+		default: {
 			unreachableCase(options);
+		}
 	}
 }
 

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

@@ -154,16 +154,20 @@ function doesNodeKindMatchStoredNodeKind(
 	storedType: SchemaFactoryNodeKind,
 ): boolean {
 	switch (viewKind) {
-		case NodeKind.Leaf:
+		case NodeKind.Leaf: {
 			return storedType === LeafNodeStoredSchema;
+		}
 		case NodeKind.Array:
-		case NodeKind.Object:
+		case NodeKind.Object: {
 			return storedType === ObjectNodeStoredSchema;
+		}
 		case NodeKind.Map:
-		case NodeKind.Record:
+		case NodeKind.Record: {
 			return storedType === MapNodeStoredSchema;
-		default:
+		}
+		default: {
 			unreachableCase(viewKind);
+		}
 	}
 }
 
@@ -291,8 +295,9 @@ function* getNodeDiscrepancies(
 			}
 			break;
 		}
-		default:
+		default: {
 			break;
+		}
 	}
 }
 
@@ -457,18 +462,19 @@ function* computeObjectNodeDiscrepancies(
 		}
 
 		// If the stored schema has a field that's not in the view schema
-		if (!viewKeys.has(fieldKey)) {
-			// When the application has opted into it, we allow viewing documents which have additional
-			// optional fields in the stored schema that are not present in the view schema.
-			if (!view.allowUnknownOptionalFields || schema.kind !== FieldKinds.optional.identifier) {
-				yield {
-					identifier,
-					fieldKey,
-					mismatch: "fieldKind",
-					view: storedEmptyFieldSchema.kind,
-					stored: schema.kind,
-				} satisfies FieldKindDiscrepancy;
-			}
+		// When the application has opted into it, we allow viewing documents which have additional
+		// optional fields in the stored schema that are not present in the view schema.
+		if (
+			!viewKeys.has(fieldKey) &&
+			(!view.allowUnknownOptionalFields || schema.kind !== FieldKinds.optional.identifier)
+		) {
+			yield {
+				identifier,
+				fieldKey,
+				mismatch: "fieldKind",
+				view: storedEmptyFieldSchema.kind,
+				stored: schema.kind,
+			} satisfies FieldKindDiscrepancy;
 		}
 	}
 }

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

@@ -0,0 +1,123 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import type {
+	TreeNode,
+	TreeNodeSchema,
+	NodeKind,
+	TreeNodeSchemaClass,
+	WithType,
+} from "../core/index.js";
+
+/**
+ * Type-erase details of a schema.
+ *
+ * @typeParam TNode - The type to narrow the node to.
+ * Typically {@link TreeNode} intersected with the public interface for the component.
+ * @typeParam ExtraSchemaProperties - Properties of the schema (statics on the schema class) to retain in addition to the basic {@link TreeNodeSchema}.
+ * Typically includes at least one static factory method for creating nodes.
+ * @remarks
+ * This can be used to type erase the details of a schema including the node's type (such as its fields and APIs for modifying those fields).
+ * This is intended for use on component boundaries to support encapsulation of implementation details, including the exact schema.
+ *
+ * This is best applied to a top level "component node" which wraps the actual component content (in a single required object node field) allowing more cases of schema evolution to be carried out as implementation details of the component.
+ *
+ * Since this type-erases the schema details, the remaining API will need to provide ways to construct instances of the node and access its contents.
+ * Typically construction is done via static functions on the schema which can be included in `ExtraSchemaProperties`,
+ * and access to contents is done via properties of TNode (usually methods).
+ *
+ * @example
+ * ```typescript
+ * const schema = new SchemaFactory("com.example");
+ *
+ * interface SquareNode {
+ * 	readonly area: number;
+ * }
+ *
+ * interface SquareSchema {
+ * 	create(sideLength: number): Square;
+ * }
+ *
+ * class SquareInternal
+ * 	extends schema.object("Demo", { hidden: schema.number })
+ * 	implements SquareNode
+ * {
+ * 	public get area(): number {
+ * 		return this.hidden * this.hidden;
+ * 	}
+ *
+ * 	public static create(sideLength: number): SquareInternal {
+ * 		return new SquareInternal({ hidden: sideLength });
+ * 	}
+ * }
+ *
+ * const Square = eraseSchemaDetails<Square, SquareSchema>()(SquareInternal);
+ * type Square = SquareNode & TreeNode & WithType<"com.example.Demo">;
+ * ```
+ * @privateRemarks
+ * See "example" test for an executable version of this example.
+ * @alpha
+ */
+export function eraseSchemaDetails<TNode, ExtraSchemaProperties = unknown>(): <
+	T extends ExtraSchemaProperties & TreeNodeSchema<string, NodeKind, TNode & TreeNode>,
+>(
+	schema: T,
+) => ExtraSchemaProperties &
+	TreeNodeSchema<
+		T["identifier"],
+		NodeKind,
+		TNode & TreeNode & WithType<T["identifier"]>,
+		never,
+		false
+	> {
+	return (schema) => schema as never;
+}
+
+/**
+ * Like {@link eraseSchemaDetails} but allows the returned schema to be subclassed.
+ * @example
+ * ```typescript
+ * const schema = new SchemaFactory("com.example");
+ *
+ * interface SquareInterface {
+ * 	readonly area: number;
+ * }
+ *
+ * class SquareInternal
+ * 	extends schema.object("Demo", { size: schema.number })
+ * 	implements SquareInterface
+ * {
+ * 	public get area(): number {
+ * 		return this.size * this.size;
+ * 	}
+ * }
+ *
+ * class Square extends eraseSchemaDetailsSubclassable<SquareInterface>()(SquareInternal) {
+ * 	public static create(sideLength: number): Square {
+ * 		return new (this as TreeNodeSchema as typeof SquareInternal)({ size: sideLength });
+ * 	}
+ * }
+ *
+ * const square = Square.create(10);
+ * assert.equal(square.area, 100);
+ * ```
+ * @privateRemarks
+ * See "example" test for an executable version of this example.
+ * @alpha
+ */
+export function eraseSchemaDetailsSubclassable<TNode, ExtraSchemaProperties = unknown>(): <
+	T extends ExtraSchemaProperties & TreeNodeSchemaClass<string, NodeKind, TNode & TreeNode>,
+>(
+	schema: T,
+) => ExtraSchemaProperties &
+	TreeNodeSchemaClass<
+		T["identifier"],
+		NodeKind,
+		TNode & TreeNode & WithType<T["identifier"]>,
+		never,
+		false
+	> {
+	return (schema) => schema as never;
+}

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

@@ -38,6 +38,10 @@ export {
 } from "./schemaFactory.js";
 export { SchemaFactoryBeta, type SchemaStaticsBeta } from "./schemaFactoryBeta.js";
 export { SchemaFactoryAlpha } from "./schemaFactoryAlpha.js";
+export {
+	eraseSchemaDetails,
+	eraseSchemaDetailsSubclassable,
+} from "./eraseSchemaDetails.js";
 export type {
 	ValidateRecursiveSchema,
 	FixRecursiveArraySchema,
@@ -149,7 +153,9 @@ export {
 
 export {
 	type TransactionConstraint,
+	type TransactionConstraintAlpha,
 	type NodeInDocumentConstraint,
+	type NoChangeConstraint,
 	type RunTransactionParams,
 	type VoidTransactionCallbackStatus,
 	type TransactionCallbackStatus,

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

@@ -75,12 +75,15 @@ import { type SchemaStatics, schemaStatics } from "./schemaStatics.js";
  */
 export function schemaFromValue(value: TreeValue): TreeNodeSchema {
 	switch (typeof value) {
-		case "boolean":
+		case "boolean": {
 			return booleanSchema;
-		case "number":
+		}
+		case "number": {
 			return numberSchema;
-		case "string":
+		}
+		case "string": {
 			return stringSchema;
+		}
 		case "object": {
 			if (value === null) {
 				return nullSchema;
@@ -88,8 +91,9 @@ export function schemaFromValue(value: TreeValue): TreeNodeSchema {
 			assert(isFluidHandle(value), 0x87e /* invalid TreeValue */);
 			return handleSchema;
 		}
-		default:
+		default: {
 			unreachableCase(value);
+		}
 	}
 }
 
@@ -928,9 +932,7 @@ export function structuralName<const T extends string>(
 	allowedTypes: TreeNodeSchema | readonly TreeNodeSchema[],
 ): `${T}<${string}>` {
 	let inner: string;
-	if (!isReadonlyArray(allowedTypes)) {
-		return structuralName(collectionName, [allowedTypes]);
-	} else {
+	if (isReadonlyArray(allowedTypes)) {
 		const names = allowedTypes.map((t): string => {
 			// Ensure that lazy types (functions) don't slip through here.
 			assert(!isLazy(t), 0x83d /* invalid type provided */);
@@ -943,6 +945,8 @@ export function structuralName<const T extends string>(
 		// Using JSON is a simple way to accomplish this.
 		// The outer `[]` around the result were needed so that a single type name "Any" would not collide with the "any" case which used to exist.
 		inner = JSON.stringify(names);
+	} else {
+		return structuralName(collectionName, [allowedTypes]);
 	}
 	return `${collectionName}<${inner}>`;
 }