@fluidframework/container-loader 0.59.4001 → 1.1.0-75972

package/lib/container.js

@@ -9,7 +9,7 @@ import { assert, performance, unreachableCase } from "@fluidframework/common-uti
 import { AttachState, isFluidCodeDetails, } from "@fluidframework/container-definitions";
 import { DataCorruptionError, extractSafePropertiesFromMessage, GenericError, UsageError, } from "@fluidframework/container-utils";
 import { readAndParse, OnlineStatus, isOnline, ensureFluidResolvedUrl, combineAppAndProtocolSummary, runWithRetry, isFluidResolvedUrl, } from "@fluidframework/driver-utils";
-import { isSystemMessage, ProtocolOpHandler, } from "@fluidframework/protocol-base";
+import { isSystemMessage, ProtocolOpHandlerWithClientValidation, } from "@fluidframework/protocol-base";
 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";
@@ -36,7 +36,7 @@ const savedContainerEvent = "saved";
  * 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.setAutoReconnect(false) is called and never switched back to auto-reconnect.
+ * 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.
@@ -58,7 +58,8 @@ export async function waitContainerToCatchUp(container) {
         };
         container.on("closed", closedCallback);
         const waitForOps = () => {
-            assert(container.connectionState !== ConnectionState.Disconnected, 0x0cd /* "Container disconnected while waiting for ops!" */);
+            assert(container.connectionState === ConnectionState.CatchingUp
+                || container.connectionState === ConnectionState.Connected, 0x0cd /* "Container disconnected while waiting for ops!" */);
             const hasCheckpointSequenceNumber = deltaManager.hasCheckpointSequenceNumber;
             const connectionOpSeqNumber = deltaManager.lastKnownSeqNumber;
             assert(deltaManager.lastSequenceNumber <= connectionOpSeqNumber, 0x266 /* "lastKnownSeqNumber should never be below last processed sequence number" */);
@@ -89,9 +90,7 @@ export async function waitContainerToCatchUp(container) {
             waitForOps();
         };
         container.on(connectedEventName, callback);
-        // TODO: Remove null check after next release #8523
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        container.resume();
+        container.connect();
     });
 }
 const getCodeProposal = 
