@fluidframework/container-loader 2.0.0-dev-rc.1.0.0.228517 → 2.0.0-dev-rc.1.0.0.232845

package/dist/container.js

@@ -3,6 +3,9 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Container = exports.ReportIfTooLong = exports.waitContainerToCatchUp = void 0;
 const uuid_1 = require("uuid");
@@ -13,6 +16,7 @@ const container_definitions_1 = require("@fluidframework/container-definitions")
 const driver_utils_1 = require("@fluidframework/driver-utils");
 const protocol_definitions_1 = require("@fluidframework/protocol-definitions");
 const telemetry_utils_1 = require("@fluidframework/telemetry-utils");
+const structured_clone_1 = __importDefault(require("@ungap/structured-clone"));
 const audience_1 = require("./audience");
 const containerContext_1 = require("./containerContext");
 const contracts_1 = require("./contracts");
@@ -27,11 +31,11 @@ const noopHeuristic_1 = require("./noopHeuristic");
 const connectionManager_1 = require("./connectionManager");
 const connectionState_1 = require("./connectionState");
 const protocol_1 = require("./protocol");
+const attachment_1 = require("./attachment");
 const detachedContainerRefSeqNumber = 0;
 const dirtyContainerEvent = "dirty";
 const savedContainerEvent = "saved";
 const packageNotFactoryError = "Code package does not implement IRuntimeFactory";
-const hasBlobsSummaryTree = ".hasAttachmentBlobs";
 /**
  * Waits until container connects to delta storage and gets up-to-date.
  *
@@ -185,11 +189,8 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
     static async rehydrateDetachedFromSnapshot(createProps, snapshot) {
         const container = new Container(createProps);
         return telemetry_utils_1.PerformanceEvent.timedExecAsync(container.mc.logger, { eventName: "RehydrateDetachedFromSnapshot" }, async (_event) => {
-            const deserializedSummary = JSON.parse(snapshot);
-            if (!(0, driver_utils_1.isCombinedAppAndProtocolSummary)(deserializedSummary, hasBlobsSummaryTree)) {
-                throw new telemetry_utils_1.UsageError("Cannot rehydrate detached container. Incorrect format");
-            }
-            await container.rehydrateDetachedFromSnapshot(deserializedSummary);
+            const detachedContainerState = (0, utils_1.getDetachedContainerStateFromSerializedContainer)(snapshot);
+            await container.rehydrateDetachedFromSnapshot(detachedContainerState);
             return container;
         }, { start: true, end: true, cancel: "generic" });
     }
@@ -240,6 +241,9 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
     get readOnlyInfo() {
         return this._deltaManager.readOnlyInfo;
     }
+    get containerMetadata() {
+        return this._containerMetadata;
+    }
     /**
      * Sends signal to runtime (and data stores) to be read-only.
      * Hosts may have read only views, indicating to data stores that no edits are allowed.
@@ -361,24 +365,103 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
          * disposed: Container has been disposed
          */
         this._lifecycleState = "loading";
-        this._attachState = container_definitions_1.AttachState.Detached;
         /** During initialization we pause the inbound queues. We track this state to ensure we only call resume once */
         this.inboundQueuePausedFromInit = true;
         this.firstConnection = true;
         this.connectionTransitionTimes = [];
-        this.attachStarted = false;
         this._dirtyContainer = false;
         this.savedOps = [];
+        this.attachmentData = { state: container_definitions_1.AttachState.Detached };
         this.clientsWhoShouldHaveLeft = new Set();
+        this._containerMetadata = {};
         this.setAutoReconnectTime = client_utils_1.performance.now();
         this._lifecycleEvents = new client_utils_1.TypedEventEmitter();
         this._disposed = false;
