@fluidframework/container-runtime 2.0.0-dev-rc.5.0.0.265721 → 2.0.0-dev-rc.5.0.0.268409

package/src/opLifecycle/opSplitter.ts

@@ -6,7 +6,7 @@
 import { IBatchMessage } from "@fluidframework/container-definitions/internal";
 import { ITelemetryBaseLogger } from "@fluidframework/core-interfaces";
 import { assert } from "@fluidframework/core-utils/internal";
-import { ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
+import { ISequencedDocumentMessage } from "@fluidframework/driver-definitions";
 import {
 	DataCorruptionError,
 	createChildLogger,
@@ -111,8 +111,10 @@ export class OpSplitter {
 	 * To illustrate, if the input is `[largeOp, emptyOp, emptyOp]`, `largeOp` will be split into `[chunk1, chunk2, chunk3, chunk4]`.
 	 * `chunk1`, `chunk2` and `chunk3` will be sent individually and `[chunk4, emptyOp, emptyOp]` will be returned.
 	 *
+	 * @remarks - A side effect here is that 1 or more chunks are queued immediately for sending in next JS turn.
+	 *
 	 * @param batch - the compressed batch which needs to be processed
-	 * @returns A new adjusted batch which can be sent over the wire
+	 * @returns A new adjusted batch (last chunk + empty placeholders) which can be sent over the wire
 	 */
 	public splitFirstBatchMessage(batch: IBatch): IBatch {
 		assert(this.isBatchChunkingEnabled, 0x513 /* Chunking needs to be enabled */);
@@ -203,16 +205,19 @@ export class OpSplitter {
 		const serializedContent = this.chunkMap.get(clientId)!.join("");
 		this.clearPartialChunks(clientId);
 
-		const newMessage = { ...message };
-		newMessage.contents = serializedContent === "" ? undefined : JSON.parse(serializedContent);
+		// The final/complete message will contain the data from all the chunks.
+		// It will have the sequenceNumber of the last chunk
+		const completeMessage = { ...message };
+		completeMessage.contents =
+			serializedContent === "" ? undefined : JSON.parse(serializedContent);
 		// back-compat with 1.x builds
 		// This is only required / present for non-compressed, chunked ops
 		// For compressed ops, we have op grouping enabled, and type of each op is preserved within compressed content.
-		newMessage.type = (chunkedContent as any).originalType;
-		newMessage.metadata = chunkedContent.originalMetadata;
-		newMessage.compression = chunkedContent.originalCompression;
+		completeMessage.type = (chunkedContent as any).originalType;
+		completeMessage.metadata = chunkedContent.originalMetadata;
+		completeMessage.compression = chunkedContent.originalCompression;
 		return {
-			message: newMessage,
+			message: completeMessage,
 			isFinalChunk: true,
 		};
 	}

package/src/opLifecycle/outbox.ts

@@ -254,7 +254,7 @@ export class Outbox {
 			return;
 		}
 
-		// Did we disconnect?
+		// Did we disconnect? (i.e. is shouldSend false?)
 		// If so, do nothing, as pending state manager will resubmit it correctly on reconnect.
 		// Because flush() is a task that executes async (on clean stack), we can get here in disconnected state.
 		if (this.params.shouldSend()) {
@@ -307,6 +307,15 @@ export class Outbox {
 		return this.params.opReentrancy() && !this.rebasing;
 	}
 
+	/**
+	 * As necessary and enabled, compresses and chunks the given batch.
+	 *
+	 * @remarks - If chunking happens, a side effect here is that 1 or more chunks are queued immediately for sending in next JS turn.
+	 *
+	 * @param batch - Raw or Grouped batch to consider for compression/chunking
+	 * @returns Either (A) the original batch, (B) a compressed batch (same length as original),
+	 * or (C) a batch containing the last chunk (plus empty placeholders from compression if applicable).
+	 */
 	private compressBatch(batch: IBatch): IBatch {
 		if (
 			batch.content.length === 0 ||

package/src/opLifecycle/remoteMessageProcessor.ts

@@ -3,7 +3,8 @@
  * Licensed under the MIT License.
  */
 
-import { ISequencedDocumentMessage, MessageType } from "@fluidframework/protocol-definitions";
+import { ISequencedDocumentMessage } from "@fluidframework/driver-definitions";
+import { MessageType } from "@fluidframework/driver-definitions/internal";
 
 import {
 	ContainerMessageType,

package/src/opProperties.ts

@@ -3,10 +3,8 @@
  * Licensed under the MIT License.
  */
 
-import {
-	ISequencedDocumentMessage,
-	ISequencedDocumentSystemMessage,
-} from "@fluidframework/protocol-definitions";
+import { ISequencedDocumentMessage } from "@fluidframework/driver-definitions";
+import { ISequencedDocumentSystemMessage } from "@fluidframework/driver-definitions/internal";
 
 export const opSize = (op: ISequencedDocumentMessage): number => {
 	// Some messages may already have string contents,

package/src/packageVersion.ts

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

package/src/pendingStateManager.ts

@@ -6,7 +6,7 @@
 import { ICriticalContainerError } from "@fluidframework/container-definitions";
 import { IDisposable } from "@fluidframework/core-interfaces";
 import { assert, Lazy } from "@fluidframework/core-utils/internal";
-import { ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
+import { ISequencedDocumentMessage } from "@fluidframework/driver-definitions";
 import {
 	ITelemetryLoggerExt,
 	DataProcessingError,

package/src/scheduleManager.ts

@@ -7,8 +7,9 @@ import type { EventEmitter } from "@fluid-internal/client-utils";
 import { performance } from "@fluid-internal/client-utils";
 import { IDeltaManager } from "@fluidframework/container-definitions/internal";
 import { assert } from "@fluidframework/core-utils/internal";
+import { ISequencedDocumentMessage } from "@fluidframework/driver-definitions";
+import { IDocumentMessage } from "@fluidframework/driver-definitions/internal";
 import { isRuntimeMessage } from "@fluidframework/driver-utils/internal";
-import { IDocumentMessage, ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
 import {
 	ITelemetryLoggerExt,
 	DataCorruptionError,

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,

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,

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,11 +5,8 @@
 
 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,
@@ -165,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;
@@ -196,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

@@ -76,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;
 
@@ -515,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;
 		}

package/src/summary/summarizerTypes.ts

@@ -10,11 +10,8 @@ import {
 	ITelemetryBaseProperties,
 	ITelemetryBaseLogger,
 } from "@fluidframework/core-interfaces";
-import {
-	IDocumentMessage,
-	ISequencedDocumentMessage,
-	ISummaryTree,
-} from "@fluidframework/protocol-definitions";
+import { ISequencedDocumentMessage, ISummaryTree } from "@fluidframework/driver-definitions";
+import { IDocumentMessage } from "@fluidframework/driver-definitions/internal";
 import { ISummaryStats } from "@fluidframework/runtime-definitions/internal";
 import {
 	ITelemetryLoggerExt,
@@ -214,8 +211,6 @@ export interface IGenerateSummaryTreeResult extends Omit<IBaseSummarizeResult, "
 	readonly summaryStats: IGeneratedSummaryStats;
 	/** Time it took to generate the summary tree and stats. */
 	readonly generateDuration: number;
-	/** True if the full tree regeneration with no handle reuse optimizations was forced. */
-	readonly forcedFullTree: boolean;
 }
 
 /**

package/src/summary/summaryCollection.ts

@@ -7,14 +7,14 @@ import { TypedEventEmitter } from "@fluid-internal/client-utils";
 import { IDeltaManager } from "@fluidframework/container-definitions/internal";
 import { IDisposable, IEvent } from "@fluidframework/core-interfaces";
 import { assert, Deferred } from "@fluidframework/core-utils/internal";
+import { ISequencedDocumentMessage } from "@fluidframework/driver-definitions";
 import {
 	IDocumentMessage,
-	ISequencedDocumentMessage,
 	ISummaryAck,
 	ISummaryContent,
 	ISummaryNack,
 	MessageType,
-} from "@fluidframework/protocol-definitions";
+} from "@fluidframework/driver-definitions/internal";
 import { ITelemetryLoggerExt } from "@fluidframework/telemetry-utils/internal";
 
 /**

package/src/summary/summaryFormat.ts

@@ -4,16 +4,15 @@
  */
 
 import { assert } from "@fluidframework/core-utils/internal";
-import { IDocumentStorageService } from "@fluidframework/driver-definitions/internal";
+import { ISequencedDocumentMessage, SummaryType } from "@fluidframework/driver-definitions";
+import {
+	IDocumentStorageService,
+	ISnapshotTree,
+} from "@fluidframework/driver-definitions/internal";
 import {
 	blobHeadersBlobName as blobNameForBlobHeaders,
 	readAndParse,
 } from "@fluidframework/driver-utils/internal";
-import {
-	ISequencedDocumentMessage,
-	ISnapshotTree,
-	SummaryType,
-} from "@fluidframework/protocol-definitions";
 import {
 	ISummaryTreeWithStats,
 	channelsTreeName,

package/src/summary/summaryFormats.md

@@ -0,0 +1,160 @@
+# Summary and snapshot formats
+
+## Table of contents
+
+-   [Introduction](#introduction)
+-   [Summary Format](#summary-format)
+-   [Snapshot Format](#snapshot-format)
+-   [Summary / Snapshot Tree Visualization](#summary--snapshot-tree-visualization)
+    -   [Protocol Tree](#protocol-tree)
+    -   [App Tree](#app-tree)
+    -   [Summary Tree distinction](#summary-tree-distinction)
+
+## Introduction
+
+This document describes the format of summaries and snapshots. For learning the differences between summaries and snapshots, see the FAQ section [here](https://fluidframework.com/docs/faq/#whats-the-difference-between-a-summary-and-a-snapshot).
+
+The goal of this document is to describe the fundamental structure of a summary / snapshot tree as produced by the runtime, to explain the various node types within the tree along with their respective data, and to show the distinctions between a summary tree and a snapshot tree.
+
+## Summary Format
+
+Summary is uploaded to storage and is the container's state at a point in time. A summary is represented by an `ISummaryTree` which is defined in [this file](../../../../../common/lib/protocol-definitions/src/summary.ts) and has the following basic structure (some optional properties are removed for simplicity):
+
+```typescript
+export interface ISummaryTree {
+	type: SummaryType.Tree;
+	tree: { [path: string]: SummaryObject };
+}
+export type SummaryType =
+	| SummaryType.Attachment
+	| SummaryType.Blob
+	| SummaryType.Handle
+	| SummaryType.Tree;
+export type SummaryObject = ISummaryTree | ISummaryBlob | ISummaryHandle | ISummaryAttachment;
+```
+
+Each tree node in a summary tree is represented by the `ISummaryTree` interface above and contains the following:
+
+-   `type` - `SummaryType.Tree`
+-   `tree` - A list of children of the tree node. Each child node has the following format:
+
+    `<tree name>`: `<SummaryObject>` where `tree name` is the name given to the child node and `SummaryObject` is one of the following:
+
+    -   `ISummaryTree` - A subtree which has the same structure as this node. For example, container runtime will have subtrees for its data store which in turn will have subtrees for its DDSes.
+
+    -   `ISummaryBlob` - A blob that has some content for this node. For example, a DDS's node has a ".attributes" blob for its attributes such as type, snapshot versions, etc. It may have additional blobs for the actual user content in the DDS.
+
+        ```typescript
+        export interface ISummaryBlob {
+        	type: SummaryType.Blob;
+        	content: string | Uint8Array;
+        }
+        ```
+
+    -   `ISummaryAttachment` - This is used for attachment blobs that are uploaded to and downloaded from storage directly. The contents of these blobs are not part of the summary. Storage returns an ID after the attachment has been uploaded and this ID is included in the summary attachment. For example, a DDS can upload some of its large content directly to storage and include its ID in the summary.
+
+        ```typescript
+        export interface ISummaryAttachment {
+        	type: SummaryType.Attachment;
+        	id: string;
+        }
+        ```
+
+    -   `ISummaryHandle` - A summary handle is used for incremental summaries. If a node hasn't changed since the last successful summary, instead of sending it's entire contents, it can send a "handle" which is a path to its summary tree object in the last summary. For example, if a data store or DDS did not change since the last summary, the runtime will use a handle for the entire data store instead of re-sending the entire subtree. The same concept applies for a summary blob or a summary attachment and the "handleType" should be set according to the type of the node. An example of "handle" that a DDS sends would be something like: "/_dataStoreId_/_ddsId_".
+
+            ```typescript
+            export interface ISummaryHandle {
+            	type: SummaryType.Handle;
+            	handleType: SummaryTypeNoHandle;
+            	handle: string;
+            }
+            export type SummaryTypeNoHandle =
+            	| SummaryType.Tree
+            	| SummaryType.Blob
+            	| SummaryType.Attachment;
+            ```
+
+## Snapshot Format
+
+Snapshot is downloaded from the storage (typically on document load) and is the container's state at a point in time. A snapshot is represented by an `ISnapshotTree` which is defined in [this file](../../../../../common/lib/protocol-definitions/src/storage.ts) and has the following basic structure (some optional properties are removed for simplicity):
+
+```typescript
+export interface ISnapshotTree {
+	blobs: { [path: string]: string };
+	trees: { [path: string]: ISnapshotTree };
+}
+```
+
+Each node in a snapshot tree is represented by the above interface and contains the following:
+
+-   `blobs` - A list of blobs that have the contents for the node. For example, a DDS's node has a ".attributes" blob for its attributes such as type, snapshot versions, etc. It may have additional blobs for the actual user content in the DDS. Each blob in the list has the following format:
+
+    `<blob name>`: `<unique blob id>` where `blob name` is the name given to the blob by the node and `unique blob id` is the id that uniquely represents the blob's content in storage.
+
+    When a node needs the content of a blob, it fetches it from storage by calling `readBlob` and providing the `unique blob id`.
+
+    > Note: Summary attachments (described in summary format) are also part of this list.
+
+-   `trees` - A list of subtrees of the node. For example, container runtime will have subtrees for its data store which in turn will have subtrees for its DDSes. Each subtree in the list has the following format:
+
+    `<tree name>`: `<snapshot tree>` where `tree name` is the name given to the subtree by the node and `snapshot tree` is its content in `ISnapshotTree` format.
+
+## Summary / Snapshot Tree Visualization
+
+This section shows what a typical summary or snapshot tree in a container looks like. Some key things to note:
+
+-   The diagrams in this section show some examples of existing blobs / trees that are added at each node and doesn't show an exhaustive list.
+-   The blue boxes represent tree nodes.
+-   The green boxes represent blobs.
+-   The purple boxes represent attachments.
+-   The orange boxes represent other nodes - either existing nodes that are not shown or new nodes that may be added in the future. A node can be a tree, blob or attachment.
+
+A typical tree uploaded to or downloaded from storage looks like the following:
+![ProtocolAndAppTree](./images/protocolAndAppTree.png)
+
+`Protocol tree` - This is the tree named `.protocol` and contains protocol level information for the container. These are used by the container to initialize.
+
+`App tree` - This is the tree named `.app` and contains the container's state and data. The subtree under .app is what is generated by the container runtime.
+
+### Protocol tree
+
+The contents of the protocol tree are:
+
+-   `attributes blob` - Attributes such as the sequence number the summary was taken at.
+-   `quorum members blob` - The members in the quorum at the time summary was taken.
+-   `quorum proposals blob` - The quorum proposals at the time summary was taken.
+-   `quorum values blob` - The quorum values at the time summary was taken.
+-   Other blobs and trees may be added at this level as needed.
+
+### App tree
+
+This is what the ".app" tree looks like which is generated by the container runtime during summary upload. The same is passed to container runtime during snapshot download:
+![appTree](./images/appTree.png)
+
+-   `Container`: The root represents the container or container runtime node. Its contents are described below:
+
+    -   `.metadata blob` - The container level metadata such as creation time, create version, etc.
+    -   `.aliases blob` - The list of aliases for data stores and the corresponding internal id.
+    -   `.idCompressor blob` - The data for the ID compressor.
+    -   `.blobs tree` - The snapshot for the attachment blobs added by the blob manager. The individual attachment blobs are present as summary attachments (`ISummaryAttachment`).
+    -   `gc tree` - The snapshot for garbage collection added by the garbage collector.
+    -   `.channels tree` - The subtrees for all the data stores.
+    -   There may be other blobs and trees added at this level as needed.
+
+-   `Data store`: Data store snapshot trees are under ".channels" subtree of container runtime's tree. Its contents are described below:
+
+    -   `.component blob` - The attributes for a data store such as the package name, snapshot version, etc.
+    -   `.channels tree` - The subtrees for all its DDSs.
+    -   There may be other blobs and trees added at this level as needed.
+
+-   `DDS`: DDS snapshot trees are under ".channels" subtree of its parent data store's tree. Its contents are described below:
+    -   `.attributes blob` - The attributes for a DDS such as the type, snapshot version, etc.
+    -   `.header blob` - Added by some DDSs and may contains its data. Note that all DDSs may not add this.
+    -   A DDS may add other blobs and / or trees to represent its data. Basically, a DDS can write its data in any form
+
+### Summary tree distinction
+
+In the visualization above, a summary tree differs from a snapshot tree in the following way:
+A summary tree supports incremental summaries via summary handles. Any node in the tree that has not changed since the previous successful summary can send a summary handle (`ISummaryHandle`) instead of sending its entire contents in a full summary. The following diagram shows this with an example where certain parts of the summary tree use a summary handle. It is a zoomed in version of the same app tree as above where nodes where summary handles are marked in red:
+
+![summaryTree](./images/summaryTree.png)

package/src/summary/summaryGenerator.ts

@@ -11,9 +11,8 @@ import {
 	IPromiseTimerResult,
 	Timer,
 } from "@fluidframework/core-utils/internal";
-import { DriverErrorTypes } from "@fluidframework/driver-definitions/internal";
+import { DriverErrorTypes, MessageType } from "@fluidframework/driver-definitions/internal";
 import { getRetryDelaySecondsFromError } from "@fluidframework/driver-utils/internal";
-import { MessageType } from "@fluidframework/protocol-definitions";
 import {
 	isFluidError,
 	ITelemetryLoggerExt,
@@ -347,7 +346,7 @@ export class SummaryGenerator {
 			 * state change of multiple data stores. So, the total number of data stores that are summarized should not
 			 * exceed the number of ops since last summary + number of data store whose reference state changed.
 			 */
-			if (!submitSummaryOptions.fullTree && !summaryData.forcedFullTree) {
+			if (!submitSummaryOptions.fullTree) {
 				const { summarizedDataStoreCount, gcStateUpdatedDataStoreCount = 0 } =
 					summaryData.summaryStats;
 				if (