@fluidframework/container-runtime 2.0.0-rc.1.0.3 → 2.0.0-rc.2.0.0

package/src/scheduleManager.ts

@@ -2,7 +2,6 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-import { EventEmitter } from "events";
 import { IDeltaManager } from "@fluidframework/container-definitions";
 import { IDocumentMessage, ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
 import {
@@ -13,11 +12,12 @@ import {
 	ITelemetryLoggerExt,
 } from "@fluidframework/telemetry-utils";
 import { assert } from "@fluidframework/core-utils";
+import type { EventEmitter } from "@fluid-internal/client-utils";
 import { performance } from "@fluid-internal/client-utils";
 import { isRuntimeMessage } from "@fluidframework/driver-utils";
-import { DeltaScheduler } from "./deltaScheduler";
-import { pkgVersion } from "./packageVersion";
-import { IBatchMetadata } from "./metadata";
+import { DeltaScheduler } from "./deltaScheduler.js";
+import { pkgVersion } from "./packageVersion.js";
+import { IBatchMetadata } from "./metadata.js";
 
 type IRuntimeMessageMetadata =
 	| undefined

package/src/summary/index.ts

@@ -10,28 +10,28 @@ export {
 	ITrackedClient,
 	OrderedClientCollection,
 	OrderedClientElection,
-} from "./orderedClientElection";
-export { defaultMaxAttemptsForSubmitFailures, RunningSummarizer } from "./runningSummarizer";
+} from "./orderedClientElection.js";
+export { defaultMaxAttemptsForSubmitFailures, RunningSummarizer } from "./runningSummarizer.js";
 export {
 	ICancellableSummarizerController,
 	neverCancelledSummaryToken,
 	RunWhileConnectedCoordinator,
-} from "./runWhileConnectedCoordinator";
-export { Summarizer } from "./summarizer";
+} from "./runWhileConnectedCoordinator.js";
+export { Summarizer } from "./summarizer.js";
 export {
 	ISummarizerClientElection,
 	ISummarizerClientElectionEvents,
 	SummarizerClientElection,
 	summarizerClientType,
-} from "./summarizerClientElection";
-export { SummarizeHeuristicData, SummarizeHeuristicRunner } from "./summarizerHeuristics";
+} from "./summarizerClientElection.js";
+export { SummarizeHeuristicData, SummarizeHeuristicRunner } from "./summarizerHeuristics.js";
 export {
 	createRootSummarizerNode,
 	createRootSummarizerNodeWithGC,
 	IRefreshSummaryResult,
 	IRootSummarizerNode,
 	IRootSummarizerNodeWithGC,
-} from "./summarizerNode";
+} from "./summarizerNode/index.js";
 export {
 	IConnectableRuntime,
 	IGeneratedSummaryStats,
@@ -65,7 +65,7 @@ export {
 	SummaryStage,
 	IRetriableFailureResult,
 	ISummarizeEventProps,
-} from "./summarizerTypes";
+} from "./summarizerTypes.js";
 export {
 	IAckedSummary,
 	ISummaryCollectionOpEvents,
@@ -77,7 +77,7 @@ export {
 	ISummaryNackMessage,
 	OpActionEventListener,
 	OpActionEventName,
-} from "./summaryCollection";
+} from "./summaryCollection.js";
 export {
 	aliasBlobName,
 	blobsTreeName,
@@ -98,12 +98,13 @@ export {
 	WriteFluidDataStoreAttributes,
 	wrapSummaryInChannelsTree,
 	idCompressorBlobName,
-} from "./summaryFormat";
-export { getFailMessage, RetriableSummaryError, SummarizeReason } from "./summaryGenerator";
+	IdCompressorMode,
+} from "./summaryFormat.js";
+export { getFailMessage, RetriableSummaryError, SummarizeReason } from "./summaryGenerator.js";
 export {
 	IConnectedEvents,
 	IConnectedState,
 	ISummaryManagerConfig,
 	SummaryManager,
 	SummaryManagerState,
-} from "./summaryManager";
+} from "./summaryManager.js";

package/src/summary/orderedClientElection.ts

