@fluidframework/container-runtime 0.58.1000 → 0.58.2000

package/src/batchTracker.ts

@@ -3,11 +3,11 @@
  * Licensed under the MIT License.
  */
 
+import EventEmitter from "events";
 import { ITelemetryLogger } from "@fluidframework/common-definitions";
 import { assert, performance } from "@fluidframework/common-utils";
 import { ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
 import { ChildLogger } from "@fluidframework/telemetry-utils";
-import EventEmitter from "events";
 
 export class BatchTracker {
     private readonly logger: ITelemetryLogger;
@@ -77,4 +77,4 @@ export const BindBatchTracker = (
     logger: ITelemetryLogger,
     batchLengthThreshold: number = 128,
     batchCountSamplingRate: number = 1000,
-) => new BatchTracker(batchEventEmitter, logger, batchLengthThreshold, batchCountSamplingRate)
+) => new BatchTracker(batchEventEmitter, logger, batchLengthThreshold, batchCountSamplingRate);

package/src/containerRuntime.ts

@@ -780,6 +780,7 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
             if (loadSequenceNumberVerification !== "bypass" && runtimeSequenceNumber !== protocolSequenceNumber) {
                 // "Load from summary, runtime metadata sequenceNumber !== initialSequenceNumber"
                 const error = new DataCorruptionError(
+                    // pre-0.58 error message: SummaryMetadataMismatch
                     "Summary metadata mismatch",
                     { runtimeSequenceNumber, protocolSequenceNumber },
                 );
@@ -1128,6 +1129,7 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
         this.pendingStateManager = new PendingStateManager(
             this,
             async (type, content) => this.applyStashedOp(type, content),
+            this._flushMode,
             context.pendingLocalState as IPendingLocalState);
 
         this.context.quorum.on("removeMember", (clientId: string) => {
@@ -1579,6 +1581,7 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
             this.context.pendingLocalState = undefined;
             if (!this.shouldContinueReconnecting()) {
                 this.closeFn(new GenericError(
+                    // pre-0.58 error message: MaxReconnectsWithNoProgress
                     "Runtime detected too many reconnects with no progress syncing local ops",
                     undefined, // error
                     { attempts: this.consecutiveReconnects }));
@@ -1762,6 +1765,7 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
             this._orderSequentiallyCalls++;
             callback();
         } catch (error) {
+            // pre-0.58 error message: orderSequentiallyCallbackException
             this.closeFn(new GenericError("orderSequentially callback exception", error));
             throw error; // throw the original error for the consumer of the runtime
         } finally {
@@ -2147,7 +2151,7 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
             if (summaryRefSeqNum !== this.deltaManager.lastMessage?.sequenceNumber) {
                 summaryLogger.sendErrorEvent({
                     eventName: "LastSequenceMismatch",
-                    message,
+                    error: message,
                 });
             }
 

package/src/dataStore.ts

@@ -123,7 +123,7 @@ class DataStore implements IDataStore {
         private readonly fluidDataStoreChannel: IFluidDataStoreChannel,
         private readonly internalId: string,
         private readonly runtime: ContainerRuntime,
-        private datastores: DataStores,
+        private readonly datastores: DataStores,
         private readonly logger: ITelemetryLogger,
     ) { }
     public get IFluidRouter() { return this.fluidDataStoreChannel; }

package/src/dataStoreContext.ts

@@ -106,6 +106,7 @@ export function createAttributesBlob(
 
 interface ISnapshotDetails {
     pkg: readonly string[];
+    isRootDataStore: boolean;
     snapshot?: ISnapshotTree;
 }
 
@@ -206,11 +207,25 @@ export abstract class FluidDataStoreContext extends TypedEventEmitter<IFluidData
         return this.registry;
     }
 
+    /**
+     * A datastore is considered as root if it
+     * 1. is root in memory - see isInMemoryRoot
+     * 2. is root as part of the base snapshot that the datastore loaded from
+     * @returns whether a datastore is root
+     */
     public async isRoot(): Promise<boolean> {
-        // This call updates this.isRootDataStore if it has not yet been updated
-        // The initial value is stored in the initial snapshot of the data store
-        await this.getInitialSnapshotDetails();
-        return this.isRootDataStore;
+        return this.isInMemoryRoot() || (await this.getInitialSnapshotDetails()).isRootDataStore;
+    }
+
+    /**
+     * There are 3 states where isInMemoryRoot needs to be true
+     * 1. when a datastore becomes aliased. This can happen for both remote and local datastores
+     * 2. when a datastore is created locally as root
+     * 3. when a datastore is created locally as root and is rehydrated
+     * @returns whether a datastore is root in memory
+     */
+    protected isInMemoryRoot(): boolean {
+        return this._isInMemoryRoot;
     }
 
     protected registry: IFluidDataStoreRegistry | undefined;
@@ -223,7 +238,7 @@ export abstract class FluidDataStoreContext extends TypedEventEmitter<IFluidData
     protected channelDeferred: Deferred<IFluidDataStoreChannel> | undefined;
     private _baseSnapshot: ISnapshotTree | undefined;
     protected _attachState: AttachState;
-    protected isRootDataStore: boolean = false;
+    private _isInMemoryRoot: boolean = false;
     protected readonly summarizerNode: ISummarizerNodeWithGC;
     private readonly subLogger: ITelemetryLogger;
     private readonly thresholdOpsCounter: ThresholdCounter;
@@ -450,7 +465,8 @@ export abstract class FluidDataStoreContext extends TypedEventEmitter<IFluidData
 
         // Add data store's attributes to the summary.
         const { pkg } = await this.getInitialSnapshotDetails();
-        const attributes = createAttributes(pkg, this.isRootDataStore, this.disableIsolatedChannels);
+        const isRoot = await this.isRoot();
+        const attributes = createAttributes(pkg, isRoot, this.disableIsolatedChannels);
         addBlobToSummary(summarizeResult, dataStoreAttributesBlobName, JSON.stringify(attributes));
 
         // Add GC data to the summary if it's not written at the root.
@@ -676,7 +692,9 @@ export abstract class FluidDataStoreContext extends TypedEventEmitter<IFluidData
      * This method should not be used outside of the aliasing context.
      * It will be removed, as the source of truth for this flag will be the aliasing blob.
      */
-    public abstract setRoot(): void;
+    public setInMemoryRoot(): void {
+        this._isInMemoryRoot = true;
+    }
 
     /**
      * @deprecated - Renamed to getBaseGCDetails().
@@ -793,7 +811,7 @@ export class RemoteFluidDataStoreContext extends FluidDataStoreContext {
              * data stores in older documents are not garbage collected incorrectly. This may lead to additional
              * roots in the document but they won't break.
              */
-            isRootDataStore = this.isRootDataStore === true || (attributes.isRootDataStore ?? true);
+            isRootDataStore = attributes.isRootDataStore ?? true;
 
             if (hasIsolatedChannels(attributes)) {
                 tree = tree.trees[channelsTreeName];
@@ -802,11 +820,10 @@ export class RemoteFluidDataStoreContext extends FluidDataStoreContext {
             }
         }
 
-        this.isRootDataStore = isRootDataStore;
-
         return {
             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
             pkg: this.pkg!,
+            isRootDataStore,
             snapshot: tree,
         };
     });
@@ -829,15 +846,6 @@ export class RemoteFluidDataStoreContext extends FluidDataStoreContext {
     public generateAttachMessage(): IAttachMessage {
         throw new Error("Cannot attach remote store");
     }
-
-    /**
-     * @deprecated - Sets the datastore as root, for aliasing purposes: #7948
-     * This method should not be used outside of the aliasing context.
-     * It will be removed, as the source of truth for this flag will be the aliasing blob.
-     */
-    public setRoot(): void {
-        this.isRootDataStore = true;
-    }
 }
 
 /**
@@ -860,7 +868,9 @@ export class LocalFluidDataStoreContextBase extends FluidDataStoreContext {
         );
 
         this.snapshotTree = props.snapshotTree;
-        this.isRootDataStore = props.isRootDataStore ?? false;
+        if (props.isRootDataStore === true) {
+            this.setInMemoryRoot();
+        }
         this.createProps = props.createProps;
         this.attachListeners();
     }
@@ -879,8 +889,6 @@ export class LocalFluidDataStoreContextBase extends FluidDataStoreContext {
     public generateAttachMessage(): IAttachMessage {
         assert(this.channel !== undefined, 0x14f /* "There should be a channel when generating attach message" */);
         assert(this.pkg !== undefined, 0x150 /* "pkg should be available in local data store context" */);
-        assert(this.isRootDataStore !== undefined,
-            0x151 /* "isRootDataStore should be available in local data store context" */);
 
         const summarizeResult = this.channel.getAttachSummary();
 
@@ -892,7 +900,7 @@ export class LocalFluidDataStoreContextBase extends FluidDataStoreContext {
         // Add data store's attributes to the summary.
         const attributes = createAttributes(
             this.pkg,
-            this.isRootDataStore,
+            this.isInMemoryRoot(),
             this.disableIsolatedChannels,
         );
         addBlobToSummary(summarizeResult, dataStoreAttributesBlobName, JSON.stringify(attributes));
@@ -912,6 +920,7 @@ export class LocalFluidDataStoreContextBase extends FluidDataStoreContext {
     protected async getInitialSnapshotDetails(): Promise<ISnapshotDetails> {
         let snapshot = this.snapshotTree;
         let attributes: ReadFluidDataStoreAttributes;
+        let isRootDataStore = false;
         if (snapshot !== undefined) {
             // Get the dataStore attributes.
             // Note: storage can be undefined in special case while detached.
@@ -926,15 +935,17 @@ export class LocalFluidDataStoreContextBase extends FluidDataStoreContext {
                 // If there is no isRootDataStore in the attributes blob, set it to true. This ensures that data
                 // stores in older documents are not garbage collected incorrectly. This may lead to additional
                 // roots in the document but they won't break.
-                this.isRootDataStore = this.isRootDataStore || (attributes.isRootDataStore ?? true);
+                if (attributes.isRootDataStore ?? true) {
+                    isRootDataStore = true;
+                    this.setInMemoryRoot();
+                }
             }
         }
         assert(this.pkg !== undefined, 0x152 /* "pkg should be available in local data store" */);
-        assert(this.isRootDataStore !== undefined,
-            0x153 /* "isRootDataStore should be available in local data store" */);
 
         return {
             pkg: this.pkg,
+            isRootDataStore,
             snapshot,
         };
     }
@@ -951,15 +962,6 @@ export class LocalFluidDataStoreContextBase extends FluidDataStoreContext {
         // Local data store does not have initial summary.
         return {};
     }
-
-    /**
-     * @deprecated - Sets the datastore as root, for aliasing purposes: #7948
-     * This method should not be used outside of the aliasing context.
-     * It will be removed, as the source of truth for this flag will be the aliasing blob.
-     */
-    public setRoot(): void {
-        this.isRootDataStore = true;
-    }
 }
 
 /**
@@ -1009,7 +1011,7 @@ export class LocalDetachedFluidDataStoreContext
 
         super.bindRuntime(dataStoreRuntime);
 
-        if (this.isRootDataStore) {
+        if (await this.isRoot()) {
             dataStoreRuntime.bindToContext();
         }
     }

package/src/dataStores.ts

@@ -194,6 +194,7 @@ export class DataStores implements IDisposable {
         if (this.alreadyProcessed(attachMessage.id)) {
             // TODO: dataStoreId may require a different tag from PackageData #7488
             const error = new DataCorruptionError(
+                // pre-0.58 error message: duplicateDataStoreCreatedWithExistingId
                 "Duplicate DataStore created with existing id",
                 {
                     ...extractSafePropertiesFromMessage(message),
@@ -282,7 +283,7 @@ export class DataStores implements IDisposable {
         }
 
         this.aliasMap.set(aliasMessage.alias, currentContext.id);
-        currentContext.setRoot();
+        currentContext.setInMemoryRoot();
         return true;
     }
 

package/src/garbageCollection.ts

@@ -35,10 +35,9 @@ import {
     MonitoringContext,
     PerformanceEvent,
     TelemetryDataTag,
- } from "@fluidframework/telemetry-utils";
-import { RuntimeHeaders } from ".";
+} from "@fluidframework/telemetry-utils";
 
-import { IGCRuntimeOptions } from "./containerRuntime";
+import { IGCRuntimeOptions, RuntimeHeaders } from "./containerRuntime";
 import { getSummaryForDatastores } from "./dataStores";
 import {
     getGCVersion,
@@ -96,7 +95,7 @@ interface IUnreferencedEvent {
     lastSummaryTime?: number;
     externalRequest?: boolean;
     viaHandle?: boolean;
-};
+}
 
 /** Defines the APIs for the runtime object to be passed to the garbage collector. */
 export interface IGarbageCollectionRuntime {
@@ -186,7 +185,7 @@ class UnreferencedStateTracker {
         }
 
         // The node isn't inactive yet. Restart a timer for the duration remaining for it to become inactive.
-        const remainingDurationMs = this.inactiveTimeoutMs - unreferencedDurationMs; 
+        const remainingDurationMs = this.inactiveTimeoutMs - unreferencedDurationMs;
         if (this.timer === undefined) {
             this.timer = new Timer(remainingDurationMs, () => { this._inactive = true; });
         }
@@ -322,7 +321,7 @@ export class GarbageCollector implements IGarbageCollector {
     // per event per node.
     private readonly loggedUnreferencedEvents: Set<string> = new Set();
     // Queue for unreferenced events that should be logged the next time GC runs.
-    private pendingEventsQueue: IUnreferencedEvent[] = [];
+    private readonly pendingEventsQueue: IUnreferencedEvent[] = [];
 
     protected constructor(
         private readonly provider: IGarbageCollectionRuntime,

package/src/packageVersion.ts

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

package/src/pendingStateManager.ts

@@ -37,8 +37,8 @@ export interface IPendingFlushMode {
 }
 
 /**
- * This represents a manual flush and is added to the pending queue when `flush` is called on the ContainerRuntime to
- * flush any pending messages. This is applicable only when the FlushMode is Manual.
+ * This represents an explicit flush call and is added to the pending queue when flush is called on the ContainerRuntime
+ * to flush pending messages.
  */
 export interface IPendingFlush {
     type: "flush";
@@ -86,6 +86,13 @@ export class PendingStateManager implements IDisposable {
     // the correct batch metadata.
     private pendingBatchBeginMessage: ISequencedDocumentMessage | undefined;
 
+    /**
+     * This tracks the flush mode for the next message in the pending state queue. When replaying messages, we need to
+     * first set the flush mode to this value and then send ops. It is important to do this info because the flush
+     * mode could have been updated.
+     */
+    private flushModeForNextMessage: FlushMode;
+
     private clientId: string | undefined;
 
     private get connected(): boolean {
@@ -115,19 +122,23 @@ export class PendingStateManager implements IDisposable {
     constructor(
         private readonly containerRuntime: ContainerRuntime,
         private readonly applyStashedOp: (type, content) => Promise<unknown>,
-        initialState: IPendingLocalState | undefined,
+        initialFlushMode: FlushMode,
+        initialLocalState: IPendingLocalState | undefined,
     ) {
-        this.initialStates = new Deque<IPendingState>(initialState?.pendingStates ?? []);
+        this.initialStates = new Deque<IPendingState>(initialLocalState?.pendingStates ?? []);
 
-        if (initialState) {
-            if (initialState?.clientId) {
-                this.previousClientIds.add(initialState.clientId);
+        if (initialLocalState) {
+            if (initialLocalState?.clientId) {
+                this.previousClientIds.add(initialLocalState.clientId);
             }
             // get stashed op count and client sequence number of first op
-            const messages = initialState.pendingStates
+            const messages = initialLocalState.pendingStates
                 .filter((state) => state.type === "message") as IPendingMessage[];
             this.firstStashedCSN = messages[0].clientSequenceNumber;
         }
+
+        this.flushModeForNextMessage = initialFlushMode;
+        this.onFlushModeUpdated(initialFlushMode);
     }
 
     public get disposed() { return this.disposeOnce.evaluated; }
@@ -169,54 +180,27 @@ export class PendingStateManager implements IDisposable {
      * @param flushMode - The flushMode that was updated.
      */
     public onFlushModeUpdated(flushMode: FlushMode) {
-        if (flushMode === FlushMode.Immediate) {
-            const previousState = this.pendingStates.peekBack();
-
-            // We don't have to track a previous "flush" state because FlushMode.Immediate flushes the messages. So,
-            // just tracking this FlushMode.Immediate is enough.
-            if (previousState?.type === "flush") {
-                this.pendingStates.removeBack();
-            }
-
-            // If no messages were sent between FlushMode.TurnBased and FlushMode.Immediate,
-            // then we do not have to track both these states.
-            // Remove FlushMode.TurnBased from the pending queue and return.
-            if (previousState?.type === "flushMode" && previousState.flushMode === FlushMode.TurnBased) {
-                this.pendingStates.removeBack();
-                return;
-            }
-        }
-
-        const pendingFlushMode: IPendingFlushMode = {
-            type: "flushMode",
-            flushMode,
-        };
-        this.pendingStates.push(pendingFlushMode);
+        this.pendingStates.push({ type: "flushMode", flushMode });
     }
 
     /**
      * Called when flush() is called on the ContainerRuntime to manually flush messages.
      */
     public onFlush() {
-        // If the FlushMode is Immediate, we should not track this flush call as it is only applicable when FlushMode
-        // is TurnBased.
+        // If the FlushMode is Immediate, we don't need to track an explicit flush call because every message is
+        // automatically flushed. So, flush is a no-op.
         if (this.containerRuntime.flushMode === FlushMode.Immediate) {
             return;
         }
 
-        // If the previous state is not a message, we don't have to track this flush call as there is nothing to flush.
+        // If the previous state is not a message, flush is a no-op.
         const previousState = this.pendingStates.peekBack();
         if (previousState?.type !== "message") {
             return;
         }
 
-        // Note that because of the checks above and the checks in onFlushModeUpdated(), we can be sure that a "flush"
-        // state always has a "message" before and after it. So, it marks the end of a batch and the beginning of a
-        // new one.
-        const pendingFlush: IPendingFlush = {
-            type: "flush",
-        };
-        this.pendingStates.push(pendingFlush);
+        // An explicit flush is interesting and is tracked only if there are messages sent in TurnBased mode.
+        this.pendingStates.push({ type: "flush" });
     }
 
     /**
@@ -249,7 +233,7 @@ export class PendingStateManager implements IDisposable {
      * Processes a local message once it's ack'd by the server to verify that there was no data corruption and that
      * the batch information was preserved for batch messages. Also process remote messages that might have been
      * sent from a previous container.
-     * @param message - The messsage that got ack'd and needs to be processed.
+     * @param message - The message that got ack'd and needs to be processed.
      */
     public processMessage(message: ISequencedDocumentMessage, local: boolean) {
         // Do not process chunked ops until all pieces are available.
@@ -324,7 +308,7 @@ export class PendingStateManager implements IDisposable {
     /**
      * Processes a local message once its ack'd by the server. It verifies that there was no data corruption and that
      * the batch information was preserved for batch messages.
-     * @param message - The messsage that got ack'd and needs to be processed.
+     * @param message - The message that got ack'd and needs to be processed.
      */
     private processPendingLocalMessage(message: ISequencedDocumentMessage): unknown {
         // Pre-processing part - This may be the start of a batch.
@@ -353,9 +337,7 @@ export class PendingStateManager implements IDisposable {
         this.pendingMessagesCount--;
 
         // Post-processing part - If we are processing a batch then this could be the last message in the batch.
-        if (this.isProcessingBatch) {
-            this.maybeProcessBatchEnd(message);
-        }
+        this.maybeProcessBatchEnd(message);
 
         return pendingState.localOpMetadata;
     }
@@ -365,46 +347,82 @@ export class PendingStateManager implements IDisposable {
      * @param message - The message that is being processed.
      */
     private maybeProcessBatchBegin(message: ISequencedDocumentMessage) {
-        const pendingState = this.peekNextPendingState();
-        if (pendingState.type !== "flush" && pendingState.type !== "flushMode") {
-            return;
+        // Tracks the last FlushMode that was set before this message was sent.
+        let pendingFlushMode: FlushMode | undefined;
+        // Tracks whether a flush was called before this message was sent.
+        let pendingFlush: boolean = false;
+
+        /**
+         * We are checking if the next message is the start of a batch. It can happen in the following scenarios:
+         * 1. The FlushMode was set to TurnBased before this message was sent.
+         * 2. The FlushMode was already TurnBased and a flush was called before this message was sent. This essentially
+         *    means that the flush marked the end of a previous batch and beginning of a new batch.
+         *
+         * Keep reading pending states from the queue until we encounter a message. It's possible that the FlushMode was
+         * updated a bunch of times without sending any messages.
+         */
+        let nextPendingState = this.peekNextPendingState();
+        while (nextPendingState.type !== "message") {
+            if (nextPendingState.type === "flushMode") {
+                pendingFlushMode = nextPendingState.flushMode;
+            }
+            if (nextPendingState.type === "flush") {
+                pendingFlush = true;
+            }
+            this.pendingStates.shift();
+            nextPendingState = this.peekNextPendingState();
         }
 
-        // If the pending state is of type "flushMode", it must be Manual since Automatic flush mode is processed
-        // after a message is processed and not before.
-        if (pendingState.type === "flushMode") {
-            assert(pendingState.flushMode === FlushMode.TurnBased,
-                0x16a /* "Flush mode should be manual when processing batch begin" */);
+        if (pendingFlushMode !== undefined) {
+            this.flushModeForNextMessage = pendingFlushMode;
         }
 
-        // We should not already be processing a batch and there should be no pending batch begin message.
-        assert(!this.isProcessingBatch && this.pendingBatchBeginMessage === undefined,
-            0x16b /* "The pending batch state indicates we are already processing a batch" */);
-
-        // Set the pending batch state indicating we have started processing a batch.
-        this.pendingBatchBeginMessage = message;
-        this.isProcessingBatch = true;
+        // If the FlushMode was set to Immediate before this message was sent, this message won't be a batch message
+        // because in Immediate mode, every message is flushed individually.
+        if (pendingFlushMode === FlushMode.Immediate) {
+            return;
+        }
 
-        // Remove this pending state from the queue as we have processed it.
-        this.pendingStates.shift();
+        /**
+         * This message is the first in a batch if before it was sent either the FlushMode was set to TurnBased or there
+         * was an explicit flush call. Note that a flush call is tracked only in TurnBased mode and it indicates the end
+         * of one batch and beginning of another.
+         */
+        if (pendingFlushMode === FlushMode.TurnBased || pendingFlush) {
+            // We should not already be processing a batch and there should be no pending batch begin message.
+            assert(!this.isProcessingBatch && this.pendingBatchBeginMessage === undefined,
+                0x16b /* "The pending batch state indicates we are already processing a batch" */);
+
+            // Set the pending batch state indicating we have started processing a batch.
+            this.pendingBatchBeginMessage = message;
+            this.isProcessingBatch = true;
+        }
     }
 
+    /**
+     * This message could be the last message in batch. If so, clear batch state since the batch is complete.
+     * @param message - The message that is being processed.
+     */
     private maybeProcessBatchEnd(message: ISequencedDocumentMessage) {
-        const nextPendingState = this.peekNextPendingState();
-        if (nextPendingState.type !== "flush" && nextPendingState.type !== "flushMode") {
+        if (!this.isProcessingBatch) {
             return;
         }
 
-        // If the next pending state is of type "flushMode", it must be Immediate and if so, we need to remove it from
-        // the queue.
-        // Note that we do not remove the type "flush" from the queue because it indicates the end of one batch and the
-        // beginning of a new one. So, it will removed when the next batch begin is processed.
-        if (nextPendingState.type === "flushMode") {
-            assert(nextPendingState.flushMode === FlushMode.Immediate,
-                0x16c /* "Flush mode is set to TurnBased in the middle of processing a batch" */);
-            this.pendingStates.shift();
+        const nextPendingState = this.peekNextPendingState();
+        if (nextPendingState.type === "message") {
+            return;
         }
 
+        /**
+         * We are in the middle of processing a batch. The batch ends when we see an explicit flush. We should never see
+         * a FlushMode before flush. This is true because we track batches only when FlushMode is TurnBased and in this
+         * mode, a batch ends either by calling flush or by changing the mode to Immediate which also triggers a flush.
+         */
+        assert(
+            nextPendingState.type !== "flushMode",
+            0x2bd /* "We should not see a pending FlushMode until we see a flush when processing a batch" */,
+        );
+
         // There should be a pending batch begin message.
         assert(this.pendingBatchBeginMessage !== undefined, 0x16d /* "There is no pending batch begin message" */);
 
@@ -462,6 +480,10 @@ export class PendingStateManager implements IDisposable {
         // Save the current FlushMode so that we can revert it back after replaying the states.
         const savedFlushMode = this.containerRuntime.flushMode;
 
+        // Set the flush mode for the next message. This step is important because the flush mode may have been changed
+        // after the next pending message was sent.
+        this.containerRuntime.setFlushMode(this.flushModeForNextMessage);
+
         // Process exactly `pendingStatesCount` items in the queue as it represents the number of states that were
         // pending when we connected. This is important because the `reSubmitFn` might add more items in the queue
         // which must not be replayed.
@@ -470,23 +492,17 @@ export class PendingStateManager implements IDisposable {
             const pendingState = this.pendingStates.shift()!;
             switch (pendingState.type) {
                 case "message":
-                    {
-                        this.containerRuntime.reSubmitFn(
-                            pendingState.messageType,
-                            pendingState.content,
-                            pendingState.localOpMetadata,
-                            pendingState.opMetadata);
-                    }
+                    this.containerRuntime.reSubmitFn(
+                        pendingState.messageType,
+                        pendingState.content,
+                        pendingState.localOpMetadata,
+                        pendingState.opMetadata);
                     break;
                 case "flushMode":
-                    {
-                        this.containerRuntime.setFlushMode(pendingState.flushMode);
-                    }
+                    this.containerRuntime.setFlushMode(pendingState.flushMode);
                     break;
                 case "flush":
-                    {
-                        this.containerRuntime.flush();
-                    }
+                    this.containerRuntime.flush();
                     break;
                 default:
                     break;