@fluidframework/container-runtime 2.0.0-dev-rc.5.0.0.263932 → 2.0.0-dev-rc.5.0.0.267932

package/src/summary/index.ts

@@ -63,7 +63,7 @@ export {
 	SummarizeResultPart,
 	SubmitSummaryFailureData,
 	SummaryStage,
-	IRetriableFailureResult,
+	IRetriableFailureError,
 	ISummarizeEventProps,
 } from "./summarizerTypes.js";
 export {

package/src/summary/orderedClientElection.ts

@@ -9,7 +9,7 @@ import { TypedEventEmitter } from "@fluid-internal/client-utils";
 import { IDeltaManager } from "@fluidframework/container-definitions/internal";
 import { IEvent, IEventProvider, ITelemetryBaseLogger } from "@fluidframework/core-interfaces";
 import { assert } from "@fluidframework/core-utils/internal";
-import { IClient, IQuorumClients, ISequencedClient } from "@fluidframework/protocol-definitions";
+import { IClient, IQuorumClients, ISequencedClient } from "@fluidframework/driver-definitions";
 import {
 	ITelemetryLoggerExt,
 	UsageError,
@@ -351,6 +351,7 @@ export class OrderedClientElection
 		/** Serialized state from summary or current sequence number at time of load if new. */
 		initialState: ISerializedElection | number,
 		private readonly isEligibleFn: (c: ITrackedClient) => boolean,
+		private readonly recordPerformanceEvents: boolean = false,
 	) {
 		super();
 		let initialClient: ILinkedClient | undefined;
@@ -410,17 +411,42 @@ export class OrderedClientElection
 	 * Note that this function does no eligibility or suitability checks. If we get here, then
 	 * we will set _electedClient, and we will set _electedParent if this is an interactive client.
 	 */
-	private tryElectingClient(client: ILinkedClient | undefined, sequenceNumber: number): void {
+	private tryElectingClient(
+		client: ILinkedClient | undefined,
+		sequenceNumber: number,
+		reason: string,
+	): void {
+		this.sendPerformanceEvent(
+			"TryElectingClient",
+			client,
+			sequenceNumber,
+			false /* forceSend */,
+			reason,
+		);
 		let change = false;
 		const isSummarizerClient = client?.client.details.type === summarizerClientType;
 		const prevClient = this._electedClient;
 		if (this._electedClient !== client) {
+			this.sendPerformanceEvent(
+				"ClientElected",
+				client,
+				sequenceNumber,
+				true /* forceSend */,
+				reason,
+			);
 			// Changing the elected client. Record the sequence number and note that we have to fire an event.
 			this._electionSequenceNumber = sequenceNumber;
 			this._electedClient = client;
 			change = true;
 		}
 		if (this._electedParent !== client && !isSummarizerClient) {
+			this.sendPerformanceEvent(
+				"InteractiveClientElected",
+				client,
+				sequenceNumber,
+				true /* forceSend */,
+				reason,
+			);
 			// Changing the elected parent as well.
 			this._electedParent = client;
 			change = true;
@@ -430,8 +456,26 @@ export class OrderedClientElection
 		}
 	}
 
-	private tryElectingParent(client: ILinkedClient | undefined, sequenceNumber: number): void {
+	private tryElectingParent(
+		client: ILinkedClient | undefined,
+		sequenceNumber: number,
+		reason: string,
+	): void {
+		this.sendPerformanceEvent(
+			"TryElectingParent",
+			client,
+			sequenceNumber,
+			false /* forceSend */,
+			reason,
+		);
 		if (this._electedParent !== client) {
+			this.sendPerformanceEvent(
+				"ParentElected",
+				client,
+				sequenceNumber,
+				true /* forceSend */,
+				reason,
+			);
 			this._electedParent = client;
 			this.emit("election", this._electedClient, sequenceNumber, this._electedClient);
 		}
@@ -462,6 +506,7 @@ export class OrderedClientElection
 	 * @param sequenceNumber - sequence number when client was added
 	 */
 	private addClient(client: ILinkedClient, sequenceNumber: number): void {
+		this.sendPerformanceEvent("AddClient", client, sequenceNumber);
 		if (this.isEligibleFn(client)) {
 			this._eligibleCount++;
 			const newClientIsSummarizer = client.client.details.type === summarizerClientType;
@@ -472,10 +517,10 @@ export class OrderedClientElection
 				this._electedClient === undefined ||
 				(!electedClientIsSummarizer && newClientIsSummarizer)
 			) {
-				this.tryElectingClient(client, sequenceNumber);
+				this.tryElectingClient(client, sequenceNumber, "AddClient");
 			} else if (this._electedParent === undefined && !newClientIsSummarizer) {
 				// This is an odd case. If the _electedClient is set, the _electedParent should be as well.
-				this.tryElectingParent(client, sequenceNumber);
+				this.tryElectingParent(client, sequenceNumber, "AddClient");
 			}
 		}
 	}
@@ -487,6 +532,7 @@ export class OrderedClientElection
 	 * @param sequenceNumber - sequence number when client was removed
 	 */
 	private removeClient(client: ILinkedClient, sequenceNumber: number): void {
+		this.sendPerformanceEvent("RemoveClient", client, sequenceNumber);
 		if (this.isEligibleFn(client)) {
 			this._eligibleCount--;
 			if (this._electedClient === client) {
@@ -497,14 +543,18 @@ export class OrderedClientElection
 					if (this._electedClient.client.details.type !== summarizerClientType) {
 						throw new UsageError("Elected client should be a summarizer client 1");
 					}
-					this.tryElectingClient(this._electedParent, sequenceNumber);
+					this.tryElectingClient(
+						this._electedParent,
+						sequenceNumber,
+						"RemoveSummarizerClient",
+					);
 				} else {
 					// 2. The _electedClient is an interactive client that has left the quorum.
 					// Automatically shift to next oldest client.
 					const nextClient =
 						this.findFirstEligibleParent(this._electedParent?.youngerClient) ??
 						this.findFirstEligibleParent(this.orderedClientCollection.oldestClient);
-					this.tryElectingClient(nextClient, sequenceNumber);
+					this.tryElectingClient(nextClient, sequenceNumber, "RemoveClient");
 				}
 			} else if (this._electedParent === client) {
 				// Removing the _electedParent (but not _electedClient).
@@ -516,7 +566,7 @@ export class OrderedClientElection
 				const nextParent =
 					this.findFirstEligibleParent(this._electedParent?.youngerClient) ??
 					this.findFirstEligibleParent(this.orderedClientCollection.oldestClient);
-				this.tryElectingParent(nextParent, sequenceNumber);
+				this.tryElectingParent(nextParent, sequenceNumber, "RemoveClient");
 			}
 		}
 	}
@@ -534,11 +584,11 @@ export class OrderedClientElection
 			this.findFirstEligibleParent(this._electedParent?.youngerClient) ??
 			this.findFirstEligibleParent(this.orderedClientCollection.oldestClient);
 		if (this._electedClient === undefined || this._electedClient === this._electedParent) {
-			this.tryElectingClient(nextClient, sequenceNumber);
+			this.tryElectingClient(nextClient, sequenceNumber, "IncrementElectedClient");
 		} else {
 			// The _electedClient is a summarizer and should not be replaced until it leaves the quorum.
 			// Changing the _electedParent will stop the summarizer.
-			this.tryElectingParent(nextClient, sequenceNumber);
+			this.tryElectingParent(nextClient, sequenceNumber, "IncrementElectedClient");
 		}
 	}
 
@@ -549,11 +599,11 @@ export class OrderedClientElection
 	public resetElectedClient(sequenceNumber: number): void {
 		const firstClient = this.findFirstEligibleParent(this.orderedClientCollection.oldestClient);
 		if (this._electedClient === undefined || this._electedClient === this._electedParent) {
-			this.tryElectingClient(firstClient, sequenceNumber);
+			this.tryElectingClient(firstClient, sequenceNumber, "ResetElectedClient");
 		} else {
 			// The _electedClient is a summarizer and should not be replaced until it leaves the quorum.
 			// Changing the _electedParent will stop the summarizer.
-			this.tryElectingParent(firstClient, sequenceNumber);
+			this.tryElectingParent(firstClient, sequenceNumber, "ResetElectedClient");
 		}
 	}
 
@@ -571,4 +621,25 @@ export class OrderedClientElection
 			electedParentId: this.electedParent?.clientId,
 		};
 	}
