@fluidframework/container-loader 2.0.0-internal.5.1.1 → 2.0.0-internal.5.3.0

package/lib/container.js

@@ -5,30 +5,30 @@
 // eslint-disable-next-line import/no-internal-modules
 import merge from "lodash/merge";
 import { v4 as uuid } from "uuid";
-import { assert, performance, unreachableCase } from "@fluidframework/common-utils";
+import { TypedEventEmitter, assert, performance, unreachableCase, } from "@fluidframework/common-utils";
 import { AttachState, isFluidCodeDetails, } from "@fluidframework/container-definitions";
 import { GenericError, UsageError } from "@fluidframework/container-utils";
-import { readAndParse, OnlineStatus, isOnline, combineAppAndProtocolSummary, runWithRetry, isCombinedAppAndProtocolSummary, } from "@fluidframework/driver-utils";
+import { readAndParse, OnlineStatus, isOnline, combineAppAndProtocolSummary, runWithRetry, isCombinedAppAndProtocolSummary, MessageType2, canBeCoalescedByService, } from "@fluidframework/driver-utils";
 import { MessageType, SummaryType, } from "@fluidframework/protocol-definitions";
 import { ChildLogger, EventEmitterWithErrorHandling, PerformanceEvent, raiseConnectedEvent, TelemetryLogger, connectedEventName, normalizeError, loggerToMonitoringContext, wrapError, } from "@fluidframework/telemetry-utils";
 import { Audience } from "./audience";
 import { ContainerContext } from "./containerContext";
 import { ReconnectMode, getPackageName } from "./contracts";
 import { DeltaManager } from "./deltaManager";
-import { DeltaManagerProxy } from "./deltaManagerProxy";
 import { RelativeLoader } from "./loader";
 import { pkgVersion } from "./packageVersion";
 import { ContainerStorageAdapter, getBlobContentsFromTree, getBlobContentsFromTreeWithBlobContents, } from "./containerStorageAdapter";
 import { createConnectionStateHandler } from "./connectionStateHandler";
 import { getProtocolSnapshotTree, getSnapshotTreeFromSerializedContainer } from "./utils";
-import { initQuorumValuesFromCodeDetails, getCodeDetailsFromQuorumValues, QuorumProxy, } from "./quorum";
-import { CollabWindowTracker } from "./collabWindowTracker";
+import { initQuorumValuesFromCodeDetails, getCodeDetailsFromQuorumValues } from "./quorum";
+import { NoopHeuristic } from "./noopHeuristic";
 import { ConnectionManager } from "./connectionManager";
 import { ConnectionState } from "./connectionState";
-import { OnlyValidTermValue, ProtocolHandler, } from "./protocol";
+import { OnlyValidTermValue, ProtocolHandler, protocolHandlerShouldProcessSignal, } from "./protocol";
 const detachedContainerRefSeqNumber = 0;
 const dirtyContainerEvent = "dirty";
 const savedContainerEvent = "saved";
