@fluidframework/tree 2.23.0-323641 → 2.23.0

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

package/src/serializableDomainSchema.ts

@@ -0,0 +1,121 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import type { IFluidHandle } from "@fluidframework/core-interfaces";
+import {
+	SchemaFactory,
+	type FixRecursiveArraySchema,
+	type TreeNodeFromImplicitAllowedTypes,
+	type ValidateRecursiveSchema,
+} from "./simple-tree/index.js";
+import type { JsonCompatible } from "./util/index.js";
+
+const sf = new SchemaFactory("com.fluidframework.serializable");
+
+/**
+ * Utilities for storing {@link FluidSerializableAsTree.Data|Fluid Serializable data} in {@link TreeNode}s.
+ *
+ * Same as {@link JsonAsTree} except allows {@link @fluidframework/core-interfaces#(IFluidHandle:interface)}s.
+ * @remarks
+ * Schema which replicate the Fluid Serializable data model with {@link TreeNode}s.
+ *
+ * Fluid Serializable data can be imported from the {@link FluidSerializableAsTree.Data|Fluid Serializable format} into this format using {@link TreeAlpha.importConcise} with the {@link FluidSerializableAsTree.(Tree:variable)} schema.
+ * @internal
+ */
+export namespace FluidSerializableAsTree {
+	/**
+	 * Data which can be serialized by Fluid.
+	 * @remarks
+	 * Can be encoded as a {@link FluidSerializableAsTree.(Tree:type)} using {@link TreeAlpha.importConcise}.
+	 * @internal
+	 */
+	export type Data = JsonCompatible<IFluidHandle>;
+
+	/**
+	 * {@link AllowedTypes} for any content allowed in the {@link FluidSerializableAsTree} domain.
+	 * @example
+	 * ```typescript
+	 * const tree = TreeAlpha.importConcise(FluidSerializableAsTree.Tree, { example: { nested: true }, value: 5 });
+	 * ```
+	 * @internal
+	 */
+	export const Tree = [
+		() => FluidSerializableObject,
+		() => Array,
+		...SchemaFactory.leaves,
+	] as const;
+
+	/**
+	 * @internal
+	 */
+	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 @internal
+	 */
+	export const _APIExtractorWorkaroundObjectBase = sf.mapRecursive("object", Tree);
+
+	/**
+	 * Arbitrary Fluid Serializable 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 Fluid Serializable data:
+	 * const imported = TreeAlpha.importConcise(FluidSerializableAsTree.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 @internal
+	 */
+	export class FluidSerializableObject extends _APIExtractorWorkaroundObjectBase {}
+	{
+		type _check = ValidateRecursiveSchema<typeof FluidSerializableObject>;
+	}
+
+	/**
+	 * 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 FluidSerializableAsTree.Array instead.
+	 * @system @internal
+	 */
+	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 @internal
+	 */
+	export const _APIExtractorWorkaroundArrayBase = sf.arrayRecursive("array", Tree);
+
+	/**
+	 * Arbitrary Fluid Serializable 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 FluidSerializableAsTree.Array(["a", 0, new FluidSerializableAsTree.Array([1])]);
+	 * // Using `importConcise` can work better for Fluid Serializable data:
+	 * const imported = TreeAlpha.importConcise(FluidSerializableAsTree.Array, ["a", 0, [1]]);
+	 * // Node API is like an Array:
+	 * const inner: FluidSerializableAsTree.Tree = imported[2];
+	 * assert(Tree.is(inner, FluidSerializableAsTree.Array));
+	 * const leaf = inner[0];
+	 * ```
+	 * @sealed @internal
+	 */
+	export class Array extends _APIExtractorWorkaroundArrayBase {}
+	{
+		type _check = ValidateRecursiveSchema<typeof Array>;
+	}
+}

package/src/shared-tree/index.ts

@@ -21,7 +21,6 @@ export {
 	ForestTypeOptimized,
 	ForestTypeExpensiveDebug,
 	ForestTypeReference,
-	type IChannelView,
 } from "./sharedTree.js";
 
 export {

package/src/shared-tree/schematizeTree.ts

@@ -198,7 +198,7 @@ export function initialize(checkout: ITreeCheckout, treeContent: TreeStoredConte
 					break;
 				}
 				default: {
-					fail("unexpected root field kind during initialize");
+					fail(0xac7 /* unexpected root field kind during initialize */);
 				}
 			}
 		});

package/src/shared-tree/sharedTree.ts

