@fluidframework/container-loader 2.0.0-dev.5.2.0.169897 → 2.0.0-dev.6.4.0.191258

package/dist/container.js

@@ -11,9 +11,10 @@ exports.Container = exports.ReportIfTooLong = exports.waitContainerToCatchUp = v
 // eslint-disable-next-line import/no-internal-modules
 const merge_1 = __importDefault(require("lodash/merge"));
 const uuid_1 = require("uuid");
-const common_utils_1 = require("@fluidframework/common-utils");
+const core_utils_1 = require("@fluidframework/core-utils");
+const client_utils_1 = require("@fluid-internal/client-utils");
+const core_interfaces_1 = require("@fluidframework/core-interfaces");
 const container_definitions_1 = require("@fluidframework/container-definitions");
-const container_utils_1 = require("@fluidframework/container-utils");
 const driver_utils_1 = require("@fluidframework/driver-utils");
 const protocol_definitions_1 = require("@fluidframework/protocol-definitions");
 const telemetry_utils_1 = require("@fluidframework/telemetry-utils");
@@ -21,20 +22,20 @@ const audience_1 = require("./audience");
 const containerContext_1 = require("./containerContext");
 const contracts_1 = require("./contracts");
 const deltaManager_1 = require("./deltaManager");
-const deltaManagerProxy_1 = require("./deltaManagerProxy");
 const loader_1 = require("./loader");
 const packageVersion_1 = require("./packageVersion");
 const containerStorageAdapter_1 = require("./containerStorageAdapter");
 const connectionStateHandler_1 = require("./connectionStateHandler");
 const utils_1 = require("./utils");
 const quorum_1 = require("./quorum");
