@fluidframework/tree 2.80.0 → 2.81.0

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

@@ -4,8 +4,9 @@
  */
 
 import { assert, fail } from "@fluidframework/core-utils/internal";
-import { BTree } from "@tylerbu/sorted-btree-es6";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
+import { BTree } from "@tylerbu/sorted-btree-es6";
+import { lt } from "semver-ts";
 
 import {
 	FluidClientVersion,
@@ -61,6 +62,11 @@ import {
 	RangeMap,
 	balancedReduce,
 } from "../../util/index.js";
+import {
+	getFromChangeAtomIdMap,
+	setInChangeAtomIdMap,
+	type ChangeAtomIdBTree,
+} from "../changeAtomIdBTree.js";
 import type { TreeChunk } from "../chunked-forest/index.js";
 
 import {
@@ -75,6 +81,7 @@ import {
 	NodeAttachState,
 	type RebaseRevisionMetadata,
 } from "./fieldChangeHandler.js";
+import type { FlexFieldKind } from "./fieldKind.js";
 import { convertGenericChange, genericFieldKind } from "./genericFieldKind.js";
 import type { GenericChangeset } from "./genericFieldKindTypes.js";
 import {
@@ -91,13 +98,6 @@ import {
 	type NodeChangeset,
 	type NodeId,
 } from "./modularChangeTypes.js";
-import type { FlexFieldKind } from "./fieldKind.js";
-import {
-	getFromChangeAtomIdMap,
-	setInChangeAtomIdMap,
-	type ChangeAtomIdBTree,
-} from "../changeAtomIdBTree.js";
-import { lt } from "semver-ts";
 
 /**
  * Implementation of ChangeFamily which delegates work in a given field to the appropriate FieldKind
@@ -481,6 +481,7 @@ export class ModularChangeFamily
 				setInChangeAtomIdMap(composedNodes, nodeId, nodeChangeset);
 			}
 
+			// eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing -- using ??= could change behavior if value is falsy
 			if (nodeChangeset.fieldChanges === undefined) {
 				nodeChangeset.fieldChanges = new Map();
 			}
@@ -1039,15 +1040,6 @@ export class ModularChangeFamily
 
 			// This field has no changes in the new changeset, otherwise it would have been added to
 			// `crossFieldTable.baseFieldToContext` when processing fields with both base and new changes.
-			const rebaseChild = (
-				child: NodeId | undefined,
-				baseChild: NodeId | undefined,
-				stateChange: NodeAttachState | undefined,
-			): NodeId | undefined => {
-				assert(child === undefined, 0x9c3 /* There should be no new changes in this field */);
-				return undefined;
-			};
-
 			const handler = getChangeHandler(this.fieldKinds, baseFieldChange.fieldKind);
 			const fieldChange: FieldChange = {
 				...baseFieldChange,
@@ -1063,7 +1055,7 @@ export class ModularChangeFamily
 			const rebasedField: unknown = handler.rebaser.rebase(
 				fieldChange.change,
 				baseFieldChange.change,
-				rebaseChild,
+				noNewChangesRebaseChild,
 				genId,
 				new RebaseManager(crossFieldTable, baseFieldChange, fieldId),
 				metadata,
@@ -1909,23 +1901,26 @@ export function* relevantRemovedRoots(
 	yield* relevantRemovedRootsFromFields(change.fieldChanges, change.nodeChanges, fieldKinds);
 }
 
+function* relevantRemovedRootsFromNode(
+	node: NodeId,
+	nodeChanges: ChangeAtomIdBTree<NodeChangeset>,
+	fieldKinds: ReadonlyMap<FieldKindIdentifier, FlexFieldKind>,
+): Iterable<DeltaDetachedNodeId> {
+	const nodeChangeset = nodeChangeFromId(nodeChanges, node);
+	if (nodeChangeset.fieldChanges !== undefined) {
+		yield* relevantRemovedRootsFromFields(nodeChangeset.fieldChanges, nodeChanges, fieldKinds);
+	}
+}
+
 function* relevantRemovedRootsFromFields(
 	change: FieldChangeMap,
 	nodeChanges: ChangeAtomIdBTree<NodeChangeset>,
 	fieldKinds: ReadonlyMap<FieldKindIdentifier, FlexFieldKind>,
 ): Iterable<DeltaDetachedNodeId> {
+	const delegate = (node: NodeId): Iterable<DeltaDetachedNodeId> =>
+		relevantRemovedRootsFromNode(node, nodeChanges, fieldKinds);
 	for (const [_, fieldChange] of change) {
 		const handler = getChangeHandler(fieldKinds, fieldChange.fieldKind);
-		const delegate = function* (node: NodeId): Iterable<DeltaDetachedNodeId> {
-			const nodeChangeset = nodeChangeFromId(nodeChanges, node);
-			if (nodeChangeset.fieldChanges !== undefined) {
-				yield* relevantRemovedRootsFromFields(
-					nodeChangeset.fieldChanges,
-					nodeChanges,
-					fieldKinds,
-				);
-			}
-		};
 		yield* handler.relevantRemovedRoots(fieldChange.change, delegate);
 	}
 }
@@ -2111,8 +2106,12 @@ function intoDeltaImpl(
 		if (fieldChanges !== undefined && fieldChanges.length > 0) {
 			delta.set(field, fieldChanges);
 		}
-		fieldGlobal?.forEach((c) => global.push(c));
-		fieldRename?.forEach((r) => rename.push(r));
+		for (const c of fieldGlobal ?? []) {
+			global.push(c);
+		}
+		for (const r of fieldRename ?? []) {
+			rename.push(r);
+		}
 	}
 	return delta;
 }
@@ -2608,63 +2607,60 @@ class ComposeManager extends CrossFieldManagerI<FieldChange> {
 	}
 }
 
-function makeModularChangeset(
-	props: {
-		fieldChanges?: FieldChangeMap;
-		nodeChanges?: ChangeAtomIdBTree<NodeChangeset>;
-		nodeToParent?: ChangeAtomIdBTree<FieldId>;
-		nodeAliases?: ChangeAtomIdBTree<NodeId>;
-		crossFieldKeys?: CrossFieldKeyTable;
-		maxId: number;
-		revisions?: readonly RevisionInfo[];
-		constraintViolationCount?: number;
-		constraintViolationCountOnRevert?: number;
-		noChangeConstraint?: NoChangeConstraint;
-		noChangeConstraintOnRevert?: NoChangeConstraint;
-		builds?: ChangeAtomIdBTree<TreeChunk>;
-		destroys?: ChangeAtomIdBTree<number>;
-		refreshers?: ChangeAtomIdBTree<TreeChunk>;
-	} = {
-		maxId: -1,
-	},
-): ModularChangeset {
+function makeModularChangeset(props?: {
+	fieldChanges?: FieldChangeMap;
+	nodeChanges?: ChangeAtomIdBTree<NodeChangeset>;
+	nodeToParent?: ChangeAtomIdBTree<FieldId>;
+	nodeAliases?: ChangeAtomIdBTree<NodeId>;
+	crossFieldKeys?: CrossFieldKeyTable;
+	maxId: number;
+	revisions?: readonly RevisionInfo[];
+	constraintViolationCount?: number;
+	constraintViolationCountOnRevert?: 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: props.fieldChanges ?? new Map(),
-		nodeChanges: props.nodeChanges ?? newTupleBTree(),
-		nodeToParent: props.nodeToParent ?? newTupleBTree(),
-		nodeAliases: props.nodeAliases ?? newTupleBTree(),
-		crossFieldKeys: props.crossFieldKeys ?? newCrossFieldKeyTable(),
+		fieldChanges: p.fieldChanges ?? new Map(),
+		nodeChanges: p.nodeChanges ?? newTupleBTree(),
+		nodeToParent: p.nodeToParent ?? newTupleBTree(),
+		nodeAliases: p.nodeAliases ?? newTupleBTree(),
+		crossFieldKeys: p.crossFieldKeys ?? newCrossFieldKeyTable(),
 	};
 
-	if (props.revisions !== undefined && props.revisions.length > 0) {
-		changeset.revisions = props.revisions;
+	if (p.revisions !== undefined && p.revisions.length > 0) {
+		changeset.revisions = p.revisions;
 	}
-	if (props.maxId >= 0) {
-		changeset.maxId = brand(props.maxId);
+	if (p.maxId >= 0) {
+		changeset.maxId = brand(p.maxId);
 	}
-	if (props.constraintViolationCount !== undefined && props.constraintViolationCount > 0) {
-		changeset.constraintViolationCount = props.constraintViolationCount;
+	if (p.constraintViolationCount !== undefined && p.constraintViolationCount > 0) {
+		changeset.constraintViolationCount = p.constraintViolationCount;
 	}
 	if (
-		props.constraintViolationCountOnRevert !== undefined &&
-		props.constraintViolationCountOnRevert > 0
+		p.constraintViolationCountOnRevert !== undefined &&
+		p.constraintViolationCountOnRevert > 0
 	) {
-		changeset.constraintViolationCountOnRevert = props.constraintViolationCountOnRevert;
+		changeset.constraintViolationCountOnRevert = p.constraintViolationCountOnRevert;
 	}
-	if (props.noChangeConstraint !== undefined) {
-		changeset.noChangeConstraint = props.noChangeConstraint;
+	if (p.noChangeConstraint !== undefined) {
+		changeset.noChangeConstraint = p.noChangeConstraint;
 	}
-	if (props.noChangeConstraintOnRevert !== undefined) {
-		changeset.noChangeConstraintOnRevert = props.noChangeConstraintOnRevert;
+	if (p.noChangeConstraintOnRevert !== undefined) {
+		changeset.noChangeConstraintOnRevert = p.noChangeConstraintOnRevert;
 	}
-	if (props.builds !== undefined && props.builds.size > 0) {
-		changeset.builds = props.builds;
+	if (p.builds !== undefined && p.builds.size > 0) {
+		changeset.builds = p.builds;
 	}
-	if (props.destroys !== undefined && props.destroys.size > 0) {
-		changeset.destroys = props.destroys;
+	if (p.destroys !== undefined && p.destroys.size > 0) {
+		changeset.destroys = p.destroys;
 	}
-	if (props.refreshers !== undefined && props.refreshers.size > 0) {
-		changeset.refreshers = props.refreshers;
+	if (p.refreshers !== undefined && p.refreshers.size > 0) {
+		changeset.refreshers = p.refreshers;
 	}
 	return changeset;
 }
@@ -3177,6 +3173,19 @@ function hasConflicts(change: ModularChangeset): boolean {
 	return (change.constraintViolationCount ?? 0) > 0;
 }
 
+/**
+ * A rebaseChild callback for fields with no new changes.
+ * Asserts that there are no new changes and returns undefined.
+ */
+function noNewChangesRebaseChild(
+	child: NodeId | undefined,
+	_baseChild: NodeId | undefined,
+	_stateChange: NodeAttachState | undefined,
+): NodeId | undefined {
+	assert(child === undefined, 0x9c3 /* There should be no new changes in this field */);
+	return undefined;
+}
+
 interface ModularChangesetContent {
 	fieldChanges: FieldChangeMap;
 	nodeChanges: ChangeAtomIdBTree<NodeChangeset>;

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

@@ -101,8 +101,8 @@ export interface CrossFieldKey extends ChangeAtomId {
 }
 
 export interface CrossFieldKeyRange {
-	key: CrossFieldKey;
-	count: number;
+	readonly key: CrossFieldKey;
+	readonly count: number;
 }
 
 export interface FieldId {
@@ -140,7 +140,7 @@ export interface HasFieldChanges {
 export type FieldChangeMap = Map<FieldKey, FieldChange>;
 
 export interface FieldChange {
-	fieldKind: FieldKindIdentifier;
+	readonly fieldKind: FieldKindIdentifier;
 	change: FieldChangeset;
 }
 

package/src/feature-libraries/object-forest/objectForest.ts

@@ -50,10 +50,10 @@ import {
 	type WithBreakable,
 } from "../../util/index.js";
 import { chunkField, defaultChunkPolicy } from "../chunked-forest/index.js";
-import { cursorForMapTreeNode, mapTreeFromCursor } from "../mapTreeCursor.js";
-import { type CursorWithNode, SynchronousCursor } from "../treeCursorUtils.js";
 import { defaultSchemaPolicy, FieldKinds } from "../default-schema/index.js";
+import { cursorForMapTreeNode, mapTreeFromCursor } from "../mapTreeCursor.js";
 import { isFieldInSchema, throwOutOfSchema } from "../schemaChecker.js";
+import { type CursorWithNode, SynchronousCursor } from "../treeCursorUtils.js";
 
 /** A `MapTree` with mutable fields */
 interface MutableMapTree extends MapTree {
@@ -308,7 +308,9 @@ export class ObjectForest implements IEditableForest, WithBreakable {
 
 		const forestVisitor = new Visitor(this);
 		const announcedVisitors: AnnouncedVisitor[] = [];
-		this.deltaVisitors.forEach((getVisitor) => announcedVisitors.push(getVisitor()));
+		for (const getVisitor of this.deltaVisitors) {
+			announcedVisitors.push(getVisitor());
+		}
 		const combinedVisitor = combineVisitors([forestVisitor, ...announcedVisitors]);
 		this.activeVisitor = combinedVisitor;
 		return combinedVisitor;

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

@@ -3,14 +3,12 @@
  * Licensed under the MIT License.
  */
 
-export { makeOptionalFieldCodecFamily } from "./optionalFieldCodecs.js";
-export type { Move, OptionalChangeset, RegisterId } from "./optionalFieldChangeTypes.js";
+export type { OptionalChangeset } from "./optionalFieldChangeTypes.js";
 export {
-	type IRegisterMap,
-	RegisterMap,
-	optionalChangeHandler,
-	optionalFieldEditor,
-	optionalChangeRebaser,
-	optionalFieldIntoDelta,
 	type OptionalFieldEditor,
+	optional,
 } from "./optionalField.js";
+export {
+	required,
+	type RequiredFieldEditor,
+} from "./requiredField.js";

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

@@ -12,9 +12,11 @@ import {
 	type DeltaDetachedNodeChanges,
 	type DeltaDetachedNodeId,
 	type DeltaMark,
+	Multiplicity,
 	type RevisionReplacer,
 	type RevisionTag,
 	areEqualChangeAtomIds,
+	forbiddenFieldKindIdentifier,
 	makeChangeAtomId,
 	taggedAtomId,
 } from "../../core/index.js";
@@ -27,6 +29,11 @@ import {
 	tryGetFromNestedMap,
 } from "../../util/index.js";
 import { nodeIdFromChangeAtom } from "../deltaUtils.js";
+import {
+	optionalIdentifier,
+	identifierFieldIdentifier,
+	requiredIdentifier,
+} from "../fieldKindIdentifiers.js";
 import {
 	type FieldChangeHandler,
 	type FieldChangeRebaser,
@@ -40,6 +47,7 @@ import {
 	type ToDelta,
 	type NestedChangesIndices,
 	type FieldChangeDelta,
+	FlexFieldKind,
 } from "../modular-schema/index.js";
 
 import type {
@@ -783,3 +791,26 @@ function* relevantRemovedRoots(
 		yield nodeIdFromChangeAtom(selfSrc);
 	}
 }
+
+interface Optional
+	extends FlexFieldKind<
+		OptionalFieldEditor,
+		typeof optionalIdentifier,
+		Multiplicity.Optional
+	> {}
+
+/**
+ * 0 or 1 items.
+ */
+export const optional: Optional = new FlexFieldKind(
+	optionalIdentifier,
+	Multiplicity.Optional,
+	{
+		changeHandler: optionalChangeHandler,
+		allowMonotonicUpgradeFrom: new Set([
+			identifierFieldIdentifier,
+			requiredIdentifier,
+			forbiddenFieldKindIdentifier,
+		]),
+	},
+);

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

@@ -0,0 +1,62 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { type ChangeAtomId, Multiplicity } from "../../core/index.js";
+import { requiredIdentifier, identifierFieldIdentifier } from "../fieldKindIdentifiers.js";
+import {
+	type FieldEditor,
+	type FieldChangeHandler,
+	FlexFieldKind,
+} from "../modular-schema/index.js";
+
+import { optionalChangeHandler, optionalFieldEditor } from "./optionalField.js";
+import type { OptionalChangeset } from "./optionalFieldChangeTypes.js";
+
+// Required fields are a restricted version of optional fields that must always contain a value.
+// Because of this, the implementation of required fields lives here, inside optional.
+// This avoids having to export optional field implementation details which are only used by required.
+
+/**
+ * {@link FieldEditor} for required fields (always contain exactly 1 child).
+ * @remarks
+ * This shares code with optional fields, since they are the same edit wise except setting to empty is not allowed,
+ * and the content is always assumed to not be empty.
+ * This means the actual edits implemented for optional fields are sufficient to support required fields
+ * which is why this is defined and implemented in terms of optional fields.
+ */
+export interface RequiredFieldEditor extends FieldEditor<OptionalChangeset> {
+	/**
+	 * Creates a change which replaces the current value of the field with `newValue`.
+	 * @param ids - The ids for the fill and detach fields.
+	 */
+	set(ids: { fill: ChangeAtomId; detach: ChangeAtomId }): OptionalChangeset;
+}
+
+export const requiredFieldEditor: RequiredFieldEditor = {
+	...optionalFieldEditor,
+	set: (ids: {
+		fill: ChangeAtomId;
+		detach: ChangeAtomId;
+	}): OptionalChangeset => optionalFieldEditor.set(false, ids),
+};
+
+export const requiredFieldChangeHandler: FieldChangeHandler<
+	OptionalChangeset,
+	RequiredFieldEditor
+> = {
+	...optionalChangeHandler,
+	editor: requiredFieldEditor,
+};
+
+interface Required
+	extends FlexFieldKind<RequiredFieldEditor, typeof requiredIdentifier, Multiplicity.Single> {}
+
+/**
+ * Exactly one item.
+ */
+export const required: Required = new FlexFieldKind(requiredIdentifier, Multiplicity.Single, {
+	changeHandler: requiredFieldChangeHandler,
+	allowMonotonicUpgradeFrom: new Set([identifierFieldIdentifier]),
+});

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

@@ -15,11 +15,11 @@ import {
 	makeVersionDispatchingCodec,
 	withSchemaValidation,
 } from "../../codec/index.js";
+import { SchemaFormatVersion } from "../../core/index.js";
 import { makeSchemaCodec, schemaCodecBuilder } from "../schema-index/index.js";
 
 import { EncodedSchemaChange } from "./schemaChangeFormat.js";
 import type { SchemaChange } from "./schemaChangeTypes.js";
-import { SchemaFormatVersion } from "../../core/index.js";
 
 /**
  * Create a family of schema change codecs.

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

@@ -4,6 +4,7 @@
  */
 
 import { type Static, Type } from "@sinclair/typebox";
+
 import { JsonCompatibleReadOnlySchema } from "../../util/index.js";
 
 export const EncodedSchemaChange = Type.Object({

package/src/feature-libraries/schemaChecker.ts

@@ -14,10 +14,11 @@ import {
 	Multiplicity,
 	type SchemaAndPolicy,
 } from "../core/index.js";
-import { allowsValue } from "./valueUtilities.js";
-import type { MapTreeFieldViewGeneric, MinimalMapTreeNodeView } from "./mapTreeCursor.js";
 import { iterableHasSome, mapIterable } from "../util/index.js";
 
+import type { MapTreeFieldViewGeneric, MinimalMapTreeNodeView } from "./mapTreeCursor.js";
+import { allowsValue } from "./valueUtilities.js";
+
 export enum SchemaValidationError {
 	Field_KindNotInSchemaPolicy,
 	Field_MissingRequiredChild,

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

@@ -3,54 +3,5 @@
  * Licensed under the MIT License.
  */
 
-export type {
-	Changeset,
-	Remove,
-	Detach,
-	HasMoveId,
-	HasRevisionTag,
-	Insert,
-	Mark,
-	MarkList,
-	MoveIn,
-	MoveOut,
-	CellCount as NodeCount,
-	MoveId,
-	Attach,
-	NoopMark,
-	CellId,
-	HasMarkFields,
-	CellMark,
-	AttachAndDetach,
-	Rename,
-} from "./types.js";
-export { DetachIdOverrideType } from "./formatV1.js";
-export {
-	type SequenceFieldChangeHandler,
-	sequenceFieldChangeHandler,
-} from "./sequenceFieldChangeHandler.js";
-export {
-	type SequenceChangeRebaser,
-	sequenceFieldChangeRebaser,
-} from "./sequenceFieldChangeRebaser.js";
-export { sequenceFieldChangeCodecFactory } from "./sequenceFieldCodecs.js";
-export { sequenceFieldToDelta } from "./sequenceFieldToDelta.js";
-export { type SequenceFieldEditor, sequenceFieldEditor } from "./sequenceFieldEditor.js";
-export { MarkListFactory } from "./markListFactory.js";
-export { rebase } from "./rebase.js";
-export { invert } from "./invert.js";
-export { compose } from "./compose.js";
-export {
-	getInputLength,
-	isDetach,
-	cloneMark,
-	extractMarkEffect,
-} from "./utils.js";
-export {
-	isMoveMark,
-	type MoveMark,
-	type MoveEffectTable,
-	type MoveEffect,
-} from "./moveEffectTable.js";
-
-export { relevantRemovedRoots } from "./relevantRemovedRoots.js";
+export type { CellId } from "./types.js";
+export { sequence } from "./sequenceKind.js";

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

@@ -315,7 +315,7 @@ function rebaseMarkIgnoreChild(
 			if (currMark.changes !== undefined) {
 				moveRebasedChanges(currMark.changes, moveEffects, getEndpoint(baseMark));
 			}
-			rebasedMark = { ...(remains ?? {}), count: baseMark.count };
+			rebasedMark = { ...remains, count: baseMark.count };
 		} else {
 			rebasedMark = currMark;
 		}

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

@@ -0,0 +1,40 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { Multiplicity, forbiddenFieldKindIdentifier } from "../../core/index.js";
+import {
+	sequenceIdentifier,
+	identifierFieldIdentifier,
+	requiredIdentifier,
+	optionalIdentifier,
+} from "../fieldKindIdentifiers.js";
+import { FlexFieldKind } from "../modular-schema/index.js";
+
+import { sequenceFieldChangeHandler } from "./sequenceFieldChangeHandler.js";
+import type { SequenceFieldEditor } from "./sequenceFieldEditor.js";
+
+interface Sequence
+	extends FlexFieldKind<
+		SequenceFieldEditor,
+		typeof sequenceIdentifier,
+		Multiplicity.Sequence
+	> {}
+
+/**
+ * 0 or more items.
+ */
+export const sequence: Sequence = new FlexFieldKind(
+	sequenceIdentifier,
+	Multiplicity.Sequence,
+	{
+		changeHandler: sequenceFieldChangeHandler,
+		allowMonotonicUpgradeFrom: new Set([
+			requiredIdentifier,
+			optionalIdentifier,
+			identifierFieldIdentifier,
+			forbiddenFieldKindIdentifier,
+		]),
+	},
+);

package/src/index.ts

@@ -9,6 +9,8 @@ export {
 	CommitKind,
 	RevertibleStatus,
 	type CommitMetadata,
+	type LocalChangeMetadata,
+	type RemoteChangeMetadata,
 	type ChangeMetadata,
 	type RevertibleFactory,
 	type RevertibleAlphaFactory,
@@ -292,10 +294,13 @@ export {
 	exportCompatibilitySchemaSnapshot,
 	importCompatibilitySchemaSnapshot,
 	checkCompatibility,
+	checkSchemaCompatibilitySnapshots,
+	type SnapshotFileSystem,
 	incrementalSummaryHint,
 	incrementalEncodingPolicyForAllowedTypes,
 	eraseSchemaDetails,
 	eraseSchemaDetailsSubclassable,
+	type SchemaCompatibilitySnapshotsOptions,
 } from "./simple-tree/index.js";
 export {
 	SharedTree,
@@ -360,3 +365,5 @@ export { JsonAsTree } from "./jsonDomainSchema.js";
 export { FluidSerializableAsTree } from "./serializableDomainSchema.js";
 export { TableSchema, type System_TableSchema } from "./tableSchema.js";
 export { asAlpha, asBeta } from "./api.js";
+
+export { TextAsTree, FormattedTextAsTree } from "./text/index.js";

package/src/packageVersion.ts

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

package/src/shared-tree/independentView.ts

@@ -30,6 +30,7 @@ import {
 	TreeCompressionStrategy,
 	defaultIncrementalEncodingPolicy,
 } from "../feature-libraries/index.js";
+import { combineChunks } from "../feature-libraries/index.js";
 // eslint-disable-next-line import-x/no-internal-modules
 import type { Format } from "../feature-libraries/schema-index/formatV1.js";
 import type {
@@ -49,6 +50,9 @@ import {
 	Breakable,
 	oneFromIterable,
 } from "../util/index.js";
+
+import { initialize, initializerFromChunk } from "./schematizeTree.js";
+import { SchematizingSimpleTreeView } from "./schematizingTreeView.js";
 import {
 	buildConfiguredForest,
 	defaultSharedTreeOptions,
@@ -56,9 +60,6 @@ import {
 	type ForestOptions,
 } from "./sharedTree.js";
 import { createTreeCheckout } from "./treeCheckout.js";
-import { SchematizingSimpleTreeView } from "./schematizingTreeView.js";
-import { initialize, initializerFromChunk } from "./schematizeTree.js";
-import { combineChunks } from "../feature-libraries/index.js";
 
 /**
  * Create an uninitialized {@link TreeView} that is not tied to any {@link ITree} instance.