+const packageNotFactoryError = "Code package does not implement IRuntimeFactory";
 /**
  * Waits until container connects to delta storage and gets up-to-date.
  *
@@ -156,8 +156,23 @@ export class Container extends EventEmitterWithErrorHandling {
         this.attachStarted = false;
         this._dirtyContainer = false;
         this.savedOps = [];
+        this.clientsWhoShouldHaveLeft = new Set();
         this.setAutoReconnectTime = performance.now();
+        this._lifecycleEvents = new TypedEventEmitter();
         this._disposed = false;
+        this.getAbsoluteUrl = async (relativeUrl) => {
+            if (this.resolvedUrl === undefined) {
+                return undefined;
+            }
+            return this.urlResolver.getAbsoluteUrl(this.resolvedUrl, relativeUrl, getPackageName(this._loadedCodeDetails));
+        };
+        this.updateDirtyContainerState = (dirty) => {
+            if (this._dirtyContainer === dirty) {
+                return;
+            }
+            this._dirtyContainer = dirty;
+            this.emit(dirty ? dirtyContainerEvent : savedContainerEvent);
+        };
         const { canReconnect, clientDetailsOverride, urlResolver, documentServiceFactory, codeLoader, options, scope, subLogger, detachedBlobStorage, protocolHandlerBuilder, } = createProps;
         this.connectionTransitionTimes[ConnectionState.Disconnected] = performance.now();
         const pendingLocalState = loadProps === null || loadProps === void 0 ? void 0 : loadProps.pendingLocalState;
@@ -202,13 +217,18 @@ export class Container extends EventEmitterWithErrorHandling {
                 dmInitialSeqNumber: () => { var _a; return (_a = this._deltaManager) === null || _a === void 0 ? void 0 : _a.initialSequenceNumber; },
                 dmLastProcessedSeqNumber: () => { var _a; return (_a = this._deltaManager) === null || _a === void 0 ? void 0 : _a.lastSequenceNumber; },
                 dmLastKnownSeqNumber: () => { var _a; return (_a = this._deltaManager) === null || _a === void 0 ? void 0 : _a.lastKnownSeqNumber; },
-                containerLoadedFromVersionId: () => { var _a; return (_a = this.loadedFromVersion) === null || _a === void 0 ? void 0 : _a.id; },
-                containerLoadedFromVersionDate: () => { var _a; return (_a = this.loadedFromVersion) === null || _a === void 0 ? void 0 : _a.date; },
+                containerLoadedFromVersionId: () => { var _a; return (_a = this._loadedFromVersion) === null || _a === void 0 ? void 0 : _a.id; },
+                containerLoadedFromVersionDate: () => { var _a; return (_a = this._loadedFromVersion) === null || _a === void 0 ? void 0 : _a.date; },
                 // message information to associate errors with the specific execution state
                 // dmLastMsqSeqNumber: if present, same as dmLastProcessedSeqNumber
                 dmLastMsqSeqNumber: () => { var _a, _b; return (_b = (_a = this.deltaManager) === null || _a === void 0 ? void 0 : _a.lastMessage) === null || _b === void 0 ? void 0 : _b.sequenceNumber; },
                 dmLastMsqSeqTimestamp: () => { var _a, _b; return (_b = (_a = this.deltaManager) === null || _a === void 0 ? void 0 : _a.lastMessage) === null || _b === void 0 ? void 0 : _b.timestamp; },
-                dmLastMsqSeqClientId: () => { var _a, _b; return (_b = (_a = this.deltaManager) === null || _a === void 0 ? void 0 : _a.lastMessage) === null || _b === void 0 ? void 0 : _b.clientId; },
+                dmLastMsqSeqClientId: () => {
+                    var _a, _b, _c, _d;
+                    return ((_b = (_a = this.deltaManager) === null || _a === void 0 ? void 0 : _a.lastMessage) === null || _b === void 0 ? void 0 : _b.clientId) === null
+                        ? "null"
+                        : (_d = (_c = this.deltaManager) === null || _c === void 0 ? void 0 : _c.lastMessage) === null || _d === void 0 ? void 0 : _d.clientId;
+                },
                 dmLastMsgClientSeq: () => { var _a, _b; return (_b = (_a = this.deltaManager) === null || _a === void 0 ? void 0 : _a.lastMessage) === null || _b === void 0 ? void 0 : _b.clientSequenceNumber; },
                 connectionStateDuration: () => performance.now() - this.connectionTransitionTimes[this.connectionState],
             },
@@ -254,6 +274,9 @@ export class Container extends EventEmitterWithErrorHandling {
                     this.connect();
                 }
             },
+            clientShouldHaveLeft: (clientId) => {
+                this.clientsWhoShouldHaveLeft.add(clientId);
+            },
         }, this.deltaManager, pendingLocalState === null || pendingLocalState === void 0 ? void 0 : pendingLocalState.clientId);
         this.on(savedContainerEvent, () => {
             this.connectionStateHandler.containerSaved();
@@ -296,6 +319,7 @@ export class Container extends EventEmitterWithErrorHandling {
     static async load(loadProps, createProps) {
         const { version, pendingLocalState, loadMode, resolvedUrl } = loadProps;
         const container = new Container(createProps, loadProps);
+        const disableRecordHeapSize = container.mc.config.getBoolean("Fluid.Loader.DisableRecordHeapSize");
         return PerformanceEvent.timedExecAsync(container.mc.logger, { eventName: "Load" }, async (event) => new Promise((resolve, reject) => {
             const defaultMode = { opsBeforeReturn: "cached" };
             // if we have pendingLocalState, anything we cached is not useful and we shouldn't wait for connection
@@ -323,7 +347,7 @@ export class Container extends EventEmitterWithErrorHandling {
                 container.close(err);
                 onClosed(err);
             });
-        }), { start: true, end: true, cancel: "generic" });
+        }), { start: true, end: true, cancel: "generic" }, disableRecordHeapSize !== true /* recordHeapSize */);
     }
     /**
      * Create a new container in a detached state.
@@ -362,14 +386,11 @@ export class Container extends EventEmitterWithErrorHandling {
             this._lifecycleState === "disposing" ||
             this._lifecycleState === "disposed");
     }
-    get storage() {
-        return this.storageAdapter;
-    }
-    get context() {
-        if (this._context === undefined) {
-            throw new GenericError("Attempted to access context before it was defined");
+    get runtime() {
+        if (this._runtime === undefined) {
+            throw new Error("Attempted to access runtime before it was defined");
         }
-        return this._context;
+        return this._runtime;
     }
     get protocolHandler() {
         if (this._protocolHandler === undefined) {
@@ -398,15 +419,9 @@ export class Container extends EventEmitterWithErrorHandling {
          */
         return (_a = this.service) === null || _a === void 0 ? void 0 : _a.resolvedUrl;
     }
