@fluidframework/container-loader 2.0.0-dev.3.1.0.125672 → 2.0.0-dev.4.1.0.148229

package/dist/container.js

@@ -127,9 +127,15 @@ async function ReportIfTooLong(logger, eventName, action) {
 }
 exports.ReportIfTooLong = ReportIfTooLong;
 const summarizerClientType = "summarizer";
+/**
+ * @deprecated - In the next release Container will no longer be exported, IContainer should be used in its place.
+ */
 class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
+    /**
+     * @internal
+     */
     constructor(loader, config, protocolHandlerBuilder) {
-        var _a, _b;
+        var _a, _b, _c;
         super((name, error) => {
             this.mc.logger.sendErrorEvent({
                 eventName: "ContainerEventHandlerException",
@@ -165,6 +171,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         this.messageCountAfterDisconnection = 0;
         this.attachStarted = false;
         this._dirtyContainer = false;
+        this.savedOps = [];
         this.setAutoReconnectTime = common_utils_1.performance.now();
         this._disposed = false;
         this.clientDetailsOverride = config.clientDetailsOverride;
@@ -203,15 +210,14 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                 dmLastMsqSeqNumber: () => { var _a, _b; return (_b = (_a = this.deltaManager) === null || _a === void 0 ? void 0 : _a.lastMessage) === null || _b === void 0 ? void 0 : _b.sequenceNumber; },
                 dmLastMsqSeqTimestamp: () => { var _a, _b; return (_b = (_a = this.deltaManager) === null || _a === void 0 ? void 0 : _a.lastMessage) === null || _b === void 0 ? void 0 : _b.timestamp; },
                 dmLastMsqSeqClientId: () => { var _a, _b; return (_b = (_a = this.deltaManager) === null || _a === void 0 ? void 0 : _a.lastMessage) === null || _b === void 0 ? void 0 : _b.clientId; },
+                dmLastMsgClientSeq: () => { var _a, _b; return (_b = (_a = this.deltaManager) === null || _a === void 0 ? void 0 : _a.lastMessage) === null || _b === void 0 ? void 0 : _b.clientSequenceNumber; },
                 connectionStateDuration: () => common_utils_1.performance.now() - this.connectionTransitionTimes[this.connectionState],
             },
         });
         // Prefix all events in this file with container-loader
         this.mc = (0, telemetry_utils_1.loggerToMonitoringContext)(telemetry_utils_1.ChildLogger.create(this.subLogger, "Container"));
-        const summarizeProtocolTree = (_a = this.mc.config.getBoolean("Fluid.Container.summarizeProtocolTree2")) !== null && _a !== void 0 ? _a : this.loader.services.options.summarizeProtocolTree;
-        this.options = Object.assign(Object.assign({}, this.loader.services.options), { summarizeProtocolTree });
+        this.options = Object.assign({}, this.loader.services.options);
         this._deltaManager = this.createDeltaManager();
-        this._clientId = (_b = config.serializedContainerState) === null || _b === void 0 ? void 0 : _b.clientId;
         this.connectionStateHandler = (0, connectionStateHandler_1.createConnectionStateHandler)({
             logger: this.mc.logger,
             connectionStateChanged: (value, oldState, reason) => {
@@ -250,13 +256,20 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                     this.connect();
                 }
             },
-        }, this.deltaManager, this._clientId);
+        }, this.deltaManager, (_a = config.serializedContainerState) === null || _a === void 0 ? void 0 : _a.clientId);
         this.on(savedContainerEvent, () => {
             this.connectionStateHandler.containerSaved();
         });
