@fluidframework/container-runtime 2.0.0-dev-rc.2.0.0.246488 → 2.0.0-dev-rc.3.0.0.250606

package/src/opLifecycle/opDecompressor.ts

@@ -3,15 +3,14 @@
  * Licensed under the MIT License.
  */
 
-import { decompress } from "lz4js";
-import { ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
-import { assert } from "@fluidframework/core-utils";
 import { IsoBuffer, Uint8ArrayToString } from "@fluid-internal/client-utils";
-import { createChildLogger } from "@fluidframework/telemetry-utils";
 import { ITelemetryBaseLogger } from "@fluidframework/core-interfaces";
+import { assert } from "@fluidframework/core-utils";
+import { ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
+import { createChildLogger } from "@fluidframework/telemetry-utils";
+import { decompress } from "lz4js";
 import { CompressionAlgorithms } from "../containerRuntime.js";
 import { IBatchMetadata } from "../metadata.js";
-import { IMessageProcessingResult } from "./definitions.js";
 
 /**
  * Compression makes assumptions about the shape of message contents. This interface codifies those assumptions, but does not validate them.
@@ -38,100 +37,7 @@ export class OpDecompressor {
 		this.logger = createChildLogger({ logger, namespace: "OpDecompressor" });
 	}
 
-	public processMessage(message: ISequencedDocumentMessage): IMessageProcessingResult {
-		assert(
-			message.compression === undefined || message.compression === CompressionAlgorithms.lz4,
-			0x511 /* Only lz4 compression is supported */,
-		);
-
-		if (
-			(message.metadata as IBatchMetadata | undefined)?.batch === true &&
-			this.isCompressed(message)
-		) {
-			// Beginning of a compressed batch
-			assert(this.activeBatch === false, 0x4b8 /* shouldn't have multiple active batches */);
-			this.activeBatch = true;
-
-			const contents = IsoBuffer.from(
-				(message.contents as IPackedContentsContents).packedContents,
-				"base64",
-			);
-			const decompressedMessage = decompress(contents);
-			const intoString = Uint8ArrayToString(decompressedMessage);
-			const asObj = JSON.parse(intoString);
-			this.rootMessageContents = asObj;
-
-			return {
-				message: newMessage(message, this.rootMessageContents[this.processedCount++]),
-				state: "Accepted",
-			};
-		}
-
-		if (
-			this.rootMessageContents !== undefined &&
-			(message.metadata as IBatchMetadata | undefined)?.batch === undefined &&
-			this.activeBatch
-		) {
-			assert(message.contents === undefined, 0x512 /* Expecting empty message */);
-
-			// Continuation of compressed batch
-			return {
-				message: newMessage(message, this.rootMessageContents[this.processedCount++]),
-				state: "Accepted",
-			};
-		}
-
-		if (
-			this.rootMessageContents !== undefined &&
-			(message.metadata as IBatchMetadata | undefined)?.batch === false
-		) {
-			// End of compressed batch
-			const returnMessage = newMessage(
-				message,
-				this.rootMessageContents[this.processedCount++],
-			);
-
-			this.activeBatch = false;
-			this.rootMessageContents = undefined;
-			this.processedCount = 0;
-
-			return {
-				message: returnMessage,
-				state: "Processed",
-			};
-		}
-
-		if (
-			(message.metadata as IBatchMetadata | undefined)?.batch === undefined &&
-			this.isCompressed(message)
-		) {
-			// Single compressed message
-			assert(
-				this.activeBatch === false,
-				0x4ba /* shouldn't receive compressed message in middle of a batch */,
-			);
-
-			const contents = IsoBuffer.from(
-				(message.contents as IPackedContentsContents).packedContents,
-				"base64",
-			);
-			const decompressedMessage = decompress(contents);
-			const intoString = new TextDecoder().decode(decompressedMessage);
-			const asObj = JSON.parse(intoString);
-
-			return {
-				message: newMessage(message, asObj[0]),
-				state: "Processed",
-			};
-		}
-
-		return {
-			message,
-			state: "Skipped",
-		};
-	}
-
-	private isCompressed(message: ISequencedDocumentMessage) {
+	public isCompressedMessage(message: ISequencedDocumentMessage): boolean {
 		if (message.compression === CompressionAlgorithms.lz4) {
 			return true;
 		}
@@ -174,6 +80,80 @@ export class OpDecompressor {
 
 		return false;
 	}
+
+	public get currentlyUnrolling() {
+		return this.activeBatch;
+	}
+
+	/** Is the decompressed and stored batch only comprised of a single message */
+	private isSingleMessageBatch = false;
+
+	/**
+	 * Decompress the given compressed message and store it to be subsequently unrolled.
+	 * The stored message will be of type `any[]` where each element represents a message's `contents`
+	 */
+	public decompressAndStore(message: ISequencedDocumentMessage): void {
+		assert(
+			message.compression === undefined || message.compression === CompressionAlgorithms.lz4,
+			0x511 /* Only lz4 compression is supported */,
+		);
+		assert(this.isCompressedMessage(message), "provided message should be compressed");
+
+		assert(this.activeBatch === false, 0x4b8 /* shouldn't have multiple active batches */);
+		this.activeBatch = true;
+
+		const batchMetadata = (message.metadata as IBatchMetadata | undefined)?.batch;
+		if (batchMetadata === undefined) {
+			this.isSingleMessageBatch = true;
+		} else {
+			assert(batchMetadata === true, "invalid batch metadata");
+		}
+
+		const contents = IsoBuffer.from(
+			(message.contents as IPackedContentsContents).packedContents,
+			"base64",
+		);
+		const decompressedMessage = decompress(contents);
+		const intoString = Uint8ArrayToString(decompressedMessage);
+		const asObj = JSON.parse(intoString);
+		this.rootMessageContents = asObj;
+	}
+
+	/**
+	 * Unroll the next message from the decompressed content provided to {@link decompressAndStore}
+	 * @returns the unrolled `ISequencedDocumentMessage`
+	 */
+	public unroll(message: ISequencedDocumentMessage): ISequencedDocumentMessage {
+		assert(this.currentlyUnrolling, "not currently unrolling");
+		assert(this.rootMessageContents !== undefined, "missing rootMessageContents");
+		assert(this.rootMessageContents.length > this.processedCount, "no more content to unroll");
+
+		const batchMetadata = (message.metadata as IBatchMetadata | undefined)?.batch;
+
+		if (batchMetadata === false || this.isSingleMessageBatch) {
+			// End of compressed batch
+			const returnMessage = newMessage(
+				message,
+				this.rootMessageContents[this.processedCount],
+			);
+
+			this.activeBatch = false;
+			this.isSingleMessageBatch = false;
+			this.rootMessageContents = undefined;
+			this.processedCount = 0;
+
+			return returnMessage;
+		} else if (batchMetadata === true) {
+			// Start of compressed batch
+			return newMessage(message, this.rootMessageContents[this.processedCount++]);
+		}
+
+		assert(batchMetadata === undefined, "invalid batch metadata");
+		assert(message.contents === undefined, 0x512 /* Expecting empty message */);
+
+		// Continuation of compressed batch
+		return newMessage(message, this.rootMessageContents[this.processedCount++]);
+	}
 }
 
 // We should not be mutating the input message nor its metadata
@@ -186,5 +166,8 @@ const newMessage = (
 	compression: undefined,
 	// TODO: It should already be the case that we're not modifying any metadata, not clear if/why this shallow clone should be required.
 	// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
-	metadata: { ...(originalMessage.metadata as any) },
+	metadata:
+		originalMessage.metadata === undefined
+			? undefined
+			: { ...(originalMessage.metadata as any) },
 });

