@fluidframework/tree 2.62.0 → 2.63.0-359286

package/src/shared-tree/sharedTreeChangeCodecs.ts

@@ -3,8 +3,11 @@
  * Licensed under the MIT License.
  */
 
+import { fail } from "@fluidframework/core-utils/internal";
 import {
+	type CodecTree,
 	DiscriminatedUnionDispatcher,
+	type FormatVersion,
 	type ICodecFamily,
 	type ICodecOptions,
 	type IJsonCodec,
@@ -13,12 +16,21 @@ import {
 } from "../codec/index.js";
 import type { ChangeEncodingContext, TreeStoredSchema } from "../core/index.js";
 import {
+	type ModularChangeFormatVersion,
 	type ModularChangeset,
 	type SchemaChange,
+	type SchemaChangeFormatVersion,
 	defaultSchemaPolicy,
+	getCodecTreeForModularChangeFormat,
+	getCodecTreeForSchemaChangeFormat,
 	makeSchemaChangeCodecs,
 } from "../feature-libraries/index.js";
-import type { JsonCompatibleReadOnly, Mutable } from "../util/index.js";
+import {
+	brand,
+	type Brand,
+	type JsonCompatibleReadOnly,
+	type Mutable,
+} from "../util/index.js";
 
 import {
 	EncodedSharedTreeChange,
@@ -31,40 +43,66 @@ export function makeSharedTreeChangeCodecFamily(
 	options: ICodecOptions,
 ): ICodecFamily<SharedTreeChange, ChangeEncodingContext> {
 	const schemaChangeCodecs = makeSchemaChangeCodecs(options);
-	return makeCodecFamily([
-		[
-			1,
-			makeSharedTreeChangeCodec(
-				modularChangeCodecFamily.resolve(1).json,
-				schemaChangeCodecs.resolve(1).json,
-				options,
-			),
-		],
-		[
-			2,
+	const versions: [
+		FormatVersion,
+		IJsonCodec<
+			SharedTreeChange,
+			EncodedSharedTreeChange,
+			EncodedSharedTreeChange,
+			ChangeEncodingContext
+		>,
+	][] = Array.from(dependenciesForChangeFormat.entries()).map(
+		([format, { modularChange, schemaChange }]) => [
+			format,
 			makeSharedTreeChangeCodec(
-				modularChangeCodecFamily.resolve(2).json,
-				schemaChangeCodecs.resolve(1).json,
+				modularChangeCodecFamily.resolve(modularChange).json,
+				schemaChangeCodecs.resolve(schemaChange).json,
 				options,
 			),
 		],
-		[
-			3,
-			makeSharedTreeChangeCodec(
-				modularChangeCodecFamily.resolve(3).json,
-				schemaChangeCodecs.resolve(1).json,
-				options,
-			),
-		],
-		[
-			4,
-			makeSharedTreeChangeCodec(
-				modularChangeCodecFamily.resolve(4).json,
-				schemaChangeCodecs.resolve(1).json,
-				options,
-			),
+	);
+	return makeCodecFamily(versions);
+}
+
+interface ChangeFormatDependencies {
+	readonly modularChange: ModularChangeFormatVersion;
+	readonly schemaChange: SchemaChangeFormatVersion;
+}
+
+export type SharedTreeChangeFormatVersion = Brand<
+	1 | 2 | 3 | 4,
+	"SharedTreeChangeFormatVersion"
+>;
+
+/**
+ * Defines for each SharedTree change format the corresponding dependent formats to use.
+ * This is an arbitrary mapping that is injected in the SharedTree change codec.
+ * Once an entry is defined and used in production, it cannot be changed.
+ * This is because the format for the dependent formats are not explicitly versioned.
+ */
+export const dependenciesForChangeFormat: Map<
+	SharedTreeChangeFormatVersion,
+	ChangeFormatDependencies
+> = new Map([
+	[brand(1), { modularChange: brand(1), schemaChange: brand(1) }],
+	[brand(2), { modularChange: brand(2), schemaChange: brand(1) }],
+	[brand(3), { modularChange: brand(3), schemaChange: brand(1) }],
+	[brand(4), { modularChange: brand(4), schemaChange: brand(1) }],
+]);
+
+export function getCodecTreeForChangeFormat(
+	version: SharedTreeChangeFormatVersion,
+): CodecTree {
+	const { modularChange, schemaChange } =
+		dependenciesForChangeFormat.get(version) ?? fail("Unknown change format");
+	return {
+		name: "SharedTreeChange",
+		version,
+		children: [
+			getCodecTreeForModularChangeFormat(modularChange),
+			getCodecTreeForSchemaChangeFormat(schemaChange),
 		],
-	]);
+	};
 }
 
 function makeSharedTreeChangeCodec(

package/src/shared-tree/treeCheckout.ts

@@ -1024,7 +1024,7 @@ export class TreeCheckout implements ITreeCheckoutFork {
 	// #region Commit Validation
 
 	/** Used to maintain the contract of {@link onCommitValid}(). */
-	#validatedCommits = new WeakMap<
+	readonly #validatedCommits = new WeakMap<
 		GraphCommit<SharedTreeChange>,
 		((commit: GraphCommit<SharedTreeChange>) => void)[] | true
 	>();

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

@@ -3,16 +3,10 @@
  * Licensed under the MIT License.
  */
 
-import {
-	assert,
-	DoublyLinkedList,
-	oob,
-	type ListNode,
-	type ListNodeRange,
-} from "@fluidframework/core-utils/internal";
+import { assert, fail, oob } from "@fluidframework/core-utils/internal";
 
-import type { GraphCommit, TaggedChange } from "../core/index.js";
-import { disposeSymbol, hasSome } from "../util/index.js";
+import type { GraphCommit, RevisionTag, TaggedChange } from "../core/index.js";
+import { disposeSymbol } from "../util/index.js";
 
 import type { ChangeEnricherReadonlyCheckout } from "./changeEnricher.js";
 import type { ResubmitMachine } from "./resubmitMachine.js";
@@ -21,23 +15,15 @@ interface PendingChange<TChange> {
 	commit: GraphCommit<TChange>;
 	lastEnrichment: number;
 }
-type PendingChangeNode<TChange> = ListNode<PendingChange<TChange>>;
 
 /**
  * Default implementation of {@link ResubmitMachine}.
  */
 export class DefaultResubmitMachine<TChange> implements ResubmitMachine<TChange> {
 	/**
-	 * The list of commits (from oldest to most recent) that have been submitted but not sequenced.
+	 * Maps from revision of submitted commit to the pending change for that commit.
 	 */
-	private readonly inFlightQueue: DoublyLinkedList<PendingChange<TChange>> =
-		new DoublyLinkedList();
-
-	/**
-	 * The range of in-flight commits that are currently being resubmitted.
-	 * Defined only during the resubmit phase.
-	 */
-	private pendingResubmitRange: ListNodeRange<PendingChange<TChange>> | undefined;
+	private readonly pendingChanges: Map<RevisionTag, PendingChange<TChange>> = new Map();
 
 	/**
 	 * The current enrichment version for in-flight commits.
@@ -58,130 +44,101 @@ export class DefaultResubmitMachine<TChange> implements ResubmitMachine<TChange>
 	) {}
 
 	public onCommitSubmitted(commit: GraphCommit<TChange>): void {
-		if (this.pendingResubmitRange !== undefined) {
-			const toResubmit = this.pendingResubmitRange?.first;
-			assert(
-				toResubmit?.data.commit === commit,
-				0x981 /* Unexpected commit submitted during resubmit phase */,
-			);
-			// If we are not at the last commit to resubmit, advance the range to the next node.
-			// Otherwise, clear the resubmit range as we are done resubmitting.
-			if (toResubmit !== this.pendingResubmitRange.last) {
-				assert(toResubmit.next !== undefined, 0xbd6 /* must be more in the list */);
-				this.pendingResubmitRange.first = toResubmit.next;
-			} else {
-				this.pendingResubmitRange = undefined;
-			}
-			toResubmit.remove();
-		}
-		this.inFlightQueue.push({ commit, lastEnrichment: this.currentEnrichment });
+		this.pendingChanges.set(commit.revision, {
+			commit,
+			lastEnrichment: this.currentEnrichment,
+		});
 	}
 
 	public onCommitRollback(commit: GraphCommit<TChange>): void {
-		assert(
-			commit.revision === this.inFlightQueue.last?.data.commit.revision,
-			0xbd7 /* must rollback latest commit in the in flight queue */,
-		);
-		this.inFlightQueue.pop();
+		this.pendingChanges.delete(commit.revision);
 	}
 
-	public prepareForResubmit(toResubmit: readonly GraphCommit<TChange>[]): void {
-		assert(
-			!this.isInResubmitPhase,
-			0x957 /* Invalid resubmit phase start during incomplete resubmit phase */,
-		);
-
-		if (!hasSome(toResubmit)) {
+	private updateEnrichments(
+		revision: RevisionTag,
+		getLocalCommits: () => readonly GraphCommit<TChange>[],
+	): void {
+		const pendingChange = this.pendingChanges.get(revision);
+		if (
+			pendingChange === undefined ||
+			pendingChange.lastEnrichment === this.currentEnrichment
+		) {
+			// The first commit to resubmit has a valid enrichment, so all pending commits must be valid.
 			return;
 		}
 
+		const localCommits = getLocalCommits();
 		assert(
-			toResubmit.length <= this.inFlightQueue.length,
-			0xbd8 /* Unexpected resubmit of more commits than are in flight */,
+			localCommits[0]?.revision === revision,
+			"Expected local commits to start with specified revision",
 		);
 
-		// Find the first in-flight commit to resubmit.
-		const first = this.inFlightQueue.find(
-			(v) => v.data.commit.revision === toResubmit[0].revision,
-		);
-		// Always resubmit to the end of all outstanding ops, but the list may grow during resubmit,
-		// so we must track the current end at the start of the phase.
-		const last = this.inFlightQueue.last;
-		assert(
-			first !== undefined && last !== undefined,
-			0xbd9 /* there must be inflight commits to resubmit */,
-		);
+		// Some in-flight commits have stale enrichments, so we recompute them.
+		const checkout = this.tip.fork();
+
+		// Roll back the checkout to the state before the oldest commit
+		for (let iCommit = localCommits.length - 1; iCommit >= 0; iCommit -= 1) {
+			const commit = localCommits[iCommit] ?? oob();
+			const rollback = this.makeRollback(commit);
+			// WARNING: it's not currently possible to roll back past a schema change (see AB#7265).
+			// Either we have to make it possible to do so, or this logic will have to change to work
+			// forwards from an earlier fork instead of backwards.
+			checkout.applyTipChange(rollback);
+		}
 
-		this.pendingResubmitRange = { first, last };
-		// If any in-flight commits have stale enrichments, recompute them.
-		if (first.data.lastEnrichment < this.currentEnrichment) {
-			const checkout = this.tip.fork();
-
-			// Roll back the checkout to the state before the oldest commit
-			for (let iCommit = toResubmit.length - 1; iCommit >= 0; iCommit -= 1) {
-				const commit = toResubmit[iCommit] ?? oob();
-				const rollback = this.makeRollback(commit);
-				// WARNING: it's not currently possible to roll back past a schema change (see AB#7265).
-				// Either we have to make it possible to do so, or this logic will have to change to work
-				// forwards from an earlier fork instead of backwards.
-				checkout.applyTipChange(rollback);
-			}
+		// Update the enrichments of the stale commits.
+		for (const [iCommit, commit] of localCommits.entries()) {
+			const current = this.getPendingChange(commit.revision);
+			assert(
+				current !== undefined,
+				0xbda /* there must be an inflight commit for each resubmit commit */,
+			);
 
-			// Update the enrichments of the stale commits in the in-flight queue.
-			let current: PendingChangeNode<TChange> | undefined = first;
-			for (const commit of toResubmit) {
-				assert(
-					current !== undefined,
-					0xbda /* there must be an inflight commit for each resubmit commit */,
+			if (current.lastEnrichment < this.currentEnrichment) {
+				const enrichedChange = checkout.updateChangeEnrichments(
+					commit.change,
+					commit.revision,
 				);
-				current.data.commit = commit;
-				if (current.data.lastEnrichment < this.currentEnrichment) {
-					const enrichedChange = checkout.updateChangeEnrichments(
-						commit.change,
-						commit.revision,
-					);
-					const enrichedCommit = { ...commit, change: enrichedChange };
-
-					// Optimization: only apply the enriched change if the next commit also needs enrichment.
-					if (
-						current.next !== undefined &&
-						current.next.data.lastEnrichment < this.currentEnrichment
-					) {
-						checkout.applyTipChange(enrichedChange, commit.revision);
-					}
-
-					current.data.commit = enrichedCommit;
-					current.data.lastEnrichment = this.currentEnrichment;
+				const enrichedCommit = { ...commit, change: enrichedChange };
+
+				// Optimization: only apply the enriched change if the next commit also needs enrichment.
+				const nextCommit = localCommits[iCommit + 1];
+				if (
+					nextCommit !== undefined &&
+					this.getPendingChange(nextCommit.revision).lastEnrichment < this.currentEnrichment
+				) {
+					checkout.applyTipChange(enrichedChange, commit.revision);
 				}
-				current = current.next;
+
+				current.commit = enrichedCommit;
+				current.lastEnrichment = this.currentEnrichment;
 			}
-			checkout[disposeSymbol]();
 		}
+		checkout[disposeSymbol]();
 	}
 
-	public peekNextCommit(): GraphCommit<TChange> {
-		assert(
-			this.isInResubmitPhase,
-			0x982 /* No available commit to resubmit outside of resubmit phase */,
-		);
-		assert(
-			this.pendingResubmitRange !== undefined,
-			0xa87 /* Expected resubmit queue to be non-empty */,
-		);
-		return this.pendingResubmitRange.first.data.commit;
+	public getEnrichedCommit(
+		revision: RevisionTag,
+		getLocalCommitsSince: () => readonly GraphCommit<TChange>[],
+	): GraphCommit<TChange> | undefined {
+		this.updateEnrichments(revision, getLocalCommitsSince);
+		const pendingChange = this.pendingChanges.get(revision);
+		return pendingChange?.commit;
 	}
 
-	public get isInResubmitPhase(): boolean {
-		return this.pendingResubmitRange !== undefined;
+	private getPendingChange(revision: RevisionTag): PendingChange<TChange> {
+		return (
+			this.pendingChanges.get(revision) ?? fail("No pending change stored for this revision")
+		);
 	}
 
-	public onSequencedCommitApplied(isLocal: boolean): void {
-		if (isLocal) {
-			// The oldest in-flight commit has been sequenced
-			assert(this.inFlightQueue.length > 0, 0x959 /* Sequencing of unknown local commit */);
-			this.inFlightQueue.shift();
-		} else {
-			// A peer commit has been sequenced
+	public onSequencedCommitApplied(revision: RevisionTag, isLocal: boolean): void {
+		// We no longer need to track enrichment for the commit with this revision.
+		// Note that we may have a commit for this revision even if this is not a local change,
+		// as this client and another peer may have merged the same commit from a shared branch.
+		this.pendingChanges.delete(revision);
+		if (!isLocal) {
+			// A peer commit has been sequenced, invalidating the enrichment of our in-flight commits.
 			this.currentEnrichment++;
 		}
 	}

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

@@ -750,8 +750,8 @@ class SharedBranch<TEditor extends ChangeFamilyEditor, TChangeset> {
 		// Local changes, i.e., changes from this client are applied by fast forwarding the local branch commit onto
 		// the trunk.
 		if (areLocalCommits) {
-			for (const _ of newCommits) {
-				this.sequenceLocalCommit(nextSequenceId, sessionId, onSequenceLocalCommit);
+			for (const { revision } of newCommits) {
+				this.sequenceLocalCommit(revision, nextSequenceId, sessionId, onSequenceLocalCommit);
 				nextSequenceId = getNextSequenceId(nextSequenceId);
 			}
 			return;
@@ -900,10 +900,17 @@ class SharedBranch<TEditor extends ChangeFamilyEditor, TChangeset> {
 	 * Avoiding the overhead of the rebase process, even when it's a no-op, has real measured performance benefits and is worth the added complexity here.
 	 */
 	private sequenceLocalCommit(
+		revision: RevisionTag,
 		sequenceId: SequenceId,
 		sessionId: SessionId,
 		onSequenceLocalCommit: OnSequenceCommit<TChangeset>,
-	): GraphCommit<TChangeset> {
+	): void {
+		if (this.commitMetadata.has(revision)) {
+			// This can happen if the commit came from a shared branch and was concurrently merged by another client.
+			// In this case, the newly sequenced commit is redundant and should therefore be ignored.
+			return;
+		}
+
 		// First, push the local commit to the trunk.
 		// We are mutating our `localCommits` cache here,but there is no need to actually change the `localBranch` itself because it will simply catch up later if/when it next rebases.
 		const firstLocalCommit = this.localCommits.shift();
@@ -915,7 +922,6 @@ class SharedBranch<TEditor extends ChangeFamilyEditor, TChangeset> {
 		const prevSequenceId = this.getCommitSequenceId(this.trunk.getHead().revision);
 		this.pushGraphCommitToTrunk(sequenceId, firstLocalCommit, sessionId);
 		onSequenceLocalCommit(firstLocalCommit, sequenceId, prevSequenceId);
-		return firstLocalCommit;
 	}
 
 	/**

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

@@ -4,8 +4,12 @@
  */
 
 import type { IIdCompressor } from "@fluidframework/id-compressor";
+import { unreachableCase } from "@fluidframework/core-utils/internal";
 
 import {
+	type CodecTree,
+	type DependentFormatVersion,
+	type FormatVersion,
 	type ICodecFamily,
 	type ICodecOptions,
 	type IJsonCodec,
@@ -18,7 +22,7 @@ import type {
 	RevisionTag,
 	SchemaAndPolicy,
 } from "../core/index.js";
-import type { JsonCompatibleReadOnly } from "../util/index.js";
+import { brand, type Brand, type JsonCompatibleReadOnly } from "../util/index.js";
 
 import type { SummaryData } from "./editManager.js";
 import { makeV1CodecWithVersion } from "./editManagerCodecsV1toV4.js";
@@ -31,6 +35,7 @@ export interface EditManagerEncodingContext {
 
 export function makeEditManagerCodec<TChangeset>(
 	changeCodecs: ICodecFamily<TChangeset, ChangeEncodingContext>,
+	dependentChangeFormatVersion: DependentFormatVersion<EditManagerFormatVersion>,
 	revisionTagCodec: IJsonCodec<
 		RevisionTag,
 		EncodedRevisionTag,
@@ -45,12 +50,18 @@ export function makeEditManagerCodec<TChangeset>(
 	JsonCompatibleReadOnly,
 	EditManagerEncodingContext
 > {
-	const family = makeEditManagerCodecs(changeCodecs, revisionTagCodec, options);
+	const family = makeEditManagerCodecs(
+		changeCodecs,
+		dependentChangeFormatVersion,
+		revisionTagCodec,
+		options,
+	);
 	return makeVersionDispatchingCodec(family, { ...options, writeVersion });
 }
 
 export function makeEditManagerCodecs<TChangeset>(
 	changeCodecs: ICodecFamily<TChangeset, ChangeEncodingContext>,
+	dependentChangeFormatVersion: DependentFormatVersion<EditManagerFormatVersion>,
 	revisionTagCodec: IJsonCodec<
 		RevisionTag,
 		EncodedRevisionTag,
@@ -59,11 +70,53 @@ export function makeEditManagerCodecs<TChangeset>(
 	>,
 	options: ICodecOptions,
 ): ICodecFamily<SummaryData<TChangeset>, EditManagerEncodingContext> {
-	return makeCodecFamily([
-		[1, makeV1CodecWithVersion(changeCodecs.resolve(1), revisionTagCodec, options, 1)],
-		[2, makeV1CodecWithVersion(changeCodecs.resolve(2), revisionTagCodec, options, 2)],
-		[3, makeV1CodecWithVersion(changeCodecs.resolve(3), revisionTagCodec, options, 3)],
-		[4, makeV1CodecWithVersion(changeCodecs.resolve(4), revisionTagCodec, options, 4)],
-		[5, makeV5CodecWithVersion(changeCodecs.resolve(4), revisionTagCodec, options, 5)],
-	]);
+	const registry: [
+		FormatVersion,
+		IJsonCodec<
+			SummaryData<TChangeset>,
+			JsonCompatibleReadOnly,
+			JsonCompatibleReadOnly,
+			EditManagerEncodingContext
+		>,
+	][] = Array.from(editManagerFormatVersions, (version) => {
+		const changeCodec = changeCodecs.resolve(dependentChangeFormatVersion.lookup(version));
+		switch (version) {
+			case 1:
+			case 2:
+			case 3:
+			case 4:
+				return [
+					version,
+					makeV1CodecWithVersion(changeCodec, revisionTagCodec, options, version),
+				];
+			case 5:
+				return [
+					version,
+					makeV5CodecWithVersion(changeCodec, revisionTagCodec, options, version),
+				];
+			default:
+				unreachableCase(version);
+		}
+	});
+	return makeCodecFamily(registry);
+}
+
+export type EditManagerFormatVersion = Brand<1 | 2 | 3 | 4 | 5, "EditManagerFormatVersion">;
+export const editManagerFormatVersions: ReadonlySet<EditManagerFormatVersion> = new Set([
+	brand(1),
+	brand(2),
+	brand(3),
+	brand(4),
+	brand(5),
+]);
+
+export function getCodecTreeForEditManagerFormatWithChange(
+	version: EditManagerFormatVersion,
+	changeFormat: CodecTree,
+): CodecTree {
+	return {
+		name: "EditManager",
+		version,
+		children: [changeFormat],
+	};
 }

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

@@ -39,7 +39,12 @@ export {
 	NoOpChangeEnricher,
 } from "./changeEnricher.js";
 
-export { makeEditManagerCodec } from "./editManagerCodecs.js";
+export {
+	makeEditManagerCodec,
+	getCodecTreeForEditManagerFormatWithChange,
+	type EditManagerFormatVersion,
+	editManagerFormatVersions,
+} from "./editManagerCodecs.js";
 export { EditManagerSummarizer } from "./editManagerSummarizer.js";
 export {
 	EditManager,
@@ -54,3 +59,9 @@ export type {
 	SummarySessionBranch,
 	EncodedCommit,
 } from "./editManagerFormatCommons.js";
+
+export {
+	type MessageFormatVersion,
+	messageFormatVersions,
+	getCodecTreeForMessageFormatWithChange,
+} from "./messageCodecs.js";