@@ -13,7 +13,7 @@ import { assert } from "@fluidframework/core-utils";
 import { TypedEventEmitter } from "@fluid-internal/client-utils";
 import { IDeltaManager } from "@fluidframework/container-definitions";
 import { IClient, IQuorumClients, ISequencedClient } from "@fluidframework/protocol-definitions";
-import { summarizerClientType } from "./summarizerClientElection";
+import { summarizerClientType } from "./summarizerClientElection.js";
 
 // helper types for recursive readonly.
 // eslint-disable-next-line @typescript-eslint/ban-types

package/src/summary/runWhileConnectedCoordinator.ts

@@ -8,7 +8,7 @@ import {
 	SummarizerStopReason,
 	IConnectableRuntime,
 	ISummaryCancellationToken,
-} from "./summarizerTypes";
+} from "./summarizerTypes.js";
 
 /**
  * Similar to AbortController, but using promise instead of events

package/src/summary/runningSummarizer.ts

@@ -15,9 +15,9 @@ import { assert, delay, Deferred, PromiseTimer } from "@fluidframework/core-util
 import { TypedEventEmitter } from "@fluid-internal/client-utils";
 import { DriverErrorTypes } from "@fluidframework/driver-definitions";
 import { ISequencedDocumentMessage, MessageType } from "@fluidframework/protocol-definitions";
-import { ISummaryConfiguration } from "../containerRuntime";
-import { opSize } from "../opProperties";
-import { SummarizeHeuristicRunner } from "./summarizerHeuristics";
+import { ISummaryConfiguration } from "../containerRuntime.js";
+import { opSize } from "../opProperties.js";
+import { SummarizeHeuristicRunner } from "./summarizerHeuristics.js";
 import {
 	IEnqueueSummarizeOptions,
 	ISummarizeOptions,
@@ -36,14 +36,14 @@ import {
 	IRefreshSummaryAckOptions,
 	ISummarizerEvents,
 	ISummarizeEventProps,
-} from "./summarizerTypes";
-import { IAckedSummary, IClientSummaryWatcher, SummaryCollection } from "./summaryCollection";
+} from "./summarizerTypes.js";
+import { IAckedSummary, IClientSummaryWatcher, SummaryCollection } from "./summaryCollection.js";
 import {
 	raceTimer,
 	SummarizeReason,
 	SummarizeResultBuilder,
 	SummaryGenerator,
-} from "./summaryGenerator";
+} from "./summaryGenerator.js";
 
 const maxSummarizeAckWaitTime = 10 * 60 * 1000; // 10 minutes
 
@@ -91,15 +91,26 @@ export class RunningSummarizer extends TypedEventEmitter<ISummarizerEvents> impl
 			runtime,
 		);
 
-		// Before doing any heuristics or proceeding with its refreshing, if there is a summary ack received while
-		// this summarizer catches up, let's refresh state before proceeding with the summarization.
-		const lastAckRefSeq = await summarizer.handleSummaryAck();
+		// If there have been any acks newer that the one this client loaded from until now, process them before
+		// starting the running summarizer which will trigger summary heuristics.
+		// This is done primarily to handle scenarios where the summarizer loads from a cached snapshot and there
+		// is newer one available. The ack for the newer summary is processed before summarizing because otherwise
+		// that summary would fail as it has an older parent.
+		let nextReferenceSequenceNumber = runtime.deltaManager.initialSequenceNumber + 1;
+		const latestAck = summaryCollection.latestAck;
+		if (
+			latestAck !== undefined &&
+			latestAck.summaryOp.referenceSequenceNumber >= nextReferenceSequenceNumber
+		) {
+			await summarizer.handleSummaryAck(latestAck);
+			nextReferenceSequenceNumber = latestAck.summaryOp.referenceSequenceNumber + 1;
+		}
 
 		await summarizer.waitStart();
 
-		// Handle summary acks asynchronously
+		// Process summary acks asynchronously
 		// Note: no exceptions are thrown from processIncomingSummaryAcks handler as it handles all exceptions
-		summarizer.processIncomingSummaryAcks(lastAckRefSeq).catch((error) => {
+		summarizer.processIncomingSummaryAcks(nextReferenceSequenceNumber).catch((error) => {
 			createChildLogger({ logger }).sendErrorEvent(
 				{ eventName: "HandleSummaryAckFatalError" },
 				error,
@@ -243,6 +254,9 @@ export class RunningSummarizer extends TypedEventEmitter<ISummarizerEvents> impl
 			}
 		});
 
+		const immediatelyRefreshLatestSummaryAck =
+			this.mc.config.getBoolean("Fluid.Summarizer.immediatelyRefreshLatestSummaryAck") ??
+			true;
 		this.generator = new SummaryGenerator(
 			this.pendingAckTimer,
 			this.heuristicData,
@@ -250,6 +264,11 @@ export class RunningSummarizer extends TypedEventEmitter<ISummarizerEvents> impl
 			() => {
 				this.totalSuccessfulAttempts++;
 			},
+			async (options: IRefreshSummaryAckOptions) => {
+				if (immediatelyRefreshLatestSummaryAck) {
+					await this.refreshLatestSummaryAckAndHandleError(options);
+				}
+			},
 			this.summaryWatcher,
 			this.mc.logger,
 		);
@@ -272,94 +291,85 @@ export class RunningSummarizer extends TypedEventEmitter<ISummarizerEvents> impl
 				: defaultMaxAttemptsForSubmitFailures;
 	}
 
-	private async handleSummaryAck(): Promise<number> {
-		const lastAck: IAckedSummary | undefined = this.summaryCollection.latestAck;
-		let refSequenceNumber = -1;
-		// In case we haven't received the lastestAck yet, just return.
-		if (lastAck !== undefined) {
-			refSequenceNumber = lastAck.summaryOp.referenceSequenceNumber;
-			const summaryLogger = this.tryGetCorrelatedLogger(refSequenceNumber) ?? this.mc.logger;
-			const summaryOpHandle = lastAck.summaryOp.contents.handle;
-			const summaryAckHandle = lastAck.summaryAck.contents.handle;
-			while (this.summarizingLock !== undefined) {
-				summaryLogger.sendTelemetryEvent({
-					eventName: "RefreshAttemptWithSummarizerRunning",
-					referenceSequenceNumber: refSequenceNumber,
+	private async handleSummaryAck(ack: IAckedSummary) {
+		const refSequenceNumber = ack.summaryOp.referenceSequenceNumber;
+		const summaryLogger = this.tryGetCorrelatedLogger(refSequenceNumber) ?? this.mc.logger;
+		const summaryOpHandle = ack.summaryOp.contents.handle;
+		const summaryAckHandle = ack.summaryAck.contents.handle;
+		while (this.summarizingLock !== undefined) {
+			summaryLogger.sendTelemetryEvent({
+				eventName: "RefreshAttemptWithSummarizerRunning",
+				referenceSequenceNumber: refSequenceNumber,
+				proposalHandle: summaryOpHandle,
+				ackHandle: summaryAckHandle,
+			});
+			await this.summarizingLock;
+		}
+
+		// Make sure we block any summarizer from being executed/enqueued while
+		// executing the refreshLatestSummaryAck.
+		// https://dev.azure.com/fluidframework/internal/_workitems/edit/779
+		await this.lockedSummaryAction(
+			() => {},
+			async () => {
+				const options: IRefreshSummaryAckOptions = {
 					proposalHandle: summaryOpHandle,
 					ackHandle: summaryAckHandle,
-				});
-				await this.summarizingLock;
-			}
+					summaryRefSeq: refSequenceNumber,
+					summaryLogger,
+				};
+				await this.refreshLatestSummaryAckAndHandleError(options);
+			},
+			() => {},
+		);
+	}
 
-			// Make sure we block any summarizer from being executed/enqueued while
-			// executing the refreshLatestSummaryAck.
-			// https://dev.azure.com/fluidframework/internal/_workitems/edit/779
-			await this.lockedSummaryAction(
-				() => {},
-				async () =>
-					this.refreshLatestSummaryAckCallback({
-						proposalHandle: summaryOpHandle,
-						ackHandle: summaryAckHandle,
-						summaryRefSeq: refSequenceNumber,
-						summaryLogger,
-					}).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
-						// latest version with which we will refresh the state. However in case of single commit
-						// summary, we might me missing a summary ack, so in that case we are still fine as the
-						// code in `submitSummary` function in container runtime, will refresh the latest state
-						// by calling `prefetchLatestSummaryThenClose`. We will load the next summarizer from the
-						// updated state and be fine.
-						const isIgnoredError =
-							isFluidError(error) &&
-							error.errorType === DriverErrorTypes.fileNotFoundOrAccessDeniedError;
-
-						summaryLogger.sendTelemetryEvent(
-							{
-								eventName: isIgnoredError
-									? "HandleSummaryAckErrorIgnored"
-									: "HandleLastSummaryAckError",
-								referenceSequenceNumber: refSequenceNumber,
-								proposalHandle: summaryOpHandle,
-								ackHandle: summaryAckHandle,
-							},
-							error,
-						);
-					}),
-				() => {},
+	private readonly refreshLatestSummaryAckAndHandleError = async (
+		options: IRefreshSummaryAckOptions,
+	) => {
+		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
+			// latest version with which we will refresh the state. However in case of single commit
+			// summary, we might be missing a summary ack, so in that case we are still fine as the
+			// code in `submitSummary` function in container runtime, will refresh the latest state
+			// by calling `prefetchLatestSummaryThenClose`. We will load the next summarizer from the
+			// updated state and be fine.
+			const isIgnoredError =
+				isFluidError(error) &&
+				error.errorType === DriverErrorTypes.fileNotFoundOrAccessDeniedError;
+
+			options.summaryLogger.sendTelemetryEvent(
+				{
+					eventName: isIgnoredError
+						? "HandleSummaryAckErrorIgnored"
+						: "HandleLastSummaryAckError",
+					referenceSequenceNumber: options.summaryRefSeq,
+					proposalHandle: options.proposalHandle,
+					ackHandle: options.ackHandle,
+				},
+				error,
 			);
-			refSequenceNumber++;
-		}
-		return refSequenceNumber;
-	}
+		});
+	};
 
 	/**
-	 * Responsible for receiving and processing all the summaryAcks.
-	 * In case there was a summary ack processed by the running summarizer before processIncomingSummaryAcks is called,
-	 * it will wait for the summary ack that is newer than the one indicated by the lastAckRefSeq.
-	 * @param lastAckRefSeq - Identifies the minimum reference sequence number the summarizer needs to wait for.
-	 * In case of a negative number, the summarizer will wait for ANY summary ack that is greater than the deltaManager's initial sequence number,
-	 * and, in case of a positive one, it will wait for a summary ack that is greater than this current reference sequence number.
+	 * Responsible for receiving and processing all the summary acks.
+	 * It starts processing ACKs after the one for the summary this client loaded from (initialSequenceNumber). Any
+	 * ACK before that is not interesting as it will simply be ignored.
+	 *
+	 * @param referenceSequenceNumber - The referenceSequenceNumber of the summary from which to start processing
+	 * acks.
 	 */
