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

package/dist/container.js

@@ -7,7 +7,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Container = exports.waitContainerToCatchUp = void 0;
+exports.Container = exports.ReportIfTooLong = exports.waitContainerToCatchUp = void 0;
 // eslint-disable-next-line import/no-internal-modules
 const merge_1 = __importDefault(require("lodash/merge"));
 const uuid_1 = require("uuid");
@@ -71,8 +71,8 @@ async function waitContainerToCatchUp(container) {
         // Waiting for "connected" state in either case gets us at least to our own Join op
         // which is a reasonable approximation of "caught up"
         const waitForOps = () => {
-            (0, common_utils_1.assert)(container.connectionState === connectionState_1.ConnectionState.CatchingUp
-                || container.connectionState === connectionState_1.ConnectionState.Connected, 0x0cd /* "Container disconnected while waiting for ops!" */);
+            (0, common_utils_1.assert)(container.connectionState === connectionState_1.ConnectionState.CatchingUp ||
+                container.connectionState === connectionState_1.ConnectionState.Connected, 0x0cd /* "Container disconnected while waiting for ops!" */);
             const hasCheckpointSequenceNumber = deltaManager.hasCheckpointSequenceNumber;
             const connectionOpSeqNumber = deltaManager.lastKnownSeqNumber;
             (0, common_utils_1.assert)(deltaManager.lastSequenceNumber <= connectionOpSeqNumber, 0x266 /* "lastKnownSeqNumber should never be below last processed sequence number" */);
@@ -113,7 +113,7 @@ const getCodeProposal =
 // eslint-disable-next-line @typescript-eslint/no-unsafe-return
 (quorum) => { var _a; return (_a = quorum.get("code")) !== null && _a !== void 0 ? _a : quorum.get("code2"); };
 /**
- * Helper function to report to telemetry cases where operation takes longer than expected (1s)
+ * Helper function to report to telemetry cases where operation takes longer than expected (200ms)
  * @param logger - logger to use
  * @param eventName - event name
  * @param action - functor to call and measure
@@ -121,10 +121,11 @@ const getCodeProposal =
 async function ReportIfTooLong(logger, eventName, action) {
     const event = telemetry_utils_1.PerformanceEvent.start(logger, { eventName });
     const props = await action();
-    if (event.duration > 1000) {
+    if (event.duration > 200) {
         event.end(props);
     }
 }
+exports.ReportIfTooLong = ReportIfTooLong;
 const summarizerClientType = "summarizer";
 class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
     constructor(loader, config, protocolHandlerBuilder) {
@@ -140,6 +141,21 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         // Tells if container can reconnect on losing fist connection
         // If false, container gets closed on loss of connection.
         this._canReconnect = true;
+        /**
+         * Lifecycle state of the container, used mainly to prevent re-entrancy and telemetry
+         *
+         * States are allowed to progress to further states:
+         * "loading" - "loaded" - "closing" - "disposing" - "closed" - "disposed"
+         *
+         * For example, moving from "closed" to "disposing" is not allowed since it is an earlier state.
+         *
+         * loading: Container has been created, but is not yet in normal/loaded state
+         * loaded: Container is in normal/loaded state
+         * closing: Container has started closing process (for re-entrancy prevention)
+         * disposing: Container has started disposing process (for re-entrancy prevention)
+         * closed: Container has closed
+         * disposed: Container has been disposed
+         */
         this._lifecycleState = "loading";
         this._attachState = container_definitions_1.AttachState.Detached;
         /** During initialization we pause the inbound queues. We track this state to ensure we only call resume once */
@@ -150,6 +166,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         this.attachStarted = false;
         this._dirtyContainer = false;
         this.setAutoReconnectTime = common_utils_1.performance.now();
+        this._disposed = false;
         this.clientDetailsOverride = config.clientDetailsOverride;
         this._resolvedUrl = config.resolvedUrl;
         if (config.canReconnect !== undefined) {
@@ -203,17 +220,23 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                 }
                 this.logConnectionStateChangeTelemetry(value, oldState, reason);
                 if (this._lifecycleState === "loaded") {
-                    this.propagateConnectionState(false /* initial transition */, value === connectionState_1.ConnectionState.Disconnected ? reason : undefined /* disconnectedReason */);
+                    this.propagateConnectionState(false /* initial transition */, value === connectionState_1.ConnectionState.Disconnected
+                        ? reason
+                        : undefined /* disconnectedReason */);
                 }
             },
             shouldClientJoinWrite: () => this._deltaManager.connectionManager.shouldJoinWrite(),
             maxClientLeaveWaitTime: this.loader.services.options.maxClientLeaveWaitTime,
-            logConnectionIssue: (eventName, details) => {
+            logConnectionIssue: (eventName, category, details) => {
                 const mode = this.connectionMode;
                 // We get here when socket does not receive any ops on "write" connection, including
-                // its own join op. Attempt recovery option.
+                // its own join op.
+                // Report issues only if we already loaded container - op processing is paused while container is loading,
+                // so we always time-out processing of join op in cases where fetching snapshot takes a minute.
+                // It's not a problem with op processing itself - such issues should be tracked as part of boot perf monitoring instead.
                 this._deltaManager.logConnectionIssue(Object.assign({ eventName,
-                    mode, duration: common_utils_1.performance.now() - this.connectionTransitionTimes[connectionState_1.ConnectionState.CatchingUp] }, (details === undefined ? {} : { details: JSON.stringify(details) })));
+                    mode, category: this._lifecycleState === "loading" ? "generic" : category, duration: common_utils_1.performance.now() -
+                        this.connectionTransitionTimes[connectionState_1.ConnectionState.CatchingUp] }, (details === undefined ? {} : { details: JSON.stringify(details) })));
                 // If this is "write" connection, it took too long to receive join op. But in most cases that's due
                 // to very slow op fetches and we will eventually get there.
                 // For "read" connections, we get here due to self join signal not arriving on time. We will need to
