@fluidframework/container-runtime 2.13.0 → 2.20.0

package/src/gc/gcTelemetry.ts

@@ -26,7 +26,9 @@ import { UnreferencedStateTracker } from "./gcUnreferencedStateTracker.js";
 
 type NodeUsageType = "Changed" | "Loaded" | "Revived" | "Realized";
 
-/** Properties that are common to IUnreferencedEventProps and INodeUsageProps */
+/**
+ * Properties that are common to IUnreferencedEventProps and INodeUsageProps
+ */
 interface ICommonProps {
 	usageType: NodeUsageType;
 	completedGCRuns: number;
@@ -36,12 +38,18 @@ interface ICommonProps {
 	additionalProps?: ITelemetryPropertiesExt;
 }
 
-/** The event that is logged when unreferenced node is used after a certain time. */
+/**
+ * The event that is logged when unreferenced node is used after a certain time.
+ */
 interface IUnreferencedEventProps extends ICreateContainerMetadata, ICommonProps {
-	/** The id that GC uses to track the node. May or may not match id */
+	/**
+	 * The id that GC uses to track the node. May or may not match id
+	 */
 	trackedId: string;
 	state: UnreferencedState;
-	/** The full path (in GC Path format) to the node in question */
+	/**
+	 * The full path (in GC Path format) to the node in question
+	 */
 	id: Tagged<string>;
 	fromId?: Tagged<string>;
 	type: GCNodeType;
@@ -54,21 +62,37 @@ interface IUnreferencedEventProps extends ICreateContainerMetadata, ICommonProps
 	timeout?: number;
 }
 
-/** Properties passed to nodeUsed function when a node is used. */
+/**
+ * Properties passed to nodeUsed function when a node is used.
+ */
 interface INodeUsageProps extends ICommonProps {
-	/** The full path (in GC Path format) to the node in question */
+	/**
+	 * The full path (in GC Path format) to the node in question
+	 */
 	id: string;
-	/** Latest timestamp received from the server, as a baseline for computing GC state/age */
+	/**
+	 * Latest timestamp received from the server, as a baseline for computing GC state/age
+	 */
 	currentReferenceTimestampMs: number;
-	/** The package path of the node. This may not be available if the node hasn't been loaded yet */
+	/**
+	 * The package path of the node. This may not be available if the node hasn't been loaded yet
+	 */
 	packagePath: readonly string[] | undefined;
-	/** In case of Revived - what node added the reference? */
+	/**
+	 * In case of Revived - what node added the reference?
+	 */
 	fromId?: string;
-	/** In case of Revived - was it revived due to autorecovery? */
+	/**
+	 * In case of Revived - was it revived due to autorecovery?
+	 */
 	autorecovery?: true;
-	/** URL (including query string) if this usage came from a request */
+	/**
+	 * URL (including query string) if this usage came from a request
+	 */
 	requestUrl?: string;
-	/** Original request headers if this usage came from a request or handle.get */
+	/**
+	 * Original request headers if this usage came from a request or handle.get
+	 */
 	requestHeaders?: string;
 }
 
@@ -110,9 +134,13 @@ export class GCTelemetryTracker {
 	) {}
 
 	/**
-	 * Returns whether an event should be logged for a node that isn't active anymore. This does not apply to
-	 * tombstoned nodes for which an event is always logged. Some scenarios where we won't log:
+	 * Returns whether an event should be logged for a node that isn't active anymore.
+	 *
+	 * @remarks
+	 * This does not apply to tombstoned nodes for which an event is always logged. Some scenarios where we won't log:
+	 *
 	 * 1. When a DDS is changed. The corresponding data store's event will be logged instead.
+	 *
 	 * 2. An event is logged only once per container instance per event per node.
 	 */
 	private shouldLogNonActiveEvent(
@@ -120,7 +148,7 @@ export class GCTelemetryTracker {
 		usageType: NodeUsageType,
 		nodeStateTracker: UnreferencedStateTracker,
 		uniqueEventId: string,
-	) {
+	): boolean {
 		if (nodeStateTracker.state === UnreferencedState.Active) {
 			return false;
 		}
@@ -160,7 +188,7 @@ export class GCTelemetryTracker {
 			isTombstoned,
 			...otherNodeUsageProps
 		}: INodeUsageProps,
-	) {
+	): void {
 		// Note: For SubDataStore Load usage, trackedId will be the DataStore's id, not the full path in question.
 		// This is necessary because the SubDataStore path may be unrecognized by GC (if suited for a custom request handler)
 		const nodeStateTracker = this.getNodeStateTracker(trackedId);
@@ -265,7 +293,7 @@ export class GCTelemetryTracker {
 		nodeType: GCNodeType,
 		usageType: NodeUsageType,
 		packagePath?: readonly string[],
-	) {
+	): void {
 		// This will log the following events:
 		// GC_Tombstone_DataStore_Requested, GC_Tombstone_DataStore_Changed, GC_Tombstone_DataStore_Revived
 		// GC_Tombstone_SubDataStore_Requested, GC_Tombstone_SubDataStore_Changed, GC_Tombstone_SubDataStore_Revived
@@ -312,7 +340,7 @@ export class GCTelemetryTracker {
 		previousGCData: IGarbageCollectionData,
 		explicitReferences: Map<string, string[]>,
 		logger: ITelemetryLoggerExt,
-	) {
+	): void {
 		for (const [nodeId, currentOutboundRoutes] of Object.entries(currentGCData.gcNodes)) {
 			const previousRoutes = previousGCData.gcNodes[nodeId] ?? [];
 			const explicitRoutes = explicitReferences.get(nodeId) ?? [];
@@ -356,7 +384,7 @@ export class GCTelemetryTracker {
 	 * Log events that are pending in pendingEventsQueue. This is called after GC runs in the summarizer client
 	 * so that the state of an unreferenced node is updated.
 	 */
-	public async logPendingEvents(logger: ITelemetryLoggerExt) {
+	public async logPendingEvents(logger: ITelemetryLoggerExt): Promise<void> {
 		// Events sent come only from the summarizer client. In between summaries, events are pushed to a queue and at
 		// summary time they are then logged.
 		// Events generated:

package/src/gc/gcUnreferencedStateTracker.ts

@@ -8,7 +8,9 @@ import { validatePrecondition } from "@fluidframework/telemetry-utils/internal";
 
 import { UnreferencedState } from "./gcDefinitions.js";
 
-/** A wrapper around common-utils Timer that requires the timeout when calling start/restart */
+/**
+ * A wrapper around common-utils Timer that requires the timeout when calling start/restart
+ */
 class TimerWithNoDefaultTimeout extends Timer {
 	constructor(private readonly callback: () => void) {
 		// The default timeout/handlers will never be used since start/restart pass overrides below
@@ -17,7 +19,7 @@ class TimerWithNoDefaultTimeout extends Timer {
 		});
 	}
 
-	start(timeoutMs: number) {
+	start(timeoutMs: number): void {
 		super.start(timeoutMs, this.callback);
 	}
 
@@ -26,9 +28,13 @@ class TimerWithNoDefaultTimeout extends Timer {
 	}
 }
 
-/** The collection of UnreferencedStateTrackers for all unreferenced nodes. Ensures stopTracking is called when deleting */
+/**
+ * The collection of UnreferencedStateTrackers for all unreferenced nodes. Ensures stopTracking is called when deleting
+ */
 export class UnreferencedStateTrackerMap extends Map<string, UnreferencedStateTracker> {
-	/** Delete the given key, and stop tracking if that node was actually unreferenced */
+	/**
+	 * Delete the given key, and stop tracking if that node was actually unreferenced
+	 */
 	delete(key: string): boolean {
 		// Stop tracking so as to clear out any running timers.
 		this.get(key)?.stopTracking();
@@ -47,22 +53,36 @@ export class UnreferencedStateTracker {
 		return this._state;
 	}
 
-	/** Timer to indicate when an unreferenced object is considered Inactive */
+	/**
+	 * Timer to indicate when an unreferenced object is considered Inactive
+	 */
 	private readonly inactiveTimer: TimerWithNoDefaultTimeout;
-	/** Timer to indicate when an unreferenced object is Tombstone-Ready */
+	/**
+	 * Timer to indicate when an unreferenced object is Tombstone-Ready
+	 */
 	private readonly tombstoneTimer: TimerWithNoDefaultTimeout;
-	/** Timer to indicate when an unreferenced object is Sweep-Ready */
+	/**
+	 * Timer to indicate when an unreferenced object is Sweep-Ready
+	 */
 	private readonly sweepTimer: TimerWithNoDefaultTimeout;
 
 	constructor(
 		public readonly unreferencedTimestampMs: number,
-		/** The time after which node transitions to Inactive state. */
+		/**
+		 * The time after which node transitions to Inactive state.
+		 */
 		private readonly inactiveTimeoutMs: number,
-		/** The current reference timestamp used to track how long this node has been unreferenced for. */
+		/**
+		 * The current reference timestamp used to track how long this node has been unreferenced for.
+		 */
 		currentReferenceTimestampMs: number,
-		/** The time after which node transitions to TombstoneReady state; undefined if session expiry is disabled. */
+		/**
+		 * The time after which node transitions to TombstoneReady state; undefined if session expiry is disabled.
+		 */
 		private readonly tombstoneTimeoutMs: number | undefined,
-		/** The delay from TombstoneReady to SweepReady (only applies if tombstoneTimeoutMs is defined) */
+		/**
+		 * The delay from TombstoneReady to SweepReady (only applies if tombstoneTimeoutMs is defined)
+		 */
 		private readonly sweepGracePeriodMs: number,
 	) {
 		validatePrecondition(
@@ -106,8 +126,10 @@ export class UnreferencedStateTracker {
 		this.updateTracking(currentReferenceTimestampMs);
 	}
 
-	/* Updates the unreferenced state based on the provided timestamp. */
-	public updateTracking(currentReferenceTimestampMs: number) {
+	/**
+	 * Updates the unreferenced state based on the provided timestamp.
+	 */
+	public updateTracking(currentReferenceTimestampMs: number): void {
 		const unreferencedDurationMs = currentReferenceTimestampMs - this.unreferencedTimestampMs;
 
 		// Below we will set the appropriate timer (or none). Any running timers are superceded by the new currentReferenceTimestampMs
@@ -151,14 +173,16 @@ export class UnreferencedStateTracker {
 		this.inactiveTimer.restart(this.inactiveTimeoutMs - unreferencedDurationMs);
 	}
 
-	private clearTimers() {
+	private clearTimers(): void {
 		this.inactiveTimer.clear();
 		this.tombstoneTimer.clear();
 		this.sweepTimer.clear();
 	}
 
-	/** Stop tracking this node. Reset the unreferenced timers and state, if any. */
-	public stopTracking() {
+	/**
+	 * Stop tracking this node. Reset the unreferenced timers and state, if any.
+	 */
+	public stopTracking(): void {
 		this.clearTimers();
 		this._state = UnreferencedState.Active;
 	}

package/src/gc/index.ts

@@ -4,6 +4,7 @@
  */
 
 export { GarbageCollector } from "./garbageCollection.js";
+export { computeTombstoneTimeout } from "./gcConfigs.js";
 export {
 	nextGCVersion,
 	defaultInactiveTimeoutMs,

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 { 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.
- */
-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.
+ * 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.
  */
-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,47 +107,12 @@ 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,
 			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 = performance.now();
+		// 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 ? 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();
 	}
 }

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/messageTypes.ts

@@ -66,9 +66,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;
 }
 
@@ -118,13 +122,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 +167,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/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;
 	}