@fluidframework/container-runtime 2.1.0-276326 → 2.1.0-276985

package/src/{blobManager.ts → blobManager/blobManager.ts}

@@ -21,7 +21,6 @@ import { assert, Deferred } from "@fluidframework/core-utils/internal";
 import {
 	IDocumentStorageService,
 	ICreateBlobResponse,
-	ISnapshotTree,
 	ISequencedDocumentMessage,
 } from "@fluidframework/driver-definitions/internal";
 import { canRetryOnError, runWithRetry } from "@fluidframework/driver-utils/internal";
@@ -32,7 +31,6 @@ import {
 } from "@fluidframework/runtime-definitions/internal";
 import {
 	FluidHandleBase,
-	SummaryTreeBuilder,
 	createResponseError,
 	generateHandleContextPath,
 	responseToException,
@@ -47,7 +45,14 @@ import {
 } from "@fluidframework/telemetry-utils/internal";
 import { v4 as uuid } from "uuid";
 
-import { IBlobMetadata } from "./metadata.js";
+import { IBlobMetadata } from "../metadata.js";
+
+import {
+	getStorageIds,
+	summarizeBlobManagerState,
+	toRedirectTable,
+	type IBlobManagerLoadInfo,
+} from "./blobManagerSnapSum.js";
 
 /**
  * This class represents blob (long string)
@@ -87,16 +92,6 @@ export class BlobHandle extends FluidHandleBase<ArrayBufferLike> {
 	}
 }
 
-/**
- * Information from a snapshot needed to load BlobManager
- * @legacy
- * @alpha
- */
-export interface IBlobManagerLoadInfo {
-	ids?: string[];
-	redirectTable?: [string, string][];
-}
-
 // Restrict the IContainerRuntime interface to the subset required by BlobManager.  This helps to make
 // the contract explicit and reduces the amount of mocking required for tests.
 export type IBlobManagerRuntime = Pick<
@@ -146,9 +141,9 @@ const stashedPendingBlobOverrides: Pick<
 	uploadTime: undefined,
 } as const;
 
+export const blobManagerBasePath = "_blobs" as const;
+
 export class BlobManager extends TypedEventEmitter<IBlobManagerEvents> {
-	public static readonly basePath = "_blobs";
-	private static readonly redirectTableBlobName = ".redirectTable";
 	private readonly mc: MonitoringContext;
 
 	/**
@@ -178,10 +173,10 @@ export class BlobManager extends TypedEventEmitter<IBlobManagerEvents> {
 	private readonly routeContext: IFluidHandleContext;
 	private readonly getStorage: () => IDocumentStorageService;
 	// Called when a blob node is requested. blobPath is the path of the blob's node in GC's graph.
-	// blobPath's format - `/<BlobManager.basePath>/<blobId>`.
+	// blobPath's format - `/<basePath>/<blobId>`.
 	private readonly blobRequested: (blobPath: string) => void;
 	// Called to check if a blob has been deleted by GC.
-	// blobPath's format - `/<BlobManager.basePath>/<blobId>`.
+	// blobPath's format - `/<basePath>/<blobId>`.
 	private readonly isBlobDeleted: (blobPath: string) => boolean;
 	private readonly runtime: IBlobManagerRuntime;
 	private readonly closeContainer: (error?: ICriticalContainerError) => void;
@@ -202,10 +197,10 @@ export class BlobManager extends TypedEventEmitter<IBlobManagerEvents> {
 		 */
 		sendBlobAttachOp: (localId: string, storageId?: string) => void;
 		// Called when a blob node is requested. blobPath is the path of the blob's node in GC's graph.
-		// blobPath's format - `/<BlobManager.basePath>/<blobId>`.
+		// blobPath's format - `/<basePath>/<blobId>`.
 		readonly blobRequested: (blobPath: string) => void;
 		// Called to check if a blob has been deleted by GC.
-		// blobPath's format - `/<BlobManager.basePath>/<blobId>`.
+		// blobPath's format - `/<basePath>/<blobId>`.
 		readonly isBlobDeleted: (blobPath: string) => boolean;
 		readonly runtime: IBlobManagerRuntime;
 		stashedBlobs: IPendingBlobs | undefined;
@@ -235,7 +230,7 @@ export class BlobManager extends TypedEventEmitter<IBlobManagerEvents> {
 			namespace: "BlobManager",
 		});
 
