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

package/lib/container.js

@@ -7,7 +7,7 @@ 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 { GenericError, UsageError } from "@fluidframework/container-utils";
 import { readAndParse, OnlineStatus, isOnline, ensureFluidResolvedUrl, combineAppAndProtocolSummary, runWithRetry, isFluidResolvedUrl, } 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";
@@ -19,13 +19,13 @@ import { DeltaManagerProxy } from "./deltaManagerProxy";
 import { RelativeLoader } from "./loader";
 import { pkgVersion } from "./packageVersion";
 import { ContainerStorageAdapter } from "./containerStorageAdapter";
-import { createConnectionStateHandler, } from "./connectionStateHandler";
+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,15 +106,15 @@ 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
  */
-async function ReportIfTooLong(logger, eventName, action) {
+export async function ReportIfTooLong(logger, eventName, action) {
     const event = PerformanceEvent.start(logger, { eventName });
     const props = await action();
-    if (event.duration > 1000) {
+    if (event.duration > 200) {
         event.end(props);
     }
 }
@@ -133,6 +133,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 */
@@ -143,6 +158,7 @@ export class Container extends EventEmitterWithErrorHandling {
         this.attachStarted = false;
         this._dirtyContainer = false;
         this.setAutoReconnectTime = performance.now();
+        this._disposed = false;
         this.clientDetailsOverride = config.clientDetailsOverride;
         this._resolvedUrl = config.resolvedUrl;
         if (config.canReconnect !== undefined) {
@@ -196,17 +212,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
@@ -240,7 +262,9 @@ 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);
@@ -251,7 +275,8 @@ export class Container extends EventEmitterWithErrorHandling {
         // 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(() => {
+            Promise.resolve()
+                .then(() => {
                 switch (event) {
                     case dirtyContainerEvent:
                         if (this._dirtyContainer) {
@@ -275,7 +300,8 @@ export class Container extends EventEmitterWithErrorHandling {
                         break;
                     default:
                 }
-            }).catch((error) => {
+            })
+                .catch((error) => {
                 this.mc.logger.sendErrorEvent({ eventName: "RaiseConnectedEventError" }, error);
             });
         });
@@ -303,7 +329,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,7 +379,10 @@ 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;
@@ -369,8 +399,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;
     }
@@ -452,24 +486,39 @@ 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;
+    }
     /**
      * 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;
@@ -497,7 +546,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,6 +554,45 @@ 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: error === undefined ? "generic" : "error",
+                }, 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.storageService.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
@@ -522,6 +609,7 @@ export class Container extends EventEmitterWithErrorHandling {
             clientId: this.clientId,
         };
         this.mc.logger.sendTelemetryEvent({ eventName: "CloseAndGetPendingLocalState" });
+        // Only close here as method name suggests
         this.close();
         return JSON.stringify(pendingState);
     }
@@ -533,13 +621,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 +641,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;
@@ -587,7 +680,9 @@ 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);
@@ -609,7 +704,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 +718,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,23 +807,27 @@ 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);
@@ -762,7 +865,11 @@ 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) {
@@ -773,7 +880,11 @@ export class Container extends EventEmitterWithErrorHandling {
         }
         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.storageService.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.
@@ -826,8 +937,8 @@ export class Container extends EventEmitterWithErrorHandling {
         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();
             }
@@ -882,7 +993,8 @@ 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);
@@ -929,11 +1041,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 +1073,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 +1133,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 +1146,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;
@@ -1039,13 +1157,15 @@ export class Container extends EventEmitterWithErrorHandling {
         // eslint-disable-next-line @typescript-eslint/no-floating-promises
         deltaManager.inboundSignal.pause();
         deltaManager.on("connect", (details, _opsBehind) => {
-            assert(this.connectionMode === details.mode, "mismatch");
+            assert(this.connectionMode === details.mode, 0x4b7 /* mismatch */);
             this.connectionStateHandler.receivedConnectEvent(details);
         });
         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 +1183,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 +1213,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,19 +1257,26 @@ 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 */
@@ -1166,8 +1297,7 @@ export class Container extends EventEmitterWithErrorHandling {
         if (summary.details === undefined) {
             summary.details = {};
         }
-        summary.details.includesProtocolTree =
-            this.options.summarizeProtocolTree === true;
+        summary.details.includesProtocolTree = this.options.summarizeProtocolTree === true;
         return this.submitMessage(MessageType.Summarize, JSON.stringify(summary), false /* batch */);
     }
     submitMessage(type, contents, batch, metadata, compression) {
@@ -1226,10 +1356,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.storageService.getSnapshotTree(version))) !== null && _a !== void 0 ? _a : undefined;
         if (snapshot === undefined && version !== undefined) {
             this.mc.logger.sendErrorEvent({ eventName: "getSnapshotTreeFailed", id: version.id });
         }
@@ -1248,7 +1381,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) => this.submitSummaryMessage(summaryOp), (batch) => this.submitBatch(batch), (message) => this.submitSignal(message), (error) => { var _a; return (_a = this.dispose) === null || _a === void 0 ? void 0 : _a.call(this, error); }, (error) => this.close(error), Container.version, (dirty) => this.updateDirtyContainerState(dirty), existing, pendingLocalState);
         this.emit("contextChanged", codeDetails);
     }
     updateDirtyContainerState(dirty) {