@fluidframework/container-runtime 2.91.0 → 2.93.0

package/src/opLifecycle/opGroupingManager.ts

@@ -17,6 +17,13 @@ import type {
 	OutboundSingletonBatch,
 } from "./definitions.js";
 
+/**
+ * The number of ops in a batch above which the batch is considered "large"
+ * for telemetry purposes. Used by both {@link OpGroupingManager} (GroupLargeBatch event)
+ * and as the default staging-mode auto-flush threshold.
+ */
+export const largeBatchThreshold = 1000;
+
 /**
  * Grouping makes assumptions about the shape of message contents. This interface codifies those assumptions, but does not validate them.
  */
@@ -123,7 +130,10 @@ export class OpGroupingManager {
 			return batch as OutboundSingletonBatch;
 		}
 
-		if (batch.messages.length >= 1000) {
+		// Use > (not >=) so that batches flushed exactly at the staging-mode
+		// auto-flush threshold (which defaults to largeBatchThreshold) don't
+		// trigger this event. Only genuinely oversized batches are logged.
+		if (batch.messages.length > largeBatchThreshold) {
 			this.logger.sendTelemetryEvent({
 				eventName: "GroupLargeBatch",
 				length: batch.messages.length,

package/src/opLifecycle/opSerialization.ts

@@ -40,16 +40,18 @@ export function serializeOp(
 		| EmptyGroupedBatch
 		| LocalContainerRuntimeMessage
 		| LocalContainerRuntimeMessage[],
-): string {
-	return JSON.stringify(
-		toSerialize,
-		// replacer:
-		(key, value: unknown) => {
-			// If 'value' is an IFluidHandle return its encoded form.
-			if (isFluidHandle(value)) {
-				return encodeHandleForSerialization(toFluidHandleInternal(value));
-			}
-			return value;
-		},
-	);
+): { content: string } {
+	return {
+		content: JSON.stringify(
+			toSerialize,
+			// replacer:
+			(key, value: unknown) => {
+				// If 'value' is an IFluidHandle return its encoded form.
+				if (isFluidHandle(value)) {
+					return encodeHandleForSerialization(toFluidHandleInternal(value));
+				}
+				return value;
+			},
+		),
+	};
 }

package/src/opLifecycle/outbox.ts

@@ -28,6 +28,7 @@ import {
 	type BatchSequenceNumbers,
 	sequenceNumbersMatch,
 	type BatchId,
+	addBatchMetadata,
 } from "./batchManager.js";
 import type {
 	LocalBatchMessage,
@@ -48,12 +49,6 @@ export interface IOutboxConfig {
 	 * The maximum size of a batch that we can send over the wire.
 	 */
 	readonly maxBatchSizeInBytes: number;
-	/**
-	 * If true, maybeFlushPartialBatch will flush the batch if the reference sequence number changed
-	 * since the batch started. Otherwise, it will throw in this case (apart from reentrancy which is handled elsewhere).
-	 * Once the new throw-based flow is proved in a production environment, this option will be removed.
-	 */
-	readonly flushPartialBatches: boolean;
 }
 
 export interface IOutboxParameters {
@@ -71,6 +66,13 @@ export interface IOutboxParameters {
 	readonly getCurrentSequenceNumbers: () => BatchSequenceNumbers;
 	readonly reSubmit: (message: PendingMessageResubmitData, squash: boolean) => void;
 	readonly opReentrancy: () => boolean;
+	/**
+	 * JIT callback to generate an ID allocation op at flush time.
+	 * Called after rebase (if any), so the returned message has the correct refSeq.
+	 *
+	 * @returns A LocalBatchMessage for the ID allocation op, or undefined if no IDs need allocating.
+	 */
+	readonly generateIdAllocationOp: () => LocalBatchMessage | undefined;
 }
 
 /**
@@ -142,7 +144,7 @@ export function localBatchToOutboundBatch({
 	// Shallow copy each message as we switch types
 	const outboundMessages = localBatch.messages.map<OutboundBatchMessage>(
 		({ runtimeOp, ...message }) => ({
-			contents: serializeOp(runtimeOp),
+			contents: serializeOp(runtimeOp).content,
 			...message,
 		}),
 	);
@@ -195,7 +197,6 @@ export class Outbox {
 	private readonly logger: ITelemetryLoggerExt;
 	private readonly mainBatch: BatchManager;
 	private readonly blobAttachBatch: BatchManager;
-	private readonly idAllocationBatch: BatchManager;
 	private batchRebasesToReport = 5;
 	private rebasing = false;
 
@@ -211,16 +212,12 @@ export class Outbox {
 	constructor(private readonly params: IOutboxParameters) {
 		this.logger = createChildLogger({ logger: params.logger, namespace: "Outbox" });
 
-		this.mainBatch = new BatchManager({ canRebase: true });
-		this.blobAttachBatch = new BatchManager({ canRebase: true });
-		this.idAllocationBatch = new BatchManager({
-			canRebase: false,
-			ignoreBatchId: true,
-		});
+		this.mainBatch = new BatchManager({ disableGroupedBatching: false });
+		this.blobAttachBatch = new BatchManager({ disableGroupedBatching: true });
 	}
 
 	public get messageCount(): number {
-		return this.mainBatch.length + this.blobAttachBatch.length + this.idAllocationBatch.length;
+		return this.mainBatch.length + this.blobAttachBatch.length;
 	}
 
 	public get mainBatchMessageCount(): number {
@@ -231,19 +228,12 @@ export class Outbox {
 		return this.blobAttachBatch.length;
 	}
 
-	public get idAllocationBatchMessageCount(): number {
-		return this.idAllocationBatch.length;
-	}
-
 	public get isEmpty(): boolean {
 		return this.messageCount === 0;
 	}
 
 	public containsUserChanges(): boolean {
-		return (
-			this.mainBatch.containsUserChanges() || this.blobAttachBatch.containsUserChanges()
-			// ID Allocation ops are not user changes
-		);
+		return this.mainBatch.containsUserChanges() || this.blobAttachBatch.containsUserChanges();
 	}
 
 	/**
@@ -257,13 +247,11 @@ export class Outbox {
 	 * last message processed by the ContainerRuntime. In the absence of op reentrancy, this
 	 * pair will remain stable during a single JS turn during which the batch is being built up.
 	 */
-	private maybeFlushPartialBatch(): void {
+	private outboxSequenceNumberCoherencyCheck(): void {
 		const mainBatchSeqNums = this.mainBatch.sequenceNumbers;
 		const blobAttachSeqNums = this.blobAttachBatch.sequenceNumbers;
-		const idAllocSeqNums = this.idAllocationBatch.sequenceNumbers;
 		assert(
-			sequenceNumbersMatch(mainBatchSeqNums, blobAttachSeqNums) &&
-				sequenceNumbersMatch(mainBatchSeqNums, idAllocSeqNums),
+			sequenceNumbersMatch(mainBatchSeqNums, blobAttachSeqNums),
 			0x58d /* Reference sequence numbers from both batches must be in sync */,
 		);
 
@@ -271,8 +259,7 @@ export class Outbox {
 
 		if (
 			sequenceNumbersMatch(mainBatchSeqNums, currentSequenceNumbers) &&
-			sequenceNumbersMatch(blobAttachSeqNums, currentSequenceNumbers) &&
-			sequenceNumbersMatch(idAllocSeqNums, currentSequenceNumbers)
+			sequenceNumbersMatch(blobAttachSeqNums, currentSequenceNumbers)
 		) {
 			// The reference sequence numbers are stable, there is nothing to do
 			return;
@@ -295,10 +282,7 @@ export class Outbox {
 			this.logger.sendTelemetryEvent(
 				{
 					// Only log error if this is truly unexpected
-					category:
-						expectedDueToReentrancy || this.params.config.flushPartialBatches
-							? "generic"
-							: "error",
+					category: expectedDueToReentrancy ? "generic" : "error",
 					eventName: "ReferenceSequenceNumberMismatch",
 					details: {
 						expectedDueToReentrancy,
@@ -314,12 +298,6 @@ export class Outbox {
 			);
 		}
 
-		// If we're configured to flush partial batches, do that now and return (don't throw)
-		if (this.params.config.flushPartialBatches) {
-			this.flushAll();
-			return;
-		}
-
 		// If we are in a reentrant context, we know this can happen without causing any harm.
 		if (expectedDueToReentrancy) {
 			return;
@@ -329,23 +307,17 @@ export class Outbox {
 	}
 
 	public submit(message: LocalBatchMessage): void {
-		this.maybeFlushPartialBatch();
+		this.outboxSequenceNumberCoherencyCheck();
 
 		this.addMessageToBatchManager(this.mainBatch, message);
 	}
 
 	public submitBlobAttach(message: LocalBatchMessage): void {
-		this.maybeFlushPartialBatch();
+		this.outboxSequenceNumberCoherencyCheck();
 
 		this.addMessageToBatchManager(this.blobAttachBatch, message);
 	}
 
-	public submitIdAllocation(message: LocalBatchMessage): void {
-		this.maybeFlushPartialBatch();
-
-		this.addMessageToBatchManager(this.idAllocationBatch, message);
-	}
-
 	private addMessageToBatchManager(
 		batchManager: BatchManager,
 		message: LocalBatchMessage,
@@ -367,11 +339,12 @@ export class Outbox {
 	public flush(resubmitInfo?: BatchResubmitInfo): void {
 		// We have nothing to flush if all batchManagers are empty, and we we're not needing to resubmit an empty batch placeholder
 		if (
-			this.idAllocationBatch.empty &&
 			this.blobAttachBatch.empty &&
 			this.mainBatch.empty &&
 			resubmitInfo?.batchId === undefined
 		) {
+			// Note that it's possible that there are unfinalized ranges in the ID Compressor,
+			// but there's no urgency to flush those if they're not referenced in any messages.
 			return;
 		}
 
@@ -383,8 +356,7 @@ export class Outbox {
 	}
 
 	private flushAll(resubmitInfo?: BatchResubmitInfo): void {
-		const allBatchesEmpty =
-			this.idAllocationBatch.empty && this.blobAttachBatch.empty && this.mainBatch.empty;
+		const allBatchesEmpty = this.blobAttachBatch.empty && this.mainBatch.empty;
 		if (allBatchesEmpty) {
 			// If we're resubmitting with a batchId and all batches are empty, we need to flush an empty batch.
 			// Note that we currently resubmit one batch at a time, so on resubmit, 1 of the 2 batches will *always* be empty.
@@ -397,22 +369,8 @@ export class Outbox {
 			return;
 		}
 
-		// Don't use resubmittingBatchId for idAllocationBatch.
-		// ID Allocation messages are not directly resubmitted so don't pass the resubmitInfo
-		this.flushInternal({
-			batchManager: this.idAllocationBatch,
-			// Note: For now, we will never stage ID Allocation messages.
-			// They won't contain personal info and no harm in extra allocations in case of discarding the staged changes
-		});
-		this.flushInternal({
-			batchManager: this.blobAttachBatch,
-			disableGroupedBatching: true,
-			resubmitInfo,
-		});
-		this.flushInternal({
-			batchManager: this.mainBatch,
-			resubmitInfo,
-		});
+		this.flushInternal(this.blobAttachBatch, resubmitInfo);
+		this.flushInternal(this.mainBatch, resubmitInfo);
 	}
 
 	private flushEmptyBatch(
@@ -444,17 +402,15 @@ export class Outbox {
 		return;
 	}
 
-	private flushInternal(params: {
-		batchManager: BatchManager;
-		disableGroupedBatching?: boolean;
-		resubmitInfo?: BatchResubmitInfo; // undefined if not resubmitting
-	}): void {
-		const { batchManager, disableGroupedBatching = false, resubmitInfo } = params;
+	private flushInternal(
+		batchManager: BatchManager,
+		resubmitInfo?: BatchResubmitInfo, // undefined if not resubmitting
+	): void {
 		if (batchManager.empty) {
 			return;
 		}
 
-		const rawBatch = batchManager.popBatch(resubmitInfo?.batchId);
+		let rawBatch = batchManager.popBatch();
 
 		// On resubmit we use the original batch's staged state, so these should match as well.
 		const staged = rawBatch.staged === true;
@@ -464,13 +420,15 @@ export class Outbox {
 		);
 
 		const groupingEnabled =
-			!disableGroupedBatching && this.params.groupingManager.groupedBatchingEnabled();
-		if (
-			batchManager.options.canRebase &&
-			rawBatch.hasReentrantOps === true &&
-			groupingEnabled
-		) {
+			!batchManager.options.disableGroupedBatching &&
+			this.params.groupingManager.groupedBatchingEnabled();
+		if (rawBatch.hasReentrantOps === true) {
+			assert(
+				resubmitInfo === undefined,
+				0xcf2 /* Re-submitting a batch with reentrant ops is not supported */,
+			);
 			assert(!this.rebasing, 0x6fa /* A rebased batch should never have reentrant ops */);
+			// Rebase the current batch (resubmit the ops one-by-one) and then reinvoke flushInternal.
 			// If a batch contains reentrant ops (ops created as a result from processing another op)
 			// it needs to be rebased so that we can ensure consistent reference sequence numbers
 			// and eventual consistency at the DDS level.
@@ -481,11 +439,22 @@ export class Outbox {
 			return;
 		}
 
-		let clientSequenceNumber: number | undefined;
 		// Did we disconnect? (i.e. is shouldSend false?)
 		// If so, do nothing, as pending state manager will resubmit it correctly on reconnect.
 		// Because flush() is a task that executes async (on clean stack), we can get here in disconnected state.
-		if (this.params.shouldSend() && !staged) {
+		const shouldSendNow = this.params.shouldSend() && !staged;
+		let clientSequenceNumber: number | undefined;
+		if (shouldSendNow) {
+			// Generate ID Allocation op just-in-time, after rebase (if any), and before addBatchMetadata,
+			// so that the prepended idAllocMsg is correctly marked as the first op in the batch.
+			// This ensures the refSeq is correct (matching the rest of the batch) and that
+			// ID ranges aren't lost during rebase (since reSubmit drops IdAllocation ops).
+			// Only generate for non-staged batches — ID alloc ops are always non-staged.
+			const idAllocMsg = this.params.generateIdAllocationOp();
+			if (idAllocMsg !== undefined) {
+				rawBatch = { ...rawBatch, messages: [idAllocMsg, ...rawBatch.messages] };
+			}
+			addBatchMetadata(rawBatch, resubmitInfo?.batchId);
 			const virtualizedBatch = this.virtualizeBatch(rawBatch, groupingEnabled);
 
 			clientSequenceNumber = this.sendBatch(virtualizedBatch);
@@ -493,13 +462,14 @@ export class Outbox {
 				clientSequenceNumber === undefined || clientSequenceNumber >= 0,
 				0x9d2 /* unexpected negative clientSequenceNumber (empty batch should yield undefined) */,
 			);
+		} else {
+			addBatchMetadata(rawBatch, resubmitInfo?.batchId);
 		}
 
 		this.params.pendingStateManager.onFlushBatch(
 			rawBatch.messages,
 			clientSequenceNumber,
 			staged,
-			batchManager.options.ignoreBatchId,
 		);
 	}
 
@@ -511,7 +481,6 @@ export class Outbox {
 	 */
 	private rebase(rawBatch: LocalBatch, batchManager: BatchManager): void {
 		assert(!this.rebasing, 0x6fb /* Reentrancy */);
-		assert(batchManager.options.canRebase, 0x9a7 /* BatchManager does not support rebase */);
 
 		this.rebasing = true;
 		const squash = false;
@@ -538,7 +507,7 @@ export class Outbox {
 			this.batchRebasesToReport--;
 		}
 
-		this.flushInternal({ batchManager });
+		this.flushInternal(batchManager);
 		this.rebasing = false;
 	}
 
@@ -679,7 +648,6 @@ export class Outbox {
 	 */
 	public getBatchCheckpoints(): {
 		mainBatch: IBatchCheckpoint;
-		idAllocationBatch: IBatchCheckpoint;
 		blobAttachBatch: IBatchCheckpoint;
 	} {
 		// This variable is declared with a specific type so that we have a standard import of the IBatchCheckpoint type.
@@ -687,7 +655,6 @@ export class Outbox {
 		const mainBatch: IBatchCheckpoint = this.mainBatch.checkpoint();
 		return {
 			mainBatch,
-			idAllocationBatch: this.idAllocationBatch.checkpoint(),
 			blobAttachBatch: this.blobAttachBatch.checkpoint(),
 		};
 	}

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/container-runtime";
-export const pkgVersion = "2.91.0";
+export const pkgVersion = "2.93.0";

package/src/pendingStateManager.ts

@@ -84,10 +84,6 @@ export interface IPendingMessage {
 		 * length of the batch (how many runtime messages here)
 		 */
 		length: number;
-		/**
-		 * If true, don't compare batchID of incoming batches to this. e.g. ID Allocation Batch IDs should be ignored
-		 */
-		ignoreBatchId?: boolean;
 		/**
 		 * If true, this batch is staged and should not actually be submitted on replayPendingStates.
 		 */
@@ -335,7 +331,9 @@ export class PendingStateManager implements IDisposable {
 		return this.pendingMessagesCount !== 0;
 	}
 
-	public getLocalState(snapshotSequenceNumber?: number): IPendingLocalState {
+	public getLocalState(snapshotSequenceNumber?: number): {
+		pending: IPendingLocalState;
+	} {
 		assert(
 			this.initialMessages.isEmpty(),
 			0x2e9 /* "Must call getLocalState() after applying initial states" */,
@@ -359,10 +357,12 @@ export class PendingStateManager implements IDisposable {
 			}
 		}
 		return {
-			pendingStates: [
-				...newSavedOps,
-				...this.pendingMessages.toArray().map((message) => toSerializableForm(message)),
-			],
+			pending: {
+				pendingStates: [
+					...newSavedOps,
+					...this.pendingMessages.toArray().map((message) => toSerializableForm(message)),
+				],
+			},
 		};
 	}
 
@@ -403,13 +403,11 @@ export class PendingStateManager implements IDisposable {
 	 * @param clientSequenceNumber - The CSN of the first message in the batch,
 	 * or undefined if the batch was not yet sent (e.g. by the time we flushed we lost the connection)
 	 * @param staged - Indicates whether batch is staged (not to be submitted while runtime is in Staging Mode)
-	 * @param ignoreBatchId - Whether to ignore the batchId in the batchStartInfo
 	 */
 	public onFlushBatch(
 		batch: LocalBatchMessage[] | [LocalEmptyBatchPlaceholder],
 		clientSequenceNumber: number | undefined,
 		staged: boolean,
-		ignoreBatchId?: boolean,
 	): void {
 		// clientId and batchStartCsn are used for generating the batchId so we can detect container forks
 		// where this batch was submitted by two different clients rehydrating from the same local state.
@@ -427,7 +425,7 @@ export class PendingStateManager implements IDisposable {
 			clientId !== undefined,
 			0xa33 /* clientId (from stateHandler) could only be undefined if we've never connected, but we have a CSN so we know that's not the case */,
 		);
-
+		const batchInfo = { clientId, batchStartCsn, length: batch.length, staged };
 		for (const message of batch) {
 			const {
 				runtimeOp,
@@ -438,12 +436,11 @@ export class PendingStateManager implements IDisposable {
 			const pendingMessage: IPendingMessage = {
 				type: "message",
 				referenceSequenceNumber,
-				content: serializeOp(runtimeOp),
+				content: serializeOp(runtimeOp).content,
 				runtimeOp,
 				localOpMetadata,
 				opMetadata,
-				// Note: We only will read this off the first message, but put it on all for simplicity
-				batchInfo: { clientId, batchStartCsn, length: batch.length, ignoreBatchId, staged },
+				batchInfo,
 			};
 			this.pendingMessages.push(pendingMessage);
 		}
@@ -509,23 +506,14 @@ export class PendingStateManager implements IDisposable {
 	 * @returns whether the batch IDs match
 	 */
 	private remoteBatchMatchesPendingBatch(remoteBatchStart: BatchStartInfo): boolean {
-		// Find the first pending message that uses Batch ID, to compare to the incoming remote batch.
-		// If there is no such message, then the incoming remote batch doesn't have a match here and we can return.
-		const firstIndexUsingBatchId = Array.from({
-			length: this.pendingMessages.length,
-		}).findIndex((_, i) => this.pendingMessages.get(i)?.batchInfo.ignoreBatchId !== true);
-		const pendingMessageUsingBatchId =
-			firstIndexUsingBatchId === -1
-				? undefined
-				: this.pendingMessages.get(firstIndexUsingBatchId);
-
-		if (pendingMessageUsingBatchId === undefined) {
+		const pendingMessage = this.pendingMessages.peekFront();
+		if (pendingMessage === undefined) {
 			return false;
 		}
 
 		// We must compare the effective batch IDs, since one of these ops
 		// may have been the original, not resubmitted, so wouldn't have its batch ID stamped yet.
-		const pendingBatchId = getEffectiveBatchId(pendingMessageUsingBatchId);
+		const pendingBatchId = getEffectiveBatchId(pendingMessage);
 		const inboundBatchId = getEffectiveBatchId(remoteBatchStart);
 
 		return pendingBatchId === inboundBatchId;
@@ -747,8 +735,12 @@ export class PendingStateManager implements IDisposable {
 	 * Called when the Container's connection state changes. If the Container gets connected, it replays all the pending
 	 * states in its queue. This includes triggering resubmission of unacked ops.
 	 * ! Note: successfully resubmitting an op that has been successfully sequenced is not possible due to checks in the ConnectionStateHandler (Loader layer)
+	 *
+	 * @returns The unique batch infos for all batches that were replayed.
 	 */
-	public replayPendingStates(options?: ReplayPendingStateOptions): void {
+	public replayPendingStates(
+		options?: ReplayPendingStateOptions,
+	): IPendingMessage["batchInfo"][] {
 		const { committingStagedBatches, squash } = {
 			...defaultReplayPendingStatesOptions,
 			...options,
@@ -775,6 +767,7 @@ export class PendingStateManager implements IDisposable {
 
 		const initialPendingMessagesCount = this.pendingMessages.length;
 		let remainingPendingMessagesCount = this.pendingMessages.length;
+		const replayedBatchSet = new Set<IPendingMessage["batchInfo"]>();
 
 		let seenStagedBatch = false;
 
@@ -802,16 +795,14 @@ export class PendingStateManager implements IDisposable {
 			assert(batchMetadataFlag !== false, 0x41b /* We cannot process batches in chunks */);
 
 			// The next message starts a batch (possibly single-message), and we'll need its batchId.
-			const batchId =
-				pendingMessage.batchInfo.ignoreBatchId === true
-					? undefined
-					: getEffectiveBatchId(pendingMessage);
+			const batchId = getEffectiveBatchId(pendingMessage);
 
 			const staged = pendingMessage.batchInfo.staged;
 
 			if (asEmptyBatchLocalOpMetadata(pendingMessage.localOpMetadata)?.emptyBatch === true) {
 				// Resubmit no messages, with the batchId. Will result in another empty batch marker.
 				this.stateHandler.reSubmitBatch([], { batchId, staged, squash });
+				replayedBatchSet.add(pendingMessage.batchInfo);
 				continue;
 			}
 
@@ -838,6 +829,7 @@ export class PendingStateManager implements IDisposable {
 					],
 					{ batchId, staged, squash },
 				);
+				replayedBatchSet.add(pendingMessage.batchInfo);
 				continue;
 			}
 			// else: batchMetadataFlag === true  (It's a typical multi-message batch)
@@ -877,6 +869,7 @@ export class PendingStateManager implements IDisposable {
 			}
 
 			this.stateHandler.reSubmitBatch(batch, { batchId, staged, squash });
+			replayedBatchSet.add(pendingMessage.batchInfo);
 		}
 
 		if (!committingStagedBatches) {
@@ -894,6 +887,8 @@ export class PendingStateManager implements IDisposable {
 				clientId: this.stateHandler.clientId(),
 			});
 		}
+
+		return [...replayedBatchSet];
 	}
 
 	/**
@@ -904,11 +899,13 @@ export class PendingStateManager implements IDisposable {
 			// callback will only be given staged messages with a valid runtime op (i.e. not empty batch and not an initial message with only serialized content)
 			stagedMessage: IPendingMessage & { runtimeOp: LocalContainerRuntimeMessage },
 		) => void,
-	): void {
+	): IPendingMessage["batchInfo"][] {
+		const batchSet = new Set<IPendingMessage["batchInfo"]>();
 		while (!this.pendingMessages.isEmpty()) {
 			const stagedMessage = this.pendingMessages.peekBack();
 			if (stagedMessage?.batchInfo.staged === true) {
 				this.pendingMessages.pop();
+				batchSet.add(stagedMessage.batchInfo);
 
 				if (hasTypicalRuntimeOp(stagedMessage)) {
 					callback(stagedMessage);
@@ -921,6 +918,7 @@ export class PendingStateManager implements IDisposable {
 			this.pendingMessages.toArray().every((m) => m.batchInfo.staged !== true),
 			0xb89 /* Shouldn't be any more staged messages */,
 		);
+		return [...batchSet];
 	}
 }
 

package/src/summary/documentSchema.ts

@@ -512,7 +512,7 @@ function arrayToProp(arr: string[]): string[] | undefined {
  *
  * Users of this class need to use DocumentsSchemaController.sessionSchema to determine what features can be used.
  *
- * There are two modes this class can operate:
+ * There are three modes this class can operate:
  * 1) Legacy mode. In such mode it does not issue any ops to change document schema. Any changes happen implicitly,
  *    right away, and new features are available right away
  * 2) Non-legacy mode. In such mode any changes to schema require an op roundtrip. This class will manage such transitions.
@@ -523,6 +523,9 @@ function arrayToProp(arr: string[]): string[] | undefined {
  *    then eventually all documents that are modified will have that feature reflected in their schema. It could require
  *    multiple reloads / new sessions to get there (depends on if code reacts to schema changes right away, or only consults
  *    schema on document load).
+ * 3) Schema upgrade disabled mode (disableSchemaUpgrade = true). In this mode the controller will never send DocumentSchemaChange ops
+ *    and will throw an error if any incoming schema change ops are received. The document schema is effectively frozen at the schema
+ *    loaded for this session (snapshot) and will not accept further schema-change ops.
  *
  * How schemas are changed (in non-legacy mode):
  * If a client needs to change a schema, it will attempt to do so as part of normal ops sending process.
@@ -569,6 +572,7 @@ export class DocumentsSchemaController {
 	 * @param onSchemaChange - callback that is called whenever schema is changed (not called on creation / load, only when processing document schema change ops)
 	 * @param info - Informational properties of the document that are not subject to strict schema enforcement
 	 * @param logger - telemetry logger from the runtime
+	 * @param disableSchemaUpgrade - when true, the controller will never send or accept DocumentSchemaChange ops
 	 */
 	constructor(
 		existing: boolean,
@@ -578,6 +582,7 @@ export class DocumentsSchemaController {
 		private readonly onSchemaChange: (schema: IDocumentSchemaCurrent) => void,
 		info: IDocumentSchemaInfo,
 		logger: ITelemetryLoggerExt,
+		private readonly disableSchemaUpgrade: boolean,
 	) {
 		// For simplicity, let's only support new schema features for explicit schema control mode
 		assert(
@@ -704,9 +709,12 @@ export class DocumentsSchemaController {
 	 * Called by Container runtime whenever it is about to send some op.
 	 * It gives opportunity for controller to issue its own ops - we do not want to send ops if there are no local changes in document.
 	 * Please consider note above constructor about race conditions - current design is to generate op only once in a session lifetime.
-	 * @returns Optional message to send.
+	 * @returns Optional message to send. Always returns undefined when disableSchemaUpgrade is true.
 	 */
 	public maybeGenerateSchemaMessage(): IDocumentSchemaChangeMessageOutgoing | undefined {
+		if (this.disableSchemaUpgrade) {
+			return undefined;
+		}
 		if (this.futureSchema !== undefined && !this.opPending) {
 			this.opPending = true;
 			assert(
@@ -739,6 +747,7 @@ export class DocumentsSchemaController {
 	/**
 	 * Process document schema change messages
 	 * Called by ContainerRuntime whenever it sees document schema messages.
+	 * When disableSchemaUpgrade is true, an error is thrown if any incoming schema change ops are received.
 	 * @param contents - contents of the messages
 	 * @param local - whether op is local
 	 * @param sequenceNumber - sequence number of the op
@@ -749,6 +758,20 @@ export class DocumentsSchemaController {
 		local: boolean,
 		sequenceNumber: number,
 	): boolean {
+		if (this.disableSchemaUpgrade) {
+			assert(
+				!local,
+				0xceb /* local schema change messages should never be generated when disableSchemaUpgrade is enabled */,
+			);
+			// Clients with disableSchemaUpgrade enabled should never generate schema change messages, but they
+			// may receive them from misconfigured clients. In such case, throw on any incoming schema change ops
+			// to prevent unexpected schema upgrades.
+			throw DataProcessingError.create(
+				"DocSchema: Received schema change op while disableSchemaUpgrade is enabled",
+				"processDocumentSchemaMessages",
+				undefined,
+			);
+		}
 		for (const content of contents) {
 			this.validateSeqNumber(content.refSeq, this.documentSchema.refSeq, "content.refSeq");
 			this.validateSeqNumber(this.documentSchema.refSeq, sequenceNumber, "refSeq");

package/src/summary/orderedClientElection.ts

@@ -515,7 +515,7 @@ export class OrderedClientElection
 				"InteractiveClientElected",
 				client,
 				sequenceNumber,
-				true /* forceSend */,
+				false /* forceSend */,
 				reason,
 			);
 			// Changing the elected parent as well.
@@ -544,7 +544,7 @@ export class OrderedClientElection
 				"ParentElected",
 				client,
 				sequenceNumber,
-				true /* forceSend */,
+				false /* forceSend */,
 				reason,
 			);
 			this._electedParent = client;