+
+	private sendPerformanceEvent(
+		eventName: string,
+		client: ILinkedClient | undefined,
+		sequenceNumber: number,
+		forceSend: boolean = false,
+		reason?: string,
+	) {
+		if (this.recordPerformanceEvents || forceSend) {
+			this.logger.sendPerformanceEvent({
+				eventName,
+				clientId: client?.clientId,
+				sequenceNumber,
+				electedClientId: this.electedClient?.clientId,
+				electedParentId: this.electedParent?.clientId,
+				isEligible: client !== undefined ? this.isEligibleFn(client) : false,
+				isSummarizerClient: client?.client.details.type === summarizerClientType,
+				reason,
+			});
+		}
+	}
 }

package/src/summary/runningSummarizer.ts

@@ -6,8 +6,8 @@
 import { TypedEventEmitter } from "@fluid-internal/client-utils";
 import { IDisposable, ITelemetryBaseLogger } from "@fluidframework/core-interfaces";
 import { assert, Deferred, PromiseTimer, delay } from "@fluidframework/core-utils/internal";
-import { DriverErrorTypes } from "@fluidframework/driver-definitions/internal";
-import { ISequencedDocumentMessage, MessageType } from "@fluidframework/protocol-definitions";
+import { ISequencedDocumentMessage } from "@fluidframework/driver-definitions";
+import { DriverErrorTypes, MessageType } from "@fluidframework/driver-definitions/internal";
 import {
 	MonitoringContext,
 	UsageError,
@@ -38,9 +38,11 @@ import {
 	ISummaryCancellationToken,
 	SubmitSummaryResult,
 	SummarizerStopReason,
+	type IRetriableFailureError,
 } from "./summarizerTypes.js";
 import { IAckedSummary, IClientSummaryWatcher, SummaryCollection } from "./summaryCollection.js";
 import {
+	RetriableSummaryError,
 	SummarizeReason,
 	SummarizeResultBuilder,
 	SummaryGenerator,
@@ -474,7 +476,6 @@ export class RunningSummarizer extends TypedEventEmitter<ISummarizerEvents> impl
 				this.trySummarizeOnce(
 					// summarizeProps
 					{ summarizeReason: "lastSummary" },
-					// ISummarizeOptions, using defaults: { refreshLatestAck: false, fullTree: false }
 					{},
 				);
 			}
@@ -627,9 +628,7 @@ export class RunningSummarizer extends TypedEventEmitter<ISummarizerEvents> impl
 				this.beforeSummaryAction();
 			},
 			async () => {
-				return this.mc.config.getBoolean("Fluid.Summarizer.UseDynamicRetries")
-					? this.trySummarizeWithRetries(reason)
-					: this.trySummarizeWithStaticAttempts(reason);
+				return this.trySummarizeWithRetries(reason);
 			},
 			() => {
 				this.afterSummaryAction();
@@ -639,92 +638,6 @@ export class RunningSummarizer extends TypedEventEmitter<ISummarizerEvents> impl
 		});
 	}
 
