@fluidframework/tree 2.0.0-dev-rc.1.0.0.224419

package/src/feature-libraries/optional-field/optionalFieldChangeTypes.ts

@@ -0,0 +1,59 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { ChangeAtomId } from "../../core";
+import { NodeChangeset } from "../modular-schema";
+
+/**
+ * Uniquely identifies a register within the scope of this changeset.
+ * The sentinel value "self" is used for the active register, which is a universally shared register
+ * (as in, any changeset referring to "self" refers to the register containing the active value of the field).
+ *
+ * See the model description in {@link OptionalChangeset} for more details.
+ */
+export type RegisterId = ChangeAtomId | "self";
+
+/**
+ * Changes to an optional field.
+ *
+ * The model used is that optional field consists of a collection of "registers" with one designated as the "active" register.
+ * In a given change input or output context, registers may hold 0 or 1 nodes.
+ * Each register is identified using a {@link RegisterId}.
+ * The active register holds the current value of the field, and other registers hold detached roots.
+ */
+export interface OptionalChangeset {
+	/**
+	 * Each entry signifies the intent to move a node from `src` to `dst`.
+	 *
+	 * These entries should not be interpreted as "applied one after the other", but rather as "applied simultaneously".
+	 * As such, changesets should not contain duplicated src or dst entries (lest they populate the same register twice,
+	 * or try to move a node to two different places).
+	 *
+	 * The third entry specifies whether the "intent" of the move is to target a specific source register ("cellTargeting") OR to
+	 * target the node that currently happens to occupy some source register ("nodeTargeting").
+	 * This is relevant when considering how changes should be rebased.
+	 *
+	 * Rebasing logic should only generate moves whose `src` is an occupied register.
+	 */
+	moves: (readonly [src: RegisterId, dst: RegisterId, kind: "nodeTargeting" | "cellTargeting"])[];
+
+	/**
+	 * Nested changes to nodes that occupy registers.
+	 *
+	 * Nodes are identified by the register they occupy in the *input* context of the changeset.
+	 */
+	childChanges: [register: RegisterId, childChange: NodeChangeset][];
+
+	/**
+	 * Set iff:
+	 * 1. This change intends to populate a register (call it `foo`)
+	 * 2. That register is currently unoccupied
+	 *
+	 * In such cases, this changeset should not include a move with source `foo`, since `foo` is empty.
+	 * However, if this changeset is then rebased over a change which populates `foo`, the rebased changeset must now empty `foo`.
+	 * This reserved id is used as the destination of that emptying move.
+	 */
+	reservedDetachId?: RegisterId;
+}

package/src/feature-libraries/optional-field/optionalFieldCodecs.ts

