@fluidframework/tree 2.91.0 → 2.92.0

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

@@ -4,90 +4,24 @@
  */
 
 import { assert } from "@fluidframework/core-utils/internal";
-import type { MinimumVersionForCollab } from "@fluidframework/runtime-definitions/internal";
 
-import {
-	type CodecTree,
-	type CodecWriteOptions,
-	type ICodecFamily,
-	type IJsonCodec,
-	makeCodecFamily,
-	makeVersionDispatchingCodec,
-	withSchemaValidation,
-} from "../../codec/index.js";
-import { SchemaFormatVersion } from "../../core/index.js";
-import { makeSchemaCodec, schemaCodecBuilder } from "../schema-index/index.js";
+import type { CodecWriteOptions, JsonCodecPart } from "../../codec/index.js";
+import { schemaCodecBuilder } from "../schema-index/index.js";
 
 import { EncodedSchemaChange } from "./schemaChangeFormat.js";
 import type { SchemaChange } from "./schemaChangeTypes.js";
 
 /**
- * Create a family of schema change codecs.
- * @param options - Specifies common codec options, including which `validator` to use.
- * @returns The composed codec family.
- */
-export function makeSchemaChangeCodecs(
-	options: CodecWriteOptions,
-): ICodecFamily<SchemaChange> {
-	return makeCodecFamily([
-		[SchemaFormatVersion.v1, makeSchemaChangeCodecV1(options, SchemaFormatVersion.v1)],
-		// This code  (makeSchemaChangeCodecs) is constructing a SchemaFormatVersion.v2 codec, regardless of the requested write version.
-		// It then trusts the user of the produced makeCodecFamily to only select if when it is valid to do so.
-		// This trust is manifests in having to use `allowPossiblyIncompatibleWriteVersionOverrides`
-		// here as it needs to build the v2 codec regardless of if its valid to use.
-		// TODO: There should not be two separate places selecting the write version for this codec. Such cases should instead adopt one of the following patterns:
-		// 1. The outer coded should let the inner one do its own version selection instead of forcing it.
-		// 2. The outer codec should fully handle version selection and embed the inner content directly (referencing its format not codec) and not involve the codec at all.
-		// TODO: fix this up when migrating SchemaChangeCodec to use ClientVersionDispatchingCodecBuilder.
-		// This should probably use pattern 1 above, which will result in this codec having two identical versions.
-		[
-			SchemaFormatVersion.v2,
-			makeSchemaChangeCodecV1(
-				{ ...options, allowPossiblyIncompatibleWriteVersionOverrides: true },
-				SchemaFormatVersion.v2,
-			),
-		],
-	]);
-}
-
-export function getCodecTreeForSchemaChangeFormat(
-	version: SchemaFormatVersion,
-	clientVersion: MinimumVersionForCollab,
-): CodecTree {
-	return {
-		name: "SchemaChange",
-		version,
-		children: [schemaCodecBuilder.getCodecTree(clientVersion)],
-	};
-}
-
-/**
- * Create a schema change codec.
- * @param options - Specifies common codec options, including which `validator` to use.
- * @param writeVersion - The schema change write version.
- * @returns The composed codec.
- */
-export function makeSchemaChangeCodec(
-	options: CodecWriteOptions,
-	writeVersion: SchemaFormatVersion,
-): IJsonCodec<SchemaChange> {
-	const family = makeSchemaChangeCodecs(options);
-	return makeVersionDispatchingCodec(family, { ...options, writeVersion });
-}
-
-/**
- * Compose the change codec using mostly v1 logic.
+ * Creates a codec for schema changes.
  * @param options - The codec options.
- * @param schemaWriteVersion - The schema write version.
- * @returns The composed schema change codec.
+ * @returns The composed schema change codec part.
  */
