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

package/dist/container.js

@@ -71,8 +71,8 @@ async function waitContainerToCatchUp(container) {
         // Waiting for "connected" state in either case gets us at least to our own Join op
         // which is a reasonable approximation of "caught up"
         const waitForOps = () => {
-            (0, common_utils_1.assert)(container.connectionState === connectionState_1.ConnectionState.CatchingUp
-                || container.connectionState === connectionState_1.ConnectionState.Connected, 0x0cd /* "Container disconnected while waiting for ops!" */);
+            (0, common_utils_1.assert)(container.connectionState === connectionState_1.ConnectionState.CatchingUp ||
+                container.connectionState === connectionState_1.ConnectionState.Connected, 0x0cd /* "Container disconnected while waiting for ops!" */);
             const hasCheckpointSequenceNumber = deltaManager.hasCheckpointSequenceNumber;
             const connectionOpSeqNumber = deltaManager.lastKnownSeqNumber;
             (0, common_utils_1.assert)(deltaManager.lastSequenceNumber <= connectionOpSeqNumber, 0x266 /* "lastKnownSeqNumber should never be below last processed sequence number" */);
@@ -113,7 +113,7 @@ const getCodeProposal =
 // eslint-disable-next-line @typescript-eslint/no-unsafe-return
 (quorum) => { var _a; return (_a = quorum.get("code")) !== null && _a !== void 0 ? _a : quorum.get("code2"); };
 /**
- * Helper function to report to telemetry cases where operation takes longer than expected (1s)
+ * Helper function to report to telemetry cases where operation takes longer than expected (200ms)
  * @param logger - logger to use
  * @param eventName - event name
  * @param action - functor to call and measure
@@ -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",
@@ -141,6 +147,21 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         // Tells if container can reconnect on losing fist connection
         // If false, container gets closed on loss of connection.
         this._canReconnect = true;
+        /**
+         * Lifecycle state of the container, used mainly to prevent re-entrancy and telemetry
+         *
+         * States are allowed to progress to further states:
+         * "loading" - "loaded" - "closing" - "disposing" - "closed" - "disposed"
+         *
+         * For example, moving from "closed" to "disposing" is not allowed since it is an earlier state.
+         *
+         * loading: Container has been created, but is not yet in normal/loaded state
+         * loaded: Container is in normal/loaded state
+         * closing: Container has started closing process (for re-entrancy prevention)
+         * disposing: Container has started disposing process (for re-entrancy prevention)
+         * closed: Container has closed
+         * 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 */
@@ -150,7 +171,9 @@ 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;
         this._resolvedUrl = config.resolvedUrl;
         if (config.canReconnect !== undefined) {
@@ -187,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) => {
@@ -204,17 +226,23 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                 }
                 this.logConnectionStateChangeTelemetry(value, oldState, reason);
                 if (this._lifecycleState === "loaded") {
-                    this.propagateConnectionState(false /* initial transition */, value === connectionState_1.ConnectionState.Disconnected ? reason : undefined /* disconnectedReason */);
+                    this.propagateConnectionState(false /* initial transition */, value === connectionState_1.ConnectionState.Disconnected
+                        ? reason
+                        : undefined /* disconnectedReason */);
                 }
             },
             shouldClientJoinWrite: () => this._deltaManager.connectionManager.shouldJoinWrite(),
             maxClientLeaveWaitTime: this.loader.services.options.maxClientLeaveWaitTime,
-            logConnectionIssue: (eventName, details) => {
+            logConnectionIssue: (eventName, category, details) => {
                 const mode = this.connectionMode;
                 // We get here when socket does not receive any ops on "write" connection, including
-                // its own join op. Attempt recovery option.
+                // its own join op.
+                // Report issues only if we already loaded container - op processing is paused while container is loading,
+                // so we always time-out processing of join op in cases where fetching snapshot takes a minute.
+                // It's not a problem with op processing itself - such issues should be tracked as part of boot perf monitoring instead.
                 this._deltaManager.logConnectionIssue(Object.assign({ eventName,
-                    mode, duration: common_utils_1.performance.now() - this.connectionTransitionTimes[connectionState_1.ConnectionState.CatchingUp] }, (details === undefined ? {} : { details: JSON.stringify(details) })));
+                    mode, category: this._lifecycleState === "loading" ? "generic" : category, duration: common_utils_1.performance.now() -
+                        this.connectionTransitionTimes[connectionState_1.ConnectionState.CatchingUp] }, (details === undefined ? {} : { details: JSON.stringify(details) })));
                 // If this is "write" connection, it took too long to receive join op. But in most cases that's due
                 // to very slow op fetches and we will eventually get there.
                 // For "read" connections, we get here due to self join signal not arriving on time. We will need to