+        this.attach = (0, utils_1.runSingle)(async (request, attachProps) => {
+            await telemetry_utils_1.PerformanceEvent.timedExecAsync(this.mc.logger, { eventName: "Attach" }, async () => {
+                if (this._lifecycleState !== "loaded" ||
+                    this.attachmentData.state === container_definitions_1.AttachState.Attached) {
+                    // pre-0.58 error message: containerNotValidForAttach
+                    throw new telemetry_utils_1.UsageError(`The Container is not in a valid state for attach [${this._lifecycleState}] and [${this.attachState}]`);
+                }
+                const normalizeErrorAndClose = (error) => {
+                    const newError = (0, telemetry_utils_1.normalizeError)(error);
+                    this.close(newError);
+                    // add resolved URL on error object so that host has the ability to find this document and delete it
+                    newError.addTelemetryProperties({
+                        resolvedUrl: this.service?.resolvedUrl?.url,
+                    });
+                    return newError;
+                };
+                const setAttachmentData = (attachmentData) => {
+                    const previousState = this.attachmentData.state;
+                    this.attachmentData = attachmentData;
+                    const state = this.attachmentData.state;
+                    if (state !== previousState && state !== container_definitions_1.AttachState.Detached) {
+                        try {
+                            this.runtime.setAttachState(state);
+                            this.emit(state.toLocaleLowerCase());
+                        }
+                        catch (error) {
+                            throw normalizeErrorAndClose(error);
+                        }
+                    }
+                };
+                const createAttachmentSummary = (redirectTable) => {
+                    try {
+                        (0, core_utils_1.assert)(this.deltaManager.inbound.length === 0, 0x0d6 /* "Inbound queue should be empty when attaching" */);
+                        return (0, utils_1.combineAppAndProtocolSummary)(this.runtime.createSummary(redirectTable), this.captureProtocolSummary());
+                    }
+                    catch (error) {
+                        throw normalizeErrorAndClose(error);
+                    }
+                };
+                const createOrGetStorageService = async (summary) => {
+                    // Actually go and create the resolved document
+                    if (this.service === undefined) {
+                        const createNewResolvedUrl = await this.urlResolver.resolve(request);
+                        (0, core_utils_1.assert)(this.client.details.type !== summarizerClientType &&
+                            createNewResolvedUrl !== undefined, 0x2c4 /* "client should not be summarizer before container is created" */);
+                        this.service = await (0, driver_utils_1.runWithRetry)(async () => this.serviceFactory.createContainer(summary, createNewResolvedUrl, this.subLogger, false), "containerAttach", this.mc.logger, {
+                            cancel: this._deltaManager.closeAbortController.signal,
+                        });
+                    }
+                    this.storageAdapter.connectToService(this.service);
+                    return this.storageAdapter;
+                };
+                let attachP = (0, attachment_1.runRetriableAttachProcess)({
+                    initialAttachmentData: this.attachmentData,
+                    offlineLoadEnabled: this.offlineLoadEnabled,
+                    detachedBlobStorage: this.detachedBlobStorage,
+                    setAttachmentData,
+                    createAttachmentSummary,
+                    createOrGetStorageService,
+                });
+                // only enable the new behavior if the config is set
+                if (this.mc.config.getBoolean("Fluid.Container.RetryOnAttachFailure") !== true) {
+                    attachP = attachP.catch((error) => {
+                        throw normalizeErrorAndClose(error);
+                    });
+                }
+                await attachP;
+                if (!this.closed) {
+                    this.handleDeltaConnectionArg({
+                        fetchOpsFromStorage: false,
+                        reason: { text: "createDetached" },
+                    }, attachProps?.deltaConnection);
+                }
+            }, { start: true, end: true, cancel: "generic" });
+        });
         this.getAbsoluteUrl = async (relativeUrl) => {
             if (this.resolvedUrl === undefined) {
                 return undefined;
             }
             return this.urlResolver.getAbsoluteUrl(this.resolvedUrl, relativeUrl, (0, contracts_1.getPackageName)(this._loadedCodeDetails));
         };
+        this.metadataUpdateHandler = (metadata) => {
+            this._containerMetadata = { ...this._containerMetadata, ...metadata };
+            this.emit("metadataUpdate", metadata);
+        };
         this.updateDirtyContainerState = (dirty) => {
             if (this._dirtyContainer === dirty) {
                 return;
@@ -426,7 +509,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                     clientType,
                     containerId: this._containerId,
                     docId: () => this.resolvedUrl?.id,
-                    containerAttachState: () => this._attachState,
+                    containerAttachState: () => this.attachState,
                     containerLifecycleState: () => this._lifecycleState,
                     containerConnectionState: () => connectionState_1.ConnectionState[this.connectionState],
                     serializedContainer: pendingLocalState !== undefined,
@@ -577,6 +660,10 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                         : "generic",
                 }, error);
                 this._lifecycleState = "closing";