@@ -247,7 +270,9 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                 }
                 else {
                     // settimeout so this will hopefully fire after disconnect event if being hidden caused it
-                    setTimeout(() => { this.lastVisible = undefined; }, 0);
+                    setTimeout(() => {
+                        this.lastVisible = undefined;
+                    }, 0);
                 }
             };
             document.addEventListener("visibilitychange", this.visibilityEventHandler);
@@ -258,7 +283,8 @@ class Container extends telemetry_utils_1.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) {
@@ -282,7 +308,8 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                         break;
                     default:
                 }
-            }).catch((error) => {
+            })
+                .catch((error) => {
                 this.mc.logger.sendErrorEvent({ eventName: "RaiseConnectedEventError" }, error);
             });
         });
@@ -310,7 +337,8 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                 reject(err !== null && err !== void 0 ? err : new container_utils_1.GenericError("Container closed without error during load"));
             };
             container.on("closed", onClosed);
-            container.load(version, mode, pendingLocalState)
+            container
+                .load(version, mode, pendingLocalState)
                 .finally(() => {
                 container.removeListener("closed", onClosed);
             })
@@ -359,7 +387,10 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         }
     }
     get closed() {
-        return (this._lifecycleState === "closing" || this._lifecycleState === "closed");
+        return (this._lifecycleState === "closing" ||
+            this._lifecycleState === "closed" ||
+            this._lifecycleState === "disposing" ||
+            this._lifecycleState === "disposed");
     }
     get storage() {
         return this.storageService;
@@ -376,8 +407,12 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         }
         return this._protocolHandler;
     }
-    get connectionMode() { return this._deltaManager.connectionManager.connectionMode; }
-    get IFluidRouter() { return this; }
+    get connectionMode() {
+        return this._deltaManager.connectionManager.connectionMode;
+    }
+    get IFluidRouter() {
+        return this;
+    }
     get resolvedUrl() {
         return this._resolvedUrl;
     }
@@ -459,24 +494,39 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
     get isDirty() {
         return this._dirtyContainer;
     }
-    get serviceFactory() { return this.loader.services.documentServiceFactory; }
-    get urlResolver() { return this.loader.services.urlResolver; }
-    get scope() { return this.loader.services.scope; }
-    get codeLoader() { return this.loader.services.codeLoader; }
+    get serviceFactory() {
+        return this.loader.services.documentServiceFactory;
+    }
+    get urlResolver() {
+        return this.loader.services.urlResolver;
+    }
+    get scope() {
+        return this.loader.services.scope;
+    }
+    get codeLoader() {
+        return this.loader.services.codeLoader;
+    }
     /**
      * Retrieves the quorum associated with the document
      */
     getQuorum() {
         return this.protocolHandler.quorum;
     }
