@fluidframework/tree 2.74.0 → 2.80.0

package/src/shared-tree/treeAlpha.ts

@@ -12,7 +12,7 @@ import {
 import { createIdCompressor } from "@fluidframework/id-compressor/internal";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 import type { IFluidHandle } from "@fluidframework/core-interfaces";
-import type { IIdCompressor } from "@fluidframework/id-compressor";
+import type { IIdCompressor, SessionSpaceCompressedId } from "@fluidframework/id-compressor";
 
 import {
 	asIndex,
@@ -59,6 +59,7 @@ import {
 	contentSchemaSymbol,
 	type TreeNodeSchema,
 	getUnhydratedContext,
+	type TreeBranchAlpha,
 } from "../simple-tree/index.js";
 import { brand, extractFromOpaque, type JsonCompatible } from "../util/index.js";
 import {
@@ -83,32 +84,32 @@ import {
 	type Observer,
 	withObservation,
 } from "../feature-libraries/index.js";
-import type { TreeBranchAlpha } from "../simple-tree/index.js";
 import { independentInitializedView, type ViewContent } from "./independentView.js";
 import { SchematizingSimpleTreeView, ViewSlot } from "./schematizingTreeView.js";
 import { isFluidHandle } from "@fluidframework/runtime-utils";
 
 const identifier: TreeIdentifierUtils = (node: TreeNode): string | undefined => {
-	const nodeIdentifier = getIdentifierFromNode(node, "uncompressed");
-	if (typeof nodeIdentifier === "number") {
-		throw new TypeError("identifier should be uncompressed.");
-	}
-	return nodeIdentifier;
+	return getIdentifierFromNode(node, "uncompressed");
 };
 
 identifier.shorten = (branch: TreeBranch, nodeIdentifier: string): number | undefined => {
-	const nodeKeyManager = (branch as SchematizingSimpleTreeView<ImplicitFieldSchema>)
-		.nodeKeyManager;
+	assert(
+		branch instanceof SchematizingSimpleTreeView,
+		0xcac /* Unexpected branch implementation */,
+	);
+	const { nodeKeyManager } = branch;
 	const localNodeKey = nodeKeyManager.tryLocalizeNodeIdentifier(nodeIdentifier);
-	return localNodeKey !== undefined ? extractFromOpaque(localNodeKey) : undefined;
+	return localNodeKey === undefined ? undefined : extractFromOpaque(localNodeKey);
 };
 
 identifier.lengthen = (branch: TreeBranch, nodeIdentifier: number): string => {
-	const nodeKeyManager = (branch as SchematizingSimpleTreeView<ImplicitFieldSchema>)
-		.nodeKeyManager;
-	return nodeKeyManager.stabilizeNodeIdentifier(
-		nodeIdentifier as unknown as LocalNodeIdentifier,
+	assert(
+		branch instanceof SchematizingSimpleTreeView,
+		0xcad /* Unexpected branch implementation */,
 	);
+	const { nodeKeyManager } = branch;
+	const local = brand<LocalNodeIdentifier>(nodeIdentifier as SessionSpaceCompressedId);
+	return nodeKeyManager.stabilizeNodeIdentifier(local);
 };
 
 identifier.getShort = (node: TreeNode): number | undefined => {
@@ -125,64 +126,70 @@ identifier.create = (branch: TreeBranch): string => {
 Object.freeze(identifier);
 
 /**
- * A utility interface for retrieving or converting node identifiers.
- *
+ * A utility interface for manipulating node identifiers.
  * @remarks
  * This provides methods to:
  *
- * - Retrieve long or short identifiers from nodes
- *
- * - Convert between long identifiers and short identifiers
- *
- * - Generates long identifiers
+ * - Retrieve identifiers from nodes
+ * - Generate identifiers
+ * - Convert between short numeric identifiers and long string identifiers
  *
  * @alpha @sealed
  */
 export interface TreeIdentifierUtils {
 	/**
-	 * Returns the contents of a node's {@link SchemaFactory.identifier} field as a stable identifier.
-	 * If the identifier field does not exist, returns undefined.
+	 * Returns the identifier of a node.
+	 * @remarks
+	 * This returns the node's UUID if and only if it has exactly one {@link SchemaFactory.identifier | identifier field}.
+	 * If it has no identifier field, this returns undefined.
+	 * If it has more than one identifier field, this throws an error.
+	 * In that case, query the identifier fields directly instead.
 	 *
 	 * @param node - The TreeNode you want to get the identifier from,
 	 */
 	(node: TreeNode): string | undefined;
 
 	/**
-	 * Returns the shortened identifier as a number given long identifier known by the id compressor on the branch if possible.
-	 * Otherwise, it will return the original string identifier provided.
-	 * If the id does not exist, or is unknown by the id compressor, it returns undefined.
+	 * Returns the shortened identifier as a number given a UUID known by the id compressor on the branch.
+	 * @remarks
+	 * If the given string is not a valid identifier and/or was not generated by the SharedTree, this will return `undefined`.
+	 *
+	 * See {@link TreeIdentifierUtils.getShort} for additional details about shortened identifiers.
 	 *
-	 * This method is the inverse of {@link TreeIdentifierUtils.lengthen}. If you shorten an identifier
-	 * and then immediately pass it to {@link TreeIdentifierUtils.lengthen}, you will get the original string back.
+	 * This method is the inverse of {@link TreeIdentifierUtils.lengthen}.
+	 * If you shorten an identifier and then immediately pass it to {@link TreeIdentifierUtils.lengthen}, you will get the original string back.
 	 *
-	 * @param branch - TreeBranch from where you get the idCompressor to do the decompression.
-	 * @param nodeIdentifier - the stable identifier that needs to be shortened.
+	 * @param branch - The branch (and/or view) of the SharedTree that will perform the compression.
+	 * @param nodeIdentifier - the stable identifier to be shortened.
 	 */
 	shorten(branch: TreeBranch, nodeIdentifier: string): number | undefined;
 
 	/**
-	 * Returns the stable id as a string if the identifier is decompressible and known by the id compressor. Otherwise, it will throw an error.
+	 * Returns the stable id as a string if the identifier is decompressible and known by the id compressor.
+	 * @remarks
+	 * If the given number does not correspond to a valid identifier generated by the SharedTree, this will return `undefined`.
 	 *
-	 * This method is the inverse of {@link TreeIdentifierUtils.shorten}. If you lengthen an identifier
-	 * and then immediately pass it to {@link TreeIdentifierUtils.shorten}, you will get the original short identifier back.
+	 * This method is the inverse of {@link TreeIdentifierUtils.shorten}.
+	 * If you lengthen an identifier and then immediately pass it to {@link TreeIdentifierUtils.shorten}, you will get the original short identifier back.
 	 *
-	 * @param branch - TreeBranch from where you want to get the id compressor to do the decompression.
-	 * @param nodeIdentifier - The local identifier that needs to be expanded.
+	 * @param branch - The branch (and/or view) of the SharedTree that will perform the decompression.
+	 * @param nodeIdentifier - The local identifier to be lengthened.
 	 */
 	lengthen(branch: TreeBranch, nodeIdentifier: number): string;
 
 	/**
-	 * Returns the {@link SchemaFactory.identifier | identifier} of the given node in the most compressed form possible.
+	 * Returns the {@link TreeIdentifierUtils.shorten | shortened} form of the identifier {@link SchemaFactory.identifier | identifier} for the given node.
 	 * @remarks
 	 * If the node is {@link Unhydrated | hydrated} and its identifier is a valid UUID that was automatically generated by the SharedTree it is part of (or something else using the same {@link @fluidframework/id-compressor#IIdCompressor}), then this will return a process-unique integer corresponding to that identifier.
 	 * This is useful for performance-sensitive scenarios involving many nodes with identifiers that need to be compactly retained in memory or used for efficient lookup.
-	 * Note that automatically generated identifiers that were accessed before the node was hydrated will return the generated UUID, not the process-unique integer.
+	 * Note that automatically generated identifiers that were accessed before the node was hydrated will not yield a short identifier until after hydration.
 	 *
-	 * If the node's identifier is any other user-provided string, then this will return undefined.
+	 * If the node's identifier is any other user-provided string, then this will return `undefined`.
 	 *
 	 * If the node has no identifier (that is, it has no {@link SchemaFactory.identifier | identifier} field), then this returns `undefined`.
 	 *
 	 * If the node has more than one identifier, then this will throw an error.
+	 * In that case, retrieve the identifiers individually via their fields instead.
 	 *
 	 * The returned integer should not be serialized or preserved outside of the current process.
 	 * Its lifetime is that of the current in-memory instance of the FF container for this client, and it is not guaranteed to be unique or stable outside of that context.
@@ -191,10 +198,11 @@ export interface TreeIdentifierUtils {
 	getShort(node: TreeNode): number | undefined;
 
 	/**
-	 * Creates and returns a long identifier.
-	 * The long identifier is a compressible, stable identifier generated by the tree's ID compressor.
+	 * Creates a new identifier.
+	 * @remarks
+	 * The returned UUID string can be {@link TreeIdentifierUtils.shorten | shortened} for high-performance scenarios.
 	 *
-	 * @param branch - TreeBranch from where you want to get the id compressor to generate the identifier from.
+	 * @param branch - The branch (and/or view) of the SharedTree that will generate and manage the identifier.
 	 */
 	create(branch: TreeBranch): string;
 }
@@ -629,12 +637,12 @@ class NodeSubscription {
 					return;
 				}
 				const subscription = subscriptions.get(flexNode);
-				if (subscription !== undefined) {
-					// Already subscribed to this node.
-					subscription.keys = undefined; // Now subscribed to all keys.
-				} else {
+				if (subscription === undefined) {
 					const newSubscription = new NodeSubscription(invalidate, flexNode);
 					subscriptions.set(flexNode, newSubscription);
+				} else {
+					// Already subscribed to this node.
+					subscription.keys = undefined; // Now subscribed to all keys.
 				}
 			},
 			observeNodeField(flexNode: FlexTreeNode, key: FieldKey): void {
@@ -643,15 +651,15 @@ class NodeSubscription {
 					return;
 				}
 				const subscription = subscriptions.get(flexNode);
-				if (subscription !== undefined) {
+				if (subscription === undefined) {
+					const newSubscription = new NodeSubscription(invalidate, flexNode);
+					newSubscription.keys = new Set([key]);
+					subscriptions.set(flexNode, newSubscription);
+				} else {
 					// Already subscribed to this node: if not subscribed to all keys, subscribe to this one.
 					// TODO:Performance: due to how JavaScript set ordering works,
 					// it might be faster to check `has` and only add if not present in case the same field is viewed many times.
 					subscription.keys?.add(key);
-				} else {
-					const newSubscription = new NodeSubscription(invalidate, flexNode);
-					newSubscription.keys = new Set([key]);
-					subscriptions.set(flexNode, newSubscription);
 				}
 			},
 			observeParentOf(node: FlexTreeNode): void {
@@ -943,11 +951,12 @@ export const TreeAlpha: TreeAlpha = {
 
 				return getOrCreateNodeFromInnerUnboxedNode(childFlexTree);
 			}
-			case NodeKind.Map:
+			case NodeKind.Map: {
 				if (typeof propertyKey !== "string") {
 					// Map nodes only support string keys.
 					return undefined;
 				}
+			}
 			// Fall through
 			case NodeKind.Record:
 			case NodeKind.Object: {

package/src/shared-tree/treeCheckout.ts

@@ -11,7 +11,11 @@ import {
 	UsageError,
 	type ITelemetryLoggerExt,
 } from "@fluidframework/telemetry-utils/internal";
-import { FluidClientVersion, FormatValidatorNoOp } from "../codec/index.js";
+import {
+	FluidClientVersion,
+	FormatValidatorNoOp,
+	type CodecWriteOptions,
+} from "../codec/index.js";
 import {
 	type Anchor,
 	type AnchorLocator,
@@ -300,21 +304,23 @@ export function createTreeCheckout(
 		logger?: ITelemetryLoggerExt;
 		breaker?: Breakable;
 		disposeForksAfterTransaction?: boolean;
+		codecOptions?: Partial<CodecWriteOptions>;
 	},
 ): TreeCheckout {
 	const breaker = args?.breaker ?? new Breakable("TreeCheckout");
 	const schema = args?.schema ?? new TreeStoredSchemaRepository();
 	const forest = args?.forest ?? buildForest(breaker, schema);
-	const defaultCodecOptions = {
+	const defaultCodecOptions: CodecWriteOptions = {
 		jsonValidator: FormatValidatorNoOp,
 		minVersionForCollab: FluidClientVersion.v2_0,
 	};
+	const codecOptions: CodecWriteOptions = { ...defaultCodecOptions, ...args?.codecOptions };
 	const changeFamily =
 		args?.changeFamily ??
 		new SharedTreeChangeFamily(
 			revisionTagCodec,
-			args?.fieldBatchCodec ?? makeFieldBatchCodec(defaultCodecOptions),
-			defaultCodecOptions,
+			args?.fieldBatchCodec ?? makeFieldBatchCodec(codecOptions),
+			codecOptions,
 			args?.chunkCompressionStrategy,
 			idCompressor,
 		);
@@ -449,42 +455,32 @@ export class TreeCheckout implements ITreeCheckoutFork {
 	private createTransactionStack(
 		branch: SharedTreeBranch<SharedTreeEditBuilder, SharedTreeChange>,
 	): SquashingTransactionStack<SharedTreeEditBuilder, SharedTreeChange> {
-		return new SquashingTransactionStack(
-			branch,
-			(commits) => {
-				const revision = this.mintRevisionTag();
-				for (const transactionStep of commits) {
-					this._removedRoots.updateMajor(transactionStep.revision, revision);
-				}
-
-				const squashedChange = this.changeFamily.rebaser.compose(commits);
-				const change = this.changeFamily.rebaser.changeRevision(squashedChange, revision);
-				return tagChange(change, revision);
-			},
-			() => {
-				const disposeForks = this.disposeForksAfterTransaction
-					? trackForksForDisposal(this)
-					: undefined;
-				// When each transaction is started, make a restorable checkpoint of the current state of removed roots
-				const restoreRemovedRoots = this._removedRoots.createCheckpoint();
-				return (result) => {
-					switch (result) {
-						case TransactionResult.Abort:
-							restoreRemovedRoots();
-							break;
-						case TransactionResult.Commit:
-							if (!this.transaction.isInProgress()) {
-								// The changes in a transaction squash commit have already applied to the checkout and are known to be valid, so we can validate the squash commit automatically.
-								this.validateCommit(this.#transaction.branch.getHead());
-							}
-							break;
-						default:
-							unreachableCase(result);
+		return new SquashingTransactionStack(branch, this.mintRevisionTag, () => {
+			const disposeForks = this.disposeForksAfterTransaction
+				? trackForksForDisposal(this)
+				: undefined;
+			// When each transaction is started, make a restorable checkpoint of the current state of removed roots
+			const restoreRemovedRoots = this._removedRoots.createCheckpoint();
+			return (result) => {
+				switch (result) {
+					case TransactionResult.Abort: {
+						restoreRemovedRoots();
+						break;
 					}
-					disposeForks?.();
-				};
-			},
-		);
+					case TransactionResult.Commit: {
+						if (!this.transaction.isInProgress()) {
+							// The changes in a transaction squash commit have already applied to the checkout and are known to be valid, so we can validate the squash commit automatically.
+							this.validateCommit(this.#transaction.branch.getHead());
+						}
+						break;
+					}
+					default: {
+						unreachableCase(result);
+					}
+				}
+				disposeForks?.();
+			};
+		});
 	}
 
 	public exportVerbose(): VerboseTree | undefined {
@@ -822,6 +818,11 @@ export class TreeCheckout implements ITreeCheckoutFork {
 		this.checkNotDisposed(
 			"The parent branch has already been disposed and can no longer create new branches.",
 		);
+		// Branching after an unfinished transaction would expose the application to a state where its invariants may be violated.
+		if (this.transaction.isInProgress()) {
+			throw new UsageError("A view cannot be forked while it has a pending transaction.");
+		}
+
 		this.editLock.checkUnlocked("Branching");
 		const anchors = new AnchorSet();
 		const branch = this.#transaction.activeBranch.fork();
@@ -879,10 +880,16 @@ export class TreeCheckout implements ITreeCheckoutFork {
 			"The source of the branch rebase has been disposed and cannot be rebased.",
 		);
 		this.editLock.checkUnlocked("Rebasing");
-		assert(
-			!checkout.transaction.isInProgress(),
-			0x9af /* A view cannot be rebased while it has a pending transaction */,
-		);
+
+		if (this.transaction.isInProgress()) {
+			throw new UsageError(
+				"Views cannot be rebased onto a view that has a pending transaction.",
+			);
+		}
+		if (checkout.transaction.isInProgress()) {
+			throw new UsageError("A view cannot be rebased while it has a pending transaction.");
+		}
+
 		assert(
 			!checkout.isSharedBranch,
 			0xa5d /* Shared branches cannot be rebased onto another branch. */,
@@ -908,12 +915,15 @@ export class TreeCheckout implements ITreeCheckoutFork {
 			"The source of the branch merge has been disposed and cannot be merged.",
 		);
 		this.editLock.checkUnlocked("Merging");
-		assert(
-			!this.transaction.isInProgress(),
-			0x9b0 /* Views cannot be merged into a view while it has a pending transaction */,
-		);
-		while (checkout.transaction.isInProgress()) {
-			checkout.transaction.commit();
+		if (this.transaction.isInProgress()) {
+			throw new UsageError(
+				"Views cannot be merged into a view while it has a pending transaction.",
+			);
+		}
+		if (checkout.transaction.isInProgress()) {
+			throw new UsageError(
+				"Views with an open transaction cannot be merged into another view.",
+			);
 		}
 		this.#transaction.activeBranch.merge(checkout.#transaction.activeBranch);
 		if (disposeMerged && !checkout.isSharedBranch) {
@@ -962,7 +972,7 @@ export class TreeCheckout implements ITreeCheckoutFork {
 			const tree = jsonableTreeFromCursor(cursor);
 			// This method is used for tree consistency comparison.
 			const { major, minor } = id;
-			const finalizedMajor = major !== undefined ? this.revisionTagCodec.encode(major) : major;
+			const finalizedMajor = major === undefined ? major : this.revisionTagCodec.encode(major);
 			trees.push([finalizedMajor, minor, tree]);
 		}
 		cursor.free();
@@ -1186,6 +1196,12 @@ class EditLock {
 			addNodeExistsConstraintOnRevert(path) {
 				editor.addNodeExistsConstraintOnRevert(path);
 			},
+			addNoChangeConstraint() {
+				editor.addNoChangeConstraint();
+			},
+			addNoChangeConstraintOnRevert() {
+				editor.addNoChangeConstraintOnRevert();
+			},
 		};
 	}
 

package/src/shared-tree-core/branch.ts

@@ -117,6 +117,7 @@ export class SharedTreeBranch<TEditor extends ChangeFamilyEditor, TChange> {
 	 * Construct a new branch.
 	 * @param head - the head of the branch
 	 * @param changeFamily - determines the set of changes that this branch can commit
+	 * @param mintRevisionTag - used to generate a `RevisionTag` for each change.
 	 * @param branchTrimmer - an optional event emitter that informs the branch it has been trimmed. If this is not supplied, then the branch must
 	 * never be trimmed. See {@link BranchTrimmingEvents} for details on trimming.
 	 */
@@ -186,15 +187,19 @@ export class SharedTreeBranch<TEditor extends ChangeFamilyEditor, TChange> {
 	/**
 	 * Spawn a new branch that is based off of the current state of this branch.
 	 * @param commit - The commit to base the new branch off of. Defaults to the head of this branch.
+	 * @param mintRevisionTag - used to generate a `RevisionTag` for each change.
 	 * @remarks Changes made to the new branch will not be applied to this branch until the new branch is {@link SharedTreeBranch.merge | merged} back in.
 	 * Forks created during a transaction will be disposed when the transaction ends.
 	 */
-	public fork(commit: GraphCommit<TChange> = this.head): SharedTreeBranch<TEditor, TChange> {
+	public fork(
+		commit: GraphCommit<TChange> = this.head,
+		mintRevisionTag: () => RevisionTag = this.mintRevisionTag,
+	): SharedTreeBranch<TEditor, TChange> {
 		this.assertNotDisposed();
 		const fork = new SharedTreeBranch(
 			commit,
 			this.changeFamily,
-			this.mintRevisionTag,
+			mintRevisionTag,
 			this.branchTrimmer,
 		);
 		this.#events.emit("fork", fork);
@@ -226,7 +231,7 @@ export class SharedTreeBranch<TEditor extends ChangeFamilyEditor, TChange> {
 		const { deletedSourceCommits, targetCommits, sourceCommits } = commits;
 		assert(hasSome(targetCommits), 0xa83 /* Expected commit(s) for a non no-op rebase */);
 
-		const newCommits = targetCommits.concat(sourceCommits);
+		const newCommits = [...targetCommits, ...sourceCommits];
 		const changeEvent = {
 			type: "rebase",
 			get change() {

package/src/shared-tree-core/branchCommitEnricher.ts

@@ -5,12 +5,7 @@
 
 import { assert } from "@fluidframework/core-utils/internal";
 
-import {
-	type ChangeRebaser,
-	type GraphCommit,
-	replaceChange,
-	type RevisionTag,
-} from "../core/index.js";
+import { type ChangeRebaser, type GraphCommit, replaceChange } from "../core/index.js";
 
 import type { SharedTreeBranchChange } from "./branch.js";
 import type { ChangeEnricherReadonlyCheckout } from "./changeEnricher.js";
@@ -36,7 +31,7 @@ export class BranchCommitEnricher<TChange> {
 	 * Calling this function will compute the composition of that transaction's commits.
 	 * @remarks This function will be reset to undefined after each {@link BranchCommitEnricher.processChange | change is processed}.
 	 */
-	#getOuterTransactionChange?: (revision: RevisionTag) => TChange;
+	#getOuterTransactionChange?: () => TChange;
 
 	public constructor(
 		rebaser: ChangeRebaser<TChange>,
@@ -54,7 +49,7 @@ export class BranchCommitEnricher<TChange> {
 		if (change.type === "append") {
 			for (const newCommit of change.newCommits) {
 				const newChange =
-					this.#getOuterTransactionChange?.(newCommit.revision) ??
+					this.#getOuterTransactionChange?.() ??
 					this.#enricher.updateChangeEnrichments(newCommit.change, newCommit.revision);
 
 				this.#preparedCommits.set(newCommit, replaceChange(newCommit, newChange));

package/src/shared-tree-core/editManager.ts

@@ -466,7 +466,7 @@ export class EditManager<
 	}
 
 	public getSharedBranchIds(): BranchId[] {
-		return Array.from(this.sharedBranches.keys());
+		return [...this.sharedBranches.keys()];
 	}
 
 	public removeBranch(branchId: BranchId): void {

package/src/shared-tree-core/editManagerCodecs.ts

@@ -58,6 +58,7 @@ export function clientVersionToEditManagerFormatVersion(
 		getConfigForMinVersionForCollab(clientVersion, {
 			[lowestMinVersionForCollab]: EditManagerFormatVersion.v3,
 			[FluidClientVersion.v2_43]: EditManagerFormatVersion.v4,
+			[FluidClientVersion.v2_80]: EditManagerFormatVersion.v6,
 		}),
 	);
 
@@ -135,18 +136,21 @@ export function makeEditManagerCodecs<TChangeset>(
 	][] = Array.from(editManagerFormatVersions, (version) => {
 		switch (version) {
 			case unbrand(EditManagerFormatVersion.v1):
-			case unbrand(EditManagerFormatVersion.v2):
+			case unbrand(EditManagerFormatVersion.v2): {
 				return [version, makeDiscontinuedCodecVersion(options, version, "2.73.0")];
+			}
 			case unbrand(EditManagerFormatVersion.v3):
-			case unbrand(EditManagerFormatVersion.v4): {
+			case unbrand(EditManagerFormatVersion.v4):
+			case unbrand(EditManagerFormatVersion.v6): {
 				const changeCodec = changeCodecs.resolve(dependentChangeFormatVersion.lookup(version));
 				return [
 					version,
 					makeV1CodecWithVersion(changeCodec, revisionTagCodec, options, version),
 				];
 			}
-			case unbrand(EditManagerFormatVersion.v5):
+			case unbrand(EditManagerFormatVersion.v5): {
 				return [version, makeDiscontinuedCodecVersion(options, version, "2.74.0")];
+			}
 			case unbrand(EditManagerFormatVersion.vSharedBranches): {
 				const changeCodec = changeCodecs.resolve(dependentChangeFormatVersion.lookup(version));
 				return [
@@ -154,8 +158,9 @@ export function makeEditManagerCodecs<TChangeset>(
 					makeSharedBranchesCodecWithVersion(changeCodec, revisionTagCodec, options, version),
 				];
 			}
-			default:
+			default: {
 				unreachableCase(version);
+			}
 		}
 	});
 	return makeCodecFamily(registry);

package/src/shared-tree-core/editManagerFormatCommons.ts

@@ -156,6 +156,11 @@ export const EditManagerFormatVersion = strictEnum("editManager.FormatVersion",
 	 * @deprecated Use {@link EditManagerFormatVersion.vSharedBranches} for testing shared branches.
 	 */
 	v5: 5,
+	/**
+	 * Introduced and made available for writing in 2.80.0
+	 * Adds support for "no change" constraints.
+	 */
+	v6: 6,
 	/**
 	 * Not yet released.
 	 * Only used for testing shared branches.
@@ -167,6 +172,7 @@ export const supportedEditManagerFormatVersions: ReadonlySet<EditManagerFormatVe
 	new Set([
 		EditManagerFormatVersion.v3,
 		EditManagerFormatVersion.v4,
+		EditManagerFormatVersion.v6,
 		EditManagerFormatVersion.vSharedBranches,
 	]);
 export const editManagerFormatVersions: ReadonlySet<EditManagerFormatVersion> = new Set(

package/src/shared-tree-core/editManagerFormatV1toV4.ts

@@ -26,7 +26,8 @@ export interface EncodedEditManager<TChangeset> {
 		| typeof EditManagerFormatVersion.v1
 		| typeof EditManagerFormatVersion.v2
 		| typeof EditManagerFormatVersion.v3
-		| typeof EditManagerFormatVersion.v4;
+		| typeof EditManagerFormatVersion.v4
+		| typeof EditManagerFormatVersion.v6;
 }
 
 export const EncodedEditManager = <ChangeSchema extends TSchema>(tChange: ChangeSchema) =>
@@ -37,6 +38,7 @@ export const EncodedEditManager = <ChangeSchema extends TSchema>(tChange: Change
 				Type.Literal(EditManagerFormatVersion.v2),
 				Type.Literal(EditManagerFormatVersion.v3),
 				Type.Literal(EditManagerFormatVersion.v4),
+				Type.Literal(EditManagerFormatVersion.v6),
 			]),
 			trunk: Type.Array(SequencedCommit(tChange)),
 			branches: Type.Array(Type.Tuple([SessionIdSchema, SummarySessionBranch(tChange)])),

package/src/shared-tree-core/editManagerSummarizer.ts

@@ -104,9 +104,9 @@ export class EditManagerSummarizer<TChangeset>
 	}): void {
 		const { stringify, builder } = props;
 		const context: EditManagerEncodingContext =
-			this.schemaAndPolicy !== undefined
-				? { schema: this.schemaAndPolicy, idCompressor: this.idCompressor }
-				: { idCompressor: this.idCompressor };
+			this.schemaAndPolicy === undefined
+				? { idCompressor: this.idCompressor }
+				: { schema: this.schemaAndPolicy, idCompressor: this.idCompressor };
 		const jsonCompatible = this.codec.encode(this.editManager.getSummaryData(), context);
 		const dataString = stringify(jsonCompatible);
 		builder.addBlob(stringKey, dataString);

package/src/shared-tree-core/messageCodecV1ToV4.ts

@@ -33,7 +33,8 @@ export function makeV1ToV4CodecWithVersion<TChangeset>(
 		| typeof MessageFormatVersion.v1
 		| typeof MessageFormatVersion.v2
 		| typeof MessageFormatVersion.v3
-		| typeof MessageFormatVersion.v4,
+		| typeof MessageFormatVersion.v4
+		| typeof MessageFormatVersion.v6,
 ): IJsonCodec<
 	DecodedMessage<TChangeset>,
 	JsonCompatibleReadOnly,

package/src/shared-tree-core/messageCodecVSharedBranches.ts

@@ -79,8 +79,9 @@ export function makeSharedBranchesCodecWithVersion<TChangeset>(
 							version,
 						} satisfies Message & JsonCompatibleReadOnly;
 					}
-					default:
+					default: {
 						unreachableCase(type);
+					}
 				}
 			},
 			decode: (

package/src/shared-tree-core/messageCodecs.ts

@@ -55,6 +55,7 @@ export function clientVersionToMessageFormatVersion(
 		getConfigForMinVersionForCollab(clientVersion, {
 			[lowestMinVersionForCollab]: MessageFormatVersion.v3,
 			[FluidClientVersion.v2_43]: MessageFormatVersion.v4,
+			[FluidClientVersion.v2_80]: MessageFormatVersion.v6,
 		}),
 	);
 	return writeVersionOverride ?? compatibleVersion;
@@ -130,7 +131,7 @@ export function makeMessageCodecs<TChangeset>(
 			JsonCompatibleReadOnly,
 			MessageEncodingContext
 		>,
-	][] = Array.from(messageFormatVersions).map((version) => {
+	][] = [...messageFormatVersions].map((version) => {
 		switch (version) {
 			case unbrand(MessageFormatVersion.undefined):
 			case unbrand(MessageFormatVersion.v1):
@@ -143,7 +144,8 @@ export function makeMessageCodecs<TChangeset>(
 				];
 			}
 			case unbrand(MessageFormatVersion.v3):
-			case unbrand(MessageFormatVersion.v4): {
+			case unbrand(MessageFormatVersion.v4):
+			case unbrand(MessageFormatVersion.v6): {
 				const changeCodec = changeCodecs.resolve(
 					dependentChangeFormatVersion.lookup(version),
 				).json;
@@ -152,8 +154,9 @@ export function makeMessageCodecs<TChangeset>(
 					makeV1ToV4CodecWithVersion(changeCodec, revisionTagCodec, options, version),
 				];
 			}
-			case unbrand(MessageFormatVersion.v5):
+			case unbrand(MessageFormatVersion.v5): {
 				return [version, makeDiscontinuedCodecVersion(options, version, "2.74.0")];
+			}
 			case unbrand(MessageFormatVersion.vSharedBranches): {
 				const changeCodec = changeCodecs.resolve(
 					dependentChangeFormatVersion.lookup(version),
@@ -163,8 +166,9 @@ export function makeMessageCodecs<TChangeset>(
 					makeSharedBranchesCodecWithVersion(changeCodec, revisionTagCodec, options, version),
 				];
 			}
-			default:
+			default: {
 				unreachableCase(version);
+			}
 		}
 	});
 	return makeCodecFamily(registry);