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

package/lib/container.js

@@ -8,9 +8,9 @@ import { v4 as uuid } from "uuid";
 import { assert, performance, unreachableCase } from "@fluidframework/common-utils";
 import { AttachState, isFluidCodeDetails, } from "@fluidframework/container-definitions";
 import { GenericError, UsageError } from "@fluidframework/container-utils";
-import { readAndParse, OnlineStatus, isOnline, ensureFluidResolvedUrl, combineAppAndProtocolSummary, runWithRetry, isFluidResolvedUrl, } from "@fluidframework/driver-utils";
+import { readAndParse, OnlineStatus, isOnline, ensureFluidResolvedUrl, combineAppAndProtocolSummary, runWithRetry, isFluidResolvedUrl, isCombinedAppAndProtocolSummary, } from "@fluidframework/driver-utils";
 import { MessageType, SummaryType, } from "@fluidframework/protocol-definitions";
-import { ChildLogger, EventEmitterWithErrorHandling, PerformanceEvent, raiseConnectedEvent, TelemetryLogger, connectedEventName, disconnectedEventName, normalizeError, loggerToMonitoringContext, wrapError, } from "@fluidframework/telemetry-utils";
+import { ChildLogger, EventEmitterWithErrorHandling, PerformanceEvent, raiseConnectedEvent, TelemetryLogger, connectedEventName, normalizeError, loggerToMonitoringContext, wrapError, } from "@fluidframework/telemetry-utils";
 import { Audience } from "./audience";
 import { ContainerContext } from "./containerContext";
 import { ReconnectMode, getPackageName } from "./contracts";
@@ -18,7 +18,7 @@ import { DeltaManager } from "./deltaManager";
 import { DeltaManagerProxy } from "./deltaManagerProxy";
 import { RelativeLoader } from "./loader";
 import { pkgVersion } from "./packageVersion";
-import { ContainerStorageAdapter } from "./containerStorageAdapter";
+import { ContainerStorageAdapter, getBlobContentsFromTree, getBlobContentsFromTreeWithBlobContents, } from "./containerStorageAdapter";
 import { createConnectionStateHandler } from "./connectionStateHandler";
 import { getProtocolSnapshotTree, getSnapshotTreeFromSerializedContainer } from "./utils";
 import { initQuorumValuesFromCodeDetails, getCodeDetailsFromQuorumValues, QuorumProxy, } from "./quorum";
@@ -119,9 +119,15 @@ export async function ReportIfTooLong(logger, eventName, action) {
     }
 }
 const summarizerClientType = "summarizer";
