@fluidframework/container-runtime 2.13.0 → 2.21.0

package/src/{scheduleManager.ts → inboundBatchAggregator.ts}

@@ -3,24 +3,18 @@
  * Licensed under the MIT License.
  */
 
-import type { EventEmitter } from "@fluid-internal/client-utils";
-import { performance } from "@fluid-internal/client-utils";
+import { performanceNow } from "@fluid-internal/client-utils";
 import { IDeltaManagerFull } from "@fluidframework/container-definitions/internal";
 import { assert } from "@fluidframework/core-utils/internal";
-import {
-	IDocumentMessage,
-	ISequencedDocumentMessage,
-} from "@fluidframework/driver-definitions/internal";
+import { ISequencedDocumentMessage } from "@fluidframework/driver-definitions/internal";
 import { isRuntimeMessage } from "@fluidframework/driver-utils/internal";
 import {
 	ITelemetryLoggerExt,
 	DataCorruptionError,
 	DataProcessingError,
-	createChildLogger,
 	extractSafePropertiesFromMessage,
 } from "@fluidframework/telemetry-utils/internal";
 
-import { DeltaScheduler } from "./deltaScheduler.js";
 import { IBatchMetadata } from "./metadata.js";
 import { pkgVersion } from "./packageVersion.js";
 
@@ -31,46 +25,10 @@ type IRuntimeMessageMetadata =
 	  };
 
 /**
- * This class has the following responsibilities:
- *
- * 1. It tracks batches as we process ops and raises "batchBegin" and "batchEnd" events.
- * As part of it, it validates batch correctness (i.e. no system ops in the middle of batch)
- *
- * 2. It creates instance of ScheduleManagerCore that ensures we never start processing ops from batch
- * unless all ops of the batch are in.
+ * This class ensures that we aggregate a complete batch of incoming ops before processing them. It basically ensures
+ * that we never start processing ops in a batch IF we do not have all ops in the batch.
  */
