@fluidframework/tree 2.113.1 → 2.115.0

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

@@ -0,0 +1,340 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { assert, fail } from "@fluidframework/core-utils/internal";
+import {
+	newChangeAtomIdRangeMap,
+	type ChangesetLocalId,
+	type FieldKey,
+	type FieldKindIdentifier,
+	type RevisionInfo,
+	type RevisionTag,
+	type TaggedChange,
+	type TreeChunk,
+} from "../../core/index.js";
+import { brand, type Mutable, type RangeQueryResult } from "../../util/index.js";
+import {
+	getFromChangeAtomIdMap,
+	newChangeAtomIdBTree,
+	type ChangeAtomIdBTree,
+} from "../changeAtomIdBTree.js";
+import {
+	CrossFieldTarget,
+	getFirstFromCrossFieldMap,
+	setInCrossFieldMap,
+	type CrossFieldManager,
+	type CrossFieldMap,
+} from "./crossFieldQueries.js";
+import type { FieldChangeHandler } from "./fieldChangeHandler.js";
+import { NodeAttachState } from "./fieldChangeHandler.js";
+import type { FlexFieldKind } from "./fieldKind.js";
+import { genericFieldKind } from "./genericFieldKind.js";
+import {
+	newCrossFieldKeyTable,
+	type CrossFieldKeyTable,
+	type FieldChange,
+	type FieldChangeMap,
+	type FieldId,
+	type ModularChangeset,
+	type NoChangeConstraint,
+	type NodeChangeset,
+	type NodeId,
+} from "./modularChangeTypes.js";
+
+export function hasConflicts(change: ModularChangeset): boolean {
+	return (change.constraintViolationCount ?? 0) > 0;
+}
+
+export function makeModularChangeset(props?: {
+	fieldChanges?: FieldChangeMap;
+	nodeChanges?: ChangeAtomIdBTree<NodeChangeset>;
+	nodeToParent?: ChangeAtomIdBTree<FieldId>;
+	nodeAliases?: ChangeAtomIdBTree<NodeId>;
+	crossFieldKeys?: CrossFieldKeyTable;
+	maxId: number;
+	revisions?: readonly RevisionInfo[];
+	constraintViolationCount?: number;
+	noChangeConstraint?: NoChangeConstraint;
+	noChangeConstraintOnRevert?: NoChangeConstraint;
+	builds?: ChangeAtomIdBTree<TreeChunk>;
+	destroys?: ChangeAtomIdBTree<number>;
+	refreshers?: ChangeAtomIdBTree<TreeChunk>;
+}): ModularChangeset {
+	const p = props ?? { maxId: -1 };
+	const changeset: Mutable<ModularChangeset> = {
+		fieldChanges: p.fieldChanges ?? new Map<FieldKey, FieldChange>(),
+		nodeChanges: p.nodeChanges ?? newChangeAtomIdBTree(),
+		nodeToParent: p.nodeToParent ?? newChangeAtomIdBTree(),
+		nodeAliases: p.nodeAliases ?? newChangeAtomIdBTree(),
+		crossFieldKeys: p.crossFieldKeys ?? newCrossFieldKeyTable(),
+	};
+
+	if (p.revisions !== undefined && p.revisions.length > 0) {
+		changeset.revisions = p.revisions;
+	}
+	if (p.maxId >= 0) {
+		changeset.maxId = brand(p.maxId);
+	}
+	if (p.constraintViolationCount !== undefined && p.constraintViolationCount > 0) {
+		changeset.constraintViolationCount = p.constraintViolationCount;
+	}
+	if (p.noChangeConstraint !== undefined) {
+		changeset.noChangeConstraint = p.noChangeConstraint;
+	}
+	if (p.noChangeConstraintOnRevert !== undefined) {
+		changeset.noChangeConstraintOnRevert = p.noChangeConstraintOnRevert;
+	}
+	if (p.builds !== undefined && p.builds.size > 0) {
+		changeset.builds = p.builds;
+	}
+	if (p.destroys !== undefined && p.destroys.size > 0) {
+		changeset.destroys = p.destroys;
+	}
+	if (p.refreshers !== undefined && p.refreshers.size > 0) {
+		changeset.refreshers = p.refreshers;
+	}
+	return changeset;
+}
+
+// TODO: TFieldData could instead just be a numeric ID generated by the CrossFieldTable
+// The CrossFieldTable could have a generic field ID to context table
+export interface CrossFieldTable<TFieldData> {
+	srcTable: CrossFieldMap<unknown>;
+	dstTable: CrossFieldMap<unknown>;
+	srcDependents: CrossFieldMap<TFieldData>;
+	dstDependents: CrossFieldMap<TFieldData>;
+	invalidatedFields: Set<TFieldData>;
+}
+
+export abstract class CrossFieldManagerI<T> implements CrossFieldManager {
+	public constructor(
+		protected readonly crossFieldTable: CrossFieldTable<T>,
+		private readonly currentFieldKey: T,
+		protected readonly allowInval = true,
+	) {}
+
+	public set(
+		target: CrossFieldTarget,
+		revision: RevisionTag | undefined,
+		id: ChangesetLocalId,
+		count: number,
+		newValue: unknown,
+		invalidateDependents: boolean,
+	): void {
+		if (invalidateDependents && this.allowInval) {
+			const lastChangedId = (id as number) + count - 1;
+			let firstId = id;
+			while (firstId <= lastChangedId) {
+				const dependentEntry = getFirstFromCrossFieldMap(
+					this.getDependents(target),
+					revision,
+					firstId,
+					lastChangedId - firstId + 1,
+				);
+				if (dependentEntry.value !== undefined) {
+					this.crossFieldTable.invalidatedFields.add(dependentEntry.value);
+				}
+
+				firstId = brand(firstId + dependentEntry.length);
+			}
+		}
+		setInCrossFieldMap(this.getMap(target), revision, id, count, newValue);
+	}
+
+	public get(
+		target: CrossFieldTarget,
+		revision: RevisionTag | undefined,
+		id: ChangesetLocalId,
+		count: number,
+		addDependency: boolean,
+	): RangeQueryResult<unknown> {
+		if (addDependency) {
+			// We assume that if there is already an entry for this ID it is because
+			// a field handler has called compose on the same node multiple times.
+			// In this case we only want to update the latest version, so we overwrite the dependency.
+			setInCrossFieldMap(
+				this.getDependents(target),
+				revision,
+				id,
+				count,
+				this.currentFieldKey,
+			);
+		}
+		return getFirstFromCrossFieldMap(this.getMap(target), revision, id, count);
+	}
+
+	public abstract onMoveIn(id: NodeId): void;
+
+	public abstract moveKey(
+		target: CrossFieldTarget,
+		revision: RevisionTag | undefined,
+		id: ChangesetLocalId,
+		count: number,
+	): void;
+
+	private getMap(target: CrossFieldTarget): CrossFieldMap<unknown> {
+		return target === CrossFieldTarget.Source
+			? this.crossFieldTable.srcTable
+			: this.crossFieldTable.dstTable;
+	}
+
+	private getDependents(target: CrossFieldTarget): CrossFieldMap<T> {
+		return target === CrossFieldTarget.Source
+			? this.crossFieldTable.srcDependents
+			: this.crossFieldTable.dstDependents;
+	}
+}
+
+export function newCrossFieldTable<T>(): CrossFieldTable<T> {
+	return {
+		srcTable: newChangeAtomIdRangeMap(),
+		dstTable: newChangeAtomIdRangeMap(),
+		srcDependents: newChangeAtomIdRangeMap(),
+		dstDependents: newChangeAtomIdRangeMap(),
+		invalidatedFields: new Set(),
+	};
+}
+
+export function getRevInfoFromTaggedChanges(changes: TaggedChange<ModularChangeset>[]): {
+	revInfos: RevisionInfo[];
+	maxId: ChangesetLocalId;
+} {
+	let maxId = -1;
+	const revInfos: RevisionInfo[] = [];
+	const revisions = new Set<RevisionTag>();
+	for (const taggedChange of changes) {
+		const change = taggedChange.change;
+		maxId = Math.max(change.maxId ?? -1, maxId);
+		const infosToAdd = revisionInfoFromTaggedChange(taggedChange);
+		for (const info of infosToAdd) {
+			if (!revisions.has(info.revision)) {
+				revisions.add(info.revision);
+				revInfos.push(info);
+			}
+		}
+	}
+
+	const rolledBackRevisions: RevisionTag[] = [];
+	for (const info of revInfos) {
+		if (info.rollbackOf !== undefined) {
+			rolledBackRevisions.push(info.rollbackOf);
+		}
+	}
+
+	rolledBackRevisions.reverse();
+	for (const revision of rolledBackRevisions) {
+		if (!revisions.has(revision)) {
+			revInfos.push({ revision });
+		}
+	}
+
+	return { maxId: brand(maxId), revInfos };
+}
+
+export function revisionInfoFromTaggedChange(
+	taggedChange: TaggedChange<ModularChangeset>,
+): RevisionInfo[] {
+	const revInfos: RevisionInfo[] = [];
+	if (taggedChange.change.revisions !== undefined) {
+		revInfos.push(...taggedChange.change.revisions);
+	} else if (taggedChange.revision !== undefined) {
+		const info: Mutable<RevisionInfo> = { revision: taggedChange.revision };
+		if (taggedChange.rollbackOf !== undefined) {
+			info.rollbackOf = taggedChange.rollbackOf;
+		}
+		revInfos.push(info);
+	}
+	return revInfos;
+}
+
+export function getChangeHandler(
+	fieldKinds: ReadonlyMap<FieldKindIdentifier, FlexFieldKind>,
+	kind: FieldKindIdentifier,
+): FieldChangeHandler<unknown> {
+	return getFieldKind(fieldKinds, kind).changeHandler;
+}
+
+function getFieldKind(
+	fieldKinds: ReadonlyMap<FieldKindIdentifier, FlexFieldKind>,
+	kind: FieldKindIdentifier,
+): FlexFieldKind {
+	if (kind === genericFieldKind.identifier) {
+		return genericFieldKind;
+	}
+	const fieldKind = fieldKinds.get(kind);
+	assert(fieldKind !== undefined, 0x3ad /* Unknown field kind */);
+	return fieldKind;
+}
+
+export interface ConstraintState {
+	violationCount: number;
+}
+
+export function newConstraintState(violationCount: number): ConstraintState {
+	return {
+		violationCount,
+	};
+}
+
+export function updateConstraintsForFields(
+	fields: FieldChangeMap,
+	parentInputAttachState: NodeAttachState,
+	constraintState: ConstraintState,
+	nodes: ChangeAtomIdBTree<NodeChangeset>,
+	fieldKinds: ReadonlyMap<FieldKindIdentifier, FlexFieldKind>,
+): void {
+	for (const field of fields.values()) {
+		const handler = getChangeHandler(fieldKinds, field.fieldKind);
+		for (const [nodeId, inputIndex, _outputIndex] of handler.getNestedChanges(field.change)) {
+			const isInputDetached = inputIndex === undefined;
+			const inputAttachState =
+				parentInputAttachState === NodeAttachState.Detached || isInputDetached
+					? NodeAttachState.Detached
+					: NodeAttachState.Attached;
+
+			updateConstraintsForNode(nodeId, inputAttachState, nodes, constraintState, fieldKinds);
+		}
+	}
+}
+
+function updateConstraintsForNode(
+	nodeId: NodeId,
+	inputAttachState: NodeAttachState,
+	nodes: ChangeAtomIdBTree<NodeChangeset>,
+	constraintState: ConstraintState,
+	fieldKinds: ReadonlyMap<FieldKindIdentifier, FlexFieldKind>,
+): void {
+	const node =
+		nodes.get([nodeId.revision, nodeId.localId]) ?? fail(0xb24 /* Unknown node ID */);
+	if (node.nodeExistsConstraint !== undefined) {
+		const isNowViolated = inputAttachState === NodeAttachState.Detached;
+		if (node.nodeExistsConstraint.violated !== isNowViolated) {
+			node.nodeExistsConstraint = {
+				...node.nodeExistsConstraint,
+				violated: isNowViolated,
+			};
+			constraintState.violationCount += isNowViolated ? 1 : -1;
+		}
+	}
+
+	if (node.fieldChanges !== undefined) {
+		updateConstraintsForFields(
+			node.fieldChanges,
+			inputAttachState,
+			constraintState,
+			nodes,
+			fieldKinds,
+		);
+	}
+}
+
+export function nodeChangeFromId(
+	nodes: ChangeAtomIdBTree<NodeChangeset>,
+	id: NodeId,
+): NodeChangeset {
+	const node = getFromChangeAtomIdMap(nodes, id);
+	assert(node !== undefined, 0x9ca /* Unknown node ID */);
+	return node;
+}

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