+/**
+ * @deprecated - In the next release Container will no longer be exported, IContainer should be used in its place.
+ */
 export class Container extends EventEmitterWithErrorHandling {
+    /**
+     * @internal
+     */
     constructor(loader, config, protocolHandlerBuilder) {
-        var _a, _b;
+        var _a, _b, _c;
         super((name, error) => {
             this.mc.logger.sendErrorEvent({
                 eventName: "ContainerEventHandlerException",
@@ -157,6 +163,7 @@ export class Container extends EventEmitterWithErrorHandling {
         this.messageCountAfterDisconnection = 0;
         this.attachStarted = false;
         this._dirtyContainer = false;
+        this.savedOps = [];
         this.setAutoReconnectTime = performance.now();
         this._disposed = false;
         this.clientDetailsOverride = config.clientDetailsOverride;
@@ -195,15 +202,14 @@ export class Container extends 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: () => performance.now() - this.connectionTransitionTimes[this.connectionState],
             },
         });
         // Prefix all events in this file with container-loader
         this.mc = loggerToMonitoringContext(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 = createConnectionStateHandler({
             logger: this.mc.logger,
             connectionStateChanged: (value, oldState, reason) => {
@@ -242,13 +248,20 @@ export class Container extends 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(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) => isCombinedAppAndProtocolSummary(summaryTree) === true
+            ? summaryTree
+            : 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(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" &&
@@ -269,45 +282,10 @@ export class Container extends 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 connectedEventName:
-                        if (this.connected) {
-                            listener(this.clientId);
-                        }
-                        break;
-                    case 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, {
@@ -385,7 +363,7 @@ export class Container extends EventEmitterWithErrorHandling {
             this._lifecycleState === "disposed");
     }
     get storage() {
-        return this.storageService;
+        return this.storageAdapter;
     }
     get context() {
         if (this._context === undefined) {
@@ -456,6 +434,12 @@ export class Container extends 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.
@@ -498,6 +482,38 @@ export class Container extends 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 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.
+            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
      */
@@ -528,15 +544,19 @@ export class Container extends 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
@@ -565,7 +585,7 @@ export class Container extends 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") {
@@ -574,7 +594,7 @@ export class Container extends 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
@@ -597,14 +617,21 @@ export class Container extends 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 UsageError("Can't get pending local state unless offline load is enabled");
+        }
         assert(this.attachState === AttachState.Attached, 0x0d1 /* "Container should be attached before close" */);
         assert(this.resolvedUrl !== undefined && this.resolvedUrl.type === "fluid", 0x0d2 /* "resolved url should be valid Fluid url" */);
         assert(!!this._protocolHandler, 0x2e3 /* "Must have a valid protocol handler instance" */);
         assert(this._protocolHandler.attributes.term !== undefined, 0x37e /* Must have a valid protocol handler instance */);
+        assert(!!this.baseSnapshot, "no base snapshot");
+        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,
         };
@@ -657,7 +684,13 @@ export class Container extends EventEmitterWithErrorHandling {
                     // starting to attach the container to storage.
                     // Also, this should only be fired in detached container.
                     this._attachState = AttachState.Attaching;
-                    this.context.notifyAttaching(getSnapshotTreeFromSerializedContainer(summary));
+                    this.emit("attaching");
+                    if (this.offlineLoadEnabled) {
+                        const snapshot = getSnapshotTreeFromSerializedContainer(summary);
+                        this.baseSnapshot = snapshot;
+                        this.baseSnapshotBlobs =
+                            getBlobContentsFromTreeWithBlobContents(snapshot);
+                    }
                 }
                 // Actually go and create the resolved document
                 const createNewResolvedUrl = await this.urlResolver.resolve(request);
@@ -671,7 +704,7 @@ export class Container extends EventEmitterWithErrorHandling {
                 const resolvedUrl = this.service.resolvedUrl;
                 ensureFluidResolvedUrl(resolvedUrl);
                 this._resolvedUrl = resolvedUrl;
-                await this.storageService.connectToService(this.service);
+                await this.storageAdapter.connectToService(this.service);
                 if (hasAttachmentBlobs) {
                     // upload blobs to storage
                     assert(!!this.loader.services.detachedBlobStorage, 0x24e /* "assertion for type narrowing" */);
@@ -685,7 +718,7 @@ export class Container extends 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);
                         }
                     }
@@ -694,8 +727,14 @@ export class Container extends EventEmitterWithErrorHandling {
                     const protocolSummary = this.captureProtocolSummary();
                     summary = combineAppAndProtocolSummary(appSummary, protocolSummary);
                     this._attachState = AttachState.Attaching;
-                    this.context.notifyAttaching(getSnapshotTreeFromSerializedContainer(summary));
-                    await this.storageService.uploadSummaryWithContext(summary, {
+                    this.emit("attaching");
+                    if (this.offlineLoadEnabled) {
+                        const snapshot = getSnapshotTreeFromSerializedContainer(summary);
+                        this.baseSnapshot = snapshot;
+                        this.baseSnapshotBlobs =
+                            getBlobContentsFromTreeWithBlobContents(snapshot);
+                    }
+                    await this.storageAdapter.uploadSummaryWithContext(summary, {
                         referenceSequenceNumber: 0,
                         ackHandle: undefined,
                         proposalHandle: undefined,
@@ -830,7 +869,7 @@ export class Container extends 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() {
@@ -852,6 +891,7 @@ export class Container extends 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");
         }
@@ -872,15 +912,15 @@ export class Container extends 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);
@@ -890,15 +930,23 @@ export class Container extends EventEmitterWithErrorHandling {
         // Fetch specified snapshot.
         const { snapshot, versionId } = pendingLocalState === undefined
             ? await this.fetchSnapshotTree(specifiedVersion)
-            : { snapshot: undefined, versionId: undefined };
-        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 {
+            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 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.
@@ -906,32 +954,35 @@ export class Container extends 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:
                 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
+            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) {
@@ -944,6 +995,11 @@ export class Container extends 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":
                     assert(this.inboundQueuePausedFromInit, 0x346 /* inboundQueuePausedFromInit should be true */);
                     this.inboundQueuePausedFromInit = false;
@@ -998,12 +1054,12 @@ export class Container extends EventEmitterWithErrorHandling {
             delete detachedContainerSnapshot.tree[".hasAttachmentBlobs"];
         }
         const snapshotTree = 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 = getProtocolSnapshotTree(snapshotTree);
-        const qValues = await readAndParse(this.storageService, baseTree.blobs.quorumValues);
+        const qValues = await readAndParse(this.storageAdapter, baseTree.blobs.quorumValues);
         const codeDetails = getCodeDetailsFromQuorumValues(qValues);
         this.initializeProtocolState(attributes, {
             members: [],
@@ -1280,16 +1336,16 @@ export class Container extends 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(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
@@ -1297,10 +1353,10 @@ export class Container extends EventEmitterWithErrorHandling {
         if (summary.details === undefined) {
             summary.details = {};
         }
-        summary.details.includesProtocolTree = this.options.summarizeProtocolTree === true;
-        return this.submitMessage(MessageType.Summarize, JSON.stringify(summary), false /* batch */);
+        summary.details.includesProtocolTree = this.storageAdapter.summarizeProtocolTree;
+        return this.submitMessage(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.Connected) {
             this.mc.logger.sendErrorEvent({ eventName: "SubmitMessageWithNoConnection", type });
@@ -1308,9 +1364,12 @@ export class Container extends 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);
@@ -1362,7 +1421,7 @@ export class Container extends 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 });
         }
@@ -1381,7 +1440,7 @@ export class Container extends 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 RelativeLoader(this, this.loader);
-        this._context = await ContainerContext.createOrLoad(this, this.scope, this.codeLoader, codeDetails, snapshot, new DeltaManagerProxy(this._deltaManager), new 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.createOrLoad(this, this.scope, this.codeLoader, codeDetails, snapshot, new DeltaManagerProxy(this._deltaManager), new 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) {