@fluidframework/container-runtime 2.0.0-dev-rc.1.0.0.228517 → 2.0.0-dev-rc.1.0.0.232845

package/src/gc/gcDefinitions.ts

@@ -76,6 +76,8 @@ export const disableDatastoreSweepKey = "Fluid.GarbageCollection.DisableDataStor
 export const disableAttachmentBlobSweepKey = "Fluid.GarbageCollection.DisableAttachmentBlobSweep";
 /** Config key to revert new paradigm of detecting outbound routes in ContainerRuntime layer (use true) */
 export const detectOutboundRoutesViaDDSKey = "Fluid.GarbageCollection.DetectOutboundRoutesViaDDS";
+/** Config key to disable auto-recovery mechanism that protects Tombstones that are loaded from being swept (use true) */
+export const disableAutoRecoveryKey = "Fluid.GarbageCollection.DisableAutoRecovery";
 
 // One day in milliseconds.
 export const oneDayMs = 1 * 24 * 60 * 60 * 1000;
@@ -253,6 +255,8 @@ export type GCNodeType = (typeof GCNodeType)[keyof typeof GCNodeType];
 export const GarbageCollectionMessageType = {
 	/** Message sent directing GC to delete the given nodes */
 	Sweep: "Sweep",
+	/** Message sent notifying GC that a Tombstoned object was Loaded */
+	TombstoneLoaded: "TombstoneLoaded",
 } as const;
 
 /**
@@ -266,16 +270,28 @@ export type GarbageCollectionMessageType =
  * @internal
  */
 export interface ISweepMessage {
-	type: "Sweep";
-	// The ids of nodes that are deleted.
+	/** @see GarbageCollectionMessageType.Sweep */
+	type: typeof GarbageCollectionMessageType.Sweep;
+	/** The ids of nodes that are deleted. */
 	deletedNodeIds: string[];
 }
 
+/**
+ * The GC TombstoneLoaded message.
+ * @internal
+ */
+export interface ITombstoneLoadedMessage {
+	/** @see GarbageCollectionMessageType.TombstoneLoaded */
+	type: typeof GarbageCollectionMessageType.TombstoneLoaded;
+	/** The id of Tombstoned node that was loaded. */
+	nodePath: string;
+}
+
 /**
  * Type for a message to be used for sending / received garbage collection messages.
  * @internal
  */
-export type GarbageCollectionMessage = ISweepMessage;
+export type GarbageCollectionMessage = ISweepMessage | ITombstoneLoadedMessage;
 
 /**
  * Defines the APIs for the runtime object to be passed to the garbage collector.

package/src/gc/gcTelemetry.ts

@@ -63,6 +63,7 @@ interface INodeUsageProps extends ICommonProps {
 	currentReferenceTimestampMs: number | undefined;
 	packagePath: readonly string[] | undefined;
 	fromId?: string;
+	autorecovery?: true;
 }
 
 /**
@@ -189,8 +190,6 @@ export class GCTelemetryTracker {
 		};
 
 		// If the node that is used is tombstoned, log a tombstone telemetry.
-		// Note that this is done before checking if "nodeStateTracker" is undefined below because unreferenced
-		// tracking may not have yet been enabled. That happens only after the client transitions to write mode.
 		if (nodeUsageProps.isTombstoned) {
 			this.logTombstoneUsageTelemetry(nodeUsageProps, unrefEventProps, nodeType, usageType);
 		}

package/src/gc/gcUnreferencedStateTracker.ts

@@ -25,6 +25,17 @@ class TimerWithNoDefaultTimeout extends Timer {
 	}
 }
 
+/** 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(key: string): boolean {
+		// Stop tracking so as to clear out any running timers.
+		this.get(key)?.stopTracking();
+		// Delete the node as we don't need to track it any more.
+		return super.delete(key);
+	}
+}
+
 /**
  * Helper class that tracks the state of an unreferenced node such as the time it was unreferenced and if it can
  * be tombstoned or deleted by the sweep phase.

package/src/gc/index.ts

@@ -33,6 +33,7 @@ export {
 	runSweepKey,
 	stableGCVersion,
 	disableAttachmentBlobSweepKey,
+	disableAutoRecoveryKey,
 	disableDatastoreSweepKey,
 	detectOutboundRoutesViaDDSKey,
 	UnreferencedState,

package/src/index.ts

@@ -30,9 +30,11 @@ export {
 	IContainerRuntimeMessageCompatDetails,
 	CompatModeBehavior,
 	RecentlyAddedContainerRuntimeMessageDetails,
+	UnknownContainerRuntimeMessage,
 } from "./messageTypes";
 export { IBlobManagerLoadInfo } from "./blobManager";
 export { FluidDataStoreRegistry } from "./dataStoreRegistry";
+export { detectOutboundReferences } from "./dataStores";
 export {
 	GCNodeType,
 	IGCMetadata,

package/src/messageTypes.ts

@@ -133,7 +133,7 @@ export type ContainerRuntimeGCMessage = TypedContainerRuntimeMessage<
 >;
 
 /**
- * Represents an unrecognized {@link TypedContainerRuntimeMessage}, e.g. a message from a future version of the container runtime.
+ * Represents an unrecognized TypedContainerRuntimeMessage, e.g. a message from a future version of the container runtime.
  * @internal
  */
 export interface UnknownContainerRuntimeMessage

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/container-runtime";
-export const pkgVersion = "2.0.0-dev-rc.1.0.0.228517";
+export const pkgVersion = "2.0.0-dev-rc.1.0.0.232845";

