@fluidframework/container-loader 2.0.0-rc.3.0.2 → 2.0.0-rc.4.0.0

package/lib/container.js

@@ -7,7 +7,7 @@ import { AttachState, } from "@fluidframework/container-definitions";
 import { isFluidCodeDetails, } from "@fluidframework/container-definitions/internal";
 import { LogLevel, } from "@fluidframework/core-interfaces";
 import { assert, isPromiseLike, unreachableCase } from "@fluidframework/core-utils/internal";
-import { MessageType2, OnlineStatus, isCombinedAppAndProtocolSummary, isInstanceOfISnapshot, isOnline, readAndParse, runWithRetry, } from "@fluidframework/driver-utils/internal";
+import { getSnapshotTree, MessageType2, OnlineStatus, isCombinedAppAndProtocolSummary, isInstanceOfISnapshot, isOnline, readAndParse, runWithRetry, } from "@fluidframework/driver-utils/internal";
 import { MessageType, SummaryType, } from "@fluidframework/protocol-definitions";
 import { EventEmitterWithErrorHandling, GenericError, PerformanceEvent, UsageError, connectedEventName, createChildLogger, createChildMonitoringContext, formatTick, normalizeError, raiseConnectedEvent, wrapError, } from "@fluidframework/telemetry-utils/internal";
 import structuredClone from "@ungap/structured-clone";