@@ -13,10 +13,10 @@ import type {
 	IChannelAttributes,
 	IFluidDataStoreRuntime,
 	IChannelStorageService,
-	IChannel,
 } from "@fluidframework/datastore-definitions/internal";
 import {
 	SharedObject,
+	type IChannelView,
 	type IFluidSerializer,
 	type ISharedObject,
 } from "@fluidframework/shared-object-base/internal";
@@ -101,13 +101,7 @@ import { SharedTreeChangeFamily } from "./sharedTreeChangeFamily.js";
 import type { SharedTreeChange } from "./sharedTreeChangeTypes.js";
 import type { SharedTreeEditBuilder } from "./sharedTreeEditBuilder.js";
 import { type TreeCheckout, type BranchableTree, createTreeCheckout } from "./treeCheckout.js";
-import {
-	Breakable,
-	breakingClass,
-	fail,
-	throwIfBroken,
-	type WithBreakable,
-} from "../util/index.js";
+import { Breakable, breakingClass, fail, throwIfBroken } from "../util/index.js";
 
 /**
  * Copy of data from an {@link ITreePrivate} at some point in time.
@@ -133,14 +127,6 @@ export interface SharedTreeContentSnapshot {
 	readonly removed: [string | number | undefined, number, JsonableTree][];
 }
 
-/**
- * Information about a Fluid channel.
- * @privateRemarks
- * This is distinct from {@link IChannel} as it omits the APIs used by the runtime to manage the channel and instead only has things which are useful (and safe) to expose to users of the channel.
- * @internal
- */
-export type IChannelView = Pick<IChannel, "id" | "attributes" | "isAttached">;
-
 /**
  * {@link ITree} extended with some non-public APIs.
  * @internal
@@ -162,6 +148,11 @@ export interface ITreePrivate extends ITreeInternal {
 	 * This does not include everything that is included in a tree summary, since information about how to merge future edits is omitted.
 	 */
 	contentSnapshot(): SharedTreeContentSnapshot;
+
+	/**
+	 * Access to internals for testing.
+	 */
+	readonly kernel: SharedTreeKernel;
 }
 
 /**
@@ -216,17 +207,10 @@ function getCodecVersions(formatVersion: number): ExplicitCodecVersions {
 /**
  * Shared object wrapping {@link SharedTreeKernel}.
  */
-export class SharedTree extends SharedObject implements ISharedTree, WithBreakable {
-	public readonly breaker: Breakable = new Breakable("Shared Tree");
+export class SharedTree extends SharedObject implements ISharedTree {
+	private readonly breaker: Breakable = new Breakable("Shared Tree");
 
-	public get checkout(): TreeCheckout {
-		return this.kernel.checkout;
-	}
-	public get storedSchema(): TreeStoredSchemaRepository {
-		return this.checkout.storedSchema;
-	}
-
-	private readonly kernel: SharedTreeKernel;
+	public readonly kernel: SharedTreeKernel;
 
 	public constructor(
 		id: string,
@@ -251,10 +235,6 @@ export class SharedTree extends SharedObject implements ISharedTree, WithBreakab
 		);
 	}
 
-	public get editor(): SharedTreeEditBuilder {
-		return this.kernel.getEditor();
-	}
-
 	public summarizeCore(
 		serializer: IFluidSerializer,
 		telemetryContext?: ITelemetryContext,
@@ -275,7 +255,9 @@ export class SharedTree extends SharedObject implements ISharedTree, WithBreakab
 		this.kernel.processMessagesCore(messagesCollection);
 	}
 
-	protected onDisconnect(): void {}
+	protected onDisconnect(): void {
+		this.kernel.onDisconnect();
+	}
 
 	public exportVerbose(): VerboseTree | undefined {
 		return this.kernel.exportVerbose();
@@ -488,7 +470,7 @@ class SharedTreeKernel extends SharedTreeCore<SharedTreeEditBuilder, SharedTreeC
 				cursor.enterNode(0);
 				return verboseFromCursor(cursor, this.storedSchema.nodeSchema);
 			} else {
-				fail("Invalid document root length");
+				fail(0xac8 /* Invalid document root length */);
 			}
 		} finally {
 			cursor.free();
@@ -586,6 +568,8 @@ class SharedTreeKernel extends SharedTreeCore<SharedTreeEditBuilder, SharedTreeC
 			super.submitCommit(commit, schemaAndPolicy, isResubmit),
 		);
 	}
