@fluidframework/container-loader 2.63.0-359734 → 2.63.0

package/src/serializedStateManager.ts

@@ -22,7 +22,7 @@ import {
 	type IVersion,
 	type ISequencedDocumentMessage,
 } from "@fluidframework/driver-definitions/internal";
-import { getSnapshotTree } from "@fluidframework/driver-utils/internal";
+import { getSnapshotTree, isInstanceOfISnapshot } from "@fluidframework/driver-utils/internal";
 import {
 	type MonitoringContext,
 	PerformanceEvent,
@@ -31,12 +31,13 @@ import {
 } from "@fluidframework/telemetry-utils/internal";
 
 import {
-	type ISerializableBlobContents,
 	getBlobContentsFromTree,
+	type ContainerStorageAdapter,
+	type ISerializableBlobContents,
 } from "./containerStorageAdapter.js";
 import {
-	convertSnapshotToSnapshotInfo,
 	convertISnapshotToSnapshotWithBlobs,
+	convertSnapshotToSnapshotInfo,
 	getDocumentAttributes,
 } from "./utils.js";
 
@@ -80,7 +81,7 @@ export interface IPendingContainerState extends SnapshotWithBlobs {
 	/**
 	 * Any group snapshots (aka delay-loaded) we've downloaded from the service for this container
 	 */
-	loadedGroupIdSnapshots?: Record<string, ISnapshotInfo>;
+	loadedGroupIdSnapshots?: Record<string, SerializedSnapshotInfo>;
 	/**
 	 * All ops since base snapshot sequence number up to the latest op
 	 * seen when the container was closed. Used to apply stashed (saved pending)
@@ -122,14 +123,19 @@ export interface IPendingDetachedContainerState extends SnapshotWithBlobs {
 	pendingRuntimeState?: unknown;
 }
 
-export interface ISnapshotInfo extends SnapshotWithBlobs {
+export interface SerializedSnapshotInfo extends SnapshotWithBlobs {
+	snapshotSequenceNumber: number;
+}
+
+interface ISnapshotInfo {
 	snapshotSequenceNumber: number;
 	snapshotFetchedTime?: number | undefined;
+	snapshot: ISnapshot | ISnapshotTree;
 }
 
 export type ISerializedStateManagerDocumentStorageService = Pick<
-	IDocumentStorageService,
-	"getSnapshot" | "getSnapshotTree" | "getVersions" | "readBlob"
+	ContainerStorageAdapter,
+	"getSnapshot" | "getSnapshotTree" | "getVersions" | "readBlob" | "cacheSnapshotBlobs"
 > & {
 	loadedGroupIdSnapshots: Record<string, ISnapshot>;
 };
@@ -169,7 +175,7 @@ class RefreshPromiseTracker {
 export class SerializedStateManager implements IDisposable {
 	private readonly processedOps: ISequencedDocumentMessage[] = [];
 	private readonly mc: MonitoringContext;
-	private snapshot: ISnapshotInfo | undefined;
+	private snapshotInfo: ISnapshotInfo | undefined;
 	private latestSnapshot: ISnapshotInfo | undefined;
 	private readonly refreshTracker = new RefreshPromiseTracker(
 		// eslint-disable-next-line unicorn/consistent-function-scoping
@@ -211,6 +217,7 @@ export class SerializedStateManager implements IDisposable {
 		this.snapshotRefreshTimeoutMs = snapshotRefreshTimeoutMs ?? this.snapshotRefreshTimeoutMs;
 
 		this.#snapshotRefreshEnabled =
+			_offlineLoadEnabled &&
 			(this.mc.config.getBoolean("Fluid.Container.enableOfflineSnapshotRefresh") ??
 				this.mc.config.getBoolean("Fluid.Container.enableOfflineFull")) === true;
 
@@ -270,68 +277,62 @@ export class SerializedStateManager implements IDisposable {
 		specifiedVersion: string | undefined,
 		pendingLocalState: IPendingContainerState | undefined,
 	): Promise<{
-		baseSnapshot: ISnapshot | ISnapshotTree;
+		snapshot: ISnapshot | ISnapshotTree;
 		version: IVersion | undefined;
 		attributes: IDocumentAttributes;
 	}> {
 		this.verifyNotDisposed();
 		if (pendingLocalState === undefined) {
-			const { baseSnapshot, version } = await getSnapshot(
+			const { snapshot, version } = await getSnapshot(
 				this.mc,
 				this.storageAdapter,
 				this.supportGetSnapshotApi(),
 				specifiedVersion,
 			);
-			const baseSnapshotTree: ISnapshotTree | undefined = getSnapshotTree(baseSnapshot);
+			const baseSnapshotTree: ISnapshotTree | undefined = getSnapshotTree(snapshot);
 			const attributes = await getDocumentAttributes(this.storageAdapter, baseSnapshotTree);
-			// non-interactive clients will not have any pending state we want to save
 			if (this.offlineLoadEnabled) {
-				// 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;
-					}),
-				);
+				this.refreshTimer?.start();
+				this.snapshotInfo = {
+					snapshot,
+					snapshotSequenceNumber: attributes.sequenceNumber,
+				};
 			}
-			return { baseSnapshot, version, attributes };
+			return { snapshot, version, attributes };
 		} else {
 			const { baseSnapshot, snapshotBlobs, savedOps } = pendingLocalState;
-
-			// special case handle. Obtaining the last saved op seq num to avoid
-			// refreshing the snapshot before we have processed it. It could cause
-			// a subsequent stashing to have a newer snapshot than allowed.
-			if (savedOps.length > 0) {
-				const savedOpsSize = savedOps.length;
-				this.lastSavedOpSequenceNumber = savedOps[savedOpsSize - 1].sequenceNumber;
-			}
-
-			const attributes = await getDocumentAttributes(this.storageAdapter, baseSnapshot);
-			this.snapshot = {
-				baseSnapshot,
-				snapshotBlobs,
-				snapshotSequenceNumber: attributes.sequenceNumber,
-			};
-			this.tryRefreshSnapshot();
 			const blobContents = new Map<string, ArrayBuffer>();
 			for (const [id, value] of Object.entries(snapshotBlobs)) {
 				blobContents.set(id, stringToBuffer(value, "utf8"));
 			}
-			const iSnapshot: ISnapshot = {
-				sequenceNumber: this.snapshot.snapshotSequenceNumber,
+			this.storageAdapter.cacheSnapshotBlobs(blobContents);
+			const attributes = await getDocumentAttributes(this.storageAdapter, baseSnapshot);
+
+			const snapshot: ISnapshot = {
+				sequenceNumber: attributes.sequenceNumber,
 				snapshotTree: baseSnapshot,
 				blobContents,
 				latestSequenceNumber: undefined,
 				ops: [],
 				snapshotFormatV: 1,
 			};
-			return { baseSnapshot: iSnapshot, version: undefined, attributes };
+
+			if (this.offlineLoadEnabled) {
+				// special case handle. Obtaining the last saved op seq num to avoid
+				// refreshing the snapshot before we have processed it. It could cause
+				// a subsequent stashing to have a newer snapshot than allowed.
+				if (savedOps.length > 0) {
+					const savedOpsSize = savedOps.length;
+					this.lastSavedOpSequenceNumber = savedOps[savedOpsSize - 1].sequenceNumber;
+				}
+
+				this.snapshotInfo = {
+					snapshot,
+					snapshotSequenceNumber: attributes.sequenceNumber,
+				};
+				this.tryRefreshSnapshot();
+			}
+			return { snapshot, version: undefined, attributes };
 		}
 	}
 
@@ -415,7 +416,7 @@ export class SerializedStateManager implements IDisposable {
 				snapshotSequenceNumber,
 				firstProcessedOpSequenceNumber,
 				lastProcessedOpSequenceNumber,
-				stashedSnapshotSequenceNumber: this.snapshot?.snapshotSequenceNumber,
+				stashedSnapshotSequenceNumber: this.snapshotInfo?.snapshotSequenceNumber,
 			});
 			this.latestSnapshot = undefined;
 			this.refreshTimer?.restart();
@@ -423,7 +424,7 @@ export class SerializedStateManager implements IDisposable {
 			// Snapshot seq num is between the first and last processed op.
 			// Remove the ops that are already part of the snapshot
 			this.processedOps.splice(0, snapshotSequenceNumber - firstProcessedOpSequenceNumber + 1);
-			this.snapshot = this.latestSnapshot;
+			this.snapshotInfo = this.latestSnapshot;
 			this.latestSnapshot = undefined;
 			this.refreshTimer?.restart();
 			this.mc.logger.sendTelemetryEvent({
@@ -446,18 +447,9 @@ export class SerializedStateManager implements IDisposable {
 	public setInitialSnapshot(snapshot: ISnapshot): void {
 		this.verifyNotDisposed();
 		if (this.offlineLoadEnabled) {
-			assert(
-				this.snapshot === undefined,
-				0x937 /* inital snapshot should only be defined once */,
-			);
-			assert(
-				// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-				snapshot.sequenceNumber === 0,
-				0x939 /* trying to set a non attachment snapshot */,
-			);
-			this.snapshot = {
-				...convertISnapshotToSnapshotWithBlobs(snapshot),
-				snapshotSequenceNumber: snapshot.sequenceNumber,
+			this.snapshotInfo = {
+				snapshot,
+				snapshotSequenceNumber: snapshot.sequenceNumber ?? 0,
 				snapshotFetchedTime: Date.now(),
 			};
 			this.refreshTimer?.start();
@@ -474,6 +466,9 @@ export class SerializedStateManager implements IDisposable {
 		resolvedUrl: IResolvedUrl,
 	): Promise<string> {
 		this.verifyNotDisposed();
+		if (!this.offlineLoadEnabled) {
+			throw new UsageError("Can't get pending local state unless offline load is enabled");
+		}
 
 		return PerformanceEvent.timedExecAsync(
 			this.mc.logger,
@@ -488,25 +483,14 @@ export class SerializedStateManager implements IDisposable {
 				clientId,
 			},
 			async () => {
-				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 */);
+				assert(this.snapshotInfo !== undefined, 0x8e5 /* no base data */);
 				const pendingRuntimeState = await runtime.getPendingLocalState({
 					notifyImminentClosure: false,
-					snapshotSequenceNumber: this.snapshot.snapshotSequenceNumber,
-					sessionExpiryTimerStarted: this.snapshot.snapshotFetchedTime,
+					snapshotSequenceNumber: this.snapshotInfo.snapshotSequenceNumber,
+					sessionExpiryTimerStarted: this.snapshotInfo.snapshotFetchedTime,
 				});
 				// This conversion is required because ArrayBufferLike doesn't survive JSON.stringify
-				const loadedGroupIdSnapshots = {};
+				const loadedGroupIdSnapshots: Record<string, SerializedSnapshotInfo> = {};
 				let hasGroupIdSnapshots = false;
 				const groupIdSnapshots = Object.entries(this.storageAdapter.loadedGroupIdSnapshots);
 				if (groupIdSnapshots.length > 0) {
@@ -515,11 +499,20 @@ export class SerializedStateManager implements IDisposable {
 						loadedGroupIdSnapshots[groupId] = convertSnapshotToSnapshotInfo(snapshot);
 					}
 				}
+
+				const snapshotWithBlobs: SnapshotWithBlobs = isInstanceOfISnapshot(
+					this.snapshotInfo.snapshot,
+				)
+					? convertISnapshotToSnapshotWithBlobs(this.snapshotInfo.snapshot)
+					: await convertSnapshotTreeToSnapshotWithBlobs(
+							this.snapshotInfo.snapshot,
+							this.storageAdapter,
+						);
+
 				const pendingState: IPendingContainerState = {
 					attached: true,
 					pendingRuntimeState,
-					baseSnapshot: this.snapshot.baseSnapshot,
-					snapshotBlobs: this.snapshot.snapshotBlobs,
+					...snapshotWithBlobs,
 					loadedGroupIdSnapshots: hasGroupIdSnapshots ? loadedGroupIdSnapshots : undefined,
 					savedOps: this.processedOps,
 					url: resolvedUrl.url,
@@ -532,6 +525,17 @@ export class SerializedStateManager implements IDisposable {
 	}
 }
 
+async function convertSnapshotTreeToSnapshotWithBlobs(
+	snapshot: ISnapshotTree,
+	storageAdapter: ISerializedStateManagerDocumentStorageService,
+): Promise<SnapshotWithBlobs> {
+	const snapshotBlobs = await getBlobContentsFromTree(snapshot, storageAdapter);
+	return {
+		baseSnapshot: snapshot,
+		snapshotBlobs,
+	};
+}
+
 /**
  * Retrieves the most recent snapshot and returns its info.
  *
@@ -545,41 +549,46 @@ export async function getLatestSnapshotInfo(
 	storageAdapter: ISerializedStateManagerDocumentStorageService,
 	supportGetSnapshotApi: boolean,
 ): Promise<ISnapshotInfo | undefined> {
-	return PerformanceEvent.timedExecAsync(
+	return PerformanceEvent.timedExecAsync<ISnapshotInfo | undefined>(
 		mc.logger,
 		{ eventName: "GetLatestSnapshotInfo" },
-		async () => {
-			// get the latest non cached snapshot version
-			const specifiedVersion: IVersion[] = await storageAdapter.getVersions(
-				// eslint-disable-next-line unicorn/no-null
-				null,
-				1,
-				"getLatestSnapshotInfo",
-				FetchSource.noCache,
-			);
-			const { baseSnapshot } = await getSnapshot(
-				mc,
-				storageAdapter,
-				supportGetSnapshotApi,
-				specifiedVersion[0]?.id,
-			);
+		async (event) => {
+			try {
+				// get the latest non cached snapshot version
+				const specifiedVersion: IVersion[] = await storageAdapter.getVersions(
+					// eslint-disable-next-line unicorn/no-null
+					null,
+					1,
+					"getLatestSnapshotInfo",
+					FetchSource.noCache,
+				);
+				const { snapshot: baseSnapshot } = await getSnapshot(
+					mc,
+					storageAdapter,
+					supportGetSnapshotApi,
+					specifiedVersion[0]?.id,
+				);
 
-			const baseSnapshotTree: ISnapshotTree | undefined = getSnapshotTree(baseSnapshot);
-			const snapshotFetchedTime = Date.now();
-			const snapshotBlobs = await getBlobContentsFromTree(baseSnapshot, storageAdapter);
-			const attributes: IDocumentAttributes = await getDocumentAttributes(
-				storageAdapter,
-				baseSnapshotTree,
-			);
-			const snapshotSequenceNumber = attributes.sequenceNumber;
-			return {
-				baseSnapshot: baseSnapshotTree,
-				snapshotBlobs,
-				snapshotSequenceNumber,
-				snapshotFetchedTime,
-			};
+				const { sequenceNumber, snapshotTree } = isInstanceOfISnapshot(baseSnapshot)
+					? baseSnapshot
+					: { snapshotTree: baseSnapshot, sequenceNumber: undefined };
+
+				const snapshotSequenceNumber: number =
+					sequenceNumber ??
+					(await getDocumentAttributes(storageAdapter, snapshotTree).then(
+						(a) => a.sequenceNumber,
+					));
+				return {
+					snapshot: baseSnapshot,
+					snapshotSequenceNumber,
+					snapshotFetchedTime: Date.now(),
+				};
+			} catch (error) {
+				event.cancel(undefined, error);
+			}
+			return undefined;
 		},
-	).catch(() => undefined);
+	);
 }
 
 /**
@@ -599,12 +608,12 @@ async function getSnapshot(
 	>,
 	supportGetSnapshotApi: boolean,
 	specifiedVersion: string | undefined,
-): Promise<{ baseSnapshot: ISnapshot | ISnapshotTree; version?: IVersion }> {
+): Promise<{ snapshot: ISnapshot | ISnapshotTree; version?: IVersion }> {
 	const { snapshot, version } = supportGetSnapshotApi
 		? await fetchISnapshot(mc, storageAdapter, specifiedVersion)
 		: await fetchISnapshotTree(mc, storageAdapter, specifiedVersion);
 	assert(snapshot !== undefined, 0x8e4 /* Snapshot should exist */);
-	return { baseSnapshot: snapshot, version };
+	return { snapshot, version };
 }
 
 /**

package/src/summarizerResultTypes.ts

@@ -0,0 +1,115 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import type { IErrorBase } from "@fluidframework/core-interfaces";
+import type {
+	ISequencedDocumentMessage,
+	ISummaryAck,
+	ISummaryContent,
+	ISummaryTree,
+	MessageType,
+} from "@fluidframework/driver-definitions/internal";
+
+export const summarizerRequestUrl = "_summarizer";
+
+/**
+ * Stages of summary process.
+ *
+ * Stages:
+ *
+ * 1. "base" - stopped before the summary tree was even generated, and the result only contains the base data
+ *
+ * 2. "generate" - the summary tree was generated, and the result will contain that tree + stats
+ *
+ * 3. "upload" - the summary was uploaded to storage, and the result contains the server-provided handle
+ *
+ * 4. "submit" - the summarize op was submitted, and the result contains the op client sequence number.
+ *
+ * @legacy @alpha
+ */
+export type SummaryStage = "base" | "generate" | "upload" | "submit" | "unknown";
+
+type OnDemandSummaryStageResult<TSuccess> =
+	| {
+			readonly success: true;
+			readonly data: TSuccess;
+	  }
+	| {
+			readonly success: false;
+			readonly error: IErrorBase;
+	  };
+
+interface ISummaryOpMessage extends ISequencedDocumentMessage {
+	type: MessageType.Summarize;
+	contents: ISummaryContent;
+}
+
+interface ISummaryAckMessage extends ISequencedDocumentMessage {
+	type: MessageType.SummaryAck;
+	contents: ISummaryAck;
+}
+
+/**
+ * @internal
+ */
+export interface SummarizeOnDemandResults {
+	readonly summarySubmitted: OnDemandSummaryStageResult<{
+		readonly stage: SummaryStage;
+		readonly summaryTree?: ISummaryTree;
+		readonly handle?: string;
+	}>;
+	readonly summaryOpBroadcasted: OnDemandSummaryStageResult<{
+		readonly broadcastDuration: number;
+		readonly summarizeOp: ISummaryOpMessage;
+	}>;
+	readonly receivedSummaryAckOrNack: OnDemandSummaryStageResult<{
+		readonly summaryAckOp: ISummaryAckMessage;
+		readonly ackNackDuration: number;
+	}>;
+}
+
+/**
+ * Results from an on-demand summary request.
+ * @legacy @alpha
+ */
+export interface OnDemandSummaryResults {
+	/**
+	 * True if summary was generated, uploaded, and submitted.
+	 */
+	readonly summarySubmitted: boolean;
+
+	/**
+	 * Information about the summary that was submitted, if any.
+	 */
+	readonly summaryInfo: {
+		/**
+		 * Stage at which summary process ended.
+		 */
+		readonly stage?: SummaryStage;
+		/**
+		 * Handle of the complete summary.
+		 */
+		readonly handle?: string;
+	};
+
+	/**
+	 * True if summarize op broadcast was observed.
+	 */
+	readonly summaryOpBroadcasted: boolean;
+}
+
+/**
+ * Outcome from {@link loadSummarizerContainerAndMakeSummary}.
+ * @legacy @alpha
+ */
+export type LoadSummarizerSummaryResult =
+	| {
+			readonly success: true;
+			readonly summaryResults: OnDemandSummaryResults;
+	  }
+	| {
+			readonly success: false;
+			readonly error: IErrorBase;
+	  };

package/src/utils.ts

@@ -4,9 +4,9 @@
  */
 
 import {
-	Uint8ArrayToArrayBuffer,
 	bufferToString,
 	stringToBuffer,
+	Uint8ArrayToArrayBuffer,
 } from "@fluid-internal/client-utils";
 import { assert, compareArrays, unreachableCase } from "@fluidframework/core-utils/internal";
 import { type ISummaryTree, SummaryType } from "@fluidframework/driver-definitions";
@@ -34,7 +34,7 @@ import type { ISerializableBlobContents } from "./containerStorageAdapter.js";
 import type {
 	IPendingContainerState,
 	IPendingDetachedContainerState,
-	ISnapshotInfo,
+	SerializedSnapshotInfo,
 	SnapshotWithBlobs,
 } from "./serializedStateManager.js";
 
@@ -195,7 +195,7 @@ function convertSummaryToISnapshot(
  * Note, this assumes the ISnapshot sequence number is defined. Otherwise an assert will be thrown
  * @param snapshot - ISnapshot
  */
-export function convertSnapshotToSnapshotInfo(snapshot: ISnapshot): ISnapshotInfo {
+export function convertSnapshotToSnapshotInfo(snapshot: ISnapshot): SerializedSnapshotInfo {
 	assert(
 		snapshot.sequenceNumber !== undefined,
 		0x93a /* Snapshot sequence number is missing */,
@@ -219,8 +219,7 @@ export function convertSnapshotToSnapshotInfo(snapshot: ISnapshot): ISnapshotInf
  * @param snapshot - ISnapshot
  */
 export function convertSnapshotInfoToSnapshot(
-	snapshotInfo: ISnapshotInfo,
-	snapshotSequenceNumber: number,
+	snapshotInfo: SerializedSnapshotInfo,
 ): ISnapshot {
 	const blobContents = new Map<string, ArrayBuffer>();
 	for (const [blobId, serializedContent] of Object.entries(snapshotInfo.snapshotBlobs)) {
@@ -230,7 +229,7 @@ export function convertSnapshotInfoToSnapshot(
 		snapshotTree: snapshotInfo.baseSnapshot,
 		blobContents,
 		ops: [],
-		sequenceNumber: snapshotSequenceNumber,
+		sequenceNumber: snapshotInfo.snapshotSequenceNumber,
 		latestSequenceNumber: undefined,
 		snapshotFormatV: 1,
 	};
@@ -275,33 +274,34 @@ export function getProtocolSnapshotTree(snapshot: ISnapshotTree): ISnapshotTree
 	return ".protocol" in snapshot.trees ? snapshot.trees[".protocol"] : snapshot;
 }
 
-export const combineSnapshotTreeAndSnapshotBlobs = (
-	baseSnapshot: ISnapshotTree,
-	snapshotBlobs: ISerializableBlobContents,
-): ISnapshotTreeWithBlobContents => {
-	const blobsContents: { [path: string]: ArrayBufferLike } = {};
+export const combineSnapshotTreeAndSnapshotBlobs = ({
+	blobContents,
+	snapshotTree,
+}: Pick<ISnapshot, "blobContents" | "snapshotTree">): ISnapshotTreeWithBlobContents => {
+	const currentTreeBlobs: { [path: string]: ArrayBufferLike } = {};
 
 	// Process blobs in the current level
-	for (const [, id] of Object.entries(baseSnapshot.blobs)) {
-		if (snapshotBlobs[id] !== undefined) {
-			blobsContents[id] = stringToBuffer(snapshotBlobs[id], "utf8");
+	for (const [, id] of Object.entries(snapshotTree.blobs)) {
+		const blob = blobContents.get(id);
+		if (blob !== undefined) {
+			currentTreeBlobs[id] = blob;
 		}
 	}
 
 	// Recursively process trees in the current level
 	const trees: { [path: string]: ISnapshotTreeWithBlobContents } = {};
-	for (const [path, tree] of Object.entries(baseSnapshot.trees)) {
-		trees[path] = combineSnapshotTreeAndSnapshotBlobs(tree, snapshotBlobs);
+	for (const [path, tree] of Object.entries(snapshotTree.trees)) {
+		trees[path] = combineSnapshotTreeAndSnapshotBlobs({ snapshotTree: tree, blobContents });
 	}
 
 	// Create a new snapshot tree with blob contents and processed trees
-	const snapshotTreeWithBlobContents: ISnapshotTreeWithBlobContents = {
-		...baseSnapshot,
-		blobsContents,
+	const snapshot: ISnapshotTreeWithBlobContents = {
+		...snapshotTree,
+		blobsContents: currentTreeBlobs,
 		trees,
 	};
 
-	return snapshotTreeWithBlobContents;
+	return snapshot;
 };
 
 export function isDeltaStreamConnectionForbiddenError(