package/src/summary/runningSummarizer.ts

@@ -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,
@@ -272,94 +283,77 @@ 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 () =>
+				this.refreshLatestSummaryAckCallback({
 					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 () =>
-					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,
-						);
-					}),
-				() => {},
-			);
-			refSequenceNumber++;
-		}
-		return refSequenceNumber;
+					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,
+					);
+				}),
+			() => {},
+		);
 	}
 
 	/**
-	 * 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;
 		}
 	}
 
@@ -574,7 +568,17 @@ export class RunningSummarizer extends TypedEventEmitter<ISummarizerEvents> impl
 				};
 				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 +631,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;
@@ -665,6 +670,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 +693,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");
 	}
 
@@ -736,6 +751,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 +786,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 +828,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 +843,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/summarizerNode/summarizerNode.ts

@@ -8,7 +8,6 @@ import {
 	ISummarizerNode,
 	ISummarizerNodeConfig,
 	ISummarizeResult,
-	ISummaryTreeWithStats,
 	CreateChildSummarizerNodeParam,
 	CreateSummarizerNodeSource,
 	SummarizeInternalFn,
@@ -19,7 +18,6 @@ import {
 	ISequencedDocumentMessage,
 	SummaryType,
 	ISnapshotTree,
-	SummaryObject,
 } from "@fluidframework/protocol-definitions";
 import {
 	ITelemetryLoggerExt,
@@ -30,15 +28,13 @@ import {
 	tagCodeArtifacts,
 } from "@fluidframework/telemetry-utils";
 import { assert, unreachableCase } from "@fluidframework/core-utils";
-import { convertToSummaryTree, calculateStats, mergeStats } from "@fluidframework/runtime-utils";
+import { mergeStats } from "@fluidframework/runtime-utils";
 import {
 	EscapedPath,
 	ICreateChildDetails,
-	IInitialSummary,
 	IRefreshSummaryResult,
 	ISummarizerNodeRootContract,
 	parseSummaryForSubtrees,
-	parseSummaryTreeForSubtrees,
 	SummaryNode,
 	ValidateSummaryResult,
 } from "./summarizerNodeUtils";
@@ -86,7 +82,6 @@ export class SummarizerNode implements IRootSummarizerNode {
 		private _changeSequenceNumber: number,
 		/** Undefined means created without summary */
 		private _latestSummary?: SummaryNode,
-		private readonly initialSummary?: IInitialSummary,
 		protected wipSummaryLogger?: ITelemetryBaseLogger,
 		/** A unique id of this node to be logged when sending telemetry. */
 		protected telemetryNodeId?: string,
@@ -521,7 +516,6 @@ export class SummarizerNode implements IRootSummarizerNode {
 			config,
 			createDetails.changeSequenceNumber,
 			createDetails.latestSummary,
-			createDetails.initialSummary,
 			this.wipSummaryLogger,
 			createDetails.telemetryNodeId,
 		);