@@ -228,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" &&
@@ -248,48 +283,17 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                 }
                 else {
                     // settimeout so this will hopefully fire after disconnect event if being hidden caused it
-                    setTimeout(() => { this.lastVisible = undefined; }, 0);
+                    setTimeout(() => {
+                        this.lastVisible = undefined;
+                    }, 0);
                 }
             };
             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, {
@@ -311,7 +315,8 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                 reject(err !== null && err !== void 0 ? err : new container_utils_1.GenericError("Container closed without error during load"));
             };
             container.on("closed", onClosed);
-            container.load(version, mode, pendingLocalState)
+            container
+                .load(version, mode, pendingLocalState)
                 .finally(() => {
                 container.removeListener("closed", onClosed);
             })
@@ -360,10 +365,13 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         }
     }
     get closed() {
-        return (this._lifecycleState === "closing" || this._lifecycleState === "closed");
+        return (this._lifecycleState === "closing" ||
+            this._lifecycleState === "closed" ||
+            this._lifecycleState === "disposing" ||
+            this._lifecycleState === "disposed");
     }
     get storage() {
-        return this.storageService;
+        return this.storageAdapter;
     }
     get context() {
         if (this._context === undefined) {
@@ -377,8 +385,12 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         }
         return this._protocolHandler;
     }
-    get connectionMode() { return this._deltaManager.connectionManager.connectionMode; }
-    get IFluidRouter() { return this; }
+    get connectionMode() {
+        return this._deltaManager.connectionManager.connectionMode;
+    }
+    get IFluidRouter() {
+        return this;
+    }
     get resolvedUrl() {
         return this._resolvedUrl;
     }
@@ -430,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.
@@ -460,24 +478,71 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
     get isDirty() {
         return this._dirtyContainer;
     }
-    get serviceFactory() { return this.loader.services.documentServiceFactory; }
-    get urlResolver() { return this.loader.services.urlResolver; }
-    get scope() { return this.loader.services.scope; }
-    get codeLoader() { return this.loader.services.codeLoader; }
+    get serviceFactory() {
+        return this.loader.services.documentServiceFactory;
+    }
+    get urlResolver() {
+        return this.loader.services.urlResolver;
+    }
+    get scope() {
+        return this.loader.services.scope;
+    }
+    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
      */
     getQuorum() {
         return this.protocolHandler.quorum;
     }
+    dispose(error) {
+        this._deltaManager.close(error, true /* doDispose */);
+        this.verifyClosed();
+    }
     close(error) {
         // 1. Ensure that close sequence is exactly the same no matter if it's initiated by host or by DeltaManager
         // 2. We need to ensure that we deliver disconnect event to runtime properly. See connectionStateChanged
         //    handler. We only deliver events if container fully loaded. Transitioning from "loading" ->
         //    "closing" will lose that info (can also solve by tracking extra state).
         this._deltaManager.close(error);
+        this.verifyClosed();
+    }
+    verifyClosed() {
         (0, common_utils_1.assert)(this.connectionState === connectionState_1.ConnectionState.Disconnected, 0x0cf /* "disconnect event was not raised!" */);
-        (0, common_utils_1.assert)(this._lifecycleState === "closed", 0x314 /* Container properly closed */);
+        (0, common_utils_1.assert)(this._lifecycleState === "closed" || this._lifecycleState === "disposed", 0x314 /* Container properly closed */);
     }
     closeCore(error) {
         var _a, _b, _c;
@@ -487,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
@@ -505,7 +574,6 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                 this.mc.logger.sendErrorEvent({ eventName: "ContainerCloseException" }, exception);
             }
             this.emit("closed", error);
-            this.removeAllListeners();
             if (this.visibilityEventHandler !== undefined) {
                 document.removeEventListener("visibilitychange", this.visibilityEventHandler);
             }
@@ -514,22 +582,69 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             this._lifecycleState = "closed";
         }
     }
