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

package/lib/container.js

@@ -7,10 +7,10 @@ import merge from "lodash/merge";
 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 { GenericError, UsageError } from "@fluidframework/container-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,14 +18,14 @@ import { DeltaManager } from "./deltaManager";
 import { DeltaManagerProxy } from "./deltaManagerProxy";
 import { RelativeLoader } from "./loader";
 import { pkgVersion } from "./packageVersion";
-import { ContainerStorageAdapter } from "./containerStorageAdapter";
-import { createConnectionStateHandler, } from "./connectionStateHandler";
+import { ContainerStorageAdapter, getBlobContentsFromTree, getBlobContentsFromTreeWithBlobContents, } from "./containerStorageAdapter";
+import { createConnectionStateHandler } from "./connectionStateHandler";
 import { getProtocolSnapshotTree, getSnapshotTreeFromSerializedContainer } from "./utils";
-import { initQuorumValuesFromCodeDetails, getCodeDetailsFromQuorumValues, QuorumProxy } from "./quorum";
+import { initQuorumValuesFromCodeDetails, getCodeDetailsFromQuorumValues, QuorumProxy, } from "./quorum";
 import { CollabWindowTracker } from "./collabWindowTracker";
 import { ConnectionManager } from "./connectionManager";
 import { ConnectionState } from "./connectionState";
-import { ProtocolHandler, } from "./protocol";
+import { ProtocolHandler } from "./protocol";
 const detachedContainerRefSeqNumber = 0;
 const dirtyContainerEvent = "dirty";
 const savedContainerEvent = "saved";
@@ -65,8 +65,8 @@ export 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 = () => {
-            assert(container.connectionState === ConnectionState.CatchingUp
-                || container.connectionState === ConnectionState.Connected, 0x0cd /* "Container disconnected while waiting for ops!" */);
+            assert(container.connectionState === ConnectionState.CatchingUp ||
+                container.connectionState === ConnectionState.Connected, 0x0cd /* "Container disconnected while waiting for ops!" */);
             const hasCheckpointSequenceNumber = deltaManager.hasCheckpointSequenceNumber;
             const connectionOpSeqNumber = deltaManager.lastKnownSeqNumber;
             assert(deltaManager.lastSequenceNumber <= connectionOpSeqNumber, 0x266 /* "lastKnownSeqNumber should never be below last processed sequence number" */);
@@ -106,7 +106,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
@@ -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",
@@ -133,6 +139,21 @@ export class Container extends 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 = AttachState.Detached;
         /** During initialization we pause the inbound queues. We track this state to ensure we only call resume once */
@@ -142,7 +163,9 @@ 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;
         this._resolvedUrl = config.resolvedUrl;
         if (config.canReconnect !== undefined) {
@@ -179,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) => {
@@ -196,17 +218,23 @@ export class Container extends EventEmitterWithErrorHandling {
                 }
                 this.logConnectionStateChangeTelemetry(value, oldState, reason);
                 if (this._lifecycleState === "loaded") {
-                    this.propagateConnectionState(false /* initial transition */, value === ConnectionState.Disconnected ? reason : undefined /* disconnectedReason */);
+                    this.propagateConnectionState(false /* initial transition */, value === 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: performance.now() - this.connectionTransitionTimes[ConnectionState.CatchingUp] }, (details === undefined ? {} : { details: JSON.stringify(details) })));
+                    mode, category: this._lifecycleState === "loading" ? "generic" : category, duration: performance.now() -
+                        this.connectionTransitionTimes[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
@@ -220,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" &&
@@ -240,48 +275,17 @@ export class Container extends 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 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, {
@@ -303,7 +307,8 @@ export class Container extends EventEmitterWithErrorHandling {
                 reject(err !== null && err !== void 0 ? err : new 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);
             })
@@ -352,10 +357,13 @@ export class Container extends 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) {
@@ -369,8 +377,12 @@ export class Container extends 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;
     }
@@ -422,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.
@@ -452,24 +470,71 @@ export class Container extends 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 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
      */
     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() {
         assert(this.connectionState === ConnectionState.Disconnected, 0x0cf /* "disconnect event was not raised!" */);
-        assert(this._lifecycleState === "closed", 0x314 /* Container properly closed */);
+        assert(this._lifecycleState === "closed" || this._lifecycleState === "disposed", 0x314 /* Container properly closed */);
     }
     closeCore(error) {
         var _a, _b, _c;
@@ -479,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
@@ -497,7 +566,6 @@ export class Container extends EventEmitterWithErrorHandling {
                 this.mc.logger.sendErrorEvent({ eventName: "ContainerCloseException" }, exception);
             }
             this.emit("closed", error);
-            this.removeAllListeners();
             if (this.visibilityEventHandler !== undefined) {
                 document.removeEventListener("visibilitychange", this.visibilityEventHandler);
             }
@@ -506,22 +574,69 @@ export class Container extends EventEmitterWithErrorHandling {
             this._lifecycleState = "closed";
         }
     }
+    disposeCore(error) {
+        var _a, _b, _c;
+        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 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,
         };
         this.mc.logger.sendTelemetryEvent({ eventName: "CloseAndGetPendingLocalState" });
+        // Only close here as method name suggests
         this.close();
         return JSON.stringify(pendingState);
     }