-        this.storageService = new containerStorageAdapter_1.ContainerStorageAdapter(this.loader.services.detachedBlobStorage, this.mc.logger, this.options.summarizeProtocolTree === true
-            ? () => this.captureProtocolSummary()
-            : undefined);
+        // We expose our storage publicly, so it's possible others may call uploadSummaryWithContext() with a
+        // non-combined summary tree (in particular, ContainerRuntime.submitSummary).  We'll intercept those calls
+        // using this callback and fix them up.
+        const addProtocolSummaryIfMissing = (summaryTree) => (0, driver_utils_1.isCombinedAppAndProtocolSummary)(summaryTree) === true
+            ? summaryTree
+            : (0, driver_utils_1.combineAppAndProtocolSummary)(summaryTree, this.captureProtocolSummary());
+        // Whether the combined summary tree has been forced on by either the loader option or the monitoring context.
+        // Even if not forced on via this flag, combined summaries may still be enabled by service policy.
+        const forceEnableSummarizeProtocolTree = (_b = this.mc.config.getBoolean("Fluid.Container.summarizeProtocolTree2")) !== null && _b !== void 0 ? _b : this.loader.services.options.summarizeProtocolTree;
+        this.storageAdapter = new containerStorageAdapter_1.ContainerStorageAdapter(this.loader.services.detachedBlobStorage, this.mc.logger, (_c = config.serializedContainerState) === null || _c === void 0 ? void 0 : _c.snapshotBlobs, addProtocolSummaryIfMissing, forceEnableSummarizeProtocolTree);
         const isDomAvailable = typeof document === "object" &&
             document !== null &&
             typeof document.addEventListener === "function" &&
@@ -277,45 +290,10 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             };
             document.addEventListener("visibilitychange", this.visibilityEventHandler);
         }
