@fluidframework/container-loader 2.0.0-internal.1.1.3 → 2.0.0-internal.1.2.0

package/dist/connectionStateHandler.d.ts

@@ -4,23 +4,74 @@
  */
 import { ITelemetryLogger, ITelemetryProperties } from "@fluidframework/common-definitions";
 import { IConnectionDetails, IDeltaManager } from "@fluidframework/container-definitions";
-import { IProtocolHandler } from "@fluidframework/protocol-base";
-import { ConnectionMode, IQuorumClients } from "@fluidframework/protocol-definitions";
+import { ConnectionMode } from "@fluidframework/protocol-definitions";
 import { ConnectionState } from "./connectionState";
+import { IProtocolHandler } from "./protocol";
 /** Constructor parameter type for passing in dependencies needed by the ConnectionStateHandler */
 export interface IConnectionStateHandlerInputs {
-    /** Provides access to the clients currently in the quorum */
-    quorumClients: () => IQuorumClients | undefined;
+    logger: ITelemetryLogger;
     /** Log to telemetry any change in state, included to Connecting */
-    logConnectionStateChangeTelemetry: (value: ConnectionState, oldState: ConnectionState, reason?: string | undefined) => void;
+    connectionStateChanged: (value: ConnectionState, oldState: ConnectionState, reason?: string | undefined) => void;
     /** Whether to expect the client to join in write mode on next connection */
     shouldClientJoinWrite: () => boolean;
     /** (Optional) How long should we wait on our previous client's Leave op before transitioning to Connected again */
     maxClientLeaveWaitTime: number | undefined;
     /** Log an issue encountered while in the Connecting state. details will be logged as a JSON string */
     logConnectionIssue: (eventName: string, details?: ITelemetryProperties) => void;
-    /** Callback whenever the ConnectionState changes between Disconnected and Connected */
-    connectionStateChanged: () => void;
+}
+/**
+ * interface that connection state handler implements
+ */
+export interface IConnectionStateHandler {
+    readonly connectionState: ConnectionState;
+    readonly pendingClientId: string | undefined;
+    containerSaved(): void;
+    dispose(): void;
+    initProtocol(protocol: IProtocolHandler): void;
+    receivedConnectEvent(connectionMode: ConnectionMode, details: IConnectionDetails): void;
+    receivedDisconnectEvent(reason: string): void;
+}
+export declare function createConnectionStateHandler(inputs: IConnectionStateHandlerInputs, deltaManager: IDeltaManager<any, any>, clientId?: string): ConnectionStateHandler | ConnectionStateCatchup;
+export declare function createConnectionStateHandlerCore(wait: boolean, inputs: IConnectionStateHandlerInputs, deltaManager: IDeltaManager<any, any>, clientId?: string): ConnectionStateHandler | ConnectionStateCatchup;
+/**
+ * Class that can be used as a base class for building IConnectionStateHandler adapters / pipeline.
+ * It implements both ends of communication interfaces and passes data back and forward
+ */
+declare class ConnectionStateHandlerPassThrough implements IConnectionStateHandler, IConnectionStateHandlerInputs {
+    protected readonly inputs: IConnectionStateHandlerInputs;
+    protected readonly pimpl: IConnectionStateHandler;
+    constructor(inputs: IConnectionStateHandlerInputs, pimplFactory: (handler: IConnectionStateHandlerInputs) => IConnectionStateHandler);
+    /**
+     * IConnectionStateHandler
+     */
+    get connectionState(): ConnectionState;
+    get pendingClientId(): string | undefined;
+    containerSaved(): void;
+    dispose(): void;
+    initProtocol(protocol: IProtocolHandler): void;
+    receivedDisconnectEvent(reason: string): void;
+    receivedConnectEvent(connectionMode: ConnectionMode, details: IConnectionDetails): void;
+    /**
+     * IConnectionStateHandlerInputs
+     */
+    get logger(): ITelemetryLogger;
+    connectionStateChanged(value: ConnectionState, oldState: ConnectionState, reason?: string | undefined): void;
+    shouldClientJoinWrite(): boolean;
+    get maxClientLeaveWaitTime(): number | undefined;
+    logConnectionIssue(eventName: string, details?: ITelemetryProperties): void;
+}
+/**
+ * Implementation of IConnectionStateHandler pass-through adapter that waits for specific sequence number
+ * before raising connected event
+ */
+declare class ConnectionStateCatchup extends ConnectionStateHandlerPassThrough {
+    private readonly deltaManager;
+    private catchUpMonitor;
+    constructor(inputs: IConnectionStateHandlerInputs, pimplFactory: (handler: IConnectionStateHandlerInputs) => IConnectionStateHandler, deltaManager: IDeltaManager<any, any>);
+    private _connectionState;
+    get connectionState(): ConnectionState;
+    connectionStateChanged(value: ConnectionState, oldState: ConnectionState, reason?: string | undefined): void;
+    private readonly transitionToConnectedState;
 }
 /**
  * In the lifetime of a container, the connection will likely disconnect and reconnect periodically.
@@ -34,33 +85,36 @@ export interface IConnectionStateHandlerInputs {
  *
  * The job of this class is to encapsulate the transition period during reconnect, which is identified by
  * ConnectionState.CatchingUp. Specifically, before moving to Connected state with the new clientId, it ensures that:
- * (A) We process the Leave op for the previous clientId. This allows us to properly handle any acks from in-flight ops
- *     that got sequenced with the old clientId (we'll recognize them as local ops). After the Leave op, any other
- *     pending ops can safely be submitted with the new clientId without fear of duplication in the sequenced op stream.
- * (B) We process the Join op for the new clientId (identified when the underlying connection was first established),
- *     indicating the service is ready to sequence ops sent with the new clientId.
- * (C) We process all ops known at the time the underlying connection was established (so we are "caught up")
  *
- * For (A) we give up waiting after some time (same timeout as server uses), and go ahead and transition to Connected.
- * For (B) we log telemetry if it takes too long, but still only transition to Connected when the Join op is processed
+ * a. We process the Leave op for the previous clientId. This allows us to properly handle any acks from in-flight ops
+ * that got sequenced with the old clientId (we'll recognize them as local ops). After the Leave op, any other
+ * pending ops can safely be submitted with the new clientId without fear of duplication in the sequenced op stream.
+ *
+ * b. We process the Join op for the new clientId (identified when the underlying connection was first established),
+ * indicating the service is ready to sequence ops sent with the new clientId.
+ *
+ * c. We process all ops known at the time the underlying connection was established (so we are "caught up")
+ *
+ * For (a) we give up waiting after some time (same timeout as server uses), and go ahead and transition to Connected.
+ *
+ * For (b) we log telemetry if it takes too long, but still only transition to Connected when the Join op is processed
  * and we are added to the Quorum.
- * For (C) this is optional behavior, controlled by the parameters of receivedConnectEvent
+ *
+ * For (c) this is optional behavior, controlled by the parameters of receivedConnectEvent
  */
