@fluidframework/container-runtime 2.2.0 → 2.3.0

package/src/deltaManagerProxies.ts

@@ -208,10 +208,17 @@ export class DeltaManagerSummarizerProxy extends BaseDeltaManagerProxy {
 export class DeltaManagerPendingOpsProxy extends BaseDeltaManagerProxy {
 	public get minimumSequenceNumber(): number {
 		const minPendingSeqNum = this.pendingStateManager.minimumPendingMessageSequenceNumber;
-		// There is a chance that minPendingSeqNum is greater than minimum sequence number.
-		// minPendingSeqNum is based on the pending ops, so it's based on ref seq number.
-		// Imagine an op has just be sent while there's another client that has been lagging behind,
-		// it will likely have a ref seq number greater than the minimum seq number.
+		/**
+		 * The reason why the minimum pending sequence number can be less than the delta manager's minimum sequence
+		 * number (DM's msn) is that when we are processing messages in the container runtime/delta manager, the delta
+		 * manager's msn can be updated to continually increase. In the meantime, the pending state manager's op which
+		 * hasn't been sent can still have a lower sequence number than the DM's msn (think about a disconnected
+		 * scenario). To successfully resubmit that pending op it has to be rebased first by the DDS. The DDS still
+		 * needs to keep the local data for that op that has a reference sequence number lower than the DM's msn. To
+		 * achieve this, the msn passed to the DDS needs to be the minimum of the DM's msn and the minimum pending
+		 * sequence number, so that it can keep the relevant local data to generate the right data for the new op
+		 * during resubmission.
+		 */
 		if (
 			minPendingSeqNum !== undefined &&
 			minPendingSeqNum < this.deltaManager.minimumSequenceNumber

package/src/gc/garbageCollection.ts

@@ -789,9 +789,7 @@ export class GarbageCollector implements IGarbageCollector {
 				if (gcDataSuperSet.gcNodes[sourceNodeId] === undefined) {
 					gcDataSuperSet.gcNodes[sourceNodeId] = outboundRoutes;
 				} else {
-					// Non null asserting here because we are checking if it is undefined above.
-					// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-					gcDataSuperSet.gcNodes[sourceNodeId]!.push(...outboundRoutes);
+					gcDataSuperSet.gcNodes[sourceNodeId].push(...outboundRoutes);
 				}
 				newOutboundRoutesSinceLastRun.push(...outboundRoutes);
 			},

package/src/gc/gcHelpers.ts

@@ -166,9 +166,7 @@ export function concatGarbageCollectionData(
 		if (combinedGCData.gcNodes[id] === undefined) {
 			combinedGCData.gcNodes[id] = Array.from(routes);
 		} else {
-			// Non null asserting here since we are checking if combinedGCData.gcNodes[id] is not undefined above.
-			// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-			const combinedRoutes = [...routes, ...combinedGCData.gcNodes[id]!];
+			const combinedRoutes = [...routes, ...combinedGCData.gcNodes[id]];
 			combinedGCData.gcNodes[id] = [...new Set(combinedRoutes)];
 		}
 	}
@@ -189,17 +187,13 @@ export async function getGCDataFromSnapshot(
 	for (const key of Object.keys(gcSnapshotTree.blobs)) {
 		// Update deleted nodes blob.
 		if (key === gcDeletedBlobKey) {
-			// Non null asserting here, we can change this to Object.entries later
-			// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-			deletedNodes = await readAndParseBlob<string[]>(gcSnapshotTree.blobs[key]!);
+			deletedNodes = await readAndParseBlob<string[]>(gcSnapshotTree.blobs[key]);
 			continue;
 		}
 
 		// Update tombstone blob.
 		if (key === gcTombstoneBlobKey) {
-			// Non null asserting here, we can change this to Object.entries later
-			// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-			tombstones = await readAndParseBlob<string[]>(gcSnapshotTree.blobs[key]!);
+			tombstones = await readAndParseBlob<string[]>(gcSnapshotTree.blobs[key]);
 			continue;
 		}
 
@@ -302,9 +296,7 @@ function trimLeadingAndTrailingSlashes(str: string) {
 
 /** Reformats a request URL to match expected format for a GC node path */
 export function urlToGCNodePath(url: string): string {
-	// TODO Why are we non null asserting here
-	// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-	return `/${trimLeadingAndTrailingSlashes(url.split("?")[0]!)}`;
+	return `/${trimLeadingAndTrailingSlashes(url.split("?")[0])}`;
 }
 
 /**

package/src/index.ts

@@ -10,6 +10,8 @@ export {
 	ISummaryConfigurationDisableSummarizer,
 	ISummaryConfigurationDisableHeuristics,
 	IContainerRuntimeOptions,
+	loadContainerRuntime,
+	LoadContainerRuntimeParams,
 	isRuntimeMessage,
 	agentSchedulerId,
 	ContainerRuntime,

package/src/messageTypes.ts

@@ -223,16 +223,6 @@ export type InboundSequencedContainerRuntimeMessage = Omit<
 > &
 	InboundContainerRuntimeMessage;
 
-/** Essentially ISequencedDocumentMessage except that `type` is not `string` to enable narrowing
- * as `Exclude<string, InboundContainerRuntimeMessage['type']>` is not supported.
- * There should never be a runtime value of "__not_a_...".
- * Currently additionally replaces `contents` type until protocol-definitions update is taken with `unknown` instead of `any`.
- */
-export type InboundSequencedNonContainerRuntimeMessage = Omit<
-	ISequencedDocumentMessage,
-	"type" | "contents"
-> & { type: "__not_a_container_runtime_message_type__"; contents: unknown };
-
 /** A [loose] InboundSequencedContainerRuntimeMessage that is recent and may contain compat details.
  * It exists solely to to provide access to those details.
  */

package/src/opLifecycle/batchManager.ts

@@ -6,9 +6,11 @@
 import { assert } from "@fluidframework/core-utils/internal";
 
 import { ICompressionRuntimeOptions } from "../containerRuntime.js";
-import { type IBatchMetadata } from "../metadata.js";
+import { asBatchMetadata, type IBatchMetadata } from "../metadata.js";
+import type { IPendingMessage } from "../pendingStateManager.js";
 
 import { BatchMessage, IBatch, IBatchCheckpoint } from "./definitions.js";
+import type { BatchStartInfo } from "./remoteMessageProcessor.js";
 
 export interface IBatchManagerOptions {
 	readonly hardLimit: number;
@@ -33,6 +35,30 @@ export function generateBatchId(originalClientId: string, batchStartCsn: number)
 	return `${originalClientId}_[${batchStartCsn}]`;
 }
 
+/**
+ * Get the effective batch ID for the input argument.
+ * Supports either an IPendingMessage or BatchStartInfo.
+ * If the batch ID is explicitly present, return it.
+ * Otherwise, generate a new batch ID using the client ID and batch start CSN.
+ */
+export function getEffectiveBatchId(
+	pendingMessageOrBatchStartInfo: IPendingMessage | BatchStartInfo,
+): string {
+	if ("localOpMetadata" in pendingMessageOrBatchStartInfo) {
+		const pendingMessage: IPendingMessage = pendingMessageOrBatchStartInfo;
+		return (
+			asBatchMetadata(pendingMessage.opMetadata)?.batchId ??
+			generateBatchId(
+				pendingMessage.batchInfo.clientId,
+				pendingMessage.batchInfo.batchStartCsn,
+			)
+		);
+	}
+
+	const batchStart: BatchStartInfo = pendingMessageOrBatchStartInfo;
+	return batchStart.batchId ?? generateBatchId(batchStart.clientId, batchStart.batchStartCsn);
+}
+
 /**
  * Estimated size of the stringification overhead for an op accumulated
  * from runtime to loader to the service.
@@ -64,9 +90,7 @@ export class BatchManager {
 	private get referenceSequenceNumber(): number | undefined {
 		return this.pendingBatch.length === 0
 			? undefined
-			: // Non null asserting here since we are checking the length above
-				// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-				this.pendingBatch[this.pendingBatch.length - 1]!.referenceSequenceNumber;
+			: this.pendingBatch[this.pendingBatch.length - 1].referenceSequenceNumber;
 	}
 
 	/**
@@ -138,9 +162,7 @@ export class BatchManager {
 			rollback: (process: (message: BatchMessage) => void) => {
 				for (let i = this.pendingBatch.length; i > startPoint; ) {
 					i--;
-					// Non null asserting here since we are iterating though pendingBatch
-					// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-					const message = this.pendingBatch[i]!;
+					const message = this.pendingBatch[i];
 					this.batchContentSize -= message.contents?.length ?? 0;
 					process(message);
 				}

package/src/opLifecycle/duplicateBatchDetector.ts

@@ -0,0 +1,78 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { assert } from "@fluidframework/core-utils/internal";
+
+import { getEffectiveBatchId } from "./batchManager.js";
+import { type BatchStartInfo } from "./remoteMessageProcessor.js";
+
+/**
+ * This class tracks recent batchIds we've seen, and checks incoming batches for duplicates.
+ */
+export class DuplicateBatchDetector {
+	/** All batchIds we've seen recently enough (based on MSN) that we need to watch for duplicates */
+	private readonly batchIdsAll = new Set<string>();
+
+	/** We map from sequenceNumber to batchId to find which ones we can stop tracking as MSN advances */
+	private readonly batchIdsBySeqNum = new Map<number, string>();
+
+	/**
+	 * Records this batch's batchId, and checks if it's a duplicate of a batch we've already seen.
+	 * If it's a duplicate, also return the sequence number of the other batch for logging.
+	 *
+	 * @remarks - We also use the minimumSequenceNumber to clear out old batchIds that are no longer at risk for duplicates.
+	 */
+	public processInboundBatch(
+		batchStart: BatchStartInfo,
+	): { duplicate: true; otherSequenceNumber: number } | { duplicate: false } {
+		const { sequenceNumber, minimumSequenceNumber } = batchStart.keyMessage;
+
+		// Glance at this batch's MSN. Any batchIds we're tracking with a lower sequence number are now safe to forget.
+		// Why? Because any other client holding the same batch locally would have seen the earlier batch and closed before submitting its duplicate.
+		this.clearOldBatchIds(minimumSequenceNumber);
+
+		// getEffectiveBatchId is only needed in the SUPER rare/surprising case where
+		// the original batch (not resubmitted, so no batchId) arrives in parallel with a resubmitted batch.
+		// In the presence of typical network conditions, this would not be possible
+		// (the original batch should roundtrip WAY before another container could rehydrate, connect, and resubmit)
+		const batchId = getEffectiveBatchId(batchStart);
+
+		// Check this batch against the tracked batchIds to see if it's a duplicate
+		if (this.batchIdsAll.has(batchId)) {
+			for (const [otherSequenceNumber, otherBatchId] of this.batchIdsBySeqNum.entries()) {
+				if (otherBatchId === batchId) {
+					return {
+						duplicate: true,
+						otherSequenceNumber,
+					};
+				}
+			}
+			assert(false, 0xa34 /* Should have found the batchId in batchIdBySeqNum map */);
+		}
+
+		// Now we know it's not a duplicate, so add it to the tracked batchIds and return.
+		assert(
+			!this.batchIdsBySeqNum.has(sequenceNumber),
+			0xa35 /* batchIdsAll and batchIdsBySeqNum should be in sync */,
+		);
+		this.batchIdsBySeqNum.set(sequenceNumber, batchId);
+		this.batchIdsAll.add(batchId);
+
+		return { duplicate: false };
+	}
+
+	/**
+	 * Batches that started before the MSN are not at risk for a sequenced duplicate to arrive,
+	 * since the batch start has been processed by all clients, and local batches are deduped and the forked client would close.
+	 */
+	private clearOldBatchIds(msn: number) {
+		this.batchIdsBySeqNum.forEach((batchId, sequenceNumber) => {
+			if (sequenceNumber < msn) {
+				this.batchIdsBySeqNum.delete(sequenceNumber);
+				this.batchIdsAll.delete(batchId);
+			}
+		});
+	}
+}

package/src/opLifecycle/index.ts

@@ -8,17 +8,20 @@ export {
 	BatchManager,
 	BatchSequenceNumbers,
 	estimateSocketSize,
+	getEffectiveBatchId,
 	generateBatchId,
 	IBatchManagerOptions,
 } from "./batchManager.js";
 export { BatchMessage, IBatch, IBatchCheckpoint, IChunkedOp } from "./definitions.js";
+export { DuplicateBatchDetector } from "./duplicateBatchDetector.js";
 export { Outbox, getLongStack } from "./outbox.js";
 export { OpCompressor } from "./opCompressor.js";
 export { OpDecompressor } from "./opDecompressor.js";
 export { OpSplitter, splitOp, isChunkedMessage } from "./opSplitter.js";
 export {
 	ensureContentsDeserialized,
-	InboundBatch,
+	InboundMessageResult,
+	BatchStartInfo,
 	RemoteMessageProcessor,
 	unpackRuntimeMessage,
 } from "./remoteMessageProcessor.js";

package/src/opLifecycle/opCompressor.ts

@@ -47,13 +47,9 @@ export class OpCompressor {
 
 		const messages: BatchMessage[] = [];
 		messages.push({
-			// Non null asserting here because of the length assert above
-			// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-			...batch.messages[0]!,
+			...batch.messages[0],
 			contents: JSON.stringify({ packedContents: compressedContent }),
-			// Non null asserting here because of the length assert above
-			// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-			metadata: batch.messages[0]!.metadata,
+			metadata: batch.messages[0].metadata,
 			compression: CompressionAlgorithms.lz4,
 		});
 

package/src/opLifecycle/opGroupingManager.ts

@@ -99,9 +99,7 @@ export class OpGroupingManager {
 				length: batch.messages.length,
 				threshold: this.config.opCountThreshold,
 				reentrant: batch.hasReentrantOps,
-				// Non null asserting here because of the length check above
-				// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-				referenceSequenceNumber: batch.messages[0]!.referenceSequenceNumber,
+				referenceSequenceNumber: batch.messages[0].referenceSequenceNumber,
 			});
 		}
 		// We expect this will be on the first message, if present at all.
@@ -130,9 +128,7 @@ export class OpGroupingManager {
 			messages: [
 				{
 					metadata: { batchId: groupedBatchId },
-					// TODO why are we non null asserting here?
-					// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-					referenceSequenceNumber: batch.messages[0]!.referenceSequenceNumber,
+					referenceSequenceNumber: batch.messages[0].referenceSequenceNumber,
 					contents: serializedContent,
 				},
 			],

package/src/opLifecycle/opSplitter.ts

@@ -134,9 +134,7 @@ export class OpSplitter {
 			0x516 /* Chunk size needs to be smaller than the max batch size */,
 		);
 
-		// Non null asserting here because of the length check above
-		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-		const firstMessage = batch.messages[0]!; // we expect this to be the large compressed op, which needs to be split
+		const firstMessage = batch.messages[0]; // we expect this to be the large compressed op, which needs to be split
 		assert(
 			(firstMessage.contents?.length ?? 0) >= this.chunkSizeInBytes,
 			0x518 /* First message in the batch needs to be chunkable */,
@@ -165,9 +163,7 @@ export class OpSplitter {
 		// The last chunk will be part of the new batch and needs to
 		// preserve the batch metadata of the original batch
 		const lastChunk = chunkToBatchMessage(
-			// Non null asserting here because of the length assert above
-			// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-			chunks[chunks.length - 1]!,
+			chunks[chunks.length - 1],
 			batch.referenceSequenceNumber,
 			{ batch: firstMessage.metadata?.batch },
 		);

package/src/opLifecycle/outbox.ts

@@ -446,9 +446,7 @@ export class Outbox {
 			// Legacy path - supporting old loader versions. Can be removed only when LTS moves above
 			// version that has support for batches (submitBatchFn)
 			assert(
-				// Non null asserting here because of the length check above
-				// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-				batch.messages[0]!.compression === undefined,
+				batch.messages[0].compression === undefined,
 				0x5a6 /* Compression should not have happened if the loader does not support it */,
 			);
 

package/src/opLifecycle/remoteMessageProcessor.ts

@@ -21,26 +21,56 @@ import { OpDecompressor } from "./opDecompressor.js";
 import { OpGroupingManager, isGroupedBatch } from "./opGroupingManager.js";
 import { OpSplitter, isChunkedMessage } from "./opSplitter.js";
 
-/** Messages being received as a batch, with details needed to process the batch */
-export interface InboundBatch {
-	/** Messages in this batch */
-	readonly messages: InboundSequencedContainerRuntimeMessage[];
+/** Info about the batch we learn when we process the first message */
+export interface BatchStartInfo {
 	/** Batch ID, if present */
 	readonly batchId: string | undefined;
 	/** clientId that sent this batch. Used to compute Batch ID if needed */
 	readonly clientId: string;
 	/**
-	 * Client Sequence Number of the first message in the batch.
+	 * Client Sequence Number of the Grouped Batch message, or the first message in the ungrouped batch.
 	 * Used to compute Batch ID if needed
 	 *
 	 * @remarks For chunked batches, this is the CSN of the "representative" chunk (the final chunk).
 	 * For grouped batches, clientSequenceNumber on messages is overwritten, so we track this original value here.
 	 */
 	readonly batchStartCsn: number;
-	/** For an empty batch (with no messages), we need to remember the empty grouped batch's sequence number */
-	readonly emptyBatchSequenceNumber?: number;
+	/**
+	 * The first message in the batch, or if the batch is empty, the empty grouped batch message.
+	 * Used for accessing the sequence numbers for the (start of the) batch.
+	 *
+	 * @remarks Do not use clientSequenceNumber here, use batchStartCsn instead.
+	 */
+	readonly keyMessage: ISequencedDocumentMessage;
 }
 
+/**
+ * Result of processing the next inbound message.
+ * Depending on the message and configuration of RemoteMessageProcessor, the result may be:
+ * - A full batch of messages (including a single-message batch)
+ * - The first message of a multi-message batch
+ * - The next message in a multi-message batch
+ */
+export type InboundMessageResult =
+	| {
+			type: "fullBatch";
+			messages: InboundSequencedContainerRuntimeMessage[];
+			batchStart: BatchStartInfo;
+			length: number;
+	  }
+	| {
+			type: "batchStartingMessage";
+			batchStart: BatchStartInfo;
+			nextMessage: InboundSequencedContainerRuntimeMessage;
+			length?: never;
+	  }
+	| {
+			type: "nextBatchMessage";
+			batchEnd?: boolean;
+			nextMessage: InboundSequencedContainerRuntimeMessage;
+			length?: never;
+	  };
+
 function assertHasClientId(
 	message: ISequencedDocumentMessage,
 ): asserts message is ISequencedDocumentMessage & { clientId: string } {
@@ -57,12 +87,7 @@ function assertHasClientId(
  * @internal
  */
 export class RemoteMessageProcessor {
-	/**
-	 * The current batch being received, with details needed to process it.
-	 *
-	 * @remarks If undefined, we are expecting the next message to start a new batch.
-	 */
-	private batchInProgress: InboundBatch | undefined;
+	private batchInProgress: boolean = false;
 
 	constructor(
 		private readonly opSplitter: OpSplitter,
@@ -100,7 +125,7 @@ export class RemoteMessageProcessor {
 	public process(
 		remoteMessageCopy: ISequencedDocumentMessage,
 		logLegacyCase: (codePath: string) => void,
-	): InboundBatch | undefined {
+	): InboundMessageResult | undefined {
 		let message = remoteMessageCopy;
 
 		assertHasClientId(message);
@@ -129,80 +154,84 @@ export class RemoteMessageProcessor {
 		}
 
 		if (isGroupedBatch(message)) {
-			// We should be awaiting a new batch (batchInProgress undefined)
-			assert(
-				this.batchInProgress === undefined,
-				0x9d3 /* Grouped batch interrupting another batch */,
-			);
+			// We should be awaiting a new batch (batchInProgress false)
+			assert(!this.batchInProgress, 0x9d3 /* Grouped batch interrupting another batch */);
 			const batchId = asBatchMetadata(message.metadata)?.batchId;
 			const groupedMessages = this.opGroupingManager.ungroupOp(message).map(unpack);
+
 			return {
+				type: "fullBatch",
 				messages: groupedMessages, // Will be [] for an empty batch
-				batchStartCsn: message.clientSequenceNumber,
-				clientId,
-				batchId,
-				// If the batch is empty, we need to return the sequence number aside
-				emptyBatchSequenceNumber:
-					groupedMessages.length === 0 ? message.sequenceNumber : undefined,
+				batchStart: {
+					batchStartCsn: message.clientSequenceNumber,
+					clientId,
+					batchId,
+					keyMessage: groupedMessages[0] ?? message, // For an empty batch, this is the empty grouped batch message. Needed for sequence numbers for this batch
+				},
+				length: groupedMessages.length, // Will be 0 for an empty batch
 			};
 		}
 
 		// Do a final unpack of runtime messages in case the message was not grouped, compressed, or chunked
 		unpackRuntimeMessage(message, logLegacyCase);
 
-		const { batchEnded } = this.addMessageToBatch(
+		return this.getResultBasedOnBatchMetadata(
 			message as InboundSequencedContainerRuntimeMessage & { clientId: string },
 		);
-
-		if (!batchEnded) {
-			// batch not yet complete
-			return undefined;
-		}
-
-		const completedBatch = this.batchInProgress;
-		this.batchInProgress = undefined;
-		return completedBatch;
 	}
 
 	/**
-	 * Add the given message to the current batch, and indicate whether the batch is now complete.
-	 *
-	 * @returns batchEnded: true if the batch is now complete, batchEnded: false if more messages are expected
+	 * Now that the message has been "unwrapped" as to any virtualization (grouping, compression, chunking),
+	 * inspect the batch metadata flag and determine what kind of result to return.
 	 */
-	private addMessageToBatch(
+	private getResultBasedOnBatchMetadata(
 		message: InboundSequencedContainerRuntimeMessage & { clientId: string },
-	): { batchEnded: boolean } {
+	): InboundMessageResult {
 		const batchMetadataFlag = asBatchMetadata(message.metadata)?.batch;
-		if (this.batchInProgress === undefined) {
+		if (!this.batchInProgress) {
 			// We are waiting for a new batch
 			assert(batchMetadataFlag !== false, 0x9d5 /* Unexpected batch end marker */);
 
 			// Start of a new multi-message batch
 			if (batchMetadataFlag === true) {
-				this.batchInProgress = {
-					messages: [message],
-					batchId: asBatchMetadata(message.metadata)?.batchId,
-					clientId: message.clientId,
-					batchStartCsn: message.clientSequenceNumber,
+				this.batchInProgress = true;
+				return {
+					type: "batchStartingMessage",
+					batchStart: {
+						batchId: asBatchMetadata(message.metadata)?.batchId,
+						clientId: message.clientId,
+						batchStartCsn: message.clientSequenceNumber,
+						keyMessage: message,
+					},
+					nextMessage: message,
 				};
-
-				return { batchEnded: false };
 			}
 
 			// Single-message batch (Since metadata flag is undefined)
-			this.batchInProgress = {
+			return {
+				type: "fullBatch",
 				messages: [message],
-				batchStartCsn: message.clientSequenceNumber,
-				clientId: message.clientId,
-				batchId: asBatchMetadata(message.metadata)?.batchId,
+				batchStart: {
+					batchStartCsn: message.clientSequenceNumber,
+					clientId: message.clientId,
+					batchId: asBatchMetadata(message.metadata)?.batchId,
+					keyMessage: message,
+				},
+				length: 1,
 			};
-			return { batchEnded: true };
 		}
 		assert(batchMetadataFlag !== true, 0x9d6 /* Unexpected batch start marker */);
 
-		this.batchInProgress.messages.push(message);
+		// Clear batchInProgress state if the batch is ending
+		if (batchMetadataFlag === false) {
+			this.batchInProgress = false;
+		}
 
-		return { batchEnded: batchMetadataFlag === false };
+		return {
+			type: "nextBatchMessage",
+			nextMessage: message,
+			batchEnd: batchMetadataFlag === false,
+		};
 	}
 }
 
@@ -217,10 +246,9 @@ export function ensureContentsDeserialized(
 	hasModernRuntimeMessageEnvelope: boolean,
 	logLegacyCase: (codePath: string) => void,
 ): void {
-	// Currently the loader layer is parsing the contents of the message as JSON if it is a string,
-	// so we never expect to see this case.
-	// We intend to remove that logic from the Loader, at which point we will have it here.
-	// Only hasModernRuntimeMessageEnvelope true will be expected to have JSON contents.
+	// This should become unconditional once (Loader LTS) DeltaManager.processInboundMessage() stops parsing content (ADO #12052)
+	// Note: Until that change is made in the loader, this case will never be hit.
+	// Then there will be a long time of needing both cases, until LTS catches up to the change.
 	let didParseJsonContents: boolean;
 	if (typeof mutableMessage.contents === "string" && mutableMessage.contents !== "") {
 		mutableMessage.contents = JSON.parse(mutableMessage.contents);

package/src/packageVersion.ts

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