+
+	public onDisconnect(): void {}
 }
 
 /**
@@ -612,13 +596,13 @@ export function getBranch<T extends ImplicitFieldSchema | UnsafeUnknownSchema>(
 export function getBranch<T extends ImplicitFieldSchema | UnsafeUnknownSchema>(
 	treeOrView: ITree | TreeViewAlpha<T>,
 ): BranchableTree {
-	assert(
-		treeOrView instanceof SharedTree || treeOrView instanceof SchematizingSimpleTreeView,
-		0xa48 /* Unsupported implementation */,
-	);
-	const checkout: TreeCheckout = treeOrView.checkout;
+	if (treeOrView instanceof SchematizingSimpleTreeView) {
+		return treeOrView.checkout as unknown as BranchableTree;
+	}
+	const kernel = (treeOrView as ITree as ITreePrivate).kernel;
+	assert(kernel instanceof SharedTreeKernel, 0xb56 /* Invalid ITree */);
 	// This cast is safe so long as TreeCheckout supports all the operations on the branch interface.
-	return checkout as unknown as BranchableTree;
+	return kernel.checkout as unknown as BranchableTree;
 }
 
 /**
@@ -783,7 +767,8 @@ function verboseFromCursor(
 	schema: ReadonlyMap<TreeNodeSchemaIdentifier, TreeNodeStoredSchema>,
 ): VerboseTree {
 	const fields = customFromCursorStored(reader, schema, verboseFromCursor);
-	const nodeSchema = schema.get(reader.type) ?? fail("missing schema for type in cursor");
+	const nodeSchema =
+		schema.get(reader.type) ?? fail(0xac9 /* missing schema for type in cursor */);
 	if (nodeSchema instanceof LeafNodeStoredSchema) {
 		return fields as CustomTreeValue<IFluidHandle>;
 	}
@@ -811,7 +796,7 @@ function exportSimpleFieldSchemaStored(schema: TreeFieldStoredSchema): SimpleFie
 			assert(schema.types.size === 0, 0xa94 /* invalid forbidden field */);
 			break;
 		default:
-			fail("invalid field kind");
+			fail(0xaca /* invalid field kind */);
 	}
 	return { kind, allowedTypes: schema.types };
 }
@@ -838,5 +823,5 @@ function exportSimpleNodeSchemaStored(schema: TreeNodeStoredSchema): SimpleNodeS
 	if (schema instanceof LeafNodeStoredSchema) {
 		return { kind: NodeKind.Leaf, leafKind: schema.leafValue };
 	}
-	fail("invalid schema kind");
+	fail(0xacb /* invalid schema kind */);
 }

package/src/shared-tree/sharedTreeChangeFamily.ts

@@ -151,7 +151,7 @@ export class SharedTreeChangeFamily
 					};
 				}
 				default:
-					fail("Unknown SharedTree change type.");
+					fail(0xacc /* Unknown SharedTree change type. */);
 			}
 		};
 		return {

package/src/shared-tree/treeApiAlpha.ts

@@ -310,7 +310,11 @@ export const TreeAlpha: {
 		};
 
 		const cursor = borrowCursorFromTreeNodeOrValue(node);
-		return conciseFromCursor(cursor, tryGetSchema(node) ?? fail("invalid input"), config);
+		return conciseFromCursor(
+			cursor,
+			tryGetSchema(node) ?? fail(0xacd /* invalid input */),
+			config,
+		);
 	},
 
 	exportVerbose<T>(
@@ -325,7 +329,11 @@ export const TreeAlpha: {
 		};
 
 		const cursor = borrowCursorFromTreeNodeOrValue(node);
-		return verboseFromCursor(cursor, tryGetSchema(node) ?? fail("invalid input"), config);
+		return verboseFromCursor(
+			cursor,
+			tryGetSchema(node) ?? fail(0xace /* invalid input */),
+			config,
+		);
 	},
 
 	exportCompressed(
@@ -335,7 +343,7 @@ export const TreeAlpha: {
 			idCompressor?: IIdCompressor;
 		},
 	): JsonCompatible<IFluidHandle> {
-		const schema = tryGetSchema(node) ?? fail("invalid input");
+		const schema = tryGetSchema(node) ?? fail(0xacf /* invalid input */);
 		const format = versionToFormat[options.oldestCompatibleClient];
 		const codec = makeFieldBatchCodec({ jsonValidator: noopValidator }, format);
 		const cursor = borrowFieldCursorFromTreeNodeOrValue(node);
@@ -375,7 +383,7 @@ function borrowCursorFromTreeNodeOrValue(
 ): ITreeCursorSynchronous {
 	if (isTreeValue(node)) {
 		return cursorFromInsertable<UnsafeUnknownSchema>(
-			tryGetSchema(node) ?? fail("missing schema"),
+			tryGetSchema(node) ?? fail(0xad0 /* missing schema */),
 			node,
 		);
 	}

package/src/shared-tree/treeCheckout.ts

@@ -524,7 +524,7 @@ export class TreeCheckout implements ITreeCheckoutFork {
 					// original (reinstated) schema.
 					this.storedSchema.apply(change.innerChange.schema.new);
 				} else {
-					fail("Unknown Shared Tree change type.");
+					fail(0xad1 /* Unknown Shared Tree change type. */);
 				}
 			}
 		}

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

