@fluidframework/tree 2.32.0 → 2.33.0

package/src/tableSchema.ts

@@ -17,6 +17,7 @@ import {
 	TreeArrayNode,
 	type TreeNode,
 	type TreeNodeFromImplicitAllowedTypes,
+	type TreeNodeSchema,
 	type TreeNodeSchemaClass,
 	type WithType,
 } from "./simple-tree/index.js";
@@ -42,22 +43,34 @@ export namespace TableSchema {
 	 * @remarks Implemented by the schema class returned from {@link TableSchema.createColumn}.
 	 * @sealed @internal
 	 */
-	export interface IColumn {
+	export interface IColumn<TPropsSchema extends ImplicitAllowedTypes = ImplicitAllowedTypes> {
 		/**
 		 * The unique identifier of the column.
 		 * @remarks Uniquely identifies the node within the entire tree, not just the table.
 		 */
 		readonly id: string;
+
+		/**
+		 * User-provided column properties.
+		 */
+		get props(): TreeNodeFromImplicitAllowedTypes<TPropsSchema>;
+		set props(value: InsertableTreeNodeFromImplicitAllowedTypes<TPropsSchema>);
 	}
 
 	/**
 	 * Factory for creating new table column schema.
+	 * @privateRemarks
+	 * TODO:
+	 * - Add overloads to make propsSchema optional.
+	 * - Take field schema rather than node schema for `propsSchema`, in particular to allow making
+	 * the additional properties optional.
 	 * @internal
 	 */
 	// eslint-disable-next-line @typescript-eslint/explicit-function-return-type -- Return type is too complex to be reasonable to specify
-	export function createColumn<const TInputScope extends string | undefined>(
-		inputSchemaFactory: SchemaFactoryAlpha<TInputScope>,
-	) {
+	export function createColumn<
+		const TInputScope extends string | undefined,
+		const TPropsSchema extends ImplicitAllowedTypes,
+	>(inputSchemaFactory: SchemaFactoryAlpha<TInputScope>, propsSchema: TPropsSchema) {
 		const schemaFactory = inputSchemaFactory.scopedFactory(tableSchemaFactorySubScope);
 		type Scope = ScopedSchemaName<TInputScope, typeof tableSchemaFactorySubScope>;
 
@@ -65,17 +78,24 @@ export namespace TableSchema {
 		 * {@link Column} fields.
 		 * @remarks Extracted for re-use in returned type signature defined later in this function.
 		 * The implicit typing is intentional.
+		 * Note: ideally we would add a satisfies clause here to ensure that this satisfies
+		 * `Record<string, ImplicitFieldSchema>`, but doing so causes TypeScript to prematurely and incorrectly evaluate the type of `propsSchema`.
+		 * Likely related to the following issue: https://github.com/microsoft/TypeScript/issues/52394
 		 */
 		const columnFields = {
 			id: schemaFactory.identifier,
-		} as const satisfies Record<string, ImplicitFieldSchema>;
+			props: schemaFactory.required(propsSchema),
+		} as const;
 
 		/**
 		 * A column in a table.
 		 */
-		class Column extends schemaFactory.object("Column", columnFields) implements IColumn {}
+		class Column extends schemaFactory.object("Column", columnFields) {}
+
+		type ColumnValueType = TreeNode &
+			IColumn<TPropsSchema> &
+			WithType<ScopedSchemaName<Scope, "Column">>;
 
-		type ColumnValueType = TreeNode & IColumn & WithType<ScopedSchemaName<Scope, "Column">>;
 		type ColumnInsertableType = InsertableObjectFromSchemaRecord<typeof columnFields>;
 
 		// Returning SingletonSchema without a type conversion results in TypeScript generating something like `readonly "__#124291@#brand": unknown;`
@@ -99,9 +119,10 @@ export namespace TableSchema {
 	 * Base column schema type.
 	 * @sealed @system @internal
 	 */
-	export type ColumnSchemaBase<TScope extends string | undefined> = ReturnType<
-		typeof createColumn<TScope>
-	>;
+	export type ColumnSchemaBase<
+		TScope extends string | undefined,
+		TPropsSchema extends ImplicitAllowedTypes,
+	> = ReturnType<typeof createColumn<TScope, TPropsSchema>>;
 
 	// #endregion
 
@@ -114,7 +135,7 @@ export namespace TableSchema {
 	 */
 	export interface IRow<
 		TCellSchema extends ImplicitAllowedTypes,
-		TColumnSchema extends ImplicitAllowedTypes,
+		TPropsSchema extends ImplicitAllowedTypes = ImplicitAllowedTypes,
 	> {
 		/**
 		 * The unique identifier of the row.
@@ -123,45 +144,71 @@ export namespace TableSchema {
 		readonly id: string;
 
 		/**
-		 * Gets the cell in the specified column
+		 * Gets the cell in the specified column.
 		 * @returns The cell if it exists, otherwise undefined.
-		 * @privateRemarks TODO: add overload that takes column ID.
 		 */
-		getCell(
-			column: TreeNodeFromImplicitAllowedTypes<TColumnSchema>,
-		): TreeNodeFromImplicitAllowedTypes<TCellSchema> | undefined;
+		getCell(column: IColumn): TreeNodeFromImplicitAllowedTypes<TCellSchema> | undefined;
+		/**
+		 * Gets the cell in the specified column, denoted by column ID.
+		 * @returns The cell if it exists, otherwise undefined.
+		 */
+		getCell(columnId: string): TreeNodeFromImplicitAllowedTypes<TCellSchema> | undefined;
 
 		/**
 		 * Sets the cell in the specified column.
-		 * @remarks To delete a cell, call {@link TableSchema.IRow.deleteCell} instead.
-		 * @privateRemarks TODO: add overload that takes column ID.
+		 * @remarks To remove a cell, call {@link TableSchema.IRow.(removeCell:1)} instead.
+		 */
+		setCell(
+			column: IColumn,
+			value: InsertableTreeNodeFromImplicitAllowedTypes<TCellSchema>,
+		): void;
+		/**
+		 * Sets the cell in the specified column, denoted by column ID.
+		 * @remarks To remove a cell, call {@link TableSchema.IRow.(removeCell:2)} instead.
 		 */
 		setCell(
-			column: TreeNodeFromImplicitAllowedTypes<TColumnSchema>,
+			columnId: string,
 			value: InsertableTreeNodeFromImplicitAllowedTypes<TCellSchema>,
 		): void;
 
 		/**
-		 * Deletes the cell in the specified column.
-		 * @privateRemarks TODO: add overload that takes column ID.
+		 * Removes the cell in the specified column.
+		 * @privateRemarks TODO: return removed cell
 		 */
-		deleteCell(column: TreeNodeFromImplicitAllowedTypes<TColumnSchema>): void;
+		removeCell(column: IColumn): void;
+		/**
+		 * Removes the cell in the specified column, denoted by column ID.
+		 * @privateRemarks TODO: return removed cell
+		 */
+		removeCell(columnId: string): void;
+
+		/**
+		 * User-provided row properties.
+		 */
+		get props(): TreeNodeFromImplicitAllowedTypes<TPropsSchema>;
+		set props(value: InsertableTreeNodeFromImplicitAllowedTypes<TPropsSchema>);
 	}
 
 	/**
 	 * Factory for creating new table row schema.
-	 * @privateRemarks TODO: add overloads to make column schema optional.
+	 *
+	 * @privateRemarks
+	 * TODO:
+	 * - Add overloads to make propsSchema optional.
+	 * - Take field schema rather than node schema for `propsSchema`, in particular to allow making
+	 * the additional properties optional.
+	 *
 	 * @sealed @internal
 	 */
 	// eslint-disable-next-line @typescript-eslint/explicit-function-return-type -- Return type is too complex to be reasonable to specify
 	export function createRow<
 		const TInputScope extends string | undefined,
 		const TCellSchema extends ImplicitAllowedTypes,
-		const TColumnSchema extends ColumnSchemaBase<TInputScope> = ColumnSchemaBase<TInputScope>,
+		const TPropsSchema extends ImplicitAllowedTypes,
 	>(
 		inputSchemaFactory: SchemaFactoryAlpha<TInputScope>,
 		cellSchema: TCellSchema,
-		_columnSchema: TColumnSchema,
+		propsSchema: TPropsSchema,
 	) {
 		const schemaFactory = inputSchemaFactory.scopedFactory(tableSchemaFactorySubScope);
 		type Scope = ScopedSchemaName<TInputScope, typeof tableSchemaFactorySubScope>;
@@ -169,41 +216,51 @@ export namespace TableSchema {
 		type CellValueType = TreeNodeFromImplicitAllowedTypes<TCellSchema>;
 		type CellInsertableType = InsertableTreeNodeFromImplicitAllowedTypes<TCellSchema>;
 
-		type ColumnValueType = TreeNodeFromImplicitAllowedTypes<TColumnSchema>;
-
 		/**
 		 * {@link Row} fields.
 		 * @remarks Extracted for re-use in returned type signature defined later in this function.
 		 * The implicit typing is intentional.
+		 * Note: ideally we would add a satisfies clause here to ensure that this satisfies
+		 * `Record<string, ImplicitFieldSchema>`, but doing so causes TypeScript to prematurely and incorrectly evaluate the type of `propsSchema`.
+		 * Likely related to the following issue: https://github.com/microsoft/TypeScript/issues/52394
 		 */
 		const rowFields = {
 			id: schemaFactory.identifier,
 			cells: schemaFactory.map("Row.cells", cellSchema),
-		} as const satisfies Record<string, ImplicitFieldSchema>;
+			props: schemaFactory.required(propsSchema),
+		} as const;
 
 		/**
 		 * The Row schema - this is a map of Cells where the key is the column id
 		 */
 		class Row
 			extends schemaFactory.object("Row", rowFields)
-			implements IRow<TCellSchema, TColumnSchema>
+			implements IRow<TCellSchema, TPropsSchema>
 		{
-			public getCell(column: ColumnValueType): CellValueType | undefined {
-				return this.cells.get(column.id) as CellValueType | undefined;
+			public getCell(columnOrId: IColumn | string): CellValueType | undefined {
+				const columnId = typeof columnOrId === "string" ? columnOrId : columnOrId.id;
+				return this.cells.get(columnId) as CellValueType | undefined;
 			}
 
-			public setCell(column: ColumnValueType, value: CellInsertableType | undefined): void {
-				this.cells.set(column.id, value);
+			public setCell(
+				columnOrId: IColumn | string,
+				value: CellInsertableType | undefined,
+			): void {
+				const columnId = typeof columnOrId === "string" ? columnOrId : columnOrId.id;
+				this.cells.set(columnId, value);
 			}
 
-			public deleteCell(column: ColumnValueType): void {
-				if (!this.cells.has(column.id)) return;
-				this.cells.delete(column.id);
+			public removeCell(columnOrId: IColumn | string): void {
+				const columnId = typeof columnOrId === "string" ? columnOrId : columnOrId.id;
+				if (!this.cells.has(columnId)) {
+					return;
+				}
+				this.cells.delete(columnId);
 			}
 		}
 
 		type RowValueType = TreeNode &
-			IRow<TCellSchema, TColumnSchema> &
+			IRow<TCellSchema, TPropsSchema> &
 			WithType<ScopedSchemaName<Scope, "Row">>;
 		type RowInsertableType = InsertableObjectFromSchemaRecord<typeof rowFields>;
 
@@ -231,8 +288,8 @@ export namespace TableSchema {
 	export type RowSchemaBase<
 		TScope extends string | undefined,
 		TCellSchema extends ImplicitAllowedTypes,
-		TColumnSchema extends ColumnSchemaBase<TScope> = ColumnSchemaBase<TScope>,
-	> = ReturnType<typeof createRow<TScope, TCellSchema, TColumnSchema>>;
+		TPropsSchema extends ImplicitAllowedTypes,
+	> = ReturnType<typeof createRow<TScope, TCellSchema, TPropsSchema>>;
 
 	// #endregion
 
@@ -360,7 +417,7 @@ export namespace TableSchema {
 
 		/**
 		 * Sets the cell at the specified location in the table.
-		 * @remarks To delete a cell, call {@link TableSchema.ITable.deleteCell} instead.
+		 * @remarks To remove a cell, call {@link TableSchema.ITable.removeCell} instead.
 		 * @privateRemarks TODO: add overload that takes column/row nodes?
 		 */
 		setCell(
@@ -378,37 +435,100 @@ export namespace TableSchema {
 		removeColumn: (column: TreeNodeFromImplicitAllowedTypes<TColumnSchema>) => void;
 
 		/**
-		 * Deletes 0 or more rows from the table.
+		 * Removes 0 or more rows from the table.
 		 * @privateRemarks TODO: policy for when 1 or more rows are not in the table.
 		 */
-		deleteRows: (rows: readonly TreeNodeFromImplicitAllowedTypes<TRowSchema>[]) => void;
+		removeRows: (rows: readonly TreeNodeFromImplicitAllowedTypes<TRowSchema>[]) => void;
 
 		/**
-		 * Deletes all rows from the table.
+		 * Removes all rows from the table.
 		 */
-		deleteAllRows: () => void;
+		removeAllRows: () => void;
 
 		/**
-		 * Deletes the cell at the specified location in the table.
+		 * Removes the cell at the specified location in the table.
 		 * @privateRemarks TODO: add overload that takes column/row nodes?
 		 */
-		deleteCell: (key: CellKey) => void;
+		removeCell: (key: CellKey) => void;
 	}
 
+	/**
+	 * Factory for creating new table schema without specifying row or column schema.
+	 * @internal
+	 */
+	export function createTable<
+		const TInputScope extends string | undefined,
+		const TCell extends ImplicitAllowedTypes,
+	>(
+		inputSchemaFactory: SchemaFactoryAlpha<TInputScope>,
+		_cellSchema: TCell,
+	): ReturnType<typeof createTableInternal<TInputScope, TCell>>;
+	/**
+	 * Factory for creating new table schema without specifying row schema
+	 * @internal
+	 */
+	export function createTable<
+		const TInputScope extends string | undefined,
+		const TCell extends ImplicitAllowedTypes,
+		const TColumn extends ColumnSchemaBase<TInputScope, ImplicitAllowedTypes>,
+	>(
+		inputSchemaFactory: SchemaFactoryAlpha<TInputScope>,
+		_cellSchema: TCell,
+		columnSchema: TColumn,
+	): ReturnType<typeof createTableInternal<TInputScope, TCell, TColumn>>;
 	/**
 	 * Factory for creating new table schema.
-	 * @privateRemarks TODO: add overloads to make column/row schema optional.
 	 * @internal
 	 */
-	// eslint-disable-next-line @typescript-eslint/explicit-function-return-type -- Return type is too complex to be reasonable to specify
 	export function createTable<
 		const TInputScope extends string | undefined,
 		const TCell extends ImplicitAllowedTypes,
-		const TColumn extends ColumnSchemaBase<TInputScope> = ColumnSchemaBase<TInputScope>,
-		const TRow extends RowSchemaBase<TInputScope, TCell, TColumn> = RowSchemaBase<
+		const TColumn extends ColumnSchemaBase<TInputScope, ImplicitAllowedTypes>,
+		const TRow extends RowSchemaBase<TInputScope, TCell, ImplicitAllowedTypes>,
+	>(
+		inputSchemaFactory: SchemaFactoryAlpha<TInputScope>,
+		_cellSchema: TCell,
+		columnSchema: TColumn,
+		rowSchema: TRow,
+	): ReturnType<typeof createTableInternal<TInputScope, TCell, TColumn, TRow>>;
+	/** `createTable` implementation */
+	export function createTable<
+		const TInputScope extends string | undefined,
+		const TCell extends ImplicitAllowedTypes,
+		const TColumn extends ColumnSchemaBase<TInputScope, ImplicitAllowedTypes>,
+		const TRow extends RowSchemaBase<TInputScope, TCell, ImplicitAllowedTypes>,
+	>(
+		inputSchemaFactory: SchemaFactoryAlpha<TInputScope>,
+		_cellSchema: TCell,
+		columnSchema?: TColumn,
+		rowSchema?: TRow,
+	): TreeNodeSchema {
+		const column = columnSchema ?? createColumn(inputSchemaFactory, inputSchemaFactory.null);
+		return createTableInternal(
+			inputSchemaFactory,
+			_cellSchema,
+			column as TColumn,
+			rowSchema ??
+				(createRow(inputSchemaFactory, _cellSchema, inputSchemaFactory.null) as TRow),
+		);
+	}
+
+	/**
+	 * Factory for creating new table schema.
+	 * @system @internal
+	 */
+	// eslint-disable-next-line @typescript-eslint/explicit-function-return-type -- Return type is too complex to be reasonable to specify
+	export function createTableInternal<
+		const TInputScope extends string | undefined,
+		const TCell extends ImplicitAllowedTypes,
+		const TColumn extends ColumnSchemaBase<
+			TInputScope,
+			ImplicitAllowedTypes
+		> = ColumnSchemaBase<TInputScope, ImplicitAllowedTypes>,
+		const TRow extends RowSchemaBase<TInputScope, TCell, ImplicitAllowedTypes> = RowSchemaBase<
 			TInputScope,
 			TCell,
-			TColumn
+			ImplicitAllowedTypes
 		>,
 	>(
 		inputSchemaFactory: SchemaFactoryAlpha<TInputScope>,
@@ -467,7 +587,7 @@ export namespace TableSchema {
 				if (row !== undefined) {
 					const column = this.getColumn(columnId);
 					if (column !== undefined) {
-						return row.getCell(column);
+						return row.getCell(column.id);
 					}
 				}
 				// If the cell does not exist return undefined
@@ -520,7 +640,7 @@ export namespace TableSchema {
 				if (row !== undefined) {
 					const column = this.getColumn(columnId);
 					if (column !== undefined) {
-						row.setCell(column, cell);
+						row.setCell(column.id, cell);
 					}
 				}
 			}
@@ -532,22 +652,22 @@ export namespace TableSchema {
 				this.columns.removeAt(index);
 			}
 
-			public deleteRows(rows: readonly RowValueType[]): void {
-				// If there are no rows to delete, do nothing
+			public removeRows(rows: readonly RowValueType[]): void {
+				// If there are no rows to remove, do nothing
 				if (rows.length === 0) {
 					return;
 				}
 
-				// If there is only one row to delete, delete it
+				// If there is only one row to remove, remove it
 				if (rows.length === 1) {
 					const index = this.rows.indexOf(rows[0] ?? oob());
 					this.rows.removeAt(index);
 					return;
 				}
-				// If there are multiple rows to delete, delete them in a transaction
+				// If there are multiple rows to remove, remove them in a transaction
 				// This is to avoid the performance issues of deleting multiple rows at once
 				Tree.runTransaction(this, () => {
-					// Iterate over the rows and delete them
+					// Iterate over the rows and remove them
 					for (const row of rows) {
 						const index = this.rows.indexOf(row);
 						this.rows.removeAt(index);
@@ -555,17 +675,17 @@ export namespace TableSchema {
 				});
 			}
 
-			public deleteAllRows(): void {
+			public removeAllRows(): void {
 				this.rows.removeRange();
 			}
 
-			public deleteCell(key: CellKey): void {
+			public removeCell(key: CellKey): void {
 				const { columnId, rowId } = key;
 				const row = this.getRow(rowId);
 				if (row !== undefined) {
 					const column = this.getColumn(columnId);
 					if (column !== undefined) {
-						row.deleteCell(column);
+						row.removeCell(column.id);
 					}
 				}
 			}
@@ -601,8 +721,15 @@ export namespace TableSchema {
 	export type TableSchemaBase<
 		TScope extends string | undefined,
 		TCell extends ImplicitAllowedTypes,
-		TColumn extends ColumnSchemaBase<TScope> = ColumnSchemaBase<TScope>,
-		TRow extends RowSchemaBase<TScope, TCell, TColumn> = RowSchemaBase<TScope, TCell, TColumn>,
+		TColumn extends ColumnSchemaBase<TScope, ImplicitAllowedTypes> = ColumnSchemaBase<
+			TScope,
+			ImplicitAllowedTypes
+		>,
+		TRow extends RowSchemaBase<TScope, TCell, ImplicitAllowedTypes> = RowSchemaBase<
+			TScope,
+			TCell,
+			ImplicitAllowedTypes
+		>,
 	> = ReturnType<typeof createTable<TScope, TCell, TColumn, TRow>>;
 
 	// #endregion

package/src/treeFactory.ts

@@ -8,27 +8,170 @@ import type {
 	IChannelFactory,
 	IFluidDataStoreRuntime,
 	IChannelServices,
+	IChannelStorageService,
 } from "@fluidframework/datastore-definitions/internal";
+import type {
+	ITelemetryContext,
+	IExperimentalIncrementalSummaryContext,
+	ISummaryTreeWithStats,
+	IRuntimeMessageCollection,
+} from "@fluidframework/runtime-definitions/internal";
+
+import type { ISequencedDocumentMessage } from "@fluidframework/driver-definitions/internal";
 import type { SharedObjectKind } from "@fluidframework/shared-object-base";
 import {
+	type IFluidSerializer,
+	type ISharedObject,
 	type ISharedObjectKind,
+	SharedObject,
 	createSharedObjectKind,
 } from "@fluidframework/shared-object-base/internal";
 
-import {
-	SharedTree as SharedTreeImpl,
-	type ISharedTree,
-	type SharedTreeOptions,
-	type SharedTreeOptionsInternal,
+import type {
+	SchematizingSimpleTreeView,
+	SharedTreeContentSnapshot,
+	SharedTreeOptions,
+	SharedTreeOptionsInternal,
+	SharedTreeEditBuilder,
+	SharedTreeChange,
+	ITreePrivate,
 } from "./shared-tree/index.js";
-import type { ITree } from "./simple-tree/index.js";
-
+import type {
+	ImplicitFieldSchema,
+	ITree,
+	ReadSchema,
+	SimpleTreeSchema,
+	TreeView,
+	TreeViewConfiguration,
+	UnsafeUnknownSchema,
+	VerboseTree,
+} from "./simple-tree/index.js";
 import { SharedTreeFactoryType, SharedTreeAttributes } from "./sharedTreeAttributes.js";
+import { Breakable } from "./util/index.js";
+import { SharedTreeKernel } from "./shared-tree/index.js";
+import { UsageError } from "@fluidframework/telemetry-utils/internal";
+import { fail } from "@fluidframework/core-utils/internal";
+import type { SharedTreeCore } from "./shared-tree-core/index.js";
+
+/**
+ * {@link ITreePrivate} extended with ISharedObject.
+ * @remarks
+ * This is used when integration testing this package with the Fluid runtime as it exposes the APIs the runtime consumes to manipulate the tree.
+ */
+export interface ISharedTree extends ISharedObject, ITreePrivate {}
+
+/**
+ * Shared object wrapping {@link SharedTreeKernel}.
+ */
+class SharedTreeImpl extends SharedObject implements ISharedTree {
+	private readonly breaker: Breakable = new Breakable("Shared Tree");
+
+	public readonly kernel: SharedTreeKernel;
+
+	public constructor(
+		id: string,
+		runtime: IFluidDataStoreRuntime,
+		attributes: IChannelAttributes,
+		optionsParam: SharedTreeOptionsInternal,
+		telemetryContextPrefix: string = "fluid_sharedTree_",
+	) {
+		super(id, runtime, attributes, telemetryContextPrefix);
+		if (runtime.idCompressor === undefined) {
+			throw new UsageError("IdCompressor must be enabled to use SharedTree");
+		}
+		this.kernel = new SharedTreeKernel(
+			this.breaker,
+			this,
+			this.serializer,
+			(content, localOpMetadata) => this.submitLocalMessage(content, localOpMetadata),
+			() => this.deltaManager.lastSequenceNumber,
+			this.logger,
+			runtime.idCompressor,
+			optionsParam,
+		);
+	}
+
+	public summarizeCore(
+		serializer: IFluidSerializer,
+		telemetryContext?: ITelemetryContext,
+		incrementalSummaryContext?: IExperimentalIncrementalSummaryContext,
+	): ISummaryTreeWithStats {
+		return this.kernel.summarizeCore(serializer, telemetryContext, incrementalSummaryContext);
+	}
+
+	protected processCore(
+		message: ISequencedDocumentMessage,
+		local: boolean,
+		localOpMetadata: unknown,
+	): void {
+		fail(0xb75 /* processCore should not be called on SharedTree */);
+	}
+
+	protected override processMessagesCore(messagesCollection: IRuntimeMessageCollection): void {
+		this.kernel.processMessagesCore(messagesCollection);
+	}
+
+	protected onDisconnect(): void {
+		this.kernel.onDisconnect();
+	}
+
+	public exportVerbose(): VerboseTree | undefined {
+		return this.kernel.exportVerbose();
+	}
+
+	public exportSimpleSchema(): SimpleTreeSchema {
+		return this.kernel.exportSimpleSchema();
+	}
+
+	public contentSnapshot(): SharedTreeContentSnapshot {
+		return this.kernel.contentSnapshot();
+	}
+
+	// For the new TreeViewAlpha API
+	public viewWith<TRoot extends ImplicitFieldSchema | UnsafeUnknownSchema>(
+		config: TreeViewConfiguration<ReadSchema<TRoot>>,
+	): SchematizingSimpleTreeView<TRoot> & TreeView<ReadSchema<TRoot>>;
+
+	// For the old TreeView API
+	public viewWith<TRoot extends ImplicitFieldSchema>(
+		config: TreeViewConfiguration<TRoot>,
+	): SchematizingSimpleTreeView<TRoot> & TreeView<TRoot>;
+
+	public viewWith<TRoot extends ImplicitFieldSchema | UnsafeUnknownSchema>(
+		config: TreeViewConfiguration<ReadSchema<TRoot>>,
+	): SchematizingSimpleTreeView<TRoot> & TreeView<ReadSchema<TRoot>> {
+		return this.kernel.viewWith(config);
+	}
+
+	protected override async loadCore(services: IChannelStorageService): Promise<void> {
+		await this.kernel.loadCore(services);
+	}
+
+	protected override didAttach(): void {
+		this.kernel.didAttach();
+	}
+
+	protected override applyStashedOp(
+		...args: Parameters<
+			SharedTreeCore<SharedTreeEditBuilder, SharedTreeChange>["applyStashedOp"]
+		>
+	): void {
+		this.kernel.applyStashedOp(...args);
+	}
+
+	protected override reSubmitCore(
+		...args: Parameters<
+			SharedTreeCore<SharedTreeEditBuilder, SharedTreeChange>["reSubmitCore"]
+		>
+	): void {
+		this.kernel.reSubmitCore(...args);
+	}
+}
 
 /**
  * A channel factory that creates an {@link ITree}.
  */
-export class TreeFactory implements IChannelFactory<ISharedTree> {
+class TreeFactory implements IChannelFactory<ISharedTree> {
 	public static Type: string = SharedTreeFactoryType;
 	public readonly type: string = SharedTreeFactoryType;