-function makeSchemaChangeCodecV1(
+export function makeSchemaChangeCodec(
 	options: CodecWriteOptions,
-	schemaWriteVersion: SchemaFormatVersion,
-): IJsonCodec<SchemaChange, EncodedSchemaChange> {
-	const schemaCodec = makeSchemaCodec(options, schemaWriteVersion);
-	const schemaChangeCodec: IJsonCodec<SchemaChange, EncodedSchemaChange> = {
-		encode: (schemaChange) => {
+): JsonCodecPart<SchemaChange, typeof EncodedSchemaChange> {
+	const schemaCodec = schemaCodecBuilder.build(options);
+	return {
+		encode: (schemaChange: SchemaChange): EncodedSchemaChange => {
 			assert(
 				!schemaChange.isInverse,
 				0x933 /* Inverse schema changes should never be transmitted */,
@@ -97,7 +31,7 @@ function makeSchemaChangeCodecV1(
 				old: schemaCodec.encode(schemaChange.schema.old),
 			};
 		},
-		decode: (encoded) => {
+		decode: (encoded: EncodedSchemaChange): SchemaChange => {
 			return {
 				schema: {
 					new: schemaCodec.decode(encoded.new),
@@ -108,6 +42,4 @@ function makeSchemaChangeCodecV1(
 		},
 		encodedSchema: EncodedSchemaChange,
 	};
-
-	return withSchemaValidation(EncodedSchemaChange, schemaChangeCodec, options.jsonValidator);
 }

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

@@ -8,9 +8,7 @@ import { lowestMinVersionForCollab } from "@fluidframework/runtime-utils/interna
 
 import {
 	ClientVersionDispatchingCodecBuilder,
-	type CodecWriteOptions,
 	FluidClientVersion,
-	type IJsonCodec,
 } from "../../codec/index.js";
 import {
 	SchemaFormatVersion,
@@ -27,29 +25,6 @@ import { brand } from "../../util/index.js";
 import { Format as FormatV1 } from "./formatV1.js";
 import { Format as FormatV2 } from "./formatV2.js";
 
-/**
- * Create a schema codec.
- * @param options - Specifies common codec options, including `minVersionForCollab` and which `validator` to use.
- * @param writeVersionOverride - The schema version to write. If not provided, the version will be derived from `minVersionForCollab`.
- * TODO: Currently this parameter is provided when it probably should not be. Users of it should probably allow the automatic selection to occur and this parameter can be removed.
- * Any case where an override is actually required can use `options` to do so.
- * @returns The composed codec.
- *
- * @privateRemarks We should consider using the Shared Tree format version instead as it may be more valuable for application authors than the schema version.
- *
- * TODO: replace use of this with schemaCodecBuilder.build(...).
- */
-export function makeSchemaCodec(
-	options: CodecWriteOptions,
-	writeVersionOverride?: SchemaFormatVersion,
-): IJsonCodec<TreeStoredSchema> {
-	const overrides = new Map(options.writeVersionOverrides ?? []);
-	if (writeVersionOverride !== undefined) {
-		overrides.set(schemaCodecBuilder.name, writeVersionOverride);
-	}
-	return schemaCodecBuilder.build({ ...options, writeVersionOverrides: overrides });
-}
-
 function encodeRepoV1(repo: TreeStoredSchema): FormatV1 {
 	const nodeSchema = encodeNodeSchema(repo, (schema) => schema.encodeV1());
 	const rootFieldSchema = encodeFieldSchemaV1(repo.rootFieldSchema);

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

@@ -17,7 +17,7 @@ const noAdditionalProps: ObjectOptions = { additionalProperties: false };
  * 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.
+ * It also makes it simpler to deterministically sort by keys.
  */
 export const Format = Type.Object(
 	{

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

@@ -4,9 +4,6 @@
  */
 
 export { SchemaSummarizer } from "./schemaSummarizer.js";
-export {
-	makeSchemaCodec,
-	schemaCodecBuilder,
-} from "./codec.js";
+export { schemaCodecBuilder } from "./codec.js";
 export { Format as FormatV1 } from "./formatV1.js";
 export { Format as FormatV2 } from "./formatV2.js";

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

@@ -10,12 +10,14 @@ import {
 	DiscriminatedUnionDispatcher,
 	type DiscriminatedUnionLibrary,
 	type IJsonCodec,
+	type JsonCodecPart,
 } from "../../codec/index.js";
 import type {
 	ChangeEncodingContext,
 	ChangesetLocalId,
 	EncodedRevisionTag,
 	RevisionTag,
+	RevisionTagSchema,
 } from "../../core/index.js";
 import { type JsonCompatibleReadOnly, type Mutable, brand } from "../../util/index.js";
 import { makeChangeAtomIdCodec } from "../changeAtomIdCodec.js";
@@ -43,10 +45,9 @@ import {
 import { isNoopMark, normalizeCellRename } from "./utils.js";
 
 export function makeV2CodecHelpers(
-	revisionTagCodec: IJsonCodec<
+	revisionTagCodec: JsonCodecPart<
 		RevisionTag,
-		EncodedRevisionTag,
-		EncodedRevisionTag,
+		typeof RevisionTagSchema,
 		ChangeEncodingContext
 	>,
 ): SequenceCodecHelpers<MarkEffect, Encoded.MarkEffect> {
@@ -261,10 +262,9 @@ export function makeV2CodecHelpers(
 }
 
 export function makeV2Codec(
-	revisionTagCodec: IJsonCodec<
+	revisionTagCodec: JsonCodecPart<
 		RevisionTag,
-		EncodedRevisionTag,
-		EncodedRevisionTag,
+		typeof RevisionTagSchema,
 		ChangeEncodingContext
 	>,
 ): IJsonCodec<

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

@@ -5,11 +5,15 @@
 
 import type { TAnySchema } from "@sinclair/typebox";
 
-import { DiscriminatedUnionDispatcher, type IJsonCodec } from "../../codec/index.js";
+import {
+	DiscriminatedUnionDispatcher,
+	type IJsonCodec,
+	type JsonCodecPart,
+} from "../../codec/index.js";
 import type {
 	ChangeEncodingContext,
-	EncodedRevisionTag,
 	RevisionTag,
+	RevisionTagSchema,
 } from "../../core/index.js";
 import type { JsonCompatibleReadOnly } from "../../util/index.js";
 import {
@@ -23,10 +27,9 @@ import type { Changeset, Mark, MarkEffect, Rename } from "./types.js";
 import { isNoopMark } from "./utils.js";
 
 export function makeV3Codec(
-	revisionTagCodec: IJsonCodec<
+	revisionTagCodec: JsonCodecPart<
 		RevisionTag,
-		EncodedRevisionTag,
-		EncodedRevisionTag,
+		typeof RevisionTagSchema,
 		ChangeEncodingContext
 	>,
 ): IJsonCodec<

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

@@ -3,11 +3,11 @@
  * Licensed under the MIT License.
  */
 
-import { type IJsonCodec, makeCodecFamily, type ICodecFamily } from "../../codec/index.js";
+import { type JsonCodecPart, makeCodecFamily, type ICodecFamily } from "../../codec/index.js";
 import type {
 	ChangeEncodingContext,
-	EncodedRevisionTag,
 	RevisionTag,
+	RevisionTagSchema,
 } from "../../core/index.js";
 import type { FieldChangeEncodingContext } from "../modular-schema/index.js";
 
@@ -16,10 +16,9 @@ import { makeV3Codec } from "./sequenceFieldCodecV3.js";
 import type { Changeset, MarkList } from "./types.js";
 
 export const sequenceFieldChangeCodecFactory = (
-	revisionTagCodec: IJsonCodec<
+	revisionTagCodec: JsonCodecPart<
 		RevisionTag,
-		EncodedRevisionTag,
-		EncodedRevisionTag,
+		typeof RevisionTagSchema,
 		ChangeEncodingContext
 	>,
 ): ICodecFamily<MarkList, FieldChangeEncodingContext> =>

package/src/index.ts

@@ -71,9 +71,6 @@ export {
 	Tree,
 	type RunTransaction,
 	type ForestOptions,
-	getBranch,
-	type BranchableTree,
-	type TreeBranchFork,
 	independentInitializedView,
 	type ViewContent,
 	TreeAlpha,
@@ -91,6 +88,7 @@ export {
 
 export {
 	TreeArrayNode,
+	type TreeArrayNodeAlpha,
 	type Unhydrated,
 	IterableTreeArrayContent,
 	TreeNode,
@@ -134,7 +132,14 @@ export {
 	normalizeFieldSchema,
 	type InternalTreeNode,
 	type WithType,
+	type ArrayNodeDeltaOp,
+	type ArrayNodeInsertOp,
+	type ArrayNodeRemoveOp,
+	type ArrayNodeRetainOp,
 	type NodeChangedData,
+	type NodeChangedDataAlpha,
+	type NodeChangedDataDelta,
+	type NodeChangedDataProperties,
 	type SchemaUpgrade,
 	contentSchemaSymbol,
 	// Types not really intended for public use, but used in links.
@@ -205,6 +210,7 @@ export {
 	// Beta APIs
 	TreeBeta,
 	type TreeChangeEventsBeta,
+	type TreeChangeEventsAlpha,
 	// Other
 	type VerboseTreeNode,
 	type TreeEncodingOptions,
@@ -284,6 +290,7 @@ export {
 	allowUnused,
 	type LeafSchema,
 	type ArrayNodeCustomizableSchema,
+	type ArrayNodeCustomizableSchemaAlpha,
 	type ArrayNodePojoEmulationSchema,
 	ArrayNodeSchema,
 	type MapNodeCustomizableSchema,

package/src/packageVersion.ts

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

package/src/shared-tree/independentView.ts

@@ -10,29 +10,22 @@ import {
 	createIdCompressor,
 } from "@fluidframework/id-compressor/internal";
 
-import {
-	FluidClientVersion,
-	type CodecWriteOptions,
-	type ICodecOptions,
-} from "../codec/index.js";
+import type { CodecWriteOptions, ICodecOptions } from "../codec/index.js";
 import {
 	type RevisionTag,
 	RevisionTagCodec,
-	SchemaFormatVersion,
 	TreeStoredSchemaRepository,
 } from "../core/index.js";
 import {
 	createNodeIdentifierManager,
 	fieldBatchCodecBuilder,
-	makeSchemaCodec,
 	type FieldBatchEncodingContext,
 	defaultSchemaPolicy,
 	TreeCompressionStrategy,
 	defaultIncrementalEncodingPolicy,
+	schemaCodecBuilder,
 } 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 {
 	TreeViewConfiguration,
 	ImplicitFieldSchema,
@@ -236,15 +229,9 @@ export function createIndependentTreeAlpha<const TSchema extends ImplicitFieldSc
 	});
 
 	if (options?.content !== undefined) {
-		// Any version can be passed down to `makeSchemaCodec` and `fieldBatchCodecBuilder.build` here.
-		// We only use the decode part, which always dispatches to the correct codec based on the version in the data, not `minVersionForCollab`.
-		const writeOptions: CodecWriteOptions = {
-			...options,
-			minVersionForCollab: FluidClientVersion.v2_0,
-		};
-		const schemaCodec = makeSchemaCodec(writeOptions, SchemaFormatVersion.v1);
-		const fieldBatchCodec = fieldBatchCodecBuilder.build(writeOptions);
-		const newSchema = schemaCodec.decode(options.content.schema as Format);
+		const schemaCodec = schemaCodecBuilder.buildDecoder(options);
+		const fieldBatchCodec = fieldBatchCodecBuilder.buildDecoder(options);
+		const newSchema = schemaCodec.decode(options.content.schema);
 
 		const context: FieldBatchEncodingContext = {
 			encodeType: TreeCompressionStrategy.Compressed,

package/src/shared-tree/index.ts

@@ -9,7 +9,6 @@ export {
 	type SharedTreeOptions,
 	type SharedTreeOptionsBeta,
 	SharedTreeKernel,
-	getBranch,
 	type ForestType,
 	type SharedTreeContentSnapshot,
 	type SharedTreeFormatOptions,
@@ -31,9 +30,6 @@ export {
 	TreeCheckout,
 	type ITreeCheckout,
 	type CheckoutEvents,
-	type ITreeCheckoutFork,
-	type BranchableTree,
-	type TreeBranchFork,
 } from "./treeCheckout.js";
 
 export { SchematizingSimpleTreeView } from "./schematizingTreeView.js";

package/src/shared-tree/schematizingTreeView.ts

@@ -9,7 +9,7 @@ import type {
 	IEmitter,
 	Listenable,
 } from "@fluidframework/core-interfaces/internal";
-import { assert, unreachableCase } from "@fluidframework/core-utils/internal";
+import { assert } from "@fluidframework/core-utils/internal";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 
 import { anchorSlot, rootFieldKey } from "../core/index.js";
@@ -17,7 +17,6 @@ import {
 	type NodeIdentifierManager,
 	defaultSchemaPolicy,
 	cursorForMapTreeField,
-	TreeStatus,
 	Context,
 	combineChunks,
 	type FlexTreeOptionalField,
@@ -41,16 +40,12 @@ import {
 	type ReadableField,
 	type ReadSchema,
 	type UnsafeUnknownSchema,
-	type TreeBranch,
 	type TreeBranchEvents,
-	getInnerNode,
-	getKernel,
 	type VoidTransactionCallbackStatus,
 	type TransactionCallbackStatus,
 	type TransactionResult,
 	type TransactionResultExt,
 	type RunTransactionParams,
-	type TransactionConstraintAlpha,
 	HydratedContext,
 	SimpleContextSlot,
 	areImplicitFieldSchemaEqual,
@@ -72,7 +67,7 @@ import {
 } from "../util/index.js";
 
 import { canInitialize, initialize, initializerFromChunk } from "./schematizeTree.js";
-import type { ITreeCheckout, TreeCheckout } from "./treeCheckout.js";
+import type { TreeCheckout } from "./treeCheckout.js";
 
 /**
  * Creating multiple tree views from the same checkout is not supported. This slot is used to detect if one already
@@ -276,16 +271,10 @@ export class SchematizingSimpleTreeView<
 		return this.flexTreeContext;
 	}
 
-	/**
-	 * {@inheritDoc @fluidframework/shared-tree#TreeViewAlpha.runTransaction}
-	 */
 	public runTransaction<TSuccessValue, TFailureValue>(
 		transaction: () => TransactionCallbackStatus<TSuccessValue, TFailureValue>,
 		params?: RunTransactionParams,
 	): TransactionResultExt<TSuccessValue, TFailureValue>;
-	/**
-	 * {@inheritDoc @fluidframework/shared-tree#TreeViewAlpha.runTransaction}
-	 */
 	public runTransaction(
 		transaction: () => VoidTransactionCallbackStatus | void,
 		params?: RunTransactionParams,
@@ -297,21 +286,14 @@ export class SchematizingSimpleTreeView<
 			| void,
 		params?: RunTransactionParams,
 	): TransactionResultExt<TSuccessValue, TFailureValue> | TransactionResult {
-		this.mountTransaction(params, false);
-		const transactionCallbackStatus = transaction();
-		return this.unmountTransaction(transactionCallbackStatus, params);
+		this.ensureUndisposed();
+		return this.checkout.runTransaction(transaction, params);
 	}
 
-	/**
-	 * {@inheritDoc @fluidframework/shared-tree#TreeViewAlpha.runTransactionAsync}
-	 */
 	public runTransactionAsync<TSuccessValue, TFailureValue>(
 		transaction: () => Promise<TransactionCallbackStatus<TSuccessValue, TFailureValue>>,
 		params?: RunTransactionParams,
 	): Promise<TransactionResultExt<TSuccessValue, TFailureValue>>;
-	/**
-	 * {@inheritDoc @fluidframework/shared-tree#TreeViewAlpha.runTransactionAsync}
-	 */
 	public runTransactionAsync(
 		transaction: () => Promise<VoidTransactionCallbackStatus | void>,
 		params?: RunTransactionParams,
@@ -324,66 +306,21 @@ export class SchematizingSimpleTreeView<
 		>,
 		params: RunTransactionParams | undefined,
 	): Promise<TransactionResultExt<TSuccessValue, TFailureValue> | TransactionResult> {
-		this.mountTransaction(params, true);
-		const transactionCallbackStatus = await transaction();
-		return this.unmountTransaction(transactionCallbackStatus, params);
-	}
-
-	private mountTransaction(params: RunTransactionParams | undefined, isAsync: boolean): void {
 		this.ensureUndisposed();
-		const { checkout } = this;
-		if (isAsync && checkout.transaction.size > 0) {
-			throw new UsageError(
-				"An asynchronous transaction cannot be started while another transaction is already in progress.",
+		if (this.checkout.transaction.size > 0) {
+			// breaker.break() sets brokenBy synchronously before throwing.
+			// A plain `throw` inside an async function would be captured as a rejected Promise
+			// before @breakingClass could set brokenBy. By setting it here first, the
+			// subsequent call to unmountTransaction (also @breakingClass-wrapped) will see the
+			// broken state and throw synchronously, propagating out of the outer runTransaction
+			// to its caller.
+			this.breaker.break(
+				new UsageError(
+					"An asynchronous transaction cannot be started while another transaction is already in progress.",
+				),
 			);
 		}
-		checkout.pushLabelFrame(params?.label);
-		checkout.transaction.start();
-
-		// Validate preconditions before running the transaction callback.
-		addConstraintsToTransaction(
-			checkout,
-			false /* constraintsOnRevert */,
-			params?.preconditions,
-		);
-	}
-
-	private unmountTransaction<TSuccessValue, TFailureValue>(
-		transactionCallbackStatus:
-			| TransactionCallbackStatus<TSuccessValue, TFailureValue>
-			| VoidTransactionCallbackStatus
-			| void,
-		params: RunTransactionParams | undefined,
-	): TransactionResultExt<TSuccessValue, TFailureValue> | TransactionResult {
-		this.ensureUndisposed();
-		const { checkout } = this;
-		const rollback = transactionCallbackStatus?.rollback;
-		const value = (
-			transactionCallbackStatus as TransactionCallbackStatus<TSuccessValue, TFailureValue>
-		)?.value;
-
-		if (rollback === true) {
-			checkout.popLabelFrame(true);
-			checkout.transaction.abort();
-			return value === undefined
-				? { success: false }
-				: { success: false, value: value as TFailureValue };
-		}
-
-		// Validate preconditions on revert after running the transaction callback and was successful.
-		addConstraintsToTransaction(
-			checkout,
-			true /* constraintsOnRevert */,
-			transactionCallbackStatus?.preconditionsOnRevert,
-		);
-
-		checkout.popLabelFrame(false);
-		checkout.runWithTransactionLabel(() => {
-			checkout.transaction.commit();
-		}, params?.label);
-		return value === undefined
-			? { success: true }
-			: { success: true, value: value as TSuccessValue };
+		return this.checkout.runTransactionAsync(transaction, params);
 	}
 
 	private ensureUndisposed(): void {
@@ -581,99 +518,16 @@ export class SchematizingSimpleTreeView<
 
 	public fork(): ReturnType<TreeBranchAlpha["fork"]> &
 		SchematizingSimpleTreeView<TRootSchema> {
-		return this.checkout.branch().viewWith(this.config);
+		return this.checkout.fork().viewWith(this.config);
 	}
 
 	public merge(context: TreeBranchAlpha, disposeMerged = true): void {
-		this.checkout.merge(getCheckout(context), disposeMerged);
+		this.checkout.merge(context, disposeMerged);
 	}
 
 	public rebaseOnto(context: TreeBranchAlpha): void {
-		getCheckout(context).rebase(this.checkout);
+		this.checkout.rebaseOnto(context);
 	}
 
 	// #endregion Branching
 }
-
-/**
- * Get the {@link TreeCheckout} associated with a given {@link TreeBranch}.
- * @remarks Currently, all contexts are also {@link SchematizingSimpleTreeView}s.
- * Other checkout implementations (e.g. not associated with a view) may be supported in the future.
- */
-export function getCheckout(context: TreeBranch): TreeCheckout {
-	if (context instanceof SchematizingSimpleTreeView) {
-		return context.checkout;
-	}
-	throw new UsageError("Unsupported context implementation");
-}
-
-/**
- * Adds constraints to a `checkout`'s pending transaction.
- *
- * @param checkout - The checkout's who's transaction will have the constraints added to it.
- * @param constraintsOnRevert - If true, use {@link ISharedTreeEditor.addNodeExistsConstraintOnRevert}.
- * @param constraints - The constraints to add to the transaction.
- *
- * @see {@link RunTransactionParams.preconditions}.
- */
-export function addConstraintsToTransaction(
-	checkout: ITreeCheckout,
-	constraintsOnRevert: boolean,
-	constraints: readonly TransactionConstraintAlpha[] = [],
-): void {
-	for (const constraint of constraints) {
-		assertValidConstraint(constraint, constraintsOnRevert);
-		const constraintType = constraint.type;
-		switch (constraintType) {
-			case "nodeInDocument": {
-				const node = getInnerNode(constraint.node);
-				assert(node.isHydrated(), 0xbc2 /* In document node must be hydrated. */);
-				if (constraintsOnRevert) {
-					checkout.editor.addNodeExistsConstraintOnRevert(node.anchorNode);
-				} else {
-					checkout.editor.addNodeExistsConstraint(node.anchorNode);
-				}
-				break;
-			}
-			case "noChange": {
-				if (constraintsOnRevert) {
-					checkout.editor.addNoChangeConstraintOnRevert();
-				} else {
-					checkout.editor.addNoChangeConstraint();
-				}
-				break;
-			}
-			default: {
-				unreachableCase(constraintType);
-			}
-		}
-	}
-}
-
-/**
- * Throws if the given {@link TransactionConstraintAlpha | transaction constraint} is not currently satisfied.
- */
-export function assertValidConstraint(
-	constraint: TransactionConstraintAlpha,
-	onRevert: boolean,
-): void {
-	switch (constraint.type) {
-		case "nodeInDocument": {
-			const nodeStatus = getKernel(constraint.node).getStatus();
-			if (nodeStatus !== TreeStatus.InDocument) {
-				const revertText = onRevert ? " on revert" : "";
-				throw new UsageError(
-					`Attempted to add a "nodeInDocument" constraint${revertText}, but the node is not currently in the document. Node status: ${nodeStatus}`,
-				);
-			}
-			break;
-		}
-		case "noChange": {
-			// This constraint is always satisfied at the time of checking, since it just requires that no changes have been made since the transaction callback returned.
-			break;
-		}
-		default: {
-			unreachableCase(constraint);
-		}
-	}
-}