-        // We observed that most users of platform do not check Container.connected event on load, causing bugs.
-        // As such, we are raising events when new listener pops up.
-        // Note that we can raise both "disconnected" & "connect" events at the same time,
-        // if we are in connecting stage.
-        this.on("newListener", (event, listener) => {
-            // Fire events on the end of JS turn, giving a chance for caller to be in consistent state.
-            Promise.resolve()
-                .then(() => {
-                switch (event) {
-                    case dirtyContainerEvent:
-                        if (this._dirtyContainer) {
-                            listener();
-                        }
-                        break;
-                    case savedContainerEvent:
-                        if (!this._dirtyContainer) {
-                            listener();
-                        }
-                        break;
-                    case telemetry_utils_1.connectedEventName:
-                        if (this.connected) {
-                            listener(this.clientId);
-                        }
-                        break;
-                    case telemetry_utils_1.disconnectedEventName:
-                        if (!this.connected) {
-                            listener();
-                        }
-                        break;
-                    default:
-                }
-            })
-                .catch((error) => {
-                this.mc.logger.sendErrorEvent({ eventName: "RaiseConnectedEventError" }, error);
-            });
-        });
     }
     /**
      * Load an existing container.
+     * @internal
      */
     static async load(loader, loadOptions, pendingLocalState, protocolHandlerBuilder) {
         const container = new Container(loader, {
@@ -393,7 +371,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             this._lifecycleState === "disposed");
     }
     get storage() {
-        return this.storageService;
+        return this.storageAdapter;
     }
     get context() {
         if (this._context === undefined) {
@@ -464,6 +442,12 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
     get clientDetails() {
         return this._deltaManager.clientDetails;
     }
+    get offlineLoadEnabled() {
+        var _a;
+        // summarizer will not have any pending state we want to save
+        return (((_a = this.mc.config.getBoolean("Fluid.Container.enableOfflineLoad")) !== null && _a !== void 0 ? _a : false) &&
+            this.clientDetails.capabilities.interactive);
+    }
     /**
      * Get the code details that are currently specified for the container.
      * @returns The current code details if any are specified, undefined if none are specified.
@@ -506,6 +490,38 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
     get codeLoader() {
         return this.loader.services.codeLoader;
     }
+    /**
+     * {@inheritDoc @fluidframework/container-definitions#IContainer.entryPoint}
+     */
+    async getEntryPoint() {
+        var _a, _b;
+        // Only the disposing/disposed lifecycle states should prevent access to the entryPoint; closing/closed should still
+        // allow it since they mean a kind of read-only state for the Container.
+        // Note that all 4 are lifecycle states but only 'closed' and 'disposed' are emitted as events.
+        if (this._lifecycleState === "disposing" || this._lifecycleState === "disposed") {
+            throw new container_utils_1.UsageError("The container is disposing or disposed");
+        }
+        while (this._context === undefined) {
+            await new Promise((resolve, reject) => {
+                const contextChangedHandler = () => {
+                    resolve();
+                    this.off("disposed", disposedHandler);
+                };
+                const disposedHandler = (error) => {
+                    reject(error !== null && error !== void 0 ? error : "The Container is disposed");
+                    this.off("contextChanged", contextChangedHandler);
+                };
+                this.once("contextChanged", contextChangedHandler);
+                this.once("disposed", disposedHandler);
+            });
+            // The Promise above should only resolve (vs reject) if the 'contextChanged' event was emitted and that
+            // should have set this._context; making sure.
+            (0, common_utils_1.assert)(this._context !== undefined, 0x5a2 /* Context still not defined after contextChanged event */);
+        }
+        // Disable lint rule for the sake of more complete stack traces
+        // eslint-disable-next-line no-return-await
+        return await ((_b = (_a = this._context).getEntryPoint) === null || _b === void 0 ? void 0 : _b.call(_a));
+    }
     /**
      * Retrieves the quorum associated with the document
      */
@@ -536,15 +552,19 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             try {
                 // Raise event first, to ensure we capture _lifecycleState before transition.
                 // This gives us a chance to know what errors happened on open vs. on fully loaded container.
+                // Log generic events instead of error events if container is in loading state, as most errors are not really FF errors
+                // which can pollute telemetry for real bugs
                 this.mc.logger.sendTelemetryEvent({
                     eventName: "ContainerClose",
-                    category: error === undefined ? "generic" : "error",
+                    category: this._lifecycleState !== "loading" && error !== undefined
+                        ? "error"
+                        : "generic",
                 }, error);
                 this._lifecycleState = "closing";
                 (_a = this._protocolHandler) === null || _a === void 0 ? void 0 : _a.close();
                 this.connectionStateHandler.dispose();
                 (_b = this._context) === null || _b === void 0 ? void 0 : _b.dispose(error !== undefined ? new Error(error.message) : undefined);
-                this.storageService.dispose();
+                this.storageAdapter.dispose();
                 // Notify storage about critical errors. They may be due to disconnect between client & server knowledge
                 // about file, like file being overwritten in storage, but client having stale local cache.
                 // Driver need to ensure all caches are cleared on critical errors
@@ -573,7 +593,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                 // This gives us a chance to know what errors happened on open vs. on fully loaded container.
                 this.mc.logger.sendTelemetryEvent({
                     eventName: "ContainerDispose",
-                    category: error === undefined ? "generic" : "error",
+                    category: "generic",
                 }, error);
                 // ! Progressing from "closed" to "disposing" is not allowed
                 if (this._lifecycleState !== "closed") {
@@ -582,7 +602,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                 (_a = this._protocolHandler) === null || _a === void 0 ? void 0 : _a.close();
                 this.connectionStateHandler.dispose();
                 (_b = this._context) === null || _b === void 0 ? void 0 : _b.dispose(error !== undefined ? new Error(error.message) : undefined);
-                this.storageService.dispose();
+                this.storageAdapter.dispose();
                 // Notify storage about critical errors. They may be due to disconnect between client & server knowledge
                 // about file, like file being overwritten in storage, but client having stale local cache.
                 // Driver need to ensure all caches are cleared on critical errors
@@ -605,14 +625,21 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         // runtime matches pending ops to successful ones by clientId and client seq num, so we need to close the
         // container at the same time we get pending state, otherwise this container could reconnect and resubmit with
         // a new clientId and a future container using stale pending state without the new clientId would resubmit them
+        if (!this.offlineLoadEnabled) {
+            throw new container_utils_1.UsageError("Can't get pending local state unless offline load is enabled");
+        }
         (0, common_utils_1.assert)(this.attachState === container_definitions_1.AttachState.Attached, 0x0d1 /* "Container should be attached before close" */);
         (0, common_utils_1.assert)(this.resolvedUrl !== undefined && this.resolvedUrl.type === "fluid", 0x0d2 /* "resolved url should be valid Fluid url" */);
         (0, common_utils_1.assert)(!!this._protocolHandler, 0x2e3 /* "Must have a valid protocol handler instance" */);
         (0, common_utils_1.assert)(this._protocolHandler.attributes.term !== undefined, 0x37e /* Must have a valid protocol handler instance */);
+        (0, common_utils_1.assert)(!!this.baseSnapshot, "no base snapshot");
+        (0, common_utils_1.assert)(!!this.baseSnapshotBlobs, "no snapshot blobs");
         const pendingState = {
             pendingRuntimeState: this.context.getPendingLocalState(),
+            baseSnapshot: this.baseSnapshot,
+            snapshotBlobs: this.baseSnapshotBlobs,
+            savedOps: this.savedOps,
             url: this.resolvedUrl.url,
-            protocol: this.protocolHandler.getProtocolState(),
             term: this._protocolHandler.attributes.term,
             clientId: this.clientId,
         };
@@ -665,7 +692,13 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                     // starting to attach the container to storage.
                     // Also, this should only be fired in detached container.
                     this._attachState = container_definitions_1.AttachState.Attaching;
-                    this.context.notifyAttaching((0, utils_1.getSnapshotTreeFromSerializedContainer)(summary));
+                    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
                 const createNewResolvedUrl = await this.urlResolver.resolve(request);
@@ -679,7 +712,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                 const resolvedUrl = this.service.resolvedUrl;
                 (0, driver_utils_1.ensureFluidResolvedUrl)(resolvedUrl);
                 this._resolvedUrl = resolvedUrl;
-                await this.storageService.connectToService(this.service);
+                await this.storageAdapter.connectToService(this.service);
                 if (hasAttachmentBlobs) {
                     // upload blobs to storage
                     (0, common_utils_1.assert)(!!this.loader.services.detachedBlobStorage, 0x24e /* "assertion for type narrowing" */);
@@ -693,7 +726,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                             .filter((id) => !redirectTable.has(id));
                         for (const id of newIds) {
                             const blob = await this.loader.services.detachedBlobStorage.readBlob(id);
-                            const response = await this.storageService.createBlob(blob);
+                            const response = await this.storageAdapter.createBlob(blob);
                             redirectTable.set(id, response.id);
                         }
                     }
@@ -702,8 +735,14 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                     const protocolSummary = this.captureProtocolSummary();
                     summary = (0, driver_utils_1.combineAppAndProtocolSummary)(appSummary, protocolSummary);
                     this._attachState = container_definitions_1.AttachState.Attaching;
-                    this.context.notifyAttaching((0, utils_1.getSnapshotTreeFromSerializedContainer)(summary));
-                    await this.storageService.uploadSummaryWithContext(summary, {
+                    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,
@@ -838,7 +877,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         (_a = this.dispose) === null || _a === void 0 ? void 0 : _a.call(this, error);
     }
     async getVersion(version) {
-        const versions = await this.storageService.getVersions(version, 1);
+        const versions = await this.storageAdapter.getVersions(version, 1);
         return versions[0];
     }
     recordConnectStartTime() {
@@ -860,6 +899,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
      * @param specifiedVersion - Version SHA to load snapshot. If not specified, will fetch the latest snapshot.
      */
     async load(specifiedVersion, loadMode, pendingLocalState) {
+        var _a;
         if (this._resolvedUrl === undefined) {
             throw new Error("Attempting to load without a resolved url");
         }
@@ -880,15 +920,15 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         };
         // Start websocket connection as soon as possible. Note that there is no op handler attached yet, but the
         // DeltaManager is resilient to this and will wait to start processing ops until after it is attached.
-        if (loadMode.deltaConnection === undefined) {
+        if (loadMode.deltaConnection === undefined && !pendingLocalState) {
             this.connectToDeltaStream(connectionArgs);
         }
         if (!pendingLocalState) {
-            await this.storageService.connectToService(this.service);
+            await this.storageAdapter.connectToService(this.service);
         }
         else {
             // if we have pendingLocalState we can load without storage; don't wait for connection
-            this.storageService.connectToService(this.service).catch((error) => {
+            this.storageAdapter.connectToService(this.service).catch((error) => {
                 var _a;
                 this.close(error);
                 (_a = this.dispose) === null || _a === void 0 ? void 0 : _a.call(this, error);
@@ -898,15 +938,23 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         // Fetch specified snapshot.
         const { snapshot, versionId } = pendingLocalState === undefined
             ? await this.fetchSnapshotTree(specifiedVersion)
-            : { snapshot: undefined, versionId: undefined };
-        (0, common_utils_1.assert)(snapshot !== undefined || pendingLocalState !== undefined, 0x237 /* "Snapshot should exist" */);
-        const attributes = pendingLocalState === undefined
-            ? await this.getDocumentAttributes(this.storageService, snapshot)
-            : {
-                sequenceNumber: pendingLocalState.protocol.sequenceNumber,
-                minimumSequenceNumber: pendingLocalState.protocol.minimumSequenceNumber,
-                term: pendingLocalState.term,
-            };
+            : { snapshot: pendingLocalState.baseSnapshot, versionId: undefined };
+        if (pendingLocalState) {
+            this.baseSnapshot = pendingLocalState.baseSnapshot;
+            this.baseSnapshotBlobs = pendingLocalState.snapshotBlobs;
+        }
+        else {
+            (0, common_utils_1.assert)(snapshot !== 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.storage);
+            }
+        }
+        const attributes = await this.getDocumentAttributes(this.storageAdapter, snapshot);
+        // If we saved ops, we will replay them and don't need DeltaManager to fetch them
+        const sequenceNumber = (_a = pendingLocalState === null || pendingLocalState === void 0 ? void 0 : pendingLocalState.savedOps[pendingLocalState.savedOps.length - 1]) === null || _a === void 0 ? void 0 : _a.sequenceNumber;
+        const dmAttributes = sequenceNumber !== undefined ? Object.assign(Object.assign({}, attributes), { sequenceNumber }) : attributes;
         let opsBeforeReturnP;
         // Attach op handlers to finish initialization and be able to start processing ops
         // Kick off any ops fetching if required.
@@ -914,32 +962,35 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             case undefined:
                 // Start prefetch, but not set opsBeforeReturnP - boot is not blocked by it!
                 // eslint-disable-next-line @typescript-eslint/no-floating-promises
-                this.attachDeltaManagerOpHandler(attributes, loadMode.deltaConnection !== "none" ? "all" : "none");
+                this.attachDeltaManagerOpHandler(dmAttributes, loadMode.deltaConnection !== "none" ? "all" : "none");
                 break;
             case "cached":
-                opsBeforeReturnP = this.attachDeltaManagerOpHandler(attributes, "cached");
+                opsBeforeReturnP = this.attachDeltaManagerOpHandler(dmAttributes, "cached");
                 break;
             case "all":
-                opsBeforeReturnP = this.attachDeltaManagerOpHandler(attributes, "all");
+                opsBeforeReturnP = this.attachDeltaManagerOpHandler(dmAttributes, "all");
                 break;
             default:
                 (0, common_utils_1.unreachableCase)(loadMode.opsBeforeReturn);
         }
         // ...load in the existing quorum
         // Initialize the protocol handler
-        if (pendingLocalState === undefined) {
-            await this.initializeProtocolStateFromSnapshot(attributes, this.storageService, snapshot);
-        }
-        else {
-            this.initializeProtocolState(attributes, {
-                members: pendingLocalState.protocol.members,
-                proposals: pendingLocalState.protocol.proposals,
-                values: pendingLocalState.protocol.values,
-            });
-        }
+        await this.initializeProtocolStateFromSnapshot(attributes, this.storageAdapter, snapshot);
         const codeDetails = this.getCodeDetailsFromQuorum();
         await this.instantiateContext(true, // existing
         codeDetails, snapshot, pendingLocalState === null || pendingLocalState === void 0 ? void 0 : pendingLocalState.pendingRuntimeState);
+        // replay saved ops
+        if (pendingLocalState) {
+            for (const message of pendingLocalState.savedOps) {
+                this.processRemoteMessage(message);
+                // allow runtime to apply stashed ops at this op's sequence number
+                await this.context.notifyOpReplay(message);
+            }
+            pendingLocalState.savedOps = [];
+            // now set clientId to stashed clientId so live ops are correctly processed as local
+            (0, common_utils_1.assert)(this.clientId === undefined, "Unexpected clientId when setting stashed clientId");
+            this._clientId = pendingLocalState === null || pendingLocalState === void 0 ? void 0 : pendingLocalState.clientId;
+        }
         // We might have hit some failure that did not manifest itself in exception in this flow,
         // do not start op processing in such case - static version of Container.load() will handle it correctly.
         if (!this.closed) {
@@ -952,6 +1003,11 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             }
             switch (loadMode.deltaConnection) {
                 case undefined:
+                    if (pendingLocalState) {
+                        // connect to delta stream now since we did not before
+                        this.connectToDeltaStream(connectionArgs);
+                    }
+                // intentional fallthrough
                 case "delayed":
                     (0, common_utils_1.assert)(this.inboundQueuePausedFromInit, 0x346 /* inboundQueuePausedFromInit should be true */);
                     this.inboundQueuePausedFromInit = false;
@@ -1006,12 +1062,12 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             delete detachedContainerSnapshot.tree[".hasAttachmentBlobs"];
         }
         const snapshotTree = (0, utils_1.getSnapshotTreeFromSerializedContainer)(detachedContainerSnapshot);
-        this.storageService.loadSnapshotForRehydratingContainer(snapshotTree);
-        const attributes = await this.getDocumentAttributes(this.storageService, snapshotTree);
+        this.storageAdapter.loadSnapshotForRehydratingContainer(snapshotTree);
+        const attributes = await this.getDocumentAttributes(this.storageAdapter, snapshotTree);
         await this.attachDeltaManagerOpHandler(attributes);
         // Initialize the protocol handler
         const baseTree = (0, utils_1.getProtocolSnapshotTree)(snapshotTree);
-        const qValues = await (0, driver_utils_1.readAndParse)(this.storageService, baseTree.blobs.quorumValues);
+        const qValues = await (0, driver_utils_1.readAndParse)(this.storageAdapter, baseTree.blobs.quorumValues);
         const codeDetails = (0, quorum_1.getCodeDetailsFromQuorumValues)(qValues);
         this.initializeProtocolState(attributes, {
             members: [],
@@ -1288,16 +1344,16 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         }
     }
     /** @returns clientSequenceNumber of last message in a batch */
-    submitBatch(batch) {
+    submitBatch(batch, referenceSequenceNumber) {
         let clientSequenceNumber = -1;
         for (const message of batch) {
             clientSequenceNumber = this.submitMessage(protocol_definitions_1.MessageType.Operation, message.contents, true, // batch
-            message.metadata, message.compression);
+            message.metadata, message.compression, referenceSequenceNumber);
         }
         this._deltaManager.flush();
         return clientSequenceNumber;
     }
-    submitSummaryMessage(summary) {
+    submitSummaryMessage(summary, referenceSequenceNumber) {
         // github #6451: this is only needed for staging so the server
         // know when the protocol tree is included
         // this can be removed once all clients send
@@ -1305,10 +1361,10 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         if (summary.details === undefined) {
             summary.details = {};
         }
-        summary.details.includesProtocolTree = this.options.summarizeProtocolTree === true;
-        return this.submitMessage(protocol_definitions_1.MessageType.Summarize, JSON.stringify(summary), false /* batch */);
+        summary.details.includesProtocolTree = this.storageAdapter.summarizeProtocolTree;
+        return this.submitMessage(protocol_definitions_1.MessageType.Summarize, JSON.stringify(summary), false /* batch */, undefined /* metadata */, undefined /* compression */, referenceSequenceNumber);
     }
-    submitMessage(type, contents, batch, metadata, compression) {
+    submitMessage(type, contents, batch, metadata, compression, referenceSequenceNumber) {
         var _a;
         if (this.connectionState !== connectionState_1.ConnectionState.Connected) {
             this.mc.logger.sendErrorEvent({ eventName: "SubmitMessageWithNoConnection", type });
@@ -1316,9 +1372,12 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         }
         this.messageCountAfterDisconnection += 1;
         (_a = this.collabWindowTracker) === null || _a === void 0 ? void 0 : _a.stopSequenceNumberUpdate();
-        return this._deltaManager.submit(type, contents, batch, metadata, compression);
+        return this._deltaManager.submit(type, contents, batch, metadata, compression, referenceSequenceNumber);
     }
     processRemoteMessage(message) {
+        if (this.offlineLoadEnabled) {
+            this.savedOps.push(message);
+        }
         const local = this.clientId === message.clientId;
         // Allow the protocol handler to process the message
         const result = this.protocolHandler.processMessage(message, local);
@@ -1370,7 +1429,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             });
         }
         this._loadedFromVersion = version;
-        const snapshot = (_a = (await this.storageService.getSnapshotTree(version))) !== null && _a !== void 0 ? _a : undefined;
+        const snapshot = (_a = (await this.storageAdapter.getSnapshotTree(version))) !== null && _a !== void 0 ? _a : undefined;
         if (snapshot === undefined && version !== undefined) {
             this.mc.logger.sendErrorEvent({ eventName: "getSnapshotTreeFailed", id: version.id });
         }
@@ -1389,7 +1448,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         // 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
         const loader = new loader_1.RelativeLoader(this, this.loader);
-        this._context = await containerContext_1.ContainerContext.createOrLoad(this, this.scope, this.codeLoader, codeDetails, snapshot, new deltaManagerProxy_1.DeltaManagerProxy(this._deltaManager), new quorum_1.QuorumProxy(this.protocolHandler.quorum), loader, (type, contents, batch, metadata) => this.submitContainerMessage(type, contents, batch, metadata), (summaryOp) => this.submitSummaryMessage(summaryOp), (batch) => this.submitBatch(batch), (message) => this.submitSignal(message), (error) => { var _a; return (_a = this.dispose) === null || _a === void 0 ? void 0 : _a.call(this, error); }, (error) => this.close(error), Container.version, (dirty) => this.updateDirtyContainerState(dirty), existing, pendingLocalState);
+        this._context = await containerContext_1.ContainerContext.createOrLoad(this, this.scope, this.codeLoader, codeDetails, snapshot, new deltaManagerProxy_1.DeltaManagerProxy(this._deltaManager), new quorum_1.QuorumProxy(this.protocolHandler.quorum), loader, (type, contents, batch, metadata) => this.submitContainerMessage(type, contents, batch, metadata), (summaryOp, referenceSequenceNumber) => this.submitSummaryMessage(summaryOp, referenceSequenceNumber), (batch, referenceSequenceNumber) => this.submitBatch(batch, referenceSequenceNumber), (message) => this.submitSignal(message), (error) => { var _a; return (_a = this.dispose) === null || _a === void 0 ? void 0 : _a.call(this, error); }, (error) => this.close(error), Container.version, (dirty) => this.updateDirtyContainerState(dirty), existing, pendingLocalState);
         this.emit("contextChanged", codeDetails);
     }
     updateDirtyContainerState(dirty) {