@fluidframework/container-loader 2.0.0-dev.4.4.0.162253 → 2.0.0-dev.5.2.0.169897

package/lib/container.js

@@ -8,7 +8,7 @@ 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, isCombinedAppAndProtocolSummary, } from "@fluidframework/driver-utils";
+import { readAndParse, OnlineStatus, isOnline, combineAppAndProtocolSummary, runWithRetry, isCombinedAppAndProtocolSummary, } from "@fluidframework/driver-utils";
 import { MessageType, SummaryType, } from "@fluidframework/protocol-definitions";
 import { ChildLogger, EventEmitterWithErrorHandling, PerformanceEvent, raiseConnectedEvent, TelemetryLogger, connectedEventName, normalizeError, loggerToMonitoringContext, wrapError, } from "@fluidframework/telemetry-utils";
 import { Audience } from "./audience";
@@ -119,26 +119,18 @@ 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, _c;
+    constructor(createProps, loadProps) {
+        var _a;
         super((name, error) => {
             this.mc.logger.sendErrorEvent({
                 eventName: "ContainerEventHandlerException",
                 name: typeof name === "string" ? name : undefined,
             }, error);
         });
-        this.loader = loader;
-        this.protocolHandlerBuilder = protocolHandlerBuilder;
-        // 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
          *
@@ -166,26 +158,41 @@ export class Container extends EventEmitterWithErrorHandling {
         this.savedOps = [];
         this.setAutoReconnectTime = performance.now();
         this._disposed = false;
-        this.clientDetailsOverride = config.clientDetailsOverride;
-        this._resolvedUrl = config.resolvedUrl;
-        if (config.canReconnect !== undefined) {
-            this._canReconnect = config.canReconnect;
-        }
+        const { canReconnect, clientDetailsOverride, urlResolver, documentServiceFactory, codeLoader, options, scope, subLogger, detachedBlobStorage, protocolHandlerBuilder, } = createProps;
+        this.connectionTransitionTimes[ConnectionState.Disconnected] = performance.now();
+        const pendingLocalState = loadProps === null || loadProps === void 0 ? void 0 : loadProps.pendingLocalState;
+        this._canReconnect = canReconnect !== null && canReconnect !== void 0 ? canReconnect : true;
+        this.clientDetailsOverride = clientDetailsOverride;
+        this.urlResolver = urlResolver;
+        this.serviceFactory = documentServiceFactory;
+        this.codeLoader = codeLoader;
+        // Warning: this is only a shallow clone. Mutation of any individual loader option will mutate it for
+        // all clients that were loaded from the same loader (including summarizer clients).
+        // Tracking alternative ways to handle this in AB#4129.
+        this.options = Object.assign({}, options);
+        this.scope = scope;
+        this.detachedBlobStorage = detachedBlobStorage;
+        this.protocolHandlerBuilder =
+            protocolHandlerBuilder !== null && protocolHandlerBuilder !== void 0 ? protocolHandlerBuilder : ((...args) => new ProtocolHandler(...args, new Audience()));
+        // Note that we capture the createProps here so we can replicate the creation call when we want to clone.
+        this.clone = async (_loadProps, createParamOverrides) => {
+            return Container.load(_loadProps, Object.assign(Object.assign({}, createProps), createParamOverrides));
+        };
         // Create logger for data stores to use
         const type = this.client.details.type;
         const interactive = this.client.details.capabilities.interactive;
         const clientType = `${interactive ? "interactive" : "noninteractive"}${type !== undefined && type !== "" ? `/${type}` : ""}`;
         // Need to use the property getter for docId because for detached flow we don't have the docId initially.
         // We assign the id later so property getter is used.
-        this.subLogger = ChildLogger.create(loader.services.subLogger, undefined, {
+        this.subLogger = ChildLogger.create(subLogger, undefined, {
             all: {
                 clientType,
                 containerId: uuid(),
-                docId: () => { var _a, _b; return (_b = (_a = this._resolvedUrl) === null || _a === void 0 ? void 0 : _a.id) !== null && _b !== void 0 ? _b : undefined; },
+                docId: () => { var _a; return (_a = this.resolvedUrl) === null || _a === void 0 ? void 0 : _a.id; },
                 containerAttachState: () => this._attachState,
                 containerLifecycleState: () => this._lifecycleState,
                 containerConnectionState: () => ConnectionState[this.connectionState],
-                serializedContainer: config.serializedContainerState !== undefined,
+                serializedContainer: pendingLocalState !== undefined,
             },
             // we need to be judicious with our logging here to avoid generating too much data
             // all data logged here should be broadly applicable, and not specific to a
@@ -208,10 +215,6 @@ export class Container extends EventEmitterWithErrorHandling {
         });
         // Prefix all events in this file with container-loader
         this.mc = loggerToMonitoringContext(ChildLogger.create(this.subLogger, "Container"));
-        // Warning: this is only a shallow clone. Mutation of any individual loader option will mutate it for
-        // all clients that were loaded from the same loader (including summarizer clients).
-        // Tracking alternative ways to handle this in AB#4129.
-        this.options = Object.assign({}, this.loader.services.options);
         this._deltaManager = this.createDeltaManager();
         this.connectionStateHandler = createConnectionStateHandler({
             logger: this.mc.logger,
@@ -227,7 +230,7 @@ export class Container extends EventEmitterWithErrorHandling {
                 }
             },
             shouldClientJoinWrite: () => this._deltaManager.connectionManager.shouldJoinWrite(),
-            maxClientLeaveWaitTime: this.loader.services.options.maxClientLeaveWaitTime,
+            maxClientLeaveWaitTime: options.maxClientLeaveWaitTime,
             logConnectionIssue: (eventName, category, details) => {
                 const mode = this.connectionMode;
                 // We get here when socket does not receive any ops on "write" connection, including
@@ -251,7 +254,7 @@ export class Container extends EventEmitterWithErrorHandling {
                     this.connect();
                 }
             },
-        }, this.deltaManager, (_a = config.serializedContainerState) === null || _a === void 0 ? void 0 : _a.clientId);
+        }, this.deltaManager, pendingLocalState === null || pendingLocalState === void 0 ? void 0 : pendingLocalState.clientId);
         this.on(savedContainerEvent, () => {
             this.connectionStateHandler.containerSaved();
         });
@@ -263,8 +266,8 @@ export class Container extends EventEmitterWithErrorHandling {
             : 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 forceEnableSummarizeProtocolTree = (_a = this.mc.config.getBoolean("Fluid.Container.summarizeProtocolTree2")) !== null && _a !== void 0 ? _a : options.summarizeProtocolTree;
+        this.storageAdapter = new ContainerStorageAdapter(detachedBlobStorage, this.mc.logger, pendingLocalState === null || pendingLocalState === void 0 ? void 0 : pendingLocalState.snapshotBlobs, addProtocolSummaryIfMissing, forceEnableSummarizeProtocolTree);
         const isDomAvailable = typeof document === "object" &&
             document !== null &&
             typeof document.addEventListener === "function" &&
@@ -290,33 +293,28 @@ export class Container extends EventEmitterWithErrorHandling {
      * Load an existing container.
      * @internal
      */
-    static async load(loader, loadOptions, pendingLocalState, protocolHandlerBuilder) {
-        const container = new Container(loader, {
-            clientDetailsOverride: loadOptions.clientDetailsOverride,
-            resolvedUrl: loadOptions.resolvedUrl,
-            canReconnect: loadOptions.canReconnect,
-            serializedContainerState: pendingLocalState,
-        }, protocolHandlerBuilder);
+    static async load(loadProps, createProps) {
+        const { version, pendingLocalState, loadMode, resolvedUrl } = loadProps;
+        const container = new Container(createProps, loadProps);
+        const disableRecordHeapSize = container.mc.config.getBoolean("Fluid.Loader.DisableRecordHeapSize");
         return PerformanceEvent.timedExecAsync(container.mc.logger, { eventName: "Load" }, async (event) => new Promise((resolve, reject) => {
-            var _a, _b;
-            const version = loadOptions.version;
             const defaultMode = { opsBeforeReturn: "cached" };
             // if we have pendingLocalState, anything we cached is not useful and we shouldn't wait for connection
             // to return container, so ignore this value and use undefined for opsBeforeReturn
             const mode = pendingLocalState
-                ? Object.assign(Object.assign({}, ((_a = loadOptions.loadMode) !== null && _a !== void 0 ? _a : defaultMode)), { opsBeforeReturn: undefined }) : (_b = loadOptions.loadMode) !== null && _b !== void 0 ? _b : defaultMode;
+                ? Object.assign(Object.assign({}, (loadMode !== null && loadMode !== void 0 ? loadMode : defaultMode)), { opsBeforeReturn: undefined }) : loadMode !== null && loadMode !== void 0 ? loadMode : defaultMode;
             const onClosed = (err) => {
                 // pre-0.58 error message: containerClosedWithoutErrorDuringLoad
                 reject(err !== null && err !== void 0 ? err : new GenericError("Container closed without error during load"));
             };
             container.on("closed", onClosed);
             container
-                .load(version, mode, pendingLocalState)
+                .load(version, mode, resolvedUrl, pendingLocalState)
                 .finally(() => {
                 container.removeListener("closed", onClosed);
             })
                 .then((props) => {
-                event.end(Object.assign(Object.assign({}, props), loadOptions.loadMode));
+                event.end(Object.assign(Object.assign({}, props), loadMode));
                 resolve(container);
             }, (error) => {
                 const err = normalizeError(error);
@@ -326,13 +324,13 @@ export class Container extends EventEmitterWithErrorHandling {
                 container.close(err);
                 onClosed(err);
             });
-        }), { start: true, end: true, cancel: "generic" });
+        }), { start: true, end: true, cancel: "generic" }, disableRecordHeapSize !== true /* recordHeapSize */);
     }
     /**
      * Create a new container in a detached state.
      */
-    static async createDetached(loader, codeDetails, protocolHandlerBuilder) {
-        const container = new Container(loader, {}, protocolHandlerBuilder);
+    static async createDetached(createProps, codeDetails) {
+        const container = new Container(createProps);
         return PerformanceEvent.timedExecAsync(container.mc.logger, { eventName: "CreateDetached" }, async (_event) => {
             await container.createDetached(codeDetails);
             return container;
@@ -342,8 +340,8 @@ export class Container extends EventEmitterWithErrorHandling {
      * Create a new container in a detached state that is initialized with a
      * snapshot from a previous detached container.
      */
-    static async rehydrateDetachedFromSnapshot(loader, snapshot, protocolHandlerBuilder) {
-        const container = new Container(loader, {}, protocolHandlerBuilder);
+    static async rehydrateDetachedFromSnapshot(createProps, snapshot) {
+        const container = new Container(createProps);
         return PerformanceEvent.timedExecAsync(container.mc.logger, { eventName: "RehydrateDetachedFromSnapshot" }, async (_event) => {
             const deserializedSummary = JSON.parse(snapshot);
             await container.rehydrateDetachedFromSnapshot(deserializedSummary);
@@ -387,7 +385,19 @@ export class Container extends EventEmitterWithErrorHandling {
         return this;
     }
     get resolvedUrl() {
-        return this._resolvedUrl;
+        var _a;
+        /**
+         * All attached containers will have a document service,
+         * this is required, as attached containers are attached to
+         * a service. Detached containers will neither have a document
+         * service or a resolved url as they only exist locally.
+         * in order to create a document service a resolved url must
+         * first be obtained, this is how the container is identified.
+         * Because of this, the document service's resolved url
+         * is always the same as the containers, as we had to
+         * obtain the resolved url, and then create the service from it.
+         */
+        return (_a = this.service) === null || _a === void 0 ? void 0 : _a.resolvedUrl;
     }
     get loadedFromVersion() {
         return this._loadedFromVersion;
@@ -473,18 +483,6 @@ 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;
-    }
     /**
      * {@inheritDoc @fluidframework/container-definitions#IContainer.entryPoint}
      */
@@ -524,7 +522,7 @@ export class Container extends EventEmitterWithErrorHandling {
         return this.protocolHandler.quorum;
     }
     dispose(error) {
-        this._deltaManager.close(error, true /* doDispose */);
+        this._deltaManager.dispose(error);
         this.verifyClosed();
     }
     close(error) {
@@ -540,7 +538,7 @@ export class Container extends EventEmitterWithErrorHandling {
         assert(this._lifecycleState === "closed" || this._lifecycleState === "disposed", 0x314 /* Container properly closed */);
     }
     closeCore(error) {
-        var _a, _b, _c;
+        var _a;
         assert(!this.closed, 0x315 /* re-entrancy */);
         try {
             // Ensure that we raise all key events even if one of these throws
@@ -558,12 +556,6 @@ export class Container extends EventEmitterWithErrorHandling {
                 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.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: "ContainerCloseException" }, exception);
@@ -652,8 +644,7 @@ 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) {
+        if (this.detachedBlobStorage && this.detachedBlobStorage.size > 0) {
             combinedSummary.tree[".hasAttachmentBlobs"] = {
                 type: SummaryType.Blob,
                 content: "true",
@@ -672,8 +663,7 @@ 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.detachedBlobStorage !== undefined && this.detachedBlobStorage.size > 0;
             try {
                 assert(this.deltaManager.inbound.length === 0, 0x0d6 /* "Inbound queue should be empty when attaching" */);
                 let summary;
@@ -697,31 +687,28 @@ export class Container extends EventEmitterWithErrorHandling {
                     }
                 }
                 // Actually go and create the resolved document
-                const createNewResolvedUrl = await this.urlResolver.resolve(request);
-                ensureFluidResolvedUrl(createNewResolvedUrl);
                 if (this.service === undefined) {
-                    assert(this.client.details.type !== summarizerClientType, 0x2c4 /* "client should not be summarizer before container is created" */);
+                    const createNewResolvedUrl = await this.urlResolver.resolve(request);
+                    assert(this.client.details.type !== summarizerClientType &&
+                        createNewResolvedUrl !== undefined, 0x2c4 /* "client should not be summarizer before container is created" */);
                     this.service = await runWithRetry(async () => this.serviceFactory.createContainer(summary, createNewResolvedUrl, this.subLogger, false), "containerAttach", this.mc.logger, {
                         cancel: this.closeSignal,
                     });
                 }
-                const resolvedUrl = this.service.resolvedUrl;
-                ensureFluidResolvedUrl(resolvedUrl);
-                this._resolvedUrl = resolvedUrl;
                 await this.storageAdapter.connectToService(this.service);
                 if (hasAttachmentBlobs) {
                     // upload blobs to storage
-                    assert(!!this.loader.services.detachedBlobStorage, 0x24e /* "assertion for type narrowing" */);
+                    assert(!!this.detachedBlobStorage, 0x24e /* "assertion for type narrowing" */);
                     // build a table mapping IDs assigned locally to IDs assigned by storage and pass it to runtime to
                     // support blob handles that only know about the local IDs
                     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
+                    while (redirectTable.size < this.detachedBlobStorage.size) {
+                        const newIds = this.detachedBlobStorage
                             .getBlobIds()
                             .filter((id) => !redirectTable.has(id));
                         for (const id of newIds) {
-                            const blob = await this.loader.services.detachedBlobStorage.readBlob(id);
+                            const blob = await this.detachedBlobStorage.readBlob(id);
                             const response = await this.storageAdapter.createBlob(blob);
                             redirectTable.set(id, response.id);
                         }
@@ -756,12 +743,8 @@ export class Container extends EventEmitterWithErrorHandling {
             catch (error) {
                 // add resolved URL on error object so that host has the ability to find this document and delete it
                 const newError = normalizeError(error);
-                const resolvedUrl = this.resolvedUrl;
-                if (isFluidResolvedUrl(resolvedUrl)) {
-                    newError.addTelemetryProperties({ resolvedUrl: resolvedUrl.url });
-                }
+                newError.addTelemetryProperties({ resolvedUrl: (_a = this.resolvedUrl) === null || _a === void 0 ? void 0 : _a.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" });
@@ -856,7 +839,6 @@ export class Container extends EventEmitterWithErrorHandling {
             .catch(() => false);
     }
     async processCodeProposal() {
-        var _a;
         const codeDetails = this.getCodeDetailsFromQuorum();
         await Promise.all([
             this.deltaManager.inbound.pause(),
@@ -870,19 +852,12 @@ export class Container extends EventEmitterWithErrorHandling {
         // pre-0.58 error message: existingContextDoesNotSatisfyIncomingProposal
         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.storageAdapter.getVersions(version, 1);
         return versions[0];
     }
-    recordConnectStartTime() {
-        if (this.connectionTransitionTimes[ConnectionState.Disconnected] === undefined) {
-            this.connectionTransitionTimes[ConnectionState.Disconnected] = performance.now();
-        }
-    }
     connectToDeltaStream(args) {
-        this.recordConnectStartTime();
         // All agents need "write" access, including summarizer.
         if (!this._canReconnect || !this.client.details.capabilities.interactive) {
             args.mode = "write";
@@ -894,12 +869,9 @@ 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) {
+    async load(specifiedVersion, loadMode, resolvedUrl, pendingLocalState) {
         var _a;
-        if (this._resolvedUrl === undefined) {
-            throw new Error("Attempting to load without a resolved url");
-        }
-        this.service = await this.serviceFactory.createDocumentService(this._resolvedUrl, this.subLogger, this.client.details.type === summarizerClientType);
+        this.service = await this.serviceFactory.createDocumentService(resolvedUrl, this.subLogger, this.client.details.type === summarizerClientType);
         // Ideally we always connect as "read" by default.
         // Currently that works with SPO & r11s, because we get "write" connection when connecting to non-existing file.
         // We should not rely on it by (one of them will address the issue, but we need to address both)
@@ -925,9 +897,7 @@ export class Container extends EventEmitterWithErrorHandling {
         else {
             // if we have pendingLocalState we can load without storage; don't wait for connection
             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;
@@ -1053,8 +1023,7 @@ 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.detachedBlobStorage && this.detachedBlobStorage.size > 0, 0x250 /* "serialized container with attachment blobs must be rehydrated with detached blob storage" */);
             delete detachedContainerSnapshot.tree[".hasAttachmentBlobs"];
         }
         const snapshotTree = getSnapshotTreeFromSerializedContainer(detachedContainerSnapshot);
@@ -1107,9 +1076,7 @@ export class Container extends EventEmitterWithErrorHandling {
         this.initializeProtocolState(attributes, quorumSnapshot);
     }
     initializeProtocolState(attributes, quorumSnapshot) {
-        var _a;
-        const protocolHandlerBuilder = (_a = this.protocolHandlerBuilder) !== null && _a !== void 0 ? _a : ((...args) => new ProtocolHandler(...args, new Audience()));
-        const protocol = protocolHandlerBuilder(attributes, quorumSnapshot, (key, value) => this.submitMessage(MessageType.Propose, JSON.stringify({ key, value })));
+        const protocol = this.protocolHandlerBuilder(attributes, quorumSnapshot, (key, value) => this.submitMessage(MessageType.Propose, JSON.stringify({ key, value })));
         const protocolLogger = ChildLogger.create(this.subLogger, "ProtocolHandler");
         protocol.quorum.on("error", (error) => {
             protocolLogger.sendErrorEvent(error);
@@ -1129,10 +1096,8 @@ export class Container extends EventEmitterWithErrorHandling {
                     });
                 }
                 this.processCodeProposal().catch((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;
                 });
             }
@@ -1216,6 +1181,12 @@ export class Container extends EventEmitterWithErrorHandling {
             assert(this.connectionMode === details.mode, 0x4b7 /* mismatch */);
             this.connectionStateHandler.receivedConnectEvent(details);
         });
+        deltaManager.on("establishingConnection", (reason) => {
+            this.connectionStateHandler.establishingConnection(reason);
+        });
+        deltaManager.on("cancelEstablishingConnection", (reason) => {
+            this.connectionStateHandler.cancelEstablishingConnection(reason);
+        });
         deltaManager.on("disconnect", (reason, error) => {
             var _a;
             (_a = this.collabWindowTracker) === null || _a === void 0 ? void 0 : _a.stopSequenceNumberUpdate();
@@ -1272,8 +1243,8 @@ export class Container extends EventEmitterWithErrorHandling {
                     time - this.connectionTransitionTimes[ConnectionState.Disconnected];
                 durationFromDisconnected = TelemetryLogger.formatTick(durationFromDisconnected);
             }
-            else {
-                // This info is of most interest on establishing connection only.
+            else if (value === ConnectionState.CatchingUp) {
+                // This info is of most interesting while Catching Up.
                 checkpointSequenceNumber = this.deltaManager.lastKnownSeqNumber;
                 if (this.deltaManager.hasCheckpointSequenceNumber) {
                     opsBehind = checkpointSequenceNumber - this.deltaManager.lastSequenceNumber;
@@ -1322,7 +1293,6 @@ export class Container extends EventEmitterWithErrorHandling {
     }
     // 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);
@@ -1331,7 +1301,6 @@ export class Container extends EventEmitterWithErrorHandling {
             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;
             }
         }
@@ -1440,8 +1409,9 @@ export class Container extends EventEmitterWithErrorHandling {
         assert(((_a = this._context) === null || _a === void 0 ? void 0 : _a.disposed) !== false, 0x0dd /* "Existing context not disposed" */);
         // 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, 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);
+        const maybeLoader = this.scope;
+        const loader = new RelativeLoader(this, maybeLoader.ILoader);
+        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) => this.dispose(error), (error) => this.close(error), Container.version, (dirty) => this.updateDirtyContainerState(dirty), existing, pendingLocalState);
         this.emit("contextChanged", codeDetails);
     }
     updateDirtyContainerState(dirty) {