@fluidframework/routerlicious-driver 2.0.0-internal.4.1.2 → 2.0.0-internal.4.2.0

package/src/documentService.ts

@@ -24,6 +24,7 @@ import { pkgVersion as driverVersion } from "./packageVersion";
 import { GitManager } from "./gitManager";
 import { Historian } from "./historian";
 import { RestWrapper } from "./restWrapperBase";
+import { INormalizedWholeSummary } from "./contracts";
 
 /**
  * Amount of time between discoveries within which we don't need to rediscover on re-connect.
@@ -63,7 +64,8 @@ export class DocumentService implements api.IDocumentService {
 		private readonly documentStorageServicePolicies: api.IDocumentStorageServicePolicies,
 		private readonly driverPolicies: IRouterliciousDriverPolicies,
 		private readonly blobCache: ICache<ArrayBufferLike>,
-		private readonly snapshotTreeCache: ICache<ISnapshotTreeVersion>,
+		private readonly wholeSnapshotTreeCache: ICache<INormalizedWholeSummary>,
+		private readonly shreddedSummaryTreeCache: ICache<ISnapshotTreeVersion>,
 		private readonly discoverFluidResolvedUrl: () => Promise<api.IFluidResolvedUrl>,
 	) {}
 
@@ -125,7 +127,8 @@ export class DocumentService implements api.IDocumentService {
 			this.documentStorageServicePolicies,
 			this.driverPolicies,
 			this.blobCache,
-			this.snapshotTreeCache,
+			this.wholeSnapshotTreeCache,
+			this.shreddedSummaryTreeCache,
 			noCacheStorageManager,
 			getStorageManager,
 		);
@@ -184,7 +187,7 @@ export class DocumentService implements api.IDocumentService {
 	 */
 	public async connectToDeltaStream(client: IClient): Promise<api.IDocumentDeltaConnection> {
 		const connect = async (refreshToken?: boolean) => {
-			let ordererToken = this.ordererRestWrapper.getToken();
+			let ordererToken = await this.ordererRestWrapper.getToken();
 			if (this.shouldUpdateDiscoveredSessionInfo()) {
 				await this.refreshDiscovery();
 			}

package/src/documentServiceFactory.ts

@@ -34,6 +34,7 @@ import { parseFluidUrl, replaceDocumentIdInPath, getDiscoveredFluidResolvedUrl }
 import { ICache, InMemoryCache, NullCache } from "./cache";
 import { pkgVersion as driverVersion } from "./packageVersion";
 import { ISnapshotTreeVersion } from "./definitions";
+import { INormalizedWholeSummary } from "./contracts";
 
 const maximumSnapshotCacheDurationMs: FiveDaysMs = 432_000_000; // 5 days in ms
 
@@ -55,7 +56,8 @@ const defaultRouterliciousDriverPolicies: IRouterliciousDriverPolicies = {
 export class RouterliciousDocumentServiceFactory implements IDocumentServiceFactory {
 	private readonly driverPolicies: IRouterliciousDriverPolicies;
 	private readonly blobCache: ICache<ArrayBufferLike>;
-	private readonly snapshotTreeCache: ICache<ISnapshotTreeVersion>;
+	private readonly wholeSnapshotTreeCache: ICache<INormalizedWholeSummary> = new NullCache();
+	private readonly shreddedSummaryTreeCache: ICache<ISnapshotTreeVersion> = new NullCache();
 
 	constructor(
 		private readonly tokenProvider: ITokenProvider,
@@ -69,9 +71,17 @@ export class RouterliciousDocumentServiceFactory implements IDocumentServiceFact
 			...driverPolicies,
 		};
 		this.blobCache = new InMemoryCache<ArrayBufferLike>();
-		this.snapshotTreeCache = this.driverPolicies.enableInternalSummaryCaching
-			? new InMemoryCache<ISnapshotTreeVersion>(snapshotCacheExpiryMs)
-			: new NullCache<ISnapshotTreeVersion>();
+		if (this.driverPolicies.enableInternalSummaryCaching) {
+			if (this.driverPolicies.enableWholeSummaryUpload) {
+				this.wholeSnapshotTreeCache = new InMemoryCache<INormalizedWholeSummary>(
+					snapshotCacheExpiryMs,
+				);
+			} else {
+				this.shreddedSummaryTreeCache = new InMemoryCache<ISnapshotTreeVersion>(
+					snapshotCacheExpiryMs,
+				);
+			}
+		}
 	}
 
 	/**
@@ -307,7 +317,8 @@ export class RouterliciousDocumentServiceFactory implements IDocumentServiceFact
 			documentStorageServicePolicies,
 			this.driverPolicies,
 			this.blobCache,
-			this.snapshotTreeCache,
+			this.wholeSnapshotTreeCache,
+			this.shreddedSummaryTreeCache,
 			discoverFluidResolvedUrl,
 		);
 	}

package/src/documentStorageService.ts

@@ -18,8 +18,9 @@ import { IRouterliciousDriverPolicies } from "./policies";
 import { ICache } from "./cache";
 import { WholeSummaryDocumentStorageService } from "./wholeSummaryDocumentStorageService";
 import { ShreddedSummaryDocumentStorageService } from "./shreddedSummaryDocumentStorageService";
-import { ISnapshotTreeVersion } from "./definitions";
 import { GitManager } from "./gitManager";
+import { ISnapshotTreeVersion } from "./definitions";
+import { INormalizedWholeSummary } from "./contracts";
 
 export class DocumentStorageService extends DocumentStorageServiceProxy {
 	private _logTailSha: string | undefined = undefined;
@@ -35,7 +36,8 @@ export class DocumentStorageService extends DocumentStorageServiceProxy {
 		policies: IDocumentStorageServicePolicies,
 		driverPolicies?: IRouterliciousDriverPolicies,
 		blobCache?: ICache<ArrayBufferLike>,
-		snapshotTreeCache?: ICache<ISnapshotTreeVersion>,
+		snapshotTreeCache?: ICache<INormalizedWholeSummary>,
+		shreddedSummaryTreeCache?: ICache<ISnapshotTreeVersion>,
 		noCacheGitManager?: GitManager,
 		getStorageManager?: (disableCache?: boolean) => Promise<GitManager>,
 	): IDocumentStorageService {
@@ -58,7 +60,7 @@ export class DocumentStorageService extends DocumentStorageServiceProxy {
 					policies,
 					driverPolicies,
 					blobCache,
-					snapshotTreeCache,
+					shreddedSummaryTreeCache,
 					getStorageManager,
 			  );
 		// TODO: worth prefetching latest summary making version + snapshot call with WholeSummary storage?
@@ -78,7 +80,8 @@ export class DocumentStorageService extends DocumentStorageServiceProxy {
 		policies: IDocumentStorageServicePolicies,
 		driverPolicies?: IRouterliciousDriverPolicies,
 		blobCache?: ICache<ArrayBufferLike>,
-		snapshotTreeCache?: ICache<ISnapshotTreeVersion>,
+		snapshotTreeCache?: ICache<INormalizedWholeSummary>,
+		shreddedSummaryTreeCache?: ICache<ISnapshotTreeVersion>,
 		public noCacheGitManager?: GitManager,
 		getStorageManager?: (disableCache?: boolean) => Promise<GitManager>,
 	) {
@@ -91,6 +94,7 @@ export class DocumentStorageService extends DocumentStorageServiceProxy {
 				driverPolicies,
 				blobCache,
 				snapshotTreeCache,
+				shreddedSummaryTreeCache,
 				noCacheGitManager,
 				getStorageManager,
 			),

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/routerlicious-driver";
-export const pkgVersion = "2.0.0-internal.4.1.2";
+export const pkgVersion = "2.0.0-internal.4.2.0";

package/src/r11sSnapshotParser.ts

@@ -0,0 +1,83 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { ISnapshotTree } from "@fluidframework/protocol-definitions";
+import { IWholeFlatSummary, IWholeFlatSummaryTree } from "@fluidframework/server-services-client";
+import { stringToBuffer } from "@fluidframework/common-utils";
+import { INormalizedWholeSummary } from "./contracts";
+
+/**
+ * Build a tree heirarchy from a flat tree.
+ *
+ * @param flatTree - a flat tree
+ * @param treePrefixToRemove - tree prefix to strip
+ * @returns the heirarchical tree
+ */
+function buildHierarchy(
+	flatTree: IWholeFlatSummaryTree,
+	treePrefixToRemove: string,
+): ISnapshotTree {
+	const lookup: { [path: string]: ISnapshotTree } = {};
+	// Root tree id will be used to determine which version was downloaded.
+	const root: ISnapshotTree = { id: flatTree.id, blobs: {}, trees: {} };
+	lookup[""] = root;
+
+	for (const entry of flatTree.entries) {
+		// Strip the `treePrefixToRemove` path from tree entries such that they are stored under root.
+		const entryPath = entry.path.replace(new RegExp(`^${treePrefixToRemove}/`), "");
+		const lastIndex = entryPath.lastIndexOf("/");
+		const entryPathDir = entryPath.slice(0, Math.max(0, lastIndex));
+		const entryPathBase = entryPath.slice(lastIndex + 1);
+
+		// The flat output is breadth-first so we can assume we see tree nodes prior to their contents
+		const node = lookup[entryPathDir];
+
+		// Add in either the blob or tree
+		if (entry.type === "tree") {
+			const newTree: ISnapshotTree = {
+				blobs: {},
+				trees: {},
+				unreferenced: entry.unreferenced,
+			};
+			node.trees[decodeURIComponent(entryPathBase)] = newTree;
+			lookup[entryPath] = newTree;
+		} else if (entry.type === "blob") {
+			node.blobs[decodeURIComponent(entryPathBase)] = entry.id;
+		} else {
+			throw new Error(`Unknown entry type!!`);
+		}
+	}
+
+	return root;
+}
+
+/**
+ * Converts existing IWholeFlatSummary to snapshot tree, blob array, and sequence number.
+ *
+ * @param flatSummary - flat summary
+ * @param treePrefixToRemove - tree prefix to strip. By default we are stripping ".app" prefix
+ * @returns snapshot tree, blob array, and sequence number
+ */
+export function convertWholeFlatSummaryToSnapshotTreeAndBlobs(
+	flatSummary: IWholeFlatSummary,
+	treePrefixToRemove: string = ".app",
+): INormalizedWholeSummary {
+	const blobs = new Map<string, ArrayBuffer>();
+	if (flatSummary.blobs) {
+		flatSummary.blobs.forEach((blob) => {
+			blobs.set(blob.id, stringToBuffer(blob.content, blob.encoding ?? "utf-8"));
+		});
+	}
+	const flatSummaryTree = flatSummary.trees?.[0];
+	const sequenceNumber = flatSummaryTree?.sequenceNumber;
+	const snapshotTree = buildHierarchy(flatSummaryTree, treePrefixToRemove);
+
+	return {
+		blobs,
+		snapshotTree,
+		sequenceNumber,
+		id: flatSummary.id,
+	};
+}

package/src/restWrapper.ts

@@ -4,7 +4,7 @@
  */
 
 import { ITelemetryLogger, ITelemetryProperties } from "@fluidframework/common-definitions";
-import { fromUtf8ToBase64, performance } from "@fluidframework/common-utils";
+import { assert, fromUtf8ToBase64, performance } from "@fluidframework/common-utils";
 import { RateLimiter } from "@fluidframework/driver-utils";
 import {
 	getAuthorizationTokenFromCredentials,
@@ -99,11 +99,11 @@ export function getPropsToLogFromResponse(headers: {
 
 export class RouterliciousRestWrapper extends RestWrapper {
 	private readonly restLess = new RestLessClient();
+	private token: ITokenResponse | undefined;
 
 	constructor(
 		logger: ITelemetryLogger,
 		private readonly rateLimiter: RateLimiter,
-		private token: ITokenResponse,
 		private readonly fetchRefreshedToken: TokenFetcher,
 		private readonly getAuthorizationHeader: AuthorizationHeaderGetter,
 		private readonly useRestLess: boolean,
@@ -120,7 +120,7 @@ export class RouterliciousRestWrapper extends RestWrapper {
 	): Promise<IR11sResponse<T>> {
 		const config = {
 			...requestConfig,
-			headers: this.generateHeaders(requestConfig.headers),
+			headers: await this.generateHeaders(requestConfig.headers),
 		};
 
 		const translatedConfig = this.useRestLess ? this.restLess.translate(config) : config;
@@ -199,9 +199,11 @@ export class RouterliciousRestWrapper extends RestWrapper {
 		);
 	}
 
-	private generateHeaders(
+	private async generateHeaders(
 		requestHeaders?: AxiosRequestHeaders | undefined,
-	): Record<string, string> {
+	): Promise<Record<string, string>> {
+		const token = await this.getToken();
+		assert(token !== undefined, 0x679 /* token should be present */);
 		const correlationId = requestHeaders?.["x-correlation-id"] ?? uuid();
 
 		return {
@@ -211,12 +213,17 @@ export class RouterliciousRestWrapper extends RestWrapper {
 			"x-correlation-id": correlationId as string,
 			"x-driver-version": driverVersion,
 			// NOTE: If this.authorizationHeader is undefined, should "Authorization" be removed entirely?
-			"Authorization": this.getAuthorizationHeader(this.token),
+			"Authorization": this.getAuthorizationHeader(token),
 		};
 	}
 
-	public getToken(): ITokenResponse {
-		return this.token;
+	public async getToken(): Promise<ITokenResponse> {
+		if (this.token !== undefined) {
+			return this.token;
+		}
+		const token = await this.fetchRefreshedToken();
+		this.setToken(token);
+		return token;
 	}
 
 	public setToken(token: ITokenResponse) {
@@ -228,7 +235,6 @@ export class RouterliciousStorageRestWrapper extends RouterliciousRestWrapper {
 	private constructor(
 		logger: ITelemetryLogger,
 		rateLimiter: RateLimiter,
-		token: ITokenResponse,
 		fetchToken: TokenFetcher,
 		getAuthorizationHeader: AuthorizationHeaderGetter,
 		useRestLess: boolean,
@@ -238,7 +244,6 @@ export class RouterliciousStorageRestWrapper extends RouterliciousRestWrapper {
 		super(
 			logger,
 			rateLimiter,
-			token,
 			fetchToken,
 			getAuthorizationHeader,
 			useRestLess,
@@ -290,12 +295,9 @@ export class RouterliciousStorageRestWrapper extends RouterliciousRestWrapper {
 			return getAuthorizationTokenFromCredentials(credentials);
 		};
 
-		const storagetoken = await fetchStorageToken();
-
 		const restWrapper = new RouterliciousStorageRestWrapper(
 			logger,
 			rateLimiter,
-			storagetoken,
 			fetchStorageToken,
 			getAuthorizationHeader,
 			useRestLess,
@@ -311,7 +313,6 @@ export class RouterliciousOrdererRestWrapper extends RouterliciousRestWrapper {
 	private constructor(
 		logger: ITelemetryLogger,
 		rateLimiter: RateLimiter,
-		token: ITokenResponse,
 		fetchToken: TokenFetcher,
 		getAuthorizationHeader: AuthorizationHeaderGetter,
 		useRestLess: boolean,
@@ -321,7 +322,6 @@ export class RouterliciousOrdererRestWrapper extends RouterliciousRestWrapper {
 		super(
 			logger,
 			rateLimiter,
-			token,
 			fetchToken,
 			getAuthorizationHeader,
 			useRestLess,
@@ -364,12 +364,9 @@ export class RouterliciousOrdererRestWrapper extends RouterliciousRestWrapper {
 			);
 		};
 
-		const newtoken = await fetchOrdererToken();
-
 		const restWrapper = new RouterliciousOrdererRestWrapper(
 			logger,
 			rateLimiter,
-			newtoken,
 			fetchOrdererToken,
 			getAuthorizationHeader,
 			useRestLess,

package/src/treeUtils.ts

@@ -10,7 +10,7 @@ import {
 	ISummaryTree,
 	SummaryObject,
 } from "@fluidframework/protocol-definitions";
-import { INormalizedWholeSummary } from "@fluidframework/server-services-client";
+import { INormalizedWholeSummary } from "./contracts";
 
 /**
  * Summary tree assembler props

package/src/wholeSummaryDocumentStorageService.ts

@@ -10,7 +10,7 @@ import {
 	stringToBuffer,
 	Uint8ArrayToString,
 } from "@fluidframework/common-utils";
-import { getW3CData } from "@fluidframework/driver-base";
+import { getW3CData, promiseRaceWithWinner } from "@fluidframework/driver-base";
 import {
 	IDocumentStorageService,
 	ISummaryContext,
@@ -23,14 +23,9 @@ import {
 	ISummaryTree,
 	IVersion,
 } from "@fluidframework/protocol-definitions";
-import {
-	convertWholeFlatSummaryToSnapshotTreeAndBlobs,
-	INormalizedWholeSummary,
-	IWholeFlatSummary,
-} from "@fluidframework/server-services-client";
+import { IWholeFlatSummary } from "@fluidframework/server-services-client";
 import { PerformanceEvent } from "@fluidframework/telemetry-utils";
 import { ICache, InMemoryCache } from "./cache";
-import { ISnapshotTreeVersion } from "./definitions";
 import { IRouterliciousDriverPolicies } from "./policies";
 import {
 	convertSnapshotAndBlobsToSummaryTree,
@@ -41,6 +36,8 @@ import { GitManager } from "./gitManager";
 import { WholeSummaryUploadManager } from "./wholeSummaryUploadManager";
 import { ISummaryUploadManager } from "./storageContracts";
 import { IR11sResponse } from "./restWrapper";
+import { INormalizedWholeSummary } from "./contracts";
+import { convertWholeFlatSummaryToSnapshotTreeAndBlobs } from "./r11sSnapshotParser";
 
 const latestSnapshotId: string = "latest";
 
@@ -63,7 +60,7 @@ export class WholeSummaryDocumentStorageService implements IDocumentStorageServi
 		public readonly policies: IDocumentStorageServicePolicies,
 		private readonly driverPolicies?: IRouterliciousDriverPolicies,
 		private readonly blobCache: ICache<ArrayBufferLike> = new InMemoryCache(),
-		private readonly snapshotTreeCache: ICache<ISnapshotTreeVersion> = new InMemoryCache(),
+		private readonly snapshotTreeCache: ICache<INormalizedWholeSummary> = new InMemoryCache(),
 		private readonly noCacheGitManager?: GitManager,
 		private readonly getStorageManager: (
 			disableCache?: boolean,
@@ -86,14 +83,60 @@ export class WholeSummaryDocumentStorageService implements IDocumentStorageServi
 		// If this is the first versions call for the document, we know we will want the latest summary.
 		// Fetch latest summary, cache it, and return its id.
 		if (this.firstVersionsCall && count === 1) {
+			const normalizedSnapshotContents = await PerformanceEvent.timedExecAsync(
+				this.logger,
+				{
+					eventName: "ObtainSnapshot",
+					versionId: versionId ?? undefined,
+					count,
+					enableDiscovery: this.driverPolicies?.enableDiscovery,
+				},
+				async (event) => {
+					let method: string;
+					const cachedSnapshotP = this.snapshotTreeCache.get(
+						this.getCacheKey(latestSnapshotId),
+					);
+
+					const networkSnapshotP = !this.driverPolicies?.enableDiscovery
+						? this.fetchSnapshotTree(latestSnapshotId, false, "getVersions")
+						: this.fetchSnapshotTree(latestSnapshotId, true, "getVersions");
+
+					const promiseRaceWinner = await promiseRaceWithWinner([
+						cachedSnapshotP.catch(() => undefined),
+						networkSnapshotP.catch(() => undefined),
+					]);
+
+					let retrievedSnapshot = promiseRaceWinner.value;
+					method = promiseRaceWinner.index === 0 ? "cache" : "network";
+
+					if (retrievedSnapshot === undefined) {
+						// if network failed -> wait for cache ( then return network failure)
+						// If cache returned empty or failed -> wait for network (success of failure)
+						if (promiseRaceWinner.index === 1) {
+							retrievedSnapshot = await cachedSnapshotP;
+							method = "cache";
+						}
+						if (retrievedSnapshot === undefined) {
+							retrievedSnapshot = await networkSnapshotP;
+							method = "network";
+						}
+					}
+					event.end({
+						method,
+					});
+					return retrievedSnapshot;
+				},
+			);
+
+			const _id = await this.initializeFromSnapshot(
+				normalizedSnapshotContents,
+				latestSnapshotId,
+			);
 			this.firstVersionsCall = false;
-			const { id: _id, snapshotTree } = !this.driverPolicies?.enableDiscovery
-				? await this.fetchAndCacheSnapshotTree(latestSnapshotId, false)
-				: await this.fetchAndCacheSnapshotTree(latestSnapshotId, true);
 			return [
 				{
 					id: _id,
-					treeId: snapshotTree.id!,
+					treeId: normalizedSnapshotContents.snapshotTree.id!,
 				},
 			];
 		}
@@ -130,7 +173,14 @@ export class WholeSummaryDocumentStorageService implements IDocumentStorageServi
 			requestVersion = versions[0];
 		}
 
-		return (await this.fetchAndCacheSnapshotTree(requestVersion.id)).snapshotTree;
+		const normalizedWholeSnapshot = await this.snapshotTreeCache.get(
+			this.getCacheKey(requestVersion.id),
+		);
+		if (normalizedWholeSnapshot !== undefined) {
+			return normalizedWholeSnapshot.snapshotTree;
+		}
+		return (await this.fetchSnapshotTree(requestVersion.id, undefined, "getSnapshotTree"))
+			.snapshotTree;
 	}
 
 	public async readBlob(blobId: string): Promise<ArrayBufferLike> {
@@ -230,25 +280,17 @@ export class WholeSummaryDocumentStorageService implements IDocumentStorageServi
 		);
 	}
 
-	private async fetchAndCacheSnapshotTree(
+	private async fetchSnapshotTree(
 		versionId: string,
 		disableCache?: boolean,
-	): Promise<ISnapshotTreeVersion> {
-		const cachedSnapshotTreeVersion = await this.snapshotTreeCache.get(
-			this.getCacheKey(versionId),
-		);
-		if (cachedSnapshotTreeVersion !== undefined) {
-			return {
-				id: cachedSnapshotTreeVersion.id,
-				snapshotTree: cachedSnapshotTreeVersion.snapshotTree,
-			};
-		}
-
+		scenarioName?: string,
+	): Promise<INormalizedWholeSummary> {
 		const normalizedWholeSummary = await PerformanceEvent.timedExecAsync(
 			this.logger,
 			{
 				eventName: "getWholeFlatSummary",
 				treeId: versionId,
+				scenarioName,
 			},
 			async (event) => {
 				const manager = await this.getStorageManager(disableCache);
@@ -275,33 +317,32 @@ export class WholeSummaryDocumentStorageService implements IDocumentStorageServi
 			},
 		);
 
-		assert(
-			normalizedWholeSummary.snapshotTree.id !== undefined,
-			0x275 /* "Root tree should contain the id" */,
-		);
-		const wholeFlatSummaryId: string = normalizedWholeSummary.snapshotTree.id;
-		const snapshotTreeVersion = {
-			id: wholeFlatSummaryId,
-			snapshotTree: normalizedWholeSummary.snapshotTree,
-		};
+		return normalizedWholeSummary;
+	}
 
+	private async initializeFromSnapshot(
+		normalizedWholeSummary: INormalizedWholeSummary,
+		versionId: string | null,
+	): Promise<string> {
+		const snapshotId = normalizedWholeSummary.id;
+		assert(snapshotId !== undefined, 0x275 /* "Root tree should contain the id" */);
 		const cachePs: Promise<any>[] = [
-			this.snapshotTreeCache.put(this.getCacheKey(wholeFlatSummaryId), snapshotTreeVersion),
+			this.snapshotTreeCache.put(this.getCacheKey(snapshotId), normalizedWholeSummary),
 			this.initBlobCache(normalizedWholeSummary.blobs),
 		];
-		if (wholeFlatSummaryId !== versionId) {
+		if (snapshotId !== versionId && versionId !== null) {
 			// versionId could be "latest". When summarizer checks cache for "latest", we want it to be available.
 			// TODO: For in-memory cache, <latest,snapshotTree> will be a shared pointer with <snapshotId,snapshotTree>,
 			// However, for something like Redis, this will cache the same value twice. Alternatively, could we simply
 			// cache with versionId?
 			cachePs.push(
-				this.snapshotTreeCache.put(this.getCacheKey(versionId), snapshotTreeVersion),
+				this.snapshotTreeCache.put(this.getCacheKey(versionId), normalizedWholeSummary),
 			);
 		}
 
 		await Promise.all(cachePs);
 
-		return snapshotTreeVersion;
+		return snapshotId;
 	}
 
 	private async initBlobCache(blobs: Map<string, ArrayBuffer>): Promise<void> {