@fluidframework/container-loader 1.3.0 → 2.0.0-dev.1.4.5.105745

package/dist/container.js

@@ -15,7 +15,6 @@ const common_utils_1 = require("@fluidframework/common-utils");
 const container_definitions_1 = require("@fluidframework/container-definitions");
 const container_utils_1 = require("@fluidframework/container-utils");
 const driver_utils_1 = require("@fluidframework/driver-utils");
-const protocol_base_1 = require("@fluidframework/protocol-base");
 const protocol_definitions_1 = require("@fluidframework/protocol-definitions");
 const telemetry_utils_1 = require("@fluidframework/telemetry-utils");
 const audience_1 = require("./audience");
@@ -25,27 +24,31 @@ const deltaManager_1 = require("./deltaManager");
 const deltaManagerProxy_1 = require("./deltaManagerProxy");
 const loader_1 = require("./loader");
 const packageVersion_1 = require("./packageVersion");
-const connectionStateHandler_1 = require("./connectionStateHandler");
-const retriableDocumentStorageService_1 = require("./retriableDocumentStorageService");
-const protocolTreeDocumentStorageService_1 = require("./protocolTreeDocumentStorageService");
 const containerStorageAdapter_1 = require("./containerStorageAdapter");
+const connectionStateHandler_1 = require("./connectionStateHandler");
 const utils_1 = require("./utils");
 const quorum_1 = require("./quorum");
 const collabWindowTracker_1 = require("./collabWindowTracker");
 const connectionManager_1 = require("./connectionManager");
 const connectionState_1 = require("./connectionState");
+const protocol_1 = require("./protocol");
 const detachedContainerRefSeqNumber = 0;
 const dirtyContainerEvent = "dirty";
 const savedContainerEvent = "saved";
 /**
- * Waits until container connects to delta storage and gets up-to-date
+ * Waits until container connects to delta storage and gets up-to-date.
+ *
  * Useful when resolving URIs and hitting 404, due to container being loaded from (stale) snapshot and not being
  * up to date. Host may chose to wait in such case and retry resolving URI.
+ *
  * Warning: Will wait infinitely for connection to establish if there is no connection.
  * May result in deadlock if Container.disconnect() is called and never followed by a call to Container.connect().
- * @returns true: container is up to date, it processed all the ops that were know at the time of first connection
- *          false: storage does not provide indication of how far the client is. Container processed
- *          all the ops known to it, but it maybe still behind.
+ *
+ * @returns `true`: container is up to date, it processed all the ops that were know at the time of first connection.
+ *
+ * `false`: storage does not provide indication of how far the client is. Container processed all the ops known to it,
+ * but it maybe still behind.
+ *
  * @throws an error beginning with `"Container closed"` if the container is closed before it catches up.
  */
 async function waitContainerToCatchUp(container) {
@@ -63,6 +66,10 @@ async function waitContainerToCatchUp(container) {
                 : new container_utils_1.GenericError(baseMessage));
         };
         container.on("closed", closedCallback);
+        // Depending on config, transition to "connected" state may include the guarantee
+        // that all known ops have been processed.  If so, we may introduce additional wait here.
+        // 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
                 || container.connectionState === connectionState_1.ConnectionState.Connected, 0x0cd /* "Container disconnected while waiting for ops!" */);
@@ -120,7 +127,7 @@ async function ReportIfTooLong(logger, eventName, action) {
 }
 const summarizerClientType = "summarizer";
 class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
