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

package/lib/container.js

@@ -7,8 +7,8 @@ import merge from "lodash/merge";
 import { v4 as uuid } from "uuid";
 import { assert, performance, unreachableCase } from "@fluidframework/common-utils";
 import { AttachState, isFluidCodeDetails, } from "@fluidframework/container-definitions";
-import { DataCorruptionError, extractSafePropertiesFromMessage, GenericError, UsageError, } from "@fluidframework/container-utils";
-import { readAndParse, OnlineStatus, isOnline, ensureFluidResolvedUrl, combineAppAndProtocolSummary, runWithRetry, isFluidResolvedUrl, isRuntimeMessage, isUnpackedRuntimeMessage, } from "@fluidframework/driver-utils";
+import { GenericError, UsageError, } from "@fluidframework/container-utils";
+import { readAndParse, OnlineStatus, isOnline, ensureFluidResolvedUrl, combineAppAndProtocolSummary, runWithRetry, isFluidResolvedUrl, } from "@fluidframework/driver-utils";
 import { MessageType, SummaryType, } from "@fluidframework/protocol-definitions";
 import { ChildLogger, EventEmitterWithErrorHandling, PerformanceEvent, raiseConnectedEvent, TelemetryLogger, connectedEventName, disconnectedEventName, normalizeError, loggerToMonitoringContext, wrapError, } from "@fluidframework/telemetry-utils";
 import { Audience } from "./audience";
@@ -18,10 +18,8 @@ import { DeltaManager } from "./deltaManager";
 import { DeltaManagerProxy } from "./deltaManagerProxy";
 import { RelativeLoader } from "./loader";
 import { pkgVersion } from "./packageVersion";
-import { ConnectionStateHandler } from "./connectionStateHandler";
-import { RetriableDocumentStorageService } from "./retriableDocumentStorageService";
-import { ProtocolTreeStorageService } from "./protocolTreeDocumentStorageService";
-import { BlobOnlyStorage, ContainerStorageAdapter } from "./containerStorageAdapter";
+import { ContainerStorageAdapter } from "./containerStorageAdapter";
+import { createConnectionStateHandler, } from "./connectionStateHandler";
 import { getProtocolSnapshotTree, getSnapshotTreeFromSerializedContainer } from "./utils";
 import { initQuorumValuesFromCodeDetails, getCodeDetailsFromQuorumValues, QuorumProxy } from "./quorum";
 import { CollabWindowTracker } from "./collabWindowTracker";
