@fluidframework/container-loader 0.59.2001 → 0.59.3000-66610

package/dist/container.js

@@ -60,26 +60,36 @@ var ConnectionState;
  * @returns true: container is up to date, it processed all the ops that were know at the time of first connection
  *          false: storage does not provide indication of how far the client is. Container processed
  *          all the ops known to it, but it maybe still behind.
+ * @throws an error beginning with `"Container closed"` if the container is closed before it catches up.
  */
 async function waitContainerToCatchUp(container) {
     // Make sure we stop waiting if container is closed.
     if (container.closed) {
-        throw new Error("Container is closed");
+        throw new container_utils_1.UsageError("waitContainerToCatchUp: Container closed");
     }
     return new Promise((resolve, reject) => {
         const deltaManager = container.deltaManager;
-        container.on("closed", reject);
+        const closedCallback = (err) => {
+            container.off("closed", closedCallback);
+            const baseMessage = "Container closed while waiting to catch up";
+            reject(err !== undefined
+                ? (0, telemetry_utils_1.wrapError)(err, (innerMessage) => new container_utils_1.GenericError(`${baseMessage}: ${innerMessage}`))
+                : new container_utils_1.GenericError(baseMessage));
+        };
+        container.on("closed", closedCallback);
         const waitForOps = () => {
-            common_utils_1.assert(container.connectionState !== ConnectionState.Disconnected, 0x0cd /* "Container disconnected while waiting for ops!" */);
+            (0, common_utils_1.assert)(container.connectionState !== ConnectionState.Disconnected, 0x0cd /* "Container disconnected while waiting for ops!" */);
             const hasCheckpointSequenceNumber = deltaManager.hasCheckpointSequenceNumber;
             const connectionOpSeqNumber = deltaManager.lastKnownSeqNumber;
-            common_utils_1.assert(deltaManager.lastSequenceNumber <= connectionOpSeqNumber, 0x266 /* "lastKnownSeqNumber should never be below last processed sequence number" */);
+            (0, common_utils_1.assert)(deltaManager.lastSequenceNumber <= connectionOpSeqNumber, 0x266 /* "lastKnownSeqNumber should never be below last processed sequence number" */);
             if (deltaManager.lastSequenceNumber === connectionOpSeqNumber) {
+                container.off("closed", closedCallback);
                 resolve(hasCheckpointSequenceNumber);
                 return;
             }
             const callbackOps = (message) => {
                 if (connectionOpSeqNumber <= message.sequenceNumber) {
+                    container.off("closed", closedCallback);
                     resolve(hasCheckpointSequenceNumber);
                     deltaManager.off("op", callbackOps);
                 }
@@ -147,7 +157,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         this.subLogger = telemetry_utils_1.ChildLogger.create(loader.services.subLogger, undefined, {
             all: {
                 clientType,
-                containerId: uuid_1.v4(),
+                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; },
                 containerAttachState: () => this._attachState,
                 containerLifecycleState: () => this._lifecycleState,
@@ -171,7 +181,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             },
         });
         // Prefix all events in this file with container-loader
-        this.mc = telemetry_utils_1.loggerToMonitoringContext(telemetry_utils_1.ChildLogger.create(this.subLogger, "Container"));
+        this.mc = (0, telemetry_utils_1.loggerToMonitoringContext)(telemetry_utils_1.ChildLogger.create(this.subLogger, "Container"));
         const summarizeProtocolTree = (_c = this.mc.config.getBoolean("Fluid.Container.summarizeProtocolTree")) !== null && _c !== void 0 ? _c : this.loader.services.options.summarizeProtocolTree;
         this.options = Object.assign(Object.assign({}, this.loader.services.options), { summarizeProtocolTree });
         this.connectionStateHandler = new connectionStateHandler_1.ConnectionStateHandler({
@@ -278,7 +288,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             // always load unpaused with pending ops!
             // It is also default mode in general.
             const defaultMode = { opsBeforeReturn: "cached" };
-            common_utils_1.assert(pendingLocalState === undefined || loadOptions.loadMode === undefined, 0x1e1 /* "pending state requires immediate connection!" */);
+            (0, common_utils_1.assert)(pendingLocalState === undefined || loadOptions.loadMode === undefined, 0x1e1 /* "pending state requires immediate connection!" */);
             const mode = (_a = loadOptions.loadMode) !== null && _a !== void 0 ? _a : defaultMode;
             const onClosed = (err) => {
                 // pre-0.58 error message: containerClosedWithoutErrorDuringLoad
@@ -293,7 +303,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                 event.end(Object.assign(Object.assign({}, props), loadOptions.loadMode));
                 resolve(container);
             }, (error) => {
-                const err = telemetry_utils_1.normalizeError(error);
+                const err = (0, telemetry_utils_1.normalizeError)(error);
                 // Depending where error happens, we can be attempting to connect to web socket
                 // and continuously retrying (consider offline mode)
                 // Host has no container to close, so it's prudent to do it here
@@ -330,8 +340,8 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         return (this._lifecycleState !== "created" && this._lifecycleState !== "loading");
     }
     set loaded(t) {
-        common_utils_1.assert(t, 0x27d /* "Setting loaded state to false is not supported" */);
-        common_utils_1.assert(this._lifecycleState !== "created", 0x27e /* "Must go through loading state before loaded" */);
+        (0, common_utils_1.assert)(t, 0x27d /* "Setting loaded state to false is not supported" */);
+        (0, common_utils_1.assert)(this._lifecycleState !== "created", 0x27e /* "Must go through loading state before loaded" */);
         // It's conceivable the container could be closed when this is called
         // Only transition states if currently loading
         if (this._lifecycleState === "loading") {
@@ -468,7 +478,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                 (_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);
-                common_utils_1.assert(this.connectionState === ConnectionState.Disconnected, 0x0cf /* "disconnect event was not raised!" */);
+                (0, common_utils_1.assert)(this.connectionState === ConnectionState.Disconnected, 0x0cf /* "disconnect event was not raised!" */);
                 (_c = this._storageService) === null || _c === void 0 ? void 0 : _c.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.
@@ -496,8 +506,8 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         // runtime matches pending ops to successful ones by clientId and client seq num, so we need to close the
         // container at the same time we get pending state, otherwise this container could reconnect and resubmit with
         // a new clientId and a future container using stale pending state without the new clientId would resubmit them
-        common_utils_1.assert(this.attachState === container_definitions_1.AttachState.Attached, 0x0d1 /* "Container should be attached before close" */);
-        common_utils_1.assert(this.resolvedUrl !== undefined && this.resolvedUrl.type === "fluid", 0x0d2 /* "resolved url should be valid Fluid url" */);
+        (0, common_utils_1.assert)(this.attachState === container_definitions_1.AttachState.Attached, 0x0d1 /* "Container should be attached before close" */);
+        (0, common_utils_1.assert)(this.resolvedUrl !== undefined && this.resolvedUrl.type === "fluid", 0x0d2 /* "resolved url should be valid Fluid url" */);
         const pendingState = {
             pendingRuntimeState: this.context.getPendingLocalState(),
             url: this.resolvedUrl.url,
@@ -509,10 +519,10 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         return this._attachState;
     }
     serialize() {
-        common_utils_1.assert(this.attachState === container_definitions_1.AttachState.Detached, 0x0d3 /* "Should only be called in detached container" */);
+        (0, common_utils_1.assert)(this.attachState === container_definitions_1.AttachState.Detached, 0x0d3 /* "Should only be called in detached container" */);
         const appSummary = this.context.createSummary();
         const protocolSummary = this.captureProtocolSummary();
-        const combinedSummary = driver_utils_1.combineAppAndProtocolSummary(appSummary, protocolSummary);
+        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" };
         }
@@ -525,20 +535,20 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                 throw new container_utils_1.UsageError(`The Container is not in a valid state for attach [${this._lifecycleState}]`);
             }
             // If container is already attached or attach is in progress, throw an error.
-            common_utils_1.assert(this._attachState === container_definitions_1.AttachState.Detached && !this.attachStarted, 0x205 /* "attach() called more than once" */);
+            (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;
             try {
-                common_utils_1.assert(this.deltaManager.inbound.length === 0, 0x0d6 /* "Inbound queue should be empty when attaching" */);
+                (0, common_utils_1.assert)(this.deltaManager.inbound.length === 0, 0x0d6 /* "Inbound queue should be empty when attaching" */);
                 let summary;
                 if (!hasAttachmentBlobs) {
                     // Get the document state post attach - possibly can just call attach but we need to change the
                     // semantics around what the attach means as far as async code goes.
                     const appSummary = this.context.createSummary();
                     const protocolSummary = this.captureProtocolSummary();
-                    summary = driver_utils_1.combineAppAndProtocolSummary(appSummary, protocolSummary);
+                    summary = (0, driver_utils_1.combineAppAndProtocolSummary)(appSummary, protocolSummary);
                     // Set the state as attaching as we are starting the process of attaching container.
                     // This should be fired after taking the summary because it is the place where we are
                     // starting to attach the container to storage.
@@ -548,20 +558,20 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                 }
                 // Actually go and create the resolved document
                 const createNewResolvedUrl = await this.urlResolver.resolve(request);
-                driver_utils_1.ensureFluidResolvedUrl(createNewResolvedUrl);
+                (0, driver_utils_1.ensureFluidResolvedUrl)(createNewResolvedUrl);
                 if (this.service === undefined) {
-                    common_utils_1.assert(this.client.details.type !== summarizerClientType, 0x2c4 /* "client should not be summarizer before container is created" */);
-                    this.service = await driver_utils_1.runWithRetry(async () => this.serviceFactory.createContainer(summary, createNewResolvedUrl, this.subLogger, false), "containerAttach", this.mc.logger, {
+                    (0, common_utils_1.assert)(this.client.details.type !== summarizerClientType, 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;
-                driver_utils_1.ensureFluidResolvedUrl(resolvedUrl);
+                (0, driver_utils_1.ensureFluidResolvedUrl)(resolvedUrl);
                 this._resolvedUrl = resolvedUrl;
                 await this.connectStorageService();
                 if (hasAttachmentBlobs) {
                     // upload blobs to storage
-                    common_utils_1.assert(!!this.loader.services.detachedBlobStorage, 0x24e /* "assertion for type narrowing" */);
+                    (0, common_utils_1.assert)(!!this.loader.services.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();
@@ -577,7 +587,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                     // take summary and upload
                     const appSummary = this.context.createSummary(redirectTable);
                     const protocolSummary = this.captureProtocolSummary();
-                    summary = driver_utils_1.combineAppAndProtocolSummary(appSummary, protocolSummary);
+                    summary = (0, driver_utils_1.combineAppAndProtocolSummary)(appSummary, protocolSummary);
                     this._attachState = container_definitions_1.AttachState.Attaching;
                     this.context.notifyAttaching();
                     await this.storageService.uploadSummaryWithContext(summary, {
@@ -596,9 +606,9 @@ 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 = telemetry_utils_1.normalizeError(error);
+                const newError = (0, telemetry_utils_1.normalizeError)(error);
                 const resolvedUrl = this.resolvedUrl;
-                if (driver_utils_1.isFluidResolvedUrl(resolvedUrl)) {
+                if ((0, driver_utils_1.isFluidResolvedUrl)(resolvedUrl)) {
                     newError.addTelemetryProperties({ resolvedUrl: resolvedUrl.url });
                 }
                 this.close(newError);
@@ -661,8 +671,8 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         }
     }
     connectInternal(args) {
-        common_utils_1.assert(!this.closed, 0x2c5 /* "Attempting to connect() a closed Container" */);
-        common_utils_1.assert(this._attachState === container_definitions_1.AttachState.Attached, 0x2c6 /* "Attempting to connect() a container that is not attached" */);
+        (0, common_utils_1.assert)(!this.closed, 0x2c5 /* "Attempting to connect() a closed Container" */);
+        (0, common_utils_1.assert)(this._attachState === container_definitions_1.AttachState.Attached, 0x2c6 /* "Attempting to connect() a container that is not attached" */);
         // Resume processing ops and connect to delta stream
         this.resumeInternal(args);
         // Set Auto Reconnect Mode
@@ -678,7 +688,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         }
     }
     disconnectInternal() {
-        common_utils_1.assert(!this.closed, 0x2c7 /* "Attempting to disconnect() a closed Container" */);
+        (0, common_utils_1.assert)(!this.closed, 0x2c7 /* "Attempting to disconnect() a closed Container" */);
         // Set Auto Reconnect Mode
         const mode = contracts_1.ReconnectMode.Disabled;
         this.setAutoReconnectInternal(mode);
@@ -698,7 +708,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         }
     }
     resumeInternal(args) {
-        common_utils_1.assert(!this.closed, 0x0d9 /* "Attempting to setAutoReconnect() a closed DeltaManager" */);
+        (0, common_utils_1.assert)(!this.closed, 0x0d9 /* "Attempting to setAutoReconnect() a closed DeltaManager" */);
         // Resume processing ops
         if (!this.resumedOpProcessingAfterLoad) {
             this.resumedOpProcessingAfterLoad = true;
@@ -713,10 +723,10 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         if (this.resolvedUrl === undefined) {
             return undefined;
         }
-        return this.urlResolver.getAbsoluteUrl(this.resolvedUrl, relativeUrl, contracts_1.getPackageName((_a = this._context) === null || _a === void 0 ? void 0 : _a.codeDetails));
+        return this.urlResolver.getAbsoluteUrl(this.resolvedUrl, relativeUrl, (0, contracts_1.getPackageName)((_a = this._context) === null || _a === void 0 ? void 0 : _a.codeDetails));
     }
     async proposeCodeDetails(codeDetails) {
-        if (!container_definitions_1.isFluidCodeDetails(codeDetails)) {
+        if (!(0, container_definitions_1.isFluidCodeDetails)(codeDetails)) {
             throw new Error("Provided codeDetails are not IFluidCodeDetails");
         }
         if (this.codeLoader.IFluidCodeDetailsComparer) {
@@ -791,7 +801,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         this._attachState = container_definitions_1.AttachState.Attached;
         // Fetch specified snapshot.
         const { snapshot, versionId } = await this.fetchSnapshotTree(specifiedVersion);
-        common_utils_1.assert(snapshot !== undefined, 0x237 /* "Snapshot should exist" */);
+        (0, common_utils_1.assert)(snapshot !== undefined, 0x237 /* "Snapshot should exist" */);
         const attributes = await this.getDocumentAttributes(this.storageService, snapshot);
         let opsBeforeReturnP;
         // Attach op handlers to finish initialization and be able to start processing ops
@@ -809,12 +819,12 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                 opsBeforeReturnP = this.attachDeltaManagerOpHandler(attributes, "all");
                 break;
             default:
-                common_utils_1.unreachableCase(loadMode.opsBeforeReturn);
+                (0, common_utils_1.unreachableCase)(loadMode.opsBeforeReturn);
         }
         // ...load in the existing quorum
         // Initialize the protocol handler
         this._protocolHandler =
-            await this.loadAndInitializeProtocolState(attributes, this.storageService, snapshot);
+            await this.initializeProtocolStateFromSnapshot(attributes, this.storageService, snapshot);
         const codeDetails = this.getCodeDetailsFromQuorum();
         await this.instantiateContext(true, // existing
         codeDetails, snapshot, pendingLocalState);
@@ -844,7 +854,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                 case "none":
                     break;
                 default:
-                    common_utils_1.unreachableCase(loadMode.deltaConnection);
+                    (0, common_utils_1.unreachableCase)(loadMode.deltaConnection);
             }
         }
         // Safety net: static version of Container.load() should have learned about it through "closed" handler.
@@ -866,20 +876,12 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             term: 1,
             minimumSequenceNumber: 0,
         };
-        // Seed the base quorum to be an empty list with a code quorum set
-        const committedCodeProposal = {
-            key: "code",
-            value: source,
-            approvalSequenceNumber: 0,
-            commitSequenceNumber: 0,
-            sequenceNumber: 0,
-        };
-        const members = [];
-        const proposals = [];
-        const values = [["code", committedCodeProposal]];
         await this.attachDeltaManagerOpHandler(attributes);
         // Need to just seed the source data in the code quorum. Quorum itself is empty
-        this._protocolHandler = await this.initializeProtocolState(attributes, members, proposals, values);
+        const qValues = (0, quorum_1.initQuorumValuesFromCodeDetails)(source);
+        this._protocolHandler = await this.initializeProtocolState(attributes, [], // members
+        [], // proposals
+        qValues);
         // The load context - given we seeded the quorum - will be great
         await this.instantiateContextDetached(false);
         this.propagateConnectionState();
@@ -887,18 +889,21 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
     }
     async rehydrateDetachedFromSnapshot(detachedContainerSnapshot) {
         if (detachedContainerSnapshot.tree[".hasAttachmentBlobs"] !== undefined) {
-            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 = utils_1.getSnapshotTreeFromSerializedContainer(detachedContainerSnapshot);
+        const snapshotTree = (0, utils_1.getSnapshotTreeFromSerializedContainer)(detachedContainerSnapshot);
         this._storage.loadSnapshotForRehydratingContainer(snapshotTree);
         const attributes = await this.getDocumentAttributes(this._storage, snapshotTree);
-        common_utils_1.assert(attributes.sequenceNumber === 0, 0x0db /* "Seq number in detached container should be 0!!" */);
         await this.attachDeltaManagerOpHandler(attributes);
-        // ...load in the existing quorum
         // Initialize the protocol handler
+        const baseTree = (0, utils_1.getProtocolSnapshotTree)(snapshotTree);
+        const qValues = await (0, driver_utils_1.readAndParse)(this._storage, baseTree.blobs.quorumValues);
+        const codeDetails = (0, quorum_1.getCodeDetailsFromQuorumValues)(qValues);
         this._protocolHandler =
-            await this.loadAndInitializeProtocolState(attributes, this._storage, snapshotTree);
+            await this.initializeProtocolState(attributes, [], // members
+            [], // proposals
+            codeDetails !== undefined ? (0, quorum_1.initQuorumValuesFromCodeDetails)(codeDetails) : []);
         await this.instantiateContextDetached(true, // existing
         snapshotTree);
         this.loaded = true;
@@ -909,7 +914,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         if (this._storageService !== undefined) {
             return;
         }
-        common_utils_1.assert(this.service !== undefined, 0x1ef /* "services must be defined" */);
+        (0, common_utils_1.assert)(this.service !== undefined, 0x1ef /* "services must be defined" */);
         const storageService = await this.service.connectToStorage();
         this._storageService =
             new retriableDocumentStorageService_1.RetriableDocumentStorageService(storageService, this.mc.logger);
@@ -919,7 +924,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                 new protocolTreeDocumentStorageService_1.ProtocolTreeStorageService(this._storageService, () => this.captureProtocolSummary());
         }
         // ensure we did not lose that policy in the process of wrapping
-        common_utils_1.assert(((_a = storageService.policies) === null || _a === void 0 ? void 0 : _a.minBlobSize) === ((_b = this.storageService.policies) === null || _b === void 0 ? void 0 : _b.minBlobSize), 0x0e0 /* "lost minBlobSize policy" */);
+        (0, common_utils_1.assert)(((_a = storageService.policies) === null || _a === void 0 ? void 0 : _a.minBlobSize) === ((_b = this.storageService.policies) === null || _b === void 0 ? void 0 : _b.minBlobSize), 0x0e0 /* "lost minBlobSize policy" */);
     }
     async getDocumentAttributes(storage, tree) {
         if (tree === undefined) {
@@ -933,23 +938,23 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         const attributesHash = ".protocol" in tree.trees
             ? tree.trees[".protocol"].blobs.attributes
             : tree.blobs[".attributes"];
-        const attributes = await driver_utils_1.readAndParse(storage, attributesHash);
+        const attributes = await (0, driver_utils_1.readAndParse)(storage, attributesHash);
         // Backward compatibility for older summaries with no term
         if (attributes.term === undefined) {
             attributes.term = 1;
         }
         return attributes;
     }
-    async loadAndInitializeProtocolState(attributes, storage, snapshot) {
+    async initializeProtocolStateFromSnapshot(attributes, storage, snapshot) {
         let members = [];
         let proposals = [];
         let values = [];
         if (snapshot !== undefined) {
-            const baseTree = ".protocol" in snapshot.trees ? snapshot.trees[".protocol"] : snapshot;
+            const baseTree = (0, utils_1.getProtocolSnapshotTree)(snapshot);
             [members, proposals, values] = await Promise.all([
-                driver_utils_1.readAndParse(storage, baseTree.blobs.quorumMembers),
-                driver_utils_1.readAndParse(storage, baseTree.blobs.quorumProposals),
-                driver_utils_1.readAndParse(storage, baseTree.blobs.quorumValues),
+                (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),
             ]);
         }
         const protocolHandler = await this.initializeProtocolState(attributes, members, proposals, values);
@@ -975,13 +980,13 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         });
         protocol.quorum.on("approveProposal", (sequenceNumber, key, value) => {
             if (key === "code" || key === "code2") {
-                if (!container_definitions_1.isFluidCodeDetails(value)) {
+                if (!(0, container_definitions_1.isFluidCodeDetails)(value)) {
                     this.mc.logger.sendErrorEvent({
                         eventName: "CodeProposalNotIFluidCodeDetails",
                     });
                 }
                 this.processCodeProposal().catch((error) => {
-                    this.close(telemetry_utils_1.normalizeError(error));
+                    this.close((0, telemetry_utils_1.normalizeError)(error));
                     throw error;
                 });
             }
@@ -1038,7 +1043,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                 user: { id: "" },
             };
         if (this.clientDetailsOverride !== undefined) {
-            merge_1.default(client.details, this.clientDetailsOverride);
+            (0, merge_1.default)(client.details, this.clientDetailsOverride);
         }
         client.details.environment = [client.details.environment, ` loaderVersion:${packageVersion_1.pkgVersion}`].join(";");
         return client;
@@ -1136,7 +1141,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             durationFromDisconnected,
             reason,
             connectionInitiationReason, pendingClientId: this.connectionStateHandler.pendingClientId, clientId: this.clientId, autoReconnect,
-            opsBehind, online: driver_utils_1.OnlineStatus[driver_utils_1.isOnline()], lastVisible: this.lastVisible !== undefined ? common_utils_1.performance.now() - this.lastVisible : undefined, checkpointSequenceNumber }, 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 }, this._deltaManager.connectionProps));
         if (value === ConnectionState.Connected) {
             this.firstConnection = false;
         }
@@ -1152,9 +1157,9 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         if (!this.context.disposed) {
             this.context.setConnectionState(state, this.clientId);
         }
-        common_utils_1.assert(this.protocolHandler !== undefined, 0x0dc /* "Protocol handler should be set here" */);
+        (0, common_utils_1.assert)(this.protocolHandler !== undefined, 0x0dc /* "Protocol handler should be set here" */);
         this.protocolHandler.quorum.setConnectionState(state, this.clientId);
-        telemetry_utils_1.raiseConnectedEvent(this.mc.logger, this, state, this.clientId);
+        (0, telemetry_utils_1.raiseConnectedEvent)(this.mc.logger, this, state, this.clientId);
         if (logOpsOnReconnect) {
             this.mc.logger.sendTelemetryEvent({ eventName: "OpsSentOnReconnect", count: this.messageCountAfterDisconnection });
         }
@@ -1208,13 +1213,13 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                 errorMsg = "Remote message's clientId already should have left";
             }
             if (errorMsg !== undefined) {
-                const error = new container_utils_1.DataCorruptionError(errorMsg, container_utils_1.extractSafePropertiesFromMessage(message));
-                this.close(telemetry_utils_1.normalizeError(error));
+                const error = new container_utils_1.DataCorruptionError(errorMsg, (0, container_utils_1.extractSafePropertiesFromMessage)(message));
+                this.close((0, telemetry_utils_1.normalizeError)(error));
             }
         }
         const local = this.clientId === message.clientId;
         // Forward non system messages to the loaded runtime for processing
-        if (!protocol_base_1.isSystemMessage(message)) {
+        if (!(0, protocol_base_1.isSystemMessage)(message)) {
             this.context.process(message, local, undefined);
         }
         // Allow the protocol handler to process the message
@@ -1272,7 +1277,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
     }
     async instantiateContext(existing, codeDetails, snapshot, pendingLocalState) {
         var _a;
-        common_utils_1.assert(((_a = this._context) === null || _a === void 0 ? void 0 : _a.disposed) !== false, 0x0dd /* "Existing context not disposed" */);
+        (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);