-	/**
-	 * Tries to summarize 2 times with pre-defined summary options. If an attempt fails with "retryAfterSeconds"
-	 * param, that attempt is tried once more.
-	 */
-	private async trySummarizeWithStaticAttempts(reason: SummarizeReason) {
-		const attemptOptions: ISummarizeOptions[] = [
-			{ refreshLatestAck: false, fullTree: false },
-			{ refreshLatestAck: true, fullTree: false },
-		];
-		let summaryAttempts = 0;
-		let summaryAttemptsPerPhase = 0;
-		let summaryAttemptPhase = 0;
-		let error: any;
-		while (summaryAttemptPhase < attemptOptions.length) {
-			if (this.cancellationToken.cancelled) {
-				return;
-			}
-
-			// We only want to attempt 1 summary when reason is "lastSummary"
-			if (++summaryAttempts > 1 && reason === "lastSummary") {
-				return;
-			}
-
-			summaryAttemptsPerPhase++;
-
-			const summarizeOptions = attemptOptions[summaryAttemptPhase];
-			const summarizeProps: ISummarizeTelemetryProperties = {
-				summarizeReason: reason,
-				summaryAttempts,
-				summaryAttemptsPerPhase,
-				summaryAttemptPhase: summaryAttemptPhase + 1, // make everything 1-based
-				...summarizeOptions,
-			};
-			const summaryLogger = createChildLogger({
-				logger: this.mc.logger,
-				properties: { all: summarizeProps },
-			});
-			const summaryOptions: ISubmitSummaryOptions = {
-				...summarizeOptions,
-				summaryLogger,
-				cancellationToken: this.cancellationToken,
-				latestSummaryRefSeqNum: this.heuristicData.lastSuccessfulSummary.refSequenceNumber,
-			};
-
-			// Note: no need to account for cancellationToken.waitCancelled here, as
-			// this is accounted SummaryGenerator.summarizeCore that controls receivedSummaryAckOrNack.
-			const resultSummarize = this.generator.summarize(summaryOptions);
-			const ackNackResult = await resultSummarize.receivedSummaryAckOrNack;
-			if (ackNackResult.success) {
-				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;
-			const delaySeconds = !submitResult.success
-				? submitResult.data?.retryAfterSeconds
-				: ackNackResult.data?.retryAfterSeconds;
-			if (delaySeconds === undefined || summaryAttemptsPerPhase > 1) {
-				summaryAttemptPhase++;
-				summaryAttemptsPerPhase = 0;
-			}
-
-			if (delaySeconds !== undefined) {
-				this.mc.logger.sendPerformanceEvent({
-					eventName: "SummarizeAttemptDelay",
-					duration: delaySeconds,
-					summaryNackDelay: ackNackResult.data?.retryAfterSeconds !== undefined,
-					...summarizeProps,
-				});
-				await delay(delaySeconds * 1000);
-			}
-		}
-		this.mc.logger.sendErrorEvent(
-			{
-				eventName: "SummarizeFailed",
-				maxAttempts: attemptOptions.length,
-				summaryAttempts: summaryAttemptPhase,
-			},
-			error,
-		);
-		this.stopSummarizerCallback("failToSummarize");
-	}
-
 	/**
 	 * Tries to summarize with retries where retry is based on the failure params.
 	 * For example, summarization may be retried for failures with "retryAfterSeconds" param.
@@ -773,7 +686,7 @@ export class RunningSummarizer extends TypedEventEmitter<ISummarizerEvents> impl
 		let done = false;
 		let status: "success" | "failure" | "canceled" = "success";
 		let results: ISummarizeResults | undefined;
-		let error: any;
+		let error: IRetriableFailureError | undefined;
 		do {
 			currentAttempt++;
 			if (this.cancellationToken.cancelled) {
@@ -793,22 +706,18 @@ export class RunningSummarizer extends TypedEventEmitter<ISummarizerEvents> impl
 				break;
 			}
 
-			// Update max attempts and retry params from the failure result.
-			// If submit summary failed, use the params from "summarySubmitted" result. Else, use the params
-			// from "receivedSummaryAckOrNack" result.
+			// Update max attempts from the failure result.
+			// 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;
-			if (!submitSummaryResult.success) {
-				maxAttempts = this.maxAttemptsForSubmitFailures;
-				retryAfterSeconds = submitSummaryResult.data?.retryAfterSeconds;
-			} else {
-				maxAttempts = defaultMaxAttempts;
-				retryAfterSeconds = ackNackResult.data?.retryAfterSeconds;
-			}
+			maxAttempts = !submitSummaryResult.success
+				? this.maxAttemptsForSubmitFailures
+				: defaultMaxAttempts;
 
 			// Emit "summarize" event for this failed attempt.
 			status = "failure";
 			error = ackNackResult.error;
+			retryAfterSeconds = error.retryAfterSeconds;
 			const eventProps: ISummarizeEventProps = {
 				result: status,
 				currentAttempt,
@@ -817,27 +726,26 @@ export class RunningSummarizer extends TypedEventEmitter<ISummarizerEvents> impl
 			};
 			this.emit("summarize", eventProps);
 
-			// If the failure doesn't have "retryAfterSeconds" or the max number of attempts have been done, we're done.
+			// Break if the failure doesn't have "retryAfterSeconds" or we are one less from max number of attempts.
+			// Note that the final attempt if "retryAfterSeconds" does exist happens outside of the do..while loop.
 			if (retryAfterSeconds === undefined || currentAttempt >= maxAttempts - 1) {
 				done = true;
 			}
 
-			// If the failure has "retryAfterSeconds", add a delay of that time. In this case, a final attempt will
-			// take place and we need to wait for "retryAfterSeconds" before that.
-			if (retryAfterSeconds !== undefined) {
+			// If the failure has "retryAfterSeconds", add a delay of that time before starting the next attempt.
+			if (retryAfterSeconds !== undefined && retryAfterSeconds > 0) {
 				this.mc.logger.sendPerformanceEvent({
 					eventName: "SummarizeAttemptDelay",
-					duration: retryAfterSeconds,
-					summaryNackDelay: ackNackResult.data?.retryAfterSeconds !== undefined,
+					duration: retryAfterSeconds * 1000,
+					summaryNackDelay: ackNackResult.data !== undefined, // This will only be defined only for nack failures.
 					stage: submitSummaryResult.data?.stage,
-					dynamicRetries: true, // To differentiate this telemetry from regular retry logic
 					...attemptResult.summarizeProps,
 				});
 				await delay(retryAfterSeconds * 1000);
 			}
 		} while (!done);
 
-		// If summarize attempt did not fail, emit "summarize" event and return. A failed attempt may be retried below.
+		// If the attempt was successful, emit "summarize" event and return. A failed attempt may be retried below.
 		if (status !== "failure") {
 			this.emit("summarize", { result: status, currentAttempt, maxAttempts });
 			return results;
@@ -888,7 +796,10 @@ export class RunningSummarizer extends TypedEventEmitter<ISummarizerEvents> impl
 	) {
 		const results = await this.trySummarizeWithRetries(reason);
 		if (results === undefined) {
-			resultsBuilder.fail("Summarization was canceled", undefined);
+			resultsBuilder.fail(
+				"Summarization was canceled",
+				new RetriableSummaryError("Summarization was canceled"),
+			);
 			return resultsBuilder.build();
 		}
 		const submitResult = await results.summarySubmitted;
@@ -906,7 +817,10 @@ export class RunningSummarizer extends TypedEventEmitter<ISummarizerEvents> impl
 		resultsBuilder: SummarizeResultBuilder = new SummarizeResultBuilder(),
 	): ISummarizeResults {
 		if (this.stopping) {
-			resultsBuilder.fail("RunningSummarizer stopped or disposed", undefined);
+			resultsBuilder.fail(
+				"RunningSummarizer stopped or disposed",
+				new RetriableSummaryError("RunningSummarizer stopped or disposed"),
+			);
 			return resultsBuilder.build();
 		}
 		// Check for concurrent summary attempts. If one is found,
@@ -944,7 +858,9 @@ export class RunningSummarizer extends TypedEventEmitter<ISummarizerEvents> impl
 			// Override existing enqueued summarize attempt.
 			this.enqueuedSummary.resultsBuilder.fail(
 				"Aborted; overridden by another enqueue summarize attempt",
-				undefined,
+				new RetriableSummaryError(
+					"Summary was overridden by another enqueue summarize attempt",
+				),
 			);
 			this.enqueuedSummary = undefined;
 			overridden = true;
@@ -995,7 +911,7 @@ export class RunningSummarizer extends TypedEventEmitter<ISummarizerEvents> impl
 		if (this.enqueuedSummary !== undefined) {
 			this.enqueuedSummary.resultsBuilder.fail(
 				"RunningSummarizer stopped or disposed",
-				undefined,
+				new RetriableSummaryError("RunningSummarizer stopped or disposed"),
 			);
 			this.enqueuedSummary = undefined;
 		}

package/src/summary/summarizer.ts

@@ -4,7 +4,7 @@
  */
 
 import { TypedEventEmitter } from "@fluid-internal/client-utils";
-import { IFluidHandleContext } from "@fluidframework/core-interfaces";
+import { IFluidHandleContext } from "@fluidframework/core-interfaces/internal";
 import { Deferred } from "@fluidframework/core-utils/internal";
 import {
 	IFluidErrorBase,
@@ -98,7 +98,10 @@ export class Summarizer extends TypedEventEmitter<ISummarizerEvents> implements
 		) => Promise<ICancellableSummarizerController>,
 	) {
 		super();
-		this.logger = createChildLogger({ logger: this.runtime.logger, namespace: "Summarizer" });
+		this.logger = createChildLogger({
+			logger: this.runtime.baseLogger,
+			namespace: "Summarizer",
+		});
 	}
 
 	public async run(onBehalfOf: string): Promise<SummarizerStopReason> {

package/src/summary/summarizerClientElection.ts

@@ -5,7 +5,8 @@
 
 import { TypedEventEmitter } from "@fluid-internal/client-utils";
 import { IEvent, IEventProvider } from "@fluidframework/core-interfaces";
-import { IClientDetails, MessageType } from "@fluidframework/protocol-definitions";
+import { IClientDetails } from "@fluidframework/driver-definitions";
+import { MessageType } from "@fluidframework/driver-definitions/internal";
 import { ITelemetryLoggerExt } from "@fluidframework/telemetry-utils/internal";
 
 import {

package/src/summary/summarizerNode/summarizerNode.ts

@@ -5,16 +5,11 @@
 
 import { ITelemetryBaseLogger } from "@fluidframework/core-interfaces";
 import { assert, unreachableCase } from "@fluidframework/core-utils/internal";
-import {
-	ISequencedDocumentMessage,
-	ISnapshotTree,
-	SummaryType,
-} from "@fluidframework/protocol-definitions";
+import { ISequencedDocumentMessage, SummaryType } from "@fluidframework/driver-definitions";
+import { ISnapshotTree } from "@fluidframework/driver-definitions/internal";
 import {
 	IExperimentalIncrementalSummaryContext,
 	ITelemetryContext,
-} from "@fluidframework/runtime-definitions";
-import {
 	CreateChildSummarizerNodeParam,
 	CreateSummarizerNodeSource,
 	ISummarizeResult,
@@ -167,15 +162,6 @@ export class SummarizerNode implements IRootSummarizerNode {
 		trackState: boolean = true,
 		telemetryContext?: ITelemetryContext,
 	): Promise<ISummarizeResult> {
-		assert(
-			this.isSummaryInProgress(),
-			0x1a1 /* "summarize should not be called when not tracking the summary" */,
-		);
-		assert(
-			this.wipSummaryLogger !== undefined,
-			0x1a2 /* "wipSummaryLogger should have been set in startSummary or ctor" */,
-		);
-
 		// Try to reuse the tree if unchanged
 		if (this.canReuseHandle && !fullTree && !this.hasChanged()) {
 			const latestSummary = this._latestSummary;
@@ -198,21 +184,23 @@ export class SummarizerNode implements IRootSummarizerNode {
 			}
 		}
 
-		// This assert is the same the other 0a1x1 assert `isSummaryInProgress`, the only difference is that typescript
-		// complains if this assert isn't done this way
-		assert(
-			this.wipReferenceSequenceNumber !== undefined,
-			0x5df /* Summarize should not be called when not tracking the summary */,
-		);
-		const incrementalSummaryContext: IExperimentalIncrementalSummaryContext | undefined =
-			this._latestSummary !== undefined
-				? {
-						summarySequenceNumber: this.wipReferenceSequenceNumber,
-						latestSummarySequenceNumber: this._latestSummary.referenceSequenceNumber,
-						// TODO: remove summaryPath
-						summaryPath: this._latestSummary.fullPath.path,
-				  }
-				: undefined;
+		let incrementalSummaryContext: IExperimentalIncrementalSummaryContext | undefined;
+		if (!fullTree) {
+			assert(
+				this.wipReferenceSequenceNumber !== undefined,
+				0x5df /* Summarize should not be called when not tracking the summary */,
+			);
+			incrementalSummaryContext =
+				this._latestSummary !== undefined
+					? {
+							summarySequenceNumber: this.wipReferenceSequenceNumber,
+							latestSummarySequenceNumber:
+								this._latestSummary.referenceSequenceNumber,
+							// TODO: remove summaryPath
+							summaryPath: this._latestSummary.fullPath.path,
+					  }
+					: undefined;
+		}
 
 		const result = await this.summarizeInternalFn(
 			fullTree,

package/src/summary/summarizerNode/summarizerNodeUtils.ts

@@ -3,7 +3,8 @@
  * Licensed under the MIT License.
  */
 
-import { ISnapshotTree, SummaryObject } from "@fluidframework/protocol-definitions";
+import { SummaryObject } from "@fluidframework/driver-definitions";
+import { ISnapshotTree } from "@fluidframework/driver-definitions/internal";
 import { channelsTreeName } from "@fluidframework/runtime-definitions/internal";
 import { ITelemetryLoggerExt, TelemetryDataTag } from "@fluidframework/telemetry-utils/internal";
 

package/src/summary/summarizerNode/summarizerNodeWithGc.ts

@@ -7,10 +7,8 @@ import { ITelemetryBaseLogger } from "@fluidframework/core-interfaces";
 import { assert, LazyPromise } from "@fluidframework/core-utils/internal";
 import {
 	IExperimentalIncrementalSummaryContext,
-	IGarbageCollectionData,
 	ITelemetryContext,
-} from "@fluidframework/runtime-definitions";
-import {
+	IGarbageCollectionData,
 	CreateChildSummarizerNodeParam,
 	IGarbageCollectionDetailsBase,
 	ISummarizeInternalResult,
@@ -78,15 +76,13 @@ export class SummarizerNodeWithGC extends SummarizerNode implements IRootSummari
 	private referenceUsedRoutes: string[] | undefined;
 
 	// The base GC details of this node used to initialize the GC state.
-	private readonly baseGCDetailsP: LazyPromise<IGarbageCollectionDetailsBase>;
+	private readonly baseGCDetailsP: Promise<IGarbageCollectionDetailsBase>;
 
 	// Keeps track of whether we have loaded the base details to ensure that we only do it once.
 	private baseGCDetailsLoaded: boolean = false;
 
 	// The base GC details for the child nodes. This is passed to child nodes when creating them.
-	private readonly childNodesBaseGCDetailsP: LazyPromise<
-		Map<string, IGarbageCollectionDetailsBase>
-	>;
+	private readonly childNodesBaseGCDetailsP: Promise<Map<string, IGarbageCollectionDetailsBase>>;
 
 	private gcData: IGarbageCollectionData | undefined;
 
@@ -517,7 +513,7 @@ export class SummarizerNodeWithGC extends SummarizerNode implements IRootSummari
 	 * was previously used and became unused (or vice versa), its used state has changed.
 	 */
 	private hasUsedStateChanged(): boolean {
-		// If GC is disabled, we are not tracking used state, return false.
+		// If GC is disabled, it should not affect summary state, return false.
 		if (this.gcDisabled) {
 			return false;
 		}