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

package/src/opLifecycle/README.md

@@ -13,6 +13,9 @@
 -   [Note about performance and latency](#note-about-performance-and-latency)
 -   [How it works](#how-it-works)
 -   [How grouped batching works](#how-grouped-batching-works)
+-   [How the overall op flow works](#How-the-overall-op-flow-works)
+    -   [Outbound](#outbound)
+    -   [Inbound](#inbound)
 
 ## Introduction
 
@@ -317,3 +320,89 @@ Ungrouped batch:
 | ClientSeqNum: 1 | ClientSeqNum: 2 | ClientSeqNum: 3 | ClientSeqNum: 4 | ClientSeqNum: 5 |
 +-----------------+-----------------+-----------------+-----------------+-----------------+
 ```
+
+## How the overall op flow works
+
+### Outbound
+
+The outbound view is how ops are accumulated and sent by the runtime with `FlushMode.TurnBased` (default).
+
+```mermaid
+stateDiagram-v2
+	state "* End of JS turn *" as jsTurn
+    state "opGroupingManager.groupBatch" as groupBatch
+    state "opCompressor.compress" as compress
+    state "outbox.flush" as flush
+    state "outbox.flushInternal" as flushInternal
+	state "Send batch over the wire" as post
+	state "Send chunks (partial ops) over the wire" as postChunks
+	state "Store original (uncompressed, unchunked, ungrouped) batch locally" as store
+    state if_compression <<choice>>
+	[*] --> ContainerRuntime.submit
+	ContainerRuntime.submit --> outbox.submitAttach
+	ContainerRuntime.submit --> outbox.submitBlobAttach
+	ContainerRuntime.submit --> outbox.submit
+	outbox.submit --> scheduleFlush
+	outbox.submitAttach --> scheduleFlush
+	outbox.submitBlobAttach --> scheduleFlush
+	scheduleFlush --> jsTurn
+	jsTurn --> flush
+	flush --> outbox.flushInternalMain
+	flush --> outbox.flushInternalAttach
+	flush --> outbox.flushInternalBlobAttach
+	outbox.flushInternalMain --> flushInternal
+	outbox.flushInternalAttach --> flushInternal
+	outbox.flushInternalBlobAttach --> flushInternal
+	flushInternal --> ContainerRuntime.reSubmit: if batch has reentrant ops and should group
+	ContainerRuntime.reSubmit --> flushInternal
+    flushInternal --> groupBatch: if should group
+    groupBatch --> if_compression
+	flushInternal --> if_compression
+    if_compression --> post
+	if_compression --> compress: if compression is enabled
+	compress --> post
+	compress --> opSplitter.split: if the compressed payload is larger than the chunk size
+	opSplitter.split --> post
+	opSplitter.split --> postChunks
+    post --> store
+```
+
+With `FlushMode.Immediate`(deprecated) the difference is that ops are no longer accumulated in batches, but flushed as they are submitted, instead of waiting for the end of the JS turn. All the other components work in the exact same manner with the difference that they operate on batches with length 1.
+
+### Inbound
+
+There is no concept of batch in the inbound view when we receive the ops. Ops are being received and processed one-by-one and the batch is reconstructed in the runtime layer. This requires individual components to maintain their own internal state in order to keep track of the batch.
+
+```mermaid
+stateDiagram-v2
+    [*] --> ContainerRuntime.process
+	ContainerRuntime.process --> remoteMessageProcessor
+    state remoteMessageProcessor {
+        state "process chunk" as processChunk
+        state "return nothing" as returnNothing
+        state "decompress and store" as decompress
+        state if_chunk <<choice>>
+        state if_compressed <<choice>>
+        state if_unrolling <<choice>>
+        state if_grouped <<choice>>
+        [*] --> if_chunk
+        if_chunk --> if_compressed
+        if_chunk --> processChunk: is chunk
+        processChunk --> returnNothing
+        processChunk --> if_compressed: is final chunk
+        if_compressed --> if_unrolling
+        if_compressed --> decompress: is compressed
+        decompress --> if_unrolling
+        if_unrolling --> if_grouped
+        if_unrolling --> unroll: if currently unrolling
+        unroll --> if_grouped
+        if_grouped --> return
+        if_grouped --> ungroup: is grouped batch
+        ungroup --> return
+        return --> [*]
+        returnNothing --> [*]
+    }
+    remoteMessageProcessor --> ContainerRuntime.procesCore
+```
+
+Note that a "system op" originating outside the ContainerRuntime will pass through this flow entirely.

package/src/opLifecycle/batchManager.ts

@@ -4,6 +4,7 @@
  */
 
 import { ICompressionRuntimeOptions } from "../containerRuntime.js";
+
 import { BatchMessage, IBatch, IBatchCheckpoint } from "./definitions.js";
 
 export interface IBatchManagerOptions {

package/src/opLifecycle/definitions.ts

@@ -3,17 +3,15 @@
  * Licensed under the MIT License.
  */
 
-import { IBatchMessage } from "@fluidframework/container-definitions";
-import { ISequencedDocumentMessage, MessageType } from "@fluidframework/protocol-definitions";
+import { IBatchMessage } from "@fluidframework/container-definitions/internal";
+
 import { CompressionAlgorithms } from "../containerRuntime.js";
-import { ContainerMessageType } from "../messageTypes.js";
 
 /**
  * Batch message type used internally by the runtime
  */
 export type BatchMessage = IBatchMessage & {
-	localOpMetadata: unknown;
-	type: ContainerMessageType;
+	localOpMetadata?: unknown;
 	referenceSequenceNumber: number;
 	compression?: CompressionAlgorithms;
 };
@@ -59,7 +57,6 @@ export interface IChunkedOp {
 	chunkId: number;
 	totalChunks: number;
 	contents: string;
-	originalType: MessageType | ContainerMessageType;
 	originalMetadata?: Record<string, unknown>;
 	originalCompression?: string;
 }
@@ -72,18 +69,3 @@ export interface IChunkedOp {
  * will make the processor return `Processed`.
  */
 export type ProcessingState = "Processed" | "Skipped" | "Accepted";
-
-/**
- * Return type for functions which process remote messages
- */
-export interface IMessageProcessingResult {
-	/**
-	 * A shallow copy of the input message if processing happened, or
-	 * the original message otherwise
-	 */
-	readonly message: ISequencedDocumentMessage;
-	/**
-	 * Processing result of the input message.
-	 */
-	readonly state: ProcessingState;
-}

package/src/opLifecycle/index.ts

@@ -4,16 +4,10 @@
  */
 
 export { BatchManager, estimateSocketSize, BatchSequenceNumbers } from "./batchManager.js";
-export {
-	BatchMessage,
-	IBatch,
-	IBatchCheckpoint,
-	IChunkedOp,
-	IMessageProcessingResult,
-} from "./definitions.js";
+export { BatchMessage, IBatch, IBatchCheckpoint, IChunkedOp } from "./definitions.js";
 export { Outbox, getLongStack } from "./outbox.js";
 export { OpCompressor } from "./opCompressor.js";
 export { OpDecompressor } from "./opDecompressor.js";
-export { OpSplitter, splitOp } from "./opSplitter.js";
+export { OpSplitter, splitOp, isChunkedMessage } from "./opSplitter.js";
 export { RemoteMessageProcessor, unpackRuntimeMessage } from "./remoteMessageProcessor.js";
-export { OpGroupingManager } from "./opGroupingManager.js";
+export { OpGroupingManager, OpGroupingManagerConfig, isGroupedBatch } from "./opGroupingManager.js";

package/src/opLifecycle/opCompressor.ts

@@ -3,14 +3,16 @@
  * Licensed under the MIT License.
  */
 
-import { createChildLogger, UsageError } from "@fluidframework/telemetry-utils";
-import { assert } from "@fluidframework/core-utils";
 import { IsoBuffer } from "@fluid-internal/client-utils";
-import { compress } from "lz4js";
 import { ITelemetryBaseLogger } from "@fluidframework/core-interfaces";
+import { assert } from "@fluidframework/core-utils/internal";
+import { UsageError, createChildLogger } from "@fluidframework/telemetry-utils/internal";
+import { compress } from "lz4js";
+
 import { CompressionAlgorithms } from "../containerRuntime.js";
+
 import { estimateSocketSize } from "./batchManager.js";
-import { IBatch, BatchMessage } from "./definitions.js";
+import { BatchMessage, IBatch } from "./definitions.js";
 
 /**
  * Compresses batches of ops. It generates a single compressed op that contains
@@ -47,7 +49,6 @@ export class OpCompressor {
 		// Add empty placeholder messages to reserve the sequence numbers
 		for (const message of batch.content.slice(1)) {
 			messages.push({
-				type: message.type,
 				localOpMetadata: message.localOpMetadata,
 				metadata: message.metadata,
 				referenceSequenceNumber: message.referenceSequenceNumber,

package/src/opLifecycle/opDecompressor.ts

@@ -3,15 +3,15 @@
  * 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/internal";
+import { ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
+import { createChildLogger } from "@fluidframework/telemetry-utils/internal";
+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 +38,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 +81,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 +167,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,11 @@
  * Licensed under the MIT License.
  */
 
-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 { assert } from "@fluidframework/core-utils/internal";
+import { ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
+import { createChildLogger } from "@fluidframework/telemetry-utils/internal";
+
 import { IBatch } from "./definitions.js";
 
 /**
@@ -28,6 +28,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 +50,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 +86,9 @@ export class OpGroupingManager {
 			...batch,
 			content: [
 				{
-					localOpMetadata: undefined,
 					metadata: undefined,
 					referenceSequenceNumber: batch.content[0].referenceSequenceNumber,
 					contents: serializedContent,
-					type: OpGroupingManager.groupedBatchOp as ContainerMessageType,
 				},
 			],
 		};
@@ -96,13 +96,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,33 @@
  * Licensed under the MIT License.
  */
 
+import { IBatchMessage } from "@fluidframework/container-definitions/internal";
+import { ITelemetryBaseLogger } from "@fluidframework/core-interfaces";
+import { assert } from "@fluidframework/core-utils/internal";
+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";
+} from "@fluidframework/telemetry-utils/internal";
+
 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 +60,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 +180,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 +238,7 @@ const chunkToBatchMessage = (
 	};
 	return {
 		contents: JSON.stringify(payload),
-		type: payload.type,
 		metadata,
-		localOpMetadata: undefined,
 		referenceSequenceNumber,
 	};
 };
@@ -253,7 +273,6 @@ export const splitOp = (
 		const chunk: IChunkedOp = {
 			chunkId,
 			contents: op.contents.substr(offset, chunkSizeInBytes),
-			originalType: op.type,
 			totalChunks: chunkCount,
 		};
 
@@ -263,6 +282,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);