@@ -0,0 +1,69 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import type { FieldKindIdentifier } from "../../core/index.js";
+import { brand } from "../../util/index.js";
+import { setInChangeAtomIdMap, type ChangeAtomIdBTree } from "../changeAtomIdBTree.js";
+import type { FlexFieldKind } from "./fieldKind.js";
+import type { FieldChangeMap, NodeChangeset, NodeId } from "./modularChangeTypes.js";
+import { getChangeHandler, nodeChangeFromId } from "./modularChangeUtils.js";
+
+export function pruneFieldMap(
+	changeset: FieldChangeMap | undefined,
+	nodeMap: ChangeAtomIdBTree<NodeChangeset>,
+	fieldKinds: ReadonlyMap<FieldKindIdentifier, FlexFieldKind>,
+): FieldChangeMap | undefined {
+	if (changeset === undefined) {
+		return undefined;
+	}
+
+	const prunedChangeset: FieldChangeMap = new Map();
+	for (const [field, fieldChange] of changeset) {
+		const handler = getChangeHandler(fieldKinds, fieldChange.fieldKind);
+
+		const prunedFieldChangeset = handler.rebaser.prune(fieldChange.change, (nodeId) =>
+			pruneNodeChange(nodeId, nodeMap, fieldKinds),
+		);
+
+		if (!handler.isEmpty(prunedFieldChangeset)) {
+			prunedChangeset.set(field, { ...fieldChange, change: brand(prunedFieldChangeset) });
+		}
+	}
+
+	return prunedChangeset.size > 0 ? prunedChangeset : undefined;
+}
+
+function pruneNodeChange(
+	nodeId: NodeId,
+	nodeMap: ChangeAtomIdBTree<NodeChangeset>,
+	fieldKinds: ReadonlyMap<FieldKindIdentifier, FlexFieldKind>,
+): NodeId | undefined {
+	const changeset = nodeChangeFromId(nodeMap, nodeId);
+	const prunedFields =
+		changeset.fieldChanges === undefined
+			? undefined
+			: pruneFieldMap(changeset.fieldChanges, nodeMap, fieldKinds);
+
+	const prunedChange = { ...changeset, fieldChanges: prunedFields };
+	if (prunedChange.fieldChanges === undefined) {
+		delete prunedChange.fieldChanges;
+	}
+
+	if (isEmptyNodeChangeset(prunedChange)) {
+		nodeMap.delete([nodeId.revision, nodeId.localId]);
+		return undefined;
+	} else {
+		setInChangeAtomIdMap(nodeMap, nodeId, prunedChange);
+		return nodeId;
+	}
+}
+
+function isEmptyNodeChangeset(change: NodeChangeset): boolean {
+	return (
+		change.fieldChanges === undefined &&
+		change.nodeExistsConstraint === undefined &&
+		change.nodeExistsConstraintOnRevert === undefined
+	);
+}

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

