@fluidframework/tree 2.111.0 → 2.112.0

package/src/entrypoints/alpha.ts

@@ -178,6 +178,7 @@ export {
 	ChangeMetadata, 
 	CodecName, 
 	CodecWriteOptions, 
+	Component, 
 	CreateIndependentTreeAlphaOptions, 
 	DirtyTreeMap, 
 	DirtyTreeStatus, 
@@ -201,6 +202,7 @@ export {
 	ITreeAlpha, 
 	IncrementalEncodingPolicy, 
 	IndependentViewOptions, 
+	IndependentViewTelemetryOptions, 
 	Insertable, 
 	InsertableContent, 
 	InsertableField, 
@@ -316,6 +318,7 @@ export {
 	incrementalSummaryHint, 
 	independentInitializedView, 
 	independentView, 
+	minimize, 
 	normalizeAllowedTypes, 
 	persistedToSimpleSchema, 
 	replaceConciseTreeHandles, 

package/src/feature-libraries/chunked-forest/codec/chunkDecoding.ts

@@ -5,7 +5,6 @@
 
 import { assert, unreachableCase, oob } from "@fluidframework/core-utils/internal";
 import type {
-	IIdCompressor,
 	OpSpaceCompressedId,
 	SessionSpaceCompressedId,
 } from "@fluidframework/id-compressor";
@@ -17,7 +16,12 @@ import type {
 	Value,
 	TreeChunk,
 } from "../../../core/index.js";
-import { assertValidIndex, brand, decompressIdentifierIfNeeded } from "../../../util/index.js";
+import {
+	assertValidIndex,
+	brand,
+	decompressIdentifierIfNeeded,
+	type IdDecodingContext,
+} from "../../../util/index.js";
 import { BasicChunk } from "../basicChunk.js";
 import { emptyChunk } from "../emptyChunk.js";
 import { SequenceChunk } from "../sequenceChunk.js";
@@ -55,31 +59,6 @@ import {
 	supportsIncrementalEncoding,
 } from "./format/index.js";
 
-/**
- * Context for decoding identifiers.
- * @remarks
- * See {@link FieldBatchDecodingContext} for the production implementation of this.
- *
- * This intentionally avoids exposing anything which depends on the underlying id-compressor's session ID to avoid confusion with the session ID of the compressor which encoded the data.
- * If the session ID of the encoder which encoded the data is known, that information is baked into `resolveEncodedId`.
- */
-export interface IdDecodingContext {
-	/**
-	 * Compressor which can decompress session-space identifiers from {@link resolveEncodedId} as needed.
-	 */
-	readonly idCompressor: Pick<IIdCompressor, "decompress">;
-	/**
-	 * Resolves an encoded op-space identifier to either a session-space ID
-	 * (which {@link idCompressor} can decompress if needed)
-	 * or a string (which passes through unchanged).
-	 * @remarks
-	 * In contexts where non-final identifiers can't be supported (where no originator session is available),
-	 * if a non-final identifier is encountered, this may throw or perform a data healing workaround.
-	 * See {@link FieldBatchDecodingContext.forOp} and {@link FieldBatchDecodingContext.forSummary} for details.
-	 */
-	readonly resolveEncodedId: (id: OpSpaceCompressedId) => SessionSpaceCompressedId | string;
-}
-
 /**
  * Decode `chunk` into a TreeChunk.
  */

package/src/feature-libraries/chunked-forest/codec/chunkDecodingGeneric.ts

@@ -7,7 +7,7 @@ import { assert } from "@fluidframework/core-utils/internal";
 
 import type { DiscriminatedUnionDispatcher } from "../../../codec/index.js";
 import type { TreeChunk } from "../../../core/index.js";
-import type { BrandedType } from "../../../util/index.js";
+import type { BrandedType, IdDecodingContext } from "../../../util/index.js";
 
 import {
 	type ChunkDecoder,
@@ -15,7 +15,6 @@ import {
 	getChecked,
 	readStream,
 } from "./chunkCodecUtilities.js";
-import type { IdDecodingContext } from "./chunkDecoding.js";
 import type { IncrementalDecoder } from "./codecs.js";
 import type { EncodedFieldBatchGeneric, IdentifierOrIndex } from "./format/index.js";
 

package/src/feature-libraries/chunked-forest/codec/codecs.ts

@@ -4,12 +4,7 @@
  */
 
 import { assert, unreachableCase } from "@fluidframework/core-utils/internal";
-import type {
-	IIdCompressor,
-	OpSpaceCompressedId,
-	SessionId,
-	SessionSpaceCompressedId,
-} from "@fluidframework/id-compressor";
+import type { IIdCompressor } from "@fluidframework/id-compressor";
 import { lowestMinVersionForCollab } from "@fluidframework/runtime-utils/internal";
 import type { TSchema } from "@sinclair/typebox";
 
@@ -29,13 +24,14 @@ import {
 } from "../../../core/index.js";
 import {
 	brandedNumberType,
-	forceDecodeEncodedIdWithoutSession,
+	IdDecodingContext,
 	type Brand,
-	type IdentifierHealingConfig,
+	type IdDecoderOptionsOriginatorless,
+	type IdDecoderOptionsWithOriginator,
 } from "../../../util/index.js";
 import { TreeCompressionStrategy } from "../../treeCompressionUtils.js";
 
-import { decode, type IdDecodingContext } from "./chunkDecoding.js";
+import { decode } from "./chunkDecoding.js";
 import type { FieldBatch } from "./fieldBatch.js";
 import {
 	EncodedFieldBatchV1,
@@ -148,26 +144,18 @@ export interface FieldBatchEncodingContext {
  * op-style and summary-style decoding is load-bearing (different invariants
  * apply, and bugs in this area are typically the result of conflating them).
  */
-export class FieldBatchDecodingContext implements IdDecodingContext {
+export class FieldBatchDecodingContext extends IdDecodingContext {
 	private constructor(
-		/**
-		 * Used internally to prevent the use of this decoder in incremental chunks if it has a session id (which would be wrong in those chunks).
-		 */
-		private readonly hasOriginatorSessionId: boolean,
-
-		public readonly idCompressor: Pick<IIdCompressor, "decompress">,
-
-		public readonly resolveEncodedId: (
-			id: OpSpaceCompressedId,
-		) => SessionSpaceCompressedId | string,
-
+		private readonly options: IdDecoderOptionsOriginatorless | IdDecoderOptionsWithOriginator,
 		/**
 		 * Decoder for incremental fields. Defined when the encoded batch contains
 		 * incremental chunks. Only populated on summary-style contexts; op-style
 		 * contexts always have this undefined.
 		 */
 		public readonly incrementalDecoder?: IncrementalDecoder,
-	) {}
+	) {
+		super(options);
+	}
 
 	/**
 	 * Construct a decode context for an op.
@@ -178,14 +166,8 @@ export class FieldBatchDecodingContext implements IdDecodingContext {
 	 * not a recoverable state, so the resolver throws rather than synthesizing
 	 * a UUID. Incremental decoding is not used for ops.
 	 */
-	public static forOp(opts: {
-		readonly idCompressor: IIdCompressor;
-		readonly originatorId: SessionId;
-	}): FieldBatchDecodingContext {
-		const { idCompressor, originatorId } = opts;
-		return new FieldBatchDecodingContext(true, idCompressor, (id) =>
-			idCompressor.normalizeToSessionSpace(id, originatorId),
-		);
+	public static forOp(options: IdDecoderOptionsWithOriginator): FieldBatchDecodingContext {
+		return new FieldBatchDecodingContext(options);
 	}
 
 	/**
@@ -204,14 +186,10 @@ export class FieldBatchDecodingContext implements IdDecodingContext {
 	 * `withIncrementalDecoder` has logic to guard against cases which expect session-relative identifiers in incremental chunks,
 	 * as does the encoding-side assert in the {@link EncoderContext}.
 	 */
-	public static forSummary(opts: {
-		readonly idCompressor: IIdCompressor;
-		readonly healing?: IdentifierHealingConfig;
-	}): FieldBatchDecodingContext {
-		const { idCompressor, healing } = opts;
-		return new FieldBatchDecodingContext(false, idCompressor, (id) =>
-			forceDecodeEncodedIdWithoutSession(id, idCompressor, healing),
-		);
+	public static forSummary(
+		options: IdDecoderOptionsOriginatorless | IdDecoderOptionsWithOriginator,
+	): FieldBatchDecodingContext {
+		return new FieldBatchDecodingContext(options);
 	}
 
 	/**
@@ -231,12 +209,7 @@ export class FieldBatchDecodingContext implements IdDecodingContext {
 			!this.hasOriginatorSessionId,
 			0xd0c /* withIncrementalDecoder can only be called on contexts without an originator session ID */,
 		);
-		return new FieldBatchDecodingContext(
-			false,
-			this.idCompressor,
-			this.resolveEncodedId,
-			incrementalDecoder,
-		);
+		return new FieldBatchDecodingContext(this.options, incrementalDecoder);
 	}
 }
 

package/src/feature-libraries/index.ts

@@ -93,6 +93,7 @@ export {
 	isNeverTree,
 	DefaultRevisionReplacer,
 	ModularChangeFormatVersion,
+	minimizeModularChangeset,
 } from "./modular-schema/index.js";
 
 export { mapRootChanges } from "./deltaUtils.js";
@@ -149,6 +150,7 @@ export {
 
 export {
 	SchemaValidationError,
+	type SchemaValidationErrorContext,
 	isNodeInSchema,
 	isFieldInSchema,
 	throwOutOfSchema,

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

@@ -83,3 +83,4 @@ export type {
 	FieldKindConfigurationEntry,
 } from "./fieldKindConfiguration.js";
 export { DefaultRevisionReplacer } from "./defaultRevisionReplacer.js";
+export { minimizeModularChangeset } from "./minimizeModularChange.js";

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

@@ -0,0 +1,33 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import type { FieldKindIdentifier } from "../../core/index.js";
+
+import type { FlexFieldKind } from "./fieldKind.js";
+import type { ModularChangeset } from "./modularChangeTypes.js";
+
+/**
+ * "Minimizes" a {@link ModularChangeset} so that it contains no extraneous
+ * information, i.e. no new content that isn't observable from document tree
+ * and no edits without net observed effect on the document tree.
+ * @remarks
+ * "Extraneous information" includes, for example, data for nodes that were both created and removed within the same
+ * transaction, or changes whose effects cancel out to nothing. Minimizing reduces the size of an edit without altering
+ * its observable effect.
+ *
+ * This is the eventual home of the minimization algorithm, colocated with {@link ModularChangeFamily} so it can use its
+ * internals. It is currently a no-op that returns the change unchanged; a real implementation will be provided in a
+ * future change.
+ *
+ * @param change - The change to minimize.
+ * @param fieldKinds - The field kinds to delegate to when computing the change's delta.
+ */
+export function minimizeModularChangeset(
+	change: ModularChangeset,
+	fieldKinds: ReadonlyMap<FieldKindIdentifier, FlexFieldKind>,
+): ModularChangeset {
+	// TODO: Actually minimize the change. For now this is a no-op that returns the change unchanged.
+	return change;
+}

package/src/feature-libraries/schemaChecker.ts

@@ -32,13 +32,82 @@ export enum SchemaValidationError {
 	Node_MissingSchema,
 }
 
+/**
+ * Additional context about a schema validation error.
+ * @remarks
+ * Not all fields are populated for every error type — only those relevant to the specific error.
+ */
+export interface SchemaValidationErrorContext {
+	/**
+	 * The type identifier of the node that failed validation.
+	 */
+	readonly nodeType?: string;
+	/**
+	 * The set of type identifiers allowed in the field, if applicable.
+	 */
+	readonly allowedTypes?: ReadonlySet<string>;
+	/**
+	 * Field keys on the node that were not recognized by its schema.
+	 */
+	readonly unexpectedFields?: ReadonlySet<string>;
+}
+
 /**
  * Throws a UsageError indicating a tree is out of schema.
  */
-export function throwOutOfSchema(maybeError: SchemaValidationError): never {
-	throw new UsageError(
-		`Tree does not conform to schema: ${SchemaValidationError[maybeError]}`,
-	);
+export function throwOutOfSchema(
+	maybeError: SchemaValidationError,
+	context?: SchemaValidationErrorContext,
+): never {
+	throw new UsageError(formatSchemaValidationError(maybeError, context));
+}
+
+// Not exported: internal helper used by throwOutOfSchema.
+function formatSchemaValidationError(
+	error: SchemaValidationError,
+	context: SchemaValidationErrorContext | undefined,
+): string {
+	switch (error) {
+		case SchemaValidationError.Field_NodeTypeNotAllowed: {
+			const nodeDesc = context?.nodeType === undefined ? "unknown" : `"${context.nodeType}"`;
+			const allowedDesc =
+				context?.allowedTypes === undefined
+					? "unknown"
+					: `[${[...context.allowedTypes].map((t) => `"${t}"`).join(", ")}]`;
+			return (
+				`Tree does not conform to schema. ` +
+				`A node of type ${nodeDesc} is not allowed in this field. Allowed types: ${allowedDesc}. ` +
+				`If using a staged allowed type, the stored schema has not been upgraded to include this type yet. ` +
+				`Either upgrade the schema to enable the staged type or avoid inserting content of this type until the schema is upgraded.`
+			);
+		}
+		case SchemaValidationError.Node_MissingSchema: {
+			const nodeDesc = context?.nodeType === undefined ? "unknown" : `"${context.nodeType}"`;
+			return (
+				`Tree does not conform to schema. ` +
+				`No schema definition was found for node type ${nodeDesc}. ` +
+				`Ensure the node's type is included in the schema and that the stored schema has been upgraded if needed.`
+			);
+		}
+		case SchemaValidationError.ObjectNode_FieldNotInSchema: {
+			const nodeDesc = context?.nodeType === undefined ? "unknown" : `"${context.nodeType}"`;
+			const fieldsDesc =
+				context?.unexpectedFields === undefined || context.unexpectedFields.size === 0
+					? undefined
+					: `[${[...context.unexpectedFields].map((f) => `"${f}"`).join(", ")}]`;
+			const fieldsPart =
+				fieldsDesc === undefined
+					? "The node has fields that are not defined in its schema."
+					: `Unexpected fields: ${fieldsDesc}.`;
+			return (
+				`Tree does not conform to schema. ` +
+				`A node of type ${nodeDesc} has fields not defined in its schema. ${fieldsPart}`
+			);
+		}
+		default: {
+			return `Tree does not conform to schema: ${SchemaValidationError[error]}.`;
+		}
+	}
 }
 
 type NotUndefined = number | string | boolean | bigint | symbol | object;
@@ -53,12 +122,14 @@ type NotUndefined = number | string | boolean | bigint | symbol | object;
 export function isNodeInSchema<T extends NotUndefined>(
 	node: MinimalMapTreeNodeView,
 	schemaAndPolicy: SchemaAndPolicy,
-	onError: (error: SchemaValidationError) => T,
+	onError: (error: SchemaValidationError, context?: SchemaValidationErrorContext) => T,
 ): T | undefined {
 	// Validate the schema declared by the node exists
 	const schema = schemaAndPolicy.schema.nodeSchema.get(node.type);
 	if (schema === undefined) {
-		return onError(SchemaValidationError.Node_MissingSchema);
+		return onError(SchemaValidationError.Node_MissingSchema, {
+			nodeType: node.type,
+		});
 	}
 
 	// Validate the node is well formed according to its schema
@@ -95,7 +166,10 @@ export function isNodeInSchema<T extends NotUndefined>(
 			// Code using this with a stored schema derived from a view schema rather than the document can be problematic because it may be missing unknown fields that the actual document has.
 			// Other schema evolution features like "staged" allowed types will likely cause similar issues elsewhere in this checker.
 			if (uncheckedFieldsFromNode.size > 0) {
-				return onError(SchemaValidationError.ObjectNode_FieldNotInSchema);
+				return onError(SchemaValidationError.ObjectNode_FieldNotInSchema, {
+					nodeType: node.type,
+					unexpectedFields: uncheckedFieldsFromNode,
+				});
 			}
 		} else if (schema instanceof MapNodeStoredSchema) {
 			for (const [_key, field] of node.fields) {
@@ -128,7 +202,7 @@ export function isFieldInSchema<T extends NotUndefined>(
 	childNodes: MapTreeFieldViewGeneric<MinimalMapTreeNodeView>,
 	schema: TreeFieldStoredSchema,
 	schemaAndPolicy: SchemaAndPolicy,
-	onError: (error: SchemaValidationError) => T,
+	onError: (error: SchemaValidationError, context?: SchemaValidationErrorContext) => T,
 ): T | undefined {
 	// Validate that the field kind is handled by the schema policy
 	const kind = schemaAndPolicy.policy.fieldKinds.get(schema.kind);
@@ -147,7 +221,10 @@ export function isFieldInSchema<T extends NotUndefined>(
 	for (const node of childNodes) {
 		// Validate the type declared by the node is allowed in this field
 		if (schema.types !== undefined && !schema.types.has(node.type)) {
-			return onError(SchemaValidationError.Field_NodeTypeNotAllowed);
+			return onError(SchemaValidationError.Field_NodeTypeNotAllowed, {
+				nodeType: node.type,
+				allowedTypes: schema.types,
+			});
 		}
 
 		// Validate the node complies with the type it declares to be.

package/src/index.ts

@@ -78,12 +78,14 @@ export {
 	type TreeIdentifierUtils,
 	independentView,
 	type IndependentViewOptions,
+	type IndependentViewTelemetryOptions,
 	createIndependentTreeBeta,
 	createIndependentTreeAlpha,
 	type CreateIndependentTreeAlphaOptions,
 	ForestTypeOptimized,
 	ForestTypeExpensiveDebug,
 	ForestTypeReference,
+	minimize,
 } from "./shared-tree/index.js";
 
 export {
@@ -415,3 +417,4 @@ export {
 	utf16LengthForCodePoints,
 } from "./text/index.js";
 export { ExtensibleUnionNode } from "./extensibleUnionNode.js";
+export { Component } from "./componentApi.js";

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/tree";
-export const pkgVersion = "2.111.0";
+export const pkgVersion = "2.112.0";

package/src/shared-tree/independentView.ts

@@ -3,12 +3,16 @@
  * Licensed under the MIT License.
  */
 
-import type { IFluidHandle } from "@fluidframework/core-interfaces";
+import type { IFluidHandle, ITelemetryBaseLogger } from "@fluidframework/core-interfaces";
 import { assert } from "@fluidframework/core-utils/internal";
 import {
 	type IIdCompressor,
 	createIdCompressor,
 } from "@fluidframework/id-compressor/internal";
+import {
+	createChildLogger,
+	extractTelemetryLoggerExt,
+} from "@fluidframework/telemetry-utils/internal";
 
 import type { CodecWriteOptions, ICodecOptions } from "../codec/index.js";
 import {
@@ -22,8 +26,8 @@ import {
 	FieldBatchDecodingContext,
 	defaultIncrementalEncodingPolicy,
 	schemaCodecBuilder,
+	combineChunks,
 } from "../feature-libraries/index.js";
-import { combineChunks } from "../feature-libraries/index.js";
 import type {
 	TreeViewConfiguration,
 	ImplicitFieldSchema,
@@ -52,11 +56,28 @@ import {
 } from "./sharedTree.js";
 import { createTreeCheckout } from "./treeCheckout.js";
 
+/**
+ * Options for supplying a telemetry logger to an independent tree view.
+ * @remarks
+ * Events emitted by the independent tree are tagged with the `independentView` namespace.
+ * If no logger is provided, telemetry events are dropped.
+ * @alpha @input
+ */
+export interface IndependentViewTelemetryOptions {
+	/**
+	 * Optional logger for telemetry.
+	 */
+	readonly logger?: ITelemetryBaseLogger | undefined;
+}
+
 /**
  * {@link independentView} options.
  * @alpha @input
  */
-export interface IndependentViewOptions extends ForestOptions, Partial<CodecWriteOptions> {
+export interface IndependentViewOptions
+	extends ForestOptions,
+		Partial<CodecWriteOptions>,
+		IndependentViewTelemetryOptions {
 	/**
 	 * Optional ID compressor for generating and compressing identifiers.
 	 * If not provided, a new one will be created.
@@ -69,6 +90,7 @@ export interface IndependentViewOptions extends ForestOptions, Partial<CodecWrit
  * @alpha
  */
 export type CreateIndependentTreeAlphaOptions = ForestOptions &
+	IndependentViewTelemetryOptions &
 	(
 		| (IndependentViewOptions & {
 				/**
@@ -120,7 +142,7 @@ export function independentView<const TSchema extends ImplicitFieldSchema>(
  */
 export function independentInitializedView<const TSchema extends ImplicitFieldSchema>(
 	config: TreeViewConfiguration<TSchema>,
-	options: ForestOptions & ICodecOptions,
+	options: ForestOptions & ICodecOptions & IndependentViewTelemetryOptions,
 	content: ViewContent,
 ): TreeViewAlpha<TSchema> {
 	return createIndependentTreeAlpha({ ...options, content }).viewWith(
@@ -202,7 +224,13 @@ export function createIndependentTreeBeta<const TSchema extends ImplicitFieldSch
 export function createIndependentTreeAlpha<const TSchema extends ImplicitFieldSchema>(
 	options?: CreateIndependentTreeAlphaOptions,
 ): ViewableTree & Pick<ITreeAlpha, "exportVerbose" | "exportSimpleSchema"> {
-	const breaker = new Breakable("independentView");
+	const logger = extractTelemetryLoggerExt(
+		createChildLogger({
+			logger: options?.logger,
+			namespace: "independentView",
+		}),
+	);
+	const breaker = new Breakable("independentView", logger);
 	const idCompressor: IIdCompressor =
 		options?.idCompressor ?? options?.content?.idCompressor ?? createIdCompressor();
 	const mintRevisionTag = (): RevisionTag => idCompressor.generateCompressedId();
@@ -223,6 +251,7 @@ export function createIndependentTreeAlpha<const TSchema extends ImplicitFieldSc
 		forest,
 		schema: schemaRepository,
 		breaker,
+		logger,
 		codecOptions: options,
 	});
 
@@ -235,6 +264,7 @@ export function createIndependentTreeAlpha<const TSchema extends ImplicitFieldSc
 		// (finalized compressed ids or strings), so summary-style decode is correct.
 		const context = FieldBatchDecodingContext.forSummary({
 			idCompressor,
+			healing: undefined,
 		});
 		const fieldCursors = fieldBatchCodec.decode(
 			options.content.tree as JsonCompatibleReadOnly,

package/src/shared-tree/index.ts

@@ -43,6 +43,8 @@ export type {
 	SharedTreeEditBuilder,
 } from "./sharedTreeEditBuilder.js";
 
+export { minimize } from "./transactionMinimize.js";
+
 export { Tree } from "./tree.js";
 export type { RunTransaction } from "./tree.js";
 
@@ -57,6 +59,7 @@ export {
 	type ViewContent,
 	independentView,
 	type IndependentViewOptions,
+	type IndependentViewTelemetryOptions,
 	createIndependentTreeBeta,
 	createIndependentTreeAlpha,
 	type CreateIndependentTreeAlphaOptions,

package/src/shared-tree/schematizingTreeView.ts

@@ -32,7 +32,7 @@ import {
 	tryGetTreeNodeForField,
 	setField,
 	normalizeFieldSchema,
-	SchemaCompatibilityTester,
+	checkSchemaCompatibility,
 	type InsertableContent,
 	type TreeViewConfiguration,
 	type TreeViewAlpha,
@@ -57,6 +57,7 @@ import {
 	toInitialSchema,
 	toUpgradeSchema,
 	type TreeBranchAlpha,
+	type TreeSchema,
 } from "../simple-tree/index.js";
 import {
 	type Breakable,
@@ -98,7 +99,7 @@ export class SchematizingSimpleTreeView<
 		IEmitter<TreeViewEvents & TreeBranchEvents> &
 		HasListeners<TreeViewEvents & TreeBranchEvents> = createEmitter();
 
-	private readonly viewSchema: SchemaCompatibilityTester;
+	private readonly viewSchema: TreeSchema;
 
 	/**
 	 * Events to unregister upon flex-tree view disposal.
@@ -143,7 +144,7 @@ export class SchematizingSimpleTreeView<
 
 		const configAlpha = new TreeViewConfigurationAlpha({ schema: config.schema });
 
-		this.viewSchema = new SchemaCompatibilityTester(configAlpha);
+		this.viewSchema = configAlpha;
 		// This must be initialized before `update` can be called.
 		this.currentCompatibility = {
 			canView: false,
@@ -258,7 +259,7 @@ export class SchematizingSimpleTreeView<
 			);
 		}
 
-		const newSchema = toUpgradeSchema(this.viewSchema.viewSchema.root);
+		const newSchema = toUpgradeSchema(this.viewSchema.root);
 		this.runSchemaEdit(() => this.checkout.updateSchema(newSchema));
 	}
 
@@ -347,7 +348,10 @@ export class SchematizingSimpleTreeView<
 	private update(): void {
 		this.disposeFlexView();
 
-		const compatibility = this.viewSchema.checkCompatibility(this.checkout.storedSchema);
+		const compatibility = checkSchemaCompatibility(
+			this.viewSchema,
+			this.checkout.storedSchema,
+		);
 
 		this.currentCompatibility = {
 			...compatibility,
@@ -533,5 +537,11 @@ export class SchematizingSimpleTreeView<
 		return this.checkout.isMissingEditsFrom(context);
 	}
 
+	public computeNetChangeIfRebasedOnto(
+		context: TreeBranchAlpha,
+	): JsonCompatibleReadOnly | undefined {
+		return this.checkout.computeNetChangeIfRebasedOnto(context);
+	}
+
 	// #endregion Branching
 }