@fluidframework/odsp-driver 2.0.0-dev-rc.1.0.0.232845 → 2.0.0-dev-rc.2.0.0.245554

package/lib/{odspDocumentStorageManager.d.mts → odspDocumentStorageManager.d.ts}

@@ -6,12 +6,12 @@ import { ITelemetryLoggerExt } from "@fluidframework/telemetry-utils";
 import * as api from "@fluidframework/protocol-definitions";
 import { ISummaryContext, FetchSource, ISnapshot, ISnapshotFetchOptions } from "@fluidframework/driver-definitions";
 import { IOdspResolvedUrl, InstrumentedStorageTokenFetcher } from "@fluidframework/odsp-driver-definitions";
-import { HostStoragePolicyInternal } from "./contracts.mjs";
-import { SnapshotFormatSupportType } from "./fetchSnapshot.mjs";
-import { IOdspCache } from "./odspCache.mjs";
-import { EpochTracker } from "./epochTracker.mjs";
-import { FlushResult } from "./odspDocumentDeltaConnection.mjs";
-import { OdspDocumentStorageServiceBase } from "./odspDocumentStorageServiceBase.mjs";
+import { HostStoragePolicyInternal } from "./contracts.js";
+import { SnapshotFormatSupportType } from "./fetchSnapshot.js";
+import { IOdspCache } from "./odspCache.js";
+import { EpochTracker } from "./epochTracker.js";
+import { FlushResult } from "./odspDocumentDeltaConnection.js";
+import { OdspDocumentStorageServiceBase } from "./odspDocumentStorageServiceBase.js";
 export declare const defaultSummarizerCacheExpiryTimeout: number;
 export declare class OdspDocumentStorageService extends OdspDocumentStorageServiceBase {
     private readonly odspResolvedUrl;
@@ -27,7 +27,7 @@ export declare class OdspDocumentStorageService extends OdspDocumentStorageServi
     private odspSummaryModuleLoaded;
     private summaryModuleP;
     private odspSummaryUploadManager;
-    private firstVersionCall;
+    private firstSnapshotFetchCall;
     private _isFirstSnapshotFromNetwork;
     private readonly documentId;
     private readonly snapshotUrl;
@@ -46,10 +46,16 @@ export declare class OdspDocumentStorageService extends OdspDocumentStorageServi
     createBlob(file: ArrayBufferLike): Promise<api.ICreateBlobResponse>;
     protected fetchBlobFromStorage(blobId: string, evicted: boolean): Promise<ArrayBuffer>;
     getSnapshotTree(version?: api.IVersion, scenarioName?: string): Promise<api.ISnapshotTree | null>;
+    /**
+     * Fetches and returns the snapshot. If no loadingGroupIds or empty loadingGroupIds is provided, then snapshot for all
+     * ungrouped data will be provided.
+     * @param snapshotFetchOptions - fetch options for snapshot.
+     */
     getSnapshot(snapshotFetchOptions?: ISnapshotFetchOptions): Promise<ISnapshot>;
-    getVersions(blobid: string | null, count: number, scenarioName?: string, fetchSource?: FetchSource): Promise<api.IVersion[]>;
     private fetchSnapshot;
-    private fetchSnapshotCore;
+    getVersions(blobid: string | null, count: number, scenarioName?: string, fetchSource?: FetchSource): Promise<api.IVersion[]>;
+    private fetchSnapshotFromNetwork;
+    private fetchSnapshotFromNetworkCore;
     uploadSummaryWithContext(summary: api.ISummaryTree, context: ISummaryContext): Promise<string>;
     private getDelayLoadedSummaryManager;
     private checkSnapshotUrl;
@@ -57,4 +63,4 @@ export declare class OdspDocumentStorageService extends OdspDocumentStorageServi
     private checkAttachmentGETUrl;
     protected fetchTreeFromSnapshot(id: string, scenarioName?: string): Promise<api.ISnapshotTree | undefined>;
 }
-//# sourceMappingURL=odspDocumentStorageManager.d.mts.map
+//# sourceMappingURL=odspDocumentStorageManager.d.ts.map