@@ -549,7 +543,6 @@ export class SummarizerNode implements IRootSummarizerNode {
 		id: string,
 		createParam: CreateChildSummarizerNodeParam,
 	): ICreateChildDetails {
-		let initialSummary: IInitialSummary | undefined;
 		let latestSummary: SummaryNode | undefined;
 		let changeSequenceNumber: number;
 
@@ -562,63 +555,12 @@ export class SummarizerNode implements IRootSummarizerNode {
 				) {
 					// Prioritize latest summary if it was after this node was attached.
 					latestSummary = parentLatestSummary.createForChild(id);
-				} else {
-					const summary = convertToSummaryTree(
-						createParam.snapshot,
-					) as ISummaryTreeWithStats;
-					initialSummary = {
-						sequenceNumber: createParam.sequenceNumber,
-						id,
-						summary,
-					};
 				}
 				changeSequenceNumber = createParam.sequenceNumber;
 				break;
 			}
-			case CreateSummarizerNodeSource.FromSummary: {
-				if (this.initialSummary === undefined) {
-					assert(
-						!!parentLatestSummary,
-						0x1ac /* "Cannot create child from summary if parent does not have latest summary" */,
-					);
-				}
-				// fallthrough to local
-			}
+			case CreateSummarizerNodeSource.FromSummary:
 			case CreateSummarizerNodeSource.Local: {
-				const parentInitialSummary = this.initialSummary;
-				if (parentInitialSummary !== undefined) {
-					let childSummary: SummaryObject | undefined;
-					if (parentInitialSummary.summary !== undefined) {
-						const { childrenTree } = parseSummaryTreeForSubtrees(
-							parentInitialSummary.summary.summary,
-						);
-						assert(
-							childrenTree.type === SummaryType.Tree,
-							0x1d6 /* "Parent summary object is not a tree" */,
-						);
-						childSummary = childrenTree.tree[id];
-					}
-					if (createParam.type === CreateSummarizerNodeSource.FromSummary) {
-						// Locally created would not have differential subtree.
-						assert(!!childSummary, 0x1ad /* "Missing child summary tree" */);
-					}
-					let childSummaryWithStats: ISummaryTreeWithStats | undefined;
-					if (childSummary !== undefined) {
-						assert(
-							childSummary.type === SummaryType.Tree,
-							0x1ae /* "Child summary object is not a tree" */,
-						);
-						childSummaryWithStats = {
-							summary: childSummary,
-							stats: calculateStats(childSummary),
-						};
-					}
-					initialSummary = {
-						sequenceNumber: parentInitialSummary.sequenceNumber,
-						id,
-						summary: childSummaryWithStats,
-					};
-				}
 				latestSummary = parentLatestSummary?.createForChild(id);
 				changeSequenceNumber = parentLatestSummary?.referenceSequenceNumber ?? -1;
 				break;
@@ -629,13 +571,12 @@ export class SummarizerNode implements IRootSummarizerNode {
 			}
 		}
 
-		const childtelemetryNodeId = `${this.telemetryNodeId ?? ""}/${id}`;
+		const childTelemetryNodeId = `${this.telemetryNodeId ?? ""}/${id}`;
 
 		return {
-			initialSummary,
 			latestSummary,
 			changeSequenceNumber,
-			telemetryNodeId: childtelemetryNodeId,
+			telemetryNodeId: childTelemetryNodeId,
 		};
 	}
 
@@ -719,7 +660,6 @@ export const createRootSummarizerNode = (
 		referenceSequenceNumber === undefined
 			? undefined
 			: SummaryNode.createForRoot(referenceSequenceNumber),
-		undefined /* initialSummary */,
 		undefined /* wipSummaryLogger */,
 		"" /* telemetryNodeId */,
 	);

package/src/summary/summarizerNode/summarizerNodeUtils.ts

@@ -4,8 +4,8 @@
  */
 
 import { ITelemetryLoggerExt, TelemetryDataTag } from "@fluidframework/telemetry-utils";
-import { ISnapshotTree, ISummaryTree, SummaryObject } from "@fluidframework/protocol-definitions";
-import { channelsTreeName, ISummaryTreeWithStats } from "@fluidframework/runtime-definitions";
+import { ISnapshotTree, SummaryObject } from "@fluidframework/protocol-definitions";
+import { channelsTreeName } from "@fluidframework/runtime-definitions";
 
 export interface IRefreshSummaryResult {
 	/** Tells whether this summary is tracked by this client. */
@@ -135,21 +135,10 @@ export class SummaryNode {
 	}
 }
 
