@fluidframework/tree 2.0.0-dev-rc.1.0.0.224419

package/src/shared-tree/sharedTree.ts

@@ -0,0 +1,443 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import {
+	IChannelAttributes,
+	IChannelFactory,
+	IChannelServices,
+	IChannelStorageService,
+	IFluidDataStoreRuntime,
+} from "@fluidframework/datastore-definitions";
+import { ISharedObject } from "@fluidframework/shared-object-base";
+import { assert } from "@fluidframework/core-utils";
+import { UsageError } from "@fluidframework/telemetry-utils";
+import { ICodecOptions, noopValidator } from "../codec";
+import {
+	Compatibility,
+	FieldKey,
+	TreeStoredSchemaRepository,
+	JsonableTree,
+	TreeStoredSchema,
+	makeDetachedFieldIndex,
+	moveToDetachedField,
+	rootFieldKey,
+	schemaDataIsEmpty,
+} from "../core";
+import { SharedTreeCore } from "../shared-tree-core";
+import {
+	defaultSchemaPolicy,
+	ForestSummarizer,
+	SchemaSummarizer,
+	buildForest,
+	TreeFieldSchema,
+	buildChunkedForest,
+	makeTreeChunker,
+	DetachedFieldIndexSummarizer,
+	createNodeKeyManager,
+	nodeKeyFieldKey as defailtNodeKeyFieldKey,
+	jsonableTreeFromFieldCursor,
+	TreeCompressionStrategy,
+	FlexTreeSchema,
+	ViewSchema,
+	NodeKeyManager,
+	FieldKinds,
+	normalizeNewFieldContent,
+	makeMitigatedChangeFamily,
+	makeFieldBatchCodec,
+} from "../feature-libraries";
+import { HasListeners, IEmitter, ISubscribable, createEmitter } from "../events";
+import { brand, disposeSymbol, fail } from "../util";
+import {
+	ITree,
+	TreeConfiguration,
+	WrapperTreeView as ClassWrapperTreeView,
+	toFlexConfig,
+	ImplicitFieldSchema,
+	TreeFieldFromImplicitField,
+	TreeView,
+} from "../class-tree";
+import {
+	InitializeAndSchematizeConfiguration,
+	afterSchemaChanges,
+	initializeContent,
+	schematize,
+} from "./schematizedTree";
+import { TreeCheckout, CheckoutEvents, createTreeCheckout } from "./treeCheckout";
+import { FlexTreeView, CheckoutFlexTreeView } from "./treeView";
+import { SharedTreeChange } from "./sharedTreeChangeTypes";
+import { SharedTreeChangeFamily } from "./sharedTreeChangeFamily";
+import { SharedTreeEditBuilder } from "./sharedTreeEditBuilder";
+
+/**
+ * Copy of data from an {@link ISharedTree} at some point in time.
+ * @remarks
+ * This is unrelated to Fluids concept of "snapshots".
+ * @internal
+ */
+export interface SharedTreeContentSnapshot {
+	/**
+	 * The schema stored in the document.
+	 *
+	 * @remarks
+	 * Edits to the schema can mutate the schema stored of the tree which took this snapshot (but this snapshot will remain the same)
+	 * This is mainly useful for debugging cases where schematize reports an incompatible view schema.
+	 */
+	readonly schema: TreeStoredSchema;
+	/**
+	 * All {@link TreeStatus#InDocument} content.
+	 */
+	readonly tree: JsonableTree[];
+	/**
+	 * All {@link TreeStatus#Removed} content.
+	 */
+	readonly removed: [string | number | undefined, number, JsonableTree][];
+}
+
+/**
+ * Collaboratively editable tree distributed data-structure,
+ * powered by {@link @fluidframework/shared-object-base#ISharedObject}.
+ *
+ * See [the README](../../README.md) for details.
+ * @internal
+ */
+export interface ISharedTree extends ISharedObject, ITree {
+	/**
+	 * Provides a copy of the current content of the tree.
+	 * This can be useful for inspecting the tree when no suitable view schema is available.
+	 * This is only intended for use in testing and exceptional code paths: it is not performant.
+	 *
+	 * This does not include everything that is included in a tree summary, since information about how to merge future edits is omitted.
+	 */
+	contentSnapshot(): SharedTreeContentSnapshot;
+
+	/**
+	 * Like {@link ITree.schematize}, but uses the flex-tree schema system and exposes the tree as a flex-tree.
+	 * @privateRemarks
+	 * This has to avoid its name colliding with `schematize`.
+	 * TODO: Either ITree and ISharedTree should be split into separate objects, the methods should be merged or a better convention for resolving such name conflicts should be selected.
+	 */
+	schematizeInternal<TRoot extends TreeFieldSchema>(
+		config: InitializeAndSchematizeConfiguration<TRoot>,
+	): FlexTreeView<TRoot>;
+
+	/**
+	 * Like {@link ISharedTree.schematizeInternal}, but will never modify the document.
+	 *
+	 * @param schema - The view schema to use.
+	 * @param onSchemaIncompatible - A callback.
+	 * Invoked when the returned ISharedTreeView becomes invalid to use due to a change to the stored schema which makes it incompatible with the view schema.
+	 * Called at most once.
+	 * @returns a view compatible with the provided schema, or undefined if the stored schema is not compatible with the provided view schema.
+	 * If this becomes invalid to use due to a change in the stored schema, onSchemaIncompatible will be invoked.
+	 *
+	 * @privateRemarks
+	 * TODO:
+	 * Once views actually have a view schema, onSchemaIncompatible can become an event on the view (which ends its lifetime),
+	 * instead of a separate callback.
+	 */
+	requireSchema<TRoot extends TreeFieldSchema>(
+		schema: FlexTreeSchema<TRoot>,
+		onSchemaIncompatible: () => void,
+	): FlexTreeView<TRoot> | undefined;
+}
+
+/**
+ * Shared tree, configured with a good set of indexes and field kinds which will maintain compatibility over time.
+ *
+ * TODO: detail compatibility requirements.
+ */
+export class SharedTree
+	extends SharedTreeCore<SharedTreeEditBuilder, SharedTreeChange>
+	implements ISharedTree
+{
+	private readonly _events: ISubscribable<CheckoutEvents> &
+		IEmitter<CheckoutEvents> &
+		HasListeners<CheckoutEvents>;
+	public readonly view: TreeCheckout;
+	public get storedSchema(): TreeStoredSchemaRepository {
+		return this.view.storedSchema;
+	}
+
+	/**
+	 * Creating multiple editable tree contexts for the same branch, and thus with the same underlying AnchorSet does not work due to how TreeNode caching works.
+	 * This flag is used to detect if one already exists for the main branch and error if creating a second.
+	 * THis should catch most accidental violations of this restriction but there are still ways to create two conflicting contexts (for example calling constructing one manually).
+	 *
+	 * TODO:
+	 * 1. API docs need to reflect this limitation or the limitation has to be removed.
+	 */
+	private hasView2 = false;
+
+	public constructor(
+		id: string,
+		runtime: IFluidDataStoreRuntime,
+		attributes: IChannelAttributes,
+		optionsParam: SharedTreeOptions,
+		telemetryContextPrefix: string,
+	) {
+		const options = { ...defaultSharedTreeOptions, ...optionsParam };
+		const schema = new TreeStoredSchemaRepository();
+		const forest =
+			options.forest === ForestType.Optimized
+				? buildChunkedForest(makeTreeChunker(schema, defaultSchemaPolicy))
+				: buildForest();
+		const removedRoots = makeDetachedFieldIndex("repair", options);
+		const schemaSummarizer = new SchemaSummarizer(runtime, schema, options, {
+			getCurrentSeq: () => this.runtime.deltaManager.lastSequenceNumber,
+		});
+		const fieldBatchCodec = makeFieldBatchCodec(options);
+		const forestSummarizer = new ForestSummarizer(
+			forest,
+			schema,
+			defaultSchemaPolicy,
+			options.summaryEncodeType,
+			fieldBatchCodec,
+			options,
+		);
+		const removedRootsSummarizer = new DetachedFieldIndexSummarizer(removedRoots);
+		const innerChangeFamily = new SharedTreeChangeFamily(options);
+		const changeFamily = makeMitigatedChangeFamily(
+			innerChangeFamily,
+			SharedTreeChangeFamily.emptyChange,
+			(error: unknown) => {
+				// TODO:6344 Add telemetry for these errors.
+				// Rethrowing the error has a different effect depending on the context in which the
+				// ChangeFamily was invoked:
+				// - If the ChangeFamily was invoked as part of incoming op processing, rethrowing the error
+				// will cause the runtime to disconnect the client, log a severe error, and not reconnect.
+				// This will not cause the host application to crash because it is not on the stack at that time.
+				// TODO: let the host application know that the client is now disconnected.
+				// - If the ChangeFamily was invoked as part of dealing with a local change, rethrowing the
+				// error will cause the host application to crash. This is not ideal, but is better than
+				// letting the application either send an invalid change to the server or allowing the
+				// application to continue working when its local branches contain edits that cannot be
+				// reflected in its views.
+				// The best course of action for a host application in such a state is to restart.
+				// TODO: let the host application know about this situation and provide a way to
+				// programmatically reload the SharedTree container.
+				throw error;
+			},
+		);
+		super(
+			[schemaSummarizer, forestSummarizer, removedRootsSummarizer],
+			changeFamily,
+			options,
+			id,
+			runtime,
+			attributes,
+			telemetryContextPrefix,
+		);
+		this._events = createEmitter<CheckoutEvents>();
+		const localBranch = this.getLocalBranch();
+		this.view = createTreeCheckout({
+			branch: localBranch,
+			changeFamily,
+			schema,
+			forest,
+			events: this._events,
+			removedRoots,
+		});
+	}
+
+	public requireSchema<TRoot extends TreeFieldSchema>(
+		schema: FlexTreeSchema<TRoot>,
+		onSchemaIncompatible: () => void,
+		nodeKeyManager?: NodeKeyManager,
+		nodeKeyFieldKey?: FieldKey,
+	): CheckoutFlexTreeView<TRoot> | undefined {
+		assert(this.hasView2 === false, 0x7f1 /* Cannot create second view from tree. */);
+
+		const viewSchema = new ViewSchema(defaultSchemaPolicy, {}, schema);
+		const compatibility = viewSchema.checkCompatibility(this.storedSchema);
+		if (
+			compatibility.write !== Compatibility.Compatible ||
+			compatibility.read !== Compatibility.Compatible
+		) {
+			return undefined;
+		}
+
+		this.hasView2 = true;
+		const view2 = new CheckoutFlexTreeView(
+			this.view,
+			schema,
+			nodeKeyManager ?? createNodeKeyManager(this.runtime.idCompressor),
+			nodeKeyFieldKey ?? brand(defailtNodeKeyFieldKey),
+			() => {
+				assert(this.hasView2, 0x7f2 /* unexpected dispose */);
+				this.hasView2 = false;
+			},
+		);
+		const onSchemaChange = () => {
+			const compatibilityInner = viewSchema.checkCompatibility(this.storedSchema);
+			if (
+				compatibilityInner.write !== Compatibility.Compatible ||
+				compatibilityInner.read !== Compatibility.Compatible
+			) {
+				view2[disposeSymbol]();
+				onSchemaIncompatible();
+				return false;
+			} else {
+				return true;
+			}
+		};
+
+		afterSchemaChanges(this._events, this.view, onSchemaChange);
+		return view2;
+	}
+
+	public contentSnapshot(): SharedTreeContentSnapshot {
+		const cursor = this.view.forest.allocateCursor();
+		try {
+			moveToDetachedField(this.view.forest, cursor);
+			return {
+				schema: this.storedSchema.clone(),
+				tree: jsonableTreeFromFieldCursor(cursor),
+				removed: this.view.getRemovedRoots(),
+			};
+		} finally {
+			cursor.free();
+		}
+	}
+
+	public schematizeInternal<TRoot extends TreeFieldSchema>(
+		config: InitializeAndSchematizeConfiguration<TRoot>,
+		nodeKeyManager?: NodeKeyManager,
+		nodeKeyFieldKey?: FieldKey,
+	): CheckoutFlexTreeView<TRoot> {
+		if (this.hasView2 === true) {
+			throw new UsageError(
+				"Only one view can be constructed from a given tree at a time. Dispose of the first before creating a second.",
+			);
+		}
+		// TODO:
+		// When this becomes a more proper out of schema adapter, editing should be made lazy.
+		// This will improve support for readonly documents, cross version collaboration and attribution.
+
+		// Check for empty.
+		if (this.view.forest.isEmpty && schemaDataIsEmpty(this.storedSchema)) {
+			this.view.transaction.start();
+			initializeContent(this.view, config.schema, () => {
+				const field = { field: rootFieldKey, parent: undefined };
+				const content = normalizeNewFieldContent(
+					{ schema: config.schema },
+					config.schema.rootFieldSchema,
+					config.initialTree,
+				);
+				switch (this.storedSchema.rootFieldSchema.kind.identifier) {
+					case FieldKinds.optional.identifier: {
+						const fieldEditor = this.editor.optionalField(field);
+						assert(
+							content.length <= 1,
+							0x7f4 /* optional field content should normalize at most one item */,
+						);
+						fieldEditor.set(content.length === 0 ? undefined : content[0], true);
+						break;
+					}
+					case FieldKinds.sequence.identifier: {
+						const fieldEditor = this.editor.sequenceField(field);
+						// TODO: should do an idempotent edit here.
+						fieldEditor.insert(0, content);
+						break;
+					}
+					default: {
+						fail("unexpected root field kind during initialize");
+					}
+				}
+			});
+			this.view.transaction.commit();
+		}
+
+		schematize(this.view.events, this.view, config);
+
+		return (
+			this.requireSchema(
+				config.schema,
+				() => fail("schema incompatible"),
+				nodeKeyManager,
+				nodeKeyFieldKey,
+			) ?? fail("Schematize failed")
+		);
+	}
+
+	public schematize<TRoot extends ImplicitFieldSchema>(
+		config: TreeConfiguration<TRoot>,
+	): TreeView<TreeFieldFromImplicitField<TRoot>> {
+		const flexConfig = toFlexConfig(config);
+		const view = this.schematizeInternal(flexConfig);
+		return new ClassWrapperTreeView(view);
+	}
+
+	protected override async loadCore(services: IChannelStorageService): Promise<void> {
+		await super.loadCore(services);
+		this._events.emit("afterBatch");
+	}
+}
+
+/**
+ * @internal
+ */
+export interface SharedTreeOptions extends Partial<ICodecOptions> {
+	/**
+	 * The {@link ForestType} indicating which forest type should be created for the SharedTree.
+	 */
+	forest?: ForestType;
+	summaryEncodeType?: TreeCompressionStrategy;
+}
+
+/**
+ * Used to distinguish between different forest types.
+ * @internal
+ */
+export enum ForestType {
+	/**
+	 * The "ObjectForest" forest type.
+	 */
+	Reference = 0,
+	/**
+	 * The "ChunkedForest" forest type.
+	 */
+	Optimized = 1,
+}
+
+// TODO: The default summaryEncodeType is set to Uncompressed as there are many out of schema tests that break when using Compressed.
+// This should eventually be changed to use Compressed as the default tree compression strategy so production gets the compressed format.
+export const defaultSharedTreeOptions: Required<SharedTreeOptions> = {
+	jsonValidator: noopValidator,
+	forest: ForestType.Reference,
+	summaryEncodeType: TreeCompressionStrategy.Uncompressed,
+};
+
+/**
+ * A channel factory that creates {@link ISharedTree}s.
+ * @internal
+ */
+export class SharedTreeFactory implements IChannelFactory {
+	public readonly type: string = "https://graph.microsoft.com/types/tree";
+
+	public readonly attributes: IChannelAttributes = {
+		type: this.type,
+		snapshotFormatVersion: "0.0.0",
+		packageVersion: "0.0.0",
+	};
+
+	public constructor(private readonly options: SharedTreeOptions = {}) {}
+
+	public async load(
+		runtime: IFluidDataStoreRuntime,
+		id: string,
+		services: IChannelServices,
+		channelAttributes: Readonly<IChannelAttributes>,
+	): Promise<ISharedTree> {
+		const tree = new SharedTree(id, runtime, channelAttributes, this.options, "SharedTree");
+		await tree.load(services);
+		return tree;
+	}
+
+	public create(runtime: IFluidDataStoreRuntime, id: string): ISharedTree {
+		const tree = new SharedTree(id, runtime, this.attributes, this.options, "SharedTree");
+		tree.initializeLocal();
+		return tree;
+	}
+}