+                // Back-compat for Old driver
+                if (this.service?.off !== undefined) {
+                    this.service?.off("metadataUpdate", this.metadataUpdateHandler);
+                }
                 this._protocolHandler?.close();
                 this.connectionStateHandler.dispose();
             }
@@ -664,15 +751,14 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             if (this.closed || this._disposed) {
                 throw new telemetry_utils_1.UsageError("Pending state cannot be retried if the container is closed or disposed");
             }
-            (0, core_utils_1.assert)(this.attachState === container_definitions_1.AttachState.Attached, 0x0d1 /* "Container should be attached before close" */);
+            (0, core_utils_1.assert)(this.attachmentData.state === container_definitions_1.AttachState.Attached, 0x0d1 /* "Container should be attached before close" */);
             (0, core_utils_1.assert)(this.resolvedUrl !== undefined && this.resolvedUrl.type === "fluid", 0x0d2 /* "resolved url should be valid Fluid url" */);
-            (0, core_utils_1.assert)(!!this.baseSnapshot, 0x5d4 /* no base snapshot */);
-            (0, core_utils_1.assert)(!!this.baseSnapshotBlobs, 0x5d5 /* no snapshot blobs */);
+            (0, core_utils_1.assert)(this.attachmentData.snapshot !== undefined, 0x5d5 /* no base data */);
             const pendingRuntimeState = await this.runtime.getPendingLocalState(props);
             const pendingState = {
                 pendingRuntimeState,
-                baseSnapshot: this.baseSnapshot,
-                snapshotBlobs: this.baseSnapshotBlobs,
+                baseSnapshot: this.attachmentData.snapshot.tree,
+                snapshotBlobs: this.attachmentData.snapshot.blobs,
                 savedOps: this.savedOps,
                 url: this.resolvedUrl.url,
                 // no need to save this if there is no pending runtime state
@@ -682,119 +768,21 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         });
     }
     get attachState() {
-        return this._attachState;
+        return this.attachmentData.state;
     }
     serialize() {
         (0, core_utils_1.assert)(this.attachState === container_definitions_1.AttachState.Detached, 0x0d3 /* "Should only be called in detached container" */);
         const appSummary = this.runtime.createSummary();
         const protocolSummary = this.captureProtocolSummary();
         const combinedSummary = (0, utils_1.combineAppAndProtocolSummary)(appSummary, protocolSummary);
-        if (this.detachedBlobStorage && this.detachedBlobStorage.size > 0) {
-            combinedSummary.tree[hasBlobsSummaryTree] = {
-                type: protocol_definitions_1.SummaryType.Blob,
-                content: "true",
-            };
-        }
-        return JSON.stringify(combinedSummary);
-    }
-    async attach(request, attachProps) {
-        await telemetry_utils_1.PerformanceEvent.timedExecAsync(this.mc.logger, { eventName: "Attach" }, async () => {
-            if (this._lifecycleState !== "loaded") {
-                // pre-0.58 error message: containerNotValidForAttach
-                throw new telemetry_utils_1.UsageError(`The Container is not in a valid state for attach [${this._lifecycleState}]`);
-            }
-            // If container is already attached or attach is in progress, throw an error.
-            (0, core_utils_1.assert)(this._attachState === container_definitions_1.AttachState.Detached && !this.attachStarted, 0x205 /* "attach() called more than once" */);
-            this.attachStarted = true;
-            // If attachment blobs were uploaded in detached state we will go through a different attach flow
-            const hasAttachmentBlobs = this.detachedBlobStorage !== undefined && this.detachedBlobStorage.size > 0;
-            try {
-                (0, core_utils_1.assert)(this.deltaManager.inbound.length === 0, 0x0d6 /* "Inbound queue should be empty when attaching" */);
-                let summary;
-                if (!hasAttachmentBlobs) {
-                    // Get the document state post attach - possibly can just call attach but we need to change the
-                    // semantics around what the attach means as far as async code goes.
-                    const appSummary = this.runtime.createSummary();
-                    const protocolSummary = this.captureProtocolSummary();
-                    summary = (0, utils_1.combineAppAndProtocolSummary)(appSummary, protocolSummary);
-                    // Set the state as attaching as we are starting the process of attaching container.
-                    // This should be fired after taking the summary because it is the place where we are
-                    // starting to attach the container to storage.
-                    // Also, this should only be fired in detached container.
-                    this._attachState = container_definitions_1.AttachState.Attaching;
-                    this.runtime.setAttachState(container_definitions_1.AttachState.Attaching);
-                    this.emit("attaching");
-                    if (this.offlineLoadEnabled) {
-                        const snapshot = (0, utils_1.getSnapshotTreeFromSerializedContainer)(summary);
-                        this.baseSnapshot = snapshot;
-                        this.baseSnapshotBlobs =
-                            (0, containerStorageAdapter_1.getBlobContentsFromTreeWithBlobContents)(snapshot);
-                    }
-                }
-                // Actually go and create the resolved document
-                if (this.service === undefined) {
-                    const createNewResolvedUrl = await this.urlResolver.resolve(request);
-                    (0, core_utils_1.assert)(this.client.details.type !== summarizerClientType &&
-                        createNewResolvedUrl !== undefined, 0x2c4 /* "client should not be summarizer before container is created" */);
-                    this.service = await (0, driver_utils_1.runWithRetry)(async () => this.serviceFactory.createContainer(summary, createNewResolvedUrl, this.subLogger, false), "containerAttach", this.mc.logger, {
-                        cancel: this._deltaManager.closeAbortController.signal,
-                    });
-                }
-                this.storageAdapter.connectToService(this.service);
-                if (hasAttachmentBlobs) {
-                    // upload blobs to storage
-                    (0, core_utils_1.assert)(!!this.detachedBlobStorage, 0x24e /* "assertion for type narrowing" */);
-                    // build a table mapping IDs assigned locally to IDs assigned by storage and pass it to runtime to
-                    // support blob handles that only know about the local IDs
-                    const redirectTable = new Map();
-                    // if new blobs are added while uploading, upload them too
-                    while (redirectTable.size < this.detachedBlobStorage.size) {
-                        const newIds = this.detachedBlobStorage
-                            .getBlobIds()
-                            .filter((id) => !redirectTable.has(id));
-                        for (const id of newIds) {
-                            const blob = await this.detachedBlobStorage.readBlob(id);
-                            const response = await this.storageAdapter.createBlob(blob);
-                            redirectTable.set(id, response.id);
-                        }
-                    }
-                    // take summary and upload
-                    const appSummary = this.runtime.createSummary(redirectTable);
-                    const protocolSummary = this.captureProtocolSummary();
-                    summary = (0, utils_1.combineAppAndProtocolSummary)(appSummary, protocolSummary);
-                    this._attachState = container_definitions_1.AttachState.Attaching;
-                    this.runtime.setAttachState(container_definitions_1.AttachState.Attaching);
-                    this.emit("attaching");
-                    if (this.offlineLoadEnabled) {
-                        const snapshot = (0, utils_1.getSnapshotTreeFromSerializedContainer)(summary);
-                        this.baseSnapshot = snapshot;
-                        this.baseSnapshotBlobs =
-                            (0, containerStorageAdapter_1.getBlobContentsFromTreeWithBlobContents)(snapshot);
-                    }
-                    await this.storageAdapter.uploadSummaryWithContext(summary, {
-                        referenceSequenceNumber: 0,
-                        ackHandle: undefined,
-                        proposalHandle: undefined,
-                    });
-                }
-                this._attachState = container_definitions_1.AttachState.Attached;
-                this.runtime.setAttachState(container_definitions_1.AttachState.Attached);
-                this.emit("attached");
-                if (!this.closed) {
-                    this.handleDeltaConnectionArg({
-                        fetchOpsFromStorage: false,
-                        reason: { text: "createDetached" },
-                    }, attachProps?.deltaConnection);
-                }
-            }
-            catch (error) {
-                // add resolved URL on error object so that host has the ability to find this document and delete it
-                const newError = (0, telemetry_utils_1.normalizeError)(error);
-                newError.addTelemetryProperties({ resolvedUrl: this.resolvedUrl?.url });
-                this.close(newError);
-                throw newError;
-            }
-        }, { start: true, end: true, cancel: "generic" });
+        const { tree: snapshot, blobs } = (0, utils_1.getSnapshotTreeAndBlobsFromSerializedContainer)(combinedSummary);
+        const detachedContainerState = {
+            attached: false,
+            baseSnapshot: snapshot,
+            snapshotBlobs: blobs,
+            hasAttachmentBlobs: !!this.detachedBlobStorage && this.detachedBlobStorage.size > 0,
+        };
+        return JSON.stringify(detachedContainerState);
     }
     setAutoReconnectInternal(mode, reason) {
         const currentMode = this._deltaManager.connectionManager.reconnectMode;
@@ -816,7 +804,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         if (this.closed) {
             throw new telemetry_utils_1.UsageError(`The Container is closed and cannot be connected`);
         }
-        else if (this._attachState !== container_definitions_1.AttachState.Attached) {
+        else if (this.attachState !== container_definitions_1.AttachState.Attached) {
             throw new telemetry_utils_1.UsageError(`The Container is not attached and cannot be connected`);
         }
         else if (!this.connected) {
@@ -831,7 +819,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
     }
     connectInternal(args) {
         (0, core_utils_1.assert)(!this.closed, 0x2c5 /* "Attempting to connect() a closed Container" */);
-        (0, core_utils_1.assert)(this._attachState === container_definitions_1.AttachState.Attached, 0x2c6 /* "Attempting to connect() a container that is not attached" */);
+        (0, core_utils_1.assert)(this.attachState === container_definitions_1.AttachState.Attached, 0x2c6 /* "Attempting to connect() a container that is not attached" */);
         // Resume processing ops and connect to delta stream
         this.resumeInternal(args);
         // Set Auto Reconnect Mode
@@ -935,6 +923,14 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         }
         this._deltaManager.connect(args);
     }
+    async createDocumentService(serviceProvider) {
+        const service = await serviceProvider();
+        // Back-compat for Old driver
+        if (service.on !== undefined) {
+            service.on("metadataUpdate", this.metadataUpdateHandler);
+        }
+        return service;
+    }
     /**
      * Load container.
      *
@@ -942,7 +938,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
      */
     async load(specifiedVersion, loadMode, resolvedUrl, pendingLocalState, loadToSequenceNumber) {
         const timings = { phase1: client_utils_1.performance.now() };
-        this.service = await this.serviceFactory.createDocumentService(resolvedUrl, this.subLogger, this.client.details.type === summarizerClientType);
+        this.service = await this.createDocumentService(async () => this.serviceFactory.createDocumentService(resolvedUrl, this.subLogger, this.client.details.type === summarizerClientType));
         // Except in cases where it has stashed ops or 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
@@ -959,25 +955,37 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             this.connectToDeltaStream(connectionArgs);
         }
         this.storageAdapter.connectToService(this.service);
-        this._attachState = container_definitions_1.AttachState.Attached;
+        this.attachmentData = {
+            state: container_definitions_1.AttachState.Attached,
+        };
         timings.phase2 = client_utils_1.performance.now();
         // Fetch specified snapshot.
         const { snapshot, versionId } = pendingLocalState === undefined
-            ? await this.fetchSnapshotTree(specifiedVersion)
+            ? await this.fetchSnapshot(specifiedVersion)
             : { snapshot: pendingLocalState.baseSnapshot, versionId: undefined };
+        const snapshotTree = (0, driver_utils_1.isInstanceOfISnapshot)(snapshot)
+            ? snapshot.snapshotTree
+            : snapshot;
         if (pendingLocalState) {
-            this.baseSnapshot = pendingLocalState.baseSnapshot;
-            this.baseSnapshotBlobs = pendingLocalState.snapshotBlobs;
+            this.attachmentData = {
+                state: container_definitions_1.AttachState.Attached,
+                snapshot: {
+                    tree: pendingLocalState.baseSnapshot,
+                    blobs: pendingLocalState.snapshotBlobs,
+                },
+            };
         }
         else {
-            (0, core_utils_1.assert)(snapshot !== undefined, 0x237 /* "Snapshot should exist" */);
+            (0, core_utils_1.assert)(snapshotTree !== undefined, 0x237 /* "Snapshot should exist" */);
             if (this.offlineLoadEnabled) {
-                this.baseSnapshot = snapshot;
-                // Save contents of snapshot now, otherwise closeAndGetPendingLocalState() must be async
-                this.baseSnapshotBlobs = await (0, containerStorageAdapter_1.getBlobContentsFromTree)(snapshot, this.storageAdapter);
+                const blobs = await (0, containerStorageAdapter_1.getBlobContentsFromTree)(snapshotTree, this.storageAdapter);
+                this.attachmentData = {
+                    state: container_definitions_1.AttachState.Attached,
+                    snapshot: { tree: snapshotTree, blobs },
+                };
             }
         }
-        const attributes = await this.getDocumentAttributes(this.storageAdapter, snapshot);
+        const attributes = await this.getDocumentAttributes(this.storageAdapter, snapshotTree);
         // If we saved ops, we will replay them and don't need DeltaManager to fetch them
         const sequenceNumber = pendingLocalState?.savedOps[pendingLocalState.savedOps.length - 1]?.sequenceNumber;
         const dmAttributes = sequenceNumber !== undefined ? { ...attributes, sequenceNumber } : attributes;
@@ -1042,12 +1050,12 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         }
         // ...load in the existing quorum
         // Initialize the protocol handler