-	private async processIncomingSummaryAcks(lastAckRefSeq: number) {
-		let refSequenceNumber =
-			lastAckRefSeq > 0 ? lastAckRefSeq : this.runtime.deltaManager.initialSequenceNumber;
+	private async processIncomingSummaryAcks(referenceSequenceNumber: number) {
+		// Start waiting for acks that are for summaries newer that the one this client loaded from.
+		let nextReferenceSequenceNumber = referenceSequenceNumber;
 		while (!this.disposed) {
-			const summaryLogger = this.tryGetCorrelatedLogger(refSequenceNumber) ?? this.mc.logger;
-
-			// Initialize ack with undefined if exception happens inside of waitSummaryAck on second iteration,
-			// we record undefined, not previous handles.
-			await this.summaryCollection.waitSummaryAck(refSequenceNumber);
-
-			summaryLogger.sendTelemetryEvent({
-				eventName: "processIncomingSummaryAcks",
-				referenceSequenceNumber: refSequenceNumber,
-				lastAckRefSeq,
-			});
-
-			refSequenceNumber = await this.handleSummaryAck();
-			// A valid Summary Ack must have been processed.
-			assert(refSequenceNumber >= 0, 0x58f /* Invalid ref sequence number */);
+			const ackedSummary = await this.summaryCollection.waitSummaryAck(
+				nextReferenceSequenceNumber,
+			);
+			await this.handleSummaryAck(ackedSummary);
+			nextReferenceSequenceNumber = ackedSummary.summaryOp.referenceSequenceNumber + 1;
 		}
 	}
 
@@ -571,10 +581,22 @@ export class RunningSummarizer extends TypedEventEmitter<ISummarizerEvents> impl
 					...options,
 					summaryLogger,
 					cancellationToken: this.cancellationToken,
+					latestSummaryRefSeqNum:
+						this.heuristicData.lastSuccessfulSummary.refSequenceNumber,
 				};
 				const summarizeResult = this.generator.summarize(summaryOptions, resultsBuilder);
 				// ensure we wait till the end of the process