-    get loadedFromVersion() {
-        return this._loadedFromVersion;
-    }
     get readOnlyInfo() {
         return this._deltaManager.readOnlyInfo;
     }
-    get closeSignal() {
-        return this._deltaManager.closeAbortController.signal;
-    }
     /**
      * Tracks host requiring read-only mode.
      */
@@ -422,13 +437,6 @@ export class Container extends EventEmitterWithErrorHandling {
     get connected() {
         return this.connectionStateHandler.connectionState === ConnectionState.Connected;
     }
-    /**
-     * Service configuration details. If running in offline mode will be undefined otherwise will contain service
-     * configuration details returned as part of the initial connection.
-     */
-    get serviceConfiguration() {
-        return this._deltaManager.serviceConfiguration;
-    }
     /**
      * The server provided id of the client.
      * Set once this.connected is true, otherwise undefined
@@ -436,21 +444,11 @@ export class Container extends EventEmitterWithErrorHandling {
     get clientId() {
         return this._clientId;
     }
-    /**
-     * The server provided claims of the client.
-     * Set once this.connected is true, otherwise undefined
-     */
-    get scopes() {
-        return this._deltaManager.connectionManager.scopes;
-    }
-    get clientDetails() {
-        return this._deltaManager.clientDetails;
-    }
     get offlineLoadEnabled() {
         var _a, _b;
         const enabled = (_a = this.mc.config.getBoolean("Fluid.Container.enableOfflineLoad")) !== null && _a !== void 0 ? _a : ((_b = this.options) === null || _b === void 0 ? void 0 : _b.enableOfflineLoad) === true;
         // summarizer will not have any pending state we want to save
-        return enabled && this.clientDetails.capabilities.interactive;
+        return enabled && this.deltaManager.clientDetails.capabilities.interactive;
     }
     /**
      * Get the code details that are currently specified for the container.
@@ -465,8 +463,7 @@ export class Container extends EventEmitterWithErrorHandling {
      * loaded.
      */
     getLoadedCodeDetails() {
-        var _a;
-        return (_a = this._context) === null || _a === void 0 ? void 0 : _a.codeDetails;
+        return this._loadedCodeDetails;
     }
     /**
      * Retrieves the audience associated with the document
@@ -487,32 +484,26 @@ export class Container extends EventEmitterWithErrorHandling {
      */
     async getEntryPoint() {
         var _a, _b;
-        // Only the disposing/disposed lifecycle states should prevent access to the entryPoint; closing/closed should still
-        // allow it since they mean a kind of read-only state for the Container.
-        // Note that all 4 are lifecycle states but only 'closed' and 'disposed' are emitted as events.
-        if (this._lifecycleState === "disposing" || this._lifecycleState === "disposed") {
-            throw new UsageError("The container is disposing or disposed");
-        }
-        while (this._context === undefined) {
-            await new Promise((resolve, reject) => {
-                const contextChangedHandler = () => {
-                    resolve();
-                    this.off("disposed", disposedHandler);
-                };
-                const disposedHandler = (error) => {
-                    reject(error !== null && error !== void 0 ? error : "The Container is disposed");
-                    this.off("contextChanged", contextChangedHandler);
-                };
-                this.once("contextChanged", contextChangedHandler);
-                this.once("disposed", disposedHandler);
-            });
-            // The Promise above should only resolve (vs reject) if the 'contextChanged' event was emitted and that
-            // should have set this._context; making sure.
-            assert(this._context !== undefined, 0x5a2 /* Context still not defined after contextChanged event */);
+        if (this._disposed) {
+            throw new UsageError("The context is already disposed");
+        }
+        if (this._runtime !== undefined) {
+            return (_b = (_a = this._runtime).getEntryPoint) === null || _b === void 0 ? void 0 : _b.call(_a);
         }
-        // Disable lint rule for the sake of more complete stack traces
-        // eslint-disable-next-line no-return-await
-        return await ((_b = (_a = this._context).getEntryPoint) === null || _b === void 0 ? void 0 : _b.call(_a));
+        return new Promise((resolve, reject) => {
+            const runtimeInstantiatedHandler = () => {
+                var _a, _b;
+                assert(this._runtime !== undefined, 0x5a3 /* runtimeInstantiated fired but runtime is still undefined */);
+                resolve((_b = (_a = this._runtime).getEntryPoint) === null || _b === void 0 ? void 0 : _b.call(_a));
+                this._lifecycleEvents.off("disposed", disposedHandler);
+            };
+            const disposedHandler = () => {
+                reject(new Error("ContainerContext was disposed"));
+                this._lifecycleEvents.off("runtimeInstantiated", runtimeInstantiatedHandler);
+            };
+            this._lifecycleEvents.once("runtimeInstantiated", runtimeInstantiatedHandler);
+            this._lifecycleEvents.once("disposed", disposedHandler);
+        });
     }
     /**
      * Retrieves the quorum associated with the document
@@ -566,6 +557,10 @@ export class Container extends EventEmitterWithErrorHandling {
         }
         finally {
             this._lifecycleState = "closed";
+            // There is no user for summarizer, so we need to ensure dispose is called
+            if (this.client.details.type === summarizerClientType) {
+                this.dispose(error);
+            }
         }
     }
     disposeCore(error) {
@@ -579,7 +574,8 @@ export class Container extends EventEmitterWithErrorHandling {
                 // This gives us a chance to know what errors happened on open vs. on fully loaded container.
                 this.mc.logger.sendTelemetryEvent({
                     eventName: "ContainerDispose",
-                    category: "generic",
+                    // Only log error if container isn't closed
+                    category: !this.closed && error !== undefined ? "error" : "generic",
                 }, error);
                 // ! Progressing from "closed" to "disposing" is not allowed
                 if (this._lifecycleState !== "closed") {
@@ -587,7 +583,8 @@ 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);
+                const maybeError = error !== undefined ? new Error(error.message) : undefined;
+                (_b = this._runtime) === null || _b === void 0 ? void 0 : _b.dispose(maybeError);
                 this.storageAdapter.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.
@@ -605,6 +602,7 @@ export class Container extends EventEmitterWithErrorHandling {
         }
         finally {
             this._lifecycleState = "disposed";
+            this._lifecycleEvents.emit("disposed");
         }
     }
     closeAndGetPendingLocalState() {
@@ -619,12 +617,15 @@ export class Container extends EventEmitterWithErrorHandling {
         if (!this.offlineLoadEnabled) {
             throw new UsageError("Can't get pending local state unless offline load is enabled");
         }
+        if (this.closed || this._disposed) {
+            throw new UsageError("Pending state cannot be retried if the container is closed or disposed");
+        }
         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.baseSnapshot, 0x5d4 /* no base snapshot */);
         assert(!!this.baseSnapshotBlobs, 0x5d5 /* no snapshot blobs */);
         const pendingState = {
-            pendingRuntimeState: this.context.getPendingLocalState(),
+            pendingRuntimeState: this.runtime.getPendingLocalState(),
             baseSnapshot: this.baseSnapshot,
             snapshotBlobs: this.baseSnapshotBlobs,
             savedOps: this.savedOps,
@@ -640,7 +641,7 @@ export class Container extends EventEmitterWithErrorHandling {
     }
     serialize() {
         assert(this.attachState === AttachState.Detached, 0x0d3 /* "Should only be called in detached container" */);
-        const appSummary = this.context.createSummary();
+        const appSummary = this.runtime.createSummary();
         const protocolSummary = this.captureProtocolSummary();
         const combinedSummary = combineAppAndProtocolSummary(appSummary, protocolSummary);
         if (this.detachedBlobStorage && this.detachedBlobStorage.size > 0) {
@@ -669,7 +670,7 @@ export class Container extends EventEmitterWithErrorHandling {
                 if (!hasAttachmentBlobs) {
                     // Get the document state post attach - possibly can just call attach but we need to change the
                     // semantics around what the attach means as far as async code goes.
-                    const appSummary = this.context.createSummary();
+                    const appSummary = this.runtime.createSummary();
                     const protocolSummary = this.captureProtocolSummary();
                     summary = combineAppAndProtocolSummary(appSummary, protocolSummary);
                     // Set the state as attaching as we are starting the process of attaching container.
@@ -677,6 +678,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.runtime.setAttachState(AttachState.Attaching);
                     this.emit("attaching");
                     if (this.offlineLoadEnabled) {
                         const snapshot = getSnapshotTreeFromSerializedContainer(summary);
@@ -691,7 +693,7 @@ export class Container extends EventEmitterWithErrorHandling {
                     assert(this.client.details.type !== summarizerClientType &&
                         createNewResolvedUrl !== undefined, 0x2c4 /* "client should not be summarizer before container is created" */);
                     this.service = await runWithRetry(async () => this.serviceFactory.createContainer(summary, createNewResolvedUrl, this.subLogger, false), "containerAttach", this.mc.logger, {
-                        cancel: this.closeSignal,
+                        cancel: this._deltaManager.closeAbortController.signal,
                     });
                 }
                 await this.storageAdapter.connectToService(this.service);
@@ -713,10 +715,11 @@ export class Container extends EventEmitterWithErrorHandling {
                         }
                     }
                     // take summary and upload
-                    const appSummary = this.context.createSummary(redirectTable);
+                    const appSummary = this.runtime.createSummary(redirectTable);
                     const protocolSummary = this.captureProtocolSummary();
                     summary = combineAppAndProtocolSummary(appSummary, protocolSummary);
                     this._attachState = AttachState.Attaching;
+                    this.runtime.setAttachState(AttachState.Attaching);
                     this.emit("attaching");
                     if (this.offlineLoadEnabled) {
                         const snapshot = getSnapshotTreeFromSerializedContainer(summary);
@@ -731,6 +734,7 @@ export class Container extends EventEmitterWithErrorHandling {
                     });
                 }
                 this._attachState = AttachState.Attached;
+                this.runtime.setAttachState(AttachState.Attached);
                 this.emit("attached");
                 if (!this.closed) {
                     this.resumeInternal({
@@ -749,7 +753,7 @@ export class Container extends EventEmitterWithErrorHandling {
         }, { start: true, end: true, cancel: "generic" });
     }
     async request(path) {
-        return PerformanceEvent.timedExecAsync(this.mc.logger, { eventName: "Request" }, async () => this.context.request(path), { end: true, cancel: "error" });
+        return PerformanceEvent.timedExecAsync(this.mc.logger, { eventName: "Request" }, async () => this.runtime.request(path), { end: true, cancel: "error" });
     }
     setAutoReconnectInternal(mode) {
         const currentMode = this._deltaManager.connectionManager.reconnectMode;
@@ -815,13 +819,6 @@ export class Container extends EventEmitterWithErrorHandling {
         // Ensure connection to web socket
         this.connectToDeltaStream(args);
     }
-    async getAbsoluteUrl(relativeUrl) {
-        var _a;
-        if (this.resolvedUrl === undefined) {
-            return undefined;
-        }
-        return this.urlResolver.getAbsoluteUrl(this.resolvedUrl, relativeUrl, getPackageName((_a = this._context) === null || _a === void 0 ? void 0 : _a.codeDetails));
-    }
     async proposeCodeDetails(codeDetails) {
         if (!isFluidCodeDetails(codeDetails)) {
             throw new Error("Provided codeDetails are not IFluidCodeDetails");
@@ -843,7 +840,7 @@ export class Container extends EventEmitterWithErrorHandling {
             this.deltaManager.inbound.pause(),
             this.deltaManager.inboundSignal.pause(),
         ]);
-        if ((await this.context.satisfies(codeDetails)) === true) {
+        if ((await this.satisfies(codeDetails)) === true) {
             this.deltaManager.inbound.resume();
             this.deltaManager.inboundSignal.resume();
             return;
@@ -852,6 +849,38 @@ export class Container extends EventEmitterWithErrorHandling {
         const error = new GenericError("Existing context does not satisfy incoming proposal");
         this.close(error);
     }
+    /**
+     * Determines if the currently loaded module satisfies the incoming constraint code details
+     */
+    async satisfies(constraintCodeDetails) {
+        var _a, _b;
+        // If we have no module, it can't satisfy anything.
+        if (this._loadedModule === undefined) {
+            return false;
+        }
+        const comparers = [];
+        const maybeCompareCodeLoader = this.codeLoader;
+        if (maybeCompareCodeLoader.IFluidCodeDetailsComparer !== undefined) {
+            comparers.push(maybeCompareCodeLoader.IFluidCodeDetailsComparer);
+        }
+        const maybeCompareExport = (_a = this._loadedModule) === null || _a === void 0 ? void 0 : _a.module.fluidExport;
+        if ((maybeCompareExport === null || maybeCompareExport === void 0 ? void 0 : maybeCompareExport.IFluidCodeDetailsComparer) !== undefined) {
+            comparers.push(maybeCompareExport.IFluidCodeDetailsComparer);
+        }
+        // If there are no comparers, then it's impossible to know if the currently loaded package satisfies
+        // the incoming constraint, so we return false. Assuming it does not satisfy is safer, to force a reload
+        // rather than potentially running with incompatible code.
+        if (comparers.length === 0) {
+            return false;
+        }
+        for (const comparer of comparers) {
+            const satisfies = await comparer.satisfies((_b = this._loadedModule) === null || _b === void 0 ? void 0 : _b.details, constraintCodeDetails);
+            if (satisfies === false) {
+                return false;
+            }
+        }
+        return true;
+    }
     async getVersion(version) {
         const versions = await this.storageAdapter.getVersions(version, 1);
         return versions[0];
@@ -869,7 +898,7 @@ export class Container extends EventEmitterWithErrorHandling {
      * @param specifiedVersion - Version SHA to load snapshot. If not specified, will fetch the latest snapshot.
      */
     async load(specifiedVersion, loadMode, resolvedUrl, pendingLocalState) {
-        var _a;
+        var _a, _b, _c;
         this.service = await this.serviceFactory.createDocumentService(resolvedUrl, this.subLogger, this.client.details.type === summarizerClientType);
         // Ideally we always connect as "read" by default.
         // Currently that works with SPO & r11s, because we get "write" connection when connecting to non-existing file.
@@ -913,7 +942,7 @@ export class Container extends EventEmitterWithErrorHandling {
             if (this.offlineLoadEnabled) {
                 this.baseSnapshot = snapshot;
                 // Save contents of snapshot now, otherwise closeAndGetPendingLocalState() must be async
-                this.baseSnapshotBlobs = await getBlobContentsFromTree(snapshot, this.storage);
+                this.baseSnapshotBlobs = await getBlobContentsFromTree(snapshot, this.storageAdapter);
             }
         }
         const attributes = await this.getDocumentAttributes(this.storageAdapter, snapshot);
@@ -949,7 +978,7 @@ export class Container extends EventEmitterWithErrorHandling {
             for (const message of pendingLocalState.savedOps) {
                 this.processRemoteMessage(message);
                 // allow runtime to apply stashed ops at this op's sequence number
-                await this.context.notifyOpReplay(message);
+                await ((_c = (_b = this.runtime).notifyOpReplay) === null || _c === void 0 ? void 0 : _c.call(_b, message));
             }
             pendingLocalState.savedOps = [];
             // now set clientId to stashed clientId so live ops are correctly processed as local
@@ -1188,7 +1217,7 @@ export class Container extends EventEmitterWithErrorHandling {
         });
         deltaManager.on("disconnect", (reason, error) => {
             var _a;
-            (_a = this.collabWindowTracker) === null || _a === void 0 ? void 0 : _a.stopSequenceNumberUpdate();
+            (_a = this.noopHeuristic) === null || _a === void 0 ? void 0 : _a.notifyDisconnect();
             if (!this.closed) {
                 this.connectionStateHandler.receivedDisconnectEvent(reason, error);
             }
@@ -1245,7 +1274,9 @@ export class Container extends EventEmitterWithErrorHandling {
             else if (value === ConnectionState.CatchingUp) {
                 // This info is of most interesting while Catching Up.
                 checkpointSequenceNumber = this.deltaManager.lastKnownSeqNumber;
-                if (this.deltaManager.hasCheckpointSequenceNumber) {
+                // Need to check that we have already loaded and fetched the snapshot.
+                if (this.deltaManager.hasCheckpointSequenceNumber &&
+                    this._lifecycleState === "loaded") {
                     opsBehind = checkpointSequenceNumber - this.deltaManager.lastSequenceNumber;
                 }
             }
@@ -1332,7 +1363,7 @@ export class Container extends EventEmitterWithErrorHandling {
             return -1;
         }
         this.messageCountAfterDisconnection += 1;
-        (_a = this.collabWindowTracker) === null || _a === void 0 ? void 0 : _a.stopSequenceNumberUpdate();
+        (_a = this.noopHeuristic) === null || _a === void 0 ? void 0 : _a.notifyMessageSent();
         return this._deltaManager.submit(type, contents, batch, metadata, compression, referenceSequenceNumber);
     }
     processRemoteMessage(message) {
@@ -1340,24 +1371,51 @@ export class Container extends EventEmitterWithErrorHandling {
             this.savedOps.push(message);
         }
         const local = this.clientId === message.clientId;
+        // Check and report if we're getting messages from a clientId that we previously
+        // flagged should have left, or from a client that's not in the quorum but should be
+        if (message.clientId != null) {
+            const client = this.protocolHandler.quorum.getMember(message.clientId);
+            if (client === undefined && message.type !== MessageType.ClientJoin) {
+                // pre-0.58 error message: messageClientIdMissingFromQuorum
+                throw new Error("Remote message's clientId is missing from the quorum");
+            }
+            // Here checking canBeCoalescedByService is used as an approximation of "is benign to process despite being unexpected".
+            // It's still not good to see these messages from unexpected clientIds, but since they don't harm the integrity of the
+            // document we don't need to blow up aggressively.
+            if (this.clientsWhoShouldHaveLeft.has(message.clientId) &&
+                !canBeCoalescedByService(message)) {
+                // pre-0.58 error message: messageClientIdShouldHaveLeft
+                throw new Error("Remote message's clientId already should have left");
+            }
+        }
         // Allow the protocol handler to process the message
         const result = this.protocolHandler.processMessage(message, local);
         // Forward messages to the loaded runtime for processing
-        this.context.process(message, local);
+        this.runtime.process(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) {
+            if (this.noopHeuristic === undefined) {
+                const serviceConfiguration = this.deltaManager.serviceConfiguration;
                 // Note that config from first connection will be used for this container's lifetime.
                 // 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.
-                assert(this.serviceConfiguration !== undefined, 0x2e4 /* "there should be service config for active connection" */);
-                this.collabWindowTracker = new CollabWindowTracker((type) => {
-                    assert(this.activeConnection(), 0x241 /* "disconnect should result in stopSequenceNumberUpdate() call" */);
-                    this.submitMessage(type);
-                }, this.serviceConfiguration.noopTimeFrequency, this.serviceConfiguration.noopCountFrequency);
+                assert(serviceConfiguration !== undefined, 0x2e4 /* "there should be service config for active connection" */);
+                this.noopHeuristic = new NoopHeuristic(serviceConfiguration.noopTimeFrequency, serviceConfiguration.noopCountFrequency);
+                this.noopHeuristic.on("wantsNoop", () => {
+                    // On disconnect we notify the heuristic which should prevent it from wanting a noop.
+                    // Hitting this assert would imply we lost activeConnection between notifying the heuristic of a processed message and
+                    // running the microtask that the heuristic queued in response.
+                    assert(this.activeConnection(), 0x241 /* "Trying to send noop without active connection" */);
+                    this.submitMessage(MessageType.NoOp);
+                });
+            }
+            this.noopHeuristic.notifyMessageProcessed(message);
+            // The contract with the protocolHandler is that returning "immediateNoOp" is equivalent to "please immediately accept the proposal I just processed".
+            if (result.immediateNoOp === true) {
+                // ADO:1385: Remove cast and use MessageType once definition changes propagate
+                this.submitMessage(MessageType2.Accept);
             }
-            this.collabWindowTracker.scheduleSequenceNumberUpdate(message, result.immediateNoOp === true);
         }
         this.emit("op", message);
     }
@@ -1366,12 +1424,12 @@ export class Container extends EventEmitterWithErrorHandling {
     }
     processSignal(message) {
         // No clientId indicates a system signal message.
-        if (message.clientId === null) {
+        if (protocolHandlerShouldProcessSignal(message)) {
             this.protocolHandler.processSignal(message);
         }
         else {
             const local = this.clientId === message.clientId;
-            this.context.processSignal(message, local);
+            this.runtime.processSignal(message, local);
         }
     }
     /**
@@ -1404,21 +1462,37 @@ export class Container extends EventEmitterWithErrorHandling {
         await this.instantiateContext(existing, codeDetails, snapshot);
     }
     async instantiateContext(existing, codeDetails, snapshot, pendingLocalState) {
-        var _a;
-        assert(((_a = this._context) === null || _a === void 0 ? void 0 : _a.disposed) !== false, 0x0dd /* "Existing context not disposed" */);
+        var _a, _b;
+        assert(((_a = this._runtime) === null || _a === void 0 ? void 0 : _a.disposed) !== false, 0x0dd /* "Existing runtime not disposed" */);
         // 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 maybeLoader = this.scope;
         const loader = new RelativeLoader(this, maybeLoader.ILoader);
-        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, referenceSequenceNumber) => this.submitSummaryMessage(summaryOp, referenceSequenceNumber), (batch, referenceSequenceNumber) => this.submitBatch(batch, referenceSequenceNumber), (message) => this.submitSignal(message), (error) => this.dispose(error), (error) => this.close(error), Container.version, (dirty) => this.updateDirtyContainerState(dirty), existing, pendingLocalState);
-        this.emit("contextChanged", codeDetails);
-    }
-    updateDirtyContainerState(dirty) {
-        if (this._dirtyContainer === dirty) {
-            return;
+        const loadCodeResult = await PerformanceEvent.timedExecAsync(this.subLogger, { eventName: "CodeLoad" }, async () => this.codeLoader.load(codeDetails));
+        this._loadedModule = {
+            module: loadCodeResult.module,
+            // An older interface ICodeLoader could return an IFluidModule which didn't have details.
+            // If we're using one of those older ICodeLoaders, then we fix up the module with the specified details here.
+            // TODO: Determine if this is still a realistic scenario or if this fixup could be removed.
+            details: (_b = loadCodeResult.details) !== null && _b !== void 0 ? _b : codeDetails,
+        };
+        const fluidExport = this._loadedModule.module.fluidExport;
+        const runtimeFactory = fluidExport === null || fluidExport === void 0 ? void 0 : fluidExport.IRuntimeFactory;
+        if (runtimeFactory === undefined) {
+            throw new Error(packageNotFactoryError);
         }
-        this._dirtyContainer = dirty;
-        this.emit(dirty ? dirtyContainerEvent : savedContainerEvent);
+        const getSpecifiedCodeDetails = () => {
+            var _a;
+            return ((_a = this.protocolHandler.quorum.get("code")) !== null && _a !== void 0 ? _a : this.protocolHandler.quorum.get("code2"));
+        };
+        const context = new ContainerContext(this.options, this.scope, snapshot, this._loadedFromVersion, this._deltaManager, this.storageAdapter, this.protocolHandler.quorum, this.protocolHandler.audience, loader, (type, contents, batch, metadata) => this.submitContainerMessage(type, contents, batch, metadata), (summaryOp, referenceSequenceNumber) => this.submitSummaryMessage(summaryOp, referenceSequenceNumber), (batch, referenceSequenceNumber) => this.submitBatch(batch, referenceSequenceNumber), (message) => this.submitSignal(message), (error) => this.dispose(error), (error) => this.close(error), this.updateDirtyContainerState, this.getAbsoluteUrl, () => { var _a; return (_a = this.resolvedUrl) === null || _a === void 0 ? void 0 : _a.id; }, () => this.clientId, () => this._deltaManager.serviceConfiguration, () => this.attachState, () => this.connected, getSpecifiedCodeDetails, this._deltaManager.clientDetails, existing, this.subLogger, pendingLocalState);
+        this._lifecycleEvents.once("disposed", () => {
+            context.dispose();
+        });
+        this._runtime = await PerformanceEvent.timedExecAsync(this.subLogger, { eventName: "InstantiateRuntime" }, async () => runtimeFactory.instantiateRuntime(context, existing));
+        this._lifecycleEvents.emit("runtimeInstantiated");
+        this._loadedCodeDetails = codeDetails;
+        this.emit("contextChanged", codeDetails);
     }
     /**
      * Set the connected state of the ContainerContext
@@ -1428,16 +1502,15 @@ export class Container extends EventEmitterWithErrorHandling {
      */
     setContextConnectedState(state, readonly) {
         var _a;
-        if (((_a = this._context) === null || _a === void 0 ? void 0 : _a.disposed) === false) {
+        if (((_a = this._runtime) === 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);
+            this.runtime.setConnectionState(state && !readonly, this.clientId);
         }
     }
 }
-Container.version = "^0.1.0";
 //# sourceMappingURL=container.js.map