package/src/shared-tree/sharedTreeChangeCodecs.ts

@@ -0,0 +1,79 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import {
+	IJsonCodec,
+	ICodecOptions,
+	ICodecFamily,
+	makeCodecFamily,
+	DiscriminatedUnionDispatcher,
+} from "../codec";
+import { Mutable } from "../util";
+import {
+	EncodedModularChangeset,
+	ModularChangeset,
+	makeSchemaChangeCodec,
+} from "../feature-libraries";
+import { SharedTreeChange, SharedTreeInnerChange } from "./sharedTreeChangeTypes";
+import { EncodedSharedTreeChange, EncodedSharedTreeInnerChange } from "./sharedTreeChangeFormat";
+
+export function makeSharedTreeChangeCodec(
+	modularChangeCodec: IJsonCodec<ModularChangeset, EncodedModularChangeset>,
+	codecOptions: ICodecOptions,
+): IJsonCodec<SharedTreeChange, EncodedSharedTreeChange> {
+	const schemaChangeCodec = makeSchemaChangeCodec(codecOptions);
+
+	const decoderLibrary = new DiscriminatedUnionDispatcher<
+		EncodedSharedTreeInnerChange,
+		[],
+		SharedTreeInnerChange
+	>({
+		data(encoded): SharedTreeInnerChange {
+			return {
+				type: "data",
+				innerChange: modularChangeCodec.decode(encoded),
+			};
+		},
+		schema(encoded): SharedTreeInnerChange {
+			return {
+				type: "schema",
+				innerChange: schemaChangeCodec.decode(encoded),
+			};
+		},
+	});
+
+	return {
+		encode: (change) => {
+			const changes: EncodedSharedTreeInnerChange[] = [];
+			for (const decodedChange of change.changes) {
+				if (decodedChange.type === "data") {
+					changes.push({
+						data: modularChangeCodec.encode(decodedChange.innerChange),
+					});
+				} else if (decodedChange.type === "schema") {
+					changes.push({
+						schema: schemaChangeCodec.encode(decodedChange.innerChange),
+					});
+				}
+			}
+			return changes;
+		},
+		decode: (encodedChange) => {
+			const changes: Mutable<SharedTreeChange["changes"]> = [];
+			for (const subChange of encodedChange) {
+				changes.push(decoderLibrary.dispatch(subChange));
+			}
+			return { changes };
+		},
+		encodedSchema: EncodedSharedTreeChange,
+	};
+}
+
+export function makeSharedTreeChangeCodecFamily(
+	modularChangeCodec: IJsonCodec<ModularChangeset, EncodedModularChangeset>,
+	options: ICodecOptions,
+): ICodecFamily<SharedTreeChange> {
+	return makeCodecFamily([[0, makeSharedTreeChangeCodec(modularChangeCodec, options)]]);
+}