@@ -533,13 +648,18 @@ export class Container extends EventEmitterWithErrorHandling {
         const appSummary = this.context.createSummary();
         const protocolSummary = this.captureProtocolSummary();
         const combinedSummary = combineAppAndProtocolSummary(appSummary, protocolSummary);
-        if (this.loader.services.detachedBlobStorage && this.loader.services.detachedBlobStorage.size > 0) {
-            combinedSummary.tree[".hasAttachmentBlobs"] = { type: SummaryType.Blob, content: "true" };
+        if (this.loader.services.detachedBlobStorage &&
+            this.loader.services.detachedBlobStorage.size > 0) {
+            combinedSummary.tree[".hasAttachmentBlobs"] = {
+                type: SummaryType.Blob,
+                content: "true",
+            };
         }
         return JSON.stringify(combinedSummary);
     }
     async attach(request) {
         await PerformanceEvent.timedExecAsync(this.mc.logger, { eventName: "Attach" }, async () => {
+            var _a;
             if (this._lifecycleState !== "loaded") {
                 // pre-0.58 error message: containerNotValidForAttach
                 throw new UsageError(`The Container is not in a valid state for attach [${this._lifecycleState}]`);
@@ -548,8 +668,8 @@ export class Container extends EventEmitterWithErrorHandling {
             assert(this._attachState === 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 {
                 assert(this.deltaManager.inbound.length === 0, 0x0d6 /* "Inbound queue should be empty when attaching" */);
                 let summary;
@@ -564,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);
@@ -578,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" */);
@@ -587,10 +713,12 @@ export class Container extends 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);
                         }
                     }
@@ -599,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,
@@ -609,7 +743,10 @@ export class Container extends EventEmitterWithErrorHandling {
                 this._attachState = AttachState.Attached;
                 this.emit("attached");
                 if (!this.closed) {
-                    this.resumeInternal({ fetchOpsFromStorage: false, reason: "createDetached" });
+                    this.resumeInternal({
+                        fetchOpsFromStorage: false,
+                        reason: "createDetached",
+                    });
                 }
             }
             catch (error) {
@@ -620,6 +757,7 @@ export class Container extends 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" });
@@ -708,26 +846,30 @@ export class Container extends 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 GenericError("Existing context does not satisfy incoming proposal"));
+        const error = new 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() {
@@ -749,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");
         }
@@ -762,32 +905,48 @@ export class Container extends 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 = AttachState.Attached;
         // 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.
@@ -795,44 +954,52 @@ 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) {
             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 PerformanceEvent.timedExecAsync(this.mc.logger, { eventName: "WaitOps" }, async () => opsBeforeReturnP);
+                await 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":
                     assert(this.inboundQueuePausedFromInit, 0x346 /* inboundQueuePausedFromInit should be true */);
                     this.inboundQueuePausedFromInit = false;
@@ -882,16 +1049,17 @@ export class Container extends EventEmitterWithErrorHandling {
     }
     async rehydrateDetachedFromSnapshot(detachedContainerSnapshot) {
         if (detachedContainerSnapshot.tree[".hasAttachmentBlobs"] !== undefined) {
-            assert(!!this.loader.services.detachedBlobStorage && this.loader.services.detachedBlobStorage.size > 0, 0x250 /* "serialized container with attachment blobs must be rehydrated with detached blob storage" */);
+            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 = 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: [],
@@ -929,11 +1097,12 @@ export class Container extends EventEmitterWithErrorHandling {
         };
         if (snapshot !== undefined) {
             const baseTree = getProtocolSnapshotTree(snapshot);
-            [quorumSnapshot.members, quorumSnapshot.proposals, quorumSnapshot.values] = await Promise.all([
-                readAndParse(storage, baseTree.blobs.quorumMembers),
-                readAndParse(storage, baseTree.blobs.quorumProposals),
-                readAndParse(storage, baseTree.blobs.quorumValues),
-            ]);
+            [quorumSnapshot.members, quorumSnapshot.proposals, quorumSnapshot.values] =
+                await Promise.all([
+                    readAndParse(storage, baseTree.blobs.quorumMembers),
+                    readAndParse(storage, baseTree.blobs.quorumProposals),
+                    readAndParse(storage, baseTree.blobs.quorumValues),
+                ]);
         }
         this.initializeProtocolState(attributes, quorumSnapshot);
     }
@@ -960,7 +1129,10 @@ export class Container extends EventEmitterWithErrorHandling {
                     });
                 }
                 this.processCodeProposal().catch((error) => {
-                    this.close(normalizeError(error));
+                    var _a;
+                    const normalizedError = normalizeError(error);
+                    this.close(normalizedError);
+                    (_a = this.dispose) === null || _a === void 0 ? void 0 : _a.call(this, normalizedError);
                     throw error;
                 });
             }
@@ -1017,7 +1189,10 @@ export class Container extends EventEmitterWithErrorHandling {
         if (this.clientDetailsOverride !== undefined) {
             merge(client.details, this.clientDetailsOverride);
         }
-        client.details.environment = [client.details.environment, ` loaderVersion:${pkgVersion}`].join(";");
+        client.details.environment = [
+            client.details.environment,
+            ` loaderVersion:${pkgVersion}`,
+        ].join(";");
         return client;
     }
     /**
@@ -1027,8 +1202,7 @@ export class Container extends EventEmitterWithErrorHandling {
      * If it's not true, runtime is not in position to send ops.
      */
     activeConnection() {
-        return this.connectionState === ConnectionState.Connected &&
-            this.connectionMode === "write";
+        return (this.connectionState === ConnectionState.Connected && this.connectionMode === "write");
     }
     createDeltaManager() {
         const serviceProvider = () => this.service;
@@ -1045,7 +1219,9 @@ export class Container extends 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;
@@ -1063,6 +1239,9 @@ export class Container extends EventEmitterWithErrorHandling {
         deltaManager.on("closed", (error) => {
             this.closeCore(error);
         });
+        deltaManager.on("disposed", (error) => {
+            this.disposeCore(error);
+        });
         return deltaManager;
     }
     async attachDeltaManagerOpHandler(attributes, prefetchType) {
@@ -1090,7 +1269,8 @@ export class Container extends EventEmitterWithErrorHandling {
         }
         else {
             if (value === ConnectionState.Connected) {
-                durationFromDisconnected = time - this.connectionTransitionTimes[ConnectionState.Disconnected];
+                durationFromDisconnected =
+                    time - this.connectionTransitionTimes[ConnectionState.Disconnected];
                 durationFromDisconnected = TelemetryLogger.formatTick(durationFromDisconnected);
             }
             else {
@@ -1133,32 +1313,39 @@ export class Container extends EventEmitterWithErrorHandling {
         this.protocolHandler.setConnectionState(state, this.clientId);
         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 MessageType.Operation:
                 return this.submitMessage(type, JSON.stringify(contents), batch, metadata);
             case MessageType.Summarize:
                 return this.submitSummaryMessage(contents);
-            default:
-                this.close(new GenericError("invalidContainerSubmitOpType", undefined /* error */, { messageType: type }));
+            default: {
+                const newError = new 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(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
@@ -1166,11 +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 });
@@ -1178,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);
@@ -1226,10 +1415,13 @@ export class Container extends 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 });
         }
@@ -1248,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) => 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) {