+    dispose(error) {
+        this._deltaManager.close(error, true /* doDispose */);
+        this.verifyClosed();
+    }
     close(error) {
         // 1. Ensure that close sequence is exactly the same no matter if it's initiated by host or by DeltaManager
         // 2. We need to ensure that we deliver disconnect event to runtime properly. See connectionStateChanged
         //    handler. We only deliver events if container fully loaded. Transitioning from "loading" ->
         //    "closing" will lose that info (can also solve by tracking extra state).
         this._deltaManager.close(error);
+        this.verifyClosed();
+    }
+    verifyClosed() {
         (0, common_utils_1.assert)(this.connectionState === connectionState_1.ConnectionState.Disconnected, 0x0cf /* "disconnect event was not raised!" */);
-        (0, common_utils_1.assert)(this._lifecycleState === "closed", 0x314 /* Container properly closed */);
+        (0, common_utils_1.assert)(this._lifecycleState === "closed" || this._lifecycleState === "disposed", 0x314 /* Container properly closed */);
     }
     closeCore(error) {
         var _a, _b, _c;
@@ -504,7 +554,6 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                 this.mc.logger.sendErrorEvent({ eventName: "ContainerCloseException" }, exception);
             }
             this.emit("closed", error);
-            this.removeAllListeners();
             if (this.visibilityEventHandler !== undefined) {
                 document.removeEventListener("visibilitychange", this.visibilityEventHandler);
             }
@@ -513,6 +562,45 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             this._lifecycleState = "closed";
         }
     }
