@fluidframework/tree 2.63.0-358419 → 2.63.0-359286

package/src/shared-tree/sharedTree.ts

@@ -4,7 +4,7 @@
  */
 
 import type { ErasedType, IFluidLoadable } from "@fluidframework/core-interfaces/internal";
-import { assert, fail } from "@fluidframework/core-utils/internal";
+import { assert, fail, unreachableCase } from "@fluidframework/core-utils/internal";
 import type { IChannelStorageService } from "@fluidframework/datastore-definitions/internal";
 import type { IIdCompressor, StableId } from "@fluidframework/id-compressor";
 import type {
@@ -18,12 +18,15 @@ import {
 } from "@fluidframework/telemetry-utils/internal";
 
 import {
+	type CodecTree,
 	type CodecWriteOptions,
+	DependentFormatVersion,
 	FluidClientVersion,
 	FormatValidatorNoOp,
 	type ICodecOptions,
 } from "../codec/index.js";
 import {
+	type DetachedFieldIndexFormatVersion,
 	type FieldKey,
 	type GraphCommit,
 	type IEditableForest,
@@ -32,6 +35,7 @@ import {
 	MapNodeStoredSchema,
 	ObjectNodeStoredSchema,
 	RevisionTagCodec,
+	type SchemaFormatVersion,
 	SchemaVersion,
 	type TreeFieldStoredSchema,
 	type TreeNodeSchemaIdentifier,
@@ -39,6 +43,7 @@ import {
 	type TreeStoredSchema,
 	TreeStoredSchemaRepository,
 	type TreeStoredSchemaSubscription,
+	getCodecTreeForDetachedFieldIndexFormat,
 	makeDetachedFieldIndex,
 	moveToDetachedField,
 } from "../core/index.js";
@@ -51,11 +56,16 @@ import {
 	buildChunkedForest,
 	buildForest,
 	defaultSchemaPolicy,
+	getCodecTreeForFieldBatchFormat,
+	getCodecTreeForForestFormat,
+	getCodecTreeForSchemaFormat,
 	jsonableTreeFromFieldCursor,
 	makeFieldBatchCodec,
 	makeMitigatedChangeFamily,
 	makeSchemaCodec,
 	makeTreeChunker,
+	type FieldBatchFormatVersion,
+	type ForestFormatVersion,
 	type TreeCompressionStrategyPrivate,
 } from "../feature-libraries/index.js";
 // eslint-disable-next-line import/no-internal-modules
@@ -63,7 +73,11 @@ import type { FormatV1 } from "../feature-libraries/schema-index/index.js";
 import {
 	type BranchId,
 	type ClonableSchemaAndPolicy,
+	type EditManagerFormatVersion,
 	type ExplicitCoreCodecVersions,
+	getCodecTreeForEditManagerFormatWithChange,
+	getCodecTreeForMessageFormatWithChange,
+	type MessageFormatVersion,
 	SharedTreeCore,
 } from "../shared-tree-core/index.js";
 import {
@@ -92,11 +106,16 @@ import type { SharedTreeChange } from "./sharedTreeChangeTypes.js";
 import type { SharedTreeEditBuilder } from "./sharedTreeEditBuilder.js";
 import { type TreeCheckout, type BranchableTree, createTreeCheckout } from "./treeCheckout.js";
 import {
+	brand,
 	type Breakable,
 	breakingClass,
 	type JsonCompatible,
 	throwIfBroken,
 } from "../util/index.js";
+import {
+	getCodecTreeForChangeFormat,
+	type SharedTreeChangeFormatVersion,
+} from "./sharedTreeChangeCodecs.js";
 
 /**
  * Copy of data from an {@link ITreePrivate} at some point in time.
@@ -161,36 +180,78 @@ export interface ITreePrivate extends ITreeInternal {
  * TODO: Plumb these write versions into forest, schema, detached field index codec creation.
  */
 interface ExplicitCodecVersions extends ExplicitCoreCodecVersions {
-	forest: number;
-	schema: SchemaVersion;
-	detachedFieldIndex: number;
-	fieldBatch: number;
+	forest: ForestFormatVersion;
+	schema: SchemaFormatVersion;
+	detachedFieldIndex: DetachedFieldIndexFormatVersion;
+	fieldBatch: FieldBatchFormatVersion;
 }
 
 const formatVersionToTopLevelCodecVersions = new Map<number, ExplicitCodecVersions>([
 	[
 		1,
-		{ forest: 1, schema: 1, detachedFieldIndex: 1, editManager: 1, message: 1, fieldBatch: 1 },
+		{
+			forest: brand(1),
+			schema: brand(1),
+			detachedFieldIndex: brand(1),
+			editManager: brand(1),
+			message: brand(1),
+			fieldBatch: brand(1),
+		},
 	],
 	[
 		2,
-		{ forest: 1, schema: 1, detachedFieldIndex: 1, editManager: 2, message: 2, fieldBatch: 1 },
+		{
+			forest: brand(1),
+			schema: brand(1),
+			detachedFieldIndex: brand(1),
+			editManager: brand(2),
+			message: brand(2),
+			fieldBatch: brand(1),
+		},
 	],
 	[
 		3,
-		{ forest: 1, schema: 1, detachedFieldIndex: 1, editManager: 3, message: 3, fieldBatch: 1 },
+		{
+			forest: brand(1),
+			schema: brand(1),
+			detachedFieldIndex: brand(1),
+			editManager: brand(3),
+			message: brand(3),
+			fieldBatch: brand(1),
+		},
 	],
 	[
 		4,
-		{ forest: 1, schema: 1, detachedFieldIndex: 1, editManager: 4, message: 4, fieldBatch: 1 },
+		{
+			forest: brand(1),
+			schema: brand(1),
+			detachedFieldIndex: brand(1),
+			editManager: brand(4),
+			message: brand(4),
+			fieldBatch: brand(1),
+		},
 	],
 	[
 		5,
-		{ forest: 1, schema: 2, detachedFieldIndex: 1, editManager: 4, message: 4, fieldBatch: 1 },
+		{
+			forest: brand(1),
+			schema: brand(2),
+			detachedFieldIndex: brand(1),
+			editManager: brand(4),
+			message: brand(4),
+			fieldBatch: brand(1),
+		},
 	],
 	[
 		100, // SharedTreeFormatVersion.vSharedBranches
-		{ forest: 1, schema: 2, detachedFieldIndex: 1, editManager: 5, message: 5, fieldBatch: 1 },
+		{
+			forest: brand(1),
+			schema: brand(2),
+			detachedFieldIndex: brand(1),
+			editManager: brand(5),
+			message: brand(5),
+			fieldBatch: brand(1),
+		},
 	],
 ]);
 
@@ -321,6 +382,8 @@ export class SharedTreeKernel
 			changeFamily,
 			options,
 			codecVersions,
+			changeFormatVersionForEditManager,
+			changeFormatVersionForMessage,
 			idCompressor,
 			schema,
 			defaultSchemaPolicy,
@@ -635,6 +698,83 @@ export const SharedTreeFormatVersion = {
  */
 export type SharedTreeFormatVersion = typeof SharedTreeFormatVersion;
 
+/**
+ * Defines for each EditManagerFormatVersion the SharedTreeChangeFormatVersion to use.
+ * This is an arbitrary mapping that is injected in the EditManger codec.
+ * Once an entry is defined and used in production, it cannot be changed.
+ * This is because the format for SharedTree changes are not explicitly versioned.
+ */
+export const changeFormatVersionForEditManager = DependentFormatVersion.fromPairs([
+	[brand<EditManagerFormatVersion>(1), brand<SharedTreeChangeFormatVersion>(1)],
+	[brand<EditManagerFormatVersion>(2), brand<SharedTreeChangeFormatVersion>(2)],
+	[brand<EditManagerFormatVersion>(3), brand<SharedTreeChangeFormatVersion>(3)],
+	[brand<EditManagerFormatVersion>(4), brand<SharedTreeChangeFormatVersion>(4)],
+	[brand<EditManagerFormatVersion>(5), brand<SharedTreeChangeFormatVersion>(4)],
+]);
+
+/**
+ * Defines for each MessageFormatVersion the SharedTreeChangeFormatVersion to use.
+ * This is an arbitrary mapping that is injected in the message codec.
+ * Once an entry is defined and used in production, it cannot be changed.
+ * This is because the format for SharedTree changes are not explicitly versioned.
+ */
+export const changeFormatVersionForMessage = DependentFormatVersion.fromPairs([
+	[brand<MessageFormatVersion>(undefined), brand<SharedTreeChangeFormatVersion>(1)],
+	[brand<MessageFormatVersion>(1), brand<SharedTreeChangeFormatVersion>(1)],
+	[brand<MessageFormatVersion>(2), brand<SharedTreeChangeFormatVersion>(2)],
+	[brand<MessageFormatVersion>(3), brand<SharedTreeChangeFormatVersion>(3)],
+	[brand<MessageFormatVersion>(4), brand<SharedTreeChangeFormatVersion>(4)],
+	[brand<MessageFormatVersion>(5), brand<SharedTreeChangeFormatVersion>(4)],
+]);
+
+function getCodecTreeForEditManagerFormat(version: EditManagerFormatVersion): CodecTree {
+	const change = changeFormatVersionForEditManager.lookup(version);
+	const changeCodecTree = getCodecTreeForChangeFormat(change);
+	return getCodecTreeForEditManagerFormatWithChange(version, changeCodecTree);
+}
+
+function getCodecTreeForMessageFormat(version: MessageFormatVersion): CodecTree {
+	const change = changeFormatVersionForMessage.lookup(version);
+	const changeCodecTree = getCodecTreeForChangeFormat(change);
+	return getCodecTreeForMessageFormatWithChange(version, changeCodecTree);
+}
+
+export function getCodecTreeForSharedTreeFormat(
+	version: SharedTreeFormatVersion[keyof SharedTreeFormatVersion],
+): CodecTree {
+	const children: CodecTree[] = [];
+	const childCodecs = getCodecVersions(version);
+	for (const name of Object.keys(childCodecs) as (keyof ExplicitCodecVersions)[]) {
+		switch (name) {
+			case "editManager":
+				children.push(getCodecTreeForEditManagerFormat(childCodecs.editManager));
+				break;
+			case "message":
+				children.push(getCodecTreeForMessageFormat(childCodecs.message));
+				break;
+			case "forest":
+				children.push(getCodecTreeForForestFormat(childCodecs.forest));
+				break;
+			case "schema":
+				children.push(getCodecTreeForSchemaFormat(childCodecs.schema));
+				break;
+			case "detachedFieldIndex":
+				children.push(getCodecTreeForDetachedFieldIndexFormat(childCodecs.detachedFieldIndex));
+				break;
+			case "fieldBatch":
+				children.push(getCodecTreeForFieldBatchFormat(childCodecs.fieldBatch));
+				break;
+			default:
+				unreachableCase(name);
+		}
+	}
+	return {
+		name: "SharedTree",
+		version,
+		children,
+	};
+}
+
 /**
  * Configuration options for SharedTree.
  * @beta @input

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++;
 		}
 	}