Fix assert 0xb7b

packages/runtime/container-runtime/src/opLifecycle/outbox.ts

@@ -316,7 +316,7 @@ 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();
+			this.flush();
 			return;
 		}
 
@@ -365,14 +365,6 @@ export class Outbox {
 	 * @param resubmitInfo - Key information when flushing a resubmitted batch. Undefined means this is not resubmit.
 	 */
 	public flush(resubmitInfo?: BatchResubmitInfo): void {
-		assert(
-			!this.isContextReentrant(),
-			0xb7b /* Flushing must not happen while incoming changes are being processed */,
-		);
-		this.flushAll(resubmitInfo);
-	}
-
-	private flushAll(resubmitInfo?: BatchResubmitInfo): void {
 		const allBatchesEmpty =
 			this.idAllocationBatch.empty && this.blobAttachBatch.empty && this.mainBatch.empty;
 		if (allBatchesEmpty) {
@@ -387,6 +379,11 @@ export class Outbox {
 			return;
 		}
 
+		assert(
+			!this.isContextReentrant(),
+			0xb7b /* Flushing must not happen while incoming changes are being processed */,
+		);
+
 		// Don't use resubmittingBatchId for idAllocationBatch.
 		// ID Allocation messages are not directly resubmitted so don't pass the resubmitInfo
 		this.flushInternal({
@@ -409,6 +406,11 @@ export class Outbox {
 		resubmittingBatchId: BatchId,
 		resubmittingStagedBatch: boolean,
 	): void {
+		assert(
+			!this.isContextReentrant(),
+			"Flushing must not happen while incoming changes are being processed",
+		);
+
 		const referenceSequenceNumber =
 			this.params.getCurrentSequenceNumbers().referenceSequenceNumber;
 		assert(

packages/runtime/container-runtime/src/test/opLifecycle/outbox.spec.ts

@@ -17,6 +17,7 @@ import type {
 	ISequencedDocumentMessage,
 } from "@fluidframework/driver-definitions/internal";
 import { MockLogger } from "@fluidframework/telemetry-utils/internal";
+import { validateAssertionError } from "@fluidframework/test-runtime-utils/internal";
 
 import type { ICompressionRuntimeOptions } from "../../compressionDefinitions.js";
 import { CompressionAlgorithms } from "../../compressionDefinitions.js";
@@ -1092,6 +1093,57 @@ describe("Outbox", () => {
 			assert.strictEqual(state.opsResubmitted, opsResubmitted, "unexpected opsResubmitted");
 		}
 
+		it("should not assert when flushing while reentrant with empty batches", () => {
+			const outbox = getOutbox({
+				context: getMockContext(),
+				opGroupingConfig: {
+					groupedBatchingEnabled: true,
+				},
+			});
+
+			// Mark context as reentrant
+			state.isReentrant = true;
+
+			// Flush with no messages - should not throw
+			assert.doesNotThrow(() => {
+				outbox.flush();
+			}, "Should not assert when flushing empty batches while reentrant");
+
+			validateCounts(0, 0, 0);
+		});
+
+		it("should assert when flushing while reentrant with non-empty batches", () => {
+			const outbox = getOutbox({
+				context: getMockContext(),
+				opGroupingConfig: {
+					groupedBatchingEnabled: true,
+				},
+			});
+
+			const messages = [createMessage(ContainerMessageType.FluidDataStoreOp, "0")];
+
+			// Submit a message (not reentrant)
+			state.isReentrant = false;
+			outbox.submit(messages[0]);
+
+			// Now mark context as reentrant and try to flush - should throw
+			state.isReentrant = true;
+
+			assert.throws(
+				() => outbox.flush(),
+				(error: Error) => {
+					return validateAssertionError(
+						error,
+						"Flushing must not happen while incoming changes are being processed",
+					);
+				},
+				"Should assert when flushing non-empty batches while reentrant",
+			);
+
+			// Verify nothing was submitted
+			validateCounts(0, 0, 0);
+		});
+
 		it("batch has reentrant ops, but grouped batching is off", () => {
 			const outbox = getOutbox({
 				context: getMockContext(),