-/**
- * Information about the initial summary tree found from an attach op.
- */
-export interface IInitialSummary {
-	sequenceNumber: number;
-	id: string;
-	summary: ISummaryTreeWithStats | undefined;
-}
-
 /**
  * Represents the details needed to create a child summarizer node.
  */
 export interface ICreateChildDetails {
-	/** Summary from attach op if known */
-	initialSummary: IInitialSummary | undefined;
 	/** Latest summary from server node data */
 	latestSummary: SummaryNode | undefined;
 	/** Sequence number of latest known change to the node */
@@ -184,23 +173,3 @@ export function parseSummaryForSubtrees(baseSummary: ISnapshotTree): ISubtreeInf
 		childrenPathPart: undefined,
 	};
 }
-
-/**
- * Checks if the summary contains .channels subtree where the children subtrees
- * would be located if exists.
- * @param baseSummary - summary to check
- */
-export function parseSummaryTreeForSubtrees(summary: ISummaryTree): ISubtreeInfo<SummaryObject> {
-	// New versions of snapshots have child nodes isolated in .channels subtree
-	const channelsSubtree = summary.tree[channelsTreeName];
-	if (channelsSubtree !== undefined) {
-		return {
-			childrenTree: channelsSubtree,
-			childrenPathPart: channelsTreeName,
-		};
-	}
-	return {
-		childrenTree: summary,
-		childrenPathPart: undefined,
-	};
-}

package/src/summary/summarizerNode/summarizerNodeWithGc.ts

@@ -29,7 +29,6 @@ import { SummarizerNode } from "./summarizerNode";
 import {
 	EscapedPath,
 	ICreateChildDetails,
-	IInitialSummary,
 	ISummarizerNodeRootContract,
 	SummaryNode,
 	ValidateSummaryResult,
@@ -111,7 +110,6 @@ export class SummarizerNodeWithGC extends SummarizerNode implements IRootSummari
 		changeSequenceNumber: number,
 		/** Undefined means created without summary */
 		latestSummary?: SummaryNode,
-		initialSummary?: IInitialSummary,
 		wipSummaryLogger?: ITelemetryBaseLogger,
 		private readonly getGCDataFn?: (fullGC?: boolean) => Promise<IGarbageCollectionData>,
 		getBaseGCDetailsFn?: () => Promise<IGarbageCollectionDetailsBase>,
@@ -135,7 +133,6 @@ export class SummarizerNodeWithGC extends SummarizerNode implements IRootSummari
 			config,
 			changeSequenceNumber,
 			latestSummary,
-			initialSummary,
 			wipSummaryLogger,
 			telemetryId,
 		);
@@ -398,7 +395,6 @@ export class SummarizerNodeWithGC extends SummarizerNode implements IRootSummari
 		createParam: CreateChildSummarizerNodeParam,
 		config: ISummarizerNodeConfigWithGC = {},
 		getGCDataFn?: (fullGC?: boolean) => Promise<IGarbageCollectionData>,
-		getBaseGCDetailsFn?: () => Promise<IGarbageCollectionDetailsBase>,
 	): ISummarizerNodeWithGC {
 		assert(!this.children.has(id), 0x1b6 /* "Create SummarizerNode child already exists" */);
 		/**
@@ -423,7 +419,6 @@ export class SummarizerNodeWithGC extends SummarizerNode implements IRootSummari
 			},
 			createDetails.changeSequenceNumber,
 			createDetails.latestSummary,
-			createDetails.initialSummary,
 			this.wipSummaryLogger,
 			getGCDataFn,
 			getChildBaseGCDetailsFn,
@@ -563,7 +558,6 @@ export const createRootSummarizerNodeWithGC = (
 		referenceSequenceNumber === undefined
 			? undefined
 			: SummaryNode.createForRoot(referenceSequenceNumber),
-		undefined /* initialSummary */,
 		undefined /* wipSummaryLogger */,
 		getGCDataFn,
 		getBaseGCDetailsFn,

package/src/summary/summarizerTypes.ts

@@ -377,7 +377,7 @@ export type EnqueueSummarizeResult =
  * @alpha
  */
 export type SummarizerStopReason =
-	/** Summarizer client failed to summarize in all 3 consecutive attempts. */
+	/** Summarizer client failed to summarize in all attempts. */
 	| "failToSummarize"
 	/** Parent client reported that it is no longer connected. */
 	| "parentNotConnected"