-export declare class ConnectionStateHandler {
+declare class ConnectionStateHandler implements IConnectionStateHandler {
     private readonly handler;
-    private readonly logger;
     private _clientId?;
     private _connectionState;
     private _pendingClientId;
-    private catchUpMonitor;
     private readonly prevClientLeftTimer;
     private readonly joinOpTimer;
+    private protocol?;
     private waitEvent;
     get connectionState(): ConnectionState;
-    get connected(): boolean;
-    get clientId(): string | undefined;
+    private get clientId();
     get pendingClientId(): string | undefined;
-    constructor(handler: IConnectionStateHandlerInputs, logger: ITelemetryLogger, _clientId?: string | undefined);
+    constructor(handler: IConnectionStateHandlerInputs, _clientId?: string | undefined);
     private startJoinOpTimer;
     private stopJoinOpTimer;
     private get waitingForLeaveOp();
@@ -70,7 +124,6 @@ export declare class ConnectionStateHandler {
     private applyForConnectedState;
     private receivedRemoveMemberEvent;
     receivedDisconnectEvent(reason: string): void;
-    private readonly transitionToConnectedState;
     /**
      * The "connect" event indicates the connection to the Relay Service is live.
      * However, some additional conditions must be met before we can fully transition to
@@ -80,10 +133,11 @@ export declare class ConnectionStateHandler {
      * @param deltaManager - DeltaManager to be used for delaying Connected transition until caught up.
      * If it's undefined, then don't delay and transition to Connected as soon as Leave/Join op are accounted for
      */
-    receivedConnectEvent(connectionMode: ConnectionMode, details: IConnectionDetails, deltaManager?: IDeltaManager<any, any>): void;
-    /** Clear all the state used during the Connecting phase (set in receivedConnectEvent) */
-    private clearPendingConnectionState;
+    receivedConnectEvent(connectionMode: ConnectionMode, details: IConnectionDetails): void;
     private setConnectionState;
+    protected get membership(): import("@fluidframework/protocol-definitions").IQuorum | undefined;
     initProtocol(protocol: IProtocolHandler): void;
+    protected hasMember(clientId?: string): boolean;
 }
+export {};
 //# sourceMappingURL=connectionStateHandler.d.ts.map

package/dist/connectionStateHandler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"connectionStateHandler.d.ts","sourceRoot":"","sources":["../src/connectionStateHandler.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,gBAAgB,EAAE,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AAE5F,OAAO,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM,uCAAuC,CAAC;AAC1F,OAAO,EAAyB,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AACxF,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,sCAAsC,CAAC;AAEtF,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAGpD,kGAAkG;AAClG,MAAM,WAAW,6BAA6B;IAC1C,6DAA6D;IAC7D,aAAa,EAAE,MAAM,cAAc,GAAG,SAAS,CAAC;IAChD,mEAAmE;IACnE,iCAAiC,EAC7B,CAAC,KAAK,EAAE,eAAe,EAAE,QAAQ,EAAE,eAAe,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,KAAK,IAAI,CAAC;IAC7F,4EAA4E;IAC5E,qBAAqB,EAAE,MAAM,OAAO,CAAC;IACrC,mHAAmH;IACnH,sBAAsB,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3C,sGAAsG;IACtG,kBAAkB,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,oBAAoB,KAAK,IAAI,CAAC;IAChF,uFAAuF;IACvF,sBAAsB,EAAE,MAAM,IAAI,CAAC;CACtC;AAID;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,qBAAa,sBAAsB;IA0B3B,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,SAAS,CAAC;IA3BtB,OAAO,CAAC,gBAAgB,CAAgC;IACxD,OAAO,CAAC,gBAAgB,CAAqB;IAC7C,OAAO,CAAC,cAAc,CAA8B;IACpD,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAQ;IAC5C,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAQ;IAEpC,OAAO,CAAC,SAAS,CAA+B;IAEhD,IAAW,eAAe,IAAI,eAAe,CAE5C;IAED,IAAW,SAAS,IAAI,OAAO,CAE9B;IAED,IAAW,QAAQ,IAAI,MAAM,GAAG,SAAS,CAExC;IAED,IAAW,eAAe,IAAI,MAAM,GAAG,SAAS,CAE/C;gBAGoB,OAAO,EAAE,6BAA6B,EACtC,MAAM,EAAE,gBAAgB,EACjC,SAAS,CAAC,oBAAQ;IAoC9B,OAAO,CAAC,gBAAgB;IAKxB,OAAO,CAAC,eAAe;IAKvB,OAAO,KAAK,iBAAiB,GAE5B;IAEM,OAAO;IAKP,cAAc;IASrB,OAAO,CAAC,sBAAsB;IAwB9B,OAAO,CAAC,sBAAsB;IAqC9B,OAAO,CAAC,yBAAyB;IAQ1B,uBAAuB,CAAC,MAAM,EAAE,MAAM;IAI7C,OAAO,CAAC,QAAQ,CAAC,0BAA0B,CAUzC;IAEF;;;;;;;;OAQG;IACI,oBAAoB,CACvB,cAAc,EAAE,cAAc,EAC9B,OAAO,EAAE,kBAAkB,EAC3B,YAAY,CAAC,EAAE,aAAa,CAAC,GAAG,EAAE,GAAG,CAAC;IAqD1C,yFAAyF;IACzF,OAAO,CAAC,2BAA2B;IAWnC,OAAO,CAAC,kBAAkB;IA2DnB,YAAY,CAAC,QAAQ,EAAE,gBAAgB;CAcjD"}
+{"version":3,"file":"connectionStateHandler.d.ts","sourceRoot":"","sources":["../src/connectionStateHandler.ts"],"names":[],"mappings":"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"}

package/dist/connectionStateHandler.js

@@ -4,12 +4,106 @@
  * Licensed under the MIT License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConnectionStateHandler = void 0;
+exports.createConnectionStateHandlerCore = exports.createConnectionStateHandler = void 0;
 const common_utils_1 = require("@fluidframework/common-utils");
 const telemetry_utils_1 = require("@fluidframework/telemetry-utils");
 const connectionState_1 = require("./connectionState");
 const catchUpMonitor_1 = require("./catchUpMonitor");
 const JoinOpTimeoutMs = 45000;
+function createConnectionStateHandler(inputs, deltaManager, clientId) {
+    const mc = (0, telemetry_utils_1.loggerToMonitoringContext)(inputs.logger);
+    return createConnectionStateHandlerCore(mc.config.getBoolean("Fluid.Container.CatchUpBeforeDeclaringConnected") === true, inputs, deltaManager, clientId);
+}
+exports.createConnectionStateHandler = createConnectionStateHandler;
+function createConnectionStateHandlerCore(wait, inputs, deltaManager, clientId) {
+    if (!wait) {
+        return new ConnectionStateHandler(inputs, clientId);
+    }
+    return new ConnectionStateCatchup(inputs, (handler) => new ConnectionStateHandler(handler, clientId), deltaManager);
+}
+exports.createConnectionStateHandlerCore = createConnectionStateHandlerCore;
+/**
+ * Class that can be used as a base class for building IConnectionStateHandler adapters / pipeline.
+ * It implements both ends of communication interfaces and passes data back and forward
+ */
+class ConnectionStateHandlerPassThrough {
+    constructor(inputs, pimplFactory) {
+        this.inputs = inputs;
+        this.pimpl = pimplFactory(this);
+    }
+    /**
+     * IConnectionStateHandler
+     */
+    get connectionState() { return this.pimpl.connectionState; }
+    get pendingClientId() { return this.pimpl.pendingClientId; }
+    containerSaved() { return this.pimpl.containerSaved(); }
+    dispose() { return this.pimpl.dispose(); }
+    initProtocol(protocol) { return this.pimpl.initProtocol(protocol); }
+    receivedDisconnectEvent(reason) { return this.pimpl.receivedDisconnectEvent(reason); }
+    receivedConnectEvent(connectionMode, details) {
+        return this.pimpl.receivedConnectEvent(connectionMode, details);
+    }
+    /**
+     * IConnectionStateHandlerInputs
+     */
+    get logger() { return this.inputs.logger; }
+    connectionStateChanged(value, oldState, reason) {
+        return this.inputs.connectionStateChanged(value, oldState, reason);
+    }
+    shouldClientJoinWrite() { return this.inputs.shouldClientJoinWrite(); }
+    get maxClientLeaveWaitTime() { return this.inputs.maxClientLeaveWaitTime; }
+    logConnectionIssue(eventName, details) {
+        return this.inputs.logConnectionIssue(eventName, details);
+    }
+}
+/**
+ * Implementation of IConnectionStateHandler pass-through adapter that waits for specific sequence number
+ * before raising connected event
+ */
+class ConnectionStateCatchup extends ConnectionStateHandlerPassThrough {
+    constructor(inputs, pimplFactory, deltaManager) {
+        super(inputs, pimplFactory);
+        this.deltaManager = deltaManager;
+        this.transitionToConnectedState = () => {
+            // Defensive measure, we should always be in Connecting state when this is called.
+            const state = this.pimpl.connectionState;
+            (0, common_utils_1.assert)(state === connectionState_1.ConnectionState.Connected, 0x3e5 /* invariant broken */);
+            (0, common_utils_1.assert)(this._connectionState === connectionState_1.ConnectionState.CatchingUp, 0x3e6 /* invariant broken */);
+            this._connectionState = connectionState_1.ConnectionState.Connected;
+            this.inputs.connectionStateChanged(connectionState_1.ConnectionState.Connected, connectionState_1.ConnectionState.CatchingUp, "caught up");
+        };
+        this._connectionState = this.pimpl.connectionState;
+    }
+    get connectionState() {
+        return this._connectionState;
+    }
+    connectionStateChanged(value, oldState, reason) {
+        var _a;
+        switch (value) {
+            case connectionState_1.ConnectionState.Connected:
+                (0, common_utils_1.assert)(this._connectionState === connectionState_1.ConnectionState.CatchingUp, 0x3e1 /* connectivity transitions */);
+                // Create catch-up monitor here (not earlier), as we might get more exact info by now about how far
+                // client is behind through join signal. This is only true if base layer uses signals (i.e. audience,
+                // not quorum, including for "rea" connections) to make decisions about moving to "connected" state.
+                // In addition to that, in its current form, doing this in ConnectionState.CatchingUp is dangerous as
+                // we might get callback right away, and it will screw up state transition (as code outside of switch
+                // statement will overwrite current state).
+                (0, common_utils_1.assert)(this.catchUpMonitor === undefined, 0x3eb /* catchUpMonitor should be gone */);
+                this.catchUpMonitor = new catchUpMonitor_1.CatchUpMonitor(this.deltaManager, this.transitionToConnectedState);
+                return;
+            case connectionState_1.ConnectionState.Disconnected:
+                (_a = this.catchUpMonitor) === null || _a === void 0 ? void 0 : _a.dispose();
+                this.catchUpMonitor = undefined;
+                break;
+            case connectionState_1.ConnectionState.CatchingUp:
+                (0, common_utils_1.assert)(this._connectionState === connectionState_1.ConnectionState.Disconnected, 0x3e3 /* connectivity transitions */);
+                break;
+            default:
+        }
+        this._connectionState = value;
+        this.inputs.connectionStateChanged(value, oldState, reason);
+    }
+}
 /**
  * In the lifetime of a container, the connection will likely disconnect and reconnect periodically.
  * This class ensures that any ops sent by this container instance on previous connection are either
@@ -22,59 +116,49 @@ const JoinOpTimeoutMs = 45000;
  *
  * The job of this class is to encapsulate the transition period during reconnect, which is identified by
  * ConnectionState.CatchingUp. Specifically, before moving to Connected state with the new clientId, it ensures that:
- * (A) We process the Leave op for the previous clientId. This allows us to properly handle any acks from in-flight ops
- *     that got sequenced with the old clientId (we'll recognize them as local ops). After the Leave op, any other
- *     pending ops can safely be submitted with the new clientId without fear of duplication in the sequenced op stream.
- * (B) We process the Join op for the new clientId (identified when the underlying connection was first established),
- *     indicating the service is ready to sequence ops sent with the new clientId.
- * (C) We process all ops known at the time the underlying connection was established (so we are "caught up")
  *
- * For (A) we give up waiting after some time (same timeout as server uses), and go ahead and transition to Connected.
- * For (B) we log telemetry if it takes too long, but still only transition to Connected when the Join op is processed
+ * a. We process the Leave op for the previous clientId. This allows us to properly handle any acks from in-flight ops
+ * that got sequenced with the old clientId (we'll recognize them as local ops). After the Leave op, any other
+ * pending ops can safely be submitted with the new clientId without fear of duplication in the sequenced op stream.
+ *
+ * b. We process the Join op for the new clientId (identified when the underlying connection was first established),
+ * indicating the service is ready to sequence ops sent with the new clientId.
+ *
+ * c. We process all ops known at the time the underlying connection was established (so we are "caught up")
+ *
+ * For (a) we give up waiting after some time (same timeout as server uses), and go ahead and transition to Connected.
+ *
+ * For (b) we log telemetry if it takes too long, but still only transition to Connected when the Join op is processed
  * and we are added to the Quorum.
- * For (C) this is optional behavior, controlled by the parameters of receivedConnectEvent
+ *
+ * For (c) this is optional behavior, controlled by the parameters of receivedConnectEvent
  */
 class ConnectionStateHandler {
-    constructor(handler, logger, _clientId) {
+    constructor(handler, _clientId) {
         var _a;
         this.handler = handler;
-        this.logger = logger;
         this._clientId = _clientId;
         this._connectionState = connectionState_1.ConnectionState.Disconnected;
-        this.transitionToConnectedState = () => {
-            // Defensive measure, we should always be in CatchingUp state when this is called.
-            if (this._connectionState === connectionState_1.ConnectionState.CatchingUp) {
-                this.setConnectionState(connectionState_1.ConnectionState.Connected);
-            }
-            else {
-                this.logger.sendTelemetryEvent({
-                    eventName: "cannotTransitionToConnectedState",
-                    connectionState: connectionState_1.ConnectionState[this._connectionState],
-                });
-            }
-        };
         this.prevClientLeftTimer = new common_utils_1.Timer(
         // Default is 5 min for which we are going to wait for its own "leave" message. This is same as
         // the max time on server after which leave op is sent.
         (_a = this.handler.maxClientLeaveWaitTime) !== null && _a !== void 0 ? _a : 300000, () => {
-            (0, common_utils_1.assert)(!this.connected, 0x2ac /* "Connected when timeout waiting for leave from previous session fired!" */);
+            (0, common_utils_1.assert)(this.connectionState !== connectionState_1.ConnectionState.Connected, 0x2ac /* "Connected when timeout waiting for leave from previous session fired!" */);
             this.applyForConnectedState("timeout");
         });
         // Based on recent data, it looks like majority of cases where we get stuck are due to really slow or
         // timing out ops fetches. So attempt recovery infrequently. Also fetch uses 30 second timeout, so
         // if retrying fixes the problem, we should not see these events.
         this.joinOpTimer = new common_utils_1.Timer(JoinOpTimeoutMs, () => {
-            var _a;
             // I've observed timer firing within couple ms from disconnect event, looks like
             // queued timer callback is not cancelled if timer is cancelled while callback sits in the queue.
             if (this.connectionState !== connectionState_1.ConnectionState.CatchingUp) {
                 return;
             }
-            const quorumClients = this.handler.quorumClients();
             const details = {
-                quorumInitialized: quorumClients !== undefined,
+                protocolInitialized: this.protocol !== undefined,
                 pendingClientId: this.pendingClientId,
-                inQuorum: (quorumClients === null || quorumClients === void 0 ? void 0 : quorumClients.getMember((_a = this.pendingClientId) !== null && _a !== void 0 ? _a : "")) !== undefined,
+                clientJoined: this.hasMember(this.pendingClientId),
                 waitingForLeaveOp: this.waitingForLeaveOp,
             };
             this.handler.logConnectionIssue("NoJoinOp", details);
@@ -83,9 +167,6 @@ class ConnectionStateHandler {
     get connectionState() {
         return this._connectionState;
     }
-    get connected() {
-        return this.connectionState === connectionState_1.ConnectionState.Connected;
-    }
     get clientId() {
         return this._clientId;
     }
@@ -128,7 +209,7 @@ class ConnectionStateHandler {
             }
             // Start the event in case we are waiting for leave or timeout.
             if (this.waitingForLeaveOp) {
-                this.waitEvent = telemetry_utils_1.PerformanceEvent.start(this.logger, {
+                this.waitEvent = telemetry_utils_1.PerformanceEvent.start(this.handler.logger, {
                     eventName: "WaitBeforeClientLeave",
                     details: JSON.stringify({
                         waitOnClientId: this._clientId,
@@ -140,25 +221,21 @@ class ConnectionStateHandler {
         }
     }
     applyForConnectedState(source) {
-        var _a, _b;
-        const quorumClients = this.handler.quorumClients();
-        (0, common_utils_1.assert)(quorumClients !== undefined, 0x236 /* "In all cases it should be already installed" */);
-        (0, common_utils_1.assert)(this.waitingForLeaveOp === false ||
-            (this.clientId !== undefined && quorumClients.getMember(this.clientId) !== undefined), 0x2e2 /* "Must only wait for leave message when clientId in quorum" */);
+        var _a;
+        (0, common_utils_1.assert)(this.protocol !== undefined, 0x236 /* "In all cases it should be already installed" */);
+        (0, common_utils_1.assert)(!this.waitingForLeaveOp || this.hasMember(this.clientId), 0x2e2 /* "Must only wait for leave message when clientId in quorum" */);
         // Move to connected state only if we are in Connecting state, we have seen our join op
         // and there is no timer running which means we are not waiting for previous client to leave
         // or timeout has occurred while doing so.
         if (this.pendingClientId !== this.clientId
-            && this.pendingClientId !== undefined
-            && quorumClients.getMember(this.pendingClientId) !== undefined
+            && this.hasMember(this.pendingClientId)
             && !this.waitingForLeaveOp) {
             (_a = this.waitEvent) === null || _a === void 0 ? void 0 : _a.end({ source });
-            (0, common_utils_1.assert)(this.catchUpMonitor !== undefined, 0x37d /* catchUpMonitor should always be set if pendingClientId is set */);
-            this.catchUpMonitor.on("caughtUp", this.transitionToConnectedState);
+            this.setConnectionState(connectionState_1.ConnectionState.Connected);
         }
         else {
             // Adding this event temporarily so that we can get help debugging if something goes wrong.
-            this.logger.sendTelemetryEvent({
+            this.handler.logger.sendTelemetryEvent({
                 eventName: "connectedStateRejected",
                 category: source === "timeout" ? "error" : "generic",
                 details: JSON.stringify({
@@ -166,7 +243,7 @@ class ConnectionStateHandler {
                     pendingClientId: this.pendingClientId,
                     clientId: this.clientId,
                     waitingForLeaveOp: this.waitingForLeaveOp,
-                    inQuorum: (quorumClients === null || quorumClients === void 0 ? void 0 : quorumClients.getMember((_b = this.pendingClientId) !== null && _b !== void 0 ? _b : "")) !== undefined,
+                    clientJoined: this.hasMember(this.pendingClientId),
                 }),
             });
         }
@@ -190,18 +267,16 @@ class ConnectionStateHandler {
      * @param deltaManager - DeltaManager to be used for delaying Connected transition until caught up.
      * If it's undefined, then don't delay and transition to Connected as soon as Leave/Join op are accounted for
      */
-    receivedConnectEvent(connectionMode, details, deltaManager) {
-        var _a;
+    receivedConnectEvent(connectionMode, details) {
         const oldState = this._connectionState;
         this._connectionState = connectionState_1.ConnectionState.CatchingUp;
         const writeConnection = connectionMode === "write";
-        (0, common_utils_1.assert)(!this.handler.shouldClientJoinWrite() || writeConnection, 0x30a /* shouldClientJoinWrite should imply this is a writeConnection */);
-        (0, common_utils_1.assert)(!this.waitingForLeaveOp || writeConnection, 0x2a6 /* "waitingForLeaveOp should imply writeConnection (we need to be ready to flush pending ops)" */);
-        // Defensive measure in case catchUpMonitor from previous connection attempt wasn't already cleared
-        (_a = this.catchUpMonitor) === null || _a === void 0 ? void 0 : _a.dispose();
-        // Note that this may be undefined since the connection is established proactively on load
-        // and the quorum may still be under initialization.
-        const quorumClients = this.handler.quorumClients();
+        // The following checks are wrong. They are only valid if user has write access to a file.
+        // If user lost such access mid-session, user will not be able to get "write" connection.
+        // assert(!this.handler.shouldClientJoinWrite() || writeConnection,
+        //    0x30a /* shouldClientJoinWrite should imply this is a writeConnection */);
+        // assert(!this.waitingForLeaveOp || writeConnection,
+        //    0x2a6 /* "waitingForLeaveOp should imply writeConnection (we need to be ready to flush pending ops)" */);
         // Stash the clientID to detect when transitioning from connecting (socket.io channel open) to connected
         // (have received the join message for the client ID)
         // This is especially important in the reconnect case. It's possible there could be outstanding
@@ -209,18 +284,14 @@ class ConnectionStateHandler {
         // join message. after we see the join message for our new connection with our new client id,
         // we know there can no longer be outstanding ops that we sent with the previous client id.
         this._pendingClientId = details.clientId;
-        // We may want to catch up to known ops as of now before transitioning to Connected state
-        this.catchUpMonitor = deltaManager !== undefined
-            ? new catchUpMonitor_1.CatchUpMonitor(deltaManager)
-            : new catchUpMonitor_1.ImmediateCatchUpMonitor();
         // IMPORTANT: Report telemetry after we set _pendingClientId, but before transitioning to Connected state
-        this.handler.logConnectionStateChangeTelemetry(connectionState_1.ConnectionState.CatchingUp, oldState);
+        this.handler.connectionStateChanged(connectionState_1.ConnectionState.CatchingUp, oldState);
         // For write connections, this pending clientId could be in the quorum already (i.e. join op already processed).
         // We are fetching ops from storage in parallel to connecting to Relay Service,
         // and given async processes, it's possible that we have already processed our own join message before
         // connection was fully established.
-        // If quorumClients itself is undefined, we expect it will process the join op after it's initialized.
-        const waitingForJoinOp = writeConnection && (quorumClients === null || quorumClients === void 0 ? void 0 : quorumClients.getMember(this._pendingClientId)) === undefined;
+        // If protocol is not initialized yet, we expect it will process the join op after it's initialized.
+        const waitingForJoinOp = writeConnection && !this.hasMember(this._pendingClientId);
         if (waitingForJoinOp) {
             // Previous client left, and we are waiting for our own join op. When it is processed we'll join the quorum
             // and attempt to transition to Connected state via receivedAddMemberEvent.
@@ -228,33 +299,24 @@ class ConnectionStateHandler {
         }
         else if (!this.waitingForLeaveOp) {
             // We're not waiting for Join or Leave op (if read-only connection those don't even apply),
-            // but we do need to wait until we are caught up (to now-known ops) before transitioning to Connected state.
-            this.catchUpMonitor.on("caughtUp", this.transitionToConnectedState);
+            // go ahead and declare the state to be Connected!
+            // If we are waiting for Leave op still, do nothing for now, we will transition to Connected later.
+            this.setConnectionState(connectionState_1.ConnectionState.Connected);
         }
         // else - We are waiting for Leave op still, do nothing for now, we will transition to Connected later
     }
-    /** Clear all the state used during the Connecting phase (set in receivedConnectEvent) */
-    clearPendingConnectionState() {
-        var _a;
-        this._pendingClientId = undefined;
-        (_a = this.catchUpMonitor) === null || _a === void 0 ? void 0 : _a.dispose();
-        this.catchUpMonitor = undefined;
-        if (this.joinOpTimer.hasTimer) {
-            this.stopJoinOpTimer();
-        }
-    }
     setConnectionState(value, reason) {
+        var _a, _b;
         if (this.connectionState === value) {
             // Already in the desired state - exit early
-            this.logger.sendErrorEvent({ eventName: "setConnectionStateSame", value });
+            this.handler.logger.sendErrorEvent({ eventName: "setConnectionStateSame", value });
             return;
         }
         const oldState = this._connectionState;
         this._connectionState = value;
-        const quorumClients = this.handler.quorumClients();
         let client;
         if (this._clientId !== undefined) {
-            client = quorumClients === null || quorumClients === void 0 ? void 0 : quorumClients.getMember(this._clientId);
+            client = (_b = (_a = this.protocol) === null || _a === void 0 ? void 0 : _a.quorum) === null || _b === void 0 ? void 0 : _b.getMember(this._clientId);
         }
         if (value === connectionState_1.ConnectionState.Connected) {
             (0, common_utils_1.assert)(oldState === connectionState_1.ConnectionState.CatchingUp, 0x1d8 /* "Should only transition from Connecting state" */);
@@ -266,23 +328,26 @@ class ConnectionStateHandler {
         }
         else if (value === connectionState_1.ConnectionState.Disconnected) {
             // Clear pending state immediately to prepare for reconnect
-            this.clearPendingConnectionState();
-            // Only wait for "leave" message if the connected client exists in the quorum because only the write
-            // client will exist in the quorum and only for those clients we will receive "removeMember" event and
-            // the client has some unacked ops.
-            // Also server would not accept ops from read client. Also check if the timer is not already running as
+            this._pendingClientId = undefined;
+            if (this.joinOpTimer.hasTimer) {
+                this.stopJoinOpTimer();
+            }
+            // Only wait for "leave" message if the connected client exists in the quorum and had some non-acked ops
+            // Also check if the timer is not already running as
             // we could receive "Disconnected" event multiple times without getting connected and in that case we
             // don't want to reset the timer as we still want to wait on original client which started this timer.
             if (client !== undefined
                 && this.handler.shouldClientJoinWrite()
-                && this.prevClientLeftTimer.hasTimer === false) {
+                && !this.waitingForLeaveOp // same as !this.prevClientLeftTimer.hasTimer
+            ) {
                 this.prevClientLeftTimer.restart();
             }
             else {
                 // Adding this event temporarily so that we can get help debugging if something goes wrong.
-                this.logger.sendTelemetryEvent({
+                this.handler.logger.sendTelemetryEvent({
                     eventName: "noWaitOnDisconnected",
                     details: JSON.stringify({
+                        clientId: this._clientId,
                         inQuorum: client !== undefined,
                         waitingForLeaveOp: this.waitingForLeaveOp,
                         hadOutstandingOps: this.handler.shouldClientJoinWrite(),
@@ -291,22 +356,38 @@ class ConnectionStateHandler {
             }
         }
         // Report transition before we propagate event across layers
-        this.handler.logConnectionStateChangeTelemetry(this._connectionState, oldState, reason);
-        // Propagate event across layers
-        this.handler.connectionStateChanged();
+        this.handler.connectionStateChanged(this._connectionState, oldState, reason);
+    }
+    // Helper method to switch between quorum and audience.
+    // Old design was checking only quorum for "write" clients.
+    // Latest change checks audience for all types of connections.
+    get membership() {
+        var _a;
+        return (_a = this.protocol) === null || _a === void 0 ? void 0 : _a.quorum;
     }
     initProtocol(protocol) {
-        protocol.quorum.on("addMember", (clientId, _details) => {
+        var _a, _b;
+        this.protocol = protocol;
+        (_a = this.membership) === null || _a === void 0 ? void 0 : _a.on("addMember", (clientId) => {
             this.receivedAddMemberEvent(clientId);
         });
-        protocol.quorum.on("removeMember", (clientId) => {
+        (_b = this.membership) === null || _b === void 0 ? void 0 : _b.on("removeMember", (clientId) => {
             this.receivedRemoveMemberEvent(clientId);
         });
+        // Very unlikely race condition, but theoretically can happen - our new connection is already
+        // summarized and we are loading from such summary.
+        if (this.hasMember(this.pendingClientId)) {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            this.receivedAddMemberEvent(this.pendingClientId);
+        }
         // if we have a clientId from a previous container we need to wait for its leave message
-        if (this.clientId !== undefined && protocol.quorum.getMember(this.clientId) !== undefined) {
+        if (this.clientId !== undefined && this.hasMember(this.clientId)) {
             this.prevClientLeftTimer.restart();
         }
     }
+    hasMember(clientId) {
+        var _a;
+        return ((_a = this.membership) === null || _a === void 0 ? void 0 : _a.getMember(clientId !== null && clientId !== void 0 ? clientId : "")) !== undefined;
+    }
 }
-exports.ConnectionStateHandler = ConnectionStateHandler;
 //# sourceMappingURL=connectionStateHandler.js.map