@fluidframework/container-loader 2.0.0-dev.4.4.0.162574 → 2.0.0-dev.5.3.2.178189

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, ensureFluidResolvedUrl, combineAppAndProtocolSummary, runWithRetry, isFluidResolvedUrl, 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.
  *
@@ -119,26 +119,18 @@ export async function ReportIfTooLong(logger, eventName, action) {
     }
 }
 const summarizerClientType = "summarizer";
-/**
- * @deprecated - In the next release Container will no longer be exported, IContainer should be used in its place.
- */
 export class Container extends EventEmitterWithErrorHandling {
     /**
      * @internal
      */
-    constructor(loader, config, protocolHandlerBuilder) {
-        var _a, _b, _c;
+    constructor(createProps, loadProps) {
+        var _a;
         super((name, error) => {
             this.mc.logger.sendErrorEvent({
                 eventName: "ContainerEventHandlerException",
                 name: typeof name === "string" ? name : undefined,
             }, error);
         });
-        this.loader = loader;
-        this.protocolHandlerBuilder = protocolHandlerBuilder;
-        // Tells if container can reconnect on losing fist connection
-        // If false, container gets closed on loss of connection.
-        this._canReconnect = true;
         /**
          * Lifecycle state of the container, used mainly to prevent re-entrancy and telemetry
          *
@@ -164,28 +156,58 @@ 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.clientDetailsOverride = config.clientDetailsOverride;
-        this._resolvedUrl = config.resolvedUrl;
-        if (config.canReconnect !== undefined) {
-            this._canReconnect = config.canReconnect;
-        }
+        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;
+        this._canReconnect = canReconnect !== null && canReconnect !== void 0 ? canReconnect : true;
+        this.clientDetailsOverride = clientDetailsOverride;
+        this.urlResolver = urlResolver;
+        this.serviceFactory = documentServiceFactory;
+        this.codeLoader = codeLoader;
+        // Warning: this is only a shallow clone. Mutation of any individual loader option will mutate it for
+        // all clients that were loaded from the same loader (including summarizer clients).
+        // Tracking alternative ways to handle this in AB#4129.
+        this.options = Object.assign({}, options);
+        this.scope = scope;
+        this.detachedBlobStorage = detachedBlobStorage;
+        this.protocolHandlerBuilder =
+            protocolHandlerBuilder !== null && protocolHandlerBuilder !== void 0 ? protocolHandlerBuilder : ((...args) => new ProtocolHandler(...args, new Audience()));
+        // Note that we capture the createProps here so we can replicate the creation call when we want to clone.
+        this.clone = async (_loadProps, createParamOverrides) => {
+            return Container.load(_loadProps, Object.assign(Object.assign({}, createProps), createParamOverrides));
+        };
         // Create logger for data stores to use
         const type = this.client.details.type;
         const interactive = this.client.details.capabilities.interactive;
         const clientType = `${interactive ? "interactive" : "noninteractive"}${type !== undefined && type !== "" ? `/${type}` : ""}`;
         // Need to use the property getter for docId because for detached flow we don't have the docId initially.
         // We assign the id later so property getter is used.
-        this.subLogger = ChildLogger.create(loader.services.subLogger, undefined, {
+        this.subLogger = ChildLogger.create(subLogger, undefined, {
             all: {
                 clientType,
                 containerId: uuid(),
-                docId: () => { var _a, _b; return (_b = (_a = this._resolvedUrl) === null || _a === void 0 ? void 0 : _a.id) !== null && _b !== void 0 ? _b : undefined; },
+                docId: () => { var _a; return (_a = this.resolvedUrl) === null || _a === void 0 ? void 0 : _a.id; },
                 containerAttachState: () => this._attachState,
                 containerLifecycleState: () => this._lifecycleState,
                 containerConnectionState: () => ConnectionState[this.connectionState],
-                serializedContainer: config.serializedContainerState !== undefined,
+                serializedContainer: pendingLocalState !== undefined,
             },
             // we need to be judicious with our logging here to avoid generating too much data
             // all data logged here should be broadly applicable, and not specific to a
@@ -195,23 +217,24 @@ 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],
             },
         });
         // Prefix all events in this file with container-loader
         this.mc = loggerToMonitoringContext(ChildLogger.create(this.subLogger, "Container"));
-        // Warning: this is only a shallow clone. Mutation of any individual loader option will mutate it for
-        // all clients that were loaded from the same loader (including summarizer clients).
-        // Tracking alternative ways to handle this in AB#4129.
-        this.options = Object.assign({}, this.loader.services.options);
         this._deltaManager = this.createDeltaManager();
         this.connectionStateHandler = createConnectionStateHandler({
             logger: this.mc.logger,
@@ -227,7 +250,7 @@ export class Container extends EventEmitterWithErrorHandling {
                 }
             },
             shouldClientJoinWrite: () => this._deltaManager.connectionManager.shouldJoinWrite(),
-            maxClientLeaveWaitTime: this.loader.services.options.maxClientLeaveWaitTime,
+            maxClientLeaveWaitTime: options.maxClientLeaveWaitTime,
             logConnectionIssue: (eventName, category, details) => {
                 const mode = this.connectionMode;
                 // We get here when socket does not receive any ops on "write" connection, including
@@ -251,7 +274,10 @@ export class Container extends EventEmitterWithErrorHandling {
                     this.connect();
                 }
             },
-        }, this.deltaManager, (_a = config.serializedContainerState) === null || _a === void 0 ? void 0 : _a.clientId);
+            clientShouldHaveLeft: (clientId) => {
+                this.clientsWhoShouldHaveLeft.add(clientId);
+            },
+        }, this.deltaManager, pendingLocalState === null || pendingLocalState === void 0 ? void 0 : pendingLocalState.clientId);
         this.on(savedContainerEvent, () => {
             this.connectionStateHandler.containerSaved();
         });
@@ -263,8 +289,8 @@ export class Container extends EventEmitterWithErrorHandling {
             : combineAppAndProtocolSummary(summaryTree, this.captureProtocolSummary());
         // Whether the combined summary tree has been forced on by either the loader option or the monitoring context.
         // Even if not forced on via this flag, combined summaries may still be enabled by service policy.
-        const forceEnableSummarizeProtocolTree = (_b = this.mc.config.getBoolean("Fluid.Container.summarizeProtocolTree2")) !== null && _b !== void 0 ? _b : this.loader.services.options.summarizeProtocolTree;
-        this.storageAdapter = new ContainerStorageAdapter(this.loader.services.detachedBlobStorage, this.mc.logger, (_c = config.serializedContainerState) === null || _c === void 0 ? void 0 : _c.snapshotBlobs, addProtocolSummaryIfMissing, forceEnableSummarizeProtocolTree);
+        const forceEnableSummarizeProtocolTree = (_a = this.mc.config.getBoolean("Fluid.Container.summarizeProtocolTree2")) !== null && _a !== void 0 ? _a : options.summarizeProtocolTree;
+        this.storageAdapter = new ContainerStorageAdapter(detachedBlobStorage, this.mc.logger, pendingLocalState === null || pendingLocalState === void 0 ? void 0 : pendingLocalState.snapshotBlobs, addProtocolSummaryIfMissing, forceEnableSummarizeProtocolTree);
         const isDomAvailable = typeof document === "object" &&
             document !== null &&
             typeof document.addEventListener === "function" &&
@@ -290,33 +316,28 @@ export class Container extends EventEmitterWithErrorHandling {
      * Load an existing container.
      * @internal
      */
-    static async load(loader, loadOptions, pendingLocalState, protocolHandlerBuilder) {
-        const container = new Container(loader, {
-            clientDetailsOverride: loadOptions.clientDetailsOverride,
-            resolvedUrl: loadOptions.resolvedUrl,
-            canReconnect: loadOptions.canReconnect,
-            serializedContainerState: pendingLocalState,
-        }, protocolHandlerBuilder);
+    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) => {
-            var _a, _b;
-            const version = loadOptions.version;
             const defaultMode = { opsBeforeReturn: "cached" };
             // 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;
+                ? Object.assign(Object.assign({}, (loadMode !== null && loadMode !== void 0 ? loadMode : defaultMode)), { opsBeforeReturn: undefined }) : loadMode !== null && loadMode !== void 0 ? loadMode : 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"));
             };
             container.on("closed", onClosed);
             container
-                .load(version, mode, pendingLocalState)
+                .load(version, mode, resolvedUrl, pendingLocalState)
                 .finally(() => {
                 container.removeListener("closed", onClosed);
             })
                 .then((props) => {
-                event.end(Object.assign(Object.assign({}, props), loadOptions.loadMode));
+                event.end(Object.assign(Object.assign({}, props), loadMode));
                 resolve(container);
             }, (error) => {
                 const err = normalizeError(error);
@@ -326,13 +347,13 @@ 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.
      */
-    static async createDetached(loader, codeDetails, protocolHandlerBuilder) {
-        const container = new Container(loader, {}, protocolHandlerBuilder);
+    static async createDetached(createProps, codeDetails) {
+        const container = new Container(createProps);
         return PerformanceEvent.timedExecAsync(container.mc.logger, { eventName: "CreateDetached" }, async (_event) => {
             await container.createDetached(codeDetails);
             return container;
@@ -342,8 +363,8 @@ export class Container extends EventEmitterWithErrorHandling {
      * Create a new container in a detached state that is initialized with a
      * snapshot from a previous detached container.
      */
-    static async rehydrateDetachedFromSnapshot(loader, snapshot, protocolHandlerBuilder) {
-        const container = new Container(loader, {}, protocolHandlerBuilder);
+    static async rehydrateDetachedFromSnapshot(createProps, snapshot) {
+        const container = new Container(createProps);
         return PerformanceEvent.timedExecAsync(container.mc.logger, { eventName: "RehydrateDetachedFromSnapshot" }, async (_event) => {
             const deserializedSummary = JSON.parse(snapshot);
             await container.rehydrateDetachedFromSnapshot(deserializedSummary);
@@ -365,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) {
@@ -387,17 +405,23 @@ export class Container extends EventEmitterWithErrorHandling {
         return this;
     }
     get resolvedUrl() {
-        return this._resolvedUrl;
-    }
-    get loadedFromVersion() {
-        return this._loadedFromVersion;
+        var _a;
+        /**
+         * All attached containers will have a document service,
+         * this is required, as attached containers are attached to
+         * a service. Detached containers will neither have a document
+         * service or a resolved url as they only exist locally.
+         * in order to create a document service a resolved url must
+         * first be obtained, this is how the container is identified.
+         * Because of this, the document service's resolved url
+         * is always the same as the containers, as we had to
+         * obtain the resolved url, and then create the service from it.
+         */
+        return (_a = this.service) === null || _a === void 0 ? void 0 : _a.resolvedUrl;
     }
     get readOnlyInfo() {
         return this._deltaManager.readOnlyInfo;
     }
-    get closeSignal() {
-        return this._deltaManager.closeAbortController.signal;
-    }
     /**
      * Tracks host requiring read-only mode.
      */
@@ -413,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
@@ -427,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.
@@ -456,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
@@ -473,49 +479,31 @@ export class Container extends EventEmitterWithErrorHandling {
     get isDirty() {
         return this._dirtyContainer;
     }
-    get serviceFactory() {
-        return this.loader.services.documentServiceFactory;
-    }
-    get urlResolver() {
-        return this.loader.services.urlResolver;
-    }
-    get scope() {
-        return this.loader.services.scope;
-    }
-    get codeLoader() {
-        return this.loader.services.codeLoader;
-    }
     /**
      * {@inheritDoc @fluidframework/container-definitions#IContainer.entryPoint}
      */
     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
@@ -524,7 +512,7 @@ export class Container extends EventEmitterWithErrorHandling {
         return this.protocolHandler.quorum;
     }
     dispose(error) {
-        this._deltaManager.close(error, true /* doDispose */);
+        this._deltaManager.dispose(error);
         this.verifyClosed();
     }
     close(error) {
@@ -540,7 +528,7 @@ export class Container extends EventEmitterWithErrorHandling {
         assert(this._lifecycleState === "closed" || this._lifecycleState === "disposed", 0x314 /* Container properly closed */);
     }
     closeCore(error) {
-        var _a, _b, _c;
+        var _a;
         assert(!this.closed, 0x315 /* re-entrancy */);
         try {
             // Ensure that we raise all key events even if one of these throws
@@ -558,12 +546,6 @@ export class Container extends EventEmitterWithErrorHandling {
                 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);
-                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.
-                // Driver need to ensure all caches are cleared on critical errors
-                (_c = this.service) === null || _c === void 0 ? void 0 : _c.dispose(error);
             }
             catch (exception) {
                 this.mc.logger.sendErrorEvent({ eventName: "ContainerCloseException" }, exception);
@@ -575,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) {
@@ -588,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") {
@@ -596,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.
@@ -614,6 +602,7 @@ export class Container extends EventEmitterWithErrorHandling {
         }
         finally {
             this._lifecycleState = "disposed";
+            this._lifecycleEvents.emit("disposed");
         }
     }
     closeAndGetPendingLocalState() {
@@ -628,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,
@@ -649,11 +641,10 @@ 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.loader.services.detachedBlobStorage &&
-            this.loader.services.detachedBlobStorage.size > 0) {
+        if (this.detachedBlobStorage && this.detachedBlobStorage.size > 0) {
             combinedSummary.tree[".hasAttachmentBlobs"] = {
                 type: SummaryType.Blob,
                 content: "true",
@@ -672,15 +663,14 @@ export class Container extends EventEmitterWithErrorHandling {
             assert(this._attachState === AttachState.Detached && !this.attachStarted, 0x205 /* "attach() called more than once" */);
             this.attachStarted = true;
             // If attachment blobs were uploaded in detached state we will go through a different attach flow
-            const hasAttachmentBlobs = this.loader.services.detachedBlobStorage !== undefined &&
-                this.loader.services.detachedBlobStorage.size > 0;
+            const hasAttachmentBlobs = this.detachedBlobStorage !== undefined && this.detachedBlobStorage.size > 0;
             try {
                 assert(this.deltaManager.inbound.length === 0, 0x0d6 /* "Inbound queue should be empty when attaching" */);
                 let summary;
                 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.
@@ -688,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);
@@ -697,40 +688,38 @@ export class Container extends EventEmitterWithErrorHandling {
                     }
                 }
                 // Actually go and create the resolved document
-                const createNewResolvedUrl = await this.urlResolver.resolve(request);
-                ensureFluidResolvedUrl(createNewResolvedUrl);
                 if (this.service === undefined) {
-                    assert(this.client.details.type !== summarizerClientType, 0x2c4 /* "client should not be summarizer before container is created" */);
+                    const createNewResolvedUrl = await this.urlResolver.resolve(request);
+                    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,
                     });
                 }
-                const resolvedUrl = this.service.resolvedUrl;
-                ensureFluidResolvedUrl(resolvedUrl);
-                this._resolvedUrl = resolvedUrl;
                 await this.storageAdapter.connectToService(this.service);
                 if (hasAttachmentBlobs) {
                     // upload blobs to storage
-                    assert(!!this.loader.services.detachedBlobStorage, 0x24e /* "assertion for type narrowing" */);
+                    assert(!!this.detachedBlobStorage, 0x24e /* "assertion for type narrowing" */);
                     // build a table mapping IDs assigned locally to IDs assigned by storage and pass it to runtime to
                     // support blob handles that only know about the local IDs
                     const redirectTable = new Map();
                     // if new blobs are added while uploading, upload them too
-                    while (redirectTable.size < this.loader.services.detachedBlobStorage.size) {
-                        const newIds = this.loader.services.detachedBlobStorage
+                    while (redirectTable.size < this.detachedBlobStorage.size) {
+                        const newIds = this.detachedBlobStorage
                             .getBlobIds()
                             .filter((id) => !redirectTable.has(id));
                         for (const id of newIds) {
-                            const blob = await this.loader.services.detachedBlobStorage.readBlob(id);
+                            const blob = await this.detachedBlobStorage.readBlob(id);
                             const response = await this.storageAdapter.createBlob(blob);
                             redirectTable.set(id, response.id);
                         }
                     }
                     // 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);
@@ -745,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({
@@ -756,18 +746,14 @@ export class Container extends EventEmitterWithErrorHandling {
             catch (error) {
                 // add resolved URL on error object so that host has the ability to find this document and delete it
                 const newError = normalizeError(error);
-                const resolvedUrl = this.resolvedUrl;
-                if (isFluidResolvedUrl(resolvedUrl)) {
-                    newError.addTelemetryProperties({ resolvedUrl: resolvedUrl.url });
-                }
+                newError.addTelemetryProperties({ resolvedUrl: (_a = this.resolvedUrl) === null || _a === void 0 ? void 0 : _a.url });
                 this.close(newError);
-                (_a = this.dispose) === null || _a === void 0 ? void 0 : _a.call(this, newError);
                 throw newError;
             }
         }, { 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;
@@ -833,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");
@@ -856,13 +835,12 @@ export class Container extends EventEmitterWithErrorHandling {
             .catch(() => false);
     }
     async processCodeProposal() {
-        var _a;
         const codeDetails = this.getCodeDetailsFromQuorum();
         await Promise.all([
             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;
@@ -870,19 +848,44 @@ export class Container extends EventEmitterWithErrorHandling {
         // pre-0.58 error message: existingContextDoesNotSatisfyIncomingProposal
         const error = new GenericError("Existing context does not satisfy incoming proposal");
         this.close(error);
-        (_a = this.dispose) === null || _a === void 0 ? void 0 : _a.call(this, 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];
     }
-    recordConnectStartTime() {
-        if (this.connectionTransitionTimes[ConnectionState.Disconnected] === undefined) {
-            this.connectionTransitionTimes[ConnectionState.Disconnected] = performance.now();
-        }
-    }
     connectToDeltaStream(args) {
-        this.recordConnectStartTime();
         // All agents need "write" access, including summarizer.
         if (!this._canReconnect || !this.client.details.capabilities.interactive) {
             args.mode = "write";
@@ -894,12 +897,9 @@ export class Container extends EventEmitterWithErrorHandling {
      *
      * @param specifiedVersion - Version SHA to load snapshot. If not specified, will fetch the latest snapshot.
      */
-    async load(specifiedVersion, loadMode, pendingLocalState) {
-        var _a;
-        if (this._resolvedUrl === undefined) {
-            throw new Error("Attempting to load without a resolved url");
-        }
-        this.service = await this.serviceFactory.createDocumentService(this._resolvedUrl, this.subLogger, this.client.details.type === summarizerClientType);
+    async load(specifiedVersion, loadMode, resolvedUrl, pendingLocalState) {
+        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.
         // We should not rely on it by (one of them will address the issue, but we need to address both)
@@ -925,9 +925,7 @@ export class Container extends EventEmitterWithErrorHandling {
         else {
             // if we have pendingLocalState we can load without storage; don't wait for connection
             this.storageAdapter.connectToService(this.service).catch((error) => {
-                var _a;
                 this.close(error);
-                (_a = this.dispose) === null || _a === void 0 ? void 0 : _a.call(this, error);
             });
         }
         this._attachState = AttachState.Attached;
@@ -944,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);
@@ -980,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
@@ -1053,8 +1051,7 @@ export class Container extends EventEmitterWithErrorHandling {
     }
     async rehydrateDetachedFromSnapshot(detachedContainerSnapshot) {
         if (detachedContainerSnapshot.tree[".hasAttachmentBlobs"] !== undefined) {
-            assert(!!this.loader.services.detachedBlobStorage &&
-                this.loader.services.detachedBlobStorage.size > 0, 0x250 /* "serialized container with attachment blobs must be rehydrated with detached blob storage" */);
+            assert(!!this.detachedBlobStorage && this.detachedBlobStorage.size > 0, 0x250 /* "serialized container with attachment blobs must be rehydrated with detached blob storage" */);
             delete detachedContainerSnapshot.tree[".hasAttachmentBlobs"];
         }
         const snapshotTree = getSnapshotTreeFromSerializedContainer(detachedContainerSnapshot);
@@ -1107,9 +1104,7 @@ export class Container extends EventEmitterWithErrorHandling {
         this.initializeProtocolState(attributes, quorumSnapshot);
     }
     initializeProtocolState(attributes, quorumSnapshot) {
-        var _a;
-        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, JSON.stringify({ key, value })));
+        const protocol = this.protocolHandlerBuilder(attributes, quorumSnapshot, (key, value) => this.submitMessage(MessageType.Propose, JSON.stringify({ key, value })));
         const protocolLogger = ChildLogger.create(this.subLogger, "ProtocolHandler");
         protocol.quorum.on("error", (error) => {
             protocolLogger.sendErrorEvent(error);
@@ -1129,10 +1124,8 @@ export class Container extends EventEmitterWithErrorHandling {
                     });
                 }
                 this.processCodeProposal().catch((error) => {
-                    var _a;
                     const normalizedError = normalizeError(error);
                     this.close(normalizedError);
-                    (_a = this.dispose) === null || _a === void 0 ? void 0 : _a.call(this, normalizedError);
                     throw error;
                 });
             }
@@ -1216,9 +1209,15 @@ export class Container extends EventEmitterWithErrorHandling {
             assert(this.connectionMode === details.mode, 0x4b7 /* mismatch */);
             this.connectionStateHandler.receivedConnectEvent(details);
         });
+        deltaManager.on("establishingConnection", (reason) => {
+            this.connectionStateHandler.establishingConnection(reason);
+        });
+        deltaManager.on("cancelEstablishingConnection", (reason) => {
+            this.connectionStateHandler.cancelEstablishingConnection(reason);
+        });
         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);
             }
@@ -1272,10 +1271,12 @@ export class Container extends EventEmitterWithErrorHandling {
                     time - this.connectionTransitionTimes[ConnectionState.Disconnected];
                 durationFromDisconnected = TelemetryLogger.formatTick(durationFromDisconnected);
             }
-            else {
-                // This info is of most interest on establishing connection only.
+            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;
                 }
             }
@@ -1322,7 +1323,6 @@ export class Container extends EventEmitterWithErrorHandling {
     }
     // back-compat: ADO #1385: Remove in the future, summary op should come through submitSummaryMessage()
     submitContainerMessage(type, contents, batch, metadata) {
-        var _a;
         switch (type) {
             case MessageType.Operation:
                 return this.submitMessage(type, JSON.stringify(contents), batch, metadata);
@@ -1331,7 +1331,6 @@ export class Container extends EventEmitterWithErrorHandling {
             default: {
                 const newError = new GenericError("invalidContainerSubmitOpType", undefined /* error */, { messageType: type });
                 this.close(newError);
-                (_a = this.dispose) === null || _a === void 0 ? void 0 : _a.call(this, newError);
                 return -1;
             }
         }
@@ -1364,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) {
@@ -1372,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);
     }
@@ -1398,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);
         }
     }
     /**
@@ -1436,20 +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 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), (summaryOp, referenceSequenceNumber) => this.submitSummaryMessage(summaryOp, referenceSequenceNumber), (batch, referenceSequenceNumber) => this.submitBatch(batch, referenceSequenceNumber), (message) => this.submitSignal(message), (error) => { var _a; return (_a = this.dispose) === null || _a === void 0 ? void 0 : _a.call(this, 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 maybeLoader = this.scope;
+        const loader = new RelativeLoader(this, maybeLoader.ILoader);
+        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
@@ -1459,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