-export class ScheduleManager {
-	private readonly deltaScheduler: DeltaScheduler;
-
-	constructor(
-		private readonly deltaManager: IDeltaManagerFull,
-		private readonly emitter: EventEmitter,
-		readonly getClientId: () => string | undefined,
-		private readonly logger: ITelemetryLoggerExt,
-	) {
-		this.deltaScheduler = new DeltaScheduler(
-			this.deltaManager,
-			createChildLogger({ logger: this.logger, namespace: "DeltaScheduler" }),
-		);
-		void new ScheduleManagerCore(deltaManager, getClientId, logger);
-	}
-
-	public batchBegin(message: ISequencedDocumentMessage) {
-		this.emitter.emit("batchBegin", message);
-		this.deltaScheduler.batchBegin(message);
-	}
-
-	public batchEnd(error: any | undefined, message: ISequencedDocumentMessage) {
-		this.emitter.emit("batchEnd", error, message);
-		this.deltaScheduler.batchEnd(message);
-	}
-}
-
-/**
- * This class controls pausing and resuming of inbound queue to ensure that we never
- * start processing ops in a batch IF we do not have all ops in the batch.
- */
-class ScheduleManagerCore {
+export class InboundBatchAggregator {
 	private pauseSequenceNumber: number | undefined;
 	private currentBatchClientId: string | undefined;
 	private localPaused = false;
@@ -82,38 +40,8 @@ class ScheduleManagerCore {
 		private readonly getClientId: () => string | undefined,
 		private readonly logger: ITelemetryLoggerExt,
 	) {
-		// Listen for delta manager sends and add batch metadata to messages
-		this.deltaManager.on("prepareSend", (messages: IDocumentMessage[]) => {
-			if (messages.length === 0) {
-				return;
-			}
-
-			// First message will have the batch flag set to true if doing a batched send
-			const firstMessageMetadata = messages[0].metadata as IRuntimeMessageMetadata;
-			if (!firstMessageMetadata?.batch) {
-				return;
-			}
-
-			// If the batch contains only a single op, clear the batch flag.
-			if (messages.length === 1) {
-				delete firstMessageMetadata.batch;
-				return;
-			}
-
-			// Set the batch flag to false on the last message to indicate the end of the send batch
-			const lastMessage = messages[messages.length - 1];
-			// TODO: It's not clear if this shallow clone is required, as opposed to just setting "batch" to false.
-
-			lastMessage.metadata = { ...(lastMessage.metadata as any), batch: false };
-		});
-
 		// Listen for updates and peek at the inbound
-		this.deltaManager.inbound.on("push", (message: ISequencedDocumentMessage) => {
-			this.trackPending(message);
-		});
-
-		// Start with baseline - empty inbound queue.
-		assert(!this.localPaused, 0x293 /* "initial state" */);
+		this.deltaManager.inbound.on("push", this.trackPending);
 
 		const allPending = this.deltaManager.inbound.toArray();
 		for (const pending of allPending) {
@@ -121,16 +49,21 @@ class ScheduleManagerCore {
 		}
 
 		// We are intentionally directly listening to the "op" to inspect system ops as well.
-		// If we do not observe system ops, we are likely to hit 0x296 assert when system ops
+		// If we do not observe system ops, we are likely to hit an error when system ops
 		// precedes start of incomplete batch.
-		this.deltaManager.on("op", (message) => this.afterOpProcessing(message));
+		this.deltaManager.on("op", this.afterOpProcessing);
+	}
+
+	public dispose(): void {
+		this.deltaManager.off("op", this.afterOpProcessing);
+		this.deltaManager.inbound.off("push", this.trackPending);
 	}
 
 	/**
-	 * The only public function in this class - called when we processed an op,
-	 * to make decision if op processing should be paused or not after that.
+	 * Callback for DeltaManager's "op" event, for us to make decision if op processing should
+	 * be paused or not after that.
 	 */
-	public afterOpProcessing(message: ISequencedDocumentMessage) {
+	private readonly afterOpProcessing = (message: ISequencedDocumentMessage): void => {
 		assert(
 			!this.localPaused,
 			0x294 /* "can't have op processing paused if we are processing an op" */,
@@ -157,7 +90,7 @@ class ScheduleManagerCore {
 				throw DataProcessingError.create(
 					// Former assert 0x296
 					"Incomplete batch",
-					"ScheduleManager",
+					"InboundBatchAggregator",
 					message,
 					{
 						type: message.type,
@@ -174,49 +107,14 @@ class ScheduleManagerCore {
 				this.pauseQueue();
 			}
 		}
-	}
-
-	private pauseQueue() {
-		assert(!this.localPaused, 0x297 /* "always called from resumed state" */);
-		this.localPaused = true;
-		this.timePaused = performance.now();
-		// eslint-disable-next-line @typescript-eslint/no-floating-promises
-		this.deltaManager.inbound.pause();
-	}
-
-	private resumeQueue(startBatch: number, messageEndBatch: ISequencedDocumentMessage) {
-		const endBatch = messageEndBatch.sequenceNumber;
-		const duration = this.localPaused ? performance.now() - this.timePaused : undefined;
-
-		this.batchCount++;
-		if (this.batchCount % 1000 === 1) {
-			this.logger.sendTelemetryEvent({
-				eventName: "BatchStats",
-				sequenceNumber: endBatch,
-				length: endBatch - startBatch + 1,
-				msnDistance: endBatch - messageEndBatch.minimumSequenceNumber,
-				duration,
-				batchCount: this.batchCount,
-				interrupted: this.localPaused,
-			});
-		}
-
-		// Return early if no change in value
-		if (!this.localPaused) {
-			return;
-		}
-
-		this.localPaused = false;
-
-		this.deltaManager.inbound.resume();
-	}
+	};
 
 	/**
 	 * Called for each incoming op (i.e. inbound "push" notification)
 	 */
-	private trackPending(message: ISequencedDocumentMessage) {
+	private readonly trackPending = (message: ISequencedDocumentMessage): void => {
 		assert(
-			this.deltaManager.inbound.length !== 0,
+			this.deltaManager.inbound.length > 0,
 			0x298 /* "we have something in the queue that generates this event" */,
 		);
 
@@ -324,5 +222,40 @@ class ScheduleManagerCore {
 			// Continuation of current batch. Do nothing
 			assert(this.currentBatchClientId !== undefined, 0x2a1 /* "logic error" */);
 		}
+	};
+
+	private pauseQueue(): void {
+		assert(!this.localPaused, 0x297 /* "always called from resumed state" */);
+		this.localPaused = true;
+		this.timePaused = performanceNow();
+		// eslint-disable-next-line @typescript-eslint/no-floating-promises
+		this.deltaManager.inbound.pause();
+	}
+
+	private resumeQueue(startBatch: number, messageEndBatch: ISequencedDocumentMessage): void {
+		const endBatch = messageEndBatch.sequenceNumber;
+		const duration = this.localPaused ? performanceNow() - this.timePaused : undefined;
+
+		this.batchCount++;
+		if (this.batchCount % 1000 === 1) {
+			this.logger.sendTelemetryEvent({
+				eventName: "BatchStats",
+				sequenceNumber: endBatch,
+				length: endBatch - startBatch + 1,
+				msnDistance: endBatch - messageEndBatch.minimumSequenceNumber,
+				duration,
+				batchCount: this.batchCount,
+				interrupted: this.localPaused,
+			});
+		}
+
+		// Return early if no change in value
+		if (!this.localPaused) {
+			return;
+		}
+
+		this.localPaused = false;
+
+		this.deltaManager.inbound.resume();
 	}
 }

package/src/index.ts

@@ -55,7 +55,6 @@ export {
 	ISummaryCancellationToken,
 	neverCancelledSummaryToken,
 	Summarizer,
-	SummarizerStopReason,
 	SummaryCollection,
 	EnqueueSummarizeResult,
 	IAckSummaryResult,
@@ -75,7 +74,6 @@ export {
 	ISubmitSummaryOptions,
 	ISerializedElection,
 	ISummarizeOptions,
-	ISummarizerEvents,
 	ISummarizerInternalsProvider,
 	ISummarizerRuntime,
 	ISummarizingWarning,
@@ -95,7 +93,6 @@ export {
 	SubmitSummaryFailureData,
 	SummaryStage,
 	IRetriableFailureError,
-	ISummarizeEventProps,
 	IdCompressorMode,
 	IDocumentSchema,
 	DocumentSchemaValueType,

package/src/layerCompatState.ts

@@ -0,0 +1,75 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import {
+	checkLayerCompatibility,
+	type ILayerCompatDetails,
+	type ILayerCompatSupportRequirements,
+} from "@fluid-internal/client-utils";
+import type { ICriticalContainerError } from "@fluidframework/container-definitions";
+import { UsageError } from "@fluidframework/telemetry-utils/internal";
+
+import { pkgVersion } from "./packageVersion.js";
+
+/**
+ * Runtime's compatibility details that is exposed to the Loader layer.
+ */
+export const RuntimeCompatDetails: ILayerCompatDetails = {
+	/**
+	 * The package version of the Runtime layer.
+	 */
+	pkgVersion,
+	/**
+	 * The current generation of the Runtime layer.
+	 */
+	generation: 1,
+	/**
+	 * The features supported by the Runtime layer across the Runtime / Loader boundary.
+	 */
+	supportedFeatures: new Set<string>(),
+};
+
+/**
+ * The requirements that the Loader layer must meet to be compatible with this Runtime.
+ */
+export const LoaderSupportRequirements: ILayerCompatSupportRequirements = {
+	/**
+	 * Minimum generation that Loader must be at to be compatible with Runtime.
+	 */
+	minSupportedGeneration: 0,
+	/**
+	 * The features that the Loader must support to be compatible with Runtime. Note that 0 is used here for
+	 * Loader layers before the introduction of the layer compatibility enforcement.
+	 */
+	requiredFeatures: [],
+};
+
+/**
+ * Validates that the Loader layer is compatible with this Runtime.
+ */
+export function validateLoaderCompatibility(
+	maybeLoaderCompatDetails: ILayerCompatDetails | undefined,
+	disposeFn: (error?: ICriticalContainerError) => void,
+): void {
+	const layerCheckResult = checkLayerCompatibility(
+		LoaderSupportRequirements,
+		maybeLoaderCompatDetails,
+	);
+	if (!layerCheckResult.isCompatible) {
+		const error = new UsageError("Runtime is not compatible with Loader", {
+			errorDetails: JSON.stringify({
+				runtimeVersion: RuntimeCompatDetails.pkgVersion,
+				loaderVersion: maybeLoaderCompatDetails?.pkgVersion,
+				runtimeGeneration: RuntimeCompatDetails.generation,
+				loaderGeneration: maybeLoaderCompatDetails?.generation,
+				minSupportedGeneration: LoaderSupportRequirements.minSupportedGeneration,
+				isGenerationCompatible: layerCheckResult.isGenerationCompatible,
+				unsupportedFeatures: layerCheckResult.unsupportedFeatures,
+			}),
+		});
+		disposeFn(error);
+		throw error;
+	}
+}

package/src/messageTypes.ts

@@ -14,6 +14,7 @@ import {
 import { IDataStoreAliasMessage } from "./dataStore.js";
 import { GarbageCollectionMessage } from "./gc/index.js";
 import { IChunkedOp } from "./opLifecycle/index.js";
+// eslint-disable-next-line import/no-deprecated
 import { IDocumentSchemaChangeMessage } from "./summary/index.js";
 
 /**
@@ -66,9 +67,13 @@ export enum ContainerMessageType {
  * This way stringified values can be compared.
  */
 interface TypedContainerRuntimeMessage<TType extends ContainerMessageType, TContents> {
-	/** Type of the op, within the ContainerRuntime's domain */
+	/**
+	 * Type of the op, within the ContainerRuntime's domain
+	 */
 	type: TType;
-	/** Domain-specific contents, interpreted according to the type */
+	/**
+	 * Domain-specific contents, interpreted according to the type
+	 */
 	contents: TContents;
 }
 
@@ -110,6 +115,7 @@ export type ContainerRuntimeGCMessage = TypedContainerRuntimeMessage<
 >;
 export type ContainerRuntimeDocumentSchemaMessage = TypedContainerRuntimeMessage<
 	ContainerMessageType.DocumentSchemaChange,
+	// eslint-disable-next-line import/no-deprecated
 	IDocumentSchemaChangeMessage
 >;
 
@@ -118,13 +124,16 @@ export type ContainerRuntimeDocumentSchemaMessage = TypedContainerRuntimeMessage
  * @internal
  */
 export interface UnknownContainerRuntimeMessage {
-	/** Invalid type of the op, within the ContainerRuntime's domain. This value should never exist at runtime.
+	/**
+	 * 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. */
+	/**
+	 * Domain-specific contents, but not decipherable by an unknown op.
+	 */
 	contents: unknown;
 }
 
@@ -160,7 +169,9 @@ export type LocalContainerRuntimeMessage =
 	| UnknownContainerRuntimeMessage
 	| ContainerRuntimeDocumentSchemaMessage;
 
-/** A {@link TypedContainerRuntimeMessage} that is being sent to the server from the container runtime. */
+/**
+ * A {@link TypedContainerRuntimeMessage} that is being sent to the server from the container runtime.
+ */
 export type OutboundContainerRuntimeMessage =
 	| ContainerRuntimeDataStoreOpMessage
 	| OutboundContainerRuntimeAttachMessage

package/src/metadata.ts

@@ -5,12 +5,16 @@
 
 import type { BatchId } from "./opLifecycle/index.js";
 
-/** Syntactic sugar for casting */
+/**
+ * Syntactic sugar for casting
+ */
 export function asBatchMetadata(metadata: unknown): Partial<IBatchMetadata> | undefined {
 	return metadata as Partial<IBatchMetadata> | undefined;
 }
 
-/** Syntactic sugar for casting */
+/**
+ * Syntactic sugar for casting
+ */
 export function asEmptyBatchLocalOpMetadata(
 	localOpMetadata: unknown,
 ): IEmptyBatchMetadata | undefined {
@@ -28,9 +32,13 @@ export interface IEmptyBatchMetadata {
  * Properties put on the op metadata object for batch tracking
  */
 export interface IBatchMetadata {
-	/** Set on first/last messages of a multi-message batch, to true/false respectively */
+	/**
+	 * Set on first/last messages of a multi-message batch, to true/false respectively
+	 */
 	batch?: boolean;
-	/** Maybe set on first message of a batch, to the batchId generated when resubmitting (set/fixed on first resubmit) */
+	/**
+	 * Maybe set on first message of a batch, to the batchId generated when resubmitting (set/fixed on first resubmit)
+	 */
 	batchId?: BatchId;
 }
 

package/src/opLifecycle/README.md

@@ -2,21 +2,23 @@
 
 ## Table of contents
 
--   [Configs and feature gates for solving the 1MB limit.](#configs-and-feature-gates-for-solving-the-1mb-limit)
-    -   [Table of contents](#table-of-contents)
-    -   [Introduction](#introduction)
-        -   [How batching works](#how-batching-works)
-    -   [Compression](#compression)
-    -   [Grouped batching](#grouped-batching)
-        -   [Changes in op semantics](#changes-in-op-semantics)
-    -   [Chunking for compression](#chunking-for-compression)
-    -   [Configuration](#configuration)
-    -   [Note about performance and latency](#note-about-performance-and-latency)
-    -   [How it works](#how-it-works)
-    -   [How it works (Grouped Batching disabled)](#how-it-works-grouped-batching-disabled)
-    -   [How the overall op flow works](#how-the-overall-op-flow-works)
-        -   [Outbound](#outbound)
-        -   [Inbound](#inbound)
+- [Configs and feature gates for solving the 1MB limit.](#configs-and-feature-gates-for-solving-the-1mb-limit)
+  - [Table of contents](#table-of-contents)
+  - [Introduction](#introduction)
+    - [How batching works](#how-batching-works)
+  - [Grouped batching](#grouped-batching)
+    - [Changes in op semantics](#changes-in-op-semantics)
+  - [Compression](#compression)
+    - [Only single-message batches are compressed](#only-single-message-batches-are-compressed)
+  - [Chunking for compression](#chunking-for-compression)
+  - [Configuration](#configuration)
+  - [Note about performance and latency](#note-about-performance-and-latency)
+  - [How it works](#how-it-works)
+  - [Legacy behavior - How it used to work (Compression+Chunking without Grouped Batching)](#legacy-behavior---how-it-used-to-work-compressionchunking-without-grouped-batching)
+    - [IMPORTANT - As of 2.20.0, we no longer compress ungrouped batches, but we do need to read such ops - read on to learn what these legacy ops look like](#important---as-of-2200-we-no-longer-compress-ungrouped-batches-but-we-do-need-to-read-such-ops---read-on-to-learn-what-these-legacy-ops-look-like)
+  - [How the overall op flow works](#how-the-overall-op-flow-works)
+    - [Outbound](#outbound)
+    - [Inbound](#inbound)
 
 ## Introduction
 
@@ -56,20 +58,6 @@ What this means is that `FlushMode.Immediate` will send each op in its own paylo
 
 As `FlushMode.TurnBased` accumulates ops, it is the most vulnerable to run into the 1MB socket limit.
 
-## Compression
-
-**Compression targets payloads which exceed the max batch size and it is enabled by default.**. The `IContainerRuntimeOptions.compressionOptions` property, of type `ICompressionRuntimeOptions` is the configuration governing how compression works.
-
-`ICompressionRuntimeOptions` has two properties:
-
--   `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.
-
-Compressing a batch yields a batch with the same number of messages. It compresses all the content, shifting the compressed payload into the first op,
-leaving the rest of the batch's messages as empty placeholders to reserve sequence numbers for the compressed messages.
-
 ## Grouped batching
 
 With Grouped Batching enabled (it's on by default), all batch messages are combined under a single "grouped" message _before compression_. Upon receiving this new "grouped" message, the batch messages will be extracted, and they each will be given the same sequence number - that of the parent "grouped" message.
@@ -78,9 +66,7 @@ The purpose for enabling grouped batching before compression is to eliminate the
 
 Grouped batching is only relevant for `FlushMode.TurnBased`, since `OpGroupingManagerConfig.opCountThreshold` defaults to 2. 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.
 
-Grouped Batching can be disabled by setting `IContainerRuntimeOptions.enableGroupedBatching` to `false`.
-
-See [below](#how-grouped-batching-works) for an example.
+See [below](#how-it-works) for an example.
 
 ### Changes in op semantics
 
@@ -92,6 +78,27 @@ Grouped Batching changed a couple of expectations around message structure and r
 -   All ops in a batch must also have the same reference sequence number to ensure eventualy consistency of the model. The runtime will "rebase" ops in a batch with different ref sequence number to satisfy that requirement.
     -   What causes ops in a single JS turn (and thus in a batch) to have different reference sequence number? "Op reentrancy", where changes are made to a DDS inside a DDS 'onChanged' event handler.
 
+## Compression
+
+**Compression targets payloads which exceed the max batch size and it is enabled by default.**. The `IContainerRuntimeOptions.compressionOptions` property, of type `ICompressionRuntimeOptions` is the configuration governing how compression works.
+
+`ICompressionRuntimeOptions` has two properties:
+
+-   `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.
+
+### Only single-message batches are compressed
+
+The batch to compress has to have only one message and it yields a batch with a single message. It compresses all the content, replacing the op's original contents with the compressed payload and the appropriate metadata to indicate it's compressed.
+
+Compression is only enabled if Grouped Batching is enabled.
+
+Legacy compressed batches could contain multiple messages, compressing all the content and shifting the compressed payload into the first op, leaving the rest of the batch's messages as empty placeholders to reserve sequence numbers for the compressed messages.
+
+While it remains possible to read compressed batches with empty ops, the system will no longer create said type of batches.
+
 ## 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.
@@ -200,7 +207,9 @@ Ungrouped batch:
 +-----------------+-----------------+-----------------+-----------------+-----------------+
 ```
 
-## How it works (Grouped Batching disabled)
+## Legacy behavior - How it used to work (Compression+Chunking without Grouped Batching)
+
+### IMPORTANT - As of 2.20.0, we no longer compress ungrouped batches, but we do need to read such ops - read on to learn what these legacy ops look like
 
 If we have a batch with a size larger than the configured minimum required for compression (in the example let’s say it’s 850 bytes), as following:
 
@@ -311,7 +320,7 @@ stateDiagram-v2
     groupBatch --> if_compression
 	flushInternal --> if_compression
     if_compression --> post
-	if_compression --> compress: if compression is enabled
+	if_compression --> compress: if compression and grouped batching are enabled
 	compress --> post
 	compress --> opSplitter.split: if the compressed payload is larger than the chunk size
 	opSplitter.split --> post

package/src/opLifecycle/batchManager.ts

@@ -21,7 +21,9 @@ export interface IBatchManagerOptions {
 	 */
 	readonly canRebase: boolean;
 
-	/** If true, don't compare batchID of incoming batches to this. e.g. ID Allocation Batch IDs should be ignored */
+	/**
+	 * If true, don't compare batchID of incoming batches to this. e.g. ID Allocation Batch IDs should be ignored
+	 */
 	readonly ignoreBatchId?: boolean;
 }
 
@@ -30,10 +32,14 @@ export interface BatchSequenceNumbers {
 	clientSequenceNumber?: number;
 }
 
-/** Type alias for the batchId stored in batch metadata */
+/**
+ * Type alias for the batchId stored in batch metadata
+ */
 export type BatchId = string;
 
-/** Compose original client ID and client sequence number into BatchId to stamp on the message during reconnect */
+/**
+ * Compose original client ID and client sequence number into BatchId to stamp on the message during reconnect
+ */
 export function generateBatchId(originalClientId: string, batchStartCsn: number): BatchId {
 	return `${originalClientId}_[${batchStartCsn}]`;
 }
@@ -76,10 +82,10 @@ export class BatchManager {
 	private batchContentSize = 0;
 	private hasReentrantOps = false;
 
-	public get length() {
+	public get length(): number {
 		return this.pendingBatch.length;
 	}
-	public get contentSizeInBytes() {
+	public get contentSizeInBytes(): number {
 		return this.batchContentSize;
 	}
 
@@ -133,7 +139,7 @@ export class BatchManager {
 		return true;
 	}
 
-	public get empty() {
+	public get empty(): boolean {
 		return this.pendingBatch.length === 0;
 	}
 

package/src/opLifecycle/duplicateBatchDetector.ts

@@ -13,13 +13,19 @@ import { type BatchStartInfo } from "./remoteMessageProcessor.js";
  * This class tracks recent batchIds we've seen, and checks incoming batches for duplicates.
  */
 export class DuplicateBatchDetector {
-	/** All batchIds we've seen recently enough (based on MSN) that we need to watch for duplicates */
+	/**
+	 * All batchIds we've seen recently enough (based on MSN) that we need to watch for duplicates
+	 */
 	private readonly batchIdsAll = new Set<string>();
 
-	/** We map from sequenceNumber to batchId to find which ones we can stop tracking as MSN advances */
+	/**
+	 * We map from sequenceNumber to batchId to find which ones we can stop tracking as MSN advances
+	 */
 	private readonly batchIdsBySeqNum = new Map<number, string>();
 
-	/** Initialize from snapshot data if provided - otherwise initialize empty */
+	/**
+	 * Initialize from snapshot data if provided - otherwise initialize empty
+	 */
 	constructor(batchIdsFromSnapshot: [number, string][] | undefined) {
 		if (batchIdsFromSnapshot) {
 			this.batchIdsBySeqNum = new Map(batchIdsFromSnapshot);
@@ -78,13 +84,13 @@ export class DuplicateBatchDetector {
 	 * Batches that started before the MSN are not at risk for a sequenced duplicate to arrive,
 	 * since the batch start has been processed by all clients, and local batches are deduped and the forked client would close.
 	 */
-	private clearOldBatchIds(msn: number) {
-		this.batchIdsBySeqNum.forEach((batchId, sequenceNumber) => {
+	private clearOldBatchIds(msn: number): void {
+		for (const [sequenceNumber, batchId] of this.batchIdsBySeqNum) {
 			if (sequenceNumber < msn) {
 				this.batchIdsBySeqNum.delete(sequenceNumber);
 				this.batchIdsAll.delete(batchId);
 			}
-		});
+		}
 	}
 
 	/**