+    disposeCore(error) {
+        var _a, _b, _c;
+        (0, common_utils_1.assert)(!this._disposed, 0x54c /* Container already disposed */);
+        this._disposed = true;
+        try {
+            // Ensure that we raise all key events even if one of these throws
+            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.
+                this.mc.logger.sendTelemetryEvent({
+                    eventName: "ContainerDispose",
+                    category: "generic",
+                }, error);
+                // ! Progressing from "closed" to "disposing" is not allowed
+                if (this._lifecycleState !== "closed") {
+                    this._lifecycleState = "disposing";
+                }
+                (_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.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
+                (_c = this.service) === null || _c === void 0 ? void 0 : _c.dispose(error);
+            }
+            catch (exception) {
+                this.mc.logger.sendErrorEvent({ eventName: "ContainerDisposeException" }, exception);
+            }
+            this.emit("disposed", error);
+            this.removeAllListeners();
+            if (this.visibilityEventHandler !== undefined) {
+                document.removeEventListener("visibilitychange", this.visibilityEventHandler);
+            }
+        }
+        finally {
+            this._lifecycleState = "disposed";
+        }
+    }
     closeAndGetPendingLocalState() {
         // 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,
         };
         this.mc.logger.sendTelemetryEvent({ eventName: "CloseAndGetPendingLocalState" });
+        // Only close here as method name suggests
         this.close();
         return JSON.stringify(pendingState);
     }
@@ -541,13 +656,18 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         const appSummary = this.context.createSummary();
         const protocolSummary = this.captureProtocolSummary();
         const combinedSummary = (0, driver_utils_1.combineAppAndProtocolSummary)(appSummary, protocolSummary);
-        if (this.loader.services.detachedBlobStorage && this.loader.services.detachedBlobStorage.size > 0) {
-            combinedSummary.tree[".hasAttachmentBlobs"] = { type: protocol_definitions_1.SummaryType.Blob, content: "true" };
+        if (this.loader.services.detachedBlobStorage &&
+            this.loader.services.detachedBlobStorage.size > 0) {
+            combinedSummary.tree[".hasAttachmentBlobs"] = {
+                type: protocol_definitions_1.SummaryType.Blob,
+                content: "true",
+            };
         }
         return JSON.stringify(combinedSummary);
     }
     async attach(request) {
         await telemetry_utils_1.PerformanceEvent.timedExecAsync(this.mc.logger, { eventName: "Attach" }, async () => {
+            var _a;
             if (this._lifecycleState !== "loaded") {
                 // pre-0.58 error message: containerNotValidForAttach
                 throw new container_utils_1.UsageError(`The Container is not in a valid state for attach [${this._lifecycleState}]`);
@@ -556,8 +676,8 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             (0, common_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.loader.services.detachedBlobStorage !== undefined
-                && this.loader.services.detachedBlobStorage.size > 0;
+            const hasAttachmentBlobs = this.loader.services.detachedBlobStorage !== undefined &&
+                this.loader.services.detachedBlobStorage.size > 0;
             try {
                 (0, common_utils_1.assert)(this.deltaManager.inbound.length === 0, 0x0d6 /* "Inbound queue should be empty when attaching" */);
                 let summary;
@@ -572,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);
@@ -586,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" */);
@@ -595,10 +721,12 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                     const redirectTable = new Map();
                     // if new blobs are added while uploading, upload them too
                     while (redirectTable.size < this.loader.services.detachedBlobStorage.size) {
-                        const newIds = this.loader.services.detachedBlobStorage.getBlobIds().filter((id) => !redirectTable.has(id));
+                        const newIds = this.loader.services.detachedBlobStorage
+                            .getBlobIds()
+                            .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);
                         }
                     }
@@ -607,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,
@@ -617,7 +751,10 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                 this._attachState = container_definitions_1.AttachState.Attached;
                 this.emit("attached");
                 if (!this.closed) {
-                    this.resumeInternal({ fetchOpsFromStorage: false, reason: "createDetached" });
+                    this.resumeInternal({
+                        fetchOpsFromStorage: false,
+                        reason: "createDetached",
+                    });
                 }
             }
             catch (error) {
@@ -628,6 +765,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                     newError.addTelemetryProperties({ resolvedUrl: resolvedUrl.url });
                 }
                 this.close(newError);
+                (_a = this.dispose) === null || _a === void 0 ? void 0 : _a.call(this, newError);
                 throw newError;
             }
         }, { start: true, end: true, cancel: "generic" });
@@ -716,26 +854,30 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                 throw new Error("Proposed code details should be greater than the current");
             }
         }
