@fluidframework/container-loader 2.0.0-internal.6.2.0 → 2.0.0-internal.6.3.1

package/dist/container.js

@@ -11,7 +11,9 @@ exports.Container = exports.ReportIfTooLong = exports.waitContainerToCatchUp = v
 // eslint-disable-next-line import/no-internal-modules
 const merge_1 = __importDefault(require("lodash/merge"));
 const uuid_1 = require("uuid");
-const common_utils_1 = require("@fluidframework/common-utils");
+const core_utils_1 = require("@fluidframework/core-utils");
+const client_utils_1 = require("@fluid-internal/client-utils");
+const core_interfaces_1 = require("@fluidframework/core-interfaces");
 const container_definitions_1 = require("@fluidframework/container-definitions");
 const driver_utils_1 = require("@fluidframework/driver-utils");
 const protocol_definitions_1 = require("@fluidframework/protocol-definitions");
@@ -70,11 +72,11 @@ async function waitContainerToCatchUp(container) {
         // Waiting for "connected" state in either case gets us at least to our own Join op
         // which is a reasonable approximation of "caught up"
         const waitForOps = () => {
-            (0, common_utils_1.assert)(container.connectionState === connectionState_1.ConnectionState.CatchingUp ||
+            (0, core_utils_1.assert)(container.connectionState === connectionState_1.ConnectionState.CatchingUp ||
                 container.connectionState === connectionState_1.ConnectionState.Connected, 0x0cd /* "Container disconnected while waiting for ops!" */);
             const hasCheckpointSequenceNumber = deltaManager.hasCheckpointSequenceNumber;
             const connectionOpSeqNumber = deltaManager.lastKnownSeqNumber;
-            (0, common_utils_1.assert)(deltaManager.lastSequenceNumber <= connectionOpSeqNumber, 0x266 /* "lastKnownSeqNumber should never be below last processed sequence number" */);
+            (0, core_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);
@@ -162,8 +164,8 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         this._dirtyContainer = false;
         this.savedOps = [];
         this.clientsWhoShouldHaveLeft = new Set();
-        this.setAutoReconnectTime = common_utils_1.performance.now();
-        this._lifecycleEvents = new common_utils_1.TypedEventEmitter();
+        this.setAutoReconnectTime = client_utils_1.performance.now();
+        this._lifecycleEvents = new client_utils_1.TypedEventEmitter();
         this._disposed = false;
         this.getAbsoluteUrl = async (relativeUrl) => {
             if (this.resolvedUrl === undefined) {
@@ -179,7 +181,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             this.emit(dirty ? dirtyContainerEvent : savedContainerEvent);
         };
         const { canReconnect, clientDetailsOverride, urlResolver, documentServiceFactory, codeLoader, options, scope, subLogger, detachedBlobStorage, protocolHandlerBuilder, } = createProps;
-        this.connectionTransitionTimes[connectionState_1.ConnectionState.Disconnected] = common_utils_1.performance.now();
+        this.connectionTransitionTimes[connectionState_1.ConnectionState.Disconnected] = client_utils_1.performance.now();
         const pendingLocalState = loadProps?.pendingLocalState;
         this._clientId = pendingLocalState?.clientId;
         this._canReconnect = canReconnect ?? true;
@@ -239,7 +241,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                         ? "null"
                         : this.deltaManager?.lastMessage?.clientId,
                     dmLastMsgClientSeq: () => this.deltaManager?.lastMessage?.clientSequenceNumber,
-                    connectionStateDuration: () => common_utils_1.performance.now() - this.connectionTransitionTimes[this.connectionState],
+                    connectionStateDuration: () => client_utils_1.performance.now() - this.connectionTransitionTimes[this.connectionState],
                 },
             },
         });
@@ -272,7 +274,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                     eventName,
                     mode,
                     category: this._lifecycleState === "loading" ? "generic" : category,
-                    duration: common_utils_1.performance.now() -
+                    duration: client_utils_1.performance.now() -
                         this.connectionTransitionTimes[connectionState_1.ConnectionState.CatchingUp],
                     ...(details === undefined ? {} : { details: JSON.stringify(details) }),
                 });