-    constructor(loader, config) {
+    constructor(loader, config, protocolHandlerBuilder) {
         var _a, _b;
         super((name, error) => {
             this.mc.logger.sendErrorEvent({
@@ -129,6 +136,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             }, error);
         });
         this.loader = loader;
+        this.protocolHandlerBuilder = protocolHandlerBuilder;
         // Tells if container can reconnect on losing fist connection
         // If false, container gets closed on loss of connection.
         this._canReconnect = true;
@@ -142,7 +150,6 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         this.attachStarted = false;
         this._dirtyContainer = false;
         this.setAutoReconnectTime = common_utils_1.performance.now();
-        this._audience = new audience_1.Audience();
         this.clientDetailsOverride = config.clientDetailsOverride;
         this._resolvedUrl = config.resolvedUrl;
         if (config.canReconnect !== undefined) {
@@ -186,9 +193,19 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         this.mc = (0, telemetry_utils_1.loggerToMonitoringContext)(telemetry_utils_1.ChildLogger.create(this.subLogger, "Container"));
         const summarizeProtocolTree = (_a = this.mc.config.getBoolean("Fluid.Container.summarizeProtocolTree")) !== null && _a !== void 0 ? _a : this.loader.services.options.summarizeProtocolTree;
         this.options = Object.assign(Object.assign({}, this.loader.services.options), { summarizeProtocolTree });
-        this.connectionStateHandler = new connectionStateHandler_1.ConnectionStateHandler({
-            quorumClients: () => { var _a; return (_a = this._protocolHandler) === null || _a === void 0 ? void 0 : _a.quorum; },
-            logConnectionStateChangeTelemetry: (value, oldState, reason) => this.logConnectionStateChangeTelemetry(value, oldState, reason),
+        this._deltaManager = this.createDeltaManager();
+        this._clientId = (_b = config.serializedContainerState) === null || _b === void 0 ? void 0 : _b.clientId;
+        this.connectionStateHandler = (0, connectionStateHandler_1.createConnectionStateHandler)({
+            logger: this.mc.logger,
+            connectionStateChanged: (value, oldState, reason) => {
+                if (value === connectionState_1.ConnectionState.Connected) {
+                    this._clientId = this.connectionStateHandler.pendingClientId;
+                }
+                this.logConnectionStateChangeTelemetry(value, oldState, reason);
+                if (this._lifecycleState === "loaded") {
+                    this.propagateConnectionState(false /* initial transition */);
+                }
+            },
             shouldClientJoinWrite: () => this._deltaManager.connectionManager.shouldJoinWrite(),
             maxClientLeaveWaitTime: this.loader.services.options.maxClientLeaveWaitTime,
             logConnectionIssue: (eventName, details) => {
@@ -196,29 +213,13 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                 // its own join op. Attempt recovery option.
                 this._deltaManager.logConnectionIssue(Object.assign({ eventName, duration: common_utils_1.performance.now() - this.connectionTransitionTimes[connectionState_1.ConnectionState.CatchingUp] }, (details === undefined ? {} : { details: JSON.stringify(details) })));
             },
-            connectionStateChanged: () => {
-                // Fire events only if container is fully loaded and not closed
-                if (this._lifecycleState === "loaded") {
-                    this.propagateConnectionState();
-                }
-            },
-        }, this.mc.logger, (_b = config.serializedContainerState) === null || _b === void 0 ? void 0 : _b.clientId);
+        }, this.deltaManager, this._clientId);
         this.on(savedContainerEvent, () => {
             this.connectionStateHandler.containerSaved();
         });
-        this._deltaManager = this.createDeltaManager();
-        this._storage = new containerStorageAdapter_1.ContainerStorageAdapter(() => {
-            if (this.attachState !== container_definitions_1.AttachState.Attached) {
-                if (this.loader.services.detachedBlobStorage !== undefined) {
-                    return new containerStorageAdapter_1.BlobOnlyStorage(this.loader.services.detachedBlobStorage, this.mc.logger);
-                }
-                this.mc.logger.sendErrorEvent({
-                    eventName: "NoRealStorageInDetachedContainer",
-                });
-                throw new Error("Real storage calls not allowed in Unattached container");
-            }
-            return this.storageService;
-        });
+        this.storageService = new containerStorageAdapter_1.ContainerStorageAdapter(this.loader.services.detachedBlobStorage, this.mc.logger, this.options.summarizeProtocolTree === true
+            ? () => this.captureProtocolSummary()
+            : undefined);
         const isDomAvailable = typeof document === "object" &&
             document !== null &&
             typeof document.addEventListener === "function" &&
@@ -275,13 +276,13 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
     /**
      * Load an existing container.
      */
-    static async load(loader, loadOptions, pendingLocalState) {
+    static async load(loader, loadOptions, pendingLocalState, protocolHandlerBuilder) {
         const container = new Container(loader, {
             clientDetailsOverride: loadOptions.clientDetailsOverride,
             resolvedUrl: loadOptions.resolvedUrl,
             canReconnect: loadOptions.canReconnect,
             serializedContainerState: pendingLocalState,
-        });
+        }, protocolHandlerBuilder);
         return telemetry_utils_1.PerformanceEvent.timedExecAsync(container.mc.logger, { eventName: "Load" }, async (event) => new Promise((resolve, reject) => {
             var _a, _b;
             const version = loadOptions.version;
@@ -315,8 +316,8 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
     /**
      * Create a new container in a detached state.
      */
-    static async createDetached(loader, codeDetails) {
-        const container = new Container(loader, {});
+    static async createDetached(loader, codeDetails, protocolHandlerBuilder) {
+        const container = new Container(loader, {}, protocolHandlerBuilder);
         return telemetry_utils_1.PerformanceEvent.timedExecAsync(container.mc.logger, { eventName: "CreateDetached" }, async (_event) => {
             await container.createDetached(codeDetails);
             return container;
@@ -326,8 +327,8 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
      * Create a new container in a detached state that is initialized with a
      * snapshot from a previous detached container.
      */
-    static async rehydrateDetachedFromSnapshot(loader, snapshot) {
-        const container = new Container(loader, {});
+    static async rehydrateDetachedFromSnapshot(loader, snapshot, protocolHandlerBuilder) {
+        const container = new Container(loader, {}, protocolHandlerBuilder);
         return telemetry_utils_1.PerformanceEvent.timedExecAsync(container.mc.logger, { eventName: "RehydrateDetachedFromSnapshot" }, async (_event) => {
             const deserializedSummary = JSON.parse(snapshot);
             await container.rehydrateDetachedFromSnapshot(deserializedSummary);
@@ -339,7 +340,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         // Only transition states if currently loading
         if (this._lifecycleState === "loading") {
             // Propagate current connection state through the system.
-            this.propagateConnectionState();
+            this.propagateConnectionState(true /* initial transition */);
             this._lifecycleState = "loaded";
         }
     }
@@ -347,13 +348,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         return (this._lifecycleState === "closing" || this._lifecycleState === "closed");
     }
     get storage() {
-        return this._storage;
-    }
-    get storageService() {
-        if (this._storageService === undefined) {
-            throw new Error("Attempted to access storageService before it was defined");
-        }
-        return this._storageService;
+        return this.storageService;
     }
     get context() {
         if (this._context === undefined) {
@@ -394,7 +389,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         return this.connectionStateHandler.connectionState;
     }
     get connected() {
-        return this.connectionStateHandler.connected;
+        return this.connectionStateHandler.connectionState === connectionState_1.ConnectionState.Connected;
     }
     /**
      * Service configuration details. If running in offline mode will be undefined otherwise will contain service
@@ -408,7 +403,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
      * Set once this.connected is true, otherwise undefined
      */
     get clientId() {
-        return this.connectionStateHandler.clientId;
+        return this._clientId;
     }
     /**
      * The server provided claims of the client.
@@ -440,12 +435,12 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
      * Retrieves the audience associated with the document
      */
     get audience() {
-        return this._audience;
+        return this.protocolHandler.audience;
     }
     /**
      * Returns true if container is dirty.
      * Which means data loss if container is closed at that same moment
-     * Most likely that happens when there is no network connection to ordering service
+     * Most likely that happens when there is no network connection to Relay Service
      */
     get isDirty() {
         return this._dirtyContainer;
@@ -470,7 +465,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         (0, common_utils_1.assert)(this._lifecycleState === "closed", 0x314 /* Container properly closed */);
     }
     closeCore(error) {
-        var _a, _b, _c, _d;
+        var _a, _b, _c;
         (0, common_utils_1.assert)(!this.closed, 0x315 /* re-entrancy */);
         try {
             // Ensure that we raise all key events even if one of these throws
@@ -485,11 +480,11 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                 (_a = this._protocolHandler) === null || _a === void 0 ? void 0 : _a.close();
                 this.connectionStateHandler.dispose();
                 (_b = this._context) === null || _b === void 0 ? void 0 : _b.dispose(error !== undefined ? new Error(error.message) : undefined);
-                (_c = this._storageService) === null || _c === void 0 ? void 0 : _c.dispose();
+                this.storageService.dispose();
                 // Notify storage about critical errors. They may be due to disconnect between client & server knowledge
                 // about file, like file being overwritten in storage, but client having stale local cache.
                 // Driver need to ensure all caches are cleared on critical errors
-                (_d = this.service) === null || _d === void 0 ? void 0 : _d.dispose(error);
+                (_c = this.service) === null || _c === void 0 ? void 0 : _c.dispose(error);
             }
             catch (exception) {
                 this.mc.logger.sendErrorEvent({ eventName: "ContainerCloseException" }, exception);
@@ -511,7 +506,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         (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._protocolHandler, 0x2e3 /* "Must have a valid protocol handler instance" */);
-        (0, common_utils_1.assert)(this._protocolHandler.attributes.term !== undefined, 0x30b /* Must have a valid protocol handler instance */);
+        (0, common_utils_1.assert)(this._protocolHandler.attributes.term !== undefined, 0x37e /* Must have a valid protocol handler instance */);
         const pendingState = {
             pendingRuntimeState: this.context.getPendingLocalState(),
             url: this.resolvedUrl.url,
@@ -519,6 +514,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             term: this._protocolHandler.attributes.term,
             clientId: this.clientId,
         };
+        this.mc.logger.sendTelemetryEvent({ eventName: "CloseAndGetPendingLocalState" });
         this.close();
         return JSON.stringify(pendingState);
     }
@@ -575,7 +571,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                 const resolvedUrl = this.service.resolvedUrl;
                 (0, driver_utils_1.ensureFluidResolvedUrl)(resolvedUrl);
                 this._resolvedUrl = resolvedUrl;
-                await this.connectStorageService();
+                await this.storageService.connectToService(this.service);
                 if (hasAttachmentBlobs) {
                     // upload blobs to storage
                     (0, common_utils_1.assert)(!!this.loader.services.detachedBlobStorage, 0x24e /* "assertion for type narrowing" */);
@@ -605,8 +601,6 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                 }
                 this._attachState = container_definitions_1.AttachState.Attached;
                 this.emit("attached");
-                // Propagate current connection state through the system.
-                this.propagateConnectionState();
                 if (!this.closed) {
                     this.resumeInternal({ fetchOpsFromStorage: false, reason: "createDetached" });
                 }
@@ -745,9 +739,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
     /**
      * Load container.
      *
-     * @param specifiedVersion - one of the following
-     *   - undefined - fetch latest snapshot
-     *   - otherwise, version sha to load snapshot
+     * @param specifiedVersion - Version SHA to load snapshot. If not specified, will fetch the latest snapshot.
      */
     async load(specifiedVersion, loadMode, pendingLocalState) {
         if (this._resolvedUrl === undefined) {
@@ -770,11 +762,11 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             this.connectToDeltaStream(connectionArgs);
         }
         if (!pendingLocalState) {
-            await this.connectStorageService();
+            await this.storageService.connectToService(this.service);
         }
         else {
             // if we have pendingLocalState we can load without storage; don't wait for connection
-            this.connectStorageService().catch((error) => this.close(error));
+            this.storageService.connectToService(this.service).catch((error) => this.close(error));
         }
         this._attachState = container_definitions_1.AttachState.Attached;
         // Fetch specified snapshot.
@@ -809,9 +801,16 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         }
         // ...load in the existing quorum
         // Initialize the protocol handler
-        this._protocolHandler = pendingLocalState === undefined
-            ? await this.initializeProtocolStateFromSnapshot(attributes, this.storageService, snapshot)
-            : await this.initializeProtocolState(attributes, pendingLocalState.protocol.members, pendingLocalState.protocol.proposals, pendingLocalState.protocol.values);
+        if (pendingLocalState === undefined) {
+            await this.initializeProtocolStateFromSnapshot(attributes, this.storageService, snapshot);
+        }
+        else {
+            this.initializeProtocolState(attributes, {
+                members: pendingLocalState.protocol.members,
+                proposals: pendingLocalState.protocol.proposals,
+                values: pendingLocalState.protocol.values,
+            });
+        }
         const codeDetails = this.getCodeDetailsFromQuorum();
         await this.instantiateContext(true, // existing
         codeDetails, snapshot, pendingLocalState === null || pendingLocalState === void 0 ? void 0 : pendingLocalState.pendingRuntimeState);
@@ -865,9 +864,11 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         await this.attachDeltaManagerOpHandler(attributes);
         // Need to just seed the source data in the code quorum. Quorum itself is empty
         const qValues = (0, quorum_1.initQuorumValuesFromCodeDetails)(source);
-        this._protocolHandler = await this.initializeProtocolState(attributes, [], // members
-        [], // proposals
-        qValues);
+        this.initializeProtocolState(attributes, {
+            members: [],
+            proposals: [],
+            values: qValues,
+        });
         // The load context - given we seeded the quorum - will be great
         await this.instantiateContextDetached(false);
         this.setLoaded();
@@ -878,38 +879,22 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             delete detachedContainerSnapshot.tree[".hasAttachmentBlobs"];
         }
         const snapshotTree = (0, utils_1.getSnapshotTreeFromSerializedContainer)(detachedContainerSnapshot);
-        this._storage.loadSnapshotForRehydratingContainer(snapshotTree);
-        const attributes = await this.getDocumentAttributes(this._storage, snapshotTree);
+        this.storageService.loadSnapshotForRehydratingContainer(snapshotTree);
+        const attributes = await this.getDocumentAttributes(this.storageService, snapshotTree);
         await this.attachDeltaManagerOpHandler(attributes);
         // Initialize the protocol handler
         const baseTree = (0, utils_1.getProtocolSnapshotTree)(snapshotTree);
-        const qValues = await (0, driver_utils_1.readAndParse)(this._storage, baseTree.blobs.quorumValues);
+        const qValues = await (0, driver_utils_1.readAndParse)(this.storageService, baseTree.blobs.quorumValues);
         const codeDetails = (0, quorum_1.getCodeDetailsFromQuorumValues)(qValues);
-        this._protocolHandler =
-            await this.initializeProtocolState(attributes, [], // members
-            [], // proposals
-            codeDetails !== undefined ? (0, quorum_1.initQuorumValuesFromCodeDetails)(codeDetails) : []);
+        this.initializeProtocolState(attributes, {
+            members: [],
+            proposals: [],
+            values: codeDetails !== undefined ? (0, quorum_1.initQuorumValuesFromCodeDetails)(codeDetails) : [],
+        });
         await this.instantiateContextDetached(true, // existing
         snapshotTree);
         this.setLoaded();
     }
-    async connectStorageService() {
-        var _a, _b;
-        if (this._storageService !== undefined) {
-            return;
-        }
-        (0, common_utils_1.assert)(this.service !== undefined, 0x1ef /* "services must be defined" */);
-        const storageService = await this.service.connectToStorage();
-        this._storageService =
-            new retriableDocumentStorageService_1.RetriableDocumentStorageService(storageService, this.mc.logger);
-        if (this.options.summarizeProtocolTree === true) {
-            this.mc.logger.sendTelemetryEvent({ eventName: "summarizeProtocolTreeEnabled" });
-            this._storageService =
-                new protocolTreeDocumentStorageService_1.ProtocolTreeStorageService(this._storageService, () => this.captureProtocolSummary());
-        }
-        // ensure we did not lose that policy in the process of wrapping
-        (0, common_utils_1.assert)(((_a = storageService.policies) === null || _a === void 0 ? void 0 : _a.minBlobSize) === ((_b = this.storageService.policies) === null || _b === void 0 ? void 0 : _b.minBlobSize), 0x0e0 /* "lost minBlobSize policy" */);
-    }
     async getDocumentAttributes(storage, tree) {
         if (tree === undefined) {
             return {
@@ -930,22 +915,26 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         return attributes;
     }
     async initializeProtocolStateFromSnapshot(attributes, storage, snapshot) {
-        let members = [];
-        let proposals = [];
-        let values = [];
+        const quorumSnapshot = {
+            members: [],
+            proposals: [],
+            values: [],
+        };
         if (snapshot !== undefined) {
             const baseTree = (0, utils_1.getProtocolSnapshotTree)(snapshot);
-            [members, proposals, values] = await Promise.all([
+            [quorumSnapshot.members, quorumSnapshot.proposals, quorumSnapshot.values] = await Promise.all([
                 (0, driver_utils_1.readAndParse)(storage, baseTree.blobs.quorumMembers),
                 (0, driver_utils_1.readAndParse)(storage, baseTree.blobs.quorumProposals),
                 (0, driver_utils_1.readAndParse)(storage, baseTree.blobs.quorumValues),
             ]);
         }
-        const protocolHandler = await this.initializeProtocolState(attributes, members, proposals, values);
-        return protocolHandler;
+        this.initializeProtocolState(attributes, quorumSnapshot);
     }
-    async initializeProtocolState(attributes, members, proposals, values) {
-        const protocol = new protocol_base_1.ProtocolOpHandlerWithClientValidation(attributes.minimumSequenceNumber, attributes.sequenceNumber, attributes.term, members, proposals, values, (key, value) => this.submitMessage(protocol_definitions_1.MessageType.Propose, { key, value }));
+    initializeProtocolState(attributes, quorumSnapshot) {
+        var _a, _b;
+        const protocolHandlerBuilder = (_a = this.protocolHandlerBuilder) !== null && _a !== void 0 ? _a : ((...args) => new protocol_1.ProtocolHandler(...args, new audience_1.Audience()));
+        const protocol = protocolHandlerBuilder(attributes, quorumSnapshot, (key, value) => this.submitMessage(protocol_definitions_1.MessageType.Propose, JSON.stringify({ key, value })), (_b = this._initialClients) !== null && _b !== void 0 ? _b : []);
+        this._initialClients = undefined;
         const protocolLogger = telemetry_utils_1.ChildLogger.create(this.subLogger, "ProtocolHandler");
         protocol.quorum.on("error", (error) => {
             protocolLogger.sendErrorEvent(error);
@@ -970,7 +959,11 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                 });
             }
         });
-        return protocol;
+        // we need to make sure this member get set in a synchronous context,
+        // or other things can happen after the object that will be set is created, but not yet set
+        // this was breaking this._initialClients handling
+        //
+        this._protocolHandler = protocol;
     }
     captureProtocolSummary() {
         const quorumSnapshot = this.protocolHandler.snapshot();
@@ -1039,12 +1032,20 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         deltaManager.inbound.pause();
         // eslint-disable-next-line @typescript-eslint/no-floating-promises
         deltaManager.inboundSignal.pause();
-        deltaManager.on("connect", (details, opsBehind) => {
+        deltaManager.on("connect", (details, _opsBehind) => {
             var _a;
-            // Back-compat for new client and old server.
-            this._audience.clear();
-            for (const priorClient of (_a = details.initialClients) !== null && _a !== void 0 ? _a : []) {
-                this._audience.addMember(priorClient.clientId, priorClient.client);
+            if (this._protocolHandler === undefined) {
+                // Store the initial clients so that they can be submitted to the
+                // protocol handler when it is created.
+                this._initialClients = details.initialClients;
+            }
+            else {
+                // When reconnecting, the protocol handler is already created,
+                // so we can update the audience right now.
+                this._protocolHandler.audience.clear();
+                for (const priorClient of (_a = details.initialClients) !== null && _a !== void 0 ? _a : []) {
+                    this._protocolHandler.audience.addMember(priorClient.clientId, priorClient.client);
+                }
             }
             this.connectionStateHandler.receivedConnectEvent(this.connectionMode, details);
         });
@@ -1063,6 +1064,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             this.emit("warning", warn);
         });
         deltaManager.on("readonly", (readonly) => {
+            this.setContextConnectedState(this.connectionState === connectionState_1.ConnectionState.Connected, readonly);
             this.emit("readonly", readonly);
         });
         deltaManager.on("closed", (error) => {
@@ -1105,12 +1107,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                     opsBehind = checkpointSequenceNumber - this.deltaManager.lastSequenceNumber;
                 }
             }
-            if (this.firstConnection) {
-                connectionInitiationReason = "InitialConnect";
-            }
-            else {
-                connectionInitiationReason = "AutoReconnect";
-            }
+            connectionInitiationReason = this.firstConnection ? "InitialConnect" : "AutoReconnect";
         }
         this.mc.logger.sendPerformanceEvent(Object.assign({ eventName: `ConnectionStateChange_${connectionState_1.ConnectionState[value]}`, from: connectionState_1.ConnectionState[oldState], duration,
             durationFromDisconnected,
@@ -1121,49 +1118,64 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             this.firstConnection = false;
         }
     }
-    propagateConnectionState() {
+    propagateConnectionState(initialTransition) {
         var _a;
+        // When container loaded, we want to propagate initial connection state.
+        // After that, 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_1.ConnectionState.Connected &&
+            this.connectionState !== connectionState_1.ConnectionState.Disconnected) {
+            return;
+        }
+        const state = this.connectionState === connectionState_1.ConnectionState.Connected;
         const logOpsOnReconnect = this.connectionState === connectionState_1.ConnectionState.Connected &&
             !this.firstConnection &&
             this.connectionMode === "write";
         if (logOpsOnReconnect) {
             this.messageCountAfterDisconnection = 0;
         }
-        const state = this.connectionState === connectionState_1.ConnectionState.Connected;
         // Both protocol and context should not be undefined if we got so far.
-        if (((_a = this._context) === null || _a === void 0 ? void 0 : _a.disposed) === false) {
-            this.context.setConnectionState(state, this.clientId);
-        }
+        this.setContextConnectedState(state, (_a = this._deltaManager.connectionManager.readOnlyInfo.readonly) !== null && _a !== void 0 ? _a : false);
         this.protocolHandler.setConnectionState(state, this.clientId);
         (0, telemetry_utils_1.raiseConnectedEvent)(this.mc.logger, this, state, this.clientId);
         if (logOpsOnReconnect) {
             this.mc.logger.sendTelemetryEvent({ eventName: "OpsSentOnReconnect", count: this.messageCountAfterDisconnection });
         }
     }
+    // back-compat: ADO #1385: Remove in the future, summary op should come through submitSummaryMessage()
     submitContainerMessage(type, contents, batch, metadata) {
-        const outboundMessageType = type;
-        switch (outboundMessageType) {
+        switch (type) {
             case protocol_definitions_1.MessageType.Operation:
-            case protocol_definitions_1.MessageType.RemoteHelp:
-                break;
-            case protocol_definitions_1.MessageType.Summarize: {
-                // github #6451: this is only needed for staging so the server
-                // know when the protocol tree is included
-                // this can be removed once all clients send
-                // protocol tree by default
-                const summary = contents;
-                if (summary.details === undefined) {
-                    summary.details = {};
-                }
-                summary.details.includesProtocolTree =
-                    this.options.summarizeProtocolTree === true;
-                break;
-            }
+                return this.submitMessage(type, JSON.stringify(contents), batch, metadata);
+            case protocol_definitions_1.MessageType.Summarize:
+                return this.submitSummaryMessage(contents);
             default:
                 this.close(new container_utils_1.GenericError("invalidContainerSubmitOpType", undefined /* error */, { messageType: type }));
                 return -1;
         }
-        return this.submitMessage(type, contents, batch, metadata);
+    }
+    /** @returns clientSequenceNumber of last message in a batch */
+    submitBatch(batch) {
+        let clientSequenceNumber = -1;
+        for (const message of batch) {
+            clientSequenceNumber = this.submitMessage(protocol_definitions_1.MessageType.Operation, message.contents, true, // batch
+            message.metadata);
+        }
+        this._deltaManager.flush();
+        return clientSequenceNumber;
+    }
+    submitSummaryMessage(summary) {
+        // github #6451: this is only needed for staging so the server
+        // know when the protocol tree is included
+        // this can be removed once all clients send
+        // protocol tree by default
+        if (summary.details === undefined) {
+            summary.details = {};
+        }
+        summary.details.includesProtocolTree =
+            this.options.summarizeProtocolTree === true;
+        return this.submitMessage(protocol_definitions_1.MessageType.Summarize, JSON.stringify(summary), false /* batch */);
     }
     submitMessage(type, contents, batch, metadata) {
         var _a;
@@ -1178,22 +1190,9 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
     processRemoteMessage(message) {
         const local = this.clientId === message.clientId;
         // Allow the protocol handler to process the message
-        let result = { immediateNoOp: false };
-        try {
-            result = this.protocolHandler.processMessage(message, local);
-        }
-        catch (error) {
-            this.close((0, telemetry_utils_1.wrapError)(error, (errorMessage) => new container_utils_1.DataCorruptionError(errorMessage, (0, container_utils_1.extractSafePropertiesFromMessage)(message))));
-        }
-        // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
-        if ((0, driver_utils_1.isUnpackedRuntimeMessage)(message) && !(0, driver_utils_1.isRuntimeMessage)(message)) {
-            this.mc.logger.sendTelemetryEvent({ eventName: "UnpackedRuntimeMessage", type: message.type });
-        }
-        // Forward non system messages to the loaded runtime for processing
-        // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
-        if ((0, driver_utils_1.isRuntimeMessage)(message) || (0, driver_utils_1.isUnpackedRuntimeMessage)(message)) {
-            this.context.process(message, local, undefined);
-        }
+        const result = this.protocolHandler.processMessage(message, local);
+        // Forward messages to the loaded runtime for processing
+        this.context.process(message, local, undefined);
         // Inactive (not in quorum or not writers) clients don't take part in the minimum sequence number calculation.
         if (this.activeConnection()) {
             if (this.collabWindowTracker === undefined) {
@@ -1202,15 +1201,14 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                 // clients.
                 // All existing will continue to use settings they got earlier.
                 (0, common_utils_1.assert)(this.serviceConfiguration !== undefined, 0x2e4 /* "there should be service config for active connection" */);
-                this.collabWindowTracker = new collabWindowTracker_1.CollabWindowTracker((type, contents) => {
+                this.collabWindowTracker = new collabWindowTracker_1.CollabWindowTracker((type) => {
                     (0, common_utils_1.assert)(this.activeConnection(), 0x241 /* "disconnect should result in stopSequenceNumberUpdate() call" */);
-                    this.submitMessage(type, contents);
+                    this.submitMessage(type);
                 }, this.serviceConfiguration.noopTimeFrequency, this.serviceConfiguration.noopCountFrequency);
             }
             this.collabWindowTracker.scheduleSequenceNumberUpdate(message, result.immediateNoOp === true);
         }
         this.emit("op", message);
-        return result;
     }
     submitSignal(message) {
         this._deltaManager.submitSignal(JSON.stringify(message));
@@ -1218,15 +1216,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
     processSignal(message) {
         // No clientId indicates a system signal message.
         if (message.clientId === null) {
-            const innerContent = message.content;
-            if (innerContent.type === protocol_definitions_1.MessageType.ClientJoin) {
-                const newClient = innerContent.content;
-                this._audience.addMember(newClient.clientId, newClient.client);
-            }
-            else if (innerContent.type === protocol_definitions_1.MessageType.ClientLeave) {
-                const leftClientId = innerContent.content;
-                this._audience.removeMember(leftClientId);
-            }
+            this.protocolHandler.processSignal(message);
         }
         else {
             const local = this.clientId === message.clientId;
@@ -1265,7 +1255,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         // The relative loader will proxy requests to '/' to the loader itself assuming no non-cache flags
         // are set. Global requests will still go directly to the loader
         const loader = new loader_1.RelativeLoader(this, this.loader);
-        this._context = await containerContext_1.ContainerContext.createOrLoad(this, this.scope, this.codeLoader, codeDetails, snapshot, new deltaManagerProxy_1.DeltaManagerProxy(this._deltaManager), new quorum_1.QuorumProxy(this.protocolHandler.quorum), loader, (type, contents, batch, metadata) => this.submitContainerMessage(type, contents, batch, metadata), (message) => this.submitSignal(message), (error) => this.close(error), Container.version, (dirty) => this.updateDirtyContainerState(dirty), existing, pendingLocalState);
+        this._context = await containerContext_1.ContainerContext.createOrLoad(this, this.scope, this.codeLoader, codeDetails, snapshot, new deltaManagerProxy_1.DeltaManagerProxy(this._deltaManager), new quorum_1.QuorumProxy(this.protocolHandler.quorum), loader, (type, contents, batch, metadata) => this.submitContainerMessage(type, contents, batch, metadata), (summaryOp) => this.submitSummaryMessage(summaryOp), (batch) => this.submitBatch(batch), (message) => this.submitSignal(message), (error) => this.close(error), Container.version, (dirty) => this.updateDirtyContainerState(dirty), existing, pendingLocalState);
         this.emit("contextChanged", codeDetails);
     }
     updateDirtyContainerState(dirty) {
@@ -1278,6 +1268,24 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
     logContainerError(warning) {
         this.mc.logger.sendErrorEvent({ eventName: "ContainerWarning" }, warning);
     }
+    /**
+     * 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 readonly - Is the container in readonly mode?
+     */
+    setContextConnectedState(state, readonly) {
+        var _a;
+        if (((_a = this._context) === null || _a === void 0 ? void 0 : _a.disposed) === false) {
+            /**
+             * 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.context.setConnectionState(state && !readonly, this.clientId);
+        }
+    }
 }
 exports.Container = Container;
 Container.version = "^0.1.0";