@@ -0,0 +1,114 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { TAnySchema, Type } from "@sinclair/typebox";
+import { ICodecFamily, IJsonCodec, makeCodecFamily, unitCodec } from "../../codec";
+import { EncodedRevisionTag, RevisionTag } from "../../core";
+import { Mutable } from "../../util";
+import type { NodeChangeset } from "../modular-schema";
+import type { OptionalChangeset, RegisterId } from "./optionalFieldChangeTypes";
+import { EncodedOptionalChangeset, EncodedRegisterId } from "./optionalFieldChangeFormat";
+
+export const noChangeCodecFamily: ICodecFamily<0> = makeCodecFamily([[0, unitCodec]]);
+
+export const makeOptionalFieldCodecFamily = (
+	childCodec: IJsonCodec<NodeChangeset>,
+	revisionTagCodec: IJsonCodec<RevisionTag, EncodedRevisionTag>,
+): ICodecFamily<OptionalChangeset> =>
+	makeCodecFamily([[0, makeOptionalFieldCodec(childCodec, revisionTagCodec)]]);
+
+function makeRegisterIdCodec(
+	revisionTagCodec: IJsonCodec<RevisionTag, EncodedRevisionTag>,
+): IJsonCodec<RegisterId, EncodedRegisterId> {
+	return {
+		encode: (registerId: RegisterId) => {
+			if (registerId === "self") {
+				return 0;
+			}
+
+			const encodedRegisterId: EncodedRegisterId = { localId: registerId.localId };
+			if (registerId.revision !== undefined) {
+				encodedRegisterId.revision = revisionTagCodec.encode(registerId.revision);
+			}
+
+			return encodedRegisterId;
+		},
+		decode: (registerId: EncodedRegisterId) => {
+			if (registerId === 0) {
+				return "self";
+			}
+
+			const decodedRegisterId: Mutable<RegisterId> = { localId: registerId.localId };
+			if (registerId.revision !== undefined) {
+				decodedRegisterId.revision = revisionTagCodec.decode(registerId.revision);
+			}
+
+			return decodedRegisterId;
+		},
+		encodedSchema: EncodedRegisterId,
+	};
+}
+
+function makeOptionalFieldCodec(
+	childCodec: IJsonCodec<NodeChangeset>,
+	revisionTagCodec: IJsonCodec<RevisionTag, EncodedRevisionTag>,
+): IJsonCodec<OptionalChangeset, EncodedOptionalChangeset<TAnySchema>> {
+	const registerIdCodec = makeRegisterIdCodec(revisionTagCodec);
+
+	return {
+		encode: (change: OptionalChangeset) => {
+			const encoded: EncodedOptionalChangeset<TAnySchema> = {};
+			if (change.moves.length > 0) {
+				encoded.m = [];
+				for (const [src, dst, type] of change.moves) {
+					encoded.m.push([
+						registerIdCodec.encode(src),
+						registerIdCodec.encode(dst),
+						type === "nodeTargeting",
+					]);
+				}
+			}
+
+			if (change.childChanges.length > 0) {
+				encoded.c = [];
+				for (const [id, childChange] of change.childChanges) {
+					encoded.c.push([registerIdCodec.encode(id), childCodec.encode(childChange)]);
+				}
+			}
+
+			if (change.reservedDetachId !== undefined) {
+				encoded.d = registerIdCodec.encode(change.reservedDetachId);
+			}
+
+			return encoded;
+		},
+
+		decode: (encoded: EncodedOptionalChangeset<TAnySchema>) => {
+			const moves: OptionalChangeset["moves"] =
+				encoded.m?.map(
+					([src, dst, type]) =>
+						[
+							registerIdCodec.decode(src),
+							registerIdCodec.decode(dst),
+							type ? ("nodeTargeting" as const) : ("cellTargeting" as const),
+						] as const,
+				) ?? [];
+			const decoded: OptionalChangeset = {
+				moves,
+				childChanges:
+					encoded.c?.map(([id, encodedChange]) => [
+						registerIdCodec.decode(id),
+						childCodec.decode(encodedChange),
+					]) ?? [],
+			};
+
+			if (encoded.d !== undefined) {
+				decoded.reservedDetachId = registerIdCodec.decode(encoded.d);
+			}
+			return decoded;
+		},
+		encodedSchema: EncodedOptionalChangeset(childCodec.encodedSchema ?? Type.Any()),
+	};
+}

package/src/feature-libraries/schema-aware/README.md