@@ -314,10 +316,10 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             document.addEventListener !== null;
         // keep track of last time page was visible for telemetry (on interactive clients only)
         if (isDomAvailable && interactive) {
-            this.lastVisible = document.hidden ? common_utils_1.performance.now() : undefined;
+            this.lastVisible = document.hidden ? client_utils_1.performance.now() : undefined;
             this.visibilityEventHandler = () => {
                 if (document.hidden) {
-                    this.lastVisible = common_utils_1.performance.now();
+                    this.lastVisible = client_utils_1.performance.now();
                 }
                 else {
                     // settimeout so this will hopefully fire after disconnect event if being hidden caused it
@@ -512,7 +514,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         }
         return new Promise((resolve, reject) => {
             const runtimeInstantiatedHandler = () => {
-                (0, common_utils_1.assert)(this._runtime !== undefined, 0x5a3 /* runtimeInstantiated fired but runtime is still undefined */);
+                (0, core_utils_1.assert)(this._runtime !== undefined, 0x5a3 /* runtimeInstantiated fired but runtime is still undefined */);
                 resolve(this._runtime.getEntryPoint?.());
                 this._lifecycleEvents.off("disposed", disposedHandler);
             };
@@ -543,11 +545,11 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         this.verifyClosed();
     }
     verifyClosed() {
-        (0, common_utils_1.assert)(this.connectionState === connectionState_1.ConnectionState.Disconnected, 0x0cf /* "disconnect event was not raised!" */);
-        (0, common_utils_1.assert)(this._lifecycleState === "closed" || this._lifecycleState === "disposed", 0x314 /* Container properly closed */);
+        (0, core_utils_1.assert)(this.connectionState === connectionState_1.ConnectionState.Disconnected, 0x0cf /* "disconnect event was not raised!" */);
+        (0, core_utils_1.assert)(this._lifecycleState === "closed" || this._lifecycleState === "disposed", 0x314 /* Container properly closed */);
     }
     closeCore(error) {
-        (0, common_utils_1.assert)(!this.closed, 0x315 /* re-entrancy */);
+        (0, core_utils_1.assert)(!this.closed, 0x315 /* re-entrancy */);
         try {
             // Ensure that we raise all key events even if one of these throws
             try {
@@ -582,7 +584,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         }
     }
     disposeCore(error) {
-        (0, common_utils_1.assert)(!this._disposed, 0x54c /* Container already disposed */);
+        (0, core_utils_1.assert)(!this._disposed, 0x54c /* Container already disposed */);
         this._disposed = true;
         try {
             // Ensure that we raise all key events even if one of these throws
@@ -635,35 +637,41 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         return this.getPendingLocalStateCore({ notifyImminentClosure: false });
     }
     async getPendingLocalStateCore(props) {
-        if (!this.offlineLoadEnabled) {
-            throw new telemetry_utils_1.UsageError("Can't get pending local state unless offline load is enabled");
-        }
-        if (this.closed || this._disposed) {
-            throw new telemetry_utils_1.UsageError("Pending state cannot be retried if the container is closed or disposed");
-        }
-        (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" */);
-        (0, common_utils_1.assert)(!!this.baseSnapshot, 0x5d4 /* no base snapshot */);
-        (0, common_utils_1.assert)(!!this.baseSnapshotBlobs, 0x5d5 /* no snapshot blobs */);
-        const pendingRuntimeState = await this.runtime.getPendingLocalState(props);
-        const pendingState = {
-            pendingRuntimeState,
-            baseSnapshot: this.baseSnapshot,
-            snapshotBlobs: this.baseSnapshotBlobs,
-            savedOps: this.savedOps,
-            url: this.resolvedUrl.url,
-            term: protocol_1.OnlyValidTermValue,
-            // no need to save this if there is no pending runtime state
-            clientId: pendingRuntimeState !== undefined ? this.clientId : undefined,
-        };
-        this.mc.logger.sendTelemetryEvent({ eventName: "GetPendingLocalState" });
-        return JSON.stringify(pendingState);
+        return telemetry_utils_1.PerformanceEvent.timedExecAsync(this.mc.logger, {
+            eventName: "getPendingLocalState",
+            notifyImminentClosure: props.notifyImminentClosure,
+            savedOpsSize: this.savedOps.length,
+            clientId: this.clientId,
+        }, async () => {
+            if (!this.offlineLoadEnabled) {
+                throw new telemetry_utils_1.UsageError("Can't get pending local state unless offline load is enabled");
+            }
+            if (this.closed || this._disposed) {
+                throw new telemetry_utils_1.UsageError("Pending state cannot be retried if the container is closed or disposed");
+            }
+            (0, core_utils_1.assert)(this.attachState === container_definitions_1.AttachState.Attached, 0x0d1 /* "Container should be attached before close" */);
+            (0, core_utils_1.assert)(this.resolvedUrl !== undefined && this.resolvedUrl.type === "fluid", 0x0d2 /* "resolved url should be valid Fluid url" */);
+            (0, core_utils_1.assert)(!!this.baseSnapshot, 0x5d4 /* no base snapshot */);
+            (0, core_utils_1.assert)(!!this.baseSnapshotBlobs, 0x5d5 /* no snapshot blobs */);
+            const pendingRuntimeState = await this.runtime.getPendingLocalState(props);
+            const pendingState = {
+                pendingRuntimeState,
+                baseSnapshot: this.baseSnapshot,
+                snapshotBlobs: this.baseSnapshotBlobs,
+                savedOps: this.savedOps,
+                url: this.resolvedUrl.url,
+                term: protocol_1.OnlyValidTermValue,
+                // no need to save this if there is no pending runtime state
+                clientId: pendingRuntimeState !== undefined ? this.clientId : undefined,
+            };
+            return JSON.stringify(pendingState);
+        });
     }
     get attachState() {
         return this._attachState;
     }
     serialize() {
-        (0, common_utils_1.assert)(this.attachState === container_definitions_1.AttachState.Detached, 0x0d3 /* "Should only be called in detached container" */);
+        (0, core_utils_1.assert)(this.attachState === container_definitions_1.AttachState.Detached, 0x0d3 /* "Should only be called in detached container" */);
         const appSummary = this.runtime.createSummary();
         const protocolSummary = this.captureProtocolSummary();
         const combinedSummary = (0, utils_1.combineAppAndProtocolSummary)(appSummary, protocolSummary);
@@ -682,12 +690,12 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                 throw new telemetry_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.
-            (0, common_utils_1.assert)(this._attachState === container_definitions_1.AttachState.Detached && !this.attachStarted, 0x205 /* "attach() called more than once" */);
+            (0, core_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.detachedBlobStorage !== undefined && this.detachedBlobStorage.size > 0;
             try {
-                (0, common_utils_1.assert)(this.deltaManager.inbound.length === 0, 0x0d6 /* "Inbound queue should be empty when attaching" */);
+                (0, core_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
@@ -712,7 +720,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                 // Actually go and create the resolved document
                 if (this.service === undefined) {
                     const createNewResolvedUrl = await this.urlResolver.resolve(request);
-                    (0, common_utils_1.assert)(this.client.details.type !== summarizerClientType &&
+                    (0, core_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._deltaManager.closeAbortController.signal,
@@ -721,7 +729,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                 await this.storageAdapter.connectToService(this.service);
                 if (hasAttachmentBlobs) {
                     // upload blobs to storage
-                    (0, common_utils_1.assert)(!!this.detachedBlobStorage, 0x24e /* "assertion for type narrowing" */);
+                    (0, core_utils_1.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();
@@ -782,7 +790,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         if (currentMode === mode) {
             return;
         }
-        const now = common_utils_1.performance.now();
+        const now = client_utils_1.performance.now();
         const duration = now - this.setAutoReconnectTime;
         this.setAutoReconnectTime = now;
         this.mc.logger.sendTelemetryEvent({
@@ -811,8 +819,8 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         }
     }
     connectInternal(args) {
-        (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" */);
+        (0, core_utils_1.assert)(!this.closed, 0x2c5 /* "Attempting to connect() a closed Container" */);
+        (0, core_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
@@ -828,13 +836,13 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         }
     }
     disconnectInternal(reason) {
-        (0, common_utils_1.assert)(!this.closed, 0x2c7 /* "Attempting to disconnect() a closed Container" */);
+        (0, core_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, reason);
     }
     resumeInternal(args) {
-        (0, common_utils_1.assert)(!this.closed, 0x0d9 /* "Attempting to connect() a closed DeltaManager" */);
+        (0, core_utils_1.assert)(!this.closed, 0x0d9 /* "Attempting to connect() a closed DeltaManager" */);
         // Resume processing ops
         if (this.inboundQueuePausedFromInit) {
             this.inboundQueuePausedFromInit = false;
@@ -922,7 +930,7 @@ 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, resolvedUrl, pendingLocalState, loadToSequenceNumber) {
-        const timings = { phase1: common_utils_1.performance.now() };
+        const timings = { phase1: client_utils_1.performance.now() };
         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.
@@ -953,7 +961,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             });
         }
         this._attachState = container_definitions_1.AttachState.Attached;
-        timings.phase2 = common_utils_1.performance.now();
+        timings.phase2 = client_utils_1.performance.now();
         // Fetch specified snapshot.
         const { snapshot, versionId } = pendingLocalState === undefined
             ? await this.fetchSnapshotTree(specifiedVersion)
@@ -963,7 +971,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             this.baseSnapshotBlobs = pendingLocalState.snapshotBlobs;
         }
         else {
-            (0, common_utils_1.assert)(snapshot !== undefined, 0x237 /* "Snapshot should exist" */);
+            (0, core_utils_1.assert)(snapshot !== undefined, 0x237 /* "Snapshot should exist" */);
             if (this.offlineLoadEnabled) {
                 this.baseSnapshot = snapshot;
                 // Save contents of snapshot now, otherwise closeAndGetPendingLocalState() must be async
@@ -978,7 +986,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         if (loadMode.pauseAfterLoad === true) {
             // If we are trying to pause at a specific sequence number, ensure the latest snapshot is not newer than the desired sequence number.
             if (loadMode.opsBeforeReturn === "sequenceNumber") {
-                (0, common_utils_1.assert)(loadToSequenceNumber !== undefined, 0x727 /* sequenceNumber should be defined */);
+                (0, core_utils_1.assert)(loadToSequenceNumber !== undefined, 0x727 /* sequenceNumber should be defined */);
                 // Note: It is possible that we think the latest snapshot is newer than the specified sequence number
                 // due to saved ops that may be replayed after the snapshot.
                 // https://dev.azure.com/fluidframework/internal/_workitems/edit/5055
@@ -1031,12 +1039,12 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                 opsBeforeReturnP = this.attachDeltaManagerOpHandler(dmAttributes, loadMode.opsBeforeReturn);
                 break;
             default:
-                (0, common_utils_1.unreachableCase)(loadMode.opsBeforeReturn);
+                (0, core_utils_1.unreachableCase)(loadMode.opsBeforeReturn);
         }
         // ...load in the existing quorum
         // Initialize the protocol handler
         await this.initializeProtocolStateFromSnapshot(attributes, this.storageAdapter, snapshot);
-        timings.phase3 = common_utils_1.performance.now();
+        timings.phase3 = client_utils_1.performance.now();
         const codeDetails = this.getCodeDetailsFromQuorum();
         await this.instantiateRuntime(codeDetails, snapshot, 
         // give runtime a dummy value so it knows we're loading from a stash blob
@@ -1085,11 +1093,11 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         }
         // Internal context is fully loaded at this point
         this.setLoaded();
-        timings.end = common_utils_1.performance.now();
+        timings.end = client_utils_1.performance.now();
         this.subLogger.sendTelemetryEvent({
             eventName: "LoadStagesTimings",
             details: JSON.stringify(timings),
-        }, undefined, 0 /* verbose */);
+        }, undefined, core_interfaces_1.LogLevel.verbose);
         return {
             sequenceNumber: attributes.sequenceNumber,
             version: versionId,
@@ -1116,7 +1124,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
     }
     async rehydrateDetachedFromSnapshot(detachedContainerSnapshot) {
         if (detachedContainerSnapshot.tree[".hasAttachmentBlobs"] !== undefined) {
-            (0, common_utils_1.assert)(!!this.detachedBlobStorage && this.detachedBlobStorage.size > 0, 0x250 /* "serialized container with attachment blobs must be rehydrated with detached blob storage" */);
+            (0, core_utils_1.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 = (0, utils_1.getSnapshotTreeFromSerializedContainer)(detachedContainerSnapshot);
@@ -1272,7 +1280,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         // eslint-disable-next-line @typescript-eslint/no-floating-promises
         deltaManager.inboundSignal.pause();
         deltaManager.on("connect", (details, _opsBehind) => {
-            (0, common_utils_1.assert)(this.connectionMode === details.mode, 0x4b7 /* mismatch */);
+            (0, core_utils_1.assert)(this.connectionMode === details.mode, 0x4b7 /* mismatch */);
             this.connectionStateHandler.receivedConnectEvent(details);
         });
         deltaManager.on("establishingConnection", (reason) => {
@@ -1318,7 +1326,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
     }
     logConnectionStateChangeTelemetry(value, oldState, reason) {
         // Log actual event
-        const time = common_utils_1.performance.now();
+        const time = client_utils_1.performance.now();
         this.connectionTransitionTimes[value] = time;
         const duration = time - this.connectionTransitionTimes[oldState];
         let durationFromDisconnected;
@@ -1359,7 +1367,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             opsBehind,
             online: driver_utils_1.OnlineStatus[(0, driver_utils_1.isOnline)()],
             lastVisible: this.lastVisible !== undefined
-                ? common_utils_1.performance.now() - this.lastVisible
+                ? client_utils_1.performance.now() - this.lastVisible
                 : undefined,
             checkpointSequenceNumber,
             quorumSize: this._protocolHandler?.quorum.getMembers().size,
@@ -1445,13 +1453,13 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                 // That means that if relay service changes settings, such changes will impact only newly booted
                 // clients.
                 // All existing will continue to use settings they got earlier.
-                (0, common_utils_1.assert)(serviceConfiguration !== undefined, 0x2e4 /* "there should be service config for active connection" */);
+                (0, core_utils_1.assert)(serviceConfiguration !== undefined, 0x2e4 /* "there should be service config for active connection" */);
                 this.noopHeuristic = new noopHeuristic_1.NoopHeuristic(serviceConfiguration.noopTimeFrequency, serviceConfiguration.noopCountFrequency);
                 this.noopHeuristic.on("wantsNoop", () => {
                     // On disconnect we notify the heuristic which should prevent it from wanting a noop.
                     // Hitting this assert would imply we lost activeConnection between notifying the heuristic of a processed message and
                     // running the microtask that the heuristic queued in response.
-                    (0, common_utils_1.assert)(this.activeConnection(), 0x241 /* "Trying to send noop without active connection" */);
+                    (0, core_utils_1.assert)(this.activeConnection(), 0x241 /* "Trying to send noop without active connection" */);
                     this.submitMessage(protocol_definitions_1.MessageType.NoOp);
                 });
             }
@@ -1499,7 +1507,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         return { snapshot, versionId: version?.id };
     }
     async instantiateRuntime(codeDetails, snapshot, pendingLocalState) {
-        (0, common_utils_1.assert)(this._runtime?.disposed !== false, 0x0dd /* "Existing runtime not disposed" */);
+        (0, core_utils_1.assert)(this._runtime?.disposed !== false, 0x0dd /* "Existing runtime 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 maybeLoader = this.scope;
@@ -1551,7 +1559,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                 }
             // intentional fallthrough
             case "delayed":
-                (0, common_utils_1.assert)(this.inboundQueuePausedFromInit, 0x346 /* inboundQueuePausedFromInit should be true */);
+                (0, core_utils_1.assert)(this.inboundQueuePausedFromInit, 0x346 /* inboundQueuePausedFromInit should be true */);
                 this.inboundQueuePausedFromInit = false;
                 this._deltaManager.inbound.resume();
                 this._deltaManager.inboundSignal.resume();
@@ -1559,7 +1567,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             case "none":
                 break;
             default:
-                (0, common_utils_1.unreachableCase)(deltaConnectionArg);
+                (0, core_utils_1.unreachableCase)(deltaConnectionArg);
         }
     }
 }