-        return this.protocolHandler.quorum.propose("code", codeDetails)
+        return this.protocolHandler.quorum
+            .propose("code", codeDetails)
             .then(() => true)
             .catch(() => false);
     }
     async processCodeProposal() {
+        var _a;
         const codeDetails = this.getCodeDetailsFromQuorum();
         await Promise.all([
             this.deltaManager.inbound.pause(),
-            this.deltaManager.inboundSignal.pause()
+            this.deltaManager.inboundSignal.pause(),
         ]);
-        if ((await this.context.satisfies(codeDetails) === true)) {
+        if ((await this.context.satisfies(codeDetails)) === true) {
             this.deltaManager.inbound.resume();
             this.deltaManager.inboundSignal.resume();
             return;
         }
         // pre-0.58 error message: existingContextDoesNotSatisfyIncomingProposal
-        this.close(new container_utils_1.GenericError("Existing context does not satisfy incoming proposal"));
+        const error = new container_utils_1.GenericError("Existing context does not satisfy incoming proposal");
+        this.close(error);
+        (_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() {
@@ -757,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");
         }
@@ -770,32 +913,48 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         // connections to same file) in two ways:
         // A) creation flow breaks (as one of the clients "sees" file as existing, and hits #2 above)
         // B) Once file is created, transition from view-only connection to write does not work - some bugs to be fixed.
-        const connectionArgs = { reason: "DocumentOpen", mode: "write", fetchOpsFromStorage: false };
+        const connectionArgs = {
+            reason: "DocumentOpen",
+            mode: "write",
+            fetchOpsFromStorage: false,
+        };
         // 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.close(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);
+            });
         }
         this._attachState = container_definitions_1.AttachState.Attached;
         // 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.
@@ -803,44 +962,52 @@ 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) {
             if (opsBeforeReturnP !== undefined) {
                 this._deltaManager.inbound.resume();
-                await ReportIfTooLong(this.mc.logger, "WaitOps", async () => { await opsBeforeReturnP; return {}; });
-                await ReportIfTooLong(this.mc.logger, "WaitOpProcessing", async () => this._deltaManager.inbound.waitTillProcessingDone());
+                await telemetry_utils_1.PerformanceEvent.timedExecAsync(this.mc.logger, { eventName: "WaitOps" }, async () => opsBeforeReturnP);
+                await telemetry_utils_1.PerformanceEvent.timedExecAsync(this.mc.logger, { eventName: "WaitOpProcessing" }, async () => this._deltaManager.inbound.waitTillProcessingDone());
                 // eslint-disable-next-line @typescript-eslint/no-floating-promises
                 this._deltaManager.inbound.pause();
             }
             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;
@@ -890,16 +1057,17 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
     }
     async rehydrateDetachedFromSnapshot(detachedContainerSnapshot) {
         if (detachedContainerSnapshot.tree[".hasAttachmentBlobs"] !== undefined) {
-            (0, common_utils_1.assert)(!!this.loader.services.detachedBlobStorage && this.loader.services.detachedBlobStorage.size > 0, 0x250 /* "serialized container with attachment blobs must be rehydrated with detached blob storage" */);
+            (0, common_utils_1.assert)(!!this.loader.services.detachedBlobStorage &&
+                this.loader.services.detachedBlobStorage.size > 0, 0x250 /* "serialized container with attachment blobs must be rehydrated with detached blob storage" */);
             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: [],
@@ -937,11 +1105,12 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         };
         if (snapshot !== undefined) {
             const baseTree = (0, utils_1.getProtocolSnapshotTree)(snapshot);
-            [quorumSnapshot.members, quorumSnapshot.proposals, quorumSnapshot.values] = await Promise.all([
-                (0, driver_utils_1.readAndParse)(storage, baseTree.blobs.quorumMembers),
-                (0, driver_utils_1.readAndParse)(storage, baseTree.blobs.quorumProposals),
-                (0, driver_utils_1.readAndParse)(storage, baseTree.blobs.quorumValues),
-            ]);
+            [quorumSnapshot.members, quorumSnapshot.proposals, quorumSnapshot.values] =
+                await Promise.all([
+                    (0, driver_utils_1.readAndParse)(storage, baseTree.blobs.quorumMembers),
+                    (0, driver_utils_1.readAndParse)(storage, baseTree.blobs.quorumProposals),
+                    (0, driver_utils_1.readAndParse)(storage, baseTree.blobs.quorumValues),
+                ]);
         }
         this.initializeProtocolState(attributes, quorumSnapshot);
     }
@@ -968,7 +1137,10 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                     });
                 }
                 this.processCodeProposal().catch((error) => {
-                    this.close((0, telemetry_utils_1.normalizeError)(error));
+                    var _a;
+                    const normalizedError = (0, telemetry_utils_1.normalizeError)(error);
+                    this.close(normalizedError);
+                    (_a = this.dispose) === null || _a === void 0 ? void 0 : _a.call(this, normalizedError);
                     throw error;
                 });
             }