package/src/shared-tree/sharedTreeChangeFamily.ts

@@ -0,0 +1,170 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { assert } from "@fluidframework/core-utils";
+import { ICodecFamily, ICodecOptions } from "../codec";
+import {
+	ChangeFamily,
+	ChangeRebaser,
+	RevisionMetadataSource,
+	TaggedChange,
+	mapTaggedChange,
+} from "../core";
+import { fieldKinds, ModularChangeFamily, ModularChangeset } from "../feature-libraries";
+import { Mutable, fail } from "../util";
+import { RevisionTagCodec } from "../shared-tree-core";
+import { makeSharedTreeChangeCodecFamily } from "./sharedTreeChangeCodecs";
+import { SharedTreeChange } from "./sharedTreeChangeTypes";
+import { SharedTreeEditBuilder } from "./sharedTreeEditBuilder";
+
+/**
+ * Implementation of {@link ChangeFamily} that combines edits to fields and schema changes.
+ *
+ * @sealed
+ */
+export class SharedTreeChangeFamily
+	implements
+		ChangeFamily<SharedTreeEditBuilder, SharedTreeChange>,
+		ChangeRebaser<SharedTreeChange>
+{
+	public static readonly emptyChange: SharedTreeChange = {
+		changes: [],
+	};
+
+	public readonly codecs: ICodecFamily<SharedTreeChange>;
+	private readonly modularChangeFamily: ModularChangeFamily;
+
+	public constructor(codecOptions: ICodecOptions) {
+		this.modularChangeFamily = new ModularChangeFamily(
+			fieldKinds,
+			new RevisionTagCodec(),
+			codecOptions,
+		);
+		this.codecs = makeSharedTreeChangeCodecFamily(
+			this.modularChangeFamily.latestCodec,
+			codecOptions,
+		);
+	}
+
+	public buildEditor(changeReceiver: (change: SharedTreeChange) => void): SharedTreeEditBuilder {
+		return new SharedTreeEditBuilder(this.modularChangeFamily, changeReceiver);
+	}
+
+	public compose(changes: TaggedChange<SharedTreeChange>[]): SharedTreeChange {
+		const newChanges: Mutable<SharedTreeChange["changes"]> = [];
+		const dataChangeRun: TaggedChange<ModularChangeset>[] = [];
+
+		const flushDataChangeRun = (): void => {
+			if (dataChangeRun.length > 0) {
+				newChanges.push({
+					type: "data",
+					innerChange: this.modularChangeFamily.compose(dataChangeRun),
+				});
+				dataChangeRun.length = 0;
+			}
+		};
+
+		for (const topChange of changes) {
+			for (const change of topChange.change.changes) {
+				if (change.type === "schema") {
+					flushDataChangeRun();
+					newChanges.push(change);
+				} else {
+					dataChangeRun.push(mapTaggedChange(topChange, change.innerChange));
+				}
+			}
+		}
+
+		flushDataChangeRun();
+		return { changes: newChanges };
+	}
+
+	public invert(change: TaggedChange<SharedTreeChange>, isRollback: boolean): SharedTreeChange {
+		const invertInnerChange: (
+			innerChange: SharedTreeChange["changes"][number],
+		) => SharedTreeChange["changes"][number] = (innerChange) => {
+			switch (innerChange.type) {
+				case "data":
+					return {
+						type: "data",
+						innerChange: this.modularChangeFamily.invert(
+							mapTaggedChange(change, innerChange.innerChange),
+							isRollback,
+						),
+					};
+				case "schema": {
+					return {
+						type: "schema",
+						innerChange: {
+							schema: {
+								new: innerChange.innerChange.schema.old,
+								old: innerChange.innerChange.schema.new,
+							},
+						},
+					};
+				}
+				default:
+					fail("Unknown SharedTree change type.");
+			}
+		};
+		return {
+			changes: change.change.changes.map(invertInnerChange).reverse(),
+		};
+	}
+
+	public rebase(
+		change: SharedTreeChange,
+		over: TaggedChange<SharedTreeChange>,
+		revisionMetadata: RevisionMetadataSource,
+	): SharedTreeChange {
+		if (change.changes.length === 0 || over.change.changes.length === 0) {
+			return change;
+		}
+
+		if (hasSchemaChange(change) || hasSchemaChange(over.change)) {
+			// Any SharedTreeChange (a list of sub-changes) that contains a schema change will cause ANY change that rebases over it to conflict.
+			// Similarly, any SharedTreeChange containing a schema change will fail to rebase over ANY change.
+			// Those two combine to mean: no concurrency with schema changes is supported.
+			// This is fine because it's an open problem. Example: a tree with an A at the root and a schema that allows an A | B at the root will
+			// become out of schema if a schema changes to restrict root types to just A is concurrent with a data change that sets it to a B.
+			// We don't have an efficient way to detect this document-wide and there are varying opinions on restricting schema changes to prevent this.
+			// A SharedTreeChange containing a schema change will NOT conflict in a non-concurrency case, as the "meatless sandwich" optimization
+			// will result in rebase never being called.
+			return SharedTreeChangeFamily.emptyChange;
+		}
+		assert(
+			change.changes.length === 1 && over.change.changes.length === 1,
+			"SharedTreeChange should have exactly one inner change if no schema change is present.",
+		);
+
+		const dataChangeIntention = change.changes[0];
+		const dataChangeOver = over.change.changes[0];
+		assert(
+			dataChangeIntention.type === "data" && dataChangeOver.type === "data",
+			"Data change should be present.",
+		);
+
+		return {
+			changes: [
+				{
+					type: "data",
+					innerChange: this.modularChangeFamily.rebase(
+						dataChangeIntention.innerChange,
+						mapTaggedChange(over, dataChangeOver.innerChange),
+						revisionMetadata,
+					),
+				},
+			],
+		};
+	}
+
+	public get rebaser(): ChangeRebaser<SharedTreeChange> {
+		return this;
+	}
+}
+
+function hasSchemaChange(change: SharedTreeChange): boolean {
+	return change.changes.some((innerChange) => innerChange.type === "schema");
+}

package/src/shared-tree/sharedTreeChangeFormat.ts

@@ -0,0 +1,18 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { Static, Type } from "@sinclair/typebox";
+import { EncodedSchemaChange, EncodedModularChangeset } from "../feature-libraries";
+
+export const EncodedSharedTreeInnerChange = Type.Object({
+	schema: Type.Optional(EncodedSchemaChange),
+	data: Type.Optional(EncodedModularChangeset),
+});
+
+export type EncodedSharedTreeInnerChange = Static<typeof EncodedSharedTreeInnerChange>;
+
+export const EncodedSharedTreeChange = Type.Array(EncodedSharedTreeInnerChange);
+
+export type EncodedSharedTreeChange = Static<typeof EncodedSharedTreeChange>;