@fluidframework/tree 2.50.0-345060 → 2.51.0-347100

package/src/shared-tree/schematizingTreeView.ts

@@ -16,10 +16,9 @@ import { anchorSlot, type SchemaPolicy } from "../core/index.js";
 import {
 	type NodeIdentifierManager,
 	defaultSchemaPolicy,
-	ContextSlot,
 	cursorForMapTreeNode,
-	type FullSchemaPolicy,
 	TreeStatus,
+	Context,
 } from "../feature-libraries/index.js";
 import {
 	type ImplicitFieldSchema,
@@ -53,6 +52,7 @@ import {
 	createUnknownOptionalFieldPolicy,
 	prepareForInsertionContextless,
 	type FieldSchema,
+	tryDisposeTreeNode,
 } from "../simple-tree/index.js";
 import {
 	type Breakable,
@@ -61,7 +61,6 @@ import {
 	type WithBreakable,
 } from "../util/index.js";
 
-import { CheckoutFlexTreeView } from "./checkoutFlexTreeView.js";
 import { canInitialize, ensureSchema, initialize } from "./schematizeTree.js";
 import type { ITreeCheckout, TreeCheckout } from "./treeCheckout.js";
 
@@ -80,11 +79,11 @@ export class SchematizingSimpleTreeView<
 > implements TreeBranch, TreeViewAlpha<TRootSchema>, WithBreakable
 {
 	/**
-	 * The view is set to undefined when this object is disposed or the view schema does not support viewing the document's stored schema.
+	 * This is set to undefined when this object is disposed or the view schema does not support viewing the document's stored schema.
 	 *
 	 * The view schema may be incompatible with the stored schema. Use `compatibility` to check.
 	 */
-	private view: CheckoutFlexTreeView | undefined;
+	private flexTreeContext: Context | undefined;
 
 	/**
 	 * Undefined iff uninitialized or disposed.
@@ -97,6 +96,11 @@ export class SchematizingSimpleTreeView<
 
 	private readonly viewSchema: SchemaCompatibilityTester;
 
+	/**
+	 * Events to unregister upon flex-tree view disposal.
+	 */
+	private readonly flexTreeViewUnregisterCallbacks = new Set<() => void>();
+
 	/**
 	 * Events to unregister upon disposal.
 	 */
@@ -203,7 +207,7 @@ export class SchematizingSimpleTreeView<
 
 		if (!compatibility.canUpgrade) {
 			throw new UsageError(
-				"Existing stored schema can not be upgraded (see TreeView.compatibility.canUpgrade).",
+				"Existing stored schema cannot be upgraded (see TreeView.compatibility.canUpgrade).",
 			);
 		}
 
@@ -214,12 +218,12 @@ export class SchematizingSimpleTreeView<
 	}
 
 	/**
-	 * Gets the view. Throws when disposed.
+	 * Gets the flex-tree context. Throws when disposed or out of schema.
 	 */
-	public getView(): CheckoutFlexTreeView {
+	public getFlexTreeContext(): Context {
 		this.ensureUndisposed();
-		assert(this.view !== undefined, 0x8c0 /* unexpected getViewOrError */);
-		return this.view;
+		assert(this.flexTreeContext !== undefined, 0x8c0 /* unexpected getViewOrError */);
+		return this.flexTreeContext;
 	}
 
 	/**
@@ -301,82 +305,65 @@ export class SchematizingSimpleTreeView<
 	 * If implicit initialization (or some other edit) is desired, it should be done outside of this method.
 	 */
 	private update(): void {
-		this.disposeView();
+		this.disposeFlexView();
 
 		const compatibility = this.viewSchema.checkCompatibility(this.checkout.storedSchema);
 
-		let lastRoot =
-			this.compatibility.canView && this.view !== undefined ? this.root : undefined;
 		this.currentCompatibility = {
 			...compatibility,
 			canInitialize: canInitialize(this.checkout),
 		};
 
-		if (compatibility.canView) {
-			// Trigger "rootChanged" if the root changes in the future.
-			// Currently there is no good way to do this as FlexTreeField has no events for changes.
-			// this.view.flexTree.on(????)
-			// As a workaround for the above, trigger "rootChanged" in "afterBatch"
-			// which isn't the correct time since we normally do events during the batch when the forest is modified, but its better than nothing.
-			// TODO: provide a better event: this.view.flexTree.on(????)
-			const cleanupCheckOutEvents = this.checkout.events.on("afterBatch", () => {
-				// In the initialization flow, this event is raised before the correct compatibility w.r.t the new schema is calculated.
-				// Accessing `this.root` in that case can throw. It's OK to ignore this because:
-				// - The rootChanged event will already be raised at the end of the current upgrade
-				// - It doesn't matter that `lastRoot` isn't updated in this case, because `update` will be called again before the upgrade
-				//   completes (at which point this callback and the `lastRoot` captured here will be out of scope anyway)
-				if (!this.midUpgrade && lastRoot !== this.root) {
-					lastRoot = this.root;
-					this.events.emit("rootChanged");
-				}
-			});
-
-			const onViewDispose = (): void => {
-				cleanupCheckOutEvents();
-				this.view = undefined;
-				if (!this.disposed) {
-					this.update();
-				}
-			};
+		const anchors = this.checkout.forest.anchors;
+		const slots = anchors.slots;
 
-			const view = requireSchema(
+		if (compatibility.canView) {
+			this.flexTreeContext = new Context(
+				this.schemaPolicy,
 				this.checkout,
-				this.viewSchema,
-				onViewDispose,
 				this.nodeKeyManager,
-				this.schemaPolicy,
-			);
-			this.view = view;
-			assert(
-				!this.checkout.forest.anchors.slots.has(SimpleContextSlot),
-				0xa47 /* extra simple tree context */,
 			);
-			this.checkout.forest.anchors.slots.set(
+			assert(!slots.has(SimpleContextSlot), 0xa47 /* extra simple tree context */);
+			slots.set(
 				SimpleContextSlot,
 				new HydratedContext(
 					normalizeFieldSchema(this.rootFieldSchema).annotatedAllowedTypesNormalized,
-					view.context,
+					this.flexTreeContext,
 				),
 			);
 
-			const unregister = this.checkout.storedSchema.events.on("afterSchemaChange", () => {
-				unregister();
-				this.unregisterCallbacks.delete(unregister);
-				view[disposeSymbol]();
-			});
-			this.unregisterCallbacks.add(unregister);
-		} else {
-			this.view = undefined;
-			this.checkout.forest.anchors.slots.delete(SimpleContextSlot);
-
-			const unregister = this.checkout.storedSchema.events.on("afterSchemaChange", () => {
-				unregister();
-				this.unregisterCallbacks.delete(unregister);
-				this.update();
-			});
-			this.unregisterCallbacks.add(unregister);
+			// Trigger "rootChanged" events if the root changes in the future.
+			{
+				// Currently there is no good way to do this as FlexTreeField has no events for changes.
+				// this.root.on(????)
+				// As a workaround for the above, trigger "rootChanged" in "afterBatch".
+				// Ideally these events would be just events for changes within the root.
+				// TODO: provide a better event: this.view.flexTree.on(????) and/or integrate with with the normal event code paths.
+
+				// Track what the root was before to be able to detect changes.
+				let lastRoot: ReadableField<TRootSchema> = this.root;
+
+				this.flexTreeViewUnregisterCallbacks.add(
+					this.checkout.events.on("afterBatch", () => {
+						// In the initialization flow, this event is raised before the correct compatibility w.r.t the new schema is calculated.
+						// Accessing `this.root` in that case can throw. It's OK to ignore this because:
+						// - The rootChanged event will already be raised at the end of the current upgrade
+						// - It doesn't matter that `lastRoot` isn't updated in this case, because `update` will be called again before the upgrade
+						//   completes (at which point this callback and the `lastRoot` captured here will be out of scope anyway)
+						if (!this.midUpgrade && lastRoot !== this.root) {
+							lastRoot = this.root;
+							this.events.emit("rootChanged");
+						}
+					}),
+				);
+			}
 		}
 
+		this.flexTreeViewUnregisterCallbacks.add(
+			// Will dispose the old view (if there is one) when its no longer valid, and create a new one if appropriate.
+			this.checkout.storedSchema.events.on("afterSchemaChange", () => this.update()),
+		);
+
 		if (!this.midUpgrade) {
 			this.events.emit("schemaChanged");
 			this.events.emit("rootChanged");
@@ -394,14 +381,20 @@ export class SchematizingSimpleTreeView<
 		this.events.emit("rootChanged");
 	}
 
-	private disposeView(): void {
-		if (this.view !== undefined) {
-			this.view[disposeSymbol]();
-			this.view = undefined;
-			this.checkout.forest.anchors.slots.delete(SimpleContextSlot);
-			this.unregisterCallbacks.forEach((unregister) => unregister());
+	private disposeFlexView(): void {
+		const anchors = this.checkout.forest.anchors;
+		if (this.flexTreeContext !== undefined) {
+			// Cleanup any TreeNodes cached in the AnchorSet when disposing the flex-tree which they wrap.
+			for (const anchorNode of anchors) {
+				tryDisposeTreeNode(anchorNode);
+			}
+
+			this.flexTreeContext[disposeSymbol]();
+			this.flexTreeContext = undefined;
 		}
-		this.checkout.forest.anchors.slots.delete(SimpleContextSlot);
+		this.flexTreeViewUnregisterCallbacks.forEach((unregister) => unregister());
+		this.flexTreeViewUnregisterCallbacks.clear();
+		anchors.slots.delete(SimpleContextSlot);
 	}
 
 	public get compatibility(): SchemaCompatibilityStatus {
@@ -413,7 +406,8 @@ export class SchematizingSimpleTreeView<
 
 	public dispose(): void {
 		this.disposed = true;
-		this.disposeView();
+		this.disposeFlexView();
+		this.unregisterCallbacks.forEach((unregister) => unregister());
 		this.checkout.forest.anchors.slots.delete(ViewSlot);
 		this.currentCompatibility = undefined;
 		this.onDispose?.();
@@ -430,8 +424,8 @@ export class SchematizingSimpleTreeView<
 				"Document is out of schema. Check TreeView.compatibility before accessing TreeView.root.",
 			);
 		}
-		const view = this.getView();
-		return tryGetTreeNodeForField(view.flexTree) as ReadableField<TRootSchema>;
+		const view = this.getFlexTreeContext();
+		return tryGetTreeNodeForField(view.root) as ReadableField<TRootSchema>;
 	}
 
 	public set root(newRoot: InsertableField<TRootSchema>) {
@@ -441,12 +435,8 @@ export class SchematizingSimpleTreeView<
 				"Document is out of schema. Check TreeView.compatibility before accessing TreeView.root.",
 			);
 		}
-		const view = this.getView();
-		setField(
-			view.context.root,
-			this.rootFieldSchema,
-			newRoot as InsertableContent | undefined,
-		);
+		const view = this.getFlexTreeContext();
+		setField(view.root, this.rootFieldSchema, newRoot as InsertableContent | undefined);
 	}
 
 	// #region Branching
@@ -478,31 +468,6 @@ export function getCheckout(context: TreeBranch): TreeCheckout {
 	throw new UsageError("Unsupported context implementation");
 }
 
-/**
- * Creates a view that self-disposes whenever the stored schema changes.
- * This may only be called when the schema is already known to be compatible (typically via ensureSchema).
- */
-export function requireSchema(
-	checkout: ITreeCheckout,
-	viewSchema: SchemaCompatibilityTester,
-	onDispose: () => void,
-	nodeKeyManager: NodeIdentifierManager,
-	schemaPolicy: FullSchemaPolicy,
-): CheckoutFlexTreeView {
-	const slots = checkout.forest.anchors.slots;
-	assert(!slots.has(ContextSlot), 0x8c2 /* Cannot create second view from checkout */);
-
-	{
-		const compatibility = viewSchema.checkCompatibility(checkout.storedSchema);
-		assert(compatibility.canView, 0x8c3 /* requireSchema invoked with incompatible schema */);
-	}
-
-	const view = new CheckoutFlexTreeView(checkout, schemaPolicy, nodeKeyManager, onDispose);
-	assert(slots.has(ContextSlot), 0x90d /* Context should be tracked in slot */);
-
-	return view;
-}
-
 /**
  * Adds constraints to a `checkout`'s pending transaction.
  *

package/src/shared-tree/sharedTreeChangeTypes.ts

@@ -16,7 +16,7 @@ export type SharedTreeInnerChange =
 export interface SharedTreeChange {
 	/**
 	 * The changes to apply.
-	 * @remarks while not expressable in TypeScript, these changes should never have two `ModularChangeset`s adjacent in the list.
+	 * @remarks while not expressible in TypeScript, these changes should never have two `ModularChangeset`s adjacent in the list.
 	 * This restriction exists because this change type should preserve the composition behavior of `ModularChangeFamily`, which
 	 * always composes runs of `ModularChangeset`s into a single `ModularChangeset`.
 	 */

package/src/shared-tree/tree.ts

@@ -4,6 +4,7 @@
  */
 
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
+import { assert } from "@fluidframework/core-utils/internal";
 
 import {
 	type ImplicitFieldSchema,
@@ -16,12 +17,12 @@ import {
 	type TransactionConstraint,
 } from "../simple-tree/index.js";
 
-import { getCheckoutFlexTreeView } from "./checkoutFlexTreeView.js";
 import {
 	addConstraintsToTransaction,
 	SchematizingSimpleTreeView,
 } from "./schematizingTreeView.js";
 import type { ITreeCheckout } from "./treeCheckout.js";
+import { Context } from "../feature-libraries/index.js";
 
 /**
  * Provides various functions for interacting with {@link TreeNode}s.
@@ -449,8 +450,8 @@ export function runTransaction<
 				"Transactions cannot be run on Unhydrated nodes. Transactions apply to a TreeView and Unhydrated nodes are not part of a TreeView.",
 			);
 		}
-		const treeView = getCheckoutFlexTreeView(context);
-		return runTransactionInCheckout(treeView.checkout, () => t(node), preconditions);
+		assert(context instanceof Context, "Expected context to be a Context instance.");
+		return runTransactionInCheckout(context.checkout, () => t(node), preconditions);
 	}
 }
 

package/src/shared-tree/treeAlpha.ts

@@ -191,6 +191,12 @@ export interface TreeIdentifierUtils {
  * Extensions to {@link (Tree:interface)} and {@link (TreeBeta:interface)} which are not yet stable.
  * @remarks
  * Use via the {@link (TreeAlpha:variable)} singleton.
+ * @privateRemarks
+ * TODO: AB#43548:
+ * How all the create and all the import and export APIs handle unknown optional fields needs to be figured out, tested and documented.
+ * This will need to be extended/generalized to cover other future schema evolution options as well once they exist.
+ * See also TreeBeta.clone with a similar issue.
+ *
  * @system @sealed @alpha
  */
 export interface TreeAlpha {
@@ -214,7 +220,7 @@ export interface TreeAlpha {
 	 * This function exists as a generalization that can be used in other cases as well,
 	 * such as when `undefined` might be allowed (for an optional field), or when the type should be inferred from the data when more than one type is possible.
 	 * @privateRemarks
-	 * There should be a way to provide a source for defaulted identifiers, either via this API or some way to add them to its output later.
+	 * TODO: AB#43548: There should be a way to provide a source for defaulted identifiers, either via this API or some way to add them to its output later.
 	 */
 	create<const TSchema extends ImplicitFieldSchema | UnsafeUnknownSchema>(
 		schema: UnsafeUnknownSchema extends TSchema

package/src/shared-tree/treeCheckout.ts

@@ -46,8 +46,10 @@ import {
 import {
 	type FieldBatchCodec,
 	type TreeCompressionStrategy,
+	allowsRepoSuperset,
 	buildForest,
 	createNodeIdentifierManager,
+	defaultSchemaPolicy,
 	intoDelta,
 	jsonableTreeFromCursor,
 	makeFieldBatchCodec,
@@ -229,8 +231,13 @@ export interface ITreeCheckout extends AnchorLocator, ViewableTree, WithBreakabl
 	/**
 	 * Replaces all schema with the provided schema.
 	 * Can over-write preexisting schema, and removes unmentioned schema.
+	 *
+	 * @param newSchema - The new schema to replace the existing schema.
+	 * @param allowNonSupersetSchema - Whether to allow non-superset schemas.
+	 * Defaults to false.
+	 * If false, an assert will be thrown if the new schema does not permit all possible documents which were permitted under the old schema.
 	 */
-	updateSchema(newSchema: TreeStoredSchema): void;
+	updateSchema(newSchema: TreeStoredSchema, allowNonSupersetSchema?: true): void;
 
 	/**
 	 * Events about this view.
@@ -776,8 +783,14 @@ export class TreeCheckout implements ITreeCheckoutFork {
 		}
 	}
 
-	public updateSchema(newSchema: TreeStoredSchema): void {
+	public updateSchema(newSchema: TreeStoredSchema, allowNonSupersetSchema?: true): void {
 		this.checkNotDisposed();
+		if (allowNonSupersetSchema !== true) {
+			assert(
+				allowsRepoSuperset(defaultSchemaPolicy, this.storedSchema.clone(), newSchema),
+				"New schema must allow all documents allowed by old schema",
+			);
+		}
 		this.editor.schema.setStoredSchema(this.storedSchema.clone(), newSchema);
 	}
 

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

@@ -3,13 +3,25 @@
  * Licensed under the MIT License.
  */
 
-import { assert, oob } from "@fluidframework/core-utils/internal";
+import {
+	assert,
+	DoublyLinkedList,
+	oob,
+	type ListNode,
+	type ListNodeRange,
+} from "@fluidframework/core-utils/internal";
 
 import type { GraphCommit, TaggedChange } from "../core/index.js";
 import { disposeSymbol, hasSome } from "../util/index.js";
 
 import type { ChangeEnricherReadonlyCheckout, ResubmitMachine } from "./index.js";
 
+interface PendingChange<TChange> {
+	commit: GraphCommit<TChange>;
+	lastEnrichment: number;
+}
+type PendingChangeNode<TChange> = ListNode<PendingChange<TChange>>;
+
 /**
  * Default implementation of {@link ResubmitMachine}.
  */
@@ -17,24 +29,20 @@ export class DefaultResubmitMachine<TChange> implements ResubmitMachine<TChange>
 	/**
 	 * The list of commits (from oldest to most recent) that have been submitted but not sequenced.
 	 */
-	private inFlightQueue: GraphCommit<TChange>[] = [];
+	private readonly inFlightQueue: DoublyLinkedList<PendingChange<TChange>> =
+		new DoublyLinkedList();
 
 	/**
-	 * The list of commits (from oldest to most recent) that should be resubmitted.
+	 * The range of in-flight commits that are currently being resubmitted.
+	 * Defined only during the resubmit phase.
 	 */
-	private resubmitQueue: GraphCommit<TChange>[] = [];
+	private pendingResubmitRange: ListNodeRange<PendingChange<TChange>> | undefined;
 
 	/**
-	 * Represents the index in the `inFlightQueue` array of the most recent in flight commit that has
-	 * undergone rebasing but whose enrichments have not been updated.
-	 * All in-flight commits with an index inferior or equal to this number have stale enrichments.
-	 *
-	 * Is -1 when *any* of the following is true:
-	 * - There are no in-flight commits (i.e., no local commits have been made or they have all been sequenced)
-	 * - None of the in-flight commits have been rebased
-	 * - In-flight commits that have been rebased have all had their enrichments updated
+	 * The current enrichment version for in-flight commits.
+	 * Incremented when a peer commit is sequenced.
 	 */
-	private latestInFlightCommitWithStaleEnrichments: number = -1;
+	private currentEnrichment: number = 0;
 
 	public constructor(
 		/**
@@ -49,14 +57,31 @@ export class DefaultResubmitMachine<TChange> implements ResubmitMachine<TChange>
 	) {}
 
 	public onCommitSubmitted(commit: GraphCommit<TChange>): void {
-		if (this.isInResubmitPhase) {
-			const toResubmit = this.resubmitQueue.shift();
+		if (this.pendingResubmitRange !== undefined) {
+			const toResubmit = this.pendingResubmitRange?.first;
 			assert(
-				toResubmit === commit,
+				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);
+		this.inFlightQueue.push({ 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();
 	}
 
 	public prepareForResubmit(toResubmit: readonly GraphCommit<TChange>[]): void {
@@ -64,16 +89,33 @@ export class DefaultResubmitMachine<TChange> implements ResubmitMachine<TChange>
 			!this.isInResubmitPhase,
 			0x957 /* Invalid resubmit phase start during incomplete resubmit phase */,
 		);
+
+		if (!hasSome(toResubmit)) {
+			return;
+		}
+
 		assert(
-			toResubmit.length === this.inFlightQueue.length,
-			0x958 /* Unexpected resubmit of more or fewer commits than are in flight */,
+			toResubmit.length <= this.inFlightQueue.length,
+			0xbd8 /* Unexpected resubmit of more commits than are in flight */,
 		);
-		if (this.latestInFlightCommitWithStaleEnrichments === -1) {
-			// No in-flight commits have stale enrichments, so we can resubmit them as is
-			this.resubmitQueue = this.inFlightQueue;
-			this.inFlightQueue = [];
-		} else {
+
+		// 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 */,
+		);
+
+		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();
@@ -83,32 +125,37 @@ export class DefaultResubmitMachine<TChange> implements ResubmitMachine<TChange>
 				// forwards from an earlier fork instead of backwards.
 				checkout.applyTipChange(rollback);
 			}
-			// Update the enrichments of the stale commits
-			for (
-				let iCommit = 0;
-				iCommit <= this.latestInFlightCommitWithStaleEnrichments;
-				iCommit += 1
-			) {
-				const commit = toResubmit[iCommit] ?? oob();
-				const enrichedChange = checkout.updateChangeEnrichments(
-					commit.change,
-					commit.revision,
+
+			// 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 */,
 				);
-				const enrichedCommit = { ...commit, change: enrichedChange };
-				this.resubmitQueue.push(enrichedCommit);
-				if (iCommit < this.latestInFlightCommitWithStaleEnrichments) {
-					checkout.applyTipChange(enrichedChange, 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;
 				}
-				this.inFlightQueue.shift();
+				current = current.next;
 			}
 			checkout[disposeSymbol]();
-			// Whatever commits are left do not have stale enrichments
-			for (const commit of this.inFlightQueue) {
-				this.resubmitQueue.push(commit);
-			}
-			this.inFlightQueue.length = 0;
 		}
-		this.latestInFlightCommitWithStaleEnrichments = -1;
 	}
 
 	public peekNextCommit(): GraphCommit<TChange> {
@@ -116,12 +163,15 @@ export class DefaultResubmitMachine<TChange> implements ResubmitMachine<TChange>
 			this.isInResubmitPhase,
 			0x982 /* No available commit to resubmit outside of resubmit phase */,
 		);
-		assert(hasSome(this.resubmitQueue), 0xa87 /* Expected resubmit queue to be non-empty */);
-		return this.resubmitQueue[0];
+		assert(
+			this.pendingResubmitRange !== undefined,
+			0xa87 /* Expected resubmit queue to be non-empty */,
+		);
+		return this.pendingResubmitRange.first.data.commit;
 	}
 
 	public get isInResubmitPhase(): boolean {
-		return this.resubmitQueue.length !== 0;
+		return this.pendingResubmitRange !== undefined;
 	}
 
 	public onSequencedCommitApplied(isLocal: boolean): void {
@@ -129,12 +179,9 @@ export class DefaultResubmitMachine<TChange> implements ResubmitMachine<TChange>
 			// The oldest in-flight commit has been sequenced
 			assert(this.inFlightQueue.length > 0, 0x959 /* Sequencing of unknown local commit */);
 			this.inFlightQueue.shift();
-			if (this.latestInFlightCommitWithStaleEnrichments >= 0) {
-				this.latestInFlightCommitWithStaleEnrichments -= 1;
-			}
 		} else {
 			// A peer commit has been sequenced
-			this.latestInFlightCommitWithStaleEnrichments = this.inFlightQueue.length - 1;
+			this.currentEnrichment++;
 		}
 	}
 }

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

@@ -37,6 +37,13 @@ export interface ResubmitMachine<TChange> {
 	 */
 	onCommitSubmitted(commit: GraphCommit<TChange>): void;
 
+	/**
+	 * Must be called on a commit after rollback, so it can be removed
+	 * as it will never be (re)submitted.
+	 * @param commit - The commit that was rolled back
+	 */
+	onCommitRollback(commit: GraphCommit<TChange>): void;
+
 	/**
 	 * Must be called after a sequenced commit is applied.
 	 * Note that this may be called multiples times in a row after a number of sequenced commits have been applied