@@ -242,7 +242,7 @@ export class EditManager<
 	private trackBranch(b: SharedTreeBranch<TEditor, TChangeset>): void {
 		const trunkCommit =
 			findCommonAncestor(this.trunk.getHead(), b.getHead()) ??
-			fail("Expected branch to be related to trunk");
+			fail(0xad2 /* Expected branch to be related to trunk */);
 		const sequenceId = this.getCommitSequenceId(trunkCommit);
 		const branches = getOrCreate(this.trunkBranches, sequenceId, () => new Set());
 
@@ -253,10 +253,10 @@ export class EditManager<
 	private untrackBranch(b: SharedTreeBranch<TEditor, TChangeset>): void {
 		const trunkCommit =
 			findCommonAncestor(this.trunk.getHead(), b.getHead()) ??
-			fail("Expected branch to be related to trunk");
+			fail(0xad3 /* Expected branch to be related to trunk */);
 		const sequenceId = this.getCommitSequenceId(trunkCommit);
 		const branches =
-			this.trunkBranches.get(sequenceId) ?? fail("Expected branch to be tracked");
+			this.trunkBranches.get(sequenceId) ?? fail(0xad4 /* Expected branch to be tracked */);
 
 		assert(branches.delete(b), 0x671 /* Expected branch to be tracked */);
 		if (branches.size === 0) {
@@ -500,7 +500,8 @@ export class EditManager<
 					0xa61 /* Serialized trunk should not include the trunk base */,
 				);
 				const metadata =
-					this.trunkMetadata.get(c.revision) ?? fail("Expected metadata for trunk commit");
+					this.trunkMetadata.get(c.revision) ??
+					fail(0xad5 /* Expected metadata for trunk commit */);
 				const commit: SequencedCommit<TChangeset> = {
 					change: c.change,
 					revision: c.revision,
@@ -519,7 +520,7 @@ export class EditManager<
 				const branchPath: GraphCommit<TChangeset>[] = [];
 				const ancestor =
 					findCommonAncestor([branch.getHead(), branchPath], this.trunk.getHead()) ??
-					fail("Expected branch to be based on trunk");
+					fail(0xad6 /* Expected branch to be based on trunk */);
 
 				const base = ancestor === this.trunkBase ? rootRevision : ancestor.revision;
 				return [
@@ -582,7 +583,7 @@ export class EditManager<
 		for (const [sessionId, branch] of data.peerLocalBranches) {
 			const commit =
 				trunkRevisionCache.get(branch.base) ??
-				fail("Expected summary branch to be based off of a revision in the trunk");
+				fail(0xad7 /* Expected summary branch to be based off of a revision in the trunk */);
 
 			this.peerLocalBranches.set(
 				sessionId,
@@ -663,7 +664,7 @@ export class EditManager<
 		sequenceNumber: SeqNumber,
 		referenceSequenceNumber: SeqNumber,
 	): void {
-		assert(newCommits.length > 0, "Expected at least one sequenced change");
+		assert(newCommits.length > 0, 0xad8 /* Expected at least one sequenced change */);
 		assert(
 			sequenceNumber > this.minimumSequenceNumber,
 			0x713 /* Expected change sequence number to exceed the last known minimum sequence number */,

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

@@ -14,7 +14,10 @@ import type {
 	ITelemetryContext,
 } from "@fluidframework/runtime-definitions/internal";
 import { SummaryTreeBuilder } from "@fluidframework/runtime-utils/internal";
-import type { IFluidSerializer } from "@fluidframework/shared-object-base/internal";
+import type {
+	IChannelView,
+	IFluidSerializer,
+} from "@fluidframework/shared-object-base/internal";
 
 import type { ICodecOptions, IJsonCodec } from "../codec/index.js";
 import {
@@ -51,7 +54,6 @@ import { DefaultResubmitMachine } from "./defaultResubmitMachine.js";
 import { BranchCommitEnricher } from "./branchCommitEnricher.js";
 import { createChildLogger } from "@fluidframework/telemetry-utils/internal";
 import type { IFluidLoadable, ITelemetryBaseLogger } from "@fluidframework/core-interfaces";
-import type { IChannelView } from "../shared-tree/index.js";
 
 // TODO: Organize this to be adjacent to persisted types.
 const summarizablesTreeKey = "indexes";
@@ -370,13 +372,13 @@ export class SharedTreeCore<TEditor extends ChangeFamilyEditor, TChange>
 			if (messagesSessionId !== undefined) {
 				assert(
 					messagesSessionId === sessionId,
-					"All messages in a bunch must have the same session ID",
+					0xad9 /* All messages in a bunch must have the same session ID */,
 				);
 			}
 			messagesSessionId = sessionId;
 		}
 
-		assert(messagesSessionId !== undefined, "Messages must have a session ID");
+		assert(messagesSessionId !== undefined, 0xada /* Messages must have a session ID */);
 
 		this.editManager.addSequencedChanges(
 			commits,

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

@@ -79,7 +79,7 @@ export function customFromCursor<TChild, THandle>(
 	) => TChild,
 ): CustomTree<TChild, THandle> {
 	const type = reader.type;
-	const nodeSchema = schema.get(type) ?? fail("missing schema for type in cursor");
+	const nodeSchema = schema.get(type) ?? fail(0xb2e /* missing schema for type in cursor */);
 
 	switch (type) {
 		case numberSchema.identifier:
@@ -109,7 +109,7 @@ export function customFromCursor<TChild, THandle>(
 						const key =
 							isObjectNodeSchema(nodeSchema) && !options.useStoredKeys
 								? (nodeSchema.storedKeyToPropertyKey.get(storedKey) ??
-									fail("missing property key"))
+									fail(0xb2f /* missing property key */))
 								: storedKey;
 						// Length is checked above.
 						// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
@@ -138,7 +138,7 @@ export function customFromCursorStored<TChild>(
 	) => TChild,
 ): CustomTree<TChild, IFluidHandle> {
 	const type = reader.type;
-	const nodeSchema = schema.get(type) ?? fail("missing schema for type in cursor");
+	const nodeSchema = schema.get(type) ?? fail(0xb30 /* missing schema for type in cursor */);
 
 	if (nodeSchema instanceof LeafNodeStoredSchema) {
 		assert(valueSchemaAllows(nodeSchema.leafValue, reader.value), 0xa9c /* invalid value */);

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

@@ -138,7 +138,7 @@ 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")
+			inverse.get(value) ?? fail(0xb31 /* 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>>>

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

@@ -174,7 +174,7 @@ export type ValidateRecursiveSchema<
  * ```typescript
  *  // Workaround to avoid
  *  // `error TS2310: Type 'RecursiveArray' recursively references itself as a base type.` in the d.ts file.
- * export declare const _RecursiveArrayWorkaround: FixRecursiveArraySchema<typeof RecursiveArray>;
+ * export declare type _RecursiveArrayWorkaround = FixRecursiveArraySchema<typeof RecursiveArray>;
  * export class RecursiveArray extends schema.arrayRecursive("RA", [() => RecursiveArray]) {}
  * {
  * 	type _check = ValidateRecursiveSchema<typeof RecursiveArray>;

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

@@ -164,7 +164,7 @@ export function createSimpleTreeIndex<
 							return makeGenericKeyFinder<TKey>(brand(keyLocation), isKeyValid);
 						}
 					} else {
-						fail("node is out of schema");
+						fail(0xb32 /* node is out of schema */);
 					}
 				}
 			: (schemaIdentifier: TreeNodeSchemaIdentifier) => {
@@ -221,11 +221,11 @@ function makeGenericKeyFinder<TKey extends TreeIndexKey>(
 		cursor.exitField();
 
 		if (value === undefined) {
-			fail("a value for the key does not exist");
+			fail(0xb33 /* a value for the key does not exist */);
 		}
 
 		if (!isKeyValid(value)) {
-			fail("the key is an unexpected type");
+			fail(0xb34 /* the key is an unexpected type */);
 		}
 
 		return value;

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

@@ -376,7 +376,7 @@ export function checkUnion(union: Iterable<TreeNodeSchema>, errors: string[]): v
 		// For each field of schema, remove schema from possiblyAmbiguous that do not have that field
 		for (const [key, field] of schema.fields) {
 			if (field.kind === FieldKind.Required) {
-				const withKey = allObjectKeys.get(key) ?? fail("missing schema");
+				const withKey = allObjectKeys.get(key) ?? fail(0xb35 /* missing schema */);
 				for (const candidate of possiblyAmbiguous) {
 					if (!withKey.has(candidate)) {
 						possiblyAmbiguous.delete(candidate);