@@ -100,7 +99,7 @@ const getCodeProposal =
 const summarizerClientType = "summarizer";
 export class Container extends EventEmitterWithErrorHandling {
     constructor(loader, config) {
-        var _a;
+        var _a, _b;
         super((name, error) => {
             this.mc.logger.sendErrorEvent({
                 eventName: "ContainerEventHandlerException",
@@ -111,7 +110,7 @@ export class Container extends EventEmitterWithErrorHandling {
         // Tells if container can reconnect on losing fist connection
         // If false, container gets closed on loss of connection.
         this._canReconnect = true;
-        this._lifecycleState = "created";
+        this._lifecycleState = "loading";
         this._attachState = AttachState.Detached;
         this.resumedOpProcessingAfterLoad = false;
         this.firstConnection = true;
@@ -167,20 +166,18 @@ export class Container extends EventEmitterWithErrorHandling {
             logConnectionStateChangeTelemetry: (value, oldState, reason) => this.logConnectionStateChangeTelemetry(value, oldState, reason),
             shouldClientJoinWrite: () => this._deltaManager.connectionManager.shouldJoinWrite(),
             maxClientLeaveWaitTime: this.loader.services.options.maxClientLeaveWaitTime,
-            logConnectionIssue: (eventName) => {
+            logConnectionIssue: (eventName, details) => {
                 // We get here when socket does not receive any ops on "write" connection, including
                 // its own join op. Attempt recovery option.
-                this._deltaManager.logConnectionIssue({
-                    eventName,
-                    duration: performance.now() - this.connectionTransitionTimes[ConnectionState.Connecting],
-                });
+                this._deltaManager.logConnectionIssue(Object.assign({ eventName, duration: performance.now() - this.connectionTransitionTimes[ConnectionState.CatchingUp] }, (details === undefined ? {} : { details: JSON.stringify(details) })));
             },
             connectionStateChanged: () => {
-                if (this.loaded) {
+                // Fire events only if container is fully loaded and not closed
+                if (this._lifecycleState === "loaded") {
                     this.propagateConnectionState();
                 }
             },
-        }, this.mc.logger);
+        }, this.mc.logger, (_b = config.serializedContainerState) === null || _b === void 0 ? void 0 : _b.clientId);
         this.on(savedContainerEvent, () => {
             this.connectionStateHandler.containerSaved();
         });
@@ -258,16 +255,16 @@ export class Container extends EventEmitterWithErrorHandling {
             clientDetailsOverride: loadOptions.clientDetailsOverride,
             resolvedUrl: loadOptions.resolvedUrl,
             canReconnect: loadOptions.canReconnect,
+            serializedContainerState: pendingLocalState,
         });
         return PerformanceEvent.timedExecAsync(container.mc.logger, { eventName: "Load" }, async (event) => new Promise((resolve, reject) => {
-            var _a;
-            container._lifecycleState = "loading";
+            var _a, _b;
             const version = loadOptions.version;
-            // always load unpaused with pending ops!
-            // It is also default mode in general.
             const defaultMode = { opsBeforeReturn: "cached" };
-            assert(pendingLocalState === undefined || loadOptions.loadMode === undefined, 0x1e1 /* "pending state requires immediate connection!" */);
-            const mode = (_a = loadOptions.loadMode) !== null && _a !== void 0 ? _a : defaultMode;
+            // if we have pendingLocalState, anything we cached is not useful and we shouldn't wait for connection
+            // to return container, so ignore this value and use undefined for opsBeforeReturn
+            const mode = pendingLocalState
+                ? Object.assign(Object.assign({}, ((_a = loadOptions.loadMode) !== null && _a !== void 0 ? _a : defaultMode)), { opsBeforeReturn: undefined }) : (_b = loadOptions.loadMode) !== null && _b !== void 0 ? _b : defaultMode;
             const onClosed = (err) => {
                 // pre-0.58 error message: containerClosedWithoutErrorDuringLoad
                 reject(err !== null && err !== void 0 ? err : new GenericError("Container closed without error during load"));
@@ -296,7 +293,6 @@ export class Container extends EventEmitterWithErrorHandling {
     static async createDetached(loader, codeDetails) {
         const container = new Container(loader, {});
         return PerformanceEvent.timedExecAsync(container.mc.logger, { eventName: "CreateDetached" }, async (_event) => {
-            container._lifecycleState = "loading";
             await container.createDetached(codeDetails);
             return container;
         }, { start: true, end: true, cancel: "generic" });
@@ -309,20 +305,16 @@ export class Container extends EventEmitterWithErrorHandling {
         const container = new Container(loader, {});
         return PerformanceEvent.timedExecAsync(container.mc.logger, { eventName: "RehydrateDetachedFromSnapshot" }, async (_event) => {
             const deserializedSummary = JSON.parse(snapshot);
-            container._lifecycleState = "loading";
             await container.rehydrateDetachedFromSnapshot(deserializedSummary);
             return container;
         }, { start: true, end: true, cancel: "generic" });
     }
-    get loaded() {
-        return (this._lifecycleState !== "created" && this._lifecycleState !== "loading");
-    }
-    set loaded(t) {
-        assert(t, 0x27d /* "Setting loaded state to false is not supported" */);
-        assert(this._lifecycleState !== "created", 0x27e /* "Must go through loading state before loaded" */);
+    setLoaded() {
         // It's conceivable the container could be closed when this is called
         // Only transition states if currently loading
         if (this._lifecycleState === "loading") {
+            // Propagate current connection state through the system.
+            this.propagateConnectionState();
             this._lifecycleState = "loaded";
         }
     }
@@ -444,19 +436,30 @@ export class Container extends EventEmitterWithErrorHandling {
         return this.protocolHandler.quorum;
     }
     close(error) {
+        // 1. Ensure that close sequence is exactly the same no matter if it's initiated by host or by DeltaManager
+        // 2. We need to ensure that we deliver disconnect event to runtime properly. See connectionStateChanged
+        //    handler. We only deliver events if container fully loaded. Transitioning from "loading" ->
+        //    "closing" will lose that info (can also solve by tracking extra state).
+        this._deltaManager.close(error);
+        assert(this.connectionState === ConnectionState.Disconnected, 0x0cf /* "disconnect event was not raised!" */);
+        assert(this._lifecycleState === "closed", 0x314 /* Container properly closed */);
+    }
+    closeCore(error) {
         var _a, _b, _c, _d;
-        if (this.closed) {
-            return;
-        }
+        assert(!this.closed, 0x315 /* re-entrancy */);
         try {
-            this._lifecycleState = "closing";
             // Ensure that we raise all key events even if one of these throws
             try {
-                this._deltaManager.close(error);
+                // Raise event first, to ensure we capture _lifecycleState before transition.
+                // This gives us a chance to know what errors happened on open vs. on fully loaded container.
+                this.mc.logger.sendTelemetryEvent({
+                    eventName: "ContainerClose",
+                    category: error === undefined ? "generic" : "error",
+                }, error);
+                this._lifecycleState = "closing";
                 (_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);
-                assert(this.connectionState === ConnectionState.Disconnected, 0x0cf /* "disconnect event was not raised!" */);
                 (_c = this._storageService) === null || _c === void 0 ? void 0 : _c.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.
@@ -466,10 +469,6 @@ export class Container extends EventEmitterWithErrorHandling {
             catch (exception) {
                 this.mc.logger.sendErrorEvent({ eventName: "ContainerCloseException" }, exception);
             }
-            this.mc.logger.sendTelemetryEvent({
-                eventName: "ContainerClose",
-                category: error === undefined ? "generic" : "error",
-            }, error);
             this.emit("closed", error);
             this.removeAllListeners();
             if (this.visibilityEventHandler !== undefined) {
@@ -486,9 +485,14 @@ export class Container extends EventEmitterWithErrorHandling {
         // a new clientId and a future container using stale pending state without the new clientId would resubmit them
         assert(this.attachState === AttachState.Attached, 0x0d1 /* "Container should be attached before close" */);
         assert(this.resolvedUrl !== undefined && this.resolvedUrl.type === "fluid", 0x0d2 /* "resolved url should be valid Fluid url" */);
+        assert(!!this._protocolHandler, 0x2e3 /* "Must have a valid protocol handler instance" */);
+        assert(this._protocolHandler.attributes.term !== undefined, 0x30b /* Must have a valid protocol handler instance */);
         const pendingState = {
             pendingRuntimeState: this.context.getPendingLocalState(),
             url: this.resolvedUrl.url,
+            protocol: this.protocolHandler.getProtocolState(),
+            term: this._protocolHandler.attributes.term,
+            clientId: this.clientId,
         };
         this.close();
         return JSON.stringify(pendingState);
@@ -532,7 +536,7 @@ export class Container extends EventEmitterWithErrorHandling {
                     // starting to attach the container to storage.
                     // Also, this should only be fired in detached container.
                     this._attachState = AttachState.Attaching;
-                    this.context.notifyAttaching();
+                    this.context.notifyAttaching(getSnapshotTreeFromSerializedContainer(summary));
                 }
                 // Actually go and create the resolved document
                 const createNewResolvedUrl = await this.urlResolver.resolve(request);
@@ -567,7 +571,7 @@ export class Container extends EventEmitterWithErrorHandling {
                     const protocolSummary = this.captureProtocolSummary();
                     summary = combineAppAndProtocolSummary(appSummary, protocolSummary);
                     this._attachState = AttachState.Attaching;
-                    this.context.notifyAttaching();
+                    this.context.notifyAttaching(getSnapshotTreeFromSerializedContainer(summary));
                     await this.storageService.uploadSummaryWithContext(summary, {
                         referenceSequenceNumber: 0,
                         ackHandle: undefined,
@@ -597,27 +601,6 @@ export class Container extends EventEmitterWithErrorHandling {
     async request(path) {
         return PerformanceEvent.timedExecAsync(this.mc.logger, { eventName: "Request" }, async () => this.context.request(path), { end: true, cancel: "error" });
     }
-    /**
-     * Dictates whether or not the current container will automatically attempt to reconnect to the delta stream
-     * after receiving a disconnect event
-     * @param reconnect - Boolean indicating if reconnect should automatically occur
-     * @deprecated - 0.58, This API will be removed in 1.0
-     * Use `connect()` and `disconnect()` instead of `setAutoReconnect(true)` and `setAutoReconnect(false)` respectively
-     * See https://github.com/microsoft/FluidFramework/issues/9167 for context
-     */
-    setAutoReconnect(reconnect) {
-        if (this.closed) {
-            throw new Error("Attempting to setAutoReconnect() a closed Container");
-        }
-        const mode = reconnect ? ReconnectMode.Enabled : ReconnectMode.Disabled;
-        this.setAutoReconnectInternal(mode);
-        // If container state is not attached and resumed, then don't connect to delta stream. Also don't set the
-        // manual reconnection flag to true as we haven't made the initial connection yet.
-        if (reconnect && this._attachState === AttachState.Attached && this.resumedOpProcessingAfterLoad) {
-            // Ensure connection to web socket
-            this.connectToDeltaStream({ reason: "autoReconnect" });
-        }
-    }
     setAutoReconnectInternal(mode) {
         const currentMode = this._deltaManager.connectionManager.reconnectMode;
         if (currentMode === mode) {
@@ -671,22 +654,8 @@ export class Container extends EventEmitterWithErrorHandling {
         const mode = ReconnectMode.Disabled;
         this.setAutoReconnectInternal(mode);
     }
-    /**
-     * Have the container attempt to resume processing ops
-     * @deprecated - 0.58, This API will be removed in 1.0
-     * Use `connect()` instead
-     * See https://github.com/microsoft/FluidFramework/issues/9167 for context
-     */
-    resume() {
-        if (!this.closed) {
-            // Note: no need to fetch ops as we do it preemptively as part of DeltaManager.attachOpHandler().
-            // If there is gap, we will learn about it once connected, but the gap should be small (if any),
-            // assuming that resume() is called quickly after initial container boot.
-            this.resumeInternal({ reason: "DocumentOpenResume", fetchOpsFromStorage: false });
-        }
-    }
     resumeInternal(args) {
-        assert(!this.closed, 0x0d9 /* "Attempting to setAutoReconnect() a closed DeltaManager" */);
+        assert(!this.closed, 0x0d9 /* "Attempting to connect() a closed DeltaManager" */);
         // Resume processing ops
         if (!this.resumedOpProcessingAfterLoad) {
             this.resumedOpProcessingAfterLoad = true;
@@ -775,12 +744,26 @@ export class Container extends EventEmitterWithErrorHandling {
         if (loadMode.deltaConnection === undefined) {
             this.connectToDeltaStream(connectionArgs);
         }
-        await this.connectStorageService();
+        if (!pendingLocalState) {
+            await this.connectStorageService();
+        }
+        else {
+            // if we have pendingLocalState we can load without storage; don't wait for connection
+            this.connectStorageService().catch((error) => this.close(error));
+        }
         this._attachState = AttachState.Attached;
         // Fetch specified snapshot.
-        const { snapshot, versionId } = await this.fetchSnapshotTree(specifiedVersion);
-        assert(snapshot !== undefined, 0x237 /* "Snapshot should exist" */);
-        const attributes = await this.getDocumentAttributes(this.storageService, snapshot);
+        const { snapshot, versionId } = pendingLocalState === undefined
+            ? await this.fetchSnapshotTree(specifiedVersion)
+            : { snapshot: undefined, versionId: undefined };
+        assert(snapshot !== undefined || pendingLocalState !== undefined, 0x237 /* "Snapshot should exist" */);
+        const attributes = pendingLocalState === undefined
+            ? await this.getDocumentAttributes(this.storageService, snapshot)
+            : {
+                sequenceNumber: pendingLocalState.protocol.sequenceNumber,
+                minimumSequenceNumber: pendingLocalState.protocol.minimumSequenceNumber,
+                term: pendingLocalState.term,
+            };
         let opsBeforeReturnP;
         // Attach op handlers to finish initialization and be able to start processing ops
         // Kick off any ops fetching if required.
@@ -801,15 +784,14 @@ export class Container extends EventEmitterWithErrorHandling {
         }
         // ...load in the existing quorum
         // Initialize the protocol handler
-        this._protocolHandler =
-            await this.initializeProtocolStateFromSnapshot(attributes, this.storageService, snapshot);
+        this._protocolHandler = pendingLocalState === undefined
+            ? await this.initializeProtocolStateFromSnapshot(attributes, this.storageService, snapshot)
+            : await this.initializeProtocolState(attributes, pendingLocalState.protocol.members, pendingLocalState.protocol.proposals, pendingLocalState.protocol.values);
         const codeDetails = this.getCodeDetailsFromQuorum();
         await this.instantiateContext(true, // existing
-        codeDetails, snapshot, pendingLocalState);
-        // Propagate current connection state through the system.
-        this.propagateConnectionState();
+        codeDetails, snapshot, pendingLocalState === null || pendingLocalState === void 0 ? void 0 : pendingLocalState.pendingRuntimeState);
         // Internal context is fully loaded at this point
-        this.loaded = true;
+        this.setLoaded();
         // We might have hit some failure that did not manifest itself in exception in this flow,
         // do not start op processing in such case - static version of Container.load() will handle it correctly.
         if (!this.closed) {
@@ -822,7 +804,10 @@ export class Container extends EventEmitterWithErrorHandling {
             }
             switch (loadMode.deltaConnection) {
                 case undefined:
-                    this.resume();
+                    // Note: no need to fetch ops as we do it preemptively as part of DeltaManager.attachOpHandler().
+                    // If there is gap, we will learn about it once connected, but the gap should be small (if any),
+                    // assuming that resumeInternal() is called quickly after initial container boot.
+                    this.resumeInternal({ reason: "DocumentLoad", fetchOpsFromStorage: false });
                     break;
                 case "delayed":
                     this.resumedOpProcessingAfterLoad = true;
@@ -862,8 +847,7 @@ export class Container extends EventEmitterWithErrorHandling {
         qValues);
         // The load context - given we seeded the quorum - will be great
         await this.instantiateContextDetached(false);
-        this.propagateConnectionState();
-        this.loaded = true;
+        this.setLoaded();
     }
     async rehydrateDetachedFromSnapshot(detachedContainerSnapshot) {
         if (detachedContainerSnapshot.tree[".hasAttachmentBlobs"] !== undefined) {
@@ -884,8 +868,7 @@ export class Container extends EventEmitterWithErrorHandling {
             codeDetails !== undefined ? initQuorumValuesFromCodeDetails(codeDetails) : []);
         await this.instantiateContextDetached(true, // existing
         snapshotTree);
-        this.loaded = true;
-        this.propagateConnectionState();
+        this.setLoaded();
     }
     async connectStorageService() {
         var _a, _b;
@@ -939,18 +922,13 @@ export class Container extends EventEmitterWithErrorHandling {
         return protocolHandler;
     }
     async initializeProtocolState(attributes, members, proposals, values) {
-        const protocol = new ProtocolOpHandler(attributes.minimumSequenceNumber, attributes.sequenceNumber, attributes.term, members, proposals, values, (key, value) => this.submitMessage(MessageType.Propose, { key, value }));
+        const protocol = new ProtocolOpHandlerWithClientValidation(attributes.minimumSequenceNumber, attributes.sequenceNumber, attributes.term, members, proposals, values, (key, value) => this.submitMessage(MessageType.Propose, { key, value }));
         const protocolLogger = ChildLogger.create(this.subLogger, "ProtocolHandler");
         protocol.quorum.on("error", (error) => {
             protocolLogger.sendErrorEvent(error);
         });
         // Track membership changes and update connection state accordingly
-        protocol.quorum.on("addMember", (clientId, details) => {
-            this.connectionStateHandler.receivedAddMemberEvent(clientId);
-        });
-        protocol.quorum.on("removeMember", (clientId) => {
-            this.connectionStateHandler.receivedRemoveMemberEvent(clientId);
-        });
+        this.connectionStateHandler.initProtocol(protocol);
         protocol.quorum.on("addProposal", (proposal) => {
             if (proposal.key === "code" || proposal.key === "code2") {
                 this.emit("codeDetailsProposed", proposal.value, proposal);
@@ -972,17 +950,11 @@ export class Container extends EventEmitterWithErrorHandling {
         return protocol;
     }
     captureProtocolSummary() {
-        const quorumSnapshot = this.protocolHandler.quorum.snapshot();
-        // Save attributes for the document
-        const documentAttributes = {
-            minimumSequenceNumber: this.protocolHandler.minimumSequenceNumber,
-            sequenceNumber: this.protocolHandler.sequenceNumber,
-            term: this.protocolHandler.term,
-        };
+        const quorumSnapshot = this.protocolHandler.snapshot();
         const summary = {
             tree: {
                 attributes: {
-                    content: JSON.stringify(documentAttributes),
+                    content: JSON.stringify(this.protocolHandler.attributes),
                     type: SummaryType.Blob,
                 },
                 quorumMembers: {
@@ -1071,7 +1043,7 @@ export class Container extends EventEmitterWithErrorHandling {
             this.emit("readonly", readonly);
         });
         deltaManager.on("closed", (error) => {
-            this.close(error);
+            this.closeCore(error);
         });
         return deltaManager;
     }
@@ -1085,6 +1057,7 @@ export class Container extends EventEmitterWithErrorHandling {
         }, prefetchType);
     }
     logConnectionStateChangeTelemetry(value, oldState, reason) {
+        var _a;
         // Log actual event
         const time = performance.now();
         this.connectionTransitionTimes[value] = time;
@@ -1120,12 +1093,13 @@ export class Container extends EventEmitterWithErrorHandling {
             durationFromDisconnected,
             reason,
             connectionInitiationReason, pendingClientId: this.connectionStateHandler.pendingClientId, clientId: this.clientId, autoReconnect,
-            opsBehind, online: OnlineStatus[isOnline()], lastVisible: this.lastVisible !== undefined ? performance.now() - this.lastVisible : undefined, checkpointSequenceNumber }, this._deltaManager.connectionProps));
+            opsBehind, online: OnlineStatus[isOnline()], lastVisible: this.lastVisible !== undefined ? performance.now() - this.lastVisible : undefined, checkpointSequenceNumber, quorumSize: (_a = this._protocolHandler) === null || _a === void 0 ? void 0 : _a.quorum.getMembers().size }, this._deltaManager.connectionProps));
         if (value === ConnectionState.Connected) {
             this.firstConnection = false;
         }
     }
     propagateConnectionState() {
+        var _a;
         const logOpsOnReconnect = this.connectionState === ConnectionState.Connected &&
             !this.firstConnection &&
             this.connectionMode === "write";
@@ -1133,11 +1107,11 @@ export class Container extends EventEmitterWithErrorHandling {
             this.messageCountAfterDisconnection = 0;
         }
         const state = this.connectionState === ConnectionState.Connected;
-        if (!this.context.disposed) {
+        // 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);
         }
-        assert(this.protocolHandler !== undefined, 0x0dc /* "Protocol handler should be set here" */);
-        this.protocolHandler.quorum.setConnectionState(state, this.clientId);
+        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 });
@@ -1179,31 +1153,19 @@ export class Container extends EventEmitterWithErrorHandling {
         return this._deltaManager.submit(type, contents, batch, metadata);
     }
     processRemoteMessage(message) {
-        // Check and report if we're getting messages from a clientId that we previously
-        // flagged as shouldHaveLeft, or from a client that's not in the quorum but should be
-        if (message.clientId != null) {
-            let errorMsg;
-            const client = this.getQuorum().getMember(message.clientId);
-            if (client === undefined && message.type !== MessageType.ClientJoin) {
-                // pre-0.58 error message: messageClientIdMissingFromQuorum
-                errorMsg = "Remote message's clientId is missing from the quorum";
-            }
-            else if ((client === null || client === void 0 ? void 0 : client.shouldHaveLeft) === true && message.type !== MessageType.NoOp) {
-                // pre-0.58 error message: messageClientIdShouldHaveLeft
-                errorMsg = "Remote message's clientId already should have left";
-            }
-            if (errorMsg !== undefined) {
-                const error = new DataCorruptionError(errorMsg, extractSafePropertiesFromMessage(message));
-                this.close(normalizeError(error));
-            }
-        }
         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))));
+        }
         // Forward non system messages to the loaded runtime for processing
         if (!isSystemMessage(message)) {
             this.context.process(message, local, undefined);
         }
-        // Allow the protocol handler to process the message
-        const result = this.protocolHandler.processMessage(message, local);
         // 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) {
@@ -1211,35 +1173,17 @@ export class Container extends EventEmitterWithErrorHandling {
                 // That means that if relay service changes settings, such changes will impact only newly booted
                 // clients.
                 // All existing will continue to use settings they got earlier.
-                const [noopTimeFrequency, noopCountFrequency] = this.getNoopConfig();
+                assert(this.serviceConfiguration !== undefined, 0x2e4 /* "there should be service config for active connection" */);
                 this.collabWindowTracker = new CollabWindowTracker((type, contents) => {
                     assert(this.activeConnection(), 0x241 /* "disconnect should result in stopSequenceNumberUpdate() call" */);
                     this.submitMessage(type, contents);
-                }, noopTimeFrequency, noopCountFrequency);
+                }, this.serviceConfiguration.noopTimeFrequency, this.serviceConfiguration.noopCountFrequency);
             }
             this.collabWindowTracker.scheduleSequenceNumberUpdate(message, result.immediateNoOp === true);
         }
         this.emit("op", message);
         return result;
     }
-    /**
-     *  #260 (ADO)
-     * back-compat: noopTimeFrequency & noopCountFrequency properties were added to
-     * IClientConfiguration in 0.59.3000. During the integration, we must read the
-     * available configuration from the loader options.
-     */
-    getNoopConfig() {
-        var _a, _b;
-        assert(this.serviceConfiguration !== undefined, 0x2e2);
-        if (this.serviceConfiguration.noopTimeFrequency !== undefined ||
-            this.serviceConfiguration.noopCountFrequency !== undefined) {
-            return [
-                this.serviceConfiguration.noopTimeFrequency,
-                this.serviceConfiguration.noopCountFrequency,
-            ];
-        }
-        return [(_a = this.loader.services.options) === null || _a === void 0 ? void 0 : _a.noopTimeFrequency, (_b = this.loader.services.options) === null || _b === void 0 ? void 0 : _b.noopCountFrequency];
-    }
     submitSignal(message) {
         this._deltaManager.submitSignal(JSON.stringify(message));
     }
@@ -1280,12 +1224,12 @@ export class Container extends EventEmitterWithErrorHandling {
         }
         return { snapshot, versionId: version === null || version === void 0 ? void 0 : version.id };
     }
-    async instantiateContextDetached(existing, snapshot, pendingLocalState) {
+    async instantiateContextDetached(existing, snapshot) {
         const codeDetails = this.getCodeDetailsFromQuorum();
         if (codeDetails === undefined) {
             throw new Error("pkg should be provided in create flow!!");
         }
-        await this.instantiateContext(existing, codeDetails, snapshot, pendingLocalState);
+        await this.instantiateContext(existing, codeDetails, snapshot);
     }
     async instantiateContext(existing, codeDetails, snapshot, pendingLocalState) {
         var _a;