@@ -0,0 +1,19 @@
+# schema-aware
+
+Library for creating "schema aware" APIs, meaning APIs that use strong types based on schema.
+
+TODO:
+
+    - Generate the actual APIs we need for use with Tree:
+        - Flexible should align with `ContextuallyTypedNodeData`
+        - Normalized should align with `EditableTree`. This will likely require an extra setter on editable fields and on `EditableTree` for extra fields to work around [lacking support for variant accessors for index signatures in TypeScript](https://github.com/microsoft/TypeScript/issues/43826).
+    - Allow use in libraries which don't have full schema information:
+        - Make unrestricted field types include an extra type in the union that covers the other cases generically.
+    - Support extra map fields.
+    - Support extra global fields (including in a way that is compatible with use in a library that does not have global schema knowledge).
+    - Measure compiler performance, and ensure its good enough and we have a way to track it.
+
+TODO2:
+
+-   Explicit primitive schema and primary fields in schema objects.
+-   Schema sanity check somewhere (when building schema data): runtime error on missing schema types, fields, anything thats a Never node etc. Specific Error on infinite recursion.

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

@@ -0,0 +1,17 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+export {
+	InsertableFlexNode,
+	InsertableFlexField,
+	AllowedTypesToFlexInsertableTree,
+	ApplyMultiplicity,
+
+	// Internal
+	CollectOptions,
+	TypedFields,
+	UnbrandedName,
+	EmptyObject,
+} from "./schemaAware";

package/src/feature-libraries/schema-aware/schemaAware.ts

@@ -0,0 +1,123 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { TreeNodeSchemaIdentifier, TreeValue, ValueSchema } from "../../core";
+import { ContextuallyTypedNodeData, typeNameSymbol, valueSymbol } from "../contextuallyTyped";
+import {
+	TreeFieldSchema,
+	TreeNodeSchema,
+	AllowedTypes,
+	LeafNodeSchema,
+	ObjectNodeSchema,
+	Fields,
+	FieldNodeSchema,
+	MapNodeSchema,
+	FlexListToUnion,
+	LazyItem,
+} from "../typed-schema";
+import { Assume, FlattenKeys, _InlineTrick } from "../../util";
+import { Multiplicity } from "../multiplicity";
+
+/**
+ * Empty Object for use in type computations that should contribute no fields when `&`ed with another type.
+ * @internal
+ */
+// Using {} instead of interface {} or Record<string, never> for empty object here produces better IntelliSense in the generated types than `Record<string, never>` recommended by the linter.
+// Making this a type instead of an interface prevents it from showing up in IntelliSense, and also avoids breaking the typing somehow.
+// eslint-disable-next-line @typescript-eslint/ban-types, @typescript-eslint/consistent-type-definitions
+export type EmptyObject = {};
+
+/**
+ * Collects the various parts of the API together.
+ * @internal
+ */
+export type CollectOptions<
+	TTypedFields,
+	TValueSchema extends ValueSchema | undefined,
+	TName,
+> = TValueSchema extends undefined
+	? FlattenKeys<
+			{ [typeNameSymbol]?: UnbrandedName<TName> } & (TValueSchema extends ValueSchema
+				? { [valueSymbol]: TreeValue<TValueSchema> }
+				: EmptyObject)
+	  > &
+			TTypedFields
+	: TValueSchema extends ValueSchema
+	? TreeValue<TValueSchema>
+	: undefined;
+
+/**
+ * Remove type brand from name.
+ * @internal
+ */
+export type UnbrandedName<TName> = [
+	TName extends TreeNodeSchemaIdentifier<infer S> ? S : string,
+][_InlineTrick];
+
+/**
+ * `{ [key: string]: FieldSchemaTypeInfo }` to `{ [key: string]: TypedTree }`
+ *
+ * In Editable mode, unwraps the fields.
+ * @internal
+ */
+export type TypedFields<TFields extends undefined | { readonly [key: string]: TreeFieldSchema }> = [
+	TFields extends { [key: string]: TreeFieldSchema }
+		? {
+				-readonly [key in keyof TFields]: InsertableFlexField<TFields[key]>;
+		  }
+		: EmptyObject,
+][_InlineTrick];
+
+/**
+ * `TreeFieldSchema` to `TypedField`. May unwrap to child depending on FieldKind.
+ * @internal
+ */
+export type InsertableFlexField<TField extends TreeFieldSchema> = [
+	ApplyMultiplicity<
+		TField["kind"]["multiplicity"],
+		AllowedTypesToFlexInsertableTree<TField["allowedTypes"]>
+	>,
+][_InlineTrick];
+
+/**
+ * Adjusts the API for a field based on its Multiplicity.
+ * @internal
+ */
+export type ApplyMultiplicity<TMultiplicity extends Multiplicity, TypedChild> = {
+	[Multiplicity.Forbidden]: undefined;
+	[Multiplicity.Optional]: undefined | TypedChild;
+	[Multiplicity.Sequence]: TypedChild[];
+	[Multiplicity.Single]: TypedChild;
+}[TMultiplicity];
+
+/**
+ * Takes in `AllowedTypes` and returns a TypedTree union.
+ * @internal
+ */
+export type AllowedTypesToFlexInsertableTree<T extends AllowedTypes> = [
+	T extends readonly LazyItem<TreeNodeSchema>[]
+		? InsertableFlexNode<Assume<FlexListToUnion<T>, TreeNodeSchema>>
+		: ContextuallyTypedNodeData,
+][_InlineTrick];
+
+/**
+ * Generate a schema aware API for a single tree schema.
+ * @internal
+ */
+export type InsertableFlexNode<TSchema extends TreeNodeSchema> = FlattenKeys<
+	CollectOptions<
+		TSchema extends ObjectNodeSchema<string, infer TFields extends Fields>
+			? TypedFields<TFields>
+			: TSchema extends FieldNodeSchema<string, infer TField extends TreeFieldSchema>
+			? InsertableFlexField<TField>
+			: TSchema extends MapNodeSchema<string, infer TField extends TreeFieldSchema>
+			? {
+					readonly [P in string]: InsertableFlexField<TField>;
+			  }
+			: EmptyObject,
+		TSchema extends LeafNodeSchema<string, infer TValueSchema> ? TValueSchema : undefined,
+		TSchema["name"]
+	>
+>;

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

@@ -0,0 +1,8 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+export { makeSchemaChangeCodec } from "./schemaChangeCodecs";
+export { SchemaChange } from "./schemaChangeTypes";
+export { EncodedSchemaChange } from "./schemaChangeFormat";

package/src/feature-libraries/schema-edits/schemaChangeCodecs.ts

@@ -0,0 +1,32 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { ICodecOptions, IJsonCodec } from "../../codec";
+import { makeSchemaCodec } from "../schema-index";
+import { EncodedSchemaChange } from "./schemaChangeFormat";
+import { SchemaChange } from "./schemaChangeTypes";
+
+export function makeSchemaChangeCodec({
+	jsonValidator: validator,
+}: ICodecOptions): IJsonCodec<SchemaChange, EncodedSchemaChange> {
+	const schemaCodec = makeSchemaCodec({ jsonValidator: validator });
+	return {
+		encode: (schemaChange) => {
+			return {
+				new: schemaCodec.encode(schemaChange.schema.new),
+				old: schemaCodec.encode(schemaChange.schema.old),
+			};
+		},
+		decode: (encoded) => {
+			return {
+				schema: {
+					new: schemaCodec.decode(encoded.new),
+					old: schemaCodec.decode(encoded.old),
+				},
+			};
+		},
+		encodedSchema: EncodedSchemaChange,
+	};
+}

package/src/feature-libraries/schema-edits/schemaChangeFormat.ts

@@ -0,0 +1,14 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { Static, Type } from "@sinclair/typebox";
+import { Format } from "../schema-index";
+
+export const EncodedSchemaChange = Type.Object({
+	new: Format,
+	old: Format,
+});
+
+export type EncodedSchemaChange = Static<typeof EncodedSchemaChange>;

package/src/feature-libraries/schema-edits/schemaChangeTypes.ts

@@ -0,0 +1,16 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { TreeStoredSchema } from "../../core";
+
+/**
+ * A change that updates the schema of a Shared Tree.
+ */
+export interface SchemaChange {
+	/**
+	 * This property contains the new stored schema for the document and the old schema for inverting.
+	 */
+	readonly schema: { new: TreeStoredSchema; old: TreeStoredSchema };
+}

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

@@ -0,0 +1,68 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import {
+	TreeStoredSchema,
+	TreeNodeStoredSchema,
+	TreeNodeSchemaIdentifier,
+	schemaFormat,
+	BrandedTreeNodeSchemaDataFormat,
+	decodeFieldSchema,
+	encodeFieldSchema,
+	storedSchemaDecodeDispatcher,
+} from "../../core";
+import { brand, compareNamed, fromErased } from "../../util";
+import { ICodecOptions, IJsonCodec } from "../../codec";
+import { makeVersionedValidatedCodec } from "../versioned";
+import { Format, TreeNodeSchemaFormat } from "./format";
+
+export function encodeRepo(repo: TreeStoredSchema): Format {
+	const treeNodeSchema: TreeNodeSchemaFormat[] = [];
+	const rootFieldSchema = encodeFieldSchema(repo.rootFieldSchema);
+	for (const [name, schema] of repo.nodeSchema) {
+		treeNodeSchema.push(encodeTree(name, schema));
+	}
+	treeNodeSchema.sort(compareNamed);
+	return {
+		version: schemaFormat.version,
+		nodeSchema: treeNodeSchema,
+		rootFieldSchema,
+	};
+}
+
+function encodeTree(
+	name: TreeNodeSchemaIdentifier,
+	schema: TreeNodeStoredSchema,
+): TreeNodeSchemaFormat {
+	const out: TreeNodeSchemaFormat = {
+		name,
+		data: fromErased<BrandedTreeNodeSchemaDataFormat>(schema.encode()),
+	};
+	return out;
+}
+function decodeTree(schema: TreeNodeSchemaFormat): TreeNodeStoredSchema {
+	return storedSchemaDecodeDispatcher.dispatch(schema.data);
+}
+
+function decode(f: Format): TreeStoredSchema {
+	const nodeSchema: Map<TreeNodeSchemaIdentifier, TreeNodeStoredSchema> = new Map();
+	for (const tree of f.nodeSchema) {
+		nodeSchema.set(brand(tree.name), decodeTree(tree));
+	}
+	return {
+		rootFieldSchema: decodeFieldSchema(f.rootFieldSchema),
+		nodeSchema,
+	};
+}
+
+/**
+ * Creates a codec which performs synchronous monolithic encoding of schema content.
+ */
+export function makeSchemaCodec(options: ICodecOptions): IJsonCodec<TreeStoredSchema, Format> {
+	return makeVersionedValidatedCodec(options, new Set([schemaFormat.version]), Format, {
+		encode: (data: TreeStoredSchema) => encodeRepo(data),
+		decode: (data: Format) => decode(data),
+	});
+}

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

@@ -0,0 +1,45 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { ObjectOptions, Static, Type } from "@sinclair/typebox";
+import { schemaFormat } from "../../core";
+
+const noAdditionalProps: ObjectOptions = { additionalProperties: false };
+
+export const TreeNodeSchemaFormat = Type.Object(
+	{
+		name: schemaFormat.TreeNodeSchemaIdentifierSchema,
+		data: schemaFormat.TreeNodeSchemaDataFormat,
+	},
+	noAdditionalProps,
+);
+
+/**
+ * Format for encoding as json.
+ *
+ * For consistency all lists are sorted and undefined values are omitted.
+ *
+ * This chooses to use lists of named objects instead of maps:
+ * this choice is somewhat arbitrary, but avoids user data being used as object keys,
+ * which can sometimes be an issue (for example handling that for "__proto__" can require care).
+ * It also makes it simpler to determinately sort by keys.
+ */
+export const Format = Type.Object(
+	{
+		version: Type.Literal(schemaFormat.version),
+		nodeSchema: Type.Array(TreeNodeSchemaFormat),
+		rootFieldSchema: schemaFormat.FieldSchemaFormat,
+	},
+	noAdditionalProps,
+);
+
+export type Format = Static<typeof Format>;
+
+export type TreeNodeSchemaFormat = Static<typeof TreeNodeSchemaFormat>;
+
+export const Versioned = Type.Object({
+	version: Type.String(),
+});
+export type Versioned = Static<typeof Versioned>;

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

@@ -0,0 +1,8 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+export { SchemaSummarizer, encodeTreeSchema } from "./schemaSummarizer";
+export { makeSchemaCodec } from "./codec";
+export { Format } from "./format";

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

@@ -0,0 +1,138 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { bufferToString } from "@fluid-internal/client-utils";
+import { assert } from "@fluidframework/core-utils";
+import {
+	IFluidDataStoreRuntime,
+	IChannelStorageService,
+} from "@fluidframework/datastore-definitions";
+import {
+	ITelemetryContext,
+	ISummaryTreeWithStats,
+	IGarbageCollectionData,
+	IExperimentalIncrementalSummaryContext,
+} from "@fluidframework/runtime-definitions";
+import { SummaryTreeBuilder } from "@fluidframework/runtime-utils";
+import { SummaryType } from "@fluidframework/protocol-definitions";
+import { ICodecOptions, IJsonCodec } from "../../codec";
+import { MutableTreeStoredSchema, TreeStoredSchema, schemaDataIsEmpty } from "../../core";
+import {
+	Summarizable,
+	SummaryElementParser,
+	SummaryElementStringifier,
+} from "../../shared-tree-core";
+import { JsonCompatible } from "../../util";
+import { CollabWindow } from "../incrementalSummarizationUtils";
+import { Format } from "./format";
+import { encodeRepo, makeSchemaCodec } from "./codec";
+
+const schemaStringKey = "SchemaString";
+/**
+ * Provides methods for summarizing and loading a schema repository.
+ */
+export class SchemaSummarizer implements Summarizable {
+	public readonly key = "Schema";
+
+	private readonly codec: IJsonCodec<TreeStoredSchema, Format>;
+
+	private schemaIndexLastChangedSeq: number | undefined;
+
+	public constructor(
+		private readonly runtime: IFluidDataStoreRuntime,
+		private readonly schema: MutableTreeStoredSchema,
+		options: ICodecOptions,
+		collabWindow: CollabWindow,
+	) {
+		this.codec = makeSchemaCodec(options);
+		this.schema.on("afterSchemaChange", () => {
+			// Invalidate the cache, as we need to regenerate the blob if the schema changes
+			// We are assuming that schema changes from remote ops are valid, as we are in a summarization context.
+			this.schemaIndexLastChangedSeq = collabWindow.getCurrentSeq();
+		});
+	}
+
+	public getAttachSummary(
+		stringify: SummaryElementStringifier,
+		fullTree?: boolean,
+		trackState?: boolean,
+		telemetryContext?: ITelemetryContext,
+		incrementalSummaryContext?: IExperimentalIncrementalSummaryContext | undefined,
+	): ISummaryTreeWithStats {
+		const builder = new SummaryTreeBuilder();
+		if (
+			incrementalSummaryContext !== undefined &&
+			this.schemaIndexLastChangedSeq !== undefined &&
+			incrementalSummaryContext.latestSummarySequenceNumber >= this.schemaIndexLastChangedSeq
+		) {
+			builder.addHandle(
+				schemaStringKey,
+				SummaryType.Blob,
+				`${incrementalSummaryContext.summaryPath}/indexes/${this.key}/${schemaStringKey}`,
+			);
+		} else {
+			const dataString = JSON.stringify(this.codec.encode(this.schema));
+			builder.addBlob(schemaStringKey, dataString);
+		}
+		return builder.getSummaryTree();
+	}
+
+	public async summarize(
+		stringify: SummaryElementStringifier,
+		fullTree?: boolean,
+		trackState?: boolean,
+		telemetryContext?: ITelemetryContext,
+		incrementalSummaryContext?: IExperimentalIncrementalSummaryContext | undefined,
+	): Promise<ISummaryTreeWithStats> {
+		throw new Error("Method not implemented.");
+	}
+
+	public getGCData(fullGC?: boolean): IGarbageCollectionData {
+		// TODO: Properly implement garbage collection. Right now, garbage collection is performed automatically
+		// by the code in SharedObject (from which SharedTreeCore extends). The `runtime.uploadBlob` API delegates
+		// to the `BlobManager`, which automatically populates the summary with ISummaryAttachment entries for each
+		// blob.
+		return {
+			gcNodes: {},
+		};
+	}
+
+	public async load(
+		services: IChannelStorageService,
+		parse: SummaryElementParser,
+	): Promise<void> {
+		const schemaBuffer: ArrayBufferLike = await services.readBlob(schemaStringKey);
+		// After the awaits, validate that the schema is in a clean state.
+		// This detects any schema that could have been accidentally added through
+		// invalid means and are about to be overwritten.
+		assert(
+			schemaDataIsEmpty(this.schema),
+			0x3da /* there should not already be stored schema when loading stored schema */,
+		);
+
+		const schemaString = bufferToString(schemaBuffer, "utf-8");
+		// Currently no Fluid handles are used, so just use JSON.parse.
+		const decoded = this.codec.decode(JSON.parse(schemaString));
+		this.schema.apply(decoded);
+		this.schemaIndexLastChangedSeq = 0;
+	}
+}
+
+/**
+ * Dumps schema into a deterministic JSON compatible semi-human readable but unspecified format.
+ *
+ * @remarks
+ * This can be used to help inspect schema for debugging, and to save a snapshot of schema to help detect and review changes to an applications schema.
+ *
+ * This format may change across major versions of this package: such changes are considered breaking.
+ * Beyond that, no compatibility guarantee is provided for this format: it should never be relied upon to load data, it should only be used for comparing outputs from this function.
+ * @privateRemarks
+ * This currently uses the schema summary format, but that could be changed to something more human readable (particularly if the encoded format becomes less human readable).
+ * This intentionally does not leak the format types in the API.
+ * @internal
+ */
+export function encodeTreeSchema(schema: TreeStoredSchema): JsonCompatible {
+	return encodeRepo(schema);
+}