-        await this.initializeProtocolStateFromSnapshot(attributes, this.storageAdapter, snapshot);
+        await this.initializeProtocolStateFromSnapshot(attributes, this.storageAdapter, snapshotTree);
         timings.phase3 = client_utils_1.performance.now();
         const codeDetails = this.getCodeDetailsFromQuorum();
-        await this.instantiateRuntime(codeDetails, snapshot, 
+        await this.instantiateRuntime(codeDetails, snapshotTree, 
         // give runtime a dummy value so it knows we're loading from a stash blob
-        pendingLocalState ? pendingLocalState?.pendingRuntimeState ?? {} : undefined);
+        pendingLocalState ? pendingLocalState?.pendingRuntimeState ?? {} : undefined, (0, driver_utils_1.isInstanceOfISnapshot)(snapshot) ? snapshot : undefined);
         // replay saved ops
         if (pendingLocalState) {
             for (const message of pendingLocalState.savedOps) {
@@ -1123,18 +1131,16 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         await this.instantiateRuntime(codeDetails, undefined);
         this.setLoaded();
     }
-    async rehydrateDetachedFromSnapshot(detachedContainerSnapshot) {
-        if (detachedContainerSnapshot.tree[hasBlobsSummaryTree] !== undefined) {
+    async rehydrateDetachedFromSnapshot({ attached, baseSnapshot, snapshotBlobs, hasAttachmentBlobs, }) {
+        if (hasAttachmentBlobs) {
             (0, core_utils_1.assert)(!!this.detachedBlobStorage && this.detachedBlobStorage.size > 0, 0x250 /* "serialized container with attachment blobs must be rehydrated with detached blob storage" */);
-            // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
-            delete detachedContainerSnapshot.tree[hasBlobsSummaryTree];
         }
-        const snapshotTree = (0, utils_1.getSnapshotTreeFromSerializedContainer)(detachedContainerSnapshot);
-        this.storageAdapter.loadSnapshotForRehydratingContainer(snapshotTree);
-        const attributes = await this.getDocumentAttributes(this.storageAdapter, snapshotTree);
+        const snapshotTreeWithBlobContents = (0, utils_1.combineSnapshotTreeAndSnapshotBlobs)(baseSnapshot, snapshotBlobs);
+        this.storageAdapter.loadSnapshotFromSnapshotBlobs(snapshotBlobs);
+        const attributes = await this.getDocumentAttributes(this.storageAdapter, snapshotTreeWithBlobContents);
         await this.attachDeltaManagerOpHandler(attributes);
         // Initialize the protocol handler
-        const baseTree = (0, utils_1.getProtocolSnapshotTree)(snapshotTree);
+        const baseTree = (0, utils_1.getProtocolSnapshotTree)(snapshotTreeWithBlobContents);
         const qValues = await (0, driver_utils_1.readAndParse)(this.storageAdapter, baseTree.blobs.quorumValues);
         this.initializeProtocolState(attributes, {
             members: [],
@@ -1142,7 +1148,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             values: qValues,
         });
         const codeDetails = this.getCodeDetailsFromQuorum();
-        await this.instantiateRuntime(codeDetails, snapshotTree);
+        await this.instantiateRuntime(codeDetails, snapshotTreeWithBlobContents);
         this.setLoaded();
     }
     async getDocumentAttributes(storage, tree) {
@@ -1243,7 +1249,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         return pkg;
     }
     static setupClient(containerId, options, clientDetailsOverride) {
-        const loaderOptionsClient = structuredClone(options?.client);
+        const loaderOptionsClient = (0, structured_clone_1.default)(options?.client);
         const client = loaderOptionsClient !== undefined
             ? loaderOptionsClient
             : {
@@ -1516,7 +1522,29 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         }
         return { snapshot, versionId: version?.id };
     }
-    async instantiateRuntime(codeDetails, snapshot, pendingLocalState) {
+    async fetchSnapshot(specifiedVersion) {
+        if (this.mc.config.getBoolean("Fluid.Container.FetchSnapshotUsingGetSnapshotApi") ===
+            true &&
+            this.service?.policies?.supportGetSnapshotApi === true) {
+            const snapshot = await this.storageAdapter.getSnapshot({
+                versionId: specifiedVersion,
+            });
+            const version = {
+                id: snapshot.snapshotTree.id ?? "",
+                treeId: snapshot.snapshotTree.id ?? "",
+            };
+            this._loadedFromVersion = version;
+            if (snapshot === undefined && specifiedVersion !== undefined) {
+                this.mc.logger.sendErrorEvent({
+                    eventName: "getSnapshotTreeFailed",
+                    id: version.id,
+                });
+            }
+            return { snapshot, versionId: version.id };
+        }
+        return this.fetchSnapshotTree(specifiedVersion);
+    }
+    async instantiateRuntime(codeDetails, snapshotTree, pendingLocalState, snapshot) {
         (0, core_utils_1.assert)(this._runtime?.disposed !== false, 0x0dd /* "Existing runtime not disposed" */);
         // The relative loader will proxy requests to '/' to the loader itself assuming no non-cache flags
         // are set. Global requests will still go directly to the loader
@@ -1537,8 +1565,8 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         }
         const getSpecifiedCodeDetails = () => (this.protocolHandler.quorum.get("code") ??
             this.protocolHandler.quorum.get("code2"));
-        const existing = snapshot !== undefined;
-        const context = new containerContext_1.ContainerContext(this.options, this.scope, snapshot, this._loadedFromVersion, this._deltaManager, this.storageAdapter, this.protocolHandler.quorum, this.protocolHandler.audience, loader, (type, contents, batch, metadata) => this.submitContainerMessage(type, contents, batch, metadata), (summaryOp, referenceSequenceNumber) => this.submitSummaryMessage(summaryOp, referenceSequenceNumber), (batch, referenceSequenceNumber) => this.submitBatch(batch, referenceSequenceNumber), (content, targetClientId) => this.submitSignal(content, targetClientId), (error) => this.dispose(error), (error) => this.close(error), this.updateDirtyContainerState, this.getAbsoluteUrl, () => this.resolvedUrl?.id, () => this.clientId, () => this.attachState, () => this.connected, getSpecifiedCodeDetails, this._deltaManager.clientDetails, existing, this.subLogger, pendingLocalState);
+        const existing = snapshotTree !== undefined;
+        const context = new containerContext_1.ContainerContext(this.options, this.scope, snapshotTree, this._loadedFromVersion, this._deltaManager, this.storageAdapter, this.protocolHandler.quorum, this.protocolHandler.audience, loader, (type, contents, batch, metadata) => this.submitContainerMessage(type, contents, batch, metadata), (summaryOp, referenceSequenceNumber) => this.submitSummaryMessage(summaryOp, referenceSequenceNumber), (batch, referenceSequenceNumber) => this.submitBatch(batch, referenceSequenceNumber), (content, targetClientId) => this.submitSignal(content, targetClientId), (error) => this.dispose(error), (error) => this.close(error), this.updateDirtyContainerState, this.getAbsoluteUrl, () => this.resolvedUrl?.id, () => this.clientId, () => this.attachState, () => this.connected, getSpecifiedCodeDetails, this._deltaManager.clientDetails, existing, this.subLogger, pendingLocalState, snapshot);
         this._runtime = await telemetry_utils_1.PerformanceEvent.timedExecAsync(this.subLogger, { eventName: "InstantiateRuntime" }, async () => runtimeFactory.instantiateRuntime(context, existing));
         this._lifecycleEvents.emit("runtimeInstantiated");
         this._loadedCodeDetails = codeDetails;