@fluidframework/container-runtime 2.1.0 → 2.3.0-288113

package/src/gc/gcHelpers.ts

@@ -240,10 +240,11 @@ export function unpackChildNodesGCDetails(gcDetails: IGarbageCollectionDetailsBa
 			continue;
 		}
 
-		assert(id.startsWith("/"), 0x5d9 /* node id should always be an absolute route */);
-		// TODO Why are we non null asserting here
-		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-		const childId = id.split("/")[1]!;
+		const childId = id.split("/")[1];
+		assert(
+			childId !== undefined,
+			0x9fe /* node id should be an absolute route with child id part */,
+		);
 		let childGCNodeId = id.slice(childId.length + 1);
 		// GC node id always begins with "/". Handle the special case where a child's id in the parent's GC nodes is
 		// of format `/root`. In this case, the childId is root and childGCNodeId is "". Make childGCNodeId = "/".
@@ -271,10 +272,11 @@ export function unpackChildNodesGCDetails(gcDetails: IGarbageCollectionDetailsBa
 	// Remove the node's self used route, if any, and generate the children used routes.
 	const usedRoutes = gcDetails.usedRoutes.filter((route) => route !== "" && route !== "/");
 	for (const route of usedRoutes) {
-		assert(route.startsWith("/"), 0x5db /* Used route should always be an absolute route */);
-		// TODO Why are we non null asserting here
-		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-		const childId = route.split("/")[1]!;
+		const childId = route.split("/")[1];
+		assert(
+			childId !== undefined,
+			0x9ff /* used route should be an absolute route with child id part */,
+		);
 		const childUsedRoute = route.slice(childId.length + 1);
 
 		const childGCDetails = childGCDetailsMap.get(childId);

package/src/gc/gcSummaryStateTracker.ts

@@ -66,7 +66,7 @@ export class GCSummaryStateTracker {
 		// Tells whether GC should run or not.
 		private readonly configs: Pick<
 			IGarbageCollectorConfigs,
-			"gcEnabled" | "tombstoneMode" | "gcVersionInBaseSnapshot" | "gcVersionInEffect"
+			"gcAllowed" | "gcVersionInBaseSnapshot" | "gcVersionInEffect"
 		>,
 	) {}
 
@@ -100,7 +100,7 @@ export class GCSummaryStateTracker {
 		deletedNodes: Set<string>,
 		tombstones: string[],
 	): ISummarizeResult | undefined {
-		if (!this.configs.gcEnabled) {
+		if (!this.configs.gcAllowed) {
 			return;
 		}
 
@@ -109,12 +109,9 @@ export class GCSummaryStateTracker {
 		// to identify deleted nodes' usage.
 		const serializedDeletedNodes =
 			deletedNodes.size > 0 ? JSON.stringify(Array.from(deletedNodes).sort()) : undefined;
-		// If running in tombstone mode, serialize and write tombstones, if any.
-		const serializedTombstones = this.configs.tombstoneMode
-			? tombstones.length > 0
-				? JSON.stringify(tombstones.sort())
-				: undefined
-			: undefined;
+		// Serialize and write tombstones, if any.
+		const serializedTombstones =
+			tombstones.length > 0 ? JSON.stringify(tombstones.sort()) : undefined;
 
 		/**
 		 * Incremental summary of GC data - If none of GC state, deleted nodes or tombstones changed since last summary,
@@ -231,7 +228,7 @@ export class GCSummaryStateTracker {
 	 * Called to refresh the latest summary state. This happens when a pending summary is acked.
 	 */
 	public async refreshLatestSummary(result: IRefreshSummaryResult): Promise<void> {
-		if (!this.configs.gcEnabled || !result.isSummaryTracked) {
+		if (!this.configs.gcAllowed || !result.isSummaryTracked) {
 			return;
 		}
 

package/src/gc/gcTelemetry.ts

@@ -10,7 +10,6 @@ import {
 	MonitoringContext,
 	generateStack,
 	tagCodeArtifacts,
-	type ITelemetryGenericEventExt,
 	type ITelemetryPropertiesExt,
 } from "@fluidframework/telemetry-utils/internal";
 
@@ -22,11 +21,7 @@ import {
 	GCNodeType,
 	IGarbageCollectorConfigs,
 	UnreferencedState,
-	disableTombstoneKey,
-	throwOnTombstoneLoadOverrideKey,
-	throwOnTombstoneUsageKey,
 } from "./gcDefinitions.js";
-import { getGCVersionInEffect } from "./gcHelpers.js";
 import { UnreferencedStateTracker } from "./gcUnreferencedStateTracker.js";
 
 type NodeUsageType = "Changed" | "Loaded" | "Revived" | "Realized";
@@ -287,18 +282,12 @@ export class GCTelemetryTracker {
 			headers: { ...headers },
 			details: { ...detailedProps, ...additionalProps }, // Also includes some properties from INodeUsageProps type
 			gcConfigs,
-			tombstoneFlags: {
-				DisableTombstone: this.mc.config.getBoolean(disableTombstoneKey),
-				ThrowOnTombstoneUsage: this.mc.config.getBoolean(throwOnTombstoneUsageKey),
-				ThrowOnTombstoneLoad: this.mc.config.getBoolean(throwOnTombstoneLoadOverrideKey),
-			},
 		};
 
 		if (
-			(usageType === "Loaded" &&
-				this.configs.throwOnTombstoneLoad &&
-				!headers?.allowTombstone) ||
-			(usageType === "Changed" && this.configs.throwOnTombstoneUsage)
+			usageType === "Loaded" &&
+			this.configs.throwOnTombstoneLoad &&
+			!headers?.allowTombstone
 		) {
 			this.mc.logger.sendErrorEvent(event);
 		} else {
@@ -419,27 +408,3 @@ export class GCTelemetryTracker {
 		this.pendingEventsQueue = [];
 	}
 }
-
-/**
- * Consolidates info / logic for logging when we encounter unexpected usage of GC'd objects. For example, when a
- * tombstoned or deleted object is loaded.
- */
-export function sendGCUnexpectedUsageEvent(
-	mc: MonitoringContext,
-	event: ITelemetryGenericEventExt & {
-		category: "error" | "generic";
-		gcTombstoneEnforcementAllowed: boolean | undefined;
-	},
-	packagePath: readonly string[] | undefined,
-	error?: unknown,
-) {
-	event.pkg = tagCodeArtifacts({ pkg: packagePath?.join("/") })?.pkg;
-	event.tombstoneFlags = JSON.stringify({
-		DisableTombstone: mc.config.getBoolean(disableTombstoneKey),
-		ThrowOnTombstoneUsage: mc.config.getBoolean(throwOnTombstoneUsageKey),
-		ThrowOnTombstoneLoad: mc.config.getBoolean(throwOnTombstoneLoadOverrideKey),
-	});
-	event.gcVersion = getGCVersionInEffect(mc.config);
-
-	mc.logger.sendTelemetryEvent(event, error);
-}

package/src/gc/index.ts

@@ -11,8 +11,6 @@ export {
 	defaultSessionExpiryDurationMs,
 	GCNodeType,
 	gcTestModeKey,
-	gcDisableDataStoreSweepOptionName,
-	gcDisableThrowOnTombstoneLoadOptionName,
 	gcGenerationOptionName,
 	GCFeatureMatrix,
 	GCVersion,
@@ -32,10 +30,8 @@ export {
 	oneDayMs,
 	runSessionExpiryKey,
 	stableGCVersion,
-	disableAutoRecoveryKey,
-	disableDatastoreSweepKey,
 	UnreferencedState,
-	throwOnTombstoneLoadOverrideKey,
+	disableThrowOnTombstoneLoadKey,
 	GarbageCollectionMessage,
 	GarbageCollectionMessageType,
 	ISweepMessage,
@@ -59,5 +55,5 @@ export {
 	GCSummaryStateTracker,
 	IGCSummaryTrackingData,
 } from "./gcSummaryStateTracker.js";
-export { GCTelemetryTracker, sendGCUnexpectedUsageEvent } from "./gcTelemetry.js";
+export { GCTelemetryTracker } from "./gcTelemetry.js";
 export { UnreferencedStateTracker } from "./gcUnreferencedStateTracker.js";

package/src/index.ts

@@ -37,7 +37,6 @@ export {
 	RuntimeHeaders,
 	ChannelCollectionFactory,
 	AllowTombstoneRequestHeaderKey,
-	AllowInactiveRequestHeaderKey,
 } from "./channelCollection.js";
 export {
 	GCNodeType,

package/src/messageTypes.ts

@@ -88,12 +88,18 @@ export interface IContainerRuntimeMessageCompatDetails {
  * IMPORTANT: when creating one to be serialized, set the properties in the order they appear here.
  * This way stringified values can be compared.
  */
-interface TypedContainerRuntimeMessage<TType extends ContainerMessageType, TContents> {
+type TypedContainerRuntimeMessage<
+	TType extends ContainerMessageType,
+	TContents,
+	TUSedCompatDetails extends boolean = false,
+> = {
 	/** Type of the op, within the ContainerRuntime's domain */
 	type: TType;
 	/** Domain-specific contents, interpreted according to the type */
 	contents: TContents;
-}
+} & (TUSedCompatDetails extends true
+	? Partial<RecentlyAddedContainerRuntimeMessageDetails>
+	: { compatDetails?: undefined });
 
 /**
  * Additional details expected for any recently added message.
@@ -139,10 +145,9 @@ export type ContainerRuntimeIdAllocationMessage = TypedContainerRuntimeMessage<
 >;
 export type ContainerRuntimeGCMessage = TypedContainerRuntimeMessage<
 	ContainerMessageType.GC,
-	GarbageCollectionMessage
-> &
-	// While deprecating: GC messages may still contain compat details for now
-	Partial<RecentlyAddedContainerRuntimeMessageDetails>;
+	GarbageCollectionMessage,
+	true // TUsedCompatDetails
+>;
 export type ContainerRuntimeDocumentSchemaMessage = TypedContainerRuntimeMessage<
 	ContainerMessageType.DocumentSchemaChange,
 	IDocumentSchemaChangeMessage
@@ -223,15 +228,11 @@ export type InboundSequencedContainerRuntimeMessage = Omit<
  * 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`.
  */
-type InboundSequencedNonContainerRuntimeMessage = Omit<
+export type InboundSequencedNonContainerRuntimeMessage = Omit<
 	ISequencedDocumentMessage,
 	"type" | "contents"
 > & { type: "__not_a_container_runtime_message_type__"; contents: unknown };
 
-export type InboundSequencedContainerRuntimeMessageOrSystemMessage =
-	| InboundSequencedContainerRuntimeMessage
-	| InboundSequencedNonContainerRuntimeMessage;
-
 /** A [loose] InboundSequencedContainerRuntimeMessage that is recent and may contain compat details.
  * It exists solely to to provide access to those details.
  */

package/src/metadata.ts

@@ -6,10 +6,24 @@
 import type { BatchId } from "./opLifecycle/index.js";
 
 /** Syntactic sugar for casting */
-export function asBatchMetadata(metadata: unknown): IBatchMetadata | undefined {
-	return metadata as IBatchMetadata | undefined;
+export function asBatchMetadata(metadata: unknown): Partial<IBatchMetadata> | undefined {
+	return metadata as Partial<IBatchMetadata> | undefined;
 }
 
+/** Syntactic sugar for casting */
+export function asEmptyBatchLocalOpMetadata(
+	localOpMetadata: unknown,
+): IEmptyBatchMetadata | undefined {
+	return localOpMetadata as IEmptyBatchMetadata | undefined;
+}
+
+/**
+ * Properties put on the localOpMetadata object for empty batches
+ */
+export interface IEmptyBatchMetadata {
+	// Set to true on localOpMetadata for empty batches
+	emptyBatch?: boolean;
+}
 /**
  * Properties put on the op metadata object for batch tracking
  */

package/src/opLifecycle/index.ts

@@ -18,6 +18,7 @@ export { OpDecompressor } from "./opDecompressor.js";
 export { OpSplitter, splitOp, isChunkedMessage } from "./opSplitter.js";
 export {
 	ensureContentsDeserialized,
+	InboundBatch,
 	RemoteMessageProcessor,
 	unpackRuntimeMessage,
 } from "./remoteMessageProcessor.js";

package/src/opLifecycle/opGroupingManager.ts

@@ -49,6 +49,40 @@ export class OpGroupingManager {
 		this.logger = createChildLogger({ logger, namespace: "OpGroupingManager" });
 	}
 
+	/**
+	 * Creates a new batch with a single message of type "groupedBatch" and empty contents.
+	 * This is needed as a placeholder if a batch becomes empty on resubmit, but we are tracking batch IDs.
+	 * @param resubmittingBatchId - batch ID of the resubmitting batch
+	 * @param referenceSequenceNumber - reference sequence number
+	 * @returns - IBatch containing a single empty Grouped Batch op
+	 */
+	public createEmptyGroupedBatch(
+		resubmittingBatchId: string,
+		referenceSequenceNumber: number,
+	): IBatch<[BatchMessage]> {
+		assert(
+			this.config.groupedBatchingEnabled,
+			0xa00 /* cannot create empty grouped batch when grouped batching is disabled */,
+		);
+		const serializedContent = JSON.stringify({
+			type: OpGroupingManager.groupedBatchOp,
+			contents: [],
+		});
+
+		return {
+			contentSizeInBytes: 0,
+			messages: [
+				{
+					metadata: { batchId: resubmittingBatchId },
+					localOpMetadata: { emptyBatch: true },
+					referenceSequenceNumber,
+					contents: serializedContent,
+				},
+			],
+			referenceSequenceNumber,
+		};
+	}
+
 	/**
 	 * Converts the given batch into a "grouped batch" - a batch with a single message of type "groupedBatch",
 	 * with contents being an array of the original batch's messages.
@@ -70,10 +104,14 @@ export class OpGroupingManager {
 				referenceSequenceNumber: batch.messages[0]!.referenceSequenceNumber,
 			});
 		}
-
+		// We expect this will be on the first message, if present at all.
+		let groupedBatchId;
 		for (const message of batch.messages) {
 			if (message.metadata) {
 				const { batch: _batch, batchId, ...rest } = message.metadata;
+				if (batchId) {
+					groupedBatchId = batchId;
+				}
 				assert(Object.keys(rest).length === 0, 0x5dd /* cannot group ops with metadata */);
 			}
 		}
@@ -91,7 +129,7 @@ export class OpGroupingManager {
 			...batch,
 			messages: [
 				{
-					metadata: undefined,
+					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,
@@ -121,7 +159,8 @@ export class OpGroupingManager {
 			// Grouped batching must be enabled
 			this.config.groupedBatchingEnabled &&
 			// The number of ops in the batch must surpass the configured threshold
-			batch.messages.length >= this.config.opCountThreshold &&
+			// or be empty (to allow for empty batches to be grouped)
+			(batch.messages.length === 0 || batch.messages.length >= this.config.opCountThreshold) &&
 			// Support for reentrant batches must be explicitly enabled
 			(this.config.reentrantBatchGroupingEnabled || batch.hasReentrantOps !== true)
 		);

package/src/opLifecycle/outbox.ts

@@ -254,6 +254,14 @@ export class Outbox {
 		// Don't use resubmittingBatchId for idAllocationBatch.
 		// ID Allocation messages are not directly resubmitted so we don't want to reuse the batch ID.
 		this.flushInternal(this.idAllocationBatch);
+		// We need to flush an empty batch if the main batch *becomes* empty on resubmission.
+		// When resubmitting the main batch, the blobAttach batch will always be empty since we don't resubmit them simultaneously.
+		// And conversely, the blobAttach will never *become* empty on resubmit.
+		// So if both blobAttachBatch and mainBatch are empty, we must submit an empty main batch.
+		if (resubmittingBatchId && this.blobAttachBatch.empty && this.mainBatch.empty) {
+			this.flushEmptyBatch(resubmittingBatchId);
+			return;
+		}
 		this.flushInternal(
 			this.blobAttachBatch,
 			true /* disableGroupedBatching */,
@@ -266,6 +274,28 @@ export class Outbox {
 		);
 	}
 
+	private flushEmptyBatch(resubmittingBatchId: BatchId) {
+		const referenceSequenceNumber =
+			this.params.getCurrentSequenceNumbers().referenceSequenceNumber;
+		assert(
+			referenceSequenceNumber !== undefined,
+			0xa01 /* reference sequence number should be defined */,
+		);
+		const emptyGroupedBatch = this.params.groupingManager.createEmptyGroupedBatch(
+			resubmittingBatchId,
+			referenceSequenceNumber,
+		);
+		let clientSequenceNumber: number | undefined;
+		if (this.params.shouldSend()) {
+			clientSequenceNumber = this.sendBatch(emptyGroupedBatch);
+		}
+		this.params.pendingStateManager.onFlushBatch(
+			emptyGroupedBatch.messages, // This is the single empty Grouped Batch message
+			clientSequenceNumber,
+		);
+		return;
+	}
+
 	private flushInternal(
 		batchManager: BatchManager,
 		disableGroupedBatching: boolean = false,

package/src/opLifecycle/remoteMessageProcessor.ts

@@ -21,6 +21,35 @@ 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[];
+	/** 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.
+	 * 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;
+}
+
+function assertHasClientId(
+	message: ISequencedDocumentMessage,
+): asserts message is ISequencedDocumentMessage & { clientId: string } {
+	assert(
+		message.clientId !== null,
+		0xa02 /* Server-generated message should not reach RemoteMessageProcessor */,
+	);
+}
+
 /**
  * Stateful class for processing incoming remote messages as the virtualization measures are unwrapped,
  * potentially across numerous inbound ops.
@@ -29,13 +58,11 @@ import { OpSplitter, isChunkedMessage } from "./opSplitter.js";
  */
 export class RemoteMessageProcessor {
 	/**
-	 * Client Sequence Number of the first message in the current batch being processed.
-	 * If undefined, we are expecting the next message to start a new batch.
+	 * The current batch being received, with details needed to process it.
 	 *
-	 * @remarks For chunked batches, this is the CSN of the "representative" chunk (the final chunk)
+	 * @remarks If undefined, we are expecting the next message to start a new batch.
 	 */
-	private batchStartCsn: number | undefined;
-	private readonly processorBatch: InboundSequencedContainerRuntimeMessage[] = [];
+	private batchInProgress: InboundBatch | undefined;
 
 	constructor(
 		private readonly opSplitter: OpSplitter,
@@ -73,19 +100,17 @@ export class RemoteMessageProcessor {
 	public process(
 		remoteMessageCopy: ISequencedDocumentMessage,
 		logLegacyCase: (codePath: string) => void,
-	):
-		| {
-				messages: InboundSequencedContainerRuntimeMessage[];
-				batchStartCsn: number;
-		  }
-		| undefined {
+	): InboundBatch | undefined {
 		let message = remoteMessageCopy;
 
+		assertHasClientId(message);
+		const clientId = message.clientId;
+
 		if (isChunkedMessage(message)) {
 			const chunkProcessingResult = this.opSplitter.processChunk(message);
 			// Only continue further if current chunk is the final chunk
 			if (!chunkProcessingResult.isFinalChunk) {
-				return;
+				return undefined;
 			}
 			// This message will always be compressed
 			message = chunkProcessingResult.message;
@@ -104,100 +129,111 @@ export class RemoteMessageProcessor {
 		}
 
 		if (isGroupedBatch(message)) {
-			// We should be awaiting a new batch (batchStartCsn undefined)
+			// We should be awaiting a new batch (batchInProgress undefined)
 			assert(
-				this.batchStartCsn === undefined,
+				this.batchInProgress === undefined,
 				0x9d3 /* Grouped batch interrupting another batch */,
 			);
-			assert(
-				this.processorBatch.length === 0,
-				0x9d4 /* Processor batch should be empty on grouped batch */,
-			);
+			const batchId = asBatchMetadata(message.metadata)?.batchId;
+			const groupedMessages = this.opGroupingManager.ungroupOp(message).map(unpack);
 			return {
-				messages: this.opGroupingManager.ungroupOp(message).map(unpack),
+				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,
 			};
 		}
 
-		const batchStartCsn = this.getAndUpdateBatchStartCsn(message);
-
 		// Do a final unpack of runtime messages in case the message was not grouped, compressed, or chunked
 		unpackRuntimeMessage(message, logLegacyCase);
-		this.processorBatch.push(message as InboundSequencedContainerRuntimeMessage);
 
-		// this.batchStartCsn is undefined only if we have processed all messages in the batch.
-		// If it's still defined, we're still in the middle of a batch, so we return nothing, letting
-		// containerRuntime know that we're waiting for more messages to complete the batch.
-		if (this.batchStartCsn !== undefined) {
+		const { batchEnded } = this.addMessageToBatch(
+			message as InboundSequencedContainerRuntimeMessage & { clientId: string },
+		);
+
+		if (!batchEnded) {
 			// batch not yet complete
 			return undefined;
 		}
 
-		const messages = [...this.processorBatch];
-		this.processorBatch.length = 0;
-		return {
-			messages,
-			batchStartCsn,
-		};
+		const completedBatch = this.batchInProgress;
+		this.batchInProgress = undefined;
+		return completedBatch;
 	}
 
 	/**
-	 * Based on pre-existing batch tracking info and the current message's batch metadata,
-	 * this will return the starting CSN for this message's batch, and will also update
-	 * the batch tracking info (this.batchStartCsn) based on whether we're still mid-batch.
+	 * 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
 	 */
-	private getAndUpdateBatchStartCsn(message: ISequencedDocumentMessage): number {
+	private addMessageToBatch(
+		message: InboundSequencedContainerRuntimeMessage & { clientId: string },
+	): { batchEnded: boolean } {
 		const batchMetadataFlag = asBatchMetadata(message.metadata)?.batch;
-		if (this.batchStartCsn === undefined) {
+		if (this.batchInProgress === undefined) {
 			// 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.batchStartCsn = message.clientSequenceNumber;
-				return this.batchStartCsn;
+				this.batchInProgress = {
+					messages: [message],
+					batchId: asBatchMetadata(message.metadata)?.batchId,
+					clientId: message.clientId,
+					batchStartCsn: message.clientSequenceNumber,
+				};
+
+				return { batchEnded: false };
 			}
 
 			// Single-message batch (Since metadata flag is undefined)
-			// IMPORTANT: Leave this.batchStartCsn undefined, we're ready for the next batch now.
-			return message.clientSequenceNumber;
+			this.batchInProgress = {
+				messages: [message],
+				batchStartCsn: message.clientSequenceNumber,
+				clientId: message.clientId,
+				batchId: asBatchMetadata(message.metadata)?.batchId,
+			};
+			return { batchEnded: true };
 		}
-
-		// We are in the middle or end of an existing multi-message batch. Return the current batchStartCsn
-		const batchStartCsn = this.batchStartCsn;
-
 		assert(batchMetadataFlag !== true, 0x9d6 /* Unexpected batch start marker */);
-		if (batchMetadataFlag === false) {
-			// Batch end? Then get ready for the next batch to start
-			this.batchStartCsn = undefined;
-		}
 
-		return batchStartCsn;
+		this.batchInProgress.messages.push(message);
+
+		return { batchEnded: batchMetadataFlag === false };
 	}
 }
 
-/** Takes an incoming message and if the contents is a string, JSON.parse's it in place */
+/**
+ * Takes an incoming message and if the contents is a string, JSON.parse's it in place
+ * @param mutableMessage - op message received
+ * @param hasModernRuntimeMessageEnvelope - false if the message does not contain the modern op envelop where message.type is MessageType.Operation
+ * @param logLegacyCase - callback to log when legacy op is encountered
+ */
 export function ensureContentsDeserialized(
 	mutableMessage: ISequencedDocumentMessage,
-	modernRuntimeMessage: boolean,
+	hasModernRuntimeMessageEnvelope: boolean,
 	logLegacyCase: (codePath: string) => void,
 ): void {
-	// back-compat: ADO #1385: eventually should become unconditional, but only for runtime messages!
-	// System message may have no contents, or in some cases (mostly for back-compat) they may have actual objects.
-	// Old ops may contain empty string (I assume noops).
-	let parsedJsonContents: boolean;
+	// 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.
+	let didParseJsonContents: boolean;
 	if (typeof mutableMessage.contents === "string" && mutableMessage.contents !== "") {
 		mutableMessage.contents = JSON.parse(mutableMessage.contents);
-		parsedJsonContents = true;
+		didParseJsonContents = true;
 	} else {
-		parsedJsonContents = false;
+		didParseJsonContents = false;
 	}
 
-	// We expect Modern Runtime Messages to have JSON serialized contents,
-	// and all other messages not to (system messages and legacy runtime messages without outer "op" type envelope)
+	// The DeltaManager parses the contents of the message as JSON if it is a string,
+	// so we should never end up parsing it here.
 	// Let's observe if we are wrong about this to learn about these cases.
-	if (modernRuntimeMessage !== parsedJsonContents) {
-		logLegacyCase("ensureContentsDeserialized_unexpectedContentsType");
+	if (didParseJsonContents) {
+		logLegacyCase("ensureContentsDeserialized_foundJsonContents");
 	}
 }
 

package/src/packageVersion.ts

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