-		this.redirectTable = this.load(snapshot);
+		this.redirectTable = toRedirectTable(snapshot, this.mc.logger, this.runtime.attachState);
 
 		// Begin uploading stashed blobs from previous container instance
 		Object.entries(stashedBlobs ?? {}).forEach(([localId, entry]) => {
@@ -347,27 +342,6 @@ export class BlobManager extends TypedEventEmitter<IBlobManagerEvents> {
 		);
 	}
 
-	/**
-	 * Set of actual storage IDs (i.e., IDs that can be requested from storage). This will be empty if the container is
-	 * detached or there are no (non-pending) attachment blobs in the document
-	 */
-	private get storageIds(): Set<string> {
-		const ids = new Set<string | undefined>(this.redirectTable.values());
-
-		// If we are detached, we will not have storage IDs, only undefined
-		const undefinedValueInTable = ids.delete(undefined);
-
-		// For a detached container, entries are inserted into the redirect table with an undefined storage ID.
-		// For an attached container, entries are inserted w/storage ID after the BlobAttach op round-trips.
-		assert(
-			!undefinedValueInTable ||
-				(this.runtime.attachState === AttachState.Detached && ids.size === 0),
-			0x382 /* 'redirectTable' must contain only undefined while detached / defined values while attached */,
-		);
-
-		return ids as Set<string>;
-	}
-
 	public async getBlob(blobId: string): Promise<ArrayBufferLike> {
 		// Verify that the blob is not deleted, i.e., it has not been garbage collected. If it is, this will throw
 		// an error, failing the call.
@@ -419,7 +393,7 @@ export class BlobManager extends TypedEventEmitter<IBlobManagerEvents> {
 				}
 			: undefined;
 		return new BlobHandle(
-			`${BlobManager.basePath}/${id}`,
+			getGCNodePathFromBlobId(id),
 			this.routeContext,
 			async () => this.getBlob(id),
 			callback,
@@ -569,7 +543,8 @@ export class BlobManager extends TypedEventEmitter<IBlobManagerEvents> {
 		if (!entry.opsent) {
 			this.sendBlobAttachOp(localId, response.id);
 		}
-		if (this.storageIds.has(response.id)) {
+		const storageIds = getStorageIds(this.redirectTable, this.runtime.attachState);
+		if (storageIds.has(response.id)) {
 			// The blob is de-duped. Set up a local ID to storage ID mapping and return the blob. Since this is
 			// an existing blob, we don't have to wait for the op to be ack'd since this step has already
 			// happened before and so, the server won't delete it.
@@ -662,74 +637,8 @@ export class BlobManager extends TypedEventEmitter<IBlobManagerEvents> {
 		}
 	}
 
-	/**
-	 * Reads blobs needed to load BlobManager from storage.
-	 * @param blobsTree - Tree containing IDs of previously attached blobs. We
-	 * look for the IDs in the blob entries of the tree since the both the r11s
-	 * and SPO drivers replace the attachment types returned in snapshot() with blobs.
-	 */
-	public static async load(
-		blobsTree: ISnapshotTree | undefined,
-		tryFetchBlob: (id: string) => Promise<[string, string][]>,
-	): Promise<IBlobManagerLoadInfo> {
-		if (!blobsTree) {
-			return {};
-		}
-		let redirectTable;
-		const tableId = blobsTree.blobs[this.redirectTableBlobName];
-		if (tableId) {
-			redirectTable = await tryFetchBlob(tableId);
-		}
-		const ids = Object.entries(blobsTree.blobs)
-			.filter(([k, _]) => k !== this.redirectTableBlobName)
-			.map(([_, v]) => v);
-		return { ids, redirectTable };
-	}
-
-	/**
-	 * Load a set of previously attached blob IDs and redirect table from a previous snapshot.
-	 */
-	private load(snapshot: IBlobManagerLoadInfo): Map<string, string | undefined> {
-		this.mc.logger.sendTelemetryEvent({
-			eventName: "AttachmentBlobsLoaded",
-			count: snapshot.ids?.length ?? 0,
-			redirectTable: snapshot.redirectTable?.length,
-		});
-		const table = new Map<string, string | undefined>(snapshot.redirectTable);
-		if (snapshot.ids) {
-			const detached = this.runtime.attachState === AttachState.Detached;
-			// If we are detached, we don't have storage IDs yet, so set to undefined
-			// Otherwise, set identity (id -> id) entries
-			snapshot.ids.forEach((entry) => table.set(entry, detached ? undefined : entry));
-		}
-		return table;
-	}
-
 	public summarize(telemetryContext?: ITelemetryContext): ISummaryTreeWithStats {
-		// if storageIds is empty, it means we are detached and have only local IDs, or that there are no blobs attached
-		const blobIds =
-			this.storageIds.size > 0
-				? Array.from(this.storageIds)
-				: Array.from(this.redirectTable.keys());
-		const builder = new SummaryTreeBuilder();
-		blobIds.forEach((blobId) => {
-			builder.addAttachment(blobId);
-		});
-
-		// Any non-identity entries in the table need to be saved in the summary
-		if (this.redirectTable.size > blobIds.length) {
-			builder.addBlob(
-				BlobManager.redirectTableBlobName,
-				// filter out identity entries
-				JSON.stringify(
-					Array.from(this.redirectTable.entries()).filter(
-						([localId, storageId]) => localId !== storageId,
-					),
-				),
-			);
-		}
-
-		return builder.getSummaryTree();
+		return summarizeBlobManagerState(this.redirectTable, this.runtime.attachState);
 	}
 
 	/**
@@ -766,7 +675,7 @@ export class BlobManager extends TypedEventEmitter<IBlobManagerEvents> {
 
 	/**
 	 * Delete blobs with the given routes from the redirect table.
-	 * The routes are GC nodes paths of format -`/<BlobManager.basePath>/<blobId>`. The blob ids are all local ids.
+	 * The routes are GC nodes paths of format -`/<blobManagerBasePath>/<blobId>`. The blob ids are all local ids.
 	 * Deleting the blobs involves 2 steps:
 	 * 1. The redirect table entry for the local ids are deleted.
 	 * 2. If the storage ids corresponding to the deleted local ids are not in-use anymore, the redirect table entries
@@ -839,7 +748,7 @@ export class BlobManager extends TypedEventEmitter<IBlobManagerEvents> {
 		this.mc.logger.sendErrorEvent(
 			{
 				eventName: "GC_Deleted_Blob_Requested",
-				pkg: BlobManager.basePath,
+				pkg: blobManagerBasePath,
 			},
 			error,
 		);
@@ -936,22 +845,28 @@ export class BlobManager extends TypedEventEmitter<IBlobManagerEvents> {
 }
 
 /**
- * For a blobId, returns its path in GC's graph. The node path is of the format `/<BlobManager.basePath>/<blobId>`.
+ * For a blobId, returns its path in GC's graph. The node path is of the format `/<blobManagerBasePath>/<blobId>`.
  * This path must match the path of the blob handle returned by the createBlob API because blobs are marked
  * referenced by storing these handles in a referenced DDS.
  */
-function getGCNodePathFromBlobId(blobId: string) {
-	return `/${BlobManager.basePath}/${blobId}`;
-}
+const getGCNodePathFromBlobId = (blobId: string) => `/${blobManagerBasePath}/${blobId}`;
 
 /**
- * For a given GC node path, return the blobId. The node path is of the format `/<BlobManager.basePath>/<blobId>`.
+ * For a given GC node path, return the blobId. The node path is of the format `/<basePath>/<blobId>`.
  */
-function getBlobIdFromGCNodePath(nodePath: string) {
+const getBlobIdFromGCNodePath = (nodePath: string) => {
 	const pathParts = nodePath.split("/");
-	assert(
-		pathParts.length === 3 && pathParts[1] === BlobManager.basePath,
-		0x5bd /* Invalid blob node path */,
-	);
+	assert(areBlobPathParts(pathParts), 0x5bd /* Invalid blob node path */);
 	return pathParts[2];
-}
+};
+
+/**
+ * Returns whether a given path is for attachment blobs that are in the format - "/blobManagerBasePath/...".
+ */
+export const isBlobPath = (path: string): path is `/${typeof blobManagerBasePath}/${string}` =>
+	areBlobPathParts(path.split("/"));
+
+export const areBlobPathParts = (
+	pathParts: string[],
+): pathParts is ["", typeof blobManagerBasePath, string] =>
+	pathParts.length === 3 && pathParts[1] === blobManagerBasePath;

package/src/blobManager/blobManagerSnapSum.ts

@@ -0,0 +1,133 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import {
+	AttachState,
+	type IContainerContext,
+} from "@fluidframework/container-definitions/internal";
+import { assert } from "@fluidframework/core-utils/internal";
+import { readAndParse } from "@fluidframework/driver-utils/internal";
+import type { ISummaryTreeWithStats } from "@fluidframework/runtime-definitions/internal";
+import { SummaryTreeBuilder } from "@fluidframework/runtime-utils/internal";
+import type { ITelemetryLoggerExt } from "@fluidframework/telemetry-utils/internal";
+
+/**
+ * Information from a snapshot needed to load BlobManager
+ * @legacy
+ * @alpha
+ */
+export interface IBlobManagerLoadInfo {
+	ids?: string[];
+	redirectTable?: [string, string][];
+}
+
+export const redirectTableBlobName = ".redirectTable";
+
+/**
+ * @internal
+ */
+export const blobsTreeName = ".blobs";
+
+/**
+ * Reads blobs needed to load BlobManager from storage.
+ *
+ */
+export const loadBlobManagerLoadInfo = async (
+	context: Pick<IContainerContext, "baseSnapshot" | "storage" | "attachState">,
+): Promise<IBlobManagerLoadInfo> => loadV1(context);
+
+const loadV1 = async (
+	context: Pick<IContainerContext, "baseSnapshot" | "storage" | "attachState">,
+): Promise<IBlobManagerLoadInfo> => {
+	const blobsTree = context.baseSnapshot?.trees[blobsTreeName];
+
+	if (!blobsTree) {
+		return {};
+	}
+	let redirectTableEntries: [string, string][] = [];
+	const tableId = blobsTree.blobs[redirectTableBlobName];
+	if (tableId) {
+		redirectTableEntries = await readAndParse(context.storage, tableId);
+	}
+	const ids = Object.entries(blobsTree.blobs)
+		.filter(([k, _]) => k !== redirectTableBlobName)
+		.map(([_, v]) => v);
+
+	return { ids, redirectTable: redirectTableEntries };
+};
+
+export const toRedirectTable = (
+	snapshot: IBlobManagerLoadInfo,
+	logger: ITelemetryLoggerExt,
+	attachState: AttachState,
+): Map<string, string | undefined> => {
+	logger.sendTelemetryEvent({
+		eventName: "AttachmentBlobsLoaded",
+		count: snapshot.ids?.length ?? 0,
+		redirectTable: snapshot.redirectTable?.length,
+	});
+	const redirectTable = new Map<string, string | undefined>(snapshot.redirectTable);
+	const detached = attachState !== AttachState.Attached;
+	if (snapshot.ids) {
+		// If we are detached, we don't have storage IDs yet, so set to undefined
+		// Otherwise, set identity (id -> id) entries.
+		snapshot.ids.forEach((entry) => redirectTable.set(entry, detached ? undefined : entry));
+	}
+	return redirectTable;
+};
+
+export const summarizeBlobManagerState = (
+	redirectTable: Map<string, string | undefined>,
+	attachState: AttachState,
+): ISummaryTreeWithStats => summarizeV1(redirectTable, attachState);
+
+const summarizeV1 = (
+	redirectTable: Map<string, string | undefined>,
+	attachState: AttachState,
+): ISummaryTreeWithStats => {
+	const storageIds = getStorageIds(redirectTable, attachState);
+
+	// if storageIds is empty, it means we are detached and have only local IDs, or that there are no blobs attached
+	const blobIds =
+		storageIds.size > 0 ? Array.from(storageIds) : Array.from(redirectTable.keys());
+	const builder = new SummaryTreeBuilder();
+	blobIds.forEach((blobId) => {
+		builder.addAttachment(blobId);
+	});
+
+	// Any non-identity entries in the table need to be saved in the summary
+	if (redirectTable.size > blobIds.length) {
+		builder.addBlob(
+			redirectTableBlobName,
+			// filter out identity entries
+			JSON.stringify(
+				Array.from(redirectTable.entries()).filter(
+					([localId, storageId]) => localId !== storageId,
+				),
+			),
+		);
+	}
+
+	return builder.getSummaryTree();
+};
+
+export const getStorageIds = (
+	redirectTable: Map<string, string | undefined>,
+	attachState: AttachState,
+) => {
+	const ids = new Set<string | undefined>(redirectTable.values());
+
+	// If we are detached, we will not have storage IDs, only undefined
+	const undefinedValueInTable = ids.delete(undefined);
+
+	// For a detached container, entries are inserted into the redirect table with an undefined storage ID.
+	// For an attached container, entries are inserted w/storage ID after the BlobAttach op round-trips.
+	assert(
+		!undefinedValueInTable || (attachState === AttachState.Detached && ids.size === 0),
+		0x382 /* 'redirectTable' must contain only undefined while detached / defined values while attached */,
+	);
+
+	return ids as Set<string>;
+};

package/src/blobManager/index.ts

@@ -0,0 +1,19 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+export {
+	BlobManager,
+	IPendingBlobs,
+	IBlobManagerRuntime,
+	IBlobManagerEvents,
+	blobManagerBasePath,
+	isBlobPath,
+} from "./blobManager.js";
+export {
+	loadBlobManagerLoadInfo,
+	IBlobManagerLoadInfo,
+	blobsTreeName,
+	redirectTableBlobName,
+} from "./blobManagerSnapSum.js";

package/src/containerRuntime.ts

@@ -126,7 +126,15 @@ import {
 import { v4 as uuid } from "uuid";
 
 import { BindBatchTracker } from "./batchTracker.js";
-import { BlobManager, IBlobManagerLoadInfo, IPendingBlobs } from "./blobManager.js";
+import {
+	BlobManager,
+	IPendingBlobs,
+	blobManagerBasePath,
+	blobsTreeName,
+	isBlobPath,
+	loadBlobManagerLoadInfo,
+	type IBlobManagerLoadInfo,
+} from "./blobManager/index.js";
 import {
 	ChannelCollection,
 	getSummaryForDatastores,
@@ -211,7 +219,6 @@ import {
 	SummaryCollection,
 	SummaryManager,
 	aliasBlobName,
-	blobsTreeName,
 	chunksBlobName,
 	createRootSummarizerNodeWithGC,
 	electedSummarizerBlobName,
@@ -677,23 +684,26 @@ export const makeLegacySendBatchFn =
 	};
 
 /** Helper type for type constraints passed through several functions.
+ * local - Did this client send the op?
+ * savedOp - Is this op being replayed after being serialized (having been sequenced previously)
+ * batchStartCsn - The clientSequenceNumber given on submit to the start of this batch
  * message - The unpacked message. Likely a TypedContainerRuntimeMessage, but could also be a system op
  * modernRuntimeMessage - Does this appear like a current TypedContainerRuntimeMessage?
- * local - Did this client send the op?
  */
-type MessageWithContext =
+type MessageWithContext = {
+	local: boolean;
+	savedOp?: boolean;
+	batchStartCsn: number;
+} & (
 	| {
 			message: InboundSequencedContainerRuntimeMessage;
 			modernRuntimeMessage: true;
-			local: boolean;
-			savedOp?: boolean;
 	  }
 	| {
 			message: InboundSequencedContainerRuntimeMessageOrSystemMessage;
 			modernRuntimeMessage: false;
-			local: boolean;
-			savedOp?: boolean;
-	  };
+	  }
+);
 
 const summarizerRequestUrl = "_summarizer";
 
@@ -857,18 +867,7 @@ export class ContainerRuntime
 			]);
 
 		// read snapshot blobs needed for BlobManager to load
-		const blobManagerSnapshot = await BlobManager.load(
-			context.baseSnapshot?.trees[blobsTreeName],
-			async (id) => {
-				// IContainerContext storage api return type still has undefined in 0.39 package version.
-				// So once we release 0.40 container-defn package we can remove this check.
-				assert(
-					context.storage !== undefined,
-					0x256 /* "storage undefined in attached container" */,
-				);
-				return readAndParse(context.storage, id);
-			},
-		);
+		const blobManagerSnapshot = await loadBlobManagerLoadInfo(context);
 
 		const messageAtLastSummary = lastMessageFromMetadata(metadata);
 
@@ -2221,7 +2220,7 @@ export class ContainerRuntime
 				return this.resolveHandle(requestParser.createSubRequest(1));
 			}
 
-			if (id === BlobManager.basePath && requestParser.isLeaf(2)) {
+			if (id === blobManagerBasePath && requestParser.isLeaf(2)) {
 				const blob = await this.blobManager.getBlob(requestParser.pathParts[1]);
 				return blob
 					? {
@@ -2619,7 +2618,13 @@ export class ContainerRuntime
 		// but will not modify the contents object (likely it will replace it on the message).
 		const messageCopy = { ...messageArg };
 		const savedOp = (messageCopy.metadata as ISavedOpMetadata)?.savedOp;
-		for (const message of this.remoteMessageProcessor.process(messageCopy)) {
+		const processResult = this.remoteMessageProcessor.process(messageCopy);
+		if (processResult === undefined) {
+			// This means the incoming message is an incomplete part of a message or batch
+			// and we need to process more messages before the rest of the system can understand it.
+			return;
+		}
+		for (const message of processResult.messages) {
 			const msg: MessageWithContext = modernRuntimeMessage
 				? {
 						// Cast it since we expect it to be this based on modernRuntimeMessage computation above.
@@ -2629,12 +2634,14 @@ export class ContainerRuntime
 						message: message as InboundSequencedContainerRuntimeMessage,
 						local,
 						modernRuntimeMessage,
+						batchStartCsn: processResult.batchStartCsn,
 					}
 				: // Unrecognized message will be ignored.
 					{
 						message,
 						local,
 						modernRuntimeMessage,
+						batchStartCsn: processResult.batchStartCsn,
 					};
 			msg.savedOp = savedOp;
 
@@ -2682,6 +2689,7 @@ export class ContainerRuntime
 			if (local && messageWithContext.modernRuntimeMessage) {
 				localOpMetadata = this.pendingStateManager.processPendingLocalMessage(
 					messageWithContext.message,
+					messageWithContext.batchStartCsn,
 				);
 			}
 
@@ -3360,7 +3368,7 @@ export class ContainerRuntime
 	 * blob manager.
 	 */
 	public getNodeType(nodePath: string): GCNodeType {
-		if (this.isBlobPath(nodePath)) {
+		if (isBlobPath(nodePath)) {
 			return GCNodeType.Blob;
 		}
 		return this.channelCollection.getGCNodeType(nodePath) ?? GCNodeType.Other;
@@ -3379,7 +3387,7 @@ export class ContainerRuntime
 
 		switch (this.getNodeType(nodePath)) {
 			case GCNodeType.Blob:
-				return [BlobManager.basePath];
+				return [blobManagerBasePath];
 			case GCNodeType.DataStore:
 			case GCNodeType.SubDataStore:
 				return this.channelCollection.getDataStorePackagePath(nodePath);
@@ -3388,17 +3396,6 @@ export class ContainerRuntime
 		}
 	}
 
-	/**
-	 * Returns whether a given path is for attachment blobs that are in the format - "/BlobManager.basePath/...".
-	 */
-	private isBlobPath(path: string): boolean {
-		const pathParts = path.split("/");
-		if (pathParts.length < 2 || pathParts[1] !== BlobManager.basePath) {
-			return false;
-		}
-		return true;
-	}
-
 	/**
 	 * From a given list of routes, separate and return routes that belong to blob manager and data stores.
 	 * @param routes - A list of routes that can belong to data stores or blob manager.
@@ -3409,7 +3406,7 @@ export class ContainerRuntime
 		const blobManagerRoutes: string[] = [];
 		const dataStoreRoutes: string[] = [];
 		for (const route of routes) {
-			if (this.isBlobPath(route)) {
+			if (isBlobPath(route)) {
 				blobManagerRoutes.push(route);
 			} else {
 				dataStoreRoutes.push(route);

package/src/dataStoreContext.ts

@@ -1058,6 +1058,7 @@ export class RemoteFluidDataStoreContext extends FluidDataStoreContext {
 	private snapshotFetchRequired: boolean | undefined;
 	private readonly runtime: IContainerRuntimeBase;
 	private readonly blobContents: Map<string, ArrayBuffer> | undefined;
+	private readonly isSnapshotInISnapshotFormat: boolean | undefined;
 
 	constructor(props: IRemoteFluidDataStoreContextProps) {
 		super(props, true /* existing */, false /* isLocalDataStore */, () => {
@@ -1068,8 +1069,10 @@ export class RemoteFluidDataStoreContext extends FluidDataStoreContext {
 		if (isInstanceOfISnapshot(props.snapshot)) {
 			this.blobContents = props.snapshot.blobContents;
 			this._baseSnapshot = props.snapshot.snapshotTree;
+			this.isSnapshotInISnapshotFormat = true;
 		} else {
 			this._baseSnapshot = props.snapshot;
+			this.isSnapshotInISnapshotFormat = false;
 		}
 		if (this._baseSnapshot !== undefined) {
 			this.summarizerNode.updateBaseSummaryState(this._baseSnapshot);
@@ -1091,10 +1094,13 @@ export class RemoteFluidDataStoreContext extends FluidDataStoreContext {
 	private readonly initialSnapshotDetailsP = new LazyPromise<ISnapshotDetails>(async () => {
 		// Sequence number of the snapshot.
 		let sequenceNumber: number | undefined;
-		// Check whether we need to fetch the snapshot first to load.
+		// Check whether we need to fetch the snapshot first to load. The snapshot should be in new format to see
+		// whether we want to evaluate to fetch snapshot or not for loadingGroupId. Otherwise, the snapshot
+		// will contain all the blobs.
 		if (
 			this.snapshotFetchRequired === undefined &&
-			this._baseSnapshot?.groupId !== undefined
+			this._baseSnapshot?.groupId !== undefined &&
+			this.isSnapshotInISnapshotFormat
 		) {
 			assert(
 				this.blobContents !== undefined,

package/src/gc/garbageCollection.ts

@@ -26,7 +26,7 @@ import {
 	tagCodeArtifacts,
 } from "@fluidframework/telemetry-utils/internal";
 
-import { BlobManager } from "../blobManager.js";
+import { blobManagerBasePath } from "../blobManager/index.js";
 import { InactiveResponseHeaderKey, TombstoneResponseHeaderKey } from "../containerRuntime.js";
 import { ClientSessionExpiredError } from "../error.js";
 import { ContainerMessageType, ContainerRuntimeGCMessage } from "../messageTypes.js";
@@ -1272,7 +1272,7 @@ export class GarbageCollector implements IGarbageCollector {
 		// be good enough because the only types that participate in GC today are data stores, DDSes and blobs.
 		const getDeletedNodeType = (nodeId: string): GCNodeType => {
 			const pathParts = nodeId.split("/");
-			if (pathParts[1] === BlobManager.basePath) {
+			if (pathParts[1] === blobManagerBasePath) {
 				return GCNodeType.Blob;
 			}
 			if (pathParts.length === 2) {

package/src/index.ts

@@ -30,7 +30,7 @@ export {
 	RecentlyAddedContainerRuntimeMessageDetails,
 	UnknownContainerRuntimeMessage,
 } from "./messageTypes.js";
-export { IBlobManagerLoadInfo } from "./blobManager.js";
+export { IBlobManagerLoadInfo } from "./blobManager/index.js";
 export { FluidDataStoreRegistry } from "./dataStoreRegistry.js";
 export {
 	detectOutboundReferences,