@@ -32,14 +30,19 @@ 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.
  */
 export async function waitContainerToCatchUp(container) {
@@ -183,9 +186,19 @@ export class Container extends EventEmitterWithErrorHandling {
         this.mc = loggerToMonitoringContext(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({
-            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 = 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 */);
+                }
+            },
             shouldClientJoinWrite: () => this._deltaManager.connectionManager.shouldJoinWrite(),
             maxClientLeaveWaitTime: this.loader.services.options.maxClientLeaveWaitTime,
             logConnectionIssue: (eventName, details) => {
@@ -193,29 +206,13 @@ export class Container extends EventEmitterWithErrorHandling {
                 // its own join op. Attempt recovery option.
                 this._deltaManager.logConnectionIssue(Object.assign({ eventName, duration: performance.now() - this.connectionTransitionTimes[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(() => {
-            if (this.attachState !== AttachState.Attached) {
-                if (this.loader.services.detachedBlobStorage !== undefined) {
-                    return new 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(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" &&
@@ -336,7 +333,7 @@ export class Container extends 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";
         }
     }
@@ -344,13 +341,7 @@ export class Container extends 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) {
@@ -391,7 +382,7 @@ export class Container extends EventEmitterWithErrorHandling {
         return this.connectionStateHandler.connectionState;
     }
     get connected() {
-        return this.connectionStateHandler.connected;
+        return this.connectionStateHandler.connectionState === ConnectionState.Connected;
     }
     /**
      * Service configuration details. If running in offline mode will be undefined otherwise will contain service
@@ -405,7 +396,7 @@ export class Container extends 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.
@@ -467,7 +458,7 @@ export class Container extends EventEmitterWithErrorHandling {
         assert(this._lifecycleState === "closed", 0x314 /* Container properly closed */);
     }
     closeCore(error) {
-        var _a, _b, _c, _d;
+        var _a, _b, _c;
         assert(!this.closed, 0x315 /* re-entrancy */);
         try {
             // Ensure that we raise all key events even if one of these throws
@@ -482,11 +473,11 @@ export class Container extends 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);
@@ -573,7 +564,7 @@ export class Container extends EventEmitterWithErrorHandling {
                 const resolvedUrl = this.service.resolvedUrl;
                 ensureFluidResolvedUrl(resolvedUrl);
                 this._resolvedUrl = resolvedUrl;
-                await this.connectStorageService();
+                await this.storageService.connectToService(this.service);
                 if (hasAttachmentBlobs) {
                     // upload blobs to storage
                     assert(!!this.loader.services.detachedBlobStorage, 0x24e /* "assertion for type narrowing" */);
@@ -603,8 +594,6 @@ export class Container extends EventEmitterWithErrorHandling {
                 }
                 this._attachState = AttachState.Attached;
                 this.emit("attached");
-                // Propagate current connection state through the system.
-                this.propagateConnectionState();
                 if (!this.closed) {
                     this.resumeInternal({ fetchOpsFromStorage: false, reason: "createDetached" });
                 }
@@ -743,9 +732,7 @@ export class Container extends 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) {
@@ -768,11 +755,11 @@ export class Container extends 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 = AttachState.Attached;
         // Fetch specified snapshot.
@@ -807,12 +794,16 @@ export class Container extends 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, {
-            members: pendingLocalState.protocol.members,
-            proposals: pendingLocalState.protocol.proposals,
-            values: 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);
@@ -866,7 +857,7 @@ export class Container extends EventEmitterWithErrorHandling {
         await this.attachDeltaManagerOpHandler(attributes);
         // Need to just seed the source data in the code quorum. Quorum itself is empty
         const qValues = initQuorumValuesFromCodeDetails(source);
-        this._protocolHandler = await this.initializeProtocolState(attributes, {
+        this.initializeProtocolState(attributes, {
             members: [],
             proposals: [],
             values: qValues,
@@ -881,40 +872,22 @@ export class Container extends EventEmitterWithErrorHandling {
             delete detachedContainerSnapshot.tree[".hasAttachmentBlobs"];
         }
         const snapshotTree = 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 = getProtocolSnapshotTree(snapshotTree);
-        const qValues = await readAndParse(this._storage, baseTree.blobs.quorumValues);
+        const qValues = await readAndParse(this.storageService, baseTree.blobs.quorumValues);
         const codeDetails = getCodeDetailsFromQuorumValues(qValues);
-        this._protocolHandler =
-            await this.initializeProtocolState(attributes, {
-                members: [],
-                proposals: [],
-                values: codeDetails !== undefined ? initQuorumValuesFromCodeDetails(codeDetails) : [],
-            });
+        this.initializeProtocolState(attributes, {
+            members: [],
+            proposals: [],
+            values: codeDetails !== undefined ? initQuorumValuesFromCodeDetails(codeDetails) : [],
+        });
         await this.instantiateContextDetached(true, // existing
         snapshotTree);
         this.setLoaded();
     }
-    async connectStorageService() {
-        var _a, _b;
-        if (this._storageService !== undefined) {
-            return;
-        }
-        assert(this.service !== undefined, 0x1ef /* "services must be defined" */);
-        const storageService = await this.service.connectToStorage();
-        this._storageService =
-            new RetriableDocumentStorageService(storageService, this.mc.logger);
-        if (this.options.summarizeProtocolTree === true) {
-            this.mc.logger.sendTelemetryEvent({ eventName: "summarizeProtocolTreeEnabled" });
-            this._storageService =
-                new ProtocolTreeStorageService(this._storageService, () => this.captureProtocolSummary());
-        }
-        // ensure we did not lose that policy in the process of wrapping
-        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 {
@@ -948,13 +921,12 @@ export class Container extends EventEmitterWithErrorHandling {
                 readAndParse(storage, baseTree.blobs.quorumValues),
             ]);
         }
-        const protocolHandler = await this.initializeProtocolState(attributes, quorumSnapshot);
-        return protocolHandler;
+        this.initializeProtocolState(attributes, quorumSnapshot);
     }
-    async initializeProtocolState(attributes, quorumSnapshot) {
+    initializeProtocolState(attributes, quorumSnapshot) {
         var _a, _b;
         const protocolHandlerBuilder = (_a = this.protocolHandlerBuilder) !== null && _a !== void 0 ? _a : ((...args) => new ProtocolHandler(...args, new Audience()));
-        const protocol = protocolHandlerBuilder(attributes, quorumSnapshot, (key, value) => this.submitMessage(MessageType.Propose, { key, value }), (_b = this._initialClients) !== null && _b !== void 0 ? _b : []);
+        const protocol = protocolHandlerBuilder(attributes, quorumSnapshot, (key, value) => this.submitMessage(MessageType.Propose, JSON.stringify({ key, value })), (_b = this._initialClients) !== null && _b !== void 0 ? _b : []);
         this._initialClients = undefined;
         const protocolLogger = ChildLogger.create(this.subLogger, "ProtocolHandler");
         protocol.quorum.on("error", (error) => {
@@ -980,7 +952,11 @@ export class Container extends 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();
@@ -1064,10 +1040,7 @@ export class Container extends EventEmitterWithErrorHandling {
                     this._protocolHandler.audience.addMember(priorClient.clientId, priorClient.client);
                 }
             }
-            const deltaManagerForCatchingUp = this.mc.config.getBoolean("Fluid.Container.CatchUpBeforeDeclaringConnected") === true ?
-                this.deltaManager
-                : undefined;
-            this.connectionStateHandler.receivedConnectEvent(this.connectionMode, details, deltaManagerForCatchingUp);
+            this.connectionStateHandler.receivedConnectEvent(this.connectionMode, details);
         });
         deltaManager.on("disconnect", (reason) => {
             var _a;
@@ -1084,6 +1057,7 @@ export class Container extends EventEmitterWithErrorHandling {
             this.emit("warning", warn);
         });
         deltaManager.on("readonly", (readonly) => {
+            this.setContextConnectedState(this.connectionState === ConnectionState.Connected, readonly);
             this.emit("readonly", readonly);
         });
         deltaManager.on("closed", (error) => {
@@ -1126,12 +1100,7 @@ export class Container extends 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[value]}`, from: ConnectionState[oldState], duration,
             durationFromDisconnected,
@@ -1142,49 +1111,64 @@ export class Container extends 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.Connected &&
+            this.connectionState !== ConnectionState.Disconnected) {
+            return;
+        }
+        const state = this.connectionState === ConnectionState.Connected;
         const logOpsOnReconnect = this.connectionState === ConnectionState.Connected &&
             !this.firstConnection &&
             this.connectionMode === "write";
         if (logOpsOnReconnect) {
             this.messageCountAfterDisconnection = 0;
         }
-        const state = this.connectionState === 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);
         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 MessageType.Operation:
-            case MessageType.RemoteHelp:
-                break;
-            case 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 MessageType.Summarize:
+                return this.submitSummaryMessage(contents);
             default:
                 this.close(new 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(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(MessageType.Summarize, JSON.stringify(summary), false /* batch */);
     }
     submitMessage(type, contents, batch, metadata) {
         var _a;
@@ -1199,22 +1183,9 @@ export class Container extends 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(wrapError(error, (errorMessage) => new DataCorruptionError(errorMessage, extractSafePropertiesFromMessage(message))));
-        }
-        // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
-        if (isUnpackedRuntimeMessage(message) && !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 (isRuntimeMessage(message) || 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) {
@@ -1223,15 +1194,14 @@ export class Container extends EventEmitterWithErrorHandling {
                 // clients.
                 // All existing will continue to use settings they got earlier.
                 assert(this.serviceConfiguration !== undefined, 0x2e4 /* "there should be service config for active connection" */);
-                this.collabWindowTracker = new CollabWindowTracker((type, contents) => {
+                this.collabWindowTracker = new CollabWindowTracker((type) => {
                     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));
@@ -1278,7 +1248,7 @@ export class Container extends 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 RelativeLoader(this, this.loader);
-        this._context = await ContainerContext.createOrLoad(this, this.scope, this.codeLoader, codeDetails, snapshot, new DeltaManagerProxy(this._deltaManager), new 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.createOrLoad(this, this.scope, this.codeLoader, codeDetails, snapshot, new DeltaManagerProxy(this._deltaManager), new 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) {
@@ -1291,6 +1261,24 @@ export class Container extends 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);
+        }
+    }
 }
 Container.version = "^0.1.0";
 //# sourceMappingURL=container.js.map