@@ -126,10 +126,9 @@ export class Container extends EventEmitterWithErrorHandling {
      * Load an existing container.
      */
     static async load(loadProps, createProps) {
-        const { version, pendingLocalState, loadMode, resolvedUrl, loadToSequenceNumber } = loadProps;
+        const { version, pendingLocalState, loadMode, resolvedUrl } = loadProps;
         const container = new Container(createProps, loadProps);
-        const disableRecordHeapSize = container.mc.config.getBoolean("Fluid.Loader.DisableRecordHeapSize");
-        return PerformanceEvent.timedExecAsync(container.mc.logger, { eventName: "Load" }, async (event) => new Promise((resolve, reject) => {
+        return PerformanceEvent.timedExecAsync(container.mc.logger, { eventName: "Load", ...loadMode }, async (event) => new Promise((resolve, reject) => {
             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
@@ -142,12 +141,12 @@ export class Container extends EventEmitterWithErrorHandling {
             };
             container.on("closed", onClosed);
             container
-                .load(version, mode, resolvedUrl, pendingLocalState, loadToSequenceNumber)
+                .load(version, mode, resolvedUrl, pendingLocalState)
                 .finally(() => {
                 container.removeListener("closed", onClosed);
             })
                 .then((props) => {
-                event.end({ ...props, ...loadMode });
+                event.end({ ...props });
                 resolve(container);
             }, (error) => {
                 const err = normalizeError(error);
@@ -161,7 +160,7 @@ export class Container extends EventEmitterWithErrorHandling {
                 container.dispose(err);
                 onClosed(err);
             });
-        }), { start: true, end: true, cancel: "generic" }, disableRecordHeapSize !== true /* recordHeapSize */);
+        }), { start: true, end: true, cancel: "generic" });
     }
     /**
      * Create a new container in a detached state.
@@ -176,6 +175,8 @@ export class Container extends EventEmitterWithErrorHandling {
     /**
      * Create a new container in a detached state that is initialized with a
      * snapshot from a previous detached container.
+     * @param createProps - Config options for this new container instance
+     * @param snapshot - A stringified {@link IPendingDetachedContainerState}, e.g. generated via {@link serialize}
      */
     static async rehydrateDetachedFromSnapshot(createProps, snapshot) {
         const container = new Container(createProps);
@@ -189,14 +190,33 @@ export class Container extends EventEmitterWithErrorHandling {
         // It's conceivable the container could be closed when this is called
         // Only transition states if currently loading
         if (this._lifecycleState === "loading") {
-            // Propagate current connection state through the system.
-            this.propagateConnectionState(true /* initial transition */);
             this._lifecycleState = "loaded";
+            // Connections transitions are delayed till we are loaded.
+            // This is done by holding ops and signals until the end of load sequence
+            // (calling this.handleDeltaConnectionArg() after setLoaded() call)
+            // If this assert fires, it means our logic managing connection flow is wrong, and the logic below is also wrong.
+            assert(this.connectionState !== ConnectionState.Connected, 0x969 /* not connected yet */);
+            // Propagate current connection state through the system.
+            const readonly = this.readOnlyInfo.readonly ?? false;
+            // This call does not look like needed any more, with delaying all connection-related events past loaded phase.
+            // Yet, there could be some customer code that would break if we do not deliver it.
+            // Will be removed in further PRs with proper changeset.
+            this.setContextConnectedState(false /* connected */, readonly);
+            // Deliver delayed calls to DeltaManager - we ignored "connect" events while loading.
+            const cm = this._deltaManager.connectionManager;
+            if (cm.connected) {
+                const details = cm.connectionDetails;
+                assert(details !== undefined, 0x96a /* should have details if connected */);
+                this.connectionStateHandler.receivedConnectEvent(details);
+            }
         }
     }
     get closed() {
         return (this._lifecycleState === "closing" || this._lifecycleState === "closed" || this.disposed);
     }
+    get loaded() {
+        return this._lifecycleState === "loaded";
+    }
     get disposed() {
         return this._lifecycleState === "disposing" || this._lifecycleState === "disposed";
     }
@@ -265,11 +285,12 @@ export class Container extends EventEmitterWithErrorHandling {
         return this.connectionStateHandler.connectionState === ConnectionState.Connected;
     }
     /**
-     * The server provided id of the client.
-     * Set once this.connected is true, otherwise undefined
+     * clientId of the latest connection. Changes only once client is connected, caught up and fully loaded.
+     * Changes to clientId are delayed through container loading sequence and delived once container is fully loaded.
+     * clientId does not reset on lost connection - old value persists until new connection is fully established.
      */
     get clientId() {
-        return this._clientId;
+        return this.protocolHandler.audience.getSelf()?.clientId;
     }
     get isInteractiveClient() {
         return this.deltaManager.clientDetails.capabilities.interactive;
@@ -333,6 +354,7 @@ export class Container extends EventEmitterWithErrorHandling {
                 eventName: "ContainerEventHandlerException",
                 name: typeof name === "string" ? name : undefined,
             }, error);
+            this.close(normalizeError(error));
         });
         /**
          * Lifecycle state of the container, used mainly to prevent re-entrancy and telemetry
@@ -427,13 +449,14 @@ export class Container extends EventEmitterWithErrorHandling {
                         throw normalizeErrorAndClose(error);
                     });
                 }
+                // If offline load is enabled, attachP will return the attach summary (in Snapshot format) so we can initialize SerializedStateManager
                 const snapshotWithBlobs = await attachP;
                 this.serializedStateManager.setInitialSnapshot(snapshotWithBlobs);
                 if (!this.closed) {
-                    this.handleDeltaConnectionArg({
+                    this.handleDeltaConnectionArg(attachProps?.deltaConnection, {
                         fetchOpsFromStorage: false,
                         reason: { text: "createDetached" },
-                    }, attachProps?.deltaConnection);
+                    });
                 }
             }, { start: true, end: true, cancel: "generic" });
         });
@@ -457,7 +480,6 @@ export class Container extends EventEmitterWithErrorHandling {
         const { canReconnect, clientDetailsOverride, urlResolver, documentServiceFactory, codeLoader, options, scope, subLogger, detachedBlobStorage, protocolHandlerBuilder, } = createProps;
         this.connectionTransitionTimes[ConnectionState.Disconnected] = performance.now();
         const pendingLocalState = loadProps?.pendingLocalState;
-        this._clientId = pendingLocalState?.clientId;
         this._canReconnect = canReconnect ?? true;
         this.clientDetailsOverride = clientDetailsOverride;
         this.urlResolver = urlResolver;
@@ -527,12 +549,9 @@ export class Container extends EventEmitterWithErrorHandling {
         this.connectionStateHandler = createConnectionStateHandler({
             logger: this.mc.logger,
             connectionStateChanged: (value, oldState, reason) => {
-                if (value === ConnectionState.Connected) {
-                    this._clientId = this.connectionStateHandler.pendingClientId;
-                }
                 this.logConnectionStateChangeTelemetry(value, oldState, reason);
-                if (this._lifecycleState === "loaded") {
-                    this.propagateConnectionState(false /* initial transition */, value === ConnectionState.Disconnected
+                if (this.loaded) {
+                    this.propagateConnectionState(value === ConnectionState.Disconnected
                         ? reason
                         : undefined /* disconnectedReason */);
                 }
@@ -554,15 +573,22 @@ export class Container extends EventEmitterWithErrorHandling {
                         this.connectionTransitionTimes[ConnectionState.CatchingUp],
                     ...(details === undefined ? {} : { details: JSON.stringify(details) }),
                 });