@@ -1025,7 +1197,10 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         if (this.clientDetailsOverride !== undefined) {
             (0, merge_1.default)(client.details, this.clientDetailsOverride);
         }
-        client.details.environment = [client.details.environment, ` loaderVersion:${packageVersion_1.pkgVersion}`].join(";");
+        client.details.environment = [
+            client.details.environment,
+            ` loaderVersion:${packageVersion_1.pkgVersion}`,
+        ].join(";");
         return client;
     }
     /**
@@ -1035,8 +1210,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
      * If it's not true, runtime is not in position to send ops.
      */
     activeConnection() {
-        return this.connectionState === connectionState_1.ConnectionState.Connected &&
-            this.connectionMode === "write";
+        return (this.connectionState === connectionState_1.ConnectionState.Connected && this.connectionMode === "write");
     }
     createDeltaManager() {
         const serviceProvider = () => this.service;
@@ -1053,7 +1227,9 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         deltaManager.on("disconnect", (reason) => {
             var _a;
             (_a = this.collabWindowTracker) === null || _a === void 0 ? void 0 : _a.stopSequenceNumberUpdate();
-            this.connectionStateHandler.receivedDisconnectEvent(reason);
+            if (!this.closed) {
+                this.connectionStateHandler.receivedDisconnectEvent(reason);
+            }
         });
         deltaManager.on("throttled", (warning) => {
             const warn = warning;
@@ -1071,6 +1247,9 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         deltaManager.on("closed", (error) => {
             this.closeCore(error);
         });
+        deltaManager.on("disposed", (error) => {
+            this.disposeCore(error);
+        });
         return deltaManager;
     }
     async attachDeltaManagerOpHandler(attributes, prefetchType) {
@@ -1098,7 +1277,8 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         }
         else {
             if (value === connectionState_1.ConnectionState.Connected) {
-                durationFromDisconnected = time - this.connectionTransitionTimes[connectionState_1.ConnectionState.Disconnected];
+                durationFromDisconnected =
+                    time - this.connectionTransitionTimes[connectionState_1.ConnectionState.Disconnected];
                 durationFromDisconnected = telemetry_utils_1.TelemetryLogger.formatTick(durationFromDisconnected);
             }
             else {
@@ -1141,32 +1321,39 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         this.protocolHandler.setConnectionState(state, this.clientId);
         (0, telemetry_utils_1.raiseConnectedEvent)(this.mc.logger, this, state, this.clientId, disconnectedReason);
         if (logOpsOnReconnect) {
-            this.mc.logger.sendTelemetryEvent({ eventName: "OpsSentOnReconnect", count: this.messageCountAfterDisconnection });
+            this.mc.logger.sendTelemetryEvent({
+                eventName: "OpsSentOnReconnect",
+                count: this.messageCountAfterDisconnection,
+            });
         }
     }
     // back-compat: ADO #1385: Remove in the future, summary op should come through submitSummaryMessage()
     submitContainerMessage(type, contents, batch, metadata) {
+        var _a;
         switch (type) {
             case protocol_definitions_1.MessageType.Operation:
                 return this.submitMessage(type, JSON.stringify(contents), batch, metadata);
             case protocol_definitions_1.MessageType.Summarize:
                 return this.submitSummaryMessage(contents);
-            default:
-                this.close(new container_utils_1.GenericError("invalidContainerSubmitOpType", undefined /* error */, { messageType: type }));
+            default: {
+                const newError = new container_utils_1.GenericError("invalidContainerSubmitOpType", undefined /* error */, { messageType: type });
+                this.close(newError);
+                (_a = this.dispose) === null || _a === void 0 ? void 0 : _a.call(this, newError);
                 return -1;
+            }
         }
     }
     /** @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
@@ -1174,11 +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 });
@@ -1186,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);
@@ -1234,10 +1423,13 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         const version = await this.getVersion(specifiedVersion !== null && specifiedVersion !== void 0 ? specifiedVersion : null);
         if (version === undefined && specifiedVersion !== undefined) {
             // We should have a defined version to load from if specified version requested
-            this.mc.logger.sendErrorEvent({ eventName: "NoVersionFoundWhenSpecified", id: specifiedVersion });
+            this.mc.logger.sendErrorEvent({
+                eventName: "NoVersionFoundWhenSpecified",
+                id: specifiedVersion,
+            });
         }
         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 });
         }
@@ -1256,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) => 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) {