+    disposeCore(error) {
+        var _a, _b, _c;
+        (0, common_utils_1.assert)(!this._disposed, 0x54c /* Container already disposed */);
+        this._disposed = true;
+        try {
+            // Ensure that we raise all key events even if one of these throws
+            try {
+                // Raise event first, to ensure we capture _lifecycleState before transition.
+                // This gives us a chance to know what errors happened on open vs. on fully loaded container.
+                this.mc.logger.sendTelemetryEvent({
+                    eventName: "ContainerDispose",
+                    category: 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
@@ -529,6 +617,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             clientId: this.clientId,
         };
         this.mc.logger.sendTelemetryEvent({ eventName: "CloseAndGetPendingLocalState" });
+        // Only close here as method name suggests
         this.close();
         return JSON.stringify(pendingState);
     }
@@ -540,13 +629,18 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         const appSummary = this.context.createSummary();
         const protocolSummary = this.captureProtocolSummary();
         const combinedSummary = (0, driver_utils_1.combineAppAndProtocolSummary)(appSummary, protocolSummary);
-        if (this.loader.services.detachedBlobStorage && this.loader.services.detachedBlobStorage.size > 0) {
-            combinedSummary.tree[".hasAttachmentBlobs"] = { type: protocol_definitions_1.SummaryType.Blob, content: "true" };
+        if (this.loader.services.detachedBlobStorage &&
+            this.loader.services.detachedBlobStorage.size > 0) {
+            combinedSummary.tree[".hasAttachmentBlobs"] = {
+                type: protocol_definitions_1.SummaryType.Blob,
+                content: "true",
+            };
         }
         return JSON.stringify(combinedSummary);
     }
     async attach(request) {
         await telemetry_utils_1.PerformanceEvent.timedExecAsync(this.mc.logger, { eventName: "Attach" }, async () => {
+            var _a;
             if (this._lifecycleState !== "loaded") {
                 // pre-0.58 error message: containerNotValidForAttach
                 throw new container_utils_1.UsageError(`The Container is not in a valid state for attach [${this._lifecycleState}]`);
@@ -555,8 +649,8 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             (0, common_utils_1.assert)(this._attachState === container_definitions_1.AttachState.Detached && !this.attachStarted, 0x205 /* "attach() called more than once" */);
             this.attachStarted = true;
             // If attachment blobs were uploaded in detached state we will go through a different attach flow
-            const hasAttachmentBlobs = this.loader.services.detachedBlobStorage !== undefined
-                && this.loader.services.detachedBlobStorage.size > 0;
+            const hasAttachmentBlobs = this.loader.services.detachedBlobStorage !== undefined &&
+                this.loader.services.detachedBlobStorage.size > 0;
             try {
                 (0, common_utils_1.assert)(this.deltaManager.inbound.length === 0, 0x0d6 /* "Inbound queue should be empty when attaching" */);
                 let summary;
@@ -594,7 +688,9 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                     const redirectTable = new Map();
                     // if new blobs are added while uploading, upload them too
                     while (redirectTable.size < this.loader.services.detachedBlobStorage.size) {
-                        const newIds = this.loader.services.detachedBlobStorage.getBlobIds().filter((id) => !redirectTable.has(id));
+                        const newIds = this.loader.services.detachedBlobStorage
+                            .getBlobIds()
+                            .filter((id) => !redirectTable.has(id));
                         for (const id of newIds) {
                             const blob = await this.loader.services.detachedBlobStorage.readBlob(id);
                             const response = await this.storageService.createBlob(blob);
@@ -616,7 +712,10 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                 this._attachState = container_definitions_1.AttachState.Attached;
                 this.emit("attached");
                 if (!this.closed) {
-                    this.resumeInternal({ fetchOpsFromStorage: false, reason: "createDetached" });
+                    this.resumeInternal({
+                        fetchOpsFromStorage: false,
+                        reason: "createDetached",
+                    });
                 }
             }
             catch (error) {
@@ -627,6 +726,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                     newError.addTelemetryProperties({ resolvedUrl: resolvedUrl.url });
                 }
                 this.close(newError);
+                (_a = this.dispose) === null || _a === void 0 ? void 0 : _a.call(this, newError);
                 throw newError;
             }
         }, { start: true, end: true, cancel: "generic" });
@@ -715,23 +815,27 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                 throw new Error("Proposed code details should be greater than the current");
             }
         }
-        return this.protocolHandler.quorum.propose("code", codeDetails)
+        return this.protocolHandler.quorum
+            .propose("code", codeDetails)
             .then(() => true)
             .catch(() => false);
     }
     async processCodeProposal() {
+        var _a;
         const codeDetails = this.getCodeDetailsFromQuorum();
         await Promise.all([
             this.deltaManager.inbound.pause(),
-            this.deltaManager.inboundSignal.pause()
+            this.deltaManager.inboundSignal.pause(),
         ]);
-        if ((await this.context.satisfies(codeDetails) === true)) {
+        if ((await this.context.satisfies(codeDetails)) === true) {
             this.deltaManager.inbound.resume();
             this.deltaManager.inboundSignal.resume();
             return;
         }
         // pre-0.58 error message: existingContextDoesNotSatisfyIncomingProposal
-        this.close(new container_utils_1.GenericError("Existing context does not satisfy incoming proposal"));
+        const error = new container_utils_1.GenericError("Existing context does not satisfy incoming proposal");
+        this.close(error);
+        (_a = this.dispose) === null || _a === void 0 ? void 0 : _a.call(this, error);
     }
     async getVersion(version) {
         const versions = await this.storageService.getVersions(version, 1);
@@ -769,7 +873,11 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         // connections to same file) in two ways:
         // A) creation flow breaks (as one of the clients "sees" file as existing, and hits #2 above)
         // B) Once file is created, transition from view-only connection to write does not work - some bugs to be fixed.
-        const connectionArgs = { reason: "DocumentOpen", mode: "write", fetchOpsFromStorage: false };
+        const connectionArgs = {
+            reason: "DocumentOpen",
+            mode: "write",
+            fetchOpsFromStorage: false,
+        };
         // Start websocket connection as soon as possible. Note that there is no op handler attached yet, but the
         // DeltaManager is resilient to this and will wait to start processing ops until after it is attached.
         if (loadMode.deltaConnection === undefined) {
@@ -780,7 +888,11 @@ class Container extends telemetry_utils_1.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 = container_definitions_1.AttachState.Attached;
         // Fetch specified snapshot.
@@ -833,8 +945,8 @@ class Container extends telemetry_utils_1.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 telemetry_utils_1.PerformanceEvent.timedExecAsync(this.mc.logger, { eventName: "WaitOps" }, async () => opsBeforeReturnP);
+                await telemetry_utils_1.PerformanceEvent.timedExecAsync(this.mc.logger, { eventName: "WaitOpProcessing" }, async () => this._deltaManager.inbound.waitTillProcessingDone());
                 // eslint-disable-next-line @typescript-eslint/no-floating-promises
                 this._deltaManager.inbound.pause();
             }
@@ -889,7 +1001,8 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
     }
     async rehydrateDetachedFromSnapshot(detachedContainerSnapshot) {
         if (detachedContainerSnapshot.tree[".hasAttachmentBlobs"] !== undefined) {
-            (0, common_utils_1.assert)(!!this.loader.services.detachedBlobStorage && this.loader.services.detachedBlobStorage.size > 0, 0x250 /* "serialized container with attachment blobs must be rehydrated with detached blob storage" */);
+            (0, common_utils_1.assert)(!!this.loader.services.detachedBlobStorage &&
+                this.loader.services.detachedBlobStorage.size > 0, 0x250 /* "serialized container with attachment blobs must be rehydrated with detached blob storage" */);
             delete detachedContainerSnapshot.tree[".hasAttachmentBlobs"];
         }
         const snapshotTree = (0, utils_1.getSnapshotTreeFromSerializedContainer)(detachedContainerSnapshot);
@@ -936,11 +1049,12 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         };
         if (snapshot !== undefined) {
             const baseTree = (0, utils_1.getProtocolSnapshotTree)(snapshot);
-            [quorumSnapshot.members, quorumSnapshot.proposals, quorumSnapshot.values] = await Promise.all([
-                (0, driver_utils_1.readAndParse)(storage, baseTree.blobs.quorumMembers),
-                (0, driver_utils_1.readAndParse)(storage, baseTree.blobs.quorumProposals),
-                (0, driver_utils_1.readAndParse)(storage, baseTree.blobs.quorumValues),
-            ]);
+            [quorumSnapshot.members, quorumSnapshot.proposals, quorumSnapshot.values] =
+                await Promise.all([
+                    (0, driver_utils_1.readAndParse)(storage, baseTree.blobs.quorumMembers),
+                    (0, driver_utils_1.readAndParse)(storage, baseTree.blobs.quorumProposals),
+                    (0, driver_utils_1.readAndParse)(storage, baseTree.blobs.quorumValues),
+                ]);
         }
         this.initializeProtocolState(attributes, quorumSnapshot);
     }
@@ -967,7 +1081,10 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                     });
                 }
                 this.processCodeProposal().catch((error) => {
-                    this.close((0, telemetry_utils_1.normalizeError)(error));
+                    var _a;
+                    const normalizedError = (0, telemetry_utils_1.normalizeError)(error);
+                    this.close(normalizedError);
+                    (_a = this.dispose) === null || _a === void 0 ? void 0 : _a.call(this, normalizedError);
                     throw error;
                 });
             }