package/lib/odspDocumentStorageManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"odspDocumentStorageManager.d.ts","sourceRoot":"","sources":["../src/odspDocumentStorageManager.ts"],"names":[],"mappings":"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"}

package/lib/{odspDocumentStorageManager.mjs → odspDocumentStorageManager.js}

@@ -10,11 +10,11 @@ import { promiseRaceWithWinner } from "@fluidframework/driver-base";
 import { FetchSource, } from "@fluidframework/driver-definitions";
 import { RateLimiter, NonRetryableError } from "@fluidframework/driver-utils";
 import { OdspErrorTypes, getKeyForCacheEntry, } from "@fluidframework/odsp-driver-definitions";
-import { downloadSnapshot, evalBlobsAndTrees, fetchSnapshot, fetchSnapshotWithRedeem, } from "./fetchSnapshot.mjs";
-import { getUrlAndHeadersWithAuth } from "./getUrlAndHeadersWithAuth.mjs";
-import { createCacheSnapshotKey, getWithRetryForTokenRefresh, isInstanceOfISnapshot, } from "./odspUtils.mjs";
-import { pkgVersion as driverVersion } from "./packageVersion.mjs";
-import { OdspDocumentStorageServiceBase } from "./odspDocumentStorageServiceBase.mjs";
+import { downloadSnapshot, evalBlobsAndTrees, fetchSnapshot, fetchSnapshotWithRedeem, } from "./fetchSnapshot.js";
+import { getUrlAndHeadersWithAuth } from "./getUrlAndHeadersWithAuth.js";
+import { createCacheSnapshotKey, getWithRetryForTokenRefresh, isInstanceOfISnapshot, isSnapshotFetchForLoadingGroup, useLegacyFlowWithoutGroupsForSnapshotFetch, } from "./odspUtils.js";
+import { pkgVersion as driverVersion } from "./packageVersion.js";
+import { OdspDocumentStorageServiceBase } from "./odspDocumentStorageServiceBase.js";
 export const defaultSummarizerCacheExpiryTimeout = 60 * 1000; // 60 seconds.
 export class OdspDocumentStorageService extends OdspDocumentStorageServiceBase {
     constructor(odspResolvedUrl, getStorageToken, logger, fetchFullSnapshot, cache, hostPolicy, epochTracker, flushCallback, relayServiceTenantAndSessionId, snapshotFormatFetchType) {
@@ -30,7 +30,7 @@ export class OdspDocumentStorageService extends OdspDocumentStorageServiceBase {
         this.relayServiceTenantAndSessionId = relayServiceTenantAndSessionId;
         this.snapshotFormatFetchType = snapshotFormatFetchType;
         this.odspSummaryModuleLoaded = false;
-        this.firstVersionCall = true;
+        this.firstSnapshotFetchCall = true;
         // Driver specified limits for snapshot size and time.
         /**
          * NOTE: While commit cfff6e3 added restrictions to prevent large payloads, snapshot failures will continue to
@@ -84,7 +84,7 @@ export class OdspDocumentStorageService extends OdspDocumentStorageServiceBase {
                 eventName: "readDataBlob",
                 blobId,
                 evicted,
-                headers: Object.keys(headers).length !== 0 ? true : undefined,
+                headers: Object.keys(headers).length > 0 ? true : undefined,
                 waitQueueLength: this.epochTracker.rateLimiter.waitQueueLength,
             }, async (event) => {
                 const res = await this.epochTracker.fetchArray(url, { headers }, "blob");
@@ -111,14 +111,185 @@ export class OdspDocumentStorageService extends OdspDocumentStorageServiceBase {
     }
     async getSnapshotTree(version, scenarioName) {
         if (!this.snapshotUrl) {
+            // eslint-disable-next-line unicorn/no-null
             return null;
         }
         return super.getSnapshotTree(version, scenarioName);
     }
+    /**
+     * Fetches and returns the snapshot. If no loadingGroupIds or empty loadingGroupIds is provided, then snapshot for all
+     * ungrouped data will be provided.
+     * @param snapshotFetchOptions - fetch options for snapshot.
+     */
     async getSnapshot(snapshotFetchOptions) {
-        assert(this.hostPolicy.supportGetSnapshotApi !== true, "api should not be called yet");
-        // This is just temporary as this api is not yet enabled in service policies.
-        return this.fetchSnapshot(this.hostPolicy.snapshotOptions, snapshotFetchOptions?.scenarioName);
+        // Don't consult cache if request is not for a particular loading group.
+        const { snapshot } = await this.fetchSnapshot({
+            ...snapshotFetchOptions,
+            fetchSource: isSnapshotFetchForLoadingGroup(snapshotFetchOptions?.loadingGroupIds)
+                ? FetchSource.noCache
+                : snapshotFetchOptions?.fetchSource,
+            loadingGroupIds: snapshotFetchOptions?.loadingGroupIds ?? [],
+        });
+        return {
+            ...snapshot,
+            snapshotTree: this.combineProtocolAndAppSnapshotTree(snapshot.snapshotTree),
+        };
+    }
+    async fetchSnapshot(snapshotFetchOptions) {
+        const hostSnapshotOptions = this.hostPolicy.snapshotOptions;
+        const odspSnapshotCacheValue = await PerformanceEvent.timedExecAsync(this.logger, {
+            eventName: isSnapshotFetchForLoadingGroup(snapshotFetchOptions.loadingGroupIds)
+                ? "ObtainSnapshotForGroup"
+                : "ObtainSnapshot",
+            fetchSource: snapshotFetchOptions?.fetchSource,
+        }, async (event) => {
+            const props = {};
+            let cacheLookupTimeInSerialFetch = 0;
+            let retrievedSnapshot;
+            let method;
+            let prefetchWaitStartTime = performance.now();
+            if (snapshotFetchOptions.fetchSource === FetchSource.noCache) {
+                retrievedSnapshot = await this.fetchSnapshotFromNetwork(hostSnapshotOptions, snapshotFetchOptions.loadingGroupIds, snapshotFetchOptions.scenarioName);
+                method = "networkOnly";
+            }
+            else {
+                // Here's the logic to grab the persistent cache snapshot implemented by the host
+                // Epoch tracker is responsible for communicating with the persistent cache, handling epochs and cache versions
+                const cachedSnapshotP = this.epochTracker
+                    .get(createCacheSnapshotKey(this.odspResolvedUrl))
+                    .then(async (
+                // eslint-disable-next-line import/no-deprecated
+                snapshotCachedEntry) => {
+                    if (snapshotCachedEntry !== undefined) {
+                        // If the cached entry does not contain the entry time, then assign it a default of 30 days old.
+                        const age = Date.now() -
+                            (snapshotCachedEntry.cacheEntryTime ??
+                                Date.now() - 30 * 24 * 60 * 60 * 1000);
+                        // In order to decrease the number of times we have to execute a snapshot refresh,
+                        // if this is the summarizer and we have a cache entry but it is past the defaultSummarizerCacheExpiryTimeout,
+                        // force the network retrieval instead as there might be a more recent snapshot available.
+                        // See: https://github.com/microsoft/FluidFramework/issues/8995 for additional information.
+                        if (this.hostPolicy.summarizerClient) {
+                            if (age > defaultSummarizerCacheExpiryTimeout) {
+                                props.cacheSummarizerExpired = true;
+                                return undefined;
+                            }
+                            else {
+                                props.cacheSummarizerExpired = false;
+                            }
+                        }
+                        // Record the cache age
+                        props.cacheEntryAge = age;
+                        // Snapshot from cache could be in older format, so transform that before returning.
+                        if (isInstanceOfISnapshot(snapshotCachedEntry)) {
+                            return snapshotCachedEntry;
+                        }
+                        else {
+                            const snapshot = {
+                                snapshotTree: snapshotCachedEntry.snapshotTree,
+                                blobContents: snapshotCachedEntry.blobs,
+                                ops: snapshotCachedEntry.ops,
+                                latestSequenceNumber: snapshotCachedEntry.latestSequenceNumber,
+                                sequenceNumber: snapshotCachedEntry.sequenceNumber,
+                                snapshotFormatV: 1,
+                            };
+                            return snapshot;
+                        }
+                    }
+                });
+                // Based on the concurrentSnapshotFetch policy:
+                // Either retrieve both the network and cache snapshots concurrently and pick the first to return,
+                // or grab the cache value and then the network value if the cache value returns undefined.
+                // For summarizer which could call this during refreshing of summary parent, always use the cache
+                // first. Also for other clients, if it is not critical path which is determined by firstSnapshotFetchCall,
+                // then also check the cache first.
+                if (this.firstSnapshotFetchCall &&
+                    this.hostPolicy.concurrentSnapshotFetch &&
+                    !this.hostPolicy.summarizerClient) {
+                    const networkSnapshotP = this.fetchSnapshotFromNetwork(hostSnapshotOptions, snapshotFetchOptions.loadingGroupIds, snapshotFetchOptions.scenarioName);
+                    // Ensure that failures on both paths are ignored initially.
+                    // I.e. if cache fails for some reason, we will proceed with network result.
+                    // And vice versa - if (for example) client is offline and network request fails first, we
+                    // do want to attempt to succeed with cached data!
+                    const promiseRaceWinner = await promiseRaceWithWinner([
+                        cachedSnapshotP.catch(() => undefined),
+                        networkSnapshotP.catch(() => undefined),
+                    ]);
+                    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)
+                        try {
+                            if (promiseRaceWinner.index === 1) {
+                                retrievedSnapshot = await cachedSnapshotP;
+                                method = "cache";
+                            }
+                            if (retrievedSnapshot === undefined) {
+                                retrievedSnapshot = await networkSnapshotP;
+                                method = "network";
+                            }
+                        }
+                        catch (error) {
+                            // The call stacks of any errors thrown by cached snapshot or network snapshot aren't very useful:
+                            // they get truncated at this stack frame due to the promise race and how v8 tracks async stack traces--
+                            // see https://v8.dev/docs/stack-trace-api#async-stack-traces and the "zero-cost async stack traces" document
+                            // linked there. https://v8.dev/blog/fast-async#await-under-the-hood may also be helpful for context on internals.
+                            // Regenerating the stack at this level provides more information for logged errors.
+                            // Once FF uses an ES2021 target, we could convert the above promise race to use `Promise.any` + AggregateError and
+                            // get similar quality stacks with less hand-crafted code.
+                            const innerStack = error.stack;
+                            const normalizedError = normalizeError(error);
+                            normalizedError.addTelemetryProperties({ innerStack });
+                            const newStack = `<<STACK TRUNCATED: see innerStack property>> \n${generateStack()}`;
+                            overwriteStack(normalizedError, newStack);
+                            throw normalizedError;
+                        }
+                    }
+                }
+                else {
+                    // Note: There's a race condition here - another caller may come past the undefined check
+                    // while the first caller is awaiting later async code in this block.
+                    const startTime = performance.now();
+                    retrievedSnapshot = await cachedSnapshotP;
+                    cacheLookupTimeInSerialFetch = performance.now() - startTime;
+                    method = retrievedSnapshot === undefined ? "network" : "cache";
+                    if (retrievedSnapshot === undefined) {
+                        prefetchWaitStartTime = performance.now();
+                        retrievedSnapshot = await this.fetchSnapshotFromNetwork(hostSnapshotOptions, snapshotFetchOptions.loadingGroupIds, snapshotFetchOptions.scenarioName);
+                    }
+                }
+            }
+            if (method === "network") {
+                props.cacheEntryAge = undefined;
+            }
+            if (this.firstSnapshotFetchCall) {
+                this._isFirstSnapshotFromNetwork = method === "cache" ? false : true;
+            }
+            const prefetchStartTime = retrievedSnapshot.prefetchStartTime;
+            event.end({
+                ...props,
+                method,
+                fetchSnapshotForInitialLoad: this.firstSnapshotFetchCall,
+                useLegacyFlowWithoutGroups: useLegacyFlowWithoutGroupsForSnapshotFetch(snapshotFetchOptions.loadingGroupIds),
+                avoidPrefetchSnapshotCache: this.hostPolicy.avoidPrefetchSnapshotCache,
+                ...evalBlobsAndTrees(retrievedSnapshot),
+                cacheLookupTimeInSerialFetch,
+                prefetchSavedDuration: prefetchStartTime !== undefined && method !== "cache"
+                    ? prefetchWaitStartTime - prefetchStartTime
+                    : undefined,
+            });
+            return retrievedSnapshot;
+        });
+        const stTime = performance.now();
+        // Don't override ops which were fetched during initial load, since we could still need them.
+        const id = this.initializeFromSnapshot(odspSnapshotCacheValue, this.firstSnapshotFetchCall, snapshotFetchOptions?.cacheSnapshot ?? this.firstSnapshotFetchCall);
+        this.logger.sendTelemetryEvent({
+            eventName: "SnapshotInitializeTime",
+            duration: performance.now() - stTime,
+        }, undefined, LogLevel.verbose);
+        this.firstSnapshotFetchCall = false;
+        return { snapshot: odspSnapshotCacheValue, id };
     }
     async getVersions(
     // eslint-disable-next-line @rushstack/no-new-null
@@ -142,150 +313,12 @@ export class OdspDocumentStorageService extends OdspDocumentStorageServiceBase {
         }
         // If count is one, we can use the trees/latest API, which returns the latest version and trees in a single request for better performance
         if (count === 1 && (blobid === null || blobid === this.documentId)) {
-            const hostSnapshotOptions = this.hostPolicy.snapshotOptions;
-            const odspSnapshotCacheValue = await PerformanceEvent.timedExecAsync(this.logger, { eventName: "ObtainSnapshot", fetchSource }, async (event) => {
-                const props = {};
-                let cacheLookupTimeInSerialFetch = 0;
-                let retrievedSnapshot;
-                let method;
-                let prefetchWaitStartTime = performance.now();
-                if (fetchSource === FetchSource.noCache) {
-                    retrievedSnapshot = await this.fetchSnapshot(hostSnapshotOptions, scenarioName);
-                    method = "networkOnly";
-                }
-                else {
-                    // Here's the logic to grab the persistent cache snapshot implemented by the host
-                    // Epoch tracker is responsible for communicating with the persistent cache, handling epochs and cache versions
-                    const cachedSnapshotP = this.epochTracker
-                        .get(createCacheSnapshotKey(this.odspResolvedUrl))
-                        .then(async (snapshotCachedEntry) => {
-                        if (snapshotCachedEntry !== undefined) {
-                            // If the cached entry does not contain the entry time, then assign it a default of 30 days old.
-                            const age = Date.now() -
-                                (snapshotCachedEntry.cacheEntryTime ??
-                                    Date.now() - 30 * 24 * 60 * 60 * 1000);
-                            // In order to decrease the number of times we have to execute a snapshot refresh,
-                            // if this is the summarizer and we have a cache entry but it is past the defaultSummarizerCacheExpiryTimeout,
-                            // force the network retrieval instead as there might be a more recent snapshot available.
-                            // See: https://github.com/microsoft/FluidFramework/issues/8995 for additional information.
-                            if (this.hostPolicy.summarizerClient) {
-                                if (age > defaultSummarizerCacheExpiryTimeout) {
-                                    props.cacheSummarizerExpired = true;
-                                    return undefined;
-                                }
-                                else {
-                                    props.cacheSummarizerExpired = false;
-                                }
-                            }
-                            // Record the cache age
-                            props.cacheEntryAge = age;
-                            // Snapshot from cache could be in older format, so transform that before returning.
-                            if (isInstanceOfISnapshot(snapshotCachedEntry)) {
-                                return snapshotCachedEntry;
-                            }
-                            else {
-                                const snapshot = {
-                                    snapshotTree: snapshotCachedEntry.snapshotTree,
-                                    blobContents: snapshotCachedEntry.blobs,
-                                    ops: snapshotCachedEntry.ops,
-                                    latestSequenceNumber: snapshotCachedEntry.latestSequenceNumber,
-                                    sequenceNumber: snapshotCachedEntry.sequenceNumber,
-                                    snapshotFormatV: 1,
-                                };
-                                return snapshot;
-                            }
-                        }
-                    });
-                    // Based on the concurrentSnapshotFetch policy:
-                    // Either retrieve both the network and cache snapshots concurrently and pick the first to return,
-                    // or grab the cache value and then the network value if the cache value returns undefined.
-                    // For summarizer which could call this during refreshing of summary parent, always use the cache
-                    // first. Also for other clients, if it is not critical path which is determined by firstVersionCall,
-                    // then also check the cache first.
-                    if (this.firstVersionCall &&
-                        this.hostPolicy.concurrentSnapshotFetch &&
-                        !this.hostPolicy.summarizerClient) {
-                        const networkSnapshotP = this.fetchSnapshot(hostSnapshotOptions, scenarioName);
-                        // Ensure that failures on both paths are ignored initially.
-                        // I.e. if cache fails for some reason, we will proceed with network result.
-                        // And vice versa - if (for example) client is offline and network request fails first, we
-                        // do want to attempt to succeed with cached data!
-                        const promiseRaceWinner = await promiseRaceWithWinner([
-                            cachedSnapshotP.catch(() => undefined),
-                            networkSnapshotP.catch(() => undefined),
-                        ]);
-                        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)
-                            try {
-                                if (promiseRaceWinner.index === 1) {
-                                    retrievedSnapshot = await cachedSnapshotP;
-                                    method = "cache";
-                                }
-                                if (retrievedSnapshot === undefined) {
-                                    retrievedSnapshot = await networkSnapshotP;
-                                    method = "network";
-                                }
-                            }
-                            catch (err) {
-                                // The call stacks of any errors thrown by cached snapshot or network snapshot aren't very useful:
-                                // they get truncated at this stack frame due to the promise race and how v8 tracks async stack traces--
-                                // see https://v8.dev/docs/stack-trace-api#async-stack-traces and the "zero-cost async stack traces" document
-                                // linked there. https://v8.dev/blog/fast-async#await-under-the-hood may also be helpful for context on internals.
-                                // Regenerating the stack at this level provides more information for logged errors.
-                                // Once FF uses an ES2021 target, we could convert the above promise race to use `Promise.any` + AggregateError and
-                                // get similar quality stacks with less hand-crafted code.
-                                const innerStack = err.stack;
-                                const normalizedError = normalizeError(err);
-                                normalizedError.addTelemetryProperties({ innerStack });
-                                const newStack = `<<STACK TRUNCATED: see innerStack property>> \n${generateStack()}`;
-                                overwriteStack(normalizedError, newStack);
-                                throw normalizedError;
-                            }
-                        }
-                    }
-                    else {
-                        // Note: There's a race condition here - another caller may come past the undefined check
-                        // while the first caller is awaiting later async code in this block.
-                        const startTime = performance.now();
-                        retrievedSnapshot = await cachedSnapshotP;
-                        cacheLookupTimeInSerialFetch = performance.now() - startTime;
-                        method = retrievedSnapshot !== undefined ? "cache" : "network";
-                        if (retrievedSnapshot === undefined) {
-                            prefetchWaitStartTime = performance.now();
-                            retrievedSnapshot = await this.fetchSnapshot(hostSnapshotOptions, scenarioName);
-                        }
-                    }
-                }
-                if (method === "network") {
-                    props.cacheEntryAge = undefined;
-                }
-                if (this.firstVersionCall) {
-                    this._isFirstSnapshotFromNetwork = method === "cache" ? false : true;
-                }
-                const prefetchStartTime = retrievedSnapshot.prefetchStartTime;
-                event.end({
-                    ...props,
-                    method,
-                    avoidPrefetchSnapshotCache: this.hostPolicy.avoidPrefetchSnapshotCache,
-                    ...evalBlobsAndTrees(retrievedSnapshot),
-                    cacheLookupTimeInSerialFetch,
-                    prefetchSavedDuration: prefetchStartTime !== undefined && method !== "cache"
-                        ? prefetchWaitStartTime - prefetchStartTime
-                        : undefined,
-                });
-                return retrievedSnapshot;
+            const { id } = await this.fetchSnapshot({
+                cacheSnapshot: true,
+                scenarioName,
+                versionId: blobid ?? undefined,
+                fetchSource,
             });
-            const stTime = performance.now();
-            // Don't override ops which were fetched during initial load, since we could still need them.
-            const id = this.initializeFromSnapshot(odspSnapshotCacheValue, this.firstVersionCall);
-            this.logger.sendTelemetryEvent({
-                eventName: "SnapshotInitializeTime",
-                duration: performance.now() - stTime,
-            }, undefined, LogLevel.verbose);
-            this.firstVersionCall = false;
             return id ? [{ id, treeId: undefined }] : [];
         }
         return getWithRetryForTokenRefresh(async (options) => {
@@ -294,7 +327,7 @@ export class OdspDocumentStorageService extends OdspDocumentStorageServiceBase {
             // Fetch the latest snapshot versions for the document
             const response = await PerformanceEvent.timedExecAsync(this.logger, {
                 eventName: "getVersions",
-                headers: Object.keys(headers).length !== 0 ? true : undefined,
+                headers: Object.keys(headers).length > 0 ? true : undefined,
             }, async () => this.epochTracker.fetchAndParseAsJSON(url, { headers }, "versions", undefined, scenarioName));
             const versionsResponse = response.content;
             if (!versionsResponse) {
@@ -311,22 +344,24 @@ export class OdspDocumentStorageService extends OdspDocumentStorageServiceBase {
             });
         });
     }
-    async fetchSnapshot(hostSnapshotOptions, scenarioName) {
-        return this.fetchSnapshotCore(hostSnapshotOptions, scenarioName).catch((error) => {
+    async fetchSnapshotFromNetwork(hostSnapshotOptions, loadingGroupIds, scenarioName) {
+        return this.fetchSnapshotFromNetworkCore(hostSnapshotOptions, loadingGroupIds, scenarioName).catch((error) => {
             // Issue #5895:
             // If we are offline, this error is retryable. But that means that RetriableDocumentStorageService
             // will run in circles calling getSnapshotTree, which would result in OdspDocumentStorageService class
             // going getVersions / individual blob download path. This path is very slow, and will not work with
             // delay-loaded data stores and ODSP storage deleting old snapshots and blobs.
             if (typeof error === "object" && error !== null) {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
                 error.canRetry = false;
             }
             throw error;
         });
     }
-    async fetchSnapshotCore(hostSnapshotOptions, scenarioName) {
-        // Don't look into cache, if the host specifically tells us so.
-        if (!this.hostPolicy.avoidPrefetchSnapshotCache) {
+    async fetchSnapshotFromNetworkCore(hostSnapshotOptions, loadingGroupIds, scenarioName) {
+        // Don't look into cache, if the host specifically tells us so. Also, if request is
+        // for initial snapshot, don't consult the prefetch cache.
+        if (!this.hostPolicy.avoidPrefetchSnapshotCache && this.firstSnapshotFetchCall) {
             const prefetchCacheKey = getKeyForCacheEntry(createCacheSnapshotKey(this.odspResolvedUrl));
             const result = await this.cache.snapshotPrefetchResultCache
                 ?.get(prefetchCacheKey)
@@ -337,11 +372,11 @@ export class OdspDocumentStorageService extends OdspDocumentStorageServiceBase {
                 await this.epochTracker.validateEpoch(response.fluidEpoch, "treesLatest");
                 return response;
             })
-                .catch(async (err) => {
+                .catch(async (error) => {
                 this.logger.sendTelemetryEvent({
                     eventName: "PrefetchSnapshotError",
                     concurrentSnapshotFetch: this.hostPolicy.concurrentSnapshotFetch,
-                }, err);
+                }, error);
                 return undefined;
             });
             // If the prefetch call, is successful, then return the contents otherwise as backup for now, just
@@ -362,8 +397,8 @@ export class OdspDocumentStorageService extends OdspDocumentStorageServiceBase {
             snapshotOptions.mds = undefined;
             snapshotOptions.timeout = undefined;
         }
-        const snapshotDownloader = async (finalOdspResolvedUrl, storageToken, options, controller) => {
-            return downloadSnapshot(finalOdspResolvedUrl, storageToken, this.logger, options, this.snapshotFormatFetchType, controller, this.epochTracker, scenarioName);
+        const snapshotDownloader = async (finalOdspResolvedUrl, storageToken, loadingGroupId, options, controller) => {
+            return downloadSnapshot(finalOdspResolvedUrl, storageToken, loadingGroupId, options, this.snapshotFormatFetchType, controller, this.epochTracker, scenarioName);
         };
         const putInCache = async (valueWithEpoch) => {
             return this.cache.persistedCache.put(createCacheSnapshotKey(this.odspResolvedUrl), 
@@ -372,10 +407,12 @@ export class OdspDocumentStorageService extends OdspDocumentStorageServiceBase {
         };
         const removeEntries = async () => this.cache.persistedCache.removeEntries();
         try {
-            const odspSnapshot = await fetchSnapshotWithRedeem(this.odspResolvedUrl, this.getStorageToken, snapshotOptions, !!this.hostPolicy.sessionOptions?.forceAccessTokenViaAuthorizationHeader, this.logger, snapshotDownloader, putInCache, removeEntries, this.hostPolicy.enableRedeemFallback);
+            const odspSnapshot = await fetchSnapshotWithRedeem(this.odspResolvedUrl, this.getStorageToken, snapshotOptions, !!this.hostPolicy.sessionOptions?.forceAccessTokenViaAuthorizationHeader, this.logger, snapshotDownloader, putInCache, removeEntries, loadingGroupIds, this.hostPolicy.enableRedeemFallback);
             return odspSnapshot;
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
         }
         catch (error) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
             const errorType = error.errorType;
             // If the snapshot size is too big and the host specified the size limitation(specified in hostSnapshotOptions), then don't try to fetch the snapshot again.
             if (errorType === OdspErrorTypes.snapshotTooBig &&
@@ -389,6 +426,7 @@ export class OdspDocumentStorageService extends OdspDocumentStorageServiceBase {
                 snapshotOptions.blobs) {
                 this.logger.sendErrorEvent({
                     eventName: "TreeLatest_SecondCall",
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
                     errorType,
                 });
                 const snapshotOptionsWithoutBlobs = {
@@ -397,7 +435,7 @@ export class OdspDocumentStorageService extends OdspDocumentStorageServiceBase {
                     mds: undefined,
                     timeout: undefined,
                 };
-                const odspSnapshot = await fetchSnapshotWithRedeem(this.odspResolvedUrl, this.getStorageToken, snapshotOptionsWithoutBlobs, !!this.hostPolicy.sessionOptions?.forceAccessTokenViaAuthorizationHeader, this.logger, snapshotDownloader, putInCache, removeEntries, this.hostPolicy.enableRedeemFallback);
+                const odspSnapshot = await fetchSnapshotWithRedeem(this.odspResolvedUrl, this.getStorageToken, snapshotOptionsWithoutBlobs, !!this.hostPolicy.sessionOptions?.forceAccessTokenViaAuthorizationHeader, this.logger, snapshotDownloader, putInCache, removeEntries, loadingGroupIds, this.hostPolicy.enableRedeemFallback);
                 return odspSnapshot;
             }
             throw error;
@@ -454,7 +492,9 @@ export class OdspDocumentStorageService extends OdspDocumentStorageServiceBase {
     }
     async getDelayLoadedSummaryManager() {
         assert(this.odspSummaryModuleLoaded === false, 0x56f /* Should be loaded only once */);
-        const module = await import("./odspSummaryUploadManager.mjs").then((m) => {
+        const module = await import(
+        /* webpackChunkName: "summaryModule" */ "./odspSummaryUploadManager.js")
+            .then((m) => {
             this.logger.sendTelemetryEvent({ eventName: "SummaryModuleLoaded" });
             return m;
         })
@@ -502,4 +542,4 @@ export class OdspDocumentStorageService extends OdspDocumentStorageServiceBase {
         });
     }
 }
-//# sourceMappingURL=odspDocumentStorageManager.mjs.map
+//# sourceMappingURL=odspDocumentStorageManager.js.map