@@ -16,6 +16,7 @@ import type { Mutable } from "../../util/index.js";
 import { makeChangeAtomIdCodec } from "../changeAtomIdCodec.js";
 import type {
 	FieldChangeEncodingContext,
+	FieldChangeDecodingContext,
 	EncodedChangeAtomId,
 } from "../modular-schema/index.js";
 import { EncodedNodeChangeset } from "../modular-schema/index.js";
@@ -57,7 +58,8 @@ export function makeOptionalFieldCodec(
 	OptionalChangeset,
 	EncodedOptionalChangeset<TAnySchema>,
 	EncodedOptionalChangeset<TAnySchema>,
-	FieldChangeEncodingContext
+	FieldChangeEncodingContext,
+	FieldChangeDecodingContext
 > {
 	const changeAtomIdCodec = makeChangeAtomIdCodec(revisionTagCodec);
 	const registerIdCodec = makeRegisterIdCodec(changeAtomIdCodec);
@@ -98,7 +100,7 @@ export function makeOptionalFieldCodec(
 
 		decode: (
 			encoded: EncodedOptionalChangeset<TAnySchema>,
-			context: FieldChangeEncodingContext,
+			context: FieldChangeDecodingContext,
 		) => {
 			const decoded: Mutable<OptionalChangeset> = {
 				moves:

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

@@ -9,7 +9,10 @@ import type {
 	RevisionTag,
 	RevisionTagSchema,
 } from "../../core/index.js";
-import type { FieldChangeEncodingContext } from "../modular-schema/index.js";
+import type {
+	FieldChangeEncodingContext,
+	FieldChangeDecodingContext,
+} from "../modular-schema/index.js";
 
 import type { OptionalChangeset } from "./optionalFieldChangeTypes.js";
 import { makeOptionalFieldCodec as makeV2Codec } from "./optionalFieldCodecV2.js";
@@ -20,5 +23,5 @@ export const makeOptionalFieldCodecFamily = (
 		typeof RevisionTagSchema,
 		ChangeEncodingContext
 	>,
-): ICodecFamily<OptionalChangeset, FieldChangeEncodingContext> =>
+): ICodecFamily<OptionalChangeset, FieldChangeEncodingContext, FieldChangeDecodingContext> =>
 	makeCodecFamily([[2, makeV2Codec(revisionTagCodec)]]);

package/src/feature-libraries/sequence-field/sequenceFieldCodecV2.ts

@@ -24,6 +24,7 @@ import { makeChangeAtomIdCodec } from "../changeAtomIdCodec.js";
 import {
 	EncodedNodeChangeset,
 	type FieldChangeEncodingContext,
+	type FieldChangeDecodingContext,
 } from "../modular-schema/index.js";
 
 import { Changeset as ChangesetSchema, type Encoded } from "./formatV2.js";
@@ -271,7 +272,8 @@ export function makeV2Codec(
 	Changeset,
 	JsonCompatibleReadOnly,
 	JsonCompatibleReadOnly,
-	FieldChangeEncodingContext
+	FieldChangeEncodingContext,
+	FieldChangeDecodingContext
 > {
 	const { markEffectCodec, changeAtomIdCodec } = makeV2CodecHelpers(revisionTagCodec);
 	/**
@@ -305,7 +307,7 @@ export function makeV2Codec(
 		},
 		decode: (
 			changeset: Encoded.Changeset<NodeChangeSchema>,
-			context: FieldChangeEncodingContext,
+			context: FieldChangeDecodingContext,
 		): Changeset => {
 			const marks: Changeset = [];
 			for (const mark of changeset) {

package/src/feature-libraries/sequence-field/sequenceFieldCodecV3.ts

@@ -19,6 +19,7 @@ import type { JsonCompatibleReadOnly } from "../../util/index.js";
 import {
 	EncodedNodeChangeset,
 	type FieldChangeEncodingContext,
+	type FieldChangeDecodingContext,
 } from "../modular-schema/index.js";
 
 import { Changeset as ChangesetSchema, type Encoded } from "./formatV3.js";
@@ -36,7 +37,8 @@ export function makeV3Codec(
 	Changeset,
 	JsonCompatibleReadOnly,
 	JsonCompatibleReadOnly,
-	FieldChangeEncodingContext
+	FieldChangeEncodingContext,
+	FieldChangeDecodingContext
 > {
 	const {
 		changeAtomIdCodec: atomIdCodec,
@@ -115,7 +117,7 @@ export function makeV3Codec(
 		},
 		decode: (
 			changeset: Encoded.Changeset<NodeChangeSchema>,
-			context: FieldChangeEncodingContext,
+			context: FieldChangeDecodingContext,
 		): Changeset => {
 			const marks: Changeset = [];
 			for (const mark of changeset) {

package/src/feature-libraries/sequence-field/sequenceFieldCodecs.ts

@@ -9,7 +9,10 @@ import type {
 	RevisionTag,
 	RevisionTagSchema,
 } from "../../core/index.js";
-import type { FieldChangeEncodingContext } from "../modular-schema/index.js";
+import type {
+	FieldChangeEncodingContext,
+	FieldChangeDecodingContext,
+} from "../modular-schema/index.js";
 
 import { makeV2Codec } from "./sequenceFieldCodecV2.js";
 import { makeV3Codec } from "./sequenceFieldCodecV3.js";
@@ -21,8 +24,8 @@ export const sequenceFieldChangeCodecFactory = (
 		typeof RevisionTagSchema,
 		ChangeEncodingContext
 	>,
-): ICodecFamily<MarkList, FieldChangeEncodingContext> =>
-	makeCodecFamily<Changeset, FieldChangeEncodingContext>([
+): ICodecFamily<MarkList, FieldChangeEncodingContext, FieldChangeDecodingContext> =>
+	makeCodecFamily<Changeset, FieldChangeEncodingContext, FieldChangeDecodingContext>([
 		[2, makeV2Codec(revisionTagCodec)],
 		[3, makeV3Codec(revisionTagCodec)],
 	]);

package/src/feature-libraries/treeTextCursor.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { assert } from "@fluidframework/core-utils/internal";
+import { assert, fail, oob } from "@fluidframework/core-utils/internal";
 
 import {
 	CursorLocationType,
@@ -132,3 +132,68 @@ export function jsonableTreeFromForest(forest: IForestSubscription): JsonableTre
 	readCursor.free();
 	return jsonable;
 }
+
+/**
+ * The full content of `forest` (every detached/removed field) as a single {@link JsonableTree}.
+ * @remarks
+ * The returned node is the forest's above-root placeholder: its fields are the forest's detached fields.
+ * Only content is captured: schema, anchors and other forest state are not.
+ */
+function forestContent(forest: IForestSubscription): JsonableTree {
+	return jsonableTreeFromCursor(forest.getCursorAboveDetachedFields());
+}
+
+/**
+ * Structural equality of two {@link JsonableTree}s, comparing type, value and fields recursively.
+ * @remarks
+ * Fields are compared as an unordered set of keys, so this is independent of the order in which different
+ * forest implementations enumerate fields. The nodes within each field are compared in order.
+ */
+function treesEqual(a: JsonableTree, b: JsonableTree): boolean {
+	if (a.type !== b.type || !Object.is(a.value, b.value)) {
+		return false;
+	}
+	// JsonableTree never stores empty fields, so equal key counts plus a matching field for every key in
+	// `a` implies `b` has no extra fields.
+	const aKeys = genericTreeKeys(a);
+	if (aKeys.length !== genericTreeKeys(b).length) {
+		return false;
+	}
+	for (const key of aKeys) {
+		const aField = getGenericTreeField(a, key, false);
+		const bField = getGenericTreeField(b, key, false);
+		if (aField.length !== bField.length) {
+			return false;
+		}
+		for (const [index, aChild] of aField.entries()) {
+			const bChild = bField[index] ?? oob();
+			if (!treesEqual(aChild, bChild)) {
+				return false;
+			}
+		}
+	}
+	return true;
+}
+
+/**
+ * Returns true if `a` and `b` have identical content, including all detached/removed fields.
+ * @remarks
+ * Only content is compared: schema, anchors and other forest state are ignored.
+ * This is intended for debugging and testing, and is not optimized.
+ */
+export function forestsEqual(a: IForestSubscription, b: IForestSubscription): boolean {
+	return treesEqual(forestContent(a), forestContent(b));
+}
+
+/**
+ * Asserts that `a` and `b` have identical content, including all detached/removed fields.
+ * @remarks
+ * Only content is compared: schema, anchors and other forest state are ignored.
+ * This is intended for debugging and testing, and is not optimized.
+ * @throws an Error if the forests differ.
+ */
+export function assertForestsEqual(a: IForestSubscription, b: IForestSubscription): void {
+	if (!forestsEqual(a, b)) {
+		fail(0xd10 /* Forests are not equal */);
+	}
+}

package/src/index.ts

@@ -12,6 +12,8 @@ export {
 	CommitKind,
 	RevertibleStatus,
 	type CommitMetadata,
+	CommitOutcome,
+	type LocalCommitEvents,
 	type LocalChangeMetadata,
 	type RemoteChangeMetadata,
 	type ChangeMetadata,
@@ -300,6 +302,7 @@ export {
 	type HandleConverter,
 	allowUnused,
 	type LeafSchema,
+	type StringSchema,
 	type ArrayNodeCustomizableSchema,
 	type ArrayNodeCustomizableSchemaAlpha,
 	type ArrayNodePojoEmulationSchema,
@@ -344,6 +347,7 @@ export {
 } from "./simple-tree/index.js";
 export {
 	SharedTree,
+	SharedTreeAlpha,
 	configuredSharedTree,
 	configuredSharedTreeAlpha,
 	configuredSharedTreeBeta,
@@ -403,7 +407,7 @@ import * as InternalTypes from "./internalTypes.js";
 export { InternalTypes };
 
 // Internal/System types:
-// These would be put in `internalTypes` except doing so tents to cause errors like:
+// These would be put in `internalTypes` except doing so tends to cause errors like:
 // The inferred type of 'NodeMap' cannot be named without a reference to '../../node_modules/@fluidframework/tree/lib/internalTypes.js'. This is likely not portable. A type annotation is necessary.
 export type { MapNodeInsertableData } from "./simple-tree/index.js";
 
@@ -413,11 +417,14 @@ export { TableSchema, type System_TableSchema } from "./tableSchema.js";
 export { asAlpha, asBeta } from "./api.js";
 
 export {
-	TextAsTree,
-	FormattedTextAsTree,
-	FormattedTextAsTreeDefault,
+	PlainText,
+	FormattedText,
+	FormattedTextDefault,
 	codePointCount,
 	utf16LengthForCodePoints,
 } from "./text/index.js";
 export { ExtensibleUnionNode } from "./extensibleUnionNode.js";
 export { Component } from "./componentApi.js";
+
+export { defineTreeDataStore, instantiateTreeFirstTime } from "./treeDataStore.js";
+export type { TreeDataStoreOptions } from "./treeDataStore.js";

package/src/packageVersion.ts

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

package/src/shared-tree/serializedChange.ts

@@ -48,7 +48,7 @@ function isSerializedChangeV1(value: unknown): value is SerializedChange {
 
 function encodeSerializedChangeV1(
 	idCompressor: IIdCompressor,
-	changeFamily: ChangeFamily<SharedTreeEditBuilder, SharedTreeChange>,
+	changeFamily: ChangeFamily<SharedTreeEditBuilder, SharedTreeChange, unknown>,
 	change: SharedTreeChange,
 	changeRevision: RevisionTag,
 	contextRevision?: RevisionTag,
@@ -73,7 +73,7 @@ function encodeSerializedChangeV1(
 
 function decodeSerializedChangeV1(
 	idCompressor: IIdCompressor,
-	changeFamily: ChangeFamily<SharedTreeEditBuilder, SharedTreeChange>,
+	changeFamily: ChangeFamily<SharedTreeEditBuilder, SharedTreeChange, unknown>,
 	serializedChange: JsonCompatibleReadOnly,
 ): TaggedChange<SharedTreeChange> {
 	if (!isSerializedChangeV1(serializedChange)) {