-				return summarizeResult.receivedSummaryAckOrNack;
+				const result = await summarizeResult.receivedSummaryAckOrNack;
+				if (!result.success) {
+					this.mc.logger.sendErrorEvent(
+						{
+							eventName: "SummarizeFailed",
+							maxAttempts: 1,
+							summaryAttempts: 1,
+						},
+						result.error,
+					);
+				}
 			},
 			() => {
 				this.afterSummaryAction();
@@ -627,6 +649,7 @@ export class RunningSummarizer extends TypedEventEmitter<ISummarizerEvents> impl
 		let summaryAttempts = 0;
 		let summaryAttemptsPerPhase = 0;
 		let summaryAttemptPhase = 0;
+		let error: any;
 		while (summaryAttemptPhase < attemptOptions.length) {
 			if (this.cancellationToken.cancelled) {
 				return;
@@ -655,6 +678,7 @@ export class RunningSummarizer extends TypedEventEmitter<ISummarizerEvents> impl
 				...summarizeOptions,
 				summaryLogger,
 				cancellationToken: this.cancellationToken,
+				latestSummaryRefSeqNum: this.heuristicData.lastSuccessfulSummary.refSequenceNumber,
 			};
 
 			// Note: no need to account for cancellationToken.waitCancelled here, as
@@ -665,6 +689,8 @@ export class RunningSummarizer extends TypedEventEmitter<ISummarizerEvents> impl
 				return;
 			}
 
+			error = ackNackResult.error;
+
 			// Check for retryDelay that can come from summaryNack, upload summary or submit summary flows.
 			// Retry the same step only once per retryAfter response.
 			const submitResult = await resultSummarize.summarySubmitted;
@@ -686,6 +712,14 @@ export class RunningSummarizer extends TypedEventEmitter<ISummarizerEvents> impl
 				await delay(delaySeconds * 1000);
 			}
 		}