package/src/opLifecycle/opGroupingManager.ts

@@ -3,11 +3,10 @@
  * Licensed under the MIT License.
  */
 
+import { ITelemetryBaseLogger } from "@fluidframework/core-interfaces";
 import { assert } from "@fluidframework/core-utils";
 import { ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
 import { createChildLogger } from "@fluidframework/telemetry-utils";
-import { ITelemetryBaseLogger } from "@fluidframework/core-interfaces";
-import { ContainerMessageType } from "../messageTypes.js";
 import { IBatch } from "./definitions.js";
 
 /**
@@ -28,6 +27,10 @@ function isGroupContents(opContents: any): opContents is IGroupedBatchMessageCon
 	return opContents?.type === OpGroupingManager.groupedBatchOp;
 }
 
+export function isGroupedBatch(op: ISequencedDocumentMessage): boolean {
+	return isGroupContents(op.contents);
+}
+
 export interface OpGroupingManagerConfig {
 	readonly groupedBatchingEnabled: boolean;
 	readonly opCountThreshold: number;
@@ -46,9 +49,7 @@ export class OpGroupingManager {
 	}
 
 	public groupBatch(batch: IBatch): IBatch {
-		if (!this.shouldGroup(batch)) {
-			return batch;
-		}
+		assert(this.shouldGroup(batch), "cannot group the provided batch");
 
 		if (batch.content.length >= 1000) {
 			this.logger.sendTelemetryEvent({
@@ -84,11 +85,9 @@ export class OpGroupingManager {
 			...batch,
 			content: [
 				{
-					localOpMetadata: undefined,
 					metadata: undefined,
 					referenceSequenceNumber: batch.content[0].referenceSequenceNumber,
 					contents: serializedContent,
-					type: OpGroupingManager.groupedBatchOp as ContainerMessageType,
 				},
 			],
 		};
@@ -96,13 +95,11 @@ export class OpGroupingManager {
 	}
 
 	public ungroupOp(op: ISequencedDocumentMessage): ISequencedDocumentMessage[] {
-		if (!isGroupContents(op.contents)) {
-			return [op];
-		}
+		assert(isGroupContents(op.contents), "can only ungroup a grouped batch");
+		const contents: IGroupedBatchMessageContents = op.contents;
 
-		const messages = op.contents.contents;
 		let fakeCsn = 1;
-		return messages.map((subMessage) => ({
+		return contents.contents.map((subMessage) => ({
 			...op,
 			clientSequenceNumber: fakeCsn++,
 			contents: subMessage.contents,

package/src/opLifecycle/opSplitter.ts

@@ -3,18 +3,31 @@
  * Licensed under the MIT License.
  */
 
+import { IBatchMessage } from "@fluidframework/container-definitions";
+import { ITelemetryBaseLogger } from "@fluidframework/core-interfaces";
+import { assert } from "@fluidframework/core-utils";
+import { ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
 import {
-	createChildLogger,
 	DataCorruptionError,
+	createChildLogger,
 	extractSafePropertiesFromMessage,
 } from "@fluidframework/telemetry-utils";
-import { assert } from "@fluidframework/core-utils";
-import { IBatchMessage } from "@fluidframework/container-definitions";
-import { ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
-import { ITelemetryBaseLogger } from "@fluidframework/core-interfaces";
 import { ContainerMessageType, ContainerRuntimeChunkedOpMessage } from "../messageTypes.js";
 import { estimateSocketSize } from "./batchManager.js";
-import { BatchMessage, IBatch, IChunkedOp, IMessageProcessingResult } from "./definitions.js";
+import { BatchMessage, IBatch, IChunkedOp } from "./definitions.js";
+
+export function isChunkedMessage(message: ISequencedDocumentMessage): boolean {
+	return isChunkedContents(message.contents);
+}
+
+interface IChunkedContents {
+	type: typeof ContainerMessageType.ChunkedOp;
+	contents: IChunkedOp;
+}
+
+function isChunkedContents(contents: any): contents is IChunkedContents {
+	return contents?.type === ContainerMessageType.ChunkedOp;
+}
 
 /**
  * Responsible for creating and reconstructing chunked messages.
@@ -45,44 +58,6 @@ export class OpSplitter {
 		return this.chunkMap;
 	}
 
-	public processRemoteMessage(message: ISequencedDocumentMessage): IMessageProcessingResult {
-		if (message.type !== ContainerMessageType.ChunkedOp) {
-			return {
-				message,
-				state: "Skipped",
-			};
-		}
-
-		// TODO: Verify whether this should be able to handle server-generated ops (with null clientId)
-		// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
-		const clientId = message.clientId as string;
-		const chunkedContent = message.contents as IChunkedOp;
-		this.addChunk(clientId, chunkedContent, message);
-
-		if (chunkedContent.chunkId < chunkedContent.totalChunks) {
-			// We are processing the op in chunks but haven't reached
-			// the last chunk yet in order to reconstruct the original op
-			return {
-				message,
-				state: "Accepted",
-			};
-		}
-
-		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-		const serializedContent = this.chunkMap.get(clientId)!.join("");
-		this.clearPartialChunks(clientId);
-
-		const newMessage = { ...message };
-		newMessage.contents = serializedContent === "" ? undefined : JSON.parse(serializedContent);
-		newMessage.type = chunkedContent.originalType;
-		newMessage.metadata = chunkedContent.originalMetadata;
-		newMessage.compression = chunkedContent.originalCompression;
-		return {
-			message: newMessage,
-			state: "Processed",
-		};
-	}
-
 	public clearPartialChunks(clientId: string) {
 		if (this.chunkMap.has(clientId)) {
 			this.chunkMap.delete(clientId);
@@ -203,8 +178,53 @@ export class OpSplitter {
 			referenceSequenceNumber: batch.referenceSequenceNumber,
 		};
 	}
+
+	public processChunk(message: ISequencedDocumentMessage): ProcessChunkResult {
+		assert(isChunkedContents(message.contents), "message not of type ChunkedOp");
+		const contents: IChunkedContents = message.contents;
+
+		// TODO: Verify whether this should be able to handle server-generated ops (with null clientId)
+		// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
+		const clientId = message.clientId as string;
+		const chunkedContent = contents.contents;
+		this.addChunk(clientId, chunkedContent, message);
+
+		if (chunkedContent.chunkId < chunkedContent.totalChunks) {
+			// We are processing the op in chunks but haven't reached
+			// the last chunk yet in order to reconstruct the original op
+			return {
+				isFinalChunk: false,
+			};
+		}
+
+		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+		const serializedContent = this.chunkMap.get(clientId)!.join("");
+		this.clearPartialChunks(clientId);
+
+		const newMessage = { ...message };
+		newMessage.contents = serializedContent === "" ? undefined : JSON.parse(serializedContent);
+		// 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.
+		newMessage.type = (chunkedContent as any).originalType;
+		newMessage.metadata = chunkedContent.originalMetadata;
+		newMessage.compression = chunkedContent.originalCompression;
+		return {
+			message: newMessage,
+			isFinalChunk: true,
+		};
+	}
 }
 
+type ProcessChunkResult =
+	| {
+			readonly isFinalChunk: false;
+	  }
+	| {
+			readonly isFinalChunk: true;
+			readonly message: ISequencedDocumentMessage;
+	  };
+
 const chunkToBatchMessage = (
 	chunk: IChunkedOp,
 	referenceSequenceNumber: number,
@@ -216,9 +236,7 @@ const chunkToBatchMessage = (
 	};
 	return {
 		contents: JSON.stringify(payload),
-		type: payload.type,
 		metadata,
-		localOpMetadata: undefined,
 		referenceSequenceNumber,
 	};
 };
@@ -253,7 +271,6 @@ export const splitOp = (
 		const chunk: IChunkedOp = {
 			chunkId,
 			contents: op.contents.substr(offset, chunkSizeInBytes),
-			originalType: op.type,
 			totalChunks: chunkCount,
 		};
 
@@ -263,6 +280,15 @@ export const splitOp = (
 			// last chunk, therefore it is the only one that needs it.
 			chunk.originalMetadata = op.metadata;
 			chunk.originalCompression = op.compression;
+
+			// back-compat with 1.x builds
+			// 2.x builds only do chunking for compressed ops.
+			// originalType is no longer used in such cases, as each op preserves its type within compressed payload.
+			// But, if 1.x builds see this op, and there is no type on the message, then it will ignore this message silently.
+			// 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)
+			(chunk as any).originalType = "component";
 		}
 
 		chunks.push(chunk);

package/src/opLifecycle/outbox.ts

@@ -3,18 +3,17 @@
  * Licensed under the MIT License.
  */
 
+import { IBatchMessage, ICriticalContainerError } from "@fluidframework/container-definitions";
+import { ITelemetryBaseLogger } from "@fluidframework/core-interfaces";
+import { assert } from "@fluidframework/core-utils";
 import {
-	createChildMonitoringContext,
 	GenericError,
 	MonitoringContext,
 	UsageError,
+	createChildMonitoringContext,
 } from "@fluidframework/telemetry-utils";
-import { assert } from "@fluidframework/core-utils";
-import { IBatchMessage, ICriticalContainerError } from "@fluidframework/container-definitions";
-import { ITelemetryBaseLogger } from "@fluidframework/core-interfaces";
 import { ICompressionRuntimeOptions } from "../containerRuntime.js";
 import { IPendingBatchMessage, PendingStateManager } from "../pendingStateManager.js";
-import { ContainerMessageType } from "../messageTypes.js";
 import {
 	BatchManager,
 	BatchSequenceNumbers,
@@ -187,20 +186,12 @@ export class Outbox {
 	}
 
 	public submit(message: BatchMessage) {
-		assert(
-			message.type !== ContainerMessageType.IdAllocation,
-			0x8f8 /* Allocation message submitted to mainBatch. */,
-		);
 		this.maybeFlushPartialBatch();
 
 		this.addMessageToBatchManager(this.mainBatch, message);
 	}
 
 	public submitAttach(message: BatchMessage) {
-		assert(
-			message.type === ContainerMessageType.Attach,
-			0x8f9 /* Non attach message submitted to attachFlowBatch. */,
-		);
 		this.maybeFlushPartialBatch();
 
 		if (
@@ -232,10 +223,6 @@ export class Outbox {
 	}
 
 	public submitBlobAttach(message: BatchMessage) {
-		assert(
-			message.type === ContainerMessageType.BlobAttach,
-			0x8fa /* Non blobAttach message submitted to blobAttachBatch. */,
-		);
 		this.maybeFlushPartialBatch();
 
 		this.addMessageToBatchManager(this.blobAttachBatch, message);
@@ -254,10 +241,6 @@ export class Outbox {
 	}
 
 	public submitIdAllocation(message: BatchMessage) {
-		assert(
-			message.type === ContainerMessageType.IdAllocation,
-			0x8fb /* Non allocation message submitted to idAllocationBatch. */,
-		);
 		this.maybeFlushPartialBatch();
 
 		if (
@@ -328,10 +311,9 @@ export class Outbox {
 		}
 
 		const rawBatch = batchManager.popBatch();
-		if (
-			rawBatch.hasReentrantOps === true &&
-			this.params.groupingManager.shouldGroup(rawBatch)
-		) {
+		const shouldGroup =
+			!disableGroupedBatching && this.params.groupingManager.shouldGroup(rawBatch);
+		if (rawBatch.hasReentrantOps === true && shouldGroup) {
 			assert(!this.rebasing, 0x6fa /* A rebased batch should never have reentrant ops */);
 			// If a batch contains reentrant ops (ops created as a result from processing another op)
 			// it needs to be rebased so that we can ensure consistent reference sequence numbers
@@ -344,7 +326,9 @@ 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(rawBatch, disableGroupedBatching);
+			const processedBatch = this.compressBatch(
+				shouldGroup ? this.params.groupingManager.groupBatch(rawBatch) : rawBatch,
+			);
 			this.sendBatch(processedBatch);
 		}
 
@@ -390,7 +374,7 @@ export class Outbox {
 		return this.params.opReentrancy() && !this.rebasing;
 	}
 
-	private compressBatch(batch: IBatch, disableGroupedBatching: boolean): IBatch {
+	private compressBatch(batch: IBatch): IBatch {
 		if (
 			batch.content.length === 0 ||
 			this.params.config.compressionOptions === undefined ||
@@ -399,12 +383,10 @@ export class Outbox {
 			this.params.submitBatchFn === undefined
 		) {
 			// 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 disableGroupedBatching ? batch : this.params.groupingManager.groupBatch(batch);
+			return batch;
 		}
 
-		const compressedBatch = this.params.compressor.compressBatch(
-			disableGroupedBatching ? batch : this.params.groupingManager.groupBatch(batch),
-		);
+		const compressedBatch = this.params.compressor.compressBatch(batch);
 
 		if (this.params.splitter.isBatchChunkingEnabled) {
 			return compressedBatch.contentSizeInBytes <= this.params.splitter.chunkSizeInBytes

package/src/opLifecycle/remoteMessageProcessor.ts

@@ -12,8 +12,8 @@ import {
 	type InboundSequencedRecentlyAddedContainerRuntimeMessage,
 } from "../messageTypes.js";
 import { OpDecompressor } from "./opDecompressor.js";
-import { OpGroupingManager } from "./opGroupingManager.js";
-import { OpSplitter } from "./opSplitter.js";
+import { OpGroupingManager, isGroupedBatch } from "./opGroupingManager.js";
+import { OpSplitter, isChunkedMessage } from "./opSplitter.js";
 
 /**
  * Stateful class for processing incoming remote messages as the virtualization measures are unwrapped,
@@ -44,6 +44,14 @@ export class RemoteMessageProcessor {
 	 * depends on this object instance.
 	 * Note remoteMessageCopy.contents (and other object props) MUST not be modified,
 	 * but may be overwritten (as is the case with contents).
+	 *
+	 * Incoming messages will always have compression, chunking, and grouped batching happen in a defined order and that order cannot be changed.
+	 * When processing these messages, the order is:
+	 * 1. If chunked, process the chunk and only continue if this is a final chunk
+	 * 2. If compressed, decompress the message and store for further unrolling of the decompressed content
+	 * 3. If grouped, ungroup the message
+	 * For more details, see https://github.com/microsoft/FluidFramework/blob/main/packages/runtime/container-runtime/src/opLifecycle/README.md#inbound
+	 *
 	 * @returns the unchunked, decompressed, ungrouped, unpacked SequencedContainerRuntimeMessages encapsulated in the remote message.
 	 * For ops that weren't virtualized (e.g. System ops that the ContainerRuntime will ultimately ignore),
 	 * a singleton array [remoteMessageCopy] is returned
@@ -51,63 +59,38 @@ export class RemoteMessageProcessor {
 	public process(
 		remoteMessageCopy: ISequencedDocumentMessage,
 	): InboundSequencedContainerRuntimeMessageOrSystemMessage[] {
-		const result: InboundSequencedContainerRuntimeMessageOrSystemMessage[] = [];
-
-		ensureContentsDeserialized(remoteMessageCopy);
-
-		// Ungroup before and after decompression for back-compat (cleanup tracked by AB#4371)
-		for (const ungroupedMessage of this.opGroupingManager.ungroupOp(remoteMessageCopy)) {
-			const message = this.opDecompressor.processMessage(ungroupedMessage).message;
-
-			for (let ungroupedMessage2 of this.opGroupingManager.ungroupOp(message)) {
-				// unpack and unchunk the ungrouped message in place
-				unpackRuntimeMessage(ungroupedMessage2);
-				const chunkProcessingResult =
-					this.opSplitter.processRemoteMessage(ungroupedMessage2);
-				ungroupedMessage2 = chunkProcessingResult.message;
-
-				// if the splitter is still rebuilding the original message, there is no need to continue processing
-				if (chunkProcessingResult.state === "Accepted") {
-					continue;
-				}
-
-				// If the message is not chunked there is no need to continue processing
-				if (chunkProcessingResult.state !== "Processed") {
-					result.push(
-						ungroupedMessage2 as InboundSequencedContainerRuntimeMessageOrSystemMessage,
-					);
-					continue;
-				}
-
-				// Ungroup before and after decompression for back-compat (cleanup tracked by AB#4371)
-				for (const ungroupedMessageAfterChunking of this.opGroupingManager.ungroupOp(
-					ungroupedMessage2,
-				)) {
-					const decompressionAfterChunking = this.opDecompressor.processMessage(
-						ungroupedMessageAfterChunking,
-					);
-
-					for (const ungroupedMessageAfterChunking2 of this.opGroupingManager.ungroupOp(
-						decompressionAfterChunking.message,
-					)) {
-						if (decompressionAfterChunking.state === "Skipped") {
-							// After chunking, if the original message was not compressed,
-							// there is no need to continue processing
-							result.push(
-								ungroupedMessageAfterChunking2 as InboundSequencedContainerRuntimeMessageOrSystemMessage,
-							);
-							continue;
-						}
-
-						// The message needs to be unpacked after chunking + decompression
-						unpack(ungroupedMessageAfterChunking2);
-						result.push(ungroupedMessageAfterChunking2);
-					}
-				}
+		let message = remoteMessageCopy;
+		ensureContentsDeserialized(message);
+
+		if (isChunkedMessage(message)) {
+			const chunkProcessingResult = this.opSplitter.processChunk(message);
+			// Only continue further if current chunk is the final chunk
+			if (!chunkProcessingResult.isFinalChunk) {
+				return [];
 			}
+			// This message will always be compressed
+			message = chunkProcessingResult.message;
 		}
 
-		return result;
+		if (this.opDecompressor.isCompressedMessage(message)) {
+			this.opDecompressor.decompressAndStore(message);
+		}
+
+		if (this.opDecompressor.currentlyUnrolling) {
+			message = this.opDecompressor.unroll(message);
+			// Need to unpack after unrolling if not a groupedBatch
+			if (!isGroupedBatch(message)) {
+				unpack(message);
+			}
+		}
+
+		if (isGroupedBatch(message)) {
+			return this.opGroupingManager.ungroupOp(message).map(unpack);
+		}
+
+		// Do a final unpack of runtime messages in case the message was not grouped, compressed, or chunked
+		unpackRuntimeMessage(message);
+		return [message as InboundSequencedContainerRuntimeMessageOrSystemMessage];
 	}
 }
 
@@ -128,9 +111,7 @@ function ensureContentsDeserialized(mutableMessage: ISequencedDocumentMessage):
  * becomes a InboundSequencedContainerRuntimeMessage by the time the function returns
  * (but there is no runtime validation of the 'type' or 'compatDetails' values).
  */
-function unpack(
-	message: ISequencedDocumentMessage,
-): asserts message is InboundSequencedContainerRuntimeMessage {
+function unpack(message: ISequencedDocumentMessage): InboundSequencedContainerRuntimeMessage {
 	// We assume the contents is an InboundContainerRuntimeMessage (the message is "packed")
 	const contents = message.contents as InboundContainerRuntimeMessage;
 
@@ -143,6 +124,7 @@ function unpack(
 		(messageUnpacked as InboundSequencedRecentlyAddedContainerRuntimeMessage).compatDetails =
 			contents.compatDetails;
 	}
+	return messageUnpacked;
 }
 
 /**