@fluidframework/container-runtime 2.13.0 → 2.21.0

package/src/summary/runningSummarizer.ts

@@ -23,6 +23,7 @@ import {
 	createChildLogger,
 	createChildMonitoringContext,
 	isFluidError,
+	type ITelemetryLoggerExt,
 } from "@fluidframework/telemetry-utils/internal";
 
 import { ISummaryConfiguration } from "../containerRuntime.js";
@@ -33,7 +34,9 @@ import {
 	EnqueueSummarizeResult,
 	IEnqueueSummarizeOptions,
 	IOnDemandSummarizeOptions,
+	// eslint-disable-next-line import/no-deprecated
 	IRefreshSummaryAckOptions,
+	// eslint-disable-next-line import/no-deprecated
 	ISubmitSummaryOptions,
 	ISummarizeHeuristicData,
 	ISummarizeHeuristicRunner,
@@ -41,7 +44,9 @@ import {
 	ISummarizeResults,
 	ISummarizeRunnerTelemetry,
 	ISummarizeTelemetryProperties,
+	// eslint-disable-next-line import/no-deprecated
 	ISummarizerRuntime,
+	// eslint-disable-next-line import/no-deprecated
 	ISummaryCancellationToken,
 	SubmitSummaryResult,
 	type IRetriableFailureError,
@@ -87,12 +92,16 @@ export class RunningSummarizer
 		logger: ITelemetryBaseLogger,
 		summaryWatcher: IClientSummaryWatcher,
 		configuration: ISummaryConfiguration,
+		// eslint-disable-next-line import/no-deprecated
 		submitSummaryCallback: (options: ISubmitSummaryOptions) => Promise<SubmitSummaryResult>,
+		// eslint-disable-next-line import/no-deprecated
 		refreshLatestSummaryAckCallback: (options: IRefreshSummaryAckOptions) => Promise<void>,
 		heuristicData: ISummarizeHeuristicData,
 		summaryCollection: SummaryCollection,
+		// eslint-disable-next-line import/no-deprecated
 		cancellationToken: ISummaryCancellationToken,
 		stopSummarizerCallback: (reason: SummarizerStopReason) => void,
+		// eslint-disable-next-line import/no-deprecated
 		runtime: ISummarizerRuntime,
 	): Promise<RunningSummarizer> {
 		const summarizer = new RunningSummarizer(
@@ -163,7 +172,7 @@ export class RunningSummarizer
 		return summarizer;
 	}
 
-	public get disposed() {
+	public get disposed(): boolean {
 		return this._disposed;
 	}
 	private stopping = false;
@@ -187,9 +196,14 @@ export class RunningSummarizer
 	private totalSuccessfulAttempts = 0;
 	private initialized = false;
 
-	private readonly runtimeListener;
+	private readonly runtimeListener: (
+		op: ISequencedDocumentMessage,
+		runtimeMessage?: boolean,
+	) => void;
 
-	/** The maximum number of summary attempts to do when submit summary fails. */
+	/**
+	 * The maximum number of summary attempts to do when submit summary fails.
+	 */
 	private readonly maxAttemptsForSubmitFailures: number;
 
 	/**
@@ -204,15 +218,19 @@ export class RunningSummarizer
 		private readonly summaryWatcher: IClientSummaryWatcher,
 		private readonly configuration: ISummaryConfiguration,
 		private readonly submitSummaryCallback: (
+			// eslint-disable-next-line import/no-deprecated
 			options: ISubmitSummaryOptions,
 		) => Promise<SubmitSummaryResult>,
 		private readonly refreshLatestSummaryAckCallback: (
+			// eslint-disable-next-line import/no-deprecated
 			options: IRefreshSummaryAckOptions,
 		) => Promise<void>,
 		private readonly heuristicData: ISummarizeHeuristicData,
 		private readonly summaryCollection: SummaryCollection,
+		// eslint-disable-next-line import/no-deprecated
 		private readonly cancellationToken: ISummaryCancellationToken,
 		private readonly stopSummarizerCallback: (reason: SummarizerStopReason) => void,
+		// eslint-disable-next-line import/no-deprecated
 		private readonly runtime: ISummarizerRuntime,
 	) {
 		super();
@@ -290,6 +308,7 @@ export class RunningSummarizer
 			() => {
 				this.totalSuccessfulAttempts++;
 			},
+			// eslint-disable-next-line import/no-deprecated
 			async (options: IRefreshSummaryAckOptions) => {
 				if (immediatelyRefreshLatestSummaryAck) {
 					await this.refreshLatestSummaryAckAndHandleError(options);
@@ -317,7 +336,7 @@ export class RunningSummarizer
 				: defaultMaxAttemptsForSubmitFailures;
 	}
 
-	private async handleSummaryAck(ack: IAckedSummary) {
+	private async handleSummaryAck(ack: IAckedSummary): Promise<void> {
 		const refSequenceNumber = ack.summaryOp.referenceSequenceNumber;
 		const summaryLogger = this.tryGetCorrelatedLogger(refSequenceNumber) ?? this.mc.logger;
 		const summaryOpHandle = ack.summaryOp.contents.handle;
@@ -338,6 +357,7 @@ export class RunningSummarizer
 		await this.lockedSummaryAction(
 			() => {},
 			async () => {
+				// eslint-disable-next-line import/no-deprecated
 				const options: IRefreshSummaryAckOptions = {
 					proposalHandle: summaryOpHandle,
 					ackHandle: summaryAckHandle,
@@ -351,8 +371,9 @@ export class RunningSummarizer
 	}
 
 	private readonly refreshLatestSummaryAckAndHandleError = async (
+		// eslint-disable-next-line import/no-deprecated
 		options: IRefreshSummaryAckOptions,
-	) => {
+	): Promise<void> => {
 		return this.refreshLatestSummaryAckCallback(options).catch(async (error) => {
 			// If the error is 404, so maybe the fetched version no longer exists on server. We just
 			// ignore this error in that case, as that means we will have another summaryAck for the
@@ -387,7 +408,7 @@ export class RunningSummarizer
 	 * @param referenceSequenceNumber - The referenceSequenceNumber of the summary from which to start processing
 	 * acks.
 	 */
-	private async processIncomingSummaryAcks(referenceSequenceNumber: number) {
+	private async processIncomingSummaryAcks(referenceSequenceNumber: number): Promise<void> {
 		// Start waiting for acks that are for summaries newer that the one this client loaded from.
 		let nextReferenceSequenceNumber = referenceSequenceNumber;
 		while (!this.disposed) {
@@ -417,15 +438,19 @@ export class RunningSummarizer
 	 * but only if they're logging about that same summary.
 	 * @param summaryOpRefSeq - RefSeq number of the summary op, to ensure the log correlation will be correct
 	 */
-	public tryGetCorrelatedLogger = (summaryOpRefSeq) =>
+	public tryGetCorrelatedLogger = (
+		summaryOpRefSeq: number,
+	): ITelemetryLoggerExt | undefined =>
 		this.heuristicData.lastAttempt.refSequenceNumber === summaryOpRefSeq
 			? this.mc.logger
 			: undefined;
 
-	/** We only want a single heuristic runner micro-task (will provide better optimized grouping of ops) */
+	/**
+	 * We only want a single heuristic runner micro-task (will provide better optimized grouping of ops)
+	 */
 	private heuristicRunnerMicroTaskExists = false;
 
-	public handleOp(op: ISequencedDocumentMessage, runtimeMessage: boolean) {
+	public handleOp(op: ISequencedDocumentMessage, runtimeMessage: boolean): void {
 		this.heuristicData.lastOpSequenceNumber = op.sequenceNumber;
 
 		if (runtimeMessage) {
@@ -468,10 +493,12 @@ export class RunningSummarizer
 		switch (op.type) {
 			case MessageType.Summarize:
 			case MessageType.SummaryAck:
-			case MessageType.SummaryNack:
+			case MessageType.SummaryNack: {
 				return false;
-			default:
+			}
+			default: {
 				return runtimeMessage || this.nonRuntimeOpCanTriggerSummary();
+			}
 		}
 	}
 
@@ -496,16 +523,18 @@ export class RunningSummarizer
 		this.disposeEnqueuedSummary();
 
 		// This will try to run lastSummary if needed.
-		if (allowLastSummary && this.heuristicRunner?.shouldRunLastSummary()) {
-			if (this.summarizingLock === undefined) {
-				this.trySummarizeOnce(
-					// summarizeProps
-					{ summarizeReason: "lastSummary" },
-					{},
-					undefined,
-					true /* isLastSummary */,
-				);
-			}
+		if (
+			allowLastSummary &&
+			this.heuristicRunner?.shouldRunLastSummary() &&
+			this.summarizingLock === undefined
+		) {
+			this.trySummarizeOnce(
+				// summarizeProps
+				{ summarizeReason: "lastSummary" },
+				{},
+				undefined,
+				true /* isLastSummary */,
+			);
 		}
 
 		// Note that trySummarizeOnce() call above returns right away, without waiting.
@@ -525,7 +554,7 @@ export class RunningSummarizer
 		this.lastSummarizeFailureEventProps = undefined;
 	}
 
-	private async waitStart() {
+	private async waitStart(): Promise<void> {
 		// Wait no longer than ack timeout for all pending
 		const waitStartResult = await raceTimer(
 			this.summaryWatcher.waitFlushed(),
@@ -548,11 +577,11 @@ export class RunningSummarizer
 		this.initialized = true;
 	}
 
-	private beforeSummaryAction() {
+	private beforeSummaryAction(): void {
 		this.summarizeCount++;
 	}
 
-	private afterSummaryAction() {
+	private afterSummaryAction(): void {
 		const retry = this.tryWhileSummarizing;
 		this.tryWhileSummarizing = false;
 
@@ -576,7 +605,7 @@ export class RunningSummarizer
 		before: () => void,
 		action: () => Promise<T>,
 		after: () => void,
-	) {
+	): Promise<T> {
 		assert(
 			this.summarizingLock === undefined,
 			0x25b /* "Caller is responsible for checking lock" */,
@@ -618,6 +647,7 @@ export class RunningSummarizer
 					logger: this.mc.logger,
 					properties: { all: summarizeProps },
 				});
+				// eslint-disable-next-line import/no-deprecated
 				const summaryOptions: ISubmitSummaryOptions = {
 					...options,
 					summaryLogger,
@@ -680,7 +710,9 @@ export class RunningSummarizer
 		return resultsBuilder.build();
 	}
 
-	/** Heuristics summarize attempt. */
+	/**
+	 * Heuristics summarize attempt.
+	 */
 	private trySummarize(reason: SummarizeReason): void {
 		if (this.summarizingLock !== undefined) {
 			// lockedSummaryAction() will retry heuristic-based summary at the end of current attempt
@@ -712,7 +744,13 @@ export class RunningSummarizer
 		reason: SummarizeReason,
 	): Promise<ISummarizeResults | undefined> {
 		// Helper to set summarize options, telemetry properties and call summarize.
-		const attemptSummarize = (attemptNumber: number, finalAttempt: boolean) => {
+		const attemptSummarize = (
+			attemptNumber: number,
+			finalAttempt: boolean,
+		): {
+			summarizeProps: ISummarizeTelemetryProperties;
+			summarizeResult: ISummarizeResults;
+		} => {
 			const summarizeOptions: ISummarizeOptions = {
 				fullTree: false,
 			};
@@ -726,6 +764,7 @@ export class RunningSummarizer
 				logger: this.mc.logger,
 				properties: { all: summarizeProps },
 			});
+			// eslint-disable-next-line import/no-deprecated
 			const summaryOptions: ISubmitSummaryOptions = {
 				...summarizeOptions,
 				summaryLogger,
@@ -777,9 +816,9 @@ export class RunningSummarizer
 			// If submit summary failed, use maxAttemptsForSubmitFailures. Else use the defaultMaxAttempts.
 			// Note: Check "summarySubmitted" result first because if it fails, ack nack would fail as well.
 			const submitSummaryResult = await results.summarySubmitted;
-			maxAttempts = !submitSummaryResult.success
-				? this.maxAttemptsForSubmitFailures
-				: defaultMaxAttempts;
+			maxAttempts = submitSummaryResult.success
+				? defaultMaxAttempts
+				: this.maxAttemptsForSubmitFailures;
 
 			// Emit "summarize" event for this failed attempt.
 			status = "failure";
@@ -878,7 +917,7 @@ export class RunningSummarizer
 	private async summarizeOnDemandWithRetries(
 		reason: SummarizeReason,
 		resultsBuilder: SummarizeResultBuilder,
-	) {
+	): Promise<ISummarizeResults> {
 		const results = await this.trySummarizeWithRetries(reason);
 		if (results === undefined) {
 			resultsBuilder.fail(
@@ -896,7 +935,9 @@ export class RunningSummarizer
 		return resultsBuilder.build();
 	}
 
-	/** {@inheritdoc (ISummarizer:interface).summarizeOnDemand} */
+	/**
+	 *{@inheritdoc (ISummarizer:interface).summarizeOnDemand}
+	 */
 	public summarizeOnDemand(
 		options: IOnDemandSummarizeOptions,
 		resultsBuilder: SummarizeResultBuilder = new SummarizeResultBuilder(),
@@ -918,7 +959,7 @@ export class RunningSummarizer
 		const { reason, ...summarizeOptions } = options;
 		if (options.retryOnFailure === true) {
 			this.summarizeOnDemandWithRetries(`onDemand;${reason}`, resultsBuilder).catch(
-				(error) => {
+				(error: IRetriableFailureError) => {
 					resultsBuilder.fail("summarize failed", error);
 				},
 			);
@@ -932,7 +973,9 @@ export class RunningSummarizer
 		return resultsBuilder.build();
 	}
 
-	/** {@inheritdoc (ISummarizer:interface).enqueueSummarize} */
+	/**
+	 *{@inheritdoc (ISummarizer:interface).enqueueSummarize}
+	 */
 	public enqueueSummarize(options: IEnqueueSummarizeOptions): EnqueueSummarizeResult {
 		const { reason, afterSequenceNumber = 0, override = false, ...summarizeOptions } = options;
 		let overridden = false;
@@ -968,7 +1011,7 @@ export class RunningSummarizer
 			: results;
 	}
 
-	private tryRunEnqueuedSummary() {
+	private tryRunEnqueuedSummary(): boolean {
 		if (this.stopping) {
 			this.disposeEnqueuedSummary();
 			return false;
@@ -992,7 +1035,7 @@ export class RunningSummarizer
 		return true;
 	}
 
-	private disposeEnqueuedSummary() {
+	private disposeEnqueuedSummary(): void {
 		if (this.enqueuedSummary !== undefined) {
 			this.enqueuedSummary.resultsBuilder.fail(
 				"RunningSummarizer stopped or disposed",

package/src/summary/summarizer.ts

@@ -21,20 +21,25 @@ import {
 
 import { ISummaryConfiguration } from "../containerRuntime.js";
 
+// eslint-disable-next-line import/no-deprecated
 import { ICancellableSummarizerController } from "./runWhileConnectedCoordinator.js";
 import { RunningSummarizer } from "./runningSummarizer.js";
 import { SummarizeHeuristicData } from "./summarizerHeuristics.js";
 import {
 	EnqueueSummarizeResult,
+	// eslint-disable-next-line import/no-deprecated
 	IConnectableRuntime,
 	IEnqueueSummarizeOptions,
 	IOnDemandSummarizeOptions,
 	ISummarizeHeuristicData,
 	ISummarizeResults,
 	ISummarizer,
+	// eslint-disable-next-line import/no-deprecated
 	ISummarizerInternalsProvider,
+	// eslint-disable-next-line import/no-deprecated
 	ISummarizerRuntime,
 	ISummarizingWarning,
+	type IRetriableFailureError,
 } from "./summarizerTypes.js";
 import { SummaryCollection } from "./summaryCollection.js";
 import { SummarizeResultBuilder } from "./summaryGenerator.js";
@@ -55,14 +60,21 @@ export class SummarizingWarning
 		super(errorMessage);
 	}
 
-	static wrap(error: any, logged: boolean = false, logger: ITelemetryLoggerExt) {
-		const newErrorFn = (errMsg: string) => new SummarizingWarning(errMsg, logged);
+	static wrap(
+		error: unknown,
+		logged: boolean = false,
+		logger: ITelemetryLoggerExt,
+	): SummarizingWarning {
+		const newErrorFn = (errMsg: string): SummarizingWarning =>
+			new SummarizingWarning(errMsg, logged);
 		return wrapErrorAndLog<SummarizingWarning>(error, newErrorFn, logger);
 	}
 }
 
-export const createSummarizingWarning = (errorMessage: string, logged: boolean) =>
-	new SummarizingWarning(errorMessage, logged);
+export const createSummarizingWarning = (
+	errorMessage: string,
+	logged: boolean,
+): SummarizingWarning => new SummarizingWarning(errorMessage, logged);
 
 /**
  * Summarizer is responsible for coordinating when to generate and send summaries.
@@ -70,9 +82,10 @@ export const createSummarizingWarning = (errorMessage: string, logged: boolean)
  * It is created only by summarizing container (i.e. one with clientType === "summarizer")
  * @legacy
  * @alpha
+ * @deprecated This type will be moved to internal in 2.30. External usage is not necessary or supported.
  */
 export class Summarizer extends TypedEventEmitter<ISummarizerEvents> implements ISummarizer {
-	public get ISummarizer() {
+	public get ISummarizer(): this {
 		return this;
 	}
 
@@ -84,19 +97,25 @@ export class Summarizer extends TypedEventEmitter<ISummarizerEvents> implements
 	private readonly stopDeferred = new Deferred<SummarizerStopReason>();
 
 	constructor(
-		/** Reference to runtime that created this object.
+		/**
+		 * Reference to runtime that created this object.
 		 * i.e. runtime with clientType === "summarizer"
 		 */
+		// eslint-disable-next-line import/no-deprecated
 		private readonly runtime: ISummarizerRuntime,
 		private readonly configurationGetter: () => ISummaryConfiguration,
-		/** Represents an object that can generate summary.
+		/**
+		 * Represents an object that can generate summary.
 		 * In practical terms, it's same runtime (this.runtime) with clientType === "summarizer".
 		 */
+		// eslint-disable-next-line import/no-deprecated
 		private readonly internalsProvider: ISummarizerInternalsProvider,
 		handleContext: IFluidHandleContext,
 		public readonly summaryCollection: SummaryCollection,
 		private readonly runCoordinatorCreateFn: (
+			// eslint-disable-next-line import/no-deprecated
 			runtime: IConnectableRuntime,
+			// eslint-disable-next-line import/no-deprecated
 		) => Promise<ICancellableSummarizerController>,
 	) {
 		super();
@@ -134,11 +153,11 @@ export class Summarizer extends TypedEventEmitter<ISummarizerEvents> implements
 	 * the run promise, and also close the container.
 	 * @param reason - reason code for stopping
 	 */
-	public stop(reason: SummarizerStopReason) {
+	public stop(reason: SummarizerStopReason): void {
 		this.stopDeferred.resolve(reason);
 	}
 
-	public close() {
+	public close(): void {
 		// This will result in "summarizerClientDisconnected" stop reason recorded in telemetry,
 		// unless stop() was called earlier
 		this.dispose();
@@ -146,12 +165,14 @@ export class Summarizer extends TypedEventEmitter<ISummarizerEvents> implements
 	}
 
 	private async runCore(onBehalfOf: string): Promise<SummarizerStopReason> {
+		// eslint-disable-next-line import/no-deprecated
 		const runCoordinator: ICancellableSummarizerController = await this.runCoordinatorCreateFn(
 			this.runtime,
 		);
 
 		// Wait for either external signal to cancel, or loss of connectivity.
 		const stopP = Promise.race([runCoordinator.waitCancelled, this.stopDeferred.promise]);
+		// eslint-disable-next-line no-void
 		void stopP.then((reason) => {
 			this.logger.sendTelemetryEvent({
 				eventName: "StoppingSummarizer",
@@ -230,6 +251,7 @@ export class Summarizer extends TypedEventEmitter<ISummarizerEvents> implements
 	 */
 	private async start(
 		onBehalfOf: string,
+		// eslint-disable-next-line import/no-deprecated
 		runCoordinator: ICancellableSummarizerController,
 	): Promise<RunningSummarizer> {
 		if (this.runningSummarizer) {
@@ -259,7 +281,9 @@ export class Summarizer extends TypedEventEmitter<ISummarizerEvents> implements
 		this._heuristicData = new SummarizeHeuristicData(
 			this.runtime.deltaManager.lastSequenceNumber,
 			{
-				/** summary attempt baseline for heuristics */
+				/**
+				 * summary attempt baseline for heuristics
+				 */
 				refSequenceNumber: this.runtime.deltaManager.initialSequenceNumber,
 				summaryTime: Date.now(),
 			} as const,
@@ -289,7 +313,7 @@ export class Summarizer extends TypedEventEmitter<ISummarizerEvents> implements
 	 * properties.
 	 * Called by ContainerRuntime when it is disposed, as well as at the end the run().
 	 */
-	public dispose() {
+	public dispose(): void {
 		// Given that the call can come from own ContainerRuntime, ensure that we stop all the processes.
 		this.stop("summarizerClientDisconnected");
 
@@ -347,12 +371,12 @@ export class Summarizer extends TypedEventEmitter<ISummarizerEvents> implements
 							runCoordinator.stop(stopReason);
 							this.close();
 						})
-						.catch((reason) => {
-							builder.fail("Failed to start summarizer", reason);
+						.catch((error: IRetriableFailureError) => {
+							builder.fail("Failed to start summarizer", error);
 						});
 				})
-				.catch((reason) => {
-					builder.fail("Failed to create cancellation token", reason);
+				.catch((error: IRetriableFailureError) => {
+					builder.fail("Failed to create cancellation token", error);
 				});
 
 			return builder.build();
@@ -372,26 +396,28 @@ export class Summarizer extends TypedEventEmitter<ISummarizerEvents> implements
 		return this.runningSummarizer.enqueueSummarize(options);
 	}
 
-	public recordSummaryAttempt?(summaryRefSeqNum?: number) {
+	public recordSummaryAttempt?(summaryRefSeqNum?: number): void {
 		this._heuristicData?.recordAttempt(summaryRefSeqNum);
 	}
 
-	private readonly forwardedEvents = new Map<any, () => void>();
+	private readonly forwardedEvents = new Map<string, () => void>();
 
-	private setupForwardedEvents() {
-		["summarize", "summarizeAllAttemptsFailed"].forEach((event) => {
-			const listener = (...args: any[]) => {
+	private setupForwardedEvents(): void {
+		for (const event of ["summarize", "summarizeAllAttemptsFailed"]) {
+			const listener = (...args: unknown[]): void => {
 				this.emit(event, ...args);
 			};
+			// TODO: better typing here
+			// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument
 			this.runningSummarizer?.on(event as any, listener);
 			this.forwardedEvents.set(event, listener);
-		});
+		}
 	}
 
-	private cleanupForwardedEvents() {
-		this.forwardedEvents.forEach((listener, event) =>
-			this.runningSummarizer?.off(event, listener),
-		);
+	private cleanupForwardedEvents(): void {
+		for (const [event, listener] of this.forwardedEvents.entries()) {
+			this.runningSummarizer?.off(event, listener);
+		}
 		this.forwardedEvents.clear();
 	}
 }

package/src/summary/summarizerClientElection.ts

@@ -11,6 +11,7 @@ import { ITelemetryLoggerExt } from "@fluidframework/telemetry-utils/internal";
 
 import {
 	IOrderedClientElection,
+	// eslint-disable-next-line import/no-deprecated
 	ISerializedElection,
 	ITrackedClient,
 } from "./orderedClientElection.js";
@@ -51,10 +52,10 @@ export class SummarizerClientElection
 	 */
 	private lastReportedSeq = 0;
 
-	public get electedClientId() {
+	public get electedClientId(): string | undefined {
 		return this.clientElection.electedClient?.clientId;
 	}
-	public get electedParentId() {
+	public get electedParentId(): string | undefined {
 		return this.clientElection.electedParent?.clientId;
 	}
 
@@ -119,6 +120,7 @@ export class SummarizerClientElection
 		});
 	}
 
+	// eslint-disable-next-line import/no-deprecated
 	public serialize(): ISerializedElection {
 		const { electedClientId, electedParentId, electionSequenceNumber } =
 			this.clientElection.serialize();

package/src/summary/summarizerHeuristics.ts

@@ -16,7 +16,9 @@ import {
 } from "./summarizerTypes.js";
 import { SummarizeReason } from "./summaryGenerator.js";
 
-/** Simple implementation of class for tracking summarize heuristic data. */
+/**
+ * Simple implementation of class for tracking summarize heuristic data.
+ */
 export class SummarizeHeuristicData implements ISummarizeHeuristicData {
 	protected _lastAttempt: ISummarizeAttempt;
 	public get lastAttempt(): ISummarizeAttempt {
@@ -57,19 +59,21 @@ export class SummarizeHeuristicData implements ISummarizeHeuristicData {
 
 	constructor(
 		public lastOpSequenceNumber: number,
-		/** Baseline attempt data used for comparisons with subsequent attempts/calculations. */
+		/**
+		 * Baseline attempt data used for comparisons with subsequent attempts/calculations.
+		 */
 		attemptBaseline: ISummarizeAttempt,
 	) {
 		this._lastAttempt = attemptBaseline;
 		this._lastSuccessfulSummary = { ...attemptBaseline };
 	}
 
-	public updateWithLastSummaryAckInfo(lastSummary: Readonly<ISummarizeAttempt>) {
+	public updateWithLastSummaryAckInfo(lastSummary: Readonly<ISummarizeAttempt>): void {
 		this._lastAttempt = lastSummary;
 		this._lastSuccessfulSummary = { ...lastSummary };
 	}
 
-	public recordAttempt(refSequenceNumber?: number) {
+	public recordAttempt(refSequenceNumber?: number): void {
 		this._lastAttempt = {
 			refSequenceNumber: refSequenceNumber ?? this.lastOpSequenceNumber,
 			summaryTime: Date.now(),
@@ -80,7 +84,7 @@ export class SummarizeHeuristicData implements ISummarizeHeuristicData {
 		this.totalOpsSizeBefore = this.totalOpsSize;
 	}
 
-	public markLastAttemptAsSuccessful() {
+	public markLastAttemptAsSuccessful(): void {
 		this._lastSuccessfulSummary = { ...this.lastAttempt };
 
 		this.numNonRuntimeOps -= this.numNonRuntimeOpsBefore;
@@ -130,7 +134,7 @@ export class SummarizeHeuristicRunner implements ISummarizeHeuristicRunner {
 			this.configuration.runtimeOpWeight,
 			this.configuration.nonRuntimeOpWeight,
 		);
-		const pToMaxOps = (weightedNumOfOps * 1.0) / this.configuration.maxOps;
+		const pToMaxOps = (weightedNumOfOps * 1) / this.configuration.maxOps;
 
 		if (pToMaxOps >= 1) {
 			return minIdleTime;
@@ -147,11 +151,11 @@ export class SummarizeHeuristicRunner implements ISummarizeHeuristicRunner {
 		);
 	}
 
-	public start() {
+	public start(): void {
 		this.idleTimer?.start(this.idleTime);
 	}
 
-	public run() {
+	public run(): void {
 		for (const strategy of this.summarizeStrategies) {
 			if (strategy.shouldRunSummary(this.configuration, this.heuristicData)) {
 				return this.runSummarize(strategy.summarizeReason);
@@ -179,12 +183,14 @@ export class SummarizeHeuristicRunner implements ISummarizeHeuristicRunner {
 		return weightedOpsSinceLastAck >= minOpsForLastSummaryAttempt;
 	}
 
-	public dispose() {
+	public dispose(): void {
 		this.idleTimer?.clear();
 	}
 }
 
-/** Strategy used to run a summary when it's been a while since our last successful summary */
+/**
+ * Strategy used to run a summary when it's been a while since our last successful summary
+ */
 class MaxTimeSummaryHeuristicStrategy implements ISummaryHeuristicStrategy {
 	public readonly summarizeReason: Readonly<SummarizeReason> = "maxTime";
 
@@ -206,7 +212,9 @@ function getWeightedNumberOfOps(
 	return runtimeOpWeight * runtimeOpCount + nonRuntimeOpWeight * nonRuntimeOpCount;
 }
 
-/** Strategy used to do a weighted analysis on the ops we've processed since the last successful summary */
+/**
+ * Strategy used to do a weighted analysis on the ops we've processed since the last successful summary
+ */
 class WeightedOpsSummaryHeuristicStrategy implements ISummaryHeuristicStrategy {
 	public readonly summarizeReason: Readonly<SummarizeReason> = "maxOps";
 
@@ -224,6 +232,9 @@ class WeightedOpsSummaryHeuristicStrategy implements ISummaryHeuristicStrategy {
 	}
 }
 
-function getDefaultSummaryHeuristicStrategies() {
+function getDefaultSummaryHeuristicStrategies(): (
+	| MaxTimeSummaryHeuristicStrategy
+	| WeightedOpsSummaryHeuristicStrategy
+)[] {
 	return [new MaxTimeSummaryHeuristicStrategy(), new WeightedOpsSummaryHeuristicStrategy()];
 }

package/src/summary/summarizerNode/index.ts

@@ -8,6 +8,7 @@ export {
 	ISummarizerNodeRootContract,
 	ValidateSummaryResult,
 } from "./summarizerNodeUtils.js";
+
 export { IRootSummarizerNode, createRootSummarizerNode } from "./summarizerNode.js";
 export {
 	IRootSummarizerNodeWithGC,