+		this.mc.logger.sendErrorEvent(
+			{
+				eventName: "SummarizeFailed",
+				maxAttempts: attemptOptions.length,
+				summaryAttempts: summaryAttemptPhase,
+			},
+			error,
+		);
 		this.stopSummarizerCallback("failToSummarize");
 	}
 
@@ -716,6 +750,7 @@ export class RunningSummarizer extends TypedEventEmitter<ISummarizerEvents> impl
 				summaryLogger,
 				cancellationToken: this.cancellationToken,
 				finalAttempt,
+				latestSummaryRefSeqNum: this.heuristicData.lastSuccessfulSummary.refSequenceNumber,
 			};
 			const summarizeResult = this.generator.summarize(summaryOptions);
 			return { summarizeProps, summarizeResult };
@@ -736,6 +771,7 @@ export class RunningSummarizer extends TypedEventEmitter<ISummarizerEvents> impl
 		let done = false;
 		let status: "success" | "failure" | "canceled" = "success";
 		let results: ISummarizeResults | undefined;
+		let error: any;
 		do {
 			currentAttempt++;
 			if (this.cancellationToken.cancelled) {
@@ -770,11 +806,12 @@ export class RunningSummarizer extends TypedEventEmitter<ISummarizerEvents> impl
 
 			// Emit "summarize" event for this failed attempt.
 			status = "failure";
+			error = ackNackResult.error;
 			const eventProps: ISummarizeEventProps = {
 				result: status,
 				currentAttempt,
 				maxAttempts,
-				error: ackNackResult.error,
+				error,
 			};
 			this.emit("summarize", eventProps);
 
@@ -811,6 +848,9 @@ export class RunningSummarizer extends TypedEventEmitter<ISummarizerEvents> impl
 			// Ack / nack is the final step, so if it succeeds we're done.
 			const ackNackResult = await summarizeResult.receivedSummaryAckOrNack;
 			status = ackNackResult.success ? "success" : "failure";
+			if (!ackNackResult.success) {
+				error = ackNackResult.error;
+			}
 			const eventProps: ISummarizeEventProps = {
 				result: status,
 				currentAttempt,
@@ -823,6 +863,14 @@ export class RunningSummarizer extends TypedEventEmitter<ISummarizerEvents> impl
 
 		// If summarization is still unsuccessful, stop the summarizer.
 		if (status === "failure") {
+			this.mc.logger.sendErrorEvent(
+				{
+					eventName: "SummarizeFailed",
+					maxAttempts,
+					summaryAttempts: currentAttempt,
+				},
+				error,
+			);
 			this.stopSummarizerCallback("failToSummarize");
 		}
 		return results;

package/src/summary/summarizer.ts

@@ -14,10 +14,10 @@ import {
 	wrapErrorAndLog,
 } from "@fluidframework/telemetry-utils";
 import { IFluidHandleContext } from "@fluidframework/core-interfaces";
-import { ISummaryConfiguration } from "../containerRuntime";
-import { ICancellableSummarizerController } from "./runWhileConnectedCoordinator";
-import { SummaryCollection } from "./summaryCollection";
-import { RunningSummarizer } from "./runningSummarizer";
+import { ISummaryConfiguration } from "../containerRuntime.js";
+import { ICancellableSummarizerController } from "./runWhileConnectedCoordinator.js";
+import { SummaryCollection } from "./summaryCollection.js";
+import { RunningSummarizer } from "./runningSummarizer.js";
 import {
 	IConnectableRuntime,
 	ISummarizer,
@@ -32,9 +32,9 @@ import {
 	EnqueueSummarizeResult,
 	ISummarizerEvents,
 	ISummarizeEventProps,
-} from "./summarizerTypes";
-import { SummarizeHeuristicData } from "./summarizerHeuristics";
-import { SummarizeResultBuilder } from "./summaryGenerator";
+} from "./summarizerTypes.js";
+import { SummarizeHeuristicData } from "./summarizerHeuristics.js";
+import { SummarizeResultBuilder } from "./summaryGenerator.js";
 
 const summarizingError = "summarizingError";
 

package/src/summary/summarizerClientElection.ts

@@ -11,8 +11,8 @@ import {
 	IOrderedClientElection,
 	ISerializedElection,
 	ITrackedClient,
-} from "./orderedClientElection";
-import { ISummaryCollectionOpEvents } from "./summaryCollection";
+} from "./orderedClientElection.js";
+import { ISummaryCollectionOpEvents } from "./summaryCollection.js";
 
 export const summarizerClientType = "summarizer";
 

package/src/summary/summarizerHeuristics.ts

@@ -5,14 +5,14 @@
 
 import { ITelemetryLoggerExt } from "@fluidframework/telemetry-utils";
 import { Timer } from "@fluidframework/core-utils";
-import { ISummaryConfigurationHeuristics } from "../containerRuntime";
+import { ISummaryConfigurationHeuristics } from "../containerRuntime.js";
 import {
 	ISummarizeHeuristicData,
 	ISummarizeHeuristicRunner,
 	ISummarizeAttempt,
 	ISummaryHeuristicStrategy,
-} from "./summarizerTypes";
-import { SummarizeReason } from "./summaryGenerator";
+} from "./summarizerTypes.js";
+import { SummarizeReason } from "./summaryGenerator.js";
 
 /** Simple implementation of class for tracking summarize heuristic data. */
 export class SummarizeHeuristicData implements ISummarizeHeuristicData {

package/src/summary/summarizerNode/index.ts

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