@fluidframework/container-loader 2.63.0-358419 → 2.63.0-359286

package/src/container.ts

@@ -140,9 +140,10 @@ import { NoopHeuristic } from "./noopHeuristic.js";
 import { pkgVersion } from "./packageVersion.js";
 import type { IQuorumSnapshot } from "./protocol/index.js";
 import {
-	type IProtocolHandler,
+	type InternalProtocolHandlerBuilder,
 	ProtocolHandler,
 	type ProtocolHandlerBuilder,
+	type ProtocolHandlerInternal,
 	protocolHandlerShouldProcessSignal,
 } from "./protocol.js";
 import { initQuorumValuesFromCodeDetails } from "./quorum.js";
@@ -495,7 +496,7 @@ export class Container
 	private readonly scope: FluidObject;
 	private readonly subLogger: ITelemetryLoggerExt;
 	private readonly detachedBlobStorage: MemoryDetachedBlobStorage | undefined;
-	private readonly protocolHandlerBuilder: ProtocolHandlerBuilder;
+	private readonly protocolHandlerBuilder: InternalProtocolHandlerBuilder;
 	private readonly client: IClient;
 
 	private readonly mc: MonitoringContext;
@@ -597,8 +598,8 @@ export class Container
 		}
 		return this._runtime;
 	}
