@fluidframework/container-loader 2.0.0-internal.4.3.0 → 2.0.0-internal.5.0.0

package/dist/container.js

@@ -127,14 +127,11 @@ async function ReportIfTooLong(logger, eventName, action) {
 }
 exports.ReportIfTooLong = ReportIfTooLong;
 const summarizerClientType = "summarizer";
-/**
- * @deprecated - In the next release Container will no longer be exported, IContainer should be used in its place.
- */
 class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
     /**
      * @internal
      */
-    constructor(loader, config, protocolHandlerBuilder) {
+    constructor(createProps, loadProps) {
         var _a, _b, _c;
         super((name, error) => {
             this.mc.logger.sendErrorEvent({
@@ -142,8 +139,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                 name: typeof name === "string" ? name : undefined,
             }, error);
         });
-        this.loader = loader;
-        this.protocolHandlerBuilder = protocolHandlerBuilder;
+        this.createProps = createProps;
         // Tells if container can reconnect on losing fist connection
         // If false, container gets closed on loss of connection.
         this._canReconnect = true;
@@ -174,10 +170,9 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         this.savedOps = [];
         this.setAutoReconnectTime = common_utils_1.performance.now();
         this._disposed = false;
-        this.clientDetailsOverride = config.clientDetailsOverride;
-        this._resolvedUrl = config.resolvedUrl;
-        if (config.canReconnect !== undefined) {
-            this._canReconnect = config.canReconnect;
+        this.clientDetailsOverride = createProps.clientDetailsOverride;
+        if (createProps.canReconnect !== undefined) {
+            this._canReconnect = createProps.canReconnect;
         }
         // Create logger for data stores to use
         const type = this.client.details.type;
@@ -185,15 +180,15 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         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 = telemetry_utils_1.ChildLogger.create(loader.services.subLogger, undefined, {
+        this.subLogger = telemetry_utils_1.ChildLogger.create(createProps.subLogger, undefined, {
             all: {
                 clientType,
                 containerId: (0, uuid_1.v4)(),
-                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_1.ConnectionState[this.connectionState],
-                serializedContainer: config.serializedContainerState !== undefined,
+                serializedContainer: (loadProps === null || loadProps === void 0 ? void 0 : loadProps.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
@@ -219,15 +214,15 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         // 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.options = Object.assign({}, this.createProps.options);
         this._deltaManager = this.createDeltaManager();
         this.connectionStateHandler = (0, connectionStateHandler_1.createConnectionStateHandler)({
             logger: this.mc.logger,
-            connectionStateChanged: (value, oldState, reason) => {
+            connectionStateChanged: (value, oldState, reason, error) => {
                 if (value === connectionState_1.ConnectionState.Connected) {
                     this._clientId = this.connectionStateHandler.pendingClientId;
                 }
-                this.logConnectionStateChangeTelemetry(value, oldState, reason);
+                this.logConnectionStateChangeTelemetry(value, oldState, reason, error);
                 if (this._lifecycleState === "loaded") {
                     this.propagateConnectionState(false /* initial transition */, value === connectionState_1.ConnectionState.Disconnected
                         ? reason
@@ -235,7 +230,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                 }
             },
             shouldClientJoinWrite: () => this._deltaManager.connectionManager.shouldJoinWrite(),
-            maxClientLeaveWaitTime: this.loader.services.options.maxClientLeaveWaitTime,
+            maxClientLeaveWaitTime: this.createProps.options.maxClientLeaveWaitTime,
             logConnectionIssue: (eventName, category, details) => {
                 const mode = this.connectionMode;
                 // We get here when socket does not receive any ops on "write" connection, including
@@ -259,7 +254,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                     this.connect();
                 }
             },
-        }, this.deltaManager, (_a = config.serializedContainerState) === null || _a === void 0 ? void 0 : _a.clientId);
+        }, this.deltaManager, (_a = loadProps === null || loadProps === void 0 ? void 0 : loadProps.pendingLocalState) === null || _a === void 0 ? void 0 : _a.clientId);
         this.on(savedContainerEvent, () => {
             this.connectionStateHandler.containerSaved();
         });
@@ -271,8 +266,8 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             : (0, driver_utils_1.combineAppAndProtocolSummary)(summaryTree, this.captureProtocolSummary());
         // Whether the combined summary tree has been forced on by either the loader option or the monitoring context.
         // Even if not forced on via this flag, combined summaries may still be enabled by service policy.
-        const forceEnableSummarizeProtocolTree = (_b = this.mc.config.getBoolean("Fluid.Container.summarizeProtocolTree2")) !== null && _b !== void 0 ? _b : this.loader.services.options.summarizeProtocolTree;
-        this.storageAdapter = new containerStorageAdapter_1.ContainerStorageAdapter(this.loader.services.detachedBlobStorage, this.mc.logger, (_c = config.serializedContainerState) === null || _c === void 0 ? void 0 : _c.snapshotBlobs, addProtocolSummaryIfMissing, forceEnableSummarizeProtocolTree);
+        const forceEnableSummarizeProtocolTree = (_b = this.mc.config.getBoolean("Fluid.Container.summarizeProtocolTree2")) !== null && _b !== void 0 ? _b : this.createProps.options.summarizeProtocolTree;
+        this.storageAdapter = new containerStorageAdapter_1.ContainerStorageAdapter(this.createProps.detachedBlobStorage, this.mc.logger, (_c = loadProps === null || loadProps === void 0 ? void 0 : loadProps.pendingLocalState) === null || _c === void 0 ? void 0 : _c.snapshotBlobs, addProtocolSummaryIfMissing, forceEnableSummarizeProtocolTree);
         const isDomAvailable = typeof document === "object" &&
             document !== null &&
             typeof document.addEventListener === "function" &&
@@ -294,37 +289,34 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             document.addEventListener("visibilitychange", this.visibilityEventHandler);
         }
     }
+    static async clone(container, loadProps, createParamOverrides) {
+        return this.load(loadProps, Object.assign(Object.assign({}, container.createProps), createParamOverrides));
+    }
     /**
      * 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);
         return telemetry_utils_1.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 container_utils_1.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 = (0, telemetry_utils_1.normalizeError)(error);
@@ -339,8 +331,8 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
     /**
      * 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 telemetry_utils_1.PerformanceEvent.timedExecAsync(container.mc.logger, { eventName: "CreateDetached" }, async (_event) => {
             await container.createDetached(codeDetails);
             return container;
@@ -350,8 +342,8 @@ class Container extends telemetry_utils_1.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 telemetry_utils_1.PerformanceEvent.timedExecAsync(container.mc.logger, { eventName: "RehydrateDetachedFromSnapshot" }, async (_event) => {
             const deserializedSummary = JSON.parse(snapshot);
             await container.rehydrateDetachedFromSnapshot(deserializedSummary);
@@ -395,7 +387,19 @@ class Container extends telemetry_utils_1.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;
@@ -482,16 +486,16 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         return this._dirtyContainer;
     }
     get serviceFactory() {
-        return this.loader.services.documentServiceFactory;
+        return this.createProps.documentServiceFactory;
     }
     get urlResolver() {
-        return this.loader.services.urlResolver;
+        return this.createProps.urlResolver;
     }
     get scope() {
-        return this.loader.services.scope;
+        return this.createProps.scope;
     }
     get codeLoader() {
-        return this.loader.services.codeLoader;
+        return this.createProps.codeLoader;
     }
     /**
      * {@inheritDoc @fluidframework/container-definitions#IContainer.entryPoint}
@@ -548,7 +552,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         (0, common_utils_1.assert)(this._lifecycleState === "closed" || this._lifecycleState === "disposed", 0x314 /* Container properly closed */);
     }
     closeCore(error) {
-        var _a, _b, _c;
+        var _a;
         (0, common_utils_1.assert)(!this.closed, 0x315 /* re-entrancy */);
         try {
             // Ensure that we raise all key events even if one of these throws
@@ -566,12 +570,6 @@ class Container extends telemetry_utils_1.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);
@@ -660,8 +658,7 @@ 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) {
+        if (this.createProps.detachedBlobStorage && this.createProps.detachedBlobStorage.size > 0) {
             combinedSummary.tree[".hasAttachmentBlobs"] = {
                 type: protocol_definitions_1.SummaryType.Blob,
                 content: "true",
@@ -680,8 +677,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.createProps.detachedBlobStorage !== undefined &&
+                this.createProps.detachedBlobStorage.size > 0;
             try {
                 (0, common_utils_1.assert)(this.deltaManager.inbound.length === 0, 0x0d6 /* "Inbound queue should be empty when attaching" */);
                 let summary;
@@ -705,31 +702,28 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                     }
                 }
                 // Actually go and create the resolved document
-                const createNewResolvedUrl = await this.urlResolver.resolve(request);
-                (0, driver_utils_1.ensureFluidResolvedUrl)(createNewResolvedUrl);
                 if (this.service === undefined) {
-                    (0, common_utils_1.assert)(this.client.details.type !== summarizerClientType, 0x2c4 /* "client should not be summarizer before container is created" */);
+                    const createNewResolvedUrl = await this.urlResolver.resolve(request);
+                    (0, common_utils_1.assert)(this.client.details.type !== summarizerClientType &&
+                        createNewResolvedUrl !== undefined, 0x2c4 /* "client should not be summarizer before container is created" */);
                     this.service = await (0, driver_utils_1.runWithRetry)(async () => this.serviceFactory.createContainer(summary, createNewResolvedUrl, this.subLogger, false), "containerAttach", this.mc.logger, {
                         cancel: this.closeSignal,
                     });
                 }
-                const resolvedUrl = this.service.resolvedUrl;
-                (0, driver_utils_1.ensureFluidResolvedUrl)(resolvedUrl);
-                this._resolvedUrl = resolvedUrl;
                 await this.storageAdapter.connectToService(this.service);
                 if (hasAttachmentBlobs) {
                     // upload blobs to storage
-                    (0, common_utils_1.assert)(!!this.loader.services.detachedBlobStorage, 0x24e /* "assertion for type narrowing" */);
+                    (0, common_utils_1.assert)(!!this.createProps.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.createProps.detachedBlobStorage.size) {
+                        const newIds = this.createProps.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.createProps.detachedBlobStorage.readBlob(id);
                             const response = await this.storageAdapter.createBlob(blob);
                             redirectTable.set(id, response.id);
                         }
@@ -764,12 +758,8 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             catch (error) {
                 // add resolved URL on error object so that host has the ability to find this document and delete it
                 const newError = (0, telemetry_utils_1.normalizeError)(error);
-                const resolvedUrl = this.resolvedUrl;
-                if ((0, driver_utils_1.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" });
@@ -864,7 +854,6 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             .catch(() => false);
     }
     async processCodeProposal() {
-        var _a;
         const codeDetails = this.getCodeDetailsFromQuorum();
         await Promise.all([
             this.deltaManager.inbound.pause(),
@@ -878,7 +867,6 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         // pre-0.58 error message: existingContextDoesNotSatisfyIncomingProposal
         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.storageAdapter.getVersions(version, 1);
@@ -902,12 +890,9 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
      *
      * @param specifiedVersion - Version SHA to load snapshot. If not specified, will fetch the latest snapshot.
      */
-    async load(specifiedVersion, loadMode, pendingLocalState) {
+    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)
@@ -933,9 +918,7 @@ class Container extends telemetry_utils_1.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 = container_definitions_1.AttachState.Attached;
@@ -1061,8 +1044,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.createProps.detachedBlobStorage &&
+                this.createProps.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);
@@ -1116,7 +1099,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
     }
     initializeProtocolState(attributes, quorumSnapshot) {
         var _a;
-        const protocolHandlerBuilder = (_a = this.protocolHandlerBuilder) !== null && _a !== void 0 ? _a : ((...args) => new protocol_1.ProtocolHandler(...args, new audience_1.Audience()));
+        const protocolHandlerBuilder = (_a = this.createProps.protocolHandlerBuilder) !== null && _a !== void 0 ? _a : ((...args) => new protocol_1.ProtocolHandler(...args, new audience_1.Audience()));
         const protocol = protocolHandlerBuilder(attributes, quorumSnapshot, (key, value) => this.submitMessage(protocol_definitions_1.MessageType.Propose, JSON.stringify({ key, value })));
         const protocolLogger = telemetry_utils_1.ChildLogger.create(this.subLogger, "ProtocolHandler");
         protocol.quorum.on("error", (error) => {
@@ -1137,10 +1120,8 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                     });
                 }
                 this.processCodeProposal().catch((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;
                 });
             }
@@ -1224,11 +1205,11 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             (0, common_utils_1.assert)(this.connectionMode === details.mode, 0x4b7 /* mismatch */);
             this.connectionStateHandler.receivedConnectEvent(details);
         });
-        deltaManager.on("disconnect", (reason) => {
+        deltaManager.on("disconnect", (reason, error) => {
             var _a;
             (_a = this.collabWindowTracker) === null || _a === void 0 ? void 0 : _a.stopSequenceNumberUpdate();
             if (!this.closed) {
-                this.connectionStateHandler.receivedDisconnectEvent(reason);
+                this.connectionStateHandler.receivedDisconnectEvent(reason, error);
             }
         });
         deltaManager.on("throttled", (warning) => {
@@ -1260,7 +1241,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             },
         }, prefetchType);
     }
-    logConnectionStateChangeTelemetry(value, oldState, reason) {
+    logConnectionStateChangeTelemetry(value, oldState, reason, error) {
         var _a;
         // Log actual event
         const time = common_utils_1.performance.now();
@@ -1293,7 +1274,9 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             durationFromDisconnected,
             reason,
             connectionInitiationReason, pendingClientId: this.connectionStateHandler.pendingClientId, clientId: this.clientId, autoReconnect,
-            opsBehind, online: driver_utils_1.OnlineStatus[(0, driver_utils_1.isOnline)()], lastVisible: this.lastVisible !== undefined ? common_utils_1.performance.now() - this.lastVisible : undefined, checkpointSequenceNumber, quorumSize: (_a = this._protocolHandler) === null || _a === void 0 ? void 0 : _a.quorum.getMembers().size }, this._deltaManager.connectionProps));
+            opsBehind, online: driver_utils_1.OnlineStatus[(0, driver_utils_1.isOnline)()], lastVisible: this.lastVisible !== undefined
+                ? common_utils_1.performance.now() - this.lastVisible
+                : undefined, checkpointSequenceNumber, quorumSize: (_a = this._protocolHandler) === null || _a === void 0 ? void 0 : _a.quorum.getMembers().size }, this._deltaManager.connectionProps), error);
         if (value === connectionState_1.ConnectionState.Connected) {
             this.firstConnection = false;
         }
@@ -1328,7 +1311,6 @@ class Container extends telemetry_utils_1.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 protocol_definitions_1.MessageType.Operation:
                 return this.submitMessage(type, JSON.stringify(contents), batch, metadata);
@@ -1337,7 +1319,6 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             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;
             }
         }
@@ -1446,8 +1427,9 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         (0, common_utils_1.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 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, 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 loader_1.RelativeLoader(this, maybeLoader.ILoader);
+        this._context = await containerContext_1.ContainerContext.createOrLoad(this, this.scope, this.codeLoader, codeDetails, snapshot, new deltaManagerProxy_1.DeltaManagerProxy(this._deltaManager), new quorum_1.QuorumProxy(this.protocolHandler.quorum), loader, (type, contents, batch, metadata) => this.submitContainerMessage(type, contents, batch, metadata), (summaryOp, referenceSequenceNumber) => this.submitSummaryMessage(summaryOp, referenceSequenceNumber), (batch, referenceSequenceNumber) => this.submitBatch(batch, referenceSequenceNumber), (message) => this.submitSignal(message), (error) => this.dispose(error), (error) => this.close(error), Container.version, (dirty) => this.updateDirtyContainerState(dirty), existing, pendingLocalState);
         this.emit("contextChanged", codeDetails);
     }
     updateDirtyContainerState(dirty) {