+                // This assert is important for many reasons:
+                // 1) Cosmetic / OCE burden: It's useless to raise NoJoinOp error events, if we are loading, as that's most
+                //    likely to happen if snapshot loading takes too long. During this time we are not processing ops so there is no
+                //    way to move to "connected" state, and thus "NoJoin" timer would fire (see
+                //    IConnectionStateHandler.logConnectionIssue() callback and related code in ConnectStateHandler class implementation).
+                //    But these events do not tell us anything about connectivity pipeline / op processing pipeline,
+                //    only that boot is slow, and we have events for that.
+                // 2) Doing recovery below is useless in loading mode, for the reasons described above. At the same time we can't
+                //    not do it, as maybe we lost JoinSignal for "self", and when loading is done, we never move to connected
+                //    state. So we would have to do (in most cases) useless infinite reconnect loop while we are loading.
+                assert(this.loaded, 0x96b /* connection issues can be raised only after container is loaded */);
                 // If this is "write" connection, it took too long to receive join op. But in most cases that's due
                 // to very slow op fetches and we will eventually get there.
-                // For "read" connections, we get here due to self join signal not arriving on time. We will need to
-                // better understand when and why it may happen.
-                // For now, attempt to recover by reconnecting. In future, maybe we can query relay service for
-                // current state of audience.
-                // Other possible recovery path - move to connected state (i.e. ConnectionStateHandler.joinOpTimer
-                // to call this.applyForConnectedState("addMemberEvent") for "read" connections)
-                if (mode === "read") {
+                // For "read" connections, we get here due to join signal for "self" not arriving on time.
+                // Attempt to recover by reconnecting.
+                if (mode === "read" && category === "error") {
                     const reason = { text: "NoJoinSignal" };
                     this.disconnectInternal(reason);
                     this.connectInternal({ reason, fetchOpsFromStorage: false });
@@ -571,6 +597,9 @@ export class Container extends EventEmitterWithErrorHandling {
             clientShouldHaveLeft: (clientId) => {
                 this.clientsWhoShouldHaveLeft.add(clientId);
             },
+            onCriticalError: (error) => {
+                this.close(normalizeError(error));
+            },
         }, this.deltaManager, pendingLocalState?.clientId);
         this.on(savedContainerEvent, () => {
             this.connectionStateHandler.containerSaved();
@@ -585,11 +614,11 @@ export class Container extends EventEmitterWithErrorHandling {
         // Even if not forced on via this flag, combined summaries may still be enabled by service policy.
         const forceEnableSummarizeProtocolTree = this.mc.config.getBoolean("Fluid.Container.summarizeProtocolTree2") ??
             options.summarizeProtocolTree;
-        this.storageAdapter = new ContainerStorageAdapter(detachedBlobStorage, this.mc.logger, pendingLocalState?.snapshotBlobs, addProtocolSummaryIfMissing, forceEnableSummarizeProtocolTree);
+        this.storageAdapter = new ContainerStorageAdapter(detachedBlobStorage, this.mc.logger, pendingLocalState?.snapshotBlobs, pendingLocalState?.loadedGroupIdSnapshots, addProtocolSummaryIfMissing, forceEnableSummarizeProtocolTree);
         const offlineLoadEnabled = (this.isInteractiveClient &&
             this.mc.config.getBoolean("Fluid.Container.enableOfflineLoad")) ??
             options.enableOfflineLoad === true;
-        this.serializedStateManager = new SerializedStateManager(pendingLocalState, this.subLogger, this.storageAdapter, offlineLoadEnabled);
+        this.serializedStateManager = new SerializedStateManager(pendingLocalState, this.subLogger, this.storageAdapter, offlineLoadEnabled, this, () => this.isDirty);
         const isDomAvailable = typeof document === "object" &&
             document !== null &&
             typeof document.addEventListener === "function" &&
@@ -724,6 +753,11 @@ export class Container extends EventEmitterWithErrorHandling {
         this.close();
         return pendingState;
     }
+    /**
+     * Serialize current container state required to rehydrate to the same position without dataloss.
+     * Note: The container must already be attached. For detached containers use {@link serialize}
+     * @returns stringified {@link IPendingContainerState} for the container
+     */
     async getPendingLocalState() {
         return this.getPendingLocalStateCore({ notifyImminentClosure: false });
     }
@@ -733,12 +767,18 @@ export class Container extends EventEmitterWithErrorHandling {
         }
         assert(this.attachmentData.state === AttachState.Attached, 0x0d1 /* "Container should be attached before close" */);
         assert(this.resolvedUrl !== undefined && this.resolvedUrl.type === "fluid", 0x0d2 /* "resolved url should be valid Fluid url" */);
-        const pendingState = await this.serializedStateManager.getPendingLocalStateCore(props, this.clientId, this.runtime, this.resolvedUrl);
+        const pendingState = await this.serializedStateManager.getPendingLocalState(props, this.clientId, this.runtime, this.resolvedUrl);
         return pendingState;
     }
     get attachState() {
         return this.attachmentData.state;
     }
+    /**
+     * Serialize current container state required to rehydrate to the same position without dataloss.
+     * Note: The container must be detached and not closed. For attached containers use
+     * {@link getPendingLocalState} or {@link closeAndGetPendingLocalState}
+     * @returns stringified {@link IPendingDetachedContainerState} for the container
+     */
     serialize() {
         if (this.attachmentData.state === AttachState.Attached || this.closed) {
             throw new UsageError("Container must not be attached or closed.");
@@ -794,11 +834,11 @@ export class Container extends EventEmitterWithErrorHandling {
     connectInternal(args) {
         assert(!this.closed, 0x2c5 /* "Attempting to connect() a closed Container" */);
         assert(this.attachState === 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
         const mode = ReconnectMode.Enabled;
         this.setAutoReconnectInternal(mode, args.reason);
+        // Resume processing ops and connect to delta stream
+        this.resumeInternal(args);
     }
     disconnect() {
         if (this.closed) {
@@ -818,6 +858,11 @@ export class Container extends EventEmitterWithErrorHandling {
         assert(!this.closed, 0x0d9 /* "Attempting to connect() a closed DeltaManager" */);
         // Resume processing ops
         if (this.inboundQueuePausedFromInit) {
+            // This assert guards against possibility of ops/signals showing up too soon, while
+            // container is not ready yet to receive them. We can hit it only if some internal code call into here,
+            // as public API like Container.connect() can be only called when user got back container object, i.e.
+            // it is already fully loaded.
+            assert(this.loaded, 0x96c /* connect() can be called only in fully loaded state */);
             this.inboundQueuePausedFromInit = false;
             this._deltaManager.inbound.resume();
             this._deltaManager.inboundSignal.resume();
@@ -906,7 +951,7 @@ export class Container extends EventEmitterWithErrorHandling {
      *
      * @param specifiedVersion - Version SHA to load snapshot. If not specified, will fetch the latest snapshot.
      */
-    async load(specifiedVersion, loadMode, resolvedUrl, pendingLocalState, loadToSequenceNumber) {
+    async load(specifiedVersion, loadMode, resolvedUrl, pendingLocalState) {
         const timings = { phase1: performance.now() };
         this.service = await this.createDocumentService(async () => this.serviceFactory.createDocumentService(resolvedUrl, this.subLogger, this.client.details.type === summarizerClientType));
         // Except in cases where it has stashed ops or requested by feature gate, the container will connect in "read" mode
@@ -921,7 +966,7 @@ export class Container extends EventEmitterWithErrorHandling {
         };
         // Start websocket connection as soon as possible. Note that there is no op handler attached yet, but the
         // DeltaManager is resilient to this and will wait to start processing ops until after it is attached.
-        if (loadMode.deltaConnection === undefined && !pendingLocalState) {
+        if (loadMode.deltaConnection === undefined) {
             this.connectToDeltaStream(connectionArgs);
         }
         this.storageAdapter.connectToService(this.service);
@@ -933,54 +978,13 @@ export class Container extends EventEmitterWithErrorHandling {
             true && this.service?.policies?.supportGetSnapshotApi === true;
         // Fetch specified snapshot.
         const { baseSnapshot, version } = await this.serializedStateManager.fetchSnapshot(specifiedVersion, supportGetSnapshotApi);
+        const baseSnapshotTree = getSnapshotTree(baseSnapshot);
         this._loadedFromVersion = version;
-        const attributes = await getDocumentAttributes(this.storageAdapter, baseSnapshot);
+        const attributes = await getDocumentAttributes(this.storageAdapter, baseSnapshotTree);
         // If we saved ops, we will replay them and don't need DeltaManager to fetch them
         const lastProcessedSequenceNumber = pendingLocalState?.savedOps[pendingLocalState.savedOps.length - 1]?.sequenceNumber ??
             attributes.sequenceNumber;
         let opsBeforeReturnP;
-        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") {
-                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
-                if (lastProcessedSequenceNumber > loadToSequenceNumber) {
-                    throw new Error("Cannot satisfy request to pause the container at the specified sequence number. Most recent snapshot is newer than the specified sequence number.");
-                }
-            }
-            // Force readonly mode - this will ensure we don't receive an error for the lack of join op
-            this.forceReadonly(true);
-            // We need to setup a listener to stop op processing once we reach the desired sequence number (if specified).
-            const opHandler = () => {
-                if (loadToSequenceNumber === undefined) {
-                    // If there is no specified sequence number, pause after the inbound queue is empty.
-                    if (this.deltaManager.inbound.length !== 0) {
-                        return;
-                    }
-                }
-                else {
-                    // If there is a specified sequence number, keep processing until we reach it.
-                    if (this.deltaManager.lastSequenceNumber < loadToSequenceNumber) {
-                        return;
-                    }
-                }
-                // Pause op processing once we have processed the desired number of ops.
-                void this.deltaManager.inbound.pause();
-                void this.deltaManager.outbound.pause();
-                this.off("op", opHandler);
-            };
-            if ((loadToSequenceNumber === undefined && this.deltaManager.inbound.length === 0) ||
-                this.deltaManager.lastSequenceNumber === loadToSequenceNumber) {
-                // If we have already reached the desired sequence number, call opHandler() to pause immediately.
-                opHandler();
-            }
-            else {
-                // If we have not yet reached the desired sequence number, setup a listener to pause once we reach it.
-                this.on("op", opHandler);
-            }
-        }
         // Attach op handlers to finish initialization and be able to start processing ops
         // Kick off any ops fetching if required.
         switch (loadMode.opsBeforeReturn) {
@@ -989,7 +993,6 @@ export class Container extends EventEmitterWithErrorHandling {
                 // eslint-disable-next-line @typescript-eslint/no-floating-promises
                 this.attachDeltaManagerOpHandler(attributes, loadMode.deltaConnection !== "none" ? "all" : "none", lastProcessedSequenceNumber);
                 break;
-            case "sequenceNumber":
             case "cached":
             case "all":
                 opsBeforeReturnP = this.attachDeltaManagerOpHandler(attributes, loadMode.opsBeforeReturn, lastProcessedSequenceNumber);
@@ -999,10 +1002,16 @@ export class Container extends EventEmitterWithErrorHandling {
         }
         // ...load in the existing quorum
         // Initialize the protocol handler
-        await this.initializeProtocolStateFromSnapshot(attributes, this.storageAdapter, baseSnapshot);
+        await this.initializeProtocolStateFromSnapshot(attributes, this.storageAdapter, baseSnapshotTree);
+        // If we are loading from pending state, we start with old clientId.
+        // We switch to latest connection clientId only after setLoaded().
+        assert(this.clientId === undefined, 0x96d /* there should be no clientId yet */);
+        if (pendingLocalState?.clientId !== undefined) {
+            this.protocolHandler.audience.setCurrentClientId(pendingLocalState?.clientId);
+        }
         timings.phase3 = performance.now();
         const codeDetails = this.getCodeDetailsFromQuorum();
-        await this.instantiateRuntime(codeDetails, baseSnapshot, 
+        await this.instantiateRuntime(codeDetails, baseSnapshotTree, 
         // give runtime a dummy value so it knows we're loading from a stash blob
         pendingLocalState ? pendingLocalState?.pendingRuntimeState ?? {} : undefined, isInstanceOfISnapshot(baseSnapshot) ? baseSnapshot : undefined);
         // replay saved ops
@@ -1016,6 +1025,7 @@ export class Container extends EventEmitterWithErrorHandling {
                 await this.runtime.notifyOpReplay?.(message);
             }
             pendingLocalState.savedOps = [];
+            this.storageAdapter.clearPendingState();
         }
         // We might have hit some failure that did not manifest itself in exception in this flow,
         // do not start op processing in such case - static version of Container.load() will handle it correctly.
@@ -1027,20 +1037,11 @@ export class Container extends EventEmitterWithErrorHandling {
                 // eslint-disable-next-line @typescript-eslint/no-floating-promises
                 this._deltaManager.inbound.pause();
             }
-            this.handleDeltaConnectionArg(connectionArgs, loadMode.deltaConnection, pendingLocalState !== undefined);
-        }
-        // If we have not yet reached `loadToSequenceNumber`, we will wait for ops to arrive until we reach it
-        if (loadToSequenceNumber !== undefined &&
-            this.deltaManager.lastSequenceNumber < loadToSequenceNumber) {
-            await new Promise((resolve, reject) => {
-                const opHandler = (message) => {
-                    if (message.sequenceNumber >= loadToSequenceNumber) {
-                        resolve();
-                        this.off("op", opHandler);
-                    }
-                };
-                this.on("op", opHandler);
-            });
+            // Internal context is fully loaded at this point
+            // Move to loaded before calling this.handleDeltaConnectionArg() - latter allows ops & signals in, which
+            // may result in container moving to "connected" state. Such transitions are allowed only in loaded state.
+            this.setLoaded();
+            this.handleDeltaConnectionArg(loadMode.deltaConnection);
         }
         // Safety net: static version of Container.load() should have learned about it through "closed" handler.
         // But if that did not happen for some reason, fail load for sure.
@@ -1050,8 +1051,6 @@ export class Container extends EventEmitterWithErrorHandling {
         if (this.closed) {
             throw new Error("Container was closed while load()");
         }
-        // Internal context is fully loaded at this point
-        this.setLoaded();
         timings.end = performance.now();
         this.subLogger.sendTelemetryEvent({
             eventName: "LoadStagesTimings",
@@ -1231,7 +1230,21 @@ export class Container extends EventEmitterWithErrorHandling {
         deltaManager.inboundSignal.pause();
         deltaManager.on("connect", (details, _opsBehind) => {
             assert(this.connectionMode === details.mode, 0x4b7 /* mismatch */);
-            this.connectionStateHandler.receivedConnectEvent(details);
+            // Delay raising events until setLoaded()
+            // Here are some of the reasons why this design is chosen:
+            // 1. Various processes track speed of connection. But we are not processing ops or signal while container is loading,
+            //    and thus we can't move forward across connection modes. This results in telemetry errors (like NoJoinOp) that
+            //    have nothing to do with connection flow itself
+            // 2. This also makes it hard to reason about recovery (like reconnection) in case we might have lost JoinSignal. Reconnecting
+            //    in loading phase is useless (get back to same state), but at the same time not doing it may result in broken connection
+            //    without recovery (after we loaded).
+            // 3. We expose non-consistent view. ContainerRuntime may start loading in non-connected state, but end in connected, with
+            //    no events telling about it (until we loaded). Most of the code relies on a fact that state changes when events fire.
+            // This will not delay any processes (as observed by the user). I.e. once container moves to loaded phase,
+            // we immediately would transition across all phases, if we have proper signals / ops ready.
+            if (this.loaded) {
+                this.connectionStateHandler.receivedConnectEvent(details);
+            }
         });
         deltaManager.on("establishingConnection", (reason) => {
             this.connectionStateHandler.establishingConnection(reason);
@@ -1241,8 +1254,14 @@ export class Container extends EventEmitterWithErrorHandling {
         });
         deltaManager.on("disconnect", (text, error) => {
             this.noopHeuristic?.notifyDisconnect();
-            if (!this.closed) {
-                this.connectionStateHandler.receivedDisconnectEvent({ text, error });
+            const reason = { text, error };
+            // Symmetry with "connect" events
+            if (this.loaded) {
+                this.connectionStateHandler.receivedDisconnectEvent(reason);
+            }
+            else if (!this.closed) {
+                // Raise cancellation to get state machine back to initial state
+                this.connectionStateHandler.cancelEstablishingConnection(reason);
             }
         });
         deltaManager.on("throttled", (warning) => {
@@ -1255,7 +1274,9 @@ export class Container extends EventEmitterWithErrorHandling {
             this.emit("warning", warn);
         });
         deltaManager.on("readonly", (readonly) => {
-            this.setContextConnectedState(this.connectionState === ConnectionState.Connected, readonly);
+            if (this.loaded) {
+                this.setContextConnectedState(this.connectionState === ConnectionState.Connected, readonly);
+            }
             this.emit("readonly", readonly);
         });
         deltaManager.on("closed", (error) => {
@@ -1297,8 +1318,7 @@ export class Container extends EventEmitterWithErrorHandling {
                 // This info is of most interesting while Catching Up.
                 checkpointSequenceNumber = this.deltaManager.lastKnownSeqNumber;
                 // Need to check that we have already loaded and fetched the snapshot.
-                if (this.deltaManager.hasCheckpointSequenceNumber &&
-                    this._lifecycleState === "loaded") {
+                if (this.deltaManager.hasCheckpointSequenceNumber && this.loaded) {
                     opsBehind = checkpointSequenceNumber - this.deltaManager.lastSequenceNumber;
                 }
             }
@@ -1312,7 +1332,7 @@ export class Container extends EventEmitterWithErrorHandling {
             reason: reason?.text,
             connectionInitiationReason,
             pendingClientId: this.connectionStateHandler.pendingClientId,
-            clientId: this.clientId,
+            clientId: this.connectionStateHandler.clientId,
             autoReconnect,
             opsBehind,
             online: OnlineStatus[isOnline()],
@@ -1328,20 +1348,23 @@ export class Container extends EventEmitterWithErrorHandling {
             this.firstConnection = false;
         }
     }
-    propagateConnectionState(initialTransition, disconnectedReason) {
-        // When container loaded, we want to propagate initial connection state.
-        // After that, we communicate only transitions to Connected & Disconnected states, skipping all other states.
+    propagateConnectionState(disconnectedReason) {
+        const connected = this.connectionState === ConnectionState.Connected;
+        if (connected) {
+            const clientId = this.connectionStateHandler.clientId;
+            assert(clientId !== undefined, 0x96e /* there has to be clientId */);
+            this.protocolHandler.audience.setCurrentClientId(clientId);
+        }
+        // We communicate only transitions to Connected & Disconnected states, skipping all other states.
         // This can be changed in the future, for example we likely should add "CatchingUp" event on Container.
-        if (!initialTransition &&
-            this.connectionState !== ConnectionState.Connected &&
+        if (this.connectionState !== ConnectionState.Connected &&
             this.connectionState !== ConnectionState.Disconnected) {
             return;
         }
-        const state = this.connectionState === ConnectionState.Connected;
         // Both protocol and context should not be undefined if we got so far.
-        this.setContextConnectedState(state, this.readOnlyInfo.readonly ?? false);
-        this.protocolHandler.setConnectionState(state, this.clientId);
-        raiseConnectedEvent(this.mc.logger, this, state, this.clientId, disconnectedReason?.text);
+        this.setContextConnectedState(connected, this.readOnlyInfo.readonly ?? false);
+        this.protocolHandler.setConnectionState(connected, this.clientId);
+        raiseConnectedEvent(this.mc.logger, this, connected, this.clientId, disconnectedReason?.text);
     }
     // back-compat: ADO #1385: Remove in the future, summary op should come through submitSummaryMessage()
     submitContainerMessage(type, contents, batch, metadata) {
@@ -1462,24 +1485,29 @@ export class Container extends EventEmitterWithErrorHandling {
     /**
      * Set the connected state of the ContainerContext
      * This controls the "connected" state of the ContainerRuntime as well
-     * @param state - Is the container currently connected?
+     * @param connected - Is the container currently connected?
      * @param readonly - Is the container in readonly mode?
      */
-    setContextConnectedState(state, readonly) {
-        if (this._runtime?.disposed === false) {
+    setContextConnectedState(connected, readonly) {
+        if (this._runtime?.disposed === false && this.loaded) {
             /**
              * We want to lie to the ContainerRuntime when we are in readonly mode to prevent issues with pending
              * ops getting through to the DeltaManager.
              * The ContainerRuntime's "connected" state simply means it is ok to send ops
              * See https://dev.azure.com/fluidframework/internal/_workitems/edit/1246
              */
-            this.runtime.setConnectionState(state && !readonly, this.clientId);
+            this.runtime.setConnectionState(connected && !readonly, this.clientId);
         }
     }
-    handleDeltaConnectionArg(connectionArgs, deltaConnectionArg, canConnect = true) {
+    handleDeltaConnectionArg(deltaConnectionArg, connectionArgs) {
+        // This ensures that we allow transitions to "connected" state only after container has been fully loaded
+        // and we propagate such events to container runtime. All events prior to being loaded are ignored.
+        // This means if we get here in non-loaded state, we might not deliver proper events to container runtime,
+        // and runtime implementation may miss such events.
+        assert(this.loaded, 0x96f /* has to be called after container transitions to loaded state */);
         switch (deltaConnectionArg) {
             case undefined:
-                if (canConnect) {
+                if (connectionArgs) {
                     // connect to delta stream now since we did not before
                     this.connectToDeltaStream(connectionArgs);
                 }