-const collabWindowTracker_1 = require("./collabWindowTracker");
+const noopHeuristic_1 = require("./noopHeuristic");
 const connectionManager_1 = require("./connectionManager");
 const connectionState_1 = require("./connectionState");
 const protocol_1 = require("./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.
  *
@@ -54,7 +55,7 @@ const savedContainerEvent = "saved";
 async function waitContainerToCatchUp(container) {
     // Make sure we stop waiting if container is closed.
     if (container.closed) {
-        throw new container_utils_1.UsageError("waitContainerToCatchUp: Container closed");
+        throw new telemetry_utils_1.UsageError("waitContainerToCatchUp: Container closed");
     }
     return new Promise((resolve, reject) => {
         const deltaManager = container.deltaManager;
@@ -62,8 +63,8 @@ async function waitContainerToCatchUp(container) {
             container.off("closed", closedCallback);
             const baseMessage = "Container closed while waiting to catch up";
             reject(err !== undefined
-                ? (0, telemetry_utils_1.wrapError)(err, (innerMessage) => new container_utils_1.GenericError(`${baseMessage}: ${innerMessage}`))
-                : new container_utils_1.GenericError(baseMessage));
+                ? (0, telemetry_utils_1.wrapError)(err, (innerMessage) => new telemetry_utils_1.GenericError(`${baseMessage}: ${innerMessage}`))
+                : new telemetry_utils_1.GenericError(baseMessage));
         };
         container.on("closed", closedCallback);
         // Depending on config, transition to "connected" state may include the guarantee
@@ -71,11 +72,11 @@ async function waitContainerToCatchUp(container) {
         // Waiting for "connected" state in either case gets us at least to our own Join op
         // which is a reasonable approximation of "caught up"
         const waitForOps = () => {
-            (0, common_utils_1.assert)(container.connectionState === connectionState_1.ConnectionState.CatchingUp ||
+            (0, core_utils_1.assert)(container.connectionState === connectionState_1.ConnectionState.CatchingUp ||
                 container.connectionState === connectionState_1.ConnectionState.Connected, 0x0cd /* "Container disconnected while waiting for ops!" */);
             const hasCheckpointSequenceNumber = deltaManager.hasCheckpointSequenceNumber;
             const connectionOpSeqNumber = deltaManager.lastKnownSeqNumber;
-            (0, common_utils_1.assert)(deltaManager.lastSequenceNumber <= connectionOpSeqNumber, 0x266 /* "lastKnownSeqNumber should never be below last processed sequence number" */);
+            (0, core_utils_1.assert)(deltaManager.lastSequenceNumber <= connectionOpSeqNumber, 0x266 /* "lastKnownSeqNumber should never be below last processed sequence number" */);
             if (deltaManager.lastSequenceNumber === connectionOpSeqNumber) {
                 container.off("closed", closedCallback);
                 resolve(hasCheckpointSequenceNumber);
@@ -111,7 +112,7 @@ async function waitContainerToCatchUp(container) {
 exports.waitContainerToCatchUp = waitContainerToCatchUp;
 const getCodeProposal = 
 // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-(quorum) => { var _a; return (_a = quorum.get("code")) !== null && _a !== void 0 ? _a : quorum.get("code2"); };
+(quorum) => quorum.get("code") ?? quorum.get("code2");
 /**
  * Helper function to report to telemetry cases where operation takes longer than expected (200ms)
  * @param logger - logger to use
@@ -132,7 +133,6 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
      * @internal
      */
     constructor(createProps, loadProps) {
-        var _a;
         super((name, error) => {
             this.mc.logger.sendErrorEvent({
                 eventName: "ContainerEventHandlerException",
@@ -160,16 +160,31 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         this.inboundQueuePausedFromInit = true;
         this.firstConnection = true;
         this.connectionTransitionTimes = [];
-        this.messageCountAfterDisconnection = 0;
         this.attachStarted = false;
         this._dirtyContainer = false;
         this.savedOps = [];
-        this.setAutoReconnectTime = common_utils_1.performance.now();
+        this.clientsWhoShouldHaveLeft = new Set();
+        this.setAutoReconnectTime = client_utils_1.performance.now();
+        this._lifecycleEvents = new client_utils_1.TypedEventEmitter();
         this._disposed = false;
+        this.getAbsoluteUrl = async (relativeUrl) => {
+            if (this.resolvedUrl === undefined) {
+                return undefined;
+            }
+            return this.urlResolver.getAbsoluteUrl(this.resolvedUrl, relativeUrl, (0, contracts_1.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_1.ConnectionState.Disconnected] = common_utils_1.performance.now();
-        const pendingLocalState = loadProps === null || loadProps === void 0 ? void 0 : loadProps.pendingLocalState;
-        this._canReconnect = canReconnect !== null && canReconnect !== void 0 ? canReconnect : true;
+        this.connectionTransitionTimes[connectionState_1.ConnectionState.Disconnected] = client_utils_1.performance.now();
+        const pendingLocalState = loadProps?.pendingLocalState;
+        this._clientId = pendingLocalState?.clientId;
+        this._canReconnect = canReconnect ?? true;
         this.clientDetailsOverride = clientDetailsOverride;
         this.urlResolver = urlResolver;
         this.serviceFactory = documentServiceFactory;
@@ -177,14 +192,18 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         // 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.options = { ...options };
         this.scope = scope;
         this.detachedBlobStorage = detachedBlobStorage;
         this.protocolHandlerBuilder =
-            protocolHandlerBuilder !== null && protocolHandlerBuilder !== void 0 ? protocolHandlerBuilder : ((...args) => new protocol_1.ProtocolHandler(...args, new audience_1.Audience()));
+            protocolHandlerBuilder ??
+                ((attributes, quorumSnapshot, sendProposal) => new protocol_1.ProtocolHandler(attributes, quorumSnapshot, sendProposal, new audience_1.Audience(), (clientId) => this.clientsWhoShouldHaveLeft.has(clientId)));
         // 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));
+            return Container.load(_loadProps, {
+                ...createProps,
+                ...createParamOverrides,
+            });
         };
         // Create logger for data stores to use
         const type = this.client.details.type;
@@ -192,45 +211,50 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         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 = telemetry_utils_1.ChildLogger.create(subLogger, undefined, {
-            all: {
-                clientType,
-                containerId: (0, uuid_1.v4)(),
-                docId: () => { var _a; return (_a = this.resolvedUrl) === null || _a === void 0 ? void 0 : _a.id; },
-                containerAttachState: () => this._attachState,
-                containerLifecycleState: () => this._lifecycleState,
-                containerConnectionState: () => connectionState_1.ConnectionState[this.connectionState],
-                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
-            // specific error or class of errors
-            error: {
-                // load information to associate errors with the specific load point
-                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; },
-                // 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; },
-                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: () => common_utils_1.performance.now() - this.connectionTransitionTimes[this.connectionState],
+        this.subLogger = (0, telemetry_utils_1.createChildLogger)({
+            logger: subLogger,
+            properties: {
+                all: {
+                    clientType,
+                    containerId: (0, uuid_1.v4)(),
+                    docId: () => this.resolvedUrl?.id,
+                    containerAttachState: () => this._attachState,
+                    containerLifecycleState: () => this._lifecycleState,
+                    containerConnectionState: () => connectionState_1.ConnectionState[this.connectionState],
+                    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
+                // specific error or class of errors
+                error: {
+                    // load information to associate errors with the specific load point
+                    dmInitialSeqNumber: () => this._deltaManager?.initialSequenceNumber,
+                    dmLastProcessedSeqNumber: () => this._deltaManager?.lastSequenceNumber,
+                    dmLastKnownSeqNumber: () => this._deltaManager?.lastKnownSeqNumber,
+                    containerLoadedFromVersionId: () => this._loadedFromVersion?.id,
+                    containerLoadedFromVersionDate: () => this._loadedFromVersion?.date,
+                    // message information to associate errors with the specific execution state
+                    // dmLastMsqSeqNumber: if present, same as dmLastProcessedSeqNumber
+                    dmLastMsqSeqNumber: () => this.deltaManager?.lastMessage?.sequenceNumber,
+                    dmLastMsqSeqTimestamp: () => this.deltaManager?.lastMessage?.timestamp,
+                    dmLastMsqSeqClientId: () => this.deltaManager?.lastMessage?.clientId === null
+                        ? "null"
+                        : this.deltaManager?.lastMessage?.clientId,
+                    dmLastMsgClientSeq: () => this.deltaManager?.lastMessage?.clientSequenceNumber,
+                    connectionStateDuration: () => client_utils_1.performance.now() - this.connectionTransitionTimes[this.connectionState],
+                },
             },
         });
         // Prefix all events in this file with container-loader
-        this.mc = (0, telemetry_utils_1.loggerToMonitoringContext)(telemetry_utils_1.ChildLogger.create(this.subLogger, "Container"));
+        this.mc = (0, telemetry_utils_1.createChildMonitoringContext)({ logger: this.subLogger, namespace: "Container" });
         this._deltaManager = this.createDeltaManager();
         this.connectionStateHandler = (0, connectionStateHandler_1.createConnectionStateHandler)({
             logger: this.mc.logger,
-            connectionStateChanged: (value, oldState, reason, error) => {
+            connectionStateChanged: (value, oldState, reason) => {
                 if (value === connectionState_1.ConnectionState.Connected) {
                     this._clientId = this.connectionStateHandler.pendingClientId;
                 }
-                this.logConnectionStateChangeTelemetry(value, oldState, reason, error);
+                this.logConnectionStateChangeTelemetry(value, oldState, reason);
                 if (this._lifecycleState === "loaded") {
                     this.propagateConnectionState(false /* initial transition */, value === connectionState_1.ConnectionState.Disconnected
                         ? reason
@@ -246,9 +270,14 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                 // Report issues only if we already loaded container - op processing is paused while container is loading,
                 // so we always time-out processing of join op in cases where fetching snapshot takes a minute.
                 // It's not a problem with op processing itself - such issues should be tracked as part of boot perf monitoring instead.
-                this._deltaManager.logConnectionIssue(Object.assign({ eventName,
-                    mode, category: this._lifecycleState === "loading" ? "generic" : category, duration: common_utils_1.performance.now() -
-                        this.connectionTransitionTimes[connectionState_1.ConnectionState.CatchingUp] }, (details === undefined ? {} : { details: JSON.stringify(details) })));
+                this._deltaManager.logConnectionIssue({
+                    eventName,
+                    mode,
+                    category: this._lifecycleState === "loading" ? "generic" : category,
+                    duration: client_utils_1.performance.now() -
+                        this.connectionTransitionTimes[connectionState_1.ConnectionState.CatchingUp],
+                    ...(details === undefined ? {} : { details: JSON.stringify(details) }),
+                });
                 // If this is "write" connection, it took too long to receive join op. But in most cases that's due
                 // to very slow op fetches and we will eventually get there.
                 // For "read" connections, we get here due to self join signal not arriving on time. We will need to
@@ -258,11 +287,15 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                 // Other possible recovery path - move to connected state (i.e. ConnectionStateHandler.joinOpTimer
                 // to call this.applyForConnectedState("addMemberEvent") for "read" connections)
                 if (mode === "read") {
-                    this.disconnect();
-                    this.connect();
+                    const reason = { text: "NoJoinSignal" };
+                    this.disconnectInternal(reason);
+                    this.connectInternal({ reason, fetchOpsFromStorage: false });
                 }
             },
-        }, this.deltaManager, pendingLocalState === null || pendingLocalState === void 0 ? void 0 : pendingLocalState.clientId);
+            clientShouldHaveLeft: (clientId) => {
+                this.clientsWhoShouldHaveLeft.add(clientId);
+            },
+        }, this.deltaManager, pendingLocalState?.clientId);
         this.on(savedContainerEvent, () => {
             this.connectionStateHandler.containerSaved();
         });
@@ -271,21 +304,22 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         // using this callback and fix them up.
         const addProtocolSummaryIfMissing = (summaryTree) => (0, driver_utils_1.isCombinedAppAndProtocolSummary)(summaryTree) === true
             ? summaryTree
-            : (0, driver_utils_1.combineAppAndProtocolSummary)(summaryTree, this.captureProtocolSummary());
+            : (0, utils_1.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 = (_a = this.mc.config.getBoolean("Fluid.Container.summarizeProtocolTree2")) !== null && _a !== void 0 ? _a : options.summarizeProtocolTree;
-        this.storageAdapter = new containerStorageAdapter_1.ContainerStorageAdapter(detachedBlobStorage, this.mc.logger, pendingLocalState === null || pendingLocalState === void 0 ? void 0 : pendingLocalState.snapshotBlobs, addProtocolSummaryIfMissing, forceEnableSummarizeProtocolTree);
+        const forceEnableSummarizeProtocolTree = this.mc.config.getBoolean("Fluid.Container.summarizeProtocolTree2") ??
+            options.summarizeProtocolTree;
+        this.storageAdapter = new containerStorageAdapter_1.ContainerStorageAdapter(detachedBlobStorage, this.mc.logger, pendingLocalState?.snapshotBlobs, addProtocolSummaryIfMissing, forceEnableSummarizeProtocolTree);
         const isDomAvailable = typeof document === "object" &&
             document !== null &&
             typeof document.addEventListener === "function" &&
             document.addEventListener !== null;
-        // keep track of last time page was visible for telemetry
-        if (isDomAvailable) {
-            this.lastVisible = document.hidden ? common_utils_1.performance.now() : undefined;
+        // keep track of last time page was visible for telemetry (on interactive clients only)
+        if (isDomAvailable && interactive) {
+            this.lastVisible = document.hidden ? client_utils_1.performance.now() : undefined;
             this.visibilityEventHandler = () => {
                 if (document.hidden) {
-                    this.lastVisible = common_utils_1.performance.now();
+                    this.lastVisible = client_utils_1.performance.now();
                 }
                 else {
                     // settimeout so this will hopefully fire after disconnect event if being hidden caused it
@@ -302,7 +336,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
      * @internal
      */
     static async load(loadProps, createProps) {
-        const { version, pendingLocalState, loadMode, resolvedUrl } = loadProps;
+        const { version, pendingLocalState, loadMode, resolvedUrl, loadToSequenceNumber } = loadProps;
         const container = new Container(createProps, loadProps);
         const disableRecordHeapSize = container.mc.config.getBoolean("Fluid.Loader.DisableRecordHeapSize");
         return telemetry_utils_1.PerformanceEvent.timedExecAsync(container.mc.logger, { eventName: "Load" }, async (event) => new Promise((resolve, reject) => {
@@ -310,26 +344,31 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             // 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({}, (loadMode !== null && loadMode !== void 0 ? loadMode : defaultMode)), { opsBeforeReturn: undefined }) : loadMode !== null && loadMode !== void 0 ? loadMode : defaultMode;
+                ? { ...(loadMode ?? defaultMode), opsBeforeReturn: undefined }
+                : loadMode ?? defaultMode;
             const onClosed = (err) => {
                 // pre-0.58 error message: containerClosedWithoutErrorDuringLoad
-                reject(err !== null && err !== void 0 ? err : new container_utils_1.GenericError("Container closed without error during load"));
+                reject(err ?? new telemetry_utils_1.GenericError("Container closed without error during load"));
             };
             container.on("closed", onClosed);
             container
-                .load(version, mode, resolvedUrl, pendingLocalState)
+                .load(version, mode, resolvedUrl, pendingLocalState, loadToSequenceNumber)
                 .finally(() => {
                 container.removeListener("closed", onClosed);
             })
                 .then((props) => {
-                event.end(Object.assign(Object.assign({}, props), loadMode));
+                event.end({ ...props, ...loadMode });
                 resolve(container);
             }, (error) => {
                 const err = (0, telemetry_utils_1.normalizeError)(error);
                 // Depending where error happens, we can be attempting to connect to web socket
                 // and continuously retrying (consider offline mode)
                 // Host has no container to close, so it's prudent to do it here
+                // Note: We could only dispose the container instead of just close but that would
+                // the telemetry where users sometimes search for ContainerClose event to look
+                // for load failures. So not removing this at this time.
                 container.close(err);
+                container.dispose(err);
                 onClosed(err);
             });
         }), { start: true, end: true, cancel: "generic" }, disableRecordHeapSize !== true /* recordHeapSize */);
@@ -366,19 +405,16 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         }
     }
     get closed() {
-        return (this._lifecycleState === "closing" ||
-            this._lifecycleState === "closed" ||
-            this._lifecycleState === "disposing" ||
-            this._lifecycleState === "disposed");
+        return (this._lifecycleState === "closing" || this._lifecycleState === "closed" || this.disposed);
     }
-    get storage() {
-        return this.storageAdapter;
+    get disposed() {
+        return this._lifecycleState === "disposing" || this._lifecycleState === "disposed";
     }
-    get context() {
-        if (this._context === undefined) {
-            throw new container_utils_1.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) {
@@ -393,7 +429,6 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         return this;
     }
     get resolvedUrl() {
-        var _a;
         /**
          * All attached containers will have a document service,
          * this is required, as attached containers are attached to
@@ -405,17 +440,11 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
          * 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 loadedFromVersion() {
-        return this._loadedFromVersion;
+        return this.service?.resolvedUrl;
     }
     get readOnlyInfo() {
         return this._deltaManager.readOnlyInfo;
     }
-    get closeSignal() {
-        return this._deltaManager.closeAbortController.signal;
-    }
     /**
      * Tracks host requiring read-only mode.
      */
@@ -431,13 +460,6 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
     get connected() {
         return this.connectionStateHandler.connectionState === connectionState_1.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
@@ -445,21 +467,11 @@ class Container extends telemetry_utils_1.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;
+        const enabled = this.mc.config.getBoolean("Fluid.Container.enableOfflineLoad") ??
+            this.options?.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.
@@ -474,8 +486,7 @@ class Container extends telemetry_utils_1.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
@@ -495,33 +506,25 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
      * {@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 container_utils_1.UsageError("The container is disposing or disposed");
+        if (this._disposed) {
+            throw new telemetry_utils_1.UsageError("The context is already 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.
-            (0, common_utils_1.assert)(this._context !== undefined, 0x5a2 /* Context still not defined after contextChanged event */);
+        if (this._runtime !== undefined) {
+            return this._runtime.getEntryPoint?.();
         }
-        // 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 = () => {
+                (0, core_utils_1.assert)(this._runtime !== undefined, 0x5a3 /* runtimeInstantiated fired but runtime is still undefined */);
+                resolve(this._runtime.getEntryPoint?.());
+                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
@@ -542,12 +545,11 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         this.verifyClosed();
     }
     verifyClosed() {
-        (0, common_utils_1.assert)(this.connectionState === connectionState_1.ConnectionState.Disconnected, 0x0cf /* "disconnect event was not raised!" */);
-        (0, common_utils_1.assert)(this._lifecycleState === "closed" || this._lifecycleState === "disposed", 0x314 /* Container properly closed */);
+        (0, core_utils_1.assert)(this.connectionState === connectionState_1.ConnectionState.Disconnected, 0x0cf /* "disconnect event was not raised!" */);
+        (0, core_utils_1.assert)(this._lifecycleState === "closed" || this._lifecycleState === "disposed", 0x314 /* Container properly closed */);
     }
     closeCore(error) {
-        var _a;
-        (0, common_utils_1.assert)(!this.closed, 0x315 /* re-entrancy */);
+        (0, core_utils_1.assert)(!this.closed, 0x315 /* re-entrancy */);
         try {
             // Ensure that we raise all key events even if one of these throws
             try {
@@ -562,7 +564,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                         : "generic",
                 }, error);
                 this._lifecycleState = "closing";
-                (_a = this._protocolHandler) === null || _a === void 0 ? void 0 : _a.close();
+                this._protocolHandler?.close();
                 this.connectionStateHandler.dispose();
             }
             catch (exception) {
@@ -575,11 +577,14 @@ class Container extends telemetry_utils_1.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) {
-        var _a, _b, _c;
-        (0, common_utils_1.assert)(!this._disposed, 0x54c /* Container already disposed */);
+        (0, core_utils_1.assert)(!this._disposed, 0x54c /* Container already disposed */);
         this._disposed = true;
         try {
             // Ensure that we raise all key events even if one of these throws
@@ -588,20 +593,22 @@ class Container extends telemetry_utils_1.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") {
                     this._lifecycleState = "disposing";
                 }
-                (_a = this._protocolHandler) === null || _a === void 0 ? void 0 : _a.close();
+                this._protocolHandler?.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;
+                this._runtime?.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.
                 // Driver need to ensure all caches are cleared on critical errors
-                (_c = this.service) === null || _c === void 0 ? void 0 : _c.dispose(error);
+                this.service?.dispose(error);
             }
             catch (exception) {
                 this.mc.logger.sendErrorEvent({ eventName: "ContainerDisposeException" }, exception);
@@ -614,44 +621,60 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         }
         finally {
             this._lifecycleState = "disposed";
+            this._lifecycleEvents.emit("disposed");
         }
     }
-    closeAndGetPendingLocalState() {
+    async closeAndGetPendingLocalState() {
         // runtime matches pending ops to successful ones by clientId and client seq num, so we need to close the
         // container at the same time we get pending state, otherwise this container could reconnect and resubmit with
         // a new clientId and a future container using stale pending state without the new clientId would resubmit them
-        const pendingState = this.getPendingLocalState();
+        this.disconnectInternal({ text: "closeAndGetPendingLocalState" }); // TODO https://dev.azure.com/fluidframework/internal/_workitems/edit/5127
+        const pendingState = await this.getPendingLocalStateCore({ notifyImminentClosure: true });
         this.close();
         return pendingState;
     }
-    getPendingLocalState() {
-        if (!this.offlineLoadEnabled) {
-            throw new container_utils_1.UsageError("Can't get pending local state unless offline load is enabled");
-        }
-        (0, common_utils_1.assert)(this.attachState === container_definitions_1.AttachState.Attached, 0x0d1 /* "Container should be attached before close" */);
-        (0, common_utils_1.assert)(this.resolvedUrl !== undefined && this.resolvedUrl.type === "fluid", 0x0d2 /* "resolved url should be valid Fluid url" */);
-        (0, common_utils_1.assert)(!!this.baseSnapshot, 0x5d4 /* no base snapshot */);
-        (0, common_utils_1.assert)(!!this.baseSnapshotBlobs, 0x5d5 /* no snapshot blobs */);
-        const pendingState = {
-            pendingRuntimeState: this.context.getPendingLocalState(),
-            baseSnapshot: this.baseSnapshot,
-            snapshotBlobs: this.baseSnapshotBlobs,
-            savedOps: this.savedOps,
-            url: this.resolvedUrl.url,
-            term: protocol_1.OnlyValidTermValue,
+    async getPendingLocalState() {
+        return this.getPendingLocalStateCore({ notifyImminentClosure: false });
+    }
+    async getPendingLocalStateCore(props) {
+        return telemetry_utils_1.PerformanceEvent.timedExecAsync(this.mc.logger, {
+            eventName: "getPendingLocalState",
+            notifyImminentClosure: props.notifyImminentClosure,
+            savedOpsSize: this.savedOps.length,
             clientId: this.clientId,
-        };
-        this.mc.logger.sendTelemetryEvent({ eventName: "GetPendingLocalState" });
-        return JSON.stringify(pendingState);
+        }, async () => {
+            if (!this.offlineLoadEnabled) {
+                throw new telemetry_utils_1.UsageError("Can't get pending local state unless offline load is enabled");
+            }
+            if (this.closed || this._disposed) {
+                throw new telemetry_utils_1.UsageError("Pending state cannot be retried if the container is closed or disposed");
+            }
+            (0, core_utils_1.assert)(this.attachState === container_definitions_1.AttachState.Attached, 0x0d1 /* "Container should be attached before close" */);
+            (0, core_utils_1.assert)(this.resolvedUrl !== undefined && this.resolvedUrl.type === "fluid", 0x0d2 /* "resolved url should be valid Fluid url" */);
+            (0, core_utils_1.assert)(!!this.baseSnapshot, 0x5d4 /* no base snapshot */);
+            (0, core_utils_1.assert)(!!this.baseSnapshotBlobs, 0x5d5 /* no snapshot blobs */);
+            const pendingRuntimeState = await this.runtime.getPendingLocalState(props);
+            const pendingState = {
+                pendingRuntimeState,
+                baseSnapshot: this.baseSnapshot,
+                snapshotBlobs: this.baseSnapshotBlobs,
+                savedOps: this.savedOps,
+                url: this.resolvedUrl.url,
+                term: protocol_1.OnlyValidTermValue,
+                // no need to save this if there is no pending runtime state
+                clientId: pendingRuntimeState !== undefined ? this.clientId : undefined,
+            };
+            return JSON.stringify(pendingState);
+        });
     }
     get attachState() {
         return this._attachState;
     }
     serialize() {
-        (0, common_utils_1.assert)(this.attachState === container_definitions_1.AttachState.Detached, 0x0d3 /* "Should only be called in detached container" */);
-        const appSummary = this.context.createSummary();
+        (0, core_utils_1.assert)(this.attachState === container_definitions_1.AttachState.Detached, 0x0d3 /* "Should only be called in detached container" */);
+        const appSummary = this.runtime.createSummary();
         const protocolSummary = this.captureProtocolSummary();
-        const combinedSummary = (0, driver_utils_1.combineAppAndProtocolSummary)(appSummary, protocolSummary);
+        const combinedSummary = (0, utils_1.combineAppAndProtocolSummary)(appSummary, protocolSummary);
         if (this.detachedBlobStorage && this.detachedBlobStorage.size > 0) {
             combinedSummary.tree[".hasAttachmentBlobs"] = {
                 type: protocol_definitions_1.SummaryType.Blob,
@@ -660,32 +683,32 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         }
         return JSON.stringify(combinedSummary);
     }
-    async attach(request) {
+    async attach(request, attachProps) {
         await telemetry_utils_1.PerformanceEvent.timedExecAsync(this.mc.logger, { eventName: "Attach" }, async () => {
-            var _a;
             if (this._lifecycleState !== "loaded") {
                 // pre-0.58 error message: containerNotValidForAttach
-                throw new container_utils_1.UsageError(`The Container is not in a valid state for attach [${this._lifecycleState}]`);
+                throw new telemetry_utils_1.UsageError(`The Container is not in a valid state for attach [${this._lifecycleState}]`);
             }
             // If container is already attached or attach is in progress, throw an error.
-            (0, common_utils_1.assert)(this._attachState === container_definitions_1.AttachState.Detached && !this.attachStarted, 0x205 /* "attach() called more than once" */);
+            (0, core_utils_1.assert)(this._attachState === container_definitions_1.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.detachedBlobStorage !== undefined && this.detachedBlobStorage.size > 0;
             try {
-                (0, common_utils_1.assert)(this.deltaManager.inbound.length === 0, 0x0d6 /* "Inbound queue should be empty when attaching" */);
+                (0, core_utils_1.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 = (0, driver_utils_1.combineAppAndProtocolSummary)(appSummary, protocolSummary);
+                    summary = (0, utils_1.combineAppAndProtocolSummary)(appSummary, protocolSummary);
                     // Set the state as attaching as we are starting the process of attaching container.
                     // This should be fired after taking the summary because it is the place where we are
                     // starting to attach the container to storage.
                     // Also, this should only be fired in detached container.
                     this._attachState = container_definitions_1.AttachState.Attaching;
+                    this.runtime.setAttachState(container_definitions_1.AttachState.Attaching);
                     this.emit("attaching");
                     if (this.offlineLoadEnabled) {
                         const snapshot = (0, utils_1.getSnapshotTreeFromSerializedContainer)(summary);
@@ -697,16 +720,16 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                 // Actually go and create the resolved document
                 if (this.service === undefined) {
                     const createNewResolvedUrl = await this.urlResolver.resolve(request);
-                    (0, common_utils_1.assert)(this.client.details.type !== summarizerClientType &&
+                    (0, core_utils_1.assert)(this.client.details.type !== summarizerClientType &&
                         createNewResolvedUrl !== undefined, 0x2c4 /* "client should not be summarizer before container is created" */);
                     this.service = await (0, driver_utils_1.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);
                 if (hasAttachmentBlobs) {
                     // upload blobs to storage
-                    (0, common_utils_1.assert)(!!this.detachedBlobStorage, 0x24e /* "assertion for type narrowing" */);
+                    (0, core_utils_1.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();
@@ -722,10 +745,11 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                         }
                     }
                     // take summary and upload
-                    const appSummary = this.context.createSummary(redirectTable);
+                    const appSummary = this.runtime.createSummary(redirectTable);
                     const protocolSummary = this.captureProtocolSummary();
-                    summary = (0, driver_utils_1.combineAppAndProtocolSummary)(appSummary, protocolSummary);
+                    summary = (0, utils_1.combineAppAndProtocolSummary)(appSummary, protocolSummary);
                     this._attachState = container_definitions_1.AttachState.Attaching;
+                    this.runtime.setAttachState(container_definitions_1.AttachState.Attaching);
                     this.emit("attaching");
                     if (this.offlineLoadEnabled) {
                         const snapshot = (0, utils_1.getSnapshotTreeFromSerializedContainer)(summary);
@@ -740,32 +764,33 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                     });
                 }
                 this._attachState = container_definitions_1.AttachState.Attached;
+                this.runtime.setAttachState(container_definitions_1.AttachState.Attached);
                 this.emit("attached");
                 if (!this.closed) {
-                    this.resumeInternal({
+                    this.handleDeltaConnectionArg({
                         fetchOpsFromStorage: false,
-                        reason: "createDetached",
-                    });
+                        reason: { text: "createDetached" },
+                    }, attachProps?.deltaConnection);
                 }
             }
             catch (error) {
                 // add resolved URL on error object so that host has the ability to find this document and delete it
                 const newError = (0, telemetry_utils_1.normalizeError)(error);
-                newError.addTelemetryProperties({ resolvedUrl: (_a = this.resolvedUrl) === null || _a === void 0 ? void 0 : _a.url });
+                newError.addTelemetryProperties({ resolvedUrl: this.resolvedUrl?.url });
                 this.close(newError);
                 throw newError;
             }
         }, { start: true, end: true, cancel: "generic" });
     }
     async request(path) {
-        return telemetry_utils_1.PerformanceEvent.timedExecAsync(this.mc.logger, { eventName: "Request" }, async () => this.context.request(path), { end: true, cancel: "error" });
+        return telemetry_utils_1.PerformanceEvent.timedExecAsync(this.mc.logger, { eventName: "Request" }, async () => this.runtime.request(path), { end: true, cancel: "error" });
     }
-    setAutoReconnectInternal(mode) {
+    setAutoReconnectInternal(mode, reason) {
         const currentMode = this._deltaManager.connectionManager.reconnectMode;
         if (currentMode === mode) {
             return;
         }
-        const now = common_utils_1.performance.now();
+        const now = client_utils_1.performance.now();
         const duration = now - this.setAutoReconnectTime;
         this.setAutoReconnectTime = now;
         this.mc.logger.sendTelemetryEvent({
@@ -774,47 +799,50 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             connectionState: connectionState_1.ConnectionState[this.connectionState],
             duration,
         });
-        this._deltaManager.connectionManager.setAutoReconnect(mode);
+        this._deltaManager.connectionManager.setAutoReconnect(mode, reason);
     }
     connect() {
         if (this.closed) {
-            throw new container_utils_1.UsageError(`The Container is closed and cannot be connected`);
+            throw new telemetry_utils_1.UsageError(`The Container is closed and cannot be connected`);
         }
         else if (this._attachState !== container_definitions_1.AttachState.Attached) {
-            throw new container_utils_1.UsageError(`The Container is not attached and cannot be connected`);
+            throw new telemetry_utils_1.UsageError(`The Container is not attached and cannot be connected`);
         }
         else if (!this.connected) {
             // Note: no need to fetch ops as we do it preemptively as part of DeltaManager.attachOpHandler().
             // If there is gap, we will learn about it once connected, but the gap should be small (if any),
             // assuming that connect() is called quickly after initial container boot.
-            this.connectInternal({ reason: "DocumentConnect", fetchOpsFromStorage: false });
+            this.connectInternal({
+                reason: { text: "DocumentConnect" },
+                fetchOpsFromStorage: false,
+            });
         }
     }
     connectInternal(args) {
-        (0, common_utils_1.assert)(!this.closed, 0x2c5 /* "Attempting to connect() a closed Container" */);
-        (0, common_utils_1.assert)(this._attachState === container_definitions_1.AttachState.Attached, 0x2c6 /* "Attempting to connect() a container that is not attached" */);
+        (0, core_utils_1.assert)(!this.closed, 0x2c5 /* "Attempting to connect() a closed Container" */);
+        (0, core_utils_1.assert)(this._attachState === container_definitions_1.AttachState.Attached, 0x2c6 /* "Attempting to connect() a container that is not attached" */);
         // Resume processing ops and connect to delta stream
         this.resumeInternal(args);
         // Set Auto Reconnect Mode
         const mode = contracts_1.ReconnectMode.Enabled;
-        this.setAutoReconnectInternal(mode);
+        this.setAutoReconnectInternal(mode, args.reason);
     }
     disconnect() {
         if (this.closed) {
-            throw new container_utils_1.UsageError(`The Container is closed and cannot be disconnected`);
+            throw new telemetry_utils_1.UsageError(`The Container is closed and cannot be disconnected`);
         }
         else {
-            this.disconnectInternal();
+            this.disconnectInternal({ text: "DocumentDisconnect" });
         }
     }
-    disconnectInternal() {
-        (0, common_utils_1.assert)(!this.closed, 0x2c7 /* "Attempting to disconnect() a closed Container" */);
+    disconnectInternal(reason) {
+        (0, core_utils_1.assert)(!this.closed, 0x2c7 /* "Attempting to disconnect() a closed Container" */);
         // Set Auto Reconnect Mode
         const mode = contracts_1.ReconnectMode.Disabled;
-        this.setAutoReconnectInternal(mode);
+        this.setAutoReconnectInternal(mode, reason);
     }
     resumeInternal(args) {
-        (0, common_utils_1.assert)(!this.closed, 0x0d9 /* "Attempting to connect() a closed DeltaManager" */);
+        (0, core_utils_1.assert)(!this.closed, 0x0d9 /* "Attempting to connect() a closed DeltaManager" */);
         // Resume processing ops
         if (this.inboundQueuePausedFromInit) {
             this.inboundQueuePausedFromInit = false;
@@ -824,13 +852,6 @@ class Container extends telemetry_utils_1.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, (0, contracts_1.getPackageName)((_a = this._context) === null || _a === void 0 ? void 0 : _a.codeDetails));
-    }
     async proposeCodeDetails(codeDetails) {
         if (!(0, container_definitions_1.isFluidCodeDetails)(codeDetails)) {
             throw new Error("Provided codeDetails are not IFluidCodeDetails");
@@ -852,15 +873,46 @@ class Container extends telemetry_utils_1.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;
         }
         // pre-0.58 error message: existingContextDoesNotSatisfyIncomingProposal
-        const error = new container_utils_1.GenericError("Existing context does not satisfy incoming proposal");
+        const error = new telemetry_utils_1.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) {
+        // 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 = this._loadedModule?.module.fluidExport;
+        if (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(this._loadedModule?.details, constraintCodeDetails);
+            if (satisfies === false) {
+                return false;
+            }
+        }
+        return true;
+    }
     async getVersion(version) {
         const versions = await this.storageAdapter.getVersions(version, 1);
         return versions[0];
@@ -877,8 +929,8 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
      *
      * @param specifiedVersion - Version SHA to load snapshot. If not specified, will fetch the latest snapshot.
      */
-    async load(specifiedVersion, loadMode, resolvedUrl, pendingLocalState) {
-        var _a;
+    async load(specifiedVersion, loadMode, resolvedUrl, pendingLocalState, loadToSequenceNumber) {
+        const timings = { phase1: client_utils_1.performance.now() };
         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.
@@ -890,7 +942,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         // A) creation flow breaks (as one of the clients "sees" file as existing, and hits #2 above)
         // B) Once file is created, transition from view-only connection to write does not work - some bugs to be fixed.
         const connectionArgs = {
-            reason: "DocumentOpen",
+            reason: { text: "DocumentOpen" },
             mode: "write",
             fetchOpsFromStorage: false,
         };
@@ -909,6 +961,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             });
         }
         this._attachState = container_definitions_1.AttachState.Attached;
+        timings.phase2 = client_utils_1.performance.now();
         // Fetch specified snapshot.
         const { snapshot, versionId } = pendingLocalState === undefined
             ? await this.fetchSnapshotTree(specifiedVersion)
@@ -918,18 +971,60 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             this.baseSnapshotBlobs = pendingLocalState.snapshotBlobs;
         }
         else {
-            (0, common_utils_1.assert)(snapshot !== undefined, 0x237 /* "Snapshot should exist" */);
+            (0, core_utils_1.assert)(snapshot !== undefined, 0x237 /* "Snapshot should exist" */);
             if (this.offlineLoadEnabled) {
                 this.baseSnapshot = snapshot;
                 // Save contents of snapshot now, otherwise closeAndGetPendingLocalState() must be async
-                this.baseSnapshotBlobs = await (0, containerStorageAdapter_1.getBlobContentsFromTree)(snapshot, this.storage);
+                this.baseSnapshotBlobs = await (0, containerStorageAdapter_1.getBlobContentsFromTree)(snapshot, this.storageAdapter);
             }
         }
         const attributes = await this.getDocumentAttributes(this.storageAdapter, snapshot);
         // If we saved ops, we will replay them and don't need DeltaManager to fetch them
-        const sequenceNumber = (_a = pendingLocalState === null || pendingLocalState === void 0 ? void 0 : pendingLocalState.savedOps[pendingLocalState.savedOps.length - 1]) === null || _a === void 0 ? void 0 : _a.sequenceNumber;
-        const dmAttributes = sequenceNumber !== undefined ? Object.assign(Object.assign({}, attributes), { sequenceNumber }) : attributes;
+        const sequenceNumber = pendingLocalState?.savedOps[pendingLocalState.savedOps.length - 1]?.sequenceNumber;
+        const dmAttributes = sequenceNumber !== undefined ? { ...attributes, sequenceNumber } : attributes;
         let opsBeforeReturnP;
+        if (loadMode.pauseAfterLoad === true) {
+            // If we are trying to pause at a specific sequence number, ensure the latest snapshot is not newer than the desired sequence number.
+            if (loadMode.opsBeforeReturn === "sequenceNumber") {
+                (0, core_utils_1.assert)(loadToSequenceNumber !== undefined, 0x727 /* sequenceNumber should be defined */);
+                // Note: It is possible that we think the latest snapshot is newer than the specified sequence number
+                // due to saved ops that may be replayed after the snapshot.
+                // https://dev.azure.com/fluidframework/internal/_workitems/edit/5055
+                if (dmAttributes.sequenceNumber > loadToSequenceNumber) {
+                    throw new Error("Cannot satisfy request to pause the container at the specified sequence number. Most recent snapshot is newer than the specified sequence number.");
+                }
+            }
+            // Force readonly mode - this will ensure we don't receive an error for the lack of join op
+            this.forceReadonly(true);
+            // We need to setup a listener to stop op processing once we reach the desired sequence number (if specified).
+            const opHandler = () => {
+                if (loadToSequenceNumber === undefined) {
+                    // If there is no specified sequence number, pause after the inbound queue is empty.
+                    if (this.deltaManager.inbound.length !== 0) {
+                        return;
+                    }
+                }
+                else {
+                    // If there is a specified sequence number, keep processing until we reach it.
+                    if (this.deltaManager.lastSequenceNumber < loadToSequenceNumber) {
+                        return;
+                    }
+                }
+                // Pause op processing once we have processed the desired number of ops.
+                void this.deltaManager.inbound.pause();
+                void this.deltaManager.outbound.pause();
+                this.off("op", opHandler);
+            };
+            if ((loadToSequenceNumber === undefined && this.deltaManager.inbound.length === 0) ||
+                this.deltaManager.lastSequenceNumber === loadToSequenceNumber) {
+                // If we have already reached the desired sequence number, call opHandler() to pause immediately.
+                opHandler();
+            }
+            else {
+                // If we have not yet reached the desired sequence number, setup a listener to pause once we reach it.
+                this.on("op", opHandler);
+            }
+        }
         // Attach op handlers to finish initialization and be able to start processing ops
         // Kick off any ops fetching if required.
         switch (loadMode.opsBeforeReturn) {
@@ -938,32 +1033,30 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                 // eslint-disable-next-line @typescript-eslint/no-floating-promises
                 this.attachDeltaManagerOpHandler(dmAttributes, loadMode.deltaConnection !== "none" ? "all" : "none");
                 break;
+            case "sequenceNumber":
             case "cached":
-                opsBeforeReturnP = this.attachDeltaManagerOpHandler(dmAttributes, "cached");
-                break;
             case "all":
-                opsBeforeReturnP = this.attachDeltaManagerOpHandler(dmAttributes, "all");
+                opsBeforeReturnP = this.attachDeltaManagerOpHandler(dmAttributes, loadMode.opsBeforeReturn);
                 break;
             default:
-                (0, common_utils_1.unreachableCase)(loadMode.opsBeforeReturn);
+                (0, core_utils_1.unreachableCase)(loadMode.opsBeforeReturn);
         }
         // ...load in the existing quorum
         // Initialize the protocol handler
         await this.initializeProtocolStateFromSnapshot(attributes, this.storageAdapter, snapshot);
+        timings.phase3 = client_utils_1.performance.now();
         const codeDetails = this.getCodeDetailsFromQuorum();
-        await this.instantiateContext(true, // existing
-        codeDetails, snapshot, pendingLocalState === null || pendingLocalState === void 0 ? void 0 : pendingLocalState.pendingRuntimeState);
+        await this.instantiateRuntime(codeDetails, snapshot, 
+        // give runtime a dummy value so it knows we're loading from a stash blob
+        pendingLocalState ? pendingLocalState?.pendingRuntimeState ?? {} : undefined);
         // replay saved ops
         if (pendingLocalState) {
             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 this.runtime.notifyOpReplay?.(message);
             }
             pendingLocalState.savedOps = [];
-            // now set clientId to stashed clientId so live ops are correctly processed as local
-            (0, common_utils_1.assert)(this.clientId === undefined, 0x5d6 /* Unexpected clientId when setting stashed clientId */);
-            this._clientId = pendingLocalState === null || pendingLocalState === void 0 ? void 0 : pendingLocalState.clientId;
         }
         // We might have hit some failure that did not manifest itself in exception in this flow,
         // do not start op processing in such case - static version of Container.load() will handle it correctly.
@@ -975,24 +1068,20 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                 // eslint-disable-next-line @typescript-eslint/no-floating-promises
                 this._deltaManager.inbound.pause();
             }
-            switch (loadMode.deltaConnection) {
-                case undefined:
-                    if (pendingLocalState) {
-                        // connect to delta stream now since we did not before
-                        this.connectToDeltaStream(connectionArgs);
+            this.handleDeltaConnectionArg(connectionArgs, loadMode.deltaConnection, pendingLocalState !== undefined);
+        }
+        // If we have not yet reached `loadToSequenceNumber`, we will wait for ops to arrive until we reach it
+        if (loadToSequenceNumber !== undefined &&
+            this.deltaManager.lastSequenceNumber < loadToSequenceNumber) {
+            await new Promise((resolve, reject) => {
+                const opHandler = (message) => {
+                    if (message.sequenceNumber >= loadToSequenceNumber) {
+                        resolve();
+                        this.off("op", opHandler);
                     }
-                // intentional fallthrough
-                case "delayed":
-                    (0, common_utils_1.assert)(this.inboundQueuePausedFromInit, 0x346 /* inboundQueuePausedFromInit should be true */);
-                    this.inboundQueuePausedFromInit = false;
-                    this._deltaManager.inbound.resume();
-                    this._deltaManager.inboundSignal.resume();
-                    break;
-                case "none":
-                    break;
-                default:
-                    (0, common_utils_1.unreachableCase)(loadMode.deltaConnection);
-            }
+                };
+                this.on("op", opHandler);
+            });
         }
         // Safety net: static version of Container.load() should have learned about it through "closed" handler.
         // But if that did not happen for some reason, fail load for sure.
@@ -1004,6 +1093,11 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         }
         // Internal context is fully loaded at this point
         this.setLoaded();
+        timings.end = client_utils_1.performance.now();
+        this.subLogger.sendTelemetryEvent({
+            eventName: "LoadStagesTimings",
+            details: JSON.stringify(timings),
+        }, undefined, core_interfaces_1.LogLevel.verbose);
         return {
             sequenceNumber: attributes.sequenceNumber,
             version: versionId,
@@ -1011,7 +1105,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             dmLastKnownSeqNumber: this._deltaManager.lastKnownSeqNumber,
         };
     }
-    async createDetached(source) {
+    async createDetached(codeDetails) {
         const attributes = {
             sequenceNumber: detachedContainerRefSeqNumber,
             term: protocol_1.OnlyValidTermValue,
@@ -1019,19 +1113,18 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         };
         await this.attachDeltaManagerOpHandler(attributes);
         // Need to just seed the source data in the code quorum. Quorum itself is empty
-        const qValues = (0, quorum_1.initQuorumValuesFromCodeDetails)(source);
+        const qValues = (0, quorum_1.initQuorumValuesFromCodeDetails)(codeDetails);
         this.initializeProtocolState(attributes, {
             members: [],
             proposals: [],
             values: qValues,
         });
-        // The load context - given we seeded the quorum - will be great
-        await this.instantiateContextDetached(false);
+        await this.instantiateRuntime(codeDetails, undefined);
         this.setLoaded();
     }
     async rehydrateDetachedFromSnapshot(detachedContainerSnapshot) {
         if (detachedContainerSnapshot.tree[".hasAttachmentBlobs"] !== undefined) {
-            (0, common_utils_1.assert)(!!this.detachedBlobStorage && this.detachedBlobStorage.size > 0, 0x250 /* "serialized container with attachment blobs must be rehydrated with detached blob storage" */);
+            (0, core_utils_1.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 = (0, utils_1.getSnapshotTreeFromSerializedContainer)(detachedContainerSnapshot);
@@ -1041,14 +1134,13 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         // Initialize the protocol handler
         const baseTree = (0, utils_1.getProtocolSnapshotTree)(snapshotTree);
         const qValues = await (0, driver_utils_1.readAndParse)(this.storageAdapter, baseTree.blobs.quorumValues);
-        const codeDetails = (0, quorum_1.getCodeDetailsFromQuorumValues)(qValues);
         this.initializeProtocolState(attributes, {
             members: [],
             proposals: [],
-            values: codeDetails !== undefined ? (0, quorum_1.initQuorumValuesFromCodeDetails)(codeDetails) : [],
+            values: qValues,
         });
-        await this.instantiateContextDetached(true, // existing
-        snapshotTree);
+        const codeDetails = this.getCodeDetailsFromQuorum();
+        await this.instantiateRuntime(codeDetails, snapshotTree);
         this.setLoaded();
     }
     async getDocumentAttributes(storage, tree) {
@@ -1085,7 +1177,10 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
     }
     initializeProtocolState(attributes, quorumSnapshot) {
         const protocol = this.protocolHandlerBuilder(attributes, quorumSnapshot, (key, value) => this.submitMessage(protocol_definitions_1.MessageType.Propose, JSON.stringify({ key, value })));
-        const protocolLogger = telemetry_utils_1.ChildLogger.create(this.subLogger, "ProtocolHandler");
+        const protocolLogger = (0, telemetry_utils_1.createChildLogger)({
+            logger: this.subLogger,
+            namespace: "ProtocolHandler",
+        });
         protocol.quorum.on("error", (error) => {
             protocolLogger.sendErrorEvent(error);
         });
@@ -1147,8 +1242,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         return pkg;
     }
     get client() {
-        var _a;
-        const client = ((_a = this.options) === null || _a === void 0 ? void 0 : _a.client) !== undefined
+        const client = this.options?.client !== undefined
             ? this.options.client
             : {
                 details: {
@@ -1179,14 +1273,14 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
     }
     createDeltaManager() {
         const serviceProvider = () => this.service;
-        const deltaManager = new deltaManager_1.DeltaManager(serviceProvider, telemetry_utils_1.ChildLogger.create(this.subLogger, "DeltaManager"), () => this.activeConnection(), (props) => new connectionManager_1.ConnectionManager(serviceProvider, () => this.isDirty, this.client, this._canReconnect, telemetry_utils_1.ChildLogger.create(this.subLogger, "ConnectionManager"), props));
+        const deltaManager = new deltaManager_1.DeltaManager(serviceProvider, (0, telemetry_utils_1.createChildLogger)({ logger: this.subLogger, namespace: "DeltaManager" }), () => this.activeConnection(), (props) => new connectionManager_1.ConnectionManager(serviceProvider, () => this.isDirty, this.client, this._canReconnect, (0, telemetry_utils_1.createChildLogger)({ logger: this.subLogger, namespace: "ConnectionManager" }), props));
         // Disable inbound queues as Container is not ready to accept any ops until we are fully loaded!
         // eslint-disable-next-line @typescript-eslint/no-floating-promises
         deltaManager.inbound.pause();
         // eslint-disable-next-line @typescript-eslint/no-floating-promises
         deltaManager.inboundSignal.pause();
         deltaManager.on("connect", (details, _opsBehind) => {
-            (0, common_utils_1.assert)(this.connectionMode === details.mode, 0x4b7 /* mismatch */);
+            (0, core_utils_1.assert)(this.connectionMode === details.mode, 0x4b7 /* mismatch */);
             this.connectionStateHandler.receivedConnectEvent(details);
         });
         deltaManager.on("establishingConnection", (reason) => {
@@ -1195,11 +1289,10 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         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();
+        deltaManager.on("disconnect", (reason) => {
+            this.noopHeuristic?.notifyDisconnect();
             if (!this.closed) {
-                this.connectionStateHandler.receivedDisconnectEvent(reason, error);
+                this.connectionStateHandler.receivedDisconnectEvent(reason);
             }
         });
         deltaManager.on("throttled", (warning) => {
@@ -1231,10 +1324,9 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             },
         }, prefetchType);
     }
-    logConnectionStateChangeTelemetry(value, oldState, reason, error) {
-        var _a;
+    logConnectionStateChangeTelemetry(value, oldState, reason) {
         // Log actual event
-        const time = common_utils_1.performance.now();
+        const time = client_utils_1.performance.now();
         this.connectionTransitionTimes[value] = time;
         const duration = time - this.connectionTransitionTimes[oldState];
         let durationFromDisconnected;
@@ -1249,30 +1341,44 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             if (value === connectionState_1.ConnectionState.Connected) {
                 durationFromDisconnected =
                     time - this.connectionTransitionTimes[connectionState_1.ConnectionState.Disconnected];
-                durationFromDisconnected = telemetry_utils_1.TelemetryLogger.formatTick(durationFromDisconnected);
+                durationFromDisconnected = (0, telemetry_utils_1.formatTick)(durationFromDisconnected);
             }
             else if (value === connectionState_1.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;
                 }
             }
             connectionInitiationReason = this.firstConnection ? "InitialConnect" : "AutoReconnect";
         }
-        this.mc.logger.sendPerformanceEvent(Object.assign({ eventName: `ConnectionStateChange_${connectionState_1.ConnectionState[value]}`, from: connectionState_1.ConnectionState[oldState], duration,
+        this.mc.logger.sendPerformanceEvent({
+            eventName: `ConnectionStateChange_${connectionState_1.ConnectionState[value]}`,
+            from: connectionState_1.ConnectionState[oldState],
+            duration,
             durationFromDisconnected,
-            reason,
-            connectionInitiationReason, pendingClientId: this.connectionStateHandler.pendingClientId, clientId: this.clientId, autoReconnect,
-            opsBehind, online: driver_utils_1.OnlineStatus[(0, driver_utils_1.isOnline)()], lastVisible: this.lastVisible !== undefined
-                ? common_utils_1.performance.now() - this.lastVisible
-                : undefined, checkpointSequenceNumber, quorumSize: (_a = this._protocolHandler) === null || _a === void 0 ? void 0 : _a.quorum.getMembers().size }, this._deltaManager.connectionProps), error);
+            reason: reason?.text,
+            connectionInitiationReason,
+            pendingClientId: this.connectionStateHandler.pendingClientId,
+            clientId: this.clientId,
+            autoReconnect,
+            opsBehind,
+            online: driver_utils_1.OnlineStatus[(0, driver_utils_1.isOnline)()],
+            lastVisible: this.lastVisible !== undefined
+                ? client_utils_1.performance.now() - this.lastVisible
+                : undefined,
+            checkpointSequenceNumber,
+            quorumSize: this._protocolHandler?.quorum.getMembers().size,
+            isDirty: this.isDirty,
+            ...this._deltaManager.connectionProps,
+        }, reason?.error);
         if (value === connectionState_1.ConnectionState.Connected) {
             this.firstConnection = false;
         }
     }
     propagateConnectionState(initialTransition, disconnectedReason) {
-        var _a;
         // When container loaded, we want to propagate initial connection state.
         // After that, we communicate only transitions to Connected & Disconnected states, skipping all other states.
         // This can be changed in the future, for example we likely should add "CatchingUp" event on Container.
@@ -1282,22 +1388,10 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             return;
         }
         const state = this.connectionState === connectionState_1.ConnectionState.Connected;
-        const logOpsOnReconnect = this.connectionState === connectionState_1.ConnectionState.Connected &&
-            !this.firstConnection &&
-            this.connectionMode === "write";
-        if (logOpsOnReconnect) {
-            this.messageCountAfterDisconnection = 0;
-        }
         // Both protocol and context should not be undefined if we got so far.
-        this.setContextConnectedState(state, (_a = this.readOnlyInfo.readonly) !== null && _a !== void 0 ? _a : false);
+        this.setContextConnectedState(state, this.readOnlyInfo.readonly ?? false);
         this.protocolHandler.setConnectionState(state, this.clientId);
-        (0, telemetry_utils_1.raiseConnectedEvent)(this.mc.logger, this, state, this.clientId, disconnectedReason);
-        if (logOpsOnReconnect) {
-            this.mc.logger.sendTelemetryEvent({
-                eventName: "OpsSentOnReconnect",
-                count: this.messageCountAfterDisconnection,
-            });
-        }
+        (0, telemetry_utils_1.raiseConnectedEvent)(this.mc.logger, this, state, this.clientId, disconnectedReason?.text);
     }
     // back-compat: ADO #1385: Remove in the future, summary op should come through submitSummaryMessage()
     submitContainerMessage(type, contents, batch, metadata) {
@@ -1307,7 +1401,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             case protocol_definitions_1.MessageType.Summarize:
                 return this.submitSummaryMessage(contents);
             default: {
-                const newError = new container_utils_1.GenericError("invalidContainerSubmitOpType", undefined /* error */, { messageType: type });
+                const newError = new telemetry_utils_1.GenericError("invalidContainerSubmitOpType", undefined /* error */, { messageType: type });
                 this.close(newError);
                 return -1;
             }
@@ -1335,13 +1429,11 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         return this.submitMessage(protocol_definitions_1.MessageType.Summarize, JSON.stringify(summary), false /* batch */, undefined /* metadata */, undefined /* compression */, referenceSequenceNumber);
     }
     submitMessage(type, contents, batch, metadata, compression, referenceSequenceNumber) {
-        var _a;
         if (this.connectionState !== connectionState_1.ConnectionState.Connected) {
             this.mc.logger.sendErrorEvent({ eventName: "SubmitMessageWithNoConnection", type });
             return -1;
         }
-        this.messageCountAfterDisconnection += 1;
-        (_a = this.collabWindowTracker) === null || _a === void 0 ? void 0 : _a.stopSequenceNumberUpdate();
+        this.noopHeuristic?.notifyMessageSent();
         return this._deltaManager.submit(type, contents, batch, metadata, compression, referenceSequenceNumber);
     }
     processRemoteMessage(message) {
@@ -1352,21 +1444,31 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         // 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.
-                (0, common_utils_1.assert)(this.serviceConfiguration !== undefined, 0x2e4 /* "there should be service config for active connection" */);
-                this.collabWindowTracker = new collabWindowTracker_1.CollabWindowTracker((type) => {
-                    (0, common_utils_1.assert)(this.activeConnection(), 0x241 /* "disconnect should result in stopSequenceNumberUpdate() call" */);
-                    this.submitMessage(type);
-                }, this.serviceConfiguration.noopTimeFrequency, this.serviceConfiguration.noopCountFrequency);
+                (0, core_utils_1.assert)(serviceConfiguration !== undefined, 0x2e4 /* "there should be service config for active connection" */);
+                this.noopHeuristic = new noopHeuristic_1.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.
+                    (0, core_utils_1.assert)(this.activeConnection(), 0x241 /* "Trying to send noop without active connection" */);
+                    this.submitMessage(protocol_definitions_1.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(driver_utils_1.MessageType2.Accept);
             }
-            this.collabWindowTracker.scheduleSequenceNumberUpdate(message, result.immediateNoOp === true);
         }
         this.emit("op", message);
     }
@@ -1375,12 +1477,12 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
     }
     processSignal(message) {
         // No clientId indicates a system signal message.
-        if (message.clientId === null) {
+        if ((0, protocol_1.protocolHandlerShouldProcessSignal)(message)) {
             this.protocolHandler.processSignal(message);
         }
         else {
             const local = this.clientId === message.clientId;
-            this.context.processSignal(message, local);
+            this.runtime.processSignal(message, local);
         }
     }
     /**
@@ -1389,8 +1491,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
      * @returns The snapshot requested, or the latest snapshot if no version was specified, plus version ID
      */
     async fetchSnapshotTree(specifiedVersion) {
-        var _a;
-        const version = await this.getVersion(specifiedVersion !== null && specifiedVersion !== void 0 ? specifiedVersion : null);
+        const version = await this.getVersion(specifiedVersion ?? null);
         if (version === undefined && specifiedVersion !== undefined) {
             // We should have a defined version to load from if specified version requested
             this.mc.logger.sendErrorEvent({
@@ -1399,35 +1500,38 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             });
         }
         this._loadedFromVersion = version;
-        const snapshot = (_a = (await this.storageAdapter.getSnapshotTree(version))) !== null && _a !== void 0 ? _a : undefined;
+        const snapshot = (await this.storageAdapter.getSnapshotTree(version)) ?? undefined;
         if (snapshot === undefined && version !== undefined) {
             this.mc.logger.sendErrorEvent({ eventName: "getSnapshotTreeFailed", id: version.id });
         }
-        return { snapshot, versionId: version === null || version === void 0 ? void 0 : version.id };
-    }
-    async instantiateContextDetached(existing, snapshot) {
-        const codeDetails = this.getCodeDetailsFromQuorum();
-        if (codeDetails === undefined) {
-            throw new Error("pkg should be provided in create flow!!");
-        }
-        await this.instantiateContext(existing, codeDetails, snapshot);
+        return { snapshot, versionId: version?.id };
     }
-    async instantiateContext(existing, codeDetails, snapshot, pendingLocalState) {
-        var _a;
-        (0, common_utils_1.assert)(((_a = this._context) === null || _a === void 0 ? void 0 : _a.disposed) !== false, 0x0dd /* "Existing context not disposed" */);
+    async instantiateRuntime(codeDetails, snapshot, pendingLocalState) {
+        (0, core_utils_1.assert)(this._runtime?.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 loader_1.RelativeLoader(this, maybeLoader.ILoader);
-        this._context = await containerContext_1.ContainerContext.createOrLoad(this, this.scope, this.codeLoader, codeDetails, snapshot, new deltaManagerProxy_1.DeltaManagerProxy(this._deltaManager), new quorum_1.QuorumProxy(this.protocolHandler.quorum), loader, (type, contents, batch, metadata) => this.submitContainerMessage(type, contents, batch, metadata), (summaryOp, 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 telemetry_utils_1.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: loadCodeResult.details ?? codeDetails,
+        };
+        const fluidExport = this._loadedModule.module.fluidExport;
+        const runtimeFactory = fluidExport?.IRuntimeFactory;
+        if (runtimeFactory === undefined) {
+            throw new Error(packageNotFactoryError);
         }
-        this._dirtyContainer = dirty;
-        this.emit(dirty ? dirtyContainerEvent : savedContainerEvent);
+        const getSpecifiedCodeDetails = () => (this.protocolHandler.quorum.get("code") ??
+            this.protocolHandler.quorum.get("code2"));
+        const existing = snapshot !== undefined;
+        const context = new containerContext_1.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, () => this.resolvedUrl?.id, () => this.clientId, () => this.attachState, () => this.connected, getSpecifiedCodeDetails, this._deltaManager.clientDetails, existing, this.subLogger, pendingLocalState);
+        this._runtime = await telemetry_utils_1.PerformanceEvent.timedExecAsync(this.subLogger, { eventName: "InstantiateRuntime" }, async () => runtimeFactory.instantiateRuntime(context, existing));
+        this._lifecycleEvents.emit("runtimeInstantiated");
+        this._loadedCodeDetails = codeDetails;
     }
     /**
      * Set the connected state of the ContainerContext
@@ -1436,18 +1540,36 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
      * @param readonly - Is the container in readonly mode?
      */
     setContextConnectedState(state, readonly) {
-        var _a;
-        if (((_a = this._context) === null || _a === void 0 ? void 0 : _a.disposed) === false) {
+        if (this._runtime?.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);
+        }
+    }
+    handleDeltaConnectionArg(connectionArgs, deltaConnectionArg, canConnect = true) {
+        switch (deltaConnectionArg) {
+            case undefined:
+                if (canConnect) {
+                    // connect to delta stream now since we did not before
+                    this.connectToDeltaStream(connectionArgs);
+                }
+            // intentional fallthrough
+            case "delayed":
+                (0, core_utils_1.assert)(this.inboundQueuePausedFromInit, 0x346 /* inboundQueuePausedFromInit should be true */);
+                this.inboundQueuePausedFromInit = false;
+                this._deltaManager.inbound.resume();
+                this._deltaManager.inboundSignal.resume();
+                break;
+            case "none":
+                break;
+            default:
+                (0, core_utils_1.unreachableCase)(deltaConnectionArg);
         }
     }
 }
 exports.Container = Container;
-Container.version = "^0.1.0";
 //# sourceMappingURL=container.js.map