-	private _protocolHandler: IProtocolHandler | undefined;
-	private get protocolHandler(): IProtocolHandler {
+	private _protocolHandler: ProtocolHandlerInternal | undefined;
+	private get protocolHandler(): ProtocolHandlerInternal {
 		if (this._protocolHandler === undefined) {
 			throw new Error("Attempted to access protocolHandler before it was defined");
 		}
@@ -830,7 +831,7 @@ export class Container
 				attributes: IDocumentAttributes,
 				quorumSnapshot: IQuorumSnapshot,
 				sendProposal: (key: string, value: unknown) => number,
-			): ProtocolHandler =>
+			): ProtocolHandlerInternal =>
 				new ProtocolHandler(
 					attributes,
 					quorumSnapshot,
@@ -1641,10 +1642,9 @@ export class Container
 		const timings: Record<string, number> = { phase1: performanceNow() };
 		this.service = await this.createDocumentService(resolvedUrl, { mode: "load" });
 
-		// Except in cases where it has stashed ops or requested by feature gate, the container will connect in "read" mode
+		// Except in cases where its requested by feature gate, the container will connect in "read" mode
 		const mode =
-			this.mc.config.getBoolean("Fluid.Container.ForceWriteConnection") === true ||
-			(pendingLocalState?.savedOps.length ?? 0) > 0
+			this.mc.config.getBoolean("Fluid.Container.ForceWriteConnection") === true
 				? "write"
 				: "read";
 		const connectionArgs: IConnectionArgs = {
@@ -1668,14 +1668,10 @@ export class Container
 		timings.phase2 = performanceNow();
 
 		// Fetch specified snapshot.
-		const { baseSnapshot, version } =
+		const { baseSnapshot, version, attributes } =
 			await this.serializedStateManager.fetchSnapshot(specifiedVersion);
 		const baseSnapshotTree: ISnapshotTree | undefined = getSnapshotTree(baseSnapshot);
 		this._loadedFromVersion = version;
-		const attributes: IDocumentAttributes = await getDocumentAttributes(
-			this.storageAdapter,
-			baseSnapshotTree,
-		);
 
 		// If we saved ops, we will replay them and don't need DeltaManager to fetch them
 		const lastProcessedSequenceNumber =

package/src/containerContext.ts

@@ -39,52 +39,50 @@ import { loaderCompatDetailsForRuntime } from "./loaderLayerCompatState.js";
 
 /**
  * Configuration object for ContainerContext constructor.
+ *
+ * @remarks
+ * A large subset of properties are from {@link IContainerContext}. Select
+ * properties are explicitly omitted so that, as {@link ContainerContext} is
+ * extended, newly added properties are not overlooked (but may also be
+ * explicitly omitted here by adding to the list).
  */
-export interface IContainerContextConfig {
+export interface IContainerContextConfig
+	extends Readonly<
+		Required<
+			Omit<
+				IContainerContext,
+				| "clientId"
+				| "connected"
+				| "attachState"
+				| "getLoadedFromVersion"
+				| "supportedFeatures"
+				| "id"
+				| "snapshotWithContents"
+			>
+		>
+	> {
+	// This overrides IContainerContext.options with specific type.
 	readonly options: ILoaderOptions;
-	readonly scope: FluidObject;
-	readonly baseSnapshot: ISnapshotTree | undefined;
 	readonly version: IVersion | undefined;
-	readonly deltaManager: IDeltaManager<ISequencedDocumentMessage, IDocumentMessage>;
-	readonly storage: IContainerStorageService;
-	readonly quorum: IQuorumClients;
-	readonly audience: IAudience;
-	readonly loader: ILoader;
-	readonly submitFn: (
-		type: MessageType,
-		contents: unknown,
-		batch: boolean,
-		appData: unknown,
-	) => number;
-	readonly submitSummaryFn: (
-		summaryOp: ISummaryContent,
-		referenceSequenceNumber?: number,
-	) => number;
-	readonly submitBatchFn: (batch: IBatchMessage[], referenceSequenceNumber?: number) => number;
-	readonly submitSignalFn: (
-		content: unknown | ISignalEnvelope,
-		targetClientId?: string,
-	) => void;
-	readonly disposeFn: (error?: ICriticalContainerError) => void;
-	readonly closeFn: (error?: ICriticalContainerError) => void;
-	readonly updateDirtyContainerState: (dirty: boolean) => void;
-	readonly getAbsoluteUrl: (relativeUrl: string) => Promise<string | undefined>;
 	readonly getContainerDiagnosticId: () => string | undefined;
 	readonly getClientId: () => string | undefined;
 	readonly getAttachState: () => AttachState;
 	readonly getConnected: () => boolean;
-	readonly getConnectionState: () => ConnectionState;
-	readonly clientDetails: IClientDetails;
 	readonly existing: boolean;
 	readonly taggedLogger: ITelemetryLoggerExt;
-	readonly pendingLocalState?: unknown;
-	readonly snapshotWithContents?: ISnapshot;
+	// This "overrides" IContainerContext.snapshotWithContents to be required but allow `undefined`.
+	readonly snapshotWithContents: IContainerContext["snapshotWithContents"] | undefined;
 }
 
 /**
  * {@inheritDoc @fluidframework/container-definitions#IContainerContext}
  */
-export class ContainerContext implements IContainerContext, IProvideLayerCompatDetails {
+export class ContainerContext
+	implements
+		Required<Omit<IContainerContext, "snapshotWithContents">>,
+		Pick<IContainerContext, "snapshotWithContents">,
+		IProvideLayerCompatDetails
+{
 	/**
 	 * @deprecated - This has been replaced by ILayerCompatDetails.
 	 */
@@ -139,7 +137,7 @@ export class ContainerContext implements IContainerContext, IProvideLayerCompatD
 	public readonly existing: boolean;
 	public readonly taggedLogger: ITelemetryLoggerExt;
 	public readonly pendingLocalState: unknown;
-	public readonly snapshotWithContents: ISnapshot | undefined;
+	public readonly snapshotWithContents?: ISnapshot;
 
 	public readonly getConnectionState: () => ConnectionState;
 
@@ -197,7 +195,9 @@ export class ContainerContext implements IContainerContext, IProvideLayerCompatD
 		this.existing = config.existing;
 		this.taggedLogger = config.taggedLogger;
 		this.pendingLocalState = config.pendingLocalState;
-		this.snapshotWithContents = config.snapshotWithContents;
+		if (config.snapshotWithContents !== undefined) {
+			this.snapshotWithContents = config.snapshotWithContents;
+		}
 
 		this.getConnectionState = config.getConnectionState;
 		this._getClientId = config.getClientId;

package/src/contracts.ts

@@ -12,6 +12,7 @@ import {
 	type IConnectionDetails,
 } from "@fluidframework/container-definitions/internal";
 import type { IErrorBase, ITelemetryBaseProperties } from "@fluidframework/core-interfaces";
+import type { JsonString } from "@fluidframework/core-interfaces/internal";
 import type { ConnectionMode, IClientDetails } from "@fluidframework/driver-definitions";
 import type {
 	IContainerPackageInfo,
@@ -145,7 +146,9 @@ export interface IConnectionManagerFactoryArgs {
 	 * Called by connection manager for each incoming signal.
 	 * May be called before connectHandler is called (due to initial signals on socket connection)
 	 */
-	readonly signalHandler: (signals: ISignalMessage[]) => void;
+	readonly signalHandler: (
+		signals: ISignalMessage<{ type: never; content: JsonString<unknown> }>[],
+	) => void;
 
 	/**
 	 * Called when connection manager experiences delay in connecting to relay service.

package/src/createAndLoadContainerUtils.ts

@@ -179,51 +179,12 @@ export async function loadExistingContainer(
  * Properties required to load a frozen container from pending state.
  * @legacy @alpha
  */
-export interface ILoadFrozenContainerFromPendingStateProps {
-	/**
-	 * The code loader handles loading the necessary code for running a container once it is loaded.
-	 */
-	readonly codeLoader: ICodeDetailsLoader;
-
-	/**
-	 * The url resolver used by the loader for resolving external urls into Fluid urls.
-	 */
-	readonly urlResolver: IUrlResolver;
-
-	/**
-	 * The request to resolve the container.
-	 */
-	readonly request: IRequest;
-
+export interface ILoadFrozenContainerFromPendingStateProps
+	extends ILoadExistingContainerProps {
 	/**
 	 * Pending local state to be applied to the container.
 	 */
 	readonly pendingLocalState: string;
-
-	/**
-	 * A property bag of options/policies used by various layers to control features.
-	 */
-	readonly options?: IContainerPolicies | undefined;
-
-	/**
-	 * Scope is provided to all container and is a set of shared services for container's to integrate with their host environment.
-	 */
-	readonly scope?: FluidObject | undefined;
-
-	/**
-	 * The logger that all telemetry should be pushed to.
-	 */
-	readonly logger?: ITelemetryBaseLogger | undefined;
-
-	/**
-	 * The configuration provider which may be used to control features.
-	 */
-	readonly configProvider?: IConfigProviderBase | undefined;
-
-	/**
-	 * Client details provided in the override will be merged over the default client.
-	 */
-	readonly clientDetailsOverride?: IClientDetails | undefined;
 }
 
 /**
@@ -236,6 +197,6 @@ export async function loadFrozenContainerFromPendingState(
 ): Promise<IContainer> {
 	return loadExistingContainer({
 		...props,
-		documentServiceFactory: new FrozenDocumentServiceFactory(),
+		documentServiceFactory: new FrozenDocumentServiceFactory(props.documentServiceFactory),
 	});
 }

package/src/deltaManager.ts

@@ -16,7 +16,8 @@ import type {
 	ITelemetryBaseEvent,
 	ITelemetryBaseProperties,
 } from "@fluidframework/core-interfaces";
-import type { IThrottlingWarning } from "@fluidframework/core-interfaces/internal";
+import { JsonParse } from "@fluidframework/core-interfaces/internal";
+import type { IThrottlingWarning, JsonString } from "@fluidframework/core-interfaces/internal";
 import { assert } from "@fluidframework/core-utils/internal";
 import type { ConnectionMode } from "@fluidframework/driver-definitions";
 import {
@@ -210,7 +211,9 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
 	private initSequenceNumber: number = 0;
 
 	private readonly _inbound: DeltaQueue<ISequencedDocumentMessage>;
-	private readonly _inboundSignal: DeltaQueue<ISignalMessage>;
+	private readonly _inboundSignal: DeltaQueue<
+		ISignalMessage<{ type: never; content: JsonString<unknown> }>
+	>;
 
 	private _closed = false;
 	private _disposed = false;
@@ -433,7 +436,9 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
 					this.close(normalizeError(error));
 				}
 			},
-			signalHandler: (signals: ISignalMessage[]) => {
+			signalHandler: (
+				signals: ISignalMessage<{ type: never; content: JsonString<unknown> }>[],
+			) => {
 				for (const signal of signals) {
 					this._inboundSignal.push(signal);
 				}
@@ -474,14 +479,16 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
 		});
 
 		// Inbound signal queue
-		this._inboundSignal = new DeltaQueue<ISignalMessage>((message) => {
+		this._inboundSignal = new DeltaQueue<
+			ISignalMessage<{ type: never; content: JsonString<unknown> }>
+		>((message) => {
 			if (this.handler === undefined) {
 				throw new Error("Attempted to process an inbound signal without a handler attached");
 			}
 
 			this.handler.processSignal({
 				...message,
-				content: JSON.parse(message.content as string),
+				content: JsonParse(message.content),
 			});
 		});
 

package/src/frozenServices.ts

@@ -29,8 +29,13 @@ import {
 import type { IConnectionStateChangeReason } from "./contracts.js";
 
 export class FrozenDocumentServiceFactory implements IDocumentServiceFactory {
+	constructor(private readonly documentServiceFactory?: IDocumentServiceFactory) {}
+
 	async createDocumentService(resolvedUrl: IResolvedUrl): Promise<IDocumentService> {
-		return new FrozenDocumentService(resolvedUrl);
+		return new FrozenDocumentService(
+			resolvedUrl,
+			await this.documentServiceFactory?.createDocumentService(resolvedUrl),
+		);
 	}
 	async createContainer(): Promise<IDocumentService> {
 		throw new Error("The FrozenDocumentServiceFactory cannot be used to create containers.");
@@ -41,7 +46,10 @@ class FrozenDocumentService
 	extends TypedEventEmitter<IDocumentServiceEvents>
 	implements IDocumentService
 {
-	constructor(public readonly resolvedUrl: IResolvedUrl) {
+	constructor(
+		public readonly resolvedUrl: IResolvedUrl,
+		private readonly documentService?: IDocumentService,
+	) {
 		super();
 	}
 
@@ -49,7 +57,7 @@ class FrozenDocumentService
 		storageOnly: true,
 	};
 	async connectToStorage(): Promise<IDocumentStorageService> {
-		return frozenDocumentStorageService;
+		return new FrozenDocumentStorageService(await this.documentService?.connectToStorage());
 	}
 	async connectToDeltaStorage(): Promise<IDocumentDeltaStorageService> {
 		return frozenDocumentDeltaStorageService;
@@ -63,15 +71,19 @@ class FrozenDocumentService
 const frozenDocumentStorageServiceHandler = (): never => {
 	throw new Error("Operations are not supported on the FrozenDocumentStorageService.");
 };
-const frozenDocumentStorageService: IDocumentStorageService = {
-	getSnapshotTree: frozenDocumentStorageServiceHandler,
-	getSnapshot: frozenDocumentStorageServiceHandler,
-	getVersions: frozenDocumentStorageServiceHandler,
-	createBlob: frozenDocumentStorageServiceHandler,
-	readBlob: frozenDocumentStorageServiceHandler,
-	uploadSummaryWithContext: frozenDocumentStorageServiceHandler,
-	downloadSummary: frozenDocumentStorageServiceHandler,
-};
+class FrozenDocumentStorageService implements IDocumentStorageService {
+	constructor(private readonly documentStorageService?: IDocumentStorageService) {}
+
+	getSnapshotTree = frozenDocumentStorageServiceHandler;
+	getSnapshot = frozenDocumentStorageServiceHandler;
+	getVersions = frozenDocumentStorageServiceHandler;
+	createBlob = frozenDocumentStorageServiceHandler;
+	readBlob =
+		this.documentStorageService?.readBlob.bind(this.documentStorageService) ??
+		frozenDocumentStorageServiceHandler;
+	uploadSummaryWithContext = frozenDocumentStorageServiceHandler;
+	downloadSummary = frozenDocumentStorageServiceHandler;
+}
 
 const frozenDocumentDeltaStorageService: IDocumentDeltaStorageService = {
 	fetchMessages: () => ({

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/container-loader";
-export const pkgVersion = "2.63.0-358419";
+export const pkgVersion = "2.63.0-359286";

package/src/protocol.ts

@@ -21,12 +21,39 @@ import {
 } from "./protocol/index.js";
 
 // ADO: #1986: Start using enum from protocol-base.
-export enum SignalType {
-	ClientJoin = "join", // same value as MessageType.ClientJoin,
-	ClientLeave = "leave", // same value as MessageType.ClientLeave,
-	Clear = "clear", // used only by client for synthetic signals
+export const SignalType = {
+	ClientJoin: "join", // same value as MessageType.ClientJoin,
+	ClientLeave: "leave", // same value as MessageType.ClientLeave,
+	Clear: "clear", // used only by client for synthetic signals
+} as const;
+
+interface SystemSignalContent {
+	type: (typeof SignalType)[keyof typeof SignalType];
+	content?: unknown;
+}
+
+interface InboundSystemSignal<TSignalContent extends SystemSignalContent>
+	extends ISignalMessage<{ type: never; content: TSignalContent }> {
+	// eslint-disable-next-line @rushstack/no-new-null -- `null` is used in JSON protocol to indicate system message
+	readonly clientId: null;
 }
 
+type ClientJoinSignal = InboundSystemSignal<{
+	type: typeof SignalType.ClientJoin;
+	content: ISignalClient;
+}>;
+
+type ClientLeaveSignal = InboundSystemSignal<{
+	type: typeof SignalType.ClientLeave;
+	content: string; // clientId of leaving client
+}>;
+
+type ClearClientsSignal = InboundSystemSignal<{
+	type: typeof SignalType.Clear;
+}>;
+
+type AudienceSignal = ClientJoinSignal | ClientLeaveSignal | ClearClientsSignal;
+
 /**
  * Function to be used for creating a protocol handler.
  * @legacy @beta
@@ -47,7 +74,35 @@ export interface IProtocolHandler extends IBaseProtocolHandler {
 	processSignal(message: ISignalMessage);
 }
 
-export class ProtocolHandler extends ProtocolOpHandler implements IProtocolHandler {
+/**
+ * More specific version of {@link IProtocolHandler} with narrower call
+ * constraints for {@link IProtocolHandler.processSignal}.
+ */
+export interface ProtocolHandlerInternal extends IProtocolHandler {
+	/**
+	 * Process the audience related signal.
+	 * @privateRemarks
+	 * Internally, only {@link AudienceSignal} messages need handling.
+	 */
+	processSignal(message: AudienceSignal): void;
+}
+
+/**
+ * Function to be used for creating a protocol handler.
+ *
+ * @remarks This is the same are {@link ProtocolHandlerBuilder} but
+ * returns the {@link ProtocolHandlerInternal} which has narrower
+ * expectations for `processSignal`.
+ */
+export type InternalProtocolHandlerBuilder = (
+	attributes: IDocumentAttributes,
+	snapshot: IQuorumSnapshot,
+	// TODO: use a real type (breaking change)
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	sendProposal: (key: string, value: any) => number,
+) => ProtocolHandlerInternal;
+
+export class ProtocolHandler extends ProtocolOpHandler implements ProtocolHandlerInternal {
 	constructor(
 		attributes: IDocumentAttributes,
 		quorumSnapshot: IQuorumSnapshot,
@@ -104,8 +159,8 @@ export class ProtocolHandler extends ProtocolOpHandler implements IProtocolHandl
 		return super.processMessage(message, local);
 	}
 
-	public processSignal(message: ISignalMessage): void {
-		const innerContent = message.content as { content: unknown; type: string };
+	public processSignal(message: AudienceSignal): void {
+		const innerContent = message.content;
 		switch (innerContent.type) {
 			case SignalType.Clear: {
 				const members = this.audience.getMembers();
@@ -117,7 +172,7 @@ export class ProtocolHandler extends ProtocolOpHandler implements IProtocolHandl
 				break;
 			}
 			case SignalType.ClientJoin: {
-				const newClient = innerContent.content as ISignalClient;
+				const newClient = innerContent.content;
 				// Ignore write clients - quorum will control such clients.
 				if (newClient.client.mode === "read") {
 					this.audience.addMember(newClient.clientId, newClient.client);
@@ -125,7 +180,7 @@ export class ProtocolHandler extends ProtocolOpHandler implements IProtocolHandl
 				break;
 			}
 			case SignalType.ClientLeave: {
-				const leftClientId = innerContent.content as string;
+				const leftClientId = innerContent.content;
 				// Ignore write clients - quorum will control such clients.
 				if (this.audience.getMember(leftClientId)?.mode === "read") {
 					this.audience.removeMember(leftClientId);
@@ -144,7 +199,9 @@ export class ProtocolHandler extends ProtocolOpHandler implements IProtocolHandl
  * The protocol handler should strictly handle only ClientJoin, ClientLeave
  * and Clear signal types.
  */
-export function protocolHandlerShouldProcessSignal(message: ISignalMessage): boolean {
+export function protocolHandlerShouldProcessSignal(
+	message: ISignalMessage,
+): message is AudienceSignal {
 	// Signal originates from server
 	if (message.clientId === null) {
 		const innerContent = message.content as { content: unknown; type: string };

package/src/serializedStateManager.ts

@@ -9,7 +9,6 @@ import type {
 	IEventProvider,
 	IEvent,
 	ITelemetryBaseLogger,
-	Tagged,
 } from "@fluidframework/core-interfaces";
 import { Timer, assert } from "@fluidframework/core-utils/internal";
 import {
@@ -28,7 +27,6 @@ import {
 	PerformanceEvent,
 	UsageError,
 	createChildMonitoringContext,
-	type TelemetryEventPropertyTypeExt,
 } from "@fluidframework/telemetry-utils/internal";
 
 import {
@@ -135,6 +133,27 @@ interface ISerializerEvent extends IEvent {
 	(event: "saved", listener: (dirty: boolean) => void): void;
 }
 
+class RefreshPromiseTracker {
+	public get hasPromise(): boolean {
+		return this.#promise !== undefined;
+	}
+	public get Promise(): Promise<number> | undefined {
+		return this.#promise;
+	}
+	constructor(private readonly catchHandler: (error: Error) => void) {}
+
+	#promise: Promise<number> | undefined;
+	setPromise(p: Promise<number>): void {
+		if (this.hasPromise) {
+			throw new Error("Cannot set promise while promise exists");
+		}
+		this.#promise = p.finally(() => {
+			this.#promise = undefined;
+		});
+		p.catch(this.catchHandler);
+	}
+}
+
 /**
  * Helper class to manage the state of the container needed for proper serialization.
  *
@@ -147,7 +166,16 @@ export class SerializedStateManager {
 	private readonly mc: MonitoringContext;
 	private snapshot: ISnapshotInfo | undefined;
 	private latestSnapshot: ISnapshotInfo | undefined;
-	private _refreshSnapshotP: Promise<number> | undefined;
+	private readonly refreshTracker = new RefreshPromiseTracker(
+		// eslint-disable-next-line unicorn/consistent-function-scoping
+		(error) =>
+			this.mc.logger.sendErrorEvent(
+				{
+					eventName: "RefreshLatestSnapshotFailed",
+				},
+				error,
+			),
+	);
 	private readonly lastSavedOpSequenceNumber: number = 0;
 	private readonly refreshTimer: Timer;
 	private readonly snapshotRefreshTimeoutMs: number = 60 * 60 * 24 * 1000;
@@ -199,8 +227,8 @@ export class SerializedStateManager {
 	 * only intended to be used for testing purposes.
 	 * @returns The snapshot sequence number associated with the latest fetched snapshot
 	 */
-	public get refreshSnapshotP(): Promise<number> | undefined {
-		return this._refreshSnapshotP;
+	public get refreshSnapshotP(): Promise<number | undefined> | undefined {
+		return this.refreshTracker.Promise;
 	}
 
 	/**
@@ -226,6 +254,7 @@ export class SerializedStateManager {
 	public async fetchSnapshot(specifiedVersion: string | undefined): Promise<{
 		baseSnapshot: ISnapshot | ISnapshotTree;
 		version: IVersion | undefined;
+		attributes: IDocumentAttributes;
 	}> {
 		if (this.pendingLocalState === undefined) {
 			const { baseSnapshot, version } = await getSnapshot(
@@ -235,18 +264,24 @@ export class SerializedStateManager {
 				specifiedVersion,
 			);
 			const baseSnapshotTree: ISnapshotTree | undefined = getSnapshotTree(baseSnapshot);
+			const attributes = await getDocumentAttributes(this.storageAdapter, baseSnapshotTree);
 			// non-interactive clients will not have any pending state we want to save
 			if (this.offlineLoadEnabled) {
-				const snapshotBlobs = await getBlobContentsFromTree(baseSnapshot, this.storageAdapter);
-				const attributes = await getDocumentAttributes(this.storageAdapter, baseSnapshotTree);
-				this.snapshot = {
-					baseSnapshot: baseSnapshotTree,
-					snapshotBlobs,
-					snapshotSequenceNumber: attributes.sequenceNumber,
-				};
-				this.refreshTimer.start();
+				// we defer getting the blobs to not impact the container load flow
+				// only getPendingState depends on the resolution of this promise
+				this.refreshTracker.setPromise(
+					getBlobContentsFromTree(baseSnapshot, this.storageAdapter).then((snapshotBlobs) => {
+						this.snapshot = {
+							baseSnapshot: baseSnapshotTree,
+							snapshotBlobs,
+							snapshotSequenceNumber: attributes.sequenceNumber,
+						};
+						this.refreshTimer.start();
+						return attributes.sequenceNumber;
+					}),
+				);
 			}
-			return { baseSnapshot, version };
+			return { baseSnapshot, version, attributes };
 		} else {
 			const { baseSnapshot, snapshotBlobs } = this.pendingLocalState;
 			const attributes = await getDocumentAttributes(this.storageAdapter, baseSnapshot);
@@ -268,30 +303,18 @@ export class SerializedStateManager {
 				ops: [],
 				snapshotFormatV: 1,
 			};
-			return { baseSnapshot: iSnapshot, version: undefined };
+			return { baseSnapshot: iSnapshot, version: undefined, attributes };
 		}
 	}
 
 	private tryRefreshSnapshot(): void {
 		if (
 			this.mc.config.getBoolean("Fluid.Container.enableOfflineSnapshotRefresh") === true &&
-			this._refreshSnapshotP === undefined &&
+			!this.refreshTracker.hasPromise &&
 			this.latestSnapshot === undefined
 		) {
 			// Don't block on the refresh snapshot call - it is for the next time we serialize, not booting this incarnation
-			this._refreshSnapshotP = this.refreshLatestSnapshot(this.supportGetSnapshotApi());
-			this._refreshSnapshotP
-				.catch(
-					(error: TelemetryEventPropertyTypeExt | Tagged<TelemetryEventPropertyTypeExt>) => {
-						this.mc.logger.sendTelemetryEvent({
-							eventName: "RefreshLatestSnapshotFailed",
-							error,
-						});
-					},
-				)
-				.finally(() => {
-					this._refreshSnapshotP = undefined;
-				});
+			this.refreshTracker.setPromise(this.refreshLatestSnapshot(this.supportGetSnapshotApi()));
 		}
 	}
 
@@ -439,6 +462,14 @@ export class SerializedStateManager {
 				if (!this.offlineLoadEnabled) {
 					throw new UsageError("Can't get pending local state unless offline load is enabled");
 				}
+				if (this.snapshot === undefined && this.refreshTracker.hasPromise) {
+					// we deferred the initial download of the snapshot to not block
+					// the container load flow, so if it is not resolved
+					// and we don't have a snapshot, we will wait for the download
+					// to finish.
+					await this.refreshTracker.Promise;
+				}
+
 				assert(this.snapshot !== undefined, 0x8e5 /* no base data */);
 				const pendingRuntimeState = await runtime.getPendingLocalState({
 					notifyImminentClosure: false,