@fluidframework/container-runtime 2.13.0 → 2.21.0

package/src/opLifecycle/opCompressor.ts

@@ -6,7 +6,11 @@
 import { IsoBuffer } from "@fluid-internal/client-utils";
 import { ITelemetryBaseLogger } from "@fluidframework/core-interfaces";
 import { assert } from "@fluidframework/core-utils/internal";
-import { UsageError, createChildLogger } from "@fluidframework/telemetry-utils/internal";
+import {
+	UsageError,
+	createChildLogger,
+	type ITelemetryLoggerExt,
+} from "@fluidframework/telemetry-utils/internal";
 import { compress } from "lz4js";
 
 import { CompressionAlgorithms } from "../containerRuntime.js";
@@ -20,7 +24,7 @@ import { BatchMessage, IBatch } from "./definitions.js";
  * op to reserve sequence numbers.
  */
 export class OpCompressor {
-	private readonly logger;
+	private readonly logger: ITelemetryLoggerExt;
 
 	constructor(logger: ITelemetryBaseLogger) {
 		this.logger = createChildLogger({ logger, namespace: "OpCompressor" });
@@ -30,13 +34,14 @@ export class OpCompressor {
 	 * Combines the contents of the batch into a single JSON string and compresses it, putting
 	 * the resulting string as the first message of the batch. The rest of the messages are
 	 * empty placeholders to reserve sequence numbers.
+	 * This should only take a single message batch and compress it.
 	 * @param batch - The batch to compress
 	 * @returns A batch of the same length as the input batch, containing a single compressed message followed by empty placeholders
 	 */
-	public compressBatch(batch: IBatch): IBatch {
+	public compressBatch(batch: IBatch): IBatch<[BatchMessage]> {
 		assert(
-			batch.contentSizeInBytes > 0 && batch.messages.length > 0,
-			0x5a4 /* Batch should not be empty */,
+			batch.contentSizeInBytes > 0 && batch.messages.length === 1,
+			0x5a4 /* Batch should not be empty and should contain a single message */,
 		);
 
 		const compressionStart = Date.now();
@@ -45,24 +50,16 @@ export class OpCompressor {
 		const compressedContent = IsoBuffer.from(compressedContents).toString("base64");
 		const duration = Date.now() - compressionStart;
 
-		const messages: BatchMessage[] = [];
-		messages.push({
-			...batch.messages[0],
-			contents: JSON.stringify({ packedContents: compressedContent }),
-			metadata: batch.messages[0].metadata,
-			compression: CompressionAlgorithms.lz4,
-		});
+		const messages: [BatchMessage] = [
+			{
+				...batch.messages[0],
+				contents: JSON.stringify({ packedContents: compressedContent }),
+				metadata: batch.messages[0].metadata,
+				compression: CompressionAlgorithms.lz4,
+			},
+		];
 
-		// Add empty placeholder messages to reserve the sequence numbers
-		for (const message of batch.messages.slice(1)) {
-			messages.push({
-				localOpMetadata: message.localOpMetadata,
-				metadata: message.metadata,
-				referenceSequenceNumber: message.referenceSequenceNumber,
-			});
-		}
-
-		const compressedBatch: IBatch = {
+		const compressedBatch = {
 			contentSizeInBytes: compressedContent.length,
 			messages,
 			referenceSequenceNumber: batch.referenceSequenceNumber,
@@ -89,8 +86,8 @@ export class OpCompressor {
 		try {
 			// Yields a valid JSON array, since each message.contents is already serialized to JSON
 			return `[${batch.messages.map(({ contents }) => contents).join(",")}]`;
-		} catch (e: any) {
-			if (e.message === "Invalid string length") {
+		} catch (newError: unknown) {
+			if ((newError as Partial<Error>).message === "Invalid string length") {
 				// This is how JSON.stringify signals that
 				// the content size exceeds its capacity
 				const error = new UsageError("Payload too large");
@@ -105,7 +102,7 @@ export class OpCompressor {
 				throw error;
 			}
 
-			throw e;
+			throw newError;
 		}
 	}
 }

package/src/opLifecycle/opDecompressor.ts

@@ -7,7 +7,10 @@ import { IsoBuffer, Uint8ArrayToString } from "@fluid-internal/client-utils";
 import { ITelemetryBaseLogger } from "@fluidframework/core-interfaces";
 import { assert } from "@fluidframework/core-utils/internal";
 import { ISequencedDocumentMessage } from "@fluidframework/driver-definitions/internal";
-import { createChildLogger } from "@fluidframework/telemetry-utils/internal";
+import {
+	createChildLogger,
+	type ITelemetryLoggerExt,
+} from "@fluidframework/telemetry-utils/internal";
 import { decompress } from "lz4js";
 
 import { CompressionAlgorithms } from "../containerRuntime.js";
@@ -27,12 +30,17 @@ interface IPackedContentsContents {
  * 2. Messages in the middle of a compressed batch will have neither batch metadata nor the compression property set
  * 3. The final message of a batch will have batch metadata set to false
  * 4. An individually compressed op will have undefined batch metadata and compression set to true
+ *
+ * Compressed batches from current code are always a single message but this class needs to handle a legacy compressed batch with multiple messages
+ * because we need that functionality for back compat.
  */
 export class OpDecompressor {
 	private activeBatch = false;
+	// TODO: better typing
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
 	private rootMessageContents: any | undefined;
 	private processedCount = 0;
-	private readonly logger;
+	private readonly logger: ITelemetryLoggerExt;
 
 	constructor(logger: ITelemetryBaseLogger) {
 		this.logger = createChildLogger({ logger, namespace: "OpDecompressor" });
@@ -74,18 +82,20 @@ export class OpDecompressor {
 				});
 				return true;
 			}
-		} catch (err) {
+		} catch {
 			return false;
 		}
 
 		return false;
 	}
 
-	public get currentlyUnrolling() {
+	public get currentlyUnrolling(): boolean {
 		return this.activeBatch;
 	}
 
-	/** Is the decompressed and stored batch only comprised of a single message */
+	/**
+	 * Is the decompressed and stored batch only comprised of a single message
+	 */
 	private isSingleMessageBatch = false;
 
 	/**
@@ -118,8 +128,8 @@ export class OpDecompressor {
 		);
 		const decompressedMessage = decompress(contents);
 		const intoString = Uint8ArrayToString(decompressedMessage);
-		const asObj = JSON.parse(intoString);
-		this.rootMessageContents = asObj;
+		// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+		this.rootMessageContents = JSON.parse(intoString);
 	}
 
 	/**
@@ -130,6 +140,7 @@ export class OpDecompressor {
 		assert(this.currentlyUnrolling, 0x942 /* not currently unrolling */);
 		assert(this.rootMessageContents !== undefined, 0x943 /* missing rootMessageContents */);
 		assert(
+			// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
 			this.rootMessageContents.length > this.processedCount,
 			0x944 /* no more content to unroll */,
 		);
@@ -138,6 +149,7 @@ export class OpDecompressor {
 
 		if (batchMetadata === false || this.isSingleMessageBatch) {
 			// End of compressed batch
+			// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
 			const returnMessage = newMessage(message, this.rootMessageContents[this.processedCount]);
 
 			this.activeBatch = false;
@@ -148,6 +160,7 @@ export class OpDecompressor {
 			return returnMessage;
 		} else if (batchMetadata === true) {
 			// Start of compressed batch
+			// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
 			return newMessage(message, this.rootMessageContents[this.processedCount++]);
 		}
 
@@ -155,6 +168,7 @@ export class OpDecompressor {
 		assert(message.contents === undefined, 0x512 /* Expecting empty message */);
 
 		// Continuation of compressed batch
+		// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
 		return newMessage(message, this.rootMessageContents[this.processedCount++]);
 	}
 }
@@ -162,7 +176,7 @@ export class OpDecompressor {
 // We should not be mutating the input message nor its metadata
 const newMessage = (
 	originalMessage: ISequencedDocumentMessage,
-	contents: any,
+	contents: unknown,
 ): ISequencedDocumentMessage => ({
 	...originalMessage,
 	contents,
@@ -170,7 +184,5 @@ const newMessage = (
 	// TODO: It should already be the case that we're not modifying any metadata, not clear if/why this shallow clone should be required.
 
 	metadata:
-		originalMessage.metadata === undefined
-			? undefined
-			: { ...(originalMessage.metadata as any) },
+		originalMessage.metadata === undefined ? undefined : { ...originalMessage.metadata },
 });

package/src/opLifecycle/opGroupingManager.ts

@@ -6,7 +6,10 @@
 import { ITelemetryBaseLogger } from "@fluidframework/core-interfaces";
 import { assert } from "@fluidframework/core-utils/internal";
 import { ISequencedDocumentMessage } from "@fluidframework/driver-definitions/internal";
-import { createChildLogger } from "@fluidframework/telemetry-utils/internal";
+import {
+	createChildLogger,
+	type ITelemetryLoggerExt,
+} from "@fluidframework/telemetry-utils/internal";
 
 import { IBatch, type BatchMessage } from "./definitions.js";
 
@@ -24,8 +27,11 @@ interface IGroupedMessage {
 	compression?: string;
 }
 
-function isGroupContents(opContents: any): opContents is IGroupedBatchMessageContents {
-	return opContents?.type === OpGroupingManager.groupedBatchOp;
+function isGroupContents(opContents: unknown): opContents is IGroupedBatchMessageContents {
+	return (
+		(opContents as Partial<IGroupedBatchMessageContents>)?.type ===
+		OpGroupingManager.groupedBatchOp
+	);
 }
 
 export function isGroupedBatch(op: ISequencedDocumentMessage): boolean {
@@ -34,13 +40,11 @@ export function isGroupedBatch(op: ISequencedDocumentMessage): boolean {
 
 export interface OpGroupingManagerConfig {
 	readonly groupedBatchingEnabled: boolean;
-	readonly opCountThreshold: number;
-	readonly reentrantBatchGroupingEnabled: boolean;
 }
 
 export class OpGroupingManager {
 	static readonly groupedBatchOp = "groupedBatch";
-	private readonly logger;
+	private readonly logger: ITelemetryLoggerExt;
 
 	constructor(
 		private readonly config: OpGroupingManagerConfig,
@@ -97,7 +101,6 @@ export class OpGroupingManager {
 			this.logger.sendTelemetryEvent({
 				eventName: "GroupLargeBatch",
 				length: batch.messages.length,
-				threshold: this.config.opCountThreshold,
 				reentrant: batch.hasReentrantOps,
 				referenceSequenceNumber: batch.messages[0].referenceSequenceNumber,
 			});
@@ -154,11 +157,13 @@ export class OpGroupingManager {
 		return (
 			// Grouped batching must be enabled
 			this.config.groupedBatchingEnabled &&
-			// The number of ops in the batch must surpass the configured threshold
+			// The number of ops in the batch must be 2 or more
 			// 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)
+			batch.messages.length !== 1
+			// Support for reentrant batches will be on by default
 		);
 	}
+	public groupedBatchingEnabled(): boolean {
+		return this.config.groupedBatchingEnabled;
+	}
 }

package/src/opLifecycle/opSplitter.ts

@@ -11,6 +11,7 @@ import {
 	DataCorruptionError,
 	createChildLogger,
 	extractSafePropertiesFromMessage,
+	type ITelemetryLoggerExt,
 } from "@fluidframework/telemetry-utils/internal";
 
 import { ContainerMessageType, ContainerRuntimeChunkedOpMessage } from "../messageTypes.js";
@@ -23,12 +24,12 @@ export function isChunkedMessage(message: ISequencedDocumentMessage): boolean {
 }
 
 interface IChunkedContents {
-	type: typeof ContainerMessageType.ChunkedOp;
-	contents: IChunkedOp;
+	readonly type: typeof ContainerMessageType.ChunkedOp;
+	readonly contents: IChunkedOp;
 }
 
-function isChunkedContents(contents: any): contents is IChunkedContents {
-	return contents?.type === ContainerMessageType.ChunkedOp;
+function isChunkedContents(contents: unknown): contents is IChunkedContents {
+	return (contents as Partial<IChunkedContents>)?.type === ContainerMessageType.ChunkedOp;
 }
 
 /**
@@ -37,7 +38,7 @@ function isChunkedContents(contents: any): contents is IChunkedContents {
 export class OpSplitter {
 	// Local copy of incomplete received chunks.
 	private readonly chunkMap: Map<string, string[]>;
-	private readonly logger;
+	private readonly logger: ITelemetryLoggerExt;
 
 	constructor(
 		chunks: [string, string[]][],
@@ -62,7 +63,7 @@ export class OpSplitter {
 		return this.chunkMap;
 	}
 
-	public clearPartialChunks(clientId: string) {
+	public clearPartialChunks(clientId: string): void {
 		if (this.chunkMap.has(clientId)) {
 			this.chunkMap.delete(clientId);
 		}
@@ -72,7 +73,7 @@ export class OpSplitter {
 		clientId: string,
 		chunkedContent: IChunkedOp,
 		originalMessage: ISequencedDocumentMessage,
-	) {
+	): void {
 		let map = this.chunkMap.get(clientId);
 		if (map === undefined) {
 			map = [];
@@ -98,25 +99,28 @@ export class OpSplitter {
 	 * Splits the first op of a compressed batch in chunks, sends the chunks separately and
 	 * returns a new batch composed of the last chunk and the rest of the ops in the original batch.
 	 *
-	 * A compressed batch is formed by one large op at the first position, followed by a series of placeholder ops
-	 * which are used in order to reserve the sequence numbers for when the first op gets unrolled into the original
-	 * uncompressed ops at ingestion in the runtime.
+	 * A compressed batch is formed by one large op at the first position.
 	 *
-	 * If the first op is too large, it can be chunked (split into smaller op) which can be sent individually over the wire
+	 * If the op is too large, it can be chunked (split into smaller op) which can be sent individually over the wire
 	 * and accumulate at ingestion, until the last op in the chunk is processed, when the original op is unrolled.
 	 *
-	 * This method will send the first N - 1 chunks separately and use the last chunk as the first message in the result batch
-	 * and then appends the original placeholder ops. This will ensure that the batch semantics of the original (non-compressed) batch
-	 * are preserved, as the original chunked op will be unrolled by the runtime when the first message in the batch is processed
-	 * (as it is the last chunk).
+	 * This method will send the first N - 1 chunks separately and use the last chunk as the first message in the result batch.
+	 * This will ensure that the batch semantics of the original (non-compressed) batch are preserved, as the original chunked op
+	 * will be unrolled by the runtime when the first message in the batch is processed (as it is the last chunk).
+	 *
+	 * To handle legacy compressed batches with empty placeholders this method can attach the empty placeholder ops at the end
+	 * of the result batch, ensuring that the batch semantics are preserved.
+	 *
+	 * To illustrate the current functionality, if the input is `[largeOp]`, `largeOp` will be split into `[chunk1, chunk2, chunk3, chunk4]`.
+	 * `chunk1`, `chunk2` and `chunk3` will be sent individually and `[chunk4]` will be returned.
 	 *
-	 * To illustrate, if the input is `[largeOp, emptyOp, emptyOp]`, `largeOp` will be split into `[chunk1, chunk2, chunk3, chunk4]`.
+	 * With the legacy code, if the input is `[largeOp, emptyOp, emptyOp]`, `largeOp` will be split into `[chunk1, chunk2, chunk3, chunk4]`.
 	 * `chunk1`, `chunk2` and `chunk3` will be sent individually and `[chunk4, emptyOp, emptyOp]` will be returned.
 	 *
 	 * @remarks - A side effect here is that 1 or more chunks are queued immediately for sending in next JS turn.
 	 *
 	 * @param batch - the compressed batch which needs to be processed
-	 * @returns A new adjusted batch (last chunk + empty placeholders) which can be sent over the wire
+	 * @returns A batch with the last chunk of the original message
 	 */
 	public splitFirstBatchMessage(batch: IBatch): IBatch {
 		assert(this.isBatchChunkingEnabled, 0x513 /* Chunking needs to be enabled */);
@@ -215,6 +219,7 @@ export class OpSplitter {
 		// back-compat with 1.x builds
 		// This is only required / present for non-compressed, chunked ops
 		// For compressed ops, we have op grouping enabled, and type of each op is preserved within compressed content.
+		// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-assignment
 		completeMessage.type = (chunkedContent as any).originalType;
 		completeMessage.metadata = chunkedContent.originalMetadata;
 		completeMessage.compression = chunkedContent.originalCompression;
@@ -280,7 +285,7 @@ export const splitOp = (
 	for (let chunkId = 1; chunkId <= chunkCount; chunkId++) {
 		const chunk: IChunkedOp = {
 			chunkId,
-			contents: op.contents.substr(offset, chunkSizeInBytes),
+			contents: op.contents.slice(offset, offset + chunkSizeInBytes),
 			totalChunks: chunkCount,
 		};
 
@@ -298,6 +303,7 @@ export const splitOp = (
 			// This is really bad, as we will crash on later ops and it's very hard to debug these cases.
 			// If we put some known type here, then we will crash on it (as 1.x does not understand compression, and thus will not
 			// find info on the op like address of the channel to deliver the op)
+			// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
 			(chunk as any).originalType = "component";
 		}
 

package/src/opLifecycle/outbox.ts

@@ -77,6 +77,8 @@ export function serializeOpContents(contents: OutboundContainerRuntimeMessage):
  * @returns the result of the action provided
  */
 export function getLongStack<T>(action: () => T, length: number = 50): T {
+	// TODO: better typing here
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-assignment
 	const errorObj = Error as any;
 	if (
 		/* eslint-disable @typescript-eslint/prefer-nullish-coalescing */
@@ -90,11 +92,14 @@ export function getLongStack<T>(action: () => T, length: number = 50): T {
 		return action();
 	}
 
+	// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-assignment
 	const originalStackTraceLimit = errorObj.stackTraceLimit;
 	try {
+		// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
 		errorObj.stackTraceLimit = length;
 		return action();
 	} finally {
+		// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-assignment
 		errorObj.stackTraceLimit = originalStackTraceLimit;
 	}
 }
@@ -130,7 +135,9 @@ export class Outbox {
 			this.params.config.compressionOptions.minimumBatchSizeInBytes !==
 			Number.POSITIVE_INFINITY;
 		// We need to allow infinite size batches if we enable compression
-		const hardLimit = isCompressionEnabled ? Infinity : this.params.config.maxBatchSizeInBytes;
+		const hardLimit = isCompressionEnabled
+			? Number.POSITIVE_INFINITY
+			: this.params.config.maxBatchSizeInBytes;
 
 		this.mainBatch = new BatchManager({ hardLimit, canRebase: true });
 		this.blobAttachBatch = new BatchManager({ hardLimit, canRebase: true });
@@ -171,7 +178,7 @@ 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() {
+	private maybeFlushPartialBatch(): void {
 		const mainBatchSeqNums = this.mainBatch.sequenceNumbers;
 		const blobAttachSeqNums = this.blobAttachBatch.sequenceNumbers;
 		const idAllocSeqNums = this.idAllocationBatch.sequenceNumbers;
@@ -214,37 +221,25 @@ export class Outbox {
 		}
 	}
 
-	public submit(message: BatchMessage) {
+	public submit(message: BatchMessage): void {
 		this.maybeFlushPartialBatch();
 
 		this.addMessageToBatchManager(this.mainBatch, message);
 	}
 
-	public submitBlobAttach(message: BatchMessage) {
+	public submitBlobAttach(message: BatchMessage): void {
 		this.maybeFlushPartialBatch();
 
 		this.addMessageToBatchManager(this.blobAttachBatch, message);
-
-		// If compression is enabled, we will always successfully receive
-		// blobAttach ops and compress then send them at the next JS turn, regardless
-		// of the overall size of the accumulated ops in the batch.
-		// However, it is more efficient to flush these ops faster, preferably
-		// after they reach a size which would benefit from compression.
-		if (
-			this.blobAttachBatch.contentSizeInBytes >=
-			this.params.config.compressionOptions.minimumBatchSizeInBytes
-		) {
-			this.flushInternal(this.blobAttachBatch);
-		}
 	}
 
-	public submitIdAllocation(message: BatchMessage) {
+	public submitIdAllocation(message: BatchMessage): void {
 		this.maybeFlushPartialBatch();
 
 		this.addMessageToBatchManager(this.idAllocationBatch, message);
 	}
 
-	private addMessageToBatchManager(batchManager: BatchManager, message: BatchMessage) {
+	private addMessageToBatchManager(batchManager: BatchManager, message: BatchMessage): void {
 		if (
 			!batchManager.push(
 				message,
@@ -267,7 +262,7 @@ export class Outbox {
 	 * @param resubmittingBatchId - If defined, indicates this is a resubmission of a batch
 	 * with the given Batch ID, which must be preserved
 	 */
-	public flush(resubmittingBatchId?: BatchId) {
+	public flush(resubmittingBatchId?: BatchId): void {
 		if (this.isContextReentrant()) {
 			const error = new UsageError("Flushing is not supported inside DDS event handlers");
 			this.params.closeContainer(error);
@@ -277,7 +272,7 @@ export class Outbox {
 		this.flushAll(resubmittingBatchId);
 	}
 
-	private flushAll(resubmittingBatchId?: BatchId) {
+	private flushAll(resubmittingBatchId?: BatchId): void {
 		// If we're resubmitting 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, 2 of the 3 batches will *always* be empty.
 		// It's theoretically possible that we don't *need* to resubmit this empty batch, and in those cases, it'll safely be ignored
@@ -304,7 +299,7 @@ export class Outbox {
 		);
 	}
 
-	private flushEmptyBatch(resubmittingBatchId: BatchId) {
+	private flushEmptyBatch(resubmittingBatchId: BatchId): void {
 		const referenceSequenceNumber =
 			this.params.getCurrentSequenceNumbers().referenceSequenceNumber;
 		assert(
@@ -330,7 +325,7 @@ export class Outbox {
 		batchManager: BatchManager,
 		disableGroupedBatching: boolean = false,
 		resubmittingBatchId?: BatchId,
-	) {
+	): void {
 		if (batchManager.empty) {
 			return;
 		}
@@ -352,9 +347,11 @@ export class Outbox {
 		// 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()) {
-			const processedBatch = this.compressBatch(
-				shouldGroup ? this.params.groupingManager.groupBatch(rawBatch) : rawBatch,
-			);
+			const processedBatch = disableGroupedBatching
+				? rawBatch
+				: this.compressAndChunkBatch(
+						shouldGroup ? this.params.groupingManager.groupBatch(rawBatch) : rawBatch,
+					);
 			clientSequenceNumber = this.sendBatch(processedBatch);
 			assert(
 				clientSequenceNumber === undefined || clientSequenceNumber >= 0,
@@ -375,7 +372,7 @@ export class Outbox {
 	 *
 	 * @param rawBatch - the batch to be rebased
 	 */
-	private rebase(rawBatch: IBatch, batchManager: BatchManager) {
+	private rebase(rawBatch: IBatch, batchManager: BatchManager): void {
 		assert(!this.rebasing, 0x6fb /* Reentrancy */);
 		assert(batchManager.options.canRebase, 0x9a7 /* BatchManager does not support rebase */);
 
@@ -415,16 +412,17 @@ export class Outbox {
 	 * @remarks - If chunking happens, a side effect here is that 1 or more chunks are queued immediately for sending in next JS turn.
 	 *
 	 * @param batch - Raw or Grouped batch to consider for compression/chunking
-	 * @returns Either (A) the original batch, (B) a compressed batch (same length as original),
-	 * or (C) a batch containing the last chunk (plus empty placeholders from compression if applicable).
+	 * @returns Either (A) the original batch, (B) a compressed batch (same length as original)
+	 * or (C) a batch containing the last chunk.
 	 */
-	private compressBatch(batch: IBatch): IBatch {
+	private compressAndChunkBatch(batch: IBatch): IBatch {
 		if (
 			batch.messages.length === 0 ||
 			this.params.config.compressionOptions === undefined ||
 			this.params.config.compressionOptions.minimumBatchSizeInBytes >
 				batch.contentSizeInBytes ||
-			this.params.submitBatchFn === undefined
+			this.params.submitBatchFn === undefined ||
+			!this.params.groupingManager.groupedBatchingEnabled()
 		) {
 			// Nothing to do if the batch is empty or if compression is disabled or not supported, or if we don't need to compress
 			return batch;
@@ -459,7 +457,7 @@ export class Outbox {
 	 * @param batch - batch to be sent
 	 * @returns the clientSequenceNumber of the start of the batch, or undefined if nothing was sent
 	 */
-	private sendBatch(batch: IBatch) {
+	private sendBatch(batch: IBatch): number | undefined {
 		const length = batch.messages.length;
 		if (length === 0) {
 			return undefined; // Nothing submitted
@@ -505,9 +503,13 @@ export class Outbox {
 	}
 
 	/**
-	 * @returns A checkpoint object per batch that facilitates iterating over the batch messages when rolling back.
+	 * Gets a checkpoint object per batch that facilitates iterating over the batch messages when rolling back.
 	 */
-	public getBatchCheckpoints() {
+	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.
 		// When the type is inferred, the generated .d.ts uses a dynamic import which doesn't resolve.
 		const mainBatch: IBatchCheckpoint = this.mainBatch.checkpoint();

package/src/opLifecycle/remoteMessageProcessor.ts

@@ -22,11 +22,17 @@ import { OpSplitter, isChunkedMessage } from "./opSplitter.js";
 // eslint-disable-next-line unused-imports/no-unused-imports -- Used by "@link" comment annotation below
 import { serializeOpContents } from "./outbox.js";
 
-/** Info about the batch we learn when we process the first message */
+/**
+ * Info about the batch we learn when we process the first message
+ */
 export interface BatchStartInfo {
-	/** Batch ID, if present */
+	/**
+	 * Batch ID, if present
+	 */
 	readonly batchId: string | undefined;
-	/** clientId that sent this batch. Used to compute Batch ID if needed */
+	/**
+	 * clientId that sent this batch. Used to compute Batch ID if needed
+	 */
 	readonly clientId: string;
 	/**
 	 * Client Sequence Number of the Grouped Batch message, or the first message in the ungrouped batch.
@@ -101,7 +107,7 @@ export class RemoteMessageProcessor {
 		return this.opSplitter.chunks;
 	}
 
-	public clearPartialMessagesFor(clientId: string) {
+	public clearPartialMessagesFor(clientId: string): void {
 		this.opSplitter.clearPartialChunks(clientId);
 	}
 
@@ -159,7 +165,9 @@ export class RemoteMessageProcessor {
 			// 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);
+			const groupedMessages = this.opGroupingManager
+				.ungroupOp(message)
+				.map((innerMessage) => unpack(innerMessage));
 
 			return {
 				type: "fullBatch",

package/src/packageVersion.ts

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