@fluidframework/container-runtime 2.0.0-dev.6.4.0.192049 → 2.0.0-dev.7.2.0.204906

package/src/index.ts

@@ -4,10 +4,6 @@
  */
 
 export {
-	ContainerMessageType,
-	ContainerRuntimeMessage,
-	IContainerRuntimeMessageCompatDetails,
-	CompatModeBehavior,
 	ISummaryRuntimeOptions,
 	ISummaryBaseConfiguration,
 	ISummaryConfigurationHeuristics,
@@ -27,9 +23,25 @@ export {
 	DefaultSummaryConfiguration,
 	ICompressionRuntimeOptions,
 	CompressionAlgorithms,
+	TEST_requestSummarizer,
 } from "./containerRuntime";
+export {
+	ContainerMessageType,
+	ContainerRuntimeMessage,
+	IContainerRuntimeMessageCompatDetails,
+	CompatModeBehavior,
+	RecentlyAddedContainerRuntimeMessageDetails,
+} from "./messageTypes";
+export { IBlobManagerLoadInfo } from "./blobManager";
 export { FluidDataStoreRegistry } from "./dataStoreRegistry";
-export { IGCRuntimeOptions, IGCStats } from "./gc";
+export {
+	GCNodeType,
+	IGCMetadata,
+	GCFeatureMatrix,
+	GCVersion,
+	IGCRuntimeOptions,
+	IGCStats,
+} from "./gc";
 export {
 	IAckedSummary,
 	ISummarizer,
@@ -45,6 +57,8 @@ export {
 	IBroadcastSummaryResult,
 	ICancellationToken,
 	IConnectableRuntime,
+	IContainerRuntimeMetadata,
+	ICreateContainerMetadata,
 	IEnqueueSummarizeOptions,
 	IGenerateSummaryTreeResult,
 	IGeneratedSummaryStats,
@@ -53,6 +67,7 @@ export {
 	IRefreshSummaryAckOptions,
 	ISubmitSummaryOpResult,
 	ISubmitSummaryOptions,
+	ISerializedElection,
 	ISummarizeOptions,
 	ISummarizerEvents,
 	ISummarizerInternalsProvider,
@@ -65,6 +80,7 @@ export {
 	ISummary,
 	ISummaryCollectionOpEvents,
 	ISummaryAckMessage,
+	ISummaryMetadataMessage,
 	ISummaryNackMessage,
 	ISummaryOpMessage,
 	OpActionEventListener,

package/src/messageTypes.ts

@@ -0,0 +1,228 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
+import {
+	IEnvelope,
+	InboundAttachMessage,
+	IAttachMessage,
+	IdCreationRangeWithStashedState,
+	IdCreationRange,
+} from "@fluidframework/runtime-definitions";
+import { IDataStoreAliasMessage } from "./dataStore";
+import { IChunkedOp } from "./opLifecycle";
+
+/**
+ * @public
+ */
+export enum ContainerMessageType {
+	// An op to be delivered to store
+	FluidDataStoreOp = "component",
+
+	// Creates a new store
+	Attach = "attach",
+
+	// Chunked operation.
+	ChunkedOp = "chunkedOp",
+
+	// Signifies that a blob has been attached and should not be garbage collected by storage
+	BlobAttach = "blobAttach",
+
+	// Ties our new clientId to our old one on reconnect
+	Rejoin = "rejoin",
+
+	// Sets the alias of a root data store
+	Alias = "alias",
+
+	/**
+	 * An op containing an IdRange of Ids allocated using the runtime's IdCompressor since
+	 * the last allocation op was sent.
+	 * See the [IdCompressor README](./id-compressor/README.md) for more details.
+	 */
+	IdAllocation = "idAllocation",
+}
+
+/**
+ * How should an older client handle an unrecognized remote op type?
+ *
+ * @internal
+ */
+export type CompatModeBehavior =
+	/** Ignore the op. It won't be persisted if this client summarizes */
+	| "Ignore"
+	/** Fail processing immediately. (The container will close) */
+	| "FailToProcess";
+
+/**
+ * All the info an older client would need to know how to handle an unrecognized remote op type
+ *
+ * @internal
+ */
+export interface IContainerRuntimeMessageCompatDetails {
+	/** How should an older client handle an unrecognized remote op type? */
+	behavior: CompatModeBehavior;
+}
+
+/**
+ * The unpacked runtime message / details to be handled or dispatched by the ContainerRuntime.
+ * Message type are differentiated via a `type` string and contain different contents depending on their type.
+ *
+ * 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 of the op, within the ContainerRuntime's domain */
+	type: TType;
+	/** Domain-specific contents, interpreted according to the type */
+	contents: TContents;
+}
+
+/**
+ * Additional details expected for any recently added message.
+ * @internal
+ */
+export interface RecentlyAddedContainerRuntimeMessageDetails {
+	/** Info describing how to handle this op in case the type is unrecognized (default: fail to process) */
+	compatDetails: IContainerRuntimeMessageCompatDetails;
+}
+
+export type ContainerRuntimeDataStoreOpMessage = TypedContainerRuntimeMessage<
+	ContainerMessageType.FluidDataStoreOp,
+	IEnvelope
+>;
+export type InboundContainerRuntimeAttachMessage = TypedContainerRuntimeMessage<
+	ContainerMessageType.Attach,
+	InboundAttachMessage
+>;
+export type OutboundContainerRuntimeAttachMessage = TypedContainerRuntimeMessage<
+	ContainerMessageType.Attach,
+	IAttachMessage
+>;
+export type ContainerRuntimeChunkedOpMessage = TypedContainerRuntimeMessage<
+	ContainerMessageType.ChunkedOp,
+	IChunkedOp
+>;
+export type ContainerRuntimeBlobAttachMessage = TypedContainerRuntimeMessage<
+	ContainerMessageType.BlobAttach,
+	undefined
+>;
+export type ContainerRuntimeRejoinMessage = TypedContainerRuntimeMessage<
+	ContainerMessageType.Rejoin,
+	undefined
+>;
+export type ContainerRuntimeAliasMessage = TypedContainerRuntimeMessage<
+	ContainerMessageType.Alias,
+	IDataStoreAliasMessage
+>;
+export type LocalContainerRuntimeIdAllocationMessage = TypedContainerRuntimeMessage<
+	ContainerMessageType.IdAllocation,
+	IdCreationRangeWithStashedState
+>;
+export type ContainerRuntimeIdAllocationMessage = TypedContainerRuntimeMessage<
+	ContainerMessageType.IdAllocation,
+	IdCreationRange & { stashedState?: never }
+>;
+
+/**
+ * Represents an unrecognized {@link TypedContainerRuntimeMessage}, e.g. a message from a future version of the container runtime.
+ * @internal
+ */
+export interface UnknownContainerRuntimeMessage
+	extends Partial<RecentlyAddedContainerRuntimeMessageDetails> {
+	/** Invalid type of the op, within the ContainerRuntime's domain. This value should never exist at runtime.
+	 * This is useful for type narrowing but should never be used as an actual message type at runtime.
+	 * Actual value will not be "__unknown...", but the type `Exclude<string, ContainerMessageType>` is not supported.
+	 */
+	type: "__unknown_container_message_type__never_use_as_value__";
+
+	/** Domain-specific contents, but not decipherable by an unknown op. */
+	contents: unknown;
+}
+
+/**
+ * A {@link TypedContainerRuntimeMessage} that is received from the server and will be processed by the container runtime.
+ */
+export type InboundContainerRuntimeMessage =
+	| ContainerRuntimeDataStoreOpMessage
+	| InboundContainerRuntimeAttachMessage
+	| ContainerRuntimeChunkedOpMessage
+	| ContainerRuntimeBlobAttachMessage
+	| ContainerRuntimeRejoinMessage
+	| ContainerRuntimeAliasMessage
+	| ContainerRuntimeIdAllocationMessage
+	// Inbound messages may include unknown types from other clients, so we include that as a special case here
+	| UnknownContainerRuntimeMessage;
+
+/** A {@link TypedContainerRuntimeMessage} that has been generated by the container runtime but is not yet being sent to the server. */
+export type LocalContainerRuntimeMessage =
+	| ContainerRuntimeDataStoreOpMessage
+	| OutboundContainerRuntimeAttachMessage
+	| ContainerRuntimeChunkedOpMessage
+	| ContainerRuntimeBlobAttachMessage
+	| ContainerRuntimeRejoinMessage
+	| ContainerRuntimeAliasMessage
+	| LocalContainerRuntimeIdAllocationMessage
+	// In rare cases (e.g. related to stashed ops) we could have a local message of an unknown type
+	| UnknownContainerRuntimeMessage;
+
+/** A {@link TypedContainerRuntimeMessage} that is being sent to the server from the container runtime. */
+export type OutboundContainerRuntimeMessage =
+	| ContainerRuntimeDataStoreOpMessage
+	| OutboundContainerRuntimeAttachMessage
+	| ContainerRuntimeChunkedOpMessage
+	| ContainerRuntimeBlobAttachMessage
+	| ContainerRuntimeRejoinMessage
+	| ContainerRuntimeAliasMessage
+	| ContainerRuntimeIdAllocationMessage;
+
+/**
+ * An unpacked ISequencedDocumentMessage with the inner TypedContainerRuntimeMessage type/contents/etc
+ * promoted up to the outer object
+ */
+export type InboundSequencedContainerRuntimeMessage = Omit<
+	ISequencedDocumentMessage,
+	"type" | "contents"
+> &
+	InboundContainerRuntimeMessage;
+
+/** Essentially ISequencedDocumentMessage except that `type` is not `string` to enable narrowing
+ * as `Exclude<string, InboundContainerRuntimeMessage['type']>` is not supported.
+ * There should never be a runtime value of "__not_a_...".
+ * Currently additionally replaces `contents` type until protocol-definitions update is taken with `unknown` instead of `any`.
+ */
+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.
+ */
+export type InboundSequencedRecentlyAddedContainerRuntimeMessage = ISequencedDocumentMessage &
+	Partial<RecentlyAddedContainerRuntimeMessageDetails>;
+
+/**
+ * The unpacked runtime message / details to be handled or dispatched by the ContainerRuntime
+ *
+ * IMPORTANT: when creating one to be serialized, set the properties in the order they appear here.
+ * This way stringified values can be compared.
+ *
+ * @deprecated this is an internal type which should not be used outside of the package.
+ * Internally, it is superseded by `TypedContainerRuntimeMessage`.
+ *
+ * @internal
+ */
+export interface ContainerRuntimeMessage {
+	/** Type of the op, within the ContainerRuntime's domain */
+	type: ContainerMessageType;
+	/** Domain-specific contents, interpreted according to the type */
+	contents: any;
+	/** Info describing how to handle this op in case the type is unrecognized (default: fail to process) */
+	compatDetails?: IContainerRuntimeMessageCompatDetails;
+}

package/src/opLifecycle/README.md

@@ -1,5 +1,19 @@
 # Configs and feature gates for solving the 1MB limit.
 
+## Table of contents
+
+-   [Introduction](#introduction)
+    -   [How batching works](#how-batching-works)
+-   [Compression](#compression)
+-   [Grouped batching](#grouped-batching)
+    -   [Risks](#risks)
+-   [Chunking for compression](#chunking-for-compression)
+-   [Disabling in case of emergency](#disabling-in-case-of-emergency)
+-   [Example configs](#example-configs)
+-   [Note about performance and latency](#note-about-performance-and-latency)
+-   [How it works](#how-it-works)
+-   [How grouped batching works](#how-grouped-batching-works)
+
 ## Introduction
 
 There is a current limitation regarding the size of the payload a Fluid client can send and receive. [The limit is 1MB per payload](https://github.com/microsoft/FluidFramework/issues/9023) and it is currently enforced explicitly with the `BatchTooLarge` error which closes the container.
@@ -8,17 +22,35 @@ There are two features which can be used to work around this size limit, batch c
 
 By default, the runtime is configured with a max batch size of `716800` bytes, which is lower than the 1MB limit. The reason for the lower value is to account for possible overhead from the op envelope and metadata.
 
-## Table of contents
+### How batching works
 
--   [Introduction](#introduction)
-    -   [Compression](#compression)
-    -   [Grouped batching](#grouped-batching)
-        -   [Risks](#risks)
-    -   [Chunking for compression](#chunking-for-compression)
-    -   [Disabling in case of emergency](#disabling-in-case-of-emergency)
-    -   [Example configs](#example-configs)
-    -   [How it works](#how-it-works)
-    -   [How grouped batching works](#how-grouped-batching-works)
+Batching in the context of Fluid ops is a way in which the framework accumulates and applies ops. A batch is a group of ops accumulated within a single JS turn, which will be broadcasted in the same order to all the other connected clients and applied synchronously. Additional logic and validation ensure that batches are never interleaved, nested or interrupted and they are processed in isolation without interleaving of ops from other clients.
+
+The way batches are formed is governed by the `FlushMode` setting of the `ContainerRuntimeOptions` and it is immutable for the entire lifetime of the runtime and subsequently the container.
+
+```
+export enum FlushMode {
+    /**
+     * In Immediate flush mode the runtime will immediately send all operations to the driver layer.
+     */
+    Immediate,
+
+    /**
+     * When in TurnBased flush mode the runtime will buffer operations in the current turn and send them as a single
+     * batch at the end of the turn. The flush call on the runtime can be used to force send the current batch.
+     */
+    TurnBased,
+}
+```
+
+What this means is that `FlushMode.Immediate` will send each op in its own payload to the server, while `FlushMode.TurnBased` will accumulate all ops in a single JS turn and send them together in the same payload. Technically, `FlushMode.Immediate` can be simulated with `FlushMode.TurnBased` by interrupting the JS turn after producing only one op (for example by pausing the execution to wait on a promise). Therefore, for all intents and purposes, `FlushMode.Immediate` enables all batches to have only one op.
+
+**By default, Fluid uses `FlushMode.TurnBased`** as:
+
+-   it is more efficient from an I/O perspective (batching ops overall decrease the number of payloads sent to the server)
+-   reduces concurrency related bugs, as it ensures that all ops generated within the same JS turn are also applied by all other clients within a single JS turn. Clients using the same pattern can safely assume ops will be applied exactly as they are observed locally. The alternative would be for ops to be both produced and applied with interruptions (which may involve processing input or rendering), invalidating the state based off which the changes were produced.
+
+As `FlushMode.TurnBased` accumulates ops, it is the most vulnerable to run into the 1MB socket limit.
 
 ## Compression
 
@@ -29,6 +61,8 @@ By default, the runtime is configured with a max batch size of `716800` bytes, w
 -   `minimumBatchSizeInBytes` – the minimum size of the batch for which compression should kick in. If the payload is too small, compression may not yield too many benefits. To target the original 1MB issue, a good value here would be to match the default maxBatchSizeInBytes (972800), however, experimentally, a good lower value could be at around 614400 bytes. Setting this value to `Number.POSITIVE_INFINITY` will disable compression.
 -   `compressionAlgorithm` – currently, only `lz4` is supported.
 
+Compression is relevant for both `FlushMode.TurnBased` and `FlushMode.Immediate` as it only targets the contents of the ops and not the number of ops in a batch. Compression is opaque to the server and implementations of the Fluid protocol do not need to alter their behavior to support this client feature.
+
 ## Grouped batching
 
 **Note: This feature is currently considered experimental and is not ready for production usage.**
@@ -71,6 +105,8 @@ If all prerequisites in the previous section are met, enabling the feature can b
 
 In case of emergency grouped batching can be disabled at runtime, using feature gates. If `"Fluid.ContainerRuntime.DisableGroupedBatching"` is set to `true`, it will disable grouped batching if enabled from `IContainerRuntimeOptions` in the code.
 
+Grouped batching is only relevant for `FlushMode.TurnBased` as it only targets the number of ops in a batch. Grouped batching is opaque to the server and implementations of the Fluid protocol do not need to alter their behavior to support this client feature.
+
 ## Chunking for compression
 
 **Op chunking for compression targets payloads which exceed the max batch size after compression.** So, only payloads which are already compressed. By default, the feature is enabled.
@@ -79,6 +115,8 @@ The `IContainerRuntimeOptions.chunkSizeInBytes` property is the only configurati
 
 This config would govern chunking compressed batches only. We will not be enabling chunking across all types of ops/batches but **only when compression is enabled and when the batch is compressed**, and its payload size is more than `IContainerRuntimeOptions.chunkSizeInBytes`.
 
+Chunking is relevant for both `FlushMode.TurnBased` and `FlushMode.Immediate` as it only targets the contents of the ops and not the number of ops in a batch. Chunking is opaque to the server and implementations of the Fluid protocol do not need to alter their behavior to support this client feature.
+
 ## Disabling in case of emergency
 
 If the features are enabled using the configs, they can be disabled at runtime via feature gates as following:
@@ -102,32 +140,19 @@ By default, the runtime is configured with the following values related to compr
     }
 ```
 
-To use compression but disable chunking:
+To enable grouped batching, use the following property:
 
 ```
     const runtimeOptions: IContainerRuntimeOptions = {
-        chunkSizeInBytes: Number.POSITIVE_INFINITY,
+        enableGroupedBatching: true,
     }
 ```
 
-To disable compression (will also disable chunking, as chunking works only for compressed batches):
+## Note about performance and latency
 
-```
-    const runtimeOptions: IContainerRuntimeOptions = {
-        compressionOptions: {
-            minimumBatchSizeInBytes: Number.POSITIVE_INFINITY,
-            compressionAlgorithm: CompressionAlgorithms.lz4,
-        },
-    }
-```
+In terms of performance and impact on latency, the results greatly depend on payload size, payload structure, network speed and CPU speed. Therefore, customers must perform the required measurements and adjust the settings according to their scenarios.
 
-To enable grouped batching:
-
-```
-    const runtimeOptions: IContainerRuntimeOptions = {
-        enableGroupedBatching: true,
-    }
-```
+In general, compression offers a trade-off between higher compute costs, lower bandwidth consumption and lower storage requirements, while chunking slightly increases latency due to the overhead of splitting an op, sending the chunks and reconstructing them on each client. Grouped batching heavily decreases the number of ops observed by the server and slightly decreases the bandwidth requirements as it merges all the ops in a batch into a single op and also eliminates the op envelope overhead.
 
 ## How it works
 
@@ -212,8 +237,6 @@ On the receiving end, the client will accumulate chunks 1 and 2 and keep them in
 
 ## How grouped batching works
 
-**Note: There are plans to replace empty ops with something more efficient when doing grouped batching AB#4092**
-
 Given the following baseline batch:
 
 ```
@@ -223,68 +246,70 @@ Given the following baseline batch:
 +---------------+---------------+---------------+---------------+---------------+
 ```
 
-Compressed batch:
+Grouped batch:
 
 ```
-+--------------------+-----------------+-----------------+-----------------+-----------------+
-| Op 1               | Op 2            | Op 3            | Op 4            | Op 5            |
-| Contents: "abcde"  | Contents: empty | Contents: empty | Contents: empty | Contents: empty |
-| Compression: 'lz4' |                 |                 |                 |                 |
-+--------------------+-----------------+-----------------+-----------------+-----------------+
++---------------------------------------------------------------------------------------------------------------------+
+| Op 1                   Contents: +----------------+---------------+---------------+---------------+---------------+ |
+| Type: "groupedBatch"             | Op 1           | Op 2          | Op 3          | Op 4          | Op 5          | |
+|                                  | Contents: "a"  | Contents: "b" | Contents: "c" | Contents: "d" | Contents: "e" | |
+|                                  +----------------+---------------+---------------+---------------+---------------+ |
++---------------------------------------------------------------------------------------------------------------------+
 ```
 
-Grouped batch:
+Compressed batch:
 
 ```
-+---------------------------------------------------------------------------------------------------------------------------------+
-| Op 1                   Contents: +--------------------+-----------------+-----------------+-----------------+-----------------+ |
-| SeqNum: 1                        | Op 1               | Op 2            | Op 3            | Op 4            | Op 5            | |
-| Type: "groupedBatch"             | Contents: "abcde"  | Contents: empty | Contents: empty | Contents: empty | Contents: empty | |
-|                                  | Compression: 'lz4' |                 |                 |                 |                 | |
-|                                  +--------------------+-----------------+-----------------+-----------------+-----------------+ |
-+---------------------------------------------------------------------------------------------------------------------------------+
++-------------------------------------------------------------------------------------------------------------------------+
+| Op 1                   Contents: +------------------------------------------------------------------------------------+ |
+| Compression: 'lz4'               | Type: "groupedBatch"                                                               | |
+|                                  | +----------------+---------------+---------------+---------------+---------------+ | |
+|                                  | | Op 1           | Op 2          | Op 3          | Op 4          | Op 5          | | |
+|                                  | | Contents: "a"  | Contents: "b" | Contents: "c" | Contents: "d" | Contents: "e" | | |
+|                                  | +----------------+---------------+---------------+---------------+---------------+ | |
+|                                  +------------------------------------------------------------------------------------+ |
++-------------------------------------------------------------------------------------------------------------------------+
 ```
 
 Can produce the following chunks:
 
 ```
-+-------------------------------------------------+
-| Chunk 1/2    Contents: +----------------------+ |
-| SeqNum: 1              |  +-----------------+ | |
-|                        |  | Contents: "abc" | | |
-|                        |  +-----------------+ | |
-|                        +----------------------+ |
-+-------------------------------------------------+
++------------------------------------------------+
+| Chunk 1/2    Contents: +---------------------+ |
+|                        | +-----------------+ | |
+|                        | | Contents: "abc" | | |
+|                        | +-----------------+ | |
+|                        +---------------------+ |
++------------------------------------------------+
 ```
 
 ```
-+--------------------------------------------------------------------------------------------------------------------------+
-| Chunk 2/2    Contents: +---------------------------------------------------------------------------------------------+ | |
-| SeqNum: 2              |  +----------------+-----------------+-----------------+-----------------+-----------------+ | | |
-|                        |  | Contents: "de" | Contents: empty | Contents: empty | Contents: empty | Contents: empty | | | |
-|                        |  +----------------+-----------------+-----------------+-----------------+-----------------+ | | |
-|                        +---------------------------------------------------------------------------------------------+ | |
-+--------------------------------------------------------------------------------------------------------------------------+
++-----------------------------------------------+
+| Chunk 2/2    Contents: +--------------------+ |
+|                        | +----------------+ | |
+|                        | | Contents: "de" | | |
+|                        | +----------------+ | |
+|                        +--------------------+ |
++-----------------------------------------------+
 ```
 
 -   Send to service
 -   Service acks ops sent
 -   Receive chunks from service
--   Recompile to the grouped batch step
+-   Recompile to the compression step
 
-Ungrouped batch:
+Decompressed batch:
 
 ```
-+--------------------+-----------------+-----------------+-----------------+-----------------+
-| Op 1               | Op 2            | Op 3            | Op 4            | Op 5            |
-| Contents: "abcde"  | Contents: empty | Contents: empty | Contents: empty | Contents: empty |
-| SeqNum: 2          | SeqNum: 2       | SeqNum: 2       | SeqNum: 2       | SeqNum: 2       |
-| ClientSeqNum: 1    | ClientSeqNum: 2 | ClientSeqNum: 3 | ClientSeqNum: 4 | ClientSeqNum: 5 |
-| Compression: 'lz4' |                 |                 |                 |                 |
-+--------------------+-----------------+-----------------+-----------------+-----------------+
++---------------------------------------------------------------------------------------------------------------------+
+| Op 1                   Contents: +----------------+---------------+---------------+---------------+---------------+ |
+| SeqNum: 2                        | Op 1           | Op 2            | Op 3        | Op 4          | Op 5          | |
+| Type: "groupedBatch"             | Contents: "a"  | Contents: "b" | Contents: "c" | Contents: "d" | Contents: "e" | |
+|                                  +----------------+---------------+---------------+---------------+---------------+ |
++---------------------------------------------------------------------------------------------------------------------+
 ```
 
-Uncompressed batch:
+Ungrouped batch:
 
 ```
 +-----------------+-----------------+-----------------+-----------------+-----------------+

package/src/opLifecycle/definitions.ts

@@ -5,7 +5,8 @@
 
 import { IBatchMessage } from "@fluidframework/container-definitions";
 import { ISequencedDocumentMessage, MessageType } from "@fluidframework/protocol-definitions";
-import { CompressionAlgorithms, ContainerMessageType } from "..";
+import { CompressionAlgorithms } from "..";
+import { ContainerMessageType } from "../messageTypes";
 
 /**
  * Batch message type used internally by the runtime
@@ -51,6 +52,9 @@ export interface IBatchCheckpoint {
 	rollback: (action: (message: BatchMessage) => void) => void;
 }
 
+/**
+ * @public
+ */
 export interface IChunkedOp {
 	chunkId: number;
 	totalChunks: number;

package/src/opLifecycle/opDecompressor.ts

@@ -50,14 +50,6 @@ export class OpDecompressor {
 		) {
 			// Beginning of a compressed batch
 			assert(this.activeBatch === false, 0x4b8 /* shouldn't have multiple active batches */);
-			if (message.compression) {
-				// lz4 is the only supported compression algorithm for now
-				assert(
-					message.compression === CompressionAlgorithms.lz4,
-					0x4b9 /* lz4 is currently the only supported compression algorithm */,
-				);
-			}
-
 			this.activeBatch = true;
 
 			const contents = IsoBuffer.from(

package/src/opLifecycle/opGroupingManager.ts

@@ -5,7 +5,7 @@
 
 import { assert } from "@fluidframework/core-utils";
 import { ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
-import { ContainerMessageType } from "..";
+import { ContainerMessageType } from "../messageTypes";
 import { IBatch } from "./definitions";
 
 /**
@@ -22,9 +22,7 @@ interface IGroupedMessage {
 	compression?: string;
 }
 
-function isGroupContents(
-	opContents: IGroupedBatchMessageContents | { type?: unknown } | undefined,
-): opContents is IGroupedBatchMessageContents {
+function isGroupContents(opContents: any): opContents is IGroupedBatchMessageContents {
 	return opContents?.type === OpGroupingManager.groupedBatchOp;
 }
 

package/src/opLifecycle/opSplitter.ts

@@ -12,7 +12,7 @@ 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, ContainerRuntimeMessage } from "../containerRuntime";
+import { ContainerMessageType, ContainerRuntimeChunkedOpMessage } from "../messageTypes";
 import { estimateSocketSize } from "./batchManager";
 import { BatchMessage, IBatch, IChunkedOp, IMessageProcessingResult } from "./definitions";
 
@@ -210,7 +210,7 @@ const chunkToBatchMessage = (
 	referenceSequenceNumber: number,
 	metadata: Record<string, unknown> | undefined = undefined,
 ): BatchMessage => {
-	const payload: ContainerRuntimeMessage = {
+	const payload: ContainerRuntimeChunkedOpMessage = {
 		type: ContainerMessageType.ChunkedOp,
 		contents: chunk,
 	};

package/src/opLifecycle/outbox.ts

@@ -65,10 +65,13 @@ export interface IOutboxParameters {
 export function getLongStack<T>(action: () => T, length: number = 50): T {
 	const errorObj = Error as any;
 	if (
+		/* eslint-disable @typescript-eslint/prefer-nullish-coalescing */
+		// ?? is not logically equivalent when the first clause returns false.
 		(
 			Object.getOwnPropertyDescriptor(errorObj, "stackTraceLimit") ||
 			Object.getOwnPropertyDescriptor(Object.getPrototypeOf(errorObj), "stackTraceLimit")
 		)?.writable !== true
+		/* eslint-enable @typescript-eslint/prefer-nullish-coalescing */
 	) {
 		return action();
 	}