@@ -1024,7 +1141,10 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         if (this.clientDetailsOverride !== undefined) {
             (0, merge_1.default)(client.details, this.clientDetailsOverride);
         }
-        client.details.environment = [client.details.environment, ` loaderVersion:${packageVersion_1.pkgVersion}`].join(";");
+        client.details.environment = [
+            client.details.environment,
+            ` loaderVersion:${packageVersion_1.pkgVersion}`,
+        ].join(";");
         return client;
     }
     /**
@@ -1034,8 +1154,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
      * If it's not true, runtime is not in position to send ops.
      */
     activeConnection() {
-        return this.connectionState === connectionState_1.ConnectionState.Connected &&
-            this.connectionMode === "write";
+        return (this.connectionState === connectionState_1.ConnectionState.Connected && this.connectionMode === "write");
     }
     createDeltaManager() {
         const serviceProvider = () => this.service;
@@ -1046,13 +1165,15 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         // eslint-disable-next-line @typescript-eslint/no-floating-promises
         deltaManager.inboundSignal.pause();
         deltaManager.on("connect", (details, _opsBehind) => {
-            (0, common_utils_1.assert)(this.connectionMode === details.mode, "mismatch");
+            (0, common_utils_1.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;
@@ -1070,6 +1191,9 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         deltaManager.on("closed", (error) => {
             this.closeCore(error);
         });
+        deltaManager.on("disposed", (error) => {
+            this.disposeCore(error);
+        });
         return deltaManager;
     }
     async attachDeltaManagerOpHandler(attributes, prefetchType) {
@@ -1097,7 +1221,8 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         }
         else {
             if (value === connectionState_1.ConnectionState.Connected) {
-                durationFromDisconnected = time - this.connectionTransitionTimes[connectionState_1.ConnectionState.Disconnected];
+                durationFromDisconnected =
+                    time - this.connectionTransitionTimes[connectionState_1.ConnectionState.Disconnected];
                 durationFromDisconnected = telemetry_utils_1.TelemetryLogger.formatTick(durationFromDisconnected);
             }
             else {
@@ -1140,19 +1265,26 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         this.protocolHandler.setConnectionState(state, this.clientId);
         (0, telemetry_utils_1.raiseConnectedEvent)(this.mc.logger, this, state, this.clientId, disconnectedReason);
         if (logOpsOnReconnect) {
-            this.mc.logger.sendTelemetryEvent({ eventName: "OpsSentOnReconnect", count: this.messageCountAfterDisconnection });
+            this.mc.logger.sendTelemetryEvent({
+                eventName: "OpsSentOnReconnect",
+                count: this.messageCountAfterDisconnection,
+            });
         }
     }
     // back-compat: ADO #1385: Remove in the future, summary op should come through submitSummaryMessage()
     submitContainerMessage(type, contents, batch, metadata) {
+        var _a;
         switch (type) {
             case protocol_definitions_1.MessageType.Operation:
                 return this.submitMessage(type, JSON.stringify(contents), batch, metadata);
             case protocol_definitions_1.MessageType.Summarize:
                 return this.submitSummaryMessage(contents);
-            default:
-                this.close(new container_utils_1.GenericError("invalidContainerSubmitOpType", undefined /* error */, { messageType: type }));
+            default: {
+                const newError = new container_utils_1.GenericError("invalidContainerSubmitOpType", undefined /* error */, { messageType: type });
+                this.close(newError);
+                (_a = this.dispose) === null || _a === void 0 ? void 0 : _a.call(this, newError);
                 return -1;
+            }
         }
     }
     /** @returns clientSequenceNumber of last message in a batch */
@@ -1173,8 +1305,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         if (summary.details === undefined) {
             summary.details = {};
         }
-        summary.details.includesProtocolTree =
-            this.options.summarizeProtocolTree === true;
+        summary.details.includesProtocolTree = this.options.summarizeProtocolTree === true;
         return this.submitMessage(protocol_definitions_1.MessageType.Summarize, JSON.stringify(summary), false /* batch */);
     }
     submitMessage(type, contents, batch, metadata, compression) {
@@ -1233,10 +1364,13 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         const version = await this.getVersion(specifiedVersion !== null && specifiedVersion !== void 0 ? specifiedVersion : null);
         if (version === undefined && specifiedVersion !== undefined) {
             // We should have a defined version to load from if specified version requested
-            this.mc.logger.sendErrorEvent({ eventName: "NoVersionFoundWhenSpecified", id: specifiedVersion });
+            this.mc.logger.sendErrorEvent({
+                eventName: "NoVersionFoundWhenSpecified",
+                id: specifiedVersion,
+            });
         }
         this._loadedFromVersion = version;
-        const snapshot = (_a = await this.storageService.getSnapshotTree(version)) !== null && _a !== void 0 ? _a : undefined;
+        const snapshot = (_a = (await this.storageService.getSnapshotTree(version))) !== null && _a !== void 0 ? _a : undefined;
         if (snapshot === undefined && version !== undefined) {
             this.mc.logger.sendErrorEvent({ eventName: "getSnapshotTreeFailed", id: version.id });
         }
@@ -1255,7 +1389,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         // The relative loader will proxy requests to '/' to the loader itself assuming no non-cache flags
         // are set. Global requests will still go directly to the loader
         const loader = new loader_1.RelativeLoader(this, this.loader);
-        this._context = await containerContext_1.ContainerContext.createOrLoad(this, this.scope, this.codeLoader, codeDetails, snapshot, new deltaManagerProxy_1.DeltaManagerProxy(this._deltaManager), new quorum_1.QuorumProxy(this.protocolHandler.quorum), loader, (type, contents, batch, metadata) => this.submitContainerMessage(type, contents, batch, metadata), (summaryOp) => this.submitSummaryMessage(summaryOp), (batch) => this.submitBatch(batch), (message) => this.submitSignal(message), (error) => this.close(error), Container.version, (dirty) => this.updateDirtyContainerState(dirty), existing, pendingLocalState);
+        this._context = await containerContext_1.ContainerContext.createOrLoad(this, this.scope, this.codeLoader, codeDetails, snapshot, new deltaManagerProxy_1.DeltaManagerProxy(this._deltaManager), new quorum_1.QuorumProxy(this.protocolHandler.quorum), loader, (type, contents, batch, metadata) => this.submitContainerMessage(type, contents, batch, metadata), (summaryOp) => 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) {